vgxness 0.1.0

package/dist/cli/dashboard-screen-renderers.js

@@ -0,0 +1,332 @@
+import { renderSetupStatus } from './setup-status-renderer.js';
+import { canonicalSddPhasePresence, classifyAgentsSkills, classifyDoctor, classifyProjectScoped, classifySdd, classifySetupForProject, copyOnly, isSetupReady } from './dashboard-tui-read-model.js';
+import { dashboardScreens } from './dashboard-tui-state.js';
+import { renderSetupWizard } from './setup-wizard-renderer.js';
+import { joinSections, normalizeRenderWidth, renderFooterGroups, renderPanel, renderTabRow, styleFocusedRow } from './tui-render-helpers.js';
+const screenLabels = dashboardScreens;
+const menuLabelColumnWidth = Math.max(...screenLabels.map((screen) => screen.label.length));
+const menuFocusColumnWidth = '[focused]'.length;
+const menuDescriptionColumnWidth = Math.max(...screenLabels.map((screen) => menuPurpose(screen.id).length));
+export function renderDashboardFrame(state, options = {}) {
+    if (state.viewMode === 'menu') {
+        return joinSections([
+            renderDashboardHeader(state, options),
+            renderErrorsPanel(state, options),
+            renderDashboardMenuView(state, options),
+            renderDashboardFooter(state, options),
+        ]);
+    }
+    return joinSections([
+        renderDashboardHeader(state, options),
+        renderTabRow(screenLabels.map((screen) => ({ key: screen.key, label: screen.label, selected: screen.id === state.activeScreen, focused: screen.id === state.focusedScreen })), options),
+        renderErrorsPanel(state, options),
+        renderBackControl(options),
+        renderPanel(`Content · ${activeLabel(state.activeScreen)}`, renderActiveScreen(state, options).split('\n'), options),
+        renderDashboardFooter(state, options),
+    ]);
+}
+function renderDashboardHeader(state, options) {
+    if (state.viewMode === 'menu') {
+        return renderPanel('Header', [
+            'VGXNESS Interactive Dashboard',
+            `Project: ${state.project ?? 'none'} · Change: ${state.change ?? 'none'}`,
+        ], options);
+    }
+    return renderPanel('Header', [
+        'VGXNESS Interactive Dashboard',
+        `Context: Project: ${state.project ?? 'none'} · Change: ${state.change ?? 'none'} · View: ${state.viewMode} · Screen: ${activeLabel(state.activeScreen)} · Menu focus: ${activeLabel(state.focusedScreen)}`,
+        `Menu order: ${screenLabels.map((screen) => screen.label).join(', ')}`,
+    ], options);
+}
+function renderDashboardMenuView(state, options) {
+    return renderPanel('Menu', [
+        'Choose a section to open:',
+        ...screenLabels.map((screen) => renderMenuRow(screen, screen.id === state.focusedScreen, options)),
+    ], options);
+}
+function renderMenuRow(screen, focused, options) {
+    const marker = focused ? '›' : ' ';
+    const label = screen.label.padEnd(menuLabelColumnWidth);
+    const focusMarker = (focused ? '[focused]' : '').padEnd(menuFocusColumnWidth);
+    const description = menuPurpose(screen.id).padEnd(menuDescriptionColumnWidth);
+    const row = `${marker} [${screen.key}] ${label}  ${focusMarker}  ${description}`;
+    return focused ? styleFocusedRow(row, options) : row;
+}
+function menuPurpose(id) {
+    if (id === 'setup')
+        return 'Setup readiness';
+    if (id === 'workflows')
+        return 'Workflow previews';
+    if (id === 'runs')
+        return 'Run status';
+    if (id === 'approvals')
+        return 'Approval queue';
+    if (id === 'agents')
+        return 'Agents and skills';
+    if (id === 'sdd')
+        return 'Artifact status';
+    if (id === 'doctor')
+        return 'Diagnostics';
+    return 'Workspace context';
+}
+function renderBackControl(options) {
+    return renderPanel('Back', ['[ b / Esc ] Back to menu', 'Direct shortcuts 1-8 open another section.'], options);
+}
+function renderErrorsPanel(state, options) {
+    const errors = [state.error === undefined ? undefined : `Error: ${state.error}`].filter((value) => value !== undefined);
+    if (errors.length === 0)
+        return undefined;
+    return renderPanel('Recovery', [...errors, 'Recovery: press r to refresh.'], { ...options, status: 'error' });
+}
+function renderDashboardFooter(state, options) {
+    const modeGroups = state.viewMode === 'menu'
+        ? [
+            { label: 'Menu', items: ['↑/↓ or j/k move', 'Enter open', '1-8 open'] },
+        ]
+        : [
+            { label: 'Section', items: ['b/Esc back', '1-8 open', 'j/k or ↑/↓ move'] },
+        ];
+    return renderPanel('Footer/help', [
+        ...renderFooterGroups([
+            ...modeGroups,
+            ...(state.viewMode === 'screen' && state.activeScreen === 'setup' ? [{ label: 'Setup wizard', items: ['n next step', 'Space toggle', 'd details'] }] : []),
+            { label: 'Global', items: ['r refresh', '? help', 'q quit'] },
+        ], options),
+        'Safety: read-only TUI; provider/apply/install stay external-only.',
+    ], options);
+}
+function renderActiveScreen(state, options) {
+    if (state.activeScreen === 'setup')
+        return renderSetupScreen(state, options);
+    if (state.activeScreen === 'workflows')
+        return renderWorkflowsScreen(state);
+    if (state.activeScreen === 'runs')
+        return renderRunsScreen(state);
+    if (state.activeScreen === 'approvals')
+        return renderApprovalsScreen(state);
+    if (state.activeScreen === 'agents')
+        return renderAgentsScreen(state);
+    if (state.activeScreen === 'sdd')
+        return renderSddScreen(state);
+    if (state.activeScreen === 'doctor')
+        return renderDoctorScreen(state);
+    return renderSettingsScreen(state);
+}
+function renderSetupScreen(state, options) {
+    const nestedOptions = { ...options, width: Math.max(40, normalizeRenderWidth(options.width) - 4) };
+    const status = classifySetupForProject(state.project, state.setup, state.sectionErrors.setup);
+    if (status === 'ready-without-project')
+        return ['Setup', 'State: ready-without-project', 'Environment and provider setup can continue without a selected project; project-scoped checks are deferred.', renderSetupWizard(state.setupWizardReadModel, state.setupWizard, nestedOptions), copyOnly('Preview setup', 'npm run cli -- mcp setup --provider opencode --preview')].join('\n');
+    if (status === 'loading')
+        return ['Setup', 'State: loading', 'Checking setup status from the shared setup lifecycle.', renderSetupWizard(state.setupWizardReadModel, state.setupWizard, nestedOptions), copyOnly('Preview setup', 'npm run cli -- mcp setup --provider opencode --preview')].join('\n');
+    if (status === 'error')
+        return ['Setup', 'State: error', `Setup status unavailable: ${state.sectionErrors.setup ?? state.error ?? 'unknown error'}`, renderSetupWizard(state.setupWizardReadModel, state.setupWizard, nestedOptions), copyOnly('Inspect setup status', 'npm run cli -- setup status')].join('\n');
+    if (state.setup === undefined)
+        return ['Setup', 'State: empty', 'No setup status data is available yet.', renderSetupWizard(state.setupWizardReadModel, state.setupWizard, nestedOptions), copyOnly('Inspect setup status', 'npm run cli -- setup status')].join('\n');
+    const setupReady = isSetupReady(state.setup);
+    return [
+        'Setup',
+        `State: ${setupReady ? 'ready' : 'blocked'}`,
+        `Next action: ${setupReady ? 'Continue to Runs with key 3.' : state.setup.nextAction.reason}`,
+        renderSetupWizard(state.setupWizardReadModel, state.setupWizard, nestedOptions),
+        'Readiness checklist',
+        checklist('Project store', state.setup.store.status, state.setup.store.blocker),
+        checklist('Default manager/profile', state.setup.defaults.status, state.setup.defaults.blocker),
+        checklist('MCP visibility/setup', state.setup.mcp.status, state.setup.mcp.nextAction),
+        checklist('Doctor guidance', setupReady ? 'ready' : 'unknown', setupReady ? undefined : 'Run diagnostics outside the TUI.'),
+        renderSetupStatus(state.setup),
+        'PRD install flow: choose AI tool integration, preview MCP setup, configure memory/profile through CLI, run doctor outside TUI, then press r to refresh.',
+        copyOnly('Preview setup', 'npm run cli -- mcp setup --provider opencode --preview'),
+        copyOnly('Plan install', 'npm run cli -- mcp install opencode --plan'),
+        copyOnly('Apply install explicitly', 'npm run cli -- mcp install opencode --yes'),
+        copyOnly('Run doctor', 'npm run cli -- mcp doctor opencode'),
+    ].join('\n');
+}
+function renderWorkflowsScreen(state) {
+    const status = classifyProjectScoped(state.project, state.project === undefined ? undefined : state.workflows === undefined || state.workflows.items.length === 0 ? 'empty' : 'ready', state.sectionErrors.workflows);
+    const lines = ['Workflows', `State: ${status}`];
+    if (status === 'project-required')
+        lines.push('Select or pass --project to inspect workflow guidance for a project.');
+    else if (state.workflows?.errorState !== undefined)
+        lines.push(`Error: ${state.workflows.errorState.message}`, ...renderCopyActions(state.workflows.errorState.nextActions));
+    else if (state.workflows === undefined)
+        lines.push('Workflow registry read model is unavailable; press r to refresh.', copyOnly('Inspect help', 'npm run cli -- --help'));
+    else if (state.workflows.items.length === 0)
+        lines.push(state.workflows.emptyState?.message ?? 'No workflows are available.', ...renderCopyActions(state.workflows.emptyState?.nextActions ?? state.workflows.copyActions));
+    else {
+        lines.push(`Source: ${state.workflows.meta.source}`, state.workflows.summary);
+        for (const workflow of state.workflows.items) {
+            lines.push(`- ${workflow.label} (${workflow.id}) [${workflow.availability}]`, `  ${workflow.description}`, `  phase=${workflow.phase} · mutability=${workflow.mutability} · safety=${workflow.safetyProfile} · sddArtifacts=${workflow.requiresSddArtifacts}`, `  inputs=${workflow.inputsSummary}`, `  lastRun=${workflow.lastKnownRun === undefined ? 'none' : `${workflow.lastKnownRun.id} [${workflow.lastKnownRun.status}] ${workflow.lastKnownRun.phase} updated ${workflow.lastKnownRun.updatedAt}`}`, ...renderCopyActions(workflow.nextActions).map((line) => `  ${line}`));
+        }
+    }
+    return lines.join('\n');
+}
+function renderRunsScreen(state) {
+    if (state.project === undefined)
+        return ['Runs', 'State: project-required', 'Pass --project <name> to list project runs.'].join('\n');
+    const homeError = state.sectionErrors.runs ?? state.error;
+    const status = homeError !== undefined ? state.runs.length > 0 ? 'ready' : 'error' : state.runs.length > 0 ? 'ready' : 'empty';
+    const lines = ['Runs', `State: ${status}`];
+    if (state.setup !== undefined)
+        lines.push(`Setup: ${isSetupReady(state.setup) ? 'ready' : `blocked — ${state.setup.nextAction.reason}`}`);
+    if (status === 'empty')
+        lines.push('No runs or supplied change are available yet.', copyOnly('Inspect runs', `npm run cli -- runs list --project ${state.project}`));
+    else
+        lines.push(renderRuns(state), renderSelectedRunOperationalTrace(state), renderSelectedRunInsights(state));
+    if (state.sdd !== undefined)
+        lines.push(`SDD change: ${state.sdd.change} · next ready phase: ${state.sdd.status.nextReadyPhase ?? 'none'}`);
+    lines.push(copyOnly('Inspect dashboard status', `npm run cli -- dashboard status --project ${state.project}${state.change === undefined ? '' : ` --change ${state.change}`}`));
+    return lines.filter((line) => line.length > 0).join('\n');
+}
+function renderApprovalsScreen(state) {
+    const status = classifyProjectScoped(state.project, state.project === undefined ? undefined : state.approvals === undefined || state.approvals.items.length === 0 ? 'empty' : 'ready', state.sectionErrors.approvals);
+    const lines = ['Approvals', `State: ${status}`];
+    if (status === 'project-required')
+        lines.push('Pass --project <name> to inspect approvals.');
+    else if (state.approvals?.errorState !== undefined)
+        lines.push(`Error: ${state.approvals.errorState.message}`, ...renderCopyActions(state.approvals.errorState.nextActions));
+    else if (state.approvals === undefined)
+        lines.push('Approval/preflight read model is unavailable; press r to refresh.', copyOnly('Inspect approvals', `npm run cli -- approvals list --project ${state.project ?? '<project>'}`));
+    else if (state.approvals.items.length === 0)
+        lines.push(state.approvals.emptyState?.message ?? 'No pending or recent approvals/preflights are visible.', ...renderCopyActions(state.approvals.emptyState?.nextActions ?? state.approvals.copyActions));
+    else {
+        lines.push(`Source: ${state.approvals.meta.source}`, state.approvals.summary, 'Pending items are listed before recent/resolved items.');
+        for (const item of state.approvals.items) {
+            lines.push(`- ${item.kind} ${item.id} [${item.status}] run=${item.runId ?? 'unknown'}`, `  category=${item.category} · operation=${item.operation} · risk=${item.riskFlags.join(', ') || 'none'}`, `  reason=${item.reason}`, `  agent=${item.agent ?? 'unknown'} · updated=${item.updatedAt ?? item.createdAt ?? 'unknown'}`, ...renderCopyActions(item.nextActions).map((line) => `  ${line}`));
+        }
+    }
+    return lines.join('\n');
+}
+function renderSddScreen(state) {
+    if (state.project === undefined)
+        return ['SDD', 'State: project-required', 'Pass --project <name> and optionally --change <id> to inspect SDD artifacts.'].join('\n');
+    const status = classifySdd(state.sdd, state.change, state.sectionErrors.sdd);
+    const lines = ['SDD', `State: ${status}`];
+    if (state.change === undefined) {
+        lines.push('No change supplied. Change discovery/indexing is deferred for this MVP.', copyOnly('Relaunch with a change', `npm run cli -- dashboard interactive --project ${state.project ?? '<project>'} --change <change>`));
+        return lines.join('\n');
+    }
+    lines.push(`Change: ${state.change}`);
+    lines.push(...canonicalSddPhasePresence(state.sdd).map((phase) => `${phase.present ? '[x]' : '[ ]'} ${phase.phase} — ${phase.topicKey}`));
+    if (state.sdd?.status.nextReadyPhase !== undefined)
+        lines.push(`Next ready phase: ${state.sdd.status.nextReadyPhase}`);
+    if (state.sdd?.readiness !== undefined && !state.sdd.readiness.ready)
+        lines.push(`Missing prerequisites: ${state.sdd.readiness.missingArtifactTopicKeys.join(', ') || 'none reported'}`);
+    if (state.sectionErrors.sdd !== undefined)
+        lines.push(`Readiness/status error: ${state.sectionErrors.sdd}`);
+    lines.push(copyOnly('Inspect SDD status', `npm run cli -- sdd status --project ${state.project} --change ${state.change}`));
+    lines.push(copyOnly('Continue SDD outside TUI', `npm run cli -- sdd next --project ${state.project} --change ${state.change}`));
+    return lines.join('\n');
+}
+function renderAgentsScreen(state) {
+    if (state.project === undefined)
+        return ['Agents', 'State: project-required', 'Pass --project <name> to inspect project-scoped agents and skills.'].join('\n');
+    const profileError = state.sectionErrors.agents;
+    const status = classifyAgentsSkills(state.agentsSkills, profileError);
+    const lines = ['Agents', `State: ${status}`];
+    if (state.profiles === undefined)
+        lines.push('No effective manager profile data is available.');
+    else {
+        lines.push(`Manager: ${state.profiles.managerName}`, `Scope: ${state.profiles.scope}`, `Agent: ${state.profiles.agentId ?? 'unavailable'}`, `Provider: ${state.profiles.providerAdapter ?? 'unavailable'}`, `Model: ${state.profiles.model ?? 'unavailable'}`, `Profile: ${state.profiles.profile ?? 'unavailable'}`, `Overlay: ${state.profiles.overlayPresent === true ? 'present' : 'missing'}`);
+        if (state.profiles.error !== undefined)
+            lines.push(`Partial error: ${state.profiles.error}`);
+    }
+    if (profileError !== undefined)
+        lines.push(`Profile error: ${profileError}`);
+    lines.push(copyOnly('Inspect manager profile', `npm run cli -- agents manager-profile get --project ${state.project} --scope project --manager vgxness-manager`));
+    lines.push(copyOnly('Change manager profile', `npm run cli -- agents manager-profile set --project ${state.project} --scope project --manager vgxness-manager --instructions <text>`));
+    const agents = state.agentsSkills?.agents ?? [];
+    const skills = state.agentsSkills?.skills ?? [];
+    if (agents.length === 0)
+        lines.push('Agents: none registered for this project scope.');
+    else
+        lines.push('Agents:', ...agents.map((agent) => `- ${agent.name} (${agent.id}) [${agent.mode}/${agent.scope}]${agent.providerAdapter === undefined ? '' : ` via ${agent.providerAdapter}`}${agent.model === undefined ? '' : ` ${agent.model}`} — ${truncate(agent.description ?? 'no description', 96)}`));
+    if (skills.length === 0)
+        lines.push('Skills: none registered for this project scope.');
+    else
+        lines.push('Skills:', ...skills.map((skill) => `- ${skill.name} (${skill.id}) [${skill.scope}] — ${truncate(skill.description ?? 'no description', 96)}`));
+    if (state.agentsSkills?.truncated === true)
+        lines.push('List truncated by --limit.');
+    if (profileError !== undefined)
+        lines.push(`Registry error: ${profileError}`);
+    lines.push(copyOnly('Inspect agents', `npm run cli -- agents list --project ${state.project}`));
+    lines.push(copyOnly('Inspect skills', `npm run cli -- skills list --project ${state.project}`));
+    return lines.join('\n');
+}
+function renderDoctorScreen(state) {
+    const status = state.project === undefined && state.doctor === undefined ? 'ready-without-project' : classifyDoctor(state.doctor, state.sectionErrors.doctor);
+    const lines = ['Doctor', `State: ${status}`, 'Warning: doctor commands may prepare or initialize local state; run them outside the TUI only.'];
+    if (state.doctor === undefined)
+        lines.push('No doctor report was executed by the TUI. Guidance is based on setup evidence only.');
+    else {
+        lines.push(state.doctor.summary, ...state.doctor.warnings.map((warning) => `Warning: ${warning}`), ...state.doctor.commands.map((command) => copyOnly('Doctor command', command)));
+    }
+    if (state.setup !== undefined && !isSetupReady(state.setup))
+        lines.push(`Setup blocker: ${state.setup.nextAction.reason}`);
+    if (state.sectionErrors.doctor !== undefined)
+        lines.push(`Doctor guidance error: ${state.sectionErrors.doctor}`);
+    lines.push(copyOnly('Run full doctor', 'npm run cli -- mcp doctor'));
+    lines.push(copyOnly('Run OpenCode doctor', 'npm run cli -- mcp doctor opencode'));
+    return lines.join('\n');
+}
+function renderSettingsScreen(state) {
+    return ['Settings', `State: ${state.project === undefined ? 'ready-without-project' : 'ready'}`, `Workspace: ${state.context.workspaceRoot}`, `Database: ${state.context.databasePath ?? 'default'}`, 'Safety: provider config writes are external/copy-only and require explicit confirmation.'].join('\n');
+}
+function renderRuns(state) {
+    const notice = state.navigationNotice === undefined ? [] : [`Notice: ${state.navigationNotice}`];
+    if (state.runs.length === 0)
+        return ['Latest Runs', ...notice, '- No runs found.'].join('\n');
+    return ['Latest Runs', ...notice, ...state.runs.map((run, index) => renderRun(run, index === state.selectedIndex))].join('\n');
+}
+function renderRun(run, selected) {
+    return `${selected ? '›' : ' '} ${run.id} [${run.status}] ${run.workflow}/${run.phase} — ${run.userIntent}`;
+}
+function renderSelectedRunInsights(state) {
+    const selectedRun = state.runs[state.selectedIndex];
+    if (selectedRun === undefined)
+        return '';
+    const insights = state.runInsights?.[selectedRun.id];
+    if (insights === undefined)
+        return '';
+    const lines = ['Selected Run Insights', `Debug: ${insights.debug.cause} — ${insights.debug.summary}`, `Recommended action: ${insights.debug.recommendedAction}`, `Resume plan: ${renderResumePlan(insights.resumePlan)}`];
+    if (insights.resumePlan.blockers.length > 0)
+        lines.push(`Blockers: ${insights.resumePlan.blockers.map((blocker) => `${blocker.code} — ${blocker.message}`).join('; ')}`);
+    const latestTimeline = insights.timeline.slice(-3).map((entry) => `${entry.type}: ${entry.label}`);
+    if (latestTimeline.length > 0)
+        lines.push(`Latest timeline: ${latestTimeline.join(' · ')}`);
+    return lines.join('\n');
+}
+function renderSelectedRunOperationalTrace(state) {
+    const selectedRun = state.runs[state.selectedIndex];
+    if (selectedRun === undefined)
+        return '';
+    const item = state.operationalRuns?.items.find((candidate) => candidate.runId === selectedRun.id);
+    if (item === undefined)
+        return ['Selected Run Trace', 'Trace: sin vínculo disponible'].join('\n');
+    const lines = ['Selected Run Trace', `Run: ${item.runId} [${item.status}] ${item.workflow}/${item.phase}`, `Agent/model: ${item.selectedAgentId} · ${item.model}`, `Updated: ${item.updatedAt}${item.outcome === undefined ? '' : ` · outcome=${item.outcome}`}`, `Last checkpoint: ${item.lastCheckpoint === undefined ? 'sin vínculo disponible' : `${item.lastCheckpoint.label} (${item.lastCheckpoint.id}) — ${item.lastCheckpoint.stateSummary}`}`, `Checkpoints: ${item.checkpointsSummary}`];
+    lines.push(`Approvals: ${item.relatedApprovals.length === 0 ? 'sin vínculo disponible' : item.relatedApprovals.map((approval) => `${approval.id} [${approval.status}] ${approval.category ?? 'unknown'}/${approval.operation ?? 'unknown'}`).join('; ')}`);
+    lines.push(`Preflights/attempts: ${item.relatedPreflights.length === 0 ? 'sin vínculo disponible' : item.relatedPreflights.map((attempt) => `${attempt.id} [${attempt.status}] ${attempt.category}/${attempt.operation} risk=${attempt.riskFlags.join(',') || 'none'}`).join('; ')}`);
+    if (item.blockers.length > 0)
+        lines.push(`Blockers: ${item.blockers.join('; ')}`);
+    if (item.latestTimeline.length > 0)
+        lines.push(`Latest timeline: ${item.latestTimeline.join(' · ')}`);
+    lines.push(...renderCopyActions(item.nextActions));
+    return lines.join('\n');
+}
+function renderCopyActions(actions) {
+    return actions.map((action) => copyOnly(action.label, action.command));
+}
+function renderResumePlan(plan) {
+    if (plan.resumable && plan.latestCheckpoint !== undefined)
+        return `manual review eligible from checkpoint ${plan.latestCheckpoint.id}`;
+    return 'blocked or unavailable';
+}
+function checklist(label, status, detail) {
+    return `${status === 'ready' ? '[x]' : '[ ]'} ${label} — ${status}${detail === undefined ? '' : ` — ${detail}`}`;
+}
+function activeLabel(id) {
+    return screenLabels.find((screen) => screen.id === id)?.label ?? id;
+}
+function truncate(value, limit) {
+    return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 1))}…`;
+}

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

@@ -0,0 +1,71 @@
+import { sddPhases } from '../sdd/schema.js';
+export function sanitizeDashboardError(error) {
+    const message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unavailable';
+    return message.replace(/\s+/g, ' ').trim().slice(0, 180) || 'Unavailable';
+}
+export function isSetupReady(setup) {
+    return setup?.store.status === 'ready' && setup.verification.status === 'ready' && setup.agents.deferred !== true && setup.defaults.status === 'ready';
+}
+export function classifySetup(setup, error) {
+    if (error !== undefined)
+        return 'error';
+    if (setup === undefined)
+        return 'loading';
+    return isSetupReady(setup) ? 'ready' : 'blocked';
+}
+export function classifySetupForProject(project, setup, error) {
+    if (project === undefined && error === undefined && setup === undefined)
+        return 'ready-without-project';
+    if (project === undefined && error === undefined && setup !== undefined)
+        return setup.store.status === 'ready' ? 'ready-without-project' : 'blocked';
+    return classifySetup(setup, error);
+}
+export function classifySdd(sdd, change, error) {
+    if (error !== undefined)
+        return sdd === undefined ? 'error' : 'blocked';
+    if (change === undefined)
+        return 'empty';
+    if (sdd === undefined || sdd.status.phases.every((phase) => !phase.present))
+        return 'empty';
+    if (sdd.readiness !== undefined && !sdd.readiness.ready)
+        return 'blocked';
+    return 'ready';
+}
+export function classifyProjectScoped(project, status, error) {
+    if (error !== undefined)
+        return 'error';
+    if (project === undefined)
+        return 'project-required';
+    return status ?? 'empty';
+}
+export function createNoProjectDashboardSections() {
+    return {
+        setup: 'ready-without-project',
+        workflows: 'project-required',
+        runs: 'project-required',
+        approvals: 'project-required',
+        agents: 'project-required',
+        sdd: 'project-required',
+        doctor: 'ready-without-project',
+        settings: 'ready-without-project',
+    };
+}
+export function classifyAgentsSkills(agentsSkills, error) {
+    if (error !== undefined)
+        return agentsSkills === undefined ? 'error' : agentsSkills.status;
+    return agentsSkills?.status ?? 'empty';
+}
+export function classifyDoctor(doctor, error) {
+    if (error !== undefined)
+        return doctor === undefined ? 'error' : doctor.status;
+    return doctor?.status ?? 'empty';
+}
+export function canonicalSddPhasePresence(sdd) {
+    return sddPhases.map((phase) => {
+        const status = sdd?.status.phases.find((item) => item.phase === phase);
+        return { phase, present: status?.present ?? false, topicKey: status?.topicKey ?? `sdd/${sdd?.change ?? '<change>'}/${phase}` };
+    });
+}
+export function copyOnly(label, command) {
+    return `${label} (copy-only, Run outside TUI): ${command}`;
+}

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

@@ -0,0 +1,218 @@
+import { classifySetup } from './dashboard-tui-read-model.js';
+import { buildSetupWizardReadModel } from './setup-wizard-read-model.js';
+import { createSetupWizardState, reduceSetupWizardKey, setupWizardKeyFromInput } from './setup-wizard-state.js';
+export const dashboardScreens = [
+    { id: 'setup', key: '1', label: 'Setup' },
+    { id: 'workflows', key: '2', label: 'Workflows' },
+    { id: 'runs', key: '3', label: 'Runs' },
+    { id: 'approvals', key: '4', label: 'Approvals' },
+    { id: 'agents', key: '5', label: 'Agents' },
+    { id: 'sdd', key: '6', label: 'SDD' },
+    { id: 'doctor', key: '7', label: 'Doctor' },
+    { id: 'settings', key: '8', label: 'Settings' },
+];
+export function createDashboardState(input) {
+    void input.setupOnboardingDismissed;
+    const sectionErrors = input.sectionErrors ?? {};
+    const activeScreen = input.activeScreen ?? initialDashboardScreen(input.setup, sectionErrors.setup);
+    const focusedScreen = input.focusedScreen ?? activeScreen;
+    const project = input.project ?? input.context?.project;
+    const change = input.change ?? input.context?.change;
+    const databasePath = input.databasePath ?? input.context?.databasePath;
+    const context = {
+        workspaceRoot: input.workspaceRoot ?? input.context?.workspaceRoot ?? process.cwd(),
+        ...(project === undefined ? {} : { project }),
+        ...(change === undefined ? {} : { change }),
+        ...(databasePath === undefined ? {} : { databasePath }),
+    };
+    const state = {
+        context,
+        ...(project === undefined ? {} : { project }),
+        activeScreen,
+        focusedScreen,
+        viewMode: input.viewMode ?? 'menu',
+        runs: input.runs,
+        selectedIndex: clampSelection(input.selectedIndex ?? 0, input.runs),
+        shouldExit: input.shouldExit ?? false,
+        helpVisible: false,
+        setupWizard: input.setupWizard ?? createSetupWizardState({ projectMode: project === undefined ? 'none' : 'current', ...(project === undefined ? {} : { selectedProject: project }) }),
+        sectionErrors,
+    };
+    if (change !== undefined)
+        state.change = change;
+    if (input.sdd !== undefined)
+        state.sdd = input.sdd;
+    if (input.setup !== undefined)
+        state.setup = input.setup;
+    if (input.setupWizardReadModel !== undefined)
+        state.setupWizardReadModel = input.setupWizardReadModel;
+    else if (input.setup !== undefined)
+        state.setupWizardReadModel = buildSetupWizardReadModel(input.setup);
+    if (input.profiles !== undefined)
+        state.profiles = input.profiles;
+    if (input.agentsSkills !== undefined)
+        state.agentsSkills = input.agentsSkills;
+    if (input.workflows !== undefined)
+        state.workflows = input.workflows;
+    if (input.operationalRuns !== undefined)
+        state.operationalRuns = input.operationalRuns;
+    if (input.approvals !== undefined)
+        state.approvals = input.approvals;
+    if (input.doctor !== undefined)
+        state.doctor = input.doctor;
+    if (input.runInsights !== undefined)
+        state.runInsights = input.runInsights;
+    if (input.navigationNotice !== undefined)
+        state.navigationNotice = input.navigationNotice;
+    if (input.error !== undefined)
+        state.error = input.error;
+    return state;
+}
+export function initialDashboardScreen(setup, setupError) {
+    return classifySetup(setup, setupError) === 'ready' || setupError !== undefined ? 'runs' : 'setup';
+}
+export function reduceDashboardKey(state, key) {
+    const screen = screenForKey(key);
+    if (screen !== undefined) {
+        const { navigationNotice: _navigationNotice, ...rest } = state;
+        return { ...rest, viewMode: 'screen', activeScreen: screen, focusedScreen: screen };
+    }
+    if (key === 'menu-back')
+        return state.viewMode === 'screen' ? { ...state, viewMode: 'menu' } : state;
+    if (key === 'menu-left')
+        return moveMenuFocus(state, -1);
+    if (key === 'menu-right')
+        return moveMenuFocus(state, 1);
+    if (key === 'menu-open') {
+        const { navigationNotice: _navigationNotice, ...rest } = state;
+        return { ...rest, viewMode: 'screen', activeScreen: state.focusedScreen };
+    }
+    if (isSetupKey(key) && state.viewMode === 'screen' && state.activeScreen === 'setup')
+        return { ...state, setupWizard: reduceSetupWizardKey(state.setupWizard, toSetupWizardKey(key)) };
+    if (key === 'up')
+        return state.viewMode === 'menu' ? moveMenuFocus(state, -1) : state.activeScreen === 'runs' ? navigateRuns(state, -1) : state.activeScreen === 'setup' ? { ...state, setupWizard: reduceSetupWizardKey(state.setupWizard, 'up') } : state;
+    if (key === 'down')
+        return state.viewMode === 'menu' ? moveMenuFocus(state, 1) : state.activeScreen === 'runs' ? navigateRuns(state, 1) : state.activeScreen === 'setup' ? { ...state, setupWizard: reduceSetupWizardKey(state.setupWizard, 'down') } : state;
+    if (key === 'help')
+        return { ...state, helpVisible: !state.helpVisible };
+    if (key === 'quit')
+        return { ...state, shouldExit: true };
+    return state;
+}
+export function dashboardKeyFromInput(input) {
+    if (input === '1')
+        return 'screen-setup';
+    if (input === '2')
+        return 'screen-workflows';
+    if (input === '3')
+        return 'screen-runs';
+    if (input === '4')
+        return 'screen-approvals';
+    if (input === '5')
+        return 'screen-agents';
+    if (input === '6')
+        return 'screen-sdd';
+    if (input === '7')
+        return 'screen-doctor';
+    if (input === '8')
+        return 'screen-settings';
+    if (input === '' || input === 'h')
+        return 'menu-left';
+    if (input === '' || input === 'l')
+        return 'menu-right';
+    if (input === '\r' || input === '\n')
+        return 'menu-open';
+    if (input === 'b' || input === '\u001B')
+        return 'menu-back';
+    if (input === 'd')
+        return 'setup-details';
+    if (input === '?')
+        return 'help';
+    const setupKey = setupWizardKeyFromInput(input);
+    if (setupKey === 'next')
+        return 'setup-next';
+    if (setupKey === 'back')
+        return 'setup-back';
+    if (setupKey === 'toggle')
+        return 'setup-toggle';
+    if (setupKey === 'details')
+        return 'setup-details';
+    if (setupKey === 'escape')
+        return 'setup-escape';
+    if (input === 'k' || input === '\u001B[A')
+        return 'up';
+    if (input === 'j' || input === '\u001B[B')
+        return 'down';
+    if (input === 'r')
+        return 'refresh';
+    if (input === 'q' || input === '\u0003')
+        return 'quit';
+    return undefined;
+}
+export function refreshDashboardState(previous, loaded) {
+    return createDashboardState({
+        ...(previous.project === undefined ? {} : { project: previous.project }),
+        context: previous.context,
+        ...(previous.change === undefined ? {} : { change: previous.change }),
+        ...loaded,
+        activeScreen: previous.activeScreen,
+        focusedScreen: previous.focusedScreen,
+        viewMode: previous.viewMode,
+        selectedIndex: previous.selectedIndex,
+        shouldExit: previous.shouldExit,
+        setupWizard: previous.setupWizard,
+    });
+}
+function moveMenuFocus(state, delta) {
+    const currentIndex = Math.max(0, dashboardScreens.findIndex((screen) => screen.id === state.focusedScreen));
+    const nextIndex = (currentIndex + delta + dashboardScreens.length) % dashboardScreens.length;
+    const focusedScreen = dashboardScreens[nextIndex]?.id ?? state.focusedScreen;
+    return focusedScreen === state.focusedScreen ? state : { ...state, focusedScreen };
+}
+function screenForKey(key) {
+    if (key === 'screen-setup')
+        return 'setup';
+    if (key === 'screen-workflows')
+        return 'workflows';
+    if (key === 'screen-runs')
+        return 'runs';
+    if (key === 'screen-approvals')
+        return 'approvals';
+    if (key === 'screen-agents')
+        return 'agents';
+    if (key === 'screen-sdd')
+        return 'sdd';
+    if (key === 'screen-doctor')
+        return 'doctor';
+    if (key === 'screen-settings')
+        return 'settings';
+    return undefined;
+}
+function isSetupKey(key) {
+    return key.startsWith('setup-');
+}
+function toSetupWizardKey(key) {
+    if (key === 'setup-next')
+        return 'next';
+    if (key === 'setup-back')
+        return 'back';
+    if (key === 'setup-toggle')
+        return 'toggle';
+    if (key === 'setup-details')
+        return 'details';
+    return 'escape';
+}
+function clampSelection(selectedIndex, runs) {
+    if (runs.length === 0)
+        return 0;
+    return Math.max(0, Math.min(selectedIndex, runs.length - 1));
+}
+function navigateRuns(state, delta) {
+    if (state.runs.length === 0)
+        return { ...state, selectedIndex: 0, navigationNotice: 'No runs are available to select yet.' };
+    if (state.runs.length === 1)
+        return { ...state, selectedIndex: 0, navigationNotice: 'Only one run is available; selection stayed on the only run.' };
+    const selectedIndex = clampSelection(state.selectedIndex + delta, state.runs);
+    const { navigationNotice: _navigationNotice, ...rest } = state;
+    return { ...rest, selectedIndex };
+}