gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

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

@@ -14,9 +14,11 @@ import { debugLog } from "../debug-logger.js";
 import { PROJECT_FILES } 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 { existsSync, cpSync, readdirSync } from "node:fs";
-import { logWarning, logError } from "../workflow-logger.js";
+import { logWarning, logError, _resetLogs, drainLogs, drainAndSummarize, formatForNotification, hasAnyIssues, } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
 import { verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.js";
@@ -25,10 +27,19 @@ 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 { resolveUokFlags } from "../uok/flags.js";
+import { UokGateRunner } from "../uok/gate-runner.js";
 import { resetEvidence } from "../safety/evidence-collector.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
-import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "../workflow-mcp.js";
+import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, supportsStructuredQuestions, } from "../workflow-mcp.js";
+// ─── Session timeout auto-resume state ────────────────────────────────────────
+let consecutiveSessionTimeouts = 0;
+const MAX_SESSION_TIMEOUT_AUTO_RESUMES = 3;
+export function resetSessionTimeoutState() {
+    consecutiveSessionTimeouts = 0;
+}
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
  * Resolve the base path for milestone reports.
@@ -46,6 +57,15 @@ export function _resolveReportBasePath(s) {
 export function _resolveDispatchGuardBasePath(s) {
     return s.originalBasePath || s.basePath;
 }
+const PLAN_V2_GATE_PHASES = new Set([
+    "executing",
+    "summarizing",
+    "validating-milestone",
+    "completing-milestone",
+]);
+function shouldRunPlanV2Gate(phase) {
+    return PLAN_V2_GATE_PHASES.has(phase);
+}
 /**
  * Generate and write an HTML milestone report snapshot.
  * Extracted from the milestone-transition block in autoLoop.
@@ -100,6 +120,63 @@ async function closeoutAndStop(ctx, pi, s, deps, reason) {
     }
     await deps.stopAuto(ctx, pi, reason);
 }
+async function emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, errorContext) {
+    ic.deps.emitJournalEvent({
+        ts: new Date().toISOString(),
+        flowId: ic.flowId,
+        seq: ic.nextSeq(),
+        eventType: "unit-end",
+        data: {
+            unitType,
+            unitId,
+            status: "cancelled",
+            artifactVerified: false,
+            ...(errorContext ? { errorContext } : {}),
+        },
+        causedBy: { flowId: ic.flowId, seq: unitStartSeq },
+    });
+}
+async function failClosedOnFinalizeTimeout(ic, iterData, loopState, stage, startedAt) {
+    const { ctx, pi, s, deps } = ic;
+    const now = Date.now();
+    const unitType = iterData.unitType;
+    const unitId = iterData.unitId;
+    const timeoutMs = stage === "pre" ? FINALIZE_PRE_TIMEOUT_MS : FINALIZE_POST_TIMEOUT_MS;
+    const progressKind = stage === "pre" ? "finalize-pre-timeout" : "finalize-post-timeout";
+    writeUnitRuntimeRecord(s.basePath, unitType, unitId, startedAt, {
+        phase: "finalize-timeout",
+        timeoutAt: now,
+        lastProgressAt: now,
+        lastProgressKind: progressKind,
+    });
+    deps.emitJournalEvent({
+        ts: new Date(now).toISOString(),
+        flowId: ic.flowId,
+        seq: ic.nextSeq(),
+        eventType: "unit-end",
+        data: {
+            unitType,
+            unitId,
+            status: "timed-out-finalize",
+            artifactVerified: false,
+            finalizeStage: stage,
+        },
+    });
+    loopState.consecutiveFinalizeTimeouts++;
+    debugLog("autoLoop", {
+        phase: progressKind,
+        iteration: ic.iteration,
+        unitType,
+        unitId,
+        consecutiveTimeouts: loopState.consecutiveFinalizeTimeouts,
+    });
+    ctx.ui.notify(`${stage === "pre" ? "postUnitPreVerification" : "postUnitPostVerification"} timed out after ${timeoutMs / 1000}s for ${unitType} ${unitId} (${loopState.consecutiveFinalizeTimeouts}/${MAX_FINALIZE_TIMEOUTS}) — pausing auto-mode for recovery.`, "warning");
+    await deps.pauseAuto(ctx, pi);
+    s.currentUnit = null;
+    clearCurrentPhase();
+    drainLogs();
+    return { action: "break", reason: progressKind };
+}
 // ─── runPreDispatch ───────────────────────────────────────────────────────────
 /**
  * Phase 1: Pre-dispatch — resource guard, health gate, state derivation,
@@ -108,13 +185,52 @@ async function closeoutAndStop(ctx, pi, s, deps, reason) {
  */
 export async function runPreDispatch(ic, loopState) {
     const { ctx, pi, s, deps, prefs } = ic;
+    const uokFlags = resolveUokFlags(prefs);
+    const runPreDispatchGate = async (input) => {
+        if (!uokFlags.gates)
+            return;
+        const gateRunner = new UokGateRunner();
+        gateRunner.register({
+            id: input.gateId,
+            type: input.gateType,
+            execute: async () => ({
+                outcome: input.outcome,
+                failureClass: input.failureClass,
+                rationale: input.rationale,
+                findings: input.findings ?? "",
+            }),
+        });
+        await gateRunner.run(input.gateId, {
+            basePath: s.basePath,
+            traceId: `pre-dispatch:${ic.flowId}`,
+            turnId: `iter-${ic.iteration}`,
+            milestoneId: input.milestoneId ?? s.currentMilestoneId ?? undefined,
+            unitType: "pre-dispatch",
+            unitId: `iter-${ic.iteration}`,
+        });
+    };
     // Resource version guard
     const staleMsg = deps.checkResourcesStale(s.resourceVersionOnStart);
     if (staleMsg) {
+        await runPreDispatchGate({
+            gateId: "resource-version-guard",
+            gateType: "policy",
+            outcome: "fail",
+            failureClass: "policy",
+            rationale: "resource version guard blocked dispatch",
+            findings: staleMsg,
+        });
         await deps.stopAuto(ctx, pi, staleMsg);
         debugLog("autoLoop", { phase: "exit", reason: "resources-stale" });
         return { action: "break", reason: "resources-stale" };
     }
+    await runPreDispatchGate({
+        gateId: "resource-version-guard",
+        gateType: "policy",
+        outcome: "pass",
+        failureClass: "none",
+        rationale: "resource version guard passed",
+    });
     deps.invalidateAllCaches();
     s.lastPromptCharCount = undefined;
     s.lastBaselineCharCount = undefined;
@@ -125,13 +241,37 @@ export async function runPreDispatch(ic, loopState) {
             ctx.ui.notify(`Pre-dispatch: ${healthGate.fixesApplied.join(", ")}`, "info");
         }
         if (!healthGate.proceed) {
+            await runPreDispatchGate({
+                gateId: "pre-dispatch-health-gate",
+                gateType: "execution",
+                outcome: "manual-attention",
+                failureClass: "manual-attention",
+                rationale: "pre-dispatch health gate blocked dispatch",
+                findings: healthGate.reason,
+            });
             ctx.ui.notify(healthGate.reason || "Pre-dispatch health check failed — run /gsd doctor for details.", "error");
             await deps.pauseAuto(ctx, pi);
             debugLog("autoLoop", { phase: "exit", reason: "health-gate-failed" });
             return { action: "break", reason: "health-gate-failed" };
         }
+        await runPreDispatchGate({
+            gateId: "pre-dispatch-health-gate",
+            gateType: "execution",
+            outcome: "pass",
+            failureClass: "none",
+            rationale: "pre-dispatch health gate passed",
+            findings: healthGate.fixesApplied.length > 0 ? healthGate.fixesApplied.join(", ") : "",
+        });
     }
     catch (e) {
+        await runPreDispatchGate({
+            gateId: "pre-dispatch-health-gate",
+            gateType: "execution",
+            outcome: "manual-attention",
+            failureClass: "manual-attention",
+            rationale: "pre-dispatch health gate threw unexpectedly",
+            findings: String(e),
+        });
         logWarning("engine", "Pre-dispatch health gate threw unexpectedly", { error: String(e) });
     }
     // Sync project root artifacts into worktree
@@ -142,6 +282,32 @@ export async function runPreDispatch(ic, loopState) {
     }
     // Derive state
     let state = await deps.deriveState(s.basePath);
+    if (prefs?.uok?.plan_v2?.enabled && shouldRunPlanV2Gate(state.phase)) {
+        const compiled = ensurePlanV2Graph(s.basePath, state);
+        if (!compiled.ok) {
+            const reason = compiled.reason ?? "Plan v2 compilation failed";
+            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}`, "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;
     let midTitle = state.activeMilestone?.title;
@@ -177,7 +343,10 @@ export async function runPreDispatch(ic, loopState) {
                         eligibleSlices: eligible.map(e => e.id),
                     });
                     ctx.ui.notify(`Slice-parallel: dispatching ${eligible.length} eligible slices for ${mid}.`, "info");
-                    const result = await startSliceParallel(s.basePath, mid, eligible, { maxWorkers: prefs.slice_parallel.max_workers ?? 2 });
+                    const result = await startSliceParallel(s.basePath, mid, eligible, {
+                        maxWorkers: prefs.slice_parallel.max_workers ?? 2,
+                        useExecutionGraph: uokFlags.executionGraph,
+                    });
                     if (result.started.length > 0) {
                         ctx.ui.notify(`Slice-parallel: started ${result.started.length} worker(s): ${result.started.join(", ")}.`, "info");
                         await deps.stopAuto(ctx, pi, `Slice-parallel dispatched for ${mid}`);
@@ -420,6 +589,15 @@ export async function runDispatch(ic, preData, loopState) {
     const { ctx, pi, s, deps, prefs } = ic;
     const { state, mid, midTitle } = preData;
     const STUCK_WINDOW_SIZE = 6;
+    const provider = ctx.model?.provider;
+    const authMode = provider && typeof ctx.modelRegistry?.getProviderAuthMode === "function"
+        ? ctx.modelRegistry.getProviderAuthMode(provider)
+        : undefined;
+    const activeTools = typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [];
+    const structuredQuestionsAvailable = supportsStructuredQuestions(activeTools, {
+        authMode,
+        baseUrl: ctx.model?.baseUrl,
+    }) ? "true" : "false";
     debugLog("autoLoop", { phase: "dispatch-resolve", iteration: ic.iteration });
     const dispatchResult = await deps.resolveDispatch({
         basePath: s.basePath,
@@ -428,6 +606,7 @@ export async function runDispatch(ic, preData, loopState) {
         state,
         prefs,
         session: s,
+        structuredQuestionsAvailable,
     });
     if (dispatchResult.action === "stop") {
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-stop", rule: dispatchResult.matchedRule, data: { reason: dispatchResult.reason } });
@@ -476,6 +655,18 @@ export async function runDispatch(ic, preData, loopState) {
                 loopState.stuckRecoveryAttempts++;
                 const artifactExists = verifyExpectedArtifact(unitType, unitId, s.basePath);
                 if (artifactExists) {
+                    if (unitType === "complete-milestone") {
+                        const stuckDiag = diagnoseExpectedArtifact(unitType, unitId, s.basePath);
+                        const stuckParts = [
+                            `Detected ${unitType} ${unitId} output on disk, but the same unit is still being derived.`,
+                            "This usually means the milestone summary exists while the DB row still does not mark the milestone complete.",
+                        ];
+                        if (stuckDiag)
+                            stuckParts.push(`Expected: ${stuckDiag}`);
+                        ctx.ui.notify(stuckParts.join(" "), "warning");
+                        await deps.pauseAuto(ctx, pi);
+                        return { action: "break", reason: "complete-milestone-artifact-db-mismatch" };
+                    }
                     debugLog("autoLoop", {
                         phase: "stuck-recovery",
                         level: 1,
@@ -776,7 +967,15 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.type === unitType &&
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
+    // Scope workflow-logger buffer to this unit so post-finalize drains are
+    // per-unit. Without this, the module-level _buffer accumulates across every
+    // unit in the same Node process (see workflow-logger.ts module header).
+    _resetLogs();
+    const dispatchKey = `${unitType}/${unitId}`;
+    s.unitDispatchCount.set(dispatchKey, (s.unitDispatchCount.get(dispatchKey) ?? 0) + 1);
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
+    s.lastGitActionFailure = null;
+    s.lastGitActionStatus = null;
     setCurrentPhase(unitType);
     s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
     const unitStartSeq = ic.nextSeq();
@@ -826,7 +1025,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         finalPrompt = `${capped}\n\n---\n\n${finalPrompt}`;
         s.pendingCrashRecovery = null;
     }
-    else if ((s.unitDispatchCount.get(`${unitType}/${unitId}`) ?? 0) > 1) {
+    else if ((s.unitDispatchCount.get(dispatchKey) ?? 0) > 1) {
         const diagnostic = deps.getDeepDiagnostic(s.basePath);
         if (diagnostic) {
             const cappedDiag = diagnostic.length > MAX_RECOVERY_CHARS
@@ -975,22 +1174,65 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         // Provider-error pause: pauseAuto already handled cleanup and scheduled
         // recovery. Don't hard-stop — just break out of the loop (#2762).
         if (unitResult.errorContext?.category === "provider") {
+            await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
             debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
             return { action: "break", reason: "provider-pause" };
         }
-        // Session creation timeout (not a structural error): pause auto-mode
-        // and let the provider-error-resume timer handle recovery (#3767). This
-        // matches the provider-pause path — break out cleanly, don't hard-stop.
+        // 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
         // 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") {
-            ctx.ui.notify(`Session creation timed out for ${unitType} ${unitId}. Pausing auto-mode (recoverable).`, "warning");
-            debugLog("autoLoop", { phase: "session-timeout-pause", unitType, unitId });
+            const isSessionCreationTimeout = unitResult.errorContext.message?.includes("Session creation timed out");
+            if (isSessionCreationTimeout) {
+                consecutiveSessionTimeouts += 1;
+                const baseRetryAfterMs = 30_000;
+                const retryAfterMs = baseRetryAfterMs * 2 ** Math.max(0, consecutiveSessionTimeouts - 1);
+                const allowAutoResume = consecutiveSessionTimeouts <= MAX_SESSION_TIMEOUT_AUTO_RESUMES;
+                if (!allowAutoResume) {
+                    ctx.ui.notify(`Session creation timed out ${consecutiveSessionTimeouts} consecutive times for ${unitType} ${unitId}. Pausing for manual review.`, "warning");
+                }
+                debugLog("autoLoop", {
+                    phase: "session-timeout-pause",
+                    unitType, unitId,
+                    consecutiveSessionTimeouts,
+                    retryAfterMs,
+                    allowAutoResume,
+                });
+                const errorDetail = ` for ${unitType} ${unitId}`;
+                await pauseAutoForProviderError(ctx.ui, errorDetail, () => deps.pauseAuto(ctx, pi), {
+                    isRateLimit: false,
+                    isTransient: allowAutoResume,
+                    retryAfterMs,
+                    resume: allowAutoResume
+                        ? () => {
+                            void resumeAutoAfterProviderDelay(pi, ctx).catch((err) => {
+                                const message = err instanceof Error ? err.message : String(err);
+                                ctx.ui.notify(`Session timeout recovery failed: ${message}`, "error");
+                            });
+                        }
+                        : undefined,
+                });
+                await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
+                await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
+                return { action: "break", reason: "session-timeout" };
+            }
+            // Unit hard timeout (30min+): pause without auto-resume — stuck agent
+            ctx.ui.notify(`Unit timed out for ${unitType} ${unitId} (supervision may have failed). Pausing auto-mode.`, "warning");
+            debugLog("autoLoop", { phase: "unit-hard-timeout-pause", unitType, unitId });
             await deps.pauseAuto(ctx, pi);
-            return { action: "break", reason: "session-timeout" };
+            await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
+            await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
+            return { action: "break", reason: "unit-hard-timeout" };
         }
         // All other cancelled states (structural errors, non-transient failures): hard stop
+        if (s.currentUnit) {
+            await deps.closeoutUnit(ctx, s.basePath, unitType, unitId, s.currentUnit.startedAt, deps.buildSnapshotOpts(unitType, unitId));
+        }
+        await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
+        await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
         ctx.ui.notify(`Session creation failed for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Stopping auto-mode.`, "warning");
         await deps.stopAuto(ctx, pi, `Session creation failed: ${unitResult.errorContext?.message ?? "unknown"}`);
         debugLog("autoLoop", { phase: "exit", reason: "session-failed" });
@@ -1002,6 +1244,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     // Guard: stopAuto() may have nulled s.currentUnit via s.reset() while
     // this coroutine was suspended at `await runUnit(...)` (#2939).
     if (s.currentUnit) {
+        // Reset session timeout counter — any successful unit clears the slate
+        consecutiveSessionTimeouts = 0;
         await deps.closeoutUnit(ctx, s.basePath, unitType, unitId, s.currentUnit.startedAt, deps.buildSnapshotOpts(unitType, unitId));
     }
     // ── Zero tool-call guard (#1833, #2653) ──────────────────────────
@@ -1035,7 +1279,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const artifactVerified = skipArtifactVerification ||
         verifyExpectedArtifact(unitType, unitId, s.basePath);
     if (artifactVerified) {
-        s.unitDispatchCount.delete(`${unitType}/${unitId}`);
+        s.unitDispatchCount.delete(dispatchKey);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
     // Write phase handoff anchor after successful research/planning completion
@@ -1120,33 +1364,19 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         : null;
     const preResultGuard = await withTimeout(deps.postUnitPreVerification(postUnitCtx, preVerificationOpts), FINALIZE_PRE_TIMEOUT_MS, "postUnitPreVerification");
     if (preResultGuard.timedOut) {
-        // Detach session from the timed-out unit so late async completions
-        // cannot mutate state for the next unit (#3757).
-        s.currentUnit = null;
-        clearCurrentPhase();
-        loopState.consecutiveFinalizeTimeouts++;
-        debugLog("autoLoop", {
-            phase: "pre-verification-timeout",
-            iteration: ic.iteration,
-            unitType: iterData.unitType,
-            unitId: iterData.unitId,
-            consecutiveTimeouts: loopState.consecutiveFinalizeTimeouts,
-        });
-        if (loopState.consecutiveFinalizeTimeouts >= MAX_FINALIZE_TIMEOUTS) {
-            ctx.ui.notify(`postUnitPreVerification timed out ${loopState.consecutiveFinalizeTimeouts} consecutive times — stopping auto-mode to prevent budget waste`, "error");
-            await deps.stopAuto(ctx, pi, `${loopState.consecutiveFinalizeTimeouts} consecutive finalize timeouts`);
-            return { action: "break", reason: "finalize-timeout-escalation" };
-        }
-        ctx.ui.notify(`postUnitPreVerification timed out after ${FINALIZE_PRE_TIMEOUT_MS / 1000}s for ${iterData.unitType} ${iterData.unitId} (${loopState.consecutiveFinalizeTimeouts}/${MAX_FINALIZE_TIMEOUTS}) — continuing to next iteration`, "warning");
-        return { action: "next", data: undefined };
+        return failClosedOnFinalizeTimeout(ic, iterData, loopState, "pre", preUnitSnapshot?.startedAt ?? Date.now());
     }
     const preResult = preResultGuard.value;
     if (preResult === "dispatched") {
+        const dispatchedReason = s.lastGitActionFailure
+            ? "git-closeout-failure"
+            : "pre-verification-dispatched";
         debugLog("autoLoop", {
             phase: "exit",
-            reason: "pre-verification-dispatched",
+            reason: dispatchedReason,
+            gitError: s.lastGitActionFailure ?? undefined,
         });
-        return { action: "break", reason: "pre-verification-dispatched" };
+        return { action: "break", reason: dispatchedReason };
     }
     if (preResult === "retry") {
         if (sidecarItem) {
@@ -1195,25 +1425,7 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     // auto-loop is not permanently frozen (#2344).
     const postResultGuard = await withTimeout(deps.postUnitPostVerification(postUnitCtx), FINALIZE_POST_TIMEOUT_MS, "postUnitPostVerification");
     if (postResultGuard.timedOut) {
-        // Detach session from the timed-out unit so late async completions
-        // cannot mutate state for the next unit (#3757).
-        s.currentUnit = null;
-        clearCurrentPhase();
-        loopState.consecutiveFinalizeTimeouts++;
-        debugLog("autoLoop", {
-            phase: "post-verification-timeout",
-            iteration: ic.iteration,
-            unitType: iterData.unitType,
-            unitId: iterData.unitId,
-            consecutiveTimeouts: loopState.consecutiveFinalizeTimeouts,
-        });
-        if (loopState.consecutiveFinalizeTimeouts >= MAX_FINALIZE_TIMEOUTS) {
-            ctx.ui.notify(`postUnitPostVerification timed out ${loopState.consecutiveFinalizeTimeouts} consecutive times — stopping auto-mode to prevent budget waste`, "error");
-            await deps.stopAuto(ctx, pi, `${loopState.consecutiveFinalizeTimeouts} consecutive finalize timeouts`);
-            return { action: "break", reason: "finalize-timeout-escalation" };
-        }
-        ctx.ui.notify(`postUnitPostVerification timed out after ${FINALIZE_POST_TIMEOUT_MS / 1000}s for ${iterData.unitType} ${iterData.unitId} (${loopState.consecutiveFinalizeTimeouts}/${MAX_FINALIZE_TIMEOUTS}) — continuing to next iteration`, "warning");
-        return { action: "next", data: undefined };
+        return failClosedOnFinalizeTimeout(ic, iterData, loopState, "post", preUnitSnapshot?.startedAt ?? Date.now());
     }
     const postResult = postResultGuard.value;
     if (postResult === "stopped") {
@@ -1230,5 +1442,15 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     }
     // Both pre and post verification completed without timeout — reset counter
     loopState.consecutiveFinalizeTimeouts = 0;
+    // Surface accumulated workflow-logger issues for this unit to the user.
+    // Warnings/errors logged during the unit are buffered in the logger and
+    // drained here so the user sees a single consolidated post-unit alert.
+    if (hasAnyIssues()) {
+        const { logs } = drainAndSummarize();
+        if (logs.length > 0) {
+            const severity = logs.some((e) => e.severity === "error") ? "error" : "warning";
+            ctx.ui.notify(formatForNotification(logs), severity);
+        }
+    }
     return { action: "next", data: undefined };
 }

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

@@ -60,7 +60,7 @@ export function isSessionSwitchInFlight() {
 /**
  * Force-resolve the pending unit promise with { status: "cancelled" }.
  *
- * Used by pauseAuto, handleAgentEnd early-return, and supervision catch
+ * Used by pauseAuto and supervision catch
  * blocks to ensure the autoLoop is never stuck awaiting a promise that
  * will never resolve. Safe to call when no resolver is pending (no-op).
  */

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

@@ -62,7 +62,16 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     if (s.currentUnitModel && typeof pi.setModel === "function") {
         const restored = await pi.setModel(s.currentUnitModel, { persist: false });
         if (!restored) {
-            ctx.ui.notify(`Failed to restore ${s.currentUnitModel.provider}/${s.currentUnitModel.id} after session creation. Using session default.`, "warning");
+            const message = `Failed to restore configured model ${s.currentUnitModel.provider}/${s.currentUnitModel.id} after session creation`;
+            ctx.ui.notify(`${message}. Cancelling unit before dispatch.`, "warning");
+            return {
+                status: "cancelled",
+                errorContext: {
+                    message,
+                    category: "session-failed",
+                    isTransient: false,
+                },
+            };
         }
     }
     // ── Create the agent_end promise (per-unit one-shot) ──

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

@@ -52,6 +52,8 @@ export class AutoSession {
     continueHereHandle = null;
     // ── Current unit ─────────────────────────────────────────────────────────
     currentUnit = null;
+    currentTraceId = null;
+    currentTurnId = null;
     currentUnitRouting = null;
     currentMilestoneId = null;
     // ── Model state ──────────────────────────────────────────────────────────
@@ -79,6 +81,10 @@ export class AutoSession {
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
     lastToolInvocationError = null;
+    /** Set when turn-level git action fails during closeout. */
+    lastGitActionFailure = null;
+    /** Last turn-level git action status captured during finalize. */
+    lastGitActionStatus = null;
     // ── Isolation degradation ────────────────────────────────────────────
     /** Set to true when worktree creation fails; prevents merge of nonexistent branch. */
     isolationDegraded = false;
@@ -101,6 +107,9 @@ export class AutoSession {
     checkpointSha = null;
     // ── Signal handler ───────────────────────────────────────────────────────
     sigtermHandler = null;
+    // ── Remote command polling ───────────────────────────────────────────────
+    /** Cleanup function returned by startCommandPolling(); null when not running. */
+    commandPollingCleanup = null;
     // ── Loop promise state ──────────────────────────────────────────────────
     // Per-unit resolve function and session-switch guard live at module level
     // in auto-loop.ts (_currentResolve, _sessionSwitchInFlight).
@@ -157,6 +166,8 @@ export class AutoSession {
         this.unitRecoveryCount.clear();
         // Unit
         this.currentUnit = null;
+        this.currentTraceId = null;
+        this.currentTurnId = null;
         this.currentUnitRouting = null;
         this.currentMilestoneId = null;
         // Model
@@ -185,11 +196,15 @@ export class AutoSession {
         this.rewriteAttemptCount = 0;
         this.consecutiveCompleteBootstraps = 0;
         this.lastToolInvocationError = null;
+        this.lastGitActionFailure = null;
+        this.lastGitActionStatus = null;
         this.isolationDegraded = false;
         this.milestoneMergedInPhases = false;
         this.checkpointSha = null;
         // Signal handler
         this.sigtermHandler = null;
+        // Remote command polling — cleanup must be called before reset (auto.ts stopAuto)
+        this.commandPollingCleanup = null;
         // Loop promise state lives in auto-loop.ts module scope
     }
     toJSON() {

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -29,6 +29,16 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             return dir ? join(dir, buildMilestoneFileName(mid, "ROADMAP")) : null;
         }
         case "research-slice": {
+            // #4414: Sentinel unitId "{mid}/parallel-research" fans out across
+            // multiple slices. Resolve to a milestone-level placeholder path so
+            // blocker escalation has somewhere to write. Verification for this
+            // sentinel is handled directly in verifyExpectedArtifact.
+            if (sid === "parallel-research") {
+                const mdir = resolveMilestonePath(base, mid);
+                return mdir
+                    ? join(mdir, buildMilestoneFileName(mid, "PARALLEL-BLOCKER"))
+                    : null;
+            }
             const dir = resolveSlicePath(base, mid, sid);
             return dir ? join(dir, buildSliceFileName(sid, "RESEARCH")) : null;
         }
@@ -36,6 +46,11 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             const dir = resolveSlicePath(base, mid, sid);
             return dir ? join(dir, buildSliceFileName(sid, "PLAN")) : null;
         }
+        case "refine-slice": {
+            // ADR-011: refine-slice expands a sketch and writes the same PLAN.md as plan-slice.
+            const dir = resolveSlicePath(base, mid, sid);
+            return dir ? join(dir, buildSliceFileName(sid, "PLAN")) : null;
+        }
         case "reassess-roadmap": {
             const dir = resolveSlicePath(base, mid, sid);
             return dir ? join(dir, buildSliceFileName(sid, "ASSESSMENT")) : null;
@@ -90,9 +105,14 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
         case "plan-milestone":
             return `${relMilestoneFile(base, mid, "ROADMAP")} (milestone roadmap)`;
         case "research-slice":
+            if (sid === "parallel-research") {
+                return `${relMilestoneFile(base, mid, "PARALLEL-BLOCKER")} (parallel slice research sentinel)`;
+            }
             return `${relSliceFile(base, mid, sid, "RESEARCH")} (slice research)`;
         case "plan-slice":
             return `${relSliceFile(base, mid, sid, "PLAN")} (slice plan)`;
+        case "refine-slice":
+            return `${relSliceFile(base, mid, sid, "PLAN")} (refined slice plan from sketch)`;
         case "execute-task": {
             return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid, "PLAN")} + summary written`;
         }