@linxiraos/pi-tui 1.2.1 → 1.3.0

package/src/chat/tool-execution.ts

@@ -8,7 +8,7 @@ import { Text } from "../components/text";
 import { getImageDimensions, ImageProtocol, imageFallback, TERMINAL } from "../terminal-capabilities";
 import { type Component, Container, type TUI } from "../tui";
 import { truncateToWidth } from "../utils";
-import { getProjectDir, isRecord, logger, sanitizeText } from "@linxiraos/pi-utils";
+import { getProjectDir, isRecord, logger, sanitizeText, sanitizeTextDeep } from "@linxiraos/pi-utils";
 import type { Theme } from "../theme/theme";
 import { ensureThemeSync, getThemeEpoch, theme } from "../theme/theme";
 import {
@@ -32,7 +32,8 @@ import {
 import { plainText } from "../native/spans";
 import { diagnosticsSection, displayPath, toolHead } from "../tools/native-view";
 import type { FileDiagnosticsResult } from "../tools/lsp";
-import { NativeImageCache } from "../native/blobs";
+import { NativeImageCache, readMediaPath, shownMedia } from "../native/blobs";
+import { imageLinksEnabled, linkedImageText } from "../prompt/image-references";
 import { Memo } from "../native/memo";
 import { type EditMode, type PerFileDiffPreview, renderStreamingFallback } from "../tools/edit";
 import { taskCardAgentIds } from "../tools/task";
@@ -218,18 +219,17 @@ export interface ToolExecutionOptions {
 	useBuiltInRenderer?: boolean;
 }
 
+/** A tool result or progress frame as a card shows it. */
+export interface ToolResultFrame {
+	content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
+	details?: unknown;
+	isError?: boolean;
+}
+
 export interface ToolExecutionHandle extends Component {
 	updateArgs(args: unknown, toolCallId?: string): void;
 	updateStreamPreview?(update: unknown): void;
-	updateResult(
-		result: {
-			content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
-			details?: unknown;
-			isError?: boolean;
-		},
-		isPartial?: boolean,
-		toolCallId?: string,
-	): void;
+	updateResult(result: ToolResultFrame, isPartial?: boolean, toolCallId?: string): void;
 	setArgsComplete(toolCallId?: string): void;
 	setExecutionStarted(toolCallId?: string): void;
 	setExpanded(expanded: boolean): void;
@@ -240,6 +240,50 @@ export interface ToolExecutionHandle extends Component {
 	seal(): void;
 }
 
+/** Tools whose returned call hands its card to the background job it started (see {@link parksAsBackground}). */
+const JOB_CARD_TOOLS: Record<string, "always" | "native"> = { task: "always", bash: "native", eval: "native" };
+
+/**
+ * Whether a call that returned with `details.async.state === "running"` stays
+ * parked ({@link ToolExecutionHandle.parkAsBackground}) so its job's later
+ * frames keep filling the card until a `completed`/`failed` frame settles it.
+ * Detached `task` spawns always do; backgrounded `bash`/`eval` jobs only under
+ * native rendering, where the terminal transcript keeps them frozen instead.
+ * Shared by the live event controller and the transcript rebuild.
+ */
+export function parksAsBackground(toolName: string, details: unknown): boolean {
+	const mode = JOB_CARD_TOOLS[toolName];
+	if (mode === undefined || (mode === "native" && !isNativeRendering())) return false;
+	return asyncJobState(details) === "running";
+}
+
+/** The background job state a tool result reports (`details.async.state`: running, completed, failed, cancelled). */
+export function asyncJobState(details: unknown): string | undefined {
+	if (!isRecord(details) || !isRecord(details.async)) return undefined;
+	return typeof details.async.state === "string" ? details.async.state : undefined;
+}
+
+/** Whether a frame is a background job's last one: it completed, failed or was cancelled. */
+export function isSettledJobFrame(details: unknown): boolean {
+	const state = asyncJobState(details);
+	return state === "completed" || state === "failed" || state === "cancelled";
+}
+
+/**
+ * Settle a parked card ({@link parksAsBackground}) with its job's last frame
+ * ({@link isSettledJobFrame}): a completed or failed job is the call's result;
+ * a cancelled one keeps the output it got to and seals the card as cancelled.
+ */
+export function settleWithJobFrame(component: ToolExecutionHandle, frame: ToolResultFrame, toolCallId: string): void {
+	const state = asyncJobState(frame.details);
+	if (state === "cancelled") {
+		component.updateResult(frame, true, toolCallId);
+		component.seal();
+		return;
+	}
+	component.updateResult({ ...frame, isError: state === "failed" }, false, toolCallId);
+}
+
 /** Card tone per status when the renderer doesn't choose one; settled cards stay neutral. */
 const NATIVE_STATUS_TONE: Record<TspCardStatus, TspTone | undefined> = {
 	pending: "pending",
@@ -376,6 +420,8 @@ export class ToolExecutionComponent extends Container {
 		isError?: boolean;
 		details?: unknown;
 	};
+	// Machine paths remain verbatim; only #result.details is handed to display renderers.
+	#rawDetails: unknown;
 	// Edit preview state
 	#editMode?: EditMode;
 	#editDiffPreview?: PerFileDiffPreview[];
@@ -581,22 +627,18 @@ export class ToolExecutionComponent extends Container {
 		return result !== undefined && !this.#isPartial && (result.isError === true || result.details != null);
 	}
 
-	updateResult(
-		result: {
-			content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
-			details?: unknown;
-			isError?: boolean;
-		},
-		isPartial = false,
-		_toolCallId?: string,
-	): void {
+	updateResult(result: ToolResultFrame, isPartial = false, _toolCallId?: string): void {
 		const hadNoResult = this.#result === undefined;
 		const wasPartialResult = this.#result !== undefined && this.#isPartial;
 		const firstResultRepaintShapePainted = this.#firstResultViewportRepaintShapePainted;
 		const partialResultPainted = this.#partialResultShapePainted;
 		this.#firstResultViewportRepaintShapePainted = false;
 		this.#partialResultShapePainted = false;
-		this.#result = result;
+		this.#rawDetails = result.details;
+		// Renderers receive sanitized details for display; raw paths are available
+		// separately for links and media through the built-in render context.
+		const details = sanitizeTextDeep(result.details);
+		this.#result = details === result.details ? result : { ...result, details };
 		this.#resultVersion++;
 		this.#blockVersion++;
 		this.#isPartial = isPartial;
@@ -941,6 +983,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 key = [
 			dataFirst,
 			this.#resultVersion,
@@ -953,10 +996,11 @@ export class ToolExecutionComponent extends Container {
 			this.#showImages,
 			this.#displayInputVersion,
 			this.#toolActivityVisible,
+			media,
 			getThemeEpoch(),
 		];
 		return this.#native.get(key, () =>
-			withHidden(dataFirst ? this.#describeTool() : this.#describeCard(), !this.#toolActivityVisible),
+			withHidden(dataFirst ? this.#describeTool(media) : this.#describeCard(media), !this.#toolActivityVisible),
 		);
 	}
 
@@ -1002,12 +1046,12 @@ 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(): NativeNode {
-		const view = this.#nativeView();
+	#describeTool(media: boolean): NativeNode {
+		const view = this.#nativeView(media);
 		const status = this.#nativeStatus();
 		const head = view.tool;
 		const late = this.#lateDiagnosticsParts();
-		const body: NativeChild[] = [...(view.body ?? []), ...this.#nativeResultImages()];
+		const body: NativeChild[] = [...(view.body ?? []), ...this.#nativeResultImages(view.body)];
 		if (late.section) body.push(late.section);
 		const inline = view.inline === true;
 		const hasBody = body.length > 0;
@@ -1072,8 +1116,8 @@ export class ToolExecutionComponent extends Container {
 		return spans;
 	}
 
-	#describeCard(): NativeNode {
-		const view = this.#nativeView();
+	#describeCard(media: boolean): NativeNode {
+		const view = this.#nativeView(media);
 		const status = this.#nativeStatus();
 		const late = this.#lateDiagnosticsParts();
 		const fallbackHead = this.#fallbackHead(view);
@@ -1095,7 +1139,7 @@ export class ToolExecutionComponent extends Container {
 		const children: NativeChild[] = [
 			node("row", { gap: "sm", align: "baseline" }, headChildren, "head"),
 			...(view.body ?? []),
-			...this.#nativeResultImages(),
+			...this.#nativeResultImages(view.body),
 			...(late.section ? [late.section] : []),
 		];
 		const role = `zeta.tool.${this.#toolName}`;
@@ -1127,9 +1171,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(): NativeToolView {
+	#nativeView(media: boolean): NativeToolView {
 		const status = this.#nativeStatus();
 		const options: RenderResultContextOptions = {
+			media,
 			expanded: this.#expanded,
 			isPartial: this.#isPartial,
 			argsComplete: this.#argsComplete,
@@ -1208,12 +1253,17 @@ export class ToolExecutionComponent extends Container {
 		return indicators ? (output ? `${output}\n${indicators}` : indicators) : output;
 	}
 
-	#nativeResultImages(): NativeNode[] {
+	/** Result images under the renderer's body, minus those the body already shows (as an `image` blob or a `media` file). */
+	#nativeResultImages(body: readonly NativeChild[] | undefined): NativeNode[] {
 		if (!this.#result || !this.#showImages) return [];
+		const shown = shownMedia(body);
+		const mediaPath = readMediaPath(this.#rawDetails);
+		if (mediaPath && shown.paths.has(mediaPath)) return [];
 		const images: NativeNode[] = [];
 		this.#getAllImageBlocks().forEach((image, index) => {
-			if (image.data && image.mimeType)
-				images.push(this.#nativeImages.get(`img${index}`, image.data, image.mimeType));
+			if (!image.data || !image.mimeType) return;
+			const described = this.#nativeImages.get(`img${index}`, image.data, image.mimeType, mediaPath);
+			if (!shown.blobs.has((described.p as { blob?: string } | undefined)?.blob ?? "")) images.push(described);
 		});
 		return images;
 	}
@@ -1244,7 +1294,7 @@ export class ToolExecutionComponent extends Container {
 		// TUI startup, so a result rendered before it lands must re-shape once it
 		// does (it gates Image children vs text fallback in #rebuildDisplay); keyed
 		// here for the same reason markdown.ts keys its render cache on it.
-		const key = `${this.#resultVersion}|${this.#expanded}|${this.#isPartial}|${this.#argsComplete ? "1" : "0"}|${this.#executionStarted ? "1" : "0"}|${this.#spinnerFrame ?? "-"}|${this.#showImages}|${getThemeEpoch()}|${this.#displayInputVersion}|${TERMINAL.imageProtocol ?? "-"}|${this.#imageSizeKey()}`;
+		const key = `${this.#resultVersion}|${this.#expanded}|${this.#isPartial}|${this.#argsComplete ? "1" : "0"}|${this.#executionStarted ? "1" : "0"}|${this.#spinnerFrame ?? "-"}|${this.#showImages}|${getThemeEpoch()}|${this.#displayInputVersion}|${TERMINAL.imageProtocol ?? "-"}|${this.#imageSizeKey()}|${imageLinksEnabled()}`;
 		if (key === this.#lastDisplayKey && this.#displayBuilt) return;
 		this.#lastDisplayKey = key;
 
@@ -1514,6 +1564,10 @@ export class ToolExecutionComponent extends Container {
 				this.#contentBox.clear();
 
 				const renderContext = this.#buildRenderContext();
+				const rawPerFileResults =
+					isRecord(this.#rawDetails) && Array.isArray(this.#rawDetails.perFileResults)
+						? this.#rawDetails.perFileResults
+						: undefined;
 				this.#renderState.renderContext = renderContext;
 
 				for (let i = 0; i < perFileResults.length; i++) {
@@ -1525,9 +1579,13 @@ export class ToolExecutionComponent extends Container {
 					}
 					const fileBox = new Box(0, 0);
 					try {
+						const fileOptions = {
+							...this.#renderState,
+							renderContext: { ...renderContext, rawDetails: rawPerFileResults?.[i] },
+						};
 						const resultComponent = renderer.renderResult(
 							{ content: [], details: fileResult, isError: fileResult.isError },
-							this.#renderState,
+							fileOptions,
 							theme,
 						);
 						if (resultComponent) {
@@ -1651,6 +1709,7 @@ export class ToolExecutionComponent extends Container {
 
 		if (this.#result) {
 			const imageBlocks = this.#getAllImageBlocks();
+			const sourcePath = readMediaPath(this.#rawDetails);
 
 			for (let i = 0; i < imageBlocks.length; i++) {
 				const img = imageBlocks[i];
@@ -1678,6 +1737,7 @@ export class ToolExecutionComponent extends Container {
 						{ fallbackColor: (s: string) => theme.fg("toolOutput", s) },
 						{
 							...resolveImageOptions(),
+							sourcePath,
 							budget: this.#ui.imageBudget,
 							imageKey: `te${this.#instanceId}:${i}`,
 							requestRender: () => this.#ui.requestRender(),
@@ -1756,6 +1816,9 @@ export class ToolExecutionComponent extends Container {
 			return Math.max(1, Math.min(maxSeconds, value));
 		};
 
+		if (this.#renderer && !this.#tool?.renderResult && this.#rawDetails !== undefined) {
+			context.rawDetails = this.#rawDetails;
+		}
 		if (this.#toolName === "bash") {
 			// Bash needs render context even before a result exists. The renderer uses the pending-call args
 			// plus this context to keep the inline command preview visible while tool-call JSON is still streaming.
@@ -1816,7 +1879,8 @@ export class ToolExecutionComponent extends Container {
 
 	#getTextOutput(): string {
 		if (!this.#result) return "";
-		const key = `${this.#resultVersion}|${this.#showImages}|${TERMINAL.imageProtocol ?? "-"}`;
+		// Image placeholders embed a link only under an enabled hyperlink policy.
+		const key = `${this.#resultVersion}|${this.#showImages}|${TERMINAL.imageProtocol ?? "-"}|${imageLinksEnabled()}`;
 		if (key === this.#textOutputKey) return this.#textOutput;
 
 		const textBlocks = this.#result.content.filter(c => c.type === "text");
@@ -1833,7 +1897,10 @@ export class ToolExecutionComponent extends Container {
 				.map(img => {
 					const mimeType = String(img.mimeType);
 					const dims = img.data ? (getImageDimensions(img.data, mimeType) ?? undefined) : undefined;
-					return imageFallback(mimeType, dims);
+					const placeholder = imageFallback(mimeType, dims);
+					return img.data
+						? linkedImageText(placeholder, { data: img.data, mimeType }, readMediaPath(this.#rawDetails))
+						: placeholder;
 				})
 				.join("\n");
 			output = output ? `${output}\n${imageIndicators}` : imageIndicators;

package/src/chat/user-message.d.ts

@@ -39,8 +39,9 @@ export declare class UserMessageComponent extends Container implements ReactionT
     /**
      * A head-less user-toned frame with the prompt as markdown under its
      * attached images (titled `#N` like their chips, opening the materialized
-     * file on click): the fill says "you". A quiet toolbar (time, Copy, Rewind) fades in on hover when the
-     * host handles transcript actions. The live-steering marker and the
+     * file on click): the fill says "you". A quiet footer like a turn's usage line
+     * (`⧉ ⏪ · 09:45`: Copy, Rewind, the time sent) fades in at its bottom-left on hover when
+     * the host handles transcript actions. The live-steering marker and the
      * agent's reaction are chips at the bottom-right, so a reaction landing
      * later updates the frame in place, even deep in scrollback.
      */

package/src/chat/user-message.ts

@@ -18,12 +18,12 @@ import {
 	skillChipStyle,
 } from "../prompt/composer-attachments";
 import { MODEL_MENTION_TAG_RE } from "../prompt/model-mention-syntax";
-import { expandKeyHint, fileHyperlink } from "../render";
-import { imageReferenceHyperlink } from "../prompt/image-references";
+import { expandKeyHint, fileHyperlink, fileLinkSpan } from "../render";
+import { imageLinksEnabled, imageReferenceHyperlink } from "../prompt/image-references";
 import { highlightMagicKeywords } from "../prompt/magic-keywords";
 import type { ReactionTarget } from "./reaction";
 import { card, md, node, row, span, text } from "../native/describe";
-import { base64ImageNode } from "../native/blobs";
+import { base64ImageNode, openableImageProps } from "../native/blobs";
 import { hasTranscriptActions, runTranscriptAction } from "./transcript-actions";
 import {
 	type DescribeContext,
@@ -145,8 +145,9 @@ export class UserMessageComponent extends Container implements ReactionTarget, T
 	readonly #tokens: RegExp;
 	#reaction: string | undefined;
 	#native: NativeNode | undefined;
-	/** The terminal's clock {@link #native} was described with. */
+	/** The terminal's clock and the image link policy {@link #native} was described with. */
 	#nativeHour12: boolean | undefined;
+	#nativeLinked = false;
 
 	constructor(text: string, options: UserBubbleOptions = {}) {
 		super();
@@ -195,44 +196,60 @@ export class UserMessageComponent extends Container implements ReactionTarget, T
 	/**
 	 * A head-less user-toned frame with the prompt as markdown under its
 	 * attached images (titled `#N` like their chips, opening the materialized
-	 * file on click): the fill says "you". A quiet toolbar (time, Copy, Rewind) fades in on hover when the
-	 * host handles transcript actions. The live-steering marker and the
+	 * file on click): the fill says "you". A quiet footer like a turn's usage line
+	 * (`⧉ ⏪ · 09:45`: Copy, Rewind, the time sent) fades in at its bottom-left on hover when
+	 * the host handles transcript actions. The live-steering marker and the
 	 * agent's reaction are chips at the bottom-right, so a reaction landing
 	 * later updates the frame in place, even deep in scrollback.
 	 */
 	override describe(cx?: DescribeContext): NativeNode {
 		// The terminal's clock: Bun's own default locale ignores the user's.
 		const hour12 = cx?.hour12;
-		if (this.#native && this.#nativeHour12 === hour12) return this.#native;
+		// Chip marks and thumbnails carry links only under an enabled policy.
+		const linked = imageLinksEnabled();
+		if (this.#native && this.#nativeHour12 === hour12 && this.#nativeLinked === linked) return this.#native;
 		this.#nativeHour12 = hour12;
+		this.#nativeLinked = linked;
 		const children: NativeChild[] = [];
 		if (!this.#synthetic && hasTranscriptActions()) {
-			const tools: NativeChild[] = [];
+			const tools: NativeChild[] = [
+				// `copy-message`, not Tern's local `copy` (that would copy the icon's empty label).
+				node(
+					"icon",
+					{
+						name: "copy",
+						role: "zeta.user.tool",
+						title: "Copy message",
+						aria: "Copy message",
+						actions: { click: "copy-message" },
+					},
+					undefined,
+					"copy",
+				),
+				node(
+					"icon",
+					{
+						name: "rewind",
+						role: "zeta.user.tool",
+						title: "Rewind the conversation to an earlier message",
+						aria: "Rewind",
+						actions: { click: "rewind" },
+					},
+					undefined,
+					"rewind",
+				),
+			];
 			if (this.#timestamp !== undefined) {
 				const at = new Date(this.#timestamp);
 				tools.push(
+					node("text", { text: "·" }, undefined, "dot"),
 					text([span(at.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", hour12 }), "dim mono")], {
 						role: "zeta.user.time",
 						title: at.toLocaleString([], { hour12 }),
 					}),
 				);
 			}
-			tools.push(
-				// `copy-message`, not Tern's local `copy` (that would copy the label).
-				text("Copy", {
-					role: "zeta.user.tool",
-					actions: { click: "copy-message" },
-					title: "Copy message",
-					key: "copy",
-				}),
-				text("Rewind", {
-					role: "zeta.user.tool",
-					actions: { click: "rewind" },
-					title: "Rewind the conversation to an earlier message",
-					key: "rewind",
-				}),
-			);
-			children.push(node("row", { gap: "xs", role: "zeta.user.tools" }, tools, "tools"));
+			children.push(node("row", { gap: "xs", align: "center", role: "zeta.user.tools" }, tools, "tools"));
 		}
 		// Videos keep their chip only: the native image node decodes stills.
 		const thumbs: NativeNode[] = [];
@@ -240,16 +257,14 @@ export class UserMessageComponent extends Container implements ReactionTarget, T
 			this.#images.forEach((image, i) => {
 				if (!image.mimeType.startsWith("image/")) return;
 				const label = `#${i + 1}`;
-				const link = this.#imageLinks?.[i];
-				// A click zooms the image in the terminal; the file opens from its context menu.
-				const open = link ? { href: link, actions: { menu: ["open"] } } : {};
+				const open = openableImageProps(linked ? this.#imageLinks?.[i] : undefined);
 				thumbs.push(base64ImageNode(image.data, image.mimeType, { alt: label, title: label, ...open }, label));
 			});
 		}
 		if (thumbs.length > 0) {
 			children.push(row(thumbs, { gap: "sm", wrap: true, align: "start", role: "zeta.user.images" }));
 		}
-		const marks = this.#synthetic ? [] : tokenMarks(this.#text, this.#tokens);
+		const marks = this.#synthetic ? [] : tokenMarks(this.#text, this.#tokens, this.#imageLinks);
 		children.push(md(this.#text, marks.length > 0 ? { marks } : undefined));
 		const badges: NativeChild[] = [];
 		if (this.#liveSteered) {
@@ -346,13 +361,13 @@ export class UserMessageComponent extends Container implements ReactionTarget, T
 /**
  * The composer tokens in `text` as `md` marks, styled as the composer
  * decorates them (`CustomEditor.describeDecorations`), so a sent prompt keeps
- * its chips highlighted.
+ * its chips highlighted. Image and video chips link to their file, as in text mode.
  */
-function tokenMarks(text: string, tokens: RegExp): TspSpan[] {
+function tokenMarks(text: string, tokens: RegExp, imageLinks: readonly (string | undefined)[] | undefined): TspSpan[] {
 	// One mark per distinct token: Tern styles every occurrence of its text.
-	const styles = new Map<string, string>();
+	const marks = new Map<string, TspSpan>();
 	const mark = (s: string) => (label: string) => {
-		styles.set(label, s);
+		marks.set(label, { t: label, s });
 		return "";
 	};
 	renderPlaceholders(
@@ -361,11 +376,16 @@ function tokenMarks(text: string, tokens: RegExp): TspSpan[] {
 			renderText: () => "",
 			renderSkill: mark("customMessageLabel strong"),
 			renderMention: mark("statusLineModel strong"),
-			renderReference: mark("accent strong"),
+			renderReference: (label, kind, index) => {
+				const s = "accent strong";
+				const link = kind === "image" || kind === "video" ? imageLinks?.[index - 1] : undefined;
+				marks.set(label, link ? fileLinkSpan(link, label, s) : { t: label, s });
+				return "";
+			},
 		},
 		tokens,
 	);
-	return [...styles].map(([t, s]) => ({ t, s }));
+	return [...marks.values()];
 }
 
 /**

package/src/chrome/countdown-timer.ts

@@ -49,15 +49,15 @@ export class CountdownTimer {
 
 	/**
 	 * The remaining time as a terminal-clocked `elapsed` node: its age is the
-	 * negative remaining time (the start lies in the future), so it counts up
-	 * toward zero and freezes there at expiry. The age is taken on the first
+	 * negative remaining time (the start lies in the future), so it counts down
+	 * to zero and holds there at expiry (no `stopped`: that would freeze it at
+	 * zero from the start). The age is taken on the first
 	 * call after a (re)start, when the node is first written, and the node is
 	 * reused until {@link reset}.
 	 */
 	describe(): NativeNode {
 		this.#node ??= node("elapsed", {
 			age: Math.min(0, Date.now() - this.#deadlineMs),
-			stopped: 0,
 			format: "short",
 		});
 		return this.#node;

package/src/chrome/diff.d.ts

@@ -7,10 +7,9 @@ import type { NativeNode } from "../native/node";
  * becomes one hunk; the terminal draws gutters, word emphasis and highlighting.
  * Removed rows carry old line numbers, added rows new ones and context rows
  * old ones, so the other side is derived from the running line delta.
+ * Tern picks the grammar from `path`.
  */
-export declare function nativeDiff(diffText: string, options?: {
-    filePath?: string;
-} & TspProps<"diff">): NativeNode;
+export declare function nativeDiff(diffText: string, props?: TspProps<"diff">): NativeNode;
 export interface RenderDiffOptions {
     /** File path used to resolve indentation (.editorconfig + defaults) */
     filePath?: string;

package/src/chrome/diff.ts

@@ -2,7 +2,7 @@ import { diffWords } from "@linxiraos/pi-natives";
 import { DEFAULT_TAB_WIDTH, sanitizeText } from "@linxiraos/pi-utils";
 import type { TspDiffHunk, TspProps } from "@linxiraos/pi-wire";
 import { theme as activeTheme, getLanguageFromPath, highlightCode, type Theme } from "../theme/index";
-import { type CodeFrameMarker, formatCodeFrameLine, replaceTabs, shortenPath } from "../render/render-utils";
+import { type CodeFrameMarker, formatCodeFrameLine, replaceTabs } from "../render/render-utils";
 import { node } from "../native/describe";
 import type { NativeNode } from "../native/node";
 /** SGR dim on / normal intensity — additive, preserves fg/bg colors. */
@@ -106,9 +106,9 @@ function renderIntraLineDiff(
  * becomes one hunk; the terminal draws gutters, word emphasis and highlighting.
  * Removed rows carry old line numbers, added rows new ones and context rows
  * old ones, so the other side is derived from the running line delta.
+ * Tern picks the grammar from `path`.
  */
-export function nativeDiff(diffText: string, options: { filePath?: string } & TspProps<"diff"> = {}): NativeNode {
-	const { filePath, ...props } = options;
+export function nativeDiff(diffText: string, props: TspProps<"diff"> = {}): NativeNode {
 	const hunks: TspDiffHunk[] = [];
 	let lines: string[] = [];
 	let oldStart = 0;
@@ -148,12 +148,7 @@ export function nativeDiff(diffText: string, options: { filePath?: string } & Ts
 		lines.push(`${parsed.prefix}${parsed.content}`);
 	}
 	close();
-	return node("diff", {
-		...props,
-		hunks,
-		path: props.path ?? (filePath ? shortenPath(filePath) : undefined),
-		lang: props.lang ?? (filePath ? getLanguageFromPath(filePath) : undefined),
-	});
+	return node("diff", { ...props, hunks });
 }
 
 export interface RenderDiffOptions {

package/src/chrome/transcript-container.d.ts

@@ -100,6 +100,8 @@ export declare class TranscriptContainer extends Container {
     blockModes(): readonly TranscriptBlockMode[];
     /** Emitted stable semantic-row counts in transcript order. */
     emittedStableRows(): readonly number[];
+    /** Whether any block is still streaming or otherwise unfinalized. */
+    hasActiveBlock(): boolean;
     /** Whether visible active capacity and live-block memory permit another admission. */
     canAdmit(rows: number): boolean;
     /** Prepares one atomic replay of the committed ledger and an emitted active-head prefix. */