@oh-my-pi/pi-coding-agent 6.0.0 → 6.2.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## [Unreleased]
 
+## [6.2.0] - 2026-01-19
+### Changed
+
+- Improved LSP batching to coalesce formatting and diagnostics for parallel edits
+- Updated edit and write tools to support batched LSP operations
+
+### Fixed
+
+- Coalesced LSP formatting/diagnostics for parallel edits so only the final write triggers LSP across touched files
+
+## [6.1.0] - 2026-01-19
+
+### Added
+
+- Added lspmux integration for LSP server multiplexing to reduce startup time and memory usage
+- Added LSP tool proxy support for subagent workers
+- Updated LSP status command to show lspmux connection state
+- Added maxdepth and mindepth parameters to find function for depth-controlled file search
+- Added counter function to count occurrences and sort by frequency
+- Added basenames function to extract base names from paths
+
+### Changed
+
+- Simplified rust-analyzer default configuration by removing custom initOptions and settings
+
 ## [6.0.0] - 2026-01-19
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "6.0.0",
+	"version": "6.2.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,10 +40,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "6.0.0",
-		"@oh-my-pi/pi-ai": "6.0.0",
-		"@oh-my-pi/pi-git-tool": "6.0.0",
-		"@oh-my-pi/pi-tui": "6.0.0",
+		"@oh-my-pi/pi-agent-core": "6.2.0",
+		"@oh-my-pi/pi-ai": "6.2.0",
+		"@oh-my-pi/pi-git-tool": "6.2.0",
+		"@oh-my-pi/pi-tui": "6.2.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/python-prelude.py

@@ -191,14 +191,26 @@ if "__omp_prelude_loaded__" not in globals():
         limit: int = 1000,
         hidden: bool = False,
         sort_by_mtime: bool = False,
+        maxdepth: int | None = None,
+        mindepth: int | None = None,
     ) -> list[Path]:
-        """Recursive glob find. Respects .gitignore."""
-        p = Path(path)
+        """Recursive glob find. Respects .gitignore.
+        
+        maxdepth/mindepth are relative to path (0 = path itself, 1 = direct children).
+        """
+        p = Path(path).resolve()
+        base_depth = len(p.parts)
         ignore_patterns = _load_gitignore_patterns(p)
         matches: list[Path] = []
         for m in p.rglob(pattern):
             if len(matches) >= limit:
                 break
+            # Check depth constraints
+            rel_depth = len(m.resolve().parts) - base_depth
+            if maxdepth is not None and rel_depth > maxdepth:
+                continue
+            if mindepth is not None and rel_depth < mindepth:
+                continue
             # Skip hidden files unless requested
             if not hidden and any(part.startswith(".") for part in m.parts):
                 continue
@@ -485,6 +497,30 @@ if "__omp_prelude_loaded__" not in globals():
             return groups
         return "\n".join(line for _, line in groups)
 
+    @_category("Text")
+    def counter(
+        items: str | list,
+        *,
+        limit: int | None = None,
+        reverse: bool = True,
+    ) -> list[tuple[int, str]]:
+        """Count occurrences and sort by frequency. Like sort | uniq -c | sort -rn.
+        
+        items: text (splits into lines) or list of strings
+        reverse: True for descending (most common first), False for ascending
+        Returns: [(count, item), ...] sorted by count
+        """
+        from collections import Counter
+        if isinstance(items, str):
+            items = items.splitlines()
+        counts = Counter(items)
+        sorted_items = sorted(counts.items(), key=lambda x: (x[1], x[0]), reverse=reverse)
+        if limit is not None:
+            sorted_items = sorted_items[:limit]
+        result = [(count, item) for item, count in sorted_items]
+        _emit_status("counter", unique=len(counts), total=sum(counts.values()), top=result[:10])
+        return result
+
     @_category("Text")
     def cols(text: str, *indices: int, sep: str | None = None) -> str:
         """Extract columns from text (0-indexed). Like cut."""
@@ -497,6 +533,13 @@ if "__omp_prelude_loaded__" not in globals():
         _emit_status("cols", lines=len(result_lines), columns=list(indices))
         return out
 
+    @_category("Navigation")
+    def basenames(paths: list[str | Path]) -> list[str]:
+        """Extract basename from each path. Like: sed 's|.*/||'."""
+        names = [Path(p).name for p in paths]
+        _emit_status("basenames", count=len(names), sample=names[:10])
+        return names
+
     @_category("Navigation")
     def tree(path: str | Path = ".", *, max_depth: int = 3, show_hidden: bool = False) -> str:
         """Return directory tree."""

package/src/core/tools/context.ts

@@ -1,4 +1,4 @@
-import type { AgentToolContext } from "@oh-my-pi/pi-agent-core";
+import type { AgentToolContext, ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { CustomToolContext } from "../custom-tools/types";
 import type { ExtensionUIContext } from "../extensions/types";
 
@@ -7,11 +7,12 @@ declare module "@oh-my-pi/pi-agent-core" {
 		ui?: ExtensionUIContext;
 		hasUI?: boolean;
 		toolNames?: string[];
+		toolCall?: ToolCallContext;
 	}
 }
 
 export interface ToolContextStore {
-	getContext(): AgentToolContext;
+	getContext(toolCall?: ToolCallContext): AgentToolContext;
 	setUIContext(uiContext: ExtensionUIContext, hasUI: boolean): void;
 	setToolNames(names: string[]): void;
 }
@@ -22,11 +23,12 @@ export function createToolContextStore(getBaseContext: () => CustomToolContext):
 	let toolNames: string[] = [];
 
 	return {
-		getContext: () => ({
+		getContext: (toolCall) => ({
 			...getBaseContext(),
 			ui: uiContext,
 			hasUI,
 			toolNames,
+			toolCall,
 		}),
 		setUIContext: (context, uiAvailable) => {
 			uiContext = context;

package/src/core/tools/edit.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -41,6 +41,22 @@ export interface EditToolDetails {
 	diagnostics?: FileDiagnosticsResult;
 }
 
+const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
+
+function getLspBatchRequest(toolCall: ToolCallContext | undefined): { id: string; flush: boolean } | undefined {
+	if (!toolCall) {
+		return undefined;
+	}
+	const hasOtherWrites = toolCall.toolCalls.some(
+		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
+	);
+	if (!hasOtherWrites) {
+		return undefined;
+	}
+	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some((call) => LSP_BATCH_TOOLS.has(call.name));
+	return { id: toolCall.batchId, flush: !hasLaterWrites };
+}
+
 export function createEditTool(session: ToolSession): AgentTool<typeof editSchema> {
 	const allowFuzzy = session.settings?.getEditFuzzyMatch() ?? true;
 	const enableLsp = session.enableLsp ?? true;
@@ -58,6 +74,8 @@ export function createEditTool(session: ToolSession): AgentTool<typeof editSchem
 			_toolCallId: string,
 			{ path, oldText, newText, all }: { path: string; oldText: string; newText: string; all?: boolean },
 			signal?: AbortSignal,
+			_onUpdate?: unknown,
+			context?: AgentToolContext,
 		) => {
 			// Reject .ipynb files - use NotebookEdit tool instead
 			if (path.endsWith(".ipynb")) {
@@ -163,7 +181,8 @@ export function createEditTool(session: ToolSession): AgentTool<typeof editSchem
 			}
 
 			const finalContent = bom + restoreLineEndings(normalizedNewContent, originalEnding);
-			const diagnostics = await writethrough(absolutePath, finalContent, signal, file);
+			const batchRequest = getLspBatchRequest(context?.toolCall);
+			const diagnostics = await writethrough(absolutePath, finalContent, signal, file, batchRequest);
 
 			const diffResult = generateDiffString(normalizedContent, normalizedNewContent);
 

package/src/core/tools/lsp/client.ts

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import { logger } from "../../logger";
 import { applyWorkspaceEdit } from "./edits";
+import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
 import type {
 	Diagnostic,
 	LspClient,
@@ -400,13 +401,20 @@ export async function getOrCreateClient(config: ServerConfig, cwd: string, initT
 
 	// Create new client with lock
 	const clientPromise = (async () => {
-		const args = config.args ?? [];
-		const command = config.resolvedCommand ?? config.command;
+		const baseCommand = config.resolvedCommand ?? config.command;
+		const baseArgs = config.args ?? [];
+
+		// Wrap with lspmux if available and supported
+		const { command, args, env } = isLspmuxSupported(baseCommand)
+			? await getLspmuxCommand(baseCommand, baseArgs)
+			: { command: baseCommand, args: baseArgs };
+
 		const proc = Bun.spawn([command, ...args], {
 			cwd,
 			stdin: "pipe",
 			stdout: "pipe",
 			stderr: "pipe",
+			env: env ? { ...process.env, ...env } : undefined,
 		});
 
 		const client: LspClient = {

package/src/core/tools/lsp/defaults.json

@@ -4,17 +4,8 @@
 		"args": [],
 		"fileTypes": [".rs"],
 		"rootMarkers": ["Cargo.toml", "rust-analyzer.toml"],
-		"initOptions": {
-			"checkOnSave": { "command": "clippy" },
-			"cargo": { "allFeatures": true },
-			"procMacro": { "enable": true }
-		},
-		"settings": {
-			"rust-analyzer": {
-				"diagnostics": { "enable": true },
-				"inlayHints": { "enable": true }
-			}
-		},
+		"initOptions": {},
+		"settings": {},
 		"capabilities": {
 			"flycheck": true,
 			"ssr": true,

package/src/core/tools/lsp/index.ts

@@ -25,6 +25,7 @@ import {
 import { getLinterClient } from "./clients";
 import { getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config";
 import { applyTextEditsToString, applyWorkspaceEdit } from "./edits";
+import { detectLspmux } from "./lspmux";
 import { renderCall, renderResult } from "./render";
 import * as rustAnalyzer from "./rust-analyzer";
 import {
@@ -666,6 +667,7 @@ export type WritethroughCallback = (
 	content: string,
 	signal?: AbortSignal,
 	file?: BunFile,
+	batch?: LspWritethroughBatchRequest,
 ) => Promise<FileDiagnosticsResult | undefined>;
 
 /** No-op writethrough callback */
@@ -683,83 +685,241 @@ export async function writethroughNoop(
 	return undefined;
 }
 
-/** Create a writethrough callback for LSP aware write operations */
-export function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback {
-	const { enableFormat = false, enableDiagnostics = false } = options ?? {};
-	if (!enableFormat && !enableDiagnostics) {
-		return writethroughNoop;
+interface PendingWritethrough {
+	dst: string;
+	content: string;
+	file?: BunFile;
+}
+
+interface LspWritethroughBatchRequest {
+	id: string;
+	flush: boolean;
+}
+
+interface LspWritethroughBatchState {
+	entries: Map<string, PendingWritethrough>;
+	options: Required<WritethroughOptions>;
+}
+
+const writethroughBatches = new Map<string, LspWritethroughBatchState>();
+
+function getOrCreateWritethroughBatch(id: string, options: Required<WritethroughOptions>): LspWritethroughBatchState {
+	const existing = writethroughBatches.get(id);
+	if (existing) {
+		existing.options.enableFormat ||= options.enableFormat;
+		existing.options.enableDiagnostics ||= options.enableDiagnostics;
+		return existing;
+	}
+	const batch: LspWritethroughBatchState = {
+		entries: new Map<string, PendingWritethrough>(),
+		options: { ...options },
+	};
+	writethroughBatches.set(id, batch);
+	return batch;
+}
+
+function summarizeDiagnosticMessages(messages: string[]): { summary: string; errored: boolean } {
+	const counts = { error: 0, warning: 0, info: 0, hint: 0 };
+	for (const message of messages) {
+		const match = message.match(/\[(error|warning|info|hint)\]/i);
+		if (!match) continue;
+		const key = match[1].toLowerCase() as keyof typeof counts;
+		counts[key] += 1;
 	}
-	return async (dst: string, content: string, signal?: AbortSignal, file?: BunFile) => {
-		const config = await getConfig(cwd);
-		const servers = getServersForFile(config, dst);
-		if (servers.length === 0) {
-			return writethroughNoop(dst, content, signal, file);
+
+	const parts: string[] = [];
+	if (counts.error > 0) parts.push(`${counts.error} error(s)`);
+	if (counts.warning > 0) parts.push(`${counts.warning} warning(s)`);
+	if (counts.info > 0) parts.push(`${counts.info} info(s)`);
+	if (counts.hint > 0) parts.push(`${counts.hint} hint(s)`);
+
+	return {
+		summary: parts.length > 0 ? parts.join(", ") : "no issues",
+		errored: counts.error > 0,
+	};
+}
+
+function mergeDiagnostics(
+	results: Array<FileDiagnosticsResult | undefined>,
+	options: Required<WritethroughOptions>,
+): FileDiagnosticsResult | undefined {
+	const messages: string[] = [];
+	const servers = new Set<string>();
+	let hasResults = false;
+	let hasFormatter = false;
+	let formatted = false;
+
+	for (const result of results) {
+		if (!result) continue;
+		hasResults = true;
+		if (result.server) {
+			for (const server of result.server.split(",")) {
+				const trimmed = server.trim();
+				if (trimmed) {
+					servers.add(trimmed);
+				}
+			}
+		}
+		if (result.messages.length > 0) {
+			messages.push(...result.messages);
 		}
-		const { lspServers, customLinterServers } = splitServers(servers);
+		if (result.formatter !== undefined) {
+			hasFormatter = true;
+			if (result.formatter === FileFormatResult.FORMATTED) {
+				formatted = true;
+			}
+		}
+	}
 
-		let finalContent = content;
-		const writeContent = async (value: string) => (file ? file.write(value) : Bun.write(dst, value));
-		const getWritePromise = once(() => writeContent(finalContent));
-		const useCustomFormatter = enableFormat && customLinterServers.length > 0;
+	if (!hasResults && !hasFormatter) {
+		return undefined;
+	}
 
-		// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
-		const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers) : undefined;
+	let summary = options.enableDiagnostics ? "no issues" : "OK";
+	let errored = false;
+	if (messages.length > 0) {
+		const summaryInfo = summarizeDiagnosticMessages(messages);
+		summary = summaryInfo.summary;
+		errored = summaryInfo.errored;
+	}
+	const formatter = hasFormatter ? (formatted ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED) : undefined;
 
-		let formatter: FileFormatResult | undefined;
-		let diagnostics: FileDiagnosticsResult | undefined;
-		try {
-			const timeoutSignal = AbortSignal.timeout(10_000);
-			const operationSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
-			await untilAborted(operationSignal, async () => {
-				if (useCustomFormatter) {
-					// Custom linters (e.g. Biome CLI) require on-disk input.
-					await writeContent(content);
-					finalContent = await formatContent(dst, content, cwd, customLinterServers, operationSignal);
+	return {
+		server: servers.size > 0 ? Array.from(servers).join(", ") : undefined,
+		messages,
+		summary,
+		errored,
+		formatter,
+	};
+}
+
+async function runLspWritethrough(
+	dst: string,
+	content: string,
+	cwd: string,
+	options: Required<WritethroughOptions>,
+	signal?: AbortSignal,
+	file?: BunFile,
+): Promise<FileDiagnosticsResult | undefined> {
+	const { enableFormat, enableDiagnostics } = options;
+	const config = await getConfig(cwd);
+	const servers = getServersForFile(config, dst);
+	if (servers.length === 0) {
+		return writethroughNoop(dst, content, signal, file);
+	}
+	const { lspServers, customLinterServers } = splitServers(servers);
+
+	let finalContent = content;
+	const writeContent = async (value: string) => (file ? file.write(value) : Bun.write(dst, value));
+	const getWritePromise = once(() => writeContent(finalContent));
+	const useCustomFormatter = enableFormat && customLinterServers.length > 0;
+
+	// Capture diagnostic versions BEFORE syncing to detect stale diagnostics
+	const minVersions = enableDiagnostics ? await captureDiagnosticVersions(cwd, servers) : undefined;
+
+	let formatter: FileFormatResult | undefined;
+	let diagnostics: FileDiagnosticsResult | undefined;
+	try {
+		const timeoutSignal = AbortSignal.timeout(10_000);
+		const operationSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+		await untilAborted(operationSignal, async () => {
+			if (useCustomFormatter) {
+				// Custom linters (e.g. Biome CLI) require on-disk input.
+				await writeContent(content);
+				finalContent = await formatContent(dst, content, cwd, customLinterServers, operationSignal);
+				formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
+				await writeContent(finalContent);
+				await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
+			} else {
+				// 1. Sync original content to LSP servers
+				await syncFileContent(dst, content, cwd, lspServers, operationSignal);
+
+				// 2. Format in-memory via LSP
+				if (enableFormat) {
+					finalContent = await formatContent(dst, content, cwd, lspServers, operationSignal);
 					formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
-					await writeContent(finalContent);
+				}
+
+				// 3. If formatted, sync formatted content to LSP servers
+				if (finalContent !== content) {
 					await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
-				} else {
-					// 1. Sync original content to LSP servers
-					await syncFileContent(dst, content, cwd, lspServers, operationSignal);
-
-					// 2. Format in-memory via LSP
-					if (enableFormat) {
-						finalContent = await formatContent(dst, content, cwd, lspServers, operationSignal);
-						formatter = finalContent !== content ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED;
-					}
+				}
 
-					// 3. If formatted, sync formatted content to LSP servers
-					if (finalContent !== content) {
-						await syncFileContent(dst, finalContent, cwd, lspServers, operationSignal);
-					}
+				// 4. Write to disk
+				await getWritePromise();
+			}
 
-					// 4. Write to disk
-					await getWritePromise();
-				}
+			// 5. Notify saved to LSP servers
+			await notifyFileSaved(dst, cwd, lspServers, operationSignal);
 
-				// 5. Notify saved to LSP servers
-				await notifyFileSaved(dst, cwd, lspServers, operationSignal);
+			// 6. Get diagnostics from all servers (wait for fresh results)
+			if (enableDiagnostics) {
+				diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal, minVersions);
+			}
+		});
+	} catch {
+		await getWritePromise();
+	}
 
-				// 6. Get diagnostics from all servers (wait for fresh results)
-				if (enableDiagnostics) {
-					diagnostics = await getDiagnosticsForFile(dst, cwd, servers, operationSignal, minVersions);
-				}
-			});
-		} catch {
-			await getWritePromise();
+	if (formatter !== undefined) {
+		diagnostics ??= {
+			server: servers.map(([name]) => name).join(", "),
+			messages: [],
+			summary: "OK",
+			errored: false,
+		};
+		diagnostics.formatter = formatter;
+	}
+
+	return diagnostics;
+}
+
+async function flushWritethroughBatch(
+	batch: PendingWritethrough[],
+	cwd: string,
+	options: Required<WritethroughOptions>,
+	signal?: AbortSignal,
+): Promise<FileDiagnosticsResult | undefined> {
+	if (batch.length === 0) {
+		return undefined;
+	}
+	const results: Array<FileDiagnosticsResult | undefined> = [];
+	for (const entry of batch) {
+		results.push(await runLspWritethrough(entry.dst, entry.content, cwd, options, signal, entry.file));
+	}
+	return mergeDiagnostics(results, options);
+}
+
+/** Create a writethrough callback for LSP aware write operations */
+export function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback {
+	const resolvedOptions: Required<WritethroughOptions> = {
+		enableFormat: options?.enableFormat ?? false,
+		enableDiagnostics: options?.enableDiagnostics ?? false,
+	};
+	if (!resolvedOptions.enableFormat && !resolvedOptions.enableDiagnostics) {
+		return writethroughNoop;
+	}
+	return async (
+		dst: string,
+		content: string,
+		signal?: AbortSignal,
+		file?: BunFile,
+		batch?: LspWritethroughBatchRequest,
+	) => {
+		if (!batch) {
+			return runLspWritethrough(dst, content, cwd, resolvedOptions, signal, file);
 		}
 
-		if (formatter !== undefined) {
-			diagnostics ??= {
-				server: servers.map(([name]) => name).join(", "),
-				messages: [],
-				summary: "OK",
-				errored: false,
-			};
-			diagnostics.formatter = formatter;
+		const state = getOrCreateWritethroughBatch(batch.id, resolvedOptions);
+		state.entries.set(dst, { dst, content, file });
+
+		if (!batch.flush) {
+			await writethroughNoop(dst, content, signal, file);
+			return undefined;
 		}
 
-		return diagnostics;
+		writethroughBatches.delete(batch.id);
+		return flushWritethroughBatch(Array.from(state.entries.values()), cwd, state.options, signal);
 	};
 }
 
@@ -798,10 +958,19 @@ export function createLspTool(session: ToolSession): AgentTool<typeof lspSchema,
 			// Status action doesn't need a file
 			if (action === "status") {
 				const servers = Object.keys(config.servers);
-				const output =
+				const lspmuxState = await detectLspmux();
+				const lspmuxStatus = lspmuxState.available
+					? lspmuxState.running
+						? "lspmux: active (multiplexing enabled)"
+						: "lspmux: installed but server not running"
+					: "";
+
+				const serverStatus =
 					servers.length > 0
 						? `Active language servers: ${servers.join(", ")}`
 						: "No language servers configured for this project";
+
+				const output = lspmuxStatus ? `${serverStatus}\n${lspmuxStatus}` : serverStatus;
 				return {
 					content: [{ type: "text", text: output }],
 					details: { action, success: true },

package/src/core/tools/lsp/lspmux.ts

@@ -0,0 +1,249 @@
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { TOML } from "bun";
+import { logger } from "../../logger";
+
+/**
+ * lspmux integration for LSP server multiplexing.
+ *
+ * When lspmux is available and running, this module wraps supported LSP server
+ * commands to use lspmux client mode, enabling server instance sharing across
+ * multiple editor windows.
+ *
+ * Integration is transparent: if lspmux is unavailable, falls back to direct spawning.
+ */
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface LspmuxConfig {
+	instance_timeout?: number;
+	gc_interval?: number;
+	listen?: [string, number] | string;
+	connect?: [string, number] | string;
+	log_filters?: string;
+	pass_environment?: string[];
+}
+
+interface LspmuxState {
+	available: boolean;
+	running: boolean;
+	binaryPath: string | null;
+	config: LspmuxConfig | null;
+}
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+/**
+ * Servers that benefit from lspmux multiplexing.
+ *
+ * lspmux can multiplex any LSP server, but it's most beneficial for servers
+ * with high startup cost or significant memory usage.
+ */
+const DEFAULT_SUPPORTED_SERVERS = new Set([
+	"rust-analyzer",
+	// Other servers can be added after testing with lspmux
+]);
+
+/** Timeout for liveness check (ms) */
+const LIVENESS_TIMEOUT_MS = 1000;
+
+/** Cache duration for lspmux state (5 minutes) */
+const STATE_CACHE_TTL_MS = 5 * 60 * 1000;
+
+// =============================================================================
+// Config Path
+// =============================================================================
+
+/**
+ * Get the lspmux config path based on platform.
+ * Matches Rust's `dirs::config_dir()` behavior.
+ */
+function getConfigPath(): string {
+	const home = homedir();
+	switch (platform()) {
+		case "win32":
+			return join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "lspmux", "config.toml");
+		case "darwin":
+			return join(home, "Library", "Application Support", "lspmux", "config.toml");
+		default:
+			return join(process.env.XDG_CONFIG_HOME ?? join(home, ".config"), "lspmux", "config.toml");
+	}
+}
+
+// =============================================================================
+// State Management
+// =============================================================================
+
+let cachedState: LspmuxState | null = null;
+let cacheTimestamp = 0;
+
+/**
+ * Parse lspmux config.toml file.
+ */
+async function parseConfig(): Promise<LspmuxConfig | null> {
+	try {
+		const file = Bun.file(getConfigPath());
+		if (!(await file.exists())) {
+			return null;
+		}
+		return TOML.parse(await file.text()) as LspmuxConfig;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Check if lspmux server is running via `lspmux status`.
+ */
+async function checkServerRunning(binaryPath: string): Promise<boolean> {
+	try {
+		const proc = Bun.spawn([binaryPath, "status"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+
+		const exited = await Promise.race([
+			proc.exited,
+			new Promise<null>((resolve) => setTimeout(() => resolve(null), LIVENESS_TIMEOUT_MS)),
+		]);
+
+		if (exited === null) {
+			proc.kill();
+			return false;
+		}
+
+		return exited === 0;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Detect lspmux availability and state.
+ * Results are cached for STATE_CACHE_TTL_MS.
+ *
+ * Set OMP_DISABLE_LSPMUX=1 to disable.
+ */
+export async function detectLspmux(): Promise<LspmuxState> {
+	const now = Date.now();
+	if (cachedState && now - cacheTimestamp < STATE_CACHE_TTL_MS) {
+		return cachedState;
+	}
+
+	if (process.env.OMP_DISABLE_LSPMUX === "1") {
+		cachedState = { available: false, running: false, binaryPath: null, config: null };
+		cacheTimestamp = now;
+		return cachedState;
+	}
+
+	const binaryPath = Bun.which("lspmux");
+	if (!binaryPath) {
+		cachedState = { available: false, running: false, binaryPath: null, config: null };
+		cacheTimestamp = now;
+		return cachedState;
+	}
+
+	const [config, running] = await Promise.all([parseConfig(), checkServerRunning(binaryPath)]);
+
+	cachedState = { available: true, running, binaryPath, config };
+	cacheTimestamp = now;
+
+	if (running) {
+		logger.debug("lspmux detected and running", { binaryPath });
+	}
+
+	return cachedState;
+}
+
+/**
+ * Invalidate the cached lspmux state.
+ * Call this if you know the server state has changed.
+ */
+export function invalidateLspmuxCache(): void {
+	cachedState = null;
+	cacheTimestamp = 0;
+}
+
+// =============================================================================
+// Command Wrapping
+// =============================================================================
+
+/**
+ * Check if a server command is supported by lspmux.
+ */
+export function isLspmuxSupported(command: string): boolean {
+	// Extract base command name (handle full paths)
+	const baseName = command.split("/").pop() ?? command;
+	return DEFAULT_SUPPORTED_SERVERS.has(baseName);
+}
+
+export interface LspmuxWrappedCommand {
+	command: string;
+	args: string[];
+	env?: Record<string, string>;
+}
+
+/**
+ * Wrap a server command to use lspmux client mode.
+ *
+ * @param originalCommand - The original LSP server command (e.g., "rust-analyzer")
+ * @param originalArgs - Original command arguments
+ * @param state - lspmux state from detectLspmux()
+ * @returns Wrapped command, args, and env vars; or original if lspmux unavailable
+ */
+export function wrapWithLspmux(
+	originalCommand: string,
+	originalArgs: string[] | undefined,
+	state: LspmuxState,
+): LspmuxWrappedCommand {
+	if (!state.available || !state.running || !state.binaryPath) {
+		return { command: originalCommand, args: originalArgs ?? [] };
+	}
+
+	if (!isLspmuxSupported(originalCommand)) {
+		return { command: originalCommand, args: originalArgs ?? [] };
+	}
+
+	const baseName = originalCommand.split("/").pop() ?? originalCommand;
+	const isDefaultRustAnalyzer = baseName === "rust-analyzer" && originalCommand === "rust-analyzer";
+	const hasArgs = originalArgs && originalArgs.length > 0;
+
+	// rust-analyzer from $PATH with no args - lspmux's default, simplest case
+	if (isDefaultRustAnalyzer && !hasArgs) {
+		return { command: state.binaryPath, args: [] };
+	}
+
+	// Use explicit `client` subcommand with LSPMUX_SERVER env var
+	// Use `--` to separate lspmux options from server args
+	const args = hasArgs ? ["client", "--", ...originalArgs] : ["client"];
+	return {
+		command: state.binaryPath,
+		args,
+		env: { LSPMUX_SERVER: originalCommand },
+	};
+}
+
+/**
+ * Get lspmux-wrapped command if available, otherwise return original.
+ * This is the main entry point for config.ts integration.
+ *
+ * @param command - Original LSP server command
+ * @param args - Original command arguments
+ * @returns Command and args to use (possibly wrapped with lspmux)
+ */
+export async function getLspmuxCommand(command: string, args?: string[]): Promise<LspmuxWrappedCommand> {
+	const state = await detectLspmux();
+	return wrapWithLspmux(command, args, state);
+}
+
+/**
+ * Check if lspmux is currently active and usable.
+ */
+export async function isLspmuxActive(): Promise<boolean> {
+	const state = await detectLspmux();
+	return state.available && state.running;
+}

package/src/core/tools/task/executor.ts

@@ -12,6 +12,8 @@ import type { MCPManager } from "../../mcp/manager";
 import type { ModelRegistry } from "../../model-registry";
 import { checkPythonKernelAvailability } from "../../python-kernel";
 import type { ToolSession } from "..";
+import { createLspTool } from "../lsp/index";
+import type { LspParams } from "../lsp/types";
 import { createPythonTool } from "../python";
 import { ensureArtifactsDir, getArtifactPaths } from "./artifacts";
 import { resolveModelPattern } from "./model-resolver";
@@ -27,6 +29,7 @@ import {
 	TASK_SUBAGENT_PROGRESS_CHANNEL,
 } from "./types";
 import type {
+	LspToolCallRequest,
 	MCPToolCallRequest,
 	MCPToolMetadata,
 	PythonToolCallCancel,
@@ -307,6 +310,9 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		pythonProxyEnabled = availability.ok;
 	}
 
+	const lspEnabled = enableLsp ?? true;
+	const lspToolRequested = lspEnabled && (toolNames === undefined || toolNames.includes("lsp"));
+
 	let worker: Worker;
 	try {
 		worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
@@ -385,6 +391,17 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	const pythonTool = pythonProxyEnabled ? createPythonTool(pythonToolSession) : null;
 	const pythonCallControllers = new Map<string, AbortController>();
 
+	const lspToolSession: ToolSession = {
+		cwd,
+		hasUI: false,
+		enableLsp: lspEnabled,
+		getSessionFile: () => pythonSessionFile,
+		getSessionSpawns: () => spawnsEnv,
+		settings: options.settingsManager as ToolSession["settings"],
+		settingsManager: options.settingsManager,
+	};
+	const lspTool = lspToolRequested ? createLspTool(lspToolSession) : null;
+
 	// Accumulate usage incrementally from message_end events (no memory for streaming events)
 	const accumulatedUsage = {
 		input: 0,
@@ -678,12 +695,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			outputSchema,
 			sessionFile,
 			spawnsEnv,
-			enableLsp,
+			enableLsp: lspEnabled,
 			serializedAuth: options.authStorage?.serialize(),
 			serializedModels: options.modelRegistry?.serialize(),
 			serializedSettings,
 			mcpTools: options.mcpManager ? extractMCPToolMetadata(options.mcpManager) : undefined,
 			pythonToolProxy: pythonProxyEnabled,
+			lspToolProxy: Boolean(lspTool),
 		},
 	};
 
@@ -792,6 +810,40 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			}
 		};
 
+		const handleLspCall = async (request: LspToolCallRequest) => {
+			if (!lspTool) {
+				worker.postMessage({
+					type: "lsp_tool_result",
+					callId: request.callId,
+					error: "LSP proxy not available",
+				});
+				return;
+			}
+			try {
+				const result = await withTimeout(
+					lspTool.execute(request.callId, request.params as LspParams, signal),
+					request.timeoutMs,
+				);
+				worker.postMessage({
+					type: "lsp_tool_result",
+					callId: request.callId,
+					result: { content: result.content ?? [], details: result.details },
+				});
+			} catch (error) {
+				const message =
+					request.timeoutMs !== undefined && error instanceof Error && error.message.includes("timed out")
+						? `LSP tool call timed out after ${request.timeoutMs}ms`
+						: error instanceof Error
+							? error.message
+							: String(error);
+				worker.postMessage({
+					type: "lsp_tool_result",
+					callId: request.callId,
+					error: message,
+				});
+			}
+		};
+
 		const onMessage = (event: WorkerMessageEvent<SubagentWorkerResponse>) => {
 			const message = event.data;
 			if (!message || resolved) return;
@@ -807,6 +859,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				handlePythonCancel(message as PythonToolCallCancel);
 				return;
 			}
+			if (message.type === "lsp_tool_call") {
+				handleLspCall(message as LspToolCallRequest);
+				return;
+			}
 			if (message.type === "event") {
 				try {
 					processEvent(message.event);

package/src/core/tools/task/worker-protocol.ts

@@ -64,6 +64,24 @@ export interface PythonToolCallCancel {
 	reason?: string;
 }
 
+export interface LspToolCallRequest {
+	type: "lsp_tool_call";
+	callId: string;
+	params: Record<string, unknown>;
+	timeoutMs?: number;
+}
+
+export interface LspToolCallResponse {
+	type: "lsp_tool_result";
+	callId: string;
+	result?: {
+		content: Array<{ type: string; text?: string; [key: string]: unknown }>;
+		details?: unknown;
+		isError?: boolean;
+	};
+	error?: string;
+}
+
 export interface SubagentWorkerStartPayload {
 	cwd: string;
 	task: string;
@@ -80,6 +98,7 @@ export interface SubagentWorkerStartPayload {
 	serializedSettings?: Settings;
 	mcpTools?: MCPToolMetadata[];
 	pythonToolProxy?: boolean;
+	lspToolProxy?: boolean;
 }
 
 export type SubagentWorkerRequest =
@@ -87,11 +106,13 @@ export type SubagentWorkerRequest =
 	| { type: "abort" }
 	| MCPToolCallResponse
 	| PythonToolCallResponse
-	| PythonToolCallCancel;
+	| PythonToolCallCancel
+	| LspToolCallResponse;
 
 export type SubagentWorkerResponse =
 	| { type: "event"; event: AgentEvent }
 	| { type: "done"; exitCode: number; durationMs: number; error?: string; aborted?: boolean }
 	| MCPToolCallRequest
 	| PythonToolCallRequest
-	| PythonToolCallCancel;
+	| PythonToolCallCancel
+	| LspToolCallRequest;

package/src/core/tools/task/worker.ts

@@ -16,18 +16,22 @@
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
 import type { TSchema } from "@sinclair/typebox";
+import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
 import type { AgentSessionEvent } from "../../agent-session";
 import { AuthStorage } from "../../auth-storage";
 import type { CustomTool } from "../../custom-tools/types";
 import { logger } from "../../logger";
 import { ModelRegistry } from "../../model-registry";
 import { parseModelPattern, parseModelString } from "../../model-resolver";
+import { renderPromptTemplate } from "../../prompt-templates";
 import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";
 import { SessionManager } from "../../session-manager";
 import { SettingsManager } from "../../settings-manager";
 import { untilAborted } from "../../utils";
+import { type LspToolDetails, lspSchema } from "../lsp/types";
 import { getPythonToolDescription, type PythonToolDetails, type PythonToolParams, pythonSchema } from "../python";
 import type {
+	LspToolCallResponse,
 	MCPToolCallResponse,
 	MCPToolMetadata,
 	PythonToolCallResponse,
@@ -58,11 +62,19 @@ interface PendingPythonCall {
 	timeoutId?: ReturnType<typeof setTimeout>;
 }
 
+interface PendingLspCall {
+	resolve: (result: LspToolCallResponse["result"]) => void;
+	reject: (error: Error) => void;
+	timeoutId?: ReturnType<typeof setTimeout>;
+}
+
 const pendingMCPCalls = new Map<string, PendingMCPCall>();
 const pendingPythonCalls = new Map<string, PendingPythonCall>();
+const pendingLspCalls = new Map<string, PendingLspCall>();
 const MCP_CALL_TIMEOUT_MS = 60_000;
 let mcpCallIdCounter = 0;
 let pythonCallIdCounter = 0;
+let lspCallIdCounter = 0;
 
 function generateMCPCallId(): string {
 	return `mcp_${Date.now()}_${++mcpCallIdCounter}`;
@@ -72,6 +84,10 @@ function generatePythonCallId(): string {
 	return `python_${Date.now()}_${++pythonCallIdCounter}`;
 }
 
+function generateLspCallId(): string {
+	return `lsp_${Date.now()}_${++lspCallIdCounter}`;
+}
+
 function callMCPToolViaParent(
 	toolName: string,
 	params: Record<string, unknown>,
@@ -193,6 +209,65 @@ function callPythonToolViaParent(
 	});
 }
 
+function callLspToolViaParent(
+	params: Record<string, unknown>,
+	signal?: AbortSignal,
+	timeoutMs?: number,
+): Promise<LspToolCallResponse["result"]> {
+	return new Promise((resolve, reject) => {
+		const callId = generateLspCallId();
+		if (signal?.aborted) {
+			reject(new Error("Aborted"));
+			return;
+		}
+
+		const timeoutId =
+			typeof timeoutMs === "number" && Number.isFinite(timeoutMs)
+				? setTimeout(() => {
+						pendingLspCalls.delete(callId);
+						reject(new Error(`LSP call timed out after ${timeoutMs}ms`));
+					}, timeoutMs)
+				: undefined;
+
+		const cleanup = () => {
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+			}
+			pendingLspCalls.delete(callId);
+		};
+
+		if (typeof signal?.addEventListener === "function") {
+			signal.addEventListener(
+				"abort",
+				() => {
+					cleanup();
+					reject(new Error("Aborted"));
+				},
+				{ once: true },
+			);
+		}
+
+		pendingLspCalls.set(callId, {
+			resolve: (result) => {
+				cleanup();
+				resolve(result ?? { content: [] });
+			},
+			reject: (error) => {
+				cleanup();
+				reject(error);
+			},
+			timeoutId,
+		});
+
+		postMessageSafe({
+			type: "lsp_tool_call",
+			callId,
+			params,
+			timeoutMs,
+		} as SubagentWorkerResponse);
+	});
+}
+
 function handleMCPToolResult(response: MCPToolCallResponse): void {
 	const pending = pendingMCPCalls.get(response.callId);
 	if (!pending) return;
@@ -213,12 +288,24 @@ function handlePythonToolResult(response: PythonToolCallResponse): void {
 	}
 }
 
+function handleLspToolResult(response: LspToolCallResponse): void {
+	const pending = pendingLspCalls.get(response.callId);
+	if (!pending) return;
+	if (response.error) {
+		pending.reject(new Error(response.error));
+	} else {
+		pending.resolve(response.result);
+	}
+}
+
 function rejectPendingCalls(reason: string): void {
 	const error = new Error(reason);
 	const mcpCalls = Array.from(pendingMCPCalls.values());
 	const pythonCalls = Array.from(pendingPythonCalls.values());
+	const lspCalls = Array.from(pendingLspCalls.values());
 	pendingMCPCalls.clear();
 	pendingPythonCalls.clear();
+	pendingLspCalls.clear();
 	for (const pending of mcpCalls) {
 		clearTimeout(pending.timeoutId);
 		pending.reject(error);
@@ -227,6 +314,10 @@ function rejectPendingCalls(reason: string): void {
 		clearTimeout(pending.timeoutId);
 		pending.reject(error);
 	}
+	for (const pending of lspCalls) {
+		clearTimeout(pending.timeoutId);
+		pending.reject(error);
+	}
 }
 
 function createMCPProxyTool(metadata: MCPToolMetadata): CustomTool<TSchema> {
@@ -296,6 +387,40 @@ function createPythonProxyTool(): CustomTool<typeof pythonSchema> {
 	};
 }
 
+function createLspProxyTool(): CustomTool<typeof lspSchema> {
+	return {
+		name: "lsp",
+		label: "LSP",
+		description: renderPromptTemplate(lspDescription),
+		parameters: lspSchema,
+		execute: async (_toolCallId, params, _onUpdate, _ctx, signal) => {
+			try {
+				const result = await callLspToolViaParent(params as Record<string, unknown>, signal);
+				return {
+					content:
+						result?.content?.map((c) =>
+							c.type === "text"
+								? { type: "text" as const, text: c.text ?? "" }
+								: { type: "text" as const, text: JSON.stringify(c) },
+						) ?? [],
+					details: result?.details as LspToolDetails | undefined,
+				};
+			} catch (error) {
+				const { action } = params;
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `LSP error: ${error instanceof Error ? error.message : String(error)}`,
+						},
+					],
+					details: { action, success: false } as LspToolDetails,
+				};
+			}
+		},
+	};
+}
+
 interface WorkerMessageEvent<T> {
 	data: T;
 }
@@ -423,12 +548,17 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 			checkAbort();
 		}
 
-		// Create MCP/python proxy tools if provided
+		// Create MCP/python/LSP proxy tools if provided
 		const mcpProxyTools: CustomTool<TSchema>[] = payload.mcpTools?.map(createMCPProxyTool) ?? [];
 		const pythonProxyTools: CustomTool<TSchema>[] = payload.pythonToolProxy
 			? [createPythonProxyTool() as unknown as CustomTool<TSchema>]
 			: [];
-		const proxyTools = [...mcpProxyTools, ...pythonProxyTools];
+		const lspProxyTools: CustomTool<TSchema>[] = payload.lspToolProxy
+			? [createLspProxyTool() as unknown as CustomTool<TSchema>]
+			: [];
+		const proxyTools = [...mcpProxyTools, ...pythonProxyTools, ...lspProxyTools];
+		const enableLsp = payload.enableLsp ?? true;
+		const lspProxyEnabled = payload.lspToolProxy ?? false;
 
 		// Resolve model override (equivalent to CLI's parseModelPattern with --model)
 		const { model, thinkingLevel: modelThinkingLevel } = resolveModelOverride(payload.model, modelRegistry);
@@ -465,7 +595,7 @@ async function runTask(runState: RunState, payload: SubagentWorkerStartPayload):
 			hasUI: false,
 			// Pass spawn restrictions to nested tasks
 			spawns: payload.spawnsEnv,
-			enableLsp: payload.enableLsp ?? true,
+			enableLsp: enableLsp && !lspProxyEnabled,
 			// Disable local MCP discovery if using proxy tools
 			enableMCP: !payload.mcpTools,
 			// Add proxy tools
@@ -703,7 +833,7 @@ self.addEventListener("messageerror", () => {
 	reportFatal("Failed to deserialize parent message");
 });
 
-// Message handler - receives start/abort/mcp_tool_result commands from parent
+// Message handler - receives start/abort/tool_result commands from parent
 globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorkerRequest>) => {
 	const message = event.data;
 	if (!message) return;
@@ -723,6 +853,11 @@ globalThis.addEventListener("message", (event: WorkerMessageEvent<SubagentWorker
 		return;
 	}
 
+	if (message.type === "lsp_tool_result") {
+		handleLspToolResult(message);
+		return;
+	}
+
 	if (message.type === "start") {
 		// Only allow one task per worker
 		if (activeRun) return;

package/src/core/tools/write.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
@@ -22,6 +22,22 @@ export interface WriteToolDetails {
 	diagnostics?: FileDiagnosticsResult;
 }
 
+const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
+
+function getLspBatchRequest(toolCall: ToolCallContext | undefined): { id: string; flush: boolean } | undefined {
+	if (!toolCall) {
+		return undefined;
+	}
+	const hasOtherWrites = toolCall.toolCalls.some(
+		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
+	);
+	if (!hasOtherWrites) {
+		return undefined;
+	}
+	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some((call) => LSP_BATCH_TOOLS.has(call.name));
+	return { id: toolCall.batchId, flush: !hasLaterWrites };
+}
+
 export function createWriteTool(session: ToolSession): AgentTool<typeof writeSchema, WriteToolDetails> {
 	const enableLsp = session.enableLsp ?? true;
 	const enableFormat = enableLsp ? (session.settings?.getLspFormatOnWrite() ?? true) : false;
@@ -38,11 +54,14 @@ export function createWriteTool(session: ToolSession): AgentTool<typeof writeSch
 			_toolCallId: string,
 			{ path, content }: { path: string; content: string },
 			signal?: AbortSignal,
+			_onUpdate?: unknown,
+			context?: AgentToolContext,
 		) => {
 			return untilAborted(signal, async () => {
 				const absolutePath = resolveToCwd(path, session.cwd);
+				const batchRequest = getLspBatchRequest(context?.toolCall);
 
-				const diagnostics = await writethrough(absolutePath, content, signal);
+				const diagnostics = await writethrough(absolutePath, content, signal, undefined, batchRequest);
 
 				let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
 				if (!diagnostics) {