salmon-loop 0.2.13 → 0.3.0

package/dist/cli/argv/headless-detection.js

@@ -1,3 +1,4 @@
+const HEADLESS_OUTPUT_FORMATS = new Set(['json', 'stream-json']);
 function readFlagValue(tokens, index) {
     const token = tokens[index];
     const eq = token.indexOf('=');
@@ -57,4 +58,30 @@ export function detectHeadlessOutputFromArgv(argv) {
         outputProfile,
     };
 }
+export function shouldForceColorForArgv(argv) {
+    if (process.env.NO_COLOR !== undefined)
+        return false;
+    const existingForceColor = process.env.FORCE_COLOR;
+    if (existingForceColor !== undefined && existingForceColor !== '')
+        return false;
+    const tokens = argv.slice(2);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token === '--')
+            break;
+        if (token === '--output-format') {
+            const value = tokens[i + 1];
+            if (HEADLESS_OUTPUT_FORMATS.has(String(value)))
+                return false;
+            i += 1;
+            continue;
+        }
+        if (token.startsWith('--output-format=')) {
+            const value = token.slice('--output-format='.length);
+            if (HEADLESS_OUTPUT_FORMATS.has(value))
+                return false;
+        }
+    }
+    return true;
+}
 //# sourceMappingURL=headless-detection.js.map

package/dist/cli/chat-flow.js

@@ -0,0 +1,11 @@
+import { resolveExecutionProfile, } from '../core/facades/cli-chat.js';
+export function resolveActiveChatFlowMode(sessionFlowMode, defaultFlowMode) {
+    return sessionFlowMode ?? defaultFlowMode ?? 'autopilot';
+}
+export function resolveChatCheckpointStrategy(flowMode, configured) {
+    const profile = resolveExecutionProfile(flowMode);
+    return profile.readOnly
+        ? 'direct'
+        : (configured ?? profile.defaultCheckpointStrategy ?? 'worktree');
+}
+//# sourceMappingURL=chat-flow.js.map

package/dist/cli/chat.js

@@ -1,6 +1,7 @@
-import { buildSessionConversationContext, ChatSessionManager, DEFAULT_LLM_OUTPUT_POLICY, emitLlmOutput, getDefaultSessionContextBudgetTokens, InputHistoryManager, logIgnoredError, getLogger, refreshSessionSummary, routeChatIntent, runSalmonLoop, TokenTracker, } from '../core/facades/cli-chat.js';
+import { buildSessionArtifactStateFromLoopResult, buildEffectiveConversationContext, ChatSessionManager, DEFAULT_LLM_OUTPUT_POLICY, emitLlmOutput, getDefaultSessionContextBudgetTokens, InputHistoryManager, logIgnoredError, getLogger, refreshSessionSummary, runSalmonLoop, TokenTracker, createInitialTracking, onNormalTurnComplete, runCompactionPipeline, reactiveCompact, } from '../core/facades/cli-chat.js';
 import { createSubAgentController } from '../core/facades/cli-subagent.js';
 import { createUiAuthorizationProvider } from './authorization/provider.js';
+import { resolveActiveChatFlowMode, resolveChatCheckpointStrategy } from './chat-flow.js';
 import { commands } from './commands/registry.js';
 import { CHAT_QUEUE_CONFIG } from './config.js';
 import { text } from './locales/index.js';
@@ -49,7 +50,10 @@ export async function startChatMode(options) {
     let hideTimer = null;
     let currentInstruction = null;
     let lastInterruptedInput = null;
+    let currentFlowMode = null;
+    let lastInterruptedFlowMode = null;
     let currentLlmOutputPolicy = options.llmOutput ?? DEFAULT_LLM_OUTPUT_POLICY;
+    let currentCompactionTracking = createInitialTracking();
     const authorizationProvider = createUiAuthorizationProvider({
         emit: (event) => {
             latestEmit?.({ ...event, timestamp: new Date() });
@@ -156,8 +160,28 @@ export async function startChatMode(options) {
             return false;
         return /cancelled by user/i.test(reason);
     };
-    const markInterrupted = (input) => {
+    const buildRecoveryFailureSummary = (result) => {
+        if (result.success)
+            return null;
+        const isRecoveryCandidate = result.reasonCode === 'TOOL_CORRECTION_REQUIRED' ||
+            result.reasonCode === 'AWAITING_INPUT' ||
+            isInterruptResult(result.reason);
+        if (!isRecoveryCandidate)
+            return null;
+        const summary = {};
+        if (typeof result.reasonCode === 'string')
+            summary.reasonCode = result.reasonCode;
+        if (typeof result.diagnosticCode === 'string')
+            summary.diagnosticCode = result.diagnosticCode;
+        if (typeof result.safeHint === 'string')
+            summary.safeHint = result.safeHint;
+        if (typeof result.failurePhase === 'string')
+            summary.failurePhase = result.failurePhase;
+        return Object.keys(summary).length > 0 ? summary : null;
+    };
+    const markInterrupted = (input, flowMode) => {
         lastInterruptedInput = input;
+        lastInterruptedFlowMode = flowMode ?? null;
         queue.pause();
         latestEmit?.({
             type: 'log',
@@ -172,6 +196,8 @@ export async function startChatMode(options) {
             return;
         if (!latestDispatch)
             return;
+        const queuedFlowMode = queueOptions?.flowMode ??
+            resolveActiveChatFlowMode(sessionManager.getChatFlowMode(), options.defaultFlowMode);
         try {
             const currentSessionId = sessionManager.getCurrent().meta.id;
             historyManager
@@ -203,13 +229,30 @@ export async function startChatMode(options) {
             started = true;
             latestDispatch?.({ type: 'SHIFT_QUEUE_MESSAGE' });
             currentInstruction = trimmed;
+            currentFlowMode = queuedFlowMode;
             const timeoutAbort = new AbortController();
             const mergedSignal = mergeAbortSignals([latestGuiOptions?.signal, timeoutAbort.signal]);
+            // Run compaction pipeline (Level 1 Autocompact) before building context
+            const compactionResult = await runCompactionPipeline({
+                sessionManager,
+                llm: options.llm,
+                tracking: currentCompactionTracking,
+                signal: mergedSignal.signal,
+            });
+            if (compactionResult.performed) {
+                currentCompactionTracking = compactionResult.tracking;
+            }
             const modelIdForBudget = options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL;
-            const conversationContext = buildSessionConversationContext(sessionManager.getMessages(), {
-                budgetTokens: getDefaultSessionContextBudgetTokens({ modelId: modelIdForBudget }),
-                summaryState: sessionManager.getSummaryState(),
+            const baseSessionBudgetTokens = getDefaultSessionContextBudgetTokens({
+                modelId: modelIdForBudget,
+            });
+            const conversationContext = buildEffectiveConversationContext({
+                llm: options.llm,
+                sessionManager,
+                budgetTokens: baseSessionBudgetTokens,
             });
+            const artifactHints = sessionManager.getArtifactState();
+            const replacementState = sessionManager.getReplacementState();
             // Single source of truth: chat runtime owns when a user message is appended to the UI list.
             // The UI layer must not also append user messages (to avoid duplicates).
             latestDispatch?.({
@@ -228,27 +271,15 @@ export async function startChatMode(options) {
                 timestamp: Date.now(),
             });
             const execution = await withTimeout((async () => {
-                const intentDecision = await routeChatIntent(trimmed, {
-                    llm: options.llm,
-                    signal: mergedSignal.signal,
-                });
-                latestEmit?.({
-                    type: 'log',
-                    level: 'info',
-                    message: text.cli.chatIntentRouted(intentDecision.intent, intentDecision.confidence, intentDecision.reason),
-                    timestamp: new Date(),
-                });
-                const nonMutating = intentDecision.intent === 'review' ||
-                    intentDecision.intent === 'research' ||
-                    intentDecision.intent === 'answer';
-                const strategy = nonMutating ? 'direct' : options.checkpointStrategy || 'worktree';
+                const flowMode = queuedFlowMode;
+                const strategy = resolveChatCheckpointStrategy(flowMode, options.checkpointStrategy);
                 const verboseLevel = options.verbose === true ? 'basic' : options.verbose;
                 const result = await runSalmonLoop({
                     instruction: trimmed,
                     verify: options.verifyCommand,
                     repoPath: options.repoPath,
                     llm: options.llm,
-                    mode: intentDecision.intent,
+                    mode: flowMode,
                     strategy,
                     verbose: verboseLevel,
                     onEvent: latestEmit,
@@ -257,6 +288,8 @@ export async function startChatMode(options) {
                     outcomeReporter: options.outcomeReporter,
                     auditScope: options.auditScope,
                     conversationContext: conversationContext.length > 0 ? conversationContext : undefined,
+                    artifactHints,
+                    replacementState,
                     astValidation: options.astValidation,
                     languagePlugins: options.languagePlugins,
                     // Resolve sessionId at call time to support `/session` switching.
@@ -267,15 +300,99 @@ export async function startChatMode(options) {
                     userInputProvider,
                     subAgentController,
                     permissionMode: options.permissionMode,
+                }).catch(async (error) => {
+                    // Level 2: Reactive Compact
+                    // If the provider reports prompt-too-long, attempt emergency compaction AND retry ONCE
+                    // with a smaller session context budget to guarantee prompt reduction.
+                    const isContextOverflow = (() => {
+                        if (!error || typeof error !== 'object')
+                            return false;
+                        if ('llmCode' in error &&
+                            error.llmCode === 'LLM_CONTEXT_LENGTH_EXCEEDED') {
+                            return true;
+                        }
+                        const message = error instanceof Error
+                            ? error.message
+                            : typeof error.message === 'string'
+                                ? String(error.message)
+                                : '';
+                        const lower = message.toLowerCase();
+                        return (lower.includes('maximum context length') ||
+                            lower.includes('context length') ||
+                            lower.includes('too many tokens') ||
+                            lower.includes('prompt is too long') ||
+                            lower.includes('input is too long') ||
+                            lower.includes('please reduce'));
+                    })();
+                    if (!isContextOverflow) {
+                        throw error;
+                    }
+                    const reactiveResult = await reactiveCompact({
+                        sessionManager,
+                        llm: options.llm,
+                        error,
+                        tracking: currentCompactionTracking,
+                        signal: mergedSignal.signal,
+                    });
+                    currentCompactionTracking = reactiveResult.tracking;
+                    // Rebuild context and retry runSalmonLoop.
+                    // Important: avoid duplicating the current instruction inside `conversationContext`,
+                    // since `instruction: trimmed` is already provided as the primary input.
+                    const history = sessionManager.getMessages();
+                    const retryMessages = history.length > 0 &&
+                        history[history.length - 1]?.role === 'user' &&
+                        history[history.length - 1]?.content === trimmed
+                        ? history.slice(0, -1)
+                        : history;
+                    const reactiveBudgetTokens = Math.max(64, Math.min(baseSessionBudgetTokens - 1, Math.floor(baseSessionBudgetTokens * 0.5)));
+                    getLogger().audit('COMPACTION_REACTIVE_RETRY', {
+                        reason: 'context_overflow',
+                        baseSessionBudgetTokens,
+                        reactiveBudgetTokens,
+                        baseIsMinimum: baseSessionBudgetTokens <= 256,
+                        modelId: modelIdForBudget ?? 'unknown',
+                    }, { source: 'chat', severity: 'low', scope: 'session', phase: 'COMPACTION' });
+                    const newContext = buildEffectiveConversationContext({
+                        llm: options.llm,
+                        sessionManager,
+                        messages: retryMessages,
+                        budgetTokens: reactiveBudgetTokens,
+                    });
+                    return await runSalmonLoop({
+                        instruction: trimmed,
+                        verify: options.verifyCommand,
+                        repoPath: options.repoPath,
+                        llm: options.llm,
+                        mode: flowMode,
+                        strategy,
+                        verbose: verboseLevel,
+                        onEvent: latestEmit,
+                        signal: mergedSignal.signal,
+                        llmOutput: currentLlmOutputPolicy,
+                        outcomeReporter: options.outcomeReporter,
+                        auditScope: options.auditScope,
+                        conversationContext: newContext.length > 0 ? newContext : undefined,
+                        artifactHints,
+                        replacementState,
+                        astValidation: options.astValidation,
+                        languagePlugins: options.languagePlugins,
+                        langfuseSessionId: options.langfuseSessionId || sessionManager.getCurrent().meta.id,
+                        langfuseUserId: options.langfuseUserId,
+                        authorizationProvider,
+                        authorizationMode: 'deferred',
+                        userInputProvider,
+                        subAgentController,
+                        permissionMode: options.permissionMode,
+                    });
                 });
-                return { kind: 'flow', mode: intentDecision.intent, result };
+                return { kind: 'flow', mode: flowMode, result };
             })(), CHAT_QUEUE_CONFIG.TASK_TIMEOUT_MS, () => timeoutAbort.abort()).finally(() => {
                 mergedSignal.cleanup();
             });
             const result = execution.result;
             const mode = execution.mode;
             if (!result.success && isInterruptResult(result.reason)) {
-                markInterrupted(trimmed);
+                markInterrupted(trimmed, mode);
             }
             // Add assistant message & iteration info
             const changedFiles = result.changedFiles ?? [];
@@ -313,23 +430,38 @@ export async function startChatMode(options) {
             if (usage) {
                 TokenTracker.accumulate(sessionManager.getCurrent(), usage);
             }
+            sessionManager.mergeArtifactState(buildSessionArtifactStateFromLoopResult(result));
+            for (const preview of result.artifactHints?.toolResultPreviewArtifacts ?? []) {
+                sessionManager.freezeReplacementDecision({
+                    toolResultId: `${preview.label}::${preview.artifact.handle}`,
+                    decision: 'replaced',
+                    preview: preview.label,
+                    sourceArtifactHandle: preview.artifact.handle,
+                });
+            }
             await refreshSessionSummary({
                 sessionManager,
                 llm: options.llm,
                 contextHash: result.contextHash,
                 strategy: 'auto',
+                recoveryStatePatch: {
+                    lastFailureSummary: buildRecoveryFailureSummary(result),
+                },
             });
+            currentCompactionTracking = onNormalTurnComplete(currentCompactionTracking);
             await sessionManager.save();
             currentInstruction = null;
+            currentFlowMode = null;
             return result;
         }).catch((error) => {
             if (!started) {
                 latestDispatch?.({ type: 'REMOVE_QUEUE_MESSAGE', payload: { id: queueMessageId } });
             }
             if (isInterruptError(error) && currentInstruction) {
-                markInterrupted(currentInstruction);
+                markInterrupted(currentInstruction, currentFlowMode ?? undefined);
             }
             currentInstruction = null;
+            currentFlowMode = null;
             throw error;
         });
     };
@@ -341,11 +473,13 @@ export async function startChatMode(options) {
         resume: () => {
             queue.resume();
             lastInterruptedInput = null;
+            lastInterruptedFlowMode = null;
             getLogger().audit('QUEUE_RESUME', { status: 'resumed' }, { source: 'chat', severity: 'low', scope: 'session' });
         },
         clear: () => {
             const cleared = queue.clear();
             lastInterruptedInput = null;
+            lastInterruptedFlowMode = null;
             latestDispatch?.({ type: 'CLEAR_QUEUE_MESSAGES' });
             getLogger().audit('QUEUE_CLEAR', { cleared }, { source: 'chat', severity: 'low', scope: 'session' });
             return cleared;
@@ -354,9 +488,11 @@ export async function startChatMode(options) {
             if (!lastInterruptedInput)
                 return false;
             const retryInput = lastInterruptedInput;
+            const retryFlowMode = lastInterruptedFlowMode ?? undefined;
             lastInterruptedInput = null;
+            lastInterruptedFlowMode = null;
             queue.resume();
-            enqueueInput(retryInput, { front: true });
+            enqueueInput(retryInput, { front: true, flowMode: retryFlowMode });
             return true;
         },
         status: () => {

package/dist/cli/commands/chat.js

@@ -1,5 +1,6 @@
-import { createPluginRegistry, createPromptRegistry, createRuntimeLlm, setPluginRegistry, setPromptRegistry, ExtensionConfigError, getLogger, normalizePermissionMode, PluginLoader, resolveExtensions, } from '../../core/facades/cli-command-chat.js';
+import { createPluginRegistry, createPromptRegistry, createRuntimeLlm, setPluginRegistry, setPromptRegistry, ExtensionConfigError, getLogger, normalizePermissionMode, PluginLoader, resolveExecutionProfile, resolveExtensions, } from '../../core/facades/cli-command-chat.js';
 import { text } from '../locales/index.js';
+import { getOptionValueSourceWithGlobalFallback } from '../utils/command-option-source.js';
 import { resolveLlmOutputPolicyFromCli } from '../utils/llm-output.js';
 import { createOutcomeReporter } from '../utils/outcome-reporter.js';
 import { resolveCliConfig } from '../utils/resolve-cli-config.js';
@@ -40,7 +41,14 @@ export async function handleChatCommand(options, command) {
     setPluginRegistry(languagePlugins);
     setPromptRegistry(createPromptRegistry());
     await PluginLoader.loadPlugins(languagePlugins, runPath);
-    const rawPermissionMode = allOptions.mode ?? resolvedConfig.permissionMode ?? 'interactive';
+    const defaultFlowMode = 'autopilot';
+    const defaultFlowProfile = resolveExecutionProfile(defaultFlowMode);
+    const modeOptionSource = getOptionValueSourceWithGlobalFallback(command, 'mode');
+    const checkpointStrategyOptionSource = getOptionValueSourceWithGlobalFallback(command, 'checkpointStrategy');
+    const rawPermissionMode = (modeOptionSource === 'cli' ? allOptions.mode : undefined) ??
+        resolvedConfig.permissionMode ??
+        defaultFlowProfile.defaultPermissionMode ??
+        'interactive';
     const permissionMode = normalizePermissionMode(rawPermissionMode);
     if (!permissionMode) {
         getLogger().error(`Invalid --mode "${String(rawPermissionMode)}". Expected "interactive" or "yolo".`);
@@ -86,11 +94,10 @@ export async function handleChatCommand(options, command) {
             repoPath: runPath,
             llm,
             verifyCommand,
-            checkpointStrategy: permissionMode === 'yolo' &&
-                typeof command.getOptionValueSource === 'function' &&
-                command.getOptionValueSource('checkpointStrategy') !== 'cli'
-                ? 'direct'
-                : allOptions.checkpointStrategy || 'worktree',
+            defaultFlowMode,
+            checkpointStrategy: checkpointStrategyOptionSource === 'cli'
+                ? allOptions.checkpointStrategy || 'worktree'
+                : undefined,
             continue: continueSession,
             resumeSessionId,
             verbose: verboseLevel,

package/dist/cli/commands/flow-mode.js

@@ -0,0 +1,63 @@
+import { FLOW_MODES, parseFlowMode } from '../../core/types/flow-mode.js';
+import { text } from '../locales/index.js';
+import { parseSuggestionContext } from './utils.js';
+export const flowModeCommand = {
+    name: '/flow-mode',
+    description: text.cli.commandFlowMode,
+    order: 55,
+    getSuggestions: ({ input }) => {
+        const { argIndex, currentPrefix } = parseSuggestionContext(input);
+        if (argIndex !== 1)
+            return [];
+        const search = currentPrefix.toLowerCase();
+        return FLOW_MODES.filter((mode) => mode.startsWith(search)).map((mode) => ({
+            name: mode,
+            description: text.cli.flowModeSuggestion(mode),
+        }));
+    },
+    execute: async ({ emit, input, sessionManager }) => {
+        const args = input.trim().split(/\s+/).slice(1);
+        const rawValue = args[0];
+        if (!rawValue) {
+            const current = sessionManager.getChatFlowMode() ?? 'autopilot';
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.flowModeCurrent(current),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.flowModeUsage,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const normalized = parseFlowMode(rawValue);
+        if (!normalized) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: text.cli.flowModeInvalid(rawValue),
+                timestamp: new Date(),
+            });
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.flowModeUsage,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        sessionManager.updateChatFlowMode(normalized);
+        await sessionManager.save();
+        emit({
+            type: 'log',
+            level: 'info',
+            message: text.cli.flowModeUpdated(normalized),
+            timestamp: new Date(),
+        });
+    },
+};
+//# sourceMappingURL=flow-mode.js.map

package/dist/cli/commands/registry.js

@@ -2,6 +2,7 @@ import { text } from '../locales/index.js';
 import { allowlistCommand } from './allowlist.js';
 import { configCommand } from './config.js';
 import { exitCommand } from './exit.js';
+import { flowModeCommand } from './flow-mode.js';
 import { formatHelpRows } from './help-format.js';
 import { llmOutputCommand } from './llm-output.js';
 import { logModeCommand } from './log-mode.js';
@@ -21,6 +22,7 @@ const baseCommands = [
     allowlistCommand,
     modeCommand,
     logModeCommand,
+    flowModeCommand,
     configCommand,
     subAgentCommand,
     newCommand,

package/dist/cli/commands/run/benchmark-artifacts.js

@@ -0,0 +1,41 @@
+import { FileAdapter } from '../../../core/adapters/fs/file-adapter.js';
+import { buildBenchmarkPatchArtifact } from '../../../core/benchmark/patch-artifact.js';
+import { encodeSweBenchPredictionJsonl } from '../../../core/benchmark/swe-bench.js';
+export async function attachRunBenchmarkArtifacts(params) {
+    if (!params.exportPatchPath && !params.sweBenchPredictionsPath)
+        return;
+    const fileAdapter = new FileAdapter();
+    const artifact = await buildBenchmarkPatchArtifact({
+        repoPath: params.repoPath,
+        changedFilesHint: params.result.changedFiles,
+        excludePaths: [params.exportPatchPath, params.sweBenchPredictionsPath].filter((path) => typeof path === 'string'),
+    });
+    if (params.exportPatchPath) {
+        await fileAdapter.writeFile(params.exportPatchPath, artifact.patch);
+    }
+    params.result.benchmarkPatchArtifact = {
+        kind: 'git-unified-diff',
+        path: params.exportPatchPath,
+        sha256: artifact.sha256,
+        bytes: artifact.bytes,
+        changedFiles: artifact.changedFiles,
+        isEmpty: artifact.isEmpty,
+    };
+    if (params.sweBenchPredictionsPath) {
+        if (!params.sweBenchInstanceId || !params.sweBenchModelName) {
+            throw new Error('SWE-bench predictions require instance id and model name.');
+        }
+        await fileAdapter.appendFile(params.sweBenchPredictionsPath, encodeSweBenchPredictionJsonl({
+            instanceId: params.sweBenchInstanceId,
+            modelNameOrPath: params.sweBenchModelName,
+            modelPatch: artifact.patch,
+        }));
+        params.result.benchmarkArtifact = {
+            provider: 'swe-bench',
+            instanceId: params.sweBenchInstanceId,
+            modelNameOrPath: params.sweBenchModelName,
+            predictionsPath: params.sweBenchPredictionsPath,
+        };
+    }
+}
+//# sourceMappingURL=benchmark-artifacts.js.map

package/dist/cli/commands/run/early-errors.js

@@ -57,6 +57,7 @@ export function handleEarlyRunCommandErrors(params) {
                 instruction: params.instruction,
                 message: text.cli.outputProfileRequiresStreamJson,
                 exitCode: 1,
+                errorCode: 'USAGE_ERROR',
             });
         }
         return { ok: false, exitCode: 1 };
@@ -103,6 +104,28 @@ export function handleEarlyRunCommandErrors(params) {
         }
         return { ok: false, exitCode: 1 };
     }
+    if (params.sweBenchPredictionsPath && !params.sweBenchInstanceId) {
+        getLogger().error(text.cli.sweBenchInstanceRequired);
+        if (params.headlessOutput) {
+            params.headlessErrorWriter.writeUsageError({
+                sessionId: params.sessionIdForOutput ?? params.resumeSessionId,
+                message: text.cli.sweBenchInstanceRequired,
+                instruction: params.instruction,
+            });
+        }
+        return { ok: false, exitCode: 1 };
+    }
+    if (params.sweBenchPredictionsPath && !params.sweBenchModelName) {
+        getLogger().error(text.cli.sweBenchModelRequired);
+        if (params.headlessOutput) {
+            params.headlessErrorWriter.writeUsageError({
+                sessionId: params.sessionIdForOutput ?? params.resumeSessionId,
+                message: text.cli.sweBenchModelRequired,
+                instruction: params.instruction,
+            });
+        }
+        return { ok: false, exitCode: 1 };
+    }
     return { ok: true };
 }
 //# sourceMappingURL=early-errors.js.map