@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/modes/components/tool-status-header.ts

@@ -1,7 +1,9 @@
 import * as fs from "node:fs";
 
+import { resolveOAuthStorageProvider } from "@gajae-code/ai/core";
 import { type Component, truncateToWidth, visibleWidth } from "@gajae-code/tui";
-import { formatCount, getProjectDir } from "@gajae-code/utils";
+import { formatCount, getProjectDir, logger } from "@gajae-code/utils";
+import { getShellConfig } from "@gajae-code/utils/shell-config";
 import {
 	type AppKeybinding,
 	KEYBINDINGS,
@@ -19,6 +21,11 @@ import type { ActionRegistry, FocusDomain } from "../action-registry";
 import { EMPTY_JOBS_SNAPSHOT, type JobsSnapshot } from "../jobs-observer";
 import { sanitizeStatusText } from "../shared";
 import { renderSkillHudBar } from "./skill-hud/render";
+import {
+	normalizeStatusLineCommandOptions,
+	runStatusLineCommand,
+	type StatusLineCommandOptions,
+} from "./status-line/command";
 import { lookupCurrentPrCached } from "./status-line/gh";
 import {
 	canReuseCachedPr,
@@ -40,6 +47,7 @@ export interface StatusLineSegmentOptions {
 	git?: { showBranch?: boolean; showStaged?: boolean; showUnstaged?: boolean; showUntracked?: boolean };
 	time?: { format?: "12h" | "24h"; showSeconds?: boolean };
 	usage?: { mode?: "used" | "remaining" };
+	command?: StatusLineCommandOptions;
 }
 
 export interface StatusLineSettings {
@@ -49,6 +57,7 @@ export interface StatusLineSettings {
 	separator?: StatusLineSeparatorStyle;
 	segmentOptions?: StatusLineSegmentOptions;
 	previewHighlightSegment?: StatusLineSegmentId;
+	previewHighlightStyle?: "focus" | "selected";
 	showHookStatus?: boolean;
 	showSkillHud?: boolean;
 	showActionHints?: boolean;
@@ -62,6 +71,7 @@ export interface StatusLineComponentOptions {
 	getKeybindings?: () => KeybindingsManager;
 	focusDomain?: FocusDomain;
 	keyDisplayContext?: KeyDisplayContext;
+	onUpdate?: () => void;
 }
 
 export interface StatusLineActionHint {
@@ -69,6 +79,14 @@ export interface StatusLineActionHint {
 	content: string;
 }
 
+export interface StatusLinePreviewParts {
+	left: string[];
+	leftIds: StatusLineSegmentId[];
+	right: string[];
+	rightIds: (StatusLineSegmentId | null)[];
+	separator: SeparatorDef;
+}
+
 const ACTION_HINT_PRIORITY: readonly AppKeybinding[] = [
 	"app.message.sendNow",
 	"app.message.followUp",
@@ -136,6 +154,7 @@ interface CollectedStatusSegments {
 	/** Parallel to `right`; null for action hints, job counts and the version tag. */
 	rightSegIds: (StatusLineSegmentId | null)[];
 	previewHighlightSegment: StatusLineSegmentId | undefined;
+	previewHighlightStyle: "focus" | "selected";
 	sessionAccent: boolean | undefined;
 	leftSepWidth: number;
 	rightSepWidth: number;
@@ -155,6 +174,8 @@ export class StatusLineComponent implements Component {
 	#branchInFlight = false;
 	#gitWatcher: fs.FSWatcher | null = null;
 	#onBranchChange: (() => void) | null = null;
+	#onUpdate: (() => void) | null = null;
+	#disposed = false;
 	#autoCompactEnabled: boolean = true;
 	#hookStatuses: Map<string, string> = new Map();
 	#subagentCount: number = 0;
@@ -195,9 +216,22 @@ export class StatusLineComponent implements Component {
 
 	// Provider usage caching (5-min TTL, OAuth/sub only)
 	#cachedUsage: SegmentContext["usage"] = null;
+	#cachedUsageReports: unknown = null;
+	#cachedUsageProvider: string | undefined;
 	#usageFetchedAt = 0;
 	#usageInFlight = false;
 
+	// Configured command segment cache. Command execution is always backgrounded;
+	// rendering only reads these bounded, last-known values.
+	#commandConfigKey: string | undefined;
+	#commandOutput: string | null = null;
+	#commandFailed = false;
+	#commandFetchedAt = 0;
+	#commandInFlightKey: string | undefined;
+	#commandAbortController: AbortController | undefined;
+	#commandRefreshTimer: ReturnType<typeof setTimeout> | undefined;
+	#commandDiagnosticKey: string | undefined;
+
 	constructor(
 		private readonly session: AgentSession,
 		options: StatusLineComponentOptions = {},
@@ -218,6 +252,7 @@ export class StatusLineComponent implements Component {
 		this.#getKeybindings = options.getKeybindings;
 		this.#focusDomain = options.focusDomain ?? "composer";
 		this.#keyDisplayContext = options.keyDisplayContext;
+		this.#onUpdate = options.onUpdate ?? null;
 	}
 
 	updateSettings(settings: StatusLineSettings): void {
@@ -300,12 +335,175 @@ export class StatusLineComponent implements Component {
 	}
 
 	dispose(): void {
+		this.#disposed = true;
+		this.#onBranchChange = null;
+		this.#onUpdate = null;
+		this.#cancelCommandExecution();
+		this.#clearCommandRefreshTimer();
 		if (this.#gitWatcher) {
 			this.#gitWatcher.close();
 			this.#gitWatcher = null;
 		}
 	}
 
+	#notifyUpdate(): void {
+		if (this.#onUpdate) this.#onUpdate();
+		else this.#onBranchChange?.();
+	}
+
+	#logCommandDiagnostic(key: string, message: string, details: Record<string, unknown> = {}): void {
+		if (this.#commandDiagnosticKey === key) return;
+		this.#commandDiagnosticKey = key;
+		logger.warn(message, details);
+	}
+
+	#clearCommandRefreshTimer(): void {
+		if (this.#commandRefreshTimer) {
+			clearTimeout(this.#commandRefreshTimer);
+			this.#commandRefreshTimer = undefined;
+		}
+	}
+
+	#cancelCommandExecution(): void {
+		this.#commandAbortController?.abort();
+		this.#commandAbortController = undefined;
+		this.#commandInFlightKey = undefined;
+	}
+
+	#disableCommandSegment(): void {
+		this.#clearCommandRefreshTimer();
+		this.#cancelCommandExecution();
+		this.#commandConfigKey = undefined;
+		this.#commandOutput = null;
+		this.#commandFailed = false;
+		this.#commandFetchedAt = 0;
+		this.#commandDiagnosticKey = undefined;
+	}
+
+	#armCommandRefreshTimer(key: string, refreshMs: number): void {
+		this.#clearCommandRefreshTimer();
+		if (this.#disposed || this.#commandConfigKey !== key) return;
+		this.#commandRefreshTimer = setTimeout(
+			() => {
+				this.#commandRefreshTimer = undefined;
+				if (this.#disposed || this.#commandConfigKey !== key) return;
+				this.#notifyUpdate();
+			},
+			Math.max(0, refreshMs),
+		);
+		this.#commandRefreshTimer.unref?.();
+	}
+
+	#trustedCommandOptions(): StatusLineCommandOptions | undefined {
+		const globalLeft = this.session.settings.getGlobal("statusLine.leftSegments");
+		const globalRight = this.session.settings.getGlobal("statusLine.rightSegments");
+		const includesCommand = (value: unknown): boolean => Array.isArray(value) && value.includes("command");
+		if (!includesCommand(globalLeft) && !includesCommand(globalRight)) return undefined;
+
+		const globalSegmentOptions = this.session.settings.getGlobal("statusLine.segmentOptions");
+		if (!globalSegmentOptions || typeof globalSegmentOptions !== "object" || Array.isArray(globalSegmentOptions)) {
+			return undefined;
+		}
+		const commandOptions = (globalSegmentOptions as Record<string, unknown>).command;
+		const resolved = normalizeStatusLineCommandOptions(commandOptions);
+		return resolved.command ? resolved : undefined;
+	}
+
+	#refreshCommandInBackground(options: StatusLineCommandOptions | undefined): string {
+		const resolved = normalizeStatusLineCommandOptions(options);
+		const key = JSON.stringify(resolved);
+		if (this.#commandConfigKey !== key) {
+			this.#clearCommandRefreshTimer();
+			this.#cancelCommandExecution();
+			this.#commandConfigKey = key;
+			this.#commandOutput = null;
+			this.#commandFailed = false;
+			this.#commandFetchedAt = 0;
+			this.#commandDiagnosticKey = undefined;
+			this.#renderedRowsCache = undefined;
+		}
+
+		if (!resolved.command) {
+			this.#commandFailed = true;
+			this.#logCommandDiagnostic(key, "Status line command segment is configured without a command");
+			return key;
+		}
+
+		const now = Date.now();
+		if (this.#commandInFlightKey === key) return key;
+		const elapsed = now - this.#commandFetchedAt;
+		if (this.#commandFetchedAt > 0 && elapsed < resolved.refreshMs) {
+			this.#armCommandRefreshTimer(key, resolved.refreshMs - elapsed);
+			return key;
+		}
+		this.#clearCommandRefreshTimer();
+
+		this.#commandInFlightKey = key;
+		const abortController = new AbortController();
+		this.#commandAbortController = abortController;
+		let shellConfig: { shell: string; args: string[]; env: Record<string, string> };
+		try {
+			shellConfig = getShellConfig(this.session.settings.getGlobal("shellPath"));
+		} catch (error) {
+			if (this.#commandInFlightKey === key && this.#commandAbortController === abortController) {
+				this.#commandInFlightKey = undefined;
+				this.#commandAbortController = undefined;
+			}
+			this.#commandFailed = true;
+			this.#commandFetchedAt = Date.now();
+			this.#logCommandDiagnostic(key, "Status line command shell configuration failed", {
+				error: sanitizeStatusText(error instanceof Error ? error.message : String(error)).slice(0, 256),
+			});
+			this.#armCommandRefreshTimer(key, resolved.refreshMs);
+			return key;
+		}
+
+		void runStatusLineCommand(resolved.command, {
+			cwd: getProjectDir(),
+			shell: shellConfig.shell,
+			shellArgs: shellConfig.args,
+			env: shellConfig.env,
+			timeoutMs: resolved.timeoutMs,
+			signal: abortController.signal,
+		})
+			.then(result => {
+				if (this.#disposed || this.#commandConfigKey !== key) return;
+				this.#commandFetchedAt = Date.now();
+				if (result.timedOut || result.exitCode !== 0) {
+					this.#commandFailed = true;
+					this.#logCommandDiagnostic(key, "Status line command failed", {
+						exitCode: result.exitCode,
+						timedOut: result.timedOut,
+						stderr: result.stderr,
+						outputTruncated: result.outputTruncated,
+					});
+				} else {
+					this.#commandOutput = result.stdout;
+					this.#commandFailed = false;
+					this.#commandDiagnosticKey = undefined;
+				}
+				this.#renderedRowsCache = undefined;
+				this.#notifyUpdate();
+			})
+			.catch(error => {
+				if (this.#disposed || this.#commandConfigKey !== key) return;
+				this.#commandFetchedAt = Date.now();
+				this.#commandFailed = true;
+				this.#logCommandDiagnostic(key, "Status line command could not start", {
+					error: sanitizeStatusText(error instanceof Error ? error.message : String(error)).slice(0, 256),
+				});
+				this.#renderedRowsCache = undefined;
+				this.#notifyUpdate();
+			})
+			.finally(() => {
+				if (this.#commandInFlightKey !== key || this.#commandAbortController !== abortController) return;
+				this.#commandInFlightKey = undefined;
+				this.#commandAbortController = undefined;
+				this.#armCommandRefreshTimer(key, resolved.refreshMs);
+			});
+		return key;
+	}
+
 	invalidate(): void {
 		this.#invalidateGitCaches();
 	}
@@ -502,6 +700,8 @@ export class StatusLineComponent implements Component {
 		void fetcher
 			.call(this.session)
 			.then(reports => {
+				this.#cachedUsageReports = reports;
+				this.#cachedUsageProvider = this.#activeUsageProvider();
 				this.#cachedUsage = this.#normalizeUsageReports(reports);
 				this.#usageFetchedAt = Date.now();
 				if (this.#onBranchChange) {
@@ -521,7 +721,9 @@ export class StatusLineComponent implements Component {
 	}
 
 	#normalizeUsageReports(reports: unknown): SegmentContext["usage"] {
-		if (!Array.isArray(reports)) return null;
+		const activeProvider = this.#activeUsageProvider();
+
+		if (!activeProvider || !Array.isArray(reports)) return null;
 		const windows: NonNullable<SegmentContext["usage"]>["windows"] = [];
 		const seen = new Set<string>();
 		const now = Date.now();
@@ -555,20 +757,24 @@ export class StatusLineComponent implements Component {
 		for (const report of reports) {
 			if (!report || typeof report !== "object") continue;
 			const provider = (report as { provider?: unknown }).provider;
-			const providerId = typeof provider === "string" ? provider : undefined;
+			const providerId = typeof provider === "string" ? resolveOAuthStorageProvider(provider) : undefined;
+			if (providerId !== activeProvider) continue;
 			const limits = (report as { limits?: unknown }).limits;
 			if (!Array.isArray(limits)) continue;
 			for (const limit of limits) {
 				if (!limit || typeof limit !== "object") continue;
 				const l = limit as {
 					id?: unknown;
-					scope?: { windowId?: string; tier?: string; modelId?: string };
+					scope?: { provider?: unknown; windowId?: string; tier?: string; modelId?: string };
 					window?: { id?: string; resetsAt?: number };
 					amount?: { usedFraction?: number };
 				};
 				const fraction = l.amount?.usedFraction;
 				if (typeof fraction !== "number") continue;
 				const id = typeof l.id === "string" ? l.id : "";
+				const scopeProvider =
+					typeof l.scope?.provider === "string" ? resolveOAuthStorageProvider(l.scope.provider) : undefined;
+				if (scopeProvider !== undefined && scopeProvider !== providerId) continue;
 				const windowId = l.scope?.windowId ?? l.window?.id;
 				const tier = l.scope?.tier;
 				const modelId = l.scope?.modelId;
@@ -584,9 +790,9 @@ export class StatusLineComponent implements Component {
 					}
 				} else if (windowId === "5h" && !tier) {
 					pushWindow(`${providerId ?? "provider"}:5h`, "5h", fraction, resetsAt, "m");
-				} else if (windowId === "7d" && !tier) {
+				} else if (windowId === "7d" && !tier && providerId !== "grok-build" && providerId !== "xai") {
 					pushWindow(`${providerId ?? "provider"}:7d`, "7d", fraction, resetsAt, "h");
-				} else if (providerId === "grok-build" && windowId === "weekly" && !tier) {
+				} else if (providerId === "grok-build" && id === "grok-build:weekly" && windowId === "weekly" && !tier) {
 					pushWindow("grok-build:weekly", "weekly", fraction, resetsAt, "h");
 				}
 			}
@@ -595,17 +801,32 @@ export class StatusLineComponent implements Component {
 		return windows.length > 0 ? { windows } : null;
 	}
 
+	#activeUsageProvider(): string | undefined {
+		const model = this.session.state.model ?? this.session.model;
+		if (!model || typeof model !== "object") return undefined;
+		const provider = (model as { provider?: unknown }).provider;
+		return typeof provider === "string" && provider.length > 0 ? resolveOAuthStorageProvider(provider) : undefined;
+	}
+
+	#syncCachedUsageForActiveProvider(): void {
+		const activeProvider = this.#activeUsageProvider();
+		if (this.#cachedUsageProvider === activeProvider) return;
+		this.#cachedUsageProvider = activeProvider;
+		this.#cachedUsage = this.#normalizeUsageReports(this.#cachedUsageReports);
+	}
+
 	#buildSegmentContext(
 		width: number,
 		effectiveSettings: Required<
 			Pick<StatusLineSettings, "leftSegments" | "rightSegments" | "separator" | "segmentOptions">
 		> &
 			StatusLineSettings,
+		previewOnly = false,
 	): SegmentContext {
 		const state = this.session.state;
 
-		// Trigger background fetch (5-min TTL); render uses cached value
-		this.refreshUsageInBackground();
+		this.#syncCachedUsageForActiveProvider();
+		if (!previewOnly) this.refreshUsageInBackground();
 
 		// Get usage statistics
 		const aggregateUsageStats = this.session.sessionManager?.getUsageStatistics() ?? {
@@ -633,6 +854,20 @@ export class StatusLineComponent implements Component {
 		// treats a null value as hidden, so gating here is behavior-identical.
 		const prSegmentActive =
 			effectiveSettings.leftSegments.includes("pr") || effectiveSettings.rightSegments.includes("pr");
+		const gitSegmentActive =
+			effectiveSettings.leftSegments.includes("git") || effectiveSettings.rightSegments.includes("git");
+		const commandSegmentActive =
+			effectiveSettings.leftSegments.includes("command") || effectiveSettings.rightSegments.includes("command");
+		const commandOptions = commandSegmentActive ? this.#trustedCommandOptions() : undefined;
+		let commandKey: string | undefined = this.#commandConfigKey;
+		if (!previewOnly) {
+			if (commandOptions) {
+				commandKey = this.#refreshCommandInBackground(commandOptions);
+			} else {
+				this.#disableCommandSegment();
+				commandKey = undefined;
+			}
+		}
 
 		return {
 			session: this.session,
@@ -650,10 +885,20 @@ export class StatusLineComponent implements Component {
 			sessionStartTime: this.#sessionStartTime,
 			git: {
 				branch: this.#getCurrentBranch(),
-				status: this.#getGitStatus(),
-				pr: prSegmentActive ? this.#lookupPr() : null,
+				status: gitSegmentActive ? this.#getGitStatus() : null,
+				pr: prSegmentActive ? (previewOnly ? (this.#cachedPr ?? null) : this.#lookupPr()) : null,
 			},
 			usage: this.#cachedUsage,
+			command:
+				commandSegmentActive && (previewOnly || commandKey !== undefined)
+					? {
+							output: this.#commandOutput,
+							failed: this.#commandFailed,
+							pending: previewOnly
+								? this.#commandOutput === null && !this.#commandFailed
+								: this.#commandInFlightKey === commandKey,
+						}
+					: undefined,
 		};
 	}
 
@@ -730,7 +975,14 @@ export class StatusLineComponent implements Component {
 		if (available <= 0 || count <= 0) return "";
 		const withCount = `…+${count}`;
 		const text = visibleWidth(withCount) <= available ? withCount : "…";
-		return theme.fg("dim", text);
+		return truncateToWidth(theme.fg("dim", text), available);
+	}
+
+	#renderPreviewHighlight(content: string, style: "focus" | "selected"): string {
+		const bgColor = style === "selected" ? "warning" : "text";
+		const bgAnsi = theme.getFgAnsi(bgColor).replace("\x1b[38;", "\x1b[48;");
+		const fgAnsi = theme.getBgAnsi("selectedBg").replace("\x1b[48;", "\x1b[38;");
+		return `${bgAnsi}${fgAnsi}> ${Bun.stripANSI(content)} <\x1b[0m`;
 	}
 
 	#renderStatusGroup(
@@ -795,8 +1047,9 @@ export class StatusLineComponent implements Component {
 			Pick<StatusLineSettings, "leftSegments" | "rightSegments" | "separator" | "segmentOptions">
 		> &
 			StatusLineSettings,
+		previewOnly = false,
 	): CollectedStatusSegments {
-		const ctx = this.#buildSegmentContext(width, effectiveSettings);
+		const ctx = this.#buildSegmentContext(width, effectiveSettings, previewOnly);
 		const separatorDef = getSeparator(effectiveSettings.separator ?? "powerline-thin", theme);
 
 		// Use the subtle surface tone (the same elevated background as user-message
@@ -808,12 +1061,14 @@ export class StatusLineComponent implements Component {
 		const sepAnsi = theme.getFgAnsi("statusLineSep");
 
 		const previewHighlightSegment = effectiveSettings.previewHighlightSegment;
+		const previewHighlightStyle = effectiveSettings.previewHighlightStyle ?? "focus";
 		const highlightSegment = (segId: StatusLineSegmentId, content: string): string =>
-			previewHighlightSegment === segId ? `\x1b[7m${content}\x1b[27m` : content;
+			previewHighlightSegment === segId ? this.#renderPreviewHighlight(content, previewHighlightStyle) : content;
 
 		const left: string[] = [];
 		const leftSegIds: StatusLineSegmentId[] = [];
 		for (const segId of effectiveSettings.leftSegments) {
+			if (segId === "command" && !ctx.command) continue;
 			const rendered = renderSegment(segId, ctx);
 			if (rendered.visible && rendered.content) {
 				left.push(highlightSegment(segId, rendered.content));
@@ -834,6 +1089,7 @@ export class StatusLineComponent implements Component {
 						this.#keyDisplayContext,
 					);
 		for (const segId of effectiveSettings.rightSegments) {
+			if (segId === "command" && !ctx.command) continue;
 			const rendered = renderSegment(segId, ctx);
 			if (rendered.visible && rendered.content) {
 				right.push(highlightSegment(segId, rendered.content));
@@ -869,6 +1125,7 @@ export class StatusLineComponent implements Component {
 			right,
 			rightSegIds,
 			previewHighlightSegment,
+			previewHighlightStyle,
 			sessionAccent: effectiveSettings.sessionAccent,
 			leftSepWidth: visibleWidth(separatorDef.left),
 			rightSepWidth: visibleWidth(separatorDef.right),
@@ -965,7 +1222,7 @@ export class StatusLineComponent implements Component {
 
 	#buildStatusLine(width: number, precollected?: CollectedStatusSegments): string {
 		const seg = precollected ?? this.#collectStatusSegments(width, this.#resolveSettings());
-		const { ctx, separatorDef, bgAnsi, fgAnsi, sepAnsi, previewHighlightSegment } = seg;
+		const { ctx, separatorDef, bgAnsi, fgAnsi, sepAnsi, previewHighlightSegment, previewHighlightStyle } = seg;
 		const { leftSepWidth, rightSepWidth, leftCapWidth, rightCapWidth } = seg;
 		const topFillWidth = Math.max(0, width);
 
@@ -998,7 +1255,10 @@ export class StatusLineComponent implements Component {
 					const overflow = totalWidth() - budget;
 					const shrunk = this.#shrinkPathToWidth(left[pathIdx], ctx, overflow);
 					if (shrunk !== null) {
-						left[pathIdx] = previewHighlightSegment === "path" ? `\x1b[7m${shrunk}\x1b[27m` : shrunk;
+						left[pathIdx] =
+							previewHighlightSegment === "path"
+								? this.#renderPreviewHighlight(shrunk, previewHighlightStyle)
+								: shrunk;
 						leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
 					}
 				}
@@ -1087,9 +1347,9 @@ export class StatusLineComponent implements Component {
 	 * being dropped. Falls back to the polished justified single row whenever
 	 * everything fits on one line.
 	 */
-	#buildStatusRows(width: number, maxRows: number): string[] {
+	#buildStatusRows(width: number, maxRows: number, previewOnly = false): string[] {
 		const effectiveSettings = this.#resolveSettings();
-		const seg = this.#collectStatusSegments(width, effectiveSettings);
+		const seg = this.#collectStatusSegments(width, effectiveSettings, previewOnly);
 		const cacheKey = JSON.stringify({
 			width,
 			maxRows,
@@ -1124,14 +1384,14 @@ export class StatusLineComponent implements Component {
 				.join(","),
 			version: this.#version,
 		});
-		if (this.#renderedRowsCache?.key === cacheKey) {
+		if (!previewOnly && this.#renderedRowsCache?.key === cacheKey) {
 			this.#renderedRowsCacheHits++;
 			return [...this.#renderedRowsCache.rows];
 		}
-		this.#renderedRowsCacheMisses++;
+		if (!previewOnly) this.#renderedRowsCacheMisses++;
 
 		if (seg.left.length === 0 && seg.right.length === 0) {
-			this.#renderedRowsCache = { key: cacheKey, rows: [] };
+			if (!previewOnly) this.#renderedRowsCache = { key: cacheKey, rows: [] };
 			return [];
 		}
 
@@ -1209,7 +1469,7 @@ export class StatusLineComponent implements Component {
 			if (dropped > 0) {
 				const priorityRow = this.#priorityRowFor(seg, [], [], topFillWidth);
 				if (priorityRow !== null) {
-					this.#renderedRowsCache = { key: cacheKey, rows: [priorityRow] };
+					if (!previewOnly) this.#renderedRowsCache = { key: cacheKey, rows: [priorityRow] };
 					return [priorityRow];
 				}
 			}
@@ -1249,7 +1509,7 @@ export class StatusLineComponent implements Component {
 			if (packedRows.length === 0 && marker) rows = [marker];
 		}
 
-		this.#renderedRowsCache = { key: cacheKey, rows };
+		if (!previewOnly) this.#renderedRowsCache = { key: cacheKey, rows };
 		return [...rows];
 	}
 
@@ -1271,6 +1531,120 @@ export class StatusLineComponent implements Component {
 		return this.#buildStatusRows(width, this.#resolveMaxRows()).join("\n");
 	}
 
+	getPreviewContentForSettings(width: number, previewSettings: StatusLineSettings): string {
+		const previousSettings = this.#settings;
+		this.#settings = { ...previousSettings, previewHighlightSegment: undefined, ...previewSettings };
+		try {
+			return this.#buildStatusRows(width, this.#resolveMaxRows(), true).join("\n");
+		} finally {
+			this.#settings = previousSettings;
+		}
+	}
+
+	#placePreviewSegments(
+		seg: CollectedStatusSegments,
+		width: number,
+	): {
+		left: string[];
+		leftIds: StatusLineSegmentId[];
+		right: string[];
+		rightIds: (StatusLineSegmentId | null)[];
+	} {
+		const {
+			ctx,
+			previewHighlightSegment,
+			previewHighlightStyle,
+			leftSepWidth,
+			rightSepWidth,
+			leftCapWidth,
+			rightCapWidth,
+		} = seg;
+		const rank = this.#priorityRanker(seg);
+		const layout = (budget: number) => {
+			const left = [...seg.left];
+			const leftIds = [...seg.leftSegIds];
+			const right = [...seg.right];
+			const rightIds = [...seg.rightSegIds];
+			let leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
+			let rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
+			const totalWidth = () => leftWidth + rightWidth + (left.length > 0 && right.length > 0 ? 1 : 0);
+			let dropped = 0;
+
+			const pathIdx = leftIds.indexOf("path");
+			if (pathIdx >= 0 && totalWidth() > budget) {
+				const shrunk = this.#shrinkPathToWidth(left[pathIdx], ctx, totalWidth() - budget);
+				if (shrunk !== null) {
+					left[pathIdx] =
+						previewHighlightSegment === "path"
+							? this.#renderPreviewHighlight(shrunk, previewHighlightStyle)
+							: shrunk;
+					leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
+				}
+			}
+			while (totalWidth() > budget && (left.length > 0 || right.length > 0)) {
+				let victimSide: "left" | "right" | null = null;
+				let victimIndex = -1;
+				let victimRank = Number.POSITIVE_INFINITY;
+				for (let index = right.length - 1; index >= 0; index -= 1) {
+					const candidate = rank(rightIds[index]);
+					if (candidate < victimRank) {
+						victimRank = candidate;
+						victimSide = "right";
+						victimIndex = index;
+					}
+				}
+				for (let index = left.length - 1; index >= 0; index -= 1) {
+					const candidate = rank(leftIds[index]);
+					if (candidate < victimRank) {
+						victimRank = candidate;
+						victimSide = "left";
+						victimIndex = index;
+					}
+				}
+				if (victimSide === null) break;
+				if (victimSide === "right") {
+					right.splice(victimIndex, 1);
+					rightIds.splice(victimIndex, 1);
+					rightWidth = this.#groupWidth(right, rightCapWidth, rightSepWidth);
+				} else {
+					left.splice(victimIndex, 1);
+					leftIds.splice(victimIndex, 1);
+					leftWidth = this.#groupWidth(left, leftCapWidth, leftSepWidth);
+				}
+				dropped += 1;
+			}
+			return { left, leftIds, right, rightIds, dropped };
+		};
+
+		let placed = layout(Math.max(0, width));
+		let reserved = 0;
+		if (placed.dropped > 0 && width > 0) {
+			for (let pass = 0; pass < 4; pass += 1) {
+				const needed = Math.min(width, visibleWidth(`…+${placed.dropped}`));
+				if (needed <= reserved) break;
+				reserved = needed;
+				placed = layout(Math.max(0, width - reserved));
+			}
+		}
+		return placed;
+	}
+
+	getPreviewPartsForSettings(width: number, previewSettings: StatusLineSettings): StatusLinePreviewParts {
+		const previousSettings = this.#settings;
+		this.#settings = { ...previousSettings, ...previewSettings };
+		this.#resolvedSettingsCache = undefined;
+		this.#resolvedSettingsFingerprint = undefined;
+		try {
+			const seg = this.#collectStatusSegments(width, this.#resolveSettings(), true);
+			const placed = this.#placePreviewSegments(seg, width);
+			return { ...placed, separator: seg.separatorDef };
+		} finally {
+			this.#settings = previousSettings;
+			this.#resolvedSettingsCache = undefined;
+			this.#resolvedSettingsFingerprint = undefined;
+		}
+	}
+
 	getCacheStatsForTest(): { rowHits: number; rowMisses: number } {
 		return { rowHits: this.#renderedRowsCacheHits, rowMisses: this.#renderedRowsCacheMisses };
 	}

package/src/modes/controllers/command-controller.ts

@@ -1043,6 +1043,7 @@ export class CommandController {
 		this.ctx.ui.requestRender();
 
 		prepareTranscriptRebuild(this.ctx.ui, "replace-identity");
+		this.ctx.resetAssistantTextPresentation();
 		this.ctx.chatContainer.clear();
 		this.ctx.pendingMessagesContainer.clear();
 		this.ctx.compactionQueuedMessages = [];
@@ -1083,6 +1084,7 @@ export class CommandController {
 		this.ctx.ui.requestRender();
 
 		prepareTranscriptRebuild(this.ctx.ui, "replace-identity");
+		this.ctx.resetAssistantTextPresentation();
 		this.ctx.chatContainer.clear();
 		this.ctx.pendingMessagesContainer.clear();
 		this.ctx.compactionQueuedMessages = [];
@@ -1231,6 +1233,7 @@ export class CommandController {
 				const meta = outputMeta().truncationFromSummary(result, { direction: "tail" }).get();
 				this.ctx.bashComponent.setComplete(result.exitCode, result.cancelled, {
 					output: result.output,
+					signal: result.signal,
 					truncation: meta?.truncation,
 				});
 			}