gsd-pi 2.67.0-dev.1cd1e0f → 2.67.0-dev.2367d7e

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

@@ -11,6 +11,7 @@
  */
 import { deriveState } from "./state.js";
 import { parseUnitId } from "./unit-id.js";
+import { assessInterruptedSession, readPausedSessionMetadata, } from "./interrupted-session.js";
 import { getManifestStatus } from "./files.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
@@ -18,7 +19,7 @@ import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveDir, milest
 import { invalidateAllCaches } from "./cache.js";
 import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, readActiveMilestoneId, } from "./session-forensics.js";
-import { writeLock, clearLock, readCrashLock, isLockProcessAlive, } from "./crash-recovery.js";
+import { writeLock, clearLock, readCrashLock, isLockProcessAlive, formatCrashInfo, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
@@ -34,7 +35,8 @@ import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
-import { setLogBasePath, logWarning } from "./workflow-logger.js";
+import { logWarning } from "./workflow-logger.js";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -79,6 +81,27 @@ export { MAX_UNIT_DISPATCHES, STUB_RECOVERY_THRESHOLD, MAX_LIFETIME_DISPATCHES,
 const s = new AutoSession();
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
+function captureProjectRootEnv(projectRoot) {
+    if (!s.projectRootEnvCaptured) {
+        s.hadProjectRootEnv = Object.prototype.hasOwnProperty.call(process.env, "GSD_PROJECT_ROOT");
+        s.previousProjectRootEnv = process.env.GSD_PROJECT_ROOT ?? null;
+        s.projectRootEnvCaptured = true;
+    }
+    process.env.GSD_PROJECT_ROOT = projectRoot;
+}
+function restoreProjectRootEnv() {
+    if (!s.projectRootEnvCaptured)
+        return;
+    if (s.hadProjectRootEnv && s.previousProjectRootEnv !== null) {
+        process.env.GSD_PROJECT_ROOT = s.previousProjectRootEnv;
+    }
+    else {
+        delete process.env.GSD_PROJECT_ROOT;
+    }
+    s.previousProjectRootEnv = null;
+    s.hadProjectRootEnv = false;
+    s.projectRootEnvCaptured = false;
+}
 export function shouldUseWorktreeIsolation() {
     const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
     if (prefs?.isolation === "worktree")
@@ -315,6 +338,7 @@ function handleLostSessionLock(ctx, lockStatus) {
     s.active = false;
     s.paused = false;
     clearUnitTimeout();
+    restoreProjectRootEnv();
     deregisterSigtermHandler();
     clearCmuxSidebar(loadEffectiveGSDPreferences()?.preferences);
     const base = lockBase();
@@ -345,6 +369,7 @@ function cleanupAfterLoopExit(ctx) {
     s.currentUnit = null;
     s.active = false;
     clearUnitTimeout();
+    restoreProjectRootEnv();
     // Clear crash lock and release session lock so the next `/gsd next` does
     // not see a stale lock with the current PID and treat it as a "remote"
     // session (which would cause it to SIGTERM itself). (#2730)
@@ -601,6 +626,7 @@ export async function stopAuto(ctx, pi, reason) {
         ctx?.ui.setStatus("gsd-auto", undefined);
         ctx?.ui.setWidget("gsd-progress", undefined);
         ctx?.ui.setFooter(undefined);
+        restoreProjectRootEnv();
         // Reset all session state in one call
         s.reset();
     }
@@ -641,6 +667,8 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
             stepMode: s.stepMode,
             pausedAt: new Date().toISOString(),
             sessionFile: s.pausedSessionFile,
+            unitType: s.currentUnit?.type ?? undefined,
+            unitId: s.currentUnit?.id ?? undefined,
             activeEngineId: s.activeEngineId,
             activeRunDir: s.activeRunDir,
             autoStartTime: s.autoStartTime,
@@ -674,6 +702,7 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     _resetPendingResolve();
     s.active = false;
     s.paused = true;
+    restoreProjectRootEnv();
     s.pendingVerificationRetry = null;
     s.verificationRetryCount.clear();
     ctx?.ui.setStatus("gsd-auto", "paused");
@@ -828,38 +857,54 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         return;
     }
     const requestedStepMode = options?.step ?? false;
+    const interruptedAssessment = options?.interrupted ?? null;
     // Escape stale worktree cwd from a previous milestone (#608).
     base = escapeStaleWorktree(base);
+    const freshStartAssessment = interruptedAssessment
+        ?? await assessInterruptedSession(base);
+    if (freshStartAssessment.classification === "running") {
+        const pid = freshStartAssessment.lock?.pid;
+        ctx.ui.notify(pid
+            ? `Another auto-mode session (PID ${pid}) appears to be running.\nStop it with \`kill ${pid}\` before starting a new session.`
+            : "Another auto-mode session appears to be running.", "error");
+        return;
+    }
     // If resuming from paused state, just re-activate and dispatch next unit.
     // Check persisted paused-session first (#1383) — survives /exit.
     if (!s.paused) {
         try {
+            const meta = freshStartAssessment.pausedSession ?? readPausedSessionMetadata(base);
             const pausedPath = join(gsdRoot(base), "runtime", "paused-session.json");
-            if (existsSync(pausedPath)) {
-                const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
-                if (meta.activeEngineId && meta.activeEngineId !== "dev") {
-                    // Custom workflow resume — restore engine state
-                    s.activeEngineId = meta.activeEngineId;
-                    s.activeRunDir = meta.activeRunDir ?? null;
-                    s.originalBasePath = meta.originalBasePath || base;
-                    s.stepMode = meta.stepMode ?? requestedStepMode;
-                    s.autoStartTime = meta.autoStartTime || Date.now();
-                    s.paused = true;
-                    // Don't delete pause file yet — defer until lock is acquired.
-                    // If lock fails, the file must survive for retry.
-                    s.pausedSessionFile = pausedPath;
-                    ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
+            if (meta?.activeEngineId && meta.activeEngineId !== "dev") {
+                // Custom workflow resume — restore engine state
+                s.activeEngineId = meta.activeEngineId;
+                s.activeRunDir = meta.activeRunDir ?? null;
+                s.originalBasePath = meta.originalBasePath || base;
+                s.stepMode = meta.stepMode ?? requestedStepMode;
+                s.autoStartTime = meta.autoStartTime || Date.now();
+                s.paused = true;
+                try {
+                    unlinkSync(pausedPath);
                 }
-                else if (meta.milestoneId) {
+                catch (e) {
+                    logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                }
+                ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
+            }
+            else if (meta?.milestoneId) {
+                const shouldResumePausedSession = freshStartAssessment.classification === "recoverable"
+                    && (freshStartAssessment.hasResumableDiskState
+                        || !!freshStartAssessment.recoveryPrompt
+                        || !!freshStartAssessment.lock);
+                if (shouldResumePausedSession) {
                     // Validate the milestone still exists and isn't already complete (#1664).
                     const mDir = resolveMilestonePath(base, meta.milestoneId);
                     const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
                     if (!mDir || summaryFile) {
-                        // Stale milestone — clean up and fall through to fresh bootstrap
                         try {
                             unlinkSync(pausedPath);
                         }
-                        catch (err) { /* non-fatal */
+                        catch (err) {
                             logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
                         }
                         ctx.ui.notify(`Paused milestone ${meta.milestoneId} is ${!mDir ? "missing" : "already complete"}. Starting fresh.`, "info");
@@ -868,12 +913,26 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         s.currentMilestoneId = meta.milestoneId;
                         s.originalBasePath = meta.originalBasePath || base;
                         s.stepMode = meta.stepMode ?? requestedStepMode;
+                        s.pausedSessionFile = meta.sessionFile ?? null;
+                        s.pausedUnitType = meta.unitType ?? null;
+                        s.pausedUnitId = meta.unitId ?? null;
                         s.autoStartTime = meta.autoStartTime || Date.now();
                         s.paused = true;
-                        // Don't delete pause file yet — defer until lock is acquired.
-                        // If lock fails, the file must survive for retry.
-                        s.pausedSessionFile = pausedPath;
-                        ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath ? ` (worktree)` : ""}.`, "info");
+                        try {
+                            unlinkSync(pausedPath);
+                        }
+                        catch (e) {
+                            logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
+                        }
+                        ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath && existsSync(meta.worktreePath) ? ` (worktree)` : ""}.`, "info");
+                    }
+                }
+                else if (existsSync(pausedPath)) {
+                    try {
+                        unlinkSync(pausedPath);
+                    }
+                    catch (e) {
+                        logWarning("session", `stale pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
                     }
                 }
             }
@@ -882,6 +941,30 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             // Malformed or missing — proceed with fresh bootstrap
             logWarning("session", `paused-session restore failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
+        // Guard against zero/missing autoStartTime after resume (#3585)
+        if (!s.autoStartTime || s.autoStartTime <= 0)
+            s.autoStartTime = Date.now();
+    }
+    if (!s.paused) {
+        s.stepMode = requestedStepMode;
+    }
+    if (freshStartAssessment.lock) {
+        clearLock(base);
+    }
+    if (!s.paused) {
+        s.pendingCrashRecovery =
+            freshStartAssessment.classification === "recoverable"
+                ? freshStartAssessment.recoveryPrompt
+                : null;
+        if (freshStartAssessment.classification === "recoverable" && freshStartAssessment.lock) {
+            const info = formatCrashInfo(freshStartAssessment.lock);
+            if (freshStartAssessment.recoveryToolCallCount > 0) {
+                ctx.ui.notify(`${info}\nRecovered ${freshStartAssessment.recoveryToolCallCount} tool calls from crashed session. Resuming with full context.`, "warning");
+            }
+            else if (freshStartAssessment.hasResumableDiskState) {
+                ctx.ui.notify(`${info}\nResuming from disk state.`, "warning");
+            }
+        }
     }
     if (s.paused) {
         const resumeLock = acquireSessionLock(base);
@@ -906,29 +989,19 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.active = true;
         s.verbose = verboseMode;
         s.stepMode = requestedStepMode;
-        // Preserve the original cmdCtx (ExtensionCommandContext with newSession)
-        // when resuming from a provider-error pause. The resume callback receives
-        // an ExtensionContext (from the agent_end hook) which lacks newSession —
-        // using it would crash runUnit with "newSession is not a function".
-        // Only override if the new ctx actually has newSession (user-initiated resume).
-        if ("newSession" in ctx && typeof ctx.newSession === "function") {
-            s.cmdCtx = ctx;
-        }
-        else if (!s.cmdCtx) {
-            // No saved cmdCtx — this shouldn't happen, but handle gracefully
-            s.cmdCtx = ctx;
-        }
-        // else: keep existing s.cmdCtx which has the real newSession
+        s.cmdCtx = ctx;
         s.basePath = base;
-        setLogBasePath(base);
-        if (!s.autoStartTime || s.autoStartTime <= 0)
-            s.autoStartTime = Date.now();
         s.unitDispatchCount.clear();
         s.unitLifetimeDispatches.clear();
         if (!getLedger())
             initMetrics(base);
         if (s.currentMilestoneId)
             setActiveMilestoneId(base, s.currentMilestoneId);
+        // Re-register health level notification callback lost across process restart
+        setLevelChangeCallback((_from, to, summary) => {
+            const level = to === "red" ? "error" : to === "yellow" ? "warning" : "info";
+            ctx.ui.notify(summary, level);
+        });
         // ── Auto-worktree: re-enter worktree on resume ──
         if (s.currentMilestoneId &&
             shouldUseWorktreeIsolation() &&
@@ -945,6 +1018,11 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         ctx.ui.setFooter(hideFooter);
         ctx.ui.notify(s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
         restoreHookState(s.basePath);
+        // Re-sync managed resources on resume so long-lived auto sessions pick up
+        // bundled extension updates before resume-time verification/state logic runs.
+        const agentDir = process.env.GSD_CODING_AGENT_DIR || join(process.env.GSD_HOME || homedir(), ".gsd", "agent");
+        const { initResources } = await import("../../../" + "resource-loader.js");
+        initResources(agentDir);
         // Open the project DB before rebuild/derive so resume uses DB-backed
         // state instead of falling back to stale markdown parsing (#2940).
         await openProjectDbIfPresent(s.basePath);
@@ -971,7 +1049,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         invalidateAllCaches();
         if (s.pausedSessionFile) {
             const activityDir = join(gsdRoot(s.basePath), "activity");
-            const recovery = synthesizeCrashRecovery(s.basePath, s.currentUnit?.type ?? "unknown", s.currentUnit?.id ?? "unknown", s.pausedSessionFile ?? undefined, activityDir);
+            const recovery = synthesizeCrashRecovery(s.basePath, s.currentUnit?.type ?? s.pausedUnitType ?? "unknown", s.currentUnit?.id ?? s.pausedUnitId ?? "unknown", s.pausedSessionFile ?? undefined, activityDir);
             if (recovery && recovery.trace.toolCallCount > 0) {
                 s.pendingCrashRecovery = recovery.prompt;
                 ctx.ui.notify(`Recovered ${recovery.trace.toolCallCount} tool calls from paused session. Resuming with context.`, "info");
@@ -981,6 +1059,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
+        captureProjectRootEnv(s.originalBasePath || s.basePath);
         await autoLoop(ctx, pi, s, buildLoopDeps());
         cleanupAfterLoopExit(ctx);
         return;
@@ -992,9 +1071,10 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         lockBase,
         buildResolver,
     };
-    const ready = await bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, bootstrapDeps);
+    const ready = await bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, bootstrapDeps, freshStartAssessment);
     if (!ready)
         return;
+    captureProjectRootEnv(s.originalBasePath || s.basePath);
     try {
         syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
     }
@@ -1074,24 +1154,6 @@ function ensurePreconditions(unitType, unitId, base, state) {
         }
     }
 }
-// ─── Diagnostics ──────────────────────────────────────────────────────────────
-/** Build recovery context from module state for recoverTimedOutUnit */
-function buildRecoveryContext() {
-    return {
-        basePath: s.basePath,
-        verbose: s.verbose,
-        currentUnitStartedAt: s.currentUnit?.startedAt ?? Date.now(),
-        unitRecoveryCount: s.unitRecoveryCount,
-    };
-}
-/**
- * Test-only: expose skip-loop state for unit tests.
- * Not part of the public API.
- */
-/**
- * Dispatch a hook unit directly, bypassing normal pre-dispatch hooks.
- * Used for manual hook triggers via /gsd run-hook.
- */
 export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, triggerUnitId, hookPrompt, hookModel, targetBasePath) {
     if (!s.active) {
         s.active = true;