@oh-my-pi/pi-coding-agent 16.4.5 → 16.4.6

package/src/modes/components/usage-row.ts

@@ -18,12 +18,11 @@ export function createUsageRowBlock(usage: Usage, durationMs?: number, ttftMs?:
 		parts.push(`${theme.icon.time} ${(ttftMs / 1000).toFixed(1)}s`);
 	}
 	if (durationMs && durationMs > MIN_DURATION_MS && usage.output > 0) {
-		// Throughput excludes TTFT — generation time is duration minus time-to-first-token.
-		const genMs = durationMs - (ttftMs ?? 0);
-		if (genMs > MIN_DURATION_MS) {
-			const tokPerSec = (usage.output / genMs) * 1000;
-			parts.push(`${theme.icon.throughput} ${tokPerSec.toFixed(1)}/s`);
-		}
+		// TPS over the total request duration — the post-TTFT window undercounts
+		// generation time when reasoning tokens are hidden before the first
+		// visible byte, inflating the rate.
+		const tokPerSec = (usage.output / durationMs) * 1000;
+		parts.push(`${theme.icon.throughput} ${tokPerSec.toFixed(1)}/s`);
 	}
 	const block = new Container();
 	block.addChild(new Spacer(1));

package/src/modes/controllers/input-controller.ts

@@ -13,6 +13,7 @@ import { TinyTitleDownloadProgressComponent } from "../../modes/components/tiny-
 import { expandEmoticons } from "../../modes/emoji-autocomplete";
 import { materializeImageReferenceLinks, shiftImageMarkers } from "../../modes/image-references";
 import { createPromptActionAutocompleteProvider } from "../../modes/prompt-action-autocomplete";
+import { parseQueueShorthand, splitQueuedMessages } from "../../modes/queue-input";
 import { invokeSkillCommandFromText, isKnownSkillCommand } from "../../modes/skill-command";
 import type { InteractiveModeContext } from "../../modes/types";
 import manualContinuePrompt from "../../prompts/system/manual-continue.md" with { type: "text" };
@@ -266,6 +267,8 @@ export class InputController {
 			});
 		}
 		this.ctx.editor.onEscape = () => {
+			// Side-channel panels are the topmost view. Esc dismisses them before
+			// touching loop mode, maintenance, or the underlying main turn.
 			// Active context maintenance owns Esc: auto/manual compaction,
 			// handoff generation, and auto-retry backoff all advertise
 			// "(esc to cancel)". Dispatch on live session state instead of
@@ -281,6 +284,13 @@ export class InputController {
 			// (see EventController). Main-session maintenance still owns Esc and
 			// stays cancellable from the main view (focused submit gates /compact
 			// and handoff, so manual maintenance is main-only anyway).
+			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
+				return;
+			}
+			if (this.ctx.hasActiveOmfg() && this.ctx.handleOmfgEscape()) {
+				return;
+			}
+
 			if (!this.ctx.focusedAgentId) {
 				const viewSession = this.ctx.viewSession;
 				let aborted = false;
@@ -308,12 +318,6 @@ export class InputController {
 				}
 				return;
 			}
-			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
-				return;
-			}
-			if (this.ctx.hasActiveOmfg() && this.ctx.handleOmfgEscape()) {
-				return;
-			}
 			if (this.ctx.focusedAgentId) {
 				// Esc never interrupts the focused agent's turn: clear typed text,
 				// else return the view to the main session. Interrupt via empty
@@ -647,6 +651,16 @@ export class InputController {
 
 			if (!text && !hasInputImages) return;
 
+			const queueBody = parseQueueShorthand(text);
+			if (queueBody !== undefined) {
+				await this.#queueForYield(queueBody, {
+					historyText: text,
+					images: inputImages,
+					imageLinks: inputImageLinks,
+				});
+				return;
+			}
+
 			// Handle built-in slash commands
 			if (text) {
 				const slashResult = await executeBuiltinSlashCommand(text, {
@@ -1114,6 +1128,126 @@ export class InputController {
 		}
 	}
 
+	/** Queue `/queue` input behind an active turn, or start it immediately when idle. */
+	async handleQueueCommand(text: string): Promise<void> {
+		const images = this.ctx.editor.pendingImages.length > 0 ? [...this.ctx.editor.pendingImages] : undefined;
+		const imageLinks =
+			images && this.ctx.editor.pendingImageLinks.length > 0 ? [...this.ctx.editor.pendingImageLinks] : undefined;
+		await this.#queueForYield(text, { images, imageLinks });
+	}
+
+	async #queueForYield(
+		text: string,
+		options: {
+			historyText?: string;
+			images?: ImageContent[];
+			imageLinks?: (string | undefined)[];
+		},
+	): Promise<void> {
+		const splitMessages = splitQueuedMessages(text);
+		if (splitMessages.length === 0 && !options.images?.length) {
+			this.ctx.editor.clearDraft();
+			this.ctx.showWarning("Usage: /queue <message> (or start a prompt with -> / =>)");
+			return;
+		}
+
+		const messages = splitMessages.length > 0 ? splitMessages : [""];
+		const originalDraft = this.ctx.editor.getText();
+		const images = options.images?.length ? [...options.images] : undefined;
+		const imageLinks = options.imageLinks
+			? [...options.imageLinks]
+			: images
+				? images.map(() => undefined)
+				: undefined;
+		this.ctx.editor.clearDraft(options.historyText);
+
+		if (this.ctx.session.isCompacting) {
+			for (let index = 0; index < messages.length; index++) {
+				this.ctx.compactionQueuedMessages.push({
+					text: messages[index] ?? "",
+					mode: "followUp",
+					images: index === 0 ? images : undefined,
+				});
+			}
+			this.ctx.updatePendingMessagesDisplay();
+			this.ctx.showStatus(
+				messages.length === 1
+					? "Queued message for after compaction"
+					: `Queued ${messages.length} messages for after compaction`,
+			);
+			this.ctx.ui.requestRender();
+			return;
+		}
+
+		const startImmediately = !this.ctx.session.isStreaming && this.ctx.session.queuedMessageCount === 0;
+		let queuedCount = 0;
+		try {
+			if (startImmediately && this.ctx.onInputCallback) {
+				const first = messages[0] ?? "";
+				const submission = this.ctx.startPendingSubmission({
+					text: first,
+					images,
+					imageLinks,
+					streamingBehavior: "followUp",
+				});
+				this.ctx.onInputCallback(submission);
+				queuedCount = 1;
+			}
+			while (queuedCount < messages.length) {
+				const message = messages[queuedCount] ?? "";
+				const queuedImages = queuedCount === 0 ? images : undefined;
+				await this.ctx.withLocalSubmission(
+					message,
+					async () => {
+						if (startImmediately && queuedCount === 0) {
+							await this.ctx.session.prompt(message, {
+								images: queuedImages,
+								streamingBehavior: "followUp",
+							});
+						} else {
+							await this.ctx.session.followUp(message, queuedImages);
+						}
+					},
+					{ imageCount: queuedImages?.length ?? 0 },
+				);
+				queuedCount++;
+			}
+		} catch (error) {
+			if (queuedCount === 0) {
+				this.ctx.editor.setText(originalDraft);
+				if (images) {
+					this.ctx.editor.pendingImages = images;
+					this.ctx.editor.pendingImageLinks = imageLinks ?? images.map(() => undefined);
+					this.ctx.editor.imageLinks = this.ctx.editor.pendingImageLinks;
+				}
+			} else {
+				const remaining = messages.slice(queuedCount);
+				const restored =
+					remaining.length === 1
+						? `=> ${remaining[0]}`
+						: `=>\n${remaining
+								.map((message, index) => `${index + 1}. ${message.replaceAll("\n", "\n   ")}`)
+								.join("\n")}`;
+				this.ctx.editor.setText(restored);
+			}
+			this.ctx.showError(error instanceof Error ? error.message : String(error));
+		}
+
+		this.ctx.updatePendingMessagesDisplay();
+		if (queuedCount === messages.length) {
+			this.ctx.showStatus(
+				startImmediately
+					? queuedCount === 1
+						? "Sent queued message"
+						: `Sent first message; queued ${queuedCount - 1} for later yields`
+					: queuedCount === 1
+						? "Queued message for when the agent yields"
+						: `Queued ${queuedCount} messages for when the agent yields`,
+			);
+		}
+		this.ctx.ui.requestRender();
+	}
+
 	/** Send editor text as a follow-up message (queued behind current stream). */
 	async handleFollowUp(): Promise<void> {
 		let text = this.ctx.editor.getExpandedText().trim();

package/src/modes/controllers/selector-controller.ts

@@ -616,7 +616,7 @@ export class SelectorController {
 			this.ctx.session.modelRegistry,
 			this.ctx.session.scopedModels,
 			{
-				onAssign: async (model, role, thinkingLevel, selector, action) => {
+				onAssign: async (model, role, thinkingLevel, selector) => {
 					// `auto` is session-global: never baked into a per-role model value
 					// (it can't round-trip through `model:<level>`). Apply it to the session
 					// separately and persist via `defaultThinkingLevel`.
@@ -624,18 +624,6 @@ export class SelectorController {
 					const concreteThinking = isAuto || thinkingLevel === undefined ? undefined : thinkingLevel;
 					const selectorValue = selector ?? `${model.provider}/${model.id}`;
 					try {
-						if (action === "retryFallback") {
-							const fallbackSelector = formatModelSelectorValue(selectorValue, concreteThinking);
-							const fallbackChains = this.ctx.settings.get("retry.fallbackChains");
-							const chain = Array.isArray(fallbackChains[role]) ? fallbackChains[role] : [];
-							this.ctx.settings.set("retry.fallbackChains", {
-								...fallbackChains,
-								[role]: [fallbackSelector, ...chain.filter(existing => existing !== fallbackSelector)],
-							});
-							const roleInfo = getRoleInfo(role, settings);
-							this.ctx.showStatus(`${roleInfo?.name ?? role} fallback model: ${fallbackSelector}`);
-							return;
-						}
 						if (role === "default") {
 							const { switched } = await this.ctx.session.setModel(model, role, {
 								selector,
@@ -679,6 +667,25 @@ export class SelectorController {
 						this.ctx.showError(error instanceof Error ? error.message : String(error));
 					}
 				},
+				onFallbackChainChange: (role, chain) => {
+					try {
+						const chains = { ...this.ctx.settings.get("retry.fallbackChains") };
+						if (chain.length === 0) {
+							delete chains[role];
+						} else {
+							chains[role] = chain;
+						}
+						this.ctx.settings.set("retry.fallbackChains", chains);
+						const roleInfo = getRoleInfo(role, settings);
+						this.ctx.showStatus(
+							chain.length > 0
+								? `${roleInfo?.name ?? role} fallbacks: ${chain.join(" → ")}`
+								: `${roleInfo?.name ?? role} fallbacks cleared`,
+						);
+					} catch (error) {
+						this.ctx.showError(error instanceof Error ? error.message : String(error));
+					}
+				},
 				onPick: async (model, selector) => {
 					try {
 						// Session-only: update agent state but don't persist the model to settings.

package/src/modes/controllers/todo-command-controller.ts

@@ -133,8 +133,7 @@ export class TodoCommandController {
 
 	/**
 	 * True latest todo state for the user-facing /todo verbs. Reads from session
-	 * entries so that completed/abandoned tasks remain visible after resume
-	 * (where `session.getTodoPhases()` would have stripped them).
+	 * entries or falls back to the active session state.
 	 */
 	#currentPhases(): TodoPhase[] {
 		const fromEntries = getLatestTodoPhasesFromEntries(this.ctx.sessionManager.getBranch());

package/src/modes/interactive-mode.ts

@@ -4287,6 +4287,11 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#inputController.handleImagePaste();
 	}
 
+	/** Queue slash-command input behind the active turn. */
+	handleQueueCommand(message: string): Promise<void> {
+		return this.#inputController.handleQueueCommand(message);
+	}
+
 	handleBtwCommand(question: string): Promise<void> {
 		return this.#btwController.start(question);
 	}

package/src/modes/queue-input.ts

@@ -0,0 +1,132 @@
+const QUEUE_PREFIXES: readonly string[] = ["->", "=>"];
+/** Prefix matcher shared by queue-list parsing and editor highlighting. */
+export const QUEUE_LIST_MARKER_RE = /^([\t ]*)(\d+|[A-Za-z]+)([.)])(?=[\t ]|$)/;
+const CANONICAL_ROMAN_RE = /^(?=[MDCLXVI])M{0,3}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})$/i;
+
+interface EnumeratedItem {
+	line: number;
+	indent: string;
+	marker: string;
+	punctuation: string;
+	content: string;
+}
+
+interface EnumeratedList {
+	source: string;
+	lines: string[];
+	items: EnumeratedItem[];
+}
+
+/** Extract the message body from the `->` / `=>` yield-queue shorthand. */
+export function parseQueueShorthand(text: string): string | undefined {
+	const prefix = QUEUE_PREFIXES.find(candidate => text.startsWith(candidate));
+	return prefix ? text.slice(prefix.length).trim() : undefined;
+}
+
+function parseEnumeratedItem(line: string, lineIndex: number): EnumeratedItem | undefined {
+	const match = QUEUE_LIST_MARKER_RE.exec(line);
+	if (!match) return undefined;
+	const [matched, indent, marker, punctuation] = match;
+	if (indent === undefined || marker === undefined || punctuation === undefined) return undefined;
+	return { line: lineIndex, indent, marker, punctuation, content: line.slice(matched.length).trimStart() };
+}
+
+function decodeDecimal(marker: string): number | undefined {
+	if (!/^\d+$/.test(marker)) return undefined;
+	const value = Number(marker);
+	return Number.isSafeInteger(value) ? value : undefined;
+}
+
+function decodeRoman(marker: string): number | undefined {
+	if (!CANONICAL_ROMAN_RE.test(marker)) return undefined;
+	const values: Readonly<Record<string, number>> = {
+		I: 1,
+		V: 5,
+		X: 10,
+		L: 50,
+		C: 100,
+		D: 500,
+		M: 1000,
+	};
+	const upper = marker.toUpperCase();
+	let value = 0;
+	for (let index = 0; index < upper.length; index++) {
+		const current = values[upper[index] ?? ""];
+		if (current === undefined) return undefined;
+		const next = values[upper[index + 1] ?? ""] ?? 0;
+		value += current < next ? -current : current;
+	}
+	return value;
+}
+
+function decodeAlpha(marker: string): number | undefined {
+	if (!/^[A-Za-z]+$/.test(marker)) return undefined;
+	let value = 0;
+	for (const char of marker.toUpperCase()) {
+		value = value * 26 + char.charCodeAt(0) - 64;
+		if (!Number.isSafeInteger(value)) return undefined;
+	}
+	return value;
+}
+
+function isSequential(markers: readonly string[], decode: (marker: string) => number | undefined): boolean {
+	let previous = decode(markers[0] ?? "");
+	if (previous === undefined) return false;
+	for (let index = 1; index < markers.length; index++) {
+		const current = decode(markers[index] ?? "");
+		if (current === undefined || current !== previous + 1) return false;
+		previous = current;
+	}
+	return true;
+}
+
+function isEnumeratedSequence(items: readonly EnumeratedItem[]): boolean {
+	const markers = items.map(item => item.marker);
+	if (markers.every(marker => /^\d+$/.test(marker))) return isSequential(markers, decodeDecimal);
+	if (
+		!markers.every(marker => marker === marker.toUpperCase()) &&
+		!markers.every(marker => marker === marker.toLowerCase())
+	) {
+		return false;
+	}
+	return isSequential(markers, decodeRoman) || isSequential(markers, decodeAlpha);
+}
+
+function parseEnumeratedList(text: string): EnumeratedList | undefined {
+	const source = text.trim();
+	if (!source) return undefined;
+	const lines = source.split(/\r?\n/);
+	const first = parseEnumeratedItem(lines[0] ?? "", 0);
+	if (!first) return undefined;
+
+	const items = [first];
+	for (let lineIndex = 1; lineIndex < lines.length; lineIndex++) {
+		const item = parseEnumeratedItem(lines[lineIndex] ?? "", lineIndex);
+		if (item?.indent === first.indent) items.push(item);
+	}
+	if (items.length < 2 || items.some(item => item.punctuation !== first.punctuation) || !isEnumeratedSequence(items)) {
+		return undefined;
+	}
+	return { source, lines, items };
+}
+
+/** Whether text currently forms a sequential queue list, including an unfinished trailing item. */
+export function isQueuedMessageList(text: string): boolean {
+	return parseEnumeratedList(text) !== undefined;
+}
+
+/** Split a sequential numeric, Roman-numeral, or alphabetic list into queue entries. */
+export function splitQueuedMessages(text: string): string[] {
+	const list = parseEnumeratedList(text);
+	if (!list) {
+		const source = text.trim();
+		return source ? [source] : [];
+	}
+
+	const messages = list.items.map((item, index) => {
+		const nextLine = list.items[index + 1]?.line ?? list.lines.length;
+		return [item.content, ...list.lines.slice(item.line + 1, nextLine)].join("\n").trim();
+	});
+	while (messages.at(-1) === "") messages.pop();
+	return messages.length > 0 && messages.every(Boolean) ? messages : [list.source];
+}

package/src/modes/types.ts

@@ -377,6 +377,8 @@ export interface InteractiveModeContext {
 	handleCtrlZ(): void;
 	handleDequeue(): void;
 	handleImagePaste(): Promise<boolean>;
+	/** Queue a message for delivery only after the active agent turn would stop. */
+	handleQueueCommand(message: string): Promise<void>;
 	handleBtwCommand(question: string): Promise<void>;
 	handleTanCommand(work: string): Promise<void>;
 	hasActiveBtw(): boolean;

package/src/modes/utils/ui-helpers.ts

@@ -46,6 +46,7 @@ import {
 	type SkillPromptDetails,
 } from "../../session/messages";
 import type { SessionContext } from "../../session/session-context";
+import { replaceTabs } from "../../tools/render-utils";
 import { buildSkillCommandPrompt, invokeSkillCommandFromText, isKnownSkillCommand } from "../skill-command";
 import { createAssistantMessageComponent } from "./interactive-context-helpers";
 import {
@@ -677,35 +678,33 @@ export class UiHelpers {
 		this.ctx.pendingMessagesContainer.disposeChildren();
 		const queuedMessages = this.ctx.viewSession.getQueuedMessages() as QueuedMessages;
 
-		const steeringMessages: Array<{ message: string; label: string }> = [];
-		for (const message of queuedMessages.steering) {
-			steeringMessages.push({ message, label: "Steer" });
-		}
+		const steeringMessages = [...queuedMessages.steering];
 		for (const entry of this.ctx.compactionQueuedMessages as CompactionQueuedMessage[]) {
-			if (entry.mode === "steer") {
-				steeringMessages.push({ message: entry.text, label: "Steer" });
-			}
+			if (entry.mode === "steer") steeringMessages.push(entry.text);
 		}
 
-		const followUpMessages: Array<{ message: string; label: string }> = [];
-		for (const message of queuedMessages.followUp) {
-			followUpMessages.push({ message, label: "Follow-up" });
-		}
+		const followUpMessages = [...queuedMessages.followUp];
 		for (const entry of this.ctx.compactionQueuedMessages as CompactionQueuedMessage[]) {
-			if (entry.mode === "followUp") {
-				followUpMessages.push({ message: entry.text, label: "Follow-up" });
-			}
+			if (entry.mode === "followUp") followUpMessages.push(entry.text);
 		}
 
-		const allMessages = [...steeringMessages, ...followUpMessages];
-		if (allMessages.length > 0) {
+		const groups = [
+			{ label: "Steering", messages: steeringMessages },
+			{ label: "After yield", messages: followUpMessages },
+		].filter(group => group.messages.length > 0);
+		if (groups.length > 0) {
 			this.ctx.pendingMessagesContainer.addChild(new Spacer(1));
-			for (const entry of allMessages) {
-				const queuedText = theme.fg("dim", `${entry.label}: ${entry.message}`);
-				this.ctx.pendingMessagesContainer.addChild(new TruncatedText(queuedText, 1, 0));
+			for (const group of groups) {
+				const heading = theme.fg("muted", `${group.label}${theme.sep.dot}${group.messages.length}`);
+				this.ctx.pendingMessagesContainer.addChild(new TruncatedText(heading, 1, 0));
+				for (let index = 0; index < group.messages.length; index++) {
+					const message = replaceTabs(group.messages[index] ?? "").replace(/\r?\n/g, " ↵ ");
+					const queuedText = theme.fg("dim", `  ${index + 1}. ${message}`);
+					this.ctx.pendingMessagesContainer.addChild(new TruncatedText(queuedText, 1, 0));
+				}
 			}
 			const dequeueKey = this.ctx.keybindings.getDisplayString("app.message.dequeue") || "Alt+Up";
-			const hintText = theme.fg("dim", `${theme.tree.hook} ${dequeueKey} to edit`);
+			const hintText = theme.fg("dim", `  ${theme.tree.hook} ${dequeueKey} to edit`);
 			this.ctx.pendingMessagesContainer.addChild(new TruncatedText(hintText, 1, 0));
 		}
 	}