salmon-loop 0.2.3

package/dist/cli/commands/parallel.js

@@ -0,0 +1,256 @@
+import { CheckpointManager, createStandardToolstack, InMemoryLockManager, ParallelScheduler, PlanPersistence, resolveExtensions, WorkspaceManager, } from '../../core/facades/cli-command-parallel.js';
+import { createUiAuthorizationProvider } from '../authorization/provider.js';
+import { text } from '../locales/index.js';
+import { requestSelection } from '../ui/selection/bus.js';
+function summarizeParallelPlan(state) {
+    const planId = state.plan?.id || state.result?.planId || 'unknown';
+    const blocked = state.result?.blockedApprovals?.length ?? 0;
+    const failed = Boolean(state.result?.failed);
+    const canceled = Boolean(state.result?.canceled);
+    const nodeCount = state.plan?.nodes?.length ?? 0;
+    let status = 'pending';
+    if (failed)
+        status = 'failed';
+    else if (canceled)
+        status = 'canceled';
+    else if (blocked > 0)
+        status = 'blocked';
+    const updatedAt = state.updatedAt ? new Date(state.updatedAt).toLocaleString() : 'unknown';
+    const description = `${status}, blocked=${blocked}, nodes=${nodeCount}, updated=${updatedAt}`;
+    return { planId, label: planId, description };
+}
+async function selectParallelPlanFromUi(title, plans) {
+    const items = plans.map((state) => {
+        const summary = summarizeParallelPlan(state);
+        return { id: summary.planId, label: summary.label, description: summary.description };
+    });
+    const promptId = `parallel-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const selected = await requestSelection({ id: promptId, title, items });
+    return selected?.[0] ?? null;
+}
+function parallelSubcommandHint(sub) {
+    return text.cli.parallelSubcommandHint(sub);
+}
+export const parallelCommand = {
+    name: '/parallel',
+    hidden: true,
+    description: text.cli.commandParallel,
+    getSuggestions: ({ input }) => {
+        const trimmed = input.trimStart();
+        const parts = trimmed.split(/\s+/);
+        const argIndex = parts.length - 1;
+        const currentPrefix = parts[argIndex] || '';
+        if (argIndex === 1) {
+            const subCommands = ['list', 'resume', 'delete'];
+            const search = currentPrefix.toLowerCase();
+            return subCommands
+                .filter((s) => s.startsWith(search))
+                .map((s) => ({ name: s, description: parallelSubcommandHint(s) }));
+        }
+        return [];
+    },
+    execute: async ({ emit, input, sessionManager, toolAuthorization }) => {
+        const repoRoot = sessionManager.getCurrent().meta.repoPath;
+        const args = input.trim().split(/\s+/).slice(1);
+        const subCommand = (args[0] || 'list').toLowerCase();
+        const plans = await PlanPersistence.listPendingOrBlocked(repoRoot);
+        plans.sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
+        if (subCommand === 'list') {
+            if (plans.length === 0) {
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.parallelListEmpty,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const picked = await selectParallelPlanFromUi(text.cli.parallelSelectTitle, plans);
+            if (!picked) {
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.parallelCanceled,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const state = await PlanPersistence.load(repoRoot, picked);
+            if (!state) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.parallelNotFound(picked),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const summary = summarizeParallelPlan(state);
+            emit({
+                type: 'log',
+                level: 'info',
+                message: summary.description,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        if (subCommand === 'delete') {
+            let planId = args[1];
+            if (!planId) {
+                if (plans.length === 0) {
+                    emit({
+                        type: 'log',
+                        level: 'info',
+                        message: text.cli.parallelListEmpty,
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                planId = await selectParallelPlanFromUi(text.cli.parallelSelectTitle, plans);
+            }
+            if (!planId) {
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.parallelCanceled,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            await PlanPersistence.delete(repoRoot, planId);
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.parallelDeleted(planId),
+                timestamp: new Date(),
+            });
+            return;
+        }
+        if (subCommand === 'resume') {
+            let planId = args[1];
+            if (!planId) {
+                if (plans.length === 0) {
+                    emit({
+                        type: 'log',
+                        level: 'info',
+                        message: text.cli.parallelListEmpty,
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                planId = await selectParallelPlanFromUi(text.cli.parallelSelectTitle, plans);
+            }
+            if (!planId) {
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.parallelCanceled,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const state = await PlanPersistence.load(repoRoot, planId);
+            if (!state) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: text.cli.parallelNotFound(planId),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            const checkpointManager = new CheckpointManager();
+            const snapshot = await checkpointManager.createSafeSnapshot(repoRoot, [], 'Parallel resume');
+            const workspace = await WorkspaceManager.setup({
+                instruction: 'Parallel plan resume',
+                repoPath: repoRoot,
+                strategy: 'worktree',
+            }, snapshot.commitHash, emit);
+            try {
+                await checkpointManager.restoreToShadow(repoRoot, workspace.workPath, snapshot.commitHash);
+                const authorizationProvider = createUiAuthorizationProvider({
+                    emit,
+                    config: toolAuthorization,
+                });
+                let extensionResolution;
+                try {
+                    extensionResolution = await resolveExtensions({ repoRoot: workspace.baseRepoPath });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    emit({
+                        type: 'log',
+                        level: 'error',
+                        message: `Failed to resolve extensions: ${message}`,
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                const toolstack = await createStandardToolstack({
+                    repoRoot: workspace.workPath,
+                    persistenceRoot: workspace.baseRepoPath,
+                    worktreeRoot: workspace.workPath,
+                    attemptId: 0,
+                    dryRun: false,
+                    authorizationProvider,
+                    authorizationMode: 'deferred',
+                    extensions: extensionResolution.resolved,
+                });
+                const scheduler = new ParallelScheduler(toolstack.router, new InMemoryLockManager());
+                const phase = state.runtime?.phase || 'PATCH';
+                const runtime = {
+                    repoRoot: workspace.workPath,
+                    worktreeRoot: workspace.workPath,
+                    persistenceRoot: workspace.baseRepoPath,
+                    attemptId: 0,
+                    dryRun: false,
+                    model: state.runtime?.model,
+                    phase,
+                };
+                const runSignal = new AbortController().signal;
+                let result = await scheduler.run(state.plan, runtime, runSignal, {
+                    initialResults: state.result.nodeResults,
+                    resumeBlockedApprovals: true,
+                });
+                const canWaitForAuth = typeof toolstack.router.waitForAuthorization === 'function';
+                let resumeAttempts = 0;
+                while (result.blockedApprovals.length > 0 && canWaitForAuth && !runSignal.aborted) {
+                    resumeAttempts++;
+                    if (resumeAttempts > 10)
+                        break;
+                    await Promise.all(result.blockedApprovals.map(async (a) => {
+                        await toolstack.router.waitForAuthorization(a.nodeId, runSignal);
+                    }));
+                    result = await scheduler.run(state.plan, runtime, runSignal, {
+                        initialResults: result.nodeResults,
+                        resumeBlockedApprovals: true,
+                    });
+                }
+                await PlanPersistence.save(workspace.baseRepoPath, state.plan, result, {
+                    repoRoot: workspace.workPath,
+                    worktreeRoot: workspace.workPath,
+                    persistenceRoot: workspace.baseRepoPath,
+                    phase,
+                    model: state.runtime?.model,
+                });
+                emit({
+                    type: 'log',
+                    level: result.failed ? 'warn' : 'info',
+                    message: text.cli.parallelResumed(planId, result.blockedApprovals.length, result.failed),
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            finally {
+                await WorkspaceManager.teardown(workspace, emit);
+            }
+        }
+        emit({
+            type: 'log',
+            level: 'error',
+            message: text.cli.parallelUsage,
+            timestamp: new Date(),
+        });
+    },
+};
+//# sourceMappingURL=parallel.js.map

package/dist/cli/commands/queue.js

@@ -0,0 +1,130 @@
+import { getLogger } from '../../core/facades/cli-observability.js';
+import { text } from '../locales/index.js';
+import { parseSuggestionContext } from './utils.js';
+export const queueCommand = {
+    name: '/queue',
+    description: text.cli.commandQueue,
+    order: 50,
+    getSuggestions: ({ input }) => {
+        const { argIndex, currentPrefix } = parseSuggestionContext(input);
+        if (argIndex === 1) {
+            const subCommands = ['status', 'pause', 'resume', 'retry', 'clear'];
+            const search = currentPrefix.toLowerCase();
+            return subCommands
+                .filter((s) => s.startsWith(search))
+                .map((s) => ({ name: s, description: text.cli.queueSubcommandHint(s) }));
+        }
+        return [];
+    },
+    execute: ({ emit, input, queue }) => {
+        if (!queue) {
+            emit({
+                type: 'log',
+                level: 'error',
+                message: text.cli.queueUnavailable,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        const args = input.trim().split(/\s+/).slice(1);
+        const subCommand = (args[0] || 'status').toLowerCase();
+        const status = queue.status();
+        if (subCommand === 'status') {
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.queueStatus(status.pendingCount, status.isProcessing, status.isPaused, status.hasInterrupted),
+                timestamp: new Date(),
+            });
+            if (status.hasInterrupted) {
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.queueInterruptedHint,
+                    timestamp: new Date(),
+                });
+            }
+            return;
+        }
+        if (subCommand === 'pause') {
+            if (status.isPaused) {
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.queueAlreadyPaused,
+                    timestamp: new Date(),
+                });
+                getLogger().audit('QUEUE_PAUSE', { status: 'already_paused' }, { source: 'cli', severity: 'low', scope: 'session' });
+                return;
+            }
+            queue.pause();
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.queuePaused,
+                timestamp: new Date(),
+            });
+            getLogger().audit('QUEUE_PAUSE', { status: 'paused' }, { source: 'cli', severity: 'low', scope: 'session' });
+            return;
+        }
+        if (subCommand === 'resume') {
+            if (!status.isPaused) {
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.queueNotPaused,
+                    timestamp: new Date(),
+                });
+                getLogger().audit('QUEUE_RESUME', { status: 'not_paused' }, { source: 'cli', severity: 'low', scope: 'session' });
+                return;
+            }
+            queue.resume();
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.queueResumed,
+                timestamp: new Date(),
+            });
+            getLogger().audit('QUEUE_RESUME', { status: 'resumed' }, { source: 'cli', severity: 'low', scope: 'session' });
+            return;
+        }
+        if (subCommand === 'retry') {
+            const retried = queue.retry();
+            if (!retried) {
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: text.cli.queueRetryMissing,
+                    timestamp: new Date(),
+                });
+                return;
+            }
+            queue.resume();
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.queueRetryQueued,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        if (subCommand === 'clear') {
+            const cleared = queue.clear();
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.queueClearedCount(cleared),
+                timestamp: new Date(),
+            });
+            getLogger().audit('QUEUE_CLEAR', { cleared }, { source: 'cli', severity: 'low', scope: 'session' });
+            return;
+        }
+        emit({
+            type: 'log',
+            level: 'error',
+            message: text.cli.queueUsage,
+            timestamp: new Date(),
+        });
+    },
+};
+//# sourceMappingURL=queue.js.map

package/dist/cli/commands/registry.js

@@ -0,0 +1,85 @@
+import { allowlistCommand } from './allowlist.js';
+import { configCommand } from './config.js';
+import { exitCommand } from './exit.js';
+import { llmOutputCommand } from './llm-output.js';
+import { logModeCommand } from './log-mode.js';
+import { modeCommand } from './mode.js';
+import { newCommand } from './new.js';
+import { queueCommand } from './queue.js';
+import { sessionCommand } from './session.js';
+import { snapshotInteractiveCommand } from './snapshot-interactive.js';
+import { statusCommand } from './status.js';
+import { subAgentCommand } from './subagent.js';
+import { suggestSubcommands } from './subcommand-suggestions.js';
+import { parseSuggestionContext } from './utils.js';
+const baseCommands = [
+    exitCommand,
+    statusCommand,
+    queueCommand,
+    allowlistCommand,
+    modeCommand,
+    logModeCommand,
+    configCommand,
+    subAgentCommand,
+    newCommand,
+    llmOutputCommand,
+    {
+        name: '/help',
+        description: 'Show available commands',
+        order: 80,
+        execute: ({ emit }) => {
+            const visible = commands.filter((c) => !c.hidden);
+            const maxName = Math.max(...visible.map((cmd) => cmd.name.length), 0);
+            const rows = visible.map((cmd) => {
+                const paddedName = `${cmd.name}`.padEnd(maxName + 2);
+                return `${paddedName}${cmd.description}`;
+            });
+            const helpMsg = rows.join('\n');
+            emit({
+                type: 'log',
+                level: 'info',
+                message: `Available Commands:\n${helpMsg}`,
+                timestamp: new Date(),
+            });
+        },
+    },
+    sessionCommand,
+    snapshotInteractiveCommand,
+];
+export const commands = [...baseCommands].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+function getCommandNames(command) {
+    return [
+        command.name.toLowerCase(),
+        ...(command.aliases?.map((alias) => alias.toLowerCase()) ?? []),
+    ];
+}
+export async function getSuggestions(input, context) {
+    const { argIndex, currentPrefix } = parseSuggestionContext(input);
+    if (!input.trimStart().startsWith('/'))
+        return [];
+    const commandName = input.trimStart().split(/\s+/)[0].toLowerCase();
+    const exactMatch = commands.find((c) => getCommandNames(c).includes(commandName));
+    // If we have an exact command match and we are in the argument area
+    if (exactMatch && argIndex > 0) {
+        if (exactMatch.getSuggestions)
+            return await exactMatch.getSuggestions(context);
+        if (exactMatch.subcommands && exactMatch.subcommands.length > 0) {
+            return await suggestSubcommands(exactMatch, context);
+        }
+        return [];
+    }
+    // Otherwise, suggest base commands
+    const search = currentPrefix.toLowerCase();
+    const matches = commands.filter((c) => !c.hidden && getCommandNames(c).some((n) => n.startsWith(search)));
+    const maxNameLength = matches.reduce((max, cmdItem) => Math.max(max, cmdItem.name.length), 0);
+    return matches.map((c) => ({
+        name: c.name.padEnd(maxNameLength + 2),
+        description: c.description,
+        command: c,
+    }));
+}
+export function findCommand(input) {
+    const firstWord = input.trim().split(/\s+/)[0].toLowerCase();
+    return commands.find((c) => getCommandNames(c).includes(firstWord));
+}
+//# sourceMappingURL=registry.js.map

package/dist/cli/commands/restore.js

@@ -0,0 +1,26 @@
+import { resolve } from 'path';
+import { CheckpointManager, getLogger } from '../../core/facades/cli-command-checkpoint.js';
+import { text } from '../locales/index.js';
+export async function handleRestoreCommand(hash, options, command) {
+    // Use optsWithGlobals() to get merged options if repo is defined globally
+    const allOptions = command.optsWithGlobals();
+    const runPath = resolve(allOptions.repo || process.cwd());
+    const manager = new CheckpointManager();
+    try {
+        getLogger().info(text.cli.restoreStarting(hash));
+        await manager.restoreToMain(runPath, hash, options.force);
+        getLogger().success(text.cli.restoreSuccess(hash));
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes('Workspace is dirty')) {
+            getLogger().error(text.cli.restoreFailedDirty);
+            getLogger().warn(text.cli.restoreFailedDirtyHint);
+        }
+        else {
+            getLogger().error(text.cli.restoreFailed(msg));
+        }
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=restore.js.map

package/dist/cli/commands/run/assistant-message.js

@@ -0,0 +1,14 @@
+import { text } from '../../locales/index.js';
+export function buildRunAssistantMessage(params) {
+    if (!params.result.success)
+        return text.cli.chatFailed(params.result.reason);
+    if (params.mode === 'review')
+        return text.cli.chatReviewCompleted;
+    if (params.mode === 'research')
+        return text.cli.chatResearchCompleted;
+    const changedFiles = params.result.changedFiles ?? [];
+    if (changedFiles.length === 0)
+        return text.cli.chatNoChanges;
+    return text.cli.chatSuccess(changedFiles.join(', '));
+}
+//# sourceMappingURL=assistant-message.js.map

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

@@ -0,0 +1,37 @@
+import { redactConfigForPrint, resolveConfig, ConfigError } from '../../../core/config/index.js';
+import { getLogger } from '../../../core/facades/cli-observability.js';
+import { text } from '../../locales/index.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));
+        if (params.outputFormat === 'json') {
+            params.writeJsonFailure({ message: text.config.loadFailed(msg), repoPath: params.repoPath });
+        }
+        return { ok: false, exitCode: 1 };
+    }
+    if (params.cliOptions.printConfig) {
+        const raw = 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 };
+}
+//# sourceMappingURL=config-resolution.js.map

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

@@ -0,0 +1,108 @@
+import { getLogger } from '../../../core/facades/cli-observability.js';
+import { text } from '../../locales/index.js';
+export function handleEarlyRunCommandErrors(params) {
+    if ((params.headlessIncludeToolInput || params.headlessIncludeToolOutput) &&
+        params.outputFormat !== 'stream-json') {
+        getLogger().error(text.cli.headlessToolPayloadRequiresStreamJson);
+        if (params.headlessOutput) {
+            params.headlessErrorWriter.writeUsageError({
+                sessionId: params.sessionIdForOutput ?? params.resumeSessionId,
+                message: text.cli.headlessToolPayloadRequiresStreamJson,
+                instruction: params.instruction,
+            });
+        }
+        return { ok: false, exitCode: 1 };
+    }
+    if (params.headlessIncludeAuthorizationDecisions && params.outputFormat === 'text') {
+        getLogger().error(text.cli.headlessAuthorizationDecisionsRequireHeadlessOutput);
+        if (params.headlessOutput) {
+            params.headlessErrorWriter.writeUsageError({
+                sessionId: params.sessionIdForOutput ?? params.resumeSessionId,
+                message: text.cli.headlessAuthorizationDecisionsRequireHeadlessOutput,
+                instruction: params.instruction,
+            });
+        }
+        return { ok: false, exitCode: 1 };
+    }
+    if (params.explicitInstruction && params.printInstruction) {
+        if (params.headlessOutput) {
+            getLogger().error(text.cli.printInstructionConflict);
+            params.headlessErrorWriter.writeUsageError({
+                message: text.cli.printInstructionConflict,
+                instruction: params.printInstruction,
+            });
+            return { ok: false, exitCode: 1 };
+        }
+        getLogger().error(text.cli.printInstructionConflict, true);
+        return { ok: false, exitCode: 1 };
+    }
+    if (params.continueSession && params.resumeSessionId) {
+        if (params.headlessOutput) {
+            getLogger().error(text.cli.continueResumeConflict);
+            params.headlessErrorWriter.writeUsageError({
+                message: text.cli.continueResumeConflict,
+                sessionId: params.resumeSessionId,
+                instruction: params.instruction,
+            });
+            return { ok: false, exitCode: 1 };
+        }
+        getLogger().error(text.cli.continueResumeConflict, true);
+        return { ok: false, exitCode: 1 };
+    }
+    if (params.rawOutputProfile && params.outputFormat !== 'stream-json') {
+        getLogger().error(text.cli.outputProfileRequiresStreamJson);
+        if (params.outputFormat === 'json') {
+            params.headlessErrorWriter.writeJsonFailure({
+                sessionId: params.sessionIdForOutput,
+                instruction: params.instruction,
+                message: text.cli.outputProfileRequiresStreamJson,
+                exitCode: 1,
+            });
+        }
+        return { ok: false, exitCode: 1 };
+    }
+    if (params.outputFormat === 'stream-json') {
+        const outputProfile = params.outputProfileForStreamJson;
+        if (outputProfile !== 'native' && outputProfile !== 'anthropic' && outputProfile !== 'openai') {
+            getLogger().error(text.cli.invalidOutputProfile(outputProfile));
+            params.headlessErrorWriter.writeUsageError({
+                sessionId: params.sessionIdForOutput ?? params.resumeSessionId,
+                message: text.cli.invalidOutputProfile(outputProfile),
+            });
+            return { ok: false, exitCode: 1 };
+        }
+        if (outputProfile === 'openai' &&
+            (params.headlessIncludeToolInput || params.headlessIncludeToolOutput)) {
+            getLogger().error(text.cli.headlessToolPayloadNotSupportedWithOpenAiProfile);
+            params.headlessErrorWriter.writeUsageError({
+                sessionId: params.sessionIdForOutput ?? params.resumeSessionId,
+                message: text.cli.headlessToolPayloadNotSupportedWithOpenAiProfile,
+                instruction: params.instruction,
+            });
+            return { ok: false, exitCode: 1 };
+        }
+        if (params.headlessIncludeAuthorizationDecisions &&
+            (outputProfile === 'anthropic' || outputProfile === 'openai')) {
+            getLogger().error(text.cli.headlessAuthorizationDecisionsNotSupportedWithStrictProfiles);
+            params.headlessErrorWriter.writeUsageError({
+                sessionId: params.sessionIdForOutput ?? params.resumeSessionId,
+                message: text.cli.headlessAuthorizationDecisionsNotSupportedWithStrictProfiles,
+                instruction: params.instruction,
+            });
+            return { ok: false, exitCode: 1 };
+        }
+    }
+    if (params.jsonSchemaSpec && params.outputFormat !== 'json') {
+        getLogger().error(text.cli.jsonSchemaRequiresJsonOutput);
+        if (params.outputFormat === 'stream-json') {
+            params.headlessErrorWriter.writeUsageError({
+                sessionId: params.sessionIdForOutput,
+                message: text.cli.jsonSchemaRequiresJsonOutput,
+                instruction: params.instruction,
+            });
+        }
+        return { ok: false, exitCode: 1 };
+    }
+    return { ok: true };
+}
+//# sourceMappingURL=early-errors.js.map