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

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [15.1.6] - 2026-05-19
+
+### Fixed
+
+- Fixed plan-mode `resolve` looping when grammar-constrained models (e.g. Qwen3.6-35B-MTP via llama.cpp) emit `extra: { title: {} }` instead of a string — the open `Record<string, unknown>` schema for `extra` lets such models drop in an empty object, and the apply guard then hard-threw on every retry. Plan approval now derives the title from `extra.title` when usable, falling back to the plan's first `# Heading`, then the plan filename stem (`local://PLAN.md` → `PLAN`), then the literal `"plan"`. Prompt language relaxed from "MUST" to "SHOULD" for `extra.title`. ([#1179](https://github.com/can1357/oh-my-pi/issues/1179))
+
+## [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
@@ -150,6 +162,7 @@
 
 ### Fixed
 
+- Fixed hashline pure inserts to drop a single echoed anchor line when `edit.hashlineAutoDropPureInsertDuplicates` is enabled and `+ ANCHOR` payloads start with the anchor line or `< ANCHOR` payloads end with it, while preserving intentional single-line duplicates by default. ([#1090](https://github.com/can1357/oh-my-pi/issues/1090))
 - Fixed bash command fixups to remove a redundant standalone trailing `2>&1` redirect when no other pipe or redirection remains
 - Fixed command-fixup notices to list all stripped segments instead of reporting only one
 - Fixed summarized `read` output stalling agents on elided regions by appending an explicit footer like `[NN lines across MM elided regions; read <path>:raw or a line range like <path>:1-9999 for verbatim content]`. The footer fires whenever the structural summarizer elided at least one span, so the model gets a concrete recovery selector instead of having to guess from a bare `...` / `{ .. }` marker. Surfaces `elidedLines` on `ReadToolDetails.summary` alongside the existing `elidedSpans`. ([#1046](https://github.com/can1357/oh-my-pi/issues/1046))

package/dist/types/plan-mode/approved-plan.d.ts

@@ -17,6 +17,24 @@ export declare function normalizePlanTitle(title: string): {
     title: string;
     fileName: string;
 };
+/** Best-effort derivation of a plan title from inputs the agent already produced.
+ *  Returns the first non-empty candidate that survives `normalizePlanTitle`:
+ *    1. an explicit `suppliedTitle` (e.g. `extra.title` from the resolve call),
+ *    2. the first level-1 markdown heading inside `planContent`,
+ *    3. the filename stem of `planFilePath` (e.g. `PLAN` from `local://PLAN.md`),
+ *    4. the literal `"plan"` so callers never have to handle `null`.
+ *  The fallback exists because some grammar-constrained models cannot emit a
+ *  string into the open `extra` schema and instead drop in `{}` (issue #1179);
+ *  plan-mode would otherwise loop forever on an unreachable validation. */
+export declare function resolvePlanTitle(input: {
+    suppliedTitle?: unknown;
+    planContent: string;
+    planFilePath: string;
+}): {
+    title: string;
+    fileName: string;
+    source: "supplied" | "heading" | "filename" | "default";
+};
 /** Humanize a normalized plan title for use as a session display name.
  *  Replaces `-`/`_` separators with spaces and capitalizes the first letter.
  *  Returns an empty string when the input collapses to whitespace. */

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/path-utils.d.ts

@@ -4,6 +4,28 @@ export declare function splitPathAndSel(rawPath: string): {
     path: string;
     sel?: string;
 };
+/**
+ * Variant of {@link splitPathAndSel} for internal URLs (`scheme://...`).
+ *
+ * The filesystem-path splitter is intentionally conservative: it refuses to
+ * peel a trailing `:<chunk>` unless that chunk matches the strict selector
+ * grammar. That rule is right for filesystem paths (a file named `a:1-50` is
+ * legal) but wrong for internal URLs, where any trailing `:<chunk>` after the
+ * scheme is unambiguously a read-tool selector — even if malformed (e.g.
+ * `artifact://3:raw:-100`).
+ *
+ * This function iteratively peels selector-shaped chunks (well-formed plus
+ * common malformed shapes like `:-N`) so the rest of the read tool can pass a
+ * clean URL to the protocol handler and surface selector errors via parseSel
+ * instead of as misleading "host invalid" errors from the handler. Schemes
+ * whose resource URIs may legitimately contain colons (`mcp://`) are skipped.
+ *
+ * Falls back to the input unchanged when nothing matches.
+ */
+export declare function splitInternalUrlSel(rawPath: string): {
+    path: string;
+    sel?: string;
+};
 export declare function normalizeLocalScheme(filePath: string): string;
 export declare function isInternalUrlPath(filePath: string): boolean;
 /**

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.6",
 	"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.6",
+		"@oh-my-pi/pi-agent-core": "15.1.6",
+		"@oh-my-pi/pi-ai": "15.1.6",
+		"@oh-my-pi/pi-natives": "15.1.6",
+		"@oh-my-pi/pi-tui": "15.1.6",
+		"@oh-my-pi/pi-utils": "15.1.6",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/src/hashline/apply.ts

@@ -382,10 +382,9 @@ interface PureInsertAbsorbResult {
  * Mirror of replacement-absorb's prefix/suffix block check, but for pure
  * inserts: drop payload lines that exactly duplicate the file lines
  * immediately above (leading) or immediately below (trailing) the insertion
- * point. Generic context echo absorption requires a minimum run of 2, but a
- * single structural closing delimiter is absorbed because duplicated `}` /
- * `});`-style boundaries almost always mean the insert included adjacent
- * context.
+ * point. Generic context echo absorption requires the caller's opt-in setting;
+ * without it, only single structural closing delimiters use the
+ * balance-validated structural rule below.
  */
 function tryAbsorbPureInsertGroup(
 	group: HashlinePureInsertGroup,
@@ -415,6 +414,17 @@ function tryAbsorbPureInsertGroup(
 			}
 		}
 	}
+	if (
+		absorbedLeading === 0 &&
+		allowGenericBoundaryAbsorb &&
+		group.cursor.kind === "after_anchor" &&
+		group.payload.length > 0 &&
+		aboveEndIdx >= 0 &&
+		!isStructuralClosingBoundaryLine(group.payload[0]) &&
+		group.payload[0] === fileLines[aboveEndIdx]
+	) {
+		absorbedLeading = 1;
+	}
 	if (
 		absorbedLeading === 0 &&
 		group.payload.length > 0 &&
@@ -447,6 +457,17 @@ function tryAbsorbPureInsertGroup(
 			}
 		}
 	}
+	if (
+		absorbedTrailing === 0 &&
+		group.cursor.kind === "before_anchor" &&
+		allowGenericBoundaryAbsorb &&
+		remaining > 0 &&
+		belowStartIdx < fileLines.length &&
+		!isStructuralClosingBoundaryLine(remainingPayload[remainingPayload.length - 1]) &&
+		remainingPayload[remainingPayload.length - 1] === fileLines[belowStartIdx]
+	) {
+		absorbedTrailing = 1;
+	}
 	if (
 		absorbedTrailing === 0 &&
 		remaining > 0 &&

package/src/modes/interactive-mode.ts

@@ -43,9 +43,9 @@ import { resolveLocalUrlToPath } from "../internal-urls";
 import { LSP_STARTUP_EVENT_CHANNEL, type LspStartupEvent } from "../lsp/startup-events";
 import {
 	humanizePlanTitle,
-	normalizePlanTitle,
 	type PlanApprovalDetails,
 	renameApprovedPlanFile,
+	resolvePlanTitle,
 } from "../plan-mode/approved-plan";
 import planModeApprovedPrompt from "../prompts/system/plan-mode-approved.md" with { type: "text" };
 import planModeCompactInstructionsPrompt from "../prompts/system/plan-mode-compact-instructions.md" with {
@@ -1197,13 +1197,6 @@ export class InteractiveMode implements InteractiveModeContext {
 				if (!state?.enabled) {
 					throw new ToolError("Plan mode is not active.");
 				}
-				const title = extra?.title;
-				if (typeof title !== "string" || title.trim() === "") {
-					throw new ToolError(
-						'Plan approval requires `extra: { title: "<PLAN_TITLE>" }`. Provide a title with letters, numbers, underscores, or hyphens only.',
-					);
-				}
-				const normalized = normalizePlanTitle(title);
 				const planFilePath = state.planFilePath;
 				const planContent = await this.#readPlanFile(planFilePath);
 				if (planContent === null) {
@@ -1211,6 +1204,11 @@ export class InteractiveMode implements InteractiveModeContext {
 						`Plan file not found at ${planFilePath}. Write the finalized plan to ${planFilePath} before requesting approval.`,
 					);
 				}
+				const normalized = resolvePlanTitle({
+					suppliedTitle: extra?.title,
+					planContent,
+					planFilePath,
+				});
 				const details: PlanApprovalDetails = {
 					planFilePath,
 					finalPlanFilePath: `local://${normalized.fileName}`,

package/src/plan-mode/approved-plan.ts

@@ -49,6 +49,58 @@ export function normalizePlanTitle(title: string): { title: string; fileName: st
 	return { title: sanitized, fileName };
 }
 
+/** Best-effort derivation of a plan title from inputs the agent already produced.
+ *  Returns the first non-empty candidate that survives `normalizePlanTitle`:
+ *    1. an explicit `suppliedTitle` (e.g. `extra.title` from the resolve call),
+ *    2. the first level-1 markdown heading inside `planContent`,
+ *    3. the filename stem of `planFilePath` (e.g. `PLAN` from `local://PLAN.md`),
+ *    4. the literal `"plan"` so callers never have to handle `null`.
+ *  The fallback exists because some grammar-constrained models cannot emit a
+ *  string into the open `extra` schema and instead drop in `{}` (issue #1179);
+ *  plan-mode would otherwise loop forever on an unreachable validation. */
+export function resolvePlanTitle(input: { suppliedTitle?: unknown; planContent: string; planFilePath: string }): {
+	title: string;
+	fileName: string;
+	source: "supplied" | "heading" | "filename" | "default";
+} {
+	const candidates: Array<{ value: string; source: "supplied" | "heading" | "filename" | "default" }> = [];
+	if (typeof input.suppliedTitle === "string") {
+		const trimmed = input.suppliedTitle.trim();
+		if (trimmed) candidates.push({ value: trimmed, source: "supplied" });
+	}
+	const heading = firstLevelOneHeading(input.planContent);
+	if (heading) candidates.push({ value: heading, source: "heading" });
+	const stem = planFilenameStem(input.planFilePath);
+	if (stem) candidates.push({ value: stem, source: "filename" });
+	candidates.push({ value: "plan", source: "default" });
+
+	for (const candidate of candidates) {
+		try {
+			const normalized = normalizePlanTitle(candidate.value);
+			return { ...normalized, source: candidate.source };
+		} catch {
+			// Fall through to the next candidate.
+		}
+	}
+	// Last-ditch literal so the type-system contract holds even if `normalizePlanTitle("plan")` ever throws.
+	return { title: "plan", fileName: "plan.md", source: "default" };
+}
+
+/** First `# Heading` text on its own line, trimmed. Returns the empty string if
+ *  none is found so callers can chain it through truthiness checks. */
+function firstLevelOneHeading(planContent: string): string {
+	const match = planContent.match(/^[ \t]*#[ \t]+(.+?)[ \t]*$/m);
+	return match?.[1]?.trim() ?? "";
+}
+
+/** Stem of a `local://name.md` (or bare `name.md`) URL — the filename without
+ *  scheme or extension. Returns the empty string for inputs that have no stem. */
+function planFilenameStem(planFilePath: string): string {
+	const withoutScheme = planFilePath.replace(/^local:\/+/, "");
+	const lastSegment = withoutScheme.split(/[\\/]/).pop() ?? "";
+	return lastSegment.replace(/\.md$/i, "");
+}
+
 /** Humanize a normalized plan title for use as a session display name.
  *  Replaces `-`/`_` separators with spaces and capitalizes the first letter.
  *  Returns an empty string when the input collapses to whitespace. */

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/path-utils.ts

@@ -10,6 +10,26 @@ const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
 const FILE_LINE_RANGE_RE = /^(?:L?\d+(?:[-+]L?\d+|-)?(?:,L?\d+(?:[-+]L?\d+|-)?)*|raw|conflicts)$/i;
 const FILE_LINE_RANGE_ONLY_RE = /^L?\d+(?:[-+]L?\d+|-)?(?:,L?\d+(?:[-+]L?\d+|-)?)*$/i;
 const FILE_RAW_ONLY_RE = /^raw$/i;
+// Permissive selector chunk for internal URLs — accepts well-formed selectors
+// plus common malformed shapes (e.g. `:-N`) so the read tool peels the entire
+// selector chain off before dispatching to a protocol handler.
+const INTERNAL_URL_SELECTOR_PART_RE =
+	/^(?:raw|conflicts|L?\d+(?:[-+]L?\d+|-)?(?:,L?\d+(?:[-+]L?\d+|-)?)*|-\d+(?:[-+]\d+)?)$/i;
+// Schemes whose host grammar is identifier-shaped, so any trailing
+// `:<selector-chunk>` is unambiguously a read-tool selector. `mcp://` is
+// excluded because mcp resource URIs may legitimately contain colons.
+const INTERNAL_SCHEMES_WITH_SELECTORS: Record<string, true> = {
+	agent: true,
+	artifact: true,
+	issue: true,
+	local: true,
+	memory: true,
+	omp: true,
+	pr: true,
+	rule: true,
+	skill: true,
+};
+const INTERNAL_URL_SCHEME_RE = /^([a-z][a-z0-9+.-]*):\/\//i;
 const NARROW_NO_BREAK_SPACE = "\u202F";
 const TOP_LEVEL_INTERNAL_URL_PREFIXES = [
 	"agent://",
@@ -135,6 +155,45 @@ export function splitPathAndSel(rawPath: string): { path: string; sel?: string }
 	return { path: basePath, sel };
 }
 
+/**
+ * Variant of {@link splitPathAndSel} for internal URLs (`scheme://...`).
+ *
+ * The filesystem-path splitter is intentionally conservative: it refuses to
+ * peel a trailing `:<chunk>` unless that chunk matches the strict selector
+ * grammar. That rule is right for filesystem paths (a file named `a:1-50` is
+ * legal) but wrong for internal URLs, where any trailing `:<chunk>` after the
+ * scheme is unambiguously a read-tool selector — even if malformed (e.g.
+ * `artifact://3:raw:-100`).
+ *
+ * This function iteratively peels selector-shaped chunks (well-formed plus
+ * common malformed shapes like `:-N`) so the rest of the read tool can pass a
+ * clean URL to the protocol handler and surface selector errors via parseSel
+ * instead of as misleading "host invalid" errors from the handler. Schemes
+ * whose resource URIs may legitimately contain colons (`mcp://`) are skipped.
+ *
+ * Falls back to the input unchanged when nothing matches.
+ */
+export function splitInternalUrlSel(rawPath: string): { path: string; sel?: string } {
+	const schemeMatch = rawPath.match(INTERNAL_URL_SCHEME_RE);
+	if (!schemeMatch) return { path: rawPath };
+	if (!INTERNAL_SCHEMES_WITH_SELECTORS[schemeMatch[1].toLowerCase()]) return { path: rawPath };
+
+	const schemeEnd = schemeMatch[0].length;
+	let path = rawPath;
+	const chunks: string[] = [];
+	while (true) {
+		const colon = path.lastIndexOf(":");
+		// Stop before crossing into the scheme separator `://`.
+		if (colon < schemeEnd) break;
+		const tail = path.slice(colon + 1);
+		if (!INTERNAL_URL_SELECTOR_PART_RE.test(tail)) break;
+		chunks.unshift(tail);
+		path = path.slice(0, colon);
+	}
+	if (chunks.length === 0) return { path: rawPath };
+	return { path, sel: chunks.join(":") };
+}
+
 function assertNotInternalUrl(expanded: string, original: string): void {
 	for (const prefix of TOP_LEVEL_INTERNAL_URL_PREFIXES) {
 		if (expanded.startsWith(prefix)) {

package/src/tools/read.ts

@@ -62,7 +62,13 @@ import {
 	resolveOutputMaxColumns,
 	stripOutputNotice,
 } from "./output-meta";
-import { expandPath, formatPathRelativeToCwd, resolveReadPath, splitPathAndSel } from "./path-utils";
+import {
+	expandPath,
+	formatPathRelativeToCwd,
+	resolveReadPath,
+	splitInternalUrlSel,
+	splitPathAndSel,
+} from "./path-utils";
 import { formatBytes, replaceTabs, shortenPath, wrapBrackets } from "./render-utils";
 import {
 	executeReadQuery,
@@ -1474,10 +1480,12 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			return executeReadUrl(this.session, { path: parsedUrlTarget.path, raw: parsedUrlTarget.raw }, signal);
 		}
 
-		// Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://)
-		const internalTarget = splitPathAndSel(readPath);
+		// Handle internal URLs (agent://, artifact://, memory://, skill://, rule://, local://, mcp://, omp://, issue://, pr://).
+		// Use the internal-URL-aware splitter so malformed selectors are peeled
+		// off the URL and surfaced via parseSel rather than confusing handlers.
 		const internalRouter = InternalUrlRouter.instance();
-		if (internalRouter.canHandle(internalTarget.path)) {
+		if (internalRouter.canHandle(readPath)) {
+			const internalTarget = splitInternalUrlSel(readPath);
 			const parsed = parseSel(internalTarget.sel);
 			return this.#handleInternalUrl(internalTarget.path, parsed, signal);
 		}

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" : ""}`;
 }
 
 // =============================================================================