@oh-my-pi/pi-coding-agent 15.7.2 → 15.7.3

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

@@ -1,4 +1,13 @@
-import { type Component, Container, matchesKey, Spacer, Text, truncateToWidth } from "@oh-my-pi/pi-tui";
+import {
+	type Component,
+	Container,
+	extractPrintableText,
+	fuzzyFilter,
+	matchesKey,
+	Spacer,
+	Text,
+	truncateToWidth,
+} from "@oh-my-pi/pi-tui";
 import { theme } from "../../modes/theme/theme";
 import { matchesSelectCancel, matchesSelectDown, matchesSelectUp } from "../../modes/utils/keybinding-matchers";
 import { DynamicBorder } from "./dynamic-border";
@@ -13,6 +22,8 @@ interface UserMessageItem {
  * Custom user message list component with selection
  */
 class UserMessageList implements Component {
+	#filteredMessages: UserMessageItem[];
+	#searchQuery = "";
 	#selectedIndex: number = 0;
 	onSelect?: (entryId: string) => void;
 	onCancel?: () => void;
@@ -20,14 +31,60 @@ class UserMessageList implements Component {
 
 	constructor(private readonly messages: UserMessageItem[]) {
 		// Store messages in chronological order (oldest to newest)
+		this.#filteredMessages = messages;
 		// Start with the last (most recent) message selected
-		this.#selectedIndex = Math.max(0, this.messages.length - 1);
+		this.#selectedIndex = Math.max(0, this.#filteredMessages.length - 1);
 	}
 
 	invalidate(): void {
 		// No cached state to invalidate currently
 	}
 
+	#isSearchEnabled(): boolean {
+		return this.messages.length > this.#maxVisible;
+	}
+
+	#shouldRenderSearchStatus(): boolean {
+		return this.#isSearchEnabled() || this.#searchQuery.length > 0;
+	}
+
+	#renderStatusLine(total: number): string {
+		const selectedCount = total === 0 ? 0 : this.#selectedIndex + 1;
+		const count =
+			this.#searchQuery.trim() && total !== this.messages.length
+				? `${selectedCount}/${total} of ${this.messages.length}`
+				: `${selectedCount}/${total}`;
+		const suffix = this.#searchQuery.trim() ? `  Search: ${this.#searchQuery}` : "  Type to search";
+		return theme.fg("muted", `  (${count})${suffix}`);
+	}
+
+	#setSearchQuery(query: string): void {
+		this.#searchQuery = query;
+		this.#filteredMessages = query.trim()
+			? fuzzyFilter(this.messages, query, message => `${message.text} ${message.timestamp ?? ""}`)
+			: this.messages;
+		this.#selectedIndex = query.trim() ? 0 : Math.max(0, this.#filteredMessages.length - 1);
+	}
+
+	#handleSearchInput(keyData: string): boolean {
+		if (!this.#isSearchEnabled()) return false;
+
+		if (matchesKey(keyData, "backspace")) {
+			if (this.#searchQuery.length === 0) return false;
+			const chars = [...this.#searchQuery];
+			chars.pop();
+			this.#setSearchQuery(chars.join(""));
+			return true;
+		}
+
+		const printableText = extractPrintableText(keyData);
+		if (printableText === undefined) return false;
+		if (this.#searchQuery.length === 0 && printableText.trim().length === 0) return false;
+
+		this.#setSearchQuery(this.#searchQuery + printableText);
+		return true;
+	}
+
 	render(width: number): string[] {
 		const lines: string[] = [];
 
@@ -36,16 +93,19 @@ class UserMessageList implements Component {
 			return lines;
 		}
 
+		const total = this.#filteredMessages.length;
+
 		// Calculate visible range with scrolling
 		const startIndex = Math.max(
 			0,
-			Math.min(this.#selectedIndex - Math.floor(this.#maxVisible / 2), this.messages.length - this.#maxVisible),
+			Math.min(this.#selectedIndex - Math.floor(this.#maxVisible / 2), total - this.#maxVisible),
 		);
-		const endIndex = Math.min(startIndex + this.#maxVisible, this.messages.length);
+		const endIndex = Math.min(startIndex + this.#maxVisible, total);
 
 		// Render visible messages (2 lines per message + blank line)
 		for (let i = startIndex; i < endIndex; i++) {
-			const message = this.messages[i];
+			const message = this.#filteredMessages[i];
+			if (!message) continue;
 			const isSelected = i === this.#selectedIndex;
 
 			// Normalize message to single line
@@ -60,44 +120,59 @@ class UserMessageList implements Component {
 			lines.push(messageLine);
 
 			// Second line: metadata (position in history)
-			const position = i + 1;
+			const position = this.messages.indexOf(message) + 1;
 			const metadata = `  Message ${position} of ${this.messages.length}`;
 			const metadataLine = theme.fg("muted", metadata);
 			lines.push(metadataLine);
 			lines.push(""); // Blank line between messages
 		}
 
-		// Add scroll indicator if needed
-		if (startIndex > 0 || endIndex < this.messages.length) {
-			const scrollInfo = theme.fg("muted", `  (${this.#selectedIndex + 1}/${this.messages.length})`);
-			lines.push(scrollInfo);
+		if (total === 0) {
+			lines.push(theme.fg("muted", "  No matching messages"));
+		}
+
+		// Add scroll/search indicator if needed
+		if (startIndex > 0 || endIndex < total || this.#shouldRenderSearchStatus()) {
+			lines.push(this.#renderStatusLine(total));
 		}
 
 		return lines;
 	}
 
 	handleInput(keyData: string): void {
+		// Escape / cancel
+		if (matchesSelectCancel(keyData)) {
+			if (this.onCancel) {
+				this.onCancel();
+			}
+			return;
+		}
+
+		if (this.#handleSearchInput(keyData)) {
+			return;
+		}
+
 		// Up arrow - go to previous (older) message, wrap to bottom when at top
 		if (matchesSelectUp(keyData)) {
-			this.#selectedIndex = this.#selectedIndex === 0 ? this.messages.length - 1 : this.#selectedIndex - 1;
+			if (this.#filteredMessages.length > 0) {
+				this.#selectedIndex =
+					this.#selectedIndex === 0 ? this.#filteredMessages.length - 1 : this.#selectedIndex - 1;
+			}
 		}
 		// Down arrow - go to next (newer) message, wrap to top when at bottom
 		else if (matchesSelectDown(keyData)) {
-			this.#selectedIndex = this.#selectedIndex === this.messages.length - 1 ? 0 : this.#selectedIndex + 1;
+			if (this.#filteredMessages.length > 0) {
+				this.#selectedIndex =
+					this.#selectedIndex === this.#filteredMessages.length - 1 ? 0 : this.#selectedIndex + 1;
+			}
 		}
 		// Enter - select message and branch
 		else if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
-			const selected = this.messages[this.#selectedIndex];
+			const selected = this.#filteredMessages[this.#selectedIndex];
 			if (selected && this.onSelect) {
 				this.onSelect(selected.id);
 			}
 		}
-		// Escape / cancel
-		else if (matchesSelectCancel(keyData)) {
-			if (this.onCancel) {
-				this.onCancel();
-			}
-		}
 	}
 }
 

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

@@ -1,5 +1,6 @@
 import { Container, Markdown, Spacer } from "@oh-my-pi/pi-tui";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
+import { highlightMagicKeywords } from "../magic-keywords";
 
 // OSC 133 shell integration: marks prompt zones for terminal multiplexers
 const OSC133_ZONE_START = "\x1b]133;A\x07";
@@ -13,9 +14,15 @@ export class UserMessageComponent extends Container {
 	constructor(text: string, synthetic = false) {
 		super();
 		const bgColor = (value: string) => theme.bg("userMessageBg", value);
+		// Paint the magic keywords ("ultrathink"/"orchestrate"/"workflow") 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
+		// painted keyword so the gradient never bleeds into the rest of the line.
+		const keywordReset = theme.getFgAnsi("userMessageText") || "\x1b[39m";
 		const color = synthetic
 			? (value: string) => theme.fg("dim", value)
-			: (value: string) => theme.fg("userMessageText", value);
+			: (value: string) => theme.fg("userMessageText", highlightMagicKeywords(value, keywordReset));
 		this.addChild(new Spacer(1));
 		this.addChild(
 			new Markdown(text, 1, 1, getMarkdownTheme(), {

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

@@ -39,6 +39,7 @@ import { buildToolsMarkdown } from "../../modes/utils/tools-markdown";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage } from "../../session/auth-storage";
 import type { NewSessionOptions } from "../../session/session-manager";
+import { formatShakeSummary, type ShakeMode, type ShakeResult } from "../../session/shake-types";
 import { outputMeta } from "../../tools/output-meta";
 import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
 import { replaceTabs } from "../../tools/render-utils";
@@ -1122,6 +1123,62 @@ export class CommandController {
 		return this.executeCompaction(customInstructions, false);
 	}
 
+	/**
+	 * TUI handler for `/shake`. `elide`/`images` are instant structural drops;
+	 * `summary` runs the local on-device compressor behind a cancelable loader
+	 * (Esc aborts via `abortCompaction`). Rebuilds the chat and reports counts.
+	 */
+	async handleShakeCommand(mode: ShakeMode): Promise<void> {
+		let result: ShakeResult;
+		if (mode === "summary") {
+			if (this.ctx.loadingAnimation) {
+				this.ctx.loadingAnimation.stop();
+				this.ctx.loadingAnimation = undefined;
+			}
+			this.ctx.statusContainer.clear();
+			const originalOnEscape = this.ctx.editor.onEscape;
+			this.ctx.editor.onEscape = () => {
+				this.ctx.session.abortCompaction();
+			};
+			const loader = new Loader(
+				this.ctx.ui,
+				spinner => theme.fg("accent", spinner),
+				text => theme.fg("muted", text),
+				"Shaking context (summary)… (esc to cancel)",
+				getSymbolTheme().spinnerFrames,
+			);
+			this.ctx.statusContainer.addChild(loader);
+			this.ctx.ui.requestRender();
+			try {
+				result = await this.ctx.session.shake("summary");
+			} catch (error) {
+				this.ctx.showError(`Shake failed: ${error instanceof Error ? error.message : String(error)}`);
+				return;
+			} finally {
+				loader.stop();
+				this.ctx.statusContainer.clear();
+				this.ctx.editor.onEscape = originalOnEscape;
+			}
+		} else {
+			try {
+				result = await this.ctx.session.shake(mode);
+			} catch (error) {
+				this.ctx.showError(`Shake failed: ${error instanceof Error ? error.message : String(error)}`);
+				return;
+			}
+		}
+
+		const dropped = result.toolResultsDropped + result.blocksDropped + (result.imagesDropped ?? 0);
+		if (dropped === 0) {
+			this.ctx.showStatus("Nothing to shake.");
+			return;
+		}
+		this.ctx.rebuildChatFromMessages();
+		this.ctx.statusLine.invalidate();
+		this.ctx.updateEditorTopBorder();
+		this.ctx.showStatus(formatShakeSummary(result));
+	}
+
 	async handleSkillCommand(skillPath: string, args: string): Promise<void> {
 		try {
 			const content = await Bun.file(skillPath).text();

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

@@ -25,6 +25,17 @@ type AgentSessionEventKind = AgentSessionEvent["type"];
 
 const IRC_MESSAGE_VISIBLE_TTL_MS = 10_000;
 
+// Events that change which foreground tools are executing, or that reset a turn.
+// The eager native-scrollback rebuild mode is recomputed only on these — other
+// events (assistant text streaming, IRC, notices) leave it untouched so plain
+// streaming keeps the no-yank deferral.
+const TOOL_RENDER_MODE_EVENTS: Record<string, true> = {
+	agent_start: true,
+	tool_execution_start: true,
+	tool_execution_update: true,
+	tool_execution_end: true,
+};
+
 type AgentSessionEventHandlers = {
 	[E in AgentSessionEventKind]: (event: Extract<AgentSessionEvent, { type: E }>) => Promise<void>;
 };
@@ -158,6 +169,27 @@ export class EventController {
 
 		const run = this.#handlers[event.type] as (e: AgentSessionEvent) => Promise<void>;
 		await run(event);
+		// While a foreground tool is executing, its streaming result re-renders and can
+		// re-lay-out rows that already scrolled into native scrollback. Let the TUI
+		// rebuild history on those offscreen edits (a snap to the tail is acceptable
+		// mid-tool) instead of deferring, which would leave stale/duplicated rows.
+		// Background-running tools are excluded so their late async updates — and the
+		// assistant text that streams alongside them — keep the no-yank deferral;
+		// agent_start resets the mode at every turn boundary.
+		if (TOOL_RENDER_MODE_EVENTS[event.type]) {
+			this.#refreshToolRenderMode();
+		}
+	}
+
+	#refreshToolRenderMode(): void {
+		let foregroundToolActive = false;
+		for (const toolCallId of this.ctx.pendingTools.keys()) {
+			if (!this.#backgroundToolCallIds.has(toolCallId)) {
+				foregroundToolActive = true;
+				break;
+			}
+		}
+		this.ctx.ui.setEagerNativeScrollbackRebuild(foregroundToolActive);
 	}
 
 	async #handleAgentStart(_event: Extract<AgentSessionEvent, { type: "agent_start" }>): Promise<void> {
@@ -610,7 +642,14 @@ export class EventController {
 					: event.reason === "idle"
 						? "Idle "
 						: "";
-		const actionLabel = event.action === "handoff" ? "Auto-handoff" : "Auto context-full maintenance";
+		const actionLabel =
+			event.action === "handoff"
+				? "Auto-handoff"
+				: event.action === "shake"
+					? "Auto-shake"
+					: event.action === "shake-summary"
+						? "Auto-shake (summary)"
+						: "Auto context-full maintenance";
 		this.ctx.autoCompactionLoader = new Loader(
 			this.ctx.ui,
 			spinner => theme.fg("accent", spinner),
@@ -634,8 +673,27 @@ export class EventController {
 			this.ctx.statusContainer.clear();
 		}
 		const isHandoffAction = event.action === "handoff";
+		const isShakeAction = event.action === "shake" || event.action === "shake-summary";
 		if (event.aborted) {
-			this.ctx.showStatus(isHandoffAction ? "Auto-handoff cancelled" : "Auto context-full maintenance cancelled");
+			this.ctx.showStatus(
+				isHandoffAction
+					? "Auto-handoff cancelled"
+					: isShakeAction
+						? "Auto-shake cancelled"
+						: "Auto context-full maintenance cancelled",
+			);
+		} else if (isShakeAction) {
+			// Shake produces no CompactionResult; rebuild on success, suppress benign skips.
+			if (event.errorMessage) {
+				this.ctx.showWarning(event.errorMessage);
+			} else if (!event.skipped) {
+				this.ctx.rebuildChatFromMessages();
+				this.ctx.statusLine.invalidate();
+				this.ctx.updateEditorTopBorder();
+				this.ctx.showStatus(
+					event.action === "shake-summary" ? "Auto-shake (summary) completed" : "Auto-shake completed",
+				);
+			}
 		} else if (event.result) {
 			this.ctx.rebuildChatFromMessages();
 			this.ctx.statusLine.invalidate();

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

@@ -8,7 +8,6 @@ import { renderSegmentTrack } from "../../modes/components/segment-track";
 import { TinyTitleDownloadProgressComponent } from "../../modes/components/tiny-title-download-progress";
 import { expandEmoticons } from "../../modes/emoji-autocomplete";
 import { createPromptActionAutocompleteProvider } from "../../modes/prompt-action-autocomplete";
-import { theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../../session/messages";
@@ -91,6 +90,7 @@ export class InputController {
 			Boolean(
 				this.ctx.loadingAnimation ||
 					this.ctx.hasActiveBtw() ||
+					this.ctx.hasActiveOmfg() ||
 					this.ctx.session.isStreaming ||
 					this.ctx.session.isCompacting ||
 					this.ctx.session.isGeneratingHandoff ||
@@ -114,6 +114,9 @@ export class InputController {
 			if (this.ctx.hasActiveBtw() && this.ctx.handleBtwEscape()) {
 				return;
 			}
+			if (this.ctx.hasActiveOmfg() && this.ctx.handleOmfgEscape()) {
+				return;
+			}
 			if (this.ctx.loadingAnimation) {
 				if (this.ctx.cancelPendingSubmission()) {
 					return;
@@ -161,9 +164,9 @@ export class InputController {
 		this.ctx.editor.setActionKeys("app.thinking.cycle", this.ctx.keybindings.getKeys("app.thinking.cycle"));
 		this.ctx.editor.onCycleThinkingLevel = () => this.cycleThinkingLevel();
 		this.ctx.editor.setActionKeys("app.model.cycleForward", this.ctx.keybindings.getKeys("app.model.cycleForward"));
-		this.ctx.editor.onCycleModelForward = () => this.cycleRoleModel();
+		this.ctx.editor.onCycleModelForward = () => this.cycleRoleModel("forward");
 		this.ctx.editor.setActionKeys("app.model.cycleBackward", this.ctx.keybindings.getKeys("app.model.cycleBackward"));
-		this.ctx.editor.onCycleModelBackward = () => this.cycleRoleModel({ temporary: true });
+		this.ctx.editor.onCycleModelBackward = () => this.cycleRoleModel("backward");
 		this.ctx.editor.setActionKeys(
 			"app.model.selectTemporary",
 			this.ctx.keybindings.getKeys("app.model.selectTemporary"),
@@ -180,7 +183,6 @@ export class InputController {
 		this.ctx.editor.onToggleThinking = () => this.ctx.toggleThinkingBlockVisibility();
 		this.ctx.editor.setActionKeys("app.editor.external", this.ctx.keybindings.getKeys("app.editor.external"));
 		this.ctx.editor.onExternalEditor = () => void this.openExternalEditor();
-		this.ctx.editor.onShowHotkeys = () => this.ctx.handleHotkeysCommand();
 		this.ctx.editor.setActionKeys(
 			"app.clipboard.pasteImage",
 			this.ctx.keybindings.getKeys("app.clipboard.pasteImage"),
@@ -606,6 +608,9 @@ export class InputController {
 		if (this.ctx.hasActiveBtw()) {
 			this.ctx.handleBtwEscape();
 		}
+		if (this.ctx.hasActiveOmfg()) {
+			this.ctx.handleOmfgEscape();
+		}
 
 		this.ctx.isBackgrounded = true;
 		const backgroundUiContext = this.ctx.createBackgroundUiContext();
@@ -760,10 +765,10 @@ export class InputController {
 		}
 	}
 
-	async cycleRoleModel(options?: { temporary?: boolean }): Promise<void> {
+	async cycleRoleModel(direction: "forward" | "backward" = "forward"): Promise<void> {
 		try {
 			const cycleOrder = settings.get("cycleOrder");
-			const result = await this.ctx.session.cycleRoleModels(cycleOrder, options);
+			const result = await this.ctx.session.cycleRoleModels(cycleOrder, direction);
 			if (!result) {
 				this.ctx.showStatus("Only one role model available");
 				return;
@@ -773,14 +778,12 @@ export class InputController {
 			this.ctx.updateEditorBorderColor();
 			// The status line already reports the resolved model + thinking level, so
 			// the cycle status is just a status-line-style chip track (active role
-			// filled), matching the plan-approval model slider. A dim suffix flags a
-			// temporary switch since that isn't shown elsewhere.
+			// filled), matching the plan-approval model slider.
 			const track = renderSegmentTrack(
 				cycleOrder.map(role => ({ label: role, color: getRoleInfo(role, settings).color })),
 				cycleOrder.indexOf(result.role),
 			);
-			const tempLabel = options?.temporary ? theme.fg("dim", "  (temporary)") : "";
-			this.ctx.showStatus(`${track}${tempLabel}`, { dim: false });
+			this.ctx.showStatus(track, { dim: false });
 		} catch (error) {
 			this.ctx.showError(error instanceof Error ? error.message : String(error));
 		}
@@ -797,7 +800,7 @@ export class InputController {
 				child.setExpanded(expanded);
 			}
 		}
-		this.ctx.ui.requestRender();
+		this.ctx.ui.requestRender(false, { allowUnknownViewportMutation: true });
 	}
 
 	toggleThinkingBlockVisibility(): void {