vgxness 1.2.0 → 1.3.0

package/dist/cli/dashboard-operational-read-models.js

@@ -1,428 +0,0 @@
-import { redactedPlaceholder, redactJsonValue } from '../export/redaction.js';
-import { defaultPermissionPolicy } from '../permissions/policy-evaluator.js';
-import { verificationChangeTypeList } from '../verification/index.js';
-import { listWorkflows } from '../workflows/workflow-registry.js';
-import { isSetupReady } from './dashboard-tui-read-model.js';
-const noLink = 'no link available';
-const verificationPlanCommand = 'npm run cli -- verification plan --type <change-type>';
-const verificationPlanCopyActionLabel = 'Copy verification plan command';
-const verificationReportCopyActionLabel = 'Copy verification report get command';
-export function dashboardCopyAction(label, command, safety = 'read-only') {
-    return { label, command, safety, copyOnly: true, executesInTui: false };
-}
-export function verificationPlanGuidanceDetail() {
-    return [
-        'Verification plan guidance: read-only recommendations/manual guidance for a user-selected change type.',
-        `Copy placeholder command: ${verificationPlanCommand}`,
-        `Supported change types: ${verificationChangeTypeList}`,
-        'Choose the change type explicitly; the dashboard does not infer, rank, prefill, or recommend one from SDD or repository state.',
-        'Plans are not verification status, proof, run evidence, checkpoints, SDD readiness, or acceptance.',
-    ];
-}
-function verificationPlanCopyAction() {
-    return dashboardCopyAction(verificationPlanCopyActionLabel, verificationPlanCommand);
-}
-export function verificationReportCommand(project, change) {
-    return `npm run cli -- verification report get --project ${project} --change ${change}`;
-}
-export function verificationReportMetadataDetail(sdd) {
-    const fallbackTopicKey = `sdd/${sdd.change}/verify`;
-    const cockpitVerify = sdd.cockpit?.phases.find((phase) => phase.phase === 'verify');
-    const statusVerify = sdd.status.phases.find((phase) => phase.phase === 'verify');
-    const verify = cockpitVerify ?? statusVerify;
-    const present = verify?.present === true;
-    const topicKey = verify?.topicKey ?? fallbackTopicKey;
-    if (!present)
-        return `Verification report artifact: not present · topicKey=${topicKey}`;
-    const state = verify?.state ?? 'present';
-    const accepted = verify?.accepted === true ? 'yes' : 'no';
-    const artifactId = cockpitVerify?.artifact?.artifactId ?? statusVerify?.artifactId ?? 'unavailable';
-    return `Verification report artifact: present · state=${state} · accepted=${accepted} · topicKey=${topicKey} · artifactId=${artifactId}`;
-}
-function verificationReportCopyAction(project, change) {
-    return dashboardCopyAction(verificationReportCopyActionLabel, verificationReportCommand(project, change));
-}
-export function dashboardSafety() {
-    return {
-        readOnly: true,
-        copyOnly: true,
-        providerWrites: false,
-        providerExecution: false,
-        modifiesDotOpencode: false,
-        modifiesDotClaude: false,
-        modifiesOpenSpec: false,
-        executesWorkflow: false,
-        executesDoctor: false,
-    };
-}
-export function buildDashboardWorkflowsReadModel(input = {}) {
-    const project = input.project ?? '<project>';
-    const workflows = listWorkflows();
-    const items = workflows.map((workflow) => {
-        const lastKnownRun = (input.runs ?? []).filter((run) => run.workflow === workflow.id).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
-        return {
-            id: workflow.id,
-            label: workflow.title,
-            description: workflow.description,
-            phase: workflow.defaultPhase,
-            mutability: workflow.mutability,
-            safetyProfile: workflow.safetyProfile,
-            requiresSddArtifacts: workflow.requiresSddArtifacts,
-            availability: 'available',
-            inputsSummary: workflow.id === 'sdd'
-                ? '--project and --change for SDD status; --intent for explicit preview outside TUI'
-                : '--project and --intent for explicit preview outside TUI',
-            sourceRef: 'src/workflows/workflow-registry.ts',
-            ...(lastKnownRun === undefined
-                ? {}
-                : { lastKnownRun: { id: lastKnownRun.id, status: lastKnownRun.status, phase: lastKnownRun.phase, updatedAt: lastKnownRun.updatedAt } }),
-            nextActions: [
-                dashboardCopyAction('Preview workflow metadata', `npm run cli -- ${workflow.id} preview --project ${project} --intent <intent>`),
-                dashboardCopyAction('Inspect workflow runs', `npm run cli -- runs list --project ${project}`),
-            ],
-        };
-    });
-    return {
-        meta: meta('workflows', 'Workflows', 'workflow registry', input.generatedAt),
-        summary: `${items.length} workflow(s) from registry; actions are copy-only and not executed by the TUI.`,
-        items,
-        ...(items.length === 0
-            ? {
-                emptyState: {
-                    message: 'No workflows are registered in the workflow registry.',
-                    nextActions: [dashboardCopyAction('Inspect help', 'npm run cli -- --help')],
-                },
-            }
-            : {}),
-        copyActions: [dashboardCopyAction('Inspect CLI help', 'npm run cli -- --help')],
-    };
-}
-export function buildDashboardRunsReadModel(input) {
-    const items = input.runs.map((run) => buildRunTraceItem(run, input.detailsByRunId?.[run.id], input.insightsByRunId?.[run.id]));
-    const project = input.project ?? '<project>';
-    return {
-        meta: meta('runs', 'Runs', 'run records, details, checkpoints, approvals, operation attempts', input.generatedAt),
-        summary: `${items.length} visible run(s); ${items.reduce((count, item) => count + item.relatedApprovals.length, 0)} approval(s); ${items.reduce((count, item) => count + item.relatedPreflights.length, 0)} preflight/attempt(s).`,
-        items,
-        ...(items.length === 0
-            ? {
-                emptyState: {
-                    message: 'No runs are registered or visible for this project.',
-                    nextActions: [dashboardCopyAction('Inspect runs', `npm run cli -- runs list --project ${project}`)],
-                },
-            }
-            : {}),
-        copyActions: [dashboardCopyAction('Inspect runs', `npm run cli -- runs list --project ${project}`)],
-    };
-}
-export function buildDashboardApprovalsReadModel(input) {
-    const items = input.runs.flatMap((run) => approvalItemsForRun(run, input.detailsByRunId?.[run.id]));
-    items.sort((a, b) => (a.status === 'pending' ? 0 : 1) - (b.status === 'pending' ? 0 : 1) || (b.createdAt ?? '').localeCompare(a.createdAt ?? ''));
-    const project = input.project ?? '<project>';
-    return {
-        meta: meta('approvals', 'Approvals', 'run approvals and operation attempts', input.generatedAt),
-        summary: `${items.filter((item) => item.status === 'pending').length} pending; ${items.length} pending/recent approval or preflight item(s).`,
-        items,
-        ...(items.length === 0
-            ? {
-                emptyState: {
-                    message: 'No pending or recent approvals/preflights are visible for this project.',
-                    nextActions: [dashboardCopyAction('Inspect approvals', `npm run cli -- approvals list --project ${project}`)],
-                },
-            }
-            : {}),
-        copyActions: [dashboardCopyAction('Inspect approvals', `npm run cli -- approvals list --project ${project}`)],
-    };
-}
-export function buildDashboardInstallationReadModel(input) {
-    const project = input.project ?? '<project>';
-    const ready = isSetupReady(input.setup);
-    return {
-        meta: meta('installation', 'Installation', 'setup lifecycle, provider status, doctor, change-plan preview', input.generatedAt),
-        lifecycle: {
-            status: input.setup === undefined ? 'loading' : ready ? 'ready' : 'blocked',
-            summary: input.setup?.verification.summary ?? 'Setup lifecycle evidence is unavailable.',
-            ...(input.setup?.nextAction.reason === undefined ? {} : { nextAction: input.setup.nextAction.reason }),
-        },
-        setupPlan: {
-            status: 'ready',
-            summary: 'Preview-only setup guidance; writes remain in vgx init final confirmation or explicit CLI commands.',
-            previewCommands: [
-                dashboardCopyAction('Preview OpenCode setup', 'npm run cli -- mcp setup --provider opencode --preview'),
-                dashboardCopyAction('Preview OpenCode install plan', 'npm run cli -- mcp install opencode --plan'),
-            ],
-        },
-        ...(input.providerStatus === undefined ? {} : { providerStatus: input.providerStatus }),
-        ...(input.providerDoctor === undefined ? {} : { providerDoctor: input.providerDoctor }),
-        ...(input.providerChangePlan === undefined ? {} : { providerChangePlan: input.providerChangePlan }),
-        copyActions: [
-            dashboardCopyAction('Inspect dashboard status', `npm run cli -- dashboard status --project ${project}`),
-            dashboardCopyAction('Open write-capable setup TUI', 'npm run cli -- init', 'manual-review'),
-        ],
-    };
-}
-export function buildDashboardManagementReadModels(input) {
-    const project = input.project ?? '<project>';
-    const generatedAt = input.generatedAt;
-    const agents = input.agentsSkills?.agents.map((agent) => ({
-        id: agent.id,
-        title: agent.name,
-        status: agent.mode,
-        summary: agent.description ?? 'No description',
-        detail: [`Scope: ${agent.scope}`, `Provider: ${agent.providerAdapter ?? 'unavailable'}`, `Model: ${agent.model ?? 'unavailable'}`],
-        copyActions: [dashboardCopyAction('Inspect agent', `npm run cli -- agents get --id ${agent.id}`)],
-    })) ?? [];
-    const skills = input.agentsSkills?.skills.map((skill) => ({
-        id: skill.id,
-        title: skill.name,
-        status: skill.scope,
-        summary: skill.description ?? 'No description',
-        detail: [`Scope: ${skill.scope}`, 'Skill metadata is displayed read-only.'],
-        copyActions: [dashboardCopyAction('Inspect skills', `npm run cli -- skills list --project ${project}`)],
-    })) ?? [];
-    const memory = input.memoryObservations?.map((observation) => ({
-        id: observation.id,
-        title: observation.title,
-        status: observation.type,
-        summary: observation.preview,
-        detail: [
-            `Project: ${observation.project}`,
-            `Scope/topic: ${observation.scope}${observation.topicKey === undefined ? '' : ` · ${observation.topicKey}`}`,
-            `Updated: ${observation.updatedAt}`,
-        ],
-        copyActions: [dashboardCopyAction('Inspect memory observation', `npm run cli -- memory get --id ${observation.id}`)],
-    })) ?? [];
-    const policy = input.permissionPolicy ?? defaultPermissionPolicy;
-    const permissions = policy.rules.map((rule) => ({
-        id: rule.category,
-        title: rule.category,
-        status: rule.decision,
-        summary: rule.reason ?? 'No explicit reason recorded.',
-        detail: [`Decision: ${rule.decision}`, `Reason: ${rule.reason ?? 'unspecified'}`, 'Dashboard never approves or changes permissions.'],
-        copyActions: [dashboardCopyAction('Inspect permissions', 'npm run cli -- permissions --help')],
-    }));
-    const settings = [
-        {
-            id: 'workspace-root',
-            title: 'Workspace root',
-            status: 'read-only',
-            summary: input.workspaceRoot ?? 'unknown',
-            detail: ['Filesystem paths are displayed only; dashboard does not write provider config.'],
-            copyActions: [],
-        },
-        {
-            id: 'database-path',
-            title: 'Database path',
-            status: 'read-only',
-            summary: input.databasePath ?? 'default resolution',
-            detail: ['SQLite path is informational; dashboard read models avoid memory writes.'],
-            copyActions: [],
-        },
-        {
-            id: 'provider-boundary',
-            title: 'Provider boundary',
-            status: 'copy-only',
-            summary: 'OpenCode setup writes remain in vgx init final confirmation or explicit CLI.',
-            detail: ['No provider install/write API is called by dashboard rendering or refresh.'],
-            copyActions: [dashboardCopyAction('Open guided setup explicitly', 'npm run cli -- init', 'manual-review')],
-        },
-    ];
-    return {
-        agents: management('agents', 'Agents', 'agent registry', agents, project, generatedAt),
-        skills: management('skills', 'Skills', 'skill registry', skills, project, generatedAt),
-        memory: management('memory', 'Memory', 'memory observations', memory, project, generatedAt, 'No recent memory observations are visible for this project.'),
-        sdd: management('sdd', 'SDD', 'SDD artifacts', sddRows(input.sdd, project), project, generatedAt),
-        runs: management('runs', 'Runs', 'run records', input.runs.map((run) => ({
-            id: run.id,
-            title: run.workflow,
-            status: run.status,
-            summary: `${run.phase} · ${run.userIntent}`,
-            detail: [`Agent: ${run.selectedAgentId}`, `Model: ${run.model}`, `Updated: ${run.updatedAt}`],
-            copyActions: [dashboardCopyAction('Inspect run', `npm run cli -- runs get --id ${run.id}`)],
-        })), project, generatedAt),
-        approvals: management('approvals', 'Approvals', 'approvals/preflights', input.approvals?.items.map((item) => ({
-            id: item.id,
-            title: item.kind,
-            status: item.status,
-            summary: `${item.category} · ${item.operation}`,
-            detail: [`Reason: ${item.reason}`, `Risk: ${item.riskFlags.join(', ') || 'none'}`, `Run: ${item.runId ?? 'unknown'}`],
-            copyActions: item.nextActions,
-        })) ?? [], project, generatedAt),
-        permissions: management('permissions', 'Permissions', 'permission policy', permissions, project, generatedAt, 'Permission rules are inspect-only here; dashboard never approves or changes permissions.'),
-        settings: management('settings', 'Settings', 'workspace settings', settings, project, generatedAt, 'Settings are displayed read-only in the dashboard.'),
-    };
-}
-export function redactDashboardValue(value) {
-    return redactJsonValue(value);
-}
-function meta(screen, title, source, generatedAt = new Date().toISOString()) {
-    return { screen, title, generatedAt, source, redactionsApplied: [redactedPlaceholder], safety: dashboardSafety() };
-}
-function management(section, title, source, rows, _project, generatedAt, emptyMessage = `No ${title.toLowerCase()} rows are visible for this project.`) {
-    return {
-        meta: meta(section, title, source, generatedAt),
-        section,
-        status: rows.length === 0 ? 'empty' : 'ready',
-        summary: `${rows.length} ${title.toLowerCase()} row(s); Enter shows detail only.`,
-        rows,
-        ...(rows.length === 0
-            ? { emptyState: { message: emptyMessage, nextActions: [dashboardCopyAction(`Inspect ${title}`, `npm run cli -- ${section} --help`)] } }
-            : {}),
-        copyActions: [dashboardCopyAction(`Inspect ${title}`, `npm run cli -- ${section} --help`)],
-    };
-}
-function sddRows(sdd, project) {
-    if (sdd === undefined)
-        return [];
-    const cockpit = sdd.cockpit;
-    if (cockpit !== undefined) {
-        return [
-            {
-                id: sdd.change,
-                title: sdd.change,
-                status: cockpit.actionablePhase ?? cockpit.next.status,
-                summary: `actionable=${cockpit.actionablePhase ?? 'none'}; next=${cockpit.next.status}; accepted=${cockpit.acceptedCount}/${cockpit.phases.length}; legacy=${cockpit.legacyCount}`,
-                detail: [
-                    `Recommended action: ${cockpit.recommendedAction}`,
-                    `Aggregate blockers: ${cockpit.aggregateBlockers.length === 0 ? 'none' : cockpit.aggregateBlockers.map((blocker) => `${blocker.kind}:${blocker.topicKey}`).join(', ')}`,
-                    `Inspect: ${cockpit.inspectCommand}`,
-                    'Copy/inspect only: Enter shows details; it never runs commands.',
-                    verificationReportMetadataDetail(sdd),
-                    ...verificationPlanGuidanceDetail(),
-                ],
-                copyActions: [
-                    dashboardCopyAction('Inspect SDD cockpit', `npm run cli -- sdd cockpit --project ${project} --change ${sdd.change}`),
-                    verificationPlanCopyAction(),
-                    verificationReportCopyAction(project, sdd.change),
-                ],
-            },
-        ];
-    }
-    return [
-        {
-            id: sdd.change,
-            title: sdd.change,
-            status: sdd.status.nextReadyPhase ?? 'no-ready-phase',
-            summary: `${sdd.status.phases.filter((phase) => phase.present).length}/${sdd.status.phases.length} artifacts present; acceptance is not inferred.`,
-            detail: [
-                ...sdd.status.phases.map((phase) => `${phase.present ? 'present' : 'missing'}: ${phase.topicKey}`),
-                verificationReportMetadataDetail(sdd),
-                ...verificationPlanGuidanceDetail(),
-            ],
-            copyActions: [
-                dashboardCopyAction('Inspect SDD status', `npm run cli -- sdd status --project ${project} --change ${sdd.change}`),
-                verificationPlanCopyAction(),
-                verificationReportCopyAction(project, sdd.change),
-            ],
-        },
-    ];
-}
-function buildRunTraceItem(run, details, insights) {
-    const checkpoints = details?.checkpoints ?? [];
-    const lastCheckpoint = checkpoints.at(-1);
-    const approvals = details?.approvals ?? [];
-    const attempts = details?.operationAttempts ?? [];
-    const relatedApprovals = approvals.map((approval) => {
-        const attempt = attempts.find((candidate) => candidate.approvalId === approval.id || candidate.decisionEventId === approval.decisionEventId);
-        return { id: approval.id, status: approval.status, ...(attempt === undefined ? {} : { category: attempt.category, operation: attempt.operation }) };
-    });
-    const relatedPreflights = attempts.map((attempt) => ({
-        id: attempt.id,
-        status: attempt.status,
-        category: attempt.category,
-        operation: attempt.operation,
-        riskFlags: riskFlags(attempt),
-    }));
-    return {
-        runId: run.id,
-        project: run.project,
-        workflow: run.workflow,
-        phase: run.phase,
-        status: run.status,
-        ...(run.outcome === undefined ? {} : { outcome: run.outcome }),
-        ...(run.outcomeReason === undefined ? {} : { outcomeReason: safeText(run.outcomeReason) }),
-        selectedAgentId: run.selectedAgentId,
-        model: run.model,
-        createdAt: run.createdAt,
-        updatedAt: run.updatedAt,
-        ...(run.completedAt === undefined ? {} : { completedAt: run.completedAt }),
-        ...(lastCheckpoint === undefined
-            ? {}
-            : {
-                lastCheckpoint: {
-                    id: lastCheckpoint.id,
-                    label: lastCheckpoint.label,
-                    createdAt: lastCheckpoint.createdAt,
-                    stateSummary: summarizeJson(lastCheckpoint.state),
-                },
-            }),
-        checkpointsSummary: checkpoints.length === 0 ? noLink : `${checkpoints.length} checkpoint(s); latest ${lastCheckpoint?.label ?? 'unknown'}`,
-        relatedApprovals,
-        relatedPreflights,
-        blockers: insights?.resumePlan.blockers.map((blocker) => `${blocker.code}: ${safeText(blocker.message)}`) ?? [],
-        latestTimeline: insights?.timeline.slice(-3).map((entry) => `${entry.type}: ${safeText(entry.label)}`) ?? [],
-        nextActions: [
-            dashboardCopyAction('Inspect run', `npm run cli -- runs get --id ${run.id}`),
-            dashboardCopyAction('Inspect timeline', `npm run cli -- runs timeline --id ${run.id}`),
-            dashboardCopyAction('Inspect resume plan', `npm run cli -- runs resume-inspect --id ${run.id}`),
-        ],
-    };
-}
-function approvalItemsForRun(run, details) {
-    if (details === undefined)
-        return [];
-    const approvalItems = details.approvals.map((approval) => {
-        const attempt = details.operationAttempts.find((candidate) => candidate.approvalId === approval.id || candidate.decisionEventId === approval.decisionEventId);
-        return {
-            id: approval.id,
-            kind: 'approval',
-            runId: run.id,
-            category: attempt?.category ?? 'unknown',
-            operation: attempt?.operation ?? 'unknown',
-            status: approval.status,
-            riskFlags: attempt === undefined ? [] : riskFlags(attempt),
-            reason: safeText(approval.resolutionReason ?? (approval.status === 'pending' ? 'Awaiting explicit decision outside TUI.' : 'No reason recorded.')),
-            agent: run.selectedAgentId,
-            createdAt: approval.requestedAt,
-            updatedAt: approval.resolvedAt ?? approval.requestedAt,
-            nextActions: [
-                dashboardCopyAction('Inspect run approvals', `npm run cli -- runs approvals --run-id ${run.id}`),
-                dashboardCopyAction('Inspect resume gate', `npm run cli -- runs resume-gate --approval ${approval.id}`),
-            ],
-        };
-    });
-    const preflightItems = details.operationAttempts.map((attempt) => ({
-        id: attempt.id,
-        kind: 'preflight',
-        runId: run.id,
-        category: attempt.category,
-        operation: attempt.operation,
-        status: attempt.status,
-        riskFlags: riskFlags(attempt),
-        reason: summarizeJson(attempt.operationMetadata),
-        agent: attempt.executorName,
-        createdAt: attempt.reservedAt,
-        updatedAt: attempt.updatedAt,
-        nextActions: [
-            dashboardCopyAction('Inspect run', `npm run cli -- runs get --id ${run.id}`),
-            dashboardCopyAction('Evaluate retry', `npm run cli -- runs retry-check --approval ${attempt.approvalId ?? '<approval-id>'}`),
-        ],
-    }));
-    return [...approvalItems, ...preflightItems];
-}
-function riskFlags(attempt) {
-    const metadata = redactDashboardValue(attempt.operationMetadata);
-    if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata))
-        return [];
-    return ['destructive', 'external', 'privileged', 'ambiguous', 'sandboxStrategy']
-        .filter((key) => Object.hasOwn(metadata, key))
-        .map((key) => `${key}=${String(metadata[key])}`);
-}
-function summarizeJson(value) {
-    const redacted = redactDashboardValue(value);
-    const rendered = typeof redacted === 'string' ? redacted : JSON.stringify(redacted);
-    return safeText(rendered).slice(0, 180);
-}
-function safeText(value) {
-    return redactJsonValue(value).replaceAll(/\s+/g, ' ').trim();
-}

package/dist/cli/dashboard-renderer.js

@@ -1,158 +0,0 @@
-import { renderSetupStatus, setupNeedsAction } from './setup-status-renderer.js';
-export function renderDashboard(view) {
-    return [
-        'VGXNESS Dashboard',
-        '',
-        renderProject(view),
-        '',
-        renderLatestRuns(view.runs),
-        '',
-        renderSelectedRun(view.selectedRun, view.selectedRunInsights),
-        '',
-        renderSetup(view.setup),
-        '',
-        renderSdd(view.sdd, view.project),
-        '',
-        renderNextDecision(view),
-        '',
-        renderSafetyBoundary(),
-        '',
-    ].join('\n');
-}
-function renderSetup(setup) {
-    return setup === undefined
-        ? ['Setup Status', '- Setup lifecycle status unavailable. Run `setup status` for JSON details.'].join('\n')
-        : renderSetupStatus(setup);
-}
-function renderProject(view) {
-    return ['Project', `- Name: ${view.project}`, `- Store: ${view.databasePath}`].join('\n');
-}
-function renderLatestRuns(runs) {
-    if (runs.length === 0)
-        return ['Latest Runs', '- No runs found for this project.'].join('\n');
-    return ['Latest Runs', ...runs.map((run) => `- ${run.id}: ${run.status} ${run.workflow}/${run.phase} — ${run.userIntent}`)].join('\n');
-}
-function renderSelectedRun(run, insights) {
-    if (run === undefined)
-        return ['Selected Run', '- No run selected. Pass --run-id <id> for details.'].join('\n');
-    const lines = [
-        'Selected Run',
-        `- ID: ${run.id}`,
-        `- Status: ${run.status}`,
-        `- Intent: ${run.userIntent}`,
-        `- Events: ${run.events.length}`,
-        `- Checkpoints: ${run.checkpoints.length}`,
-        `- Approvals: ${run.approvals.length}`,
-        `- Operation attempts: ${run.operationAttempts.length}`,
-    ];
-    if (insights !== undefined)
-        lines.push('', renderRunInsights(insights));
-    return lines.join('\n');
-}
-function renderRunInsights(insights) {
-    const lines = [
-        '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.map((entry) => `  - ${entry}`));
-    return lines.join('\n');
-}
-function renderResumePlan(plan) {
-    if (plan.resumable && plan.latestCheckpoint !== undefined)
-        return `manual review eligible from checkpoint ${plan.latestCheckpoint.id}`;
-    return 'blocked or unavailable';
-}
-function renderSdd(sdd, project) {
-    if (sdd === undefined)
-        return ['SDD Change', '- No change selected. Pass --change <id> to inspect workflow state.'].join('\n');
-    const statusPresent = sdd.status.phases.filter((phase) => phase.present).map((phase) => phase.phase);
-    if (statusPresent.length === 0) {
-        return ['SDD Change', `- Change ${sdd.change} cannot be found yet. Pass --change <id> after saving SDD artifacts.`].join('\n');
-    }
-    if (sdd.cockpit !== undefined) {
-        const cockpit = sdd.cockpit;
-        const present = cockpit.phases.filter((phase) => phase.present).map((phase) => phase.phase);
-        const missing = cockpit.phases.filter((phase) => !phase.present).map((phase) => phase.phase);
-        return [
-            'SDD Change',
-            `- Change: ${cockpit.change}`,
-            `- Present: ${present.join(', ') || 'none'}`,
-            `- Missing: ${missing.join(', ') || 'none'}`,
-            `- Actionable phase: ${cockpit.actionablePhase ?? 'none'}`,
-            `- Next status: ${cockpit.next.status}`,
-            `- Recommended action: ${cockpit.recommendedAction}`,
-            `- Accepted: ${cockpit.acceptedCount}/${cockpit.phases.length}`,
-            `- Legacy artifacts: ${cockpit.legacyCount}`,
-            `- Blockers: ${cockpit.aggregateBlockers.length === 0 ? 'none' : cockpit.aggregateBlockers.map((blocker) => `${blocker.phase}:${blocker.reason}`).join('; ')}`,
-            `- ${verificationReportMetadataDetail(sdd)}`,
-            `- Copy verification report command: ${verificationReportCommand(project, sdd.change)}`,
-            `- Inspect with: ${cockpit.inspectCommand}`,
-        ].join('\n');
-    }
-    const lines = [
-        'SDD Change',
-        `- Change: ${sdd.change}`,
-        `- Present: ${statusPresent.join(', ')}`,
-        `- Missing: ${sdd.status.phases
-            .filter((phase) => !phase.present)
-            .map((phase) => phase.phase)
-            .join(', ') || 'none'}`,
-    ];
-    if (sdd.status.nextReadyPhase !== undefined)
-        lines.push(`- Next ready phase: ${sdd.status.nextReadyPhase}`);
-    if (sdd.readiness !== undefined && !sdd.readiness.ready)
-        lines.push(`- Missing prerequisites: ${sdd.readiness.missingArtifactTopicKeys.join(', ')}`);
-    lines.push(`- ${verificationReportMetadataDetail(sdd)}`);
-    lines.push(`- Copy verification report command: ${verificationReportCommand(project, sdd.change)}`);
-    lines.push(`- Inspect with: sdd status --project ${project} --change ${sdd.change}`);
-    return lines.join('\n');
-}
-function verificationReportCommand(project, change) {
-    return `npm run cli -- verification report get --project ${project} --change ${change}`;
-}
-function verificationReportMetadataDetail(sdd) {
-    const fallbackTopicKey = `sdd/${sdd.change}/verify`;
-    const cockpitVerify = sdd.cockpit?.phases.find((phase) => phase.phase === 'verify');
-    const statusVerify = sdd.status.phases.find((phase) => phase.phase === 'verify');
-    const verify = cockpitVerify ?? statusVerify;
-    const present = verify?.present === true;
-    const topicKey = verify?.topicKey ?? fallbackTopicKey;
-    if (!present)
-        return `Verification report artifact: not present · topicKey=${topicKey}`;
-    const state = verify?.state ?? 'present';
-    const accepted = verify?.accepted === true ? 'yes' : 'no';
-    const artifactId = cockpitVerify?.artifact?.artifactId ?? statusVerify?.artifactId ?? 'unavailable';
-    return `Verification report artifact: present · state=${state} · accepted=${accepted} · topicKey=${topicKey} · artifactId=${artifactId}`;
-}
-function renderNextDecision(view) {
-    if (view.setup !== undefined && setupNeedsAction(view.setup)) {
-        return ['Next Decision', `- Resolve setup first with \`${view.setup.nextAction.command}\`: ${view.setup.nextAction.reason}.`].join('\n');
-    }
-    const sddNext = view.sdd?.status.nextReadyPhase;
-    if (view.sdd?.cockpit !== undefined)
-        return ['Next Decision', `- ${view.sdd.cockpit.recommendedAction} Inspect: ${view.sdd.cockpit.inspectCommand}.`].join('\n');
-    const hasSddArtifacts = view.sdd?.status.phases.some((phase) => phase.present) ?? false;
-    if (view.sdd !== undefined && hasSddArtifacts && sddNext !== undefined) {
-        return [
-            'Next Decision',
-            `- Continue the next SDD phase in OpenCode; CLI readiness is only a fallback: \`sdd ready --project ${view.project} --change ${view.sdd.change} --phase ${sddNext}\`.`,
-        ].join('\n');
-    }
-    if (view.selectedRun !== undefined)
-        return ['Next Decision', '- Inspect selected run events, checkpoints, approvals, or operation attempts.'].join('\n');
-    if (view.runs.length === 0)
-        return ['Next Decision', '- Create a run or pass --change <id> to inspect SDD state.'].join('\n');
-    return ['Next Decision', '- Select a run with --run-id <id> or pass --change <id> for workflow readiness.'].join('\n');
-}
-function renderSafetyBoundary() {
-    return [
-        'Safety Boundary',
-        '- Read-only dashboard: no preflight, provider execution, shell execution, config writes, workers, sandbox, worktree, or OpenSpec writes.',
-    ].join('\n');
-}