@oh-my-pi/pi-coding-agent 6.9.69 → 8.0.0

package/src/{core/python-kernel.ts → ipy/kernel.ts}

@@ -3,12 +3,12 @@ import { delimiter, join } from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import { $, type Subprocess } from "bun";
 import { nanoid } from "nanoid";
-import { getShellConfig, killProcessTree } from "../utils/shell";
-import { getOrCreateSnapshot } from "../utils/shell-snapshot";
-import { acquireSharedGateway, releaseSharedGateway } from "./python-gateway-coordinator";
-import { loadPythonModules } from "./python-modules";
-import { PYTHON_PRELUDE } from "./python-prelude";
-import { htmlToBasicMarkdown } from "./tools/web-scrapers/types";
+import { getShellConfig, killProcessTree } from "$c/utils/shell";
+import { getOrCreateSnapshot } from "$c/utils/shell-snapshot";
+import { htmlToBasicMarkdown } from "$c/web/scrapers/types";
+import { acquireSharedGateway, releaseSharedGateway } from "./gateway-coordinator";
+import { loadPythonModules } from "./modules";
+import { PYTHON_PRELUDE } from "./prelude";
 
 const TEXT_ENCODER = new TextEncoder();
 const TEXT_DECODER = new TextDecoder();
@@ -511,7 +511,7 @@ export class PythonKernel {
 
 		const externalConfig = getExternalGatewayConfig();
 		if (externalConfig) {
-			return PythonKernel.startWithExternalGateway(externalConfig, options.cwd);
+			return PythonKernel.startWithExternalGateway(externalConfig, options.cwd, options.env);
 		}
 
 		// Try shared gateway first (unless explicitly disabled)
@@ -519,7 +519,7 @@ export class PythonKernel {
 			try {
 				const sharedResult = await acquireSharedGateway(options.cwd);
 				if (sharedResult) {
-					return PythonKernel.startWithSharedGateway(sharedResult.url, options.cwd);
+					return PythonKernel.startWithSharedGateway(sharedResult.url, options.cwd, options.env);
 				}
 			} catch (err) {
 				logger.warn("Failed to acquire shared gateway, falling back to local", {
@@ -531,7 +531,11 @@ export class PythonKernel {
 		return PythonKernel.startWithLocalGateway(options);
 	}
 
-	private static async startWithExternalGateway(config: ExternalGatewayConfig, cwd: string): Promise<PythonKernel> {
+	private static async startWithExternalGateway(
+		config: ExternalGatewayConfig,
+		cwd: string,
+		env?: Record<string, string | undefined>,
+	): Promise<PythonKernel> {
 		const headers: Record<string, string> = { "Content-Type": "application/json" };
 		if (config.token) {
 			headers.Authorization = `token ${config.token}`;
@@ -554,6 +558,7 @@ export class PythonKernel {
 
 		try {
 			await kernel.connectWebSocket();
+			await kernel.initializeKernelEnvironment(cwd, env);
 			kernel.startHeartbeat();
 			const preludeResult = await kernel.execute(PYTHON_PRELUDE, { silent: true, storeHistory: false });
 			if (preludeResult.cancelled || preludeResult.status === "error") {
@@ -567,7 +572,11 @@ export class PythonKernel {
 		}
 	}
 
-	private static async startWithSharedGateway(gatewayUrl: string, cwd: string): Promise<PythonKernel> {
+	private static async startWithSharedGateway(
+		gatewayUrl: string,
+		cwd: string,
+		env?: Record<string, string | undefined>,
+	): Promise<PythonKernel> {
 		const createResponse = await fetch(`${gatewayUrl}/api/kernels`, {
 			method: "POST",
 			headers: { "Content-Type": "application/json" },
@@ -586,6 +595,7 @@ export class PythonKernel {
 
 		try {
 			await kernel.connectWebSocket();
+			await kernel.initializeKernelEnvironment(cwd, env);
 			kernel.startHeartbeat();
 			const preludeResult = await kernel.execute(PYTHON_PRELUDE, { silent: true, storeHistory: false });
 			if (preludeResult.cancelled || preludeResult.status === "error") {
@@ -702,6 +712,7 @@ export class PythonKernel {
 
 		try {
 			await kernel.connectWebSocket();
+			await kernel.initializeKernelEnvironment(options.cwd, options.env);
 			kernel.startHeartbeat();
 			const preludeResult = await kernel.execute(PYTHON_PRELUDE, { silent: true, storeHistory: false });
 			if (preludeResult.cancelled || preludeResult.status === "error") {
@@ -802,6 +813,23 @@ export class PythonKernel {
 		return promise;
 	}
 
+	private async initializeKernelEnvironment(cwd: string, env?: Record<string, string | undefined>): Promise<void> {
+		const envEntries = Object.entries(env ?? {}).filter(([, value]) => value !== undefined);
+		const envPayload = Object.fromEntries(envEntries);
+		const initScript = [
+			"import os, sys",
+			`__omp_cwd = ${JSON.stringify(cwd)}`,
+			"os.chdir(__omp_cwd)",
+			`__omp_env = ${JSON.stringify(envPayload)}`,
+			"for __omp_key, __omp_val in __omp_env.items():\n    os.environ[__omp_key] = __omp_val",
+			"if __omp_cwd not in sys.path:\n    sys.path.insert(0, __omp_cwd)",
+		].join("\n");
+		const result = await this.execute(initScript, { silent: true, storeHistory: false });
+		if (result.cancelled || result.status === "error") {
+			throw new Error("Failed to initialize Python kernel environment");
+		}
+	}
+
 	private abortPendingExecutions(reason: string): void {
 		if (this.#pendingExecutions.size === 0) return;
 		for (const cancel of this.#pendingExecutions.values()) {

package/src/{core/python-prelude.py → ipy/prelude.py}

@@ -24,14 +24,6 @@ if "__omp_prelude_loaded__" not in globals():
         _emit_status("pwd", path=str(p))
         return p
 
-    @_category("Navigation")
-    def cd(path: str | Path) -> Path:
-        """Change directory."""
-        p = Path(path).expanduser().resolve()
-        os.chdir(p)
-        _emit_status("cd", path=str(p))
-        return p
-
     @_category("Shell")
     def env(key: str | None = None, value: str | None = None):
         """Get/set environment variables."""
@@ -914,6 +906,207 @@ if "__omp_prelude_loaded__" not in globals():
         _emit_status("git_has_changes", has_changes=has_changes)
         return has_changes
 
+    @_category("Agent")
+    def output(
+        *ids: str,
+        format: str = "raw",
+        query: str | None = None,
+        offset: int | None = None,
+        limit: int | None = None,
+    ) -> str | dict | list[dict]:
+        """Read task/agent output by ID. Returns text or JSON depending on format.
+        
+        Args:
+            *ids: Output IDs to read (e.g., 'explore_0', 'reviewer_1')
+            format: 'raw' (default), 'json' (dict with metadata), 'stripped' (no ANSI)
+            query: jq-like query for JSON outputs (e.g., '.endpoints[0].file')
+            offset: Line number to start reading from (1-indexed)
+            limit: Maximum number of lines to read
+        
+        Returns:
+            Single ID: str (format='raw'/'stripped') or dict (format='json')
+            Multiple IDs: list of dict with 'id' and 'content'/'data' keys
+        
+        Examples:
+            output('explore_0')  # Read as raw text
+            output('reviewer_0', format='json')  # Read with metadata
+            output('explore_0', query='.files[0]')  # Extract JSON field
+            output('explore_0', offset=10, limit=20)  # Lines 10-29
+            output('explore_0', 'reviewer_1')  # Read multiple outputs
+        """
+        session_file = os.environ.get("OMP_SESSION_FILE")
+        if not session_file:
+            _emit_status("output", error="No session file available")
+            raise RuntimeError("No session - output artifacts unavailable")
+        
+        artifacts_dir = session_file.rsplit(".", 1)[0]  # Strip .jsonl extension
+        if not Path(artifacts_dir).exists():
+            _emit_status("output", error="Artifacts directory not found", path=artifacts_dir)
+            raise RuntimeError(f"No artifacts directory found: {artifacts_dir}")
+        
+        if not ids:
+            _emit_status("output", error="No IDs provided")
+            raise ValueError("At least one output ID is required")
+        
+        if query and (offset is not None or limit is not None):
+            _emit_status("output", error="query cannot be combined with offset/limit")
+            raise ValueError("query cannot be combined with offset/limit")
+        
+        results: list[dict] = []
+        not_found: list[str] = []
+        
+        for output_id in ids:
+            output_path = Path(artifacts_dir) / f"{output_id}.md"
+            if not output_path.exists():
+                not_found.append(output_id)
+                continue
+            
+            raw_content = output_path.read_text(encoding="utf-8")
+            raw_lines = raw_content.splitlines()
+            total_lines = len(raw_lines)
+            
+            selected_content = raw_content
+            range_info: dict | None = None
+            
+            # Handle query
+            if query:
+                try:
+                    json_value = json.loads(raw_content)
+                except json.JSONDecodeError as e:
+                    _emit_status("output", id=output_id, error=f"Not valid JSON: {e}")
+                    raise ValueError(f"Output {output_id} is not valid JSON: {e}")
+                
+                # Apply jq-like query
+                result_value = _apply_query(json_value, query)
+                try:
+                    selected_content = json.dumps(result_value, indent=2) if result_value is not None else "null"
+                except (TypeError, ValueError):
+                    selected_content = str(result_value)
+            
+            # Handle offset/limit
+            elif offset is not None or limit is not None:
+                start_line = max(1, offset or 1)
+                if start_line > total_lines:
+                    _emit_status("output", id=output_id, error=f"Offset {start_line} beyond end ({total_lines} lines)")
+                    raise ValueError(f"Offset {start_line} is beyond end of output ({total_lines} lines) for {output_id}")
+                
+                effective_limit = limit if limit is not None else total_lines - start_line + 1
+                end_line = min(total_lines, start_line + effective_limit - 1)
+                selected_lines = raw_lines[start_line - 1 : end_line]
+                selected_content = "\n".join(selected_lines)
+                range_info = {"start_line": start_line, "end_line": end_line, "total_lines": total_lines}
+            
+            # Strip ANSI codes if requested
+            if format == "stripped":
+                import re
+                selected_content = re.sub(r"\x1b\[[0-9;]*m", "", selected_content)
+            
+            # Build result
+            if format == "json":
+                result_data = {
+                    "id": output_id,
+                    "path": str(output_path),
+                    "line_count": total_lines if not query else len(selected_content.splitlines()),
+                    "char_count": len(raw_content) if not query else len(selected_content),
+                    "content": selected_content,
+                }
+                if range_info:
+                    result_data["range"] = range_info
+                if query:
+                    result_data["query"] = query
+                results.append(result_data)
+            else:
+                results.append({"id": output_id, "content": selected_content})
+        
+        # Handle not found
+        if not_found:
+            available = sorted(
+                [f.stem for f in Path(artifacts_dir).glob("*.md")]
+            )
+            error_msg = f"Output not found: {', '.join(not_found)}"
+            if available:
+                error_msg += f"\n\nAvailable outputs: {', '.join(available[:20])}"
+                if len(available) > 20:
+                    error_msg += f" (and {len(available) - 20} more)"
+            _emit_status("output", not_found=not_found, available_count=len(available))
+            raise FileNotFoundError(error_msg)
+        
+        # Return format
+        if len(ids) == 1:
+            if format == "json":
+                _emit_status("output", id=ids[0], chars=results[0]["char_count"])
+                return results[0]
+            _emit_status("output", id=ids[0], chars=len(results[0]["content"]))
+            return results[0]["content"]
+        
+        # Multiple IDs
+        if format == "json":
+            total_chars = sum(r["char_count"] for r in results)
+            _emit_status("output", count=len(results), total_chars=total_chars)
+            return results
+        
+        combined_output: list[dict] = []
+        for r in results:
+            combined_output.append({"id": r["id"], "content": r["content"]})
+        total_chars = sum(len(r["content"]) for r in combined_output)
+        _emit_status("output", count=len(combined_output), total_chars=total_chars)
+        return combined_output
+
+    def _apply_query(data: any, query: str) -> any:
+        """Apply jq-like query to data. Supports .key, [index], and chaining."""
+        if not query:
+            return data
+        
+        query = query.strip()
+        if query.startswith("."):
+            query = query[1:]
+        if not query:
+            return data
+        
+        # Parse query into tokens
+        tokens = []
+        current_token = ""
+        i = 0
+        while i < len(query):
+            ch = query[i]
+            if ch == ".":
+                if current_token:
+                    tokens.append(("key", current_token))
+                    current_token = ""
+            elif ch == "[":
+                if current_token:
+                    tokens.append(("key", current_token))
+                    current_token = ""
+                # Find matching ]
+                j = i + 1
+                while j < len(query) and query[j] != "]":
+                    j += 1
+                bracket_content = query[i+1:j]
+                if bracket_content.startswith('"') and bracket_content.endswith('"'):
+                    tokens.append(("key", bracket_content[1:-1]))
+                else:
+                    tokens.append(("index", int(bracket_content)))
+                i = j
+            else:
+                current_token += ch
+            i += 1
+        if current_token:
+            tokens.append(("key", current_token))
+        
+        # Apply tokens
+        current = data
+        for token_type, value in tokens:
+            if token_type == "index":
+                if not isinstance(current, list) or value >= len(current):
+                    return None
+                current = current[value]
+            elif token_type == "key":
+                if not isinstance(current, dict) or value not in current:
+                    return None
+                current = current[value]
+        
+        return current
+
     def __omp_prelude_docs__() -> list[dict[str, str]]:
         """Return prelude helper docs for templating. Discovers functions by _omp_category attribute."""
         helpers: list[dict[str, str]] = []

package/src/ipy/prelude.ts

@@ -0,0 +1,3 @@
+import pythonPrelude from "./prelude.py" with { type: "text" };
+
+export const PYTHON_PRELUDE = pythonPrelude;

package/src/{core/tools/lsp → lsp}/client.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import { logger } from "@oh-my-pi/pi-utils";
+import { ToolAbortError, throwIfAborted } from "$c/tools/tool-errors";
 import { applyWorkspaceEdit } from "./edits";
 import { getLspmuxCommand, isLspmuxSupported } from "./lspmux";
 import type {
@@ -547,7 +548,7 @@ export async function syncContent(
 ): Promise<void> {
 	const uri = fileToUri(filePath);
 	const lockKey = `${client.name}:${uri}`;
-	signal?.throwIfAborted();
+	throwIfAborted(signal);
 
 	const existingLock = fileOperationLocks.get(lockKey);
 	if (existingLock) {
@@ -563,7 +564,7 @@ export async function syncContent(
 		if (!info) {
 			// Open file with provided content instead of reading from disk
 			const languageId = detectLanguageId(filePath);
-			signal?.throwIfAborted();
+			throwIfAborted(signal);
 			await sendNotification(client, "textDocument/didOpen", {
 				textDocument: {
 					uri,
@@ -578,7 +579,7 @@ export async function syncContent(
 		}
 
 		const version = ++info.version;
-		signal?.throwIfAborted();
+		throwIfAborted(signal);
 		await sendNotification(client, "textDocument/didChange", {
 			textDocument: { uri, version },
 			contentChanges: [{ text: content }],
@@ -603,7 +604,7 @@ export async function notifySaved(client: LspClient, filePath: string, signal?:
 	const info = client.openFiles.get(uri);
 	if (!info) return; // File not open, nothing to notify
 
-	signal?.throwIfAborted();
+	throwIfAborted(signal);
 	await sendNotification(client, "textDocument/didSave", {
 		textDocument: { uri },
 	});
@@ -698,7 +699,7 @@ export async function sendRequest(
 	// Atomically increment and capture request ID
 	const id = ++client.requestId;
 	if (signal?.aborted) {
-		const reason = signal.reason instanceof Error ? signal.reason : new Error("Operation aborted");
+		const reason = signal.reason instanceof Error ? signal.reason : new ToolAbortError();
 		return Promise.reject(reason);
 	}
 
@@ -724,7 +725,7 @@ export async function sendRequest(
 		}
 		if (timeout) clearTimeout(timeout);
 		cleanup();
-		const reason = signal?.reason instanceof Error ? signal.reason : new Error("Operation aborted");
+		const reason = signal?.reason instanceof Error ? signal.reason : new ToolAbortError();
 		reject(reason);
 	};
 

package/src/{core/tools/lsp → lsp}/clients/biome-client.ts

@@ -4,7 +4,7 @@
  */
 
 import path from "node:path";
-import type { Diagnostic, DiagnosticSeverity, LinterClient, ServerConfig } from "../types";
+import type { Diagnostic, DiagnosticSeverity, LinterClient, ServerConfig } from "$c/lsp/types";
 
 // =============================================================================
 // Biome JSON Output Types

package/src/{core/tools/lsp → lsp}/clients/index.ts

@@ -8,7 +8,7 @@
 export { BiomeClient } from "./biome-client";
 export { LspLinterClient } from "./lsp-linter-client";
 
-import type { LinterClient, ServerConfig } from "../types";
+import type { LinterClient, ServerConfig } from "$c/lsp/types";
 import { LspLinterClient } from "./lsp-linter-client";
 
 // Cache of linter clients by server name + cwd

package/src/{core/tools/lsp → lsp}/clients/lsp-linter-client.ts

@@ -3,10 +3,10 @@
  * Uses the Language Server Protocol for formatting and diagnostics.
  */
 
-import { getOrCreateClient, notifySaved, sendRequest, syncContent } from "../client";
-import { applyTextEditsToString } from "../edits";
-import type { Diagnostic, LinterClient, LspClient, ServerConfig, TextEdit } from "../types";
-import { fileToUri } from "../utils";
+import { getOrCreateClient, notifySaved, sendRequest, syncContent } from "$c/lsp/client";
+import { applyTextEditsToString } from "$c/lsp/edits";
+import type { Diagnostic, LinterClient, LspClient, ServerConfig, TextEdit } from "$c/lsp/types";
+import { fileToUri } from "$c/lsp/utils";
 
 /** Default formatting options for LSP */
 const DEFAULT_FORMAT_OPTIONS = {

package/src/{core/tools/lsp → lsp}/config.ts

@@ -3,7 +3,7 @@ import { basename, extname, join } from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { globSync } from "glob";
-import { getConfigDirPaths } from "../../../config";
+import { getConfigDirPaths } from "$c/config";
 import { BiomeClient } from "./clients/biome-client";
 import DEFAULTS from "./defaults.json" with { type: "json" };
 import type { ServerConfig } from "./types";

package/src/{core/tools/lsp → lsp}/index.ts

@@ -4,11 +4,12 @@ import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { logger, once, untilAborted } from "@oh-my-pi/pi-utils";
 import type { BunFile } from "bun";
-import { type Theme, theme } from "../../../modes/interactive/theme/theme";
-import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
-import { renderPromptTemplate } from "../../prompt-templates";
-import type { ToolSession } from "../index";
-import { resolveToCwd } from "../path-utils";
+import { renderPromptTemplate } from "$c/config/prompt-templates";
+import { type Theme, theme } from "$c/modes/theme/theme";
+import lspDescription from "$c/prompts/tools/lsp.md" with { type: "text" };
+import type { ToolSession } from "$c/tools/index";
+import { resolveToCwd } from "$c/tools/path-utils";
+import { throwIfAborted } from "$c/tools/tool-errors";
 import {
 	ensureFileOpen,
 	getActiveClients,
@@ -152,15 +153,15 @@ async function syncFileContent(
 	servers: Array<[string, ServerConfig]>,
 	signal?: AbortSignal,
 ): Promise<void> {
-	signal?.throwIfAborted();
+	throwIfAborted(signal);
 	await Promise.allSettled(
 		servers.map(async ([_serverName, serverConfig]) => {
-			signal?.throwIfAborted();
+			throwIfAborted(signal);
 			if (serverConfig.createClient) {
 				return;
 			}
 			const client = await getOrCreateClient(serverConfig, cwd);
-			signal?.throwIfAborted();
+			throwIfAborted(signal);
 			await syncContent(client, absolutePath, content, signal);
 		}),
 	);
@@ -180,10 +181,10 @@ async function notifyFileSaved(
 	servers: Array<[string, ServerConfig]>,
 	signal?: AbortSignal,
 ): Promise<void> {
-	signal?.throwIfAborted();
+	throwIfAborted(signal);
 	await Promise.allSettled(
 		servers.map(async ([_serverName, serverConfig]) => {
-			signal?.throwIfAborted();
+			throwIfAborted(signal);
 			if (serverConfig.createClient) {
 				return;
 			}
@@ -243,6 +244,14 @@ function getLspServerForFile(config: LspConfig, filePath: string): [string, Serv
 
 const FILE_SEARCH_MAX_DEPTH = 5;
 const IGNORED_DIRS = new Set(["node_modules", "target", "dist", "build", ".git"]);
+const DIAGNOSTIC_MESSAGE_LIMIT = 50;
+
+function limitDiagnosticMessages(messages: string[]): string[] {
+	if (messages.length <= DIAGNOSTIC_MESSAGE_LIMIT) {
+		return messages;
+	}
+	return messages.slice(0, DIAGNOSTIC_MESSAGE_LIMIT);
+}
 
 function findFileByExtensions(baseDir: string, extensions: string[], maxDepth: number): string | null {
 	const normalized = extensions.map((ext) => ext.toLowerCase());
@@ -334,7 +343,7 @@ async function waitForDiagnostics(
 ): Promise<Diagnostic[]> {
 	const start = Date.now();
 	while (Date.now() - start < timeoutMs) {
-		signal?.throwIfAborted();
+		throwIfAborted(signal);
 		const diagnostics = client.diagnostics.get(uri);
 		const versionOk = minVersion === undefined || client.diagnosticsVersion > minVersion;
 		if (diagnostics !== undefined && versionOk) return diagnostics;
@@ -513,7 +522,7 @@ async function getDiagnosticsForFile(
 	// Wait for diagnostics from all servers in parallel
 	const results = await Promise.allSettled(
 		servers.map(async ([serverName, serverConfig]) => {
-			signal?.throwIfAborted();
+			throwIfAborted(signal);
 			// Use custom linter client if configured
 			if (serverConfig.createClient) {
 				const linterClient = getLinterClient(serverName, serverConfig, cwd);
@@ -523,7 +532,7 @@ async function getDiagnosticsForFile(
 
 			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
-			signal?.throwIfAborted();
+			throwIfAborted(signal);
 			// Content already synced + didSave sent, wait for fresh diagnostics
 			const minVersion = minVersions?.get(serverName);
 			const diagnostics = await waitForDiagnostics(client, uri, 3000, signal, minVersion);
@@ -563,12 +572,13 @@ async function getDiagnosticsForFile(
 	}
 
 	const formatted = uniqueDiagnostics.map((d) => formatDiagnostic(d, relPath));
+	const limited = limitDiagnosticMessages(formatted);
 	const summary = formatDiagnosticsSummary(uniqueDiagnostics);
 	const hasErrors = uniqueDiagnostics.some((d) => d.severity === 1);
 
 	return {
 		server: serverNames.join(", "),
-		messages: formatted,
+		messages: limited,
 		summary,
 		errored: hasErrors,
 	};
@@ -612,7 +622,7 @@ async function formatContent(
 
 	for (const [serverName, serverConfig] of servers) {
 		try {
-			signal?.throwIfAborted();
+			throwIfAborted(signal);
 			// Use custom linter client if configured
 			if (serverConfig.createClient) {
 				const linterClient = getLinterClient(serverName, serverConfig, cwd);
@@ -621,7 +631,7 @@ async function formatContent(
 
 			// Default: use LSP
 			const client = await getOrCreateClient(serverConfig, cwd);
-			signal?.throwIfAborted();
+			throwIfAborted(signal);
 
 			const caps = client.serverCapabilities;
 			if (!caps?.documentFormattingProvider) {
@@ -788,16 +798,18 @@ function mergeDiagnostics(
 
 	let summary = options.enableDiagnostics ? "no issues" : "OK";
 	let errored = false;
+	let limitedMessages = messages;
 	if (messages.length > 0) {
 		const summaryInfo = summarizeDiagnosticMessages(messages);
 		summary = summaryInfo.summary;
 		errored = summaryInfo.errored;
+		limitedMessages = limitDiagnosticMessages(messages);
 	}
 	const formatter = hasFormatter ? (formatted ? FileFormatResult.FORMATTED : FileFormatResult.UNCHANGED) : undefined;
 
 	return {
 		server: servers.size > 0 ? Array.from(servers).join(", ") : undefined,
-		messages,
+		messages: limitedMessages,
 		summary,
 		errored,
 		formatter,

package/src/{core/tools/lsp → lsp}/render.ts

@@ -11,8 +11,8 @@
 import type { AgentToolResult, RenderResultOptions } from "@oh-my-pi/pi-agent-core";
 import { Text } from "@oh-my-pi/pi-tui";
 import { highlight, supportsLanguage } from "cli-highlight";
-import { getLanguageFromPath, type Theme } from "../../../modes/interactive/theme/theme";
-import { formatExpandHint, formatMoreItems, TRUNCATE_LENGTHS, truncate } from "../render-utils";
+import { getLanguageFromPath, type Theme } from "$c/modes/theme/theme";
+import { formatExpandHint, formatMoreItems, TRUNCATE_LENGTHS, truncate } from "$c/tools/render-utils";
 import type { LspParams, LspToolDetails } from "./types";
 
 // =============================================================================

package/src/{core/tools/lsp → lsp}/types.ts

@@ -30,23 +30,21 @@ export const lspSchema = Type.Object({
 			"related_tests",
 			"reload_workspace",
 		],
-		{ description: "LSP action to perform" },
-	),
-	files: Type.Optional(Type.Array(Type.String({ description: "File paths for diagnostics" }))),
-	file: Type.Optional(Type.String({ description: "File path for file-specific actions" })),
-	line: Type.Optional(Type.Number({ description: "1-based line number" })),
-	column: Type.Optional(Type.Number({ description: "1-based column number" })),
-	end_line: Type.Optional(Type.Number({ description: "1-based end line number for ranges" })),
-	end_character: Type.Optional(Type.Number({ description: "1-based end column number for ranges" })),
-	query: Type.Optional(Type.String({ description: "Search query for symbols/SSR pattern" })),
-	new_name: Type.Optional(Type.String({ description: "New name for rename action" })),
-	replacement: Type.Optional(Type.String({ description: "Replacement for SSR action" })),
-	kind: Type.Optional(Type.String({ description: "Code action kind filter (quickfix, refactor, source)" })),
-	apply: Type.Optional(Type.Boolean({ description: "Apply edits instead of preview (default: true)" })),
-	action_index: Type.Optional(Type.Number({ description: "Index of code action to apply" })),
-	include_declaration: Type.Optional(
-		Type.Boolean({ description: "Include declaration in references (default: true)" }),
+		{ description: "LSP operation" },
 	),
+	files: Type.Optional(Type.Array(Type.String({ description: "File path" }))),
+	file: Type.Optional(Type.String({ description: "File path" })),
+	line: Type.Optional(Type.Number({ description: "Line number (1-indexed)" })),
+	column: Type.Optional(Type.Number({ description: "Column number (1-indexed)" })),
+	end_line: Type.Optional(Type.Number({ description: "End line for range (1-indexed)" })),
+	end_character: Type.Optional(Type.Number({ description: "End column for range (1-indexed)" })),
+	query: Type.Optional(Type.String({ description: "Search query or SSR pattern" })),
+	new_name: Type.Optional(Type.String({ description: "New name for rename" })),
+	replacement: Type.Optional(Type.String({ description: "Replacement text for SSR" })),
+	kind: Type.Optional(Type.String({ description: "Action kind: quickfix, refactor, source" })),
+	apply: Type.Optional(Type.Boolean({ description: "Apply edits (default: true)" })),
+	action_index: Type.Optional(Type.Number({ description: "Index of action to apply" })),
+	include_declaration: Type.Optional(Type.Boolean({ description: "Include declaration in refs (default: true)" })),
 });
 
 export type LspParams = Static<typeof lspSchema>;

package/src/{core/tools/lsp → lsp}/utils.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { type Theme, theme } from "../../../modes/interactive/theme/theme";
+import { type Theme, theme } from "$c/modes/theme/theme";
 import type {
 	Diagnostic,
 	DiagnosticSeverity,