@aeondave/pi-persona 1.17.1 → 1.17.4

package/src/ui/agent-tree.ts

@@ -1,6 +1,10 @@
 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";
 
 /**
  * The unified agent tree — a single live model of *every* agent in flight,
@@ -11,7 +15,7 @@ import { compactInlineText } from "./presentation.ts";
  */
 
 export type AgentNodeStatus = "running" | "done" | "failed" | "stopped";
-export type AgentNodeKind = "subagent" | "delegate" | "council" | "flow" | "phase";
+export type AgentNodeKind = "subagent" | "delegate" | "council" | "flow" | "phase" | "monitor" | "timer";
 
 export interface AgentNode {
 	id: string;
@@ -23,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. */
@@ -31,6 +42,8 @@ export interface AgentNode {
 	 *  Excluded from change notifications — the live clock paints them. */
 	startedAt?: number;
 	lastAdvanceAt?: number;
+	/** Epoch ms when a wake source is due: a monitor's deadline or a timer's fire time. Its countdown replaces the elapsed/stall clock. Set once by the source; a change notifies (it is not a clock key). */
+	dueAt?: number;
 }
 
 export type AgentTreeChange =
@@ -60,6 +73,21 @@ export function flattenTree(nodes: AgentNode[]): FlatRow[] {
 /** Status → glyph, shared by every agent surface (tree, overlay). */
 export const GLYPH: Record<AgentNodeStatus, string> = { running: "⏳", done: "✓", failed: "✗", stopped: "■" };
 
+/** A wake source is a row that is not an agent (never counted, steered, or stopped in bulk). */
+export function isWakeSource(node: Pick<AgentNode, "kind">): boolean {
+	return node.kind === "monitor" || node.kind === "timer";
+}
+
+/** 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 === "timer") return "⏰";
+		if (node.kind === "monitor") return "◉";
+	}
+	return GLYPH[node.status];
+}
+
 export interface RenderOptions {
 	/** Current time; omitted ⇒ no elapsed/stall annotation (pure renders stay byte-identical). */
 	now?: number;
@@ -69,6 +97,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. */
@@ -79,11 +129,20 @@ export function isQueuedMarker(detail: string | undefined): boolean {
 /** "1m 15s" while a running node keeps advancing; "⚠ stalled 1m 30s" once it has been quiet
  *  for `stallMs`. Undefined for settled nodes, nodes without clock data, or a node still carrying
  *  the "queued" marker — it was seeded ahead of the concurrency gate and has not started running
- *  yet, so its clock (stamped at seed time) has nothing true to report. Pure. */
-export function runningAnnotation(node: Pick<AgentNode, "status" | "startedAt" | "lastAdvanceAt" | "detail">, now: number, stallMs: number, waitingForSupervisor = false): string | undefined {
+ *  yet, so its clock (stamped at seed time) has nothing true to report. A wake-source row (one with
+ *  a `dueAt`) counts down instead — "fires in 49m 12s" for a timer, "12m 3s · deadline in 1h 47m"
+ *  for a monitor — and NEVER shows the stall badge: a quiet monitor is waiting for its event,
+ *  not stalled. Pure. */
+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 (waitingForSupervisor) return "waiting for supervisor";
+	if (node.dueAt !== undefined) {
+		const left = node.dueAt - now;
+		if (node.kind === "timer") return left > 0 ? `fires in ${formatDuration(left)}` : "firing…";
+		const elapsed = formatDuration(now - node.startedAt);
+		return left > 0 ? `${elapsed} · deadline in ${formatDuration(left)}` : `${elapsed} · deadline reached`;
+	}
 	const quietSince = node.lastAdvanceAt ?? node.startedAt;
 	if (stallMs > 0 && now - quietSince >= stallMs) return `⚠ stalled ${formatDuration(now - quietSince)}`;
 	return formatDuration(now - node.startedAt);
@@ -118,12 +177,13 @@ export function deriveWaitingNodeIds(nodes: readonly AgentNode[], isWaiting: (id
 }
 
 /** The tree patch for one progress snapshot: every snapshot is an advance; activity wins over
- *  a bare token count as the visible detail. One helper for every progress site. */
-export function progressPatch(snap: { output?: string; activity?: string; tokens?: number }, now: number): AgentNodePatch {
+ *  usage, formatted like a completed row. Legacy aggregate-only progress stays a neutral count. */
+export function progressPatch(snap: { output?: string; activity?: string; tokens?: number; usage?: ChildUsage }, now: number): AgentNodePatch {
 	const patch: AgentNodePatch = { lastAdvanceAt: now };
 	if (snap.output) patch.output = snap.output;
 	if (snap.activity) patch.detail = snap.activity;
-	else if (snap.tokens) patch.detail = `${compactTokens(snap.tokens)} tok`;
+	else if (snap.usage) patch.detail = formatUsage(snap.usage);
+	else if (snap.tokens) patch.detail = compactTokens(snap.tokens);
 	return patch;
 }
 
@@ -150,12 +210,15 @@ 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(" · ");
 			const detail = tail ? `  ${tail}` : "";
-			lines.push(`${prefix}${branch}${GLYPH[node.status]} ${label}${detail}`);
+			lines.push(`${prefix}${branch}${nodeGlyph(node)} ${label}${detail}`);
 			const childPrefix = isRoot ? "" : `${prefix}${isLast ? "   " : "│  "}`;
 			walk(node.id, childPrefix);
 		});
@@ -165,14 +228,41 @@ export function renderAgentTree(nodes: AgentNode[], opts: RenderOptions = {}): s
 	return lines;
 }
 
+/** One digest line for the running wake sources (monitors, timers) that fell below the summary
+ *  fold: counts by kind ("◉ 1 monitor · ⏰ 2 timers"), plus the countdown to the soonest finite
+ *  `dueAt` when a clock is given. A monitor armed after a fan-out would otherwise hide behind the
+ *  "… +N more" line — exactly the "armed but nothing visible" case wake rows exist to fix. Pure. */
+function wakeDigestLine(hidden: readonly AgentNode[], now: number | undefined): string {
+	const monitors = hidden.filter((node) => node.kind === "monitor").length;
+	const timers = hidden.filter((node) => node.kind === "timer").length;
+	const parts: string[] = [];
+	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) {
+		const due = hidden.map((node) => node.dueAt).filter((at): at is number => at !== undefined && Number.isFinite(at));
+		if (due.length > 0) {
+			const left = Math.min(...due) - now;
+			parts.push(left > 0 ? `next due in ${formatDuration(left)}` : "next due now");
+		}
+	}
+	return parts.join(" · ");
+}
+
 /**
  * Bounded above-editor digest. Large fan-outs belong in the scrollable F9
  * overlay; they must not push the editor and conversation off the screen.
+ *
+ * Below the fold, two kinds of row stay visible as one line each, because an operator must not
+ * have to open F9 to learn them: failures (`✗ N failed: …`) and RUNNING wake sources (`◉ 1 monitor
+ * · ⏰ 2 timers · next due in 4m 12s`). The layout when overflowing is
+ * `[...rows, failureLine?, wakeDigest?, overflowLine]`, every line inside `maxRows`; when the budget
+ * cannot hold them all the lowest-priority line goes first (failure > wake digest > overflow).
  */
 export function renderAgentTreeSummary(nodes: AgentNode[], maxRows = 8, opts: RenderOptions = {}): string[] {
 	const rows = renderAgentTree(nodes, opts);
 	const limit = Math.max(1, Math.floor(maxRows));
 	if (rows.length <= limit) return rows;
+	let failureLine: string | undefined;
 	const failed = nodes.filter((node) => node.status === "failed");
 	if (failed.length > 0) {
 		const names = failed.slice(0, 2).map((node) => {
@@ -181,20 +271,26 @@ export function renderAgentTreeSummary(nodes: AgentNode[], maxRows = 8, opts: Re
 			return detail ? `${label} (${detail})` : label;
 		});
 		const extra = failed.length - names.length;
-		const failureLine = `✗ ${failed.length} failed: ${names.join(", ")}${extra > 0 ? `, +${extra} more` : ""}`;
-		if (limit === 1) return [failureLine];
-		const visibleCount = Math.max(0, limit - 2);
-		return [
-			...rows.slice(0, visibleCount),
-			failureLine,
-			`… +${rows.length - visibleCount} more · F9 or /agents for the full live tree`,
-		];
+		failureLine = `✗ ${failed.length} failed: ${names.join(", ")}${extra > 0 ? `, +${extra} more` : ""}`;
+	}
+	// `flattenTree(nodes)[i]` is the node behind `rows[i]`: `renderAgentTree` and `flattenTree` walk the
+	// 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");
+	let visibleCount = Math.max(0, limit - (failureLine !== undefined ? 2 : 1));
+	let hidden = hiddenWake(visibleCount);
+	if (hidden.length > 0) {
+		// The digest takes a slot of its own; one fewer visible row can only hide more wake rows.
+		visibleCount = Math.max(0, visibleCount - 1);
+		hidden = hiddenWake(visibleCount);
 	}
-	const visibleCount = Math.max(0, limit - 1);
-	return [
-		...rows.slice(0, visibleCount),
+	const tail = [
+		...(failureLine !== undefined ? [failureLine] : []),
+		...(hidden.length > 0 ? [wakeDigestLine(hidden, opts.now)] : []),
 		`… +${rows.length - visibleCount} more · F9 or /agents for the full live tree`,
 	];
+	return [...rows.slice(0, visibleCount), ...tail.slice(0, Math.max(0, limit - visibleCount))];
 }
 
 export interface AddNodeInput {
@@ -205,10 +301,13 @@ export interface AddNodeInput {
 	kind?: AgentNodeKind;
 	agent?: string;
 	model?: string;
+	thinking?: ThinkingLevel;
+	thinkingEffective?: ThinkingLevel;
 	detail?: string;
 	output?: string;
 	startedAt?: number;
 	lastAdvanceAt?: number;
+	dueAt?: number;
 }
 
 export interface AgentNodePatch {
@@ -216,10 +315,13 @@ export interface AgentNodePatch {
 	kind?: AgentNodeKind;
 	agent?: string;
 	model?: string;
+	thinking?: ThinkingLevel;
+	thinkingEffective?: ThinkingLevel;
 	detail?: string;
 	output?: string;
 	startedAt?: number;
 	lastAdvanceAt?: number;
+	dueAt?: number;
 }
 
 /** Apply the fields `add`'s upsert branch and `update` both accept, in place — the one place
@@ -229,10 +331,13 @@ function applyPatch(node: AgentNode, patch: AgentNodePatch): void {
 	if (patch.kind !== undefined) node.kind = patch.kind;
 	if (patch.agent !== undefined) node.agent = patch.agent;
 	if (patch.model !== undefined) node.model = patch.model;
+	if (patch.thinking !== undefined) node.thinking = patch.thinking;
+	if (patch.thinkingEffective !== undefined) 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;
 	if (patch.lastAdvanceAt !== undefined) node.lastAdvanceAt = patch.lastAdvanceAt;
+	if (patch.dueAt !== undefined) node.dueAt = patch.dueAt;
 }
 
 /** A small mutable registry with change notification. The extension owns one. */
@@ -268,7 +373,10 @@ 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 } : {}),
 		};
 		this.nodes.push(node);
 		this.emit({ type: "added", node: { ...node } });

package/src/ui/compact-widget.ts

@@ -0,0 +1,25 @@
+import { type Component, sliceByColumn, visibleWidth } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "./presentation.ts";
+
+/**
+ * Public setWidget factory for already-budgeted, raw-text rows. Unlike the host's
+ * string[]/Text path this never wraps: one source row occupies at most one terminal
+ * row. Right-edge clipping preserves tree indentation and leading semantic markers;
+ * F9/exocom_list remain the full-detail surfaces.
+ *
+ * Snapshot and sanitize once per publication, without trimming/collapsing indentation.
+ * No theme colors are captured; each render uses its supplied width (including resize).
+ */
+export function compactWidget(rows: readonly string[]): () => Component {
+	const lines = rows.map((row) => sanitizeTerminalText(row.replace(/\t/g, " ")).replace(/[\n\u2028\u2029]/g, " "));
+	return () => ({
+		render(width: number): string[] {
+			const columns = Math.max(0, Math.floor(width));
+			if (columns === 0) return [];
+			return lines.map((line) => visibleWidth(line) <= columns
+				? line
+				: `${sliceByColumn(line, 0, columns - 1, true)}…`);
+		},
+		invalidate(): void { /* No width/theme-dependent cache. */ },
+	});
+}

package/src/ui/failure-summary.ts

@@ -0,0 +1,55 @@
+import { compactInlineText, sanitizeTerminalText } from "./presentation.ts";
+
+const MAX_INSPECTED_CHARS = 16_384;
+const MAX_SUMMARY_COLUMNS = 140;
+
+/** Display-only cause preview. The caller retains the original error for diagnostics. */
+export function summarizeFailure(error: string): string {
+	let source = sanitizeTerminalText(error.slice(0, MAX_INSPECTED_CHARS)).trim();
+	// Omit only the runtime's identity/model wrapper, not meaningful tags such as [BLOCKED].
+	const wrapperEnd = source.startsWith("[") ? source.indexOf("]") : -1;
+	if (wrapperEnd > 0 && wrapperEnd <= 512 && source.slice(1, wrapperEnd).includes(" · ")) source = source.slice(wrapperEnd + 1).trim();
+	const reason = sanitizeTerminalText(jsonCause(source) ?? source).replace(/\s+/g, " ").trim();
+	if (/^(?:(?:the|this)\s+)?(?:['"`][^'"`]{1,200}['"`]\s+)?model\s+is\s+not\s+supported\s+when\s+using\s+Codex\s+with\s+a\s+ChatGPT\s+account[.!]?$/i.test(reason)) {
+		return "Model not supported by this ChatGPT account.";
+	}
+	return compactInlineText(reason, { maxChars: MAX_SUMMARY_COLUMNS });
+}
+
+/** Scan one bounded object, respecting JSON strings; never retry parsing at every brace. */
+function jsonCause(source: string): string | undefined {
+	const start = source.indexOf("{");
+	if (start < 0) return undefined;
+	let depth = 0;
+	let quoted = false;
+	let escaped = false;
+	for (let index = start; index < source.length; index++) {
+		const char = source[index];
+		if (quoted) {
+			if (escaped) escaped = false;
+			else if (char === "\\") escaped = true;
+			else if (char === '"') quoted = false;
+		} else if (char === '"') quoted = true;
+		else if (char === "{") depth++;
+		else if (char === "}" && --depth === 0) {
+			try { return objectCause(JSON.parse(source.slice(start, index + 1)) as unknown); }
+			catch { return undefined; }
+		}
+	}
+	return undefined;
+}
+
+function objectCause(value: unknown): string | undefined {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const object = value as Record<string, unknown>;
+	for (const field of [object.detail, object.message, object.error]) {
+		if (typeof field === "string" && field.trim()) return field;
+	}
+	if (object.error !== null && typeof object.error === "object" && !Array.isArray(object.error)) {
+		const error = object.error as Record<string, unknown>;
+		for (const field of [error.message, error.detail]) {
+			if (typeof field === "string" && field.trim()) return field;
+		}
+	}
+	return undefined;
+}

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

@@ -0,0 +1,24 @@
+/** One compact renderer for literal control receipts and diagnostic fallbacks. Pi owns the shell. */
+import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { compactVisibleText, sanitizeTerminalText } from "./presentation.ts";
+
+interface LiteralResult {
+	content: readonly { type: string; text?: string }[];
+	/** Direct internal renderer calls carry this; Pi passes it in the render context. */
+	isError?: boolean;
+}
+
+export function renderLiteralToolResult(
+	result: LiteralResult,
+	{ expanded }: { expanded: boolean },
+	theme: Theme,
+	context?: { isError: boolean },
+): Text {
+	const full = sanitizeTerminalText(result.content.filter((part) => part.type === "text").map((part) => part.text ?? "").join("\n")) || "(no output)";
+	const failed = context?.isError ?? result.isError ?? false;
+	const preview = expanded ? undefined : compactVisibleText(full, { maxLines: 4, maxLineChars: 100 });
+	const heading = failed ? `${theme.fg("error", theme.bold("failed"))}\n` : "";
+	const hint = preview?.truncated ? `\n${theme.fg("dim", keyHint("app.tools.expand", "to expand"))}` : "";
+	return new Text(`${heading}${theme.fg("toolOutput", preview?.text ?? full)}${hint}`, 0, 0);
+}