@lotagate/cli 0.1.22 → 0.1.23

package/dist/presentation/tui/tui-application.js

@@ -1,675 +0,0 @@
-import { createElement } from 'react';
-import { render } from 'ink';
-import { AuthenticationService } from '../../application/auth/authentication-service.js';
-import { ChatService } from '../../application/chat/chat-service.js';
-import { createLotaGateClient } from '../../infrastructure/sdk/lotagate-client-factory.js';
-import { SdkChatCompletionAdapter } from '../../infrastructure/sdk/chat-completion-adapter.js';
-import { detectTerminalCapabilities } from './terminal-capabilities.js';
-import { enterInteractiveScreen, exitInteractiveScreen } from './terminal-screen.js';
-import { createImageAttachment, normalizeImage } from '../../infrastructure/clipboard/image-normalizer.js';
-import { ToolPolicy } from '@lotagate/agent-sdk';
-import { PlanGenerator } from '../../application/orchestration/plan-generator.js';
-import { PendingAttachmentStore } from '../../application/chat/pending-attachment-store.js';
-import { HookRuntime } from '../../infrastructure/extensions/hook-runtime.js';
-import { ShellToolExecutor } from '../../infrastructure/shell/shell-tool-executor.js';
-import { resolveSkillRootScopes } from '../../infrastructure/extensions/skill-roots.js';
-import { CLI_VERSION } from '../../version.js';
-import { asCliError, CliError } from '../../domain/errors/cli-error.js';
-import { CLI_ERROR_CODES } from '../../domain/errors/error-codes.js';
-import { InkTuiBridge } from './ink/tui-bridge.js';
-import { LotaGateTui } from './ink/lotagate-tui.js';
-import { estimateTurnUsage } from '../../infrastructure/tokens/tiktoken-token-estimator.js';
-import { WorkspaceFileIndex } from '../../application/workspace/workspace-file-index.js';
-import { ProjectSessionAccess } from '../../application/session/project-session-access.js';
-import { PluginContributionRegistry } from '../../application/extensions/plugin-contribution-registry.js';
-import { createCapabilitySnapshot } from '../../application/agent/capability-profile.js';
-import { SystemPromptBuilder } from '../../application/agent/system-prompt-builder.js';
-import { createTuiCommandHost } from './tui-command-host-factory.js';
-import { workspaceFileSuggestions } from './tui-file-suggestions.js';
-import { buildTuiAttachmentInput } from './tui-attachment-input.js';
-import { AUTH_LOGIN_HINT, MODEL_SELECT_HINT, formatCliErrorMessage, formatCommandHint } from '../../application/commands/command-hints.js';
-import { AgentRunTracker } from '../../application/agent/agent-run-tracker.js';
-import { buildAgentInputContext } from '../../application/agent/agent-input-context.js';
-import { prepareCliAgent } from '../../application/agent/cli-agent-execution-service.js';
-import { TuiToolApprovalCoordinator } from './tui-tool-approval.js';
-import { TuiContextService } from './tui-context-service.js';
-import { createTuiClipboardPasteHandlers } from './tui-clipboard-paste-handlers.js';
-import { dispatchTuiPrompt } from './tui-prompt-dispatcher.js';
-import { CliAgentSessionStore, retainLatestCompaction } from '../../application/agent/agent-session-store.js';
-import { createTuiContextManagement } from './tui-context-compaction.js';
-import { compactManualTuiSession } from './tui-manual-compaction.js';
-import { resolveInitialModel } from './tui-initial-model.js';
-import { cancelTuiResponse, handleTuiInterrupt, isAbortError, runTuiHookEvent, throwIfAborted } from './tui-lifecycle-actions.js';
-import { loadExecutionConfig } from '../../application/config/execution-config.js';
-import { resumeTuiGoal, runTuiGoal } from './tui-goal-controller.js';
-import { runTuiSkill } from './tui-skill-controller.js';
-import { SubagentJobRegistry } from '../../application/orchestration/cli-subagent-service.js';
-import { formatResumeCommand } from './tui-application-contract.js';
-import { runTuiAgentEvents } from './tui-agent-event-runner.js';
-import { createTurnId, recordTurnCompletion, recordTurnFailure, recordTurnStart } from '../../application/session/session-turn-lifecycle.js';
-export class TuiApplication {
-    runtime;
-    cwd;
-    options;
-    input;
-    output;
-    renderer;
-    pendingAttachments = new PendingAttachmentStore();
-    session;
-    hookRuntime;
-    hooks = [];
-    skillRootScopes = [];
-    enabledPluginNames = [];
-    pluginMcpConfig = {};
-    activeAbortController;
-    activePromptRun;
-    activeForegroundRun;
-    exitArmedUntil = 0;
-    lastInterruptAt = 0;
-    printResumeCommandOnExit = false;
-    activeModel = null;
-    activeProfile = null;
-    approvals;
-    contextService;
-    agentSessionStore = new CliAgentSessionStore();
-    subagentJobs = new SubagentJobRegistry();
-    constructor(runtime, cwd, options = {}) {
-        this.runtime = runtime;
-        this.cwd = cwd;
-        this.options = options;
-        this.input = options.input ?? process.stdin;
-        this.output = options.output ?? process.stdout;
-        this.renderer = new InkTuiBridge();
-        this.contextService = new TuiContextService(this.runtime, this.cwd);
-        this.approvals = new TuiToolApprovalCoordinator({
-            renderer: this.renderer,
-            runtime: this.runtime,
-            getSessionId: () => this.session?.id,
-            getActiveSignal: () => this.activeAbortController?.signal,
-        });
-        this.renderer.setInterruptHandler(() => this.handleInterrupt());
-        this.renderer.setCancelHandler(() => cancelTuiResponse(this.activeAbortController, this.renderer));
-        const clipboard = createTuiClipboardPasteHandlers({
-            platform: this.runtime.platform,
-            notify: (message) => this.renderer.notice(message),
-            attachImage: (image) => this.attachClipboardImage(image, false),
-        });
-        this.renderer.setImagePasteHandler(clipboard.image);
-        this.renderer.setTextPasteHandler(clipboard.text);
-        this.renderer.setClearAttachmentsHandler(() => {
-            this.pendingAttachments.clear();
-            this.renderer.setPendingAttachments([]);
-        });
-    }
-    async run() {
-        const capabilities = detectTerminalCapabilities(this.input, this.output);
-        if (!capabilities.isInteractive) {
-            this.output.write('Interactive TUI requires a terminal. Use `lotagate chat "prompt"` for non-interactive streaming.\n');
-            return 2;
-        }
-        enterInteractiveScreen(this.output);
-        const ink = render(createElement(LotaGateTui, { bridge: this.renderer }), { stdin: this.input, stdout: this.output, exitOnCtrlC: false });
-        const onInterrupt = () => this.handleInterrupt();
-        process.on('SIGINT', onInterrupt);
-        let finalStatus = 'completed';
-        try {
-            const identity = await this.runtime.projectTrust.inspect(this.cwd);
-            let trusted = await this.runtime.projectTrust.isTrusted(identity);
-            let loadedConfig = await this.runtime.configLoader.load(this.cwd, { includeProject: trusted });
-            let initialModel = await resolveInitialModel(this.runtime, this.cwd, loadedConfig.config);
-            let loaded = { ...loadedConfig, config: { ...loadedConfig.config, model: initialModel } };
-            this.activeModel = loaded.config.model;
-            this.activeProfile = loaded.config.profile;
-            this.renderer.setWelcome({ version: CLI_VERSION, cwd: identity.canonicalPath, model: loaded.config.model, profile: loaded.config.profile, trusted });
-            this.renderer.setFileSuggestions([]);
-            if (!trusted) {
-                trusted = await this.renderer.confirmTrust();
-                if (trusted) {
-                    await this.runtime.projectTrust.grant(identity);
-                    loadedConfig = await this.runtime.configLoader.load(this.cwd);
-                    initialModel = await resolveInitialModel(this.runtime, this.cwd, loadedConfig.config);
-                    loaded = { ...loadedConfig, config: { ...loadedConfig.config, model: initialModel } };
-                    this.activeModel = loaded.config.model;
-                    this.activeProfile = loaded.config.profile;
-                    this.renderer.setWelcome({ version: CLI_VERSION, cwd: identity.canonicalPath, model: this.activeModel, profile: this.activeProfile, trusted: true });
-                    this.renderer.notice('Project trusted.');
-                }
-                else
-                    this.renderer.notice('Project remains untrusted; local tools and extensions stay disabled.');
-            }
-            if (trusted)
-                await this.runtime.workspaceSettings.ensureInitialized(identity.canonicalPath);
-            await this.reloadExtensions(trusted, loaded.config.approvalMode, identity.canonicalPath);
-            if (this.options.sessionId !== undefined) {
-                const resumed = await this.runtime.sessionStore.get(this.options.sessionId);
-                if (resumed === undefined)
-                    throw new Error(`Session not found: ${this.options.sessionId}`);
-                if (resumed.projectFingerprint !== identity.fingerprint)
-                    throw new Error('Session belongs to another project.');
-                this.session = resumed;
-                this.renderer.status(`Resuming session ${resumed.id}`);
-                for (const entry of retainLatestCompaction(await this.runtime.sessionStore.readTranscript(resumed.id))) {
-                    if (entry.type === 'user')
-                        this.renderer.userPrompt(entry.content);
-                    else if (entry.type === 'assistant') {
-                        this.renderer.beginAssistant();
-                        this.renderer.assistantDelta(entry.content);
-                        this.renderer.finishAssistant();
-                    }
-                }
-            }
-            else
-                this.session = await this.runtime.sessionStore.create({ projectFingerprint: identity.fingerprint, cwd: identity.canonicalPath, model: loaded.config.model, profile: loaded.config.profile, status: 'active' });
-            await this.refreshContextUsage();
-            await this.runHookEvent('session.start', identity.canonicalPath, this.session.id);
-            this.renderer.setSubmitHandler(async (input) => { if (await this.processPrompt(input))
-                this.renderer.requestExit(); });
-            this.renderer.clearActivity();
-            this.renderer.setReady();
-            void new WorkspaceFileIndex(identity.canonicalPath).listEntries()
-                .then((entries) => this.renderer.setFileSuggestions(workspaceFileSuggestions(entries)))
-                .catch((error) => this.runtime.logger.debug('Unable to load workspace file suggestions.', { reason: error instanceof Error ? error.message : String(error) }));
-            return await this.renderer.waitForExit();
-        }
-        catch (error) {
-            finalStatus = isAbortError(error) ? 'cancelled' : 'failed';
-            throw error;
-        }
-        finally {
-            this.activeAbortController?.abort(new Error('Interactive session is closing.'));
-            this.renderer.resolveActiveModal(undefined);
-            await this.awaitActiveForegroundRun();
-            try {
-                await this.subagentJobs.close();
-            }
-            catch (error) {
-                this.runtime.logger.warn('Unable to close subagent jobs during TUI shutdown.', { reason: error instanceof Error ? error.message : String(error) });
-            }
-            if (this.session !== undefined) {
-                try {
-                    await this.runHookEvent('session.end', this.cwd, this.session.id);
-                }
-                catch (error) {
-                    this.runtime.logger.warn('Session end hook failed during TUI shutdown.', { sessionId: this.session.id, reason: error instanceof Error ? error.message : String(error) });
-                }
-                try {
-                    await this.runtime.sessionStore.updateStatus(this.session.id, finalStatus);
-                }
-                catch (error) {
-                    this.runtime.logger.warn('Unable to update TUI session status during shutdown.', { sessionId: this.session.id, reason: error instanceof Error ? error.message : String(error) });
-                }
-            }
-            process.off('SIGINT', onInterrupt);
-            this.renderer.dispose();
-            ink.unmount();
-            exitInteractiveScreen(this.output);
-            if (this.printResumeCommandOnExit && this.session !== undefined) {
-                this.output.write(`\n${formatResumeCommand(this.session.id)}\n`);
-            }
-        }
-    }
-    async processPrompt(input) {
-        if (this.activeForegroundRun !== undefined) {
-            this.renderer.notice('An operation is already running. Stop it before starting another one.');
-            return false;
-        }
-        const run = dispatchTuiPrompt(input, {
-            renderer: this.renderer,
-            logger: this.runtime.logger,
-            commandHost: createTuiCommandHost({
-                runtime: this.runtime,
-                cwd: this.cwd,
-                renderer: this.renderer,
-                pendingAttachments: this.pendingAttachments,
-                getHooks: () => this.hooks,
-                getSession: () => this.session,
-                getActiveAbortController: () => this.activeAbortController,
-                setActiveAbortController: (controller) => { this.activeAbortController = controller; },
-                attachClipboardImage: (image) => this.attachClipboardImage(image),
-                runPrompt: (prompt, initialSkill) => this.sendPrompt(prompt, this.pendingAttachments.list(), initialSkill),
-                runGoal: (objective, context, limits) => this.runGoal(objective, context, limits),
-                resumeGoal: (context) => this.resumeGoal(context),
-                runSkill: (name, args, context, availableSkills, scope) => this.runSkill(name, args, context, availableSkills, scope),
-                refreshExtensions: () => this.refreshExtensions(),
-                compactSession: () => this.compactSession(),
-                refreshWelcome: (overrides) => this.refreshWelcome(overrides),
-                getContextSnapshot: () => this.getContextSnapshot(),
-                resumeSession: (sessionId) => this.resumeSession(sessionId),
-            }),
-            pendingAttachments: this.pendingAttachments,
-            commandContext: () => this.commandContext(),
-            sendPrompt: (prompt, attachments) => this.sendPrompt(prompt, attachments),
-            resetActiveAbortController: () => { if (this.activePromptRun === undefined)
-                this.activeAbortController = undefined; },
-        });
-        this.activeForegroundRun = run;
-        try {
-            return await run;
-        }
-        finally {
-            if (this.activeForegroundRun === run)
-                this.activeForegroundRun = undefined;
-        }
-    }
-    async attachClipboardImage(image, announce = true) {
-        if (image === undefined) {
-            if (announce)
-                this.renderer.notice('Clipboard does not contain an image.');
-            return;
-        }
-        const normalized = normalizeImage(image.bytes, image.mimeType);
-        this.pendingAttachments.assertCanAdd(normalized.bytes.byteLength);
-        const id = this.pendingAttachments.nextId();
-        const attachment = createImageAttachment(normalized, 'clipboard', id);
-        const storedAttachment = this.session === undefined ? attachment : await this.runtime.sessionStore.saveAttachment(this.session.id, attachment, normalized.bytes);
-        this.pendingAttachments.add({ attachment: storedAttachment, bytes: normalized.bytes });
-        this.renderer.setPendingAttachments(this.pendingAttachments.list().map(({ attachment: item }) => item));
-        if (announce)
-            this.renderer.notice(`Attached ${attachment.name} · ${attachment.mimeType} · ${attachment.sizeBytes} bytes`);
-    }
-    async runPrompt(prompt, initialSkill, goalCallbacks) {
-        return this.sendPrompt(prompt, this.pendingAttachments.list(), initialSkill, goalCallbacks);
-    }
-    async runGoal(objective, context, limits = {}) { if (this.activePromptRun !== undefined) {
-        context.write('Stop the active response before starting a goal.');
-        return;
-    } await runTuiGoal({ runtime: this.runtime, cwd: this.cwd, sessionId: this.session?.id, model: this.activeModel ?? this.session?.model ?? null, profile: this.activeProfile ?? this.session?.profile ?? null, runPrompt: (prompt, callbacks) => this.runPrompt(prompt, undefined, callbacks), write: (message) => context.write(message) }, objective, limits); }
-    async resumeGoal(context) { if (this.activePromptRun !== undefined) {
-        context.write('Stop the active response before resuming a goal.');
-        return;
-    } await resumeTuiGoal({ runtime: this.runtime, cwd: this.cwd, sessionId: this.session?.id, model: this.activeModel ?? this.session?.model ?? null, profile: this.activeProfile ?? this.session?.profile ?? null, runPrompt: (prompt, callbacks) => this.runPrompt(prompt, undefined, callbacks), write: (message) => context.write(message) }); }
-    async sendPrompt(prompt, attachments = [], initialSkill, goalCallbacks) {
-        if (this.activePromptRun !== undefined) {
-            this.renderer.notice('A response is already running. Stop it before sending another prompt.');
-            return '';
-        }
-        const run = this.executePrompt(prompt, attachments, initialSkill, goalCallbacks);
-        this.activePromptRun = run;
-        this.renderer.setRunActive(true);
-        try {
-            return await run;
-        }
-        finally {
-            if (this.activePromptRun === run)
-                this.activePromptRun = undefined;
-            this.renderer.setRunActive(false);
-        }
-    }
-    async executePrompt(prompt, attachments = [], initialSkill, goalCallbacks) {
-        const loaded = await loadExecutionConfig(this.runtime, this.cwd);
-        const selectedModel = this.activeModel ?? loaded.config.model;
-        if (selectedModel === null) {
-            this.renderer.error(`No model is selected. ${formatCommandHint(MODEL_SELECT_HINT, 'tui')}`);
-            return '';
-        }
-        const profileName = this.activeProfile ?? loaded.config.profile ?? AuthenticationService.defaultProfileName();
-        const credential = await this.runtime.credentialStore.get(profileName);
-        if (credential === undefined) {
-            this.renderer.error(`No API key is configured. ${formatCommandHint(AUTH_LOGIN_HINT, 'tui')}`);
-            return '';
-        }
-        const plan = new PlanGenerator().generate(prompt);
-        if (plan.requiresApproval && !(await this.renderer.confirmPlan(plan))) {
-            this.renderer.error('Plan cancelled.');
-            return '';
-        }
-        await this.runHookEvent('prompt.before', this.cwd, this.session?.id ?? 'tui');
-        this.renderer.userPrompt(prompt, attachments.map(({ attachment }) => attachment));
-        const turnId = createTurnId();
-        if (this.session !== undefined)
-            await recordTurnStart(this.runtime.sessionStore, this.session.id, turnId, prompt, attachments.map(({ attachment }) => attachment.id));
-        const startedAt = Date.now();
-        let usage;
-        let agentUsageReported = false;
-        this.renderer.status('Thinking');
-        const abortController = new AbortController();
-        this.activeAbortController = abortController;
-        const client = createLotaGateClient(credential.profile, credential.apiKey);
-        const identity = await this.runtime.projectTrust.inspect(this.cwd);
-        const trusted = await this.runtime.projectTrust.isTrusted(identity);
-        const activeGoal = this.session === undefined ? undefined : await this.runtime.goalStore.get(this.session.id);
-        const canUseAgent = trusted && attachments.length === 0;
-        const tracker = new AgentRunTracker();
-        const toolActivity = {
-            start: (activity) => this.renderer.startToolActivity(activity.key, activity.label),
-        };
-        const subagentLifecycle = {
-            onSubagentLifecycle: (event) => {
-                if (event.sessionId === this.session?.id)
-                    this.renderer.subagentLifecycle(event);
-            },
-        };
-        const contextWindow = await this.contextService.getModelContextWindow(selectedModel, profileName);
-        const onModelComplete = (summary) => {
-            tracker.observeModel(summary);
-            if (summary.usage !== undefined) {
-                agentUsageReported = true;
-                goalCallbacks?.onUsage({ usage: summary.usage, modelCalls: 1 });
-            }
-            this.runtime.logger.debug('Model turn completed.', {
-                model: summary.model,
-                stream: summary.stream,
-                contentLength: summary.contentLength,
-                toolCallCount: summary.toolCallCount,
-                toolNames: summary.toolNames,
-                finishReason: summary.finishReason,
-            });
-        };
-        const prepared = canUseAgent
-            ? await prepareCliAgent({
-                runtime: this.runtime,
-                cwd: this.cwd,
-                model: selectedModel,
-                client,
-                profile: 'interactive-trusted',
-                approvalMode: loaded.config.approvalMode,
-                subagentJobs: this.subagentJobs,
-                ...(initialSkill === undefined ? {} : { initialSkill }),
-                onWrite: (change) => this.renderer.fileChange(change),
-                prompt: (request) => this.approvals.ask(request),
-                rememberApproval: (request) => this.approvals.remember(identity.canonicalPath, request),
-                onApprovalPersistenceFailure: (_request, error) => this.approvals.rememberFailure(error),
-                audit: (decision) => this.approvals.audit(decision),
-                onModelComplete,
-                onSubagentModelComplete: (summary) => { if (summary.usage !== undefined)
-                    goalCallbacks?.onUsage({ usage: summary.usage, modelCalls: 1 }); },
-                contextManagement: createTuiContextManagement(client, selectedModel, contextWindow, (error) => this.runtime.logger.warn('Context summarization failed; using fallback summary.', { reason: error instanceof Error ? error.message : String(error) })),
-                agentSessionStore: this.agentSessionStore,
-                toolActivity,
-                subagentLifecycle,
-                ...(activeGoal === undefined ? {} : { goal: {
-                        objective: activeGoal.objective,
-                        status: activeGoal.status,
-                        turns: activeGoal.turns,
-                        evaluatorRuns: activeGoal.evaluatorRuns,
-                        tokensUsed: activeGoal.usage.totalTokens,
-                        ...(activeGoal.tokenBudget === undefined ? {} : { tokenBudget: activeGoal.tokenBudget }),
-                        ...(activeGoal.maxTurns === undefined ? {} : { maxTurns: activeGoal.maxTurns }),
-                        ...(activeGoal.maxDurationMs === undefined ? {} : { maxDurationMs: activeGoal.maxDurationMs }),
-                        ...(activeGoal.lastError === undefined ? {} : { lastError: activeGoal.lastError }),
-                        ...(activeGoal.lastEvaluation === undefined ? {} : { lastEvaluation: activeGoal.lastEvaluation.reason }),
-                    } }),
-            })
-            : undefined;
-        const referenceContext = prepared === undefined
-            ? await buildAgentInputContext(prompt, identity.canonicalPath, trusted)
-            : await prepared.buildInput(prompt);
-        const fileReferences = referenceContext.references;
-        const agentInput = referenceContext.input;
-        const system = prepared?.system ?? new SystemPromptBuilder().build(createCapabilitySnapshot({
-            profile: 'interactive-untrusted',
-            model: selectedModel,
-            cwd: identity.canonicalPath,
-            workspaceRoot: identity.canonicalPath,
-            trusted: false,
-            tools: [],
-            skills: [],
-            plugins: [],
-        }));
-        const response = [];
-        const appendAssistantDelta = (content) => {
-            throwIfAborted(abortController.signal);
-            response.push(content);
-            this.renderer.assistantDelta(content);
-        };
-        try {
-            if (prepared === undefined) {
-                const service = new ChatService(new SdkChatCompletionAdapter(client));
-                const attachmentInput = await buildTuiAttachmentInput(prompt, fileReferences, identity.canonicalPath);
-                for await (const event of service.stream(selectedModel, attachmentInput, { system, signal: abortController.signal, attachments })) {
-                    throwIfAborted(abortController.signal);
-                    if (event.type === 'activity')
-                        this.renderer.activity(event.state === 'writing' ? 'Writing' : 'Thinking', Date.now() - startedAt, usage);
-                    if (event.type === 'usage') {
-                        usage = event.usage;
-                        this.renderer.activity('Writing', Date.now() - startedAt, usage);
-                    }
-                    if (event.type === 'delta')
-                        appendAssistantDelta(event.content);
-                }
-            }
-            else {
-                throwIfAborted(abortController.signal);
-                await runTuiAgentEvents({
-                    prepared,
-                    input: agentInput,
-                    model: selectedModel,
-                    ...(this.session === undefined ? {} : { sessionId: this.session.id }),
-                    turnId,
-                    signal: abortController.signal,
-                    agentSessionStore: this.agentSessionStore,
-                    tracker,
-                    runtime: this.runtime,
-                    renderer: this.renderer,
-                    startedAt,
-                    getUsage: () => usage,
-                    appendAssistantDelta,
-                    hasResponse: () => response.length > 0,
-                });
-            }
-            if (response.join('').trim().length === 0) {
-                const snapshot = tracker.snapshot();
-                if (snapshot.toolCalls > 0)
-                    tracker.markStuck();
-                const code = snapshot.toolCalls > 0 ? CLI_ERROR_CODES.MODEL_EMPTY_FINAL : CLI_ERROR_CODES.MODEL_PROTOCOL_EMPTY_RESPONSE;
-                const message = snapshot.toolCalls > 0
-                    ? 'The model completed its tool work without a final text response.'
-                    : 'The model returned neither text nor a tool call.';
-                throw new CliError(code, message, {
-                    category: 'model',
-                    userMessage: `${message} Check the selected model and gateway tool-calling support, then try again.`,
-                    retryable: true,
-                    details: {
-                        modelTurns: snapshot.modelTurns,
-                        toolCalls: snapshot.toolCalls,
-                        toolCompletions: snapshot.toolCompletions,
-                        toolFailures: snapshot.toolFailures,
-                        toolNames: snapshot.toolNames,
-                        finishReason: snapshot.lastFinishReason,
-                    },
-                });
-            }
-            goalCallbacks?.onSnapshot(tracker.snapshot());
-        }
-        catch (error) {
-            const cancelled = abortController.signal.aborted || isAbortError(error);
-            if (this.session !== undefined)
-                this.agentSessionStore.delete(this.session.id);
-            if (cancelled)
-                tracker.markCancelled();
-            else if (tracker.snapshot().state !== 'stuck')
-                tracker.markFailed();
-            if (this.session !== undefined)
-                await recordTurnFailure(this.runtime.sessionStore, this.session.id, turnId, error, cancelled);
-            this.renderer.finishAssistant();
-            if (cancelled)
-                this.renderer.notice('Interrupted.');
-            else {
-                const cliError = asCliError(error);
-                this.renderer.failed();
-                this.runtime.logger.error('Agent run failed.', { code: cliError.code, category: cliError.category, ...(cliError.details ?? {}) });
-                this.renderer.error(formatCliErrorMessage(cliError, 'tui'));
-            }
-            goalCallbacks?.onError(error);
-            goalCallbacks?.onSnapshot(tracker.snapshot());
-            return '';
-        }
-        finally {
-            if (this.activeAbortController === abortController)
-                this.activeAbortController = undefined;
-            if (prepared !== undefined) {
-                try {
-                    await prepared.close();
-                }
-                catch (error) {
-                    // Preserve a completed turn when an MCP or local executor fails during cleanup.
-                    this.runtime.logger.warn('Agent cleanup failed after a completed turn.', { reason: error instanceof Error ? error.message : String(error) });
-                }
-            }
-        }
-        this.renderer.finishAssistant();
-        try {
-            if (this.session !== undefined) {
-                await recordTurnCompletion(this.runtime.sessionStore, this.session.id, turnId, response.join(''));
-            }
-        }
-        catch (error) {
-            this.runtime.logger.warn('Unable to persist the completed turn.', { reason: error instanceof Error ? error.message : String(error) });
-            this.renderer.notice('Response completed, but the session state could not be saved.');
-        }
-        try {
-            await this.runHookEvent('response.after', this.cwd, this.session?.id ?? 'tui');
-        }
-        catch (error) {
-            this.runtime.logger.warn('Response hook failed after a completed turn.', { reason: error instanceof Error ? error.message : String(error) });
-            this.renderer.notice('Response completed, but the response hook failed.');
-        }
-        this.pendingAttachments.clear();
-        this.renderer.setPendingAttachments([]);
-        if (!agentUsageReported && usage !== undefined)
-            goalCallbacks?.onUsage({ usage, modelCalls: 1 });
-        const finalUsage = usage?.totalTokens === undefined
-            ? estimateTurnUsage({ model: selectedModel, prompt, response: response.join('') })
-            : usage;
-        if (!agentUsageReported && usage === undefined && finalUsage !== undefined)
-            goalCallbacks?.onUsage({ usage: finalUsage, modelCalls: 1 });
-        this.renderer.complete(Date.now() - startedAt, finalUsage);
-        await this.refreshContextUsage();
-        return response.join('');
-    }
-    commandContext() {
-        return { write: (message) => this.renderer.commandOutput(message) };
-    }
-    getActiveModel() { return this.activeModel; }
-    getActiveProfile() { return this.activeProfile; }
-    async refreshExtensions() {
-        const identity = await this.runtime.projectTrust.inspect(this.cwd);
-        const trusted = await this.runtime.projectTrust.isTrusted(identity);
-        const loaded = await this.runtime.configLoader.load(this.cwd, { includeProject: trusted });
-        await this.reloadExtensions(trusted, loaded.config.approvalMode, identity.canonicalPath);
-        await this.refreshContextUsage();
-    }
-    async refreshWelcome(overrides = {}) {
-        const identity = await this.runtime.projectTrust.inspect(this.cwd);
-        const trusted = await this.runtime.projectTrust.isTrusted(identity);
-        const loaded = await this.runtime.configLoader.load(this.cwd, { includeProject: trusted });
-        this.activeModel = overrides.model === undefined ? (this.activeModel ?? loaded.config.model) : overrides.model;
-        this.activeProfile = overrides.profile === undefined ? (this.activeProfile ?? loaded.config.profile) : overrides.profile;
-        this.renderer.setWelcome({
-            version: CLI_VERSION,
-            cwd: identity.canonicalPath,
-            model: this.activeModel,
-            profile: this.activeProfile,
-            trusted,
-        });
-        await this.refreshContextUsage();
-    }
-    async getContextSnapshot() {
-        const model = this.activeModel ?? this.session?.model ?? null;
-        const activeGoal = this.session === undefined ? undefined : await this.runtime.goalStore.get(this.session.id);
-        const snapshot = await this.contextService.buildForProject({
-            ...(this.session === undefined ? {} : { sessionId: this.session.id }),
-            model,
-            profileName: this.activeProfile ?? this.session?.profile ?? null,
-            pluginNames: this.enabledPluginNames,
-            pluginMcpConfig: this.pluginMcpConfig,
-            pendingAttachments: this.pendingAttachments.size,
-            skillRootScopes: this.skillRootScopes,
-            agentSessionStore: this.agentSessionStore,
-            ...(activeGoal === undefined ? {} : { goal: { objective: activeGoal.objective, status: activeGoal.status, turns: activeGoal.turns, evaluatorRuns: activeGoal.evaluatorRuns, tokensUsed: activeGoal.usage.totalTokens, ...(activeGoal.tokenBudget === undefined ? {} : { tokenBudget: activeGoal.tokenBudget }), ...(activeGoal.maxTurns === undefined ? {} : { maxTurns: activeGoal.maxTurns }), ...(activeGoal.maxDurationMs === undefined ? {} : { maxDurationMs: activeGoal.maxDurationMs }), ...(activeGoal.lastError === undefined ? {} : { lastError: activeGoal.lastError }), ...(activeGoal.lastEvaluation === undefined ? {} : { lastEvaluation: activeGoal.lastEvaluation.reason }) } }),
-        });
-        this.renderer.setContextUsage({ usedTokens: snapshot.usedTokens, ...(snapshot.contextWindow === undefined ? {} : { contextWindow: snapshot.contextWindow }) });
-        return snapshot;
-    }
-    async refreshContextUsage() {
-        try {
-            await this.getContextSnapshot();
-        }
-        catch (error) {
-            this.runtime.logger.debug('Unable to refresh context usage.', { reason: error instanceof Error ? error.message : String(error) });
-        }
-    }
-    async runSkill(name, args, context, availableSkills, scope) {
-        await runTuiSkill({ globalConfigDir: this.runtime.paths.globalConfigDir, skillRootScopes: this.skillRootScopes, runPrompt: (prompt, skill) => this.sendPrompt(prompt, this.pendingAttachments.list(), skill) }, name, args, context, scope, availableSkills);
-    }
-    async reloadExtensions(trusted, approvalMode, workspaceRoot) {
-        const approval = this.approvals.create(approvalMode, trusted, workspaceRoot);
-        this.hookRuntime = new HookRuntime(new ShellToolExecutor({ platform: this.runtime.platform }), { trustedProject: trusted, enabled: true, toolPolicy: new ToolPolicy(approval.policy()) });
-        this.skillRootScopes = resolveSkillRootScopes(this.cwd, this.runtime.paths.globalConfigDir);
-        this.enabledPluginNames = [];
-        this.pluginMcpConfig = {};
-        this.hooks = [];
-        if (!trusted)
-            return;
-        const contributions = await new PluginContributionRegistry(this.runtime.paths.globalConfigDir).resolve(this.cwd, true);
-        this.skillRootScopes = resolveSkillRootScopes(this.cwd, this.runtime.paths.globalConfigDir, contributions.skillRoots);
-        this.enabledPluginNames = contributions.plugins.map((plugin) => plugin.name);
-        this.pluginMcpConfig = contributions.mcpConfig;
-        const discoveredHooks = [...await this.hookRuntime.loadProject(workspaceRoot)];
-        for (const plugin of contributions.plugins)
-            discoveredHooks.push(...await this.hookRuntime.load(plugin));
-        this.hooks = discoveredHooks;
-    }
-    async compactSession() {
-        await compactManualTuiSession({ runtime: this.runtime, cwd: this.cwd, session: this.session, activeModel: this.activeModel, activeProfile: this.activeProfile, activeResponse: this.activeAbortController !== undefined, renderer: this.renderer, contextService: this.contextService, agentSessionStore: this.agentSessionStore, refreshContextUsage: () => this.refreshContextUsage() });
-    }
-    async resumeSession(sessionId) {
-        if (this.activePromptRun !== undefined)
-            throw new Error('Stop the active response before resuming another session.');
-        const identity = await this.runtime.projectTrust.inspect(this.cwd);
-        const next = await new ProjectSessionAccess(this.runtime.sessionStore).require(sessionId, identity.fingerprint);
-        if (next.id === this.session?.id) {
-            this.renderer.notice(`Already using session: ${next.id}`);
-            return;
-        }
-        const transcript = await this.runtime.sessionStore.readTranscript(next.id);
-        const previous = this.session;
-        if (previous !== undefined) {
-            await this.runHookEvent('session.end', this.cwd, previous.id);
-            await this.runtime.sessionStore.updateStatus(previous.id, 'completed');
-        }
-        this.session = await this.runtime.sessionStore.updateStatus(next.id, 'active');
-        const loaded = await loadExecutionConfig(this.runtime, this.cwd);
-        this.activeModel = next.model ?? loaded.config.model;
-        this.activeProfile = next.profile ?? loaded.config.profile;
-        this.renderer.setWelcome({
-            version: CLI_VERSION,
-            cwd: identity.canonicalPath,
-            model: this.activeModel,
-            profile: this.activeProfile,
-            trusted: await this.runtime.projectTrust.isTrusted(identity),
-        });
-        this.renderer.clearTranscript();
-        for (const entry of retainLatestCompaction(transcript)) {
-            if (entry.type === 'user')
-                this.renderer.userPrompt(entry.content);
-            else if (entry.type === 'assistant') {
-                this.renderer.beginAssistant();
-                this.renderer.assistantDelta(entry.content);
-                this.renderer.finishAssistant();
-            }
-        }
-        await this.refreshContextUsage();
-        await this.runHookEvent('session.start', identity.canonicalPath, next.id);
-        this.renderer.notice(`Resumed session: ${next.id}`);
-    }
-    handleInterrupt() {
-        const active = this.activeAbortController;
-        const next = handleTuiInterrupt({ lastInterruptAt: this.lastInterruptAt, exitArmedUntil: this.exitArmedUntil, printResumeCommandOnExit: this.printResumeCommandOnExit }, active, this.renderer);
-        this.lastInterruptAt = next.lastInterruptAt;
-        this.exitArmedUntil = next.exitArmedUntil;
-        this.printResumeCommandOnExit = next.printResumeCommandOnExit;
-    }
-    async awaitActiveForegroundRun() {
-        const run = this.activeForegroundRun;
-        if (run === undefined)
-            return;
-        try {
-            await run;
-        }
-        catch (error) {
-            this.runtime.logger.warn('Foreground TUI operation failed during shutdown.', { reason: error instanceof Error ? error.message : String(error) });
-        }
-    }
-    async runHookEvent(event, cwd, sessionId) { await runTuiHookEvent(this.hookRuntime, this.hooks, event, cwd, sessionId); }
-}