gsd-pi 2.82.0 → 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

@@ -3,6 +3,15 @@
 function now() {
     return Date.now();
 }
+/**
+ * Size of the dispatch-decision ring buffer used by the Auto Orchestration
+ * module's stuck-loop detector. When the same `${unitType}:${unitId}` key
+ * fills the window, advance() blocks with `action: "stop"`.
+ *
+ * Mirrors the legacy `STUCK_WINDOW_SIZE` in auto/phases.ts so behaviour is
+ * preserved across the eventual cutover (issue #5791).
+ */
+export const STUCK_WINDOW_SIZE = 6;
 export class AutoOrchestrator {
     status = {
         phase: "idle",
@@ -10,11 +19,13 @@ export class AutoOrchestrator {
     };
     deps;
     lastAdvanceKey = null;
+    dispatchKeyWindow = [];
     constructor(deps) {
         this.deps = deps;
     }
     async start(_sessionContext) {
         this.lastAdvanceKey = null;
+        this.dispatchKeyWindow = [];
         this.status.phase = "running";
         this.bumpTransition();
         await this.deps.runtime.journalTransition({ name: "start" });
@@ -24,18 +35,70 @@ export class AutoOrchestrator {
     async advance() {
         try {
             await this.deps.runtime.ensureLockOwnership();
+            const staleMsg = this.deps.health.checkResourcesStale();
+            if (staleMsg) {
+                await this.deps.uokGate.emit({
+                    gateId: "resource-version-guard",
+                    gateType: "policy",
+                    outcome: "fail",
+                    failureClass: "policy",
+                    rationale: "resource version guard blocked dispatch",
+                    findings: staleMsg,
+                });
+                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;
+            }
+            await this.deps.uokGate.emit({
+                gateId: "resource-version-guard",
+                gateType: "policy",
+                outcome: "pass",
+                failureClass: "none",
+                rationale: "resource version guard passed",
+            });
             const gate = await this.deps.health.preAdvanceGate();
-            if (!gate.allow) {
-                const blocked = { kind: "blocked", reason: gate.reason ?? "health gate blocked" };
+            if (gate.kind === "fail") {
+                await this.deps.uokGate.emit({
+                    gateId: "pre-dispatch-health-gate",
+                    gateType: "execution",
+                    outcome: "manual-attention",
+                    failureClass: "manual-attention",
+                    rationale: "pre-dispatch health gate blocked dispatch",
+                    findings: gate.reason,
+                });
+                const blocked = { kind: "blocked", reason: gate.reason, action: "pause" };
                 await this.deps.runtime.journalTransition({ name: "advance-blocked", reason: blocked.reason });
                 await this.deps.health.postAdvanceRecord(blocked);
                 return blocked;
             }
+            if (gate.kind === "threw") {
+                await this.deps.uokGate.emit({
+                    gateId: "pre-dispatch-health-gate",
+                    gateType: "execution",
+                    outcome: "manual-attention",
+                    failureClass: "manual-attention",
+                    rationale: "pre-dispatch health gate threw unexpectedly",
+                    findings: String(gate.error),
+                });
+                // intentional fall-through: matches runPreDispatch behaviour
+            }
+            else {
+                await this.deps.uokGate.emit({
+                    gateId: "pre-dispatch-health-gate",
+                    gateType: "execution",
+                    outcome: "pass",
+                    failureClass: "none",
+                    rationale: "pre-dispatch health gate passed",
+                    findings: gate.fixesApplied?.join(", ") ?? "",
+                });
+            }
             const reconciliation = await this.deps.stateReconciliation.reconcileBeforeDispatch();
             if (!reconciliation.ok || !reconciliation.stateSnapshot) {
                 const blocked = {
                     kind: "blocked",
-                    reason: reconciliation.reason,
+                    reason: reconciliation.reason ?? "state reconciliation produced no snapshot",
+                    action: "pause",
                     stateSnapshot: reconciliation.stateSnapshot,
                 };
                 await this.deps.runtime.journalTransition({ name: "advance-blocked", reason: blocked.reason });
@@ -48,14 +111,60 @@ export class AutoOrchestrator {
                 this.status.phase = "stopped";
                 this.status.activeUnit = undefined;
                 this.lastAdvanceKey = null;
+                this.dispatchKeyWindow = [];
                 this.bumpTransition();
                 await this.deps.runtime.journalTransition({ name: "advance-stopped", reason: stopped.reason });
                 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}`;
-            if (this.lastAdvanceKey === nextKey) {
-                const blocked = { kind: "blocked", reason: "idempotent advance: unit already active" };
+            // Record every dispatch decision in the ring buffer before pre-flight
+            // checks so the stuck-loop detector observes the full decision history
+            // (including decisions that idempotency would otherwise short-circuit).
+            // The ring is capped at STUCK_WINDOW_SIZE and evicts oldest-first.
+            this.dispatchKeyWindow.push(nextKey);
+            if (this.dispatchKeyWindow.length > STUCK_WINDOW_SIZE) {
+                this.dispatchKeyWindow.shift();
+            }
+            // Idempotency: same key as immediately previous successful advance.
+            // This is the soft, fast-path block kept from #5786. It only fires when
+            // the ring is NOT yet saturated for this key — once the ring is full of
+            // `nextKey`, the stuck-loop verdict takes precedence (see below). Both
+            // checks coexist: idempotency for the common immediate-repeat case,
+            // 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: "pause" };
+                await this.deps.runtime.journalTransition({
+                    name: "advance-blocked",
+                    reason: blocked.reason,
+                    unitType: decision.unitType,
+                    unitId: decision.unitId,
+                });
+                await this.deps.health.postAdvanceRecord(blocked);
+                return blocked;
+            }
+            // Stuck-loop detection: when the ring is saturated with copies of
+            // `nextKey` (count >= STUCK_WINDOW_SIZE), the orchestrator has been
+            // picking the same unit across the whole window and must hard-stop with
+            // a diagnosable reason.
+            if (matchingCount >= STUCK_WINDOW_SIZE) {
+                const blocked = {
+                    kind: "blocked",
+                    reason: `stuck-loop: ${nextKey} picked ${matchingCount} times`,
+                    action: "stop",
+                };
                 await this.deps.runtime.journalTransition({
                     name: "advance-blocked",
                     reason: blocked.reason,
@@ -70,6 +179,7 @@ export class AutoOrchestrator {
                 const blocked = {
                     kind: "blocked",
                     reason: contract.reason,
+                    action: "pause",
                     stateSnapshot: reconciliation.stateSnapshot,
                 };
                 await this.deps.runtime.journalTransition({
@@ -86,6 +196,7 @@ export class AutoOrchestrator {
                 const blocked = {
                     kind: "blocked",
                     reason: worktree.reason,
+                    action: "pause",
                     stateSnapshot: reconciliation.stateSnapshot,
                 };
                 await this.deps.runtime.journalTransition({
@@ -108,7 +219,11 @@ export class AutoOrchestrator {
                 unitId: decision.unitId,
             });
             await this.deps.worktree.syncAfterUnit(decision.unitType, decision.unitId);
-            const advanced = { kind: "advanced", stateSnapshot: reconciliation.stateSnapshot };
+            const advanced = {
+                kind: "advanced",
+                unit: { unitType: decision.unitType, unitId: decision.unitId },
+                stateSnapshot: reconciliation.stateSnapshot,
+            };
             await this.deps.health.postAdvanceRecord(advanced);
             return advanced;
         }
@@ -134,6 +249,7 @@ export class AutoOrchestrator {
             }
             if (result.kind === "stopped") {
                 this.lastAdvanceKey = null;
+                this.dispatchKeyWindow = [];
                 this.status.activeUnit = undefined;
             }
             this.bumpTransition();
@@ -158,6 +274,7 @@ export class AutoOrchestrator {
     }
     async resume() {
         this.lastAdvanceKey = null;
+        this.dispatchKeyWindow = [];
         this.status.phase = "running";
         this.bumpTransition();
         await this.deps.runtime.journalTransition({ name: "resume" });
@@ -172,6 +289,7 @@ export class AutoOrchestrator {
         this.status.phase = "stopped";
         this.status.activeUnit = undefined;
         this.lastAdvanceKey = null;
+        this.dispatchKeyWindow = [];
         this.bumpTransition();
         await this.deps.runtime.journalTransition({ name: "stop", reason });
         await this.deps.notifications.notifyLifecycle({ name: "stop", detail: reason });