@oh-my-pi/pi-coding-agent 15.9.5 → 15.10.0

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

@@ -7,7 +7,6 @@ import { getAgentDbPath, getProjectDir, normalizePathForComparison } from "@oh-m
 import { getRoleInfo } from "../../config/model-registry";
 import { formatModelSelectorValue } from "../../config/model-resolver";
 import { settings } from "../../config/settings";
-import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
 import {
@@ -37,9 +36,11 @@ import {
 	setPreferredSearchProvider,
 } from "../../tools";
 import { shortenPath } from "../../tools/render-utils";
+import { copyToClipboard } from "../../utils/clipboard";
 import { setSessionTerminalTitle } from "../../utils/title-generator";
 import { AgentDashboard } from "../components/agent-dashboard";
 import { AssistantMessageComponent } from "../components/assistant-message";
+import { CopySelectorComponent } from "../components/copy-selector";
 import { ExtensionDashboard } from "../components/extensions";
 import { HistorySearchComponent } from "../components/history-search";
 import { ModelSelectorComponent } from "../components/model-selector";
@@ -52,6 +53,8 @@ import { ToolExecutionComponent } from "../components/tool-execution";
 import { TreeSelectorComponent } from "../components/tree-selector";
 import { UserMessageSelectorComponent } from "../components/user-message-selector";
 import type { SessionObserverRegistry } from "../session-observer-registry";
+import { computeContextBreakdown } from "../utils/context-usage";
+import { buildCopyTargets } from "../utils/copy-targets";
 
 const CALLBACK_SERVER_PROVIDERS = new Set<OAuthProvider>([
 	"anthropic",
@@ -407,6 +410,7 @@ export class SelectorController {
 	}
 
 	showModelSelector(options?: { temporaryOnly?: boolean }): void {
+		const currentContextTokens = computeContextBreakdown(this.ctx.session).usedTokens;
 		this.showSelector(done => {
 			const selector = new ModelSelectorComponent(
 				this.ctx.ui,
@@ -470,7 +474,7 @@ export class SelectorController {
 					done();
 					this.ctx.ui.requestRender();
 				},
-				options,
+				{ ...options, currentContextTokens },
 			);
 			return { component: selector, focus: selector };
 		});
@@ -598,6 +602,38 @@ export class SelectorController {
 		});
 	}
 
+	showCopySelector(): void {
+		const targets = buildCopyTargets(this.ctx.session);
+		if (targets.length === 0) {
+			this.ctx.showStatus("Nothing to copy yet.");
+			return;
+		}
+
+		let overlayHandle: OverlayHandle | undefined;
+		const done = () => {
+			overlayHandle?.hide();
+			this.ctx.ui.requestRender();
+		};
+		const selector = new CopySelectorComponent(targets, {
+			onPick: target => {
+				done();
+				if (target.content === undefined) return;
+				void copyToClipboard(target.content);
+				this.ctx.showStatus(target.copyMessage ?? "Copied to clipboard");
+			},
+			onCancel: done,
+		});
+
+		overlayHandle = this.ctx.ui.showOverlay(selector, {
+			anchor: "bottom-center",
+			width: "100%",
+			maxHeight: "100%",
+			margin: 0,
+		});
+		this.ctx.ui.setFocus(selector);
+		this.ctx.ui.requestRender();
+	}
+
 	showTreeSelector(): void {
 		const tree = this.ctx.sessionManager.getTree();
 		const realLeafId = this.ctx.sessionManager.getLeafId();
@@ -1043,7 +1079,8 @@ export class SelectorController {
 		});
 	}
 
-	showDebugSelector(): void {
+	async showDebugSelector(): Promise<void> {
+		const { DebugSelectorComponent } = await import("../../debug");
 		this.showSelector(done => {
 			const selector = new DebugSelectorComponent(this.ctx, done);
 			return { component: selector, focus: selector };

package/src/modes/index.ts

@@ -2,11 +2,13 @@ import { emergencyTerminalRestore } from "@oh-my-pi/pi-tui";
 import { postmortem } from "@oh-my-pi/pi-utils";
 
 /**
- * Run modes for the coding agent.
+ * Interactive mode and embeddable RPC client exports for the coding agent.
+ *
+ * Branch-specific runners live in their concrete modules so importing this
+ * barrel does not pull print, RPC server, or ACP server mode into the normal
+ * TUI graph.
  */
-export { runAcpMode } from "./acp";
 export { InteractiveMode, type InteractiveModeOptions } from "./interactive-mode";
-export { type PrintModeOptions, runPrintMode } from "./print-mode";
 export {
 	defineRpcClientTool,
 	type ModelInfo,
@@ -17,7 +19,6 @@ export {
 	type RpcClientToolResult,
 	type RpcEventListener,
 } from "./rpc/rpc-client";
-export { runRpcMode } from "./rpc/rpc-mode";
 export type {
 	RpcCommand,
 	RpcHostToolCallRequest,

package/src/modes/interactive-mode.ts

@@ -250,6 +250,20 @@ export interface InteractiveModeOptions {
 	initialMessages?: string[];
 }
 
+/**
+ * Plan-review preview block. Once rendered it is static (a one-shot Markdown of
+ * the plan file), so even while it sits as the live bottom block beneath the
+ * approval selector its scrolled-off head is safe to commit to native
+ * scrollback. Reporting append-only lets an over-tall plan + selector commit the
+ * plan's head instead of clipping it — without this a plain {@link Container} is
+ * deferred and a long plan is cut off the top on ED3-risk terminals.
+ */
+class PlanReviewBlock extends Container {
+	isTranscriptBlockAppendOnly(): boolean {
+		return true;
+	}
+}
+
 export class InteractiveMode implements InteractiveModeContext {
 	session: AgentSession;
 	sessionManager: SessionManager;
@@ -1680,7 +1694,7 @@ export class InteractiveMode implements InteractiveModeContext {
 	#renderPlanPreview(planContent: string, options?: { append?: boolean }): void {
 		const existingContainer = this.#planReviewContainer;
 		const replaceExisting = options?.append !== true && existingContainer !== undefined;
-		const planReviewContainer = replaceExisting ? existingContainer : new Container();
+		const planReviewContainer = replaceExisting ? existingContainer : new PlanReviewBlock();
 		planReviewContainer.clear();
 		planReviewContainer.addChild(new Spacer(1));
 		planReviewContainer.addChild(new DynamicBorder());
@@ -2700,10 +2714,6 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.#commandController.handleShareCommand();
 	}
 
-	handleCopyCommand(sub?: string) {
-		return this.#commandController.handleCopyCommand(sub);
-	}
-
 	handleTodoCommand(args: string): Promise<void> {
 		return this.#todoCommandController.handleTodoCommand(args);
 	}
@@ -2848,8 +2858,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		}
 	}
 
-	showDebugSelector(): void {
-		this.#selectorController.showDebugSelector();
+	async showDebugSelector(): Promise<void> {
+		await this.#selectorController.showDebugSelector();
 	}
 
 	showSessionObserver(): void {
@@ -2936,6 +2946,10 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#selectorController.showUserMessageSelector();
 	}
 
+	showCopySelector(): void {
+		this.#selectorController.showCopySelector();
+	}
+
 	showTreeSelector(): void {
 		this.#selectorController.showTreeSelector();
 	}

package/src/modes/setup-version.ts

@@ -0,0 +1,11 @@
+/**
+ * Setup version the wizard advances a fresh install to. Bump it whenever a new
+ * setup scene lands (or an existing scene raises its `minVersion`).
+ *
+ * Kept in its own dependency-free module so the cold-launch gate in `main.ts`
+ * can answer "is the stored setup version stale?" without statically importing
+ * the full wizard — every scene (sign-in/OAuth, web search, theme previews) plus
+ * the overlay component and their TUI deps. MUST equal `max(scene.minVersion)`
+ * across `ALL_SCENES`; the `setup-wizard` barrel and test suite guard it.
+ */
+export const CURRENT_SETUP_VERSION = 1;

package/src/modes/setup-wizard/index.ts

@@ -1,4 +1,5 @@
 import type { Settings } from "../../config/settings";
+import { CURRENT_SETUP_VERSION } from "../setup-version";
 import type { InteractiveModeContext } from "../types";
 import { glyphSetupScene } from "./scenes/glyph";
 import { providersSetupScene } from "./scenes/providers";
@@ -8,14 +9,14 @@ import { SetupWizardComponent } from "./wizard-overlay";
 
 export type { SetupScene, SetupSceneController, SetupSceneHost, SetupSceneResult } from "./scenes/types";
 
+export { CURRENT_SETUP_VERSION };
+
 export const ALL_SCENES = [
 	providersSetupScene,
 	glyphSetupScene,
 	themeSetupScene,
 ] as const satisfies readonly SetupScene[];
 
-export const CURRENT_SETUP_VERSION = ALL_SCENES.reduce((max, scene) => Math.max(max, scene.minVersion), 0);
-
 export interface SetupSceneSelectionOptions {
 	resuming?: boolean;
 	isTTY?: boolean;

package/src/modes/setup-wizard/scenes/web-search.ts

@@ -19,7 +19,8 @@ type Availability = "checking" | boolean;
 /**
  * "Web search" panel: picks the provider the web_search tool should prefer and
  * reports whether the highlighted provider is ready to use given current
- * credentials (env keys or OAuth sign-ins from the Sign in tab).
+ * credentials (env keys or OAuth sign-ins from the Sign in tab) or an
+ * unauthenticated fallback.
  */
 export class WebSearchTab implements SetupTab {
 	readonly id = "web-search";
@@ -91,7 +92,7 @@ export class WebSearchTab implements SetupTab {
 			let ready = false;
 			try {
 				const provider = await getSearchProvider(id);
-				ready = await provider.isAvailable(this.host.ctx.session.modelRegistry.authStorage);
+				ready = await provider.isExplicitlyAvailable(this.host.ctx.session.modelRegistry.authStorage);
 			} catch {
 				ready = false;
 			}

package/src/modes/theme/theme.ts

@@ -12,6 +12,7 @@ import {
 import type { EditorTheme, MarkdownTheme, SelectListTheme, SymbolTheme } from "@oh-my-pi/pi-tui";
 import { adjustHsv, colorLuma, getCustomThemesDir, isEnoent, logger, relativeLuminance } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { LRUCache } from "lru-cache/raw";
 import * as z from "zod/v4";
 // Embed theme JSON files at build time
 import darkThemeJson from "./dark.json" with { type: "json" };
@@ -2429,17 +2430,54 @@ function getHighlightColors(t: Theme): NativeHighlightColors {
 	return cachedHighlightColors;
 }
 
+/**
+ * Memoized native syntax highlight. Returns the joined ANSI string, or `null`
+ * when the native tokenizer throws so callers can apply their own fallback.
+ *
+ * Keyed on `(lang, code)` and reset whenever the active `theme` instance
+ * changes — the ANSI colors are baked into the highlighted output, so a theme
+ * switch (which always reassigns `theme`) must invalidate every entry.
+ *
+ * Why this exists: animated tool blocks (eval/bash) repaint their box on every
+ * ~16ms border-shimmer frame, and markdown re-lexes on every streamed delta.
+ * Without memoization each frame re-tokenizes an unchanged code body through the
+ * Rust FFI — ~26ms for 100 lines, ~40ms for 150 — overrunning the 16ms frame
+ * budget and starving the spinner/render timers (the "TUI freeze").
+ */
+const HIGHLIGHT_CACHE_MAX = 256;
+const highlightCache = new LRUCache<string, string>({ max: HIGHLIGHT_CACHE_MAX });
+let highlightCacheTheme: Theme | undefined;
+
+function highlightCached(code: string, validLang: string | undefined): string | null {
+	if (highlightCacheTheme !== theme) {
+		highlightCache.clear();
+		highlightCacheTheme = theme;
+	}
+	const key = `${validLang ?? ""}\x00${code}`;
+	const hit = highlightCache.get(key);
+	if (hit !== undefined) {
+		return hit;
+	}
+	let highlighted: string;
+	try {
+		highlighted = nativeHighlightCode(code, validLang, getHighlightColors(theme));
+	} catch {
+		return null;
+	}
+	highlightCache.set(key, highlighted);
+	return highlighted;
+}
+
 /**
  * Highlight code with syntax coloring based on file extension or language.
  * Returns array of highlighted lines.
  */
 export function highlightCode(code: string, lang?: string): string[] {
 	const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
-	try {
-		return nativeHighlightCode(code, validLang, getHighlightColors(theme)).split("\n");
-	} catch {
-		return code.split("\n");
-	}
+	const highlighted = highlightCached(code, validLang);
+	// Always return a fresh array: callers (e.g. renderCodeCell) push extra lines
+	// onto the result, which would corrupt the cached string otherwise.
+	return (highlighted ?? code).split("\n");
 }
 
 export function getSymbolTheme(): SymbolTheme {
@@ -2484,11 +2522,9 @@ export function getMarkdownTheme(): MarkdownTheme {
 		resolveMermaidAscii,
 		highlightCode: (code: string, lang?: string): string[] => {
 			const validLang = lang && nativeSupportsLanguage(lang) ? lang : undefined;
-			try {
-				return nativeHighlightCode(code, validLang, getHighlightColors(theme)).split("\n");
-			} catch {
-				return code.split("\n").map(line => theme.fg("mdCodeBlock", line));
-			}
+			const highlighted = highlightCached(code, validLang);
+			if (highlighted !== null) return highlighted.split("\n");
+			return code.split("\n").map(line => theme.fg("mdCodeBlock", line));
 		},
 	};
 	cachedMarkdownTheme = markdownTheme;

package/src/modes/types.ts

@@ -222,7 +222,6 @@ export interface InteractiveModeContext {
 	// Command handling
 	handleExportCommand(text: string): Promise<void>;
 	handleShareCommand(): Promise<void>;
-	handleCopyCommand(sub?: string): void;
 	handleTodoCommand(args: string): Promise<void>;
 	handleSessionCommand(): Promise<void>;
 	handleJobsCommand(): Promise<void>;
@@ -263,13 +262,14 @@ export interface InteractiveModeContext {
 	showModelSelector(options?: { temporaryOnly?: boolean }): void;
 	showPluginSelector(mode?: "install" | "uninstall"): void;
 	showUserMessageSelector(): void;
+	showCopySelector(): void;
 	showTreeSelector(): void;
 	showSessionSelector(): void;
 	handleResumeSession(sessionPath: string): Promise<void>;
 	handleSessionDeleteCommand(): Promise<void>;
 	showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
 	showHookConfirm(title: string, message: string): Promise<boolean>;
-	showDebugSelector(): void;
+	showDebugSelector(): Promise<void>;
 	showSessionObserver(): void;
 	resetObserverRegistry(): void;
 

package/src/modes/utils/context-usage.ts

@@ -37,6 +37,9 @@ export interface ContextBreakdown {
 	freeTokens: number;
 }
 
+const EMPTY_STRING_PARTS: readonly string[] = [];
+const EMPTY_TOOLS: ReadonlyArray<Pick<Tool, "name" | "description" | "parameters">> = [];
+
 export function estimateSkillsTokens(skills: readonly Skill[]): number {
 	const fragments: string[] = [];
 	for (const skill of skills) {
@@ -75,15 +78,16 @@ export function estimateToolSchemaTokens(
  * messages walked incrementally as new entries append.
  */
 export function computeNonMessageTokens(session: AgentSession): number {
-	const parts = computeNonMessageBreakdown(session);
-	return parts.systemPromptTokens + parts.systemContextTokens + parts.toolsTokens + parts.skillsTokens;
+	const systemPromptParts = session.systemPrompt ?? EMPTY_STRING_PARTS;
+	const tools = session.agent?.state?.tools ?? EMPTY_TOOLS;
+	return countTokens(systemPromptParts) + estimateToolSchemaTokens(tools);
 }
 
 /**
- * Shared helper for the four non-message token totals. Single source of truth
- * for both `computeNonMessageTokens` (status-line incremental cache) and
- * `computeContextBreakdown` (/context panel). The split avoids drift between
- * the two surfaces — they MUST report the same numbers.
+ * Shared helper for the four non-message token totals used by
+ * `computeContextBreakdown` (/context panel). Keep this category split stable:
+ * the status-line fast path intentionally uses the equivalent collapsed total
+ * in `computeNonMessageTokens`.
  */
 function computeNonMessageBreakdown(session: AgentSession): {
 	skillsTokens: number;

package/src/modes/utils/copy-targets.ts

@@ -0,0 +1,254 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { ToolCall } from "@oh-my-pi/pi-ai";
+
+/** A fenced code block extracted from assistant markdown. */
+export interface CodeBlock {
+	/** Info string after the opening fence (language id), trimmed. */
+	lang: string;
+	/** Block body with the trailing newline stripped. */
+	code: string;
+}
+
+/** A runnable command found in the transcript. */
+export interface LastCommand {
+	kind: "bash" | "eval";
+	code: string;
+	/** Highlight language: "bash" for bash, "python"/"javascript" for eval. */
+	language: string;
+}
+
+/**
+ * A node in the `/copy` picker tree. Leaves carry `content` (placed on the
+ * clipboard) plus `copyMessage` (the status shown afterwards); groups carry
+ * `children` to drill into.
+ */
+export interface CopyTarget {
+	/** Stable identifier (e.g. "msg:1", "msg:1:code:0", "msg:1:all", "cmd:1"). */
+	id: string;
+	label: string;
+	/** Dim annotation: line/block counts, language, or tool name. */
+	hint?: string;
+	/** Full text rendered in the preview pane. */
+	preview: string;
+	/** Highlight language for code/command previews (undefined = plain/markdown). */
+	language?: string;
+	/** Leaf: text copied to the clipboard. */
+	content?: string;
+	/** Leaf: status message shown after copying. */
+	copyMessage?: string;
+	/** Group: nested targets to drill into. */
+	children?: CopyTarget[];
+}
+
+/** Minimal session surface needed to assemble copy targets (eases testing). */
+export interface CopySource {
+	readonly messages: readonly AgentMessage[];
+	getLastVisibleHandoffText(): string | undefined;
+}
+
+/** Cap on how many recent assistant messages the picker lists. */
+const MAX_MESSAGES = 50;
+
+const CODE_BLOCK_RE = /^```([^\n]*)\n([\s\S]*?)^```/gm;
+
+/** Extract fenced code blocks from assistant markdown, in document order. */
+export function extractCodeBlocks(text: string): CodeBlock[] {
+	const blocks: CodeBlock[] = [];
+	for (const match of text.matchAll(CODE_BLOCK_RE)) {
+		blocks.push({ lang: match[1].trim(), code: match[2].replace(/\n$/, "") });
+	}
+	return blocks;
+}
+
+function extractEvalCode(args: unknown): { code: string; language: string } | undefined {
+	if (!args || typeof args !== "object") return undefined;
+	const cells = (args as { cells?: unknown }).cells;
+	if (!Array.isArray(cells)) return undefined;
+
+	const codeBlocks: string[] = [];
+	let language = "python";
+	let languageResolved = false;
+	for (const cell of cells) {
+		if (!cell || typeof cell !== "object") continue;
+		const code = (cell as { code?: unknown }).code;
+		if (typeof code !== "string" || code.length === 0) continue;
+		codeBlocks.push(code);
+		if (!languageResolved) {
+			language = (cell as { language?: unknown }).language === "js" ? "javascript" : "python";
+			languageResolved = true;
+		}
+	}
+
+	return codeBlocks.length > 0 ? { code: codeBlocks.join("\n\n"), language } : undefined;
+}
+
+function commandFromToolCall(tc: ToolCall): LastCommand | undefined {
+	if (tc.name === "bash" && typeof tc.arguments.command === "string") {
+		return { kind: "bash", code: tc.arguments.command, language: "bash" };
+	}
+	if (tc.name === "eval") {
+		const evalResult = extractEvalCode(tc.arguments);
+		if (evalResult) return { kind: "eval", code: evalResult.code, language: evalResult.language };
+	}
+	return undefined;
+}
+
+/** Walk the transcript backwards for the most recent bash command or eval code. */
+export function extractLastCommand(messages: readonly AgentMessage[]): LastCommand | undefined {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role !== "assistant") continue;
+		const toolCalls = msg.content.filter((c): c is ToolCall => c.type === "toolCall");
+		for (let j = toolCalls.length - 1; j >= 0; j--) {
+			const command = commandFromToolCall(toolCalls[j]!);
+			if (command) return command;
+		}
+	}
+	return undefined;
+}
+
+/** Concatenated visible text of an assistant message, or undefined when empty. */
+function assistantText(msg: AgentMessage): string | undefined {
+	if (msg.role !== "assistant") return undefined;
+	let text = "";
+	for (const content of msg.content) {
+		if (content.type === "text") text += content.text;
+	}
+	return text.trim() || undefined;
+}
+
+function pluralLines(text: string): string {
+	const count = text.length === 0 ? 0 : text.split("\n").length;
+	return `${count} line${count === 1 ? "" : "s"}`;
+}
+
+function blockHint(block: CodeBlock): string {
+	const lines = pluralLines(block.code);
+	return block.lang ? `${block.lang} · ${lines}` : lines;
+}
+
+/** First non-empty line, whitespace-collapsed, used as a message label. */
+function firstLine(text: string): string {
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed) return trimmed.replace(/\s+/g, " ");
+	}
+	return text.trim().replace(/\s+/g, " ");
+}
+
+/** Build the target node for one assistant message: a leaf when it has no code
+ * blocks, otherwise a group exposing the full message, each block, and "all". */
+function messageTarget(text: string, rank: number): CopyTarget {
+	const id = `msg:${rank}`;
+	const label = firstLine(text);
+	const blocks = extractCodeBlocks(text);
+	const hint = blocks.length > 0 ? `${pluralLines(text)} · ${blocks.length} code` : pluralLines(text);
+	const messageCopy = rank === 1 ? "Copied last message to clipboard" : "Copied message to clipboard";
+
+	if (blocks.length === 0) {
+		return { id, label, hint, preview: text, content: text, copyMessage: messageCopy };
+	}
+
+	// The message node itself copies the full message; its code blocks are
+	// child copy targets you can expand into.
+	const children: CopyTarget[] = blocks.map((block, j) => ({
+		id: `${id}:code:${j}`,
+		label: `Block ${j + 1}`,
+		hint: blockHint(block),
+		preview: block.code,
+		language: block.lang || undefined,
+		content: block.code,
+		copyMessage: `Copied code block ${j + 1} to clipboard`,
+	}));
+	if (blocks.length > 1) {
+		const combined = blocks.map(b => b.code).join("\n\n");
+		children.push({
+			id: `${id}:all`,
+			label: `All ${blocks.length} blocks`,
+			hint: pluralLines(combined),
+			preview: combined,
+			content: combined,
+			copyMessage: `Copied ${blocks.length} code blocks to clipboard`,
+		});
+	}
+
+	return { id, label, hint, preview: text, content: text, copyMessage: messageCopy, children };
+}
+
+function commandTitle(command: LastCommand): string {
+	return command.kind === "bash" ? "Bash command" : "Eval code";
+}
+
+function commandTarget(command: LastCommand, rank: number): CopyTarget {
+	const title = commandTitle(command);
+	return {
+		id: `cmd:${rank}`,
+		label: firstLine(command.code) || title,
+		hint: `${command.kind} · ${pluralLines(command.code)}`,
+		preview: command.code,
+		language: command.language,
+		content: command.code,
+		copyMessage: `Copied ${command.kind === "bash" ? "bash command" : "eval code"} to clipboard`,
+	};
+}
+
+/**
+ * Assemble the unified `/copy` target tree: recent assistant messages
+ * (most recent first, each drillable into its code blocks), runnable command
+ * targets interleaved after the assistant message that issued them, and a
+ * fresh-handoff fallback when no assistant message exists yet.
+ */
+export function buildCopyTargets(source: CopySource): CopyTarget[] {
+	const targets: CopyTarget[] = [];
+	const pendingCommands: LastCommand[] = [];
+	let messageRank = 0;
+	let commandRank = 0;
+
+	const appendCommands = (commands: readonly LastCommand[]) => {
+		for (const command of commands) {
+			commandRank += 1;
+			targets.push(commandTarget(command, commandRank));
+		}
+	};
+
+	for (let i = source.messages.length - 1; i >= 0 && messageRank < MAX_MESSAGES; i--) {
+		const msg = source.messages[i];
+		if (msg.role !== "assistant") continue;
+
+		const toolCalls = msg.content.filter((c): c is ToolCall => c.type === "toolCall");
+		const commands: LastCommand[] = [];
+		for (let j = toolCalls.length - 1; j >= 0; j--) {
+			const command = commandFromToolCall(toolCalls[j]!);
+			if (command) commands.push(command);
+		}
+
+		const text = assistantText(msg);
+		if (!text) {
+			pendingCommands.push(...commands);
+			continue;
+		}
+
+		messageRank += 1;
+		targets.push(messageTarget(text, messageRank));
+		appendCommands(pendingCommands);
+		appendCommands(commands);
+		pendingCommands.length = 0;
+	}
+
+	if (messageRank === 0) {
+		const handoff = source.getLastVisibleHandoffText();
+		if (handoff) {
+			targets.unshift({
+				id: "handoff",
+				label: "Handoff context",
+				hint: pluralLines(handoff),
+				preview: handoff,
+				content: handoff,
+				copyMessage: "Copied handoff context to clipboard",
+			});
+		}
+		appendCommands(pendingCommands);
+	}
+
+	return targets;
+}

package/src/modes/utils/hotkeys-markdown.ts

@@ -37,6 +37,7 @@ export function buildHotkeysMarkdown(bindings: HotkeysMarkdownBindings): string
 		`| \`${appKey(bindings, "app.clear")}\` | Clear editor (first) / exit (second) |`,
 		`| \`${appKey(bindings, "app.exit")}\` | Exit (when editor is empty) |`,
 		`| \`${appKey(bindings, "app.suspend")}\` | Suspend to background |`,
+		`| \`${appKey(bindings, "app.display.reset")}\` | Reset terminal display |`,
 		`| \`${appKey(bindings, "app.thinking.cycle")}\` | Cycle thinking level |`,
 		`| \`${appKey(bindings, "app.model.cycleForward")}\` | Cycle role models (slow/default/smol) |`,
 		`| \`${appKey(bindings, "app.model.cycleBackward")}\` | Cycle role models (backward) |`,

package/src/prompts/tools/ast-edit.md

@@ -14,7 +14,7 @@ Performs structural AST-aware rewrites via native ast-grep.
 </instruction>
 
 <output>
-- Replacement summary, per-file replacement counts, and change diffs as `¶src/foo.ts#0a`, `-12:before`, `+12:after` lines in hashline mode
+- Replacement summary, per-file replacement counts, and change diffs as `[src/foo.ts#1A2B]`, `-12:before`, `+12:after` lines in hashline mode
 - Parse issues when files cannot be processed
 </output>
 

package/src/prompts/tools/ast-grep.md

@@ -18,7 +18,7 @@ Performs structural code search using AST matching via native ast-grep.
 
 <output>
 - Grouped matches with file path, byte range, line/column ranges, metavariable captures
-- Match lines are numbered under a file snapshot tag header in hashline mode: `¶src/foo.ts#0a`, `*42:content` for the matched line, ` 43:content` for context
+- Match lines are numbered under a file snapshot tag header in hashline mode: `[src/foo.ts#1A2B]`, `*42:content` for the matched line, ` 43:content` for context
 - Summary counts (`totalMatches`, `filesWithMatches`, `filesSearched`) and parse issues when present
 </output>
 

package/src/prompts/tools/read.md

@@ -28,7 +28,7 @@ Append `:<sel>` to `path`. The bare path falls back to the default mode.
 
 - Reading a directory path returns a depth-limited dirent listing.
 {{#if IS_HL_MODE}}
-- Reading a file with an explicit selector emits a file snapshot tag header and numbered lines: `¶src/foo.ts#0a` then `41:def alpha():`. Copy the `¶PATH#TAG` header for anchored edits; ops use bare line numbers. NEVER fabricate the tag.
+- Reading a file with an explicit selector emits a file snapshot tag header and numbered lines: `[src/foo.ts#1A2B]` then `41:def alpha():`. Copy the `[PATH#TAG]` header for anchored edits; ops use bare line numbers. NEVER fabricate the tag.
 {{else}}
 {{#if IS_LINE_NUMBER_MODE}}
 - Reading a file with an explicit selector returns lines prefixed with line numbers: `41|def alpha():`.