salmon-loop 0.2.3

package/dist/cli/commands/run/structured-output.js

@@ -0,0 +1,106 @@
+import { resolve } from 'path';
+import { readFile, stat } from '../../../core/adapters/fs/node-fs.js';
+import { LIMITS } from '../../../core/config/limits.js';
+import { JsonSchemaValidator } from '../../../core/structured-output/index.js';
+export async function loadJsonSchema(params) {
+    const value = params.schema.trim();
+    if (!value)
+        throw new Error('Empty schema');
+    const maxBytes = LIMITS.maxJsonSchemaBytes;
+    const inputBytes = Buffer.byteLength(value, 'utf8');
+    if (inputBytes > maxBytes) {
+        throw new Error(`Schema input exceeds maximum size: ${inputBytes} bytes (max ${maxBytes} bytes).`);
+    }
+    if (value.startsWith('{') || value.startsWith('[')) {
+        return JSON.parse(value);
+    }
+    const schemaPath = resolve(params.repoPath, value);
+    const stats = await stat(schemaPath);
+    if (typeof stats?.size === 'number' && stats.size > maxBytes) {
+        throw new Error(`Schema input exceeds maximum size: ${stats.size} bytes (max ${maxBytes} bytes).`);
+    }
+    const raw = await readFile(schemaPath, 'utf8');
+    return JSON.parse(raw);
+}
+export async function buildStructuredOutputState(params) {
+    if (params.outputFormat !== 'json' || !params.jsonSchemaSpec || !params.result.success) {
+        return { ok: true, candidate: null };
+    }
+    try {
+        const schema = await loadJsonSchema({
+            schema: params.jsonSchemaSpec,
+            repoPath: params.repoPath,
+        });
+        const validator = new JsonSchemaValidator();
+        const candidate = {
+            command: 'run',
+            repo_path: params.repoPath,
+            instruction: params.instruction,
+            session_id: params.sessionIdForOutput,
+            success: Boolean(params.result.success),
+            exit_code: params.exitCode,
+            reason: params.result.reason,
+            reason_code: params.reasonCode,
+            attempts: params.result.attempts,
+            changed_files: params.result.changedFiles ?? [],
+            audit_path: params.result.auditPath,
+            error_code: params.result.errorCode,
+            authorization_summary: params.result.authorizationSummary,
+            authorization_decisions: Array.isArray(params.result.authorizationDecisions)
+                ? params.result.authorizationDecisions.map((d) => ({
+                    call_id: d.callId,
+                    tool_name: d.toolName,
+                    phase: d.phase,
+                    outcome: d.outcome,
+                    source: d.source,
+                    reason: d.reason,
+                    ttl_ms: d.ttlMs,
+                    persist: d.persist,
+                    risk_level: d.riskLevel,
+                    side_effects: d.sideEffects,
+                    timestamp: d.timestamp,
+                }))
+                : undefined,
+            usage: params.result.usage
+                ? {
+                    input_tokens: params.result.usage.inputTokens,
+                    output_tokens: params.result.usage.outputTokens,
+                    total_tokens: params.result.usage.totalTokens,
+                }
+                : undefined,
+            budget_summary: params.result.budgetSummary
+                ? {
+                    attempt_count: params.result.budgetSummary.attemptCount,
+                    adjustment_count: params.result.budgetSummary.adjustmentCount,
+                    alert_count: params.result.budgetSummary.alertCount,
+                    critical_drop_count: params.result.budgetSummary.criticalDropCount,
+                    avg_utilization: params.result.budgetSummary.avgUtilization,
+                    truncation_rate: params.result.budgetSummary.truncationRate,
+                    success_rate: params.result.budgetSummary.successRate,
+                }
+                : undefined,
+        };
+        const validation = validator.validate({ schema, data: candidate });
+        if (!validation.ok) {
+            return {
+                ok: false,
+                candidate,
+                errorCode: validation.error?.code,
+                errorReason: validation.error?.message,
+                errorKind: 'validation_failed',
+            };
+        }
+        return { ok: true, candidate };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            candidate: null,
+            errorCode: 'SCHEMA_INVALID',
+            errorReason: msg,
+            errorKind: 'schema_invalid',
+        };
+    }
+}
+//# sourceMappingURL=structured-output.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1,28 @@
+export function resolveOutputFormat(raw) {
+    if (raw === 'text' || raw === 'stream-json' || raw === 'json')
+        return raw;
+    return undefined;
+}
+export function validateRunCommandOptions(params) {
+    const { parsed } = params;
+    if (parsed.explicitInstruction && parsed.printInstruction) {
+        return { ok: false, code: 'USAGE_ERROR', message: 'PRINT_INSTRUCTION_CONFLICT' };
+    }
+    if (parsed.continueSession && parsed.resumeSessionId) {
+        return { ok: false, code: 'USAGE_ERROR', message: 'CONTINUE_RESUME_CONFLICT' };
+    }
+    if (parsed.rawOutputProfile && parsed.outputFormat !== 'stream-json') {
+        return { ok: false, code: 'USAGE_ERROR', message: 'OUTPUT_PROFILE_REQUIRES_STREAM_JSON' };
+    }
+    if (parsed.outputFormat === 'stream-json') {
+        const outputProfile = parsed.outputProfileForStreamJson;
+        if (outputProfile !== 'native' && outputProfile !== 'anthropic' && outputProfile !== 'openai') {
+            return { ok: false, code: 'USAGE_ERROR', message: 'INVALID_OUTPUT_PROFILE' };
+        }
+    }
+    if (parsed.jsonSchemaSpec && parsed.outputFormat !== 'json') {
+        return { ok: false, code: 'USAGE_ERROR', message: 'JSON_SCHEMA_REQUIRES_JSON' };
+    }
+    return { ok: true };
+}
+//# sourceMappingURL=validate-options.js.map

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

@@ -0,0 +1,36 @@
+import { getLogger } from '../../../core/facades/cli-observability.js';
+import { text } from '../../locales/index.js';
+export function resolveVerboseLevel(raw) {
+    if (raw === true)
+        return 'basic';
+    if (typeof raw === 'string')
+        return raw;
+    return undefined;
+}
+export function logRunVerboseSummary(params) {
+    if (!params.verboseLevel)
+        return;
+    getLogger().setVerbose(params.verboseLevel);
+    getLogger().cyan(text.cli.runningWith);
+    getLogger().log(text.cli.instruction(params.instruction));
+    if (params.verify) {
+        getLogger().log(text.cli.verify(params.verify));
+    }
+    getLogger().log(text.cli.repoPath(params.repoPath));
+    if (params.file)
+        getLogger().log(text.cli.contextFile(params.file));
+    if (params.selection)
+        getLogger().log(text.cli.contextSelection(params.selection.length));
+    if (params.allowedToolRules.length > 0) {
+        getLogger().log(text.cli.allowedTools(params.allowedToolRules.join(', ')));
+    }
+    if (params.disallowedToolRules.length > 0) {
+        getLogger().log(text.cli.disallowedTools(params.disallowedToolRules.join(', ')));
+    }
+    if (params.dryRun)
+        getLogger().warn(text.cli.dryRunEnabled);
+    if (params.configPath) {
+        getLogger().log(text.cli.configPath(params.configPath));
+    }
+}
+//# sourceMappingURL=verbose.js.map

package/dist/cli/commands/run.js

@@ -0,0 +1,2 @@
+export { handleRunCommand } from './run/handler.js';
+//# sourceMappingURL=run.js.map

package/dist/cli/commands/serve.js

@@ -0,0 +1,323 @@
+import { buildA2AAgentCard, buildSidecarRouteDescriptors, createAcpFormalAgent, createAgentServerRuntime, createInteractionFacade, createSalmonTaskExecutor, createTaskEventBus, createPluginRegistry, createPromptRegistry, defaultSidecarRouteCatalog, defaultPathAdapter, getSidecarListenOptions, getUserAcpSessionStorePath, GitSnapshotCheckpointService, getLogger, mkdir, PlainReporter, PluginLoader, resolveConfig, resolveExtensions, runSalmonLoop, setPluginRegistry, setPromptRegistry, startAcpStdioServer, StderrReporter, } from '../../core/facades/cli-serve.js';
+import { createTerminalAuthorizationProvider } from '../authorization/provider.js';
+import { text } from '../locales/index.js';
+import { resolveAuditScope } from '../utils/audit-scope.js';
+import { createOutcomeReporter } from '../utils/outcome-reporter.js';
+import { createRuntimeLlmAndWarn } from './run/runtime-llm.js';
+function parsePort(value, fallback) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : Number.NaN;
+}
+function buildSidecarHandlers(deps) {
+    return {
+        health: async () => Response.json({ status: 'ok' }),
+        status: async () => Response.json({ state: 'idle' }),
+        info: async () => Response.json({
+            name: deps.name,
+            version: deps.version,
+            capabilities: deps.capabilities,
+        }),
+        abort: async () => new Response('Abort not implemented for this runtime', { status: 501 }),
+        workspace_files: async () => new Response('Workspace file access not enabled', { status: 501 }),
+        logs_stream: async () => new Response('Log streaming not enabled', { status: 501 }),
+        config_patch: async () => new Response('Config patch not enabled', { status: 501 }),
+    };
+}
+export function registerServeCommands(program) {
+    const serve = program
+        .command('serve')
+        .description(text.cli.serveDescription)
+        .option('--a2a-host <host>', text.cli.a2aHostOption)
+        .option('--a2a-port <port>', text.cli.a2aPortOption)
+        .option('--a2a-token <token>', text.cli.a2aTokenOption, (value, previous) => previous.concat([value]), [])
+        .option('--no-acp-stdio', text.cli.acpStdioDisableOption)
+        .option('--sidecar-socket <path>', text.cli.sidecarSocketOption)
+        .option('--sidecar-allow-conditional', text.cli.sidecarAllowConditionalOption)
+        .option('--no-color', text.cli.noColorOption)
+        .action(handleServeCommand);
+    serve
+        .command('acp')
+        .description(text.cli.serveAcpDescription)
+        .option('--no-color', text.cli.noColorOption)
+        .action(handleServeAcpCommand);
+}
+export async function handleServeCommand(_options, command) {
+    const allOptions = command.optsWithGlobals();
+    const defaultRepoPath = defaultPathAdapter.resolve(allOptions.repo || process.cwd());
+    const resolvedConfig = await resolveConfig({ repoRoot: defaultRepoPath });
+    const serverConfig = resolvedConfig.server;
+    const auditScopeResolution = resolveAuditScope({
+        cliValue: allOptions.auditScope,
+        configValue: resolvedConfig.observability.audit.scope,
+    });
+    if (!auditScopeResolution.ok) {
+        getLogger().error(text.cli.invalidAuditScope(auditScopeResolution.invalid), true);
+        process.exit(1);
+    }
+    const auditScope = auditScopeResolution.value;
+    const rawA2aHost = allOptions.a2aHost ?? serverConfig?.a2a?.host;
+    const a2aHost = String(rawA2aHost ?? '127.0.0.1');
+    const rawA2aPort = allOptions.a2aPort ?? serverConfig?.a2a?.port;
+    const a2aPort = parsePort(rawA2aPort, 7431);
+    if (!Number.isFinite(a2aPort) || a2aPort <= 0) {
+        getLogger().error(text.cli.invalidA2APort(String(rawA2aPort ?? '')), true);
+        process.exit(1);
+    }
+    const acpStdioEnabled = allOptions.acpStdio !== false;
+    if (acpStdioEnabled) {
+        getLogger().setReporter(allOptions.color === false ? new StderrReporter() : new PlainReporter());
+    }
+    const sidecarListen = typeof allOptions.sidecarSocket === 'string' && allOptions.sidecarSocket.length > 0
+        ? { type: 'pipe', path: allOptions.sidecarSocket }
+        : getSidecarListenOptions();
+    const allowConditional = allOptions.sidecarAllowConditional ?? serverConfig?.sidecar?.allowConditional ?? false;
+    if (sidecarListen.type === 'pipe' && !sidecarListen.path.startsWith('\\\\.\\pipe\\')) {
+        await mkdir(defaultPathAdapter.dirname(sidecarListen.path), { recursive: true });
+    }
+    const languagePlugins = createPluginRegistry();
+    setPluginRegistry(languagePlugins);
+    setPromptRegistry(createPromptRegistry());
+    await PluginLoader.loadPlugins(languagePlugins, defaultRepoPath);
+    const extensions = await resolveExtensions({ repoRoot: defaultRepoPath });
+    const { llm } = createRuntimeLlmAndWarn({
+        llmConfig: resolvedConfig.llm,
+        langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
+    });
+    const outcomeReporter = createOutcomeReporter({
+        enabled: resolvedConfig.observability.langfuse.outcome,
+        endpoint: resolvedConfig.observability.langfuse.endpoint,
+        llmBaseUrl: resolvedConfig.llm.api.baseUrl,
+        langfuseApiKey: resolvedConfig.observability.langfuse.apiKey,
+    });
+    const defaultAuthorizationProvider = createTerminalAuthorizationProvider({
+        config: resolvedConfig.toolAuthorization,
+        extensions: extensions.resolved,
+        forceNonInteractive: true,
+    });
+    const executor = createSalmonTaskExecutor({
+        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, fileSystemOverride, }) => {
+            const effectiveRepoPath = repoPath ?? defaultRepoPath;
+            return await runSalmonLoop({
+                instruction,
+                repoPath: effectiveRepoPath,
+                llm,
+                mode: mode,
+                verify: resolvedConfig.verify.command,
+                strategy: 'worktree',
+                applyBackOnDirty: '3way',
+                environmentMode: 'strict',
+                llmOutput: resolvedConfig.llmOutput,
+                outcomeReporter,
+                langfuseSessionId: resolvedConfig.observability.langfuse.sessionId,
+                langfuseUserId: resolvedConfig.observability.langfuse.userId,
+                auditScope,
+                languagePlugins,
+                fileSystemOverride,
+                authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
+                authorizationMode,
+                extensions: extensions.resolved,
+                onEvent,
+                signal,
+            });
+        },
+    });
+    const sharedEventBus = createTaskEventBus();
+    const checkpointService = new GitSnapshotCheckpointService(undefined, resolvedConfig.server?.acp?.checkpointManifest);
+    await checkpointService.gc({
+        repoPath: defaultRepoPath,
+        olderThanMs: 1000 * 60 * 60 * 24 * 14,
+        maxPerSession: 30,
+    });
+    const acpFacade = createInteractionFacade({
+        executeTask: executor.execute,
+        eventBus: sharedEventBus,
+    });
+    const tokens = Array.isArray(allOptions.a2aToken)
+        ? allOptions.a2aToken.filter((token) => typeof token === 'string')
+        : [];
+    const authTokens = tokens.length > 0 ? tokens : (serverConfig?.a2a?.tokens ?? []);
+    // Create Express middleware for authentication
+    const authMiddleware = authTokens.length > 0
+        ? (req, res, next) => {
+            const authHeader = req.headers.authorization;
+            if (!authHeader) {
+                res.status(401).json({ error: 'Unauthorized' });
+                return;
+            }
+            const [scheme, token] = authHeader.split(' ');
+            if (scheme?.toLowerCase() !== 'bearer' || !authTokens.includes(token)) {
+                res.status(401).json({ error: 'Unauthorized' });
+                return;
+            }
+            next();
+        }
+        : undefined;
+    const capabilities = [{ id: 'patch', title: 'Patch code' }];
+    const agentCard = buildA2AAgentCard({
+        name: 'salmon-loop',
+        url: `http://${a2aHost}:${a2aPort}`,
+        capabilities,
+        security: authTokens.length > 0 ? [{ type: 'http', scheme: 'bearer' }] : [],
+    });
+    const sidecarRoutes = buildSidecarRouteDescriptors({
+        strict: true,
+        catalog: defaultSidecarRouteCatalog,
+        handlers: buildSidecarHandlers({
+            name: 'salmon-loop',
+            version: '0.2.0',
+            capabilities,
+        }),
+    });
+    if (acpStdioEnabled) {
+        startAcpStdioServer((conn) => createAcpFormalAgent({
+            conn,
+            agentInfo: { name: 'salmon-loop', version: '0.2.0' },
+            defaultModeId: resolvedConfig.permissionMode,
+            checkpointReader: {
+                listBySession: async ({ repoPath, sessionId, limit }) => await checkpointService.list({ repoPath, sessionId, limit }),
+                getById: async ({ repoPath, checkpointId }) => (await checkpointService.loadWithStatus({ repoPath, checkpointId })).handle,
+                probeById: async ({ repoPath, checkpointId }) => {
+                    const status = await checkpointService.loadWithStatus({ repoPath, checkpointId });
+                    return { valid: Boolean(status.handle), reason: status.reason };
+                },
+            },
+            facade: acpFacade,
+            sessionPersistencePath: getUserAcpSessionStorePath(),
+            sessionStorePolicy: resolvedConfig.server?.acp?.sessionStore,
+            eventBus: sharedEventBus,
+        }));
+        getLogger().info(text.cli.acpStdioStarted('n/a (stdio)'));
+        // Handle SIGINT for graceful shutdown
+        process.on('SIGINT', () => {
+            getLogger().info('Received SIGINT, shutting down ACP server...');
+            process.stdin.destroy();
+            process.exit(0);
+        });
+    }
+    const fastify = (await import('fastify')).default;
+    const runtime = createAgentServerRuntime({
+        createFastify: () => fastify(),
+        a2a: {
+            buildAgentCard: () => agentCard,
+            executeTask: executor.execute,
+            eventBus: sharedEventBus,
+            authMiddleware,
+        },
+        sidecar: {
+            routes: sidecarRoutes,
+            allowConditional,
+        },
+        listen: {
+            a2a: { host: a2aHost, port: a2aPort },
+            sidecar: sidecarListen,
+        },
+        a2aBaseUrl: `http://${a2aHost}:${a2aPort}`,
+    });
+    // Handle SIGINT for graceful shutdown
+    process.on('SIGINT', () => {
+        getLogger().info('Received SIGINT, shutting down server...');
+        runtime.close().then(() => process.exit(0));
+    });
+    await runtime.start();
+    const sidecarAddress = sidecarListen.type === 'tcp'
+        ? `http://${sidecarListen.host}:${sidecarListen.port}`
+        : sidecarListen.path;
+    getLogger().success(text.cli.serveStarted(a2aHost, a2aPort, sidecarAddress));
+}
+export async function handleServeAcpCommand(_options, command) {
+    const allOptions = command.optsWithGlobals();
+    const defaultRepoPath = defaultPathAdapter.resolve(allOptions.repo || process.cwd());
+    const resolvedConfig = await resolveConfig({ repoRoot: defaultRepoPath });
+    getLogger().setReporter(allOptions.color === false ? new StderrReporter() : new PlainReporter());
+    const languagePlugins = createPluginRegistry();
+    setPluginRegistry(languagePlugins);
+    setPromptRegistry(createPromptRegistry());
+    await PluginLoader.loadPlugins(languagePlugins, defaultRepoPath);
+    const extensions = await resolveExtensions({ repoRoot: defaultRepoPath });
+    const { llm } = createRuntimeLlmAndWarn({
+        llmConfig: resolvedConfig.llm,
+        langfuseEnabled: resolvedConfig.observability.langfuse.enabled,
+    });
+    const auditScopeResolution = resolveAuditScope({
+        cliValue: allOptions.auditScope,
+        configValue: resolvedConfig.observability.audit.scope,
+    });
+    if (!auditScopeResolution.ok) {
+        getLogger().error(text.cli.invalidAuditScope(auditScopeResolution.invalid), true);
+        process.exit(1);
+    }
+    const outcomeReporter = createOutcomeReporter({
+        enabled: resolvedConfig.observability.langfuse.outcome,
+        endpoint: resolvedConfig.observability.langfuse.endpoint,
+        llmBaseUrl: resolvedConfig.llm.api.baseUrl,
+        langfuseApiKey: resolvedConfig.observability.langfuse.apiKey,
+    });
+    const defaultAuthorizationProvider = createTerminalAuthorizationProvider({
+        config: resolvedConfig.toolAuthorization,
+        extensions: extensions.resolved,
+        forceNonInteractive: true,
+    });
+    const executor = createSalmonTaskExecutor({
+        runLoop: async ({ instruction, mode, repoPath, onEvent, signal, authorizationProvider, authorizationMode, }) => {
+            const effectiveRepoPath = repoPath ?? defaultRepoPath;
+            return await runSalmonLoop({
+                instruction,
+                repoPath: effectiveRepoPath,
+                llm,
+                mode: mode,
+                verify: resolvedConfig.verify.command,
+                strategy: 'worktree',
+                applyBackOnDirty: '3way',
+                environmentMode: 'strict',
+                llmOutput: resolvedConfig.llmOutput,
+                outcomeReporter,
+                langfuseSessionId: resolvedConfig.observability.langfuse.sessionId,
+                langfuseUserId: resolvedConfig.observability.langfuse.userId,
+                auditScope: auditScopeResolution.value,
+                languagePlugins,
+                authorizationProvider: authorizationProvider ?? defaultAuthorizationProvider,
+                authorizationMode,
+                extensions: extensions.resolved,
+                onEvent,
+                signal,
+            });
+        },
+    });
+    const sharedEventBus = createTaskEventBus();
+    const checkpointService = new GitSnapshotCheckpointService(undefined, resolvedConfig.server?.acp?.checkpointManifest);
+    await checkpointService.gc({
+        repoPath: defaultRepoPath,
+        olderThanMs: 1000 * 60 * 60 * 24 * 14,
+        maxPerSession: 30,
+    });
+    const acpFacade = createInteractionFacade({
+        executeTask: executor.execute,
+        eventBus: sharedEventBus,
+    });
+    startAcpStdioServer((conn) => createAcpFormalAgent({
+        conn,
+        agentInfo: { name: 'salmon-loop', version: '0.2.0' },
+        defaultModeId: resolvedConfig.permissionMode,
+        checkpointReader: {
+            listBySession: async ({ repoPath, sessionId, limit }) => await checkpointService.list({ repoPath, sessionId, limit }),
+            getById: async ({ repoPath, checkpointId }) => (await checkpointService.loadWithStatus({ repoPath, checkpointId })).handle,
+            probeById: async ({ repoPath, checkpointId }) => {
+                const status = await checkpointService.loadWithStatus({ repoPath, checkpointId });
+                return { valid: Boolean(status.handle), reason: status.reason };
+            },
+        },
+        facade: acpFacade,
+        sessionPersistencePath: getUserAcpSessionStorePath(),
+        sessionStorePolicy: resolvedConfig.server?.acp?.sessionStore,
+        eventBus: sharedEventBus,
+    }));
+    getLogger().info(text.cli.acpStdioStarted('n/a (stdio)'));
+    process.on('SIGINT', () => {
+        getLogger().info('Received SIGINT, shutting down ACP server...');
+        process.stdin.destroy();
+        process.exit(0);
+    });
+}
+//# sourceMappingURL=serve.js.map

package/dist/cli/commands/session.js

@@ -0,0 +1,77 @@
+import { InputHistoryManager } from '../../core/facades/cli-command-session.js';
+import { text } from '../locales/index.js';
+import { buildTranscriptMessages } from '../ui/utils/transcript.js';
+import { parseSuggestionContext } from './utils.js';
+export const sessionCommand = {
+    name: '/session',
+    description: text.cli.commandSessions,
+    order: 60,
+    getSuggestions: async ({ sessionManager, input }) => {
+        const { argIndex, currentPrefix } = parseSuggestionContext(input);
+        // Level 1: Suggest sessions
+        if (argIndex === 1) {
+            const sessions = await sessionManager.listSessions();
+            const search = currentPrefix.toLowerCase();
+            return sessions
+                .filter((s) => s.id.toLowerCase().startsWith(search) || s.name.toLowerCase().includes(search))
+                .map((s) => ({
+                name: s.id.slice(0, 8),
+                description: `${s.name} (${new Date(s.updatedAt).toLocaleDateString()})`,
+            }));
+        }
+        return [];
+    },
+    execute: async ({ emit, sessionManager, input, dispatch }) => {
+        const args = input.trim().split(/\s+/).slice(1);
+        if (args.length > 0) {
+            const sessionId = args[0];
+            try {
+                await sessionManager.resumeSession(sessionId);
+                dispatch({
+                    type: 'HYDRATE_TRANSCRIPT',
+                    payload: buildTranscriptMessages(sessionManager.getMessages(), { limit: 200 }),
+                });
+                dispatch({ type: 'SET_INPUT', payload: '' });
+                const current = sessionManager.getCurrent();
+                const repoPath = typeof current?.meta?.repoPath === 'string' && current.meta.repoPath.trim()
+                    ? current.meta.repoPath
+                    : process.cwd();
+                const historyManager = new InputHistoryManager(repoPath);
+                await historyManager.init();
+                const inputHistory = await historyManager.load(current.meta.id);
+                dispatch({ type: 'SET_INPUT_HISTORY', payload: inputHistory });
+                emit({
+                    type: 'log',
+                    level: 'info',
+                    message: `Switched to session: ${sessionId}`,
+                    timestamp: new Date(),
+                });
+            }
+            catch (error) {
+                emit({
+                    type: 'log',
+                    level: 'error',
+                    message: `Failed to switch session: ${error instanceof Error ? error.message : String(error)}`,
+                });
+            }
+            return;
+        }
+        const sessions = await sessionManager.listSessions();
+        if (sessions.length === 0) {
+            emit({
+                type: 'log',
+                level: 'info',
+                message: text.cli.noSessionsFound,
+                timestamp: new Date(),
+            });
+            return;
+        }
+        emit({
+            type: 'log',
+            level: 'info',
+            message: 'Type "/session " (with a space) to select a session from the interactive list.',
+            timestamp: new Date(),
+        });
+    },
+};
+//# sourceMappingURL=session.js.map