@oh-my-pi/pi-tui 18.4.2 → 18.4.3

package/src/components/markdown.ts

@@ -880,7 +880,10 @@ for (const table of [Lexer.rules.block.normal, Lexer.rules.block.gfm]) {
 
 const RENDER_CACHE_MAX = 256; // sane cap: ~256 distinct message × width combos
 const RENDER_CACHE_MAX_SIZE = 4 * 1024 * 1024;
-const RENDER_CACHE_MAX_ENTRY_SIZE = 256 * 1024;
+// Entry size counts the key (it embeds the whole normalized source) plus the
+// rendered rows, so this admits roughly the same documents a rows-only 256 KiB
+// cap did while the aggregate bound covers everything the entry retains.
+const RENDER_CACHE_MAX_ENTRY_SIZE = 512 * 1024;
 const EMPTY_RENDER_LINES: readonly string[] = [];
 
 interface RenderedLine {
@@ -900,7 +903,7 @@ const renderCache = new LRUCache<string, readonly string[]>({
 	max: RENDER_CACHE_MAX,
 	maxSize: RENDER_CACHE_MAX_SIZE,
 	maxEntrySize: RENDER_CACHE_MAX_ENTRY_SIZE,
-	sizeCalculation: renderedLinesCacheSize,
+	sizeCalculation: (lines, key) => renderedLinesCacheSize(lines) + key.length,
 });
 
 function renderedLinesCacheSize(lines: readonly string[]): number {
@@ -909,6 +912,15 @@ function renderedLinesCacheSize(lines: readonly string[]): number {
 	return Math.max(1, size);
 }
 
+/**
+ * Append `src` onto `dst` element-wise. `dst.push(...src)` passes every row as
+ * a call argument, which throws past the engine's argument limit on very long
+ * documents.
+ */
+function appendLines(dst: string[], src: readonly string[]): void {
+	for (let i = 0; i < src.length; i++) dst.push(src[i]!);
+}
+
 // ---------------------------------------------------------------------------
 // Fast-tail (B+) hazard gates
 // ---------------------------------------------------------------------------
@@ -1661,7 +1673,9 @@ interface RenderSignature {
 interface StreamPrefixLineCache extends RenderSignature {
 	text: string;
 	tokenCount: number;
-	lines: readonly string[];
+	// Private to the cache and never handed to callers (each frame copies it
+	// into a fresh output array), so an advancing prefix appends in place.
+	lines: string[];
 }
 /**
  * Per-token row cache for the *unfrozen tail* (PoC H). The tail re-lexes every
@@ -1717,7 +1731,9 @@ interface TailRenderRecorder {
 interface StreamingHighlightCache extends RenderSignature {
 	lang: string | undefined;
 	text: string;
-	lines: readonly string[];
+	// Appended in place as the fence grows. Only ever returned to
+	// #renderCodeBodyLines, which reads it synchronously and keeps no reference.
+	lines: string[];
 	stream: HighlightStreamSession;
 }
 
@@ -1882,10 +1898,7 @@ export class Markdown implements Component {
 			// Blank replacement: render() early-returns before #lexTokens can see
 			// the non-append edit, so drop the frozen stream state here or it
 			// outlives the content it indexed.
-			this.#streamPrefixText = undefined;
-			this.#streamPrefixTokens = undefined;
-			this.#streamPrefixLineCache = undefined;
-			this.#tailRowCache = undefined;
+			this.#dropStreamPrefix();
 			// 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;
@@ -1927,6 +1940,17 @@ export class Markdown implements Component {
 		// source — drop the fast-path recipe so stale rows cannot be served
 		// across the transition.
 		this.#fastTail = undefined;
+		if (!next) {
+			// Finalize: the prefix row cache, tail row cache and open-fence
+			// highlight stream are read only by transient renders, and each
+			// rebuilds from scratch if the block ever streams again — release
+			// them so settled blocks stop pinning rows and a native parser.
+			// The frozen lex prefix survives only until the next final-mode
+			// render consumes it (see #lexTokens / the L2 hit path).
+			this.#streamPrefixLineCache = undefined;
+			this.#tailRowCache = undefined;
+			this.#streamingHighlightCache = undefined;
+		}
 		this.invalidate();
 	}
 
@@ -1964,8 +1988,14 @@ export class Markdown implements Component {
 		// happens exactly when the CR/ref-def trigger behind a false verdict
 		// may have been deleted — never left stale, and never re-scanned on
 		// frames where the memo is sound.
+		const appendGrowth = this.#lastScanValid && this.#appendOnlySinceLastScan && text.length > this.#lastScanLength;
+		// Final mode keeps the frozen prefix only while the text keeps growing
+		// by appends (a stream rendered without the transient flag). A one-shot
+		// or just-finalized render still lexes against any existing prefix but
+		// then drops it, so settled blocks do not pin a token tree.
+		const retainPrefix = this.#transientRenderCache || appendGrowth;
 		let canStream: boolean;
-		if (this.#lastScanValid && this.#appendOnlySinceLastScan && text.length > this.#lastScanLength) {
+		if (appendGrowth) {
 			const delta = text.slice(this.#lastScanLength);
 			if (
 				!delta.includes("[") &&
@@ -1990,21 +2020,27 @@ export class Markdown implements Component {
 		if (canStream && hasPrefix) {
 			const tailTokens = lexDocument(refDefText);
 			const tokens = [...prefixTokens, ...tailTokens];
-			this.#freezeStablePrefix(text, tokens, { preserveExisting: true });
+			if (retainPrefix) this.#freezeStablePrefix(text, tokens, { preserveExisting: true });
+			else this.#dropStreamPrefix();
 			return tokens;
 		}
 		const tokens = lexDocument(text);
-		if (canStream) {
+		if (canStream && retainPrefix) {
 			this.#freezeStablePrefix(text, tokens, { preserveExisting: false });
 		} else {
-			this.#streamPrefixText = undefined;
-			this.#streamPrefixTokens = undefined;
-			this.#streamPrefixLineCache = undefined;
-			this.#tailRowCache = undefined;
+			this.#dropStreamPrefix();
 		}
 		return tokens;
 	}
 
+	/** Drop the frozen lex prefix and the transient row caches keyed on it. */
+	#dropStreamPrefix(): void {
+		this.#streamPrefixText = undefined;
+		this.#streamPrefixTokens = undefined;
+		this.#streamPrefixLineCache = undefined;
+		this.#tailRowCache = undefined;
+	}
+
 	// Freeze the largest run of leading blocks that end on a hard "\n\n" boundary
 	// (complete and immutable under append-only growth) so the next streaming
 	// render re-lexes only the unfrozen tail. Caller guarantees no CR / no
@@ -2032,12 +2068,7 @@ export class Markdown implements Component {
 			return;
 		}
 
-		if (!opts.preserveExisting) {
-			this.#streamPrefixText = undefined;
-			this.#streamPrefixTokens = undefined;
-			this.#streamPrefixLineCache = undefined;
-			this.#tailRowCache = undefined;
-		}
+		if (!opts.preserveExisting) this.#dropStreamPrefix();
 	}
 
 	render(width: number): readonly string[] {
@@ -2166,9 +2197,12 @@ export class Markdown implements Component {
 						);
 					}
 					// Splice onto the previous frame's rows (new array — parent may
-					// hold the old one).
+					// hold the old one). One copy of the head, then the few new and
+					// trailing rows, instead of spreading two intermediate slices.
 					const prev = recipe.lines;
-					const fastResult = [...prev.slice(0, recipe.rowStart), ...fastRows, ...prev.slice(recipe.rowEnd)];
+					const fastResult = prev.slice(0, recipe.rowStart);
+					appendLines(fastResult, fastRows);
+					for (let i = recipe.rowEnd; i < prev.length; i++) fastResult.push(prev[i]!);
 					this.#cachedText = this.#text;
 					this.#cachedWidth = width;
 					this.#cachedLines = fastResult;
@@ -2220,6 +2254,10 @@ export class Markdown implements Component {
 			cacheKey = this.#renderCacheKey(normalizedText, signature);
 			const cached = renderCache.get(cacheKey);
 			if (cached !== undefined) {
+				// A final-mode hit right after finalize (or a non-append edit)
+				// never reaches #lexTokens, which would otherwise consume and drop
+				// the frozen lex prefix — release it here instead.
+				if (!this.#appendOnlySinceLastScan) this.#dropStreamPrefix();
 				// Populate L1 so subsequent calls from this instance are O(1) map lookup.
 				this.#cachedText = this.#text;
 				this.#cachedWidth = width;
@@ -2241,8 +2279,10 @@ export class Markdown implements Component {
 		}
 		const emptyLines = this.#renderEmptyPaddingLines(signature);
 
-		// Combine top padding, content, and bottom padding
-		const rawResult = [...emptyLines, ...contentLines, ...emptyLines];
+		// Combine top padding, content, and bottom padding. contentLines is a
+		// fresh per-render array (never cache-owned), so without vertical
+		// padding it is handed out as-is rather than copied again.
+		const rawResult = emptyLines.length === 0 ? contentLines : [...emptyLines, ...contentLines, ...emptyLines];
 		const result = rawResult.length > 0 ? rawResult : [""];
 
 		// Update caches and hand the array out by reference. Callers must not
@@ -2329,11 +2369,15 @@ export class Markdown implements Component {
 			return this.#renderStreamingTail(tokens, 0, contentWidth, signature);
 		}
 
-		const contentLines: string[] = [];
+		// Prefix rows live in #streamPrefixLineCache.lines, which is private to
+		// the cache: an advancing prefix appends its newly frozen rows in place
+		// instead of re-snapshotting, and each frame's output is one fresh copy
+		// of prefix + tail, so no array handed to a caller is ever mutated.
 		const reusablePrefix = this.#matchingStreamPrefixLineCache(normalizedText, stableText, signature);
+		let prefixLines: string[] = [];
 		let renderedUntil = 0;
 		if (reusablePrefix && reusablePrefix.tokenCount <= stableTokenCount) {
-			contentLines.push(...reusablePrefix.lines);
+			prefixLines = reusablePrefix.lines;
 			renderedUntil = reusablePrefix.tokenCount;
 		}
 
@@ -2341,13 +2385,14 @@ export class Markdown implements Component {
 			// Stable tokens render with full fidelity (syntax highlighting on)
 			// so these cached rows byte-match the finalized render.
 			this.#renderingStablePrefix = true;
+			let frozenRows: string[];
 			try {
-				contentLines.push(
-					...this.#renderContentLines(tokens, renderedUntil, stableTokenCount, contentWidth, signature),
-				);
+				frozenRows = this.#renderContentLines(tokens, renderedUntil, stableTokenCount, contentWidth, signature);
 			} finally {
 				this.#renderingStablePrefix = false;
 			}
+			if (prefixLines.length === 0) prefixLines = frozenRows;
+			else appendLines(prefixLines, frozenRows);
 			renderedUntil = stableTokenCount;
 		}
 
@@ -2355,14 +2400,11 @@ export class Markdown implements Component {
 			...signature,
 			text: stableText,
 			tokenCount: stableTokenCount,
-			lines: contentLines.slice(),
+			lines: prefixLines,
 		};
 
-		if (renderedUntil < tokens.length) {
-			contentLines.push(...this.#renderStreamingTail(tokens, renderedUntil, contentWidth, signature));
-		}
-
-		return contentLines;
+		if (renderedUntil >= tokens.length) return prefixLines.slice();
+		return prefixLines.concat(this.#renderStreamingTail(tokens, renderedUntil, contentWidth, signature));
 	}
 
 	#matchingStreamPrefixLineCache(
@@ -2403,7 +2445,7 @@ export class Markdown implements Component {
 		if (cache !== undefined) {
 			spliceEnd = this.#tailSpliceEnd(cache, start, signature, tokens);
 			for (let i = start; i < spliceEnd; i++) {
-				out.push(...cache.rows[i - start]!);
+				appendLines(out, cache.rows[i - start]!);
 			}
 		}
 
@@ -2416,7 +2458,7 @@ export class Markdown implements Component {
 			nextTypes: new Array(tokens.length - spliceEnd).fill(undefined),
 		};
 		const fresh = this.#renderContentLines(tokens, spliceEnd, tokens.length, contentWidth, signature, recorder);
-		out.push(...fresh);
+		const result = out.length === 0 ? fresh : out.concat(fresh);
 
 		// Refresh the cache: keep entries for spliced tokens (their raws stay
 		// valid), overlay the fresh entries, and re-derive the contiguous
@@ -2453,7 +2495,7 @@ export class Markdown implements Component {
 			raws,
 			nextTypes,
 		};
-		return out;
+		return result;
 	}
 
 	// Longest cache-spliceable prefix: every cached row from `start` up to
@@ -2658,7 +2700,7 @@ export class Markdown implements Component {
 			// colors reach completed rows immediately; only the trailing partial
 			// line stays unhighlighted.
 			const lineEnd = tokenText.lastIndexOf("\n");
-			const completedLines = lineEnd >= 0 ? this.#highlightStreamingLines(tokenText.slice(0, lineEnd), lang) : null;
+			const completedLines = lineEnd >= 0 ? this.#highlightStreamingLines(tokenText, lineEnd, lang) : null;
 			if (completedLines) {
 				for (const hlLine of completedLines) {
 					addBodyLine(hlLine);
@@ -2708,21 +2750,28 @@ export class Markdown implements Component {
 	}
 
 	/**
-	 * Highlight the completed (newline-terminated) prefix of a streaming code
-	 * fence. Uses a stateful per-fence highlight stream so each render pushes
-	 * only the newly completed lines, with output byte-identical to the
-	 * whole-block `highlightCode` the finalized render performs. Returns null
-	 * when no stream is available for `lang` (caller falls back to plain
-	 * code-block styling).
+	 * Highlight the completed (newline-terminated) prefix `tokenText[0,
+	 * completedEnd)` of a streaming code fence. Uses a stateful per-fence
+	 * highlight stream so each render pushes only the newly completed lines,
+	 * with output byte-identical to the whole-block `highlightCode` the
+	 * finalized render performs. Returns null when no stream is available for
+	 * `lang` (caller falls back to plain code-block styling).
 	 */
-	#highlightStreamingLines(completedText: string, lang: string | undefined): readonly string[] | null {
+	#highlightStreamingLines(
+		tokenText: string,
+		completedEnd: number,
+		lang: string | undefined,
+	): readonly string[] | null {
 		const signature = this.#activeRenderSignature;
 		const cache = this.#streamingHighlightCache;
+		// Cheap cursor/length and signature gates first; the prefix compare
+		// (the only O(fence) check, needed because a different fence can reach
+		// this cache) runs last.
 		if (
 			signature &&
 			cache &&
-			completedText.startsWith(cache.text) &&
-			(cache.text.length === completedText.length || completedText.charCodeAt(cache.text.length) === 0x0a) &&
+			cache.text.length <= completedEnd &&
+			(cache.text.length === completedEnd || tokenText.charCodeAt(cache.text.length) === 0x0a) &&
 			cache.lang === lang &&
 			cache.width === signature.width &&
 			cache.paddingX === signature.paddingX &&
@@ -2734,18 +2783,23 @@ export class Markdown implements Component {
 			cache.hyperlinks === signature.hyperlinks &&
 			cache.textSizing === signature.textSizing &&
 			cache.bgColorProbe === signature.bgColorProbe &&
-			cache.headingProbe === signature.headingProbe
+			cache.headingProbe === signature.headingProbe &&
+			tokenText.startsWith(cache.text)
 		) {
-			if (completedText.length === cache.text.length) return cache.lines;
+			const cachedEnd = cache.text.length;
+			if (cachedEnd === completedEnd) return cache.lines;
 			// Invariant: the stream has consumed `cache.text + "\n"`, so pushing
 			// the added lines with a trailing newline advances it to
-			// `completedText + "\n"` — every fed line stays newline-terminated.
-			const addedText = completedText.slice(cache.text.length + 1);
-			const lines = cache.lines.concat(splitPushedHighlightLines(cache.stream.push(`${addedText}\n`)));
-			this.#streamingHighlightCache = { ...signature, lang, text: completedText, lines, stream: cache.stream };
-			return lines;
+			// `completed + "\n"` — every fed line stays newline-terminated. The
+			// signature gates above matched, so advancing the cache in place is
+			// equivalent to rebuilding it, minus the whole-array copy per frame.
+			const pushed = cache.stream.push(`${tokenText.slice(cachedEnd + 1, completedEnd)}\n`);
+			appendLines(cache.lines, splitPushedHighlightLines(pushed));
+			cache.text = tokenText.slice(0, completedEnd);
+			return cache.lines;
 		}
 
+		const completedText = tokenText.slice(0, completedEnd);
 		const stream = this.#createHighlightStream(lang);
 		if (!stream) return null;
 		const lines = splitPushedHighlightLines(stream.push(`${completedText}\n`));

package/src/loop-watchdog.ts

@@ -64,6 +64,8 @@ export class LoopWatchdog {
 	#expected = 0;
 	#expectedCpu = 0;
 	#wasBlocked = false;
+	// When the most recent late tick ran — the moment a detected block ended.
+	#stallEndedAt = Number.NEGATIVE_INFINITY;
 	#running = false;
 	// Bumped by stop(); each scheduled tick captures the generation it was armed
 	// under and no-ops if it no longer matches, so a start()→stop()→start() cycle
@@ -94,17 +96,40 @@ export class LoopWatchdog {
 		if (this.#running) return;
 		this.#running = true;
 		this.#wasBlocked = false;
+		this.#stallEndedAt = Number.NEGATIVE_INFINITY;
 		this.#armTick();
 	}
 
 	stop(): void {
 		this.#running = false;
 		this.#wasBlocked = false;
+		this.#stallEndedAt = Number.NEGATIVE_INFINITY;
 		this.#generation++;
 		this.#handle?.cancel?.();
 		this.#handle = undefined;
 	}
 
+	/**
+	 * Whether the loop is blocked right now — the armed tick is already more
+	 * than `thresholdMs` overdue — or a detected block ended within the last
+	 * `thresholdMs`. Input read at such a moment may be keystrokes the block
+	 * batched into one read. Resolves both orders in which a resumed loop can
+	 * run the late tick and the queued stdin read. A suspended-process gap is
+	 * not a stall, and a stopped watchdog never reports one.
+	 */
+	isStalled(): boolean {
+		if (!this.#running) return false;
+		const now = this.#now();
+		if (now - this.#stallEndedAt <= this.#thresholdMs) return true;
+		const overdueMs = now - this.#expected;
+		return overdueMs > this.#thresholdMs && !this.#isSuspension(overdueMs, this.#cpuNow() - this.#expectedCpu);
+	}
+
+	/** A long gap the process spent negligible CPU on: it was suspended, not blocked. */
+	#isSuspension(blockedMs: number, cpuMs: number): boolean {
+		return blockedMs > this.#sleepMs && cpuMs < blockedMs * CPU_BUSY_RATIO;
+	}
+
 	#armTick(): void {
 		const generation = this.#generation;
 		this.#expected = this.#now() + this.#intervalMs;
@@ -115,23 +140,26 @@ export class LoopWatchdog {
 
 	#tick(generation: number): void {
 		if (!this.#running || generation !== this.#generation) return;
-		const blockedMs = this.#now() - this.#expected;
+		const now = this.#now();
+		const blockedMs = now - this.#expected;
 		const cpuMs = this.#cpuNow() - this.#expectedCpu;
 		// Consume the recent phase every tick (block or not) so attribution is
 		// scoped to the just-elapsed interval and never carries a stale phase
 		// forward to a later, phase-less block.
 		const phase = takeRecentLoopPhase();
 		if (blockedMs > this.#thresholdMs) {
-			if (blockedMs > this.#sleepMs && cpuMs < blockedMs * CPU_BUSY_RATIO) {
-				// A long gap the process did not spend CPU on: it was suspended.
+			if (this.#isSuspension(blockedMs, cpuMs)) {
 				this.#wasBlocked = false;
-			} else if (!this.#wasBlocked) {
-				this.#wasBlocked = true;
-				logger.warn("ui.loop-blocked", {
-					blockedMs: Math.round(blockedMs),
-					cpuMs: Math.round(cpuMs),
-					phase: phase ?? "unknown",
-				});
+			} else {
+				this.#stallEndedAt = now;
+				if (!this.#wasBlocked) {
+					this.#wasBlocked = true;
+					logger.warn("ui.loop-blocked", {
+						blockedMs: Math.round(blockedMs),
+						cpuMs: Math.round(cpuMs),
+						phase: phase ?? "unknown",
+					});
+				}
 			}
 		} else {
 			this.#wasBlocked = false;

package/src/overlays/model-picker.ts

@@ -28,7 +28,8 @@ export interface ResolvedRoleModel {
 
 /** Catalog refresh capability used by the session picker. */
 export interface ModelPickerRegistry extends ModelBrowserRegistry {
-	refresh(strategy: "offline"): Promise<void>;
+	/** Bring the catalog up to date without rebuilding a current one; `true` when the picker must re-read it. */
+	refreshIfStale(): Promise<boolean>;
 }
 
 export interface ModelPickerCallbacks {
@@ -172,13 +173,15 @@ export class ModelPickerComponent implements Component {
 			this.#browser.selectSelector(options.currentSelector);
 		}
 
-		// Reconcile with cached discovery state in the background. A --models
-		// scope is registry-independent, so the offline reload would only repeat
-		// the synchronous hydration above.
+		// Re-read only if the catalog moves (startup discovery landing, a
+		// models.yml edit): rebuilding a current catalog on every open blocks
+		// the first paint for seconds. A --models scope is registry-independent.
 		if (this.#scopedModels.length === 0) {
 			this.#registry
-				.refresh("offline")
-				.then(() => this.#syncFromRegistryState())
+				.refreshIfStale()
+				.then(changed => {
+					if (changed) this.#syncFromRegistryState();
+				})
 				.catch(error => {
 					this.#configError = error instanceof Error ? error.message : String(error);
 				})

package/src/overlays/settings-selector.ts

@@ -1139,15 +1139,7 @@ export class SettingsSelectorComponent implements Component {
 		return entries.map(([provider, limit]) => `${provider}: ${limit}`).join(", ");
 	}
 
-	#getMultiSelectOptions(def: SettingDef & { type: "multiselect" }) {
-		if (def.path !== "providers.webSearchOrder") return def.options;
-		const excluded: unknown = this.#context.settings.get("providers.webSearchExclude");
-		if (!Array.isArray(excluded)) return def.options;
-		return def.options.filter(option => !excluded.includes(option.value));
-	}
-
 	#createMultiSelect(def: SettingDef & { type: "multiselect" }, done: (value?: string) => void): Container {
-		const options = this.#getMultiSelectOptions(def);
 		const current: unknown = this.#context.settings.get(def.path);
 		const initial = Array.isArray(current)
 			? current.filter((entry): entry is string => typeof entry === "string")
@@ -1155,7 +1147,7 @@ export class SettingsSelectorComponent implements Component {
 		return new MultiSelectSubmenu(
 			def.label,
 			def.description,
-			options,
+			def.options,
 			initial,
 			def.ordered,
 			value => {
@@ -1167,7 +1159,7 @@ export class SettingsSelectorComponent implements Component {
 	}
 
 	#formatMultiSelectValue(def: SettingDef & { type: "multiselect" }, value: unknown): string {
-		const options = this.#getMultiSelectOptions(def);
+		const { options } = def;
 		const labels = Array.isArray(value)
 			? value.flatMap(entry => {
 					if (typeof entry !== "string") return [];

package/src/setup/scenes/sign-in.ts

@@ -14,7 +14,7 @@ import { wrapTextWithAnsi } from "../../utils";
 import { getAgentDbPath } from "@oh-my-pi/pi-utils";
 import { OAuthSelectorComponent } from "../../overlays/oauth-selector";
 import { theme } from "../../theme/theme";
-import type { SetupSceneHost, SetupTab } from "./types";
+import type { SetupScene, SetupSceneController, SetupSceneHost } from "./types";
 
 function loginUrlLink(url: string): string {
 	return `\x1b]8;;${url}\x07Open login URL\x1b]8;;\x07`;
@@ -69,13 +69,15 @@ interface PromptState {
 }
 
 /**
- * "Sign in" panel: lets the user authenticate one or more model providers via
- * OAuth. Unlike a standalone scene it never auto-advances the wizard — the user
- * may sign in to several providers and then continue with Esc.
+ * "Sign in" scene: lets the user authenticate one or more model providers via
+ * OAuth. It never auto-advances the wizard — the user may sign in to several
+ * providers and then continue with Esc.
  */
-export class SignInTab implements SetupTab {
-	readonly id = "sign-in";
-	readonly label = "Sign in";
+export class SignInScene implements SetupSceneController {
+	readonly title = "Sign in to your providers";
+	get subtitle(): string {
+		return `Sign in to one or more providers. Press ${editorKey("tui.select.cancel")} when you're done.`;
+	}
 
 	#authStorage: AuthStorage;
 	#selector: OAuthSelectorComponent;
@@ -99,11 +101,6 @@ export class SignInTab implements SetupTab {
 		this.#selector = this.#createSelector();
 	}
 
-	/** Modal while an OAuth flow is running so the scene won't switch tabs or finish. */
-	get modal(): boolean {
-		return this.#loggingInProvider !== undefined;
-	}
-
 	dispose(): void {
 		this.#disposed = true;
 		this.#selector.stopValidation();
@@ -373,3 +370,11 @@ export class SignInTab implements SetupTab {
 		this.#host.requestRender();
 	}
 }
+
+/** Onboarding scene for provider sign-in. */
+export const providersSetupScene: SetupScene = {
+	id: "providers",
+	title: "Sign in to your providers",
+	minVersion: 1,
+	mount: host => new SignInScene(host),
+};

package/src/setup/scenes/types.ts

@@ -5,7 +5,6 @@ import type { ComposerPreviewStatusSource } from "../../overlays/composer-shape-
 import type { ComposerShape } from "../../overlays/composer-shape-registry";
 import type { ModelBrowserSource } from "../../overlays/model-browser";
 import type { SymbolPreset } from "../../theme/theme";
-import type { SearchProviderId } from "../../tools/web-search";
 import type { Component, TUI } from "../../tui";
 
 /** Terminal capabilities used by setup overlays and the startup splash. */
@@ -21,7 +20,6 @@ export interface SetupHost extends SetupUiHost {
 	readonly composerShape: ComposerShape;
 	readonly symbolPreset: SymbolPreset;
 	readonly colorBlindMode: boolean;
-	readonly webSearchOrder: readonly string[];
 	readonly disabledProviders: readonly string[];
 	readonly authStorage: AuthStorage;
 	readonly modelSource: ModelBrowserSource;
@@ -33,8 +31,6 @@ export interface SetupHost extends SetupUiHost {
 	saveSymbolPreset(preset: SymbolPreset): void;
 	saveColorBlindMode(enabled: boolean): void;
 	saveTheme(mode: "dark" | "light", name: string): void;
-	isSearchProviderAvailable(id: SearchProviderId): Promise<boolean>;
-	saveSearchProvider(id: SearchProviderId | "auto"): void;
 	captureBrowserSession(request: OAuthBrowserSessionRequest, signal?: AbortSignal): Promise<string>;
 	copyToClipboard(text: string): Promise<void>;
 	openInBrowser(url: string): void;
@@ -78,29 +74,6 @@ export interface SetupSceneController extends Component {
 	routeMouse?(event: SgrMouseEvent, line: number, col: number): void;
 }
 
-/**
- * A single panel inside a tabbed setup scene. The host scene owns the tab bar
- * and forwards rendering/input to the active tab.
- */
-export interface SetupTab {
-	readonly id: string;
-	readonly label: string;
-	/**
-	 * While `true` the tab owns all keyboard input (e.g. an in-progress OAuth
-	 * login). The parent scene MUST NOT switch tabs or finish while modal.
-	 */
-	readonly modal: boolean;
-	/** See {@link SetupSceneController.render}: `maxLines` is the tab-local row budget. */
-	render(width: number, maxLines?: number): readonly string[];
-	handleInput(data: string): void;
-	invalidate(): void;
-	/** Called when the tab becomes active (including initial mount). */
-	onActivate?(): void;
-	/** Mouse routing at tab-local coordinates; see {@link SetupSceneController.routeMouse}. */
-	routeMouse?(event: SgrMouseEvent, line: number, col: number): void;
-	dispose(): void;
-}
-
 /** Versioned onboarding scene definition. */
 export interface SetupScene {
 	id: string;

package/src/setup/wizard.ts

@@ -3,7 +3,7 @@ import type { SetupHost } from "./scenes/types";
 import { composerSetupScene } from "./scenes/composer";
 import { glyphSetupScene } from "./scenes/glyph";
 import { modelSetupScene } from "./scenes/model";
-import { providersSetupScene } from "./scenes/providers";
+import { providersSetupScene } from "./scenes/sign-in";
 import { themeSetupScene } from "./scenes/theme";
 import type { SetupScene } from "./scenes/types";
 import { SetupWizardComponent } from "./wizard-overlay";