@minionry/minion 0.7.36

package/dist/server/cli/headless/resilient-runner.js

@@ -0,0 +1,326 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { runEngineOnce, shouldRouteToEngine } from '../../engines/execution/engine-session.js';
+import { getEngine } from '../../services/settings.js';
+import { hlog, runWithFileLogger } from './headless-logger.js';
+import { isAgentBrowserSurfaceAvailable } from './mcp-config.js';
+import { chooseBestAttempt, createRetryState, extractNoticeMarkers, isResponseAbandoned, isTerminalEngineNotice, pickPreferredResult, scoreResult, tryContextLoss, tryServerError, trySignalCrash, tryToolTimeout, } from './retry-strategies.js';
+import { HeadlessRunner } from './runner.js';
+export const RETRY_BACKOFF_MS = [1000, 5000, 30000];
+function resolveRetryConfig(policy, verbose) {
+    switch (policy) {
+        case 'FULL':
+            return { enableContextLossDetection: true, enableBestResultSelection: true, verbose };
+        case 'STANDARD':
+            return { enableContextLossDetection: false, enableBestResultSelection: false, verbose };
+        case 'NONE':
+            return { enableContextLossDetection: false, enableBestResultSelection: false, verbose };
+    }
+}
+function wireAbortSignal(runner, abortSignal) {
+    if (!abortSignal)
+        return null;
+    const handler = () => { runner.cleanup(); };
+    abortSignal.addEventListener('abort', handler, { once: true });
+    return () => abortSignal.removeEventListener('abort', handler);
+}
+function abortedFallback(bestResult) {
+    return bestResult ?? {
+        completed: false,
+        needsHandoff: false,
+        totalTokens: 0,
+        sessionId: '',
+        error: 'Execution stopped by user',
+    };
+}
+function sleep(ms, abortSignal) {
+    if (ms <= 0 || abortSignal?.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            abortSignal?.removeEventListener('abort', done);
+            resolve();
+        }
+        abortSignal?.addEventListener('abort', done, { once: true });
+    });
+}
+export class ResilientRunner {
+    config;
+    notices = [];
+    retryLog = [];
+    attempts = 0;
+    assessments = [];
+    assessorFailed = false;
+    constructor(config) {
+        this.config = config;
+    }
+    get outputCallback() {
+        const inner = this.config.outputCallback;
+        return (text) => {
+            for (const marker of extractNoticeMarkers(text))
+                this.notices.push(marker);
+            inner?.(text);
+        };
+    }
+    decorate(result, isAutoContinue = false) {
+        return {
+            ...result,
+            ...(this.retryLog && this.retryLog.length > 0 ? { retryLog: [...this.retryLog] } : {}),
+            ...(this.notices.length > 0 ? { notices: [...this.notices] } : {}),
+            ...(this.assessments.length > 0 ? { assessments: [...this.assessments] } : {}),
+            ...(this.assessorFailed ? { assessorFailed: true } : {}),
+            ...(isAutoContinue ? { isAutoContinue: true } : {}),
+            attempts: this.attempts,
+        };
+    }
+    absorbState(state) {
+        this.assessments.push(...state.assessments);
+        if (state.assessorFailed)
+            this.assessorFailed = true;
+    }
+    async run() {
+        const { logLabel, logDir } = this.config;
+        if (logLabel) {
+            return runWithFileLogger(logLabel, () => this.execute(), logDir);
+        }
+        return this.execute();
+    }
+    async execute() {
+        const engineId = this.config.engineId ?? getEngine();
+        if (shouldRouteToEngine(engineId)) {
+            return this.runViaEngine(engineId);
+        }
+        const policy = this.config.policy ?? 'STANDARD';
+        const maxRetries = this.config.maxRetries ?? 3;
+        const verbose = this.config.verbose ?? true;
+        const maxAutoContinues = this.config.maxAutoContinues ?? (policy === 'NONE' ? 0 : 1);
+        const retryConfig = resolveRetryConfig(policy, verbose);
+        if (policy === 'NONE') {
+            return this.decorate(await this.runSingle(this.config.prompt, false, undefined));
+        }
+        const state = createRetryState(this.config.prompt, maxRetries);
+        const loopResult = await this.retryLoop(state, retryConfig, policy, maxRetries);
+        this.absorbState(state);
+        let result;
+        if (!this.config.abortSignal?.aborted &&
+            retryConfig.enableBestResultSelection && state.retryNumber > 0 && state.bestResult && loopResult) {
+            result = await this.selectBestResult(state.bestResult, loopResult, this.config.prompt);
+        }
+        else {
+            result = loopResult ?? abortedFallback(state.bestResult);
+        }
+        return this.autoContinue(result, retryConfig, policy, maxRetries, maxAutoContinues);
+    }
+    async runViaEngine(engineId) {
+        hlog(`[RESILIENT] engine=${engineId}: single-turn engine path (retry/stall policy bypassed)`);
+        return runEngineOnce({
+            engineId,
+            workingDir: this.config.workingDir,
+            prompt: this.config.prompt,
+            model: this.config.model,
+            effortLevel: this.config.effortLevel,
+            fastMode: this.config.fastMode,
+            imageAttachments: this.config.imageAttachments,
+            extraEnv: this.config.extraEnv,
+            disallowedTools: this.config.disallowedTools,
+            browserMcp: (await isAgentBrowserSurfaceAvailable()) ? this.config.browserMcp : undefined,
+            abortSignal: this.config.abortSignal,
+            callbacks: {
+                outputCallback: this.config.outputCallback,
+                thinkingCallback: this.config.thinkingCallback,
+                toolUseCallback: this.config.toolUseCallback,
+                tokenUsageCallback: this.config.tokenUsageCallback,
+            },
+        });
+    }
+    async retryLoop(state, retryConfig, policy, maxRetries, initialPrompt, initialResumeSessionId) {
+        let lastResult;
+        let currentPrompt = initialPrompt ?? this.config.prompt;
+        let resumeSessionId = initialResumeSessionId;
+        let useResume = !!initialResumeSessionId;
+        let attemptsInLoop = 0;
+        while (state.retryNumber <= maxRetries) {
+            if (this.config.abortSignal?.aborted)
+                return undefined;
+            await this.backoffBefore(attemptsInLoop);
+            if (this.config.abortSignal?.aborted)
+                return state.bestResult ?? lastResult;
+            attemptsInLoop++;
+            this.attempts++;
+            state.checkpoint = null;
+            state.lastUseResume = useResume;
+            const result = await this.runAttempt(currentPrompt, useResume, resumeSessionId, state);
+            if (this.config.abortSignal?.aborted)
+                return state.bestResult ?? result;
+            state.bestResult = state.bestResult ? pickPreferredResult(state.bestResult, result) : result;
+            lastResult = result;
+            const decision = await this.evaluateStrategies(result, state, retryConfig, policy);
+            if (!decision)
+                break;
+            state.checkpoint = null;
+            currentPrompt = decision.nextPrompt;
+            resumeSessionId = decision.resumeSessionId;
+            useResume = decision.useResume;
+            hlog(`[RESILIENT] Retry ${state.retryNumber}/${maxRetries}: ${decision.path} — ${decision.reason}`);
+            this.retryLog?.push({ retryNumber: state.retryNumber, path: decision.path, reason: decision.reason, timestamp: Date.now() });
+            this.config.onRetry?.({
+                retryNumber: state.retryNumber,
+                maxRetries,
+                path: decision.path,
+                reason: decision.reason,
+            });
+        }
+        return lastResult;
+    }
+    backoffBefore(attemptsInLoop) {
+        if (attemptsInLoop === 0)
+            return Promise.resolve();
+        const delay = RETRY_BACKOFF_MS[Math.min(attemptsInLoop - 1, RETRY_BACKOFF_MS.length - 1)];
+        return sleep(delay, this.config.abortSignal);
+    }
+    async runAttempt(prompt, useResume, resumeSessionId, state) {
+        const runner = this.createHeadlessRunner(prompt, useResume, resumeSessionId, state);
+        const removeAbortListener = wireAbortSignal(runner, this.config.abortSignal);
+        const result = await runner.run();
+        removeAbortListener?.();
+        return result;
+    }
+    createHeadlessRunner(prompt, continueSession, claudeSessionId, state) {
+        return new HeadlessRunner({
+            workingDir: this.config.workingDir,
+            directPrompt: prompt,
+            tabId: this.config.tabId,
+            stallWarningMs: this.config.stallWarningMs,
+            stallKillMs: this.config.stallKillMs,
+            stallHardCapMs: this.config.stallHardCapMs,
+            stallMaxExtensions: this.config.stallMaxExtensions,
+            verbose: this.config.verbose ?? true,
+            continueSession: continueSession || undefined,
+            claudeSessionId,
+            outputCallback: this.outputCallback,
+            thinkingCallback: this.config.thinkingCallback,
+            toolUseCallback: this.config.toolUseCallback,
+            tokenUsageCallback: this.config.tokenUsageCallback,
+            model: this.config.model,
+            effortLevel: this.config.effortLevel,
+            fastMode: this.config.fastMode,
+            extraEnv: this.config.extraEnv,
+            disallowedTools: this.config.disallowedTools,
+            inferenceOnly: this.config.inferenceOnly,
+            imageAttachments: this.config.imageAttachments,
+            appTools: this.config.appTools,
+            onBackgroundActivity: this.config.onBackgroundActivity,
+            onToolTimeout: (cp) => {
+                state.checkpoint = cp;
+            },
+        });
+    }
+    async evaluateStrategies(result, state, retryConfig, policy) {
+        if (isTerminalEngineNotice(result)) {
+            hlog(`[RESILIENT] No retry: engine notice (${result.engineNotice?.kind}) — ${result.engineNotice?.text.slice(0, 120)}`);
+            return null;
+        }
+        const serverError = tryServerError(result, state);
+        if (serverError)
+            return serverError;
+        const toolTimeout = tryToolTimeout(result, state);
+        if (toolTimeout)
+            return toolTimeout;
+        const signalCrash = trySignalCrash(result, state);
+        if (signalCrash)
+            return signalCrash;
+        if (policy === 'FULL') {
+            const contextLoss = await tryContextLoss(result, state, retryConfig);
+            if (contextLoss)
+                return contextLoss;
+        }
+        return null;
+    }
+    async selectBestResult(bestResult, finalResult, originalPrompt) {
+        if (bestResult === finalResult)
+            return finalResult;
+        const { chosen, assessment } = await chooseBestAttempt(bestResult, finalResult, originalPrompt, resolveClaudeCommand(), this.config.verbose ?? true);
+        this.assessments.push(assessment);
+        if (!assessment.assessed)
+            this.assessorFailed = true;
+        hlog(`[RESILIENT] Best result selection: ${assessment.verdict} — ${assessment.reason}`);
+        return chosen;
+    }
+    shouldAutoContinue(result) {
+        if (!result.claudeSessionId)
+            return false;
+        if (isTerminalEngineNotice(result) || result.startupTimedOut)
+            return false;
+        if (result.signalName || result.interrupted)
+            return true;
+        if (result.completed && !result.signalName && result.stopReason === 'end_turn') {
+            return isResponseAbandoned(result);
+        }
+        return false;
+    }
+    async autoContinue(initialResult, retryConfig, policy, maxRetries, maxAutoContinues) {
+        let result = initialResult;
+        let continued = false;
+        for (let count = 0; count < maxAutoContinues; count++) {
+            if (this.config.abortSignal?.aborted)
+                break;
+            if (!this.shouldAutoContinue(result))
+                break;
+            const reason = result.signalName
+                ? 'Process stalled'
+                : result.interrupted ? 'Execution interrupted' : 'Response appears incomplete';
+            hlog(`[RESILIENT] Auto-continue ${count + 1}/${maxAutoContinues}: ${reason}`);
+            this.retryLog?.push({ retryNumber: count + 1, path: 'AutoContinue', reason, timestamp: Date.now() });
+            this.config.onRetry?.({
+                retryNumber: count + 1,
+                maxRetries: maxAutoContinues,
+                path: 'AutoContinue',
+                reason,
+            });
+            const continueState = createRetryState('continue', maxRetries);
+            const continueResult = await this.retryLoop(continueState, retryConfig, policy, maxRetries, 'continue', result.claudeSessionId);
+            this.absorbState(continueState);
+            if (!continueResult)
+                break;
+            if (pickPreferredResult(result, continueResult) === continueResult || scoreResult(continueResult) >= scoreResult(result)) {
+                result = continueResult;
+                continued = true;
+            }
+        }
+        return this.decorate(result, continued);
+    }
+    async runSingle(prompt, continueSession, claudeSessionId) {
+        const runner = new HeadlessRunner({
+            workingDir: this.config.workingDir,
+            directPrompt: prompt,
+            stallWarningMs: this.config.stallWarningMs,
+            stallKillMs: this.config.stallKillMs,
+            stallHardCapMs: this.config.stallHardCapMs,
+            stallMaxExtensions: this.config.stallMaxExtensions,
+            verbose: this.config.verbose ?? true,
+            continueSession: continueSession || undefined,
+            claudeSessionId,
+            outputCallback: this.outputCallback,
+            thinkingCallback: this.config.thinkingCallback,
+            toolUseCallback: this.config.toolUseCallback,
+            tokenUsageCallback: this.config.tokenUsageCallback,
+            model: this.config.model,
+            effortLevel: this.config.effortLevel,
+            fastMode: this.config.fastMode,
+            extraEnv: this.config.extraEnv,
+            disallowedTools: this.config.disallowedTools,
+            inferenceOnly: this.config.inferenceOnly,
+            imageAttachments: this.config.imageAttachments,
+            appTools: this.config.appTools,
+            onBackgroundActivity: this.config.onBackgroundActivity,
+        });
+        this.attempts++;
+        const removeAbortListener = wireAbortSignal(runner, this.config.abortSignal);
+        const result = await runner.run();
+        removeAbortListener?.();
+        return result;
+    }
+}

package/dist/server/cli/headless/retry-strategies.js

@@ -0,0 +1,292 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { buildFreshRecoveryPrompt, buildResumeRetryPrompt, buildRetryPrompt, buildServerErrorRetryPrompt, buildSignalCrashRecoveryPrompt, } from '../prompt-builders.js';
+import { hlog } from './headless-logger.js';
+import { assessBestResult, assessContextLoss } from './stall-assessor.js';
+export const MAX_SERVER_ERROR_RETRIES = 2;
+export function isCompletedAttempt(r) {
+    return r.completed && !r.signalName && !r.interrupted && !r.engineNotice && !r.startupTimedOut;
+}
+export function attemptsAreComparable(a, b) {
+    return isCompletedAttempt(a) === isCompletedAttempt(b);
+}
+export function pickPreferredResult(earlier, later) {
+    if (!attemptsAreComparable(earlier, later))
+        return isCompletedAttempt(earlier) ? earlier : later;
+    return scoreResult(later) >= scoreResult(earlier) ? later : earlier;
+}
+export async function chooseBestAttempt(earlier, later, originalPrompt, claudeCommand, verbose) {
+    const at = Date.now();
+    if (!attemptsAreComparable(earlier, later)) {
+        const chosen = pickPreferredResult(earlier, later);
+        return {
+            chosen,
+            assessment: { kind: 'best-result', verdict: chosen === earlier ? 'A' : 'B', reason: 'rule: a completed attempt is preferred over a killed or errored one', assessed: true, at },
+        };
+    }
+    const verdict = await assessBestResult({
+        originalPrompt,
+        resultA: summarizeAttempt(earlier),
+        resultB: summarizeAttempt(later),
+    }, claudeCommand, verbose);
+    if (verdict.assessed && verdict.winner) {
+        return {
+            chosen: verdict.winner === 'A' ? earlier : later,
+            assessment: { kind: 'best-result', verdict: verdict.winner, reason: verdict.reason, assessed: true, at },
+        };
+    }
+    const chosen = pickPreferredResult(earlier, later);
+    return {
+        chosen,
+        assessment: { kind: 'best-result', verdict: chosen === earlier ? 'A' : 'B', reason: `fallback (${verdict.reason}): numeric score`, assessed: false, at },
+    };
+}
+function summarizeAttempt(r) {
+    return {
+        successfulToolCalls: r.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0,
+        responseLength: r.assistantResponse?.length ?? 0,
+        hasThinking: !!r.thinkingOutput,
+        responseTail: (r.assistantResponse ?? '').slice(-500),
+    };
+}
+const NOTICE_MARKER_RE = /\[\[MINIONRY_[A-Z_]+(?::[A-Z_0-9]+)?\]\][^\n]*/g;
+export function extractNoticeMarkers(text) {
+    const found = [];
+    for (const match of text.matchAll(NOTICE_MARKER_RE))
+        found.push(match[0].slice(0, 300));
+    return found;
+}
+export function summarizeRetryLog(retryLog) {
+    if (!retryLog || retryLog.length === 0)
+        return undefined;
+    return {
+        count: retryLog.length,
+        paths: Array.from(new Set(retryLog.map((r) => r.path))),
+        lastReason: retryLog[retryLog.length - 1]?.reason.slice(0, 200),
+    };
+}
+const MAX_ACCUMULATED_RESULTS = 50;
+export function createRetryState(originalPrompt, maxRetries) {
+    return {
+        retryNumber: 0,
+        maxRetries,
+        originalPrompt,
+        accumulatedToolResults: [],
+        timedOutTools: [],
+        checkpoint: null,
+        bestResult: null,
+        lastUseResume: false,
+        serverErrorRetries: 0,
+        retryLog: [],
+        assessments: [],
+        assessorFailed: false,
+    };
+}
+export function isTerminalEngineNotice(result) {
+    return !!result.engineNotice && result.engineNotice.kind !== 'server_error';
+}
+export function tryServerError(result, state) {
+    if (result.engineNotice?.kind !== 'server_error')
+        return null;
+    if (state.checkpoint || state.retryNumber >= state.maxRetries)
+        return null;
+    if (state.serverErrorRetries >= MAX_SERVER_ERROR_RETRIES)
+        return null;
+    accumulateToolResults(result, state);
+    state.serverErrorRetries++;
+    state.retryNumber++;
+    const useResume = !!result.claudeSessionId;
+    const reason = `Transient API error (${result.engineNotice.text.slice(0, 80)}), ${useResume ? 'resuming' : 'fresh start'} (server-error retry ${state.serverErrorRetries}/${MAX_SERVER_ERROR_RETRIES})`;
+    hlog(`[RETRY] Server error: ${reason} (retry ${state.retryNumber}/${state.maxRetries})`);
+    return {
+        nextPrompt: buildServerErrorRetryPrompt(state.originalPrompt, useResume, state.accumulatedToolResults),
+        useResume,
+        resumeSessionId: useResume ? result.claudeSessionId : undefined,
+        path: 'ServerError',
+        reason,
+    };
+}
+export function accumulateToolResults(result, state) {
+    if (!result.toolUseHistory)
+        return;
+    for (const t of result.toolUseHistory) {
+        if (t.result !== undefined) {
+            state.accumulatedToolResults.push({
+                toolName: t.toolName,
+                toolId: t.toolId,
+                toolInput: t.toolInput,
+                result: t.result,
+                isError: t.isError,
+                duration: t.duration,
+            });
+        }
+    }
+    if (state.accumulatedToolResults.length > MAX_ACCUMULATED_RESULTS) {
+        state.accumulatedToolResults = state.accumulatedToolResults.slice(-MAX_ACCUMULATED_RESULTS);
+    }
+}
+export function scoreResult(r) {
+    const toolCount = r.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0;
+    const responseLen = Math.min((r.assistantResponse?.length ?? 0) / 50, 100);
+    const hasThinking = r.thinkingOutput ? 20 : 0;
+    return toolCount * 10 + responseLen + hasThinking;
+}
+export function isResponseAbandoned(result) {
+    const thinkingLen = result.thinkingOutput?.length ?? 0;
+    const responseLen = result.assistantResponse?.length ?? 0;
+    const toolCallsInResponse = result.toolUseHistory?.filter(t => t.result !== undefined).length ?? 0;
+    if (thinkingLen < 500 || responseLen > 1000)
+        return false;
+    if (toolCallsInResponse > 0 && responseLen > 200)
+        return false;
+    return thinkingLen >= responseLen * 3;
+}
+export function tryToolTimeout(_result, state) {
+    if (!state.checkpoint || state.retryNumber >= state.maxRetries)
+        return null;
+    const cp = state.checkpoint;
+    state.retryNumber++;
+    state.timedOutTools.push({
+        toolName: cp.hungTool.toolName,
+        input: cp.hungTool.input ?? {},
+        timeoutMs: cp.hungTool.timeoutMs,
+    });
+    const canResume = !!cp.claudeSessionId;
+    const reason = `${cp.hungTool.toolName} timed out after ${Math.round(cp.hungTool.timeoutMs / 1000)}s, ${cp.completedTools.length} tools completed${cp.inProgressTools.length > 0 ? `, ${cp.inProgressTools.length} in flight` : ''}, ${canResume ? 'resuming' : 'fresh start'}`;
+    hlog(`[RETRY] Tool timeout: ${reason} (retry ${state.retryNumber}/${state.maxRetries})`);
+    if (canResume) {
+        return {
+            nextPrompt: buildResumeRetryPrompt(cp, state.timedOutTools),
+            useResume: true,
+            resumeSessionId: cp.claudeSessionId,
+            path: 'ToolTimeout',
+            reason,
+        };
+    }
+    return {
+        nextPrompt: buildRetryPrompt(cp, state.originalPrompt, state.timedOutTools),
+        useResume: false,
+        path: 'ToolTimeout',
+        reason,
+    };
+}
+export function trySignalCrash(result, state) {
+    const isSignalCrash = !!result.signalName || (!!result.interrupted && !result.completed);
+    const exitCodeSignal = !result.completed && !result.signalName && result.error?.match(/exited with code (1[2-9]\d|[2-9]\d{2})/);
+    if (!isSignalCrash && !exitCodeSignal)
+        return null;
+    if (isTerminalEngineNotice(result))
+        return null;
+    if (state.retryNumber >= state.maxRetries)
+        return null;
+    if (state.checkpoint)
+        return null;
+    accumulateToolResults(result, state);
+    state.retryNumber++;
+    const signalInfo = result.signalName || (result.interrupted ? 'interrupted' : 'unknown signal');
+    const useResume = !!result.claudeSessionId && state.retryNumber === 1;
+    const backgroundWorkLost = !!result.backgroundTasksPendingAtExit;
+    const reason = `Process killed (${signalInfo}), ${state.accumulatedToolResults.length} tools preserved, ${useResume ? 'resuming' : 'fresh start'}${backgroundWorkLost ? `, ${result.backgroundTasksPendingAtExit} background task(s) lost` : ''}`;
+    hlog(`[RETRY] Signal crash: ${reason} (retry ${state.retryNumber}/${state.maxRetries})`);
+    if (useResume) {
+        return {
+            nextPrompt: buildSignalCrashRecoveryPrompt(state.originalPrompt, true, undefined, backgroundWorkLost),
+            useResume: true,
+            resumeSessionId: result.claudeSessionId,
+            path: 'SignalCrash',
+            reason,
+        };
+    }
+    return {
+        nextPrompt: buildSignalCrashRecoveryPrompt(state.originalPrompt, false, state.accumulatedToolResults, backgroundWorkLost),
+        useResume: false,
+        path: 'SignalCrash',
+        reason,
+    };
+}
+export function detectContextLossHeuristic(result, verbose, onResumeTurn = true) {
+    if (result.engineNotice || result.startupTimedOut)
+        return false;
+    if (!result.assistantResponse || result.assistantResponse.trim().length === 0) {
+        if (verbose)
+            hlog('[RETRY] Context loss heuristic: null/empty response');
+        return true;
+    }
+    if (result.resumeBufferedOutput !== undefined) {
+        if (verbose)
+            hlog('[RETRY] Context loss heuristic: buffer never flushed (no thinking/tools)');
+        return true;
+    }
+    if (onResumeTurn &&
+        (!result.toolUseHistory || result.toolUseHistory.length === 0) &&
+        !result.thinkingOutput &&
+        result.assistantResponse.length < 500) {
+        if (verbose)
+            hlog('[RETRY] Context loss heuristic: no tools, no thinking, short response');
+        return true;
+    }
+    return false;
+}
+function computeEffectiveTimeouts(result) {
+    const nativeTimeouts = result.nativeTimeoutCount ?? 0;
+    if (nativeTimeouts === 0)
+        return 0;
+    const succeededIds = new Set();
+    const allIds = new Set();
+    for (const t of result.toolUseHistory ?? []) {
+        allIds.add(t.toolId);
+        if (t.result !== undefined)
+            succeededIds.add(t.toolId);
+    }
+    const toolsWithoutResult = Array.from(allIds).filter(id => !succeededIds.has(id)).length;
+    return Math.max(nativeTimeouts, toolsWithoutResult);
+}
+async function detectContextLossViaHaiku(result, effectiveTimeouts, verbose) {
+    if (effectiveTimeouts === 0 || !result.assistantResponse)
+        return false;
+    const writeToolNames = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+    const claudeCmd = resolveClaudeCommand();
+    try {
+        const verdict = await assessContextLoss({
+            assistantResponse: result.assistantResponse,
+            effectiveTimeouts,
+            nativeTimeoutCount: result.nativeTimeoutCount ?? 0,
+            successfulToolCalls: result.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0,
+            thinkingOutputLength: result.thinkingOutput?.length ?? 0,
+            hasSuccessfulWrite: result.toolUseHistory?.some(t => writeToolNames.has(t.toolName) && t.result !== undefined && !t.isError) ?? false,
+        }, claudeCmd, verbose);
+        if (verbose)
+            hlog(`[RETRY] Haiku context loss verdict: ${verdict.contextLost ? 'LOST' : 'OK'} — ${verdict.reason}`);
+        return verdict.contextLost;
+    }
+    catch {
+        if (verbose)
+            hlog('[RETRY] Haiku context loss assessment failed, assuming OK');
+        return false;
+    }
+}
+export async function tryContextLoss(result, state, config) {
+    if (!config.enableContextLossDetection)
+        return null;
+    if (state.checkpoint || state.retryNumber >= state.maxRetries)
+        return null;
+    if (isTerminalEngineNotice(result))
+        return null;
+    const heuristicLost = detectContextLossHeuristic(result, config.verbose, state.lastUseResume);
+    const haikuLost = heuristicLost
+        ? false
+        : await detectContextLossViaHaiku(result, computeEffectiveTimeouts(result), config.verbose);
+    if (!heuristicLost && !haikuLost)
+        return null;
+    accumulateToolResults(result, state);
+    state.retryNumber++;
+    const reason = `Context lost, ${state.accumulatedToolResults.length} tools preserved`;
+    hlog(`[RETRY] Context loss: ${reason} (retry ${state.retryNumber}/${state.maxRetries})`);
+    return {
+        nextPrompt: buildFreshRecoveryPrompt(state.originalPrompt, state.accumulatedToolResults, state.timedOutTools),
+        useResume: false,
+        path: 'ContextLoss',
+        reason,
+    };
+}