vgxness 1.14.0 → 1.15.0

package/dist/cli/home-tui-app.js

@@ -0,0 +1,310 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box } from 'ink';
+import { TuiCard, TuiFooter, TuiHeader, TuiSummaryBar, TuiTabs } from './tui/ink/components.js';
+import { inkTuiTheme, normalizeInkTuiWidth } from './tui/ink/theme.js';
+export const homeTuiTabs = ['setup', 'status', 'runs', 'sdd', 'skills', 'provider'];
+const homeTuiTabItems = homeTuiTabs.map((tab) => ({ key: tab, label: labelForHomeTab(tab) }));
+export function HomeTuiApp({ plan, width, selectedTab, view = 'overview', runsReadModel = { state: 'not-loaded' }, skillsReadModel = { state: 'not-loaded' }, sddInput = { change: '' } }) {
+    const cardWidth = normalizeInkTuiWidth(width);
+    if (view === 'status-focus')
+        return _jsx(FocusedStatusView, { plan: plan, width: cardWidth });
+    if (view === 'runs-focus')
+        return _jsx(FocusedRunsView, { plan: plan, width: cardWidth, runs: runsReadModel });
+    if (view === 'sdd-focus')
+        return _jsx(FocusedSddView, { plan: plan, width: cardWidth, sddInput: sddInput });
+    if (view === 'skills-focus')
+        return _jsx(FocusedSkillsView, { plan: plan, width: cardWidth, skills: skillsReadModel });
+    if (view === 'provider-focus')
+        return _jsx(FocusedProviderView, { plan: plan, width: cardWidth });
+    return (_jsxs(Box, { flexDirection: "column", width: cardWidth, paddingX: 1, paddingY: 1, children: [_jsx(TuiHeader, { title: inkTuiTheme.copy.homeTitle, subtitle: inkTuiTheme.copy.homeSubtitle, project: plan.project }), _jsx(TuiTabs, { items: homeTuiTabItems, selectedKey: selectedTab }), _jsx(TuiSummaryBar, { items: summaryItems(plan) }), _jsx(Box, { marginTop: 1, children: _jsx(HomePanel, { plan: plan, selectedTab: selectedTab }) }), _jsx(TuiFooter, { text: "Keys: \u2191/\u2193 or j/k move \u00B7 Tab/Shift+Tab next/back \u00B7 Enter opens focused area \u00B7 q exits \u00B7 read-only" })] }));
+}
+function FocusedSkillsView({ plan, width, skills }) {
+    const badge = skills.state === 'ready' ? 'read-only' : skills.state === 'unavailable' ? 'unavailable' : 'loading';
+    const tone = skills.state === 'unavailable' ? 'warning' : 'info';
+    return (_jsxs(Box, { flexDirection: "column", width: width, paddingX: 1, paddingY: 1, children: [_jsx(TuiHeader, { title: "VGXNESS Skills", subtitle: "Registry guidance cockpit \u00B7 read-only", project: plan.project }), _jsx(TuiSummaryBar, { items: summaryItems(plan) }), _jsx(Box, { marginTop: 1, children: _jsx(TuiCard, { title: "Skills", badge: badge, tone: tone, lines: focusedSkillsLines(plan, skills) }) }), _jsx(TuiFooter, { text: "Keys: Esc/b back to Home \u00B7 q exits \u00B7 read-only \u00B7 no provider skill writes" })] }));
+}
+function FocusedRunsView({ plan, width, runs }) {
+    const badge = runs.state === 'ready' ? 'read-only' : runs.state === 'unavailable' ? 'unavailable' : 'loading';
+    const tone = runs.state === 'unavailable' ? 'warning' : 'info';
+    return (_jsxs(Box, { flexDirection: "column", width: width, paddingX: 1, paddingY: 1, children: [_jsx(TuiHeader, { title: "VGXNESS Runs", subtitle: "Run recovery cockpit \u00B7 read-only", project: plan.project }), _jsx(TuiSummaryBar, { items: summaryItems(plan) }), _jsx(Box, { marginTop: 1, children: _jsx(TuiCard, { title: "Runs", badge: badge, tone: tone, lines: focusedRunsLines(plan, runs) }) }), _jsx(TuiFooter, { text: "Keys: Esc/b back to Home \u00B7 q exits \u00B7 read-only \u00B7 no writes" })] }));
+}
+function FocusedSddView({ plan, width, sddInput }) {
+    return (_jsxs(Box, { flexDirection: "column", width: width, paddingX: 1, paddingY: 1, children: [_jsx(TuiHeader, { title: "VGXNESS SDD", subtitle: "Spec-driven development cockpit \u00B7 change required \u00B7 read-only", project: plan.project }), _jsx(TuiSummaryBar, { items: summaryItems(plan) }), _jsx(Box, { marginTop: 1, children: _jsx(TuiCard, { title: "SDD change gate", badge: sddInput.change.length === 0 ? 'change required' : 'change selected', tone: "info", lines: focusedSddLines(plan, sddInput) }) }), _jsx(TuiFooter, { text: "Keys: type change id \u00B7 Backspace edits \u00B7 Esc back \u00B7 Ctrl-C exits \u00B7 local SDD state not opened" })] }));
+}
+function FocusedStatusView({ plan, width }) {
+    return (_jsxs(Box, { flexDirection: "column", width: width, paddingX: 1, paddingY: 1, children: [_jsx(TuiHeader, { title: "VGXNESS Status", subtitle: "Focused setup readiness \u00B7 read-only", project: plan.project }), _jsx(TuiSummaryBar, { items: summaryItems(plan) }), _jsx(Box, { marginTop: 1, children: _jsx(TuiCard, { title: "Current setup status", badge: plan.status === 'ready' ? 'ready' : statusTitle(plan.status), tone: plan.status === 'ready' ? 'success' : plan.status === 'conflict' ? 'danger' : 'warning', lines: focusedStatusLines(plan) }) }), _jsx(TuiFooter, { text: "Keys: Esc/b back to Home \u00B7 q exits \u00B7 read-only \u00B7 no provider config writes" })] }));
+}
+function FocusedProviderView({ plan, width }) {
+    return (_jsxs(Box, { flexDirection: "column", width: width, paddingX: 1, paddingY: 1, children: [_jsx(TuiHeader, { title: "VGXNESS Provider", subtitle: "Provider setup plan \u00B7 read-only", project: plan.project }), _jsx(TuiSummaryBar, { items: summaryItems(plan) }), _jsx(Box, { marginTop: 1, children: _jsx(TuiCard, { title: "Provider plan", badge: providerTitle(plan.provider), tone: plan.provider === 'opencode' ? 'info' : 'warning', lines: focusedProviderLines(plan) }) }), _jsx(TuiFooter, { text: "Keys: Esc/b back to Home \u00B7 q exits \u00B7 read-only \u00B7 providers were not executed" })] }));
+}
+function HomePanel({ plan, selectedTab }) {
+    if (selectedTab === 'setup')
+        return _jsx(TuiCard, { title: "Setup", badge: "preview-only", tone: "warning", lines: setupLines(plan) });
+    if (selectedTab === 'status')
+        return _jsx(TuiCard, { title: "Status", badge: plan.status === 'ready' ? 'ready' : 'blocked', tone: plan.status === 'ready' ? 'success' : 'danger', lines: statusLines(plan) });
+    if (selectedTab === 'runs')
+        return _jsx(TuiCard, { title: "Runs", badge: "coming-soon", tone: "neutral", lines: runsLines() });
+    if (selectedTab === 'sdd')
+        return _jsx(TuiCard, { title: "SDD", badge: "manual", tone: "info", lines: sddLines() });
+    if (selectedTab === 'skills')
+        return _jsx(TuiCard, { title: "Skills", badge: "read-only", tone: "info", lines: skillsLines() });
+    return _jsx(TuiCard, { title: "Provider", badge: plan.opencode === undefined ? 'manual' : plan.status === 'ready' ? 'ready' : 'blocked', tone: plan.status === 'ready' ? 'success' : 'warning', lines: providerLines(plan) });
+}
+function setupLines(plan) {
+    return [
+        'Setup preview',
+        '',
+        field('Project', plan.project),
+        field('Status', plan.status),
+        field('Provider', plan.provider),
+        field('Database', `${plan.db.mode} (${plan.db.source})`),
+        field('Safety', 'read-only preview'),
+        '',
+        'Press Enter to open the focused setup flow.',
+        'CLI fallback: `vgxness init`.',
+        'Use `vgxness setup plan` for a copyable text preview.',
+    ];
+}
+function statusLines(plan) {
+    return [
+        field('Setup', plan.status),
+        field('Provider', plan.provider),
+        field('Actions', plan.actions.length === 0 ? 'none planned' : `${plan.actions.length} preview action(s)`),
+        field('Conflicts', plan.conflicts.length === 0 ? 'none' : `${plan.conflicts.length} item(s)`),
+        '',
+        'This home view is intentionally read-only and does not open provider processes.',
+        nextSetupStep(plan),
+    ];
+}
+function focusedStatusLines(plan) {
+    return [
+        field('Project', plan.project),
+        field('Setup', plan.status),
+        field('Provider', providerTitle(plan.provider)),
+        field('Database', `${plan.db.mode} (${plan.db.source})`),
+        field('Actions', plan.actions.length === 0 ? 'none planned' : `${plan.actions.length} preview action(s)`),
+        field('Conflicts', plan.conflicts.length === 0 ? 'none' : `${plan.conflicts.length} item(s)`),
+        field('Backups', plan.backupsPlanned.length === 0 ? 'none planned' : `${plan.backupsPlanned.length} planned for future apply`),
+        field('Provider writes', String(plan.safety.writesProviderConfig)),
+        '',
+        nextSetupStep(plan),
+        ...(plan.conflicts.length === 0 ? [] : ['', 'Blocking conflicts:', ...plan.conflicts.map((conflict) => `- ${conflict.message}`)]),
+        '',
+        'This focused panel is still a setup-readiness view; it does not open local run/SDD state.',
+    ];
+}
+function focusedRunsLines(plan, runs) {
+    if (runs.state === 'unavailable') {
+        return [
+            field('Project', plan.project),
+            field('Store', 'unavailable'),
+            field('Database', runs.databasePath),
+            field('Safety', 'read-only'),
+            '',
+            runs.message,
+            '',
+            'Use `vgxness resume --project <name>` to inspect interrupted runs from a Bun-backed runtime.',
+            'Use `vgxness runs list --project <name> --status needs-human` for actionable blockers.',
+        ];
+    }
+    if (runs.state === 'ready') {
+        return [
+            field('Project', plan.project),
+            field('Store', 'opened read-only'),
+            field('Database', runs.databasePath),
+            field('Recent runs', String(runs.recent.length)),
+            field('Interrupted', String(runs.interrupted.length)),
+            '',
+            ...runSummarySection('Interrupted runs', runs.interrupted),
+            '',
+            ...runSummarySection('Recent runs', runs.recent),
+            '',
+            'Inspect one run: `vgxness runs get --id <run-id>`.',
+        ];
+    }
+    return [
+        field('Project', plan.project),
+        field('Loaded state', 'not opened'),
+        field('Safety', 'read-only placeholder'),
+        '',
+        'This panel does not open the local SQLite store yet.',
+        'Use `vgxness resume --project <name>` to inspect interrupted runs.',
+        'Use `vgxness runs list --project <name> --status needs-human` for actionable blockers.',
+        '',
+        'Next implementation slice can wire this panel to the run read model.',
+    ];
+}
+function runSummarySection(title, runs) {
+    if (runs.length === 0)
+        return [title, '- none'];
+    return [title, ...runs.map((run) => `- ${shortRunId(run.id)} ${run.status} ${run.workflow}/${run.phase}${run.userIntent === undefined ? '' : ` — ${run.userIntent}`}`)];
+}
+function shortRunId(id) {
+    return id.length <= 8 ? id : id.slice(0, 8);
+}
+function focusedSddLines(plan, input) {
+    const change = input.change.length === 0 ? '<id>' : input.change;
+    return [
+        field('Project', plan.project),
+        field('Change', input.change.length === 0 ? 'not selected' : input.change),
+        field('Input', `${input.change}_`),
+        field('Store', 'not opened'),
+        field('Acceptance', 'human-only'),
+        field('Safety', 'read-only gate'),
+        '',
+        'This panel intentionally does not open SQLite until a change id is selected.',
+        'Allowed input: letters, numbers, dot, underscore, dash; first character must be alphanumeric.',
+        'Daily SDD stays in OpenCode through conversation, VGXNESS MCP, hidden SDD subagents, and registry skills.',
+        '',
+        `Continue: vgxness sdd continue --project ${plan.project} --change ${change}`,
+        `Status:   vgxness sdd status --project ${plan.project} --change ${change}`,
+        'Governance reminder: artifact presence is not acceptance; acceptance is explicit and human-only.',
+        '',
+        'Next implementation slice can ask for/select a change id before loading SDD state.',
+    ];
+}
+function focusedSkillsLines(plan, skills) {
+    if (skills.state === 'unavailable') {
+        return [
+            field('Project', plan.project),
+            field('Scope', 'project'),
+            field('Store', 'unavailable'),
+            field('Database', skills.databasePath),
+            '',
+            skills.message,
+            '',
+            'Use `vgxness skills index --project <name> --scope project` from a Bun-backed runtime.',
+            'OpenCode native skill installation is not performed by this TUI.',
+        ];
+    }
+    if (skills.state === 'ready') {
+        return [
+            field('Project', skills.index.project),
+            field('Scope', skills.index.scope),
+            field('Store', 'opened read-only'),
+            field('Skills', String(skills.index.totals.skills)),
+            field('Active', String(skills.index.totals.active)),
+            field('Preview-only', String(skills.index.totals.previewOnly)),
+            field('Provider writes', String(skills.index.safety.providerConfigWrites)),
+            '',
+            ...skillSummarySection(skills.index.skills),
+            '',
+            'OpenCode native skill installation is not performed by this TUI.',
+        ];
+    }
+    return [
+        field('Project', plan.project),
+        field('Scope', 'project'),
+        field('Provider', 'preview-only'),
+        '',
+        'Skill registry view is planned and remains read-only here.',
+        'Use `vgxness skills index --project <name> --scope project` for the current CLI view.',
+        'OpenCode native skill installation is not performed by this TUI.',
+        '',
+        'Next implementation slice can show registry diagnostics and attached skill summaries.',
+    ];
+}
+function skillSummarySection(skills) {
+    if (skills.length === 0)
+        return ['Indexed skills', '- none'];
+    return ['Indexed skills', ...skills.slice(0, 8).map((skill) => `- ${skill.name} ${skill.status}${skill.activeVersion === null ? '' : ` @ ${skill.activeVersion}`}`), ...(skills.length > 8 ? [`- +${skills.length - 8} more`] : [])];
+}
+function runsLines() {
+    return ['Run dashboard is not loaded in this first Home TUI slice.', '', 'Use `vgxness status` or `vgxness resume --project <name>` for current CLI diagnostics.', 'Next slice can wire this panel to the run read model.'];
+}
+function sddLines() {
+    return [
+        'Change: not selected. Press Enter for the focused SDD gate.',
+        '',
+        'The Home TUI does not open local SDD state until a change id is selected.',
+        'Daily SDD should stay in OpenCode through conversation, VGXNESS MCP, and hidden SDD subagents.',
+        '',
+        'CLI fallback: `vgxness sdd continue --project <name> --change <id>`.',
+    ];
+}
+function skillsLines() {
+    return ['Skill registry view is planned.', '', 'Read-only CLI today: `vgxness skills index --project <name> --scope project`.'];
+}
+function providerLines(plan) {
+    if (plan.opencode === undefined)
+        return [field('Provider', plan.provider), 'No provider-specific setup plan is available.'];
+    return [
+        field('Provider', 'opencode'),
+        field('Scope', plan.opencode.scope),
+        field('Action', plan.opencode.action),
+        field('Installs agents', plan.opencode.installsAgents ? 'yes' : 'no'),
+        field('Target', plan.opencode.targetPath ?? 'not applicable'),
+        '',
+        'Apply remains explicit: `vgxness setup apply --yes` after review.',
+    ];
+}
+function focusedProviderLines(plan) {
+    if (plan.opencode === undefined) {
+        return [
+            field('Provider', providerTitle(plan.provider)),
+            field('Setup', plan.status),
+            field('Provider writes', String(plan.safety.writesProviderConfig)),
+            '',
+            'No OpenCode-specific setup plan is available for this provider choice.',
+            'Use `vgxness setup plan --provider <name>` for copyable CLI guidance.',
+        ];
+    }
+    return [
+        field('Provider', 'OpenCode'),
+        field('Scope', plan.opencode.scope),
+        field('Planned action', plan.opencode.action),
+        field('Target', plan.opencode.targetPath ?? 'not applicable'),
+        field('Installs agents', plan.opencode.installsAgents ? 'yes' : 'no'),
+        field('Agent count', String(plan.opencode.agentNames.length)),
+        field('Bash policy', bashPolicySummary(plan.opencode.bashPermissionPolicy)),
+        field('Provider writes', String(plan.safety.writesProviderConfig)),
+        '',
+        plan.opencode.agentNames.length === 0 ? 'Agents: none planned.' : `Agents: ${plan.opencode.agentNames.join(', ')}`,
+        'Apply remains explicit: `vgxness setup apply --yes` after review.',
+    ];
+}
+function bashPolicySummary(policy) {
+    return policy.manager === 'allow' ? `${policy.topLevel} globally, allow for VGXNESS manager` : policy.topLevel;
+}
+function summaryItems(plan) {
+    const ready = plan.status === 'ready';
+    const hasConflicts = plan.conflicts.length > 0;
+    return [
+        { label: 'Setup', value: ready ? 'Ready' : statusTitle(plan.status), tone: ready ? 'success' : hasConflicts ? 'danger' : 'warning' },
+        { label: 'Provider', value: providerTitle(plan.provider), tone: plan.provider === 'opencode' ? 'info' : 'warning' },
+        { label: 'Safety', value: 'Read-only', tone: 'success' },
+    ];
+}
+function statusTitle(status) {
+    if (status === 'manual-required')
+        return 'Manual';
+    return status.charAt(0).toUpperCase() + status.slice(1);
+}
+function providerTitle(provider) {
+    if (provider === 'opencode')
+        return 'OpenCode';
+    return provider.charAt(0).toUpperCase() + provider.slice(1);
+}
+function nextSetupStep(plan) {
+    if (plan.status === 'ready')
+        return 'Next: review setup details, then apply explicitly only if intended.';
+    if (plan.status === 'conflict')
+        return 'Next: resolve the provider conflict before applying setup.';
+    return 'Next: follow manual setup guidance before applying changes.';
+}
+function labelForHomeTab(tab) {
+    if (tab === 'setup')
+        return 'Setup';
+    if (tab === 'status')
+        return 'Status';
+    if (tab === 'runs')
+        return 'Runs';
+    if (tab === 'sdd')
+        return 'SDD';
+    if (tab === 'skills')
+        return 'Skills';
+    return 'Provider';
+}
+function field(label, value) {
+    return `${label.padEnd(16)} ${value}`;
+}

package/dist/cli/home-tui-controller.js

@@ -0,0 +1,217 @@
+import { render as renderInk } from 'ink';
+import React from 'react';
+import { RunService } from '../runs/run-service.js';
+import { SkillRegistryService } from '../skills/skill-registry-service.js';
+import { SkillIndexService } from '../skills/skill-index-service.js';
+import { okText } from './cli-help.js';
+import { HomeTuiApp, homeTuiTabs } from './home-tui-app.js';
+import { renderSetupPlan } from './setup-plan-renderer.js';
+import { runSetupTuiController } from './setup-tui-controller.js';
+import { navigationIntentFromInput } from './tui/keymap.js';
+import { nextItem } from './tui/navigation.js';
+import { openMemoryDatabase } from '../memory/sqlite/database.js';
+const enter = '\r';
+const escape = '\u001B';
+const ctrlC = '\u0003';
+const backspace = '\u007F';
+const ctrlH = '\b';
+const clearScreen = '\u001B[2J\u001B[3J\u001B[H';
+export async function runHomeTuiController(input) {
+    const { stdin, stdout } = input.environment;
+    if (stdin === undefined || stdout === undefined)
+        return okText(renderSetupPlan(input.plan));
+    const width = tuiWidth(stdout);
+    let selectedTab = 'setup';
+    let view = 'overview';
+    let runsReadModel = { state: 'not-loaded' };
+    let skillsReadModel = { state: 'not-loaded' };
+    let sddInput = { change: '' };
+    const app = renderInk(React.createElement(HomeTuiApp, { plan: input.plan, width, selectedTab, view, runsReadModel, skillsReadModel, sddInput }), {
+        stdin: stdin,
+        stdout: stdout,
+        interactive: true,
+        patchConsole: false,
+        exitOnCtrlC: false,
+    });
+    const rerender = () => {
+        app.rerender(React.createElement(HomeTuiApp, { plan: input.plan, width, selectedTab, view, runsReadModel, skillsReadModel, sddInput }));
+    };
+    stdin.setRawMode?.(true);
+    stdin.resume?.();
+    const action = await new Promise((resolve) => {
+        const listener = (chunk) => {
+            const value = chunk.toString();
+            if (view === 'sdd-focus') {
+                if (value === ctrlC) {
+                    cleanup();
+                    resolve('quit');
+                    return;
+                }
+                if (value === escape) {
+                    view = 'overview';
+                    rerender();
+                    return;
+                }
+                if (value === backspace || value === ctrlH) {
+                    sddInput = { change: sddInput.change.slice(0, -1) };
+                    rerender();
+                    return;
+                }
+                const nextSddChange = appendSddChangeInput(sddInput.change, value);
+                if (nextSddChange !== sddInput.change) {
+                    sddInput = { change: nextSddChange };
+                    rerender();
+                    return;
+                }
+                if (value === enter || value === '\n')
+                    return;
+            }
+            const intent = navigationIntentFromInput(value);
+            if (value === 'q' || value === 'Q' || value === ctrlC) {
+                cleanup();
+                resolve('quit');
+                return;
+            }
+            if (view !== 'overview' && (value === escape || value === 'b' || value === 'B' || intent === 'back')) {
+                view = 'overview';
+                rerender();
+                return;
+            }
+            if (intent === 'cancel') {
+                cleanup();
+                resolve('quit');
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'setup') {
+                cleanup();
+                resolve('open-setup');
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'status') {
+                view = 'status-focus';
+                rerender();
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'runs') {
+                runsReadModel = readHomeRuns(input.plan);
+                view = 'runs-focus';
+                rerender();
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'sdd') {
+                view = 'sdd-focus';
+                rerender();
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'skills') {
+                skillsReadModel = readHomeSkills(input.plan);
+                view = 'skills-focus';
+                rerender();
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'provider') {
+                view = 'provider-focus';
+                rerender();
+                return;
+            }
+            if (value === enter || value === '\n' || intent === 'select')
+                return;
+            if (view !== 'overview')
+                return;
+            if (intent === 'next' || intent === 'down') {
+                selectedTab = nextItem(homeTuiTabs, selectedTab, 1);
+                rerender();
+                return;
+            }
+            if (intent === 'back' || intent === 'up') {
+                selectedTab = nextItem(homeTuiTabs, selectedTab, -1);
+                rerender();
+            }
+        };
+        const cleanup = () => {
+            if (stdin.off !== undefined)
+                stdin.off('data', listener);
+            else
+                stdin.removeListener?.('data', listener);
+            stdin.setRawMode?.(false);
+            stdin.pause?.();
+            app.unmount();
+        };
+        stdin.on('data', listener);
+    });
+    await app.waitUntilExit();
+    if (action === 'open-setup') {
+        clearTerminalBeforeNestedTui(stdout);
+        return runSetupTuiController({ environment: input.environment, plan: input.plan });
+    }
+    return okText('');
+}
+function appendSddChangeInput(current, input) {
+    if (input.length !== 1 || current.length >= 80)
+        return current;
+    if (current.length === 0)
+        return /^[A-Za-z0-9]$/.test(input) ? input : current;
+    return /^[A-Za-z0-9._-]$/.test(input) ? `${current}${input}` : current;
+}
+function clearTerminalBeforeNestedTui(stdout) {
+    stdout.write(clearScreen);
+}
+function readHomeRuns(plan) {
+    const opened = openMemoryDatabase({ path: plan.db.path, readonly: true });
+    if (!opened.ok)
+        return { state: 'unavailable', databasePath: plan.db.path, message: opened.error.message };
+    try {
+        const service = new RunService(opened.value);
+        const recent = service.listRuns({ project: plan.project, limit: 5 });
+        if (!recent.ok)
+            return { state: 'unavailable', databasePath: plan.db.path, message: recent.error.message };
+        const interrupted = service.listRecentInterruptedRuns({ project: plan.project, limit: 5 });
+        if (!interrupted.ok)
+            return { state: 'unavailable', databasePath: plan.db.path, message: interrupted.error.message };
+        return {
+            state: 'ready',
+            databasePath: plan.db.path,
+            recent: recent.value.map(runRecordSummary),
+            interrupted: interrupted.value.map((run) => ({
+                id: run.runId,
+                status: run.status,
+                workflow: run.workflow,
+                phase: run.phase,
+                ...(run.userIntent === undefined ? {} : { userIntent: run.userIntent }),
+            })),
+        };
+    }
+    finally {
+        opened.value.close();
+    }
+}
+function runRecordSummary(run) {
+    const userIntent = run.userIntent.trim();
+    return {
+        id: run.id,
+        status: run.status,
+        workflow: run.workflow,
+        phase: run.phase,
+        ...(userIntent.length === 0 ? {} : { userIntent }),
+    };
+}
+function readHomeSkills(plan) {
+    const opened = openMemoryDatabase({ path: plan.db.path, readonly: true });
+    if (!opened.ok)
+        return { state: 'unavailable', databasePath: plan.db.path, message: opened.error.message };
+    try {
+        const registry = new SkillRegistryService(opened.value);
+        const index = new SkillIndexService(registry).getIndex({ project: plan.project, scope: 'project' });
+        if (!index.ok)
+            return { state: 'unavailable', databasePath: plan.db.path, message: index.error.message };
+        return { state: 'ready', databasePath: plan.db.path, index: index.value };
+    }
+    finally {
+        opened.value.close();
+    }
+}
+function tuiWidth(stdout) {
+    const columns = stdout.columns;
+    const width = typeof columns === 'number' && Number.isFinite(columns) ? Math.floor(columns) : 88;
+    return Math.max(60, Math.min(width, 88));
+}

package/dist/cli/setup-plan-renderer.js

@@ -1,55 +1,79 @@
+import { joinSections, renderActionLine, renderPanel } from './tui-render-helpers.js';
 export function renderSetupPlan(plan) {
-    return [
-        'Setup Plan [read-only] [preview]',
-        `Project: ${plan.project}`,
-        `Workspace root: ${plan.workspaceRoot}`,
-        `Database: ${plan.db.mode} — ${plan.db.path} (source: ${plan.db.source})`,
-        `Provider: ${plan.provider}`,
-        ...renderOpenCode(plan),
-        ...renderActions(plan),
-        ...renderBackups(plan),
-        ...renderConflicts(plan),
-        ...renderNextCommands(plan),
+    return `${joinSections([
+        renderPanel('VGXNESS Setup [read-only]', renderOverview(plan), { status: 'preview-only' }),
+        renderOpenCode(plan),
+        renderPanel('Planned Actions', renderActions(plan), { status: 'preview-only' }),
+        renderPanel('Backups', renderBackups(plan), { status: 'requires confirmation' }),
+        renderConflicts(plan),
+        renderPanel('Next Commands', renderNextCommands(plan), { status: 'manual' }),
         'Safety: [read-only] preview only. No provider config was written. Explicit confirmation is required before writing provider config; apply with --yes only after review.',
-    ].join('\n');
+    ])}\n`;
 }
 function renderOpenCode(plan) {
     if (plan.opencode === undefined)
-        return [];
+        return undefined;
     const target = plan.opencode.targetPath === undefined ? 'not applicable' : plan.opencode.targetPath;
-    return [
-        'OpenCode:',
-        `- Scope: ${plan.opencode.scope}`,
-        `- Action: ${plan.opencode.action}`,
-        `- Target path: ${target}`,
-        `- Installs agents: ${String(plan.opencode.installsAgents)}`,
-        `- Reinstall VGXNESS entries: ${String(plan.opencode.overwriteVgxness)}`,
-        `- Agent names: ${plan.opencode.agentNames.length === 0 ? 'none' : plan.opencode.agentNames.join(', ')}`,
-    ];
+    const status = plan.status === 'ready' ? 'ready' : plan.status === 'conflict' ? 'blocked' : 'manual';
+    return renderPanel('OpenCode Provider', [
+        field('Scope', plan.opencode.scope),
+        field('Action', plan.opencode.action),
+        field('Target path', target),
+        field('Installs agents', yesNo(plan.opencode.installsAgents)),
+        field('Reinstall entries', yesNo(plan.opencode.overwriteVgxness === true)),
+        field('Bash policy', formatBashPermissionPolicy(plan.opencode.bashPermissionPolicy)),
+        field('Agent names', plan.opencode.agentNames.length === 0 ? 'none' : plan.opencode.agentNames.join(', ')),
+    ], { status });
 }
 function renderActions(plan) {
     if (plan.actions.length === 0)
-        return ['Actions: none'];
-    return [
-        'Actions:',
-        ...plan.actions.map((action) => `- ${action.id}: ${action.description} (mutating: ${String(action.mutating)}, backup: ${String(action.backupRequired)}${action.targetPath === undefined ? '' : `, target: ${action.targetPath}`})`),
-    ];
+        return ['No provider config writes are planned for this preview.'];
+    return plan.actions.flatMap((action) => renderActionLine(action.id, {
+        labels: [action.mutating ? 'writes provider config' : 'no provider writes', action.backupRequired ? 'requires confirmation' : 'preview-only'],
+        description: action.targetPath === undefined ? action.description : `${action.description} Target: ${action.targetPath}`,
+    }));
 }
 function renderBackups(plan) {
     if (plan.backupsPlanned.length === 0)
-        return ['Backups: none'];
-    return ['Backups:', ...plan.backupsPlanned.map((backup) => `- ${backup.targetPath}: ${backup.reason}`)];
+        return ['No backups are required for this preview.'];
+    return plan.backupsPlanned.flatMap((backup) => renderActionLine(backup.targetPath, { labels: ['requires confirmation'], description: backup.reason }));
 }
 function renderConflicts(plan) {
     if (plan.conflicts.length === 0)
-        return ['Conflicts/recovery: none'];
-    return [
-        'Conflicts/recovery:',
-        ...plan.conflicts.map((conflict) => `- ${conflict.severity} ${conflict.id}: ${conflict.message}${conflict.targetPath === undefined ? '' : ` (target: ${conflict.targetPath})`}${conflict.recovery === undefined ? '' : ` Recovery: ${conflict.recovery}`}`),
-    ];
+        return undefined;
+    return renderPanel('Conflicts & Recovery', plan.conflicts.flatMap((conflict) => renderActionLine(conflict.id, {
+        labels: [conflict.severity === 'blocking' ? 'blocked' : 'manual'],
+        description: [
+            conflict.message,
+            conflict.targetPath === undefined ? undefined : `Target: ${conflict.targetPath}`,
+            conflict.recovery === undefined ? undefined : `Recovery: ${conflict.recovery}`,
+        ]
+            .filter((value) => value !== undefined)
+            .join(' '),
+    })), { status: 'blocked' });
 }
 function renderNextCommands(plan) {
     if (plan.nextCommands.length === 0)
-        return ['Next commands: none'];
-    return ['Next commands:', ...plan.nextCommands.map((command) => `- ${command}`)];
+        return ['No next command is recommended.'];
+    return plan.nextCommands.flatMap((command) => renderActionLine(command, { labels: ['manual'] }));
+}
+function renderOverview(plan) {
+    return [
+        field('Project', plan.project),
+        field('Workspace', plan.workspaceRoot),
+        field('Database', `${plan.db.mode} — ${plan.db.path}`),
+        field('DB source', plan.db.source),
+        field('Provider', plan.provider),
+        field('Status', plan.status),
+    ];
+}
+function field(label, value) {
+    return `${label.padEnd(18)} ${value}`;
+}
+function yesNo(value) {
+    return value ? 'yes' : 'no';
+}
+function formatBashPermissionPolicy(policy) {
+    const typedPolicy = policy;
+    return `top-level ${typedPolicy.topLevel}; manager ${typedPolicy.manager}`;
 }