zidane 7.2.5 → 8.0.4

package/dist/todo-edits-Dn251YUP.js

@@ -0,0 +1,1790 @@
+import { i as readFileInputPaths } from "./format-bytes-C7tfc3Zm.js";
+import { rn as parseMachineKind } from "./tool-formatters-IQFDrdrs.js";
+import { y as computeLineDiff } from "./url-D8HCl65b.js";
+import { p as LOCAL_HOST_KEY } from "./types-CH5XpIHw.js";
+//#region src/chat/hosts/host-index.ts
+/**
+* Which host an id lives on: a session (or a request a host handed out: an
+* approval, a question, a terminal). A client learns it from what a host
+* tells it (its lists, a create, an activation, its signals) and routes
+* every later call on that id there.
+*
+* Never guessed: an id no host told about is an error
+* ({@link UnknownHostIdError}), one several hosts list is an error unless the
+* lookup names its host ({@link AmbiguousHostIdError}), and the ids of a host
+* that was removed stay remembered as such ({@link HostRemovedError}) until
+* a host claims them again, so nothing aimed at a removed server quietly
+* lands on another host.
+* Node-free, shared by the TUI and the GUI main process.
+*/
+/** No host told this client about the id: nothing to route it to. */
+var UnknownHostIdError = class extends Error {
+	id;
+	code = "unknown-host-id";
+	constructor(id, noun = "session") {
+		super(`No host is known for ${noun} "${id}": list or open it on its host first.`);
+		this.id = id;
+		this.name = "UnknownHostIdError";
+	}
+};
+/** The id lived on a host that was removed from this window. */
+var HostRemovedError = class extends Error {
+	hostKey;
+	hostName;
+	code = "host-removed";
+	constructor(hostKey, hostName) {
+		super(`${hostName} was removed.`);
+		this.hostKey = hostKey;
+		this.hostName = hostName;
+		this.name = "HostRemovedError";
+	}
+};
+/**
+* Several hosts list the id (two hosts can hold the same session id: a
+* server sharing this machine's data dir, a copied store) and the lookup
+* did not say which: refused, never guessed.
+*/
+var AmbiguousHostIdError = class extends Error {
+	id;
+	hostKeys;
+	code = "ambiguous-host-id";
+	constructor(id, hostKeys, noun = "session") {
+		super(`${noun[0].toUpperCase()}${noun.slice(1)} "${id}" exists on several hosts (${hostKeys.join(", ")}): say which one.`);
+		this.id = id;
+		this.hostKeys = hostKeys;
+		this.name = "AmbiguousHostIdError";
+	}
+};
+function createHostIndex(noun = "session") {
+	/** id → live host keys, in the order they were noted. */
+	const live = /* @__PURE__ */ new Map();
+	/** id → removed host key → its name. */
+	const removed = /* @__PURE__ */ new Map();
+	const liveOf = (id) => [...live.get(id) ?? []];
+	const removedOf = (id, hostKey) => {
+		const marks = removed.get(id);
+		if (!marks) return void 0;
+		if (hostKey !== void 0) {
+			const name = marks.get(hostKey);
+			return name === void 0 ? void 0 : {
+				key: hostKey,
+				name
+			};
+		}
+		const first = [...marks][0];
+		return first ? {
+			key: first[0],
+			name: first[1]
+		} : void 0;
+	};
+	const index = {
+		note: (id, hostKey) => {
+			let hosts = live.get(id);
+			if (!hosts) live.set(id, hosts = /* @__PURE__ */ new Set());
+			hosts.add(hostKey);
+			const marks = removed.get(id);
+			marks?.delete(hostKey);
+			if (marks?.size === 0) removed.delete(id);
+		},
+		forget: (id, hostKey) => {
+			if (hostKey === void 0) {
+				live.delete(id);
+				removed.delete(id);
+				return;
+			}
+			live.get(id)?.delete(hostKey);
+			if (live.get(id)?.size === 0) live.delete(id);
+			removed.get(id)?.delete(hostKey);
+			if (removed.get(id)?.size === 0) removed.delete(id);
+		},
+		hostOf: (id, hostKey) => {
+			const hosts = liveOf(id);
+			if (hostKey !== void 0) return hosts.includes(hostKey) ? hostKey : void 0;
+			return hosts.length === 1 ? hosts[0] : void 0;
+		},
+		hostsOf: liveOf,
+		require: (id, hostKey) => {
+			const hosts = liveOf(id);
+			if (hostKey !== void 0) {
+				if (hosts.includes(hostKey)) return hostKey;
+				const gone = removedOf(id, hostKey);
+				if (gone) throw new HostRemovedError(gone.key, gone.name);
+				throw new UnknownHostIdError(id, noun);
+			}
+			if (hosts.length === 1) return hosts[0];
+			if (hosts.length > 1) throw new AmbiguousHostIdError(id, hosts, noun);
+			const gone = removedOf(id);
+			if (gone) throw new HostRemovedError(gone.key, gone.name);
+			throw new UnknownHostIdError(id, noun);
+		},
+		removedHostOf: removedOf,
+		idsOf: (hostKey) => [...live].filter(([, hosts]) => hosts.has(hostKey)).map(([id]) => id),
+		dropHost: (hostKey, hostName) => {
+			const ids = index.idsOf(hostKey);
+			for (const id of ids) {
+				index.forget(id, hostKey);
+				let marks = removed.get(id);
+				if (!marks) removed.set(id, marks = /* @__PURE__ */ new Map());
+				marks.set(hostKey, hostName);
+			}
+			return ids;
+		}
+	};
+	return index;
+}
+//#endregion
+//#region src/chat/hosts/session-key.ts
+/**
+* A session's identity across hosts: the (host, session) pair, as one
+* string every client keys rows, maps and persisted state by. Two hosts may
+* hold the same session id (a server sharing this computer's data dir, a
+* copied store), so a bare id never names a session on its own once several
+* hosts are listed.
+*
+* The host is named by its HOST KEY, the key of a client's host directory:
+* {@link LOCAL_HOST_KEY} for This computer (the in-process host or the
+* daemon), a saved server's `hostId` (for a server, hostKey === hostId),
+* or a client's own key for a host it never saves (the TUI's `--host`
+* server: `'ad-hoc'`).
+*
+* The encoding, shared by the TUI and the GUI:
+*
+* - This computer: the bare id (`abc`). Local-only users see exactly the
+*   ids, and state persisted before keys existed still means the same
+*   session.
+* - Any other host: `<hostKey>␟<id>` (U+001F, never in a host key).
+*
+* A local id that itself contains U+001F is written `local␟<id>`, so a key
+* always parses back to the pair it was made from. Node-free.
+*/
+const SESSION_KEY_SEPARATOR = "";
+/** The key of `sessionId` on `hostKey` (`null` / absent / {@link LOCAL_HOST_KEY}: a local session). */
+function sessionKey(hostKey, sessionId) {
+	if (!hostKey || hostKey === "local") return sessionId.includes("") ? `${LOCAL_HOST_KEY}${sessionId}` : sessionId;
+	if (hostKey.includes("")) throw new Error("A host key cannot contain U+001F.");
+	return `${hostKey}${sessionId}`;
+}
+/** The pair `key` names (a bare id: This computer's). */
+function parseSessionKey(key) {
+	const at = key.indexOf("");
+	if (at < 0) return {
+		hostKey: LOCAL_HOST_KEY,
+		sessionId: key
+	};
+	return {
+		hostKey: key.slice(0, at),
+		sessionId: key.slice(at + 1)
+	};
+}
+//#endregion
+//#region src/chat/auth-rows.ts
+/**
+* Stored credentials, i.e. the ones a user can actually choose between.
+*
+* `env` is excluded: it is observed rather than stored, and is usually just the
+* mirror `applyApiKeyEnv` wrote from the stored API key, so counting it would
+* advertise a choice that does not exist.
+*/
+function selectableSources(provider) {
+	return provider.methods.filter((m) => m.source !== "env");
+}
+/** A provider earns a chevron only when there is a real choice to reveal. */
+function isExpandableProvider(provider) {
+	return selectableSources(provider).length > 1;
+}
+/**
+* Flatten the provider list plus the expanded set into the visible-row list.
+*
+*   - `providers` — filtered / ordered provider list (post-search).
+*   - `expanded`  — keys of providers whose sources are open. Keys for
+*                   providers that are no longer expandable are ignored rather
+*                   than cleaned up, so stale expansion state (a credential
+*                   removed while the modal is open) can't desync the cursor.
+*/
+function buildVisibleAuthRows(providers, expanded) {
+	const out = [];
+	for (const provider of providers) {
+		const expandable = isExpandableProvider(provider);
+		out.push({
+			kind: "provider",
+			provider,
+			expandable
+		});
+		if (!expandable || !expanded.has(provider.key)) continue;
+		for (const method of selectableSources(provider)) out.push({
+			kind: "source",
+			providerKey: provider.key,
+			method
+		});
+		if (provider.envKey) {
+			const envMethod = provider.methods.find((m) => m.source === "env");
+			out.push({
+				kind: "source",
+				providerKey: provider.key,
+				method: envMethod ?? {
+					source: "env",
+					detail: provider.envKey,
+					active: false
+				}
+			});
+		}
+	}
+	return out;
+}
+/**
+* Provider key a row "belongs to" — its own for a provider header, the parent's
+* for a source row.
+*/
+function parentProviderKey(row) {
+	return row.kind === "provider" ? row.provider.key : row.providerKey;
+}
+/**
+* Index in `rows` of the header for the given provider key, or `-1`.
+*
+* Collapse handlers snap the cursor up to the parent BEFORE the row list
+* shrinks; without that the cursor keeps its flat index and silently lands on
+* whichever sibling row slid into that slot.
+*/
+function indexOfProviderRow(rows, providerKey) {
+	return rows.findIndex((r) => r.kind === "provider" && r.provider.key === providerKey);
+}
+//#endregion
+//#region src/chat/fold-actions.ts
+/** Programs whose first argument is the thing they do (`git status`, `bun test`). */
+const SUBCOMMAND_PROGRAMS = /* @__PURE__ */ new Set([
+	"git",
+	"gh",
+	"bun",
+	"npm",
+	"pnpm",
+	"yarn",
+	"npx",
+	"bunx",
+	"cargo",
+	"go",
+	"docker",
+	"kubectl",
+	"make",
+	"uv",
+	"pip",
+	"pip3",
+	"brew",
+	"deno",
+	"node",
+	"playwright",
+	"vitest",
+	"jest",
+	"tsc",
+	"eslint",
+	"prettier"
+]);
+/** Wrappers that only change how the next program runs. */
+const WRAPPERS = /* @__PURE__ */ new Set([
+	"sudo",
+	"time",
+	"nice",
+	"nohup",
+	"exec",
+	"command",
+	"caffeinate"
+]);
+/** Setup steps that carry no meaning of their own. */
+const SETUP = /* @__PURE__ */ new Set([
+	"cd",
+	"pushd",
+	"popd",
+	"export",
+	"set",
+	"source",
+	".",
+	"unset",
+	"true",
+	"mkdir"
+]);
+/** Split on `&&`, `||`, `;`, `|` and newlines outside quotes. */
+function splitSegments(command) {
+	const out = [];
+	let cur = "";
+	let quote = null;
+	for (let i = 0; i < command.length; i++) {
+		const ch = command[i];
+		if (quote) {
+			if (ch === quote) quote = null;
+			cur += ch;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			quote = ch;
+			cur += ch;
+			continue;
+		}
+		const two = command.slice(i, i + 2);
+		if (two === "&&" || two === "||") {
+			out.push(cur);
+			cur = "";
+			i++;
+			continue;
+		}
+		if (ch === ";" || ch === "|" || ch === "\n") {
+			out.push(cur);
+			cur = "";
+			continue;
+		}
+		cur += ch;
+	}
+	out.push(cur);
+	return out.map((s) => s.trim()).filter(Boolean);
+}
+/** Words of a segment, quotes kept as one word (unquoted). */
+function words(segment) {
+	const out = [];
+	for (const m of segment.matchAll(/"([^"]*)"|'([^']*)'|(\S+)/g)) out.push(m[1] ?? m[2] ?? m[3] ?? "");
+	return out;
+}
+/** The gist of one segment (`bun run build`, `python3`), or null for setup noise. */
+function segmentGist(segment) {
+	let w = words(segment);
+	for (;;) {
+		if (w.length === 0) return null;
+		const head = w[0];
+		if (/^[A-Z_]\w*=/i.test(head)) w = w.slice(1);
+		else if (WRAPPERS.has(head)) w = w.slice(1);
+		else if (head === "env") {
+			w = w.slice(1);
+			while (w[0] && (w[0].startsWith("-") || /^[A-Z_]\w*=/i.test(w[0]))) {
+				const flag = w[0];
+				w = w.slice(1);
+				if (flag === "-u" && w[0]) w = w.slice(1);
+			}
+		} else if (head === "timeout" && w[1] && /^\d/.test(w[1])) w = w.slice(2);
+		else break;
+	}
+	const program = w[0].split("/").pop();
+	if (SETUP.has(program)) return null;
+	if (!SUBCOMMAND_PROGRAMS.has(program)) return program;
+	const rest = w.slice(1).filter((arg) => !arg.startsWith("-"));
+	let sub = rest[0];
+	if ((program === "npx" || program === "bunx") && sub) {
+		const tool = sub.split("/").pop();
+		const next = rest[1];
+		return SUBCOMMAND_PROGRAMS.has(tool) && next && !next.includes("/") && !next.includes(".") ? `${tool} ${next}` : tool;
+	}
+	if ((sub === "run" || sub === "exec") && rest[1] && [
+		"bun",
+		"npm",
+		"pnpm",
+		"yarn"
+	].includes(program)) return `${program} ${sub} ${rest[1]}`;
+	if (sub && (sub.includes("/") || /\.[a-z]+$/i.test(sub))) sub = void 0;
+	return sub ? `${program} ${sub}` : program;
+}
+/**
+* `Ran <gist>` for a shell command: heredoc bodies dropped, setup steps
+* (`cd`, `export`, `set -e`) skipped, env and wrappers peeled off, program
+* plus subcommand kept. Further meaningful steps read as `+N`.
+*/
+function commandGist(command) {
+	const gists = splitSegments(command.replace(/<<-?\s*(['"]?)(\w+)\1[\s\S]*?(?:\n\2\b|$)/g, "")).map(segmentGist).filter((g) => g !== null);
+	if (gists.length === 0) return {
+		gist: "a command",
+		more: 0
+	};
+	return {
+		gist: gists[0],
+		more: gists.length - 1
+	};
+}
+function splitPath(path) {
+	const clean = path.replace(/\/+$/, "");
+	const i = clean.lastIndexOf("/");
+	return i < 0 ? {
+		name: clean,
+		dir: ""
+	} : {
+		name: clean.slice(i + 1),
+		dir: clean.slice(0, i)
+	};
+}
+function str$1(input, key) {
+	const v = input?.[key];
+	return typeof v === "string" && v.trim() !== "" ? v : void 0;
+}
+/** Line counts exactly as the diff in the details shows them. */
+function editCounts(edit) {
+	if (!edit) return null;
+	let added = 0;
+	let removed = 0;
+	for (const h of edit.hunks) for (const d of computeLineDiff(h.oldString, h.newString)) if (d.op === "add") added++;
+	else if (d.op === "remove") removed++;
+	return {
+		added,
+		removed
+	};
+}
+function shortUrl(url) {
+	const short = url.replace(/^https?:\/\//, "").replace(/\/$/, "");
+	return short.length > 48 ? `${short.slice(0, 47)}…` : short;
+}
+/**
+* The dev browser in words: where it went and what it did. Clicks and typing
+* read their result's first line (`Clicked "Save"`), which names the element;
+* the ref the model used (`e12`) means nothing to a person.
+*/
+function browserOverview(tool) {
+	const input = tool.input;
+	const url = str$1(input, "url");
+	const head = typeof tool.result === "string" && tool.ok ? tool.result.split("\n")[0].replace(/\. No navigation, dialog or error\.$|\.$/, "") : "";
+	switch (tool.name) {
+		case "browser_open": return url ? {
+			label: `Opened ${shortUrl(url)}`,
+			title: url
+		} : { label: "Opened the browser" };
+		case "browser_navigate": {
+			const action = str$1(input, "action");
+			if (action === "back") return { label: "Went back" };
+			if (action === "forward") return { label: "Went forward" };
+			if (action === "reload") return { label: "Reloaded the page" };
+			return url ? {
+				label: `Went to ${shortUrl(url)}`,
+				title: url
+			} : { label: "Navigated" };
+		}
+		case "browser_snapshot": return { label: "Read the page" };
+		case "browser_screenshot": return { label: "Took a screenshot" };
+		case "browser_click": return { label: head.startsWith("Clicked") ? head : `Clicked ${tool.target ?? "the page"}` };
+		case "browser_type": return { label: head.startsWith("Typed") ? head : "Typed in the page" };
+		case "browser_press": return { label: head.startsWith("Pressed") ? head : `Pressed ${str$1(input, "key") ?? "a key"}` };
+		case "browser_scroll": return { label: "Scrolled the page" };
+		case "browser_wait_for": {
+			const what = str$1(input, "text") ?? str$1(input, "selector") ?? str$1(input, "urlIncludes");
+			return { label: what ? `Waited for “${what.length > 40 ? `${what.slice(0, 39)}…` : what}”` : "Waited" };
+		}
+		case "browser_evaluate": {
+			const expression = str$1(input, "expression") ?? "";
+			return {
+				label: "Ran a script in the page",
+				...expression ? { title: expression.slice(0, 600) } : {}
+			};
+		}
+		case "browser_console": return { label: "Read the console" };
+		default: return null;
+	}
+}
+/** The overview line for one tool call. */
+function toolOverview(tool) {
+	const input = tool.input;
+	if (tool.name.startsWith("browser_")) {
+		const browser = browserOverview(tool);
+		if (browser) return browser;
+	}
+	switch (tool.name) {
+		case "shell":
+		case "bash": {
+			const command = str$1(input, "command") ?? tool.target ?? "";
+			const description = str$1(input, "description")?.trim();
+			if (description) return {
+				label: description.length > 120 ? `${description.slice(0, 119)}…` : description,
+				title: command.slice(0, 600)
+			};
+			const { gist, more } = commandGist(command);
+			return {
+				label: `Ran ${gist}`,
+				...more > 0 ? { hint: `+${more}` } : {},
+				title: command.slice(0, 600)
+			};
+		}
+		case "read_file": {
+			const batch = str$1(input, "path") ? [] : readFileInputPaths(input);
+			if (batch.length > 1) return {
+				label: `Read ${splitPath(batch[0]).name} +${batch.length - 1}`,
+				title: batch.join("\n")
+			};
+			const path = str$1(input, "path") ?? batch[0] ?? tool.target ?? "";
+			const { name, dir } = splitPath(path);
+			return {
+				label: `Read ${name || "a file"}`,
+				...dir ? { hint: dir } : {},
+				title: path
+			};
+		}
+		case "edit":
+		case "multi_edit":
+		case "write_file": {
+			const path = str$1(input, "path") ?? tool.edit?.path ?? tool.target ?? "";
+			const { name, dir } = splitPath(path);
+			const counts = editCounts(tool.edit);
+			return {
+				label: `${tool.name === "write_file" ? "Wrote" : "Edited"} ${name || "a file"}`,
+				...dir ? { hint: dir } : {},
+				...counts && (counts.added > 0 || counts.removed > 0) ? counts : {},
+				title: path
+			};
+		}
+		case "grep": {
+			const pattern = str$1(input, "pattern") ?? tool.target ?? "";
+			const where = str$1(input, "path");
+			return {
+				label: pattern ? `Searched for “${pattern.length > 48 ? `${pattern.slice(0, 47)}…` : pattern}”` : "Searched",
+				...where ? { hint: where } : {},
+				title: pattern
+			};
+		}
+		case "glob": {
+			const pattern = str$1(input, "pattern") ?? tool.target ?? "";
+			return {
+				label: pattern ? `Found files ${pattern}` : "Found files",
+				title: pattern
+			};
+		}
+		case "spawn": {
+			const task = str$1(input, "task") ?? tool.target ?? "";
+			const first = task.split("\n").find((line) => line.trim()) ?? "";
+			return {
+				label: "Agent",
+				...first ? { hint: first.length > 80 ? `${first.slice(0, 79)}…` : first } : {},
+				...task ? { title: task.slice(0, 600) } : {}
+			};
+		}
+		case "present_plan": {
+			const title = str$1(input, "title");
+			return {
+				label: "Presented a plan",
+				...title ? {
+					hint: title,
+					title
+				} : {}
+			};
+		}
+		case "ask_user": {
+			const n = Array.isArray(input?.questions) ? input.questions.length : 0;
+			return { label: n > 0 ? `Asked ${n} question${n === 1 ? "" : "s"}` : "Asked a question" };
+		}
+		case "todowrite": {
+			const todos = Array.isArray(input?.todos) ? input.todos : [];
+			const done = todos.filter((t) => t.status === "completed").length;
+			return {
+				label: "Updated todos",
+				...todos.length > 0 ? { hint: `${done} of ${todos.length} done` } : {}
+			};
+		}
+		case "list_files": {
+			const path = str$1(input, "path") ?? tool.target ?? ".";
+			return {
+				label: `Listed ${path}`,
+				title: path
+			};
+		}
+		default: {
+			const target = tool.target;
+			const short = target && target.length > 60 ? `${target.slice(0, 59)}…` : target;
+			return {
+				label: short ? `${tool.displayName} ${short}` : tool.displayName,
+				...target ? { title: target } : {}
+			};
+		}
+	}
+}
+/**
+* Verb phrase per canonical tool name for a batch summary. Unknown tools
+* derive one from their display name, so MCP and host tools read cleanly.
+*/
+const BATCH_VERB_PHRASE = {
+	shell: "ran a command",
+	read_file: "read a file",
+	grep: "searched",
+	glob: "searched for files",
+	list_files: "listed files",
+	edit: "edited a file",
+	multi_edit: "edited a file",
+	write_file: "created a file",
+	spawn: "spawned a subagent",
+	tool_search: "searched for tools",
+	skills_use: "activated a skill",
+	skills_read: "read a skill",
+	skills_run_script: "ran a skill script",
+	ask_user: "asked a question",
+	present_plan: "presented a plan",
+	browser_open: "opened the browser",
+	browser_navigate: "navigated",
+	browser_snapshot: "read the page",
+	browser_screenshot: "took a screenshot",
+	browser_click: "clicked",
+	browser_type: "typed",
+	browser_press: "pressed a key",
+	browser_scroll: "scrolled",
+	browser_wait_for: "waited",
+	browser_evaluate: "ran a script in the page",
+	browser_console: "read the console",
+	terminal_list: "listed terminals",
+	terminal_read: "read a terminal",
+	terminal_write: "typed in a terminal"
+};
+function toolPhrase(name, displayName) {
+	return BATCH_VERB_PHRASE[name] ?? `used ${displayName.toLowerCase()}`;
+}
+/**
+* Cap on distinct phrases in a summary: a 40-call exchange reads "Ran a
+* command, searched, read a file, edited a file +23", where +N counts the
+* calls the shown phrases do not cover.
+*/
+const MAX_SUMMARY_PHRASES = 4;
+/**
+* "Ran a command, read a file +2" for a run of calls. Adjacent identical
+* phrases merge, so three reads in a row say "read a file" once.
+*/
+function summarizeTools(tools) {
+	const phrases = [];
+	for (const t of tools) {
+		const phrase = toolPhrase(t.name, t.displayName);
+		const last = phrases[phrases.length - 1];
+		if (last && last.phrase === phrase) last.calls += 1;
+		else phrases.push({
+			phrase,
+			calls: 1
+		});
+	}
+	if (phrases.length === 0) return "Ran tools";
+	const shown = phrases.slice(0, MAX_SUMMARY_PHRASES);
+	const shownCalls = shown.reduce((n, p) => n + p.calls, 0);
+	const rest = tools.length - shownCalls;
+	const joined = shown.map((p) => p.phrase).join(", ");
+	const capped = rest > 0 ? `${joined} +${rest}` : joined;
+	return capped.charAt(0).toUpperCase() + capped.slice(1);
+}
+/**
+* A message as a person skims it: its words, markdown syntax and code
+* blocks dropped, whitespace folded. For the compact stacks of earlier
+* messages.
+*/
+function messagePreview(text) {
+	return text.replace(/```[\s\S]*?(?:```|$)/g, " ").replace(/`([^`]*)`/g, "$1").replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^\s{0,3}(?:#{1,6}\s+|>\s?|[-*+]\s+|\d+[.)]\s+)/gm, "").replace(/(\*\*|__|\*|_|~~)(\S(?:.*?\S)?)\1/g, "$2").replace(/\s+/g, " ").trim();
+}
+//#endregion
+//#region src/chat/instruction-rows.ts
+/**
+* Upper bound on preview lines rendered for one expanded segment. Mirrors the
+* Logs tab's render cap: the scrollbox can hold arbitrary height, but pasting a
+* runaway 64KB instruction file into the layout pass is a waste of a frame.
+* File-backed segments have `$EDITOR` as the escape hatch for the remainder.
+*/
+const INSTRUCTION_PREVIEW_LINE_CAP = 400;
+/**
+* Filter segments by the active query and resolve each one's expanded state.
+*
+* Deliberately does NOT auto-expand matches the way the Extensions tab does:
+* the search corpus includes each segment's full text, so a query typically
+* matches deep inside a long document — auto-expanding every hit would dump
+* thousands of lines into the viewport on a keystroke. The user expands the row
+* they care about.
+*/
+function buildVisibleInstructionRows(opts) {
+	const { segments, expanded, queryActive, matchSegment } = opts;
+	const out = [];
+	for (const segment of segments) {
+		if (queryActive && !matchSegment(segment)) continue;
+		out.push({
+			segment,
+			expanded: expanded.has(segment.id)
+		});
+	}
+	return out;
+}
+/**
+* Split a segment's text into renderable preview lines, clamped to
+* {@link INSTRUCTION_PREVIEW_LINE_CAP}.
+*
+* `hidden` is how many lines were dropped off the tail, so the view can render
+* an honest "+N more lines" marker instead of silently truncating. Tabs are
+* expanded to two spaces because the terminal text renderable doesn't
+* interpret `\t`, and `\r` is stripped so CRLF files don't leave artefacts at
+* every line end.
+*/
+function instructionPreviewLines(text) {
+	const all = text.replace(/\r\n?/g, "\n").replace(/\t/g, "  ").split("\n");
+	while (all.length > 0 && all[all.length - 1].trim() === "") all.pop();
+	if (all.length <= 400) return {
+		lines: all,
+		hidden: 0
+	};
+	return {
+		lines: all.slice(0, 400),
+		hidden: all.length - 400
+	};
+}
+/**
+* Short badge for a segment's origin — the "where does this come from" column.
+* `'file'` is intentionally the only one that reads like a location, since it's
+* the only origin the user can act on.
+*/
+function instructionOriginBadge(segment) {
+	switch (segment.origin) {
+		case "file": return "file";
+		case "generated": return "generated";
+		case "mcp": return "mcp server";
+		case "built-in": return "built-in";
+	}
+}
+//#endregion
+//#region src/chat/machines-view.ts
+/** The `label` of the notices a host emits about a session's machine. */
+const MACHINE_NOTICE_LABEL = "machine";
+const WAITING_RE = /^waiting for (\S+?)…/;
+const BACK_RE = /^\S+ is back\./;
+const GAVE_UP_RE = /^\S+ stayed offline for /;
+/**
+* The machine a session's run is paused on, from its notices (`waiting for
+* laptop…` until `laptop is back.` or `laptop stayed offline … run stopped`),
+* `null` when none. `online`: machines known to be back since (a
+* `machine:status` the window saw), which clear the wait at once.
+*/
+function machineWaiting(events, online = /* @__PURE__ */ new Set()) {
+	for (let i = events.length - 1; i >= 0; i--) {
+		const event = events[i];
+		if (event.notice?.label !== "machine" || typeof event.text !== "string") continue;
+		if (BACK_RE.test(event.text) || GAVE_UP_RE.test(event.text)) return null;
+		const waiting = WAITING_RE.exec(event.text)?.[1];
+		if (waiting) return online.has(waiting) ? null : waiting;
+	}
+	return null;
+}
+function dirname(path) {
+	const trimmed = path.replace(/\/+$/, "");
+	const at = trimmed.lastIndexOf("/");
+	return at <= 0 ? "/" : trimmed.slice(0, at);
+}
+function basename(path) {
+	const trimmed = path.replace(/\/+$/, "");
+	return trimmed.slice(trimmed.lastIndexOf("/") + 1) || trimmed;
+}
+/** `machines.listDirs` as a folder listing: the parent stops at the root the folder is in. */
+function machineDirListing(result) {
+	const { path } = result;
+	return {
+		roots: result.roots,
+		path,
+		parent: result.roots.includes(path) ? null : dirname(path),
+		entries: result.dirs.map((dir) => ({
+			path: dir,
+			name: basename(dir),
+			isGitRepo: false
+		}))
+	};
+}
+/**
+* Environment kinds in picker order: this host's own first, then each
+* machine's together (`local@` before `worktree@`), machines by name.
+*/
+function orderByMachine(descriptors) {
+	const rank = (d) => {
+		const parsed = parseMachineKind(d.kind);
+		return parsed ? [
+			1,
+			parsed.name,
+			parsed.base === "local" ? 0 : 1
+		] : [
+			0,
+			"",
+			0
+		];
+	};
+	return descriptors.map((d, i) => ({
+		d,
+		i,
+		r: rank(d)
+	})).sort((a, b) => a.r[0] - b.r[0] || a.r[1].localeCompare(b.r[1]) || a.r[2] - b.r[2] || a.i - b.i).map((entry) => entry.d);
+}
+/** Why a machine kind can't be picked now (its machine is offline), else `undefined`. */
+function machineBlockedReason(descriptor) {
+	return descriptor.machine?.status === "offline" ? `${descriptor.machine.name} is offline` : void 0;
+}
+/** A session's environment as its header shows it: `local@laptop`, `worktree@laptop ⎇ feat`, `⎇ feat`, or the kind. */
+function environmentLabel(environment) {
+	if (parseMachineKind(environment.kind)) return environment.branch ? `${environment.kind} ⎇ ${environment.branch}` : environment.kind;
+	return environment.branch ? `⎇ ${environment.branch}` : environment.kind;
+}
+const MACHINE_LINK_STATE_TEXT = {
+	"connecting": "connecting…",
+	"connected": "connected",
+	"reconnecting": "reconnecting…",
+	"offline": "offline",
+	"auth-refused": "refused",
+	"identity": "another server answers there",
+	"refused": "refused"
+};
+/** "seen 5 min ago" for a machine's `lastSeen`. */
+function lastSeenText(lastSeen, now) {
+	if (lastSeen === void 0) return "never seen";
+	const minutes = Math.max(0, Math.round((now - lastSeen) / 6e4));
+	if (minutes < 1) return "seen just now";
+	if (minutes < 60) return `seen ${minutes} min ago`;
+	const hours = Math.round(minutes / 60);
+	return hours < 48 ? `seen ${hours} h ago` : `seen ${Math.round(hours / 24)} d ago`;
+}
+//#endregion
+//#region src/chat/mcp-form.ts
+const MCP_TRANSPORTS = [
+	"stdio",
+	"streamable-http",
+	"sse"
+];
+/**
+* Validate + normalize the raw field values into a config entry.
+* Returns the first problem in row order so the dialog can surface it.
+*/
+function validateMcpForm(values) {
+	const name = values.name.trim();
+	if (name.length === 0) return {
+		ok: false,
+		error: "name is required"
+	};
+	if (!/^[\w.-]+$/.test(name)) return {
+		ok: false,
+		error: "name must be alphanumerics, dots, hyphens, underscores"
+	};
+	if (values.transport === "stdio") {
+		const tokens = splitCommandLine(values.commandLine);
+		if (tokens.length === 0) return {
+			ok: false,
+			error: "command is required for stdio servers"
+		};
+		const env = parseKeyValueLines(values.env, {
+			label: "env",
+			separators: ["="]
+		});
+		if (!env.ok) return {
+			ok: false,
+			error: env.error
+		};
+		return {
+			ok: true,
+			result: {
+				entry: {
+					name,
+					transport: "stdio",
+					command: tokens[0],
+					...tokens.length > 1 ? { args: tokens.slice(1) } : {},
+					...Object.keys(env.pairs).length > 0 ? { env: env.pairs } : {}
+				},
+				scope: values.scope
+			}
+		};
+	}
+	const url = values.url.trim();
+	if (url.length === 0) return {
+		ok: false,
+		error: "url is required for http/sse servers"
+	};
+	if (!/^https?:\/\//.test(url)) return {
+		ok: false,
+		error: "url must start with http:// or https://"
+	};
+	const headers = parseKeyValueLines(values.headers, {
+		label: "headers",
+		separators: [":", "="]
+	});
+	if (!headers.ok) return {
+		ok: false,
+		error: headers.error
+	};
+	return {
+		ok: true,
+		result: {
+			entry: {
+				name,
+				transport: values.transport,
+				url,
+				...Object.keys(headers.pairs).length > 0 ? { headers: headers.pairs } : {}
+			},
+			scope: values.scope
+		}
+	};
+}
+/**
+* Split a command line into tokens, honoring single/double quotes so
+* `npx -y my-server --root "/path with spaces"` round-trips. No escape
+* processing beyond quote grouping — this is a form field, not a shell.
+*/
+function splitCommandLine(line) {
+	const out = [];
+	const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+	for (let m = re.exec(line); m !== null; m = re.exec(line)) out.push(m[1] ?? m[2] ?? m[3]);
+	return out;
+}
+/**
+* Parse one key/value pair PER LINE. Line-based (not whitespace-split)
+* because values legitimately contain spaces — `Authorization: Bearer
+* abc123` is the canonical headers case, and env values like
+* `GREETING=hello world` are equally valid. The first separator found
+* (in `separators` priority order, `:` before `=` for headers) splits;
+* the rest of the line is the value, trimmed. Blank lines skipped.
+*/
+function parseKeyValueLines(raw, opts) {
+	const pairs = {};
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.length === 0) continue;
+		let splitAt = -1;
+		for (const sep of opts.separators) {
+			const idx = trimmed.indexOf(sep);
+			if (idx > 0 && (splitAt === -1 || idx < splitAt)) splitAt = idx;
+		}
+		if (splitAt <= 0) {
+			const forms = opts.separators.map((s) => `KEY${s}VALUE`).join(" or ");
+			return {
+				ok: false,
+				error: `${opts.label} entries must be ${forms}, one per line (got "${trimmed}")`
+			};
+		}
+		const key = trimmed.slice(0, splitAt).trim();
+		const value = trimmed.slice(splitAt + 1).trim();
+		if (key.length === 0) return {
+			ok: false,
+			error: `${opts.label} entry has an empty key ("${trimmed}")`
+		};
+		pairs[key] = value;
+	}
+	return {
+		ok: true,
+		pairs
+	};
+}
+//#endregion
+//#region src/chat/model-name.ts
+/** Brand words a first-party provider's names start with. */
+const OWN_BRAND = {
+	anthropic: /^claude[\s-]+/i,
+	openai: /^openai[\s:-]+/i
+};
+const ACRONYMS = /* @__PURE__ */ new Set([
+	"gpt",
+	"glm",
+	"oss",
+	"ai",
+	"r1",
+	"vl"
+]);
+/** `claude-opus-4-7-20250722` → `Claude Opus 4.7`; `gpt-5.5` → `GPT 5.5`. */
+function readableId(id) {
+	const parts = (id.split("/").pop() ?? id).replace(/-\d{8}$/, "").split(/[-_]/).filter(Boolean);
+	const out = [];
+	for (const part of parts) {
+		const prev = out[out.length - 1];
+		if (/^\d+$/.test(part) && prev && /^\d+(?:\.\d+)*$/.test(prev)) {
+			out[out.length - 1] = `${prev}.${part}`;
+			continue;
+		}
+		out.push(ACRONYMS.has(part.toLowerCase()) ? part.toUpperCase() : part.charAt(0).toUpperCase() + part.slice(1));
+	}
+	return out.join(" ");
+}
+function modelDisplayName({ providerKey, modelId, modelName }) {
+	let name = (modelName && modelName !== modelId ? modelName : readableId(modelId)).trim();
+	let vendor;
+	name = name.replace(/\s*\(latest\)\s*$/i, "");
+	const prefixed = /^([^:]{2,40}):\s+(\S.*)$/.exec(name);
+	if (prefixed) {
+		vendor = prefixed[1].trim();
+		name = prefixed[2].trim();
+	}
+	const key = providerKey ?? (/^claude[-_]/i.test(modelId) ? "anthropic" : void 0);
+	const brand = key ? OWN_BRAND[key] : void 0;
+	if (brand && brand.test(name) && name.replace(brand, "").trim()) name = name.replace(brand, "").trim();
+	return vendor ? {
+		name,
+		vendor
+	} : { name };
+}
+//#endregion
+//#region src/chat/notice-format.ts
+/** Leading glyph per severity. `info` is deliberately quiet — a middle dot. */
+const NOTICE_GLYPH = {
+	info: "·",
+	warn: "!",
+	error: "✗"
+};
+//#endregion
+//#region src/chat/palette.ts
+/** Group name the hosts use for the most-recently-used rows shown on an empty query. */
+const PALETTE_RECENT_GROUP = "Recent";
+const PALETTE_RECENTS_MAX = 12;
+/** Ranked rows returned for a query; the host virtualises anyway, this bounds the work. */
+const PALETTE_RESULT_MAX = 200;
+const WORD_BREAKS = /* @__PURE__ */ new Set([
+	" ",
+	"/",
+	"-",
+	"_",
+	":",
+	"."
+]);
+/** What a hit at `at` is worth: the very start, a word start, a camelCase hump, or anywhere. */
+function startBonus(text, lower, at) {
+	if (at === 0) return 8;
+	if (WORD_BREAKS.has(lower[at - 1])) return 6;
+	if (text[at] !== lower[at] && text[at - 1] === lower[at - 1]) return 4;
+	return 1;
+}
+/** Bonus per character for a term found whole: "set" in "settings" beats s·e·t across words. */
+const WHOLE_TERM_BONUS = 2;
+/**
+* Subsequence match of `query` in `text` with the usual bonuses: word
+* starts and the very beginning score higher, gaps cost, runs of adjacent
+* hits are rewarded, and the query found whole (as one run) beats the same
+* letters scattered. Returns null when not every query character appears
+* in order. Case-insensitive; `query` must already be lower-cased.
+*/
+function fuzzyMatch(text, query) {
+	return matchLowered(text, text.toLowerCase(), query);
+}
+const NO_INDICES = [];
+/** `indices` null: the score alone (a fallback field never highlights), without the allocations. */
+function matchLowered(text, lower, query, indices = []) {
+	if (query.length === 0) return {
+		score: 0,
+		indices: [],
+		whole: true
+	};
+	let score = 0;
+	let from = 0;
+	let prev = -2;
+	for (let q = 0; q < query.length; q++) {
+		const at = lower.indexOf(query[q], from);
+		if (at === -1) return null;
+		score += startBonus(text, lower, at);
+		if (at === prev + 1) score += 3;
+		else if (prev >= 0) score -= Math.min(3, at - prev - 1) * .5;
+		indices?.push(at);
+		prev = at;
+		from = at + 1;
+	}
+	let whole = -Infinity;
+	let wholeAt = -1;
+	for (let at = lower.indexOf(query); at !== -1; at = lower.indexOf(query, at + 1)) {
+		const value = startBonus(text, lower, at) + (query.length - 1) * 4 + query.length * WHOLE_TERM_BONUS;
+		if (value > whole) {
+			whole = value;
+			wholeAt = at;
+		}
+		if (at === 0 || WORD_BREAKS.has(lower[at - 1])) break;
+	}
+	const found = whole > score;
+	if (found) {
+		score = whole;
+		if (indices) for (let q = 0; q < query.length; q++) indices[q] = wholeAt + q;
+	}
+	score -= text.length * .02;
+	return {
+		score,
+		indices: indices ?? NO_INDICES,
+		whole: found
+	};
+}
+const haystacks = /* @__PURE__ */ new WeakMap();
+function haystackOf(item) {
+	let h = haystacks.get(item);
+	if (!h) {
+		const texts = [
+			item.title,
+			item.description,
+			item.group,
+			...item.keywords ?? []
+		].filter((t) => !!t);
+		h = {
+			title: item.title.toLowerCase(),
+			fields: texts.map((t) => [t, t.toLowerCase()])
+		};
+		haystacks.set(item, h);
+	}
+	return h;
+}
+/**
+* Every whitespace-separated term must match (AND); scores add. `whole`:
+* each term was found as one run (the words typed, not letters picked
+* across the text). `indices` collects the merged highlight when given;
+* ranking scores without it and highlights only the rows it keeps.
+*/
+function matchTerms(text, lower, terms, indices) {
+	let score = 0;
+	let whole = true;
+	for (const term of terms) {
+		const m = matchLowered(text, lower, term, indices && []);
+		if (!m) return null;
+		score += m.score;
+		whole &&= m.whole;
+		indices?.push(...m.indices);
+	}
+	return {
+		score,
+		whole
+	};
+}
+function titleIndices(item, terms) {
+	const indices = [];
+	matchTerms(item.title, haystackOf(item).title, terms, indices);
+	return terms.length === 1 ? indices : [...new Set(indices)].sort((a, b) => a - b);
+}
+const collator = new Intl.Collator();
+function termsOf(query) {
+	return query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+}
+/** On an empty query: recents first (most recent on top), then the catalog in provider order. */
+function listUnfiltered(items, recents) {
+	const recentRank = new Map(recents.map((id, i) => [id, i]));
+	const out = [];
+	for (const item of items) {
+		const r = recentRank.get(item.id);
+		if (item.searchOnly && r === void 0) continue;
+		out.push({
+			item,
+			score: r === void 0 ? 0 : 12 - r,
+			titleMatches: []
+		});
+	}
+	return out.sort((a, b) => b.score - a.score).slice(0, 200);
+}
+/** The ranked rows for `terms`, and every item that matched (the pool a longer query searches). */
+function rankTerms(items, terms) {
+	const hits = [];
+	for (const item of items) {
+		const hay = haystackOf(item);
+		const title = matchTerms(item.title, hay.title, terms, null);
+		if (title?.whole) {
+			hits.push({
+				item,
+				score: 100 + title.score,
+				inTitle: true
+			});
+			continue;
+		}
+		let total = 0;
+		let ok = true;
+		for (const term of terms) {
+			let best = -Infinity;
+			for (const [text, lower] of hay.fields) {
+				const m = matchLowered(text, lower, term, null);
+				if (m && m.score > best) best = m.score;
+			}
+			if (best === -Infinity) {
+				ok = false;
+				break;
+			}
+			total += best;
+		}
+		if (title && title.score >= total) hits.push({
+			item,
+			score: title.score,
+			inTitle: true
+		});
+		else if (ok) hits.push({
+			item,
+			score: total,
+			inTitle: false
+		});
+	}
+	const matched = hits.map((h) => h.item);
+	hits.sort((a, b) => b.score - a.score || collator.compare(a.item.title, b.item.title));
+	return {
+		ranked: hits.slice(0, 200).map(({ item, score, inTitle }) => ({
+			item,
+			score,
+			titleMatches: inTitle ? titleIndices(item, terms) : []
+		})),
+		matched
+	};
+}
+/**
+* Score every item against `query`. Terms are AND-ed: `tog sid` needs both
+* `tog` and `sid` in order somewhere in the text. Title matches dominate;
+* description, keywords and group are fallbacks that never outrank a
+* title hit. On an empty query recents come first (most recent on top),
+* then the catalog in provider order.
+*/
+function rankPaletteItems(items, query, recents = []) {
+	const terms = termsOf(query);
+	return terms.length === 0 ? listUnfiltered(items, recents) : rankTerms(items, terms).ranked;
+}
+/** `next` asks for at least what `prev` did: each earlier term grew or stayed, new ones came after. */
+function narrows(prev, next) {
+	return next.length >= prev.length && prev.every((term, i) => next[i].startsWith(term));
+}
+/**
+* `rankPaletteItems` for a palette being typed into: it remembers the last
+* query, and when the next one only adds to it (one more character, one
+* more word) it searches just what matched before. A longer query never
+* matches an item the shorter one missed, so the result is the same.
+*/
+function createPaletteRanker() {
+	let last = null;
+	return (items, query, recents = []) => {
+		const terms = termsOf(query);
+		if (terms.length === 0) {
+			last = null;
+			return listUnfiltered(items, recents);
+		}
+		const { ranked, matched } = rankTerms(last && last.items === items && narrows(last.terms, terms) ? last.matched : items, terms);
+		last = {
+			items,
+			terms,
+			matched
+		};
+		return ranked;
+	};
+}
+/**
+* Sections for display. With a query the ranking already interleaves
+* providers, so groups follow the order of their best row. Without a
+* query the recents (ids in `recents`, present in `ranked`) form a
+* leading `Recent` section and the rest keeps provider order.
+*/
+function groupPaletteRows(ranked, query, recents = []) {
+	const groups = /* @__PURE__ */ new Map();
+	const push = (title, row) => {
+		const list = groups.get(title);
+		if (list) list.push(row);
+		else groups.set(title, [row]);
+	};
+	const isRecent = new Set(query.trim() ? [] : recents);
+	for (const row of ranked) push(isRecent.has(row.item.id) ? PALETTE_RECENT_GROUP : row.item.group, row);
+	return [...groups.entries()].map(([title, rows]) => ({
+		title,
+		rows
+	}));
+}
+/** Most-recent-first list of ids, deduplicated and capped. */
+function pushPaletteRecent(recents, id) {
+	return [id, ...recents.filter((r) => r !== id)].slice(0, 12);
+}
+const PALETTE_LIMITS = {
+	items: 500,
+	textChars: 500,
+	keywords: 16
+};
+function str(v, max = PALETTE_LIMITS.textChars) {
+	return typeof v === "string" && v.length > 0 ? v.length > max ? `${v.slice(0, max - 1)}…` : v : void 0;
+}
+/**
+* Coerce whatever a provider returned into well-formed items: entries
+* without an id or title are dropped, strings are capped, unknown kinds
+* fall back to `action`, and `source` is stamped with the provider id.
+* Never throws.
+*/
+function normalizePaletteItems(input, source, defaultGroup) {
+	if (!Array.isArray(input)) return [];
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const raw of input.slice(0, PALETTE_LIMITS.items)) {
+		if (!raw || typeof raw !== "object") continue;
+		const r = raw;
+		const id = str(r.id, 200);
+		const title = str(r.title, 200);
+		if (!id || !title || seen.has(id)) continue;
+		seen.add(id);
+		const item = {
+			id,
+			title,
+			group: str(r.group, 80) ?? defaultGroup,
+			source
+		};
+		const description = str(r.description);
+		if (description) item.description = description;
+		if (Array.isArray(r.keywords)) {
+			const kw = r.keywords.filter((k) => typeof k === "string" && k.length > 0).slice(0, PALETTE_LIMITS.keywords);
+			if (kw.length > 0) item.keywords = kw.map((k) => k.slice(0, 60));
+		}
+		if (r.icon && typeof r.icon === "object") {
+			const icon = r.icon;
+			const gui = str(icon.gui, 120);
+			const tui = str(icon.tui, 8);
+			if (gui || tui) item.icon = {
+				...gui ? { gui } : {},
+				...tui ? { tui } : {}
+			};
+		}
+		if (r.kind === "toggle" || r.kind === "picker") item.kind = r.kind;
+		if (typeof r.checked === "boolean") item.checked = r.checked;
+		const keybinding = str(r.keybinding, 60);
+		if (keybinding) item.keybinding = keybinding;
+		const disabled = str(r.disabled, 200);
+		if (disabled) item.disabled = disabled;
+		if (r.searchOnly === true) item.searchOnly = true;
+		out.push(item);
+	}
+	return out;
+}
+/** Same guard for a `run` result: anything malformed becomes `undefined` (nothing to do). */
+function normalizePaletteRunResult(input, source, defaultGroup) {
+	if (!input || typeof input !== "object") return void 0;
+	const r = input;
+	switch (r.kind) {
+		case "items": {
+			const out = {
+				kind: "items",
+				items: normalizePaletteItems(r.items, source, defaultGroup)
+			};
+			const title = str(r.title, 200);
+			const placeholder = str(r.placeholder, 200);
+			if (title) out.title = title;
+			if (placeholder) out.placeholder = placeholder;
+			return out;
+		}
+		case "prompt":
+		case "insert": {
+			const text = str(r.text, 2e4);
+			return text ? {
+				kind: r.kind,
+				text
+			} : void 0;
+		}
+		case "notify": {
+			const text = str(r.text, 1e3);
+			if (!text) return void 0;
+			return {
+				kind: "notify",
+				text,
+				tone: r.tone === "warn" || r.tone === "error" ? r.tone : "info"
+			};
+		}
+		default: return;
+	}
+}
+/** Type guard hosts use before forwarding a payload from an untrusted provider. */
+function isPaletteContext(v) {
+	if (!v || typeof v !== "object") return false;
+	const c = v;
+	return (c.host === "gui" || c.host === "tui") && (c.cwd === void 0 || typeof c.cwd === "string") && (c.sessionId === void 0 || typeof c.sessionId === "string") && (c.busy === void 0 || typeof c.busy === "boolean");
+}
+//#endregion
+//#region src/chat/panels.ts
+const INBOX_PANEL_ID = "inbox";
+const TODOS_PANEL_ID = "todos";
+const ARTIFACTS_PANEL_ID = "artifacts";
+const DIFFS_PANEL_ID = "diffs";
+const FILES_PANEL_ID = "files";
+const BROWSER_PANEL_ID = "browser";
+const TERMINAL_PANEL_ID = "terminal";
+const BUILTIN_PANEL_TABS = [
+	{
+		id: INBOX_PANEL_ID,
+		label: "Inbox",
+		icon: {
+			gui: "i-ph-tray",
+			tui: "✉"
+		},
+		builtin: true
+	},
+	{
+		id: TODOS_PANEL_ID,
+		label: "Todos",
+		icon: {
+			gui: "i-ph-list-checks",
+			tui: "▣"
+		},
+		builtin: true
+	},
+	{
+		id: ARTIFACTS_PANEL_ID,
+		label: "Artifacts",
+		icon: {
+			gui: "i-ph-cube",
+			tui: "◆"
+		},
+		builtin: true
+	},
+	{
+		id: DIFFS_PANEL_ID,
+		label: "Diffs",
+		icon: {
+			gui: "i-ph-git-diff",
+			tui: "±"
+		},
+		builtin: true
+	},
+	{
+		id: FILES_PANEL_ID,
+		label: "Files",
+		icon: {
+			gui: "i-ph-tree-structure",
+			tui: "▤"
+		},
+		builtin: true
+	},
+	{
+		id: BROWSER_PANEL_ID,
+		label: "Browser",
+		icon: {
+			gui: "i-ph-globe-simple",
+			tui: "◎"
+		},
+		builtin: true
+	},
+	{
+		id: TERMINAL_PANEL_ID,
+		label: "Terminal",
+		icon: {
+			gui: "i-ph-terminal-window",
+			tui: "❯"
+		},
+		builtin: true
+	}
+];
+/** Built-ins first, then extension panels in registry (load) order. */
+function buildPanelCatalog(extensionPanels, options = {}) {
+	const tabs = [];
+	for (const tab of BUILTIN_PANEL_TABS) {
+		if (tab.id === "artifacts" && options.showArtifacts === false) continue;
+		if (options.omitBuiltins?.includes(tab.id)) continue;
+		tabs.push(tab);
+	}
+	const seen = new Set(tabs.map((t) => t.id));
+	for (const p of extensionPanels) {
+		if (seen.has(p.id)) continue;
+		seen.add(p.id);
+		tabs.push({
+			id: p.id,
+			label: p.label,
+			builtin: false,
+			owner: p.owner,
+			...p.icon ? { icon: p.icon } : {}
+		});
+	}
+	return tabs;
+}
+const INITIAL_PANEL_STATE = {
+	open: false,
+	activeId: null,
+	userPicks: 0,
+	proactiveAt: 0
+};
+/** Add a tab to the host's pinned strip (idempotent, keeps order). */
+function pinTab(pinned, id) {
+	return pinned.includes(id) ? pinned : [...pinned, id];
+}
+/**
+* Apply a user reorder of the VISIBLE strip to the pinned list. `pinned` can
+* hold ids the catalog no longer shows (an extension disabled for this cwd);
+* they keep their slots, and the visible ids fill the remaining slots in the
+* new order, so re-enabling the extension brings its tab back where it was.
+* Ids in `visible` that aren't pinned are ignored. Returns `pinned` itself
+* when nothing moved.
+*/
+function reorderTabs(pinned, visible) {
+	const shown = new Set(visible.filter((id) => pinned.includes(id)));
+	const order = visible.filter((id) => shown.has(id));
+	let next = 0;
+	const out = pinned.map((id) => shown.has(id) ? order[next++] : id);
+	return out.every((id, i) => id === pinned[i]) ? pinned : out;
+}
+/**
+* Move one visible tab `delta` slots within the visible strip (keyboard
+* reorder), clamped at the ends. Hidden pinned ids keep their slots.
+*/
+function moveTab(pinned, visible, id, delta) {
+	const from = visible.indexOf(id);
+	if (from < 0) return pinned;
+	const to = Math.max(0, Math.min(visible.length - 1, from + delta));
+	if (to === from) return pinned;
+	const order = [...visible];
+	order.splice(from, 1);
+	order.splice(to, 0, id);
+	return reorderTabs(pinned, order);
+}
+/** The user clicked a tab (or a keybinding cycled to it). Always honoured, always opens. */
+function pickTab(state, id) {
+	return {
+		...state,
+		open: true,
+		activeId: id,
+		userPicks: state.userPicks + 1
+	};
+}
+function togglePanel(state) {
+	return {
+		...state,
+		open: !state.open
+	};
+}
+function closePanel(state) {
+	return {
+		...state,
+		open: false
+	};
+}
+/**
+* Agent / extension asked to show a tab. Honoured only until the user has
+* picked a tab themselves (a badge that flipped must never steal the tab);
+* otherwise the request is dropped and the state returned unchanged.
+*/
+function openProactive(state, id) {
+	if (state.userPicks !== state.proactiveAt) return state;
+	return {
+		...state,
+		open: true,
+		activeId: id
+	};
+}
+/**
+* The agent is blocked on the user (a plan to approve, a question to
+* answer): show the tab regardless of earlier picks. Costs at most a tab
+* switch, and nothing in that tab decides implicitly. Not a user pick, so
+* it does not lock out later proactive opens.
+*/
+function openForAttention(state, id) {
+	if (state.open && state.activeId === id) return state;
+	return {
+		...state,
+		open: true,
+		activeId: id
+	};
+}
+/**
+* Resolve the tab to render: the active one when it still exists, else the
+* first tab, else `null` (empty catalog). Keeps state stable when an
+* extension is disabled and its tab vanishes.
+*/
+function resolveActiveTab(state, catalog) {
+	if (catalog.length === 0) return null;
+	return catalog.find((t) => t.id === state.activeId) ?? catalog[0];
+}
+/** Cycle to the next / previous tab (wraps). Counts as a user pick. */
+function cycleTab(state, catalog, direction) {
+	if (catalog.length === 0) return state;
+	const current = resolveActiveTab(state, catalog);
+	const next = catalog[((current ? catalog.findIndex((t) => t.id === current.id) : 0) + direction + catalog.length) % catalog.length];
+	return pickTab(state, next.id);
+}
+//#endregion
+//#region src/chat/prompt-text.ts
+function tidyPromptText(text, refs) {
+	const trimmed = text.trimEnd();
+	if (!/\n{3,}/.test(trimmed)) return {
+		text: trimmed,
+		refs: refs.filter((r) => r.end <= trimmed.length)
+	};
+	const map = Array.from({ length: trimmed.length + 1 });
+	let out = "";
+	for (let i = 0; i < trimmed.length;) {
+		if (/^\n{3,}/.exec(trimmed.slice(i, i + 64)) && trimmed[i] === "\n") {
+			let end = i;
+			while (trimmed[end] === "\n") end++;
+			for (let k = i; k < end; k++) map[k] = out.length + Math.min(k - i, 2);
+			out += "\n\n";
+			i = end;
+			continue;
+		}
+		map[i] = out.length;
+		out += trimmed[i];
+		i++;
+	}
+	map[trimmed.length] = out.length;
+	const remapped = refs.filter((r) => r.end <= trimmed.length).map((r) => ({
+		...r,
+		start: map[r.start],
+		end: map[r.end]
+	}));
+	return {
+		text: out,
+		refs: remapped
+	};
+}
+//#endregion
+//#region src/chat/stream-failure.ts
+const FAILED = /(?:^|\n\n)\[✗ Streaming failed (before any output|mid-output)(?:: ([\s\S]*))?\.?\]\s*$/;
+const ABORTED = /(?:^|\n\n)\[⏹ Streaming was aborted\.\]\s*$/;
+/** Split a reply into what the model wrote and the stop marker at its end, if any. */
+function splitStreamFailure(text) {
+	const aborted = ABORTED.exec(text);
+	if (aborted) {
+		const before = text.slice(0, aborted.index).trimEnd();
+		return {
+			text: before,
+			failure: {
+				message: "",
+				midOutput: before !== "",
+				aborted: true
+			}
+		};
+	}
+	const m = FAILED.exec(text);
+	if (!m) return {
+		text,
+		failure: null
+	};
+	return {
+		text: text.slice(0, m.index).trimEnd(),
+		failure: {
+			message: (m[2] ?? "").trim(),
+			midOutput: m[1] === "mid-output",
+			aborted: false
+		}
+	};
+}
+/** Cheap pre-check before splitting: the text may end in a stop marker. */
+function mayHaveStreamFailure(text) {
+	return text.includes("[✗ Streaming failed") || text.includes("[⏹ Streaming was aborted");
+}
+/** What the "continue" action sends after a run that had done work. */
+const CONTINUE_PROMPT = "Continue from where you stopped.";
+//#endregion
+//#region src/chat/stream-rate.ts
+const EMPTY_RATE = {
+	turnId: null,
+	samples: [],
+	estimated: null,
+	rate: null
+};
+/** Trailing window the rate is measured over. */
+const WINDOW_MS = 3e3;
+/** Minimum span before a reading counts: shorter spans are one or two ticks of noise. */
+const MIN_SPAN_MS = 1200;
+/** Faster than any served model today (the fastest wafer-scale ones run ~3k): a reading above is a glitch. */
+const MAX_PLAUSIBLE_RATE = 6e3;
+/** Weight of a new reading in the smoothed rate. */
+const SMOOTHING = .35;
+function stepStreamRate(state, sample) {
+	const point = {
+		t: sample.elapsedMs,
+		n: sample.outputTokens
+	};
+	if (state.turnId !== sample.turnId) return {
+		turnId: sample.turnId,
+		samples: [point],
+		estimated: sample.estimated,
+		rate: null
+	};
+	const last = state.samples[state.samples.length - 1];
+	if (state.estimated === true && !sample.estimated || last !== void 0 && point.n < last.n || !last) return {
+		...state,
+		samples: [point],
+		estimated: sample.estimated
+	};
+	if (point.t <= last.t) return state;
+	const kept = [...state.samples, point];
+	let start = 0;
+	while (start < kept.length - 2 && kept[start + 1].t <= point.t - WINDOW_MS) start++;
+	const samples = kept.slice(start);
+	const base = samples[0];
+	const span = point.t - base.t;
+	let rate = state.rate;
+	if (span >= MIN_SPAN_MS) {
+		const reading = (point.n - base.n) / span * 1e3;
+		if (reading >= 0 && reading <= 6e3) rate = rate === null ? reading : rate + SMOOTHING * (reading - rate);
+	}
+	return {
+		turnId: state.turnId,
+		samples,
+		estimated: sample.estimated,
+		rate
+	};
+}
+/** Whole tokens per second for display, or `null` when there is no honest reading. */
+function streamRateValue(state) {
+	if (state.rate === null) return null;
+	const rounded = Math.round(state.rate);
+	return rounded > 0 ? rounded : null;
+}
+//#endregion
+//#region src/chat/todo-edits.ts
+/**
+* Prefix for ids minted here, distinguishing user-authored rows from the
+* model's own ids in a session file. Purely diagnostic — nothing branches on
+* it — but it makes "who added this" answerable after the fact.
+*/
+const USER_TODO_ID_PREFIX = "user-";
+/**
+* Mint an id that cannot collide with an existing row.
+*
+* Counter-based rather than random: a stable, readable id keeps session diffs
+* legible, and the collision check makes it safe against ids the model already
+* used (including previous `user-*` ones after a reload).
+*/
+function nextTodoId(items) {
+	const taken = new Set(items.map((i) => i.id));
+	for (let n = 1;; n++) {
+		const id = `${USER_TODO_ID_PREFIX}${n}`;
+		if (!taken.has(id)) return id;
+	}
+}
+/**
+* Append a todo. Returns the list unchanged when `content` is blank — an empty
+* row is never what the user meant, and rejecting it here means every caller
+* (keyboard, click, future GUI) gets the same guard.
+*/
+function addTodo(items, content) {
+	const trimmed = content.trim();
+	if (!trimmed) return [...items];
+	return [...items, {
+		id: nextTodoId(items),
+		content: trimmed,
+		status: "pending"
+	}];
+}
+/**
+* Replace one todo's text. Blank content is rejected (see {@link addTodo}); an
+* unknown id is a no-op rather than an error, because the list can be replaced
+* by a `todowrite` between render and keypress.
+*/
+function editTodo(items, id, content) {
+	const trimmed = content.trim();
+	if (!trimmed) return [...items];
+	return items.map((item) => item.id === id ? {
+		...item,
+		content: trimmed
+	} : item);
+}
+/** Drop one todo. Unknown id is a no-op, same rationale as {@link editTodo}. */
+function removeTodo(items, id) {
+	return items.filter((item) => item.id !== id);
+}
+/** Drop everything. Separate from `removeTodo` so the caller's intent is explicit at the call site. */
+function clearTodos() {
+	return [];
+}
+/**
+* Advance a todo's status one step: pending → in_progress → completed →
+* pending. `cancelled` also lands on `pending`, so a dropped item can be
+* revived without a dedicated key.
+*
+* Cycling INTO `in_progress` demotes any other in-progress row to `pending`:
+* the list's whole purpose is "what is being worked on right now", and two
+* live rows make that unanswerable — `TodoIndicator`'s successor
+* (`todoProgressLabel`) reads the first one and would silently ignore the rest.
+*/
+function cycleTodoStatus(items, id) {
+	const target = items.find((item) => item.id === id);
+	if (!target) return [...items];
+	const next = nextStatus(target.status);
+	return items.map((item) => {
+		if (item.id === id) return {
+			...item,
+			status: next
+		};
+		if (next === "in_progress" && item.status === "in_progress") return {
+			...item,
+			status: "pending"
+		};
+		return item;
+	});
+}
+function nextStatus(status) {
+	switch (status) {
+		case "pending": return "in_progress";
+		case "in_progress": return "completed";
+		default: return "pending";
+	}
+}
+/**
+* Steering text for a "retry this todo" request.
+*
+* Quotes the content so a model reading it can match the row verbatim against
+* its own list, and names the status because "retry" means different things
+* for a row it believes is `completed` versus one it abandoned as `cancelled`.
+* Shared by the TUI and GUI modals so both surfaces steer with byte-identical
+* text; pinned by a test rather than living inside a JSX callback.
+*/
+function buildTodoRetryMessage(item) {
+	return `Retry this todo (currently ${item.status}): "${item.content}"`;
+}
+//#endregion
+export { validateMcpForm as $, openProactive as A, createPaletteRanker as B, TERMINAL_PANEL_ID as C, parseSessionKey as Ct, cycleTab as D, UnknownHostIdError as Dt, closePanel as E, HostRemovedError as Et, togglePanel as F, normalizePaletteRunResult as G, groupPaletteRows as H, PALETTE_LIMITS as I, NOTICE_GLYPH as J, pushPaletteRecent as K, PALETTE_RECENTS_MAX as L, pinTab as M, reorderTabs as N, moveTab as O, createHostIndex as Ot, resolveActiveTab as P, splitCommandLine as Q, PALETTE_RECENT_GROUP as R, INITIAL_PANEL_STATE as S, SESSION_KEY_SEPARATOR as St, buildPanelCatalog as T, AmbiguousHostIdError as Tt, isPaletteContext as U, fuzzyMatch as V, normalizePaletteItems as W, MCP_TRANSPORTS as X, modelDisplayName as Y, parseKeyValueLines as Z, BROWSER_PANEL_ID as _, buildVisibleAuthRows as _t, editTodo as a, machineDirListing as at, FILES_PANEL_ID as b, parentProviderKey as bt, EMPTY_RATE as c, INSTRUCTION_PREVIEW_LINE_CAP as ct, streamRateValue as d, instructionPreviewLines as dt, MACHINE_LINK_STATE_TEXT as et, CONTINUE_PROMPT as f, commandGist as ft, ARTIFACTS_PANEL_ID as g, toolPhrase as gt, tidyPromptText as h, toolOverview as ht, cycleTodoStatus as i, machineBlockedReason as it, pickTab as j, openForAttention as k, MAX_PLAUSIBLE_RATE as l, buildVisibleInstructionRows as lt, splitStreamFailure as m, summarizeTools as mt, buildTodoRetryMessage as n, environmentLabel as nt, nextTodoId as o, machineWaiting as ot, mayHaveStreamFailure as p, messagePreview as pt, rankPaletteItems as q, clearTodos as r, lastSeenText as rt, removeTodo as s, orderByMachine as st, addTodo as t, MACHINE_NOTICE_LABEL as tt, stepStreamRate as u, instructionOriginBadge as ut, BUILTIN_PANEL_TABS as v, indexOfProviderRow as vt, TODOS_PANEL_ID as w, sessionKey as wt, INBOX_PANEL_ID as x, selectableSources as xt, DIFFS_PANEL_ID as y, isExpandableProvider as yt, PALETTE_RESULT_MAX as z };
+
+//# sourceMappingURL=todo-edits-Dn251YUP.js.map