salmon-loop 0.2.3

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

@@ -0,0 +1,182 @@
+import { randomUUID } from 'crypto';
+import { getExitCode, } from '../../../core/facades/cli-run-headless-error-writer.js';
+import { encodeAnthropicEnd, encodeAnthropicError, encodeAnthropicStart, } from '../../headless/anthropic-stream-protocol.js';
+import { encodeJsonFailure } from '../../headless/json-protocol.js';
+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();
+    params.writer.writeJsonLine(encodeStreamStart({
+        uuid: randomUUID(),
+        mode: 'run',
+        repoPath: params.repoPath,
+        sessionId: params.sessionId,
+        instruction: params.instruction,
+        at,
+    }));
+    params.writer.writeJsonLine(encodeStreamFailure({
+        uuid: randomUUID(),
+        sessionId: params.sessionId,
+        at,
+        message: params.message,
+    }));
+    params.writer.writeJsonLine(encodeStreamEnd({
+        uuid: randomUUID(),
+        sessionId: params.sessionId,
+        at,
+        success: false,
+        exitCode: params.exitCode ?? 1,
+    }));
+}
+function writeAnthropicEarlyFailure(params) {
+    params.writer.writeJsonLine(encodeAnthropicStart({
+        sessionId: params.sessionId,
+        mode: 'run',
+        repoPath: params.repoPath,
+        instruction: params.instruction,
+    }));
+    params.writer.writeJsonLine(encodeAnthropicError({
+        sessionId: params.sessionId,
+        message: params.message,
+    }));
+    params.writer.writeJsonLine(encodeAnthropicEnd({
+        sessionId: params.sessionId,
+        loopResult: {
+            success: false,
+            reason: params.message,
+            errorCode: 'USAGE_ERROR',
+        },
+    }));
+}
+function writeOpenAiEarlyFailure(params) {
+    const encoder = new OpenAiStreamEncoder({
+        now: () => new Date(),
+        model: 'unknown',
+        responseId: () => `resp_${randomUUID().replace(/-/g, '')}`,
+        itemId: () => `msg_${randomUUID().replace(/-/g, '')}`,
+    });
+    const code = params.exitCode === 1 ? 'usage_error' : null;
+    for (const event of encoder.usageError({ message: params.message, code })) {
+        params.writer.writeJsonLine(event);
+    }
+}
+function writeOpenAiUnexpectedFailure(params) {
+    const encoder = new OpenAiStreamEncoder({
+        now: () => new Date(),
+        model: 'unknown',
+        responseId: () => `resp_${randomUUID().replace(/-/g, '')}`,
+        itemId: () => `msg_${randomUUID().replace(/-/g, '')}`,
+    });
+    for (const event of encoder.crash(new Error(params.message))) {
+        params.writer.writeJsonLine(event);
+    }
+}
+function resolveSessionId(ctx, override) {
+    return override ?? ctx.getResumeSessionId() ?? ctx.getSessionId() ?? randomUUID();
+}
+export function createHeadlessErrorWriter(ctx) {
+    const writeJsonFailure = (params) => {
+        const sessionId = resolveSessionId(ctx, params.sessionId);
+        ctx.writer.writeJsonLine(encodeJsonFailure({
+            mode: 'run',
+            repoPath: params.repoPath ?? ctx.repoPath,
+            sessionId,
+            instruction: params.instruction,
+            message: params.message,
+            errorCode: params.errorCode,
+            exitCode: params.exitCode ?? 1,
+        }));
+    };
+    const writeUsageError = (params) => {
+        const sessionId = resolveSessionId(ctx, params.sessionId);
+        const exitCode = params.exitCode ?? 1;
+        if (ctx.outputFormat === 'json') {
+            writeJsonFailure({
+                message: params.message,
+                instruction: params.instruction,
+                exitCode,
+                errorCode: 'USAGE_ERROR',
+                sessionId,
+            });
+            return;
+        }
+        if (ctx.outputFormat === 'stream-json') {
+            if (ctx.outputProfileForStreamJson === 'anthropic') {
+                writeAnthropicEarlyFailure({
+                    writer: ctx.writer,
+                    repoPath: ctx.repoPath,
+                    sessionId,
+                    message: params.message,
+                    exitCode,
+                    instruction: params.instruction,
+                });
+            }
+            else if (ctx.outputProfileForStreamJson === 'openai') {
+                writeOpenAiEarlyFailure({
+                    writer: ctx.writer,
+                    message: params.message,
+                    exitCode,
+                });
+            }
+            else {
+                writeStreamJsonEarlyFailure({
+                    writer: ctx.writer,
+                    repoPath: ctx.repoPath,
+                    sessionId,
+                    message: params.message,
+                    exitCode,
+                    instruction: params.instruction,
+                });
+            }
+        }
+    };
+    const writeUnexpectedError = (params) => {
+        const sessionId = resolveSessionId(ctx, params.sessionId);
+        if (ctx.outputFormat === 'json') {
+            writeJsonFailure({
+                message: params.message,
+                repoPath: ctx.repoPath,
+                instruction: params.instruction,
+                sessionId,
+            });
+            return;
+        }
+        if (ctx.outputFormat === 'stream-json') {
+            if (ctx.outputProfileForStreamJson === 'anthropic') {
+                writeAnthropicEarlyFailure({
+                    writer: ctx.writer,
+                    repoPath: ctx.repoPath,
+                    sessionId,
+                    message: params.message,
+                    instruction: params.instruction,
+                });
+            }
+            else if (ctx.outputProfileForStreamJson === 'openai') {
+                writeOpenAiUnexpectedFailure({
+                    writer: ctx.writer,
+                    message: params.message,
+                });
+            }
+            else {
+                writeStreamJsonEarlyFailure({
+                    writer: ctx.writer,
+                    repoPath: ctx.repoPath,
+                    sessionId,
+                    message: params.message,
+                    instruction: params.instruction,
+                });
+            }
+        }
+    };
+    const resolveExitCode = (result) => getExitCode(result);
+    const writeResultExitCode = (result, structuredOk) => {
+        return result.success && !structuredOk ? 1 : resolveExitCode(result);
+    };
+    return {
+        writeJsonFailure,
+        writeUsageError,
+        writeUnexpectedError,
+        writeResultExitCode,
+    };
+}
+//# sourceMappingURL=headless-error-writer.js.map

package/dist/cli/commands/run/instruction-guard.js

@@ -0,0 +1,24 @@
+import { randomUUID } from 'crypto';
+import { getLogger } from '../../../core/facades/cli-observability.js';
+import { text } from '../../locales/index.js';
+export function ensureInstructionOrExit(params) {
+    if (params.instruction)
+        return { ok: true };
+    if (params.validate)
+        return { ok: true };
+    getLogger().error(text.cli.optionsRequired);
+    if (params.outputFormat === 'text') {
+        params.command.help();
+        return { ok: false, exitCode: 1 };
+    }
+    if (params.outputFormat === 'json') {
+        params.writeJsonFailure({ message: text.cli.optionsRequired, repoPath: params.repoPath });
+        return { ok: false, exitCode: 1 };
+    }
+    params.headlessErrorWriter.writeUnexpectedError({
+        sessionId: params.sessionIdForOutput ?? randomUUID(),
+        message: text.cli.optionsRequired,
+    });
+    return { ok: false, exitCode: 1 };
+}
+//# sourceMappingURL=instruction-guard.js.map

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

@@ -0,0 +1,46 @@
+import { createTerminalAuthorizationProvider } from '../../authorization/provider.js';
+export function buildRunLoopParams(params) {
+    return {
+        instruction: params.instruction,
+        verify: params.verify,
+        repoPath: params.repoPath,
+        llm: params.llm,
+        conversationContext: params.conversationContext,
+        mode: params.mode,
+        dryRun: params.dryRun,
+        forceReset: params.forceReset,
+        file: params.file,
+        selection: params.selection,
+        verbose: params.verbose,
+        strategy: params.checkpointStrategy,
+        environmentMode: params.environmentMode,
+        applyBackOnDirty: params.applyBackOnDirty,
+        worktreePrepare: params.worktreePrepare,
+        llmOutput: params.llmOutput,
+        outcomeReporter: params.outcomeReporter,
+        auditScope: params.auditScope,
+        langfuseSessionId: params.langfuseSessionId,
+        langfuseUserId: params.langfuseUserId,
+        astValidation: params.astValidation,
+        languagePlugins: params.languagePlugins,
+        allowOutsideCacheRoot: params.allowOutsideCacheRoot,
+        authorizationProvider: createTerminalAuthorizationProvider({
+            config: params.toolAuthorization,
+            extensions: params.extensions,
+            forceNonInteractive: params.headlessOutput || params.printMode,
+            permissionMode: params.permissionMode,
+        }),
+        extensions: params.extensions,
+        permissionRules: params.permissionRules,
+        eventPayload: params.headlessIncludeToolInput ||
+            params.headlessIncludeToolOutput ||
+            params.headlessIncludeAuthorizationDecisions
+            ? {
+                includeToolInput: params.headlessIncludeToolInput,
+                includeToolOutput: params.headlessIncludeToolOutput,
+                includeAuthorizationDecisions: params.headlessIncludeAuthorizationDecisions,
+            }
+            : undefined,
+    };
+}
+//# sourceMappingURL=loop-params.js.map

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

@@ -0,0 +1,8 @@
+export function resolveRunMode(raw) {
+    const value = String(raw || 'patch');
+    if (value === 'patch' || value === 'review' || value === 'debug' || value === 'research') {
+        return value;
+    }
+    return undefined;
+}
+//# sourceMappingURL=mode.js.map

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

@@ -0,0 +1,67 @@
+import { resolve } from 'path';
+function splitToolRules(raw) {
+    const parts = [];
+    const push = (s) => {
+        if (typeof s !== 'string')
+            return;
+        for (const piece of s.split(',')) {
+            const trimmed = piece.trim();
+            if (trimmed)
+                parts.push(trimmed);
+        }
+    };
+    if (Array.isArray(raw)) {
+        for (const v of raw)
+            push(v);
+        return parts;
+    }
+    push(raw);
+    return parts;
+}
+export function parseRunCommandOptions(command) {
+    const allOptions = command.optsWithGlobals();
+    const repoPath = resolve(allOptions.repo || process.cwd());
+    const continueSession = Boolean(allOptions.continue);
+    const resumeSessionId = typeof allOptions.resume === 'string'
+        ? allOptions.resume
+        : undefined;
+    const printInstruction = typeof allOptions.print === 'string'
+        ? allOptions.print
+        : undefined;
+    const explicitInstruction = typeof allOptions.instruction === 'string' ? allOptions.instruction : undefined;
+    const jsonSchemaSpec = typeof allOptions.jsonSchema === 'string'
+        ? allOptions.jsonSchema
+        : undefined;
+    const rawOutputFormat = String(allOptions.outputFormat || 'text');
+    const rawOutputProfile = typeof allOptions.outputProfile === 'string'
+        ? String(allOptions.outputProfile)
+        : undefined;
+    const outputProfileForStreamJson = rawOutputProfile ?? 'native';
+    const headlessIncludeToolInput = Boolean(allOptions.headlessIncludeToolInput);
+    const headlessIncludeToolOutput = Boolean(allOptions.headlessIncludeToolOutput);
+    const headlessIncludeAuthorizationDecisions = Boolean(allOptions.headlessIncludeAuthorizationDecisions);
+    const allowOutsideCacheRoot = Boolean(allOptions.allowOutsideCacheRoot);
+    const instruction = explicitInstruction ?? printInstruction;
+    const allowedToolRules = splitToolRules(allOptions.allowedTools);
+    const disallowedToolRules = splitToolRules(allOptions.disallowedTools);
+    return {
+        allOptions,
+        repoPath,
+        continueSession,
+        resumeSessionId,
+        printInstruction,
+        explicitInstruction,
+        instruction,
+        jsonSchemaSpec,
+        rawOutputFormat,
+        rawOutputProfile,
+        outputProfileForStreamJson,
+        headlessIncludeToolInput,
+        headlessIncludeToolOutput,
+        headlessIncludeAuthorizationDecisions,
+        allowOutsideCacheRoot,
+        allowedToolRules,
+        disallowedToolRules,
+    };
+}
+//# sourceMappingURL=parse-options.js.map

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

@@ -0,0 +1,35 @@
+import { refreshSessionSummary, } from '../../../core/facades/cli-run-persist-session.js';
+export async function persistRunSession(params) {
+    if (!params.sessionManager || typeof params.instruction !== 'string')
+        return;
+    try {
+        params.sessionManager.addMessage({
+            role: 'user',
+            content: params.instruction,
+            timestamp: Date.now(),
+        });
+        let iterationId;
+        if (Array.isArray(params.result.history) && params.result.history.length > 0) {
+            iterationId = params.sessionManager.addIteration(params.result.history[params.result.history.length - 1]);
+        }
+        if (params.result.reason !== 'Operation cancelled by user') {
+            params.sessionManager.addMessage({
+                role: 'assistant',
+                content: params.buildAssistantMessage(params.result),
+                timestamp: Date.now(),
+                iterationId,
+            });
+        }
+        await refreshSessionSummary({
+            sessionManager: params.sessionManager,
+            llm: params.llm,
+            contextHash: params.result.contextHash,
+            strategy: 'force',
+        });
+        await params.sessionManager.save();
+    }
+    catch {
+        // Best-effort persistence: never block the CLI exit path.
+    }
+}
+//# sourceMappingURL=persist-session.js.map

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

@@ -0,0 +1,156 @@
+import chalk from 'chalk';
+import { getLogger } from '../../../core/facades/cli-observability.js';
+import { PluginLoader } from '../../../core/plugin/loader.js';
+import { spawnCommand, } from '../../../core/runtime/process-runner.js';
+import { detectNodeRuntimeProfile, resolveScriptCommand, } from '../../../core/target-runtime/index.js';
+import { text } from '../../locales/index.js';
+class PreflightCommandError extends Error {
+    details;
+    constructor(details) {
+        super(details.message);
+        this.details = details;
+    }
+}
+function mapFailureDetails(scriptName, cmd, args, failure) {
+    return {
+        scriptName,
+        command: cmd,
+        args,
+        reason: failure.kind,
+        message: failure.message,
+        exitCode: failure.exitCode,
+        signal: failure.signal,
+        code: failure.code,
+    };
+}
+function buildFailureMessage(details) {
+    const printable = [details.command, ...details.args].join(' ');
+    switch (details.reason) {
+        case 'timeout':
+            return text.cli.validationCommandTimeout(details.scriptName, printable);
+        case 'spawn_error':
+            if (details.code === 'ENOENT') {
+                return text.cli.validationCommandNotFound(details.scriptName, printable);
+            }
+            if (details.code === 'OUTPUT_TRUNCATED') {
+                return text.cli.validationCommandOutputExceeded(details.scriptName, printable);
+            }
+            return text.cli.validationCommandSpawnError(details.scriptName, printable, details.message);
+        case 'nonzero_exit':
+            return text.cli.validationCommandExitCode(details.scriptName, printable, details.exitCode ?? -1);
+        case 'aborted':
+            return text.cli.validationCommandAborted(details.scriptName, printable);
+        default:
+            return text.cli.validationCommandSpawnError(details.scriptName, printable, details.message);
+    }
+}
+async function runValidateCommand(params) {
+    const maxBytesPerStream = 500_000;
+    const result = await spawnCommand({
+        command: params.cmd,
+        args: params.args,
+        cwd: params.repoPath,
+        windowsHide: true,
+        maxStdoutBytes: maxBytesPerStream,
+        maxStderrBytes: maxBytesPerStream,
+    });
+    const combined = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join('\n').trim();
+    if (combined) {
+        const output = params.useGui ? combined.slice(0, 2_000) : combined;
+        getLogger().log(output);
+    }
+    if (result.failure) {
+        throw new PreflightCommandError(mapFailureDetails(params.scriptName, params.cmd, params.args, result.failure));
+    }
+    if (result.stdoutTruncated || result.stderrTruncated) {
+        throw new PreflightCommandError({
+            scriptName: params.scriptName,
+            command: params.cmd,
+            args: params.args,
+            reason: 'spawn_error',
+            message: 'Validation output exceeded allowed size',
+            code: 'OUTPUT_TRUNCATED',
+        });
+    }
+}
+export async function runPreflight(params) {
+    await PluginLoader.loadPlugins(params.languagePlugins, params.repoPath);
+    if (!params.validate)
+        return;
+    const preflightPolicy = params.preflightPolicy ?? 'lenient';
+    getLogger().log(chalk.blue(text.cli.runningValidation));
+    const profile = await detectNodeRuntimeProfile(params.repoPath);
+    if (!profile) {
+        getLogger().warn(text.cli.validationSkippedNoPackageJson);
+        return;
+    }
+    const lintCommand = resolveScriptCommand(profile, 'lint');
+    const testCommand = resolveScriptCommand(profile, 'test');
+    if (!lintCommand && !testCommand) {
+        getLogger().warn(text.cli.validationSkippedNoScripts);
+        return;
+    }
+    getLogger().debug(text.cli.validationUsingPackageManager(profile.packageManager));
+    try {
+        if (lintCommand) {
+            getLogger().debug(text.cli.runningScript('lint', lintCommand.shellCommand));
+            try {
+                await runValidateCommand({
+                    repoPath: params.repoPath,
+                    scriptName: 'lint',
+                    cmd: lintCommand.command,
+                    args: lintCommand.args,
+                    useGui: params.useGui,
+                });
+            }
+            catch (error) {
+                if (error instanceof PreflightCommandError) {
+                    getLogger().audit('cli.preflight.command_failure', error.details, {
+                        source: 'cli',
+                        severity: 'low',
+                    });
+                    getLogger().error(buildFailureMessage(error.details));
+                }
+                throw error;
+            }
+        }
+        else {
+            getLogger().debug(text.cli.scriptMissing('lint'));
+        }
+        if (testCommand) {
+            getLogger().debug(text.cli.runningScript('test', testCommand.shellCommand));
+            try {
+                await runValidateCommand({
+                    repoPath: params.repoPath,
+                    scriptName: 'test',
+                    cmd: testCommand.command,
+                    args: testCommand.args,
+                    useGui: params.useGui,
+                });
+            }
+            catch (error) {
+                if (error instanceof PreflightCommandError) {
+                    getLogger().audit('cli.preflight.command_failure', error.details, {
+                        source: 'cli',
+                        severity: 'low',
+                    });
+                    const detailedMessage = buildFailureMessage(error.details);
+                    if (preflightPolicy === 'strict') {
+                        getLogger().error(detailedMessage);
+                        throw error;
+                    }
+                    getLogger().warn(detailedMessage);
+                }
+                getLogger().warn(text.cli.testsFailedContinuing);
+            }
+        }
+        else {
+            getLogger().debug(text.cli.scriptMissing('test'));
+        }
+        getLogger().success(text.cli.validationCompleted);
+    }
+    catch {
+        getLogger().error(text.cli.validationFailed, true);
+    }
+}
+//# sourceMappingURL=preflight.js.map

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

@@ -0,0 +1,52 @@
+import { AnthropicStreamReporter } from '../../reporters/anthropic-stream.js';
+import { JsonReporter } from '../../reporters/json.js';
+import { OpenAiStreamReporter } from '../../reporters/openai-stream.js';
+import { StandardReporter } from '../../reporters/standard.js';
+import { StreamJsonReporter } from '../../reporters/stream-json.js';
+function createNoopReporter() {
+    return {
+        onStart: () => { },
+        onEvent: () => { },
+        onFinish: () => { },
+        onError: () => { },
+    };
+}
+export function createRunReporter(params) {
+    if (params.useGui)
+        return createNoopReporter();
+    if (params.outputFormat === 'stream-json') {
+        const profile = params.rawOutputProfile ?? 'native';
+        if (profile === 'anthropic') {
+            return new AnthropicStreamReporter({
+                mode: 'run',
+                repoPath: params.repoPath,
+                sessionId: params.sessionIdForOutput,
+                writer: params.writer,
+            });
+        }
+        if (profile === 'openai') {
+            return new OpenAiStreamReporter({
+                model: params.model,
+                writer: params.writer,
+            });
+        }
+        return new StreamJsonReporter({
+            mode: 'run',
+            repoPath: params.repoPath,
+            sessionId: params.sessionIdForOutput,
+            writer: params.writer,
+        });
+    }
+    if (params.outputFormat === 'json') {
+        return new JsonReporter({
+            mode: 'run',
+            repoPath: params.repoPath,
+            sessionId: params.sessionIdForOutput,
+            writer: params.writer,
+            getStructuredOutput: params.getStructuredOutput,
+            getPayloadOverrides: params.getPayloadOverrides,
+        });
+    }
+    return new StandardReporter(params.verbose);
+}
+//# sourceMappingURL=reporter-factory.js.map

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

@@ -0,0 +1,56 @@
+import { createPhaseRoutingLlm, createRuntimeLlm, EXECUTION_PHASES, getLogger, Phase, } from '../../../core/facades/cli-run-runtime-llm.js';
+import { text } from '../../locales/index.js';
+export function createRuntimeLlmAndWarn(params) {
+    const runtimeLlm = createRuntimeLlm(params.llmConfig, {
+        langfuseEnabled: params.langfuseEnabled,
+    });
+    const warnings = [...runtimeLlm.warnings];
+    const phaseToProviderModel = params.llmConfig?.routing?.phaseToProviderModel;
+    const phaseLlms = {};
+    if (phaseToProviderModel && typeof phaseToProviderModel === 'object') {
+        const validPhases = new Set([...EXECUTION_PHASES, Phase.SLASH]);
+        for (const [phase, target] of Object.entries(phaseToProviderModel)) {
+            if (!validPhases.has(phase))
+                continue;
+            if (!target || typeof target !== 'object')
+                continue;
+            const perPhaseConfig = {
+                id: target.id,
+                type: target.type,
+                clientPackage: target.clientPackage,
+                api: {
+                    baseUrl: target.api?.baseUrl,
+                    timeoutMs: target.api?.timeoutMs,
+                    headers: target.api?.headers,
+                    apiKey: target.api?.apiKey,
+                    apiKeySource: target.api?.apiKeySource,
+                },
+                models: {
+                    selectedModelId: target.model?.id,
+                    selectedModelSlot: target.model?.slot || 'default',
+                },
+            };
+            const created = createRuntimeLlm(perPhaseConfig, { langfuseEnabled: params.langfuseEnabled });
+            warnings.push(...created.warnings);
+            phaseLlms[phase] = created.llm;
+        }
+    }
+    const llm = Object.keys(phaseLlms).length > 0
+        ? createPhaseRoutingLlm({ defaultLlm: runtimeLlm.llm, phaseLlms })
+        : 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 || '')));
+        }
+    }
+    return { llm, warnings: Array.from(new Set(warnings)) };
+}
+//# sourceMappingURL=runtime-llm.js.map

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

@@ -0,0 +1,30 @@
+import { getLogger } from '../../../core/facades/cli-observability.js';
+import { text } from '../../locales/index.js';
+import { resolveLlmOutputPolicyFromCli } from '../../utils/llm-output.js';
+import { resolveVerifyOption } from '../../utils/verify-resolver.js';
+import { resolveWorktreePrepareOption } from '../../utils/worktree-prepare-resolver.js';
+export async function resolveRunRuntimeOptions(params) {
+    const llmOutputResolution = resolveLlmOutputPolicyFromCli(params.resolvedConfig.llmOutput, params.cliOptions.llmOutput);
+    if (!llmOutputResolution.ok) {
+        getLogger().error(text.cli.invalidLlmOutputKind(llmOutputResolution.invalid));
+        if (params.outputFormat === 'json') {
+            params.writeJsonFailure({
+                message: text.cli.invalidLlmOutputKind(llmOutputResolution.invalid),
+                repoPath: params.repoPath,
+            });
+        }
+        return { ok: false, exitCode: 1 };
+    }
+    const llmOutput = {
+        ...llmOutputResolution.policy,
+        kinds: [...llmOutputResolution.policy.kinds],
+    };
+    const wantPartialMessages = Boolean(params.cliOptions.streamOutput || params.cliOptions.includePartialMessages);
+    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);
+    return { ok: true, llmOutput, effectiveVerify, effectiveWorktreePrepare };
+}
+//# sourceMappingURL=runtime-options.js.map

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

@@ -0,0 +1,19 @@
+import { ChatSessionManager } from '../../../core/session/manager.js';
+export async function initializeSession(params) {
+    const sessionManager = new ChatSessionManager(params.repoPath);
+    await sessionManager.init();
+    if (params.resumeSessionId) {
+        await sessionManager.resumeSession(params.resumeSessionId);
+    }
+    else if (params.continueSession) {
+        const resumed = await sessionManager.loadLast();
+        if (!resumed) {
+            await sessionManager.create();
+        }
+    }
+    else {
+        await sessionManager.create();
+    }
+    return { sessionManager, sessionId: sessionManager.getCurrent().meta.id };
+}
+//# sourceMappingURL=session.js.map