@aeondave/pi-persona 1.17.3 → 1.17.5

package/src/ui/agent-tree.ts

@@ -1,5 +1,7 @@
 import { compactTokens } from "../core/format.ts";
+import { effortFullName, effortSigla } from "../core/leg-thinking.ts";
 import { formatDuration } from "../core/time.ts";
+import type { ThinkingLevel } from "../core/types.ts";
 import type { ChildUsage } from "../engine/stream.ts";
 import { compactInlineText } from "./presentation.ts";
 import { formatUsage } from "./usage.ts";
@@ -13,7 +15,7 @@ import { formatUsage } from "./usage.ts";
  */
 
 export type AgentNodeStatus = "running" | "done" | "failed" | "stopped";
-export type AgentNodeKind = "subagent" | "delegate" | "council" | "flow" | "phase" | "monitor" | "timer";
+export type AgentNodeKind = "subagent" | "delegate" | "council" | "flow" | "phase" | "monitor" | "timer" | "activity";
 
 export interface AgentNode {
 	id: string;
@@ -25,6 +27,13 @@ export interface AgentNode {
 	/** Configured agent definition (operator/reviewer/…), if known. */
 	agent?: string;
 	model?: string;
+	/** Requested per-leg thinking effort, known at launch (the spec-level value the launch row
+	 *  carried). Rendered as the compact sigla right after the model; absent/off render nothing. */
+	thinking?: ThinkingLevel;
+	/** Observed effective Pi effort from the terminal result. Set ONLY from a real
+	 *  AgentResult.thinkingEffective (never invented); when it diverges from `thinking`, the row
+	 *  renders the honest `xh→h` form. */
+	thinkingEffective?: ThinkingLevel;
 	/** A short trailing annotation (usage, current activity), shown after the label. */
 	detail: string | undefined;
 	/** The agent's output buffer, shown when the user drills into the node. */
@@ -69,10 +78,16 @@ export function isWakeSource(node: Pick<AgentNode, "kind">): boolean {
 	return node.kind === "monitor" || node.kind === "timer";
 }
 
+/** Local companion work shares the view but is neither an agent nor a wake source. */
+export function isNonAgentNode(node: Pick<AgentNode, "kind">): boolean {
+	return isWakeSource(node) || node.kind === "activity";
+}
+
 /** The kind-aware glyph shared by every surface (tree, overlay): a running timer is ⏰, a running
  *  monitor ◉; everything else, settled wake rows included, uses the ordinary status glyph. */
 export function nodeGlyph(node: Pick<AgentNode, "status" | "kind">): string {
 	if (node.status === "running") {
+		if (node.kind === "activity") return "◈";
 		if (node.kind === "timer") return "⏰";
 		if (node.kind === "monitor") return "◉";
 	}
@@ -88,6 +103,28 @@ export interface RenderOptions {
 	waitingForSupervisor?: ReadonlySet<string>;
 }
 
+/** The frozen compact effort tag for a tree/overlay row: ` · xh` after the model, or ` · xh→h`
+ *  when the terminal result reported a DIFFERENT observed effective level. `off`/absent render
+ *  nothing — absence means off, and an observation is never invented: the divergence form shows
+ *  only when both sides are known and genuinely differ (an observed `off` never leaves a dangling
+ *  `→`). Pure. */
+export function effortTag(requested: ThinkingLevel | undefined, effective?: ThinkingLevel): string {
+	const req = requested !== undefined ? effortSigla(requested) : "";
+	if (!req) return "";
+	const obs = effective !== undefined ? effortSigla(effective) : "";
+	return obs && obs !== req ? ` · ${req}→${obs}` : ` · ${req}`;
+}
+
+/** The F9 drill-in line for a leg's effort — FULL names, the drill-in has the room (the compact
+ *  siglas live only on the rows): `thinking: requested xhigh → observed high`. Same honesty rules
+ *  as {@link effortTag}; the line is omitted entirely when nothing was requested. Pure. */
+export function thinkingDetailLine(requested: ThinkingLevel | undefined, effective?: ThinkingLevel): string {
+	const req = requested !== undefined ? effortFullName(requested) : "";
+	if (!req) return "";
+	const obs = effective !== undefined && effective !== requested ? effortFullName(effective) : "";
+	return obs ? `thinking: requested ${req} → observed ${obs}` : `thinking: requested ${req}`;
+}
+
 /** Whether `detail` is the literal "queued" marker a seeded-but-not-yet-live leg carries — shared
  *  by `runningAnnotation` (suppresses the clock) and `telemetryStatus` (`extension.ts`, reports the
  *  `queued` state). One predicate so the two readings of the marker cannot drift apart. */
@@ -105,6 +142,7 @@ export function isQueuedMarker(detail: string | undefined): boolean {
 export function runningAnnotation(node: Pick<AgentNode, "status" | "startedAt" | "lastAdvanceAt" | "detail" | "kind" | "dueAt">, now: number, stallMs: number, waitingForSupervisor = false): string | undefined {
 	if (node.status !== "running" || node.startedAt === undefined) return undefined;
 	if (isQueuedMarker(node.detail)) return undefined;
+	if (node.kind === "activity") return formatDuration(now - node.startedAt);
 	if (waitingForSupervisor) return "waiting for supervisor";
 	if (node.dueAt !== undefined) {
 		const left = node.dueAt - now;
@@ -179,7 +217,10 @@ export function renderAgentTree(nodes: AgentNode[], opts: RenderOptions = {}): s
 			const isRoot = parentId === undefined;
 			const isLast = i === kids.length - 1;
 			const branch = isRoot ? "" : isLast ? "└─ " : "├─ ";
-			const label = safeInline(node.label) || safeInline(node.id) || "agent";
+			const base = safeInline(node.label) || safeInline(node.id) || "agent";
+			// The compact effort sigla rides AFTER the label clamp — the existing per-part clipping is
+			// untouched; the appended field is at most ` · xh→h` wide.
+			const label = `${base}${effortTag(node.thinking, node.thinkingEffective)}`;
 			const detailText = node.detail ? safeInline(node.detail) : "";
 			const clock = opts.now !== undefined ? runningAnnotation(node, opts.now, opts.stallMs ?? 0, opts.waitingForSupervisor?.has(node.id) ?? false) : undefined;
 			const tail = [detailText, clock].filter((s): s is string => Boolean(s)).join(" · ");
@@ -202,6 +243,8 @@ function wakeDigestLine(hidden: readonly AgentNode[], now: number | undefined):
 	const monitors = hidden.filter((node) => node.kind === "monitor").length;
 	const timers = hidden.filter((node) => node.kind === "timer").length;
 	const parts: string[] = [];
+	const activities = hidden.filter((node) => node.kind === "activity");
+	if (activities.length > 0) parts.push(`◈ Mind · ${safeInline(activities[activities.length - 1]!.detail ?? "local memory work")}`);
 	if (monitors > 0) parts.push(`${nodeGlyph({ status: "running", kind: "monitor" })} ${monitors} monitor${monitors === 1 ? "" : "s"}`);
 	if (timers > 0) parts.push(`${nodeGlyph({ status: "running", kind: "timer" })} ${timers} timer${timers === 1 ? "" : "s"}`);
 	if (now !== undefined) {
@@ -243,7 +286,7 @@ export function renderAgentTreeSummary(nodes: AgentNode[], maxRows = 8, opts: Re
 	// same parent→children order, so a row's flat index doubles as its position in the rendered list.
 	const flat = flattenTree(nodes);
 	const hiddenWake = (from: number): AgentNode[] =>
-		flat.slice(from).map((row) => row.node).filter((node) => isWakeSource(node) && node.status === "running");
+		flat.slice(from).map((row) => row.node).filter((node) => node.kind === "activity" || (isWakeSource(node) && node.status === "running"));
 	let visibleCount = Math.max(0, limit - (failureLine !== undefined ? 2 : 1));
 	let hidden = hiddenWake(visibleCount);
 	if (hidden.length > 0) {
@@ -266,7 +309,9 @@ export interface AddNodeInput {
 	status?: AgentNodeStatus;
 	kind?: AgentNodeKind;
 	agent?: string;
-	model?: string;
+	model?: string | undefined;
+	thinking?: ThinkingLevel | undefined;
+	thinkingEffective?: ThinkingLevel | undefined;
 	detail?: string;
 	output?: string;
 	startedAt?: number;
@@ -278,7 +323,9 @@ export interface AgentNodePatch {
 	status?: AgentNodeStatus;
 	kind?: AgentNodeKind;
 	agent?: string;
-	model?: string;
+	model?: string | undefined;
+	thinking?: ThinkingLevel | undefined;
+	thinkingEffective?: ThinkingLevel | undefined;
 	detail?: string;
 	output?: string;
 	startedAt?: number;
@@ -292,7 +339,19 @@ function applyPatch(node: AgentNode, patch: AgentNodePatch): void {
 	if (patch.status) node.status = patch.status;
 	if (patch.kind !== undefined) node.kind = patch.kind;
 	if (patch.agent !== undefined) node.agent = patch.agent;
-	if (patch.model !== undefined) node.model = patch.model;
+	// Omission preserves metadata; explicit undefined clears a previous attempt's intent/observation.
+	if (Object.hasOwn(patch, "model")) {
+		if (patch.model === undefined) delete node.model;
+		else node.model = patch.model;
+	}
+	if (Object.hasOwn(patch, "thinking")) {
+		if (patch.thinking === undefined) delete node.thinking;
+		else node.thinking = patch.thinking;
+	}
+	if (Object.hasOwn(patch, "thinkingEffective")) {
+		if (patch.thinkingEffective === undefined) delete node.thinkingEffective;
+		else node.thinkingEffective = patch.thinkingEffective;
+	}
 	if (patch.detail !== undefined) node.detail = patch.detail;
 	if (patch.output !== undefined) node.output = patch.output;
 	if (patch.startedAt !== undefined) node.startedAt = patch.startedAt;
@@ -333,6 +392,8 @@ export class AgentTree {
 			...(input.kind !== undefined ? { kind: input.kind } : {}),
 			...(input.agent !== undefined ? { agent: input.agent } : {}),
 			...(input.model !== undefined ? { model: input.model } : {}),
+			...(input.thinking !== undefined ? { thinking: input.thinking } : {}),
+			...(input.thinkingEffective !== undefined ? { thinkingEffective: input.thinkingEffective } : {}),
 			...(input.output !== undefined ? { output: input.output } : {}),
 			...(input.dueAt !== undefined ? { dueAt: input.dueAt } : {}),
 		};

package/src/ui/literal-tool-result.ts

@@ -5,7 +5,7 @@ import { compactVisibleText, sanitizeTerminalText } from "./presentation.ts";
 
 interface LiteralResult {
 	content: readonly { type: string; text?: string }[];
-	/** Legacy direct renderer calls may carry this; the native host passes it in context. */
+	/** Direct internal renderer calls carry this; Pi passes it in the render context. */
 	isError?: boolean;
 }
 

package/src/ui/model-picker.ts

@@ -217,7 +217,7 @@ export class ModelPicker extends Container implements Focusable {
 			return;
 		} else {
 			const before = this.input.getValue();
-			// Input has no per-instance keybindings API (Pi 1.3/1.4). Scope its global
+			// Input has no per-instance keybindings API (Pi 1.4). Scope its global
 			// lookup to this synchronous call and restore it even if handling throws.
 			const global = getKeybindings();
 			try {

package/src/ui/orchestration-launch.ts

@@ -0,0 +1,49 @@
+/** Persisted orchestration launch requests. Rendering never consults live persona or model settings. */
+import { resolveLegThinking } from "../core/leg-thinking.ts";
+import type { ThinkingLevel } from "../core/types.ts";
+import type { ModelParticipant, ModelSource } from "../persona/model-participants.ts";
+import { compactInlineText, sanitizeTerminalText } from "./presentation.ts";
+
+export interface OrchestrationLaunchParticipant {
+	key: string;
+	label: string;
+	agent: string;
+	model?: string;
+	modelSource: ModelSource;
+	thinkingRequested?: ThinkingLevel;
+	setupPending: boolean;
+	param?: string;
+	phase?: string;
+}
+
+export interface OrchestrationLaunchSnapshot {
+	participants: OrchestrationLaunchParticipant[];
+	unavailable?: true;
+}
+
+export function snapshotOrchestrationParticipants(
+	participants: readonly ModelParticipant[],
+	opts: { agentThinking(agent: string): ThinkingLevel | undefined; childThinking: unknown; pendingKeys: ReadonlySet<string> },
+): OrchestrationLaunchSnapshot {
+	return { participants: participants.map((p) => {
+		const agentThinking = opts.agentThinking(p.agent);
+		const thinkingRequested = resolveLegThinking(p, agentThinking ? { thinking: agentThinking } : {}, opts.childThinking);
+		return { key: p.key, label: p.label, agent: p.agent, modelSource: p.source, setupPending: !p.assigned && opts.pendingKeys.has(p.key),
+			...(p.model ? { model: p.model } : {}), ...(thinkingRequested ? { thinkingRequested } : {}), ...(p.param ? { param: p.param } : {}) };
+	}) };
+}
+
+/** Three individually bounded rows collapsed; expansion retains every participant and full model ref. */
+export function orchestrationLaunchLines(snapshot: OrchestrationLaunchSnapshot | undefined, expanded: boolean): string[] {
+	if (!snapshot || snapshot.unavailable) return ["Launch metadata unavailable"];
+	const rows = expanded ? snapshot.participants : snapshot.participants.slice(0, 3);
+	const lines = rows.map((p) => {
+		const clean = (value: string, maxChars: number): string => expanded ? sanitizeTerminalText(value) : compactInlineText(value, { maxChars });
+		const label = clean(`${p.phase ? `${p.phase} / ` : ""}${p.label}${p.param ? ` [${p.param}]` : ""}`, 48);
+		const model = p.model ? clean(p.model, 64) : "unknown";
+		const modelText = p.setupPending ? `model pending (current default ${model}; setup may change)` : `requested model ${model}`;
+		return `  ${label} · ${modelText} · requested effort ${p.thinkingRequested ?? "unknown"}`;
+	});
+	if (!expanded && snapshot.participants.length > rows.length) lines.push(`  +${snapshot.participants.length - rows.length} more · expand for launch details`);
+	return lines;
+}

package/src/ui/session-cards.ts

@@ -1,6 +1,6 @@
 /** Operator-only presentation of existing session payloads. No delivery, storage or tool shells. */
 import type { ExtensionAPI, Theme, ThemeBg, ThemeColor } from "@earendil-works/pi-coding-agent";
-import { Text, truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import { Text, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
 import { formatDuration } from "../core/time.ts";
 import { neutralizeMonitorUnicode } from "../core/monitor-output.ts";
 import { createReportBody } from "./report-body.ts";
@@ -25,6 +25,14 @@ interface Card {
 	markdown?: boolean;
 }
 
+/** The delegate-card-family frame every surface in this file shares: a bold semantic
+ * `<Event> · <datum>` title, two-space-indented compact content lines, and the dim
+ * expand hint only when compact actually hides content. Payloads are never modified —
+ * this is projection-only (expanded still shows the complete sanitized payload). */
+const INDENT = "  ";
+/** Compact budget: title + 5 body rows + optional hint keeps every collapsed card ≤ 7 rows. */
+const COMPACT_BODY_ROWS = 4;
+
 /** All seven surfaces share semantic chrome. Literal paths style at paint time; report bodies
  * use native Markdown's invalidatable layout cache. Pi rebuilds callbacks on transcript invalidation. */
 function createSessionCard(card: Card, expanded: boolean, theme: Theme, detailHint: () => string, outputPad = 0): Component {
@@ -45,12 +53,19 @@ function createSessionCard(card: Card, expanded: boolean, theme: Theme, detailHi
 			const padding = Math.min(Math.max(0, Math.floor(outputPad)), Math.max(0, Math.floor((width - 1) / 2)));
 			const innerWidth = Math.max(1, width - padding * 2);
 			const colors = COLORS[card.state];
-			const preview = expanded ? undefined : card.preview(innerWidth);
+			// The indent only applies where a clipped content column still fits; every compact line
+			// is clipped to the remaining columns so indent + text never wrap or spill mid-word.
+			const bodyPad = innerWidth > INDENT.length ? INDENT : "";
+			const contentWidth = Math.max(1, innerWidth - bodyPad.length);
+			const preview = expanded ? undefined : card.preview(contentWidth);
 			const body = expanded ? card.full : preview?.text ?? "(no output)";
+			const bodyLines = sanitizeTerminalText(body || "(no output)").split("\n").map((line) => expanded
+				? theme.fg("toolOutput", line)
+				: theme.fg("toolOutput", `${bodyPad}${truncateToWidth(line, contentWidth)}`));
 			const lines = [
 				theme.fg(colors.fg, theme.bold(truncateToWidth(sanitizeTerminalText(card.title), innerWidth))),
-				...(card.metadata ? [theme.fg("dim", truncateToWidth(card.metadata, innerWidth))] : []),
-				...sanitizeTerminalText(body || "(no output)").split("\n").map((line) => theme.fg("toolOutput", line)),
+				...(card.metadata ? [theme.fg("dim", truncateToWidth(`${bodyPad}${sanitizeTerminalText(card.metadata)}`, innerWidth))] : []),
+				...bodyLines,
 				...(preview?.truncated ? [theme.fg("dim", truncateToWidth(detailHint(), innerWidth))] : []),
 			];
 			// Text owns wrapping and full-row padding/background, including embedded foreground resets.
@@ -65,11 +80,15 @@ function preview(full: string, maxLines: number, maxColumns: number): Card["prev
 	return (width) => compactVisibleText(full, { maxLines, maxLineChars: Math.min(width, maxColumns) });
 }
 
+/** Single source of truth for the settlement head grammar, shared by state selection and the
+ * compact projection below. The generator is `buildCompletionReport` in src/engine/async.ts. */
+const SETTLEMENT_HEAD = /^(?:\[pi-persona\] )?(\d+) async runs? settled — (\d+) done, (\d+) failed(?:, (\d+) stopped)?$/;
+
 /** Only this exact runtime-owned aggregate is evidence of settlement. No keyword scan of output,
  * asks, timers, monitor event bodies, or peers. Legacy/unknown follow-ups remain informational. */
 function followUpState(full: string): { state: State; status: string } {
 	const first = full.split("\n", 1)[0] ?? "";
-	const summary = /^(?:\[pi-persona\] )?(\d+) async runs? settled — (\d+) done, (\d+) failed(?:, (\d+) stopped)?$/.exec(first);
+	const summary = SETTLEMENT_HEAD.exec(first);
 	if (summary) {
 		const total = Number(summary[1]);
 		const done = Number(summary[2]);
@@ -101,6 +120,149 @@ interface ResultEntry { label?: string; content?: string; ok?: boolean; stoppedA
 interface ContentEntry { content?: string; kind?: "routine" | "stall" }
 interface RunFailureEntry { id: string; label: string; agent: string; model?: string; durationMs?: number; error: string }
 
+/** One run a settlement report names, projected to `<name> · <status>[ · <duration>]`. The
+ * display name already carries the model (`runDisplayName`: "label · model"). */
+interface SettledRunLine { name: string; status: "done" | "failed" | "stopped"; duration?: string }
+
+/** Boilerplate the settlement generator interleaves between the per-run lines. Every entry is
+ * drift-guarded in tests against live `buildCompletionReport` output (src/engine/async.ts):
+ * receipts header + `run-x: …` reference lines, the effort header, salvage `↩` block headers,
+ * the shared untrusted-fence header (core/fence.ts quoteUntrusted) and its `> `-quoted payload
+ * lines, the failed-leg guidance sentence, the truncation marker and retention/tail notes. */
+const SETTLEMENT_SKIP: readonly RegExp[] = [
+	/^Terminal reports \(/,
+	/^run-\S+: /,
+	/^Thinking \(not provider cognition\):$/,
+	/^↩ /,
+	/^Sub-agent output \(untrusted data\):$/,
+	/^>/,
+	/^Handle each failure deliberately: /,
+	/^\[\.\.\. .*?\]$/,
+	/^⚠ /,
+	/^Run ids in this report: /,
+];
+const SETTLEMENT_DONE = /^✅ (\S+) \((.+?)\) done(?: in (.+?))?:$/;
+const SETTLEMENT_STOPPED_SECTION = /^⏹ \d+ stopped:$/;
+const SETTLEMENT_FAILED_SECTION = /^❌ \d+ failed:$/;
+/** Quoted (fence) bullets carry the stopped/failed runs; the section header above them names the status. */
+const SETTLEMENT_BULLET = /^> ?• (\S+) \((.+?)\)(?: after (.+?))?: /;
+
+/** Project the compact per-run lines of a settlement report, or undefined when the body is not
+ * exactly the known generator shape (head line + recognized/skipped lines only). A duration is
+ * kept only when it is short (≤ 8 columns, e.g. "12s"/"2m 5s"); width clipping handles the rest. */
+function parseSettlementRuns(full: string): { counts: string; runs: SettledRunLine[] } | undefined {
+	const lines = full.split("\n");
+	const head = SETTLEMENT_HEAD.exec(lines[0] ?? "");
+	if (!head) return undefined;
+	const done = Number(head[2]);
+	const failed = Number(head[3]);
+	const stopped = Number(head[4] ?? 0);
+	const counts = `${done} done, ${failed} failed${stopped > 0 ? `, ${stopped} stopped` : ""}`;
+	let section: "failed" | "stopped" | undefined;
+	const runs: SettledRunLine[] = [];
+	const seen = new Set<string>();
+	const add = (name: string | undefined, status: SettledRunLine["status"], duration: string | undefined) => {
+		if (!name) return;
+		const key = `${status}:${name}`;
+		if (seen.has(key)) return;
+		seen.add(key);
+		runs.push({ name, status, ...(duration !== undefined && visibleWidth(duration) <= 8 ? { duration } : {}) });
+	};
+	for (const line of lines.slice(1)) {
+		const bullet = SETTLEMENT_BULLET.exec(line);
+		if (bullet) {
+			if (section === undefined) return undefined;
+			add(bullet[2], section, bullet[3]);
+			continue;
+		}
+		if (line.trim().length === 0 || SETTLEMENT_SKIP.some((skip) => skip.test(line))) continue;
+		const doneLine = SETTLEMENT_DONE.exec(line);
+		if (doneLine) {
+			section = undefined;
+			add(doneLine[2], "done", doneLine[3]);
+			continue;
+		}
+		if (SETTLEMENT_STOPPED_SECTION.test(line)) { section = "stopped"; continue; }
+		if (SETTLEMENT_FAILED_SECTION.test(line)) { section = "failed"; continue; }
+		return undefined; // unknown shape → the caller falls back to the generic bounded preview
+	}
+	return { counts, runs };
+}
+
+/** Compact projection of a settlement report: counts line + one line per named run, capped at
+ * COMPACT_BODY_ROWS (a `… +N more` tail row replaces the overflow). Undefined run list = fallback. */
+function settlementPreview(full: string): Card["preview"] | undefined {
+	const parsed = parseSettlementRuns(full);
+	if (!parsed || parsed.runs.length === 0) return undefined;
+	return () => {
+		const lines = [parsed.counts, ...parsed.runs.map((run) => `${run.name} · ${run.status}${run.duration ? ` · ${run.duration}` : ""}`)];
+		const visible = lines.length <= COMPACT_BODY_ROWS ? lines : [...lines.slice(0, COMPACT_BODY_ROWS - 1), `… +${lines.length - (COMPACT_BODY_ROWS - 1)} more`];
+		return { text: visible.join("\n"), truncated: true };
+	};
+}
+
+interface StatusRunLine { name: string; detail: string; queued: boolean }
+
+/** Skip-list for the peek-digest boilerplate the status card's title/frame replaces. Each entry
+ * is drift-guarded in tests against live `buildPeekDigest`/`buildCheckIn` output (src/engine/async.ts):
+ * the check-in header, the cumulative-token footnote and the omitted-runs tail. The
+ * `Async runs: N (M running)` header is recognized below (the title carries its counts). */
+const STATUS_SKIP: readonly RegExp[] = [
+	/^Async activity · (?:routine check-in|possible stall)$/,
+	/^Cumulative tokens show /,
+	/^… \d+ additional async runs omitted/,
+];
+const STATUS_RUNNING = /^\[([^\]]+)\] (.+?) — running \((?:(\d+) turns, )?(.+?) cumulative input \+ output tokens\)(.*)$/;
+const STATUS_SETTLED = /^\[([^\]]+)\] (.+?) — (done|failed|stopped)(?: (?:in|after) (.+?))?(?::.*)?$/;
+const STATUS_HEADER_COUNTS = /^Async runs: \d+ \((\d+) running\)$/;
+
+/** Parse one peek digest into per-run compact lines (`<name> · 53t · 216k` for running legs,
+ * `<name> · done · 12s` for settled ones), or undefined when the shape is not the generator's. */
+function parseStatusRuns(full: string): { running: number; queued: number; runs: StatusRunLine[] } | undefined {
+	let running: number | undefined;
+	let queued = 0;
+	const runs: StatusRunLine[] = [];
+	for (const line of full.split("\n")) {
+		if (line.trim().length === 0 || STATUS_SKIP.some((skip) => skip.test(line))) continue;
+		const head = STATUS_HEADER_COUNTS.exec(line);
+		if (head) {
+			if (running !== undefined) return undefined;
+			running = Number(head[1]);
+			continue;
+		}
+		const runLine = STATUS_RUNNING.exec(line);
+		if (runLine) {
+			const [, , name, turns, tokens, suffix] = runLine;
+			const isQueued = /· queued \(/.test(suffix ?? "");
+			if (isQueued) queued++;
+			const usage = `${tokens ?? "0"} cumulative input + output tokens`;
+			const detail = isQueued ? `queued · ${usage}` : `${turns !== undefined ? `${turns} turns · ` : ""}${usage}`;
+			runs.push({ name: name ?? "", detail, queued: isQueued });
+			continue;
+		}
+		const settledLine = STATUS_SETTLED.exec(line);
+		if (settledLine) {
+			const [, , name, status, duration] = settledLine;
+			runs.push({ name: name ?? "", detail: duration !== undefined ? `${status} · ${duration}` : status ?? "", queued: false });
+			continue;
+		}
+		return undefined; // unknown shape → the caller falls back to the generic bounded preview
+	}
+	if (running === undefined || runs.length === 0) return undefined;
+	return { running, queued, runs };
+}
+
+/** Compact projection of the periodic status digest, capped like the settlement preview. */
+function statusPreview(full: string): Card["preview"] | undefined {
+	const parsed = parseStatusRuns(full);
+	if (!parsed) return undefined;
+	return () => {
+		const lines = parsed.runs.map((run) => `${run.name} · ${run.detail}`);
+		const visible = lines.length <= COMPACT_BODY_ROWS ? lines : [...lines.slice(0, COMPACT_BODY_ROWS - 1), `… +${lines.length - (COMPACT_BODY_ROWS - 1)} more`];
+		return { text: visible.join("\n"), truncated: true };
+	};
+}
+
 export interface SessionCardOptions {
 	detailHint: () => string;
 	/** Existing bounded/fenced runtime formatter, injected to keep UI independent of tool wiring. */
@@ -119,7 +281,12 @@ export function registerSessionCards(pi: Pick<ExtensionAPI, "registerMessageRend
 			// Only the validated settlement envelope is a pi-persona report. Unknown is NOT
 			// Markdown: monitor stdout/stderr, timers and operational notices share this type.
 			const markdown = customType === "exocom_received" || status !== "info";
-			return sessionCard({ title: customType === "pi-persona" ? `pi-persona · update · ${status}` : "exocom · inbound", state, full, markdown, preview: preview(full, 4, 100) }, expanded, theme, outputPad);
+			const projected = customType === "pi-persona" ? settlementPreview(full) : undefined;
+			return sessionCard({
+				title: customType === "pi-persona" ? `Update · ${status}` : "Exocom · inbound",
+				state, full, markdown,
+				preview: projected ?? preview(full, 4, 100),
+			}, expanded, theme, outputPad);
 		});
 	}
 	pi.registerEntryRenderer(MONITOR_LOG_ENTRY, (entry, { expanded }, theme) => {
@@ -127,8 +294,9 @@ export function registerSessionCards(pi: Pick<ExtensionAPI, "registerMessageRend
 		if (!record) return undefined;
 		const { state, status } = monitorState(record);
 		return sessionCard({
-			title: `Monitor log ${compactInlineText(record.entry.label)} · ${record.outcome} · ${status}`,
-			state, full: sanitizeTerminalText(options.monitorLog(record)),
+			title: `Monitor · ${compactInlineText(record.entry.label)}`,
+			state, metadata: `${record.outcome} · ${status} · ${compactInlineText(record.entry.id)}`,
+			full: sanitizeTerminalText(options.monitorLog(record)),
 			preview: (width) => ({ text: `${compactInlineText(neutralizeMonitorUnicode(record.text), { maxChars: Math.min(width, 160) })}\n${compactInlineText(record.entry.id)} · monitor result`, truncated: true }),
 		}, expanded, theme);
 	});
@@ -137,7 +305,7 @@ export function registerSessionCards(pi: Pick<ExtensionAPI, "registerMessageRend
 		if (!data) return undefined;
 		const metadata = [compactInlineText(data.agent, { maxChars: 48 }), ...(data.model ? [compactInlineText(data.model, { maxChars: 96 })] : []), ...(data.durationMs !== undefined ? [formatDuration(data.durationMs)] : [])].join(" · ");
 		return sessionCard({
-			title: `${compactInlineText(data.label || data.agent, { maxChars: 80 })} · failed`, state: "error", metadata,
+			title: `Failed · ${compactInlineText(data.label || data.agent, { maxChars: 80 })}`, state: "error", metadata,
 			full: `Run ${compactInlineText(data.id)}\n${sanitizeTerminalText(data.error)}`,
 			preview: (width) => ({ text: compactVisibleText(summarizeFailure(data.error), { maxLines: 2, maxLineChars: Math.min(width, 100) }).text, truncated: true }),
 		}, expanded, theme);
@@ -150,8 +318,9 @@ export function registerSessionCards(pi: Pick<ExtensionAPI, "registerMessageRend
 		const state: State = stopped ? "attention" : data.ok === true ? "success" : data.ok === false ? "error" : "neutral";
 		const status = stopped ? `stopped · checkpoint ${compactInlineText(data.stoppedAtGate ?? "", { maxChars: 32 })}` : data.ok === true ? "complete" : data.ok === false ? "failed" : "unknown";
 		const cause = compactVisibleText([data.failureKind, data.error].filter(Boolean).join(" · "), { maxLines: 1, maxLineChars: 80 }).text;
+		const label = compactInlineText(data.label ?? "", { maxChars: 96 });
 		return sessionCard({
-			title: `${compactInlineText(data.label ?? "", { maxChars: 96 }) || "result"} · ${status}${state === "error" && cause !== "(no output)" ? ` · ${cause}` : ""}`,
+			title: `${label || "Result"} · ${status}${state === "error" && cause !== "(no output)" ? ` · ${cause}` : ""}`,
 			state, full, markdown: true, preview: preview(full, 3, 100),
 		}, expanded, theme);
 	});
@@ -159,14 +328,17 @@ export function registerSessionCards(pi: Pick<ExtensionAPI, "registerMessageRend
 		if (!entry.data) return undefined;
 		const full = sanitizeTerminalText(entry.data.content || "⟢ pi-persona · checkpoint");
 		const lines = full.split("\n").map((line) => line.trim()).filter(Boolean);
-		const header = compactInlineText(lines[0]?.replace(/^⟢\s*/, "") ?? "", { maxChars: 96 }) || "pi-persona · checkpoint";
+		const header = compactInlineText(lines[0]?.replace(/^⟢\s*/, "") ?? "", { maxChars: 96 }) || "checkpoint";
+		// Drop the generator's own "pi-persona · checkpoint" boilerplate from the datum; a bare
+		// checkpoint header leaves the title as just the event word.
+		const datum = header === "checkpoint" ? "" : header.replace(/^pi-persona · checkpoint\b\??/, "").replace(/^pi-persona · /, "").trim();
 		const details = lines.slice(1);
 		const trigger = details.find((line) => line.startsWith("Trigger:"));
 		const action = details.find((line) => /^(?:Action|Verify|Otherwise):/.test(line));
 		const selected = [trigger, action].filter((line): line is string => line !== undefined);
 		const chosen = selected.length > 0 ? selected : details.slice(0, 2);
 		return sessionCard({
-			title: header, state: "attention", full,
+			title: datum ? `Checkpoint · ${datum}` : "Checkpoint", state: "attention", full,
 			preview: (width) => {
 				const result = preview(chosen.join("\n"), 2, 100)(width);
 				return { text: result.text, truncated: result.truncated || details.some((line) => !chosen.includes(line)) };
@@ -177,10 +349,15 @@ export function registerSessionCards(pi: Pick<ExtensionAPI, "registerMessageRend
 		if (!entry.data) return undefined;
 		const full = sanitizeTerminalText(entry.data.content || "Async activity · routine check-in");
 		const stall = entry.data.kind === "stall";
+		const event = stall ? "Stall" : "Status";
 		const digest = full.split("\n").slice(1).filter((line) => line.trim().length > 0);
+		const parsed = parseStatusRuns(full);
 		return sessionCard({
-			title: stall ? "pi-persona · possible stall" : "pi-persona · async status", state: stall ? "attention" : "neutral", full,
-			preview: (width) => {
+			title: parsed
+				? `${event} · ${parsed.running} running${parsed.queued > 0 ? ` · ${parsed.queued} queued` : ""}`
+				: `${event} · check-in`,
+			state: stall ? "attention" : "neutral", full,
+			preview: parsed ? statusPreview(full)! : (width) => {
 				const result = preview(digest.slice(0, 2).join("\n") || full, 2, 140)(width);
 				return { text: result.text, truncated: result.truncated || digest.length > 2 };
 			},

package/src/ui/strategy-leg.ts

@@ -0,0 +1,40 @@
+/** Model intent for live strategy rows, resolved from exact attempt identity and frozen run settings. */
+import { isThinkingLevel, type ThinkingLevel } from "../core/types.ts";
+import type { AgentAttemptIdentity } from "../orchestration/agent-attempt.ts";
+import type { AgentResult } from "../orchestration/types.ts";
+import { participantKey } from "../persona/model-participants.ts";
+
+export interface StrategyModels {
+	readonly assigned: Readonly<Record<string, string>>;
+	readonly agents: Readonly<Record<string, string>>;
+	readonly sessionModel?: string;
+}
+
+export function snapshotStrategyModels(input: { assigned?: Record<string, string>; agents: readonly { name: string; model?: string }[]; sessionModel?: string }): StrategyModels {
+	return Object.freeze({ assigned: Object.freeze({ ...input.assigned }),
+		agents: Object.freeze(Object.fromEntries(input.agents.flatMap((a) => a.model ? [[a.name, a.model]] : []))),
+		...(input.sessionModel ? { sessionModel: input.sessionModel } : {}) });
+}
+
+export interface StrategyLegMetadata {
+	agent: string;
+	model: string | undefined;
+	thinking: ThinkingLevel | undefined;
+	thinkingEffective: ThinkingLevel | undefined;
+}
+
+/** A bare observed id preserves a known provider only when it exactly names the same requested id. */
+function observedModel(observed: string | undefined, requested: string | undefined): string | undefined {
+	const value = observed?.trim();
+	if (!value) return requested;
+	if (!value.includes("/") && requested?.includes("/") && requested.slice(requested.indexOf("/") + 1) === value) return requested;
+	return value;
+}
+
+export function strategyLegMetadata(identity: AgentAttemptIdentity, models: StrategyModels, result?: AgentResult): StrategyLegMetadata {
+	const requested = identity.model ?? models.assigned[participantKey(identity.agent, identity.role)]
+		?? models.assigned[identity.agent] ?? models.agents[identity.agent] ?? models.sessionModel;
+	return { agent: identity.agent, model: observedModel(result?.modelUsed, requested),
+		thinking: isThinkingLevel(result?.thinkingRequested) ? result.thinkingRequested : identity.thinking,
+		thinkingEffective: isThinkingLevel(result?.thinkingEffective) ? result.thinkingEffective : undefined };
+}