@aeondave/pi-persona 1.17.3 → 1.17.4

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 };
 			},