@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/edit/hashline/diff.ts

@@ -12,6 +12,7 @@
 import {
 	type ApplyResult,
 	applyEdits,
+	type Cursor,
 	computeFileHash,
 	type Edit,
 	Patch as HashlinePatch,
@@ -56,6 +57,39 @@ async function readSectionText(absolutePath: string, sectionPath: string): Promi
 	}
 }
 
+/**
+ * Streaming previews recompute on every streamed chunk; re-reading the target
+ * file from disk each tick dominates the cost on large files. Cache the raw
+ * section text keyed by mtime+size so any on-disk change invalidates
+ * naturally. Used by the streaming path only — the args-complete pass always
+ * reads fresh.
+ */
+const streamingTextCache = new Map<string, { mtimeMs: number; size: number; rawContent: string }>();
+const STREAMING_TEXT_CACHE_MAX = 8;
+
+async function readSectionTextCached(absolutePath: string, sectionPath: string): Promise<string> {
+	let stamp: { mtimeMs: number; size: number } | undefined;
+	try {
+		const stat = await Bun.file(absolutePath).stat();
+		stamp = { mtimeMs: stat.mtimeMs, size: stat.size };
+	} catch {
+		stamp = undefined;
+	}
+	if (stamp) {
+		const cached = streamingTextCache.get(absolutePath);
+		if (cached && cached.mtimeMs === stamp.mtimeMs && cached.size === stamp.size) return cached.rawContent;
+	}
+	const rawContent = await readSectionText(absolutePath, sectionPath);
+	if (stamp) {
+		if (streamingTextCache.size >= STREAMING_TEXT_CACHE_MAX && !streamingTextCache.has(absolutePath)) {
+			const oldest = streamingTextCache.keys().next().value;
+			if (oldest !== undefined) streamingTextCache.delete(oldest);
+		}
+		streamingTextCache.set(absolutePath, { mtimeMs: stamp.mtimeMs, size: stamp.size, rawContent });
+	}
+	return rawContent;
+}
+
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
@@ -131,6 +165,86 @@ function applyPreviewEdits(args: {
 	throw createMismatchError(section, absolutePath, normalized, snapshots, expected);
 }
 
+/**
+ * Map an insert cursor to the 1-indexed line where its payload lands, used to
+ * number the `+` rows of a streaming preview. Deliberately approximate: it
+ * ignores line shifts introduced by sibling ops, because the args-complete
+ * pass renumbers everything through the real unified diff.
+ */
+function insertCursorLine(cursor: Cursor, fileLineCount: number): number {
+	switch (cursor.kind) {
+		case "bof":
+			return 1;
+		case "eof":
+			return fileLineCount + 1;
+		case "before_anchor":
+			return cursor.anchor.line;
+		case "after_anchor":
+			return cursor.anchor.line + 1;
+	}
+}
+
+/**
+ * Build a streaming diff preview by emitting, per op in patch order, the
+ * removed file lines followed by the op's `+` payload rows — never a whole-file
+ * Myers re-diff. {@link generateDiffString} re-aligns the in-flight payload
+ * against the removed block on every streamed chunk (it greedily matches shared
+ * `}`/blank/`return` rows), so additions jump between hunks and the tail window
+ * the renderer pins stutters tick to tick. Natural order keeps the removed
+ * block fixed and grows the payload monotonically at the bottom so the streamed
+ * cursor stays put. Mirrors the apply_patch streaming strategy; the
+ * args-complete pass still produces the real unified diff.
+ */
+function buildStreamingSectionDiff(
+	section: PatchSection,
+	normalized: string,
+): { diff: string; firstChangedLine: number | undefined } | { error: string } {
+	const { edits } = parsePatchStreaming(section.diff);
+	const resolved = resolveBlockEdits(edits, normalized, section.path, nativeBlockResolver, { onUnresolved: "drop" });
+	if (resolved.length === 0) return { error: `No changes would be made to ${section.path}.` };
+
+	const fileLines = normalized.split("\n");
+	const rows: string[] = [];
+	let firstChangedLine: number | undefined;
+
+	// Every edit emitted from one op header carries that header's patch line
+	// number and the edits sit contiguously (a replace lays down its replacement
+	// inserts then its range deletes; block ops expand to the same shape). Group
+	// on that boundary so each op stays intact and ordered.
+	for (let i = 0; i < resolved.length; ) {
+		const opLine = resolved[i].lineNum;
+		const deletes: number[] = [];
+		const inserts: string[] = [];
+		let insertBase: number | undefined;
+		while (i < resolved.length && resolved[i].lineNum === opLine) {
+			const edit = resolved[i];
+			if (edit.kind === "delete") deletes.push(edit.anchor.line);
+			else if (edit.kind === "insert") {
+				insertBase ??= insertCursorLine(edit.cursor, fileLines.length);
+				inserts.push(edit.text);
+			}
+			i++;
+		}
+		// Removed lines first (a fixed block), payload second (grows at the
+		// bottom = the streamed cursor).
+		deletes.sort((a, b) => a - b);
+		for (const line of deletes) {
+			firstChangedLine ??= line;
+			const content = line >= 1 && line <= fileLines.length ? fileLines[line - 1] : "";
+			rows.push(`-${line}|${content}`);
+		}
+		let newLine = insertBase ?? deletes[0] ?? 1;
+		for (const text of inserts) {
+			firstChangedLine ??= newLine;
+			rows.push(`+${newLine}|${text}`);
+			newLine++;
+		}
+	}
+
+	if (rows.length === 0) return { error: `No changes would be made to ${section.path}.` };
+	return { diff: rows.join("\n"), firstChangedLine };
+}
+
 export async function computeHashlineSectionDiff(
 	section: PatchSection,
 	cwd: string,
@@ -139,12 +253,19 @@ export async function computeHashlineSectionDiff(
 ): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
 	try {
 		const absolutePath = resolveToCwd(section.path, cwd);
-		const rawContent = await readSectionText(absolutePath, section.path);
+		const rawContent = options.streaming
+			? await readSectionTextCached(absolutePath, section.path)
+			: await readSectionText(absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
+		// Streaming favors a stable, monotonic preview over an exact unified
+		// diff: feed the in-flight ops through the natural-order builder so the
+		// streamed cursor stays pinned to the bottom. The args-complete pass
+		// (`streaming` unset) falls through to the real Myers diff below.
+		if (options.streaming) return buildStreamingSectionDiff(section, normalized);
 		const result = applyPreviewEdits({ section, absolutePath, normalized, snapshots, options });
 		if (normalized === result.text) return { error: `No changes would be made to ${section.path}.` };
-		return generateDiffString(normalized, result.text);
+		return generateDiffString(normalized, result.text, undefined, { path: section.path });
 	} catch (err) {
 		return { error: err instanceof Error ? err.message : String(err) };
 	}

package/src/edit/hashline/execute.ts

@@ -13,6 +13,7 @@
 
 import type { AgentToolResult } from "@prometheus-ai/agent-core";
 import {
+	type BlockResolution,
 	buildCompactDiffPreview,
 	MismatchError as HashlineMismatchError,
 	Patch,
@@ -23,11 +24,13 @@ import {
 import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import { outputMeta } from "../../tools/output-meta";
+import { ToolError } from "../../tools/tool-errors";
 import { generateDiffString } from "../diff";
 import { getFileSnapshotStore } from "../file-snapshot-store";
 import type { EditToolDetails, EditToolPerFileResult, LspBatchRequest } from "../renderer";
 import { nativeBlockResolver } from "./block-resolver";
 import { HashlineFilesystem } from "./filesystem";
+import { hashPatchInput, NOOP_HARD_LIMIT, recordNoopEdit, resetNoopEdit } from "./noop-loop-guard";
 import { type HashlineParams, hashlineEditParamsSchema } from "./params";
 
 export interface ExecuteHashlineSingleOptions {
@@ -54,6 +57,24 @@ function noChangeDiagnostic(path: string): string {
 	);
 }
 
+/**
+ * Escalated diagnostic surfaced once the same payload has no-op'd
+ * {@link NOOP_HARD_LIMIT} times in a row on the same canonical path. Thrown as
+ * a {@link ToolError} so the agent loop sees a tool *failure* — empirically
+ * far more effective at breaking a no-op edit loop than the soft hint alone
+ * (issue #2081 saw 182 byte-identical no-op results in 205 calls before the
+ * user aborted).
+ */
+function noChangeLoopDiagnostic(path: string, count: number): string {
+	return (
+		`STOP. Edits to ${path} have been a byte-identical no-op ${count} times in a row — ` +
+		`the patch body matches the file at the targeted lines and the soft hint did not break the cycle. ` +
+		`Cease re-issuing this payload. Either the intended change is already on disk (move on), ` +
+		`or your anchor is wrong (re-read the file with \`read\` to observe the current line numbers and ` +
+		`tag, then author a different edit). This exact payload will keep being rejected until it changes.`
+	);
+}
+
 function assertUniqueCanonicalPaths(prepared: readonly PreparedSection[]): void {
 	const seen = new Map<string, string>();
 	for (const entry of prepared) {
@@ -77,6 +98,20 @@ interface RenderedSection {
 	perFileResult: EditToolPerFileResult;
 }
 
+function formatBlockResolution(resolution: BlockResolution): string {
+	const op =
+		resolution.op === "delete"
+			? "delete block"
+			: resolution.op === "insert_after"
+				? "insert after block"
+				: "replace block";
+	const lines = resolution.end - resolution.start + 1;
+	const span =
+		resolution.start === resolution.end ? `line ${resolution.start}` : `lines ${resolution.start}-${resolution.end}`;
+	const suffix = resolution.op === "insert_after" ? `; body lands after line ${resolution.end}` : "";
+	return `${op} ${resolution.anchorLine} → resolved ${span} (${lines} line${lines === 1 ? "" : "s"})${suffix}`;
+}
+
 function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsResult | undefined): RenderedSection {
 	if (result.op === "noop") {
 		const toolResult: AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema> = {
@@ -89,7 +124,7 @@ function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsR
 		};
 	}
 
-	const diff = generateDiffString(result.before, result.after);
+	const diff = generateDiffString(result.before, result.after, undefined, { path: result.path });
 	const preview = buildCompactDiffPreview(diff.diff);
 	const meta = outputMeta()
 		.diagnostics(diagnostics?.summary ?? "", diagnostics?.messages ?? [])
@@ -97,10 +132,14 @@ function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsR
 
 	const warningsBlock = result.warnings.length > 0 ? `\n\nWarnings:\n${result.warnings.join("\n")}` : "";
 	const previewBlock = preview.preview ? `\n${preview.preview}` : "";
+	const blockBlock =
+		result.blockResolutions && result.blockResolutions.length > 0
+			? `\n${result.blockResolutions.map(formatBlockResolution).join("\n")}`
+			: "";
 	const firstChangedLine = result.firstChangedLine ?? diff.firstChangedLine;
 	return {
 		toolResult: {
-			content: [{ type: "text", text: `${result.header}${previewBlock}${warningsBlock}` }],
+			content: [{ type: "text", text: `${result.header}${blockBlock}${previewBlock}${warningsBlock}` }],
 			details: {
 				diff: diff.diff,
 				firstChangedLine,
@@ -138,13 +177,19 @@ export async function executeHashlineSingle(
 	const patcher = new Patcher({ fs, snapshots, blockResolver: nativeBlockResolver });
 
 	// Single-section fast path: prepare, commit, render.
+	const inputHash = hashPatchInput(options.input);
 	if (patch.sections.length === 1) {
 		fs.setBatchRequest(narrowBatchRequest(options.batchRequest, true));
 		const prepared = await patcher.prepare(patch.sections[0]);
 		const sectionResult = await patcher.commit(prepared);
 		if (sectionResult.op === "noop") {
+			const { count, escalate } = recordNoopEdit(options.session, sectionResult.canonicalPath, inputHash);
+			if (escalate) {
+				throw new ToolError(noChangeLoopDiagnostic(sectionResult.path, count));
+			}
 			return renderSection(sectionResult, undefined).toolResult;
 		}
+		resetNoopEdit(options.session, sectionResult.canonicalPath);
 		return renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path)).toolResult;
 	}
 
@@ -154,7 +199,12 @@ export async function executeHashlineSingle(
 	for (const section of patch.sections) prepared.push(await patcher.prepare(section));
 	assertUniqueCanonicalPaths(prepared);
 	for (const entry of prepared) {
-		if (entry.isNoop) throw new Error(noChangeDiagnostic(entry.section.path));
+		if (entry.isNoop) {
+			const { count, escalate } = recordNoopEdit(options.session, entry.canonicalPath, inputHash);
+			throw escalate
+				? new ToolError(noChangeLoopDiagnostic(entry.section.path, count))
+				: new ToolError(noChangeDiagnostic(entry.section.path));
+		}
 	}
 	// Then commit each one, narrowing the LSP batch flush flag to the final
 	// section only. A no-op apply mid-batch is treated as a hard failure —
@@ -164,7 +214,13 @@ export async function executeHashlineSingle(
 		const isLast = i === prepared.length - 1;
 		fs.setBatchRequest(narrowBatchRequest(options.batchRequest, isLast));
 		const sectionResult = await patcher.commit(prepared[i]);
-		if (sectionResult.op === "noop") throw new Error(noChangeDiagnostic(sectionResult.path));
+		if (sectionResult.op === "noop") {
+			const { count, escalate } = recordNoopEdit(options.session, sectionResult.canonicalPath, inputHash);
+			throw escalate
+				? new ToolError(noChangeLoopDiagnostic(sectionResult.path, count))
+				: new ToolError(noChangeDiagnostic(sectionResult.path));
+		}
+		resetNoopEdit(options.session, sectionResult.canonicalPath);
 		rendered.push(renderSection(sectionResult, fs.consumeDiagnostics(sectionResult.path)));
 	}
 

package/src/edit/hashline/filesystem.ts

@@ -23,6 +23,7 @@ import type { ToolSession } from "../../tools";
 import { assertEditableFileContent } from "../../tools/auto-generated-guard";
 import { invalidateFsScanAfterWrite } from "../../tools/fs-cache-invalidation";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
+import { canonicalSnapshotKey } from "../file-snapshot-store";
 import { readEditFileText, serializeEditFileText } from "../read-file";
 import type { LspBatchRequest } from "../renderer";
 
@@ -81,7 +82,7 @@ export class HashlineFilesystem extends Filesystem {
 	}
 
 	canonicalPath(relativePath: string): string {
-		return this.resolveAbsolute(relativePath);
+		return canonicalSnapshotKey(this.resolveAbsolute(relativePath));
 	}
 
 	async readText(relativePath: string): Promise<string> {

package/src/edit/hashline/noop-loop-guard.ts

@@ -0,0 +1,99 @@
+/**
+ * Per-session guard against subagents looping on byte-identical no-op edits.
+ *
+ * A hashline patch can apply cleanly yet produce no change when the body rows
+ * are already byte-identical to the targeted lines. {@link executeHashlineSingle}
+ * surfaces a soft hint ("re-read the file before issuing another edit"), but in
+ * the wild some models ignore the hint and keep re-issuing the same bytes
+ * (issue #2081 captured 182 such repeats in 205 calls before the user aborted).
+ *
+ * This module tracks consecutive byte-identical no-op edits per canonical file
+ * path within a single session. Once the same payload no-ops {@link NOOP_HARD_LIMIT}
+ * times in a row the caller is expected to escalate from a soft text result to
+ * a thrown {@link ToolError} so the agent loop sees a tool *failure* — empirically
+ * far more effective at breaking the cycle than the soft hint alone.
+ *
+ * A successful (non-noop) commit for a path resets that path's counter; a
+ * different payload on the same path also resets it because the body hash
+ * changed, which is a sign of model progress and deserves another soft hint.
+ */
+
+interface NoopLoopEntry {
+	/** Hash of the most recent input that no-op'd on this canonical path. */
+	hash: string;
+	/** Consecutive no-op count for the same `hash` on this path. */
+	count: number;
+}
+
+/** Cross-session-safe state slot held on the `ToolSession`. */
+export interface NoopLoopGuard {
+	entries: Map<string, NoopLoopEntry>;
+}
+
+/**
+ * After this many consecutive byte-identical no-op edits on the same path,
+ * {@link recordNoopEdit} returns `escalate: true`. Picked deliberately small
+ * so the soft hint still fires once or twice before we escalate — the model
+ * deserves a chance to recover, but a tight bound is what actually breaks
+ * loops in practice.
+ */
+export const NOOP_HARD_LIMIT = 3;
+
+interface NoopLoopGuardOwner {
+	noopLoopGuard?: NoopLoopGuard;
+}
+
+/** Lazily create the per-session guard, mirroring `getFileSnapshotStore`. */
+export function getNoopLoopGuard(session: NoopLoopGuardOwner): NoopLoopGuard {
+	if (!session.noopLoopGuard) session.noopLoopGuard = { entries: new Map() };
+	return session.noopLoopGuard;
+}
+
+/** Result of recording one no-op against the guard. */
+export interface NoopRecordResult {
+	/** Consecutive identical no-op count, including the current one. */
+	count: number;
+	/** True once `count >= NOOP_HARD_LIMIT` and the caller MUST escalate. */
+	escalate: boolean;
+}
+
+/**
+ * Record a no-op edit for `canonicalPath` keyed by `inputHash` (a stable hash
+ * of the raw patch input bytes). Returns the running consecutive-no-op count
+ * and whether the caller should escalate from a soft text result to a thrown
+ * error.
+ *
+ * `inputHash` is intentionally derived from the raw model-authored bytes
+ * rather than from file content: when the model emits a different payload
+ * (even whitespace-only) that's progress and earns a fresh soft hint, but
+ * re-issuing the same bytes after being warned is what we want to break.
+ */
+export function recordNoopEdit(
+	session: NoopLoopGuardOwner,
+	canonicalPath: string,
+	inputHash: string,
+): NoopRecordResult {
+	const guard = getNoopLoopGuard(session);
+	const prev = guard.entries.get(canonicalPath);
+	const count = prev && prev.hash === inputHash ? prev.count + 1 : 1;
+	guard.entries.set(canonicalPath, { hash: inputHash, count });
+	return { count, escalate: count >= NOOP_HARD_LIMIT };
+}
+
+/**
+ * Clear the no-op counter for `canonicalPath`. Call after a non-noop commit
+ * for the same path so a future no-op starts fresh from the soft hint.
+ */
+export function resetNoopEdit(session: NoopLoopGuardOwner, canonicalPath: string): void {
+	const guard = session.noopLoopGuard;
+	if (!guard) return;
+	guard.entries.delete(canonicalPath);
+}
+
+/**
+ * Stable hash of the raw patch input. Bun's `Bun.hash` is xxHash64 — fast,
+ * non-cryptographic, more than adequate for "is this the same payload?".
+ */
+export function hashPatchInput(input: string): string {
+	return Bun.hash(input).toString(16);
+}

package/src/edit/hashline/params.ts

@@ -4,7 +4,7 @@
  * keys without rejection; only `input` is required. `_input` is accepted as a
  * provider-emitted alias for `input`.
  */
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 
 export const hashlineEditParamsSchema = z.preprocess(raw => {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;

package/src/edit/index.ts

@@ -14,7 +14,7 @@ import { getDiagnosticsLedger } from "../lsp/diagnostics-ledger";
 import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
-import type { ToolSession } from "../tools";
+import type { DeferredDiagnosticsEntry, ToolSession } from "../tools";
 import { truncateForPrompt } from "../tools/approval";
 import { isInternalUrlPath } from "../tools/path-utils";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
@@ -238,8 +238,23 @@ async function executeSinglePathEntries(
 			if (text) contentTexts.push(text);
 		} catch (err) {
 			const errorText = err instanceof Error ? err.message : String(err);
-			contentTexts.push(`Error editing ${path}: ${errorText}`);
+			contentTexts.push(`Error editing ${path} (entry ${i + 1} of ${runs.length}): ${errorText}`);
+			if (i > 0) {
+				contentTexts.push(i === 1 ? `Entry 1 was already applied.` : `Entries 1-${i} were already applied.`);
+			}
+			if (i + 1 < runs.length) {
+				contentTexts.push(
+					(i + 2 === runs.length
+						? `Entry ${runs.length} was NOT applied`
+						: `Entries ${i + 2}-${runs.length} were NOT applied`) +
+						`; re-read the file and re-issue only the failed and unapplied entries.`,
+				);
+			}
 			errorCount++;
+			// Stop at the first failure: later entries were authored against
+			// line numbers/content that assumed this entry succeeded, and
+			// applying them after a failure compounds the damage.
+			break;
 		}
 
 		if (!isLast && onUpdate) {
@@ -297,7 +312,6 @@ export class EditTool implements AgentTool<TInput> {
 	readonly name = "edit";
 	readonly label = "Edit";
 	readonly loadMode = "essential";
-	readonly nonAbortable = true;
 	readonly concurrency = "exclusive";
 	readonly strict = true;
 
@@ -307,6 +321,10 @@ export class EditTool implements AgentTool<TInput> {
 	readonly #editMode?: EditMode;
 	readonly #dedupDiagnostics: boolean;
 	readonly #pendingDeferredFetches = new Map<string, AbortController>();
+	/** Fallback per-path mutation counter used only when the session does not expose
+	 *  a shared one. Prefer `session.bumpFileMutationVersion` so write (and any other
+	 *  tool) mutating the same file also invalidates pending late-diagnostics. */
+	readonly #editVersionByPath = new Map<string, number>();
 
 	constructor(private readonly session: ToolSession) {
 		const {
@@ -503,10 +521,11 @@ export class EditTool implements AgentTool<TInput> {
 		}
 
 		const deferredController = new AbortController();
+		const editVersion = this.#bumpFileVersion(path);
 		return {
 			onDeferredDiagnostics: (lateDiagnostics: FileDiagnosticsResult) => {
 				this.#pendingDeferredFetches.delete(path);
-				this.#injectLateDiagnostics(path, lateDiagnostics);
+				this.#injectLateDiagnostics(path, lateDiagnostics, editVersion);
 			},
 			signal: deferredController.signal,
 			finalize: (diagnostics: FileDiagnosticsResult | undefined) => {
@@ -519,24 +538,34 @@ export class EditTool implements AgentTool<TInput> {
 		};
 	}
 
-	#injectLateDiagnostics(path: string, diagnostics: FileDiagnosticsResult): void {
+	#injectLateDiagnostics(path: string, diagnostics: FileDiagnosticsResult, editVersion: number): void {
 		const effective = this.#dedupDiagnostics
 			? getDiagnosticsLedger(this.session).reduce(path, diagnostics)
 			: diagnostics;
 		if (this.#dedupDiagnostics && effective.messages.length === 0) return;
 
-		const summary = effective.summary ?? "";
-		const lines = effective.messages ?? [];
-		const body = [`Late LSP diagnostics for ${path} (arrived after the edit tool returned):`, summary, ...lines]
-			.filter(Boolean)
-			.join("\n");
-
-		this.session.queueDeferredMessage?.({
-			role: "custom",
-			customType: "lsp-late-diagnostic",
-			content: body,
-			display: false,
-			timestamp: Date.now(),
-		});
+		const entry: DeferredDiagnosticsEntry = {
+			path,
+			summary: effective.summary ?? "",
+			messages: effective.messages ?? [],
+			errored: effective.errored,
+			// Drop at flush time if a later edit to the same file superseded this fetch.
+			isStale: () => this.#fileVersion(path) !== editVersion,
+		};
+		this.session.queueDeferredDiagnostics?.(entry);
+	}
+
+	/** Bump the file's mutation counter (session-global when available). */
+	#bumpFileVersion(path: string): number {
+		if (this.session.bumpFileMutationVersion) return this.session.bumpFileMutationVersion(path);
+		const next = (this.#editVersionByPath.get(path) ?? 0) + 1;
+		this.#editVersionByPath.set(path, next);
+		return next;
+	}
+
+	/** Read the file's current mutation counter (session-global when available). */
+	#fileVersion(path: string): number {
+		if (this.session.getFileMutationVersion) return this.session.getFileMutationVersion(path);
+		return this.#editVersionByPath.get(path) ?? 0;
 	}
 }

package/src/edit/modes/apply-patch.ts

@@ -8,7 +8,7 @@
  * the `patch` mode.
  */
 
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { parseApplyPatch, parseApplyPatchStreaming } from "../apply-patch/parser";
 import { ApplyPatchError } from "../diff";
 import type { PatchEditEntry } from "./patch";

package/src/edit/modes/patch.ts

@@ -9,7 +9,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@prometheus-ai/agent-core";
 import { isEnoent } from "@prometheus-ai/utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import {
 	type FileDiagnosticsResult,
 	flushLspWritethroughBatch,
@@ -40,6 +40,7 @@ import {
 	countLeadingWhitespace,
 	detectLineEnding,
 	getLeadingWhitespace,
+	normalizeForFuzzy,
 	normalizeToLF,
 	restoreLineEndings,
 	stripBom,
@@ -1007,6 +1008,41 @@ async function readExistingPatchFile(fileSystem: FileSystem, absolutePath: strin
 	}
 }
 
+/**
+ * A prefix/substring strategy matched pattern lines that cover only part of
+ * the corresponding file lines; replacing whole lines would silently drop the
+ * uncovered text the model never saw. Allow the replacement only when every
+ * discarded piece (normalized) survives somewhere in the hunk's new lines.
+ */
+function assertPartialMatchPreservesDiscardedText(
+	path: string,
+	pattern: string[],
+	matchedLines: string[],
+	newLines: string[],
+	matchStartIndex: number,
+): void {
+	let newLinesNorm: string | undefined;
+	for (let j = 0; j < pattern.length; j++) {
+		const lineNorm = normalizeForFuzzy(matchedLines[j]);
+		const patternNorm = normalizeForFuzzy(pattern[j]);
+		if (lineNorm === patternNorm) continue;
+		const at = lineNorm.indexOf(patternNorm);
+		if (at === -1) continue;
+		const discardedParts = [lineNorm.slice(0, at).trim(), lineNorm.slice(at + patternNorm.length).trim()];
+		for (const part of discardedParts) {
+			if (part.length === 0) continue;
+			newLinesNorm ??= newLines.map(normalizeForFuzzy).join("\n");
+			if (!newLinesNorm.includes(part)) {
+				throw new ApplyPatchError(
+					`Refusing partial-line match in ${path} at line ${matchStartIndex + j + 1}: ` +
+						`the file line also contains ${JSON.stringify(part)}, which the replacement would silently drop. ` +
+						`Provide the complete line in the hunk.`,
+				);
+			}
+		}
+	}
+}
+
 /**
  * Compute replacements needed to transform originalLines using the diff hunks.
  */
@@ -1253,6 +1289,18 @@ function computeReplacements(
 		if (searchResult.strategy === "fuzzy-dominant") {
 			const similarity = Math.round(searchResult.confidence * 100);
 			warnings.push(`Dominant fuzzy match selected in ${path} near line ${found + 1} (${similarity}% similar).`);
+		} else if (
+			searchResult.strategy === "comment-prefix" ||
+			searchResult.strategy === "prefix" ||
+			searchResult.strategy === "substring" ||
+			searchResult.strategy === "fuzzy" ||
+			searchResult.strategy === "character"
+		) {
+			const similarity = Math.round(searchResult.confidence * 100);
+			warnings.push(
+				`Inexact match in ${path} near line ${found + 1}: matched via ${searchResult.strategy} strategy ` +
+					`(${similarity}% similar). Re-read the file if the result is not what you intended.`,
+			);
 		}
 
 		// Reject if match is ambiguous (prefix/substring matching found multiple matches)
@@ -1305,6 +1353,10 @@ function computeReplacements(
 			continue;
 		}
 
+		if (searchResult.strategy === "prefix" || searchResult.strategy === "substring") {
+			assertPartialMatchPreservesDiscardedText(path, pattern, actualMatchedLines, newSlice, found);
+		}
+
 		const adjustedNewLines = adjustLinesIndentation(pattern, actualMatchedLines, newSlice);
 		replacements.push({ startIndex: found, oldLen: pattern.length, newLines: adjustedNewLines });
 		lineIndex = found + pattern.length;
@@ -1571,7 +1623,9 @@ export async function computePatchDiff(
 		if (!normalizedOld && !normalizedNew) {
 			return { diff: "", firstChangedLine: undefined };
 		}
-		return generateUnifiedDiffString(normalizedOld, normalizedNew);
+		return generateUnifiedDiffString(normalizedOld, normalizedNew, undefined, {
+			path: result.change.newPath ?? result.change.path,
+		});
 	} catch (err) {
 		return { error: err instanceof Error ? err.message : String(err) };
 	}
@@ -1785,7 +1839,9 @@ export async function executePatchSingle(
 	if (result.change.type === "update" && result.change.oldContent && result.change.newContent) {
 		const normalizedOld = normalizeToLF(stripBom(result.change.oldContent).text);
 		const normalizedNew = normalizeToLF(stripBom(result.change.newContent).text);
-		diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew);
+		diffResult = generateUnifiedDiffString(normalizedOld, normalizedNew, undefined, {
+			path: result.change.newPath ?? result.change.path,
+		});
 	}
 
 	let resultText: string;