@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/src/tui/agent-dock.ts

@@ -0,0 +1,250 @@
+import { hasText, nonemptyText } from "./text-values.ts";
+import { type Theme, rawKeyHint } from "@earendil-works/pi-coding-agent";
+import {
+  MouseRegion,
+  truncateToWidth,
+  visibleWidth,
+  type Component,
+  type TUI,
+} from "@earendil-works/pi-tui";
+import type { ReadonlyInput, AsyncJobState, HistoryRunPage } from "../shared/types.ts";
+import { getSingleResultOutput } from "../shared/utils.ts";
+import { readableText } from "./agent-history.ts";
+import { buildWidgetLines } from "./render.ts";
+import {
+  UNAVAILABLE_ASSIGNMENT,
+  activity,
+  short,
+  taskSummary,
+  runningIndicator,
+  type AgentTask,
+} from "./view-model.ts";
+interface DockSource {
+  readonly tasks: () => readonly AgentTask[];
+  readonly pinned: () => AgentTask | undefined;
+  readonly page: () => ReadonlyInput<HistoryRunPage> | undefined;
+  readonly error: () => string | undefined;
+  readonly loading: () => boolean;
+  readonly jobs: () => ReadonlyInput<AsyncJobState[]>;
+  readonly expanded: () => boolean;
+  readonly below: () => readonly Component[];
+  readonly shortcut: string;
+  readonly live: () => boolean;
+  readonly unpin: () => void;
+  readonly open: (key?: string) => void;
+}
+type DockState = "needs action" | "waiting" | "running";
+interface DockRow {
+  readonly task: Readonly<AgentTask>;
+  readonly state: DockState;
+}
+interface Hit {
+  readonly start: number;
+  readonly end: number;
+  readonly key?: string;
+  readonly unpin?: boolean;
+  readonly row: number;
+}
+const STYLES = {
+  running: { color: "success", symbol: "●" },
+  waiting: { color: "dim", symbol: "◷" },
+  "needs action": { color: "warning", symbol: "!" },
+} as const;
+function dockState(task: Readonly<AgentTask>): DockState {
+  if (task.child.state === "blocked" || task.question?.state === "awaiting_input") {
+    return "needs action";
+  }
+  return task.child.activity?.status === "pending" || task.question?.state === "answer_pending"
+    ? "waiting"
+    : "running";
+}
+function pinnedPreview(task: Readonly<AgentTask>): string {
+  if (task.child.identityUnavailable === true) {
+    return UNAVAILABLE_ASSIGNMENT;
+  }
+  if (task.child.state === "live") {
+    return activity(task);
+  }
+  const result = task.child.result;
+  return (
+    (result && nonemptyText(getSingleResultOutput(result))) ??
+    nonemptyText(task.history.findLast((item) => item.kind === "assistant")?.text) ??
+    activity(task)
+  );
+}
+export class AgentDock {
+  private hits: Hit[] = [];
+  readonly component: Component;
+  private readonly tui: TUI;
+  private readonly theme: Theme;
+  private readonly source: DockSource;
+  constructor(tui: TUI, theme: Theme, source: DockSource) {
+    this.tui = tui;
+    this.theme = theme;
+    this.source = source;
+    this.component = new MouseRegion(
+      {
+        render: (width) => this.render(width),
+        invalidate() {
+          /* Current source/theme are read on every render. */
+        },
+      },
+      (event) => {
+        if (tui.mode !== "fullscreen" || event.button !== "left" || !source.live()) {
+          return;
+        }
+        const hit = this.hits.find(
+          (candidate) =>
+            candidate.row === event.y && event.x >= candidate.start && event.x < candidate.end,
+        );
+        if (!hit) {
+          return;
+        }
+        if (event.type === "press") {
+          return { handled: true };
+        }
+        if (event.type !== "click") {
+          return;
+        }
+        if (hit.unpin === true) {
+          source.unpin();
+        } else {
+          source.open(hit.key);
+        }
+        return { handled: true };
+      },
+    );
+  }
+  private empty(width: number): string[] {
+    const failed = hasText(this.source.error());
+    if (
+      !failed &&
+      !this.source.loading() &&
+      this.source.page()?.freshness.state !== "catching-up"
+    ) {
+      return [];
+    }
+    const label = failed
+      ? "Agents history unavailable · /agents to retry"
+      : "Agents · loading history…";
+    this.hits.push({ start: 0, end: width, row: 0 });
+    return [truncateToWidth(this.theme.fg(failed ? "warning" : "dim", label), width)];
+  }
+  private heading(active: readonly DockRow[], width: number): string {
+    const running = active.filter((row) => row.state === "running").length;
+    const waiting = active.filter((row) => row.state === "waiting").length;
+    const needsAction = active.filter((row) => row.state === "needs action").length;
+    const counts = `${running} running${waiting > 0 ? ` · ${waiting} waiting` : ""}${needsAction > 0 ? ` · ${needsAction} needs action` : ""}`;
+    const hint = readableText(rawKeyHint(this.source.shortcut, "")).trim();
+    const entrance = `${this.theme.fg("accent", this.theme.bold("Agents"))} · ${this.theme.fg(running > 0 ? "success" : "muted", counts)} ${this.theme.fg("dim", `[${hint}]`)}`;
+    this.hits.push({ start: 0, end: Math.min(width, visibleWidth(entrance)), row: 0 });
+    return truncateToWidth(entrance, width);
+  }
+  private pulseFrom(rows: number, width: number): number {
+    if (this.tui.mode !== "regular") {
+      return 0;
+    }
+    // MainScreen repaints all scrollback if an offscreen row's ANSI changes.
+    return (
+      rows +
+      this.source.below().reduce((height, child) => height + child.render(width).length, 0) -
+      this.tui.terminal.rows
+    );
+  }
+  private row(row: DockRow, width: number, pulse: boolean): string {
+    const { task, state } = row,
+      { color, symbol } = STYLES[state];
+    const indicator =
+      state === "running" && pulse ? runningIndicator(this.theme) : this.theme.fg(color, symbol);
+    const { status, badge } = taskSummary(task);
+    const statusText = status === "working" ? "" : this.theme.fg(color, ` · ${status}`);
+    const available = width - visibleWidth(statusText + badge) - 4;
+    const modelWidth = available - Math.min(30, visibleWidth(task.label)) - 3;
+    const model = modelWidth >= 16 ? ` · ${short(task.model.summary, modelWidth)}` : "";
+    const label = short(task.label, Math.max(1, available - visibleWidth(model)));
+    return truncateToWidth(
+      `  ${indicator} ${this.theme.bold(label)}${statusText}${this.theme.fg("accent", badge)}${this.theme.fg("dim", model)}`,
+      width,
+    );
+  }
+  private more(count: number, width: number, row: number): string | undefined {
+    if (count <= 0) {
+      return;
+    }
+    const more = `  +${count} more · /agents`,
+      line = truncateToWidth(more, width, "...");
+    this.hits.push({
+      start: 2,
+      end: visibleWidth(line) - (visibleWidth(more) > width ? 3 : 0),
+      row,
+    });
+    return this.theme.fg("dim", line);
+  }
+  private pin(
+    task: Readonly<AgentTask> | undefined,
+    width: number,
+    row: number,
+  ): string | undefined {
+    if (!task) {
+      return;
+    }
+    const unpin = "[Unpin] ";
+    const text = this.theme.fg(
+      "dim",
+      truncateToWidth(
+        `${unpin}Pinned · ${task.child.state === "completed" ? "finished · " : ""}${short(task.label, 30)}: ${short(pinnedPreview(task), width)}`,
+        width,
+      ),
+    );
+    this.hits.push(
+      { start: 0, end: unpin.length, row, unpin: true },
+      { start: unpin.length, end: width, row, key: task.key },
+    );
+    return text;
+  }
+  private render(width: number): string[] {
+    this.hits = [];
+    const active = this.source
+      .tasks()
+      .filter(
+        (task) =>
+          task.child.state === "live" ||
+          task.child.state === "blocked" ||
+          task.question !== undefined,
+      )
+      .map((task) => ({ task, state: dockState(task) }));
+    if (active.length === 0) {
+      return this.empty(width);
+    }
+    const lines = [this.heading(active, width)];
+    const visible = active.slice(
+      0,
+      Math.max(1, Math.min(4, Math.floor(this.tui.terminal.rows / 5))),
+    );
+    const pinned = this.source.pinned();
+    const details = this.source.expanded()
+      ? buildWidgetLines([...this.source.jobs()], this.theme, width, true)
+      : [];
+    const pulse = this.pulseFrom(
+      visible.length +
+        details.length +
+        Number(pinned !== undefined) +
+        Number(visible.length < active.length),
+      width,
+    );
+    for (const [index, row] of visible.entries()) {
+      this.hits.push({ start: 0, end: width, row: lines.length, key: row.task.key });
+      lines.push(this.row(row, width, index >= pulse));
+    }
+    const more = this.more(active.length - visible.length, width, lines.length);
+    if (more !== undefined) {
+      lines.push(more);
+    }
+    const pin = this.pin(pinned, width, lines.length);
+    if (pin !== undefined) {
+      lines.push(pin);
+    }
+    lines.push(...details);
+    return lines;
+  }
+}

package/src/tui/agent-history.ts

@@ -1,210 +1,85 @@
-import type { AssistantMessage, ToolCall, ToolResultMessage } from "@earendil-works/pi-ai";
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
-import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { stripAcceptanceReport } from "../runs/shared/acceptance-reports.ts";
-import type { SubagentHistoryIndex, HistoryEntry, HistoryPage, HistoryPageInput } from "../history/index.ts";
-import { extractToolArgsPreview } from "../shared/utils.ts";
+import { displayHistory, type AgentHistory, type AgentHistoryItem } from "./history-display.ts";
+import type { DisplayEntry } from "./history-record.ts";
+import { readableText } from "./history-text.ts";
+export { readableText } from "./history-text.ts";
+export { indexedHistory } from "./indexed-history.ts";
+export type { AgentHistory, AgentHistoryItem } from "./history-display.ts";
 
-export interface AgentHistoryItem {
-	id: string;
-	/** Native IDs combined into this message or tool card, including old standalone result IDs. */
-	entryIds?: string[];
-	kind: "user" | "assistant" | "thinking" | "tool" | "result" | "change" | "notice";
-	title: string;
-	text: string;
-	details?: string;
-	diff?: string;
-	assistant?: AssistantMessage;
-	model?: string;
-	call?: ToolCall;
-	result?: ToolResultMessage;
-	messageId?: string;
-	timestamp: number;
-	/** Explicit detail request; normal history uses bounded previews. */
-	load?: () => Promise<AgentHistoryItem>;
+/** Read native entries, not a compacted model context: earlier messages remain inspectable. */
+export function historyItems(entries: readonly SessionEntry[]): AgentHistory {
+  const visible: DisplayEntry[] = [];
+  for (const entry of entries) {
+    if (
+      entry.type === "message" ||
+      entry.type === "custom_message" ||
+      entry.type === "compaction" ||
+      entry.type === "branch_summary"
+    ) {
+      visible.push(entry.type === "message" ? { ...entry, native: entry.message } : entry);
+    }
+  }
+  return displayHistory(visible);
 }
-
-export interface AgentHistory {
-	items: AgentHistoryItem[];
-	/** Original entry order, independent of where paired tool results are drawn. */
-	entryIds: string[];
-	finalId?: string;
-	findFinalResult?: (text: string) => string | undefined;
-	/** Delivered human message IDs and whether a saved assistant reply follows them. */
-	deliveredMessages?: Map<string, boolean>;
-	configuration?: { model?: string; thinking?: string; modelRecordedAt?: number };
-	unavailable?: string;
-}
-
-export function readableText(value: unknown): string {
-	return stripTerminalSequences(typeof value === "string" ? value : JSON.stringify(value, null, 2) ?? "");
-}
-
-function contentText(content: unknown): string {
-	if (typeof content === "string") return readableText(content);
-	if (!Array.isArray(content)) return readableText(content);
-	return content.map((part) => part.type === "text" ? readableText(part.text)
-		: part.type === "thinking" ? readableText(part.thinking)
-		: part.type === "image" ? `[Image: ${part.mimeType ?? "image"}]` : "").filter(Boolean).join("\n");
-}
-
-function resultDisplay(result: ToolResultMessage, call?: ToolCall) {
-	const details = result.details as { diff?: unknown } | undefined;
-	return { text: contentText(result.content), diff: typeof details?.diff === "string" ? readableText(details.diff) : undefined,
-		details: readableText({ ...(call ? { call } : {}), result }) };
+function finalMatch(history: AgentHistory, text: string): string | undefined {
+  if (history.finalId !== undefined) {
+    return history.finalId;
+  }
+  if (history.findFinalResult) {
+    return history.findFinalResult(text);
+  }
+  return history.items.findLast(
+    (item) =>
+      item.kind === "assistant" &&
+      (stripAcceptanceReport(item.text).trim() === text ||
+        item.assistant?.content.some(
+          (part) =>
+            part.type === "text" && stripAcceptanceReport(readableText(part.text)).trim() === text,
+        ) === true),
+  )?.id;
 }
-
-/** Keep reading/delivery facts eager; format bodies and raw tool details only when displayed. */
-function historyItem(
-	facts: Omit<AgentHistoryItem, "text" | "title">,
-	format: () => Pick<AgentHistoryItem, "text" | "title" | "details" | "diff">,
-): AgentHistoryItem {
-	let display: ReturnType<typeof format> | undefined;
-	return {
-		...facts,
-		get title() { return (display ??= format()).title; },
-		get text() { return (display ??= format()).text; },
-		get details() { return (display ??= format()).details; },
-		get diff() { return (display ??= format()).diff; },
-	};
-}
-
-/** Read the native entries, not a compacted model context: earlier messages remain inspectable. */
-export function historyItems(entries: SessionEntry[]): AgentHistory {
-	const items: AgentHistoryItem[] = [], entryIds: string[] = [];
-	const calls = new Map<string, AgentHistoryItem>();
-	const append = (item: AgentHistoryItem) => { items.push(item); entryIds.push(item.id); };
-	for (const entry of entries) {
-		const base = { id: entry.id, timestamp: Date.parse(entry.timestamp) };
-		if (entry.type === "custom_message") {
-			const details = entry.details as { bodyText?: string; message?: { id?: string }; from?: { name?: string } } | undefined;
-			const human = entry.customType === "subagent-human-message";
-			append(historyItem({ ...base, kind: human ? "user" : "notice", ...(human ? { messageId: details?.message?.id } : {}) },
-				() => ({ title: human ? "User · delivered to conversation" : details?.from?.name ? `From ${details.from.name}` : entry.customType, text: contentText(details?.bodyText ?? entry.content) })));
-		} else if (entry.type === "compaction") {
-			append(historyItem({ ...base, kind: "notice" }, () => ({ title: "Context summary · earlier history retained above", text: readableText(entry.summary) })));
-		} else if (entry.type === "branch_summary") {
-			append(historyItem({ ...base, kind: "notice" }, () => ({ title: "Branch summary", text: readableText(entry.summary) })));
-		} else if (entry.type === "message") {
-			const message = entry.message;
-			if (message.role === "assistant") {
-				const model = message.model ? (message.provider ? `${message.provider}/${message.model}` : message.model) : undefined;
-				const messageIds = message.content.flatMap((part, index) => part.type === "text" && part.text || part.type === "thinking" && part.thinking ? [`${entry.id}:${index}`] : []);
-				if (messageIds.length) items.push(historyItem({ ...base, id: messageIds[0]!, entryIds: messageIds,
-					kind: message.content.some((part) => part.type === "text" && part.text) ? "assistant" : "thinking",
-					assistant: message, model }, () => ({ title: "Agent", text: contentText(message.content) })));
-				for (const [index, part] of message.content.entries()) {
-					const id = `${entry.id}:${index}`;
-					if (part.type === "toolCall") {
-						const item = historyItem({ ...base, id, entryIds: [id], kind: "tool", call: part, model }, () => ({
-							title: `${part.name} ${extractToolArgsPreview(part.arguments ?? {})}`.trim() + (item.result ? ` · ${item.result.isError ? "failed" : "result recorded"}` : " · result not recorded"),
-							...(item.result ? resultDisplay(item.result, part) : {
-								text: readableText(part.arguments),
-								details: `${readableText(part)}\n\nCommand result not recorded; exit is unconfirmed. An agent pause or exit does not prove that a command or its descendants exited.`,
-							}),
-						}));
-						append(item); calls.set(part.id, item);
-					} else if (messageIds.includes(id)) entryIds.push(id);
-				}
-				if (message.errorMessage) {
-					const id = `${entry.id}:error`;
-					if (messageIds.length && !message.content.some((part) => part.type === "toolCall") && ["error", "aborted"].includes(message.stopReason)) { messageIds.push(id); entryIds.push(id); }
-					else append(historyItem({ ...base, id, kind: "notice", model }, () => ({ title: "Agent error", text: readableText(message.errorMessage) })));
-				}
-			} else if (message.role === "user") {
-				append(historyItem({ ...base, kind: "user" }, () => ({ title: "User / assignment", text: contentText(message.content) })));
-			} else if (message.role === "toolResult") {
-				const call = calls.get(message.toolCallId);
-				if (call) {
-					call.result = message;
-					call.entryIds!.push(entry.id); entryIds.push(entry.id);
-				} else append(historyItem({ ...base, result: message, kind: "result" }, () => ({
-					title: `${message.toolName} · call not recorded`, ...resultDisplay(message),
-				})));
-			} else if (message.role === "bashExecution") {
-				append(historyItem({ ...base, kind: "tool" }, () => ({ title: `Shell: ${readableText(message.command)}`, text: `${readableText(message.output)}\n${typeof message.exitCode === "number" ? `Shell exit code: ${message.exitCode}` : "Shell exit code not recorded"}${message.cancelled ? " · cancelled" : ""}`, details: readableText({ command: message.command, exitCode: message.exitCode, cancelled: message.cancelled }) })));
-			}
-		}
-	}
-	let finalResults: Map<string, string> | undefined;
-	return { items, entryIds, findFinalResult(text) {
-		// Continuations can share a large journal. Index exact, sanitized matches once,
-		// retaining the latest assistant ID just as findLast does.
-		if (!finalResults) {
-			finalResults = new Map();
-			for (const item of items) if (item.kind === "assistant") {
-				finalResults.set(stripAcceptanceReport(item.text).trim(), item.id);
-				for (const part of item.assistant?.content ?? []) if (part.type === "text") finalResults.set(stripAcceptanceReport(readableText(part.text)).trim(), item.id);
-			}
-		}
-		return finalResults.get(text);
-	} };
-}
-
 /** Canonical run output is already validated; never decode arbitrary tool JSON to find an answer. */
-export function withFinalResult(history: AgentHistory, output: string, runId: string, timestamp: number): AgentHistory {
-	const text = readableText(output).trim();
-	if (!text) return history;
-	const matched = history.finalId ?? (history.findFinalResult ? history.findFinalResult(text) : history.items.findLast((item) => item.kind === "assistant" && (stripAcceptanceReport(item.text).trim() === text
-		|| item.assistant?.content.some((part) => part.type === "text" && stripAcceptanceReport(readableText(part.text)).trim() === text)))?.id);
-	const existing = history.items.some((item) => item.id === matched) ? matched : undefined;
-	const id = `result:${runId}`;
-	let items: AgentHistoryItem[] | undefined;
-	return { get items() { return items ??= existing ? history.items.map((item) => item.id === existing ? { ...item, assistant: undefined, text } : item) : [...history.items, { id, kind: "assistant", title: "Saved result", text, timestamp }]; },
-		entryIds: existing ? history.entryIds : [...history.entryIds, id], finalId: existing ?? id,
-		findFinalResult: existing ? history.findFinalResult : (value) => value === text ? id : history.findFinalResult?.(value),
-		deliveredMessages: existing ? history.deliveredMessages : history.deliveredMessages && new Map([...history.deliveredMessages.keys()].map((id) => [id, true])),
-		configuration: history.configuration, get unavailable() { return history.unavailable; } };
-}
-
-/** A page retains only bounded previews; full selected records are validated by the process. */
-export async function indexedHistory(index: SubagentHistoryIndex, input: HistoryPageInput): Promise<{ history: AgentHistory; page: HistoryPage }> {
-	const page = await index.historyPage(input);
-	const entries = new Map(page.entries.map((entry) => [entry.id, entry]));
-	const boundary = { terminalEntryId: input.terminalEntryId, endedAt: input.endedAt };
-	if (input.terminalEntryId && page.terminalSequence === undefined) throw new Error("Saved terminal entry is unavailable; retry history.");
-	const inBoundary = (entry: HistoryEntry) => (page.terminalSequence === undefined || entry.sequence <= page.terminalSequence) && (input.endedAt === undefined || (entry.timestamp ?? Infinity) <= input.endedAt);
-	const tools = new Map<string, { call?: HistoryEntry; result?: HistoryEntry }>();
-	for (const entry of page.entries) {
-		const message = entry.entry.message;
-		if (message?.role === "assistant") for (const part of message.content ?? []) {
-			if (part.type === "toolCall") tools.set(part.id, { ...tools.get(part.id), call: entry });
-		}
-		else if (message?.role === "toolResult") tools.set(message.toolCallId, { ...tools.get(message.toolCallId), result: entry });
-	}
-	// Resolve only tools on this page, not the rest of the conversation. Adjacent-page
-	// pairing preserves physical reading order and never becomes completion evidence.
-	for (const entry of page.entries) {
-		const message = entry.entry.message;
-		const pairs: Array<{ toolCallId: string; kind: "call" | "result" }> = message?.role === "assistant" ? (message.content ?? []).filter((part: ToolCall) => part.type === "toolCall").map((part: ToolCall) => ({ toolCallId: part.id, kind: "result" as const }))
-			: message?.role === "toolResult" ? [{ toolCallId: message.toolCallId, kind: "call" as const }] : [];
-		for (const pair of pairs) {
-			const paired = tools.get(pair.toolCallId)?.[pair.kind] ?? await index.entry({ runId: input.runId, index: input.index, ...pair, ...boundary, signal: input.signal });
-			if (paired && inBoundary(paired)) entries.set(paired.id, paired);
-		}
-	}
-	const history = historyItems([...entries.values()].sort((a, b) => a.sequence - b.sequence).map((entry) => entry.entry as SessionEntry));
-	const visible = new Set(page.entries.map((entry) => entry.id));
-	history.items = history.items.filter((item) => (item.entryIds ?? [item.id]).some((id) => visible.has(id.split(":")[0])));
-	// Only page-local IDs advance the read marker; paired records can live elsewhere.
-	history.entryIds = history.entryIds.filter((id) => visible.has(id.split(":")[0]));
-	history.unavailable = page.unavailable;
-	history.configuration = page.configuration;
-	history.deliveredMessages = new Map(page.deliveredMessages);
-	history.finalId = page.finalResultId;
-	for (const item of history.items) item.load = async () => {
-		const ids = new Set((item.entryIds ?? [item.id]).map((id) => id.split(":")[0]));
-		const full: SessionEntry[] = [];
-		for (const id of ids) {
-			const entry = entries.get(id);
-			if (!entry) throw new Error("Selected native entry is unavailable; retry history.");
-			const record = await index.record({ runId: input.runId, index: input.index, ref: entry.ref, ...boundary, signal: input.signal });
-			if (!record) throw new Error("Selected native entry is unavailable; retry history.");
-			full.push({ ...record, id } as SessionEntry);
-		}
-		const detail = historyItems(full).items.find((candidate) => candidate.id === item.id);
-		if (!detail) throw new Error("Selected native entry is unavailable; retry history.");
-		return detail;
-	};
-	return { history, page };
+export function withFinalResult(
+  history: AgentHistory,
+  output: string,
+  runId: string,
+  timestamp: number,
+): AgentHistory {
+  const text = readableText(output).trim();
+  if (text.length === 0) {
+    return history;
+  }
+  const matched = finalMatch(history, text);
+  const existing = history.items.some((item) => item.id === matched) ? matched : undefined;
+  const id = `result:${runId}`;
+  let items: readonly AgentHistoryItem[] | undefined;
+  return {
+    get items() {
+      items ??=
+        existing !== undefined
+          ? history.items.map((item) =>
+              item.id === existing
+                ? { ...item, assistant: undefined, previewAssistant: undefined, text }
+                : item,
+            )
+          : [...history.items, { id, kind: "assistant", title: "Saved result", text, timestamp }];
+      return items;
+    },
+    entryIds: existing !== undefined ? history.entryIds : [...history.entryIds, id],
+    finalId: existing ?? id,
+    findFinalResult:
+      existing !== undefined
+        ? history.findFinalResult
+        : (value) => (value === text ? id : history.findFinalResult?.(value)),
+    deliveredMessages:
+      existing !== undefined
+        ? history.deliveredMessages
+        : history.deliveredMessages &&
+          new Map([...history.deliveredMessages.keys()].map((messageId) => [messageId, true])),
+    configuration: history.configuration,
+    get unavailable() {
+      return history.unavailable;
+    },
+  };
 }

package/src/tui/agent-model.ts

@@ -0,0 +1,78 @@
+import type { HistoryConfiguration, HistoryRunRow, ReadonlyInput } from "../shared/types.ts";
+import { formatModelThinking } from "../shared/formatters.ts";
+import { readableText } from "./agent-history.ts";
+import { hasText } from "./text-values.ts";
+type Child = ReadonlyInput<HistoryRunRow["children"][number]>;
+type Model = Readonly<Pick<HistoryConfiguration, "model" | "thinking">>;
+interface Selection {
+  readonly value?: Model;
+  readonly source: "selected" | "session" | "saved";
+}
+export const unavailableModel = {
+  summary: "model unavailable",
+  details: "Model unavailable. No provider/model was recorded for this assignment.",
+};
+function recordedModel(
+  child: Child,
+  native: HistoryConfiguration | undefined,
+): HistoryConfiguration | undefined {
+  if (child.state === "live") {
+    return native;
+  }
+  const saved = child.savedConfiguration ?? child.launch;
+  return hasText(native?.model) ? { ...saved, ...native } : saved;
+}
+function fallbackModel(child: Child, native: HistoryConfiguration | undefined): Model | undefined {
+  if (child.state === "live" && hasText(native?.model)) {
+    return native;
+  }
+  return hasText(child.launch?.model) ? child.launch : child.result;
+}
+function savedModelIsCurrent(child: Child, recorded: HistoryConfiguration): boolean {
+  const selected = child.modelSelection;
+  if (selected?.modelStartedAt === undefined) {
+    return child.state !== "live";
+  }
+  return (recorded.modelRecordedAt ?? 0) > selected.modelStartedAt;
+}
+function modelSelection(child: Child, native: HistoryConfiguration | undefined): Selection {
+  const recorded = recordedModel(child, native),
+    selected = child.modelSelection;
+  if (hasText(recorded?.model) && savedModelIsCurrent(child, recorded)) {
+    return { value: recorded, source: child.state === "live" ? "session" : "saved" };
+  }
+  return hasText(selected?.model)
+    ? { value: selected, source: "selected" }
+    : { value: fallbackModel(child, native), source: "saved" };
+}
+function formattedModel(value: Model | undefined): string | undefined {
+  return hasText(value?.model)
+    ? readableText(formatModelThinking(value.model, value.thinking))
+    : undefined;
+}
+export function agentModel(
+  child: Child,
+  native?: HistoryConfiguration,
+): { readonly summary: string; readonly details: string } {
+  if (child.identityUnavailable === true) {
+    return unavailableModel;
+  }
+  const selection = modelSelection(child, native),
+    formatted = formattedModel(selection.value);
+  if (formatted === undefined) {
+    return unavailableModel;
+  }
+  const selected = formattedModel(child.modelSelection),
+    saved = formattedModel(native);
+  const details = [`Model (${selection.source}): ${formatted}`];
+  if (selected !== undefined && selected !== formatted) {
+    details.push(`Selected model: ${selected}`);
+  }
+  if (child.state === "live" && saved !== undefined && saved !== formatted) {
+    details.push(`Last saved session model (may precede this attempt): ${saved}`);
+  }
+  return {
+    summary: selection.source === "session" ? formatted : `${selection.source}: ${formatted}`,
+    details: details.join("\n"),
+  };
+}