gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

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

@@ -0,0 +1,393 @@
+/**
+ * Auto-mode bootstrap — fresh-start initialization path.
+ *
+ * Git/state bootstrap, crash lock detection, debug init, worktree recovery,
+ * guided flow gate, session init, worktree lifecycle, DB lifecycle,
+ * preflight validation.
+ *
+ * Extracted from startAuto() in auto.ts. The resume path (s.paused)
+ * remains in auto.ts — this module handles only the fresh-start path.
+ */
+import { deriveState } from "./state.js";
+import { loadFile, getManifestStatus } from "./files.js";
+import { loadEffectiveGSDPreferences, resolveSkillDiscoveryMode, getIsolationMode } from "./preferences.js";
+import { isInsideWorktree, ensureGsdSymlink } from "./repo-identity.js";
+import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
+import { sendDesktopNotification } from "./notifications.js";
+import { sendRemoteNotification } from "../remote-questions/notify.js";
+import { gsdRoot, resolveMilestoneFile, } from "./paths.js";
+import { invalidateAllCaches } from "./cache.js";
+import { synthesizeCrashRecovery } from "./session-forensics.js";
+import { writeLock, clearLock, readCrashLock, formatCrashInfo } from "./crash-recovery.js";
+import { acquireSessionLock, updateSessionLock, } from "./session-lock.js";
+import { selfHealRuntimeRecords } from "./auto-recovery.js";
+import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
+import { nativeIsRepo, nativeInit } from "./native-git-bridge.js";
+import { createGitService } from "./git-service.js";
+import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
+import { createAutoWorktree, enterAutoWorktree, getAutoWorktreePath, } from "./auto-worktree.js";
+import { readResourceVersion } from "./resource-version.js";
+import { initMetrics } from "./metrics.js";
+import { initRoutingHistory } from "./routing-history.js";
+import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
+import { resetProactiveHealing } from "./doctor-proactive.js";
+import { snapshotSkills } from "./skill-discovery.js";
+import { isDbAvailable } from "./gsd-db.js";
+import { loadPersistedKeys } from "./auto-recovery.js";
+import { hideFooter } from "./auto-dashboard.js";
+import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath } from "./debug-logger.js";
+import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { getErrorMessage } from "./error-utils.js";
+import { parseUnitId } from "./unit-id.js";
+/**
+ * Bootstrap a fresh auto-mode session. Handles everything from git init
+ * through secrets collection, returning when ready for the first
+ * dispatchNextUnit call.
+ *
+ * Returns false if the bootstrap aborted (e.g., guided flow returned,
+ * concurrent session detected). Returns true when ready to dispatch.
+ */
+export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, deps) {
+    const { shouldUseWorktreeIsolation, registerSigtermHandler, lockBase } = deps;
+    // ── Session lock: acquire FIRST, before any state mutation ──────────────
+    // This is the primary guard against concurrent sessions on the same project.
+    // Uses OS-level file locking (proper-lockfile) to prevent TOCTOU races.
+    const lockResult = acquireSessionLock(base);
+    if (!lockResult.acquired) {
+        ctx.ui.notify(`${lockResult.reason}\nStop it with \`kill ${lockResult.existingPid ?? "the other process"}\` before starting a new session.`, "error");
+        return false;
+    }
+    // Ensure git repo exists
+    if (!nativeIsRepo(base)) {
+        const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
+        nativeInit(base, mainBranch);
+    }
+    // Ensure .gitignore has baseline patterns
+    const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
+    const manageGitignore = gitPrefs?.manage_gitignore;
+    ensureGitignore(base, { manageGitignore });
+    if (manageGitignore !== false)
+        untrackRuntimeFiles(base);
+    // Migrate legacy in-project .gsd/ to external state directory
+    recoverFailedMigration(base);
+    const migration = migrateToExternalState(base);
+    if (migration.error) {
+        ctx.ui.notify(`External state migration warning: ${migration.error}`, "warning");
+    }
+    // Ensure symlink exists (handles fresh projects and post-migration)
+    ensureGsdSymlink(base);
+    // Bootstrap .gsd/ if it doesn't exist
+    const gsdDir = gsdRoot(base);
+    if (!existsSync(gsdDir)) {
+        mkdirSync(join(gsdDir, "milestones"), { recursive: true });
+    }
+    // Initialize GitServiceImpl
+    s.gitService = createGitService(s.basePath);
+    // Check for crash from previous session (use both old and new lock data).
+    // Skip if the lock PID matches this process — acquireSessionLock() writes
+    // to the same auto.lock file before this check, so we'd always false-positive.
+    const crashLock = readCrashLock(base);
+    if (crashLock && crashLock.pid !== process.pid) {
+        // We already hold the session lock, so no concurrent session is running.
+        // The crash lock is from a dead process — recover context from it.
+        const recoveredMid = parseUnitId(crashLock.unitId).milestone;
+        const milestoneAlreadyComplete = recoveredMid
+            ? !!resolveMilestoneFile(base, recoveredMid, "SUMMARY")
+            : false;
+        if (milestoneAlreadyComplete) {
+            ctx.ui.notify(`Crash recovery: discarding stale context for ${crashLock.unitId} — milestone ${recoveredMid} is already complete.`, "info");
+        }
+        else {
+            const activityDir = join(gsdRoot(base), "activity");
+            const recovery = synthesizeCrashRecovery(base, crashLock.unitType, crashLock.unitId, crashLock.sessionFile, activityDir);
+            if (recovery && recovery.trace.toolCallCount > 0) {
+                s.pendingCrashRecovery = recovery.prompt;
+                ctx.ui.notify(`${formatCrashInfo(crashLock)}\nRecovered ${recovery.trace.toolCallCount} tool calls from crashed session. Resuming with full context.`, "warning");
+            }
+            else {
+                ctx.ui.notify(`${formatCrashInfo(crashLock)}\nNo session data recovered. Resuming from disk state.`, "warning");
+            }
+        }
+        clearLock(base);
+    }
+    // ── Debug mode ──
+    if (!isDebugEnabled() && process.env.GSD_DEBUG === "1") {
+        enableDebug(base);
+    }
+    if (isDebugEnabled()) {
+        const { isNativeParserAvailable } = await import("./native-parser-bridge.js");
+        debugLog("debug-start", {
+            platform: process.platform,
+            arch: process.arch,
+            node: process.version,
+            model: ctx.model?.id ?? "unknown",
+            provider: ctx.model?.provider ?? "unknown",
+            nativeParser: isNativeParserAvailable(),
+            cwd: base,
+        });
+        ctx.ui.notify(`Debug logging enabled → ${getDebugLogPath()}`, "info");
+    }
+    // Invalidate caches before initial state derivation
+    invalidateAllCaches();
+    // Clean stale runtime unit files for completed milestones (#887)
+    try {
+        const runtimeUnitsDir = join(gsdRoot(base), "runtime", "units");
+        if (existsSync(runtimeUnitsDir)) {
+            for (const file of readdirSync(runtimeUnitsDir)) {
+                if (!file.endsWith(".json"))
+                    continue;
+                const midMatch = file.match(/(M\d+(?:-[a-z0-9]{6})?)/);
+                if (!midMatch)
+                    continue;
+                const mid = midMatch[1];
+                if (resolveMilestoneFile(base, mid, "SUMMARY")) {
+                    try {
+                        unlinkSync(join(runtimeUnitsDir, file));
+                    }
+                    catch (e) {
+                        debugLog("stale-unit-cleanup-failed", { file, error: getErrorMessage(e) });
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        debugLog("stale-unit-dir-cleanup-failed", { error: getErrorMessage(e) });
+    }
+    let state = await deriveState(base);
+    // Milestone branch recovery (#601)
+    let hasSurvivorBranch = false;
+    if (state.activeMilestone &&
+        (state.phase === "pre-planning" || state.phase === "needs-discussion") &&
+        shouldUseWorktreeIsolation() &&
+        !detectWorktreeName(base) &&
+        !isInsideWorktree(base)) {
+        const milestoneBranch = `milestone/${state.activeMilestone.id}`;
+        const { nativeBranchExists } = await import("./native-git-bridge.js");
+        hasSurvivorBranch = nativeBranchExists(base, milestoneBranch);
+        if (hasSurvivorBranch) {
+            ctx.ui.notify(`Found prior session branch ${milestoneBranch}. Resuming.`, "info");
+        }
+    }
+    if (!hasSurvivorBranch) {
+        // No active work — start a new milestone via discuss flow
+        if (!state.activeMilestone || state.phase === "complete") {
+            const { showSmartEntry } = await import("./guided-flow.js");
+            await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
+            invalidateAllCaches();
+            const postState = await deriveState(base);
+            if (postState.activeMilestone && postState.phase !== "complete" && postState.phase !== "pre-planning") {
+                state = postState;
+            }
+            else if (postState.activeMilestone && postState.phase === "pre-planning") {
+                const contextFile = resolveMilestoneFile(base, postState.activeMilestone.id, "CONTEXT");
+                const hasContext = !!(contextFile && await loadFile(contextFile));
+                if (hasContext) {
+                    state = postState;
+                }
+                else {
+                    ctx.ui.notify("Discussion completed but no milestone context was written. Run /gsd to try the discussion again, or /gsd auto after creating the milestone manually.", "warning");
+                    return false;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        // Active milestone exists but has no roadmap
+        if (state.phase === "pre-planning") {
+            const mid = state.activeMilestone.id;
+            const contextFile = resolveMilestoneFile(base, mid, "CONTEXT");
+            const hasContext = !!(contextFile && await loadFile(contextFile));
+            if (!hasContext) {
+                const { showSmartEntry } = await import("./guided-flow.js");
+                await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
+                invalidateAllCaches();
+                const postState = await deriveState(base);
+                if (postState.activeMilestone && postState.phase !== "pre-planning") {
+                    state = postState;
+                }
+                else {
+                    ctx.ui.notify("Discussion completed but milestone context is still missing. Run /gsd to try again.", "warning");
+                    return false;
+                }
+            }
+        }
+    }
+    // Unreachable safety check
+    if (!state.activeMilestone) {
+        const { showSmartEntry } = await import("./guided-flow.js");
+        await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
+        return false;
+    }
+    // ── Initialize session state ──
+    s.active = true;
+    s.stepMode = requestedStepMode;
+    s.verbose = verboseMode;
+    s.cmdCtx = ctx;
+    s.basePath = base;
+    s.unitDispatchCount.clear();
+    s.unitRecoveryCount.clear();
+    s.unitConsecutiveSkips.clear();
+    s.lastBudgetAlertLevel = 0;
+    s.unitLifetimeDispatches.clear();
+    s.completedKeySet.clear();
+    loadPersistedKeys(base, s.completedKeySet);
+    resetHookState();
+    restoreHookState(base);
+    resetProactiveHealing();
+    s.autoStartTime = Date.now();
+    s.resourceVersionOnStart = readResourceVersion();
+    s.completedUnits = [];
+    s.pendingQuickTasks = [];
+    s.currentUnit = null;
+    s.currentMilestoneId = state.activeMilestone?.id ?? null;
+    s.originalModelId = ctx.model?.id ?? null;
+    s.originalModelProvider = ctx.model?.provider ?? null;
+    // Register SIGTERM handler
+    registerSigtermHandler(base);
+    // Capture integration branch
+    if (s.currentMilestoneId) {
+        if (getIsolationMode() !== "none") {
+            captureIntegrationBranch(base, s.currentMilestoneId);
+        }
+        setActiveMilestoneId(base, s.currentMilestoneId);
+    }
+    // ── Auto-worktree setup ──
+    s.originalBasePath = base;
+    if (s.currentMilestoneId && shouldUseWorktreeIsolation() && !detectWorktreeName(base) && !isInsideWorktree(base)) {
+        try {
+            const existingWtPath = getAutoWorktreePath(base, s.currentMilestoneId);
+            if (existingWtPath) {
+                const wtPath = enterAutoWorktree(base, s.currentMilestoneId);
+                s.basePath = wtPath;
+                s.gitService = createGitService(s.basePath);
+                ctx.ui.notify(`Entered auto-worktree at ${wtPath}`, "info");
+            }
+            else {
+                const wtPath = createAutoWorktree(base, s.currentMilestoneId);
+                s.basePath = wtPath;
+                s.gitService = createGitService(s.basePath);
+                ctx.ui.notify(`Created auto-worktree at ${wtPath}`, "info");
+            }
+            registerSigtermHandler(s.originalBasePath);
+        }
+        catch (err) {
+            ctx.ui.notify(`Auto-worktree setup failed: ${getErrorMessage(err)}. Continuing in project root.`, "warning");
+        }
+    }
+    // ── DB lifecycle ──
+    const gsdDbPath = join(gsdRoot(s.basePath), "gsd.db");
+    const gsdDirPath = gsdRoot(s.basePath);
+    if (existsSync(gsdDirPath) && !existsSync(gsdDbPath)) {
+        const hasDecisions = existsSync(join(gsdDirPath, "DECISIONS.md"));
+        const hasRequirements = existsSync(join(gsdDirPath, "REQUIREMENTS.md"));
+        const hasMilestones = existsSync(join(gsdDirPath, "milestones"));
+        if (hasDecisions || hasRequirements || hasMilestones) {
+            try {
+                const { openDatabase: openDb } = await import("./gsd-db.js");
+                const { migrateFromMarkdown } = await import("./md-importer.js");
+                openDb(gsdDbPath);
+                migrateFromMarkdown(s.basePath);
+            }
+            catch (err) {
+                process.stderr.write(`gsd-migrate: auto-migration failed: ${err.message}\n`);
+            }
+        }
+    }
+    if (existsSync(gsdDbPath) && !isDbAvailable()) {
+        try {
+            const { openDatabase: openDb } = await import("./gsd-db.js");
+            openDb(gsdDbPath);
+        }
+        catch (err) {
+            process.stderr.write(`gsd-db: failed to open existing database: ${err.message}\n`);
+        }
+    }
+    // Initialize metrics
+    initMetrics(s.basePath);
+    // Initialize routing history
+    initRoutingHistory(s.basePath);
+    // Capture session's model at auto-mode start (#650)
+    const currentModel = ctx.model;
+    if (currentModel) {
+        s.autoModeStartModel = { provider: currentModel.provider, id: currentModel.id };
+    }
+    // Snapshot installed skills
+    if (resolveSkillDiscoveryMode() !== "off") {
+        snapshotSkills();
+    }
+    ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+    ctx.ui.setFooter(hideFooter);
+    const modeLabel = s.stepMode ? "Step-mode" : "Auto-mode";
+    const pendingCount = (state.registry ?? []).filter(m => m.status !== 'complete' && m.status !== 'parked').length;
+    const scopeMsg = pendingCount > 1
+        ? `Will loop through ${pendingCount} milestones.`
+        : "Will loop until milestone complete.";
+    ctx.ui.notify(`${modeLabel} started. ${scopeMsg}`, "info");
+    // Update lock file with milestone info (OS lock already acquired at bootstrap start)
+    updateSessionLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown", 0);
+    writeLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown", 0);
+    // Secrets collection gate — pause instead of blocking (#1146)
+    const mid = state.activeMilestone.id;
+    try {
+        const manifestStatus = await getManifestStatus(base, mid);
+        if (manifestStatus && manifestStatus.pending.length > 0) {
+            const pendingKeys = manifestStatus.pending;
+            const keyList = pendingKeys.map((k) => `  • ${k}`).join("\n");
+            s.paused = true;
+            s.pausedForSecrets = true;
+            ctx.ui.notify(`Auto-mode paused: ${pendingKeys.length} env variable${pendingKeys.length > 1 ? "s" : ""} needed for ${mid}.\n${keyList}\n\nCollect them with /gsd secrets, then resume with /gsd auto.`, "warning");
+            ctx.ui.setStatus("gsd-auto", "paused");
+            sendDesktopNotification("GSD — Secrets Required", `${pendingKeys.length} env variable(s) needed for ${mid}. Run /gsd secrets to provide them.`, "warning", "attention");
+            // Notify remote channel if configured (one-way — never collect secrets via remote)
+            sendRemoteNotification("GSD — Secrets Required", `Auto-mode paused: ${pendingKeys.length} env variable(s) needed for ${mid}.\n${keyList}\n\nReturn to the terminal and run /gsd secrets to provide them securely.`).catch(() => { }); // fire-and-forget
+            return false;
+        }
+    }
+    catch (err) {
+        ctx.ui.notify(`Secrets check error: ${getErrorMessage(err)}. Continuing without secrets.`, "warning");
+    }
+    // Self-heal: clear stale runtime records
+    await selfHealRuntimeRecords(s.basePath, ctx, s.completedKeySet);
+    // Self-heal: remove stale .git/index.lock
+    try {
+        const gitLockFile = join(base, ".git", "index.lock");
+        if (existsSync(gitLockFile)) {
+            const lockAge = Date.now() - statSync(gitLockFile).mtimeMs;
+            if (lockAge > 60_000) {
+                unlinkSync(gitLockFile);
+                ctx.ui.notify("Removed stale .git/index.lock from prior crash.", "info");
+            }
+        }
+    }
+    catch (e) {
+        debugLog("git-lock-cleanup-failed", { error: getErrorMessage(e) });
+    }
+    // Pre-flight: validate milestone queue
+    try {
+        const msDir = join(gsdRoot(base), "milestones");
+        if (existsSync(msDir)) {
+            const milestoneIds = readdirSync(msDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && /^M\d{3}/.test(d.name))
+                .map(d => d.name.match(/^(M\d{3})/)?.[1] ?? d.name);
+            if (milestoneIds.length > 1) {
+                const issues = [];
+                for (const id of milestoneIds) {
+                    const draft = resolveMilestoneFile(base, id, "CONTEXT-DRAFT");
+                    if (draft)
+                        issues.push(`${id}: has CONTEXT-DRAFT.md (will pause for discussion)`);
+                }
+                if (issues.length > 0) {
+                    ctx.ui.notify(`Pre-flight: ${milestoneIds.length} milestones queued.\n${issues.map(i => `  ⚠ ${i}`).join("\n")}`, "warning");
+                }
+                else {
+                    ctx.ui.notify(`Pre-flight: ${milestoneIds.length} milestones queued. All have full context.`, "info");
+                }
+            }
+        }
+    }
+    catch { /* non-fatal */ }
+    return true;
+}

package/dist/resources/extensions/gsd/auto-stuck-detection.js

@@ -0,0 +1,165 @@
+/**
+ * Stuck detection and loop recovery for auto-mode unit dispatch.
+ *
+ * Tracks dispatch counts per unit, enforces lifetime caps, and attempts
+ * stub/artifact recovery before stopping.
+ *
+ * Extracted from dispatchNextUnit() in auto.ts. Returns action values
+ * instead of calling stopAuto/dispatchNextUnit — the caller handles
+ * control flow.
+ */
+import { inspectExecuteTaskDurability, } from "./unit-runtime.js";
+import { verifyExpectedArtifact, diagnoseExpectedArtifact, skipExecuteTask, persistCompletedKey, buildLoopRemediationSteps, } from "./auto-recovery.js";
+import { closeoutUnit } from "./auto-unit-closeout.js";
+import { saveActivityLog } from "./activity-log.js";
+import { invalidateAllCaches } from "./cache.js";
+import { sendDesktopNotification } from "./notifications.js";
+import { debugLog } from "./debug-logger.js";
+import { resolveMilestonePath, resolveSlicePath, resolveTasksDir, buildTaskFileName, } from "./paths.js";
+import { MAX_UNIT_DISPATCHES, STUB_RECOVERY_THRESHOLD, MAX_LIFETIME_DISPATCHES, } from "./auto/session.js";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseUnitId } from "./unit-id.js";
+/**
+ * Check dispatch counts, enforce lifetime cap and MAX_UNIT_DISPATCHES,
+ * attempt stub/artifact recovery. Returns an action for the caller.
+ */
+export async function checkStuckAndRecover(sctx) {
+    const { s, ctx, unitType, unitId, basePath, buildSnapshotOpts } = sctx;
+    const dispatchKey = `${unitType}/${unitId}`;
+    const prevCount = s.unitDispatchCount.get(dispatchKey) ?? 0;
+    // Real dispatch reached — clear the consecutive-skip counter for this unit.
+    s.unitConsecutiveSkips.delete(dispatchKey);
+    debugLog("dispatch-unit", {
+        type: unitType,
+        id: unitId,
+        cycle: prevCount + 1,
+        lifetime: (s.unitLifetimeDispatches.get(dispatchKey) ?? 0) + 1,
+    });
+    // Hard lifetime cap — survives counter resets from loop-recovery/self-repair.
+    const lifetimeCount = (s.unitLifetimeDispatches.get(dispatchKey) ?? 0) + 1;
+    s.unitLifetimeDispatches.set(dispatchKey, lifetimeCount);
+    if (lifetimeCount > MAX_LIFETIME_DISPATCHES) {
+        if (s.currentUnit) {
+            await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts());
+        }
+        else {
+            saveActivityLog(ctx, s.basePath, unitType, unitId);
+        }
+        const expected = diagnoseExpectedArtifact(unitType, unitId, basePath);
+        return {
+            action: "stop",
+            reason: `Hard loop: ${unitType} ${unitId}`,
+            notifyMessage: `Hard loop detected: ${unitType} ${unitId} dispatched ${lifetimeCount} times total (across reconciliation cycles).${expected ? `\n   Expected artifact: ${expected}` : ""}\n   This may indicate deriveState() keeps returning the same unit despite artifacts existing.\n   Check .gsd/completed-units.json and the slice plan checkbox state.`,
+        };
+    }
+    if (prevCount >= MAX_UNIT_DISPATCHES) {
+        if (s.currentUnit) {
+            await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, buildSnapshotOpts());
+        }
+        else {
+            saveActivityLog(ctx, s.basePath, unitType, unitId);
+        }
+        // Final reconciliation pass for execute-task
+        if (unitType === "execute-task") {
+            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+            if (mid && sid && tid) {
+                const status = await inspectExecuteTaskDurability(basePath, unitId);
+                if (status) {
+                    const reconciled = skipExecuteTask(basePath, mid, sid, tid, status, "loop-recovery", prevCount);
+                    if (reconciled && verifyExpectedArtifact(unitType, unitId, basePath)) {
+                        ctx.ui.notify(`Loop recovery: ${unitId} reconciled after ${prevCount + 1} dispatches — blocker artifacts written, pipeline advancing.\n   Review ${status.summaryPath} and replace the placeholder with real work.`, "warning");
+                        const reconciledKey = `${unitType}/${unitId}`;
+                        persistCompletedKey(basePath, reconciledKey);
+                        s.completedKeySet.add(reconciledKey);
+                        s.unitDispatchCount.delete(dispatchKey);
+                        invalidateAllCaches();
+                        return { action: "recovered", dispatchAgain: true };
+                    }
+                }
+            }
+        }
+        // General reconciliation: artifact appeared on last attempt
+        if (verifyExpectedArtifact(unitType, unitId, basePath)) {
+            ctx.ui.notify(`Loop recovery: ${unitType} ${unitId} — artifact verified after ${prevCount + 1} dispatches. Advancing.`, "info");
+            persistCompletedKey(basePath, dispatchKey);
+            s.completedKeySet.add(dispatchKey);
+            s.unitDispatchCount.delete(dispatchKey);
+            invalidateAllCaches();
+            return { action: "recovered", dispatchAgain: true };
+        }
+        // Last resort for complete-milestone: generate stub summary
+        if (unitType === "complete-milestone") {
+            try {
+                const mPath = resolveMilestonePath(basePath, unitId);
+                if (mPath) {
+                    const stubPath = join(mPath, `${unitId}-SUMMARY.md`);
+                    if (!existsSync(stubPath)) {
+                        writeFileSync(stubPath, `# ${unitId} Summary\n\nAuto-generated stub — milestone tasks completed but summary generation failed after ${prevCount + 1} attempts.\nReview and replace this stub with a proper summary.\n`);
+                        ctx.ui.notify(`Generated stub summary for ${unitId} to unblock pipeline. Review later.`, "warning");
+                        persistCompletedKey(basePath, dispatchKey);
+                        s.completedKeySet.add(dispatchKey);
+                        s.unitDispatchCount.delete(dispatchKey);
+                        invalidateAllCaches();
+                        return { action: "recovered", dispatchAgain: true };
+                    }
+                }
+            }
+            catch { /* non-fatal — fall through to normal stop */ }
+        }
+        const expected = diagnoseExpectedArtifact(unitType, unitId, basePath);
+        const remediation = buildLoopRemediationSteps(unitType, unitId, basePath);
+        sendDesktopNotification("GSD", `Loop detected: ${unitType} ${unitId}`, "error", "error");
+        return {
+            action: "stop",
+            reason: `Loop: ${unitType} ${unitId}`,
+            notifyMessage: `Loop detected: ${unitType} ${unitId} dispatched ${prevCount + 1} times total. Expected artifact not found.${expected ? `\n   Expected: ${expected}` : ""}${remediation ? `\n\n   Remediation steps:\n${remediation}` : "\n   Check branch state and .gsd/ artifacts."}`,
+        };
+    }
+    s.unitDispatchCount.set(dispatchKey, prevCount + 1);
+    if (prevCount > 0) {
+        // Adaptive self-repair: each retry attempts a different remediation step.
+        if (unitType === "execute-task") {
+            const status = await inspectExecuteTaskDurability(basePath, unitId);
+            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+            if (status && mid && sid && tid) {
+                if (status.summaryExists && !status.taskChecked) {
+                    const repaired = skipExecuteTask(basePath, mid, sid, tid, status, "self-repair", 0);
+                    if (repaired && verifyExpectedArtifact(unitType, unitId, basePath)) {
+                        ctx.ui.notify(`Self-repaired ${unitId}: summary existed but checkbox was unmarked. Marked [x] and advancing.`, "warning");
+                        const repairedKey = `${unitType}/${unitId}`;
+                        persistCompletedKey(basePath, repairedKey);
+                        s.completedKeySet.add(repairedKey);
+                        s.unitDispatchCount.delete(dispatchKey);
+                        invalidateAllCaches();
+                        return { action: "recovered", dispatchAgain: true };
+                    }
+                }
+                else if (prevCount >= STUB_RECOVERY_THRESHOLD && !status.summaryExists) {
+                    const tasksDir = resolveTasksDir(basePath, mid, sid);
+                    const sDir = resolveSlicePath(basePath, mid, sid);
+                    const targetDir = tasksDir ?? (sDir ? join(sDir, "tasks") : null);
+                    if (targetDir) {
+                        if (!existsSync(targetDir))
+                            mkdirSync(targetDir, { recursive: true });
+                        const summaryPath = join(targetDir, buildTaskFileName(tid, "SUMMARY"));
+                        if (!existsSync(summaryPath)) {
+                            const stubContent = [
+                                `# PARTIAL RECOVERY — attempt ${prevCount + 1} of ${MAX_UNIT_DISPATCHES}`,
+                                ``,
+                                `Task \`${tid}\` in slice \`${sid}\` (milestone \`${mid}\`) has not yet produced a real summary.`,
+                                `This placeholder was written by auto-mode after ${prevCount} dispatch attempts.`,
+                                ``,
+                                `The next agent session will retry this task. Replace this file with real work when done.`,
+                            ].join("\n");
+                            writeFileSync(summaryPath, stubContent, "utf-8");
+                            ctx.ui.notify(`Stub recovery (attempt ${prevCount + 1}/${MAX_UNIT_DISPATCHES}): ${unitId} stub summary placeholder written. Retrying with recovery context.`, "warning");
+                        }
+                    }
+                }
+            }
+        }
+        ctx.ui.notify(`${unitType} ${unitId} didn't produce expected artifact. Retrying (${prevCount + 1}/${MAX_UNIT_DISPATCHES}).`, "warning");
+    }
+    return { action: "proceed" };
+}

package/dist/resources/extensions/gsd/{auto-supervisor.ts → auto-supervisor.js}

@@ -1,56 +1,53 @@
 /**
- * Auto-mode Supervisor — SIGTERM handling and working-tree activity detection.
+ * Auto-mode Supervisor — signal handling and working-tree activity detection.
  *
  * Pure functions — no module-level globals or AutoContext dependency.
  */
-
 import { clearLock } from "./crash-recovery.js";
 import { releaseSessionLock } from "./session-lock.js";
 import { nativeHasChanges } from "./native-git-bridge.js";
-
-// ─── SIGTERM Handling ─────────────────────────────────────────────────────────
-
+// ─── Signal Handling ──────────────────────────────────────────────────────────
 /**
- * Register a SIGTERM handler that clears the lock file and exits cleanly.
+ * Register SIGTERM and SIGINT handlers that clear lock files and exit cleanly.
  * Captures the active base path at registration time so the handler
  * always references the correct path even if the module variable changes.
  * Removes any previously registered handler before installing the new one.
  *
  * Returns the new handler so the caller can store and deregister it later.
  */
-export function registerSigtermHandler(
-  currentBasePath: string,
-  previousHandler: (() => void) | null,
-): () => void {
-  if (previousHandler) process.off("SIGTERM", previousHandler);
-  const handler = () => {
-    releaseSessionLock(currentBasePath);
-    clearLock(currentBasePath);
-    process.exit(0);
-  };
-  process.on("SIGTERM", handler);
-  return handler;
+export function registerSigtermHandler(currentBasePath, previousHandler) {
+    if (previousHandler) {
+        process.off("SIGTERM", previousHandler);
+        process.off("SIGINT", previousHandler);
+    }
+    const handler = () => {
+        releaseSessionLock(currentBasePath);
+        clearLock(currentBasePath);
+        process.exit(0);
+    };
+    process.on("SIGTERM", handler);
+    process.on("SIGINT", handler);
+    return handler;
 }
-
-/** Deregister the SIGTERM handler (called on stop/pause). */
-export function deregisterSigtermHandler(handler: (() => void) | null): void {
-  if (handler) {
-    process.off("SIGTERM", handler);
-  }
+/** Deregister signal handlers (called on stop/pause). */
+export function deregisterSigtermHandler(handler) {
+    if (handler) {
+        process.off("SIGTERM", handler);
+        process.off("SIGINT", handler);
+    }
 }
-
 // ─── Working Tree Activity Detection ──────────────────────────────────────────
-
 /**
  * Detect whether the agent is producing work on disk by checking git for
  * any working-tree changes (staged, unstaged, or untracked). Returns true
  * if there are uncommitted changes — meaning the agent is actively working,
  * even though it hasn't signaled progress through runtime records.
  */
-export function detectWorkingTreeActivity(cwd: string): boolean {
-  try {
-    return nativeHasChanges(cwd);
-  } catch {
-    return false;
-  }
+export function detectWorkingTreeActivity(cwd) {
+    try {
+        return nativeHasChanges(cwd);
+    }
+    catch {
+        return false;
+    }
 }