@oh-my-pi/pi-tui 18.3.0 → 18.3.1

package/src/prompt/custom-editor.ts

@@ -5,6 +5,7 @@ import { BRACKETED_PASTE_END, BRACKETED_PASTE_START } from "../stdin-buffer";
 import { Editor, type EditorTextDecorationContext, type EditorTheme } from "../components/editor";
 import { addKeyAliases, canonicalKeyId, getKeybindings } from "../keybindings";
 import { type KeyId, parseKey, parseKittySequence } from "../keys";
+import { SpaceHoldGesture } from "../space-hold";
 import { TUI } from "../tui";
 import type { AppKeybinding } from "../app-keybindings";
 import { allowsModelMentions, allowsSkillTokens, SKILL_TOKEN_RE } from "./skill-tokens";
@@ -117,34 +118,6 @@ const ABSOLUTE_PATH_PREFIX_REGEX = new RegExp(`^${ABSOLUTE_PATH_PREFIX_SOURCE}`)
  */
 const INTERIOR_PATH_ANCHOR_REGEX = new RegExp(String.raw`(?<!\\)\s(?:${ABSOLUTE_PATH_PREFIX_SOURCE}|\.\.?[\\/])`);
 
-/** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
- *  deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
-export const SPACE_REPEAT_MAX_GAP_MS = 120;
-/** Two consecutive inter-space gaps are "mechanical" (machine-driven auto-repeat) when both are
- *  within {@link SPACE_REPEAT_MAX_GAP_MS} and differ by no more than this — an absolute jitter floor
- *  or, for slower repeat rates, {@link SPACE_REPEAT_JITTER_RATIO} of the smaller gap. OS key-repeat
- *  is metronomic; a human smashing the bar is fast but irregular, so its deltas never stay this
- *  steady. */
-export const SPACE_REPEAT_JITTER_MS = 18;
-export const SPACE_REPEAT_JITTER_RATIO = 0.35;
-/** Consecutive mechanical (fast + steady) deltas that confirm the space bar is held and start
- *  recording. Needs a sustained metronomic cadence, so jittery smashing and deliberate taps never
- *  reach it. */
-export const SPACE_HOLD_MECHANICAL_RUN = 2;
-/** Idle gap (ms) after the last repeated space that counts as the space bar being released, ending
- *  the push-to-talk recording. Must comfortably exceed the OS key-repeat interval. */
-export const SPACE_HOLD_RELEASE_MS = 250;
-
-/** Whether two consecutive inter-space gaps look machine-driven: both within the auto-repeat band
- *  and steady enough (small absolute or proportional difference). OS key-repeat is metronomic, so
- *  its successive deltas match closely; human smashing is fast but irregular and deliberate taps are
- *  too slow, so neither passes. */
-function gapsAreMechanical(gap: number, prevGap: number): boolean {
-	if (gap > SPACE_REPEAT_MAX_GAP_MS || prevGap > SPACE_REPEAT_MAX_GAP_MS) return false;
-	const tolerance = Math.max(SPACE_REPEAT_JITTER_MS, Math.min(gap, prevGap) * SPACE_REPEAT_JITTER_RATIO);
-	return Math.abs(gap - prevGap) <= tolerance;
-}
-
 function isPastedPathSeparator(char: string | undefined): boolean {
 	return char === undefined || char === " " || char === "\t" || char === "\r" || char === "\n";
 }
@@ -902,15 +875,13 @@ export class CustomEditor extends Editor {
 	/** Called when left-arrow is pressed while the editor is empty (cursor necessarily at start). */
 	onLeftAtStart?: () => void;
 
-	/** Fired when a sustained space-bar hold is recognized — the push-to-talk STT start. The
-	 *  optimistically-typed spaces have already been deleted by the time this runs. */
-	onSpaceHoldStart?: () => void;
-	/** Fired when the held space bar is released (detected as an idle gap with no further repeated
-	 *  spaces) — the push-to-talk STT stop. */
-	onSpaceHoldEnd?: () => void;
-	/** Gate for the space-hold gesture. Returns false to keep the space bar inserting spaces
-	 *  normally; wired to `stt.enabled` so disabling STT restores plain space behavior. */
-	sttHoldEnabled?: () => boolean;
+	/** Space-bar push-to-talk; set its `handler` to enable it. It is a text-composition gesture, so it
+	 *  stays out of Vim's Normal/Visual modes (where the space bar is the `l` motion) and away from an
+	 *  open autocomplete menu. */
+	readonly spaceHold = new SpaceHoldGesture(
+		count => this.deleteBeforeCursor(count),
+		() => this.vimMode === "insert" && !this.isShowingAutocomplete(),
+	);
 
 	/** Custom key handlers from extensions and non-built-in app actions. */
 	#customKeyHandlers = new Map<KeyId, () => void>();
@@ -928,18 +899,6 @@ export class CustomEditor extends Editor {
 	/** Input chunks deferred behind an in-flight paste, drained in FIFO order once the paste
 	 *  count returns to zero. */
 	#pendingInput: string[] = [];
-	/** Spaces actually inserted in the current run; tracked back out when a hold is recognized. */
-	#spaceRunInserted = 0;
-	/** Consecutive "mechanical" deltas (fast + steady); a sustained run of these confirms a held bar. */
-	#mechanicalRun = 0;
-	/** Inter-space gap (ms) of the previous space pair, compared against the next to judge steadiness. */
-	#prevSpaceGap: number | undefined;
-	/** Monotonic timestamp (ms) of the last space, to measure the gap to the next one. */
-	#lastSpaceAt = Number.NEGATIVE_INFINITY;
-	/** True while a recognized space-hold push-to-talk recording is in progress. */
-	#spaceHoldActive = false;
-	/** Idle timer that fires `onSpaceHoldEnd` once repeated spaces stop arriving. */
-	#spaceHoldTimer: NodeJS.Timeout | undefined;
 	#actionKeys = new Map<ConfigurableEditorAction, KeyId[]>(
 		Object.entries(DEFAULT_ACTION_KEYS).map(([action, keys]) => [action as ConfigurableEditorAction, [...keys]]),
 	);
@@ -1004,93 +963,6 @@ export class CustomEditor extends Editor {
 		this.#rebuildCustomMatchKeys();
 	}
 
-	#spaceHoldGestureEnabled(): boolean {
-		// Push-to-talk is a text-composition gesture, so it stays out of Vim's Normal/Visual modes
-		// where the space bar is the `l` motion.
-		if (this.vimMode !== "insert") return false;
-		return this.onSpaceHoldStart !== undefined && (this.sttHoldEnabled?.() ?? false) && !this.isShowingAutocomplete();
-	}
-
-	/** Drive the space-hold push-to-talk state machine. Returns true when the gesture consumed the
-	 *  input so it must not reach normal editing. A held space bar emits OS auto-repeat: a *steady*
-	 *  stream of spaces at a fixed fast interval. We watch the inter-space deltas and only recognize a
-	 *  hold once {@link SPACE_HOLD_MECHANICAL_RUN} consecutive deltas are "mechanical" — both
-	 *  auto-repeat-fast and near-identical (see {@link gapsAreMechanical}). Smashing the bar is fast
-	 *  but jittery and deliberate taps are too slow, so neither escalates and both keep typing real
-	 *  spaces; the few spaces typed before a real hold is recognized are tracked back out. */
-	#handleSpaceHold(data: string, canonical: string | undefined): boolean {
-		const isSpace = canonical === "space";
-		if (this.#spaceHoldActive) {
-			if (isSpace) {
-				// Auto-repeat while held: swallow it and keep the release timer alive.
-				this.#armSpaceHoldReleaseTimer();
-				return true;
-			}
-			// Any non-space means the bar was released — stop recording, then let the key through.
-			this.#endSpaceHold();
-			return false;
-		}
-		if (!isSpace) {
-			this.#resetSpaceRun();
-			return false;
-		}
-		if (!this.#spaceHoldGestureEnabled()) return false;
-		const now = performance.now();
-		const gap = now - this.#lastSpaceAt;
-		const prevGap = this.#prevSpaceGap;
-		this.#lastSpaceAt = now;
-		this.#prevSpaceGap = gap;
-		if (prevGap === undefined || !gapsAreMechanical(gap, prevGap)) {
-			// First space, a deliberate tap, or jittery smashing: not a steady machine cadence yet, so
-			// type a real space and reset the mechanical run.
-			this.#mechanicalRun = 0;
-			this.#forwardInput(data);
-			this.#spaceRunInserted++;
-			return true;
-		}
-		// Steady fast repeat: swallow it. Once the cadence has held for SPACE_HOLD_MECHANICAL_RUN
-		// deltas it's a held bar — track back the few pre-burst spaces already typed and start.
-		if (++this.#mechanicalRun >= SPACE_HOLD_MECHANICAL_RUN) {
-			this.deleteBeforeCursor(this.#spaceRunInserted);
-			this.#resetSpaceRun();
-			this.#beginSpaceHold();
-		}
-		return true;
-	}
-
-	#resetSpaceRun(): void {
-		this.#spaceRunInserted = 0;
-		this.#mechanicalRun = 0;
-		this.#prevSpaceGap = undefined;
-		this.#lastSpaceAt = Number.NEGATIVE_INFINITY;
-	}
-
-	#beginSpaceHold(): void {
-		this.#spaceHoldActive = true;
-		this.#armSpaceHoldReleaseTimer();
-		this.onSpaceHoldStart?.();
-	}
-
-	#armSpaceHoldReleaseTimer(): void {
-		if (this.#spaceHoldTimer) clearTimeout(this.#spaceHoldTimer);
-		this.#spaceHoldTimer = setTimeout(() => {
-			this.#spaceHoldTimer = undefined;
-			this.#endSpaceHold();
-		}, SPACE_HOLD_RELEASE_MS);
-		this.#spaceHoldTimer.unref?.();
-	}
-
-	#endSpaceHold(): void {
-		if (!this.#spaceHoldActive) return;
-		this.#spaceHoldActive = false;
-		this.#resetSpaceRun();
-		if (this.#spaceHoldTimer) {
-			clearTimeout(this.#spaceHoldTimer);
-			this.#spaceHoldTimer = undefined;
-		}
-		this.onSpaceHoldEnd?.();
-	}
-
 	/** Decrement {@link #pasteInFlight} once an async paste settles and, when the count returns
 	 *  to zero, drain {@link #pendingInput} through `handleInput` so requeueing still works if a
 	 *  drained chunk triggers another async paste. Bound member so it can be passed straight to
@@ -1188,7 +1060,13 @@ export class CustomEditor extends Editor {
 		}
 
 		// Space-hold push-to-talk: a sustained space bar starts/stops STT instead of typing spaces.
-		if (this.#handleSpaceHold(data, canonical)) return;
+		switch (this.spaceHold.process(canonical === "space")) {
+			case "type":
+				this.#forwardInput(data);
+				return;
+			case "swallow":
+				return;
+		}
 
 		// One union probe decides whether any per-action interception below can
 		// match — plain typing then skips the ~20 per-action set lookups per key.

package/src/prompt/tips.txt

@@ -25,4 +25,5 @@ No native tool_calling? Inference provider botches parsing them? `PI_DIALECT=glm
 Turn on `/advisor` to attach a second model that reviews every turn and quietly injects advice
 Try starting your prompt with a ->, and writing a list (1. Do X, 2. Do Y)
 Press 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 — esc cancels

package/src/space-hold.ts

@@ -0,0 +1,143 @@
+/** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
+ *  deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
+export const SPACE_REPEAT_MAX_GAP_MS = 120;
+/** Two consecutive inter-space gaps are "mechanical" (machine-driven auto-repeat) when both are
+ *  within {@link SPACE_REPEAT_MAX_GAP_MS} and differ by no more than this — an absolute jitter floor
+ *  or, for slower repeat rates, {@link SPACE_REPEAT_JITTER_RATIO} of the smaller gap. OS key-repeat
+ *  is metronomic; a human smashing the bar is fast but irregular, so its deltas never stay this
+ *  steady. */
+export const SPACE_REPEAT_JITTER_MS = 18;
+export const SPACE_REPEAT_JITTER_RATIO = 0.35;
+/** Consecutive mechanical (fast + steady) deltas that confirm the space bar is held and start
+ *  recording. Needs a sustained metronomic cadence, so jittery smashing and deliberate taps never
+ *  reach it. */
+export const SPACE_HOLD_MECHANICAL_RUN = 2;
+/** Idle gap (ms) after the last repeated space that counts as the space bar being released, ending
+ *  the push-to-talk recording. Must comfortably exceed the OS key-repeat interval. */
+export const SPACE_HOLD_RELEASE_MS = 250;
+
+/** Whether two consecutive inter-space gaps look machine-driven: both within the auto-repeat band
+ *  and steady enough (small absolute or proportional difference). OS key-repeat is metronomic, so
+ *  its successive deltas match closely; human smashing is fast but irregular and deliberate taps are
+ *  too slow, so neither passes. */
+function gapsAreMechanical(gap: number, prevGap: number): boolean {
+	if (gap > SPACE_REPEAT_MAX_GAP_MS || prevGap > SPACE_REPEAT_MAX_GAP_MS) return false;
+	const tolerance = Math.max(SPACE_REPEAT_JITTER_MS, Math.min(gap, prevGap) * SPACE_REPEAT_JITTER_RATIO);
+	return Math.abs(gap - prevGap) <= tolerance;
+}
+
+/** What a recognized space-bar hold drives — the push-to-talk start and stop. */
+export interface SpaceHoldHandler {
+	/** Gate for the gesture. Returns false to keep the space bar inserting spaces normally, so
+	 *  disabling push-to-talk restores plain space behavior. */
+	enabled(): boolean;
+	/** A sustained hold was recognized. The optimistically-typed spaces have already been deleted. */
+	onStart(): void;
+	/** The held space bar was released (an idle gap with no further repeated spaces, or any other key). */
+	onEnd(): void;
+}
+
+/** What the host must do with a keypress after {@link SpaceHoldGesture.process} has seen it:
+ *  `"pass"` — handle it normally; `"type"` — insert the space now (it is tracked back out if the run
+ *  turns into a hold); `"swallow"` — drop it, the gesture consumed it. */
+export type SpaceHoldStep = "pass" | "type" | "swallow";
+
+/** Space-hold push-to-talk state machine. A held space bar emits OS auto-repeat: a *steady* stream
+ *  of spaces at a fixed fast interval. We watch the inter-space deltas and only recognize a hold once
+ *  {@link SPACE_HOLD_MECHANICAL_RUN} consecutive deltas are "mechanical" — both auto-repeat-fast and
+ *  near-identical (see {@link gapsAreMechanical}). Smashing the bar is fast but jittery and deliberate
+ *  taps are too slow, so neither escalates and both keep typing real spaces; the few spaces typed
+ *  before a real hold is recognized are tracked back out of the host input. */
+export class SpaceHoldGesture {
+	/** Unset (the default) keeps the space bar typing spaces. */
+	handler: SpaceHoldHandler | undefined;
+	/** Deletes the given number of characters before the host input's cursor. */
+	readonly #deleteTyped: (count: number) => void;
+	/** Host input state that rules the gesture out, e.g. an editor mode where space is not text. */
+	readonly #allowed: () => boolean;
+	/** Spaces the host typed in the current run; tracked back out when a hold is recognized. */
+	#typed = 0;
+	/** Consecutive "mechanical" deltas (fast + steady); a sustained run of these confirms a held bar. */
+	#mechanicalRun = 0;
+	/** Inter-space gap (ms) of the previous space pair, compared against the next to judge steadiness. */
+	#prevGap: number | undefined;
+	/** Monotonic timestamp (ms) of the last space, to measure the gap to the next one. */
+	#lastSpaceAt = Number.NEGATIVE_INFINITY;
+	/** True while a recognized space-hold push-to-talk recording is in progress. */
+	#active = false;
+	/** Idle timer that ends the hold once repeated spaces stop arriving. */
+	#releaseTimer: NodeJS.Timeout | undefined;
+
+	constructor(deleteTyped: (count: number) => void, allowed: () => boolean = () => true) {
+		this.#deleteTyped = deleteTyped;
+		this.#allowed = allowed;
+	}
+
+	/** Feed one keypress, `isSpace` when it is a plain space bar press. */
+	process(isSpace: boolean): SpaceHoldStep {
+		if (this.#active) {
+			if (isSpace) {
+				// Auto-repeat while held: swallow it and keep the release timer alive.
+				this.#armReleaseTimer();
+				return "swallow";
+			}
+			// Any non-space means the bar was released — stop recording, then let the key through.
+			this.#end();
+			return "pass";
+		}
+		if (!isSpace) {
+			this.#resetRun();
+			return "pass";
+		}
+		if (!(this.handler?.enabled() && this.#allowed())) return "pass";
+		const now = performance.now();
+		const gap = now - this.#lastSpaceAt;
+		const prevGap = this.#prevGap;
+		this.#lastSpaceAt = now;
+		this.#prevGap = gap;
+		if (prevGap === undefined || !gapsAreMechanical(gap, prevGap)) {
+			// First space, a deliberate tap, or jittery smashing: not a steady machine cadence yet, so
+			// type a real space and reset the mechanical run.
+			this.#mechanicalRun = 0;
+			this.#typed++;
+			return "type";
+		}
+		// Steady fast repeat: swallow it. Once the cadence has held for SPACE_HOLD_MECHANICAL_RUN
+		// deltas it's a held bar — track back the few pre-burst spaces already typed and start.
+		if (++this.#mechanicalRun >= SPACE_HOLD_MECHANICAL_RUN) {
+			this.#deleteTyped(this.#typed);
+			this.#resetRun();
+			this.#active = true;
+			this.#armReleaseTimer();
+			this.handler?.onStart();
+		}
+		return "swallow";
+	}
+
+	#resetRun(): void {
+		this.#typed = 0;
+		this.#mechanicalRun = 0;
+		this.#prevGap = undefined;
+		this.#lastSpaceAt = Number.NEGATIVE_INFINITY;
+	}
+
+	#armReleaseTimer(): void {
+		if (this.#releaseTimer) clearTimeout(this.#releaseTimer);
+		this.#releaseTimer = setTimeout(() => {
+			this.#releaseTimer = undefined;
+			this.#end();
+		}, SPACE_HOLD_RELEASE_MS);
+		this.#releaseTimer.unref?.();
+	}
+
+	#end(): void {
+		if (!this.#active) return;
+		this.#active = false;
+		this.#resetRun();
+		if (this.#releaseTimer) {
+			clearTimeout(this.#releaseTimer);
+			this.#releaseTimer = undefined;
+		}
+		this.handler?.onEnd();
+	}
+}

package/src/status-line/component.ts

@@ -301,6 +301,7 @@ interface StatusLineExternalInputs {
 	isStreaming: boolean | undefined;
 	isAutoThinking: boolean | undefined;
 	isFastModeActive: boolean;
+	anthropicSlowModeLabel: string | undefined;
 	compactionSpeculation: unknown;
 }
 
@@ -2369,6 +2370,10 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			isAutoThinking: this.session.isAutoThinking,
 			isFastModeActive:
 				typeof this.session.isFastModeActive === "function" ? this.session.isFastModeActive() : false,
+			anthropicSlowModeLabel:
+				typeof this.session.getAnthropicSlowModeLabel === "function"
+					? this.session.getAnthropicSlowModeLabel()
+					: undefined,
 			compactionSpeculation: this.session.compactionSpeculation,
 		};
 	}
@@ -2423,6 +2428,7 @@ export class StatusLineComponent<TSession extends StatusLineSession = StatusLine
 			left.isStreaming === right.isStreaming &&
 			left.isAutoThinking === right.isAutoThinking &&
 			left.isFastModeActive === right.isFastModeActive &&
+			left.anthropicSlowModeLabel === right.anthropicSlowModeLabel &&
 			left.compactionSpeculation === right.compactionSpeculation
 		);
 	}

package/src/status-line/host.ts

@@ -53,6 +53,8 @@ export interface StatusLineSession {
 	getContextUsage(): { tokens: number; contextWindow: number; percent: number | null } | undefined;
 	autoResolvedThinkingLevel(): string | undefined;
 	isFastModeActive(): boolean;
+	/** Anthropic subscription slow-mode label (`low priority until 14:30 · 62% left`) while active. */
+	getAnthropicSlowModeLabel?(): string | undefined;
 	getPrewalkState?(): unknown;
 	getAsyncJobSnapshot(): { running: readonly { type: string; agentId?: string }[] } | null | undefined;
 	getGoalModeState(): { goal?: { status: string; tokensUsed: number; tokenBudget?: number } } | undefined;

package/src/status-line/segments.ts

@@ -293,6 +293,10 @@ const modelSegment: StatusLineSegment = {
 			content += accentFg(ctx, "statusLineModel", tail);
 		}
 
+		// Anthropic slow mode: a warning-colored badge so a throttled lane is never
+		// mistaken for normal service.
+		const slowModeLabel = ctx.session.getAnthropicSlowModeLabel?.();
+		if (slowModeLabel) content += theme.fg("warning", `${theme.sep.dot}${slowModeLabel}`);
 		return { content, visible: true };
 	},
 };

package/src/tools/cfg-render.ts

@@ -0,0 +1,117 @@
+/**
+ * Transcript renderers for `cfg://` settings reads and writes.
+ *
+ * Reads show the YAML-ish settings listing the model received, highlighted as
+ * YAML. Writes show the `previous → value` change, its scope (session or
+ * saved), and whether the user approved it.
+ */
+import type { Component } from "../tui";
+import { renderStatusLine } from "../render";
+import {
+	cappedHeadLines,
+	formatBadge,
+	formatErrorDetail,
+	formatMoreItems,
+	PREVIEW_LIMITS,
+} from "../render/render-utils";
+import { highlightCode, type Theme } from "../theme/theme";
+import { parseCfgUrl } from "./cfg-url";
+import type { RenderResultOptions } from "./renderer";
+import { card, type CardToolResult, firstText, safe } from "./result-card";
+
+/** Summary of a `cfg://` read, attached to read tool details. */
+export interface CfgReadDetails {
+	/** Dotted setting path or namespace that was read; empty for the whole tree. */
+	path: string;
+	/** Settings in the listing. */
+	count: number;
+	/** Listed settings whose effective value differs from the schema default. */
+	modified: number;
+}
+
+/** How a `cfg://` write ended. */
+export type CfgWriteOutcome = "applied" | "declined" | "unchanged";
+
+/** A `cfg://` write, attached to write tool details. Values are display-formatted (credentials redacted). */
+export interface CfgWriteDetails {
+	path: string;
+	/** Persisted to config.yml rather than scoped to the session. */
+	save: boolean;
+	previous: string;
+	value: string;
+	outcome: CfgWriteOutcome;
+	/** Effective value after saving when a higher-precedence layer still shadows the saved one. */
+	effective?: string;
+}
+
+/** Render `read cfg://…`: pending header, or the highlighted listing with counts. */
+export function renderCfgRead(
+	url: string,
+	result: CardToolResult | undefined,
+	details: CfgReadDetails | undefined,
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	return card((_width, expanded) => {
+		const meta: string[] = [];
+		if (details) {
+			meta.push(details.count === 1 ? "1 setting" : `${details.count} settings`);
+			if (details.modified) meta.push(`${details.modified} modified`);
+		}
+		const header = renderStatusLine(
+			{
+				icon: result === undefined ? "pending" : result.isError ? "error" : "info",
+				title: "Config",
+				description: (details?.path ?? parseCfgUrl(url)?.segments.join(".")) || "all settings",
+				meta,
+			},
+			theme,
+		);
+		if (!result) return [header];
+		if (result.isError) return [header, formatErrorDetail(firstText(result) || "Settings read failed.", theme)];
+		const body = firstText(result).trimEnd().split("\n");
+		const shown = cappedHeadLines(body, expanded ? body.length : PREVIEW_LIMITS.COLLAPSED_ITEMS);
+		const lines = [header, ...highlightCode(safe(shown.lines.join("\n")), "yaml", theme).map(line => `  ${line}`)];
+		if (shown.hidden) lines.push(theme.fg("dim", `  ${formatMoreItems(shown.hidden, "line")}`));
+		return lines;
+	}, options);
+}
+
+/** Render `write cfg://…[/save]`: the proposed value while pending, then the approved/declined change. */
+export function renderCfgWrite(
+	url: string,
+	content: string | undefined,
+	result: CardToolResult | undefined,
+	details: CfgWriteDetails | undefined,
+	options: RenderResultOptions,
+	theme: Theme,
+): Component {
+	return card(() => {
+		const target = parseCfgUrl(url);
+		const save = details?.save ?? target?.save ?? false;
+		const icon =
+			result === undefined
+				? "pending"
+				: result.isError
+					? "error"
+					: details?.outcome === "declined"
+						? "warning"
+						: "success";
+		const badges = [formatBadge(save ? "persist" : "session", save ? "accent" : "muted", theme)];
+		if (details?.outcome === "declined") badges.push(formatBadge("declined", "warning", theme));
+		if (details?.outcome === "unchanged") badges.push(formatBadge("unchanged", "muted", theme));
+		const header = `${renderStatusLine({ icon, title: "Config", description: details?.path ?? target?.segments.join(".") }, theme)} ${badges.join(" ")}`;
+		if (result?.isError) return [header, formatErrorDetail(firstText(result) || "Settings write failed.", theme)];
+		const arrow = theme.fg("dim", "→");
+		const next = theme.fg("toolOutput", details?.value ?? content?.trim() ?? "…");
+		const lines = [
+			header,
+			details ? `  ${theme.fg("dim", details.previous)} ${arrow} ${next}` : `  ${arrow} ${next}`,
+		];
+		if (details?.effective !== undefined)
+			lines.push(
+				theme.fg("warning", `  still ${details.effective}: a higher-precedence layer overrides the saved value`),
+			);
+		return lines;
+	}, options);
+}

package/src/tools/cfg-url.ts

@@ -0,0 +1,30 @@
+/** Canonical prefix for settings URLs. */
+export const CFG_URL_PREFIX = "cfg://";
+
+/** Trailing write segment that persists a `cfg://` change instead of scoping it to the session. */
+export const CFG_SAVE_SEGMENT = "save";
+
+/** Setting addressed by a `cfg://` URL. */
+export interface CfgTarget {
+	/** Setting path segments; empty for the root. `/` and `.` both separate segments. */
+	segments: string[];
+	/** Whether the URL ends in the `/save` suffix, which is removed from {@link segments}. */
+	save: boolean;
+}
+
+/**
+ * Parse a `cfg://` URL (`cfg://advisor/enabled`, `cfg://advisor.enabled/save`).
+ * Returns `null` for other schemes; query and fragment are ignored.
+ */
+export function parseCfgUrl(input: string): CfgTarget | null {
+	const trimmed = input.trim();
+	if (!trimmed.toLowerCase().startsWith(CFG_URL_PREFIX)) return null;
+	const segments = trimmed
+		.slice(CFG_URL_PREFIX.length)
+		.replace(/[?#].*$/s, "")
+		.split(/[/.]/)
+		.filter(Boolean);
+	const save = segments.length > 1 && segments.at(-1) === CFG_SAVE_SEGMENT;
+	if (save) segments.pop();
+	return { segments, save };
+}

package/src/tools/find.ts

@@ -28,6 +28,7 @@ import type { Theme, ThemeColor } from "../theme/theme";
 import type { Component } from "../tui";
 import type { OutputMeta } from "./output-meta";
 import type { RenderResultOptions, ToolRenderer } from "./renderer";
+import { splitUrlScheme } from "./url-scheme-host";
 
 /** A verified line range with its yes-probability and a one-line preview. */
 export interface FindRange {
@@ -39,7 +40,7 @@ export interface FindRange {
 
 /** A file whose verified passages cleared the threshold; `ranges` are merged positive spans, strongest first. */
 export interface FindHit {
-	/** Display path relative to {@link FindToolDetails.cwd}, or an `omp://` doc URL for docs scopes. */
+	/** Display path relative to {@link FindToolDetails.cwd}, or an internal URL under URL scopes. */
 	rel: string;
 	/** Filename judgment, when the name batch answered. */
 	nameScore?: number;
@@ -85,7 +86,7 @@ export interface FindToolDetails {
 	elapsedMs: number;
 	/** Session cwd; hit paths are relative to it. */
 	cwd: string;
-	/** Display form of the searched directory when narrower than cwd. */
+	/** Display form of the searched directory or file when narrower than cwd. */
 	scopePath?: string;
 	meta?: OutputMeta;
 }
@@ -124,11 +125,11 @@ function gauge(p: number, theme: Theme): string {
 }
 
 function renderHit(hit: FindHit, rangeLimit: number, cwd: string | undefined, theme: Theme): string[] {
-	// `omp://` hits are virtual docs, not files under `cwd`: link the URL
-	// itself instead of joining it onto a filesystem base.
-	const isOmpHit = /^omp:\/\//i.test(hit.rel);
+	// `scheme://` hits (e.g. virtual docs) are not files under `cwd`: link the
+	// URL itself instead of joining it onto a filesystem base.
+	const isUrlHit = splitUrlScheme(hit.rel) !== undefined;
 	const link = (text: string, line?: number): string => {
-		if (isOmpHit) return uriHyperlink(line === undefined ? hit.rel : `${hit.rel}:${line}`, text);
+		if (isUrlHit) return uriHyperlink(line === undefined ? hit.rel : `${hit.rel}:${line}`, text);
 		const absPath = cwd === undefined ? undefined : path.join(cwd, hit.rel);
 		return absPath === undefined ? text : fileHyperlink(absPath, text, { line });
 	};

package/src/tools/output-meta.ts

@@ -72,6 +72,8 @@ export interface OutputMeta {
 	/** Capture failure of this output itself; aggregate reports keep source failures on their entries. */
 	artifactError?: OutputArtifactError;
 	source?: SourceMeta;
+	/** The output is a bounded page of session artifact storage its `source` re-reads with line selectors; spill-to-artifact skips it. */
+	pagedSource?: true;
 	diagnostics?: DiagnosticMeta;
 	limits?: LimitsMeta;
 }

package/src/tools/proc-render.ts

@@ -1,5 +1,5 @@
 import type { Component } from "../tui";
-import { createCachedComponent, Ellipsis, renderStatusLine, renderTreeList, truncateToWidth } from "../render";
+import { Ellipsis, renderStatusLine, renderTreeList, truncateToWidth } from "../render";
 import {
 	cappedHeadLines,
 	formatBadge,
@@ -8,7 +8,6 @@ import {
 	formatStatusIcon,
 	PREVIEW_LIMITS,
 	TRUNCATE_LENGTHS,
-	replaceTabs,
 	type ToolUIColor,
 } from "../render/render-utils";
 import type { Theme } from "../theme/theme";
@@ -17,6 +16,7 @@ import type { AgentActivitySnapshot, CoordinationDetails, JobSnapshot } from "./
 import type { IrcDeliveryReceipt } from "./irc";
 import type { DaemonSnapshot } from "./daemon";
 import { styleTerminalRow } from "./terminal-output";
+import { card, type CardToolResult as ToolResult, firstText, safe } from "./result-card";
 
 export interface ProcReadDetails {
 	jobs?: JobSnapshot[];
@@ -35,30 +35,6 @@ export type ProcWriteDetails =
 /** Process operation selected by a write URL, independent of its content. */
 export type ProcWriteAction = "stdin" | "mode" | "kill";
 
-interface ToolResult {
-	content: Array<{ type: string; text?: string }>;
-	isError?: boolean;
-}
-
-function firstText(result: ToolResult): string {
-	return result.content.find(item => item.type === "text")?.text ?? "";
-}
-
-function safe(value: string): string {
-	return replaceTabs(value).replace(/\r/g, "");
-}
-
-function card(lines: (width: number, expanded: boolean) => string[], options: RenderResultOptions): Component {
-	return createCachedComponent(
-		() => Boolean(options.expanded),
-		(width, expanded) =>
-			lines(width, expanded)
-				.flatMap(line => line.split("\n"))
-				.map(line => truncateToWidth(safe(line), width, Ellipsis.Unicode)),
-		{ paddingX: 1 },
-	);
-}
-
 function preview(body: string, expanded: boolean, theme: Theme, tone: "dim" | "toolOutput" = "dim"): string[] {
 	if (!body.trim()) return [];
 	const limit = expanded ? PREVIEW_LIMITS.EXPANDED_LINES : PREVIEW_LIMITS.COLLAPSED_LINES;