@oh-my-pi/pi-tui 18.4.3 → 18.4.4

package/dist/types/tools/todo.d.ts

@@ -1,6 +1,8 @@
 import type { Component } from "../index.js";
 import type { RenderResultOptions } from "./renderer.js";
 import type { Theme } from "../theme/theme.js";
+import type { TspChecklistPhase } from "@oh-my-pi/pi-wire";
+import type { NativeToolView, ToolRenderResult } from "./renderer.js";
 /** Lifecycle state of a todo item. */
 export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned" | "blocked";
 /** Operation names accepted by the todo tool and echoed in successful result details. */
@@ -102,6 +104,14 @@ export declare const TODO_STRIKE_REVEAL_FRAMES = 12;
 export declare const TODO_STRIKE_TOTAL_FRAMES: number;
 /** Wire the live-subagent description source for {@link todoToolRenderer}. */
 export declare function setActiveTodoDescriptionsProvider(provider: () => readonly string[]): void;
+/**
+ * Checklist phases for native terminals: plain phase titles (no roman
+ * numerals — the terminal numbers nothing), completed phases folded.
+ */
+export declare function todoChecklistPhases(phases: readonly {
+    name: string;
+    tasks: readonly TodoItem[];
+}[], isMatched?: (task: TodoItem) => boolean): TspChecklistPhase[];
 /** Render todo operations and phased task snapshots. */
 export declare const todoToolRenderer: {
     renderCall(args: TodoRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
@@ -113,6 +123,8 @@ export declare const todoToolRenderer: {
         details?: TodoToolDetails;
         isError?: boolean;
     }, options: RenderResultOptions, uiTheme: Theme, args?: TodoRenderArgs): Component;
+    describeCall(args: TodoRenderArgs): NativeToolView;
+    describeResult(result: ToolRenderResult<TodoToolDetails>, options: RenderResultOptions): NativeToolView | undefined;
     mergeCallAndResult: true;
 };
 export {};

package/dist/types/tools/vibe.d.ts

@@ -1,6 +1,6 @@
 import type { Component } from "../tui.js";
 import type { Theme } from "../theme/theme.js";
-import type { RenderResultOptions } from "./renderer.js";
+import type { NativeToolView, RenderResultOptions, ToolRenderResult } from "./renderer.js";
 /** Operation represented by a worker-session tool result. */
 export type VibeOp = "spawn" | "send" | "wait" | "kill" | "list";
 /** Details payload shared by every vibe tool for TUI rendering. */
@@ -120,5 +120,7 @@ export declare function createVibeToolRenderer(op: VibeOp): {
         details?: VibeToolDetails;
         isError?: boolean;
     }, options: RenderResultOptions, uiTheme: Theme, args?: VibeRenderArgs): Component;
+    describeCall(args: VibeRenderArgs): NativeToolView | undefined;
+    describeResult(result: ToolRenderResult<VibeToolDetails>, _options: RenderResultOptions, args?: VibeRenderArgs): NativeToolView | undefined;
 };
 export {};

package/dist/types/tools/wait.d.ts

@@ -5,6 +5,7 @@ import { type ConfiguredThinkingLevel } from "../render/render-utils.js";
 import type { StructuredSubagentOutput } from "./task.js";
 import type { RenderResultOptions, ToolActivitySummary } from "./renderer.js";
 import type { IrcDeliveryReceipt, IrcMessage } from "./irc.js";
+import type { NativeToolView, ToolRenderResult } from "./renderer.js";
 /** Whether a wait snapshot contains only running jobs and no cancellations. */
 export declare function isWaitingPollDetails(details: unknown): boolean;
 /** Coordination details retained by wait and background job operations. */
@@ -119,6 +120,8 @@ export declare const waitToolRenderer: {
     mergeCallAndResult: true;
     activitySummary(): ToolActivitySummary;
     renderCall: typeof waitRenderCall;
+    describeCall(): NativeToolView;
+    describeResult(result: ToolRenderResult<CoordinationDetails>, options: RenderResultOptions): NativeToolView | undefined;
     renderResult(result: {
         content: Array<{
             type: string;

package/dist/types/tools/web-search.d.ts

@@ -1,3 +1,4 @@
+import type { NativeToolView, ToolRenderResult } from "./renderer.js";
 /**
  * Web Search TUI Rendering
  *
@@ -28,9 +29,16 @@ export declare function renderSearchCall(args: {
     query?: string;
     [key: string]: unknown;
 }, _options: RenderResultOptions, theme: Theme): Component;
+type SearchRenderArgs = {
+    query?: string;
+    [key: string]: unknown;
+};
 /** Render web search queries, answers, and cited sources. */
 export declare const webSearchToolRenderer: {
     renderCall: typeof renderSearchCall;
     renderResult: typeof renderSearchResult;
+    describeCall(args: SearchRenderArgs): NativeToolView;
+    describeResult(result: ToolRenderResult<SearchRenderDetails>, _options: RenderResultOptions, args?: SearchRenderArgs): NativeToolView | undefined;
     mergeCallAndResult: true;
 };
+export {};

package/dist/types/tools/write.d.ts

@@ -6,7 +6,7 @@ import { type ProcWriteDetails } from "./proc-render.js";
 import { type CfgWriteDetails } from "./cfg-render.js";
 import type { FileDiagnosticsResult } from "./lsp.js";
 import type { OutputMeta } from "./output-meta.js";
-import type { RenderResultOptions, ToolActivityContext, ToolActivitySummary } from "./renderer.js";
+import type { NativeToolView, RenderResultOptions, ToolActivityContext, ToolActivitySummary } from "./renderer.js";
 import { type XdevRenderDispatch, type XdevMountedRenderer } from "./xdev.js";
 /** Details returned by the write tool for transcript rendering. */
 export interface WriteToolDetails {
@@ -76,6 +76,19 @@ export declare const writeToolRenderer: {
     }, options: RenderResultOptions & {
         renderContext?: WriteRenderContext;
     }, uiTheme: Theme, args?: WriteRenderArgs): Component;
+    describeCall(args: WriteRenderArgs, options: RenderResultOptions & {
+        renderContext?: WriteRenderContext;
+    }): NativeToolView | undefined;
+    describeResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: WriteToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: WriteRenderContext;
+    }, args?: WriteRenderArgs): NativeToolView | undefined;
     mergeCallAndResult: true;
     forceFirstResultViewportRepaint: (args: unknown, options: RenderResultOptions) => boolean;
 };

package/dist/types/tools/xdev.d.ts

@@ -2,9 +2,12 @@ import type { ToolTier } from "@oh-my-pi/pi-agent-core";
 import { type Component } from "../index.js";
 import type { Theme } from "../theme/theme.js";
 import type { RenderResultOptions, ToolActivitySummary, ToolRenderer } from "./renderer.js";
+import type { NativeToolView } from "./renderer.js";
 /** Mounted device display callbacks, independent of tool execution state. */
 export interface XdevMountedRenderer {
     label?: string;
+    describeCall?: ToolRenderer["describeCall"];
+    describeResult?: ToolRenderer["describeResult"];
     renderCall?(...args: Parameters<ToolRenderer["renderCall"]>): unknown;
     renderResult?(...args: Parameters<ToolRenderer["renderResult"]>): unknown;
     mergeCallAndResult?: boolean;
@@ -50,6 +53,16 @@ export declare function xdevActivitySummary(name: string, content: unknown, reso
  * nothing) when no renderer produces output.
  */
 export declare function renderXdevCall(name: string, content: unknown, options: RenderResultOptions, theme: Theme, resolveMounted?: (name: string) => XdevMountedRenderer | undefined): Component | undefined;
+/** TSP call view for an `xd://` write: queued card until execution, then the device renderer's own view. */
+export declare function describeXdevCall(name: string, content: unknown, options: RenderResultOptions, resolveMounted?: (name: string) => XdevMountedRenderer | undefined): NativeToolView | undefined;
+/** TSP result view for an `xd://` dispatch, forwarded to the device renderer. */
+export declare function describeXdevResult(dispatch: XdevRenderDispatch, result: {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    isError?: boolean;
+}, options: RenderResultOptions, resolveMounted?: (name: string) => XdevMountedRenderer | undefined): NativeToolView | undefined;
 /** Forward an `xd://` dispatch result to the mounted tool's renderer. */
 export declare function renderXdevResult(dispatch: XdevRenderDispatch, result: {
     content: Array<{

package/dist/types/tui.d.ts

@@ -1,4 +1,6 @@
+import type { TspFrame, TspNode, TspText } from "@oh-my-pi/pi-wire";
 import { ImageBudget } from "./components/image.js";
+import type { DescribeContext, NativeNode, NativeUiEvent } from "./native/node.js";
 import { type Terminal } from "./terminal.js";
 import { visibleWidth } from "./utils.js";
 /** Full-attribute reset terminating each rendered content row. */
@@ -109,6 +111,35 @@ export interface Component {
      * last time.
      */
     render(width: number): readonly string[];
+    /**
+     * Describe the component semantically for a Tern Surface Protocol
+     * terminal (see `native/node.ts`). Called instead of `render()` when the
+     * native backend is active. Return the same node object while nothing
+     * changed; return null to fall back to `render()` rows.
+     */
+    describe?(cx: DescribeContext): NativeNode | null;
+    /**
+     * Props for the native `overlay` wrapper when this component is shown as
+     * an overlay: the sheet's `role` (Tern styles `omp.overlay.*` roles as
+     * glass sheets, so the component's own root must not draw a second frame),
+     * `head` spans for the sheet's title row, and `size`/`anchor` overriding
+     * the ones derived from the overlay options.
+     */
+    nativeOverlay?: {
+        role?: string;
+        head?: TspText;
+        size?: "sm" | "md" | "lg" | "full";
+        anchor?: "center" | "top" | "bottom";
+    };
+    /**
+     * True when this component, shown as an overlay, describes a data-first
+     * sheet (`picker`, `prefs`) that is its own frame: the backend puts it
+     * directly in `layer` with no `overlay` wrapper. Usually
+     * `cx.supports("picker")`, so older terminals keep the wrapped fallback.
+     */
+    nativeSheet?(cx: DescribeContext): boolean;
+    /** User actions on nodes this component described (toggle, select, activate, custom). */
+    handleNativeEvent?(event: NativeUiEvent): void;
     /**
      * Optional handler for keyboard input when component has focus
      */
@@ -269,6 +300,7 @@ export declare class Container implements Component {
      */
     dispose(): void;
     render(width: number): readonly string[];
+    describe(_cx: DescribeContext): NativeNode | null;
 }
 /**
  * Merge runs of byte-adjacent SGR sequences (`CSI [0-9;:]* m`) into one. Only
@@ -382,6 +414,23 @@ export declare class TUI extends Container {
     setInlineMouseTrackingProvider(provider: (() => boolean) | undefined): void;
     invalidate(): void;
     start(options?: TUIStartOptions): void;
+    /** Whether frames go to a Tern Surface Protocol surface instead of the row renderer. */
+    get nativeRendering(): boolean;
+    /**
+     * Close the TSP surfaces ahead of {@link stop}, before the exit drains
+     * input: the terminal answers nothing once they are closed, and whatever it
+     * already sent (acks, events) is read and dropped here instead of reaching
+     * the shell as typed text. A render already requested (the exit's status
+     * line) goes out first; none is forced, and nothing renders from now until
+     * `stop()`.
+     */
+    closeNative(): void;
+    /** Reference document the TSP terminal should hold (debug mirror only). */
+    getNativeDocument(): TspNode | undefined;
+    /** Most recent TSP frames sent (debug mirror only). */
+    getNativeFrames(count?: number): readonly TspFrame[];
+    /** `rows` fallback nodes in the last native frame. */
+    get nativeFallbackCount(): number;
     /**
      * Take ownership of stdin after a `deferInput` start: raw mode, input
      * handlers, and the response-eliciting capability probes start() skipped.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.4.3",
+	"version": "18.4.4",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -41,14 +41,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.4.3",
-		"@oh-my-pi/pi-agent-core": "18.4.3",
-		"@oh-my-pi/pi-ai": "18.4.3",
-		"@oh-my-pi/pi-catalog": "18.4.3",
-		"@oh-my-pi/pi-natives": "18.4.3",
-		"@oh-my-pi/pi-utils": "18.4.3",
-		"@oh-my-pi/pi-wire": "18.4.3",
-		"@oh-my-pi/snapcompact": "18.4.3"
+		"@oh-my-pi/omptype": "18.4.4",
+		"@oh-my-pi/pi-agent-core": "18.4.4",
+		"@oh-my-pi/pi-ai": "18.4.4",
+		"@oh-my-pi/pi-catalog": "18.4.4",
+		"@oh-my-pi/pi-natives": "18.4.4",
+		"@oh-my-pi/pi-utils": "18.4.4",
+		"@oh-my-pi/pi-wire": "18.4.4",
+		"@oh-my-pi/snapcompact": "18.4.4"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/apps/autoresearch-dashboard.ts

@@ -15,6 +15,28 @@ import {
 	isBetter,
 } from "./autoresearch-data";
 import { formatNum, type ExperimentResult, type ExperimentState } from "../tools/autoresearch";
+import type { TspSpan, TspTableColumn, TspText } from "@oh-my-pi/pi-wire";
+import { card, col, elapsed, keyed, node, row, span, text } from "../native/describe";
+import type { DescribeContext, NativeNode } from "../native/node";
+import { hintsRow } from "../native/overlay";
+import { Memo } from "../native/memo";
+import { isNativeRendering } from "../native/state";
+
+/** The widget's ANSI `Text`, describing itself from the runtime instead of its pre-rendered lines. */
+class DashboardWidget extends Text {
+	readonly #build: (cx: DescribeContext) => NativeNode;
+	#node: NativeNode | undefined;
+
+	constructor(content: string, build: (cx: DescribeContext) => NativeNode) {
+		super(content, 0, 0);
+		this.#build = build;
+	}
+
+	override describe(cx: DescribeContext): NativeNode {
+		this.#node ??= this.#build(cx);
+		return this.#node;
+	}
+}
 
 /** Experiment runtime fields rendered by the dashboard. */
 export interface AutoresearchDashboardRuntime {
@@ -86,7 +108,9 @@ export function createDashboardController(): DashboardController {
 
 			ctx.ui.setWidget("autoresearch", (_tui, theme) => {
 				if (state.results.length === 0 && runtime.runningExperiment) {
-					return new Text(renderRunningOnly(runtime, state, theme), 0, 0);
+					return new DashboardWidget(renderRunningOnly(runtime, state, theme), () =>
+						describeRunningOnly(runtime, state),
+					);
 				}
 				if (runtime.dashboardExpanded) {
 					const width = process.stdout.columns ?? 120;
@@ -94,9 +118,19 @@ export function createDashboardController(): DashboardController {
 						renderExpandedHeader(runtime, width, theme),
 						...renderDashboardLines(runtime, width, theme, 8),
 					];
-					return new Text(lines.join("\n"), 0, 0);
+					return new DashboardWidget(lines.join("\n"), cx =>
+						card({ role: "omp.widget.autoresearch", head: describeTitle(runtime) }, [
+							...describeDashboard(runtime, 8, cx.supports("chart")),
+							hintsRow([
+								{ keys: ["ctrl+x"], label: "collapse" },
+								{ keys: ["ctrl+shift+x"], label: "overlay" },
+							]),
+						]),
+					);
 				}
-				return new Text(renderCollapsedLine(runtime, state, theme), 0, 0);
+				return new DashboardWidget(renderCollapsedLine(runtime, state, theme), () =>
+					describeCollapsed(runtime, state),
+				);
 			});
 		},
 		async showOverlay(ctx, runtime): Promise<void> {
@@ -104,7 +138,8 @@ export function createDashboardController(): DashboardController {
 			await ctx.ui.custom<void>(
 				(tui, theme, _keybindings, done) => {
 					overlayTui = tui;
-					if (!spinnerTimer) {
+					// Repaint-only: the native overlay declares a spinner and elapsed timer instead.
+					if (!spinnerTimer && !isNativeRendering()) {
 						spinnerTimer = setInterval(() => {
 							spinnerFrame += 1;
 							requestRender();
@@ -112,7 +147,56 @@ export function createDashboardController(): DashboardController {
 					}
 
 					let scrollView: ScrollView | undefined;
+					const native = new Memo();
 					return {
+						/** A glass sheet titled by the experiment (the panels' sheet style); the body is borderless. */
+						get nativeOverlay() {
+							return { role: "omp.overlay.autoresearch", head: describeTitle(runtime), size: "lg" as const };
+						},
+						describe(cx: DescribeContext): NativeNode {
+							const state = runtime.state;
+							const chart = cx.supports("chart");
+							return native.get(
+								[
+									chart,
+									state,
+									state.results.length,
+									state.results.at(-1),
+									state.bestMetric,
+									state.confidence,
+									state.currentSegment,
+									state.name,
+									runtime.autoresearchMode,
+									runtime.lastRunSummary,
+									runtime.runningExperiment,
+								],
+								() => {
+									const running = runtime.runningExperiment;
+									const children: NativeNode[] = describeDashboard(runtime, 0, chart);
+									if (running) {
+										children.push(
+											row(
+												[
+													node("spinner", { label: [span("running", "warning")], tone: "warning" }),
+													elapsed(Date.now() - running.startedAt),
+													text([span(replaceTabs(running.command), "warning")], { truncate: "end" }),
+												],
+												{ gap: "sm" },
+											),
+										);
+									}
+									children.push(
+										hintsRow([
+											{ keys: ["up", "down", "j", "k"], label: "scroll" },
+											{ keys: ["pageUp", "pageDown"], label: "page" },
+											{ keys: ["g", "shift+g"], label: "top/bottom" },
+											{ keys: ["escape"], label: "close" },
+										]),
+									);
+									return col(children, { gap: "md", role: "omp.app.autoresearch" });
+								},
+							);
+						},
 						render(width: number): readonly string[] {
 							const terminalRows = process.stdout.rows ?? 40;
 							const header = renderExpandedHeader(runtime, width, theme);
@@ -163,6 +247,280 @@ export function createDashboardController(): DashboardController {
 	};
 }
 
+// -- native ------------------------------------------------------------------
+
+/** Card/overlay title: the experiment name plus its mode status. */
+function describeTitle(runtime: AutoresearchDashboardRuntime): TspSpan[] {
+	const state = runtime.state;
+	const spans = [span(state.name ? `autoresearch: ${replaceTabs(state.name)}` : "autoresearch", "accent")];
+	const status = renderModeStatus(runtime, state);
+	if (status) spans.push(span(` · ${status}`, "muted"));
+	return spans;
+}
+
+/** Widget shown while the very first run is in flight. */
+function describeRunningOnly(runtime: AutoresearchDashboardRuntime, state: ExperimentState): NativeNode {
+	const children: NativeNode[] = [
+		node("spinner", { label: [span("autoresearch", "accent"), span(" running", "warning")], tone: "warning" }),
+	];
+	if (runtime.runningExperiment) children.push(elapsed(Date.now() - runtime.runningExperiment.startedAt));
+	const details: TspSpan[] = [];
+	if (state.name) details.push(span(`| ${replaceTabs(state.name)}`, "dim"));
+	if (runtime.runningExperiment) details.push(span(` | ${replaceTabs(runtime.runningExperiment.command)}`, "dim"));
+	if (details.length > 0) children.push(text(details, { truncate: "end" }));
+	return row(children, { gap: "sm", role: "omp.widget.autoresearch" });
+}
+
+/** One-line collapsed widget: run counts, best/baseline, confidence and mode. */
+function describeCollapsed(runtime: AutoresearchDashboardRuntime, state: ExperimentState): NativeNode {
+	const role = "omp.widget.autoresearch";
+	const hint = hintsRow([{ keys: ["ctrl+x"], label: "expand" }]);
+	if (runtime.lastRunSummary) {
+		const spans = [
+			span("autoresearch", "accent"),
+			span(` pending run #${runtime.lastRunSummary.runNumber}`, "warning"),
+			span(runtime.lastRunSummary.passed ? " pass" : " fail", "dim"),
+		];
+		if (runtime.lastRunSummary.parsedPrimary !== null) {
+			spans.push(
+				span(
+					` | ${state.metricName}=${formatNum(runtime.lastRunSummary.parsedPrimary, state.metricUnit)}`,
+					"muted",
+				),
+			);
+		}
+		spans.push(span(" | log_experiment required", "warning"));
+		if (!runtime.autoresearchMode) spans.push(span(" | mode off", "dim"));
+		return text(spans, { truncate: "end", role });
+	}
+	if (state.results.length === 0) {
+		const spans = [
+			span("autoresearch", "accent"),
+			span(` ${runtime.autoresearchMode ? "baseline pending" : "mode off"}`, "warning"),
+		];
+		if (state.name) spans.push(span(` | ${replaceTabs(state.name)}`, "dim"));
+		if (runtime.autoresearchMode) spans.push(span(" | run the baseline", "dim"));
+		return text(spans, { truncate: "end", role });
+	}
+	const current = currentResults(state.results, state.currentSegment);
+	const counts = statusCounts(current);
+	const best = findBestResult(state);
+	const archivedRuns = Math.max(0, state.results.length - current.length);
+	const spans = [
+		span("autoresearch", "accent"),
+		span(` ${current.length} runs`, "muted"),
+		span(` ${counts.keep} kept`, "success"),
+	];
+	if (archivedRuns > 0) spans.push(span(` +${archivedRuns} archived`, "dim"));
+	if (counts.crash > 0) spans.push(span(` ${counts.crash} crash`, "error"));
+	if (counts.checks_failed > 0) spans.push(span(` ${counts.checks_failed} checks_failed`, "error"));
+	spans.push(span(" | ", "dim"));
+	if (best && state.bestMetric !== null && best.result.metric !== state.bestMetric) {
+		spans.push(span(`best ${formatNum(best.result.metric, state.metricUnit)}`, "warning"));
+		spans.push(span(` baseline ${formatNum(state.bestMetric, state.metricUnit)}`, "dim"));
+	} else if (state.bestMetric !== null) {
+		spans.push(span(`baseline ${formatNum(state.bestMetric, state.metricUnit)}`, "warning"));
+	} else {
+		spans.push(span("no kept runs yet", "warning"));
+	}
+	if (state.confidence !== null) {
+		spans.push(span(" | ", "dim"));
+		spans.push(span(`conf ${state.confidence.toFixed(1)}x`, confidenceToken(state.confidence)));
+	}
+	const children: NativeNode[] = [text(spans, { truncate: "end" })];
+	if (runtime.runningExperiment) {
+		children.push(text([span("| running", "dim")]), elapsed(Date.now() - runtime.runningExperiment.startedAt));
+	} else if (!runtime.autoresearchMode) {
+		children.push(text([span(`| ${renderModeStatus(runtime, state)}`, "dim")]));
+	}
+	children.push(hint);
+	return row(children, { gap: "sm", role });
+}
+
+/**
+ * Summary `kv`, the metric per run as a `bars` chart when the terminal draws
+ * `chart` (`chart`), and the run `table`; `maxRows > 0` keeps only the latest runs.
+ */
+function describeDashboard(runtime: AutoresearchDashboardRuntime, maxRows: number, chart: boolean): NativeNode[] {
+	const state = runtime.state;
+	if (state.results.length === 0) {
+		const pending = runtime.lastRunSummary;
+		if (pending) {
+			const items: { k: string; v: TspText }[] = [
+				{ k: "Pending run", v: `#${pending.runNumber}` },
+				{
+					k: "Result",
+					v: `${pending.passed ? "passed" : "failed"}${pending.parsedPrimary !== null ? `  ${state.metricName} ${formatNum(pending.parsedPrimary, state.metricUnit)}` : ""}`,
+				},
+				{ k: "Next action", v: "finish log_experiment before starting another run." },
+			];
+			if (!runtime.autoresearchMode) items.push({ k: "Mode", v: "off" });
+			return [node("kv", { items, layout: "grid" }, undefined, "summary")];
+		}
+		if (runtime.autoresearchMode) {
+			return [
+				node(
+					"kv",
+					{
+						items: [
+							{ k: "Current segment", v: "0 runs" },
+							{ k: "Baseline", v: "pending" },
+							{ k: "Next action", v: "run and log the baseline experiment." },
+						],
+						layout: "grid",
+					},
+					undefined,
+					"summary",
+				),
+			];
+		}
+		return [keyed(text([span("No experiments logged yet.", "dim")]), "summary")];
+	}
+
+	const current = currentResults(state.results, state.currentSegment);
+	const counts = statusCounts(current);
+	const baseline = findBaselineMetric(state.results, state.currentSegment);
+	const baselineRunNumber = findBaselineRunNumber(state.results, state.currentSegment);
+	const baselineSecondary = findBaselineSecondary(state.results, state.currentSegment, state.secondaryMetrics);
+	const best = findBestResult(state);
+	const items: { k: string; v: TspText }[] = [
+		{
+			k: "Current segment",
+			v: [
+				span(`${current.length} runs  `),
+				span(`${counts.keep} kept`, "success"),
+				span(`  ${counts.discard} discarded`, "warning"),
+				span(`  ${counts.crash} crashed`, counts.crash > 0 ? "error" : undefined),
+				span(`  ${counts.checks_failed} checks_failed`, counts.checks_failed > 0 ? "error" : undefined),
+			],
+		},
+		{
+			k: "Baseline",
+			v: `${formatNum(baseline, state.metricUnit)}${baselineRunNumber ? ` (#${baselineRunNumber})` : ""}`,
+		},
+	];
+	if (state.results.length > current.length) {
+		items.push({ k: "Archived", v: `${state.results.length - current.length} runs from earlier segments` });
+	}
+	if (runtime.lastRunSummary) {
+		items.push({
+			k: "Pending run",
+			v: [
+				span(`#${runtime.lastRunSummary.runNumber} (${runtime.lastRunSummary.passed ? "passed" : "failed"})`),
+				span(" — log_experiment required", "warning"),
+			],
+		});
+	}
+	if (!runtime.autoresearchMode) items.push({ k: "Mode", v: renderModeStatus(runtime, state) });
+	if (best) {
+		const bestRunNumber = best.result.runNumber ?? best.index + 1;
+		const value: TspSpan[] = [
+			span(`${formatNum(best.result.metric, state.metricUnit)} (#${bestRunNumber})`, "strong"),
+		];
+		if (baseline !== null && baseline !== 0 && best.result.metric !== baseline) {
+			const delta = ((best.result.metric - baseline) / baseline) * 100;
+			value.push(span(` ${delta > 0 ? "+" : ""}${delta.toFixed(1)}%`, "num"));
+		}
+		if (state.confidence !== null) {
+			value.push(span(`  conf ${state.confidence.toFixed(1)}x`, confidenceToken(state.confidence)));
+		}
+		items.push({ k: "Best", v: value });
+		const details = state.secondaryMetrics
+			.map(metric =>
+				renderSecondarySummary(
+					metric.name,
+					best.result.metrics[metric.name],
+					baselineSecondary[metric.name],
+					metric.unit,
+				),
+			)
+			.filter((detail): detail is string => Boolean(detail));
+		if (details.length > 0) items.push({ k: "Secondary", v: details.join("  ") });
+	}
+
+	const cols: TspTableColumn[] = [
+		{ id: "run", head: [span("#", "muted")], align: "end", priority: 3 },
+		{ id: "commit", head: [span("commit", "muted")], truncate: "end", priority: 2 },
+		{ id: "metric", head: [span(state.metricName, "warning")], align: "end", priority: 5 },
+		...state.secondaryMetrics.map((metric, index): TspTableColumn => ({
+			id: `secondary${index}`,
+			head: [span(metric.name, "muted")],
+			align: "end",
+			truncate: "end",
+			priority: 1,
+		})),
+		{ id: "status", head: [span("status", "muted")], priority: 4 },
+		{ id: "description", head: [span("description", "muted")], truncate: "end", grow: 1, priority: 2 },
+	];
+	const indexed = state.results
+		.map((result, index) => ({ result, index }))
+		.filter(({ result }) => result.segment === state.currentSegment);
+	const visible = maxRows > 0 ? indexed.slice(-maxRows) : indexed;
+	const rows = visible.map(({ result, index }) => {
+		const token = result.status === "keep" ? "success" : result.status === "discard" ? "warning" : "error";
+		const cells: Record<string, TspText> = {
+			run: [span(String(result.runNumber ?? index + 1), "dim")],
+			commit: [span(result.commit || "-", "accent")],
+			metric: [span(formatNum(result.metric, state.metricUnit), token)],
+			status: [span(result.status, token)],
+			description: [span(replaceTabs(result.description), "muted")],
+		};
+		state.secondaryMetrics.forEach((metric, metricIndex) => {
+			cells[`secondary${metricIndex}`] = renderSecondaryCell(
+				result.metrics[metric.name],
+				metric.unit,
+				baselineSecondary[metric.name],
+			);
+		});
+		return { id: String(index), cells };
+	});
+	const children: NativeNode[] = [node("kv", { items, layout: "grid" }, undefined, "summary")];
+	if (chart && visible.length >= 2) {
+		children.push(
+			node(
+				"chart",
+				{
+					kind: "bars",
+					series: visible.map(({ result, index }) => {
+						const run = result.runNumber ?? index + 1;
+						return {
+							label: `#${run}`,
+							value: result.metric,
+							title: `#${run} ${result.status} · ${formatNum(result.metric, state.metricUnit)} · ${replaceTabs(result.description)}`,
+						};
+					}),
+					token: "accent",
+					summary: [
+						span(`${state.metricName} per run`, "muted"),
+						...(best ? [span(` · best ${formatNum(best.result.metric, state.metricUnit)}`, "success")] : []),
+					],
+					size: "md",
+					role: "omp.autoresearch.trend",
+				},
+				undefined,
+				"trend",
+			),
+		);
+	}
+	if (visible.length < indexed.length) {
+		children.push(keyed(text([span(`… ${indexed.length - visible.length} earlier runs hidden`, "dim")]), "hidden"));
+	}
+	children.push(node("table", { cols, rows, role: "omp.autoresearch.runs" }, undefined, "runs"));
+	return [keyed(col(children, { gap: "sm" }), "dashboard")];
+}
+
+function statusCounts(results: readonly ExperimentResult[]): Record<ExperimentResult["status"], number> {
+	const counts: Record<ExperimentResult["status"], number> = { keep: 0, discard: 0, crash: 0, checks_failed: 0 };
+	for (const result of results) counts[result.status] += 1;
+	return counts;
+}
+
+function confidenceToken(confidence: number): string {
+	return confidence >= 2 ? "success" : confidence >= 1 ? "warning" : "error";
+}
+
+// -- ANSI --------------------------------------------------------------------
+
 function renderRunningOnly(runtime: AutoresearchDashboardRuntime, state: ExperimentState, theme: Theme): string {
 	const parts = [theme.fg("accent", "autoresearch"), theme.fg("warning", " running...")];
 	if (state.name) {