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

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [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

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/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.5",
+	"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.5",
-		"@oh-my-pi/pi-agent-core": "18.8.5",
-		"@oh-my-pi/pi-ai": "18.8.5",
-		"@oh-my-pi/pi-catalog": "18.8.5",
-		"@oh-my-pi/pi-natives": "18.8.5",
-		"@oh-my-pi/pi-utils": "18.8.5",
-		"@oh-my-pi/pi-wire": "18.8.5",
-		"@oh-my-pi/snapcompact": "18.8.5"
+		"@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/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-hub.ts

@@ -1991,7 +1991,13 @@ export class ModelHubComponent implements Component {
 
 		if (rolesView) {
 			const printable = extractPrintableText(data);
-			if (this.#focus === "scope" && printable !== undefined && printable.trim().length > 0) {
+			// Typing searches the catalog from the sidebar, and from the rows
+			// while a query is live (the picker shows its search field only
+			// then); otherwise the rows' letter commands own printable keys.
+			const typed = printable !== undefined && printable.trim().length > 0;
+			const editsQuery =
+				this.#browser.query.length > 0 && (printable !== undefined || matchesKey(data, "backspace"));
+			if ((this.#focus === "scope" && typed) || editsQuery) {
 				this.#setActiveEntry("all");
 				this.#focus = "list";
 				this.#browser.handleInput(data);
@@ -2434,9 +2440,14 @@ export class ModelHubComponent implements Component {
 			Math.max(0, active),
 		);
 		const { names, active: activePreset } = this.#presets();
+		// p/P type into a live query instead of switching presets.
+		const presetKeys =
+			this.#browser.query.length > 0
+				? formatKeyHints(["ctrl+left", "ctrl+right"])
+				: `${formatKeyHints(["ctrl+left", "ctrl+right"])} · ${formatKeyHints(["p", "shift+p"])}`;
 		const preset =
 			names.length > 0
-				? `   ${theme.fg("dim", "Preset:")} ${activePreset ? theme.fg("accent", activePreset) : theme.fg("muted", "custom")}  ${theme.fg("dim", `${formatKeyHints(["ctrl+left", "ctrl+right"])} · ${formatKeyHints(["p", "shift+p"])}`)}`
+				? `   ${theme.fg("dim", "Preset:")} ${activePreset ? theme.fg("accent", activePreset) : theme.fg("muted", "custom")}  ${theme.fg("dim", presetKeys)}`
 				: "";
 		return truncateToWidth(
 			` ${theme.fg("dim", "Roles:")} ${track}  ${theme.fg("dim", formatKeyHints(["alt+left", "alt+right"]))}${preset}`,
@@ -2741,6 +2752,10 @@ export class ModelHubComponent implements Component {
 					this.#presets().names.length > 0 ? ` · ${formatKeyHints(["ctrl+left", "ctrl+right"])} preset` : "";
 				return `${upDown} providers · ${enterRight} roles · ${altLeftRight} tabs${presets} · ${cancel} close`;
 			}
+			// A live query takes printable keys and backspace, so the letter commands rest.
+			if (this.#browser.query.length > 0) {
+				return `${upDown} rows · ${enter} pick · type to search · ${left} providers · ${cancel} close`;
+			}
 			const row = this.#rolesRows[this.#roleIndex];
 			const compaction =
 				this.#callbacks.onCompactionPointChange && this.#roleRowModel()
@@ -3228,7 +3243,9 @@ export class ModelHubComponent implements Component {
 			size: "lg",
 			layout: "rows",
 			preview: "side",
-			query: this.#browser.query,
+			// The Roles rows' letter commands own printable keys until a query
+			// is live, so the sheet offers no search field to type into.
+			query: rolesView && this.#browser.query.length === 0 ? null : this.#browser.query,
 			cursor: this.#browser.cursor,
 			placeholder: "Search models…",
 			scopes: this.#pickerScopes(),
@@ -3486,8 +3503,15 @@ export class ModelHubComponent implements Component {
 		}
 		if (rolesView) {
 			const row = this.#rolesRows[this.#roleIndex];
+			// A live query takes the letter keys: those buttons keep working but lose their keycaps.
+			const searching = this.#browser.query.length > 0;
 			const roleAction = (action: RolesAction, label: string, key: string, primary = false) =>
-				pickerAction(`roles:${action}`, label, key, primary ? { primary: true } : undefined);
+				pickerAction(
+					`roles:${action}`,
+					label,
+					searching && key !== "enter" ? undefined : key,
+					primary ? { primary: true } : undefined,
+				);
 			const actions: (TspPickerAction | undefined)[] = [];
 			const compaction =
 				this.#callbacks.onCompactionPointChange && this.#roleRowModel()
@@ -4042,6 +4066,17 @@ export class ModelHubComponent implements Component {
 					cancel("close"),
 				];
 			}
+			// A live query takes printable keys and backspace, so the letter commands rest.
+			if (this.#browser.query.length > 0) {
+				return [
+					upDown("rows"),
+					keys("pick", "enter"),
+					search,
+					keys("providers", "left"),
+					presetHint,
+					cancel("close"),
+				];
+			}
 			const row = this.#rolesRows[this.#roleIndex];
 			const compaction =
 				this.#callbacks.onCompactionPointChange && this.#roleRowModel() ? keys("compaction limit", "k") : undefined;

package/src/overlays/session-selector.ts

@@ -1330,7 +1330,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.
@@ -1374,6 +1378,7 @@ export class SessionSelectorComponent<T extends SessionSelectorEntry = SessionSe
 	#onRequestRender?: () => void;
 	readonly #loadAllSessions?: () => Promise<T[]>;
 	#folderSessions: T[];
+	readonly #folderShowCwd: boolean;
 	#globalSessions: T[] | null = null;
 	#scope: "folder" | "all" = "folder";
 	#toggling = false;
@@ -1440,6 +1445,9 @@ export class SessionSelectorComponent<T extends SessionSelectorEntry = SessionSe
 		this.#onDelete = options.onDelete;
 		this.#loadAllSessions = options.loadAllSessions;
 		this.#folderSessions = sessions;
+		// Storage directory, not recorded cwd: one folder's sessions may record
+		// symlink aliases of the same path, which must not turn the column on.
+		this.#folderShowCwd = options.showCwd ?? new Set(sessions.map(session => path.dirname(session.path))).size > 1;
 		this.#globalSessions = options.allSessions ?? null;
 		this.#getTerminalRows = options.getTerminalRows ?? (() => 24);
 		this.#fillHeight = options.fillHeight ?? false;
@@ -1457,7 +1465,7 @@ export class SessionSelectorComponent<T extends SessionSelectorEntry = SessionSe
 		// projects' history (issue #3099).
 		this.#sessionList = new SessionList(
 			sessions,
-			options.showCwd ?? false,
+			this.#folderShowCwd,
 			options.historyMatcher,
 			options.getTerminalRows,
 			options.pinnedIds,
@@ -1530,7 +1538,7 @@ export class SessionSelectorComponent<T extends SessionSelectorEntry = SessionSe
 			this.#sessionList.setSessions(global, true);
 		} else {
 			this.#scope = "folder";
-			this.#sessionList.setSessions(this.#folderSessions, false);
+			this.#sessionList.setSessions(this.#folderSessions, this.#folderShowCwd);
 		}
 		this.title = this.#headerLabel();
 		this.#onRequestRender?.();

package/src/prompt/tips.txt

@@ -30,4 +30,5 @@ Turn on `/advisor` to attach a second model that reviews every turn and quietly
 Try starting your prompt with a ->, and writing a list (1. Do X, 2. Do Y)
 Press {key:shift+tab} to cycle through reasoning effort levels
 omp can reconfigure and extend itself — ask any questions you have!
-Lint/type errors piling up? `omp cleanse` (or /cleanse right here) hunts project diagnostics and fixes them with parallel subagents — {key:escape} cancels
+Lint/type errors piling up? `omp cleanse` (or /cleanse right here) hunts project diagnostics and fixes them with parallel subagents — {key:escape} cancels
+[NO-TERN] Psst, omp has a natural habitat 🐦 [tern](https://scl.so/tern)

package/src/prompt/welcome.ts

@@ -5,21 +5,32 @@ import { editorKey } from "../chrome/keybinding-hints";
 import { getKeybindings, type Keybinding } from "../keybindings";
 import { card, col, keyed, node, row, span, text } from "../native/describe";
 import type { DescribeContext, NativeChild, NativeNode } from "../native/node";
-import { plainLine } from "../native/spans";
+import { compactText, plainText } from "../native/spans";
 import { isNativeRendering } from "../native/state";
+import { isHyperlinkEnabled, urlHyperlink, urlLinkSpan } from "../render/hyperlink";
 import { TERMINAL } from "../terminal-capabilities";
 import { theme } from "../theme/theme";
 import type { Component } from "../tui";
 import { padding, replaceTabs, visibleWidth, wrapTextWithAnsi } from "../utils";
 import tipsText from "./tips.txt" with { type: "text" };
 
-/** Tips embedded at build time, one per line; blanks dropped. Key placeholders
+/** Leading marker for a tip that pitches Tern: shown only while no TSP surface
+ *  is live, since a live one means the user is already in Tern. */
+const NO_TERN_TIP_MARKER = /^\[NO-TERN\]\s*/;
+
+/** tips.txt lines embedded at build time; blanks dropped. Key placeholders
  *  (see {@link expandTipKeys}) stay raw until render time. */
-const TIPS: readonly string[] = tipsText
+const TIP_LINES: readonly string[] = tipsText
 	.split("\n")
 	.map(line => line.trim())
 	.filter(line => line.length > 0);
 
+/** Tips for the classic renderer: every tip, {@link NO_TERN_TIP_MARKER} stripped. */
+const TIPS: readonly string[] = TIP_LINES.map(line => line.replace(NO_TERN_TIP_MARKER, ""));
+
+/** Tips for a live TSP surface: those marked {@link NO_TERN_TIP_MARKER} dropped. */
+const TSP_TIPS: readonly string[] = TIP_LINES.filter(line => !NO_TERN_TIP_MARKER.test(line));
+
 /** Trailing marker that flags a tip as a "what's new" callout. Stripped before
  *  wrapping (with any preceding whitespace) and replaced by {@link NEW_TAG_TEXT}
  *  painted as a shimmering rainbow. Non-global so `.test` stays stateless. */
@@ -107,6 +118,31 @@ function expandTipKeys(tip: string): string {
 	});
 }
 
+/** Markdown-style links in tips.txt: `[Tern](https://scl.so/tern)` shows the label, linked to the URL. */
+const TIP_LINK = /\[([^\]]+)\]\(([^\s)]+)\)/g;
+
+/** Tip links as underlined OSC 8 labels, or `label (url)` where the terminal cannot link. */
+function linkTipText(tip: string): string {
+	const linkable = isHyperlinkEnabled();
+	return tip.replace(TIP_LINK, (_link, label: string, url: string) =>
+		linkable ? urlHyperlink(url, theme.underline(label)) : `${label} (${url})`,
+	);
+}
+
+/** The tip as native text: escapes dropped, links as `href` spans. */
+function tipSpans(tip: string): TspSpan[] {
+	const spans: TspSpan[] = [];
+	let cursor = 0;
+	for (const match of tip.matchAll(TIP_LINK)) {
+		const [link, label, url] = match;
+		if (match.index > cursor) spans.push(span(plainText(tip.slice(cursor, match.index))));
+		spans.push(urlLinkSpan(url, label));
+		cursor = match.index + link.length;
+	}
+	if (cursor < tip.length) spans.push(span(plainText(tip.slice(cursor))));
+	return spans;
+}
+
 /**
  * The welcome tip as lines of at most `width` columns: `Tip:` and the body
  * wrapped together, with no indent, so the banner can center each line.
@@ -117,7 +153,7 @@ export function renderWelcomeTip(tip: string, width: number, phase = 0): string[
 	if (width - visibleWidth(label) < 8) return [];
 
 	const isNew = NEW_TIP_MARKER.test(tip);
-	const body = expandTipKeys(isNew ? tip.replace(NEW_TIP_MARKER, "") : tip);
+	const body = linkTipText(expandTipKeys(isNew ? tip.replace(NEW_TIP_MARKER, "") : tip));
 
 	// Trailing spaces left by the wrap would count toward the width the banner centers.
 	const wrapped = wrapTextWithAnsi(replaceTabs(`${label}${body}`), width).map(line => line.trimEnd());
@@ -164,9 +200,10 @@ export class WelcomeComponent implements Component {
 	#animTimer: Timer | null = null;
 	#requestRender: (() => void) | null = null;
 	// Tip randomness is latched once so the tip is stable across renders, but
-	// the nerdfont-nag gate re-reads the live preset: the startup prepaint can
-	// run under the default "unicode" preset before settings resolve the real
-	// one, and a memoized nag would survive the switch to "nerd".
+	// the nerdfont-nag gate re-reads the live preset and the pool re-reads the
+	// live TSP state: the startup prepaint can run under the default "unicode"
+	// preset before settings resolve the real one, and an optimistic Tern start
+	// falls back to the classic renderer when `hello` never confirms.
 	#nagRoll: number | undefined;
 	#tipRoll: number | undefined;
 	// Render cache: the welcome box is the first transcript-area component, so
@@ -183,7 +220,7 @@ export class WelcomeComponent implements Component {
 		if (theme.getSymbolPreset() === "unicode" && this.#nagRoll < 0.1) {
 			return "Please use nerdfont 😭.";
 		}
-		return pickWeightedTip(TIPS, this.#tipRoll) || undefined;
+		return pickWeightedTip(isNativeRendering() ? TSP_TIPS : TIPS, this.#tipRoll) || undefined;
 	}
 
 	invalidate(): void {
@@ -237,7 +274,7 @@ export class WelcomeComponent implements Component {
 		const body: NativeChild[] = [lockupRow];
 		if (tip) {
 			const isNew = NEW_TIP_MARKER.test(tip);
-			const tipText = plainLine(expandTipKeys(isNew ? tip.replace(NEW_TIP_MARKER, "") : tip));
+			const tipText = compactText(tipSpans(expandTipKeys(isNew ? tip.replace(NEW_TIP_MARKER, "") : tip)));
 			const tipRow: NativeChild[] = [
 				node("icon", { name: "lightbulb", role: "omp.welcome.tip-icon" }),
 				text(tipText, { wrap: "word", role: "omp.welcome.tip-text" }),

package/src/theme/theme.ts

@@ -34,6 +34,7 @@ export {
 	createHighlightStream,
 	getEditorTheme,
 	getMarkdownTheme,
+	getMarkdownThemeWithLinkTargets,
 	getSelectListTheme,
 	getSettingsListTheme,
 	getSymbolTheme,

package/src/theme/tui-adapters.ts

@@ -183,8 +183,75 @@ export function getSymbolTheme(): SymbolTheme {
 
 let cachedMarkdownTheme: MarkdownTheme | undefined;
 let cachedMarkdownThemeRef: Theme | undefined;
+const cacheableMarkdownThemes = new WeakMap<
+	MarkdownTheme,
+	{
+		theme: Theme;
+		fields: ReadonlyArray<readonly [PropertyKey, unknown]>;
+		symbolFields: ReadonlyArray<readonly [PropertyKey, unknown]>;
+		symbolValues: string;
+	}
+>();
+const linkTargetSnapshots = new WeakMap<ReadonlyMap<string, string>, ReadonlyMap<string, string>>();
 let markdownMermaidRendering = true;
 
+function ownFields(object: object): ReadonlyArray<readonly [PropertyKey, unknown]> {
+	return Reflect.ownKeys(object).map(key => [key, Object.getOwnPropertyDescriptor(object, key)?.value]);
+}
+
+function hasUnchangedOwnFields(object: object, fields: ReadonlyArray<readonly [PropertyKey, unknown]>): boolean {
+	if (Reflect.ownKeys(object).length !== fields.length) return false;
+	return fields.every(([key, value]) => {
+		const descriptor = Object.getOwnPropertyDescriptor(object, key);
+		return descriptor !== undefined && "value" in descriptor && descriptor.value === value;
+	});
+}
+
+/** Only themes assembled here have stable callbacks and private link state. */
+export function canCacheMarkdownListItems(candidate: MarkdownTheme): boolean {
+	const registered = cacheableMarkdownThemes.get(candidate);
+	if (registered === undefined || registered.theme !== theme || candidate.symbols === undefined) return false;
+	if (!hasUnchangedOwnFields(candidate, registered.fields)) return false;
+	if (!hasUnchangedOwnFields(candidate.symbols, registered.symbolFields)) return false;
+	try {
+		return JSON.stringify(candidate.symbols) === registered.symbolValues;
+	} catch {
+		return false;
+	}
+}
+
+function registerCacheableMarkdownTheme(markdownTheme: MarkdownTheme): void {
+	if (markdownTheme.symbols === undefined) return;
+	cacheableMarkdownThemes.set(markdownTheme, {
+		theme,
+		fields: ownFields(markdownTheme),
+		symbolFields: ownFields(markdownTheme.symbols),
+		symbolValues: JSON.stringify(markdownTheme.symbols),
+	});
+}
+
+export function getMarkdownThemeWithLinkTargets(targets: ReadonlyMap<string, string>): MarkdownTheme {
+	const base = getMarkdownTheme();
+	let snapshot = linkTargetSnapshots.get(targets);
+	let matches = snapshot?.size === targets.size;
+	if (matches && snapshot !== undefined) {
+		for (const [href, target] of targets) {
+			if (snapshot.get(href) !== target) {
+				matches = false;
+				break;
+			}
+		}
+	}
+	if (snapshot === undefined || !matches) {
+		snapshot = new Map(targets);
+		linkTargetSnapshots.set(targets, snapshot);
+	}
+	const stableSnapshot = snapshot;
+	const linked: MarkdownTheme = { ...base, resolveLink: href => stableSnapshot.get(href) };
+	if (canCacheMarkdownListItems(base)) registerCacheableMarkdownTheme(linked);
+	return linked;
+}
+
 export function setMarkdownMermaidRendering(enabled: boolean): void {
 	if (markdownMermaidRendering === enabled) return;
 	markdownMermaidRendering = enabled;
@@ -247,6 +314,7 @@ export function getMarkdownTheme(): MarkdownTheme {
 	};
 	cachedMarkdownTheme = markdownTheme;
 	cachedMarkdownThemeRef = theme;
+	registerCacheableMarkdownTheme(markdownTheme);
 	return markdownTheme;
 }