salmon-loop 0.2.3 → 0.2.16

package/dist/cli/headless/anthropic-stream-normalized-encoder.js

@@ -1,4 +1,9 @@
 import { encodeAnthropicStreamEvent, } from './anthropic-stream-protocol.js';
+function asToolInput(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
 export function encodeNormalizedToAnthropicStreamLines(params) {
     if (params.event.type === 'normalized.message_start') {
         return [
@@ -64,7 +69,7 @@ export function encodeNormalizedToAnthropicStreamLines(params) {
     }
     if (params.event.type === 'normalized.tool_request_start') {
         const parentToolUseId = params.event.callId;
-        const input = {};
+        const input = params.includeToolInput ? asToolInput(params.event.input) : {};
         return [
             encodeAnthropicStreamEvent({
                 sessionId: params.sessionId,

package/dist/cli/headless/json-protocol.js

@@ -1,3 +1,4 @@
+import { HEADLESS_SCHEMA_VERSION, normalizeHeadlessWarnings, } from './protocol-metadata.js';
 function toExitCode(result) {
     if (result.reason === 'Operation cancelled by user')
         return 130;
@@ -31,6 +32,30 @@ function toAuthorizationDecisions(result) {
         timestamp: d.timestamp,
     }));
 }
+function toPatchArtifact(result) {
+    const artifact = result.benchmarkPatchArtifact;
+    if (!artifact)
+        return undefined;
+    return {
+        kind: artifact.kind,
+        path: artifact.path,
+        sha256: artifact.sha256,
+        bytes: artifact.bytes,
+        changed_files: artifact.changedFiles,
+        is_empty: artifact.isEmpty,
+    };
+}
+function toBenchmarkArtifact(result) {
+    const artifact = result.benchmarkArtifact;
+    if (!artifact)
+        return undefined;
+    return {
+        provider: artifact.provider,
+        instance_id: artifact.instanceId,
+        model_name_or_path: artifact.modelNameOrPath,
+        predictions_path: artifact.predictionsPath,
+    };
+}
 export function encodeJsonResult(params) {
     const overrides = params.overrides;
     const exitCode = overrides?.exitCode ?? toExitCode(params.loopResult);
@@ -41,11 +66,13 @@ export function encodeJsonResult(params) {
     const reason = overrides?.reason ?? safeHint;
     const reasonCode = overrides?.reasonCode ?? params.loopResult.reasonCode;
     const errorCode = overrides?.errorCode ?? params.loopResult.errorCode;
+    const warnings = normalizeHeadlessWarnings(params.warnings);
     return {
         result: params.resultText,
         structured_output: params.structuredOutput,
         session_id: params.sessionId,
         metadata: {
+            schema_version: HEADLESS_SCHEMA_VERSION,
             command: params.mode,
             repo_path: params.repoPath,
             instruction: params.instruction,
@@ -58,12 +85,15 @@ export function encodeJsonResult(params) {
             remediation_steps: remediationSteps,
             attempts: params.loopResult.attempts,
             changed_files: params.loopResult.changedFiles ?? [],
+            patch_artifact: toPatchArtifact(params.loopResult),
+            benchmark_artifact: toBenchmarkArtifact(params.loopResult),
             audit_path: params.loopResult.auditPath,
             error_code: errorCode,
             authorization_summary: params.loopResult.authorizationSummary,
             usage: toUsage(params.loopResult),
             authorization_decisions: toAuthorizationDecisions(params.loopResult),
             structured_output_error: overrides?.structuredOutputError,
+            warnings,
             timestamps: {
                 started_at: params.startedAt.toISOString(),
                 ended_at: params.endedAt.toISOString(),
@@ -79,11 +109,13 @@ export function encodeJsonResult(params) {
 export function encodeJsonFailure(params) {
     const at = params.at ?? new Date();
     const exitCode = params.exitCode ?? 1;
+    const warnings = normalizeHeadlessWarnings(params.warnings);
     return {
         result: '',
         structured_output: null,
         session_id: params.sessionId,
         metadata: {
+            schema_version: HEADLESS_SCHEMA_VERSION,
             command: params.mode,
             repo_path: params.repoPath,
             instruction: params.instruction,
@@ -91,6 +123,8 @@ export function encodeJsonFailure(params) {
             exit_code: exitCode,
             reason: params.message,
             error_code: params.errorCode,
+            audit_path: params.auditPath,
+            warnings,
             timestamps: {
                 started_at: at.toISOString(),
                 ended_at: at.toISOString(),
@@ -99,11 +133,13 @@ export function encodeJsonFailure(params) {
     };
 }
 export function encodeJsonCrash(params) {
+    const warnings = normalizeHeadlessWarnings(params.warnings);
     return {
         result: '',
         structured_output: null,
         session_id: params.sessionId,
         metadata: {
+            schema_version: HEADLESS_SCHEMA_VERSION,
             command: params.mode,
             repo_path: params.repoPath,
             instruction: params.instruction,
@@ -114,6 +150,7 @@ export function encodeJsonCrash(params) {
                 message: params.error.message,
                 stack: params.error.stack,
             },
+            warnings,
             timestamps: {
                 started_at: params.startedAt.toISOString(),
                 ended_at: params.endedAt.toISOString(),

package/dist/cli/headless/native-stream-normalized-encoder.js

@@ -1,4 +1,9 @@
 import { encodeStreamEvent, encodeStreamFailure, } from './stream-json-protocol.js';
+function asToolInput(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
 export function encodeNormalizedToNativeStreamLines(params) {
     const at = params.event.timestamp;
     if (params.event.type === 'normalized.message_start') {
@@ -75,7 +80,7 @@ export function encodeNormalizedToNativeStreamLines(params) {
         const parentToolUseId = params.event.callId;
         const phase = params.event.phase;
         const round = params.event.round;
-        const input = {};
+        const input = params.includeToolInput ? asToolInput(params.event.input) : {};
         return [
             encodeStreamEvent({
                 uuid: params.uuid(),

package/dist/cli/headless/protocol-metadata.js

@@ -0,0 +1,22 @@
+export const HEADLESS_SCHEMA_VERSION = 1;
+export const HEADLESS_NATIVE_STREAM_PROTOCOL_VERSION = 1;
+export function normalizeHeadlessWarnings(warnings) {
+    if (!warnings?.length)
+        return [];
+    const seen = new Set();
+    const normalized = [];
+    for (const warning of warnings) {
+        const key = `${warning.source}:${warning.code}:${warning.message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        normalized.push({
+            code: warning.code,
+            message: warning.message,
+            source: warning.source,
+            severity: warning.severity,
+        });
+    }
+    return normalized;
+}
+//# sourceMappingURL=protocol-metadata.js.map

package/dist/cli/headless/stream-json-protocol.js

@@ -1,4 +1,5 @@
 import { getExitCode } from '../../core/facades/cli-headless.js';
+import { HEADLESS_NATIVE_STREAM_PROTOCOL_VERSION, normalizeHeadlessWarnings, } from './protocol-metadata.js';
 function toIso(date) {
     return date.toISOString();
 }
@@ -27,6 +28,8 @@ function encodeEnvelope(params) {
     return dropUndefined({
         uuid: params.uuid,
         session_id: params.sessionId,
+        protocol_version: HEADLESS_NATIVE_STREAM_PROTOCOL_VERSION,
+        event_seq: params.eventSeq,
         event: params.event,
         parent_tool_use_id: params.parentToolUseId,
     });
@@ -42,6 +45,7 @@ export function encodeStreamStart(params) {
             repo_path: params.repoPath,
             instruction: params.instruction,
         }),
+        eventSeq: params.eventSeq,
     });
 }
 export function encodeStreamEvent(params) {
@@ -53,6 +57,7 @@ export function encodeStreamEvent(params) {
             ...params.event,
             timestamp: toIso(params.at),
         }),
+        eventSeq: params.eventSeq,
     });
 }
 export function encodeStreamLoopEvent(params) {
@@ -65,10 +70,30 @@ export function encodeStreamLoopEvent(params) {
             ...mapLoopEventToJson(params.event),
             timestamp: toIso(params.event.timestamp),
         }),
+        eventSeq: params.eventSeq,
     });
 }
 export function encodeStreamResult(params) {
     const exitCode = getStreamExitCode(params.loopResult);
+    const warnings = normalizeHeadlessWarnings(params.warnings);
+    const patchArtifact = params.loopResult.benchmarkPatchArtifact
+        ? {
+            kind: params.loopResult.benchmarkPatchArtifact.kind,
+            path: params.loopResult.benchmarkPatchArtifact.path,
+            sha256: params.loopResult.benchmarkPatchArtifact.sha256,
+            bytes: params.loopResult.benchmarkPatchArtifact.bytes,
+            changed_files: params.loopResult.benchmarkPatchArtifact.changedFiles,
+            is_empty: params.loopResult.benchmarkPatchArtifact.isEmpty,
+        }
+        : undefined;
+    const benchmarkArtifact = params.loopResult.benchmarkArtifact
+        ? {
+            provider: params.loopResult.benchmarkArtifact.provider,
+            instance_id: params.loopResult.benchmarkArtifact.instanceId,
+            model_name_or_path: params.loopResult.benchmarkArtifact.modelNameOrPath,
+            predictions_path: params.loopResult.benchmarkArtifact.predictionsPath,
+        }
+        : undefined;
     return encodeEnvelope({
         uuid: params.uuid,
         sessionId: params.sessionId,
@@ -83,17 +108,21 @@ export function encodeStreamResult(params) {
             safe_hint: params.loopResult.safeHint ?? params.loopResult.reason,
             remediation_steps: params.loopResult.remediationSteps ?? [],
             attempts: params.loopResult.attempts,
-            changed_files: params.loopResult.changedFiles,
+            changed_files: params.loopResult.changedFiles ?? [],
+            patch_artifact: patchArtifact,
+            benchmark_artifact: benchmarkArtifact,
             audit_path: params.loopResult.auditPath,
             error_code: params.loopResult.errorCode,
             authorization_summary: params.loopResult.authorizationSummary,
             result: params.resultText,
+            warnings,
             run_end: {
                 success: Boolean(params.loopResult.success),
                 exit_code: exitCode,
                 timestamp: toIso(params.at),
             },
         }),
+        eventSeq: params.eventSeq,
     });
 }
 export function encodeStreamFailure(params) {
@@ -103,12 +132,14 @@ export function encodeStreamFailure(params) {
         event: {
             type: 'error',
             timestamp: toIso(params.at),
+            audit_path: params.auditPath,
             error: dropUndefined({
                 name: params.name,
                 message: params.message,
                 stack: params.stack,
             }),
         },
+        eventSeq: params.eventSeq,
     });
 }
 export function encodeStreamCrash(params) {
@@ -119,6 +150,7 @@ export function encodeStreamCrash(params) {
         message: params.error.message,
         name: params.error.name,
         stack: params.error.stack,
+        eventSeq: params.eventSeq,
     });
 }
 export function encodeStreamEnd(params) {
@@ -131,6 +163,7 @@ export function encodeStreamEnd(params) {
             success: params.success,
             exit_code: params.exitCode,
         },
+        eventSeq: params.eventSeq,
     });
 }
 //# sourceMappingURL=stream-json-protocol.js.map

package/dist/cli/index.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env bun
-// 1. MUST be the very first lines to force all chalk instances (even in node_modules)
-// to use color support before they complete initialization.
-process.env.FORCE_COLOR = '3';
+import { detectHeadlessOutputFromArgv, shouldForceColorForArgv, } from './argv/headless-detection.js';
+const headlessOutput = Boolean(detectHeadlessOutputFromArgv(process.argv).outputFormat);
+if (!headlessOutput && shouldForceColorForArgv(process.argv)) {
+    process.env.FORCE_COLOR = '3';
+}
 import 'dotenv/config';
-import { runCli } from './run-cli.js';
+const { runCli } = await import('./run-cli.js');
 await runCli(process.argv);
 //# sourceMappingURL=index.js.map

package/dist/cli/locales/en.js

@@ -3,7 +3,7 @@ export const en = {
     programDescription: 'A minimal viable loop for automated code patching',
     runDescription: 'Run the salmon-loop',
     contextDescription: 'Build and print the context prompt (no LLM call)',
-    serveDescription: 'Start the A2A + sidecar server',
+    serveDescription: 'Start the A2A server and ACP stdio bridge',
     serveAcpDescription: 'Start the agent-client-protocol (ACP) stdio server only',
     noColorOption: 'Disable colored output in logs',
     // Chat mode
@@ -35,6 +35,7 @@ export const en = {
     chatAnswerEmpty: 'No answer produced.',
     unknownCommand: (cmd) => `Unknown command: ${cmd}. Type /help for available commands.`,
     helpAvailableCommands: (rows) => `Available Commands:\n${rows}`,
+    programHelpFooter: '\nTips:\n  Use "s8p <command> --help" to see command-specific options.\n  In chat, type /help to list slash commands.',
     slashHandlerUnavailable: 'Command handler unavailable',
     slashInternalError: 'Internal error',
     skillNoPrompt: (id) => `Skill ${id} did not produce a prompt`,
@@ -73,6 +74,7 @@ export const en = {
     commandLlmOutput: 'Set which LLM sections are shown in the UI (advanced)',
     commandMode: 'Set permission mode (interactive|yolo) and save to config',
     commandLogMode: 'Set UI verbosity (quiet|normal|debug) and save to config',
+    commandFlowMode: 'Set the current chat flow mode for this session',
     commandConfig: 'Settings hub (mode, log-mode, view, output, allowlist)',
     commandAuth: 'Manage tool allowlist',
     commandParallel: 'Manage parallel plans',
@@ -119,6 +121,25 @@ export const en = {
     modeUpdated: (mode) => `Permission mode updated: ${mode}`,
     modePersisted: (path) => `Permission mode saved to ${path}`,
     modePersistFailed: (error) => `Failed to save permission mode: ${error}`,
+    flowModeUsage: 'Usage: /flow-mode <patch|review|debug|research|answer|autopilot>',
+    flowModeSuggestion: (mode) => {
+        if (mode === 'patch')
+            return 'Patch code and run verification';
+        if (mode === 'review')
+            return 'Analyze code without modifying files';
+        if (mode === 'debug')
+            return 'Investigate issues, then patch and verify';
+        if (mode === 'research')
+            return 'Research the codebase and summarize findings';
+        if (mode === 'answer')
+            return 'Answer directly without modifying files';
+        if (mode === 'autopilot')
+            return 'Let SalmonLoop choose the appropriate flow';
+        return `Set flow mode to ${mode}`;
+    },
+    flowModeCurrent: (mode) => `Current chat flow mode: ${mode}`,
+    flowModeInvalid: (mode) => `Invalid flow mode: ${mode}. Expected one of: patch, review, debug, research, answer, autopilot.`,
+    flowModeUpdated: (mode) => `Chat flow mode updated: ${mode}`,
     logModeUsage: 'Usage: /log-mode <quiet|normal|debug>',
     logModeSuggestion: (mode) => {
         if (mode === 'quiet')
@@ -158,11 +179,9 @@ export const en = {
     a2aPortOption: 'A2A listen port (default: 7431)',
     a2aTokenOption: 'Bearer token for A2A auth (repeatable)',
     acpStdioDisableOption: 'Disable agent-client-protocol (ACP) stdio server',
-    sidecarSocketOption: 'UDS path for the sidecar UI server',
-    sidecarAllowConditionalOption: 'Expose conditional sidecar routes (use with care)',
     acpStdioStarted: (port) => `ACP (agent-client-protocol) stdio enabled; port ${port}`,
     invalidA2APort: (value) => `Invalid A2A port: ${value}`,
-    serveStarted: (host, port, socket) => `A2A listening on ${host}:${port}; sidecar socket at ${socket}`,
+    serveStarted: (host, port) => `A2A listening on ${host}:${port}`,
     configAllowlistUsage: 'Usage: /config allowlist <list|add|remove|clear|hash|reload> [scope] [tool] [phase] [args=<hash>] [effects=a,b] [deny]',
     authUsage: 'Usage: /allowlist <list|add|remove|clear|hash|reload> [scope] [tool] [phase] [args=<hash>] [effects=a,b] [deny]',
     authSubcommandHint: (sub) => `Allowlist ${sub} command`,
@@ -234,6 +253,7 @@ export const en = {
     preflightPolicyOption: 'Preflight policy (lenient: continue on test failure, strict: fail on test failure)',
     checkpointStrategyOption: 'Checkpoint strategy to use (direct, worktree)',
     permissionModeOption: 'Permission mode (interactive, yolo)',
+    logModeOption: 'UI log mode (quiet, normal, debug)',
     environmentModeOption: 'Worktree environment mode (strict, parity)',
     applyBackOnDirtyOption: 'Behavior when apply-back detects a dirty workspace (3way, abort)',
     worktreePrepareOption: 'Optional setup command to run inside worktree',
@@ -241,6 +261,10 @@ export const en = {
     includePartialMessagesOption: 'Include partial message streaming events in stream-json output (alias for --stream-output).',
     outputFormatOption: 'Output format (text, json, stream-json)',
     outputProfileOption: 'Output profile for stream-json (native, anthropic, openai). Only valid with --output-format stream-json.',
+    exportPatchOption: 'Write the final workspace git unified diff to a patch file after the run completes.',
+    sweBenchInstanceIdOption: 'SWE-bench instance_id to include when writing a predictions JSONL record.',
+    sweBenchModelNameOption: 'SWE-bench model_name_or_path to include when writing a predictions JSONL record.',
+    sweBenchPredictionsOption: 'Append a SWE-bench predictions JSONL record containing instance_id, model_name_or_path, and model_patch.',
     headlessIncludeToolInputOption: 'Headless only: include (redacted) tool input in stream-json output. Only valid with --output-format stream-json.',
     headlessIncludeToolOutputOption: 'Headless only: include tool output summary in stream-json output. Only valid with --output-format stream-json.',
     headlessIncludeAuthorizationDecisionsOption: 'Headless only: include tool authorization decisions in headless output. Only valid with --output-format json or stream-json.',
@@ -250,7 +274,7 @@ export const en = {
     auditScopeOption: 'Audit log scope (repo, user)',
     contextDiffScopeOption: 'Diff scope for context (primary, ast_related)',
     contextBudgetCharsOption: 'Context budget in characters (e.g., 30000)',
-    actModeOption: 'Flow mode to run (patch, review, debug, research)',
+    actModeOption: 'Flow mode to run (patch, review, debug, research, answer, autopilot)',
     // Error messages
     fileSelectionConflict: '--file and --selection are mutually exclusive',
     instructionRequired: '--instruction is required',
@@ -260,10 +284,12 @@ export const en = {
     jsonSchemaRequiresJsonOutput: '--json-schema is only valid when --output-format is set to "json".',
     jsonSchemaLoadFailed: (msg) => `Failed to load JSON schema: ${msg}.`,
     structuredOutputSchemaFailed: 'Structured output failed schema validation.',
-    invalidActMode: (mode) => `Invalid --act-mode "${mode}". Expected "patch", "review", "debug", or "research".`,
+    invalidActMode: (mode) => `Invalid --act-mode "${mode}". Expected "patch", "review", "debug", "research", "answer", or "autopilot".`,
     invalidEnvironmentMode: (mode) => `Invalid --environment-mode "${mode}". Expected "strict" or "parity".`,
     invalidOutputFormat: (format) => `Invalid --output-format "${format}". Expected "text", "stream-json", or "json".`,
     invalidOutputProfile: (profile) => `Invalid --output-profile "${profile}". Expected "native", "anthropic", or "openai".`,
+    sweBenchInstanceRequired: '--swe-bench-predictions requires --swe-bench-instance-id.',
+    sweBenchModelRequired: '--swe-bench-predictions requires --swe-bench-model-name.',
     invalidAuditScope: (scope) => `Invalid --audit-scope "${scope}". Expected "repo" or "user".`,
     headlessToolPayloadRequiresStreamJson: '--headless-include-tool-input/--headless-include-tool-output are only valid when --output-format is set to "stream-json".',
     headlessToolPayloadNotSupportedWithOpenAiProfile: '--headless-include-tool-input/--headless-include-tool-output are not supported with --output-profile "openai".',

package/dist/cli/program-bootstrap.js

@@ -2,13 +2,23 @@ import chalk from 'chalk';
 import { Command } from 'commander';
 import { initializeRuntime } from '../core/facades/cli-program-bootstrap.js';
 import { text } from './locales/index.js';
-export function bootstrapProgram() {
+export function bootstrapProgram(options = {}) {
     initializeRuntime();
-    // Force global chalk level for all output paths.
-    chalk.level = 3;
+    if (!options.headlessDetection?.outputFormat && process.env.NO_COLOR === undefined) {
+        // Force global chalk level for interactive output paths.
+        chalk.level = 3;
+    }
+    else {
+        chalk.level = 0;
+    }
     const program = new Command();
     program.exitOverride();
-    program.name('s8p').alias('salmonloop').description(text.cli.programDescription).version('0.2.0');
+    program
+        .name('s8p')
+        .alias('salmonloop')
+        .description(text.cli.programDescription)
+        .version('0.2.0')
+        .addHelpText('after', text.cli.programHelpFooter);
     return program;
 }
 //# sourceMappingURL=program-bootstrap.js.map

package/dist/cli/program-commands.js

@@ -22,7 +22,7 @@ export function registerProgramCommands(program) {
         .option('--force-reset', text.cli.forceResetOption)
         .option('--validate', text.cli.validateOption)
         .option('--preflight-policy <policy>', text.cli.preflightPolicyOption, 'lenient')
-        .option('--act-mode <mode>', text.cli.actModeOption, 'patch')
+        .option('--act-mode <mode>', text.cli.actModeOption, 'autopilot')
         .option('--apply-back-on-dirty <mode>', text.cli.applyBackOnDirtyOption, '3way')
         .option('--environment-mode <mode>', text.cli.environmentModeOption, 'strict')
         .option('--worktree-prepare <command>', text.cli.worktreePrepareOption)
@@ -30,6 +30,10 @@ export function registerProgramCommands(program) {
         .option('--include-partial-messages', text.cli.includePartialMessagesOption)
         .option('--output-format <format>', text.cli.outputFormatOption, 'text')
         .option('--output-profile <profile>', text.cli.outputProfileOption)
+        .option('--export-patch <path>', text.cli.exportPatchOption)
+        .option('--swe-bench-instance-id <id>', text.cli.sweBenchInstanceIdOption)
+        .option('--swe-bench-model-name <name>', text.cli.sweBenchModelNameOption)
+        .option('--swe-bench-predictions <path>', text.cli.sweBenchPredictionsOption)
         .option('--headless-include-tool-input', text.cli.headlessIncludeToolInputOption)
         .option('--headless-include-tool-output', text.cli.headlessIncludeToolOutputOption)
         .option('--allow-outside-cache-root', text.cli.allowOutsideCacheRootOption)
@@ -90,6 +94,8 @@ export function registerProgramCommands(program) {
         .command('context')
         .description(text.cli.contextDescription)
         .option('-i, --instruction <instruction>', text.cli.instructionOption)
+        .option('--config <path>', text.cli.configOption)
+        .option('--no-config-file', text.cli.noConfigFileOption)
         .option('-f, --file <path>', text.cli.fileOption)
         .option('-s, --selection <text>', text.cli.selectionOption)
         .option('--diff-scope <scope>', text.cli.contextDiffScopeOption, 'primary')
@@ -100,6 +106,8 @@ export function registerProgramCommands(program) {
     program
         .command('chat', { isDefault: true })
         .description('Enter interactive chat mode (default)')
+        .option('--config <path>', text.cli.configOption)
+        .option('--no-config-file', text.cli.noConfigFileOption)
         .option('--verbose [level]', text.cli.verboseOption)
         .action(handleChatCommand);
 }

package/dist/cli/program-options.js

@@ -7,6 +7,7 @@ export function configureGlobalProgramOptions(program) {
         .option('--resume <sessionId>', text.cli.resumeOption)
         .option('-v, --verify <command>', text.cli.verifyOption)
         .option('--no-verify', 'Disable verification')
+        .option('--log-mode <mode>', text.cli.logModeOption)
         .option('-cs, --checkpoint-strategy <type>', text.cli.checkpointStrategyOption, 'worktree')
         .option('--mode <mode>', text.cli.permissionModeOption, 'interactive')
         .option('--llm-output <kinds>', text.cli.llmOutputOption)

package/dist/cli/reporters/anthropic-stream.js

@@ -8,13 +8,18 @@ export class AnthropicStreamReporter {
     repoPath;
     sessionId;
     writer;
+    includeToolInput;
     lastTextResult;
-    assembler = new StreamAssembler();
+    assembler;
     constructor(options = {}) {
         this.mode = options.mode ?? 'run';
         this.repoPath = options.repoPath;
         this.sessionId = options.sessionId ?? randomUUID();
         this.writer = options.writer ?? createStdoutWriter();
+        this.includeToolInput = options.includeToolInput ?? false;
+        this.assembler = new StreamAssembler({
+            deferToolRequestsUntilExecutionInput: this.includeToolInput,
+        });
     }
     onStart(instruction) {
         this.emit(encodeAnthropicStart({
@@ -40,6 +45,7 @@ export class AnthropicStreamReporter {
                 const lines = encodeNormalizedToAnthropicStreamLines({
                     sessionId: this.sessionId,
                     event: normalizedEvent,
+                    includeToolInput: this.includeToolInput,
                 });
                 for (const line of lines)
                     this.emit(line);

package/dist/cli/reporters/json.js

@@ -7,6 +7,7 @@ export class JsonReporter {
     sessionId;
     getStructuredOutput;
     getPayloadOverrides;
+    getWarnings;
     now;
     writer;
     startedAt = null;
@@ -18,6 +19,7 @@ export class JsonReporter {
         this.sessionId = options.sessionId ?? randomUUID();
         this.getStructuredOutput = options.getStructuredOutput;
         this.getPayloadOverrides = options.getPayloadOverrides;
+        this.getWarnings = options.getWarnings;
         this.now = options.now ?? (() => new Date());
         this.writer = options.writer ?? createStdoutWriter();
     }
@@ -48,6 +50,7 @@ export class JsonReporter {
             structuredOutput,
             loopResult: result,
             overrides,
+            warnings: this.getWarnings?.(),
         });
         this.writer.writeJsonLine(payload);
     }
@@ -62,6 +65,7 @@ export class JsonReporter {
             startedAt,
             endedAt,
             error,
+            warnings: this.getWarnings?.(),
         });
         this.writer.writeJsonLine(payload);
     }

package/dist/cli/reporters/stream-json.js

@@ -10,8 +10,11 @@ export class StreamJsonReporter {
     now;
     uuid;
     writer;
+    getWarnings;
     lastTextResult;
-    assembler = new StreamAssembler();
+    nextEventSeq = 0;
+    assembler;
+    includeToolInput;
     constructor(options = {}) {
         this.mode = options.mode ?? 'run';
         this.repoPath = options.repoPath;
@@ -19,6 +22,11 @@ export class StreamJsonReporter {
         this.now = options.now ?? (() => new Date());
         this.uuid = options.uuid ?? randomUUID;
         this.writer = options.writer ?? createStdoutWriter();
+        this.getWarnings = options.getWarnings;
+        this.includeToolInput = options.includeToolInput ?? false;
+        this.assembler = new StreamAssembler({
+            deferToolRequestsUntilExecutionInput: this.includeToolInput,
+        });
     }
     onStart(instruction) {
         this.emit(encodeStreamStart({
@@ -47,6 +55,7 @@ export class StreamJsonReporter {
                     sessionId: this.sessionId,
                     uuid: this.uuid,
                     event: normalizedEvent,
+                    includeToolInput: this.includeToolInput,
                 });
                 for (const line of lines)
                     this.emit(line);
@@ -76,6 +85,7 @@ export class StreamJsonReporter {
             loopResult: result,
             at,
             resultText: this.lastTextResult,
+            warnings: this.getWarnings?.(),
         });
         this.emit(resultLine);
         const exitCode = getStreamExitCode(result);
@@ -88,6 +98,7 @@ export class StreamJsonReporter {
         }));
     }
     onError(error) {
+        const auditPath = typeof error.auditPath === 'string' ? error.auditPath : undefined;
         this.emit(encodeStreamFailure({
             uuid: this.uuid(),
             sessionId: this.sessionId,
@@ -95,6 +106,7 @@ export class StreamJsonReporter {
             message: error.message,
             name: error.name,
             stack: error.stack,
+            auditPath,
         }));
         this.emit(encodeStreamEnd({
             uuid: this.uuid(),
@@ -105,7 +117,10 @@ export class StreamJsonReporter {
         }));
     }
     emit(line) {
-        this.writer.writeJsonLine(line);
+        this.writer.writeJsonLine({
+            ...line,
+            event_seq: line.event_seq ?? this.nextEventSeq++,
+        });
     }
 }
 //# sourceMappingURL=stream-json.js.map

package/dist/cli/run-cli.js

@@ -1,17 +1,19 @@
+import { detectHeadlessOutputFromArgv } from './argv/headless-detection.js';
 import { createCliRuntimeContext } from './cli-runtime-context.js';
 import { bootstrapProgram } from './program-bootstrap.js';
 import { registerProgramCommands } from './program-commands.js';
 import { configureGlobalProgramOptions } from './program-options.js';
 import { configureProgramOutputForHeadless } from './program-output-mode.js';
 import { parseProgramOrExit } from './program-parse.js';
-export function buildCliProgram() {
-    const program = bootstrapProgram();
+export function buildCliProgram(argv = process.argv) {
+    const headlessDetection = detectHeadlessOutputFromArgv(argv);
+    const program = bootstrapProgram({ headlessDetection });
     configureGlobalProgramOptions(program);
     registerProgramCommands(program);
     return program;
 }
 export function createCliContextFromArgv(argv) {
-    const program = buildCliProgram();
+    const program = buildCliProgram(argv);
     return createCliRuntimeContext(program, argv);
 }
 export async function executeCliContext(context) {