@oh-my-pi/pi-coding-agent 14.1.2 → 14.2.1

package/src/lsp/client.ts

@@ -211,11 +211,19 @@ async function writeMessage(
 	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
 ): Promise<void> {
 	const content = JSON.stringify(message);
-	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n`);
-	sink.write(content);
+	sink.write(`Content-Length: ${Buffer.byteLength(content, "utf-8")}\r\n\r\n${content}`);
 	await sink.flush();
 }
 
+function queueWriteMessage(
+	client: LspClient,
+	message: LspJsonRpcRequest | LspJsonRpcNotification | LspJsonRpcResponse,
+): Promise<void> {
+	const write = client.writeQueue.catch(() => {}).then(() => writeMessage(client.proc.stdin, message));
+	client.writeQueue = write.catch(() => {});
+	return write;
+}
+
 // =============================================================================
 // Message Reader
 // =============================================================================
@@ -382,7 +390,7 @@ async function sendResponse(
 	};
 
 	try {
-		await writeMessage(client.proc.stdin, response);
+		await queueWriteMessage(client, response);
 	} catch (err) {
 		logger.error("LSP failed to respond.", { method, error: String(err) });
 	}
@@ -461,6 +469,7 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 			messageBuffer: new Uint8Array(0),
 			isReading: false,
 			lastActivity: Date.now(),
+			writeQueue: Promise.resolve(),
 			activeProgressTokens: new Set(),
 			projectLoaded,
 			resolveProjectLoaded,
@@ -848,7 +857,7 @@ export async function sendRequest(
 	});
 
 	// Write request
-	writeMessage(client.proc.stdin, request).catch(err => {
+	queueWriteMessage(client, request).catch(err => {
 		if (timeout) clearTimeout(timeout);
 		client.pendingRequests.delete(id);
 		cleanup();
@@ -868,7 +877,7 @@ export async function sendNotification(client: LspClient, method: string, params
 	};
 
 	client.lastActivity = Date.now();
-	await writeMessage(client.proc.stdin, notification);
+	await queueWriteMessage(client, notification);
 }
 
 /**

package/src/lsp/index.ts

@@ -40,6 +40,7 @@ import {
 	type LspParams,
 	type LspToolDetails,
 	lspSchema,
+	type Position,
 	type PublishedDiagnostics,
 	type ServerConfig,
 	type SymbolInformation,
@@ -262,6 +263,10 @@ function getLspServerForFile(config: LspConfig, filePath: string): [string, Serv
 	return servers.length > 0 ? servers[0] : null;
 }
 
+function isProjectAwareLspServer(serverConfig: ServerConfig): boolean {
+	return !serverConfig.createClient && !serverConfig.isLinter;
+}
+
 const DIAGNOSTIC_MESSAGE_LIMIT = 50;
 const SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS = 3000;
 const BATCH_DIAGNOSTICS_WAIT_TIMEOUT_MS = 400;
@@ -278,6 +283,21 @@ function limitDiagnosticMessages(messages: string[]): string[] {
 const LOCATION_CONTEXT_LINES = 1;
 const REFERENCE_CONTEXT_LIMIT = 50;
 
+const REFERENCES_RETRY_COUNT = 2;
+const REFERENCES_RETRY_DELAY_MS = 250;
+
+function comparePosition(a: Position, b: Position): number {
+	return a.line === b.line ? a.character - b.character : a.line - b.line;
+}
+
+function rangeContainsPosition(range: Location["range"], position: Position): boolean {
+	return comparePosition(range.start, position) <= 0 && comparePosition(position, range.end) <= 0;
+}
+
+function isOnlyQueriedDeclaration(locations: Location[], uri: string, position: Position): boolean {
+	return locations.length === 1 && locations[0]?.uri === uri && rangeContainsPosition(locations[0].range, position);
+}
+
 function normalizeLocationResult(result: Location | Location[] | LocationLink | LocationLink[] | null): Location[] {
 	if (!result) return [];
 	const raw = Array.isArray(result) ? result : [result];
@@ -560,6 +580,10 @@ async function getDiagnosticsForFile(
 			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
 			throwIfAborted(signal);
+			if (isProjectAwareLspServer(serverConfig)) {
+				await waitForProjectLoaded(client, signal);
+				throwIfAborted(signal);
+			}
 			// Content already synced + didSave sent, wait for fresh diagnostics
 			const minVersion = minVersions?.get(serverName);
 			const expectedDocumentVersion = expectedDocumentVersions?.get(serverName);
@@ -1220,6 +1244,10 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 							continue;
 						}
 						const client = await getOrCreateClient(serverConfig, this.session.cwd);
+						if (isProjectAwareLspServer(serverConfig)) {
+							await waitForProjectLoaded(client, signal);
+							throwIfAborted(signal);
+						}
 						const minVersion = client.diagnosticsVersion;
 						await refreshFile(client, resolved, signal);
 						const expectedDocumentVersion = client.openFiles.get(uri)?.version;
@@ -1512,16 +1540,31 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 					break;
 				}
 				case "references": {
-					const result = (await sendRequest(
-						client,
-						"textDocument/references",
-						{
-							textDocument: { uri },
-							position,
-							context: { includeDeclaration: true },
-						},
-						signal,
-					)) as Location[] | null;
+					let result: Location[] | null = null;
+					for (let attempt = 0; attempt <= REFERENCES_RETRY_COUNT; attempt++) {
+						result = (await sendRequest(
+							client,
+							"textDocument/references",
+							{
+								textDocument: { uri },
+								position,
+								context: { includeDeclaration: true },
+							},
+							signal,
+						)) as Location[] | null;
+
+						const locations = result ?? [];
+						if (!isProjectAwareLspServer(serverConfig) || attempt === REFERENCES_RETRY_COUNT) {
+							break;
+						}
+						if (locations.length > 0 && !isOnlyQueriedDeclaration(locations, uri, position)) {
+							break;
+						}
+
+						await waitForProjectLoaded(client, signal);
+						throwIfAborted(signal);
+						await untilAborted(signal, () => Bun.sleep(REFERENCES_RETRY_DELAY_MS));
+					}
 
 					if (!result || result.length === 0) {
 						output = "No references found";

package/src/lsp/render.ts

@@ -335,7 +335,9 @@ function renderDiagnostics(
 	const parsedDiagnostics = diagLines
 		.map(line => parseDiagnosticLine(line))
 		.filter((diag): diag is ParsedDiagnostic => diag !== null);
-	const fallbackDiagnostics: RawDiagnostic[] = diagLines.map(line => ({ raw: line.trim() }));
+	const fallbackDiagnostics: RawDiagnostic[] = diagLines.map(line => ({
+		raw: sanitizeDiagnosticDisplayText(line.trim()),
+	}));
 
 	if (expanded) {
 		let output = `${icon} ${theme.fg("dim", meta.join(theme.sep.dot))}`;
@@ -651,11 +653,21 @@ interface RawDiagnostic {
 
 type DiagnosticItem = ParsedDiagnostic | RawDiagnostic;
 
+function sanitizeDiagnosticDisplayText(text: string): string {
+	return replaceTabs(text);
+}
+
 function parseDiagnosticLine(line: string): ParsedDiagnostic | null {
 	const match = line.trim().match(/^(.*):(\d+):(\d+)\s+\[(\w+)\]\s*(.*)$/);
 	if (!match) return null;
 	const [, file, lineNum, colNum, severity, message] = match;
-	return { file, line: lineNum, col: colNum, severity: severity.toLowerCase(), message };
+	return {
+		file: sanitizeDiagnosticDisplayText(file),
+		line: lineNum,
+		col: colNum,
+		severity: severity.toLowerCase(),
+		message: sanitizeDiagnosticDisplayText(message),
+	};
 }
 
 function severityToColor(severity: string): "error" | "warning" | "accent" | "dim" {

package/src/lsp/types.ts

@@ -411,6 +411,8 @@ export interface LspClient {
 	isReading: boolean;
 	serverCapabilities?: LspServerCapabilities;
 	lastActivity: number;
+	/** Serializes outbound JSON-RPC writes to the server process. */
+	writeQueue: Promise<void>;
 	/** Tracks active work-done progress tokens from the server */
 	activeProgressTokens: Set<string | number>;
 	/** Resolves when the server's initial project loading completes (or after timeout) */

package/src/main.ts

@@ -85,6 +85,7 @@ const RPC_DEFAULTED_SETTING_PATHS: SettingPath[] = [
 	"task.isolation.merge",
 	"task.isolation.commits",
 	"task.eager",
+	"task.simple",
 	"task.maxConcurrency",
 	"task.maxRecursionDepth",
 	"task.disabledAgents",

package/src/mcp/manager.ts

@@ -176,6 +176,33 @@ export class MCPManager {
 		}
 	}
 
+	#subscribeAndTrack(name: string, connection: MCPServerConnection, uris: string[], notificationEpoch: number): void {
+		void subscribeToResources(connection, uris)
+			.then(() => {
+				const action = resolveSubscriptionPostAction(
+					this.#notificationsEnabled,
+					this.#notificationsEpoch,
+					notificationEpoch,
+				);
+				if (action === "rollback") {
+					void unsubscribeFromResources(connection, uris).catch(error => {
+						logger.debug("Failed to rollback stale MCP resource subscription", {
+							path: `mcp:${name}`,
+							error,
+						});
+					});
+					return;
+				}
+				if (action === "ignore") {
+					return;
+				}
+				this.#subscribedResources.set(name, new Set(uris));
+			})
+			.catch(error => {
+				logger.debug("Failed to subscribe to MCP resources", { path: `mcp:${name}`, error });
+			});
+	}
+
 	setNotificationsEnabled(enabled: boolean): void {
 		const wasEnabled = this.#notificationsEnabled;
 		this.#notificationsEnabled = enabled;
@@ -189,30 +216,7 @@ export class MCPManager {
 			for (const [name, connection] of this.#connections) {
 				if (connection.capabilities.resources?.subscribe && connection.resources) {
 					const uris = connection.resources.map(r => r.uri);
-					void subscribeToResources(connection, uris)
-						.then(() => {
-							const action = resolveSubscriptionPostAction(
-								this.#notificationsEnabled,
-								this.#notificationsEpoch,
-								notificationEpoch,
-							);
-							if (action === "rollback") {
-								void unsubscribeFromResources(connection, uris).catch(error => {
-									logger.debug("Failed to rollback stale MCP resource subscription", {
-										path: `mcp:${name}`,
-										error,
-									});
-								});
-								return;
-							}
-							if (action === "ignore") {
-								return;
-							}
-							this.#subscribedResources.set(name, new Set(uris));
-						})
-						.catch(error => {
-							logger.debug("Failed to subscribe to MCP resources", { path: `mcp:${name}`, error });
-						});
+					this.#subscribeAndTrack(name, connection, uris, notificationEpoch);
 				}
 			}
 			return;
@@ -830,30 +834,7 @@ export class MCPManager {
 				if (this.#notificationsEnabled && connection.capabilities.resources?.subscribe) {
 					const uris = resources.map(r => r.uri);
 					const notificationEpoch = this.#notificationsEpoch;
-					void subscribeToResources(connection, uris)
-						.then(() => {
-							const action = resolveSubscriptionPostAction(
-								this.#notificationsEnabled,
-								this.#notificationsEpoch,
-								notificationEpoch,
-							);
-							if (action === "rollback") {
-								void unsubscribeFromResources(connection, uris).catch(error => {
-									logger.debug("Failed to rollback stale MCP resource subscription", {
-										path: `mcp:${name}`,
-										error,
-									});
-								});
-								return;
-							}
-							if (action === "ignore") {
-								return;
-							}
-							this.#subscribedResources.set(name, new Set(uris));
-						})
-						.catch(error => {
-							logger.debug("Failed to subscribe to MCP resources", { path: `mcp:${name}`, error });
-						});
+					this.#subscribeAndTrack(name, connection, uris, notificationEpoch);
 				}
 			} catch (error) {
 				logger.debug("Failed to load MCP resources", { path: `mcp:${name}`, error });

package/src/memories/index.ts

@@ -48,6 +48,7 @@ interface MemoryRuntimeConfig {
 	phase2RetryDelaySeconds: number;
 	phase2HeartbeatSeconds: number;
 	rolloutPayloadPercent: number;
+	phase1InputTokenLimit: number;
 	fallbackTokenLimit: number;
 	summaryInjectionTokenLimit: number;
 }
@@ -66,6 +67,7 @@ const DEFAULTS: MemoryRuntimeConfig = {
 	phase2RetryDelaySeconds: 180,
 	phase2HeartbeatSeconds: 30,
 	rolloutPayloadPercent: 0.7,
+	phase1InputTokenLimit: 4_000,
 	fallbackTokenLimit: 16_000,
 	summaryInjectionTokenLimit: 5_000,
 };
@@ -582,7 +584,10 @@ async function runStage1Job(options: {
 		const rolloutRaw = await Bun.file(claim.rolloutPath).text();
 		const persisted = extractPersistableMessages(rolloutRaw);
 		const serializedItems = JSON.stringify(persisted);
-		const budgetTokens = Math.floor(modelMaxTokens * config.rolloutPayloadPercent);
+		const budgetTokens = Math.min(
+			config.phase1InputTokenLimit,
+			Math.floor(modelMaxTokens * config.rolloutPayloadPercent),
+		);
 		const truncatedItems = truncateByApproxTokens(serializedItems, budgetTokens);
 		const inputPrompt = prompt.render(stageOneInputTemplate, {
 			thread_id: claim.threadId,
@@ -1080,6 +1085,7 @@ function loadMemoryConfig(settings: Settings): MemoryRuntimeConfig {
 		phase2RetryDelaySeconds: settings.get("memories.phase2RetryDelaySeconds") ?? DEFAULTS.phase2RetryDelaySeconds,
 		phase2HeartbeatSeconds: settings.get("memories.phase2HeartbeatSeconds") ?? DEFAULTS.phase2HeartbeatSeconds,
 		rolloutPayloadPercent: settings.get("memories.rolloutPayloadPercent") ?? DEFAULTS.rolloutPayloadPercent,
+		phase1InputTokenLimit: settings.get("memories.phase1InputTokenLimit") ?? DEFAULTS.phase1InputTokenLimit,
 		fallbackTokenLimit: settings.get("memories.fallbackTokenLimit") ?? DEFAULTS.fallbackTokenLimit,
 		summaryInjectionTokenLimit:
 			settings.get("memories.summaryInjectionTokenLimit") ?? DEFAULTS.summaryInjectionTokenLimit,

package/src/modes/acp/acp-agent.ts

@@ -40,6 +40,7 @@ import {
 import type { Model } from "@oh-my-pi/pi-ai";
 import { logger, VERSION } from "@oh-my-pi/pi-utils";
 import type { ExtensionUIContext } from "../../extensibility/extensions";
+import { runExtensionCompact } from "../../extensibility/extensions/compact-handler";
 import { loadSlashCommands } from "../../extensibility/slash-commands";
 import { MCPManager } from "../../mcp/manager";
 import type { MCPServerConfig } from "../../mcp/types";
@@ -1163,14 +1164,7 @@ export class AcpAgent implements Agent {
 				shutdown: () => {},
 				getContextUsage: () => record.session.getContextUsage(),
 				getSystemPrompt: () => record.session.systemPrompt,
-				compact: async instructionsOrOptions => {
-					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
-					const options =
-						instructionsOrOptions && typeof instructionsOrOptions === "object"
-							? instructionsOrOptions
-							: undefined;
-					await record.session.compact(instructions, options);
-				},
+				compact: instructionsOrOptions => runExtensionCompact(record.session, instructionsOrOptions),
 			},
 			{
 				getContextUsage: () => record.session.getContextUsage(),
@@ -1197,14 +1191,7 @@ export class AcpAgent implements Agent {
 				reload: async () => {
 					await record.session.reload();
 				},
-				compact: async instructionsOrOptions => {
-					const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
-					const options =
-						instructionsOrOptions && typeof instructionsOrOptions === "object"
-							? instructionsOrOptions
-							: undefined;
-					await record.session.compact(instructions, options);
-				},
+				compact: instructionsOrOptions => runExtensionCompact(record.session, instructionsOrOptions),
 			},
 			acpExtensionUiContext,
 		);

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

@@ -43,6 +43,19 @@ function getAlphaSearchTokens(query: string): string[] {
 	return [...normalizeSearchText(query).matchAll(/[a-z]+/g)].map(match => match[0]).filter(token => token.length > 0);
 }
 
+function computeModelRank(model: Model, roles: Record<string, RoleAssignment | undefined>): number {
+	let i = 0;
+	while (i < MODEL_ROLE_IDS.length) {
+		const role = MODEL_ROLE_IDS[i];
+		const assigned = roles[role];
+		if (assigned && modelsAreEqual(assigned.model, model)) {
+			break;
+		}
+		i++;
+	}
+	return i;
+}
+
 interface ModelItem {
 	kind: "provider";
 	provider: string;
@@ -252,18 +265,7 @@ export class ModelSelectorComponent extends Container {
 		const mruOrder = this.#settings.getStorage()?.getModelUsageOrder() ?? [];
 		const mruIndex = new Map(mruOrder.map((key, i) => [key, i]));
 
-		const modelRank = (model: ModelItem) => {
-			let i = 0;
-			while (i < MODEL_ROLE_IDS.length) {
-				const role = MODEL_ROLE_IDS[i];
-				const assigned = this.#roles[role];
-				if (assigned && modelsAreEqual(assigned.model, model.model)) {
-					break;
-				}
-				i++;
-			}
-			return i;
-		};
+		const modelRank = (item: ModelItem) => computeModelRank(item.model, this.#roles);
 
 		const dateRe = /-(\d{8})$/;
 		const latestRe = /-latest$/;
@@ -325,18 +327,7 @@ export class ModelSelectorComponent extends Container {
 		const mruOrder = this.#settings.getStorage()?.getModelUsageOrder() ?? [];
 		const mruIndex = new Map(mruOrder.map((key, i) => [key, i]));
 
-		const modelRank = (model: CanonicalModelItem) => {
-			let i = 0;
-			while (i < MODEL_ROLE_IDS.length) {
-				const role = MODEL_ROLE_IDS[i];
-				const assigned = this.#roles[role];
-				if (assigned && modelsAreEqual(assigned.model, model.model)) {
-					break;
-				}
-				i++;
-			}
-			return i;
-		};
+		const modelRank = (item: CanonicalModelItem) => computeModelRank(item.model, this.#roles);
 
 		models.sort((a, b) => {
 			const aRank = modelRank(a);

package/src/modes/components/plugin-settings.ts

@@ -22,6 +22,21 @@ import type { InstalledPlugin, PluginSettingSchema } from "../../extensibility/p
 import { getSelectListTheme, getSettingsListTheme, theme } from "../../modes/theme/theme";
 import { DynamicBorder } from "./dynamic-border";
 
+/**
+ * Forwards a keystroke to `input`, but cancels via `onCancel` when the user presses Escape.
+ */
+export function handleInputOrEscape(
+	data: string,
+	input: { handleInput(data: string): void },
+	onCancel: () => void,
+): void {
+	if (data === "\x1b" || data === "\x1b\x1b") {
+		onCancel();
+		return;
+	}
+	input.handleInput(data);
+}
+
 // =============================================================================
 // Plugin List Component
 // =============================================================================
@@ -383,11 +398,7 @@ class ConfigInputSubmenu extends Container {
 	}
 
 	handleInput(data: string): void {
-		if (data === "\x1b" || data === "\x1b\x1b") {
-			this.onCancel();
-			return;
-		}
-		this.#input.handleInput(data);
+		handleInputOrEscape(data, this.#input, this.onCancel);
 	}
 }
 

package/src/modes/components/read-tool-group.ts

@@ -1,7 +1,8 @@
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Container, Text } from "@oh-my-pi/pi-tui";
-import { theme } from "../../modes/theme/theme";
-import { shortenPath } from "../../tools/render-utils";
+import { getLanguageFromPath, theme } from "../../modes/theme/theme";
+import { PREVIEW_LIMITS, shortenPath } from "../../tools/render-utils";
+import { renderCodeCell } from "../../tui";
 import type { ToolExecutionHandle } from "./tool-execution";
 
 type ReadRenderArgs = {
@@ -22,6 +23,10 @@ type ReadToolResultDetails = {
 	};
 };
 
+type ReadToolGroupOptions = {
+	showContentPreview?: boolean;
+};
+
 function getSuffixResolution(details: ReadToolResultDetails | undefined): ReadToolSuffixResolution | undefined {
 	if (typeof details?.suffixResolution?.from !== "string" || typeof details.suffixResolution.to !== "string") {
 		return undefined;
@@ -35,14 +40,21 @@ type ReadEntry = {
 	sel?: string;
 	status: "pending" | "success" | "warning" | "error";
 	correctedFrom?: string;
+	contentText?: string;
 };
 
+/** Number of code lines to show in collapsed preview mode */
+const COLLAPSED_PREVIEW_LINES = PREVIEW_LIMITS.OUTPUT_COLLAPSED;
+
 export class ReadToolGroupComponent extends Container implements ToolExecutionHandle {
 	#entries = new Map<string, ReadEntry>();
 	#text: Text;
+	#expanded = false;
+	#showContentPreview: boolean;
 
-	constructor() {
+	constructor(options: ReadToolGroupOptions = {}) {
 		super();
+		this.#showContentPreview = options.showContentPreview ?? false;
 		this.#text = new Text("", 0, 0);
 		this.addChild(this.#text);
 		this.#updateDisplay();
@@ -81,6 +93,11 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 			entry.correctedFrom = undefined;
 		}
 		entry.status = result.isError ? "error" : suffixResolution ? "warning" : "success";
+		// Store the text content for preview/expanded display
+		const textContent = result.content?.find(c => c.type === "text")?.text;
+		if (textContent !== undefined) {
+			entry.contentText = textContent;
+		}
 		this.#updateDisplay();
 	}
 
@@ -88,7 +105,8 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		this.#updateDisplay();
 	}
 
-	setExpanded(_expanded: boolean): void {
+	setExpanded(expanded: boolean): void {
+		this.#expanded = expanded;
 		this.#updateDisplay();
 	}
 
@@ -99,23 +117,37 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 	#updateDisplay(): void {
 		const entries = [...this.#entries.values()];
 
+		// Clear previous children and rebuild the summary and preview blocks.
+		this.clear();
+		this.#text = new Text("", 0, 0);
+
 		if (entries.length === 0) {
 			this.#text.setText(` ${theme.format.bullet} ${theme.fg("toolTitle", theme.bold("Read"))}`);
+			this.addChild(this.#text);
 			return;
 		}
 
 		if (entries.length === 1) {
 			const entry = entries[0];
-			const statusSymbol = this.#formatStatus(entry.status);
-			const pathDisplay = this.#formatPath(entry);
-			this.#text.setText(` ${statusSymbol} ${theme.fg("toolTitle", theme.bold("Read"))} ${pathDisplay}`.trimEnd());
+			if (!this.#shouldRenderPreview(entry)) {
+				const statusSymbol = this.#formatStatus(entry.status);
+				const pathDisplay = this.#formatPath(entry);
+				this.#text.setText(
+					` ${statusSymbol} ${theme.fg("toolTitle", theme.bold("Read"))} ${pathDisplay}`.trimEnd(),
+				);
+				this.addChild(this.#text);
+			}
+			if (this.#shouldRenderPreview(entry)) {
+				this.#addContentPreview(entry);
+			}
 			return;
 		}
 
 		const header = `${theme.fg("toolTitle", theme.bold("Read"))}${theme.fg("dim", ` (${entries.length})`)}`;
 		const lines = [` ${theme.format.bullet} ${header}`];
-		const total = entries.length;
-		for (const [index, entry] of entries.entries()) {
+		const entriesWithoutPreview = entries.filter(entry => !this.#shouldRenderPreview(entry));
+		const total = entriesWithoutPreview.length;
+		for (const [index, entry] of entriesWithoutPreview.entries()) {
 			const connector = index === total - 1 ? theme.tree.last : theme.tree.branch;
 			const statusSymbol = this.#formatStatus(entry.status);
 			const pathDisplay = this.#formatPath(entry);
@@ -123,6 +155,57 @@ export class ReadToolGroupComponent extends Container implements ToolExecutionHa
 		}
 
 		this.#text.setText(lines.join("\n"));
+		this.addChild(this.#text);
+
+		for (const entry of entries) {
+			if (this.#shouldRenderPreview(entry)) {
+				this.#addContentPreview(entry);
+			}
+		}
+	}
+
+	/**
+	 * Add a code-cell content preview below the entry summary.
+	 * When collapsed: shows first COLLAPSED_PREVIEW_LINES lines with "… N more lines (Ctrl+O for more)" hint.
+	 * When expanded: shows full content.
+	 */
+	#addContentPreview(entry: ReadEntry): void {
+		const lang = getLanguageFromPath(entry.path);
+		const filePath = shortenPath(entry.path);
+		const selectionSuffix = entry.sel ? `:${entry.sel}` : "";
+		const correctionSuffix = entry.correctedFrom ? ` (corrected from ${shortenPath(entry.correctedFrom)})` : "";
+		const title = filePath ? `Read ${filePath}${selectionSuffix}${correctionSuffix}` : `Read${selectionSuffix}`;
+		let cachedWidth: number | undefined;
+		let cachedLines: string[] | undefined;
+		const expanded = this.#expanded;
+		const component: Component = {
+			render: (width: number) => {
+				if (cachedLines && cachedWidth === width) return cachedLines;
+				cachedLines = renderCodeCell(
+					{
+						code: entry.contentText ?? "",
+						language: lang,
+						title,
+						status: entry.status === "success" ? "complete" : entry.status,
+						expanded,
+						codeMaxLines: expanded ? undefined : COLLAPSED_PREVIEW_LINES,
+						width,
+					},
+					theme,
+				);
+				cachedWidth = width;
+				return cachedLines;
+			},
+			invalidate: () => {
+				cachedWidth = undefined;
+				cachedLines = undefined;
+			},
+		};
+		this.addChild(component);
+	}
+
+	#shouldRenderPreview(entry: ReadEntry): boolean {
+		return this.#showContentPreview && entry.contentText !== undefined;
 	}
 
 	#formatPath(entry: ReadEntry): string {

package/src/modes/components/settings-defs.ts

@@ -145,6 +145,24 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		},
 		{ value: "never", label: "Never", description: "Stay on the fallback model until manually changed" },
 	],
+	// Task input mode
+	"task.simple": [
+		{
+			value: "default",
+			label: "Default",
+			description: "Shared context and custom task schema are available",
+		},
+		{
+			value: "schema-free",
+			label: "Schema-free",
+			description: "Shared context stays available, but custom task schema is disabled",
+		},
+		{
+			value: "independent",
+			label: "Independent",
+			description: "No shared context or custom task schema; each task must stand alone",
+		},
+	],
 	// Task max concurrency
 	"task.maxConcurrency": [
 		{ value: "0", label: "Unlimited" },