@tshu-w/pi-agents 0.2.0 → 0.2.2

package/src/render-call.ts

@@ -1,5 +1,15 @@
-import { keyHint } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
+import { DEFAULT_MAX_BYTES, formatSize, keyHint, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
+import {
+	type Component,
+	Container,
+	getCapabilities,
+	getImageDimensions,
+	imageFallback,
+	Spacer,
+	Text,
+	truncateToWidth,
+} from "@earendil-works/pi-tui";
+import type { Truncation } from "./output.ts";
 
 type ToolCallTheme = {
 	bold(text: string): string;
@@ -37,7 +47,8 @@ export function startDuration(state: DurationState, enabled: boolean, executionS
 	if (enabled && executionStarted && state.startedAt === undefined) state.startedAt = Date.now();
 }
 
-function formatDuration(ms: number): string {
+/** Durations as Pi shows them: `4.2s` below a minute, then `1m 30s` and `2h 3m 4s`. */
+export function formatDuration(ms: number): string {
 	const seconds = ms / 1000;
 	if (seconds < 60) return `${seconds.toFixed(1)}s`;
 	const totalSeconds = Math.floor(seconds);
@@ -60,31 +71,118 @@ function updateDuration(state: DurationState, isPartial: boolean, durationMs: nu
 }
 
 interface ResultTheme {
-	fg(color: "toolOutput" | "muted", text: string): string;
+	fg(color: "toolOutput" | "muted" | "warning", text: string): string;
+	bold(text: string): string;
+}
+
+// As in Pi's `codemode` output.
+const BLOCK_PREVIEW_LINES = 5;
+
+// Pi's `stripAnsi` pattern, derived from ansi-regex (MIT), which Pi does not export: OSC sequences ended by ST, and CSI sequences.
+const ANSI = /\x1b\][\s\S]*?(?:\x07|\x1b\\|\x9c)|[\x1b\x9b][[\]()#;?]*(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]/g;
+
+/**
+ * `text` as Pi shows tool output: without ANSI sequences, carriage returns, or the control characters Pi's
+ * `sanitizeBinaryOutput` removes, which it does not export; and with tabs as 3 spaces.
+ */
+function displayText(text: string): string {
+	return text.replace(ANSI, "").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\uFFF9-\uFFFB]/g, "").replace(/\r/g, "").replace(/\t/g, "   ");
+}
+
+/** Placeholders for a result's images where Pi shows them as text: when the terminal cannot show images or they are hidden. */
+function imageText(content: Array<{ type: string; data?: string; mimeType?: string }>, showImages: boolean | undefined): string {
+	if (getCapabilities().images && showImages) return "";
+	return content.flatMap((part) => part.type !== "image" ? [] : [imageFallback(
+		part.mimeType ?? "image/unknown",
+		part.data && part.mimeType ? getImageDimensions(part.data, part.mimeType) ?? undefined : undefined,
+	)]).join("\n");
+}
+
+/** Styled non-blank lines of `text`. */
+function outputText(text: string, theme: ResultTheme): string {
+	return displayText(text).split("\n").filter((line) => line.trim()).map((line) => theme.fg("toolOutput", line)).join("\n");
+}
+
+/** The warning Pi's bash renderer shows for truncated output. */
+function truncationWarning({ truncation, fullOutputPath }: Partial<Truncation>, theme: ResultTheme): string | undefined {
+	const warnings: string[] = [];
+	if (fullOutputPath) warnings.push(`Full output: ${fullOutputPath}`);
+	if (truncation?.truncated) {
+		warnings.push(truncation.truncatedBy === "lines"
+			? `Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`
+			: `Truncated: ${truncation.outputLines} lines shown (${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`);
+	}
+	return warnings.length > 0 ? theme.fg("warning", `[${warnings.join(". ")}]`) : undefined;
+}
+
+/**
+ * The collapsed view of `wait` results: each result as its line in bold, then the first visual lines of its body without
+ * blank lines, indented, and the number of lines after them; then the notes, without blank lines, and the truncation
+ * warning as Pi's bash renderer shows it. Like Pi's `codemode` output preview, it counts wrapped lines and caches its
+ * lines per width.
+ */
+export function renderResultList(results: { line: string; body: string }[], notes: string[], truncated: Partial<Truncation>, theme: ResultTheme): Component {
+	let cached: { width: number; lines: string[] } | undefined;
+	return {
+		render(width) {
+			if (cached?.width !== width) {
+				const lines: string[] = [];
+				for (const { line, body } of results) {
+					lines.push(...new Text(theme.fg("toolOutput", theme.bold(displayText(line))), 0, 0).render(width));
+					const preview = truncateToVisualLines(outputText(body, theme), BLOCK_PREVIEW_LINES, width - 2, 0, "start");
+					lines.push(...preview.visualLines.map((visual) => `  ${visual}`));
+					if (preview.skippedCount > 0) lines.push(truncateToWidth(`  ${moreLines(preview.skippedCount, theme)}`, width, "..."));
+				}
+				lines.push(...new Text(outputText(notes.join("\n"), theme), 0, 0).render(width));
+				const warning = truncationWarning(truncated, theme);
+				if (warning) lines.push(...new Text(warning, 0, 0).render(width));
+				cached = { width, lines };
+			}
+			return cached.lines;
+		},
+		invalidate() {
+			cached = undefined;
+		},
+	};
 }
 
 /**
  * The text output like Pi's default result, with the duration of a timed call below it.
- * Like Pi's `bash` result, a blank line precedes the output and the duration.
+ * Like Pi's `bash` result, a blank line precedes the output and the duration. When collapsed, `tidy` may show its view
+ * instead, followed by the placeholders of the result's images.
  */
 export function renderTextResult(
-	result: { content: Array<{ type: string; text?: string }> },
+	result: { content: Array<{ type: string; text?: string; data?: string; mimeType?: string }> },
 	options: { expanded: boolean; isPartial: boolean },
 	theme: ResultTheme,
-	context: { state: unknown; invalidate: () => void; lastComponent?: unknown; durationMs?: number },
-): Text {
-	const output = result.content.flatMap((part) => part.type === "text" && part.text ? [part.text] : []).join("\n").trim();
+	context: { state: unknown; invalidate: () => void; lastComponent?: unknown; durationMs?: number; showImages?: boolean },
+	tidy?: () => Component | undefined,
+): Component {
+	const images = imageText(result.content, context.showImages);
+	// As Pi's text output of a result: its text items, then its image placeholders.
+	const text = result.content.flatMap((part) => part.type === "text" && part.text ? [displayText(part.text)] : []).join("\n");
+	const output = [text, images].filter(Boolean).join("\n").trim();
 	const lines = output ? output.split("\n") : [];
 	const shown = options.expanded ? lines : lines.slice(0, RESULT_PREVIEW_LINES);
-	const sections: string[] = [];
-	if (shown.length > 0) {
+	const tidied = options.expanded ? undefined : tidy?.();
+	const sections: Component[] = [];
+	if (tidied) {
+		const section = new Container();
+		section.addChild(tidied);
+		if (images) section.addChild(new Text(theme.fg("toolOutput", images), 0, 0));
+		sections.push(section);
+	} else if (shown.length > 0) {
 		let text = shown.map((line) => theme.fg("toolOutput", line)).join("\n");
 		if (shown.length < lines.length) text += `\n${moreLines(lines.length - shown.length, theme)}`;
-		sections.push(text);
+		sections.push(new Text(text, 0, 0));
 	}
 	const duration = updateDuration(context.state as DurationState, options.isPartial, context.durationMs, context.invalidate);
-	if (duration) sections.push(theme.fg("muted", duration));
-	const component = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
-	component.setText(sections.map((section) => `\n${section}`).join("\n"));
+	if (duration) sections.push(new Text(theme.fg("muted", duration), 0, 0));
+	const component = context.lastComponent instanceof Container ? context.lastComponent : new Container();
+	component.clear();
+	for (const section of sections) {
+		component.addChild(new Spacer(1));
+		component.addChild(section);
+	}
 	return component;
 }

package/src/roots/paths.mjs

@@ -39,7 +39,7 @@ export function agentDir(env = process.env) {
 }
 
 /** The session directory configured without `--session-dir`: PI_CODING_AGENT_SESSION_DIR, then the global `sessionDir` setting. */
-export function configuredSessionDir(env = process.env) {
+function configuredSessionDir(env = process.env) {
   if (env.PI_CODING_AGENT_SESSION_DIR) return resolvePath(env.PI_CODING_AGENT_SESSION_DIR);
   let setting;
   try { setting = JSON.parse(readFileSync(join(agentDir(env), 'settings.json'), 'utf8').replace(/^\uFEFF/, '')).sessionDir; }
@@ -52,9 +52,9 @@ export function sessionDir(env = process.env) {
   return configuredSessionDir(env) ?? join(agentDir(env), 'sessions');
 }
 
-/** The directory Pi keeps a cwd's Sessions in when none is configured. */
-export function defaultSessionDir(cwd, env = process.env) {
-  return join(agentDir(env), 'sessions', `--${resolve(cwd).replace(/^\//, '').replace(/[/\\:]/g, '-')}--`);
+/** The directory Pi keeps a cwd's Sessions in when none is configured, as Pi's unexported `getDefaultSessionDirPath`. */
+export function defaultSessionDir(cwd, agentDirectory) {
+  return join(resolve(agentDirectory), 'sessions', `--${resolve(cwd).replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`);
 }
 
 export async function prepareDirectory(directory) {

package/src/ui/message.ts

@@ -0,0 +1,24 @@
+import { getMarkdownTheme, UserMessageComponent, type MessageRenderer } from "@earendil-works/pi-coding-agent";
+import { Box, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import { messageBody, type Sender } from "../agents/registry.ts";
+
+/**
+ * Collapsed, a message from another Agent shows its sender after the label, as Pi shows a collapsed skill, and the
+ * user's input from the task viewer shows as a user message. Expanded, or for any other message, Pi shows the text the
+ * model received.
+ */
+export const renderAgentMessage: MessageRenderer = (message, { expanded, outputPad }, theme) => {
+	if (expanded || typeof message.content !== "string") return undefined;
+	const details = message.details as { user?: boolean; sender?: Sender } | undefined;
+	if (details?.user) return new UserMessageComponent(message.content, getMarkdownTheme(), outputPad);
+	const body = details?.sender && messageBody(message.content, details.sender);
+	if (body === undefined) return undefined;
+	const { id, name } = details!.sender!;
+	const box = new Box(outputPad, 1, (text) => theme.bg("customMessageBg", text));
+	const label = theme.fg("customMessageLabel", `\x1b[1m[${message.customType}]\x1b[22m`);
+	const sender = name === undefined ? theme.fg("customMessageText", ` from ${id}`) : theme.fg("customMessageText", ` from ${name}`) + theme.fg("dim", ` (${id})`);
+	box.addChild(new Text(label + sender, 0, 0));
+	box.addChild(new Spacer(1));
+	box.addChild(new Markdown(body, 0, 0, getMarkdownTheme(), { color: (text) => theme.fg("customMessageText", text) }));
+	return box;
+};

package/src/ui/queue.ts

@@ -1,16 +1,17 @@
 import type { AgentSession, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { TruncatedText, type TUI } from "@earendil-works/pi-tui";
-import { MESSAGE_TAG, MESSAGE_TYPE } from "../agents/registry.ts";
+import { messageBody, MESSAGE_TYPE, type Sender } from "../agents/registry.ts";
 
 const WIDGET_KEY = "pi-agents-queue";
 
-type Queued = { role: string; customType?: string; content?: unknown; details?: { delivery?: string } };
+type Queued = { role: string; customType?: string; content?: unknown; details?: { delivery?: string; sender?: Sender } };
 
 /** One line for an Agent message: its sender and body. */
-function summary(content: unknown): string {
+function summary({ content, details }: Queued): string {
 	const text = typeof content === "string" ? content : "";
-	const match = new RegExp(`^<${MESSAGE_TAG} from="([^"]*)"[^>]*>\\n([\\s\\S]*)\\n</${MESSAGE_TAG}>$`).exec(text);
-	return (match ? `[${match[1]}] ${match[2]}` : text).replace(/\s+/g, " ").trim();
+	const sender = details?.sender;
+	const body = sender && messageBody(text, sender);
+	return (body === undefined ? text : `[${sender!.name ?? sender!.id}] ${body}`).replace(/\s+/g, " ").trim();
 }
 
 /** Agent messages waiting in the Session's queues, which Pi does not list as it lists the user's. */
@@ -19,7 +20,7 @@ export function queuedLines(agent: AgentSession["agent"]): string[] {
 	const lines = (label: string, messages: Queued[]) => messages
 		.filter((message) => message.role === "custom" && message.customType === MESSAGE_TYPE)
 		// A write waits in the steering queue but asks for nothing, so it is labeled apart from a steer.
-		.map((message) => `${message.details?.delivery === "write" ? "Write" : label}: ${summary(message.content)}`);
+		.map((message) => `${message.details?.delivery === "write" ? "Write" : label}: ${summary(message)}`);
 	return [...lines("Steering", queues.steeringQueue.messages), ...lines("Follow-up", queues.followUpQueue.messages)];
 }
 

package/src/ui/viewer.ts

@@ -1,5 +1,7 @@
 import {
 	AssistantMessageComponent,
+	BashExecutionComponent,
+	BranchSummaryMessageComponent,
 	CompactionSummaryMessageComponent,
 	CustomEditor,
 	CustomMessageComponent,
@@ -8,7 +10,8 @@ import {
 	getMarkdownTheme,
 	getSelectListTheme,
 	keyHint,
-	keyText,
+	parseSkillBlock,
+	SkillInvocationMessageComponent,
 	ToolExecutionComponent,
 	UserMessageComponent,
 	type AgentSession,
@@ -22,7 +25,6 @@ import {
 	fuzzyFilter,
 	Input,
 	Loader,
-	matchesKey,
 	SelectList,
 	Spacer,
 	Text,
@@ -96,7 +98,7 @@ class AgentViewer implements Component, Focusable {
 	private live?: { component: AssistantMessageComponent; calls: string };
 	/** Tool components without a result from the last rebuild. */
 	private tools = new Map<string, ToolExecutionComponent>();
-	private running = new Map<string, { name: string; partial?: ToolResult }>();
+	private running = new Map<string, { partial?: ToolResult }>();
 	private expanded = false;
 	/** Lines scrolled up from the end. */
 	private scroll = 0;
@@ -111,7 +113,7 @@ class AgentViewer implements Component, Focusable {
 	constructor(
 		private tui: TUI,
 		private theme: Theme,
-		keys: KeybindingsManager,
+		private keys: KeybindingsManager,
 		private ctx: ExtensionContext,
 		private owner: AgentNode,
 		private entry: Entry,
@@ -152,8 +154,9 @@ class AgentViewer implements Component, Focusable {
 
 	handleInput(data: string): void {
 		const page = Math.max(1, this.tui.terminal.rows - 8);
-		if (matchesKey(data, "pageUp")) this.scroll += page;
-		else if (matchesKey(data, "pageDown")) this.scroll = Math.max(0, this.scroll - page);
+		// The page keys of Pi's fullscreen mode.
+		if (this.keys.matches(data, "tui.altScreen.pageUp")) this.scroll += page;
+		else if (this.keys.matches(data, "tui.altScreen.pageDown")) this.scroll = Math.max(0, this.scroll - page);
 		else this.editor.handleInput(data);
 		this.tui.requestRender();
 	}
@@ -217,7 +220,7 @@ class AgentViewer implements Component, Focusable {
 		this.disposers.push(session.subscribe((event) => {
 			if (event.type === "message_start" || event.type === "message_update") this.streaming = event.message;
 			else if (event.type === "message_end") this.streaming = undefined;
-			else if (event.type === "tool_execution_start") this.running.set(event.toolCallId, { name: event.toolName });
+			else if (event.type === "tool_execution_start") this.running.set(event.toolCallId, {});
 			else if (event.type === "tool_execution_update") {
 				const tool = this.running.get(event.toolCallId);
 				if (tool) tool.partial = event.partialResult as ToolResult;
@@ -234,7 +237,7 @@ class AgentViewer implements Component, Focusable {
 			if (!this.live || event.message.role !== "assistant") return false;
 			const calls = event.message.content.flatMap((part) => part.type === "toolCall" ? [part] : []);
 			if (calls.map((call) => call.id).join("\n") !== this.live.calls) return false;
-			this.live.component.updateContent(event.message);
+			this.live.component.updateContent(event.message, true);
 			for (const call of calls) this.tools.get(call.id)?.updateArgs(call.arguments);
 			return true;
 		}
@@ -254,20 +257,19 @@ class AgentViewer implements Component, Focusable {
 		this.tui.requestRender();
 	}
 
-	/** The working status in the editor's border, and its color from the Agent's thinking level, as in Pi. */
+	/**
+	 * The working status in the editor's border, and its color from the Agent's thinking level, as in Pi: `Working`,
+	 * spinner and text in the border's color.
+	 */
 	private syncStatus(conversation: ReturnType<AgentNode["agents"]["conversation"]>): void {
 		this.editor.borderColor = this.theme.getThinkingBorderColor((conversation?.thinkingLevel ?? "off") as never);
 		const state = this.owner.agents.counts(this.entry.id)?.state;
-		const busy = state === "running" || state === "waiting";
-		const tool = [...this.running.values()].at(-1);
-		const abort = `${keyText("app.interrupt")} to abort`;
-		const text = !busy ? "" : tool ? `Running ${tool.name}... (${abort})` : `Working... (${abort})`;
+		const text = state === "running" || state === "waiting" ? "Working" : "";
 		if (text === this.status) return;
 		this.status = text;
 		this.indicator?.dispose();
-		this.indicator = text
-			? new WorkingStatus(this.tui, (part) => this.editor.borderColor(part), (part) => this.theme.fg("muted", part), text)
-			: undefined;
+		const color = (part: string) => this.editor.borderColor(part);
+		this.indicator = text ? new WorkingStatus(this.tui, color, color, text) : undefined;
 		this.editor.setWorkingStatusIndicator(this.indicator as unknown as StatusIndicator);
 	}
 
@@ -285,23 +287,33 @@ class AgentViewer implements Component, Focusable {
 		this.outbox = this.outbox.filter(({ text, after }) => working && !messages.slice(after).some((message) =>
 			message.role === "custom" && message.content === text && (message.details as { user?: boolean } | undefined)?.user));
 		if (this.streaming && !messages.includes(this.streaming)) messages.push(this.streaming);
-		const markdown = getMarkdownTheme();
+		// As Pi's chat shows them, with the display settings of the Session the viewer is in.
+		const current = agentSession(this.ctx.sessionManager);
+		const settings = current?.settingsManager;
+		const markdown = settings ? { ...getMarkdownTheme(), codeBlockIndent: settings.getCodeBlockIndent() } : getMarkdownTheme();
+		const transformers = current?.extensionRunner.getMarkdownTransformers();
+		const pad = settings?.getOutputPad() ?? 1;
+		const runner = (conversation.session ?? current)?.extensionRunner;
+		const images = { showImages: settings?.getShowImages() ?? false, imageWidthCells: settings?.getImageWidthCells(), outputPad: pad };
 		for (const message of messages) {
 			if (message.role === "assistant") {
-				const component = new AssistantMessageComponent(message, false, markdown);
+				const component = new AssistantMessageComponent(message, settings?.getHideThinkingBlock() ?? false, markdown, undefined, pad, transformers);
 				if (message === this.streaming) {
+					// As Pi does, so Markdown transformers know the message is still streaming.
+					component.updateContent(message, true);
 					const calls = message.content.flatMap((part) => part.type === "toolCall" ? [part.id] : []);
 					this.live = { component, calls: calls.join("\n") };
 				}
 				this.transcript.addChild(component);
 				for (const part of message.content) {
 					if (part.type !== "toolCall") continue;
-					const tool = new ToolExecutionComponent(part.name, part.id, part.arguments, { showImages: false },
+					const tool = new ToolExecutionComponent(part.name, part.id, part.arguments, images,
 						conversation.session?.getToolDefinition(part.name), this.tui, conversation.cwd);
 					tool.setExpanded(this.expanded);
 					this.transcript.addChild(tool);
 					if (message.stopReason === "aborted" || message.stopReason === "error") {
-						tool.updateResult({ content: [{ type: "text", text: message.errorMessage || "Operation aborted" }], isError: true });
+						const text = message.stopReason === "aborted" ? "Operation aborted" : message.errorMessage || "Error";
+						tool.updateResult({ content: [{ type: "text", text }], isError: true });
 					} else {
 						this.tools.set(part.id, tool);
 					}
@@ -312,23 +324,45 @@ class AgentViewer implements Component, Focusable {
 			} else if (message.role === "user") {
 				const text = typeof message.content === "string"
 					? message.content
-					: message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+					: message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
 				if (!text) continue;
 				this.transcript.addChild(new Spacer(1));
-				this.transcript.addChild(new UserMessageComponent(text, markdown));
+				const skill = parseSkillBlock(text);
+				if (skill) {
+					const component = new SkillInvocationMessageComponent(skill, markdown, pad);
+					component.setExpanded(this.expanded);
+					this.transcript.addChild(component);
+					if (skill.userMessage) {
+						this.transcript.addChild(new Spacer(1));
+						this.transcript.addChild(new UserMessageComponent(skill.userMessage, markdown, pad, transformers));
+					}
+				} else {
+					this.transcript.addChild(new UserMessageComponent(text, markdown, pad, transformers));
+				}
 			} else if (message.role === "custom" && message.display) {
 				const user = message.customType === MESSAGE_TYPE && (message.details as { user?: boolean } | undefined)?.user;
-				this.transcript.addChild(new Spacer(1));
 				if (user && typeof message.content === "string") {
-					this.transcript.addChild(new UserMessageComponent(message.content, markdown));
+					this.transcript.addChild(new Spacer(1));
+					this.transcript.addChild(new UserMessageComponent(message.content, markdown, pad, transformers));
 				} else {
-					const component = new CustomMessageComponent(message, undefined, markdown);
+					// The component starts with its own blank line.
+					const component = new CustomMessageComponent(message, runner?.getMessageRenderer(message.customType), markdown, pad);
 					component.setExpanded(this.expanded);
 					this.transcript.addChild(component);
 				}
-			} else if (message.role === "compactionSummary") {
+			} else if (message.role === "bashExecution") {
+				const component = new BashExecutionComponent(message.command, this.tui, message.excludeFromContext, pad);
+				if (message.output) component.appendOutput(message.output);
+				component.setComplete(message.exitCode, message.cancelled, message.truncated ? { truncated: true } as never : undefined, message.fullOutputPath);
+				component.setExpanded(this.expanded);
+				this.transcript.addChild(component);
+			} else if (message.role === "compactionSummary" || message.role === "branchSummary") {
 				this.transcript.addChild(new Spacer(1));
-				this.transcript.addChild(new CompactionSummaryMessageComponent(message, markdown));
+				const component = message.role === "compactionSummary"
+					? new CompactionSummaryMessageComponent(message, markdown, pad)
+					: new BranchSummaryMessageComponent(message, markdown, pad);
+				component.setExpanded(this.expanded);
+				this.transcript.addChild(component);
 			}
 		}
 		for (const [id, tool] of this.tools) {
@@ -359,8 +393,10 @@ class ProgramViewer implements Component, Focusable {
 		private done: () => void,
 	) {
 		const code = programs.view(id)?.code;
-		this.tool = new ToolExecutionComponent(PROGRAM_TOOL_NAME, `program-${id}`, { action: "run", background: true, ...(code !== undefined && { code }) }, { showImages: false },
-			agentSession(ctx.sessionManager)?.getToolDefinition(PROGRAM_TOOL_NAME), tui, ctx.cwd);
+		const settings = agentSession(ctx.sessionManager)?.settingsManager;
+		this.tool = new ToolExecutionComponent(PROGRAM_TOOL_NAME, `program-${id}`, { action: "run", background: true, ...(code !== undefined && { code }) }, {
+			showImages: settings?.getShowImages() ?? false, imageWidthCells: settings?.getImageWidthCells(), outputPad: settings?.getOutputPad(),
+		}, agentSession(ctx.sessionManager)?.getToolDefinition(PROGRAM_TOOL_NAME), tui, ctx.cwd);
 		this.tool.markExecutionStarted();
 		this.sync();
 		this.disposers.push(programs.onView(() => {
@@ -376,8 +412,8 @@ class ProgramViewer implements Component, Focusable {
 		else if (this.keys.matches(data, "app.tools.expand" as never)) {
 			this.expanded = !this.expanded;
 			this.tool.setExpanded(this.expanded);
-		} else if (matchesKey(data, "pageUp")) this.scroll += page;
-		else if (matchesKey(data, "pageDown")) this.scroll = Math.max(0, this.scroll - page);
+		} else if (this.keys.matches(data, "tui.altScreen.pageUp")) this.scroll += page;
+		else if (this.keys.matches(data, "tui.altScreen.pageDown")) this.scroll = Math.max(0, this.scroll - page);
 		this.tui.requestRender();
 	}
 

package/src/workbench.mjs

@@ -38,23 +38,21 @@ function textOf(content) {
   return Array.isArray(content) ? content.filter(block => block?.type === 'text').map(block => block.text).join('\n') : '';
 }
 
-/** The messages on the Session's active branch since its last compaction, oldest first. */
-async function branchMessages(file) {
-  const entries = new Map();
+/** The messages on the Session's active branch since its last compaction, oldest first, read as Pi reads the Session. */
+async function branchMessages(pi, file) {
+  const entries = pi.parseSessionEntries(await readFile(file, 'utf8'));
+  // Older Sessions take Pi's current form.
+  pi.migrateSessionEntries(entries);
+  const byId = new Map();
   let leaf;
-  for (const line of (await readFile(file, 'utf8')).split('\n')) {
-    let entry;
-    try { entry = JSON.parse(line); } catch { continue; }
+  for (const entry of entries) {
     if (typeof entry?.id !== 'string' || entry.type === 'session') continue;
-    entries.set(entry.id, entry);
+    byId.set(entry.id, entry);
     leaf = entry;
   }
-  const messages = [];
-  for (let entry = leaf; entry && entry.type !== 'compaction'; entry = entries.get(entry.parentId)) {
-    if (entry.type === 'message' && entry.message) messages.push(entry.message);
-    else if (entry.type === 'custom_message') messages.push({ role: 'custom', ...entry });
-  }
-  return messages.reverse();
+  const branch = [];
+  for (let entry = leaf; entry && entry.type !== 'compaction'; entry = byId.get(entry.parentId)) branch.push(entry);
+  return branch.reverse().flatMap(entry => pi.sessionEntryToContextMessages(entry));
 }
 
 function age(ms) {
@@ -206,13 +204,13 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
       hints.keyHint('app.tools.expand', 'attach'),
       hints.rawKeyHint(['lineUp', 'halfPageUp', 'pageUp', 'lineDown', 'halfPageDown', 'pageDown']
         .map(name => hints.keyText(`tui.altScreen.${name}`)).filter(Boolean).join('/'), 'scroll'),
-      hints.rawKeyHint(`${detach}/esc`, 'close'),
+      hints.rawKeyHint(`${detach}/${hints.keyText('tui.select.cancel')}`, 'close'),
     ].join(theme.fg('muted', ' · ')) : [
-      hints.rawKeyHint('enter', 'attach'),
+      hints.keyHint('tui.select.confirm', 'attach'),
       hints.rawKeyHint(detach, 'quit'),
       hints.rawKeyHint('space', 'preview'),
       hints.rawKeyHint('ctrl+x', 'stop'),
-      hints.rawKeyHint('ctrl+d', 'remove'),
+      hints.keyHint('app.session.delete', 'remove'),
       hints.rawKeyHint('@', 'message'),
       hints.rawKeyHint('/', 'commands'),
     ].join(theme.fg('muted', ' · '));
@@ -282,11 +280,11 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
       // As in a Session, the detach key leaves and everything keeps running; in the preview, it returns to the list.
       if (isDetach(data)) return void (pane ? pane.close() : quit());
       if (pane?.handleInput(data, empty)) return;
-      if (T.matchesKey(data, 'ctrl+c')) {
+      if (keybindings.matches(data, 'app.clear')) {
         if (!empty) return editor.setText(pane?.mention ?? '');
         if (Date.now() - lastCtrlC < 1000) return void quit();
         lastCtrlC = Date.now();
-        return say('Press Ctrl+C again to quit');
+        return say(`Press ${hints.keyText('app.clear')} again to quit`);
       }
       if (T.matchesKey(data, 'ctrl+x')) return interrupt();
       if (empty && keybindings.matches(data, 'app.session.delete')) return void remove(selected()?.session);
@@ -297,10 +295,10 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
         if (pane && !editor.getText().startsWith(pane.mention)) editor.setText(before);
         return;
       }
-      if (empty && T.matchesKey(data, 'escape')) return void quit();
-      if (empty && T.matchesKey(data, 'up')) return move(-1);
-      if (empty && T.matchesKey(data, 'down')) return move(1);
-      if (empty && T.matchesKey(data, 'enter')) return void open(selected());
+      if (empty && keybindings.matches(data, 'tui.select.cancel')) return void quit();
+      if (empty && keybindings.matches(data, 'tui.select.up')) return move(-1);
+      if (empty && keybindings.matches(data, 'tui.select.down')) return move(1);
+      if (empty && keybindings.matches(data, 'tui.select.confirm')) return void open(selected());
       if (empty && T.matchesKey(data, 'space')) return void preview(selected()?.session);
       if (empty && data === '@') return pick(session => {
         picked = { session, mention: `@${mention(session)} ` };
@@ -425,7 +423,7 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
   async function preview(session) {
     if (!session?.sessionFile) return;
     let messages;
-    try { messages = await branchMessages(session.sessionFile); }
+    try { messages = await branchMessages(pi, session.sessionFile); }
     catch (error) { return say(error.message, 'error'); }
     let body = conversation(messages);
     const border = themes.getEditorTheme().borderColor;
@@ -437,7 +435,7 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
     const watcher = watch(session.sessionFile, () => {
       clearTimeout(timer);
       timer = setTimeout(async () => {
-        try { body = conversation(await branchMessages(session.sessionFile)); }
+        try { body = conversation(await branchMessages(pi, session.sessionFile)); }
         catch (error) { return say(error.message, 'error'); }
         see();
         ui.requestRender();
@@ -482,16 +480,16 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
       },
       /** Enter, `↑`/`↓`, and Space act on the preview only while no message is typed. */
       handleInput(data, empty) {
-        if (keybindings.matches(data, 'app.tools.expand') || (empty && T.matchesKey(data, 'enter'))) {
+        if (keybindings.matches(data, 'app.tools.expand') || (empty && keybindings.matches(data, 'tui.select.confirm'))) {
           close();
           void openSession(session);
           return true;
         }
-        if (!empty && T.matchesKey(data, 'escape')) {
+        if (!empty && keybindings.matches(data, 'tui.select.cancel')) {
           editor.setText(pane.mention);
           return true;
         }
-        if (T.matchesKey(data, 'escape') || (empty && (T.matchesKey(data, 'space') || T.matchesKey(data, 'ctrl+c')))) {
+        if (keybindings.matches(data, 'tui.select.cancel') || (empty && (T.matchesKey(data, 'space') || keybindings.matches(data, 'app.clear')))) {
           close();
           return true;
         }
@@ -499,7 +497,7 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
         const half = Math.max(1, Math.floor(page / 2));
         const steps = { lineUp: 1, lineDown: -1, halfPageUp: half, halfPageDown: -half, pageUp: page - 1, pageDown: 1 - page, top: Infinity, bottom: -Infinity };
         const action = Object.keys(steps).find(name => keybindings.matches(data, `tui.altScreen.${name}`));
-        const step = empty && T.matchesKey(data, 'up') ? 1 : empty && T.matchesKey(data, 'down') ? -1 : action ? steps[action] : 0;
+        const step = empty && keybindings.matches(data, 'tui.select.up') ? 1 : empty && keybindings.matches(data, 'tui.select.down') ? -1 : action ? steps[action] : 0;
         if (!step) return false;
         scroll = Math.max(0, scroll + step);
         // As in Pi's `auto` mode, the scrollbar shows while scrolling and for a second after.
@@ -514,20 +512,27 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
     ui.requestRender(true);
   }
 
-  /** Messages and replies as Pi shows them; thinking is left out and each run of tool calls folds to one line. */
+  /**
+   * Messages and replies as Pi shows them; thinking is left out, and each run of tool calls, branch summary, and custom
+   * message other than the user's input folds to one line.
+   */
   function conversation(messages) {
     const markdown = themes.getMarkdownTheme();
     const view = new T.Container();
     let tools = [];
+    // Pi's hint for folded output: "... (36 more lines, …)".
+    const summarize = summary => {
+      view.addChild(new T.Spacer(1));
+      view.addChild(new T.Text(theme.fg('muted', `... (${summary})`), 1, 0));
+    };
     const fold = () => {
       if (!tools.length) return;
-      // Pi's hint for folded output: "... (36 more lines, …)".
-      const names = [...new Set(tools)].join(', ');
-      view.addChild(new T.Spacer(1));
-      view.addChild(new T.Text(theme.fg('muted', `... (${tools.length} tool call${tools.length > 1 ? 's' : ''}: ${names})`), 1, 0));
+      summarize(`${tools.length} tool call${tools.length > 1 ? 's' : ''}: ${[...new Set(tools)].join(', ')}`);
       tools = [];
     };
     for (const message of messages) {
+      // As in Pi's chat, a custom message not for display is skipped.
+      if (message.role === 'custom' && !message.display) continue;
       const user = message.role === 'user' || (message.role === 'custom' && message.customType === 'pi-agents' && message.details?.user);
       if (user) {
         const text = textOf(message.content).trim();
@@ -542,6 +547,13 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
           view.addChild(new pi.AssistantMessageComponent({ ...message, content }, true, markdown));
         }
         tools.push(...message.content.flatMap(part => part.type === 'toolCall' ? [part.name] : []));
+      } else if (message.role === 'branchSummary') {
+        fold();
+        summarize('branch summary');
+      } else if (message.role === 'custom') {
+        const from = message.customType === 'pi-agents' ? message.details?.sender?.name ?? message.details?.sender?.id : undefined;
+        fold();
+        summarize(from ? `message from ${from}` : `${message.customType} message`);
       }
     }
     fold();