@opengsd/gsd-pi 1.2.0-dev.9ad8ae33 → 1.2.0-dev.a6376d75

package/dist/resources/extensions/gsd/auto/phase-helpers.js

@@ -0,0 +1,146 @@
+// Project/App: gsd-pi
+// File Purpose: Shared helpers used across auto-loop phase modules.
+import { setRuntimeKv } from "../db/runtime-kv.js";
+import { debugLog } from "../debug-logger.js";
+import { normalizeRealPath } from "../paths.js";
+import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "../worktree-root.js";
+import { decideVerificationRetry, verificationRetryKey } from "./verification-retry-policy.js";
+const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
+/** Compare two paths for physical identity, tolerating trailing slashes and symlinks. */
+export function isSamePathLocal(a, b) {
+    return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
+}
+export function isIsolatedWorktreeSession(s) {
+    return Boolean(s.originalBasePath)
+        && Boolean(s.basePath)
+        && !isSamePathLocal(s.originalBasePath, s.basePath);
+}
+export function persistStuckRecoveryAttempts(s, loopState) {
+    const scopeId = normalizeRealPath(s.scope?.workspace.projectRoot ?? (s.originalBasePath || s.basePath));
+    if (!scopeId)
+        return;
+    try {
+        setRuntimeKv("global", scopeId, STUCK_RECOVERY_ATTEMPTS_KEY, loopState.stuckRecoveryAttempts);
+    }
+    catch (err) {
+        debugLog("autoLoop", {
+            phase: "save-stuck-state-failed",
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+export async function applyVerificationRetryPolicy(ic, unitType, phase) {
+    const { ctx, pi, s, deps } = ic;
+    const retryInfo = s.pendingVerificationRetry;
+    const key = unitType && retryInfo
+        ? verificationRetryKey(unitType, retryInfo.unitId)
+        : undefined;
+    const decision = decideVerificationRetry({
+        unitType,
+        retryInfo,
+        previousFailureHash: key ? s.verificationRetryFailureHashes.get(key) : undefined,
+    });
+    if (decision.action === "pause") {
+        s.pendingVerificationRetry = null;
+        debugLog("autoLoop", {
+            phase: `${phase}-paused`,
+            reason: decision.reason,
+            unitType,
+            unitId: retryInfo?.unitId,
+            failureHash: decision.failureHash,
+        });
+        ctx.ui.notify(decision.reason === "duplicate-failure-context"
+            ? `Verification retry for ${unitType ?? "unit"} ${retryInfo?.unitId ?? "unknown"} produced the same failure context. Pausing auto-mode instead of re-dispatching.`
+            : "Verification retry requested without retry context. Pausing auto-mode instead of re-dispatching.", "warning");
+        await deps.pauseAuto(ctx, pi);
+        return { action: "break", reason: decision.reason };
+    }
+    s.verificationRetryFailureHashes.set(decision.key, decision.failureHash);
+    debugLog("autoLoop", {
+        phase: `${phase}-backoff`,
+        iteration: ic.iteration,
+        unitType,
+        unitId: retryInfo?.unitId,
+        attempt: retryInfo?.attempt,
+        delayMs: decision.delayMs,
+        baseDelayMs: decision.baseDelayMs,
+        failureHash: decision.failureHash,
+    });
+    await new Promise((resolve) => setTimeout(resolve, decision.delayMs));
+    return null;
+}
+export function rememberRetryDispatch(s, unit, iterData) {
+    if (!unit)
+        return;
+    s.pendingVerificationRetryDispatch = {
+        unitType: unit.type,
+        unitId: unit.id,
+        prompt: iterData.prompt,
+        pauseAfterUatDispatch: iterData.pauseAfterUatDispatch,
+        state: iterData.state,
+        mid: iterData.mid,
+        midTitle: iterData.midTitle,
+    };
+}
+/**
+ * Resolve the base path for milestone reports.
+ * Prefers originalBasePath (project root) over basePath (which may be a worktree).
+ */
+export function _resolveReportBasePath(s) {
+    return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
+}
+/**
+ * Resolve the authoritative project base for dispatch guards.
+ * Prior-milestone completion lives at the project root, even when the active
+ * unit is running inside an auto worktree.
+ */
+export function _resolveDispatchGuardBasePath(s) {
+    return resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
+}
+const PLAN_V2_GATE_PHASES = new Set([
+    "executing",
+    "summarizing",
+    "validating-milestone",
+    "completing-milestone",
+]);
+export function shouldRunPlanV2Gate(phase) {
+    return PLAN_V2_GATE_PHASES.has(phase);
+}
+export function _resolveCurrentUnitStartedAtForTest(currentUnit) {
+    return currentUnit?.startedAt;
+}
+export async function emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, errorContext) {
+    ic.deps.emitJournalEvent({
+        ts: new Date().toISOString(),
+        flowId: ic.flowId,
+        seq: ic.nextSeq(),
+        eventType: "unit-end",
+        data: {
+            unitType,
+            unitId,
+            status: "cancelled",
+            artifactVerified: false,
+            ...(errorContext ? { errorContext } : {}),
+        },
+        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",
+    };
+}
+export function _isPauseOriginCancelledResult(isPaused, errorContext) {
+    return isPaused && !errorContext;
+}