pi2dsh 0.2.0

package/dist/pi-coding-agent-Dsg6_0ua.mjs

@@ -0,0 +1,2060 @@
+
+import { i as resolvePath, n as getSessionsDir, r as normalizePath, t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
+import { t as uuidv7 } from "./pi-uuid-Db8ShZsK.mjs";
+import { g as visibleWidth, h as truncateToWidth } from "./pi-tui-utils-CcaVtm-3.mjs";
+import { realpath } from "node:fs/promises";
+import { delimiter, join, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { randomUUID } from "crypto";
+import { appendFileSync as appendFileSync$1, closeSync, createReadStream, existsSync as existsSync$1, mkdirSync as mkdirSync$1, openSync, readSync, readdirSync, statSync, writeFileSync as writeFileSync$1 } from "fs";
+import { readdir as readdir$1, stat as stat$1 } from "fs/promises";
+import { join as join$1, resolve as resolve$1 } from "path";
+import { createInterface } from "readline";
+import { StringDecoder } from "string_decoder";
+import { execFile } from "node:child_process";
+//#region src/compat/vendor/pi-messages.ts
+const COMPACTION_SUMMARY_PREFIX = `The conversation history before this point was compacted into the following summary:
+
+<summary>
+`;
+const COMPACTION_SUMMARY_SUFFIX = `
+</summary>`;
+const BRANCH_SUMMARY_PREFIX = `The following is a summary of a branch that this conversation came back from:
+
+<summary>
+`;
+const BRANCH_SUMMARY_SUFFIX = `</summary>`;
+/**
+* Convert a BashExecutionMessage to user message text for LLM context.
+*/
+function bashExecutionToText(msg) {
+	let text = `Ran \`${msg.command}\`\n`;
+	if (msg.output) text += `\`\`\`\n${msg.output}\n\`\`\``;
+	else text += "(no output)";
+	if (msg.cancelled) text += "\n\n(command cancelled)";
+	else if (msg.exitCode !== null && msg.exitCode !== void 0 && msg.exitCode !== 0) text += `\n\nCommand exited with code ${msg.exitCode}`;
+	if (msg.truncated && msg.fullOutputPath) text += `\n\n[Output truncated. Full output: ${msg.fullOutputPath}]`;
+	return text;
+}
+function createBranchSummaryMessage(summary, fromId, timestamp) {
+	return {
+		role: "branchSummary",
+		summary,
+		fromId,
+		timestamp: new Date(timestamp).getTime()
+	};
+}
+function createCompactionSummaryMessage(summary, tokensBefore, timestamp) {
+	return {
+		role: "compactionSummary",
+		summary,
+		tokensBefore,
+		timestamp: new Date(timestamp).getTime()
+	};
+}
+/** Convert CustomMessageEntry to AgentMessage format */
+function createCustomMessage(customType, content, display, details, timestamp) {
+	return {
+		role: "custom",
+		customType,
+		content,
+		display,
+		details,
+		timestamp: new Date(timestamp).getTime()
+	};
+}
+/**
+* Transform AgentMessages (including custom types) to LLM-compatible Messages.
+*
+* This is used by:
+* - Agent's transormToLlm option (for prompt calls and queued messages)
+* - Compaction's generateSummary (for summarization)
+* - Custom extensions and tools
+*/
+function convertToLlm(messages) {
+	return messages.map((m) => {
+		switch (m.role) {
+			case "bashExecution":
+				if (m.excludeFromContext) return;
+				return {
+					role: "user",
+					content: [{
+						type: "text",
+						text: bashExecutionToText(m)
+					}],
+					timestamp: m.timestamp
+				};
+			case "custom": return {
+				role: "user",
+				content: typeof m.content === "string" ? [{
+					type: "text",
+					text: m.content
+				}] : m.content,
+				timestamp: m.timestamp
+			};
+			case "branchSummary": return {
+				role: "user",
+				content: [{
+					type: "text",
+					text: BRANCH_SUMMARY_PREFIX + m.summary + BRANCH_SUMMARY_SUFFIX
+				}],
+				timestamp: m.timestamp
+			};
+			case "compactionSummary": return {
+				role: "user",
+				content: [{
+					type: "text",
+					text: COMPACTION_SUMMARY_PREFIX + m.summary + COMPACTION_SUMMARY_SUFFIX
+				}],
+				timestamp: m.timestamp
+			};
+			case "user":
+			case "assistant":
+			case "toolResult": return m;
+			default: return;
+		}
+	}).filter((m) => m !== void 0);
+}
+//#endregion
+//#region src/compat/vendor/pi-session-manager.ts
+const CURRENT_SESSION_VERSION = 3;
+function createSessionId() {
+	return uuidv7();
+}
+function assertValidSessionId(id) {
+	if (!/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id)) throw new Error("Session id must be non-empty, contain only alphanumeric characters, '-', '_', and '.', and start and end with an alphanumeric character");
+}
+/** Generate a unique short ID (8 hex chars, collision-checked) */
+function generateId(byId) {
+	for (let i = 0; i < 100; i++) {
+		const id = randomUUID().slice(0, 8);
+		if (!byId.has(id)) return id;
+	}
+	return randomUUID();
+}
+/** Migrate v1 → v2: add id/parentId tree structure. Mutates in place. */
+function migrateV1ToV2(entries) {
+	const ids = /* @__PURE__ */ new Set();
+	let prevId = null;
+	for (const entry of entries) {
+		if (entry.type === "session") {
+			entry.version = 2;
+			continue;
+		}
+		entry.id = generateId(ids);
+		entry.parentId = prevId;
+		prevId = entry.id;
+		if (entry.type === "compaction") {
+			const comp = entry;
+			if (typeof comp.firstKeptEntryIndex === "number") {
+				const targetEntry = entries[comp.firstKeptEntryIndex];
+				if (targetEntry && targetEntry.type !== "session") comp.firstKeptEntryId = targetEntry.id;
+				delete comp.firstKeptEntryIndex;
+			}
+		}
+	}
+}
+/** Migrate v2 → v3: rename hookMessage role to custom. Mutates in place. */
+function migrateV2ToV3(entries) {
+	for (const entry of entries) {
+		if (entry.type === "session") {
+			entry.version = 3;
+			continue;
+		}
+		if (entry.type === "message") {
+			const msgEntry = entry;
+			if (msgEntry.message && msgEntry.message.role === "hookMessage") msgEntry.message.role = "custom";
+		}
+	}
+}
+/**
+* Run all necessary migrations to bring entries to current version.
+* Mutates entries in place. Returns true if any migration was applied.
+*/
+function migrateToCurrentVersion(entries) {
+	const version = entries.find((e) => e.type === "session")?.version ?? 1;
+	if (version >= 3) return false;
+	if (version < 2) migrateV1ToV2(entries);
+	if (version < 3) migrateV2ToV3(entries);
+	return true;
+}
+/** Exported for testing */
+function migrateSessionEntries(entries) {
+	migrateToCurrentVersion(entries);
+}
+/** Exported for compaction.test.ts */
+function parseSessionEntries(content) {
+	const entries = [];
+	const lines = content.trim().split("\n");
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		try {
+			const entry = JSON.parse(line);
+			entries.push(entry);
+		} catch {}
+	}
+	return entries;
+}
+function getLatestCompactionEntry(entries) {
+	for (let i = entries.length - 1; i >= 0; i--) if (entries[i].type === "compaction") return entries[i];
+	return null;
+}
+function buildEntryIndex(entries, byId) {
+	if (byId) return byId;
+	const index = /* @__PURE__ */ new Map();
+	for (const entry of entries) index.set(entry.id, entry);
+	return index;
+}
+function buildSessionPath(entries, leafId, byId) {
+	const index = buildEntryIndex(entries, byId);
+	let leaf;
+	if (leafId === null) return [];
+	if (leafId) leaf = index.get(leafId);
+	leaf ??= entries[entries.length - 1];
+	if (!leaf) return [];
+	const path = [];
+	let current = leaf;
+	while (current) {
+		path.push(current);
+		current = current.parentId ? index.get(current.parentId) : void 0;
+	}
+	path.reverse();
+	return path;
+}
+function getSessionContextSettings(path) {
+	let thinkingLevel = "off";
+	let model = null;
+	for (const entry of path) if (entry.type === "thinking_level_change") thinkingLevel = entry.thinkingLevel;
+	else if (entry.type === "model_change") model = {
+		provider: entry.provider,
+		modelId: entry.modelId
+	};
+	else if (entry.type === "message" && entry.message.role === "assistant") model = {
+		provider: entry.message.provider,
+		modelId: entry.message.model
+	};
+	return {
+		thinkingLevel,
+		model
+	};
+}
+/**
+* Project one selected session entry into LLM/runtime messages.
+* Plain custom entries are display/state entries and do not participate in context.
+*/
+function sessionEntryToContextMessages(entry) {
+	if (entry.type === "message") {
+		const message = entry.message;
+		if ((message.role === "user" || message.role === "assistant" || message.role === "toolResult") && message.content == null) return [{
+			...message,
+			content: []
+		}];
+		return [message];
+	}
+	if (entry.type === "custom_message") return [createCustomMessage(entry.customType, entry.content ?? [], entry.display, entry.details, entry.timestamp)];
+	if (entry.type === "branch_summary" && entry.summary) return [createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp)];
+	if (entry.type === "compaction") return [createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp)];
+	return [];
+}
+/**
+* Build the active, compaction-aware session entry list.
+*
+* This follows the current leaf path. If the path contains compaction entries,
+* the latest compaction is represented by the compaction entry itself, followed
+* by the kept entries starting at firstKeptEntryId and all entries after the
+* compaction entry. Older summarized entries are omitted.
+*/
+function buildContextEntries(entries, leafId, byId) {
+	const path = buildSessionPath(entries, leafId, byId);
+	let compaction = null;
+	for (const entry of path) if (entry.type === "compaction") compaction = entry;
+	if (!compaction) return path;
+	const compactionIdx = path.findIndex((entry) => entry.id === compaction.id);
+	if (compactionIdx < 0) return path;
+	const contextEntries = [compaction];
+	let foundFirstKept = false;
+	for (let i = 0; i < compactionIdx; i++) {
+		const entry = path[i];
+		if (entry.id === compaction.firstKeptEntryId) foundFirstKept = true;
+		if (foundFirstKept) contextEntries.push(entry);
+	}
+	contextEntries.push(...path.slice(compactionIdx + 1));
+	return contextEntries;
+}
+/**
+* Build the session context from entries using tree traversal.
+* If leafId is provided, walks from that entry to root.
+* Handles compaction and branch summaries along the path.
+*/
+function buildSessionContext(entries, leafId, byId) {
+	const { thinkingLevel, model } = getSessionContextSettings(buildSessionPath(entries, leafId, byId));
+	return {
+		messages: buildContextEntries(entries, leafId, byId).flatMap(sessionEntryToContextMessages),
+		thinkingLevel,
+		model
+	};
+}
+/**
+* Compute the default session directory for a cwd.
+* Encodes cwd into a safe directory name under ~/.pi/agent/sessions/.
+*/
+function getDefaultSessionDirPath(cwd, agentDir = getAgentDir()) {
+	const resolvedCwd = resolvePath(cwd);
+	const resolvedAgentDir = resolvePath(agentDir);
+	const safePath = `--${resolvedCwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+	return join$1(resolvedAgentDir, "sessions", safePath);
+}
+function getDefaultSessionDir(cwd, agentDir = getAgentDir()) {
+	const sessionDir = getDefaultSessionDirPath(cwd, agentDir);
+	if (!existsSync$1(sessionDir)) mkdirSync$1(sessionDir, { recursive: true });
+	return sessionDir;
+}
+const SESSION_READ_BUFFER_SIZE = 1048576;
+const SESSION_HEADER_READ_BUFFER_SIZE = 4096;
+/** Bound synchronous header discovery while allowing large cwd and custom metadata fields. */
+const MAX_SESSION_HEADER_SCAN_BYTES = 1048576;
+var SessionHeaderScanLimitError = class extends Error {
+	constructor(filePath) {
+		super(`Session header exceeds ${MAX_SESSION_HEADER_SCAN_BYTES}-byte scan limit: ${filePath}`);
+		this.name = "SessionHeaderScanLimitError";
+	}
+};
+function parseSessionEntryLine(line) {
+	if (!line.trim()) return null;
+	try {
+		return JSON.parse(line);
+	} catch {
+		return null;
+	}
+}
+/** Exported for testing */
+function loadEntriesFromFile(filePath) {
+	const resolvedFilePath = normalizePath(filePath);
+	if (!existsSync$1(resolvedFilePath)) return [];
+	const entries = [];
+	const fd = openSync(resolvedFilePath, "r");
+	try {
+		const decoder = new StringDecoder("utf8");
+		const buffer = Buffer.allocUnsafe(SESSION_READ_BUFFER_SIZE);
+		let pending = "";
+		while (true) {
+			const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+			if (bytesRead === 0) break;
+			pending += decoder.write(buffer.subarray(0, bytesRead));
+			let lineStart = 0;
+			let newlineIndex = pending.indexOf("\n", lineStart);
+			while (newlineIndex !== -1) {
+				const entry = parseSessionEntryLine(pending.slice(lineStart, newlineIndex));
+				if (entry) entries.push(entry);
+				lineStart = newlineIndex + 1;
+				newlineIndex = pending.indexOf("\n", lineStart);
+			}
+			pending = pending.slice(lineStart);
+		}
+		pending += decoder.end();
+		const finalEntry = parseSessionEntryLine(pending);
+		if (finalEntry) entries.push(finalEntry);
+	} finally {
+		closeSync(fd);
+	}
+	if (entries.length === 0) return entries;
+	const header = entries[0];
+	if (header.type !== "session" || typeof header.id !== "string") return [];
+	return entries;
+}
+/**
+* Inspect a physical line while searching for the first parsed session entry.
+* Blank and malformed lines are skipped to match loadEntriesFromFile().
+* Returns undefined to keep scanning, null for a parsed non-header entry, or the header.
+*/
+function parseSessionHeaderCandidate(line) {
+	if (!line.trim()) return void 0;
+	const entry = parseSessionEntryLine(line);
+	if (!entry) return void 0;
+	if (entry.type !== "session" || typeof entry.id !== "string") return null;
+	return entry;
+}
+function readSessionHeader(filePath) {
+	const fd = openSync(filePath, "r");
+	try {
+		const decoder = new StringDecoder("utf8");
+		const buffer = Buffer.allocUnsafe(SESSION_HEADER_READ_BUFFER_SIZE);
+		const lineChunks = [];
+		let scannedBytes = 0;
+		while (scannedBytes < MAX_SESSION_HEADER_SCAN_BYTES) {
+			const readLength = Math.min(buffer.length, MAX_SESSION_HEADER_SCAN_BYTES - scannedBytes);
+			const bytesRead = readSync(fd, buffer, 0, readLength, null);
+			if (bytesRead === 0) {
+				lineChunks.push(decoder.end());
+				return parseSessionHeaderCandidate(lineChunks.join("")) ?? null;
+			}
+			scannedBytes += bytesRead;
+			const chunk = decoder.write(buffer.subarray(0, bytesRead));
+			let lineStart = 0;
+			let newlineIndex = chunk.indexOf("\n", lineStart);
+			while (newlineIndex !== -1) {
+				lineChunks.push(chunk.slice(lineStart, newlineIndex));
+				const header = parseSessionHeaderCandidate(lineChunks.join(""));
+				if (header !== void 0) return header;
+				lineChunks.length = 0;
+				lineStart = newlineIndex + 1;
+				newlineIndex = chunk.indexOf("\n", lineStart);
+			}
+			lineChunks.push(chunk.slice(lineStart));
+		}
+		const probe = Buffer.allocUnsafe(1);
+		if (readSync(fd, probe, 0, probe.length, null) === 0) {
+			lineChunks.push(decoder.end());
+			return parseSessionHeaderCandidate(lineChunks.join("")) ?? null;
+		}
+		throw new SessionHeaderScanLimitError(filePath);
+	} finally {
+		closeSync(fd);
+	}
+}
+function readSessionHeaderForDiscovery(filePath) {
+	try {
+		return readSessionHeader(filePath);
+	} catch {
+		return null;
+	}
+}
+function getSessionHeaderCwd(header) {
+	const cwd = header.cwd;
+	return typeof cwd === "string" ? cwd : void 0;
+}
+function sessionCwdMatches(cwd, resolvedCwd) {
+	return cwd !== void 0 && cwd !== "" && resolvePath(cwd) === resolvedCwd;
+}
+/** Exported for testing */
+function findMostRecentSession(sessionDir, cwd) {
+	const resolvedSessionDir = normalizePath(sessionDir);
+	const resolvedCwd = cwd ? resolvePath(cwd) : void 0;
+	try {
+		return readdirSync(resolvedSessionDir).filter((f) => f.endsWith(".jsonl")).map((f) => join$1(resolvedSessionDir, f)).map((path) => ({
+			path,
+			header: readSessionHeaderForDiscovery(path)
+		})).filter((file) => file.header !== null && (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd))).map(({ path }) => ({
+			path,
+			mtime: statSync(path).mtime
+		})).sort((a, b) => b.mtime.getTime() - a.mtime.getTime())[0]?.path || null;
+	} catch {
+		return null;
+	}
+}
+function isMessageWithContent(message) {
+	return typeof message.role === "string" && "content" in message;
+}
+function extractTextContent(message) {
+	const content = message.content;
+	if (typeof content === "string") return content;
+	return content.filter((block) => block.type === "text").map((block) => block.text).join(" ");
+}
+function getMessageActivityTime(entry) {
+	const message = entry.message;
+	if (!isMessageWithContent(message)) return void 0;
+	if (message.role !== "user" && message.role !== "assistant") return void 0;
+	const msgTimestamp = message.timestamp;
+	if (typeof msgTimestamp === "number") return msgTimestamp;
+	const t = new Date(entry.timestamp).getTime();
+	return Number.isNaN(t) ? void 0 : t;
+}
+async function buildSessionInfo(filePath) {
+	try {
+		const stats = await stat$1(filePath);
+		let header = null;
+		let messageCount = 0;
+		let firstMessage = "";
+		const allMessages = [];
+		let name;
+		let lastActivityTime;
+		const rl = createInterface({
+			input: createReadStream(filePath, { encoding: "utf8" }),
+			crlfDelay: Infinity
+		});
+		for await (const line of rl) {
+			const entry = parseSessionEntryLine(line);
+			if (!entry) continue;
+			if (!header) {
+				if (entry.type !== "session") return null;
+				header = entry;
+				continue;
+			}
+			if (entry.type === "session_info") name = entry.name?.trim() || void 0;
+			if (entry.type !== "message") continue;
+			messageCount++;
+			const activityTime = getMessageActivityTime(entry);
+			if (typeof activityTime === "number") lastActivityTime = Math.max(lastActivityTime ?? 0, activityTime);
+			const message = entry.message;
+			if (!isMessageWithContent(message)) continue;
+			if (message.role !== "user" && message.role !== "assistant") continue;
+			const textContent = extractTextContent(message);
+			if (!textContent) continue;
+			allMessages.push(textContent);
+			if (!firstMessage && message.role === "user") firstMessage = textContent;
+		}
+		if (!header) return null;
+		const cwd = typeof header.cwd === "string" ? header.cwd : "";
+		const parentSessionPath = header.parentSession;
+		const headerTime = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
+		const modified = typeof lastActivityTime === "number" && lastActivityTime > 0 ? new Date(lastActivityTime) : !Number.isNaN(headerTime) ? new Date(headerTime) : stats.mtime;
+		return {
+			path: filePath,
+			id: header.id,
+			cwd,
+			name,
+			parentSessionPath,
+			created: new Date(header.timestamp),
+			modified,
+			messageCount,
+			firstMessage: firstMessage || "(no messages)",
+			allMessagesText: allMessages.join(" ")
+		};
+	} catch {
+		return null;
+	}
+}
+const MAX_CONCURRENT_SESSION_INFO_LOADS = 10;
+async function buildSessionInfosWithConcurrency(files, onLoaded) {
+	const results = new Array(files.length).fill(null);
+	const inFlight = /* @__PURE__ */ new Set();
+	let nextIndex = 0;
+	const startNext = () => {
+		const index = nextIndex++;
+		const file = files[index];
+		if (!file) return;
+		let task;
+		task = buildSessionInfo(file).then((info) => {
+			results[index] = info;
+		}).catch(() => {
+			results[index] = null;
+		}).finally(() => {
+			inFlight.delete(task);
+			onLoaded();
+		});
+		inFlight.add(task);
+	};
+	while (nextIndex < files.length || inFlight.size > 0) {
+		while (nextIndex < files.length && inFlight.size < MAX_CONCURRENT_SESSION_INFO_LOADS) startNext();
+		if (inFlight.size > 0) await Promise.race(inFlight);
+	}
+	return results;
+}
+async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal) {
+	const sessions = [];
+	if (!existsSync$1(dir)) return sessions;
+	try {
+		const files = (await readdir$1(dir)).filter((f) => f.endsWith(".jsonl")).map((f) => join$1(dir, f));
+		const total = progressTotal ?? files.length;
+		let loaded = 0;
+		const results = await buildSessionInfosWithConcurrency(files, () => {
+			loaded++;
+			onProgress?.(progressOffset + loaded, total);
+		});
+		for (const info of results) if (info) sessions.push(info);
+	} catch {}
+	return sessions;
+}
+/**
+* Manages conversation sessions as append-only trees stored in JSONL files.
+*
+* Each session entry has an id and parentId forming a tree structure. The "leaf"
+* pointer tracks the current position. Appending creates a child of the current leaf.
+* Branching moves the leaf to an earlier entry, allowing new branches without
+* modifying history.
+*
+* Use buildSessionContext() to get the resolved message list for the LLM, which
+* handles compaction summaries and follows the path from root to current leaf.
+*/
+var SessionManager = class SessionManager {
+	sessionId = "";
+	sessionFile;
+	sessionDir;
+	cwd;
+	persist;
+	flushed = false;
+	fileEntries = [];
+	byId = /* @__PURE__ */ new Map();
+	labelsById = /* @__PURE__ */ new Map();
+	labelTimestampsById = /* @__PURE__ */ new Map();
+	leafId = null;
+	constructor(cwd, sessionDir, sessionFile, persist, newSessionOptions, preloadedFileEntries) {
+		this.cwd = resolvePath(cwd);
+		this.sessionDir = normalizePath(sessionDir);
+		this.persist = persist;
+		if (persist && this.sessionDir && !existsSync$1(this.sessionDir)) mkdirSync$1(this.sessionDir, { recursive: true });
+		if (sessionFile) this._setSessionFile(sessionFile, preloadedFileEntries);
+		else this.newSession(newSessionOptions);
+	}
+	/** Switch to a different session file (used for resume and branching) */
+	setSessionFile(sessionFile) {
+		this._setSessionFile(sessionFile);
+	}
+	_setSessionFile(sessionFile, preloadedFileEntries) {
+		this.sessionFile = resolvePath(sessionFile);
+		if (existsSync$1(this.sessionFile)) {
+			this.fileEntries = preloadedFileEntries ?? loadEntriesFromFile(this.sessionFile);
+			if (this.fileEntries.length === 0) {
+				const explicitPath = this.sessionFile;
+				if (statSync(explicitPath).size > 0) throw new Error(`Session file is not a valid pi session: ${explicitPath}`);
+				this.newSession();
+				this.sessionFile = explicitPath;
+				this._rewriteFile();
+				this.flushed = true;
+				return;
+			}
+			const header = this.fileEntries.find((e) => e.type === "session");
+			this.sessionId = header?.id ?? createSessionId();
+			if (migrateToCurrentVersion(this.fileEntries)) this._rewriteFile();
+			this._buildIndex();
+			this.flushed = true;
+		} else {
+			const explicitPath = this.sessionFile;
+			this.newSession();
+			this.sessionFile = explicitPath;
+		}
+	}
+	newSession(options) {
+		if (options?.id !== void 0) assertValidSessionId(options.id);
+		this.sessionId = options?.id ?? createSessionId();
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const header = {
+			type: "session",
+			version: 3,
+			id: this.sessionId,
+			timestamp,
+			cwd: this.cwd,
+			parentSession: options?.parentSession
+		};
+		this.fileEntries = [header];
+		this.byId.clear();
+		this.labelsById.clear();
+		this.labelTimestampsById.clear();
+		this.leafId = null;
+		this.flushed = false;
+		if (this.persist) {
+			const fileTimestamp = timestamp.replace(/[:.]/g, "-");
+			this.sessionFile = join$1(this.getSessionDir(), `${fileTimestamp}_${this.sessionId}.jsonl`);
+		}
+		return this.sessionFile;
+	}
+	_buildIndex() {
+		this.byId.clear();
+		this.labelsById.clear();
+		this.labelTimestampsById.clear();
+		this.leafId = null;
+		for (const entry of this.fileEntries) {
+			if (entry.type === "session") continue;
+			this.byId.set(entry.id, entry);
+			this.leafId = entry.id;
+			if (entry.type === "label") {
+				if (entry.label) {
+					this.labelsById.set(entry.targetId, entry.label);
+					this.labelTimestampsById.set(entry.targetId, entry.timestamp);
+				} else {
+					this.labelsById.delete(entry.targetId);
+					this.labelTimestampsById.delete(entry.targetId);
+				}
+			}
+		}
+	}
+	_rewriteFile() {
+		if (!this.persist || !this.sessionFile) return;
+		const fd = openSync(this.sessionFile, "w");
+		try {
+			for (const entry of this.fileEntries) writeFileSync$1(fd, `${JSON.stringify(entry)}\n`);
+		} finally {
+			closeSync(fd);
+		}
+	}
+	isPersisted() {
+		return this.persist;
+	}
+	getCwd() {
+		return this.cwd;
+	}
+	getSessionDir() {
+		return this.sessionDir;
+	}
+	usesDefaultSessionDir() {
+		return this.sessionDir === getDefaultSessionDirPath(this.cwd);
+	}
+	getSessionId() {
+		return this.sessionId;
+	}
+	getSessionFile() {
+		return this.sessionFile;
+	}
+	_persist(entry) {
+		if (!this.persist || !this.sessionFile) return;
+		if (!this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant")) {
+			if (this.flushed) appendFileSync$1(this.sessionFile, `${JSON.stringify(entry)}\n`);
+			else this.flushed = false;
+			return;
+		}
+		if (!this.flushed) {
+			const fd = openSync(this.sessionFile, "wx");
+			try {
+				for (const e of this.fileEntries) writeFileSync$1(fd, `${JSON.stringify(e)}\n`);
+			} finally {
+				closeSync(fd);
+			}
+			this.flushed = true;
+		} else appendFileSync$1(this.sessionFile, `${JSON.stringify(entry)}\n`);
+	}
+	_appendEntry(entry) {
+		this.fileEntries.push(entry);
+		this.byId.set(entry.id, entry);
+		this.leafId = entry.id;
+		this._persist(entry);
+	}
+	/** Append a message as child of current leaf, then advance leaf. Returns entry id.
+	* Does not allow writing CompactionSummaryMessage and BranchSummaryMessage directly.
+	* Reason: we want these to be top-level entries in the session, not message session entries,
+	* so it is easier to find them.
+	* These need to be appended via appendCompaction() and appendBranchSummary() methods.
+	*/
+	appendMessage(message) {
+		const entry = {
+			type: "message",
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			message
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+	/** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
+	appendThinkingLevelChange(thinkingLevel) {
+		const entry = {
+			type: "thinking_level_change",
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			thinkingLevel
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+	/** Append a model change as child of current leaf, then advance leaf. Returns entry id. */
+	appendModelChange(provider, modelId) {
+		const entry = {
+			type: "model_change",
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			provider,
+			modelId
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+	/** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
+	appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook, usage) {
+		const entry = {
+			type: "compaction",
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			summary,
+			firstKeptEntryId,
+			tokensBefore,
+			details,
+			usage,
+			fromHook
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+	/** Append a custom entry (for extensions) as child of current leaf, then advance leaf. Returns entry id. */
+	appendCustomEntry(customType, data) {
+		const entry = {
+			type: "custom",
+			customType,
+			data,
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+	/** Append a session info entry (e.g., display name). Returns entry id. */
+	appendSessionInfo(name) {
+		const sanitizedName = name.replace(/[\r\n]+/g, " ").trim();
+		const entry = {
+			type: "session_info",
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			name: sanitizedName
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+	/** Get the current session name from the latest session_info entry, if any. */
+	getSessionName() {
+		const entries = this.getEntries();
+		for (let i = entries.length - 1; i >= 0; i--) {
+			const entry = entries[i];
+			if (entry.type === "session_info") return entry.name?.trim() || void 0;
+		}
+	}
+	/**
+	* Append a custom message entry (for extensions) that participates in LLM context.
+	* @param customType Extension identifier for filtering on reload
+	* @param content Message content (string or TextContent/ImageContent array)
+	* @param display Whether to show in TUI (true = styled display, false = hidden)
+	* @param details Optional extension-specific metadata (not sent to LLM)
+	* @returns Entry id
+	*/
+	appendCustomMessageEntry(customType, content, display, details) {
+		const entry = {
+			type: "custom_message",
+			customType,
+			content,
+			display,
+			details,
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+	getLeafId() {
+		return this.leafId;
+	}
+	getLeafEntry() {
+		return this.leafId ? this.byId.get(this.leafId) : void 0;
+	}
+	getEntry(id) {
+		return this.byId.get(id);
+	}
+	/**
+	* Get all direct children of an entry.
+	*/
+	getChildren(parentId) {
+		const children = [];
+		for (const entry of this.byId.values()) if (entry.parentId === parentId) children.push(entry);
+		return children;
+	}
+	/**
+	* Get the label for an entry, if any.
+	*/
+	getLabel(id) {
+		return this.labelsById.get(id);
+	}
+	/**
+	* Set or clear a label on an entry.
+	* Labels are user-defined markers for bookmarking/navigation.
+	* Pass undefined or empty string to clear the label.
+	*/
+	appendLabelChange(targetId, label) {
+		if (!this.byId.has(targetId)) throw new Error(`Entry ${targetId} not found`);
+		const entry = {
+			type: "label",
+			id: generateId(this.byId),
+			parentId: this.leafId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			targetId,
+			label
+		};
+		this._appendEntry(entry);
+		if (label) {
+			this.labelsById.set(targetId, label);
+			this.labelTimestampsById.set(targetId, entry.timestamp);
+		} else {
+			this.labelsById.delete(targetId);
+			this.labelTimestampsById.delete(targetId);
+		}
+		return entry.id;
+	}
+	/**
+	* Walk from entry to root, returning all entries in path order.
+	* Includes all entry types (messages, compaction, model changes, etc.).
+	* Use buildSessionContext() to get the resolved messages for the LLM.
+	*/
+	getBranch(fromId) {
+		const path = [];
+		const startId = fromId ?? this.leafId;
+		let current = startId ? this.byId.get(startId) : void 0;
+		while (current) {
+			path.push(current);
+			current = current.parentId ? this.byId.get(current.parentId) : void 0;
+		}
+		path.reverse();
+		return path;
+	}
+	/**
+	* Build the active, compaction-aware entry list for context/rendering.
+	* Uses tree traversal from current leaf.
+	*/
+	buildContextEntries() {
+		return buildContextEntries(this.getEntries(), this.leafId, this.byId);
+	}
+	/**
+	* Build the session context (what gets sent to the LLM).
+	* Uses tree traversal from current leaf.
+	*/
+	buildSessionContext() {
+		return buildSessionContext(this.getEntries(), this.leafId, this.byId);
+	}
+	/**
+	* Get session header.
+	*/
+	getHeader() {
+		const h = this.fileEntries.find((e) => e.type === "session");
+		return h ? h : null;
+	}
+	/**
+	* Get all session entries (excludes header). Returns a shallow copy.
+	* The session is append-only: use appendXXX() to add entries, branch() to
+	* change the leaf pointer. Entries cannot be modified or deleted.
+	*/
+	getEntries() {
+		return this.fileEntries.filter((e) => e.type !== "session");
+	}
+	/**
+	* Get the session as a tree structure. Returns a shallow defensive copy of all entries.
+	* A well-formed session has exactly one root (first entry with parentId === null).
+	* Orphaned entries (broken parent chain) are also returned as roots.
+	*/
+	getTree() {
+		const entries = this.getEntries();
+		const nodeMap = /* @__PURE__ */ new Map();
+		const roots = [];
+		for (const entry of entries) {
+			const label = this.labelsById.get(entry.id);
+			const labelTimestamp = this.labelTimestampsById.get(entry.id);
+			nodeMap.set(entry.id, {
+				entry,
+				children: [],
+				label,
+				labelTimestamp
+			});
+		}
+		for (const entry of entries) {
+			const node = nodeMap.get(entry.id);
+			if (entry.parentId === null || entry.parentId === entry.id) roots.push(node);
+			else {
+				const parent = nodeMap.get(entry.parentId);
+				if (parent) parent.children.push(node);
+				else roots.push(node);
+			}
+		}
+		const stack = [...roots];
+		while (stack.length > 0) {
+			const node = stack.pop();
+			node.children.sort((a, b) => new Date(a.entry.timestamp).getTime() - new Date(b.entry.timestamp).getTime());
+			stack.push(...node.children);
+		}
+		return roots;
+	}
+	/**
+	* Start a new branch from an earlier entry.
+	* Moves the leaf pointer to the specified entry. The next appendXXX() call
+	* will create a child of that entry, forming a new branch. Existing entries
+	* are not modified or deleted.
+	*/
+	branch(branchFromId) {
+		if (!this.byId.has(branchFromId)) throw new Error(`Entry ${branchFromId} not found`);
+		this.leafId = branchFromId;
+	}
+	/**
+	* Reset the leaf pointer to null (before any entries).
+	* The next appendXXX() call will create a new root entry (parentId = null).
+	* Use this when navigating to re-edit the first user message.
+	*/
+	resetLeaf() {
+		this.leafId = null;
+	}
+	/**
+	* Start a new branch with a summary of the abandoned path.
+	* Same as branch(), but also appends a branch_summary entry that captures
+	* context from the abandoned conversation path.
+	*/
+	branchWithSummary(branchFromId, summary, details, fromHook, usage) {
+		if (branchFromId !== null && !this.byId.has(branchFromId)) throw new Error(`Entry ${branchFromId} not found`);
+		this.leafId = branchFromId;
+		const entry = {
+			type: "branch_summary",
+			id: generateId(this.byId),
+			parentId: branchFromId,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			fromId: branchFromId ?? "root",
+			summary,
+			details,
+			usage,
+			fromHook
+		};
+		this._appendEntry(entry);
+		return entry.id;
+	}
+	/**
+	* Create a new session file containing only the path from root to the specified leaf.
+	* Useful for extracting a single conversation path from a branched session.
+	* Returns the new session file path, or undefined if not persisting.
+	*/
+	createBranchedSession(leafId) {
+		const previousSessionFile = this.sessionFile;
+		const path = this.getBranch(leafId);
+		if (path.length === 0) throw new Error(`Entry ${leafId} not found`);
+		const pathWithoutLabels = [];
+		let pathParentId = null;
+		for (const entry of path) {
+			if (entry.type === "label") continue;
+			pathWithoutLabels.push({
+				...entry,
+				parentId: pathParentId
+			});
+			pathParentId = entry.id;
+		}
+		const newSessionId = createSessionId();
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const fileTimestamp = timestamp.replace(/[:.]/g, "-");
+		const newSessionFile = join$1(this.getSessionDir(), `${fileTimestamp}_${newSessionId}.jsonl`);
+		const header = {
+			type: "session",
+			version: 3,
+			id: newSessionId,
+			timestamp,
+			cwd: this.cwd,
+			parentSession: this.persist ? previousSessionFile : void 0
+		};
+		const pathEntryIds = new Set(pathWithoutLabels.map((e) => e.id));
+		const labelsToWrite = [];
+		for (const [targetId, label] of this.labelsById) if (pathEntryIds.has(targetId)) labelsToWrite.push({
+			targetId,
+			label,
+			timestamp: this.labelTimestampsById.get(targetId)
+		});
+		if (this.persist) {
+			let parentId = pathWithoutLabels[pathWithoutLabels.length - 1]?.id || null;
+			const labelEntries = [];
+			for (const { targetId, label, timestamp: labelTimestamp } of labelsToWrite) {
+				const labelEntry = {
+					type: "label",
+					id: generateId(new Set(pathEntryIds)),
+					parentId,
+					timestamp: labelTimestamp,
+					targetId,
+					label
+				};
+				pathEntryIds.add(labelEntry.id);
+				labelEntries.push(labelEntry);
+				parentId = labelEntry.id;
+			}
+			this.fileEntries = [
+				header,
+				...pathWithoutLabels,
+				...labelEntries
+			];
+			this.sessionId = newSessionId;
+			this.sessionFile = newSessionFile;
+			this._buildIndex();
+			if (this.fileEntries.some((e) => e.type === "message" && e.message.role === "assistant")) {
+				this._rewriteFile();
+				this.flushed = true;
+			} else this.flushed = false;
+			return newSessionFile;
+		}
+		const labelEntries = [];
+		let parentId = pathWithoutLabels[pathWithoutLabels.length - 1]?.id || null;
+		for (const { targetId, label, timestamp: labelTimestamp } of labelsToWrite) {
+			const labelEntry = {
+				type: "label",
+				id: generateId(/* @__PURE__ */ new Set([...pathEntryIds, ...labelEntries.map((e) => e.id)])),
+				parentId,
+				timestamp: labelTimestamp,
+				targetId,
+				label
+			};
+			labelEntries.push(labelEntry);
+			parentId = labelEntry.id;
+		}
+		this.fileEntries = [
+			header,
+			...pathWithoutLabels,
+			...labelEntries
+		];
+		this.sessionId = newSessionId;
+		this._buildIndex();
+	}
+	/**
+	* Create a new session.
+	* @param cwd Working directory (stored in session header)
+	* @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
+	*/
+	static create(cwd, sessionDir, options) {
+		const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
+		return new SessionManager(cwd, dir, void 0, true, options);
+	}
+	/**
+	* Open a specific session file.
+	* @param path Path to session file
+	* @param sessionDir Optional session directory for /new or /branch. If omitted, derives from file's parent.
+	* @param cwdOverride Optional cwd override instead of the session header cwd.
+	*/
+	static open(path, sessionDir, cwdOverride) {
+		const resolvedPath = resolvePath(path);
+		let header = null;
+		let preloadedFileEntries;
+		if (cwdOverride === void 0 && existsSync$1(resolvedPath)) try {
+			header = readSessionHeader(resolvedPath);
+		} catch (error) {
+			if (!(error instanceof SessionHeaderScanLimitError)) throw error;
+			preloadedFileEntries = loadEntriesFromFile(resolvedPath);
+			const firstEntry = preloadedFileEntries[0];
+			header = firstEntry?.type === "session" ? firstEntry : null;
+		}
+		const cwd = cwdOverride ?? (header ? getSessionHeaderCwd(header) : void 0) ?? process.cwd();
+		const dir = sessionDir ? normalizePath(sessionDir) : resolve$1(resolvedPath, "..");
+		return new SessionManager(cwd, dir, resolvedPath, true, void 0, preloadedFileEntries);
+	}
+	/**
+	* Continue the most recent session, or create new if none.
+	* @param cwd Working directory
+	* @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
+	*/
+	static continueRecent(cwd, sessionDir) {
+		const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
+		const mostRecent = findMostRecentSession(dir, sessionDir !== void 0 && dir !== getDefaultSessionDirPath(cwd) ? cwd : void 0);
+		if (mostRecent) return new SessionManager(cwd, dir, mostRecent, true);
+		return new SessionManager(cwd, dir, void 0, true);
+	}
+	/** Create an in-memory session (no file persistence) */
+	static inMemory(cwd = process.cwd(), options) {
+		return new SessionManager(cwd, "", void 0, false, options);
+	}
+	/**
+	* Fork a session from another project directory into the current project.
+	* Creates a new session in the target cwd with the full history from the source session.
+	* @param sourcePath Path to the source session file
+	* @param targetCwd Target working directory (where the new session will be stored)
+	* @param sessionDir Optional session directory. If omitted, uses default for targetCwd.
+	*/
+	static forkFrom(sourcePath, targetCwd, sessionDir, options) {
+		const resolvedSourcePath = resolvePath(sourcePath);
+		const resolvedTargetCwd = resolvePath(targetCwd);
+		const sourceEntries = loadEntriesFromFile(resolvedSourcePath);
+		if (sourceEntries.length === 0) throw new Error(`Cannot fork: source session file is empty or invalid: ${resolvedSourcePath}`);
+		if (!sourceEntries.find((e) => e.type === "session")) throw new Error(`Cannot fork: source session has no header: ${resolvedSourcePath}`);
+		const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(resolvedTargetCwd);
+		if (!existsSync$1(dir)) mkdirSync$1(dir, { recursive: true });
+		if (options?.id !== void 0) assertValidSessionId(options.id);
+		const newSessionId = options?.id ?? createSessionId();
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const fileTimestamp = timestamp.replace(/[:.]/g, "-");
+		const newSessionFile = join$1(dir, `${fileTimestamp}_${newSessionId}.jsonl`);
+		writeFileSync$1(newSessionFile, `${JSON.stringify({
+			type: "session",
+			version: 3,
+			id: newSessionId,
+			timestamp,
+			cwd: resolvedTargetCwd,
+			parentSession: resolvedSourcePath
+		})}\n`, { flag: "wx" });
+		for (const entry of sourceEntries) if (entry.type !== "session") appendFileSync$1(newSessionFile, `${JSON.stringify(entry)}\n`);
+		return new SessionManager(resolvedTargetCwd, dir, newSessionFile, true);
+	}
+	/**
+	* List all sessions for a directory.
+	* @param cwd Working directory (used to compute default session directory)
+	* @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
+	* @param onProgress Optional callback for progress updates (loaded, total)
+	*/
+	static async list(cwd, sessionDir, onProgress) {
+		const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
+		const filterCwd = sessionDir !== void 0 && dir !== getDefaultSessionDirPath(cwd);
+		const resolvedCwd = resolvePath(cwd);
+		const sessions = (await listSessionsFromDir(dir, onProgress)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
+		sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+		return sessions;
+	}
+	static async listAll(sessionDirOrOnProgress, onProgress) {
+		const customSessionDir = typeof sessionDirOrOnProgress === "string" ? normalizePath(sessionDirOrOnProgress) : void 0;
+		const progress = typeof sessionDirOrOnProgress === "function" ? sessionDirOrOnProgress : onProgress;
+		if (customSessionDir) {
+			const sessions = await listSessionsFromDir(customSessionDir, progress);
+			sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+			return sessions;
+		}
+		const sessionsDir = getSessionsDir();
+		try {
+			if (!existsSync$1(sessionsDir)) return [];
+			const dirs = (await readdir$1(sessionsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => join$1(sessionsDir, entry.name));
+			let totalFiles = 0;
+			const dirFiles = [];
+			for (const dir of dirs) try {
+				const files = (await readdir$1(dir)).filter((f) => f.endsWith(".jsonl"));
+				dirFiles.push(files.map((f) => join$1(dir, f)));
+				totalFiles += files.length;
+			} catch {
+				dirFiles.push([]);
+			}
+			let loaded = 0;
+			const sessions = [];
+			const results = await buildSessionInfosWithConcurrency(dirFiles.flat(), () => {
+				loaded++;
+				progress?.(loaded, totalFiles);
+			});
+			for (const info of results) if (info) sessions.push(info);
+			sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+			return sessions;
+		} catch {
+			return [];
+		}
+	}
+};
+//#endregion
+//#region src/compat/vendor/pi-truncate.ts
+/**
+* Shared truncation utilities for tool outputs.
+*
+* Truncation is based on two independent limits - whichever is hit first wins:
+* - Line limit (default: 2000 lines)
+* - Byte limit (default: 50KB)
+*
+* Never returns partial lines (except bash tail truncation edge case).
+*/
+const DEFAULT_MAX_LINES = 2e3;
+const DEFAULT_MAX_BYTES = 51200;
+function splitLinesForCounting(content) {
+	if (content.length === 0) return [];
+	const lines = content.split("\n");
+	if (content.endsWith("\n")) lines.pop();
+	return lines;
+}
+/**
+* Format bytes as human-readable size.
+*/
+function formatSize(bytes) {
+	if (bytes < 1024) return `${bytes}B`;
+	else if (bytes < 1048576) return `${(bytes / 1024).toFixed(1)}KB`;
+	else return `${(bytes / 1048576).toFixed(1)}MB`;
+}
+/**
+* Truncate content from the head (keep first N lines/bytes).
+* Suitable for file reads where you want to see the beginning.
+*
+* Never returns partial lines. If first line exceeds byte limit,
+* returns empty content with firstLineExceedsLimit=true.
+*/
+function truncateHead(content, options = {}) {
+	const maxLines = options.maxLines ?? 2e3;
+	const maxBytes = options.maxBytes ?? 51200;
+	const totalBytes = Buffer.byteLength(content, "utf-8");
+	const lines = splitLinesForCounting(content);
+	const totalLines = lines.length;
+	if (totalLines <= maxLines && totalBytes <= maxBytes) return {
+		content,
+		truncated: false,
+		truncatedBy: null,
+		totalLines,
+		totalBytes,
+		outputLines: totalLines,
+		outputBytes: totalBytes,
+		lastLinePartial: false,
+		firstLineExceedsLimit: false,
+		maxLines,
+		maxBytes
+	};
+	if (Buffer.byteLength(lines[0], "utf-8") > maxBytes) return {
+		content: "",
+		truncated: true,
+		truncatedBy: "bytes",
+		totalLines,
+		totalBytes,
+		outputLines: 0,
+		outputBytes: 0,
+		lastLinePartial: false,
+		firstLineExceedsLimit: true,
+		maxLines,
+		maxBytes
+	};
+	const outputLinesArr = [];
+	let outputBytesCount = 0;
+	let truncatedBy = "lines";
+	for (let i = 0; i < lines.length && i < maxLines; i++) {
+		const line = lines[i];
+		const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0);
+		if (outputBytesCount + lineBytes > maxBytes) {
+			truncatedBy = "bytes";
+			break;
+		}
+		outputLinesArr.push(line);
+		outputBytesCount += lineBytes;
+	}
+	if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) truncatedBy = "lines";
+	const outputContent = outputLinesArr.join("\n");
+	const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+	return {
+		content: outputContent,
+		truncated: true,
+		truncatedBy,
+		totalLines,
+		totalBytes,
+		outputLines: outputLinesArr.length,
+		outputBytes: finalOutputBytes,
+		lastLinePartial: false,
+		firstLineExceedsLimit: false,
+		maxLines,
+		maxBytes
+	};
+}
+/**
+* Truncate content from the tail (keep last N lines/bytes).
+* Suitable for bash output where you want to see the end (errors, final results).
+*
+* May return partial first line if the last line of original content exceeds byte limit.
+*/
+function truncateTail(content, options = {}) {
+	const maxLines = options.maxLines ?? 2e3;
+	const maxBytes = options.maxBytes ?? 51200;
+	const totalBytes = Buffer.byteLength(content, "utf-8");
+	const lines = splitLinesForCounting(content);
+	const totalLines = lines.length;
+	if (totalLines <= maxLines && totalBytes <= maxBytes) return {
+		content,
+		truncated: false,
+		truncatedBy: null,
+		totalLines,
+		totalBytes,
+		outputLines: totalLines,
+		outputBytes: totalBytes,
+		lastLinePartial: false,
+		firstLineExceedsLimit: false,
+		maxLines,
+		maxBytes
+	};
+	const outputLinesArr = [];
+	let outputBytesCount = 0;
+	let truncatedBy = "lines";
+	let lastLinePartial = false;
+	for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
+		const line = lines[i];
+		const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0);
+		if (outputBytesCount + lineBytes > maxBytes) {
+			truncatedBy = "bytes";
+			if (outputLinesArr.length === 0) {
+				const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
+				outputLinesArr.unshift(truncatedLine);
+				outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
+				lastLinePartial = true;
+			}
+			break;
+		}
+		outputLinesArr.unshift(line);
+		outputBytesCount += lineBytes;
+	}
+	if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) truncatedBy = "lines";
+	const outputContent = outputLinesArr.join("\n");
+	const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
+	return {
+		content: outputContent,
+		truncated: true,
+		truncatedBy,
+		totalLines,
+		totalBytes,
+		outputLines: outputLinesArr.length,
+		outputBytes: finalOutputBytes,
+		lastLinePartial,
+		firstLineExceedsLimit: false,
+		maxLines,
+		maxBytes
+	};
+}
+/**
+* Truncate a string to fit within a byte limit (from the end).
+* Handles multi-byte UTF-8 characters correctly.
+*/
+function truncateStringToBytesFromEnd(str, maxBytes) {
+	const buf = Buffer.from(str, "utf-8");
+	if (buf.length <= maxBytes) return str;
+	let start = buf.length - maxBytes;
+	while (start < buf.length && (buf[start] & 192) === 128) start++;
+	return buf.slice(start).toString("utf-8");
+}
+/**
+* Truncate a single line to max characters, adding [truncated] suffix.
+* Used for grep match lines.
+*/
+function truncateLine(line, maxChars = 500) {
+	if (line.length <= maxChars) return {
+		text: line,
+		wasTruncated: false
+	};
+	return {
+		text: `${line.slice(0, maxChars)}... [truncated]`,
+		wasTruncated: true
+	};
+}
+//#endregion
+//#region src/compat/vendor/pi-file-mutation-queue.ts
+const fileMutationQueues = /* @__PURE__ */ new Map();
+let registrationQueue = Promise.resolve();
+function isMissingPathError(error) {
+	return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+async function getMutationQueueKey(filePath) {
+	const resolvedPath = resolve(filePath);
+	try {
+		return await realpath(resolvedPath);
+	} catch (error) {
+		if (isMissingPathError(error)) return resolvedPath;
+		throw error;
+	}
+}
+/**
+* Serialize file mutation operations targeting the same file.
+* Operations for different files still run in parallel.
+*/
+async function withFileMutationQueue(filePath, fn) {
+	const registration = registrationQueue.then(async () => {
+		const key = await getMutationQueueKey(filePath);
+		const currentQueue = fileMutationQueues.get(key) ?? Promise.resolve();
+		let releaseNext;
+		const nextQueue = new Promise((resolveQueue) => {
+			releaseNext = resolveQueue;
+		});
+		const chainedQueue = currentQueue.then(() => nextQueue);
+		fileMutationQueues.set(key, chainedQueue);
+		return {
+			key,
+			currentQueue,
+			chainedQueue,
+			releaseNext
+		};
+	});
+	registrationQueue = registration.then(() => void 0, () => void 0);
+	const { key, currentQueue, chainedQueue, releaseNext } = await registration;
+	await currentQueue;
+	try {
+		return await fn();
+	} finally {
+		releaseNext();
+		if (fileMutationQueues.get(key) === chainedQueue) fileMutationQueues.delete(key);
+	}
+}
+//#endregion
+//#region src/compat/pi-coding-agent.ts
+const CONFIG_DIR_NAME = ".pi";
+const VERSION = "pi2dsh-compat";
+function defineTool(tool) {
+	return tool;
+}
+function unsupportedRuntime(name) {
+	throw new Error(`pi2dsh: ${name} belongs to Pi's internal agent runtime and has no verified DSH mapping; use the DSH-native service instead (see the pi2dsh compatibility report)`);
+}
+const identity = (text) => text;
+var Theme = class {
+	name;
+	constructor(name = "pi2dsh-headless") {
+		this.name = name;
+	}
+	fg(_color, text) {
+		return text;
+	}
+	bg(_color, text) {
+		return text;
+	}
+	bold(text) {
+		return text;
+	}
+	italic(text) {
+		return text;
+	}
+	underline(text) {
+		return text;
+	}
+	inverse(text) {
+		return text;
+	}
+	strikethrough(text) {
+		return text;
+	}
+	getFgAnsi(_color) {
+		return "";
+	}
+	getBgAnsi(_color) {
+		return "";
+	}
+	getColorMode() {
+		return "none";
+	}
+	getThinkingBorderColor(_level) {
+		return identity;
+	}
+	getBashModeBorderColor() {
+		return identity;
+	}
+};
+const theme = new Theme();
+function initTheme(_themeName, _enableWatcher = false) {}
+function getSettingsListTheme() {
+	return {
+		label: (text, _selected) => text,
+		value: (text, _selected) => text,
+		description: (text) => text,
+		cursor: "→ ",
+		hint: (text) => text
+	};
+}
+function getSelectListTheme() {
+	return {
+		selectedPrefix: "→ ",
+		selectedText: identity,
+		description: identity,
+		scrollInfo: identity,
+		noMatch: identity
+	};
+}
+function getMarkdownTheme() {
+	return {
+		heading: identity,
+		link: identity,
+		linkUrl: identity,
+		code: identity,
+		codeBlock: identity,
+		codeBlockBorder: identity,
+		quote: identity,
+		quoteBorder: identity,
+		hr: identity,
+		listBullet: identity,
+		bold: identity,
+		italic: identity,
+		underline: identity,
+		strikethrough: identity,
+		highlightCode: (code) => code.split("\n")
+	};
+}
+const LANGUAGE_BY_EXTENSION = {
+	".ts": "typescript",
+	".tsx": "typescript",
+	".js": "javascript",
+	".jsx": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".py": "python",
+	".rb": "ruby",
+	".go": "go",
+	".rs": "rust",
+	".java": "java",
+	".c": "c",
+	".h": "c",
+	".cpp": "cpp",
+	".hpp": "cpp",
+	".cs": "csharp",
+	".sh": "bash",
+	".bash": "bash",
+	".zsh": "bash",
+	".json": "json",
+	".yaml": "yaml",
+	".yml": "yaml",
+	".toml": "ini",
+	".md": "markdown",
+	".html": "xml",
+	".xml": "xml",
+	".css": "css",
+	".scss": "scss",
+	".sql": "sql",
+	".php": "php",
+	".swift": "swift",
+	".kt": "kotlin",
+	".scala": "scala",
+	".lua": "lua",
+	".r": "r"
+};
+function getLanguageFromPath(filePath) {
+	const dot = filePath.lastIndexOf(".");
+	if (dot === -1) return void 0;
+	return LANGUAGE_BY_EXTENSION[filePath.slice(dot).toLowerCase()];
+}
+function highlightCode(code, _lang) {
+	return code.split("\n");
+}
+var DynamicBorder = class {
+	color;
+	constructor(color = identity) {
+		this.color = color;
+	}
+	render(width) {
+		return [this.color("─".repeat(Math.max(1, width)))];
+	}
+	invalidate() {}
+};
+function contentChars(content) {
+	if (typeof content === "string") return content.length;
+	if (!Array.isArray(content)) return 0;
+	let chars = 0;
+	for (const block of content) {
+		if (typeof block !== "object" || block === null) continue;
+		const record = block;
+		if (typeof record.text === "string") chars += record.text.length;
+		else if (typeof record.thinking === "string") chars += record.thinking.length;
+		else if (record.type === "image") chars += 1600;
+		else if (record.arguments !== void 0) chars += JSON.stringify(record.arguments ?? {}).length;
+	}
+	return chars;
+}
+function estimateTokens(message) {
+	const record = message;
+	let chars = contentChars(record.content);
+	if (typeof record.summary === "string") chars += record.summary.length;
+	if (record.role === "bashExecution") chars += String(record.command ?? "").length + String(record.output ?? "").length;
+	return Math.ceil(chars / 4);
+}
+function calculateContextTokens(messages) {
+	return messages.reduce((total, message) => total + estimateTokens(message), 0);
+}
+const DEFAULT_COMPACTION_SETTINGS = Object.freeze({
+	enabled: true,
+	reserveTokens: 3e4,
+	keepRecentTokens: 2e4
+});
+function shouldCompact(..._args) {
+	return false;
+}
+function compact(..._args) {
+	return unsupportedRuntime("compact()");
+}
+function findCutPoint(..._args) {
+	return unsupportedRuntime("findCutPoint()");
+}
+function generateSummary(..._args) {
+	return unsupportedRuntime("generateSummary()");
+}
+function generateSummaryWithUsage(..._args) {
+	return unsupportedRuntime("generateSummaryWithUsage()");
+}
+function generateBranchSummary(..._args) {
+	return unsupportedRuntime("generateBranchSummary()");
+}
+function serializeConversation(messages) {
+	return JSON.stringify(messages);
+}
+function parseFrontmatter(text) {
+	const normalized = text.replace(/\r\n?/gu, "\n");
+	if (!normalized.startsWith("---")) return {
+		attributes: {},
+		body: normalized
+	};
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) return {
+		attributes: {},
+		body: normalized
+	};
+	const attributes = {};
+	for (const line of normalized.slice(4, endIndex).split("\n")) {
+		const separator = line.indexOf(":");
+		if (separator === -1) continue;
+		const key = line.slice(0, separator).trim();
+		let value = line.slice(separator + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		if (key.length > 0) attributes[key] = value;
+	}
+	return {
+		attributes,
+		body: normalized.slice(endIndex + 4).replace(/^\n/u, "")
+	};
+}
+function stripFrontmatter(text) {
+	return parseFrontmatter(text).body;
+}
+async function copyToClipboard(text) {
+	const attempt = (command, args) => new Promise((resolve) => {
+		const child = execFile(command, args, (error) => resolve(error === null));
+		child.stdin?.write(text);
+		child.stdin?.end();
+	});
+	if (process.platform === "darwin") return attempt("pbcopy", []);
+	if (process.platform === "win32") return attempt("clip", []);
+	if (await attempt("wl-copy", [])) return true;
+	return attempt("xclip", ["-selection", "clipboard"]);
+}
+async function resizeImage(data, mimeType, _options = {}) {
+	return {
+		data,
+		mimeType
+	};
+}
+async function convertToPng(data, mimeType) {
+	if (mimeType === "image/png") return {
+		data,
+		mimeType
+	};
+	return unsupportedRuntime("convertToPng() for non-PNG input");
+}
+function getShellConfig() {
+	if (process.platform === "win32") return {
+		shell: process.env.COMSPEC ?? "cmd.exe",
+		args: [
+			"/d",
+			"/s",
+			"/c"
+		]
+	};
+	const preferred = process.env.SHELL;
+	if (preferred !== void 0 && preferred.length > 0 && existsSync(preferred)) return {
+		shell: preferred,
+		args: ["-c"]
+	};
+	for (const candidate of [
+		"/bin/bash",
+		"/bin/zsh",
+		"/bin/sh"
+	]) if (existsSync(candidate)) return {
+		shell: candidate,
+		args: ["-c"]
+	};
+	return {
+		shell: "sh",
+		args: ["-c"]
+	};
+}
+function getPackageDir() {
+	const override = process.env.PI_PACKAGE_DIR;
+	if (override !== void 0 && override.length > 0) return override;
+	return join(getAgentDir(), "package");
+}
+function readStoredCredential(providerId, authPath = join(getAgentDir(), "auth.json")) {
+	try {
+		return JSON.parse(readFileSync(authPath, "utf8"))[providerId];
+	} catch {
+		return;
+	}
+}
+function parseSkillBlock(text) {
+	const match = /<skill_content\b[^>]*\bname="([^"]+)"[^>]*>([\s\S]*?)<\/skill_content>/u.exec(text);
+	if (match === null) return null;
+	return {
+		name: match[1],
+		content: match[2].trim()
+	};
+}
+function wrapRegisteredTool(..._args) {
+	return unsupportedRuntime("wrapRegisteredTool()");
+}
+function getBinDir() {
+	return (process.env.PATH ?? "").split(delimiter)[0] ?? join(homedir(), ".local", "bin");
+}
+var SettingsManager = class SettingsManager {
+	globalSettings;
+	projectSettings;
+	constructor(globalSettings, projectSettings) {
+		this.globalSettings = globalSettings;
+		this.projectSettings = projectSettings;
+	}
+	static create(_cwd, _agentDir, options = {}) {
+		return SettingsManager.inMemory({}, options);
+	}
+	static fromStorage(_storage, options = {}) {
+		return SettingsManager.inMemory({}, options);
+	}
+	static inMemory(settings = {}, _options = {}) {
+		return new SettingsManager({ ...settings }, {});
+	}
+	get merged() {
+		return {
+			...this.globalSettings,
+			...this.projectSettings
+		};
+	}
+	read(key, fallback) {
+		const value = this.merged[key];
+		return value === void 0 ? fallback : value;
+	}
+	async reload() {}
+	async flush() {}
+	drainErrors() {
+		return [];
+	}
+	applyOverrides(overrides) {
+		Object.assign(this.globalSettings, overrides);
+	}
+	getGlobalSettings() {
+		return { ...this.globalSettings };
+	}
+	getProjectSettings() {
+		return { ...this.projectSettings };
+	}
+	isProjectTrusted() {
+		return this.read("projectTrusted", false);
+	}
+	setProjectTrusted(trusted) {
+		this.projectSettings.projectTrusted = trusted;
+	}
+	getDefaultProjectTrust() {
+		return this.read("defaultProjectTrust", "ask");
+	}
+	getDefaultProvider() {
+		return this.read("defaultProvider", void 0);
+	}
+	getDefaultModel() {
+		return this.read("defaultModel", void 0);
+	}
+	setDefaultProvider(provider) {
+		this.globalSettings.defaultProvider = provider;
+	}
+	setDefaultModel(model) {
+		this.globalSettings.defaultModel = model;
+	}
+	setDefaultModelAndProvider(model, provider) {
+		this.setDefaultModel(model);
+		this.setDefaultProvider(provider);
+	}
+	getDefaultThinkingLevel() {
+		return this.read("defaultThinkingLevel", void 0);
+	}
+	getThemeSetting() {
+		return this.read("theme", void 0);
+	}
+	getTheme() {
+		return this.getThemeSetting();
+	}
+	setTheme(themeName) {
+		this.globalSettings.theme = themeName;
+	}
+	getCompactionSettings() {
+		return this.read("compaction", { ...DEFAULT_COMPACTION_SETTINGS });
+	}
+	getBranchSummarySettings() {
+		return this.read("branchSummary", {
+			reserveTokens: 8e3,
+			skipPrompt: false
+		});
+	}
+	getRetrySettings() {
+		return this.read("retry", {
+			enabled: true,
+			maxRetries: 3,
+			baseDelayMs: 1e3
+		});
+	}
+	getProviderRetrySettings() {
+		return this.getRetrySettings();
+	}
+	getHttpIdleTimeoutMs() {
+		return this.read("httpIdleTimeoutMs", 12e4);
+	}
+	getWebSocketConnectTimeoutMs() {
+		return this.read("webSocketConnectTimeoutMs", 3e4);
+	}
+	getPackages() {
+		return this.read("packages", []);
+	}
+	getExtensionPaths() {
+		return this.read("extensions", []);
+	}
+	getSkillPaths() {
+		return this.read("skills", []);
+	}
+	getPromptTemplatePaths() {
+		return this.read("prompts", []);
+	}
+	getThemePaths() {
+		return this.read("themes", []);
+	}
+	getTuiMode() {
+		return this.read("tuiMode", "regular");
+	}
+	getShowImages() {
+		return this.read("showImages", false);
+	}
+	getImageWidthCells() {
+		return this.read("imageWidthCells", 40);
+	}
+	getClearOnShrink() {
+		return this.read("clearOnShrink", false);
+	}
+	getShowTerminalProgress() {
+		return this.read("showTerminalProgress", false);
+	}
+	getHideThinkingBlock() {
+		return this.read("hideThinkingBlock", false);
+	}
+	getExternalEditorCommand() {
+		return this.read("externalEditorCommand", void 0);
+	}
+	getSteeringMode() {
+		return this.read("steeringMode", "all");
+	}
+	getFollowUpMode() {
+		return this.read("followUpMode", "queue");
+	}
+	getShellPath() {
+		return this.read("shellPath", void 0);
+	}
+	getShellCommandPrefix() {
+		return this.read("shellCommandPrefix", void 0);
+	}
+	getNpmCommand() {
+		return this.read("npmCommand", void 0);
+	}
+	getEnableSkillCommands() {
+		return this.read("enableSkillCommands", true);
+	}
+	getEnableAnalytics() {
+		return false;
+	}
+	getTrackingId() {}
+};
+var InMemorySettingsStorage = class {
+	settings;
+	constructor(settings = {}) {
+		this.settings = settings;
+	}
+	async withLock(_scope, fn) {
+		return fn();
+	}
+};
+var FileSettingsStorage = class extends InMemorySettingsStorage {};
+function runtimeStubClass(name) {
+	return class {
+		constructor() {
+			return unsupportedRuntime(`new ${name}()`);
+		}
+	};
+}
+const ProjectTrustStore = runtimeStubClass("ProjectTrustStore");
+const DefaultResourceLoader = runtimeStubClass("DefaultResourceLoader");
+const DefaultPackageManager = runtimeStubClass("DefaultPackageManager");
+const ModelRuntime = runtimeStubClass("ModelRuntime");
+var ModelRegistry = class {
+	models = /* @__PURE__ */ new Map();
+	register(id, model) {
+		this.models.set(id, model);
+	}
+	get(id) {
+		return this.models.get(id);
+	}
+	list() {
+		return [...this.models.values()];
+	}
+};
+function createAgentSession(..._args) {
+	return unsupportedRuntime("createAgentSession()");
+}
+function createCodingTools(..._args) {
+	return unsupportedRuntime("createCodingTools()");
+}
+function createReadOnlyTools(..._args) {
+	return unsupportedRuntime("createReadOnlyTools()");
+}
+function createBashTool(..._args) {
+	return unsupportedRuntime("createBashTool()");
+}
+function createReadTool(..._args) {
+	return unsupportedRuntime("createReadTool()");
+}
+function createEditTool(..._args) {
+	return unsupportedRuntime("createEditTool()");
+}
+function createWriteTool(..._args) {
+	return unsupportedRuntime("createWriteTool()");
+}
+function createGrepTool(..._args) {
+	return unsupportedRuntime("createGrepTool()");
+}
+function createFindTool(..._args) {
+	return unsupportedRuntime("createFindTool()");
+}
+function createLsTool(..._args) {
+	return unsupportedRuntime("createLsTool()");
+}
+function loadSkills(..._args) {
+	return unsupportedRuntime("loadSkills()");
+}
+function loadSkillsFromDir(..._args) {
+	return unsupportedRuntime("loadSkillsFromDir()");
+}
+function formatSkillsForPrompt(..._args) {
+	return unsupportedRuntime("formatSkillsForPrompt()");
+}
+function createEventBus() {
+	const handlers = /* @__PURE__ */ new Map();
+	return {
+		emit(channel, data) {
+			for (const handler of handlers.get(channel) ?? []) Promise.resolve().then(() => handler(data)).catch((error) => console.error(error));
+		},
+		on(channel, handler) {
+			const set = handlers.get(channel) ?? /* @__PURE__ */ new Set();
+			set.add(handler);
+			handlers.set(channel, set);
+			return () => {
+				set.delete(handler);
+			};
+		},
+		clear() {
+			handlers.clear();
+		}
+	};
+}
+var HeadlessComponent = class {
+	render(_width) {
+		return [];
+	}
+	invalidate() {}
+};
+var ToolExecutionComponent = class extends HeadlessComponent {};
+var FooterComponent = class extends HeadlessComponent {};
+var BorderedLoader = class extends HeadlessComponent {
+	start() {}
+	stop() {}
+	dispose() {}
+};
+var CustomMessageComponent = class extends HeadlessComponent {};
+var AssistantMessageComponent = class extends HeadlessComponent {};
+var UserMessageComponent = class extends HeadlessComponent {};
+var ExtensionSelectorComponent = class extends HeadlessComponent {};
+var ExtensionInputComponent = class extends HeadlessComponent {};
+var ExtensionEditorComponent = class extends HeadlessComponent {};
+var SettingsSelectorComponent = class extends HeadlessComponent {};
+var CustomEditor = class extends HeadlessComponent {
+	text = "";
+	onSubmit;
+	onChange;
+	getText() {
+		return this.text;
+	}
+	setText(text) {
+		this.text = text;
+		this.onChange?.(text);
+	}
+	handleInput(data) {
+		if (data === "\r" || data === "\n") {
+			this.onSubmit?.(this.text);
+			return;
+		}
+		if (data >= " ") this.setText(this.text + data);
+	}
+};
+function renderDiff(oldText, newText, _options = {}) {
+	const removed = oldText.split("\n").map((line) => `- ${line}`);
+	const added = newText.split("\n").map((line) => `+ ${line}`);
+	return [...removed, ...added];
+}
+function truncateToVisualLines(text, maxVisualLines, width, paddingX = 0) {
+	const inner = Math.max(1, width - paddingX * 2);
+	const lines = text.split("\n").map((line) => visibleWidth(line) > inner ? truncateToWidth(line, inner) : line);
+	return {
+		visualLines: lines.slice(0, Math.max(0, maxVisualLines)),
+		skippedCount: Math.max(0, lines.length - maxVisualLines)
+	};
+}
+function keyHint(keybinding, description) {
+	return `${keybinding} ${description}`;
+}
+function keyText(keybinding) {
+	return keybinding;
+}
+function rawKeyHint(key, description) {
+	return `${key} ${description}`;
+}
+//#endregion
+export { getShellConfig as $, createBashTool as A, findMostRecentSession as At, defineTool as B, COMPACTION_SUMMARY_SUFFIX as Bt, UserMessageComponent as C, truncateLine as Ct, convertToPng as D, assertValidSessionId as Dt, compact as E, SessionManager as Et, createGrepTool as F, parseSessionEntries as Ft, generateSummary as G, createCustomMessage as Gt, findCutPoint as H, convertToLlm as Ht, createLsTool as I, sessionEntryToContextMessages as It, getLanguageFromPath as J, generateSummaryWithUsage as K, createReadOnlyTools as L, BRANCH_SUMMARY_PREFIX as Lt, createEditTool as M, getLatestCompactionEntry as Mt, createEventBus as N, loadEntriesFromFile as Nt, copyToClipboard as O, buildContextEntries as Ot, createFindTool as P, migrateSessionEntries as Pt, getSettingsListTheme as Q, createReadTool as R, BRANCH_SUMMARY_SUFFIX as Rt, ToolExecutionComponent as S, truncateHead as St, calculateContextTokens as T, CURRENT_SESSION_VERSION as Tt, formatSkillsForPrompt as U, createBranchSummaryMessage as Ut, estimateTokens as V, bashExecutionToText as Vt, generateBranchSummary as W, createCompactionSummaryMessage as Wt, getPackageDir as X, getMarkdownTheme as Y, getSelectListTheme as Z, ModelRuntime as _, wrapRegisteredTool as _t, CustomMessageComponent as a, loadSkillsFromDir as at, SettingsSelectorComponent as b, DEFAULT_MAX_LINES as bt, DefaultResourceLoader as c, rawKeyHint as ct, ExtensionInputComponent as d, resizeImage as dt, highlightCode as et, ExtensionSelectorComponent as f, serializeConversation as ft, ModelRegistry as g, truncateToVisualLines as gt, InMemorySettingsStorage as h, theme as ht, CustomEditor as i, loadSkills as it, createCodingTools as j, getDefaultSessionDir as jt, createAgentSession as k, buildSessionContext as kt, DynamicBorder as l, readStoredCredential as lt, FooterComponent as m, stripFrontmatter as mt, BorderedLoader as n, keyHint as nt, DEFAULT_COMPACTION_SETTINGS as o, parseFrontmatter as ot, FileSettingsStorage as p, shouldCompact as pt, getBinDir as q, CONFIG_DIR_NAME as r, keyText as rt, DefaultPackageManager as s, parseSkillBlock as st, AssistantMessageComponent as t, initTheme as tt, ExtensionEditorComponent as u, renderDiff as ut, ProjectTrustStore as v, withFileMutationQueue as vt, VERSION as w, truncateTail as wt, Theme as x, formatSize as xt, SettingsManager as y, DEFAULT_MAX_BYTES as yt, createWriteTool as z, COMPACTION_SUMMARY_PREFIX as zt };
+
+//# sourceMappingURL=pi-coding-agent-Dsg6_0ua.mjs.map