vgxness 1.2.1 → 1.3.1

package/dist/code/tui/runtime-events.js

@@ -0,0 +1,320 @@
+export function sampleEvents(now = new Date('2026-05-26T23:30:00.000Z')) {
+    const createdAt = now.toISOString();
+    return [
+        {
+            type: 'session.started',
+            projectRoot: 'vgxness',
+            userIntent: 'Build the vgxcode OpenTUI shell',
+            createdAt,
+        },
+        {
+            type: 'provider.message',
+            content: 'I will inspect the runtime event stream and prepare a safe UI shell.',
+            toolCallCount: 1,
+            createdAt,
+        },
+        {
+            type: 'tool.requested',
+            toolName: 'read_file',
+            createdAt,
+        },
+        {
+            type: 'tool.completed',
+            toolName: 'read_file',
+            ok: true,
+            changedFiles: [],
+            createdAt,
+        },
+        {
+            type: 'verification.completed',
+            status: 'not-run',
+            reason: 'Static shell preview; no runtime commands executed.',
+            createdAt,
+        },
+        {
+            type: 'session.completed',
+            status: 'completed',
+            outcome: 'success',
+            createdAt,
+        },
+    ];
+}
+export function parseVgxcodeJsonl(input) {
+    const events = [];
+    const errors = [];
+    const lines = input.split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (isVgxcodeEvent(parsed))
+                events.push(parsed);
+            else
+                errors.push(formatUnsupportedRuntimeEvent(parsed, index + 1));
+        }
+        catch (error) {
+            errors.push(`Line ${index + 1}: ${formatJsonlParseError(trimmed, error)}`);
+        }
+    }
+    return { events, errors };
+}
+export function parseVgxcodeJsonlLine(line, lineNumber) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return {};
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (isVgxcodeEvent(parsed))
+            return { event: parsed };
+        return { error: formatUnsupportedRuntimeEvent(parsed, lineNumber) };
+    }
+    catch (error) {
+        return { error: `Line ${lineNumber}: ${formatJsonlParseError(trimmed, error)}` };
+    }
+}
+function formatJsonlParseError(line, error) {
+    const reason = error instanceof Error ? error.message : 'invalid JSON';
+    const looksLikeNpmBanner = line.startsWith('>') || line.includes('npm') || line.includes('run-script');
+    const snippet = line.length > 80 ? `${line.slice(0, 77)}...` : line;
+    return looksLikeNpmBanner
+        ? `${reason} (non-JSON output; use npm --silent for the bridge; got: ${snippet})`
+        : `${reason} (invalid JSONL; got: ${snippet})`;
+}
+function formatUnsupportedRuntimeEvent(value, lineNumber) {
+    const type = isRecord(value) && typeof value.type === 'string' ? value.type : 'missing type';
+    return `Line ${lineNumber}: unsupported runtime event (${type}); expected vgxcode read-only JSONL event`;
+}
+export function summarizeEvent(event) {
+    switch (event.type) {
+        case 'session.started':
+            return `◇ Session started — ${event.userIntent}`;
+        case 'prompt.accepted':
+            return `◇ Prompt accepted — ${event.messageCount} messages, ${event.toolCount} tools`;
+        case 'provider.message':
+            return `● Assistant — ${event.content}`;
+        case 'tool.requested':
+            return `▸ Tool requested — ${event.toolName}`;
+        case 'approval.pending':
+            return `! Approval pending — ${event.toolName}`;
+        case 'approval.decided':
+            return `! Approval ${event.final} — ${event.toolName}: ${event.reason}`;
+        case 'approval.decision_rejected':
+            return `! Approval decision rejected — ${event.bindingResult}: ${event.reason}`;
+        case 'approval.preview':
+            return `! Approval preview — ${event.toolName}: No mutation executed`;
+        case 'tool.completed':
+            return `${event.ok ? '✓' : '✕'} Tool completed — ${event.toolName}`;
+        case 'diff.preview':
+            return `◇ Diff preview — ${event.files.length} files, ${event.bodyBytes}/${event.originalBytes} bytes${event.truncated ? ' (truncated)' : ''}`;
+        case 'verification.completed':
+            return `${event.status === 'passed' ? '✓' : event.status === 'failed' ? '✕' : '·'} Verification — ${event.reason}`;
+        case 'session.completed':
+            return `◆ Session ${event.status} — ${event.outcome}`;
+        case 'session.failed':
+            return `✕ Session ${event.status} — ${event.message}`;
+    }
+}
+export function buildSafetyReadModel(events) {
+    const pendingApprovals = new Map();
+    let latestApprovalDecision;
+    let latestApprovalPreview;
+    const changedFiles = [];
+    const seenChangedFiles = new Set();
+    let latestDiffPreview;
+    for (const event of events) {
+        switch (event.type) {
+            case 'approval.pending':
+                if (event.approvalId === undefined || event.toolCallId === undefined)
+                    break;
+                pendingApprovals.set(approvalKey(event.approvalId, event.toolCallId), {
+                    ...(event.approvalId === undefined ? {} : { approvalId: event.approvalId }),
+                    ...(event.toolCallId === undefined ? {} : { toolCallId: event.toolCallId }),
+                    toolName: event.toolName,
+                    ...(event.operationSummary === undefined ? {} : { operationSummary: event.operationSummary }),
+                    ...(event.targetPath === undefined ? {} : { targetPath: event.targetPath }),
+                    ...(event.risk === undefined ? {} : { risk: event.risk }),
+                    createdAt: event.createdAt,
+                });
+                break;
+            case 'approval.decided':
+                if (event.approvalId !== undefined && event.toolCallId !== undefined)
+                    pendingApprovals.delete(approvalKey(event.approvalId, event.toolCallId));
+                latestApprovalDecision = {
+                    ...(event.approvalId === undefined ? {} : { approvalId: event.approvalId }),
+                    ...(event.toolCallId === undefined ? {} : { toolCallId: event.toolCallId }),
+                    toolName: event.toolName,
+                    ...(event.status === undefined ? {} : { status: event.status }),
+                    final: event.final,
+                    reason: event.reason,
+                    createdAt: event.createdAt,
+                };
+                break;
+            case 'approval.decision_rejected':
+                if (event.approvalId !== undefined && event.toolCallId !== undefined && isResolvingDecisionRejection(event.bindingResult)) {
+                    pendingApprovals.delete(approvalKey(event.approvalId, event.toolCallId));
+                }
+                break;
+            case 'approval.preview':
+                latestApprovalPreview = {
+                    toolName: event.toolName,
+                    capability: event.capability,
+                    ...(event.targetPath === undefined ? {} : { targetPath: event.targetPath }),
+                    reason: event.reason,
+                    risk: event.risk,
+                    createdAt: event.createdAt,
+                };
+                break;
+            case 'tool.completed':
+                for (const changedFile of event.changedFiles) {
+                    if (seenChangedFiles.has(changedFile))
+                        continue;
+                    seenChangedFiles.add(changedFile);
+                    changedFiles.push(changedFile);
+                }
+                break;
+            case 'diff.preview':
+                latestDiffPreview = {
+                    files: event.files,
+                    body: event.body,
+                    bodyBytes: event.bodyBytes,
+                    originalBytes: event.originalBytes,
+                    truncated: event.truncated,
+                    redacted: event.redacted,
+                    hash: event.hash,
+                    createdAt: event.createdAt,
+                };
+                for (const file of event.files) {
+                    if (seenChangedFiles.has(file))
+                        continue;
+                    seenChangedFiles.add(file);
+                    changedFiles.push(file);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    const pendingApprovalValues = [...pendingApprovals.values()];
+    const latestPendingApproval = pendingApprovalValues.at(-1);
+    return {
+        pendingApprovals: pendingApprovalValues,
+        pendingApprovalCount: pendingApprovalValues.length,
+        ...(latestPendingApproval ? { latestPendingApproval } : {}),
+        ...(latestApprovalDecision ? { latestApprovalDecision } : {}),
+        ...(latestApprovalPreview ? { latestApprovalPreview } : {}),
+        changedFiles,
+        diffAvailability: latestDiffPreview !== undefined ? 'preview' : changedFiles.length > 0 ? 'filenames-only' : 'none',
+        ...(latestDiffPreview ? { latestDiffPreview } : {}),
+    };
+}
+function isVgxcodeEvent(value) {
+    if (!isRecord(value) || typeof value.type !== 'string' || typeof value.createdAt !== 'string')
+        return false;
+    switch (value.type) {
+        case 'session.started':
+            return typeof value.projectRoot === 'string' && typeof value.userIntent === 'string';
+        case 'prompt.accepted':
+            return typeof value.messageCount === 'number' && typeof value.toolCount === 'number';
+        case 'provider.message':
+            return typeof value.content === 'string' && typeof value.toolCallCount === 'number';
+        case 'tool.requested':
+            return typeof value.toolName === 'string';
+        case 'approval.pending':
+            return typeof value.toolName === 'string' && isOptionalApprovalContext(value);
+        case 'approval.decided':
+            return (typeof value.toolName === 'string' &&
+                typeof value.reason === 'string' &&
+                isApprovalFinal(value.final) &&
+                (value.approvalId === undefined || typeof value.approvalId === 'string') &&
+                (value.toolCallId === undefined || typeof value.toolCallId === 'string') &&
+                (value.status === undefined || isApprovalStatus(value.status)));
+        case 'approval.decision_rejected':
+            return (typeof value.reason === 'string' &&
+                isApprovalDecisionBindingResult(value.bindingResult) &&
+                (value.approvalId === undefined || typeof value.approvalId === 'string') &&
+                (value.toolCallId === undefined || typeof value.toolCallId === 'string') &&
+                (value.status === undefined || value.status === 'approved' || value.status === 'denied'));
+        case 'approval.preview':
+            return (typeof value.toolCallId === 'string' &&
+                typeof value.toolName === 'string' &&
+                isCapability(value.capability) &&
+                isRecord(value.risk) &&
+                typeof value.risk.mutatesWorkspace === 'boolean' &&
+                typeof value.risk.requiresApproval === 'boolean' &&
+                value.reason === 'preview_only' &&
+                (value.targetPath === undefined || typeof value.targetPath === 'string'));
+        case 'tool.completed':
+            return typeof value.toolName === 'string' && typeof value.ok === 'boolean' && Array.isArray(value.changedFiles) && value.changedFiles.every((changedFile) => typeof changedFile === 'string');
+        case 'diff.preview':
+            return (typeof value.sourceToolCallId === 'string' &&
+                value.sourceToolName === 'git_diff' &&
+                value.format === 'unified' &&
+                Array.isArray(value.files) &&
+                value.files.every((file) => typeof file === 'string') &&
+                typeof value.body === 'string' &&
+                typeof value.bodyBytes === 'number' &&
+                typeof value.originalBytes === 'number' &&
+                typeof value.truncated === 'boolean' &&
+                typeof value.redacted === 'boolean' &&
+                typeof value.hash === 'string');
+        case 'verification.completed':
+            return isVerificationStatus(value.status) && typeof value.reason === 'string';
+        case 'session.completed':
+            return isSessionStatus(value.status) && isOutcome(value.outcome);
+        case 'session.failed':
+            return isFailedSessionStatus(value.status) && typeof value.message === 'string';
+        default:
+            return false;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isApprovalFinal(value) {
+    return value === 'allow' || value === 'deny' || value === 'blocked';
+}
+function isApprovalStatus(value) {
+    return value === 'approved' || value === 'denied' || value === 'blocked' || value === 'cancelled' || value === 'timed_out';
+}
+function isApprovalDecisionBindingResult(value) {
+    return value === 'malformed' || value === 'unknown' || value === 'binding_mismatch' || value === 'duplicate' || value === 'stale' || value === 'invalid_status' || value === 'cancelled';
+}
+function isResolvingDecisionRejection(bindingResult) {
+    return bindingResult === 'duplicate' || bindingResult === 'stale' || bindingResult === 'cancelled';
+}
+function approvalKey(approvalId, toolCallId) {
+    return `${approvalId}:${toolCallId}`;
+}
+function isOptionalApprovalContext(value) {
+    return ((value.approvalId === undefined || typeof value.approvalId === 'string') &&
+        (value.toolCallId === undefined || typeof value.toolCallId === 'string') &&
+        (value.operationSummary === undefined || typeof value.operationSummary === 'string') &&
+        (value.targetPath === undefined || typeof value.targetPath === 'string') &&
+        (value.risk === undefined || isApprovalRisk(value.risk)));
+}
+function isApprovalRisk(value) {
+    return (isRecord(value) &&
+        typeof value.mutatesWorkspace === 'boolean' &&
+        typeof value.requiresApproval === 'boolean' &&
+        (value.destructive === undefined || typeof value.destructive === 'boolean') &&
+        (value.external === undefined || typeof value.external === 'boolean') &&
+        (value.privileged === undefined || typeof value.privileged === 'boolean') &&
+        (value.ambiguous === undefined || typeof value.ambiguous === 'boolean'));
+}
+function isCapability(value) {
+    return value === 'read' || value === 'edit' || value === 'shell' || value === 'git' || value === 'network' || value === 'memory' || value === 'sdd' || value === 'run' || value === 'mcp';
+}
+function isVerificationStatus(value) {
+    return value === 'not-run' || value === 'passed' || value === 'failed';
+}
+function isSessionStatus(value) {
+    return value === 'completed' || value === 'partial' || value === 'blocked' || value === 'failed' || value === 'cancelled';
+}
+function isFailedSessionStatus(value) {
+    return value === 'blocked' || value === 'failed' || value === 'cancelled';
+}
+function isOutcome(value) {
+    return value === 'success' || value === 'partial' || value === 'failure' || value === 'blocked' || value === 'cancelled';
+}

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

@@ -38,30 +38,6 @@ export class SddWorkflowService {
         const phases = this.getPhaseStatuses(validated.value.project, validated.value.change);
         return statusFromPhases(validated.value.change, phases);
     }
-    getDashboardStatus(input) {
-        const validated = validateProjectAndChange(input.project, input.change);
-        if (!validated.ok)
-            return validated;
-        const phases = this.getPhaseStatusesNoTrace(validated.value.project, validated.value.change);
-        if (!phases.ok)
-            return phases;
-        return statusFromPhases(validated.value.change, phases.value);
-    }
-    getPhaseStatusesNoTrace(project, change) {
-        const statuses = [];
-        for (const phase of sddPhases) {
-            const topicKey = sddTopicKey(change, phase);
-            const artifact = this.memory.getArtifactNoTrace(project, topicKey);
-            if (!artifact.ok) {
-                if (artifact.error.code !== 'not_found')
-                    return artifact;
-                statuses.push({ phase, topicKey, present: false, state: 'missing', accepted: false, legacy: false });
-                continue;
-            }
-            statuses.push(phaseStatusFromArtifact(phase, topicKey, artifact.value));
-        }
-        return { ok: true, value: statuses };
-    }
     getNext(input) {
         const validated = validateProjectAndChange(input.project, input.change);
         if (!validated.ok)
@@ -120,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/providers/antigravity-setup-adapter.js

@@ -4,7 +4,7 @@ export const antigravitySetupAdapter = {
     displayName: 'Antigravity',
     supportLevel: 'placeholder',
     capabilities: ['manual-guidance'],
-    targets: [{ kind: 'manual', label: 'Coming soon manual guidance', writableByDashboard: false }],
+    targets: [{ kind: 'manual', label: 'Coming soon manual guidance', writableBySetup: false }],
     getStatus() {
         return {
             providerId: 'antigravity',

package/dist/setup/providers/claude-setup-adapter.js

@@ -5,7 +5,7 @@ export const claudeSetupAdapter = {
     displayName: 'Claude',
     supportLevel: 'preview-only',
     capabilities: ['mcp-preview', 'manual-guidance'],
-    targets: [{ kind: 'manual', label: 'Claude MCP config snippet', writableByDashboard: false }],
+    targets: [{ kind: 'manual', label: 'Claude MCP config snippet', writableBySetup: false }],
     getStatus(context) {
         return {
             providerId: 'claude',
@@ -14,7 +14,7 @@ export const claudeSetupAdapter = {
             evidence: context.databasePath !== undefined
                 ? ['Claude MCP preview can be generated from the selected database path.']
                 : ['Claude MCP preview uses a placeholder until a database path is selected.'],
-            guidance: ['Copy snippets manually after reviewing them. The dashboard does not install or apply Claude config.'],
+            guidance: ['Copy snippets manually after reviewing them. The TUI does not install or apply Claude config.'],
             actions: [
                 {
                     id: 'claude-manual-guidance',

package/dist/setup/providers/custom-setup-adapter.js

@@ -4,7 +4,7 @@ export const customSetupAdapter = {
     displayName: 'Custom',
     supportLevel: 'extension-point',
     capabilities: ['manual-guidance'],
-    targets: [{ kind: 'extension', label: 'Custom provider extension point', writableByDashboard: false }],
+    targets: [{ kind: 'extension', label: 'Custom provider extension point', writableBySetup: false }],
     getStatus() {
         return {
             providerId: 'custom',

package/dist/setup/providers/opencode-setup-adapter.js

@@ -8,8 +8,8 @@ export const openCodeSetupAdapter = {
     supportLevel: 'supported-primary',
     capabilities: ['mcp-preview', 'mcp-install-plan', 'mcp-install-apply-external', 'agent-preview', 'doctor', 'visibility-check'],
     targets: [
-        { kind: 'user-config', label: 'User/global OpenCode config (default)', path: '$HOME/.config/opencode/opencode.json', writableByDashboard: false },
-        { kind: 'project-config', label: 'Project OpenCode config (explicit opt-in)', path: '.opencode/opencode.json', writableByDashboard: false },
+        { kind: 'user-config', label: 'User/global OpenCode config (default)', path: '$HOME/.config/opencode/opencode.json', writableBySetup: false },
+        { kind: 'project-config', label: 'Project OpenCode config (explicit opt-in)', path: '.opencode/opencode.json', writableBySetup: false },
     ],
     getStatus(context) {
         const visibility = this.getVisibility?.(context);
@@ -161,7 +161,7 @@ function externalInstallAction(scope, targetPath) {
         label: `Copy external OpenCode ${scope === 'user' ? 'user/global' : 'project'} install command`,
         kind: 'copy-command',
         command: ['vgxness', 'mcp', 'install', 'opencode', '--scope', scope, '--yes'],
-        description: 'Copy and run this outside the dashboard only after reviewing the read-only plan.',
+        description: 'Copy and run this outside the TUI only after reviewing the read-only plan.',
         safety: externalProviderWriteSafety(targetPath),
     };
 }

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 dashboard interactive --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: {