@minionry/minion 0.7.36

package/dist/server/cli/improvisation-types.js

@@ -0,0 +1,31 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const SESSION_HISTORY_FORMAT_VERSION = 2;
+export function createRetryLoopState(promptWithAttachments, maxRetries) {
+    return {
+        promptWithAttachments,
+        maxRetries,
+        currentPrompt: promptWithAttachments,
+        retryNumber: 0,
+        checkpointRef: { value: null },
+        contextRecoverySessionId: undefined,
+        freshRecoveryMode: false,
+        accumulatedToolResults: [],
+        contextLost: false,
+        lastWatchdogCheckpoint: null,
+        timedOutTools: [],
+        bestResult: null,
+        retryLog: [],
+        lastUseResume: false,
+        lastNativeTimeouts: 0,
+        assessments: [],
+        assessorFailed: false,
+        serverErrorRetries: 0,
+    };
+}
+export function scoreRunResult(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;
+}

package/dist/server/cli/plan-lifecycle.js

@@ -0,0 +1,72 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export async function abortPlan(planId, deps, opts = {}) {
+    if (!planId)
+        return { releasedTabs: [], closedTabs: [] };
+    const { host, driverState } = deps;
+    const leases = await host.listLeases({ planId });
+    const tabIds = leases.map((l) => l.tabId);
+    const { released } = await host.releasePlan(planId);
+    for (const tabId of released) {
+        try {
+            driverState.clearOwner(tabId);
+        }
+        catch {
+        }
+    }
+    const closed = [];
+    if (opts.closeTabs) {
+        const toClose = new Set([...tabIds, ...released]);
+        for (const tabId of toClose) {
+            try {
+                await host.closeTab(tabId);
+                closed.push(tabId);
+            }
+            catch {
+            }
+        }
+    }
+    return { releasedTabs: released, closedTabs: closed };
+}
+export async function pausePlan(planId, deps) {
+    if (!planId)
+        return { pausedTabs: [] };
+    const { host, driverState } = deps;
+    const leases = await host.listLeases({ planId });
+    const paused = [];
+    for (const lease of leases) {
+        if (driverState.getState(lease.tabId) === 'automation' &&
+            driverState.getMode(lease.tabId) === 'parked') {
+            continue;
+        }
+        driverState.park(lease.tabId, 'plan-paused');
+        paused.push(lease.tabId);
+    }
+    return { pausedTabs: paused };
+}
+export async function resumePlan(planId, deps) {
+    if (!planId)
+        return { resumedTabs: [] };
+    const { host, driverState } = deps;
+    const leases = await host.listLeases({ planId });
+    const resumed = [];
+    for (const lease of leases) {
+        if (driverState.resume(lease.tabId))
+            resumed.push(lease.tabId);
+    }
+    return { resumedTabs: resumed };
+}
+export async function completePlan(planId, deps) {
+    if (!planId)
+        return { releasedTabs: [] };
+    const { host, driverState } = deps;
+    const { released } = await host.releasePlan(planId);
+    for (const tabId of released) {
+        try {
+            driverState.clearOwner(tabId);
+        }
+        catch {
+        }
+    }
+    return { releasedTabs: released };
+}

package/dist/server/cli/prompt-builders.js

@@ -0,0 +1,371 @@
+import { loadSkillPrompt } from '../services/plan/agent-loader.js';
+export function summarizeToolInput(input) {
+    if (input.url)
+        return String(input.url).slice(0, 100);
+    if (input.query)
+        return String(input.query).slice(0, 100);
+    if (input.command)
+        return String(input.command).slice(0, 100);
+    if (input.prompt)
+        return String(input.prompt).slice(0, 100);
+    return JSON.stringify(input).slice(0, 100);
+}
+const NETWORK_TOOLS = new Set(['WebFetch', 'WebSearch']);
+export function formatTimedOutTools(tools) {
+    const lines = [];
+    const networkTools = tools.filter(t => NETWORK_TOOLS.has(t.toolName));
+    const localTools = tools.filter(t => !NETWORK_TOOLS.has(t.toolName));
+    if (networkTools.length > 0) {
+        lines.push('### Network resources that timed out (DO NOT retry these URLs):');
+        for (const t of networkTools) {
+            const inputSummary = summarizeToolInput(t.input);
+            lines.push(`- **${t.toolName}**(${inputSummary}) — timed out after ${Math.round(t.timeoutMs / 1000)}s`);
+        }
+    }
+    if (localTools.length > 0) {
+        lines.push('### Tools that previously timed out (OK to retry with same or smaller content):');
+        for (const t of localTools) {
+            const inputSummary = summarizeToolInput(t.input);
+            lines.push(`- **${t.toolName}**(${inputSummary}) — timed out after ${Math.round(t.timeoutMs / 1000)}s`);
+        }
+    }
+    return lines;
+}
+export function formatCompletedTools(tools, maxLen = 2000) {
+    const lines = [];
+    lines.push('### Results already obtained:');
+    for (const tool of tools) {
+        const inputSummary = summarizeToolInput(tool.input);
+        const preview = tool.result.length > maxLen ? `${tool.result.slice(0, maxLen)}...` : tool.result;
+        lines.push(`- **${tool.toolName}**(${inputSummary}): ${preview}`);
+    }
+    return lines;
+}
+export function formatInProgressTools(tools) {
+    const lines = [];
+    lines.push('### Tools that were still running (lost when process was killed):');
+    for (const tool of tools) {
+        const inputSummary = summarizeToolInput(tool.input);
+        lines.push(`- **${tool.toolName}**(${inputSummary}) — was in progress, may need re-running`);
+    }
+    return lines;
+}
+export function formatToolResults(toolResults, maxLen = 3000) {
+    const completed = toolResults.filter(t => t.result !== undefined && !t.isError);
+    if (completed.length === 0)
+        return [];
+    const lines = [`### ${completed.length} preserved results from prior work:`, ''];
+    for (const tool of completed) {
+        const inputSummary = summarizeToolInput(tool.toolInput);
+        const preview = tool.result && tool.result.length > maxLen
+            ? `${tool.result.slice(0, maxLen)}...\n(truncated, ${tool.result.length} chars total)`
+            : tool.result || '';
+        lines.push(`**${tool.toolName}**(${inputSummary}):`);
+        lines.push(preview);
+        lines.push('');
+    }
+    return lines;
+}
+export function formatConversationHistory(movements, maxMovements = 5) {
+    const recent = movements.slice(-maxMovements);
+    if (recent.length === 0)
+        return [];
+    const lines = ['### Conversation so far:'];
+    for (const movement of recent) {
+        const promptText = movement.userPrompt.length > 300 ? `${movement.userPrompt.slice(0, 300)}...` : movement.userPrompt;
+        lines.push(`**User (prompt ${movement.sequenceNumber}):** ${promptText}`);
+        if (movement.assistantResponse) {
+            const response = movement.assistantResponse.length > 1000
+                ? `${movement.assistantResponse.slice(0, 1000)}...\n(truncated, ${movement.assistantResponse.length} chars)`
+                : movement.assistantResponse;
+            lines.push(`**Your response:** ${response}`);
+        }
+        lines.push('');
+    }
+    return lines;
+}
+export function buildHistoricalContext(movements) {
+    if (movements.length === 0) {
+        return '';
+    }
+    const contextParts = [
+        '--- CONVERSATION HISTORY (for context, do not repeat these responses) ---',
+        ''
+    ];
+    for (const movement of movements) {
+        contextParts.push(`[User Prompt ${movement.sequenceNumber}]:`);
+        const promptText = movement.userPrompt.length > 2000
+            ? `${movement.userPrompt.slice(0, 2000)}\n... (prompt truncated for context)`
+            : movement.userPrompt;
+        contextParts.push(promptText);
+        contextParts.push('');
+        if (movement.assistantResponse) {
+            contextParts.push(`[Your Response ${movement.sequenceNumber}]:`);
+            const response = movement.assistantResponse.length > 2000
+                ? `${movement.assistantResponse.slice(0, 2000)}\n... (response truncated for context)`
+                : movement.assistantResponse;
+            contextParts.push(response);
+            contextParts.push('');
+        }
+        if (movement.toolUseHistory && movement.toolUseHistory.length > 0) {
+            contextParts.push(`[Tools Used in Prompt ${movement.sequenceNumber}]:`);
+            for (const tool of movement.toolUseHistory) {
+                contextParts.push(`- ${tool.toolName}`);
+            }
+            contextParts.push('');
+        }
+    }
+    contextParts.push('--- END OF CONVERSATION HISTORY ---');
+    contextParts.push('');
+    contextParts.push('Continue the conversation from where we left off. The user is now asking:');
+    contextParts.push('');
+    return contextParts.join('\n');
+}
+export function buildRetryPrompt(checkpoint, originalPrompt, allTimedOut) {
+    const urlSuffix = checkpoint.hungTool.url ? ` while fetching: ${checkpoint.hungTool.url}` : '';
+    const hungToolTimeoutSec = String(Math.round(checkpoint.hungTool.timeoutMs / 1000));
+    const timedOutToolsSection = allTimedOut && allTimedOut.length > 0
+        ? formatTimedOutTools(allTimedOut).join('\n')
+        : 'This URL/resource is unreachable. DO NOT retry the same URL or query.';
+    const completedToolsSection = checkpoint.completedTools.length > 0
+        ? formatCompletedTools(checkpoint.completedTools).join('\n')
+        : '';
+    const inProgressToolsSection = checkpoint.inProgressTools && checkpoint.inProgressTools.length > 0
+        ? formatInProgressTools(checkpoint.inProgressTools).join('\n')
+        : '';
+    const assistantTextSection = checkpoint.assistantText
+        ? `### Your response before interruption:\n${checkpoint.assistantText.length > 8000 ? `${checkpoint.assistantText.slice(0, 8000)}...\n(truncated — full response was ${checkpoint.assistantText.length} chars)` : checkpoint.assistantText}`
+        : '';
+    const fromSkill = loadSkillPrompt('retry-task', {
+        hungToolName: checkpoint.hungTool.toolName,
+        hungToolTimeoutSec,
+        urlSuffix,
+        timedOutToolsSection,
+        completedToolsSection,
+        inProgressToolsSection,
+        assistantTextSection,
+        originalPrompt,
+    });
+    if (fromSkill)
+        return fromSkill;
+    const parts = [
+        '## AUTOMATIC RETRY -- Previous Execution Interrupted',
+        '',
+        `The previous execution was interrupted because ${checkpoint.hungTool.toolName} timed out after ${hungToolTimeoutSec}s${urlSuffix}.`,
+        '',
+        timedOutToolsSection,
+        '',
+    ];
+    if (completedToolsSection)
+        parts.push(completedToolsSection, '');
+    if (inProgressToolsSection)
+        parts.push(inProgressToolsSection, '');
+    if (assistantTextSection)
+        parts.push(assistantTextSection, '');
+    parts.push('### Original task (continue from where you left off):');
+    parts.push(originalPrompt);
+    parts.push('');
+    parts.push('INSTRUCTIONS:');
+    parts.push('1. Use the results above -- do not re-fetch content you already have');
+    parts.push('2. Find ALTERNATIVE sources for the content that timed out (different URL, different approach)');
+    parts.push('3. Re-run any in-progress tools that were lost (listed above) if their results are needed');
+    parts.push('4. If no alternative exists, proceed with the results you have and note what was unavailable');
+    return parts.join('\n');
+}
+const WRITE_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'NotebookEdit']);
+export function buildResumeRetryPrompt(checkpoint, allTimedOut) {
+    const parts = [];
+    parts.push(`Your previous ${checkpoint.hungTool.toolName} call timed out after ${Math.round(checkpoint.hungTool.timeoutMs / 1000)}s${checkpoint.hungTool.url ? ` fetching: ${checkpoint.hungTool.url}` : ''}.`);
+    parts.push(...formatTimedOutForResume(allTimedOut));
+    parts.push(...formatInFlightForResume(checkpoint.inProgressTools));
+    parts.push('Continue your task — find alternative sources for network failures, or proceed with the results you already have.');
+    return parts.join('\n');
+}
+function formatTimedOutForResume(allTimedOut) {
+    if (!allTimedOut || allTimedOut.length === 0)
+        return [];
+    const lines = [''];
+    const networkTools = allTimedOut.filter(t => NETWORK_TOOLS.has(t.toolName));
+    const localTools = allTimedOut.filter(t => !NETWORK_TOOLS.has(t.toolName));
+    if (networkTools.length > 0) {
+        lines.push('Network resources that timed out (DO NOT retry these URLs):');
+        for (const t of networkTools)
+            lines.push(`- ${t.toolName}(${summarizeToolInput(t.input)})`);
+    }
+    if (localTools.length > 0) {
+        lines.push('Tools that previously timed out (OK to retry):');
+        for (const t of localTools)
+            lines.push(`- ${t.toolName}(${summarizeToolInput(t.input)})`);
+    }
+    return lines;
+}
+function formatInFlightForResume(inProgress) {
+    if (!inProgress || inProgress.length === 0)
+        return [];
+    const lines = ['', 'These tool calls were still running when the process was stopped, so you never saw their results:'];
+    for (const t of inProgress) {
+        const verifyHint = WRITE_TOOLS.has(t.toolName)
+            ? ' — check the file on disk first; re-run only if the change is not there'
+            : ' — re-run it if you still need its result';
+        lines.push(`- ${t.toolName}(${summarizeToolInput(t.input)})${verifyHint}`);
+    }
+    return lines;
+}
+export function buildPendingBackgroundContinuePrompt(tasks) {
+    const parts = [
+        'Your previous turn ended while these background tasks were still pending:',
+    ];
+    for (const t of tasks.slice(0, 10)) {
+        parts.push(`- ${t.description || t.taskType || t.taskId}${t.taskType && t.description ? ` (${t.taskType})` : ''}`);
+    }
+    if (tasks.length > 10)
+        parts.push(`- … and ${tasks.length - 10} more`);
+    parts.push('');
+    parts.push('This is a headless run: the process exits when you end your turn, so their completion notifications will NEVER wake you. Do not wait for a callback.');
+    parts.push('Check each task\'s status and output directly (TaskOutput, the files it writes, the command it ran), re-launch anything that did not finish, and complete the original task in THIS turn.');
+    return parts.join('\n');
+}
+export function buildServerErrorRetryPrompt(originalPrompt, isResume, toolResults) {
+    if (isResume) {
+        return [
+            'Your previous turn was cut short by a temporary API error on the server side (not by anything you did).',
+            'Your conversation history and every completed tool result are preserved. Review where you left off and continue the task.',
+        ].join('\n');
+    }
+    const parts = [
+        '## AUTOMATIC RETRY — Temporary API Error',
+        '',
+        'The previous execution was cut short by a temporary API error (server side). The task itself did not fail.',
+    ];
+    if (toolResults && toolResults.length > 0) {
+        parts.push('', ...formatToolResults(toolResults));
+    }
+    parts.push('### Original task:', originalPrompt, '', 'Continue from where the previous attempt left off, using the preserved results above.');
+    return parts.join('\n');
+}
+export function buildContextRecoveryPrompt(originalPrompt) {
+    const parts = [];
+    parts.push('Your previous response indicated you lost context due to tool timeouts, but your full conversation history is preserved — including all successful tool results.');
+    parts.push('');
+    parts.push('Review your conversation history above. You already have results from many successful tool calls. Use those results to continue the task.');
+    parts.push('');
+    parts.push('Original task:');
+    parts.push(originalPrompt);
+    parts.push('');
+    parts.push('INSTRUCTIONS:');
+    parts.push('1. Review your conversation history — all your previous tool results are still available');
+    parts.push('2. Continue from where you left off using the results you already gathered');
+    parts.push('3. If specific tool calls timed out, skip those and work with what you have');
+    parts.push('4. Do NOT start over — build on the work already done');
+    parts.push('5. Do NOT spawn Task subagents for work that previously timed out — do it inline instead');
+    parts.push('6. Prefer multiple small, focused tool calls over single large ones to avoid further timeouts');
+    return parts.join('\n');
+}
+export function buildFreshRecoveryPrompt(originalPrompt, toolResults, timedOutTools) {
+    const parts = [
+        '## CONTINUING LONG-RUNNING TASK',
+        '',
+        'The previous execution encountered tool timeouts and lost context.',
+        'Below are all results gathered before the interruption. Continue the task using these results.',
+        '',
+    ];
+    if (timedOutTools && timedOutTools.length > 0) {
+        parts.push(...formatTimedOutTools(timedOutTools), '');
+    }
+    parts.push(...formatToolResults(toolResults));
+    parts.push('### Original task:');
+    parts.push(originalPrompt);
+    parts.push('');
+    parts.push('INSTRUCTIONS:');
+    parts.push('1. Use the preserved results above — do NOT re-fetch data you already have');
+    parts.push('2. Continue the task from where it was interrupted');
+    parts.push('3. If you need additional data, fetch it (but try alternative sources if the original timed out)');
+    parts.push('4. Complete the original task fully');
+    parts.push('5. Do NOT spawn Task subagents for work that previously timed out — do it inline instead');
+    parts.push('6. Prefer multiple small, focused tool calls over single large ones to avoid further timeouts');
+    return parts.join('\n');
+}
+export function buildInterMovementRecoveryPrompt(originalPrompt, toolResults, movements) {
+    const parts = [
+        '## SESSION RECOVERY — Prior Session Expired',
+        '',
+        'Your previous session expired between prompts. Below is a summary of the conversation so far and all preserved tool results.',
+        '',
+    ];
+    parts.push(...formatConversationHistory(movements));
+    parts.push(...formatToolResults(toolResults));
+    parts.push('### Current user prompt:');
+    parts.push(originalPrompt);
+    parts.push('');
+    parts.push('INSTRUCTIONS:');
+    parts.push('1. Use the preserved results above — do NOT re-fetch data you already have');
+    parts.push('2. Continue the conversation naturally based on the history above');
+    parts.push('3. If you need additional data, fetch it with small focused tool calls');
+    parts.push('4. Do NOT spawn Task subagents — do work inline to avoid further timeouts');
+    parts.push('5. Prefer multiple small, focused tool calls over single large ones');
+    return parts.join('\n');
+}
+export function buildSignalCrashRecoveryPrompt(originalPrompt, isResume, toolResults, backgroundWorkLost = false) {
+    const parts = [];
+    if (isResume) {
+        parts.push('Your previous execution was interrupted by a system signal (the process was killed externally).');
+        parts.push('Your full conversation history is preserved — including all successful tool results.');
+        if (backgroundWorkLost) {
+            parts.push('');
+            parts.push('IMPORTANT: Background agents/workflows you launched were terminated with the process. Their completion notifications will NEVER arrive — do not wait for them and do not schedule wakeups to check on them. Re-launch the background work you still need, or do it directly, and drive the task to completion.');
+        }
+        parts.push('');
+        parts.push('Review your conversation history above and continue from where you left off.');
+    }
+    else {
+        parts.push('## AUTOMATIC RETRY — Previous Execution Interrupted');
+        parts.push('');
+        parts.push('The previous execution was interrupted by a system signal (process killed).');
+        if (backgroundWorkLost) {
+            parts.push('Background agents/workflows from that run were terminated with it — their notifications will never arrive. Re-launch any background work you still need instead of waiting.');
+        }
+        if (toolResults && toolResults.length > 0) {
+            parts.push(`${toolResults.length} tool results were preserved from prior work.`);
+            parts.push('');
+            parts.push('### Preserved results:');
+            for (const t of toolResults.slice(-20)) {
+                const inputSummary = JSON.stringify(t.toolInput).slice(0, 120);
+                const resultPreview = (t.result ?? '').slice(0, 200);
+                parts.push(`- **${t.toolName}**(${inputSummary}): ${resultPreview}`);
+            }
+        }
+    }
+    parts.push('');
+    parts.push('### Original task:');
+    parts.push(originalPrompt);
+    parts.push('');
+    parts.push('INSTRUCTIONS:');
+    parts.push('1. Use the results above -- do not re-fetch content you already have');
+    parts.push('2. Continue from where you left off');
+    parts.push('3. Prefer multiple small, focused tool calls over single large ones');
+    parts.push(backgroundWorkLost
+        ? '4. Re-launch the background agents/workflows the task still needs promptly — the old ones are gone and will never report back'
+        : '4. Do NOT spawn Task subagents — do work inline to avoid further interruptions');
+    return parts.join('\n');
+}
+export function extractHistoricalToolResults(movements, maxMovements = 3) {
+    const results = [];
+    const recentMovements = movements.slice(-maxMovements);
+    for (const movement of recentMovements) {
+        if (!movement.toolUseHistory)
+            continue;
+        for (const tool of movement.toolUseHistory) {
+            if (tool.result !== undefined && !tool.isError) {
+                results.push({
+                    toolName: tool.toolName,
+                    toolId: tool.toolId,
+                    toolInput: tool.toolInput,
+                    result: tool.result,
+                    isError: tool.isError,
+                    duration: tool.duration,
+                });
+            }
+        }
+    }
+    return results;
+}

package/dist/server/cli/retry/retry-best-result.js

@@ -0,0 +1,28 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { hlog } from '../headless/headless-logger.js';
+import { chooseBestAttempt } from '../headless/retry-strategies.js';
+export async function selectBestResult(state, result, userPrompt, verbose) {
+    if (!state.bestResult || state.bestResult === result || state.retryNumber === 0) {
+        return result;
+    }
+    const claudeCmd = resolveClaudeCommand();
+    const { chosen, assessment } = await chooseBestAttempt(state.bestResult, result, userPrompt, claudeCmd, verbose);
+    state.assessments.push(assessment);
+    if (!assessment.assessed)
+        state.assessorFailed = true;
+    if (chosen === result) {
+        if (verbose)
+            hlog(`[BEST-RESULT] Final attempt kept: ${assessment.reason}`);
+        return result;
+    }
+    if (verbose)
+        hlog(`[BEST-RESULT] Earlier attempt kept: ${assessment.reason}`);
+    return mergeResultSessionId(state.bestResult, result.claudeSessionId);
+}
+function mergeResultSessionId(result, sessionId) {
+    if (sessionId)
+        return { ...result, claudeSessionId: sessionId };
+    return result;
+}

package/dist/server/cli/retry/retry-context-loss.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { hlog } from '../headless/headless-logger.js';
+import { assessContextLoss } from '../headless/stall-assessor.js';
+const WRITE_TOOL_NAMES = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+export function detectResumeContextLoss(result, state, verbose) {
+    if (!state.lastUseResume || state.checkpointRef.value || state.retryNumber >= state.maxRetries || state.lastNativeTimeouts > 0) {
+        return;
+    }
+    if (result.engineNotice || result.startupTimedOut)
+        return;
+    if (!result.assistantResponse || result.assistantResponse.trim().length === 0) {
+        state.contextLost = true;
+        if (verbose)
+            hlog('[CONTEXT-RECOVERY] Resume context loss: null/empty response');
+    }
+    else if (result.resumeBufferedOutput !== undefined) {
+        state.contextLost = true;
+        if (verbose)
+            hlog('[CONTEXT-RECOVERY] Resume context loss: buffer never flushed (no thinking/tools)');
+    }
+    else if ((!result.toolUseHistory || result.toolUseHistory.length === 0) &&
+        !result.thinkingOutput &&
+        result.assistantResponse.length < 500) {
+        state.contextLost = true;
+        if (verbose)
+            hlog('[CONTEXT-RECOVERY] Resume context loss: no tools, no thinking, short response');
+    }
+}
+export async function detectNativeTimeoutContextLoss(result, state, verbose) {
+    if (state.contextLost)
+        return;
+    const nativeTimeouts = state.lastNativeTimeouts;
+    const { effectiveTimeouts } = computeEffectiveTimeouts(result, nativeTimeouts);
+    if (effectiveTimeouts === 0 || !result.assistantResponse || state.checkpointRef.value || state.retryNumber >= state.maxRetries) {
+        return;
+    }
+    if (result.engineNotice)
+        return;
+    const contextLossCtx = {
+        assistantResponse: result.assistantResponse,
+        effectiveTimeouts,
+        nativeTimeoutCount: nativeTimeouts,
+        successfulToolCalls: result.toolUseHistory?.filter(t => t.result !== undefined && !t.isError).length ?? 0,
+        thinkingOutputLength: result.thinkingOutput?.length ?? 0,
+        hasSuccessfulWrite: result.toolUseHistory?.some(t => WRITE_TOOL_NAMES.has(t.toolName) && t.result !== undefined && !t.isError) ?? false,
+    };
+    const claudeCmd = resolveClaudeCommand();
+    const verdict = await assessContextLoss(contextLossCtx, claudeCmd, verbose);
+    state.assessments.push({
+        kind: 'context-loss',
+        verdict: verdict.assessed ? (verdict.contextLost ? 'LOST' : 'OK') : 'UNAVAILABLE',
+        reason: verdict.reason,
+        assessed: verdict.assessed,
+        at: Date.now(),
+    });
+    if (!verdict.assessed)
+        state.assessorFailed = true;
+    state.contextLost = verdict.contextLost;
+    if (verbose) {
+        hlog(`[CONTEXT-RECOVERY] Haiku verdict: ${state.contextLost ? 'LOST' : 'OK'} — ${verdict.reason}`);
+    }
+}
+function computeEffectiveTimeouts(result, nativeTimeouts) {
+    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 = [...allIds].filter(id => !succeededIds.has(id)).length;
+    return { effectiveTimeouts: Math.max(nativeTimeouts, toolsWithoutResult) };
+}