@oh-my-pi/pi-coding-agent 14.5.8 → 14.5.10

package/src/edit/modes/hashline.ts

@@ -53,7 +53,7 @@ export type HashlineEdit =
 // Accept both `|` (canonical) and `:` (legacy) so re-reads of older outputs still parse.
 const HASHLINE_CONTENT_SEPARATOR_RE = "[:|]";
 const HASHLINE_PREFIX_RE = new RegExp(
-	`^\\s*(?:>>>|>>)?\\s*(?:\\+\\s*)?\\d+${HASHLINE_BIGRAM_RE_SRC}${HASHLINE_CONTENT_SEPARATOR_RE}`,
+	`^\\s*(?:>>>|>>)?\\s*(?:[+*]\\s*)?\\d+${HASHLINE_BIGRAM_RE_SRC}${HASHLINE_CONTENT_SEPARATOR_RE}`,
 );
 const HASHLINE_PREFIX_PLUS_RE = new RegExp(
 	`^\\s*(?:>>>|>>)?\\s*\\+\\s*\\d+${HASHLINE_BIGRAM_RE_SRC}${HASHLINE_CONTENT_SEPARATOR_RE}`,
@@ -503,7 +503,7 @@ export function parseTag(ref: string): { line: number; hash: string } {
 	//  1. optional leading ">+-" markers and whitespace
 	//  2. line number (1+ digits)
 	//  3. hash (one BPE bigram from HASHLINE_BIGRAMS) directly adjacent (no separator)
-	const match = ref.match(new RegExp(`^\\s*[>+-]*\\s*(\\d+)(${HASHLINE_BIGRAM_RE_SRC})`));
+	const match = ref.match(new RegExp(`^\\s*[>+\\-*]*\\s*(\\d+)(${HASHLINE_BIGRAM_RE_SRC})`));
 	if (!match) {
 		throw new Error(`Invalid line reference. Expected ${formatFullAnchorRequirement(ref)}.`);
 	}
@@ -605,7 +605,6 @@ export class HashlineMismatchError extends Error {
 			`Edit rejected: ${mismatches.length} line${mismatches.length > 1 ? "s have" : " has"} changed since the last read (marked *).`,
 			"The edit was NOT applied, please use the updated file content shown below, and issue another edit tool-call.",
 		);
-		lines.push("");
 
 		let prevLine = -1;
 		for (const lineNum of sorted) {
@@ -650,7 +649,7 @@ export function validateLineRef(ref: { line: number; hash: string }, fileLines:
 /**
  * Default search window for {@link tryRebaseAnchor} (lines on each side of the requested anchor).
  */
-export const ANCHOR_REBASE_WINDOW = 2;
+export const ANCHOR_REBASE_WINDOW = 5;
 
 /**
  * Look for the requested hash within ±`window` lines of `anchor.line`.
@@ -1008,23 +1007,40 @@ export interface CompactHashlineDiffPreview {
 }
 
 export interface CompactHashlineDiffOptions {
+	/** Maximum entries kept on each side of an unchanged-context truncation (default: 2). */
 	maxUnchangedRun?: number;
-	maxDeletionRun?: number;
-	maxOutputLines?: number;
 }
 
 const NUMBERED_DIFF_LINE_RE = /^([ +-])(\s*\d+)\|(.*)$/;
 const HASHLINE_PREVIEW_PLACEHOLDER = "  ";
+const ELLIPSIS = "...";
 
-type DiffRunKind = " " | "+" | "-" | "meta";
-type DiffRun = { kind: DiffRunKind; lines: string[] };
+type DiffEntryKind = " " | "+" | "-" | "*";
+type RunKind = DiffEntryKind | "meta";
+
+interface DiffEntry {
+	kind: DiffEntryKind;
+	oldLine: number;
+	newLine: number;
+	content: string;
+}
+
+interface MetaEntry {
+	kind: "meta";
+	raw: string;
+}
+
+type Entry = DiffEntry | MetaEntry;
+
+interface Run {
+	kind: RunKind;
+	entries: Entry[];
+}
 
 interface ParsedNumberedDiffLine {
 	kind: " " | "+" | "-";
 	lineNumber: number;
-	lineWidth: number;
 	content: string;
-	raw: string;
 }
 
 interface CompactPreviewCounters {
@@ -1039,11 +1055,10 @@ function parseNumberedDiffLine(line: string): ParsedNumberedDiffLine | undefined
 	const kind = match[1];
 	if (kind !== " " && kind !== "+" && kind !== "-") return undefined;
 
-	const lineField = match[2];
-	const lineNumber = Number(lineField.trim());
+	const lineNumber = Number(match[2].trim());
 	if (!Number.isInteger(lineNumber)) return undefined;
 
-	return { kind, lineNumber, lineWidth: lineField.length, content: match[3], raw: line };
+	return { kind, lineNumber, content: match[3] };
 }
 
 function syncOldLineCounters(counters: CompactPreviewCounters, lineNumber: number): void {
@@ -1070,105 +1085,169 @@ function syncNewLineCounters(counters: CompactPreviewCounters, lineNumber: numbe
 	counters.newLine = lineNumber;
 }
 
-function formatCompactHashlineLine(kind: " " | "+", lineNumber: number, content: string): string {
-	return `${kind}${lineNumber}${computeLineHash(lineNumber, content)}${HASHLINE_CONTENT_SEPARATOR}${content}`;
-}
+/**
+ * Parse a unified-diff-with-line-numbers blob into structured entries while
+ * tracking both old- and new-file line numbers. `...` markers (emitted by
+ * {@link generateDiffString} for collapsed context) sync counters but are
+ * preserved as passthrough entries so the original ellipsis remains visible.
+ */
+function parseDiffEntries(lines: string[]): Entry[] {
+	const entries: Entry[] = [];
+	const counters: CompactPreviewCounters = {};
 
-function formatCompactRemovedLine(lineNumber: number, content: string): string {
-	return `-${lineNumber}${HASHLINE_PREVIEW_PLACEHOLDER}${HASHLINE_CONTENT_SEPARATOR}${content}`;
-}
+	for (const line of lines) {
+		const parsed = parseNumberedDiffLine(line);
+		if (!parsed) {
+			entries.push({ kind: "meta", raw: line });
+			continue;
+		}
 
-function formatCompactPreviewLine(line: string, counters: CompactPreviewCounters): { kind: DiffRunKind; text: string } {
-	const parsed = parseNumberedDiffLine(line);
-	if (!parsed) return { kind: "meta", text: line };
+		const isEllipsis = parsed.content === ELLIPSIS;
 
-	if (parsed.content === "...") {
 		if (parsed.kind === "+") {
 			syncNewLineCounters(counters, parsed.lineNumber);
-		} else {
-			syncOldLineCounters(counters, parsed.lineNumber);
+			const newLine = counters.newLine ?? parsed.lineNumber;
+			const oldLine = counters.oldLine ?? parsed.lineNumber;
+			entries.push({ kind: "+", oldLine, newLine, content: parsed.content });
+			if (!isEllipsis) counters.newLine = newLine + 1;
+			continue;
 		}
-		return { kind: parsed.kind, text: parsed.raw };
-	}
 
-	switch (parsed.kind) {
-		case "+": {
-			syncNewLineCounters(counters, parsed.lineNumber);
-			const newLine = counters.newLine;
-			if (newLine === undefined) return { kind: "+", text: parsed.raw };
-			const text = formatCompactHashlineLine("+", newLine, parsed.content);
-			counters.newLine = newLine + 1;
-			return { kind: "+", text };
-		}
-		case "-": {
+		if (parsed.kind === "-") {
 			syncOldLineCounters(counters, parsed.lineNumber);
-			const text = formatCompactRemovedLine(parsed.lineNumber, parsed.content);
-			counters.oldLine = parsed.lineNumber + 1;
-			return { kind: "-", text };
+			const oldLine = parsed.lineNumber;
+			const newLine = counters.newLine ?? parsed.lineNumber;
+			entries.push({ kind: "-", oldLine, newLine, content: parsed.content });
+			if (!isEllipsis) counters.oldLine = oldLine + 1;
+			continue;
 		}
-		case " ": {
-			syncOldLineCounters(counters, parsed.lineNumber);
-			const newLine = counters.newLine;
-			if (newLine === undefined) return { kind: " ", text: parsed.raw };
-			const text = formatCompactHashlineLine(" ", newLine, parsed.content);
-			counters.oldLine = parsed.lineNumber + 1;
+
+		// Context line.
+		syncOldLineCounters(counters, parsed.lineNumber);
+		const oldLine = parsed.lineNumber;
+		const newLine = counters.newLine ?? parsed.lineNumber;
+		entries.push({ kind: " ", oldLine, newLine, content: parsed.content });
+		if (!isEllipsis) {
+			counters.oldLine = oldLine + 1;
 			counters.newLine = newLine + 1;
-			return { kind: " ", text };
 		}
 	}
-}
 
-function splitDiffRuns(lines: string[]): DiffRun[] {
-	const runs: DiffRun[] = [];
-	const counters: CompactPreviewCounters = {};
+	return entries;
+}
 
-	for (const line of lines) {
-		const formatted = formatCompactPreviewLine(line, counters);
+function groupRuns(entries: Entry[]): Run[] {
+	const runs: Run[] = [];
+	for (const entry of entries) {
 		const prev = runs[runs.length - 1];
-		if (prev && prev.kind === formatted.kind) {
-			prev.lines.push(formatted.text);
+		if (prev && prev.kind === entry.kind) {
+			prev.entries.push(entry);
 			continue;
 		}
-		runs.push({ kind: formatted.kind, lines: [formatted.text] });
+		runs.push({ kind: entry.kind, entries: [entry] });
 	}
-
 	return runs;
 }
 
-function collapseFromStart(lines: string[], maxLines: number, label: string): string[] {
-	if (lines.length <= maxLines) return lines;
-	const hidden = lines.length - maxLines;
-	return [...lines.slice(0, maxLines), ` ... ${hidden} more ${label} lines`];
+/**
+ * Collapse adjacent `(-, +)` runs into a single `*` run for paired
+ * modifications. The i-th removed line pairs with the i-th added line — in
+ * unified-diff convention they replaced each other in place — and is shown as
+ * `*<newLine><hash>|<newContent>` instead of two lines `-<old>` + `+<new>`.
+ * Surplus removals or additions remain as their own runs after the paired
+ * block, preserving the unified-diff `del-then-add` ordering.
+ */
+function pairModifications(runs: Run[]): Run[] {
+	const isPairable = (entry: Entry): entry is DiffEntry => entry.kind !== "meta" && entry.content !== ELLIPSIS;
+
+	const out: Run[] = [];
+	for (let i = 0; i < runs.length; i++) {
+		const run = runs[i];
+		const next = runs[i + 1];
+		if (run.kind !== "-" || !next || next.kind !== "+") {
+			out.push(run);
+			continue;
+		}
+
+		const dels = run.entries.filter(isPairable);
+		const adds = next.entries.filter(isPairable);
+		const pairCount = Math.min(dels.length, adds.length);
+		if (pairCount === 0) {
+			out.push(run);
+			continue;
+		}
+
+		const mods: Entry[] = [];
+		for (let p = 0; p < pairCount; p++) {
+			mods.push({
+				kind: "*",
+				oldLine: dels[p].oldLine,
+				newLine: adds[p].newLine,
+				content: adds[p].content,
+			});
+		}
+		out.push({ kind: "*", entries: mods });
+
+		if (dels.length > pairCount) {
+			out.push({ kind: "-", entries: dels.slice(pairCount) });
+		}
+		if (adds.length > pairCount) {
+			out.push({ kind: "+", entries: adds.slice(pairCount) });
+		}
+
+		i++; // consume the `+` run
+	}
+	return out;
 }
 
-function _collapseFromEnd(lines: string[], maxLines: number, label: string): string[] {
-	if (lines.length <= maxLines) return lines;
-	const hidden = lines.length - maxLines;
-	return [` ... ${hidden} more ${label} lines`, ...lines.slice(-maxLines)];
+function formatEntry(entry: Entry): string {
+	if (entry.kind === "meta") return entry.raw;
+
+	if (entry.content === ELLIPSIS) {
+		// Preserve the `... <line>|...` ellipsis marker emitted by generateDiffString.
+		const lineNum = entry.kind === "+" || entry.kind === "*" ? entry.newLine : entry.oldLine;
+		const prefix = entry.kind === "*" ? "+" : entry.kind;
+		return `${prefix}${lineNum}${HASHLINE_PREVIEW_PLACEHOLDER}${HASHLINE_CONTENT_SEPARATOR}${ELLIPSIS}`;
+	}
+
+	switch (entry.kind) {
+		case "+":
+			return `+${entry.newLine}${computeLineHash(entry.newLine, entry.content)}${HASHLINE_CONTENT_SEPARATOR}${entry.content}`;
+		case "-":
+			return `-${entry.oldLine}${HASHLINE_PREVIEW_PLACEHOLDER}${HASHLINE_CONTENT_SEPARATOR}${entry.content}`;
+		case " ":
+			return ` ${entry.newLine}${computeLineHash(entry.newLine, entry.content)}${HASHLINE_CONTENT_SEPARATOR}${entry.content}`;
+		case "*":
+			return `*${entry.newLine}${computeLineHash(entry.newLine, entry.content)}${HASHLINE_CONTENT_SEPARATOR}${entry.content}`;
+	}
 }
 
-function collapseFromMiddle(lines: string[], maxLines: number, label: string): string[] {
-	if (lines.length <= maxLines * 2) return lines;
-	const hidden = lines.length - maxLines * 2;
-	return [...lines.slice(0, maxLines), ` ... ${hidden} more ${label} lines`, ...lines.slice(-maxLines)];
+function collapseUnchangedMiddle(entries: Entry[], maxRun: number): string[] {
+	if (entries.length <= maxRun * 2) return entries.map(formatEntry);
+	const hidden = entries.length - maxRun * 2;
+	return [
+		...entries.slice(0, maxRun).map(formatEntry),
+		` ... ${hidden} more unchanged lines`,
+		...entries.slice(-maxRun).map(formatEntry),
+	];
 }
 
 /**
  * Build a compact diff preview suitable for model-visible tool responses.
  *
- * Collapses long unchanged runs and long consecutive additions/removals so the
- * model sees the shape of edits without replaying full file content.
+ * Every changed line — added, removed, or modified — is shown in full. Only
+ * unchanged context blocks between or around changes get truncated. Adjacent
+ * `-`/`+` pairs are folded into single `*` modification lines so the common
+ * 1:1 line-replacement case stays compact.
  */
 export function buildCompactHashlineDiffPreview(
 	diff: string,
 	options: CompactHashlineDiffOptions = {},
 ): CompactHashlineDiffPreview {
 	const maxUnchangedRun = options.maxUnchangedRun ?? 2;
-	const maxDeletionRun = options.maxDeletionRun ?? 2;
-	const maxOutputLines = options.maxOutputLines ?? 16;
 
 	const inputLines = diff.length === 0 ? [] : diff.split("\n");
-	const runs = splitDiffRuns(inputLines);
+	const runs = pairModifications(groupRuns(parseDiffEntries(inputLines)));
 
 	const out: string[] = [];
 	let addedLines = 0;
@@ -1178,39 +1257,41 @@ export function buildCompactHashlineDiffPreview(
 		const run = runs[runIndex];
 		switch (run.kind) {
 			case "meta":
-				out.push(...run.lines);
+				for (const entry of run.entries) out.push(formatEntry(entry));
 				break;
 			case "+":
-				addedLines += run.lines.length;
-				out.push(...run.lines);
+				for (const entry of run.entries) {
+					if (entry.kind !== "meta" && entry.content !== ELLIPSIS) addedLines++;
+					out.push(formatEntry(entry));
+				}
 				break;
 			case "-":
-				removedLines += run.lines.length;
-				out.push(...collapseFromStart(run.lines, maxDeletionRun, "removed"));
+				for (const entry of run.entries) {
+					if (entry.kind !== "meta" && entry.content !== ELLIPSIS) removedLines++;
+					out.push(formatEntry(entry));
+				}
+				break;
+			case "*":
+				for (const entry of run.entries) {
+					addedLines++;
+					removedLines++;
+					out.push(formatEntry(entry));
+				}
 				break;
 			case " ":
 				if (runIndex === 0) {
-					out.push(...run.lines.slice(-maxUnchangedRun));
+					out.push(...run.entries.slice(-maxUnchangedRun).map(formatEntry));
 					break;
 				}
 				if (runIndex === runs.length - 1) {
-					out.push(...run.lines.slice(0, maxUnchangedRun));
+					out.push(...run.entries.slice(0, maxUnchangedRun).map(formatEntry));
 					break;
 				}
-				out.push(...collapseFromMiddle(run.lines, maxUnchangedRun, "unchanged"));
+				out.push(...collapseUnchangedMiddle(run.entries, maxUnchangedRun));
 				break;
 		}
 	}
 
-	if (out.length > maxOutputLines) {
-		const hidden = out.length - maxOutputLines;
-		return {
-			preview: [...out.slice(0, maxOutputLines), ` ... ${hidden} more preview lines`].join("\n"),
-			addedLines,
-			removedLines,
-		};
-	}
-
 	return { preview: out.join("\n"), addedLines, removedLines };
 }
 

package/src/extensibility/extensions/runner.ts

@@ -2,13 +2,14 @@
  * Extension runner - executes extensions and manages their lifecycle.
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
+import type { ImageContent, Model, ProviderResponseMetadata } from "@oh-my-pi/pi-ai";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../../config/model-registry";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { SessionManager } from "../../session/session-manager";
 import type {
+	AfterProviderResponseEvent,
 	BeforeAgentStartEvent,
 	BeforeAgentStartEventResult,
 	BeforeProviderRequestEvent,
@@ -70,6 +71,7 @@ type RunnerEmitEvent = Exclude<
 	| UserBashEvent
 	| ContextEvent
 	| BeforeProviderRequestEvent
+	| AfterProviderResponseEvent
 	| BeforeAgentStartEvent
 	| ResourcesDiscoverEvent
 	| InputEvent
@@ -759,6 +761,37 @@ export class ExtensionRunner {
 		return currentPayload;
 	}
 
+	async emitAfterProviderResponse(response: ProviderResponseMetadata, _model?: Model): Promise<void> {
+		const ctx = this.createContext();
+
+		for (const ext of this.extensions) {
+			const handlers = ext.handlers.get("after_provider_response");
+			if (!handlers || handlers.length === 0) continue;
+
+			for (const handler of handlers) {
+				try {
+					const event: AfterProviderResponseEvent = {
+						type: "after_provider_response",
+						status: response.status,
+						headers: response.headers,
+						requestId: response.requestId,
+						metadata: response.metadata,
+					};
+					await handler(event, ctx);
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					const stack = err instanceof Error ? err.stack : undefined;
+					this.emitError({
+						extensionPath: ext.path,
+						event: "after_provider_response",
+						error: message,
+						stack,
+					});
+				}
+			}
+		}
+	}
+
 	async emitBeforeAgentStart(
 		prompt: string,
 		images: ImageContent[] | undefined,

package/src/extensibility/extensions/types.ts

@@ -17,6 +17,7 @@ import type {
 	Model,
 	OAuthCredentials,
 	OAuthLoginCallbacks,
+	ProviderResponseMetadata,
 	SimpleStreamOptions,
 	TextContent,
 	ToolResultMessage,
@@ -482,6 +483,11 @@ export interface BeforeProviderRequestEvent {
 	payload: unknown;
 }
 
+/** Fired after a provider response is received, before its stream body is consumed. */
+export interface AfterProviderResponseEvent extends ProviderResponseMetadata {
+	type: "after_provider_response";
+}
+
 /** Fired after user submits prompt but before agent loop. */
 export interface BeforeAgentStartEvent {
 	type: "before_agent_start";
@@ -801,6 +807,7 @@ export type ExtensionEvent =
 	| SessionEvent
 	| ContextEvent
 	| BeforeProviderRequestEvent
+	| AfterProviderResponseEvent
 	| BeforeAgentStartEvent
 	| AgentStartEvent
 	| AgentEndEvent
@@ -981,6 +988,7 @@ export interface ExtensionAPI {
 		event: "before_provider_request",
 		handler: ExtensionHandler<BeforeProviderRequestEvent, BeforeProviderRequestEventResult>,
 	): void;
+	on(event: "after_provider_response", handler: ExtensionHandler<AfterProviderResponseEvent>): void;
 	on(event: "before_agent_start", handler: ExtensionHandler<BeforeAgentStartEvent, BeforeAgentStartEventResult>): void;
 	on(event: "agent_start", handler: ExtensionHandler<AgentStartEvent>): void;
 	on(event: "agent_end", handler: ExtensionHandler<AgentEndEvent>): void;

package/src/lsp/client.ts

@@ -47,7 +47,7 @@ function startIdleChecker(): void {
 		const now = Date.now();
 		for (const [key, client] of Array.from(clients.entries())) {
 			if (now - client.lastActivity > idleTimeoutMs) {
-				shutdownClient(key);
+				void shutdownClient(key);
 			}
 		}
 	}, IDLE_CHECK_INTERVAL_MS);
@@ -762,22 +762,25 @@ export async function refreshFile(client: LspClient, filePath: string, signal?:
 /**
  * Shutdown a specific client by key.
  */
-export function shutdownClient(key: string): void {
-	const client = clients.get(key);
-	if (!client) return;
-
-	// Reject all pending requests
+async function shutdownClientInstance(client: LspClient): Promise<void> {
+	const err = new Error("LSP client shutdown");
 	for (const pending of Array.from(client.pendingRequests.values())) {
-		pending.reject(new Error("LSP client shutdown"));
+		pending.reject(err);
 	}
 	client.pendingRequests.clear();
 
-	// Send shutdown request (best effort, don't wait)
-	sendRequest(client, "shutdown", null).catch(() => {});
-
-	// Kill process
+	const timeout = Bun.sleep(5_000);
+	const shutdown = sendRequest(client, "shutdown", null).catch(() => {});
+	await Promise.race([shutdown, timeout]);
 	client.proc.kill();
+	await Promise.race([client.proc.exited.catch(() => {}), Bun.sleep(1_000)]);
+}
+
+export async function shutdownClient(key: string): Promise<void> {
+	const client = clients.get(key);
+	if (!client) return;
 	clients.delete(key);
+	await shutdownClientInstance(client);
 }
 
 // =============================================================================
@@ -890,27 +893,10 @@ export async function sendNotification(client: LspClient, method: string, params
 /**
  * Shutdown all LSP clients.
  */
-export function shutdownAll(): void {
+export async function shutdownAll(): Promise<void> {
 	const clientsToShutdown = Array.from(clients.values());
 	clients.clear();
-
-	const err = new Error("LSP client shutdown");
-	for (const client of clientsToShutdown) {
-		/// Reject all pending requests
-		const reqs = Array.from(client.pendingRequests.values());
-		client.pendingRequests.clear();
-		for (const pending of reqs) {
-			pending.reject(err);
-		}
-
-		void (async () => {
-			// Send shutdown request (best effort, don't wait)
-			const timeout = Bun.sleep(5_000);
-			const result = sendRequest(client, "shutdown", null).catch(() => {});
-			await Promise.race([result, timeout]);
-			client.proc.kill();
-		})().catch(() => {});
-	}
+	await Promise.allSettled(clientsToShutdown.map(client => shutdownClientInstance(client)));
 }
 
 /** Status of an LSP server */
@@ -938,13 +924,19 @@ export function getActiveClients(): LspServerStatus[] {
 
 // Register cleanup on module unload
 if (typeof process !== "undefined") {
-	process.on("beforeExit", shutdownAll);
+	process.on("beforeExit", () => {
+		void shutdownAll();
+	});
 	process.on("SIGINT", () => {
-		shutdownAll();
-		process.exit(0);
+		void (async () => {
+			await shutdownAll();
+			process.exit(0);
+		})();
 	});
 	process.on("SIGTERM", () => {
-		shutdownAll();
-		process.exit(0);
+		void (async () => {
+			await shutdownAll();
+			process.exit(0);
+		})();
 	});
 }

package/src/lsp/index.ts

@@ -1136,7 +1136,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 		_onUpdate?: AgentToolUpdateCallback<LspToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<LspToolDetails>> {
-		const { action, file, line, symbol, occurrence, query, new_name, apply, timeout } = params;
+		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;
@@ -1449,9 +1449,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 			const uri = targetFile ? fileToUri(targetFile) : "";
 			const resolvedLine = line ?? 1;
-			const resolvedCharacter = targetFile
-				? await resolveSymbolColumn(targetFile, resolvedLine, symbol, occurrence)
-				: 0;
+			const resolvedCharacter = targetFile ? await resolveSymbolColumn(targetFile, resolvedLine, symbol) : 0;
 			const position = { line: resolvedLine - 1, character: resolvedCharacter };
 
 			let output: string;

package/src/lsp/render.ts

@@ -131,9 +131,6 @@ export function renderResult(
 	}
 	if (request?.symbol) {
 		requestLines.push(theme.fg("dim", `symbol: ${sanitizeInlineText(request.symbol)}`));
-		if (request.occurrence !== undefined) {
-			requestLines.push(theme.fg("dim", `occurrence: ${request.occurrence}`));
-		}
 	}
 	if (request?.query) requestLines.push(theme.fg("dim", `query: ${request.query}`));
 	if (request?.new_name) requestLines.push(theme.fg("dim", `new name: ${request.new_name}`));

package/src/lsp/types.ts

@@ -25,10 +25,7 @@ export const lspSchema = Type.Object({
 	),
 	file: Type.Optional(Type.String({ description: "File path" })),
 	line: Type.Optional(Type.Number({ description: "Line number (1-indexed)" })),
-	symbol: Type.Optional(
-		Type.String({ description: "Symbol/substring to locate on the line (used to compute column)" }),
-	),
-	occurrence: Type.Optional(Type.Number({ description: "Symbol occurrence on line (1-indexed, default: 1)" })),
+	symbol: Type.Optional(Type.String({ description: "Symbol/substring to locate on the line" })),
 	query: Type.Optional(Type.String({ description: "Search query or SSR pattern" })),
 	new_name: Type.Optional(Type.String({ description: "New name for rename" })),
 	apply: Type.Optional(Type.Boolean({ description: "Apply edits (default: true)" })),