@iowarp/clio-coder 0.3.4 → 0.3.7

package/src/interactive/dispatch-board.ts

@@ -9,6 +9,14 @@ import {
 import type { SafeEventBus } from "../core/event-bus.js";
 import { rawDurationMs } from "../core/timers.js";
 import type { AgentAudience } from "../domains/agents/spec.js";
+import {
+	cloneRunToolBudgetEnvelope,
+	formatBudgetPolicy,
+	formatBudgetReasons,
+	formatBudgetRequest,
+	formatEffectiveBudget,
+	type RunToolBudgetEnvelope,
+} from "../domains/dispatch/budget-envelope.js";
 import type { DispatchSnapshot } from "../domains/dispatch/contract.js";
 import {
 	type DispatchRequestOrigin,
@@ -25,8 +33,15 @@ import {
 } from "../domains/observability/index.js";
 import type { CostProvenance } from "../domains/providers/index.js";
 import { sanitizeCallTargetText } from "../domains/safety/call-target.js";
-import { type Component, truncateToWidth, visibleWidth } from "../engine/tui.js";
+import { type Component, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "../engine/tui.js";
 import { formatWorkerContextMeter } from "./context-meter.js";
+import {
+	COUNCIL_SYNTHESIS_LABEL,
+	type CouncilGroupView,
+	type CouncilMemberView,
+	councilGroupBody,
+	councilIslandLines,
+} from "./council-grid.js";
 import { formatFooterTokens } from "./footer-panel.js";
 import {
 	type ClioTheme,
@@ -42,6 +57,13 @@ import {
 	screenTitle,
 	spinnerFrame,
 } from "./theme/index.js";
+import {
+	createWorkerProgressFold,
+	type WorkerAction,
+	type WorkerProgressFold,
+	type WorkerProgressSnapshot,
+} from "./worker-progress.js";
+import type { WorkerReceiptReader } from "./worker-stream.js";
 
 export type DispatchBoardStatus =
 	| Extract<RunStatus, "running" | "completed" | "failed" | "stale" | "dead">
@@ -72,6 +94,8 @@ export interface DispatchBoardRow {
 	wireModelId: string;
 	/** Sanitized, one-line summary of the task assigned to this run. */
 	taskSummary?: string;
+	/** Immutable budget admission provenance for this run. */
+	budget?: RunToolBudgetEnvelope;
 	status: DispatchBoardStatus;
 	elapsedMs: number;
 	tokenCount: number;
@@ -86,6 +110,9 @@ export interface DispatchBoardRow {
 	node?: string;
 	/** Review/compete gate badge (role + cycle). */
 	gate?: { role: string; cycle: number };
+	council?: { group: string; label: string; color?: string; round: number };
+	/** Orchestrator-executed declared verification status. */
+	hostVerification?: "verified" | "rejected" | "skipped";
 	/** Dead-node failover hops recorded on this run's chain. */
 	rerouteCount?: number;
 	/** Assignment retry attempts observed on the assignment event stream. */
@@ -94,10 +121,17 @@ export interface DispatchBoardRow {
 	contextWindow?: number;
 	/** Last assistant message's input+cacheRead+output: current context occupancy. */
 	lastContextTokens?: number;
-	/** Tool currently executing in the worker; null between calls. */
+	/** Tool currently executing in the worker; null between calls. Projected from `progress`. */
 	currentTool?: string | null;
-	/** Recently finished tools, newest first, bounded. */
+	/** Recently finished tools, newest first, bounded. Projected from `progress`. */
 	recentTools?: ReadonlyArray<string>;
+	/**
+	 * The canonical worker-progress projection for this run: the bounded answer
+	 * tail, the phase, and the redacted action descriptors. The same projection
+	 * the transcript's worker block reads, so opening a run here shows what the
+	 * worker is doing rather than a richer spinner.
+	 */
+	progress?: WorkerProgressSnapshot;
 	/**
 	 * Id of the receipt sealed for this run (`receipts/<runId>.json`, the id
 	 * `clio-coder trace` takes). Set only once a terminal dispatch event has
@@ -110,8 +144,39 @@ export interface DispatchBoardRow {
 	retry?: DispatchRetryPresentation;
 	/** Most recent worker delivery acknowledgement for an operator steer. */
 	steerAcknowledgement?: DispatchSteerAcknowledgement;
+	/**
+	 * Where this run sits in a fleet plan: the wave the step was scheduled in
+	 * and the step id it executes. Present only for runs a fleet plan
+	 * dispatched, so a `/run`, a delegation, or a dispatch-tool run leaves the
+	 * board's phase column empty rather than claiming a position it has none of.
+	 */
+	phase?: DispatchBoardPhase;
 }
 
+/** One fleet plan position: the wave index and the step the run executes. */
+export interface DispatchBoardPhase {
+	wave: number;
+	stepId: string;
+}
+
+/**
+ * The phase cell, or null for a run that is not a fleet step. Fixed width so
+ * the column lines up across rows; a long step id is clipped with a marker
+ * rather than pushing the row's other facts out of position.
+ */
+export function formatDispatchPhaseCell(
+	phase: DispatchBoardPhase | undefined,
+	width = PHASE_COLUMN_WIDTH,
+): string | null {
+	if (phase === undefined) return null;
+	return truncateToWidth(`w${phase.wave} ${phase.stepId}`, Math.max(1, width), "…", false);
+}
+
+/** Columns the compact island reserves for the phase cell when it can afford them. */
+export const PHASE_COLUMN_WIDTH = 12;
+/** Below this much room for the agent label, the compact row drops the column entirely. */
+const PHASE_COLUMN_MIN_LABEL_WIDTH = 8;
+
 /** Live HTTP/SDK rows are the only rows whose runtime can consume operator guidance. */
 export function isDispatchBoardRowSteerable(row: DispatchBoardRow): boolean {
 	return (
@@ -126,7 +191,10 @@ export function isDispatchBoardRowCancellable(row: DispatchBoardRow): boolean {
 }
 
 interface DispatchBoardEntry
-	extends Omit<DispatchBoardRow, "elapsedMs" | "recentTools" | "lastContextTokens" | "currentTool" | "retry"> {
+	extends Omit<
+		DispatchBoardRow,
+		"elapsedMs" | "recentTools" | "lastContextTokens" | "currentTool" | "retry" | "progress"
+	> {
 	sequence: number;
 	enqueuedAtMs: number;
 	startedAtMs: number | null;
@@ -139,15 +207,19 @@ interface DispatchBoardEntry
 	finishedAtMs: number | null;
 	durationMs: number | null;
 	lastContextTokens: number;
-	currentTool: string | null;
-	recentTools: string[];
+	/**
+	 * The one fold that reads this run's worker events. Tool activity and the
+	 * answer tail are its output, so the board no longer interprets the stream
+	 * alongside the transcript.
+	 */
+	progress: WorkerProgressFold;
 	retry?: DispatchRetryPresentation;
 }
 
-/** Bound on the recent-tool trail rendered on a card. */
-const RECENT_TOOL_TRAIL_LIMIT = 4;
 /** Keep raw task text out of long-lived TUI rows and bound hostile/user-sized input. */
 const TASK_SUMMARY_MAX_WIDTH = 240;
+/** Rows of worker prose an expanded card shows before it defers to `/view`. */
+const WORKER_PROGRESS_CARD_ROWS = 6;
 
 interface WorkerEventShape {
 	type?: unknown;
@@ -433,11 +505,92 @@ function retryCountdown(retry: DispatchRetryPresentation, now = Date.now()): str
 	return remainingMs === 0 ? "now" : `in ${formatCompactMs(remainingMs)}`;
 }
 
+/**
+ * One action as a phrase: the tool name, then the verb and object of its
+ * redacted descriptor. The descriptor was bounded and scrubbed at the worker
+ * seam, so this composes text and never inspects an argument.
+ */
+function actionPhrase(action: WorkerAction): string {
+	const descriptor = action.descriptor;
+	if (descriptor === undefined) return action.tool;
+	const object = descriptor.object === undefined ? "" : ` ${descriptor.object}${descriptor.truncated ? "…" : ""}`;
+	return `${action.tool} ${descriptor.verb}${object}`;
+}
+
+/** The phase word an expanded card names, or null for a phase that says nothing new. */
+function progressPhaseUnit(theme: ClioTheme, progress: WorkerProgressSnapshot): string | null {
+	switch (progress.phase) {
+		case "thinking":
+			// The phase only. Reasoning content never reaches an operator surface.
+			return theme.fg("reason", `${GLYPH.phaseThinking} thinking`);
+		case "writing":
+			return theme.fg("accent", `${GLYPH.phaseWriting} writing`);
+		case "tool":
+			return theme.fg("action", `${GLYPH.phaseTool} tool`);
+		case "waiting":
+			return theme.fg("info", `${GLYPH.phaseWaiting} waiting`);
+		case "settled":
+		case "starting":
+			return null;
+	}
+}
+
+/** The `doing` row: the phase, then the running call or the most recent one, with its object. */
+function progressActionLine(theme: ClioTheme, progress: WorkerProgressSnapshot, contentWidth: number): string | null {
+	const phase = progressPhaseUnit(theme, progress);
+	const current = progress.currentAction;
+	const recent = progress.recentActions[0];
+	const units: string[] = [];
+	if (phase !== null) units.push(phase);
+	if (current !== null) units.push(theme.fg("muted", actionPhrase(current)));
+	else if (recent !== undefined) units.push(theme.fg("dim", `last ${actionPhrase(recent)}`));
+	if (units.length === 0) return null;
+	return cardUnitsLine(theme, "doing", units, contentWidth);
+}
+
+/**
+ * The `answer` block: the newest rows of the worker's bounded prose on a rail,
+ * then what is not shown and where to read it. Wrapping happens before the row
+ * cap, so the block is at most {@link WORKER_PROGRESS_CARD_ROWS} rows tall
+ * whatever the terminal width, and a streaming answer cannot make the card grow
+ * under the operator.
+ */
+function progressAnswerLines(
+	theme: ClioTheme,
+	progress: WorkerProgressSnapshot,
+	runId: string,
+	contentWidth: number,
+): string[] {
+	if (progress.tailText.length === 0) return [];
+	const gutter = CARD_KV_KEY_WIDTH + 1;
+	const railWidth = Math.max(1, contentWidth - gutter - 2);
+	const wrapped: string[] = [];
+	for (const line of progress.tailText.split("\n")) {
+		for (const row of wrapTextWithAnsi(sanitizeCallTargetText(line), railWidth)) wrapped.push(row);
+	}
+	const shown = wrapped.slice(Math.max(0, wrapped.length - WORKER_PROGRESS_CARD_ROWS));
+	const hiddenRows = wrapped.length - shown.length;
+	const rail = theme.fg("dim", `${GLYPH.rail} `);
+	const body = shown.map((row) => `${rail}${theme.fg("muted", row)}`);
+	const hiddenLines = progress.droppedLines + hiddenRows;
+	if (hiddenLines > 0 || progress.droppedBytes > 0) {
+		const facts = [
+			...(hiddenLines > 0 ? [`${hiddenLines} more line${hiddenLines === 1 ? "" : "s"}`] : []),
+			...(progress.droppedBytes > 0 ? [`${progress.droppedBytes} bytes outran the view`] : []),
+			`/view dispatch:${runId}`,
+		];
+		body.push(`${rail}${theme.fg("dim", truncateToWidth(facts.join(" · "), railWidth, "…", false))}`);
+	}
+	// The key labels the block once and the rest hangs under it, which is the
+	// card's key-value grammar applied to a body rather than to one value.
+	return body.map((row, index) => `${index === 0 ? cardKvKey(theme, "answer") : " ".repeat(gutter)}${row}`);
+}
+
 export function renderDispatchCard(
 	row: DispatchBoardRow,
 	width: number,
 	evidence?: RunEvidencePresentation,
-	options: { selected?: boolean } = {},
+	options: { selected?: boolean; expanded?: boolean } = {},
 ): string[] {
 	const theme = clioTheme();
 	const contentWidth = Math.max(0, width - 4);
@@ -498,14 +651,42 @@ export function renderDispatchCard(
 		`${theme.fg("dim", "ttft")} ${theme.fg("muted", ttft)}`,
 		`${theme.fg("dim", "cost")} ${theme.fg("muted", cost)}`,
 	];
+	const hostVerification = theme.fg("info", `host_verification=${row.hostVerification ?? "not_requested"}`);
 	const contextUnit = formatWorkerContextMeter(row.lastContextTokens ?? 0, row.contextWindow, theme);
+	// The phase column: a fleet step says which wave it belongs to and which
+	// step it is; every other run leaves the cell empty rather than inventing a
+	// position, so the column reads as "not a fleet step" and not as wave zero.
+	const phaseCell = formatDispatchPhaseCell(row.phase, contentWidth);
 	const bodyLines = [
 		cardUnitsLine(theme, "run", [theme.fg("dim", row.runId)], contentWidth),
+		cardUnitsLine(
+			theme,
+			"phase",
+			[phaseCell === null ? theme.fg("dim", "—") : theme.fg("info", phaseCell)],
+			contentWidth,
+		),
 		targetLine,
 		...(row.taskSummary
 			? [truncateToWidth(`${cardKvKey(theme, "task")}${theme.fg("muted", row.taskSummary)}`, contentWidth, "…", false)]
 			: []),
 		cardUnitsLine(theme, "status", statusUnits, contentWidth),
+		cardUnitsLine(theme, "evidence", [hostVerification], contentWidth),
+		...(row.budget !== undefined
+			? [
+					truncateToWidth(
+						`${cardKvKey(theme, "policy")}${theme.fg("muted", `${formatBudgetPolicy(row.budget)}; requested ${formatBudgetRequest(row.budget)}`)}`,
+						contentWidth,
+						"…",
+						false,
+					),
+					truncateToWidth(
+						`${cardKvKey(theme, "budget")}${theme.fg("muted", `${formatEffectiveBudget(row.budget)}; reason ${formatBudgetReasons(row.budget)}`)}`,
+						contentWidth,
+						"…",
+						false,
+					),
+				]
+			: []),
 		cardUnitsLine(theme, "telemetry", [up, down, total, ...(contextUnit !== null ? [contextUnit] : [])], contentWidth),
 	];
 	if (row.retry) {
@@ -533,6 +714,13 @@ export function renderDispatchCard(
 		];
 		bodyLines.push(cardUnitsLine(theme, "tools", toolUnits, contentWidth));
 	}
+	// Live worker progress is expanded detail, never a default row: five running
+	// scouts must stay five compact cards until the operator opens one.
+	if (options.expanded === true && row.progress) {
+		const doing = progressActionLine(theme, row.progress, contentWidth);
+		if (doing !== null) bodyLines.push(doing);
+		bodyLines.push(...progressAnswerLines(theme, row.progress, row.runId, contentWidth));
+	}
 	if (row.steerAcknowledgement) {
 		bodyLines.push(
 			cardUnitsLine(
@@ -580,11 +768,25 @@ function renderTaskIslandRow(row: DispatchBoardRow, width: number): string[] {
 		visibleWidth(presentation.label) +
 		3 +
 		visibleWidth(elapsed);
-	const clampedLabel = truncateToWidth(agentLabel, Math.max(1, width - labelChrome), "…", false);
+	// The phase column rides the compact row only when the row can still show a
+	// readable agent label beside it. TASK_ISLAND_WIDTH is fixed, so a row that
+	// cannot afford the cell drops the column here and shows the phase in the
+	// expanded card instead of clipping the label to make room.
+	const phaseCell = formatDispatchPhaseCell(row.phase);
+	const phaseColumn = phaseCell === null ? "" : `${dot}${theme.fg("info", padAnsi(phaseCell, PHASE_COLUMN_WIDTH))}`;
+	const phaseChrome = phaseCell === null ? 0 : PHASE_COLUMN_WIDTH + 3;
+	const labelWidth = width - labelChrome - phaseChrome;
+	const showPhase = phaseCell !== null && labelWidth >= PHASE_COLUMN_MIN_LABEL_WIDTH;
+	const clampedLabel = truncateToWidth(
+		agentLabel,
+		Math.max(1, showPhase ? labelWidth : width - labelChrome),
+		"…",
+		false,
+	);
 
 	// The agent label drops its accent color for plain bold; the status word is
 	// the only status-colored element on the row, with dim middot separators.
-	const line1 = `${glyph} ${rowPrefix.text}${theme.paint(clampedLabel, { bold: true })}${dot}${statusStr}${dot}${theme.fg("muted", elapsed)}`;
+	const line1 = `${glyph} ${rowPrefix.text}${theme.paint(clampedLabel, { bold: true })}${dot}${statusStr}${dot}${theme.fg("muted", elapsed)}${showPhase ? phaseColumn : ""}`;
 
 	const elapsedSec = row.elapsedMs / 1000;
 	const tokensPerSec = elapsedSec > 0.1 ? Math.round(row.outputTokens / elapsedSec) : 0;
@@ -605,11 +807,138 @@ function renderTaskIslandRow(row: DispatchBoardRow, width: number): string[] {
 	return [padAnsi(line1, width), ...(task ? [padAnsi(task, width)] : []), padAnsi(telemetry, width)];
 }
 
+/**
+ * One member column's facts, drawn from the row the board already keeps. The
+ * route, status, and answer tail are the same values the run's own card shows,
+ * so a council column and a council card can never disagree.
+ */
+function councilMemberView(
+	row: DispatchBoardRow,
+	council: NonNullable<DispatchBoardRow["council"]>,
+): CouncilMemberView {
+	const presentation = dispatchStatusPresentation(row.status, {
+		compact: true,
+		...(row.status === "running" ? { tick: Math.floor(Date.now() / 100) } : {}),
+	});
+	return {
+		runId: row.runId,
+		label: council.label,
+		...(council.color !== undefined ? { color: council.color } : {}),
+		round: council.round,
+		route: `${row.targetId}/${row.wireModelId}`,
+		status: { glyph: presentation.glyph, label: presentation.label, token: presentation.token },
+		tailText: sanitizeCallTargetText(row.progress?.tailText ?? ""),
+		droppedLines: row.progress?.droppedLines ?? 0,
+	};
+}
+
+/**
+ * Fold one council group's rows into the view the grid renders.
+ *
+ * A council of N members over R rounds seals N x R member runs, and the
+ * operator is looking at a council, not at its history: each label keeps its
+ * newest round, so the group shows one column per member however many rounds
+ * it ran. Columns are ordered by label so a repaint cannot reshuffle them under
+ * the cursor while runs settle in whatever order they finish.
+ */
+function foldCouncilGroup(
+	group: string,
+	rows: ReadonlyArray<DispatchBoardRow>,
+	selectedRunId?: string | null,
+): CouncilGroupView {
+	const newest = new Map<string, DispatchBoardRow>();
+	let synthesisRow: DispatchBoardRow | null = null;
+	let rank = Number.POSITIVE_INFINITY;
+	let elapsedMs = 0;
+	let round = 1;
+	for (const row of rows) {
+		const council = row.council;
+		if (council === undefined) continue;
+		rank = Math.min(rank, STATUS_ORDER[row.status]);
+		elapsedMs = Math.max(elapsedMs, row.elapsedMs);
+		if (council.label === COUNCIL_SYNTHESIS_LABEL) {
+			synthesisRow = row;
+			continue;
+		}
+		round = Math.max(round, council.round);
+		const previous = newest.get(council.label);
+		if (previous === undefined || (previous.council?.round ?? 0) <= council.round) newest.set(council.label, row);
+	}
+	const aggregate = (Object.entries(STATUS_ORDER) as Array<[DispatchBoardStatus, number]>).find(
+		([, value]) => value === rank,
+	);
+	const presentation = dispatchStatusPresentation(aggregate?.[0] ?? "running", {
+		compact: true,
+		...(aggregate?.[0] === "running" ? { tick: Math.floor(Date.now() / 100) } : {}),
+	});
+	const members = [...newest.entries()]
+		.sort(([left], [right]) => left.localeCompare(right))
+		// biome-ignore lint/style/noNonNullAssertion: every entry was inserted with its own council badge.
+		.map(([, row]) => councilMemberView(row, row.council!));
+	const selectedInGroup =
+		selectedRunId != null && rows.some((row) => row.runId === selectedRunId) ? selectedRunId : undefined;
+	return {
+		group,
+		members,
+		// biome-ignore lint/style/noNonNullAssertion: the synthesis row was matched on its own council badge.
+		synthesis: synthesisRow === null ? null : councilMemberView(synthesisRow, synthesisRow.council!),
+		status: { glyph: presentation.glyph, label: presentation.label, token: presentation.token },
+		round,
+		elapsed: formatCompactMs(elapsedMs),
+		...(selectedInGroup !== undefined ? { selectedRunId: selectedInGroup } : {}),
+	};
+}
+
+/** A board entry: either one ordinary run, or one whole council in the position of its first row. */
+export type DispatchBoardItem = { kind: "run"; row: DispatchBoardRow } | { kind: "council"; group: CouncilGroupView };
+
+/**
+ * Board order with councils folded in place. A council occupies the position of
+ * its first row and its remaining rows are consumed, so the board never shows a
+ * member both inside its group and beside it.
+ */
+export function dispatchBoardItems(
+	rows: ReadonlyArray<DispatchBoardRow>,
+	selectedRunId?: string | null,
+): DispatchBoardItem[] {
+	const byGroup = new Map<string, DispatchBoardRow[]>();
+	for (const row of rows) {
+		const group = row.council?.group;
+		if (group === undefined) continue;
+		const bucket = byGroup.get(group);
+		if (bucket === undefined) byGroup.set(group, [row]);
+		else bucket.push(row);
+	}
+	const emitted = new Set<string>();
+	const items: DispatchBoardItem[] = [];
+	for (const row of rows) {
+		const group = row.council?.group;
+		if (group === undefined) {
+			items.push({ kind: "run", row });
+			continue;
+		}
+		if (emitted.has(group)) continue;
+		emitted.add(group);
+		items.push({ kind: "council", group: foldCouncilGroup(group, byGroup.get(group) ?? [row], selectedRunId) });
+	}
+	return items;
+}
+
+/** The framed council card: the member grid or stack, with the synthesis run full width under it. */
+export function renderCouncilCard(group: CouncilGroupView, width: number): string[] {
+	const theme = clioTheme();
+	const contentWidth = Math.max(0, width - 4);
+	const title = `${theme.fg("info", "council")} ${theme.paint(group.group, { bold: true })}`;
+	return frame(theme, title, councilGroupBody(theme, group, contentWidth), width, { rightMeta: group.elapsed });
+}
+
 export function formatDispatchBoardLines(
 	rows: ReadonlyArray<DispatchBoardRow>,
 	width = 76,
 	observability?: ObservabilitySnapshot,
 	selectedRunId?: string | null,
+	/** Whether the selected row renders its worker-progress detail. Off by default. */
+	detailExpanded = false,
 ): string[] {
 	if (rows.length === 0) {
 		const theme = clioTheme();
@@ -620,10 +949,15 @@ export function formatDispatchBoardLines(
 		});
 	}
 
-	const cards = rows.map((row) =>
-		renderDispatchCard(row, width, deriveRunEvidenceState(observability, row.runId), {
-			selected: row.runId === selectedRunId,
-		}),
+	// A council is one question asked of several members, so its rows render as
+	// one card holding the whole group rather than as unrelated neighbours.
+	const cards = dispatchBoardItems(rows, selectedRunId).map((item) =>
+		item.kind === "council"
+			? renderCouncilCard(item.group, width)
+			: renderDispatchCard(item.row, width, deriveRunEvidenceState(observability, item.row.runId), {
+					selected: item.row.runId === selectedRunId,
+					expanded: detailExpanded && item.row.runId === selectedRunId,
+				}),
 	);
 	const body: string[] = [];
 	for (const card of cards) {
@@ -648,6 +982,9 @@ export interface DispatchBoardView extends Component {
 	selectPrevious(): void;
 	selectNext(): void;
 	resetSelection(): void;
+	/** Open or close the selected row's worker-progress detail. */
+	toggleDetail(): void;
+	detailExpanded(): boolean;
 }
 
 export function createDispatchBoardView(
@@ -655,6 +992,9 @@ export function createDispatchBoardView(
 	observability: () => ObservabilitySnapshot | undefined,
 ): DispatchBoardView {
 	let selectedRunId: string | null = null;
+	// Detail is a property of the operator's attention, not of a run, so it
+	// follows the cursor rather than pinning to the row it was opened on.
+	let expanded = false;
 
 	const normalizeSelection = (currentRows: ReadonlyArray<DispatchBoardRow>): DispatchBoardRow | null => {
 		if (currentRows.length === 0) {
@@ -679,7 +1019,7 @@ export function createDispatchBoardView(
 		render(width: number): string[] {
 			const currentRows = rows();
 			normalizeSelection(currentRows);
-			return formatDispatchBoardLines(currentRows, Math.max(1, width), observability(), selectedRunId);
+			return formatDispatchBoardLines(currentRows, Math.max(1, width), observability(), selectedRunId, expanded);
 		},
 		selectedRow(): DispatchBoardRow | null {
 			return normalizeSelection(rows());
@@ -692,30 +1032,44 @@ export function createDispatchBoardView(
 		},
 		resetSelection(): void {
 			selectedRunId = null;
+			expanded = false;
 			normalizeSelection(rows());
 		},
+		toggleDetail(): void {
+			expanded = !expanded;
+		},
+		detailExpanded(): boolean {
+			return expanded;
+		},
 		invalidate(): void {},
 	};
 }
 
 export function formatTaskIslandLines(rows: ReadonlyArray<DispatchBoardRow>, maxRows = 4): string[] {
-	const visibleRows = rows.slice(0, Math.max(1, maxRows));
+	// Councils are folded before the row cap, so a five-member council costs the
+	// island one card and never crowds out the runs beside it.
+	const items = dispatchBoardItems(rows);
+	const visibleItems = items.slice(0, Math.max(1, maxRows));
 	const body: string[] = [];
 
-	if (visibleRows.length === 0) {
+	if (visibleItems.length === 0) {
 		const theme = clioTheme();
 		body.push(theme.fg("dim", "No active fleet runs."));
 		body.push(theme.fg("dim", "Use /run or /delegate to spawn agents."));
 	} else {
-		for (let i = 0; i < visibleRows.length; i++) {
-			const row = visibleRows[i];
-			if (!row) continue;
+		for (let i = 0; i < visibleItems.length; i++) {
+			const item = visibleItems[i];
+			if (!item) continue;
 			if (i > 0) {
 				body.push(innerDivider(clioTheme(), TASK_ISLAND_WIDTH));
 			}
-			body.push(...renderTaskIslandRow(row, TASK_ISLAND_WIDTH));
+			body.push(
+				...(item.kind === "council"
+					? councilIslandLines(clioTheme(), item.group, TASK_ISLAND_WIDTH)
+					: renderTaskIslandRow(item.row, TASK_ISLAND_WIDTH)),
+			);
 		}
-		const hidden = rows.length - visibleRows.length;
+		const hidden = items.length - visibleItems.length;
 		if (hidden > 0) {
 			body.push(innerDivider(clioTheme(), TASK_ISLAND_WIDTH));
 			body.push(clioTheme().fg("dim", `+ ${hidden} more`));
@@ -781,6 +1135,21 @@ function parseGateBadge(value: unknown): { role: string; cycle: number } | undef
 	return { role: record.role, cycle };
 }
 
+function parseCouncilBadge(value: unknown): DispatchBoardRow["council"] | undefined {
+	if (typeof value !== "object" || value === null) return undefined;
+	const record = value as { group?: unknown; label?: unknown; color?: unknown; round?: unknown };
+	const group = parseNonEmptyString(record.group);
+	const label = parseNonEmptyString(record.label);
+	const round = parsePositiveInt(record.round);
+	if (group === undefined || label === undefined || round === undefined) return undefined;
+	return {
+		group,
+		label,
+		...(typeof record.color === "string" && record.color.length > 0 ? { color: record.color } : {}),
+		round,
+	};
+}
+
 function parseFiniteNumberOrZero(value: unknown): number {
 	return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
@@ -879,6 +1248,7 @@ function readRunningSnapshot(snapshot: DispatchSnapshot): Map<
 		costUsd: number;
 		costProvenance: CostProvenance;
 		outcomePhase: string;
+		budget?: RunToolBudgetEnvelope;
 	}
 > {
 	const running = new Map<
@@ -890,12 +1260,14 @@ function readRunningSnapshot(snapshot: DispatchSnapshot): Map<
 			costUsd: number;
 			costProvenance: CostProvenance;
 			outcomePhase: string;
+			budget?: RunToolBudgetEnvelope;
 		}
 	>();
 	try {
 		for (const value of snapshot.running) {
 			const runId = parseRunId(value.runId);
 			if (!runId) continue;
+			const budget = cloneRunToolBudgetEnvelope(value.budget);
 			running.set(runId, {
 				inputTokens: parseFiniteNumberOrZero(value.tokens.input),
 				outputTokens: parseFiniteNumberOrZero(value.tokens.output),
@@ -903,6 +1275,7 @@ function readRunningSnapshot(snapshot: DispatchSnapshot): Map<
 				costUsd: parseFiniteNumberOrZero(value.costUsd),
 				costProvenance: value.costProvenance ?? "unknown",
 				outcomePhase: value.outcomePhase,
+				...(budget !== undefined ? { budget } : {}),
 			});
 		}
 	} catch {
@@ -920,7 +1293,9 @@ function resolveElapsedMs(entry: DispatchBoardEntry, now: number): number {
 
 function toRow(entry: DispatchBoardEntry, now: number): DispatchBoardRow {
 	const retry = entry.retry;
+	const progress = entry.progress.snapshot();
 	return {
+		progress,
 		runId: entry.runId,
 		agentId: entry.agentId,
 		...(entry.agentAudience !== undefined ? { agentAudience: entry.agentAudience } : {}),
@@ -930,6 +1305,7 @@ function toRow(entry: DispatchBoardEntry, now: number): DispatchBoardRow {
 		targetId: entry.targetId,
 		wireModelId: entry.wireModelId,
 		...(entry.taskSummary !== undefined ? { taskSummary: entry.taskSummary } : {}),
+		...(entry.budget !== undefined ? { budget: entry.budget } : {}),
 		status: retry ? "retrying" : entry.status,
 		elapsedMs: resolveElapsedMs(entry, now),
 		tokenCount: entry.tokenCount,
@@ -941,13 +1317,18 @@ function toRow(entry: DispatchBoardEntry, now: number): DispatchBoardRow {
 		...(entry.outcomeDetail !== undefined ? { outcomeDetail: entry.outcomeDetail } : {}),
 		...(entry.node !== undefined ? { node: entry.node } : {}),
 		...(entry.gate !== undefined ? { gate: { ...entry.gate } } : {}),
+		...(entry.council !== undefined ? { council: { ...entry.council } } : {}),
+		...(entry.hostVerification !== undefined ? { hostVerification: entry.hostVerification } : {}),
 		...(entry.rerouteCount !== undefined ? { rerouteCount: entry.rerouteCount } : {}),
 		...(entry.failoverHops !== undefined ? { failoverHops: entry.failoverHops } : {}),
 		...(entry.contextWindow !== undefined ? { contextWindow: entry.contextWindow } : {}),
 		lastContextTokens: entry.lastContextTokens,
 		...(entry.receiptId !== undefined ? { receiptId: entry.receiptId } : {}),
-		currentTool: retry ? null : entry.currentTool,
-		recentTools: [...entry.recentTools],
+		...(entry.phase !== undefined ? { phase: { ...entry.phase } } : {}),
+		// Both tool fields are views of the one projection, so the compact card and
+		// the expanded detail can never disagree about what is running.
+		currentTool: retry ? null : (progress.currentAction?.tool ?? null),
+		recentTools: progress.recentActions.map((action) => action.tool),
 		...(retry ? { retry: { ...retry } } : {}),
 		...(entry.steerAcknowledgement ? { steerAcknowledgement: { ...entry.steerAcknowledgement } } : {}),
 	};
@@ -964,7 +1345,7 @@ function sortEntries(a: DispatchBoardEntry, b: DispatchBoardEntry): number {
 	return a.sequence - b.sequence;
 }
 
-function pruneEntries(entries: Map<string, DispatchBoardEntry>): void {
+function pruneEntries(entries: Map<string, DispatchBoardEntry>, onEvict?: (runId: string) => void): void {
 	if (entries.size <= MAX_DISPATCH_BOARD_ROWS) return;
 	const terminalEntries = [...entries.values()]
 		.filter((entry) => !entry.retry && isTerminalStatus(entry.status))
@@ -974,22 +1355,49 @@ function pruneEntries(entries: Map<string, DispatchBoardEntry>): void {
 	for (const entry of evictionQueue) {
 		if (entries.size <= MAX_DISPATCH_BOARD_ROWS) break;
 		entries.delete(entry.runId);
+		onEvict?.(entry.runId);
 	}
 }
 
 export function createDispatchBoardStore(
 	bus: SafeEventBus,
 	snapshot?: () => DispatchSnapshot,
+	/**
+	 * Sealed terminal facts for a finished run. Settlement replaces the
+	 * provisional live tail with the receipt's answer where one can be read; the
+	 * run's own durable message stands in where it cannot.
+	 */
+	readReceipt?: WorkerReceiptReader,
 ): {
 	rows(): ReadonlyArray<DispatchBoardRow>;
 	activeRows(): ReadonlyArray<DispatchBoardRow>;
 	reconcile(): void;
+	/**
+	 * Record the fleet-plan position of a run the caller just dispatched. The
+	 * board never infers a position: a run carries one only because whoever
+	 * dispatched the plan said so, which is why a non-fleet run can never grow
+	 * a phase cell.
+	 */
+	setFleetPhase(runId: string, phase: DispatchBoardPhase): void;
 	unsubscribe(): void;
 } {
 	const entries = new Map<string, DispatchBoardEntry>();
+	// Positions arrive from the fleet-run path, which may hand one over before
+	// the run's first lifecycle event creates the entry.
+	const fleetPhases = new Map<string, DispatchBoardPhase>();
 	let nextSequence = 0;
 	let reconciledAtMs = Date.now();
 
+	/**
+	 * Seal a run's projection on the sealed receipt's answer. Only for the
+	 * terminal bus events: the dispatch domain writes `receipts/<runId>.json`
+	 * before it publishes one, so this is the first moment the file exists.
+	 */
+	const settleFromReceipt = (entry: DispatchBoardEntry): void => {
+		const text = readReceipt?.(entry.runId)?.text;
+		entry.progress.settle(typeof text === "string" && text.trim().length > 0 ? text : undefined);
+	};
+
 	// Payloads arrive typed off the bus, but the board keeps its runtime
 	// parsing (parse* helpers) because events are not validated at runtime.
 	const upsertBase = (
@@ -1004,9 +1412,12 @@ export function createDispatchBoardStore(
 		const requestOrigin = parseRequestOrigin(raw.requestOrigin, previous?.requestOrigin);
 		const node = parseNonEmptyString(raw.node) ?? previous?.node;
 		const gate = parseGateBadge(raw.gate) ?? previous?.gate;
+		const council = parseCouncilBadge(raw.council) ?? previous?.council;
 		const rerouteCount = parsePositiveInt(raw.rerouteCount) ?? previous?.rerouteCount;
 		const contextWindow = parsePositiveInt(raw.contextWindow) ?? previous?.contextWindow;
 		const taskSummary = parseTaskSummary(raw, previous?.taskSummary);
+		const budget = cloneRunToolBudgetEnvelope(raw.budget) ?? previous?.budget;
+		const phase = fleetPhases.get(runId) ?? previous?.phase;
 		const entry: DispatchBoardEntry = {
 			runId,
 			agentId: parseText(raw.agentId, previous?.agentId ?? "-"),
@@ -1017,6 +1428,7 @@ export function createDispatchBoardStore(
 			targetId: parseText(raw.targetId, previous?.targetId ?? "-"),
 			wireModelId: parseText(raw.wireModelId, previous?.wireModelId ?? "-"),
 			...(taskSummary !== undefined ? { taskSummary } : {}),
+			...(budget !== undefined ? { budget } : {}),
 			status,
 			tokenCount: previous?.tokenCount ?? 0,
 			costUsd: previous?.costUsd ?? 0,
@@ -1033,17 +1445,19 @@ export function createDispatchBoardStore(
 			outcomeDetail: previous?.outcomeDetail ?? null,
 			...(node !== undefined ? { node } : {}),
 			...(gate !== undefined ? { gate } : {}),
+			...(council !== undefined ? { council } : {}),
+			...(previous?.hostVerification !== undefined ? { hostVerification: previous.hostVerification } : {}),
 			...(rerouteCount !== undefined ? { rerouteCount } : {}),
 			...(contextWindow !== undefined ? { contextWindow } : {}),
 			lastContextTokens: previous?.lastContextTokens ?? 0,
 			...(previous?.receiptId !== undefined ? { receiptId: previous.receiptId } : {}),
-			currentTool: previous?.currentTool ?? null,
-			recentTools: previous?.recentTools ?? [],
+			...(phase !== undefined ? { phase } : {}),
+			progress: previous?.progress ?? createWorkerProgressFold(),
 			...(previous?.retry ? { retry: { ...previous.retry } } : {}),
 			...(previous?.steerAcknowledgement ? { steerAcknowledgement: { ...previous.steerAcknowledgement } } : {}),
 		};
 		entries.set(runId, entry);
-		pruneEntries(entries);
+		pruneEntries(entries, (evicted) => fleetPhases.delete(evicted));
 		return entry;
 	};
 
@@ -1074,7 +1488,8 @@ export function createDispatchBoardStore(
 			entry.costUsd = parseFiniteNumber(payload.costUsd, entry.costUsd);
 			entry.costProvenance = payload.costProvenance ?? "unknown";
 			entry.outcomeDetail = null;
-			entry.currentTool = null;
+			if (payload.hostVerification !== undefined) entry.hostVerification = payload.hostVerification;
+			settleFromReceipt(entry);
 			// A terminal dispatch event is published only after the run's receipt is
 			// sealed at receipts/<runId>.json, so the run id is the receipt id here.
 			entry.receiptId = entry.runId;
@@ -1102,7 +1517,8 @@ export function createDispatchBoardStore(
 			entry.costUsd = parseFiniteNumber(payload.costUsd, entry.costUsd);
 			entry.costProvenance = payload.costProvenance ?? "unknown";
 			entry.outcomeDetail = resolveFailureDetail(payload, entry.outcomeDetail);
-			entry.currentTool = null;
+			if (payload.hostVerification !== undefined) entry.hostVerification = payload.hostVerification;
+			settleFromReceipt(entry);
 			// A denied retry never reached a run, so no receipt was sealed for it;
 			// every other failure finalized through recordReceipt like a success.
 			if (payload.reason !== "retry_denied") entry.receiptId = entry.runId;
@@ -1126,7 +1542,7 @@ export function createDispatchBoardStore(
 				// wind down, so the history row can become terminal immediately.
 				entry.status = "aborted";
 				entry.finishedAtMs = Date.now();
-				entry.currentTool = null;
+				entry.progress.settle();
 			} else {
 				if (isTerminalStatus(entry.status) && !wasRetrying) return;
 				entry.status = "cancelling";
@@ -1148,7 +1564,10 @@ export function createDispatchBoardStore(
 				entry.status = status;
 				if (status === "dead") {
 					entry.finishedAtMs ??= Date.now();
-					entry.currentTool = null;
+					// A worker-side terminal signal arrives before any receipt is
+					// sealed, so the run's own last durable message is the best truth
+					// there is; the terminal bus event replaces it with the sealed one.
+					entry.progress.settle();
 					delete entry.retry;
 				}
 				return;
@@ -1159,7 +1578,9 @@ export function createDispatchBoardStore(
 				entry.failoverHops = (entry.failoverHops ?? 0) + 1;
 				entry.status = "running";
 				entry.finishedAtMs = null;
-				entry.currentTool = null;
+				// The projection keeps the tail the operator is reading and drops the
+				// finished attempt's live state, exactly as the transcript block does.
+				entry.progress.restart();
 				delete entry.retry;
 				return;
 			}
@@ -1183,20 +1604,10 @@ export function createDispatchBoardStore(
 					entry.ttftMs = Math.round(performance.now() - entry.startedAtClockMs);
 				}
 			}
-			if (type === "clio_tool_start") {
-				const payload = (workerEvent as { payload?: { tool?: unknown } }).payload;
-				const tool = parseNonEmptyString(payload?.tool);
-				if (tool !== undefined) entry.currentTool = tool;
-			}
-			if (type === "clio_tool_finish") {
-				const payload = (workerEvent as { payload?: { tool?: unknown } }).payload;
-				const tool = parseNonEmptyString(payload?.tool);
-				entry.currentTool = null;
-				if (tool !== undefined) {
-					entry.recentTools.unshift(tool);
-					if (entry.recentTools.length > RECENT_TOOL_TRAIL_LIMIT) entry.recentTools.length = RECENT_TOOL_TRAIL_LIMIT;
-				}
-			}
+			// The one fold that reads worker prose and tool activity. Everything the
+			// board says about what a worker is saying or touching comes from here,
+			// so the board and the transcript block cannot tell two stories.
+			entry.progress.observe(payload.event);
 			if (type === "clio_steer_received") {
 				const steerPayload = (workerEvent as { payload?: { chars?: unknown } }).payload;
 				entry.steerAcknowledgement = {
@@ -1221,7 +1632,10 @@ export function createDispatchBoardStore(
 				if (!status) return;
 				entry.status = status;
 				entry.finishedAtMs ??= Date.now();
-				entry.currentTool = null;
+				// The worker says it is done before the domain seals its receipt. Settle
+				// on the durable message now so the card stops reading as live; the
+				// terminal bus event seals it on the receipt shortly after.
+				entry.progress.settle();
 				delete entry.retry;
 			}
 		}),
@@ -1270,7 +1684,8 @@ export function createDispatchBoardStore(
 					now,
 				);
 			if (entry) {
-				entry.currentTool = null;
+				// A waiting retry has no live worker; the row projection already
+				// renders a retrying row with no current tool.
 				entry.retry = { ...projection.retry };
 				if (entry.taskSummary === undefined && projection.taskSummary !== undefined) {
 					entry.taskSummary = projection.taskSummary;
@@ -1286,6 +1701,7 @@ export function createDispatchBoardStore(
 			entry.tokenCount = live.tokenCount;
 			entry.costUsd = live.costUsd;
 			entry.costProvenance = live.costProvenance;
+			if (live.budget !== undefined) entry.budget = live.budget;
 			if (live.outcomePhase === "aborting") {
 				if (entry.status !== "completed" && entry.status !== "aborted") {
 					entry.status = "cancelling";
@@ -1310,6 +1726,11 @@ export function createDispatchBoardStore(
 			return projectRows(true);
 		},
 		reconcile,
+		setFleetPhase(runId: string, phase: DispatchBoardPhase): void {
+			fleetPhases.set(runId, phase);
+			const entry = entries.get(runId);
+			if (entry) entry.phase = { ...phase };
+		},
 		unsubscribe() {
 			if (closed) return;
 			closed = true;