vgxness 1.2.1 → 1.3.0

package/README.md

@@ -6,7 +6,7 @@ VGXNESS is an installable CLI and MCP control plane for guided AI-agent workflow
 
 This package is proprietary software. The npm package ships inspectable JavaScript (`dist/`) so Node can run it, but it is **not open-source licensed** and may not be redistributed unless you have written permission. See [LICENSE](./LICENSE).
 
-OpenCode is the primary supported provider. Other providers remain preview/manual only. The dashboard is read-only/copy-only; provider config writes require explicit CLI confirmation.
+OpenCode is the primary supported provider. Other providers remain preview/manual only. Provider config writes require explicit CLI confirmation.
 
 ## Requirements
 
@@ -162,19 +162,20 @@ vgx setup apply --yes
 
 - Preview, status, and plan commands are read-only.
 - Provider config writes require explicit `--yes` confirmation.
-- The dashboard is read-only/copy-only; run copied commands outside the TUI when you choose to act.
+- Setup/status TUI surfaces are preview-oriented; run copied commands explicitly when you choose to act.
 - SDD artifacts are SQLite-backed through VGXNESS services. Do not create or write `openspec/`.
 - `vgx sdd accept-artifact` records explicit human-only acceptance; saving a draft never implies acceptance.
 - OpenCode is the primary supported provider; other providers are preview/manual extension points.
 
-## Dashboard entrypoint
+## Main menu entrypoint
 
-Run `vgx` or `vgxness` with no arguments in an interactive terminal to open the operational dashboard. `vgx dashboard interactive` opens the same read-only/copy-only surface. In non-TTY shells, no-args prints static safe guidance and exits 0 without reading dashboard status or inferring project state.
+Run `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.
 
-For scripts, use the read-only status renderer with an explicit project:
+For scripts, use explicit read-only commands with an explicit project:
 
 ```bash
-vgx dashboard status --project <name>
+vgx setup status --project <name>
+vgx 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:

package/dist/cli/cli-help.js

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

package/dist/cli/commands/index.js

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

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

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

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

@@ -1,5 +1,4 @@
 import { resolve } from 'node:path';
-import React from 'react';
 import { AgentRegistryService } from '../../agents/agent-registry-service.js';
 import { resolveAgentProfileModel } from '../../agents/profile-model-routing.js';
 import { installOpenCodeMcpClient } from '../../mcp/client-install-opencode.js';
@@ -14,8 +13,6 @@ import { okText, usageFailure, validationFailure } from '../cli-help.js';
 import { jsonResult, openCliDatabase, resultFailure } from '../cli-helpers.js';
 import { renderSetupPlan } from '../setup-plan-renderer.js';
 import { renderSetupStatus } from '../setup-status-renderer.js';
-import { renderInkApp } from '../tui/render-ink-app.js';
-import { SetupTuiApp } from '../tui/setup/setup-tui-app.js';
 import { createDefaultSetupTuiServices } from '../tui/setup/setup-tui-services.js';
 import { canRunInteractiveTui } from '../tui/terminal-capabilities.js';
 function renderSetupRollbackApply(result, parsed) {
@@ -361,7 +358,13 @@ export async function runSetupTuiCommand(environment, input) {
         },
     };
     try {
-        await renderInkApp(React.createElement(SetupTuiApp, { services: createDefaultSetupTuiServices({ lifecycle, cwd: environment.cwd, env: environment.env }), runtime }), { stdin: environment.stdin, stdout: environment.stdout });
+        const { renderOpenTuiSetup } = await import('../tui/opentui/setup/index.js');
+        await renderOpenTuiSetup({
+            services: createDefaultSetupTuiServices({ lifecycle, cwd: environment.cwd, env: environment.env }),
+            runtime,
+            stdin: environment.stdin,
+            stdout: environment.stdout,
+        });
         return { exitCode: 0, stdout: '', stderr: '' };
     }
     finally {

package/dist/cli/dispatcher.js

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

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

@@ -58,7 +58,7 @@ function renderFocusedProviderDetails(cards, state) {
         return [];
     const targets = focusedCard.targets.length === 0
         ? 'Targets: none'
-        : `Targets: ${focusedCard.targets.map((target) => `${target.label} (${target.kind}${target.path === undefined ? '' : `: ${target.path}`}; dashboard-write: no; no-TUI-write)`).join('; ')}`;
+        : `Targets: ${focusedCard.targets.map((target) => `${target.label} (${target.kind}${target.path === undefined ? '' : `: ${target.path}`}; TUI-write: no)`).join('; ')}`;
     const safetyLabels = setupSafetyLabels(focusedCard);
     return [
         '',

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

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

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

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

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

@@ -1,4 +1,5 @@
-import { formatTuiFooter, tuiBadges } from '../visual/index.js';
+import { tuiBadges } from '../visual/badges.js';
+import { formatTuiFooter } from '../visual/footer.js';
 import { mainMenuOptionIds } from './main-menu-state.js';
 const optionCopy = {
     setup: {
@@ -12,13 +13,6 @@ const optionCopy = {
             'Provider writes require final confirmation; OpenCode is the only automatic provider with explicit consent.',
         ],
     },
-    dashboard: {
-        label: 'Dashboard',
-        description: 'Inspect project health, runs, approvals, SDD, agents, and skills.',
-        badges: [tuiBadges.readOnly],
-        detailTitle: 'Interactive dashboard',
-        detailLines: ['Opens the existing read-only dashboard.', 'Dashboard navigation does not apply provider config or write OpenCode setup.'],
-    },
     doctor: {
         label: 'Doctor / recovery',
         description: 'See health-check and recovery commands.',

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

@@ -1,4 +1,4 @@
-import { choiceLine } from '../visual/index.js';
+import { formatBadges, tuiBadges } from '../visual/badges.js';
 import { buildMainMenuViewModel } from './main-menu-read-model.js';
 export function renderMainMenuShape(input) {
     const state = input.width === undefined ? input.state : { ...input.state, viewport: { ...input.state.viewport, width: input.width } };
@@ -27,3 +27,7 @@ function clampLine(line, width) {
         return `${line.slice(0, Math.max(0, width - phrase.length - 5)).trim()} ... ${phrase}`.trim();
     return `${line.slice(0, Math.max(0, width - 1)).trim()}…`;
 }
+function choiceLine(choice) {
+    const badges = formatBadges([...(choice.focused === true ? [tuiBadges.focused] : []), ...choice.badges]);
+    return `${choice.focused === true ? '›' : ' '} ${choice.label}${badges.length === 0 ? '' : ` ${badges}`} — ${choice.description}`;
+}

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

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

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

@@ -0,0 +1,210 @@
+import { createCliRenderer } from '@opentui/core';
+import { spawn } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ApprovalDecisionWriter, getApprovalActionsState } from '../../../../code/tui/approval-actions.js';
+import { buildSafetyReadModel, parseVgxcodeJsonl, parseVgxcodeJsonlLine } from '../../../../code/tui/runtime-events.js';
+import { parsePromptSubmission, toggleReadOnlyMode } from '../../../../code/tui/prompt-mode.js';
+import { createVgxcodeScreen } from './screen.js';
+async function main() {
+    const project = process.argv[2] ?? 'vgxness';
+    const parsedStdin = await readPipedRuntimeEvents();
+    const state = {
+        project,
+        prompt: '',
+        submittedPrompt: '',
+        events: [...parsedStdin.events],
+        errors: [...parsedStdin.errors],
+        status: parsedStdin.errors.length > 0 ? 'error' : parsedStdin.events.length > 0 ? 'completed' : 'idle',
+        source: parsedStdin.events.length > 0 || parsedStdin.errors.length > 0 ? 'stdin' : 'interactive',
+        mode: 'inspect',
+        childStdinOpen: false,
+        decisionWriter: undefined,
+    };
+    const renderer = await createCliRenderer({
+        exitOnCtrlC: true,
+        clearOnShutdown: true,
+        screenMode: 'alternate-screen',
+        consoleMode: 'disabled',
+    });
+    const render = () => {
+        const current = renderer.root.getRenderable('vgxcode-screen');
+        if (current)
+            renderer.root.remove('vgxcode-screen');
+        const safety = buildSafetyReadModel(state.events);
+        renderer.root.add(createVgxcodeScreen({
+            ...state,
+            approvalActionsEnabled: getApprovalActionsState({
+                source: state.source,
+                status: state.status,
+                mode: state.mode,
+                childStdinOpen: state.childStdinOpen,
+                pendingApprovalCount: safety.pendingApprovalCount,
+                ...(safety.latestPendingApproval === undefined ? {} : { latestPendingApproval: safety.latestPendingApproval }),
+            }).enabled,
+        }));
+        renderer.requestRender();
+    };
+    render();
+    if (state.source === 'interactive') {
+        renderer.keyInput.on('keypress', (key) => {
+            if (key.ctrl && key.name === 'c')
+                return;
+            if (state.status === 'running') {
+                if (key.name === 'a' || key.sequence === 'a')
+                    writePendingApprovalDecision(state, 'approved', render);
+                if (key.name === 'd' || key.sequence === 'd')
+                    writePendingApprovalDecision(state, 'denied', render);
+                return;
+            }
+            if (key.name === 'tab') {
+                state.mode = toggleReadOnlyMode(state.mode);
+                render();
+                return;
+            }
+            if (key.name === 'return' || key.name === 'enter') {
+                void runReadOnlyBridge(state, render);
+                return;
+            }
+            if (key.name === 'backspace' || key.name === 'delete') {
+                state.prompt = state.prompt.slice(0, -1);
+                render();
+                return;
+            }
+            const text = printableKeyText(key.sequence);
+            if (text !== '') {
+                state.prompt += text;
+                render();
+            }
+        });
+    }
+}
+async function readPipedRuntimeEvents() {
+    if (process.stdin.isTTY)
+        return { events: [], errors: [] };
+    let input = '';
+    for await (const chunk of process.stdin)
+        input += String(chunk);
+    return parseVgxcodeJsonl(input);
+}
+async function runReadOnlyBridge(state, render) {
+    const submission = parsePromptSubmission(state.prompt, state.mode);
+    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.'];
+        render();
+        return;
+    }
+    state.mode = submission.mode;
+    state.submittedPrompt = prompt;
+    state.prompt = '';
+    state.status = 'running';
+    state.errors = [];
+    state.events = [];
+    state.childStdinOpen = false;
+    state.decisionWriter = undefined;
+    render();
+    const root = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../..');
+    const approvalCapableCraft = state.mode === 'craft';
+    const child = spawn('npm', commandArgsForMode(state.mode, prompt), {
+        cwd: root,
+        stdio: approvalCapableCraft ? ['pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
+        env: process.env,
+    });
+    state.childStdinOpen = approvalCapableCraft && child.stdin !== null;
+    state.decisionWriter = approvalCapableCraft && child.stdin !== null ? new ApprovalDecisionWriter(child.stdin) : undefined;
+    if (child.stdout === null || child.stderr === null) {
+        state.status = 'error';
+        state.childStdinOpen = false;
+        state.decisionWriter = undefined;
+        state.errors.push('Failed to start root CLI with JSONL output streams.');
+        render();
+        return;
+    }
+    child.stdin?.on('close', () => {
+        state.childStdinOpen = false;
+        render();
+    });
+    child.stdin?.on('error', () => {
+        state.childStdinOpen = false;
+        render();
+    });
+    let lineNumber = 0;
+    let stdoutBuffer = '';
+    let stderr = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+        stdoutBuffer += chunk;
+        const lines = stdoutBuffer.split(/\r?\n/);
+        stdoutBuffer = lines.pop() ?? '';
+        for (const line of lines) {
+            lineNumber += 1;
+            const parsed = parseVgxcodeJsonlLine(line, lineNumber);
+            if (parsed.event)
+                state.events.push(parsed.event);
+            if (parsed.error)
+                state.errors.push(parsed.error);
+        }
+        render();
+    });
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+        stderr += chunk;
+    });
+    child.on('error', (error) => {
+        state.status = 'error';
+        state.childStdinOpen = false;
+        state.errors.push(`Failed to start root CLI: ${error.message}`);
+        render();
+    });
+    child.on('close', (code, signal) => {
+        state.childStdinOpen = false;
+        state.decisionWriter = undefined;
+        if (stdoutBuffer.trim() !== '') {
+            lineNumber += 1;
+            const parsed = parseVgxcodeJsonlLine(stdoutBuffer, lineNumber);
+            if (parsed.event)
+                state.events.push(parsed.event);
+            if (parsed.error)
+                state.errors.push(parsed.error);
+        }
+        state.status = state.errors.length > 0 ? 'error' : 'completed';
+        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}`);
+        }
+        render();
+    });
+}
+function commandArgsForMode(mode, prompt) {
+    const args = ['run', '--silent', 'cli', '--', 'code', mode, prompt, '--events-jsonl'];
+    if (mode === 'craft')
+        args.push('--approval-channel', 'stdio');
+    return args;
+}
+function writePendingApprovalDecision(state, status, render) {
+    const model = buildSafetyReadModel(state.events);
+    const actions = getApprovalActionsState({
+        source: state.source,
+        status: state.status,
+        mode: state.mode,
+        childStdinOpen: state.childStdinOpen,
+        pendingApprovalCount: model.pendingApprovalCount,
+        ...(model.latestPendingApproval === undefined ? {} : { latestPendingApproval: model.latestPendingApproval }),
+    });
+    if (!actions.enabled)
+        return;
+    const wrote = state.decisionWriter?.write(actions.approval, status, status === 'approved' ? 'Approved from vgxcode.' : 'Denied from vgxcode.') ?? false;
+    if (!wrote)
+        return;
+    render();
+}
+function printableKeyText(sequence) {
+    if (sequence.length !== 1)
+        return '';
+    const code = sequence.charCodeAt(0);
+    return code >= 32 && code !== 127 ? sequence : '';
+}
+await main();