salmon-loop 0.2.13 → 0.3.0

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

@@ -1,12 +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 { 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';
@@ -58,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 ||
@@ -94,6 +99,9 @@ export async function handleRunCommand(options, command) {
         continueSession,
         resumeSessionId,
         jsonSchemaSpec,
+        sweBenchInstanceId,
+        sweBenchModelName,
+        sweBenchPredictionsPath,
         sessionIdForOutput,
         headlessErrorWriter,
     });
@@ -149,6 +157,7 @@ export async function handleRunCommand(options, command) {
         repoPath: runPath,
         validate: Boolean(allOptions.validate),
         useGui,
+        headlessOutput,
         preflightPolicy,
     });
     if (allOptions.validate && !instruction)
@@ -158,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(),
@@ -181,6 +191,7 @@ export async function handleRunCommand(options, command) {
         resolvedConfig,
         cliOptions: allOptions,
         outputFormat,
+        headlessOutput,
         writeJsonFailure: ({ message, repoPath }) => writeJsonFailure({ message, repoPath }),
     });
     if (!runtimeOptions.ok) {
@@ -205,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,
             });
         }
@@ -235,6 +276,8 @@ export async function handleRunCommand(options, command) {
         if (outputFormat === 'json') {
             writeJsonFailure({
                 message: text.cli.invalidEnvironmentMode(rawEnvironmentMode),
+                errorCode: 'USAGE_ERROR',
+                instruction,
                 repoPath: runPath,
             });
         }
@@ -258,8 +301,19 @@ 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 = commonOptions.options.verboseLevel;
     logRunVerboseSummary({
@@ -274,10 +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 { llm } = createRuntimeLlmAndWarn({
+        const { llm, headlessWarnings } = createRuntimeLlmAndWarn({
             llmConfig: resolvedConfig.llm,
             langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
+            headlessOutput,
         });
         let structuredOutputState = { ok: true, candidate: null };
         const reporter = createRunReporter({
@@ -289,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)
@@ -305,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,
@@ -320,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,
@@ -332,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,
@@ -360,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 });
@@ -384,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,
@@ -418,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,

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

@@ -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);

package/dist/cli/commands/run/runtime-llm.js

@@ -1,5 +1,32 @@
 import { createPhaseRoutingLlm, createRuntimeLlm, EXECUTION_PHASES, getLogger, Phase, } from '../../../core/facades/cli-run-runtime-llm.js';
 import { text } from '../../locales/index.js';
+function runtimeWarningMessage(code, params) {
+    if (code === 'API_KEY_MISSING')
+        return text.cli.apiKeyMissing;
+    if (code === 'PROVIDER_NOT_SUPPORTED') {
+        return text.cli.providerNotSupported(String(params.llmType));
+    }
+    if (code === 'CLIENT_PACKAGE_NOT_SUPPORTED') {
+        return text.cli.clientPackageNotSupported(String(params.clientPackage || ''));
+    }
+    return code;
+}
+function toHeadlessWarning(code, params) {
+    if (code === 'API_KEY_MISSING') {
+        return {
+            code: 'LLM_CREDENTIAL_MISSING',
+            message: 'LLM credential not configured; using StubLLM. Configure provider credentials to use a real LLM.',
+            source: 'llm.runtime',
+            severity: 'warning',
+        };
+    }
+    return {
+        code,
+        message: runtimeWarningMessage(code, params).replace(/^\[WARN\]\s*/, ''),
+        source: 'llm.runtime',
+        severity: 'warning',
+    };
+}
 export function createRuntimeLlmAndWarn(params) {
     const runtimeLlm = createRuntimeLlm(params.llmConfig, {
         langfuseEnabled: params.langfuseEnabled,
@@ -8,7 +35,7 @@ export function createRuntimeLlmAndWarn(params) {
     const phaseToProviderModel = params.llmConfig?.routing?.phaseToProviderModel;
     const phaseLlms = {};
     if (phaseToProviderModel && typeof phaseToProviderModel === 'object') {
-        const validPhases = new Set([...EXECUTION_PHASES, Phase.SLASH]);
+        const validPhases = new Set([...EXECUTION_PHASES, Phase.SLASH, Phase.AUTOPILOT]);
         for (const [phase, target] of Object.entries(phaseToProviderModel)) {
             if (!validPhases.has(phase))
                 continue;
@@ -29,6 +56,7 @@ export function createRuntimeLlmAndWarn(params) {
                     selectedModelId: target.model?.id,
                     selectedModelSlot: target.model?.slot || 'default',
                 },
+                capabilities: target.capabilities,
             };
             const created = createRuntimeLlm(perPhaseConfig, { langfuseEnabled: params.langfuseEnabled });
             warnings.push(...created.warnings);
@@ -40,17 +68,16 @@ export function createRuntimeLlmAndWarn(params) {
         : runtimeLlm.llm;
     const llmType = params.llmConfig?.type;
     const clientPackage = params.llmConfig?.clientPackage;
-    for (const w of Array.from(new Set(warnings))) {
-        if (w === 'API_KEY_MISSING') {
-            getLogger().warn(text.cli.apiKeyMissing);
-        }
-        else if (w === 'PROVIDER_NOT_SUPPORTED') {
-            getLogger().warn(text.cli.providerNotSupported(String(llmType)));
-        }
-        else if (w === 'CLIENT_PACKAGE_NOT_SUPPORTED') {
-            getLogger().warn(text.cli.clientPackageNotSupported(String(clientPackage || '')));
+    const uniqueWarnings = Array.from(new Set(warnings));
+    for (const w of uniqueWarnings) {
+        if (!params.headlessOutput) {
+            getLogger().warn(runtimeWarningMessage(w, { llmType, clientPackage }));
         }
     }
-    return { llm, warnings: Array.from(new Set(warnings)) };
+    return {
+        llm,
+        warnings: uniqueWarnings,
+        headlessWarnings: uniqueWarnings.map((w) => toHeadlessWarning(w, { llmType, clientPackage })),
+    };
 }
 //# sourceMappingURL=runtime-llm.js.map

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

@@ -23,8 +23,8 @@ export async function resolveRunRuntimeOptions(params) {
     if (wantPartialMessages && !llmOutput.kinds.includes('plan')) {
         llmOutput.kinds.push('plan');
     }
-    const effectiveVerify = await resolveVerifyOption(params.repoPath, params.cliOptions.verify, params.resolvedConfig.verify.command);
-    const effectiveWorktreePrepare = await resolveWorktreePrepareOption(params.repoPath, params.cliOptions.checkpointStrategy, params.cliOptions.worktreePrepare);
+    const effectiveVerify = await resolveVerifyOption(params.repoPath, params.cliOptions.verify, params.resolvedConfig.verify.command, { quiet: params.headlessOutput });
+    const effectiveWorktreePrepare = await resolveWorktreePrepareOption(params.repoPath, params.cliOptions.checkpointStrategy, params.cliOptions.worktreePrepare, { quiet: params.headlessOutput });
     return { ok: true, llmOutput, effectiveVerify, effectiveWorktreePrepare };
 }
 //# sourceMappingURL=runtime-options.js.map