gsd-pi 2.74.0-dev.b741afb → 2.74.0-dev.b7c5f96

package/dist/resources/extensions/gsd/activity-log.js

@@ -13,6 +13,8 @@ import { join } from "node:path";
 import { GSDError, GSD_IO_ERROR } from "./errors.js";
 const SEQ_PREFIX_RE = /^(\d+)-/;
 import { gsdRoot } from "./paths.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 const activityLogState = new Map();
 /**
  * Clear accumulated activity log state (#611).
@@ -110,6 +112,20 @@ export function saveActivityLog(ctx, basePath, unitType, unitId) {
         }
         state.nextSeq += 1;
         state.lastSnapshotKeyByUnit.set(unitKey, key);
+        if (isUnifiedAuditEnabled()) {
+            emitUokAuditEvent(basePath, buildAuditEnvelope({
+                traceId: `activity:${unitType}:${unitId}`,
+                turnId: unitId,
+                category: "execution",
+                type: "activity-log-saved",
+                payload: {
+                    unitType,
+                    unitId,
+                    filePath,
+                    entryCount: entries.length,
+                },
+            }));
+        }
         return filePath;
     }
     catch (e) {

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

@@ -15,6 +15,8 @@ import { isInfrastructureError, isTransientCooldownError, getCooldownRetryAfterM
 import { resolveEngine } from "../engine-resolver.js";
 import { logWarning } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
+import { resolveUokFlags } from "../uok/flags.js";
+import { scheduleSidecarQueue } from "../uok/execution-graph.js";
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 // ── Stuck detection persistence (#3704) ──────────────────────────────────
@@ -104,6 +106,40 @@ export async function autoLoop(ctx, pi, s, deps) {
         const flowId = randomUUID();
         let seqCounter = 0;
         const nextSeq = () => ++seqCounter;
+        const turnId = randomUUID();
+        s.currentTraceId = flowId;
+        s.currentTurnId = turnId;
+        const turnStartedAt = new Date().toISOString();
+        let observedUnitType;
+        let observedUnitId;
+        let turnFinished = false;
+        const finishTurn = (status, failureClass = "none", error) => {
+            if (turnFinished)
+                return;
+            turnFinished = true;
+            deps.uokObserver?.onTurnResult({
+                traceId: flowId,
+                turnId,
+                iteration,
+                unitType: observedUnitType,
+                unitId: observedUnitId,
+                status,
+                failureClass,
+                phaseResults: [],
+                error,
+                startedAt: turnStartedAt,
+                finishedAt: new Date().toISOString(),
+            });
+            s.currentTraceId = null;
+            s.currentTurnId = null;
+        };
+        deps.uokObserver?.onTurnStart({
+            traceId: flowId,
+            turnId,
+            iteration,
+            basePath: s.basePath,
+            startedAt: turnStartedAt,
+        });
         if (iteration > MAX_LOOP_ITERATIONS) {
             debugLog("autoLoop", {
                 phase: "exit",
@@ -111,6 +147,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 iteration,
             });
             await deps.stopAuto(ctx, pi, `Safety: loop exceeded ${MAX_LOOP_ITERATIONS} iterations — possible runaway`);
+            finishTurn("stopped", "manual-attention", "max-iterations");
             break;
         }
         // ── Memory pressure check (#3331) ──
@@ -123,19 +160,30 @@ export async function autoLoop(ctx, pi, s, deps) {
                 await deps.stopAuto(ctx, pi, `Memory pressure: heap at ${mem.heapMB}MB / ${mem.limitMB}MB (${Math.round(mem.pct * 100)}%). ` +
                     `Stopping gracefully to prevent OOM kill after ${iteration} iterations. ` +
                     `Resume with /gsd auto to continue from where you left off.`);
+                finishTurn("stopped", "timeout", "memory-pressure");
                 break;
             }
         }
         if (!s.cmdCtx) {
             debugLog("autoLoop", { phase: "exit", reason: "no-cmdCtx" });
+            finishTurn("stopped", "manual-attention", "missing-command-context");
             break;
         }
         try {
             // ── Blanket try/catch: one bad iteration must not kill the session
             const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
+            const uokFlags = resolveUokFlags(prefs);
             // ── Check sidecar queue before deriveState ──
             let sidecarItem;
             if (s.sidecarQueue.length > 0) {
+                if (uokFlags.executionGraph && s.sidecarQueue.length > 1) {
+                    try {
+                        s.sidecarQueue = await scheduleSidecarQueue(s.sidecarQueue);
+                    }
+                    catch (err) {
+                        logWarning("dispatch", `sidecar queue scheduling failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
                 sidecarItem = s.sidecarQueue.shift();
                 debugLog("autoLoop", {
                     phase: "sidecar-dequeue",
@@ -210,25 +258,49 @@ export async function autoLoop(ctx, pi, s, deps) {
                     isRetry: false,
                     previousTier: undefined,
                 };
+                observedUnitType = iterData.unitType;
+                observedUnitId = iterData.unitId;
                 // ── Progress widget (mirrors dev path in runDispatch) ──
                 deps.updateProgressWidget(ctx, iterData.unitType, iterData.unitId, iterData.state);
                 // ── Guards (shared with dev path) ──
                 const guardsResult = await runGuards(ic, s.currentMilestoneId ?? "workflow");
-                if (guardsResult.action === "break")
+                deps.uokObserver?.onPhaseResult("guard", guardsResult.action, {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                });
+                if (guardsResult.action === "break") {
+                    finishTurn("stopped", "manual-attention", "guard-break");
                     break;
+                }
                 // ── Unit execution (shared with dev path) ──
                 const unitPhaseResult = await runUnitPhase(ic, iterData, loopState);
-                if (unitPhaseResult.action === "break")
+                deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                });
+                if (unitPhaseResult.action === "break") {
+                    finishTurn("stopped", "execution", "unit-break");
                     break;
+                }
                 // ── Verify first, then reconcile (only mark complete on pass) ──
                 debugLog("autoLoop", { phase: "custom-engine-verify", iteration, unitId: iterData.unitId });
                 const verifyResult = await policy.verify(iterData.unitType, iterData.unitId, { basePath: s.basePath });
                 if (verifyResult === "pause") {
                     await deps.pauseAuto(ctx, pi);
+                    deps.uokObserver?.onPhaseResult("custom-engine", "pause", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
+                    finishTurn("paused", "manual-attention", "custom-engine-verify-pause");
                     break;
                 }
                 if (verifyResult === "retry") {
                     debugLog("autoLoop", { phase: "custom-engine-verify-retry", iteration, unitId: iterData.unitId });
+                    deps.uokObserver?.onPhaseResult("custom-engine", "retry", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
+                    finishTurn("retry");
                     continue;
                 }
                 // Verification passed — mark step complete
@@ -248,37 +320,73 @@ export async function autoLoop(ctx, pi, s, deps) {
                 debugLog("autoLoop", { phase: "iteration-complete", iteration });
                 if (reconcileResult.outcome === "milestone-complete") {
                     await deps.stopAuto(ctx, pi, "Workflow complete");
+                    deps.uokObserver?.onPhaseResult("custom-engine", "milestone-complete", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
+                    finishTurn("completed");
                     break;
                 }
                 if (reconcileResult.outcome === "pause") {
                     await deps.pauseAuto(ctx, pi);
+                    deps.uokObserver?.onPhaseResult("custom-engine", "pause", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
+                    finishTurn("paused", "manual-attention");
                     break;
                 }
                 if (reconcileResult.outcome === "stop") {
                     await deps.stopAuto(ctx, pi, reconcileResult.reason ?? "Engine stopped");
+                    deps.uokObserver?.onPhaseResult("custom-engine", "stop", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                        reason: reconcileResult.reason,
+                    });
+                    finishTurn("stopped", "manual-attention", reconcileResult.reason);
                     break;
                 }
+                deps.uokObserver?.onPhaseResult("custom-engine", "continue", {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                });
+                finishTurn("completed");
                 continue;
             }
             if (!sidecarItem) {
                 // ── Phase 1: Pre-dispatch ─────────────────────────────────────────
                 const preDispatchResult = await runPreDispatch(ic, loopState);
-                if (preDispatchResult.action === "break")
+                deps.uokObserver?.onPhaseResult("pre-dispatch", preDispatchResult.action);
+                if (preDispatchResult.action === "break") {
+                    finishTurn("stopped", "manual-attention", "pre-dispatch-break");
                     break;
-                if (preDispatchResult.action === "continue")
+                }
+                if (preDispatchResult.action === "continue") {
+                    finishTurn("skipped");
                     continue;
+                }
                 const preData = preDispatchResult.data;
                 // ── Phase 2: Guards ───────────────────────────────────────────────
                 const guardsResult = await runGuards(ic, preData.mid);
-                if (guardsResult.action === "break")
+                deps.uokObserver?.onPhaseResult("guard", guardsResult.action);
+                if (guardsResult.action === "break") {
+                    finishTurn("stopped", "manual-attention", "guard-break");
                     break;
+                }
                 // ── Phase 3: Dispatch ─────────────────────────────────────────────
                 const dispatchResult = await runDispatch(ic, preData, loopState);
-                if (dispatchResult.action === "break")
+                deps.uokObserver?.onPhaseResult("dispatch", dispatchResult.action);
+                if (dispatchResult.action === "break") {
+                    finishTurn("stopped", "manual-attention", "dispatch-break");
                     break;
-                if (dispatchResult.action === "continue")
+                }
+                if (dispatchResult.action === "continue") {
+                    finishTurn("skipped");
                     continue;
+                }
                 iterData = dispatchResult.data;
+                observedUnitType = iterData.unitType;
+                observedUnitId = iterData.unitId;
             }
             else {
                 // ── Sidecar path: use values from the sidecar item directly ──
@@ -294,21 +402,46 @@ export async function autoLoop(ctx, pi, s, deps) {
                     midTitle: sidecarState.activeMilestone?.title,
                     isRetry: false, previousTier: undefined,
                 };
+                observedUnitType = iterData.unitType;
+                observedUnitId = iterData.unitId;
+                deps.uokObserver?.onPhaseResult("dispatch", "sidecar", {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                    sidecarKind: sidecarItem.kind,
+                });
             }
             const unitPhaseResult = await runUnitPhase(ic, iterData, loopState, sidecarItem);
-            if (unitPhaseResult.action === "break")
+            deps.uokObserver?.onPhaseResult("unit", unitPhaseResult.action, {
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            });
+            if (unitPhaseResult.action === "break") {
+                finishTurn("stopped", "execution", "unit-break");
                 break;
+            }
             // ── Phase 5: Finalize ───────────────────────────────────────────────
             const finalizeResult = await runFinalize(ic, iterData, loopState, sidecarItem);
-            if (finalizeResult.action === "break")
+            deps.uokObserver?.onPhaseResult("finalize", finalizeResult.action, {
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            });
+            if (finalizeResult.action === "break") {
+                const finalizeFailureClass = finalizeResult.reason === "git-closeout-failure"
+                    ? "git"
+                    : "closeout";
+                finishTurn("stopped", finalizeFailureClass, "finalize-break");
                 break;
-            if (finalizeResult.action === "continue")
+            }
+            if (finalizeResult.action === "continue") {
+                finishTurn("retry");
                 continue;
+            }
             consecutiveErrors = 0; // Iteration completed successfully
             consecutiveCooldowns = 0;
             recentErrorMessages.length = 0;
             deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
             debugLog("autoLoop", { phase: "iteration-complete", iteration });
+            finishTurn("completed");
         }
         catch (loopErr) {
             // ── Blanket catch: absorb unexpected exceptions, apply graduated recovery ──
@@ -330,6 +463,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 });
                 ctx.ui.notify(`Auto-mode stopped: infrastructure error ${infraCode} — ${msg}`, "error");
                 await deps.stopAuto(ctx, pi, `Infrastructure error (${infraCode}): not recoverable by retry`);
+                finishTurn("failed", "execution", msg);
                 break;
             }
             // ── Credential cooldown: wait and retry with bounded budget ──
@@ -358,6 +492,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     : COOLDOWN_FALLBACK_WAIT_MS;
                 ctx.ui.notify(`Credentials in cooldown (${consecutiveCooldowns}/${MAX_COOLDOWN_RETRIES}) — waiting ${Math.round(waitMs / 1000)}s before retrying.`, "warning");
                 await new Promise(resolve => setTimeout(resolve, waitMs));
+                finishTurn("retry", "timeout", msg);
                 continue; // Retry iteration without incrementing consecutiveErrors
             }
             consecutiveErrors++;
@@ -375,6 +510,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                     .join("\n");
                 ctx.ui.notify(`Auto-mode stopped: ${consecutiveErrors} consecutive iteration failures:\n${errorHistory}`, "error");
                 await deps.stopAuto(ctx, pi, `${consecutiveErrors} consecutive iteration failures`);
+                finishTurn("failed", "execution", msg);
                 break;
             }
             else if (consecutiveErrors === 2) {
@@ -386,6 +522,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 // 1st error: log and retry — transient failures happen
                 ctx.ui.notify(`Iteration error: ${msg}. Retrying.`, "warning");
             }
+            finishTurn("retry", "execution", msg);
         }
     }
     _clearCurrentResolve();

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

@@ -14,6 +14,8 @@ 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, _resetLogs, drainLogs, drainAndSummarize, formatForNotification, hasAnyIssues, } from "../workflow-logger.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";
+// ─── 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.
@@ -124,13 +144,52 @@ async function emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, errorCon
  */
 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;
@@ -141,13 +200,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
@@ -158,6 +241,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;
@@ -193,7 +302,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}`);
@@ -797,6 +909,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     // unit in the same Node process (see workflow-logger.ts module header).
     _resetLogs();
     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();
@@ -999,19 +1113,54 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             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);
             await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
             await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
-            return { action: "break", reason: "session-timeout" };
+            return { action: "break", reason: "unit-hard-timeout" };
         }
         // All other cancelled states (structural errors, non-transient failures): hard stop
         if (s.currentUnit) {
@@ -1030,6 +1179,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) ──────────────────────────
@@ -1173,11 +1324,15 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     }
     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) {

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;
@@ -157,6 +163,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,6 +193,8 @@ 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;