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

package/src/prompt/composer.ts

@@ -103,6 +103,13 @@ export interface RuntimeChildrenOptions {
 	 * to the roots below the transcript in render order.
 	 */
 	readonly nativeDock?: readonly Component[];
+	/**
+	 * Below-transcript containers whose children continue `main` on a TSP
+	 * terminal, one block each after the transcript's, instead of riding in the
+	 * dock: output on its way into the transcript (shell runs deferred until the
+	 * next prompt) reads as its tail, and keeps its block when it moves in.
+	 */
+	readonly nativeTail?: readonly Container[];
 	/**
 	 * Below-transcript roots the user opens and closes (the editor surface that
 	 * drafts and dialogs swap into, docked reports). Their rows never become
@@ -259,6 +266,7 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 	#headerAfter: readonly Component[] = [];
 	#runtimeChildren: readonly Component[] = [];
 	#nativeDock: readonly Component[] | undefined;
+	#nativeTail: readonly Container[] = [];
 	/** Cache-driven status line shown until {@link setStatusComponent} mounts the session's. */
 	#startupStatus: StatusLineComponent | undefined;
 	#runtimeMounted = false;
@@ -653,10 +661,11 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 	/**
 	 * Describe the whole surface for a TSP terminal. `main` is the flowing
 	 * document: the header (welcome, extras) and every transcript block as its
-	 * own component child. `dock` is the live chrome below the transcript in
-	 * render order: pending messages, HUDs, the working row, the editor and the
-	 * status line. There is no history/viewport split: retirement, resize
-	 * replay and hover bands are ANSI concerns.
+	 * own component child, then the children of the
+	 * {@link RuntimeChildrenOptions.nativeTail} roots. `dock` is the live chrome
+	 * below the transcript in render order: pending messages, HUDs, the working
+	 * row, the editor and the status line. There is no history/viewport split:
+	 * retirement, resize replay and hover bands are ANSI concerns.
 	 */
 	describeSurface(): NativeSurface {
 		if (!this.#started || this.#stopped) return this.#nativeSurface;
@@ -673,7 +682,9 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 			} else {
 				const transcript = roots[transcriptIndex] as TranscriptContainer;
 				main.push(...roots.slice(0, transcriptIndex), ...transcript.nativeBlocks());
-				dock.push(...(this.#nativeDock ?? roots.slice(transcriptIndex + 1)));
+				for (const root of this.#nativeTail) main.push(...root.children);
+				const tail: readonly Component[] = this.#nativeTail;
+				dock.push(...(this.#nativeDock ?? roots.slice(transcriptIndex + 1).filter(root => !tail.includes(root))));
 			}
 		}
 		const previous = this.#nativeSurface;
@@ -1259,6 +1270,7 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		this.#chromeFloorPromoted = false;
 		this.#resetIdleChrome();
 		this.#nativeDock = options.nativeDock;
+		this.#nativeTail = options.nativeTail ?? [];
 		this.#transientChrome = new Set(options.transientChrome);
 		this.#selfClearingChrome = new Set(options.selfClearingChrome);
 		this.#transientFloor = undefined;

package/src/render/render-utils.ts

@@ -103,6 +103,8 @@ export const PREVIEW_LIMITS = {
 	EXPANDED_LINES: 12,
 	/** Items (files, results) shown in collapsed view */
 	COLLAPSED_ITEMS: 8,
+	/** Definition, type-definition and implementation locations shown in collapsed view */
+	LOCATIONS_COLLAPSED: 2,
 	/** Output preview lines in collapsed view */
 	OUTPUT_COLLAPSED: 3,
 	/** Output preview lines in expanded view */

package/src/theme/theme-class.ts

@@ -138,6 +138,15 @@ const LANG_BRAND_COLORS: Partial<Record<SymbolKey, string>> = {
 const BACKGROUND_RESET_PATTERN = /\x1b\[(?:0|49)m/g;
 const FOREGROUND_RESET_PATTERN = /\x1b\[(?:0|39)m/g;
 
+/**
+ * Color `text` with the foreground `ansi`, restoring it after every nested reset so the rest of `text`
+ * keeps it (`fg("dim", `${fg("success", "+2")} more`)`); only the foreground is reset at the end.
+ */
+function wrapForeground(ansi: string, text: string): string {
+	const body = text.includes("\x1b[") ? text.replace(FOREGROUND_RESET_PATTERN, `$&${ansi}`) : text;
+	return `${ansi}${body}\x1b[39m`;
+}
+
 // Prebuilt stylers: each `chalk.<style>` access builds a fresh builder. Builders share the
 // root chalk context, so later `chalk.level` changes still apply.
 const boldStyler = chalk.bold;
@@ -350,7 +359,7 @@ export class Theme {
 	fg(color: ThemeColor, text: string): string {
 		const ansi = this.#fgColors[color];
 		if (!ansi) throw new Error(`Unknown theme color: ${color}`);
-		return `${ansi}${text}\x1b[39m`; // Reset only foreground color
+		return wrapForeground(ansi, text);
 	}
 
 	/** Apply a foreground, replacing terminal-default tokens with the theme's contrast-safe fallback. */
@@ -362,7 +371,7 @@ export class Theme {
 			resolved = ansi === "\x1b[39m" ? colorToAnsi(this.getColorHex(color), this.mode) : ansi;
 			this.#resolvedFgColors.set(color, resolved);
 		}
-		return `${resolved}${text.replace(FOREGROUND_RESET_PATTERN, `$&${resolved}`)}\x1b[39m`;
+		return wrapForeground(resolved, text);
 	}
 
 	bg(color: ThemeBg, text: string): string {
@@ -390,7 +399,7 @@ export class Theme {
 	 */
 	fgOnBg(color: ThemeColor, background: ThemeBg, text: string): string {
 		const ansi = this.getFgOnBgAnsi(color, background);
-		return `${ansi}${text.replace(FOREGROUND_RESET_PATTERN, `$&${ansi}`)}\x1b[39m`;
+		return wrapForeground(ansi, text);
 	}
 
 	bold(text: string): string {

package/src/theme/theme.ts

@@ -32,6 +32,7 @@ export {
 	getSettingsListTheme,
 	getSymbolTheme,
 	highlightCode,
+	isHighlightLanguage,
 	setMarkdownMermaidRendering,
 	warmHighlighter,
 } from "./tui-adapters";

package/src/theme/tui-adapters.ts

@@ -96,12 +96,17 @@ function highlightCached(code: string, validLang: string | undefined, highlightT
 	return highlighted;
 }
 
+/** Whether {@link highlightCode} colors `lang`; text in any other language comes back unstyled. */
+export function isHighlightLanguage(lang: string | undefined): lang is string {
+	return lang !== undefined && nativeSupportsLanguage(lang);
+}
+
 /**
  * Highlight code with syntax coloring based on file extension or language.
  * Returns array of highlighted lines.
  */
 export function highlightCode(code: string, lang?: string, highlightTheme: Theme = theme): string[] {
-	const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
+	const validLang = isHighlightLanguage(lang) ? lang : undefined;
 	const highlighted = highlightCached(code, validLang, highlightTheme);
 	// Always return a fresh array: callers (e.g. renderCodeCell) push extra lines
 	// onto the result, which would corrupt the cached string otherwise.
@@ -110,7 +115,7 @@ export function highlightCode(code: string, lang?: string, highlightTheme: Theme
 
 /** Create a stateful highlighter for progressive terminal rendering. */
 export function createHighlightStream(lang?: string, highlightTheme: Theme = theme): NativeHighlightStream | null {
-	const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
+	const validLang = isHighlightLanguage(lang) ? lang : undefined;
 	if (!validLang) return null;
 	// Workspace loads skip the natives version sentinel, so a stale local
 	// `.node` can omit `HighlightStream` after a pull. Napi constructors can
@@ -305,7 +310,7 @@ export function getMarkdownTheme(): MarkdownTheme {
 					})
 			: undefined,
 		highlightCode: (code: string, lang?: string): string[] => {
-			const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
+			const validLang = isHighlightLanguage(lang) ? lang : undefined;
 			const highlighted = highlightCached(code, validLang, theme);
 			if (highlighted !== null) return highlighted.split("\n");
 			return code.split("\n").map(line => theme.fg("mdCodeBlock", line));

package/src/thinking.ts

@@ -312,23 +312,21 @@ export function resolveTaskEffortLevel(
 			break;
 	}
 	if (maxEffort === undefined) return resolved;
+	if (model) assertModelSupportsEffortCeiling(model, maxEffort);
 	const maxIndex = THINKING_EFFORTS.indexOf(maxEffort);
-	const ceiling = supported.findLast(candidate => THINKING_EFFORTS.indexOf(candidate) <= maxIndex);
-	if (ceiling === undefined) {
-		const modelName = model ? `${model.provider}/${model.id}` : "Selected model";
-		throw new RangeError(`${modelName} has no supported thinking effort at or below task.maxEffort=${maxEffort}`);
-	}
+	// Without a model the full canonical range always holds `maxEffort` itself.
+	const ceiling = supported.findLast(candidate => THINKING_EFFORTS.indexOf(candidate) <= maxIndex) ?? maxEffort;
 	return THINKING_EFFORTS.indexOf(resolved) > THINKING_EFFORTS.indexOf(ceiling) ? ceiling : resolved;
 }
 
 /**
  * Clamps a concrete thinking selector to a per-session effort ceiling (e.g. a
- * task spawn's `task.maxEffort`-capped effort hint). `off`/`inherit`/
- * `undefined` pass through, as do levels already at or below the ceiling.
- * Levels above it snap to the highest model-supported effort at or below the
- * ceiling. A model whose floor exceeds the ceiling has nothing valid to snap
- * to; the requested level is returned unchanged and the caller is responsible
- * for rejecting or skipping such models (see {@link modelSupportsEffortCeiling}).
+ * task spawn's `task.maxEffort`). Unset/`inherit`/`off` retain their existing
+ * meaning, as do levels already at or below the ceiling. Levels above it snap
+ * to the highest model-supported effort at or below the ceiling. A model whose
+ * floor exceeds the ceiling has nothing valid to snap to; the requested level
+ * is returned unchanged and the caller must reject or skip such models (see
+ * {@link modelSupportsEffortCeiling}).
  */
 export function clampThinkingLevelToCeiling(
 	model: Model | undefined,
@@ -367,6 +365,14 @@ export function modelSupportsEffortCeiling(model: Model, ceiling: Effort): boole
 	return supported.some(candidate => THINKING_EFFORTS.indexOf(candidate) <= maxIndex);
 }
 
+/** Throws when `model` has no supported effort at or below `task.maxEffort`, so a capped spawn fails instead of running at its floor. */
+export function assertModelSupportsEffortCeiling(model: Model, maxEffort: Effort): void {
+	if (modelSupportsEffortCeiling(model, maxEffort)) return;
+	throw new RangeError(
+		`${model.provider}/${model.id} has no supported thinking effort at or below task.maxEffort=${maxEffort}`,
+	);
+}
+
 /**
  * The provisional concrete level shown while `auto` is configured but before a
  * turn has been classified, and the fallback when classification fails. Prefers

package/src/tools/ast-grep.ts

@@ -14,7 +14,12 @@ import {
 	PREVIEW_LIMITS,
 	toPathList,
 } from "../render/render-utils";
-import { classifyGroupedLines, describeGroupedOutput, groupLineIndicesByBlank } from "./grouped-file-output";
+import {
+	classifyGroupedLines,
+	createCodeFrameStyler,
+	describeGroupedOutput,
+	groupLineIndicesByBlank,
+} from "./grouped-file-output";
 import { code, compact, node, span } from "../native/describe";
 import type { NativeChild } from "../native/node";
 import { errorText, noteText, resultText, toolHead } from "./native-view";
@@ -51,6 +56,8 @@ interface AstGrepRenderArgs {
 	/** Legacy pre-`path` argument name; kept so historical transcripts still render a scope. */
 	paths?: string[];
 	skip?: number;
+	/** Language the search parsed the files as; highlighting follows it over the file extension. */
+	lang?: string;
 }
 
 const COLLAPSED_MATCH_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
@@ -124,6 +131,7 @@ export const astGrepToolRenderer = {
 		// Resolve hyperlinks over the whole output so nested directory headers
 		// reconstruct across the blank-line groups the tree list collapses by.
 		const contexts = classifyGroupedLines(allLines, details?.cwd ?? details?.searchPath, details?.searchPath);
+		const styleCodeFrame = createCodeFrameStyler(allLines, contexts, "toolOutput", uiTheme, args?.lang);
 		// The displayed lines are sanitized, but OSC 8 destinations must retain the
 		// original path bytes. Only substitute targets for headers already linked
 		// by the sanitized output; never let raw text create additional links.
@@ -159,7 +167,7 @@ export const astGrepToolRenderer = {
 				const tinted = uiTheme.fg(ctx.depth === 1 ? "accent" : "dim", line);
 				styled = target ? fileHyperlink(target, tinted) : tinted;
 			} else {
-				styled = uiTheme.fg(line.startsWith("  meta:") ? "dim" : "toolOutput", line);
+				styled = styleCodeFrame(index) ?? uiTheme.fg(line.startsWith("  meta:") ? "dim" : "toolOutput", line);
 			}
 			styledLines[index] = styled;
 			return styled;

package/src/tools/eval.ts

@@ -120,6 +120,8 @@ export interface EvalToolDetails {
 	statusEvents?: EvalStatusEvent[];
 	/** Evictable events dropped from the front of `statusEvents` (see {@link recordStatusEvent}). */
 	statusEventsElided?: number;
+	/** Text the cell's tool calls sent to `out://`, oldest first; transcripts draw each as a reply after the call. */
+	replies?: string[];
 	isError?: boolean;
 	meta?: OutputMeta;
 	/** First backend that produced cells. Kept for transcript compatibility. */

package/src/tools/find.ts

@@ -17,7 +17,8 @@ import {
 	PREVIEW_LIMITS,
 	replaceTabs,
 } from "../render/render-utils";
-import type { Theme, ThemeColor } from "../theme/theme";
+import { getLanguageFromPath } from "../lang-from-path";
+import { highlightCode, isHighlightLanguage, type Theme, type ThemeColor } from "../theme/theme";
 import type { Component } from "../tui";
 import type { OutputMeta } from "./output-meta";
 import type {
@@ -171,10 +172,14 @@ function renderHit(hit: FindHit, rangeLimit: number, cwd: string | undefined, ra
 		`${gauge(hit.contentScore, theme)} ${theme.fg(scoreColor(hit.contentScore), hit.contentScore.toFixed(2))} ${link(theme.fg("accent", hit.rel))} ${theme.fg("dim", coverage)}`,
 	];
 	const ranges = [...hit.ranges].sort((a, b) => b.p - a.p || a.start - b.start).slice(0, rangeLimit);
+	const lang = getLanguageFromPath(hit.rel);
 	ranges.forEach((range, index) => {
 		const span = range.start === range.end ? String(range.start) : `${range.start}-${range.end}`;
 		const ref = link(theme.fg("muted", `:${span}`), range.start);
-		const snippet = theme.fg("toolOutput", replaceTabs(range.snippet.trim()));
+		const source = replaceTabs(range.snippet.trim());
+		const snippet = isHighlightLanguage(lang)
+			? highlightCode(source, lang, theme).join("\n")
+			: theme.fg("toolOutput", source);
 		const branch = theme.fg("dim", getTreeBranch(index === ranges.length - 1, theme));
 		lines.push(`  ${branch} ${ref} ${theme.fg("dim", range.p.toFixed(2))} ${snippet}`);
 	});

package/src/tools/grep.ts

@@ -34,7 +34,12 @@ import {
 	PREVIEW_LIMITS,
 	replaceTabs,
 } from "../render/render-utils";
-import { classifyGroupedLines, describeGroupedOutput, groupLineIndicesByBlank } from "./grouped-file-output";
+import {
+	classifyGroupedLines,
+	createCodeFrameStyler,
+	describeGroupedOutput,
+	groupLineIndicesByBlank,
+} from "./grouped-file-output";
 
 /** Display metadata for grep tool results. */
 export interface GrepToolDetails {
@@ -214,6 +219,7 @@ function createSearchLineStyler(
 	target: (displayPath: string) => string,
 ): (index: number) => string {
 	const contexts = classifyGroupedLines(lines, headerBase, fileScope);
+	const styleCodeFrame = createCodeFrameStyler(lines, contexts, "toolOutput", uiTheme);
 	// `classifyGroupedLines` can't resolve internal URLs (TUI-only), so track the
 	// resolved URL target here and use it for the body lines that follow.
 	const urlRaw: (string | undefined)[] = Array.from({ length: lines.length }, () => undefined);
@@ -257,7 +263,7 @@ function createSearchLineStyler(
 				styled = ctx.headerPath ? fileHyperlink(target(ctx.headerPath), tinted) : tinted;
 			}
 		} else {
-			const tinted = uiTheme.fg("toolOutput", line);
+			const tinted = styleCodeFrame(index) ?? uiTheme.fg("toolOutput", line);
 			const lineNumber = parseSearchDisplayLineNumber(line);
 			const filePath = ctx.filePath ? target(ctx.filePath) : urlFiles[index];
 			styled = filePath && lineNumber !== undefined ? fileHyperlink(filePath, tinted, { line: lineNumber }) : tinted;

package/src/tools/grouped-file-output.ts

@@ -2,8 +2,11 @@ import * as path from "node:path";
 
 import { buildPathTree, isUrlLikePath, type PathTreeInput, walkPathTree } from "@oh-my-pi/pi-utils";
 import type { TspTone } from "@oh-my-pi/pi-wire";
-import { code, col, keyed, span, text } from "../native/describe";
+import { code, col, keyed } from "../native/describe";
 import type { NativeNode } from "../native/node";
+import { getLanguageFromPath } from "../lang-from-path";
+import { replaceTabs } from "../render/render-utils";
+import { highlightCode, isHighlightLanguage, type Theme, type ThemeColor } from "../theme/theme";
 import { formatHashlineHeader } from "./hashline-format";
 import { fileRow } from "./native-view";
 
@@ -266,6 +269,135 @@ export function groupLineIndicesByBlank(rawLines: readonly string[]): number[][]
 	return groups;
 }
 
+// =============================================================================
+// Code frames highlighted in their file's language (TUI renderers)
+// =============================================================================
+
+/** A code-frame row split after its rule: the gutter (match marker, line number, rule) and the source line. */
+interface CodeFrameRow {
+	gutter: string;
+	source: string;
+}
+
+/**
+ * Draw the code-frame rows of consecutive source lines: each gutter in
+ * `color`, the sources highlighted in `lang` as one run, so a multi-line
+ * string or comment keeps its colors. Without a language the sources take
+ * `color` too.
+ */
+function renderCodeFrameRun(
+	rows: readonly CodeFrameRow[],
+	lang: string | undefined,
+	color: ThemeColor,
+	theme: Theme,
+): string[] {
+	const sources = rows.map(row => replaceTabs(row.source));
+	const highlighted = isHighlightLanguage(lang) ? highlightCode(sources.join("\n"), lang, theme) : undefined;
+	return rows.map((row, index) => {
+		const source = highlighted?.[index] ?? theme.fg(color, sources[index]!);
+		return `${theme.fg(color, row.gutter)}${source}`;
+	});
+}
+
+/** A numbered code-frame row of search output, with its line number. */
+interface NumberedCodeFrame {
+	row: CodeFrameRow;
+	n: number;
+}
+
+function parseNumberedCodeFrame(line: string): NumberedCodeFrame | undefined {
+	const match = GROUPED_NUMBERED_LINE_RE.exec(line);
+	if (!match) return undefined;
+	const source = match[3]!;
+	return { row: { gutter: line.slice(0, line.length - source.length), source }, n: Number(match[2]) };
+}
+
+/** The file a grouped file header names, without its suffix and hashline tag: `## a.ts#3f2a (2)` → `a.ts`. */
+function groupedHeaderName(line: string): string {
+	const rest = GROUPED_HEADER_RE.exec(line)?.[2]?.trimEnd() ?? "";
+	return rest.replace(HEADER_SUFFIX_RE, "").replace(HEADER_HASH_TAG_RE, "");
+}
+
+/**
+ * Source rows highlighted together. A run longer than this (a huge AST match) highlights chunk by chunk as rows
+ * are requested, so a collapsed view never tokenizes source it hides; a string or comment spanning a chunk
+ * boundary loses its continuation there.
+ */
+const CODE_FRAME_CHUNK_ROWS = 64;
+
+/**
+ * Styled code-frame rows of grouped search output, highlighted in each owning
+ * file's language (`lang` overrides it when the highlighter knows it). A run of
+ * consecutive line numbers in one file highlights together on its first
+ * request; a gap row, a jump in line numbers or another file starts a new run.
+ * Rows without a numbered code frame (headers, gap rows, notes) return
+ * undefined, for the caller to style.
+ */
+export function createCodeFrameStyler(
+	lines: readonly string[],
+	contexts: readonly GroupedLineContext[],
+	color: ThemeColor,
+	theme: Theme,
+	lang?: string,
+): (index: number) => string | undefined {
+	// Each body row's language: the override, else its owning file's, from the resolved path or its header's name.
+	const langOverride = isHighlightLanguage(lang) ? lang : undefined;
+	const langs: (string | undefined)[] = [];
+	let headerLang: string | undefined;
+	for (let index = 0; index < lines.length; index++) {
+		const ctx = contexts[index]!;
+		if (ctx.kind === "content") {
+			langs.push(langOverride ?? (ctx.filePath ? getLanguageFromPath(ctx.filePath) : headerLang));
+			continue;
+		}
+		headerLang = ctx.kind === "file" ? getLanguageFromPath(groupedHeaderName(lines[index]!)) : undefined;
+		langs.push(undefined);
+	}
+
+	const frames: (NumberedCodeFrame | null)[] = [];
+	const frameAt = (index: number): NumberedCodeFrame | null => {
+		let frame = frames[index];
+		if (frame === undefined) {
+			frame = contexts[index]!.kind === "content" ? (parseNumberedCodeFrame(lines[index]!) ?? null) : null;
+			frames[index] = frame;
+		}
+		return frame;
+	};
+	// Whether the row at `index` continues the run of the row above it.
+	const continuesRun = (index: number): boolean => {
+		if (index <= 0 || langs[index] !== langs[index - 1]) return false;
+		const frame = frameAt(index);
+		const above = frameAt(index - 1);
+		return frame !== null && above !== null && frame.n === above.n + 1;
+	};
+	// First row of each row's run, memoized so walking back through a long run happens once.
+	const runStarts: number[] = [];
+	const runStartOf = (index: number): number => {
+		let row = index;
+		while (runStarts[row] === undefined && continuesRun(row)) row--;
+		const start = runStarts[row] ?? row;
+		for (let filled = row; filled <= index; filled++) runStarts[filled] = start;
+		return start;
+	};
+
+	const styled: string[] = [];
+	return index => {
+		if (frameAt(index) === null) return undefined;
+		const cached = styled[index];
+		if (cached !== undefined) return cached;
+		const runStart = runStartOf(index);
+		const start = runStart + Math.floor((index - runStart) / CODE_FRAME_CHUNK_ROWS) * CODE_FRAME_CHUNK_ROWS;
+		let end = index + 1;
+		while (end < start + CODE_FRAME_CHUNK_ROWS && end < lines.length && continuesRun(end)) end++;
+		const chunkRows: CodeFrameRow[] = [];
+		for (let row = start; row < end; row++) chunkRows.push(frameAt(row)!.row);
+		renderCodeFrameRun(chunkRows, langs[index], color, theme).forEach((row, offset) => {
+			styled[start + offset] = row;
+		});
+		return styled[index];
+	};
+}
+
 // =============================================================================
 // Native (TSP) description of grouped output
 // =============================================================================
@@ -306,10 +438,10 @@ export function* walkGroupedOutput(lines: readonly string[]): Generator<GroupedO
 
 /** `*12│text`, ` 12|text`, `*12:text`: optional match marker, line number, gutter, content. */
 const GROUPED_NUMBERED_LINE_RE = /^\s*(\*?)(\d+)(?:│|[:|])(.*)$/;
-/** `    │...`: grep's gap between non-adjacent context runs (drawn as {@link numberedCode}'s `…` row). */
+/** `    │...`: grep's gap between non-adjacent context runs (Tern draws it from the jump in {@link numberedCode}'s numbers). */
 const GROUPED_GAP_LINE_RE = /^\s*│\.\.\.$/;
 
-/** One source line for {@link numberedCode}: its number (`null` for an elision marker), text and match mark. */
+/** One source line for {@link numberedCode}: its number (`null` for an elision marker, which adds no line), text and match mark. */
 export interface NumberedLine {
 	n: number | null;
 	text: string;
@@ -317,58 +449,52 @@ export interface NumberedLine {
 }
 
 /**
- * Numbered `code` for possibly non-contiguous source lines: one block per run
- * of consecutive line numbers (`start` = the run's first line, match lines
- * `mark`ed), with a `…` row wherever the numbers jump or an elision marker
- * (`n: null`) sits. `path` is the file the lines come from: Tern picks their
- * grammar from it and draws no header (the row or head above names the file).
- * `wrap` soft-wraps long lines instead of scrolling the block sideways.
+ * One numbered `code` block for possibly non-contiguous source lines (match
+ * lines `mark`ed by their line number): `start` when the numbers run on
+ * consecutively, else `nums` (each line's number), from whose jumps Tern draws
+ * the `…` gap rows in the gutter. Elision markers (`n: null`) add no line; the
+ * numbers jump around them. `path` is the file the lines come from: Tern picks
+ * their grammar from it and draws no header (the row or head above names the
+ * file). `wrap` soft-wraps long lines instead of scrolling the block sideways.
+ * `undefined` when no line is numbered.
  */
 export function numberedCode(
 	lines: readonly NumberedLine[],
 	opts: { path?: string; wrap?: boolean } = {},
-): NativeNode[] {
-	const out: NativeNode[] = [];
-	let run: { start: number; text: string[]; marks: { line: number; tone: TspTone }[] } | undefined;
-	const flush = () => {
-		if (!run) return;
-		// The quiet `…` row between two non-adjacent runs.
-		if (out.length > 0) out.push(keyed(text([span("…", "dim")], { wrap: "none" }), `g${run.start}`));
-		out.push(
-			keyed(
-				code(run.text.join("\n"), {
-					start: run.start,
-					numbers: true,
-					path: opts.path,
-					wrap: opts.wrap,
-					marks: run.marks.length > 0 ? run.marks : undefined,
-				}),
-				`c${run.start}`,
-			),
-		);
-		run = undefined;
-	};
+): NativeNode | undefined {
+	const nums: number[] = [];
+	const body: string[] = [];
+	const marks: { line: number; tone: TspTone }[] = [];
+	let contiguous = true;
 	for (const line of lines) {
-		if (line.n === null) {
-			flush();
-			continue;
-		}
-		if (run && run.start + run.text.length !== line.n) flush();
-		run ??= { start: line.n, text: [], marks: [] };
-		run.text.push(line.text);
-		if (line.mark) run.marks.push({ line: line.n, tone: "accent" });
+		if (line.n === null) continue;
+		if (nums.length > 0 && line.n !== nums[nums.length - 1]! + 1) contiguous = false;
+		nums.push(line.n);
+		body.push(line.text);
+		if (line.mark) marks.push({ line: line.n, tone: "accent" });
 	}
-	flush();
-	return out;
+	if (nums.length === 0) return undefined;
+	return keyed(
+		code(body.join("\n"), {
+			start: contiguous ? nums[0] : undefined,
+			nums: contiguous ? undefined : nums,
+			numbers: true,
+			path: opts.path,
+			wrap: opts.wrap,
+			marks: marks.length > 0 ? marks : undefined,
+		}),
+		`c${nums[0]}`,
+	);
 }
 
 /**
  * Describe grouped search output (grep / ast-grep / ast-edit display content)
  * by file (§7.3 grep): per file a 22px path row (dim dir, strong name, the
  * header's suffix or the match count as a chip), then its lines as
- * {@link numberedCode} with match lines marked and `…` between non-adjacent
- * runs. Unnumbered body lines stay plain `code`. `maxFiles` keeps only the
- * first files (the caller says how many were left out). `file` owns the lines
+ * one {@link numberedCode} block with match lines marked (gaps between
+ * non-adjacent runs drawn in its gutter). Unnumbered body lines stay plain
+ * `code`. `maxFiles` keeps only the first files (the caller says how many
+ * were left out). `file` owns the lines
  * before any header: a single-file search prints none, yet its lines get the
  * same file row as a directory search's.
  */
@@ -386,10 +512,9 @@ export function describeGroupedOutput(
 
 	const flushLines = () => {
 		const target = current?.children ?? loose;
-		if (numbered.length > 0) {
-			target.push(...numberedCode(numbered, { path: current?.path }));
-			numbered = [];
-		}
+		const block = numberedCode(numbered, { path: current?.path });
+		if (block) target.push(block);
+		numbered = [];
 		if (plain.length > 0) {
 			target.push(keyed(code(plain.join("\n")), `p${target.length}`));
 			plain = [];