gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.4ea7d80e7

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

@@ -0,0 +1,146 @@
+function now() {
+    return Date.now();
+}
+export class AutoOrchestrator {
+    status = {
+        phase: "idle",
+        transitionCount: 0,
+    };
+    deps;
+    lastAdvanceKey = null;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async start(_sessionContext) {
+        this.lastAdvanceKey = null;
+        this.status.phase = "running";
+        this.bumpTransition();
+        await this.deps.runtime.journalTransition({ name: "start" });
+        await this.deps.notifications.notifyLifecycle({ name: "start" });
+        return this.advance();
+    }
+    async advance() {
+        try {
+            await this.deps.runtime.ensureLockOwnership();
+            const gate = await this.deps.health.preAdvanceGate();
+            if (!gate.allow) {
+                const blocked = { kind: "blocked", reason: gate.reason ?? "health gate blocked" };
+                await this.deps.runtime.journalTransition({ name: "advance-blocked", reason: blocked.reason });
+                await this.deps.health.postAdvanceRecord(blocked);
+                return blocked;
+            }
+            const decision = await this.deps.dispatch.decideNextUnit();
+            if (!decision) {
+                const stopped = { kind: "stopped", reason: "no remaining units" };
+                this.status.phase = "stopped";
+                this.status.activeUnit = undefined;
+                this.lastAdvanceKey = null;
+                this.bumpTransition();
+                await this.deps.runtime.journalTransition({ name: "advance-stopped", reason: stopped.reason });
+                await this.deps.health.postAdvanceRecord(stopped);
+                return stopped;
+            }
+            const nextKey = `${decision.unitType}:${decision.unitId}`;
+            if (this.lastAdvanceKey === nextKey) {
+                const blocked = { kind: "blocked", reason: "idempotent advance: unit already active" };
+                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;
+            }
+            this.status.activeUnit = { unitType: decision.unitType, unitId: decision.unitId };
+            this.status.phase = "running";
+            this.lastAdvanceKey = nextKey;
+            this.bumpTransition();
+            await this.deps.runtime.journalTransition({
+                name: "advance",
+                reason: decision.reason,
+                unitType: decision.unitType,
+                unitId: decision.unitId,
+            });
+            await this.deps.worktree.prepareForUnit(decision.unitType, decision.unitId);
+            await this.deps.worktree.syncAfterUnit(decision.unitType, decision.unitId);
+            const advanced = { kind: "advanced" };
+            await this.deps.health.postAdvanceRecord(advanced);
+            return advanced;
+        }
+        catch (error) {
+            const recovery = await this.deps.recovery.classifyAndRecover({
+                error,
+                unitType: this.status.activeUnit?.unitType,
+                unitId: this.status.activeUnit?.unitId,
+            });
+            const result = recovery.action === "retry"
+                ? { kind: "paused", reason: recovery.reason }
+                : recovery.action === "escalate"
+                    ? { kind: "error", reason: recovery.reason }
+                    : { kind: "stopped", reason: recovery.reason };
+            if (result.kind === "paused") {
+                this.status.phase = "paused";
+            }
+            else if (result.kind === "stopped") {
+                this.status.phase = "stopped";
+            }
+            else {
+                this.status.phase = "error";
+            }
+            if (result.kind === "stopped") {
+                this.lastAdvanceKey = null;
+                this.status.activeUnit = undefined;
+            }
+            this.bumpTransition();
+            const journalName = result.kind === "paused"
+                ? "advance-paused"
+                : result.kind === "stopped"
+                    ? "advance-stopped"
+                    : "advance-error";
+            await this.deps.runtime.journalTransition({ name: journalName, reason: recovery.reason });
+            if (result.kind === "paused") {
+                await this.deps.notifications.notifyLifecycle({ name: "pause", detail: recovery.reason });
+            }
+            else if (result.kind === "stopped") {
+                await this.deps.notifications.notifyLifecycle({ name: "stopped", detail: recovery.reason });
+            }
+            else if (result.kind === "error") {
+                await this.deps.notifications.notifyLifecycle({ name: "error", detail: recovery.reason });
+            }
+            await this.deps.health.postAdvanceRecord(result);
+            return result;
+        }
+    }
+    async resume() {
+        this.lastAdvanceKey = null;
+        this.status.phase = "running";
+        this.bumpTransition();
+        await this.deps.runtime.journalTransition({ name: "resume" });
+        await this.deps.notifications.notifyLifecycle({ name: "resume" });
+        return this.advance();
+    }
+    async stop(reason) {
+        if (this.status.phase === "stopped") {
+            return { kind: "stopped", reason };
+        }
+        await this.deps.worktree.cleanupOnStop(reason);
+        this.status.phase = "stopped";
+        this.status.activeUnit = undefined;
+        this.lastAdvanceKey = null;
+        this.bumpTransition();
+        await this.deps.runtime.journalTransition({ name: "stop", reason });
+        await this.deps.notifications.notifyLifecycle({ name: "stop", detail: reason });
+        return { kind: "stopped", reason };
+    }
+    getStatus() {
+        return { ...this.status, activeUnit: this.status.activeUnit ? { ...this.status.activeUnit } : undefined };
+    }
+    bumpTransition() {
+        this.status.transitionCount += 1;
+        this.status.lastTransitionAt = now();
+    }
+}
+export function createAutoOrchestrator(deps) {
+    return new AutoOrchestrator(deps);
+}

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

@@ -28,7 +28,7 @@ import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 import { withTimeout, FINALIZE_PRE_TIMEOUT_MS, FINALIZE_POST_TIMEOUT_MS } from "./finalize-timeout.js";
 import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { startSliceParallel } from "../slice-parallel-orchestrator.js";
-import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, refreshOpenDatabaseFromDisk } from "../gsd-db.js";
 import { ensurePlanV2Graph, isEmptyPlanV2GraphResult, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
@@ -42,6 +42,13 @@ import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit,
 function isSamePathLocal(a, b) {
     return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
+function refreshPlanSliceRecoveryDbIfNeeded(unitType) {
+    if (unitType !== "plan-slice")
+        return true;
+    if (!isDbAvailable())
+        return true;
+    return refreshOpenDatabaseFromDisk();
+}
 // ─── Session timeout auto-resume state ────────────────────────────────────────
 let consecutiveSessionTimeouts = 0;
 const MAX_SESSION_TIMEOUT_AUTO_RESUMES = 3;
@@ -145,6 +152,22 @@ async function emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, errorCon
         causedBy: { flowId: ic.flowId, seq: unitStartSeq },
     });
 }
+export function _buildCancelledUnitStopReason(unitType, unitId, errorContext) {
+    const cancellationMessage = errorContext?.message ?? "unknown";
+    const isSessionCreationFailure = errorContext?.category === "session-failed";
+    if (isSessionCreationFailure) {
+        return {
+            notifyMessage: `Session creation failed for ${unitType} ${unitId}: ${cancellationMessage}. Stopping auto-mode.`,
+            stopReason: `Session creation failed: ${cancellationMessage}`,
+            loopReason: "session-failed",
+        };
+    }
+    return {
+        notifyMessage: `Unit ${unitType} ${unitId} aborted after dispatch: ${cancellationMessage}. Stopping auto-mode.`,
+        stopReason: `Unit aborted: ${cancellationMessage}`,
+        loopReason: "unit-aborted",
+    };
+}
 async function failClosedOnFinalizeTimeout(ic, iterData, loopState, stage, startedAt) {
     const { ctx, pi, s, deps } = ic;
     const now = Date.now();
@@ -710,7 +733,10 @@ export async function runDispatch(ic, preData, loopState) {
         // See: https://github.com/gsd-build/gsd-2/issues/2474
         if (dispatchResult.level === "warning") {
             ctx.ui.notify(dispatchResult.reason, "warning");
-            await deps.pauseAuto(ctx, pi);
+            await deps.pauseAuto(ctx, pi, {
+                message: dispatchResult.reason,
+                category: "unknown",
+            });
         }
         else {
             await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
@@ -770,7 +796,13 @@ export async function runDispatch(ic, preData, loopState) {
                         action: "artifact-found",
                     });
                     ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
+                    if (!refreshPlanSliceRecoveryDbIfNeeded(unitType)) {
+                        ctx.ui.notify(`Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed. Keeping stuck state for retry.`, "warning");
+                        return { action: "continue" };
+                    }
                     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");
@@ -778,6 +810,22 @@ export async function runDispatch(ic, preData, loopState) {
             }
             else {
                 // Level 2: hard stop — genuinely stuck
+                deps.invalidateAllCaches();
+                const artifactExists = verifyExpectedArtifact(unitType, unitId, s.basePath);
+                if (artifactExists && unitType !== "complete-milestone") {
+                    debugLog("autoLoop", {
+                        phase: "stuck-recovery",
+                        level: 2,
+                        action: "artifact-found",
+                    });
+                    ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk after cache invalidation. Continuing.`, "info");
+                    if (refreshPlanSliceRecoveryDbIfNeeded(unitType)) {
+                        loopState.recentUnits.length = 0;
+                        loopState.stuckRecoveryAttempts = 0;
+                        return { action: "continue" };
+                    }
+                    ctx.ui.notify(`Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed. Stopping for manual recovery.`, "warning");
+                }
                 debugLog("autoLoop", {
                     phase: "stuck-detected",
                     unitType,
@@ -1384,10 +1432,11 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
         await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
         await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
-        ctx.ui.notify(`Session creation failed for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Stopping auto-mode.`, "warning");
-        await deps.stopAuto(ctx, pi, `Session creation failed: ${unitResult.errorContext?.message ?? "unknown"}`);
-        debugLog("autoLoop", { phase: "exit", reason: "session-failed" });
-        return { action: "break", reason: "session-failed" };
+        const cancelledStop = _buildCancelledUnitStopReason(unitType, unitId, unitResult.errorContext);
+        ctx.ui.notify(cancelledStop.notifyMessage, "warning");
+        await deps.stopAuto(ctx, pi, cancelledStop.stopReason);
+        debugLog("autoLoop", { phase: "exit", reason: cancelledStop.loopReason });
+        return { action: "break", reason: cancelledStop.loopReason };
     }
     // ── Immediate unit closeout (metrics, activity log, memory) ────────
     // Run right after runUnit() returns so telemetry is never lost to a

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

@@ -1,14 +1,11 @@
-/**
- * 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 { 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";
 // 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;
@@ -151,22 +148,29 @@ 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);
     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) => {
+            unitTimeoutHandle = setTimeout(() => {
+                resolve({ status: "cancelled", errorContext: { message: "Unit hard timeout — supervision may have failed", category: "timeout", isTransient: true } });
+            }, 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

@@ -148,6 +148,8 @@ export class AutoSession {
     // ── Remote command polling ───────────────────────────────────────────────
     /** Cleanup function returned by startCommandPolling(); null when not running. */
     commandPollingCleanup = null;
+    // ── Orchestration seam ───────────────────────────────────────────────────
+    orchestration = null;
     // ── Loop promise state ──────────────────────────────────────────────────
     // Per-unit resolve function and session-switch guard live at module level
     // in auto-loop.ts (_currentResolve, _sessionSwitchInFlight).
@@ -268,9 +270,12 @@ export class AutoSession {
         this.sigtermHandler = null;
         // Remote command polling — cleanup must be called before reset (auto.ts stopAuto)
         this.commandPollingCleanup = null;
+        // Orchestration seam
+        this.orchestration = null;
         // Loop promise state lives in auto-loop.ts module scope
     }
     toJSON() {
+        const orchestrationStatus = this.orchestration?.getStatus();
         return {
             active: this.active,
             paused: this.paused,
@@ -280,6 +285,9 @@ export class AutoSession {
             activeRunDir: this.activeRunDir,
             currentMilestoneId: this.currentMilestoneId,
             currentUnit: this.currentUnit,
+            orchestrationPhase: orchestrationStatus?.phase,
+            orchestrationTransitionCount: orchestrationStatus?.transitionCount,
+            orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
             unitDispatchCount: Object.fromEntries(this.unitDispatchCount),
         };
     }

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,48 @@
+// Project/App: GSD-2
+// File Purpose: Best-effort unit dispatch claim adapter for auto-mode loop.
+export function openDispatchClaim(s, flowId, turnId, iterData, deps) {
+    if (!s.workerId || s.milestoneLeaseToken === null)
+        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" };
+    }
+}

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

@@ -0,0 +1,26 @@
+// Project/App: GSD-2
+// File Purpose: Best-effort dispatch ledger write helpers for auto-mode loop adapters.
+export function settleDispatchFailed(dispatchId, errorSummary, deps) {
+    if (dispatchId === null)
+        return false;
+    try {
+        deps.markFailed(dispatchId, { errorSummary });
+        return true;
+    }
+    catch (err) {
+        deps.logWriteFailure(err);
+        return false;
+    }
+}
+export function settleDispatchCompleted(dispatchId, deps) {
+    if (dispatchId === null)
+        return false;
+    try {
+        deps.markCompleted(dispatchId);
+        return true;
+    }
+    catch (err) {
+        deps.logWriteFailure(err);
+        return false;
+    }
+}

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

@@ -0,0 +1,10 @@
+// Project/App: GSD-2
+// File Purpose: Successful auto-mode iteration cleanup helper.
+export function completeWorkflowIteration(state, deps) {
+    state.consecutiveErrors = 0;
+    state.consecutiveCooldowns = 0;
+    state.recentErrorMessages.length = 0;
+    deps.emitIterationEnd();
+    deps.saveStuckState();
+    deps.logIterationComplete();
+}

package/dist/resources/extensions/gsd/auto/workflow-journal-reporter.js

@@ -0,0 +1,16 @@
+// Project/App: GSD-2
+// File Purpose: Thin adapter for auto-mode workflow journal event emission.
+export function createWorkflowJournalReporter(input) {
+    const now = input.now ?? (() => new Date().toISOString());
+    return {
+        emit(eventType, data) {
+            input.emitJournalEvent({
+                ts: now(),
+                flowId: input.flowId,
+                seq: input.nextSeq(),
+                eventType,
+                data,
+            });
+        },
+    };
+}