gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0

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

@@ -12,13 +12,15 @@ import { _clearCurrentResolve } from "./resolve.js";
 import { runPreDispatch, runDispatch, runGuards, runUnitPhase, runFinalize, } from "./phases.js";
 import { debugLog } from "../debug-logger.js";
 import { isInfrastructureError, isTransientCooldownError, getCooldownRetryAfterMs, COOLDOWN_FALLBACK_WAIT_MS, MAX_COOLDOWN_RETRIES } from "./infra-errors.js";
+import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import { resolveEngine } from "../engine-resolver.js";
 import { logWarning } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
+import { atomicWriteSync } from "../atomic-write.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { scheduleSidecarQueue } from "../uok/execution-graph.js";
 import { ExecutionGraphScheduler } from "../uok/execution-graph.js";
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 // ── Stuck detection persistence (#3704) ──────────────────────────────────
 // Persist stuck detection state to disk so it survives session restarts.
@@ -62,12 +64,64 @@ function saveStuckState(basePath, state) {
         debugLog("autoLoop", { phase: "save-stuck-state-failed", error: err instanceof Error ? err.message : String(err) });
     }
 }
+// ── Custom workflow verification retry persistence ───────────────────────
+// Custom workflows can request verification retries after a step runs. The
+// retry budget must survive an auto-mode restart or a failing verifier can
+// consume a fresh retry budget every session.
+function customVerifyRetryStateDir(s) {
+    return s.activeRunDir ? join(s.activeRunDir, "runtime") : join(gsdRoot(s.basePath), "runtime");
+}
+function customVerifyRetryStatePath(s) {
+    return join(customVerifyRetryStateDir(s), "custom-verify-retries.json");
+}
+function hydrateCustomVerifyRetryCounts(s) {
+    if (s.verificationRetryCount.size > 0) {
+        return s.verificationRetryCount;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(customVerifyRetryStatePath(s), "utf-8"));
+        const counts = raw && typeof raw === "object" && raw.counts && typeof raw.counts === "object"
+            ? raw.counts
+            : {};
+        for (const [key, value] of Object.entries(counts)) {
+            if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+                s.verificationRetryCount.set(key, Math.floor(value));
+            }
+        }
+    }
+    catch (err) {
+        debugLog("autoLoop", { phase: "load-custom-verify-retries-failed", error: err instanceof Error ? err.message : String(err) });
+    }
+    return s.verificationRetryCount;
+}
+function saveCustomVerifyRetryCounts(s) {
+    const retryCounts = s.verificationRetryCount;
+    const filePath = customVerifyRetryStatePath(s);
+    try {
+        if (!retryCounts || retryCounts.size === 0) {
+            unlinkSync(filePath);
+            return;
+        }
+        mkdirSync(customVerifyRetryStateDir(s), { recursive: true });
+        atomicWriteSync(filePath, JSON.stringify({
+            counts: Object.fromEntries(retryCounts),
+            updatedAt: new Date().toISOString(),
+        }) + "\n");
+    }
+    catch (err) {
+        const code = err && typeof err === "object" && "code" in err ? err.code : undefined;
+        if (code !== "ENOENT") {
+            debugLog("autoLoop", { phase: "save-custom-verify-retries-failed", error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+}
 // ── Memory pressure monitoring (#3331) ──────────────────────────────────
 // Check heap usage every N iterations and trigger graceful shutdown before
 // the OS OOM killer sends SIGKILL. The threshold is 90% of the V8 heap
 // limit (--max-old-space-size or default ~1.5-4GB depending on platform).
 const MEMORY_CHECK_INTERVAL = 5; // check every 5 iterations
 const MEMORY_PRESSURE_THRESHOLD = 0.85; // 85% of heap limit
+const MAX_CUSTOM_ENGINE_VERIFY_RETRIES = 3;
 function checkMemoryPressure() {
     const mem = process.memoryUsage();
     // v8.getHeapStatistics() gives heap_size_limit but requires import
@@ -360,15 +414,41 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     break;
                 }
                 if (verifyResult === "retry") {
-                    debugLog("autoLoop", { phase: "custom-engine-verify-retry", iteration, unitId: iterData.unitId });
+                    const recoveryKey = `${iterData.unitType}/${iterData.unitId}`;
+                    const retryCounts = hydrateCustomVerifyRetryCounts(s);
+                    const attempts = (retryCounts.get(recoveryKey) ?? 0) + 1;
+                    retryCounts.set(recoveryKey, attempts);
+                    saveCustomVerifyRetryCounts(s);
+                    debugLog("autoLoop", { phase: "custom-engine-verify-retry", iteration, unitId: iterData.unitId, attempts });
                     deps.uokObserver?.onPhaseResult("custom-engine", "retry", {
                         unitType: iterData.unitType,
                         unitId: iterData.unitId,
+                        attempts,
                     });
+                    if (attempts > MAX_CUSTOM_ENGINE_VERIFY_RETRIES) {
+                        const recovery = await policy.recover(iterData.unitType, iterData.unitId, { basePath: s.basePath });
+                        if (recovery.outcome === "pause") {
+                            await deps.pauseAuto(ctx, pi);
+                            finishTurn("paused", "manual-attention", recovery.reason ?? "custom-engine-verify-retry-exhausted");
+                            break;
+                        }
+                        if (recovery.outcome === "skip") {
+                            await deps.stopAuto(ctx, pi, recovery.reason ??
+                                `Custom workflow verification for ${iterData.unitId} requested skip after retry exhaustion, but the custom engine cannot reconcile skipped steps.`);
+                            finishTurn("stopped", "manual-attention", "custom-engine-verify-retry-exhausted");
+                            break;
+                        }
+                        const exhaustedReason = `Custom workflow verification for ${iterData.unitId} requested retry ${attempts} times without passing.`;
+                        await deps.stopAuto(ctx, pi, recovery.outcome === "stop" && recovery.reason ? recovery.reason : exhaustedReason);
+                        finishTurn("stopped", "manual-attention", "custom-engine-verify-retry-exhausted");
+                        break;
+                    }
                     finishTurn("retry");
                     continue;
                 }
                 // Verification passed — mark step complete
+                s.verificationRetryCount?.delete(`${iterData.unitType}/${iterData.unitId}`);
+                saveCustomVerifyRetryCounts(s);
                 debugLog("autoLoop", { phase: "custom-engine-reconcile", iteration, unitId: iterData.unitId });
                 const reconcileResult = await engine.reconcile(engineState, {
                     unitType: iterData.unitType,
@@ -516,6 +596,48 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             // completion even on failure (#2344). Without this, errors in
             // runFinalize leave the journal incomplete, making diagnosis harder.
             deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration, error: msg } });
+            // ── Pre-send model-policy block: not a retryable error (#4959 / #4850) ──
+            // The model-policy gate runs before the prompt is sent.  When every
+            // candidate model is denied (cross-provider disabled + flat-rate
+            // baseline + tool-policy denial), retrying the same unit produces the
+            // same denial — burning the consecutive-error budget toward a 3-strike
+            // hard stop and corrupting auto-mode state.  Pause for user attention
+            // instead, with the per-model deny reasons surfaced from the typed
+            // error.
+            if (loopErr instanceof ModelPolicyDispatchBlockedError) {
+                debugLog("autoLoop", {
+                    phase: "model-policy-blocked",
+                    iteration,
+                    unitType: loopErr.unitType,
+                    unitId: loopErr.unitId,
+                    reasons: loopErr.reasons,
+                });
+                ctx.ui.notify(`Auto-mode paused: model-policy denied dispatch for ${loopErr.unitType}/${loopErr.unitId}. ${msg}`, "error");
+                deps.emitJournalEvent({
+                    ts: new Date().toISOString(),
+                    flowId,
+                    seq: nextSeq(),
+                    eventType: "unit-end",
+                    data: {
+                        unitType: loopErr.unitType,
+                        unitId: loopErr.unitId,
+                        status: "blocked",
+                        reason: "model-policy-dispatch-blocked",
+                        reasons: loopErr.reasons,
+                    },
+                });
+                // Carry the blocked unit identity into the turn-result observer:
+                // the throw originated inside dispatch, so observedUnitType/Id were
+                // not assigned by the success path at lines 453/631/647 — but the
+                // typed error already names the unit (#4959 / CodeRabbit).
+                observedUnitType = loopErr.unitType;
+                observedUnitId = loopErr.unitId;
+                await deps.pauseAuto(ctx, pi);
+                finishTurn("paused", "manual-attention", msg);
+                // Do NOT increment consecutiveErrors — the failure is configuration,
+                // not a transient runtime fault.
+                break;
+            }
             // ── Infrastructure errors: immediate stop, no retry ──
             // These are unrecoverable (disk full, OOM, etc.). Retrying just burns
             // LLM budget on guaranteed failures.

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

@@ -11,12 +11,12 @@ import { MAX_RECOVERY_CHARS, BUDGET_THRESHOLDS, MAX_FINALIZE_TIMEOUTS, } from ".
 import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
-import { PROJECT_FILES } from "../detection.js";
+import { PROJECT_FILES, hasProjectFileInAncestor } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.js";
-import { join, basename, dirname, parse as parsePath } from "node:path";
+import { join, basename } from "node:path";
 import { existsSync, cpSync, readdirSync } from "node:fs";
 import { logWarning, logError, _resetLogs, drainLogs, drainAndSummarize, formatForNotification, hasAnyIssues, } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
@@ -27,7 +27,7 @@ import { withTimeout, FINALIZE_PRE_TIMEOUT_MS, FINALIZE_POST_TIMEOUT_MS } from "
 import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { startSliceParallel } from "../slice-parallel-orchestrator.js";
 import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
-import { ensurePlanV2Graph } from "../uok/plan-v2.js";
+import { ensurePlanV2Graph, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
 import { resetEvidence, loadEvidenceFromDisk } from "../safety/evidence-collector.js";
@@ -127,6 +127,7 @@ async function generateMilestoneReport(s, ctx, milestoneId) {
 async function closeoutAndStop(ctx, pi, s, deps, reason) {
     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));
+        s.currentUnit = null;
     }
     await deps.stopAuto(ctx, pi, reason);
 }
@@ -296,27 +297,42 @@ export async function runPreDispatch(ic, loopState) {
         const compiled = ensurePlanV2Graph(s.basePath, state);
         if (!compiled.ok) {
             const reason = compiled.reason ?? "Plan v2 compilation failed";
+            if (isMissingFinalizedContextResult(compiled)) {
+                await runPreDispatchGate({
+                    gateId: "plan-v2-gate",
+                    gateType: "policy",
+                    outcome: "pass",
+                    failureClass: "none",
+                    rationale: "plan v2 missing context recovery deferred to dispatch",
+                    findings: reason,
+                    milestoneId: state.activeMilestone?.id ?? undefined,
+                });
+            }
+            else {
+                await runPreDispatchGate({
+                    gateId: "plan-v2-gate",
+                    gateType: "policy",
+                    outcome: "manual-attention",
+                    failureClass: "manual-attention",
+                    rationale: "plan v2 compile gate failed",
+                    findings: reason,
+                    milestoneId: state.activeMilestone?.id ?? undefined,
+                });
+                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" };
+            }
+        }
+        if (compiled.ok) {
             await runPreDispatchGate({
                 gateId: "plan-v2-gate",
                 gateType: "policy",
-                outcome: "manual-attention",
-                failureClass: "manual-attention",
-                rationale: "plan v2 compile gate failed",
-                findings: reason,
+                outcome: "pass",
+                failureClass: "none",
+                rationale: "plan v2 compile gate passed",
                 milestoneId: state.activeMilestone?.id ?? undefined,
             });
-            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" };
         }
-        await runPreDispatchGate({
-            gateId: "plan-v2-gate",
-            gateType: "policy",
-            outcome: "pass",
-            failureClass: "none",
-            rationale: "plan v2 compile gate passed",
-            milestoneId: state.activeMilestone?.id ?? undefined,
-        });
     }
     deps.syncCmuxSidebar(prefs, state);
     let mid = state.activeMilestone?.id;
@@ -667,10 +683,14 @@ export async function runDispatch(ic, preData, loopState) {
     const pauseAfterUatDispatch = dispatchResult.pauseAfterDispatch ?? false;
     // ── Sliding-window stuck detection with graduated recovery ──
     const derivedKey = `${unitType}/${unitId}`;
+    // Always record this dispatch in the sliding window so detectStuck() has
+    // accurate history. Skipping the push when pendingVerificationRetry is set
+    // caused infinite artifact-retry loops to be invisible to stuck detection
+    // (#2007). Only the *response* to a stuck signal is suppressed during retries.
+    loopState.recentUnits.push({ key: derivedKey });
+    if (loopState.recentUnits.length > STUCK_WINDOW_SIZE)
+        loopState.recentUnits.shift();
     if (!s.pendingVerificationRetry) {
-        loopState.recentUnits.push({ key: derivedKey });
-        if (loopState.recentUnits.length > STUCK_WINDOW_SIZE)
-            loopState.recentUnits.shift();
         const stuckSignal = detectStuck(loopState.recentUnits);
         if (stuckSignal) {
             debugLog("autoLoop", {
@@ -996,22 +1016,9 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         // Monorepo support (#2347): if no project files in the worktree directory,
         // walk parent directories up to the filesystem root. In monorepos,
         // package.json / Cargo.toml etc. live in a parent directory.
-        let hasProjectFileInParent = false;
-        if (!hasProjectFile && !hasSrcDir && !hasXcodeBundle) {
-            let checkDir = dirname(s.basePath);
-            const { root } = parsePath(checkDir);
-            while (checkDir !== root) {
-                // Stop at git repository boundary — ancestors above the repo root
-                // (e.g. ~ or /usr/local) may contain unrelated project files.
-                if (deps.existsSync(join(checkDir, ".git")))
-                    break;
-                if (PROJECT_FILES.some((f) => deps.existsSync(join(checkDir, f)))) {
-                    hasProjectFileInParent = true;
-                    break;
-                }
-                checkDir = dirname(checkDir);
-            }
-        }
+        const hasProjectFileInParent = !hasProjectFile && !hasSrcDir && !hasXcodeBundle
+            ? hasProjectFileInAncestor(s.basePath, deps.existsSync)
+            : false;
         if (!hasProjectFile && !hasSrcDir && !hasXcodeBundle && !hasProjectFileInParent) {
             // Greenfield projects won't have project files yet — the first task creates them.
             // Log a warning but allow execution to proceed. The .git check above is sufficient
@@ -1241,9 +1248,18 @@ 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).
+        // Provider-error pause: agent_end recovery normally pauses before this
+        // branch. Provider readiness failures happen before dispatch, so pause here
+        // if nothing upstream already did.
         if (errorCategory === "provider") {
+            if (!s.paused) {
+                const detail = unitResult.errorContext?.message ?? `Provider unavailable for ${unitType} ${unitId}`;
+                await pauseAutoForProviderError(ctx.ui, detail, () => deps.pauseAuto(ctx, pi), {
+                    isRateLimit: false,
+                    isTransient: Boolean(unitResult.errorContext?.isTransient),
+                    retryAfterMs: unitResult.errorContext?.retryAfterMs,
+                });
+            }
             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" };
@@ -1537,6 +1553,8 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     }
     // Both pre and post verification completed without timeout — reset counter
     loopState.consecutiveFinalizeTimeouts = 0;
+    s.currentUnit = null;
+    clearCurrentPhase();
     // 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.

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

@@ -16,9 +16,7 @@
  * `let` or `var` declarations.
  */
 // ─── Constants ───────────────────────────────────────────────────────────────
-export const MAX_UNIT_DISPATCHES = 3;
 export const STUB_RECOVERY_THRESHOLD = 2;
-export const MAX_LIFETIME_DISPATCHES = 6;
 export const NEW_SESSION_TIMEOUT_MS = 120_000;
 // ─── AutoSession ─────────────────────────────────────────────────────────────
 export class AutoSession {
@@ -105,6 +103,11 @@ export class AutoSession {
     /** Set to true after phases.ts successfully calls mergeAndExit, so that
      *  stopAuto does not attempt the same merge a second time (#2645). */
     milestoneMergedInPhases = false;
+    // #4765 — slice-cadence collapse: main-branch SHAs at the moment each
+    // milestone's first slice merge began. Used by resquashMilestoneOnMain at
+    // milestone completion to collapse N slice commits into one. Cleared when
+    // the milestone finishes (or resquash runs).
+    milestoneStartShas = new Map();
     // ── Dispatch circuit breakers ──────────────────────────────────────
     rewriteAttemptCount = 0;
     /** Tracks consecutive bootstrap attempts that found phase === "complete".
@@ -221,6 +224,7 @@ export class AutoSession {
         this.lastGitActionStatus = null;
         this.isolationDegraded = false;
         this.milestoneMergedInPhases = false;
+        this.milestoneStartShas = new Map();
         this.checkpointSha = null;
         // Signal handler
         this.sigtermHandler = null;

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

@@ -17,11 +17,47 @@ import { parseRoadmap } from "./parsers-legacy.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { logWarning, logError } from "./workflow-logger.js";
 import { join } from "node:path";
-import { hasImplementationArtifacts, classifyMilestoneSummaryContent } from "./auto-recovery.js";
+import { hasImplementationArtifacts } from "./auto-recovery.js";
+import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildRefineSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, buildParallelResearchSlicesPrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
 import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { selectReactiveDispatchBatch } from "./uok/execution-graph.js";
+import { getMilestonePipelineVariant } from "./milestone-scope-classifier.js";
+import { EXECUTION_ENTRY_PHASES, hasFinalizedMilestoneContext } from "./uok/plan-v2.js";
+import { isAutoActive } from "./auto.js";
+import { markDepthVerified } from "./bootstrap/write-gate.js";
+let reassessmentChecker = checkNeedsReassessment;
+export function setReassessmentCheckerForTest(checker) {
+    const previous = reassessmentChecker;
+    reassessmentChecker = checker;
+    return () => {
+        reassessmentChecker = previous;
+    };
+}
+async function readUatGateVerdict(basePath, mid, sliceId) {
+    const uatFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
+    const assessmentFile = resolveSliceFile(basePath, mid, sliceId, "ASSESSMENT");
+    const uatContent = uatFile ? await loadFile(uatFile) : null;
+    const uatType = uatContent ? extractUatType(uatContent) : undefined;
+    const assessmentContent = assessmentFile ? await loadFile(assessmentFile) : null;
+    if (assessmentContent) {
+        const assessmentVerdict = extractVerdict(assessmentContent);
+        if (assessmentVerdict) {
+            return {
+                verdict: assessmentVerdict,
+                uatType: uatType ?? extractUatType(assessmentContent),
+            };
+        }
+    }
+    if (uatContent) {
+        const legacyUatVerdict = extractVerdict(uatContent);
+        if (legacyUatVerdict) {
+            return { verdict: legacyUatVerdict, uatType };
+        }
+    }
+    return null;
+}
 function missingSliceStop(mid, phase) {
     return {
         action: "stop",
@@ -155,6 +191,45 @@ export const DISPATCH_RULES = [
             };
         },
     },
+    {
+        // #4671 — Recovery path for execution-entry phases with missing CONTEXT.md.
+        //
+        // Once `deriveStateFromDb` returns an execution-entry phase (executing /
+        // summarizing / validating-milestone / completing-milestone), the
+        // pre-planning guard at `pre-planning (no context) → discuss-milestone`
+        // no longer fires. The plan-v2 gate correctly detects the missing context
+        // but can only block — it cannot redispatch. Without this rule the
+        // milestone is stuck until `/gsd doctor heal` repairs it (and heal
+        // historically missed this check too).
+        //
+        // Fire BEFORE the execution-entry phase rules so we redispatch to
+        // `discuss-milestone` instead of hitting the plan-v2 gate.
+        name: "execution-entry phase (no context) → discuss-milestone",
+        match: async ({ state, mid, midTitle, basePath, structuredQuestionsAvailable }) => {
+            if (!EXECUTION_ENTRY_PHASES.has(state.phase))
+                return null;
+            // Align with the plan-v2 gate's lookup semantics: whitespace-only counts
+            // as missing, and an auto worktree may fall back to GSD_PROJECT_ROOT.
+            if (hasFinalizedMilestoneContext(basePath, mid))
+                return null;
+            // H6 fix (#4973): In auto-mode there is no human to answer the
+            // depth-verification ask_user_questions, so the write-gate deadlocks.
+            // Pre-mark the milestone as depth-verified so gsd_summary_save({artifact_type:"CONTEXT"})
+            // is not blocked. Safe ordering: session_switch fires clearDiscussionFlowState()
+            // (register-hooks.ts:106) before before_agent_start, which fires before resolveDispatch
+            // reaches this match fn — so this call always happens after any session-switch reset.
+            // Interactive sessions (isAutoActive()===false) are unaffected.
+            if (isAutoActive()) {
+                markDepthVerified(mid, basePath);
+            }
+            return {
+                action: "dispatch",
+                unitType: "discuss-milestone",
+                unitId: mid,
+                prompt: await buildDiscussMilestonePrompt(mid, midTitle, basePath, structuredQuestionsAvailable),
+            };
+        },
+    },
     {
         name: "summarizing → complete-slice",
         match: async ({ state, mid, midTitle, basePath }) => {
@@ -205,27 +280,29 @@ export const DISPATCH_RULES = [
             // Only applies when UAT dispatch is enabled
             if (!prefs?.uat_dispatch)
                 return null;
-            const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            // DB-first: get completed slices from DB
-            let completedSliceIds;
+            // DB-first: prefer closed slices from DB; fall back to ROADMAP on disk.
+            let closedSliceIds;
             if (isDbAvailable()) {
-                completedSliceIds = getMilestoneSlices(mid)
-                    .filter(s => s.status === "complete")
+                closedSliceIds = getMilestoneSlices(mid)
+                    .filter(s => isClosedStatus(s.status))
                     .map(s => s.id);
             }
             else {
-                return null;
+                // Filesystem fallback for degraded / unmigrated projects.
+                // `slice.done` in the parsed ROADMAP is the disk-level closed signal.
+                const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
+                const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+                if (!roadmapContent)
+                    return null;
+                const roadmap = parseRoadmap(roadmapContent);
+                closedSliceIds = roadmap.slices.filter(s => s.done).map(s => s.id);
             }
-            for (const sliceId of completedSliceIds) {
-                const resultFile = resolveSliceFile(basePath, mid, sliceId, "UAT");
-                if (!resultFile)
+            for (const sliceId of closedSliceIds) {
+                const result = await readUatGateVerdict(basePath, mid, sliceId);
+                if (!result)
                     continue;
-                const content = await loadFile(resultFile);
-                if (!content)
-                    continue;
-                const verdict = extractVerdict(content);
-                const uatType = extractUatType(content);
-                if (verdict && !isAcceptableUatVerdict(verdict, uatType)) {
+                const { verdict, uatType } = result;
+                if (!isAcceptableUatVerdict(verdict, uatType)) {
                     return {
                         action: "stop",
                         reason: `UAT verdict for ${sliceId} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
@@ -241,12 +318,16 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
             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;
+            // Default reassess_after_slice to false per ADR-003 §4 — most reassess
+            // units conclude "roadmap is fine" and burn a session for no change.
+            // The plan-slice prompt now carries a reassessment preamble so the
+            // next slice's planner does JIT roadmap verification at zero extra
+            // cost. Opt-in via explicit `reassess_after_slice: true` (e.g.
+            // burn-max profile) when you want the dedicated reassess session.
+            const reassessEnabled = prefs?.phases?.reassess_after_slice ?? false;
             if (!reassessEnabled)
                 return null;
-            const needsReassess = await checkNeedsReassessment(basePath, mid, state);
+            const needsReassess = await reassessmentChecker(basePath, mid, state);
             if (!needsReassess)
                 return null;
             return {
@@ -262,6 +343,12 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath, structuredQuestionsAvailable }) => {
             if (state.phase !== "needs-discussion")
                 return null;
+            // H6 fix (#4973): auto-mark depth-verified so the write-gate does not
+            // deadlock in non-interactive (auto-mode) runs. See ordering note at
+            // "execution-entry phase (no context) → discuss-milestone" above.
+            if (isAutoActive()) {
+                markDepthVerified(mid, basePath);
+            }
             return {
                 action: "dispatch",
                 unitType: "discuss-milestone",
@@ -279,6 +366,12 @@ export const DISPATCH_RULES = [
             const hasContext = !!(contextFile && (await loadFile(contextFile)));
             if (hasContext)
                 return null; // fall through to next rule
+            // H6 fix (#4973): auto-mark depth-verified so the write-gate does not
+            // deadlock in non-interactive (auto-mode) runs. See ordering note at
+            // "execution-entry phase (no context) → discuss-milestone" above.
+            if (isAutoActive()) {
+                markDepthVerified(mid, basePath);
+            }
             return {
                 action: "dispatch",
                 unitType: "discuss-milestone",
@@ -352,6 +445,12 @@ export const DISPATCH_RULES = [
                 return null;
             if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
                 return null;
+            // #4781 phase 2: trivial-scope milestones skip dedicated slice research.
+            // plan-slice absorbs the lightweight discovery a trivial deliverable
+            // needs. Null result (DB unavailable / unknown) falls through to today's
+            // behavior.
+            if (await getMilestonePipelineVariant(mid) === "trivial")
+                return null;
             // Load roadmap to find all slices
             const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
             const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
@@ -401,6 +500,9 @@ export const DISPATCH_RULES = [
             // Phase skip: skip research when preference or profile says so
             if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
                 return null;
+            // #4781 phase 2: trivial-scope milestones skip dedicated slice research.
+            if (await getMilestonePipelineVariant(mid) === "trivial")
+                return null;
             if (!state.activeSlice)
                 return missingSliceStop(mid, state.phase);
             const sid = state.activeSlice.id;
@@ -682,22 +784,29 @@ export const DISPATCH_RULES = [
                     level: "error",
                 };
             }
-            // Skip preference: write a minimal pass-through VALIDATION file
-            if (prefs?.phases?.skip_milestone_validation) {
+            // #4781 phase 2: trivial-scope milestones skip the dedicated validate
+            // unit — complete-milestone's own verification steps (3/4/5 in the
+            // closer prompt) are sufficient proof for contained deliverables.
+            const trivialVariant = await getMilestonePipelineVariant(mid) === "trivial";
+            // Skip preference OR trivial scope: write a minimal pass-through VALIDATION file.
+            if (prefs?.phases?.skip_milestone_validation || trivialVariant) {
                 const mDir = resolveMilestonePath(basePath, mid);
                 if (mDir) {
                     if (!existsSync(mDir))
                         mkdirSync(mDir, { recursive: true });
                     const validationPath = join(mDir, buildMilestoneFileName(mid, "VALIDATION"));
+                    const skipSource = trivialVariant
+                        ? "trivial-scope pipeline variant (#4781)"
+                        : "`skip_milestone_validation` preference";
                     const content = [
                         "---",
                         "verdict: pass",
                         "remediation_round: 0",
                         "---",
                         "",
-                        "# Milestone Validation (skipped by preference)",
+                        "# Milestone Validation (skipped)",
                         "",
-                        "Milestone validation was skipped via `skip_milestone_validation` preference.",
+                        `Milestone validation was skipped via ${skipSource}.`,
                     ].join("\n");
                     writeFileSync(validationPath, content, "utf-8");
                 }
@@ -728,7 +837,7 @@ export const DISPATCH_RULES = [
             }
             const existingSummary = resolveMilestoneFile(basePath, mid, "SUMMARY");
             let summaryOutcome = "unknown";
-            if (existingSummary && isDbAvailable()) {
+            if (existingSummary) {
                 const summaryContent = await loadFile(existingSummary);
                 if (summaryContent) {
                     summaryOutcome = classifyMilestoneSummaryContent(summaryContent);
@@ -764,7 +873,7 @@ export const DISPATCH_RULES = [
             // Safety guard (#1703): verify the milestone produced implementation
             // artifacts (non-.gsd/ files). A milestone with only plan files and
             // zero implementation code should not be marked complete.
-            const artifactCheck = hasImplementationArtifacts(basePath);
+            const artifactCheck = hasImplementationArtifacts(basePath, mid);
             if (artifactCheck === "absent") {
                 return {
                     action: "stop",
@@ -815,10 +924,14 @@ export const DISPATCH_RULES = [
             // - success summary: reconcile DB and skip re-dispatch
             // - failure summary: pause/fail-closed
             // - unknown summary: pause/fail-closed
-            if (existingSummary && isDbAvailable()) {
-                const milestone = getMilestone(mid);
-                const status = milestone?.status ?? "missing";
+            if (existingSummary) {
+                const milestone = isDbAvailable() ? getMilestone(mid) : null;
+                const status = milestone?.status ?? (isDbAvailable() ? "missing" : "unavailable");
                 if (summaryOutcome === "success") {
+                    if (!isDbAvailable()) {
+                        logWarning("dispatch", `Milestone ${mid} SUMMARY indicates completion while DB is unavailable — skipping duplicate complete-milestone dispatch`);
+                        return { action: "skip" };
+                    }
                     try {
                         updateMilestoneStatus(mid, "complete", new Date().toISOString());
                         logWarning("dispatch", `Milestone ${mid} SUMMARY indicates completion while DB status was "${status}" — reconciled DB to complete (#4658)`);