@bastani/atomic 0.9.11-alpha.9 → 0.9.11

package/dist/builtin/workflows/src/tui/dispatch-confirm.ts

@@ -5,10 +5,8 @@
  * Visual contract:
  *  - One rounded `DISPATCHED` panel.
  *  - One status-coloured rounded run card:
- *      title: runId8 · workflowName · ● running
+ *      title: full runId · workflowName · ● running
  *      body: compact `k=v · k=v · +N more` input summary when present
- *  - One compact next-step hint:
- *      ▸ /workflow connect <id>  see agents working · chat with and steer each stage
  *
  * What we deliberately do NOT emit (was in the legacy 7-row layout):
  *  - the `✓ submitted · /workflow <name>` echo line — pi already shows
@@ -16,8 +14,8 @@
  *  - the `[ DISPATCHED ]` band — a single-card surface doesn't need a
  *    band wrapper (bands frame multi-card surfaces like BACKGROUND /
  *    WORKFLOWS);
- *  - the `run id` muted caption beside the tag — the bg-pill chip with
- *    an 8-char hex string visually communicates "identifier";
+ *  - the `run id` muted caption — the bare identifier row already
+ *    communicates identity without restoring legacy chrome;
  *  - the `status starting…` body row — the `● running` badge on row 1
  *    occupies the same semantic slot;
  *  - the second hint row `▸ /workflow status` — that is a separate intent
@@ -34,13 +32,13 @@
  */
 
 import type { WorkflowInputValues } from "../shared/types.js";
-import { chatWidth, ELLIPSIS, renderHintRows, renderRoundedBox } from "./chat-surface.js";
+import { chatWidth, ELLIPSIS, renderRoundedBox } from "./chat-surface.js";
 import { hexToAnsi, RESET } from "./color-utils.js";
 import type { GraphTheme } from "./graph-theme.js";
+import { wrapIdentifierLines } from "./run-identity-rows.js";
 import { truncateToWidth, visibleWidth } from "./text-helpers.js";
 
 const INLINE_INPUT_LIMIT = 3;
-const SHORT_ID_LEN = 8;
 
 /**
  * Below this many cells, inline inputs on row 1 are unreadable. We wrap
@@ -51,9 +49,9 @@ const SHORT_ID_LEN = 8;
 const MIN_INLINE_INPUT_BUDGET = 16;
 
 export interface RenderDispatchConfirmOpts {
-	/** Registered workflow name (rendered bold beside the run-id tag on row 1). */
+	/** Registered workflow name rendered beside the full run-id body row. */
 	workflowName: string;
-	/** Real run UUID; the renderer surfaces the first 8 chars in the tag. */
+	/** Real run UUID; every rendered occurrence keeps the complete value. */
 	runId: string;
 	/** Inputs merged from CLI tokens + picker output. */
 	inputs: Readonly<WorkflowInputValues>;
@@ -72,8 +70,7 @@ export function renderDispatchConfirm(opts: RenderDispatchConfirmOpts): string {
 	const width = effectiveWidth(opts.width);
 	const theme = opts.theme;
 	const accent = theme?.warning ?? "#000000";
-	const tag = shortRunId(opts.runId);
-
+	const tag = opts.runId;
 	// Status badge — anchored to the right of row 1, in the running hue.
 	// Mirrors the `● running` glyph used by every other live-run surface.
 	const trailing = theme ? { text: "● running", fg: theme.warning } : { text: "● running" };
@@ -117,34 +114,53 @@ export function renderDispatchConfirm(opts: RenderDispatchConfirmOpts): string {
 	// the full body interior (width - body chrome) as the wider canvas.
 	if (hasInputs && titleSuffix === undefined) {
 		const BODY_PREFIX_W = 4; // "    " — see renderTaggedCard body prefix
-		const bodyBudget = Math.max(0, width - BODY_PREFIX_W - 1);
+		const bodyBudget = Math.max(0, width - 2 - BODY_PREFIX_W);
 		const overflowSeg = renderInputsSegment(opts.inputs, bodyBudget, theme);
 		if (overflowSeg) bodyRows.push(overflowSeg.rendered);
 	}
 
 	const inputRows =
 		bodyRows.length > 0 ? bodyRows.map((row) => `   ${row} `) : [`   ${titleSuffix ?? "started in background"} `];
-	const titleLine = ` ●  ${tag}  ${opts.workflowName}  ${trailing.text} `;
+	const identifierRows = renderIdentifierRows(opts.runId, width - 2, theme);
+	const titleLine = ` ●  ${opts.workflowName}  ${trailing.text} `;
 
-	const hints = renderHintRows(
-		[{ command: `/workflow connect ${tag}`, hint: "see agents working · chat with and steer each stage" }],
-		theme,
-	)
-		.split("\n")
-		.map((line) => ` ${line} `);
+	const hints = renderDispatchHintRows(opts.runId, width - 4, theme).map((line) => ` ${line} `);
 
 	return renderRoundedBox({
 		title: "DISPATCHED",
-		bodyLines: [titleLine, ...inputRows, "", ...hints],
+		bodyLines: [...identifierRows, titleLine, ...inputRows, "", ...hints],
 		accent,
 		theme,
 		width,
 	});
 }
 
-/** First 8 chars of the run UUID — the canonical short form. */
-function shortRunId(runId: string): string {
-	return runId.length > SHORT_ID_LEN ? runId.slice(0, SHORT_ID_LEN) : runId;
+function renderIdentifierRows(id: string, width: number, theme?: GraphTheme): string[] {
+	const rows = wrapIdentifierLines(id, width, "   ", "   ");
+	if (!theme) return rows.map((row) => `${row.prefix}${row.chunk}`);
+	const accent = hexToAnsi(theme.accent);
+	return rows.map((row) => `${row.prefix}${accent}${row.chunk}${RESET}`);
+}
+
+function renderDispatchHintRows(id: string, width: number, theme?: GraphTheme): string[] {
+	const budget = Math.max(1, width);
+	const prefix = "▸ /workflow connect ";
+	const continuation = "  ";
+	const rows = wrapIdentifierLines(id, budget, prefix, continuation);
+	const suffix = "  see agents working · chat with and steer each stage";
+	const last = rows[rows.length - 1]!;
+	if (visibleWidth(`${last.prefix}${last.chunk}${suffix}`) <= budget) {
+		last.chunk += suffix;
+	} else {
+		rows.push({
+			prefix: continuation,
+			chunk: truncateToWidth(suffix.trimStart(), Math.max(1, budget - visibleWidth(continuation)), ELLIPSIS),
+		});
+	}
+	if (!theme) return rows.map((row) => `${row.prefix}${row.chunk}`);
+	const dim = hexToAnsi(theme.dim);
+	const accent = hexToAnsi(theme.accent);
+	return rows.map((row) => `${dim}${row.prefix}${RESET}${accent}${row.chunk}${RESET}`);
 }
 
 interface InputsSegment {

package/dist/builtin/workflows/src/tui/graph-canvas.ts

@@ -70,14 +70,27 @@ function glyphForDirs(dirs: Set<Dir>): string {
 	return " ";
 }
 
+export interface GraphCanvasBounds {
+	top: number;
+	bottom: number;
+	left: number;
+	right: number;
+}
+
 export class GraphCanvas {
-	/** rowIdx → colIdx → Cell. Sparse — empty cells render as a single space. */
 	private rows: Map<number, Map<number, Cell>> = new Map();
 	private maxRow = -1;
 	private maxCol = -1;
 
+	constructor(private readonly bounds?: GraphCanvasBounds) {}
 	setCell(row: number, col: number, ch: string, fg: string | null): void {
 		if (row < 0 || col < 0) return;
+		if (
+			this.bounds &&
+			(row < this.bounds.top || row >= this.bounds.bottom || col < this.bounds.left || col >= this.bounds.right)
+		) {
+			return;
+		}
 		let cols = this.rows.get(row);
 		if (!cols) {
 			cols = new Map();
@@ -116,34 +129,38 @@ export class GraphCanvas {
 	 * different glyph at the final column (e.g. `>`-style arrowhead).
 	 */
 	hline(row: number, fromCol: number, toCol: number, fg: string | null): void {
-		const lo = Math.min(fromCol, toCol);
-		const hi = Math.max(fromCol, toCol);
+		if (this.bounds && (row < this.bounds.top || row >= this.bounds.bottom)) return;
+		const lo = Math.max(Math.min(fromCol, toCol), this.bounds?.left ?? 0);
+		const hi = Math.min(Math.max(fromCol, toCol), (this.bounds?.right ?? Number.POSITIVE_INFINITY) - 1);
 		for (let c = lo; c <= hi; c++) this.mergeCell(row, c, ["l", "r"], fg);
 	}
 
 	vline(col: number, fromRow: number, toRow: number, fg: string | null): void {
-		const lo = Math.min(fromRow, toRow);
-		const hi = Math.max(fromRow, toRow);
+		if (this.bounds && (col < this.bounds.left || col >= this.bounds.right)) return;
+		const lo = Math.max(Math.min(fromRow, toRow), this.bounds?.top ?? 0);
+		const hi = Math.min(Math.max(fromRow, toRow), (this.bounds?.bottom ?? Number.POSITIVE_INFINITY) - 1);
 		for (let r = lo; r <= hi; r++) this.mergeCell(r, col, ["u", "d"], fg);
 	}
 
 	/** Materialise the canvas as one ANSI-styled string per row. */
 	toLines(): string[] {
-		if (this.maxRow < 0) return [];
+		const top = this.bounds?.top ?? 0;
+		const bottom = this.bounds?.bottom ?? this.maxRow + 1;
+		const left = this.bounds?.left ?? 0;
+		if (bottom <= top) return [];
 		const lines: string[] = [];
-		for (let r = 0; r <= this.maxRow; r++) {
+		for (let r = top; r < bottom; r++) {
 			const cols = this.rows.get(r);
 			if (!cols || cols.size === 0) {
 				lines.push("");
 				continue;
 			}
 			let buf = "";
-			let cursorCol = 0;
+			let cursorCol = left;
 			let activeFg: string | null = null;
 			const sortedCols = Array.from(cols.keys()).sort((a, b) => a - b);
 			for (const c of sortedCols) {
 				if (c > cursorCol) {
-					// Reset before emitting the gap so trailing styles don't bleed.
 					if (activeFg !== null) {
 						buf += RESET;
 						activeFg = null;

package/dist/builtin/workflows/src/tui/graph-view-constants.ts

@@ -37,6 +37,9 @@ export const OVERLAY_VERTICAL_MARGIN_ROWS = 1;
  * and the running-stage border lerps between `borderDim` and
  * `warning` without a key press. The host-supplied `requestRender`
  * gate prevents work while the overlay is hidden or unfocused.
+ * GraphView also skips ticks when nothing is animating — no running or
+ * awaiting_input stage and no prompt caret — so large idle graphs do not
+ * burn ~10 full paints/sec (#2100).
  */
 export const ANIMATION_TICK_MS = 100;
 

package/dist/builtin/workflows/src/tui/graph-view-graph-render.ts

@@ -18,16 +18,14 @@ export abstract class GraphViewGraphRenderer extends GraphViewRenderHelpers {
 		if (!run || this.cachedLayout.length === 0) {
 			this.lastGraphViewport = null;
 			this.graphNodeHitRects = [];
+			this.lastGraphTotalRows = 1;
 			const dim = hexToAnsi(this.graphTheme.dim);
 			return [this._centerCanvasContent(`${dim}waiting for stage events…${RESET}`, width)];
 		}
 
 		const graphInner = Math.max(1, width - 4);
-		const canvasWidth = this.cachedLayout.reduce((max, node) => Math.max(max, node.x + NODE_W), 0);
-		// Centre the whole graph horizontally when it fits; otherwise keep a
-		// small gutter and reveal focused nodes by horizontally scrolling the
-		// graph canvas. Do not switch to a compact list: the orchestrator pane
-		// should always preserve the node-card graph view.
+		const { canvasWidth, totalRows, bands, edges } = this.cachedRenderGeometry;
+		this.lastGraphTotalRows = totalRows;
 		const leftMargin = Math.max(2, canvasWidth <= graphInner ? Math.floor((graphInner - canvasWidth) / 2) : 2);
 		const viewportWidth = Math.max(1, width - leftMargin);
 		const fullCanvasWidth = Math.max(canvasWidth, viewportWidth);
@@ -37,73 +35,83 @@ export abstract class GraphViewGraphRenderer extends GraphViewRenderHelpers {
 			this._scrollFocusedColumnIntoView(viewportWidth, fullCanvasWidth);
 		}
 
-		// Pulse phase ∈ [0, 1) derived from wall-clock time so cards lerp
-		// their border colour on the same beat regardless of how often
-		// render() fires. The animation tick (`ANIMATION_TICK_MS`) only
-		// controls render cadence — it does not advance the phase.
-		const pulsePhase = (Date.now() % PULSE_PERIOD_MS) / PULSE_PERIOD_MS;
+		const bodyRows = this._overlayBodyRows(this._overlayPanelLineCount());
+		if (totalRows > bodyRows) {
+			this._clampGraphScroll(totalRows, bodyRows);
+			if (this.pendingEnsureFocusedVisible) this._scrollFocusedIntoView(width, bodyRows, totalRows);
+			this._clampGraphScroll(totalRows, bodyRows);
+		} else {
+			this.graphScrollOffset = 0;
+		}
 
-		// 1. Plot parent → child edges into a sparse char canvas so they
-		//    survive crisp through column gaps. Node-card bodies overwrite
-		//    edge cells per-row when we compose the final output below.
-		const edgeCanvas = new GraphCanvas();
+		const viewportTop = this.graphScrollOffset;
+		const viewportBottom = Math.min(totalRows, viewportTop + bodyRows);
+		const viewportLeft = this.graphScrollColOffset;
+		const viewportRight = viewportLeft + viewportWidth;
+		const pulsePhase = (Date.now() % PULSE_PERIOD_MS) / PULSE_PERIOD_MS;
+		const edgeCanvas = new GraphCanvas({
+			top: viewportTop,
+			bottom: viewportBottom,
+			left: viewportLeft,
+			right: viewportRight,
+		});
 		const edgeColor = this.graphTheme.borderDim;
-		const nodeByStageId = new Map(this.cachedLayout.map((n) => [n.stage.id, n]));
-		for (const node of this.cachedLayout) {
-			for (const parentId of node.stage.parentIds) {
-				const parent = nodeByStageId.get(parentId);
-				if (!parent) continue;
-				this._plotEdge(edgeCanvas, parent.x, parent.y, node.x, node.y, edgeColor);
+		for (const edge of edges) {
+			if (
+				edge.bottom <= viewportTop ||
+				edge.top >= viewportBottom ||
+				edge.right <= viewportLeft ||
+				edge.left >= viewportRight
+			) {
+				continue;
 			}
+			this._plotEdge(edgeCanvas, edge.parentX, edge.parentY, edge.childX, edge.childY, edgeColor);
 		}
 		const edgeLines = edgeCanvas.toLines();
-
-		// 2. Render each node card and record its row span / start column.
-		const placements: Map<number, Placement[]> = new Map();
-		for (let ni = 0; ni < this.cachedLayout.length; ni++) {
-			const node = this.cachedLayout[ni]!;
-			const focused = ni === this.focusedIndex;
-			const cardLines = renderNodeCard(node.stage, {
-				width: NODE_W,
-				height: NODE_H,
-				focused,
-				pulsePhase,
-				theme: this.graphTheme,
-				stages: this.cachedLayout.map((layoutNode) => layoutNode.stage),
-				queuedMessageCount: this._stageQueuedMessageCount(node.stage),
-			});
-			for (let li = 0; li < cardLines.length; li++) {
-				const rowIdx = node.y + li;
-				let bucket = placements.get(rowIdx);
-				if (!bucket) {
-					bucket = [];
-					placements.set(rowIdx, bucket);
+		const placements = new Map<number, Placement[]>();
+		for (let bandIndex = this._firstVisibleLayoutBand(viewportTop); bandIndex < bands.length; bandIndex++) {
+			const band = bands[bandIndex]!;
+			if (band.top >= viewportBottom) break;
+			for (const ni of band.nodeIndices) {
+				const node = this.cachedLayout[ni]!;
+				if (node.x + NODE_W <= viewportLeft || node.x >= viewportRight) continue;
+				const cardLines = renderNodeCard(node.stage, {
+					width: NODE_W,
+					height: NODE_H,
+					focused: ni === this.focusedIndex,
+					pulsePhase,
+					theme: this.graphTheme,
+					stages: this.cachedDisplayStages,
+					queuedMessageCount: this._stageQueuedMessageCount(node.stage),
+				});
+				const visibleLeft = Math.max(node.x, viewportLeft);
+				const visibleRight = Math.min(node.x + NODE_W, viewportRight);
+				for (let li = 0; li < cardLines.length; li++) {
+					const globalRow = node.y + li;
+					if (globalRow < viewportTop || globalRow >= viewportBottom) continue;
+					const localRow = globalRow - viewportTop;
+					let bucket = placements.get(localRow);
+					if (!bucket) {
+						bucket = [];
+						placements.set(localRow, bucket);
+					}
+					bucket.push({
+						startCol: visibleLeft - viewportLeft,
+						width: visibleRight - visibleLeft,
+						line: this._sliceColumns(cardLines[li]!, visibleLeft - node.x, visibleRight - node.x),
+					});
 				}
-				bucket.push({ startCol: node.x, width: NODE_W, line: cardLines[li]! });
 			}
 		}
 
-		// 3. Compose each output row by interleaving edge segments with the
-		//    card placements at their assigned columns.
-		const totalRows = Math.max(edgeLines.length, ...this.cachedLayout.map((n) => n.y + NODE_H));
-		const composed: string[] = [];
-		for (let rowIdx = 0; rowIdx < totalRows; rowIdx++) {
-			const edgeRowChars = this._edgeRowToCells(edgeLines[rowIdx] ?? "");
-			const cards = placements.get(rowIdx) ?? [];
-			composed.push(this._composeRow(edgeRowChars, cards, edgeColor));
-		}
-
-		// Pad the full graph canvas, then crop a horizontal viewport when the
-		// fan-out is wider than the terminal. Cards/edges only paint cells they
-		// occupy; everywhere else needs explicit bg so default terminal colours
-		// never leak through.
 		const bg = hexBg(this.graphTheme.bg);
 		const leftPad = `${bg}${" ".repeat(leftMargin)}${RESET}`;
-		return composed.map((line) => {
-			const full = this._padCanvas(line, fullCanvasWidth);
-			const sliced = this._sliceColumns(full, this.graphScrollColOffset, this.graphScrollColOffset + viewportWidth);
-			return `${leftPad}${this._padCanvas(sliced, viewportWidth)}`;
-		});
+		const composed: string[] = [];
+		for (let localRow = 0; localRow < viewportBottom - viewportTop; localRow++) {
+			const line = this._composeRow(edgeLines[localRow] ?? "", placements.get(localRow) ?? [], edgeColor);
+			composed.push(`${leftPad}${this._padCanvas(line, viewportWidth)}`);
+		}
+		return composed;
 	}
 
 	protected _recordGraphNodeHitRects(graphStartRow: number, visibleRowCount: number): void {
@@ -118,52 +126,41 @@ export abstract class GraphViewGraphRenderer extends GraphViewRenderHelpers {
 		const viewportLeft = viewport.leftMargin;
 		const viewportRight = viewport.leftMargin + viewport.viewportWidth;
 		const rects: typeof this.graphNodeHitRects = [];
-
-		for (let index = 0; index < this.cachedLayout.length; index++) {
-			const node = this.cachedLayout[index]!;
-			const top = graphStartRow + node.y - this.graphScrollOffset;
-			const bottom = top + NODE_H;
-			const left = viewport.leftMargin + node.x - this.graphScrollColOffset;
-			const right = left + NODE_W;
-			const clippedTop = Math.max(visibleTop, top);
-			const clippedBottom = Math.min(visibleBottom, bottom);
-			const clippedLeft = Math.max(viewportLeft, left);
-			const clippedRight = Math.min(viewportRight, right);
-			if (clippedTop >= clippedBottom || clippedLeft >= clippedRight) continue;
-			rects.push({
-				index,
-				top: clippedTop,
-				bottom: clippedBottom,
-				left: clippedLeft,
-				right: clippedRight,
-			});
+		const viewportTop = this.graphScrollOffset;
+		const viewportBottom = viewportTop + visibleRowCount;
+		const { bands } = this.cachedRenderGeometry;
+		for (let bandIndex = this._firstVisibleLayoutBand(viewportTop); bandIndex < bands.length; bandIndex++) {
+			const band = bands[bandIndex]!;
+			if (band.top >= viewportBottom) break;
+			for (const index of band.nodeIndices) {
+				const node = this.cachedLayout[index]!;
+				const top = graphStartRow + node.y - viewportTop;
+				const bottom = top + NODE_H;
+				const left = viewport.leftMargin + node.x - this.graphScrollColOffset;
+				const right = left + NODE_W;
+				const clippedTop = Math.max(visibleTop, top);
+				const clippedBottom = Math.min(visibleBottom, bottom);
+				const clippedLeft = Math.max(viewportLeft, left);
+				const clippedRight = Math.min(viewportRight, right);
+				if (clippedTop >= clippedBottom || clippedLeft >= clippedRight) continue;
+				rects.push({ index, top: clippedTop, bottom: clippedBottom, left: clippedLeft, right: clippedRight });
+			}
 		}
 		this.graphNodeHitRects = rects;
 	}
 
 	protected _visibleGraphLines(
 		graphLines: string[],
-		frameWidth: number,
+		_frameWidth: number,
 		bodyRows: number,
 	): { lines: string[]; topPad: number } {
-		if (graphLines.length <= bodyRows) {
-			this.graphScrollOffset = 0;
-			this.pendingEnsureFocusedVisible = false;
-			return {
-				lines: graphLines,
-				topPad: Math.min(3, Math.max(0, Math.floor((bodyRows - graphLines.length) / 2))),
-			};
-		}
-
-		this._clampGraphScroll(graphLines.length, bodyRows);
-		if (this.pendingEnsureFocusedVisible) {
-			this._scrollFocusedIntoView(frameWidth, bodyRows, graphLines.length);
-			this.pendingEnsureFocusedVisible = false;
-		}
-		this._clampGraphScroll(graphLines.length, bodyRows);
+		this.pendingEnsureFocusedVisible = false;
 		return {
-			lines: graphLines.slice(this.graphScrollOffset, this.graphScrollOffset + bodyRows),
-			topPad: 0,
+			lines: graphLines,
+			topPad:
+				this.lastGraphTotalRows <= bodyRows
+					? Math.min(3, Math.max(0, Math.floor((bodyRows - this.lastGraphTotalRows) / 2)))
+					: 0,
 		};
 	}
 }

package/dist/builtin/workflows/src/tui/graph-view-render.ts

@@ -4,8 +4,6 @@ import { GraphViewGraphRenderer } from "./graph-view-graph-render.js";
 import { renderHeader, renderOutlinePill } from "./header.js";
 import { renderPromptCard } from "./prompt-card.js";
 import { renderSwitcher } from "./switcher.js";
-import { truncateToWidth } from "./text-helpers.js";
-import { renderToasts } from "./toast.js";
 
 /** Overlay/widget rendering orchestration for GraphView. */
 export abstract class GraphViewRenderer extends GraphViewGraphRenderer {
@@ -68,7 +66,6 @@ export abstract class GraphViewRenderer extends GraphViewGraphRenderer {
 
 		this._renderSwitcherOverlay(lines, run, frameWidth, bodyTarget);
 		this._renderPromptOverlay(lines, frameWidth, bodyTarget);
-		this._renderToastOverlay(lines, frameWidth);
 
 		// 5. Three-row statusline pinned to the bottom.
 		lines.push(...this._renderStatusline(frameWidth));
@@ -146,37 +143,27 @@ export abstract class GraphViewRenderer extends GraphViewGraphRenderer {
 		// surface that interacts with the prompt. When the stage switcher is
 		// open it owns the body/input, so hide the prompt card until it closes.
 		if (!this.promptState || this.switcherOpen) return;
-
+		const run = this._getCurrentRun();
 		const cardWidth = Math.min(72, Math.max(40, frameWidth - 6));
 		const cardLines = renderPromptCard({
 			state: this.promptState,
 			theme: this.graphTheme,
 			width: cardWidth,
 			cursorOn: ((Date.now() / 530) | 0) % 2 === 0,
+			identity: run ? { runId: run.id, name: run.name } : undefined,
+			maxRows: bodyTarget,
 		});
 		const bodyStart = 3;
-		const bodyEnd = 3 + bodyTarget;
+		const bodyEnd = bodyStart + bodyTarget;
 		const slot = Math.max(bodyStart, bodyStart + Math.floor((bodyTarget - cardLines.length) / 2));
+		// The card renderer owns row budgeting, but keep this composition boundary
+		// defensive: a complete card fits wholly in the body or is not painted.
+		if (cardLines.length > bodyTarget || slot + cardLines.length > bodyEnd) return;
 		const leftPad = Math.max(0, Math.floor((frameWidth - cardWidth) / 2));
 		for (let i = 0; i < cardLines.length; i++) {
 			const lineIdx = slot + i;
-			if (lineIdx >= bodyEnd) break;
 			const base = lines[lineIdx] ?? this._blankRow(frameWidth);
 			lines[lineIdx] = this._overlayCard(base, cardLines[i]!, leftPad, frameWidth);
 		}
 	}
-
-	private _renderToastOverlay(lines: string[], frameWidth: number): void {
-		// Toast overlay — top-right of header band.
-		const toastLines = renderToasts(this.toastManager.active(), {
-			theme: this.graphTheme,
-		});
-		if (toastLines.length === 0) return;
-
-		for (let i = 0; i < toastLines.length && i < lines.length; i++) {
-			const existing = lines[i] ?? "";
-			const merged = `${existing} ${toastLines[i]}`;
-			lines[i] = truncateToWidth(merged, frameWidth, "", true);
-		}
-	}
 }