@oh-my-pi/pi-coding-agent 14.3.0 → 14.4.1

package/src/task/render.ts

@@ -101,12 +101,12 @@ function formatTaskId(id: string): string {
 	return `${indices} ${labels}`;
 }
 
-const MISSING_SUBMIT_RESULT_WARNING_PREFIX = "SYSTEM WARNING: Subagent exited without calling submit_result tool";
+const MISSING_YIELD_WARNING_PREFIX = "SYSTEM WARNING: Subagent exited without calling yield tool";
 
-function extractMissingSubmitResultWarning(output: string): { warning?: string; rest: string } {
+function extractMissingYieldWarning(output: string): { warning?: string; rest: string } {
 	const lines = output.split("\n");
 	const firstLine = lines[0]?.trim() ?? "";
-	if (!firstLine.startsWith(MISSING_SUBMIT_RESULT_WARNING_PREFIX)) {
+	if (!firstLine.startsWith(MISSING_YIELD_WARNING_PREFIX)) {
 		return { rest: output };
 	}
 	const rest = lines
@@ -572,9 +572,9 @@ function renderAgentProgress(
 
 	// Render extracted tool data inline (e.g., review findings)
 	if (progress.extractedToolData) {
-		// For completed tasks, check for review verdict from submit_result tool
+		// For completed tasks, check for review verdict from yield tool
 		if (progress.status === "completed") {
-			const completeData = progress.extractedToolData.submit_result as Array<{ data: unknown }> | undefined;
+			const completeData = progress.extractedToolData.yield as Array<{ data: unknown }> | undefined;
 			const reportFindingData = normalizeReportFindings(progress.extractedToolData.report_finding);
 			const reviewData = completeData
 				?.map(c => c.data as SubmitReviewDetails)
@@ -731,9 +731,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	const prefix = isLast ? theme.fg("dim", theme.tree.last) : theme.fg("dim", theme.tree.branch);
 	const continuePrefix = isLast ? "   " : `${theme.fg("dim", theme.tree.vertical)}  `;
 
-	const { warning: missingCompleteWarning, rest: outputWithoutWarning } = extractMissingSubmitResultWarning(
-		result.output,
-	);
+	const { warning: missingCompleteWarning, rest: outputWithoutWarning } = extractMissingYieldWarning(result.output);
 	const aborted = result.aborted ?? false;
 	const mergeFailed = !aborted && result.exitCode === 0 && !!result.error;
 	const success = !aborted && result.exitCode === 0 && !result.error;
@@ -783,11 +781,11 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 			`${continuePrefix}${theme.fg("error", theme.status.aborted)} ${theme.fg("dim", truncateToWidth(replaceTabs(result.abortReason), 80))}`,
 		);
 	}
-	// Check for review result (submit_result with review schema + report_finding)
-	const completeData = result.extractedToolData?.submit_result as Array<{ data: unknown }> | undefined;
+	// Check for review result (yield with review schema + report_finding)
+	const completeData = result.extractedToolData?.yield as Array<{ data: unknown }> | undefined;
 	const reportFindingData = normalizeReportFindings(result.extractedToolData?.report_finding);
 
-	// Extract review verdict from submit_result tool's data field if it matches SubmitReviewDetails
+	// Extract review verdict from yield tool's data field if it matches SubmitReviewDetails
 	const reviewData = completeData
 		?.map(c => c.data as SubmitReviewDetails)
 		.filter(d => d && typeof d === "object" && "overall_correctness" in d);
@@ -804,7 +802,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 		const hasCompleteData = completeData && completeData.length > 0;
 		const message = hasCompleteData
 			? "Review verdict missing expected fields"
-			: "Review incomplete (submit_result not called)";
+			: "Review incomplete (yield not called)";
 		lines.push(`${continuePrefix}${theme.fg("warning", theme.status.warning)} ${theme.fg("dim", message)}`);
 		lines.push(`${continuePrefix}${formatFindingSummary(reportFindingData, theme)}`);
 		lines.push(...renderFindings(reportFindingData, continuePrefix, expanded, theme));
@@ -817,7 +815,7 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	if (result.extractedToolData) {
 		for (const [toolName, dataArray] of Object.entries(result.extractedToolData)) {
 			// Skip review tools - handled above
-			if (toolName === "submit_result" || toolName === "report_finding") continue;
+			if (toolName === "yield" || toolName === "report_finding") continue;
 
 			const handler = subprocessToolRegistry.getHandler(toolName);
 			if (handler?.renderFinal && (dataArray as unknown[]).length > 0) {

package/src/tools/ask.ts

@@ -32,19 +32,19 @@ import { ToolAbortError } from "./tool-errors";
 // =============================================================================
 
 const OptionItem = Type.Object({
-	label: Type.String({ description: "Display label" }),
+	label: Type.String({ description: "display label" }),
 });
 
 const QuestionItem = Type.Object({
-	id: Type.String({ description: "Question ID, e.g. 'auth', 'cache'" }),
-	question: Type.String({ description: "Question text" }),
-	options: Type.Array(OptionItem, { description: "Available options" }),
-	multi: Type.Optional(Type.Boolean({ description: "Allow multiple selections" })),
-	recommended: Type.Optional(Type.Number({ description: "Index of recommended option (0-indexed)" })),
+	id: Type.String({ description: "question id", examples: ["auth", "cache"] }),
+	question: Type.String({ description: "question text" }),
+	options: Type.Array(OptionItem, { description: "available options" }),
+	multi: Type.Optional(Type.Boolean({ description: "allow multiple selections" })),
+	recommended: Type.Optional(Type.Number({ description: "recommended option index" })),
 });
 
 const askSchema = Type.Object({
-	questions: Type.Array(QuestionItem, { description: "Questions to ask", minItems: 1 }),
+	questions: Type.Array(QuestionItem, { description: "questions to ask", minItems: 1 }),
 });
 
 export type AskToolInput = Static<typeof askSchema>;

package/src/tools/ast-edit.ts

@@ -5,7 +5,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { $envpos, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { computeLineHash } from "../edit/line-hash";
+import { computeLineHash, HASHLINE_CONTENT_SEPARATOR } from "../edit/line-hash";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import astEditDescription from "../prompts/tools/ast-edit.md" with { type: "text" };
@@ -15,7 +15,6 @@ import type { ToolSession } from ".";
 import { createFileRecorder, formatResultPath } from "./file-recorder";
 import type { OutputMeta } from "./output-meta";
 import {
-	combineSearchGlobs,
 	hasGlobPathChars,
 	normalizePathLikeInput,
 	parseSearchPath,
@@ -24,6 +23,7 @@ import {
 } from "./path-utils";
 import {
 	dedupeParseErrors,
+	formatCodeFrameLine,
 	formatCount,
 	formatEmptyMessage,
 	formatErrorMessage,
@@ -36,20 +36,19 @@ import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
 const astEditOpSchema = Type.Object({
-	pat: Type.String({ description: "AST pattern to match" }),
-	out: Type.String({ description: "Replacement template" }),
+	pat: Type.String({ description: "ast pattern", examples: ["oldFn($$$ARGS)"] }),
+	out: Type.String({ description: "replacement template", examples: ["newFn($$$ARGS)"] }),
 });
 
 const astEditSchema = Type.Object({
 	ops: Type.Array(astEditOpSchema, {
 		minItems: 1,
-		description: "Rewrite ops as [{ pat, out }]",
+		description: "rewrite ops",
+	}),
+	path: Type.String({
+		description: "file, directory, glob, or comma-separated paths to rewrite",
+		examples: ["src/", "src/foo.ts", "src/**/*.ts"],
 	}),
-	lang: Type.Optional(Type.String({ description: "Language override" })),
-	path: Type.Optional(Type.String({ description: "File, directory, or glob pattern to rewrite (default: cwd)" })),
-	glob: Type.Optional(Type.String({ description: "Optional glob filter relative to path" })),
-	sel: Type.Optional(Type.String({ description: "Optional selector for contextual pattern mode" })),
-	limit: Type.Optional(Type.Number({ description: "Max total replacements" })),
 });
 
 export interface AstEditToolDetails {
@@ -63,6 +62,9 @@ export interface AstEditToolDetails {
 	files?: string[];
 	fileReplacements?: Array<{ path: string; count: number }>;
 	meta?: OutputMeta;
+	/** Pre-formatted text for the user-visible TUI render. Mirrors `result.text` lines but uses
+	 * a `│` gutter (no model-only hashline anchors). The TUI uses this directly so it never parses model-facing text. */
+	displayContent?: string;
 }
 
 export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolDetails> {
@@ -101,10 +103,6 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 				seenPatterns.add(pat);
 			}
 			const normalizedRewrites = Object.fromEntries(ops);
-			const maxReplacements = params.limit !== undefined ? Math.floor(params.limit) : undefined;
-			if (maxReplacements !== undefined && (!Number.isFinite(maxReplacements) || maxReplacements < 1)) {
-				throw new ToolError("limit must be a positive number");
-			}
 			const maxFiles = $envpos("PI_MAX_AST_FILES", 1000);
 
 			const formatScopePath = (targetPath: string): string => {
@@ -113,8 +111,11 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			};
 			let searchPath: string | undefined;
 			let scopePath: string | undefined;
-			let globFilter = params.glob ? normalizePathLikeInput(params.glob) || undefined : undefined;
-			const rawPath = params.path ? normalizePathLikeInput(params.path) || undefined : undefined;
+			let globFilter: string | undefined;
+			const rawPath = normalizePathLikeInput(params.path);
+			if (rawPath.length === 0) {
+				throw new ToolError("`path` must be a non-empty path or glob");
+			}
 			if (rawPath) {
 				const internalRouter = this.session.internalRouter;
 				if (internalRouter?.canHandle(rawPath)) {
@@ -136,7 +137,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 					} else {
 						const parsedPath = parseSearchPath(rawPath);
 						searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-						globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
+						globFilter = parsedPath.glob;
 						scopePath = formatScopePath(searchPath);
 					}
 				}
@@ -153,12 +154,9 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 
 			const result = await astEdit({
 				rewrites: normalizedRewrites,
-				lang: params.lang?.trim(),
 				path: resolvedSearchPath,
 				glob: globFilter,
-				selector: params.sel?.trim(),
 				dryRun: true,
-				maxReplacements,
 				maxFiles,
 				failOnParseError: false,
 				signal,
@@ -205,24 +203,29 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
 			const outputLines: string[] = [];
+			const displayLines: string[] = [];
 			const renderChangesForFile = (relativePath: string) => {
 				const fileChanges = changesByFile.get(relativePath) ?? [];
-				const lineWidth =
-					fileChanges.length > 0 ? Math.max(...fileChanges.map(change => change.startLine.toString().length)) : 1;
+				const lineNumberWidth = fileChanges.reduce(
+					(width, change) => Math.max(width, String(change.startLine).length),
+					0,
+				);
 				for (const change of fileChanges) {
 					const beforeFirstLine = change.before.split("\n", 1)[0] ?? "";
 					const afterFirstLine = change.after.split("\n", 1)[0] ?? "";
 					const beforeLine = beforeFirstLine.slice(0, 120);
 					const afterLine = afterFirstLine.slice(0, 120);
 					const beforeRef = useHashLines
-						? `${change.startLine}#${computeLineHash(change.startLine, beforeFirstLine)}`
-						: `${change.startLine.toString().padStart(lineWidth, " ")}:${change.startColumn}`;
+						? `${change.startLine}${computeLineHash(change.startLine, beforeFirstLine)}`
+						: `${change.startLine}:${change.startColumn}`;
 					const afterRef = useHashLines
-						? `${change.startLine}#${computeLineHash(change.startLine, afterFirstLine)}`
-						: `${change.startLine.toString().padStart(lineWidth, " ")}:${change.startColumn}`;
-					const lineSeparator = useHashLines ? ":" : " ";
+						? `${change.startLine}${computeLineHash(change.startLine, afterFirstLine)}`
+						: `${change.startLine}:${change.startColumn}`;
+					const lineSeparator = useHashLines ? HASHLINE_CONTENT_SEPARATOR : " ";
 					outputLines.push(`-${beforeRef}${lineSeparator}${beforeLine}`);
 					outputLines.push(`+${afterRef}${lineSeparator}${afterLine}`);
+					displayLines.push(formatCodeFrameLine("-", change.startLine, beforeLine, lineNumberWidth));
+					displayLines.push(formatCodeFrameLine("+", change.startLine, afterLine, lineNumberWidth));
 				}
 			};
 
@@ -240,20 +243,28 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 						for (const relativePath of directoryFiles) {
 							if (outputLines.length > 0) {
 								outputLines.push("");
+								displayLines.push("");
 							}
 							const count = fileReplacementCounts.get(relativePath) ?? 0;
-							outputLines.push(`# ${path.basename(relativePath)} (${formatCount("replacement", count)})`);
+							const header = `# ${path.basename(relativePath)} (${formatCount("replacement", count)})`;
+							outputLines.push(header);
+							displayLines.push(header);
 							renderChangesForFile(relativePath);
 						}
 						continue;
 					}
 					if (outputLines.length > 0) {
 						outputLines.push("");
+						displayLines.push("");
 					}
-					outputLines.push(`# ${directory}`);
+					const dirHeader = `# ${directory}`;
+					outputLines.push(dirHeader);
+					displayLines.push(dirHeader);
 					for (const relativePath of directoryFiles) {
 						const count = fileReplacementCounts.get(relativePath) ?? 0;
-						outputLines.push(`## └─ ${path.basename(relativePath)} (${formatCount("replacement", count)})`);
+						const fileHeader = `## └─ ${path.basename(relativePath)} (${formatCount("replacement", count)})`;
+						outputLines.push(fileHeader);
+						displayLines.push(fileHeader);
 						renderChangesForFile(relativePath);
 					}
 				}
@@ -268,7 +279,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 				count: fileReplacementCounts.get(filePath) ?? 0,
 			}));
 			if (result.limitReached) {
-				outputLines.push("", "Limit reached; narrow path or increase limit.");
+				outputLines.push("", "Limit reached; narrow path.");
 			}
 			if (dedupedParseErrors.length) {
 				outputLines.push("", ...formatParseErrors(dedupedParseErrors));
@@ -284,12 +295,9 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 					apply: async (_reason: string) => {
 						const applyResult = await astEdit({
 							rewrites: normalizedRewrites,
-							lang: params.lang?.trim(),
 							path: resolvedSearchPath,
 							glob: globFilter,
-							selector: params.sel?.trim(),
 							dryRun: false,
-							maxReplacements,
 							maxFiles,
 							failOnParseError: false,
 						});
@@ -351,6 +359,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			const details: AstEditToolDetails = {
 				...baseDetails,
 				fileReplacements,
+				displayContent: displayLines.join("\n"),
 			};
 			return toolResult(details).text(outputLines.join("\n")).done();
 		});
@@ -363,10 +372,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 
 interface AstEditRenderArgs {
 	ops?: Array<{ pat?: string; out?: string }>;
-	lang?: string;
 	path?: string;
-	sel?: string;
-	limit?: number;
 }
 
 const COLLAPSED_CHANGE_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
@@ -375,9 +381,7 @@ export const astEditToolRenderer = {
 	inline: true,
 	renderCall(args: AstEditRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const meta: string[] = [];
-		if (args.lang) meta.push(`lang:${args.lang}`);
 		if (args.path) meta.push(`in ${args.path}`);
-		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
 		const rewriteCount = args.ops?.length ?? 0;
 		if (rewriteCount > 1) meta.push(`${rewriteCount} rewrites`);
 
@@ -432,7 +436,7 @@ export const astEditToolRenderer = {
 		const rewriteCount = args?.ops?.length ?? 0;
 		const description = rewriteCount === 1 ? args?.ops?.[0]?.pat : undefined;
 
-		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
+		const textContent = result.details?.displayContent ?? result.content?.find(c => c.type === "text")?.text ?? "";
 		const rawLines = textContent.split("\n");
 		const hasSeparators = rawLines.some(line => line.trim().length === 0);
 		const allGroups: string[][] = [];
@@ -467,7 +471,7 @@ export const astEditToolRenderer = {
 
 		const extraLines: string[] = [];
 		if (limitReached) {
-			extraLines.push(uiTheme.fg("warning", "limit reached; narrow path or increase limit"));
+			extraLines.push(uiTheme.fg("warning", "limit reached; narrow path"));
 		}
 		if (details?.parseErrors?.length) {
 			const total = details.parseErrors.length;

package/src/tools/ast-grep.ts

@@ -15,7 +15,6 @@ import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { formatMatchLine } from "./match-line-format";
 import type { OutputMeta } from "./output-meta";
 import {
-	combineSearchGlobs,
 	hasGlobPathChars,
 	normalizePathLikeInput,
 	parseSearchPath,
@@ -24,6 +23,7 @@ import {
 } from "./path-utils";
 import {
 	dedupeParseErrors,
+	formatCodeFrameLine,
 	formatCount,
 	formatEmptyMessage,
 	formatErrorMessage,
@@ -35,14 +35,12 @@ import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
 const astGrepSchema = Type.Object({
-	pat: Type.Array(Type.String(), { minItems: 1, description: "AST patterns to match" }),
-	lang: Type.Optional(Type.String({ description: "Language override" })),
-	path: Type.Optional(Type.String({ description: "File, directory, or glob pattern to search (default: cwd)" })),
-	glob: Type.Optional(Type.String({ description: "Optional glob filter relative to path" })),
-	sel: Type.Optional(Type.String({ description: "Optional selector for contextual pattern mode" })),
-	limit: Type.Optional(Type.Number({ description: "Max matches", default: 50 })),
-	offset: Type.Optional(Type.Number({ description: "Skip first N matches", default: 0 })),
-	context: Type.Optional(Type.Number({ description: "Context lines around each match" })),
+	pat: Type.String({ description: "ast pattern", examples: ["console.log($$$)"] }),
+	path: Type.String({
+		description: "file, directory, glob, or comma-separated paths to search",
+		examples: ["src/", "src/foo.ts", "src/**/*.ts"],
+	}),
+	skip: Type.Optional(Type.Number({ description: "matches to skip", default: 0 })),
 });
 
 export interface AstGrepToolDetails {
@@ -55,6 +53,9 @@ export interface AstGrepToolDetails {
 	files?: string[];
 	fileMatches?: Array<{ path: string; count: number }>;
 	meta?: OutputMeta;
+	/** Pre-formatted text for the user-visible TUI render. Mirrors `result.text` lines but uses
+	 * a `│` gutter and `*` to mark match lines. The TUI uses this directly so it never parses model-facing text. */
+	displayContent?: string;
 }
 
 export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolDetails> {
@@ -76,55 +77,48 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<AstGrepToolDetails>> {
 		return untilAborted(signal, async () => {
-			const patterns = [...new Set(params.pat.map(pattern => pattern.trim()).filter(pattern => pattern.length > 0))];
-			if (patterns.length === 0) {
-				throw new ToolError("`pat` must include at least one non-empty pattern");
+			const pattern = params.pat.trim();
+			if (pattern.length === 0) {
+				throw new ToolError("`pat` must be a non-empty pattern");
 			}
-			const limit = params.limit === undefined ? 50 : Math.floor(params.limit);
-			if (!Number.isFinite(limit) || limit < 1) {
-				throw new ToolError("Limit must be a positive number");
+			const patterns = [pattern];
+			const skip = params.skip === undefined ? 0 : Math.floor(params.skip);
+			if (!Number.isFinite(skip) || skip < 0) {
+				throw new ToolError("skip must be a non-negative number");
 			}
-			const offset = params.offset === undefined ? 0 : Math.floor(params.offset);
-			if (!Number.isFinite(offset) || offset < 0) {
-				throw new ToolError("Offset must be a non-negative number");
-			}
-			const context = params.context === undefined ? undefined : Math.floor(params.context);
-			if (context !== undefined && (!Number.isFinite(context) || context < 0)) {
-				throw new ToolError("Context must be a non-negative number");
-			}
-
 			const formatScopePath = (targetPath: string): string => {
 				const relative = path.relative(this.session.cwd, targetPath).replace(/\\/g, "/");
 				return relative.length === 0 ? "." : relative;
 			};
 			let searchPath: string | undefined;
 			let scopePath: string | undefined;
-			let globFilter = params.glob ? normalizePathLikeInput(params.glob) || undefined : undefined;
-			const rawPath = params.path ? normalizePathLikeInput(params.path) || undefined : undefined;
-			if (rawPath) {
-				const internalRouter = this.session.internalRouter;
-				if (internalRouter?.canHandle(rawPath)) {
-					if (hasGlobPathChars(rawPath)) {
-						throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
-					}
-					const resource = await internalRouter.resolve(rawPath);
-					if (!resource.sourcePath) {
-						throw new ToolError(`Cannot search internal URL without backing file: ${rawPath}`);
-					}
-					searchPath = resource.sourcePath;
-					scopePath = formatScopePath(searchPath);
+			let globFilter: string | undefined;
+			const rawPath = normalizePathLikeInput(params.path);
+			if (rawPath.length === 0) {
+				throw new ToolError("`path` must be a non-empty path or glob");
+			}
+			const internalRouter = this.session.internalRouter;
+			if (internalRouter?.canHandle(rawPath)) {
+				if (hasGlobPathChars(rawPath)) {
+					throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPath}`);
+				}
+				const resource = await internalRouter.resolve(rawPath);
+				if (!resource.sourcePath) {
+					throw new ToolError(`Cannot search internal URL without backing file: ${rawPath}`);
+				}
+				searchPath = resource.sourcePath;
+				scopePath = formatScopePath(searchPath);
+			} else {
+				const multiSearchPath = await resolveMultiSearchPath(rawPath, this.session.cwd, globFilter);
+				if (multiSearchPath) {
+					searchPath = multiSearchPath.basePath;
+					globFilter = multiSearchPath.glob;
+					scopePath = multiSearchPath.scopePath;
 				} else {
-					const multiSearchPath = await resolveMultiSearchPath(rawPath, this.session.cwd, globFilter);
-					if (multiSearchPath) {
-						searchPath = multiSearchPath.basePath;
-						globFilter = multiSearchPath.glob;
-						scopePath = multiSearchPath.scopePath;
-					} else {
-						const parsedPath = parseSearchPath(rawPath);
-						searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
-						globFilter = combineSearchGlobs(parsedPath.glob, globFilter);
-						scopePath = formatScopePath(searchPath);
-					}
+					const parsedPath = parseSearchPath(rawPath);
+					searchPath = resolveToCwd(parsedPath.basePath, this.session.cwd);
+					globFilter = parsedPath.glob;
+					scopePath = formatScopePath(searchPath);
 				}
 			}
 
@@ -140,13 +134,9 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 			const result = await astGrep({
 				patterns,
-				lang: params.lang?.trim(),
 				path: resolvedSearchPath,
 				glob: globFilter,
-				selector: params.sel?.trim(),
-				limit,
-				offset,
-				context,
+				offset: skip,
 				includeMeta: true,
 				signal,
 			});
@@ -183,7 +173,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 			if (result.matches.length === 0) {
 				const noMatchMessage = dedupedParseErrors.length
-					? "No matches found. Parse issues mean the query may be mis-scoped; narrow `path`/`glob` or set `lang` before concluding absence."
+					? "No matches found. Parse issues mean the query may be mis-scoped; narrow `path` before concluding absence."
 					: "No matches found";
 				const parseMessage = dedupedParseErrors.length
 					? `\n${formatParseErrors(dedupedParseErrors).join("\n")}`
@@ -193,16 +183,22 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
 			const outputLines: string[] = [];
+			const displayLines: string[] = [];
 			const renderMatchesForFile = (relativePath: string) => {
 				const fileMatches = matchesByFile.get(relativePath) ?? [];
+				const lineNumberWidth = fileMatches.reduce((width, match) => {
+					const lineCount = match.text.split("\n").length;
+					const endLine = match.startLine + lineCount - 1;
+					return Math.max(width, String(match.startLine).length, String(endLine).length);
+				}, 0);
 				for (const match of fileMatches) {
 					const matchLines = match.text.split("\n");
-					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 =>
-						formatMatchLine(lineNumber, line, isMatch, { useHashLines, lineWidth });
 					for (let index = 0; index < matchLines.length; index++) {
-						outputLines.push(formatLine(match.startLine + index, matchLines[index], index === 0));
+						const lineNumber = match.startLine + index;
+						const isMatch = index === 0;
+						const line = matchLines[index] ?? "";
+						outputLines.push(formatMatchLine(lineNumber, line, isMatch, { useHashLines }));
+						displayLines.push(formatCodeFrameLine(isMatch ? "*" : " ", lineNumber, line, lineNumberWidth));
 					}
 					if (match.metaVariables && Object.keys(match.metaVariables).length > 0) {
 						const serializedMeta = Object.entries(match.metaVariables)
@@ -210,6 +206,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 							.map(([key, value]) => `${key}=${value}`)
 							.join(", ");
 						outputLines.push(`  meta: ${serializedMeta}`);
+						displayLines.push(`  meta: ${serializedMeta}`);
 					}
 					fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 				}
@@ -229,18 +226,26 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 						for (const relativePath of directoryFiles) {
 							if (outputLines.length > 0) {
 								outputLines.push("");
+								displayLines.push("");
 							}
-							outputLines.push(`# ${path.basename(relativePath)}`);
+							const header = `# ${path.basename(relativePath)}`;
+							outputLines.push(header);
+							displayLines.push(header);
 							renderMatchesForFile(relativePath);
 						}
 						continue;
 					}
 					if (outputLines.length > 0) {
 						outputLines.push("");
+						displayLines.push("");
 					}
-					outputLines.push(`# ${directory}`);
+					const dirHeader = `# ${directory}`;
+					outputLines.push(dirHeader);
+					displayLines.push(dirHeader);
 					for (const relativePath of directoryFiles) {
-						outputLines.push(`## └─ ${path.basename(relativePath)}`);
+						const fileHeader = `## └─ ${path.basename(relativePath)}`;
+						outputLines.push(fileHeader);
+						displayLines.push(fileHeader);
 						renderMatchesForFile(relativePath);
 					}
 				}
@@ -256,6 +261,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 					path: filePath,
 					count: fileMatchCounts.get(filePath) ?? 0,
 				})),
+				displayContent: displayLines.join("\n"),
 			};
 			if (result.limitReached) {
 				outputLines.push("", "Result limit reached; narrow path pattern or increase limit.");
@@ -274,13 +280,9 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 // =============================================================================
 
 interface AstGrepRenderArgs {
-	pat?: string[];
-	lang?: string;
+	pat?: string;
 	path?: string;
-	sel?: string;
-	limit?: number;
-	offset?: number;
-	context?: number;
+	skip?: number;
 }
 
 const COLLAPSED_MATCH_LIMIT = PREVIEW_LIMITS.COLLAPSED_LINES * 2;
@@ -289,15 +291,10 @@ export const astGrepToolRenderer = {
 	inline: true,
 	renderCall(args: AstGrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const meta: string[] = [];
-		if (args.lang) meta.push(`lang:${args.lang}`);
 		if (args.path) meta.push(`in ${args.path}`);
-		if (args.sel) meta.push("selector");
-		if (args.limit !== undefined && args.limit > 0) meta.push(`limit:${args.limit}`);
-		if (args.offset !== undefined && args.offset > 0) meta.push(`offset:${args.offset}`);
-		if (args.context !== undefined) meta.push(`context:${args.context}`);
-		if (args.pat && args.pat.length > 1) meta.push(`${args.pat.length} patterns`);
+		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);
 
-		const description = args.pat?.length === 1 ? args.pat[0] : args.pat ? `${args.pat.length} patterns` : "?";
+		const description = args.pat ?? "?";
 		const text = renderStatusLine({ icon: "pending", title: "AST Grep", description, meta }, uiTheme);
 		return new Text(text, 0, 0);
 	},
@@ -321,19 +318,14 @@ export const astGrepToolRenderer = {
 		const limitReached = details?.limitReached ?? false;
 
 		if (matchCount === 0) {
-			const description = args?.pat?.length === 1 ? args.pat[0] : undefined;
+			const description = args?.pat;
 			const meta = ["0 matches"];
 			if (details?.scopePath) meta.push(`in ${details.scopePath}`);
 			if (filesSearched > 0) meta.push(`searched ${filesSearched}`);
 			const header = renderStatusLine({ icon: "warning", title: "AST Grep", description, meta }, uiTheme);
 			const lines = [header, formatEmptyMessage("No matches found", uiTheme)];
 			if (details?.parseErrors?.length) {
-				lines.push(
-					uiTheme.fg(
-						"warning",
-						"Query may be mis-scoped; narrow `path`/`glob` or set `lang` before concluding absence",
-					),
-				);
+				lines.push(uiTheme.fg("warning", "Query may be mis-scoped; narrow `path` before concluding absence"));
 				const capped = details.parseErrors.slice(0, PARSE_ERRORS_LIMIT);
 				for (const err of capped) {
 					lines.push(uiTheme.fg("warning", `  - ${err}`));
@@ -350,13 +342,13 @@ export const astGrepToolRenderer = {
 		if (details?.scopePath) meta.push(`in ${details.scopePath}`);
 		meta.push(`searched ${filesSearched}`);
 		if (limitReached) meta.push(uiTheme.fg("warning", "limit reached"));
-		const description = args?.pat?.length === 1 ? args.pat[0] : undefined;
+		const description = args?.pat;
 		const header = renderStatusLine(
 			{ icon: limitReached ? "warning" : "success", title: "AST Grep", description, meta },
 			uiTheme,
 		);
 
-		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
+		const textContent = result.details?.displayContent ?? result.content?.find(c => c.type === "text")?.text ?? "";
 		const rawLines = textContent.split("\n");
 		const hasSeparators = rawLines.some(line => line.trim().length === 0);
 		const allGroups: string[][] = [];