@khanhicetea/pi-better-tool 0.2.1 → 0.2.3

package/src/diagnostics.ts

@@ -8,12 +8,12 @@
  *   prefix/suffix context expansion that makes that occurrence unique,
  *   rendered as a ready-to-use oldText snippet
  * - not-found oldText  → the closest matching region (fuzzy line similarity),
- *   a per-line comparison, and the exact file bytes to retry with
+ *   an original-text comparison, and exact LF-normalized retry text when safe
  */
 
-import { formatSize, truncateHead } from "@earendil-works/pi-coding-agent";
 import type { EditFailure, EditOp, LineRange } from "./apply.ts";
 import { normalizeEdits } from "./apply.ts";
+import { languageForPath } from "./symbols.ts";
 import { findClosestRegion, lineSimilarity, probeMatchCauses } from "./similarity.ts";
 import {
 	countFuzzyOccurrences,
@@ -41,6 +41,8 @@ const MAX_OUTPUT_LINES = 1_500;
 const MAX_OUTPUT_BYTES = 48 * 1024;
 /** Minimum score at which a unique closest region may be suggested directly. */
 const MIN_DIRECT_RETRY_SCORE = 0.75;
+/** Required separation from a distinct runner-up before direct-retry wording. */
+const MIN_DIRECT_RETRY_GAP = 0.1;
 /** Max non-equal alignment ops rendered. */
 const MAX_DIFF_OPS_SHOWN = 12;
 
@@ -81,22 +83,32 @@ export function formatAutoDisambiguationSuccess(
 	newContent: string,
 	resolutions: AutoDisambiguation[],
 ): string {
-	if (resolutions.length === 0) return baseMessage;
+	if (resolutions.length === 0) return boundCompleteOutput(baseMessage);
 	const lines = [baseMessage, ""];
 	const shownResolutions = resolutions.slice(0, MAX_SUCCESS_RESOLUTIONS);
+	if (newContent.length > MAX_CONTENT_FOR_DIAGNOSTICS) {
+		for (const resolution of shownResolutions) {
+			lines.push(
+				`Auto-disambiguated edits[${resolution.editIndex}] to ${describeLines(resolution.chosenRange.start, resolution.chosenRange.end)} because it was the only occurrence fully contained in the latest verified read of ${describeLines(resolution.readRange.start, resolution.readRange.end)}.`,
+			);
+		}
+		lines.push("Remaining-occurrence snippets were omitted because the edited file exceeds the diagnostic analysis limit.");
+		return boundCompleteOutput(lines.join("\n"));
+	}
 
 	for (const resolution of shownResolutions) {
 		lines.push(
 			`Auto-disambiguated edits[${resolution.editIndex}] to ${describeLines(resolution.chosenRange.start, resolution.chosenRange.end)} because it was the only occurrence fully contained in the latest verified read of ${describeLines(resolution.readRange.start, resolution.readRange.end)}.`,
 		);
 		const oldText = normalizeToLF(resolution.oldText);
-		const offsets = findAllOccurrences(newContent, oldText);
-		if (offsets.length === 0) {
+		const remainingCount = countLiteralOccurrences(newContent, oldText);
+		const offsets = findAllOccurrences(newContent, oldText, MAX_REMAINING_OCCURRENCES);
+		if (remainingCount === 0) {
 			lines.push("No exact occurrences of the original oldText remain after this edit.", "");
 			continue;
 		}
 
-		lines.push(`Remaining exact occurrences of the original oldText (${Math.min(offsets.length, MAX_REMAINING_OCCURRENCES)} shown${offsets.length > MAX_REMAINING_OCCURRENCES ? `, ${offsets.length - MAX_REMAINING_OCCURRENCES} more omitted` : ""}):`);
+		lines.push(`Remaining exact occurrences of the original oldText (${offsets.length} shown${remainingCount > offsets.length ? `, ${remainingCount - offsets.length} more omitted` : ""}):`);
 		const fuzzyContent = normalizeForFuzzyMatch(newContent);
 		const spans = getLineSpans(newContent);
 		for (const [index, offset] of offsets.slice(0, MAX_REMAINING_OCCURRENCES).entries()) {
@@ -119,14 +131,24 @@ export function formatAutoDisambiguationSuccess(
 	if (resolutions.length > shownResolutions.length) {
 		lines.push(`${resolutions.length - shownResolutions.length} more auto-disambiguated edits were applied; details omitted.`);
 	}
-	return lines.join("\n").trimEnd();
+	return boundCompleteOutput(lines.join("\n").trimEnd());
 }
 
 export function formatEditFailure(opts: FormatFailureOptions): string {
-	const message = formatEditFailureUnbounded(opts);
-	const bounded = truncateHead(message, { maxBytes: MAX_OUTPUT_BYTES, maxLines: MAX_OUTPUT_LINES });
-	if (!bounded.truncated) return message;
-	return `${bounded.content}\n\n[Diagnostic output truncated to ${formatSize(bounded.outputBytes)} / ${bounded.outputLines} lines. Any incomplete snippet is not retryable; read the referenced range first.]`;
+	const { failure, edits } = opts;
+	const target = "editIndex" in failure ? `edits[${failure.editIndex}]` : failure.kind === "overlap" ? `edits[${failure.firstEditIndex}] and edits[${failure.secondEditIndex}]` : "the replacement text";
+	const batch = edits.length > 1
+		? `Batch status: 0/${edits.length} replacements written. Fix ${target} and resubmit the complete batch against the original file; no earlier replacement was applied.`
+		: "Write status: no changes were written by this call.";
+	return boundCompleteOutput(`[edit failure: ${failure.kind}]\n${batch}\n\n${formatEditFailureUnbounded(opts)}`);
+}
+
+/** Concrete next arguments prevent another call just to discover boundaries. */
+function nextContextCall(path: string, start: number, end = start): string {
+	const read = `read ${JSON.stringify({ path, offset: Math.max(1, start - 3), limit: Math.min(1800, end - start + 7) })}`;
+	return languageForPath(path)
+		? `Next context call: read_symbol ${JSON.stringify({ path, line: start })} for the enclosing symbol; or ${read} for exact line context.`
+		: `Next context call: ${read}.`;
 }
 
 function formatEditFailureUnbounded(opts: FormatFailureOptions): string {
@@ -135,9 +157,7 @@ function formatEditFailureUnbounded(opts: FormatFailureOptions): string {
 
 	switch (failure.kind) {
 		case "empty-old-text": {
-			return total === 1
-				? `oldText must not be empty in ${path}.`
-				: `edits[${failure.editIndex}].oldText must not be empty in ${path}.`;
+			return `${total === 1 ? "oldText" : `edits[${failure.editIndex}].oldText`} must not be empty in ${path}. Copy non-empty source text as the anchor; for insertion, retain that anchor in newText.\n${nextContextCall(path, 1)}`;
 		}
 
 		case "not-found": {
@@ -156,8 +176,8 @@ function formatEditFailureUnbounded(opts: FormatFailureOptions): string {
 		case "ambiguous": {
 			const head =
 				total === 1
-					? `Found ${failure.occurrenceOffsets.length} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`
-					: `Found ${failure.occurrenceOffsets.length} occurrences of edits[${failure.editIndex}] in ${path}. Each oldText must be unique. Please provide more context to make it unique.`;
+					? `Found ${failure.occurrenceCount} occurrences of the text in ${path}. The text must be unique. Please provide more context to make it unique.`
+					: `Found ${failure.occurrenceCount} occurrences of edits[${failure.editIndex}] in ${path}. Each oldText must be unique. Please provide more context to make it unique.`;
 			const body =
 				normalizedContent.length <= MAX_CONTENT_FOR_DIAGNOSTICS
 					? formatAmbiguous(opts, failure)
@@ -167,13 +187,19 @@ function formatEditFailureUnbounded(opts: FormatFailureOptions): string {
 
 		case "overlap": {
 			const { firstEditIndex, secondEditIndex, firstRange, secondRange } = failure;
-			return `edits[${firstEditIndex}] and edits[${secondEditIndex}] overlap in ${path} (edits[${firstEditIndex}] covers lines ${firstRange.start}-${firstRange.end}, edits[${secondEditIndex}] covers lines ${secondRange.start}-${secondRange.end}). Merge them into one edit or target disjoint regions.`;
+			const start = Math.min(firstRange.start, secondRange.start);
+			const end = Math.max(firstRange.end, secondRange.end);
+			const head = `edits[${firstEditIndex}] and edits[${secondEditIndex}] overlap in ${path} (edits[${firstEditIndex}] covers lines ${firstRange.start}-${firstRange.end}, edits[${secondEditIndex}] covers lines ${secondRange.start}-${secondRange.end}). Merge them into one edit or target disjoint regions.`;
+			const expansion = normalizedContent.length <= MAX_CONTENT_FOR_DIAGNOSTICS
+				? findMinimalUniqueExpansion(normalizedContent, normalizeForFuzzyMatch(normalizedContent), getLineSpans(normalizedContent), { start, end }) : null;
+			if (expansion && isSnippetRenderable(expansion.text)) {
+				return `${head}\n\nRetryable merged oldText at lines ${expansion.startLine}-${expansion.endLine}. Apply BOTH intended changes to this snippet in one newText; do not concatenate the previous replacements.\n${renderSnippet(expansion.text).join("\n")}`;
+			}
+			return `${head}\nMerged source snippet omitted or not unique. ${nextContextCall(path, start, end)}`;
 		}
 
 		case "no-change": {
-			return total === 1
-				? `No changes made to ${path}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`
-				: `No changes made to ${path}. The replacements produced identical content.`;
+			return `No changes made to ${path}. The replacement${total === 1 ? "" : "s"} produced identical content. Do not repeat the same call. If the intended change is already present, stop; otherwise change newText so it differs from the matched source.`;
 		}
 	}
 }
@@ -196,9 +222,10 @@ function formatAmbiguous(opts: FormatFailureOptions, failure: Extract<EditFailur
 	listed.forEach((offset, i) => {
 		const range = rangeFromOffset(fuzzySpans, offset, fuzzyOld.length);
 		lines.push(`  ${i + 1}. ${describeLines(range.start, range.end)}`);
+		lines.push(`     ${nextContextCall(opts.path, range.start, range.end)}`);
 	});
-	if (failure.occurrenceOffsets.length > listed.length) {
-		lines.push(`  … and ${failure.occurrenceOffsets.length - listed.length} more`);
+	if (failure.occurrenceCount > listed.length) {
+		lines.push(`  … and ${failure.occurrenceCount - listed.length} more`);
 	}
 	lines.push("");
 
@@ -259,6 +286,17 @@ function plural(n: number, noun: string): string {
 	return `${n} ${noun}${n === 1 ? "" : "s"}`;
 }
 
+function countLiteralOccurrences(haystack: string, needle: string): number {
+	if (!needle) return 0;
+	let count = 0;
+	let index = haystack.indexOf(needle);
+	while (index !== -1) {
+		count++;
+		index = haystack.indexOf(needle, index + needle.length);
+	}
+	return count;
+}
+
 /**
  * Find the smallest whole-line context expansion of the occurrence at `range`
  * whose text occurs exactly once in the file (checked in fuzzy space, exactly
@@ -326,6 +364,14 @@ function formatNotFound(opts: FormatFailureOptions, oldText: string): string {
 	const causes = probeMatchCauses(normalizedContent, oldText);
 
 	const lines: string[] = [];
+	const edit = "editIndex" in opts.failure ? normalizeEdits(opts.edits)[opts.failure.editIndex] : undefined;
+	if (edit?.newText && edit.newText !== oldText) {
+		const offsets = findAllOccurrences(normalizedContent, edit.newText, 4);
+		if (offsets.length) {
+			const spans = getLineSpans(normalizedContent);
+			lines.push(`Replacement text already appears at ${offsets.map((offset) => { const range = rangeFromOffset(spans, offset, edit.newText.length); return describeLines(range.start, range.end); }).join(", ")} (up to 4 shown). The change may already be applied; verify intent before choosing another target.`, "");
+		}
+	}
 	if (closest) {
 		lines.push(
 			`Closest match in the file: ${describeLines(closest.startLine, closest.endLine)} (~${Math.round(closest.score * 100)}% line similarity${closest.truncated ? `, compared against the first ${closest.totalOldLines} lines of your oldText` : ""}).`,
@@ -353,9 +399,9 @@ function formatNotFound(opts: FormatFailureOptions, oldText: string): string {
 				);
 			}
 		} else {
-			lines.push(`Differences vs your oldText (${closest.equalCount} of ${closest.totalOldLines} compared lines match):`);
+			lines.push(`Differences vs your oldText (${closest.equalCount} of ${closest.totalOldLines} compared lines match exactly):`);
 			for (const op of diffOps.slice(0, MAX_DIFF_OPS_SHOWN)) {
-				if (op.type === "changed") {
+				if (op.type === "changed" || op.type === "similar") {
 					lines.push(`  file line ${op.fileLine} differs from your oldText line ${op.oldLine}:`);
 					lines.push(`    file:     ${truncateLine(op.fileText ?? "")}`);
 					lines.push(`    oldText:  ${truncateLine(op.oldText ?? "")}`);
@@ -375,9 +421,12 @@ function formatNotFound(opts: FormatFailureOptions, oldText: string): string {
 		const candidate = textFromLines(normalizedContent, closest.startLine, closest.endLine);
 		const uniqueCandidate = verifyUniqueSnippet(normalizeForFuzzyMatch(normalizedContent), candidate);
 		const safelyRenderable = isSnippetRenderable(uniqueCandidate ?? candidate);
+		const competitorGap = closest.competitor ? closest.score - closest.competitor.score : Number.POSITIVE_INFINITY;
 		const directRetry =
 			!closest.truncated &&
 			closest.score >= MIN_DIRECT_RETRY_SCORE &&
+			!closest.competitionIncomplete &&
+			competitorGap >= MIN_DIRECT_RETRY_GAP &&
 			uniqueCandidate !== null &&
 			safelyRenderable;
 		if (directRetry) {
@@ -389,6 +438,10 @@ function formatNotFound(opts: FormatFailureOptions, oldText: string): string {
 			const reasons = [
 				closest.truncated ? "only part of oldText was compared" : undefined,
 				closest.score < MIN_DIRECT_RETRY_SCORE ? "similarity confidence is too low" : undefined,
+				closest.competitionIncomplete ? "the bounded search discarded another competitively scored window" : undefined,
+				competitorGap < MIN_DIRECT_RETRY_GAP && closest.competitor
+					? `a distinct candidate at ${describeLines(closest.competitor.startLine, closest.competitor.endLine)} has a similar heuristic score (~${Math.round(closest.competitor.score * 100)}%)`
+					: undefined,
 				uniqueCandidate === null ? "the candidate is not unique under edit matching" : undefined,
 				!safelyRenderable ? "the exact candidate exceeds the safe output limit" : undefined,
 			].filter((reason): reason is string => reason !== undefined);
@@ -396,11 +449,14 @@ function formatNotFound(opts: FormatFailureOptions, oldText: string): string {
 				`Candidate file content at ${describeLines(closest.startLine, closest.endLine)} is not safe for a direct retry (${reasons.join("; ")}). Read and verify this range before editing.`,
 			);
 			if (safelyRenderable) lines.push(...renderSnippet(uniqueCandidate ?? candidate));
+			lines.push(nextContextCall(opts.path, closest.startLine, closest.endLine));
+			if (closest.competitor && competitorGap < MIN_DIRECT_RETRY_GAP) lines.push(nextContextCall(opts.path, closest.competitor.startLine, closest.competitor.endLine));
 		}
 
 	} else {
 		lines.push("No reliable similar region was found within the bounded diagnostic search.");
 		lines.push("If you expected this text to exist, read the file around the expected location and retry.");
+		lines.push(languageForPath(opts.path) ? `Next context call: read_symbol ${JSON.stringify({ path: opts.path })} to locate the intended symbol without guessing line ranges.` : nextContextCall(opts.path, 1));
 	}
 
 	if (causes.length > 0) {
@@ -412,8 +468,85 @@ function formatNotFound(opts: FormatFailureOptions, oldText: string): string {
 }
 
 function truncateLine(line: string): string {
-	const collapsed = line.replace(/\t/g, "→tab→");
-	return collapsed.length > 120 ? `${collapsed.slice(0, 117)}…` : collapsed;
+	const visibleTrailing = line.replace(/[ \t]+$/, (suffix) =>
+		[...suffix].map((char) => (char === "\t" ? "→tab→" : "·")).join(""),
+	);
+	const visible = visibleTrailing.replace(/\t/g, "→tab→");
+	return visible.length > 120 ? `${visible.slice(0, 117)}…` : visible;
+}
+
+/**
+ * Enforce the complete output budget without ever cutting a generated fenced
+ * snippet. Oversized snippets are omitted atomically and clearly marked.
+ */
+export function boundCompleteOutput(message: string): string {
+	const source = message.split("\n");
+	const output: string[] = [];
+	let bytes = 0;
+	let omitted = false;
+	const reservedBytes = 512;
+	const maxBodyBytes = MAX_OUTPUT_BYTES - reservedBytes;
+	const maxBodyLines = MAX_OUTPUT_LINES - 3;
+
+	const canAdd = (block: string[]) => {
+		const text = block.join("\n");
+		const addedBytes = Buffer.byteLength(text, "utf8") + (output.length > 0 ? 1 : 0);
+		return output.length + block.length <= maxBodyLines && bytes + addedBytes <= maxBodyBytes;
+	};
+	const add = (block: string[]) => {
+		const text = block.join("\n");
+		bytes += Buffer.byteLength(text, "utf8") + (output.length > 0 ? 1 : 0);
+		output.push(...block);
+	};
+
+	for (let index = 0; index < source.length; index++) {
+		const opener = source[index];
+		if (/^`{3,}$/.test(opener)) {
+			let closing = index + 1;
+			while (closing < source.length && source[closing] !== opener) closing++;
+			if (closing < source.length) {
+				const block = source.slice(index, closing + 1);
+				if (canAdd(block)) add(block);
+				else {
+					omitted = true;
+					const notice = ["[Exact fenced snippet omitted to keep the complete tool output within its byte/line budget.]" ];
+					if (canAdd(notice)) add(notice);
+				}
+				index = closing;
+				continue;
+			}
+		}
+
+		if (canAdd([opener])) {
+			add([opener]);
+			continue;
+		}
+		omitted = true;
+		const available = Math.max(0, maxBodyBytes - bytes - (output.length > 0 ? 1 : 0));
+		if (available > 4 && output.length < maxBodyLines) add([truncateUtf8(opener, available)]);
+		break;
+	}
+
+	if (omitted) {
+		const notice = "[Diagnostic output was bounded. Omitted fenced snippets are not retryable; read the referenced range first.]";
+		if (output.length > 0) output.push("");
+		output.push(notice);
+	}
+	return output.join("\n").trimEnd();
+}
+
+function truncateUtf8(text: string, maxBytes: number): string {
+	if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+	const suffix = "…";
+	const target = Math.max(0, maxBytes - Buffer.byteLength(suffix, "utf8"));
+	let low = 0;
+	let high = text.length;
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		if (Buffer.byteLength(text.slice(0, middle), "utf8") <= target) low = middle;
+		else high = middle - 1;
+	}
+	return `${text.slice(0, low)}${suffix}`;
 }
 
 // ---------------------------------------------------------------------------

package/src/index.ts

@@ -1,17 +1,26 @@
 /**
  * pi-better-tool — better built-in tools for the pi coding agent.
  *
- * Currently ships one override:
- * - `edit` — built-in-compatible exact replacement with richer recovery
- *   context and conservative read-based resolution when a recent verified
- *   read contains exactly one of several literal occurrences.
+ * Ships a safe edit override and a separate syntax-aware source reader:
+ * - `edit` — exact replacement with actionable recovery context.
+ * - `read_symbol` — whole symbols by containing line or exact name.
+ * Built-in `read` remains available for text, images, and explicit line ranges.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerBetterEditTool } from "./tool.ts";
+import { registerReadSymbolTool } from "./read-symbol.ts";
+
+export { executeReadSymbol, registerReadSymbolTool, readSymbolSchema } from "./read-symbol.ts";
+export type { ReadSymbolInput, ReadSymbolResult } from "./read-symbol.ts";
 
 export { registerBetterEditTool, executeBetterEdit, prepareEditArguments, betterEditSchema } from "./tool.ts";
-export type { BetterEditInput } from "./tool.ts";
+export type {
+	BetterEditExecutionOptions,
+	BetterEditInput,
+	BetterEditOperations,
+	BetterEditSuccess,
+} from "./tool.ts";
 export {
 	formatAutoDisambiguationSuccess,
 	formatEditFailure,
@@ -24,4 +33,5 @@ export type { AnalyzeOptions, EditFailure, EditOp, EditAnalysis } from "./apply.
 
 export default function (pi: ExtensionAPI) {
 	registerBetterEditTool(pi);
+	registerReadSymbolTool(pi);
 }

package/src/paths.ts

@@ -0,0 +1,19 @@
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+
+/** Match Pi's built-in path normalization for all local tools in this package. */
+export function resolveToolPath(input: string, cwd: string): string {
+	let path = input.replace(UNICODE_SPACES, " ");
+	if (path.startsWith("@")) path = path.slice(1);
+	if (process.platform === "win32" && path.startsWith("/") && !path.startsWith("//") && !path.includes("\\")) {
+		const match = path.match(/^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i);
+		if (match) path = `${match[1].toUpperCase()}:\\${match[2]?.replaceAll("/", "\\") ?? ""}`;
+	}
+	if (path === "~") path = homedir();
+	else if (path.startsWith("~/") || (process.platform === "win32" && path.startsWith("~\\"))) path = join(homedir(), path.slice(2));
+	if (/^file:\/\//.test(path)) path = fileURLToPath(path);
+	return isAbsolute(path) ? resolve(path) : resolve(cwd, path);
+}

package/src/read-evidence.ts

@@ -6,34 +6,52 @@ import {
 	type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { normalizeToLF } from "./text.ts";
+import { buildSymbolRead, type ReadSymbolInput } from "./read-symbol.ts";
 
 export interface ReadEvidence {
 	/** 0-based, end-exclusive offsets in LF-normalized, BOM-stripped content. */
 	startOffset: number;
 	endOffset: number;
-	/** 1-based inclusive range actually shown to the model. */
+	/** 1-based inclusive range represented by the verified read output. */
 	startLine: number;
 	endLine: number;
 }
 
 interface ReadCall {
+	id: string;
+	name: "read" | "read_symbol";
+	arguments: Record<string, unknown>;
 	path: string;
 	offset?: number;
 	limit?: number;
 }
 
 interface StoredToolResult {
+	role: "toolResult";
 	toolCallId: string;
 	toolName: string;
 	isError: boolean;
 	content: Array<{ type: string; text?: string }>;
 }
 
+interface StoredAssistant {
+	role: "assistant";
+	content: Array<{ type: string; id?: string; name?: string; arguments?: unknown }>;
+}
+
+interface ContextEntryLike {
+	type: string;
+	message?: StoredAssistant | StoredToolResult | { role: string };
+	retainedTail?: Array<StoredAssistant | StoredToolResult | { role: string }>;
+}
+
 /**
- * Find the newest successful read of targetPath still present in the active
- * model context. The returned range is accepted only when the stored tool
- * output exactly matches what the built-in read tool would produce from the
- * current file bytes. This makes stale or custom read output fail closed.
+ * Find the newest read call for targetPath in Pi's compaction-aware stored
+ * context. The call is accepted only when its successful result exactly
+ * matches the built-in read formatting for the current LF-normalized content.
+ *
+ * This establishes stored-context evidence, not proof of the final provider
+ * payload after other extensions' context/provider hooks.
  */
 export async function findLatestReadEvidence(
 	sessionManager: Pick<ExtensionContext["sessionManager"], "buildContextEntries"> | undefined,
@@ -42,49 +60,70 @@ export async function findLatestReadEvidence(
 	resolvePath: (path: string) => Promise<string>,
 ): Promise<ReadEvidence | null> {
 	if (!sessionManager) return null;
-	const entries = sessionManager.buildContextEntries();
-	const calls = new Map<string, ReadCall>();
-
-	for (const entry of entries) {
-		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
-		for (const item of entry.message.content) {
-			if (item.type !== "toolCall" || item.name !== "read") continue;
-			const args = item.arguments as Record<string, unknown>;
-			if (typeof args.path !== "string") continue;
-			calls.set(item.id, {
-				path: args.path,
-				offset: typeof args.offset === "number" ? args.offset : undefined,
-				limit: typeof args.limit === "number" ? args.limit : undefined,
-			});
+	const entries = sessionManager.buildContextEntries() as ContextEntryLike[];
+	const messages = entries.flatMap((entry) => {
+		if (entry.type === "message" && entry.message) return [entry.message];
+		if (entry.type === "compaction" && Array.isArray(entry.retainedTail)) return entry.retainedTail;
+		return [];
+	});
+	const calls: ReadCall[] = [];
+	const results = new Map<string, StoredToolResult>();
+
+	for (const message of messages) {
+		if (message.role === "assistant") {
+			for (const item of (message as StoredAssistant).content) {
+				if (item.type !== "toolCall" || (item.name !== "read" && item.name !== "read_symbol") || typeof item.id !== "string") continue;
+				const args = item.arguments as Record<string, unknown> | undefined;
+				if (!args || typeof args.path !== "string") continue;
+				calls.push({
+					id: item.id,
+					name: item.name,
+					arguments: args,
+					path: args.path,
+					offset: typeof args.offset === "number" ? args.offset : undefined,
+					limit: typeof args.limit === "number" ? args.limit : undefined,
+				});
+			}
+		} else if (message.role === "toolResult") {
+			const result = message as StoredToolResult;
+			if (result.toolName === "read" || result.toolName === "read_symbol") results.set(result.toolCallId, result);
 		}
 	}
 
-	for (let i = entries.length - 1; i >= 0; i--) {
-		const entry = entries[i];
-		if (entry.type !== "message" || entry.message.role !== "toolResult") continue;
-		const result = entry.message as StoredToolResult;
-		if (result.toolName !== "read" || result.isError) continue;
-		const call = calls.get(result.toolCallId);
-		if (!call) continue;
-
+	for (let index = calls.length - 1; index >= 0; index--) {
+		const call = calls[index];
 		let readPath: string;
 		try {
 			readPath = await resolvePath(call.path);
 		} catch {
-			continue;
+			// Without a canonical identity we cannot prove that this newer read is
+			// unrelated, so fail closed instead of falling back to older intent.
+			return null;
 		}
 		if (readPath !== targetPath) continue;
 
-		// This is the latest successful read of this file. If it cannot be
-		// verified, do not silently fall back to older, potentially stale intent.
+		// Never fall back to older intent when the newest same-file read is
+		// missing, failed, malformed, or stale.
+		const result = results.get(call.id);
+		if (!result || result.isError || result.toolName !== call.name) return null;
+		if (call.name === "read_symbol") {
+			if (result.content.length !== 1 || result.content[0].type !== "text") return null;
+			try {
+				// Regenerate from current source and original arguments, not untrusted
+				// details. Snapshot, selector, envelope, and visible bytes must agree.
+				const expected = await buildSymbolRead(call.arguments as ReadSymbolInput, normalizedContent);
+				if (result.content[0].text !== expected.content[0].text) return null;
+				return expected.details.visible ?? null;
+			} catch { return null; }
+		}
 		return evidenceFromBuiltinRead(normalizedContent, call, result.content);
 	}
 	return null;
 }
 
-function evidenceFromBuiltinRead(
+export function evidenceFromBuiltinRead(
 	content: string,
-	call: ReadCall,
+	call: Pick<ReadCall, "path" | "offset" | "limit">,
 	blocks: Array<{ type: string; text?: string }>,
 ): ReadEvidence | null {
 	if (blocks.length !== 1 || blocks[0].type !== "text" || typeof blocks[0].text !== "string") return null;
@@ -131,7 +170,9 @@ function evidenceFromBuiltinRead(
 	const startLine = startIndex + 1;
 	const endLine = startLine + visibleLines - 1;
 	const startOffset = offsetAtLine(content, startLine);
-	const endOffset = offsetAtLine(content, endLine + 1);
+	// A line-limited/truncated result omits the separator after its final
+	// displayed line. Do not authorize an edit anchor through unseen bytes.
+	const endOffset = startOffset + truncation.content.length;
 	return { startOffset, endOffset, startLine, endLine };
 }