@oh-my-pi/pi-coding-agent 15.10.1 → 15.10.3

package/src/modes/components/session-selector.ts

@@ -1,7 +1,7 @@
 import {
 	type Component,
 	Container,
-	fuzzyFilter,
+	fuzzyMatch,
 	Input,
 	matchesKey,
 	padding,
@@ -46,43 +46,107 @@ function formatSessionStatus(status: SessionStatus | undefined): string | undefi
 /** Returns the IDs of sessions whose recorded prompts match a query, best first. */
 export type SessionHistoryMatcher = (query: string) => string[];
 
+function sessionSearchText(session: SessionInfo): string {
+	const parts = [
+		session.id,
+		session.title ?? "",
+		session.cwd ?? "",
+		session.firstMessage ?? "",
+		session.allMessagesText,
+		session.path,
+	];
+	return parts.filter(Boolean).join(" ");
+}
+
+function tokenizeSessionQuery(query: string): string[] {
+	const trimmed = query.trim().toLowerCase();
+	return trimmed ? trimmed.split(/\s+/) : [];
+}
+
+function compareSessionRecency(a: SessionInfo, b: SessionInfo): number {
+	return b.modified.getTime() - a.modified.getTime();
+}
+
+/**
+ * Filter and rank session picker search results.
+ *
+ * Resume search narrows a recency-sorted list: once every query token appears
+ * as a literal substring, newer sessions should beat a slightly better fuzzy
+ * position match. Pure fuzzy/acronym matches still sort by fuzzy score after
+ * literal matches.
+ */
+export function rankSessionSearchMatches(allSessions: SessionInfo[], query: string): SessionInfo[] {
+	const tokens = tokenizeSessionQuery(query);
+	if (tokens.length === 0) return allSessions;
+
+	const results: Array<{ session: SessionInfo; score: number; literal: boolean; index: number }> = [];
+	for (let index = 0; index < allSessions.length; index++) {
+		const session = allSessions[index]!;
+		const text = sessionSearchText(session);
+		const textLower = text.toLowerCase();
+		let score = 0;
+		let literal = true;
+		let matches = true;
+
+		for (const token of tokens) {
+			const match = fuzzyMatch(token, textLower);
+			if (!match.matches) {
+				matches = false;
+				break;
+			}
+			score += match.score;
+			if (!textLower.includes(token)) literal = false;
+		}
+
+		if (matches) results.push({ session, score, literal, index });
+	}
+
+	results.sort((a, b) => {
+		if (a.literal !== b.literal) return a.literal ? -1 : 1;
+		if (a.literal) return compareSessionRecency(a.session, b.session) || a.index - b.index;
+		return a.score - b.score || compareSessionRecency(a.session, b.session) || a.index - b.index;
+	});
+
+	return results.map(result => result.session);
+}
+
 /**
- * Combine fuzzy session matches with prompt-history matches for ranking, using
- * both signals rather than replacing one with the other.
+ * Combine metadata matches with prompt-history matches for ranking, using both
+ * signals rather than replacing one with the other.
  *
- * - `fuzzy` is the ordered fuzzy-filter result over session metadata (best first).
+ * - `fuzzy` is the ordered metadata/session-text result.
  * - `historyIds` are session IDs whose recorded prompts matched the query,
  *   ordered by prompt-history rank (typically newest matching prompt first); duplicates are tolerated.
  *
- * Ranking: sessions matched by **both** signals lead (keeping fuzzy order), then
- * fuzzy-only matches, then history-only matches (by prompt-history order). A fuzzy match
- * is never dropped, and history matches not present in `allSessions` (e.g. deleted
- * or out-of-scope sessions) are ignored since they cannot be resumed from here.
+ * Ranking: prompt-history matches lead in history order, then remaining
+ * metadata matches keep their existing order. A metadata match is never dropped,
+ * and history matches not present in `allSessions` (e.g. deleted or out-of-scope
+ * sessions) are ignored since they cannot be resumed from here.
  */
 export function mergeSessionRanking(
 	allSessions: SessionInfo[],
 	fuzzy: SessionInfo[],
 	historyIds: string[],
 ): SessionInfo[] {
-	const historyRank = new Map<string, number>();
-	historyIds.forEach((id, index) => {
-		if (!historyRank.has(id)) historyRank.set(id, index);
-	});
-	if (historyRank.size === 0) return fuzzy;
-
-	const both: SessionInfo[] = [];
-	const fuzzyOnly: SessionInfo[] = [];
-	const fuzzyPaths = new Set<string>();
-	for (const session of fuzzy) {
-		fuzzyPaths.add(session.path);
-		(historyRank.has(session.id) ? both : fuzzyOnly).push(session);
+	if (historyIds.length === 0) return fuzzy;
+
+	const sessionsById = new Map<string, SessionInfo>();
+	for (const session of allSessions) {
+		if (!sessionsById.has(session.id)) sessionsById.set(session.id, session);
 	}
 
-	const historyOnly = allSessions
-		.filter(session => historyRank.has(session.id) && !fuzzyPaths.has(session.path))
-		.sort((a, b) => (historyRank.get(a.id) ?? 0) - (historyRank.get(b.id) ?? 0));
+	const historyMatches: SessionInfo[] = [];
+	const historyPaths = new Set<string>();
+	for (const id of historyIds) {
+		const session = sessionsById.get(id);
+		if (!session || historyPaths.has(session.path)) continue;
+		historyMatches.push(session);
+		historyPaths.add(session.path);
+	}
+	if (historyMatches.length === 0) return fuzzy;
 
-	return [...both, ...fuzzyOnly, ...historyOnly];
+	const metadataOnly = fuzzy.filter(session => !historyPaths.has(session.path));
+	return [...historyMatches, ...metadataOnly];
 }
 
 /**
@@ -156,17 +220,7 @@ class SessionList implements Component {
 	}
 
 	#filterSessions(query: string): void {
-		const fuzzy = fuzzyFilter(this.#allSessions, query, session => {
-			const parts = [
-				session.id,
-				session.title ?? "",
-				session.cwd ?? "",
-				session.firstMessage ?? "",
-				session.allMessagesText,
-				session.path,
-			];
-			return parts.filter(Boolean).join(" ");
-		});
+		const fuzzy = rankSessionSearchMatches(this.#allSessions, query);
 		this.#filteredSessions = this.#mergeHistoryMatches(query, fuzzy);
 		this.#selectedIndex = Math.min(this.#selectedIndex, Math.max(0, this.#filteredSessions.length - 1));
 	}

package/src/modes/components/status-line.ts

@@ -40,6 +40,11 @@ export interface StatusLineSettings {
 	sessionAccent?: boolean;
 }
 
+export type EffectiveStatusLineSettings = Required<
+	Pick<StatusLineSettings, "leftSegments" | "rightSegments" | "separator" | "segmentOptions">
+> &
+	StatusLineSettings;
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Per-message token cache
 // ═══════════════════════════════════════════════════════════════════════════
@@ -143,6 +148,7 @@ function tokensForMessage(msg: AgentMessage): number {
 
 export class StatusLineComponent implements Component {
 	#settings: StatusLineSettings = {};
+	#effectiveSettings: EffectiveStatusLineSettings | undefined;
 	#cachedBranch: string | null | undefined = undefined;
 	#cachedBranchRepoId: string | null | undefined = undefined;
 	#gitWatcher: fs.FSWatcher | null = null;
@@ -204,6 +210,11 @@ export class StatusLineComponent implements Component {
 
 	updateSettings(settings: StatusLineSettings): void {
 		this.#settings = settings;
+		this.#effectiveSettings = undefined;
+	}
+
+	getEffectiveSettingsForTest(): EffectiveStatusLineSettings {
+		return this.#resolveSettings();
 	}
 
 	setAutoCompactEnabled(enabled: boolean): void {
@@ -594,10 +605,14 @@ export class StatusLineComponent implements Component {
 		};
 	}
 
-	#resolveSettings(): Required<
-		Pick<StatusLineSettings, "leftSegments" | "rightSegments" | "separator" | "segmentOptions">
-	> &
-		StatusLineSettings {
+	#resolveSettings(): EffectiveStatusLineSettings {
+		if (this.#effectiveSettings === undefined) {
+			this.#effectiveSettings = this.#computeEffectiveSettings();
+		}
+		return this.#effectiveSettings;
+	}
+
+	#computeEffectiveSettings(): EffectiveStatusLineSettings {
 		const preset = this.#settings.preset ?? "default";
 		const presetDef = getPreset(preset);
 		const useCustomSegments = preset === "custom";

package/src/modes/components/tips.txt

@@ -9,7 +9,7 @@ Spaghetti code? Try complaining with /omfg
 Did you know? Each kitty/tmux/cmux split keeps its own session — `omp -c` resumes the right one
 Drop the word `ultrathink` in your message for harder multi-step reasoning — watch it glow rainbow as you type
 Say `orchestrate` in your message to drive a multi-phase task with parallel subagents — watch it glow as you type
-Say `workflow` in your message to drive the task with parallel subagents in eval — watch it glow as you type
+Say `workflowz` in your message to drive the task with parallel subagents in eval — watch it glow as you type
 Log in to several accounts of the same provider — `/login` again — and omp load-balances across them automatically
 Run `omp auth-broker serve` once and every machine pulls live tokens over the wire — refresh keys never leave the host; `omp auth-gateway` fronts it as a drop-in proxy any OpenAI-compatible client can hit
 Press alt+p (or /switch) to switch provider, and ctrl+p to cycle role models smol -> slow -> etc

package/src/modes/components/tool-execution.ts

@@ -15,7 +15,6 @@ import {
 } from "@oh-my-pi/pi-tui";
 import { getProjectDir, logger, sanitizeText } from "@oh-my-pi/pi-utils";
 import { EDIT_MODE_STRATEGIES, type EditMode, type PerFileDiffPreview } from "../../edit";
-import { shimmerEnabled } from "../../modes/theme/shimmer";
 import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";
 import { BASH_DEFAULT_PREVIEW_LINES } from "../../tools/bash";
@@ -31,7 +30,7 @@ import {
 	renderJsonTreeLines,
 } from "../../tools/json-tree";
 import { formatExpandHint, replaceTabs, resolveImageOptions, truncateToWidth } from "../../tools/render-utils";
-import { type ToolRenderer, toolRenderers } from "../../tools/renderers";
+import { toolRenderers } from "../../tools/renderers";
 import { TODO_STRIKE_TOTAL_FRAMES } from "../../tools/todo";
 import { isFramedBlockComponent, renderStatusLine } from "../../tui";
 import { sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
@@ -133,9 +132,10 @@ export interface ToolExecutionHandle {
 	setExpanded(expanded: boolean): void;
 }
 
-/** Drive pending-tool redraws at 30fps so the animated border sweep stays
- * smooth without spending twice the frame budget. The TUI throttles at the same
- * cadence, and static frames diff to a no-op redraw at ~zero cost. */
+/** Drive pending-tool redraws at 30fps so the running `task` row's shimmered
+ * subagent name stays smooth without spending twice the frame budget. The TUI
+ * throttles at the same cadence, and static frames diff to a no-op redraw at
+ * ~zero cost. */
 const SPINNER_RENDER_INTERVAL_MS = 1000 / 30;
 /** Advance the spinner glyph at its classic ~12.5fps step, decoupled from the
  * render cadence (mirrors `Loader`). */
@@ -425,16 +425,7 @@ export class ToolExecutionComponent extends Container {
 			(this.#result?.details as { async?: { state?: string } } | undefined)?.async?.state === "running";
 		const isBackgroundAsyncTask = this.#toolName === "task" && isBackgroundAsyncRunning;
 		const isPartialTask = this.#isPartial && this.#toolName === "task" && !isBackgroundAsyncTask;
-		// Sweep the border of bash/eval execution blocks while they're pending — but
-		// not once they've been backgrounded: a backgrounded job's block gets
-		// committed to scrollback and finalizes later via the async update path, so a
-		// mid-sweep frame would freeze a stray dark "bar" segment into the border.
-		const isPendingExecBlock =
-			this.#isPartial &&
-			shimmerEnabled() &&
-			(this.#toolName === "bash" || this.#toolName === "eval") &&
-			!isBackgroundAsyncRunning;
-		const needsSpinner = isStreamingArgs || isPartialTask || isPendingExecBlock;
+		const needsSpinner = isStreamingArgs || isPartialTask;
 		if (needsSpinner && !this.#spinnerInterval) {
 			const now = performance.now();
 			const frameCount = theme.spinnerFrames.length;
@@ -446,7 +437,7 @@ export class ToolExecutionComponent extends Container {
 			this.#spinnerInterval = setInterval(() => {
 				const now = performance.now();
 				const frameCount = theme.spinnerFrames.length;
-				// Redraw at 30fps for a smooth border sweep, but keep the spinner
+				// Redraw at 30fps for a smooth `task` name shimmer, but keep the spinner
 				// glyph phase-locked to its classic ~12.5fps cadence. Advancing the
 				// anchor by elapsed frames instead of resetting to `now` avoids the
 				// 30fps timer quantizing the glyph down to one step every three ticks.
@@ -529,39 +520,6 @@ export class ToolExecutionComponent extends Container {
 		return (this.#result.details as { async?: { state?: string } } | undefined)?.async?.state === "running";
 	}
 
-	/**
-	 * While a tool's preview is still streaming, a block whose preview is
-	 * append-only (rows only grow at the bottom, never re-layout) lets the
-	 * renderer commit the scrolled-off head of an over-tall preview to native
-	 * scrollback instead of dropping it — the same anti-yank path a streaming
-	 * assistant reply uses (see {@link TranscriptContainer} +
-	 * `NativeScrollbackLiveRegion`). Covers both phases: a pre-result call preview
-	 * (a `write` whose content streams in) and a partial-result preview that
-	 * streams output below fixed input (an `eval`/`bash` whose stdout grows under
-	 * its code cell). Gated on {@link isTranscriptBlockFinalized} so the boundary
-	 * closes the instant the block reaches a terminal state — a final result that
-	 * may collapse to a compact view, a backgrounded async tool, or a seal — and
-	 * the renderer decides whether its current preview shape qualifies via
-	 * `isStreamingPreviewAppendOnly` (typically: only the expanded full view,
-	 * which is top-anchored; the collapsed tail window re-layouts but is bounded
-	 * so it never overflows anyway).
-	 */
-	isTranscriptBlockAppendOnly(): boolean {
-		// A finalized block's preview can collapse/re-layout; only a live,
-		// still-streaming block is a candidate.
-		if (this.isTranscriptBlockFinalized()) return false;
-		const predicate =
-			(this.#tool as { isStreamingPreviewAppendOnly?: ToolRenderer["isStreamingPreviewAppendOnly"] } | undefined)
-				?.isStreamingPreviewAppendOnly ?? toolRenderers[this.#toolName]?.isStreamingPreviewAppendOnly;
-		if (!predicate) return false;
-		try {
-			return predicate(this.#getCallArgsForRender(), this.#renderState, this.#result);
-		} catch (err) {
-			logger.warn("Tool append-only predicate failed", { tool: this.#toolName, error: String(err) });
-			return false;
-		}
-	}
-
 	/**
 	 * Mark the tool terminal even though no result arrived (the turn aborted or
 	 * abandoned it) and stop animating, so it can freeze and stops pinning the

package/src/modes/components/transcript-container.ts

@@ -6,6 +6,8 @@ interface FrozenRender {
 	width: number;
 	lines: string[];
 	generation: number;
+	appendOnly: boolean;
+	volatile: boolean;
 }
 
 interface SnapshotCarrier {
@@ -17,16 +19,9 @@ interface SnapshotCarrier {
  * result, an assistant message mid-stream) reports `false` so the container
  * keeps it inside the live (repaintable) region instead of freezing it. Blocks
  * without the method are treated as finalized — the default, stable behavior.
- *
- * `isTranscriptBlockAppendOnly` marks a still-live block whose rendered rows
- * only grow at the bottom and never re-layout (a streaming assistant reply).
- * Such a block's scrolled-off head is safe to commit to native scrollback even
- * while live; blocks that omit it (tool previews that collapse to a compact
- * result) keep their mutable rows deferred. Default is `false`.
  */
 interface FinalizableBlock {
 	isTranscriptBlockFinalized?(): boolean;
-	isTranscriptBlockAppendOnly?(): boolean;
 }
 
 function isBlockFinalized(child: Component): boolean {
@@ -34,11 +29,6 @@ function isBlockFinalized(child: Component): boolean {
 	return fn ? fn.call(child) : true;
 }
 
-function isBlockAppendOnly(child: Component): boolean {
-	const fn = (child as Component & FinalizableBlock).isTranscriptBlockAppendOnly;
-	return fn ? fn.call(child) : false;
-}
-
 // A "plain blank" row is empty or whitespace-only with no ANSI bytes. It marks
 // separation padding (a `Spacer`, or a no-background `paddingY` row) as opposed
 // to a background-colored padding row, whose escape sequences contain `\S` and
@@ -59,6 +49,73 @@ function stripPlainBlankEdges(lines: string[]): string[] {
 	return start === 0 && end === lines.length ? lines : lines.slice(start, end);
 }
 
+interface LiveCommitState {
+	appendOnly: boolean;
+	volatile: boolean;
+	safeLength: number;
+}
+
+function hasValidSnapshot(
+	snapshot: FrozenRender | undefined,
+	width: number,
+	generation: number,
+): snapshot is FrozenRender {
+	return snapshot !== undefined && snapshot.generation === generation && snapshot.width === width;
+}
+
+function commonPrefixLength(prev: string[], cur: string[]): number {
+	const limit = Math.min(prev.length, cur.length);
+	let i = 0;
+	while (i < limit && prev[i] === cur[i]) i++;
+	return i;
+}
+
+function commonSuffixLength(prev: string[], cur: string[], prefixLength: number): number {
+	const prevLimit = prev.length - prefixLength;
+	const curLimit = cur.length - prefixLength;
+	const limit = Math.min(prevLimit, curLimit);
+	let i = 0;
+	while (i < limit && prev[prev.length - 1 - i] === cur[cur.length - 1 - i]) i++;
+	return i;
+}
+
+function deriveLiveCommitState(
+	previous: FrozenRender | undefined,
+	current: string[],
+	width: number,
+	generation: number,
+): LiveCommitState {
+	let appendOnly = false;
+	let volatile = false;
+	if (hasValidSnapshot(previous, width, generation)) {
+		appendOnly = previous.appendOnly;
+		volatile = previous.volatile;
+
+		const prefixLength = commonPrefixLength(previous.lines, current);
+		const staticRender = prefixLength === previous.lines.length && prefixLength === current.length;
+		if (!staticRender) {
+			const suffixLength = commonSuffixLength(previous.lines, current, prefixLength);
+			const stablePreviousLength = prefixLength + suffixLength;
+			const appendGrew =
+				previous.lines.length > 0 &&
+				current.length > previous.lines.length &&
+				stablePreviousLength >= previous.lines.length;
+			if (appendGrew && !volatile) {
+				appendOnly = true;
+			} else if (stablePreviousLength < previous.lines.length) {
+				volatile = true;
+				appendOnly = false;
+			}
+		}
+	}
+
+	return {
+		appendOnly,
+		volatile,
+		safeLength: volatile ? 0 : appendOnly ? current.length : 0,
+	};
+}
+
 /**
  * Transcript container that freezes the rendered output of every block except
  * the bottom-most (live) one on terminals where committed native scrollback is
@@ -97,11 +154,10 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 	// render. TUI extends the native-scrollback pinned region from this point
 	// through the live blocks and the root chrome rendered below them.
 	#nativeScrollbackLiveRegionStart: number | undefined;
-	// Local line index up to which the leading run of live blocks is append-only
-	// (a streaming assistant reply): everything in [liveRegionStart,
-	// commitSafeEnd) only grows at the bottom and never re-layouts, so its
-	// scrolled-off head is safe to commit to native scrollback. `undefined` when
-	// the first live block is volatile (a tool preview).
+	// Local line index up to which the leading run of live blocks is safe to
+	// commit. Finalized blocks contribute their full frozen body; still-live
+	// blocks contribute only after their stripped render has been observed
+	// growing without changing a previously rendered interior row.
 	#nativeScrollbackCommitSafeEnd: number | undefined;
 
 	override invalidate(): void {
@@ -164,8 +220,9 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 		if (risk) this.#prevLiveStartIndex = liveStartIndex;
 
 		const lines: string[] = [];
-		// Tracks whether we are still inside the leading run of append-only live
-		// blocks. The first non-append-only live block closes it.
+		// Tracks whether we are still inside the leading run of commit-safe live
+		// blocks. The first still-live volatile block closes it, but rendering
+		// continues so lower blocks remain visible.
 		let commitSafeOpen = true;
 		// The live-region start is recorded at the first visible row at/after the
 		// cutoff; empty leading blocks (or a separator) must not claim it early.
@@ -179,24 +236,41 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 			// instead of recomputing; a stale generation (post-thaw) or width
 			// mismatch (resize) recomputes, as does a block still live last frame.
 			let contribution: string[] | undefined;
+			const previousSnapshot = risk ? child[kSnapshot] : undefined;
 			if (risk && i < liveStartIndex && i < replayCutoff) {
-				const snapshot = child[kSnapshot];
-				if (snapshot && snapshot.generation === this.#generation && snapshot.width === width) {
-					contribution = snapshot.lines;
+				if (hasValidSnapshot(previousSnapshot, width, this.#generation)) {
+					contribution = previousSnapshot.lines;
 				}
 			}
+			let liveCommitState: LiveCommitState | undefined;
 			if (contribution === undefined) {
 				const rendered = child.render(width);
 				contribution = stripPlainBlankEdges(rendered);
+				if (risk && i >= liveStartIndex && !isBlockFinalized(child)) {
+					liveCommitState = deriveLiveCommitState(previousSnapshot, contribution, width, this.#generation);
+				}
 				// Cache every block's latest contribution. While a block is in the
 				// live region this keeps its snapshot current; on the frame it crosses
 				// out, the recompute above refreshes it before it freezes.
-				if (risk) child[kSnapshot] = { width, lines: contribution, generation: this.#generation };
+				if (risk) {
+					child[kSnapshot] = {
+						width,
+						lines: contribution,
+						generation: this.#generation,
+						appendOnly: liveCommitState?.appendOnly ?? false,
+						volatile: liveCommitState?.volatile ?? false,
+					};
+				}
 			}
 
 			// Empty (or stripped-to-nothing) children contribute nothing and never
-			// affect spacing or the live-region offsets.
-			if (contribution.length === 0) continue;
+			// affect spacing or the live-region offsets. An empty still-live child
+			// still closes the commit-safe run: if it later gains rows, it pushes
+			// everything below it.
+			if (contribution.length === 0) {
+				if (risk && i >= liveStartIndex && commitSafeOpen && !isBlockFinalized(child)) commitSafeOpen = false;
+				continue;
+			}
 
 			// Every block is separated from preceding visible content by exactly one
 			// blank row — skipped when it opens the transcript or the prior row is
@@ -212,17 +286,19 @@ export class TranscriptContainer extends Container implements NativeScrollbackLi
 			}
 
 			if (sep) lines.push("");
+			const blockStart = lines.length;
 			for (let j = 0; j < contribution.length; j++) lines.push(contribution[j]!);
 
-			// Extend the commit-safe boundary through each leading append-only live
-			// block. The first volatile live block closes the run so its mutable
-			// rows stay deferred.
 			if (risk && i >= liveStartIndex && commitSafeOpen) {
-				if (isBlockAppendOnly(child)) {
-					this.#nativeScrollbackCommitSafeEnd = lines.length;
-				} else {
-					commitSafeOpen = false;
+				const finalized = isBlockFinalized(child);
+				const safeLength = finalized ? contribution.length : (liveCommitState?.safeLength ?? 0);
+				if (safeLength > 0) {
+					this.#nativeScrollbackCommitSafeEnd = blockStart + safeLength;
 				}
+				// A finalized, fully safe block may let the contiguous safe run extend
+				// into blocks rendered below it. A still-live block keeps pushing lower
+				// rows around as it grows, so the run closes there.
+				if (!(finalized && safeLength >= contribution.length)) commitSafeOpen = false;
 			}
 		}
 		return lines;

package/src/modes/components/user-message.ts

@@ -15,7 +15,7 @@ export class UserMessageComponent extends Container {
 	constructor(text: string, synthetic = false, imageLinks?: readonly (string | undefined)[]) {
 		super();
 		const bgColor = (value: string) => theme.bg("userMessageBg", value);
-		// Paint the magic keywords ("ultrathink"/"orchestrate"/"workflow") inside the rendered
+		// Paint the magic keywords ("ultrathink"/"orchestrate"/"workflowz") inside the rendered
 		// bubble too — matching the live editor glow. The Markdown component routes code spans and
 		// fenced blocks through its own code styling (never `color`), so those are already excluded;
 		// `highlightMagicKeywords` additionally restores the bubble's own foreground after each

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

@@ -26,6 +26,16 @@ type AgentSessionEventKind = AgentSessionEvent["type"];
 
 const IRC_MESSAGE_VISIBLE_TTL_MS = 10_000;
 
+/**
+ * Loader label shown the instant a user interrupt (Esc) is requested, kept until
+ * the agent turn fully unwinds. Esc fires the abort synchronously, but the loop
+ * only stops the spinner at `agent_end`, which it cannot reach until every
+ * in-flight tool settles its abort in `executeToolCalls` (`Promise.allSettled`).
+ * Swapping the steady "Working…" for this acknowledges the keypress instead of
+ * reading as an ignored Esc for the seconds a slow tool takes to tear down.
+ */
+export const INTERRUPTING_WORKING_MESSAGE = "Interrupting…";
+
 // Events that change foreground streaming state, or that reset a turn. The TUI
 // eager native-scrollback rebuild mode is recomputed only on these so unrelated
 // IRC/notices/status refreshes do not toggle scrollback replay policy.
@@ -57,6 +67,7 @@ export class EventController {
 	#backgroundToolCallIds = new Set<string>();
 	#assistantMessageStreaming = false;
 	#agentTurnActive = false;
+	#interrupting = false;
 	#readToolCallArgs = new Map<string, Record<string, unknown>>();
 	#readToolCallAssistantComponents = new Map<string, AssistantMessageComponent>();
 	#lastAssistantComponent: AssistantMessageComponent | undefined = undefined;
@@ -167,6 +178,7 @@ export class EventController {
 		return true;
 	}
 	#updateWorkingMessageFromIntent(intent: unknown): void {
+		if (this.#interrupting) return;
 		// Streamed JSON can deliver non-string `_i` (object, number, boolean) before
 		// schema validation; `?.` only guards null/undefined, so guard the type too.
 		if (typeof intent !== "string") return;
@@ -176,6 +188,19 @@ export class EventController {
 		this.ctx.setWorkingMessage(`${trimmed}${interruptHint()}`);
 	}
 
+	/**
+	 * Acknowledge a user interrupt (Esc) immediately: switch the loader to
+	 * `INTERRUPTING_WORKING_MESSAGE` and freeze intent-driven working-message
+	 * updates for the rest of the turn so a late `tool_execution_start` intent
+	 * cannot repaint a "Working…/<intent>" line over the acknowledgment. Reset at
+	 * the next `agent_start`. No-op outside an active turn or if already set.
+	 */
+	notifyInterrupting(): void {
+		if (!this.#agentTurnActive || this.#interrupting) return;
+		this.#interrupting = true;
+		this.ctx.setWorkingMessage(INTERRUPTING_WORKING_MESSAGE);
+	}
+
 	subscribeToAgent(): void {
 		this.ctx.unsubscribe = this.ctx.session.subscribe(async (event: AgentSessionEvent) => {
 			await this.handleEvent(event);
@@ -220,6 +245,7 @@ export class EventController {
 
 	async #handleAgentStart(_event: Extract<AgentSessionEvent, { type: "agent_start" }>): Promise<void> {
 		this.#agentTurnActive = true;
+		this.#interrupting = false;
 		this.#lastIntent = undefined;
 		this.#readToolCallArgs.clear();
 		this.#readToolCallAssistantComponents.clear();
@@ -694,7 +720,12 @@ export class EventController {
 				// seal it so it freezes (and stops animating) rather than lingering in
 				// the transcript live region as a streaming preview until the next thaw.
 				const component = this.ctx.pendingTools.get(toolCallId);
-				if (component instanceof ToolExecutionComponent) component.seal();
+				// A foreground read still pending at turn end shares a group component
+				// keyed by every read's id; seal it too so a never-delivered read does
+				// not keep the group live (and pinning the live region) indefinitely.
+				if (component instanceof ToolExecutionComponent || component instanceof ReadToolGroupComponent) {
+					component.seal();
+				}
 				this.ctx.pendingTools.delete(toolCallId);
 			}
 		}