@lotagate/cli 0.1.21 → 0.1.22

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

@@ -0,0 +1,675 @@
+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); }
+}