vgxness 1.2.1 → 1.3.1

package/README.md

@@ -6,7 +6,7 @@ VGXNESS is an installable CLI and MCP control plane for guided AI-agent workflow
 
 This package is proprietary software. The npm package ships inspectable JavaScript (`dist/`) so Node can run it, but it is **not open-source licensed** and may not be redistributed unless you have written permission. See [LICENSE](./LICENSE).
 
-OpenCode is the primary supported provider. Other providers remain preview/manual only. The dashboard is read-only/copy-only; provider config writes require explicit CLI confirmation.
+OpenCode is the primary supported provider. Other providers remain preview/manual only. Provider config writes require explicit CLI confirmation.
 
 ## Requirements
 
@@ -123,8 +123,8 @@ bun run package:bun:evidence
 
 ```bash
 npm install -g vgxness
-vgx --help
 vgxness --help
+vgx --help # compatibility alias
 ```
 
 ## First setup with OpenCode
@@ -132,16 +132,16 @@ vgxness --help
 Run the guided setup wizard in a TTY:
 
 ```bash
-vgx init
+vgxness init
 ```
 
-In non-TTY shells, `vgx init` prints the same read-only setup plan instead of prompting. For a copyable happy path after installing the package globally:
+In non-TTY shells, `vgxness init` prints the same read-only setup plan instead of prompting. For a copyable happy path after installing the package globally:
 
 ```bash
-vgx setup plan
-vgx setup apply --yes
-vgx doctor
-vgx sdd next --project <project> --change <change>
+vgxness setup plan
+vgxness setup apply --yes
+vgxness doctor
+vgxness sdd next --project <project> --change <change>
 ```
 
 Stable defaults are: package `vgxness`, provider `opencode`, global user data DB, user/global OpenCode scope (`$HOME/.config/opencode/opencode.json`), and `mcp-plus-agents` mode. Use `--scope project` only when you intentionally want `<workspace>/.opencode/opencode.json`. The generated MCP command for the global DB default is:
@@ -153,28 +153,29 @@ vgxness mcp start
 Apply only after reviewing the plan:
 
 ```bash
-vgx setup apply --yes
+vgxness setup apply --yes
 ```
 
-`vgx setup plan` and `vgx setup status` are human-readable and read-only by default. `vgx doctor`, `vgx sdd status`, `vgx sdd next`, and `vgx sdd accept-artifact` are also human-readable by default. Pass `--json` when you need parseable automation output. `vgx setup apply --yes` is the explicit provider-config write path.
+`vgxness setup plan` and `vgxness setup status` are human-readable and read-only by default. `vgxness doctor`, `vgxness sdd status`, `vgxness sdd next`, and `vgxness sdd accept-artifact` are also human-readable by default. Pass `--json` when you need parseable automation output. `vgxness setup apply --yes` is the explicit provider-config write path.
 
 ## Safety model
 
 - Preview, status, and plan commands are read-only.
 - Provider config writes require explicit `--yes` confirmation.
-- The dashboard is read-only/copy-only; run copied commands outside the TUI when you choose to act.
+- Setup/status TUI surfaces are preview-oriented; run copied commands explicitly when you choose to act.
 - SDD artifacts are SQLite-backed through VGXNESS services. Do not create or write `openspec/`.
-- `vgx sdd accept-artifact` records explicit human-only acceptance; saving a draft never implies acceptance.
+- `vgxness sdd accept-artifact` records explicit human-only acceptance; saving a draft never implies acceptance.
 - OpenCode is the primary supported provider; other providers are preview/manual extension points.
 
-## Dashboard entrypoint
+## Main menu entrypoint
 
-Run `vgx` or `vgxness` with no arguments in an interactive terminal to open the operational dashboard. `vgx dashboard interactive` opens the same read-only/copy-only surface. In non-TTY shells, no-args prints static safe guidance and exits 0 without reading dashboard status or inferring project state.
+Run `vgxness` with no arguments in an interactive terminal to open the OpenTUI main menu. `vgx` remains a compatibility alias. In non-TTY shells, no-args prints static safe setup guidance and exits 0 without inferring project state.
 
-For scripts, use the read-only status renderer with an explicit project:
+For scripts, use explicit read-only commands with an explicit project:
 
 ```bash
-vgx dashboard status --project <name>
+vgxness setup status --project <name>
+vgxness sdd status --project <name> --change <change>
 ```
 
 For project-local or custom databases, use `--db project-local` or `--db custom --db-path <path>` with setup commands. Existing low-level commands remain available:
@@ -187,7 +188,7 @@ vgxness mcp install opencode --yes
 ## Verify
 
 ```bash
-vgx doctor
+vgxness doctor
 vgxness mcp doctor opencode
 vgxness setup status
 ```
@@ -199,10 +200,10 @@ Restart OpenCode after applying config and verify that the `vgxness` MCP server
 OpenCode applies create a backup before merging existing config. Restore one with:
 
 ```bash
-vgx setup rollback --backup <path>
+vgxness setup rollback --backup <path>
 ```
 
-Rollback validates the backup, creates a pre-rollback backup of the current target when present, restores the selected backup byte-for-byte, and keeps the original backup if anything fails. Rerun `vgx doctor` after rollback.
+Rollback validates the backup, creates a pre-rollback backup of the current target when present, restores the selected backup byte-for-byte, and keeps the original backup if anything fails. Rerun `vgxness doctor` after rollback.
 
 Common issues:
 

package/dist/cli/cli-help.js

@@ -91,14 +91,11 @@ Areas:
   subagents list --parent-agent-id <id>
   subagents get --id <id> | --project <name> --name <name> [--scope project|personal]
 
-  dashboard status --project <name> [--change <id>] [--run-id <id>] [--limit <n>]
-  dashboard interactive [--project <name>] [--change <id>] [--limit <n>]
-  No args in an interactive TTY opens the same operational dashboard as dashboard interactive.
-  No args without a TTY prints static safe guidance and exits 0 without reading dashboard status or opening project state.
-  Dashboard menu: Installation, Status, Agents, Skills, Memory, SDD, Runs, Approvals, Permissions, Settings. Menu: ↑/↓ or j/k, Enter, 1-9/0. Section: b/Esc/Backspace back, r, ?, q.
-  Dashboardinteractive may launch without --project; Installation remains available and project-scoped checks are deferred while project screens render project-required recovery states.
+  No args in an interactive TTY opens the OpenTUI main menu.
+  No args without a TTY prints static safe setup guidance and exits 0 without opening project state.
+  Setup TUI may launch without --project; Installation remains available and project-scoped checks are deferred while project screens render project-required recovery states.
   Provider setup support: OpenCode supported primary; Claude preview-only; Antigravity placeholder; Custom/future extension point.
-  Dashboard status is scriptable/read-only and requires --project. Provider config writes/install/apply are external-only, require explicit confirmation outside the dashboard, and are not run by dashboard flows.
+  Provider config writes/install/apply are external-only and require explicit confirmation.
 
   sdd status --project <name> --change <id> [--json]
   sdd next --project <name> --change <id> [--json]

package/dist/cli/commands/index.js

@@ -1,5 +1,5 @@
 export { runAgentCommand, runSkillCommand, runSubagentCommand } from './agent-skill-dispatcher.js';
-export { runCodeCliCommand, runDashboardCommand, runDashboardInteractiveCommand, runDefaultInteractiveEntrypoint } from './dashboard-dispatcher.js';
+export { runCodeCliCommand, runDefaultInteractiveEntrypoint } from './interactive-entrypoint-dispatcher.js';
 export { runDoctorAliasCommand, runMcpDoctorCommand, runMcpDoctorOpenCodeCommand, runMcpInstallCommand, runMcpSetupCommand } from './mcp-dispatcher.js';
 export { runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runSddCommand } from './memory-sdd-dispatcher.js';
 export { runApprovalsCommand, runPermissionsCommand, runRunsCommand } from './run-permission-dispatcher.js';

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

@@ -0,0 +1,150 @@
+import { runCodeCommand } from '../../code/cli/code-command.js';
+import { InMemoryRunGateway } from '../../code/runtime/gateways.js';
+import { MemoryServiceCodeGateway } from '../../code/runtime/memory-service-gateway.js';
+import { RunsCodeRunGateway } from '../../code/runtime/runs-code-run-gateway.js';
+import { SddWorkflowGateway } from '../../code/runtime/sdd-workflow-gateway.js';
+import { MemoryService } from '../../memory/memory-service.js';
+import { RunService } from '../../runs/run-service.js';
+import { SddWorkflowService } from '../../sdd/sdd-workflow-service.js';
+import { codeApprovalPolicyFlag, codeMemoryPolicyFlag, codeTranscriptModeFlag, codeVerificationModeFlag, databasePathFor, optionalNumberFlag, optionalStringFlag, } from '../cli-flags.js';
+import { okText, usageFailure, validationFailure } from '../cli-help.js';
+import { openCliDatabase, resultFailure } from '../cli-helpers.js';
+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.',
+        'Next: rerun `vgxness` in an interactive terminal, run `vgxness init --plan`, or run `vgxness setup plan` for read-only installation guidance.',
+    ].join('\n') + '\n');
+}
+function guidanceForMainMenuResult(result) {
+    if (result.type === 'show-doctor-guidance')
+        return ['Doctor / recovery guidance:', '- Read-only status: `vgxness setup status`', '- Provider doctor: `vgxness mcp doctor opencode`', '- No provider config was written.'].join('\n') + '\n';
+    if (result.type === 'show-sdd-guidance')
+        return ['SDD / workflow guidance:', '- Use VGXNESS MCP tools from OpenCode for normal SDD progression.', '- Manual status: `vgxness sdd status --project <name> --change <change>`', '- No provider config was written.'].join('\n') + '\n';
+    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 undefined;
+}
+async function renderDefaultMainMenu(environment, onResult) {
+    const { renderOpenTuiMainMenu } = await import('../tui/opentui/main-menu/renderer.js');
+    await renderOpenTuiMainMenu({
+        stdin: environment.stdin,
+        stdout: environment.stdout,
+        onResult,
+    });
+}
+export async function runDefaultInteractiveEntrypointWithMainMenu(environment, input = {}) {
+    if (!canRunInteractiveTui(environment.stdin, environment.stdout))
+        return okText(defaultNoTtyGuidance());
+    let selected;
+    await (input.renderMainMenu ?? ((onResult) => renderDefaultMainMenu(environment, onResult)))((result) => {
+        selected = result;
+    });
+    const result = selected ?? { type: 'exit' };
+    if (result.type === 'open-setup')
+        return (input.setupTui ?? runSetupTuiCommand)(environment);
+    return okText(guidanceForMainMenuResult(result) ?? 'No provider config was written.\n');
+}
+function codeApprovalChannelFlag(flags) {
+    const value = optionalStringFlag(flags, 'approval-channel');
+    if (value === undefined)
+        return { ok: true, value: undefined };
+    return value === 'stdio' ? { ok: true, value } : validationFailure('--approval-channel must be stdio');
+}
+export async function runDefaultInteractiveEntrypoint(environment) {
+    return runDefaultInteractiveEntrypointWithMainMenu(environment);
+}
+export async function runCodeCliCommand(parsed, environment) {
+    const [, command] = parsed.positionals;
+    if (command !== 'inspect' && command !== 'plan' && command !== 'craft' && command !== 'craft-preview' && command !== 'sdd')
+        return usageFailure(`Unknown code command: ${command ?? ''}`.trim());
+    const eventsJsonl = parsed.flags['events-jsonl'] === true;
+    const approvalChannel = codeApprovalChannelFlag(parsed.flags);
+    if (!approvalChannel.ok)
+        return resultFailure(approvalChannel);
+    if (approvalChannel.value === 'stdio' && (command !== 'craft' || !eventsJsonl))
+        return usageFailure('--approval-channel stdio is supported only for code craft --events-jsonl');
+    if (eventsJsonl && command !== 'inspect' && command !== 'plan' && command !== 'craft-preview' && approvalChannel.value !== 'stdio')
+        return usageFailure('code craft --events-jsonl requires --approval-channel stdio; JSONL without approvals is currently supported only for read-only inspect, plan, and craft-preview');
+    const maxSourceBytes = optionalNumberFlag(parsed.flags, 'max-source-bytes');
+    if (!maxSourceBytes.ok)
+        return resultFailure(maxSourceBytes);
+    const output = parsed.flags.json === true || optionalStringFlag(parsed.flags, 'output') === 'json' ? 'json' : 'human';
+    const approvalPolicy = codeApprovalPolicyFlag(parsed.flags);
+    if (!approvalPolicy.ok)
+        return resultFailure(approvalPolicy);
+    const verificationMode = codeVerificationModeFlag(parsed.flags);
+    if (!verificationMode.ok)
+        return resultFailure(verificationMode);
+    const transcriptMode = codeTranscriptModeFlag(parsed.flags);
+    if (!transcriptMode.ok)
+        return resultFailure(transcriptMode);
+    const memoryPolicy = codeMemoryPolicyFlag(parsed.flags);
+    if (!memoryPolicy.ok)
+        return resultFailure(memoryPolicy);
+    const provider = optionalStringFlag(parsed.flags, 'provider');
+    const model = optionalStringFlag(parsed.flags, 'model');
+    if (eventsJsonl) {
+        if (approvalChannel.value === 'stdio' && (environment.stdin === undefined || environment.stdout === undefined))
+            return resultFailure(validationFailure('--approval-channel stdio requires CLI stdin and stdout streams'));
+        return await runCodeCommand({
+            command,
+            args: parsed.positionals.slice(2),
+            cwd: environment.cwd,
+            output,
+            runGateway: new InMemoryRunGateway(),
+            project: optionalStringFlag(parsed.flags, 'project') ?? 'vgxness',
+            ...(provider === undefined ? {} : { provider }),
+            ...(model === undefined ? {} : { model }),
+            stream: parsed.flags.stream === true,
+            env: environment.env,
+            eventsJsonl,
+            memoryPolicy: 'off',
+            ...(approvalChannel.value === undefined ? {} : { approvalChannel: approvalChannel.value }),
+            ...(approvalChannel.value === 'stdio' ? { approvalDecisionInput: environment.stdin, eventOutput: environment.stdout } : {}),
+            ...(maxSourceBytes.value !== undefined ? { maxSourceBytes: maxSourceBytes.value } : {}),
+            ...(approvalPolicy.value === undefined ? {} : { approvalPolicy: approvalPolicy.value }),
+            ...(verificationMode.value === undefined ? {} : { verificationMode: verificationMode.value }),
+            ...(transcriptMode.value === undefined ? {} : { transcriptMode: transcriptMode.value }),
+        });
+    }
+    const selectedDatabasePath = databasePathFor(parsed.flags, environment);
+    if (!selectedDatabasePath.ok)
+        return resultFailure(selectedDatabasePath);
+    const opened = openCliDatabase(selectedDatabasePath.value);
+    if (!opened.ok)
+        return resultFailure(opened);
+    try {
+        const runs = new RunService(opened.value);
+        const memory = new MemoryService(opened.value);
+        return await runCodeCommand({
+            command,
+            args: parsed.positionals.slice(2),
+            cwd: environment.cwd,
+            output,
+            runGateway: new RunsCodeRunGateway(runs),
+            sddGateway: new SddWorkflowGateway(new SddWorkflowService(memory)),
+            memoryGateway: new MemoryServiceCodeGateway(memory),
+            project: optionalStringFlag(parsed.flags, 'project') ?? 'vgxness',
+            ...(provider === undefined ? {} : { provider }),
+            ...(model === undefined ? {} : { model }),
+            stream: parsed.flags.stream === true,
+            env: environment.env,
+            eventsJsonl,
+            persistArtifact: parsed.flags['save-artifact'] === true || parsed.flags.persist === true,
+            ...(maxSourceBytes.value !== undefined ? { maxSourceBytes: maxSourceBytes.value } : {}),
+            ...(approvalPolicy.value === undefined ? {} : { approvalPolicy: approvalPolicy.value }),
+            ...(verificationMode.value === undefined ? {} : { verificationMode: verificationMode.value }),
+            ...(transcriptMode.value === undefined ? {} : { transcriptMode: transcriptMode.value }),
+            ...(memoryPolicy.value === undefined ? {} : { memoryPolicy: memoryPolicy.value }),
+        });
+    }
+    finally {
+        opened.value.close();
+    }
+}
+// Re-export helpers
+export { defaultNoTtyGuidance, };

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

@@ -1,5 +1,4 @@
 import { resolve } from 'node:path';
-import React from 'react';
 import { AgentRegistryService } from '../../agents/agent-registry-service.js';
 import { resolveAgentProfileModel } from '../../agents/profile-model-routing.js';
 import { installOpenCodeMcpClient } from '../../mcp/client-install-opencode.js';
@@ -14,8 +13,6 @@ import { okText, usageFailure, validationFailure } from '../cli-help.js';
 import { jsonResult, openCliDatabase, resultFailure } from '../cli-helpers.js';
 import { renderSetupPlan } from '../setup-plan-renderer.js';
 import { renderSetupStatus } from '../setup-status-renderer.js';
-import { renderInkApp } from '../tui/render-ink-app.js';
-import { SetupTuiApp } from '../tui/setup/setup-tui-app.js';
 import { createDefaultSetupTuiServices } from '../tui/setup/setup-tui-services.js';
 import { canRunInteractiveTui } from '../tui/terminal-capabilities.js';
 function renderSetupRollbackApply(result, parsed) {
@@ -28,7 +25,7 @@ function renderSetupRollbackApply(result, parsed) {
         `Target: ${result.value.targetPath}`,
         `Restored from: ${result.value.backupPath}`,
         ...(result.value.preRollbackBackupPath === undefined ? [] : [`Pre-rollback backup: ${result.value.preRollbackBackupPath}`]),
-        'Next: vgx doctor; restart OpenCode and verify the vgxness MCP server is visible.',
+        'Next: vgxness doctor; restart OpenCode and verify the vgxness MCP server is visible.',
     ];
     return okText(`${lines.join('\n')}\n`);
 }
@@ -92,7 +89,7 @@ export function runSetupRollbackCommand(parsed, environment) {
         `Backup: ${result.value.backupPath}`,
         ...result.value.blockers.map((blocker) => `Blocker: ${blocker}`),
         ...result.value.warnings.map((warning) => `Warning: ${warning}`),
-        ...(result.value.restorable ? [`Apply with: vgx setup rollback --backup ${result.value.backupPath} --yes`] : []),
+        ...(result.value.restorable ? [`Apply with: vgxness setup rollback --backup ${result.value.backupPath} --yes`] : []),
     ];
     return okText(`${lines.join('\n')}\n`);
 }
@@ -156,7 +153,7 @@ export async function applySetupPlanInput(input, environment) {
                 status: 'installed',
                 plan: plan.value,
                 opencode: result,
-                nextCommands: ['vgx doctor', 'Restart OpenCode and verify the vgxness MCP server is visible.'],
+                nextCommands: ['vgxness doctor', 'Restart OpenCode and verify the vgxness MCP server is visible.'],
             },
         }
         : validationFailure(`${result.reason}: ${result.message}`);
@@ -339,7 +336,7 @@ export async function runInitCommandWithSetupTui(parsed, environment, setupTui)
 }
 export async function runSetupTuiCommand(environment, input) {
     if (!canRunInteractiveTui(environment.stdin, environment.stdout))
-        return okText('Setup TUI requires an interactive TTY; no provider config was written. Run `vgx init --plan` or `vgx setup plan` for read-only output.\n');
+        return okText('Setup TUI requires an interactive TTY; no provider config was written. Run `vgxness init --plan` or `vgxness setup plan` for read-only output.\n');
     const selectedDatabasePath = databasePathSelectionFor({}, environment);
     if (!selectedDatabasePath.ok)
         return resultFailure(selectedDatabasePath);
@@ -361,7 +358,13 @@ export async function runSetupTuiCommand(environment, input) {
         },
     };
     try {
-        await renderInkApp(React.createElement(SetupTuiApp, { services: createDefaultSetupTuiServices({ lifecycle, cwd: environment.cwd, env: environment.env }), runtime }), { stdin: environment.stdin, stdout: environment.stdout });
+        const { renderOpenTuiSetup } = await import('../tui/opentui/setup/index.js');
+        await renderOpenTuiSetup({
+            services: createDefaultSetupTuiServices({ lifecycle, cwd: environment.cwd, env: environment.env }),
+            runtime,
+            stdin: environment.stdin,
+            stdout: environment.stdout,
+        });
         return { exitCode: 0, stdout: '', stderr: '' };
     }
     finally {

package/dist/cli/dispatcher.js

@@ -4,7 +4,7 @@ import { isWorkflowId } from '../workflows/schema.js';
 import { databasePathFor, parseArgs, requiredFlag } from './cli-flags.js';
 import { okText, usageFailure, visibleHelpText } from './cli-help.js';
 import { openCliDatabase, resultFailure } from './cli-helpers.js';
-import { runAgentCommand, runApprovalsCommand, runCodeCliCommand, runDashboardCommand, runDashboardInteractiveCommand, runDefaultInteractiveEntrypoint, runDoctorAliasCommand, runInitCommand, runMcpDoctorCommand, runMcpInstallCommand, runMcpSetupCommand, runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runPermissionsCommand, runRunsCommand, runSddCommand, runSetupApplyCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, runSkillCommand, runSubagentCommand, runVerificationPlanCommand, runVerificationReportCommand, runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand, } from './commands/index.js';
+import { runAgentCommand, runApprovalsCommand, runCodeCliCommand, runDefaultInteractiveEntrypoint, runDoctorAliasCommand, runInitCommand, runMcpDoctorCommand, runMcpInstallCommand, runMcpSetupCommand, runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runPermissionsCommand, runRunsCommand, runSddCommand, runSetupApplyCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, runSkillCommand, runSubagentCommand, runVerificationPlanCommand, runVerificationReportCommand, runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand, } from './commands/index.js';
 const _promptBuffers = new WeakMap();
 const require = createRequire(import.meta.url);
 const packageJson = require('../../package.json');
@@ -75,8 +75,6 @@ export function dispatchCli(argv, environment) {
             return runOrchestratorCommand(command, parsed, opened.value);
         if (area === 'opencode')
             return runOpenCodeCommand(command, parsed, opened.value, environment);
-        if (area === 'dashboard')
-            return runDashboardCommand(command, parsed, opened.value, environment, databasePath);
         return usageFailure(`Unknown command area: ${area}`);
     }
     finally {
@@ -91,8 +89,6 @@ export async function dispatchCliAsync(argv, environment) {
     const [area, command] = parsed.positionals;
     if (argv.length === 0)
         return runDefaultInteractiveEntrypoint(environment);
-    if (area === 'dashboard' && command === 'interactive')
-        return runDashboardInteractiveCommand(parsed, environment);
     if (area === 'mcp') {
         if (!command)
             return usageFailure('Missing command for mcp');
@@ -222,9 +218,6 @@ function validateCommand(area, command) {
     if (area === 'verification') {
         return command === 'plan' || command === 'report' ? { ok: true } : { ok: false, message: `Unknown verification command: ${command}` };
     }
-    if (area === 'dashboard') {
-        return command === 'status' ? { ok: true } : { ok: false, message: `Unknown dashboard command: ${command}` };
-    }
     if (area === 'code') {
         return command === 'inspect' || command === 'plan' || command === 'craft' || command === 'sdd'
             ? { ok: true }

package/dist/cli/doctor-renderer.js

@@ -7,7 +7,7 @@ export function renderDoctorReport(input) {
     const failedCheckRemediation = input.report.checks.find((check) => check.status === 'fail' && check.remediation !== undefined)?.remediation;
     const next = input.report.ready
         ? 'VGXNESS doctor checks are ready; continue with your SDD workflow.'
-        : (failedCheckRemediation ?? 'Resolve failed or skipped checks, then rerun `vgx doctor --json` or `vgx doctor`.');
+        : (failedCheckRemediation ?? 'Resolve failed or skipped checks, then rerun `vgxness doctor --json` or `vgxness doctor`.');
     const lines = [
         'VGXNESS Doctor',
         `Project: ${input.project}`,

package/dist/cli/sdd-renderer.js

@@ -4,7 +4,7 @@ export function renderSddStatus(input) {
     const blockers = input.status.phases.filter((phase) => phase.present && phase.accepted !== true);
     const complete = input.status.phases.length > 0 && input.status.phases.every((phase) => phase.present && phase.accepted === true);
     const statusLabel = complete ? 'complete' : input.status.nextReadyPhase === undefined ? 'blocked' : 'ready';
-    const directPhaseCommand = input.status.nextReadyPhase === undefined ? undefined : `vgx code sdd ${input.status.change} ${input.status.nextReadyPhase} --save-artifact`;
+    const directPhaseCommand = input.status.nextReadyPhase === undefined ? undefined : `vgxness code sdd ${input.status.change} ${input.status.nextReadyPhase} --save-artifact`;
     const recommendedAction = complete
         ? 'No next SDD phase remains for this change.'
         : input.status.nextReadyPhase === undefined
@@ -27,8 +27,8 @@ export function renderSddStatus(input) {
         ...(missing.length === 0 ? ['- none'] : missing.map((topicKey) => `- ${topicKey}`)),
         '',
         `Recommended action: ${recommendedAction}`,
-        `Command: ${directPhaseCommand ?? `vgx sdd next --project ${input.project} --change ${input.status.change}`}`,
-        `JSON: vgx sdd status --project ${input.project} --change ${input.status.change} --json`,
+        `Command: ${directPhaseCommand ?? `vgxness sdd next --project ${input.project} --change ${input.status.change}`}`,
+        `JSON: vgxness sdd status --project ${input.project} --change ${input.status.change} --json`,
     ];
     return `${lines.join('\n')}\n`;
 }
@@ -36,8 +36,8 @@ export function renderSddNext(input) {
     const blockers = input.decision.blockedPrerequisites ?? [];
     const phase = input.decision.nextPhase ?? 'none';
     const commandGuidance = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined
-        ? `vgx code sdd ${input.decision.change} ${input.decision.nextPhase} --save-artifact`
-        : `vgx sdd status --project ${input.project} --change ${input.decision.change}`;
+        ? `vgxness code sdd ${input.decision.change} ${input.decision.nextPhase} --save-artifact`
+        : `vgxness sdd status --project ${input.project} --change ${input.decision.change}`;
     const lines = [
         'SDD Next',
         `Project: ${input.project}`,
@@ -54,7 +54,7 @@ export function renderSddNext(input) {
         '',
         `Recommended action: ${input.decision.recommendedAction}`,
         `Command: ${commandGuidance}`,
-        `JSON: vgx sdd next --project ${input.project} --change ${input.decision.change} --json`,
+        `JSON: vgxness sdd next --project ${input.project} --change ${input.decision.change} --json`,
     ];
     return `${lines.join('\n')}\n`;
 }
@@ -89,7 +89,7 @@ export function renderSddArtifactAccepted(input) {
         `- Accepted by: ${input.acceptedBy.displayName} (${input.acceptedBy.id})`,
         `- Accepted at: ${input.acceptedAt}`,
         ...(input.note === undefined ? [] : [`- Note: ${input.note}`]),
-        `JSON: vgx sdd accept-artifact --project ${input.project} --change ${input.change} --phase ${input.phase} --actor ${input.acceptedBy.id} --json`,
+        `JSON: vgxness sdd accept-artifact --project ${input.project} --change ${input.change} --phase ${input.phase} --actor ${input.acceptedBy.id} --json`,
     ];
     return `${lines.join('\n')}\n`;
 }

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

@@ -29,6 +29,7 @@ function renderProviderPreview(provider) {
         ...(preview.backupRequired === undefined ? [] : [`    Backup required: ${String(preview.backupRequired)}`]),
         ...(preview.confirmationRequired === undefined ? [] : [`    Confirmation required: ${String(preview.confirmationRequired)}`]),
         ...(preview.risks.length === 0 ? [] : [`    Risks: ${preview.risks.join(' ')}`]),
+        ...(preview.warnings.length === 0 ? [] : [`    Warnings: ${preview.warnings.join(' ')}`]),
     ];
 }
 function renderDefaults(status) {

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

@@ -1,5 +1,4 @@
 export * from './main-menu-actions.js';
-export * from './main-menu-app.js';
 export * from './main-menu-controller.js';
 export * from './main-menu-read-model.js';
 export * from './main-menu-render-shape.js';

package/dist/cli/tui/main-menu/main-menu-controller.js

@@ -1,8 +1,6 @@
 export function resultForMainMenuOption(optionId) {
     if (optionId === 'setup')
         return { type: 'open-setup' };
-    if (optionId === 'dashboard')
-        return { type: 'open-dashboard' };
     if (optionId === 'doctor')
         return { type: 'show-doctor-guidance' };
     if (optionId === 'sdd')

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

@@ -1,5 +1,12 @@
-import { formatTuiFooter, tuiBadges } from '../visual/index.js';
+import { tuiBadges } from '../visual/badges.js';
+import { formatTuiFooter } from '../visual/footer.js';
 import { mainMenuOptionIds } from './main-menu-state.js';
+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.',
+];
 const optionCopy = {
     setup: {
         label: 'Installation',
@@ -12,13 +19,6 @@ const optionCopy = {
             'Provider writes require final confirmation; OpenCode is the only automatic provider with explicit consent.',
         ],
     },
-    dashboard: {
-        label: 'Dashboard',
-        description: 'Inspect project health, runs, approvals, SDD, agents, and skills.',
-        badges: [tuiBadges.readOnly],
-        detailTitle: 'Interactive dashboard',
-        detailLines: ['Opens the existing read-only dashboard.', 'Dashboard navigation does not apply provider config or write OpenCode setup.'],
-    },
     doctor: {
         label: 'Doctor / recovery',
         description: 'See health-check and recovery commands.',
@@ -63,8 +63,10 @@ export function buildMainMenuViewModel(state) {
         contextLines: ['Choose where to go next. Installation is first; the menu itself is read-only and does not write provider config.'],
         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.',
         ],

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

@@ -1,4 +1,4 @@
-import { choiceLine } from '../visual/index.js';
+import { formatBadges, tuiBadges } from '../visual/badges.js';
 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 } };
@@ -11,6 +11,8 @@ export function renderMainMenuShape(input) {
         ...vm.options.map(choiceLine),
         `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.lines,
         'Safety',
         ...vm.safetyLines,
         ...vm.helpLines.map((line) => `Help: ${line}`),
@@ -21,9 +23,24 @@ export function renderMainMenuShape(input) {
 function clampLine(line, width) {
     if (line.length <= width)
         return line;
-    const protectedPhrases = ['final confirmation', 'read-only', 'Requires confirmation', 'explicit consent', 'No provider writes', 'quit without writes'];
+    const protectedPhrases = [
+        'final confirmation',
+        'read-only',
+        'Requires confirmation',
+        'explicit consent',
+        'No provider writes',
+        'quit without writes',
+        'vgxness setup status',
+        'vgxness mcp doctor opencode',
+        'no SQLite',
+        'provider config writes',
+    ];
     const phrase = protectedPhrases.find((candidate) => line.includes(candidate));
     if (phrase !== undefined)
         return `${line.slice(0, Math.max(0, width - phrase.length - 5)).trim()} ... ${phrase}`.trim();
     return `${line.slice(0, Math.max(0, width - 1)).trim()}…`;
 }
+function choiceLine(choice) {
+    const badges = formatBadges([...(choice.focused === true ? [tuiBadges.focused] : []), ...choice.badges]);
+    return `${choice.focused === true ? '›' : ' '} ${choice.label}${badges.length === 0 ? '' : ` ${badges}`} — ${choice.description}`;
+}

package/dist/cli/tui/main-menu/main-menu-state.js

@@ -1,5 +1,5 @@
 import { createTuiViewport } from '../visual/viewport.js';
-export const mainMenuOptionIds = ['setup', 'dashboard', 'doctor', 'sdd', 'advanced-cli', 'exit'];
+export const mainMenuOptionIds = ['setup', 'doctor', 'sdd', 'advanced-cli', 'exit'];
 export function createMainMenuState(input = {}) {
     return {
         focusedOptionId: input.focusedOptionId ?? 'setup',