@pixelzx/genesis 2026.6.28 → 2026.7.8

package/dist/tui-cli-B9Emgd5Q.js

@@ -0,0 +1,4585 @@
+import { i as formatErrorMessage } from "./errors-CufR9eHH.js";
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DPP_aYVc.js";
+import { h as loggingState } from "./logger-BRmjL88V.js";
+import { n as defaultRuntime } from "./runtime-DDkDH9fa.js";
+import { i as visibleWidth, r as stripAnsi$1 } from "./ansi-cSbP14w0.js";
+import { u as setConsoleSubsystemFilter } from "./subsystem-CNq69MoE.js";
+import { t as formatDocsLink } from "./links-C1-jbHJx.js";
+import { r as theme$1 } from "./theme-DD6pQv2_.js";
+import { n as VERSION } from "./version-qod78efn.js";
+import { n as assertExplicitGatewayAuthModeWhenBothConfigured } from "./auth-mode-policy-DNpWBcwq.js";
+import { a as isLoopbackHost } from "./net-BzaeD_3Q.js";
+import { a as loadConfig } from "./io-Cy5vajWd.js";
+import { s as parseAgentSessionKey } from "./session-key-utils-DDwuwYKT.js";
+import { c as normalizeAgentId, l as normalizeMainKey, r as buildAgentMainSessionKey } from "./session-key-CI3KvTQC.js";
+import { r as DEFAULT_PROVIDER } from "./defaults-Dg3aovOH.js";
+import { a as resolveAgentIdByWorkspacePath, p as resolveSessionAgentId, x as resolveDefaultAgentId } from "./agent-scope-BUYwVohk.js";
+import "./config-DYHZ3jG1.js";
+import { n as GatewayClientRequestError, t as GatewayClient } from "./client-DQsu_IXu.js";
+import { i as GATEWAY_CLIENT_NAMES, r as GATEWAY_CLIENT_MODES, t as GATEWAY_CLIENT_CAPS } from "./client-info-CjxzJxIU.js";
+import { r as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-core-BsSExTA7.js";
+import "./message-channel-8hna3ogc.js";
+import "./protocol-DgMCJAA_.js";
+import { g as resolveResponseUsageMode, m as normalizeUsageDisplay, r as listThinkingLevelLabels, t as formatThinkingLevels } from "./thinking-BxrysYYp.js";
+import { p as resolveThinkingDefault, t as buildAllowedModelSet } from "./model-selection-D-mV4REq.js";
+import { t as loadCombinedSessionStoreForGateway } from "./combined-store-gateway-CZ0lKQMU.js";
+import { o as updateSessionStore } from "./store-BtHVDH2Q.js";
+import "./sessions-C1_80mqv.js";
+import { l as onAgentEvent } from "./agent-events-DxDJre6N.js";
+import { r as formatTokenCount } from "./usage-format-DlUyhc8n.js";
+import { c as stripEnvelopeFromMessages, i as readSessionMessages, n as capArrayByJsonBytes } from "./session-utils.fs-moBTdnuM.js";
+import { r as extractAssistantVisibleText } from "./chat-message-content-BJIvXbdD.js";
+import { i as stripInlineDirectiveTagsForDisplay } from "./directive-tags-DoksNPSD.js";
+import { r as stripLeadingInboundMetadata } from "./strip-inbound-meta-Bk4Y0lw3.js";
+import { a as loadSessionEntry, d as resolveGatewaySessionStoreTarget, n as listAgentsForGateway, o as migrateAndPruneGatewaySessionStoreKey, p as resolveSessionModelRef, r as listSessionsFromStore } from "./session-utils-otyfumhD.js";
+import { v as setEmbeddedMode } from "./genesis-tools-Bkxp7zlI.js";
+import "./pi-embedded-helpers-DNexwzyg.js";
+import { D as formatRawAssistantErrorForUi, m as isAuthErrorMessage } from "./sanitize-user-facing-text-DKqUCgHB.js";
+import { a as isSilentReplyText, n as SILENT_REPLY_TOKEN } from "./tokens-DUMwK-9w.js";
+import { r as resolveToolDisplay, t as formatToolDetail } from "./tool-display-D7v2v3qV.js";
+import { l as resolveExplicitGatewayAuth, n as buildGatewayConnectionDetails, s as ensureExplicitGatewayAuth } from "./call-DgFhP0IB.js";
+import { t as parseTimeoutMs } from "./parse-timeout-XtJqYUc8.js";
+import { r as resolveSessionInfoModelSelection } from "./model-selection-display-BiU1dZp5.js";
+import { n as listChatCommands, r as listChatCommandsForConfig } from "./commands-registry-list-CINBp5YN.js";
+import "./commands-registry-B5egnRQ_.js";
+import { n as formatTimeAgo, t as formatRelativeTimestamp } from "./format-relative-B39tx_LC.js";
+import { t as normalizeGroupActivation } from "./group-activation-BiaHgDAZ.js";
+import { r as agentCommandFromIngress } from "./agent-command-Baehh2jJ.js";
+import { t as createDefaultDeps } from "./deps-CMhJYvQj.js";
+import { _ as loadGatewayModelCatalog } from "./http-utils-LFOvdepz.js";
+import { T as augmentChatHistoryWithCliSessionImports, a as enforceChatHistoryFinalBudget, c as sanitizeChatHistoryMessages, o as replaceOversizedChatHistoryMessages, r as augmentChatHistoryWithCanvasBlocks, s as resolveEffectiveChatHistoryMaxChars, t as CHAT_HISTORY_MAX_SINGLE_MESSAGE_BYTES, w as getMaxChatHistoryMessagesBytes } from "./chat-C-K_PnVS.js";
+import { n as timestampOptsFromConfig, t as injectTimestamp } from "./agent-timestamp-LCcsN9SL.js";
+import { a as performGatewaySessionReset } from "./session-reset-service-Cs7o8vTZ.js";
+import { t as applySessionsPatchToStore } from "./sessions-patch-XzBTc4fY.js";
+import { t as resolveGatewayInteractiveSurfaceAuth } from "./auth-surface-resolution-DKXlV4bg.js";
+import { n as TUI_SETUP_AUTH_SOURCE_ENV, t as TUI_SETUP_AUTH_SOURCE_CONFIG } from "./setup-launch-env-UVaxdANl.js";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { execFileSync, spawn } from "node:child_process";
+import chalk from "chalk";
+import { randomUUID } from "node:crypto";
+import { Box, CombinedAutocompleteProvider, Container, Editor, Input, Key, Loader, Markdown, ProcessTerminal, SelectList, SettingsList, Spacer, TUI, Text, isKeyRelease, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+//#region src/tui/commands.ts
+const VERBOSE_LEVELS = ["on", "off"];
+const TRACE_LEVELS = ["on", "off"];
+const FAST_LEVELS = [
+	"status",
+	"on",
+	"off"
+];
+const REASONING_LEVELS = ["on", "off"];
+const ELEVATED_LEVELS = [
+	"on",
+	"off",
+	"ask",
+	"full"
+];
+const ACTIVATION_LEVELS = ["mention", "always"];
+const USAGE_FOOTER_LEVELS = [
+	"off",
+	"tokens",
+	"full"
+];
+const COMMAND_ALIASES = {
+	elev: "elevated",
+	gwstatus: "gateway-status"
+};
+function createLevelCompletion(levels) {
+	return (prefix) => levels.filter((value) => value.startsWith(normalizeLowercaseStringOrEmpty(prefix))).map((value) => ({
+		value,
+		label: value
+	}));
+}
+function parseCommand(input) {
+	const trimmed = input.replace(/^\//, "").trim();
+	if (!trimmed) return {
+		name: "",
+		args: ""
+	};
+	const [name, ...rest] = trimmed.split(/\s+/);
+	const normalized = normalizeLowercaseStringOrEmpty(name);
+	return {
+		name: COMMAND_ALIASES[normalized] ?? normalized,
+		args: rest.join(" ").trim()
+	};
+}
+function getSlashCommands(options = {}) {
+	const thinkLevels = listThinkingLevelLabels(options.provider, options.model);
+	const verboseCompletions = createLevelCompletion(VERBOSE_LEVELS);
+	const traceCompletions = createLevelCompletion(TRACE_LEVELS);
+	const fastCompletions = createLevelCompletion(FAST_LEVELS);
+	const reasoningCompletions = createLevelCompletion(REASONING_LEVELS);
+	const usageCompletions = createLevelCompletion(USAGE_FOOTER_LEVELS);
+	const elevatedCompletions = createLevelCompletion(ELEVATED_LEVELS);
+	const activationCompletions = createLevelCompletion(ACTIVATION_LEVELS);
+	const commands = [
+		{
+			name: "help",
+			description: "Show slash command help"
+		},
+		{
+			name: "gateway-status",
+			description: "Show gateway status summary"
+		},
+		{
+			name: "gwstatus",
+			description: "Alias for /gateway-status"
+		},
+		...options.local ? [{
+			name: "auth",
+			description: "Run provider auth/login flow"
+		}] : [],
+		{
+			name: "agent",
+			description: "Switch agent (or open picker)"
+		},
+		{
+			name: "agents",
+			description: "Open agent picker"
+		},
+		{
+			name: "session",
+			description: "Switch session (or open picker)"
+		},
+		{
+			name: "sessions",
+			description: "Open session picker"
+		},
+		{
+			name: "model",
+			description: "Set model (or open picker)"
+		},
+		{
+			name: "models",
+			description: "Open model picker"
+		},
+		{
+			name: "think",
+			description: "Set thinking level",
+			getArgumentCompletions: (prefix) => thinkLevels.filter((v) => v.startsWith(normalizeLowercaseStringOrEmpty(prefix))).map((value) => ({
+				value,
+				label: value
+			}))
+		},
+		{
+			name: "fast",
+			description: "Set fast mode on/off",
+			getArgumentCompletions: fastCompletions
+		},
+		{
+			name: "verbose",
+			description: "Set verbose on/off",
+			getArgumentCompletions: verboseCompletions
+		},
+		{
+			name: "trace",
+			description: "Set trace on/off",
+			getArgumentCompletions: traceCompletions
+		},
+		{
+			name: "reasoning",
+			description: "Set reasoning on/off",
+			getArgumentCompletions: reasoningCompletions
+		},
+		{
+			name: "usage",
+			description: "Toggle per-response usage line",
+			getArgumentCompletions: usageCompletions
+		},
+		{
+			name: "elevated",
+			description: "Set elevated on/off/ask/full",
+			getArgumentCompletions: elevatedCompletions
+		},
+		{
+			name: "elev",
+			description: "Alias for /elevated",
+			getArgumentCompletions: elevatedCompletions
+		},
+		{
+			name: "activation",
+			description: "Set group activation",
+			getArgumentCompletions: activationCompletions
+		},
+		{
+			name: "abort",
+			description: "Abort active run"
+		},
+		{
+			name: "new",
+			description: "Reset the session"
+		},
+		{
+			name: "reset",
+			description: "Reset the session"
+		},
+		{
+			name: "settings",
+			description: "Open settings"
+		},
+		{
+			name: "exit",
+			description: "Exit the TUI"
+		},
+		{
+			name: "quit",
+			description: "Exit the TUI"
+		}
+	];
+	const seen = new Set(commands.map((command) => command.name));
+	const gatewayCommands = options.cfg ? listChatCommandsForConfig(options.cfg) : listChatCommands();
+	for (const command of gatewayCommands) {
+		const aliases = command.textAliases.length > 0 ? command.textAliases : [`/${command.key}`];
+		for (const alias of aliases) {
+			const name = alias.replace(/^\//, "").trim();
+			if (!name || seen.has(name)) continue;
+			seen.add(name);
+			commands.push({
+				name,
+				description: command.description
+			});
+		}
+	}
+	return commands;
+}
+function helpText(options = {}) {
+	const thinkLevels = formatThinkingLevels(options.provider, options.model, "|");
+	return [
+		"Slash commands:",
+		"/help",
+		"/commands",
+		"/status",
+		"/gateway-status",
+		"/gwstatus",
+		...options.local ? ["/auth [provider]"] : [],
+		"/agent <id> (or /agents)",
+		"/session <key> (or /sessions)",
+		"/model <provider/model> (or /models)",
+		`/think <${thinkLevels}>`,
+		"/fast <status|on|off>",
+		"/verbose <on|off>",
+		"/trace <on|off>",
+		"/reasoning <on|off>",
+		"/usage <off|tokens|full>",
+		"/elevated <on|off|ask|full>",
+		"/elev <on|off|ask|full>",
+		"/activation <mention|always>",
+		"/new or /reset",
+		"/abort",
+		"/settings",
+		"/exit"
+	].join("\n");
+}
+//#endregion
+//#region src/tui/theme/theme.ts
+const DARK_TEXT = "#E8E3D5";
+const LIGHT_TEXT = "#1E1E1E";
+const XTERM_LEVELS = [
+	0,
+	95,
+	135,
+	175,
+	215,
+	255
+];
+function channelToSrgb(value) {
+	const normalized = value / 255;
+	return normalized <= .03928 ? normalized / 12.92 : ((normalized + .055) / 1.055) ** 2.4;
+}
+function relativeLuminanceRgb(r, g, b) {
+	const red = channelToSrgb(r);
+	const green = channelToSrgb(g);
+	const blue = channelToSrgb(b);
+	return .2126 * red + .7152 * green + .0722 * blue;
+}
+function relativeLuminanceHex(hex) {
+	return relativeLuminanceRgb(Number.parseInt(hex.slice(1, 3), 16), Number.parseInt(hex.slice(3, 5), 16), Number.parseInt(hex.slice(5, 7), 16));
+}
+function contrastRatio(background, foregroundHex) {
+	const foreground = relativeLuminanceHex(foregroundHex);
+	const lighter = Math.max(background, foreground);
+	const darker = Math.min(background, foreground);
+	return (lighter + .05) / (darker + .05);
+}
+function pickHigherContrastText(r, g, b) {
+	const background = relativeLuminanceRgb(r, g, b);
+	return contrastRatio(background, LIGHT_TEXT) >= contrastRatio(background, DARK_TEXT);
+}
+function isLightBackground() {
+	const explicit = normalizeOptionalLowercaseString(process.env.GENESIS_THEME);
+	if (explicit === "light") return true;
+	if (explicit === "dark") return false;
+	const colorfgbg = process.env.COLORFGBG;
+	if (colorfgbg && colorfgbg.length <= 64) {
+		const sep = colorfgbg.lastIndexOf(";");
+		const bg = Number.parseInt(sep >= 0 ? colorfgbg.slice(sep + 1) : colorfgbg, 10);
+		if (bg >= 0 && bg <= 255) {
+			if (bg <= 15) return bg === 7 || bg === 15;
+			if (bg >= 232) return bg >= 244;
+			const cubeIndex = bg - 16;
+			const bVal = XTERM_LEVELS[cubeIndex % 6];
+			const gVal = XTERM_LEVELS[Math.floor(cubeIndex / 6) % 6];
+			const rVal = XTERM_LEVELS[Math.floor(cubeIndex / 36)];
+			return pickHigherContrastText(rVal, gVal, bVal);
+		}
+	}
+	return false;
+}
+const palette = isLightBackground() ? {
+	text: "#1E1E1E",
+	dim: "#5B6472",
+	accent: "#B45309",
+	accentSoft: "#C2410C",
+	border: "#5B6472",
+	userBg: "#F3F0E8",
+	userText: "#1E1E1E",
+	systemText: "#4B5563",
+	toolPendingBg: "#EFF6FF",
+	toolSuccessBg: "#ECFDF5",
+	toolErrorBg: "#FEF2F2",
+	toolTitle: "#B45309",
+	toolOutput: "#374151",
+	quote: "#1D4ED8",
+	quoteBorder: "#2563EB",
+	code: "#92400E",
+	codeBlock: "#F9FAFB",
+	codeBorder: "#92400E",
+	link: "#047857",
+	error: "#DC2626",
+	success: "#047857"
+} : {
+	text: "#E8E3D5",
+	dim: "#7B7F87",
+	accent: "#F6C453",
+	accentSoft: "#F2A65A",
+	border: "#3C414B",
+	userBg: "#2B2F36",
+	userText: "#F3EEE0",
+	systemText: "#9BA3B2",
+	toolPendingBg: "#1F2A2F",
+	toolSuccessBg: "#1E2D23",
+	toolErrorBg: "#2F1F1F",
+	toolTitle: "#F6C453",
+	toolOutput: "#E1DACB",
+	quote: "#8CC8FF",
+	quoteBorder: "#3B4D6B",
+	code: "#F0C987",
+	codeBlock: "#1E232A",
+	codeBorder: "#343A45",
+	link: "#7DD3A5",
+	error: "#F97066",
+	success: "#7DD3A5"
+};
+const fg = (hex) => (text) => chalk.hex(hex)(text);
+const bg = (hex) => (text) => chalk.bgHex(hex)(text);
+/**
+* Render code blocks with the theme code color without pulling a parser into the base TUI path.
+* Returns an array of lines with ANSI escape codes.
+*/
+function highlightCode(code) {
+	return code.split("\n").map((line) => fg(palette.code)(line));
+}
+const theme = {
+	fg: fg(palette.text),
+	assistantText: (text) => text,
+	dim: fg(palette.dim),
+	accent: fg(palette.accent),
+	accentSoft: fg(palette.accentSoft),
+	success: fg(palette.success),
+	error: fg(palette.error),
+	header: (text) => chalk.bold(fg(palette.accent)(text)),
+	system: fg(palette.systemText),
+	userBg: bg(palette.userBg),
+	userText: fg(palette.userText),
+	toolTitle: fg(palette.toolTitle),
+	toolOutput: fg(palette.toolOutput),
+	toolPendingBg: bg(palette.toolPendingBg),
+	toolSuccessBg: bg(palette.toolSuccessBg),
+	toolErrorBg: bg(palette.toolErrorBg),
+	border: fg(palette.border),
+	bold: (text) => chalk.bold(text),
+	italic: (text) => chalk.italic(text)
+};
+const markdownTheme = {
+	heading: (text) => chalk.bold(fg(palette.accent)(text)),
+	link: (text) => fg(palette.link)(text),
+	linkUrl: (text) => chalk.dim(text),
+	code: (text) => fg(palette.code)(text),
+	codeBlock: (text) => fg(palette.code)(text),
+	codeBlockBorder: (text) => fg(palette.codeBorder)(text),
+	quote: (text) => fg(palette.quote)(text),
+	quoteBorder: (text) => fg(palette.quoteBorder)(text),
+	hr: (text) => fg(palette.border)(text),
+	listBullet: (text) => fg(palette.accentSoft)(text),
+	bold: (text) => chalk.bold(text),
+	italic: (text) => chalk.italic(text),
+	strikethrough: (text) => chalk.strikethrough(text),
+	underline: (text) => chalk.underline(text),
+	highlightCode
+};
+const baseSelectListTheme = {
+	selectedPrefix: (text) => fg(palette.accent)(text),
+	selectedText: (text) => chalk.bold(fg(palette.accent)(text)),
+	description: (text) => fg(palette.dim)(text),
+	scrollInfo: (text) => fg(palette.dim)(text),
+	noMatch: (text) => fg(palette.dim)(text)
+};
+const selectListTheme = baseSelectListTheme;
+const filterableSelectListTheme = {
+	...baseSelectListTheme,
+	filterLabel: (text) => fg(palette.dim)(text)
+};
+const settingsListTheme = {
+	label: (text, selected) => selected ? chalk.bold(fg(palette.accent)(text)) : fg(palette.text)(text),
+	value: (text, selected) => selected ? fg(palette.accentSoft)(text) : fg(palette.dim)(text),
+	description: (text) => fg(palette.systemText)(text),
+	cursor: fg(palette.accent)("→ "),
+	hint: (text) => fg(palette.dim)(text)
+};
+const editorTheme = {
+	borderColor: (text) => fg(palette.border)(text),
+	selectList: selectListTheme
+};
+const searchableSelectListTheme = {
+	...baseSelectListTheme,
+	searchPrompt: (text) => fg(palette.accentSoft)(text),
+	searchInput: (text) => fg(palette.text)(text),
+	matchHighlight: (text) => chalk.bold(fg(palette.accent)(text))
+};
+//#endregion
+//#region src/tui/osc8-hyperlinks.ts
+const SGR_PATTERN = "\\x1b\\[[0-9;]*m";
+const OSC8_PATTERN = "\\x1b\\]8;;.*?(?:\\x07|\\x1b\\\\)";
+const ANSI_RE = new RegExp(`${SGR_PATTERN}|${OSC8_PATTERN}`, "g");
+const SGR_START_RE = new RegExp(`^${SGR_PATTERN}`);
+const OSC8_START_RE = new RegExp(`^${OSC8_PATTERN}`);
+/**
+* Extract all unique URLs from raw markdown text.
+* Finds both bare URLs and markdown link hrefs [text](url).
+*/
+function extractUrls(markdown) {
+	const urls = /* @__PURE__ */ new Set();
+	const mdLinkRe = /\[(?:[^\]]*)\]\(\s*<?(https?:\/\/[^)\s>]+)>?(?:\s+["'][^"']*["'])?\s*\)/g;
+	let m;
+	while ((m = mdLinkRe.exec(markdown)) !== null) urls.add(m[1]);
+	const stripped = markdown.replace(/\[(?:[^\]]*)\]\(\s*<?https?:\/\/[^)\s>]+>?(?:\s+["'][^"']*["'])?\s*\)/g, "");
+	const bareRe = /https?:\/\/[^\s)\]>]+/g;
+	while ((m = bareRe.exec(stripped)) !== null) urls.add(m[0]);
+	return [...urls];
+}
+/** Strip ANSI SGR and OSC 8 sequences to get visible text. */
+function stripAnsi(input) {
+	return input.replace(ANSI_RE, "");
+}
+/**
+* Find URL ranges in a line's visible text, handling cross-line URL splits.
+*/
+function findUrlRanges(visibleText, knownUrls, pending) {
+	const ranges = [];
+	let newPending = null;
+	let searchFrom = 0;
+	if (pending) {
+		const remaining = pending.url.slice(pending.consumed);
+		const trimmed = visibleText.trimStart();
+		const leadingSpaces = visibleText.length - trimmed.length;
+		let matchLen = 0;
+		for (let j = 0; j < remaining.length && j < trimmed.length; j++) if (remaining[j] === trimmed[j]) matchLen++;
+		else break;
+		if (matchLen > 0) {
+			ranges.push({
+				start: leadingSpaces,
+				end: leadingSpaces + matchLen,
+				url: pending.url
+			});
+			searchFrom = leadingSpaces + matchLen;
+			if (pending.consumed + matchLen < pending.url.length) newPending = {
+				url: pending.url,
+				consumed: pending.consumed + matchLen
+			};
+		}
+	}
+	const urlRe = /https?:\/\/[^\s)\]>]+/g;
+	urlRe.lastIndex = searchFrom;
+	let match;
+	while ((match = urlRe.exec(visibleText)) !== null) {
+		const fragment = match[0];
+		const start = match.index;
+		let resolvedUrl = fragment;
+		let found = false;
+		for (const known of knownUrls) if (known === fragment) {
+			resolvedUrl = known;
+			found = true;
+			break;
+		}
+		if (!found) {
+			let bestLen = 0;
+			for (const known of knownUrls) if (known.startsWith(fragment) && known.length > bestLen) {
+				resolvedUrl = known;
+				bestLen = known.length;
+				found = true;
+			}
+		}
+		if (!found) {
+			let bestLen = 0;
+			for (const known of knownUrls) if (fragment.startsWith(known) && known.length > bestLen) {
+				resolvedUrl = known;
+				bestLen = known.length;
+			}
+		}
+		ranges.push({
+			start,
+			end: start + fragment.length,
+			url: resolvedUrl
+		});
+		if (resolvedUrl.length > fragment.length && resolvedUrl.startsWith(fragment)) newPending = {
+			url: resolvedUrl,
+			consumed: fragment.length
+		};
+	}
+	return {
+		ranges,
+		pending: newPending
+	};
+}
+/**
+* Apply OSC 8 hyperlink sequences to a line based on visible-text URL ranges.
+* Walks through the raw string character by character, inserting OSC 8
+* open/close sequences at URL range boundaries while preserving ANSI codes.
+*/
+function applyOsc8Ranges(line, ranges) {
+	if (ranges.length === 0) return line;
+	const urlAt = /* @__PURE__ */ new Map();
+	for (const r of ranges) for (let p = r.start; p < r.end; p++) urlAt.set(p, r.url);
+	let result = "";
+	let visiblePos = 0;
+	let activeUrl = null;
+	let i = 0;
+	while (i < line.length) {
+		if (line.charCodeAt(i) === 27) {
+			const sgr = line.slice(i).match(SGR_START_RE);
+			if (sgr) {
+				result += sgr[0];
+				i += sgr[0].length;
+				continue;
+			}
+			const osc = line.slice(i).match(OSC8_START_RE);
+			if (osc) {
+				result += osc[0];
+				i += osc[0].length;
+				continue;
+			}
+		}
+		const targetUrl = urlAt.get(visiblePos) ?? null;
+		if (targetUrl !== activeUrl) {
+			if (activeUrl !== null) result += "\x1B]8;;\x07";
+			if (targetUrl !== null) result += `\x1b]8;;${targetUrl}\x07`;
+			activeUrl = targetUrl;
+		}
+		result += line[i];
+		visiblePos++;
+		i++;
+	}
+	if (activeUrl !== null) result += "\x1B]8;;\x07";
+	return result;
+}
+/**
+* Add OSC 8 hyperlinks to rendered lines using a pre-extracted URL list.
+*
+* For each line, finds URL-like substrings in the visible text, matches them
+* against known URLs, and wraps each fragment with OSC 8 escape sequences.
+* Handles URLs broken across multiple lines by pi-tui's word wrapping.
+*/
+function addOsc8Hyperlinks(lines, urls) {
+	if (urls.length === 0) return lines;
+	let pending = null;
+	return lines.map((line) => {
+		const result = findUrlRanges(stripAnsi(line), urls, pending);
+		pending = result.pending;
+		return applyOsc8Ranges(line, result.ranges);
+	});
+}
+//#endregion
+//#region src/tui/components/hyperlink-markdown.ts
+/**
+* Wrapper around pi-tui's Markdown component that adds OSC 8 terminal
+* hyperlinks to rendered output, making URLs clickable even when broken
+* across multiple lines by word wrapping.
+*/
+var HyperlinkMarkdown = class {
+	constructor(text, paddingX, paddingY, theme, options) {
+		this.inner = new Markdown(text, paddingX, paddingY, theme, options);
+		this.urls = extractUrls(text);
+	}
+	render(width) {
+		return addOsc8Hyperlinks(this.inner.render(width), this.urls);
+	}
+	setText(text) {
+		this.inner.setText(text);
+		this.urls = extractUrls(text);
+	}
+	invalidate() {
+		this.inner.invalidate();
+	}
+};
+//#endregion
+//#region src/tui/components/assistant-message.ts
+var AssistantMessageComponent = class extends Container {
+	constructor(text) {
+		super();
+		this.body = new HyperlinkMarkdown(text, 0, 0, markdownTheme, { color: (line) => theme.assistantText(line) });
+		this.addChild(new Spacer(1));
+		this.addChild(this.body);
+	}
+	setText(text) {
+		this.body.setText(text);
+	}
+};
+//#endregion
+//#region src/tui/components/btw-inline-message.ts
+var BtwInlineMessage = class extends Container {
+	constructor(params) {
+		super();
+		this.setResult(params);
+	}
+	setResult(params) {
+		this.clear();
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(theme.header(`BTW: ${params.question}`), 1, 0));
+		if (params.isError) this.addChild(new Text(theme.error(params.text), 1, 0));
+		else this.addChild(new AssistantMessageComponent(params.text));
+		this.addChild(new Text(theme.dim("Press Enter or Esc to dismiss"), 1, 0));
+	}
+};
+//#endregion
+//#region src/tui/tui-formatters.ts
+const REPLACEMENT_CHAR_RE = /\uFFFD/g;
+const MAX_TOKEN_CHARS = 32;
+const LONG_TOKEN_RE = /\S{33,}/g;
+const LONG_TOKEN_TEST_RE = /\S{33,}/;
+const BINARY_LINE_REPLACEMENT_THRESHOLD = 12;
+const URL_PREFIX_RE = /^(https?:\/\/|file:\/\/)/i;
+const WINDOWS_DRIVE_RE = /^[a-zA-Z]:[\\/]/;
+const FILE_LIKE_RE = /^[a-zA-Z0-9._-]+$/;
+const EDGE_PUNCTUATION_RE = /^[`"'([{<]+|[`"')\]}>.,:;!?]+$/g;
+const TOKENISH_MIN_LENGTH = 24;
+const RTL_SCRIPT_RE = /[\u0590-\u08ff\ufb1d-\ufdff\ufe70-\ufefc]/;
+const BIDI_CONTROL_RE = /[\u202a-\u202e\u2066-\u2069]/;
+const RTL_ISOLATE_START = "⁧";
+const RTL_ISOLATE_END = "⁩";
+function hasControlChars(text) {
+	for (const char of text) {
+		const code = char.charCodeAt(0);
+		if (code <= 31 && code !== 9 && code !== 10 && code !== 13 || code >= 127 && code <= 159) return true;
+	}
+	return false;
+}
+function stripControlChars(text) {
+	if (!hasControlChars(text)) return text;
+	let sanitized = "";
+	for (const char of text) {
+		const code = char.charCodeAt(0);
+		if (!(code <= 31 && code !== 9 && code !== 10 && code !== 13) && !(code >= 127 && code <= 159)) sanitized += char;
+	}
+	return sanitized;
+}
+function chunkToken(token, maxChars) {
+	if (token.length <= maxChars) return [token];
+	const chunks = [];
+	for (let i = 0; i < token.length; i += maxChars) chunks.push(token.slice(i, i + maxChars));
+	return chunks;
+}
+function isCopySensitiveToken(token) {
+	const candidate = token.replace(EDGE_PUNCTUATION_RE, "") || token;
+	if (URL_PREFIX_RE.test(token)) return true;
+	if (token.startsWith("/") || token.startsWith("~/") || token.startsWith("./") || token.startsWith("../")) return true;
+	if (WINDOWS_DRIVE_RE.test(token) || token.startsWith("\\\\")) return true;
+	if (token.includes("/") || token.includes("\\")) return true;
+	if (token.includes("_") && FILE_LIKE_RE.test(token)) return true;
+	if (candidate.length >= TOKENISH_MIN_LENGTH && /[a-z]/i.test(candidate) && /\d/.test(candidate)) return true;
+	return false;
+}
+function normalizeLongTokenForDisplay(token) {
+	if (isCopySensitiveToken(token)) return token;
+	return chunkToken(token, MAX_TOKEN_CHARS).join(" ");
+}
+function redactBinaryLikeLine(line) {
+	const replacementCount = (line.match(REPLACEMENT_CHAR_RE) || []).length;
+	if (replacementCount >= BINARY_LINE_REPLACEMENT_THRESHOLD && replacementCount * 2 >= line.length) return "[binary data omitted]";
+	return line;
+}
+function isolateRtlLine(line) {
+	if (!RTL_SCRIPT_RE.test(line) || BIDI_CONTROL_RE.test(line)) return line;
+	return `${RTL_ISOLATE_START}${line}${RTL_ISOLATE_END}`;
+}
+function applyRtlIsolation(text) {
+	if (!RTL_SCRIPT_RE.test(text)) return text;
+	return text.split("\n").map((line) => isolateRtlLine(line)).join("\n");
+}
+function sanitizeRenderableText(text) {
+	if (!text) return text;
+	const hasAnsi = text.includes("\x1B");
+	const hasReplacementChars = text.includes("�");
+	const hasLongTokens = LONG_TOKEN_TEST_RE.test(text);
+	const hasControls = hasControlChars(text);
+	if (!hasAnsi && !hasReplacementChars && !hasLongTokens && !hasControls) return applyRtlIsolation(text);
+	const withoutAnsi = hasAnsi ? stripAnsi$1(text) : text;
+	const withoutControlChars = hasControls ? stripControlChars(withoutAnsi) : withoutAnsi;
+	const redacted = hasReplacementChars ? withoutControlChars.split("\n").map((line) => redactBinaryLikeLine(line)).join("\n") : withoutControlChars;
+	return applyRtlIsolation(LONG_TOKEN_TEST_RE.test(redacted) ? redacted.replace(LONG_TOKEN_RE, normalizeLongTokenForDisplay) : redacted);
+}
+function resolveFinalAssistantText(params) {
+	const finalText = params.finalText ?? "";
+	if (finalText.trim()) return finalText;
+	const streamedText = params.streamedText ?? "";
+	if (streamedText.trim()) return streamedText;
+	const errorMessage = params.errorMessage ?? "";
+	if (errorMessage.trim()) return formatRawAssistantErrorForUi(errorMessage);
+	return "(no output)";
+}
+function composeThinkingAndContent(params) {
+	const thinkingText = params.thinkingText?.trim() ?? "";
+	const contentText = params.contentText?.trim() ?? "";
+	const parts = [];
+	if (params.showThinking && thinkingText) parts.push(`[thinking]\n${thinkingText}`);
+	if (contentText) parts.push(contentText);
+	return parts.join("\n\n").trim();
+}
+function asMessageRecord(message) {
+	if (!message || typeof message !== "object") return;
+	return message;
+}
+function resolveMessageRecord(message) {
+	const record = asMessageRecord(message);
+	if (!record) return;
+	return {
+		record,
+		content: record.content
+	};
+}
+function formatAssistantErrorFromRecord(record) {
+	if ((typeof record.stopReason === "string" ? record.stopReason : "") !== "error") return "";
+	return formatRawAssistantErrorForUi(typeof record.errorMessage === "string" ? record.errorMessage : "");
+}
+function collectSanitizedBlockStrings(params) {
+	if (!Array.isArray(params.content)) return [];
+	const parts = [];
+	for (const block of params.content) {
+		if (!block || typeof block !== "object") continue;
+		const rec = block;
+		if (rec.type === params.blockType && typeof rec[params.valueKey] === "string") parts.push(sanitizeRenderableText(rec[params.valueKey]));
+	}
+	return parts;
+}
+/**
+* Extract ONLY thinking blocks from message content.
+* Model-agnostic: returns empty string if no thinking blocks exist.
+*/
+function extractThinkingFromMessage(message) {
+	const resolved = resolveMessageRecord(message);
+	if (!resolved) return "";
+	const { content } = resolved;
+	if (typeof content === "string") return "";
+	return collectSanitizedBlockStrings({
+		content,
+		blockType: "thinking",
+		valueKey: "thinking"
+	}).join("\n").trim();
+}
+/**
+* Extract ONLY text content blocks from message (excludes thinking).
+* Model-agnostic: works for any model with text content blocks.
+*/
+function extractContentFromMessage(message) {
+	const resolved = resolveMessageRecord(message);
+	if (!resolved) return "";
+	const { record, content } = resolved;
+	if (record.role === "assistant") {
+		if (typeof content === "string") return sanitizeRenderableText(content).trim();
+		if (Array.isArray(content)) return extractAssistantRenderableContent(record);
+	}
+	if (typeof content === "string") return sanitizeRenderableText(content).trim();
+	const parts = collectSanitizedBlockStrings({
+		content,
+		blockType: "text",
+		valueKey: "text"
+	});
+	if (parts.length > 0) return parts.join("\n").trim();
+	return formatAssistantErrorFromRecord(record);
+}
+function extractAssistantRenderableContent(record) {
+	const visible = sanitizeRenderableText(extractAssistantVisibleText(record) ?? "").trim();
+	if (visible) return visible;
+	return formatAssistantErrorFromRecord(record);
+}
+function extractTextBlocks(content, opts) {
+	if (typeof content === "string") return sanitizeRenderableText(content).trim();
+	if (!Array.isArray(content)) return "";
+	const textParts = collectSanitizedBlockStrings({
+		content,
+		blockType: "text",
+		valueKey: "text"
+	});
+	return composeThinkingAndContent({
+		thinkingText: (opts?.includeThinking === true ? collectSanitizedBlockStrings({
+			content,
+			blockType: "thinking",
+			valueKey: "thinking"
+		}) : []).join("\n").trim(),
+		contentText: textParts.join("\n").trim(),
+		showThinking: opts?.includeThinking ?? false
+	});
+}
+function extractTextFromMessage(message, opts) {
+	const record = asMessageRecord(message);
+	if (!record) return "";
+	if (record.role === "assistant") return composeThinkingAndContent({
+		thinkingText: extractThinkingFromMessage(record),
+		contentText: extractAssistantRenderableContent(record),
+		showThinking: opts?.includeThinking ?? false
+	});
+	const text = extractTextBlocks(record.content, opts);
+	if (text) {
+		if (record.role === "user" || record.command === true) return stripLeadingInboundMetadata(text);
+		return text;
+	}
+	const errorText = formatAssistantErrorFromRecord(record);
+	if (!errorText) return "";
+	return errorText;
+}
+function isCommandMessage(message) {
+	if (!message || typeof message !== "object") return false;
+	return message.command === true;
+}
+function formatTokens(total, context) {
+	if (total == null && context == null) return "tokens ?";
+	const totalLabel = total == null ? "?" : formatTokenCount(total);
+	if (context == null) return `tokens ${totalLabel}`;
+	const pct = typeof total === "number" && context > 0 ? Math.min(999, Math.round(total / context * 100)) : null;
+	return `tokens ${totalLabel}/${formatTokenCount(context)}${pct !== null ? ` (${pct}%)` : ""}`;
+}
+function formatContextUsageLine(params) {
+	const totalLabel = typeof params.total === "number" ? formatTokenCount(params.total) : "?";
+	const ctxLabel = typeof params.context === "number" ? formatTokenCount(params.context) : "?";
+	const pct = typeof params.percent === "number" ? Math.min(999, Math.round(params.percent)) : null;
+	const extra = [typeof params.remaining === "number" ? `${formatTokenCount(params.remaining)} left` : null, pct !== null ? `${pct}%` : null].filter(Boolean).join(", ");
+	return `tokens ${totalLabel}/${ctxLabel}${extra ? ` (${extra})` : ""}`;
+}
+function asString(value, fallback = "") {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return fallback;
+}
+//#endregion
+//#region src/tui/components/tool-execution.ts
+const PREVIEW_LINES = 12;
+function formatArgs(toolName, args) {
+	const detail = formatToolDetail(resolveToolDisplay({
+		name: toolName,
+		args
+	}));
+	if (detail) return sanitizeRenderableText(detail);
+	if (!args || typeof args !== "object") return "";
+	try {
+		return sanitizeRenderableText(JSON.stringify(args));
+	} catch {
+		return "";
+	}
+}
+function extractText(result) {
+	if (!result?.content) return "";
+	const lines = [];
+	for (const entry of result.content) if (entry.type === "text" && entry.text) lines.push(sanitizeRenderableText(entry.text));
+	else if (entry.type === "image") {
+		const mime = entry.mimeType ?? "image";
+		const size = entry.bytes ? ` ${Math.round(entry.bytes / 1024)}kb` : "";
+		const omitted = entry.omitted ? " (omitted)" : "";
+		lines.push(`[${mime}${size}${omitted}]`);
+	}
+	return lines.join("\n").trim();
+}
+var ToolExecutionComponent = class extends Container {
+	constructor(toolName, args) {
+		super();
+		this.expanded = false;
+		this.isError = false;
+		this.isPartial = true;
+		this.toolName = toolName;
+		this.args = args;
+		this.box = new Box(1, 1, (line) => theme.toolPendingBg(line));
+		this.header = new Text("", 0, 0);
+		this.argsLine = new Text("", 0, 0);
+		this.output = new Markdown("", 0, 0, markdownTheme, { color: (line) => theme.toolOutput(line) });
+		this.addChild(new Spacer(1));
+		this.addChild(this.box);
+		this.box.addChild(this.header);
+		this.box.addChild(this.argsLine);
+		this.box.addChild(this.output);
+		this.refresh();
+	}
+	setArgs(args) {
+		this.args = args;
+		this.refresh();
+	}
+	setExpanded(expanded) {
+		this.expanded = expanded;
+		this.refresh();
+	}
+	setResult(result, opts) {
+		this.result = result;
+		this.isPartial = false;
+		this.isError = Boolean(opts?.isError);
+		this.refresh();
+	}
+	setPartialResult(result) {
+		this.result = result;
+		this.isPartial = true;
+		this.refresh();
+	}
+	refresh() {
+		const bg = this.isPartial ? theme.toolPendingBg : this.isError ? theme.toolErrorBg : theme.toolSuccessBg;
+		this.box.setBgFn((line) => bg(line));
+		const display = resolveToolDisplay({
+			name: this.toolName,
+			args: this.args
+		});
+		const title = `${display.emoji} ${display.label}${this.isPartial ? " (running)" : ""}`;
+		this.header.setText(theme.toolTitle(theme.bold(title)));
+		const argLine = formatArgs(this.toolName, this.args);
+		this.argsLine.setText(argLine ? theme.dim(argLine) : theme.dim(" "));
+		const text = extractText(this.result) || (this.isPartial ? "…" : "");
+		if (!this.expanded && text) {
+			const lines = text.split("\n");
+			const preview = lines.length > PREVIEW_LINES ? `${lines.slice(0, PREVIEW_LINES).join("\n")}\n…` : text;
+			this.output.setText(preview);
+		} else this.output.setText(text);
+	}
+};
+//#endregion
+//#region src/tui/components/markdown-message.ts
+var MarkdownMessageComponent = class extends Container {
+	constructor(text, y, options) {
+		super();
+		this.body = new HyperlinkMarkdown(text, 0, y, markdownTheme, options);
+		this.addChild(new Spacer(1));
+		this.addChild(this.body);
+	}
+	setText(text) {
+		this.body.setText(text);
+	}
+};
+//#endregion
+//#region src/tui/components/user-message.ts
+var UserMessageComponent = class extends MarkdownMessageComponent {
+	constructor(text) {
+		super(text, 1, {
+			bgColor: (line) => theme.userBg(line),
+			color: (line) => theme.userText(line)
+		});
+	}
+};
+//#endregion
+//#region src/tui/components/chat-log.ts
+const PENDING_HISTORY_CLOCK_SKEW_TOLERANCE_MS = 6e4;
+var ChatLog = class extends Container {
+	constructor(maxComponents = 180) {
+		super();
+		this.toolById = /* @__PURE__ */ new Map();
+		this.streamingRuns = /* @__PURE__ */ new Map();
+		this.pendingUsers = /* @__PURE__ */ new Map();
+		this.btwMessage = null;
+		this.toolsExpanded = false;
+		this.maxComponents = Math.max(20, Math.floor(maxComponents));
+	}
+	dropComponentReferences(component) {
+		for (const [toolId, tool] of this.toolById.entries()) if (tool === component) this.toolById.delete(toolId);
+		for (const [runId, message] of this.streamingRuns.entries()) if (message === component) this.streamingRuns.delete(runId);
+		for (const [runId, entry] of this.pendingUsers.entries()) if (entry.component === component) this.pendingUsers.delete(runId);
+		if (this.btwMessage === component) this.btwMessage = null;
+	}
+	pruneOverflow() {
+		while (this.children.length > this.maxComponents) {
+			const oldest = this.children[0];
+			if (!oldest) return;
+			this.removeChild(oldest);
+			this.dropComponentReferences(oldest);
+		}
+	}
+	append(component) {
+		this.addChild(component);
+		this.pruneOverflow();
+	}
+	clearAll(opts) {
+		this.clear();
+		this.toolById.clear();
+		this.streamingRuns.clear();
+		this.btwMessage = null;
+		if (!opts?.preservePendingUsers) this.pendingUsers.clear();
+	}
+	restorePendingUsers() {
+		for (const entry of this.pendingUsers.values()) {
+			if (this.children.includes(entry.component)) continue;
+			this.append(entry.component);
+		}
+	}
+	clearPendingUsers() {
+		for (const entry of this.pendingUsers.values()) this.removeChild(entry.component);
+		this.pendingUsers.clear();
+	}
+	createSystemMessage(text) {
+		const entry = new Container();
+		entry.addChild(new Spacer(1));
+		entry.addChild(new Text(theme.system(text), 1, 0));
+		return entry;
+	}
+	addSystem(text) {
+		this.append(this.createSystemMessage(text));
+	}
+	addUser(text) {
+		this.append(new UserMessageComponent(text));
+	}
+	addPendingUser(runId, text, createdAt = Date.now()) {
+		const existing = this.pendingUsers.get(runId);
+		if (existing) {
+			existing.text = text;
+			existing.createdAt = createdAt;
+			existing.component.setText(text);
+			return existing.component;
+		}
+		const component = new UserMessageComponent(text);
+		this.pendingUsers.set(runId, {
+			component,
+			text,
+			createdAt
+		});
+		this.append(component);
+		return component;
+	}
+	commitPendingUser(runId) {
+		return this.pendingUsers.delete(runId);
+	}
+	dropPendingUser(runId) {
+		const existing = this.pendingUsers.get(runId);
+		if (!existing) return false;
+		this.removeChild(existing.component);
+		this.pendingUsers.delete(runId);
+		return true;
+	}
+	hasPendingUser(runId) {
+		return this.pendingUsers.has(runId);
+	}
+	reconcilePendingUsers(historyUsers) {
+		const normalizedHistory = historyUsers.map((entry) => ({
+			text: entry.text.trim(),
+			timestamp: typeof entry.timestamp === "number" ? entry.timestamp : null
+		})).filter((entry) => entry.text.length > 0 && entry.timestamp !== null);
+		const clearedRunIds = [];
+		for (const [runId, entry] of this.pendingUsers.entries()) {
+			const pendingText = entry.text.trim();
+			if (!pendingText) continue;
+			const matchIndex = normalizedHistory.findIndex((historyEntry) => historyEntry.text === pendingText && (historyEntry.timestamp ?? 0) >= entry.createdAt - PENDING_HISTORY_CLOCK_SKEW_TOLERANCE_MS);
+			if (matchIndex === -1) continue;
+			if (this.children.includes(entry.component)) this.removeChild(entry.component);
+			this.pendingUsers.delete(runId);
+			clearedRunIds.push(runId);
+			normalizedHistory.splice(matchIndex, 1);
+		}
+		return clearedRunIds;
+	}
+	countPendingUsers() {
+		return this.pendingUsers.size;
+	}
+	resolveRunId(runId) {
+		return runId ?? "default";
+	}
+	startAssistant(text, runId) {
+		const effectiveRunId = this.resolveRunId(runId);
+		const existing = this.streamingRuns.get(effectiveRunId);
+		if (existing) {
+			existing.setText(text);
+			return existing;
+		}
+		const component = new AssistantMessageComponent(text);
+		this.streamingRuns.set(effectiveRunId, component);
+		this.append(component);
+		return component;
+	}
+	updateAssistant(text, runId) {
+		const effectiveRunId = this.resolveRunId(runId);
+		const existing = this.streamingRuns.get(effectiveRunId);
+		if (!existing) {
+			this.startAssistant(text, runId);
+			return;
+		}
+		existing.setText(text);
+	}
+	finalizeAssistant(text, runId) {
+		const effectiveRunId = this.resolveRunId(runId);
+		const existing = this.streamingRuns.get(effectiveRunId);
+		if (existing) {
+			existing.setText(text);
+			this.streamingRuns.delete(effectiveRunId);
+			return;
+		}
+		this.append(new AssistantMessageComponent(text));
+	}
+	dropAssistant(runId) {
+		const effectiveRunId = this.resolveRunId(runId);
+		const existing = this.streamingRuns.get(effectiveRunId);
+		if (!existing) return;
+		this.removeChild(existing);
+		this.streamingRuns.delete(effectiveRunId);
+	}
+	showBtw(params) {
+		if (this.btwMessage) {
+			this.btwMessage.setResult(params);
+			if (this.children[this.children.length - 1] !== this.btwMessage) {
+				this.removeChild(this.btwMessage);
+				this.append(this.btwMessage);
+			}
+			return this.btwMessage;
+		}
+		const component = new BtwInlineMessage(params);
+		this.btwMessage = component;
+		this.append(component);
+		return component;
+	}
+	dismissBtw() {
+		if (!this.btwMessage) return;
+		this.removeChild(this.btwMessage);
+		this.btwMessage = null;
+	}
+	hasVisibleBtw() {
+		return this.btwMessage !== null;
+	}
+	startTool(toolCallId, toolName, args) {
+		const existing = this.toolById.get(toolCallId);
+		if (existing) {
+			existing.setArgs(args);
+			return existing;
+		}
+		const component = new ToolExecutionComponent(toolName, args);
+		component.setExpanded(this.toolsExpanded);
+		this.toolById.set(toolCallId, component);
+		this.append(component);
+		return component;
+	}
+	updateToolArgs(toolCallId, args) {
+		const existing = this.toolById.get(toolCallId);
+		if (!existing) return;
+		existing.setArgs(args);
+	}
+	updateToolResult(toolCallId, result, opts) {
+		const existing = this.toolById.get(toolCallId);
+		if (!existing) return;
+		if (opts?.partial) {
+			existing.setPartialResult(result);
+			return;
+		}
+		existing.setResult(result, { isError: opts?.isError });
+	}
+	setToolsExpanded(expanded) {
+		this.toolsExpanded = expanded;
+		for (const tool of this.toolById.values()) tool.setExpanded(expanded);
+	}
+};
+//#endregion
+//#region src/tui/components/custom-editor.ts
+var CustomEditor = class extends Editor {
+	handleInput(data) {
+		if (matchesKey(data, Key.alt("enter")) && this.onAltEnter) {
+			this.onAltEnter();
+			return;
+		}
+		if (matchesKey(data, Key.alt("up")) && this.onAltUp) {
+			this.onAltUp();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("l")) && this.onCtrlL) {
+			this.onCtrlL();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("o")) && this.onCtrlO) {
+			this.onCtrlO();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("p")) && this.onCtrlP) {
+			this.onCtrlP();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("g")) && this.onCtrlG) {
+			this.onCtrlG();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("t")) && this.onCtrlT) {
+			this.onCtrlT();
+			return;
+		}
+		if (matchesKey(data, Key.shift("tab")) && this.onShiftTab) {
+			this.onShiftTab();
+			return;
+		}
+		if (matchesKey(data, Key.escape) && this.onEscape && !this.isShowingAutocomplete()) {
+			this.onEscape();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("c")) && this.onCtrlC) {
+			this.onCtrlC();
+			return;
+		}
+		if (matchesKey(data, Key.ctrl("d"))) {
+			if (this.getText().length === 0 && this.onCtrlD) this.onCtrlD();
+			return;
+		}
+		super.handleInput(data);
+	}
+};
+//#endregion
+//#region src/tui/embedded-backend.ts
+const silentRuntime = {
+	log: (..._args) => void 0,
+	error: (..._args) => void 0,
+	exit: (code) => {
+		throw new Error(`embedded tui runtime exit ${String(code)}`);
+	}
+};
+function isSilentReplyLeadFragment(text) {
+	const normalized = text.trim().toUpperCase();
+	if (!normalized) return false;
+	if (!/^[A-Z_]+$/.test(normalized)) return false;
+	if (normalized === "NO_REPLY") return false;
+	return SILENT_REPLY_TOKEN.startsWith(normalized);
+}
+function appendUniqueSuffix(base, suffix) {
+	if (!suffix) return base;
+	if (!base) return suffix;
+	if (base.endsWith(suffix)) return base;
+	const maxOverlap = Math.min(base.length, suffix.length);
+	for (let overlap = maxOverlap; overlap > 0; overlap -= 1) if (base.slice(-overlap) === suffix.slice(0, overlap)) return base + suffix.slice(overlap);
+	return base + suffix;
+}
+function resolveMergedAssistantText(params) {
+	const previous = params.previousText;
+	const next = params.nextText;
+	const delta = params.nextDelta;
+	if (!previous) return next || delta;
+	if (next && next.startsWith(previous)) return next;
+	if (delta) return appendUniqueSuffix(previous, delta);
+	return appendUniqueSuffix(previous, next);
+}
+function resolveBtwQuestion(message) {
+	const question = /^\/btw(?::|\s)+(.*)$/i.exec(message.trim())?.[1]?.trim();
+	return question ? question : void 0;
+}
+function payloadText(parts) {
+	if (!Array.isArray(parts)) return "";
+	return parts.map((part) => {
+		if (!part || typeof part !== "object") return "";
+		const payload = part;
+		return typeof payload.text === "string" ? payload.text.trim() : "";
+	}).filter(Boolean).join("\n\n").trim();
+}
+function timeoutSecondsFromMs(timeoutMs) {
+	if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs < 0) return;
+	return String(Math.max(0, Math.ceil(timeoutMs / 1e3)));
+}
+var EmbeddedTuiBackend = class {
+	constructor() {
+		this.connection = { url: "local embedded" };
+		this.deps = createDefaultDeps();
+		this.runs = /* @__PURE__ */ new Map();
+		this.seq = 0;
+	}
+	start() {
+		if (this.unsubscribe) return;
+		setEmbeddedMode(true);
+		this.previousRuntimeLog = defaultRuntime.log;
+		this.previousRuntimeError = defaultRuntime.error;
+		defaultRuntime.log = silentRuntime.log;
+		defaultRuntime.error = silentRuntime.error;
+		this.unsubscribe = onAgentEvent((evt) => {
+			this.handleAgentEvent(evt);
+		});
+		queueMicrotask(() => {
+			this.onConnected?.();
+		});
+	}
+	stop() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		for (const run of this.runs.values()) run.controller.abort();
+		this.runs.clear();
+		defaultRuntime.log = this.previousRuntimeLog ?? defaultRuntime.log;
+		defaultRuntime.error = this.previousRuntimeError ?? defaultRuntime.error;
+		this.previousRuntimeLog = void 0;
+		this.previousRuntimeError = void 0;
+		setEmbeddedMode(false);
+	}
+	async sendChat(opts) {
+		const runId = opts.runId ?? randomUUID();
+		const question = resolveBtwQuestion(opts.message);
+		if (!question) this.abortSessionRuns(opts.sessionKey);
+		const controller = new AbortController();
+		this.runs.set(runId, {
+			sessionKey: opts.sessionKey,
+			controller,
+			buffer: "",
+			isBtw: Boolean(question),
+			question,
+			finalSent: false,
+			registered: false
+		});
+		this.runTurn({
+			runId,
+			sessionKey: opts.sessionKey,
+			message: opts.message,
+			thinking: opts.thinking,
+			deliver: opts.deliver,
+			timeoutMs: opts.timeoutMs,
+			controller
+		});
+		return { runId };
+	}
+	async abortChat(opts) {
+		const run = this.runs.get(opts.runId);
+		if (!run || run.sessionKey !== opts.sessionKey) return {
+			ok: true,
+			aborted: false
+		};
+		run.controller.abort();
+		return {
+			ok: true,
+			aborted: true
+		};
+	}
+	async loadHistory(opts) {
+		const { cfg, storePath, entry } = loadSessionEntry(opts.sessionKey);
+		const sessionId = entry?.sessionId;
+		const resolvedSessionModel = resolveSessionModelRef(cfg, entry, resolveSessionAgentId({
+			sessionKey: opts.sessionKey,
+			config: cfg
+		}));
+		const localMessages = sessionId && storePath ? readSessionMessages(sessionId, storePath, entry?.sessionFile) : [];
+		const rawMessages = augmentChatHistoryWithCliSessionImports({
+			entry,
+			provider: resolvedSessionModel.provider,
+			localMessages
+		});
+		const max = Math.min(1e3, typeof opts.limit === "number" ? opts.limit : 200);
+		const sliced = rawMessages.length > max ? rawMessages.slice(-max) : rawMessages;
+		const effectiveMaxChars = resolveEffectiveChatHistoryMaxChars(cfg);
+		const normalized = augmentChatHistoryWithCanvasBlocks(sanitizeChatHistoryMessages(stripEnvelopeFromMessages(sliced), effectiveMaxChars));
+		const maxHistoryBytes = getMaxChatHistoryMessagesBytes();
+		const capped = capArrayByJsonBytes(replaceOversizedChatHistoryMessages({
+			messages: normalized,
+			maxSingleMessageBytes: Math.min(CHAT_HISTORY_MAX_SINGLE_MESSAGE_BYTES, maxHistoryBytes)
+		}).messages, maxHistoryBytes).items;
+		const messages = enforceChatHistoryFinalBudget({
+			messages: capped,
+			maxBytes: maxHistoryBytes
+		}).messages;
+		let thinkingLevel = entry?.thinkingLevel;
+		if (!thinkingLevel) {
+			const catalog = await loadGatewayModelCatalog();
+			thinkingLevel = resolveThinkingDefault({
+				cfg,
+				provider: resolvedSessionModel.provider,
+				model: resolvedSessionModel.model,
+				catalog
+			});
+		}
+		return {
+			sessionKey: opts.sessionKey,
+			sessionId,
+			messages,
+			thinkingLevel,
+			fastMode: entry?.fastMode,
+			verboseLevel: entry?.verboseLevel ?? cfg.agents?.defaults?.verboseDefault
+		};
+	}
+	async listSessions(opts) {
+		const cfg = loadConfig();
+		const { storePath, store } = loadCombinedSessionStoreForGateway(cfg);
+		return listSessionsFromStore({
+			cfg,
+			storePath,
+			store,
+			opts: opts ?? {}
+		});
+	}
+	async listAgents() {
+		return listAgentsForGateway(loadConfig());
+	}
+	async patchSession(opts) {
+		const cfg = loadConfig();
+		const target = resolveGatewaySessionStoreTarget({
+			cfg,
+			key: opts.key
+		});
+		const applied = await updateSessionStore(target.storePath, async (store) => {
+			const { primaryKey } = migrateAndPruneGatewaySessionStoreKey({
+				cfg,
+				key: opts.key,
+				store
+			});
+			return await applySessionsPatchToStore({
+				cfg,
+				store,
+				storeKey: primaryKey,
+				patch: opts,
+				loadGatewayModelCatalog
+			});
+		});
+		if (!applied.ok) throw new Error(applied.error.message);
+		const agentId = resolveSessionAgentId({
+			sessionKey: target.canonicalKey ?? opts.key,
+			config: cfg
+		});
+		const resolved = resolveSessionModelRef(cfg, applied.entry, agentId);
+		return {
+			ok: true,
+			path: target.storePath,
+			key: target.canonicalKey ?? opts.key,
+			entry: applied.entry,
+			resolved: {
+				modelProvider: resolved.provider,
+				model: resolved.model
+			}
+		};
+	}
+	async resetSession(key, reason) {
+		const result = await performGatewaySessionReset({
+			key,
+			reason: reason === "new" ? "new" : "reset",
+			commandSource: "tui:embedded"
+		});
+		if (!result.ok) throw new Error(result.error.message);
+		return {
+			ok: true,
+			key: result.key,
+			entry: result.entry
+		};
+	}
+	async getGatewayStatus() {
+		return `local embedded mode${this.runs.size > 0 ? ` (${String(this.runs.size)} active run${this.runs.size === 1 ? "" : "s"})` : ""}`;
+	}
+	async listModels() {
+		const catalog = await loadGatewayModelCatalog();
+		const { allowedCatalog } = buildAllowedModelSet({
+			cfg: loadConfig(),
+			catalog,
+			defaultProvider: DEFAULT_PROVIDER
+		});
+		return (allowedCatalog.length > 0 ? allowedCatalog : catalog).map((entry) => ({
+			id: entry.id,
+			name: entry.name ?? entry.id,
+			provider: entry.provider,
+			contextWindow: entry.contextWindow,
+			reasoning: entry.reasoning
+		}));
+	}
+	abortSessionRuns(sessionKey) {
+		for (const run of this.runs.values()) if (run.sessionKey === sessionKey && !run.isBtw) run.controller.abort();
+	}
+	nextSeq() {
+		this.seq += 1;
+		return this.seq;
+	}
+	emit(event, payload) {
+		this.onEvent?.({
+			event,
+			payload,
+			seq: this.nextSeq()
+		});
+	}
+	emitChatDelta(runId, run) {
+		const text = run.buffer.trim();
+		if (!text || isSilentReplyText(text, "NO_REPLY") || isSilentReplyLeadFragment(text)) return;
+		run.registered = true;
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "delta",
+			message: {
+				role: "assistant",
+				content: [{
+					type: "text",
+					text
+				}],
+				timestamp: Date.now()
+			}
+		});
+	}
+	emitChatFinal(runId, run, stopReason) {
+		if (run.finalSent) return;
+		run.finalSent = true;
+		run.registered = true;
+		const text = run.buffer.trim();
+		const shouldIncludeMessage = Boolean(text) && !isSilentReplyText(text, "NO_REPLY") && !isSilentReplyLeadFragment(text);
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "final",
+			...stopReason ? { stopReason } : {},
+			...shouldIncludeMessage ? { message: {
+				role: "assistant",
+				content: [{
+					type: "text",
+					text
+				}],
+				timestamp: Date.now()
+			} } : {}
+		});
+	}
+	emitChatAborted(runId, run) {
+		if (run.finalSent) return;
+		run.finalSent = true;
+		run.registered = true;
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "aborted"
+		});
+	}
+	emitChatError(runId, run, errorMessage) {
+		if (run.finalSent) return;
+		run.finalSent = true;
+		run.registered = true;
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "error",
+			...errorMessage ? { errorMessage } : {}
+		});
+	}
+	ensureRunRegistered(runId, run) {
+		if (run.registered || run.isBtw) return;
+		run.registered = true;
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "delta",
+			message: {
+				role: "assistant",
+				content: [{
+					type: "text",
+					text: ""
+				}],
+				timestamp: Date.now()
+			}
+		});
+	}
+	async handleAgentEvent(evt) {
+		const run = this.runs.get(evt.runId);
+		if (!run) return;
+		if (evt.stream !== "assistant") this.ensureRunRegistered(evt.runId, run);
+		this.emit("agent", {
+			runId: evt.runId,
+			stream: evt.stream,
+			data: evt.data
+		});
+		if (evt.stream === "assistant" && !run.isBtw && typeof evt.data?.text === "string") {
+			const nextText = stripInlineDirectiveTagsForDisplay(evt.data.text).text;
+			const nextDelta = typeof evt.data?.delta === "string" ? stripInlineDirectiveTagsForDisplay(evt.data.delta).text : "";
+			run.buffer = resolveMergedAssistantText({
+				previousText: run.buffer,
+				nextText,
+				nextDelta
+			});
+			this.emitChatDelta(evt.runId, run);
+			return;
+		}
+		if (evt.stream !== "lifecycle") return;
+		const phase = typeof evt.data?.phase === "string" ? evt.data.phase : "";
+		const aborted = evt.data?.aborted === true || run.controller.signal.aborted;
+		if (phase === "end") {
+			if (aborted) {
+				this.emitChatAborted(evt.runId, run);
+				return;
+			}
+			if (!run.isBtw) {
+				const stopReason = typeof evt.data?.stopReason === "string" ? evt.data.stopReason : void 0;
+				this.emitChatFinal(evt.runId, run, stopReason);
+			}
+			return;
+		}
+		if (phase === "error") {
+			if (aborted) {
+				this.emitChatAborted(evt.runId, run);
+				return;
+			}
+			const errorMessage = typeof evt.data?.error === "string" ? evt.data.error : void 0;
+			this.emitChatError(evt.runId, run, errorMessage);
+		}
+	}
+	async runTurn(params) {
+		try {
+			const { cfg, canonicalKey, entry } = loadSessionEntry(params.sessionKey);
+			const result = await agentCommandFromIngress({
+				message: injectTimestamp(params.message, timestampOptsFromConfig(cfg)),
+				sessionKey: canonicalKey,
+				...entry?.sessionId ? { sessionId: entry.sessionId } : {},
+				thinking: params.thinking,
+				deliver: params.deliver,
+				channel: INTERNAL_MESSAGE_CHANNEL,
+				runContext: { messageChannel: INTERNAL_MESSAGE_CHANNEL },
+				timeout: timeoutSecondsFromMs(params.timeoutMs),
+				runId: params.runId,
+				abortSignal: params.controller.signal,
+				senderIsOwner: true,
+				allowModelOverride: false
+			}, silentRuntime, this.deps);
+			const run = this.runs.get(params.runId);
+			if (!run) return;
+			if (run.isBtw) {
+				const text = payloadText(result?.payloads);
+				if (run.question && text) this.emit("chat.side_result", {
+					kind: "btw",
+					runId: params.runId,
+					sessionKey: run.sessionKey,
+					question: run.question,
+					text
+				});
+				this.emitChatFinal(params.runId, run);
+				return;
+			}
+			if (!run.finalSent) {
+				const normalizedText = payloadText(result?.payloads);
+				if (normalizedText && !run.buffer) run.buffer = normalizedText;
+				this.emitChatFinal(params.runId, run);
+			}
+		} catch (error) {
+			const run = this.runs.get(params.runId);
+			if (!run) return;
+			if (params.controller.signal.aborted) {
+				this.emitChatAborted(params.runId, run);
+				return;
+			}
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			this.emitChatError(params.runId, run, errorMessage);
+		} finally {
+			this.runs.delete(params.runId);
+		}
+	}
+};
+//#endregion
+//#region src/tui/gateway-chat.ts
+const STARTUP_CHAT_HISTORY_RETRY_TIMEOUT_MS = 6e4;
+const STARTUP_CHAT_HISTORY_DEFAULT_RETRY_MS = 500;
+const STARTUP_CHAT_HISTORY_MAX_RETRY_MS = 5e3;
+function throwGatewayAuthResolutionError(reason) {
+	throw new Error([
+		reason,
+		"Fix: set GENESIS_GATEWAY_TOKEN/GENESIS_GATEWAY_PASSWORD, pass --token/--password,",
+		"or resolve the configured secret provider for this credential."
+	].join("\n"));
+}
+function isRetryableStartupUnavailable(err, method) {
+	if (!(err instanceof GatewayClientRequestError)) return false;
+	if (err.gatewayCode !== "UNAVAILABLE" || !err.retryable) return false;
+	const details = err.details;
+	if (!details || typeof details !== "object") return true;
+	const detailMethod = details.method;
+	return typeof detailMethod !== "string" || detailMethod === method;
+}
+function resolveStartupRetryDelayMs(err) {
+	const retryAfterMs = typeof err.retryAfterMs === "number" ? err.retryAfterMs : STARTUP_CHAT_HISTORY_DEFAULT_RETRY_MS;
+	return Math.min(Math.max(retryAfterMs, 100), STARTUP_CHAT_HISTORY_MAX_RETRY_MS);
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var GatewayChatClient = class GatewayChatClient {
+	constructor(connection) {
+		this.connection = connection;
+		this.readyPromise = new Promise((resolve) => {
+			this.resolveReady = resolve;
+		});
+		this.client = new GatewayClient({
+			url: connection.url,
+			token: connection.token,
+			password: connection.password,
+			clientName: GATEWAY_CLIENT_NAMES.TUI,
+			clientDisplayName: "genesis-tui",
+			clientVersion: VERSION,
+			platform: process.platform,
+			mode: GATEWAY_CLIENT_MODES.UI,
+			deviceIdentity: connection.allowInsecureLocalOperatorUi ? null : void 0,
+			caps: [GATEWAY_CLIENT_CAPS.TOOL_EVENTS, GATEWAY_CLIENT_CAPS.CHAT_INCREMENTAL],
+			instanceId: randomUUID(),
+			minProtocol: 4,
+			maxProtocol: 4,
+			onHelloOk: (hello) => {
+				this.hello = hello;
+				this.resolveReady?.();
+				this.onConnected?.();
+			},
+			onEvent: (evt) => {
+				this.onEvent?.({
+					event: evt.event,
+					payload: evt.payload,
+					seq: evt.seq
+				});
+			},
+			onClose: (_code, reason) => {
+				this.readyPromise = new Promise((resolve) => {
+					this.resolveReady = resolve;
+				});
+				this.onDisconnected?.(reason);
+			},
+			onGap: (info) => {
+				this.onGap?.(info);
+			}
+		});
+	}
+	static async connect(opts) {
+		return new GatewayChatClient(await resolveGatewayConnection(opts));
+	}
+	start() {
+		this.client.start();
+	}
+	stop() {
+		this.client.stop();
+	}
+	async waitForReady() {
+		await this.readyPromise;
+	}
+	async sendChat(opts) {
+		const runId = opts.runId ?? randomUUID();
+		await this.client.request("chat.send", {
+			sessionKey: opts.sessionKey,
+			message: opts.message,
+			thinking: opts.thinking,
+			deliver: opts.deliver,
+			timeoutMs: opts.timeoutMs,
+			idempotencyKey: runId
+		});
+		return { runId };
+	}
+	async abortChat(opts) {
+		return await this.client.request("chat.abort", {
+			sessionKey: opts.sessionKey,
+			runId: opts.runId
+		});
+	}
+	async loadHistory(opts) {
+		const startedAt = Date.now();
+		for (;;) try {
+			return await this.client.request("chat.history", {
+				sessionKey: opts.sessionKey,
+				limit: opts.limit
+			});
+		} catch (err) {
+			if (Date.now() - startedAt < STARTUP_CHAT_HISTORY_RETRY_TIMEOUT_MS && isRetryableStartupUnavailable(err, "chat.history")) {
+				await sleep(resolveStartupRetryDelayMs(err));
+				continue;
+			}
+			throw err;
+		}
+	}
+	async listSessions(opts) {
+		return await this.client.request("sessions.list", {
+			limit: opts?.limit,
+			activeMinutes: opts?.activeMinutes,
+			includeGlobal: opts?.includeGlobal,
+			includeUnknown: opts?.includeUnknown,
+			includeDerivedTitles: opts?.includeDerivedTitles,
+			includeLastMessage: opts?.includeLastMessage,
+			agentId: opts?.agentId
+		});
+	}
+	async listAgents() {
+		return await this.client.request("agents.list", {});
+	}
+	async patchSession(opts) {
+		return await this.client.request("sessions.patch", opts);
+	}
+	async resetSession(key, reason) {
+		return await this.client.request("sessions.reset", {
+			key,
+			...reason ? { reason } : {}
+		});
+	}
+	async getGatewayStatus() {
+		return await this.client.request("status");
+	}
+	async listModels() {
+		const res = await this.client.request("models.list");
+		return Array.isArray(res?.models) ? res.models : [];
+	}
+};
+async function resolveGatewayConnection(opts) {
+	const config = loadConfig();
+	const env = process.env;
+	const gatewayAuthMode = config.gateway?.auth?.mode;
+	const isRemoteMode = config.gateway?.mode === "remote";
+	const preferConfiguredAuth = env[TUI_SETUP_AUTH_SOURCE_ENV] === TUI_SETUP_AUTH_SOURCE_CONFIG;
+	const urlOverride = typeof opts.url === "string" && opts.url.trim().length > 0 ? opts.url.trim() : void 0;
+	const explicitAuth = resolveExplicitGatewayAuth({
+		token: opts.token,
+		password: opts.password
+	});
+	ensureExplicitGatewayAuth({
+		urlOverride,
+		urlOverrideSource: "cli",
+		explicitAuth,
+		errorHint: "Fix: pass --token or --password when using --url."
+	});
+	const url = buildGatewayConnectionDetails({
+		config,
+		...urlOverride ? { url: urlOverride } : {}
+	}).url;
+	const allowInsecureLocalOperatorUi = (() => {
+		if (config.gateway?.controlUi?.allowInsecureAuth !== true) return false;
+		try {
+			return isLoopbackHost(new URL(url).hostname);
+		} catch {
+			return false;
+		}
+	})();
+	if (urlOverride) return {
+		url,
+		token: explicitAuth.token,
+		password: explicitAuth.password,
+		allowInsecureLocalOperatorUi
+	};
+	if (isRemoteMode) {
+		const resolved = await resolveGatewayInteractiveSurfaceAuth({
+			config,
+			env,
+			explicitAuth,
+			surface: "remote"
+		});
+		if (resolved.failureReason) throwGatewayAuthResolutionError(resolved.failureReason);
+		return {
+			url,
+			token: resolved.token,
+			password: resolved.password,
+			allowInsecureLocalOperatorUi: false
+		};
+	}
+	if (gatewayAuthMode === "none" || gatewayAuthMode === "trusted-proxy") {
+		const resolved = await resolveGatewayInteractiveSurfaceAuth({
+			config,
+			env,
+			explicitAuth,
+			surface: "local"
+		});
+		return {
+			url,
+			token: resolved.token,
+			password: resolved.password,
+			allowInsecureLocalOperatorUi
+		};
+	}
+	try {
+		assertExplicitGatewayAuthModeWhenBothConfigured(config);
+	} catch (err) {
+		throwGatewayAuthResolutionError(formatErrorMessage(err));
+	}
+	const resolved = await resolveGatewayInteractiveSurfaceAuth({
+		config,
+		env,
+		explicitAuth,
+		suppressEnvAuthFallback: preferConfiguredAuth,
+		surface: "local"
+	});
+	if (resolved.failureReason) throwGatewayAuthResolutionError(resolved.failureReason);
+	return {
+		url,
+		token: resolved.token,
+		password: resolved.password,
+		allowInsecureLocalOperatorUi
+	};
+}
+//#endregion
+//#region src/tui/components/fuzzy-filter.ts
+/**
+* Shared fuzzy filtering utilities for select list components.
+*/
+/**
+* Word boundary characters for matching.
+*/
+const WORD_BOUNDARY_CHARS = /[\s\-_./:#@]/;
+/**
+* Check if position is at a word boundary.
+*/
+function isWordBoundary(text, index) {
+	return index === 0 || WORD_BOUNDARY_CHARS.test(text[index - 1] ?? "");
+}
+/**
+* Find index where query matches at a word boundary in text.
+* Returns null if no match.
+*/
+function findWordBoundaryIndex(text, query) {
+	if (!query) return null;
+	const textLower = normalizeLowercaseStringOrEmpty(text);
+	const queryLower = normalizeLowercaseStringOrEmpty(query);
+	const maxIndex = textLower.length - queryLower.length;
+	if (maxIndex < 0) return null;
+	for (let i = 0; i <= maxIndex; i++) if (textLower.startsWith(queryLower, i) && isWordBoundary(textLower, i)) return i;
+	return null;
+}
+/**
+* Fuzzy match with pre-lowercased inputs (avoids toLowerCase on every keystroke).
+* Returns score (lower = better) or null if no match.
+*/
+function fuzzyMatchLower(queryLower, textLower) {
+	if (queryLower.length === 0) return 0;
+	if (queryLower.length > textLower.length) return null;
+	let queryIndex = 0;
+	let score = 0;
+	let lastMatchIndex = -1;
+	let consecutiveMatches = 0;
+	for (let i = 0; i < textLower.length && queryIndex < queryLower.length; i++) if (textLower[i] === queryLower[queryIndex]) {
+		const isAtWordBoundary = isWordBoundary(textLower, i);
+		if (lastMatchIndex === i - 1) {
+			consecutiveMatches++;
+			score -= consecutiveMatches * 5;
+		} else {
+			consecutiveMatches = 0;
+			if (lastMatchIndex >= 0) score += (i - lastMatchIndex - 1) * 2;
+		}
+		if (isAtWordBoundary) score -= 10;
+		score += i * .1;
+		lastMatchIndex = i;
+		queryIndex++;
+	}
+	return queryIndex < queryLower.length ? null : score;
+}
+/**
+* Filter items using pre-lowercased searchTextLower field.
+* Supports space-separated tokens (all must match).
+*/
+function fuzzyFilterLower(items, queryLower) {
+	const trimmed = queryLower.trim();
+	if (!trimmed) return items;
+	const tokens = trimmed.split(/\s+/).filter((t) => t.length > 0);
+	if (tokens.length === 0) return items;
+	const results = [];
+	for (const item of items) {
+		const text = item.searchTextLower ?? "";
+		let totalScore = 0;
+		let allMatch = true;
+		for (const token of tokens) {
+			const score = fuzzyMatchLower(token, text);
+			if (score !== null) totalScore += score;
+			else {
+				allMatch = false;
+				break;
+			}
+		}
+		if (allMatch) results.push({
+			item,
+			score: totalScore
+		});
+	}
+	results.sort((a, b) => a.score - b.score);
+	return results.map((r) => r.item);
+}
+/**
+* Prepare items for fuzzy filtering by pre-computing lowercase search text.
+*/
+function prepareSearchItems(items) {
+	return items.map((item) => {
+		const parts = [];
+		if (item.label) parts.push(item.label);
+		if (item.description) parts.push(item.description);
+		if (item.searchText) parts.push(item.searchText);
+		return {
+			...item,
+			searchTextLower: normalizeLowercaseStringOrEmpty(parts.join(" "))
+		};
+	});
+}
+//#endregion
+//#region src/tui/components/filterable-select-list.ts
+/**
+* Combines text input filtering with a select list.
+* User types to filter, arrows/j/k to navigate, Enter to select, Escape to clear/cancel.
+*/
+var FilterableSelectList = class {
+	constructor(items, maxVisible, theme) {
+		this.filterText = "";
+		this.allItems = prepareSearchItems(items);
+		this.maxVisible = maxVisible;
+		this.theme = theme;
+		this.input = new Input();
+		this.selectList = new SelectList(this.allItems, maxVisible, theme);
+	}
+	applyFilter() {
+		const queryLower = normalizeLowercaseStringOrEmpty(this.filterText);
+		if (!queryLower.trim()) {
+			this.selectList = new SelectList(this.allItems, this.maxVisible, this.theme);
+			return;
+		}
+		const filtered = fuzzyFilterLower(this.allItems, queryLower);
+		this.selectList = new SelectList(filtered, this.maxVisible, this.theme);
+	}
+	invalidate() {
+		this.input.invalidate();
+		this.selectList.invalidate();
+	}
+	render(width) {
+		const lines = [];
+		const filterLabel = this.theme.filterLabel("Filter: ");
+		const inputText = this.input.render(width - 8)[0] ?? "";
+		lines.push(filterLabel + inputText);
+		lines.push(chalk.dim("─".repeat(Math.max(0, width))));
+		const listLines = this.selectList.render(width);
+		lines.push(...listLines);
+		return lines;
+	}
+	handleInput(keyData) {
+		const allowVimNav = !this.filterText.trim();
+		if (matchesKey(keyData, "up") || matchesKey(keyData, "ctrl+p") || allowVimNav && keyData === "k") {
+			this.selectList.handleInput("\x1B[A");
+			return;
+		}
+		if (matchesKey(keyData, "down") || matchesKey(keyData, "ctrl+n") || allowVimNav && keyData === "j") {
+			this.selectList.handleInput("\x1B[B");
+			return;
+		}
+		if (matchesKey(keyData, "enter")) {
+			const selected = this.selectList.getSelectedItem();
+			if (selected) this.onSelect?.(selected);
+			return;
+		}
+		if (matchesKey(keyData, "escape") || keyData === "") {
+			if (this.filterText) {
+				this.filterText = "";
+				this.input.setValue("");
+				this.applyFilter();
+			} else this.onCancel?.();
+			return;
+		}
+		const prevValue = this.input.getValue();
+		this.input.handleInput(keyData);
+		const newValue = this.input.getValue();
+		if (newValue !== prevValue) {
+			this.filterText = newValue;
+			this.applyFilter();
+		}
+	}
+	getSelectedItem() {
+		return this.selectList.getSelectedItem();
+	}
+	getFilterText() {
+		return this.filterText;
+	}
+};
+//#endregion
+//#region src/tui/components/searchable-select-list.ts
+const ANSI_SGR_REGEX = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+/**
+* A select list with a search input at the top for fuzzy filtering.
+*/
+var SearchableSelectList = class SearchableSelectList {
+	static {
+		this.DESCRIPTION_LAYOUT_MIN_WIDTH = 40;
+	}
+	static {
+		this.DESCRIPTION_MIN_WIDTH = 12;
+	}
+	static {
+		this.DESCRIPTION_SPACING_WIDTH = 2;
+	}
+	static {
+		this.RIGHT_MARGIN_WIDTH = 2;
+	}
+	constructor(items, maxVisible, theme) {
+		this.selectedIndex = 0;
+		this.regexCache = /* @__PURE__ */ new Map();
+		this.compareByScore = (a, b) => {
+			if (a.tier !== b.tier) return a.tier - b.tier;
+			if (a.score !== b.score) return a.score - b.score;
+			return this.getItemLabel(a.item).localeCompare(this.getItemLabel(b.item));
+		};
+		this.items = items;
+		this.filteredItems = items;
+		this.maxVisible = maxVisible;
+		this.theme = theme;
+		this.searchInput = new Input();
+	}
+	getCachedRegex(pattern) {
+		let regex = this.regexCache.get(pattern);
+		if (!regex) {
+			regex = new RegExp(this.escapeRegex(pattern), "gi");
+			this.regexCache.set(pattern, regex);
+		}
+		return regex;
+	}
+	updateFilter() {
+		const query = this.searchInput.getValue().trim();
+		if (!query) this.filteredItems = this.items;
+		else this.filteredItems = this.smartFilter(query);
+		this.selectedIndex = 0;
+		this.notifySelectionChange();
+	}
+	/**
+	* Smart filtering that prioritizes:
+	* 1. Exact substring match in label (highest priority)
+	* 2. Word-boundary prefix match in label
+	* 3. Exact substring in description
+	* 4. Fuzzy match (lowest priority)
+	*/
+	smartFilter(query) {
+		const q = normalizeLowercaseStringOrEmpty(query);
+		const scoredItems = [];
+		const fuzzyCandidates = [];
+		for (const item of this.items) {
+			const rawLabel = this.getItemLabel(item);
+			const rawDesc = item.description ?? "";
+			const label = normalizeLowercaseStringOrEmpty(stripAnsi$1(rawLabel));
+			const desc = normalizeLowercaseStringOrEmpty(stripAnsi$1(rawDesc));
+			const labelIndex = label.indexOf(q);
+			if (labelIndex !== -1) {
+				scoredItems.push({
+					item,
+					tier: 0,
+					score: labelIndex
+				});
+				continue;
+			}
+			const wordBoundaryIndex = findWordBoundaryIndex(label, q);
+			if (wordBoundaryIndex !== null) {
+				scoredItems.push({
+					item,
+					tier: 1,
+					score: wordBoundaryIndex
+				});
+				continue;
+			}
+			const descIndex = desc.indexOf(q);
+			if (descIndex !== -1) {
+				scoredItems.push({
+					item,
+					tier: 2,
+					score: descIndex
+				});
+				continue;
+			}
+			const searchText = item.searchText ?? "";
+			fuzzyCandidates.push({
+				item,
+				searchTextLower: normalizeLowercaseStringOrEmpty([
+					rawLabel,
+					rawDesc,
+					searchText
+				].map((value) => stripAnsi$1(value)).filter(Boolean).join(" "))
+			});
+		}
+		scoredItems.sort(this.compareByScore);
+		const fuzzyMatches = fuzzyFilterLower(fuzzyCandidates, q);
+		return [...scoredItems.map((s) => s.item), ...fuzzyMatches.map((entry) => entry.item)];
+	}
+	escapeRegex(str) {
+		return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}
+	getItemLabel(item) {
+		return item.label || item.value;
+	}
+	splitAnsiParts(text) {
+		const parts = [];
+		ANSI_SGR_REGEX.lastIndex = 0;
+		let lastIndex = 0;
+		let match;
+		while ((match = ANSI_SGR_REGEX.exec(text)) !== null) {
+			if (match.index > lastIndex) parts.push({
+				text: text.slice(lastIndex, match.index),
+				isAnsi: false
+			});
+			parts.push({
+				text: match[0],
+				isAnsi: true
+			});
+			lastIndex = match.index + match[0].length;
+		}
+		if (lastIndex < text.length) parts.push({
+			text: text.slice(lastIndex),
+			isAnsi: false
+		});
+		return parts;
+	}
+	highlightMatch(text, query) {
+		const tokens = query.trim().split(/\s+/).map((token) => normalizeLowercaseStringOrEmpty(token)).filter((token) => token.length > 0);
+		if (tokens.length === 0) return text;
+		const uniqueTokens = Array.from(new Set(tokens)).toSorted((a, b) => b.length - a.length);
+		let parts = this.splitAnsiParts(text);
+		for (const token of uniqueTokens) {
+			const regex = this.getCachedRegex(token);
+			const nextParts = [];
+			for (const part of parts) {
+				if (part.isAnsi) {
+					nextParts.push(part);
+					continue;
+				}
+				regex.lastIndex = 0;
+				const replaced = part.text.replace(regex, (match) => this.theme.matchHighlight(match));
+				if (replaced === part.text) {
+					nextParts.push(part);
+					continue;
+				}
+				nextParts.push(...this.splitAnsiParts(replaced));
+			}
+			parts = nextParts;
+		}
+		return parts.map((part) => part.text).join("");
+	}
+	setSelectedIndex(index) {
+		this.selectedIndex = Math.max(0, Math.min(index, this.filteredItems.length - 1));
+	}
+	invalidate() {
+		this.searchInput.invalidate();
+	}
+	render(width) {
+		const lines = [];
+		const prompt = this.theme.searchPrompt("search: ");
+		const inputWidth = Math.max(1, width - visibleWidth(prompt));
+		const inputText = this.searchInput.render(inputWidth)[0] ?? "";
+		lines.push(`${prompt}${this.theme.searchInput(inputText)}`);
+		lines.push("");
+		const query = this.searchInput.getValue().trim();
+		if (this.filteredItems.length === 0) {
+			lines.push(this.theme.noMatch("  No matches"));
+			return lines;
+		}
+		const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredItems.length - this.maxVisible));
+		const endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
+		for (let i = startIndex; i < endIndex; i++) {
+			const item = this.filteredItems[i];
+			if (!item) continue;
+			const isSelected = i === this.selectedIndex;
+			lines.push(this.renderItemLine(item, isSelected, width, query));
+		}
+		if (this.filteredItems.length > this.maxVisible) {
+			const scrollInfo = `${this.selectedIndex + 1}/${this.filteredItems.length}`;
+			lines.push(this.theme.scrollInfo(`  ${scrollInfo}`));
+		}
+		return lines;
+	}
+	renderItemLine(item, isSelected, width, query) {
+		const prefix = isSelected ? "→ " : "  ";
+		const prefixWidth = prefix.length;
+		const displayValue = this.getItemLabel(item);
+		const description = item.description;
+		if (description) {
+			const descriptionLayout = this.getDescriptionLayout(width, prefixWidth);
+			if (descriptionLayout) {
+				const truncatedValue = truncateToWidth(displayValue, descriptionLayout.maxValueWidth, "");
+				const valueText = this.highlightMatch(truncatedValue, query);
+				const usedByValue = visibleWidth(valueText);
+				const descriptionWidth = descriptionLayout.availableWidth - usedByValue - descriptionLayout.spacingWidth;
+				if (descriptionWidth >= SearchableSelectList.DESCRIPTION_MIN_WIDTH) {
+					const spacing = " ".repeat(descriptionLayout.spacingWidth);
+					const truncatedDesc = truncateToWidth(description, descriptionWidth, "");
+					const highlightedDesc = this.highlightMatch(truncatedDesc, query);
+					const line = `${prefix}${valueText}${spacing}${isSelected ? highlightedDesc : this.theme.description(highlightedDesc)}`;
+					return isSelected ? this.theme.selectedText(line) : line;
+				}
+			}
+		}
+		const truncatedValue = truncateToWidth(displayValue, width - prefixWidth - 2, "");
+		const line = `${prefix}${this.highlightMatch(truncatedValue, query)}`;
+		return isSelected ? this.theme.selectedText(line) : line;
+	}
+	getDescriptionLayout(width, prefixWidth) {
+		if (width <= SearchableSelectList.DESCRIPTION_LAYOUT_MIN_WIDTH) return null;
+		const availableWidth = Math.max(1, width - prefixWidth - SearchableSelectList.RIGHT_MARGIN_WIDTH);
+		const maxValueWidth = availableWidth - SearchableSelectList.DESCRIPTION_MIN_WIDTH - SearchableSelectList.DESCRIPTION_SPACING_WIDTH;
+		if (maxValueWidth < 1) return null;
+		return {
+			availableWidth,
+			maxValueWidth,
+			spacingWidth: SearchableSelectList.DESCRIPTION_SPACING_WIDTH
+		};
+	}
+	handleInput(keyData) {
+		if (isKeyRelease(keyData)) return;
+		if (matchesKey(keyData, "up") || matchesKey(keyData, "ctrl+p")) {
+			this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+			this.notifySelectionChange();
+			return;
+		}
+		if (matchesKey(keyData, "down") || matchesKey(keyData, "ctrl+n")) {
+			this.selectedIndex = Math.min(this.filteredItems.length - 1, this.selectedIndex + 1);
+			this.notifySelectionChange();
+			return;
+		}
+		if (matchesKey(keyData, "enter")) {
+			const item = this.filteredItems[this.selectedIndex];
+			if (item && this.onSelect) this.onSelect(item);
+			return;
+		}
+		if (matchesKey(keyData, "escape") || keyData === "") {
+			if (this.onCancel) this.onCancel();
+			return;
+		}
+		const prevValue = this.searchInput.getValue();
+		this.searchInput.handleInput(keyData);
+		if (prevValue !== this.searchInput.getValue()) this.updateFilter();
+	}
+	notifySelectionChange() {
+		const item = this.filteredItems[this.selectedIndex];
+		if (item && this.onSelectionChange) this.onSelectionChange(item);
+	}
+	getSelectedItem() {
+		return this.filteredItems[this.selectedIndex] ?? null;
+	}
+};
+//#endregion
+//#region src/tui/components/selectors.ts
+function createSearchableSelectList(items, maxVisible = 7) {
+	return new SearchableSelectList(items, maxVisible, searchableSelectListTheme);
+}
+function createFilterableSelectList(items, maxVisible = 7) {
+	return new FilterableSelectList(items, maxVisible, filterableSelectListTheme);
+}
+function createSettingsList(items, onChange, onCancel, maxVisible = 7) {
+	return new SettingsList(items, maxVisible, settingsListTheme, onChange, onCancel);
+}
+//#endregion
+//#region src/tui/tui-status-summary.ts
+function formatStatusSummary(summary) {
+	const lines = [];
+	lines.push("Gateway status");
+	if (summary.runtimeVersion) lines.push(`Version: ${summary.runtimeVersion}`);
+	if (!summary.linkChannel) lines.push("Link channel: unknown");
+	else {
+		const linkLabel = summary.linkChannel.label ?? "Link channel";
+		const linked = summary.linkChannel.linked === true;
+		const authAge = linked && typeof summary.linkChannel.authAgeMs === "number" ? ` (last refreshed ${formatTimeAgo(summary.linkChannel.authAgeMs)})` : "";
+		lines.push(`${linkLabel}: ${linked ? "linked" : "not linked"}${authAge}`);
+	}
+	const providerSummary = Array.isArray(summary.providerSummary) ? summary.providerSummary : [];
+	if (providerSummary.length > 0) {
+		lines.push("");
+		lines.push("System:");
+		for (const line of providerSummary) lines.push(`  ${line}`);
+	}
+	const sessionPaths = summary.sessions?.paths ?? [];
+	if (sessionPaths.length === 1) lines.push(`Session store: ${sessionPaths[0]}`);
+	else if (sessionPaths.length > 1) lines.push(`Session stores: ${sessionPaths.length}`);
+	const defaults = summary.sessions?.defaults;
+	const defaultModel = defaults?.model ?? "unknown";
+	const defaultCtx = typeof defaults?.contextTokens === "number" ? ` (${formatTokenCount(defaults.contextTokens)} ctx)` : "";
+	lines.push(`Default model: ${defaultModel}${defaultCtx}`);
+	const sessionCount = summary.sessions?.count ?? 0;
+	lines.push(`Active sessions: ${sessionCount}`);
+	const recent = Array.isArray(summary.sessions?.recent) ? summary.sessions?.recent : [];
+	if (recent.length > 0) {
+		lines.push("Recent sessions:");
+		for (const entry of recent) {
+			const ageLabel = typeof entry.age === "number" ? formatTimeAgo(entry.age) : "no activity";
+			const model = entry.model ?? "unknown";
+			const usage = formatContextUsageLine({
+				total: entry.totalTokens ?? null,
+				context: entry.contextTokens ?? null,
+				remaining: entry.remainingTokens ?? null,
+				percent: entry.percentUsed ?? null
+			});
+			const flags = entry.flags?.length ? ` | flags: ${entry.flags.join(", ")}` : "";
+			lines.push(`- ${entry.key}${entry.kind ? ` [${entry.kind}]` : ""} | ${ageLabel} | model ${model} | ${usage}${flags}`);
+		}
+	}
+	const queued = Array.isArray(summary.queuedSystemEvents) ? summary.queuedSystemEvents : [];
+	if (queued.length > 0) {
+		const preview = queued.slice(0, 3).join(" | ");
+		lines.push(`Queued system events (${queued.length}): ${preview}`);
+	}
+	return lines;
+}
+//#endregion
+//#region src/tui/tui-command-handlers.ts
+function isBtwCommand(text) {
+	return /^\/btw(?::|\s|$)/i.test(text.trim());
+}
+function createCommandHandlers(context) {
+	const { client, chatLog, tui, opts, state, deliverDefault, openOverlay, closeOverlay, refreshSessionInfo, loadHistory, setSession, refreshAgents, abortActive, setActivityStatus, formatSessionKey, applySessionInfoFromPatch, noteLocalBtwRunId, forgetLocalRunId, forgetLocalBtwRunId, runAuthFlow, requestExit } = context;
+	const setAgent = async (id) => {
+		state.currentAgentId = normalizeAgentId(id);
+		await setSession("");
+	};
+	const closeOverlayAndRender = () => {
+		closeOverlay();
+		tui.requestRender();
+	};
+	const openSelector = (selector, onSelect) => {
+		selector.onSelect = (item) => {
+			(async () => {
+				await onSelect(item.value);
+				closeOverlayAndRender();
+			})();
+		};
+		selector.onCancel = closeOverlayAndRender;
+		openOverlay(selector);
+		tui.requestRender();
+	};
+	const openModelSelector = async () => {
+		try {
+			const models = await client.listModels();
+			if (models.length === 0) {
+				chatLog.addSystem("no models available");
+				tui.requestRender();
+				return;
+			}
+			openSelector(createSearchableSelectList(models.map((model) => ({
+				value: `${model.provider}/${model.id}`,
+				label: `${model.provider}/${model.id}`,
+				description: model.name && model.name !== model.id ? model.name : ""
+			})), 9), async (value) => {
+				try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						model: value
+					});
+					chatLog.addSystem(`model set to ${value}`);
+					applySessionInfoFromPatch(result);
+					await refreshSessionInfo();
+				} catch (err) {
+					chatLog.addSystem(`model set failed: ${String(err)}`);
+				}
+			});
+		} catch (err) {
+			chatLog.addSystem(`model list failed: ${String(err)}`);
+			tui.requestRender();
+		}
+	};
+	const openAgentSelector = async () => {
+		await refreshAgents();
+		if (state.agents.length === 0) {
+			chatLog.addSystem("no agents found");
+			tui.requestRender();
+			return;
+		}
+		openSelector(createSearchableSelectList(state.agents.map((agent) => ({
+			value: agent.id,
+			label: agent.name ? `${agent.id} (${agent.name})` : agent.id,
+			description: agent.id === state.agentDefaultId ? "default" : ""
+		})), 9), async (value) => {
+			await setAgent(value);
+		});
+	};
+	const openSessionSelector = async () => {
+		try {
+			openSelector(createFilterableSelectList((await client.listSessions({
+				includeGlobal: false,
+				includeUnknown: false,
+				includeDerivedTitles: true,
+				includeLastMessage: true,
+				agentId: state.currentAgentId
+			})).sessions.map((session) => {
+				const title = session.derivedTitle ?? session.displayName;
+				const formattedKey = formatSessionKey(session.key);
+				const label = title && title !== formattedKey ? `${title} (${formattedKey})` : formattedKey;
+				const timePart = session.updatedAt ? formatRelativeTimestamp(session.updatedAt, {
+					dateFallback: true,
+					fallback: ""
+				}) : "";
+				const preview = session.lastMessagePreview?.replace(/\s+/g, " ").trim();
+				const description = timePart && preview ? `${timePart} · ${preview}` : preview ?? timePart;
+				return {
+					value: session.key,
+					label,
+					description,
+					searchText: [
+						session.displayName,
+						session.label,
+						session.subject,
+						session.sessionId,
+						session.key,
+						session.lastMessagePreview
+					].filter(Boolean).join(" ")
+				};
+			}), 9), async (value) => {
+				await setSession(value);
+			});
+		} catch (err) {
+			chatLog.addSystem(`sessions list failed: ${String(err)}`);
+			tui.requestRender();
+		}
+	};
+	const openSettings = () => {
+		openOverlay(createSettingsList([{
+			id: "tools",
+			label: "Tool output",
+			currentValue: state.toolsExpanded ? "expanded" : "collapsed",
+			values: ["collapsed", "expanded"]
+		}, {
+			id: "thinking",
+			label: "Show thinking",
+			currentValue: state.showThinking ? "on" : "off",
+			values: ["off", "on"]
+		}], (id, value) => {
+			if (id === "tools") {
+				state.toolsExpanded = value === "expanded";
+				chatLog.setToolsExpanded(state.toolsExpanded);
+			}
+			if (id === "thinking") {
+				state.showThinking = value === "on";
+				loadHistory();
+			}
+			tui.requestRender();
+		}, () => {
+			closeOverlay();
+			tui.requestRender();
+		}));
+		tui.requestRender();
+	};
+	const handleCommand = async (raw) => {
+		const { name, args } = parseCommand(raw);
+		if (!name) return;
+		switch (name) {
+			case "help":
+				chatLog.addSystem(helpText({
+					local: opts.local,
+					provider: state.sessionInfo.modelProvider,
+					model: state.sessionInfo.model
+				}));
+				break;
+			case "auth": {
+				if (!runAuthFlow) {
+					chatLog.addSystem("auth login is only available in local embedded mode");
+					break;
+				}
+				if (state.activeChatRunId || state.pendingOptimisticUserMessage) {
+					chatLog.addSystem("abort the current run before /auth");
+					break;
+				}
+				const provider = args.trim() || state.sessionInfo.modelProvider || void 0;
+				chatLog.addSystem(provider ? `opening auth flow for ${provider}; TUI will resume when it exits` : "opening auth flow; TUI will resume when it exits");
+				tui.requestRender();
+				setActivityStatus("auth");
+				try {
+					const result = await runAuthFlow({ provider });
+					await refreshSessionInfo();
+					if (result.exitCode === 0 && !result.signal) {
+						chatLog.addSystem(provider ? `auth flow finished for ${provider}` : "auth flow finished");
+						setActivityStatus("idle");
+					} else {
+						const failureSuffix = result.signal ? ` (signal ${result.signal})` : typeof result.exitCode === "number" ? ` (exit ${String(result.exitCode)})` : "";
+						chatLog.addSystem(`auth flow failed${failureSuffix}`);
+						setActivityStatus("error");
+					}
+				} catch (err) {
+					chatLog.addSystem(`auth flow failed: ${sanitizeRenderableText(String(err))}`);
+					setActivityStatus("error");
+				}
+				break;
+			}
+			case "gateway-status":
+				try {
+					const status = await client.getGatewayStatus();
+					if (typeof status === "string") {
+						chatLog.addSystem(status);
+						break;
+					}
+					if (status && typeof status === "object") {
+						const lines = formatStatusSummary(status);
+						for (const line of lines) chatLog.addSystem(line);
+						break;
+					}
+					chatLog.addSystem("status: unknown response");
+				} catch (err) {
+					chatLog.addSystem(`status failed: ${String(err)}`);
+				}
+				break;
+			case "agent":
+				if (!args) await openAgentSelector();
+				else await setAgent(args);
+				break;
+			case "agents":
+				await openAgentSelector();
+				break;
+			case "session":
+				if (!args) await openSessionSelector();
+				else await setSession(args);
+				break;
+			case "sessions":
+				await openSessionSelector();
+				break;
+			case "model":
+				if (!args) await openModelSelector();
+				else try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						model: args
+					});
+					chatLog.addSystem(`model set to ${args}`);
+					applySessionInfoFromPatch(result);
+					await refreshSessionInfo();
+				} catch (err) {
+					chatLog.addSystem(`model set failed: ${String(err)}`);
+				}
+				break;
+			case "models":
+				await openModelSelector();
+				break;
+			case "think":
+				if (!args) {
+					const levels = formatThinkingLevels(state.sessionInfo.modelProvider, state.sessionInfo.model, "|");
+					chatLog.addSystem(`usage: /think <${levels}>`);
+					break;
+				}
+				try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						thinkingLevel: args
+					});
+					chatLog.addSystem(`thinking set to ${args}`);
+					applySessionInfoFromPatch(result);
+					await refreshSessionInfo();
+				} catch (err) {
+					chatLog.addSystem(`think failed: ${String(err)}`);
+				}
+				break;
+			case "verbose":
+				if (!args) {
+					chatLog.addSystem("usage: /verbose <on|off>");
+					break;
+				}
+				try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						verboseLevel: args
+					});
+					chatLog.addSystem(`verbose set to ${args}`);
+					applySessionInfoFromPatch(result);
+					await loadHistory();
+				} catch (err) {
+					chatLog.addSystem(`verbose failed: ${String(err)}`);
+				}
+				break;
+			case "trace":
+				if (!args) {
+					chatLog.addSystem("usage: /trace <on|off>");
+					break;
+				}
+				try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						traceLevel: args
+					});
+					chatLog.addSystem(`trace set to ${args}`);
+					applySessionInfoFromPatch(result);
+					await loadHistory();
+				} catch (err) {
+					chatLog.addSystem(`trace failed: ${String(err)}`);
+				}
+				break;
+			case "fast":
+				if (!args || args === "status") {
+					chatLog.addSystem(`fast mode: ${state.sessionInfo.fastMode ? "on" : "off"}`);
+					break;
+				}
+				if (args !== "on" && args !== "off") {
+					chatLog.addSystem("usage: /fast <status|on|off>");
+					break;
+				}
+				try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						fastMode: args === "on"
+					});
+					chatLog.addSystem(`fast mode ${args === "on" ? "enabled" : "disabled"}`);
+					applySessionInfoFromPatch(result);
+					await refreshSessionInfo();
+				} catch (err) {
+					chatLog.addSystem(`fast failed: ${String(err)}`);
+				}
+				break;
+			case "reasoning":
+				if (!args) {
+					chatLog.addSystem("usage: /reasoning <on|off>");
+					break;
+				}
+				try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						reasoningLevel: args
+					});
+					chatLog.addSystem(`reasoning set to ${args}`);
+					applySessionInfoFromPatch(result);
+					await refreshSessionInfo();
+				} catch (err) {
+					chatLog.addSystem(`reasoning failed: ${String(err)}`);
+				}
+				break;
+			case "usage": {
+				const normalized = args ? normalizeUsageDisplay(args) : void 0;
+				if (args && !normalized) {
+					chatLog.addSystem("usage: /usage <off|tokens|full>");
+					break;
+				}
+				const currentRaw = state.sessionInfo.responseUsage;
+				const current = resolveResponseUsageMode(currentRaw);
+				const next = normalized ?? (current === "off" ? "tokens" : current === "tokens" ? "full" : "off");
+				try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						responseUsage: next === "off" ? null : next
+					});
+					chatLog.addSystem(`usage footer: ${next}`);
+					applySessionInfoFromPatch(result);
+					await refreshSessionInfo();
+				} catch (err) {
+					chatLog.addSystem(`usage failed: ${String(err)}`);
+				}
+				break;
+			}
+			case "elevated":
+				if (!args) {
+					chatLog.addSystem("usage: /elevated <on|off|ask|full>");
+					break;
+				}
+				if (![
+					"on",
+					"off",
+					"ask",
+					"full"
+				].includes(args)) {
+					chatLog.addSystem("usage: /elevated <on|off|ask|full>");
+					break;
+				}
+				try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						elevatedLevel: args
+					});
+					chatLog.addSystem(`elevated set to ${args}`);
+					applySessionInfoFromPatch(result);
+					await refreshSessionInfo();
+				} catch (err) {
+					chatLog.addSystem(`elevated failed: ${String(err)}`);
+				}
+				break;
+			case "activation": {
+				if (!args) {
+					chatLog.addSystem("usage: /activation <mention|always>");
+					break;
+				}
+				const activation = normalizeGroupActivation(args);
+				if (!activation) {
+					chatLog.addSystem("usage: /activation <mention|always>");
+					break;
+				}
+				try {
+					const result = await client.patchSession({
+						key: state.currentSessionKey,
+						groupActivation: activation
+					});
+					chatLog.addSystem(`activation set to ${activation}`);
+					applySessionInfoFromPatch(result);
+					await refreshSessionInfo();
+				} catch (err) {
+					chatLog.addSystem(`activation failed: ${String(err)}`);
+				}
+				break;
+			}
+			case "new":
+				try {
+					state.sessionInfo.inputTokens = null;
+					state.sessionInfo.outputTokens = null;
+					state.sessionInfo.totalTokens = null;
+					tui.requestRender();
+					const uniqueKey = `tui-${randomUUID()}`;
+					await setSession(uniqueKey);
+					chatLog.addSystem(`new session: ${uniqueKey}`);
+				} catch (err) {
+					chatLog.addSystem(`new session failed: ${sanitizeRenderableText(String(err))}`);
+				}
+				break;
+			case "reset":
+				try {
+					state.sessionInfo.inputTokens = null;
+					state.sessionInfo.outputTokens = null;
+					state.sessionInfo.totalTokens = null;
+					tui.requestRender();
+					await client.resetSession(state.currentSessionKey, name);
+					chatLog.addSystem(`session ${state.currentSessionKey} reset`);
+					await loadHistory();
+				} catch (err) {
+					chatLog.addSystem(`reset failed: ${sanitizeRenderableText(String(err))}`);
+				}
+				break;
+			case "abort":
+				await abortActive();
+				break;
+			case "settings":
+				openSettings();
+				break;
+			case "exit":
+			case "quit":
+				requestExit();
+				break;
+			default:
+				await sendMessage(raw);
+				break;
+		}
+		tui.requestRender();
+	};
+	const sendMessage = async (text) => {
+		if (!state.isConnected) {
+			chatLog.addSystem(opts.local ? "local runtime not ready — message not sent" : "not connected to gateway — message not sent");
+			setActivityStatus("disconnected");
+			tui.requestRender();
+			return;
+		}
+		const isBtw = isBtwCommand(text);
+		const runId = randomUUID();
+		try {
+			if (!isBtw) {
+				chatLog.addUser(text);
+				state.pendingOptimisticUserMessage = true;
+				setActivityStatus("sending");
+			} else noteLocalBtwRunId?.(runId);
+			tui.requestRender();
+			await client.sendChat({
+				sessionKey: state.currentSessionKey,
+				message: text,
+				thinking: opts.thinking,
+				deliver: deliverDefault,
+				timeoutMs: opts.timeoutMs,
+				runId
+			});
+			if (!isBtw) {
+				setActivityStatus("waiting");
+				tui.requestRender();
+			}
+		} catch (err) {
+			if (isBtw) forgetLocalBtwRunId?.(runId);
+			if (!isBtw && state.activeChatRunId) forgetLocalRunId?.(state.activeChatRunId);
+			if (!isBtw) {
+				state.pendingOptimisticUserMessage = false;
+				state.activeChatRunId = null;
+			}
+			chatLog.addSystem(`${isBtw ? "btw failed" : "send failed"}: ${String(err)}`);
+			if (!isBtw) setActivityStatus("error");
+			tui.requestRender();
+		}
+	};
+	return {
+		handleCommand,
+		sendMessage,
+		openModelSelector,
+		openAgentSelector,
+		openSessionSelector,
+		openSettings,
+		setAgent
+	};
+}
+//#endregion
+//#region src/tui/tui-stream-assembler.ts
+function extractTextBlocksAndSignals(message) {
+	if (!message || typeof message !== "object") return {
+		textBlocks: [],
+		sawNonTextContentBlocks: false
+	};
+	const content = message.content;
+	if (typeof content === "string") {
+		const text = content.trim();
+		return {
+			textBlocks: text ? [text] : [],
+			sawNonTextContentBlocks: false
+		};
+	}
+	if (!Array.isArray(content)) return {
+		textBlocks: [],
+		sawNonTextContentBlocks: false
+	};
+	const textBlocks = [];
+	let sawNonTextContentBlocks = false;
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const rec = block;
+		if (rec.type === "text" && typeof rec.text === "string") {
+			const text = rec.text.trim();
+			if (text) textBlocks.push(text);
+			continue;
+		}
+		if (typeof rec.type === "string" && rec.type !== "thinking") sawNonTextContentBlocks = true;
+	}
+	return {
+		textBlocks,
+		sawNonTextContentBlocks
+	};
+}
+function isDroppedBoundaryTextBlockSubset(params) {
+	const { streamedTextBlocks, finalTextBlocks } = params;
+	if (finalTextBlocks.length === 0 || finalTextBlocks.length >= streamedTextBlocks.length) return false;
+	if (finalTextBlocks.every((block, index) => streamedTextBlocks[index] === block)) return true;
+	const suffixStart = streamedTextBlocks.length - finalTextBlocks.length;
+	return finalTextBlocks.every((block, index) => streamedTextBlocks[suffixStart + index] === block);
+}
+function shouldPreserveBoundaryDroppedText(params) {
+	if (params.boundaryDropMode === "off") return false;
+	if (!(params.boundaryDropMode === "streamed-or-incoming" ? params.streamedSawNonTextContentBlocks || params.incomingSawNonTextContentBlocks : params.streamedSawNonTextContentBlocks)) return false;
+	return isDroppedBoundaryTextBlockSubset({
+		streamedTextBlocks: params.streamedTextBlocks,
+		finalTextBlocks: params.nextContentBlocks
+	});
+}
+var TuiStreamAssembler = class {
+	constructor() {
+		this.runs = /* @__PURE__ */ new Map();
+	}
+	getOrCreateRun(runId) {
+		let state = this.runs.get(runId);
+		if (!state) {
+			state = {
+				thinkingText: "",
+				contentText: "",
+				contentBlocks: [],
+				sawNonTextContentBlocks: false,
+				displayText: ""
+			};
+			this.runs.set(runId, state);
+		}
+		return state;
+	}
+	updateRunState(state, message, showThinking, opts) {
+		const thinkingText = extractThinkingFromMessage(message);
+		const contentText = extractContentFromMessage(message);
+		const { textBlocks, sawNonTextContentBlocks } = extractTextBlocksAndSignals(message);
+		if (thinkingText) state.thinkingText = thinkingText;
+		if (contentText) {
+			const nextContentBlocks = textBlocks.length > 0 ? textBlocks : [contentText];
+			if (!shouldPreserveBoundaryDroppedText({
+				boundaryDropMode: opts?.boundaryDropMode ?? "off",
+				streamedSawNonTextContentBlocks: state.sawNonTextContentBlocks,
+				incomingSawNonTextContentBlocks: sawNonTextContentBlocks,
+				streamedTextBlocks: state.contentBlocks,
+				nextContentBlocks
+			})) {
+				state.contentText = contentText;
+				state.contentBlocks = nextContentBlocks;
+			}
+		}
+		if (sawNonTextContentBlocks) state.sawNonTextContentBlocks = true;
+		state.displayText = composeThinkingAndContent({
+			thinkingText: state.thinkingText,
+			contentText: state.contentText,
+			showThinking
+		});
+	}
+	ingestDelta(runId, message, showThinking) {
+		const state = this.getOrCreateRun(runId);
+		const previousDisplayText = state.displayText;
+		this.updateRunState(state, message, showThinking, { boundaryDropMode: "streamed-or-incoming" });
+		if (!state.displayText || state.displayText === previousDisplayText) return null;
+		return state.displayText;
+	}
+	/**
+	* Ingest an incremental assistant-text suffix (gateway `chat-incremental`
+	* capability). Appends to the accumulated content (or replaces it on `reset`)
+	* and recomposes the display text. Chat deltas carry assistant text only, so
+	* accumulated thinking state is left untouched.
+	*/
+	ingestAppendText(runId, appendText, reset, showThinking) {
+		const state = this.getOrCreateRun(runId);
+		const previousDisplayText = state.displayText;
+		const nextContentText = reset ? appendText : state.contentText + appendText;
+		state.contentText = nextContentText;
+		state.contentBlocks = nextContentText ? [nextContentText] : [];
+		state.displayText = composeThinkingAndContent({
+			thinkingText: state.thinkingText,
+			contentText: state.contentText,
+			showThinking
+		});
+		if (!state.displayText || state.displayText === previousDisplayText) return null;
+		return state.displayText;
+	}
+	finalize(runId, message, showThinking, errorMessage) {
+		const state = this.getOrCreateRun(runId);
+		const streamedDisplayText = state.displayText;
+		const streamedTextBlocks = [...state.contentBlocks];
+		const streamedSawNonTextContentBlocks = state.sawNonTextContentBlocks;
+		this.updateRunState(state, message, showThinking, { boundaryDropMode: "streamed-only" });
+		const finalComposed = state.displayText;
+		const finalText = resolveFinalAssistantText({
+			finalText: streamedSawNonTextContentBlocks && isDroppedBoundaryTextBlockSubset({
+				streamedTextBlocks,
+				finalTextBlocks: state.contentBlocks
+			}) ? streamedDisplayText : finalComposed,
+			streamedText: streamedDisplayText,
+			errorMessage
+		});
+		this.runs.delete(runId);
+		return finalText;
+	}
+	drop(runId) {
+		this.runs.delete(runId);
+	}
+};
+//#endregion
+//#region src/tui/tui-event-handlers.ts
+const DEFAULT_STREAMING_WATCHDOG_MS = 3e4;
+function createEventHandlers(context) {
+	const { chatLog, btw, tui, state, setActivityStatus, refreshSessionInfo, loadHistory, noteLocalRunId, isLocalRunId, forgetLocalRunId, clearLocalRunIds, isLocalBtwRunId, forgetLocalBtwRunId, clearLocalBtwRunIds, localMode } = context;
+	const finalizedRuns = /* @__PURE__ */ new Map();
+	const sessionRuns = /* @__PURE__ */ new Map();
+	let streamAssembler = new TuiStreamAssembler();
+	let lastSessionKey = state.currentSessionKey;
+	let pendingHistoryRefresh = false;
+	const streamingWatchdogMs = typeof context.streamingWatchdogMs === "number" && Number.isFinite(context.streamingWatchdogMs) && context.streamingWatchdogMs >= 0 ? Math.floor(context.streamingWatchdogMs) : DEFAULT_STREAMING_WATCHDOG_MS;
+	let streamingWatchdogTimer = null;
+	let streamingWatchdogRunId = null;
+	const clearStreamingWatchdog = () => {
+		if (streamingWatchdogTimer) {
+			clearTimeout(streamingWatchdogTimer);
+			streamingWatchdogTimer = null;
+		}
+		streamingWatchdogRunId = null;
+	};
+	const armStreamingWatchdog = (runId) => {
+		if (streamingWatchdogMs <= 0) return;
+		if (streamingWatchdogTimer) clearTimeout(streamingWatchdogTimer);
+		streamingWatchdogRunId = runId;
+		streamingWatchdogTimer = setTimeout(() => {
+			streamingWatchdogTimer = null;
+			if (streamingWatchdogRunId !== runId || state.activeChatRunId !== runId) return;
+			streamingWatchdogRunId = null;
+			state.activeChatRunId = null;
+			setActivityStatus("idle");
+			chatLog.addSystem(`streaming watchdog: no stream updates for ${Math.round(streamingWatchdogMs / 1e3)}s; resetting status. The backend may have dropped this run silently — send a new message to resync.`);
+			tui.requestRender();
+		}, streamingWatchdogMs);
+		const maybeUnref = streamingWatchdogTimer.unref;
+		if (typeof maybeUnref === "function") maybeUnref.call(streamingWatchdogTimer);
+	};
+	const pruneRunMap = (runs) => {
+		if (runs.size <= 200) return;
+		const keepUntil = Date.now() - 600 * 1e3;
+		for (const [key, ts] of runs) {
+			if (runs.size <= 150) break;
+			if (ts < keepUntil) runs.delete(key);
+		}
+		if (runs.size > 200) for (const key of runs.keys()) {
+			runs.delete(key);
+			if (runs.size <= 150) break;
+		}
+	};
+	const syncSessionKey = () => {
+		if (state.currentSessionKey === lastSessionKey) return;
+		lastSessionKey = state.currentSessionKey;
+		finalizedRuns.clear();
+		sessionRuns.clear();
+		streamAssembler = new TuiStreamAssembler();
+		pendingHistoryRefresh = false;
+		state.pendingOptimisticUserMessage = false;
+		clearLocalRunIds?.();
+		clearLocalBtwRunIds?.();
+		btw.clear();
+		clearStreamingWatchdog();
+	};
+	const flushPendingHistoryRefreshIfIdle = () => {
+		if (!pendingHistoryRefresh || state.activeChatRunId) return;
+		pendingHistoryRefresh = false;
+		loadHistory?.();
+	};
+	const resolveAuthErrorHint = (errorMessage) => {
+		if (!localMode || !isAuthErrorMessage(errorMessage)) return;
+		const provider = state.sessionInfo.modelProvider?.trim();
+		return provider ? `auth or provider access failed for ${provider}. Run /auth ${provider} to refresh credentials; if you already re-authed, switch models/providers because this account may still be blocked for inference.` : "auth or provider access failed for the current provider. Run /auth to refresh credentials; if you already re-authed, switch models/providers because this account may still be blocked for inference.";
+	};
+	const noteSessionRun = (runId) => {
+		sessionRuns.set(runId, Date.now());
+		pruneRunMap(sessionRuns);
+	};
+	const noteFinalizedRun = (runId) => {
+		finalizedRuns.set(runId, Date.now());
+		sessionRuns.delete(runId);
+		streamAssembler.drop(runId);
+		pruneRunMap(finalizedRuns);
+	};
+	const clearActiveRunIfMatch = (runId) => {
+		if (state.activeChatRunId === runId) state.activeChatRunId = null;
+	};
+	const finalizeRun = (params) => {
+		noteFinalizedRun(params.runId);
+		clearActiveRunIfMatch(params.runId);
+		flushPendingHistoryRefreshIfIdle();
+		if (params.wasActiveRun) {
+			setActivityStatus(params.status);
+			clearStreamingWatchdog();
+		} else if (streamingWatchdogRunId === params.runId) clearStreamingWatchdog();
+		refreshSessionInfo?.();
+	};
+	const terminateRun = (params) => {
+		streamAssembler.drop(params.runId);
+		sessionRuns.delete(params.runId);
+		clearActiveRunIfMatch(params.runId);
+		flushPendingHistoryRefreshIfIdle();
+		if (params.wasActiveRun) {
+			setActivityStatus(params.status);
+			clearStreamingWatchdog();
+		} else if (streamingWatchdogRunId === params.runId) clearStreamingWatchdog();
+		refreshSessionInfo?.();
+	};
+	const hasConcurrentActiveRun = (runId) => {
+		const activeRunId = state.activeChatRunId;
+		if (!activeRunId || activeRunId === runId) return false;
+		return sessionRuns.has(activeRunId);
+	};
+	const maybeRefreshHistoryForRun = (runId, opts) => {
+		if (isLocalRunId?.(runId) ?? false) {
+			forgetLocalRunId?.(runId);
+			if (!opts?.allowLocalWithoutDisplayableFinal) return;
+			if (state.activeChatRunId && state.activeChatRunId !== runId) {
+				pendingHistoryRefresh = true;
+				return;
+			}
+		}
+		if (hasConcurrentActiveRun(runId)) return;
+		pendingHistoryRefresh = false;
+		loadHistory?.();
+	};
+	const isSameSessionKey = (left, right) => {
+		const normalizedLeft = normalizeLowercaseStringOrEmpty(left);
+		const normalizedRight = normalizeLowercaseStringOrEmpty(right);
+		if (!normalizedLeft || !normalizedRight) return false;
+		if (normalizedLeft === normalizedRight) return true;
+		const parsedLeft = parseAgentSessionKey(normalizedLeft);
+		const parsedRight = parseAgentSessionKey(normalizedRight);
+		if (parsedLeft && parsedRight) return parsedLeft.agentId === parsedRight.agentId && parsedLeft.rest === parsedRight.rest;
+		if (parsedLeft) return parsedLeft.rest === normalizedRight;
+		if (parsedRight) return normalizedLeft === parsedRight.rest;
+		return false;
+	};
+	const handleChatEvent = (payload) => {
+		if (!payload || typeof payload !== "object") return;
+		const evt = payload;
+		syncSessionKey();
+		if (!isSameSessionKey(evt.sessionKey, state.currentSessionKey)) return;
+		if (finalizedRuns.has(evt.runId)) {
+			if (evt.state === "delta") return;
+			if (evt.state === "final") return;
+		}
+		noteSessionRun(evt.runId);
+		if (!state.activeChatRunId && !isLocalBtwRunId?.(evt.runId)) {
+			state.activeChatRunId = evt.runId;
+			if (state.pendingOptimisticUserMessage) {
+				noteLocalRunId?.(evt.runId);
+				state.pendingOptimisticUserMessage = false;
+			}
+		}
+		if (evt.state === "delta") {
+			setActivityStatus("streaming");
+			if (state.activeChatRunId === evt.runId) armStreamingWatchdog(evt.runId);
+			const displayText = typeof evt.appendText === "string" ? streamAssembler.ingestAppendText(evt.runId, evt.appendText, evt.reset === true, state.showThinking) : streamAssembler.ingestDelta(evt.runId, evt.message, state.showThinking);
+			if (!displayText) return;
+			chatLog.updateAssistant(displayText, evt.runId);
+		}
+		if (evt.state === "final") {
+			const isLocalBtwRun = isLocalBtwRunId?.(evt.runId) ?? false;
+			const wasActiveRun = state.activeChatRunId === evt.runId;
+			if (!evt.message && isLocalBtwRun) {
+				forgetLocalBtwRunId?.(evt.runId);
+				noteFinalizedRun(evt.runId);
+				tui.requestRender();
+				return;
+			}
+			if (!evt.message) {
+				maybeRefreshHistoryForRun(evt.runId, { allowLocalWithoutDisplayableFinal: true });
+				chatLog.dropAssistant(evt.runId);
+				finalizeRun({
+					runId: evt.runId,
+					wasActiveRun,
+					status: "idle"
+				});
+				tui.requestRender();
+				return;
+			}
+			if (isCommandMessage(evt.message)) {
+				maybeRefreshHistoryForRun(evt.runId);
+				const text = extractTextFromMessage(evt.message);
+				if (text) chatLog.addSystem(text);
+				finalizeRun({
+					runId: evt.runId,
+					wasActiveRun,
+					status: "idle"
+				});
+				tui.requestRender();
+				return;
+			}
+			maybeRefreshHistoryForRun(evt.runId);
+			const stopReason = evt.message && typeof evt.message === "object" && !Array.isArray(evt.message) ? typeof evt.message.stopReason === "string" ? evt.message.stopReason : "" : "";
+			const finalText = streamAssembler.finalize(evt.runId, evt.message, state.showThinking, evt.errorMessage);
+			if (finalText === "(no output)" && !isLocalRunId?.(evt.runId)) chatLog.dropAssistant(evt.runId);
+			else chatLog.finalizeAssistant(finalText, evt.runId);
+			finalizeRun({
+				runId: evt.runId,
+				wasActiveRun,
+				status: stopReason === "error" ? "error" : "idle"
+			});
+		}
+		if (evt.state === "aborted") {
+			forgetLocalBtwRunId?.(evt.runId);
+			const wasActiveRun = state.activeChatRunId === evt.runId;
+			chatLog.addSystem("run aborted");
+			terminateRun({
+				runId: evt.runId,
+				wasActiveRun,
+				status: "aborted"
+			});
+			maybeRefreshHistoryForRun(evt.runId);
+		}
+		if (evt.state === "error") {
+			forgetLocalBtwRunId?.(evt.runId);
+			const wasActiveRun = state.activeChatRunId === evt.runId;
+			const errorMessage = evt.errorMessage ?? "unknown";
+			chatLog.addSystem(resolveAuthErrorHint(errorMessage) ?? `run error: ${errorMessage}`);
+			terminateRun({
+				runId: evt.runId,
+				wasActiveRun,
+				status: "error"
+			});
+			maybeRefreshHistoryForRun(evt.runId);
+		}
+		tui.requestRender();
+	};
+	const handleAgentEvent = (payload) => {
+		if (!payload || typeof payload !== "object") return;
+		const evt = payload;
+		syncSessionKey();
+		const isActiveRun = evt.runId === state.activeChatRunId;
+		if (!(isActiveRun || sessionRuns.has(evt.runId) || finalizedRuns.has(evt.runId))) return;
+		if (evt.stream === "tool") {
+			const verbose = state.sessionInfo.verboseLevel ?? "off";
+			const allowToolEvents = verbose !== "off";
+			const allowToolOutput = verbose === "full";
+			if (!allowToolEvents) return;
+			const data = evt.data ?? {};
+			const phase = asString(data.phase, "");
+			const toolCallId = asString(data.toolCallId, "");
+			const toolName = asString(data.name, "tool");
+			if (!toolCallId) return;
+			if (phase === "start") chatLog.startTool(toolCallId, toolName, data.args);
+			else if (phase === "update") {
+				if (!allowToolOutput) return;
+				chatLog.updateToolResult(toolCallId, data.partialResult, { partial: true });
+			} else if (phase === "result") if (allowToolOutput) chatLog.updateToolResult(toolCallId, data.result, { isError: Boolean(data.isError) });
+			else chatLog.updateToolResult(toolCallId, { content: [] }, { isError: Boolean(data.isError) });
+			tui.requestRender();
+			return;
+		}
+		if (evt.stream === "lifecycle") {
+			if (!isActiveRun) return;
+			const phase = typeof evt.data?.phase === "string" ? evt.data.phase : "";
+			if (phase === "start") setActivityStatus("running");
+			if (phase === "end") setActivityStatus("idle");
+			if (phase === "error") setActivityStatus("error");
+			tui.requestRender();
+		}
+	};
+	const handleBtwEvent = (payload) => {
+		if (!payload || typeof payload !== "object") return;
+		const evt = payload;
+		syncSessionKey();
+		if (!isSameSessionKey(evt.sessionKey, state.currentSessionKey)) return;
+		if (evt.kind !== "btw") return;
+		const question = evt.question.trim();
+		const text = evt.text.trim();
+		if (!question || !text) return;
+		btw.showResult({
+			question,
+			text,
+			isError: evt.isError
+		});
+		tui.requestRender();
+	};
+	const dispose = () => {
+		clearStreamingWatchdog();
+	};
+	return {
+		handleChatEvent,
+		handleAgentEvent,
+		handleBtwEvent,
+		dispose
+	};
+}
+//#endregion
+//#region src/tui/tui-local-shell.ts
+function createLocalShellRunner(deps) {
+	let localExecAsked = false;
+	let localExecAllowed = false;
+	const createSelector = deps.createSelector ?? createSearchableSelectList;
+	const spawnCommand = deps.spawnCommand ?? spawn;
+	const getCwd = deps.getCwd ?? (() => process.cwd());
+	const env = deps.env ?? process.env;
+	const maxChars = deps.maxOutputChars ?? 4e4;
+	const ensureLocalExecAllowed = async () => {
+		if (localExecAllowed) return true;
+		if (localExecAsked) return false;
+		localExecAsked = true;
+		return await new Promise((resolve) => {
+			deps.chatLog.addSystem("Allow local shell commands for this session?");
+			deps.chatLog.addSystem("This runs commands on YOUR machine (not the gateway) and may delete files or reveal secrets.");
+			deps.chatLog.addSystem("Select Yes/No (arrows + Enter), Esc to cancel.");
+			const selector = createSelector([{
+				value: "no",
+				label: "No"
+			}, {
+				value: "yes",
+				label: "Yes"
+			}], 2);
+			selector.onSelect = (item) => {
+				deps.closeOverlay();
+				if (item.value === "yes") {
+					localExecAllowed = true;
+					deps.chatLog.addSystem("local shell: enabled for this session");
+					resolve(true);
+				} else {
+					deps.chatLog.addSystem("local shell: not enabled");
+					resolve(false);
+				}
+				deps.tui.requestRender();
+			};
+			selector.onCancel = () => {
+				deps.closeOverlay();
+				deps.chatLog.addSystem("local shell: cancelled");
+				deps.tui.requestRender();
+				resolve(false);
+			};
+			deps.openOverlay(selector);
+			deps.tui.requestRender();
+		});
+	};
+	const runLocalShellLine = async (line) => {
+		const cmd = line.slice(1);
+		if (cmd === "") return;
+		if (localExecAsked && !localExecAllowed) {
+			deps.chatLog.addSystem("local shell: not enabled for this session");
+			deps.tui.requestRender();
+			return;
+		}
+		if (!await ensureLocalExecAllowed()) return;
+		deps.chatLog.addSystem(`[local] $ ${cmd}`);
+		deps.tui.requestRender();
+		const appendWithCap = (text, chunk) => {
+			const combined = text + chunk;
+			return combined.length > maxChars ? combined.slice(-maxChars) : combined;
+		};
+		await new Promise((resolve) => {
+			const child = spawnCommand(cmd, {
+				shell: true,
+				cwd: getCwd(),
+				env: {
+					...env,
+					GENESIS_SHELL: "tui-local"
+				}
+			});
+			let stdout = "";
+			let stderr = "";
+			child.stdout.on("data", (buf) => {
+				stdout = appendWithCap(stdout, buf.toString("utf8"));
+			});
+			child.stderr.on("data", (buf) => {
+				stderr = appendWithCap(stderr, buf.toString("utf8"));
+			});
+			child.on("close", (code, signal) => {
+				const combined = (stdout + (stderr ? (stdout ? "\n" : "") + stderr : "")).slice(0, maxChars).trimEnd();
+				if (combined) for (const line of combined.split("\n")) deps.chatLog.addSystem(`[local] ${line}`);
+				deps.chatLog.addSystem(`[local] exit ${code ?? "?"}${signal ? ` (signal ${signal})` : ""}`);
+				deps.tui.requestRender();
+				resolve();
+			});
+			child.on("error", (err) => {
+				deps.chatLog.addSystem(`[local] error: ${String(err)}`);
+				deps.tui.requestRender();
+				resolve();
+			});
+		});
+	};
+	return { runLocalShellLine };
+}
+//#endregion
+//#region src/tui/tui-overlays.ts
+function createOverlayHandlers(host, fallbackFocus) {
+	const openOverlay = (component) => {
+		host.showOverlay(component);
+	};
+	const closeOverlay = () => {
+		if (host.hasOverlay()) {
+			host.hideOverlay();
+			return;
+		}
+		host.setFocus(fallbackFocus);
+	};
+	return {
+		openOverlay,
+		closeOverlay
+	};
+}
+//#endregion
+//#region src/tui/tui-session-actions.ts
+function createSessionActions(context) {
+	const { client, chatLog, btw, tui, opts, state, agentNames, initialSessionInput, initialSessionAgentId, resolveSessionKey, updateHeader, updateFooter, updateAutocompleteProvider, setActivityStatus, clearLocalRunIds } = context;
+	let refreshSessionInfoPromise = Promise.resolve();
+	let lastSessionDefaults = null;
+	const applyAgentsResult = (result) => {
+		state.agentDefaultId = normalizeAgentId(result.defaultId);
+		state.sessionMainKey = normalizeMainKey(result.mainKey);
+		state.sessionScope = result.scope ?? state.sessionScope;
+		state.agents = result.agents.map((agent) => ({
+			id: normalizeAgentId(agent.id),
+			name: normalizeOptionalString(agent.name)
+		}));
+		agentNames.clear();
+		for (const agent of state.agents) if (agent.name) agentNames.set(agent.id, agent.name);
+		if (!state.initialSessionApplied) {
+			if (initialSessionAgentId) {
+				if (state.agents.some((agent) => agent.id === initialSessionAgentId)) state.currentAgentId = initialSessionAgentId;
+			} else if (!state.agents.some((agent) => agent.id === state.currentAgentId)) state.currentAgentId = state.agents[0]?.id ?? normalizeAgentId(result.defaultId ?? state.currentAgentId);
+			const nextSessionKey = resolveSessionKey(initialSessionInput);
+			if (nextSessionKey !== state.currentSessionKey) state.currentSessionKey = nextSessionKey;
+			state.initialSessionApplied = true;
+		} else if (!state.agents.some((agent) => agent.id === state.currentAgentId)) state.currentAgentId = state.agents[0]?.id ?? normalizeAgentId(result.defaultId ?? state.currentAgentId);
+		updateHeader();
+		updateFooter();
+	};
+	const refreshAgents = async () => {
+		try {
+			applyAgentsResult(await client.listAgents());
+		} catch (err) {
+			chatLog.addSystem(`agents list failed: ${String(err)}`);
+		}
+	};
+	const updateAgentFromSessionKey = (key) => {
+		const parsed = parseAgentSessionKey(key);
+		if (!parsed) return;
+		const next = normalizeAgentId(parsed.agentId);
+		if (next !== state.currentAgentId) state.currentAgentId = next;
+	};
+	const resolveModelSelection = (entry) => {
+		return resolveSessionInfoModelSelection({
+			currentProvider: state.sessionInfo.modelProvider,
+			currentModel: state.sessionInfo.model,
+			defaultProvider: lastSessionDefaults?.modelProvider,
+			defaultModel: lastSessionDefaults?.model,
+			entryProvider: entry?.modelProvider,
+			entryModel: entry?.model,
+			overrideProvider: entry?.providerOverride,
+			overrideModel: entry?.modelOverride
+		});
+	};
+	const applySessionInfo = (params) => {
+		const entry = params.entry ?? void 0;
+		const defaults = params.defaults ?? lastSessionDefaults ?? void 0;
+		const previousDefaults = lastSessionDefaults;
+		const defaultsChanged = params.defaults ? previousDefaults?.model !== params.defaults.model || previousDefaults?.modelProvider !== params.defaults.modelProvider || previousDefaults?.contextTokens !== params.defaults.contextTokens : false;
+		if (params.defaults) lastSessionDefaults = params.defaults;
+		const entryUpdatedAt = entry?.updatedAt ?? null;
+		const currentUpdatedAt = state.sessionInfo.updatedAt ?? null;
+		if (!params.force && entryUpdatedAt !== null && currentUpdatedAt !== null && entryUpdatedAt < currentUpdatedAt && !defaultsChanged) return;
+		const next = { ...state.sessionInfo };
+		if (entry?.thinkingLevel !== void 0) next.thinkingLevel = entry.thinkingLevel;
+		if (entry?.fastMode !== void 0) next.fastMode = entry.fastMode;
+		if (entry?.verboseLevel !== void 0) next.verboseLevel = entry.verboseLevel;
+		if (entry?.traceLevel !== void 0) next.traceLevel = entry.traceLevel;
+		if (entry?.reasoningLevel !== void 0) next.reasoningLevel = entry.reasoningLevel;
+		if (entry?.responseUsage !== void 0) next.responseUsage = entry.responseUsage;
+		if (entry?.inputTokens !== void 0) next.inputTokens = entry.inputTokens;
+		if (entry?.outputTokens !== void 0) next.outputTokens = entry.outputTokens;
+		if (entry?.totalTokens !== void 0) next.totalTokens = entry.totalTokens;
+		if (entry?.contextTokens !== void 0 || defaults?.contextTokens !== void 0) next.contextTokens = entry?.contextTokens ?? defaults?.contextTokens ?? state.sessionInfo.contextTokens;
+		if (entry?.displayName !== void 0) next.displayName = entry.displayName;
+		if (entry?.updatedAt !== void 0) next.updatedAt = entry.updatedAt;
+		const selection = resolveModelSelection(entry);
+		if (selection.modelProvider !== void 0) next.modelProvider = selection.modelProvider;
+		if (selection.model !== void 0) next.model = selection.model;
+		state.sessionInfo = next;
+		updateAutocompleteProvider();
+		updateFooter();
+		tui.requestRender();
+	};
+	const runRefreshSessionInfo = async () => {
+		try {
+			const resolveListAgentId = () => {
+				if (state.currentSessionKey === "global" || state.currentSessionKey === "unknown") return;
+				const parsed = parseAgentSessionKey(state.currentSessionKey);
+				return parsed?.agentId ? normalizeAgentId(parsed.agentId) : state.currentAgentId;
+			};
+			const listAgentId = resolveListAgentId();
+			const result = await client.listSessions({
+				includeGlobal: false,
+				includeUnknown: false,
+				agentId: listAgentId
+			});
+			const normalizeMatchKey = (key) => parseAgentSessionKey(key)?.rest ?? key;
+			const currentMatchKey = normalizeMatchKey(state.currentSessionKey);
+			const entry = result.sessions.find((row) => {
+				if (row.key === state.currentSessionKey) return true;
+				return normalizeMatchKey(row.key) === currentMatchKey;
+			});
+			if (entry?.key && entry.key !== state.currentSessionKey) {
+				updateAgentFromSessionKey(entry.key);
+				state.currentSessionKey = entry.key;
+				updateHeader();
+			}
+			applySessionInfo({
+				entry,
+				defaults: result.defaults
+			});
+		} catch (err) {
+			chatLog.addSystem(`sessions list failed: ${String(err)}`);
+		}
+	};
+	const refreshSessionInfo = async () => {
+		refreshSessionInfoPromise = refreshSessionInfoPromise.then(runRefreshSessionInfo, runRefreshSessionInfo);
+		await refreshSessionInfoPromise;
+	};
+	const applySessionInfoFromPatch = (result) => {
+		if (!result?.entry) return;
+		if (result.key && result.key !== state.currentSessionKey) {
+			updateAgentFromSessionKey(result.key);
+			state.currentSessionKey = result.key;
+			updateHeader();
+		}
+		const resolved = result.resolved;
+		applySessionInfo({
+			entry: resolved && (resolved.modelProvider || resolved.model) ? {
+				...result.entry,
+				modelProvider: resolved.modelProvider ?? result.entry.modelProvider,
+				model: resolved.model ?? result.entry.model
+			} : result.entry,
+			force: true
+		});
+	};
+	const loadHistory = async () => {
+		try {
+			const record = await client.loadHistory({
+				sessionKey: state.currentSessionKey,
+				limit: opts.historyLimit ?? 200
+			});
+			state.currentSessionId = typeof record.sessionId === "string" ? record.sessionId : null;
+			state.sessionInfo.thinkingLevel = record.thinkingLevel ?? state.sessionInfo.thinkingLevel;
+			state.sessionInfo.fastMode = record.fastMode ?? state.sessionInfo.fastMode;
+			state.sessionInfo.verboseLevel = record.verboseLevel ?? state.sessionInfo.verboseLevel;
+			state.sessionInfo.traceLevel = record.traceLevel ?? state.sessionInfo.traceLevel;
+			const showTools = (state.sessionInfo.verboseLevel ?? "off") !== "off";
+			chatLog.clearAll();
+			btw.clear();
+			chatLog.addSystem(`session ${state.currentSessionKey}`);
+			for (const entry of record.messages ?? []) {
+				if (!entry || typeof entry !== "object") continue;
+				const message = entry;
+				if (isCommandMessage(message)) {
+					const text = extractTextFromMessage(message);
+					if (text) chatLog.addSystem(text);
+					continue;
+				}
+				if (message.role === "user") {
+					const text = extractTextFromMessage(message);
+					if (text) chatLog.addUser(text);
+					continue;
+				}
+				if (message.role === "assistant") {
+					const text = extractTextFromMessage(message, { includeThinking: state.showThinking });
+					if (text) chatLog.finalizeAssistant(text);
+					continue;
+				}
+				if (message.role === "toolResult") {
+					if (!showTools) continue;
+					const toolCallId = asString(message.toolCallId, "");
+					const toolName = asString(message.toolName, "tool");
+					chatLog.startTool(toolCallId, toolName, {}).setResult({
+						content: Array.isArray(message.content) ? message.content : [],
+						details: typeof message.details === "object" && message.details ? message.details : void 0
+					}, { isError: Boolean(message.isError) });
+				}
+			}
+			state.historyLoaded = true;
+		} catch (err) {
+			chatLog.addSystem(`history failed: ${String(err)}`);
+		}
+		await refreshSessionInfo();
+		tui.requestRender();
+	};
+	const setSession = async (rawKey) => {
+		const nextKey = resolveSessionKey(rawKey);
+		updateAgentFromSessionKey(nextKey);
+		state.currentSessionKey = nextKey;
+		state.activeChatRunId = null;
+		setActivityStatus("idle");
+		state.currentSessionId = null;
+		state.sessionInfo.updatedAt = null;
+		state.historyLoaded = false;
+		clearLocalRunIds?.();
+		btw.clear();
+		updateHeader();
+		updateFooter();
+		await loadHistory();
+	};
+	const abortActive = async () => {
+		if (!state.activeChatRunId) {
+			chatLog.addSystem("no active run");
+			tui.requestRender();
+			return;
+		}
+		try {
+			await client.abortChat({
+				sessionKey: state.currentSessionKey,
+				runId: state.activeChatRunId
+			});
+			setActivityStatus("aborted");
+		} catch (err) {
+			chatLog.addSystem(`abort failed: ${String(err)}`);
+			setActivityStatus("abort failed");
+		}
+		tui.requestRender();
+	};
+	return {
+		applyAgentsResult,
+		refreshAgents,
+		refreshSessionInfo,
+		applySessionInfoFromPatch,
+		loadHistory,
+		setSession,
+		abortActive
+	};
+}
+//#endregion
+//#region src/tui/tui-submit.ts
+function createEditorSubmitHandler(params) {
+	return (text) => {
+		const raw = text;
+		const value = raw.trim();
+		params.editor.setText("");
+		if (!value) return;
+		if (raw.startsWith("!") && raw !== "!") {
+			params.editor.addToHistory(raw);
+			params.handleBangLine(raw);
+			return;
+		}
+		params.editor.addToHistory(value);
+		if (value.startsWith("/")) {
+			params.handleCommand(value);
+			return;
+		}
+		params.sendMessage(value);
+	};
+}
+function shouldEnableWindowsGitBashPasteFallback(params) {
+	const platform = params?.platform ?? process.platform;
+	const env = params?.env ?? process.env;
+	const termProgram = normalizeLowercaseStringOrEmpty(env.TERM_PROGRAM);
+	if (platform === "darwin") {
+		if (termProgram.includes("iterm") || termProgram.includes("apple_terminal")) return true;
+		return false;
+	}
+	if (platform !== "win32") return false;
+	const msystem = (env.MSYSTEM ?? "").toUpperCase();
+	const shell = env.SHELL ?? "";
+	if (msystem.startsWith("MINGW") || msystem.startsWith("MSYS")) return true;
+	if (normalizeLowercaseStringOrEmpty(shell).includes("bash")) return true;
+	return termProgram.includes("mintty");
+}
+function createSubmitBurstCoalescer(params) {
+	const windowMs = Math.max(1, params.burstWindowMs ?? 50);
+	const now = params.now ?? (() => Date.now());
+	const setTimer = params.setTimer ?? setTimeout;
+	const clearTimer = params.clearTimer ?? clearTimeout;
+	let pending = null;
+	let pendingAt = 0;
+	let flushTimer = null;
+	const clearFlushTimer = () => {
+		if (!flushTimer) return;
+		clearTimer(flushTimer);
+		flushTimer = null;
+	};
+	const flushPending = () => {
+		if (pending === null) return;
+		const value = pending;
+		pending = null;
+		pendingAt = 0;
+		clearFlushTimer();
+		params.submit(value);
+	};
+	const scheduleFlush = () => {
+		clearFlushTimer();
+		flushTimer = setTimer(() => {
+			flushPending();
+		}, windowMs);
+	};
+	return (value) => {
+		if (!params.enabled) {
+			params.submit(value);
+			return;
+		}
+		if (value.includes("\n")) {
+			flushPending();
+			params.submit(value);
+			return;
+		}
+		const ts = now();
+		if (pending === null) {
+			pending = value;
+			pendingAt = ts;
+			scheduleFlush();
+			return;
+		}
+		if (ts - pendingAt <= windowMs) {
+			pending = `${pending}\n${value}`;
+			pendingAt = ts;
+			scheduleFlush();
+			return;
+		}
+		flushPending();
+		pending = value;
+		pendingAt = ts;
+		scheduleFlush();
+	};
+}
+//#endregion
+//#region src/tui/tui-waiting.ts
+const defaultWaitingPhrases = [
+	"flibbertigibbeting",
+	"kerfuffling",
+	"dillydallying",
+	"twiddling thumbs",
+	"noodling",
+	"bamboozling",
+	"moseying",
+	"hobnobbing",
+	"pondering",
+	"conjuring"
+];
+function pickWaitingPhrase(tick, phrases = defaultWaitingPhrases) {
+	return phrases[Math.floor(tick / 10) % phrases.length] ?? phrases[0] ?? "waiting";
+}
+function shimmerText(theme, text, tick) {
+	const width = 6;
+	const hi = (ch) => theme.bold(theme.accentSoft(ch));
+	const pos = tick % (text.length + width);
+	const start = Math.max(0, pos - width);
+	const end = Math.min(text.length - 1, pos);
+	let out = "";
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		out += i >= start && i <= end ? hi(ch) : theme.dim(ch);
+	}
+	return out;
+}
+function buildWaitingStatusMessage(params) {
+	const phrase = pickWaitingPhrase(params.tick, params.phrases);
+	return `${shimmerText(params.theme, `${phrase}…`, params.tick)} • ${params.elapsed} | ${params.connectionStatus}`;
+}
+//#endregion
+//#region src/tui/tui.ts
+const GENESIS_CLI_WRAPPER_PATH = fileURLToPath(new URL("../../genesis.mjs", import.meta.url));
+const GENESIS_RUN_NODE_SCRIPT_PATH = fileURLToPath(new URL("../../scripts/run-node.mjs", import.meta.url));
+const GENESIS_DIST_ENTRY_JS_PATH = fileURLToPath(new URL("../../dist/entry.js", import.meta.url));
+const GENESIS_DIST_ENTRY_MJS_PATH = fileURLToPath(new URL("../../dist/entry.mjs", import.meta.url));
+const OPENAI_CODEX_PROVIDER = "openai-codex";
+/** Resolve the absolute path to the `codex` CLI binary, or `null` if not installed. */
+function resolveCodexCliBin() {
+	try {
+		return execFileSync(process.platform === "win32" ? "where" : "which", ["codex"], { encoding: "utf8" }).trim().split(/\r?\n/)[0] || null;
+	} catch {
+		return null;
+	}
+}
+function resolveLocalAuthCliInvocation(params) {
+	const hasDistEntry = params?.hasDistEntry ?? (existsSync(GENESIS_DIST_ENTRY_JS_PATH) || existsSync(GENESIS_DIST_ENTRY_MJS_PATH));
+	const hasRunNodeScript = params?.hasRunNodeScript ?? existsSync(GENESIS_RUN_NODE_SCRIPT_PATH);
+	const command = params?.execPath ?? process.execPath;
+	const wrapperPath = params?.wrapperPath ?? GENESIS_CLI_WRAPPER_PATH;
+	const runNodePath = params?.runNodePath ?? GENESIS_RUN_NODE_SCRIPT_PATH;
+	return hasDistEntry || !hasRunNodeScript ? {
+		command,
+		args: [
+			wrapperPath,
+			"models",
+			"auth",
+			"login"
+		]
+	} : {
+		command,
+		args: [
+			runNodePath,
+			"models",
+			"auth",
+			"login"
+		]
+	};
+}
+function resolveLocalAuthSpawnOptions(params) {
+	return (params.platform ?? process.platform) === "win32" && /\.(cmd|bat)$/iu.test(params.command.trim()) ? { shell: true } : {};
+}
+function resolveLocalAuthSpawnCwd(params) {
+	const defaultCwd = params.defaultCwd ?? process.cwd();
+	const entryArg = params.args[0]?.trim();
+	if (!entryArg) return defaultCwd;
+	const entryBase = path.basename(entryArg).toLowerCase();
+	if (entryBase === "genesis.mjs") return path.dirname(entryArg);
+	if (entryBase === "run-node.mjs") return path.dirname(path.dirname(entryArg));
+	return defaultCwd;
+}
+function resolveTuiSessionKey(params) {
+	const trimmed = (params.raw ?? "").trim();
+	if (!trimmed) {
+		if (params.sessionScope === "global") return "global";
+		return buildAgentMainSessionKey({
+			agentId: params.currentAgentId,
+			mainKey: params.sessionMainKey
+		});
+	}
+	if (trimmed === "global" || trimmed === "unknown") return trimmed;
+	if (trimmed.startsWith("agent:")) return normalizeLowercaseStringOrEmpty(trimmed);
+	return `agent:${params.currentAgentId}:${normalizeLowercaseStringOrEmpty(trimmed)}`;
+}
+function resolveInitialTuiAgentId(params) {
+	const parsed = parseAgentSessionKey((params.initialSessionInput ?? "").trim());
+	if (parsed?.agentId) return normalizeAgentId(parsed.agentId);
+	const inferredFromWorkspace = resolveAgentIdByWorkspacePath(params.cfg, params.cwd ?? process.cwd());
+	if (inferredFromWorkspace) return inferredFromWorkspace;
+	return normalizeAgentId(params.fallbackAgentId);
+}
+function resolveGatewayDisconnectState(reason) {
+	const reasonLabel = reason?.trim() ? reason.trim() : "closed";
+	if (/pairing required/i.test(reasonLabel)) return {
+		connectionStatus: `gateway disconnected: ${reasonLabel}`,
+		activityStatus: "pairing required: run genesis devices list",
+		pairingHint: "Pairing required. Run `genesis devices list`, approve your request ID, then reconnect."
+	};
+	return {
+		connectionStatus: `gateway disconnected: ${reasonLabel}`,
+		activityStatus: "idle"
+	};
+}
+function createBackspaceDeduper(params) {
+	const dedupeWindowMs = Math.max(0, Math.floor(params?.dedupeWindowMs ?? 8));
+	const now = params?.now ?? (() => Date.now());
+	let lastBackspaceAt = -1;
+	return (data) => {
+		if (!matchesKey(data, Key.backspace)) return data;
+		const ts = now();
+		if (lastBackspaceAt >= 0 && ts - lastBackspaceAt <= dedupeWindowMs) return "";
+		lastBackspaceAt = ts;
+		return data;
+	};
+}
+function isIgnorableTuiStopError(error) {
+	if (!error || typeof error !== "object") return false;
+	const err = error;
+	const code = typeof err.code === "string" ? err.code : "";
+	const syscall = typeof err.syscall === "string" ? err.syscall : "";
+	const message = typeof err.message === "string" ? err.message : "";
+	if (code === "EBADF" && syscall === "setRawMode") return true;
+	return /setRawMode/i.test(message) && /EBADF/i.test(message);
+}
+function stopTuiSafely(stop) {
+	try {
+		stop();
+	} catch (error) {
+		if (!isIgnorableTuiStopError(error)) throw error;
+	}
+}
+async function drainAndStopTuiSafely(tui) {
+	if (typeof tui.terminal?.drainInput === "function") try {
+		await tui.terminal.drainInput();
+	} catch {}
+	stopTuiSafely(() => tui.stop());
+}
+function resolveCtrlCAction(params) {
+	const exitWindowMs = Math.max(1, Math.floor(params.exitWindowMs ?? 1e3));
+	if (params.hasInput) return {
+		action: "clear",
+		nextLastCtrlCAt: params.now
+	};
+	if (params.now - params.lastCtrlCAt <= exitWindowMs) return {
+		action: "exit",
+		nextLastCtrlCAt: params.lastCtrlCAt
+	};
+	return {
+		action: "warn",
+		nextLastCtrlCAt: params.now
+	};
+}
+async function runTui(opts) {
+	const isLocalMode = opts.local === true;
+	const config = loadConfig();
+	const initialSessionInput = (opts.session ?? "").trim();
+	let sessionScope = config.session?.scope ?? "per-sender";
+	let sessionMainKey = normalizeMainKey(config.session?.mainKey);
+	let agentDefaultId = resolveDefaultAgentId(config);
+	let currentAgentId = resolveInitialTuiAgentId({
+		cfg: config,
+		fallbackAgentId: agentDefaultId,
+		initialSessionInput,
+		cwd: process.cwd()
+	});
+	let agents = [];
+	const agentNames = /* @__PURE__ */ new Map();
+	let currentSessionKey = "";
+	let initialSessionApplied = false;
+	let currentSessionId = null;
+	let activeChatRunId = null;
+	let pendingOptimisticUserMessage = false;
+	let historyLoaded = false;
+	let isConnected = false;
+	let wasDisconnected = false;
+	let toolsExpanded = false;
+	let showThinking = false;
+	let pairingHintShown = false;
+	const localRunIds = /* @__PURE__ */ new Set();
+	const localBtwRunIds = /* @__PURE__ */ new Set();
+	const deliverDefault = opts.deliver ?? false;
+	const autoMessage = opts.message?.trim();
+	let autoMessageSent = false;
+	let sessionInfo = {};
+	let lastCtrlCAt = 0;
+	let exitRequested = false;
+	let activityStatus = "idle";
+	let connectionStatus = isLocalMode ? "starting local runtime" : "connecting";
+	let statusTimeout = null;
+	let statusTimer = null;
+	let statusStartedAt = null;
+	let lastActivityStatus = activityStatus;
+	const state = {
+		get agentDefaultId() {
+			return agentDefaultId;
+		},
+		set agentDefaultId(value) {
+			agentDefaultId = value;
+		},
+		get sessionMainKey() {
+			return sessionMainKey;
+		},
+		set sessionMainKey(value) {
+			sessionMainKey = value;
+		},
+		get sessionScope() {
+			return sessionScope;
+		},
+		set sessionScope(value) {
+			sessionScope = value;
+		},
+		get agents() {
+			return agents;
+		},
+		set agents(value) {
+			agents = value;
+		},
+		get currentAgentId() {
+			return currentAgentId;
+		},
+		set currentAgentId(value) {
+			currentAgentId = value;
+		},
+		get currentSessionKey() {
+			return currentSessionKey;
+		},
+		set currentSessionKey(value) {
+			currentSessionKey = value;
+		},
+		get currentSessionId() {
+			return currentSessionId;
+		},
+		set currentSessionId(value) {
+			currentSessionId = value;
+		},
+		get activeChatRunId() {
+			return activeChatRunId;
+		},
+		set activeChatRunId(value) {
+			activeChatRunId = value;
+		},
+		get pendingOptimisticUserMessage() {
+			return pendingOptimisticUserMessage;
+		},
+		set pendingOptimisticUserMessage(value) {
+			pendingOptimisticUserMessage = value;
+		},
+		get historyLoaded() {
+			return historyLoaded;
+		},
+		set historyLoaded(value) {
+			historyLoaded = value;
+		},
+		get sessionInfo() {
+			return sessionInfo;
+		},
+		set sessionInfo(value) {
+			sessionInfo = value;
+		},
+		get initialSessionApplied() {
+			return initialSessionApplied;
+		},
+		set initialSessionApplied(value) {
+			initialSessionApplied = value;
+		},
+		get isConnected() {
+			return isConnected;
+		},
+		set isConnected(value) {
+			isConnected = value;
+		},
+		get autoMessageSent() {
+			return autoMessageSent;
+		},
+		set autoMessageSent(value) {
+			autoMessageSent = value;
+		},
+		get toolsExpanded() {
+			return toolsExpanded;
+		},
+		set toolsExpanded(value) {
+			toolsExpanded = value;
+		},
+		get showThinking() {
+			return showThinking;
+		},
+		set showThinking(value) {
+			showThinking = value;
+		},
+		get connectionStatus() {
+			return connectionStatus;
+		},
+		set connectionStatus(value) {
+			connectionStatus = value;
+		},
+		get activityStatus() {
+			return activityStatus;
+		},
+		set activityStatus(value) {
+			activityStatus = value;
+		},
+		get statusTimeout() {
+			return statusTimeout;
+		},
+		set statusTimeout(value) {
+			statusTimeout = value;
+		},
+		get lastCtrlCAt() {
+			return lastCtrlCAt;
+		},
+		set lastCtrlCAt(value) {
+			lastCtrlCAt = value;
+		}
+	};
+	const noteLocalRunId = (runId) => {
+		if (!runId) return;
+		localRunIds.add(runId);
+		if (localRunIds.size > 200) {
+			const [first] = localRunIds;
+			if (first) localRunIds.delete(first);
+		}
+	};
+	const forgetLocalRunId = (runId) => {
+		localRunIds.delete(runId);
+	};
+	const isLocalRunId = (runId) => localRunIds.has(runId);
+	const clearLocalRunIds = () => {
+		localRunIds.clear();
+	};
+	const noteLocalBtwRunId = (runId) => {
+		if (!runId) return;
+		localBtwRunIds.add(runId);
+		if (localBtwRunIds.size > 200) {
+			const [first] = localBtwRunIds;
+			if (first) localBtwRunIds.delete(first);
+		}
+	};
+	const forgetLocalBtwRunId = (runId) => {
+		localBtwRunIds.delete(runId);
+	};
+	const isLocalBtwRunId = (runId) => localBtwRunIds.has(runId);
+	const clearLocalBtwRunIds = () => {
+		localBtwRunIds.clear();
+	};
+	const client = opts.local ? new EmbeddedTuiBackend() : await GatewayChatClient.connect({
+		url: opts.url,
+		token: opts.token,
+		password: opts.password
+	});
+	const previousConsoleSubsystemFilter = isLocalMode ? loggingState.consoleSubsystemFilter ? [...loggingState.consoleSubsystemFilter] : null : null;
+	if (isLocalMode) setConsoleSubsystemFilter(["__genesis_tui_quiet__"]);
+	const tui = new TUI(new ProcessTerminal());
+	const dedupeBackspace = createBackspaceDeduper();
+	tui.addInputListener((data) => {
+		const next = dedupeBackspace(data);
+		if (next.length === 0) return { consume: true };
+		return { data: next };
+	});
+	const header = new Text("", 1, 0);
+	const statusContainer = new Container();
+	const footer = new Text("", 1, 0);
+	const chatLog = new ChatLog();
+	const editor = new CustomEditor(tui, editorTheme);
+	const root = new Container();
+	root.addChild(header);
+	root.addChild(chatLog);
+	root.addChild(statusContainer);
+	root.addChild(footer);
+	root.addChild(editor);
+	const updateAutocompleteProvider = () => {
+		editor.setAutocompleteProvider(new CombinedAutocompleteProvider(getSlashCommands({
+			cfg: config,
+			local: isLocalMode,
+			provider: sessionInfo.modelProvider,
+			model: sessionInfo.model
+		}), process.cwd()));
+	};
+	tui.addChild(root);
+	tui.setFocus(editor);
+	const formatSessionKey = (key) => {
+		if (key === "global" || key === "unknown") return key;
+		return parseAgentSessionKey(key)?.rest ?? key;
+	};
+	const formatAgentLabel = (id) => {
+		const name = agentNames.get(id);
+		return name ? `${id} (${name})` : id;
+	};
+	const resolveSessionKey = (raw) => {
+		return resolveTuiSessionKey({
+			raw,
+			sessionScope,
+			currentAgentId,
+			sessionMainKey
+		});
+	};
+	currentSessionKey = resolveSessionKey(initialSessionInput);
+	const updateHeader = () => {
+		const sessionLabel = formatSessionKey(currentSessionKey);
+		const agentLabel = formatAgentLabel(currentAgentId);
+		header.setText(theme.header(`genesis tui - ${client.connection.url} - agent ${agentLabel} - session ${sessionLabel}`));
+	};
+	const busyStates = new Set([
+		"sending",
+		"waiting",
+		"streaming",
+		"running"
+	]);
+	let statusText = null;
+	let statusLoader = null;
+	const formatElapsed = (startMs) => {
+		const totalSeconds = Math.max(0, Math.floor((Date.now() - startMs) / 1e3));
+		if (totalSeconds < 60) return `${totalSeconds}s`;
+		return `${Math.floor(totalSeconds / 60)}m ${totalSeconds % 60}s`;
+	};
+	const ensureStatusText = () => {
+		if (statusText) return;
+		statusContainer.clear();
+		statusLoader?.stop();
+		statusLoader = null;
+		statusText = new Text("", 1, 0);
+		statusContainer.addChild(statusText);
+	};
+	const ensureStatusLoader = () => {
+		if (statusLoader) return;
+		statusContainer.clear();
+		statusText = null;
+		statusLoader = new Loader(tui, (spinner) => theme.accent(spinner), (text) => theme.bold(theme.accentSoft(text)), "");
+		statusContainer.addChild(statusLoader);
+	};
+	let waitingTick = 0;
+	let waitingTimer = null;
+	let waitingPhrase = null;
+	const updateBusyStatusMessage = () => {
+		if (!statusLoader || !statusStartedAt) return;
+		const elapsed = formatElapsed(statusStartedAt);
+		if (activityStatus === "waiting") {
+			waitingTick++;
+			statusLoader.setMessage(buildWaitingStatusMessage({
+				theme,
+				tick: waitingTick,
+				elapsed,
+				connectionStatus,
+				phrases: waitingPhrase ? [waitingPhrase] : void 0
+			}));
+			return;
+		}
+		statusLoader.setMessage(`${activityStatus} • ${elapsed} | ${connectionStatus}`);
+	};
+	const startStatusTimer = () => {
+		if (statusTimer) return;
+		statusTimer = setInterval(() => {
+			if (!busyStates.has(activityStatus)) return;
+			updateBusyStatusMessage();
+		}, 1e3);
+	};
+	const stopStatusTimer = () => {
+		if (!statusTimer) return;
+		clearInterval(statusTimer);
+		statusTimer = null;
+	};
+	const startWaitingTimer = () => {
+		if (waitingTimer) return;
+		if (!waitingPhrase) waitingPhrase = defaultWaitingPhrases[Math.floor(Math.random() * defaultWaitingPhrases.length)] ?? defaultWaitingPhrases[0] ?? "waiting";
+		waitingTick = 0;
+		waitingTimer = setInterval(() => {
+			if (activityStatus !== "waiting") return;
+			updateBusyStatusMessage();
+		}, 120);
+	};
+	const stopWaitingTimer = () => {
+		if (!waitingTimer) return;
+		clearInterval(waitingTimer);
+		waitingTimer = null;
+		waitingPhrase = null;
+	};
+	const renderStatus = () => {
+		if (busyStates.has(activityStatus)) {
+			if (!statusStartedAt || lastActivityStatus !== activityStatus) statusStartedAt = Date.now();
+			ensureStatusLoader();
+			if (activityStatus === "waiting") {
+				stopStatusTimer();
+				startWaitingTimer();
+			} else {
+				stopWaitingTimer();
+				startStatusTimer();
+			}
+			updateBusyStatusMessage();
+		} else {
+			statusStartedAt = null;
+			stopStatusTimer();
+			stopWaitingTimer();
+			statusLoader?.stop();
+			statusLoader = null;
+			ensureStatusText();
+			const text = activityStatus ? `${connectionStatus} | ${activityStatus}` : connectionStatus;
+			statusText?.setText(theme.dim(text));
+		}
+		lastActivityStatus = activityStatus;
+	};
+	const setConnectionStatus = (text, ttlMs) => {
+		connectionStatus = text;
+		renderStatus();
+		if (statusTimeout) clearTimeout(statusTimeout);
+		if (ttlMs && ttlMs > 0) statusTimeout = setTimeout(() => {
+			connectionStatus = isConnected ? isLocalMode ? "local ready" : "connected" : isLocalMode ? "local stopped" : "disconnected";
+			renderStatus();
+		}, ttlMs);
+	};
+	const setActivityStatus = (text) => {
+		activityStatus = text;
+		renderStatus();
+	};
+	const withTuiSuspended = async (work) => {
+		await drainAndStopTuiSafely(tui);
+		if (isLocalMode) setConsoleSubsystemFilter(previousConsoleSubsystemFilter);
+		try {
+			return await work();
+		} finally {
+			if (isLocalMode) setConsoleSubsystemFilter(["__genesis_tui_quiet__"]);
+			tui.start();
+			tui.setFocus(editor);
+			updateHeader();
+			updateFooter();
+			tui.requestRender(true);
+		}
+	};
+	const runAuthFlow = isLocalMode ? async (params) => await withTuiSuspended(async () => await new Promise((resolve, reject) => {
+		const provider = params.provider?.trim() || void 0;
+		const codexBin = provider === OPENAI_CODEX_PROVIDER || !provider && sessionInfo.modelProvider === OPENAI_CODEX_PROVIDER ? resolveCodexCliBin() : null;
+		let command;
+		let args;
+		if (codexBin) {
+			command = codexBin;
+			args = ["login"];
+		} else {
+			({command, args} = resolveLocalAuthCliInvocation());
+			if (provider) args.push("--provider", provider);
+		}
+		const child = spawn(command, args, {
+			cwd: resolveLocalAuthSpawnCwd({
+				args,
+				defaultCwd: process.cwd()
+			}),
+			env: process.env,
+			stdio: "inherit",
+			...resolveLocalAuthSpawnOptions({ command })
+		});
+		child.once("error", reject);
+		child.once("exit", (exitCode, signal) => {
+			resolve({
+				exitCode,
+				signal
+			});
+		});
+	})) : void 0;
+	const updateFooter = () => {
+		const sessionKeyLabel = formatSessionKey(currentSessionKey);
+		const sessionLabel = sessionInfo.displayName ? `${sessionKeyLabel} (${sessionInfo.displayName})` : sessionKeyLabel;
+		const agentLabel = formatAgentLabel(currentAgentId);
+		const modelLabel = sessionInfo.model ? sessionInfo.modelProvider ? `${sessionInfo.modelProvider}/${sessionInfo.model}` : sessionInfo.model : "unknown";
+		const tokens = formatTokens(sessionInfo.totalTokens ?? null, sessionInfo.contextTokens ?? null);
+		const think = sessionInfo.thinkingLevel ?? "off";
+		const fast = sessionInfo.fastMode === true;
+		const verbose = sessionInfo.verboseLevel ?? "off";
+		const reasoning = sessionInfo.reasoningLevel ?? "off";
+		const reasoningLabel = reasoning === "on" ? "reasoning" : reasoning === "stream" ? "reasoning:stream" : null;
+		const footerParts = [
+			`agent ${agentLabel}`,
+			`session ${sessionLabel}`,
+			modelLabel,
+			think !== "off" ? `think ${think}` : null,
+			fast ? "fast" : null,
+			verbose !== "off" ? `verbose ${verbose}` : null,
+			reasoningLabel,
+			tokens
+		].filter(Boolean);
+		footer.setText(theme.dim(footerParts.join(" | ")));
+	};
+	const { openOverlay, closeOverlay } = createOverlayHandlers(tui, editor);
+	const btw = {
+		showResult: (params) => {
+			chatLog.showBtw(params);
+		},
+		clear: () => {
+			chatLog.dismissBtw();
+		}
+	};
+	const { refreshAgents, refreshSessionInfo, applySessionInfoFromPatch, loadHistory, setSession, abortActive } = createSessionActions({
+		client,
+		chatLog,
+		btw,
+		tui,
+		opts,
+		state,
+		agentNames,
+		initialSessionInput,
+		initialSessionAgentId: (() => {
+			if (!initialSessionInput) return null;
+			const parsed = parseAgentSessionKey(initialSessionInput);
+			return parsed ? normalizeAgentId(parsed.agentId) : null;
+		})(),
+		resolveSessionKey,
+		updateHeader,
+		updateFooter,
+		updateAutocompleteProvider,
+		setActivityStatus,
+		clearLocalRunIds
+	});
+	const { handleChatEvent, handleAgentEvent, handleBtwEvent } = createEventHandlers({
+		chatLog,
+		btw,
+		tui,
+		state,
+		localMode: isLocalMode,
+		setActivityStatus,
+		refreshSessionInfo,
+		loadHistory,
+		noteLocalRunId,
+		isLocalRunId,
+		forgetLocalRunId,
+		clearLocalRunIds,
+		isLocalBtwRunId,
+		forgetLocalBtwRunId,
+		clearLocalBtwRunIds
+	});
+	const requestExit = () => {
+		if (exitRequested) return;
+		exitRequested = true;
+		client.stop();
+		drainAndStopTuiSafely(tui).then(() => {
+			process.exit(0);
+		});
+	};
+	const { handleCommand, sendMessage, openModelSelector, openAgentSelector, openSessionSelector } = createCommandHandlers({
+		client,
+		chatLog,
+		tui,
+		opts,
+		state,
+		deliverDefault,
+		openOverlay,
+		closeOverlay,
+		refreshSessionInfo,
+		applySessionInfoFromPatch,
+		loadHistory,
+		setSession,
+		refreshAgents,
+		abortActive,
+		setActivityStatus,
+		formatSessionKey,
+		noteLocalRunId,
+		noteLocalBtwRunId,
+		forgetLocalRunId,
+		forgetLocalBtwRunId,
+		runAuthFlow,
+		requestExit
+	});
+	const { runLocalShellLine } = createLocalShellRunner({
+		chatLog,
+		tui,
+		openOverlay,
+		closeOverlay
+	});
+	updateAutocompleteProvider();
+	editor.onSubmit = createSubmitBurstCoalescer({
+		submit: createEditorSubmitHandler({
+			editor,
+			handleCommand,
+			sendMessage,
+			handleBangLine: runLocalShellLine
+		}),
+		enabled: shouldEnableWindowsGitBashPasteFallback()
+	});
+	editor.onEscape = () => {
+		if (chatLog.hasVisibleBtw()) {
+			chatLog.dismissBtw();
+			tui.requestRender();
+			return;
+		}
+		abortActive();
+	};
+	const handleCtrlC = () => {
+		const now = Date.now();
+		const decision = resolveCtrlCAction({
+			hasInput: editor.getText().trim().length > 0,
+			now,
+			lastCtrlCAt
+		});
+		lastCtrlCAt = decision.nextLastCtrlCAt;
+		if (decision.action === "clear") {
+			editor.setText("");
+			setActivityStatus("cleared input; press ctrl+c again to exit");
+			tui.requestRender();
+			return;
+		}
+		if (decision.action === "exit") {
+			requestExit();
+			return;
+		}
+		setActivityStatus("press ctrl+c again to exit");
+		tui.requestRender();
+	};
+	editor.onCtrlC = () => {
+		handleCtrlC();
+	};
+	editor.onCtrlD = () => {
+		requestExit();
+	};
+	editor.onCtrlO = () => {
+		toolsExpanded = !toolsExpanded;
+		chatLog.setToolsExpanded(toolsExpanded);
+		setActivityStatus(toolsExpanded ? "tools expanded" : "tools collapsed");
+		tui.requestRender();
+	};
+	editor.onCtrlL = () => {
+		openModelSelector();
+	};
+	editor.onCtrlG = () => {
+		openAgentSelector();
+	};
+	editor.onCtrlP = () => {
+		openSessionSelector();
+	};
+	editor.onCtrlT = () => {
+		showThinking = !showThinking;
+		loadHistory();
+	};
+	tui.addInputListener((data) => {
+		if (!chatLog.hasVisibleBtw()) return;
+		if (editor.getText().length > 0) return;
+		if (matchesKey(data, "enter")) {
+			chatLog.dismissBtw();
+			tui.requestRender();
+			return { consume: true };
+		}
+	});
+	client.onEvent = (evt) => {
+		if (evt.event === "chat") handleChatEvent(evt.payload);
+		if (evt.event === "chat.side_result") handleBtwEvent(evt.payload);
+		if (evt.event === "agent") handleAgentEvent(evt.payload);
+	};
+	client.onConnected = () => {
+		isConnected = true;
+		pairingHintShown = false;
+		const reconnected = wasDisconnected;
+		wasDisconnected = false;
+		setConnectionStatus(isLocalMode ? "local ready" : "connected");
+		(async () => {
+			await refreshAgents();
+			updateHeader();
+			await loadHistory();
+			setConnectionStatus(isLocalMode ? "local ready" : reconnected ? "gateway reconnected" : "gateway connected", 4e3);
+			tui.requestRender();
+			if (!autoMessageSent && autoMessage) {
+				autoMessageSent = true;
+				await sendMessage(autoMessage);
+			}
+			updateFooter();
+			tui.requestRender();
+		})();
+	};
+	client.onDisconnected = (reason) => {
+		isConnected = false;
+		wasDisconnected = true;
+		historyLoaded = false;
+		const disconnectState = isLocalMode ? {
+			connectionStatus: `local runtime stopped${reason ? `: ${reason}` : ""}`,
+			activityStatus: "idle",
+			pairingHint: void 0
+		} : resolveGatewayDisconnectState(reason);
+		setConnectionStatus(disconnectState.connectionStatus, 5e3);
+		setActivityStatus(disconnectState.activityStatus);
+		if (disconnectState.pairingHint && !pairingHintShown) {
+			pairingHintShown = true;
+			chatLog.addSystem(disconnectState.pairingHint);
+		}
+		updateFooter();
+		tui.requestRender();
+	};
+	client.onGap = (info) => {
+		setConnectionStatus(`event gap: expected ${info.expected}, got ${info.received}`, 5e3);
+		tui.requestRender();
+	};
+	updateHeader();
+	setConnectionStatus(isLocalMode ? "starting local runtime" : "connecting");
+	updateFooter();
+	const sigintHandler = () => {
+		handleCtrlC();
+	};
+	const sigtermHandler = () => {
+		requestExit();
+	};
+	process.on("SIGINT", sigintHandler);
+	process.on("SIGTERM", sigtermHandler);
+	tui.start();
+	client.start();
+	await new Promise((resolve) => {
+		const finish = () => {
+			if (isLocalMode) setConsoleSubsystemFilter(previousConsoleSubsystemFilter);
+			process.removeListener("SIGINT", sigintHandler);
+			process.removeListener("SIGTERM", sigtermHandler);
+			resolve();
+		};
+		process.once("exit", finish);
+	});
+}
+//#endregion
+//#region src/cli/tui-cli.ts
+function registerTuiCli(program) {
+	program.command("tui").alias("terminal").alias("chat").description("Open a terminal UI connected to the Gateway").option("--local", "Run against the local embedded agent runtime", false).option("--url <url>", "Gateway WebSocket URL (defaults to gateway.remote.url when configured)").option("--token <token>", "Gateway token (if required)").option("--password <password>", "Gateway password (if required)").option("--session <key>", "Session key (default: \"main\", or \"global\" when scope is global)").option("--deliver", "Deliver assistant replies", false).option("--thinking <level>", "Thinking level override").option("--message <text>", "Send an initial message after connecting").option("--timeout-ms <ms>", "Agent timeout in ms (defaults to agents.defaults.timeoutSeconds)").option("--history-limit <n>", "History entries to load", "200").addHelpText("after", () => `\n${theme$1.muted("Docs:")} ${formatDocsLink("/cli/tui", "genesis.pixelzx.com/docs/cli/tui")}\n`).action(async (opts, cmd) => {
+		try {
+			const invokedSubcommand = cmd.parent?.args[0];
+			const invokedAsLocalAlias = invokedSubcommand === "terminal" || invokedSubcommand === "chat";
+			const isLocal = Boolean(opts.local) || invokedAsLocalAlias;
+			if (isLocal && (opts.url || opts.token || opts.password)) throw new Error("--local cannot be combined with --url, --token, or --password");
+			const timeoutMs = parseTimeoutMs(opts.timeoutMs);
+			if (opts.timeoutMs !== void 0 && timeoutMs === void 0) defaultRuntime.error(`warning: invalid --timeout-ms "${String(opts.timeoutMs)}"; ignoring`);
+			const historyLimit = Number.parseInt(String(opts.historyLimit ?? "200"), 10);
+			await runTui({
+				local: isLocal,
+				url: opts.url,
+				token: opts.token,
+				password: opts.password,
+				session: opts.session,
+				deliver: Boolean(opts.deliver),
+				thinking: opts.thinking,
+				message: opts.message,
+				timeoutMs,
+				historyLimit: Number.isNaN(historyLimit) ? void 0 : historyLimit
+			});
+		} catch (err) {
+			defaultRuntime.error(String(err));
+			defaultRuntime.exit(1);
+		}
+	});
+}
+//#endregion
+export { registerTuiCli };