@ccgv2/pi-acp 0.5.0

package/dist/index.mjs

@@ -0,0 +1,2640 @@
+#!/usr/bin/env node
+import { homedir, platform } from "node:os";
+import { AgentSideConnection, RequestError, ndJsonStream } from "@agentclientprotocol/sdk";
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { SessionManager, createAgentSession, defineTool } from "@earendil-works/pi-coding-agent";
+import * as z from "zod";
+import { createHash } from "node:crypto";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StdioClientTransport, getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import { Unsafe } from "typebox";
+//#region src/acp/auth.ts
+const AUTH_METHOD_ID = "pi_terminal_login";
+function buildAuthMethods(opts) {
+	const supportsTerminalAuthMeta = opts?.supportsTerminalAuthMeta ?? true;
+	const method = {
+		id: AUTH_METHOD_ID,
+		name: "Launch pi in the terminal",
+		description: "Start pi in an interactive terminal to configure API keys or login",
+		type: "terminal",
+		args: ["--terminal-login"],
+		env: {}
+	};
+	if (supportsTerminalAuthMeta) method._meta = { "terminal-auth": {
+		...resolveTerminalLaunchCommand(),
+		label: "Launch pi"
+	} };
+	return [method];
+}
+function resolveTerminalLaunchCommand() {
+	const argv0 = process.argv[0] ?? "node";
+	const argv1 = process.argv[1];
+	if (argv1 !== void 0 && argv0.includes("node") && argv1.endsWith(".js")) return {
+		command: argv0,
+		args: [argv1, "--terminal-login"]
+	};
+	return {
+		command: "pi-acp",
+		args: ["--terminal-login"]
+	};
+}
+//#endregion
+//#region src/acp/auth-required.ts
+/**
+* Detect common auth/credential errors from pi and surface them as ACP AUTH_REQUIRED.
+*/
+const AUTH_ERROR_PATTERNS = [
+	"api key",
+	"apikey",
+	"missing key",
+	"no key",
+	"not configured",
+	"unauthorized",
+	"authentication",
+	"permission denied",
+	"forbidden",
+	"401",
+	"403"
+];
+function detectAuthError(err) {
+	const lower = (err instanceof Error ? err.message : String(err ?? "")).toLowerCase();
+	if (!AUTH_ERROR_PATTERNS.some((p) => lower.includes(p))) return null;
+	return RequestError.authRequired({ authMethods: buildAuthMethods() }, "Configure an API key or log in with an OAuth provider.");
+}
+//#endregion
+//#region src/acp/client-capabilities.ts
+/**
+* Extract well-known capability flags from ACP `ClientCapabilities`.
+*
+* Reads from:
+* - `_meta.terminal_output` (terminal output rendering)
+* - `_meta.terminal-auth` (terminal auth with command metadata)
+* - `auth._meta.gateway` (gateway auth, future use)
+*/
+function parseClientCapabilities(caps) {
+	if (caps === void 0 || caps === null) return {
+		terminalOutput: false,
+		terminalAuth: false,
+		gatewayAuth: false
+	};
+	const meta = caps._meta;
+	const terminalOutput = typeof meta === "object" && meta !== null && meta["terminal_output"] === true;
+	const terminalAuth = typeof meta === "object" && meta !== null && meta["terminal-auth"] === true;
+	let gatewayAuth = false;
+	if ("auth" in caps) {
+		const auth = caps.auth;
+		if (typeof auth === "object" && auth !== null && "_meta" in auth) {
+			const authMeta = auth._meta;
+			if (typeof authMeta === "object" && authMeta !== null && "gateway" in authMeta) gatewayAuth = authMeta["gateway"] === true;
+		}
+	}
+	return {
+		terminalOutput,
+		terminalAuth,
+		gatewayAuth
+	};
+}
+//#endregion
+//#region src/acp/model-alias.ts
+/**
+* Tokenize a string: split on non-alphanumeric, lowercase, strip "claude".
+*/
+function tokenize(input) {
+	return input.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t !== "" && t !== "claude");
+}
+/**
+* Extract a context hint in square brackets, e.g. "opus[1m]" -> { base: "opus", hint: "1m" }.
+*/
+function extractContextHint(input) {
+	const match = /^(.+?)\[([^\]]+)\]$/.exec(input);
+	if (match !== null && match[1] !== void 0 && match[2] !== void 0) return {
+		base: match[1],
+		hint: match[2]
+	};
+	return {
+		base: input,
+		hint: null
+	};
+}
+/** Check if a string is purely numeric. */
+function isNumeric(s) {
+	return /^\d+$/.test(s);
+}
+/**
+* Score how well a model matches the given preference tokens.
+*
+* Returns a score >= 0 (higher is better), or -1 for no match.
+* Requires at least one non-numeric token to match to avoid false positives
+* from bare version numbers (e.g. "4" matching model version suffixes).
+*/
+function scoreModel(model, prefTokens, hint) {
+	const modelStr = `${model.provider}/${model.id}/${model.name ?? ""}`.toLowerCase();
+	const modelTokens = tokenize(modelStr);
+	let matched = 0;
+	let hasNonNumericMatch = false;
+	for (const pt of prefTokens) if (modelTokens.some((mt) => mt.includes(pt) || pt.includes(mt))) {
+		matched++;
+		if (!isNumeric(pt)) hasNonNumericMatch = true;
+	}
+	if (matched === 0) return -1;
+	if (!hasNonNumericMatch) return -1;
+	let score = matched / prefTokens.length;
+	if (hint !== null && modelStr.includes(hint.toLowerCase())) score += .5;
+	const pref = prefTokens.join("");
+	if (model.id.toLowerCase().includes(pref)) score += .25;
+	return score;
+}
+/**
+* Resolve a user-friendly model preference to a concrete model.
+*
+* Matching strategy (in order):
+* 1. Exact match on "provider/id"
+* 2. Exact match on "id" alone
+* 3. Tokenized scored match with optional context hint
+*
+* Returns null if no model matches.
+*/
+function resolveModelPreference(models, preference) {
+	const trimmed = preference.trim();
+	if (trimmed === "") return null;
+	if (trimmed.includes("/")) {
+		const [p, ...rest] = trimmed.split("/");
+		const provider = p ?? "";
+		const id = rest.join("/");
+		const exact = models.find((m) => m.provider.toLowerCase() === provider.toLowerCase() && m.id.toLowerCase() === id.toLowerCase());
+		if (exact !== void 0) return {
+			provider: exact.provider,
+			id: exact.id
+		};
+	}
+	const byId = models.find((m) => m.id.toLowerCase() === trimmed.toLowerCase());
+	if (byId !== void 0) return {
+		provider: byId.provider,
+		id: byId.id
+	};
+	const { base, hint } = extractContextHint(trimmed);
+	const prefTokens = tokenize(base);
+	if (prefTokens.length === 0) return null;
+	let bestModel = null;
+	let bestScore = -1;
+	for (const model of models) {
+		const s = scoreModel(model, prefTokens, hint);
+		if (s > bestScore) {
+			bestScore = s;
+			bestModel = model;
+		}
+	}
+	if (bestModel === null || bestScore < .5) return null;
+	return {
+		provider: bestModel.provider,
+		id: bestModel.id
+	};
+}
+//#endregion
+//#region src/acp/pi-settings.ts
+/**
+* Read pi settings from global and project config files.
+*
+* Settings are merged: project overrides global.
+* Paths follow pi-mono conventions:
+*   Global: ~/.pi/agent/settings.json
+*   Project: <cwd>/.pi/settings.json
+*/
+const piSettingsSchema = z.object({
+	enableSkillCommands: z.boolean().optional(),
+	quietStartup: z.boolean().optional(),
+	quietStart: z.boolean().optional(),
+	skills: z.object({ enableSkillCommands: z.boolean().optional() }).optional()
+});
+function isRecord(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function merge(base, override) {
+	const result = { ...base };
+	for (const [key, val] of Object.entries(override)) {
+		const existing = result[key];
+		if (isRecord(existing) && isRecord(val)) result[key] = merge(existing, val);
+		else result[key] = val;
+	}
+	return result;
+}
+function readJson(path) {
+	try {
+		if (!existsSync(path)) return {};
+		const data = JSON.parse(readFileSync(path, "utf-8"));
+		return isRecord(data) ? data : {};
+	} catch {
+		return {};
+	}
+}
+function piAgentDir() {
+	return process.env.PI_CODING_AGENT_DIR !== void 0 ? resolve(process.env.PI_CODING_AGENT_DIR) : join(homedir(), ".pi", "agent");
+}
+function resolvedSettings(cwd) {
+	const globalPath = join(piAgentDir(), "settings.json");
+	const projectPath = resolve(cwd, ".pi", "settings.json");
+	const merged = merge(readJson(globalPath), readJson(projectPath));
+	const result = piSettingsSchema.safeParse(merged);
+	return result.success ? result.data : {};
+}
+function skillCommandsEnabled(cwd) {
+	const settings = resolvedSettings(cwd);
+	if (typeof settings.enableSkillCommands === "boolean") return settings.enableSkillCommands;
+	if (typeof settings.skills?.enableSkillCommands === "boolean") return settings.skills.enableSkillCommands;
+	return true;
+}
+//#endregion
+//#region src/acp/translate/tool-content.ts
+const textBlockSchema = z.object({
+	type: z.literal("text"),
+	text: z.string()
+});
+const imageBlockSchema = z.object({ type: z.literal("image") });
+const contentBlockSchema = z.union([textBlockSchema, imageBlockSchema]);
+const bashDetailsSchema = z.object({
+	stdout: z.string().optional(),
+	stderr: z.string().optional(),
+	output: z.string().optional(),
+	exitCode: z.number().optional(),
+	code: z.number().optional()
+});
+const bashResultSchema = z.object({
+	content: z.array(z.unknown()).optional(),
+	details: bashDetailsSchema.optional(),
+	stdout: z.string().optional(),
+	stderr: z.string().optional(),
+	output: z.string().optional(),
+	exitCode: z.number().optional(),
+	code: z.number().optional()
+});
+/**
+* Extract stdout/stderr and exit code from a pi bash/tmux result.
+*/
+function extractBashOutput(result) {
+	if (result === null || result === void 0 || typeof result !== "object") return {
+		output: "",
+		exitCode: void 0
+	};
+	const parsed = bashResultSchema.safeParse(result);
+	if (!parsed.success) return {
+		output: "",
+		exitCode: void 0
+	};
+	const r = parsed.data;
+	const d = r.details;
+	if (r.content !== void 0) {
+		const texts = r.content.map((block) => textBlockSchema.safeParse(block)).filter((res) => res.success).map((res) => res.data.text);
+		if (texts.length > 0) {
+			const exitCode = d?.exitCode ?? r.exitCode ?? d?.code ?? r.code;
+			return {
+				output: texts.join(""),
+				exitCode
+			};
+		}
+	}
+	const stdout = d?.stdout ?? r.stdout ?? d?.output ?? r.output;
+	const stderr = d?.stderr ?? r.stderr;
+	const exitCode = d?.exitCode ?? r.exitCode ?? d?.code ?? r.code;
+	const parts = [];
+	if (stdout !== void 0 && stdout.trim() !== "") parts.push(stdout);
+	if (stderr !== void 0 && stderr.trim() !== "") parts.push(stderr);
+	return {
+		output: parts.join("\n"),
+		exitCode
+	};
+}
+/**
+* Extract text content from a pi tool result (generic).
+*/
+function extractTextContent(result) {
+	if (result === null || result === void 0 || typeof result !== "object") return "";
+	if ("content" in result && Array.isArray(result.content)) {
+		const texts = [];
+		for (const block of result.content) {
+			const parsed = textBlockSchema.safeParse(block);
+			if (parsed.success) texts.push(parsed.data.text);
+		}
+		if (texts.length > 0) return texts.join("");
+	}
+	try {
+		return JSON.stringify(result, null, 2);
+	} catch {
+		return String(result);
+	}
+}
+/**
+* Extract content blocks from a pi result, preserving type information.
+* Used for read results where images need to be preserved.
+*/
+function extractContentBlocks(result) {
+	if (result === null || result === void 0 || typeof result !== "object") return [];
+	if (!("content" in result) || !Array.isArray(result.content)) return [];
+	const blocks = [];
+	for (const raw of result.content) {
+		const parsed = contentBlockSchema.safeParse(raw);
+		if (parsed.success) blocks.push(parsed.data);
+	}
+	return blocks;
+}
+/**
+* Find the longest consecutive backtick sequence in a string.
+*/
+function longestBacktickRun(text) {
+	let max = 0;
+	let current = 0;
+	for (const ch of text) if (ch === "`") {
+		current++;
+		if (current > max) max = current;
+	} else current = 0;
+	return max;
+}
+/**
+* Wrap text in a dynamically-sized backtick fence to prevent markdown rendering.
+*
+* Instead of character-level escaping (which fails on files containing backtick
+* sequences, indented code blocks, blockquotes, and list markers), this wraps
+* the entire text in a backtick fence whose length exceeds any backtick sequence
+* in the content. This approach is simpler and strictly more correct (following
+* the claude-agent-acp pattern).
+*/
+function markdownEscape(text) {
+	if (text === "") return "";
+	const fenceLen = Math.max(3, longestBacktickRun(text) + 1);
+	const fence = "`".repeat(fenceLen);
+	return `${fence}\n${text.endsWith("\n") ? text.slice(0, -1) : text}\n${fence}`;
+}
+/**
+* Format tool output into `ToolCallContent[]` by tool name.
+*
+* Returns the appropriate content shape for each tool type:
+* - bash/tmux: console code fences
+* - read: markdown-escaped text (images preserved)
+* - edit/write: empty (diff handled separately)
+* - lsp: code fences
+* - errors: code fences with failed status
+* - everything else: plain text
+*/
+function formatToolContent(toolName, result, isError) {
+	if (isError) {
+		const text = extractTextContent(result);
+		if (text === "") return [];
+		return [{
+			type: "content",
+			content: {
+				type: "text",
+				text: `\`\`\`\n${text}\n\`\`\``
+			}
+		}];
+	}
+	switch (toolName) {
+		case "bash":
+		case "tmux": return formatBashContent(result);
+		case "read": return formatReadContent(result);
+		case "edit":
+		case "write": return [];
+		case "lsp": return formatLspContent(result);
+		default: return formatFallbackContent(result);
+	}
+}
+function formatBashContent(result) {
+	const { output, exitCode } = extractBashOutput(result);
+	if (output === "" && exitCode === void 0) return [];
+	const parts = [];
+	if (output !== "") parts.push(`\`\`\`console\n${output}\n\`\`\``);
+	if (exitCode !== void 0 && exitCode !== 0) parts.push(`exit code: ${exitCode}`);
+	const text = parts.join("\n\n");
+	if (text === "") return [];
+	return [{
+		type: "content",
+		content: {
+			type: "text",
+			text
+		}
+	}];
+}
+function formatReadContent(result) {
+	const blocks = extractContentBlocks(result);
+	if (blocks.length === 0) {
+		if (typeof result === "object" && result !== null && "content" in result && Array.isArray(result.content) && result.content.length === 0) return [];
+		const text = extractTextContent(result);
+		if (text === "") return [];
+		return [{
+			type: "content",
+			content: {
+				type: "text",
+				text: markdownEscape(text)
+			}
+		}];
+	}
+	const content = [];
+	for (const block of blocks) if (block.type === "text") content.push({
+		type: "content",
+		content: {
+			type: "text",
+			text: markdownEscape(block.text)
+		}
+	});
+	return content;
+}
+function formatLspContent(result) {
+	const text = extractTextContent(result);
+	if (text === "") return [];
+	return [{
+		type: "content",
+		content: {
+			type: "text",
+			text: `\`\`\`\n${text}\n\`\`\``
+		}
+	}];
+}
+function formatFallbackContent(result) {
+	const text = extractTextContent(result);
+	if (text === "") return [];
+	return [{
+		type: "content",
+		content: {
+			type: "text",
+			text
+		}
+	}];
+}
+/**
+* Wrap streaming output text in a console code fence for bash/tmux.
+*
+* Each streaming update is self-contained (full accumulated buffer),
+* following the codex-acp pattern.
+*/
+function wrapStreamingBashOutput(text) {
+	if (text === "") return "";
+	return `\`\`\`console\n${text}\n\`\`\``;
+}
+//#endregion
+//#region src/acp/unreachable.ts
+/**
+* Exhaustive switch/case helper.
+*
+* Writes unknown values to stderr instead of silently ignoring them, aiding
+* debugging when the pi SDK adds new event types. Never write to stdout: it
+* carries the ACP NDJSON stream and any other byte poisons the protocol.
+*/
+function unreachable(value, context) {
+	const label = context !== void 0 ? `[${context}] ` : "";
+	process.stderr.write(`${label}Unhandled value: ${String(value)}\n`);
+}
+//#endregion
+//#region src/acp/session.ts
+function findUniqueLineNumber(text, needle) {
+	if (!needle) return void 0;
+	const first = text.indexOf(needle);
+	if (first < 0) return void 0;
+	if (text.indexOf(needle, first + needle.length) >= 0) return void 0;
+	let line = 1;
+	for (let i = 0; i < first; i++) if (text.charCodeAt(i) === 10) line++;
+	return line;
+}
+function resolveToolPath(args, cwd, line) {
+	const p = args.path;
+	if (p === void 0) return void 0;
+	return [{
+		path: isAbsolute(p) ? p : resolve(cwd, p),
+		...typeof line === "number" ? { line } : {}
+	}];
+}
+function toToolKind(toolName) {
+	switch (toolName) {
+		case "read": return "read";
+		case "write":
+		case "edit": return "edit";
+		case "bash":
+		case "tmux": return "execute";
+		case "lsp": return "search";
+		default: return "other";
+	}
+}
+const MAX_TITLE_LEN = 80;
+function truncateTitle(text) {
+	const oneLine = text.replace(/\n/g, " ").trim();
+	if (oneLine.length <= MAX_TITLE_LEN) return oneLine;
+	return `${oneLine.slice(0, MAX_TITLE_LEN - 1)}…`;
+}
+function capitalize(s) {
+	if (s.length === 0) return s;
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+/**
+* Build a descriptive tool title from tool name and args.
+*
+* Returns a short human-readable label like "Read src/index.ts" or "Run ls -la".
+*/
+function buildToolTitle(toolName, args) {
+	const p = args.path;
+	switch (toolName) {
+		case "read": return p !== void 0 ? `Read ${p}` : "Read";
+		case "write": return p !== void 0 ? `Write ${p}` : "Write";
+		case "edit": return p !== void 0 ? `Edit ${p}` : "Edit";
+		case "bash": {
+			const command = typeof args["command"] === "string" ? args["command"] : typeof args["cmd"] === "string" ? args["cmd"] : void 0;
+			return command !== void 0 ? truncateTitle(`Run ${command}`) : "bash";
+		}
+		case "lsp": {
+			const action = typeof args["action"] === "string" ? args["action"] : void 0;
+			const file = typeof args["file"] === "string" ? args["file"] : void 0;
+			const query = typeof args["query"] === "string" ? args["query"] : void 0;
+			const line = typeof args["line"] === "number" ? args["line"] : void 0;
+			if (action !== void 0) {
+				const target = file !== void 0 ? line !== void 0 ? `${file}:${line}` : file : query;
+				return target !== void 0 ? truncateTitle(`${capitalize(action)} ${target}`) : capitalize(action);
+			}
+			return "LSP";
+		}
+		case "tmux": {
+			const action = typeof args["action"] === "string" ? args["action"] : void 0;
+			const command = typeof args["command"] === "string" ? args["command"] : void 0;
+			const name = typeof args["name"] === "string" ? args["name"] : void 0;
+			if (action === "run" && command !== void 0) return truncateTitle(`Tmux: ${command}`);
+			if (action !== void 0 && name !== void 0) return truncateTitle(`Tmux ${action} ${name}`);
+			if (action !== void 0) return `Tmux ${action}`;
+			return "Tmux";
+		}
+		case "context_tag": {
+			const name = typeof args["name"] === "string" ? args["name"] : void 0;
+			return name !== void 0 ? `Tag ${name}` : "Tag";
+		}
+		case "context_log": return "Context log";
+		case "context_checkout": {
+			const target = typeof args["target"] === "string" ? args["target"] : void 0;
+			return target !== void 0 ? truncateTitle(`Checkout ${target}`) : "Checkout";
+		}
+		case "claudemon": return "Check quota";
+		default: return toolName;
+	}
+}
+/**
+* Map pi assistant stopReason to ACP StopReason.
+* pi: "stop" | "length" | "toolUse" | "error" | "aborted"
+* ACP: "end_turn" | "cancelled" | "max_tokens" | "error"
+*/
+function mapPiStopReason(piReason) {
+	switch (piReason) {
+		case "stop":
+		case "toolUse": return "end_turn";
+		case "length": return "max_tokens";
+		case "aborted": return "cancelled";
+		case "error": return "error";
+		default: return "end_turn";
+	}
+}
+function extractToolCallFromPartial(ame) {
+	if (!("partial" in ame)) return void 0;
+	const block = ame.partial.content["contentIndex" in ame ? ame.contentIndex : 0];
+	if (block && "type" in block && block.type === "toolCall") return block;
+}
+function parseToolInput(tc) {
+	return tc.arguments;
+}
+const toolArgsSchema = z.object({
+	path: z.string().trim().optional(),
+	oldText: z.string().trim().optional()
+}).loose();
+function toToolArgs(raw) {
+	const result = toolArgsSchema.safeParse(raw);
+	return result.success ? result.data : {};
+}
+/** Build the `_meta.piAcp` tool name metadata. */
+function buildToolMeta(toolName, extra) {
+	const base = { piAcp: { toolName } };
+	if (extra !== void 0) return {
+		...base,
+		...extra
+	};
+	return base;
+}
+/** Tools that produce terminal-style output. */
+function isTerminalTool(toolName) {
+	return toolName === "bash" || toolName === "tmux";
+}
+var SessionManager$1 = class {
+	sessions = /* @__PURE__ */ new Map();
+	disposeAll() {
+		for (const id of this.sessions.keys()) this.close(id);
+	}
+	async disposeAllAsync() {
+		await Promise.all([...this.sessions.keys()].map((id) => this.closeAsync(id)));
+	}
+	maybeGet(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	close(sessionId) {
+		const s = this.sessions.get(sessionId);
+		if (!s) return;
+		try {
+			s.dispose();
+		} catch {}
+		this.sessions.delete(sessionId);
+	}
+	async closeAsync(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (session === void 0) return;
+		this.sessions.delete(sessionId);
+		await session.disposeAsync();
+	}
+	closeAllExcept(keepSessionId) {
+		for (const id of this.sessions.keys()) if (id !== keepSessionId) this.close(id);
+	}
+	register(session) {
+		this.sessions.set(session.sessionId, session);
+	}
+	get(sessionId) {
+		const s = this.sessions.get(sessionId);
+		if (!s) throw RequestError.invalidParams(`Unknown sessionId: ${sessionId}`);
+		return s;
+	}
+};
+var PiAcpSession = class {
+	sessionId;
+	cwd;
+	mcpServers;
+	piSession;
+	supportsTerminalOutput;
+	mcpFingerprint;
+	conn;
+	mcpManager;
+	cancelRequested = false;
+	promptRunning = false;
+	pendingTurn = null;
+	/** Queued prompts waiting for the active turn to complete. */
+	pendingMessages = [];
+	currentToolCalls = /* @__PURE__ */ new Map();
+	/** Map of toolCallId -> toolName for streaming updates (Phase 5). */
+	toolCallNames = /* @__PURE__ */ new Map();
+	editSnapshots = /* @__PURE__ */ new Map();
+	lastAssistantStopReason = null;
+	lastEmit = Promise.resolve();
+	unsubscribe;
+	constructor(opts) {
+		this.sessionId = opts.sessionId;
+		this.cwd = opts.cwd;
+		this.mcpServers = opts.mcpServers;
+		this.piSession = opts.piSession;
+		this.mcpManager = opts.mcpManager;
+		this.mcpFingerprint = opts.mcpManager?.fingerprint ?? "";
+		this.conn = opts.conn;
+		this.supportsTerminalOutput = opts.supportsTerminalOutput ?? false;
+		this.unsubscribe = this.piSession.subscribe((ev) => this.handlePiEvent(ev));
+	}
+	dispose() {
+		this.unsubscribe?.();
+		this.piSession.dispose();
+		this.mcpManager?.close();
+	}
+	async disposeAsync() {
+		this.unsubscribe?.();
+		this.piSession.dispose();
+		await this.mcpManager?.close();
+	}
+	async prompt(message, images = []) {
+		if (this.promptRunning) return new Promise((resolve, reject) => {
+			this.pendingMessages.push({
+				message,
+				images,
+				resolve,
+				reject
+			});
+		});
+		return this.executePrompt(message, images);
+	}
+	async cancel() {
+		this.cancelRequested = true;
+		for (const pending of this.pendingMessages) pending.resolve("cancelled");
+		this.pendingMessages = [];
+		await this.piSession.abort();
+	}
+	executePrompt(message, images) {
+		this.promptRunning = true;
+		const turnPromise = new Promise((resolve, reject) => {
+			this.cancelRequested = false;
+			this.pendingTurn = {
+				resolve,
+				reject
+			};
+		});
+		const imageContents = Array.isArray(images) ? images.filter((img) => typeof img === "object" && img !== null && "type" in img && img.type === "image") : [];
+		this.piSession.prompt(message, { images: imageContents }).catch(() => {
+			this.flushEmits().finally(() => {
+				const reason = this.cancelRequested ? "cancelled" : "error";
+				this.pendingTurn?.resolve(reason);
+				this.pendingTurn = null;
+			});
+		});
+		return turnPromise;
+	}
+	/**
+	* Dequeue and execute the next pending prompt, if any.
+	* Called after a turn completes.
+	*/
+	dequeueNextPrompt() {
+		const next = this.pendingMessages.shift();
+		if (next === void 0) {
+			this.promptRunning = false;
+			return;
+		}
+		this.executePrompt(next.message, next.images).then(next.resolve, next.reject);
+	}
+	wasCancelRequested() {
+		return this.cancelRequested;
+	}
+	emit(update) {
+		this.lastEmit = this.lastEmit.then(() => this.conn.sessionUpdate({
+			sessionId: this.sessionId,
+			update
+		})).catch(() => {});
+	}
+	async flushEmits() {
+		await this.lastEmit;
+	}
+	handlePiEvent(ev) {
+		if (!isAgentEvent(ev)) return;
+		switch (ev.type) {
+			case "message_update":
+				this.handleMessageUpdate(ev.assistantMessageEvent);
+				break;
+			case "message_end":
+				this.handleMessageEnd(ev.message);
+				break;
+			case "tool_execution_start":
+				this.handleToolStart(ev.toolCallId, ev.toolName, toToolArgs(ev.args));
+				break;
+			case "tool_execution_update":
+				this.handleToolUpdate(ev.toolCallId, ev.toolName, ev.partialResult);
+				break;
+			case "tool_execution_end":
+				this.handleToolEnd(ev.toolCallId, ev.toolName, ev.result, ev.isError);
+				break;
+			case "agent_end":
+				this.handleAgentEnd();
+				break;
+			default:
+				unreachable(ev, "handlePiEvent");
+				break;
+		}
+	}
+	handleMessageUpdate(ame) {
+		if (ame.type === "text_delta") {
+			this.emit({
+				sessionUpdate: "agent_message_chunk",
+				content: {
+					type: "text",
+					text: ame.delta
+				}
+			});
+			return;
+		}
+		if (ame.type === "thinking_delta") {
+			this.emit({
+				sessionUpdate: "agent_thought_chunk",
+				content: {
+					type: "text",
+					text: ame.delta
+				}
+			});
+			return;
+		}
+		if (ame.type === "toolcall_start" || ame.type === "toolcall_delta" || ame.type === "toolcall_end") {
+			const toolCall = ame.type === "toolcall_end" ? ame.toolCall : extractToolCallFromPartial(ame);
+			if (!toolCall) return;
+			const rawInput = parseToolInput(toolCall);
+			const locations = resolveToolPath(rawInput, this.cwd);
+			const existingStatus = this.currentToolCalls.get(toolCall.id);
+			const status = existingStatus ?? "pending";
+			if (!existingStatus) {
+				this.currentToolCalls.set(toolCall.id, "pending");
+				this.emit({
+					sessionUpdate: "tool_call",
+					toolCallId: toolCall.id,
+					title: buildToolTitle(toolCall.name, rawInput),
+					kind: toToolKind(toolCall.name),
+					status,
+					...locations ? { locations } : {},
+					rawInput,
+					_meta: buildToolMeta(toolCall.name)
+				});
+			} else this.emit({
+				sessionUpdate: "tool_call_update",
+				toolCallId: toolCall.id,
+				status,
+				...locations ? { locations } : {},
+				rawInput,
+				_meta: buildToolMeta(toolCall.name)
+			});
+		}
+	}
+	handleMessageEnd(msg) {
+		if ("role" in msg && msg.role === "assistant") this.lastAssistantStopReason = msg.stopReason;
+	}
+	handleToolStart(toolCallId, toolName, args) {
+		this.toolCallNames.set(toolCallId, toolName);
+		let line;
+		if ((toolName === "edit" || toolName === "write") && args.path !== void 0) try {
+			const abs = isAbsolute(args.path) ? args.path : resolve(this.cwd, args.path);
+			let oldText = "";
+			try {
+				oldText = readFileSync(abs, "utf8");
+			} catch {}
+			this.editSnapshots.set(toolCallId, {
+				path: abs,
+				oldText
+			});
+			if (toolName === "edit") line = findUniqueLineNumber(oldText, args.oldText ?? "");
+		} catch {}
+		const locations = resolveToolPath(args, this.cwd, line);
+		const meta = buildToolMeta(toolName, this.supportsTerminalOutput && isTerminalTool(toolName) ? { terminal_info: {
+			terminal_id: toolCallId,
+			cwd: this.cwd
+		} } : void 0);
+		const terminalContent = this.supportsTerminalOutput && isTerminalTool(toolName) ? [{
+			type: "terminal",
+			terminalId: toolCallId
+		}] : void 0;
+		if (!this.currentToolCalls.has(toolCallId)) {
+			this.currentToolCalls.set(toolCallId, "in_progress");
+			this.emit({
+				sessionUpdate: "tool_call",
+				toolCallId,
+				title: buildToolTitle(toolName, args),
+				kind: toToolKind(toolName),
+				status: "in_progress",
+				...locations ? { locations } : {},
+				...terminalContent !== void 0 ? { content: terminalContent } : {},
+				rawInput: args,
+				_meta: meta
+			});
+		} else {
+			this.currentToolCalls.set(toolCallId, "in_progress");
+			this.emit({
+				sessionUpdate: "tool_call_update",
+				toolCallId,
+				title: buildToolTitle(toolName, args),
+				status: "in_progress",
+				...locations ? { locations } : {},
+				...terminalContent !== void 0 ? { content: terminalContent } : {},
+				rawInput: args,
+				_meta: meta
+			});
+		}
+	}
+	handleToolUpdate(toolCallId, toolName, partialResult) {
+		const name = this.toolCallNames.get(toolCallId) ?? toolName;
+		if (this.supportsTerminalOutput && isTerminalTool(name)) {
+			const text = extractStreamingText(partialResult);
+			this.emit({
+				sessionUpdate: "tool_call_update",
+				toolCallId,
+				status: "in_progress",
+				_meta: buildToolMeta(name, { terminal_output: {
+					terminal_id: toolCallId,
+					data: text
+				} }),
+				rawOutput: partialResult
+			});
+		} else if (isTerminalTool(name)) {
+			const wrapped = wrapStreamingBashOutput(extractStreamingText(partialResult));
+			this.emit({
+				sessionUpdate: "tool_call_update",
+				toolCallId,
+				status: "in_progress",
+				content: wrapped ? [{
+					type: "content",
+					content: {
+						type: "text",
+						text: wrapped
+					}
+				}] : null,
+				_meta: buildToolMeta(name),
+				rawOutput: partialResult
+			});
+		} else {
+			const text = extractStreamingText(partialResult);
+			this.emit({
+				sessionUpdate: "tool_call_update",
+				toolCallId,
+				status: "in_progress",
+				content: text ? [{
+					type: "content",
+					content: {
+						type: "text",
+						text
+					}
+				}] : null,
+				_meta: buildToolMeta(name),
+				rawOutput: partialResult
+			});
+		}
+	}
+	handleToolEnd(toolCallId, toolName, result, isError) {
+		const snapshot = this.editSnapshots.get(toolCallId);
+		let content = null;
+		if (!isError && snapshot) try {
+			const newText = readFileSync(snapshot.path, "utf8");
+			if (newText !== snapshot.oldText) {
+				const formatted = formatToolContent(toolName, result, isError);
+				content = [{
+					type: "diff",
+					path: snapshot.path,
+					oldText: snapshot.oldText,
+					newText
+				}, ...formatted];
+			}
+		} catch {}
+		if (content === null) {
+			const formatted = formatToolContent(toolName, result, isError);
+			content = formatted.length > 0 ? formatted : null;
+		}
+		if (content === null && !isError && toolName !== "edit" && toolName !== "write") {
+			const text = extractStreamingText(result);
+			if (text) content = [{
+				type: "content",
+				content: {
+					type: "text",
+					text
+				}
+			}];
+		}
+		if (this.supportsTerminalOutput && isTerminalTool(toolName)) {
+			const outputText = extractStreamingText(result);
+			if (outputText !== "") this.emit({
+				sessionUpdate: "tool_call_update",
+				toolCallId,
+				status: "in_progress",
+				_meta: buildToolMeta(toolName, { terminal_output: {
+					terminal_id: toolCallId,
+					data: outputText
+				} }),
+				rawOutput: result
+			});
+		}
+		const meta = buildToolMeta(toolName, this.supportsTerminalOutput && isTerminalTool(toolName) ? { terminal_exit: {
+			terminal_id: toolCallId,
+			exit_code: extractExitCode(result),
+			signal: null
+		} } : void 0);
+		this.emit({
+			sessionUpdate: "tool_call_update",
+			toolCallId,
+			status: isError ? "failed" : "completed",
+			content,
+			_meta: meta,
+			rawOutput: result
+		});
+		this.currentToolCalls.delete(toolCallId);
+		this.editSnapshots.delete(toolCallId);
+		this.toolCallNames.delete(toolCallId);
+	}
+	handleAgentEnd() {
+		this.emitUsageUpdate();
+		this.flushEmits().finally(() => {
+			const reason = this.cancelRequested ? "cancelled" : mapPiStopReason(this.lastAssistantStopReason);
+			this.lastAssistantStopReason = null;
+			this.pendingTurn?.resolve(reason);
+			this.pendingTurn = null;
+			this.dequeueNextPrompt();
+		});
+	}
+	/**
+	* Emit a usage_update notification with current context and cost data.
+	*/
+	emitUsageUpdate() {
+		const contextUsage = this.piSession.getContextUsage?.();
+		const stats = this.piSession.getSessionStats();
+		const used = contextUsage?.tokens ?? 0;
+		const size = contextUsage?.contextWindow ?? 0;
+		this.emit({
+			sessionUpdate: "usage_update",
+			used,
+			size,
+			cost: stats.cost > 0 ? {
+				amount: stats.cost,
+				currency: "USD"
+			} : null
+		});
+	}
+	/**
+	* Build ACP Usage data from pi session stats for prompt response.
+	*/
+	getUsage() {
+		const stats = this.piSession.getSessionStats();
+		return {
+			inputTokens: stats.tokens.input,
+			outputTokens: stats.tokens.output,
+			cachedReadTokens: stats.tokens.cacheRead,
+			cachedWriteTokens: stats.tokens.cacheWrite
+		};
+	}
+	/**
+	* Get cumulative session cost.
+	*/
+	getCost() {
+		return this.piSession.getSessionStats().cost;
+	}
+};
+function isTextBlock$1(v) {
+	return typeof v === "object" && v !== null && "type" in v && v.type === "text" && "text" in v && typeof v.text === "string";
+}
+function extractStreamingText(result) {
+	if (result === null || result === void 0) return "";
+	if (typeof result === "string") return result;
+	if (typeof result !== "object") return String(result);
+	if ("content" in result && Array.isArray(result.content)) {
+		const texts = [];
+		for (const raw of result.content) if (isTextBlock$1(raw)) texts.push(raw.text);
+		if (texts.length > 0) return texts.join("");
+	}
+	if ("details" in result) {
+		const details = result.details;
+		if (typeof details === "object" && details !== null) {
+			if ("stdout" in details && typeof details.stdout === "string" && details.stdout.trim() !== "") return details.stdout;
+			if ("output" in details && typeof details.output === "string" && details.output.trim() !== "") return details.output;
+		}
+	}
+	if ("output" in result && typeof result.output === "string" && result.output.trim() !== "") return result.output;
+	if ("stdout" in result && typeof result.stdout === "string" && result.stdout.trim() !== "") return result.stdout;
+	return "";
+}
+function extractExitCode(result) {
+	if (result === null || result === void 0 || typeof result !== "object") return null;
+	if ("details" in result) {
+		const details = result.details;
+		if (typeof details === "object" && details !== null) {
+			if ("exitCode" in details && typeof details.exitCode === "number") return details.exitCode;
+			if ("code" in details && typeof details.code === "number") return details.code;
+		}
+	}
+	if ("exitCode" in result && typeof result.exitCode === "number") return result.exitCode;
+	if ("code" in result && typeof result.code === "number") return result.code;
+	return null;
+}
+/**
+* Type guard to narrow AgentSessionEvent to the AgentEvent subset
+* (the variants we handle). Session-specific events like auto_compaction
+* are ignored.
+*/
+function isAgentEvent(ev) {
+	return ev.type === "message_update" || ev.type === "message_end" || ev.type === "tool_execution_start" || ev.type === "tool_execution_update" || ev.type === "tool_execution_end" || ev.type === "agent_end";
+}
+//#endregion
+//#region src/acp/translate/pi-messages.ts
+function isTextBlock(block) {
+	if (typeof block !== "object" || block === null) return false;
+	return "type" in block && block.type === "text" && "text" in block && typeof block.text === "string";
+}
+function extractUserMessageText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter(isTextBlock).map((b) => b.text).join("");
+}
+//#endregion
+//#region src/acp/translate/prompt.ts
+function acpPromptToPiMessage(blocks) {
+	let message = "";
+	const images = [];
+	for (const block of blocks) switch (block.type) {
+		case "text":
+			message += block.text;
+			break;
+		case "resource_link":
+			message += `\n[Context] ${block.uri}`;
+			break;
+		case "image":
+			images.push({
+				type: "image",
+				mimeType: block.mimeType,
+				data: block.data
+			});
+			break;
+		case "resource": {
+			const resource = block.resource;
+			const uri = resource.uri;
+			const mime = resource.mimeType ?? null;
+			if ("text" in resource) message += `\n[Embedded Context] ${uri} (${mime ?? "text/plain"})\n${resource.text}`;
+			else if ("blob" in resource) {
+				const bytes = Buffer.byteLength(resource.blob, "base64");
+				message += `\n[Embedded Context] ${uri} (${mime ?? "application/octet-stream"}, ${bytes} bytes)`;
+			} else message += `\n[Embedded Context] ${uri}`;
+			break;
+		}
+		case "audio": {
+			const bytes = Buffer.byteLength(block.data, "base64");
+			message += `\n[Audio] (${block.mimeType}, ${bytes} bytes) not supported`;
+			break;
+		}
+		default: break;
+	}
+	return {
+		message,
+		images
+	};
+}
+//#endregion
+//#region src/mcp/fingerprint.ts
+function sortedEntries(values) {
+	return Object.entries(values).sort(([left], [right]) => left.localeCompare(right));
+}
+function fingerprintMcpServers(servers) {
+	const canonical = [...servers].sort((left, right) => left.stableName.localeCompare(right.stableName)).map((server) => server.kind === "stdio" ? {
+		kind: server.kind,
+		originalName: server.originalName,
+		stableName: server.stableName,
+		command: server.command,
+		args: server.args,
+		env: sortedEntries(server.env),
+		cwd: server.cwd
+	} : {
+		kind: server.kind,
+		originalName: server.originalName,
+		stableName: server.stableName,
+		url: server.url,
+		headers: sortedEntries(server.headers)
+	});
+	return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+//#endregion
+//#region src/mcp/types.ts
+var McpConfigurationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "McpConfigurationError";
+	}
+};
+//#endregion
+//#region src/mcp/normalize.ts
+const INVALID_HEADER_CHARACTER = /[\r\n]/;
+const LOOPBACK_HOSTS = new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+function stableServerName(name) {
+	return name.replaceAll(/[^A-Za-z0-9_-]/g, "_");
+}
+function validateCwd(cwd) {
+	if (!isAbsolute(cwd)) throw new McpConfigurationError(`MCP cwd must be an absolute path: ${cwd}`);
+	try {
+		if (!statSync(cwd).isDirectory()) throw new McpConfigurationError(`MCP cwd is not a directory: ${cwd}`);
+	} catch (error) {
+		if (error instanceof McpConfigurationError) throw error;
+		throw new McpConfigurationError(`MCP cwd does not exist: ${cwd}`);
+	}
+}
+function normalizeName(name) {
+	const originalName = name.trim();
+	if (originalName.length === 0) throw new McpConfigurationError("MCP server name must not be empty");
+	const stableName = stableServerName(originalName);
+	if (stableName.length === 0) throw new McpConfigurationError(`MCP server name cannot be normalized safely: ${name}`);
+	return {
+		originalName,
+		stableName
+	};
+}
+function normalizeKeyValuePairs(pairs, kind) {
+	const result = {};
+	const seen = /* @__PURE__ */ new Set();
+	for (const pair of pairs) {
+		const key = pair.name.trim();
+		if (key.length === 0) throw new McpConfigurationError(`MCP ${kind} name must not be empty`);
+		if (INVALID_HEADER_CHARACTER.test(key) || INVALID_HEADER_CHARACTER.test(pair.value)) throw new McpConfigurationError(`MCP ${kind} contains a forbidden newline`);
+		const identity = kind === "header" ? key.toLowerCase() : key;
+		if (seen.has(identity)) throw new McpConfigurationError(`Duplicate MCP ${kind} key: ${key}`);
+		seen.add(identity);
+		result[key] = pair.value;
+	}
+	return Object.fromEntries(Object.entries(result).sort(([left], [right]) => left.localeCompare(right)));
+}
+function normalizeStdioServer(server, cwd) {
+	const names = normalizeName(server.name);
+	if (server.command.trim().length === 0) throw new McpConfigurationError(`MCP stdio server "${names.originalName}" command must not be empty`);
+	return {
+		kind: "stdio",
+		...names,
+		command: server.command,
+		args: [...server.args],
+		env: normalizeKeyValuePairs(server.env, "environment"),
+		cwd
+	};
+}
+function normalizeHttpServer(server) {
+	const names = normalizeName(server.name);
+	let url;
+	try {
+		url = new URL(server.url);
+	} catch {
+		throw new McpConfigurationError(`Invalid MCP HTTP URL for "${names.originalName}"`);
+	}
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname))) throw new McpConfigurationError(`MCP HTTP server "${names.originalName}" must use HTTPS unless it is loopback`);
+	return {
+		kind: "http",
+		...names,
+		url: url.toString(),
+		headers: normalizeKeyValuePairs(server.headers, "header")
+	};
+}
+function normalizeMcpServers(servers, cwd) {
+	validateCwd(cwd);
+	if ((servers?.length ?? 0) > 32) throw new McpConfigurationError(`A session may configure at most 32 MCP servers`);
+	const normalized = (servers ?? []).map((server) => {
+		if (!("type" in server)) return normalizeStdioServer(server, cwd);
+		if (server.type === "http") return normalizeHttpServer(server);
+		throw new McpConfigurationError(`Unsupported MCP transport "${server.type}"`);
+	});
+	const originalNames = /* @__PURE__ */ new Set();
+	const stableNames = /* @__PURE__ */ new Set();
+	for (const server of normalized) {
+		if (originalNames.has(server.originalName)) throw new McpConfigurationError(`Duplicate MCP server name: ${server.originalName}`);
+		if (stableNames.has(server.stableName)) throw new McpConfigurationError(`Duplicate MCP server stable name: ${server.stableName}`);
+		originalNames.add(server.originalName);
+		stableNames.add(server.stableName);
+	}
+	return normalized;
+}
+//#endregion
+//#region src/mcp/http-connection.ts
+var HttpTransportBridge = class {
+	onclose;
+	onerror;
+	onmessage;
+	constructor(transport) {
+		this.transport = transport;
+	}
+	start() {
+		this.transport.onclose = () => this.onclose?.();
+		this.transport.onerror = (error) => this.onerror?.(error);
+		this.transport.onmessage = (message) => this.onmessage?.(message);
+		return this.transport.start();
+	}
+	close() {
+		return this.transport.close();
+	}
+	send(message) {
+		return this.transport.send(message);
+	}
+};
+var McpHttpConnection = class McpHttpConnection {
+	client;
+	server;
+	#state = "starting";
+	#closePromise;
+	constructor(server, client) {
+		this.server = server;
+		this.client = client;
+	}
+	static async open(server) {
+		const client = new Client({
+			name: "pi-acp",
+			version: "0.5.0"
+		});
+		const connection = new McpHttpConnection(server, client);
+		const transport = new HttpTransportBridge(new StreamableHTTPClientTransport(new URL(server.url), { requestInit: { headers: server.headers } }));
+		try {
+			await client.connect(transport);
+			connection.#state = "ready";
+			return connection;
+		} catch (error) {
+			connection.#state = "failed";
+			await connection.close();
+			throw error;
+		}
+	}
+	get state() {
+		return this.#state;
+	}
+	get pid() {
+		return 0;
+	}
+	async close() {
+		if (this.#closePromise !== void 0) return this.#closePromise;
+		this.#state = "closing";
+		this.#closePromise = this.client.close().finally(() => {
+			this.#state = "closed";
+		});
+		return this.#closePromise;
+	}
+};
+//#endregion
+//#region src/mcp/stdio-connection.ts
+const DEFAULT_INITIALIZE_TIMEOUT_MS = 1e4;
+const DEFAULT_STDERR_LIMIT_BYTES = 64 * 1024;
+var McpConnectionError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "McpConnectionError";
+	}
+};
+var McpStdioConnection = class McpStdioConnection {
+	client;
+	server;
+	#state = "starting";
+	#stderr = "";
+	#closePromise;
+	#stderrLimitBytes;
+	#transport;
+	constructor(server, transport, client, stderrLimitBytes) {
+		this.server = server;
+		this.#transport = transport;
+		this.client = client;
+		this.#stderrLimitBytes = stderrLimitBytes;
+		transport.stderr?.on("data", (chunk) => {
+			this.#appendStderr(chunk);
+		});
+	}
+	static async open(server, options = {}) {
+		const transport = new StdioClientTransport({
+			command: server.command,
+			args: server.args,
+			env: {
+				...getDefaultEnvironment(),
+				...server.env
+			},
+			cwd: server.cwd,
+			stderr: "pipe"
+		});
+		const client = new Client({
+			name: "pi-acp",
+			version: "0.5.0"
+		});
+		const connection = new McpStdioConnection(server, transport, client, options.stderrLimitBytes ?? DEFAULT_STDERR_LIMIT_BYTES);
+		try {
+			await client.connect(transport, { timeout: options.initializeTimeoutMs ?? DEFAULT_INITIALIZE_TIMEOUT_MS });
+			connection.#state = "ready";
+			return connection;
+		} catch (cause) {
+			connection.#state = "failed";
+			await connection.close();
+			throw new McpConnectionError(`MCP server "${server.originalName}" failed to initialize${connection.#stderrSuffix()}`, { cause });
+		}
+	}
+	get state() {
+		return this.#state;
+	}
+	get pid() {
+		return this.#transport.pid ?? 0;
+	}
+	get stderr() {
+		return this.#stderr;
+	}
+	async close() {
+		if (this.#closePromise !== void 0) return this.#closePromise;
+		this.#state = "closing";
+		this.#closePromise = this.client.close().finally(() => {
+			this.#state = "closed";
+		});
+		return this.#closePromise;
+	}
+	#appendStderr(chunk) {
+		let text;
+		if (typeof chunk === "string") text = chunk;
+		else if (chunk instanceof Uint8Array) text = Buffer.from(chunk).toString("utf8");
+		else return;
+		this.#stderr = `${this.#stderr}${text}`.slice(-this.#stderrLimitBytes);
+	}
+	#stderrSuffix() {
+		const diagnostic = this.#stderr.trim();
+		return diagnostic.length === 0 ? "" : `: ${diagnostic}`;
+	}
+};
+//#endregion
+//#region src/mcp/session-manager.ts
+var McpSessionManager = class McpSessionManager {
+	fingerprint;
+	#state = "starting";
+	#closePromise;
+	#connections = /* @__PURE__ */ new Map();
+	constructor(servers) {
+		this.fingerprint = fingerprintMcpServers(servers);
+	}
+	static async open(servers, options = {}) {
+		const manager = new McpSessionManager(servers);
+		for (const server of servers) try {
+			const connection = server.kind === "stdio" ? await McpStdioConnection.open(server, options.connection) : await McpHttpConnection.open(server);
+			manager.#connections.set(server.stableName, connection);
+		} catch (cause) {
+			await manager.close();
+			throw new McpConnectionError(`MCP session startup failed at server "${server.originalName}"`, { cause });
+		}
+		manager.#state = "ready";
+		return manager;
+	}
+	get state() {
+		return this.#state;
+	}
+	get connections() {
+		return [...this.#connections.values()];
+	}
+	get(stableName) {
+		const connection = this.#connections.get(stableName);
+		if (connection === void 0) throw new McpConnectionError(`Unknown MCP server: ${stableName}`);
+		return connection;
+	}
+	async close() {
+		if (this.#closePromise !== void 0) return this.#closePromise;
+		this.#state = "closing";
+		this.#closePromise = Promise.allSettled([...this.#connections.values()].map((connection) => connection.close())).then(() => {
+			this.#connections.clear();
+			this.#state = "closed";
+		});
+		return this.#closePromise;
+	}
+};
+//#endregion
+//#region src/mcp/tool-adapter.ts
+var McpToolExecutionError = class extends Error {
+	serverName;
+	toolName;
+	constructor(serverName, toolName, message) {
+		super(message);
+		this.name = "McpToolExecutionError";
+		this.serverName = serverName;
+		this.toolName = toolName;
+	}
+};
+function sanitizeToolNamePart(value) {
+	return value.replaceAll(/[^A-Za-z0-9_]/g, "_");
+}
+function mcpToolName(serverName, toolName) {
+	return `mcp__${sanitizeToolNamePart(serverName)}__${sanitizeToolNamePart(toolName)}`;
+}
+function validateUniqueMcpToolNames(tools) {
+	const names = /* @__PURE__ */ new Set();
+	for (const tool of tools) {
+		const name = mcpToolName(tool.serverName, tool.toolName);
+		if (names.has(name)) throw new McpToolExecutionError(tool.serverName, tool.toolName, `MCP tool name collision after sanitization: ${name}`);
+		names.add(name);
+	}
+}
+function mcpResultToPiContent(result) {
+	const content = [];
+	for (const block of result.content) switch (block.type) {
+		case "text":
+			content.push({
+				type: "text",
+				text: block.text
+			});
+			break;
+		case "image":
+			content.push({
+				type: "image",
+				data: block.data,
+				mimeType: block.mimeType
+			});
+			break;
+		case "audio":
+			content.push({
+				type: "text",
+				text: `[MCP audio: ${block.mimeType}]`
+			});
+			break;
+		case "resource_link":
+			content.push({
+				type: "text",
+				text: `[MCP resource link: ${block.name}](${block.uri})`
+			});
+			break;
+		case "resource":
+			content.push({
+				type: "text",
+				text: "text" in block.resource ? `[MCP resource: ${block.resource.uri}]\n${block.resource.text}` : `[MCP binary resource: ${block.resource.uri}${block.resource.mimeType === void 0 ? "" : ` (${block.resource.mimeType})`}]`
+			});
+			break;
+	}
+	if (result.structuredContent !== void 0) content.push({
+		type: "text",
+		text: `[MCP structured content]\n${JSON.stringify(result.structuredContent)}`
+	});
+	return content;
+}
+function errorMessage(content) {
+	const text = content.filter((block) => block.type === "text").map((block) => block.text).join("\n").trim();
+	return text.length === 0 ? "MCP tool returned an error" : text;
+}
+async function invokeMcpTool(connection, toolName, arguments_, signal) {
+	const rawResult = await connection.client.callTool({
+		name: toolName,
+		arguments: arguments_
+	}, CallToolResultSchema, signal === void 0 ? void 0 : { signal });
+	const result = CallToolResultSchema.parse(rawResult);
+	const content = mcpResultToPiContent(result);
+	if (result.isError === true) throw new McpToolExecutionError(connection.server.originalName, toolName, errorMessage(content));
+	return {
+		content,
+		details: {
+			serverName: connection.server.originalName,
+			toolName,
+			...result.structuredContent === void 0 ? {} : { structuredContent: result.structuredContent }
+		}
+	};
+}
+async function buildMcpTools(manager) {
+	const discovered = await Promise.all(manager.connections.map(async (connection) => ({
+		connection,
+		tools: (await connection.client.listTools()).tools
+	})));
+	validateUniqueMcpToolNames(discovered.flatMap(({ connection, tools }) => tools.map((tool) => ({
+		serverName: connection.server.stableName,
+		toolName: tool.name
+	}))));
+	return discovered.flatMap(({ connection, tools }) => tools.map((tool) => defineTool({
+		name: mcpToolName(connection.server.stableName, tool.name),
+		label: `${connection.server.originalName} / ${tool.name}`,
+		description: tool.description ?? `MCP tool ${tool.name}`,
+		parameters: Unsafe(tool.inputSchema),
+		execute: async (_toolCallId, params, signal) => invokeMcpTool(connection, tool.name, params, signal)
+	})));
+}
+//#endregion
+//#region package.json
+var name = "@ccgv2/pi-acp";
+var version = "0.5.0";
+//#endregion
+//#region src/acp/agent.ts
+function assertResumeMcpCompatible(existing, requested) {
+	if (existing !== requested) throw RequestError.invalidParams("MCP configuration does not match the live session; close and load it with the new configuration");
+}
+/** Builtin ACP slash commands handled directly by the adapter. */
+const BUILTIN_COMMANDS = [
+	{
+		name: "compact",
+		description: "Manually compact the session context",
+		input: { hint: "optional custom instructions" }
+	},
+	{
+		name: "autocompact",
+		description: "Toggle automatic context compaction",
+		input: { hint: "on|off|toggle" }
+	},
+	{
+		name: "export",
+		description: "Export session to an HTML file in the session cwd"
+	},
+	{
+		name: "session",
+		description: "Show session stats (messages, tokens, cost, session file)"
+	},
+	{
+		name: "name",
+		description: "Set session display name",
+		input: { hint: "<name>" }
+	},
+	{
+		name: "steering",
+		description: "Get/set pi steering message delivery mode",
+		input: { hint: "(no args to show) all | one-at-a-time" }
+	},
+	{
+		name: "follow-up",
+		description: "Get/set pi follow-up message delivery mode",
+		input: { hint: "(no args to show) all | one-at-a-time" }
+	},
+	{
+		name: "changelog",
+		description: "Show pi changelog"
+	}
+];
+/**
+* Deduplicate commands by name. First occurrence wins.
+*/
+function deduplicateCommands(commands) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const c of commands) {
+		if (seen.has(c.name)) continue;
+		seen.add(c.name);
+		out.push(c);
+	}
+	return out;
+}
+function parseArgs(input) {
+	const args = [];
+	let current = "";
+	let quote = null;
+	for (const ch of input) if (quote !== null) if (ch === quote) quote = null;
+	else current += ch;
+	else if (ch === "\"" || ch === "'") quote = ch;
+	else if (ch === " " || ch === "	") {
+		if (current !== "") {
+			args.push(current);
+			current = "";
+		}
+	} else current += ch;
+	if (current !== "") args.push(current);
+	return args;
+}
+const SESSION_TITLE_MAX = 100;
+function truncateSessionTitle(text) {
+	const trimmed = text.trim();
+	if (trimmed === "") return null;
+	const oneLine = trimmed.replace(/\n/g, " ");
+	if (oneLine.length <= SESSION_TITLE_MAX) return oneLine;
+	return `${oneLine.slice(0, SESSION_TITLE_MAX - 1)}…`;
+}
+var PiAcpAgent = class {
+	conn;
+	sessions = new SessionManager$1();
+	createPiSession;
+	mcpInitializeTimeoutMs;
+	/** Cache of sessionId → file path, populated by listSessions and newSession. */
+	sessionPaths = /* @__PURE__ */ new Map();
+	/** Parsed client capability flags from initialize(). */
+	clientCapabilities = {
+		terminalOutput: false,
+		terminalAuth: false,
+		gatewayAuth: false
+	};
+	dispose() {
+		this.sessions.disposeAll();
+	}
+	constructor(conn, config = {}) {
+		this.conn = conn;
+		this.createPiSession = config.createAgentSession ?? createAgentSession;
+		this.mcpInitializeTimeoutMs = config.mcpInitializeTimeoutMs;
+	}
+	async initialize(params) {
+		const supportedVersion = 1;
+		const requested = params.protocolVersion;
+		this.clientCapabilities = parseClientCapabilities(params.clientCapabilities);
+		return {
+			protocolVersion: requested === supportedVersion ? requested : supportedVersion,
+			agentInfo: {
+				name,
+				title: "pi ACP adapter",
+				version
+			},
+			authMethods: buildAuthMethods({ supportsTerminalAuthMeta: this.clientCapabilities.terminalAuth }),
+			agentCapabilities: {
+				loadSession: true,
+				mcpCapabilities: {
+					http: true,
+					sse: false
+				},
+				promptCapabilities: {
+					image: true,
+					audio: false,
+					embeddedContext: true
+				},
+				sessionCapabilities: {
+					list: {},
+					close: {},
+					resume: {},
+					fork: {}
+				}
+			}
+		};
+	}
+	async newSession(params) {
+		if (!isAbsolute(params.cwd)) throw RequestError.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+		const { manager: mcpManager, tools: customTools } = await this.openMcpRuntime(params.mcpServers, params.cwd);
+		let result;
+		try {
+			result = await this.createPiSession({
+				cwd: params.cwd,
+				customTools
+			});
+		} catch (e) {
+			await mcpManager.close();
+			const authErr = detectAuthError(e);
+			if (authErr !== null) throw authErr;
+			const msg = e instanceof Error ? e.message : String(e);
+			throw RequestError.internalError({}, `Failed to create pi session: ${msg}`);
+		}
+		const piSession = result.session;
+		if (piSession.modelRegistry.getAvailable().length === 0) {
+			piSession.dispose();
+			throw RequestError.authRequired({ authMethods: buildAuthMethods() }, "Configure an API key or log in with an OAuth provider.");
+		}
+		const sessionId = piSession.sessionManager.getSessionId();
+		const sessionFile = piSession.sessionManager.getSessionFile();
+		if (sessionFile !== void 0) this.sessionPaths.set(sessionId, sessionFile);
+		const session = new PiAcpSession({
+			sessionId,
+			cwd: params.cwd,
+			mcpServers: params.mcpServers,
+			piSession,
+			mcpManager,
+			conn: this.conn,
+			supportsTerminalOutput: this.clientCapabilities.terminalOutput
+		});
+		this.sessions.register(session);
+		const modes = buildThinkingModes(piSession);
+		const models = buildModelState(piSession);
+		const configOptions = buildConfigOptions(modes, models);
+		const enableSkillCommands = skillCommandsEnabled(params.cwd);
+		setTimeout(() => {
+			(async () => {
+				try {
+					const commands = buildCommandList(piSession, enableSkillCommands);
+					await this.conn.sessionUpdate({
+						sessionId: session.sessionId,
+						update: {
+							sessionUpdate: "available_commands_update",
+							availableCommands: deduplicateCommands([...commands, ...BUILTIN_COMMANDS])
+						}
+					});
+				} catch {}
+			})();
+		}, 0);
+		return {
+			sessionId: session.sessionId,
+			configOptions,
+			modes,
+			models
+		};
+	}
+	async authenticate(_params) {
+		return {};
+	}
+	async prompt(params) {
+		const session = this.sessions.get(params.sessionId);
+		const { message, images } = acpPromptToPiMessage(params.prompt);
+		if (images.length === 0 && message.trimStart().startsWith("/")) {
+			const trimmed = message.trim();
+			const space = trimmed.indexOf(" ");
+			const cmd = space === -1 ? trimmed.slice(1) : trimmed.slice(1, space);
+			const args = parseArgs(space === -1 ? "" : trimmed.slice(space + 1));
+			const handled = await this.handleBuiltinCommand(session, cmd, args);
+			if (handled) return handled;
+		}
+		const result = await session.prompt(message, images);
+		const stopReason = result === "error" ? "end_turn" : result;
+		const usage = session.getUsage();
+		const cost = session.getCost();
+		return {
+			stopReason,
+			usage: {
+				inputTokens: usage.inputTokens,
+				outputTokens: usage.outputTokens,
+				cachedReadTokens: usage.cachedReadTokens,
+				cachedWriteTokens: usage.cachedWriteTokens,
+				totalTokens: usage.inputTokens + usage.outputTokens
+			},
+			_meta: cost > 0 ? { cost: {
+				amount: cost,
+				currency: "USD"
+			} } : {}
+		};
+	}
+	async cancel(params) {
+		await this.sessions.get(params.sessionId).cancel();
+	}
+	/**
+	* Resolve a session ID to a file path.
+	* Checks the local cache first (populated by listSessions/newSession),
+	* falls back to a full listAll() scan on cache miss.
+	*/
+	async resolveSessionFile(sessionId) {
+		const cached = this.sessionPaths.get(sessionId);
+		if (cached !== void 0) return cached;
+		const all = await SessionManager.listAll();
+		for (const s of all) this.sessionPaths.set(s.id, s.path);
+		return this.sessionPaths.get(sessionId) ?? null;
+	}
+	/**
+	* Replay persisted session messages as ACP session updates.
+	*
+	* Iterates through the message history, emitting structured updates for each
+	* content block type: text, thinking, tool calls, and tool results. A map of
+	* tool call IDs to their invocation data (from assistant messages) is built
+	* to enrich subsequent tool result updates with rawInput and locations.
+	*/
+	async replaySessionHistory(session, messages) {
+		const toolCallMap = /* @__PURE__ */ new Map();
+		for (const m of messages) {
+			if (!("role" in m)) continue;
+			if (m.role === "user") {
+				const text = extractUserMessageText(m.content);
+				if (text) await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "user_message_chunk",
+						content: {
+							type: "text",
+							text
+						}
+					}
+				});
+				continue;
+			}
+			if (m.role === "assistant") {
+				const am = m;
+				for (const block of am.content) if (block.type === "text" && block.text) await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: block.text
+						}
+					}
+				});
+				else if (block.type === "thinking" && block.thinking) await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_thought_chunk",
+						content: {
+							type: "text",
+							text: block.thinking
+						}
+					}
+				});
+				else if (block.type === "toolCall") {
+					const args = toToolArgs(block.arguments);
+					toolCallMap.set(block.id, {
+						name: block.name,
+						args
+					});
+					const locations = resolveToolPath(args, session.cwd);
+					await this.conn.sessionUpdate({
+						sessionId: session.sessionId,
+						update: {
+							sessionUpdate: "tool_call",
+							toolCallId: block.id,
+							title: buildToolTitle(block.name, args),
+							kind: toToolKind(block.name),
+							status: "completed",
+							rawInput: args,
+							...locations ? { locations } : {},
+							_meta: { piAcp: { toolName: block.name } }
+						}
+					});
+				}
+				continue;
+			}
+			if (m.role === "toolResult") {
+				const tr = m;
+				const toolName = tr.toolName;
+				const toolCallId = tr.toolCallId;
+				const isError = tr.isError;
+				const invocation = toolCallMap.get(toolCallId);
+				const args = invocation?.args;
+				const locations = args !== void 0 ? resolveToolPath(args, session.cwd) : void 0;
+				if (invocation === void 0) await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "tool_call",
+						toolCallId,
+						title: buildToolTitle(toolName, {}),
+						kind: toToolKind(toolName),
+						status: "completed",
+						rawInput: null,
+						rawOutput: m,
+						_meta: { piAcp: { toolName } }
+					}
+				});
+				const content = formatToolContent(toolName, m, isError);
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "tool_call_update",
+						toolCallId,
+						status: isError ? "failed" : "completed",
+						content: content.length > 0 ? content : null,
+						rawOutput: m,
+						...locations ? { locations } : {},
+						_meta: { piAcp: { toolName } }
+					}
+				});
+			}
+		}
+	}
+	async listSessions(params) {
+		const cwd = params.cwd;
+		const raw = cwd !== void 0 && cwd !== null ? await SessionManager.list(cwd) : await SessionManager.listAll();
+		for (const s of raw) this.sessionPaths.set(s.id, s.path);
+		const sessions = raw.map((s) => ({
+			id: s.id,
+			cwd: s.cwd,
+			name: s.name,
+			firstMessage: s.firstMessage,
+			modified: s.modified,
+			messageCount: s.messageCount
+		}));
+		if (params.cursor !== void 0 && params.cursor !== null) {
+			const parsed = Number.parseInt(params.cursor, 10);
+			if (!Number.isFinite(parsed) || parsed < 0) throw RequestError.invalidParams(`Invalid cursor: ${params.cursor}`);
+		}
+		const start = params.cursor !== void 0 && params.cursor !== null ? Number.parseInt(params.cursor, 10) : 0;
+		const PAGE_SIZE = 50;
+		return {
+			sessions: sessions.slice(start, start + PAGE_SIZE).map((s) => ({
+				sessionId: s.id,
+				cwd: s.cwd,
+				title: (s.name !== void 0 && s.name !== "" ? s.name : null) ?? truncateSessionTitle(s.firstMessage) ?? null,
+				updatedAt: s.modified.toISOString()
+			})),
+			nextCursor: start + PAGE_SIZE < sessions.length ? String(start + PAGE_SIZE) : null,
+			_meta: {}
+		};
+	}
+	async loadSession(params) {
+		if (!isAbsolute(params.cwd)) throw RequestError.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+		await this.sessions.closeAsync(params.sessionId);
+		const sessionFile = await this.resolveSessionFile(params.sessionId);
+		if (sessionFile === null) throw RequestError.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+		const { manager: mcpManager, tools: customTools } = await this.openMcpRuntime(params.mcpServers, params.cwd);
+		let result;
+		try {
+			const sm = SessionManager.open(sessionFile);
+			result = await this.createPiSession({
+				cwd: params.cwd,
+				sessionManager: sm,
+				customTools
+			});
+		} catch (e) {
+			await mcpManager.close();
+			const authErr = detectAuthError(e);
+			if (authErr !== null) throw authErr;
+			const msg = e instanceof Error ? e.message : String(e);
+			throw RequestError.internalError({}, `Failed to load pi session: ${msg}`);
+		}
+		const piSession = result.session;
+		const session = new PiAcpSession({
+			sessionId: params.sessionId,
+			cwd: params.cwd,
+			mcpServers: params.mcpServers,
+			piSession,
+			mcpManager,
+			conn: this.conn,
+			supportsTerminalOutput: this.clientCapabilities.terminalOutput
+		});
+		this.sessions.register(session);
+		await this.replaySessionHistory(session, piSession.messages);
+		const modes = buildThinkingModes(piSession);
+		const models = buildModelState(piSession);
+		const configOptions = buildConfigOptions(modes, models);
+		const enableSkillCommands = skillCommandsEnabled(params.cwd);
+		setTimeout(() => {
+			(async () => {
+				try {
+					const commands = buildCommandList(piSession, enableSkillCommands);
+					await this.conn.sessionUpdate({
+						sessionId: session.sessionId,
+						update: {
+							sessionUpdate: "available_commands_update",
+							availableCommands: deduplicateCommands([...commands, ...BUILTIN_COMMANDS])
+						}
+					});
+				} catch {}
+			})();
+		}, 0);
+		return {
+			configOptions,
+			modes,
+			models
+		};
+	}
+	async closeSession(params) {
+		if (this.sessions.maybeGet(params.sessionId) === void 0) throw RequestError.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+		await this.sessions.closeAsync(params.sessionId);
+		return {};
+	}
+	async resumeSession(params) {
+		if (!isAbsolute(params.cwd)) throw RequestError.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+		const existing = this.sessions.maybeGet(params.sessionId);
+		if (existing !== void 0) {
+			if (params.mcpServers !== void 0) {
+				const requestedFingerprint = fingerprintMcpServers(normalizeMcpServers(params.mcpServers, params.cwd));
+				assertResumeMcpCompatible(existing.mcpFingerprint, requestedFingerprint);
+			}
+			const modes = buildThinkingModes(existing.piSession);
+			const models = buildModelState(existing.piSession);
+			return {
+				configOptions: buildConfigOptions(modes, models),
+				modes,
+				models
+			};
+		}
+		const sessionFile = await this.resolveSessionFile(params.sessionId);
+		if (sessionFile === null) throw RequestError.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+		const resumeMcpServers = params.mcpServers ?? [];
+		const { manager: mcpManager, tools: customTools } = await this.openMcpRuntime(resumeMcpServers, params.cwd);
+		let result;
+		try {
+			const sm = SessionManager.open(sessionFile);
+			result = await this.createPiSession({
+				cwd: params.cwd,
+				sessionManager: sm,
+				customTools
+			});
+		} catch (e) {
+			await mcpManager.close();
+			const authErr = detectAuthError(e);
+			if (authErr !== null) throw authErr;
+			const msg = e instanceof Error ? e.message : String(e);
+			throw RequestError.internalError({}, `Failed to resume pi session: ${msg}`);
+		}
+		const piSession = result.session;
+		const session = new PiAcpSession({
+			sessionId: params.sessionId,
+			cwd: params.cwd,
+			mcpServers: resumeMcpServers,
+			piSession,
+			mcpManager,
+			conn: this.conn,
+			supportsTerminalOutput: this.clientCapabilities.terminalOutput
+		});
+		this.sessions.register(session);
+		this.sessionPaths.set(params.sessionId, sessionFile);
+		const enableSkillCommands = skillCommandsEnabled(params.cwd);
+		setTimeout(() => {
+			(async () => {
+				try {
+					const commands = buildCommandList(piSession, enableSkillCommands);
+					await this.conn.sessionUpdate({
+						sessionId: session.sessionId,
+						update: {
+							sessionUpdate: "available_commands_update",
+							availableCommands: deduplicateCommands([...commands, ...BUILTIN_COMMANDS])
+						}
+					});
+				} catch {}
+			})();
+		}, 0);
+		const modes = buildThinkingModes(piSession);
+		const models = buildModelState(piSession);
+		return {
+			configOptions: buildConfigOptions(modes, models),
+			modes,
+			models
+		};
+	}
+	async unstable_forkSession(params) {
+		if (!isAbsolute(params.cwd)) throw RequestError.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
+		const sourceFile = await this.resolveSessionFile(params.sessionId);
+		if (sourceFile === null) throw RequestError.invalidParams(`Unknown sessionId: ${params.sessionId}`);
+		const forkMcpServers = params.mcpServers ?? [];
+		const { manager: mcpManager, tools: customTools } = await this.openMcpRuntime(forkMcpServers, params.cwd);
+		let result;
+		try {
+			const sm = SessionManager.forkFrom(sourceFile, params.cwd);
+			result = await this.createPiSession({
+				cwd: params.cwd,
+				sessionManager: sm,
+				customTools
+			});
+		} catch (e) {
+			await mcpManager.close();
+			const authErr = detectAuthError(e);
+			if (authErr !== null) throw authErr;
+			const msg = e instanceof Error ? e.message : String(e);
+			throw RequestError.internalError({}, `Failed to fork pi session: ${msg}`);
+		}
+		const piSession = result.session;
+		const newSessionId = piSession.sessionManager.getSessionId();
+		const newSessionFile = piSession.sessionManager.getSessionFile();
+		if (newSessionFile !== void 0) this.sessionPaths.set(newSessionId, newSessionFile);
+		const session = new PiAcpSession({
+			sessionId: newSessionId,
+			cwd: params.cwd,
+			mcpServers: forkMcpServers,
+			piSession,
+			mcpManager,
+			conn: this.conn,
+			supportsTerminalOutput: this.clientCapabilities.terminalOutput
+		});
+		this.sessions.register(session);
+		const enableSkillCommands = skillCommandsEnabled(params.cwd);
+		setTimeout(() => {
+			(async () => {
+				try {
+					const commands = buildCommandList(piSession, enableSkillCommands);
+					await this.conn.sessionUpdate({
+						sessionId: session.sessionId,
+						update: {
+							sessionUpdate: "available_commands_update",
+							availableCommands: deduplicateCommands([...commands, ...BUILTIN_COMMANDS])
+						}
+					});
+				} catch {}
+			})();
+		}, 0);
+		const modes = buildThinkingModes(piSession);
+		const models = buildModelState(piSession);
+		return {
+			sessionId: newSessionId,
+			configOptions: buildConfigOptions(modes, models),
+			modes,
+			models
+		};
+	}
+	async openMcpRuntime(mcpServers, cwd) {
+		let manager;
+		try {
+			const normalized = normalizeMcpServers(mcpServers, cwd);
+			manager = await McpSessionManager.open(normalized, this.mcpInitializeTimeoutMs === void 0 ? {} : { connection: { initializeTimeoutMs: this.mcpInitializeTimeoutMs } });
+			return {
+				manager,
+				tools: await buildMcpTools(manager)
+			};
+		} catch (error) {
+			await manager?.close();
+			const message = error instanceof Error ? error.message : "Invalid MCP server configuration";
+			throw RequestError.invalidParams(message);
+		}
+	}
+	async setSessionMode(params) {
+		const session = this.sessions.get(params.sessionId);
+		const mode = String(params.modeId);
+		if (!isThinkingLevel(mode)) throw RequestError.invalidParams(`Unknown modeId: ${mode}`);
+		session.piSession.setThinkingLevel(mode);
+		this.conn.sessionUpdate({
+			sessionId: session.sessionId,
+			update: {
+				sessionUpdate: "current_mode_update",
+				currentModeId: mode
+			}
+		});
+		this.emitConfigOptionUpdate(session);
+		return {};
+	}
+	async unstable_setSessionModel(params) {
+		const session = this.sessions.get(params.sessionId);
+		const available = session.piSession.modelRegistry.getAvailable();
+		const resolved = resolveModelPreference(available, params.modelId);
+		if (resolved === null) throw RequestError.invalidParams(`Unknown modelId: ${params.modelId}`);
+		const model = available.find((m) => m.provider === resolved.provider && m.id === resolved.id);
+		if (!model) throw RequestError.invalidParams(`Unknown modelId: ${params.modelId}`);
+		await session.piSession.setModel(model);
+		this.emitConfigOptionUpdate(session);
+	}
+	async setSessionConfigOption(params) {
+		const session = this.sessions.get(params.sessionId);
+		const configId = String(params.configId);
+		const value = String(params.value);
+		if (configId === "model") {
+			const available = session.piSession.modelRegistry.getAvailable();
+			const resolved = resolveModelPreference(available, value);
+			if (resolved === null) throw RequestError.invalidParams(`Unknown model: ${value}`);
+			const model = available.find((m) => m.provider === resolved.provider && m.id === resolved.id);
+			if (!model) throw RequestError.invalidParams(`Unknown model: ${value}`);
+			await session.piSession.setModel(model);
+		} else if (configId === "thought_level") {
+			if (!isThinkingLevel(value)) throw RequestError.invalidParams(`Unknown thinking level: ${value}`);
+			session.piSession.setThinkingLevel(value);
+		} else throw RequestError.invalidParams(`Unknown config option: ${configId}`);
+		return { configOptions: buildConfigOptions(buildThinkingModes(session.piSession), buildModelState(session.piSession)) };
+	}
+	emitConfigOptionUpdate(session) {
+		const configOptions = buildConfigOptions(buildThinkingModes(session.piSession), buildModelState(session.piSession));
+		this.conn.sessionUpdate({
+			sessionId: session.sessionId,
+			update: {
+				sessionUpdate: "config_option_update",
+				configOptions
+			}
+		});
+	}
+	async handleBuiltinCommand(session, cmd, args) {
+		const piSession = session.piSession;
+		if (cmd === "compact") {
+			const customInstructions = args.join(" ").trim() || void 0;
+			const res = await piSession.compact(customInstructions);
+			const text = [`Compaction completed.${customInstructions !== void 0 && customInstructions !== "" ? " (custom instructions applied)" : ""}`, typeof res?.tokensBefore === "number" ? `Tokens before: ${res.tokensBefore}` : null].filter(Boolean).join("\n") + (res?.summary ? `\n\n${res.summary}` : "");
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "session") {
+			const stats = piSession.getSessionStats();
+			const lines = [];
+			if (stats.sessionId !== void 0 && stats.sessionId !== "") lines.push(`Session: ${stats.sessionId}`);
+			if (stats.sessionFile !== void 0 && stats.sessionFile !== "") lines.push(`Session file: ${stats.sessionFile}`);
+			lines.push(`Messages: ${stats.totalMessages}`);
+			lines.push(`Cost: ${stats.cost}`);
+			const t = stats.tokens;
+			const parts = [];
+			if (t.input) parts.push(`in ${t.input}`);
+			if (t.output) parts.push(`out ${t.output}`);
+			if (t.cacheRead) parts.push(`cache read ${t.cacheRead}`);
+			if (t.cacheWrite) parts.push(`cache write ${t.cacheWrite}`);
+			if (t.total) parts.push(`total ${t.total}`);
+			if (parts.length > 0) lines.push(`Tokens: ${parts.join(", ")}`);
+			const text = lines.join("\n");
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "name") {
+			const name = args.join(" ").trim();
+			if (!name) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Usage: /name <name>"
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			piSession.setSessionName(name);
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "session_info_update",
+					title: name,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				}
+			});
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text: `Session name set: ${name}`
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "steering") {
+			const modeRaw = String(args[0] ?? "").toLowerCase();
+			if (!modeRaw) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `Steering mode: ${piSession.steeringMode}`
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			if (modeRaw !== "all" && modeRaw !== "one-at-a-time") {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Usage: /steering all | /steering one-at-a-time"
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			piSession.setSteeringMode(modeRaw);
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text: `Steering mode set to: ${modeRaw}`
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "follow-up") {
+			const modeRaw = String(args[0] ?? "").toLowerCase();
+			if (!modeRaw) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `Follow-up mode: ${piSession.followUpMode}`
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			if (modeRaw !== "all" && modeRaw !== "one-at-a-time") {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Usage: /follow-up all | /follow-up one-at-a-time"
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			piSession.setFollowUpMode(modeRaw);
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text: `Follow-up mode set to: ${modeRaw}`
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "autocompact") {
+			const mode = (args[0] ?? "toggle").toLowerCase();
+			let enabled = null;
+			if (mode === "on" || mode === "true" || mode === "enable") enabled = true;
+			else if (mode === "off" || mode === "false" || mode === "disable") enabled = false;
+			if (enabled === null) enabled = !piSession.autoCompactionEnabled;
+			piSession.setAutoCompactionEnabled(enabled);
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text: `Auto-compaction ${enabled ? "enabled" : "disabled"}.`
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "changelog") {
+			const changelogPath = findChangelog();
+			if (changelogPath === null) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Changelog not found."
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			let text = "";
+			try {
+				text = readFileSync(changelogPath, "utf-8");
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `Failed to read changelog: ${msg}`
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			const maxChars = 2e4;
+			if (text.length > maxChars) text = `${text.slice(0, maxChars)}\n\n...(truncated)...`;
+			await this.conn.sessionUpdate({
+				sessionId: session.sessionId,
+				update: {
+					sessionUpdate: "agent_message_chunk",
+					content: {
+						type: "text",
+						text
+					}
+				}
+			});
+			return { stopReason: "end_turn" };
+		}
+		if (cmd === "export") {
+			if (piSession.messages.length === 0) {
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Nothing to export yet. Send a prompt first."
+						}
+					}
+				});
+				return { stopReason: "end_turn" };
+			}
+			try {
+				const safeSessionId = session.sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+				const outputPath = join(session.cwd, `pi-session-${safeSessionId}.html`);
+				const resultPath = await piSession.exportToHtml(outputPath);
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: "Session exported: "
+						}
+					}
+				});
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "resource_link",
+							name: `pi-session-${safeSessionId}.html`,
+							uri: `file://${resultPath}`,
+							mimeType: "text/html",
+							title: "Session exported"
+						}
+					}
+				});
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				await this.conn.sessionUpdate({
+					sessionId: session.sessionId,
+					update: {
+						sessionUpdate: "agent_message_chunk",
+						content: {
+							type: "text",
+							text: `Export failed: ${msg}`
+						}
+					}
+				});
+			}
+			return { stopReason: "end_turn" };
+		}
+		return null;
+	}
+};
+function isThinkingLevel(x) {
+	return x === "off" || x === "minimal" || x === "low" || x === "medium" || x === "high" || x === "xhigh";
+}
+function buildThinkingModes(piSession) {
+	const levels = piSession.getAvailableThinkingLevels();
+	return {
+		currentModeId: piSession.thinkingLevel,
+		availableModes: levels.map((id) => ({
+			id,
+			name: `Thinking: ${id}`,
+			description: null
+		}))
+	};
+}
+function buildModelState(piSession) {
+	const available = piSession.modelRegistry.getAvailable();
+	const current = piSession.model;
+	const availableModels = available.map((m) => ({
+		modelId: `${m.provider}/${m.id}`,
+		name: `${m.provider}/${m.name ?? m.id}`,
+		description: null
+	}));
+	let currentModelId = "default";
+	if (current !== void 0) currentModelId = `${current.provider}/${current.id}`;
+	else if (availableModels.length > 0 && availableModels[0] !== void 0) currentModelId = availableModels[0].modelId;
+	return {
+		availableModels,
+		currentModelId
+	};
+}
+function buildConfigOptions(modes, models) {
+	return [{
+		id: "model",
+		name: "Model",
+		description: "AI model to use",
+		category: "model",
+		type: "select",
+		currentValue: models.currentModelId,
+		options: models.availableModels.map((m) => ({
+			value: m.modelId,
+			name: m.name,
+			description: m.description ?? null
+		}))
+	}, {
+		id: "thought_level",
+		name: "Thinking Level",
+		description: "Reasoning depth for models that support it",
+		category: "thought_level",
+		type: "select",
+		currentValue: modes.currentModeId,
+		options: modes.availableModes.map((m) => ({
+			value: m.id,
+			name: m.name,
+			description: m.description ?? null
+		}))
+	}];
+}
+function buildCommandList(piSession, enableSkillCommands) {
+	const commands = [];
+	for (const template of piSession.promptTemplates) commands.push({
+		name: template.name,
+		description: template.description ?? `(prompt)`
+	});
+	if (enableSkillCommands) {
+		const skills = piSession.resourceLoader.getSkills();
+		for (const skill of skills.skills) commands.push({
+			name: `skill:${skill.name}`,
+			description: skill.description ?? `(skill)`
+		});
+	}
+	for (const cmd of piSession.extensionRunner.getRegisteredCommands()) commands.push({
+		name: cmd.name,
+		description: cmd.description ?? "(extension)"
+	});
+	return commands;
+}
+function findChangelog() {
+	try {
+		const which = spawnSync(process.platform === "win32" ? "where" : "which", ["pi"], { encoding: "utf-8" });
+		const piPath = String(which.stdout ?? "").split(/\r?\n/)[0]?.trim();
+		if (piPath !== void 0 && piPath !== "") {
+			const p = join(dirname(dirname(realpathSync(piPath))), "CHANGELOG.md");
+			if (existsSync(p)) return p;
+		}
+	} catch {}
+	try {
+		const npmRoot = spawnSync("npm", ["root", "-g"], { encoding: "utf-8" });
+		const root = String(npmRoot.stdout ?? "").trim();
+		if (root) {
+			const p = join(root, "@mariozechner", "pi-coding-agent", "CHANGELOG.md");
+			if (existsSync(p)) return p;
+		}
+	} catch {}
+	return null;
+}
+//#endregion
+//#region src/index.ts
+{
+	const toStderr = (...args) => {
+		process.stderr.write(`${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}\n`);
+	};
+	console.log = toStderr;
+	console.info = toStderr;
+	console.warn = toStderr;
+	console.debug = toStderr;
+}
+if (process.argv.includes("--terminal-login")) {
+	const { spawnSync } = await import("node:child_process");
+	const isWindows = platform() === "win32";
+	const cmd = process.env.PI_ACP_PI_COMMAND ?? (isWindows ? "pi.cmd" : "pi");
+	const res = spawnSync(cmd, [], {
+		stdio: "inherit",
+		env: process.env
+	});
+	if (res.error && "code" in res.error && res.error.code === "ENOENT") {
+		process.stderr.write(`pi-acp: could not start pi (command not found: ${cmd}). Install via \`npm install -g @earendil-works/pi-coding-agent\` or ensure \`pi\` is on your PATH.
+`);
+		process.exit(1);
+	}
+	process.exit(typeof res.status === "number" ? res.status : 1);
+}
+const agent = new AgentSideConnection((conn) => new PiAcpAgent(conn), ndJsonStream(new WritableStream({ write(chunk) {
+	return new Promise((resolve) => {
+		if (process.stdout.destroyed || !process.stdout.writable) {
+			resolve();
+			return;
+		}
+		try {
+			process.stdout.write(chunk, () => resolve());
+		} catch {
+			resolve();
+		}
+	});
+} }), new ReadableStream({ start(controller) {
+	process.stdin.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+	process.stdin.on("end", () => controller.close());
+	process.stdin.on("error", (err) => controller.error(err));
+} })));
+let shuttingDown = false;
+function shutdown() {
+	if (shuttingDown) return;
+	shuttingDown = true;
+	try {
+		if ("agent" in agent) {
+			const inner = agent.agent;
+			if (typeof inner === "object" && inner !== null && "dispose" in inner && typeof inner.dispose === "function") inner.dispose();
+		}
+	} catch {}
+	process.exit(0);
+}
+agent.closed.then(shutdown);
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.stdout.on("error", () => process.exit(0));
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map