gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.2e8b124f7

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Main auto-mode execution loop.
 /**
  * auto/loop.ts — Main auto-mode execution loop.
  *
@@ -35,7 +37,7 @@ import { createWorkflowTurnReporter } from "./workflow-turn-reporter.js";
 import { validateWorkflowSessionLock } from "./workflow-session-lock.js";
 import { dequeueSidecarItem } from "./workflow-sidecar-queue.js";
 import { maintainWorkerHeartbeat } from "./workflow-worker-heartbeat.js";
-import { measureMemoryPressure } from "./workflow-memory-pressure.js";
+import { measureMemoryPressure, shouldCheckMemoryPressure, } from "./workflow-memory-pressure.js";
 import { buildSidecarIterationData } from "./workflow-sidecar-iteration.js";
 import { createExecutionGraphUnitDispatchDeps, runUnitPhaseViaContract, } from "./workflow-unit-dispatch.js";
 import { handleCustomEngineDispatchOutcome } from "./workflow-custom-engine-dispatch-outcome.js";
@@ -130,9 +132,9 @@ function logCustomVerifyRetrySaveFailure(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).
+// Check heap usage on session startup, then 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 MAX_CUSTOM_ENGINE_VERIFY_RETRIES = 3;
 async function enforceMinRequestInterval(s, prefs) {
@@ -184,6 +186,9 @@ export async function autoLoop(ctx, pi, s, deps, options) {
         recentUnits: persisted.recentUnits,
         stuckRecoveryAttempts: persisted.stuckRecoveryAttempts,
         consecutiveFinalizeTimeouts: 0,
+        consecutiveDispatchCount: new Map(),
+        lastDispatchedKey: null,
+        lastDispatchPhase: null,
     };
     let consecutiveErrors = 0;
     let consecutiveCooldowns = 0;
@@ -262,7 +267,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
         }
         // ── Memory pressure check (#3331) ──
         // Graceful shutdown before OOM killer sends SIGKILL.
-        if (iteration % MEMORY_CHECK_INTERVAL === 0) {
+        if (shouldCheckMemoryPressure(iteration, MEMORY_CHECK_INTERVAL)) {
             const mem = measureMemoryPressure();
             debugLog("autoLoop", { phase: "memory-check", ...mem });
             const memoryDecision = decideMemoryPressure({ ...mem, iteration });
@@ -307,9 +312,11 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 logIterationComplete: () => debugLog("autoLoop", { phase: "iteration-complete", iteration }),
             });
         };
+        let stuckStatePersistedThisIteration = false;
         const finishIncompleteIteration = (details) => {
             emitIterationEnd(details);
             saveStuckState(s, loopState);
+            stuckStatePersistedThisIteration = true;
         };
         try {
             // ── Blanket try/catch: one bad iteration must not kill the session
@@ -596,39 +603,87 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 continue;
             }
             if (!sidecarItem) {
-                // ── Phase 1: Pre-dispatch ─────────────────────────────────────────
-                const preDispatchResult = await runPreDispatch(ic, loopState);
-                phaseReporter.report("pre-dispatch", preDispatchResult.action);
-                if (preDispatchResult.action === "break") {
-                    finishTurn("stopped", "manual-attention", "pre-dispatch-break");
-                    break;
-                }
-                if (preDispatchResult.action === "continue") {
-                    finishTurn("skipped");
-                    continue;
-                }
-                const preData = preDispatchResult.data;
-                // ── Phase 2: Guards ───────────────────────────────────────────────
-                const guardsResult = await runGuards(ic, preData.mid);
-                phaseReporter.report("guard", guardsResult.action);
-                if (guardsResult.action === "break") {
-                    finishTurn("stopped", "manual-attention", "guard-break");
-                    break;
-                }
-                // ── Phase 3: Dispatch ─────────────────────────────────────────────
-                const dispatchResult = await runDispatch(ic, preData, loopState);
-                phaseReporter.report("dispatch", dispatchResult.action);
-                if (dispatchResult.action === "break") {
-                    finishTurn("stopped", "manual-attention", "dispatch-break");
-                    break;
+                const orchestration = s.orchestration;
+                if (orchestration) {
+                    const orchestrationResult = await orchestration.advance();
+                    if (orchestrationResult.kind === "blocked") {
+                        s.pendingOrchestrationDispatch = null;
+                        if (orchestrationResult.action === "pause") {
+                            await deps.pauseAuto(ctx, pi, {
+                                message: orchestrationResult.reason,
+                                category: "unknown",
+                            });
+                        }
+                        else {
+                            await deps.stopAuto(ctx, pi, orchestrationResult.reason);
+                        }
+                        finishTurn("stopped", "manual-attention", "orchestration-blocked");
+                        break;
+                    }
+                    if (orchestrationResult.kind === "stopped") {
+                        s.pendingOrchestrationDispatch = null;
+                        await deps.stopAuto(ctx, pi, orchestrationResult.reason);
+                        finishTurn("stopped", "manual-attention", "orchestration-stopped");
+                        break;
+                    }
+                    if (orchestrationResult.kind !== "advanced") {
+                        s.pendingOrchestrationDispatch = null;
+                        finishTurn("skipped");
+                        continue;
+                    }
+                    const pendingDispatch = s.pendingOrchestrationDispatch;
+                    iterData = {
+                        unitType: pendingDispatch?.unitType ?? orchestrationResult.unit.unitType,
+                        unitId: pendingDispatch?.unitId ?? orchestrationResult.unit.unitId,
+                        prompt: pendingDispatch?.prompt ?? "",
+                        finalPrompt: pendingDispatch?.prompt ?? "",
+                        pauseAfterUatDispatch: pendingDispatch?.pauseAfterUatDispatch ?? false,
+                        state: pendingDispatch?.state ?? orchestrationResult.stateSnapshot,
+                        mid: pendingDispatch?.mid ?? s.currentMilestoneId ?? "workflow",
+                        midTitle: pendingDispatch?.midTitle ?? orchestrationResult.stateSnapshot.activeMilestone?.title ?? "Workflow",
+                        isRetry: false,
+                        previousTier: undefined,
+                    };
+                    s.pendingOrchestrationDispatch = null;
+                    phaseReporter.report("dispatch", "next", {
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
+                    observedUnitType = iterData.unitType;
+                    observedUnitId = iterData.unitId;
                 }
-                if (dispatchResult.action === "continue") {
-                    finishTurn("skipped");
-                    continue;
+                else {
+                    const preDispatchResult = await runPreDispatch(ic, loopState);
+                    phaseReporter.report("pre-dispatch", preDispatchResult.action);
+                    if (preDispatchResult.action === "break") {
+                        finishTurn("stopped", "manual-attention", "pre-dispatch-break");
+                        break;
+                    }
+                    if (preDispatchResult.action === "continue") {
+                        finishTurn("skipped");
+                        continue;
+                    }
+                    const preData = preDispatchResult.data;
+                    const guardsResult = await runGuards(ic, preData.mid);
+                    phaseReporter.report("guard", guardsResult.action);
+                    if (guardsResult.action === "break") {
+                        finishTurn("stopped", "manual-attention", "guard-break");
+                        break;
+                    }
+                    const dispatchResult = await runDispatch(ic, preData, loopState);
+                    phaseReporter.report("dispatch", dispatchResult.action);
+                    if (dispatchResult.action === "break") {
+                        finishTurn("stopped", "manual-attention", "dispatch-break");
+                        break;
+                    }
+                    if (dispatchResult.action === "continue") {
+                        finishTurn("skipped");
+                        continue;
+                    }
+                    iterData = dispatchResult.data;
+                    observedUnitType = iterData.unitType;
+                    observedUnitId = iterData.unitId;
                 }
-                iterData = dispatchResult.data;
-                observedUnitType = iterData.unitType;
-                observedUnitId = iterData.unitId;
             }
             else {
                 iterData = await buildSidecarIterationData({
@@ -789,11 +844,18 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 unitId: iterData.unitId,
             });
             const finalizeReason = finalizeResult.action === "break" ? finalizeResult.reason : undefined;
+            const finalizeStatus = finalizeReason === "step-wizard"
+                ? "completed"
+                : finalizeResult.action === "next"
+                    ? "completed"
+                    : finalizeResult.action === "continue"
+                        ? "retry"
+                        : "stopped";
             journalReporter.emit("post-unit-finalize-end", {
                 iteration,
                 unitType: iterData.unitType,
                 unitId: iterData.unitId,
-                status: finalizeResult.action === "next" ? "completed" : finalizeResult.action === "continue" ? "retry" : "stopped",
+                status: finalizeStatus,
                 action: finalizeResult.action,
                 ...(finalizeReason ? { reason: finalizeReason } : {}),
             });
@@ -825,6 +887,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 finishIncompleteIteration({
                     status: "retry",
                     reason: "finalize-retry",
+                    retry: true,
                     unitType: iterData.unitType,
                     unitId: iterData.unitId,
                 });
@@ -836,7 +899,12 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 logWriteFailure: logDispatchLedgerWriteFailure,
             }) || dispatchSettled;
             completeIteration();
+            stuckStatePersistedThisIteration = true;
             finishTurn("completed");
+            if (finalizeDecision.action === "complete-and-break") {
+                s.preserveStepSurfaceAfterLoopExit = true;
+                break;
+            }
         }
         catch (loopErr) {
             // ── Blanket catch: absorb unexpected exceptions, apply graduated recovery ──
@@ -974,6 +1042,11 @@ export async function autoLoop(ctx, pi, s, deps, options) {
             }
             finishTurn(errorDecision.turnStatus, "execution", msg);
         }
+        finally {
+            if (!stuckStatePersistedThisIteration) {
+                saveStuckState(s, loopState);
+            }
+        }
     }
     _clearCurrentResolve();
     debugLog("autoLoop", { phase: "exit", totalIterations: iteration });

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

@@ -45,7 +45,7 @@ export class AutoOrchestrator {
                     rationale: "resource version guard blocked dispatch",
                     findings: staleMsg,
                 });
-                const blocked = { kind: "blocked", reason: staleMsg, action: "stop" };
+                const blocked = { kind: "blocked", reason: staleMsg, action: "pause" };
                 await this.deps.runtime.journalTransition({ name: "advance-blocked", reason: blocked.reason });
                 await this.deps.health.postAdvanceRecord(blocked);
                 return blocked;
@@ -117,6 +117,17 @@ export class AutoOrchestrator {
                 await this.deps.health.postAdvanceRecord(stopped);
                 return stopped;
             }
+            if (!("unitType" in decision)) {
+                const blocked = {
+                    kind: "blocked",
+                    reason: decision.reason,
+                    action: decision.action,
+                    stateSnapshot: reconciliation.stateSnapshot,
+                };
+                await this.deps.runtime.journalTransition({ name: "advance-blocked", reason: blocked.reason });
+                await this.deps.health.postAdvanceRecord(blocked);
+                return blocked;
+            }
             const nextKey = `${decision.unitType}:${decision.unitId}`;
             // Record every dispatch decision in the ring buffer before pre-flight
             // checks so the stuck-loop detector observes the full decision history
@@ -134,7 +145,7 @@ export class AutoOrchestrator {
             // stuck-loop for the saturated-window case.
             const matchingCount = this.dispatchKeyWindow.filter((k) => k === nextKey).length;
             if (this.lastAdvanceKey === nextKey && matchingCount < STUCK_WINDOW_SIZE) {
-                const blocked = { kind: "blocked", reason: "idempotent advance: unit already active", action: "stop" };
+                const blocked = { kind: "blocked", reason: "idempotent advance: unit already active", action: "pause" };
                 await this.deps.runtime.journalTransition({
                     name: "advance-blocked",
                     reason: blocked.reason,

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

@@ -44,6 +44,8 @@ import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule } from "../worktree-safety.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
 import { decideVerificationRetry, verificationRetryKey } from "./verification-retry-policy.js";
+import { buildPhaseHandoffOutcome, setAutoOutcomeWidget } from "../auto-dashboard.js";
+import { getConsecutiveDispatchBlocker } from "../dispatch-guard.js";
 // ─── Path Comparison Helper ───────────────────────────────────────────────
 /** Compare two paths for physical identity, tolerating trailing slashes and symlinks. */
 function isSamePathLocal(a, b) {
@@ -103,6 +105,12 @@ function unitWritesSource(unitType) {
 function formatWorktreeSafetyFailure(result) {
     return `Worktree Safety failed (${result.kind}): ${result.reason} ${result.remediation}`;
 }
+function formatWorktreeSafetyStopReason(result) {
+    if (result.kind === "empty-worktree-with-project-content") {
+        return `Worktree Safety failed (${result.kind}). Run /gsd doctor fix, then /gsd auto.`;
+    }
+    return `Worktree Safety failed (${result.kind}).`;
+}
 function resolveEmptyWorktreeWithProjectContent(unitRoot, projectRoot) {
     if (isSamePathLocal(unitRoot, projectRoot))
         return false;
@@ -176,7 +184,7 @@ async function validateSourceWriteWorktreeSafety(ic, unitType, unitId, milestone
         projectRoot,
     });
     ctx.ui.notify(msg, "error");
-    await deps.stopAuto(ctx, pi, msg);
+    await deps.stopAuto(ctx, pi, formatWorktreeSafetyStopReason(result));
     return { action: "break", reason: result.kind };
 }
 // ─── Session timeout auto-resume state ────────────────────────────────────────
@@ -383,6 +391,9 @@ export function _buildCancelledUnitStopReason(unitType, unitId, errorContext) {
         loopReason: "unit-aborted",
     };
 }
+export function _isPauseOriginCancelledResult(isPaused, errorContext) {
+    return isPaused && !errorContext;
+}
 async function failClosedOnFinalizeTimeout(ic, iterData, loopState, stage, startedAt) {
     const { ctx, pi, s, deps } = ic;
     const now = Date.now();
@@ -968,12 +979,25 @@ export async function runDispatch(ic, preData, loopState) {
         prompt = preDispatchResult.prompt;
     }
     const guardBasePath = _resolveDispatchGuardBasePath(s);
-    const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(guardBasePath, deps.getMainBranch(guardBasePath), unitType, unitId);
+    let mainBranch = "main";
+    try {
+        mainBranch = deps.getMainBranch(guardBasePath);
+    }
+    catch (err) {
+        debugLog("autoLoop", { phase: "getMainBranch-failed", error: String(err) });
+    }
+    const priorSliceBlocker = deps.getPriorSliceCompletionBlocker(guardBasePath, mainBranch, unitType, unitId);
     if (priorSliceBlocker) {
         await deps.stopAuto(ctx, pi, priorSliceBlocker);
         debugLog("autoLoop", { phase: "exit", reason: "prior-slice-blocker" });
         return { action: "break", reason: "prior-slice-blocker" };
     }
+    const consecutiveDispatchBlocker = getConsecutiveDispatchBlocker(loopState, state.phase, unitType, unitId);
+    if (consecutiveDispatchBlocker) {
+        await deps.stopAuto(ctx, pi, consecutiveDispatchBlocker);
+        debugLog("autoLoop", { phase: "exit", reason: "consecutive-dispatch-blocker" });
+        return { action: "break", reason: "consecutive-dispatch-blocker" };
+    }
     const worktreeSafetyBlock = await validateSourceWriteWorktreeSafety(ic, unitType, unitId, mid, "pre-dispatch");
     if (worktreeSafetyBlock)
         return worktreeSafetyBlock;
@@ -1030,7 +1054,6 @@ export async function runDispatch(ic, preData, loopState) {
                 ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
                 deps.invalidateAllCaches();
                 loopState.recentUnits.length = 0;
-                loopState.stuckRecoveryAttempts = 0;
                 return { action: "continue" };
             }
             ctx.ui.notify(`Stuck on ${unitType} ${unitId} (${stuckSignal.reason}). Invalidating caches and retrying.`, "warning");
@@ -1324,35 +1347,8 @@ 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;
-    s.lastUnitAgentEndMessages = null;
-    setCurrentPhase(unitType, {
-        basePath: s.basePath,
-        traceId: ic.flowId,
-        turnId: `iter-${ic.iteration}`,
-        causedBy: "unit-start",
-    });
-    s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
-    const unitStartSeq = ic.nextSeq();
-    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
-    deps.captureAvailableSkills();
-    writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
-        phase: "dispatched",
-        wrapupWarningSent: false,
-        timeoutAt: null,
-        lastProgressAt: s.currentUnit.startedAt,
-        progressCount: 0,
-        lastProgressKind: "dispatch",
-        recoveryAttempts: 0, // Reset so re-dispatched units get full recovery budget (#2322)
-    });
+    const nextDispatchCount = (s.unitDispatchCount.get(dispatchKey) ?? 0) + 1;
     // Status bar (widget + preconditions deferred until after model selection — see #2899)
     ctx.ui.setStatus("gsd-auto", "auto");
     if (mid)
@@ -1406,7 +1402,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         finalPrompt = `${capped}\n\n---\n\n${finalPrompt}`;
         s.pendingCrashRecovery = null;
     }
-    else if ((s.unitDispatchCount.get(dispatchKey) ?? 0) > 1) {
+    else if (nextDispatchCount > 1) {
         const diagnostic = deps.getDeepDiagnostic(s.basePath);
         if (diagnostic) {
             const cappedDiag = diagnostic.length > MAX_RECOVERY_CHARS
@@ -1445,6 +1441,11 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         logWarning("engine", "Prompt reorder failed", { error: msg });
     }
     // Select and apply model (with tier escalation on retry — normal units only)
+    const prevUnitRouting = s.currentUnitRouting;
+    const prevUnitModel = s.currentUnitModel;
+    const prevDispatchedModelId = s.currentDispatchedModelId;
+    const prevSessionModel = ctx.model;
+    const prevSessionThinkingLevel = pi.getThinkingLevel();
     const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier }, undefined, s.manualSessionModelOverride, s.autoModeStartThinkingLevel);
     s.currentUnitRouting =
         modelResult.routing;
@@ -1488,12 +1489,58 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                 ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
                 : undefined,
         baseUrl: s.currentUnitModel?.baseUrl ?? ctx.model?.baseUrl,
+        activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
     });
     if (compatibilityError) {
+        s.currentUnitRouting = prevUnitRouting;
+        s.currentUnitModel = prevUnitModel;
+        s.currentDispatchedModelId = prevDispatchedModelId;
+        if (s.checkpointSha) {
+            cleanupCheckpoint(s.basePath, unitId);
+            s.checkpointSha = null;
+        }
+        if (prevSessionModel) {
+            const ok = await pi.setModel(prevSessionModel, { persist: false });
+            if (!ok) {
+                ctx.ui.notify("Failed to restore previous session model after compatibility check failure.", "warning");
+            }
+            if (prevSessionThinkingLevel) {
+                pi.setThinkingLevel(prevSessionThinkingLevel);
+            }
+        }
         ctx.ui.notify(compatibilityError, "error");
         await deps.stopAuto(ctx, pi, compatibilityError);
         return { action: "break", reason: "workflow-capability" };
     }
+    // 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 unitStartedAt = Date.now();
+    s.unitDispatchCount.set(dispatchKey, nextDispatchCount);
+    s.currentUnit = { type: unitType, id: unitId, startedAt: unitStartedAt };
+    s.lastGitActionFailure = null;
+    s.lastGitActionStatus = null;
+    s.lastUnitAgentEndMessages = null;
+    setCurrentPhase(unitType, {
+        basePath: s.basePath,
+        traceId: ic.flowId,
+        turnId: `iter-${ic.iteration}`,
+        causedBy: "unit-start",
+    });
+    s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
+    const unitStartSeq = ic.nextSeq();
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
+    deps.captureAvailableSkills();
+    writeUnitRuntimeRecord(s.basePath, unitType, unitId, unitStartedAt, {
+        phase: "dispatched",
+        wrapupWarningSent: false,
+        timeoutAt: null,
+        lastProgressAt: unitStartedAt,
+        progressCount: 0,
+        lastProgressKind: "dispatch",
+        recoveryAttempts: 0, // Reset so re-dispatched units get full recovery budget (#2322)
+    });
     // Progress widget + preconditions — deferred to after model selection so the
     // widget's first render tick shows the correct model (#2899).
     deps.updateProgressWidget(ctx, unitType, unitId, state);
@@ -1579,6 +1626,10 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
     }
     if (unitResult.status === "cancelled") {
+        if (_isPauseOriginCancelledResult(s.paused, unitResult.errorContext)) {
+            debugLog("autoLoop", { phase: "cancelled-after-pause", unitType, unitId });
+            return { action: "break", reason: "paused" };
+        }
         const errorCategory = unitResult.errorContext?.category;
         // Provider-error pause: agent_end recovery normally pauses before this
         // branch. Provider readiness failures happen before dispatch, so pause here
@@ -1720,12 +1771,12 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             }
         }
     }
-    if (s.currentUnitRouting) {
-        deps.recordOutcome(unitType, s.currentUnitRouting.tier, true);
-    }
     const skipArtifactVerification = unitType.startsWith("hook/") || unitType === "custom-step";
     const artifactVerified = skipArtifactVerification ||
         verifyExpectedArtifact(unitType, unitId, s.basePath);
+    if (s.currentUnitRouting) {
+        deps.recordOutcome(unitType, s.currentUnitRouting.tier, artifactVerified);
+    }
     if (artifactVerified) {
         s.unitDispatchCount.delete(dispatchKey);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
@@ -1749,7 +1800,10 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             logWarning("engine", `phase anchor failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified, ...(unitResult.errorContext ? { errorContext: unitResult.errorContext } : {}) }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
+    const unitEndStatus = !artifactVerified && unitResult.status === "completed"
+        ? "no-artifact"
+        : unitResult.status;
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitEndStatus, artifactVerified, ...(unitResult.errorContext ? { errorContext: unitResult.errorContext } : {}) }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
     // ── Safety harness: checkpoint cleanup or rollback ──
     if (s.checkpointSha) {
         if (unitResult.status === "error" && safetyConfig.auto_rollback) {
@@ -1810,6 +1864,8 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     const preUnitSnapshot = s.currentUnit
         ? { type: s.currentUnit.type, id: s.currentUnit.id, startedAt: s.currentUnit.startedAt }
         : null;
+    s.currentUnit = null;
+    clearCurrentPhase();
     const preResultGuard = await withTimeout(deps.postUnitPreVerification(postUnitCtx, preVerificationOpts), FINALIZE_PRE_TIMEOUT_MS, "postUnitPreVerification");
     if (preResultGuard.timedOut) {
         return failClosedOnFinalizeTimeout(ic, iterData, loopState, "pre", preUnitSnapshot?.startedAt ?? Date.now());
@@ -1923,9 +1979,19 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
             lastProgressAt: Date.now(),
             lastProgressKind: "finalize-success",
         });
+        if (!preUnitSnapshot.type.startsWith("hook/") &&
+            preUnitSnapshot.type !== "custom-step" &&
+            preUnitSnapshot.type !== "complete-milestone") {
+            setAutoOutcomeWidget(ctx, {
+                ...buildPhaseHandoffOutcome({
+                    unitType: preUnitSnapshot.type,
+                    unitId: preUnitSnapshot.id,
+                    agentEndMessages: s.lastUnitAgentEndMessages,
+                }),
+                startedAt: s.autoStartTime,
+            });
+        }
     }
-    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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Mutable auto-mode session state container.
 /**
  * AutoSession — encapsulates all mutable auto-mode state into a single instance.
  *
@@ -26,6 +28,7 @@ export class AutoSession {
     active = false;
     paused = false;
     completionStopInProgress = false;
+    preserveStepSurfaceAfterLoopExit = false;
     stepMode = false;
     verbose = false;
     activeEngineId = null;
@@ -159,6 +162,7 @@ export class AutoSession {
     commandPollingCleanup = null;
     // ── Orchestration seam ───────────────────────────────────────────────────
     orchestration = null;
+    pendingOrchestrationDispatch = null;
     // ── Loop promise state ──────────────────────────────────────────────────
     // Per-unit resolve function and session-switch guard live at module level
     // in auto-loop.ts (_currentResolve, _sessionSwitchInFlight).
@@ -210,6 +214,7 @@ export class AutoSession {
         this.active = false;
         this.paused = false;
         this.completionStopInProgress = false;
+        this.preserveStepSurfaceAfterLoopExit = false;
         this.stepMode = false;
         this.verbose = false;
         this.activeEngineId = null;
@@ -284,6 +289,7 @@ export class AutoSession {
         this.commandPollingCleanup = null;
         // Orchestration seam
         this.orchestration = null;
+        this.pendingOrchestrationDispatch = null;
         // Loop promise state lives in auto-loop.ts module scope
     }
     resetAfterStop(options = {}) {

package/dist/resources/extensions/gsd/auto/unit-runner-events.js

@@ -3,5 +3,11 @@ export function isInternalSessionTransitionAbortEvent(event) {
     return event.abortOrigin === "session-transition";
 }
 export function shouldIgnoreAgentEndForActiveUnit(event) {
-    return isInternalSessionTransitionAbortEvent(event);
+    if (!isInternalSessionTransitionAbortEvent(event))
+        return false;
+    const lastMsg = event.messages[event.messages.length - 1];
+    if (!lastMsg || typeof lastMsg !== "object")
+        return true;
+    const stopReason = lastMsg.stopReason;
+    return stopReason === "aborted" || stopReason === "error";
 }

package/dist/resources/extensions/gsd/auto/workflow-kernel.js

@@ -66,6 +66,9 @@ export function decideEngineDispatch(input) {
 export function decideFinalizeResult(input) {
     if (input.action === "break") {
         const reason = input.reason ?? "unknown";
+        if (reason === "step-wizard") {
+            return { action: "complete-and-break" };
+        }
         return {
             action: "stop",
             failureClass: reason === "git-closeout-failure" ? "git" : "closeout",

package/dist/resources/extensions/gsd/auto/workflow-memory-pressure.js

@@ -4,6 +4,18 @@ import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const DEFAULT_MEMORY_PRESSURE_THRESHOLD = 0.85;
 const DEFAULT_HEAP_LIMIT_MB = 4096;
+/**
+ * Returns true on auto-mode startup, then every configured interval.
+ *
+ * Iteration 1 is checked explicitly so early session memory pressure cannot
+ * bypass the periodic interval guard.
+ */
+export function shouldCheckMemoryPressure(iteration, interval) {
+    if (!Number.isInteger(interval) || interval <= 0) {
+        throw new Error("Memory pressure check interval must be a positive integer");
+    }
+    return iteration === 1 || iteration % interval === 0;
+}
 function defaultHeapLimitBytes() {
     const v8 = require("node:v8");
     const limit = v8.getHeapStatistics?.().heap_size_limit;