praxis-agent 0.7.0 → 0.9.0

package/dist/cli/tui/mcp-panel-projector.js

@@ -0,0 +1,181 @@
+const SCOPE_ORDER = {
+    project: 0,
+    local: 1,
+    user: 2,
+};
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : [];
+}
+function transport(config) {
+    if (config.type === 'sse')
+        return 'sse';
+    return config.type === 'http' || typeof config.url === 'string'
+        ? 'http'
+        : 'stdio';
+}
+export function projectTuiMcpPanel({ cwd, records, disabledNames, runtime, }) {
+    const disabled = new Set(disabledNames);
+    const runtimeByName = new Map(runtime.map((server) => [server.name, server]));
+    const servers = records
+        .map((record) => {
+        const active = runtimeByName.get(record.name);
+        const status = disabled.has(record.name)
+            ? 'disabled'
+            : (active?.status ?? 'failed');
+        const selectedTransport = transport(record.config);
+        const command = stringValue(record.config.command);
+        const url = stringValue(record.config.url);
+        return {
+            name: record.name,
+            scope: record.scope,
+            path: record.path,
+            location: record.scope === 'local'
+                ? `${record.path} [project: ${cwd}]`
+                : record.path,
+            status,
+            statusDetail: status === 'disabled'
+                ? '◯ disabled'
+                : status === 'needs-authentication'
+                    ? '△ needs authentication'
+                    : status === 'connected'
+                        ? `done: ${active?.statusDetail ?? 'connected'}`
+                        : `failed: ${active?.statusDetail ?? 'failed'}`,
+            ...(active?.authDetail ? { authDetail: active.authDetail } : {}),
+            transport: selectedTransport,
+            ...(selectedTransport === 'stdio' && command ? { command } : {}),
+            ...(selectedTransport !== 'stdio' && url ? { url } : {}),
+            args: stringArray(record.config.args),
+            capabilities: active?.capabilities ?? [],
+            toolCount: active?.toolCount ?? 0,
+        };
+    })
+        .sort((left, right) => SCOPE_ORDER[left.scope] - SCOPE_ORDER[right.scope] ||
+        left.location.localeCompare(right.location) ||
+        left.name.localeCompare(right.name));
+    return { cwd, servers };
+}
+export function initialTuiMcpPanelState(model) {
+    return {
+        depth: 'list',
+        serverIndex: bounded(0, model.servers.length),
+        selectedIndex: 0,
+    };
+}
+export function tuiMcpServerActions(server) {
+    if (server.status === 'disabled') {
+        return [
+            {
+                type: 'set-enabled',
+                name: server.name,
+                scope: server.scope,
+                enabled: true,
+            },
+        ];
+    }
+    if (server.status === 'needs-authentication') {
+        return [
+            { type: 'authenticate', name: server.name },
+            {
+                type: 'set-enabled',
+                name: server.name,
+                scope: server.scope,
+                enabled: false,
+            },
+        ];
+    }
+    return [
+        ...(server.status === 'connected' && server.toolCount > 0
+            ? [{ type: 'view-tools', name: server.name }]
+            : []),
+        { type: 'reconnect', name: server.name },
+        {
+            type: 'set-enabled',
+            name: server.name,
+            scope: server.scope,
+            enabled: false,
+        },
+    ];
+}
+function bounded(index, length) {
+    return Math.min(Math.max(0, index), Math.max(0, length - 1));
+}
+export function reduceTuiMcpPanelState(model, state, input) {
+    const serverIndex = bounded(state.serverIndex, model.servers.length);
+    const server = model.servers[serverIndex];
+    const normalized = { ...state, serverIndex };
+    if (input.type === 'back') {
+        if (state.depth === 'list') {
+            return { state: normalized, command: { type: 'close' } };
+        }
+        if (state.depth === 'detail') {
+            return { state: { depth: 'list', serverIndex, selectedIndex: 0 } };
+        }
+        if (state.depth === 'tools') {
+            return { state: { depth: 'detail', serverIndex, selectedIndex: 0 } };
+        }
+        return { state: { depth: 'tools', serverIndex, selectedIndex: 0 } };
+    }
+    if (!server)
+        return { state: normalized };
+    if (state.depth === 'list') {
+        if (input.type === 'confirm') {
+            return {
+                state: { depth: 'detail', serverIndex, selectedIndex: 0 },
+            };
+        }
+        const offset = input.type === 'up' ? -1 : input.type === 'down' ? 1 : 0;
+        const requested = input.type === 'select' ? input.index : serverIndex + offset;
+        return {
+            state: {
+                depth: 'list',
+                serverIndex: bounded(requested, model.servers.length),
+                selectedIndex: 0,
+            },
+        };
+    }
+    if (state.depth === 'detail') {
+        const actions = tuiMcpServerActions(server);
+        const selectedIndex = bounded(state.selectedIndex, actions.length);
+        if (input.type === 'confirm') {
+            const command = actions[selectedIndex];
+            if (command?.type === 'view-tools') {
+                return {
+                    state: { depth: 'tools', serverIndex, selectedIndex: 0 },
+                    command,
+                };
+            }
+            return command
+                ? { state: { ...normalized, selectedIndex }, command }
+                : { state: { ...normalized, selectedIndex } };
+        }
+        const offset = input.type === 'up' ? -1 : input.type === 'down' ? 1 : 0;
+        const requested = input.type === 'select' ? input.index : selectedIndex + offset;
+        return {
+            state: {
+                ...normalized,
+                selectedIndex: bounded(requested, actions.length),
+            },
+        };
+    }
+    if (state.depth === 'tool')
+        return { state: normalized };
+    const tools = server.tools ?? [];
+    const selectedIndex = bounded(state.selectedIndex, tools.length);
+    if (state.depth === 'tools' && input.type === 'confirm' && tools.length > 0) {
+        return { state: { depth: 'tool', serverIndex, selectedIndex } };
+    }
+    const offset = input.type === 'up' ? -1 : input.type === 'down' ? 1 : 0;
+    const requested = input.type === 'select' ? input.index : selectedIndex + offset;
+    return {
+        state: {
+            ...normalized,
+            selectedIndex: bounded(requested, tools.length),
+        },
+    };
+}
+//# sourceMappingURL=mcp-panel-projector.js.map

package/dist/cli/tui/mcp-panel.d.ts

@@ -0,0 +1,8 @@
+import { type TuiMcpPanelModel, type TuiMcpPanelState } from './mcp-panel-projector.js';
+export declare function McpPanel({ model, state, screenReader, width, }: {
+    model: TuiMcpPanelModel;
+    state: TuiMcpPanelState;
+    screenReader?: boolean;
+    width?: number;
+}): import("react").JSX.Element;
+//# sourceMappingURL=mcp-panel.d.ts.map

package/dist/cli/tui/mcp-panel.js

@@ -0,0 +1,99 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useTerminalWidth } from './claude-style.js';
+import { tuiMcpServerActions, } from './mcp-panel-projector.js';
+const EMPTY_MESSAGE = 'No MCP servers configured. Run claude doctor if this is unexpected — it lists MCP config files that failed validation. Otherwise, run claude mcp --help or visit https://code.claude.com/docs/en/mcp to learn more.';
+const SCOPE_LABELS = {
+    project: 'Project MCPs',
+    local: 'Local MCPs',
+    user: 'User MCPs',
+};
+function capitalized(value) {
+    return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+}
+function serverStatus(server) {
+    if (server.status === 'connected') {
+        return `✔  connected${server.toolCount > 0
+            ? ` · ${server.toolCount} ${server.toolCount === 1 ? 'tool' : 'tools'}`
+            : ''}`;
+    }
+    if (server.status === 'needs-authentication') {
+        return '△  needs authentication';
+    }
+    return server.status === 'failed' ? '✘  failed' : '◯  disabled';
+}
+function actionLabel(command) {
+    if (command.type === 'view-tools')
+        return 'View tools';
+    if (command.type === 'reconnect')
+        return 'Reconnect';
+    if (command.type === 'authenticate')
+        return 'Authenticate';
+    if (command.type === 'set-enabled') {
+        return command.enabled ? 'Enable' : 'Disable';
+    }
+    return 'Close';
+}
+function ListPanel({ model, state, screenReader, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Manage MCP servers" }), _jsxs(Text, { children: [model.servers.length, ' ', model.servers.length === 1 ? 'server' : 'servers'] }), ['project', 'local', 'user'].flatMap((scope) => {
+                const scoped = model.servers
+                    .map((server, index) => ({ server, index }))
+                    .filter(({ server }) => server.scope === scope);
+                if (scoped.length === 0)
+                    return null;
+                const locations = [
+                    ...new Set(scoped.map(({ server }) => server.location)),
+                ];
+                return locations.map((location) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: [SCOPE_LABELS[scope], " ", '  ', "(", location, ")"] }), scoped
+                            .filter(({ server }) => server.location === location)
+                            .map(({ server, index }) => {
+                            const selected = index === state.serverIndex;
+                            return (_jsxs(Text, { inverse: !screenReader && selected, children: [screenReader && selected
+                                        ? 'Selected server: '
+                                        : selected
+                                            ? '❯  '
+                                            : '   ', server.name, " ", ' · ', serverStatus(server)] }, `${scope}:${server.name}`));
+                        })] }, `${scope}:${location}`)));
+            }), _jsx(Text, { children: "\u203B Run claude --debug to see error logs" }), _jsx(Text, { children: "https://code.claude.com/docs/en/mcp for help" }), _jsx(Text, { dimColor: true, children: "\u2191/\u2193 to navigate \u00B7 Enter to confirm \u00B7 Esc to cancel" })] }));
+}
+function DetailPanel({ server, state, screenReader, }) {
+    const actions = tuiMcpServerActions(server);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [capitalized(server.name), " MCP Server"] }), _jsxs(Text, { children: ["Status: ", server.statusDetail] }), server.authDetail ? _jsxs(Text, { children: ["Auth: ", server.authDetail] }) : null, server.transport === 'stdio' ? (_jsxs(_Fragment, { children: [_jsxs(Text, { children: ["Command: ", server.command ?? ''] }), server.args.length > 0 ? (_jsxs(Text, { children: ["Args: ", server.args.join(' ')] })) : null] })) : (_jsxs(Text, { children: ["URL: ", server.url ?? ''] })), _jsxs(Text, { children: ["Config location: ", server.location] }), server.status === 'connected' && server.capabilities.length > 0 ? (_jsxs(Text, { children: ["Capabilities: ", ' ' + server.capabilities.join(' · ')] })) : null, server.status === 'connected' && server.toolCount > 0 ? (_jsx(Text, { children: `Tools:  ${server.toolCount} ${server.toolCount === 1 ? 'tool' : 'tools'}` })) : null, actions.map((action, index) => (_jsxs(Text, { inverse: !screenReader && index === state.selectedIndex, children: [screenReader && index === state.selectedIndex
+                        ? 'Selected action: '
+                        : `${index + 1}. `, actionLabel(action)] }, `${action.type}:${index}`))), _jsxs(Text, { children: ["Enter selection [1-", actions.length, "], or Escape to cancel:"] }), _jsx(Text, { dimColor: true, children: "\u2191/\u2193 to navigate \u00B7 Enter to select \u00B7 Esc to back" })] }));
+}
+function ToolsPanel({ server, state, screenReader, }) {
+    const tools = server.tools ?? [];
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Tools for ", server.name] }), _jsxs(Text, { children: [tools.length, " ", tools.length === 1 ? 'tool' : 'tools'] }), tools.map((tool, index) => (_jsxs(Text, { inverse: !screenReader && index === state.selectedIndex, children: [screenReader && index === state.selectedIndex
+                        ? 'Selected tool: '
+                        : `${index + 1}. `, tool.name] }, tool.fullName))), _jsxs(Text, { children: ["Enter selection [1-", tools.length, "], or Escape to cancel:"] }), _jsx(Text, { dimColor: true, children: "\u2191/\u2193 to navigate \u00B7 Enter to select \u00B7 Esc to back" })] }));
+}
+function ToolPanel({ server, state, }) {
+    const tool = server.tools?.[state.selectedIndex];
+    if (!tool)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: tool.name }), _jsx(Text, { children: server.name }), _jsxs(Text, { children: ["Tool name: ", ' ' + tool.name] }), _jsxs(Text, { children: ["Full name: ", ' ' + tool.fullName] }), _jsx(Text, { children: "Description:" }), _jsx(Text, { children: tool.description ?? '' }), _jsx(Text, { dimColor: true, children: "Esc to go back" })] }));
+}
+export function McpPanel({ model, state, screenReader = false, width, }) {
+    const terminalWidth = useTerminalWidth(width);
+    const server = model.servers[state.serverIndex];
+    let content;
+    if (model.servers.length === 0)
+        content = _jsx(Text, { children: EMPTY_MESSAGE });
+    else if (!server)
+        content = null;
+    else if (state.depth === 'detail') {
+        content = (_jsx(DetailPanel, { server: server, state: state, screenReader: screenReader }));
+    }
+    else if (state.depth === 'tools') {
+        content = (_jsx(ToolsPanel, { server: server, state: state, screenReader: screenReader }));
+    }
+    else if (state.depth === 'tool') {
+        content = _jsx(ToolPanel, { server: server, state: state });
+    }
+    else {
+        content = (_jsx(ListPanel, { model: model, state: state, screenReader: screenReader }));
+    }
+    return (_jsx(Box, { flexDirection: "column", width: terminalWidth, children: content }));
+}
+//# sourceMappingURL=mcp-panel.js.map

package/dist/cli/tui/recently-denied.d.ts

@@ -0,0 +1,15 @@
+import type { ModelToolCall } from '../../core/runtime.js';
+export interface RecentlyDeniedAction {
+    id: string;
+    call: ModelToolCall;
+    display: string;
+    reason: string;
+    sessionId: string;
+}
+export interface RecentlyDeniedStore {
+    load(): Promise<readonly RecentlyDeniedAction[]>;
+    record(action: RecentlyDeniedAction): Promise<readonly RecentlyDeniedAction[]>;
+    remove(id: string): Promise<readonly RecentlyDeniedAction[]>;
+}
+export declare function createRecentlyDeniedStore(): RecentlyDeniedStore;
+//# sourceMappingURL=recently-denied.d.ts.map

package/dist/cli/tui/recently-denied.js

@@ -0,0 +1,19 @@
+export function createRecentlyDeniedStore() {
+    let entries = [];
+    return {
+        async load() {
+            return entries;
+        },
+        async record(action) {
+            entries = [action, ...entries];
+            return entries;
+        },
+        async remove(id) {
+            const index = entries.findIndex((entry) => entry.id === id);
+            if (index >= 0)
+                entries = entries.toSpliced(index, 1);
+            return entries;
+        },
+    };
+}
+//# sourceMappingURL=recently-denied.js.map

package/dist/cli/tui/runtime-interactions.d.ts

@@ -0,0 +1,17 @@
+import type { TranscriptItem } from './claude-style.js';
+import type { PraxisRuntimeSettings } from './runtime-settings.js';
+export type CopyCandidate = {
+    label: string;
+    description: string;
+    text: string;
+};
+export declare function spinnerTip(settings: Pick<PraxisRuntimeSettings, 'tips'>): string | undefined;
+export declare function questionTimeoutMilliseconds(value: PraxisRuntimeSettings['askUserQuestionTimeout']): number | undefined;
+export declare function workflowRuntimeInstructions(settings: Pick<PraxisRuntimeSettings, 'workflows' | 'workflowKeywordTriggerEnabled' | 'workflowSizeGuideline'>): string | undefined;
+export declare function copyCandidates(response: string): readonly CopyCandidate[];
+export declare function shouldShowCopyPicker(response: string): boolean;
+export declare function externalEditorInitialContent(prompt: string, history: readonly TranscriptItem[], enabled: boolean): string;
+export declare function sessionRecap(history: readonly TranscriptItem[]): string | undefined;
+export declare function formatTurnDuration(milliseconds: number | undefined): string | undefined;
+export declare function autoUpdateTarget(channel: PraxisRuntimeSettings['autoUpdatesChannel']): 'latest' | 'stable';
+//# sourceMappingURL=runtime-interactions.d.ts.map

package/dist/cli/tui/runtime-interactions.js

@@ -0,0 +1,100 @@
+const SPINNER_TIPS = [
+    'Tip: use /help to browse local commands.',
+    'Tip: use @ to attach a file or an agent definition.',
+    'Tip: press ctrl+o to expand the detailed transcript.',
+    'Tip: use /compact to summarize a long conversation.',
+];
+export function spinnerTip(settings) {
+    if (!settings.tips)
+        return undefined;
+    return SPINNER_TIPS[Math.floor(Date.now() / 8_000) % SPINNER_TIPS.length];
+}
+export function questionTimeoutMilliseconds(value) {
+    switch (value) {
+        case '60s':
+            return 60_000;
+        case '5m':
+            return 5 * 60_000;
+        case '10m':
+            return 10 * 60_000;
+        case 'never':
+            return undefined;
+    }
+}
+export function workflowRuntimeInstructions(settings) {
+    if (!settings.workflows)
+        return undefined;
+    const keyword = settings.workflowKeywordTriggerEnabled
+        ? 'Treat an explicit "ultracode" request as a request to consider a dynamic workflow.'
+        : 'Do not infer a dynamic workflow from an "ultracode" keyword alone; require an explicit workflow request.';
+    const size = settings.workflowSizeGuideline === 'unrestricted'
+        ? 'No workflow size guideline is configured.'
+        : `Prefer a ${settings.workflowSizeGuideline} workflow when creating a dynamic workflow unless the user explicitly asks otherwise.`;
+    return `Dynamic workflows are available for explicitly requested multi-step automation. ${keyword} ${size}`;
+}
+export function copyCandidates(response) {
+    const candidates = [
+        {
+            label: 'Full response',
+            description: 'Copy the complete assistant response.',
+            text: response,
+        },
+    ];
+    const blocks = response.matchAll(/```[^\n]*\n([\s\S]*?)```/gu);
+    let index = 0;
+    for (const block of blocks) {
+        const text = block[1] ?? '';
+        if (!text)
+            continue;
+        index += 1;
+        candidates.push({
+            label: `Code block ${index}`,
+            description: `Copy code block ${index} only.`,
+            text,
+        });
+    }
+    return candidates;
+}
+export function shouldShowCopyPicker(response) {
+    return copyCandidates(response).length > 1;
+}
+export function externalEditorInitialContent(prompt, history, enabled) {
+    if (!enabled)
+        return prompt;
+    const response = [...history]
+        .reverse()
+        .find((item) => item.kind === 'assistant');
+    if (!response?.text)
+        return prompt;
+    return `${prompt}\n\n--- Last response (context only; remove before sending) ---\n${response.text}`;
+}
+export function sessionRecap(history) {
+    const lastUser = [...history]
+        .reverse()
+        .find((item) => item.kind === 'user');
+    const lastAssistant = [...history]
+        .reverse()
+        .find((item) => item.kind === 'assistant');
+    if (!lastUser && !lastAssistant)
+        return undefined;
+    const compact = (text) => text.replace(/\s+/gu, ' ').trim().slice(0, 160);
+    return [
+        'Session recap',
+        ...(lastUser ? [`Last request: ${compact(lastUser.text)}`] : []),
+        ...(lastAssistant ? [`Last response: ${compact(lastAssistant.text)}`] : []),
+    ].join(' · ');
+}
+export function formatTurnDuration(milliseconds) {
+    if (milliseconds === undefined || milliseconds < 0)
+        return undefined;
+    if (milliseconds < 1_000)
+        return `${milliseconds}ms`;
+    const seconds = Math.floor(milliseconds / 1_000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+export function autoUpdateTarget(channel) {
+    return channel === 'stable' ? 'stable' : 'latest';
+}
+//# sourceMappingURL=runtime-interactions.js.map

package/dist/cli/tui/runtime-settings.d.ts

@@ -0,0 +1,40 @@
+import { type ConfigSettingsTarget, type ConfigSettingsSnapshot } from './config-settings.js';
+import type { CliControls } from '../protocol.js';
+export interface PraxisRuntimeSettings {
+    tui: 'default' | 'fullscreen';
+    autoCompact: boolean;
+    switchModelsOnFlag: boolean;
+    tips: boolean;
+    reduceMotion: boolean;
+    thinking: boolean;
+    recap: boolean;
+    checkpoints: boolean;
+    workflows: boolean;
+    workflowKeywordTriggerEnabled: boolean;
+    workflowSizeGuideline: 'unrestricted' | 'small' | 'medium' | 'large';
+    verbose: boolean;
+    progressBar: boolean;
+    turnDuration: boolean;
+    permissionMode: 'default' | 'plan' | 'acceptEdits' | 'auto' | 'dontAsk';
+    worktreeBaseRef: 'fresh' | 'head';
+    useAutoModeDuringPlan: boolean;
+    gitignore: boolean;
+    copyFullResponse: boolean;
+    defaultToAgentsView: boolean;
+    leftArrowOpensAgents: boolean;
+    autoUpdatesChannel: 'latest' | 'stable';
+    theme: string;
+    notifChannel: string;
+    outputStyle: 'default' | 'Proactive' | 'Explanatory' | 'Learning';
+    language: string;
+    editor: 'normal' | 'vim';
+    askUserQuestionTimeout: 'never' | '60s' | '5m' | '10m';
+    externalEditorContext: boolean;
+    prStatus: boolean;
+    model: string;
+}
+export declare function projectRuntimeSettings(snapshot: ConfigSettingsSnapshot): PraxisRuntimeSettings;
+export declare function loadRuntimeSettings(target?: ConfigSettingsTarget): Promise<PraxisRuntimeSettings>;
+export declare function runtimeSettingsSystemPrompt(settings: PraxisRuntimeSettings | undefined): string | undefined;
+export declare function applyRuntimeSettingDefaults(controls: CliControls, settings: PraxisRuntimeSettings | undefined): CliControls;
+//# sourceMappingURL=runtime-settings.d.ts.map

package/dist/cli/tui/runtime-settings.js

@@ -0,0 +1,84 @@
+import { CLAUDE_2_1_208_CONFIG_SETTINGS, configSettingValue, loadConfigSettings, } from './config-settings.js';
+function value(snapshot, id) {
+    const definition = CLAUDE_2_1_208_CONFIG_SETTINGS.find((candidate) => candidate.id === id);
+    if (!definition)
+        throw new Error(`Unknown runtime setting: ${id}`);
+    return configSettingValue(snapshot, definition);
+}
+export function projectRuntimeSettings(snapshot) {
+    return {
+        tui: value(snapshot, 'tui'),
+        autoCompact: value(snapshot, 'autoCompact'),
+        switchModelsOnFlag: value(snapshot, 'switchModelsOnFlag'),
+        tips: value(snapshot, 'tips'),
+        reduceMotion: value(snapshot, 'reduceMotion'),
+        thinking: value(snapshot, 'thinking'),
+        recap: value(snapshot, 'recap'),
+        checkpoints: value(snapshot, 'checkpoints'),
+        workflows: value(snapshot, 'workflows'),
+        workflowKeywordTriggerEnabled: value(snapshot, 'workflowKeywordTriggerEnabled'),
+        workflowSizeGuideline: value(snapshot, 'workflowSizeGuideline'),
+        verbose: value(snapshot, 'verbose'),
+        progressBar: value(snapshot, 'progressBar'),
+        turnDuration: value(snapshot, 'turnDuration'),
+        permissionMode: value(snapshot, 'permissionMode'),
+        worktreeBaseRef: value(snapshot, 'worktreeBaseRef'),
+        useAutoModeDuringPlan: value(snapshot, 'useAutoModeDuringPlan'),
+        gitignore: value(snapshot, 'gitignore'),
+        copyFullResponse: value(snapshot, 'copyFullResponse'),
+        defaultToAgentsView: value(snapshot, 'defaultToAgentsView'),
+        leftArrowOpensAgents: value(snapshot, 'leftArrowOpensAgents'),
+        autoUpdatesChannel: value(snapshot, 'autoUpdatesChannel'),
+        theme: value(snapshot, 'theme'),
+        notifChannel: value(snapshot, 'notifChannel'),
+        outputStyle: value(snapshot, 'outputStyle'),
+        language: value(snapshot, 'language'),
+        editor: value(snapshot, 'editor'),
+        askUserQuestionTimeout: value(snapshot, 'askUserQuestionTimeout'),
+        externalEditorContext: value(snapshot, 'externalEditorContext'),
+        prStatus: value(snapshot, 'prStatus'),
+        model: value(snapshot, 'model'),
+    };
+}
+export async function loadRuntimeSettings(target) {
+    return projectRuntimeSettings(await loadConfigSettings(target));
+}
+export function runtimeSettingsSystemPrompt(settings) {
+    if (!settings)
+        return undefined;
+    const sections = [
+        settings.outputStyle === 'default'
+            ? null
+            : `Output style: ${settings.outputStyle}. Adapt explanations and initiative to this style.`,
+        settings.language === 'default'
+            ? null
+            : `Respond in the user's configured language: ${settings.language}.`,
+        settings.verbose
+            ? 'Provide enough operational detail for the interactive verbose transcript; include exact tool and implementation outcomes when useful.'
+            : null,
+        settings.workflowKeywordTriggerEnabled
+            ? null
+            : 'Do not treat "ultracode" as a dynamic-workflow trigger unless the user explicitly requests a workflow.',
+        settings.workflowSizeGuideline === 'unrestricted'
+            ? null
+            : `When creating a dynamic workflow, prefer a ${settings.workflowSizeGuideline} workflow unless the user explicitly requests otherwise.`,
+    ].filter((section) => section !== null);
+    return sections.length > 0 ? sections.join('\n') : undefined;
+}
+export function applyRuntimeSettingDefaults(controls, settings) {
+    if (!settings)
+        return controls;
+    return {
+        ...controls,
+        ...(settings.model !== 'default' && controls.model === undefined
+            ? { model: settings.model }
+            : {}),
+        ...(controls.permissionMode === 'default'
+            ? { permissionMode: settings.permissionMode }
+            : {}),
+        ...(controls.thinking === undefined
+            ? { thinking: settings.thinking ? 'enabled' : 'disabled' }
+            : {}),
+    };
+}
+//# sourceMappingURL=runtime-settings.js.map

package/dist/cli/tui/slash-commands.js

@@ -104,6 +104,11 @@ export const BUILTIN_TUI_SLASH_COMMANDS = [
         description: 'Show runtime status, configuration, usage, and statistics',
         source: 'builtin',
     },
+    {
+        name: 'theme',
+        description: 'Change the theme',
+        source: 'builtin',
+    },
     {
         name: 'skills',
         description: 'List available skills',
@@ -159,6 +164,11 @@ export const BUILTIN_TUI_SLASH_COMMANDS = [
         description: 'Browse running and completed workflows',
         source: 'builtin',
     },
+    {
+        name: 'tui',
+        description: 'Switch between the default and fullscreen renderers',
+        source: 'builtin',
+    },
     {
         name: 'exit',
         description: 'Exit the CLI',

package/dist/cli/tui/task-panel.d.ts

@@ -0,0 +1,53 @@
+import type { BackgroundAgentSnapshot } from '../../application/background-agent-manager.js';
+import type { BackgroundBashSnapshot } from '../../application/background-bash-manager.js';
+import type { WorkflowTaskSnapshot } from '../../application/workflow-manager.js';
+export type TuiTaskKind = 'shell' | 'agent' | 'workflow';
+export type TuiTaskStatus = 'running' | 'completed' | 'failed' | 'stopped';
+export interface TuiTaskEntry {
+    id: string;
+    kind: TuiTaskKind;
+    status: TuiTaskStatus;
+    label: string;
+    command?: string;
+    output?: string;
+    startedAtMs?: number;
+    durationMs?: number;
+    createdAtMs: number;
+}
+export interface TuiTaskPanelState {
+    depth: 'list' | 'detail';
+    selectedIndex: number;
+    scrollOffset: number;
+}
+export type TuiTaskPanelAction = {
+    type: 'move';
+    delta: -1 | 1;
+} | {
+    type: 'open';
+} | {
+    type: 'back';
+} | {
+    type: 'scroll';
+    delta: -1 | 1;
+};
+export declare function projectBackgroundBashTask(snapshot: BackgroundBashSnapshot): TuiTaskEntry;
+export declare function projectBackgroundAgentTask(snapshot: BackgroundAgentSnapshot): TuiTaskEntry;
+export declare function projectWorkflowTask(workflow: WorkflowTaskSnapshot | Readonly<Record<string, unknown>>): TuiTaskEntry;
+export declare function projectTuiTasks(input: {
+    shells?: readonly BackgroundBashSnapshot[];
+    agents?: readonly BackgroundAgentSnapshot[];
+    workflows?: readonly WorkflowTaskSnapshot[];
+}): readonly TuiTaskEntry[];
+/** Preserve selection by task identity across polling and task reordering. */
+export declare function reconcileTuiTaskPanelState(state: TuiTaskPanelState, previousTasks: readonly TuiTaskEntry[], tasks: readonly TuiTaskEntry[]): TuiTaskPanelState;
+export declare function updateTuiTaskPanelState(state: TuiTaskPanelState, tasks: readonly TuiTaskEntry[], action: TuiTaskPanelAction): TuiTaskPanelState;
+export declare function initialTuiTaskPanelState(tasks: readonly TuiTaskEntry[]): TuiTaskPanelState;
+export declare function TaskPanel({ tasks, state, nowMs, screenReader, width, height, }: {
+    tasks: readonly TuiTaskEntry[];
+    state: TuiTaskPanelState;
+    nowMs?: number;
+    screenReader?: boolean;
+    width?: number;
+    height?: number;
+}): import("react").JSX.Element;
+//# sourceMappingURL=task-panel.d.ts.map