gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

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

@@ -17,6 +17,9 @@ import { bumpTurnGeneration } from "./turn-epoch.js";
 // scoped pendingResolve + pendingAgentEndQueue pattern.
 let _currentResolve = null;
 let _sessionSwitchInFlight = false;
+let _pendingSwitchCancellation = null;
+let _sessionSwitchAbortGraceUntil = 0;
+const DEFAULT_SESSION_SWITCH_ABORT_GRACE_MS = 2_000;
 // ─── Setters (needed for cross-module mutation) ─────────────────────────────
 export function _setCurrentResolve(fn) {
     _currentResolve = fn;
@@ -24,9 +27,23 @@ export function _setCurrentResolve(fn) {
 export function _setSessionSwitchInFlight(v) {
     _sessionSwitchInFlight = v;
 }
+export function _markSessionSwitchAbortGraceWindow(durationMs = DEFAULT_SESSION_SWITCH_ABORT_GRACE_MS) {
+    _sessionSwitchAbortGraceUntil = Math.max(_sessionSwitchAbortGraceUntil, Date.now() + durationMs);
+}
+export function _clearSessionSwitchAbortGraceWindow() {
+    _sessionSwitchAbortGraceUntil = 0;
+}
+export function isSessionSwitchAbortGraceActive(now = Date.now()) {
+    return now < _sessionSwitchAbortGraceUntil;
+}
 export function _clearCurrentResolve() {
     _currentResolve = null;
 }
+export function _consumePendingSwitchCancellation() {
+    const pending = _pendingSwitchCancellation;
+    _pendingSwitchCancellation = null;
+    return pending;
+}
 // ─── resolveAgentEnd ─────────────────────────────────────────────────────────
 /**
  * Called from the agent_end event handler in index.ts to resolve the
@@ -90,8 +107,18 @@ export function resolveAgentEndCancelled(errorContext) {
         debugLog("resolveAgentEndCancelled", { status: "resolving-cancelled" });
         const r = _currentResolve;
         _currentResolve = null;
+        _pendingSwitchCancellation = null;
         r({ status: "cancelled", ...(errorContext ? { errorContext } : {}) });
+        return true;
+    }
+    if (_sessionSwitchInFlight) {
+        bumpTurnGeneration(`cancelled-during-switch:${errorContext?.category ?? "unknown"}`);
+        _pendingSwitchCancellation = errorContext ? { errorContext } : {};
+        debugLog("resolveAgentEndCancelled", { status: "queued-during-switch" });
+        return false;
     }
+    debugLog("resolveAgentEndCancelled", { status: "no-pending-resolve" });
+    return false;
 }
 // ─── resetPendingResolve (test helper) ───────────────────────────────────────
 /**
@@ -101,6 +128,8 @@ export function resolveAgentEndCancelled(errorContext) {
 export function _resetPendingResolve() {
     _currentResolve = null;
     _sessionSwitchInFlight = false;
+    _pendingSwitchCancellation = null;
+    _sessionSwitchAbortGraceUntil = 0;
 }
 export function _hasPendingResolveForTest() {
     return _currentResolve !== null;

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

@@ -1,14 +1,36 @@
-/**
- * auto/run-unit.ts — Single unit execution: session create → prompt → await agent_end.
- *
- * Imports from: auto/types, auto/resolve
- */
+// GSD-2 + src/resources/extensions/gsd/auto/run-unit.ts - Runs one GSD auto-mode unit from session creation through agent completion.
 import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
-import { _clearCurrentResolve, _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
+import { _clearCurrentResolve, _consumePendingSwitchCancellation, _markSessionSwitchAbortGraceWindow, _setCurrentResolve, _setSessionSwitchInFlight, } from "./resolve.js";
 import { getCurrentTurnGeneration, runWithTurnGeneration, } from "./turn-epoch.js";
 import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
 import { resolveAutoSupervisorConfig } from "../preferences.js";
+import { formatAutoUnitWorkingMessage } from "../working-output-messages.js";
+import { readUnitRuntimeRecord } from "../unit-runtime.js";
+const UNIT_FAILSAFE_BUFFER_MS = 30_000;
+const UNIT_FAILSAFE_RECHECK_MS = 30_000;
+export function shouldDeferUnitFailsafeTimeout(runtime, opts) {
+    if (!runtime)
+        return false;
+    if (opts.currentUnitStartedAt === undefined)
+        return false;
+    if (runtime.startedAt !== opts.currentUnitStartedAt)
+        return false;
+    if (runtime.lastProgressAt <= 0)
+        return false;
+    const progressAgeMs = opts.nowMs - runtime.lastProgressAt;
+    if (progressAgeMs < 0)
+        return false;
+    if (progressAgeMs > opts.freshProgressMs)
+        return false;
+    if (runtime.phase === "recovered")
+        return true;
+    if (runtime.lastProgressKind.includes("recovery"))
+        return true;
+    if (runtime.recoveryAttempts && runtime.recoveryAttempts > 0)
+        return true;
+    return progressAgeMs >= 0 && progressAgeMs <= opts.freshProgressMs;
+}
 // Tracks the latest session-switch attempt so a late timeout settlement from an
 // older runUnit() call cannot clear the guard for a newer one.
 let sessionSwitchGeneration = 0;
@@ -22,44 +44,23 @@ let sessionSwitchGeneration = 0;
  */
 export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
-    // Ensure cwd matches basePath BEFORE newSession() captures it. The new
-    // session reads process.cwd() during construction to anchor its tool
-    // runtime and system prompt; if cwd has drifted (async_bash, background
-    // jobs, prior unit cleanup), the session would otherwise be rooted to
-    // the wrong directory. Must be synchronous — no awaits between chdir
-    // and newSession (#1389, #4762 follow-up).
-    try {
-        if (process.cwd() !== s.basePath) {
-            process.chdir(s.basePath);
-        }
-    }
-    catch (e) {
-        const msg = `Failed to chdir to basePath before newSession (basePath: ${s.basePath}): ${String(e)}`;
-        logWarning("engine", msg, { basePath: s.basePath, error: String(e) });
-        return {
-            status: "cancelled",
-            errorContext: {
-                message: msg,
-                category: "session-failed",
-                isTransient: true,
-            },
-        };
-    }
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
-    // #3731: Cancellation controller for newSession(). When the session-creation
-    // timeout fires, we abort this controller so that the still-in-flight
-    // newSession() discards itself after await this.abort() completes, preventing
-    // it from capturing the (now-root) process.cwd() and rebuilding the tool
-    // runtime with the wrong cwd.
+    // #3731: Cancellation controller for newSession(). When session creation
+    // times out, abort before a late session switch can rebuild the tool runtime
+    // against a stale workspace root.
     const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession({ abortSignal: sessionAbortController.signal }).finally(() => {
+        const sessionPromise = s.cmdCtx.newSession({
+            abortSignal: sessionAbortController.signal,
+            workspaceRoot: s.basePath,
+        }).finally(() => {
             if (sessionSwitchGeneration === mySessionSwitchGeneration) {
+                _markSessionSwitchAbortGraceWindow();
                 _setSessionSwitchInFlight(false);
             }
         });
@@ -74,6 +75,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     catch (sessionErr) {
         if (sessionTimeoutHandle)
             clearTimeout(sessionTimeoutHandle);
+        _consumePendingSwitchCancellation();
         const msg = sessionErr instanceof Error ? sessionErr.message : String(sessionErr);
         debugLog("runUnit", {
             phase: "session-error",
@@ -86,15 +88,18 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     if (sessionTimeoutHandle)
         clearTimeout(sessionTimeoutHandle);
     if (sessionResult.cancelled) {
+        _consumePendingSwitchCancellation();
         debugLog("runUnit-session-timeout", { unitType, unitId });
         return { status: "cancelled", errorContext: { message: "Session creation timed out", category: "timeout", isTransient: true } };
     }
     if (!s.active) {
+        _consumePendingSwitchCancellation();
         return { status: "cancelled" };
     }
     if (s.currentUnitModel && typeof pi.setModel === "function") {
         const restored = await pi.setModel(s.currentUnitModel, { persist: false });
         if (!restored) {
+            _consumePendingSwitchCancellation();
             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 {
@@ -110,10 +115,19 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     // ── Create the agent_end promise (per-unit one-shot) ──
     // This happens after newSession completes so session-switch agent_end events
     // from the previous session cannot resolve the new unit.
+    _markSessionSwitchAbortGraceWindow();
     _setSessionSwitchInFlight(false);
     const unitPromise = new Promise((resolve) => {
         _setCurrentResolve(resolve);
     });
+    const pendingSwitchCancellation = _consumePendingSwitchCancellation();
+    if (pendingSwitchCancellation) {
+        _clearCurrentResolve();
+        return {
+            status: "cancelled",
+            ...(pendingSwitchCancellation.errorContext ? { errorContext: pendingSwitchCancellation.errorContext } : {}),
+        };
+    }
     // ── Provider request-readiness pre-check (#4555) ──
     // Verify the provider can accept requests before dispatching. If the token
     // has expired since bootstrap, return cancelled immediately so the unit is
@@ -151,22 +165,67 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
     const requestDispatchedAt = Date.now();
-    pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
+    ctx.ui.setWorkingMessage?.(formatAutoUnitWorkingMessage(unitType, unitId));
     // ── Await agent_end with absolute timeout (H4 fix) ──
     // If supervision fails to resolve unitPromise within 30s, treat as cancelled.
     // Without this, a crashed agent that never emits agent_end hangs the loop (#3161).
-    debugLog("runUnit", { phase: "awaiting-agent-end", unitType, unitId });
     const supervisor = resolveAutoSupervisorConfig();
-    const UNIT_HARD_TIMEOUT_MS = Math.max(30_000, ((supervisor.hard_timeout_minutes ?? 30) * 60 * 1000) + 30_000);
+    const UNIT_HARD_TIMEOUT_MS = Math.max(UNIT_FAILSAFE_BUFFER_MS, ((supervisor.hard_timeout_minutes ?? 30) * 60 * 1000) + UNIT_FAILSAFE_BUFFER_MS);
+    const freshProgressMs = Math.max(UNIT_FAILSAFE_BUFFER_MS, ((supervisor.idle_timeout_minutes ?? 10) * 60 * 1000) + UNIT_FAILSAFE_BUFFER_MS);
     let unitTimeoutHandle;
-    const timeoutResult = new Promise((resolve) => {
-        unitTimeoutHandle = setTimeout(() => {
-            resolve({ status: "cancelled", errorContext: { message: "Unit hard timeout — supervision may have failed", category: "timeout", isTransient: true } });
-        }, UNIT_HARD_TIMEOUT_MS);
-    });
-    const result = await runWithTurnGeneration(capturedTurnGen, () => Promise.race([unitPromise, timeoutResult]));
-    if (unitTimeoutHandle)
-        clearTimeout(unitTimeoutHandle);
+    let result;
+    try {
+        pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
+        debugLog("runUnit", { phase: "awaiting-agent-end", unitType, unitId });
+        const timeoutResult = new Promise((resolve) => {
+            const settleOrDefer = () => {
+                let runtime;
+                try {
+                    runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
+                }
+                catch (error) {
+                    debugLog("runUnit", {
+                        phase: "unit-failsafe-runtime-read-failed",
+                        unitType,
+                        unitId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                    resolve({
+                        status: "cancelled",
+                        errorContext: {
+                            message: "Unit hard timeout — supervision may have failed; runtime progress could not be read",
+                            category: "timeout",
+                            isTransient: true,
+                        },
+                    });
+                    return;
+                }
+                if (shouldDeferUnitFailsafeTimeout(runtime, {
+                    nowMs: Date.now(),
+                    currentUnitStartedAt: s.currentUnit?.startedAt,
+                    freshProgressMs,
+                })) {
+                    debugLog("runUnit", {
+                        phase: "unit-failsafe-deferred",
+                        unitType,
+                        unitId,
+                        runtimePhase: runtime?.phase,
+                        lastProgressKind: runtime?.lastProgressKind,
+                    });
+                    unitTimeoutHandle = setTimeout(settleOrDefer, UNIT_FAILSAFE_RECHECK_MS);
+                    return;
+                }
+                resolve({ status: "cancelled", errorContext: { message: "Unit hard timeout — supervision may have failed", category: "timeout", isTransient: true } });
+            };
+            unitTimeoutHandle = setTimeout(settleOrDefer, UNIT_HARD_TIMEOUT_MS);
+        });
+        result = await runWithTurnGeneration(capturedTurnGen, () => Promise.race([unitPromise, timeoutResult]));
+    }
+    finally {
+        if (unitTimeoutHandle)
+            clearTimeout(unitTimeoutHandle);
+        ctx.ui.setWorkingMessage?.(undefined);
+    }
     debugLog("runUnit", {
         phase: "agent-end-received",
         unitType,

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

@@ -25,6 +25,7 @@ export class AutoSession {
     // ── Lifecycle ────────────────────────────────────────────────────────────
     active = false;
     paused = false;
+    completionStopInProgress = false;
     stepMode = false;
     verbose = false;
     activeEngineId = null;
@@ -44,7 +45,7 @@ export class AutoSession {
     workerId = null;
     /**
      * Active milestone lease fencing token, set by claimMilestoneLease() inside
-     * worktree-resolver.enterMilestone(). Threaded into recordDispatchClaim()
+     * WorktreeLifecycle.enterMilestone(). Threaded into recordDispatchClaim()
      * as milestone_lease_token so out-of-band dispatches by a stale worker
      * are detectable.
      */
@@ -88,6 +89,7 @@ export class AutoSession {
     pendingCrashRecovery = null;
     pendingVerificationRetry = null;
     verificationRetryCount = new Map();
+    verificationRetryFailureHashes = new Map();
     pausedSessionFile = null;
     pausedUnitType = null;
     pausedUnitId = null;
@@ -106,6 +108,13 @@ export class AutoSession {
      * stale context bleeding into unrelated slices.
      */
     lastPreExecFailure = null;
+    /**
+     * Tracks how many consecutive times each slice unit has failed pre-execution
+     * checks. Keyed by unitId (e.g. "M001/S01"). Used to break the infinite
+     * plan-slice → pre-exec fail → re-dispatch loop when the planner cannot fix
+     * the issues after MAX_PRE_EXEC_RETRIES re-attempts.
+     */
+    preExecRetryCount = new Map();
     // ── Tool invocation errors (#2883) ──────────────────────────────────
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
@@ -200,6 +209,7 @@ export class AutoSession {
         // Lifecycle
         this.active = false;
         this.paused = false;
+        this.completionStopInProgress = false;
         this.stepMode = false;
         this.verbose = false;
         this.activeEngineId = null;
@@ -243,6 +253,7 @@ export class AutoSession {
         this.pendingCrashRecovery = null;
         this.pendingVerificationRetry = null;
         this.verificationRetryCount.clear();
+        this.verificationRetryFailureHashes.clear();
         this.pausedSessionFile = null;
         this.pausedUnitType = null;
         this.pausedUnitId = null;
@@ -258,6 +269,7 @@ export class AutoSession {
         this.rewriteAttemptCount = 0;
         this.consecutiveCompleteBootstraps = 0;
         this.lastPreExecFailure = null;
+        this.preExecRetryCount.clear();
         this.lastToolInvocationError = null;
         this.lastUnitAgentEndMessages = null;
         this.lastGitActionFailure = null;
@@ -274,6 +286,11 @@ export class AutoSession {
         this.orchestration = null;
         // Loop promise state lives in auto-loop.ts module scope
     }
+    resetAfterStop(options = {}) {
+        const completionStopInProgress = options.preserveCompletionSurface ? this.completionStopInProgress : false;
+        this.reset();
+        this.completionStopInProgress = completionStopInProgress;
+    }
     toJSON() {
         const orchestrationStatus = this.orchestration?.getStatus();
         return {

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

@@ -0,0 +1,7 @@
+// GSD-2 + src/resources/extensions/gsd/auto/unit-runner-events.ts - Classifies agent lifecycle events before Unit settlement.
+export function isInternalSessionTransitionAbortEvent(event) {
+    return event.abortOrigin === "session-transition";
+}
+export function shouldIgnoreAgentEndForActiveUnit(event) {
+    return isInternalSessionTransitionAbortEvent(event);
+}

package/dist/resources/extensions/gsd/auto/verification-retry-policy.js

@@ -0,0 +1,43 @@
+// Project/App: GSD-2
+// File Purpose: Central retry policy for auto-mode verification redispatches.
+import { createHash } from "node:crypto";
+export const VERIFICATION_RETRY_BASE_DELAY_MS = 2_000;
+export const VERIFICATION_RETRY_MAX_DELAY_MS = 30_000;
+export const VERIFICATION_RETRY_JITTER_RATIO = 0.1;
+export function verificationRetryKey(unitType, unitId) {
+    return `${unitType}:${unitId}`;
+}
+export function hashVerificationFailureContext(failureContext) {
+    const normalized = failureContext.replace(/\r\n/g, "\n").trim();
+    return createHash("sha256").update(normalized).digest("hex");
+}
+export function verificationRetryDelayMs(attempt, random = Math.random) {
+    const safeAttempt = Math.max(1, Math.floor(attempt));
+    const baseDelayMs = Math.min(VERIFICATION_RETRY_MAX_DELAY_MS, VERIFICATION_RETRY_BASE_DELAY_MS * 2 ** (safeAttempt - 1));
+    const jitterSpanMs = Math.round(baseDelayMs * VERIFICATION_RETRY_JITTER_RATIO);
+    const jitterMs = Math.round((random() - 0.5) * 2 * jitterSpanMs);
+    const delayMs = Math.min(VERIFICATION_RETRY_MAX_DELAY_MS, Math.max(0, baseDelayMs + jitterMs));
+    return { delayMs, baseDelayMs };
+}
+export function decideVerificationRetry(input) {
+    const { retryInfo, unitType } = input;
+    if (!retryInfo || !unitType) {
+        return { action: "pause", reason: "missing-retry-context" };
+    }
+    const key = verificationRetryKey(unitType, retryInfo.unitId);
+    const failureHash = hashVerificationFailureContext(retryInfo.failureContext);
+    if (input.previousFailureHash === failureHash) {
+        return {
+            action: "pause",
+            reason: "duplicate-failure-context",
+            key,
+            failureHash,
+        };
+    }
+    return {
+        action: "delay",
+        key,
+        failureHash,
+        ...verificationRetryDelayMs(retryInfo.attempt, input.random),
+    };
+}

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-dispatch-outcome.js

@@ -0,0 +1,12 @@
+// Project/App: GSD-2
+// File Purpose: Applies custom-engine dispatch decisions to auto-mode loop side effects.
+export async function handleCustomEngineDispatchOutcome(input) {
+    if (input.decision.action === "stop") {
+        await input.deps.stopAuto(input.decision.reason);
+        return { action: "break" };
+    }
+    if (input.decision.action === "skip") {
+        return { action: "continue" };
+    }
+    return { action: "dispatch" };
+}

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-iteration.js

@@ -0,0 +1,24 @@
+// Project/App: GSD-2
+// File Purpose: Custom-engine iteration-data adapter for auto-mode loop.
+export async function buildCustomEngineIterationData(input) {
+    const gsdState = await input.deriveState(input.canonicalProjectRoot);
+    input.logPostDerive({
+        site: "custom-engine-gsd-state",
+        basePath: input.basePath,
+        canonicalProjectRoot: input.canonicalProjectRoot,
+        derivedPhase: gsdState.phase,
+        activeUnit: gsdState.activeTask?.id ?? gsdState.activeSlice?.id ?? gsdState.activeMilestone?.id,
+    });
+    return {
+        unitType: input.step.unitType,
+        unitId: input.step.unitId,
+        prompt: input.step.prompt,
+        finalPrompt: input.step.prompt,
+        pauseAfterUatDispatch: false,
+        state: gsdState,
+        mid: input.currentMilestoneId ?? "workflow",
+        midTitle: "Workflow",
+        isRetry: false,
+        previousTier: undefined,
+    };
+}

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-reconcile-outcome.js

@@ -0,0 +1,33 @@
+// Project/App: GSD-2
+// File Purpose: Applies custom-engine reconcile outcomes to auto-mode loop side effects.
+export async function handleCustomEngineReconcileOutcome(input) {
+    const details = {
+        unitType: input.unitType,
+        unitId: input.unitId,
+    };
+    const decision = input.outcome.decision;
+    if (decision.action === "complete-workflow") {
+        await input.deps.stopAuto(decision.stopReason);
+        input.deps.report("milestone-complete", details);
+        input.deps.finishTurn("completed");
+        return { action: "break" };
+    }
+    if (decision.action === "pause") {
+        await input.deps.pauseAuto();
+        input.deps.report("pause", details);
+        input.deps.finishTurn("paused", "manual-attention");
+        return { action: "break" };
+    }
+    if (decision.action === "stop") {
+        await input.deps.stopAuto(decision.reason);
+        input.deps.report("stop", {
+            ...details,
+            reason: input.outcome.reason,
+        });
+        input.deps.finishTurn("stopped", "manual-attention", input.outcome.reason);
+        return { action: "break" };
+    }
+    input.deps.report("continue", details);
+    input.deps.finishTurn("completed");
+    return { action: "continue" };
+}

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-reconcile.js

@@ -0,0 +1,26 @@
+// Project/App: GSD-2
+// File Purpose: Custom-engine successful verification reconcile adapter for auto-mode loop.
+import { decideEngineReconcile, } from "./workflow-kernel.js";
+export async function handleCustomEngineReconcile(input) {
+    input.session.verificationRetryCount?.delete(`${input.iterData.unitType}/${input.iterData.unitId}`);
+    input.deps.saveRetryCounts();
+    input.deps.logReconcile({
+        iteration: input.iteration,
+        unitId: input.iterData.unitId,
+    });
+    const finishedAt = input.deps.now();
+    const reconcileResult = await input.deps.reconcile(input.engineState, {
+        unitType: input.iterData.unitType,
+        unitId: input.iterData.unitId,
+        startedAt: input.session.currentUnit?.startedAt ?? finishedAt,
+        finishedAt,
+    });
+    input.deps.clearUnitTimeout();
+    input.deps.completeIteration();
+    return {
+        decision: decideEngineReconcile(reconcileResult.outcome === "stop"
+            ? { outcome: "stop", reason: reconcileResult.reason }
+            : { outcome: reconcileResult.outcome }),
+        reason: reconcileResult.reason,
+    };
+}

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-retry.js

@@ -0,0 +1,49 @@
+// Project/App: GSD-2
+// File Purpose: Custom-engine verification retry adapter for auto-mode loop.
+import { decideCustomEngineRecovery, decideCustomEngineVerifyRetry, } from "./workflow-kernel.js";
+export async function handleCustomEngineVerifyRetry(input) {
+    const recoveryKey = `${input.unitType}/${input.unitId}`;
+    const retryCounts = input.deps.hydrateRetryCounts();
+    const attempts = (retryCounts.get(recoveryKey) ?? 0) + 1;
+    input.session.verificationRetryCount.set(recoveryKey, attempts);
+    input.deps.saveRetryCounts();
+    input.deps.logRetry({
+        iteration: input.iteration,
+        unitId: input.unitId,
+        attempts,
+    });
+    input.deps.reportRetry({
+        unitType: input.unitType,
+        unitId: input.unitId,
+        attempts,
+    });
+    const retryDecision = decideCustomEngineVerifyRetry({
+        attempts,
+        maxRetries: input.maxRetries,
+    });
+    if (retryDecision.action === "retry") {
+        return { action: "retry", attempts };
+    }
+    const recovery = await input.deps.recover(input.unitType, input.unitId, {
+        basePath: input.basePath,
+    });
+    const recoveryDecision = decideCustomEngineRecovery({
+        outcome: recovery.outcome,
+        reason: recovery.reason,
+        unitId: input.unitId,
+        attempts,
+    });
+    if (recoveryDecision.action === "pause") {
+        return {
+            action: "pause",
+            attempts,
+            turnError: recoveryDecision.turnError,
+        };
+    }
+    return {
+        action: "stop",
+        attempts,
+        stopMessage: recoveryDecision.stopMessage,
+        turnError: recoveryDecision.turnError,
+    };
+}

package/dist/resources/extensions/gsd/auto/workflow-custom-engine-verify-outcome.js

@@ -0,0 +1,25 @@
+// Project/App: GSD-2
+// File Purpose: Applies custom-engine verification outcomes to auto-mode loop side effects.
+export async function handleCustomEngineVerifyPause(input) {
+    await input.deps.pauseAuto();
+    input.deps.reportPause({
+        unitType: input.unitType,
+        unitId: input.unitId,
+    });
+    input.deps.finishTurn("paused", "manual-attention", "custom-engine-verify-pause");
+    return { action: "break" };
+}
+export async function handleCustomEngineVerifyRetryOutcome(input) {
+    if (input.outcome.action === "pause") {
+        await input.deps.pauseAuto();
+        input.deps.finishTurn("paused", "manual-attention", input.outcome.turnError);
+        return { action: "break" };
+    }
+    if (input.outcome.action === "stop") {
+        await input.deps.stopAuto(input.outcome.stopMessage);
+        input.deps.finishTurn("stopped", "manual-attention", input.outcome.turnError);
+        return { action: "break" };
+    }
+    input.deps.finishTurn("retry");
+    return { action: "continue" };
+}

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

@@ -0,0 +1,80 @@
+// Project/App: GSD-2
+// File Purpose: Best-effort unit dispatch claim adapter for auto-mode loop.
+export function ensureDispatchLease(s, milestoneId, deps, opts = {}) {
+    if (!s.workerId)
+        return { kind: "degraded", reason: "missing-worker" };
+    if (!milestoneId)
+        return { kind: "degraded", reason: "missing-milestone" };
+    if (!opts.forceReclaim && typeof s.milestoneLeaseToken === "number") {
+        return { kind: "ready", token: s.milestoneLeaseToken, recovered: false };
+    }
+    s.milestoneLeaseToken = null;
+    try {
+        const claim = deps.claimMilestoneLease(s.workerId, milestoneId);
+        if (!claim.ok) {
+            const reason = `Milestone ${milestoneId} is held by worker ${claim.byWorker} until ${claim.expiresAt}.`;
+            deps.logLeaseRecoveryFailed({ milestoneId, workerId: s.workerId, reason });
+            return { kind: "blocked", reason };
+        }
+        s.currentMilestoneId = milestoneId;
+        s.milestoneLeaseToken = claim.token;
+        deps.logLeaseRecovered({
+            milestoneId,
+            workerId: s.workerId,
+            token: claim.token,
+            recovered: opts.forceReclaim === true,
+        });
+        return { kind: "ready", token: claim.token, recovered: opts.forceReclaim === true };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        deps.logLeaseRecoveryFailed({ milestoneId, workerId: s.workerId, reason });
+        return { kind: "failed", reason };
+    }
+}
+export function openDispatchClaim(s, flowId, turnId, iterData, deps) {
+    if (!s.workerId || typeof s.milestoneLeaseToken !== "number")
+        return { kind: "degraded" };
+    const mid = iterData.mid;
+    if (!mid)
+        return { kind: "degraded" };
+    const recent = deps.getRecentDispatchesForUnit(iterData.unitId, 1);
+    const attemptN = (recent[0]?.attempt_n ?? 0) + 1;
+    try {
+        const claim = deps.recordDispatchClaim({
+            traceId: flowId,
+            turnId,
+            workerId: s.workerId,
+            milestoneLeaseToken: s.milestoneLeaseToken,
+            milestoneId: mid,
+            sliceId: iterData.state.activeSlice?.id ?? null,
+            taskId: iterData.state.activeTask?.id ?? null,
+            unitType: iterData.unitType,
+            unitId: iterData.unitId,
+            attemptN,
+        });
+        if (!claim.ok) {
+            deps.logClaimRejected({
+                unitId: iterData.unitId,
+                reason: claim.error,
+                existingId: claim.existingId,
+                existingWorker: claim.existingWorker,
+            });
+            if (claim.error === "already_active") {
+                return {
+                    kind: "skip",
+                    reason: "already-active",
+                    existingId: claim.existingId,
+                    existingWorker: claim.existingWorker,
+                };
+            }
+            return { kind: "skip", reason: "stale-lease" };
+        }
+        deps.markDispatchRunning(claim.dispatchId);
+        return { kind: "opened", dispatchId: claim.dispatchId };
+    }
+    catch (err) {
+        deps.logClaimFailed(err);
+        return { kind: "degraded" };
+    }
+}