@oh-my-pi/pi-tui 18.8.4 → 18.8.6

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [18.8.6] - 2026-10-08
+
+### Changed
+
+- Improved rendering performance for streaming long Markdown lists while preserving nested items, numbering, and reference links.
+
+### Fixed
+
+- Added package exports for the native Tern/TSP modules, allowing extensions in compiled `omp` binaries to import them.
+- Fixed the Tern `/model` picker's Roles tab so typing and Backspace consistently edit the search field without triggering role commands.
+- Fixed the session picker so sessions retain and display their directory when switching between the current folder and all-project views.
+
+## [18.8.5] - 2026-10-08
+
+### Added
+
+- Added a **Compacts at** fact to the model hub preview and a Roles-view **Compaction limit** action (`k`) that edits the selected row's model limit through the new `ModelBrowserSource.compactionPointFor` and `ModelHubCallbacks.onCompactionPointChange` hooks ([#14952](https://github.com/can1357/oh-my-pi/pull/14952) by [@H4vC](https://github.com/H4vC))
+
+### Fixed
+
+- Fixed `/usage` dashboard cards reordering their limit rows by usage; rows now keep the provider's window order (e.g. 5 hour → weekly → monthly) ([#14953](https://github.com/can1357/oh-my-pi/pull/14953) by [@H4vC](https://github.com/H4vC))
+- Fixed Cmd+A, Cmd+C, Cmd+X and Shift+arrow selection doing nothing in the Tern prompt while Vim mode is in Insert mode ([#14954](https://github.com/can1357/oh-my-pi/pull/14954) by [@H4vC](https://github.com/H4vC))
+
 ## [18.8.4] - 2026-10-08
 
 ### Changed

package/dist/types/chat/user-message.d.ts

@@ -4,7 +4,7 @@ import type { ReactionTarget } from "./reaction.js";
 import { type DescribeContext, type NativeNode, type NativeUiEvent } from "../native/node.js";
 /** How a user bubble styles its prose and chips (see {@link userBubbleColor}). */
 export interface UserBubbleOptions {
-    /** Materialized `file://` targets per attached image, indexed by chip number. */
+    /** Filesystem paths for attached image chips, indexed by chip number. */
     imageLinks?: readonly (string | undefined)[];
     /** The message's attached images in chip order (`#1` first); a native bubble shows them. */
     images?: readonly ImageContent[];

package/dist/types/overlays/model-browser.d.ts

@@ -37,6 +37,17 @@ export interface ResolvedModelRoleValue {
     explicitThinkingLevel: boolean;
     warning?: string;
 }
+/** Where auto-compaction triggers for one model, as the model hub's preview shows it (edited from the Roles view). */
+export interface ModelCompactionPoint {
+    /** Context tokens that trigger auto-compaction; undefined when auto-compaction is off or the window is unknown. */
+    tokens: number | undefined;
+    /** The configured percentage of the window, when the trigger is percent-based. */
+    percent?: number;
+    /** What sets it: the matching `compaction.modelThresholds` key, `global`, or `default`. */
+    source: string;
+    /** The model's own exact entry as editable text (`90k`, `80%`); absent when it has none. */
+    draft?: string;
+}
 /** Host-provided preferences and model-role resolution for the browser. */
 export interface ModelBrowserSource extends ModelRoleLookup {
     /**
@@ -58,6 +69,8 @@ export interface ModelBrowserSource extends ModelRoleLookup {
     getRoleInfo(role: string): ModelBrowserRoleInfo;
     defaultRoleChain(role: string): string[];
     resolveRoleValue(value: string | undefined, models: Model[], roleLookup?: ModelRoleLookup): ResolvedModelRoleValue;
+    /** Auto-compaction point for `model`; absent hosts show no compaction row in the preview. */
+    compactionPointFor?(model: Model): ModelCompactionPoint | undefined;
 }
 /** Read-only catalog surface consumed by model browsers. */
 export interface ModelBrowserRegistry {

package/dist/types/overlays/model-hub.d.ts

@@ -64,6 +64,12 @@ export interface ModelHubCallbacks {
     onSwitchPreset?: (name: string) => void | Promise<void>;
     /** Persist a new quick-switch cycle order (the ctrl+p role cycle). */
     onCycleOrderChange?: (order: string[]) => void;
+    /**
+     * Persist typed text as `model`'s own compaction point: a token count (`90000`,
+     * `90k`, `1M`), a percentage (`80%`), or empty to reset. Returns an error
+     * message for input it rejects, which keeps the field open.
+     */
+    onCompactionPointChange?: (model: Model, input: string) => string | undefined;
     onCancel: () => void;
 }
 export interface ModelHubOptions {

package/dist/types/overlays/session-selector.d.ts

@@ -129,7 +129,11 @@ export interface SessionSelectorOptions<T extends SessionSelectorEntry = Session
     title?: string;
     /** Fixed scope label, or false to omit the scope suffix. */
     scopeLabel?: string | false;
-    /** Show each session's working directory in the list. */
+    /**
+     * Show each session's working directory in the list. Defaults to on when
+     * the session files live in more than one directory (e.g. the folder scope
+     * merging a repository's worktrees).
+     */
     showCwd?: boolean;
     /**
      * Reads the live terminal height so the visible window fits the viewport.

package/dist/types/overlays/usage-dashboard.d.ts

@@ -33,7 +33,7 @@ export interface ProviderCard {
     /** Number of represented accounts, including unavailable usage lookups. */
     accounts: number;
     unavailableAccounts: string[];
-    /** Window rows sorted most-pressing first. */
+    /** Window rows in provider-declared order (e.g. 5h → weekly → monthly); the fullest CARD_MAX_WINDOWS lead. */
     windows: CardWindowRow[];
     /** True when every account reports no limits (e.g. enterprise plans). */
     unlimited: boolean;
@@ -52,8 +52,10 @@ export interface ProviderCard {
  * Collapse usage reports into one compact card per provider: limits grouped by
  * quota bucket (label + window), each bucket showing the mean used fraction
  * across accounts (matching the classic report's aggregate "% free") with the
- * most-used account's reset countdown. Cards sort most-pressing first so
- * what's burning is on top-left; fully idle providers collapse into a tick.
+ * most-used account's reset countdown. Rows keep the provider's declared window
+ * order so 5h → week → month reads the same every time; cards sort by their
+ * fullest window so what's burning is on top-left; fully idle providers
+ * collapse into a tick.
  */
 export declare function buildProviderCards(reports: UsageReport[], nowMs: number, unavailableAccounts?: readonly UnavailableUsageAccount[]): ProviderCard[];
 /** GitHub-style week-per-column heatmap grid derived from daily activity. */

package/dist/types/prompt/custom-editor.d.ts

@@ -118,8 +118,8 @@ export declare class CustomEditor extends Editor {
      *  Numbered by a per-draft monotonic counter so a deleted chip never recycles its number
      *  (labels key the atom table). */
     pendingTexts: TextAttachment[];
-    /** Host-wired producer of per-image `file://` links (session blob store); drives clickable
-     *  chip tokens for restored drafts (esc-esc, `/tree`, branch). */
+    /** Host-wired producer of per-image chip targets (a file on disk, or a session blob copy);
+     *  drives clickable chip tokens for restored drafts (esc-esc, `/tree`, branch). */
     draftImageLinkMaterializer?: (images: readonly ImageContent[]) => Promise<(string | undefined)[] | undefined>;
     /**
      * The host {@link TUI}, captured when a plugin constructs this editor through

package/dist/types/prompt/image-source.d.ts

@@ -4,7 +4,8 @@
  * to the session's `local://` root, and generated video contact-sheet previews.
  * Symbol metadata stays out of serialized/model-bound image data while traveling
  * with the draft object, until AgentSession creates the hidden companion message
- * that tells the model the path (and link materialization prefers it over a blob copy).
+ * that tells the model the path. The model keeps `local://` references across
+ * `/move`; chips for internal URLs instead use a stable blob copy.
  */
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 /** How an image attachment's backing file entered the session. */

package/dist/types/theme/theme.d.ts

@@ -6,7 +6,7 @@ export { getAvailableThemes, getAvailableThemesWithPaths, getThemeByName, type T
 export { isValidThemeColor, type ThemeBg, type ThemeColor } from "./schema.js";
 export { getAvailableSymbolPresets, isValidSymbolPreset, type SpinnerType, type SymbolKey, type SymbolPreset, } from "./symbols.js";
 export { Theme } from "./theme-class.js";
-export { createHighlightStream, getEditorTheme, getMarkdownTheme, getSelectListTheme, getSettingsListTheme, getSymbolTheme, highlightCode, setMarkdownMermaidRendering, warmHighlighter, } from "./tui-adapters.js";
+export { createHighlightStream, getEditorTheme, getMarkdownTheme, getMarkdownThemeWithLinkTargets, getSelectListTheme, getSettingsListTheme, getSymbolTheme, highlightCode, setMarkdownMermaidRendering, warmHighlighter, } from "./tui-adapters.js";
 /** Active theme; imports remain live across initialization, previews, and theme switches. */
 export declare var theme: Theme;
 type ThemeBinding = (value: Theme) => void;

package/dist/types/theme/tui-adapters.d.ts

@@ -16,6 +16,9 @@ export declare function createHighlightStream(lang?: string, highlightTheme?: Th
 /** Warm native syntax grammars off-thread once per process. */
 export declare function warmHighlighter(): Promise<void>;
 export declare function getSymbolTheme(): SymbolTheme;
+/** Only themes assembled here have stable callbacks and private link state. */
+export declare function canCacheMarkdownListItems(candidate: MarkdownTheme): boolean;
+export declare function getMarkdownThemeWithLinkTargets(targets: ReadonlyMap<string, string>): MarkdownTheme;
 export declare function setMarkdownMermaidRendering(enabled: boolean): void;
 export declare function getMarkdownTheme(): MarkdownTheme;
 export declare function getSelectListTheme(): SelectListTheme;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.8.4",
+	"version": "18.8.6",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -41,14 +41,14 @@
 		"gen:glyphs": "bun scripts/gen-glyphs.ts"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.8.4",
-		"@oh-my-pi/pi-agent-core": "18.8.4",
-		"@oh-my-pi/pi-ai": "18.8.4",
-		"@oh-my-pi/pi-catalog": "18.8.4",
-		"@oh-my-pi/pi-natives": "18.8.4",
-		"@oh-my-pi/pi-utils": "18.8.4",
-		"@oh-my-pi/pi-wire": "18.8.4",
-		"@oh-my-pi/snapcompact": "18.8.4"
+		"@oh-my-pi/omptype": "18.8.6",
+		"@oh-my-pi/pi-agent-core": "18.8.6",
+		"@oh-my-pi/pi-ai": "18.8.6",
+		"@oh-my-pi/pi-catalog": "18.8.6",
+		"@oh-my-pi/pi-natives": "18.8.6",
+		"@oh-my-pi/pi-utils": "18.8.6",
+		"@oh-my-pi/pi-wire": "18.8.6",
+		"@oh-my-pi/snapcompact": "18.8.6"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"
@@ -105,6 +105,10 @@
 			"types": "./dist/types/components/*.d.ts",
 			"import": "./src/components/*.ts"
 		},
+		"./native/*": {
+			"types": "./dist/types/native/*.d.ts",
+			"import": "./src/native/*.ts"
+		},
 		"./*.js": "./src/*.ts"
 	}
 }

package/src/chat/assistant-message.ts

@@ -9,7 +9,7 @@ import { formatDuration, formatNumber } from "@oh-my-pi/pi-utils";
 import chalk from "@oh-my-pi/pi-utils/chalk";
 import { LRUCache } from "@oh-my-pi/pi-utils/lru";
 import type { AssistantThinkingRenderer } from "./extension-types";
-import { ensureThemeSync, getMarkdownTheme, getThemeEpoch, theme } from "../theme";
+import { ensureThemeSync, getMarkdownTheme, getMarkdownThemeWithLinkTargets, getThemeEpoch, theme } from "../theme";
 import { card, col, elapsed, node, span, text } from "../native/describe";
 import { hasTranscriptActions, runTranscriptAction } from "./transcript-actions";
 import type { NativeChild, NativeNode, NativeUiEvent } from "../native/node";
@@ -394,7 +394,7 @@ export class AssistantMessageComponent extends Container {
 		if (this.#markdownTheme) return this.#markdownTheme;
 		const base = getMarkdownTheme();
 		const snapshot = this.#linkTargets;
-		const markdownTheme = snapshot.size > 0 ? { ...base, resolveLink: (href: string) => snapshot.get(href) } : base;
+		const markdownTheme = snapshot.size > 0 ? getMarkdownThemeWithLinkTargets(snapshot) : base;
 		this.#markdownTheme = markdownTheme;
 		return markdownTheme;
 	}

package/src/chat/user-message.ts

@@ -57,7 +57,7 @@ const OSC133_ZONE_CLOSE = OSC133_ZONE_END + OSC133_COMMAND_START + OSC133_COMMAN
 
 /** How a user bubble styles its prose and chips (see {@link userBubbleColor}). */
 export interface UserBubbleOptions {
-	/** Materialized `file://` targets per attached image, indexed by chip number. */
+	/** Filesystem paths for attached image chips, indexed by chip number. */
 	imageLinks?: readonly (string | undefined)[];
 	/** The message's attached images in chip order (`#1` first); a native bubble shows them. */
 	images?: readonly ImageContent[];

package/src/components/editor.ts

@@ -74,9 +74,12 @@ export interface NativeEditorLayout {
 	readonly caret: string;
 }
 
-/** Vim mode as the TSP `editor.mode` label. */
-const VIM_MODE_LABELS: Record<VimMode, string> = {
-	insert: "INSERT",
+/**
+ * Vim mode as the TSP `editor.mode` label. Insert carries none: Insert edits like a plain field,
+ * and a host such as Tern stops native editing (selection, ⌘A/⌘C/⌘X) for any labelled mode.
+ */
+const VIM_MODE_LABELS: Record<VimMode, string | undefined> = {
+	insert: undefined,
 	normal: "NORMAL",
 	visual: "VISUAL",
 	"visual-line": "VISUAL",

package/src/components/markdown.ts

@@ -25,7 +25,8 @@ import { md } from "../native/describe";
 import type { DescribeContext, NativeNode } from "../native/node";
 import type { SymbolTheme } from "../symbols";
 import { TERMINAL } from "../terminal-capabilities";
-import { getSymbolTheme } from "../theme/theme";
+import { getSymbolTheme, getThemeEpoch } from "../theme/theme";
+import { canCacheMarkdownListItems } from "../theme/tui-adapters";
 import type { Component } from "../tui";
 import {
 	applyBackgroundToLine,
@@ -1390,10 +1391,27 @@ interface InlineStyleContext {
 	stylePrefix: string;
 }
 
-type ListToken = Token & { items: Array<{ tokens?: Token[] }>; ordered: boolean; start?: number };
+type ListToken = Token & {
+	items: Array<{ raw: string; tokens?: Token[] }>;
+	ordered: boolean;
+	start?: number;
+	loose: boolean;
+};
 type TableCellToken = { tokens?: Token[] };
 type TableToken = Token & { header: TableCellToken[]; rows: TableCellToken[][]; raw?: string };
 
+/** `item` as marked lexes it inside a loose list: tight `text` blocks become paragraphs. */
+function loosenListItem(item: Tokens.ListItem): Tokens.ListItem {
+	if (item.loose) return item;
+	return {
+		...item,
+		loose: true,
+		tokens: item.tokens.map(token =>
+			token.type === "text" ? ({ ...token, type: "paragraph" } as Tokens.Paragraph) : token,
+		),
+	};
+}
+
 function formatHyperlink(text: string, target: string): string {
 	if (!TERMINAL.hyperlinks || !target) {
 		return text;
@@ -1743,6 +1761,25 @@ interface TailRowCache extends RenderSignature {
 	// type of token[i+1] when the rows were produced (blank/spacing gate).
 	nextTypes: (string | undefined)[];
 }
+interface ListItemRowsCache {
+	signature: RenderSignature;
+	width: number;
+	themeEpoch: number;
+	ordered: boolean;
+	start: number | undefined;
+	loose: boolean;
+	raws: string[];
+	rows: RenderedLine[][];
+}
+
+interface StreamingListCache {
+	text: string;
+	before: Token[];
+	start: number;
+	tailStart: number;
+	stableCount: number;
+	list: Tokens.List;
+}
 /**
  * Mutable per-token record collector passed to #renderContentLines while
  * rendering the streaming tail. The render loop fills `raws`/`nextTypes`
@@ -1856,6 +1893,8 @@ export class Markdown implements Component {
 	// the blank-replacement branch of setText and the fallback branch of
 	// #lexTokens.
 	#tailRowCache?: TailRowCache;
+	#listItemRowsCache?: ListItemRowsCache;
+	#streamingListCache?: StreamingListCache;
 	// True while #renderStreamingContentLines renders the frozen token range:
 	// frozen code blocks highlight even in transient mode so their bytes match
 	// the finalized render (they render once into the prefix line cache, so
@@ -1962,6 +2001,7 @@ export class Markdown implements Component {
 			// the non-append edit, so drop the frozen stream state here or it
 			// outlives the content it indexed.
 			this.#dropStreamPrefix();
+			this.#listItemRowsCache = undefined;
 			// B+: the captured fast-path rows index the replaced content — drop
 			// the recipe so a fresh stream cannot splice onto stale rows.
 			this.#fastTail = undefined;
@@ -2031,7 +2071,9 @@ export class Markdown implements Component {
 			// render consumes it (see #lexTokens / the L2 hit path).
 			this.#streamPrefixLineCache = undefined;
 			this.#tailRowCache = undefined;
+			this.#listItemRowsCache = undefined;
 			this.#streamingHighlightCache = undefined;
+			this.#streamingListCache = undefined;
 			this.#streamRewound = undefined;
 		}
 		this.invalidate();
@@ -2108,32 +2150,98 @@ export class Markdown implements Component {
 		}
 		this.#lastScanLength = text.length;
 		this.#lastScanCanStream = canStream;
+		if (!canStream) this.#listItemRowsCache = undefined;
 		this.#lastScanValid = true;
 		this.#appendOnlySinceLastScan = true;
+		if (canStream && retainPrefix) {
+			const tokens = this.#resumeStreamingList(text);
+			if (tokens !== undefined) {
+				this.#freezeStablePrefix(text, tokens, { preserveExisting: true });
+				this.#checkpointStreamingList(text, tokens);
+				return tokens;
+			}
+		}
 		if (canStream && hasPrefix) {
-			const tailTokens = markdownParser.lexer(refDefText);
-			// HAS_REF_DEF sees top-level definition lines only. A definition nested
-			// in a quote or list item still registers for the whole document and
-			// can resolve a reference in the frozen prefix, which was lexed
+			const tailTokens = lexDocument(refDefText);
+			// A definition at any nesting depth registers for the whole document
+			// and can resolve a reference in the frozen prefix, which was lexed
 			// without it, so any definition in the tail sends the text to a full lex.
 			if (Object.keys(tailTokens.links).length === 0) {
 				const tokens = [...prefixTokens, ...tailTokens];
 				if (retainPrefix) this.#freezeStablePrefix(text, tokens, { preserveExisting: true });
 				else this.#dropStreamPrefix();
+				if (retainPrefix) this.#checkpointStreamingList(text, tokens);
 				return tokens;
 			}
 		}
-		const tokens = markdownParser.lexer(text);
+		const tokens = lexDocument(text);
+		const hasReferenceDefinitions = Object.keys(tokens.links).length > 0;
+		if (hasReferenceDefinitions) this.#lastScanCanStream = false;
 		// A definition frozen into the prefix would be missing from every later
 		// tail lex, so a full lex that registered any definition freezes nothing.
-		if (canStream && retainPrefix && Object.keys(tokens.links).length === 0) {
+		if (canStream && retainPrefix && !hasReferenceDefinitions) {
 			this.#freezeStablePrefix(text, tokens, { preserveExisting: false });
+			this.#checkpointStreamingList(text, tokens);
 		} else {
 			this.#dropStreamPrefix();
 		}
 		return tokens;
 	}
 
+	#resumeStreamingList(text: string): Token[] | undefined {
+		const cached = this.#streamingListCache;
+		if (cached === undefined || text.length <= cached.text.length || !text.startsWith(cached.text)) return undefined;
+		const tail = lexDocument(text.slice(cached.tailStart));
+		if (Object.keys(tail.links).length > 0) return undefined;
+		const first = tail[0];
+		if (first?.type !== "list") return undefined;
+		const list = first as Tokens.List;
+		if (!listMayContinueAt(list.raw, 0, cached.list.raw)) return undefined;
+		const loose = cached.list.loose || list.loose;
+		const completed = cached.list.items.slice(0, cached.stableCount);
+		const items = [...completed, ...list.items];
+		const merged: Tokens.List = {
+			...cached.list,
+			raw: text.slice(cached.start, cached.tailStart + list.raw.length),
+			loose,
+			items: loose ? items.map(loosenListItem) : items,
+		};
+		return [...cached.before, merged, ...tail.slice(1)];
+	}
+
+	#checkpointStreamingList(text: string, tokens: Token[]): void {
+		const previous = this.#streamingListCache;
+		this.#streamingListCache = undefined;
+		let index = tokens.length - 1;
+		while (tokens[index]?.type === "space") index--;
+		const token = tokens[index];
+		if (token?.type !== "list") return;
+		const list = token as Tokens.List;
+		let start = 0;
+		for (let i = 0; i < index; i++) start += tokens[i]!.raw.length;
+		// Late block delimiters can absorb an unfrozen preceding region. Bare
+		// environments can also absorb list items through an equation prefix.
+		if (start !== (this.#streamPrefixText?.length ?? 0) || BARE_ENV_BEGIN.test(list.raw)) return;
+		const canResume = previous !== undefined && previous.start === start && text.startsWith(previous.text);
+		let cursor = canResume ? previous.tailStart : start;
+		let tailStart = start;
+		let stableCount = 0;
+		const indent = /^ */.exec(list.raw)![0].length;
+		for (let i = canResume ? previous.stableCount : 0; i < list.items.length; i++) {
+			const item = list.items[i]!;
+			const position = text.indexOf(item.raw, cursor);
+			if (position < cursor || position >= start + list.raw.length) return;
+			// List continuation uses the first item's indentation. Resume only at
+			// an item with that same indentation so the lexer sees the same context.
+			if (/^ */.exec(item.raw)![0].length === indent) {
+				tailStart = position;
+				stableCount = i;
+			}
+			cursor = position + item.raw.length;
+		}
+		this.#streamingListCache = { text, before: tokens.slice(0, index), start, tailStart, stableCount, list };
+	}
+
 	/**
 	 * Drop the frozen lex prefix and the transient row caches keyed on it. A
 	 * prefix set aside for #restoreRewoundPrefix checks itself against each
@@ -2146,6 +2254,8 @@ export class Markdown implements Component {
 		this.#streamSettledText = undefined;
 		this.#streamPrefixLineCache = undefined;
 		this.#tailRowCache = undefined;
+		this.#listItemRowsCache = undefined;
+		this.#streamingListCache = undefined;
 	}
 
 	/**
@@ -2186,6 +2296,8 @@ export class Markdown implements Component {
 	#rewindStreamPrefix(end: number, count: number): void {
 		this.#streamPrefixLineCache = rewoundLineCache(this.#streamPrefixLineCache, count);
 		this.#tailRowCache = undefined;
+		this.#listItemRowsCache = undefined;
+		this.#streamingListCache = undefined;
 		if (count === 0) {
 			this.#streamPrefixText = undefined;
 			this.#streamPrefixTokens = undefined;
@@ -2223,6 +2335,8 @@ export class Markdown implements Component {
 		this.#streamPrefixOpeners = rewound.openers;
 		this.#streamPrefixLineCache = rewound.lineCache;
 		this.#tailRowCache = rewound.tailRowCache;
+		this.#listItemRowsCache = undefined;
+		this.#streamingListCache = undefined;
 	}
 
 	// Freeze the largest run of leading blocks that end on a hard "\n\n" boundary
@@ -2591,6 +2705,7 @@ export class Markdown implements Component {
 		signature: RenderSignature,
 		contentWidth: number,
 	): string[] {
+		if (tokens[tokens.length - 1]?.type !== "list") this.#listItemRowsCache = undefined;
 		const stableText = this.#streamPrefixText;
 		const stableTokenCount = this.#streamPrefixTokens?.length ?? 0;
 		if (stableText === undefined || stableTokenCount === 0 || !normalizedText.startsWith(stableText)) {
@@ -3594,6 +3709,41 @@ export class Markdown implements Component {
 		const indent = "  ".repeat(depth);
 		// Use the list's start property (defaults to 1 for ordered lists)
 		const startNumber = token.start ?? 1;
+		const signature =
+			depth === 0 &&
+			styleContext === undefined &&
+			this.#defaultTextStyle === undefined &&
+			this.#transientRenderCache &&
+			!this.#renderingStablePrefix &&
+			this.#lastScanCanStream &&
+			canCacheMarkdownListItems(this.#theme)
+				? this.#activeRenderSignature
+				: undefined;
+		const themeEpoch = signature === undefined ? undefined : getThemeEpoch();
+		const previous = this.#listItemRowsCache;
+		const reusable =
+			signature !== undefined &&
+			themeEpoch !== undefined &&
+			previous !== undefined &&
+			previous.width === width &&
+			previous.themeEpoch === themeEpoch &&
+			previous.ordered === token.ordered &&
+			previous.start === token.start &&
+			previous.loose === token.loose &&
+			this.#signatureEquals(previous.signature, signature)
+				? previous
+				: undefined;
+		let reusableCount = 0;
+		if (reusable !== undefined) {
+			while (
+				reusableCount < token.items.length &&
+				token.items[reusableCount]?.raw === reusable.raws[reusableCount]
+			) {
+				reusableCount++;
+			}
+		}
+		const raws: string[] | undefined = signature === undefined ? undefined : [];
+		const rows: RenderedLine[][] | undefined = signature === undefined ? undefined : [];
 		const pushWrapped = (line: RenderedLine, firstPrefix: string, continuationPrefix: string): void => {
 			if (line.literalCode) {
 				const wrappedLiteralRows = wrapTextWithAnsi(line.text, Math.max(1, width));
@@ -3629,6 +3779,14 @@ export class Markdown implements Component {
 
 		for (let i = 0; i < token.items.length; i++) {
 			const item = token.items[i];
+			if (i < reusableCount && reusable !== undefined && raws !== undefined && rows !== undefined) {
+				const cached = reusable.rows[i]!;
+				for (const row of cached) lines.push(row);
+				raws.push(item.raw);
+				rows.push(cached);
+				continue;
+			}
+			const rowStart = lines.length;
 			const bullet = token.ordered ? `${startNumber + i}. ` : "- ";
 			const firstPrefix = indent + this.#theme.listBullet(bullet);
 			// Continuation rows align under the item text, so the hang matches the
@@ -3658,6 +3816,22 @@ export class Markdown implements Component {
 			} else {
 				lines.push(renderedLine(firstPrefix));
 			}
+			if (raws !== undefined && rows !== undefined) {
+				raws.push(item.raw);
+				rows.push(lines.slice(rowStart));
+			}
+		}
+		if (signature !== undefined && themeEpoch !== undefined && raws !== undefined && rows !== undefined) {
+			this.#listItemRowsCache = {
+				signature,
+				width,
+				themeEpoch,
+				ordered: token.ordered,
+				start: token.start,
+				loose: token.loose,
+				raws,
+				rows,
+			};
 		}
 
 		return lines;

package/src/overlays/model-browser.ts

@@ -122,6 +122,18 @@ export interface ResolvedModelRoleValue {
 	warning?: string;
 }
 
+/** Where auto-compaction triggers for one model, as the model hub's preview shows it (edited from the Roles view). */
+export interface ModelCompactionPoint {
+	/** Context tokens that trigger auto-compaction; undefined when auto-compaction is off or the window is unknown. */
+	tokens: number | undefined;
+	/** The configured percentage of the window, when the trigger is percent-based. */
+	percent?: number;
+	/** What sets it: the matching `compaction.modelThresholds` key, `global`, or `default`. */
+	source: string;
+	/** The model's own exact entry as editable text (`90k`, `80%`); absent when it has none. */
+	draft?: string;
+}
+
 /** Host-provided preferences and model-role resolution for the browser. */
 export interface ModelBrowserSource extends ModelRoleLookup {
 	/**
@@ -143,6 +155,8 @@ export interface ModelBrowserSource extends ModelRoleLookup {
 	getRoleInfo(role: string): ModelBrowserRoleInfo;
 	defaultRoleChain(role: string): string[];
 	resolveRoleValue(value: string | undefined, models: Model[], roleLookup?: ModelRoleLookup): ResolvedModelRoleValue;
+	/** Auto-compaction point for `model`; absent hosts show no compaction row in the preview. */
+	compactionPointFor?(model: Model): ModelCompactionPoint | undefined;
 }
 
 /** Read-only catalog surface consumed by model browsers. */
@@ -2061,7 +2075,7 @@ export class ModelBrowser implements Component {
 	pickerPreview(mode: "full" | "compact", current?: string): readonly NativeChild[] {
 		const selected = this.getSelected();
 		const item = selected && !this.#isDisabled(selected) ? selected : undefined;
-		const key = `${mode}\0${current ?? ""}`;
+		const key = `${mode}\0${current ?? ""}\0${this.#settings.revision}`;
 		const memo = this.#pickerPreview;
 		if (
 			memo !== undefined &&
@@ -2155,6 +2169,17 @@ export class ModelBrowser implements Component {
 			if (v) facts.push({ k: [span(k, "muted")], v: [span(v, "mono")] });
 		};
 		fact("Context", ctx > 0 ? ctx.toLocaleString("en-US") : undefined);
+		const compaction = this.#settings.compactionPointFor?.(model);
+		if (compaction) {
+			const value =
+				compaction.tokens === undefined
+					? "off"
+					: `${compaction.tokens.toLocaleString("en-US")}${compaction.percent !== undefined ? ` · ${compaction.percent}%` : ""}`;
+			facts.push({
+				k: [span("Compacts at", "muted")],
+				v: [span(value, "mono"), span(` · ${compaction.source}`, "dim")],
+			});
+		}
 		fact("Max output", out > 0 ? out.toLocaleString("en-US") : undefined);
 		fact("Price", isFreeModel(model) ? "free" : `${previewPrice(model)} per M`);
 		fact("Speed", speed.length > 0 ? speed.join(" · ") : undefined);