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

package/src/eval/js/context-manager.ts

@@ -52,7 +52,7 @@ interface JsSession {
 }
 
 const sessions = new Map<string, JsSession>();
-const READY_TIMEOUT_MS = 5_000;
+const READY_TIMEOUT_MS_DEFAULT = 5_000;
 
 export async function executeInVmContext(options: {
 	sessionKey: string;
@@ -68,10 +68,11 @@ export async function executeInVmContext(options: {
 	if (options.reset) {
 		await resetVmContext(options.sessionKey);
 	}
-	const session = await acquireSession(options.sessionKey, {
-		cwd: options.cwd,
-		sessionId: options.sessionId,
-	});
+	const session = await acquireSession(
+		options.sessionKey,
+		{ cwd: options.cwd, sessionId: options.sessionId },
+		options.timeoutMs,
+	);
 	return await runQueued(session, () => runOnce(session, options));
 }
 
@@ -158,7 +159,7 @@ async function runOnce(
 	}
 }
 
-async function acquireSession(sessionKey: string, snapshot: SessionSnapshot): Promise<JsSession> {
+async function acquireSession(sessionKey: string, snapshot: SessionSnapshot, timeoutMs?: number): Promise<JsSession> {
 	const existing = sessions.get(sessionKey);
 	if (existing && existing.state === "alive") return existing;
 
@@ -186,7 +187,10 @@ async function acquireSession(sessionKey: string, snapshot: SessionSnapshot): Pr
 		handleSessionMessage(session, msg);
 	});
 	try {
-		await raceWithTimeout(readyPromise, READY_TIMEOUT_MS, "Timed out initializing JS eval worker");
+		// Cold-start can exceed 5s on slow hosts. Let the caller's per-cell timeout dominate so
+		// users can grant more headroom when they raise `timeout` on a cell.
+		const readyTimeoutMs = Math.max(READY_TIMEOUT_MS_DEFAULT, timeoutMs ?? 0);
+		await raceWithTimeout(readyPromise, readyTimeoutMs, "Timed out initializing JS eval worker");
 	} catch (error) {
 		unsubscribe();
 		await worker.terminate().catch(() => undefined);

package/src/eval/js/shared/rewrite-imports.ts

@@ -303,15 +303,27 @@ function returnFinalExpression(code: string): { source: string; returned: boolea
 	let lastIndex = body.length - 1;
 	while (lastIndex >= 0 && body[lastIndex]?.type === "EmptyStatement") lastIndex--;
 	const last = lastIndex >= 0 ? body[lastIndex] : undefined;
-	if (last?.type !== "ExpressionStatement") return { source: code, returned: false };
-
-	const expression = last as BabelExpressionStatement;
-	const prefix = code.slice(0, expression.start);
-	const statement = code.slice(expression.start, expression.end);
-	const suffix = code.slice(expression.end);
-	const semicolonMatch = statement.match(/;\s*$/);
-	const trimmedStatement = semicolonMatch ? statement.slice(0, semicolonMatch.index) : statement;
-	return { source: `${prefix}__omp_set_final_expr__((${trimmedStatement}));${suffix}`, returned: true };
+	if (last?.type === "ExpressionStatement") {
+		const expression = last as BabelExpressionStatement;
+		const prefix = code.slice(0, expression.start);
+		const statement = code.slice(expression.start, expression.end);
+		const suffix = code.slice(expression.end);
+		const semicolonMatch = statement.match(/;\s*$/);
+		const trimmedStatement = semicolonMatch ? statement.slice(0, semicolonMatch.index) : statement;
+		return { source: `${prefix}__omp_set_final_expr__((${trimmedStatement}));${suffix}`, returned: true };
+	}
+	if (last?.type === "ReturnStatement") {
+		// Top-level `return value;` is otherwise swallowed: it forces the cell into an async IIFE
+		// wrapper that discards the returned value. Rewrite into `__omp_set_final_expr__((expr))`
+		// so the runtime can surface the value to the caller just like a trailing expression.
+		const ret = last as unknown as { start: number; end: number; argument?: { start: number; end: number } | null };
+		if (!ret.argument) return { source: code, returned: false };
+		const prefix = code.slice(0, ret.start);
+		const suffix = code.slice(ret.end);
+		const expr = code.slice(ret.argument.start, ret.argument.end);
+		return { source: `${prefix}__omp_set_final_expr__((${expr}));${suffix}`, returned: true };
+	}
+	return { source: code, returned: false };
 }
 
 function isExecutionBoundary(type: string): boolean {

package/src/eval/js/shared/runtime.ts

@@ -165,7 +165,8 @@ export class JsRuntime {
 				const finalValue = this.#finalExpressionValue;
 				this.#finalExpressionSet = false;
 				this.#finalExpressionValue = undefined;
-				return await awaitMaybePromise(finalValue);
+				const resolved = await awaitMaybePromise(finalValue);
+				return resolved;
 			}
 			return awaited;
 		}

package/src/hashline/hash.ts

@@ -136,21 +136,24 @@ export const HL_BODY_SEP = "|";
 /** Regex-escaped form of {@link HL_BODY_SEP}, safe for embedding inside a regex. */
 export const HL_BODY_SEP_RE_RAW = regexEscape(HL_BODY_SEP);
 
-const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
-
 /**
  * Compute a 2-character hash of a single line via xxHash32 mod 647 over
- * {@link HL_BIGRAMS}. Lines with no letter or digit mix the line number
- * into the seed so adjacent identical punctuation-only lines (e.g. brace-only
- * lines) get distinct hashes; lines with significant content stay
- * line-number-independent so a line is identifiable across small shifts.
+ * {@link HL_BIGRAMS}. The hash depends only on the line's content (after
+ * stripping CR and trailing whitespace); the `idx` parameter is accepted
+ * for call-site symmetry with line numbers but is intentionally unused so
+ * that anchors remain stable across line shifts caused by sibling edits.
  *
  * The line input should not include a trailing newline.
  */
 export function computeLineHash(idx: number, line: string): string {
+	void idx;
 	line = line.replace(/\r/g, "").trimEnd();
-	const seed = RE_SIGNIFICANT.test(line) ? 0 : idx;
-	return HL_BIGRAMS[Bun.hash.xxHash32(line, seed) % HL_BIGRAMS_COUNT];
+	// Seed is fixed so the hash depends only on line content. Earlier we mixed
+	// in `idx` for blank/punctuation-only lines, but that meant any line shift
+	// (e.g. from a sibling edit in the same batch) invalidated anchors whose
+	// content had not changed. Identical blank lines are intentionally allowed
+	// to collide — the edit op's line number disambiguates them.
+	return HL_BIGRAMS[Bun.hash.xxHash32(line, 0) % HL_BIGRAMS_COUNT];
 }
 
 /**

package/src/hashline/parser.ts

@@ -74,19 +74,29 @@ export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
 	if (cursor.kind === "after_anchor") return { kind: "after_anchor", anchor: { ...cursor.anchor } };
 	return cursor;
 }
+/** Returns true when every non-empty payload line starts with `${sep} ` (sep + one space). */
+function hasUniformSeparatorPadding(payload: string[]): boolean {
+	let any = false;
+	for (const text of payload) {
+		if (text.length === 0) continue;
+		if (!text.startsWith(" ")) return false;
+		any = true;
+	}
+	return any;
+}
 
 function collectPayload(
 	lines: string[],
 	startIndex: number,
 	opLineNum: number,
 	requirePayload: boolean,
-): { payload: string[]; nextIndex: number } {
+): { payload: string[]; nextIndex: number; paddingWarning?: string } {
 	const payload: string[] = [];
 	let index = startIndex;
 	while (index < lines.length) {
 		const line = lines[index];
 		if (line.startsWith(HL_EDIT_SEP)) {
-			payload.push(line.slice(1).trimEnd());
+			payload.push(line.slice(HL_EDIT_SEP.length).trimEnd());
 			index++;
 			continue;
 		}
@@ -115,7 +125,11 @@ function collectPayload(
 	if (payload.length === 0 && requirePayload) {
 		throw new Error(`line ${opLineNum}: + and < operations require at least one ${HL_EDIT_SEP}TEXT payload line.`);
 	}
-	return { payload, nextIndex: index };
+	const paddingWarning = hasUniformSeparatorPadding(payload)
+		? `line ${opLineNum}: all payload lines start with "${HL_EDIT_SEP} " (separator + space). ` +
+			`The space becomes file content. Remove it unless the target file requires leading spaces.`
+		: undefined;
+	return { payload, nextIndex: index, paddingWarning };
 }
 
 export function parseHashline(diff: string): HashlineEdit[] {
@@ -158,7 +172,8 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const insertBeforeMatch = INSERT_BEFORE_OP_RE.exec(line);
 		if (insertBeforeMatch) {
 			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, true);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true);
+			if (paddingWarning) warnings.push(paddingWarning);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
 			continue;
@@ -167,7 +182,8 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const insertAfterMatch = INSERT_AFTER_OP_RE.exec(line);
 		if (insertAfterMatch) {
 			const cursor = parseInsertTarget(insertAfterMatch[1], lineNum, "after");
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, true);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true);
+			if (paddingWarning) warnings.push(paddingWarning);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
 			continue;
@@ -185,7 +201,8 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const replaceMatch = REPLACE_OP_RE.exec(line);
 		if (replaceMatch) {
 			const range = parseRange(replaceMatch[1], lineNum);
-			const { payload, nextIndex } = collectPayload(lines, i + 1, lineNum, false);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, false);
+			if (paddingWarning) warnings.push(paddingWarning);
 			// `= A..B` with no payload blanks the range to a single empty line.
 			const replacement = payload.length === 0 ? [""] : payload;
 			for (const text of replacement) {

package/src/hashline/recovery.ts

@@ -3,7 +3,8 @@ import { generateDiffString } from "../edit/diff";
 import type { FileReadCache } from "../edit/file-read-cache";
 import { HashlineMismatchError } from "./anchors";
 import { applyHashlineEdits, type HashlineApplyResult } from "./apply";
-import type { HashlineApplyOptions, HashlineEdit } from "./types";
+import { computeLineHash } from "./hash";
+import type { Anchor, HashlineApplyOptions, HashlineEdit } from "./types";
 
 export interface HashlineRecoveryArgs {
 	cache: FileReadCache;
@@ -19,23 +20,58 @@ export interface HashlineRecoveryResult {
 	warnings: string[];
 }
 
-const HASHLINE_RECOVERY_FUZZ_FACTOR = 3;
+// Anchors are line-precise; never let Diff.applyPatch slide a hunk onto a
+// duplicate closer 100+ lines away. If the snapshot-based replay does not
+// align by exact line number, refuse and let the model re-read.
+const HASHLINE_RECOVERY_FUZZ_FACTOR = 0;
 
 const HASHLINE_RECOVERY_WARNING =
 	"Recovered from stale anchors using a previous read snapshot (file changed externally between read and edit).";
 
+/** Collect every line anchor an edit batch depends on. */
+function collectEditAnchors(edits: HashlineEdit[]): Anchor[] {
+	const anchors: Anchor[] = [];
+	for (const edit of edits) {
+		if (edit.kind === "delete") {
+			anchors.push(edit.anchor);
+			continue;
+		}
+		const cursor = edit.cursor;
+		if (cursor.kind === "before_anchor" || cursor.kind === "after_anchor") {
+			anchors.push(cursor.anchor);
+		}
+	}
+	return anchors;
+}
+
 /**
  * Attempt to recover from a `HashlineMismatchError` by replaying the edits
  * against a cached pre-edit snapshot of the file and 3-way-merging the result
  * onto the current on-disk content. Returns `null` when no recovery is
  * possible — callers should propagate the original mismatch error in that
  * case.
+ *
+ * Recovery is gated on a strict precondition: every line the model anchored
+ * MUST be present in the cached snapshot AND its content MUST hash to the
+ * model-supplied hash. This prevents 3-way merges from silently sliding onto
+ * the wrong site when only tangential parts of the file went stale.
  */
 export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): HashlineRecoveryResult | null {
 	const { cache, absolutePath, currentText, edits, options } = args;
 	const snapshot = cache.get(absolutePath);
 	if (!snapshot || snapshot.lines.size === 0) return null;
 
+	// Precondition: the model's anchors must be vouched-for by the cache. If
+	// even one anchored line is missing from the snapshot, or its cached
+	// content hashes to a different value than the model supplied, refuse —
+	// any merge from here is a guess.
+	const anchors = collectEditAnchors(edits);
+	for (const anchor of anchors) {
+		const cachedLine = snapshot.lines.get(anchor.line);
+		if (cachedLine === undefined) return null;
+		if (computeLineHash(anchor.line, cachedLine) !== anchor.hash) return null;
+	}
+
 	const overlaid = currentText.split("\n");
 	let maxCachedLine = 0;
 	for (const lineNum of snapshot.lines.keys()) {
@@ -62,7 +98,12 @@ export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): Hashlin
 	if (typeof merged !== "string" || merged === currentText) return null;
 
 	const mergedDiff = generateDiffString(currentText, merged);
-	const recoveryWarnings = [HASHLINE_RECOVERY_WARNING, ...(applied.warnings ?? [])];
+	// Only surface the recovery warning when the merge actually changed
+	// something visible. A no-op merge (e.g. trailing-newline only) is noise.
+	const hasNetChange = mergedDiff.firstChangedLine !== undefined;
+	const recoveryWarnings = hasNetChange
+		? [HASHLINE_RECOVERY_WARNING, ...(applied.warnings ?? [])]
+		: [...(applied.warnings ?? [])];
 
 	return {
 		lines: merged,

package/src/lsp/edits.ts

@@ -1,7 +1,17 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { formatPathRelativeToCwd } from "../tools/path-utils";
-import type { CreateFile, DeleteFile, RenameFile, TextDocumentEdit, TextEdit, WorkspaceEdit } from "./types";
+import { ToolError } from "../tools/tool-errors";
+import type {
+	CreateFile,
+	DeleteFile,
+	Position,
+	Range,
+	RenameFile,
+	TextDocumentEdit,
+	TextEdit,
+	WorkspaceEdit,
+} from "./types";
 import { uriToFile } from "./utils";
 
 // =============================================================================
@@ -23,6 +33,19 @@ export function applyTextEditsToString(content: string, edits: TextEdit[]): stri
 		return b.range.start.character - a.range.start.character;
 	});
 
+	// Detect overlapping ranges: in reverse-sorted order, each edit's start
+	// must be >= the next edit's end. If not, the edits would clobber each other
+	// once applied bottom-up (typically a multi-server rename with stale positions).
+	for (let i = 0; i < sortedEdits.length - 1; i++) {
+		const later = sortedEdits[i].range;
+		const earlier = sortedEdits[i + 1].range;
+		if (comparePosition(earlier.end, later.start) > 0) {
+			throw new ToolError(
+				`overlapping LSP edits: ${formatRange(earlier)} conflicts with ${formatRange(later)}; multi-server rename produced inconsistent edits`,
+			);
+		}
+	}
+
 	for (const edit of sortedEdits) {
 		const { start, end } = edit.range;
 
@@ -42,6 +65,47 @@ export function applyTextEditsToString(content: string, edits: TextEdit[]): stri
 	return lines.join("\n");
 }
 
+function comparePosition(a: Position, b: Position): number {
+	return a.line === b.line ? a.character - b.character : a.line - b.line;
+}
+
+function formatRange(range: Range): string {
+	return `${range.start.line + 1}:${range.start.character + 1}-${range.end.line + 1}:${range.end.character + 1}`;
+}
+
+/** True when two ranges overlap (share any position other than a touching boundary). */
+export function rangesOverlap(a: Range, b: Range): boolean {
+	return comparePosition(a.start, b.end) < 0 && comparePosition(b.start, a.end) < 0;
+}
+
+/**
+ * Flatten a WorkspaceEdit's text edits into a Map<uri, TextEdit[]>.
+ * Resource operations (create/rename/delete) are ignored — callers handle them separately.
+ */
+export function flattenWorkspaceTextEdits(edit: WorkspaceEdit): Map<string, TextEdit[]> {
+	const out = new Map<string, TextEdit[]>();
+	const push = (uri: string, edits: TextEdit[]) => {
+		if (edits.length === 0) return;
+		const prev = out.get(uri);
+		if (prev) prev.push(...edits);
+		else out.set(uri, [...edits]);
+	};
+	if (edit.changes) {
+		const changes = edit.changes;
+		for (const uri in changes) push(uri, changes[uri]);
+	}
+	if (edit.documentChanges) {
+		for (const change of edit.documentChanges) {
+			if ("textDocument" in change && change.textDocument && "edits" in change && change.edits) {
+				const tdc = change as TextDocumentEdit;
+				const textEdits = tdc.edits.filter((e): e is TextEdit => "range" in e && "newText" in e);
+				push(tdc.textDocument.uri, textEdits);
+			}
+		}
+	}
+	return out;
+}
+
 /**
  * Apply text edits to a file.
  * Edits are applied in reverse order (bottom-to-top) to preserve line/character indices.
@@ -63,47 +127,37 @@ export async function applyTextEdits(filePath: string, edits: TextEdit[]): Promi
 export async function applyWorkspaceEdit(edit: WorkspaceEdit, cwd: string): Promise<string[]> {
 	const applied: string[] = [];
 
-	// Handle changes map (legacy format)
-	if (edit.changes) {
-		for (const [uri, textEdits] of Object.entries(edit.changes)) {
-			const filePath = uriToFile(uri);
-			await applyTextEdits(filePath, textEdits);
-			applied.push(`Applied ${textEdits.length} edit(s) to ${formatPathRelativeToCwd(filePath, cwd)}`);
-		}
+	// Coalesce all text edits per URI before applying so a single file's edits
+	// are applied in one pass against a single snapshot — multiple TextDocumentEdits
+	// for the same URI would otherwise read stale positions on subsequent writes.
+	const textEditsByUri = flattenWorkspaceTextEdits(edit);
+	for (const [uri, textEdits] of textEditsByUri) {
+		const filePath = uriToFile(uri);
+		await applyTextEdits(filePath, textEdits);
+		applied.push(`Applied ${textEdits.length} edit(s) to ${formatPathRelativeToCwd(filePath, cwd)}`);
 	}
 
-	// Handle documentChanges array (modern format)
+	// Resource operations (create/rename/delete) preserve their original order.
 	if (edit.documentChanges) {
 		for (const change of edit.documentChanges) {
-			if ("textDocument" in change && change.textDocument && "edits" in change && change.edits) {
-				// TextDocumentEdit
-				const docChange = change as TextDocumentEdit;
-				const filePath = uriToFile(docChange.textDocument.uri);
-				const textEdits = docChange.edits.filter((e): e is TextEdit => "range" in e && "newText" in e);
-				await applyTextEdits(filePath, textEdits);
-				applied.push(`Applied ${textEdits.length} edit(s) to ${formatPathRelativeToCwd(filePath, cwd)}`);
-			} else if ("kind" in change && change.kind) {
-				// Resource operations
-				if (change.kind === "create") {
-					const createOp = change as CreateFile;
-					const filePath = uriToFile(createOp.uri);
-					await Bun.write(filePath, "");
-					applied.push(`Created ${formatPathRelativeToCwd(filePath, cwd)}`);
-				} else if (change.kind === "rename") {
-					const renameOp = change as RenameFile;
-					const oldPath = uriToFile(renameOp.oldUri);
-					const newPath = uriToFile(renameOp.newUri);
-					await fs.mkdir(path.dirname(newPath), { recursive: true });
-					await fs.rename(oldPath, newPath);
-					applied.push(
-						`Renamed ${formatPathRelativeToCwd(oldPath, cwd)} → ${formatPathRelativeToCwd(newPath, cwd)}`,
-					);
-				} else if (change.kind === "delete") {
-					const deleteOp = change as DeleteFile;
-					const filePath = uriToFile(deleteOp.uri);
-					await fs.rm(filePath, { recursive: true });
-					applied.push(`Deleted ${formatPathRelativeToCwd(filePath, cwd)}`);
-				}
+			if (!("kind" in change) || !change.kind) continue;
+			if (change.kind === "create") {
+				const createOp = change as CreateFile;
+				const filePath = uriToFile(createOp.uri);
+				await Bun.write(filePath, "");
+				applied.push(`Created ${formatPathRelativeToCwd(filePath, cwd)}`);
+			} else if (change.kind === "rename") {
+				const renameOp = change as RenameFile;
+				const oldPath = uriToFile(renameOp.oldUri);
+				const newPath = uriToFile(renameOp.newUri);
+				await fs.mkdir(path.dirname(newPath), { recursive: true });
+				await fs.rename(oldPath, newPath);
+				applied.push(`Renamed ${formatPathRelativeToCwd(oldPath, cwd)} → ${formatPathRelativeToCwd(newPath, cwd)}`);
+			} else if (change.kind === "delete") {
+				const deleteOp = change as DeleteFile;
+				const filePath = uriToFile(deleteOp.uri);
+				await fs.rm(filePath, { recursive: true });
+				applied.push(`Deleted ${formatPathRelativeToCwd(filePath, cwd)}`);
 			}
 		}
 	}

package/src/lsp/index.ts

@@ -7,7 +7,7 @@ import { type Theme, theme } from "../modes/theme/theme";
 import lspDescription from "../prompts/tools/lsp.md" with { type: "text" };
 import type { ToolSession } from "../tools";
 import { formatPathRelativeToCwd, resolveToCwd } from "../tools/path-utils";
-import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
+import { ToolAbortError, ToolError, throwIfAborted } from "../tools/tool-errors";
 import { clampTimeout } from "../tools/tool-timeouts";
 import {
 	ensureFileOpen,
@@ -25,7 +25,13 @@ import {
 } from "./client";
 import { getLinterClient } from "./clients";
 import { getServersForFile, type LspConfig, loadConfig } from "./config";
-import { applyTextEditsToString, applyWorkspaceEdit } from "./edits";
+import {
+	applyTextEdits,
+	applyTextEditsToString,
+	applyWorkspaceEdit,
+	flattenWorkspaceTextEdits,
+	rangesOverlap,
+} from "./edits";
 import { detectLspmux } from "./lspmux";
 import { renderCall, renderResult } from "./render";
 import {
@@ -1197,7 +1203,8 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 		const { action, file, line, symbol, query, new_name, apply, timeout } = params;
 		const timeoutSec = clampTimeout("lsp", timeout);
 		const timeoutSignal = AbortSignal.timeout(timeoutSec * 1000);
-		signal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+		const callerSignal = signal;
+		signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
 		throwIfAborted(signal);
 
 		const config = getConfig(this.session.cwd);
@@ -1519,11 +1526,81 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			}
 
 			const summary: string[] = [];
+
+			// Coalesce per-URI edits across servers before applying. Each server
+			// computed positions against the pre-edit file content, so applying
+			// server A then re-reading for server B yields stale positions and
+			// produces malformed imports. Group all text edits by URI, prefer the
+			// project-primary (project-aware) server on overlap, and apply once
+			// per URI from a single snapshot.
+			const serverConfigByName = new Map(servers);
+			interface AcceptedBucket {
+				primaryServer: string;
+				edits: TextEdit[];
+				discarded: number;
+				conflictServers: Set<string>;
+			}
+			const acceptedByUri = new Map<string, AcceptedBucket>();
 			for (const { serverName, edit } of perServerEdits) {
-				const applied = await applyWorkspaceEdit(edit, this.session.cwd);
-				if (applied.length > 0) {
-					summary.push(`  ${serverName}:`);
-					summary.push(...applied.map(line => `    ${line}`));
+				const cfg = serverConfigByName.get(serverName);
+				const incomingPrimary = cfg ? isProjectAwareLspServer(cfg) : false;
+				const flat = flattenWorkspaceTextEdits(edit);
+				for (const [uri, edits] of flat) {
+					const existing = acceptedByUri.get(uri);
+					if (!existing) {
+						acceptedByUri.set(uri, {
+							primaryServer: serverName,
+							edits: [...edits],
+							discarded: 0,
+							conflictServers: new Set(),
+						});
+						continue;
+					}
+					const existingCfg = serverConfigByName.get(existing.primaryServer);
+					const existingIsPrimary = existingCfg ? isProjectAwareLspServer(existingCfg) : false;
+					if (incomingPrimary && !existingIsPrimary) {
+						// Promote incoming to primary; keep existing edits that don't overlap.
+						const keptOld: TextEdit[] = [];
+						let discardedOld = 0;
+						for (const oe of existing.edits) {
+							if (edits.some(ne => rangesOverlap(ne.range, oe.range))) discardedOld++;
+							else keptOld.push(oe);
+						}
+						if (discardedOld > 0) existing.conflictServers.add(existing.primaryServer);
+						existing.discarded += discardedOld;
+						existing.primaryServer = serverName;
+						existing.edits = [...edits, ...keptOld];
+					} else {
+						// Existing wins; discard incoming edits that overlap any accepted edit.
+						let discardedNew = 0;
+						for (const ne of edits) {
+							if (existing.edits.some(ae => rangesOverlap(ae.range, ne.range))) {
+								discardedNew++;
+							} else {
+								existing.edits.push(ne);
+							}
+						}
+						if (discardedNew > 0) {
+							existing.conflictServers.add(serverName);
+							existing.discarded += discardedNew;
+						}
+					}
+				}
+			}
+
+			for (const [uri, bucket] of acceptedByUri) {
+				const filePath = uriToFile(uri);
+				await applyTextEdits(filePath, bucket.edits);
+				const rel = formatPathRelativeToCwd(filePath, this.session.cwd);
+				summary.push(`  ${bucket.primaryServer}: applied ${bucket.edits.length} edit(s) to ${rel}`);
+				if (bucket.discarded > 0) {
+					const others = Array.from(bucket.conflictServers).join(", ");
+					summary.push(
+						`    note: discarded ${bucket.discarded} overlapping edit(s) from ${others} (kept ${bucket.primaryServer})`,
+					);
+					logger.warn(
+						`lsp rename_file: discarded ${bucket.discarded} overlapping edit(s) from ${others} on ${rel}; kept ${bucket.primaryServer}`,
+					);
 				}
 			}
 
@@ -1844,6 +1921,22 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				await ensureFileOpen(client, targetFile, signal);
 			}
 
+			// For project-aware servers, references/rename/definition without a `symbol`
+			// silently falls back to the first non-whitespace column on the line, which
+			// frequently points at the wrong identifier (decorator, keyword, parameter)
+			// and the server returns plausible-looking but unrelated results. Require
+			// `symbol` explicitly so callers cannot accidentally trigger that fallback.
+			if (
+				targetFile &&
+				line !== undefined &&
+				!symbol &&
+				(action === "references" || action === "rename" || action === "definition") &&
+				isProjectAwareLspServer(serverConfig)
+			) {
+				throw new ToolError(
+					`symbol is required for project-aware ${action}; pass symbol=<name>, optionally symbol#N for repeated occurrences`,
+				);
+			}
 			const uri = targetFile ? fileToUri(targetFile) : "";
 			const resolvedLine = line ?? 1;
 			const resolvedCharacter = targetFile ? await resolveSymbolColumn(targetFile, resolvedLine, symbol) : 0;
@@ -2166,7 +2259,17 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 				details: { serverName, action, success: true, request: params },
 			};
 		} catch (err) {
+			if (err instanceof ToolError) throw err;
 			if (err instanceof ToolAbortError || signal?.aborted) {
+				// Distinguish a wall-clock timeout from a caller cancel:
+				// callerSignal aborting → real cancel (re-throw ToolAbortError);
+				// timeoutSignal aborting without callerSignal → emit a ToolError naming the
+				// elapsed budget and server, instead of opaque "Operation aborted".
+				if (timeoutSignal.aborted && !callerSignal?.aborted) {
+					throw new ToolError(
+						`LSP ${action} timed out after ${timeoutSec}s on ${serverName}. The server may still be indexing; try again or pass timeout=<larger>.`,
+					);
+				}
 				throw new ToolAbortError();
 			}
 			const errorMessage = err instanceof Error ? err.message : String(err);

package/src/lsp/utils.ts

@@ -581,15 +581,28 @@ function firstNonWhitespaceColumn(lineText: string): number {
 	return match ? (match.index ?? 0) : 0;
 }
 
+const BARE_IDENTIFIER_RE = /^[A-Za-z_][\w]*$/;
+const IDENTIFIER_CHAR_RE = /[A-Za-z0-9_$]/;
+
 function findSymbolMatchIndexes(lineText: string, symbol: string, caseInsensitive = false): number[] {
 	if (symbol.length === 0) return [];
 	const haystack = caseInsensitive ? lineText.toLowerCase() : lineText;
 	const needle = caseInsensitive ? symbol.toLowerCase() : symbol;
+	const requireWordBoundary = BARE_IDENTIFIER_RE.test(symbol);
 	const indexes: number[] = [];
 	let fromIndex = 0;
 	while (fromIndex <= haystack.length - needle.length) {
 		const matchIndex = haystack.indexOf(needle, fromIndex);
 		if (matchIndex === -1) break;
+		if (requireWordBoundary) {
+			const before = matchIndex > 0 ? haystack[matchIndex - 1] : "";
+			const afterIdx = matchIndex + needle.length;
+			const after = afterIdx < haystack.length ? haystack[afterIdx] : "";
+			if (IDENTIFIER_CHAR_RE.test(before) || IDENTIFIER_CHAR_RE.test(after)) {
+				fromIndex = matchIndex + 1;
+				continue;
+			}
+		}
 		indexes.push(matchIndex);
 		fromIndex = matchIndex + needle.length;
 	}

package/src/modes/acp/acp-client-bridge.ts

@@ -124,6 +124,7 @@ async function requestPermission(
 		...(toolCall.kind ? { kind: toolCall.kind as ToolCallUpdate["kind"] } : {}),
 		...(toolCall.status ? { status: toolCall.status as ToolCallUpdate["status"] } : {}),
 		...(toolCall.rawInput !== undefined ? { rawInput: toolCall.rawInput } : {}),
+		...(toolCall.content ? { content: toolCall.content as ToolCallUpdate["content"] } : {}),
 		...(toolCall.locations ? { locations: toolCall.locations } : {}),
 	};
 	const acpOptions: AcpPermissionOption[] = options.map(option => ({

package/src/modes/components/status-line/segments.ts

@@ -84,7 +84,7 @@ const modelSegment: StatusLineSegment = {
 
 		let content = withIcon(theme.icon.model, modelName);
 
-		if (ctx.session.isFastModeEnabled() && theme.icon.fast) {
+		if (ctx.session.isFastModeActive() && theme.icon.fast) {
 			content += ` ${theme.icon.fast}`;
 		}