onto-mcp 0.4.12 → 0.4.13

package/dist/tui/screens/log.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Log screen — a tail of a session's `runtime-events.ndjson` (fed by the
+ * event-follower in the app). Pure presentation: shows the most recent events
+ * with timestamp · source · stream · message. Read-only.
+ */
+import { Box, Text } from "ink";
+function clockTime(timestamp) {
+    // Render only HH:MM:SS from an ISO timestamp without constructing a Date
+    // (avoids locale/clock surprises and keeps it test-stable).
+    const match = /T(\d{2}:\d{2}:\d{2})/.exec(timestamp);
+    return match ? match[1] : timestamp.slice(0, 8);
+}
+const STREAM_COLOR = {
+    model_call: "magenta",
+    status: undefined,
+    chunk: "gray",
+};
+export function LogScreen({ sessionId, events, maxLines = 18, }) {
+    const tail = events.slice(-maxLines);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: `onto watch · ${sessionId} · log` }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: tail.length === 0 ? (_jsx(Text, { dimColor: true, children: "no events yet" })) : (tail.map((event, index) => {
+                    const sourceColor = STREAM_COLOR[event.stream];
+                    return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: `${clockTime(event.timestamp)}  ` }), _jsx(Text, { ...(sourceColor ? { color: sourceColor } : {}), children: `${(event.source.label ?? event.source.kind).padEnd(16)} ` }), _jsx(Text, { children: event.message })] }, index));
+                })) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "[tab] tree  [q]uit" }) })] }));
+}

package/dist/tui/screens/node-detail.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Drill-down detail pane for the node selected in the WorkflowTree HUD — shows
+ * the node's status/owner/attempts/failure/output and a tail of its output (the
+ * running log / authored artifact). Pure presentation.
+ */
+import { Box, Text } from "ink";
+export function NodeDetail({ node, tail }) {
+    const meta = [`status ${node.status}`];
+    if (node.owner)
+        meta.push(`owner ${node.owner}`);
+    if (node.attempts && node.attempts > 1)
+        meta.push(`try${node.attempts}`);
+    if (node.signalAgeSec != null)
+        meta.push(`${node.signalAgeSec}s`);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsx(Text, { bold: true, children: node.label }), _jsx(Text, { dimColor: true, children: meta.join(" · ") }), node.failureMessage ? _jsx(Text, { color: "red", children: node.failureMessage }) : null, node.outputPath ? _jsx(Text, { dimColor: true, children: node.outputPath }) : null, tail.length > 0 ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "\u2500\u2500 output (tail) \u2500\u2500" }), tail.map((line, index) => (_jsx(Text, { children: line }, index)))] })) : null] }));
+}

package/dist/tui/screens/session-selector.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * SessionSelector — the `onto watch` entry screen when no session is given (or
+ * `s` from a session view). Lists review/reconstruct sessions (most recent
+ * first) with a cursor. Pure presentation: selection state is owned by the app.
+ */
+import { Box, Text } from "ink";
+function relativeAge(modifiedMs, nowMs) {
+    if (!modifiedMs)
+        return "";
+    const sec = Math.max(0, Math.round((nowMs - modifiedMs) / 1000));
+    if (sec < 60)
+        return `${sec}s ago`;
+    if (sec < 3600)
+        return `${Math.round(sec / 60)}m ago`;
+    if (sec < 86400)
+        return `${Math.round(sec / 3600)}h ago`;
+    return `${Math.round(sec / 86400)}d ago`;
+}
+export function SessionSelector({ sessions, selectedIndex, nowMs, }) {
+    const now = nowMs ?? Date.now();
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "onto watch \u00B7 sessions" }), sessions.length === 0 ? (_jsx(Text, { dimColor: true, children: "no review/reconstruct sessions found" })) : (_jsx(Box, { flexDirection: "column", marginTop: 1, children: sessions.map((session, index) => {
+                    const active = index === selectedIndex;
+                    return (_jsxs(Box, { children: [_jsx(Text, { ...(active ? { color: "cyan" } : {}), children: `${active ? "›" : " "} ${session.pipeline.padEnd(11)} ` }), _jsx(Text, { bold: active, children: session.sessionId }), _jsx(Text, { dimColor: true, children: `  ${relativeAge(session.modifiedMs, now)}` })] }, `${session.pipeline}:${session.sessionRoot}`));
+                }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "[\u2191\u2193] select  [enter] watch  [q]uit" }) })] }));
+}

package/dist/tui/screens/workflow-tree.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * WorkflowTree HUD — the primary `onto watch` screen. Pure presentation: renders
+ * a {@link TreeViewModel} (header · narrator · phase-grouped unit tree · footer)
+ * for either pipeline. The HUD never branches on pipeline; the adapters already
+ * normalized the difference into the view model.
+ */
+import { Box, Text } from "ink";
+const NODE_ICON = {
+    completed: "✓",
+    running: "◐",
+    pending: "○",
+    failed: "✗",
+    halted: "◑",
+    skipped: "⊘",
+};
+const NODE_COLOR = {
+    completed: "green",
+    running: "cyan",
+    pending: "gray",
+    failed: "red",
+    halted: "yellow",
+    skipped: "gray",
+};
+const STATUS_BADGE = {
+    running: { label: "◐ running", color: "cyan" },
+    completed: { label: "✓ completed", color: "green" },
+    halted: { label: "◑ halted", color: "yellow" },
+    failed: { label: "✗ failed", color: "red" },
+};
+const SEVERITY_ORDER = ["blocker", "high", "medium", "low", "info"];
+const SEVERITY_ABBR = {
+    blocker: "blk",
+    high: "high",
+    medium: "med",
+    low: "low",
+    info: "info",
+};
+function NodeBadge({ node }) {
+    const parts = [];
+    if (node.owner)
+        parts.push(node.owner);
+    if (node.signalAgeSec != null)
+        parts.push(`${node.signalAgeSec}s`);
+    if (node.attempts && node.attempts > 1)
+        parts.push(`try${node.attempts}`);
+    if (node.failureMessage)
+        parts.push(node.failureMessage);
+    if (parts.length === 0)
+        return null;
+    return _jsx(Text, { dimColor: true, children: `  ${parts.join(" · ")}` });
+}
+/**
+ * Surfaces the run-control availability the status projection carries (observe-
+ * only: it reports what the operator can do via the MCP/CLI, the HUD never acts).
+ * Most relevant for halted/stale sessions where continue is the next step.
+ */
+function RunControlRow({ control }) {
+    const available = [];
+    if (control.continuable)
+        available.push("continue");
+    if (control.advanceable)
+        available.push("advance");
+    if (control.cancellable)
+        available.push("cancel");
+    if (available.length === 0)
+        return null;
+    return _jsx(Text, { dimColor: true, children: `Controls  ${available.join(" · ")} available` });
+}
+function Footer({ vm }) {
+    const { findings, counts } = vm.summary;
+    if (findings) {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Findings  ", SEVERITY_ORDER.map((s) => `⬤${findings[s]} ${SEVERITY_ABBR[s]}`).join("  ")] }), findings.material.map((title, index) => (_jsx(Text, { dimColor: true, children: `  › ${title}` }, index)))] }));
+    }
+    if (counts) {
+        const pairs = Object.entries(counts)
+            .filter(([, value]) => value != null)
+            .map(([key, value]) => `${key} ${value}`);
+        return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Coverage  ", pairs.join(" · ")] }) }));
+    }
+    return _jsx(Box, { marginTop: 1 });
+}
+export function WorkflowTree({ vm, selectedNodeId }) {
+    const badge = STATUS_BADGE[vm.status];
+    const phasesDone = vm.phases.filter((p) => p.state === "completed").length;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "onto watch" }), _jsx(Text, { children: ` · ${vm.pipeline} · ${vm.sessionId} ` }), _jsx(Text, { color: badge.color, children: badge.label })] }), vm.headline ? _jsx(Text, { dimColor: true, children: vm.headline }) : null, _jsx(Text, { children: `▸ ${vm.narrator}` }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: `Pipeline  ${phasesDone}/${vm.phases.length} phases` }), vm.liveness.secondsSinceSignal != null ? (_jsx(Text, { dimColor: true, children: `  · ${vm.liveness.secondsSinceSignal}s since signal` })) : null] }), _jsx(RunControlRow, { control: vm.runControl }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: vm.phases.map((phase) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: NODE_COLOR[phase.state], children: `${NODE_ICON[phase.state]} ${phase.label}` }), phase.nodes.map((node) => {
+                            const selected = node.id === selectedNodeId;
+                            return (_jsxs(Box, { children: [_jsx(Text, { color: NODE_COLOR[node.status], children: `${selected ? "›" : " "} ${NODE_ICON[node.status]} ` }), _jsx(Text, { bold: selected, children: node.label }), _jsx(NodeBadge, { node: node })] }, node.id));
+                        })] }, phase.id))) }), _jsx(Footer, { vm: vm }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "[q]uit  [r]efresh" }) })] }));
+}

package/dist/tui/view-model/reconstruct-adapter.js

@@ -0,0 +1,162 @@
+/**
+ * v1 grouping: a single "pipeline" phase holds every reconstruct stage as a
+ * node, in canonical stage order (the projection already lists stages in
+ * `RECONSTRUCT_STAGE_IDS` order). This keeps the adapter simple and mirrors the
+ * design's "stages are the nodes" framing; finer maturation-stage grouping can
+ * be layered on later without changing the node mapping.
+ */
+const PIPELINE_PHASE_ID = "pipeline";
+const PIPELINE_PHASE_LABEL = "reconstruct pipeline";
+/**
+ * Map a reconstruct stage `state` to the shared {@link NodeState}. Reconstruct
+ * stage states are a strict subset (`pending | completed | skipped | halted`) —
+ * there is no per-stage `running` signal in the projection, so the in-flight
+ * stage is surfaced at the phase/headline level (see {@link derivePhaseState}),
+ * not on individual nodes.
+ */
+function stageStateToNodeState(state) {
+    switch (state) {
+        case "completed":
+            return "completed";
+        case "skipped":
+            return "skipped";
+        case "halted":
+            return "halted";
+        case "pending":
+            return "pending";
+    }
+}
+/** Human-ize a snake_case stageId for display, e.g. `ontology_seed` → `ontology seed`. */
+function humanizeStageId(stageId) {
+    return stageId.replace(/_/g, " ");
+}
+function stageToNode(stage, hiddenArtifactRef) {
+    const outputPath = stage.artifactRefs.find((ref) => ref !== hiddenArtifactRef) ?? null;
+    return {
+        id: stage.stageId,
+        label: humanizeStageId(stage.stageId),
+        status: stageStateToNodeState(stage.state),
+        // reconstruct nodes badge by stageId (kind) + carry the owner column.
+        kind: stage.stageId,
+        // owner is optional under exactOptionalPropertyTypes: omit when absent.
+        ...(stage.owner ? { owner: stage.owner } : {}),
+        // No per-stage live signal in the projection.
+        signalAgeSec: null,
+        // `reason` is the stage's terminal explanation (skip/halt rationale).
+        failureMessage: stage.reason,
+        // First authored artifact ref is the drill-down target.
+        outputPath,
+    };
+}
+/**
+ * Phase state for the single pipeline phase. A halted stage halts the phase;
+ * otherwise a completed run completes the phase; otherwise it is running (the
+ * pipeline is mid-flight regardless of which individual stages are still
+ * pending).
+ */
+function derivePhaseState(stages, workflowStatus) {
+    if (stages.some((stage) => stage.state === "halted"))
+        return "halted";
+    if (workflowStatus === "completed")
+        return "completed";
+    return "running";
+}
+/**
+ * Map record_stage + stage states to the shared {@link WorkflowStatus}.
+ * reconstruct has no `failed` record_stage and no per-stage `running`; we treat
+ * a halted stage as a halt (terminal-ish, surfaced for the operator) and a
+ * completed record as completed. Everything else is an in-flight run.
+ */
+function deriveWorkflowStatus(status) {
+    if (status.status === "failed")
+        return "failed";
+    if (status.status === "completed")
+        return "completed";
+    // A graceful terminal (design §16.7) is terminal but not completed: surface it as `halted` so
+    // the watch loop stops polling and the operator sees an honest stop, not a "session completed".
+    if (status.status === "blocked" || status.status === "limited")
+        return "halted";
+    if (status.progress.stages.some((stage) => stage.state === "halted")) {
+        return "halted";
+    }
+    return "running";
+}
+/** Flatten countSummary + answerabilitySummary into the footer label→value map. */
+function deriveCounts(progress) {
+    const c = progress.countSummary;
+    const a = progress.answerabilitySummary;
+    return {
+        observations: c.selectedObservationCount ?? c.sourceObservationCount,
+        claims: c.semanticClaimCount,
+        confirmed: c.confirmedClaimCount,
+        deferredClaims: c.deferredClaimCount,
+        CQ: c.competencyQuestionCount,
+        passRate: c.passRate,
+        // Answerability (maturation) summary — null until metrics are computed.
+        declared: a ? a.declaredQuestionCount : null,
+        supported: a ? a.supportedQuestionCount : null,
+        deferred: a ? a.deferredQuestionCount : null,
+        unsupported: a ? a.unsupportedQuestionCount : null,
+    };
+}
+/** One-line narrator from the current stage + the most informative counts. */
+function deriveNarrator(progress, workflowStatus) {
+    const stage = humanizeStageId(progress.currentStageId);
+    const a = progress.answerabilitySummary;
+    const lead = workflowStatus === "completed"
+        ? "reconstruct complete"
+        : workflowStatus === "failed"
+            ? `reconstruct failed at ${stage}`
+            : workflowStatus === "halted"
+                ? `halted at ${stage}`
+                : `reconstructing — ${stage}`;
+    if (a) {
+        return `${lead} · CQ ${a.declaredQuestionCount} · supported ${a.supportedQuestionCount} · deferred ${a.deferredQuestionCount} · unsupported ${a.unsupportedQuestionCount}`;
+    }
+    const claims = progress.countSummary.semanticClaimCount;
+    return claims === null ? lead : `${lead} · ${claims} claims`;
+}
+/**
+ * Pure projection: {@link ReconstructSessionStatus} → {@link TreeViewModel}.
+ *
+ * `sessionRoot` is threaded explicitly (the caller already knows it) so the view
+ * model header is independent of how the status was fetched.
+ */
+export function reconstructStatusToTreeViewModel(status, sessionRoot) {
+    const { progress } = status;
+    const workflowStatus = deriveWorkflowStatus(status);
+    const hiddenArtifactRef = status.status === "failed"
+        ? status.failure.failure_artifact_ref
+        : null;
+    const nodes = progress.stages.map((stage) => stageToNode(stage, hiddenArtifactRef));
+    const phase = {
+        id: PIPELINE_PHASE_ID,
+        label: PIPELINE_PHASE_LABEL,
+        state: derivePhaseState(progress.stages, workflowStatus),
+        nodes,
+    };
+    return {
+        pipeline: "reconstruct",
+        sessionId: status.sessionId,
+        sessionRoot,
+        status: workflowStatus,
+        narrator: deriveNarrator(progress, workflowStatus),
+        liveness: {
+            state: progress.liveness.state,
+            // The projection carries no per-signal timestamp for reconstruct.
+            secondsSinceSignal: null,
+            pollMs: progress.liveness.recommendedPollIntervalMs,
+        },
+        phases: [phase],
+        summary: { counts: deriveCounts(progress) },
+        // reconstruct status carries no rich run_control (unlike review): be
+        // conservative — only a still-running session is cancellable; continue /
+        // advance are display-only false until a control path exists (design §4,
+        // later stage E).
+        runControl: {
+            cancellable: workflowStatus === "running",
+            continuable: false,
+            advanceable: false,
+        },
+    };
+}

package/dist/tui/view-model/review-adapter.js

@@ -0,0 +1,270 @@
+import { REVIEW_PROGRESS_STEPS, } from "../../core-api/review-progress.js";
+/** Phase that collects units the projection has not bound to a progress step. */
+const UNCATEGORIZED_PHASE_ID = "unassigned";
+const UNCATEGORIZED_PHASE_LABEL = "unassigned units";
+/** Canonical progress-step ids — used to reject non-step `completed_steps` keys. */
+const VALID_PROGRESS_STEP_IDS = new Set(REVIEW_PROGRESS_STEPS.map((step) => step.id));
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Narrow the `unknown` presentation payload to the read-only fields we use. */
+function readProgressPresentationInput(status) {
+    const input = status.llmPresentation?.progress?.input;
+    return isRecord(input) ? input : {};
+}
+/**
+ * Map a runtime unit status to the shared {@link NodeState}. `retrying` and
+ * `running_stale` are both still in-flight (the HUD surfaces the retry count /
+ * stale signal age separately), so they collapse to `running`.
+ */
+function unitStatusToNodeState(unitStatus) {
+    switch (unitStatus) {
+        case "pending":
+            return "pending";
+        case "running":
+        case "retrying":
+        case "running_stale":
+            return "running";
+        case "completed":
+            return "completed";
+        case "failed":
+            return "failed";
+    }
+}
+function unitToNode(unit) {
+    return {
+        id: unit.unitId,
+        label: unit.publicAlias,
+        status: unitStatusToNodeState(unit.status),
+        kind: unit.unitKind,
+        signalAgeSec: unit.secondsSinceLatestSignal,
+        attempts: unit.attemptCount,
+        failureMessage: unit.failureMessage,
+        outputPath: drillDownPath(unit),
+    };
+}
+/**
+ * Drill-down target for a unit. A completed unit's authored output is the
+ * authoritative artifact. For an active/failed unit that planned output may not
+ * exist yet, so prefer the live running-log (the projection only sets
+ * `runningLogRef` when that file is present) and fall back to the planned output.
+ */
+function drillDownPath(unit) {
+    if (unit.status === "completed") {
+        return unit.outputPath ?? unit.runningLogRef ?? null;
+    }
+    return unit.runningLogRef ?? unit.outputPath ?? null;
+}
+/**
+ * State of the current (in-flight) progress step, given the workflow's own
+ * status: a halted or failed run is terminal, and its current step is the
+ * halt/failure locus — surface that rather than a misleading "running". A live
+ * run's current step is running.
+ */
+function currentStepState(workflowStatus) {
+    if (workflowStatus === "failed")
+        return "failed";
+    if (workflowStatus === "halted")
+        return "halted";
+    return "running";
+}
+/**
+ * Phase state from its nodes (+ the projection's completed step ids). A failed
+ * node fails the phase; any in-flight node makes it running; a step listed in
+ * `completed_steps` (or all nodes completed) completes it; a halted node halts
+ * it. A step at the current step whose units exist but have not signalled yet
+ * takes the workflow's current-step state — matching {@link emptyStepState}'s
+ * current-step branch so the same current step reports the same state whether or
+ * not it carries units. Otherwise it is pending.
+ */
+function derivePhaseState(nodes, stepId, completedStepIds, stepNumber, currentStep, workflowStatus) {
+    if (nodes.some((node) => node.status === "failed"))
+        return "failed";
+    if (nodes.some((node) => node.status === "running"))
+        return "running";
+    if (nodes.some((node) => node.status === "halted"))
+        return "halted";
+    if (stepId !== null && completedStepIds.has(stepId))
+        return "completed";
+    if (nodes.length > 0 && nodes.every((node) => node.status === "completed")) {
+        return "completed";
+    }
+    if (nodes.length > 0 && nodes.every((node) => node.status === "skipped")) {
+        return "skipped";
+    }
+    if (stepNumber != null && currentStep != null && stepNumber === currentStep) {
+        return currentStepState(workflowStatus);
+    }
+    return "pending";
+}
+/**
+ * State for a progress step that has no bound units: completed when the workflow
+ * itself completed, when the step is in `completed_steps`, or when it sits before
+ * the current step; the workflow's current-step state at the current step (so a
+ * halted/failed run points at its halt/failure locus, not a phantom "running");
+ * otherwise pending. This keeps idle/completed steps visible so the HUD shows the
+ * whole pipeline (not only the steps that happened to carry units).
+ */
+function emptyStepState(stepId, stepNumber, completedStepIds, currentStep, workflowStatus) {
+    if (workflowStatus === "completed")
+        return "completed";
+    if (completedStepIds.has(stepId))
+        return "completed";
+    if (currentStep != null) {
+        if (stepNumber < currentStep)
+            return "completed";
+        if (stepNumber === currentStep)
+            return currentStepState(workflowStatus);
+    }
+    return "pending";
+}
+/**
+ * Emit a phase for EVERY progress step (in canonical order), attaching any units
+ * bound to it, so completed/idle steps stay visible. Units the projection left
+ * unbound (`progressStepId === null`) collect into a trailing uncategorized phase.
+ */
+function derivePhases(status, completedStepIds, currentStep, workflowStatus) {
+    const byStep = new Map();
+    for (const unit of status.unitProgress ?? []) {
+        const key = unit.progressStepId;
+        const bucket = byStep.get(key);
+        if (bucket)
+            bucket.push(unitToNode(unit));
+        else
+            byStep.set(key, [unitToNode(unit)]);
+    }
+    const phases = REVIEW_PROGRESS_STEPS.map((spec) => {
+        const nodes = byStep.get(spec.id) ?? [];
+        const state = nodes.length > 0
+            ? derivePhaseState(nodes, spec.id, completedStepIds, spec.step, currentStep, workflowStatus)
+            : emptyStepState(spec.id, spec.step, completedStepIds, currentStep, workflowStatus);
+        return { id: spec.id, label: spec.label, state, nodes };
+    });
+    const unassigned = byStep.get(null);
+    if (unassigned && unassigned.length > 0) {
+        phases.push({
+            id: UNCATEGORIZED_PHASE_ID,
+            label: UNCATEGORIZED_PHASE_LABEL,
+            state: derivePhaseState(unassigned, null, completedStepIds, null, currentStep, workflowStatus),
+            nodes: unassigned,
+        });
+    }
+    return phases;
+}
+/**
+ * Map the review status union to the shared {@link WorkflowStatus}. A degraded
+ * completion is still a completion; `halted_partial` is the operator-facing halt;
+ * `prepared` / `unknown` are pre-run states the HUD shows as still-running (the
+ * narrator/liveness convey the finer state).
+ */
+function deriveWorkflowStatus(status) {
+    switch (status) {
+        case "completed":
+        case "completed_with_degradation":
+            return "completed";
+        case "halted_partial":
+            return "halted";
+        case "failed":
+            return "failed";
+        case "running":
+        case "prepared":
+        case "unknown":
+            return "running";
+    }
+}
+/**
+ * Run control from the review projection. `cancellationAvailable` /
+ * `continuationAvailable` are the authoritative flags; review has no per-round
+ * advance, so `advanceable` is left undefined.
+ */
+function deriveRunControl(runControl) {
+    return {
+        cancellable: runControl?.cancellationAvailable ?? false,
+        continuable: runControl?.continuationAvailable ?? false,
+    };
+}
+const EMPTY_SEVERITY_COUNTS = {
+    blocker: 0,
+    high: 0,
+    medium: 0,
+    low: 0,
+    info: 0,
+};
+/**
+ * Footer findings: severity counts + material issue titles. Works for both the
+ * full and compact result-classification projections — material titles come from
+ * `material_issues[]` (full) or `material_issue_signals[]` (compact).
+ */
+function deriveFindings(summary) {
+    if (!summary) {
+        return { ...EMPTY_SEVERITY_COUNTS, material: [] };
+    }
+    const counts = {
+        blocker: summary.severity_counts.blocker,
+        high: summary.severity_counts.high,
+        medium: summary.severity_counts.medium,
+        low: summary.severity_counts.low,
+        info: summary.severity_counts.info,
+    };
+    return { ...counts, material: materialIssueTitles(summary) };
+}
+function isCompactSummary(summary) {
+    return "material_issue_signals" in summary;
+}
+function materialIssueTitles(summary) {
+    if (isCompactSummary(summary)) {
+        return summary.material_issue_signals.map((signal) => titleLine(signal.issue_id, signal.signal));
+    }
+    return summary.material_issues.map((issue) => titleLine(issue.issue_id, issue.problem_definition ?? issue.issue_statement ?? issue.impact));
+}
+function titleLine(issueId, text) {
+    const trimmed = (text ?? "").trim();
+    return trimmed.length > 0 ? `${issueId}: ${trimmed}` : issueId;
+}
+/**
+ * Narrator line: prefer the latest progress signal summary, fall back to the
+ * liveness summary, then to the bare status. Mirrors the design's
+ * `latest_update.summary / liveness.summary` rule.
+ */
+function deriveNarrator(input, workflowStatus) {
+    const latest = input.latest_update?.summary?.trim();
+    if (latest)
+        return latest;
+    const liveness = input.liveness?.summary?.trim();
+    if (liveness)
+        return liveness;
+    return `review ${workflowStatus}`;
+}
+/**
+ * Pure projection: {@link ReviewStatus} → {@link TreeViewModel}.
+ *
+ * `sessionRoot` is threaded explicitly (the caller already knows it) so the view
+ * model header is independent of how the status was fetched.
+ */
+export function reviewStatusToTreeViewModel(status, sessionRoot) {
+    const input = readProgressPresentationInput(status);
+    const workflowStatus = deriveWorkflowStatus(status.status);
+    // Consume only real progress-step ids: a prepared session fills
+    // `completed_steps` with preparation-artifact keys (interpretation/binding/
+    // execution_plan), a different vocabulary, which must not be matched against
+    // (or mistaken for) progress-step ids during phase rollup.
+    const completedStepIds = new Set((input.progress?.completed_steps ?? []).filter((id) => VALID_PROGRESS_STEP_IDS.has(id)));
+    const phases = derivePhases(status, completedStepIds, input.progress?.current_step ?? null, workflowStatus);
+    return {
+        pipeline: "review",
+        sessionId: status.sessionId,
+        sessionRoot,
+        status: workflowStatus,
+        narrator: deriveNarrator(input, workflowStatus),
+        liveness: {
+            state: input.liveness?.state ?? "unknown",
+            secondsSinceSignal: input.liveness?.seconds_since_last_observed_artifact ?? null,
+            pollMs: input.liveness?.poll_after_seconds == null
+                ? null
+                : input.liveness.poll_after_seconds * 1000,
+        },
+        phases,
+        summary: { findings: deriveFindings(input.result_classification_summary) },
+        runControl: deriveRunControl(status.runControl),
+    };
+}

package/dist/tui/view-model/tree-view-model.js

@@ -0,0 +1,19 @@
+/**
+ * Pipeline-agnostic view model rendered by the `onto watch` HUD.
+ *
+ * review and reconstruct expose progress in different shapes (review = per-UNIT
+ * live signal; reconstruct = per-STAGE state + owner + domain counts). The
+ * review/reconstruct adapters normalize both into this single shape, so the Ink
+ * HUD never branches on pipeline. This is a pure derived VIEW — it carries no
+ * authority and is never persisted.
+ */
+/**
+ * True when the workflow has reached a terminal state (stop polling). `halted`
+ * is terminal for the watch loop too: it sits paused awaiting an explicit
+ * operator continuation that may be a long way off, so the live loop stops
+ * rather than re-reading an unchanging projection every interval. The operator
+ * re-engages with [r]efresh after continuing (consistent with completed/failed).
+ */
+export function isTerminalStatus(status) {
+    return status === "completed" || status === "failed" || status === "halted";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onto-mcp",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "MCP-native ontology review runtime with context-isolated lenses and controlled deliberation",
   "homepage": "https://github.com/kangminlee-maker/onto-mcp#readme",
   "bugs": {
@@ -49,10 +49,17 @@
     "check:invariant-change": "tsx scripts/check-invariant-change-marker.ts",
     "check:invariant-drift": "tsx scripts/check-invariant-drift.ts",
     "check:supported-models": "tsx scripts/check-supported-models.ts",
+    "check:prompt-projection-parity": "tsx scripts/check-prompt-projection-parity.ts",
+    "check:final-output-sections-parity": "tsx scripts/check-final-output-sections-parity.ts",
+    "check:obligation-coverage": "tsx scripts/check-obligation-coverage.ts",
+    "check:dispatch-fallback-package-parity": "tsx scripts/check-dispatch-fallback-package-parity.ts",
+    "check:graceful-signal-rethrow": "tsx scripts/check-graceful-signal-rethrow.ts",
     "test": "npm run test:e2e",
     "test:vitest": "vitest run",
     "test:review:live": "npm run build:ts-core && tsx scripts/review-mcp-live-e2e.ts",
     "test:review:live:cli": "npm run build:ts-core && tsx scripts/review-live-e2e.ts",
+    "test:reconstruct:dispatch-fallback:live": "node --env-file=.env --import tsx scripts/reconstruct-dispatch-fallback-live-e2e.mts",
+    "test:reconstruct:output-headroom:live": "node --env-file=.env --import tsx scripts/reconstruct-output-headroom-live-e2e.mts",
     "benchmark:review:pipeline": "tsx scripts/review-pipeline-benchmark.ts",
     "benchmark:reconstruct:pipeline": "tsx scripts/reconstruct-pipeline-benchmark.ts",
     "calibration:effort:report": "tsx scripts/effort-calibration-report.ts",
@@ -60,13 +67,21 @@
     "test:e2e": "npm run build:ts-core && tsx scripts/review-mcp-live-e2e.ts"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.99.0",
-    "openai": "^6.33.0",
+    "@anthropic-ai/sdk": "0.99.0",
+    "fflate": "^0.8.3",
+    "ink": "^5.2.1",
+    "openai": "6.39.0",
+    "proper-lockfile": "^4.1.2",
+    "react": "^18.3.1",
+    "saxes": "^6.0.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/react": "^18.3.31",
+    "ink-testing-library": "^4.0.0",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"