vgxness 1.2.0 → 1.3.0

package/dist/cli/tui/opentui/code/screen.js

@@ -0,0 +1,107 @@
+import { Box, Text } from '@opentui/core';
+import { buildSafetyReadModel, summarizeEvent } from '../../../../code/tui/runtime-events.js';
+export function createVgxcodeScreen(input) {
+    const latest = input.events.at(-1);
+    const transcript = input.events.filter((event) => event.type === 'provider.message').map(summarizeEvent);
+    const activity = input.events.filter((event) => event.type !== 'provider.message').map(summarizeEvent);
+    const safety = buildSafetyReadModel(input.events);
+    const status = input.errors.length > 0 ? 'error' : input.status;
+    const latestText = latest ? `   Last event: ${latest.type}` : '';
+    const modeDescription = describeMode(input.mode);
+    const promptLabel = input.source === 'stdin' ? 'piped JSONL replay (safe)' : `${input.mode} prompt (${modeDescription})`;
+    const submittedText = input.submittedPrompt === '' ? 'Last submitted: none' : `Last submitted (${input.mode}): ${input.submittedPrompt}`;
+    const promptText = input.source === 'stdin'
+        ? 'stdin JSONL detected; not spawning root CLI.'
+        : `Mode: ${input.mode} (${modeDescription})   State: ${status}\n${submittedText}\n> ${input.prompt}${input.status === 'running' ? '  [running]' : ''}`;
+    const errorText = input.errors.length === 0 ? '' : `\n\nErrors (${input.errors.length}):\n${input.errors.map((error) => `! ${error}`).join('\n')}`;
+    const safetyText = formatSafetyDetails(safety);
+    return Box({
+        id: 'vgxcode-screen',
+        flexDirection: 'column',
+        width: '100%',
+        height: '100%',
+        padding: 1,
+        gap: 1,
+        backgroundColor: '#080B12',
+    }, Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#7DD3FC',
+        paddingX: 1,
+        title: ' vgxcode ',
+    }, Text({ content: `Project: ${input.project}   UI: OpenTUI/Bun experimental   Source: ${input.source}   State: ${status}${latestText}`, fg: '#E0F2FE', wrapMode: 'word' })), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#A78BFA',
+        paddingX: 1,
+        title: ` Prompt — ${promptLabel} `,
+    }, Text({ content: promptText, fg: '#F8FAFC', wrapMode: 'word' })), Box({
+        flexDirection: 'row',
+        flexGrow: 1,
+        gap: 1,
+    }, Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#22C55E',
+        flexGrow: 2,
+        padding: 1,
+        title: ' Transcript ',
+    }, Text({ content: transcript.length === 0 ? 'No assistant output yet.' : transcript.join('\n'), fg: '#DCFCE7', wrapMode: 'word' })), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#F59E0B',
+        flexGrow: 1,
+        padding: 1,
+        title: ' Activity ',
+    }, Text({ content: `${activity.length === 0 ? 'No runtime activity yet.' : activity.join('\n')}${errorText}`, fg: input.errors.length > 0 ? '#FECACA' : '#FEF3C7', wrapMode: 'word' }))), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#38BDF8',
+        paddingX: 1,
+        title: ` Safety details — ${input.mode === 'craft' ? 'approval-capable craft' : 'preview/read-only'} `,
+    }, Text({ content: safetyText, fg: '#E0F2FE', wrapMode: 'word' })), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#475569',
+        paddingX: 1,
+        title: ' Shortcuts ',
+    }, Text({ content: formatFooter(input.approvalActionsEnabled === true), fg: '#CBD5E1', wrapMode: 'word' })));
+}
+function formatSafetyDetails(safety) {
+    const approvalText = safety.latestPendingApproval
+        ? `! Pending approvals: ${safety.pendingApprovalCount} (latest: ${safety.latestPendingApproval.toolName})`
+        : `✓ Pending approvals: ${safety.pendingApprovalCount}`;
+    const decisionText = safety.latestApprovalDecision
+        ? `${approvalDecisionCue(safety.latestApprovalDecision.final)} Latest approval decision: ${safety.latestApprovalDecision.final} — ${safety.latestApprovalDecision.toolName}: ${safety.latestApprovalDecision.reason}`
+        : '· Latest approval decision: none';
+    const previewText = safety.latestApprovalPreview
+        ? `! Approval preview: ${safety.latestApprovalPreview.toolName} (${safety.latestApprovalPreview.capability}) — Approve disabled, Deny disabled. No mutation executed.${safety.latestApprovalPreview.targetPath ? ` Target: ${safety.latestApprovalPreview.targetPath}.` : ''}`
+        : '· Approval preview: none';
+    const changedFilesText = safety.changedFiles.length > 0
+        ? `! Changed files (${safety.changedFiles.length}): ${safety.changedFiles.join(', ')}`
+        : '✓ Changed files: none reported';
+    const diffText = safety.diffAvailability === 'filenames-only'
+        ? '· Diff preview: unavailable in current event stream; only changed filenames were reported.'
+        : safety.diffAvailability === 'preview' && safety.latestDiffPreview
+            ? formatDiffPreview(safety.latestDiffPreview)
+            : '· Diff preview: no changed files reported.';
+    return `${approvalText}\n${decisionText}\n${previewText}\n${changedFilesText}\n${diffText}\n· Craft is approval-capable and may mutate after you approve. Craft-preview is preview-only and never sends approval decisions.`;
+}
+function describeMode(mode) {
+    if (mode === 'craft')
+        return 'approval-capable, mutating after approval';
+    if (mode === 'craft-preview')
+        return 'preview-only, no mutation executed';
+    return 'read-only';
+}
+function formatFooter(approvalActionsEnabled) {
+    const approvalText = approvalActionsEnabled ? '[a] Approve pending  [d] Deny pending' : 'Approve/Deny hidden until a live craft run has a pending approval';
+    return `[Enter] Run mode  [Tab] Toggle inspect/plan  Prefix: /inspect, /plan, /craft, or /craft-preview  [Backspace] Edit  ${approvalText}  [Ctrl+C] Quit.`;
+}
+function formatDiffPreview(preview) {
+    const metadata = `· Diff preview: ${preview.files.length} files, ${preview.bodyBytes}/${preview.originalBytes} bytes, sha256:${preview.hash.slice(0, 12)}${preview.truncated ? ', truncated' : ''}${preview.redacted ? ', redacted' : ''}`;
+    return `${metadata}\n${preview.body}`;
+}
+function approvalDecisionCue(final) {
+    return final === 'allow' ? '✓' : '✕';
+}

package/dist/cli/tui/opentui/code/smoke.js

@@ -0,0 +1,32 @@
+import { createTestRenderer } from '@opentui/core/testing';
+import { parseVgxcodeJsonl, sampleEvents } from '../../../../code/tui/runtime-events.js';
+import { createVgxcodeScreen } from './screen.js';
+const input = await readPipedInput();
+const parsed = input === '' ? { events: [], errors: [] } : parseVgxcodeJsonl(input);
+if (parsed.errors.length > 0) {
+    throw new Error(`Smoke input contained invalid events: ${parsed.errors.join('; ')}`);
+}
+const events = parsed.events.length > 0 ? parsed.events : sampleEvents();
+const setup = await createTestRenderer({ width: 140, height: 36 });
+try {
+    setup.renderer.root.add(createVgxcodeScreen({ project: 'vgxness-smoke', events, prompt: 'smoke test prompt', submittedPrompt: 'previous smoke prompt', status: 'completed', errors: [], source: 'interactive', mode: 'inspect' }));
+    await setup.renderOnce();
+    const frame = setup.captureCharFrame();
+    const requiredText = ['vgxcode', 'vgxness-smoke', 'State: completed', 'Mode: inspect', 'Last submitted', 'Prompt', 'Transcript', 'Activity', 'Safety details', 'hidden until a live craft run', '/craft-preview'];
+    const missing = requiredText.filter((text) => !frame.includes(text));
+    if (missing.length > 0) {
+        throw new Error(`Smoke frame is missing expected text: ${missing.join(', ')}`);
+    }
+    console.log('vgxcode OpenTUI smoke passed');
+}
+finally {
+    setup.renderer.destroy();
+}
+async function readPipedInput() {
+    if (process.stdin.isTTY)
+        return '';
+    let input = '';
+    for await (const chunk of process.stdin)
+        input += String(chunk);
+    return input;
+}

package/dist/cli/tui/opentui/main-menu/index.js

@@ -0,0 +1,3 @@
+export * from './renderer.js';
+export * from './screen.js';
+export * from './view.js';

package/dist/cli/tui/opentui/main-menu/renderer.js

@@ -0,0 +1,68 @@
+import { createCliRenderer } from '@opentui/core';
+import { mainMenuActionFromInput, reduceMainMenuState } from '../../main-menu/main-menu-actions.js';
+import { createMainMenuState } from '../../main-menu/main-menu-state.js';
+import { createTuiViewport } from '../../visual/viewport.js';
+import { createOpenTuiMainMenuScreen } from './screen.js';
+export async function renderOpenTuiMainMenu(options = {}) {
+    const width = terminalWidth(options.stdout);
+    let state = options.initialState ?? createMainMenuState(width === undefined ? {} : { width });
+    const renderer = await createCliRenderer({
+        ...(options.stdin === undefined ? {} : { stdin: options.stdin }),
+        ...(options.stdout === undefined ? {} : { stdout: options.stdout }),
+        exitOnCtrlC: true,
+        clearOnShutdown: true,
+        screenMode: 'alternate-screen',
+        consoleMode: 'disabled',
+    });
+    await new Promise((resolve) => {
+        let finished = false;
+        const finish = (result) => {
+            if (finished)
+                return;
+            finished = true;
+            options.onResult?.(result);
+            renderer.destroy();
+            resolve();
+        };
+        const render = () => {
+            const current = renderer.root.getRenderable('main-menu-screen');
+            if (current)
+                renderer.root.remove('main-menu-screen');
+            renderer.root.add(createOpenTuiMainMenuScreen(state));
+            renderer.requestRender();
+        };
+        renderer.on('destroy', () => {
+            if (!finished)
+                resolve();
+        });
+        renderer.on('resize', () => {
+            state = { ...state, viewport: createTuiViewport(renderer.terminalWidth, state.viewport.width) };
+            render();
+        });
+        renderer.keyInput.on('keypress', (key) => {
+            if (key.ctrl && key.name === 'c')
+                return;
+            const action = mainMenuActionFromInput(key.sequence, keyToMainMenuInputKey(key));
+            if (action === undefined)
+                return;
+            const reduced = reduceMainMenuState(state, action);
+            state = reduced.state;
+            if (reduced.result !== undefined)
+                finish(reduced.result);
+            else
+                render();
+        });
+        render();
+    });
+}
+function terminalWidth(stdout) {
+    return stdout?.columns;
+}
+function keyToMainMenuInputKey(key) {
+    return {
+        upArrow: key.name === 'up',
+        downArrow: key.name === 'down',
+        return: key.name === 'return' || key.name === 'enter',
+        escape: key.name === 'escape',
+    };
+}

package/dist/cli/tui/opentui/main-menu/screen.js

@@ -0,0 +1,62 @@
+import { Box, Text } from '@opentui/core';
+import { tuiBadges } from '../../visual/badges.js';
+import { buildMainMenuViewModel } from '../../main-menu/main-menu-read-model.js';
+import { formatMainMenuOptions } from './view.js';
+export function createOpenTuiMainMenuScreen(state) {
+    const vm = buildMainMenuViewModel(state);
+    return Box({
+        id: 'main-menu-screen',
+        flexDirection: 'column',
+        width: '100%',
+        height: '100%',
+        padding: 1,
+        gap: 1,
+        backgroundColor: '#080B12',
+    }, Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#7DD3FC',
+        paddingX: 1,
+        title: ' VGXNESS ',
+    }, Text({ content: `${vm.title}\n${vm.subtitle} ${tuiBadges.readOnly}\n${vm.contextLines.join('\n')}`, fg: '#E0F2FE', wrapMode: 'word' })), Box({
+        flexDirection: state.viewport.mode === 'narrow' ? 'column' : 'row',
+        flexGrow: 1,
+        gap: 1,
+    }, Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#A78BFA',
+        flexGrow: 1,
+        padding: 1,
+        title: ' Menu ',
+    }, Text({ content: formatMainMenuOptions(vm.options), fg: '#F8FAFC', wrapMode: 'word' })), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#22C55E',
+        flexGrow: 1,
+        padding: 1,
+        title: ` ${vm.detail.title}${vm.detail.badges.length === 0 ? '' : ` ${vm.detail.badges.join(' ')}`} `,
+    }, Text({ content: vm.detail.lines.join('\n'), fg: '#DCFCE7', wrapMode: 'word' }))), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#F59E0B',
+        paddingX: 1,
+        title: ` Safety ${tuiBadges.noProviderWrites} `,
+    }, Text({ content: vm.safetyLines.join('\n'), fg: '#FEF3C7', wrapMode: 'word' })), ...(vm.helpLines.length === 0
+        ? []
+        : [
+            Box({
+                border: true,
+                borderStyle: 'rounded',
+                borderColor: '#38BDF8',
+                paddingX: 1,
+                title: ` Help ${tuiBadges.readOnly} `,
+            }, Text({ content: vm.helpLines.join('\n'), fg: '#E0F2FE', wrapMode: 'word' })),
+        ]), Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#475569',
+        paddingX: 1,
+        title: ' Shortcuts ',
+    }, Text({ content: vm.footer, fg: '#CBD5E1', wrapMode: 'word' })));
+}

package/dist/cli/tui/opentui/main-menu/smoke.js

@@ -0,0 +1,17 @@
+import { createTestRenderer } from '@opentui/core/testing';
+import { createMainMenuState } from '../../main-menu/main-menu-state.js';
+import { createOpenTuiMainMenuScreen } from './screen.js';
+const setup = await createTestRenderer({ width: 120, height: 32 });
+try {
+    setup.renderer.root.add(createOpenTuiMainMenuScreen(createMainMenuState({ focusedOptionId: 'setup', helpVisible: true, width: 120 })));
+    await setup.renderOnce();
+    const frame = setup.captureCharFrame();
+    const requiredText = ['VGXNESS Main Menu', 'Installation', 'Requires confirmation', 'No provider writes', 'final confirmation', 'q/Esc'];
+    const missing = requiredText.filter((text) => !frame.includes(text));
+    if (missing.length > 0)
+        throw new Error(`Main menu smoke frame is missing expected text: ${missing.join(', ')}`);
+    console.log('main-menu OpenTUI smoke passed');
+}
+finally {
+    setup.renderer.destroy();
+}

package/dist/cli/tui/opentui/main-menu/view.js

@@ -0,0 +1,8 @@
+import { formatBadges, tuiBadges } from '../../visual/badges.js';
+export function formatMainMenuOptions(options) {
+    return options.map(formatMainMenuOption).join('\n');
+}
+function formatMainMenuOption(option) {
+    const badges = formatBadges([...(option.focused ? [tuiBadges.focused] : []), ...option.badges]);
+    return `${option.focused ? '›' : ' '} ${option.label}${badges.length === 0 ? '' : ` ${badges}`} — ${option.description}`;
+}

package/dist/cli/tui/opentui/setup/index.js

@@ -0,0 +1,3 @@
+export { renderOpenTuiSetup } from './renderer.js';
+export { createOpenTuiSetupScreen } from './screen.js';
+export { formatOpenTuiSetupScreen } from './view.js';

package/dist/cli/tui/opentui/setup/renderer.js

@@ -0,0 +1,87 @@
+import { createCliRenderer } from '@opentui/core';
+import { createSetupTuiController } from '../../setup/setup-tui-controller.js';
+import { setupTuiActionFromInput } from '../../setup/setup-tui-input.js';
+import { createSetupTuiState } from '../../setup/setup-tui-state.js';
+import { createOpenTuiSetupScreen } from './screen.js';
+export async function renderOpenTuiSetup(options) {
+    let state = options.initialState ?? createSetupTuiState({ selections: options.runtime.selections });
+    const renderer = await createCliRenderer({
+        ...(options.stdin === undefined ? {} : { stdin: options.stdin }),
+        ...(options.stdout === undefined ? {} : { stdout: options.stdout }),
+        exitOnCtrlC: true,
+        clearOnShutdown: true,
+        screenMode: 'alternate-screen',
+        consoleMode: 'disabled',
+    });
+    await new Promise((resolve) => {
+        let finished = false;
+        let dispatching = false;
+        const finish = () => {
+            if (finished)
+                return;
+            finished = true;
+            renderer.destroy();
+            resolve();
+        };
+        const render = () => {
+            const current = renderer.root.getRenderable('setup-screen');
+            if (current)
+                renderer.root.remove('setup-screen');
+            renderer.root.add(createOpenTuiSetupScreen(state, renderer.terminalWidth));
+            renderer.requestRender();
+            options.onState?.(state);
+        };
+        const dispatch = async (action) => {
+            dispatching = true;
+            try {
+                const controller = await createSetupTuiController({ state, services: options.services, runtime: options.runtime }).dispatch(action);
+                state = controller.state;
+                render();
+                if (state.screen === 'cancelled' && action.type === 'cancel')
+                    finish();
+            }
+            finally {
+                dispatching = false;
+            }
+        };
+        renderer.on('destroy', () => {
+            if (!finished)
+                resolve();
+        });
+        renderer.on('resize', render);
+        renderer.keyInput.on('keypress', (key) => {
+            if (key.ctrl && key.name === 'c')
+                return;
+            if (dispatching)
+                return;
+            if (isCloseKey(key) && (state.screen === 'cancelled' || state.screen === 'result' || state.screen === 'error-recovery')) {
+                finish();
+                return;
+            }
+            const action = setupTuiActionFromInput(key.sequence, keyToSetupTuiInputKey(key), state);
+            if (action !== undefined)
+                void dispatch(action);
+        });
+        void createSetupTuiController({ state, services: options.services, runtime: options.runtime })
+            .load()
+            .then((controller) => {
+            if (finished)
+                return;
+            state = controller.state;
+            render();
+        });
+    });
+}
+function isCloseKey(key) {
+    return key.name === 'escape' || key.sequence === 'q';
+}
+function keyToSetupTuiInputKey(key) {
+    return {
+        upArrow: key.name === 'up',
+        downArrow: key.name === 'down',
+        return: key.name === 'return' || key.name === 'enter',
+        escape: key.name === 'escape',
+        tab: key.name === 'tab',
+        shift: key.shift === true,
+    };
+}

package/dist/cli/tui/opentui/setup/screen.js

@@ -0,0 +1,170 @@
+import { Box, Text } from '@opentui/core';
+import { buildSetupTuiViewModel } from '../../setup/setup-tui-read-model.js';
+import { formatFooter, setupFooterHints } from '../../setup/setup-tui-view-helpers.js';
+export function createOpenTuiSetupScreen(state, width) {
+    const vm = buildSetupTuiViewModel(state);
+    const screen = setupScreenContent(state, vm, width);
+    return Box({
+        id: 'setup-screen',
+        flexDirection: 'column',
+        width: '100%',
+        height: '100%',
+        padding: 1,
+        backgroundColor: '#080B12',
+        gap: 1,
+    }, headerPanel(vm), Box({ flexDirection: width < 100 ? 'column' : 'row', flexGrow: 1, gap: 1 }, setupPanel({ title: screen.leftTitle, content: screen.left, borderColor: '#A78BFA', grow: 1 }), setupPanel({ title: screen.rightTitle, content: screen.right, borderColor: '#22C55E', grow: 1 })), setupPanel({ title: ' Safety ', content: screen.safety, borderColor: state.screen === 'final-confirmation' ? '#F59E0B' : '#38BDF8' }), ...(screen.help.length === 0 ? [] : [setupPanel({ title: ' Help [read-only] ', content: screen.help, borderColor: '#38BDF8' })]), Box({ border: true, borderStyle: 'rounded', borderColor: '#475569', paddingX: 1, title: ' Shortcuts ' }, Text({ content: screen.footer, fg: '#CBD5E1', wrapMode: 'word' })));
+}
+function headerPanel(vm) {
+    return Box({ border: true, borderStyle: 'rounded', borderColor: '#7DD3FC', paddingX: 1, title: ' VGXNESS Setup ' }, Text({
+        content: `${vm.title}\n${vm.progressLabel}\nProject: ${vm.projectLabel} · Provider: ${vm.providerLabel} · Database: ${vm.databaseLabel}`,
+        fg: '#E0F2FE',
+        wrapMode: 'word',
+    }));
+}
+function setupPanel(input) {
+    return Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: input.borderColor,
+        paddingX: 1,
+        title: input.title,
+        ...(input.grow === undefined ? {} : { flexGrow: input.grow }),
+    }, Text({ content: input.content.join('\n'), fg: '#F8FAFC', wrapMode: 'word' }));
+}
+function setupScreenContent(state, vm, width) {
+    const footer = footerForScreen(state.screen, width);
+    const safety = safetyLines(vm, state.screen);
+    const help = state.helpVisible ? vm.helpLines : [];
+    switch (state.screen) {
+        case 'welcome':
+            return {
+                leftTitle: ' Flow ',
+                left: ['1. Choose storage', '2. Choose provider', '3. Review OpenCode details', '4. Read-only plan preview', '5. Final confirmation', '6. Result and next steps'],
+                rightTitle: ' Current context ',
+                right: previewLines(vm),
+                safety,
+                help,
+                footer,
+            };
+        case 'project-database':
+            return {
+                leftTitle: ' Database choices ',
+                left: choiceLines(vm.databaseChoices),
+                rightTitle: focusedChoiceTitle(vm.databaseChoices, 'Database details'),
+                right: [...focusedChoiceDetails(vm.databaseChoices), `Mode: ${vm.databaseLabel}`, `Path: ${vm.databasePathLabel}`, `Source: ${vm.databaseSourceLabel}`],
+                safety,
+                help,
+                footer,
+            };
+        case 'provider':
+            return {
+                leftTitle: ' Provider choices ',
+                left: choiceLines(vm.providerChoices),
+                rightTitle: focusedChoiceTitle(vm.providerChoices, 'Provider details'),
+                right: [...focusedChoiceDetails(vm.providerChoices), vm.providerInstallabilityLabel],
+                safety,
+                help,
+                footer,
+            };
+        case 'opencode-details':
+            return {
+                leftTitle: ' OpenCode controls ',
+                left: [...choiceLines(vm.scopeChoices), '', ...choiceLines(vm.installModeChoices)].filter(Boolean),
+                rightTitle: ' Plan target ',
+                right: [`Scope: ${vm.scopeLabel}`, `Install mode: ${vm.installModeLabel}`, `Action: ${vm.opencodeActionLabel}`, `Target: ${vm.targetPathLabel}`, `Agents: ${vm.agentReadinessLabel}`],
+                safety,
+                help,
+                footer,
+            };
+        case 'plan-review':
+            return {
+                leftTitle: ' Read-only plan ',
+                left: planSummaryLines(vm),
+                rightTitle: ' Blockers / next ',
+                right: blockerAndNextLines(vm),
+                safety,
+                help,
+                footer,
+            };
+        case 'final-confirmation':
+            return {
+                leftTitle: ' Final confirmation ',
+                left: ['! This is the first write-capable step.', 'Press Enter only if the target and backups look correct.', 'Esc/q cancels without writing.', '', ...planSummaryLines(vm)],
+                rightTitle: ' Before apply ',
+                right: blockerAndNextLines(vm),
+                safety,
+                help,
+                footer,
+            };
+        case 'applying':
+            return { leftTitle: ' Applying ', left: ['Applying confirmed OpenCode setup...', 'Waiting for the apply operation to finish.'], rightTitle: ' Status ', right: previewLines(vm), safety, help, footer };
+        case 'result':
+            return { leftTitle: ' Result ', left: ['Setup finished.', ...vm.nextCommands.map((command) => `Next: ${command}`)], rightTitle: ' Summary ', right: previewLines(vm), safety, help, footer };
+        case 'error-recovery':
+            return { leftTitle: ' Recovery ', left: ['! Setup hit an error.', 'No unconfirmed provider config write was performed.', 'Inspect `vgx setup plan`, resolve blockers, then retry.'], rightTitle: ' Context ', right: previewLines(vm), safety, help, footer };
+        case 'cancelled':
+            return { leftTitle: ' Cancelled ', left: ['Setup was cancelled.', 'No provider config was written.', 'No agent seeding was performed.'], rightTitle: ' Context ', right: previewLines(vm), safety, help, footer };
+    }
+}
+function choiceLines(choices) {
+    if (choices.length === 0)
+        return ['No editable choices on this step.'];
+    return choices.map((choice) => `${choice.focused ? '›' : ' '} ${choice.label}${choiceBadges(choice)}\n  ${choice.description}`);
+}
+function choiceBadges(choice) {
+    const badges = [...(choice.selected ? ['[selected]'] : []), ...(choice.focused ? ['[focused]'] : []), ...choice.badges];
+    return badges.length === 0 ? '' : ` ${badges.join(' ')}`;
+}
+function focusedChoiceTitle(choices, fallback) {
+    return ` ${choices.find((choice) => choice.focused)?.label ?? fallback} `;
+}
+function focusedChoiceDetails(choices) {
+    const focused = choices.find((choice) => choice.focused) ?? choices.find((choice) => choice.selected) ?? choices[0];
+    if (focused === undefined)
+        return ['No focused choice.'];
+    return [focused.description, focused.badges.length === 0 ? 'Badges: none' : `Badges: ${focused.badges.join(' ')}`];
+}
+function previewLines(vm) {
+    return [
+        `Readiness: ${vm.readinessBadge} ${vm.readinessLabel}`,
+        `Provider: ${vm.providerLabel}`,
+        `Database: ${vm.databaseLabel}`,
+        `Path: ${vm.databasePathLabel}`,
+        `Target: ${vm.targetPathLabel}`,
+        `Backups: ${vm.backupLabel.replace(/^Backup(?: planned)?:\s*/u, '')}`,
+    ];
+}
+function planSummaryLines(vm) {
+    return [
+        `Provider: ${vm.providerLabel}`,
+        `Database: ${vm.databaseLabel}`,
+        `Target: ${vm.targetPathLabel}`,
+        `Agents: ${vm.agentReadinessLabel}`,
+        vm.backupLabel,
+        ...vm.plannedActions.slice(0, 3).map((action) => `${action.safetyBadge} ${action.label}`),
+    ];
+}
+function blockerAndNextLines(vm) {
+    return [
+        ...(vm.blockers.length === 0 ? ['Blockers: none'] : vm.blockers.map((blocker) => `! ${blocker}`)),
+        ...(vm.warnings.length === 0 ? ['Warnings: none'] : vm.warnings.map((warning) => `! ${warning}`)),
+        '',
+        ...vm.nextCommands.slice(0, 3).map((command) => `Next: ${command}`),
+    ].filter(Boolean);
+}
+function safetyLines(vm, screen) {
+    return [
+        screen === 'final-confirmation' ? '! Final confirmation can apply OpenCode setup.' : 'Read-only until final confirmation.',
+        vm.footerSafetyLabel,
+        vm.canAutoApply ? 'Apply is available only from final confirmation.' : 'Automatic apply is currently unavailable for this selection.',
+    ];
+}
+function footerForScreen(screen, width) {
+    if (screen === 'final-confirmation')
+        return formatFooter([setupFooterHints.confirmApply, setupFooterHints.back, setupFooterHints.cancel], width);
+    if (screen === 'project-database' || screen === 'provider' || screen === 'opencode-details')
+        return formatFooter([setupFooterHints.select, setupFooterHints.continue, setupFooterHints.back, setupFooterHints.cancel], width);
+    if (screen === 'result' || screen === 'error-recovery' || screen === 'cancelled')
+        return formatFooter([setupFooterHints.close], width);
+    return formatFooter([setupFooterHints.continue, setupFooterHints.back, setupFooterHints.cancel], width);
+}

package/dist/cli/tui/opentui/setup/smoke.js

@@ -0,0 +1,42 @@
+import { createTestRenderer } from '@opentui/core/testing';
+import { createSetupTuiState } from '../../setup/setup-tui-state.js';
+import { createOpenTuiSetupScreen } from './screen.js';
+const setup = await createTestRenderer({ width: 160, height: 70 });
+try {
+    setup.renderer.root.add(createOpenTuiSetupScreen(createSetupTuiState({
+        screen: 'final-confirmation',
+        plan: {
+            version: 1,
+            kind: 'setup-plan',
+            status: 'ready',
+            project: 'vgxness',
+            workspaceRoot: '/tmp/project',
+            db: { mode: 'global', path: '/tmp/db.sqlite', source: 'flag' },
+            provider: 'opencode',
+            opencode: { scope: 'user', action: 'merge', targetPath: '/tmp/.config/opencode/opencode.json', installsAgents: true, agentNames: ['vgxness-manager'] },
+            actions: [
+                {
+                    id: 'opencode-merge',
+                    description: 'Merge OpenCode config with mcp.vgxness.',
+                    mutating: false,
+                    targetPath: '/tmp/.config/opencode/opencode.json',
+                    backupRequired: true,
+                },
+            ],
+            conflicts: [],
+            backupsPlanned: [{ targetPath: '/tmp/.config/opencode/opencode.json', reason: 'Existing OpenCode config would be backed up before merge.' }],
+            safety: { mutating: false, writesProviderConfig: false, requiresConfirmationForApply: true },
+            nextCommands: ['vgx setup apply --yes', 'vgx doctor'],
+        },
+    }), 120));
+    await setup.renderOnce();
+    const frame = setup.captureCharFrame();
+    const requiredText = ['VGXNESS Setup Assistant', 'Final confirmation', 'confirm and apply', 'will write after confirm', 'opencode.json'];
+    const missing = requiredText.filter((text) => !frame.includes(text));
+    if (missing.length > 0)
+        throw new Error(`Setup OpenTUI smoke frame is missing expected text: ${missing.join(', ')}`);
+    console.log('setup OpenTUI smoke passed');
+}
+finally {
+    setup.renderer.destroy();
+}

package/dist/cli/tui/opentui/setup/view.js

@@ -0,0 +1,12 @@
+import { buildSetupTuiViewModel } from '../../setup/setup-tui-read-model.js';
+import { renderSetupTuiShape } from '../../setup/setup-tui-render-shape.js';
+export function formatOpenTuiSetupScreen(state, width = 100) {
+    return renderSetupTuiShape({
+        screen: state.screen,
+        viewModel: buildSetupTuiViewModel(state),
+        ...(state.result === undefined ? {} : { result: state.result }),
+        ...(state.error === undefined ? {} : { error: state.error }),
+        width,
+        color: false,
+    });
+}