@oh-my-pi/pi-tui 18.4.12 → 18.5.0

package/src/overlays/plan-review-overlay.ts

@@ -249,6 +249,11 @@ export class PlanReviewOverlay implements Component {
 	#nativeRoot: NativeNode | undefined;
 	/** Content the memoized root was built from. */
 	#nativeRootContent: NativePlanContent | undefined;
+	/**
+	 * The section the last Contents jump targets under a native surface, which
+	 * scrolls the body itself: `n` counts the jumps, so each one reveals it again.
+	 */
+	#jump: { section: number; n: number } | undefined;
 
 	constructor(
 		planContent: string,
@@ -798,6 +803,7 @@ export class PlanReviewOverlay implements Component {
 	#scrubBodyToToc(): void {
 		const sectionIndex = this.#toc[this.#tocCursor];
 		if (sectionIndex === undefined) return;
+		this.#jump = { section: sectionIndex, n: (this.#jump?.n ?? 0) + 1 };
 		const offset = this.#sectionOffsets[sectionIndex];
 		if (offset !== undefined) {
 			this.#scrollView.setScrollOffset(offset);
@@ -1404,6 +1410,7 @@ export class PlanReviewOverlay implements Component {
 		const sig = [
 			this.#focus,
 			this.#tocCursor,
+			this.#jump?.n ?? 0,
 			this.#selectedIndex,
 			this.#sliderIndex,
 			this.#committed ? `committed:${this.#committedLabel ?? ""}` : "",
@@ -1419,10 +1426,17 @@ export class PlanReviewOverlay implements Component {
 		const children: NativeChild[] = [];
 		const tools = this.#describeTools();
 		if (tools) children.push(tools);
+		// The section a Contents jump targets scrolls to the body's top.
+		const jump = this.#jump;
+		const body = jump
+			? content.body.map((section): NativeNode =>
+					section.key === `s${jump.section}` ? { ...section, reveal: { at: "start", n: jump.n } } : section,
+				)
+			: content.body;
 		const bodyCol = node(
 			"col",
 			{ role: "omp.plan.body", grow: 1, gap: "md", tone: this.#focus === "body" ? "accent" : undefined },
-			content.body,
+			body,
 			"body",
 		);
 		if (this.#sidebarShown) {

package/src/overlays/report-panel.ts

@@ -0,0 +1,191 @@
+import type { TspScrollBy, TspText } from "@oh-my-pi/pi-wire";
+import { OverlayPanel } from "../chrome/overlay-box";
+import { editorKey } from "../chrome/keybinding-hints";
+import { Ellipsis } from "../index";
+import { ScrollView } from "../components/scroll-view";
+import { Spacer } from "../components/spacer";
+import { Text } from "../components/text";
+import {
+	matchesSelectCancel,
+	matchesSelectDown,
+	matchesSelectPageDown,
+	matchesSelectPageUp,
+	matchesSelectUp,
+} from "../keybinding-matchers";
+import { matchesKey } from "../keys";
+import { routeSgrMouseInput } from "../mouse";
+import { actionBar, actionButton } from "../native/overlay";
+import { col } from "../native/describe";
+import type { NativeNode, NativeScroll, NativeUiEvent } from "../native/node";
+import { theme } from "../theme/theme";
+import type { Component } from "../tui";
+
+/** Options of a {@link ReportPanel}. */
+export interface ReportPanelOptions {
+	/** Plain title: the text-mode border title, and the native sheet head unless {@link head} is given. */
+	readonly title: string;
+	/** Styled native sheet head. */
+	readonly head?: TspText;
+	/** The read-only report; it draws no frame or title of its own. */
+	readonly body: Component;
+	/**
+	 * Display form of the key that dismisses the report while it sits above the
+	 * editor (the editor's interrupt key, which routes to it). Once the panel
+	 * holds focus ({@link ReportPanel.holdFocus}) the hint shows the key its own
+	 * input closes on instead.
+	 */
+	readonly closeKey: string;
+	/** The focused panel (native sheet, text-mode full-screen page) closes on Esc / its Close button: this runs. */
+	readonly onClose: () => void;
+	/**
+	 * Most rows the text-mode panel may take, borders included (the screen rows
+	 * left above the editor); a taller report scrolls inside it. `undefined`
+	 * leaves it uncapped.
+	 */
+	readonly maxRows?: () => number | undefined;
+}
+
+/** Text-mode rows around the scrolled body: the borders, two spacers and the footer. */
+const TEXT_CHROME_ROWS = 5;
+
+/**
+ * A read-only command report (`/changelog`, `/context`, `/tools`, …).
+ *
+ * Text mode draws a titled box with the body and an Esc hint: above the editor
+ * like the `/btw` panel while it fits there (the editor keeps focus and its
+ * Esc takes it away), or as a full-screen page on the alternate screen when it
+ * is taller, whose body scrolls on the arrow/page/Home/End keys and the wheel.
+ * Natively it is a sheet like `/usage`: a centred `lg` glass sheet titled by
+ * the report whose body the terminal scrolls (wheel, and the same keys
+ * forwarded as scroll requests), then a Close button; Esc closes it.
+ */
+export class ReportPanel extends OverlayPanel {
+	readonly nativeOverlay: NonNullable<Component["nativeOverlay"]>;
+	readonly #body: Component;
+	readonly #onClose: () => void;
+	readonly #maxRows: (() => number | undefined) | undefined;
+	readonly #view: ScrollView;
+	readonly #footer: Text;
+	#closeHint: string;
+	#bodyRows = 0;
+	#scroll: NativeScroll | undefined;
+	#native: { scroll: NativeScroll | undefined; node: NativeNode } | undefined;
+
+	constructor(options: ReportPanelOptions) {
+		super(options.title, "omp.overlay.report");
+		this.nativeOverlay = {
+			role: "omp.overlay.report",
+			size: "lg",
+			anchor: "center",
+			head: options.head ?? options.title,
+		};
+		this.#body = options.body;
+		this.#onClose = options.onClose;
+		this.#maxRows = options.maxRows;
+		this.#closeHint = `${options.closeKey} to close`;
+		this.#view = new ScrollView(options.body, {
+			height: 0,
+			scrollbar: "auto",
+			ellipsis: Ellipsis.Omit,
+			theme: { track: text => theme.fg("dim", text), thumb: text => theme.fg("accent", text) },
+		});
+		this.#footer = new Text(theme.fg("muted", this.#closeHint), 0, 0);
+		this.addChild(new Spacer(1));
+		this.addChild(this.#view);
+		this.addChild(new Spacer(1));
+		this.addChild(this.#footer);
+	}
+
+	/**
+	 * The panel is shown with focus (native sheet, text-mode full-screen page):
+	 * its own {@link handleInput} closes it, so the hint names that key.
+	 */
+	holdFocus(): void {
+		this.#closeHint = `${editorKey("tui.select.cancel")} to close`;
+	}
+
+	/**
+	 * Text mode: cap the box to {@link ReportPanelOptions.maxRows}, scrolling a
+	 * taller body. The cap is a hard limit: when a resize leaves fewer rows than
+	 * the box's chrome needs, its bottom (the hint and closing border) is cut
+	 * rather than spilling over the editor.
+	 */
+	override render(width: number): readonly string[] {
+		const innerWidth = Math.max(1, width - 4);
+		const rows = this.#body.render(innerWidth).length;
+		const cap = this.#maxRows?.();
+		const bodyMax = cap === undefined ? rows : Math.max(1, cap - TEXT_CHROME_ROWS);
+		const overflows = rows > bodyMax;
+		this.#bodyRows = Math.min(rows, bodyMax);
+		this.#view.setHeight(this.#bodyRows);
+		const scrollHint = `${editorKey("tui.select.pageUp")}/${editorKey("tui.select.pageDown")} scroll · `;
+		this.#footer.setText(theme.fg("muted", overflows ? scrollHint + this.#closeHint : this.#closeHint));
+		const lines = super.render(width);
+		return cap !== undefined && lines.length > cap ? lines.slice(0, Math.max(0, cap)) : lines;
+	}
+
+	/** Text mode: rows the whole box takes at `width` when nothing caps it. */
+	heightAt(width: number): number {
+		return this.#body.render(Math.max(1, width - 4)).length + TEXT_CHROME_ROWS;
+	}
+
+	/** The sheet body (the overlay is the frame, and its body the scroller): the report, then Close (Esc). */
+	override describe(): NativeNode {
+		const scroll = this.#scroll;
+		if (this.#native && this.#native.scroll === scroll) return this.#native.node;
+		const body: NativeNode = { ...col([this.#body]), key: "body", scroll };
+		const node = col([body, actionBar([null, actionButton("Close", "close", { keys: "escape" })])], { gap: "md" });
+		this.#native = { scroll, node };
+		return node;
+	}
+
+	override invalidate(): void {
+		this.#native = undefined;
+		super.invalidate();
+	}
+
+	/**
+	 * Focused (the native sheet, or the text-mode full-screen page): Esc closes;
+	 * the arrow, page, Home and End keys and the wheel scroll the body.
+	 */
+	handleInput(data: string): void {
+		if (
+			routeSgrMouseInput(data, event => {
+				if (event.wheel === null) return false;
+				this.#view.scroll(event.wheel * 3);
+				return true;
+			})
+		) {
+			return;
+		}
+		if (matchesSelectCancel(data)) {
+			this.#onClose();
+			return;
+		}
+		const by: TspScrollBy | undefined = matchesSelectUp(data)
+			? "line-up"
+			: matchesSelectDown(data)
+				? "line-down"
+				: matchesSelectPageUp(data)
+					? "page-up"
+					: matchesSelectPageDown(data)
+						? "page-down"
+						: matchesKey(data, "home")
+							? "start"
+							: matchesKey(data, "end")
+								? "end"
+								: undefined;
+		if (by === undefined) return;
+		// Natively the terminal scrolls the sheet body; text mode scrolls the box.
+		this.#scroll = { by, n: (this.#scroll?.n ?? 0) + 1 };
+		const page = Math.max(1, this.#bodyRows - 1);
+		if (by === "start") this.#view.scrollToTop();
+		else if (by === "end") this.#view.scrollToBottom();
+		else this.#view.scroll(by === "line-up" ? -1 : by === "line-down" ? 1 : by === "page-up" ? -page : page);
+	}
+
+	/** Close runs what Esc runs. */
+	handleNativeEvent(event: NativeUiEvent): void {
+		if (event.type === "action" && event.act === "close") this.#onClose();
+	}
+}

package/src/overlays/thinking-selector.ts

@@ -1,7 +1,6 @@
-import type { Effort } from "@oh-my-pi/pi-ai";
+import { AUTO_THINKING, type ConfiguredThinkingLevel, getConfiguredThinkingLevelMetadata } from "../thinking";
 import { type SelectItem, SelectList, type SgrMouseEvent } from "../index";
 import { getSelectListTheme } from "../theme/theme";
-import { getThinkingLevelMetadata } from "../thinking";
 import { OverlayPanel } from "../chrome/overlay-box";
 import { routeSelectListMouseWithTopBorder } from "../chrome/select-list-mouse-routing";
 import type { DescribeContext, NativeNode, NativeUiEvent } from "../native/node";
@@ -15,14 +14,14 @@ export class ThinkingSelectorComponent extends OverlayPanel {
 	#sheet: SelectListSheet;
 
 	constructor(
-		currentLevel: Effort,
-		availableLevels: Effort[],
-		onSelect: (level: Effort) => void,
+		currentLevel: ConfiguredThinkingLevel | undefined,
+		availableLevels: ConfiguredThinkingLevel[],
+		onSelect: (level: ConfiguredThinkingLevel) => void,
 		onCancel: () => void,
 	) {
 		super("Thinking Level", "omp.overlay.thinking");
 
-		const thinkingLevels: SelectItem[] = availableLevels.map(getThinkingLevelMetadata);
+		const thinkingLevels: SelectItem[] = availableLevels.map(getConfiguredThinkingLevelMetadata);
 
 		// Create selector
 		this.#selectList = new SelectList(thinkingLevels, thinkingLevels.length, getSelectListTheme());
@@ -34,7 +33,7 @@ export class ThinkingSelectorComponent extends OverlayPanel {
 		}
 
 		this.#selectList.onSelect = item => {
-			onSelect(item.value as Effort);
+			onSelect(item.value as ConfiguredThinkingLevel);
 		};
 
 		this.#selectList.onCancel = () => {
@@ -46,10 +45,11 @@ export class ThinkingSelectorComponent extends OverlayPanel {
 			title: "Thinking level",
 			icon: "brain",
 			noun: "levels",
-			current: [currentLevel],
-			decorate: item => ({
-				chips: [{ text: "", dot: `thinking${item.value.charAt(0).toUpperCase()}${item.value.slice(1)}` }],
-			}),
+			current: currentLevel ? [currentLevel] : [],
+			decorate: item =>
+				item.value === AUTO_THINKING
+					? {}
+					: { chips: [{ text: "", dot: `thinking${item.value.charAt(0).toUpperCase()}${item.value.slice(1)}` }] },
 		});
 	}
 

package/src/prompt/composer-cache.ts

@@ -3,11 +3,10 @@
  * (`~/.omp/agent/cache/composer.db`).
  *
  * Each row is one JSON payload keyed by project (the resolved cwd) and kind.
- * Settings-derived kinds (theme/composer preferences, welcome model labels,
- * status-bar inputs) are also written under the empty project, so a folder that
- * never ran omp still paints with the user's theme and status bar: those are
- * rarely project-specific, and path/branch render live. Recent sessions and LSP
- * rows stay per project.
+ * Settings-derived kinds (theme/composer preferences, status-bar inputs) are
+ * also written under the empty project, so a folder that never ran omp still
+ * paints with the user's theme and status bar: those are rarely
+ * project-specific, and path/branch render live.
  *
  * ```text
  * entries (project TEXT, kind TEXT, value TEXT JSON, PRIMARY KEY (project, kind))
@@ -25,7 +24,6 @@ import * as logger from "@oh-my-pi/pi-utils/logger";
 import * as postmortem from "@oh-my-pi/pi-utils/postmortem";
 import { openSqliteDatabaseSync } from "@oh-my-pi/pi-utils/sqlite";
 import { isRecord } from "@oh-my-pi/pi-utils/type-guards";
-import type { LspServerInfo, RecentSession } from "./welcome";
 import type { ComposerPreferences, ComposerStatusCache } from "./composer";
 import { readStatusLineStartupData } from "../status-line/startup";
 import type { SymbolPreset } from "../theme/theme";
@@ -35,7 +33,6 @@ import { isWordCompletionMethod } from "./word-completion";
 const FORMAT_VERSION = 1;
 /** Project key of rows that serve every project lacking its own. */
 const ANY_PROJECT = "";
-const RECENT_SESSION_LIMIT = 4;
 
 const SCHEMA = `
 PRAGMA journal_mode=WAL;
@@ -48,9 +45,8 @@ CREATE TABLE IF NOT EXISTS entries (
 ) WITHOUT ROWID;
 `;
 
-type EntryKind = "ui" | "welcome" | "recent-sessions" | "lsp-servers" | "status";
-/** Kinds mirrored under {@link ANY_PROJECT} as the fallback for projects without their own row. */
-type SharedEntryKind = "ui" | "welcome" | "status";
+/** Every kind is mirrored under {@link ANY_PROJECT} as the fallback for projects without their own row. */
+type EntryKind = "ui" | "status";
 
 /** Theme inputs cached from the last resolved settings load for stable prepaint colors. */
 export interface ComposerThemePreferences {
@@ -60,20 +56,10 @@ export interface ComposerThemePreferences {
 	readonly lightTheme?: string;
 }
 
-/** Last authoritative model labels shown in the welcome component. */
-export interface ComposerWelcomeCache {
-	readonly modelName: string;
-	readonly providerName: string;
-}
-
 /** Speculative composer state read before the settings/session graph is available. */
 export interface ComposerStartupCache {
 	readonly preferences?: ComposerPreferences;
 	readonly theme?: ComposerThemePreferences;
-	readonly welcome?: ComposerWelcomeCache;
-	readonly recentSessions: RecentSession[];
-	/** `null` when the last run had LSP disabled. */
-	readonly lspServers: LspServerInfo[] | null;
 	readonly status?: ComposerStatusCache;
 }
 
@@ -86,44 +72,6 @@ function parseJson(value: string | undefined): unknown {
 	}
 }
 
-function parseRecentSessions(value: unknown): RecentSession[] {
-	if (!Array.isArray(value)) return [];
-	const sessions: RecentSession[] = [];
-	for (const item of value) {
-		if (!isRecord(item)) continue;
-		const { name, timeAgo } = item;
-		if (typeof name === "string" && typeof timeAgo === "string") sessions.push({ name, timeAgo });
-		if (sessions.length === RECENT_SESSION_LIMIT) break;
-	}
-	return sessions;
-}
-
-function parseLspServers(value: unknown): LspServerInfo[] | null {
-	if (value === null) return null;
-	if (!Array.isArray(value)) return [];
-	const servers: LspServerInfo[] = [];
-	for (const item of value) {
-		if (!isRecord(item)) continue;
-		const { name, status, fileTypes } = item;
-		if (
-			typeof name !== "string" ||
-			(status !== "ready" && status !== "error" && status !== "connecting" && status !== "available") ||
-			!Array.isArray(fileTypes) ||
-			!fileTypes.every(fileType => typeof fileType === "string")
-		) {
-			continue;
-		}
-		servers.push({ name, status, fileTypes });
-	}
-	return servers;
-}
-
-function parseWelcome(value: unknown): ComposerWelcomeCache | undefined {
-	if (!isRecord(value)) return undefined;
-	const { modelName, providerName } = value;
-	return typeof modelName === "string" && typeof providerName === "string" ? { modelName, providerName } : undefined;
-}
-
 function parseStatus(value: unknown): ComposerStatusCache | undefined {
 	if (!isRecord(value)) return undefined;
 	const statusLine = readStatusLineStartupData(value.statusLine);
@@ -275,9 +223,6 @@ export class ComposerCache {
 		return {
 			preferences: ui?.preferences,
 			theme: ui?.theme,
-			welcome: parseWelcome(parseJson(own.welcome)) ?? parseWelcome(parseJson(anyProject.welcome)),
-			recentSessions: parseRecentSessions(parseJson(own["recent-sessions"])),
-			lspServers: own["lsp-servers"] === undefined ? [] : parseLspServers(parseJson(own["lsp-servers"])),
 			status: parseStatus(parseJson(own.status)) ?? parseStatus(parseJson(anyProject.status)),
 		};
 	}
@@ -287,21 +232,6 @@ export class ComposerCache {
 		this.#putShared(cwd, "ui", { preferences, theme });
 	}
 
-	/** Authoritative model/provider labels for the next welcome prepaint. */
-	writeWelcome(cwd: string, welcome: ComposerWelcomeCache): void {
-		this.#putShared(cwd, "welcome", welcome);
-	}
-
-	/** The latest recent-session rows (first four). */
-	writeRecentSessions(cwd: string, sessions: readonly RecentSession[]): void {
-		this.#put(cwd, "recent-sessions", sessions.slice(0, RECENT_SESSION_LIMIT));
-	}
-
-	/** The latest detected project LSP rows; `null` records that LSP is disabled. */
-	writeLspServers(cwd: string, servers: readonly LspServerInfo[] | null): void {
-		this.#put(cwd, "lsp-servers", servers);
-	}
-
 	/** Status-bar inputs for the next prepaint's startup status line. */
 	writeStatus(cwd: string, status: ComposerStatusCache): void {
 		this.#putShared(cwd, "status", status);
@@ -314,22 +244,11 @@ export class ComposerCache {
 		this.#db.close();
 	}
 
-	/** Best-effort upsert: a failed write only costs the next launch its speculation. */
-	#put(cwd: string, kind: EntryKind, value: unknown): void {
-		const project = path.resolve(cwd);
-		const json = JSON.stringify(value);
-		const key = `${project}\0${kind}`;
-		if (this.#known.get(key) === json) return;
-		try {
-			this.#upsert.run(project, kind, json);
-			this.#known.set(key, json);
-		} catch (error) {
-			logger.debug("composer cache write failed", { kind, error: String(error) });
-		}
-	}
-
-	/** {@link #put} for this project plus the any-project fallback row, atomically. */
-	#putShared(cwd: string, kind: SharedEntryKind, value: unknown): void {
+	/**
+	 * Best-effort upsert of this project's row plus the any-project fallback row,
+	 * atomically: a failed write only costs the next launch its speculation.
+	 */
+	#putShared(cwd: string, kind: EntryKind, value: unknown): void {
 		const project = path.resolve(cwd);
 		const json = JSON.stringify(value);
 		const ownKey = `${project}\0${kind}`;

package/src/prompt/composer.ts

@@ -22,7 +22,7 @@ import { postmortem } from "@oh-my-pi/pi-utils";
 import { CustomEditor } from "./custom-editor";
 import type { WordCompletionMethod } from "./word-completion";
 import { type AnimationFrame, TranscriptContainer } from "../chrome/transcript-container";
-import { type LspServerInfo, type RecentSession, WelcomeComponent } from "./welcome";
+import { WelcomeComponent } from "./welcome";
 import { ensureThemeSync, getEditorTheme, theme } from "../theme/theme";
 
 const DOUBLE_INTERRUPT_MS = 500;
@@ -58,11 +58,6 @@ export const COMPOSER_DEFAULTS: ComposerPreferences = {
 /** Welcome data that can be supplied initially or patched as startup resolves it. */
 export interface ComposerWelcomeUpdate {
 	readonly version?: string;
-	readonly modelName?: string;
-	readonly providerName?: string;
-	readonly recentSessions?: readonly RecentSession[];
-	/** Detected project servers; `null` means LSP is disabled and hides the welcome section. */
-	readonly lspServers?: readonly LspServerInfo[] | null;
 }
 
 /**
@@ -215,10 +210,6 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 	#preferences: ComposerPreferences;
 	#welcome: WelcomeComponent | undefined;
 	#version = "";
-	#modelName = "";
-	#providerName = "";
-	#recentSessions: RecentSession[] = [];
-	#lspServers: LspServerInfo[] | null = [];
 	#headerBefore: readonly Component[] = [];
 	#headerAfter: readonly Component[] = [];
 	#runtimeChildren: readonly Component[] = [];
@@ -279,6 +270,8 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 	#transientChrome: ReadonlySet<Component> = new Set();
 	#transientChromeFloor: number | undefined;
 	#anchorAfterInlineRetirement = false;
+	/** Rows the chrome below each below-transcript root took in the last frame (see {@link rowsBelow}). */
+	#rowsBelow = new Map<Component, number>();
 	#lastInterruptAt = 0;
 	/** Last described surface; its arrays are reused while their children are unchanged. */
 	#nativeSurface: NativeSurface = { main: [], dock: [] };
@@ -347,6 +340,27 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		this.ui.addChild(this.#statusHost);
 		this.ui.setFocus(this.editor);
 	}
+	/**
+	 * Rows the below-transcript chrome under `root` (editor, status line, …)
+	 * took in the last frame, so a root that grows upward can cap itself to
+	 * the screen rows left above them; `undefined` before `root` was laid out.
+	 */
+	rowsBelow(root: Component): number | undefined {
+		return this.#rowsBelow.get(root);
+	}
+
+	/**
+	 * Keep the input on the bottom row while the live rows cannot fill the
+	 * screen, as after an inline decision panel closes. A tall block that just
+	 * left the chrome above the editor (a command report) may have scrolled
+	 * rows into native history that cannot be pulled back; without the pin the
+	 * editor would jump up to where the shorter frame now ends. The pin lifts
+	 * once live rows fill the screen again.
+	 */
+	pinInputToBottom(): void {
+		this.#anchorAfterInlineRetirement = true;
+	}
+
 	/** Compose the bounded mutable viewport and the next ordered history append. */
 	renderFrame(viewport: ViewportSize): TerminalFramePlan {
 		if (!this.#started || this.#stopped) return { viewport: [] };
@@ -373,10 +387,12 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		let transientRows = 0;
 		let displacingRows = 0;
 		let decisionPanelOpen = false;
+		const ends: { root: Component; end: number }[] = [];
 		for (const root of afterRoots) {
 			const chrome: Component = root;
 			const start = after.length;
 			this.#renderBelowRoot(root, width, after, afterSpans);
+			ends.push({ root, end: after.length });
 			if (this.#transientChrome.has(root)) transientRows += after.length - start;
 			if (
 				chrome.retireDisplacedTranscript ||
@@ -386,6 +402,7 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 				decisionPanelOpen = true;
 			}
 		}
+		this.#rowsBelow = new Map(ends.map(({ root, end }) => [root, after.length - end]));
 		// Offer history under capacity pressure only: blocks stay live (and keep
 		// reflowing to the current width) while the screen has room. A batch
 		// leaves the mutable viewport in the same frame it is appended, so its
@@ -871,7 +888,7 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		this.ui.requestRender();
 	}
 
-	/** Patch welcome data in place as model, session, and project discovery complete. */
+	/** Patch welcome data in place as version, session, and project discovery complete. */
 	updateWelcome(update: ComposerWelcomeUpdate): void {
 		if (this.#stopped) return;
 		this.#applyWelcomeUpdate(update);
@@ -880,11 +897,6 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 		const welcome = this.#welcome;
 		if (!welcome) return;
 		if (update.version !== undefined) welcome.setVersion(this.#version);
-		if (update.modelName !== undefined || update.providerName !== undefined) {
-			welcome.setModel(this.#modelName, this.#providerName);
-		}
-		if (update.recentSessions !== undefined) welcome.setRecentSessions(this.#recentSessions);
-		if (update.lspServers !== undefined) welcome.setLspServers(this.#lspServers);
 		this.ui.requestRender();
 	}
 
@@ -965,20 +977,10 @@ export class Composer implements TerminalFrameProvider, NativeSurfaceProvider {
 
 	#applyWelcomeUpdate(update: ComposerWelcomeUpdate): void {
 		if (update.version !== undefined) this.#version = update.version;
-		if (update.modelName !== undefined) this.#modelName = update.modelName;
-		if (update.providerName !== undefined) this.#providerName = update.providerName;
-		if (update.recentSessions !== undefined) this.#recentSessions = [...update.recentSessions];
-		if (update.lspServers !== undefined) this.#lspServers = update.lspServers && [...update.lspServers];
 	}
 
 	#ensureWelcome(): void {
-		this.#welcome ??= new WelcomeComponent(
-			this.#version,
-			this.#modelName,
-			this.#providerName,
-			this.#recentSessions,
-			this.#lspServers,
-		);
+		this.#welcome ??= new WelcomeComponent(this.#version);
 	}
 
 	#rebuildHeader(): void {

package/src/prompt/custom-editor.ts

@@ -197,8 +197,14 @@ function normalizePastedPath(path: string): string {
 		try {
 			return url.fileURLToPath(unquoted);
 		} catch {
-			// Malformed file URL: drop through to the shell-unescape branch
-			// so the caller can still reject it as a non-explicit path.
+			// Windows rejects drive-less URLs (`file:///Users/…`, forwarded from a
+			// macOS pasteboard or a remote session); decode them as POSIX paths.
+			try {
+				return url.fileURLToPath(unquoted, { windows: false });
+			} catch {
+				// Malformed file URL: drop through to the shell-unescape branch
+				// so the caller can still reject it as a non-explicit path.
+			}
 		}
 	}
 	return unquoted.replace(SHELL_ESCAPED_PATH_CHAR_REGEX, "$1");

package/src/prompt/tips.txt

@@ -1,4 +1,8 @@
 Tired of typing "keep going"? Just send a '.'
+Type `#` anywhere in your prompt for quick actions — copy the line or the whole prompt, undo, jump the cursor
+Type `/` at the start of your prompt to browse every command
+Start your prompt with `!` to run it as bash — `!!` runs it without adding the output to context
+Start your prompt with `$ ` to run Python — `$$ ` runs it without adding the output to context
 You can /btw to ask a side question
 Use /tan to fork the current conversation into a background agent
 With default keybindings, {key:ctrl+d} deletes the character under the cursor instead of quitting your draft — see /hotkeys for your exit key