@oh-my-pi/pi-coding-agent 17.1.8 → 17.2.1

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -17,6 +17,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type AuthCredential, SqliteAuthCredentialStore, type TSchema } from "@oh-my-pi/pi-ai";
+import { piEscapeRegexLiteral, piJoinPath } from "@oh-my-pi/pi-ai/providers/cursor-pi-args";
 import { getKeybindings, type Keybinding, Text } from "@oh-my-pi/pi-tui";
 import {
 	getAgentDbPath,
@@ -139,6 +140,25 @@ export interface LsToolOptions {
 	operations?: LsOperations;
 }
 
+export interface EditOperations {
+	readFile: (absolutePath: string) => Promise<Buffer>;
+	writeFile: (absolutePath: string, content: string) => Promise<void>;
+	access: (absolutePath: string) => Promise<void>;
+}
+
+export interface EditToolOptions {
+	operations?: EditOperations;
+}
+
+export interface WriteOperations {
+	writeFile: (absolutePath: string, content: string) => Promise<void>;
+	mkdir: (dir: string) => Promise<void>;
+}
+
+export interface WriteToolOptions {
+	operations?: WriteOperations;
+}
+
 const legacyBashSchema = Type.Object({
 	command: Type.String({ description: "Bash command to execute" }),
 	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds" })),
@@ -298,16 +318,6 @@ function lineRangePath(readPath: string, offset: number | undefined, limit: numb
 	return `${readPath}:${start}-${end}`;
 }
 
-function escapeRegexLiteral(value: string): string {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function joinLegacyGlob(searchPath: string, pattern: string): string {
-	if (path.isAbsolute(pattern)) return pattern;
-	if (!searchPath || searchPath === ".") return pattern;
-	return path.join(searchPath, pattern);
-}
-
 function normalizeLegacyLimit(limit: number | undefined, fallback: number): number {
 	if (limit === undefined || !Number.isFinite(limit)) return fallback;
 	return Math.max(1, Math.floor(limit));
@@ -512,7 +522,7 @@ export function createGrepToolDefinition(cwd: string, options?: GrepToolOptions)
 		renderResult: legacyRenderResult,
 		execute: (toolCallId, params, signal, onUpdate) => {
 			const rawPattern = stringField(params, "pattern") ?? "";
-			const pattern = booleanField(params, "literal") ? escapeRegexLiteral(rawPattern) : rawPattern;
+			const pattern = booleanField(params, "literal") ? piEscapeRegexLiteral(rawPattern) : rawPattern;
 			const searchPath = stringField(params, "path") ?? ".";
 			const glob = stringField(params, "glob");
 			const context = numberField(params, "context");
@@ -529,7 +539,7 @@ export function createGrepToolDefinition(cwd: string, options?: GrepToolOptions)
 				toolCallId,
 				{
 					pattern,
-					path: glob ? joinLegacyGlob(searchPath, glob) : searchPath,
+					path: glob ? piJoinPath(searchPath, glob) : searchPath,
 					case: booleanField(params, "ignoreCase") ? false : undefined,
 				},
 				signal,
@@ -587,7 +597,7 @@ export function createFindToolDefinition(cwd: string, options?: FindToolOptions)
 			}
 			return tool.execute(
 				toolCallId,
-				{ path: joinLegacyGlob(searchPath, pattern), hidden: true, gitignore: true, limit },
+				{ path: piJoinPath(searchPath, pattern), hidden: true, gitignore: true, limit },
 				signal,
 				onUpdate,
 			);
@@ -645,6 +655,40 @@ export function createLsTool(cwd: string, options?: LsToolOptions): ToolDefiniti
 	return createLsToolDefinition(cwd, options);
 }
 
+/** Create the legacy edit tool definition. */
+export function createEditToolDefinition(cwd: string, options?: EditToolOptions): ToolDefinition {
+	if (options?.operations) {
+		throw new Error(
+			"Legacy EditToolOptions.operations is not supported: OMP's built-in edit tool writes the local " +
+				"filesystem natively and exposes no pluggable operations seam. Register a custom edit tool via " +
+				"defineTool() instead of passing operations to createEditTool()/createEditToolDefinition().",
+		);
+	}
+	return legacyBuiltinTool(cwd, "edit");
+}
+
+/** Create the legacy edit tool. */
+export function createEditTool(cwd: string, options?: EditToolOptions): ToolDefinition {
+	return createEditToolDefinition(cwd, options);
+}
+
+/** Create the legacy write tool definition. */
+export function createWriteToolDefinition(cwd: string, options?: WriteToolOptions): ToolDefinition {
+	if (options?.operations) {
+		throw new Error(
+			"Legacy WriteToolOptions.operations is not supported: OMP's built-in write tool writes the local " +
+				"filesystem natively and exposes no pluggable operations seam. Register a custom write tool via " +
+				"defineTool() instead of passing operations to createWriteTool()/createWriteToolDefinition().",
+		);
+	}
+	return legacyBuiltinTool(cwd, "write");
+}
+
+/** Create the legacy write tool. */
+export function createWriteTool(cwd: string, options?: WriteToolOptions): ToolDefinition {
+	return createWriteToolDefinition(cwd, options);
+}
+
 /** Create legacy read, bash, edit, and write tools. */
 export function createCodingTools(cwd: string): ToolDefinition[] {
 	return LEGACY_CODING_TOOL_NAMES.map(name => legacyBuiltinTool(cwd, name));
@@ -1378,6 +1422,14 @@ export function getPackageDir(): string {
 // check during validation (issue #6583).
 export { estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
 
+// Same barrel gap for two more legacy package-root exports: pi re-exported the
+// `CONFIG_DIR_NAME` constant and the CLI parser `parseArgs`. In omp
+// `CONFIG_DIR_NAME` lives in `@oh-my-pi/pi-utils` and `parseArgs` in
+// `../cli/args`, neither of which the barrel below forwards, so legacy
+// extensions importing either fail Bun's static export check during validation.
+export { CONFIG_DIR_NAME } from "@oh-my-pi/pi-utils";
+export { parseArgs } from "../cli/args";
+
 export * from "../index";
 export { formatBytes as formatSize } from "../tools/render-utils";
 export { copyToClipboard } from "../utils/clipboard";

package/src/internal-urls/index.ts

@@ -20,6 +20,7 @@ export * from "./omp-protocol";
 export * from "./parse";
 export * from "./router";
 export * from "./rule-protocol";
+export * from "./security-protocol";
 export * from "./skill-protocol";
 export * from "./ssh-protocol";
 export type * from "./types";

package/src/internal-urls/local-protocol.ts

@@ -390,8 +390,9 @@ export class LocalProtocolHandler implements ProtocolHandler {
 
 	/**
 	 * Install a process-global override that wins over the AgentRegistry-based
-	 * derivation. Used by SDK consumers that wire `localProtocolOptions` on
-	 * `createAgentSession` and by subagents that share their parent's root.
+	 * derivation. Used by top-level SDK consumers that wire
+	 * `localProtocolOptions` on `createAgentSession`; subagents keep their
+	 * inherited mapping session-bound.
 	 */
 	static setOverride(value: LocalProtocolOptions | undefined): void {
 		LocalProtocolHandler.#override = value;

package/src/internal-urls/mcp-protocol.ts

@@ -97,7 +97,10 @@ function formatAvailableResources(mcpManager: MCPManager): string {
 		.getConnectedServers()
 		.flatMap(name => {
 			const serverResources = mcpManager.getServerResources(name);
-			return (serverResources?.resources ?? []).map(r => `  ${r.uri} (${name})`);
+			if (!serverResources) return [];
+			const concrete = serverResources.resources.map(r => `  ${r.uri} (${name})`);
+			const templates = serverResources.templates.map(t => `  ${t.uriTemplate} (${name}, template)`);
+			return [...concrete, ...templates];
 		})
 		.join("\n");
 	return available || "  (none)";

package/src/internal-urls/router.ts

@@ -1,5 +1,5 @@
 /**
- * Internal URL router for internal protocols (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, `ssh://`, `vault://`, and `xd://`).
+ * Internal URL router for internal protocols (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `security://`, `skill://`, `ssh://`, `vault://`, and `xd://`).
  *
  * One process-global router with one handler per scheme. Access via
  * `InternalUrlRouter.instance()`. Handlers are stateless; per-session and
@@ -15,6 +15,7 @@ import { MemoryProtocolHandler } from "./memory-protocol";
 import { OmpProtocolHandler } from "./omp-protocol";
 import { extractUriScheme, parseInternalUrl } from "./parse";
 import { RuleProtocolHandler } from "./rule-protocol";
+import { SecurityProtocolHandler } from "./security-protocol";
 import { SkillProtocolHandler } from "./skill-protocol";
 import { SshProtocolHandler } from "./ssh-protocol";
 import type {
@@ -42,6 +43,8 @@ export class InternalUrlRouter {
 		this.register(new VaultProtocolHandler());
 		this.register(new SkillProtocolHandler());
 		this.register(new RuleProtocolHandler());
+		// Reserved OMP-owned security-analysis namespace; vendor adapters normalize into its store.
+		this.register(new SecurityProtocolHandler());
 		this.register(new McpProtocolHandler());
 		this.register(new IssueProtocolHandler());
 		this.register(new PrProtocolHandler());

package/src/internal-urls/security-protocol.ts

@@ -0,0 +1,261 @@
+import * as path from "node:path";
+import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { isSettingsInitialized, settings } from "../config/settings";
+import { getDefault } from "../config/settings-schema";
+import type { SecurityFinding } from "../security/contracts";
+import { createPublicSecurityScan, redactPrivateSecurityMetadata } from "../security/provenance";
+import { createSecurityResource } from "../security/resource-output";
+import type { SecurityScanSummary } from "../security/store";
+import { SecurityStore } from "../security/store";
+import type { InternalResource, InternalUrl, ProtocolHandler, ResolveContext, UrlCompletion } from "./types";
+
+export type SecurityStoreResolver = (cwd: string, signal?: AbortSignal) => Promise<SecurityStore>;
+
+export function isSecurityEnabled(): boolean {
+	if (!isSettingsInitialized()) return getDefault("security.enabled");
+	try {
+		return settings.get("security.enabled");
+	} catch {
+		return getDefault("security.enabled");
+	}
+}
+
+function securityEnabledFromContext(context?: ResolveContext): boolean | undefined {
+	if (!context?.settings || typeof context.settings !== "object") return undefined;
+	try {
+		const get = Reflect.get(context.settings, "get");
+		if (typeof get !== "function") return undefined;
+		const enabled = Reflect.apply(get, context.settings, ["security.enabled"]);
+		return typeof enabled === "boolean" ? enabled : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+const SECURITY_DISABLED_MESSAGE =
+	"security:// is disabled. Enable it by setting `security.enabled = true` (Settings → Tools → Security).";
+
+export class SecurityDisabledError extends Error {
+	constructor() {
+		super(SECURITY_DISABLED_MESSAGE);
+		this.name = "SecurityDisabledError";
+	}
+}
+
+function splitSecurityPath(url: InternalUrl): string[] {
+	const host = url.rawHost || url.hostname;
+	const pathname = (url.rawPathname ?? url.pathname).replace(/^\/+/, "");
+	return [host, ...pathname.split("/")].filter(Boolean).map(segment => decodeURIComponent(segment));
+}
+
+function formatScans(scans: SecurityScanSummary[]): string {
+	if (scans.length === 0) return "# Security scans\n\nNo scans are stored for this project.\n";
+	const rows = scans.map(
+		scan =>
+			`- \`${scan.id}\` — ${scan.status}; ${scan.findingCount} finding(s); ${scan.producer.name}; ${scan.createdAt}`,
+	);
+	return `# Security scans\n\n${rows.join("\n")}\n`;
+}
+
+function formatFinding(finding: SecurityFinding): string {
+	const locations = finding.occurrences.flatMap(occurrence => occurrence.locations);
+	const locationLines = locations.map(location => {
+		const end = location.endLine && location.endLine !== location.startLine ? `-${location.endLine}` : "";
+		return [
+			`- \`${sanitizeText(location.path)}:${location.startLine}${end}\``,
+			location.role ? ` (${sanitizeText(location.role)})` : "",
+		].join("");
+	});
+	const evidence = finding.evidence.map(
+		item => `- **${sanitizeText(item.label)}** — ${sanitizeText(item.explanation)}`,
+	);
+	return [
+		`# ${sanitizeText(finding.title)}`,
+		"",
+		`- ID: \`${finding.id}\``,
+		`- Rule: \`${sanitizeText(finding.ruleId)}\``,
+		`- Severity: **${finding.severity.level}**`,
+		`- Confidence: **${finding.confidence.level}**`,
+		`- Disposition: **${finding.disposition.status}**`,
+		`- Fingerprint: \`${finding.fingerprint}\``,
+		"",
+		"## Summary",
+		"",
+		sanitizeText(finding.summary),
+		"",
+		"## Locations",
+		"",
+		...(locationLines.length > 0 ? locationLines : ["No source locations recorded."]),
+		"",
+		"## Evidence",
+		"",
+		...(evidence.length > 0 ? evidence : ["No expanded evidence recorded."]),
+		"",
+		"## Remediation",
+		"",
+		sanitizeText(finding.remediation ?? "No remediation guidance recorded."),
+		"",
+	].join("\n");
+}
+
+export class SecurityProtocolHandler implements ProtocolHandler {
+	readonly scheme = "security";
+	readonly immutable = true;
+	readonly #resolveStore: SecurityStoreResolver;
+	readonly #enabled: () => boolean;
+
+	constructor(
+		resolveStore: SecurityStoreResolver = (cwd, signal) => SecurityStore.openForCwd(cwd, { signal }),
+		enabled: () => boolean = isSecurityEnabled,
+	) {
+		this.#resolveStore = resolveStore;
+		this.#enabled = enabled;
+	}
+
+	async #store(context?: ResolveContext): Promise<SecurityStore> {
+		return this.#resolveStore(path.resolve(context?.cwd ?? process.cwd()), context?.signal);
+	}
+
+	async resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource> {
+		if (!(securityEnabledFromContext(context) ?? this.#enabled())) throw new SecurityDisabledError();
+		const parts = splitSecurityPath(url);
+		const store = await this.#store(context);
+		if (parts.length === 0) {
+			return createSecurityResource({
+				url: "security://",
+				content: [
+					"# Security",
+					"",
+					"OMP-owned software-security analysis resources. The namespace is read-only; use explicit security commands or tools for mutations.",
+					"",
+					"- `security://scans` — list scans",
+					"",
+				].join("\n"),
+				contentType: "text/markdown",
+				isDirectory: true,
+			});
+		}
+		if (parts[0] !== "scans") throw new Error(`Unknown security resource: security://${parts.join("/")}`);
+		if (parts.length === 1) {
+			return createSecurityResource({
+				url: "security://scans",
+				content: formatScans(await store.listScans()),
+				contentType: "text/markdown",
+				isDirectory: true,
+			});
+		}
+		const scanId = parts[1];
+		const bundle = await store.getBundle(scanId);
+		if (!bundle) throw new Error(`Unknown security scan: ${scanId}`);
+		if (parts.length === 2) {
+			return createSecurityResource({
+				url: `security://scans/${scanId}`,
+				content: [
+					`# Security scan ${scanId}`,
+					"",
+					`- Status: **${bundle.scan.status}**`,
+					`- Producer: **${sanitizeText(bundle.scan.producer.name)}**`,
+					`- Findings: **${bundle.findings.length}**`,
+					`- Coverage: **${bundle.scan.coverage.completeness}**`,
+					`- Target: \`${sanitizeText(bundle.scan.target.displayName)}\``,
+					"",
+					"Resources: `manifest`, `findings`, `coverage`, `report`, `sarif`, `provenance`.",
+					"",
+				].join("\n"),
+				contentType: "text/markdown",
+				isDirectory: true,
+			});
+		}
+		switch (parts[2]) {
+			case "manifest":
+				if (parts.length !== 3) throw new Error(`Unknown security resource: security://${parts.join("/")}`);
+				return createSecurityResource({
+					url: `security://scans/${scanId}/manifest`,
+					content: `${JSON.stringify(createPublicSecurityScan(bundle.scan, { includePlan: true }), null, 2)}\n`,
+					contentType: "application/json",
+				});
+			case "findings": {
+				if (parts.length === 3) {
+					const listing = bundle.findings.map(finding =>
+						[
+							`- \`${finding.id}\` **${finding.severity.level}** — ${sanitizeText(finding.title)}`,
+							` (\`${sanitizeText(finding.ruleId)}\`)`,
+						].join(""),
+					);
+					return createSecurityResource({
+						url: `security://scans/${scanId}/findings`,
+						content: `# Findings for ${scanId}\n\n${listing.length > 0 ? listing.join("\n") : "No findings."}\n`,
+						contentType: "text/markdown",
+						isDirectory: true,
+					});
+				}
+				if (parts.length !== 4) throw new Error(`Unknown security resource: security://${parts.join("/")}`);
+				const findingId = parts[3];
+				const finding = await store.getFinding(scanId, findingId);
+				if (!finding) throw new Error(`Unknown security finding: ${findingId}`);
+				return createSecurityResource({
+					url: `security://scans/${scanId}/findings/${findingId}`,
+					content: formatFinding(finding),
+					contentType: "text/markdown",
+				});
+			}
+			case "coverage":
+				if (parts.length !== 3) throw new Error(`Unknown security resource: security://${parts.join("/")}`);
+				return createSecurityResource({
+					url: `security://scans/${scanId}/coverage`,
+					content: `${JSON.stringify(bundle.scan.coverage, null, 2)}\n`,
+					contentType: "application/json",
+				});
+			case "report":
+				if (parts.length !== 3) throw new Error(`Unknown security resource: security://${parts.join("/")}`);
+				if (bundle.report === undefined) throw new Error(`Security scan ${scanId} has no report`);
+				return createSecurityResource({
+					url: `security://scans/${scanId}/report`,
+					content: bundle.report,
+					contentType: "text/markdown",
+				});
+			case "sarif":
+				if (parts.length !== 3) throw new Error(`Unknown security resource: security://${parts.join("/")}`);
+				if (bundle.sarif === undefined) throw new Error(`Security scan ${scanId} has no SARIF export`);
+				return createSecurityResource({
+					url: `security://scans/${scanId}/sarif`,
+					content: `${JSON.stringify(bundle.sarif, null, 2)}\n`,
+					contentType: "application/json",
+				});
+			case "provenance":
+				if (parts.length !== 3) throw new Error(`Unknown security resource: security://${parts.join("/")}`);
+				return createSecurityResource({
+					url: `security://scans/${scanId}/provenance`,
+					content: `${JSON.stringify(redactPrivateSecurityMetadata(bundle.scan.provenance), null, 2)}\n`,
+					contentType: "application/json",
+				});
+			default:
+				throw new Error(`Unknown security resource: security://${parts.join("/")}`);
+		}
+	}
+
+	async complete(query = "", context?: ResolveContext): Promise<UrlCompletion[]> {
+		if (!(securityEnabledFromContext(context) ?? this.#enabled())) return [];
+		const store = await this.#store(context);
+		const scans = await store.listScans();
+		const candidates: UrlCompletion[] = [{ value: "scans", label: "Scans", description: "Stored security scans" }];
+		for (const scan of scans.slice(0, 50)) {
+			const prefix = `scans/${scan.id}`;
+			candidates.push({
+				value: prefix,
+				label: scan.id,
+				description: `${scan.status}; ${scan.findingCount} findings`,
+			});
+			for (const child of ["manifest", "findings", "coverage", "report", "sarif", "provenance"]) {
+				candidates.push({ value: `${prefix}/${child}`, label: `${scan.id}/${child}` });
+			}
+		}
+		const normalizedQuery = query.trim().toLowerCase();
+		if (!normalizedQuery) return candidates;
+		return candidates.filter(candidate =>
+			[candidate.value, candidate.label ?? "", candidate.description ?? ""].some(value =>
+				value.toLowerCase().includes(normalizedQuery),
+			),
+		);
+	}
+}

package/src/internal-urls/types.ts

@@ -1,7 +1,7 @@
 /**
  * Types for the internal URL routing system.
  *
- * Internal URLs (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `skill://`, `ssh://`, `vault://`, and `xd://`) are resolved by tools like read,
+ * Internal URLs (`agent://`, `artifact://`, `history://`, `issue://`, `local://`, `mcp://`, `memory://`, `omp://`, `pr://`, `rule://`, `security://`, `skill://`, `ssh://`, `vault://`, and `xd://`) are resolved by tools like read,
  * providing access to agent outputs and server resources without exposing filesystem paths.
  */
 

package/src/launch/terminal-output-worker-client.ts

@@ -0,0 +1,53 @@
+import { workerHostEntry } from "@oh-my-pi/pi-utils/worker-host";
+import type { TerminalOutputOptions } from "./terminal-output";
+import {
+	TERMINAL_OUTPUT_WORKER_ARG,
+	type TerminalOutputWorkerRequest,
+	type TerminalOutputWorkerResult,
+} from "./terminal-output-worker-protocol";
+
+/** Replay legacy broker PTY bytes without evaluating xterm in the client process. */
+export async function renderTerminalOutputIsolated(
+	output: string,
+	options: TerminalOutputOptions,
+): Promise<string[] | undefined> {
+	const hostEntry = workerHostEntry();
+	const worker = hostEntry
+		? new Worker(hostEntry, { type: "module", argv: [TERMINAL_OUTPUT_WORKER_ARG] })
+		: new Worker(new URL("./terminal-output-worker.ts", import.meta.url).href, { type: "module" });
+	const pending = Promise.withResolvers<string[] | undefined>();
+	const onMessage = (event: MessageEvent<TerminalOutputWorkerResult>): void => {
+		if (event.data.ok) pending.resolve(event.data.rows);
+		else pending.reject(new Error(event.data.error));
+	};
+	const onError = (event: ErrorEvent): void => {
+		pending.reject(event.error instanceof Error ? event.error : new Error(event.message));
+	};
+	const onClose = (): void => {
+		pending.reject(new Error("Terminal output worker exited before responding"));
+	};
+	worker.addEventListener("message", onMessage);
+	worker.addEventListener("error", onError);
+	worker.addEventListener("close", onClose);
+	try {
+		const request: TerminalOutputWorkerRequest = { output, options };
+		worker.postMessage(request);
+		return await pending.promise;
+	} finally {
+		worker.removeEventListener("message", onMessage);
+		worker.removeEventListener("error", onError);
+		worker.removeEventListener("close", onClose);
+		worker.terminate();
+	}
+}
+
+/** Distribution smoke for source, npm-bundle, and compiled worker routing. */
+export async function smokeTestTerminalOutputWorker(): Promise<void> {
+	const rows = await renderTerminalOutputIsolated("old\r\x1b[2K\x1b[1;32mready\x1b[0m", {
+		head: false,
+		maxRows: 10,
+	});
+	if (rows?.length !== 1 || rows[0] !== "\x1b[0m\x1b[1;38;5;2mready") {
+		throw new Error("terminal output worker smoke mismatch");
+	}
+}

package/src/launch/terminal-output-worker-protocol.ts

@@ -0,0 +1,11 @@
+import type { TerminalOutputOptions } from "./terminal-output";
+
+/** Hidden CLI selector for legacy PTY replay outside the client process. */
+export const TERMINAL_OUTPUT_WORKER_ARG = "__omp_worker_terminal_output";
+
+export interface TerminalOutputWorkerRequest {
+	output: string;
+	options: TerminalOutputOptions;
+}
+
+export type TerminalOutputWorkerResult = { ok: true; rows: string[] | undefined } | { ok: false; error: string };

package/src/launch/terminal-output-worker.ts

@@ -0,0 +1,23 @@
+import { parentPort } from "node:worker_threads";
+import { consumeWorkerInbox } from "@oh-my-pi/pi-utils/worker-host";
+import { renderTerminalOutput } from "./terminal-output";
+import type { TerminalOutputWorkerRequest, TerminalOutputWorkerResult } from "./terminal-output-worker-protocol";
+
+if (!parentPort) throw new Error("terminal-output-worker: missing parentPort");
+
+const port = parentPort;
+const inbox = consumeWorkerInbox();
+const handle = async (message: unknown): Promise<void> => {
+	const request = message as TerminalOutputWorkerRequest;
+	let result: TerminalOutputWorkerResult;
+	try {
+		result = { ok: true, rows: await renderTerminalOutput(request.output, request.options) };
+	} catch (error) {
+		result = { ok: false, error: error instanceof Error ? error.message : String(error) };
+	}
+	port.postMessage(result);
+	port.close();
+};
+
+if (inbox) inbox.bind(message => void handle(message));
+else port.on("message", message => void handle(message));

package/src/lsp/client.ts

@@ -27,6 +27,7 @@ const fileOperationLocks = new Map<string, Promise<void>>();
 /** Negative cache of recent init failures so a broken server fails fast instead of re-spawning per call. */
 const INIT_FAILURE_BACKOFF_MS = 3 * 60 * 1000;
 const initFailures = new Map<string, { at: number; message: string }>();
+const READER_EXIT_GRACE_MS = 100;
 
 // Idle timeout configuration (disabled by default)
 let idleTimeoutMs: number | null = null;
@@ -303,6 +304,7 @@ async function startMessageReader(client: LspClient): Promise<void> {
 
 	const framer = new MessageFramer(Buffer.from(client.messageBuffer));
 
+	let readerFailed = false;
 	try {
 		while (true) {
 			const { done, value } = await reader.read();
@@ -391,6 +393,7 @@ async function startMessageReader(client: LspClient): Promise<void> {
 			}
 		}
 	} catch (err) {
+		readerFailed = true;
 		// Connection closed or error - reject all pending requests
 		for (const pending of Array.from(client.pendingRequests.values())) {
 			pending.reject(new Error(`LSP connection closed: ${err}`));
@@ -401,6 +404,9 @@ async function startMessageReader(client: LspClient): Promise<void> {
 		client.messageBuffer = framer.remainder();
 		reader.releaseLock();
 		client.isReading = false;
+		if (!readerFailed && client.proc.exitCode === null) {
+			await waitForExit(client, READER_EXIT_GRACE_MS);
+		}
 		// Reader exited while the server process is still alive (unrecoverable
 		// read error or bad stream state): nothing will route responses anymore,
 		// so tear the client down — the next call respawns instead of timing out.
@@ -676,6 +682,15 @@ const PROJECT_LOAD_TIMEOUT_MS = 15_000;
 const SHUTDOWN_TIMEOUT_MS = 5_000;
 const EXIT_TIMEOUT_MS = 1_000;
 
+function clientKey(config: ServerConfig, cwd: string): string {
+	return `${config.command}:${cwd}`;
+}
+
+/** Allow an explicit user reload to retry a matching initialization failure immediately. */
+export function clearInitializationFailure(config: ServerConfig, cwd: string): void {
+	initFailures.delete(clientKey(config, cwd));
+}
+
 /**
  * Get or create an LSP client for the given server configuration and working directory.
  * @param config - Server configuration
@@ -692,7 +707,7 @@ export async function getOrCreateClient(
 	initTimeoutMs?: number,
 	signal?: AbortSignal,
 ): Promise<LspClient> {
-	const key = `${config.command}:${cwd}`;
+	const key = clientKey(config, cwd);
 
 	// Check if client already exists
 	const existingClient = clients.get(key);
@@ -865,13 +880,13 @@ export async function getActiveOrPendingClient(
 	signal?: AbortSignal,
 ): Promise<LspClient | undefined> {
 	throwIfAborted(signal);
-	const client = clients.get(`${config.command}:${cwd}`);
+	const client = clients.get(clientKey(config, cwd));
 	if (client) {
 		client.lastActivity = Date.now();
 		return client;
 	}
 
-	const pending = clientLocks.get(`${config.command}:${cwd}`);
+	const pending = clientLocks.get(clientKey(config, cwd));
 	if (!pending) return undefined;
 	try {
 		return await untilAborted(signal, pending);

package/src/lsp/index.ts

@@ -17,6 +17,7 @@ import { formatPathRelativeToCwd, resolveToCwd } from "../tools/path-utils";
 import { ToolAbortError, ToolError, throwIfAborted } from "../tools/tool-errors";
 import { clampTimeout } from "../tools/tool-timeouts";
 import {
+	clearInitializationFailure,
 	ensureFileOpen,
 	FileChangeType,
 	getActiveClients,
@@ -1598,6 +1599,9 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<LspToolDetails>> {
 		const { action, file, line, symbol, query, new_name, apply, timeout } = params;
+		if (this.session.lspReadOnly && !LSP_READONLY_ACTIONS.has(action)) {
+			throw new ToolError(`LSP action ${action} is disabled in this read-only session`);
+		}
 		const timeoutSec = clampTimeout("lsp", timeout, this.session.settings.get("tools.maxTimeout"));
 		const timeoutSignal = AbortSignal.timeout(timeoutSec * 1000);
 		const callerSignal = signal;
@@ -2345,6 +2349,7 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 			const outputs: string[] = [];
 			for (const [workspaceServerName, workspaceServerConfig] of servers) {
 				throwIfAborted(signal);
+				clearInitializationFailure(workspaceServerConfig, this.session.cwd);
 				try {
 					const workspaceClient = await getOrCreateClient(
 						workspaceServerConfig,
@@ -2377,6 +2382,8 @@ export class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Them
 
 		const [serverName, serverConfig] = serverInfo;
 
+		if (action === "reload") clearInitializationFailure(serverConfig, this.session.cwd);
+
 		try {
 			const client = await getOrCreateClient(serverConfig, this.session.cwd, undefined, signal);
 			const targetFile = resolvedFile;

package/src/lsp/render.ts

@@ -582,7 +582,7 @@ function renderGeneric(text: string, lines: string[], expanded: boolean, theme:
 		for (let i = 0; i < lines.length; i++) {
 			const isLast = i === lines.length - 1;
 			const branch = isLast ? theme.tree.last : theme.tree.branch;
-			output += `\n ${theme.fg("dim", branch)} ${lines[i]}`;
+			output += `\n ${theme.fg("dim", branch)} ${truncateToWidth(replaceTabs(lines[i]), TRUNCATE_LENGTHS.CONTENT)}`;
 		}
 		return output.split("\n");
 	}