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

package/src/native/node.ts

@@ -29,10 +29,12 @@ export type NativeNode = {
 		 */
 		readonly key?: string;
 		/**
-		 * Scroll the node into view, placed like the `reveal` op, when it is
-		 * added. Key a node by what it points at to reveal it again on a move.
+		 * Scroll the node into view, placed like the `reveal` op. A placement
+		 * reveals it when it is added: key a node by what it points at to
+		 * reveal it again on a move. A {@link NativeReveal} reveals it whenever
+		 * its `n` differs from the previous description of the same node.
 		 */
-		readonly reveal?: "start" | "end" | "nearest";
+		readonly reveal?: NativeRevealAt | NativeReveal;
 		/**
 		 * Keyboard scrolling forwarded to the terminal (PgUp/PgDn/End reach the
 		 * program): moves the scroller at or above the node by `by` whenever
@@ -44,6 +46,19 @@ export type NativeNode = {
 	};
 }[TspKind];
 
+/** Where a revealed node lands in its scroller. */
+export type NativeRevealAt = "start" | "end" | "nearest";
+
+/**
+ * A repeatable {@link NativeNode.reveal}: bump `n` to bring an existing node
+ * into view again (a Contents entry jumping to its section). A freshly added
+ * node is not revealed.
+ */
+export interface NativeReveal {
+	readonly at: NativeRevealAt;
+	readonly n: number;
+}
+
 /** A {@link NativeNode.scroll} request. */
 export interface NativeScroll {
 	readonly by: TspScrollBy;
@@ -113,7 +128,9 @@ export type NativeUiEvent =
 			readonly value: boolean | number | string | readonly string[] | null;
 	  }
 	/** An edit over the terminal's own selection in an `editor`/`input` node (see {@link NativeTextEdit}). */
-	| ({ readonly type: "edit"; readonly key: string } & NativeTextEdit);
+	| ({ readonly type: "edit"; readonly key: string } & NativeTextEdit)
+	/** Undo the last change to an `editor`/`input` node's text (the terminal's ⌃Z); a no-op with no history. */
+	| { readonly type: "undo"; readonly key: string };
 
 /**
  * A primitive edit the terminal made over its own text selection (cut,

package/src/native/reconcile.ts

@@ -31,7 +31,7 @@ import * as logger from "@oh-my-pi/pi-utils/logger";
 import { TSP_TEXT_KINDS, type TspKind, type TspNode, type TspOp, type TspScrollBy } from "@oh-my-pi/pi-wire";
 import { type Component, Container, CURSOR_MARKER } from "../tui";
 import { normalizeIconProps } from "./icons";
-import type { DescribeContext, NativeChild, NativeNode } from "./node";
+import type { DescribeContext, NativeChild, NativeNode, NativeRevealAt } from "./node";
 import { isNativeSettled } from "./settle";
 
 /** The regions a frame fills. */
@@ -213,8 +213,11 @@ export class Reconciler {
 	#ops: TspOp[] = [];
 	#dels: Entry[] = [];
 	#settles: string[] = [];
-	/** Selected list items and added `reveal` nodes sent this frame, revealed once the frame's adds have landed. */
-	#reveals: [id: string, at: "start" | "end" | "nearest"][] = [];
+	/**
+	 * Selected list items, added `reveal` nodes and nodes whose reveal `n` moved this frame,
+	 * revealed once the frame's adds have landed.
+	 */
+	#reveals: [id: string, at: NativeRevealAt][] = [];
 	/** `scroll` requests whose `n` moved this frame, sent after the reveals. */
 	#scrolls: [id: string, by: TspScrollBy][] = [];
 	/** Wire ids `list.selected` keys resolved to (an unresolved key names no node to reveal). */
@@ -595,6 +598,11 @@ export class Reconciler {
 			this.#revisitNode(next, inner);
 			return;
 		}
+		const reveal = next.node.reveal;
+		if (typeof reveal === "object") {
+			const was = old.node.reveal;
+			if (reveal.n !== (typeof was === "object" ? was.n : undefined)) this.#reveals.push([next.id, reveal.at]);
+		}
 		if (old.node.k !== next.node.k) {
 			this.#dropSubtree(old);
 			this.#ops.push(["del", next.id]);
@@ -743,7 +751,7 @@ export class Reconciler {
 
 	/** A full wire subtree for an entry; nested components get states (or pending moves when mounted elsewhere). */
 	#materialize(entry: NodeEntry, walk: Walk): TspNode {
-		if (entry.node.reveal) this.#reveals.push([entry.id, entry.node.reveal]);
+		if (typeof entry.node.reveal === "string") this.#reveals.push([entry.id, entry.node.reveal]);
 		const entries = this.#entries(entry.node.c, entry.keypath, entry.owner, entry.hoist, walk);
 		const children: TspNode[] = [];
 		for (let i = 0; i < entries.length; i++) {

package/src/overlays/jobs-panel.ts

@@ -1,14 +1,13 @@
 /**
- * The async background jobs of a session, twice: {@link JobsPanel} is the
- * `/jobs` transcript block (ANSI keeps the caller's text report; natively one
- * frame), {@link JobsSheet} the dismissable sheet the native jobs pill opens.
- * The panel draws task jobs as `agent` nodes and the others as a status dot,
- * the one-line label and a live `elapsed`; the sheet lists every job and
- * inspects the selected one (command, cwd, live pids, exit code, output tail).
+ * The async background jobs of a session as {@link JobsSheet}: the dismissable
+ * sheet the native jobs pill and `/jobs` open. It draws task jobs as `agent`
+ * nodes and the others as a status dot, the one-line label and a live
+ * `elapsed`, lists every job and inspects the selected one (command, cwd, live
+ * pids, exit code, output tail).
  */
 import type { TspAgentProps, TspSpan } from "@oh-my-pi/pi-wire";
 import { formatDuration } from "@oh-my-pi/pi-utils";
-import { type Component, Container } from "../tui";
+import type { Component } from "../tui";
 import { matchesSelectCancel, matchesSelectDown, matchesSelectUp } from "../keybinding-matchers";
 import { matchesKey } from "../keys";
 import { truncateToWidth } from "../utils";
@@ -92,31 +91,6 @@ const DOT: Record<JobsPanelJob["status"], TspSpan> = {
 /** Output tail rows the terminal fallback shows under the selected job. */
 const FALLBACK_TAIL_LINES = 8;
 
-/** The `/jobs` block: `ansi` renders in the terminal, the snapshot describes the native frame. */
-export class JobsPanel extends Container {
-	readonly #snapshot: JobsPanelSnapshot;
-	readonly #nowMs: number;
-	#native: { agent: boolean; node: NativeNode } | undefined;
-
-	constructor(snapshot: JobsPanelSnapshot, nowMs: number, ansi: readonly Component[]) {
-		super();
-		this.#snapshot = snapshot;
-		this.#nowMs = nowMs;
-		for (const child of ansi) this.addChild(child);
-	}
-
-	override describe(cx: DescribeContext): NativeNode {
-		const agent = cx.supports("agent");
-		if (this.#native?.agent === agent) return this.#native.node;
-		const head: TspSpan[] = [span("Background jobs", "strong")];
-		const running = this.#snapshot.running.length;
-		if (running > 0) head.push(span(` · ${running} running`, "muted"));
-		const described = card({ role: "omp.jobs", head }, describeJobs(this.#snapshot, this.#nowMs, agent));
-		this.#native = { agent, node: described };
-		return described;
-	}
-}
-
 /**
  * The jobs pill's sheet: a centred `lg` glass sheet titled Background jobs.
  * A selectable list of every job (running first) sits over the selected
@@ -254,27 +228,6 @@ function jobAge(job: JobsPanelJob, nowMs: number): number {
 	return Math.max(0, (job.endTime ?? nowMs) - job.startTime);
 }
 
-/** The body the `/jobs` panel draws: running rows, then a Recent section; an empty note when there are none. */
-function describeJobs(snapshot: JobsPanelSnapshot, nowMs: number, agent: boolean): NativeChild[] {
-	const { running, recent } = snapshot;
-	const children: NativeChild[] = [];
-	if (running.length === 0 && recent.length === 0) {
-		children.push(node("text", { text: "No background jobs", role: "omp.jobs.empty" }, undefined, "empty"));
-	}
-	for (const job of running) children.push(describeJob(job, nowMs, agent));
-	if (recent.length > 0) {
-		children.push(
-			node(
-				"section",
-				{ head: [span("Recent", "muted")] },
-				recent.map(job => describeJob(job, nowMs, agent)),
-				"recent",
-			),
-		);
-	}
-	return children;
-}
-
 /** A task job as an `agent` node when the terminal draws them, else a one-line dot row. */
 function describeJob(job: JobsPanelJob, nowMs: number, agent: boolean): NativeNode {
 	const settled = job.status !== "running";

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}`;