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

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

@@ -19,7 +19,7 @@
 import {
 	type Component,
 	Ellipsis,
-	Input,
+	Editor,
 	Markdown,
 	type MarkdownTheme,
 	matchesKey,
@@ -31,7 +31,7 @@ import {
 } from "../index";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import { sanitizeStatusText } from "../chrome/shared";
-import { getMarkdownTheme, theme } from "../theme/theme";
+import { getEditorTheme, getMarkdownTheme, theme } from "../theme/theme";
 import {
 	matchesAppExternalEditor,
 	matchesSelectCancel,
@@ -57,6 +57,8 @@ import { renderSegmentTrack } from "../chrome/segment-track";
 const OVERLAY_TITLE = "Plan Review";
 /** Minimum plan-body rows kept visible even on short terminals. */
 const MIN_BODY_ROWS = 3;
+/** Visible rows for the in-overlay annotation editor before it scrolls. */
+const MAX_ANNOTATION_EDITOR_ROWS = 6;
 /** Sidebar gates: enough headings, a wide terminal, and a usable body column. */
 const SIDEBAR_MIN_HEADINGS = 2;
 const SIDEBAR_MIN_TOTAL_WIDTH = 64;
@@ -93,6 +95,16 @@ interface BodyRowAnchor {
 	contextTruncated: boolean;
 }
 
+interface AnnotationSelection {
+	sectionIndex: number;
+	annotationIndex: number;
+}
+
+interface AnnotationChooser {
+	entries: AnnotationSelection[];
+	selected: number;
+}
+
 /** Serializable annotations retained by the plan-review owner between overlays. */
 export interface PlanReviewAnnotationState {
 	annotations: Array<{
@@ -207,8 +219,10 @@ export class PlanReviewOverlay implements Component {
 	/** Label of the committed choice, shown while the async approval settles. */
 	#committedLabel: string | undefined;
 	#annotating = false;
-	#input: Input;
+	#editor: Editor;
 	#annotationTarget: BodyRowAnchor | { sectionIndex: number; row: null; context: null } | undefined;
+	#editingAnnotation: AnnotationSelection | undefined;
+	#annotationChooser: AnnotationChooser | undefined;
 
 	constructor(
 		planContent: string,
@@ -236,10 +250,11 @@ export class PlanReviewOverlay implements Component {
 		} else {
 			this.#sliderIndex = 0;
 		}
-		this.#input = new Input();
-		this.#input.setUseTerminalCursor(false);
-		this.#input.onSubmit = value => this.#submitAnnotation(value);
-		this.#input.onEscape = () => this.#exitAnnotate();
+		this.#editor = new Editor(getEditorTheme());
+		this.#editor.setBorderVisible(false);
+		this.#editor.setPromptGutter("> ");
+		this.#editor.setUseTerminalCursor(false);
+		this.#editor.onSubmit = value => this.#submitAnnotation(value);
 		this.#setSections(planContent);
 		this.#restoreAnnotationState(options.annotationState);
 		if (Array.isArray(options.annotationState?.annotations) && options.annotationState.annotations.length > 0) {
@@ -490,14 +505,22 @@ export class PlanReviewOverlay implements Component {
 	handleInput(keyData: string): void {
 		if (this.#committed) return;
 		if (keyData.startsWith("\x1b[<") && this.#handleMouse(keyData)) return;
+		if (this.#annotationChooser) {
+			this.#handleAnnotationChooser(keyData);
+			return;
+		}
 		if (this.#annotating) {
 			if (this.callbacks.onAnnotationExternalEditor && matchesAppExternalEditor(keyData)) {
-				this.callbacks.onAnnotationExternalEditor(this.#input.getValue(), text => {
-					if (text !== null) this.#submitAnnotation(text);
+				this.callbacks.onAnnotationExternalEditor(this.#editor.getExpandedText(), text => {
+					if (text !== null && this.#annotating) this.#editor.setText(text);
 				});
 				return;
 			}
-			this.#input.handleInput(keyData);
+			if (matchesSelectCancel(keyData)) {
+				this.#exitAnnotate();
+				return;
+			}
+			this.#editor.handleInput(keyData);
 			return;
 		}
 		if (matchesSelectCancel(keyData)) {
@@ -505,6 +528,14 @@ export class PlanReviewOverlay implements Component {
 			this.callbacks.onCancel();
 			return;
 		}
+		if (this.#focus !== "actions" && keyData === "u") {
+			this.#undoLast();
+			return;
+		}
+		if (this.#focus !== "actions" && keyData === "e") {
+			this.#editCurrentAnnotation();
+			return;
+		}
 		if (this.callbacks.onExternalEditor && matchesAppExternalEditor(keyData)) {
 			this.callbacks.onExternalEditor();
 			return;
@@ -726,10 +757,6 @@ export class PlanReviewOverlay implements Component {
 			this.#startSectionAnnotate();
 			return;
 		}
-		if (data === "u") {
-			this.#undoLast();
-			return;
-		}
 	}
 
 	#moveTocCursor(delta: number): void {
@@ -828,39 +855,145 @@ export class PlanReviewOverlay implements Component {
 
 	#startAnnotate(target: BodyRowAnchor | { sectionIndex: number; row: null; context: null }): void {
 		this.#annotationTarget = target;
+		this.#editingAnnotation = undefined;
+		this.#annotating = true;
+		this.#editor.setText("");
+	}
+
+	#startExistingAnnotation(selection: AnnotationSelection): void {
+		const section = this.#sections[selection.sectionIndex];
+		const annotation = section?.annotations[selection.annotationIndex];
+		if (!section || !annotation) return;
+		this.#annotationChooser = undefined;
+		this.#editingAnnotation = selection;
+		this.#annotationTarget =
+			annotation.target.kind === "section"
+				? { sectionIndex: selection.sectionIndex, row: null, context: null }
+				: {
+						sectionIndex: selection.sectionIndex,
+						row: annotation.target.row,
+						context: annotation.target.context,
+						contextTruncated: annotation.target.contextTruncated,
+					};
 		this.#annotating = true;
-		this.#input.setValue("");
+		this.#editor.setText(annotation.note);
+	}
+
+	#annotationMatchesBodyAnchor(annotation: OverlayAnnotation, anchor: BodyRowAnchor): boolean {
+		if (annotation.target.kind === "section") return true;
+		if (annotation.target.row === anchor.row && annotation.target.context === anchor.context) return true;
+		const seenRows = new Set<number>();
+		const sectionAnchors: LineAnchorContext[] = [];
+		for (const candidate of this.#bodyRowAnchors) {
+			if (candidate.sectionIndex !== anchor.sectionIndex || seenRows.has(candidate.row)) continue;
+			seenRows.add(candidate.row);
+			sectionAnchors.push({ text: candidate.context, truncated: candidate.contextTruncated });
+		}
+		const resolvedRow = this.#resolveLineRow(
+			annotation.target.row,
+			{ text: annotation.target.context, truncated: annotation.target.contextTruncated },
+			sectionAnchors,
+		);
+		return resolvedRow === anchor.row;
+	}
+
+	#annotationCandidates(): AnnotationSelection[] {
+		if (this.#focus === "toc") {
+			const sectionIndex = this.#toc[this.#tocCursor];
+			const section = sectionIndex === undefined ? undefined : this.#sections[sectionIndex];
+			if (!section || section.annotations.length === 0) return [];
+			return section.annotations.map((_, annotationIndex) => ({ sectionIndex, annotationIndex }));
+		}
+		if (this.#focus !== "body") return [];
+		const maxRow = this.#bodyRowAnchors.length - 1;
+		if (maxRow < 0) return [];
+		const topRow = Math.max(0, Math.min(maxRow, Math.floor(this.#scrollView.getScrollOffset())));
+		const anchor = this.#bodyRowAnchors[topRow];
+		const section = anchor ? this.#sections[anchor.sectionIndex] : undefined;
+		if (!anchor || !section) return [];
+		const entries: AnnotationSelection[] = [];
+		for (const [annotationIndex, annotation] of section.annotations.entries()) {
+			if (this.#annotationMatchesBodyAnchor(annotation, anchor)) {
+				entries.push({ sectionIndex: anchor.sectionIndex, annotationIndex });
+			}
+		}
+		return entries;
+	}
+
+	#editCurrentAnnotation(): void {
+		const entries = this.#annotationCandidates();
+		if (entries.length === 0) return;
+		if (entries.length === 1) {
+			this.#startExistingAnnotation(entries[0]!);
+			return;
+		}
+		this.#annotationChooser = { entries, selected: 0 };
+	}
+
+	#handleAnnotationChooser(data: string): void {
+		const chooser = this.#annotationChooser;
+		if (!chooser) return;
+		if (matchesSelectCancel(data)) {
+			this.#annotationChooser = undefined;
+			return;
+		}
+		if (matchesSelectUp(data) || matchesKey(data, "k")) {
+			chooser.selected = (chooser.selected - 1 + chooser.entries.length) % chooser.entries.length;
+			return;
+		}
+		if (matchesSelectDown(data) || matchesKey(data, "j")) {
+			chooser.selected = (chooser.selected + 1) % chooser.entries.length;
+			return;
+		}
+		if (matchesKey(data, "enter") || matchesKey(data, "return") || data === "\n") {
+			const selection = chooser.entries[chooser.selected];
+			this.#annotationChooser = undefined;
+			if (selection) this.#startExistingAnnotation(selection);
+		}
 	}
 
 	#submitAnnotation(value: string): void {
-		this.#annotating = false;
 		const note = value.trim();
 		const target = this.#annotationTarget;
+		const editing = this.#editingAnnotation;
+		this.#annotating = false;
 		this.#annotationTarget = undefined;
-		const section = target ? this.#sections[target.sectionIndex] : undefined;
-		if (note && section && target) {
+		this.#editingAnnotation = undefined;
+		this.#editor.setText("");
+		if (editing) {
+			const section = this.#sections[editing.sectionIndex];
+			const annotation = section?.annotations[editing.annotationIndex];
+			if (!section || !annotation) return;
 			this.#pushUndo();
-			section.annotations.push({
-				note,
-				target:
-					target.row === null
-						? { kind: "section" }
-						: {
-								kind: "line",
-								row: target.row,
-								context: target.context,
-								contextTruncated: target.contextTruncated,
-							},
-			});
+			if (note) annotation.note = note;
+			else section.annotations.splice(editing.annotationIndex, 1);
 			this.#recomputeFeedback();
+			return;
 		}
-		this.#input.setValue("");
+		if (!note || !target) return;
+		const section = this.#sections[target.sectionIndex];
+		if (!section) return;
+		this.#pushUndo();
+		section.annotations.push({
+			note,
+			target:
+				target.row === null
+					? { kind: "section" }
+					: {
+							kind: "line",
+							row: target.row,
+							context: target.context,
+							contextTruncated: target.contextTruncated,
+						},
+		});
+		this.#recomputeFeedback();
 	}
 
 	#exitAnnotate(): void {
 		this.#annotating = false;
 		this.#annotationTarget = undefined;
-		this.#input.setValue("");
+		this.#editingAnnotation = undefined;
+		this.#editor.setText("");
 	}
 
 	#recomputeFeedback(): void {
@@ -942,10 +1075,10 @@ export class PlanReviewOverlay implements Component {
 				if (this.#slider) parts.push("◂▸ model");
 				break;
 			case "toc":
-				parts.push("↑↓ section", "⏎ open", "a annotate", "d delete", "u undo");
+				parts.push("↑↓ section", "⏎ open", "a annotate", "e edit", "d delete", "u undo");
 				break;
 			case "body":
-				parts.push("↑↓ scroll", "⇧ faster", "pgup/pgdn", "g/G ends", "a annotate");
+				parts.push("↑↓ scroll", "⇧ faster", "pgup/pgdn", "g/G ends", "a annotate", "e edit", "u undo");
 				break;
 		}
 		if (this.callbacks.onCopyPlan) parts.push("c copy");
@@ -1136,8 +1269,39 @@ export class PlanReviewOverlay implements Component {
 		if (glow) return theme.fg("accent", line);
 		return theme.fg("muted", line);
 	}
+	#renderAnnotationChooserLines(innerWidth: number, maxRows = Number.POSITIVE_INFINITY): string[] {
+		const chooser = this.#annotationChooser;
+		if (!chooser || maxRows <= 0) return [];
+		const optionLimit = Number.isFinite(maxRows) ? Math.max(0, Math.floor(maxRows) - 2) : chooser.entries.length;
+		const start =
+			optionLimit >= chooser.entries.length
+				? 0
+				: Math.max(
+						0,
+						Math.min(chooser.selected - Math.floor(optionLimit / 2), chooser.entries.length - optionLimit),
+					);
+		const lines = [theme.bold(theme.fg("accent", "Edit annotation"))];
+		for (let windowIndex = 0; windowIndex < optionLimit; windowIndex++) {
+			const optionIndex = start + windowIndex;
+			const selection = chooser.entries[optionIndex];
+			if (!selection) continue;
+			const section = this.#sections[selection.sectionIndex];
+			const annotation = section?.annotations[selection.annotationIndex];
+			if (!section || !annotation) continue;
+			const target = annotation.target.kind === "section" ? "section" : `line ${annotation.target.context}`;
+			const note = sanitizeStatusText(annotation.note);
+			const marker = optionIndex === chooser.selected ? theme.fg("accent", "› ") : "  ";
+			const label = `${marker}${sanitizeStatusText(section.title || "Plan preamble")} · ${target} · ${note}`;
+			lines.push(truncateToWidth(label, innerWidth, Ellipsis.Unicode));
+		}
+		if (!Number.isFinite(maxRows) || maxRows >= 2) {
+			lines.push(theme.fg("dim", "↑↓ choose · enter edit · esc cancel"));
+		}
+		return lines.slice(0, Math.max(0, Math.floor(maxRows)));
+	}
 
-	#renderFooterLines(innerWidth: number): string[] {
+	#renderFooterLines(innerWidth: number, maxChooserRows = Number.POSITIVE_INFINITY): string[] {
+		if (this.#annotationChooser) return this.#renderAnnotationChooserLines(innerWidth, maxChooserRows);
 		if (this.#annotating) {
 			const target = this.#annotationTarget;
 			const section = target ? this.#sections[target.sectionIndex] : undefined;
@@ -1151,9 +1315,12 @@ export class PlanReviewOverlay implements Component {
 				innerWidth,
 				Ellipsis.Unicode,
 			);
-			const hintParts = ["enter save", "esc cancel"];
+			const hintParts = ["enter save", "shift+enter newline", "esc cancel"];
+			if (this.#editingAnnotation) hintParts.push("empty deletes");
 			if (this.#externalEditorLabel) hintParts.push(`${this.#externalEditorLabel} editor`);
-			return [caption, this.#input.render(innerWidth)[0] ?? "", theme.fg("dim", hintParts.join(" · "))];
+			this.#editor.setMaxHeight(Math.max(1, Math.min(MAX_ANNOTATION_EDITOR_ROWS, (process.stdout.rows || 40) - 12)));
+			this.#editor.focused = true;
+			return [caption, ...this.#editor.render(innerWidth), theme.fg("dim", hintParts.join(" · "))];
 		}
 		return [theme.fg("dim", this.#buildHelp())];
 	}
@@ -1171,14 +1338,20 @@ export class PlanReviewOverlay implements Component {
 		const submittingLabel = this.#committedLabel ? `${this.#committedLabel} — submitting…` : "Submitting…";
 		const optionLines = committed ? [theme.bold(theme.fg("accent", submittingLabel))] : this.#renderOptionLines();
 		const promptLines = this.#promptTitle ? [theme.bold(theme.fg("accent", this.#promptTitle))] : [];
+		const baseChrome = 4 + promptLines.length + sliderLines.length + optionLines.length;
+		const chooserFooterRows = this.#annotationChooser
+			? Math.max(0, termHeight - baseChrome - MIN_BODY_ROWS)
+			: Number.POSITIVE_INFINITY;
 		const footerLines = committed
 			? [theme.fg("dim", "Applying your selection — this can take a moment while context is prepared.")]
-			: this.#renderFooterLines(innerWidth);
+			: this.#renderFooterLines(innerWidth, chooserFooterRows);
 
 		// Chrome rows: top border, two dividers, bottom border, plus the
 		// prompt/slider/option/footer rows between them.
-		const chrome = 4 + promptLines.length + sliderLines.length + optionLines.length + footerLines.length;
-		const regionRows = Math.max(MIN_BODY_ROWS, termHeight - chrome);
+		const chrome = baseChrome + footerLines.length;
+		const regionRows = this.#annotationChooser
+			? Math.max(0, termHeight - chrome)
+			: Math.max(MIN_BODY_ROWS, termHeight - chrome);
 
 		const bodyLines = this.#buildBody(bodyContentWidth);
 		this.#layoutBody(bodyLines, regionRows);

package/src/overlays/usage-dashboard.ts

@@ -83,6 +83,8 @@ export interface ProviderCard {
 		soonestExpiryMs?: number;
 		unavailableReasons: string[];
 	};
+	/** Labels of accounts with verified Daybreak access. */
+	daybreakAccounts?: string[];
 }
 
 /**
@@ -202,6 +204,17 @@ export function buildProviderCards(reports: UsageReport[], nowMs: number): Provi
 						unavailableReasons,
 					}
 				: undefined;
+		const daybreakAccounts = providerReports.flatMap((report, index) =>
+			report.metadata?.daybreak === true
+				? [
+						typeof report.metadata.email === "string" && report.metadata.email
+							? report.metadata.email
+							: typeof report.metadata.accountId === "string" && report.metadata.accountId
+								? report.metadata.accountId
+								: `account ${index + 1}`,
+					]
+				: [],
+		);
 		cards.push({
 			provider,
 			name: formatProviderName(provider),
@@ -209,8 +222,11 @@ export function buildProviderCards(reports: UsageReport[], nowMs: number): Provi
 			windows,
 			unlimited: windows.length === 0,
 			idle:
-				!resetCredits && windows.every(window => window.fraction !== undefined && window.fraction < IDLE_FRACTION),
+				!resetCredits &&
+				daybreakAccounts.length === 0 &&
+				windows.every(window => window.fraction !== undefined && window.fraction < IDLE_FRACTION),
 			resetCredits,
+			...(daybreakAccounts.length > 0 ? { daybreakAccounts } : {}),
 		});
 	}
 
@@ -453,6 +469,11 @@ export class UsageDashboardComponent implements Component {
 		const titlePad = Math.max(0, width - 2 - visibleWidth(title) - visibleWidth(accountsText));
 		lines.push(`${this.#statusIcon(cardStatus)} ${title}${" ".repeat(titlePad)}${accountsText}`);
 
+		for (const account of card.daybreakAccounts ?? []) {
+			const label = sanitizeText(account.replace(/[\r\n\t]+/g, " "));
+			lines.push(`  ${theme.fg("success", truncateToWidth(`daybreak · ${label}`, width - 2))}`);
+		}
+
 		if (card.resetCredits) {
 			const resets = card.resetCredits;
 			let resetText = `✦ ${resets.bankedCount} reset${resets.bankedCount === 1 ? "" : "s"}`;

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/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/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/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);
 			}
 		});