salmon-loop 0.2.3 → 0.2.16

package/dist/cli/commands/run/config-resolution.js

@@ -1,37 +1,43 @@
-import { redactConfigForPrint, resolveConfig, ConfigError } from '../../../core/config/index.js';
+import { redactConfigForPrint } from '../../../core/config/index.js';
 import { getLogger } from '../../../core/facades/cli-observability.js';
-import { text } from '../../locales/index.js';
+import { resolveCliConfig } from '../../utils/resolve-cli-config.js';
 export async function resolveRunConfig(params) {
-    let resolvedConfig;
-    try {
-        resolvedConfig = await resolveConfig({
-            repoRoot: params.repoPath,
-            configFilePath: params.cliOptions.config,
-            enableConfigFile: params.cliOptions.configFile !== false,
-        });
-    }
-    catch (err) {
-        if (err instanceof ConfigError) {
-            const msg = text.config.error(err.code || err.message, err.details);
-            getLogger().error(msg);
-            if (params.outputFormat === 'json') {
-                params.writeJsonFailure({ message: msg, errorCode: err.code, repoPath: params.repoPath });
-            }
-            return { ok: false, exitCode: 1 };
-        }
-        const msg = err instanceof Error ? err.message : String(err);
-        getLogger().error(text.config.loadFailed(msg));
+    const resolved = await resolveCliConfig({
+        repoPath: params.repoPath,
+        configPath: params.cliOptions.config,
+        enableConfigFile: params.cliOptions.configFile !== false,
+        auditScope: params.cliOptions.auditScope,
+        verbose: params.cliOptions.verbose,
+        outputFormat: params.cliOptions.outputFormat,
+        logMode: params.cliOptions.logMode,
+    });
+    if (!resolved.ok) {
+        getLogger().error(resolved.message);
         if (params.outputFormat === 'json') {
-            params.writeJsonFailure({ message: text.config.loadFailed(msg), repoPath: params.repoPath });
+            params.writeJsonFailure({
+                message: resolved.message,
+                errorCode: resolved.errorCode,
+                repoPath: params.repoPath,
+            });
         }
         return { ok: false, exitCode: 1 };
     }
     if (params.cliOptions.printConfig) {
-        const raw = resolvedConfig.raw || { version: 1 };
+        const raw = resolved.resolvedConfig.raw || { version: 1 };
         const redacted = redactConfigForPrint(raw);
         process.stdout.write(JSON.stringify(redacted, null, 2) + '\n');
         return { ok: true, printedConfig: true };
     }
-    return { ok: true, resolvedConfig };
+    return {
+        ok: true,
+        resolvedConfig: {
+            repoPath: resolved.repoPath,
+            verboseLevel: resolved.verboseLevel,
+            outputFormat: resolved.outputFormat,
+            headlessOutput: resolved.headlessOutput,
+            resolvedConfig: resolved.resolvedConfig,
+            auditScope: resolved.auditScope,
+        },
+    };
 }
 //# sourceMappingURL=config-resolution.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

package/dist/cli/commands/run/handler.js

@@ -1,11 +1,13 @@
 import { randomUUID } from 'crypto';
-import { buildSessionConversationContext, createPluginRegistry, createPromptRegistry, getExitCode, getDefaultSessionContextBudgetTokens, getLogger, normalizePermissionMode, setPluginRegistry, setPromptRegistry, } from '../../../core/facades/cli-run-handler.js';
+import { buildEffectiveConversationContext, createPluginRegistry, createPromptRegistry, getExitCode, getDefaultSessionContextBudgetTokens, getLogger, normalizePermissionMode, resolveExecutionProfile, SilentReporter, setPluginRegistry, setPromptRegistry, } from '../../../core/facades/cli-run-handler.js';
 import { createStdoutWriter } from '../../headless/stdout-writer.js';
 import { text } from '../../locales/index.js';
-import { StderrLogReporter } from '../../reporters/stderr-log-reporter.js';
-import { resolveAuditScope } from '../../utils/audit-scope.js';
+import { getOptionValueSourceWithGlobalFallback } from '../../utils/command-option-source.js';
 import { createOutcomeReporter } from '../../utils/outcome-reporter.js';
+import { resolveOutputFormat } from '../../utils/output-format.js';
+import { resolveCliCommonOptions } from '../../utils/resolve-cli-config.js';
 import { buildRunAssistantMessage } from './assistant-message.js';
+import { attachRunBenchmarkArtifacts } from './benchmark-artifacts.js';
 import { resolveRunConfig } from './config-resolution.js';
 import { handleEarlyRunCommandErrors } from './early-errors.js';
 import { executeRunLoop } from './execute.js';
@@ -22,7 +24,7 @@ import { createRuntimeLlmAndWarn } from './runtime-llm.js';
 import { resolveRunRuntimeOptions } from './runtime-options.js';
 import { initializeSession } from './session.js';
 import { buildStructuredOutputState } from './structured-output.js';
-import { logRunVerboseSummary, resolveVerboseLevel } from './verbose.js';
+import { logRunVerboseSummary } from './verbose.js';
 export async function handleRunCommand(options, command) {
     const parsed = parseRunCommandOptions(command);
     const allOptions = parsed.allOptions;
@@ -36,13 +38,20 @@ export async function handleRunCommand(options, command) {
     const explicitInstruction = parsed.explicitInstruction;
     const jsonSchemaSpec = parsed.jsonSchemaSpec;
     const rawOutputFormat = parsed.rawOutputFormat;
-    if (rawOutputFormat !== 'text' &&
-        rawOutputFormat !== 'stream-json' &&
-        rawOutputFormat !== 'json') {
+    const commonOptions = resolveCliCommonOptions({
+        repoPath: runPath,
+        verbose: allOptions.verbose,
+        outputFormat: rawOutputFormat,
+    });
+    if (!commonOptions.ok) {
+        getLogger().error(commonOptions.message, true);
+        process.exit(1);
+    }
+    const outputFormat = commonOptions.options.outputFormat ?? resolveOutputFormat(rawOutputFormat);
+    if (!outputFormat) {
         getLogger().error(text.cli.invalidOutputFormat(rawOutputFormat), true);
         process.exit(1);
     }
-    const outputFormat = rawOutputFormat;
     const headlessOutput = outputFormat !== 'text';
     const rawOutputProfile = parsed.rawOutputProfile;
     const outputProfileForStreamJson = parsed.outputProfileForStreamJson;
@@ -50,12 +59,16 @@ export async function handleRunCommand(options, command) {
     const headlessIncludeToolOutput = parsed.headlessIncludeToolOutput;
     const headlessIncludeAuthorizationDecisions = parsed.headlessIncludeAuthorizationDecisions;
     const allowOutsideCacheRoot = parsed.allowOutsideCacheRoot;
+    const exportPatchPath = parsed.exportPatchPath;
+    const sweBenchInstanceId = parsed.sweBenchInstanceId;
+    const sweBenchModelName = parsed.sweBenchModelName;
+    const sweBenchPredictionsPath = parsed.sweBenchPredictionsPath;
     const stdoutWriter = createStdoutWriter();
     const instruction = parsed.instruction;
     const printMode = Boolean(printInstruction);
     const useGui = !headlessOutput && !printMode && allOptions.gui !== false && process.stdout.isTTY;
     if (headlessOutput) {
-        getLogger().setReporter(new StderrLogReporter());
+        getLogger().setReporter(new SilentReporter());
     }
     const wantSessionPersistence = !allOptions.printConfig &&
         (headlessOutput ||
@@ -86,6 +99,9 @@ export async function handleRunCommand(options, command) {
         continueSession,
         resumeSessionId,
         jsonSchemaSpec,
+        sweBenchInstanceId,
+        sweBenchModelName,
+        sweBenchPredictionsPath,
         sessionIdForOutput,
         headlessErrorWriter,
     });
@@ -141,6 +157,7 @@ export async function handleRunCommand(options, command) {
         repoPath: runPath,
         validate: Boolean(allOptions.validate),
         useGui,
+        headlessOutput,
         preflightPolicy,
     });
     if (allOptions.validate && !instruction)
@@ -150,6 +167,7 @@ export async function handleRunCommand(options, command) {
             exitCode: params.exitCode,
             message: params.message,
             errorCode: params.errorCode,
+            auditPath: params.auditPath,
             repoPath: params.repoPath,
             instruction: params.instruction,
             sessionId: sessionIdForOutput ?? randomUUID(),
@@ -167,12 +185,13 @@ export async function handleRunCommand(options, command) {
     }
     if ('printedConfig' in configResult)
         return;
-    const resolvedConfig = configResult.resolvedConfig;
+    const { resolvedConfig, auditScope } = configResult.resolvedConfig;
     const runtimeOptions = await resolveRunRuntimeOptions({
         repoPath: runPath,
         resolvedConfig,
         cliOptions: allOptions,
         outputFormat,
+        headlessOutput,
         writeJsonFailure: ({ message, repoPath }) => writeJsonFailure({ message, repoPath }),
     });
     if (!runtimeOptions.ok) {
@@ -197,24 +216,54 @@ export async function handleRunCommand(options, command) {
         return;
     }
     const instructionText = instruction;
-    const rawPermissionMode = allOptions.mode ?? resolvedConfig.permissionMode ?? 'interactive';
-    const permissionMode = normalizePermissionMode(rawPermissionMode);
-    if (!permissionMode) {
-        getLogger().error(`Invalid --mode "${String(rawPermissionMode)}". Expected "interactive" or "yolo".`);
+    const actModeOptionSource = typeof command.getOptionValueSource === 'function'
+        ? command.getOptionValueSource('actMode')
+        : undefined;
+    const rawActMode = actModeOptionSource === 'cli' ? allOptions.actMode : undefined;
+    const mode = resolveRunMode(rawActMode);
+    if (!mode) {
+        const invalidMode = String(rawActMode ?? allOptions.actMode);
+        getLogger().error(text.cli.invalidActMode(invalidMode));
+        if (outputFormat === 'json') {
+            writeJsonFailure({
+                message: text.cli.invalidActMode(invalidMode),
+                errorCode: 'USAGE_ERROR',
+                instruction,
+                repoPath: runPath,
+            });
+        }
+        else if (outputFormat === 'stream-json') {
+            headlessErrorWriter.writeUsageError({
+                sessionId: sessionIdForOutput ?? randomUUID(),
+                message: text.cli.invalidActMode(invalidMode),
+                instruction,
+            });
+        }
         process.exitCode = 1;
         return;
     }
-    const rawMode = String(allOptions.actMode || 'patch');
-    const mode = resolveRunMode(rawMode);
-    if (!mode) {
-        getLogger().error(text.cli.invalidActMode(rawMode));
+    const profile = resolveExecutionProfile(mode);
+    const permissionModeOptionSource = getOptionValueSourceWithGlobalFallback(command, 'mode');
+    const rawPermissionMode = (permissionModeOptionSource === 'cli' ? allOptions.mode : undefined) ??
+        resolvedConfig.permissionMode ??
+        profile.defaultPermissionMode ??
+        'interactive';
+    const permissionMode = normalizePermissionMode(rawPermissionMode);
+    if (!permissionMode) {
+        const message = `Invalid --mode "${String(rawPermissionMode)}". Expected "interactive" or "yolo".`;
+        getLogger().error(message);
         if (outputFormat === 'json') {
-            writeJsonFailure({ message: text.cli.invalidActMode(rawMode), repoPath: runPath });
+            writeJsonFailure({
+                message,
+                errorCode: 'USAGE_ERROR',
+                instruction,
+                repoPath: runPath,
+            });
         }
         else if (outputFormat === 'stream-json') {
             headlessErrorWriter.writeUsageError({
                 sessionId: sessionIdForOutput ?? randomUUID(),
-                message: text.cli.invalidActMode(rawMode),
+                message,
                 instruction,
             });
         }
@@ -227,6 +276,8 @@ export async function handleRunCommand(options, command) {
         if (outputFormat === 'json') {
             writeJsonFailure({
                 message: text.cli.invalidEnvironmentMode(rawEnvironmentMode),
+                errorCode: 'USAGE_ERROR',
+                instruction,
                 repoPath: runPath,
             });
         }
@@ -250,10 +301,21 @@ export async function handleRunCommand(options, command) {
         return;
     }
     const extensionResolution = extensionsResult.extensionResolution;
+    const operationalHeadlessWarnings = [];
     if (!effectiveVerify) {
-        getLogger().warn(text.verify.noCommandFound);
+        if (!headlessOutput) {
+            getLogger().warn(text.verify.noCommandFound);
+        }
+        else {
+            operationalHeadlessWarnings.push({
+                code: 'VERIFY_COMMAND_MISSING',
+                message: text.verify.noCommandFound,
+                source: 'verify.runtime',
+                severity: 'warning',
+            });
+        }
     }
-    const verboseLevel = resolveVerboseLevel(allOptions.verbose);
+    const verboseLevel = commonOptions.options.verboseLevel;
     logRunVerboseSummary({
         verboseLevel,
         instruction: instructionText,
@@ -266,19 +328,14 @@ export async function handleRunCommand(options, command) {
         dryRun: allOptions.dryRun,
         configPath: resolvedConfig.source.used ? resolvedConfig.source.path || '' : undefined,
     });
+    let lastKnownAuditPath;
+    let activeReporter;
+    let activeReporterStarted = false;
     try {
-        const auditScopeResolution = resolveAuditScope({
-            cliValue: allOptions.auditScope,
-            configValue: resolvedConfig.observability.audit.scope,
-        });
-        if (!auditScopeResolution.ok) {
-            getLogger().error(text.cli.invalidAuditScope(auditScopeResolution.invalid), true);
-            process.exit(1);
-        }
-        const auditScope = auditScopeResolution.value;
-        const { llm } = createRuntimeLlmAndWarn({
+        const { llm, headlessWarnings } = createRuntimeLlmAndWarn({
             llmConfig: resolvedConfig.llm,
             langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
+            headlessOutput,
         });
         let structuredOutputState = { ok: true, candidate: null };
         const reporter = createRunReporter({
@@ -290,6 +347,7 @@ export async function handleRunCommand(options, command) {
             writer: stdoutWriter,
             verbose: Boolean(allOptions.verbose),
             model: resolvedConfig.llm.models?.selectedModelId,
+            includeToolInput: headlessIncludeToolInput,
             getStructuredOutput: () => structuredOutputState.ok ? structuredOutputState.candidate : null,
             getPayloadOverrides: () => {
                 if (structuredOutputState.ok)
@@ -306,8 +364,11 @@ export async function handleRunCommand(options, command) {
                     structuredOutputError: structuredOutputState.errorReason,
                 };
             },
+            getWarnings: () => [...headlessWarnings, ...operationalHeadlessWarnings],
         });
+        activeReporter = reporter;
         reporter.onStart(instructionText);
+        activeReporterStarted = true;
         const applyBackOnDirty = allOptions.applyBackOnDirty === 'abort' ? 'abort' : '3way';
         const outcomeReporter = createOutcomeReporter({
             enabled: resolvedConfig.observability.langfuse.outcome,
@@ -321,11 +382,18 @@ export async function handleRunCommand(options, command) {
             process.env.S8P_MODEL;
         const shouldInjectSessionContext = Boolean(continueSession || resumeSessionId);
         const conversationContext = shouldInjectSessionContext && sessionManager
-            ? buildSessionConversationContext(sessionManager.getMessages(), {
+            ? buildEffectiveConversationContext({
+                llm,
+                sessionManager,
                 budgetTokens: getDefaultSessionContextBudgetTokens({ modelId: modelIdForBudget }),
-                summaryState: sessionManager.getSummaryState(),
             })
             : [];
+        const artifactHints = shouldInjectSessionContext
+            ? sessionManager?.getArtifactState()
+            : undefined;
+        const replacementState = shouldInjectSessionContext
+            ? sessionManager?.getReplacementState()
+            : undefined;
         const loopParams = buildRunLoopParams({
             instruction: instructionText,
             verify: effectiveVerify,
@@ -333,17 +401,18 @@ export async function handleRunCommand(options, command) {
             llm,
             languagePlugins,
             conversationContext: conversationContext.length > 0 ? conversationContext : undefined,
+            artifactHints,
+            replacementState,
             mode,
             dryRun: allOptions.dryRun,
             forceReset: allOptions.forceReset,
             file: allOptions.file,
             selection: allOptions.selection,
             verbose: verboseLevel,
-            checkpointStrategy: permissionMode === 'yolo' &&
-                typeof command.getOptionValueSource === 'function' &&
-                command.getOptionValueSource('checkpointStrategy') !== 'cli'
-                ? 'direct'
-                : allOptions.checkpointStrategy,
+            checkpointStrategy: getOptionValueSourceWithGlobalFallback(command, 'checkpointStrategy') === 'cli'
+                ? allOptions.checkpointStrategy
+                : (profile.defaultCheckpointStrategy ??
+                    allOptions.checkpointStrategy),
             environmentMode: rawEnvironmentMode,
             applyBackOnDirty,
             worktreePrepare: effectiveWorktreePrepare,
@@ -361,11 +430,9 @@ export async function handleRunCommand(options, command) {
             headlessIncludeToolOutput,
             headlessIncludeAuthorizationDecisions,
             allowOutsideCacheRoot,
-            permissionRules: permissionMode === 'yolo'
-                ? undefined
-                : allowedToolRules.length > 0 || disallowedToolRules.length > 0
-                    ? { allow: allowedToolRules, deny: disallowedToolRules }
-                    : undefined,
+            permissionRules: allowedToolRules.length > 0 || disallowedToolRules.length > 0
+                ? { allow: allowedToolRules, deny: disallowedToolRules }
+                : undefined,
             permissionMode,
         });
         const buildAssistantMessage = (result) => buildRunAssistantMessage({ mode, result });
@@ -385,6 +452,15 @@ export async function handleRunCommand(options, command) {
                 logMode: resolvedConfig.ui.logMode,
             },
         });
+        lastKnownAuditPath = result.auditPath;
+        await attachRunBenchmarkArtifacts({
+            result,
+            repoPath: runPath,
+            exportPatchPath,
+            sweBenchInstanceId,
+            sweBenchModelName,
+            sweBenchPredictionsPath,
+        });
         structuredOutputState = await buildStructuredOutputState({
             outputFormat,
             jsonSchemaSpec,
@@ -419,12 +495,23 @@ export async function handleRunCommand(options, command) {
                 message: text.cli.unexpectedError(msg),
                 repoPath: runPath,
                 instruction,
+                auditPath: lastKnownAuditPath,
             });
         }
+        else if (outputFormat === 'stream-json' &&
+            rawOutputProfile !== 'anthropic' &&
+            rawOutputProfile !== 'openai' &&
+            activeReporterStarted &&
+            activeReporter) {
+            const error = new Error(text.cli.unexpectedError(msg));
+            error.auditPath = lastKnownAuditPath;
+            activeReporter.onError(error);
+        }
         else if (outputFormat === 'stream-json') {
             headlessErrorWriter.writeUnexpectedError({
                 sessionId: sessionIdForOutput ?? resumeSessionId ?? randomUUID(),
                 message: text.cli.unexpectedError(msg),
+                auditPath: lastKnownAuditPath,
             });
         }
         process.exitCode = 1;

package/dist/cli/commands/run/headless-error-writer.js

@@ -6,6 +6,7 @@ import { OpenAiStreamEncoder } from '../../headless/openai-stream-encoder.js';
 import { encodeStreamEnd, encodeStreamFailure, encodeStreamStart, } from '../../headless/stream-json-protocol.js';
 function writeStreamJsonEarlyFailure(params) {
     const at = new Date();
+    let eventSeq = 0;
     params.writer.writeJsonLine(encodeStreamStart({
         uuid: randomUUID(),
         mode: 'run',
@@ -13,12 +14,15 @@ function writeStreamJsonEarlyFailure(params) {
         sessionId: params.sessionId,
         instruction: params.instruction,
         at,
+        eventSeq: eventSeq++,
     }));
     params.writer.writeJsonLine(encodeStreamFailure({
         uuid: randomUUID(),
         sessionId: params.sessionId,
         at,
         message: params.message,
+        auditPath: params.auditPath,
+        eventSeq: eventSeq++,
     }));
     params.writer.writeJsonLine(encodeStreamEnd({
         uuid: randomUUID(),
@@ -26,6 +30,7 @@ function writeStreamJsonEarlyFailure(params) {
         at,
         success: false,
         exitCode: params.exitCode ?? 1,
+        eventSeq: eventSeq++,
     }));
 }
 function writeAnthropicEarlyFailure(params) {
@@ -84,6 +89,7 @@ export function createHeadlessErrorWriter(ctx) {
             instruction: params.instruction,
             message: params.message,
             errorCode: params.errorCode,
+            auditPath: params.auditPath,
             exitCode: params.exitCode ?? 1,
         }));
     };
@@ -137,6 +143,7 @@ export function createHeadlessErrorWriter(ctx) {
                 message: params.message,
                 repoPath: ctx.repoPath,
                 instruction: params.instruction,
+                auditPath: params.auditPath,
                 sessionId,
             });
             return;
@@ -163,6 +170,7 @@ export function createHeadlessErrorWriter(ctx) {
                     repoPath: ctx.repoPath,
                     sessionId,
                     message: params.message,
+                    auditPath: params.auditPath,
                     instruction: params.instruction,
                 });
             }

package/dist/cli/commands/run/loop-params.js

@@ -6,6 +6,8 @@ export function buildRunLoopParams(params) {
         repoPath: params.repoPath,
         llm: params.llm,
         conversationContext: params.conversationContext,
+        artifactHints: params.artifactHints,
+        replacementState: params.replacementState,
         mode: params.mode,
         dryRun: params.dryRun,
         forceReset: params.forceReset,
@@ -30,6 +32,7 @@ export function buildRunLoopParams(params) {
             forceNonInteractive: params.headlessOutput || params.printMode,
             permissionMode: params.permissionMode,
         }),
+        permissionMode: params.permissionMode,
         extensions: params.extensions,
         permissionRules: params.permissionRules,
         eventPayload: params.headlessIncludeToolInput ||

package/dist/cli/commands/run/mode.js

@@ -1,8 +1,5 @@
+import { parseFlowMode } from '../../../core/types/flow-mode.js';
 export function resolveRunMode(raw) {
-    const value = String(raw || 'patch');
-    if (value === 'patch' || value === 'review' || value === 'debug' || value === 'research') {
-        return value;
-    }
-    return undefined;
+    return parseFlowMode(raw || 'autopilot');
 }
 //# sourceMappingURL=mode.js.map

package/dist/cli/commands/run/parse-options.js

@@ -1,4 +1,4 @@
-import { resolve } from 'path';
+import { resolveRepoPath } from '../../utils/resolve-cli-config.js';
 function splitToolRules(raw) {
     const parts = [];
     const push = (s) => {
@@ -20,7 +20,7 @@ function splitToolRules(raw) {
 }
 export function parseRunCommandOptions(command) {
     const allOptions = command.optsWithGlobals();
-    const repoPath = resolve(allOptions.repo || process.cwd());
+    const repoPath = resolveRepoPath({ repo: allOptions.repo, cwd: process.cwd() });
     const continueSession = Boolean(allOptions.continue);
     const resumeSessionId = typeof allOptions.resume === 'string'
         ? allOptions.resume
@@ -41,6 +41,18 @@ export function parseRunCommandOptions(command) {
     const headlessIncludeToolOutput = Boolean(allOptions.headlessIncludeToolOutput);
     const headlessIncludeAuthorizationDecisions = Boolean(allOptions.headlessIncludeAuthorizationDecisions);
     const allowOutsideCacheRoot = Boolean(allOptions.allowOutsideCacheRoot);
+    const exportPatchPath = typeof allOptions.exportPatch === 'string'
+        ? allOptions.exportPatch
+        : undefined;
+    const sweBenchInstanceId = typeof allOptions.sweBenchInstanceId === 'string'
+        ? allOptions.sweBenchInstanceId
+        : undefined;
+    const sweBenchModelName = typeof allOptions.sweBenchModelName === 'string'
+        ? allOptions.sweBenchModelName
+        : undefined;
+    const sweBenchPredictionsPath = typeof allOptions.sweBenchPredictions === 'string'
+        ? allOptions.sweBenchPredictions
+        : undefined;
     const instruction = explicitInstruction ?? printInstruction;
     const allowedToolRules = splitToolRules(allOptions.allowedTools);
     const disallowedToolRules = splitToolRules(allOptions.disallowedTools);
@@ -60,6 +72,10 @@ export function parseRunCommandOptions(command) {
         headlessIncludeToolOutput,
         headlessIncludeAuthorizationDecisions,
         allowOutsideCacheRoot,
+        exportPatchPath,
+        sweBenchInstanceId,
+        sweBenchModelName,
+        sweBenchPredictionsPath,
         allowedToolRules,
         disallowedToolRules,
     };

package/dist/cli/commands/run/persist-session.js

@@ -1,4 +1,4 @@
-import { refreshSessionSummary, } from '../../../core/facades/cli-run-persist-session.js';
+import { buildSessionArtifactStateFromLoopResult, refreshSessionSummary, } from '../../../core/facades/cli-run-persist-session.js';
 export async function persistRunSession(params) {
     if (!params.sessionManager || typeof params.instruction !== 'string')
         return;
@@ -20,6 +20,15 @@ export async function persistRunSession(params) {
                 iterationId,
             });
         }
+        params.sessionManager.mergeArtifactState(buildSessionArtifactStateFromLoopResult(params.result));
+        for (const preview of params.result.artifactHints?.toolResultPreviewArtifacts ?? []) {
+            params.sessionManager.freezeReplacementDecision({
+                toolResultId: `${preview.label}::${preview.artifact.handle}`,
+                decision: 'replaced',
+                preview: preview.label,
+                sourceArtifactHandle: preview.artifact.handle,
+            });
+        }
         await refreshSessionSummary({
             sessionManager: params.sessionManager,
             llm: params.llm,

package/dist/cli/commands/run/preflight.js

@@ -46,10 +46,18 @@ function buildFailureMessage(details) {
 }
 async function runValidateCommand(params) {
     const maxBytesPerStream = 500_000;
+    const env = params.headlessOutput
+        ? {
+            ...process.env,
+            NO_COLOR: process.env.NO_COLOR ?? '1',
+            FORCE_COLOR: '0',
+        }
+        : process.env;
     const result = await spawnCommand({
         command: params.cmd,
         args: params.args,
         cwd: params.repoPath,
+        env,
         windowsHide: true,
         maxStdoutBytes: maxBytesPerStream,
         maxStderrBytes: maxBytesPerStream,
@@ -101,6 +109,7 @@ export async function runPreflight(params) {
                     cmd: lintCommand.command,
                     args: lintCommand.args,
                     useGui: params.useGui,
+                    headlessOutput: params.headlessOutput,
                 });
             }
             catch (error) {
@@ -126,6 +135,7 @@ export async function runPreflight(params) {
                     cmd: testCommand.command,
                     args: testCommand.args,
                     useGui: params.useGui,
+                    headlessOutput: params.headlessOutput,
                 });
             }
             catch (error) {

package/dist/cli/commands/run/reporter-factory.js

@@ -22,6 +22,7 @@ export function createRunReporter(params) {
                 repoPath: params.repoPath,
                 sessionId: params.sessionIdForOutput,
                 writer: params.writer,
+                includeToolInput: params.includeToolInput,
             });
         }
         if (profile === 'openai') {
@@ -35,6 +36,8 @@ export function createRunReporter(params) {
             repoPath: params.repoPath,
             sessionId: params.sessionIdForOutput,
             writer: params.writer,
+            getWarnings: params.getWarnings,
+            includeToolInput: params.includeToolInput,
         });
     }
     if (params.outputFormat === 'json') {
@@ -45,6 +48,7 @@ export function createRunReporter(params) {
             writer: params.writer,
             getStructuredOutput: params.getStructuredOutput,
             getPayloadOverrides: params.getPayloadOverrides,
+            getWarnings: params.getWarnings,
         });
     }
     return new StandardReporter(params.verbose);