@iowarp/clio-coder 0.3.6 → 0.3.8

package/src/interactive/dispatch-board.ts

@@ -24,6 +24,11 @@ import {
 	type RunStatus,
 	runKindSupportsLiveSteering,
 } from "../domains/dispatch/types.js";
+import {
+	summarizeTrustStatus,
+	type TrustSummaryProjection,
+	type TrustVerdict,
+} from "../domains/evidence/trust-projection.js";
 import {
 	COST_NOT_MEASURED,
 	costAggregateForAmount,
@@ -35,6 +40,13 @@ import type { CostProvenance } from "../domains/providers/index.js";
 import { sanitizeCallTargetText } from "../domains/safety/call-target.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,
@@ -103,6 +115,16 @@ 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";
+	/**
+	 * The canonical trust projection of the sealed receipt, read back from
+	 * disk and authenticated against the ledger row. Absent while the run is
+	 * live or when the receipt could not be read back, so the card never
+	 * implies a verdict the terminal bus event cannot carry.
+	 */
+	trust?: TrustSummaryProjection;
 	/** Dead-node failover hops recorded on this run's chain. */
 	rerouteCount?: number;
 	/** Assignment retry attempts observed on the assignment event stream. */
@@ -134,8 +156,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 (
@@ -610,14 +663,34 @@ export function renderDispatchCard(
 		`${theme.fg("dim", "ttft")} ${theme.fg("muted", ttft)}`,
 		`${theme.fg("dim", "cost")} ${theme.fg("muted", cost)}`,
 	];
+	// The trust line is the canonical projection, styled by its verdict tier;
+	// a host check is folded into that projection as validation grounding, so
+	// it is named as a secondary fact and never as independent verification.
+	const trustUnits = [
+		row.trust === undefined
+			? theme.fg("dim", isTerminalStatus(row.status) ? "trust: receipt not read back" : "trust: not sealed yet")
+			: theme.fg(trustVerdictToken(row.trust.verdict), `${trustVerdictGlyph(row.trust.verdict)} ${row.trust.text}`),
+		...(row.hostVerification !== undefined ? [theme.fg("muted", `host checks ${row.hostVerification}`)] : []),
+	];
 	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, "trust", trustUnits, contentWidth),
 		...(row.budget !== undefined
 			? [
 					truncateToWidth(
@@ -715,11 +788,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;
@@ -740,6 +827,131 @@ 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,
@@ -757,11 +969,15 @@ export function formatDispatchBoardLines(
 		});
 	}
 
-	const cards = rows.map((row) =>
-		renderDispatchCard(row, width, deriveRunEvidenceState(observability, row.runId), {
-			selected: row.runId === selectedRunId,
-			expanded: detailExpanded && 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) {
@@ -850,23 +1066,30 @@ export function createDispatchBoardView(
 }
 
 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`));
@@ -932,6 +1155,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;
 }
@@ -942,6 +1180,33 @@ function parseOptionalDetail(value: unknown): string | null {
 	return detail.length > 0 ? detail : null;
 }
 
+/** Only an authenticated independent pass earns the success token; sealed alone is never green. */
+function trustVerdictToken(verdict: TrustVerdict): ClioToken {
+	switch (verdict) {
+		case "reviewed":
+			return "success";
+		case "grounded":
+			return "info";
+		case "unverified":
+			return "muted";
+		case "compromised":
+			return "error";
+		default:
+			return "dim";
+	}
+}
+
+function trustVerdictGlyph(verdict: TrustVerdict): string {
+	switch (verdict) {
+		case "reviewed":
+			return GLYPH.ok;
+		case "compromised":
+			return GLYPH.error;
+		default:
+			return "◇";
+	}
+}
+
 function terminalDetail(row: DispatchBoardRow): string | null {
 	if (row.status !== "failed" && row.status !== "dead" && row.status !== "aborted") return null;
 	return parseOptionalDetail(row.outcomeDetail);
@@ -1099,11 +1364,15 @@ 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.trust !== undefined ? { trust: entry.trust } : {}),
 		...(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 } : {}),
+		...(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),
@@ -1124,7 +1393,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))
@@ -1134,6 +1403,7 @@ 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);
 	}
 }
 
@@ -1150,9 +1420,19 @@ export function createDispatchBoardStore(
 	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();
 
@@ -1162,8 +1442,10 @@ export function createDispatchBoardStore(
 	 * before it publishes one, so this is the first moment the file exists.
 	 */
 	const settleFromReceipt = (entry: DispatchBoardEntry): void => {
-		const text = readReceipt?.(entry.runId)?.text;
+		const facts = readReceipt?.(entry.runId);
+		const text = facts?.text;
 		entry.progress.settle(typeof text === "string" && text.trim().length > 0 ? text : undefined);
+		if (facts?.trust !== undefined) entry.trust = summarizeTrustStatus(facts.trust);
 	};
 
 	// Payloads arrive typed off the bus, but the board keeps its runtime
@@ -1180,10 +1462,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 ?? "-"),
@@ -1211,16 +1495,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 } : {}),
+			...(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;
 	};
 
@@ -1251,6 +1538,7 @@ export function createDispatchBoardStore(
 			entry.costUsd = parseFiniteNumber(payload.costUsd, entry.costUsd);
 			entry.costProvenance = payload.costProvenance ?? "unknown";
 			entry.outcomeDetail = 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.
@@ -1279,6 +1567,7 @@ export function createDispatchBoardStore(
 			entry.costUsd = parseFiniteNumber(payload.costUsd, entry.costUsd);
 			entry.costProvenance = payload.costProvenance ?? "unknown";
 			entry.outcomeDetail = resolveFailureDetail(payload, entry.outcomeDetail);
+			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.
@@ -1487,6 +1776,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;