@oh-my-pi/pi-coding-agent 15.10.12 → 15.11.0

package/src/modes/components/compaction-summary-message.ts

@@ -1,51 +1,87 @@
-import { Box, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
+import { Box, type Component, Markdown } from "@oh-my-pi/pi-tui";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
 import type { CompactionSummaryMessage } from "../../session/messages";
 
 /**
- * Component that renders a compaction message with collapsed/expanded state.
- * Uses same background color as hook messages for visual consistency.
+ * Compaction point in the transcript, rendered as a slim horizontal divider:
+ *
+ *   ──────── 📷 compacted · ctrl+o ────────
+ *
+ * The conversation above the divider stays visible (display transcript keeps
+ * full history); only the LLM context was reset. Expanding (ctrl+o) reveals
+ * the compaction summary below the divider.
  */
-export class CompactionSummaryMessageComponent extends Box {
+export class CompactionSummaryMessageComponent implements Component {
 	#expanded = false;
+	#cache?: { width: number; lines: string[] };
+	#detail?: Box;
 
-	constructor(private readonly message: CompactionSummaryMessage) {
-		super(1, 1, t => theme.bg("customMessageBg", t));
-		this.#updateDisplay();
-	}
+	constructor(private readonly message: CompactionSummaryMessage) {}
 
 	setExpanded(expanded: boolean): void {
+		if (this.#expanded === expanded) return;
 		this.#expanded = expanded;
-		this.#updateDisplay();
+		this.#cache = undefined;
 	}
 
-	override invalidate(): void {
-		super.invalidate();
-		this.#updateDisplay();
+	invalidate(): void {
+		this.#cache = undefined;
+		// Theme may have changed — rebuild the detail box lazily on next render.
+		this.#detail = undefined;
 	}
 
-	#updateDisplay(): void {
-		this.clear();
+	render(width: number): readonly string[] {
+		width = Math.max(1, width);
+		if (this.#cache?.width === width) {
+			return this.#cache.lines;
+		}
+		const lines = this.#expanded
+			? ["", this.#divider(width), "", ...this.#detailBox().render(width)]
+			: ["", this.#divider(width), ""];
+		this.#cache = { width, lines };
+		return lines;
+	}
 
-		const tokenStr = this.message.tokensBefore.toLocaleString();
-		const label = theme.fg("customMessageLabel", theme.bold("[compaction]"));
-		this.addChild(new Text(label, 0, 0));
-		this.addChild(new Spacer(1));
+	#divider(width: number): string {
+		const rule = theme.tree.horizontal;
+		const label = `${theme.icon.camera} compacted`;
+		// sep.dot ships pre-padded (" · "); trim so the hint joins with single spaces.
+		const hint = `${theme.sep.dot.trim()} ctrl+o`;
+		const plainWidth = Bun.stringWidth(`${label} ${hint}`, { countAnsiEscapeCodes: false });
+		// ` label hint ` framed by rules on both sides.
+		const remaining = width - plainWidth - 2;
+		if (remaining < 4) {
+			// Too narrow for a framed rule — emit the bare label.
+			return theme.fg("muted", label);
+		}
+		const left = Math.floor(remaining / 2);
+		const right = remaining - left;
+		return (
+			theme.fg("dim", rule.repeat(left)) +
+			` ${theme.fg("muted", label)} ${theme.fg("dim", hint)} ` +
+			theme.fg("dim", rule.repeat(right))
+		);
+	}
 
-		if (this.#expanded) {
-			const header = `**Compacted from ${tokenStr} tokens**\n\n`;
-			this.addChild(
-				new Markdown(header + this.message.summary, 0, 0, getMarkdownTheme(), {
+	#detailBox(): Box {
+		if (this.#detail) return this.#detail;
+		const box = new Box(1, 1, t => theme.bg("customMessageBg", t));
+		const tokenStr = this.message.tokensBefore.toLocaleString();
+		const frameCount = this.message.images?.length ?? 0;
+		const frameNote =
+			frameCount > 0 ? `\n\n_${frameCount} snapcompact frame${frameCount === 1 ? "" : "s"} attached_` : "";
+		box.addChild(
+			new Markdown(
+				`**Compacted from ${tokenStr} tokens**\n\n${this.message.summary}${frameNote}`,
+				0,
+				0,
+				getMarkdownTheme(),
+				{
 					color: (text: string) => theme.fg("customMessageText", text),
-				}),
-			);
-		} else {
-			this.addChild(
-				new Text(theme.fg("customMessageText", `Compacted from ${tokenStr} tokens (ctrl+o to expand)`), 0, 0),
-			);
-			if (this.message.shortSummary) {
-				this.addChild(new Text(theme.fg("customMessageText", this.message.shortSummary), 0, 1));
-			}
-		}
+				},
+			),
+		);
+		this.#detail = box;
+		return box;
 	}
 }

package/src/modes/components/custom-editor.ts

@@ -175,6 +175,8 @@ export class CustomEditor extends Editor {
 	onDequeue?: () => void;
 	/** Called when Caps Lock is pressed. */
 	onCapsLock?: () => void;
+	/** Called when left-arrow is pressed while the editor is empty (cursor necessarily at start). */
+	onLeftAtStart?: () => void;
 
 	/** Custom key handlers from extensions and non-built-in app actions. */
 	#customKeyHandlers = new Map<KeyId, () => void>();
@@ -257,6 +259,14 @@ export class CustomEditor extends Editor {
 		const parsedKey = parseKey(data);
 		const canonical = parsedKey !== undefined ? canonicalKeyId(parsedKey) : undefined;
 
+		// Left-arrow on an empty editor: surface for the agent-hub double-tap
+		// gesture. Plain "left" only — modified arrows and any in-text cursor
+		// movement fall through to normal handling.
+		if (canonical === "left" && this.onLeftAtStart && this.getText().trim() === "") {
+			this.onLeftAtStart();
+			return;
+		}
+
 		if (canonical !== undefined) {
 			// Intercept configured image paste (async - fires and handles result)
 			if (this.#matchesAction(canonical, "app.clipboard.pasteImage") && this.onPasteImage) {

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

@@ -19,6 +19,7 @@ import type { Theme } from "../../modes/theme/theme";
 import { theme } from "../../modes/theme/theme";
 import { BASH_DEFAULT_PREVIEW_LINES } from "../../tools/bash";
 import { EVAL_DEFAULT_PREVIEW_LINES } from "../../tools/eval";
+import { isWaitingPollDetails } from "../../tools/job";
 import {
 	formatArgsInline,
 	JSON_TREE_MAX_DEPTH_COLLAPSED,
@@ -194,6 +195,11 @@ export class ToolExecutionComponent extends Container {
 	// sealed the block stays in the transcript's repaintable live region so a
 	// late result still repaints instead of stranding the streaming preview.
 	#sealed = false;
+	// A `job` poll result whose watched jobs are all still running. Such a
+	// block never finalizes (stays in the transcript live region) so a
+	// follow-up `job` call can displace it instead of stacking another
+	// "waiting on N jobs" frame. Cleared by `seal()`.
+	#displaceable = false;
 	#renderState: {
 		spinnerFrame?: number;
 		expanded: boolean;
@@ -359,6 +365,11 @@ export class ToolExecutionComponent extends Container {
 	): void {
 		this.#result = result;
 		this.#isPartial = isPartial;
+		// A `job` poll that found every watched job still running is transient
+		// "still waiting" chrome; keep the block displaceable so the next `job`
+		// call replaces it instead of stacking another waiting frame (see the
+		// event controller's displaceable-poll bookkeeping).
+		this.#displaceable = this.#toolName === "job" && result.isError !== true && isWaitingPollDetails(result.details);
 		// When tool is complete, ensure args are marked complete so spinner stops
 		if (!isPartial) {
 			this.#argsComplete = true;
@@ -425,7 +436,11 @@ 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;
-		const needsSpinner = isStreamingArgs || isPartialTask;
+		// A displaceable waiting poll keeps its spinner ticking: it reads as one
+		// persistent live poll, and the changing leading glyph keeps the
+		// transcript's stable-prefix ratchet from committing rows of a block
+		// that a follow-up `job` call may remove.
+		const needsSpinner = isStreamingArgs || isPartialTask || this.isDisplaceableBlock();
 		if (needsSpinner && !this.#spinnerInterval) {
 			const now = performance.now();
 			const frameCount = theme.spinnerFrames.length;
@@ -513,6 +528,9 @@ export class ToolExecutionComponent extends Container {
 	isTranscriptBlockFinalized(): boolean {
 		if (this.#sealed) return true;
 		if (this.#result === undefined) return false;
+		// A displaceable waiting poll stays live: its rows are kept out of
+		// native scrollback so a follow-up `job` call can remove the block.
+		if (this.#displaceable) return false;
 		if (!this.#isPartial) return true;
 		// Partial result: a background async tool is accepted to freeze (the agent
 		// continues while it runs and would otherwise pin an unbounded live region);
@@ -528,11 +546,23 @@ export class ToolExecutionComponent extends Container {
 	seal(): void {
 		if (this.#sealed) return;
 		this.#sealed = true;
+		this.#displaceable = false;
 		this.stopAnimation();
 		this.#updateDisplay();
 		this.#ui.requestRender();
 	}
 
+	/**
+	 * Whether this block is a waiting `job` poll (every watched job still
+	 * running) that has not been sealed. Such a block never finalized, so none
+	 * of its rows entered native scrollback (the ticking spinner keeps the
+	 * stable-prefix ratchet at zero) and the whole block can be removed when a
+	 * follow-up `job` call supersedes it.
+	 */
+	isDisplaceableBlock(): boolean {
+		return this.#displaceable && !this.#sealed;
+	}
+
 	/**
 	 * Stop spinner animation and cleanup resources.
 	 */

package/src/modes/components/ttsr-notification.ts

@@ -2,16 +2,24 @@ import { Box, Container, Spacer, Text } from "@oh-my-pi/pi-tui";
 import type { Rule } from "../../capability/rule";
 import { theme } from "../../modes/theme/theme";
 
+/** Collapsed view shows at most this many rules before eliding the rest. */
+const MAX_COLLAPSED_RULES = 4;
+
 /**
  * Component that renders a TTSR (Time Traveling Stream Rules) notification.
  * Shows when a rule violation is detected and the stream is being rewound.
+ * One block can carry several rules: a single event may match multiple rules,
+ * and consecutive notifications merge into the previous block via
+ * {@link addRules} while it is still the live transcript tail.
  */
 export class TtsrNotificationComponent extends Container {
 	#box: Box;
 	#expanded = false;
+	#rules: Rule[];
 
-	constructor(private readonly rules: Rule[]) {
+	constructor(rules: Rule[]) {
 		super();
+		this.#rules = [...rules];
 
 		this.addChild(new Spacer(1));
 
@@ -22,6 +30,17 @@ export class TtsrNotificationComponent extends Container {
 		this.#rebuild();
 	}
 
+	/** Merge additional rules into this block (deduped by rule name). */
+	addRules(rules: Rule[]): void {
+		let changed = false;
+		for (const rule of rules) {
+			if (this.#rules.some(existing => existing.name === rule.name)) continue;
+			this.#rules.push(rule);
+			changed = true;
+		}
+		if (changed) this.#rebuild();
+	}
+
 	setExpanded(expanded: boolean): void {
 		if (this.#expanded !== expanded) {
 			this.#expanded = expanded;
@@ -35,46 +54,69 @@ export class TtsrNotificationComponent extends Container {
 
 	#rebuild(): void {
 		this.#box.clear();
+		// fg colors conflict with inverse, so styling inside the block is limited
+		// to bold (names) and italic (descriptions).
+		if (this.#rules.length === 1) {
+			this.#rebuildSingle(this.#rules[0]!);
+		} else {
+			this.#rebuildMulti();
+		}
+	}
 
-		// Build header: warning symbol + rule name + rewind icon
-		const ruleNames = this.rules.map(r => theme.bold(r.name)).join(", ");
-		const label = this.rules.length === 1 ? "rule" : "rules";
-		const header = `${theme.icon.warning} Injecting ${label}: ${ruleNames}`;
+	#rebuildSingle(rule: Rule): void {
+		const header = `${theme.icon.warning} Injecting rule: ${theme.bold(rule.name)}  ${theme.icon.rewind}`;
+		this.#box.addChild(new Text(header, 0, 0));
 
-		// Create header with rewind icon on the right
-		const rewindIcon = theme.icon.rewind;
+		const desc = (rule.description || rule.content)?.trim();
+		if (!desc) return;
 
-		this.#box.addChild(new Text(`${header}  ${rewindIcon}`, 0, 0));
+		let displayText = desc;
+		let truncated = false;
+		if (!this.#expanded) {
+			const lines = desc.split("\n");
+			if (lines.length > 2) {
+				displayText = `${lines.slice(0, 2).join("\n")}…`;
+				truncated = true;
+			}
+		}
 
-		// Show description(s) - italic and truncated
-		for (const rule of this.rules) {
-			const desc = rule.description || rule.content;
-			if (desc) {
-				this.#box.addChild(new Spacer(1));
+		this.#box.addChild(new Spacer(1));
+		this.#box.addChild(new Text(theme.italic(displayText), 0, 0));
+		if (truncated) {
+			this.#box.addChild(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
+		}
+	}
+
+	#rebuildMulti(): void {
+		const header = `${theme.icon.warning} Injecting ${this.#rules.length} rules:  ${theme.icon.rewind}`;
+		this.#box.addChild(new Text(header, 0, 0));
+		this.#box.addChild(new Spacer(1));
 
-				let displayText = desc.trim();
+		const visible = this.#expanded ? this.#rules : this.#rules.slice(0, MAX_COLLAPSED_RULES);
+		let elidedDetail = false;
+		for (const rule of visible) {
+			const desc = (rule.description || rule.content)?.trim();
+			let line = theme.bold(rule.name);
+			if (desc) {
+				let displayText = desc;
 				if (!this.#expanded) {
-					// Truncate to first 2 lines
-					const lines = displayText.split("\n");
-					if (lines.length > 2) {
-						displayText = `${lines.slice(0, 2).join("\n")}…`;
+					// One line per rule when collapsed; full description when expanded.
+					const newline = desc.indexOf("\n");
+					if (newline !== -1) {
+						displayText = `${desc.slice(0, newline).trimEnd()}…`;
+						elidedDetail = true;
 					}
 				}
-
-				// Use italic for subtle distinction (fg colors conflict with inverse)
-				this.#box.addChild(new Text(theme.italic(displayText), 0, 0));
+				line += `: ${theme.italic(displayText)}`;
 			}
+			this.#box.addChild(new Text(line, 0, 0));
 		}
 
-		// Show expand hint if collapsed and there's more content
-		if (!this.#expanded) {
-			const hasMoreContent = this.rules.some(r => {
-				const desc = r.description || r.content;
-				return desc && desc.split("\n").length > 2;
-			});
-			if (hasMoreContent) {
-				this.#box.addChild(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
-			}
+		const hidden = this.#rules.length - visible.length;
+		if (hidden > 0) {
+			this.#box.addChild(new Text(theme.italic(`… +${hidden} more (ctrl+o to expand)`), 0, 0));
+		} else if (elidedDetail) {
+			this.#box.addChild(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
 		}
 	}
 }

package/src/modes/components/welcome.ts

@@ -18,14 +18,8 @@ const TIPS: readonly string[] = tipsText
 	.filter(line => line.length > 0);
 
 /**
- * Tip chosen once per process so the pre-TUI startup splash and the in-TUI
- * welcome screen show the same tip instead of shuffling on the swap.
- */
-const PROCESS_TIP: string | undefined = TIPS.length > 0 ? TIPS[Math.floor(Math.random() * TIPS.length)] : undefined;
-
-/**
- * Fixed number of session rows in the welcome box so its height doesn't shift
- * between the pre-TUI splash (loading placeholder) and the loaded state.
+ * Fixed number of session rows in the welcome box so its height stays stable
+ * across recent-session updates.
  */
 export const WELCOME_SESSION_SLOTS = 4;
 
@@ -76,10 +70,8 @@ export interface LspServerInfo {
 export class WelcomeComponent implements Component {
 	#animStart: number | null = null;
 	#animTimer: ReturnType<typeof setInterval> | null = null;
-	/** When set, a non-animating render shows the intro's first frame instead of the resting frame. */
-	#holdIntroFirstFrame = false;
-	/** Per-process tip so re-renders (intro, LSP updates, splash swap) don't shuffle it. */
-	readonly #tip: string | undefined = PROCESS_TIP;
+	/** Tip chosen once per instance so re-renders (intro, LSP updates) don't shuffle it. */
+	readonly #tip: string | undefined = TIPS.length > 0 ? TIPS[Math.floor(Math.random() * TIPS.length)] : undefined;
 	// Render cache: the welcome box is the first transcript-area component, so
 	// returning a stable array reference keeps the whole frame prefix stable.
 	// Bypassed while the intro animation runs (every frame differs).
@@ -90,7 +82,7 @@ export class WelcomeComponent implements Component {
 		private readonly version: string,
 		private modelName: string,
 		private providerName: string,
-		private recentSessions: RecentSession[] | null = [],
+		private recentSessions: RecentSession[] = [],
 		private lspServers: LspServerInfo[] = [],
 	) {}
 
@@ -99,16 +91,6 @@ export class WelcomeComponent implements Component {
 		this.#cachedLines = undefined;
 	}
 
-	/**
-	 * Freeze the logo on the intro animation's first frame. The pre-TUI startup
-	 * splash uses this so the in-TUI intro — which starts at that exact frame —
-	 * picks up seamlessly from the splash's static box.
-	 */
-	holdIntroFirstFrame(): void {
-		this.#holdIntroFirstFrame = true;
-		this.invalidate();
-	}
-
 	/**
 	 * Play a one-shot intro that sweeps the gradient through every phase
 	 * before settling on the resting frame. Safe to call multiple times —
@@ -116,7 +98,6 @@ export class WelcomeComponent implements Component {
 	 */
 	playIntro(requestRender: () => void): void {
 		this.#stopAnimation();
-		this.#holdIntroFirstFrame = false;
 		this.#animStart = performance.now();
 		requestRender();
 		this.#animTimer = setInterval(() => {
@@ -217,9 +198,7 @@ export class WelcomeComponent implements Component {
 
 		// Recent sessions content
 		const sessionLines: string[] = [];
-		if (this.recentSessions === null) {
-			sessionLines.push(` ${theme.fg("dim", "Loading…")}`);
-		} else if (this.recentSessions.length === 0) {
+		if (this.recentSessions.length === 0) {
 			sessionLines.push(` ${theme.fg("dim", "No recent sessions")}`);
 		} else {
 			// Reserve width for the bullet prefix (" • ") and the trailing " (timeAgo)"
@@ -238,7 +217,7 @@ export class WelcomeComponent implements Component {
 				);
 			}
 		}
-		// Pad to the fixed slot count so the box doesn't grow when sessions load in.
+		// Pad to the fixed slot count so the box height doesn't depend on session count.
 		while (sessionLines.length < WELCOME_SESSION_SLOTS) {
 			sessionLines.push("");
 		}
@@ -377,9 +356,9 @@ export class WelcomeComponent implements Component {
 		return str + padding(width - visLen);
 	}
 
-	/** Pick the logo frame for the current intro phase, or the resting/held frame. */
+	/** Pick the logo frame for the current intro phase, or the resting frame. */
 	#currentLogoFrame(): readonly string[] {
-		if (this.#animStart == null) return this.#holdIntroFirstFrame ? INTRO_FIRST_FRAME : REST_FRAME;
+		if (this.#animStart == null) return REST_FRAME;
 		const elapsed = performance.now() - this.#animStart;
 		if (elapsed >= INTRO_MS) return REST_FRAME;
 		return introLogoFrame(elapsed / INTRO_MS);
@@ -510,8 +489,5 @@ function introLogoFrame(progress: number): string[] {
 	return gradientLogo(PI_LOGO, phase, { strength: shineStrength, pos: shinePos });
 }
 
-/** First intro frame, cached for splash-held renders (resize re-renders reuse it). */
-const INTRO_FIRST_FRAME = introLogoFrame(0);
-
 /** Resting gradient frame, cached for re-renders outside of the intro. */
 const REST_FRAME = gradientLogo(PI_LOGO, 0);

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

@@ -77,6 +77,14 @@ export class EventController {
 	// Insertion-ordered IRC cards not yet retired; values are the transcript
 	// components each card contributed (see #retireIrcCard for the guard).
 	#liveIrcCards = new Map<string, Component[]>();
+	// Most recent `job` tool block whose result still had every watched job
+	// running. Kept un-finalized (live) so the next `job` call displaces it —
+	// one persistent poll instead of a stack of "waiting on N jobs" frames —
+	// and sealed in place the moment anything else lands below it.
+	#displaceablePollComponent: ToolExecutionComponent | undefined = undefined;
+	// Most recent TTSR notification block. A new ttsr_triggered event merges its
+	// rules into this block while it is still the (live-region) transcript tail.
+	#lastTtsrNotification: TtsrNotificationComponent | undefined = undefined;
 	#streamingReveal: StreamingRevealController;
 	#handlers: AgentSessionEventHandlers;
 
@@ -282,6 +290,7 @@ export class EventController {
 			const signature = `${textContent}\u0000${imageCount}`;
 
 			this.#resetReadGroup();
+			this.#resolveDisplaceablePoll();
 			const wasOptimistic = this.ctx.optimisticUserMessageSignature === signature;
 			const wasLocallySubmitted = this.ctx.locallySubmittedUserSignatures.delete(signature) || wasOptimistic;
 			if (!wasOptimistic) {
@@ -389,6 +398,28 @@ export class EventController {
 		}
 	}
 
+	/**
+	 * Resolve the pending displaceable poll block before the next block lands.
+	 * A follow-up `job` call displaces it — the stale "waiting on N jobs" frame
+	 * is removed so repeated polls read as one persistent poll — while anything
+	 * else seals it in place as final history. Removal is safe only because a
+	 * displaceable block never finalizes: commits stop at the first live block,
+	 * so none of its rows have entered native scrollback (see
+	 * ToolExecutionComponent.isDisplaceableBlock).
+	 */
+	#resolveDisplaceablePoll(nextToolName?: string): void {
+		const previous = this.#displaceablePollComponent;
+		if (!previous) return;
+		this.#displaceablePollComponent = undefined;
+		if (nextToolName === "job" && previous.isDisplaceableBlock()) {
+			this.ctx.chatContainer.removeChild(previous);
+		}
+		// Sealing stops the waiting-poll spinner and freezes the block (for a
+		// just-removed component it only clears the animation timer).
+		previous.seal();
+		this.ctx.ui.requestRender();
+	}
+
 	async #handleNotice(event: Extract<AgentSessionEvent, { type: "notice" }>): Promise<void> {
 		const message = event.source ? `${event.source}: ${event.message}` : event.message;
 		if (event.level === "error") {
@@ -444,6 +475,7 @@ export class EventController {
 						continue;
 					}
 					if (!readArgsTargetInternalUrl(content.arguments)) {
+						if (!this.ctx.pendingTools.has(content.id)) this.#resolveDisplaceablePoll(content.name);
 						this.#trackReadToolCall(content.id, content.arguments);
 						const component = this.ctx.pendingTools.get(content.id);
 						if (component) {
@@ -465,6 +497,7 @@ export class EventController {
 						? { ...content.arguments, __partialJson: content.partialJson }
 						: content.arguments;
 				if (!this.ctx.pendingTools.has(content.id)) {
+					this.#resolveDisplaceablePoll(content.name);
 					this.#resetReadGroup();
 					const tool = this.ctx.session.getToolByName(content.name);
 					const component = new ToolExecutionComponent(
@@ -561,6 +594,9 @@ export class EventController {
 						component.seal();
 					}
 				}
+				// These calls will never produce a result either, so the tracked
+				// waiting poll cannot be displaced anymore — freeze it in place.
+				this.#resolveDisplaceablePoll();
 			}
 			this.#lastAssistantComponent = this.ctx.streamingComponent;
 			this.#lastAssistantComponent.setUsageInfo(event.message.usage);
@@ -589,6 +625,7 @@ export class EventController {
 	async #handleToolExecutionStart(event: Extract<AgentSessionEvent, { type: "tool_execution_start" }>): Promise<void> {
 		this.#updateWorkingMessageFromIntent(event.intent);
 		if (!this.ctx.pendingTools.has(event.toolCallId)) {
+			this.#resolveDisplaceablePoll(event.toolName);
 			if (event.toolName === "read" && readArgsHaveTarget(event.args) && !readArgsTargetInternalUrl(event.args)) {
 				this.#trackReadToolCall(event.toolCallId, event.args);
 				const component = this.ctx.pendingTools.get(event.toolCallId);
@@ -697,6 +734,14 @@ export class EventController {
 					this.ctx.pendingTools.delete(event.toolCallId);
 					this.#backgroundToolCallIds.delete(event.toolCallId);
 				}
+				if (
+					event.toolName === "job" &&
+					component instanceof ToolExecutionComponent &&
+					component.isDisplaceableBlock()
+				) {
+					// Remember the waiting poll so the next `job` call can displace it.
+					this.#displaceablePollComponent = component;
+				}
 				this.ctx.ui.requestRender();
 			}
 		}
@@ -759,6 +804,9 @@ export class EventController {
 		this.#readToolCallArgs.clear();
 		this.#readToolCallAssistantComponents.clear();
 		this.#resetReadGroup();
+		// The turn is over: nothing else lands this turn, so the waiting poll is
+		// final history — seal it instead of letting its spinner tick while idle.
+		this.#resolveDisplaceablePoll();
 		this.#lastAssistantComponent = undefined;
 		this.ctx.ui.requestRender();
 		this.#scheduleIdleCompaction();
@@ -908,9 +956,26 @@ export class EventController {
 	}
 
 	async #handleTtsrTriggered(event: Extract<AgentSessionEvent, { type: "ttsr_triggered" }>): Promise<void> {
+		// Consecutive notifications (e.g. per-tool matches from one assistant
+		// message) merge into the previous block instead of stacking. Mutating an
+		// existing block is only safe while it sits inside the live region — a
+		// still-mutating block above it means none of its rows have been committed
+		// to native scrollback yet (commits are prefix-only and stop at the first
+		// live block), so the grown block still repaints.
+		const previous = this.#lastTtsrNotification;
+		if (
+			previous &&
+			this.ctx.chatContainer.children.at(-1) === previous &&
+			this.ctx.chatContainer.isWithinLiveRegion(previous)
+		) {
+			previous.addRules(event.rules);
+			this.ctx.ui.requestRender();
+			return;
+		}
 		const component = new TtsrNotificationComponent(event.rules);
 		component.setExpanded(this.ctx.toolOutputExpanded);
 		this.ctx.present(component);
+		this.#lastTtsrNotification = component;
 	}
 
 	async #handleTodoReminder(event: Extract<AgentSessionEvent, { type: "todo_reminder" }>): Promise<void> {