@alivault/pico 0.12.0 → 0.14.0

package/.output/server/_ssr/{router-D36lUq7O.mjs → router-CN4JMm2A.mjs}

@@ -1,8 +1,8 @@
 import { i as __toESM } from "../_runtime.mjs";
 import { $ as require_react, Q as require_jsx_runtime } from "../_libs/@base-ui/react+[...].mjs";
 import { a as createRouter, c as createRootRoute, n as Scripts, r as HeadContent, s as createFileRoute } from "../_libs/@tanstack/react-router+[...].mjs";
-import { R as CircleCheck, a as TriangleAlert, v as OctagonX, w as Info } from "../_libs/lucide-react.mjs";
-import { B as createCompactionSummaryItem, G as extractToolText, I as appliedThemeClassColorMode, J as mergeAssistantBlocksForStreaming, L as assistantBlocksFromMessage, M as TooltipProvider, R as buildItemsFromSync, T as Spinner, U as extractMessageImages, W as extractMessageText$1, f as PICO_SHIKI_VARIABLE_DEFAULTS, kt as toolCategoryFromTool, n as APPLIED_THEME_STORAGE_KEY, t as APPLIED_THEME_CLASSES, u as PICO_CODE_SHIKI_THEME, x as Route$54 } from "./routes-9nZumcXQ.mjs";
+import { T as Info, a as TriangleAlert, y as OctagonX, z as CircleCheck } from "../_libs/lucide-react.mjs";
+import { B as buildItemsFromSync, H as createCompactionSummaryItem, J as extractToolText, K as extractMessageImages, Lt as toolCategoryFromTool, P as TooltipProvider, R as appliedThemeClassColorMode, T as Spinner, Z as mergeAssistantBlocksForStreaming, f as PICO_SHIKI_VARIABLE_DEFAULTS, n as APPLIED_THEME_STORAGE_KEY, q as extractMessageText$1, t as APPLIED_THEME_CLASSES, u as PICO_CODE_SHIKI_THEME, x as Route$62, z as assistantBlocksFromMessage } from "./routes-DbjuMLFI.mjs";
 import { t as QueryClient } from "../_libs/tanstack__query-core.mjs";
 import { t as setupRouterSsrQueryIntegration } from "../_libs/@tanstack/react-router-ssr-query+[...].mjs";
 import { n as HotkeysProvider } from "../_libs/tanstack__react-hotkeys.mjs";
@@ -11,16 +11,17 @@ import { t as Toaster } from "../_libs/sonner.mjs";
 import { c as bundledLanguages, l as bundledLanguagesAlias, s as codeToHtml, u as createCssVariablesTheme } from "../_libs/@pierre/diffs+[...].mjs";
 import { t as createTwoFilesPatch } from "../_libs/diff.mjs";
 import { n as Debouncer } from "../_libs/tanstack__pacer.mjs";
+import { createRequire } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
 import fs, { constants, existsSync, readFileSync, watch } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path, { basename, dirname, isAbsolute, join, resolve } from "node:path";
-import { access, mkdir, readFile, readdir, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { access, chmod, mkdir, readFile, readdir, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
 import os, { homedir } from "node:os";
 import { performance } from "node:perf_hooks";
 import { isMainThread } from "node:worker_threads";
 import { execSync, spawn } from "node:child_process";
-//#region node_modules/.nitro/vite/services/ssr/assets/router-D36lUq7O.js
+//#region node_modules/.nitro/vite/services/ssr/assets/router-CN4JMm2A.js
 var import_react = /* @__PURE__ */ __toESM(require_react());
 var import_jsx_runtime = require_jsx_runtime();
 function sonnerThemeFromAppliedTheme(theme) {
@@ -87,15 +88,19 @@ function AppProviders({ children }) {
 		})
 	});
 }
-var styles_default = "/assets/styles-DJ9ubgcc.css";
+var styles_default = "/assets/styles-CUVz7jV9.css";
 var TANSTACK_DEVTOOLS_SETTINGS_KEY = "tanstack_devtools_settings";
-var TANSTACK_DEVTOOLS_DEFAULTS_STORAGE_KEY = "pico-tanstack-devtools-defaults-v1";
+var TANSTACK_DEVTOOLS_DEFAULTS_STORAGE_KEY = "pico-tanstack-devtools-defaults-v2";
 var TANSTACK_DEVTOOLS_CONFIG = {
 	position: "bottom-right",
-	openHotkey: ["Control", "`"],
+	openHotkey: [
+		"Control",
+		"Shift",
+		"`"
+	],
 	triggerHidden: true
 };
-var Route$53 = createRootRoute({
+var Route$61 = createRootRoute({
 	head: () => ({
 		meta: [
 			{ charSet: "utf-8" },
@@ -264,15 +269,18 @@ async function loadPiSdk() {
 	const sdkDir = resolvePiSdkDir();
 	return patchSdkForWorkerThreads(await importExternalModule(path.join(sdkDir, "dist", "index.js")));
 }
+function addPiAiCandidateEntries(candidates, packageDir) {
+	candidates.push(path.join(packageDir, "dist", "compat.js"), path.join(packageDir, "dist", "index.js"));
+}
 function getPiAiCandidates(sdkDir) {
 	const candidates = [];
-	for (const scope of ["@earendil-works", "@mariozechner"]) candidates.push(path.join(sdkDir, "node_modules", scope, "pi-ai", "dist", "index.js"));
+	for (const scope of ["@earendil-works", "@mariozechner"]) addPiAiCandidateEntries(candidates, path.join(sdkDir, "node_modules", scope, "pi-ai"));
 	try {
 		const realSdkDir = fs.realpathSync(sdkDir);
-		for (const scope of ["@earendil-works", "@mariozechner"]) candidates.push(path.join(realSdkDir, "node_modules", scope, "pi-ai", "dist", "index.js"));
-		candidates.push(path.join(path.dirname(realSdkDir), "pi-ai", "dist", "index.js"));
+		for (const scope of ["@earendil-works", "@mariozechner"]) addPiAiCandidateEntries(candidates, path.join(realSdkDir, "node_modules", scope, "pi-ai"));
+		addPiAiCandidateEntries(candidates, path.join(path.dirname(realSdkDir), "pi-ai"));
 	} catch {}
-	candidates.push(path.join(path.dirname(sdkDir), "pi-ai", "dist", "index.js"));
+	addPiAiCandidateEntries(candidates, path.join(path.dirname(sdkDir), "pi-ai"));
 	return candidates;
 }
 function resolvePiAiEntry(sdkDir) {
@@ -456,11 +464,62 @@ function buildSessionNamePrompt(prompt, cwdBasename, imageCount) {
 		normalizedPrompt
 	].filter(Boolean).join("\n");
 }
+function modelLabel(model) {
+	return `${model.provider}/${model.id}`;
+}
+function formatSessionNamingError(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	return "Unknown error";
+}
+function modelSupportsTextInput(model) {
+	if (!Array.isArray(model.input)) return true;
+	return model.input.includes("text");
+}
+function collectSessionNamingModelCandidates(entry) {
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	const addCandidate = (model, source) => {
+		if (!model || !modelSupportsTextInput(model)) return;
+		const key = modelLabel(model);
+		if (seen.has(key)) return;
+		seen.add(key);
+		candidates.push({
+			model,
+			source
+		});
+	};
+	addCandidate(entry.model, "active");
+	for (const model of entry.services.modelRegistry.getAvailable()) addCandidate(model, "available");
+	return candidates;
+}
+async function selectSessionNamingModel(entry) {
+	const candidates = collectSessionNamingModelCandidates(entry);
+	if (candidates.length === 0) return {
+		ok: false,
+		reason: "no text-capable models are available for session naming"
+	};
+	const failures = [];
+	for (const candidate of candidates) try {
+		const auth = await entry.services.modelRegistry.getApiKeyAndHeaders(candidate.model);
+		if (auth?.ok) return {
+			ok: true,
+			...candidate,
+			auth
+		};
+		failures.push(`${modelLabel(candidate.model)}: ${auth?.error || "not authenticated"}`);
+	} catch (error) {
+		failures.push(`${modelLabel(candidate.model)}: ${formatSessionNamingError(error)}`);
+	}
+	return {
+		ok: false,
+		reason: `no authenticated text model is available for session naming${failures.length > 0 ? ` (${failures.slice(0, 3).join("; ")})` : ""}`
+	};
+}
 async function generateSessionNameWithLlm(entry, text, imageCount) {
-	const model = entry.services.modelRegistry.find("openai-codex", "gpt-5.4-mini");
-	if (!model) return { reason: "refinement model openai-codex/gpt-5.4-mini is unavailable" };
-	const auth = await entry.services.modelRegistry.getApiKeyAndHeaders(model);
-	if (!auth?.ok) return { reason: auth?.error || `failed to authenticate ${model.provider}/${model.id} for session naming` };
+	const selectedModel = await selectSessionNamingModel(entry);
+	if (!selectedModel.ok) return { reason: selectedModel.reason };
+	const { model, auth } = selectedModel;
 	const response = await (await loadPiAi()).complete(model, {
 		systemPrompt: SESSION_NAME_SYSTEM_PROMPT,
 		messages: [{
@@ -488,8 +547,12 @@ function normalizeSessionScope(rawScope, defaultCwd) {
 function resolveScopeCwd(scope, defaultCwd) {
 	return normalizeSessionScope(scope ?? null, defaultCwd);
 }
-function getSsePayloadText(payload) {
-	return `${JSON.stringify(payload).split(/\r?\n/).map((line) => `data: ${line}`).join("\n")}\n\n`;
+function formatSsePayloadText(payload, options) {
+	const prefixLines = [];
+	if (options?.id) prefixLines.push(`id: ${options.id}`);
+	if (typeof options?.retry === "number" && Number.isFinite(options.retry)) prefixLines.push(`retry: ${Math.max(0, Math.round(options.retry))}`);
+	const dataLines = JSON.stringify(payload).split(/\r?\n/).map((line) => `data: ${line}`);
+	return `${[...prefixLines, ...dataLines].join("\n")}\n\n`;
 }
 function writeRawToClient(options) {
 	const { encoder, context, client, text, closeSseClient } = options;
@@ -503,12 +566,15 @@ function writeRawToClient(options) {
 	}
 }
 function sendPayloadToClient(options) {
-	const { context, client, payload, closeSseClient, encoder } = options;
+	const { context, client, payload, closeSseClient, encoder, eventId, retry } = options;
 	return writeRawToClient({
 		encoder,
 		context,
 		client,
-		text: getSsePayloadText(payload),
+		text: formatSsePayloadText(payload, {
+			id: eventId,
+			retry
+		}),
 		closeSseClient
 	});
 }
@@ -630,6 +696,398 @@ async function buildHighlightPayload(options) {
 		}))
 	};
 }
+var TERMINAL_BACKLOG_MAX_CHUNKS = 500;
+var TERMINAL_BACKLOG_MAX_BYTES = 512 * 1024;
+var TERMINAL_EXITED_TTL_MS = 1800 * 1e3;
+var TERMINAL_CLEANUP_INTERVAL_MS = 60 * 1e3;
+var TERMINAL_MIN_COLS = 20;
+var TERMINAL_MAX_COLS = 500;
+var TERMINAL_MIN_ROWS = 5;
+var TERMINAL_MAX_ROWS = 200;
+var TERMINAL_DEFAULT_COLS = 100;
+var TERMINAL_DEFAULT_ROWS = 30;
+var TERMINAL_KEY_MAX_LENGTH = 256;
+var require = createRequire(import.meta.url);
+var ensureSpawnHelperExecutablePromise;
+function normalizeDimension(value, fallback, min, max) {
+	const numericValue = typeof value === "number" ? value : Number(value);
+	if (!Number.isFinite(numericValue)) return fallback;
+	return Math.min(max, Math.max(min, Math.round(numericValue)));
+}
+function createTerminalEnv() {
+	const env = {};
+	for (const [key, value] of Object.entries(process.env)) if (typeof value === "string") env[key] = value;
+	delete env.ZELLIJ;
+	delete env.ZELLIJ_SESSION_NAME;
+	delete env.TMUX;
+	delete env.TMUX_PANE;
+	env.TERM = "xterm-256color";
+	env.COLORTERM = "truecolor";
+	return env;
+}
+function defaultShell() {
+	if (process.platform === "win32") return process.env.COMSPEC || "powershell.exe";
+	return process.env.SHELL || "/bin/sh";
+}
+async function ensureNodePtySpawnHelperExecutable() {
+	if (process.platform === "win32") return;
+	ensureSpawnHelperExecutablePromise ??= (async () => {
+		try {
+			const helperPath = join(dirname(dirname(require.resolve("node-pty"))), "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper");
+			const helperStat = await stat(helperPath).catch(() => null);
+			if (!helperStat) return;
+			if ((helperStat.mode & 73) !== 0) return;
+			await chmod(helperPath, helperStat.mode | 493);
+		} catch {}
+	})();
+	await ensureSpawnHelperExecutablePromise;
+}
+function terminalLabel(shell) {
+	return basename(shell) || shell;
+}
+function eventSize(event) {
+	if (event.type === "output") return event.data.length;
+	return JSON.stringify(event).length;
+}
+function formatTerminalError(error) {
+	if (error instanceof Error && error.message.trim()) return error.message;
+	if (typeof error === "string" && error.trim()) return error;
+	return "Unknown terminal error";
+}
+function sseFrame(event) {
+	return `${event.type === "output" ? `id: ${event.seq}\n` : ""}data: ${JSON.stringify(event)}\n\n`;
+}
+function exitPayload(exitCode, signal) {
+	return typeof signal === "number" && signal > 0 ? {
+		exitCode,
+		signal
+	} : { exitCode };
+}
+function exitEvent(exitCode, signal) {
+	return {
+		type: "exit",
+		...exitPayload(exitCode, signal)
+	};
+}
+function readyEvent(record) {
+	return {
+		type: "ready",
+		backend: record.backend,
+		id: record.id,
+		cwd: record.cwd,
+		shell: terminalLabel(record.shell),
+		nextInputSeq: record.lastInputSeq + 1
+	};
+}
+function parseTerminalWebSocketMessage(text) {
+	const parsed = JSON.parse(text);
+	if (!parsed || typeof parsed !== "object") throw new Error("Terminal WebSocket message must be an object.");
+	const message = parsed;
+	if (message.type !== "input" && message.type !== "resize" && message.type !== "ping") throw new Error("Unknown terminal WebSocket message type.");
+	return message;
+}
+function normalizeTerminalKey(value) {
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	if (!normalized) return void 0;
+	return normalized.slice(0, TERMINAL_KEY_MAX_LENGTH);
+}
+function terminalLookupKey(scopeKey, terminalKey) {
+	return `${scopeKey}\0${terminalKey}`;
+}
+var PicoTerminalManager = class {
+	terminals = /* @__PURE__ */ new Map();
+	terminalKeys = /* @__PURE__ */ new Map();
+	encoder = new TextEncoder();
+	cleanupTimer;
+	constructor() {
+		this.cleanupTimer = setInterval(() => {
+			this.cleanupExitedTerminals();
+		}, TERMINAL_CLEANUP_INTERVAL_MS);
+		this.cleanupTimer.unref?.();
+	}
+	async createTerminal({ clientKey, cols, cwd, rows, scopeKey }) {
+		await ensureNodePtySpawnHelperExecutable();
+		const terminalKey = normalizeTerminalKey(clientKey);
+		const lookupKey = terminalKey ? terminalLookupKey(scopeKey, terminalKey) : void 0;
+		const existingId = lookupKey ? this.terminalKeys.get(lookupKey) : void 0;
+		const existingRecord = existingId ? this.terminals.get(existingId) : void 0;
+		if (existingRecord && !existingRecord.exited) {
+			existingRecord.lastUsedAt = Date.now();
+			return {
+				id: existingRecord.id,
+				backend: existingRecord.backend,
+				cwd: existingRecord.cwd,
+				shell: terminalLabel(existingRecord.shell),
+				reused: true
+			};
+		}
+		if (existingRecord) await this.disposeTerminalRecord(existingRecord.id);
+		const spawnConfig = this.createSpawnConfig();
+		const pty = await this.spawnPty(spawnConfig, cwd, cols, rows);
+		const id = randomUUID();
+		const now = Date.now();
+		const record = {
+			id,
+			args: spawnConfig.args,
+			backend: spawnConfig.backend,
+			command: spawnConfig.command,
+			scopeKey,
+			cwd,
+			shell: spawnConfig.shellLabel,
+			pty,
+			dataDisposable: { dispose: () => {} },
+			exitDisposable: { dispose: () => {} },
+			subscribers: /* @__PURE__ */ new Set(),
+			backlog: [],
+			backlogBytes: 0,
+			nextOutputSeq: 1,
+			lastInputSeq: 0,
+			createdAt: now,
+			lastUsedAt: now
+		};
+		if (lookupKey) record.lookupKey = lookupKey;
+		if (terminalKey) record.terminalKey = terminalKey;
+		this.attachPtyHandlers(record);
+		this.terminals.set(id, record);
+		if (lookupKey) this.terminalKeys.set(lookupKey, id);
+		return {
+			id,
+			backend: record.backend,
+			cwd,
+			shell: terminalLabel(record.shell),
+			reused: false
+		};
+	}
+	createEventsResponse(id, scopeKey, signal, lastSeq) {
+		const record = this.assertTerminalScope(id, scopeKey);
+		record.lastUsedAt = Date.now();
+		let cleanupStream = () => {};
+		const stream = new ReadableStream({
+			start: (controller) => {
+				let closed = false;
+				const send = (event) => {
+					if (closed) return;
+					try {
+						controller.enqueue(this.encoder.encode(sseFrame(event)));
+					} catch {
+						cleanup();
+					}
+				};
+				const cleanup = () => {
+					if (closed) return;
+					closed = true;
+					record.subscribers.delete(send);
+					signal.removeEventListener("abort", cleanup);
+					try {
+						controller.close();
+					} catch {}
+				};
+				cleanupStream = cleanup;
+				record.subscribers.add(send);
+				signal.addEventListener("abort", cleanup, { once: true });
+				this.sendInitialEvents(record, send, lastSeq);
+			},
+			cancel: () => {
+				cleanupStream();
+			}
+		});
+		return new Response(stream, { headers: {
+			"cache-control": "no-cache, no-transform",
+			connection: "keep-alive",
+			"content-type": "text/event-stream; charset=utf-8",
+			"x-accel-buffering": "no"
+		} });
+	}
+	validateTerminal(id, scopeKey) {
+		this.assertTerminalScope(id, scopeKey);
+	}
+	connectWebSocket(options) {
+		const { id, lastSeq, peer, scopeKey } = options;
+		const record = this.assertTerminalScope(id, scopeKey);
+		record.lastUsedAt = Date.now();
+		let closed = false;
+		const send = (event) => {
+			if (closed) return;
+			try {
+				peer.send(JSON.stringify(event));
+			} catch {
+				cleanup();
+			}
+		};
+		const cleanup = () => {
+			if (closed) return;
+			closed = true;
+			record.subscribers.delete(send);
+		};
+		record.subscribers.add(send);
+		this.sendInitialEvents(record, send, lastSeq);
+		return cleanup;
+	}
+	handleWebSocketMessage(options) {
+		const { id, message, peer, scopeKey } = options;
+		try {
+			const payload = parseTerminalWebSocketMessage(message);
+			if (payload.type === "input") {
+				const inputSeq = this.writeTerminal(id, scopeKey, payload.data, payload.inputSeq);
+				if (typeof inputSeq === "number" && inputSeq > 0) peer.send(JSON.stringify({
+					type: "input_ack",
+					inputSeq
+				}));
+				return;
+			}
+			if (payload.type === "resize") {
+				this.resizeTerminal(id, scopeKey, payload);
+				return;
+			}
+			peer.send(JSON.stringify({ type: "pong" }));
+		} catch (error) {
+			try {
+				peer.send(JSON.stringify({
+					type: "error",
+					error: formatTerminalError(error)
+				}));
+			} catch {}
+		}
+	}
+	writeTerminal(id, scopeKey, data, inputSeq) {
+		const record = this.assertTerminalScope(id, scopeKey);
+		if (record.exited) throw new Error("Terminal has exited.");
+		if (typeof data !== "string") throw new Error("Terminal input data is required.");
+		const normalizedInputSeq = normalizeDimension(inputSeq, 0, 0, Number.MAX_SAFE_INTEGER);
+		if (normalizedInputSeq > 0) {
+			if (normalizedInputSeq <= record.lastInputSeq) return normalizedInputSeq;
+			record.lastInputSeq = normalizedInputSeq;
+		}
+		record.lastUsedAt = Date.now();
+		record.pty.write(data);
+		return normalizedInputSeq > 0 ? normalizedInputSeq : void 0;
+	}
+	resizeTerminal(id, scopeKey, dimensions) {
+		const record = this.assertTerminalScope(id, scopeKey);
+		if (record.exited) return;
+		const cols = normalizeDimension(dimensions.cols, record.pty.cols, TERMINAL_MIN_COLS, TERMINAL_MAX_COLS);
+		const rows = normalizeDimension(dimensions.rows, record.pty.rows, TERMINAL_MIN_ROWS, TERMINAL_MAX_ROWS);
+		record.lastUsedAt = Date.now();
+		record.pty.resize(cols, rows);
+	}
+	async closeTerminal(id, scopeKey) {
+		this.assertTerminalScope(id, scopeKey);
+		await this.disposeTerminalRecord(id);
+	}
+	dispose() {
+		clearInterval(this.cleanupTimer);
+		for (const id of this.terminals.keys()) this.disposeTerminalRecord(id);
+	}
+	async spawnPty(spawnConfig, cwd, cols, rows) {
+		return (await import("node-pty")).spawn(spawnConfig.command, spawnConfig.args, {
+			cols: normalizeDimension(cols, TERMINAL_DEFAULT_COLS, TERMINAL_MIN_COLS, TERMINAL_MAX_COLS),
+			cwd,
+			env: createTerminalEnv(),
+			name: "xterm-256color",
+			rows: normalizeDimension(rows, TERMINAL_DEFAULT_ROWS, TERMINAL_MIN_ROWS, TERMINAL_MAX_ROWS)
+		});
+	}
+	attachPtyHandlers(record) {
+		record.dataDisposable = record.pty.onData((data) => {
+			const seq = record.nextOutputSeq;
+			record.nextOutputSeq += 1;
+			this.publish(record, {
+				type: "output",
+				data,
+				seq
+			});
+		});
+		record.exitDisposable = record.pty.onExit((event) => {
+			this.handlePtyExit(record, event.exitCode, event.signal);
+		});
+	}
+	handlePtyExit(record, exitCode, signal) {
+		if (this.terminals.get(record.id) !== record) return;
+		record.exited = exitPayload(exitCode, signal);
+		this.publish(record, exitEvent(exitCode, signal));
+	}
+	createSpawnConfig() {
+		const shell = defaultShell();
+		return {
+			args: [],
+			backend: "shell",
+			command: shell,
+			shellLabel: shell
+		};
+	}
+	assertTerminalScope(id, scopeKey) {
+		const record = this.terminals.get(id);
+		if (!record) throw new Error("Terminal not found.");
+		if (record.scopeKey !== scopeKey) throw new Error("Terminal not found for this session.");
+		return record;
+	}
+	sendInitialEvents(record, send, lastSeq) {
+		send(readyEvent(record));
+		const firstSeq = record.backlog[0]?.seq;
+		if (typeof lastSeq === "number" && firstSeq !== void 0 && lastSeq < firstSeq - 1) send({
+			type: "reset",
+			reason: "backlog_gap",
+			firstSeq,
+			nextSeq: record.nextOutputSeq
+		});
+		for (const event of record.backlog) {
+			if (typeof lastSeq === "number" && event.seq <= lastSeq) continue;
+			send(event);
+		}
+		if (record.exited) send(exitEvent(record.exited.exitCode, record.exited.signal));
+	}
+	publish(record, event) {
+		record.lastUsedAt = Date.now();
+		this.rememberBacklog(record, event);
+		for (const subscriber of record.subscribers) try {
+			subscriber(event);
+		} catch {
+			record.subscribers.delete(subscriber);
+		}
+	}
+	rememberBacklog(record, event) {
+		if (event.type !== "output") return;
+		record.backlog.push(event);
+		record.backlogBytes += eventSize(event);
+		while (record.backlog.length > TERMINAL_BACKLOG_MAX_CHUNKS || record.backlogBytes > TERMINAL_BACKLOG_MAX_BYTES) {
+			const removed = record.backlog.shift();
+			if (!removed) break;
+			record.backlogBytes = Math.max(0, record.backlogBytes - eventSize(removed));
+		}
+	}
+	async disposeTerminalRecord(id) {
+		const record = this.terminals.get(id);
+		if (!record) return;
+		this.terminals.delete(id);
+		if (record.lookupKey) this.terminalKeys.delete(record.lookupKey);
+		record.subscribers.clear();
+		try {
+			record.dataDisposable.dispose();
+		} catch {}
+		try {
+			record.exitDisposable.dispose();
+		} catch {}
+		try {
+			record.pty.kill();
+		} catch (error) {
+			const message = formatTerminalError(error);
+			if (!record.exited) this.rememberBacklog(record, {
+				type: "error",
+				error: message
+			});
+		}
+	}
+	cleanupExitedTerminals() {
+		const now = Date.now();
+		for (const record of this.terminals.values()) {
+			if (record.subscribers.size > 0) continue;
+			if (!record.exited) continue;
+			if (now - record.lastUsedAt < TERMINAL_EXITED_TTL_MS) continue;
+			this.disposeTerminalRecord(record.id);
+		}
+	}
+};
 function messageItemIndex(item) {
 	const match = item.itemKey?.match(/^message:(\d+)$/);
 	if (!match) return -1;
@@ -1399,6 +1857,22 @@ function serializeSessionTreeNode(node) {
 	});
 	return serialized;
 }
+function extractBranchableMessages(entry) {
+	const manager = entry.session.sessionManager;
+	const leafId = manager.getLeafId?.() ?? null;
+	const branchEntries = manager.getBranch?.(leafId) ?? [];
+	return (branchEntries.length > 0 ? branchEntries : []).flatMap((entry) => {
+		const entryId = typeof entry.id === "string" ? entry.id.trim() : "";
+		const message = entry.message;
+		const role = typeof message?.role === "string" ? message.role : "";
+		if (!entryId || entry.type !== "message" || role !== "user" && role !== "assistant") return [];
+		return [{
+			entryId,
+			role,
+			text: extractMessageText(message)
+		}];
+	});
+}
 function extractForkableUserMessages(entry) {
 	const messages = entry.session.getUserMessagesForForking?.();
 	if (Array.isArray(messages) && messages.length > 0) return messages.flatMap((message) => {
@@ -2486,6 +2960,39 @@ async function unstageDirectoryGitAll(cwd) {
 		stderr: result.stderr
 	};
 }
+async function unstageDirectoryGitFile(cwd, path, previousPath) {
+	const normalizedCwd = normalizeGitCwd(cwd);
+	const normalizedPath = assertGitFilePath(path);
+	const normalizedPreviousPath = previousPath ? assertGitFilePath(previousPath) : void 0;
+	if (!normalizedCwd) throw new Error("cwd is required");
+	if (!await isInsideWorkTree(normalizedCwd)) throw new Error("No git repository detected");
+	const paths = uniqueGitActionPaths([normalizedPreviousPath, normalizedPath]);
+	const result = await gitRepositoryHasHead(normalizedCwd) ? await runCommand("git", [
+		"restore",
+		"--staged",
+		"--",
+		...paths
+	], {
+		cwd: normalizedCwd,
+		timeoutMs: GIT_ACTION_TIMEOUT_MS
+	}) : await runCommand("git", [
+		"rm",
+		"-r",
+		"--cached",
+		"--ignore-unmatch",
+		"--",
+		...paths
+	], {
+		cwd: normalizedCwd,
+		timeoutMs: GIT_ACTION_TIMEOUT_MS
+	});
+	if (result.code !== 0) throw new Error(gitCommandErrorMessage("Failed to unstage changes", result));
+	invalidateDirectoryGitCaches(normalizedCwd);
+	return {
+		stdout: result.stdout,
+		stderr: result.stderr
+	};
+}
 async function discardDirectoryGitAll(cwd) {
 	const normalizedCwd = normalizeGitCwd(cwd);
 	if (!normalizedCwd) throw new Error("cwd is required");
@@ -3539,12 +4046,20 @@ var VALID_THINKING_LEVELS = new Set([
 	"high",
 	"xhigh"
 ]);
+var PICO_DEFAULT_MODEL_PROVIDER = "openai-codex";
+var PICO_DEFAULT_MODEL_ID = "gpt-5.5";
+var PICO_DEFAULT_THINKING_LEVEL = "xhigh";
 var SESSION_LIST_LIMIT_DEFAULT = 5;
 var SESSION_LIST_LIMIT_MAX = 100;
 var SESSION_HISTORY_PAGE_LIMIT_DEFAULT = 50;
 var SESSION_HISTORY_PAGE_LIMIT_MAX = 200;
 var SESSION_NAME_MAX_LENGTH = 48;
 var HEARTBEAT_INTERVAL_MS = 2e4;
+var SSE_RETRY_MS = 1e3;
+var SSE_REPLAY_MAX_EVENTS = 200;
+var CONTEXT_INACTIVE_GRACE_MS = 3e4;
+var PROMPT_IDEMPOTENCY_TTL_MS = 1440 * 60 * 1e3;
+var PROMPT_IDEMPOTENCY_MAX_RECORDS = 200;
 var SESSION_INDEX_CACHE_TTL_MS = 5e3;
 var SESSION_LOAD_DEBUG_ENV_KEYS = [
 	"PICO_DEBUG_SESSION_LOAD",
@@ -3702,17 +4217,40 @@ function normalizeRequestedDirectories(values) {
 	}
 	return nextDirectories;
 }
+function textFromThinkingSignature(value) {
+	if (typeof value !== "string" || !value.trim()) return "";
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		return "";
+	}
+	if (!parsed || typeof parsed !== "object") return "";
+	const content = parsed.content;
+	if (!Array.isArray(content)) return "";
+	return content.flatMap((part) => {
+		if (!part || typeof part !== "object") return [];
+		const type = part.type;
+		const text = part.text;
+		return type === "reasoning_text" && typeof text === "string" && text.trim() ? [text] : [];
+	}).join("\n\n").trim();
+}
 function sanitizeMessageContentPart(part) {
 	const type = typeof part?.type === "string" ? part.type : "";
 	if (type === "text") return {
 		type: "text",
 		text: typeof part.text === "string" ? part.text : ""
 	};
-	if (type === "thinking") return {
-		type: "thinking",
-		thinking: typeof part.thinking === "string" ? part.thinking : "",
-		...typeof part.summaryLabel === "string" ? { summaryLabel: part.summaryLabel } : {}
-	};
+	if (type === "thinking") {
+		const rawThinking = typeof part.thinking === "string" ? part.thinking : "";
+		const signatureThinking = textFromThinkingSignature(part.thinkingSignature);
+		const summaryLabel = typeof part.summaryLabel === "string" ? part.summaryLabel : signatureThinking && rawThinking.trim() ? rawThinking : void 0;
+		return {
+			type: "thinking",
+			thinking: signatureThinking || rawThinking,
+			...summaryLabel ? { summaryLabel } : {}
+		};
+	}
 	if (type === "toolCall") return {
 		type: "toolCall",
 		...typeof part.id === "string" ? { id: part.id } : {},
@@ -3733,6 +4271,8 @@ function sanitizeSessionMessage(message) {
 		const sanitizedPart = sanitizeMessageContentPart(part);
 		return sanitizedPart ? [sanitizedPart] : [];
 	}) : typeof message?.content === "string" ? message.content : void 0;
+	const tokensBefore = Number(message?.tokensBefore);
+	const estimatedTokensAfter = message?.estimatedTokensAfter == null ? NaN : Number(message.estimatedTokensAfter);
 	return {
 		...role ? { role } : {},
 		...sanitizedContent !== void 0 ? { content: sanitizedContent } : {},
@@ -3743,7 +4283,8 @@ function sanitizeSessionMessage(message) {
 		...message?.queued || metadata?.queued ? { queued: true } : {},
 		...message?.streamingBehavior === "steer" || message?.streamingBehavior === "followUp" ? { streamingBehavior: message.streamingBehavior } : message?.deliverAs === "steer" || message?.deliverAs === "followUp" ? { streamingBehavior: message.deliverAs } : metadata?.streamingBehavior === "steer" || metadata?.streamingBehavior === "followUp" ? { streamingBehavior: metadata.streamingBehavior } : metadata?.deliverAs === "steer" || metadata?.deliverAs === "followUp" ? { streamingBehavior: metadata.deliverAs } : {},
 		...typeof message?.summary === "string" ? { summary: message.summary } : {},
-		...Number.isFinite(Number(message?.tokensBefore)) ? { tokensBefore: Number(message.tokensBefore) } : {},
+		...Number.isFinite(tokensBefore) ? { tokensBefore } : {},
+		...Number.isFinite(estimatedTokensAfter) ? { estimatedTokensAfter } : {},
 		...typeof message?.toolCallId === "string" ? { toolCallId: message.toolCallId } : {},
 		...Object.prototype.hasOwnProperty.call(message, "details") ? { details: message.details } : {},
 		...message?.isError ? { isError: true } : {}
@@ -3902,10 +4443,72 @@ function normalizeClientPendingId(value) {
 	if (pendingId.length > 128) return void 0;
 	return pendingId;
 }
+function normalizeClientPromptRequestId(value) {
+	if (typeof value !== "string") return void 0;
+	const requestId = value.trim();
+	if (!requestId.startsWith("prompt:")) return void 0;
+	if (requestId.length > 160) return void 0;
+	return requestId;
+}
+function parsePositiveInteger(value) {
+	if (!value) return void 0;
+	const parsed = Number(value);
+	if (!Number.isSafeInteger(parsed) || parsed < 0) return void 0;
+	return parsed;
+}
+function terminalWebSocketIdFromRequest(request) {
+	const pathname = new URL(request.url).pathname;
+	const match = /^\/api\/terminal\/([^/]+)\/ws\/?$/.exec(pathname);
+	if (!match?.[1]) throw new Response("Terminal WebSocket route not found.", { status: 404 });
+	try {
+		return decodeURIComponent(match[1]);
+	} catch {
+		throw new Response("Invalid terminal id.", { status: 400 });
+	}
+}
+function terminalWebSocketCleanupFromPeer(peer) {
+	const cleanup = peer.context.terminalCleanup;
+	return typeof cleanup === "function" ? cleanup : void 0;
+}
+function terminalWebSocketContextFromPeer(peer) {
+	const { terminalId, terminalLastSeq, terminalScopeKey } = peer.context;
+	if (typeof terminalId !== "string" || !terminalId) throw new Error("Terminal WebSocket is missing a terminal id.");
+	if (typeof terminalScopeKey !== "string" || !terminalScopeKey) throw new Error("Terminal WebSocket is missing a terminal scope.");
+	return {
+		terminalId,
+		terminalLastSeq: typeof terminalLastSeq === "number" ? terminalLastSeq : void 0,
+		terminalScopeKey
+	};
+}
+function normalizePromptDraftOwnerKey(value) {
+	if (typeof value !== "string") return "";
+	const ownerKey = value.trim();
+	if (!ownerKey.startsWith("draft:")) return "";
+	if (ownerKey.length > 1024) return "";
+	return ownerKey;
+}
+function normalizePromptDraftCwd(value) {
+	if (typeof value !== "string") return void 0;
+	return value.trim() || void 0;
+}
+function promptDraftOwnerKeyForCwd(cwd) {
+	return `draft:${cwd?.trim() || "default"}`;
+}
+function promptDraftCwdFromOwnerKey(ownerKey) {
+	if (!ownerKey || ownerKey === promptDraftOwnerKeyForCwd(void 0)) return;
+	return ownerKey.slice(6).trim() || void 0;
+}
+function promptDraftTargetMatches(entry, target) {
+	if (target.cwd && entry.cwd === target.cwd) return true;
+	const entryOwnerKey = promptDraftOwnerKeyForCwd(entry.cwd);
+	if (target.ownerKey === entryOwnerKey) return true;
+	return target.ownerKey === promptDraftOwnerKeyForCwd(void 0);
+}
 var PicoRuntime = class {
 	encoder = new TextEncoder();
 	contexts = /* @__PURE__ */ new Map();
 	sessionEntries = /* @__PURE__ */ new Map();
+	contextCleanupTimeout;
 	sessionTreeLeafOverrides = /* @__PURE__ */ new Map();
 	servicesByCwd = /* @__PURE__ */ new Map();
 	pendingUiRequests = /* @__PURE__ */ new Map();
@@ -3916,6 +4519,7 @@ var PicoRuntime = class {
 	gitWatchManager = new GitWatchManager((change) => {
 		this.handleGitWatchChange(change);
 	});
+	terminalManager = new PicoTerminalManager();
 	sessionIndexCache;
 	sessionIndexPromise;
 	sdkPromise;
@@ -4060,6 +4664,20 @@ var PicoRuntime = class {
 			});
 		});
 	}
+	findPicoDefaultModel(entry) {
+		return entry.services.modelRegistry.getAvailable().find((model) => model.provider === PICO_DEFAULT_MODEL_PROVIDER && model.id === PICO_DEFAULT_MODEL_ID);
+	}
+	async applyPicoDefaultSessionPreferences(entry) {
+		const settingsManager = entry.services.settingsManager;
+		const configuredProvider = settingsManager.getDefaultProvider?.()?.trim();
+		const configuredModel = settingsManager.getDefaultModel?.()?.trim();
+		const configuredThinkingLevel = settingsManager.getDefaultThinkingLevel?.()?.trim();
+		if (!configuredProvider && !configuredModel) {
+			const defaultModel = this.findPicoDefaultModel(entry);
+			if (defaultModel && (entry.session.model?.provider !== defaultModel.provider || entry.session.model?.id !== defaultModel.id)) await entry.session.setModel(defaultModel);
+		}
+		if (!configuredThinkingLevel && entry.session.thinkingLevel !== PICO_DEFAULT_THINKING_LEVEL && entry.session.getAvailableThinkingLevels().includes(PICO_DEFAULT_THINKING_LEVEL)) entry.session.setThinkingLevel(PICO_DEFAULT_THINKING_LEVEL);
+	}
 	listAvailableModels(entry) {
 		return entry.services.modelRegistry.getAvailable().flatMap((model) => {
 			const serializedModel = serializeModel(model);
@@ -4090,7 +4708,10 @@ var PicoRuntime = class {
 			draftKey: void 0,
 			sessionScope: process.cwd(),
 			unreadFinished: /* @__PURE__ */ new Set(),
-			sidebarBootstrapDirectories: []
+			sidebarBootstrapDirectories: [],
+			nextSseEventId: 1,
+			replayEvents: [],
+			inactiveSince: void 0
 		};
 		this.contexts.set(id, next);
 		return next;
@@ -4152,11 +4773,27 @@ var PicoRuntime = class {
 		});
 		await Promise.all(candidates.map((entry) => this.disposeSessionEntry(entry)));
 	}
+	scheduleInactiveContextCleanup() {
+		if (this.contextCleanupTimeout) return;
+		this.contextCleanupTimeout = setTimeout(() => {
+			this.contextCleanupTimeout = void 0;
+			this.cleanupInactiveContexts();
+		}, CONTEXT_INACTIVE_GRACE_MS + 100);
+	}
 	async cleanupInactiveContexts() {
+		const now = performance.now();
 		for (const context of this.contexts.values()) {
-			if (context.clients.size > 0) continue;
+			if (context.clients.size > 0) {
+				context.inactiveSince = void 0;
+				continue;
+			}
 			const activeEntry = this.getActiveEntry(context);
 			if (activeEntry && this.isSessionBusyForDone(activeEntry)) continue;
+			context.inactiveSince ??= now;
+			if (now - context.inactiveSince < CONTEXT_INACTIVE_GRACE_MS) {
+				this.scheduleInactiveContextCleanup();
+				continue;
+			}
 			this.contexts.delete(context.id);
 		}
 		this.syncGitWatchDirectories();
@@ -4199,6 +4836,49 @@ var PicoRuntime = class {
 		}
 		return lastValue;
 	}
+	stateConversationItems(entry) {
+		const branchableMessages = extractBranchableMessages(entry);
+		const forkableMessages = branchableMessages.length === 0 ? extractForkableUserMessages(entry) : [];
+		if (branchableMessages.length === 0 && forkableMessages.length === 0) return entry.retainedConversationItems;
+		let branchableIndex = 0;
+		let forkableIndex = 0;
+		let changed = false;
+		const nextBranchableMessage = (role) => {
+			const matchedIndex = branchableMessages.findIndex((message, index) => index >= branchableIndex && message.role === role);
+			if (matchedIndex < 0) return void 0;
+			branchableIndex = matchedIndex + 1;
+			return branchableMessages[matchedIndex];
+		};
+		const nextForkableUserEntryId = (text) => {
+			const normalizedText = text.trim();
+			if (!normalizedText) return void 0;
+			const matchedIndex = forkableMessages.findIndex((message, index) => index >= forkableIndex && message.text.trim() === normalizedText);
+			if (matchedIndex < 0) return void 0;
+			forkableIndex = matchedIndex + 1;
+			return forkableMessages[matchedIndex]?.entryId;
+		};
+		const items = entry.retainedConversationItems.map((item) => {
+			if (item.kind === "user") {
+				const entryId = nextBranchableMessage("user")?.entryId ?? nextForkableUserEntryId(item.text);
+				if (!entryId || item.forkEntryId === entryId) return item;
+				changed = true;
+				return {
+					...item,
+					forkEntryId: entryId
+				};
+			}
+			if (item.streaming) return item;
+			const entryId = nextBranchableMessage("assistant")?.entryId;
+			if (!entryId || item.branchEntryId === entryId) return item;
+			changed = true;
+			return {
+				...item,
+				branchEntryId: entryId
+			};
+		});
+		if (changed) entry.retainedConversationItems = items;
+		return entry.retainedConversationItems;
+	}
 	currentStatePayload(entry, context) {
 		const draft = this.isDraftEntry(entry);
 		const historyTotalCount = entry.session.messages.length;
@@ -4206,7 +4886,7 @@ var PicoRuntime = class {
 			type: "state_sync",
 			activationRevision: context.activeRevision,
 			sessionKey: entry.key,
-			items: entry.retainedConversationItems,
+			items: this.stateConversationItems(entry),
 			pendingUserMessages: entry.pendingUserMessages.map((message) => clonePendingUserMessage(message)),
 			draft,
 			streaming: this.getEntryStreamingState(entry),
@@ -4504,8 +5184,32 @@ var PicoRuntime = class {
 			messages
 		};
 	}
+	shouldReplayPayload(payload) {
+		if (!payload || typeof payload !== "object") return false;
+		const type = payload.type;
+		return type === "session_done" || type === "request_error" || type === "extension_error" || type === "extension_ui_request" || type === "auto_session_naming_error" || type === "git_changed";
+	}
+	rememberReplayPayload(context, payload) {
+		if (!this.shouldReplayPayload(payload)) return void 0;
+		const eventId = context.nextSseEventId;
+		context.nextSseEventId += 1;
+		context.replayEvents.push({
+			id: eventId,
+			text: formatSsePayloadText(payload, { id: String(eventId) })
+		});
+		while (context.replayEvents.length > SSE_REPLAY_MAX_EVENTS) context.replayEvents.shift();
+		return String(eventId);
+	}
+	replayEventsToClient(context, client, lastEventId) {
+		if (lastEventId === void 0 || context.replayEvents.length === 0) return;
+		for (const event of context.replayEvents) {
+			if (event.id <= lastEventId) continue;
+			this.writeRawToClient(context, client, event.text);
+		}
+	}
 	sendToContext(context, payload) {
-		for (const client of context.clients) this.sendPayloadToClient(context, client, payload);
+		const eventId = this.rememberReplayPayload(context, payload);
+		for (const client of context.clients) this.sendPayloadToClient(context, client, payload, { eventId });
 	}
 	sendStatePayloadToClient(context, client, payload, options) {
 		const debug = isSessionLoadDebugEnabled();
@@ -4845,6 +5549,32 @@ var PicoRuntime = class {
 		if (!entry || !this.isDraftEntry(entry)) return;
 		if (![...this.contexts.values()].some((context) => context.activeKey === entry.key || context.draftKey === entry.key)) await this.disposeSessionEntry(entry);
 	}
+	async recoverMissingPromptDraftTarget(context, target) {
+		if (!target.ownerKey && !target.cwd) return void 0;
+		const matchesTarget = (entry) => Boolean(entry && this.isDraftEntry(entry) && promptDraftTargetMatches(entry, target));
+		const recoveredCwd = target.cwd || promptDraftCwdFromOwnerKey(target.ownerKey) || (target.ownerKey === promptDraftOwnerKeyForCwd(void 0) ? resolveScopeCwd(context.sessionScope, process.cwd()) : void 0);
+		const activeEntry = this.getActiveEntry(context);
+		if (matchesTarget(activeEntry)) return activeEntry;
+		if (activeEntry && recoveredCwd && activeEntry.cwd === recoveredCwd && this.getEntryStreamingState(activeEntry)) return activeEntry;
+		const draftEntry = context.draftKey ? this.sessionEntries.get(context.draftKey) : void 0;
+		if (draftEntry && matchesTarget(draftEntry)) {
+			await this.activateContextSession(context, draftEntry);
+			return draftEntry;
+		}
+		if (!recoveredCwd) return void 0;
+		const nextEntry = await this.createNewSessionEntry(recoveredCwd, {
+			draft: true,
+			sessionDir: activeEntry && recoveredCwd === activeEntry.cwd ? activeEntry.session.sessionManager.getSessionDir?.() : void 0,
+			sessionStartEvent: {
+				type: "session_start",
+				reason: "new",
+				previousSessionFile: activeEntry?.session.sessionFile
+			}
+		});
+		context.draftKey = nextEntry.key;
+		await this.activateContextSession(context, nextEntry);
+		return nextEntry;
+	}
 	async clearContextDraft(context) {
 		await clearContextDraft({
 			context,
@@ -4958,6 +5688,9 @@ var PicoRuntime = class {
 	getBaseCwd(activeEntry, context) {
 		return activeEntry.cwd || resolveScopeCwd(context.sessionScope, process.cwd());
 	}
+	getTerminalScopeKey(activeEntry, context) {
+		return `${context.id}:${activeEntry.key}:${this.getBaseCwd(activeEntry, context)}`;
+	}
 	async createSessionEntryFromRuntime(runtime, options) {
 		const startedAt = performance.now();
 		this.logRuntimeDiagnostics(runtime.diagnostics);
@@ -4990,6 +5723,7 @@ var PicoRuntime = class {
 			retainedConversationItems: createRetainedConversationState(session.messages.map((message) => sanitizeSessionMessage(message))).items,
 			pendingUserMessages: [],
 			pendingQueueMutation: false,
+			pausedPendingUserMessageIds: /* @__PURE__ */ new Set(),
 			canceledPendingUserMessageIds: /* @__PURE__ */ new Set(),
 			firstMessageHint: "",
 			modifiedAt: void 0,
@@ -5004,6 +5738,7 @@ var PicoRuntime = class {
 				disposed: false
 			},
 			promptRequestChain: Promise.resolve(),
+			promptRequestRecords: /* @__PURE__ */ new Map(),
 			doneNotificationSuppressed: false
 		};
 		this.sessionEntries.set(key, entry);
@@ -5039,10 +5774,12 @@ var PicoRuntime = class {
 	async createNewSessionEntry(cwd, options) {
 		const sessionManager = (await this.getSdk()).SessionManager.create(cwd, options?.sessionDir);
 		if (options?.newSessionOptions && sessionManager.newSession) sessionManager.newSession(options.newSessionOptions);
-		return await this.createSessionEntry(sessionManager, {
+		const entry = await this.createSessionEntry(sessionManager, {
 			draft: options?.draft,
 			sessionStartEvent: options?.sessionStartEvent
 		});
+		await this.applyPicoDefaultSessionPreferences(entry);
+		return entry;
 	}
 	async ensureSessionEntryByPath(sessionPath) {
 		const existing = this.sessionEntries.get(sessionPath);
@@ -5172,6 +5909,18 @@ var PicoRuntime = class {
 			refinementReason: input.refinementReason
 		});
 	}
+	applyHeuristicSessionNameAttempt(entry, text, imageCount) {
+		const heuristic = deriveHeuristicSessionNameAttempt(text, imageCount);
+		if (heuristic.name) this.applyManagedSessionName(entry, heuristic.name, "initial");
+		return heuristic;
+	}
+	applySessionNameFallbackAfterRefinementFailure(entry, text, imageCount) {
+		if (this.getCurrentSessionName(entry)) return true;
+		if (this.applyHeuristicSessionNameAttempt(entry, text, imageCount).name && this.getCurrentSessionName(entry)) return true;
+		const fallbackName = cleanupSessionNameCandidate(normalizeSessionListTitle(text, SESSION_NAME_MAX_LENGTH));
+		if (!fallbackName) return false;
+		return this.applyManagedSessionName(entry, fallbackName, "initial");
+	}
 	scheduleSessionNameRefinement(entry, text, imageCount, heuristicReason) {
 		if (entry.sessionNaming.pendingGeneration) return;
 		entry.sessionNaming.pendingGeneration = true;
@@ -5181,10 +5930,11 @@ var PicoRuntime = class {
 			try {
 				const generated = await generateSessionNameWithLlm({
 					cwd: entry.cwd,
+					model: entry.session.model,
 					services: { modelRegistry: entry.services.modelRegistry }
 				}, text, imageCount);
 				if (!generated?.name) {
-					if (!entry.sessionNaming.disposed && entry.sessionNaming.nonce === nonce && sessionId === entry.session.sessionId && !this.getCurrentSessionName(entry)) this.emitAutoSessionNamingFailure(entry, {
+					if (!entry.sessionNaming.disposed && entry.sessionNaming.nonce === nonce && sessionId === entry.session.sessionId && !this.applySessionNameFallbackAfterRefinementFailure(entry, text, imageCount)) this.emitAutoSessionNamingFailure(entry, {
 						heuristicReason,
 						refinementReason: generated?.reason || "session name refinement returned no usable title",
 						text,
@@ -5195,7 +5945,7 @@ var PicoRuntime = class {
 				if (entry.sessionNaming.disposed || entry.sessionNaming.nonce !== nonce || sessionId !== entry.session.sessionId) return;
 				this.applyManagedSessionName(entry, generated.name, "refine");
 			} catch (error) {
-				if (!entry.sessionNaming.disposed && entry.sessionNaming.nonce === nonce && sessionId === entry.session.sessionId && !this.getCurrentSessionName(entry)) this.emitAutoSessionNamingFailure(entry, {
+				if (!entry.sessionNaming.disposed && entry.sessionNaming.nonce === nonce && sessionId === entry.session.sessionId && !this.applySessionNameFallbackAfterRefinementFailure(entry, text, imageCount)) this.emitAutoSessionNamingFailure(entry, {
 					heuristicReason,
 					refinementReason: formatError(error),
 					text,
@@ -5208,21 +5958,28 @@ var PicoRuntime = class {
 	}
 	startAutoSessionNaming(entry, text, imageCount) {
 		if (this.getCurrentSessionName(entry)) return;
-		const heuristic = deriveHeuristicSessionNameAttempt(text, imageCount);
-		if (heuristic.name) this.applyManagedSessionName(entry, heuristic.name, "initial");
+		const heuristic = this.applyHeuristicSessionNameAttempt(entry, text, imageCount);
 		this.scheduleSessionNameRefinement(entry, text, imageCount, heuristic.reason);
 	}
-	maybeAutoNameSession(entry) {
-		if (this.getCurrentSessionName(entry)) return;
-		for (const message of entry.session.messages) {
+	getFirstPromptForNamingFromMessages(messages, firstMessageHint = "") {
+		for (const message of messages) {
 			if (message?.role !== "user") continue;
 			const firstPrompt = summarizePromptContent(message.content);
-			if (firstPrompt.text || firstPrompt.imageCount > 0) {
-				this.startAutoSessionNaming(entry, firstPrompt.text, firstPrompt.imageCount);
-				return;
-			}
+			if (firstPrompt.text || firstPrompt.imageCount > 0) return firstPrompt;
 		}
-		if (entry.firstMessageHint.trim()) this.startAutoSessionNaming(entry, entry.firstMessageHint.trim(), 0);
+		const trimmedHint = firstMessageHint.trim();
+		return trimmedHint ? {
+			text: trimmedHint,
+			imageCount: 0
+		} : null;
+	}
+	getSessionFirstPromptForNaming(entry) {
+		return this.getFirstPromptForNamingFromMessages(entry.session.messages, entry.firstMessageHint);
+	}
+	maybeAutoNameSession(entry) {
+		if (this.getCurrentSessionName(entry)) return;
+		const firstPrompt = this.getSessionFirstPromptForNaming(entry);
+		if (firstPrompt) this.startAutoSessionNaming(entry, firstPrompt.text, firstPrompt.imageCount);
 	}
 	reconcilePendingUserMessages(entry, queueState) {
 		const nextQueueState = queueState ?? {
@@ -5231,7 +5988,10 @@ var PicoRuntime = class {
 		};
 		const steering = [...nextQueueState.steering].filter((text) => typeof text === "string");
 		const followUp = [...nextQueueState.followUp].filter((text) => typeof text === "string");
-		const pending = entry.pendingUserMessages.map((message) => clonePendingUserMessage(message));
+		const allPending = entry.pendingUserMessages.map((message) => clonePendingUserMessage(message));
+		const pausedPending = allPending.filter((message) => entry.pausedPendingUserMessageIds.has(message.pendingId));
+		const pending = allPending.filter((message) => !entry.pausedPendingUserMessageIds.has(message.pendingId));
+		entry.pausedPendingUserMessageIds = new Set(pausedPending.map((message) => message.pendingId));
 		const steeringCounts = /* @__PURE__ */ new Map();
 		const followUpCounts = /* @__PURE__ */ new Map();
 		for (const text of steering) steeringCounts.set(text, (steeringCounts.get(text) ?? 0) + 1);
@@ -5257,7 +6017,7 @@ var PicoRuntime = class {
 			nextPending.push(createPendingUserMessage(text, [], "followUp"));
 			followUpCounts.set(text, count - 1);
 		}
-		entry.pendingUserMessages = sortPendingUserMessages(nextPending);
+		entry.pendingUserMessages = sortPendingUserMessages([...pausedPending, ...nextPending]);
 		return entry.pendingUserMessages;
 	}
 	pendingMessagesFromClientUpdate(entry, pendingMessagesUpdate) {
@@ -5328,6 +6088,75 @@ var PicoRuntime = class {
 		await this.broadcastEntryState(entry);
 		return entry.pendingUserMessages;
 	}
+	drainPendingUserMessagesWhenIdle(entry) {
+		if (entry.pendingQueueDrainPromise) return entry.pendingQueueDrainPromise;
+		const drainPromise = this.runSerializedPromptRequest(entry, async () => {
+			if (this.getEntryStreamingState(entry) || entry.session.isStreaming || this.getEntryCompactingState(entry) || entry.session.isCompacting) return;
+			const pendingMessages = sortPendingUserMessages(entry.pendingUserMessages.map((message) => clonePendingUserMessage(message)));
+			const pendingMessage = pendingMessages[0];
+			if (!pendingMessage) return;
+			const remainingMessages = pendingMessages.slice(1);
+			const message = pendingMessage.text;
+			const images = normalizePromptImages(pendingMessage.images);
+			if (!message.trim() && images.length === 0) {
+				await this.replacePendingUserMessages(entry, remainingMessages);
+				return;
+			}
+			entry.streamingState = true;
+			this.markSessionUserMessage(entry);
+			entry.pendingUserMessages = remainingMessages;
+			await this.broadcastEntryState(entry);
+			await this.broadcastSessionsAll();
+			this.broadcastToViewers(entry.key, {
+				type: "user_message",
+				message,
+				images,
+				queued: false
+			});
+			let promptPreflightComplete;
+			let promptPreflightSettled = false;
+			const promptPreflight = new Promise((resolve) => {
+				promptPreflightComplete = resolve;
+			});
+			const settlePromptPreflight = () => {
+				if (promptPreflightSettled) return;
+				promptPreflightSettled = true;
+				promptPreflightComplete?.();
+			};
+			const promptOptions = images.length > 0 ? { images } : void 0;
+			const promptPromise = entry.session.prompt(message, {
+				...promptOptions,
+				preflightResult: settlePromptPreflight
+			});
+			const finishPromptIfIdle = async () => {
+				if (!entry.streamingState || entry.session.isStreaming) return;
+				entry.streamingState = false;
+				this.reconcilePendingUserMessages(entry);
+				await this.broadcastEntryState(entry);
+				await this.broadcastSessionsAll();
+			};
+			promptPromise.then(() => {}).catch(async (error) => {
+				await finishPromptIfIdle();
+				console.error("[pico] queued prompt error", error);
+				this.broadcastToViewers(entry.key, {
+					type: "request_error",
+					scope: "prompt",
+					message,
+					error: formatError(error)
+				});
+			}).finally(() => {
+				settlePromptPreflight();
+			});
+			await promptPreflight;
+			if (remainingMessages.length > 0) await this.replacePendingUserMessages(entry, remainingMessages);
+		});
+		let trackedPromise = Promise.resolve();
+		trackedPromise = drainPromise.finally(() => {
+			if (entry.pendingQueueDrainPromise === trackedPromise) entry.pendingQueueDrainPromise = void 0;
+		});
+		entry.pendingQueueDrainPromise = trackedPromise;
+		return trackedPromise;
+	}
 	refreshRetainedConversationItems(entry) {
 		entry.retainedConversationItems = createRetainedConversationState(entry.session.messages.map((message) => sanitizeSessionMessage(message))).items;
 	}
@@ -5530,7 +6359,8 @@ var PicoRuntime = class {
 			const state = createRetainedConversationState(entry.session.messages.map((message) => sanitizeSessionMessage(message)));
 			const summary = result.summary;
 			const tokensBefore = result.tokensBefore;
-			state.items = [...state.items, createCompactionSummaryItem(summary, tokensBefore, `compaction:live:${state.items.length}`)];
+			const estimatedTokensAfter = result.estimatedTokensAfter;
+			state.items = [...state.items, createCompactionSummaryItem(summary, tokensBefore, `compaction:live:${state.items.length}`, estimatedTokensAfter)];
 			entry.retainedConversationItems = state.items;
 			return;
 		}
@@ -5563,6 +6393,7 @@ var PicoRuntime = class {
 				followUp: Array.isArray(event.followUp) ? event.followUp : []
 			});
 		}
+		if (type === "session_info_changed") this.touchSessionEntry(entry);
 		if (type === "message_end" && event.message?.role === "user") {
 			this.touchSessionEntry(entry);
 			this.reconcilePendingUserMessages(entry);
@@ -5575,6 +6406,7 @@ var PicoRuntime = class {
 			const willRetry = Boolean(event.willRetry);
 			if (compactionReason === "manual" && compactionSucceeded) this.scheduleSessionDoneCheck(entry, "manual_compaction");
 			else if (entry.pendingDoneReason === "agent" && !willRetry) this.scheduleSessionDoneCheck(entry, "agent", entry.pendingDoneOutcome ?? "success");
+			this.drainPendingUserMessagesWhenIdle(entry);
 		}
 		if (type === "auto_retry_end") {
 			if (entry.pendingDoneReason === "agent" && event.success === false) this.scheduleSessionDoneCheck(entry, "agent", "error");
@@ -5593,7 +6425,7 @@ var PicoRuntime = class {
 		if (statusChanged) this.broadcastSessionStatusAll(entry);
 		this.rememberSessionTreeLeaf(entry, true);
 		await this.broadcastEntryState(entry);
-		if (type === "agent_start" || type === "agent_end" || type === "message_end" || type === "compaction_end" || type === "queue_update") await this.broadcastSessionsAll();
+		if (type === "agent_start" || type === "agent_end" || type === "message_end" || type === "compaction_end" || type === "queue_update" || type === "session_info_changed") await this.broadcastSessionsAll();
 		if (type === "agent_end" || type === "compaction_end") await this.cleanupInactiveContexts();
 	}
 	writeRawToClient(context, client, text) {
@@ -5605,12 +6437,14 @@ var PicoRuntime = class {
 			closeSseClient: (activeContext, activeClient) => this.closeSseClient(activeContext, activeClient)
 		});
 	}
-	sendPayloadToClient(context, client, payload) {
+	sendPayloadToClient(context, client, payload, options) {
 		return sendPayloadToClient({
 			encoder: this.encoder,
 			context,
 			client,
 			payload,
+			eventId: options?.eventId,
+			retry: options?.retry,
 			closeSseClient: (activeContext, activeClient) => this.closeSseClient(activeContext, activeClient)
 		});
 	}
@@ -5618,6 +6452,10 @@ var PicoRuntime = class {
 		if (client.closed) return;
 		client.closed = true;
 		context.clients.delete(client);
+		if (context.clients.size === 0) {
+			context.inactiveSince = performance.now();
+			this.scheduleInactiveContextCleanup();
+		}
 		this.syncGitWatchDirectories();
 		try {
 			client.controller.close();
@@ -5627,6 +6465,7 @@ var PicoRuntime = class {
 		const startedAt = performance.now();
 		const { url, context, activeEntry } = await this.resolveRequest(request, { preferActiveDraft: false });
 		context.sidebarBootstrapDirectories = normalizeRequestedDirectories(url.searchParams.getAll("sidebarDirectory"));
+		const lastEventId = parsePositiveInteger(request.headers.get("last-event-id") || url.searchParams.get("lastEventId"));
 		this.logSessionLoadDebug("events_response:create", {
 			contextId: context.id,
 			sidebarBootstrapDirectoryCount: context.sidebarBootstrapDirectories.length,
@@ -5642,9 +6481,11 @@ var PicoRuntime = class {
 					controller,
 					lastStateSyncSnapshot: void 0
 				};
+				context.inactiveSince = void 0;
 				context.clients.add(client);
 				this.syncGitWatchDirectories();
-				this.writeRawToClient(context, client, ": connected\n\n");
+				this.writeRawToClient(context, client, `retry: ${SSE_RETRY_MS}\n: connected\n\n`);
+				this.replayEventsToClient(context, client, lastEventId);
 				(async () => {
 					const bootstrapStartedAt = performance.now();
 					try {
@@ -5704,8 +6545,43 @@ var PicoRuntime = class {
 			release?.();
 		}
 	}
+	prunePromptRequestRecords(entry) {
+		const now = Date.now();
+		for (const [requestId, record] of entry.promptRequestRecords) if (now - record.createdAt > PROMPT_IDEMPOTENCY_TTL_MS) entry.promptRequestRecords.delete(requestId);
+		while (entry.promptRequestRecords.size > PROMPT_IDEMPOTENCY_MAX_RECORDS) {
+			const oldestRequestId = entry.promptRequestRecords.keys().next().value;
+			if (!oldestRequestId) break;
+			entry.promptRequestRecords.delete(oldestRequestId);
+		}
+	}
 	async prompt(request, body) {
-		const { context, activeEntry } = await this.resolveRequest(request, {
+		const url = new URL(request.url);
+		const requestedSessionKey = url.searchParams.get("sessionKey")?.trim() || "";
+		const requestedDraftTarget = {
+			ownerKey: normalizePromptDraftOwnerKey(body.draftOwnerKey),
+			cwd: normalizePromptDraftCwd(body.draftCwd)
+		};
+		let resolvedContext;
+		let resolvedActiveEntry;
+		if (requestedSessionKey && !this.sessionEntries.has(requestedSessionKey)) {
+			const context = this.ensureContext(url.searchParams.get("context") || "default");
+			context.sessionScope = normalizeSessionScope(url.searchParams.get("scope"), process.cwd());
+			const recoveredEntry = await this.recoverMissingPromptDraftTarget(context, requestedDraftTarget);
+			if (!recoveredEntry) throw new Error("Requested session is no longer available.");
+			this.logSessionLoadDebug("prompt:recovered_missing_draft_target", {
+				requestedSessionKey,
+				requestedDraftOwnerKey: requestedDraftTarget.ownerKey || void 0,
+				requestedDraftCwd: requestedDraftTarget.cwd,
+				...this.sessionDebugDetails(recoveredEntry)
+			});
+			resolvedContext = context;
+			resolvedActiveEntry = recoveredEntry;
+		}
+		const { context, activeEntry } = resolvedActiveEntry ? {
+			url,
+			context: resolvedContext,
+			activeEntry: resolvedActiveEntry
+		} : await this.resolveRequest(request, {
 			preferActiveDraft: true,
 			preferActiveDraftOverRequestedSession: true
 		});
@@ -5716,104 +6592,132 @@ var PicoRuntime = class {
 		if (requestedThinkingLevel && !VALID_THINKING_LEVELS.has(requestedThinkingLevel)) throw new Error(`Invalid thinking level: ${requestedThinkingLevel || "(empty)"}`);
 		const streamingBehavior = body.streamingBehavior === "steer" ? "steer" : body.streamingBehavior === "followUp" ? "followUp" : void 0;
 		const clientPendingId = normalizeClientPendingId(body.pendingId);
-		return await this.runSerializedPromptRequest(activeEntry, async () => {
-			if (requestedThinkingLevel && activeEntry.session.thinkingLevel !== requestedThinkingLevel) activeEntry.session.setThinkingLevel(requestedThinkingLevel);
-			const promptOptions = images.length > 0 ? { images } : void 0;
-			const promotedDraft = this.isDraftEntry(activeEntry);
-			const isAlreadyStreaming = this.getEntryStreamingState(activeEntry);
-			if (clientPendingId && activeEntry.canceledPendingUserMessageIds.delete(clientPendingId)) {
-				await this.broadcastEntryState(activeEntry);
-				return {
-					ok: true,
-					queued: isAlreadyStreaming,
-					pendingId: clientPendingId,
-					canceled: true
-				};
-			}
-			if (!this.getSessionFirstMessage(activeEntry)) {
-				activeEntry.firstMessageHint = message.trim();
-				this.startAutoSessionNaming(activeEntry, message.trim(), images.length);
-			}
-			if (isAlreadyStreaming) {
-				const queuedStreamingBehavior = streamingBehavior ?? "steer";
-				const pendingMessage = createPendingUserMessage(message, images, queuedStreamingBehavior, clientPendingId);
-				this.markSessionUserMessage(activeEntry);
-				activeEntry.canceledPendingUserMessageIds.delete(pendingMessage.pendingId);
-				activeEntry.pendingUserMessages.push(pendingMessage);
-				await this.broadcastEntryState(activeEntry);
-				try {
-					await activeEntry.session.prompt(message, {
-						...promptOptions,
-						streamingBehavior: queuedStreamingBehavior
-					});
-				} catch (error) {
-					activeEntry.pendingUserMessages = activeEntry.pendingUserMessages.filter((entry) => entry.pendingId !== pendingMessage.pendingId);
+		const clientRequestId = normalizeClientPromptRequestId(body.clientRequestId);
+		const executePromptRequest = async () => {
+			return await this.runSerializedPromptRequest(activeEntry, async () => {
+				if (requestedThinkingLevel && activeEntry.session.thinkingLevel !== requestedThinkingLevel) activeEntry.session.setThinkingLevel(requestedThinkingLevel);
+				const promptOptions = images.length > 0 ? { images } : void 0;
+				const promotedDraft = this.isDraftEntry(activeEntry);
+				const isAlreadyStreaming = this.getEntryStreamingState(activeEntry);
+				const isCompactingOnly = !isAlreadyStreaming && Boolean(this.getEntryCompactingState(activeEntry) || activeEntry.session.isCompacting);
+				const isAlreadyBusy = isAlreadyStreaming || isCompactingOnly;
+				if (clientPendingId && activeEntry.canceledPendingUserMessageIds.delete(clientPendingId)) {
+					await this.broadcastEntryState(activeEntry);
+					return {
+						ok: true,
+						queued: isAlreadyBusy,
+						pendingId: clientPendingId,
+						canceled: true
+					};
+				}
+				if (!this.getSessionFirstMessage(activeEntry)) {
+					activeEntry.firstMessageHint = message.trim();
+					this.startAutoSessionNaming(activeEntry, message.trim(), images.length);
+				}
+				if (activeEntry.uiState.editorText) activeEntry.uiState.editorText = "";
+				if (isAlreadyBusy) {
+					const queuedStreamingBehavior = streamingBehavior ?? "steer";
+					const pendingMessage = createPendingUserMessage(message, images, queuedStreamingBehavior, clientPendingId);
+					this.markSessionUserMessage(activeEntry);
+					activeEntry.canceledPendingUserMessageIds.delete(pendingMessage.pendingId);
+					activeEntry.pendingUserMessages.push(pendingMessage);
+					activeEntry.pendingUserMessages = sortPendingUserMessages(activeEntry.pendingUserMessages);
+					await this.broadcastEntryState(activeEntry);
+					if (isCompactingOnly) {
+						await this.broadcastSessionsAll();
+						return {
+							ok: true,
+							queued: true,
+							pendingId: pendingMessage.pendingId
+						};
+					}
+					try {
+						await activeEntry.session.prompt(message, {
+							...promptOptions,
+							streamingBehavior: queuedStreamingBehavior
+						});
+					} catch (error) {
+						activeEntry.pendingUserMessages = activeEntry.pendingUserMessages.filter((entry) => entry.pendingId !== pendingMessage.pendingId);
+						this.reconcilePendingUserMessages(activeEntry);
+						await this.broadcastEntryState(activeEntry);
+						throw error;
+					}
 					this.reconcilePendingUserMessages(activeEntry);
 					await this.broadcastEntryState(activeEntry);
-					throw error;
+					await this.broadcastSessionsAll();
+					return {
+						ok: true,
+						queued: true,
+						pendingId: pendingMessage.pendingId
+					};
+				}
+				activeEntry.streamingState = true;
+				this.markSessionUserMessage(activeEntry);
+				if (promotedDraft) {
+					activeEntry.draft = false;
+					if (context.draftKey === activeEntry.key) context.draftKey = void 0;
+					await this.broadcastEntryState(activeEntry);
+					await this.broadcastSessionsAll();
 				}
-				this.reconcilePendingUserMessages(activeEntry);
-				await this.broadcastEntryState(activeEntry);
-				await this.broadcastSessionsAll();
-				return {
-					ok: true,
-					queued: true,
-					pendingId: pendingMessage.pendingId
-				};
-			}
-			activeEntry.streamingState = true;
-			this.markSessionUserMessage(activeEntry);
-			if (promotedDraft) {
-				activeEntry.draft = false;
-				if (context.draftKey === activeEntry.key) context.draftKey = void 0;
-				await this.broadcastEntryState(activeEntry);
-				await this.broadcastSessionsAll();
-			}
-			this.broadcastToViewers(activeEntry.key, {
-				type: "user_message",
-				message,
-				images,
-				queued: false
-			});
-			let promptPreflightComplete;
-			let promptPreflightSettled = false;
-			const promptPreflight = new Promise((resolve) => {
-				promptPreflightComplete = resolve;
-			});
-			const settlePromptPreflight = () => {
-				if (promptPreflightSettled) return;
-				promptPreflightSettled = true;
-				promptPreflightComplete?.();
-			};
-			const promptPromise = activeEntry.session.prompt(message, {
-				...promptOptions,
-				preflightResult: settlePromptPreflight
-			});
-			const finishPromptIfIdle = async () => {
-				if (!activeEntry.streamingState || activeEntry.session.isStreaming) return;
-				activeEntry.streamingState = false;
-				this.reconcilePendingUserMessages(activeEntry);
-				await this.broadcastEntryState(activeEntry);
-				await this.broadcastSessionsAll();
-			};
-			promptPromise.then(() => {}).catch(async (error) => {
-				await finishPromptIfIdle();
-				console.error("[pico] prompt error", error);
 				this.broadcastToViewers(activeEntry.key, {
-					type: "request_error",
-					scope: "prompt",
+					type: "user_message",
 					message,
-					error: formatError(error)
+					images,
+					queued: false
 				});
-			}).finally(() => {
-				settlePromptPreflight();
+				let promptPreflightComplete;
+				let promptPreflightSettled = false;
+				const promptPreflight = new Promise((resolve) => {
+					promptPreflightComplete = resolve;
+				});
+				const settlePromptPreflight = () => {
+					if (promptPreflightSettled) return;
+					promptPreflightSettled = true;
+					promptPreflightComplete?.();
+				};
+				const promptPromise = activeEntry.session.prompt(message, {
+					...promptOptions,
+					preflightResult: settlePromptPreflight
+				});
+				const finishPromptIfIdle = async () => {
+					if (!activeEntry.streamingState || activeEntry.session.isStreaming) return;
+					activeEntry.streamingState = false;
+					this.reconcilePendingUserMessages(activeEntry);
+					await this.broadcastEntryState(activeEntry);
+					await this.broadcastSessionsAll();
+				};
+				promptPromise.then(() => {}).catch(async (error) => {
+					await finishPromptIfIdle();
+					console.error("[pico] prompt error", error);
+					this.broadcastToViewers(activeEntry.key, {
+						type: "request_error",
+						scope: "prompt",
+						message,
+						error: formatError(error)
+					});
+				}).finally(() => {
+					settlePromptPreflight();
+				});
+				await promptPreflight;
+				return {
+					ok: true,
+					queued: false
+				};
 			});
-			await promptPreflight;
-			return {
-				ok: true,
-				queued: false
-			};
+		};
+		if (!clientRequestId) return await executePromptRequest();
+		const existingRequest = activeEntry.promptRequestRecords.get(clientRequestId);
+		if (existingRequest) return await existingRequest.promise;
+		this.prunePromptRequestRecords(activeEntry);
+		const promptPromise = executePromptRequest().catch((error) => {
+			activeEntry.promptRequestRecords.delete(clientRequestId);
+			throw error;
+		});
+		activeEntry.promptRequestRecords.set(clientRequestId, {
+			createdAt: Date.now(),
+			promise: promptPromise
 		});
+		return await promptPromise;
 	}
 	async reorderPendingMessages(request, body) {
 		const { activeEntry } = await this.resolveRequest(request);
@@ -5850,6 +6754,7 @@ var PicoRuntime = class {
 			throw new Error("Pending prompt not found");
 		}
 		activeEntry.canceledPendingUserMessageIds.delete(pendingId);
+		activeEntry.pausedPendingUserMessageIds.delete(pendingId);
 		pendingMessages.splice(pendingIndex, 1);
 		await this.replacePendingUserMessages(activeEntry, pendingMessages);
 		return {
@@ -5857,13 +6762,42 @@ var PicoRuntime = class {
 			pendingId
 		};
 	}
+	async startPendingQueue(request) {
+		const { activeEntry } = await this.resolveRequest(request);
+		if (activeEntry.pendingUserMessages.length === 0) return {
+			ok: true,
+			pendingMessages: []
+		};
+		if (this.getEntryStreamingState(activeEntry) || activeEntry.session.isStreaming || this.getEntryCompactingState(activeEntry) || activeEntry.session.isCompacting) throw new Error("Wait for the current response to finish before starting the queue.");
+		activeEntry.pausedPendingUserMessageIds.clear();
+		await this.drainPendingUserMessagesWhenIdle(activeEntry);
+		return {
+			ok: true,
+			pendingMessages: activeEntry.pendingUserMessages.map((message) => ({
+				pendingId: message.pendingId,
+				text: message.text,
+				images: message.images,
+				streamingBehavior: message.streamingBehavior
+			}))
+		};
+	}
 	async abort(request) {
 		const { activeEntry } = await this.resolveRequest(request);
 		activeEntry.doneNotificationSuppressed = true;
 		this.clearPendingSessionDone(activeEntry);
+		const pendingMessages = activeEntry.pendingUserMessages.map((message) => clonePendingUserMessage(message));
+		if (pendingMessages.length > 0) for (const message of pendingMessages) activeEntry.pausedPendingUserMessageIds.add(message.pendingId);
+		activeEntry.pendingQueueMutation = true;
+		try {
+			activeEntry.session.clearQueue?.();
+			activeEntry.pendingUserMessages = pendingMessages;
+		} finally {
+			activeEntry.pendingQueueMutation = false;
+		}
 		activeEntry.session.abortCompaction?.();
 		activeEntry.session.abortBranchSummary?.();
 		await activeEntry.session.abort();
+		await this.broadcastEntryState(activeEntry);
 		return { ok: true };
 	}
 	async createNewSession(request, body) {
@@ -5882,7 +6816,9 @@ var PicoRuntime = class {
 		await this.activateContextSession(context, nextEntry);
 		return {
 			ok: true,
-			draft: true
+			draft: true,
+			sessionKey: nextEntry.key,
+			cwd: nextEntry.cwd
 		};
 	}
 	async selectSession(request) {
@@ -5972,7 +6908,8 @@ var PicoRuntime = class {
 		return {
 			ok: true,
 			model: serializeModel(activeEntry.session.model),
-			thinkingLevel: activeEntry.session.thinkingLevel
+			thinkingLevel: activeEntry.session.thinkingLevel,
+			availableThinkingLevels: activeEntry.session.getAvailableThinkingLevels()
 		};
 	}
 	async setThinking(request, body) {
@@ -6140,13 +7077,18 @@ var PicoRuntime = class {
 		const { context, activeEntry } = await this.resolveRequest(request);
 		const entryId = typeof body.entryId === "string" ? body.entryId.trim() : "";
 		if (!entryId) throw new Error("entryId is required");
+		const forkPosition = body.position === "at" ? "at" : "before";
+		const isEditFork = forkPosition === "before";
 		const currentManager = activeEntry.session.sessionManager;
 		const selectedEntry = currentManager.getEntry?.(entryId);
 		const selectedParentId = typeof selectedEntry?.parentId === "string" ? selectedEntry.parentId : void 0;
-		if (!selectedEntry || selectedEntry.type !== "message" || selectedEntry.message?.role !== "user") throw new Error("Invalid entry ID for forking");
-		const selectedText = extractMessageText(selectedEntry.message);
+		const selectedRole = typeof selectedEntry?.message?.role === "string" ? selectedEntry.message.role : "";
+		if (!selectedEntry || selectedEntry.type !== "message" || (isEditFork ? selectedRole !== "user" : selectedRole !== "assistant")) throw new Error("Invalid entry ID for forking");
+		const selectedText = isEditFork ? extractMessageText(selectedEntry.message) : "";
 		const previousSessionFile = activeEntry.session.sessionFile;
 		const sourceSessionDir = currentManager.getSessionDir?.();
+		const forkLeafId = isEditFork ? selectedParentId : entryId;
+		const draft = isEditFork ? !selectedParentId : false;
 		let nextEntry;
 		if (currentManager.isPersisted?.()) {
 			const sdk = await this.getSdk();
@@ -6155,7 +7097,7 @@ var PicoRuntime = class {
 			const sourceManager = sdk.SessionManager.open(currentSessionFile, sourceSessionDir, activeEntry.cwd);
 			const runtime = await this.createSessionRuntime(sourceManager);
 			try {
-				const result = await runtime.fork(entryId, { position: "before" });
+				const result = await runtime.fork(entryId, { position: forkPosition });
 				if (result.cancelled) {
 					await runtime.dispose();
 					return {
@@ -6163,8 +7105,8 @@ var PicoRuntime = class {
 						cancelled: true
 					};
 				}
-				nextEntry = await this.createSessionEntryFromRuntime(runtime, { draft: !selectedParentId });
-				if (result.selectedText) nextEntry.uiState.editorText = result.selectedText;
+				nextEntry = await this.createSessionEntryFromRuntime(runtime, { draft });
+				if (isEditFork && result.selectedText) nextEntry.uiState.editorText = result.selectedText;
 			} catch (error) {
 				await runtime.dispose().catch(() => {});
 				throw error;
@@ -6175,30 +7117,102 @@ var PicoRuntime = class {
 				reason: "fork",
 				previousSessionFile
 			};
-			const sessionManager = await this.createForkedInMemorySessionManager(currentManager, selectedParentId, previousSessionFile);
+			const sessionManager = await this.createForkedInMemorySessionManager(currentManager, forkLeafId, previousSessionFile);
 			nextEntry = await this.createSessionEntry(sessionManager, {
-				draft: !selectedParentId,
+				draft,
 				sessionStartEvent
 			});
 		}
-		if (!nextEntry.uiState.editorText) nextEntry.uiState.editorText = selectedText;
+		if (isEditFork && !nextEntry.uiState.editorText) nextEntry.uiState.editorText = selectedText;
 		const baseName = cleanupSessionNameCandidate(activeEntry.session.sessionName) || getSessionListTitle({
 			name: activeEntry.session.sessionName,
 			firstMessage: this.getSessionFirstMessage(activeEntry)
 		});
-		if (baseName) nextEntry.session.setSessionName(clampSessionNameLength(`${baseName} fork`));
-		nextEntry.uiState.editorText = selectedText;
-		if (!selectedParentId) nextEntry.firstMessageHint = selectedText;
+		if (baseName) nextEntry.session.setSessionName(clampSessionNameLength(`${baseName} ${isEditFork ? "fork" : "branch"}`));
+		if (isEditFork) {
+			nextEntry.uiState.editorText = selectedText;
+			if (!selectedParentId) nextEntry.firstMessageHint = selectedText;
+		} else nextEntry.uiState.editorText = "";
 		this.touchSessionEntry(nextEntry);
 		await this.activateContextSession(context, nextEntry);
 		await this.broadcastSessionsAll();
 		return {
 			ok: true,
 			draft: this.isDraftEntry(nextEntry),
+			sessionKey: nextEntry.key,
 			sessionId: nextEntry.session.sessionId,
 			sessionFile: nextEntry.session.sessionFile
 		};
 	}
+	async generateSessionName(request, body) {
+		const sessionPath = typeof body.path === "string" ? body.path.trim() : "";
+		let source;
+		let temporaryRuntime;
+		try {
+			if (sessionPath) {
+				const targetEntry = this.sessionEntries.get(sessionPath);
+				if (targetEntry) {
+					const firstPrompt = this.getSessionFirstPromptForNaming(targetEntry);
+					if (firstPrompt) source = {
+						cwd: targetEntry.cwd,
+						model: targetEntry.session.model,
+						modelRegistry: targetEntry.services.modelRegistry,
+						firstPrompt
+					};
+				} else {
+					const sessionManager = (await this.getSdk()).SessionManager.open(sessionPath);
+					this.restoreSessionTreeLeafOverride(sessionManager, sessionPath);
+					temporaryRuntime = await this.createSessionRuntime(sessionManager);
+					const firstPrompt = this.getFirstPromptForNamingFromMessages(temporaryRuntime.session.messages);
+					if (firstPrompt) source = {
+						cwd: temporaryRuntime.cwd,
+						model: temporaryRuntime.session.model,
+						modelRegistry: temporaryRuntime.services.modelRegistry,
+						firstPrompt
+					};
+				}
+			} else {
+				const { activeEntry } = await this.resolveRequest(request);
+				const firstPrompt = this.getSessionFirstPromptForNaming(activeEntry);
+				if (firstPrompt) source = {
+					cwd: activeEntry.cwd,
+					model: activeEntry.session.model,
+					modelRegistry: activeEntry.services.modelRegistry,
+					firstPrompt
+				};
+			}
+			if (!source) throw new Error("Session has no user message to name from");
+			const heuristic = deriveHeuristicSessionNameAttempt(source.firstPrompt.text, source.firstPrompt.imageCount);
+			const generated = await generateSessionNameWithLlm({
+				cwd: source.cwd,
+				model: source.model,
+				services: { modelRegistry: source.modelRegistry }
+			}, source.firstPrompt.text, source.firstPrompt.imageCount);
+			if (generated.name) return {
+				ok: true,
+				name: clampSessionNameLength(generated.name),
+				source: "llm"
+			};
+			if (heuristic.name) return {
+				ok: true,
+				name: clampSessionNameLength(heuristic.name),
+				source: "heuristic",
+				reason: generated.reason || heuristic.reason
+			};
+			const fallbackName = cleanupSessionNameCandidate(normalizeSessionListTitle(source.firstPrompt.text, SESSION_NAME_MAX_LENGTH));
+			if (fallbackName) return {
+				ok: true,
+				name: clampSessionNameLength(fallbackName),
+				source: "heuristic",
+				reason: generated.reason || heuristic.reason
+			};
+			throw new Error(generated.reason || heuristic.reason || "Could not generate a session name from the first user message");
+		} finally {
+			await temporaryRuntime?.dispose().catch((error) => {
+				console.error("[pico] temporary session dispose error:", error);
+			});
+		}
+	}
 	async renameSession(body) {
 		const sessionPath = typeof body.path === "string" ? body.path : "";
 		const nextName = typeof body.name === "string" ? body.name.trim() : "";
@@ -6438,6 +7452,7 @@ var PicoRuntime = class {
 	}
 	async getAuthProviders(request) {
 		const { activeEntry } = await this.resolveRequest(request);
+		this.refreshModelRegistries();
 		const modelRegistry = activeEntry.services.modelRegistry;
 		const authStorage = this.requireAuthStorage(activeEntry);
 		const oauthProviders = authStorage.getOAuthProviders();
@@ -6482,7 +7497,8 @@ var PicoRuntime = class {
 					...authStatus(providerId),
 					configured: true
 				};
-			}).sort((left, right) => left.name.localeCompare(right.name))
+			}).sort((left, right) => left.name.localeCompare(right.name)),
+			availableModels: this.listAvailableModels(activeEntry)
 		};
 	}
 	async saveProviderApiKey(request, body) {
@@ -6651,11 +7667,86 @@ var PicoRuntime = class {
 			activeEntry.compactingState = false;
 			await this.broadcastEntryState(activeEntry);
 			await this.broadcastSessionsAll();
+			this.drainPendingUserMessagesWhenIdle(activeEntry);
 		}
 	}
 	async resolveUiRequest(id, body) {
 		return resolvePendingUiRequest(this.pendingUiRequests, id, body);
 	}
+	async createTerminal(request, body) {
+		const { context, activeEntry } = await this.resolveRequest(request);
+		const cwd = this.getBaseCwd(activeEntry, context);
+		return {
+			ok: true,
+			...await this.terminalManager.createTerminal({
+				clientKey: body.clientKey,
+				cols: body.cols,
+				cwd,
+				rows: body.rows,
+				scopeKey: this.getTerminalScopeKey(activeEntry, context)
+			})
+		};
+	}
+	async createTerminalEventsResponse(request, id) {
+		const { context, activeEntry } = await this.resolveRequest(request);
+		const lastSeq = parsePositiveInteger(request.headers.get("last-event-id") || new URL(request.url).searchParams.get("lastSeq"));
+		return this.terminalManager.createEventsResponse(id, this.getTerminalScopeKey(activeEntry, context), request.signal, lastSeq);
+	}
+	async createTerminalWebSocketContext(request) {
+		try {
+			const id = terminalWebSocketIdFromRequest(request);
+			const { context, activeEntry } = await this.resolveRequest(request);
+			const scopeKey = this.getTerminalScopeKey(activeEntry, context);
+			const lastSeq = parsePositiveInteger(request.headers.get("last-event-id") || new URL(request.url).searchParams.get("lastSeq"));
+			this.terminalManager.validateTerminal(id, scopeKey);
+			return {
+				terminalId: id,
+				terminalLastSeq: lastSeq,
+				terminalScopeKey: scopeKey
+			};
+		} catch (error) {
+			if (error instanceof Response) throw error;
+			throw new Response(safeErrorMessage(error), { status: 400 });
+		}
+	}
+	openTerminalWebSocket(peer) {
+		const context = terminalWebSocketContextFromPeer(peer);
+		const cleanup = this.terminalManager.connectWebSocket({
+			id: context.terminalId,
+			lastSeq: context.terminalLastSeq,
+			peer,
+			scopeKey: context.terminalScopeKey
+		});
+		peer.context.terminalCleanup = cleanup;
+	}
+	handleTerminalWebSocketMessage(peer, message) {
+		const context = terminalWebSocketContextFromPeer(peer);
+		this.terminalManager.handleWebSocketMessage({
+			id: context.terminalId,
+			message,
+			peer,
+			scopeKey: context.terminalScopeKey
+		});
+	}
+	closeTerminalWebSocket(peer) {
+		terminalWebSocketCleanupFromPeer(peer)?.();
+		delete peer.context.terminalCleanup;
+	}
+	async writeTerminalInput(request, id, body) {
+		const { context, activeEntry } = await this.resolveRequest(request);
+		this.terminalManager.writeTerminal(id, this.getTerminalScopeKey(activeEntry, context), body.data, body.inputSeq);
+		return { ok: true };
+	}
+	async resizeTerminal(request, id, body) {
+		const { context, activeEntry } = await this.resolveRequest(request);
+		this.terminalManager.resizeTerminal(id, this.getTerminalScopeKey(activeEntry, context), body);
+		return { ok: true };
+	}
+	async closeTerminal(request, id) {
+		const { context, activeEntry } = await this.resolveRequest(request);
+		await this.terminalManager.closeTerminal(id, this.getTerminalScopeKey(activeEntry, context));
+		return { ok: true };
+	}
 	async highlightCode(code, language) {
 		const text = typeof code === "string" ? code : "";
 		try {
@@ -6713,6 +7804,7 @@ var PicoRuntime = class {
 			pending.resolve({ cancelled: true });
 		} catch {}
 		this.pendingUiRequests.clear();
+		this.terminalManager.dispose();
 		await Promise.all([...this.sessionEntries.values()].map((entry) => this.disposeSessionEntry(entry)));
 	}
 };
@@ -6720,7 +7812,7 @@ function getPicoRuntime() {
 	globalThis.__picoRuntime ??= new PicoRuntime();
 	return globalThis.__picoRuntime;
 }
-var Route$52 = createFileRoute("/events")({ server: { handlers: { GET: ({ request }) => getPicoRuntime().createEventsResponse(request) } } });
+var Route$60 = createFileRoute("/events")({ server: { handlers: { GET: ({ request }) => getPicoRuntime().createEventsResponse(request) } } });
 function jsonResponse(data, init = 200) {
 	const responseInit = typeof init === "number" ? { status: init } : init;
 	const headers = new Headers(responseInit.headers);
@@ -6756,7 +7848,7 @@ function routeErrorResponse(error, fallbackMessage) {
 async function readRequestJson(request) {
 	return await request.json().catch(() => ({}));
 }
-var Route$51 = createFileRoute("/api/thinking")({ server: { handlers: { POST: async ({ request }) => {
+var Route$59 = createFileRoute("/api/thinking")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().setThinking(request, body));
@@ -6764,7 +7856,15 @@ var Route$51 = createFileRoute("/api/thinking")({ server: { handlers: { POST: as
 		return routeErrorResponse(error, "Failed to update thinking level");
 	}
 } } } });
-var Route$50 = createFileRoute("/api/slash-command")({ server: { handlers: { POST: async ({ request }) => {
+var Route$58 = createFileRoute("/api/terminal")({ server: { handlers: { POST: async ({ request }) => {
+	try {
+		const body = await readRequestJson(request);
+		return jsonResponse(await getPicoRuntime().createTerminal(request, body));
+	} catch (error) {
+		return routeErrorResponse(error, "Failed to create terminal");
+	}
+} } } });
+var Route$57 = createFileRoute("/api/slash-command")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().runSlashCommand(request, body));
@@ -6772,7 +7872,7 @@ var Route$50 = createFileRoute("/api/slash-command")({ server: { handlers: { POS
 		return routeErrorResponse(error, "Failed to run slash command");
 	}
 } } } });
-var Route$49 = createFileRoute("/api/provider-usage")({ server: { handlers: { GET: async ({ request }) => {
+var Route$56 = createFileRoute("/api/provider-usage")({ server: { handlers: { GET: async ({ request }) => {
 	const provider = new URL(request.url).searchParams.get("provider") || void 0;
 	try {
 		return jsonResponse({
@@ -6783,7 +7883,7 @@ var Route$49 = createFileRoute("/api/provider-usage")({ server: { handlers: { GE
 		return routeErrorResponse(error, "Failed to read provider usage");
 	}
 } } } });
-var Route$48 = createFileRoute("/api/prompt")({ server: { handlers: { POST: async ({ request }) => {
+var Route$55 = createFileRoute("/api/prompt")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().prompt(request, body));
@@ -7338,7 +8438,7 @@ async function listFileReferenceEntries(query, baseCwd, { isQuotedPrefix = false
 		};
 	});
 }
-var Route$47 = createFileRoute("/api/path-completions")({ server: { handlers: { POST: async ({ request }) => {
+var Route$54 = createFileRoute("/api/path-completions")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const { context, activeEntry } = await getPicoRuntime().resolveRequest(request);
@@ -7354,7 +8454,7 @@ var Route$47 = createFileRoute("/api/path-completions")({ server: { handlers: {
 		return routeErrorResponse(error, "Failed to list path completions");
 	}
 } } } });
-var Route$46 = createFileRoute("/api/model")({ server: { handlers: { POST: async ({ request }) => {
+var Route$53 = createFileRoute("/api/model")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().setModel(request, body));
@@ -7362,7 +8462,7 @@ var Route$46 = createFileRoute("/api/model")({ server: { handlers: { POST: async
 		return routeErrorResponse(error, "Failed to update model");
 	}
 } } } });
-var Route$45 = createFileRoute("/api/highlight")({ server: { handlers: { POST: async ({ request }) => {
+var Route$52 = createFileRoute("/api/highlight")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().highlightCode(body.code, body.language));
@@ -7370,7 +8470,7 @@ var Route$45 = createFileRoute("/api/highlight")({ server: { handlers: { POST: a
 		return routeErrorResponse(error, "Failed to highlight code");
 	}
 } } } });
-var Route$44 = createFileRoute("/api/git-status")({ server: { handlers: { GET: async ({ request }) => {
+var Route$51 = createFileRoute("/api/git-status")({ server: { handlers: { GET: async ({ request }) => {
 	const requestedCwd = new URL(request.url).searchParams.get("cwd") || "";
 	if (!requestedCwd.trim()) return errorResponse("cwd is required");
 	try {
@@ -7385,10 +8485,12 @@ var Route$44 = createFileRoute("/api/git-status")({ server: { handlers: { GET: a
 		return routeErrorResponse(error, "Failed to read git status");
 	}
 } } } });
-var Route$43 = createFileRoute("/api/git-stage")({ server: { handlers: { POST: async ({ request }) => {
+var Route$50 = createFileRoute("/api/git-stage")({ server: { handlers: { POST: async ({ request }) => {
+	let errorFallback = "Failed to stage changes";
 	try {
 		const body = await readRequestJson(request);
 		const action = typeof body.action === "string" ? body.action : "";
+		if (action === "unstage" || action === "unstage-all") errorFallback = "Failed to unstage changes";
 		const all = body.all === true;
 		const requestedCwd = typeof body.cwd === "string" ? body.cwd : "";
 		const path = typeof body.path === "string" ? body.path : "";
@@ -7397,7 +8499,7 @@ var Route$43 = createFileRoute("/api/git-stage")({ server: { handlers: { POST: a
 		if (!path.trim() && !all && action !== "stage-all" && action !== "unstage-all") throw new Error("file path is required");
 		const { context, activeEntry } = await getPicoRuntime().resolveRequest(request);
 		const cwd = await resolveDirectoryPath(requestedCwd, getPicoRuntime().getBaseCwd(activeEntry, context));
-		const result = action === "unstage-all" ? await unstageDirectoryGitAll(cwd) : all || action === "stage-all" ? await stageDirectoryGitAll(cwd) : await stageDirectoryGitFile(cwd, path, previousPath || void 0);
+		const result = action === "unstage-all" ? await unstageDirectoryGitAll(cwd) : action === "unstage" ? await unstageDirectoryGitFile(cwd, path, previousPath || void 0) : all || action === "stage-all" ? await stageDirectoryGitAll(cwd) : await stageDirectoryGitFile(cwd, path, previousPath || void 0);
 		return jsonResponse({
 			ok: true,
 			cwd,
@@ -7405,10 +8507,10 @@ var Route$43 = createFileRoute("/api/git-stage")({ server: { handlers: { POST: a
 			stderr: result.stderr
 		});
 	} catch (error) {
-		return routeErrorResponse(error, "Failed to stage changes");
+		return routeErrorResponse(error, errorFallback);
 	}
 } } } });
-var Route$42 = createFileRoute("/api/git-review")({ server: { handlers: { GET: async ({ request }) => {
+var Route$49 = createFileRoute("/api/git-review")({ server: { handlers: { GET: async ({ request }) => {
 	const url = new URL(request.url);
 	const requestedCwd = url.searchParams.get("cwd") || "";
 	const requestedPath = url.searchParams.get("path") || "";
@@ -7431,7 +8533,7 @@ var Route$42 = createFileRoute("/api/git-review")({ server: { handlers: { GET: a
 		return routeErrorResponse(error, "Failed to read git review file");
 	}
 } } } });
-var Route$41 = createFileRoute("/api/git-push")({ server: { handlers: { POST: async ({ request }) => {
+var Route$48 = createFileRoute("/api/git-push")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const requestedCwd = typeof body.cwd === "string" ? body.cwd : "";
@@ -7450,7 +8552,7 @@ var Route$41 = createFileRoute("/api/git-push")({ server: { handlers: { POST: as
 		return routeErrorResponse(error, "Failed to push changes");
 	}
 } } } });
-var Route$40 = createFileRoute("/api/git-pull")({ server: { handlers: { POST: async ({ request }) => {
+var Route$47 = createFileRoute("/api/git-pull")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const requestedCwd = typeof body.cwd === "string" ? body.cwd : "";
@@ -7468,7 +8570,7 @@ var Route$40 = createFileRoute("/api/git-pull")({ server: { handlers: { POST: as
 		return routeErrorResponse(error, "Failed to pull changes");
 	}
 } } } });
-var Route$39 = createFileRoute("/api/git-discard")({ server: { handlers: { POST: async ({ request }) => {
+var Route$46 = createFileRoute("/api/git-discard")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const action = typeof body.action === "string" ? body.action : "";
@@ -7492,7 +8594,7 @@ var Route$39 = createFileRoute("/api/git-discard")({ server: { handlers: { POST:
 		return routeErrorResponse(error, "Failed to discard changes");
 	}
 } } } });
-var Route$38 = createFileRoute("/api/git-diff")({ server: { handlers: { GET: async ({ request }) => {
+var Route$45 = createFileRoute("/api/git-diff")({ server: { handlers: { GET: async ({ request }) => {
 	const url = new URL(request.url);
 	const requestedCwd = url.searchParams.get("cwd") || "";
 	const requestedPath = url.searchParams.get("path") || "";
@@ -7512,7 +8614,7 @@ var Route$38 = createFileRoute("/api/git-diff")({ server: { handlers: { GET: asy
 		return routeErrorResponse(error, "Failed to read git diff");
 	}
 } } } });
-var Route$37 = createFileRoute("/api/git-commit-remote-url")({ server: { handlers: { GET: async ({ request }) => {
+var Route$44 = createFileRoute("/api/git-commit-remote-url")({ server: { handlers: { GET: async ({ request }) => {
 	try {
 		const url = new URL(request.url);
 		const requestedCwd = url.searchParams.get("cwd") || "";
@@ -7533,7 +8635,7 @@ var Route$37 = createFileRoute("/api/git-commit-remote-url")({ server: { handler
 		return routeErrorResponse(error, "Failed to read commit remote URL");
 	}
 } } } });
-var Route$36 = createFileRoute("/api/git-commit-message")({ server: { handlers: { POST: async ({ request }) => {
+var Route$43 = createFileRoute("/api/git-commit-message")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const requestedCwd = typeof body.cwd === "string" ? body.cwd : "";
@@ -7552,7 +8654,7 @@ var Route$36 = createFileRoute("/api/git-commit-message")({ server: { handlers:
 		return routeErrorResponse(error, "Failed to generate commit message");
 	}
 } } } });
-var Route$35 = createFileRoute("/api/git-commit-files")({ server: { handlers: { GET: async ({ request }) => {
+var Route$42 = createFileRoute("/api/git-commit-files")({ server: { handlers: { GET: async ({ request }) => {
 	try {
 		const url = new URL(request.url);
 		const requestedCwd = url.searchParams.get("cwd") || "";
@@ -7575,7 +8677,7 @@ function normalizeGitCommitDiffMode(value) {
 	if (value === "head" || value === "previous") return value;
 	return "commit";
 }
-var Route$34 = createFileRoute("/api/git-commit-diff")({ server: { handlers: { GET: async ({ request }) => {
+var Route$41 = createFileRoute("/api/git-commit-diff")({ server: { handlers: { GET: async ({ request }) => {
 	try {
 		const url = new URL(request.url);
 		const requestedCwd = url.searchParams.get("cwd") || "";
@@ -7612,7 +8714,7 @@ var gitCommitActions = new Set([
 	"drop",
 	"squash"
 ]);
-var Route$33 = createFileRoute("/api/git-commit-action")({ server: { handlers: { POST: async ({ request }) => {
+var Route$40 = createFileRoute("/api/git-commit-action")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const requestedCwd = typeof body.cwd === "string" ? body.cwd : "";
@@ -7638,7 +8740,7 @@ var Route$33 = createFileRoute("/api/git-commit-action")({ server: { handlers: {
 		return routeErrorResponse(error, "Failed to run commit action");
 	}
 } } } });
-var Route$32 = createFileRoute("/api/git-commit")({ server: { handlers: { POST: async ({ request }) => {
+var Route$39 = createFileRoute("/api/git-commit")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const requestedCwd = typeof body.cwd === "string" ? body.cwd : "";
@@ -7663,7 +8765,7 @@ var Route$32 = createFileRoute("/api/git-commit")({ server: { handlers: { POST:
 		return routeErrorResponse(error, "Failed to commit changes");
 	}
 } } } });
-var Route$31 = createFileRoute("/api/git-checkout")({ server: { handlers: { POST: async ({ request }) => {
+var Route$38 = createFileRoute("/api/git-checkout")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const requestedCwd = typeof body.cwd === "string" ? body.cwd : "";
@@ -7713,7 +8815,7 @@ function getRuntimeRequestForGitChanges(request, url) {
 		method: request.method
 	});
 }
-var Route$30 = createFileRoute("/api/git-changes")({ server: { handlers: { GET: async ({ request }) => {
+var Route$37 = createFileRoute("/api/git-changes")({ server: { handlers: { GET: async ({ request }) => {
 	const url = new URL(request.url);
 	const requestedCwd = url.searchParams.get("cwd") || "";
 	const gitScope = getGitChangesScope(url);
@@ -7783,7 +8885,7 @@ var Route$30 = createFileRoute("/api/git-changes")({ server: { handlers: { GET:
 		return routeErrorResponse(error, "Failed to read git changes");
 	}
 } } } });
-var Route$29 = createFileRoute("/api/file-completions")({ server: { handlers: { POST: async ({ request }) => {
+var Route$36 = createFileRoute("/api/file-completions")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const { context, activeEntry } = await getPicoRuntime().resolveRequest(request);
@@ -7800,7 +8902,7 @@ var Route$29 = createFileRoute("/api/file-completions")({ server: { handlers: {
 		return routeErrorResponse(error, "Failed to list file completions");
 	}
 } } } });
-var Route$28 = createFileRoute("/api/directory-sessions-indexes")({ server: { handlers: { GET: async ({ request }) => {
+var Route$35 = createFileRoute("/api/directory-sessions-indexes")({ server: { handlers: { GET: async ({ request }) => {
 	const directories = new URL(request.url).searchParams.getAll("directory");
 	if (directories.length === 0) return errorResponse("at least one directory is required");
 	try {
@@ -7809,7 +8911,7 @@ var Route$28 = createFileRoute("/api/directory-sessions-indexes")({ server: { ha
 		return routeErrorResponse(error, "Failed to list directory session indexes");
 	}
 } } } });
-var Route$27 = createFileRoute("/api/directory-sessions-index")({ server: { handlers: { GET: async ({ request }) => {
+var Route$34 = createFileRoute("/api/directory-sessions-index")({ server: { handlers: { GET: async ({ request }) => {
 	const directory = new URL(request.url).searchParams.get("directory") || "";
 	if (!directory.trim()) return errorResponse("directory is required");
 	try {
@@ -7818,7 +8920,7 @@ var Route$27 = createFileRoute("/api/directory-sessions-index")({ server: { hand
 		return routeErrorResponse(error, "Failed to list directory session index");
 	}
 } } } });
-var Route$26 = createFileRoute("/api/directory-sessions")({ server: { handlers: { GET: async ({ request }) => {
+var Route$33 = createFileRoute("/api/directory-sessions")({ server: { handlers: { GET: async ({ request }) => {
 	const url = new URL(request.url);
 	const directory = url.searchParams.get("directory") || "";
 	const offset = Number.parseInt(url.searchParams.get("offset") || "0", 10);
@@ -7833,7 +8935,7 @@ var Route$26 = createFileRoute("/api/directory-sessions")({ server: { handlers:
 		return routeErrorResponse(error, "Failed to list directory sessions");
 	}
 } } } });
-var Route$25 = createFileRoute("/api/directory-search")({ server: { handlers: { POST: async ({ request }) => {
+var Route$32 = createFileRoute("/api/directory-search")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const { context, activeEntry } = await getPicoRuntime().resolveRequest(request);
@@ -7849,14 +8951,14 @@ var Route$25 = createFileRoute("/api/directory-search")({ server: { handlers: {
 		return routeErrorResponse(error, "Failed to search directories");
 	}
 } } } });
-var Route$24 = createFileRoute("/api/abort")({ server: { handlers: { POST: async ({ request }) => {
+var Route$31 = createFileRoute("/api/abort")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		return jsonResponse(await getPicoRuntime().abort(request));
 	} catch (error) {
 		return routeErrorResponse(error, "Failed to abort session");
 	}
 } } } });
-var Route$23 = createFileRoute("/api/ui/$id")({ server: { handlers: { POST: async ({ request, params }) => {
+var Route$30 = createFileRoute("/api/ui/$id")({ server: { handlers: { POST: async ({ request, params }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().resolveUiRequest(params.id, body));
@@ -7864,7 +8966,7 @@ var Route$23 = createFileRoute("/api/ui/$id")({ server: { handlers: { POST: asyn
 		return routeErrorResponse(error, "Failed to resolve UI request");
 	}
 } } } });
-var Route$22 = createFileRoute("/api/settings/hide-thinking")({ server: { handlers: { POST: async ({ request }) => {
+var Route$29 = createFileRoute("/api/settings/hide-thinking")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().setHideThinking(body));
@@ -7872,7 +8974,7 @@ var Route$22 = createFileRoute("/api/settings/hide-thinking")({ server: { handle
 		return routeErrorResponse(error, "Failed to update hide-thinking setting");
 	}
 } } } });
-var Route$21 = createFileRoute("/api/sessions/delete")({ server: { handlers: { POST: async ({ request }) => {
+var Route$28 = createFileRoute("/api/sessions/delete")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().deleteSessions(request, body));
@@ -7880,7 +8982,7 @@ var Route$21 = createFileRoute("/api/sessions/delete")({ server: { handlers: { P
 		return routeErrorResponse(error, "Failed to delete sessions");
 	}
 } } } });
-var Route$20 = createFileRoute("/api/session/tree")({ server: { handlers: {
+var Route$27 = createFileRoute("/api/session/tree")({ server: { handlers: {
 	GET: async ({ request }) => {
 		try {
 			return jsonResponse(await getPicoRuntime().getSessionTreeForRequest(request));
@@ -7897,14 +8999,14 @@ var Route$20 = createFileRoute("/api/session/tree")({ server: { handlers: {
 		}
 	}
 } } });
-var Route$19 = createFileRoute("/api/session/select")({ server: { handlers: { POST: async ({ request }) => {
+var Route$26 = createFileRoute("/api/session/select")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		return jsonResponse(await getPicoRuntime().selectSession(request));
 	} catch (error) {
 		return routeErrorResponse(error, "Failed to select session");
 	}
 } } } });
-var Route$18 = createFileRoute("/api/session/rename")({ server: { handlers: { POST: async ({ request }) => {
+var Route$25 = createFileRoute("/api/session/rename")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().renameSession(body));
@@ -7912,7 +9014,7 @@ var Route$18 = createFileRoute("/api/session/rename")({ server: { handlers: { PO
 		return routeErrorResponse(error, "Failed to rename session");
 	}
 } } } });
-var Route$17 = createFileRoute("/api/session/read-state")({ server: { handlers: { POST: async ({ request }) => {
+var Route$24 = createFileRoute("/api/session/read-state")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().setSessionReadState(request, body));
@@ -7920,7 +9022,7 @@ var Route$17 = createFileRoute("/api/session/read-state")({ server: { handlers:
 		return routeErrorResponse(error, "Failed to update session read state");
 	}
 } } } });
-var Route$16 = createFileRoute("/api/session/new")({ server: { handlers: { POST: async ({ request }) => {
+var Route$23 = createFileRoute("/api/session/new")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().createNewSession(request, body));
@@ -7928,7 +9030,15 @@ var Route$16 = createFileRoute("/api/session/new")({ server: { handlers: { POST:
 		return routeErrorResponse(error, "Failed to create session");
 	}
 } } } });
-var Route$15 = createFileRoute("/api/session/move")({ server: { handlers: { POST: async ({ request }) => {
+var Route$22 = createFileRoute("/api/session/name")({ server: { handlers: { POST: async ({ request }) => {
+	try {
+		const body = await readRequestJson(request);
+		return jsonResponse(await getPicoRuntime().generateSessionName(request, body));
+	} catch (error) {
+		return routeErrorResponse(error, "Failed to generate session name");
+	}
+} } } });
+var Route$21 = createFileRoute("/api/session/move")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().moveSession(request, body));
@@ -7936,7 +9046,7 @@ var Route$15 = createFileRoute("/api/session/move")({ server: { handlers: { POST
 		return routeErrorResponse(error, "Failed to move session");
 	}
 } } } });
-var Route$14 = createFileRoute("/api/session/history")({ server: { handlers: { GET: async ({ request }) => {
+var Route$20 = createFileRoute("/api/session/history")({ server: { handlers: { GET: async ({ request }) => {
 	try {
 		const url = new URL(request.url);
 		const before = Number(url.searchParams.get("before"));
@@ -7949,7 +9059,7 @@ var Route$14 = createFileRoute("/api/session/history")({ server: { handlers: { G
 		return routeErrorResponse(error, "Failed to load session history");
 	}
 } } } });
-var Route$13 = createFileRoute("/api/session/fork")({ server: { handlers: {
+var Route$19 = createFileRoute("/api/session/fork")({ server: { handlers: {
 	GET: async ({ request }) => {
 		try {
 			return jsonResponse(await getPicoRuntime().getForkableMessages(request));
@@ -7966,7 +9076,7 @@ var Route$13 = createFileRoute("/api/session/fork")({ server: { handlers: {
 		}
 	}
 } } });
-var Route$12 = createFileRoute("/api/session/delete")({ server: { handlers: { POST: async ({ request }) => {
+var Route$18 = createFileRoute("/api/session/delete")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().deleteSession(request, body));
@@ -7974,14 +9084,21 @@ var Route$12 = createFileRoute("/api/session/delete")({ server: { handlers: { PO
 		return routeErrorResponse(error, "Failed to delete session");
 	}
 } } } });
-var Route$11 = createFileRoute("/api/session/clone")({ server: { handlers: { POST: async ({ request }) => {
+var Route$17 = createFileRoute("/api/session/clone")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		return jsonResponse(await getPicoRuntime().cloneSession(request));
 	} catch (error) {
 		return routeErrorResponse(error, "Failed to clone session");
 	}
 } } } });
-var Route$10 = createFileRoute("/api/pending-messages/reorder")({ server: { handlers: { POST: async ({ request }) => {
+var Route$16 = createFileRoute("/api/pending-messages/start")({ server: { handlers: { POST: async ({ request }) => {
+	try {
+		return jsonResponse(await getPicoRuntime().startPendingQueue(request));
+	} catch (error) {
+		return routeErrorResponse(error, "Failed to start queued prompts");
+	}
+} } } });
+var Route$15 = createFileRoute("/api/pending-messages/reorder")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().reorderPendingMessages(request, body));
@@ -7989,7 +9106,7 @@ var Route$10 = createFileRoute("/api/pending-messages/reorder")({ server: { hand
 		return routeErrorResponse(error, "Failed to update pending prompts");
 	}
 } } } });
-var Route$9 = createFileRoute("/api/pending-message/remove")({ server: { handlers: { POST: async ({ request }) => {
+var Route$14 = createFileRoute("/api/pending-message/remove")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().removePendingMessage(request, body));
@@ -7997,7 +9114,7 @@ var Route$9 = createFileRoute("/api/pending-message/remove")({ server: { handler
 		return routeErrorResponse(error, "Failed to remove pending prompt");
 	}
 } } } });
-var Route$8 = createFileRoute("/api/files/tree")({ server: { handlers: { GET: async ({ request }) => {
+var Route$13 = createFileRoute("/api/files/tree")({ server: { handlers: { GET: async ({ request }) => {
 	const requestedCwd = new URL(request.url).searchParams.get("cwd") || "";
 	if (!requestedCwd.trim()) return errorResponse("cwd is required");
 	try {
@@ -8014,7 +9131,7 @@ var Route$8 = createFileRoute("/api/files/tree")({ server: { handlers: { GET: as
 		return routeErrorResponse(error, "Failed to read file tree");
 	}
 } } } });
-var Route$7 = createFileRoute("/api/files/read")({ server: { handlers: { GET: async ({ request }) => {
+var Route$12 = createFileRoute("/api/files/read")({ server: { handlers: { GET: async ({ request }) => {
 	const url = new URL(request.url);
 	const requestedCwd = url.searchParams.get("cwd") || "";
 	const requestedPath = url.searchParams.get("path") || "";
@@ -8034,7 +9151,7 @@ var Route$7 = createFileRoute("/api/files/read")({ server: { handlers: { GET: as
 		return routeErrorResponse(error, "Failed to read file");
 	}
 } } } });
-var Route$6 = createFileRoute("/api/directory/resolve")({ server: { handlers: { POST: async ({ request }) => {
+var Route$11 = createFileRoute("/api/directory/resolve")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		const { context, activeEntry } = await getPicoRuntime().resolveRequest(request);
@@ -8046,7 +9163,7 @@ var Route$6 = createFileRoute("/api/directory/resolve")({ server: { handlers: {
 		return routeErrorResponse(error, "Failed to resolve directory");
 	}
 } } } });
-var Route$5 = createFileRoute("/api/directory-sessions/cleanup")({ server: { handlers: { POST: async ({ request }) => {
+var Route$10 = createFileRoute("/api/directory-sessions/cleanup")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().deleteOldDirectorySessions(request, body));
@@ -8054,14 +9171,107 @@ var Route$5 = createFileRoute("/api/directory-sessions/cleanup")({ server: { han
 		return routeErrorResponse(error, "Failed to clean up sessions");
 	}
 } } } });
-var Route$4 = createFileRoute("/api/auth/providers")({ server: { handlers: { GET: async ({ request }) => {
+var API_CONTRACT_VERSION = 1;
+function readPicoPackageVersion() {
+	let currentDir = dirname(fileURLToPath(import.meta.url));
+	while (currentDir && currentDir !== dirname(currentDir)) {
+		const packageJsonPath = join(currentDir, "package.json");
+		if (existsSync(packageJsonPath)) try {
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+			if (packageJson.name === "@alivault/pico" && typeof packageJson.version === "string") return packageJson.version;
+		} catch {
+			return "0.0.0";
+		}
+		currentDir = dirname(currentDir);
+	}
+	return "0.0.0";
+}
+function buildClientManifest() {
+	return {
+		ok: true,
+		name: "@alivault/pico",
+		version: readPicoPackageVersion(),
+		displayName: "Pico",
+		apiContractVersion: API_CONTRACT_VERSION,
+		pairingRequired: false,
+		authentication: { type: "none" },
+		transport: {
+			sse: true,
+			httpsRequired: false,
+			localHttpAllowed: true
+		},
+		capabilities: {
+			events: [
+				"state_sync",
+				"sessions",
+				"session_status",
+				"session_done",
+				"request_error",
+				"extension_error",
+				"extension_ui_request",
+				"user_message",
+				"auto_session_naming_error",
+				"git_changed"
+			],
+			endpoints: [
+				"/events",
+				"/api/prompt",
+				"/api/abort",
+				"/api/session/new",
+				"/api/session/select",
+				"/api/session/fork",
+				"/api/session/name",
+				"/api/session/rename",
+				"/api/session/delete",
+				"/api/session/read-state",
+				"/api/directory-sessions-indexes",
+				"/api/directory/resolve",
+				"/api/directory-search",
+				"/api/path-completions",
+				"/api/model",
+				"/api/thinking",
+				"/api/auth/providers",
+				"/api/auth/api-key",
+				"/api/auth/oauth",
+				"/api/auth/logout",
+				"/api/ui/$id",
+				"/api/settings/hide-thinking",
+				"/api/pending-message/remove",
+				"/api/pending-messages/reorder",
+				"/api/pending-messages/start"
+			],
+			features: [
+				"sse",
+				"session-browser",
+				"conversation",
+				"prompt-composer",
+				"queue-and-steer",
+				"model-selection",
+				"thinking-selection",
+				"provider-authentication",
+				"native-directory-browser",
+				"post-compaction-token-estimates",
+				"edit-user-message-fork",
+				"assistant-message-actions"
+			]
+		}
+	};
+}
+var Route$9 = createFileRoute("/api/client/manifest")({ server: { handlers: { GET: async () => {
+	try {
+		return jsonResponse(buildClientManifest());
+	} catch (error) {
+		return routeErrorResponse(error, "Failed to build client manifest");
+	}
+} } } });
+var Route$8 = createFileRoute("/api/auth/providers")({ server: { handlers: { GET: async ({ request }) => {
 	try {
 		return jsonResponse(await getPicoRuntime().getAuthProviders(request));
 	} catch (error) {
 		return routeErrorResponse(error, "Failed to list auth providers");
 	}
 } } } });
-var Route$3 = createFileRoute("/api/auth/oauth")({ server: { handlers: { POST: async ({ request }) => {
+var Route$7 = createFileRoute("/api/auth/oauth")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().loginProviderOAuth(request, body));
@@ -8069,7 +9279,7 @@ var Route$3 = createFileRoute("/api/auth/oauth")({ server: { handlers: { POST: a
 		return routeErrorResponse(error, "Failed to login to provider");
 	}
 } } } });
-var Route$2 = createFileRoute("/api/auth/logout")({ server: { handlers: { POST: async ({ request }) => {
+var Route$6 = createFileRoute("/api/auth/logout")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().logoutProvider(request, body));
@@ -8077,7 +9287,7 @@ var Route$2 = createFileRoute("/api/auth/logout")({ server: { handlers: { POST:
 		return routeErrorResponse(error, "Failed to logout from provider");
 	}
 } } } });
-var Route$1 = createFileRoute("/api/auth/api-key")({ server: { handlers: { POST: async ({ request }) => {
+var Route$5 = createFileRoute("/api/auth/api-key")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
 		return jsonResponse(await getPicoRuntime().saveProviderApiKey(request, body));
@@ -8085,6 +9295,36 @@ var Route$1 = createFileRoute("/api/auth/api-key")({ server: { handlers: { POST:
 		return routeErrorResponse(error, "Failed to save provider API key");
 	}
 } } } });
+var Route$4 = createFileRoute("/api/terminal/$id/resize")({ server: { handlers: { POST: async ({ request, params }) => {
+	try {
+		const body = await readRequestJson(request);
+		return jsonResponse(await getPicoRuntime().resizeTerminal(request, params.id, body));
+	} catch (error) {
+		return routeErrorResponse(error, "Failed to resize terminal");
+	}
+} } } });
+var Route$3 = createFileRoute("/api/terminal/$id/input")({ server: { handlers: { POST: async ({ request, params }) => {
+	try {
+		const body = await readRequestJson(request);
+		return jsonResponse(await getPicoRuntime().writeTerminalInput(request, params.id, body));
+	} catch (error) {
+		return routeErrorResponse(error, "Failed to write terminal input");
+	}
+} } } });
+var Route$2 = createFileRoute("/api/terminal/$id/events")({ server: { handlers: { GET: async ({ request, params }) => {
+	try {
+		return await getPicoRuntime().createTerminalEventsResponse(request, params.id);
+	} catch (error) {
+		return routeErrorResponse(error, "Failed to connect terminal");
+	}
+} } } });
+var Route$1 = createFileRoute("/api/terminal/$id/close")({ server: { handlers: { POST: async ({ request, params }) => {
+	try {
+		return jsonResponse(await getPicoRuntime().closeTerminal(request, params.id));
+	} catch (error) {
+		return routeErrorResponse(error, "Failed to close terminal");
+	}
+} } } });
 var Route = createFileRoute("/api/session/tree/label")({ server: { handlers: { POST: async ({ request }) => {
 	try {
 		const body = await readRequestJson(request);
@@ -8093,270 +9333,310 @@ var Route = createFileRoute("/api/session/tree/label")({ server: { handlers: { P
 		return routeErrorResponse(error, "Failed to update tree label");
 	}
 } } } });
-var EventsRoute = Route$52.update({
+var EventsRoute = Route$60.update({
 	id: "/events",
 	path: "/events",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var IndexRoute = Route$54.update({
+var IndexRoute = Route$62.update({
 	id: "/",
 	path: "/",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiThinkingRoute = Route$51.update({
+var ApiThinkingRoute = Route$59.update({
 	id: "/api/thinking",
 	path: "/api/thinking",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSlashCommandRoute = Route$50.update({
+var ApiTerminalRoute = Route$58.update({
+	id: "/api/terminal",
+	path: "/api/terminal",
+	getParentRoute: () => Route$61
+});
+var ApiSlashCommandRoute = Route$57.update({
 	id: "/api/slash-command",
 	path: "/api/slash-command",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiProviderUsageRoute = Route$49.update({
+var ApiProviderUsageRoute = Route$56.update({
 	id: "/api/provider-usage",
 	path: "/api/provider-usage",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiPromptRoute = Route$48.update({
+var ApiPromptRoute = Route$55.update({
 	id: "/api/prompt",
 	path: "/api/prompt",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiPathCompletionsRoute = Route$47.update({
+var ApiPathCompletionsRoute = Route$54.update({
 	id: "/api/path-completions",
 	path: "/api/path-completions",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiModelRoute = Route$46.update({
+var ApiModelRoute = Route$53.update({
 	id: "/api/model",
 	path: "/api/model",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiHighlightRoute = Route$45.update({
+var ApiHighlightRoute = Route$52.update({
 	id: "/api/highlight",
 	path: "/api/highlight",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitStatusRoute = Route$44.update({
+var ApiGitStatusRoute = Route$51.update({
 	id: "/api/git-status",
 	path: "/api/git-status",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitStageRoute = Route$43.update({
+var ApiGitStageRoute = Route$50.update({
 	id: "/api/git-stage",
 	path: "/api/git-stage",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitReviewRoute = Route$42.update({
+var ApiGitReviewRoute = Route$49.update({
 	id: "/api/git-review",
 	path: "/api/git-review",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitPushRoute = Route$41.update({
+var ApiGitPushRoute = Route$48.update({
 	id: "/api/git-push",
 	path: "/api/git-push",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitPullRoute = Route$40.update({
+var ApiGitPullRoute = Route$47.update({
 	id: "/api/git-pull",
 	path: "/api/git-pull",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitDiscardRoute = Route$39.update({
+var ApiGitDiscardRoute = Route$46.update({
 	id: "/api/git-discard",
 	path: "/api/git-discard",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitDiffRoute = Route$38.update({
+var ApiGitDiffRoute = Route$45.update({
 	id: "/api/git-diff",
 	path: "/api/git-diff",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitCommitRemoteUrlRoute = Route$37.update({
+var ApiGitCommitRemoteUrlRoute = Route$44.update({
 	id: "/api/git-commit-remote-url",
 	path: "/api/git-commit-remote-url",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitCommitMessageRoute = Route$36.update({
+var ApiGitCommitMessageRoute = Route$43.update({
 	id: "/api/git-commit-message",
 	path: "/api/git-commit-message",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitCommitFilesRoute = Route$35.update({
+var ApiGitCommitFilesRoute = Route$42.update({
 	id: "/api/git-commit-files",
 	path: "/api/git-commit-files",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitCommitDiffRoute = Route$34.update({
+var ApiGitCommitDiffRoute = Route$41.update({
 	id: "/api/git-commit-diff",
 	path: "/api/git-commit-diff",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitCommitActionRoute = Route$33.update({
+var ApiGitCommitActionRoute = Route$40.update({
 	id: "/api/git-commit-action",
 	path: "/api/git-commit-action",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitCommitRoute = Route$32.update({
+var ApiGitCommitRoute = Route$39.update({
 	id: "/api/git-commit",
 	path: "/api/git-commit",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitCheckoutRoute = Route$31.update({
+var ApiGitCheckoutRoute = Route$38.update({
 	id: "/api/git-checkout",
 	path: "/api/git-checkout",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiGitChangesRoute = Route$30.update({
+var ApiGitChangesRoute = Route$37.update({
 	id: "/api/git-changes",
 	path: "/api/git-changes",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiFileCompletionsRoute = Route$29.update({
+var ApiFileCompletionsRoute = Route$36.update({
 	id: "/api/file-completions",
 	path: "/api/file-completions",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiDirectorySessionsIndexesRoute = Route$28.update({
+var ApiDirectorySessionsIndexesRoute = Route$35.update({
 	id: "/api/directory-sessions-indexes",
 	path: "/api/directory-sessions-indexes",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiDirectorySessionsIndexRoute = Route$27.update({
+var ApiDirectorySessionsIndexRoute = Route$34.update({
 	id: "/api/directory-sessions-index",
 	path: "/api/directory-sessions-index",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiDirectorySessionsRoute = Route$26.update({
+var ApiDirectorySessionsRoute = Route$33.update({
 	id: "/api/directory-sessions",
 	path: "/api/directory-sessions",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiDirectorySearchRoute = Route$25.update({
+var ApiDirectorySearchRoute = Route$32.update({
 	id: "/api/directory-search",
 	path: "/api/directory-search",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiAbortRoute = Route$24.update({
+var ApiAbortRoute = Route$31.update({
 	id: "/api/abort",
 	path: "/api/abort",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiUiIdRoute = Route$23.update({
+var ApiUiIdRoute = Route$30.update({
 	id: "/api/ui/$id",
 	path: "/api/ui/$id",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSettingsHideThinkingRoute = Route$22.update({
+var ApiSettingsHideThinkingRoute = Route$29.update({
 	id: "/api/settings/hide-thinking",
 	path: "/api/settings/hide-thinking",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionsDeleteRoute = Route$21.update({
+var ApiSessionsDeleteRoute = Route$28.update({
 	id: "/api/sessions/delete",
 	path: "/api/sessions/delete",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionTreeRoute = Route$20.update({
+var ApiSessionTreeRoute = Route$27.update({
 	id: "/api/session/tree",
 	path: "/api/session/tree",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionSelectRoute = Route$19.update({
+var ApiSessionSelectRoute = Route$26.update({
 	id: "/api/session/select",
 	path: "/api/session/select",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionRenameRoute = Route$18.update({
+var ApiSessionRenameRoute = Route$25.update({
 	id: "/api/session/rename",
 	path: "/api/session/rename",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionReadStateRoute = Route$17.update({
+var ApiSessionReadStateRoute = Route$24.update({
 	id: "/api/session/read-state",
 	path: "/api/session/read-state",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionNewRoute = Route$16.update({
+var ApiSessionNewRoute = Route$23.update({
 	id: "/api/session/new",
 	path: "/api/session/new",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
+});
+var ApiSessionNameRoute = Route$22.update({
+	id: "/api/session/name",
+	path: "/api/session/name",
+	getParentRoute: () => Route$61
 });
-var ApiSessionMoveRoute = Route$15.update({
+var ApiSessionMoveRoute = Route$21.update({
 	id: "/api/session/move",
 	path: "/api/session/move",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionHistoryRoute = Route$14.update({
+var ApiSessionHistoryRoute = Route$20.update({
 	id: "/api/session/history",
 	path: "/api/session/history",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionForkRoute = Route$13.update({
+var ApiSessionForkRoute = Route$19.update({
 	id: "/api/session/fork",
 	path: "/api/session/fork",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionDeleteRoute = Route$12.update({
+var ApiSessionDeleteRoute = Route$18.update({
 	id: "/api/session/delete",
 	path: "/api/session/delete",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiSessionCloneRoute = Route$11.update({
+var ApiSessionCloneRoute = Route$17.update({
 	id: "/api/session/clone",
 	path: "/api/session/clone",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiPendingMessagesReorderRoute = Route$10.update({
+var ApiPendingMessagesStartRoute = Route$16.update({
+	id: "/api/pending-messages/start",
+	path: "/api/pending-messages/start",
+	getParentRoute: () => Route$61
+});
+var ApiPendingMessagesReorderRoute = Route$15.update({
 	id: "/api/pending-messages/reorder",
 	path: "/api/pending-messages/reorder",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiPendingMessageRemoveRoute = Route$9.update({
+var ApiPendingMessageRemoveRoute = Route$14.update({
 	id: "/api/pending-message/remove",
 	path: "/api/pending-message/remove",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiFilesTreeRoute = Route$8.update({
+var ApiFilesTreeRoute = Route$13.update({
 	id: "/api/files/tree",
 	path: "/api/files/tree",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiFilesReadRoute = Route$7.update({
+var ApiFilesReadRoute = Route$12.update({
 	id: "/api/files/read",
 	path: "/api/files/read",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiDirectoryResolveRoute = Route$6.update({
+var ApiDirectoryResolveRoute = Route$11.update({
 	id: "/api/directory/resolve",
 	path: "/api/directory/resolve",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiDirectorySessionsCleanupRoute = Route$5.update({
+var ApiDirectorySessionsCleanupRoute = Route$10.update({
 	id: "/cleanup",
 	path: "/cleanup",
 	getParentRoute: () => ApiDirectorySessionsRoute
 });
-var ApiAuthProvidersRoute = Route$4.update({
+var ApiClientManifestRoute = Route$9.update({
+	id: "/api/client/manifest",
+	path: "/api/client/manifest",
+	getParentRoute: () => Route$61
+});
+var ApiAuthProvidersRoute = Route$8.update({
 	id: "/api/auth/providers",
 	path: "/api/auth/providers",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiAuthOauthRoute = Route$3.update({
+var ApiAuthOauthRoute = Route$7.update({
 	id: "/api/auth/oauth",
 	path: "/api/auth/oauth",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiAuthLogoutRoute = Route$2.update({
+var ApiAuthLogoutRoute = Route$6.update({
 	id: "/api/auth/logout",
 	path: "/api/auth/logout",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
 });
-var ApiAuthApiKeyRoute = Route$1.update({
+var ApiAuthApiKeyRoute = Route$5.update({
 	id: "/api/auth/api-key",
 	path: "/api/auth/api-key",
-	getParentRoute: () => Route$53
+	getParentRoute: () => Route$61
+});
+var ApiTerminalIdResizeRoute = Route$4.update({
+	id: "/$id/resize",
+	path: "/$id/resize",
+	getParentRoute: () => ApiTerminalRoute
+});
+var ApiTerminalIdInputRoute = Route$3.update({
+	id: "/$id/input",
+	path: "/$id/input",
+	getParentRoute: () => ApiTerminalRoute
+});
+var ApiTerminalIdEventsRoute = Route$2.update({
+	id: "/$id/events",
+	path: "/$id/events",
+	getParentRoute: () => ApiTerminalRoute
+});
+var ApiTerminalIdCloseRoute = Route$1.update({
+	id: "/$id/close",
+	path: "/$id/close",
+	getParentRoute: () => ApiTerminalRoute
 });
 var ApiSessionTreeLabelRoute = Route.update({
 	id: "/label",
@@ -8365,6 +9645,13 @@ var ApiSessionTreeLabelRoute = Route.update({
 });
 var ApiDirectorySessionsRouteChildren = { ApiDirectorySessionsCleanupRoute };
 var ApiDirectorySessionsRouteWithChildren = ApiDirectorySessionsRoute._addFileChildren(ApiDirectorySessionsRouteChildren);
+var ApiTerminalRouteChildren = {
+	ApiTerminalIdCloseRoute,
+	ApiTerminalIdEventsRoute,
+	ApiTerminalIdInputRoute,
+	ApiTerminalIdResizeRoute
+};
+var ApiTerminalRouteWithChildren = ApiTerminalRoute._addFileChildren(ApiTerminalRouteChildren);
 var ApiSessionTreeRouteChildren = { ApiSessionTreeLabelRoute };
 var rootRouteChildren = {
 	IndexRoute,
@@ -8396,21 +9683,25 @@ var rootRouteChildren = {
 	ApiPromptRoute,
 	ApiProviderUsageRoute,
 	ApiSlashCommandRoute,
+	ApiTerminalRoute: ApiTerminalRouteWithChildren,
 	ApiThinkingRoute,
 	ApiAuthApiKeyRoute,
 	ApiAuthLogoutRoute,
 	ApiAuthOauthRoute,
 	ApiAuthProvidersRoute,
+	ApiClientManifestRoute,
 	ApiDirectoryResolveRoute,
 	ApiFilesReadRoute,
 	ApiFilesTreeRoute,
 	ApiPendingMessageRemoveRoute,
 	ApiPendingMessagesReorderRoute,
+	ApiPendingMessagesStartRoute,
 	ApiSessionCloneRoute,
 	ApiSessionDeleteRoute,
 	ApiSessionForkRoute,
 	ApiSessionHistoryRoute,
 	ApiSessionMoveRoute,
+	ApiSessionNameRoute,
 	ApiSessionNewRoute,
 	ApiSessionReadStateRoute,
 	ApiSessionRenameRoute,
@@ -8420,7 +9711,7 @@ var rootRouteChildren = {
 	ApiSettingsHideThinkingRoute,
 	ApiUiIdRoute
 };
-var routeTree = Route$53._addFileChildren(rootRouteChildren)._addFileTypes();
+var routeTree = Route$61._addFileChildren(rootRouteChildren)._addFileTypes();
 function getRouter() {
 	const queryClient = new QueryClient({ defaultOptions: { queries: {
 		retry: 1,