vgxness 1.2.1 → 1.3.0

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

@@ -0,0 +1,43 @@
+import { navigationIntentFromInput } from '../keymap.js';
+export function setupTuiActionFromInput(input, key, state) {
+    if (key.upArrow === true)
+        return { type: 'focus-previous-choice' };
+    if (key.downArrow === true)
+        return { type: 'focus-next-choice' };
+    if (key.escape === true)
+        return state.helpVisible ? { type: 'toggle-help' } : { type: 'cancel' };
+    if (key.tab === true && key.shift === true)
+        return { type: 'back' };
+    if (key.tab === true)
+        return { type: 'continue' };
+    const raw = key.return === true ? '\n' : input;
+    const intent = navigationIntentFromInput(raw);
+    if (intent === 'cancel')
+        return state.helpVisible ? { type: 'toggle-help' } : { type: 'cancel' };
+    if (intent === 'help')
+        return { type: 'toggle-help' };
+    if (intent === 'up')
+        return { type: 'focus-previous-choice' };
+    if (intent === 'down')
+        return { type: 'focus-next-choice' };
+    if (intent === 'select')
+        return { type: 'select-focused-choice' };
+    if (intent === 'back')
+        return { type: 'back' };
+    if (intent !== 'next')
+        return undefined;
+    if (key.return === true && isEditableChoiceScreen(state))
+        return { type: 'select-focused-choice' };
+    if (state.screen === 'plan-review')
+        return { type: 'request-apply' };
+    if (state.screen === 'final-confirmation')
+        return { type: 'confirm-apply' };
+    return { type: 'continue' };
+}
+function isEditableChoiceScreen(state) {
+    if (state.focusedChoiceId === undefined)
+        return false;
+    if (state.screen === 'project-database' || state.screen === 'provider')
+        return true;
+    return state.screen === 'opencode-details' && state.selections.provider === 'opencode';
+}

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

@@ -1,4 +1,4 @@
-import { badgeLabels, compactPath } from './screens/screen-components.js';
+import { badgeLabels, compactPath } from './setup-tui-view-helpers.js';
 export function buildSetupTuiViewModel(state) {
     return setupTuiViewModelFromPlan(state.plan, state.status, state);
 }

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

@@ -1,4 +1,4 @@
-import { badgeLabels, compactPath, formatFooter, setupFooterHints, wrapLabel } from './screens/screen-components.js';
+import { badgeLabels, compactPath, formatFooter, setupFooterHints, wrapLabel } from './setup-tui-view-helpers.js';
 export function renderSetupTuiShape(input) {
     const width = input.width ?? 80;
     const lines = [input.viewModel.title, ...screenLines(input, width)];

package/dist/cli/tui/setup/setup-tui-view-helpers.js

@@ -0,0 +1,46 @@
+import { formatTuiFooter } from '../visual/footer.js';
+export const badgeLabels = {
+    recommended: '[recommended]',
+    selected: '[selected]',
+    focused: '[focused]',
+    warning: '[warning]',
+    error: '[error]',
+    writeAfterConfirm: '[will write after confirm]',
+    readOnly: '[read-only]',
+    manual: '[manual]',
+    deferred: '[deferred]',
+    cancelled: '[cancelled]',
+    pending: '[pending]',
+    success: '[success]',
+};
+export const setupFooterHints = {
+    continue: { key: 'Enter', label: 'continue' },
+    select: { key: 'Enter/Space', label: 'select focused row' },
+    finalConfirmation: { key: 'Enter', label: 'final confirmation' },
+    confirmApply: { key: 'Enter', label: 'confirm and apply' },
+    help: { key: '?/h', label: 'help' },
+    back: { key: 'Shift+Tab', label: 'back' },
+    cancel: { key: 'q/Esc', label: 'cancel' },
+    close: { key: 'q/Esc', label: 'close' },
+};
+export function compactPath(path, width) {
+    if (width <= 0 || path.length <= width)
+        return path;
+    const basename = path.split(/[\\/]/).filter(Boolean).pop() ?? path;
+    if (basename.length + 4 >= width)
+        return `.../${basename}`;
+    const prefixWidth = Math.max(1, width - basename.length - 5);
+    return `${path.slice(0, prefixWidth)}.../${basename}`;
+}
+export function wrapLabel(value, width) {
+    if (width <= 0 || value.length <= width)
+        return value;
+    const protectedPhrases = ['final confirmation', 'confirm and apply', 'not installable', 'read-only', 'requires confirmation', 'will write after confirm', 'error', 'cancelled'];
+    const phrase = protectedPhrases.find((candidate) => value.includes(candidate));
+    if (phrase !== undefined)
+        return `${value.slice(0, Math.max(0, width - phrase.length - 5)).trim()} ... ${phrase}`.trim();
+    return `${value.slice(0, Math.max(0, width - 1)).trim()}…`;
+}
+export function formatFooter(hints, width) {
+    return formatTuiFooter(hints, width);
+}

package/dist/cli/tui/visual/index.js

@@ -1,5 +1,3 @@
 export * from './badges.js';
-export * from './choice-list.js';
 export * from './footer.js';
-export * from './layout.js';
 export * from './viewport.js';

package/dist/code/tui/approval-actions.js

@@ -0,0 +1,33 @@
+export function getApprovalActionsState(input) {
+    if (input.source !== 'interactive' || input.status !== 'running' || input.mode !== 'craft' || !input.childStdinOpen)
+        return { enabled: false };
+    const approval = input.latestPendingApproval;
+    if (input.pendingApprovalCount < 1 || approval?.approvalId === undefined || approval.toolCallId === undefined)
+        return { enabled: false };
+    return { enabled: true, approval };
+}
+export class ApprovalDecisionWriter {
+    #sink;
+    #writtenKeys = new Set();
+    constructor(sink) {
+        this.#sink = sink;
+    }
+    write(approval, status, reason) {
+        if (approval?.approvalId === undefined || approval.toolCallId === undefined)
+            return false;
+        if (this.#sink.writableEnded === true || this.#sink.destroyed === true)
+            return false;
+        const key = `${approval.approvalId}:${approval.toolCallId}`;
+        if (this.#writtenKeys.has(key))
+            return false;
+        this.#sink.write(`${JSON.stringify({
+            type: 'approval.decision',
+            approvalId: approval.approvalId,
+            toolCallId: approval.toolCallId,
+            status,
+            reason,
+        })}\n`);
+        this.#writtenKeys.add(key);
+        return true;
+    }
+}

package/dist/code/tui/prompt-mode.js

@@ -0,0 +1,11 @@
+export function parsePromptSubmission(input, currentMode) {
+    const trimmed = input.trim();
+    const prefixMatch = /^(\/(inspect|plan|craft|craft-preview))(?:\s+|$)/iu.exec(trimmed);
+    if (!prefixMatch)
+        return { mode: currentMode, prompt: trimmed };
+    const mode = prefixMatch[2]?.toLowerCase();
+    return { mode, prompt: trimmed.slice(prefixMatch[0].length).trim() };
+}
+export function toggleReadOnlyMode(mode) {
+    return mode === 'inspect' ? 'plan' : 'inspect';
+}

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/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)

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

@@ -183,7 +183,7 @@ function nextAction(store, mcp, defaults, providers, project) {
     if (defaults.status !== 'ready') {
         if (defaults.blocker?.startsWith('No project selected') === true) {
             return {
-                command: 'vgx dashboard interactive --project <project>',
+                command: 'vgx setup status --project <project>',
                 reason: defaults.nextAction ?? 'Select a project to verify project-scoped setup checks.',
             };
         }

package/docs/architecture.md

@@ -178,7 +178,7 @@ This plane should remain separate from runtime execution. Rendering OpenCode, Cl
 |---|---|---|---|
 | MCP server | AI coding tools and agents | Query/update workflow state, resolve agents/skills, record runs/checkpoints, request approvals. | Bypass permission policy or mutate provider config directly. |
 | CLI | Human operators, scripts, CI-friendly automation | Initialize, inspect, doctor, sync/render assets, manage MCP installs, inspect SDD/runs/profiles. | Hide dangerous changes or require manual JSON editing for the happy path. |
-| TUI | Humans during setup and local operation | Guide installation, show health/status, configure profiles, inspect SDD progress, surface blockers. | Become a decorative dashboard without next actions. |
+| TUI | Humans during setup and local operation | Guide installation, show health/status, surface blockers. | Become decorative without next actions. |
 
 ### Natural-language planning seam
 
@@ -214,7 +214,7 @@ Current MCP tool groups are defined in source by `SUPPORTED_VGX_MCP_TOOL_NAMES`;
 | Runs | `vgxness_run_start`, `vgxness_run_list`, `vgxness_run_get`, `vgxness_run_preflight`, `vgxness_run_checkpoint`, `vgxness_run_finalize` | Keep execution history, safety preflight, and resumability explicit. |
 | Resolution/profile/payload | `vgxness_agent_resolve`, `vgxness_agent_activate`, `vgxness_manager_profile_get`, `vgxness_manager_profile_set`, `vgxness_skill_payload`, `vgxness_opencode_manager_payload` | Give agents the correct role, skills, model/profile context, and read-only OpenCode manager previews. Payload/profile preview tools do not execute providers or mutate provider config by default. |
 
-MVP transport should prefer local stdio because it matches common MCP host expectations and avoids opening a network port. A local HTTP transport can be added later for dashboard or background-daemon use cases.
+MVP transport should prefer local stdio because it matches common MCP host expectations and avoids opening a network port. A local HTTP transport can be added later for web-console or background-daemon use cases.
 
 ### CLI boundary
 
@@ -249,7 +249,7 @@ The TUI is the guided human surface. It should optimize for the next meaningful
 | Doctor | Fix broken config, missing MCP integration, memory issues, and stale assets. |
 | Settings | Review local preferences and configuration status without silent provider writes. |
 
-Every TUI screen must define loading, empty, error, success, blocked, and permission states. The dashboard TUI is read-only: provider config writes/install/apply are external-only, require explicit confirmation outside the dashboard, and are not run by dashboard flows.
+Every TUI screen must define loading, empty, error, success, blocked, and permission states. TUI status surfaces are read-only: provider config writes/install/apply are external-only, require explicit confirmation outside the TUI, and are not run by preview/status flows.
 
 ### Installation flow
 
@@ -693,6 +693,6 @@ Out of scope:
 
 - cloud sync
 - team collaboration
-- web dashboard
+- web console
 - distributed workers
 - fully autonomous skill mutation