gsd-pi 2.81.0 → 2.82.0-dev.20138ae42

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

@@ -6,6 +6,31 @@ 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;
@@ -145,16 +170,54 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     // 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).
     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;
     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(() => {
+            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 } });
-            }, UNIT_HARD_TIMEOUT_MS);
+            };
+            unitTimeoutHandle = setTimeout(settleOrDefer, UNIT_HARD_TIMEOUT_MS);
         });
         result = await runWithTurnGeneration(capturedTurnGen, () => Promise.race([unitPromise, timeoutResult]));
     }

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;
@@ -88,6 +89,7 @@ export class AutoSession {
     pendingCrashRecovery = null;
     pendingVerificationRetry = null;
     verificationRetryCount = new Map();
+    verificationRetryFailureHashes = new Map();
     pausedSessionFile = null;
     pausedUnitType = null;
     pausedUnitId = null;
@@ -207,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;
@@ -250,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;
@@ -282,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/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-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;