@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/task/worktree.ts

@@ -1,10 +1,11 @@
 import type { Dirent } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
-import path from "node:path";
+import * as path from "node:path";
 import { projfsOverlayStart, projfsOverlayStop } from "@oh-my-pi/pi-natives";
-import { getWorktreeDir, isEnoent, logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { $which, getWorktreeDir, isEnoent, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
+import * as git from "../utils/git";
 
 /** Baseline state for a single git repository. */
 export interface RepoBaseline {
@@ -27,14 +28,11 @@ export function getEncodedProjectName(cwd: string): string {
 }
 
 export async function getRepoRoot(cwd: string): Promise<string> {
-	const result = await $`git rev-parse --show-toplevel`.cwd(cwd).quiet().nothrow();
-	if (result.exitCode !== 0) {
-		throw new Error("Git repository not found for isolated task execution.");
-	}
-	const repoRoot = result.text().trim();
+	const repoRoot = await git.repo.root(cwd);
 	if (!repoRoot) {
-		throw new Error("Git repository root could not be resolved for isolated task execution.");
+		throw new Error("Git repository not found for isolated task execution.");
 	}
+
 	return repoRoot;
 }
 
@@ -54,26 +52,16 @@ export async function ensureWorktree(baseCwd: string, id: string): Promise<strin
 	const encodedProject = getEncodedProjectName(repoRoot);
 	const worktreeDir = getWorktreeDir(encodedProject, id);
 	await fs.mkdir(path.dirname(worktreeDir), { recursive: true });
-	await $`git worktree remove -f ${worktreeDir}`.cwd(repoRoot).quiet().nothrow();
+	await git.worktree.tryRemove(repoRoot, worktreeDir);
 	await fs.rm(worktreeDir, { recursive: true, force: true });
-	await $`git worktree add --detach ${worktreeDir} HEAD`.cwd(repoRoot).quiet();
+	await git.worktree.add(repoRoot, worktreeDir, "HEAD", { detach: true });
 	return worktreeDir;
 }
 
 /** Find nested git repositories (non-submodule) under the given root. */
 async function discoverNestedRepos(repoRoot: string): Promise<string[]> {
 	// Get submodule paths so we can exclude them
-	const submoduleRaw = await $`git submodule --quiet foreach --recursive 'echo $sm_path'`
-		.cwd(repoRoot)
-		.quiet()
-		.nothrow()
-		.text();
-	const submodulePaths = new Set(
-		submoduleRaw
-			.split("\n")
-			.map(l => l.trim())
-			.filter(Boolean),
-	);
+	const submodulePaths = new Set(await git.ls.submodules(repoRoot));
 
 	// Find all .git dirs/files that aren't the root or known submodules
 	const result: string[] = [];
@@ -109,14 +97,10 @@ async function discoverNestedRepos(repoRoot: string): Promise<string[]> {
 }
 
 async function captureRepoBaseline(repoRoot: string): Promise<RepoBaseline> {
-	const headCommit = (await $`git rev-parse HEAD`.cwd(repoRoot).quiet().text()).trim();
-	const staged = await $`git diff --cached --binary`.cwd(repoRoot).quiet().text();
-	const unstaged = await $`git diff --binary`.cwd(repoRoot).quiet().text();
-	const untrackedRaw = await $`git ls-files --others --exclude-standard`.cwd(repoRoot).quiet().text();
-	const untracked = untrackedRaw
-		.split("\n")
-		.map(line => line.trim())
-		.filter(line => line.length > 0);
+	const headCommit = (await git.head.sha(repoRoot)) ?? "";
+	const staged = await git.diff(repoRoot, { binary: true, cached: true });
+	const unstaged = await git.diff(repoRoot, { binary: true });
+	const untracked = await git.ls.untracked(repoRoot);
 	return { repoRoot, headCommit, staged, unstaged, untracked };
 }
 
@@ -131,35 +115,10 @@ export async function captureBaseline(repoRoot: string): Promise<WorktreeBaselin
 	return { root, nested };
 }
 
-async function writeTempPatchFile(patch: string): Promise<string> {
-	const tempPath = path.join(os.tmpdir(), `omp-task-patch-${Snowflake.next()}.patch`);
-	await Bun.write(tempPath, patch);
-	return tempPath;
-}
-
-async function applyPatch(
-	cwd: string,
-	patch: string,
-	options?: { cached?: boolean; env?: Record<string, string> },
-): Promise<void> {
-	if (!patch.trim()) return;
-	const tempPath = await writeTempPatchFile(patch);
-	try {
-		const command = options?.cached ? $`git apply --cached --binary ${tempPath}` : $`git apply --binary ${tempPath}`;
-		let runner = command.cwd(cwd).quiet();
-		if (options?.env) {
-			runner = runner.env(options.env);
-		}
-		await runner;
-	} finally {
-		await fs.rm(tempPath, { force: true });
-	}
-}
-
 async function applyRepoBaseline(worktreeDir: string, rb: RepoBaseline, sourceRoot: string): Promise<void> {
-	await applyPatch(worktreeDir, rb.staged, { cached: true });
-	await applyPatch(worktreeDir, rb.staged);
-	await applyPatch(worktreeDir, rb.unstaged);
+	await git.patch.applyText(worktreeDir, rb.staged, { cached: true });
+	await git.patch.applyText(worktreeDir, rb.staged);
+	await git.patch.applyText(worktreeDir, rb.unstaged);
 
 	for (const entry of rb.untracked) {
 		const source = path.join(sourceRoot, entry);
@@ -193,15 +152,12 @@ export async function applyBaseline(worktreeDir: string, baseline: WorktreeBasel
 		// Commit baseline state so captureRepoDeltaPatch can cleanly subtract it.
 		// Without this, `git add -A && git commit` by the task would include
 		// baseline untracked files in the diff-tree output.
-		const hasChanges = (
-			await $`git --no-optional-locks status --porcelain`.cwd(nestedDir).quiet().nothrow().text()
-		).trim();
-		if (hasChanges) {
-			await $`git add -A`.cwd(nestedDir).quiet();
-			await $`git commit -m omp-baseline --allow-empty`.cwd(nestedDir).quiet();
+		if ((await git.status(nestedDir)).trim().length > 0) {
+			await git.stage.files(nestedDir);
+			await git.commit(nestedDir, "omp-baseline", { allowEmpty: true });
 			// Update baseline to reflect the committed state — prevents double-apply
 			// in captureRepoDeltaPatch's temp-index path
-			entry.baseline.headCommit = (await $`git rev-parse HEAD`.cwd(nestedDir).quiet().text()).trim();
+			entry.baseline.headCommit = (await git.head.sha(nestedDir)) ?? "";
 			entry.baseline.staged = "";
 			entry.baseline.unstaged = "";
 			entry.baseline.untracked = [];
@@ -209,32 +165,9 @@ export async function applyBaseline(worktreeDir: string, baseline: WorktreeBasel
 	}
 }
 
-async function applyPatchToIndex(cwd: string, patch: string, indexFile: string): Promise<void> {
-	if (!patch.trim()) return;
-	const tempPath = await writeTempPatchFile(patch);
-	try {
-		await $`git apply --cached --binary ${tempPath}`
-			.cwd(cwd)
-			.env({
-				GIT_INDEX_FILE: indexFile,
-			})
-			.quiet();
-	} finally {
-		await fs.rm(tempPath, { force: true });
-	}
-}
-
-async function listUntracked(cwd: string): Promise<string[]> {
-	const raw = await $`git ls-files --others --exclude-standard`.cwd(cwd).quiet().text();
-	return raw
-		.split("\n")
-		.map(line => line.trim())
-		.filter(line => line.length > 0);
-}
-
 async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise<string> {
 	// Check if HEAD advanced (task committed changes)
-	const currentHead = (await $`git rev-parse HEAD`.cwd(repoDir).quiet().nothrow().text()).trim();
+	const currentHead = (await git.head.sha(repoDir)) ?? "";
 	const headAdvanced = currentHead && currentHead !== rb.headCommit;
 
 	if (headAdvanced) {
@@ -242,28 +175,31 @@ async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise
 		const parts: string[] = [];
 
 		// Committed changes since baseline
-		const committedDiff = await $`git diff-tree -r -p --binary ${rb.headCommit} ${currentHead}`
-			.cwd(repoDir)
-			.quiet()
-			.nothrow()
-			.text();
+		const committedDiff = await git.diff.tree(repoDir, rb.headCommit, currentHead, {
+			allowFailure: true,
+			binary: true,
+		});
 		if (committedDiff.trim()) parts.push(committedDiff);
 
 		// Uncommitted changes on top of the new HEAD
-		const staged = await $`git diff --cached --binary`.cwd(repoDir).quiet().text();
-		const unstaged = await $`git diff --binary`.cwd(repoDir).quiet().text();
+		const staged = await git.diff(repoDir, { binary: true, cached: true });
+		const unstaged = await git.diff(repoDir, { binary: true });
 		if (staged.trim()) parts.push(staged);
 		if (unstaged.trim()) parts.push(unstaged);
 
 		// New untracked files (relative to both baseline and current tracking)
-		const currentUntracked = await listUntracked(repoDir);
+		const currentUntracked = await git.ls.untracked(repoDir);
 		const baselineUntracked = new Set(rb.untracked);
 		const newUntracked = currentUntracked.filter(entry => !baselineUntracked.has(entry));
 		if (newUntracked.length > 0) {
 			const nullPath = getGitNoIndexNullPath();
 			const untrackedDiffs = await Promise.all(
 				newUntracked.map(entry =>
-					$`git diff --binary --no-index ${nullPath} ${entry}`.cwd(repoDir).quiet().nothrow().text(),
+					git.diff(repoDir, {
+						allowFailure: true,
+						binary: true,
+						noIndex: { left: nullPath, right: entry },
+					}),
 				),
 			);
 			parts.push(...untrackedDiffs.filter(d => d.trim()));
@@ -275,12 +211,23 @@ async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise
 	// HEAD unchanged: use temp index approach (subtracts baseline from delta)
 	const tempIndex = path.join(os.tmpdir(), `omp-task-index-${Snowflake.next()}`);
 	try {
-		await $`git read-tree ${rb.headCommit}`.cwd(repoDir).env({ GIT_INDEX_FILE: tempIndex });
-		await applyPatchToIndex(repoDir, rb.staged, tempIndex);
-		await applyPatchToIndex(repoDir, rb.unstaged, tempIndex);
-		const diff = await $`git diff --binary`.cwd(repoDir).env({ GIT_INDEX_FILE: tempIndex }).quiet().text();
-
-		const currentUntracked = await listUntracked(repoDir);
+		await git.readTree(repoDir, rb.headCommit, {
+			env: { GIT_INDEX_FILE: tempIndex },
+		});
+		await git.patch.applyText(repoDir, rb.staged, {
+			cached: true,
+			env: { GIT_INDEX_FILE: tempIndex },
+		});
+		await git.patch.applyText(repoDir, rb.unstaged, {
+			cached: true,
+			env: { GIT_INDEX_FILE: tempIndex },
+		});
+		const diff = await git.diff(repoDir, {
+			binary: true,
+			env: { GIT_INDEX_FILE: tempIndex },
+		});
+
+		const currentUntracked = await git.ls.untracked(repoDir);
 		const baselineUntracked = new Set(rb.untracked);
 		const newUntracked = currentUntracked.filter(entry => !baselineUntracked.has(entry));
 
@@ -289,7 +236,11 @@ async function captureRepoDeltaPatch(repoDir: string, rb: RepoBaseline): Promise
 		const nullPath = getGitNoIndexNullPath();
 		const untrackedDiffs = await Promise.all(
 			newUntracked.map(entry =>
-				$`git diff --binary --no-index ${nullPath} ${entry}`.cwd(repoDir).quiet().nothrow().text(),
+				git.diff(repoDir, {
+					allowFailure: true,
+					binary: true,
+					noIndex: { left: nullPath, right: entry },
+				}),
 			),
 		);
 		return `${diff}${diff && !diff.endsWith("\n") ? "\n" : ""}${untrackedDiffs.join("\n")}`;
@@ -355,29 +306,25 @@ export async function applyNestedPatches(
 
 		const combinedDiff = repoPatches.map(p => p.patch).join("\n");
 		for (const { patch } of repoPatches) {
-			await applyPatch(nestedDir, patch);
+			await git.patch.applyText(nestedDir, patch);
 		}
 
 		// Commit so nested repo history reflects the task changes
-		const hasChanges = (
-			await $`git --no-optional-locks status --porcelain`.cwd(nestedDir).quiet().nothrow().text()
-		).trim();
-		if (hasChanges) {
+		if ((await git.status(nestedDir)).trim().length > 0) {
 			const msg = (await commitMessage?.(combinedDiff)) ?? "changes from isolated task(s)";
-			await $`git add -A`.cwd(nestedDir).quiet();
-			await $`git commit -m ${msg}`.cwd(nestedDir).quiet();
+			await git.stage.files(nestedDir);
+			await git.commit(nestedDir, msg);
 		}
 	}
 }
 
 export async function cleanupWorktree(dir: string): Promise<void> {
 	try {
-		const commonDirRaw = await $`git rev-parse --git-common-dir`.cwd(dir).quiet().nothrow().text();
-		const commonDir = commonDirRaw.trim();
-		if (commonDir) {
-			const resolvedCommon = path.resolve(dir, commonDir);
-			const repoRoot = path.dirname(resolvedCommon);
-			await $`git worktree remove -f ${dir}`.cwd(repoRoot).quiet().nothrow();
+		const repository = await git.repo.resolve(dir);
+		const commonDir = repository?.commonDir ?? "";
+		if (commonDir && path.basename(commonDir) === ".git") {
+			const repoRoot = path.dirname(commonDir);
+			await git.worktree.tryRemove(repoRoot, dir);
 		}
 	} finally {
 		await fs.rm(dir, { recursive: true, force: true });
@@ -401,7 +348,7 @@ export async function ensureFuseOverlay(baseCwd: string, id: string): Promise<st
 	const mergedDir = path.join(baseDir, "merged");
 
 	// Clean up any stale mount at this path (linux only)
-	const fusermount = Bun.which("fusermount3") ?? Bun.which("fusermount");
+	const fusermount = $which("fusermount3") ?? $which("fusermount");
 	if (fusermount) {
 		await $`${fusermount} -u ${mergedDir}`.quiet().nothrow();
 	}
@@ -411,7 +358,7 @@ export async function ensureFuseOverlay(baseCwd: string, id: string): Promise<st
 	await fs.mkdir(workDir, { recursive: true });
 	await fs.mkdir(mergedDir, { recursive: true });
 
-	const binary = Bun.which("fuse-overlayfs");
+	const binary = $which("fuse-overlayfs");
 	if (!binary) {
 		await fs.rm(baseDir, { recursive: true, force: true });
 		throw new Error(
@@ -433,7 +380,7 @@ export async function ensureFuseOverlay(baseCwd: string, id: string): Promise<st
 
 export async function cleanupFuseOverlay(mergedDir: string): Promise<void> {
 	try {
-		const fusermount = Bun.which("fusermount3") ?? Bun.which("fusermount");
+		const fusermount = $which("fusermount3") ?? $which("fusermount");
 		if (fusermount) {
 			await $`${fusermount} -u ${mergedDir}`.quiet().nothrow();
 		}
@@ -518,33 +465,31 @@ export async function commitToBranch(
 
 	// Only create a branch if the root repo has changes
 	if (rootPatch.trim()) {
-		await $`git branch ${branchName} HEAD`.cwd(repoRoot).quiet();
+		await git.branch.create(repoRoot, branchName);
 		const tmpDir = path.join(os.tmpdir(), `omp-branch-${Snowflake.next()}`);
 		try {
-			await $`git worktree add ${tmpDir} ${branchName}`.cwd(repoRoot).quiet();
-			const patchPath = path.join(os.tmpdir(), `omp-branch-patch-${Snowflake.next()}.patch`);
+			await git.worktree.add(repoRoot, tmpDir, branchName);
 			try {
-				await Bun.write(patchPath, rootPatch);
-				const applyResult = await $`git apply --binary ${patchPath}`.cwd(tmpDir).quiet().nothrow();
-				if (applyResult.exitCode !== 0) {
-					const stderr = applyResult.stderr.toString().slice(0, 2000);
+				await git.patch.applyText(tmpDir, rootPatch);
+			} catch (err) {
+				if (err instanceof git.GitCommandError) {
+					const stderr = err.result.stderr.slice(0, 2000);
 					logger.error("commitToBranch: git apply failed", {
 						taskId,
-						exitCode: applyResult.exitCode,
+						exitCode: err.result.exitCode,
 						stderr,
 						patchSize: rootPatch.length,
 						patchHead: rootPatch.slice(0, 500),
 					});
 					throw new Error(`git apply failed for task ${taskId}: ${stderr}`);
 				}
-			} finally {
-				await fs.rm(patchPath, { force: true });
+				throw err;
 			}
-			await $`git add -A`.cwd(tmpDir).quiet();
+			await git.stage.files(tmpDir);
 			const msg = (commitMessage && (await commitMessage(rootPatch))) || fallbackMessage;
-			await $`git commit -m ${msg}`.cwd(tmpDir).quiet();
+			await git.commit(tmpDir, msg);
 		} finally {
-			await $`git worktree remove -f ${tmpDir}`.cwd(repoRoot).quiet().nothrow();
+			await git.worktree.tryRemove(repoRoot, tmpDir);
 			await fs.rm(tmpDir, { recursive: true, force: true });
 		}
 	}
@@ -570,29 +515,66 @@ export async function mergeTaskBranches(
 	const merged: string[] = [];
 	const failed: string[] = [];
 
-	for (const { branchName } of branches) {
-		const result = await $`git cherry-pick ${branchName}`.cwd(repoRoot).quiet().nothrow();
-
-		if (result.exitCode !== 0) {
-			await $`git cherry-pick --abort`.cwd(repoRoot).quiet().nothrow();
-			const stderr = result.stderr.toString().trim();
-			failed.push(branchName);
-			return {
-				merged,
-				failed: [...failed, ...branches.slice(merged.length + failed.length).map(b => b.branchName)],
-				conflict: `${branchName}: ${stderr}`,
-			};
-		}
+	// Stash dirty working tree so cherry-pick can operate on a clean HEAD.
+	// Without this, cherry-pick refuses to run when uncommitted changes exist.
+	const didStash = await git.stash.push(repoRoot, "omp-task-merge");
+
+	let conflictResult: MergeBranchResult | undefined;
 
-		merged.push(branchName);
+	try {
+		for (const { branchName } of branches) {
+			try {
+				await git.cherryPick(repoRoot, branchName);
+			} catch (err) {
+				try {
+					await git.cherryPick.abort(repoRoot);
+				} catch {
+					/* no state to abort */
+				}
+				const stderr =
+					err instanceof git.GitCommandError
+						? err.result.stderr.trim()
+						: err instanceof Error
+							? err.message
+							: String(err);
+				failed.push(branchName);
+				conflictResult = {
+					merged,
+					failed: [...failed, ...branches.slice(merged.length + failed.length).map(b => b.branchName)],
+					conflict: `${branchName}: ${stderr}`,
+				};
+				break;
+			}
+
+			merged.push(branchName);
+		}
+	} finally {
+		if (didStash) {
+			try {
+				await git.stash.pop(repoRoot, { index: true });
+			} catch {
+				// Stash-pop conflicts mean the replayed changes clash with the user's
+				// uncommitted edits. Treat this as a merge failure so the caller preserves
+				// recovery branches instead of reporting success and deleting them.
+				logger.warn("Failed to restore stashed changes after task merge; stash entry preserved");
+				if (!conflictResult) {
+					conflictResult = {
+						merged,
+						failed: merged,
+						conflict:
+							"stash pop: cherry-picked changes conflict with uncommitted edits. Run `git stash pop` and resolve manually.",
+					};
+				}
+			}
+		}
 	}
 
-	return { merged, failed };
+	return conflictResult ?? { merged, failed };
 }
 
 /** Clean up temporary task branches. */
 export async function cleanupTaskBranches(repoRoot: string, branches: string[]): Promise<void> {
 	for (const branch of branches) {
-		await $`git branch -D ${branch}`.cwd(repoRoot).quiet().nothrow();
+		await git.branch.tryDelete(repoRoot, branch);
 	}
 }

package/src/tools/ask.ts

@@ -17,9 +17,8 @@
 
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type Component, Container, Markdown, renderInlineMarkdown, TERMINAL, Text } from "@oh-my-pi/pi-tui";
-import { untilAborted } from "@oh-my-pi/pi-utils";
+import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { getMarkdownTheme, type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
@@ -385,7 +384,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(askDescription);
+		this.description = prompt.render(askDescription);
 	}
 
 	static createIf(session: ToolSession): AskTool | null {

package/src/tools/ast-edit.ts

@@ -3,12 +3,11 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { type AstReplaceChange, astEdit } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { untilAborted } from "@oh-my-pi/pi-utils";
+import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
+import { computeLineHash } from "../edit/line-hash";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import { computeLineHash } from "../patch/hashline";
 import astEditDescription from "../prompts/tools/ast-edit.md" with { type: "text" };
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
@@ -31,6 +30,7 @@ import {
 	PARSE_ERRORS_LIMIT,
 	PREVIEW_LIMITS,
 } from "./render-utils";
+import { queueResolveHandler } from "./resolve";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
@@ -71,7 +71,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 	readonly strict = true;
 	readonly deferrable = true;
 	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(astEditDescription);
+		this.description = prompt.render(astEditDescription);
 	}
 
 	async execute(
@@ -201,7 +201,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 				filesSearched: result.filesSearched,
 				applied: result.applied,
 				limitReached: result.limitReached,
-				parseErrors: dedupedParseErrors,
+				...(dedupedParseErrors.length > 0 ? { parseErrors: dedupedParseErrors } : {}),
 				scopePath,
 				files: fileList,
 				fileReplacements: [],
@@ -289,7 +289,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			if (!result.applied && result.totalReplacements > 0) {
 				const previewReplacementPlural = result.totalReplacements !== 1 ? "s" : "";
 				const previewFilePlural = result.filesTouched !== 1 ? "s" : "";
-				this.session.pendingActionStore?.push({
+				queueResolveHandler(this.session, {
 					label: `AST Edit: ${result.totalReplacements} replacement${previewReplacementPlural} in ${result.filesTouched} file${previewFilePlural}`,
 					sourceToolName: this.name,
 					apply: async (_reason: string) => {
@@ -311,7 +311,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 							filesSearched: applyResult.filesSearched,
 							applied: applyResult.applied,
 							limitReached: applyResult.limitReached,
-							parseErrors: dedupedApplyParseErrors,
+							...(dedupedApplyParseErrors.length > 0 ? { parseErrors: dedupedApplyParseErrors } : {}),
 							scopePath,
 							files: fileList,
 							fileReplacements,

package/src/tools/ast-grep.ts

@@ -3,12 +3,11 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { type AstFindMatch, astGrep } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import { untilAborted } from "@oh-my-pi/pi-utils";
+import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { renderPromptTemplate } from "../config/prompt-templates";
+import { computeLineHash } from "../edit/line-hash";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
-import { computeLineHash } from "../patch/hashline";
 import astGrepDescription from "../prompts/tools/ast-grep.md" with { type: "text" };
 import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
@@ -65,7 +64,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(astGrepDescription);
+		this.description = prompt.render(astGrepDescription);
 	}
 
 	async execute(
@@ -188,7 +187,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				fileCount: result.filesWithMatches,
 				filesSearched: result.filesSearched,
 				limitReached: result.limitReached,
-				parseErrors: dedupedParseErrors,
+				...(dedupedParseErrors.length > 0 ? { parseErrors: dedupedParseErrors } : {}),
 				scopePath,
 				files: fileList,
 				fileMatches: [],
@@ -213,12 +212,13 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 					const lineNumbers = matchLines.map((_, index) => match.startLine + index);
 					const lineWidth = Math.max(...lineNumbers.map(value => value.toString().length));
 					const formatLine = (lineNumber: number, line: string, isMatch: boolean): string => {
+						const separator = isMatch ? ":" : "-";
 						if (useHashLines) {
 							const ref = `${lineNumber}#${computeLineHash(lineNumber, line)}`;
-							return isMatch ? `>>${ref}:${line}` : `  ${ref}:${line}`;
+							return `${ref}${separator}${line}`;
 						}
 						const padded = lineNumber.toString().padStart(lineWidth, " ");
-						return isMatch ? `>>${padded}:${line}` : `  ${padded}:${line}`;
+						return `${padded}${separator}${line}`;
 					};
 					for (let index = 0; index < matchLines.length; index++) {
 						outputLines.push(formatLine(match.startLine + index, matchLines[index], index === 0));