@oh-my-pi/pi-coding-agent 15.7.5 → 15.8.0

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

@@ -15,9 +15,52 @@ import { formatBytes } from "@oh-my-pi/pi-utils";
 import { theme } from "../../modes/theme/theme";
 import { matchesAppInterrupt, matchesSelectDown, matchesSelectUp } from "../../modes/utils/keybinding-matchers";
 import type { SessionInfo } from "../../session/session-manager";
+import { shortenPath } from "../../tools/render-utils";
 import { DynamicBorder } from "./dynamic-border";
 import { HookSelectorComponent } from "./hook-selector";
 
+/** Returns the IDs of sessions whose recorded prompts match a query, best first. */
+export type SessionHistoryMatcher = (query: string) => string[];
+
+/**
+ * Combine fuzzy session 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).
+ * - `historyIds` are session IDs whose recorded prompts matched the query,
+ *   ordered by history relevance (best first); duplicates are tolerated.
+ *
+ * Ranking: sessions matched by **both** signals lead (keeping fuzzy order), then
+ * fuzzy-only matches, then history-only matches (by 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.
+ */
+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);
+	}
+
+	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));
+
+	return [...both, ...fuzzyOnly, ...historyOnly];
+}
+
 /**
  * Custom session list component with multi-line items and search
  */
@@ -25,33 +68,44 @@ class SessionList implements Component {
 	#filteredSessions: SessionInfo[] = [];
 	#selectedIndex: number = 0;
 	readonly #searchInput: Input;
-	onSelect?: (sessionPath: string) => void;
+	onSelect?: (session: SessionInfo) => void;
 	onCancel?: () => void;
 	onExit: () => void = () => {};
+	onToggleScope?: () => void;
 	#maxVisible: number = 5; // Max sessions visible (each session is 3 lines: msg + metadata + blank)
 
 	onDeleteRequest?: (session: SessionInfo) => void;
 
-	constructor(
-		private readonly allSessions: SessionInfo[],
-		private readonly showCwd = false,
-	) {
-		this.#filteredSessions = allSessions;
+	#allSessions: SessionInfo[];
+	#showCwd: boolean;
+	readonly #historyMatcher?: SessionHistoryMatcher;
+
+	constructor(sessions: SessionInfo[], showCwd = false, historyMatcher?: SessionHistoryMatcher) {
+		this.#allSessions = sessions;
+		this.#showCwd = showCwd;
+		this.#historyMatcher = historyMatcher;
+		this.#filteredSessions = sessions;
 		this.#searchInput = new Input();
 
 		// Handle Enter in search input - select current item
 		this.#searchInput.onSubmit = () => {
-			if (this.#filteredSessions[this.#selectedIndex]) {
-				const selected = this.#filteredSessions[this.#selectedIndex];
-				if (this.onSelect) {
-					this.onSelect(selected.path);
-				}
+			const selected = this.#filteredSessions[this.#selectedIndex];
+			if (selected) {
+				this.onSelect?.(selected);
 			}
 		};
 	}
 
+	/** Replace the visible dataset, e.g. when toggling folder/all-projects scope. */
+	setSessions(sessions: SessionInfo[], showCwd: boolean): void {
+		this.#allSessions = sessions;
+		this.#showCwd = showCwd;
+		this.#selectedIndex = 0;
+		this.#filterSessions(this.#searchInput.getValue());
+	}
+
 	#filterSessions(query: string): void {
-		this.#filteredSessions = fuzzyFilter(this.allSessions, query, session => {
+		const fuzzy = fuzzyFilter(this.#allSessions, query, session => {
 			const parts = [
 				session.id,
 				session.title ?? "",
@@ -62,13 +116,28 @@ class SessionList implements Component {
 			];
 			return parts.filter(Boolean).join(" ");
 		});
+		this.#filteredSessions = this.#mergeHistoryMatches(query, fuzzy);
 		this.#selectedIndex = Math.min(this.#selectedIndex, Math.max(0, this.#filteredSessions.length - 1));
 	}
 
+	/**
+	 * Augment fuzzy results with prompt-history matches without replacing them.
+	 * The session-list corpus only sees the first 4KB of each session, so a prompt
+	 * typed deep into a long session is invisible to fuzzy search; `historyMatcher`
+	 * recovers those via `history.db`.
+	 */
+	#mergeHistoryMatches(query: string, fuzzy: SessionInfo[]): SessionInfo[] {
+		const trimmed = query.trim();
+		if (!trimmed || !this.#historyMatcher) return fuzzy;
+		const historyIds = this.#historyMatcher(trimmed);
+		if (historyIds.length === 0) return fuzzy;
+		return mergeSessionRanking(this.#allSessions, fuzzy, historyIds);
+	}
+
 	removeSession(sessionPath: string): void {
-		const index = this.allSessions.findIndex(s => s.path === sessionPath);
+		const index = this.#allSessions.findIndex(s => s.path === sessionPath);
 		if (index === -1) return;
-		this.allSessions.splice(index, 1);
+		this.#allSessions.splice(index, 1);
 		// Re-filter to update filteredSessions
 		this.#filterSessions(this.#searchInput.getValue());
 		// Adjust selectedIndex if we deleted the last item or beyond
@@ -89,7 +158,7 @@ class SessionList implements Component {
 		lines.push(""); // Blank line after search
 
 		if (this.#filteredSessions.length === 0) {
-			if (this.showCwd) {
+			if (this.#showCwd) {
 				// "All" scope - no sessions anywhere that match filter
 				lines.push(truncateToWidth(theme.fg("muted", "  No sessions found"), width));
 			} else {
@@ -158,9 +227,12 @@ class SessionList implements Component {
 				lines.push(messageLine);
 			}
 
-			// Metadata line: date + file size
+			// Metadata line: date + file size (+ project dir in all-projects scope)
 			const modified = formatDate(session.modified);
-			const metadata = `  ${modified} ${theme.sep.dot} ${formatBytes(session.size)}`;
+			let metadata = `  ${modified} ${theme.sep.dot} ${formatBytes(session.size)}`;
+			if (this.#showCwd && session.cwd) {
+				metadata += ` ${theme.sep.dot} ${shortenPath(session.cwd)}`;
+			}
 			const metadataLine = theme.fg("dim", truncateToWidth(metadata, width));
 
 			lines.push(metadataLine);
@@ -176,7 +248,12 @@ class SessionList implements Component {
 
 		// Add keybinding hint
 		lines.push("");
-		lines.push(theme.fg("muted", "  [Del to delete, Enter to select, Esc to cancel]"));
+		lines.push(
+			theme.fg(
+				"muted",
+				`  [Del delete · Enter select · Tab ${this.#showCwd ? "current folder" : "all projects"} · Esc cancel]`,
+			),
+		);
 
 		return lines;
 	}
@@ -215,7 +292,7 @@ class SessionList implements Component {
 		if (matchesKey(keyData, "enter") || matchesKey(keyData, "return") || keyData === "\n") {
 			const selected = this.#filteredSessions[this.#selectedIndex];
 			if (selected && this.onSelect) {
-				this.onSelect(selected.path);
+				this.onSelect(selected);
 			}
 			return;
 		}
@@ -231,12 +308,28 @@ class SessionList implements Component {
 			this.onExit();
 			return;
 		}
+		// Tab - toggle folder / all-projects scope
+		if (matchesKey(keyData, "tab")) {
+			this.onToggleScope?.();
+			return;
+		}
 		// Pass everything else to search input
 		this.#searchInput.handleInput(keyData);
 		this.#filterSessions(this.#searchInput.getValue());
 	}
 }
 
+export interface SessionSelectorOptions {
+	onDelete?: (session: SessionInfo) => Promise<boolean>;
+	historyMatcher?: SessionHistoryMatcher;
+	/** Loads sessions across all projects for the all-projects scope toggle (Tab). */
+	loadAllSessions?: () => Promise<SessionInfo[]>;
+	/** Preloaded all-projects list; cached so the first Tab toggle is instant. */
+	allSessions?: SessionInfo[];
+	/** Open directly in all-projects scope (e.g. the current folder has no sessions). */
+	startInAllScope?: boolean;
+}
+
 /**
  * Component that renders a session selector with optional confirmation dialog
  */
@@ -244,35 +337,55 @@ export class SessionSelectorComponent extends Container {
 	#sessionList: SessionList;
 	#confirmationDialog: HookSelectorComponent | null = null;
 	#messageContainer: Container;
+	#headerText: Text;
 	#onDelete?: (session: SessionInfo) => Promise<boolean>;
 	#onRequestRender?: () => void;
+	readonly #loadAllSessions?: () => Promise<SessionInfo[]>;
+	#folderSessions: SessionInfo[];
+	#globalSessions: SessionInfo[] | null = null;
+	#scope: "folder" | "all" = "folder";
+	#toggling = false;
 
 	constructor(
 		sessions: SessionInfo[],
-		onSelect: (sessionPath: string) => void,
+		onSelect: (session: SessionInfo) => void,
 		onCancel: () => void,
 		onExit: () => void,
-		onDelete?: (session: SessionInfo) => Promise<boolean>,
+		options: SessionSelectorOptions = {},
 	) {
 		super();
 
 		this.#messageContainer = new Container();
-		this.#onDelete = onDelete;
+		this.#onDelete = options.onDelete;
+		this.#loadAllSessions = options.loadAllSessions;
+		this.#folderSessions = sessions;
+		this.#globalSessions = options.allSessions ?? null;
+		// Open in all-projects scope when asked and we already have that list
+		// (e.g. the current folder has no sessions to show).
+		const startAll = options.startInAllScope === true && this.#globalSessions !== null;
+		this.#scope = startAll ? "all" : "folder";
+		const initialSessions = startAll ? this.#globalSessions! : sessions;
 		// Add header
 		this.addChild(new Spacer(1));
-		this.addChild(new Text(theme.bold("Resume Session"), 1, 0));
+		this.#headerText = new Text(this.#headerLabel(), 1, 0);
+		this.addChild(this.#headerText);
 		this.addChild(new Spacer(1));
 		this.addChild(new DynamicBorder());
 		this.addChild(new Spacer(1));
 		this.addChild(this.#messageContainer);
 		// Create session list
-		this.#sessionList = new SessionList(sessions);
+		this.#sessionList = new SessionList(initialSessions, startAll, options.historyMatcher);
 		this.#sessionList.onSelect = onSelect;
 		this.#sessionList.onCancel = onCancel;
 		this.#sessionList.onExit = onExit;
 		this.#sessionList.onDeleteRequest = (session: SessionInfo) => {
 			this.#showDeleteConfirmation(session);
 		};
+		if (this.#loadAllSessions || this.#globalSessions) {
+			this.#sessionList.onToggleScope = () => {
+				void this.#toggleScope();
+			};
+		}
 		this.addChild(this.#sessionList);
 
 		// Add bottom border
@@ -280,6 +393,48 @@ export class SessionSelectorComponent extends Container {
 		this.addChild(new DynamicBorder());
 	}
 
+	#headerLabel(): string {
+		const scopeLabel = this.#scope === "all" ? "all projects" : "current folder";
+		return `${theme.bold("Resume Session")} ${theme.fg("muted", `(${scopeLabel})`)}`;
+	}
+
+	/**
+	 * Toggle between current-folder and all-projects scope. The global list is
+	 * loaded lazily on first switch and cached, so the common folder-scope path
+	 * never pays for the cross-project scan.
+	 */
+	async #toggleScope(): Promise<void> {
+		if (this.#toggling || this.#confirmationDialog) return;
+		if (this.#scope === "folder") {
+			let global = this.#globalSessions;
+			if (!global) {
+				if (!this.#loadAllSessions) return;
+				this.#toggling = true;
+				this.#messageContainer.clear();
+				this.#messageContainer.addChild(new Text(theme.fg("muted", "  Loading all projects…"), 1, 0));
+				this.#onRequestRender?.();
+				try {
+					global = await this.#loadAllSessions();
+				} catch (err) {
+					this.#showError(err instanceof Error ? err.message : String(err));
+					this.#toggling = false;
+					this.#onRequestRender?.();
+					return;
+				}
+				this.#globalSessions = global;
+				this.#messageContainer.clear();
+				this.#toggling = false;
+			}
+			this.#scope = "all";
+			this.#sessionList.setSessions(global, true);
+		} else {
+			this.#scope = "folder";
+			this.#sessionList.setSessions(this.#folderSessions, false);
+		}
+		this.#headerText.setText(this.#headerLabel());
+		this.#onRequestRender?.();
+	}
+
 	setOnRequestRender(callback: () => void): void {
 		this.#onRequestRender = callback;
 	}

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

@@ -141,6 +141,14 @@ export interface ToolExecutionHandle {
 	setExpanded(expanded: boolean): void;
 }
 
+/** Drive pending-tool redraws at ~60fps so the animated border sweep is smooth.
+ * The TUI already throttles at its 16ms `MIN_RENDER_INTERVAL_MS`, so this is the
+ * natural upper bound and static frames diff to a no-op redraw at ~zero cost. */
+const SPINNER_RENDER_INTERVAL_MS = 16;
+/** Advance the spinner glyph at its classic ~12.5fps step, decoupled from the
+ * 60fps render cadence (mirrors `Loader`). */
+const SPINNER_GLYPH_ADVANCE_MS = 80;
+
 /**
  * Component that renders a tool call with its result (updateable)
  */
@@ -172,11 +180,14 @@ export class ToolExecutionComponent extends Container {
 	#editDiffPreview?: PerFileDiffPreview[];
 	#editDiffAbort?: AbortController;
 	#editDiffLastArgsKey?: string;
+	// Latest in-flight streaming diff recompute, captured so it can be awaited.
+	#editDiffInFlight?: Promise<void>;
 	// Cached converted images for Kitty protocol (which requires PNG), keyed by index
 	#convertedImages: Map<number, { data: string; mimeType: string }> = new Map();
 	// Spinner animation for partial task results
 	#spinnerFrame?: number;
 	#spinnerInterval?: NodeJS.Timeout;
+	#lastSpinnerAdvanceAt = 0;
 	// Todo write completion strikethrough reveal animation
 	#todoStrikeInterval?: NodeJS.Timeout;
 	// Track if args are still being streamed (for edit/write spinner)
@@ -230,7 +241,7 @@ export class ToolExecutionComponent extends Container {
 		this.#editMode = resolveEditModeForTool(toolName, tool);
 
 		this.#updateDisplay();
-		void this.#runPreviewDiff();
+		this.#editDiffInFlight = this.#runPreviewDiff();
 	}
 
 	updateArgs(args: any, _toolCallId?: string): void {
@@ -241,7 +252,7 @@ export class ToolExecutionComponent extends Container {
 		if (args === this.#args) return;
 		this.#args = args;
 		this.#updateSpinnerAnimation();
-		void this.#runPreviewDiff();
+		this.#editDiffInFlight = this.#runPreviewDiff();
 		this.#updateDisplay();
 	}
 
@@ -252,7 +263,18 @@ export class ToolExecutionComponent extends Container {
 	setArgsComplete(_toolCallId?: string): void {
 		this.#argsComplete = true;
 		this.#updateSpinnerAnimation();
-		void this.#runPreviewDiff();
+		this.#editDiffInFlight = this.#runPreviewDiff();
+	}
+
+	/**
+	 * Await the streaming diff recompute kicked off by the most recent
+	 * `updateArgs`/`setArgsComplete`. The recompute reads the file and re-runs the
+	 * whole-file Myers diff off the render path, signalling completion only via a
+	 * throttled `requestRender`. Tests await this to sample a *settled* preview
+	 * deterministically instead of racing the spinner's render ticks.
+	 */
+	async whenPreviewSettled(): Promise<void> {
+		await this.#editDiffInFlight;
 	}
 
 	async #runPreviewDiff(): Promise<void> {
@@ -404,13 +426,20 @@ export class ToolExecutionComponent extends Container {
 			this.#isPartial && shimmerEnabled() && (this.#toolName === "bash" || this.#toolName === "eval");
 		const needsSpinner = isStreamingArgs || isPartialTask || isPendingExecBlock;
 		if (needsSpinner && !this.#spinnerInterval) {
+			this.#lastSpinnerAdvanceAt = performance.now();
 			this.#spinnerInterval = setInterval(() => {
+				const now = performance.now();
 				const frameCount = theme.spinnerFrames.length;
-				if (frameCount === 0) return;
-				this.#spinnerFrame = ((this.#spinnerFrame ?? -1) + 1) % frameCount;
-				this.#renderState.spinnerFrame = this.#spinnerFrame;
+				// Redraw at ~60fps for a smooth border sweep, but only step the spinner
+				// glyph at its classic ~12.5fps cadence. The TUI throttles renders at
+				// 16ms and the differ drops no-op redraws, so the extra ticks are free.
+				if (frameCount > 0 && now - this.#lastSpinnerAdvanceAt >= SPINNER_GLYPH_ADVANCE_MS) {
+					this.#spinnerFrame = ((this.#spinnerFrame ?? -1) + 1) % frameCount;
+					this.#renderState.spinnerFrame = this.#spinnerFrame;
+					this.#lastSpinnerAdvanceAt = now;
+				}
 				this.#ui.requestRender();
-			}, 80);
+			}, SPINNER_RENDER_INTERVAL_MS);
 		} else if (!needsSpinner && this.#spinnerInterval) {
 			clearInterval(this.#spinnerInterval);
 			this.#spinnerInterval = undefined;

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

@@ -11,10 +11,8 @@ import {
 	type UsageReport,
 } from "@oh-my-pi/pi-ai";
 import { Loader, Markdown, padding, Spacer, Text, visibleWidth } from "@oh-my-pi/pi-tui";
-import { formatDuration, Snowflake, setProjectDir } from "@oh-my-pi/pi-utils";
+import { formatDuration, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
-import { reset as resetCapabilities } from "../../capability";
-import { clearClaudePluginRootsCache } from "../../discovery/helpers";
 import { loadCustomShare } from "../../export/custom-share";
 import type { CompactOptions } from "../../extensibility/extensions/types";
 import {
@@ -993,14 +991,7 @@ export class CommandController {
 		try {
 			await this.ctx.sessionManager.flush();
 			await this.ctx.sessionManager.moveTo(resolvedPath);
-			setProjectDir(resolvedPath);
-			clearClaudePluginRootsCache(); // re-warms preloadedPluginRoots with new project dir (async)
-			resetCapabilities();
-			await this.ctx.refreshSlashCommandState(resolvedPath);
-			await this.ctx.session.refreshSshTool({ activateIfAvailable: true });
-
-			this.ctx.statusLine.invalidate();
-			this.ctx.updateEditorTopBorder();
+			await this.ctx.applyCwdChange(resolvedPath);
 
 			this.ctx.chatContainer.addChild(new Spacer(1));
 			this.ctx.chatContainer.addChild(

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

@@ -277,8 +277,11 @@ export class EventController {
 			this.#lastThinkingCount = 0;
 			this.#assistantMessageStreaming = true;
 			this.#resetReadGroup();
-			this.ctx.streamingComponent = new AssistantMessageComponent(undefined, this.ctx.hideThinkingBlock, () =>
-				this.ctx.ui.requestRender(),
+			this.ctx.streamingComponent = new AssistantMessageComponent(
+				undefined,
+				this.ctx.hideThinkingBlock,
+				() => this.ctx.ui.requestRender(),
+				this.ctx.session.extensionRunner?.getAssistantThinkingRenderers(),
 			);
 			this.ctx.streamingMessage = event.message;
 			this.ctx.chatContainer.addChild(this.ctx.streamingComponent);

package/src/modes/controllers/extension-ui-controller.ts

@@ -10,6 +10,7 @@ import type {
 	ExtensionError,
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
+	ExtensionUISelectItem,
 	ExtensionUiComponent,
 	ExtensionWidgetContent,
 	ExtensionWidgetOptions,
@@ -21,7 +22,7 @@ import { HookEditorComponent } from "../../modes/components/hook-editor";
 import { HookInputComponent } from "../../modes/components/hook-input";
 import { HookSelectorComponent, type HookSelectorSlider } from "../../modes/components/hook-selector";
 import { getAvailableThemesWithPaths, getThemeByName, setTheme, type Theme, theme } from "../../modes/theme/theme";
-import type { InteractiveModeContext } from "../../modes/types";
+import type { InteractiveModeContext, InteractiveSelectorDialogOptions } from "../../modes/types";
 import { setSessionTerminalTitle, setTerminalTitle } from "../../utils/title-generator";
 
 const MAX_WIDGET_LINES = 10;
@@ -483,7 +484,7 @@ export class ExtensionUiController {
 
 	createBackgroundUiContext(): ExtensionUIContext {
 		return {
-			select: async (_title: string, _options: string[], _dialogOptions) => undefined,
+			select: async (_title: string, _options: ExtensionUISelectItem[], _dialogOptions) => undefined,
 			confirm: async (_title: string, _message: string, _dialogOptions) => false,
 			input: async (_title: string, _placeholder?: string, _dialogOptions?: unknown) => undefined,
 			notify: () => {},
@@ -581,8 +582,8 @@ export class ExtensionUiController {
 	 */
 	showHookSelector(
 		title: string,
-		options: string[],
-		dialogOptions?: ExtensionUIDialogOptions,
+		options: ExtensionUISelectItem[],
+		dialogOptions?: InteractiveSelectorDialogOptions,
 		extra?: { slider?: HookSelectorSlider },
 	): Promise<string | undefined> {
 		const { promise, finish, attachAbort } = this.#createHookDialogState(
@@ -623,6 +624,7 @@ export class ExtensionUiController {
 				onTimeout: dialogOptions?.onTimeout,
 				tui: this.ctx.ui,
 				outline: dialogOptions?.outline,
+				disabledIndices: dialogOptions?.disabledIndices,
 				maxVisible,
 				slider: extra?.slider,
 			},

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

@@ -15,7 +15,7 @@ import { executeBuiltinSlashCommand } from "../../slash-commands/builtin-registr
 import { isTinyTitleLocalModelKey } from "../../tiny/models";
 import { tinyTitleClient } from "../../tiny/title-client";
 import type { TinyTitleProgressEvent } from "../../tiny/title-protocol";
-import { copyToClipboard, readImageFromClipboard } from "../../utils/clipboard";
+import { copyToClipboard, readImageFromClipboard, readTextFromClipboard } from "../../utils/clipboard";
 import { getEditorCommand, openInEditor } from "../../utils/external-editor";
 import { ensureSupportedImageInput } from "../../utils/image-loading";
 import { resizeImage } from "../../utils/image-resize";
@@ -86,21 +86,6 @@ export class InputController {
 
 	setupKeyHandlers(): void {
 		this.ctx.editor.setActionKeys("app.interrupt", this.ctx.keybindings.getKeys("app.interrupt"));
-		this.ctx.editor.shouldBypassAutocompleteOnEscape = () =>
-			Boolean(
-				this.ctx.loadingAnimation ||
-					this.ctx.hasActiveBtw() ||
-					this.ctx.hasActiveOmfg() ||
-					this.ctx.session.isStreaming ||
-					this.ctx.session.isCompacting ||
-					this.ctx.session.isGeneratingHandoff ||
-					this.ctx.session.isBashRunning ||
-					this.ctx.session.isEvalRunning ||
-					this.ctx.autoCompactionLoader ||
-					this.ctx.retryLoader ||
-					this.ctx.autoCompactionEscapeHandler ||
-					this.ctx.retryEscapeHandler,
-			);
 		this.ctx.editor.onEscape = () => {
 			if (this.ctx.loopModeEnabled) {
 				this.ctx.pauseLoop();
@@ -188,6 +173,11 @@ export class InputController {
 			this.ctx.keybindings.getKeys("app.clipboard.pasteImage"),
 		);
 		this.ctx.editor.onPasteImage = () => this.handleImagePaste();
+		this.ctx.editor.setActionKeys(
+			"app.clipboard.pasteTextRaw",
+			this.ctx.keybindings.getKeys("app.clipboard.pasteTextRaw"),
+		);
+		this.ctx.editor.onPasteTextRaw = () => void this.handleClipboardTextRawPaste();
 		this.ctx.editor.setActionKeys(
 			"app.clipboard.copyPrompt",
 			this.ctx.keybindings.getKeys("app.clipboard.copyPrompt"),
@@ -705,6 +695,19 @@ export class InputController {
 		}
 	}
 
+	async handleClipboardTextRawPaste(): Promise<void> {
+		try {
+			const text = await readTextFromClipboard();
+			if (text) {
+				this.ctx.editor.insertText(text);
+				this.ctx.ui.requestRender();
+				this.ctx.showStatus("No text in clipboard to paste raw");
+			}
+		} catch {
+			this.ctx.showStatus("Failed to paste raw text from clipboard");
+		}
+	}
+
 	createAutocompleteProvider(commands: SlashCommand[], basePath: string): AutocompleteProvider {
 		return createPromptActionAutocompleteProvider({
 			commands,