@litmers/cursorflow-orchestrator 0.1.18 → 0.1.26

package/dist/core/auto-recovery.js

@@ -0,0 +1,737 @@
+"use strict";
+/**
+ * Auto-Recovery Module
+ *
+ * Automatic recovery strategies for common orchestration failures:
+ * - Agent idle/no response detection with escalating interventions
+ * - Guidance messages for git conflicts and push failures
+ * - Process health monitoring with restart capabilities
+ * - Doctor integration for persistent failures
+ * - POF (Post-mortem of Failure) saving for failed recoveries
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoRecoveryManager = exports.DEFAULT_AUTO_RECOVERY_CONFIG = exports.RecoveryStage = void 0;
+exports.getGitPushFailureGuidance = getGitPushFailureGuidance;
+exports.getMergeConflictGuidance = getMergeConflictGuidance;
+exports.getGitErrorGuidance = getGitErrorGuidance;
+exports.savePOF = savePOF;
+exports.createPOFFromRecoveryState = createPOFFromRecoveryState;
+exports.loadPOF = loadPOF;
+exports.listPOFs = listPOFs;
+exports.getAutoRecoveryManager = getAutoRecoveryManager;
+exports.resetAutoRecoveryManager = resetAutoRecoveryManager;
+const fs = __importStar(require("fs"));
+const logger = __importStar(require("../utils/logger"));
+const events_1 = require("../utils/events");
+const path_1 = require("../utils/path");
+const health_1 = require("../utils/health");
+// ============================================================================
+// Types & Constants
+// ============================================================================
+/** Recovery stages for escalating interventions */
+var RecoveryStage;
+(function (RecoveryStage) {
+    /** Normal operation - monitoring */
+    RecoveryStage[RecoveryStage["NORMAL"] = 0] = "NORMAL";
+    /** First intervention - send continue signal */
+    RecoveryStage[RecoveryStage["CONTINUE_SIGNAL"] = 1] = "CONTINUE_SIGNAL";
+    /** Second intervention - send stronger prompt */
+    RecoveryStage[RecoveryStage["STRONGER_PROMPT"] = 2] = "STRONGER_PROMPT";
+    /** Third intervention - kill and restart process */
+    RecoveryStage[RecoveryStage["RESTART_PROCESS"] = 3] = "RESTART_PROCESS";
+    /** Final stage - run doctor and report */
+    RecoveryStage[RecoveryStage["DIAGNOSE"] = 4] = "DIAGNOSE";
+    /** No more recovery possible */
+    RecoveryStage[RecoveryStage["ABORT"] = 5] = "ABORT";
+})(RecoveryStage || (exports.RecoveryStage = RecoveryStage = {}));
+/** Default auto-recovery configuration */
+exports.DEFAULT_AUTO_RECOVERY_CONFIG = {
+    idleTimeoutMs: 60 * 1000, // 1 minute - quick detection
+    continueGraceMs: 60 * 1000, // 1 minute after continue
+    strongerPromptGraceMs: 60 * 1000, // 1 minute after stronger prompt
+    maxRestarts: 2,
+    runDoctorOnFailure: true,
+    longOperationPatterns: [
+        /installing\s+dependencies/i,
+        /npm\s+(i|install|ci)/i,
+        /pnpm\s+(i|install)/i,
+        /yarn\s+(install)?/i,
+        /building/i,
+        /compiling/i,
+        /bundling/i,
+        /downloading/i,
+        /fetching/i,
+        /cloning/i,
+    ],
+    longOperationGraceMs: 10 * 60 * 1000, // 10 minutes for long ops
+    verbose: false,
+};
+// ============================================================================
+// Guidance Messages for Git Issues
+// ============================================================================
+/** Generate guidance message for git push failure */
+function getGitPushFailureGuidance() {
+    return `[SYSTEM INTERVENTION] Git push가 실패했습니다. 다음 단계를 수행해주세요:
+
+1. 먼저 원격 변경사항을 가져오세요:
+   \`\`\`bash
+   git fetch origin
+   git pull --rebase origin HEAD
+   \`\`\`
+
+2. 충돌이 발생하면 해결하세요:
+   - 충돌 파일을 확인하고 수정
+   - git add로 스테이징
+   - git rebase --continue 실행
+
+3. 다시 푸시하세요:
+   \`\`\`bash
+   git push origin HEAD
+   \`\`\`
+
+작업을 계속 진행해주세요.`;
+}
+/** Generate guidance message for merge conflict */
+function getMergeConflictGuidance() {
+    return `[SYSTEM INTERVENTION] Merge conflict가 발생했습니다. 다음 단계를 수행해주세요:
+
+1. 충돌 파일 확인:
+   \`\`\`bash
+   git status
+   \`\`\`
+
+2. 각 충돌 파일을 열어서 수동으로 해결:
+   - <<<<<<< 와 >>>>>>> 사이의 내용을 확인
+   - 적절한 코드를 선택하거나 병합
+   - 충돌 마커 제거
+
+3. 해결 후 스테이징 및 커밋:
+   \`\`\`bash
+   git add -A
+   git commit -m "chore: resolve merge conflict"
+   git push origin HEAD
+   \`\`\`
+
+작업을 계속 진행해주세요.`;
+}
+/** Generate guidance message for general git error */
+function getGitErrorGuidance(errorMessage) {
+    return `[SYSTEM INTERVENTION] Git 작업 중 오류가 발생했습니다:
+${errorMessage}
+
+다음을 시도해주세요:
+1. git status로 현재 상태 확인
+2. 필요시 git reset --hard HEAD로 초기화
+3. 원격 저장소와 동기화: git fetch origin && git pull --rebase
+
+작업을 계속 진행해주세요.`;
+}
+// ============================================================================
+// Recovery State Manager
+// ============================================================================
+/**
+ * Manages recovery state for all lanes
+ */
+class AutoRecoveryManager {
+    config;
+    laneStates = new Map();
+    eventHandlers = new Map();
+    constructor(config = {}) {
+        this.config = { ...exports.DEFAULT_AUTO_RECOVERY_CONFIG, ...config };
+    }
+    /**
+     * Register a lane for recovery monitoring
+     */
+    registerLane(laneName) {
+        const now = Date.now();
+        this.laneStates.set(laneName, {
+            laneName,
+            stage: RecoveryStage.NORMAL,
+            lastActivityTime: now,
+            lastBytesReceived: 0,
+            totalBytesReceived: 0,
+            lastOutput: '',
+            restartCount: 0,
+            continueSignalsSent: 0,
+            lastStageChangeTime: now,
+            isLongOperation: false,
+            failureHistory: [],
+        });
+        if (this.config.verbose) {
+            logger.info(`[AutoRecovery] Registered lane: ${laneName}`);
+        }
+    }
+    /**
+     * Unregister a lane from recovery monitoring
+     */
+    unregisterLane(laneName) {
+        this.laneStates.delete(laneName);
+        const handler = this.eventHandlers.get(laneName);
+        if (handler) {
+            this.eventHandlers.delete(laneName);
+        }
+    }
+    /**
+     * Record activity for a lane
+     */
+    recordActivity(laneName, bytesReceived = 0, output) {
+        const state = this.laneStates.get(laneName);
+        if (!state)
+            return;
+        const now = Date.now();
+        state.lastActivityTime = now;
+        if (bytesReceived > 0) {
+            state.lastBytesReceived = bytesReceived;
+            state.totalBytesReceived += bytesReceived;
+        }
+        if (output) {
+            state.lastOutput = output;
+            // Check if this is a long operation
+            state.isLongOperation = this.config.longOperationPatterns.some(p => p.test(output));
+        }
+        // Reset stage if we got meaningful activity
+        if (bytesReceived > 0 && state.stage !== RecoveryStage.NORMAL) {
+            if (this.config.verbose) {
+                logger.info(`[AutoRecovery] [${laneName}] Activity detected, resetting to NORMAL stage`);
+            }
+            state.stage = RecoveryStage.NORMAL;
+            state.lastStageChangeTime = now;
+        }
+    }
+    /**
+     * Get current recovery state for a lane
+     */
+    getState(laneName) {
+        return this.laneStates.get(laneName);
+    }
+    /**
+     * Check if a lane needs recovery intervention
+     */
+    needsIntervention(laneName) {
+        const state = this.laneStates.get(laneName);
+        if (!state)
+            return false;
+        const now = Date.now();
+        const idleTime = now - state.lastActivityTime;
+        // Use longer timeout for long operations
+        const effectiveTimeout = state.isLongOperation
+            ? this.config.longOperationGraceMs
+            : this.config.idleTimeoutMs;
+        // Check based on current stage
+        switch (state.stage) {
+            case RecoveryStage.NORMAL:
+                return idleTime > effectiveTimeout;
+            case RecoveryStage.CONTINUE_SIGNAL:
+                return (now - state.lastStageChangeTime) > this.config.continueGraceMs;
+            case RecoveryStage.STRONGER_PROMPT:
+                return (now - state.lastStageChangeTime) > this.config.strongerPromptGraceMs;
+            case RecoveryStage.RESTART_PROCESS:
+                // After restart, use normal timeout to detect if it's working
+                return idleTime > effectiveTimeout;
+            case RecoveryStage.DIAGNOSE:
+            case RecoveryStage.ABORT:
+                return false; // No more interventions
+            default:
+                return false;
+        }
+    }
+    /**
+     * Get the next recovery action for a lane
+     */
+    async getRecoveryAction(laneName, laneRunDir, child) {
+        const state = this.laneStates.get(laneName);
+        if (!state) {
+            return {
+                success: false,
+                action: 'none',
+                message: 'Lane not registered',
+                shouldContinue: false,
+            };
+        }
+        const now = Date.now();
+        const idleTime = now - state.lastActivityTime;
+        const idleSeconds = Math.round(idleTime / 1000);
+        switch (state.stage) {
+            case RecoveryStage.NORMAL:
+                // Escalate to CONTINUE_SIGNAL
+                return await this.sendContinueSignal(laneName, laneRunDir, state, idleSeconds);
+            case RecoveryStage.CONTINUE_SIGNAL:
+                // Try a stronger prompt
+                return await this.sendStrongerPrompt(laneName, laneRunDir, state);
+            case RecoveryStage.STRONGER_PROMPT:
+                // Try restarting the process
+                if (state.restartCount < this.config.maxRestarts) {
+                    return await this.requestRestart(laneName, state, child);
+                }
+                // Fall through to diagnose
+                state.stage = RecoveryStage.DIAGNOSE;
+                state.lastStageChangeTime = now;
+                return await this.runDiagnosis(laneName, laneRunDir, state);
+            case RecoveryStage.RESTART_PROCESS:
+                // After restart, if still no response, diagnose
+                if (state.restartCount >= this.config.maxRestarts) {
+                    state.stage = RecoveryStage.DIAGNOSE;
+                    state.lastStageChangeTime = now;
+                    return await this.runDiagnosis(laneName, laneRunDir, state);
+                }
+                // Try continue signal again after restart
+                return await this.sendContinueSignal(laneName, laneRunDir, state, idleSeconds);
+            case RecoveryStage.DIAGNOSE:
+                // Final stage - abort
+                state.stage = RecoveryStage.ABORT;
+                state.lastStageChangeTime = now;
+                return {
+                    success: false,
+                    action: 'abort',
+                    message: `Lane ${laneName} failed after all recovery attempts`,
+                    shouldContinue: false,
+                    nextStage: RecoveryStage.ABORT,
+                    diagnostic: state.diagnosticInfo,
+                };
+            default:
+                return {
+                    success: false,
+                    action: 'abort',
+                    message: 'Recovery exhausted',
+                    shouldContinue: false,
+                };
+        }
+    }
+    /**
+     * Send a continue signal to the lane
+     */
+    async sendContinueSignal(laneName, laneRunDir, state, idleSeconds) {
+        const interventionPath = (0, path_1.safeJoin)(laneRunDir, 'intervention.txt');
+        try {
+            fs.writeFileSync(interventionPath, 'continue');
+            state.stage = RecoveryStage.CONTINUE_SIGNAL;
+            state.lastStageChangeTime = Date.now();
+            state.continueSignalsSent++;
+            // Record failure history
+            state.failureHistory.push({
+                timestamp: Date.now(),
+                stage: RecoveryStage.CONTINUE_SIGNAL,
+                action: 'continue_signal',
+                message: `Idle for ${idleSeconds}s`,
+                idleTimeMs: idleSeconds * 1000,
+                bytesReceived: state.totalBytesReceived,
+                lastOutput: state.lastOutput,
+            });
+            const message = `[${laneName}] Idle for ${idleSeconds}s - sent continue signal (#${state.continueSignalsSent})`;
+            logger.warn(message);
+            events_1.events.emit('recovery.continue_signal', {
+                laneName,
+                idleSeconds,
+                signalCount: state.continueSignalsSent,
+            });
+            return {
+                success: true,
+                action: 'continue_signal',
+                message,
+                shouldContinue: true,
+                nextStage: RecoveryStage.CONTINUE_SIGNAL,
+            };
+        }
+        catch (error) {
+            logger.error(`[AutoRecovery] Failed to send continue signal to ${laneName}: ${error.message}`);
+            return {
+                success: false,
+                action: 'continue_signal',
+                message: `Failed to send continue signal: ${error.message}`,
+                shouldContinue: true,
+            };
+        }
+    }
+    /**
+     * Send a stronger prompt to nudge the agent
+     */
+    async sendStrongerPrompt(laneName, laneRunDir, state) {
+        const interventionPath = (0, path_1.safeJoin)(laneRunDir, 'intervention.txt');
+        const strongerPrompt = `[SYSTEM INTERVENTION] You seem to be stuck or waiting. 
+Please continue with your current task immediately. 
+If you're waiting for something, explain what you need and proceed with what you can do now.
+If you've completed the task, please summarize your work and finish.
+If you encountered a git error, resolve it and continue.`;
+        try {
+            fs.writeFileSync(interventionPath, strongerPrompt);
+            state.stage = RecoveryStage.STRONGER_PROMPT;
+            state.lastStageChangeTime = Date.now();
+            // Record failure history
+            state.failureHistory.push({
+                timestamp: Date.now(),
+                stage: RecoveryStage.STRONGER_PROMPT,
+                action: 'stronger_prompt',
+                message: 'Still idle after continue signal',
+                idleTimeMs: Date.now() - state.lastActivityTime,
+                bytesReceived: state.totalBytesReceived,
+                lastOutput: state.lastOutput,
+            });
+            const message = `[${laneName}] Still idle after continue signal - sent stronger prompt`;
+            logger.warn(message);
+            events_1.events.emit('recovery.stronger_prompt', {
+                laneName,
+                prompt: strongerPrompt,
+            });
+            return {
+                success: true,
+                action: 'stronger_prompt',
+                message,
+                shouldContinue: true,
+                nextStage: RecoveryStage.STRONGER_PROMPT,
+            };
+        }
+        catch (error) {
+            logger.error(`[AutoRecovery] Failed to send stronger prompt to ${laneName}: ${error.message}`);
+            return {
+                success: false,
+                action: 'stronger_prompt',
+                message: `Failed to send stronger prompt: ${error.message}`,
+                shouldContinue: true,
+            };
+        }
+    }
+    /**
+     * Request process restart
+     */
+    async requestRestart(laneName, state, child) {
+        state.restartCount++;
+        state.stage = RecoveryStage.RESTART_PROCESS;
+        state.lastStageChangeTime = Date.now();
+        // Record failure history
+        state.failureHistory.push({
+            timestamp: Date.now(),
+            stage: RecoveryStage.RESTART_PROCESS,
+            action: 'restart',
+            message: `Restart attempt ${state.restartCount}/${this.config.maxRestarts}`,
+            idleTimeMs: Date.now() - state.lastActivityTime,
+            bytesReceived: state.totalBytesReceived,
+            lastOutput: state.lastOutput,
+        });
+        // Kill the current process if provided
+        if (child && child.pid && !child.killed) {
+            try {
+                child.kill('SIGKILL');
+                logger.info(`[AutoRecovery] [${laneName}] Killed process ${child.pid}`);
+            }
+            catch (error) {
+                logger.warn(`[AutoRecovery] [${laneName}] Failed to kill process: ${error.message}`);
+            }
+        }
+        const message = `[${laneName}] Restarting lane (attempt ${state.restartCount}/${this.config.maxRestarts})`;
+        logger.warn(message);
+        events_1.events.emit('recovery.restart', {
+            laneName,
+            restartCount: state.restartCount,
+            maxRestarts: this.config.maxRestarts,
+        });
+        return {
+            success: true,
+            action: 'restart',
+            message,
+            shouldContinue: true,
+            nextStage: RecoveryStage.RESTART_PROCESS,
+        };
+    }
+    /**
+     * Run diagnostic checks
+     */
+    async runDiagnosis(laneName, laneRunDir, state) {
+        if (!this.config.runDoctorOnFailure) {
+            return {
+                success: false,
+                action: 'diagnose',
+                message: 'Diagnosis skipped (disabled in config)',
+                shouldContinue: false,
+            };
+        }
+        logger.info(`[AutoRecovery] [${laneName}] Running diagnostic checks...`);
+        try {
+            // Run health checks
+            const [agentHealth, authHealth] = await Promise.all([
+                (0, health_1.checkAgentHealth)(),
+                (0, health_1.checkAuthHealth)(),
+            ]);
+            const systemHealth = await (0, health_1.runHealthCheck)({ skipRemote: true, skipAuth: true });
+            const diagnostic = {
+                timestamp: Date.now(),
+                agentHealthy: agentHealth.ok,
+                authHealthy: authHealth.ok,
+                systemHealthy: systemHealth.healthy,
+                suggestedAction: '',
+                details: '',
+            };
+            // Analyze and suggest action
+            const issues = [];
+            if (!agentHealth.ok) {
+                issues.push(`Agent: ${agentHealth.message}`);
+            }
+            if (!authHealth.ok) {
+                issues.push(`Auth: ${authHealth.message}`);
+                diagnostic.suggestedAction = 'Please sign in to Cursor IDE and verify authentication';
+            }
+            if (!systemHealth.healthy) {
+                const failedChecks = systemHealth.checks.filter(c => !c.ok);
+                issues.push(`System: ${failedChecks.map(c => c.message).join(', ')}`);
+            }
+            if (issues.length === 0) {
+                diagnostic.details = 'All health checks passed. The issue may be with the AI model or network.';
+                diagnostic.suggestedAction = 'Try resuming with a different model or wait and retry.';
+            }
+            else {
+                diagnostic.details = issues.join('\n');
+            }
+            state.diagnosticInfo = diagnostic;
+            // Record failure history
+            state.failureHistory.push({
+                timestamp: Date.now(),
+                stage: RecoveryStage.DIAGNOSE,
+                action: 'diagnose',
+                message: diagnostic.details,
+                idleTimeMs: Date.now() - state.lastActivityTime,
+                bytesReceived: state.totalBytesReceived,
+                lastOutput: state.lastOutput,
+            });
+            // Save diagnostic to file
+            const diagnosticPath = (0, path_1.safeJoin)(laneRunDir, 'diagnostic.json');
+            fs.writeFileSync(diagnosticPath, JSON.stringify(diagnostic, null, 2));
+            const message = `[${laneName}] Diagnostic complete:\n${diagnostic.details}\nSuggested action: ${diagnostic.suggestedAction}`;
+            logger.error(message);
+            events_1.events.emit('recovery.diagnosed', {
+                laneName,
+                diagnostic,
+            });
+            return {
+                success: true,
+                action: 'diagnose',
+                message,
+                shouldContinue: false,
+                diagnostic,
+            };
+        }
+        catch (error) {
+            logger.error(`[AutoRecovery] Diagnostic failed: ${error.message}`);
+            return {
+                success: false,
+                action: 'diagnose',
+                message: `Diagnostic failed: ${error.message}`,
+                shouldContinue: false,
+            };
+        }
+    }
+    /**
+     * Get failure history for a lane
+     */
+    getFailureHistory(laneName) {
+        const state = this.laneStates.get(laneName);
+        return state?.failureHistory || [];
+    }
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+}
+exports.AutoRecoveryManager = AutoRecoveryManager;
+// ============================================================================
+// POF (Post-mortem of Failure) Management
+// ============================================================================
+/**
+ * Save a POF entry to the pof directory
+ */
+function savePOF(runId, pofDir, entry) {
+    // Ensure pof directory exists
+    if (!fs.existsSync(pofDir)) {
+        fs.mkdirSync(pofDir, { recursive: true });
+    }
+    const pofPath = (0, path_1.safeJoin)(pofDir, `pof-${runId}.json`);
+    let existingPOF = null;
+    try {
+        const data = fs.readFileSync(pofPath, 'utf8');
+        existingPOF = JSON.parse(data);
+    }
+    catch {
+        // File doesn't exist or is invalid JSON - ignore
+    }
+    // If there's an existing POF, add it to previousFailures
+    if (existingPOF) {
+        entry.previousFailures = entry.previousFailures || [];
+        entry.previousFailures.unshift(existingPOF);
+    }
+    // Use atomic write: write to temp file then rename
+    const tempPath = `${pofPath}.${Math.random().toString(36).substring(2, 7)}.tmp`;
+    try {
+        fs.writeFileSync(tempPath, JSON.stringify(entry, null, 2), 'utf8');
+        fs.renameSync(tempPath, pofPath);
+    }
+    catch (err) {
+        // If temp file was created, try to clean it up
+        try {
+            if (fs.existsSync(tempPath))
+                fs.unlinkSync(tempPath);
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
+    logger.info(`[POF] Saved post-mortem to ${pofPath}`);
+    return pofPath;
+}
+/**
+ * Create a POF entry from recovery state
+ */
+function createPOFFromRecoveryState(runId, runDir, laneName, state, laneState, diagnostic) {
+    const now = new Date();
+    // Determine root cause type
+    let rootCauseType = 'AGENT_NO_RESPONSE';
+    let rootCauseDescription = 'Agent stopped responding and did not recover after multiple interventions';
+    const symptoms = [];
+    if (state.totalBytesReceived === 0) {
+        rootCauseType = 'AGENT_NO_RESPONSE';
+        rootCauseDescription = 'Agent produced 0 bytes of output - possible API or network issue';
+        symptoms.push('No bytes received from agent');
+    }
+    else if (state.restartCount >= 2) {
+        rootCauseType = 'ZOMBIE_PROCESS';
+        rootCauseDescription = 'Lane processes repeatedly failed to make progress after restarts';
+        symptoms.push(`Restarted ${state.restartCount} times without success`);
+    }
+    symptoms.push(`Total bytes received: ${state.totalBytesReceived}`);
+    symptoms.push(`Continue signals sent: ${state.continueSignalsSent}`);
+    symptoms.push(`Last output: ${state.lastOutput.substring(0, 100)}...`);
+    // Possible causes based on diagnostic
+    const possibleCauses = [
+        'Model API rate limiting or quota exceeded',
+        'Cursor authentication token expired',
+        'Network connectivity issues',
+        'Agent process hung waiting for stdin/stdout',
+    ];
+    if (diagnostic) {
+        if (!diagnostic.agentHealthy) {
+            possibleCauses.unshift('cursor-agent CLI is not responding properly');
+        }
+        if (!diagnostic.authHealthy) {
+            possibleCauses.unshift('Cursor authentication failed or expired');
+        }
+    }
+    const entry = {
+        title: 'Run Failure Post-mortem',
+        runId,
+        failureTime: now.toISOString(),
+        detectedAt: now.toISOString(),
+        summary: `Lane ${laneName} failed after ${state.restartCount} restart(s) and ${state.continueSignalsSent} continue signal(s)`,
+        rootCause: {
+            type: rootCauseType,
+            description: rootCauseDescription,
+            symptoms,
+        },
+        affectedLanes: [
+            {
+                name: laneName,
+                status: 'failed',
+                task: laneState ? `[${(laneState.currentTaskIndex || 0) + 1}/${laneState.totalTasks}]` : 'unknown',
+                taskIndex: laneState?.currentTaskIndex || 0,
+                pid: laneState?.pid,
+                reason: rootCauseDescription,
+                recoveryAttempts: state.failureHistory,
+            },
+        ],
+        possibleCauses,
+        recovery: {
+            command: `cursorflow resume --all --run-dir ${runDir}`,
+            description: 'Resume all failed lanes from their last checkpoint',
+            alternativeCommand: `cursorflow resume --all --restart --run-dir ${runDir}`,
+            alternativeDescription: 'Restart all failed lanes from the beginning',
+        },
+    };
+    return entry;
+}
+/**
+ * Load existing POF entries for a run
+ */
+function loadPOF(pofDir, runId) {
+    const pofPath = (0, path_1.safeJoin)(pofDir, `pof-${runId}.json`);
+    if (!fs.existsSync(pofPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(pofPath, 'utf8'));
+    }
+    catch (error) {
+        logger.warn(`[POF] Failed to load POF from ${pofPath}: ${error.message}`);
+        return null;
+    }
+}
+/**
+ * List all POF files in a directory
+ */
+function listPOFs(pofDir) {
+    if (!fs.existsSync(pofDir)) {
+        return [];
+    }
+    return fs.readdirSync(pofDir)
+        .filter(f => f.startsWith('pof-') && f.endsWith('.json'))
+        .map(f => (0, path_1.safeJoin)(pofDir, f));
+}
+// ============================================================================
+// Exports
+// ============================================================================
+/** Singleton instance for easy access */
+let defaultManager = null;
+/**
+ * Get or create the default auto-recovery manager
+ */
+function getAutoRecoveryManager(config) {
+    if (!defaultManager) {
+        defaultManager = new AutoRecoveryManager(config);
+    }
+    else if (config) {
+        defaultManager.updateConfig(config);
+    }
+    return defaultManager;
+}
+/**
+ * Reset the default manager (for testing)
+ */
+function resetAutoRecoveryManager() {
+    defaultManager = null;
+}
+//# sourceMappingURL=auto-recovery.js.map