gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.1594b263e

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

@@ -13,6 +13,75 @@ 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";
+import { getRequiredWorkflowToolsForAutoUnit } from "./workflow-mcp.js";
+/**
+ * Thrown when the model-policy gate rejects every candidate model for a unit
+ * dispatch (#4959 / #4681 / #4850).  The auto-loop catches this specifically
+ * to classify the unit as `blocked` rather than counting it as a retryable
+ * iteration error — pre-send policy denial is a configuration problem, not a
+ * transient runtime failure, so retrying just burns the consecutive-error
+ * budget toward a hard stop.
+ */
+export class ModelPolicyDispatchBlockedError extends Error {
+    unitType;
+    unitId;
+    reasons;
+    constructor(unitType, unitId, reasons) {
+        const summary = reasons.length === 0
+            ? "no candidate models"
+            : reasons
+                .slice(0, 4)
+                .map((r) => `${r.provider}/${r.modelId} (${r.reason})`)
+                .join("; ");
+        super(`Model policy denied dispatch for ${unitType}/${unitId} before prompt send. Rejected: ${summary}`);
+        this.name = "ModelPolicyDispatchBlockedError";
+        this.unitType = unitType;
+        this.unitId = unitId;
+        this.reasons = reasons;
+    }
+}
+// Baseline active-tool set per-`pi` instance, captured the first time
+// `selectAndApplyModel` runs against that instance during an auto session
+// and re-applied before each subsequent dispatch.  WeakMap so that test
+// fakes / disposed sessions are garbage-collected normally.  See
+// #4959 / #4681 cross-unit poisoning notes at the call site below.
+//
+// LIFECYCLE: the baseline is tied to a single auto session, NOT to the
+// lifetime of the `pi` instance (which can outlive many auto runs and have
+// the user mutate tools between them).  `clearToolBaseline` MUST be called
+// at auto start AND auto stop so that a second `/gsd auto` run on the same
+// `pi` does not silently restore a stale snapshot from the prior run and
+// undo any tool changes the user made between sessions.
+const TOOL_BASELINE = new WeakMap();
+/**
+ * Drop the captured tool baseline for `pi` so the next `selectAndApplyModel`
+ * call re-captures from the live active set.  Wired into `startAuto` and
+ * `stopAuto` in `auto.ts` to bound the baseline to a single auto session.
+ *
+ * Safe to call when no baseline is recorded (no-op).
+ */
+export function clearToolBaseline(pi) {
+    TOOL_BASELINE.delete(pi);
+}
+function restoreToolBaseline(pi) {
+    const key = pi;
+    const baseline = TOOL_BASELINE.get(key);
+    if (baseline === undefined) {
+        // First call: capture the canonical pre-dispatch tool set.  At auto-mode
+        // start the active set has not yet been narrowed for any provider.
+        // Guarded against test fakes that omit getActiveTools — record an empty
+        // baseline so subsequent calls don't keep re-probing.
+        const initial = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+        TOOL_BASELINE.set(key, [...initial]);
+        return;
+    }
+    // Restore baseline before the next unit reads getActiveTools / applies
+    // post-selection adjustToolSet.  Older fakes that omit setActiveTools are
+    // tolerated — the test asserts call order on real fakes.
+    if (typeof pi.setActiveTools === "function") {
+        pi.setActiveTools([...baseline]);
+    }
+}
 function reapplyThinkingLevel(pi, level) {
     if (!level)
         return;
@@ -86,6 +155,29 @@ autoModeStartThinkingLevel) {
         : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
     let routing = null;
     let appliedModel = null;
+    // ── Restore active-tool baseline before policy evaluation (#4959, #4681, #4850) ──
+    // Per-unit narrowing at the bottom of this function (line ~417) calls
+    // `pi.setActiveTools(finalToolNames)` and monotonically narrows the active
+    // set across units.  Without restoration, a previously-dispatched unit on a
+    // narrow-API provider (e.g. openai-completions) leaves the active set
+    // missing tools that the next unit's selected model fully supports, but
+    // `pi.getActiveTools()` snapshot-as-hard-gate (the old behaviour) blocked
+    // dispatch with "tool policy denied" anyway.
+    //
+    // The baseline is captured once per `pi` instance via a WeakMap and
+    // re-applied here so each unit starts from a clean slate.  Soft adaptation
+    // (adjustToolSet at the bottom of this function) still trims for the
+    // selected model.
+    //
+    // Auto-mode only (#4965): `guided-flow.ts:dispatchWorkflow` also calls
+    // `selectAndApplyModel` with `isAutoMode=false`. Guided-flow has its own
+    // narrow/restore via discuss-tool-scoping (guided-flow.ts:587-622) and no
+    // baseline-clear hook of its own, so an unconditional restore here would
+    // resurrect an auto-era baseline on guided-flow dispatches — silently
+    // overwriting any tool changes made interactively between auto sessions.
+    // The baseline is structurally an auto-mode concept; gate it accordingly.
+    if (isAutoMode)
+        restoreToolBaseline(pi);
     if (modelConfig) {
         const availableModels = ctx.modelRegistry.getAvailable();
         const modelPolicyTraceId = `model:${ctx.sessionManager.getSessionId()}:${Date.now()}`;
@@ -114,7 +206,16 @@ autoModeStartThinkingLevel) {
         const taskMetadataForPolicy = unitType === "execute-task"
             ? extractTaskMetadata(unitId, basePath)
             : undefined;
+        let policyDenyReasons = [];
         if (uokFlags.modelPolicy) {
+            // Use the workflow-spec required-tool subset for the unit type rather
+            // than the live `pi.getActiveTools()` snapshot (#4959).  The active set
+            // is poisoned by per-unit narrowing for narrow-API providers — using it
+            // as a hard gate promotes soft adaptation (adjustToolSet at line ~417)
+            // into a layering violation that throws before dispatch.  The smaller
+            // workflow-required subset reflects what the unit actually needs; soft
+            // adaptation post-selection still trims provider-incompatible tools.
+            const requiredTools = getRequiredWorkflowToolsForAutoUnit(unitType);
             const policy = applyModelPolicyFilter(availableModels, {
                 basePath,
                 traceId: modelPolicyTraceId,
@@ -123,12 +224,15 @@ autoModeStartThinkingLevel) {
                 taskMetadata: taskMetadataForPolicy,
                 currentProvider: ctx.model?.provider,
                 allowCrossProvider: routingConfig.cross_provider !== false,
-                requiredTools: pi.getActiveTools(),
+                requiredTools,
             });
             routingEligibleModels = policy.eligible;
             policyAllowedModelKeys = new Set(policy.eligible.map((m) => `${m.provider.toLowerCase()}/${m.id.toLowerCase()}`));
+            policyDenyReasons = policy.decisions
+                .filter((d) => !d.allowed)
+                .map((d) => ({ provider: d.provider, modelId: d.modelId, reason: d.reason }));
             if (routingEligibleModels.length === 0) {
-                throw new Error(`Model policy denied all candidate models for ${unitType}/${unitId}`);
+                throw new ModelPolicyDispatchBlockedError(unitType, unitId, policyDenyReasons);
             }
         }
         // Disable routing for flat-rate providers like GitHub Copilot (#3453).
@@ -169,7 +273,11 @@ autoModeStartThinkingLevel) {
             if (shouldClassify) {
                 let classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct, taskMetadataForPolicy);
                 const availableModelIds = routingEligibleModels.map(m => `${m.provider}/${m.id}`);
-                // Escalate tier on retry when escalate_on_failure is enabled (default: true)
+                // Escalate tier on retry when escalate_on_failure is enabled (default: true).
+                // #4973: Deterministic policy errors are short-circuited at the postUnit
+                // level (auto-post-unit.ts writes a placeholder and returns "continue"),
+                // so this code path only runs for legitimate model-quality retries where
+                // tier escalation is the right response.
                 if (retryContext?.isRetry &&
                     retryContext.previousTier &&
                     routingConfig.escalate_on_failure !== false) {
@@ -179,6 +287,18 @@ autoModeStartThinkingLevel) {
                         // Always notify on tier escalation — model changes should be visible (#3962)
                         ctx.ui.notify(`Tier escalation: ${retryContext.previousTier} → ${escalated} (retry after failure)`, "info");
                     }
+                    else {
+                        // #4973: Already at max tier — keep previousTier rather than letting
+                        // fresh classification silently downgrade the model back to a lower tier.
+                        // Without this, a light-start unit on retry 3 would revert to the light
+                        // model after escalating to heavy on retries 1 and 2.
+                        const tierOrder = { light: 0, standard: 1, heavy: 2 };
+                        const prevOrder = tierOrder[retryContext.previousTier] ?? 0;
+                        const freshOrder = tierOrder[classification.tier] ?? 0;
+                        if (prevOrder > freshOrder) {
+                            classification = { ...classification, tier: retryContext.previousTier, reason: "retained escalated tier from retry" };
+                        }
+                    }
                 }
                 // Load user capability overrides from preferences (D-17: deep-merged with built-in profiles)
                 const capabilityOverrides = loadCapabilityOverrides(prefs ?? {});
@@ -291,7 +411,7 @@ 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) {
@@ -335,7 +455,7 @@ autoModeStartThinkingLevel) {
             }
         }
         if (uokFlags.modelPolicy && policyAllowedModelKeys && !attemptedPolicyEligible) {
-            throw new Error(`Model policy denied dispatch for ${unitType}/${unitId} before prompt send`);
+            throw new ModelPolicyDispatchBlockedError(unitType, unitId, policyDenyReasons);
         }
     }
     else if (autoModeStartModel) {

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";
@@ -45,8 +45,34 @@ import { ensureCodebaseMapFresh } from "./codebase-generator.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { UokGateRunner } from "./uok/gate-runner.js";
 import { writeTurnGitTransaction } from "./uok/gitops.js";
+import { isClosedStatus } from "./status-guards.js";
+import { detectAbandonMilestone } from "./abandon-detect.js";
+import { isDeterministicPolicyError } from "./auto-tool-tracking.js";
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
+/** Keep failure toasts short while still showing concrete examples. */
+const MAX_NOTIFICATION_DETAILS = 3;
+const NOTIFICATION_BULLET = "•";
+function formatPreExecutionCheckDetail(check) {
+    const category = check.category?.trim() || "unknown category";
+    const target = check.target?.trim() || "unknown target";
+    const message = check.message.split(/\r?\n/, 1)[0]?.trim() || "No details provided";
+    return `  ${NOTIFICATION_BULLET} [${category}] ${target}: ${message}`;
+}
+const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
+const COMPLETE_MILESTONE_DB_SETTLE_POLL_MS = 100;
+async function waitForMilestoneDbClose(mid) {
+    const deadline = Date.now() + COMPLETE_MILESTONE_DB_SETTLE_MS;
+    while (Date.now() < deadline) {
+        if (!isDbAvailable())
+            return false;
+        const milestone = getMilestone(mid);
+        if (milestone && isClosedStatus(milestone.status))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, COMPLETE_MILESTONE_DB_SETTLE_POLL_MS));
+    }
+    return false;
+}
 /** Enqueue a sidecar item (hook, triage, or quick-task) for the main loop to
  *  drain via runUnit. Logs the enqueue event and notifies the UI. */
 function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
@@ -72,7 +98,7 @@ const LIFECYCLE_ONLY_UNITS = new Set([
 ]);
 import { describeNextUnit, } from "./auto-dashboard.js";
 import { existsSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
 import { autoCommitCurrentBranch } from "./worktree.js";
 /**
@@ -184,6 +210,13 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
     }
     return rogues;
 }
+/**
+ * Maximum number of times to retry a unit whose expected artifact is missing
+ * after execution. Matches the bounded pattern used by runPostUnitVerification
+ * in auto-verification.ts. Exceeding this limit pauses auto-mode instead of
+ * looping indefinitely (#2007).
+ */
+const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
 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") {
@@ -457,6 +490,36 @@ export async function postUnitPreVerification(pctx, opts) {
         // Rewrite-docs completion
         if (s.currentUnit.type === "rewrite-docs") {
             await runSafely("postUnit", "rewrite-docs-resolve", async () => {
+                // Detect abandon/descope overrides BEFORE resolving them (#3490).
+                // If an override is about abandoning the milestone, park it so the
+                // state engine skips it. Without this, rewrite-docs only edits
+                // markdown but the DB still has the milestone as active.
+                try {
+                    const { loadActiveOverrides } = await import("./files.js");
+                    const overrides = await loadActiveOverrides(s.basePath);
+                    const decision = detectAbandonMilestone(overrides, s.currentMilestoneId);
+                    if (decision.shouldPark && s.currentMilestoneId) {
+                        const { parkMilestone } = await import("./milestone-actions.js");
+                        const parked = parkMilestone(s.basePath, s.currentMilestoneId, decision.reason);
+                        if (parked) {
+                            ctx.ui.notify(`Milestone ${s.currentMilestoneId} parked: "${decision.reason}"`, "info");
+                        }
+                        else {
+                            // Park refused: milestone directory missing, milestone already
+                            // completed (SUMMARY present), or PARKED.md already exists.
+                            // resolveAllOverrides below will still consume the override —
+                            // surface this loudly so the user notices state drift rather
+                            // than silently losing the abandon directive.
+                            const msg = `Abandon detected for ${s.currentMilestoneId} but park refused (milestone is completed, already parked, or missing). Override will be resolved anyway — verify state is correct.`;
+                            logError("engine", msg);
+                            ctx.ui.notify(msg, "warning");
+                        }
+                    }
+                }
+                catch (err) {
+                    logError("engine", `abandon-detect failed: ${err.message}`);
+                    ctx.ui.notify(`Abandon detection failed — check logs. Overrides will still be resolved.`, "warning");
+                }
                 await resolveAllOverrides(s.basePath);
                 // Reset both disk and in-memory counters. Disk counter is authoritative
                 // (survives restarts); in-memory is kept in sync for the current session.
@@ -475,6 +538,85 @@ export async function postUnitPreVerification(pctx, opts) {
                     clearReactiveState(s.basePath, mid, sid);
                 }
             });
+            // #4765 — slice-cadence collapse. When `git.collapse_cadence: "slice"`
+            // is set, squash-merge the slice's commits from the milestone branch
+            // onto main right here, so orphan risk shrinks from milestone-size to
+            // slice-size. Only runs in worktree isolation mode — the feature needs
+            // a milestone branch to squash from.
+            let sliceMergeStopped = false;
+            await runSafely("postUnit", "slice-cadence-merge", async () => {
+                const prefsResult = loadEffectiveGSDPreferences(s.basePath);
+                const prefs = prefsResult?.preferences;
+                const { getCollapseCadence, mergeSliceToMain } = await import("./slice-cadence.js");
+                if (getCollapseCadence(prefs) !== "slice")
+                    return;
+                if (prefs?.git?.isolation !== "worktree")
+                    return;
+                if (s.isolationDegraded)
+                    return;
+                const projectRoot = s.originalBasePath || s.basePath;
+                const { milestone: mid, slice: sid } = parseUnitId(unit.id);
+                if (!mid || !sid)
+                    return;
+                // Record the milestone start SHA before the first slice merge, so
+                // resquashMilestoneOnMain has a target at milestone completion.
+                // Resolve main branch dynamically — hard-coding "main" breaks repos
+                // that use "master" or a custom default branch.
+                if (!s.milestoneStartShas.has(mid)) {
+                    try {
+                        const { nativeDetectMainBranch } = await import("./native-git-bridge.js");
+                        const mainBranch = nativeDetectMainBranch(projectRoot);
+                        const { execFileSync } = await import("node:child_process");
+                        const sha = execFileSync("git", ["rev-parse", mainBranch], {
+                            cwd: projectRoot, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8",
+                        }).trim();
+                        if (sha)
+                            s.milestoneStartShas.set(mid, sha);
+                    }
+                    catch (err) {
+                        logWarning("engine", `slice-cadence: failed to record milestone start SHA: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+                try {
+                    const result = mergeSliceToMain(projectRoot, mid, sid);
+                    if (result.skipped) {
+                        logWarning("engine", `slice-cadence: merge skipped for ${sid} — ${result.skippedReason}`);
+                        return;
+                    }
+                    ctx.ui.notify(`slice-cadence: ${sid} merged to main (${result.durationMs}ms).`, "info");
+                }
+                catch (err) {
+                    const { MergeConflictError } = await import("./git-service.js");
+                    if (err instanceof MergeConflictError) {
+                        ctx.ui.notify(`slice-cadence merge conflict in ${sid}: ${err.conflictedFiles.join(", ")}. ` +
+                            `Resolve manually on main and run \`/gsd auto\` to resume.`, "error");
+                        // Stop auto AND signal the outer postUnit flow to exit early.
+                        // Without the flag, subsequent hooks (triage, rogue detection,
+                        // DB writes) would keep running against a conflicted main
+                        // checkout after the loop was already told to stop.
+                        const { stopAuto } = await import("./auto.js");
+                        await stopAuto(ctx, undefined, `slice-merge-conflict on ${sid}`);
+                        sliceMergeStopped = true;
+                        return;
+                    }
+                    logError("engine", `slice-cadence merge failed for ${sid}`, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                    // Non-conflict failures (dirty main, rev-walk error, etc.) can
+                    // leave the checkout in an unexpected state. Stop auto-mode so
+                    // the next slice doesn't dispatch on top of it.
+                    const { stopAuto } = await import("./auto.js");
+                    await stopAuto(ctx, undefined, `slice-merge-error on ${sid}`);
+                    sliceMergeStopped = true;
+                }
+            });
+            // Exit early after stopAuto so the rest of post-unit processing
+            // (triage, rogue detection, hook dispatch, DB writes) doesn't run
+            // against a conflicted main checkout. Return "dispatched" to match
+            // the convention used by other stop/pauseAuto paths in this function
+            // (see signal handling earlier: stop/pause also return "dispatched").
+            if (sliceMergeStopped)
+                return "dispatched";
         }
         // Post-triage: execute actionable resolutions
         if (s.currentUnit.type === "triage-captures") {
@@ -535,7 +677,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 +730,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) {
@@ -607,6 +759,25 @@ export async function postUnitPreVerification(pctx, opts) {
             }
             // If verification failed, attempt to regenerate missing projection files
             // from DB data before giving up (e.g. research-slice produces PLAN from engine).
+            if (!triggerArtifactVerified) {
+                if (s.currentUnit.type === "complete-milestone") {
+                    try {
+                        const { milestone: mid } = parseUnitId(s.currentUnit.id);
+                        if (mid) {
+                            const settled = await waitForMilestoneDbClose(mid);
+                            if (settled) {
+                                triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                                if (triggerArtifactVerified) {
+                                    invalidateAllCaches();
+                                }
+                            }
+                        }
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "artifact-verify-settle-db", error: String(e) });
+                    }
+                }
+            }
             if (!triggerArtifactVerified) {
                 try {
                     const { milestone: mid, slice: sid } = parseUnitId(s.currentUnit.id);
@@ -628,24 +799,38 @@ export async function postUnitPreVerification(pctx, opts) {
             // When artifact verification fails for a unit type that has a known expected
             // artifact, return "retry" so the caller re-dispatches with failure context
             // instead of blindly re-dispatching the same unit (#1571).
-            // After MAX_VERIFICATION_RETRIES, escalate to writeBlockerPlaceholder so the
-            // pipeline can advance instead of looping forever (#2653).
+            // Retries are capped at MAX_ARTIFACT_VERIFICATION_RETRIES to prevent
+            // unbounded loops (#2007).
             //
-            // HOWEVER, if the DB is unavailable (db_unavailable), the artifact was never
-            // written because the completion tool failed at the infra level. Retrying
-            // can never succeed and produces a costly re-dispatch loop (#2517).
-            if (!triggerArtifactVerified && !isDbAvailable()) {
-                // DB infra failure — do NOT retry; the completion tool returned
-                // db_unavailable so the artifact was never written. Retrying would
-                // produce an infinite re-dispatch loop (#2517).
+            // Pre-checks short-circuit retry for known-unrecoverable failures:
+            // - Deterministic policy rejection (#4973): structural write-gate failure
+            //   that will recur on every retry, so write a blocker placeholder.
+            // - DB infra failure (#2517): completion tool returned db_unavailable, so
+            //   the artifact was never written. Retrying can never succeed.
+            // - Tool invocation error (#2883/#3595): malformed JSON args or queued
+            //   user message — retry will produce the same failure.
+            //
+            // #4973: Deterministic policy rejections (e.g. context_write_blocked from the
+            // write-gate) are checked FIRST — before the DB-availability check — because
+            // they are structural gates that will fire on every retry regardless of DB or
+            // model tier. Short-circuit immediately by writing a blocker placeholder.
+            if (!triggerArtifactVerified && s.lastToolInvocationError && isDeterministicPolicyError(s.lastToolInvocationError)) {
+                const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
+                debugLog("postUnit", { phase: "deterministic-policy-error-placeholder", unitType: s.currentUnit.type, unitId: s.currentUnit.id, error: s.lastToolInvocationError });
+                const reason = `Deterministic policy rejection for ${s.currentUnit.type} "${s.currentUnit.id}": ${s.lastToolInvocationError}. Retrying cannot resolve this gate — writing blocker placeholder to advance pipeline.`;
+                s.lastToolInvocationError = null;
+                s.pendingVerificationRetry = null;
+                s.verificationRetryCount.delete(retryKey);
+                writeBlockerPlaceholder(s.currentUnit.type, s.currentUnit.id, s.basePath, reason);
+                ctx.ui.notify(`${s.currentUnit.type} ${s.currentUnit.id} — deterministic policy rejection, wrote blocker placeholder (no retries) (#4973)`, "warning");
+                // Fall through to "continue" — do NOT enter the retry or db-unavailable paths.
+            }
+            else if (!triggerArtifactVerified && !isDbAvailable()) {
                 debugLog("postUnit", { phase: "artifact-verify-skip-db-unavailable", unitType: s.currentUnit.type, unitId: s.currentUnit.id });
                 const dbSkipDiag = diagnoseExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
                 ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — DB unavailable, skipping retry.${dbSkipDiag ? ` Expected: ${dbSkipDiag}` : ""}`, "error");
             }
             else if (!triggerArtifactVerified) {
-                // #2883/#3595: If the artifact is missing because the tool invocation
-                // failed (malformed JSON) or was skipped (queued user message), retrying
-                // will produce the same failure. Pause auto-mode instead of looping.
                 if (s.lastToolInvocationError) {
                     const isUserSkip = /queued user message/i.test(s.lastToolInvocationError);
                     const errMsg = isUserSkip
@@ -661,58 +846,29 @@ export async function postUnitPreVerification(pctx, opts) {
                 if (hasExpectedArtifact) {
                     const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
                     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", {
-                            phase: "artifact-verify-escalate",
-                            unitType: s.currentUnit.type,
-                            unitId: s.currentUnit.id,
-                            attempt,
-                            maxRetries: MAX_VERIFICATION_RETRIES,
-                        });
-                        const reason = `Artifact verification failed after ${MAX_VERIFICATION_RETRIES} retries for ${s.currentUnit.type} "${s.currentUnit.id}".`;
-                        writeBlockerPlaceholder(s.currentUnit.type, s.currentUnit.id, s.basePath, reason);
-                        ctx.ui.notify(`${s.currentUnit.type} ${s.currentUnit.id} — verification retries exhausted (${MAX_VERIFICATION_RETRIES}), wrote blocker placeholder to advance pipeline`, "warning");
-                        // Reset retry count and fall through to "continue" so the loop
-                        // re-derives state with the placeholder in place.
+                    if (attempt > MAX_ARTIFACT_VERIFICATION_RETRIES) {
                         s.verificationRetryCount.delete(retryKey);
-                        s.pendingVerificationRetry = null;
-                        // Do NOT return "retry" — fall through to "continue" below.
-                    }
-                    else {
-                        s.pendingVerificationRetry = {
-                            unitId: s.currentUnit.id,
-                            failureContext: `Artifact verification failed: expected artifact for ${s.currentUnit.type} "${s.currentUnit.id}" was not found on disk after unit execution (attempt ${attempt}).`,
-                            attempt,
-                        };
-                        debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
-                        ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — retrying (attempt ${attempt})`, "warning");
-                        return "retry";
+                        debugLog("postUnit", { phase: "artifact-verify-exhausted", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
+                        ctx.ui.notify(`Artifact still missing for ${s.currentUnit.type} ${s.currentUnit.id} after ${MAX_ARTIFACT_VERIFICATION_RETRIES} retries — pausing auto-mode`, "error");
+                        await pauseAuto(ctx, pi);
+                        return "dispatched";
                     }
+                    s.verificationRetryCount.set(retryKey, attempt);
+                    s.pendingVerificationRetry = {
+                        unitId: s.currentUnit.id,
+                        failureContext: `Artifact verification failed: expected artifact for ${s.currentUnit.type} "${s.currentUnit.id}" was not found on disk after unit execution (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
+                        attempt,
+                    };
+                    debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
+                    ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — retrying (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES})`, "warning");
+                    return "retry";
                 }
             }
+            // Verification succeeded — clear the retry counter so a future failure
+            // of the same unit gets a full retry budget instead of the stale count.
+            if (triggerArtifactVerified) {
+                s.verificationRetryCount.delete(`${s.currentUnit.type}:${s.currentUnit.id}`);
+            }
         }
         else {
             // Hook unit completed — no additional processing needed
@@ -910,8 +1066,11 @@ export async function postUnitPostVerification(pctx) {
                 }
                 // Write evidence JSON to slice artifacts directory
                 const slicePath = resolveSlicePath(s.basePath, mid, sid);
+                const evidenceFileName = `${sid}-PRE-EXEC-VERIFY.json`;
+                let evidencePath = join(".gsd", "milestones", mid, "slices", sid, evidenceFileName);
                 if (slicePath) {
                     writePreExecutionEvidence(result, slicePath, mid, sid);
+                    evidencePath = relative(s.basePath, join(slicePath, evidenceFileName)) || evidenceFileName;
                 }
                 if (uokFlags.gates) {
                     const failedChecks = result.checks
@@ -946,16 +1105,31 @@ export async function postUnitPostVerification(pctx) {
                 if (result.status === "fail") {
                     const blockingChecks = result.checks.filter(c => !c.passed && c.blocking);
                     const blockingCount = blockingChecks.length;
-                    const details = blockingChecks.slice(0, 3).map(c => `  \u2022 ${c.message}`).join("\n");
-                    const suffix = blockingChecks.length > 3 ? `\n  \u2022 ...and ${blockingChecks.length - 3} more` : "";
-                    const evidenceNote = `\nSee ${sid}-PRE-EXEC-VERIFY.json for full details.`;
+                    const details = blockingChecks.slice(0, MAX_NOTIFICATION_DETAILS).map(formatPreExecutionCheckDetail).join("\n");
+                    const suffix = blockingChecks.length > MAX_NOTIFICATION_DETAILS
+                        ? `\n  ${NOTIFICATION_BULLET} ...and ${blockingChecks.length - MAX_NOTIFICATION_DETAILS} more`
+                        : "";
+                    const evidenceNote = `\nSee ${evidencePath} 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;
                     }
                 }