@howaboua/pi-codex-conversion 1.0.9 → 1.0.10

package/README.md

@@ -7,6 +7,7 @@ This package replaces Pi's default Codex/GPT experience with a narrower Codex-li
 - swaps active tools to `exec_command`, `write_stdin`, `apply_patch`, `view_image`, and native OpenAI Codex Responses `web_search` on `openai-codex`
 - preserves Pi's composed system prompt and applies a narrow Codex-oriented delta on top
 - renders exec activity with Codex-style command and background-terminal labels
+- renders `apply_patch` calls with Codex-style `Added` / `Edited` / `Deleted` diff blocks and Pi-style colored diff lines
 
 ![Available tools](./available-tools.png)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@howaboua/pi-codex-conversion",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Codex-oriented tool and prompt adapter for pi coding agent",
   "type": "module",
   "repository": {
@@ -51,8 +51,8 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*",
+    "@mariozechner/pi-coding-agent": "^0.62.0",
+    "@mariozechner/pi-tui": "^0.62.0",
     "@sinclair/typebox": "*"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { getCodexRuntimeShell } from "./adapter/runtime-shell.ts";
 import { CORE_ADAPTER_TOOL_NAMES, DEFAULT_TOOL_NAMES, STATUS_KEY, STATUS_TEXT, VIEW_IMAGE_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from "./adapter/tool-set.ts";
-import { registerApplyPatchTool } from "./tools/apply-patch-tool.ts";
+import { clearApplyPatchRenderState, registerApplyPatchTool } from "./tools/apply-patch-tool.ts";
 import { isCodexLikeContext, isOpenAICodexContext } from "./adapter/codex-model.ts";
 import { createExecCommandTracker } from "./tools/exec-command-state.ts";
 import { registerExecCommandTool } from "./tools/exec-command-tool.ts";
@@ -35,6 +35,16 @@ function getCommandArg(args: unknown): string | undefined {
 	return args.cmd;
 }
 
+function isToolCallOnlyAssistantMessage(message: unknown): boolean {
+	if (!message || typeof message !== "object" || !("role" in message) || message.role !== "assistant") {
+		return false;
+	}
+	if (!("content" in message) || !Array.isArray(message.content) || message.content.length === 0) {
+		return false;
+	}
+	return message.content.every((item) => typeof item === "object" && item !== null && "type" in item && item.type === "toolCall");
+}
+
 export default function codexConversion(pi: ExtensionAPI) {
 	const tracker = createExecCommandTracker();
 	const state: AdapterState = { enabled: false, promptSkills: [], webSearchNoticeShown: false };
@@ -46,12 +56,14 @@ export default function codexConversion(pi: ExtensionAPI) {
 	registerWebSearchTool(pi);
 	registerWebSearchSessionNoteRenderer(pi);
 
-	sessions.onSessionExit((_sessionId, command) => {
-		tracker.recordCommandFinished(command);
+	sessions.onSessionExit((sessionId) => {
+		tracker.recordSessionFinished(sessionId);
 	});
 
 	pi.on("session_start", async (_event, ctx) => {
 		state.webSearchNoticeShown = false;
+		clearApplyPatchRenderState();
+		tracker.clear();
 		syncAdapter(pi, ctx, state);
 	});
 
@@ -59,8 +71,17 @@ export default function codexConversion(pi: ExtensionAPI) {
 		syncAdapter(pi, ctx, state);
 	});
 
+	pi.on("message_start", async (event) => {
+		if (event.message.role === "toolResult") return;
+		if (isToolCallOnlyAssistantMessage(event.message)) return;
+		tracker.resetExplorationGroup();
+	});
+
 	pi.on("tool_execution_start", async (event) => {
-		if (event.toolName !== "exec_command") return;
+		if (event.toolName !== "exec_command") {
+			tracker.resetExplorationGroup();
+			return;
+		}
 		const command = getCommandArg(event.args);
 		if (!command) return;
 		tracker.recordStart(event.toolCallId, command);
@@ -72,6 +93,7 @@ export default function codexConversion(pi: ExtensionAPI) {
 	});
 
 	pi.on("session_shutdown", async () => {
+		clearApplyPatchRenderState();
 		sessions.shutdown();
 	});
 

package/src/shell/parse-command.ts

@@ -61,8 +61,6 @@ function parseCommandImpl(command: string[]): ParsedShellCommand[] {
 		const parsed = summarizeMainTokens(tokens);
 		if (parsed.kind === "read" && cwd) {
 			commands.push({ ...parsed, path: joinPaths(cwd, parsed.path) });
-		} else if (parsed.kind === "list" && cwd && !parsed.path) {
-			commands.push({ ...parsed, path: shortDisplayPath(cwd) });
 		} else {
 			commands.push(parsed);
 		}

package/src/shell/parse.ts

@@ -18,12 +18,6 @@ export function parseShellPart(tokens: string[], cwd?: string): ShellAction | nu
 			path: joinPaths(cwd, parsed.path),
 		};
 	}
-	if (parsed.kind === "list" && cwd && !parsed.path) {
-		return {
-			...parsed,
-			path: shortDisplayPath(cwd),
-		};
-	}
 
 	return parsed;
 }

package/src/shell/tokenize.ts

@@ -84,10 +84,21 @@ export function shellSplit(input: string): string[] {
 
 export function shellQuote(token: string): string {
 	if (token.length === 0) return "''";
-	if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(token)) return token;
+	if (canEmitUnquoted(token)) return token;
 	return `'${token.replace(/'/g, `'"'"'`)}'`;
 }
 
+function canEmitUnquoted(token: string): boolean {
+	for (const char of token) {
+		if (!isUnquotedOk(char)) return false;
+	}
+	return true;
+}
+
+function isUnquotedOk(char: string): boolean {
+	return /^[+\-./:@\]_0-9A-Za-z]$/.test(char);
+}
+
 export function joinCommandTokens(tokens: string[]): string {
 	return tokens
 		.map((token) => (token === "&&" || token === "||" || token === "|" || token === ";" ? token : shellQuote(token)))

package/src/tools/apply-patch-rendering.ts

@@ -0,0 +1,352 @@
+import { isAbsolute, relative } from "node:path";
+import { renderDiff } from "@mariozechner/pi-coding-agent";
+import { openFileAtPath } from "../patch/paths.ts";
+import { parsePatchActions } from "../patch/parser.ts";
+import type { ParsedPatchAction } from "../patch/types.ts";
+
+interface PreviewLine {
+	lineNumber: number;
+	marker: " " | "+" | "-";
+	text: string;
+}
+
+interface FilePreview {
+	verb: "Added" | "Deleted" | "Edited";
+	path: string;
+	movePath?: string;
+	added: number;
+	removed: number;
+	lines: PreviewLine[];
+}
+
+export function formatApplyPatchSummary(patchText: string, cwd = process.cwd()): string {
+	let actions: ParsedPatchAction[];
+	try {
+		actions = parsePatchActions({ text: patchText });
+	} catch {
+		return "apply_patch patch";
+	}
+
+	const files = actions.map((action) => buildFilePreview(action, cwd));
+	if (files.length === 0) {
+		return "apply_patch patch";
+	}
+
+	const totalAdded = files.reduce((sum, file) => sum + file.added, 0);
+	const totalRemoved = files.reduce((sum, file) => sum + file.removed, 0);
+	const lines: string[] = [];
+
+	if (files.length === 1) {
+		const [file] = files;
+		lines.push(`${bulletHeader(file.verb, renderPath(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
+		return lines.join("\n");
+	}
+
+	lines.push(`${bulletHeader("Edited", `${files.length} files`)} ${renderCounts(totalAdded, totalRemoved)}`);
+	for (const [index, file] of files.entries()) {
+		const prefix = index === 0 ? "  └ " : "    ";
+		lines.push(`${prefix}${renderPath(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
+	}
+
+	return lines.join("\n");
+}
+
+export function formatApplyPatchCall(patchText: string, cwd = process.cwd()): string {
+	let actions: ParsedPatchAction[];
+	try {
+		actions = parsePatchActions({ text: patchText });
+	} catch {
+		return "apply_patch patch";
+	}
+
+	const files = actions.map((action) => buildFilePreview(action, cwd));
+	if (files.length === 0) {
+		return "apply_patch patch";
+	}
+
+	const totalAdded = files.reduce((sum, file) => sum + file.added, 0);
+	const totalRemoved = files.reduce((sum, file) => sum + file.removed, 0);
+	const lines: string[] = [];
+
+	if (files.length === 1) {
+		const [file] = files;
+		lines.push(`${bulletHeader(file.verb, renderPath(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
+		lines.push(...file.lines.map((line) => formatPreviewLine(line, file.lines)));
+		return lines.join("\n");
+	}
+
+	lines.push(`${bulletHeader("Edited", `${files.length} files`)} ${renderCounts(totalAdded, totalRemoved)}`);
+	for (const [index, file] of files.entries()) {
+		if (index > 0) {
+			lines.push("");
+		}
+		lines.push(`  └ ${renderPath(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
+		lines.push(...file.lines.map((line) => formatPreviewLine(line, file.lines)));
+	}
+
+	return lines.join("\n");
+}
+
+export function renderApplyPatchCall(patchText: string, cwd = process.cwd()): string {
+	let actions: ParsedPatchAction[];
+	try {
+		actions = parsePatchActions({ text: patchText });
+	} catch {
+		return "apply_patch patch";
+	}
+
+	const files = actions.map((action) => buildFilePreview(action, cwd));
+	if (files.length === 0) {
+		return "apply_patch patch";
+	}
+
+	const totalAdded = files.reduce((sum, file) => sum + file.added, 0);
+	const totalRemoved = files.reduce((sum, file) => sum + file.removed, 0);
+	const lines: string[] = [];
+
+	if (files.length === 1) {
+		const [file] = files;
+		lines.push(`${bulletHeader(file.verb, renderPath(file.path, file.movePath, cwd))} ${renderCounts(file.added, file.removed)}`);
+		lines.push(...renderPreviewLines(file.lines));
+		return lines.join("\n");
+	}
+
+	lines.push(`${bulletHeader("Edited", `${files.length} files`)} ${renderCounts(totalAdded, totalRemoved)}`);
+	for (const [index, file] of files.entries()) {
+		if (index > 0) {
+			lines.push("");
+		}
+		lines.push(`  └ ${renderPath(file.path, file.movePath, cwd)} ${renderCounts(file.added, file.removed)}`);
+		lines.push(...renderPreviewLines(file.lines));
+	}
+
+	return lines.join("\n");
+}
+
+function buildFilePreview(action: ParsedPatchAction, cwd: string): FilePreview {
+	if (action.type === "add") {
+		const lines = splitFileLines(action.newFile ?? "");
+		return {
+			verb: "Added",
+			path: action.path,
+			added: lines.length,
+			removed: 0,
+			lines: lines.map((text, index) => ({ lineNumber: index + 1, marker: "+", text })),
+		};
+	}
+
+	if (action.type === "delete") {
+		const deletedLines = readFileLines(action.path, cwd);
+		return {
+			verb: "Deleted",
+			path: action.path,
+			added: 0,
+			removed: deletedLines.length,
+			lines: deletedLines.map((text, index) => ({ lineNumber: index + 1, marker: "-", text })),
+		};
+	}
+
+	const preview = buildUpdatePreview(action, cwd);
+	return {
+		verb: "Edited",
+		path: action.path,
+		movePath: action.movePath,
+		added: preview.added,
+		removed: preview.removed,
+		lines: preview.lines,
+	};
+}
+
+function buildUpdatePreview(action: ParsedPatchAction, cwd: string): { added: number; removed: number; lines: PreviewLine[] } {
+	if (!action.lines) {
+		return { added: 0, removed: 0, lines: [] };
+	}
+
+	const originalLines = readFileLines(action.path, cwd);
+	const renderedLines: PreviewLine[] = [];
+	let added = 0;
+	let removed = 0;
+	let searchStart = 0;
+	let delta = 0;
+	let index = 0;
+
+	while (index < action.lines.length) {
+		const line = action.lines[index];
+		if (line === "*** End of File") {
+			break;
+		}
+		if (!line.startsWith("@@")) {
+			index += 1;
+			continue;
+		}
+
+		index += 1;
+		const sectionLines: string[] = [];
+		while (index < action.lines.length && !action.lines[index].startsWith("@@") && action.lines[index] !== "*** End of File") {
+			sectionLines.push(action.lines[index]);
+			index += 1;
+		}
+
+		if (sectionLines.length === 0) {
+			continue;
+		}
+
+		const oldSequence = sectionLines
+			.map(normalizePatchLine)
+			.filter((entry) => entry.marker === " " || entry.marker === "-")
+			.map((entry) => entry.text);
+		const sectionStart = findMatchingSequence(originalLines, oldSequence, searchStart);
+		let oldLineNumber = sectionStart + 1;
+		let newLineNumber = sectionStart + 1 + delta;
+
+		for (const rawLine of sectionLines) {
+			const entry = normalizePatchLine(rawLine);
+			if (entry.marker === "+") {
+				added += 1;
+				renderedLines.push({ lineNumber: newLineNumber, marker: "+", text: entry.text });
+				newLineNumber += 1;
+				continue;
+			}
+
+			if (entry.marker === "-") {
+				removed += 1;
+				renderedLines.push({ lineNumber: oldLineNumber, marker: "-", text: entry.text });
+				oldLineNumber += 1;
+				continue;
+			}
+
+			renderedLines.push({ lineNumber: newLineNumber, marker: " ", text: entry.text });
+			oldLineNumber += 1;
+			newLineNumber += 1;
+		}
+
+		searchStart = sectionStart + oldSequence.length;
+		delta += sectionLines.reduce((sum, rawLine) => {
+			const marker = normalizePatchLine(rawLine).marker;
+			if (marker === "+") return sum + 1;
+			if (marker === "-") return sum - 1;
+			return sum;
+		}, 0);
+	}
+
+	return { added, removed, lines: renderedLines };
+}
+
+function formatPreviewLine(line: PreviewLine, lines: PreviewLine[]): string {
+	const numberWidth = Math.max(1, ...lines.map((entry) => String(entry.lineNumber).length));
+	return `    ${String(line.lineNumber).padStart(numberWidth, " ")} ${line.marker}${line.text}`;
+}
+
+function renderPreviewLines(lines: PreviewLine[]): string[] {
+	if (lines.length === 0) {
+		return [];
+	}
+
+	const numberWidth = Math.max(1, ...lines.map((entry) => String(entry.lineNumber).length));
+	const diffText = lines
+		.map((line) => `${line.marker}${String(line.lineNumber).padStart(numberWidth, " ")} ${line.text}`)
+		.join("\n");
+	try {
+		return renderDiff(diffText)
+			.split("\n")
+			.map((line) => `    ${line}`);
+	} catch {
+		return lines.map((line) => formatPreviewLine(line, lines));
+	}
+}
+
+function normalizePatchLine(rawLine: string): PreviewLine {
+	const normalized = rawLine === "" ? " " : rawLine;
+	const marker = normalized[0];
+	if (marker !== " " && marker !== "+" && marker !== "-") {
+		return { lineNumber: 0, marker: " ", text: rawLine };
+	}
+	return { lineNumber: 0, marker, text: normalized.slice(1) };
+}
+
+function findMatchingSequence(lines: string[], context: string[], start: number): number {
+	if (context.length === 0) {
+		return start;
+	}
+
+	const exact = findSequence(lines, context, start, (value) => value);
+	if (exact !== -1) {
+		return exact;
+	}
+
+	const trimEnd = findSequence(lines, context, start, (value) => value.trimEnd());
+	if (trimEnd !== -1) {
+		return trimEnd;
+	}
+
+	const trim = findSequence(lines, context, start, (value) => value.trim());
+	if (trim !== -1) {
+		return trim;
+	}
+
+	return start;
+}
+
+function findSequence(lines: string[], context: string[], start: number, normalize: (value: string) => string): number {
+	for (let lineIndex = start; lineIndex <= lines.length - context.length; lineIndex += 1) {
+		let matches = true;
+		for (let contextIndex = 0; contextIndex < context.length; contextIndex += 1) {
+			if (normalize(lines[lineIndex + contextIndex]) !== normalize(context[contextIndex])) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) {
+			return lineIndex;
+		}
+	}
+	return -1;
+}
+
+function renderPath(path: string, movePath: string | undefined, cwd: string): string {
+	const from = displayPath(path, cwd);
+	if (!movePath) {
+		return from;
+	}
+	return `${from} → ${displayPath(movePath, cwd)}`;
+}
+
+function displayPath(path: string, cwd: string): string {
+	if (!isAbsolute(path)) {
+		return path;
+	}
+
+	const relativePath = relative(cwd, path);
+	if (relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath)) {
+		return relativePath;
+	}
+
+	return path;
+}
+
+function readFileLines(path: string, cwd: string): string[] {
+	try {
+		return splitFileLines(openFileAtPath({ cwd, path }));
+	} catch {
+		return [];
+	}
+}
+
+function splitFileLines(text: string): string[] {
+	if (text.length === 0) {
+		return [];
+	}
+	const lines = text.split("\n");
+	if (lines.at(-1) === "") {
+		lines.pop();
+	}
+	return lines;
+}
+
+function bulletHeader(verb: string, label: string): string {
+	return `• ${verb} ${label}`;
+}
+
+function renderCounts(added: number, removed: number): string {
+	return `(+${added} -${removed})`;
+}

package/src/tools/apply-patch-tool.ts

@@ -1,8 +1,9 @@
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
+import { Container, Text } from "@mariozechner/pi-tui";
 import { executePatch } from "../patch/core.ts";
 import type { ExecutePatchResult } from "../patch/types.ts";
+import { formatApplyPatchSummary, renderApplyPatchCall } from "./apply-patch-rendering.ts";
 
 const APPLY_PATCH_PARAMETERS = Type.Object({
 	input: Type.String({
@@ -10,6 +11,21 @@ const APPLY_PATCH_PARAMETERS = Type.Object({
 	}),
 });
 
+interface ApplyPatchRenderState {
+	cwd: string;
+	collapsed: string;
+	expanded: string;
+}
+
+const applyPatchRenderStates = new Map<string, ApplyPatchRenderState>();
+
+interface ApplyPatchRenderContextLike {
+	toolCallId?: string;
+	cwd?: string;
+	expanded?: boolean;
+	argsComplete?: boolean;
+}
+
 function parseApplyPatchParams(params: unknown): { patchText: string } {
 	if (!params || typeof params !== "object" || !("input" in params) || typeof params.input !== "string") {
 		throw new Error("apply_patch requires a string 'input' parameter");
@@ -23,6 +39,28 @@ function isExecutePatchResult(details: unknown): details is ExecutePatchResult {
 
 export type { ExecutePatchResult } from "../patch/types.ts";
 
+export function clearApplyPatchRenderState(): void {
+	applyPatchRenderStates.clear();
+}
+
+const renderApplyPatchCallWithOptionalContext: any = (
+	args: { input?: unknown },
+	theme: { fg(role: string, text: string): string; bold(text: string): string },
+	context?: ApplyPatchRenderContextLike,
+) => {
+	if (context?.argsComplete === false) {
+		return new Text(`${theme.fg("dim", "•")} ${theme.bold("Patching")}`, 0, 0);
+	}
+	const patchText = typeof args.input === "string" ? args.input : "";
+	if (patchText.trim().length === 0) {
+		return new Text(`${theme.fg("dim", "•")} ${theme.bold("Patching")}`, 0, 0);
+	}
+	const cached = context?.toolCallId ? applyPatchRenderStates.get(context.toolCallId) : undefined;
+	const cwd = context?.cwd ?? cached?.cwd;
+	const text = context?.expanded ? cached?.expanded ?? renderApplyPatchCall(patchText, cwd) : cached?.collapsed ?? formatApplyPatchSummary(patchText, cwd);
+	return new Text(text, 0, 0);
+};
+
 export function registerApplyPatchTool(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "apply_patch",
@@ -31,12 +69,17 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 		promptSnippet: "Edit files with a patch.",
 		promptGuidelines: ["Prefer apply_patch for focused textual edits instead of rewriting whole files."],
 		parameters: APPLY_PATCH_PARAMETERS,
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			if (signal?.aborted) {
 				throw new Error("apply_patch aborted");
 			}
 
 			const typedParams = parseApplyPatchParams(params);
+			applyPatchRenderStates.set(toolCallId, {
+				cwd: ctx.cwd,
+				collapsed: formatApplyPatchSummary(typedParams.patchText, ctx.cwd),
+				expanded: renderApplyPatchCall(typedParams.patchText, ctx.cwd),
+			});
 			const result = executePatch({ cwd: ctx.cwd, patchText: typedParams.patchText });
 			const summary = [
 				"Applied patch successfully.",
@@ -52,33 +95,17 @@ export function registerApplyPatchTool(pi: ExtensionAPI): void {
 				details: result,
 			};
 		},
-		renderCall(_args, theme) {
-			return new Text(`${theme.fg("toolTitle", theme.bold("apply_patch"))} ${theme.fg("muted", "patch")}`, 0, 0);
-		},
-		renderResult(result, { isPartial, expanded }, theme) {
+		renderCall: renderApplyPatchCallWithOptionalContext,
+		renderResult(result, { isPartial }, theme) {
 			if (isPartial) {
-				return new Text(theme.fg("warning", "Applying patch..."), 0, 0);
+				return new Text(`${theme.fg("dim", "•")} ${theme.bold("Patching")}`, 0, 0);
 			}
 
-			const details = isExecutePatchResult(result.details) ? result.details : undefined;
-			if (!details) {
-				return new Text(theme.fg("success", "Patch applied"), 0, 0);
+			if (!isExecutePatchResult(result.details)) {
+				return new Container();
 			}
 
-			let text = theme.fg("success", "Patch applied");
-			text += theme.fg(
-				"dim",
-				` (${details.changedFiles.length} changed, ${details.createdFiles.length} created, ${details.deletedFiles.length} deleted)`,
-			);
-			if (expanded) {
-				for (const file of details.changedFiles) {
-					text += `\n${theme.fg("dim", file)}`;
-				}
-				for (const move of details.movedFiles) {
-					text += `\n${theme.fg("accent", move)}`;
-				}
-			}
-			return new Text(text, 0, 0);
+			return new Container();
 		},
 	});
 }

package/src/tools/codex-rendering.ts

@@ -8,7 +8,11 @@ export interface RenderTheme {
 
 export function renderExecCommandCall(command: string, state: ExecCommandStatus, theme: RenderTheme): string {
 	const summary = summarizeShellCommand(command);
-	return summary.maskAsExplored ? renderExplorationText(summary.actions, state, theme) : renderCommandText(command, state, theme);
+	return summary.maskAsExplored ? renderExplorationText([summary.actions], state, theme) : renderCommandText(command, state, theme);
+}
+
+export function renderGroupedExecCommandCall(actionGroups: ShellAction[][], state: ExecCommandStatus, theme: RenderTheme): string {
+	return renderExplorationText(actionGroups, state, theme);
 }
 
 export function renderWriteStdinCall(
@@ -32,11 +36,11 @@ export function renderWriteStdinCall(
 	return text;
 }
 
-function renderExplorationText(actions: ShellAction[], state: ExecCommandStatus, theme: RenderTheme): string {
+function renderExplorationText(actionGroups: ShellAction[][], state: ExecCommandStatus, theme: RenderTheme): string {
 	const header = state === "running" ? "Exploring" : "Explored";
 	let text = `${theme.fg("dim", "•")} ${theme.bold(header)}`;
 
-	for (const [index, line] of coalesceReads(actions).map(formatActionLine).entries()) {
+	for (const [index, line] of coalesceReadGroups(actionGroups).map(formatActionLine).entries()) {
 		const prefix = index === 0 ? "  └ " : "    ";
 		text += `\n${theme.fg("dim", prefix)}${theme.fg("accent", line.title)} ${theme.fg("muted", line.body)}`;
 	}
@@ -83,13 +87,56 @@ function formatActionLine(action: ShellAction): { title: string; body: string }
 	return { title: "Run", body: action.command };
 }
 
-function coalesceReads(actions: ShellAction[]): ShellAction[] {
-	if (!actions.every((action) => action.kind !== "run")) return actions;
-	const reads = actions.filter((action): action is Extract<ShellAction, { kind: "read" }> => action.kind === "read");
-	if (reads.length !== actions.length) {
-		return actions;
+function coalesceReadGroups(actionGroups: ShellAction[][]): ShellAction[] {
+	const flattened: ShellAction[] = [];
+
+	for (let index = 0; index < actionGroups.length; index += 1) {
+		const actions = actionGroups[index];
+		if (actions.every((action) => action.kind === "read")) {
+			const reads: Extract<ShellAction, { kind: "read" }>[] = [];
+			const seenPaths = new Set<string>();
+			let lastRead: Extract<ShellAction, { kind: "read" }> | undefined;
+
+			for (let readIndex = index; readIndex < actionGroups.length; readIndex += 1) {
+				const readActions = actionGroups[readIndex];
+				if (!readActions.every((action) => action.kind === "read")) {
+					break;
+				}
+
+				for (const action of readActions) {
+					if (action.kind !== "read") continue;
+					lastRead = action;
+					if (seenPaths.has(action.path)) continue;
+					seenPaths.add(action.path);
+					reads.push(action);
+				}
+
+				index = readIndex;
+			}
+
+			if (lastRead) {
+				const duplicateNames = new Set<string>();
+				const seenNames = new Set<string>();
+				for (const read of reads) {
+					if (seenNames.has(read.name)) {
+						duplicateNames.add(read.name);
+						continue;
+					}
+					seenNames.add(read.name);
+				}
+				const labels = reads.map((read) => (duplicateNames.has(read.name) ? read.path : read.name));
+				flattened.push({
+					kind: "read",
+					command: labels.join(" && "),
+					name: labels.join(", "),
+					path: lastRead.path,
+				});
+			}
+			continue;
+		}
+
+		flattened.push(...actions);
 	}
 
-	const names = [...new Set(reads.map((action) => action.name))];
-	return [{ kind: "read", command: reads.map((action) => action.command).join(" && "), name: names.join(", "), path: reads[0].path }];
+	return flattened;
 }

package/src/tools/exec-command-state.ts

@@ -1,43 +1,215 @@
+import { summarizeShellCommand, type CommandSummary, type ShellAction } from "../shell/summary.ts";
+
 export type ExecCommandStatus = "running" | "done";
 
+export interface ExecCommandRenderInfo {
+	hidden: boolean;
+	status: ExecCommandStatus;
+	actionGroups?: ShellAction[][];
+}
+
+interface ExecEntry {
+	toolCallId: string;
+	command: string;
+	summary: CommandSummary;
+	status: ExecCommandStatus;
+	hidden: boolean;
+	groupId?: number;
+	invalidate?: () => void;
+}
+
+interface ExecGroup {
+	id: number;
+	entryIds: string[];
+	visibleEntryId: string;
+}
+
 export interface ExecCommandTracker {
 	getState(command: string): ExecCommandStatus;
+	getRenderInfo(toolCallId: string | undefined, command: string): ExecCommandRenderInfo;
+	registerRenderContext(toolCallId: string | undefined, invalidate: () => void): void;
 	recordStart(toolCallId: string, command: string): void;
-	recordPersistentSession(command: string): void;
+	recordPersistentSession(toolCallId: string, sessionId: number): void;
 	recordEnd(toolCallId: string): void;
-	recordCommandFinished(command: string): void;
+	recordSessionFinished(sessionId: number): void;
+	resetExplorationGroup(): void;
+	clear(): void;
 }
 
 export function createExecCommandTracker(): ExecCommandTracker {
 	const commandByToolCallId = new Map<string, string>();
-	const executionStateByCommand = new Map<string, ExecCommandStatus>();
-	const persistentCommands = new Set<string>();
+	const runningCountsByCommand = new Map<string, number>();
+	const sessionBackedToolCallIds = new Set<string>();
+	const toolCallIdBySessionId = new Map<number, string>();
+	const entriesByToolCallId = new Map<string, ExecEntry>();
+	const groupsById = new Map<number, ExecGroup>();
+	let activeExplorationGroupId: number | undefined;
+	let nextGroupId = 1;
+
+	function incrementCommand(command: string): void {
+		runningCountsByCommand.set(command, (runningCountsByCommand.get(command) ?? 0) + 1);
+	}
+
+	function decrementCommand(command: string): void {
+		const next = (runningCountsByCommand.get(command) ?? 0) - 1;
+		if (next > 0) {
+			runningCountsByCommand.set(command, next);
+			return;
+		}
+		runningCountsByCommand.delete(command);
+	}
+
+	function invalidateToolCall(toolCallId: string | undefined): void {
+		if (!toolCallId) return;
+		entriesByToolCallId.get(toolCallId)?.invalidate?.();
+	}
+
+	function findLatestEntryByCommand(command: string): ExecEntry | undefined {
+		let latest: ExecEntry | undefined;
+		for (const entry of entriesByToolCallId.values()) {
+			if (entry.command !== command) continue;
+			latest = entry;
+		}
+		return latest;
+	}
+
+	function getGroupForEntry(entry: ExecEntry | undefined): ExecGroup | undefined {
+		if (!entry?.groupId) return undefined;
+		return groupsById.get(entry.groupId);
+	}
+
+	function getVisibleEntry(group: ExecGroup | undefined): ExecEntry | undefined {
+		if (!group) return undefined;
+		return entriesByToolCallId.get(group.visibleEntryId);
+	}
 
 	return {
 		getState(command) {
-			return executionStateByCommand.get(command) ?? "running";
+			return (runningCountsByCommand.get(command) ?? 0) > 0 ? "running" : "done";
+		},
+		getRenderInfo(toolCallId, command) {
+			if (!toolCallId) {
+				return { hidden: false, status: (runningCountsByCommand.get(command) ?? 0) > 0 ? "running" : "done" };
+			}
+
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!entry) {
+				return { hidden: false, status: (runningCountsByCommand.get(command) ?? 0) > 0 ? "running" : "done" };
+			}
+
+			if (entry.hidden) {
+				return { hidden: true, status: entry.status };
+			}
+
+			const group = getGroupForEntry(entry);
+			if (!group) {
+				return {
+					hidden: false,
+					status: entry.status,
+					actionGroups: entry.summary.maskAsExplored ? [entry.summary.actions] : undefined,
+				};
+			}
+
+			const entries = group.entryIds
+				.map((groupEntryId) => entriesByToolCallId.get(groupEntryId))
+				.filter((groupEntry): groupEntry is ExecEntry => Boolean(groupEntry));
+			return {
+				hidden: false,
+				status: entries.some((groupEntry) => groupEntry.status === "running") ? "running" : "done",
+				actionGroups: entries.map((groupEntry) => groupEntry.summary.actions),
+			};
+		},
+		registerRenderContext(toolCallId, invalidate) {
+			if (!toolCallId) return;
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!entry) return;
+			entry.invalidate = invalidate;
 		},
 		recordStart(toolCallId, command) {
 			commandByToolCallId.set(toolCallId, command);
-			executionStateByCommand.set(command, "running");
+			incrementCommand(command);
+
+			const summary = summarizeShellCommand(command);
+			const entry: ExecEntry = {
+				toolCallId,
+				command,
+				summary,
+				status: "running",
+				hidden: false,
+			};
+			entriesByToolCallId.set(toolCallId, entry);
+
+			if (!summary.maskAsExplored) {
+				activeExplorationGroupId = undefined;
+				return;
+			}
+
+			let group = activeExplorationGroupId ? groupsById.get(activeExplorationGroupId) : undefined;
+			if (!group) {
+				group = { id: nextGroupId++, entryIds: [toolCallId], visibleEntryId: toolCallId };
+				groupsById.set(group.id, group);
+				activeExplorationGroupId = group.id;
+				entry.groupId = group.id;
+				return;
+			}
+
+			const previousVisibleEntry = getVisibleEntry(group);
+			if (previousVisibleEntry) {
+				previousVisibleEntry.hidden = true;
+				invalidateToolCall(previousVisibleEntry.toolCallId);
+			}
+
+			group.entryIds.push(toolCallId);
+			group.visibleEntryId = toolCallId;
+			entry.groupId = group.id;
 		},
-		recordPersistentSession(command) {
-			persistentCommands.add(command);
-			executionStateByCommand.set(command, "running");
+		recordPersistentSession(toolCallId, sessionId) {
+			sessionBackedToolCallIds.add(toolCallId);
+			toolCallIdBySessionId.set(sessionId, toolCallId);
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!entry) return;
+			entry.status = "running";
+			const group = getGroupForEntry(entry);
+			invalidateToolCall(group?.visibleEntryId ?? entry.toolCallId);
 		},
 		recordEnd(toolCallId) {
 			const command = commandByToolCallId.get(toolCallId);
 			if (!command) return;
-			// Pi renderers do not currently receive toolCallId, so we track the
-			// last-known state per command string for compact Exploring/Explored UI.
-			if (!persistentCommands.has(command)) {
-				executionStateByCommand.set(command, "done");
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!sessionBackedToolCallIds.has(toolCallId)) {
+				decrementCommand(command);
+				if (entry) {
+					entry.status = "done";
+				}
 			}
+			const group = getGroupForEntry(entry);
+			invalidateToolCall(group?.visibleEntryId ?? toolCallId);
 			commandByToolCallId.delete(toolCallId);
 		},
-		recordCommandFinished(command) {
-			persistentCommands.delete(command);
-			executionStateByCommand.set(command, "done");
+		recordSessionFinished(sessionId) {
+			const toolCallId = toolCallIdBySessionId.get(sessionId);
+			if (!toolCallId) return;
+			toolCallIdBySessionId.delete(sessionId);
+			const entry = entriesByToolCallId.get(toolCallId);
+			if (!entry) return;
+			decrementCommand(entry.command);
+			entry.status = "done";
+			sessionBackedToolCallIds.delete(toolCallId);
+			const group = getGroupForEntry(entry);
+			invalidateToolCall(group?.visibleEntryId ?? entry.toolCallId);
+		},
+		resetExplorationGroup() {
+			activeExplorationGroupId = undefined;
+		},
+		clear() {
+			commandByToolCallId.clear();
+			runningCountsByCommand.clear();
+			sessionBackedToolCallIds.clear();
+			toolCallIdBySessionId.clear();
+			entriesByToolCallId.clear();
+			groupsById.clear();
+			activeExplorationGroupId = undefined;
+			nextGroupId = 1;
 		},
 	};
 }

package/src/tools/exec-command-tool.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { Text } from "@mariozechner/pi-tui";
-import { renderExecCommandCall } from "./codex-rendering.ts";
+import { Container, Text } from "@mariozechner/pi-tui";
+import { renderExecCommandCall, renderGroupedExecCommandCall } from "./codex-rendering.ts";
 import type { ExecCommandTracker } from "./exec-command-state.ts";
 import type { ExecSessionManager, UnifiedExecResult } from "./exec-session-manager.ts";
 import { formatUnifiedExecResult } from "./unified-exec-format.ts";
@@ -56,6 +56,62 @@ function isUnifiedExecResult(details: unknown): details is UnifiedExecResult {
 	return typeof details === "object" && details !== null;
 }
 
+function createEmptyResultComponent(): Container {
+	return new Container();
+}
+
+interface ExecCommandRenderContextLike {
+	toolCallId?: string;
+	invalidate?: () => void;
+}
+
+const renderExecCommandCallWithOptionalContext: any = (
+	args: { cmd?: unknown },
+	theme: { fg(role: string, text: string): string; bold(text: string): string },
+	context: ExecCommandRenderContextLike | undefined,
+	tracker: ExecCommandTracker,
+) => {
+	const command = typeof args.cmd === "string" ? args.cmd : "";
+	tracker.registerRenderContext(context?.toolCallId, context?.invalidate ?? (() => {}));
+	const renderInfo = tracker.getRenderInfo(context?.toolCallId, command);
+	if (renderInfo.hidden) {
+		return new Text("", 0, 0);
+	}
+	const text = renderInfo.actionGroups
+		? renderGroupedExecCommandCall(renderInfo.actionGroups, renderInfo.status, theme)
+		: renderExecCommandCall(command, renderInfo.status, theme);
+	return new Text(text, 0, 0);
+};
+
+const renderExecCommandResultWithOptionalContext: any = (
+	result: { content: Array<{ type: string; text?: string }>; details?: unknown },
+	options: { expanded: boolean; isPartial: boolean },
+	theme: { fg(role: string, text: string): string },
+	context: ExecCommandRenderContextLike | undefined,
+	tracker: ExecCommandTracker,
+) => {
+	if (options.isPartial || !options.expanded) {
+		return createEmptyResultComponent();
+	}
+
+	const command = context && "args" in context && context.args && typeof (context as any).args.cmd === "string" ? (context as any).args.cmd : undefined;
+	if (tracker.getRenderInfo(context?.toolCallId, command ?? "").hidden) {
+		return createEmptyResultComponent();
+	}
+
+	const details = isUnifiedExecResult(result.details) ? result.details : undefined;
+	const content = result.content.find((item) => item.type === "text");
+	const output = details?.output ?? (content?.type === "text" ? content.text : "");
+	let text = theme.fg("dim", output || "(no output)");
+	if (details?.session_id !== undefined) {
+		text += `\n${theme.fg("accent", `Session ${details.session_id} still running`)}`;
+	}
+	if (details?.exit_code !== undefined) {
+		text += `\n${theme.fg("muted", `Exit code: ${details.exit_code}`)}`;
+	}
+	return new Text(text, 0, 0);
+};
+
 export function registerExecCommandTool(pi: ExtensionAPI, tracker: ExecCommandTracker, sessions: ExecSessionManager): void {
 	pi.registerTool({
 		name: "exec_command",
@@ -68,40 +124,27 @@ export function registerExecCommandTool(pi: ExtensionAPI, tracker: ExecCommandTr
 			"Keep tty disabled unless the command truly needs interactive terminal behavior.",
 		],
 		parameters: EXEC_COMMAND_PARAMETERS,
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			if (signal?.aborted) {
 				throw new Error("exec_command aborted");
 			}
 			const typedParams = parseExecCommandParams(params);
 			const result = await sessions.exec(typedParams, ctx.cwd, signal);
 			if (result.session_id !== undefined) {
-				tracker.recordPersistentSession(typedParams.cmd);
+				tracker.recordPersistentSession(toolCallId, result.session_id);
 			}
 			return {
 				content: [{ type: "text", text: formatUnifiedExecResult(result, typedParams.cmd) }],
 				details: result,
 			};
 		},
-		renderCall(args, theme) {
-			const command = typeof args.cmd === "string" ? args.cmd : "";
-			return new Text(renderExecCommandCall(command, tracker.getState(command), theme), 0, 0);
-		},
-		renderResult(result, { expanded, isPartial }, theme) {
-			if (isPartial || !expanded) {
-				return undefined;
-			}
-
-			const details = isUnifiedExecResult(result.details) ? result.details : undefined;
-			const content = result.content.find((item) => item.type === "text");
-			const output = details?.output ?? (content?.type === "text" ? content.text : "");
-			let text = theme.fg("dim", output || "(no output)");
-			if (details?.session_id !== undefined) {
-				text += `\n${theme.fg("accent", `Session ${details.session_id} still running`)}`;
-			}
-			if (details?.exit_code !== undefined) {
-				text += `\n${theme.fg("muted", `Exit code: ${details.exit_code}`)}`;
-			}
-			return new Text(text, 0, 0);
-		},
+		renderCall: ((args: { cmd?: unknown }, theme: { fg(role: string, text: string): string; bold(text: string): string }, context?: ExecCommandRenderContextLike) =>
+			renderExecCommandCallWithOptionalContext(args, theme, context, tracker)) as any,
+		renderResult: ((
+			result: { content: Array<{ type: string; text?: string }>; details?: unknown },
+			options: { expanded: boolean; isPartial: boolean },
+			theme: { fg(role: string, text: string): string },
+			context?: ExecCommandRenderContextLike,
+		) => renderExecCommandResultWithOptionalContext(result, options, theme, context, tracker)) as any,
 	});
 }

package/src/tools/web-search-tool.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { Box, Text } from "@mariozechner/pi-tui";
+import { Box, Container, Text } from "@mariozechner/pi-tui";
 import { isOpenAICodexModel } from "../adapter/codex-model.ts";
 
 export const WEB_SEARCH_UNSUPPORTED_MESSAGE = "web_search is only available with the openai-codex provider";
@@ -56,6 +56,10 @@ function isWebSearchFunctionTool(tool: unknown): tool is FunctionToolPayload {
 	return !!tool && typeof tool === "object" && (tool as FunctionToolPayload).type === "function" && (tool as FunctionToolPayload).name === "web_search";
 }
 
+function createEmptyResultComponent(): Container {
+	return new Container();
+}
+
 export function rewriteNativeWebSearchTool(payload: unknown, model: ExtensionContext["model"]): unknown {
 	if (!supportsNativeWebSearch(model) || !payload || typeof payload !== "object") {
 		return payload;
@@ -113,7 +117,7 @@ export function createWebSearchTool(): ToolDefinition<typeof WEB_SEARCH_PARAMETE
 		},
 		renderResult(result, { expanded }, theme) {
 			if (!expanded) {
-				return undefined;
+				return createEmptyResultComponent();
 			}
 			const textBlock = result.content.find((item) => item.type === "text");
 			const text = textBlock?.type === "text" ? textBlock.text : "(no output)";

package/src/tools/write-stdin-tool.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { Text } from "@mariozechner/pi-tui";
+import { Container, Text } from "@mariozechner/pi-tui";
 import { renderWriteStdinCall } from "./codex-rendering.ts";
 import type { ExecSessionManager, UnifiedExecResult } from "./exec-session-manager.ts";
 import { formatUnifiedExecResult } from "./unified-exec-format.ts";
@@ -100,6 +100,10 @@ function isUnifiedExecResult(details: unknown): details is UnifiedExecResult {
 	return typeof details === "object" && details !== null;
 }
 
+function createEmptyResultComponent(): Container {
+	return new Container();
+}
+
 export function registerWriteStdinTool(pi: ExtensionAPI, sessions: ExecSessionManager): void {
 	pi.registerTool({
 		name: "write_stdin",
@@ -129,7 +133,7 @@ export function registerWriteStdinTool(pi: ExtensionAPI, sessions: ExecSessionMa
 			return new Text(renderWriteStdinCall(sessionId, input, command, theme), 0, 0);
 		},
 		renderResult(result, { expanded, isPartial }, theme) {
-			if (isPartial || !expanded) return undefined;
+			if (isPartial || !expanded) return createEmptyResultComponent();
 			const state = getResultState(result);
 			const output = renderTerminalText(state.output);
 			let text = theme.fg("dim", output || "(no output)");