@minionry/minion 0.7.36

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

@@ -0,0 +1,213 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { AnalyticsEvents, trackEvent } from '../../services/analytics.js';
+import { hlog } from '../headless/headless-logger.js';
+import { isTerminalEngineNotice, MAX_SERVER_ERROR_RETRIES } from '../headless/retry-strategies.js';
+import { buildContextRecoveryPrompt, buildFreshRecoveryPrompt, buildInterMovementRecoveryPrompt, buildResumeRetryPrompt, buildRetryPrompt, buildServerErrorRetryPrompt, buildSignalCrashRecoveryPrompt, extractHistoricalToolResults, } from '../prompt-builders.js';
+import { accumulateToolResults } from './retry-tool-results.js';
+export function shouldRetryServerError(result, state, session, callbacks) {
+    if (result.engineNotice?.kind !== 'server_error')
+        return false;
+    if (state.checkpointRef.value || state.retryNumber >= state.maxRetries)
+        return false;
+    if (state.serverErrorRetries >= MAX_SERVER_ERROR_RETRIES)
+        return false;
+    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})`;
+    state.retryLog.push({ retryNumber: state.retryNumber, path: 'ServerError', reason, timestamp: Date.now() });
+    hlog(`[RETRY] Server error: ${reason} (retry ${state.retryNumber}/${state.maxRetries})`);
+    callbacks.emit('onAutoRetry', {
+        retryNumber: state.retryNumber,
+        maxRetries: state.maxRetries,
+        toolName: 'ServerError',
+        completedCount: state.accumulatedToolResults.length,
+    });
+    callbacks.queueOutput(`\n[[MINIONRY_SIGNAL_RECOVERY]] Temporary API error — ${useResume ? 'resuming session' : 'restarting'} with ${state.accumulatedToolResults.length} preserved results (retry ${state.retryNumber}/${state.maxRetries}).\n`);
+    callbacks.flushOutputQueue();
+    if (useResume) {
+        state.contextRecoverySessionId = result.claudeSessionId;
+        session.claudeSessionId = result.claudeSessionId;
+        state.currentPrompt = buildServerErrorRetryPrompt(state.promptWithAttachments, true);
+    }
+    else {
+        state.freshRecoveryMode = true;
+        state.currentPrompt = buildServerErrorRetryPrompt(state.promptWithAttachments, false, state.accumulatedToolResults);
+    }
+    return true;
+}
+export function applyInterMovementRecovery(state, history, callbacks) {
+    const historicalResults = extractHistoricalToolResults(history);
+    const allResults = [...historicalResults, ...state.accumulatedToolResults];
+    callbacks.emit('onAutoRetry', {
+        retryNumber: state.retryNumber,
+        maxRetries: 3,
+        toolName: 'InterMovementRecovery',
+        completedCount: allResults.length,
+    });
+    callbacks.queueOutput(`\n[[MINIONRY_CONTEXT_RECOVERY]] Session context expired — continuing with ${allResults.length} preserved results from prior work (retry ${state.retryNumber}/3).\n`);
+    callbacks.flushOutputQueue();
+    state.freshRecoveryMode = true;
+    state.currentPrompt = buildInterMovementRecoveryPrompt(state.promptWithAttachments, allResults, history);
+}
+export function applyNativeTimeoutRecovery(result, state, session, callbacks) {
+    const completedCount = state.accumulatedToolResults.length;
+    callbacks.emit('onAutoRetry', {
+        retryNumber: state.retryNumber,
+        maxRetries: 3,
+        toolName: 'ContextRecovery',
+        completedCount,
+    });
+    if (result.claudeSessionId && state.retryNumber === 1) {
+        callbacks.queueOutput(`\n[[MINIONRY_CONTEXT_RECOVERY]] Context loss detected — resuming session with ${completedCount} preserved results (retry ${state.retryNumber}/3).\n`);
+        callbacks.flushOutputQueue();
+        state.contextRecoverySessionId = result.claudeSessionId;
+        session.claudeSessionId = result.claudeSessionId;
+        state.currentPrompt = buildContextRecoveryPrompt(state.promptWithAttachments);
+    }
+    else {
+        callbacks.queueOutput(`\n[[MINIONRY_CONTEXT_RECOVERY]] Continuing with fresh context — ${completedCount} preserved results injected (retry ${state.retryNumber}/3).\n`);
+        callbacks.flushOutputQueue();
+        state.freshRecoveryMode = true;
+        state.currentPrompt = buildFreshRecoveryPrompt(state.promptWithAttachments, state.accumulatedToolResults, state.timedOutTools);
+    }
+}
+export function shouldRetryContextLoss(result, state, session, callbacks) {
+    if (state.checkpointRef.value || state.retryNumber >= state.maxRetries || !state.contextLost) {
+        return false;
+    }
+    const useResume = state.lastUseResume;
+    const nativeTimeouts = state.lastNativeTimeouts;
+    accumulateToolResults(result, state);
+    state.retryNumber++;
+    const path = (useResume && nativeTimeouts === 0) ? 'InterMovementRecovery' : 'NativeTimeoutRecovery';
+    state.retryLog.push({
+        retryNumber: state.retryNumber,
+        path,
+        reason: `Context lost (${nativeTimeouts} timeouts, ${state.accumulatedToolResults.length} tools preserved)`,
+        timestamp: Date.now(),
+    });
+    if (useResume && nativeTimeouts === 0) {
+        applyInterMovementRecovery(state, session.history.movements, callbacks);
+    }
+    else {
+        applyNativeTimeoutRecovery(result, state, session, callbacks);
+    }
+    return true;
+}
+export function shouldRetrySessionNotFound(result, state, session, callbacks) {
+    if (!result.sessionNotFound || state.checkpointRef.value || state.retryNumber >= state.maxRetries) {
+        return false;
+    }
+    accumulateToolResults(result, state);
+    state.retryNumber++;
+    session.claudeSessionId = undefined;
+    state.retryLog.push({
+        retryNumber: state.retryNumber,
+        path: 'SessionNotFound',
+        reason: `Resume session expired/not found, ${state.accumulatedToolResults.length} tools preserved`,
+        timestamp: Date.now(),
+    });
+    trackEvent(AnalyticsEvents.IMPROVISE_AUTO_RETRY, {
+        retry_number: state.retryNumber,
+        hung_tool: 'session_not_found',
+        completed_tools: state.accumulatedToolResults.length,
+        resume_attempted: false,
+    });
+    applyInterMovementRecovery(state, session.history.movements, callbacks);
+    return true;
+}
+export function applyToolTimeoutRetry(state, callbacks, model, effortLevel) {
+    if (!state.checkpointRef.value || state.retryNumber >= state.maxRetries) {
+        return false;
+    }
+    const cp = state.checkpointRef.value;
+    state.retryNumber++;
+    state.timedOutTools.push({
+        toolName: cp.hungTool.toolName,
+        input: cp.hungTool.input ?? {},
+        timeoutMs: cp.hungTool.timeoutMs,
+    });
+    const canResumeSession = !!cp.claudeSessionId;
+    state.retryLog.push({
+        retryNumber: state.retryNumber,
+        path: 'ToolTimeout',
+        reason: `${cp.hungTool.toolName} timed out after ${cp.hungTool.timeoutMs}ms, ${cp.completedTools.length} tools completed${cp.inProgressTools.length > 0 ? `, ${cp.inProgressTools.length} in flight` : ''}, ${canResumeSession ? 'resuming' : 'fresh start'}`,
+        timestamp: Date.now(),
+    });
+    callbacks.emit('onAutoRetry', {
+        retryNumber: state.retryNumber,
+        maxRetries: state.maxRetries,
+        toolName: cp.hungTool.toolName,
+        url: cp.hungTool.url,
+        completedCount: cp.completedTools.length,
+    });
+    trackEvent(AnalyticsEvents.IMPROVISE_AUTO_RETRY, {
+        retry_number: state.retryNumber,
+        hung_tool: cp.hungTool.toolName,
+        hung_url: cp.hungTool.url?.slice(0, 200),
+        completed_tools: cp.completedTools.length,
+        elapsed_ms: cp.elapsedMs,
+        resume_attempted: canResumeSession,
+        model: model || 'default',
+        effort_level: effortLevel || 'auto',
+    });
+    state.currentPrompt = canResumeSession
+        ? buildResumeRetryPrompt(cp, state.timedOutTools)
+        : buildRetryPrompt(cp, state.promptWithAttachments, state.timedOutTools);
+    callbacks.queueOutput(`\n[[MINIONRY_AUTO_RETRY]] Auto-retry ${state.retryNumber}/${state.maxRetries}: ${canResumeSession ? 'Resuming session' : 'Continuing'} with ${cp.completedTools.length} successful results, skipping failed ${cp.hungTool.toolName}.\n`);
+    callbacks.flushOutputQueue();
+    return true;
+}
+export function shouldRetrySignalCrash(result, state, session, callbacks) {
+    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) || state.retryNumber >= state.maxRetries) {
+        return false;
+    }
+    if (state.checkpointRef.value || isTerminalEngineNotice(result)) {
+        return false;
+    }
+    accumulateToolResults(result, state);
+    state.retryNumber++;
+    const completedCount = state.accumulatedToolResults.length;
+    const signalInfo = result.signalName || (result.interrupted ? 'interrupted' : 'unknown signal');
+    const useResume = !!result.claudeSessionId && state.retryNumber === 1;
+    const backgroundWorkLost = !!result.backgroundTasksPendingAtExit;
+    state.retryLog.push({
+        retryNumber: state.retryNumber,
+        path: 'SignalCrash',
+        reason: `Process killed (${signalInfo}), ${completedCount} tools preserved, ${useResume ? 'resuming' : 'fresh start'}${backgroundWorkLost ? `, ${result.backgroundTasksPendingAtExit} background task(s) lost` : ''}`,
+        timestamp: Date.now(),
+    });
+    callbacks.emit('onAutoRetry', {
+        retryNumber: state.retryNumber,
+        maxRetries: state.maxRetries,
+        toolName: `SignalCrash(${signalInfo})`,
+        completedCount,
+    });
+    trackEvent(AnalyticsEvents.IMPROVISE_AUTO_RETRY, {
+        retry_number: state.retryNumber,
+        hung_tool: `signal_crash:${signalInfo}`,
+        completed_tools: completedCount,
+        resume_attempted: useResume,
+    });
+    const lostSuffix = backgroundWorkLost ? ' Background tasks were terminated and will be re-launched.' : '';
+    if (useResume) {
+        callbacks.queueOutput(`\n[[MINIONRY_SIGNAL_RECOVERY]] Process killed (${signalInfo}) — resuming session with ${completedCount} preserved results (retry ${state.retryNumber}/${state.maxRetries}).${lostSuffix}\n`);
+        callbacks.flushOutputQueue();
+        state.contextRecoverySessionId = result.claudeSessionId;
+        session.claudeSessionId = result.claudeSessionId;
+        state.currentPrompt = buildSignalCrashRecoveryPrompt(state.promptWithAttachments, true, undefined, backgroundWorkLost);
+    }
+    else {
+        callbacks.queueOutput(`\n[[MINIONRY_SIGNAL_RECOVERY]] Process killed (${signalInfo}) — restarting with ${completedCount} preserved results (retry ${state.retryNumber}/${state.maxRetries}).${lostSuffix}\n`);
+        callbacks.flushOutputQueue();
+        state.freshRecoveryMode = true;
+        const allResults = [...extractHistoricalToolResults(session.history.movements), ...state.accumulatedToolResults];
+        state.currentPrompt = buildSignalCrashRecoveryPrompt(state.promptWithAttachments, false, allResults, backgroundWorkLost);
+    }
+    return true;
+}

package/dist/server/cli/retry/retry-resume-strategy.js

@@ -0,0 +1,20 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export function determineResumeStrategy(state, session) {
+    if (state.freshRecoveryMode) {
+        state.freshRecoveryMode = false;
+        return { useResume: false, resumeSessionId: undefined };
+    }
+    if (state.contextRecoverySessionId) {
+        const id = state.contextRecoverySessionId;
+        state.contextRecoverySessionId = undefined;
+        return { useResume: true, resumeSessionId: id };
+    }
+    if (state.retryNumber === 0) {
+        return { useResume: session.claudeSessionId !== undefined, resumeSessionId: session.claudeSessionId };
+    }
+    if (state.lastWatchdogCheckpoint?.claudeSessionId) {
+        return { useResume: true, resumeSessionId: state.lastWatchdogCheckpoint.claudeSessionId };
+    }
+    return { useResume: false, resumeSessionId: undefined };
+}

package/dist/server/cli/retry/retry-runner-factory.js

@@ -0,0 +1,92 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { profileAllowsBrowserControl } from '../../services/sdk/run-profile.js';
+import { resolveSystemPromptContent } from '../../services/system-prompts.js';
+import { HeadlessRunner } from '../headless/index.js';
+import { buildHistoricalContext } from '../prompt-builders.js';
+function resolveBrowserMcpRunContext(options) {
+    const profile = options.appOrigin?.profile;
+    if (!profile || !profileAllowsBrowserControl(profile))
+        return undefined;
+    return {
+        agentId: `agent-${options.sessionId}`,
+        agentLabel: options.agentLabel ?? options.sessionId,
+        ...(options.planId ? { planId: options.planId } : {}),
+        ...(options.tabId ? { defaultTabId: options.tabId } : {}),
+        ...(options.tabId ? { agentSessionId: options.tabId } : {}),
+    };
+}
+export function createExecutionRunner(state, session, callbacks, sequenceNumber, resume, imageAttachments, workingDirOverride) {
+    const browserMcp = resolveBrowserMcpRunContext(session.options);
+    return new HeadlessRunner({
+        workingDir: workingDirOverride || session.options.workingDir,
+        tokenBudgetThreshold: session.options.tokenBudgetThreshold,
+        maxSessions: session.options.maxSessions,
+        verbose: session.options.verbose,
+        noColor: session.options.noColor,
+        model: session.options.model,
+        effortLevel: session.options.effortLevel,
+        fastMode: session.options.fastMode,
+        ultracode: session.options.ultracode,
+        appendSystemPrompt: session.options.systemPromptProfile
+            ? resolveSystemPromptContent(session.options.systemPromptProfile, session.options.systemPromptLang)
+            : undefined,
+        tabId: session.options.tabId,
+        agentId: `agent-${session.options.sessionId}`,
+        agentLabel: session.options.agentLabel ?? session.options.sessionId,
+        ...(session.options.planId ? { planId: session.options.planId } : {}),
+        ...(session.options.disallowedTools ? { disallowedTools: session.options.disallowedTools } : {}),
+        ...(session.options.appOrigin?.profile ? { appRunProfile: session.options.appOrigin.profile } : {}),
+        appTools: {
+            spaceDir: session.options.workingDir,
+            ...(session.options.appOrigin ? { onlyAppId: session.options.appOrigin.appId } : {}),
+        },
+        ...(browserMcp ? { browserMcp } : {}),
+        improvisationMode: true,
+        movementNumber: sequenceNumber,
+        continueSession: resume.useResume,
+        claudeSessionId: resume.resumeSessionId,
+        ...buildStreamingCallbacks(callbacks),
+        directPrompt: state.currentPrompt,
+        imageAttachments,
+        promptContext: (state.retryNumber === 0 && (session.primeFromHistory ?? (session.isResumedSession && session.isFirstPrompt)))
+            ? { accumulatedKnowledge: buildHistoricalContext(session.history.movements.filter((m) => m.sequenceNumber !== sequenceNumber)), filesModified: [] }
+            : undefined,
+        onToolTimeout: (checkpoint) => {
+            state.checkpointRef.value = checkpoint;
+        },
+        onExecutionTargetResolved: (model) => {
+            if (callbacks.isCancelled())
+                return;
+            callbacks.emit('onExecutionTargetUpdate', { model });
+        },
+    });
+}
+export function buildStreamingCallbacks(callbacks) {
+    return {
+        outputCallback: (text) => {
+            if (callbacks.isCancelled())
+                return;
+            callbacks.addEventLog({ type: 'output', data: { text, timestamp: Date.now() }, timestamp: Date.now() });
+            callbacks.queueOutput(text);
+        },
+        thinkingCallback: (text) => {
+            if (callbacks.isCancelled())
+                return;
+            callbacks.addEventLog({ type: 'thinking', data: { text }, timestamp: Date.now() });
+            callbacks.queueThinking(text);
+        },
+        toolUseCallback: (event) => {
+            if (callbacks.isCancelled())
+                return;
+            callbacks.addEventLog({ type: 'toolUse', data: { ...event, timestamp: Date.now() }, timestamp: Date.now() });
+            callbacks.flushOutputQueue();
+            callbacks.emit('onToolUse', event);
+        },
+        tokenUsageCallback: (usage) => {
+            if (callbacks.isCancelled())
+                return;
+            callbacks.emit('onTokenUsage', usage);
+        },
+    };
+}

package/dist/server/cli/retry/retry-tool-results.js

@@ -0,0 +1,22 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const MAX_ACCUMULATED_RESULTS = 50;
+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);
+    }
+}

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

@@ -0,0 +1,3 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const MAX_RETRIES = 3;

package/dist/server/engines/EngineEvent.js

@@ -0,0 +1,57 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const ENGINE_IDS = ['claude-code', 'codex', 'hermes'];
+export function isEngineId(value) {
+    return typeof value === 'string' && ENGINE_IDS.includes(value);
+}
+export function parseEngineId(value) {
+    return isEngineId(value) ? value : undefined;
+}
+export const CODEX_MODEL_IDS = ['gpt-5.1-codex-max', 'gpt-5-codex'];
+export const CLAUDE_MODEL_PRESETS = [
+    { value: 'default', label: 'Default', description: "The engine's own default model", isDefault: true },
+    { value: 'fable', label: 'Fable', description: 'Most capable, for the hardest work' },
+    { value: 'opus', label: 'Opus', description: 'Frontier reasoning for complex tasks' },
+    { value: 'sonnet', label: 'Sonnet', description: 'Balanced speed and capability' },
+    { value: 'haiku', label: 'Haiku', description: 'Fastest, for simple tasks' },
+];
+export const CODEX_MODEL_PRESETS = [
+    { value: 'gpt-5.1-codex-max', label: 'GPT-5.1 Codex Max', description: "Codex's most capable model", isDefault: true },
+    { value: 'gpt-5-codex', label: 'GPT-5 Codex', description: 'Faster Codex model' },
+];
+export const ENGINE_EFFORT_LEVELS = {
+    'claude-code': ['auto', 'low', 'medium', 'high', 'xhigh', 'max'],
+    codex: ['auto', 'minimal', 'low', 'medium', 'high', 'xhigh'],
+    hermes: [],
+};
+export function engineForModel(model) {
+    const profile = parseProfileModelValue(model);
+    if (profile)
+        return profile.engine;
+    if (CODEX_MODEL_IDS.includes(model))
+        return 'codex';
+    if (model.includes('/'))
+        return 'hermes';
+    return 'claude-code';
+}
+const PROFILE_MODEL_PREFIX = 'custom';
+export function profileModelValue(profile) {
+    return `${PROFILE_MODEL_PREFIX}:${profile.engine}:${profile.id}`;
+}
+export function parseProfileModelValue(value) {
+    if (!value.startsWith(`${PROFILE_MODEL_PREFIX}:`))
+        return undefined;
+    const parts = value.split(':');
+    if (parts.length !== 3)
+        return undefined;
+    const [, engine, profileId] = parts;
+    if (!isEngineId(engine) || !profileId)
+        return undefined;
+    return { engine, profileId };
+}
+export function isMessageEvent(event) {
+    return event.kind === 'message.delta' || event.kind === 'message.thinking';
+}
+export function isToolEvent(event) {
+    return event.kind === 'tool.start' || event.kind === 'tool.end';
+}