vgxness 1.5.1 → 1.6.0

package/dist/cli/commands/agent-skill-dispatcher.js

@@ -266,13 +266,14 @@ export function runAgentCommand(command, parsed, database, environment) {
     if (command === 'seed') {
         if (parsed.positionals[2] !== 'load')
             return usageFailure('agents seed requires load');
-        const file = requiredFlag(parsed.flags, 'file');
-        if (!file.ok)
-            return resultFailure(file);
-        const manifest = readJsonFile(file.value, environment);
+        const file = optionalStringFlag(parsed.flags, 'file');
+        const seed = new AgentSeedService(database);
+        if (file === undefined)
+            return jsonResult(seed.loadBuiltInDefaults());
+        const manifest = readJsonFile(file, environment);
         if (!manifest.ok)
             return resultFailure(manifest);
-        return jsonResult(new AgentSeedService(database).loadManifest(manifest.value));
+        return jsonResult(seed.loadManifest(manifest.value));
     }
     if (command === 'register') {
         const payload = registerPayload(parsed, environment, false);

package/dist/cli/commands/interactive-entrypoint-dispatcher.js

@@ -13,7 +13,7 @@ import { canRunInteractiveTui } from '../tui/terminal-capabilities.js';
 import { runSetupTuiCommand } from './setup-dispatcher.js';
 function defaultNoTtyGuidance() {
     return ([
-        'VGXNESS main menu requires a TTY; no provider config was written.',
+        'VGXNESS Dashboard requires a TTY; no provider config was written.',
         'Next: rerun `vgxness` in an interactive terminal, run `vgxness init --plan`, or run `vgxness setup plan` for read-only installation guidance.',
     ].join('\n') + '\n');
 }
@@ -25,7 +25,7 @@ function guidanceForMainMenuResult(result) {
     if (result.type === 'show-advanced-cli')
         return ['Advanced CLI guidance:', '- Installation preview: `vgxness init --plan` or `vgxness setup plan`', '- Setup status: `vgxness setup status --project <name>`', '- SDD status: `vgxness sdd status --project <name> --change <change>`', '- No provider config was written.'].join('\n') + '\n';
     if (result.type === 'exit')
-        return 'Exited main menu; no provider config was written.\n';
+        return 'Exited dashboard; no provider config was written.\n';
     return undefined;
 }
 async function renderDefaultMainMenu(environment, onResult) {

package/dist/cli/commands/mcp-dispatcher.js

@@ -1,17 +1,21 @@
 import { installOpenCodeMcpClient } from '../../mcp/client-install-opencode.js';
+import { installClaudeCodeMcpClient } from '../../mcp/client-install-claude-code.js';
+import { planClaudeCodeMcpInstall } from '../../mcp/client-install-claude-code-contract.js';
 import { planOpenCodeMcpInstall } from '../../mcp/client-install-opencode-contract.js';
 import { createMcpClientSetupPreview, isMcpClientSetupProvider } from '../../mcp/client-setup-preview.js';
 import { createMcpDoctorReport } from '../../mcp/doctor.js';
 import { createOpenCodeMcpVisibilityReport } from '../../mcp/opencode-visibility.js';
+import { resolveClaudeCodeScope } from '../../mcp/claude-code-scope.js';
+import { RunService } from '../../runs/run-service.js';
 import { databasePathFor, databasePathSelectionFor, opencodeInstallScopeFlag, optionalNumberFlag, optionalStringFlag } from '../cli-flags.js';
 import { usageFailure, validationFailure } from '../cli-help.js';
-import { jsonResult, resultFailure } from '../cli-helpers.js';
+import { jsonResult, openCliDatabase, resultFailure } from '../cli-helpers.js';
 import { renderDoctorReport } from '../doctor-renderer.js';
 export function runMcpInstallCommand(parsed, environment) {
     return (async () => {
         const client = parsed.positionals[2];
-        if (client !== 'opencode')
-            return usageFailure('mcp install requires client opencode');
+        if (client !== 'opencode' && client !== 'claude')
+            return usageFailure('mcp install requires client opencode or claude');
         const databasePath = databasePathSelectionFor(parsed.flags, environment);
         if (!databasePath.ok)
             return resultFailure(databasePath);
@@ -20,6 +24,39 @@ export function runMcpInstallCommand(parsed, environment) {
             return resultFailure(scope);
         const mcpOnly = parsed.flags['mcp-only'] === true || parsed.flags['no-agents'] === true;
         const overwriteVgxness = parsed.flags['overwrite-vgxness'] === true || parsed.flags.reinstall === true;
+        if (client === 'claude') {
+            const claudeScope = claudeInstallScopeFlag(parsed.flags);
+            if (!claudeScope.ok)
+                return resultFailure(claudeScope);
+            if (parsed.flags.plan === true) {
+                return jsonResult({ ok: true, value: planClaudeCodeMcpInstall({ cwd: environment.cwd, databasePath: databasePath.value.path, databasePathSource: databasePath.value.source, overwriteVgxness, scope: claudeScope.value }) });
+            }
+            if (parsed.flags.yes !== true) {
+                return resultFailure({ ok: false, error: { code: 'validation_failed', message: 'confirmation_required: `mcp install claude` requires explicit --yes before any project config write.' } });
+            }
+            if (optionalStringFlag(parsed.flags, 'run-id') === undefined) {
+                return resultFailure({ ok: false, error: { code: 'validation_failed', message: 'preflight_failed: Claude Code provider config writes require VGXNESS preflight; pass --run-id for an existing VGXNESS run before using --yes.' } });
+            }
+            const opened = openCliDatabase(databasePath.value.path);
+            if (!opened.ok)
+                return resultFailure(opened);
+            try {
+                const preflight = createClaudeCodeInstallPreflight(parsed, opened.value, environment);
+                const result = await installClaudeCodeMcpClient({
+                    cwd: environment.cwd,
+                    databasePath: databasePath.value.path,
+                    databasePathSource: databasePath.value.source,
+                    confirmed: true,
+                    overwriteVgxness,
+                    scope: claudeScope.value,
+                    preflight,
+                });
+                return result.status === 'installed' ? jsonResult({ ok: true, value: result }) : resultFailure({ ok: false, error: { code: 'validation_failed', message: `${result.reason}: ${result.message}` } });
+            }
+            finally {
+                opened.value.close();
+            }
+        }
         if (parsed.flags.plan === true) {
             return jsonResult({
                 ok: true,
@@ -55,6 +92,41 @@ export function runMcpInstallCommand(parsed, environment) {
             });
     })();
 }
+function claudeInstallScopeFlag(flags) {
+    const value = optionalStringFlag(flags, 'scope');
+    const resolved = resolveClaudeCodeScope(value);
+    return resolved.ok ? { ok: true, value: resolved.value.canonical } : validationFailure(resolved.error.message);
+}
+function createClaudeCodeInstallPreflight(parsed, database, environment) {
+    return (request) => {
+        const runId = optionalStringFlag(parsed.flags, 'run-id');
+        if (runId === undefined) {
+            return validationFailure('Claude Code provider config writes require VGXNESS preflight; pass --run-id for an existing VGXNESS run before using --yes.');
+        }
+        const service = new RunService(database);
+        const details = service.getRun(runId);
+        if (!details.ok)
+            return details;
+        const phase = optionalStringFlag(parsed.flags, 'phase') ?? details.value.phase;
+        const agentId = optionalStringFlag(parsed.flags, 'agent-id') ?? details.value.selectedAgentId;
+        const preflight = service.preflightOperation({
+            runId,
+            category: request.category,
+            operation: request.operation,
+            workspaceRoot: environment.cwd,
+            targetPath: request.targetPath,
+            providerToolName: request.providerToolName,
+            phase,
+            agentId,
+        });
+        if (!preflight.ok)
+            return preflight;
+        if (preflight.value.outcome !== 'allowed') {
+            return validationFailure(`VGXNESS preflight ${preflight.value.outcome} for Claude Code provider config write: ${request.targetPath}`);
+        }
+        return { ok: true, value: preflight.value };
+    };
+}
 export function runMcpSetupCommand(parsed, environment) {
     if (parsed.flags.preview !== true)
         return usageFailure('mcp setup requires --preview; provider config installation is not supported');

package/dist/cli/commands/setup-dispatcher.js

@@ -135,6 +135,15 @@ export async function applySetupPlanInput(input, environment) {
         return validationFailure(`Setup plan is ${plan.value.status}; resolve conflicts before applying.`);
     if (input.provider === 'none')
         return { ok: true, value: { status: 'manual-required', message: 'Provider is none; there is no config to apply.', plan: plan.value } };
+    if (input.provider === 'claude')
+        return {
+            ok: true,
+            value: {
+                status: 'manual-required',
+                message: 'Claude setup apply is intentionally non-mutating here; use vgxness mcp install claude --scope project --yes --run-id <id> for guarded Claude writes.',
+                plan: plan.value,
+            },
+        };
     const result = await installOpenCodeMcpClient({
         cwd: environment.cwd,
         databasePath: plan.value.db.path,

package/dist/cli/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { startVgxMcpStdioServer } from '../mcp/stdio-server.js';
 import { dispatchCliAsync } from './dispatcher.js';
 import { resolveMcpStartDatabasePath } from './mcp-start-path.js';
 void main();
@@ -12,6 +11,7 @@ async function main() {
             process.exitCode = 1;
             return;
         }
+        const { startVgxMcpStdioServer } = await import('../mcp/stdio-server.js');
         await startVgxMcpStdioServer({ databasePath: databasePath.value });
         return;
     }

package/dist/cli/tui/main-menu/main-menu-read-model.js

@@ -1,78 +1,75 @@
 import { tuiBadges } from '../visual/badges.js';
-import { formatTuiFooter } from '../visual/footer.js';
 import { mainMenuOptionIds } from './main-menu-state.js';
+const dashboardHero = {
+    title: 'VGXNESS ONLINE',
+    subtitle: 'vgxness — local-first SDD control',
+    compactTitle: 'VGXNESS Dashboard',
+    asciiLines: ['██╗   ██╗ ██████╗ ██╗  ██╗███╗   ██╗███████╗███████╗███████╗', '██║   ██║██╔════╝ ╚██╗██╔╝████╗  ██║██╔════╝██╔════╝██╔════╝', '██║   ██║██║  ███╗ ╚███╔╝ ██╔██╗ ██║█████╗  ███████╗███████╗', '╚██╗ ██╔╝██║   ██║ ██╔██╗ ██║╚██╗██║██╔══╝  ╚════██║╚════██║', ' ╚████╔╝ ╚██████╔╝██╔╝ ██╗██║ ╚████║███████╗███████║███████║'],
+    badges: [tuiBadges.readOnly, tuiBadges.noProviderWrites],
+};
+const statCards = [
+    { label: 'actions', value: '5', badge: '', description: 'safe routes' },
+    { label: 'provider', value: '1', badge: '', description: 'OpenCode' },
+    { label: 'writes', value: '0', badge: '', description: 'dashboard render' },
+    { label: 'SDD', value: 'guided', badge: '', description: 'MCP flow' },
+];
 const statusSnapshotLines = [
-    'Primary provider: OpenCode.',
-    'Manual checks: vgxness setup status; vgxness mcp doctor opencode.',
-    'SDD cue: vgxness sdd next --project <project> --change <change>.',
-    'No checks run here; copy and run commands explicitly when needed.',
+    'OpenCode primary; dashboard does not call providers.',
+    'Advanced checks stay explicit: setup status, mcp doctor opencode.',
 ];
 const optionCopy = {
     setup: {
-        label: 'Installation',
-        description: 'Start guided installation for memory and OpenCode integration safely.',
+        label: 'Setup OpenCode',
+        description: 'guided install; confirm before writes',
         badges: [tuiBadges.requiresConfirmation],
-        detailTitle: 'Installation',
-        detailLines: [
-            'Opens the guided Installation TUI.',
-            'Plan/review screens are read-only.',
-            'Provider writes require final confirmation; OpenCode is the only automatic provider with explicit consent.',
-        ],
+        detailTitle: 'Setup OpenCode',
+        detailLines: ['Guided install opens in review mode; provider writes require final confirmation.'],
     },
     doctor: {
         label: 'Doctor / recovery',
-        description: 'See health-check and recovery commands.',
+        description: 'health and repair commands',
         badges: [tuiBadges.previewOnly],
-        detailTitle: 'Doctor guidance',
-        detailLines: ['Shows commands for status and recovery.', 'This menu only prints guidance for doctor/recovery; it does not call providers.'],
+        detailTitle: 'Doctor / recovery',
+        detailLines: ['Shows status and recovery guidance only; it does not call providers.'],
     },
     sdd: {
-        label: 'SDD / workflow guidance',
-        description: 'Review safe workflow entry points and artifact guidance.',
+        label: 'SDD workflow',
+        description: 'artifacts, phases, next step',
         badges: [tuiBadges.previewOnly],
-        detailTitle: 'SDD guidance',
-        detailLines: ['Use OpenCode conversation plus VGXNESS MCP for daily SDD progression.', 'Terminal commands are shown only as advanced/manual references.'],
+        detailTitle: 'SDD workflow',
+        detailLines: ['Use OpenCode conversation plus VGXNESS MCP for daily progression.'],
     },
     'advanced-cli': {
         label: 'Advanced CLI',
-        description: 'Show common explicit commands for experienced users.',
+        description: 'manual commands, no automation',
         badges: [tuiBadges.manual],
         detailTitle: 'Advanced CLI',
-        detailLines: ['Commands remain explicit and user-triggered.', 'No new public product commands are introduced by this menu.'],
+        detailLines: ['Prints explicit command references; no provider config is written.'],
     },
     exit: {
-        label: 'Exit',
-        description: 'Close without changing files.',
+        label: 'Quit',
+        description: 'leave cleanly',
         badges: [tuiBadges.exit, tuiBadges.noProviderWrites],
-        detailTitle: 'Exit',
-        detailLines: ['Close the main menu.', 'No provider config was written.'],
+        detailTitle: 'Quit',
+        detailLines: ['Close the dashboard; no provider config was written.'],
     },
 };
 export function buildMainMenuViewModel(state) {
     const options = mainMenuOptionIds.map((id) => ({ id, ...optionCopy[id], focused: id === state.focusedOptionId }));
     const focused = optionCopy[state.focusedOptionId];
-    const footerHints = [
-        { key: '↑/↓ j/k', label: 'move' },
-        { key: 'Enter', label: 'open focused item' },
-        { key: '?/h', label: 'help' },
-        { key: 'q/Esc', label: 'quit without writes', priority: 'critical' },
-    ];
     return {
-        title: 'VGXNESS Main Menu',
-        subtitle: 'Keyboard-first local control plane',
-        contextLines: ['Choose where to go next. Installation is first; the menu itself is read-only and does not write provider config.'],
+        title: dashboardHero.title,
+        subtitle: dashboardHero.subtitle,
+        hero: dashboardHero,
+        statCards,
+        contextLines: ['Pick a route. Dashboard render stays passive/read-only.'],
         options,
         detail: { title: focused.detailTitle, lines: focused.detailLines, badges: focused.badges },
-        statusSnapshot: { title: 'Status snapshot', lines: statusSnapshotLines, badges: [tuiBadges.readOnly, tuiBadges.noProviderWrites] },
-        safetyLines: [
-            'Previews are read-only.',
-            'Status snapshot is static guidance; no SQLite, doctor/status checks, provider calls, or provider config writes run from the main menu.',
-            'Installation/provider writes require final confirmation.',
-            'OpenCode is the only automatic provider path and still requires explicit consent.',
-        ],
+        statusSnapshot: { title: 'Signal', lines: statusSnapshotLines, badges: [tuiBadges.readOnly] },
+        safetyLines: ['read-only • no provider writes • explicit confirmation'],
         helpLines: state.helpVisible
-            ? ['Keys: ↑/↓ or j/k move, Enter open, ?/h toggle help, q/Esc quit.', 'Doctor, SDD, and Advanced CLI entries print guidance only.']
+            ? ['Keys: ↑/↓ or j/k move, Enter open, ?/h help, q/Esc quit.', 'Guidance entries print commands only; setup writes still require confirmation.']
             : [],
-        footer: formatTuiFooter(footerHints, state.viewport.width, state.viewport.mode),
+        footer: state.viewport.mode === 'narrow' ? 'no provider writes • explicit confirmation' : 'j/k • enter • q • no provider writes • explicit confirmation',
     };
 }

package/dist/cli/tui/main-menu/main-menu-render-shape.js

@@ -3,20 +3,22 @@ import { buildMainMenuViewModel } from './main-menu-read-model.js';
 export function renderMainMenuShape(input) {
     const state = input.width === undefined ? input.state : { ...input.state, viewport: { ...input.state.viewport, width: input.width } };
     const vm = buildMainMenuViewModel(state);
+    const showAscii = state.viewport.mode === 'wide';
+    const stats = vm.statCards.map((card) => `${card.value} ${card.label}`).join('      ');
     const lines = [
-        vm.title,
-        vm.subtitle,
+        `Hero: ${state.viewport.mode === 'narrow' ? vm.hero.compactTitle : vm.hero.title} ${vm.hero.badges.join(' ')}`,
+        ...(showAscii ? vm.hero.asciiLines : []),
+        vm.hero.subtitle,
         ...vm.contextLines,
-        'Menu',
+        `Stats: ${stats}`,
+        'Actions',
         ...vm.options.map(choiceLine),
-        `Detail: ${vm.detail.title}${vm.detail.badges.length === 0 ? '' : ` ${vm.detail.badges.join(' ')}`}`,
+        `Focused detail: ${vm.detail.title}${vm.detail.badges.length === 0 ? '' : ` ${vm.detail.badges.join(' ')}`}`,
         ...vm.detail.lines,
-        `${vm.statusSnapshot.title}${vm.statusSnapshot.badges.length === 0 ? '' : ` ${vm.statusSnapshot.badges.join(' ')}`}`,
+        `${vm.statusSnapshot.title}: ${vm.statusSnapshot.badges.join(' ')}`,
         ...vm.statusSnapshot.lines,
-        'Safety',
-        ...vm.safetyLines,
-        ...vm.helpLines.map((line) => `Help: ${line}`),
         `Footer: ${vm.footer}`,
+        ...vm.helpLines.map((line) => `Help: ${line}`),
     ];
     return lines.map((line) => clampLine(line, state.viewport.width)).join('\n');
 }
@@ -25,14 +27,12 @@ function clampLine(line, width) {
         return line;
     const protectedPhrases = [
         'final confirmation',
-        'read-only',
-        'Requires confirmation',
-        'explicit consent',
         'No provider writes',
+        'no provider writes',
+        'explicit confirmation',
+        'Requires confirmation',
+        'read-only',
         'quit without writes',
-        'vgxness setup status',
-        'vgxness mcp doctor opencode',
-        'no SQLite',
         'provider config writes',
     ];
     const phrase = protectedPhrases.find((candidate) => line.includes(candidate));
@@ -41,6 +41,6 @@ function clampLine(line, width) {
     return `${line.slice(0, Math.max(0, width - 1)).trim()}…`;
 }
 function choiceLine(choice) {
-    const badges = formatBadges([...(choice.focused === true ? [tuiBadges.focused] : []), ...choice.badges]);
+    const badges = formatBadges(choice.focused === true ? [tuiBadges.focused] : []);
     return `${choice.focused === true ? '›' : ' '} ${choice.label}${badges.length === 0 ? '' : ` ${badges}`} — ${choice.description}`;
 }

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

@@ -12,43 +12,7 @@ export function createOpenTuiMainMenuScreen(state) {
         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({
-        border: true,
-        borderStyle: 'rounded',
-        borderColor: '#14B8A6',
-        paddingX: 1,
-        title: ` ${vm.statusSnapshot.title} ${vm.statusSnapshot.badges.join(' ')} `,
-    }, Text({ content: vm.statusSnapshot.lines.join('\n'), fg: '#CCFBF1', 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
+    }, renderHeroPanel(vm, state), renderStatsStrip(vm), renderActionDetailPanel(vm, state), ...(vm.helpLines.length === 0
         ? []
         : [
             Box({
@@ -58,11 +22,45 @@ export function createOpenTuiMainMenuScreen(state) {
                 paddingX: 1,
                 title: ` Help ${tuiBadges.readOnly} `,
             }, Text({ content: vm.helpLines.join('\n'), fg: '#E0F2FE', wrapMode: 'word' })),
-        ]), Box({
+        ]), renderFooterStrip(vm));
+}
+function renderHeroPanel(vm, state) {
+    const title = state.viewport.mode === 'narrow' ? vm.hero.compactTitle : vm.hero.title;
+    const ascii = state.viewport.mode === 'wide' ? `${vm.hero.asciiLines.join('\n')}\n` : '';
+    return Box({
         border: true,
         borderStyle: 'rounded',
-        borderColor: '#475569',
+        borderColor: '#7DD3FC',
         paddingX: 1,
-        title: ' Shortcuts ',
-    }, Text({ content: vm.footer, fg: '#CBD5E1', wrapMode: 'word' })));
+        title: ` ${title}                         READ-ONLY `,
+    }, Text({ content: `${ascii}${vm.hero.subtitle}\n${vm.contextLines.join('\n')}`, fg: '#E0F2FE', wrapMode: 'word' }));
+}
+function renderStatsStrip(vm) {
+    const content = vm.statCards.map((card) => `${card.value} ${card.label}`).join('      ');
+    return Text({ content, fg: '#99F6E4', wrapMode: 'word' });
+}
+function renderActionDetailPanel(vm, state) {
+    return Box({
+        border: true,
+        borderStyle: 'rounded',
+        borderColor: '#A78BFA',
+        flexDirection: state.viewport.mode === 'narrow' ? 'column' : 'row',
+        flexGrow: 1,
+        gap: 1,
+        padding: 1,
+        title: ' Actions ',
+    }, renderActionsList(vm), renderFocusedDetail(vm));
+}
+function renderActionsList(vm) {
+    return Box({
+        flexGrow: 1,
+    }, Text({ content: formatMainMenuOptions(vm.options), fg: '#F8FAFC', wrapMode: 'word' }));
+}
+function renderFocusedDetail(vm) {
+    return Box({
+        flexGrow: 1,
+    }, Text({ content: `Detail: ${vm.detail.title}${vm.detail.badges.length === 0 ? '' : ` ${vm.detail.badges.join(' ')}`}\n${vm.detail.lines.join('\n')}`, fg: '#DCFCE7', wrapMode: 'word' }));
+}
+function renderFooterStrip(vm) {
+    return Text({ content: vm.footer, fg: '#CBD5E1', wrapMode: 'word' });
 }

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

@@ -6,7 +6,7 @@ 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 requiredText = ['VGXNESS ONLINE', 'Setup OpenCode', 'Requires confirmation', 'no provider writes', 'final confirmation', 'q quit'];
     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(', ')}`);

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

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

package/dist/cli/tui/setup/setup-tui-read-model.js

@@ -8,6 +8,7 @@ export function setupTuiViewModelFromPlan(plan, status, state) {
     const provider = selections?.provider ?? plan?.provider ?? 'opencode';
     const opencode = plan?.opencode;
     const isOpenCode = provider === 'opencode';
+    const isClaude = provider === 'claude';
     const project = plan?.project ?? status?.project ?? status?.projectState.project ?? 'pending project';
     const workspaceRoot = plan?.workspaceRoot ?? status?.environment.workspaceRoot ?? 'pending workspace';
     const databasePath = plan?.db.path ?? status?.store.path ?? 'pending database path';
@@ -30,22 +31,24 @@ export function setupTuiViewModelFromPlan(plan, status, state) {
         workspaceRootLabel: compactPath(workspaceRoot, 72),
         readinessLabel: label(readiness),
         readinessBadge: readinessBadge(readiness),
-        providerLabel: isOpenCode ? 'OpenCode' : 'Manual / none',
+        providerLabel: isOpenCode ? 'OpenCode' : isClaude ? 'Claude (supported secondary)' : 'Manual / none',
         databaseLabel: plan === undefined ? 'pending' : plan.db.mode,
         databasePathLabel: compactPath(databasePath, 72),
         databaseSourceLabel: String(databaseSource),
-        scopeLabel: isOpenCode ? (opencode?.scope ?? selections?.scope ?? 'user') : 'Manual / none (OpenCode controls disabled)',
+        scopeLabel: isOpenCode ? (opencode?.scope ?? selections?.scope ?? 'user') : isClaude ? 'Project-local Claude config only; OpenCode controls disabled' : 'Manual / none (OpenCode controls disabled)',
         installModeLabel: isOpenCode
             ? opencode?.installsAgents === false
                 ? 'mcp-only'
                 : (selections?.installMode ?? 'mcp-plus-agents')
-            : 'Manual / none (no OpenCode install)',
-        targetPathLabel: isOpenCode && opencode?.targetPath !== undefined ? compactPath(opencode.targetPath, 72) : 'No provider config target; manual/no-provider-write mode',
-        opencodeActionLabel: isOpenCode ? opencodeActionLabel(opencode?.action) : 'No automatic provider write; use manual setup guidance.',
+            : isClaude
+                ? 'Claude guarded apply outside guided OpenCode install'
+                : 'Manual / none (no OpenCode install)',
+        targetPathLabel: isOpenCode && opencode?.targetPath !== undefined ? compactPath(opencode.targetPath, 72) : isClaude ? 'Claude targets: .mcp.json and .claude/agents/*.md via guarded apply' : 'No provider config target; manual/no-provider-write mode',
+        opencodeActionLabel: isOpenCode ? opencodeActionLabel(opencode?.action) : isClaude ? 'No guided setup write; use guarded Claude install with run preflight.' : 'No automatic provider write; use manual setup guidance.',
         memoryPathExplanation: memoryExplanation,
         providerInstallabilityLabel: isOpenCode
-            ? 'OpenCode is the only installable provider in this guided setup. Claude is deferred guidance only.'
-            : 'Manual / none is read-only guidance; no provider is installable from this selection. Claude is deferred guidance only.',
+            ? 'OpenCode is the default guided install provider. Claude is supported secondary via guarded mcp install claude --scope project --yes --run-id <id>.'
+            : 'Manual / none is read-only guidance. Claude remains supported secondary through explicit guarded apply outside this guided OpenCode flow.',
         agentReadinessLabel: agentReadiness.label,
         agentReadinessDetail: agentReadiness.detail,
         plannedActions: plan?.actions.map((action) => ({
@@ -75,8 +78,8 @@ export function setupTuiViewModelFromPlan(plan, status, state) {
             choice('database:custom', 'Custom database path', 'Deferred/read-only in the TUI unless already supplied by flags or environment.', selections?.databaseMode === 'custom' || (selections === undefined && plan?.db.mode === 'custom'), state?.focusedChoiceId, [badgeLabels.deferred, badgeLabels.readOnly]),
         ],
         providerChoices: [
-            choice('provider:opencode', 'OpenCode', 'Only installable provider in this guided setup; writes still require final confirmation.', (selections?.provider ?? plan?.provider ?? 'opencode') === 'opencode', state?.focusedChoiceId, [badgeLabels.recommended]),
-            choice('provider:claude-deferred', 'Claude (deferred)', 'Guidance only for now; not selectable and not installable in this setup flow.', false, state?.focusedChoiceId, [badgeLabels.deferred, badgeLabels.readOnly]),
+            choice('provider:opencode', 'OpenCode', 'Default guided install provider; writes still require final confirmation.', (selections?.provider ?? plan?.provider ?? 'opencode') === 'opencode', state?.focusedChoiceId, [badgeLabels.recommended]),
+            choice('provider:claude-supported-secondary', 'Claude (supported secondary)', 'Claude CLI MCP registration and project compatibility apply only via guarded mcp install claude --scope project --yes --run-id <id>; not default.', (selections?.provider ?? plan?.provider) === 'claude', state?.focusedChoiceId, ['[supported secondary]', badgeLabels.readOnly]),
             choice('provider:none', 'Manual / none', 'No automatic provider config write; follow manual setup guidance.', (selections?.provider ?? plan?.provider) === 'none', state?.focusedChoiceId, [badgeLabels.manual, badgeLabels.readOnly]),
         ],
         scopeChoices: isOpenCode
@@ -103,13 +106,13 @@ function previewDetailLines(input) {
     const opencode = plan?.opencode;
     const actions = plan?.actions.map((action) => `Planned action: ${action.description}${action.targetPath === undefined ? '' : ` Target: ${compactPath(action.targetPath, 72)}`}${action.backupRequired ? ' Backup required.' : ''}`) ?? ['Planned action: create read-only preview plan.'];
     return [
-        `Provider: ${input.provider === 'opencode' ? 'OpenCode [recommended]' : 'Manual / none [manual] [read-only]'}`,
+        `Provider: ${input.provider === 'opencode' ? 'OpenCode [recommended default]' : input.provider === 'claude' ? 'Claude [supported secondary] [guarded explicit apply]' : 'Manual / none [manual] [read-only]'}`,
         `Memory path: ${plan?.db.mode ?? 'pending'} at ${compactPath(input.databasePath, 72)} (source: ${String(input.databaseSource)})`,
         `Memory guidance: ${memoryPathExplanation(plan, input.databasePath, input.databaseSource)}`,
         `Scope: ${input.isOpenCode ? (opencode?.scope ?? 'user') : 'disabled for manual/none provider'}`,
         `Install mode: ${input.isOpenCode ? (opencode?.installsAgents === false ? 'mcp-only' : 'mcp-plus-agents') : 'disabled for manual/none provider'}`,
         `Reinstall VGXNESS entries: ${input.isOpenCode ? String(opencode?.overwriteVgxness ?? false) : 'disabled for manual/none provider'}`,
-        `Provider installability: ${input.isOpenCode ? 'OpenCode installable after final confirmation; Claude deferred/not installable.' : 'No provider installable; OpenCode controls disabled and Claude deferred.'}`,
+        `Provider installability: ${input.isOpenCode ? 'OpenCode installable after final confirmation; Claude supported secondary requires guarded mcp install claude --scope project --yes --run-id <id>.' : 'No guided provider install from this selection; Claude supported secondary uses guarded explicit apply.'}`,
         `Agent readiness: ${agentReadinessFromPlan(plan)}`,
         `Target config: ${input.isOpenCode && opencode?.targetPath !== undefined ? compactPath(opencode.targetPath, 72) : 'none; no provider config will be written'}`,
         `Safety: ${input.isOpenCode ? '[will write after confirm] only on final confirmation' : '[read-only] manual/no-provider-write mode'}`,
@@ -129,7 +132,7 @@ function helpLines(screen) {
         'Next/back: Tab continues; Shift+Tab goes back. Enter continues on review and confirms only on final confirmation.',
         'Cancel/close: q or Esc cancels setup; when help is open, ?/h toggles it closed.',
         reviewLine,
-        'Provider support: OpenCode is the only installable provider; Claude is [deferred] [read-only] guidance and Manual / none writes no provider config.',
+        'Provider support: OpenCode is the default guided install provider; Claude is supported secondary for guarded explicit apply via mcp install claude --scope project --yes --run-id <id>; Manual / none writes no provider config.',
         'Agent readiness: the preview checks vgxness-manager/SDD readiness guidance; preview screens never seed agents.',
         'No-write guarantee: no provider config is written before explicit final confirmation.',
     ];