@oh-my-pi/pi-tui 18.13.2 → 18.14.0

package/src/chat/chat-transcript-builder.ts

@@ -65,8 +65,9 @@ import {
 	routeLateDiagnostics,
 } from "./late-diagnostics-message";
 import { groupedReadUsageCallIds, ReadToolGroupComponent, readArgsCollapseIntoGroup } from "./read-tool-group";
+import { isReplyWrite, ReplyWriteComponent, replyDisplayMessage, toolResultReplies } from "./reply-write";
 import { SkillMessageComponent } from "./skill-message";
-import { ToolExecutionComponent } from "./tool-execution";
+import { ToolExecutionComponent, type ToolExecutionHandle } from "./tool-execution";
 import { TranscriptContainer } from "../chrome/transcript-container";
 import { createUsageRowBlock, TurnUsageTally, turnElapsedMs } from "../overlays/usage-row";
 import { CollapsedSyntheticMessageComponent, UserMessageComponent } from "./user-message";
@@ -90,7 +91,7 @@ export interface ChatTranscriptBuilderDeps {
 
 export class ChatTranscriptBuilder {
 	readonly container = new TranscriptContainer();
-	#pendingTools = new Map<string, ToolExecutionComponent | ReadToolGroupComponent>();
+	#pendingTools = new Map<string, ToolExecutionHandle>();
 	#readArgs = new Map<string, Record<string, unknown>>();
 	#readGroup: ReadToolGroupComponent | null = null;
 	#pendingUsage: Usage | undefined;
@@ -203,6 +204,15 @@ export class ChatTranscriptBuilder {
 		this.#expandables.push(component);
 	}
 
+	/** Append assistant prose (a reply, a post-tool segment, or an `out://` reply write) with the transcript's display preferences. */
+	#mountProse(component: AssistantMessageComponent): void {
+		component.setImagesVisible(displayPreferences.showImages);
+		component.setToolResultImagesVisible(!displayPreferences.hideToolActivity);
+		component.setTableChartsVisible(this.#deps.tableCharts !== false);
+		this.#trackExpandable(component);
+		this.container.addChild(component);
+	}
+
 	/** A `wait` showing all-running is displaced by the next `wait` call. */
 	#resolveWaitingPoll(nextToolName?: string): void {
 		const previous = this.#waitingPoll;
@@ -417,12 +427,8 @@ export class ChatTranscriptBuilder {
 			this.#deps.linkTargets,
 			expandThinkingBlocks,
 		);
-		assistantComponent.setImagesVisible(displayPreferences.showImages);
-		assistantComponent.setToolResultImagesVisible(!displayPreferences.hideToolActivity);
-		assistantComponent.setTableChartsVisible(this.#deps.tableCharts !== false);
-		this.#trackExpandable(assistantComponent);
 		assistantComponent.pickReactionTarget(this.container.children);
-		this.container.addChild(assistantComponent);
+		this.#mountProse(assistantComponent);
 		let lastAssistantComponent = assistantComponent;
 
 		if (displayPreferences.cacheMissMarker) {
@@ -456,11 +462,7 @@ export class ChatTranscriptBuilder {
 				this.#deps.linkTargets,
 				expandThinkingBlocks,
 			);
-			component.setImagesVisible(displayPreferences.showImages);
-			component.setToolResultImagesVisible(!displayPreferences.hideToolActivity);
-			component.setTableChartsVisible(this.#deps.tableCharts !== false);
-			this.#trackExpandable(component);
-			this.container.addChild(component);
+			this.#mountProse(component);
 			lastAssistantComponent = component;
 		};
 
@@ -492,22 +494,37 @@ export class ChatTranscriptBuilder {
 
 			this.#readGroup?.seal();
 			this.#readGroup = null;
-			const component = new ToolExecutionComponent(
-				content.name,
-				content.arguments,
-				{
-					useBuiltInRenderer: this.#deps.isBuiltInTool?.(content.name) ?? true,
-					// Stable ids and Kitty placeholder cells keep images anchored
-					// while the transcript viewport scrolls and reflows.
-					showImages: displayPreferences.showImages,
-				},
-				this.#deps.getTool?.(content.name),
-				this.#deps.ui,
-				this.#deps.cwd,
-				content.id,
-			);
-			this.#trackExpandable(component);
-			this.container.addChild(component);
+			const builtIn = this.#deps.isBuiltInTool?.(content.name) ?? true;
+			let component: ToolExecutionHandle;
+			if (builtIn && isReplyWrite(content.name, content.arguments) === true) {
+				const reply = new ReplyWriteComponent({
+					requestRender: () => this.#deps.requestRender(),
+					imageBudget: this.#deps.ui.imageBudget,
+					linkTargets: this.#deps.linkTargets,
+				});
+				reply.updateArgs(content.arguments);
+				reply.setArgsComplete();
+				this.#mountProse(reply);
+				component = reply;
+			} else {
+				const card = new ToolExecutionComponent(
+					content.name,
+					content.arguments,
+					{
+						useBuiltInRenderer: builtIn,
+						// Stable ids and Kitty placeholder cells keep images anchored
+						// while the transcript viewport scrolls and reflows.
+						showImages: displayPreferences.showImages,
+					},
+					this.#deps.getTool?.(content.name),
+					this.#deps.ui,
+					this.#deps.cwd,
+					content.id,
+				);
+				this.#trackExpandable(card);
+				this.container.addChild(card);
+				component = card;
+			}
 
 			if (hasErrorStop && errorMessage) {
 				component.updateResult(
@@ -549,6 +566,19 @@ export class ChatTranscriptBuilder {
 			this.#readArgs.delete(message.toolCallId);
 			return;
 		}
+		for (const reply of toolResultReplies(message.details)) {
+			this.#mountProse(
+				new AssistantMessageComponent(
+					replyDisplayMessage(reply),
+					false,
+					() => this.#deps.requestRender(),
+					[],
+					this.#deps.ui.imageBudget,
+					true,
+					this.#deps.linkTargets,
+				),
+			);
+		}
 		if (!pending) return;
 		pending.updateResult(message, false, message.toolCallId);
 		this.#pendingTools.delete(message.toolCallId);

package/src/chat/compaction-summary-message.ts

@@ -10,6 +10,7 @@ import type { TspSpan } from "@oh-my-pi/pi-wire";
 import { md, node, span, text } from "../native/describe";
 import { type NativeChild, type NativeNode, type NativeUiEvent, rootToggleExpanded } from "../native/node";
 import { Memo } from "../native/memo";
+import { noticeRow } from "../chrome/transcript-notice";
 
 /** Divider labels per compaction method; unknown/legacy methods fall back to "compacted". */
 const COMPACTION_METHOD_LABELS: Record<string, string> = {
@@ -237,7 +238,7 @@ function compactionNativeDetail(message: CompactionSummaryMessage): NativeChild[
 			? `Summary · ${frames} snapcompact frame${frames === 1 ? "" : "s"} attached`
 			: "Summary of the earlier conversation";
 	const detail: NativeChild[] = [text([span(caption, "dim")], { role: "omp.compaction.caption", key: "caption" })];
-	if (message.warning) detail.push(text([span(message.warning, "warning")], { wrap: "word", key: "warning" }));
+	if (message.warning) detail.push(noticeRow("warning", message.warning, { key: "warning" }));
 	detail.push(md(message.summary, { key: "summary" }));
 	return detail;
 }

package/src/chat/display-preferences.ts

@@ -6,6 +6,8 @@ export interface ChatTranscriptDisplayPreferences {
 	cacheMissMarker: boolean;
 	showTokenUsage: boolean;
 	showTurnTime: boolean;
+	/** Max rows a collapsed advisor card shows below its header; 0 = no cap. */
+	advisorCollapsedLines: number;
 }
 
 /** Current transcript display preferences. */
@@ -16,6 +18,7 @@ export const chatTranscriptDisplayPreferences: ChatTranscriptDisplayPreferences
 	cacheMissMarker: false,
 	showTokenUsage: false,
 	showTurnTime: false,
+	advisorCollapsedLines: 0,
 };
 
 /** Apply host display preferences without pulling settings into the renderer. */

package/src/chat/extension-types.ts

@@ -1,3 +1,4 @@
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import type { Component, TUI } from "../tui";
 import type { Theme } from "../theme/theme";
 import type { CustomMessage, HookMessage } from "./messages";
@@ -30,6 +31,39 @@ export type AssistantThinkingRenderer = (
 	theme: Theme,
 ) => Component | undefined;
 
+export interface AssistantTextRenderContext {
+	/**
+	 * The message being drawn; `message.timestamp` identifies the reply for `ctx.ui.rerenderMessage()`.
+	 * After a tool call this is only the segment drawn there, so its `content` does not hold the whole reply.
+	 * A deep copy: editing it, at any depth, cannot change the stored reply.
+	 */
+	message: AssistantMessage;
+	/**
+	 * The text block's index in the full reply's `content`, also when the reply is drawn in segments
+	 * around tool calls; not an index into `message.content` for a segment. It counts the content as
+	 * currently stored: a transcript rebuild that drops tool calls left without a result shifts later
+	 * blocks down, so do not persist it as a permanent key.
+	 */
+	contentIndex: number;
+	/** The block's markdown as drawn so far, after any earlier renderer. */
+	text: string;
+	/** True while the block may still grow; false for its final render, a block sealed at a tool call, and later redraws. */
+	streaming: boolean;
+}
+
+/**
+ * Display-only transform of one assistant text block: returns the markdown to draw, or `undefined`
+ * to draw `context.text` unchanged. The session, exports and model context keep the original text.
+ */
+export type AssistantTextRenderer = (context: AssistantTextRenderContext) => string | undefined;
+
+/** Extension text renderers for one assistant component, and where its content starts in the full reply. */
+export interface AssistantTextRendering {
+	renderers: readonly AssistantTextRenderer[];
+	/** Index in the full reply's `content` of this component's first block; a segment after a tool call starts past it. */
+	contentOffset: number;
+}
+
 export interface HookMessageRenderOptions {
 	/** Whether the view is expanded */
 	expanded: boolean;

package/src/chat/reply-write.ts

@@ -0,0 +1,127 @@
+/**
+ * Replies: text the agent sends to a scheme whose writes are `reply`-scoped (`out://`)
+ * is its mid-turn message to the user, drawn as assistant prose so it can answer
+ * without ending its turn.
+ * - A `write` call to a reply URL draws as {@link ReplyWriteComponent}, streaming as the
+ *   call's arguments arrive, instead of a tool card.
+ * - Text a tool's commands write there (`printf … > out://` in bash) arrives in the
+ *   tool's result `details.replies` ({@link toolResultReplies}); transcripts draw each
+ *   one as a prose block after the call ({@link replyDisplayMessage}).
+ */
+import type { AssistantMessage, Usage } from "@oh-my-pi/pi-ai";
+import { isRecord } from "@oh-my-pi/pi-utils";
+import type { ImageBudget } from "../components/image";
+import { internalUrlSchemeSpec, internalUrlSchemeSpecs, splitUrlScheme } from "../tools/url-scheme-host";
+import { AssistantMessageComponent } from "./assistant-message";
+import type { ToolExecutionHandle, ToolResultFrame } from "./tool-execution";
+
+/**
+ * Whether a `toolName` call writes to a reply URL. `undefined` while streamed args cannot tell yet:
+ * no path so far, or a path that could still grow into a reply URL (`ou`, `out:/`). Callers holding
+ * final args treat `undefined` as `false`.
+ */
+export function isReplyWrite(toolName: string, args: unknown): boolean | undefined {
+	if (toolName !== "write") return false;
+	if (!isRecord(args)) return undefined;
+	const target = typeof args.path === "string" ? args.path : args.file_path;
+	if (typeof target !== "string") return undefined;
+	const url = splitUrlScheme(target);
+	if (url) return internalUrlSchemeSpec(url.scheme)?.write?.scope === "reply";
+	const lower = target.toLowerCase();
+	for (const [scheme, spec] of internalUrlSchemeSpecs()) {
+		if (spec.write?.scope === "reply" && `${scheme}://`.startsWith(lower)) return undefined;
+	}
+	return false;
+}
+
+/** Display options of a reply block; the rest of its presentation follows the assistant prose defaults. */
+export interface ReplyWriteOptions {
+	/** Repaint request for figures and images that finish loading after a render. */
+	readonly requestRender?: () => void;
+	readonly imageBudget?: ImageBudget;
+	/** Resolved local destinations of Markdown links, as for assistant text. */
+	readonly linkTargets?: ReadonlyMap<string, string>;
+}
+
+const NO_USAGE: Usage = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+/** Replies a tool result carries in `details.replies` (text its commands wrote to a reply URL), oldest first. */
+export function toolResultReplies(details: unknown): readonly string[] {
+	if (!isRecord(details) || !Array.isArray(details.replies)) return [];
+	return details.replies.filter((reply): reply is string => typeof reply === "string");
+}
+
+/** Assistant message drawing reply text. No provider turn backs it, so its identity fields stay empty. */
+export function replyDisplayMessage(text: string, errorMessage?: string): AssistantMessage {
+	return {
+		role: "assistant",
+		content: [{ type: "text", text }],
+		api: "",
+		provider: "",
+		model: "",
+		usage: NO_USAGE,
+		stopReason: errorMessage === undefined ? "stop" : "error",
+		errorMessage,
+		timestamp: 0,
+	};
+}
+
+/**
+ * A reply write ({@link isReplyWrite}) drawn as assistant prose. The call's lifecycle arrives
+ * through {@link ToolExecutionHandle}: streamed args grow the text, final args settle it, and
+ * the result seals the block, a failure showing its error under the text. It is a reply, not
+ * tool activity, so hiding tool activity leaves it on screen.
+ */
+export class ReplyWriteComponent extends AssistantMessageComponent implements ToolExecutionHandle {
+	#text = "";
+	#argsComplete = false;
+
+	constructor(options: ReplyWriteOptions = {}) {
+		super(undefined, false, options.requestRender, [], options.imageBudget, true, options.linkTargets);
+	}
+
+	updateArgs(args: unknown): void {
+		const text = isRecord(args) && typeof args.content === "string" ? args.content : "";
+		if (text === this.#text || this.isTranscriptBlockFinalized()) return;
+		this.#text = text;
+		this.#draw();
+	}
+
+	setArgsComplete(): void {
+		if (this.#argsComplete || this.isTranscriptBlockFinalized()) return;
+		this.#argsComplete = true;
+		this.#draw();
+	}
+
+	setExecutionStarted(): void {}
+
+	updateResult(result: ToolResultFrame, isPartial = false): void {
+		if (isPartial || this.isTranscriptBlockFinalized()) return;
+		this.#argsComplete = true;
+		const error = result.isError
+			? result.content
+					.filter(block => block.type === "text")
+					.map(block => block.text ?? "")
+					.join("\n")
+			: undefined;
+		this.updateContent(replyDisplayMessage(this.#text, error));
+		this.markTranscriptBlockFinalized();
+	}
+
+	parkAsBackground(): void {}
+
+	seal(): void {
+		this.markTranscriptBlockFinalized();
+	}
+
+	#draw(): void {
+		this.updateContent(replyDisplayMessage(this.#text), { transient: !this.#argsComplete });
+	}
+}

package/src/chat/table-chart.ts

@@ -37,10 +37,11 @@ export interface TableChartRequest {
 }
 
 /**
- * Picks the chart for a multi-series table under `smart`: a plan, or `null`
- * for no chart. A rejection falls back to the local guess.
+ * Picks the chart for a table under `smart`: a plan, or `null` for no chart.
+ * A rejection falls back to the local guess; `undefined` (no judge to ask
+ * right now) keeps the guess at once, exactly as `always` would draw it.
  */
-export type TableChartPlanner = (request: TableChartRequest) => Promise<ChartPlan | null>;
+export type TableChartPlanner = (request: TableChartRequest) => Promise<ChartPlan | null> | undefined;
 
 /**
  * The chart under a table: its SVG, colored with figure tokens (`var(--accent)`, …)
@@ -126,7 +127,12 @@ export function lookupTableChart(table: Tokens.Table): ChartLookup {
 	if (entry.chart !== undefined) return entry.chart;
 	if (entry.pending) return entry.pending;
 	const { analysis, guess } = entry;
-	entry.pending = chartPlanner!({ markdown: table.raw, table: analysis, guess: guess! }).then(
+	const pick = chartPlanner!({ markdown: table.raw, table: analysis, guess: guess! });
+	if (!pick) {
+		entry.chart = drawChart(analysis, guess!, true);
+		return entry.chart;
+	}
+	entry.pending = pick.then(
 		plan => {
 			entry.chart = plan ? drawChart(analysis, plan) : null;
 		},

package/src/chat/tool-execution.ts

@@ -126,6 +126,9 @@ function cardPreview(preview: NativeToolView["preview"]): TspPreview | undefined
 /** The describe hooks of a registry renderer or of a custom tool object. */
 type ToolDescriber = Pick<ToolRenderer, "describeCall" | "describeResult" | "mergeCallAndResult">;
 
+/** Optional kinds of the host's vocabulary the describe hooks branch on. */
+type NativeHostKinds = Required<Pick<RenderResultContextOptions, "media" | "json">>;
+
 class SafeToolRendererComponent implements Component {
 	#toolName: string;
 	#stage: ToolRendererStage;
@@ -233,7 +236,6 @@ export interface ToolExecutionHandle extends Component {
 	setArgsComplete(toolCallId?: string): void;
 	setExecutionStarted(toolCallId?: string): void;
 	setExpanded(expanded: boolean): void;
-	setToolActivityVisible(visible: boolean): void;
 	/** Mark the call parked: it returned, but stays tracked for async job frames. */
 	parkAsBackground(): void;
 	/** Seal the block as final history and stop its animations. */
@@ -711,14 +713,15 @@ export class ToolExecutionComponent extends Container {
 			// Convert async - catch errors from processing
 			convertImageToPngShared(image)
 				.then(converted => {
+					this.#kittyConversionsAwaited.delete(key);
 					this.#kittyConverted.set(key, converted);
 					this.#displayInputVersion++;
 					this.#updateDisplay();
 					this.#ui.requestRender();
 				})
 				.catch(() => {
-					// Ignore conversion failures - display will use original image format
 					this.#kittyConversionsAwaited.delete(key);
+					this.#ui.requestRender();
 				});
 		}
 	}
@@ -859,9 +862,12 @@ export class ToolExecutionComponent extends Container {
 		}
 	}
 
-	/** Whether the result's figure still waits for its raster; the transcript holds retirement meanwhile. */
+	/** Hold visible results until their figures and Kitty images are ready for immutable scrollback. */
 	isTranscriptBlockPending(): boolean {
-		return this.#toolActivityVisible && this.#figure?.pending === true;
+		return (
+			this.#toolActivityVisible &&
+			((this.#showImages && this.#kittyConversionsAwaited.size > 0) || this.#figure?.pending === true)
+		);
 	}
 
 	/**
@@ -1018,7 +1024,7 @@ export class ToolExecutionComponent extends Container {
 	override describe(cx?: DescribeContext): NativeNode {
 		if (this.#toolName === "wait" && this.#isBenignSkip()) return EMPTY_NODE;
 		const dataFirst = cx?.supports("tool") === true;
-		const media = cx?.supports("media") === true;
+		const host: NativeHostKinds = { media: cx?.supports("media") === true, json: cx?.supports("json") === true };
 		const key = [
 			dataFirst,
 			this.#resultVersion,
@@ -1031,11 +1037,12 @@ export class ToolExecutionComponent extends Container {
 			this.#showImages,
 			this.#displayInputVersion,
 			this.#toolActivityVisible,
-			media,
+			host.media,
+			host.json,
 			getThemeEpoch(),
 		];
 		return this.#native.get(key, () =>
-			withHidden(dataFirst ? this.#describeTool(media) : this.#describeCard(media), !this.#toolActivityVisible),
+			withHidden(dataFirst ? this.#describeTool(host) : this.#describeCard(host), !this.#toolActivityVisible),
 		);
 	}
 
@@ -1081,8 +1088,8 @@ export class ToolExecutionComponent extends Container {
 	 * The data-first `tool` node (§7.2): the renderer's head data, status,
 	 * timer, exit and intent as props; its body as borderless children.
 	 */
-	#describeTool(media: boolean): NativeNode {
-		const view = this.#nativeView(media);
+	#describeTool(host: NativeHostKinds): NativeNode {
+		const view = this.#nativeView(host);
 		const status = this.#nativeStatus();
 		const head = view.tool;
 		const late = this.#lateDiagnosticsParts();
@@ -1151,8 +1158,8 @@ export class ToolExecutionComponent extends Container {
 		return spans;
 	}
 
-	#describeCard(media: boolean): NativeNode {
-		const view = this.#nativeView(media);
+	#describeCard(host: NativeHostKinds): NativeNode {
+		const view = this.#nativeView(host);
 		const status = this.#nativeStatus();
 		const late = this.#lateDiagnosticsParts();
 		const fallbackHead = this.#fallbackHead(view);
@@ -1206,10 +1213,10 @@ export class ToolExecutionComponent extends Container {
 	 * the result view (merged renderers) or the call head over both bodies.
 	 * A renderer that throws falls back to the generic card.
 	 */
-	#nativeView(media: boolean): NativeToolView {
+	#nativeView(host: NativeHostKinds): NativeToolView {
 		const status = this.#nativeStatus();
 		const options: RenderResultContextOptions = {
-			media,
+			...host,
 			expanded: this.#expanded,
 			isPartial: this.#isPartial,
 			argsComplete: this.#argsComplete,

package/src/chat/transcript-outline.ts

@@ -17,6 +17,7 @@ import { type ThemeColor, theme } from "../theme";
 import type { ChatTranscriptBuilder } from "./chat-transcript-builder";
 import { padToWidth } from "../render/utils";
 import { isUsageRowBlock } from "../overlays/usage-row";
+import type { DescribeContext, NativeChild } from "../native/node";
 
 /** One selectable transcript item: a message entry plus its rendered block range. */
 export interface OutlineTarget {
@@ -148,6 +149,32 @@ export function outlineVisibility(
 	});
 }
 
+/**
+ * Per-target "describes something that shows" flags: {@link outlineVisibility}
+ * for a TSP page, where blocks describe nodes instead of rendering rows. An
+ * empty `col`/`row` (an interrupted turn with no output) shows nothing.
+ */
+export function describedVisibility(
+	blocks: readonly Component[],
+	targets: readonly OutlineTarget[],
+	cx: DescribeContext,
+): boolean[] {
+	return targets.map(target => {
+		for (let index = target.start; index < target.end; index++) {
+			if (shows(blocks[index]!, cx)) return true;
+		}
+		return false;
+	});
+}
+
+/** Whether `child` describes a node that shows: a layout `col`/`row` only through a child that does. */
+function shows(child: NativeChild, cx: DescribeContext): boolean {
+	const node = "k" in child ? child : child.describe?.(cx);
+	if (!node) return false;
+	if (node.k !== "col" && node.k !== "row") return true;
+	return (node.c ?? []).some(grandchild => shows(grandchild, cx));
+}
+
 /** Dotted horizontal rule with rounded corners, spanning the outline width. */
 export function outlineRule(
 	left: string,