@oh-my-pi/pi-coding-agent 15.1.4 → 15.1.5

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [15.1.5] - 2026-05-19
+
+### Fixed
+
+- Fixed `ast_grep` and `ast_edit` tool details retaining every per-file parse error — a scan over hundreds of files with syntax-error nodes inflated `details.parseErrors` to one entry per file, leaking into traces and the renderer's "X more" overflow. Errors are now capped at `PARSE_ERRORS_LIMIT` (20) at the source, with the original total preserved in a new `parseErrorsTotal` field for accurate count labels.
+
 ## [15.1.4] - 2026-05-19
 
 ### Fixed

package/dist/types/tools/ast-edit.d.ts

@@ -19,6 +19,8 @@ export interface AstEditToolDetails {
     applied: boolean;
     limitReached: boolean;
     parseErrors?: string[];
+    /** Total parse error count before {@link PARSE_ERRORS_LIMIT} capping. Omitted when no errors. */
+    parseErrorsTotal?: number;
     scopePath?: string;
     files?: string[];
     fileReplacements?: Array<{

package/dist/types/tools/ast-grep.d.ts

@@ -16,6 +16,8 @@ export interface AstGrepToolDetails {
     filesSearched: number;
     limitReached: boolean;
     parseErrors?: string[];
+    /** Total parse error count before {@link PARSE_ERRORS_LIMIT} capping. Omitted when no errors. */
+    parseErrorsTotal?: number;
     scopePath?: string;
     files?: string[];
     fileMatches?: Array<{

package/dist/types/tools/render-utils.d.ts

@@ -117,7 +117,17 @@ export declare function formatScreenshot(opts: {
 export declare function wrapBrackets(text: string, theme: Theme): string;
 export declare const PARSE_ERRORS_LIMIT = 20;
 export declare function dedupeParseErrors(errors: string[] | undefined): string[];
-export declare function formatParseErrors(errors: string[]): string[];
+export declare function formatParseErrors(errors: string[], total?: number): string[];
+/**
+ * Cap an upstream parse-error list to {@link PARSE_ERRORS_LIMIT} unique entries,
+ * preserving the original deduplicated total. Use this at the source so tool
+ * details never carry thousands of per-file parse errors into traces or
+ * renderers.
+ */
+export declare function capParseErrors(errors: string[] | undefined, limit?: number): {
+    errors: string[];
+    total: number;
+};
 /**
  * Group `rawLines` by blank-line separators, mirroring the historical search /
  * ast-grep / ast-edit renderer behavior: if any blank line is present, splits on
@@ -135,12 +145,12 @@ export declare function createCachedComponent(getExpanded: () => boolean, comput
  * {@link PARSE_ERRORS_LIMIT}) to `lines`, with an overflow summary line if the
  * total exceeds the cap. No-op when `parseErrors` is empty.
  */
-export declare function appendParseErrorsBulletList(lines: string[], parseErrors: readonly string[] | undefined, theme: Theme): void;
+export declare function appendParseErrorsBulletList(lines: string[], parseErrors: readonly string[] | undefined, theme: Theme, total?: number): void;
 /**
  * Human-readable summary string for the parse-issues count, capped by
  * {@link PARSE_ERRORS_LIMIT}.
  */
-export declare function formatParseErrorsCountLabel(parseErrors: readonly string[]): string;
+export declare function formatParseErrorsCountLabel(parseErrors: readonly string[], total?: number): string;
 export interface LspBatchRequest {
     id: string;
     flush: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.1.4",
+	"version": "15.1.5",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,12 +47,12 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "15.1.4",
-		"@oh-my-pi/pi-agent-core": "15.1.4",
-		"@oh-my-pi/pi-ai": "15.1.4",
-		"@oh-my-pi/pi-natives": "15.1.4",
-		"@oh-my-pi/pi-tui": "15.1.4",
-		"@oh-my-pi/pi-utils": "15.1.4",
+		"@oh-my-pi/omp-stats": "15.1.5",
+		"@oh-my-pi/pi-agent-core": "15.1.5",
+		"@oh-my-pi/pi-ai": "15.1.5",
+		"@oh-my-pi/pi-natives": "15.1.5",
+		"@oh-my-pi/pi-tui": "15.1.5",
+		"@oh-my-pi/pi-utils": "15.1.5",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/prompts/agents/oracle.md

@@ -0,0 +1,56 @@
+---
+name: oracle
+description: Deep reasoning advisor for debugging dead ends, architecture decisions, and second opinions. Read-only.
+spawns: explore
+model: pi/slow
+thinking-level: xhigh
+blocking: true
+---
+
+You are a senior diagnostician and strategic technical advisor. You receive problems other agents are stuck on — doom loops, mysterious failures, architectural tradeoffs, subtle bugs — and return clear, actionable analysis.
+
+You diagnose, explain, and recommend. You do not implement. Others act on your findings.
+
+<critical>
+You MUST operate as read-only. You NEVER write, edit, or modify files, nor execute any state-changing commands.
+</critical>
+
+<directives>
+- You MUST reason from first principles. The caller already tried the obvious.
+- You MUST use tools to verify claims. You NEVER speculate about code behavior — read it.
+- You MUST identify root causes, not symptoms. If the caller says "X is broken", determine *why* X is broken.
+- You MUST surface hidden assumptions — in the code, in the caller's framing, in the environment.
+- You SHOULD consider at least two hypotheses before converging on one.
+- You SHOULD invoke tools in parallel when investigating multiple hypotheses.
+- When the problem is architectural, you MUST weigh tradeoffs explicitly: what does each option cost, what does it buy, what does it foreclose.
+</directives>
+
+<decision-framework>
+Apply pragmatic minimalism:
+- **Bias toward simplicity**: The right solution is the least complex one that fulfills actual requirements. Resist hypothetical future needs.
+- **Leverage what exists**: Favor modifications to current code and established patterns over introducing new components. New dependencies or infrastructure require explicit justification.
+- **One clear path**: Present a single primary recommendation. Mention alternatives only when they offer substantially different tradeoffs worth considering.
+- **Match depth to complexity**: Quick questions get quick answers. Reserve thorough analysis for genuinely complex problems.
+- **Signal the investment**: Tag recommendations with estimated effort — Quick (<1h), Short (1-4h), Medium (1-2d), Large (3d+).
+</decision-framework>
+
+<procedure>
+1. Read the problem statement carefully. Identify what was already tried and why it failed.
+2. Form 2-3 hypotheses for the root cause.
+3. Use tools to gather evidence — read relevant code, trace data flow, check types, grep for related patterns. Parallelize independent reads.
+4. Eliminate hypotheses based on evidence. Narrow to the most likely cause.
+5. If the problem is a decision (not a bug), lay out options with concrete tradeoffs.
+6. Deliver a clear verdict with supporting evidence.
+</procedure>
+<scope-discipline>
+- Recommend ONLY what was asked. No unsolicited improvements.
+- If you notice other issues, list at most 2 as "Optional future considerations" at the end.
+- You NEVER expand the problem surface beyond the original request.
+- Exhaust provided context before reaching for tools. External lookups fill genuine gaps, not curiosity.
+</scope-discipline>
+
+<critical>
+You MUST keep going until you have a clear answer or have exhausted available evidence.
+Before finalizing: re-scan for unstated assumptions, verify claims are grounded in code not invented, check for overly strong language not justified by evidence.
+This matters. The caller is stuck. Get it right.
+</critical>

package/src/task/agents.ts

@@ -11,6 +11,7 @@ import exploreMd from "../prompts/agents/explore.md" with { type: "text" };
 // Embed agent markdown files at build time
 import agentFrontmatterTemplate from "../prompts/agents/frontmatter.md" with { type: "text" };
 import librarianMd from "../prompts/agents/librarian.md" with { type: "text" };
+import oracleMd from "../prompts/agents/oracle.md" with { type: "text" };
 
 import planMd from "../prompts/agents/plan.md" with { type: "text" };
 import reviewerMd from "../prompts/agents/reviewer.md" with { type: "text" };
@@ -46,6 +47,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 	{ fileName: "designer.md", template: designerMd },
 	{ fileName: "reviewer.md", template: reviewerMd },
 	{ fileName: "librarian.md", template: librarianMd },
+	{ fileName: "oracle.md", template: oracleMd },
 	{
 		fileName: "task.md",
 		frontmatter: {

package/src/tools/ast-edit.ts

@@ -18,8 +18,8 @@ import type { OutputMeta } from "./output-meta";
 import { resolveToolSearchScope } from "./path-utils";
 import {
 	appendParseErrorsBulletList,
+	capParseErrors,
 	createCachedComponent,
-	dedupeParseErrors,
 	formatCodeFrameLine,
 	formatCount,
 	formatEmptyMessage,
@@ -146,6 +146,8 @@ export interface AstEditToolDetails {
 	applied: boolean;
 	limitReached: boolean;
 	parseErrors?: string[];
+	/** Total parse error count before {@link PARSE_ERRORS_LIMIT} capping. Omitted when no errors. */
+	parseErrorsTotal?: number;
 	scopePath?: string;
 	files?: string[];
 	fileReplacements?: Array<{ path: string; count: number }>;
@@ -210,7 +212,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 				signal,
 			});
 
-			const dedupedParseErrors = dedupeParseErrors(result.parseErrors);
+			const { errors: cappedParseErrors, total: parseErrorsTotal } = capParseErrors(result.parseErrors);
 			const formatPath = (filePath: string): string =>
 				formatResultPath(filePath, isDirectory, resolvedSearchPath, this.session.cwd);
 
@@ -237,15 +239,15 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 				filesSearched: result.filesSearched,
 				applied: result.applied,
 				limitReached: result.limitReached,
-				...(dedupedParseErrors.length > 0 ? { parseErrors: dedupedParseErrors } : {}),
+				...(cappedParseErrors.length > 0 ? { parseErrors: cappedParseErrors, parseErrorsTotal } : {}),
 				scopePath,
 				files: fileList,
 				fileReplacements: [],
 			};
 
 			if (result.totalReplacements === 0) {
-				const parseMessage = dedupedParseErrors.length
-					? `\n${formatParseErrors(dedupedParseErrors).join("\n")}`
+				const parseMessage = cappedParseErrors.length
+					? `\n${formatParseErrors(cappedParseErrors, parseErrorsTotal).join("\n")}`
 					: "";
 				return toolResult(baseDetails).text(`No replacements made${parseMessage}`).done();
 			}
@@ -308,8 +310,8 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 			if (result.limitReached) {
 				outputLines.push("", "Limit reached; narrow paths.");
 			}
-			if (dedupedParseErrors.length) {
-				outputLines.push("", ...formatParseErrors(dedupedParseErrors));
+			if (cappedParseErrors.length) {
+				outputLines.push("", ...formatParseErrors(cappedParseErrors, parseErrorsTotal));
 			}
 
 			// Register pending action so `resolve` can apply or discard these previewed changes
@@ -326,7 +328,9 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 							maxFiles,
 							failOnParseError: false,
 						});
-						const dedupedApplyParseErrors = dedupeParseErrors(applyResult.parseErrors);
+						const { errors: cappedApplyParseErrors, total: applyParseErrorsTotal } = capParseErrors(
+							applyResult.parseErrors,
+						);
 						const { record: recordAppliedFile, list: appliedFileList } = createFileRecorder();
 						const appliedFileReplacementCounts = new Map<string, number>();
 						for (const fileChange of applyResult.fileChanges) {
@@ -350,7 +354,9 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 							filesSearched: applyResult.filesSearched,
 							applied: applyResult.applied,
 							limitReached: applyResult.limitReached,
-							...(dedupedApplyParseErrors.length > 0 ? { parseErrors: dedupedApplyParseErrors } : {}),
+							...(cappedApplyParseErrors.length > 0
+								? { parseErrors: cappedApplyParseErrors, parseErrorsTotal: applyParseErrorsTotal }
+								: {}),
 							scopePath,
 							files: appliedFileList,
 							fileReplacements: appliedFileReplacements,
@@ -441,7 +447,7 @@ export const astEditToolRenderer = {
 			if (filesSearched > 0) meta.push(`searched ${filesSearched}`);
 			const header = renderStatusLine({ icon: "warning", title: "AST Edit", description, meta }, uiTheme);
 			const lines = [header, formatEmptyMessage("No replacements made", uiTheme)];
-			appendParseErrorsBulletList(lines, details?.parseErrors, uiTheme);
+			appendParseErrorsBulletList(lines, details?.parseErrors, uiTheme, details?.parseErrorsTotal);
 			return new Text(lines.join("\n"), 0, 0);
 		}
 
@@ -470,7 +476,9 @@ export const astEditToolRenderer = {
 			extraLines.push(uiTheme.fg("warning", "limit reached; narrow path"));
 		}
 		if (details?.parseErrors?.length) {
-			extraLines.push(uiTheme.fg("warning", formatParseErrorsCountLabel(details.parseErrors)));
+			extraLines.push(
+				uiTheme.fg("warning", formatParseErrorsCountLabel(details.parseErrors, details.parseErrorsTotal)),
+			);
 		}
 		return createCachedComponent(
 			() => options.expanded,

package/src/tools/ast-grep.ts

@@ -18,8 +18,8 @@ import type { OutputMeta } from "./output-meta";
 import { resolveToolSearchScope } from "./path-utils";
 import {
 	appendParseErrorsBulletList,
+	capParseErrors,
 	createCachedComponent,
-	dedupeParseErrors,
 	formatCodeFrameLine,
 	formatCount,
 	formatEmptyMessage,
@@ -104,6 +104,8 @@ export interface AstGrepToolDetails {
 	filesSearched: number;
 	limitReached: boolean;
 	parseErrors?: string[];
+	/** Total parse error count before {@link PARSE_ERRORS_LIMIT} capping. Omitted when no errors. */
+	parseErrorsTotal?: number;
 	scopePath?: string;
 	files?: string[];
 	fileMatches?: Array<{ path: string; count: number }>;
@@ -172,7 +174,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				const parseError = error.match(/^.+: (.+: parse error \(syntax tree contains error nodes\))$/);
 				return parseError?.[1] ?? error;
 			});
-			const dedupedParseErrors = dedupeParseErrors(normalizedParseErrors);
+			const { errors: cappedParseErrors, total: parseErrorsTotal } = capParseErrors(normalizedParseErrors);
 			const formatPath = (filePath: string): string =>
 				formatResultPath(filePath, isDirectory, resolvedSearchPath, this.session.cwd);
 
@@ -193,18 +195,18 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				fileCount: result.filesWithMatches,
 				filesSearched: result.filesSearched,
 				limitReached: result.limitReached,
-				...(dedupedParseErrors.length > 0 ? { parseErrors: dedupedParseErrors } : {}),
+				...(cappedParseErrors.length > 0 ? { parseErrors: cappedParseErrors, parseErrorsTotal } : {}),
 				scopePath,
 				files: fileList,
 				fileMatches: [],
 			};
 
 			if (result.matches.length === 0) {
-				const noMatchMessage = dedupedParseErrors.length
+				const noMatchMessage = cappedParseErrors.length
 					? "No matches found. Parse issues mean the query may be mis-scoped; narrow `paths` before concluding absence."
 					: "No matches found";
-				const parseMessage = dedupedParseErrors.length
-					? `\n${formatParseErrors(dedupedParseErrors).join("\n")}`
+				const parseMessage = cappedParseErrors.length
+					? `\n${formatParseErrors(cappedParseErrors, parseErrorsTotal).join("\n")}`
 					: "";
 				return toolResult(baseDetails).text(`${noMatchMessage}${parseMessage}`).done();
 			}
@@ -269,8 +271,8 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 			if (result.limitReached) {
 				outputLines.push("", "Result limit reached; narrow paths or increase limit.");
 			}
-			if (dedupedParseErrors.length) {
-				outputLines.push("", ...formatParseErrors(dedupedParseErrors));
+			if (cappedParseErrors.length) {
+				outputLines.push("", ...formatParseErrors(cappedParseErrors, parseErrorsTotal));
 			}
 
 			return toolResult(details).text(outputLines.join("\n")).done();
@@ -329,7 +331,7 @@ export const astGrepToolRenderer = {
 			const lines = [header, formatEmptyMessage("No matches found", uiTheme)];
 			if (details?.parseErrors?.length) {
 				lines.push(uiTheme.fg("warning", "Query may be mis-scoped; narrow `paths` before concluding absence"));
-				appendParseErrorsBulletList(lines, details.parseErrors, uiTheme);
+				appendParseErrorsBulletList(lines, details.parseErrors, uiTheme, details.parseErrorsTotal);
 			}
 			return new Text(lines.join("\n"), 0, 0);
 		}
@@ -356,7 +358,9 @@ export const astGrepToolRenderer = {
 			extraLines.push(uiTheme.fg("warning", "limit reached; narrow paths or increase limit"));
 		}
 		if (details?.parseErrors?.length) {
-			extraLines.push(uiTheme.fg("warning", formatParseErrorsCountLabel(details.parseErrors)));
+			extraLines.push(
+				uiTheme.fg("warning", formatParseErrorsCountLabel(details.parseErrors, details.parseErrorsTotal)),
+			);
 		}
 
 		return createCachedComponent(

package/src/tools/render-utils.ts

@@ -633,17 +633,29 @@ export function dedupeParseErrors(errors: string[] | undefined): string[] {
 	return deduped;
 }
 
-export function formatParseErrors(errors: string[]): string[] {
+export function formatParseErrors(errors: string[], total?: number): string[] {
 	const deduped = dedupeParseErrors(errors);
 	if (deduped.length === 0) return [];
+	const fullCount = total ?? deduped.length;
 	const capped = deduped.slice(0, PARSE_ERRORS_LIMIT);
-	const header =
-		deduped.length > PARSE_ERRORS_LIMIT
-			? `Parse issues (${PARSE_ERRORS_LIMIT} / ${deduped.length}):`
-			: "Parse issues:";
+	const header = fullCount > capped.length ? `Parse issues (${capped.length} / ${fullCount}):` : "Parse issues:";
 	return [header, ...capped.map(err => `- ${err}`)];
 }
 
+/**
+ * Cap an upstream parse-error list to {@link PARSE_ERRORS_LIMIT} unique entries,
+ * preserving the original deduplicated total. Use this at the source so tool
+ * details never carry thousands of per-file parse errors into traces or
+ * renderers.
+ */
+export function capParseErrors(
+	errors: string[] | undefined,
+	limit: number = PARSE_ERRORS_LIMIT,
+): { errors: string[]; total: number } {
+	const deduped = dedupeParseErrors(errors);
+	return { errors: deduped.slice(0, limit), total: deduped.length };
+}
+
 // =============================================================================
 // Renderer helpers shared by search / find / ast tools
 // =============================================================================
@@ -712,14 +724,16 @@ export function appendParseErrorsBulletList(
 	lines: string[],
 	parseErrors: readonly string[] | undefined,
 	theme: Theme,
+	total?: number,
 ): void {
 	if (!parseErrors || parseErrors.length === 0) return;
+	const fullCount = total ?? parseErrors.length;
 	const capped = parseErrors.slice(0, PARSE_ERRORS_LIMIT);
 	for (const err of capped) {
 		lines.push(theme.fg("warning", `  - ${err}`));
 	}
-	if (parseErrors.length > PARSE_ERRORS_LIMIT) {
-		lines.push(theme.fg("dim", `  … ${parseErrors.length - PARSE_ERRORS_LIMIT} more`));
+	if (fullCount > capped.length) {
+		lines.push(theme.fg("dim", `  … ${fullCount - capped.length} more`));
 	}
 }
 
@@ -727,11 +741,11 @@ export function appendParseErrorsBulletList(
  * Human-readable summary string for the parse-issues count, capped by
  * {@link PARSE_ERRORS_LIMIT}.
  */
-export function formatParseErrorsCountLabel(parseErrors: readonly string[]): string {
-	const total = parseErrors.length;
-	return total > PARSE_ERRORS_LIMIT
-		? `${PARSE_ERRORS_LIMIT} / ${total} parse issues`
-		: `${total} parse issue${total !== 1 ? "s" : ""}`;
+export function formatParseErrorsCountLabel(parseErrors: readonly string[], total?: number): string {
+	const fullCount = total ?? parseErrors.length;
+	return fullCount > PARSE_ERRORS_LIMIT
+		? `${PARSE_ERRORS_LIMIT} / ${fullCount} parse issues`
+		: `${fullCount} parse issue${fullCount !== 1 ? "s" : ""}`;
 }
 
 // =============================================================================