vgxness 1.3.0 → 1.3.1

package/README.md

@@ -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,10 +153,10 @@ 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
 
@@ -164,18 +164,18 @@ vgx setup apply --yes
 - Provider config writes require explicit `--yes` confirmation.
 - 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.
 
 ## Main menu entrypoint
 
-Run `vgx` or `vgxness` with no arguments in an interactive terminal to open the OpenTUI main menu. In non-TTY shells, no-args prints static safe setup guidance and exits 0 without 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 explicit read-only commands with an explicit project:
 
 ```bash
-vgx setup status --project <name>
-vgx sdd status --project <name> --change <change>
+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:
@@ -188,7 +188,7 @@ vgxness mcp install opencode --yes
 ## Verify
 
 ```bash
-vgx doctor
+vgxness doctor
 vgxness mcp doctor opencode
 vgxness setup status
 ```
@@ -200,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/commands/interactive-entrypoint-dispatcher.js

@@ -14,16 +14,16 @@ import { runSetupTuiCommand } from './setup-dispatcher.js';
 function defaultNoTtyGuidance() {
     return ([
         'VGXNESS main menu requires a TTY; no provider config was written.',
-        'Next: rerun `vgx` in an interactive terminal, run `vgx init --plan`, or run `vgx setup plan` for read-only installation guidance.',
+        '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: `vgx setup status`', '- Provider doctor: `vgx mcp doctor opencode`', '- No provider config was written.'].join('\n') + '\n';
+        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: `vgx sdd status --project <name> --change <change>`', '- No provider config was written.'].join('\n') + '\n';
+        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: `vgx init --plan` or `vgx setup plan`', '- Setup status: `vgx setup status --project <name>`', '- SDD status: `vgx sdd status --project <name> --change <change>`', '- No provider config was written.'].join('\n') + '\n';
+        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;

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

@@ -25,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`);
 }
@@ -89,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`);
 }
@@ -153,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}`);
@@ -336,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);

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/main-menu-read-model.js

@@ -1,6 +1,12 @@
 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',
@@ -57,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

@@ -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,7 +23,18 @@ 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();

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

@@ -92,7 +92,7 @@ async function runReadOnlyBridge(state, render) {
     const prompt = submission.prompt;
     if (prompt === '') {
         state.status = 'error';
-        state.errors = ['Enter a prompt before running inspect, plan, or craft-preview. Prefix with /plan, /inspect, or /craft-preview; press Tab to switch inspect/plan.'];
+        state.errors = ['Enter a prompt before running inspect, plan, craft-preview, or craft. Prefix with /inspect, /plan, /craft-preview, or /craft; press Tab to switch inspect/plan.'];
         render();
         return;
     }
@@ -107,7 +107,7 @@ async function runReadOnlyBridge(state, render) {
     render();
     const root = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../..');
     const approvalCapableCraft = state.mode === 'craft';
-    const child = spawn('npm', commandArgsForMode(state.mode, prompt), {
+    const child = spawn('bun', commandArgsForMode(state.mode, prompt), {
         cwd: root,
         stdio: approvalCapableCraft ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
         env: process.env,
@@ -173,13 +173,13 @@ async function runReadOnlyBridge(state, render) {
         if (code !== 0 && !(state.mode === 'craft-preview' && code === 3)) {
             const detail = stderr.trim() === '' ? `signal ${signal ?? 'none'}` : stderr.trim();
             state.status = 'error';
-            state.errors.push(`Root CLI ${state.mode} failed (exit ${code ?? 'signal'}): ${detail}`);
+            state.errors.push(`Root Bun CLI ${state.mode} failed (exit ${code ?? 'signal'}): ${detail}`);
         }
         render();
     });
 }
 function commandArgsForMode(mode, prompt) {
-    const args = ['run', '--silent', 'cli', '--', 'code', mode, prompt, '--events-jsonl'];
+    const args = ['run', '--silent', 'cli:bun', '--', 'code', mode, prompt, '--events-jsonl'];
     if (mode === 'craft')
         args.push('--approval-channel', 'stdio');
     return args;

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

@@ -19,6 +19,12 @@ export function createOpenTuiMainMenuScreen(state) {
         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,

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

@@ -101,7 +101,7 @@ function setupScreenContent(state, vm, width) {
         case 'result':
             return { leftTitle: ' Result ', left: ['Setup finished.', ...vm.nextCommands.map((command) => `Next: ${command}`)], rightTitle: ' Summary ', right: previewLines(vm), safety, help, footer };
         case 'error-recovery':
-            return { leftTitle: ' Recovery ', left: ['! Setup hit an error.', 'No unconfirmed provider config write was performed.', 'Inspect `vgx setup plan`, resolve blockers, then retry.'], rightTitle: ' Context ', right: previewLines(vm), safety, help, footer };
+            return { leftTitle: ' Recovery ', left: ['! Setup hit an error.', 'No unconfirmed provider config write was performed.', 'Inspect `vgxness setup plan`, resolve blockers, then retry.'], rightTitle: ' Context ', right: previewLines(vm), safety, help, footer };
         case 'cancelled':
             return { leftTitle: ' Cancelled ', left: ['Setup was cancelled.', 'No provider config was written.', 'No agent seeding was performed.'], rightTitle: ' Context ', right: previewLines(vm), safety, help, footer };
     }

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

@@ -26,7 +26,7 @@ try {
             conflicts: [],
             backupsPlanned: [{ targetPath: '/tmp/.config/opencode/opencode.json', reason: 'Existing OpenCode config would be backed up before merge.' }],
             safety: { mutating: false, writesProviderConfig: false, requiresConfirmationForApply: true },
-            nextCommands: ['vgx setup apply --yes', 'vgx doctor'],
+            nextCommands: ['vgxness setup apply --yes', 'vgxness doctor'],
         },
     }), 120));
     await setup.renderOnce();

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

@@ -57,7 +57,7 @@ export function setupTuiViewModelFromPlan(plan, status, state) {
         warnings,
         blockers,
         backupLabel: backups.length === 0 ? 'Backup: none planned' : `Backup planned: ${backups.join('; ')}`,
-        nextCommands: plan?.nextCommands ?? ['vgx setup plan'],
+        nextCommands: plan?.nextCommands ?? ['vgxness setup plan'],
         canAutoApply: plan?.provider === 'opencode' && plan.status === 'ready' && state?.selections.provider !== 'none' && plan.opencode !== undefined,
         safetyWarning: 'Final confirmation is required before any provider config write. OpenCode config may be modified and backed up.',
         frameLabel: 'VGXNESS Setup Assistant workspace',
@@ -108,7 +108,7 @@ function previewDetailLines(input) {
         ...actions,
         input.backups.length === 0 ? 'Backups: none planned' : `Backups: ${input.backups.join('; ')}`,
         ...(input.warnings.length === 0 ? ['Warnings: none'] : input.warnings.map((warning) => `Warning: ${warning}`)),
-        ...(input.blockers.length === 0 ? ['Blockers: none'] : input.blockers.map((blocker) => `Blocker: ${blocker}`)),
+        ...(input.blockers.length === 0 ? ['Blockers: none'] : input.blockers.map((blocker) => `Blocked because: ${blocker}`)),
     ];
 }
 function helpLines(screen) {
@@ -145,7 +145,7 @@ function agentReadinessLabels(plan, status) {
     if (status?.agents.status === 'blocked')
         return {
             label: 'Agents need attention',
-            detail: `${status.agents.blocker ?? 'Required agents are not ready.'} Next: ${status.agents.nextAction ?? 'vgx agents seed --scope project'}`,
+            detail: `${status.agents.blocker ?? 'Required agents are not ready.'} Next: ${status.agents.nextAction ?? 'vgxness agents seed --scope project'}`,
         };
     return { label: 'Agent readiness preview', detail: `Required agents: ${names.join(', ')}. Preview/status screens do not seed agents.` };
 }

package/dist/cli/tui/setup/setup-tui-render-shape.js

@@ -59,11 +59,10 @@ function screenLines(input, width) {
                 'Read-only plan review',
                 'Plan summary ' + badgeLabels.readOnly,
                 ...planLines(vm, width),
-                `Doctor next step: ${doctorCommand(vm)}`,
-                'Restart next step: Restart OpenCode after confirmed setup so it reloads MCP configuration.',
+                ...nextCommandLines(vm),
                 'Review only: this screen does not write provider config.',
-                vm.canAutoApply ? 'Press Enter to continue to final confirmation.' : 'Manual setup required; no automatic apply is available.',
-            ], width, [setupFooterHints.finalConfirmation, setupFooterHints.back, setupFooterHints.cancel]);
+                vm.canAutoApply ? 'Press Enter to continue to final confirmation.' : 'Press Enter to show manual next steps; no automatic apply is available.',
+            ], width, vm.canAutoApply ? [setupFooterHints.finalConfirmation, setupFooterHints.back, setupFooterHints.cancel] : [setupFooterHints.continue, setupFooterHints.back, setupFooterHints.cancel]);
         case 'final-confirmation':
             return workspaceLines(vm, [
                 'Final confirmation',
@@ -84,7 +83,7 @@ function screenLines(input, width) {
                 badgeLabels.error,
                 `Error: ${input.error ?? 'Unknown setup error'}`,
                 'No unconfirmed provider config write was performed.',
-                'Next: inspect `vgx setup plan`, resolve blockers, then retry.',
+                'Next: inspect `vgxness setup plan`, resolve blockers, then retry.',
                 footer([setupFooterHints.close], width),
             ];
         case 'cancelled':
@@ -106,7 +105,7 @@ function planLines(vm, width) {
         vm.backupLabel,
         ...vm.plannedActions.map((action) => `Action: ${action.safetyBadge} ${action.label}${action.targetPathLabel === undefined ? '' : ` (${compactPath(action.targetPathLabel, width - 12)})`}`),
         ...vm.warnings.map((warning) => `Warning: ${warning}`),
-        ...vm.blockers.map((blocker) => `Blocked: ${blocker}`),
+        ...vm.blockers.map((blocker) => `Blocked because: ${blocker}`),
     ];
 }
 function workspaceLines(vm, lines, width, hints = [setupFooterHints.continue, setupFooterHints.back, setupFooterHints.cancel]) {
@@ -155,11 +154,11 @@ function resultLines(result, vm, width) {
 }
 function resultNextCommands(vm) {
     const filtered = vm.nextCommands.filter((command) => !/^vgx(?:ness)? setup apply\b/.test(command));
-    const withDoctor = filtered.some((command) => /\bdoctor\b/.test(command)) ? filtered : [...filtered, 'vgx doctor'];
+    const withDoctor = filtered.some((command) => /\bdoctor\b/.test(command)) ? filtered : [...filtered, 'vgxness doctor'];
     return withDoctor.some((command) => /Restart OpenCode/i.test(command)) ? withDoctor : [...withDoctor, 'Restart OpenCode and verify the vgxness MCP server is visible.'];
 }
-function doctorCommand(vm) {
-    return vm.nextCommands.find((command) => /\bdoctor\b/.test(command)) ?? 'vgx doctor';
+function nextCommandLines(vm) {
+    return ['Next commands:', ...vm.nextCommands.map((command) => `Next: ${command}`)];
 }
 function footer(hints, width) {
     return formatFooter(hints, width);

package/dist/cli/tui/setup/setup-tui-state.js

@@ -81,7 +81,7 @@ export function reduceSetupTuiState(state, action) {
                 result: {
                     status: 'failed',
                     message: action.message,
-                    recovery: ['Inspect the setup plan with `vgx setup plan`.', 'Resolve blockers before retrying.'],
+                    recovery: ['Inspect the setup plan with `vgxness setup plan`.', 'Resolve blockers before retrying.'],
                     writesOccurred: false,
                 },
             };

package/dist/code/runtime/sdd-context.js

@@ -84,8 +84,6 @@ export function validateSddReadiness(context) {
     if (context.next.status === 'complete')
         return { ok: true };
     const present = context.status.phases.find((candidate) => candidate.phase === context.phase)?.present === true;
-    if (present)
-        return { ok: true };
     const blockedPrerequisites = activeBlockedPrerequisites(context);
     if (blockedPrerequisites.length > 0)
         return {
@@ -100,6 +98,8 @@ export function validateSddReadiness(context) {
                 recommendedAction: `Accept or restore prerequisites before running ${context.phase}.`,
             },
         };
+    if (present)
+        return { ok: true };
     if (context.status.nextReadyPhase === context.phase)
         return { ok: true };
     return {

package/dist/mcp/validation.js

@@ -244,7 +244,7 @@ function readProjectAndChange(record, tool) {
     return { ok: true, value: { project: project.value, change: change.value } };
 }
 function validateSddReadyInput(input, tool) {
-    const record = inputRecord(input, tool, ['project', 'change', 'phase']);
+    const record = inputRecord(input, tool, ['project', 'change', 'phase', 'runId', 'agentId']);
     if (!record.ok)
         return record;
     const base = readProjectAndChange(record.value, tool);
@@ -253,7 +253,11 @@ function validateSddReadyInput(input, tool) {
     const phase = readPhase(record.value, tool);
     if (!phase.ok)
         return phase;
-    return { ok: true, value: { ...base.value, phase: phase.value } };
+    const result = { ...base.value, phase: phase.value };
+    const copied = copyOptionalStrings(result, record.value, tool, ['runId', 'agentId']);
+    if (!copied.ok)
+        return copied;
+    return { ok: true, value: result };
 }
 function validateSddGetReadinessInput(input, tool) {
     return validateSddReadyInput(input, tool);

package/dist/orchestrator/natural-language-planner.js

@@ -226,7 +226,7 @@ function buildPreviewActions(input, flow, needsClarification) {
     if (flow === 'build')
         return [{ kind: 'workflow-preview', description: 'Preview a scoped build workflow; no execution occurs in this planner response.' }];
     const change = input.change;
-    const command = change === undefined ? undefined : `npm run cli -- sdd next --project ${input.project} --change ${change}`;
+    const command = change === undefined ? undefined : `vgxness sdd next --project ${input.project} --change ${change}`;
     return [
         {
             kind: 'sdd-preview',

package/dist/sdd/sdd-workflow-service.js

@@ -96,7 +96,7 @@ export class SddWorkflowService {
             acceptedCount: cockpitPhases.filter((phase) => phase.accepted).length,
             legacyCount: cockpitPhases.filter((phase) => phase.legacy).length,
             aggregateBlockers,
-            inspectCommand: `vgx sdd cockpit --project ${validated.value.project} --change ${validated.value.change} --json`,
+            inspectCommand: `vgxness sdd cockpit --project ${validated.value.project} --change ${validated.value.change} --json`,
         };
         return ok(cockpit);
     }

package/dist/setup/backup-rollback-service.js

@@ -81,7 +81,7 @@ export function previewRollbackConfigBackup(input) {
             restorable: blockers.length === 0 && targetPath !== undefined,
             blockers,
             warnings,
-            nextCommands: blockers.length === 0 ? [`vgx setup rollback --backup ${backupPath} --yes`] : ['Resolve blockers, then rerun rollback preview.'],
+            nextCommands: blockers.length === 0 ? [`vgxness setup rollback --backup ${backupPath} --yes`] : ['Resolve blockers, then rerun rollback preview.'],
         },
     };
 }
@@ -133,7 +133,7 @@ export function applyRollbackConfigBackup(input) {
                 targetPath,
                 ...(preRollbackBackup === undefined ? {} : { preRollbackBackupPath: preRollbackBackup.backupPath, preRollbackBackup }),
                 backup: preview.value.backup,
-                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.'],
             },
         };
     }

package/dist/setup/setup-lifecycle-service.js

@@ -74,7 +74,7 @@ function storeStatus(result) {
         status: 'blocked',
         path: '',
         blocker: result.error.message,
-        recovery: 'Run `vgx doctor` and verify the configured local memory path is writable.',
+        recovery: 'Run `vgxness doctor` and verify the configured local memory path is writable.',
     };
 }
 function mcpStatus(result, storeReadiness) {
@@ -178,17 +178,17 @@ function verificationSummary(environment, project, providers, agents, mcp) {
 }
 function nextAction(store, mcp, defaults, providers, project) {
     if (store.status !== 'ready') {
-        return { command: 'vgx doctor', reason: `Local store is blocked: ${store.blocker ?? 'local store is unavailable'}` };
+        return { command: 'vgxness doctor', reason: `Local store is blocked: ${store.blocker ?? 'local store is unavailable'}` };
     }
     if (defaults.status !== 'ready') {
         if (defaults.blocker?.startsWith('No project selected') === true) {
             return {
-                command: 'vgx setup status --project <project>',
+                command: 'vgxness setup status --project <project>',
                 reason: defaults.nextAction ?? 'Select a project to verify project-scoped setup checks.',
             };
         }
         return {
-            command: 'vgx agents seed --scope project',
+            command: 'vgxness agents seed --scope project',
             reason: `Default context is blocked: ${defaults.blocker ?? 'default context is unavailable'}`,
         };
     }
@@ -201,8 +201,8 @@ function nextAction(store, mcp, defaults, providers, project) {
             reason: `Provider MCP status is not ready; review the Providers section for provider-specific preview/install guidance (${providerSummary}).`,
         };
     }
-    return { command: 'vgx runs list', reason: 'Project setup is ready; continue with normal vgxness usage.' };
+    return { command: 'vgxness runs list', reason: 'Project setup is ready; continue with normal vgxness usage.' };
 }
 function setupStatusCommand(project) {
-    return project === undefined ? 'vgx setup status' : `vgx setup status --project ${project}`;
+    return project === undefined ? 'vgxness setup status' : `vgxness setup status --project ${project}`;
 }

package/dist/setup/setup-plan.js

@@ -78,11 +78,11 @@ function setupPlanFromOpenCode(input) {
                     severity: 'blocking',
                     message: input.opencode.message,
                     ...(input.opencode.targetPath === undefined ? {} : { targetPath: input.opencode.targetPath }),
-                    recovery: 'Inspect the OpenCode config, resolve the conflict, then rerun `vgx setup plan`.',
+                    recovery: 'Inspect the OpenCode config, resolve the conflict, then rerun `vgxness setup plan`.',
                 },
             ],
             backupsPlanned: [],
-            nextCommands: ['vgx setup plan', 'vgxness mcp doctor opencode'],
+            nextCommands: ['vgxness setup plan', 'vgxness mcp doctor opencode'],
         };
     }
     return {
@@ -115,7 +115,7 @@ function setupPlanFromOpenCode(input) {
                 },
             ]
             : [],
-        nextCommands: ['vgx setup apply --yes', 'vgx doctor', 'Restart OpenCode and verify the vgxness MCP server is visible.'],
+        nextCommands: ['vgxness setup apply --yes', 'vgxness doctor', 'Restart OpenCode and verify the vgxness MCP server is visible.'],
     };
 }
 function resolveSetupDatabase(input) {

package/dist/verification/verification-plan-service.js

@@ -21,7 +21,7 @@ const templates = {
     },
     cli: {
         rationale: ['CLI changes affect TypeScript dispatch/rendering paths and user-visible behavior.', 'Only typecheck is currently allowlisted; CLI execution remains manual/copy-only.'],
-        recommendations: [typecheckRecommendation(), manualRecommendation('manual-cli-smoke', 'Smoke-test CLI command manually', 'Use npm run cli -- <command> as copy-only text for an operator-selected CLI scenario.', 'npm run cli -- <command>')],
+        recommendations: [typecheckRecommendation(), manualRecommendation('manual-cli-smoke', 'Smoke-test CLI command manually', 'Use bun run cli:bun -- <command> as copy-only text for an operator-selected CLI scenario.', 'bun run cli:bun -- <command>')],
         manualChecks: [manualCheck('review-cli-output', 'Review CLI output shape', 'Confirm human output is concise and JSON output remains structured where applicable.')],
     },
     mcp: {