@oh-my-pi/pi-tui 18.2.11 → 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/image-source.ts

@@ -1,10 +1,10 @@
 /**
- * Original filesystem source carried on image attachments that entered from a
- * file on disk: path-pasted/drag-and-dropped images and generated video
- * contact-sheet previews. Symbol metadata stays out of serialized/model-bound
- * image data while traveling with the draft object, until AgentSession creates
- * the hidden companion message that tells the model the path (and link
- * materialization prefers it over a blob copy).
+ * File source carried on image attachments backed by a file on disk:
+ * path-pasted/drag-and-dropped images, clipboard images the coding agent commits
+ * to the session's `local://` root, and generated video contact-sheet previews.
+ * Symbol metadata stays out of serialized/model-bound image data while traveling
+ * with the draft object, until AgentSession creates the hidden companion message
+ * that tells the model the path (and link materialization prefers it over a blob copy).
  */
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { isRecord } from "@oh-my-pi/pi-utils";
@@ -12,8 +12,9 @@ import { isRecord } from "@oh-my-pi/pi-utils";
 /** How an image attachment's backing file entered the session. */
 export type ImageAttachmentSourceKind = "image" | "video";
 
-/** Original local file backing an image attachment. */
+/** Local file backing an image attachment. */
 export interface ImageAttachmentSource {
+	/** Absolute filesystem path, or a session-relative `local://` URL for images committed to the session. */
 	readonly path: string;
 	readonly kind: ImageAttachmentSourceKind;
 }
@@ -43,7 +44,7 @@ function isImageAttachmentSource(value: unknown): value is ImageAttachmentSource
 	return isRecord(value) && typeof value.path === "string" && (value.kind === "image" || value.kind === "video");
 }
 
-/** Return the original local source of an image attachment, or undefined for payloads with no source file (clipboard bitmaps). */
+/** Return the local file backing an image attachment, or undefined for payloads with no file on disk. */
 export function imageAttachmentSource(image: ImageContent): ImageAttachmentSource | undefined {
 	if (!(kImageAttachmentSource in image)) return undefined;
 	const source = image[kImageAttachmentSource];

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/setup/scenes/sign-in.ts

@@ -230,7 +230,7 @@ export class SignInTab implements SetupTab {
 		this.#host.restoreFocus();
 		this.#host.requestRender();
 		try {
-			await this.#authStorage.login(providerId as OAuthProvider, {
+			await this.#authStorage.oauth.login(providerId as OAuthProvider, {
 				signal: this.#loginAbort.signal,
 				onBrowserSession: (request, signal) => this.#host.ctx.captureBrowserSession(request, signal),
 				onAuth: info => {

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/context-usage.ts

@@ -2,6 +2,7 @@ import type { AgentMessage, Tokenizer } from "@oh-my-pi/pi-agent-core";
 import type { CompactionSettings } from "@oh-my-pi/pi-agent-core/compaction";
 import { effectiveReserveTokens, resolveThresholdTokens } from "@oh-my-pi/pi-agent-core/compaction";
 import type { Tool as AiTool, Model } from "@oh-my-pi/pi-ai";
+import { renderToolExamples } from "@oh-my-pi/pi-ai/dialect";
 import { toolWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
 import { formatNumber } from "@oh-my-pi/pi-utils";
 import type { Theme } from "../theme";
@@ -12,7 +13,7 @@ interface ContextSkill {
 	readonly hide?: boolean;
 }
 
-type ContextTool = Pick<AiTool, "name" | "description" | "parameters">;
+type ContextTool = Pick<AiTool, "name" | "description" | "parameters" | "examples">;
 
 /** Savings computed by the host's inline-image planner, not by the renderer. */
 export interface ContextSavingsEstimate {
@@ -140,6 +141,8 @@ export interface NonMessageTokenSource {
 		};
 	};
 	readonly skills?: readonly ContextSkill[];
+	/** Provider-facing, session-frozen descriptions when available. */
+	readonly renderedSkills?: readonly ContextSkill[];
 }
 
 /** Shared empty system-prompt part list, avoiding an allocation per render. */
@@ -244,9 +247,13 @@ export function estimateToolSchemaTokens(tools: ToolSchemaSource, tokenizer: Tok
 				name,
 				description,
 				parameters: parameters as AiTool["parameters"],
+				examples: tool.examples,
 			};
 			const wireJson = JSON.stringify(toolWireSchema(wireTool) ?? {});
 			if (typeof wireJson === "string") fragments.push(wireJson);
+			// The agent loop appends rendered examples to the wire description.
+			const examplesBlock = renderToolExamples(wireTool);
+			if (examplesBlock) fragments.push(examplesBlock);
 		} catch {
 			// Schema may contain functions or cycles; ignore.
 		}
@@ -313,7 +320,7 @@ function nonMessageTokenCacheEntry(
 	const systemPromptRef = session.systemPrompt ?? EMPTY_STRING_PARTS;
 	const toolsRef = session.agent?.state?.tools ?? EMPTY_TOOLS;
 	const toolsRevision = getToolSchemaMetadataRevision(toolsRef);
-	const skillsRef = session.skills ?? EMPTY_SKILLS;
+	const skillsRef = session.renderedSkills ?? session.skills ?? EMPTY_SKILLS;
 	let entry = cachedSession[NON_MESSAGE_TOKEN_CACHE];
 	if (
 		entry &&
@@ -378,7 +385,12 @@ export function computeNonMessageBreakdown(
 	if (entry.breakdown && entry.skillful === skillful) return entry.breakdown;
 	const tools = session.agent?.state?.tools ?? EMPTY_TOOLS;
 	const skillsTokens =
-		skillful === false ? 0 : estimateSkillsTokens(renderedSkills(session.skills ?? EMPTY_SKILLS, tools), tokenizer);
+		skillful === false
+			? 0
+			: estimateSkillsTokens(
+					renderedSkills(session.renderedSkills ?? session.skills ?? EMPTY_SKILLS, tools),
+					tokenizer,
+				);
 	const toolsTokens = estimateToolSchemaTokens(tools, tokenizer, sourceRevision);
 	const systemPromptParts = session.systemPrompt ?? EMPTY_STRING_PARTS;
 	const systemContextTokens = tokenizer.countTokens(Array.from(systemPromptParts.slice(1), part => part ?? ""));

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/terminal-capabilities.ts

@@ -42,7 +42,7 @@ export type TerminalId =
 	| "base"
 	| "trueColor";
 
-const CMUX_NOTIFICATION_TITLE = "Oh My Pi";
+const CMUX_NOTIFICATION_TITLE = "omp";
 const CMUX_SURFACE_ID_PATTERN = /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/iu;
 
 /** Title and body for an out-of-band multiplexer notification (cmux, Herdr). */
@@ -1433,7 +1433,7 @@ function notificationToLine(n: TerminalNotification): string {
 // C0/C1 control characters that are unsafe inside an OSC payload (must base64).
 const OSC99_UNSAFE = /[\x00-\x1f\x7f\x80-\x9f]/u;
 const OSC99_MAX_PAYLOAD_BYTES = 2048;
-const OSC99_APP_NAME = "Oh My Pi";
+const OSC99_APP_NAME = "omp";
 let nextOsc99NotificationId = 1;
 
 function base64Utf8(value: string): string {

package/src/terminal.ts

@@ -25,6 +25,7 @@ import {
 } from "./terminal-capabilities";
 import { isInsideTmux, wrapTmuxPassthrough } from "./tmux";
 import { setHangulCompatibilityJamoWidth } from "./utils";
+import { translateWindowsAltGrSequence } from "./windows-altgr";
 
 const TERMINAL_PROGRESS_KEEPALIVE_MS = 1000;
 const TERMINAL_PROGRESS_ACTIVE_SEQUENCE = "\x1b]9;4;3\x07";
@@ -1463,7 +1464,13 @@ export class ProcessTerminal implements Terminal {
 				return;
 			}
 			if (this.#inputHandler) {
-				this.#inputHandler(sequence);
+				// Windows console hosts drop AltGr text under kitty (AltGr+F → `CSI 102;3u`);
+				// recover it from the active layout before any keybinding sees an Alt chord.
+				const altGrText =
+					this.#kittyProtocolActive && this.#conpty && process.platform === "win32"
+						? translateWindowsAltGrSequence(sequence)
+						: undefined;
+				this.#inputHandler(altGrText ?? sequence);
 			}
 		});