@lotagate/cli 0.1.20 → 0.1.22

package/dist/presentation/tui/tui-attachment-input.d.ts

@@ -0,0 +1,2 @@
+import { type WorkspaceFileReference } from '../../application/workspace/workspace-file-reference-resolver.js';
+export declare function buildTuiAttachmentInput(prompt: string, references: readonly WorkspaceFileReference[], workspaceRoot: string): Promise<string>;

package/dist/presentation/tui/tui-attachment-input.js

@@ -0,0 +1,5 @@
+import { WorkspaceFileReferenceResolver } from '../../application/workspace/workspace-file-reference-resolver.js';
+export async function buildTuiAttachmentInput(prompt, references, workspaceRoot) {
+    const contents = await new WorkspaceFileReferenceResolver(workspaceRoot).contentInstruction(references);
+    return contents === undefined ? prompt : `${prompt}\n\n${contents}`;
+}

package/dist/presentation/tui/tui-clipboard-paste-handlers.d.ts

@@ -0,0 +1,11 @@
+import type { ClipboardImage } from '../../ports/clipboard-adapter.js';
+import type { HostPlatformContext } from '../../infrastructure/platform/host-platform.js';
+export interface TuiClipboardPasteHandlers {
+    image: () => Promise<void>;
+    text: () => Promise<string | undefined>;
+}
+export declare function createTuiClipboardPasteHandlers(options: {
+    platform: HostPlatformContext;
+    notify: (message: string) => void;
+    attachImage: (image: ClipboardImage | undefined) => Promise<void>;
+}): TuiClipboardPasteHandlers;

package/dist/presentation/tui/tui-clipboard-paste-handlers.js

@@ -0,0 +1,25 @@
+import { asCliError } from '../../domain/errors/cli-error.js';
+import { createClipboardAdapter } from '../../infrastructure/clipboard/clipboard-adapter-factory.js';
+import { createClipboardTextAdapter } from '../../infrastructure/clipboard/clipboard-text-adapter-factory.js';
+import { formatCliErrorMessage } from '../../application/commands/command-hints.js';
+export function createTuiClipboardPasteHandlers(options) {
+    return {
+        image: async () => {
+            try {
+                await options.attachImage(await createClipboardAdapter(options.platform).readImage());
+            }
+            catch (error) {
+                options.notify(formatCliErrorMessage(asCliError(error), 'tui'));
+            }
+        },
+        text: async () => {
+            try {
+                return await createClipboardTextAdapter(options.platform).readText();
+            }
+            catch (error) {
+                options.notify(formatCliErrorMessage(asCliError(error), 'tui'));
+                return undefined;
+            }
+        },
+    };
+}

package/dist/presentation/tui/tui-command-context.d.ts

@@ -0,0 +1,3 @@
+export interface TuiCommandContext {
+    write(message: string): void;
+}

package/dist/presentation/tui/tui-command-context.js

@@ -0,0 +1 @@
+export {};

package/dist/presentation/tui/tui-command-executor.d.ts

@@ -0,0 +1,38 @@
+import type { CommandInvocation } from '../../application/commands/command-contract.js';
+import { type TuiContextSnapshot } from './context-display.js';
+import type { SkillManifest } from '../../domain/extensions/skill-manifest.js';
+import type { ScopedSkill } from '../../infrastructure/extensions/skill-manager.js';
+import type { ExtensionScope } from '../../domain/extensions/extension-scope.js';
+import type { SessionMetadata } from '../../domain/session/session.js';
+import type { HookDefinition } from '../../domain/extensions/hook-manifest.js';
+import type { PendingAttachmentStore } from '../../application/chat/pending-attachment-store.js';
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+import type { InkTuiBridge } from './ink/tui-bridge.js';
+import type { CreateGoalInput } from '../../domain/orchestration/goal.js';
+import type { TuiCommandContext } from './tui-command-context.js';
+export interface TuiCommandHost {
+    runtime: CliRuntime;
+    cwd: string;
+    renderer: InkTuiBridge;
+    pendingAttachments: PendingAttachmentStore;
+    hooks: readonly HookDefinition[];
+    session: SessionMetadata | undefined;
+    activeAbortController: AbortController | undefined;
+    attachClipboardImage(image: {
+        bytes: Uint8Array;
+        mimeType: string;
+    } | undefined): Promise<void>;
+    runPrompt(prompt: string, initialSkill?: SkillManifest): Promise<string>;
+    runGoal(objective: string, context: TuiCommandContext, limits?: Omit<CreateGoalInput, 'objective'>): Promise<void>;
+    resumeGoal(context: TuiCommandContext): Promise<void>;
+    runSkill(name: string, args: readonly string[], context: TuiCommandContext, availableSkills?: readonly ScopedSkill[], scope?: ExtensionScope): Promise<void>;
+    refreshExtensions(): Promise<void>;
+    compactSession(): Promise<void>;
+    refreshWelcome(overrides?: {
+        model?: string | null;
+        profile?: string | null;
+    }): Promise<void>;
+    getContextSnapshot(): Promise<TuiContextSnapshot>;
+    resumeSession(sessionId: string): Promise<void>;
+}
+export declare function executeTuiCommand(invocation: CommandInvocation, host: TuiCommandHost, context: TuiCommandContext): Promise<boolean>;

package/dist/presentation/tui/tui-command-executor.js

@@ -0,0 +1,214 @@
+import { AuthenticationService } from '../../application/auth/authentication-service.js';
+import { executeApplicationCommand } from '../../application/commands/application-command-executor.js';
+import { runModelCommand } from '../../application/commands/cli-command-services.js';
+import { loadModelCatalog } from '../../application/model/model-catalog-service.js';
+import { formatContextSnapshot } from './context-display.js';
+import { createClipboardAdapter } from '../../infrastructure/clipboard/clipboard-adapter-factory.js';
+import { formatCompactTable } from '../../application/formatting/compact-table.js';
+import { formatGoalStatus } from '../../application/orchestration/goal-output.js';
+import { parseGoalLimits } from '../../application/orchestration/goal-input.js';
+import { prepareTuiMediaInvocation } from './tui-media-model-selection.js';
+export async function executeTuiCommand(invocation, host, context) {
+    switch (invocation.action.executor) {
+        case 'tui-exit': return true;
+        case 'tui-clear':
+            host.renderer.clearTranscript();
+            return false;
+        case 'tui-stop':
+            stopActiveRun(host, context);
+            return false;
+        case 'tui-details':
+            context.write(`Action details: ${host.renderer.toggleActionDetails() ? 'on' : 'off'}`);
+            return false;
+        case 'tui-context':
+            await showContext(host, context);
+            return false;
+        case 'tui-auth-login':
+            await login(host, invocation, context);
+            return false;
+        case 'tui-model-select':
+            await selectModel(host, context);
+            return false;
+        case 'tui-skill-run':
+            await runSkill(host, invocation, context);
+            return false;
+        case 'tui-session-resume':
+            await host.resumeSession(requirePosition(invocation, 0, 'session id'));
+            return false;
+        case 'tui-session-compact':
+            await host.compactSession();
+            return false;
+        case 'tui-session-rename':
+            await renameSession(host, invocation, context);
+            return false;
+        case 'tui-goal':
+            await executeGoal(host, invocation, context);
+            return false;
+        case 'tui-attachments':
+            await executeAttachments(host, invocation, context);
+            return false;
+        case 'tui-prompt':
+            await host.runPrompt(invocation.positionals.join(' '));
+            return false;
+        case 'tui-agent-info':
+            context.write('The JSONL agent protocol owns stdin/stdout and must be run directly: lotagate agent stdio.');
+            return false;
+        default: {
+            const preparedInvocation = await prepareTuiMediaInvocation(invocation, {
+                loadModels: () => loadModelCatalog(host.runtime, host.cwd),
+                selectModel: (title, choices) => host.renderer.selectModel(title, choices),
+            });
+            if (preparedInvocation === undefined) {
+                context.write('Model selection cancelled.');
+                return false;
+            }
+            await executeApplicationTuiCommand(preparedInvocation, host, context);
+            await refreshAfterApplicationCommand(host, preparedInvocation);
+            return false;
+        }
+    }
+}
+async function executeApplicationTuiCommand(invocation, host, context) {
+    const abortController = new AbortController();
+    host.activeAbortController = abortController;
+    try {
+        await executeApplicationCommand(invocation, applicationHost(host, context, abortController.signal));
+    }
+    finally {
+        if (host.activeAbortController === abortController)
+            host.activeAbortController = undefined;
+    }
+}
+function applicationHost(host, context, signal) {
+    return {
+        runtime: host.runtime,
+        cwd: host.cwd,
+        output: { write: (value) => context.write(value.endsWith('\n') ? value.slice(0, -1) : value) },
+        selectScope: (title) => host.renderer.selectScope(title),
+        activity: { start: (key, label) => host.renderer.startToolActivity(key, label) },
+        signal,
+    };
+}
+async function refreshAfterApplicationCommand(host, invocation) {
+    if (invocation.action.id === 'model.use')
+        await host.refreshWelcome({ model: invocation.positionals[0] ?? null });
+    if (invocation.action.id === 'trust.grant' || invocation.action.id === 'trust.revoke') {
+        await host.refreshExtensions();
+        await host.refreshWelcome();
+    }
+    if (invocation.action.id.startsWith('plugin.') && invocation.action.id !== 'plugin.list' && invocation.action.id !== 'plugin.list.default')
+        await host.refreshExtensions();
+}
+function stopActiveRun(host, context) {
+    if (host.activeAbortController === undefined)
+        context.write('No response is currently running.');
+    else {
+        host.activeAbortController.abort();
+        context.write('Stopping the active response.');
+    }
+}
+async function showContext(host, context) {
+    context.write(host.session === undefined ? 'No active session.' : formatContextSnapshot(await host.getContextSnapshot()));
+}
+async function login(host, invocation, context) {
+    const loaded = await host.runtime.configLoader.load(host.cwd, { includeProject: false });
+    const profileName = String(invocation.options.get('profile') ?? loaded.config.profile ?? AuthenticationService.defaultProfileName());
+    const baseUrl = String(invocation.options.get('base-url') ?? loaded.config.baseUrl);
+    const apiKey = await host.renderer.requestSecret('LotaGate API key');
+    if (apiKey === undefined) {
+        context.write('Login cancelled.');
+        return;
+    }
+    const profile = await host.runtime.auth.login({ profileName, baseUrl, apiKey });
+    await host.runtime.configLoader.setGlobal('profile', profile.name);
+    await host.refreshWelcome({ profile: profile.name });
+    context.write(`Logged in profile: ${profile.name}`);
+}
+async function selectModel(host, context) {
+    const loaded = await host.runtime.configLoader.load(host.cwd);
+    const models = await loadModelCatalog(host.runtime, host.cwd);
+    if (models.data.length === 0) {
+        context.write('No models are available.');
+        return;
+    }
+    const selected = await host.renderer.selectModel('Select a model', models.data.map((model) => ({ value: model.id, label: model.id })), loaded.config.model ?? undefined);
+    if (selected === undefined) {
+        context.write('Model selection cancelled.');
+        return;
+    }
+    await runModelCommand(['use', selected], host.runtime, host.cwd, { write: (value) => context.write(value.endsWith('\n') ? value.slice(0, -1) : value) });
+    await host.refreshWelcome({ model: selected });
+}
+async function runSkill(host, invocation, context) {
+    const name = requirePosition(invocation, 0, 'skill name');
+    await host.runSkill(name, invocation.positionals.slice(1), context, undefined, readScope(invocation));
+}
+async function renameSession(host, invocation, context) {
+    if (host.session === undefined) {
+        context.write('No active session.');
+        return;
+    }
+    const name = invocation.positionals.join(' ').trim();
+    host.session = await host.runtime.sessionStore.rename(host.session.id, name);
+    context.write(`Renamed session: ${host.session.name}`);
+}
+async function executeGoal(host, invocation, context) {
+    if (invocation.action.id === 'goal.start.tui') {
+        await host.runGoal(invocation.positionals.join(' '), context, parseGoalLimits(invocation.options));
+        return;
+    }
+    if (host.session === undefined) {
+        context.write('No active session.');
+        return;
+    }
+    if (invocation.action.id === 'goal.status.tui') {
+        const state = await host.runtime.goalStore.get(host.session.id);
+        context.write(state === undefined ? 'No active goal.' : formatGoalStatus(state));
+        return;
+    }
+    if (invocation.action.id === 'goal.pause.tui') {
+        host.activeAbortController?.abort();
+        const current = await host.runtime.goalStore.get(host.session.id);
+        if (current?.status === 'active')
+            await host.runtime.goalStore.pause(host.session.id);
+        context.write(current?.status === 'paused' ? 'Goal already paused.' : 'Goal paused.');
+        return;
+    }
+    if (invocation.action.id === 'goal.resume.tui') {
+        await host.resumeGoal(context);
+        return;
+    }
+    host.activeAbortController?.abort();
+    await host.runtime.goalStore.clear(host.session.id);
+    context.write('Goal cleared.');
+}
+async function executeAttachments(host, invocation, context) {
+    const action = invocation.action.id;
+    if (action === 'attachments.paste') {
+        const image = await createClipboardAdapter(host.runtime.platform).readImage();
+        await host.attachClipboardImage(image);
+        context.write(image === undefined ? 'Clipboard does not contain an image.' : 'Attachment added from clipboard.');
+        return;
+    }
+    if (action === 'attachments.remove') {
+        const id = requirePosition(invocation, 0, 'attachment id');
+        if (!host.pendingAttachments.remove(id))
+            context.write(`Attachment not found: ${id}`);
+        else {
+            host.renderer.setPendingAttachments(host.pendingAttachments.list().map(({ attachment }) => attachment));
+            context.write(`Removed attachment: ${id}`);
+        }
+        return;
+    }
+    context.write(formatCompactTable(host.pendingAttachments.list().map(({ attachment }) => ({ name: attachment.name, status: attachment.mimeType, detail: `${attachment.sizeBytes} bytes` })), { empty: 'No pending attachments.' }));
+}
+function requirePosition(invocation, index, label) {
+    const value = invocation.positionals[index];
+    if (value === undefined)
+        throw new Error(`Missing ${label}.`);
+    return value;
+}
+function readScope(invocation) {
+    const value = invocation.options.get('scope');
+    return value === 'user' || value === 'project' ? value : undefined;
+}

package/dist/presentation/tui/tui-command-host-factory.d.ts

@@ -0,0 +1,40 @@
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+import type { PendingAttachmentStore } from '../../application/chat/pending-attachment-store.js';
+import type { HookDefinition } from '../../domain/extensions/hook-manifest.js';
+import type { SessionMetadata } from '../../domain/session/session.js';
+import type { SkillManifest } from '../../domain/extensions/skill-manifest.js';
+import type { ScopedSkill } from '../../infrastructure/extensions/skill-manager.js';
+import type { ExtensionScope } from '../../domain/extensions/extension-scope.js';
+import type { CreateGoalInput } from '../../domain/orchestration/goal.js';
+import type { InkTuiBridge } from './ink/tui-bridge.js';
+import type { TuiCommandContext } from './tui-command-context.js';
+import type { TuiCommandHost } from './tui-command-executor.js';
+import type { TuiContextSnapshot } from './context-display.js';
+export interface TuiCommandHostBindings {
+    runtime: CliRuntime;
+    cwd: string;
+    renderer: InkTuiBridge;
+    pendingAttachments: PendingAttachmentStore;
+    getHooks(): readonly HookDefinition[];
+    getSession(): SessionMetadata | undefined;
+    getActiveAbortController(): AbortController | undefined;
+    setActiveAbortController(controller: AbortController | undefined): void;
+    attachClipboardImage(image: {
+        bytes: Uint8Array;
+        mimeType: string;
+    } | undefined): Promise<void>;
+    runPrompt(prompt: string, initialSkill?: SkillManifest): Promise<string>;
+    runGoal(objective: string, context: TuiCommandContext, limits?: Omit<CreateGoalInput, 'objective'>): Promise<void>;
+    resumeGoal(context: TuiCommandContext): Promise<void>;
+    runSkill(name: string, args: readonly string[], context: TuiCommandContext, availableSkills?: readonly ScopedSkill[], scope?: ExtensionScope): Promise<void>;
+    refreshExtensions(): Promise<void>;
+    compactSession(): Promise<void>;
+    refreshWelcome(overrides?: {
+        model?: string | null;
+        profile?: string | null;
+    }): Promise<void>;
+    getContextSnapshot(): Promise<TuiContextSnapshot>;
+    resumeSession(sessionId: string): Promise<void>;
+}
+/** Adapts TUI-owned mutable state without exposing the application instance as an unsafe structural cast. */
+export declare function createTuiCommandHost(bindings: TuiCommandHostBindings): TuiCommandHost;

package/dist/presentation/tui/tui-command-host-factory.js

@@ -0,0 +1,23 @@
+/** Adapts TUI-owned mutable state without exposing the application instance as an unsafe structural cast. */
+export function createTuiCommandHost(bindings) {
+    return {
+        runtime: bindings.runtime,
+        cwd: bindings.cwd,
+        renderer: bindings.renderer,
+        pendingAttachments: bindings.pendingAttachments,
+        get hooks() { return bindings.getHooks(); },
+        get session() { return bindings.getSession(); },
+        get activeAbortController() { return bindings.getActiveAbortController(); },
+        set activeAbortController(controller) { bindings.setActiveAbortController(controller); },
+        attachClipboardImage: bindings.attachClipboardImage,
+        runPrompt: bindings.runPrompt,
+        runGoal: bindings.runGoal,
+        resumeGoal: bindings.resumeGoal,
+        runSkill: bindings.runSkill,
+        refreshExtensions: bindings.refreshExtensions,
+        compactSession: bindings.compactSession,
+        refreshWelcome: bindings.refreshWelcome,
+        getContextSnapshot: bindings.getContextSnapshot,
+        resumeSession: bindings.resumeSession,
+    };
+}

package/dist/presentation/tui/tui-context-compaction.d.ts

@@ -0,0 +1,5 @@
+import type { SessionStore as AgentSessionStore } from '@lotagate/agent-sdk';
+import type { LotaGate } from '@lotagate/sdk';
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+export declare function createTuiContextManagement(client: LotaGate, model: string, contextWindow: number | undefined, onSummaryFailure: (error: unknown) => void): import("@lotagate/agent-sdk").ContextManagementOptions;
+export declare function compactTuiSession(runtime: CliRuntime, agentSessions: AgentSessionStore, sessionId: string, client: LotaGate, model: string, contextWindow?: number, onSummaryFailure?: (error: unknown) => void): Promise<boolean>;

package/dist/presentation/tui/tui-context-compaction.js

@@ -0,0 +1,22 @@
+import { createContextManagement, redactCompactionSummary } from '../../application/agent/context-compaction.js';
+import { retainLatestCompaction, toAgentMessage } from '../../application/agent/agent-session-store.js';
+import { buildAgentHistory } from '../../application/agent/agent-history.js';
+import { compactSessionMessages } from '../../application/session/session-compaction-service.js';
+export function createTuiContextManagement(client, model, contextWindow, onSummaryFailure) {
+    return createContextManagement({ client, model, ...(contextWindow === undefined ? {} : { contextWindow }), onSummaryFailure });
+}
+export async function compactTuiSession(runtime, agentSessions, sessionId, client, model, contextWindow, onSummaryFailure) {
+    const state = await agentSessions.get(sessionId);
+    const messages = state?.messages ?? await loadStoredAgentMessages(runtime, sessionId);
+    const result = await compactSessionMessages(messages, client, model, contextWindow, onSummaryFailure);
+    if (result.summary === undefined)
+        return false;
+    if (state !== undefined)
+        await agentSessions.update(sessionId, { messages: result.messages, status: 'completed' });
+    await runtime.sessionStore.compact(sessionId, redactCompactionSummary(result.summary));
+    return true;
+}
+async function loadStoredAgentMessages(runtime, sessionId) {
+    const history = await runtime.sessionStore.readHistory(sessionId);
+    return retainLatestCompaction(buildAgentHistory(history.transcript, history.events)).map(toAgentMessage);
+}

package/dist/presentation/tui/tui-context-service.d.ts

@@ -0,0 +1,34 @@
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+import type { SkillManifest } from '../../domain/extensions/skill-manifest.js';
+import { type CliMcpConfig } from '../../domain/extensions/mcp-config.js';
+import type { SkillRootScope } from '../../infrastructure/extensions/skill-roots.js';
+import type { TuiContextSnapshot } from './context-display.js';
+import type { SessionStore as AgentSessionStore } from '@lotagate/agent-sdk';
+import type { AgentGoalSummary } from '../../application/agent/capability-profile.js';
+export interface TuiContextServiceInput {
+    sessionId?: string;
+    model: string | null;
+    profileName?: string | null;
+    trusted: boolean;
+    skills: readonly (SkillManifest & {
+        enabled: boolean;
+    })[];
+    pluginNames: readonly string[];
+    pluginMcpConfig?: CliMcpConfig;
+    pendingAttachments: number;
+    skillRootScopes?: readonly SkillRootScope[];
+    agentSessionStore?: AgentSessionStore;
+    goal?: AgentGoalSummary;
+}
+/** Builds the human-readable context model from durable session data and CLI-owned metadata. */
+export declare class TuiContextService {
+    private readonly runtime;
+    private readonly cwd;
+    private contextWindow;
+    private contextWindowModel;
+    constructor(runtime: CliRuntime, cwd: string);
+    buildForProject(input: Omit<TuiContextServiceInput, 'trusted' | 'skills'>): Promise<TuiContextSnapshot>;
+    build(input: TuiContextServiceInput): Promise<TuiContextSnapshot>;
+    getModelContextWindow(model: string | null, profileName?: string | null): Promise<number | undefined>;
+    private resolveContextWindow;
+}

package/dist/presentation/tui/tui-context-service.js

@@ -0,0 +1,126 @@
+import path from 'node:path';
+import { resolveModelContextWindow } from '../../application/model/model-context-window.js';
+import { SystemPromptBuilder } from '../../application/agent/system-prompt-builder.js';
+import { createCapabilitySnapshot } from '../../application/agent/capability-profile.js';
+import { buildToolCatalogFromDefinitions } from '../../application/agent/tool-catalog.js';
+import { filesystemToolDefinitions } from '../../infrastructure/filesystem/local-filesystem-tool-executor.js';
+import { shellToolDefinitions } from '../../infrastructure/shell/shell-tool-executor.js';
+import { skillToolDefinitions } from '../../infrastructure/extensions/skill-tool-executor.js';
+import { subagentToolDefinitions } from '../../application/orchestration/subagent-tool-executor.js';
+import { FileMcpConfigStore } from '../../infrastructure/extensions/file-mcp-config-store.js';
+import { mergeMcpConfigsWithOverride } from '../../domain/extensions/mcp-config.js';
+import { SkillManager } from '../../infrastructure/extensions/skill-manager.js';
+import { estimateTextTokens } from '../../infrastructure/tokens/tiktoken-token-estimator.js';
+import { retainLatestCompaction } from '../../application/agent/agent-session-store.js';
+import { buildAgentHistory } from '../../application/agent/agent-history.js';
+import { WorkspaceInstructionLoader } from '../../application/workspace/workspace-instruction-loader.js';
+/** Builds the human-readable context model from durable session data and CLI-owned metadata. */
+export class TuiContextService {
+    runtime;
+    cwd;
+    contextWindow;
+    contextWindowModel;
+    constructor(runtime, cwd) {
+        this.runtime = runtime;
+        this.cwd = cwd;
+    }
+    async buildForProject(input) {
+        const identity = await this.runtime.projectTrust.inspect(this.cwd);
+        const trusted = await this.runtime.projectTrust.isTrusted(identity);
+        const skills = trusted && input.skillRootScopes !== undefined
+            ? await new SkillManager(path.join(this.runtime.paths.globalConfigDir, 'skills-state.json')).listScoped(input.skillRootScopes)
+            : [];
+        return this.build({ ...input, trusted, skills });
+    }
+    async build(input) {
+        const contextWindow = await this.resolveContextWindow(input.model, input.profileName);
+        const [history, configuredMcp] = await Promise.all([
+            input.sessionId === undefined
+                ? Promise.resolve({ transcript: [], events: [] })
+                : this.runtime.sessionStore.readHistory(input.sessionId),
+            Promise.all([
+                FileMcpConfigStore.forScope(this.cwd, this.runtime.paths.globalConfigDir, 'user').list(),
+                FileMcpConfigStore.forScope(this.cwd, this.runtime.paths.globalConfigDir, 'project').list(),
+            ]).then(([user, project]) => mergeMcpConfigsWithOverride(user, project, input.pluginMcpConfig ?? {})),
+        ]);
+        const transcript = retainLatestCompaction(buildAgentHistory(history.transcript, history.events));
+        const instructions = input.trusted ? await new WorkspaceInstructionLoader().load(this.cwd, this.cwd) : [];
+        const localTools = input.trusted ? buildToolCatalogFromDefinitions([
+            ...filesystemToolDefinitions(),
+            ...shellToolDefinitions(),
+            ...skillToolDefinitions(),
+            ...subagentToolDefinitions(),
+        ]) : undefined;
+        const toolNames = localTools?.names ?? [];
+        const systemPrompt = new SystemPromptBuilder().build(createCapabilitySnapshot({
+            profile: input.trusted ? 'interactive-trusted' : 'interactive-untrusted',
+            model: input.model ?? 'unselected',
+            cwd: this.cwd,
+            workspaceRoot: this.cwd,
+            trusted: input.trusted,
+            tools: toolNames,
+            skills: input.skills.map((skill) => ({ name: 'skillKey' in skill ? skill.skillKey : skill.name, description: skill.description })),
+            plugins: input.trusted ? input.pluginNames : [],
+            ...(instructions.length === 0 ? {} : { instructions }),
+            ...(input.goal === undefined ? {} : { goal: input.goal }),
+        }));
+        const tokenModel = input.model ?? 'o200k_base';
+        const liveMessages = input.sessionId === undefined ? undefined : await input.agentSessionStore?.get(input.sessionId);
+        const liveContextMessages = liveMessages?.messages?.[0]?.role === 'system' ? liveMessages.messages.slice(1) : liveMessages?.messages;
+        const contextMessages = liveContextMessages === undefined || liveContextMessages.length === 0 ? transcript : liveContextMessages.map(toTranscriptLike);
+        const inputTokens = estimateEntries(contextMessages.filter((entry) => entry.type === 'user'), tokenModel);
+        const outputTokens = estimateEntries(contextMessages.filter((entry) => entry.type === 'assistant'), tokenModel);
+        const otherTokens = estimateEntries(contextMessages.filter((entry) => entry.type !== 'user' && entry.type !== 'assistant'), tokenModel);
+        const conversationTokens = inputTokens + outputTokens + otherTokens;
+        const systemPromptTokens = estimateTextTokens({ model: tokenModel, text: systemPrompt });
+        return {
+            model: input.model,
+            ...(contextWindow === undefined ? {} : { contextWindow }),
+            usedTokens: conversationTokens + systemPromptTokens,
+            systemPromptTokens,
+            conversationTokens,
+            inputTokens,
+            outputTokens,
+            otherTokens,
+            transcriptEntries: transcript.length,
+            userMessages: transcript.filter((entry) => entry.type === 'user').length,
+            assistantMessages: transcript.filter((entry) => entry.type === 'assistant').length,
+            toolCalls: history.events.filter((event) => event.type === 'tool.called').length,
+            compactions: history.events.filter((event) => event.type === 'context.compacted').length,
+            pendingAttachments: input.pendingAttachments,
+            toolNames,
+            mcpServers: Object.values(configuredMcp).filter((entry) => entry.enabled).length,
+            memoryFiles: 0,
+        };
+    }
+    async getModelContextWindow(model, profileName) {
+        return this.resolveContextWindow(model, profileName);
+    }
+    async resolveContextWindow(model, profileName) {
+        if (model === null || model.trim().length === 0) {
+            this.contextWindow = undefined;
+            this.contextWindowModel = undefined;
+            return undefined;
+        }
+        const cacheKey = `${profileName ?? ''}\0${model}`;
+        if (this.contextWindowModel === cacheKey)
+            return this.contextWindow;
+        this.contextWindowModel = cacheKey;
+        this.contextWindow = undefined;
+        this.contextWindow = await resolveModelContextWindow(this.runtime, model, profileName);
+        return this.contextWindow;
+    }
+}
+function toTranscriptLike(message) {
+    return { type: message.role, content: textContent(message.content) };
+}
+function textContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.map((part) => typeof part === 'object' && part !== null && 'text' in part && typeof part.text === 'string' ? part.text : '').join('');
+}
+function estimateEntries(entries, model) {
+    return estimateTextTokens({ model, text: entries.map((entry) => `${entry.type}: ${entry.content}`).join('\n') });
+}

package/dist/presentation/tui/tui-file-suggestions.d.ts

@@ -0,0 +1,3 @@
+import type { WorkspaceEntry } from '../../application/workspace/workspace-file-index.js';
+import type { TuiChoice } from './ink/tui-bridge.js';
+export declare function workspaceFileSuggestions(entries: readonly WorkspaceEntry[]): readonly TuiChoice[];

package/dist/presentation/tui/tui-file-suggestions.js

@@ -0,0 +1,8 @@
+export function workspaceFileSuggestions(entries) {
+    return entries.map((entry) => ({
+        value: `@${entry.path}`,
+        label: `@${entry.path}`,
+        description: entry.kind === 'directory' ? 'Workspace folder' : 'Workspace file',
+        kind: entry.kind,
+    }));
+}

package/dist/presentation/tui/tui-goal-controller.d.ts

@@ -0,0 +1,14 @@
+import type { CliRuntime } from '../../bootstrap/runtime-factory.js';
+import type { CreateGoalInput } from '../../domain/orchestration/goal.js';
+import { type GoalTurnCallbacks } from '../../application/orchestration/goal-runner.js';
+export interface TuiGoalControllerOptions {
+    runtime: CliRuntime;
+    cwd: string;
+    sessionId: string | undefined;
+    model: string | null;
+    profile: string | null;
+    runPrompt: (prompt: string, callbacks?: GoalTurnCallbacks) => Promise<string>;
+    write: (message: string) => void;
+}
+export declare function runTuiGoal(options: TuiGoalControllerOptions, objective: string, limits?: Omit<CreateGoalInput, 'objective'>): Promise<void>;
+export declare function resumeTuiGoal(options: TuiGoalControllerOptions): Promise<void>;