@oh-my-pi/pi-coding-agent 7.0.0 → 8.0.1

package/src/{core/tools/task → task}/index.ts

@@ -13,25 +13,25 @@
  *   - Session artifacts for debugging
  */
 
-import { mkdir, rm } from "node:fs/promises";
+import { mkdir, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
+import { $ } from "bun";
 import { nanoid } from "nanoid";
-import type { Theme } from "../../../modes/interactive/theme/theme";
-import taskDescriptionTemplate from "../../../prompts/tools/task.md" with { type: "text" };
-import { renderPromptTemplate } from "../../prompt-templates";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import type { Theme } from "$c/modes/theme/theme";
+import taskDescriptionTemplate from "$c/prompts/tools/task.md" with { type: "text" };
+import { formatDuration } from "$c/tools/render-utils";
 import type { ToolSession } from "..";
-import { formatDuration } from "../render-utils";
 import { discoverAgents, getAgent } from "./discovery";
 import { runSubprocess } from "./executor";
 import { mapWithConcurrencyLimit } from "./parallel";
 import { renderCall, renderResult } from "./render";
-import { renderTemplate, validateTaskTemplate } from "./template";
+import { renderTemplate } from "./template";
 import {
 	type AgentProgress,
-	MAX_AGENTS_IN_DESCRIPTION,
 	MAX_CONCURRENCY,
 	MAX_PARALLEL_TASKS,
 	type SingleResult,
@@ -39,9 +39,17 @@ import {
 	type TaskToolDetails,
 	taskSchema,
 } from "./types";
+import {
+	applyBaseline,
+	captureBaseline,
+	captureDeltaPatch,
+	cleanupWorktree,
+	ensureWorktree,
+	getRepoRoot,
+} from "./worktree";
 
 // Import review tools for side effects (registers subagent tool handlers)
-import "../review";
+import "../tools/review";
 
 /** Format byte count for display */
 function formatBytes(bytes: number): string {
@@ -103,8 +111,7 @@ async function buildDescription(cwd: string): Promise<string> {
 	const { agents } = await discoverAgents(cwd);
 
 	return renderPromptTemplate(taskDescriptionTemplate, {
-		agents: agents.slice(0, MAX_AGENTS_IN_DESCRIPTION),
-		moreAgents: agents.length > MAX_AGENTS_IN_DESCRIPTION ? agents.length - MAX_AGENTS_IN_DESCRIPTION : 0,
+		agents,
 		MAX_PARALLEL_TASKS,
 		MAX_CONCURRENCY,
 	});
@@ -153,7 +160,8 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 	): Promise<AgentToolResult<TaskToolDetails>> {
 		const startTime = Date.now();
 		const { agents, projectAgentsDir } = await discoverAgents(this.session.cwd);
-		const { agent: agentName, context, model, output: outputSchema } = params;
+		const { agent: agentName, context, output: outputSchema, isolated } = params;
+		const isIsolated = isolated === true;
 
 		const isDefaultModelAlias = (value: string | undefined): boolean => {
 			if (!value) return true;
@@ -180,9 +188,9 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			};
 		}
 
-		const shouldInheritSessionModel = model === undefined && isDefaultModelAlias(agent.model);
-		const sessionModel = shouldInheritSessionModel ? this.session.getActiveModelString?.() : undefined;
-		const modelOverride = model ?? sessionModel ?? this.session.getModelString?.();
+		const effectiveAgentModel = isDefaultModelAlias(agent.model) ? undefined : agent.model;
+		const modelOverride =
+			effectiveAgentModel ?? this.session.getActiveModelString?.() ?? this.session.getModelString?.();
 		const thinkingLevelOverride = agent.thinkingLevel;
 
 		// Output schema priority: agent frontmatter > params > inherited from parent session
@@ -195,7 +203,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				content: [
 					{
 						type: "text",
-						text: `No tasks provided. Use: { agent, context, tasks: [{id, description, vars}, ...] }`,
+						text: `No tasks provided. Use: { agent, context, tasks: [{id, description, args}, ...] }`,
 					},
 				],
 				details: {
@@ -271,16 +279,28 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			};
 		}
 
-		const templateError = validateTaskTemplate(context, tasks);
-		if (templateError) {
-			return {
-				content: [{ type: "text", text: templateError }],
-				details: {
-					projectAgentsDir,
-					results: [],
-					totalDurationMs: 0,
-				},
-			};
+		let repoRoot: string | null = null;
+		let baseline = null as Awaited<ReturnType<typeof captureBaseline>> | null;
+		if (isIsolated) {
+			try {
+				repoRoot = await getRepoRoot(this.session.cwd);
+				baseline = await captureBaseline(repoRoot);
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Isolated task execution requires a git repository. ${message}`,
+						},
+					],
+					details: {
+						projectAgentsDir,
+						results: [],
+						totalDurationMs: Date.now() - startTime,
+					},
+				};
+			}
 		}
 
 		// Derive artifacts directory
@@ -347,25 +367,19 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			}
 
 			// Build full prompts with context prepended
-			const contextTemplate = context ?? "";
-			const tasksWithContext = tasks.map((t) => ({
-				task: renderTemplate(contextTemplate, t.vars),
-				description: t.description,
-				taskId: t.id,
-				vars: t.vars,
-			}));
+			const tasksWithContext = tasks.map((t) => renderTemplate(context, t));
 
 			// Initialize progress for all tasks
 			for (let i = 0; i < tasksWithContext.length; i++) {
 				const t = tasksWithContext[i];
 				progressMap.set(i, {
 					index: i,
-					taskId: t.taskId,
+					id: t.id,
 					agent: agentName,
 					agentSource: agent.source,
 					status: "pending",
 					task: t.task,
-					vars: t.vars,
+					args: t.args,
 					recentTools: [],
 					recentOutput: [],
 					toolCount: 0,
@@ -377,18 +391,15 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 			}
 			emitProgress();
 
-			// Execute in parallel with concurrency limit
-			const { results: partialResults, aborted } = await mapWithConcurrencyLimit(
-				tasksWithContext,
-				MAX_CONCURRENCY,
-				async (task, index) => {
+			const runTask = async (task: (typeof tasksWithContext)[number], index: number) => {
+				if (!isIsolated) {
 					return runSubprocess({
 						cwd: this.session.cwd,
 						agent,
 						task: task.task,
 						description: task.description,
 						index,
-						taskId: task.taskId,
+						id: task.id,
 						context: undefined, // Already prepended above
 						modelOverride,
 						thinkingLevel: thinkingLevelOverride,
@@ -402,7 +413,7 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						onProgress: (progress) => {
 							progressMap.set(index, {
 								...structuredClone(progress),
-								vars: tasksWithContext[index]?.vars,
+								args: tasksWithContext[index]?.args,
 							});
 							emitProgress();
 						},
@@ -411,7 +422,83 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 						settingsManager: this.session.settingsManager,
 						mcpManager: this.session.mcpManager,
 					});
-				},
+				}
+
+				const taskStart = Date.now();
+				let worktreeDir: string | undefined;
+				try {
+					if (!repoRoot || !baseline) {
+						throw new Error("Isolated task execution not initialized.");
+					}
+					worktreeDir = await ensureWorktree(repoRoot, task.id);
+					await applyBaseline(worktreeDir, baseline);
+					const result = await runSubprocess({
+						cwd: this.session.cwd,
+						worktree: worktreeDir,
+						agent,
+						task: task.task,
+						description: task.description,
+						index,
+						id: task.id,
+						context: undefined, // Already prepended above
+						modelOverride,
+						thinkingLevel: thinkingLevelOverride,
+						outputSchema: effectiveOutputSchema,
+						sessionFile,
+						persistArtifacts: !!artifactsDir,
+						artifactsDir: effectiveArtifactsDir,
+						enableLsp: false,
+						signal,
+						eventBus: undefined,
+						onProgress: (progress) => {
+							progressMap.set(index, {
+								...structuredClone(progress),
+								args: tasksWithContext[index]?.args,
+							});
+							emitProgress();
+						},
+						authStorage: this.session.authStorage,
+						modelRegistry: this.session.modelRegistry,
+						settingsManager: this.session.settingsManager,
+						mcpManager: this.session.mcpManager,
+					});
+					const patch = await captureDeltaPatch(worktreeDir, baseline);
+					const patchPath = path.join(effectiveArtifactsDir, `${task.id}.patch`);
+					await Bun.write(patchPath, patch);
+					return {
+						...result,
+						patchPath,
+					};
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					return {
+						index,
+						id: task.id,
+						agent: agent.name,
+						agentSource: agent.source,
+						task: task.task,
+						description: task.description,
+						exitCode: 1,
+						output: "",
+						stderr: message,
+						truncated: false,
+						durationMs: Date.now() - taskStart,
+						tokens: 0,
+						modelOverride,
+						error: message,
+					};
+				} finally {
+					if (worktreeDir) {
+						await cleanupWorktree(worktreeDir);
+					}
+				}
+			};
+
+			// Execute in parallel with concurrency limit
+			const { results: partialResults, aborted } = await mapWithConcurrencyLimit(
+				tasksWithContext,
+				MAX_CONCURRENCY,
+				runTask,
 				signal,
 			);
 
@@ -420,17 +507,17 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				if (result !== undefined) {
 					return {
 						...result,
-						vars: tasksWithContext[index]?.vars,
+						args: tasksWithContext[index]?.args,
 					};
 				}
 				const task = tasksWithContext[index];
 				return {
 					index,
-					taskId: task.taskId,
+					id: task.id,
 					agent: agentName,
 					agentSource: agent.source,
 					task: task.task,
-					vars: task.vars,
+					args: task.args,
 					description: task.description,
 					exitCode: 1,
 					output: "",
@@ -456,10 +543,75 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 
 			// Collect output paths (artifacts already written by executor in real-time)
 			const outputPaths: string[] = [];
+			const patchPaths: string[] = [];
 			for (const result of results) {
 				if (result.outputPath) {
 					outputPaths.push(result.outputPath);
 				}
+				if (result.patchPath) {
+					patchPaths.push(result.patchPath);
+				}
+			}
+
+			let patchApplySummary = "";
+			let patchesApplied: boolean | null = null;
+			if (isIsolated) {
+				const patchesInOrder = results.map((result) => result.patchPath).filter(Boolean) as string[];
+				const missingPatch = results.some((result) => !result.patchPath);
+				if (!repoRoot || missingPatch) {
+					patchesApplied = false;
+				} else {
+					const patchStats = await Promise.all(
+						patchesInOrder.map(async (patchPath) => ({
+							patchPath,
+							size: (await stat(patchPath)).size,
+						})),
+					);
+					const nonEmptyPatches = patchStats.filter((patch) => patch.size > 0).map((patch) => patch.patchPath);
+					if (nonEmptyPatches.length === 0) {
+						patchesApplied = true;
+					} else {
+						const patchTexts = await Promise.all(
+							nonEmptyPatches.map(async (patchPath) => Bun.file(patchPath).text()),
+						);
+						const combinedPatch = patchTexts.map((text) => (text.endsWith("\n") ? text : `${text}\n`)).join("");
+						if (!combinedPatch.trim()) {
+							patchesApplied = true;
+						} else {
+							const combinedPatchPath = path.join(tmpdir(), `omp-task-combined-${nanoid()}.patch`);
+							try {
+								await Bun.write(combinedPatchPath, combinedPatch);
+								const checkResult = await $`git apply --check --binary ${combinedPatchPath}`
+									.cwd(repoRoot)
+									.quiet()
+									.nothrow();
+								if (checkResult.exitCode !== 0) {
+									patchesApplied = false;
+								} else {
+									const applyResult = await $`git apply --binary ${combinedPatchPath}`
+										.cwd(repoRoot)
+										.quiet()
+										.nothrow();
+									patchesApplied = applyResult.exitCode === 0;
+								}
+							} finally {
+								await rm(combinedPatchPath, { force: true });
+							}
+						}
+					}
+				}
+
+				if (patchesApplied) {
+					patchApplySummary = "\n\nApplied patches: yes";
+				} else {
+					const notification =
+						"<system-notification>Patches were not applied and must be handled manually.</system-notification>";
+					const patchList =
+						patchPaths.length > 0
+							? `\n\nPatch artifacts:\n${patchPaths.map((patch) => `- ${patch}`).join("\n")}`
+							: "";
+					patchApplySummary = `\n\n${notification}${patchList}`;
+				}
 			}
 
 			// Build final output - match plugin format
@@ -474,22 +626,26 @@ export class TaskTool implements AgentTool<typeof taskSchema, TaskToolDetails, T
 				const meta = r.outputMeta
 					? ` [${r.outputMeta.lineCount} lines, ${formatBytes(r.outputMeta.charCount)}]`
 					: "";
-				return `[${r.agent}] ${status}${meta} ${r.taskId}\n${preview}`;
+				return `[${r.agent}] ${status}${meta} ${r.id}\n${preview}`;
 			});
 
-			const outputIds = results.filter((r) => !r.aborted || r.output.trim()).map((r) => r.taskId);
+			const outputIds = results.filter((r) => !r.aborted || r.output.trim()).map((r) => r.id);
 			const outputHint =
-				outputIds.length > 0 ? `\n\nUse output tool for full logs: output ids ${outputIds.join(", ")}` : "";
+				outputIds.length > 0
+					? `\n\nUse read with agent:// for full logs: ${outputIds.map((id) => `agent://${id}`).join(", ")}`
+					: "";
 			const schemaNote = schemaOverridden
 				? `\n\nNote: Agent '${agentName}' has a fixed output schema; your 'output' parameter was ignored.\nRequired schema: ${JSON.stringify(agent.output)}`
 				: "";
 			const cancelledNote = aborted && cancelledCount > 0 ? ` (${cancelledCount} cancelled)` : "";
 			const summary = `${successCount}/${results.length} succeeded${cancelledNote} [${formatDuration(
 				totalDuration,
-			)}]\n\n${summaries.join("\n\n---\n\n")}${outputHint}${schemaNote}`;
+			)}]\n\n${summaries.join("\n\n---\n\n")}${outputHint}${schemaNote}${patchApplySummary}`;
 
 			// Cleanup temp directory if used
-			if (tempArtifactsDir) {
+			const shouldCleanupTempArtifacts =
+				tempArtifactsDir && (!isIsolated || patchesApplied === true || patchesApplied === null);
+			if (shouldCleanupTempArtifacts) {
 				await rm(tempArtifactsDir, { recursive: true, force: true });
 			}
 

package/src/{core/tools/task → task}/render.ts

@@ -8,8 +8,8 @@
 import path from "node:path";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Container, Text } from "@oh-my-pi/pi-tui";
-import type { Theme } from "../../../modes/interactive/theme/theme";
-import type { RenderResultOptions } from "../../custom-tools/types";
+import type { RenderResultOptions } from "$c/extensibility/custom-tools/types";
+import type { Theme } from "$c/modes/theme/theme";
 import {
 	formatBadge,
 	formatDuration,
@@ -17,14 +17,14 @@ import {
 	formatStatusIcon,
 	formatTokens,
 	truncate,
-} from "../render-utils";
+} from "$c/tools/render-utils";
 import {
 	type FindingPriority,
 	getPriorityInfo,
 	PRIORITY_LABELS,
 	type ReportFindingDetails,
 	type SubmitReviewDetails,
-} from "../review";
+} from "$c/tools/review";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import type { AgentProgress, SingleResult, TaskParams, TaskToolDetails } from "./types";
 
@@ -236,7 +236,7 @@ function renderOutputSection(
 		try {
 			const parsed = JSON.parse(trimmedOutput);
 
-			// Collapsed: inline format like Vars
+			// Collapsed: inline format like Args
 			if (!expanded) {
 				lines.push(`${continuePrefix}${theme.fg("dim", formatOutputInline(parsed, theme))}`);
 				return lines;
@@ -276,11 +276,25 @@ function renderOutputSection(
 	return lines;
 }
 
-function formatVarsInline(vars: Record<string, string>, theme: Theme): string {
-	const entries = Object.entries(vars);
-	if (entries.length === 0) return "Vars: none";
+function formatArgsInline(args: Record<string, string>, theme: Theme): string {
+	const entries = Object.entries(args);
+	if (entries.length === 0) return "No arguments";
+
+	// Single variable: show inline as "Key: value" without tree structure
+	if (entries.length === 1) {
+		const [key, value] = entries[0];
+		const humanKey = humanizeKey(key);
+		const displayValue = `"${truncate(value, 32, theme.format.ellipsis)}"`;
+		return `${humanKey}: ${displayValue}`;
+	}
+
 	const pairs = entries.map(([key, value]) => `${key}=${truncate(value, 24, theme.format.ellipsis)}`);
-	return `Vars: ${pairs.join(", ")}`;
+	return `Args: ${pairs.join(", ")}`;
+}
+
+/** Convert snake_case or kebab-case to Title Case */
+function humanizeKey(key: string): string {
+	return key.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 
 function formatScalarInline(value: unknown, maxLen: number, theme: Theme): string {
@@ -336,22 +350,37 @@ function formatOutputInline(data: unknown, theme: Theme, maxWidth = 80): string
 	return `Output: ${pairs.join(", ")}`;
 }
 
-function renderVarsSection(
-	vars: Record<string, string> | undefined,
+function renderArgsSection(
+	args: Record<string, string> | undefined,
 	continuePrefix: string,
 	expanded: boolean,
 	theme: Theme,
 ): string[] {
-	if (!vars || Object.keys(vars).length === 0) return [];
+	if (!args) return [];
+	// Filter out auto-injected id and description
+	const filteredArgs = Object.fromEntries(
+		Object.entries(args).filter(([key]) => key !== "id" && key !== "description"),
+	);
+	if (Object.keys(filteredArgs).length === 0) return [];
 	const lines: string[] = [];
+	const entries = Object.entries(filteredArgs);
 
 	if (!expanded) {
-		lines.push(`${continuePrefix}${theme.fg("dim", formatVarsInline(vars, theme))}`);
+		lines.push(`${continuePrefix}${theme.fg("dim", formatArgsInline(filteredArgs, theme))}`);
+		return lines;
+	}
+
+	// Single variable: show inline as "Key: value" without tree structure
+	if (entries.length === 1) {
+		const [key, value] = entries[0];
+		const humanKey = humanizeKey(key);
+		const displayValue = `"${truncate(value, 60, theme.format.ellipsis)}"`;
+		lines.push(`${continuePrefix}${theme.fg("dim", `${humanKey}: ${displayValue}`)}`);
 		return lines;
 	}
 
-	lines.push(`${continuePrefix}${theme.fg("dim", "Vars")}`);
-	const tree = renderJsonTreeLines(vars, theme, 4, 16);
+	lines.push(`${continuePrefix}${theme.fg("dim", "Args")}`);
+	const tree = renderJsonTreeLines(filteredArgs, theme, 4, 16);
 	for (const line of tree.lines) {
 		lines.push(`${continuePrefix}  ${line}`);
 	}
@@ -380,6 +409,7 @@ export function renderCall(args: TaskParams, theme: Theme): Component {
 	const branch = theme.fg("dim", theme.tree.branch);
 	const last = theme.fg("dim", theme.tree.last);
 	const vertical = theme.fg("dim", theme.tree.vertical);
+	const showIsolated = args.isolated === true;
 
 	if (hasContext) {
 		lines.push(` ${branch} ${theme.fg("dim", "Context")}`);
@@ -387,11 +417,18 @@ export function renderCall(args: TaskParams, theme: Theme): Component {
 			const content = line ? theme.fg("muted", line) : "";
 			lines.push(` ${vertical}  ${content}`);
 		}
-		lines.push(` ${last} ${theme.fg("dim", "Tasks")}: ${theme.fg("muted", `${args.tasks.length} agents`)}`);
+		const taskPrefix = showIsolated ? branch : last;
+		lines.push(` ${taskPrefix} ${theme.fg("dim", "Tasks")}: ${theme.fg("muted", `${args.tasks.length} agents`)}`);
+		if (showIsolated) {
+			lines.push(` ${last} ${theme.fg("dim", "Isolated")}: ${theme.fg("muted", "true")}`);
+		}
 		return new Text(lines.join("\n"), 0, 0);
 	}
 
 	lines.push(`${theme.fg("dim", "Tasks")}: ${theme.fg("muted", `${args.tasks.length} agents`)}`);
+	if (showIsolated) {
+		lines.push(`${theme.fg("dim", "Isolated")}: ${theme.fg("muted", "true")}`);
+	}
 
 	return new Text(lines.join("\n"), 0, 0);
 }
@@ -418,9 +455,9 @@ function renderAgentProgress(
 				? "error"
 				: "accent";
 
-	// Main status line: taskId: description [status] · stats · ⟨agent⟩
+	// Main status line: id: description [status] · stats · ⟨agent⟩
 	const description = progress.description?.trim();
-	const titlePart = description ? `${theme.bold(progress.taskId)}: ${description}` : progress.taskId;
+	const titlePart = description ? `${theme.bold(progress.id)}: ${description}` : progress.id;
 	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)}`;
 
 	// Only show badge for non-running states (spinner already indicates running)
@@ -445,7 +482,7 @@ function renderAgentProgress(
 
 	lines.push(statusLine);
 
-	lines.push(...renderVarsSection(progress.vars, continuePrefix, expanded, theme));
+	lines.push(...renderArgsSection(progress.args, continuePrefix, expanded, theme));
 
 	// Current tool (if running) or most recent completed tool
 	if (progress.status === "running") {
@@ -638,9 +675,9 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	const iconColor = success ? "success" : "error";
 	const statusText = aborted ? "aborted" : success ? "done" : "failed";
 
-	// Main status line: taskId: description [status] · stats · ⟨agent⟩
+	// Main status line: id: description [status] · stats · ⟨agent⟩
 	const description = result.description?.trim();
-	const titlePart = description ? `${theme.bold(result.taskId)}: ${description}` : result.taskId;
+	const titlePart = description ? `${theme.bold(result.id)}: ${description}` : result.id;
 	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)} ${formatBadge(
 		statusText,
 		iconColor,
@@ -656,7 +693,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	}
 
 	lines.push(statusLine);
-	lines.push(...renderVarsSection(result.vars, continuePrefix, expanded, theme));
+	lines.push(...renderArgsSection(result.args, continuePrefix, expanded, theme));
 
 	// Check for review result (complete with review schema + report_finding)
 	const completeData = result.extractedToolData?.complete as Array<{ data: unknown }> | undefined;
@@ -722,6 +759,10 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 		lines.push(...renderOutputSection(result.output, continuePrefix, expanded, theme, 3, 12));
 	}
 
+	if (result.patchPath && !aborted && result.exitCode === 0) {
+		lines.push(`${continuePrefix}${theme.fg("dim", `Patch: ${result.patchPath}`)}`);
+	}
+
 	// Error message
 	if (result.error && !success) {
 		lines.push(`${continuePrefix}${theme.fg("error", truncate(result.error, 70, theme.format.ellipsis))}`);
@@ -739,6 +780,7 @@ export function renderResult(
 	theme: Theme,
 ): Component {
 	const { expanded, isPartial, spinnerFrame } = options;
+	const fallbackText = result.content.find((c) => c.type === "text")?.text ?? "";
 	const details = result.details;
 
 	if (!details) {
@@ -785,7 +827,22 @@ export function renderResult(
 	}
 
 	if (lines.length === 0) {
-		return new Text(theme.fg("dim", "No results"), 0, 0);
+		const text = fallbackText.trim() ? fallbackText : "No results";
+		return new Text(theme.fg("dim", truncate(text, 140, theme.format.ellipsis)), 0, 0);
+	}
+
+	if (fallbackText.trim()) {
+		const summaryLines = fallbackText.split("\n");
+		const markerIndex = summaryLines.findIndex(
+			(line) => line.includes("<system-notification>") || line.startsWith("Applied patches:"),
+		);
+		if (markerIndex >= 0) {
+			const extra = summaryLines.slice(markerIndex);
+			for (const line of extra) {
+				if (!line.trim()) continue;
+				lines.push(theme.fg("dim", line));
+			}
+		}
 	}
 
 	const indented = lines.map((line) => (line.trim() ? `   ${line}` : ""));

package/src/{core/tools/task → task}/subprocess-tool-registry.ts

@@ -8,7 +8,7 @@
  */
 
 import type { Component } from "@oh-my-pi/pi-tui";
-import type { Theme } from "../../../modes/interactive/theme/theme";
+import type { Theme } from "$c/modes/theme/theme";
 
 /** Event from subprocess tool execution (parsed from JSONL) */
 export interface SubprocessToolEvent {

package/src/task/template.ts

@@ -0,0 +1,47 @@
+import type { TaskItem } from "./types";
+
+type RenderResult = {
+	task: string;
+	args: Record<string, string>;
+	id: string;
+	description: string;
+};
+
+export function renderTemplate(template: string, task: TaskItem): RenderResult {
+	const { id, description, args } = task;
+
+	let usedPlaceholder = false;
+	const unknownArguments: string[] = [];
+	let renderedTask = template.replace(/\{\{(\w+)\}\}/g, (_match, key: string) => {
+		const value = args?.[key];
+		if (value) {
+			usedPlaceholder = true;
+			return value;
+		}
+		switch (key) {
+			case "id":
+				usedPlaceholder = true;
+				return id;
+			case "description":
+				usedPlaceholder = true;
+				return description;
+			default:
+				unknownArguments.push(key);
+				return `{{${key}}}`;
+		}
+	});
+
+	if (unknownArguments.length > 0) {
+		throw new Error(`Task "${id}" has unknown arguments: ${unknownArguments.join(", ")}`);
+	}
+
+	if (!usedPlaceholder) {
+		renderedTask += `\n----------------------\n# ${id}\n${description}`;
+	}
+	return {
+		task: renderedTask,
+		args: { id, description, ...args },
+		id,
+		description,
+	};
+}