zidane 4.0.2 → 4.1.4

package/dist/tui.js

@@ -0,0 +1,2004 @@
+import { d as createAgent } from "./tools-DpeWKzP1.js";
+import { n as toolResultToText } from "./types-Bx_F8jet.js";
+import { r as basic_default } from "./presets-Cs7_CsMk.js";
+import { i as anthropic, n as openai, r as cerebras, t as openrouter } from "./providers-CX-R-Oy-.js";
+import { n as loadSession, t as createSession } from "./session-Cn68UASv.js";
+import { createSqliteStore } from "./session/sqlite.js";
+import { dirname, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { getModel, getModels } from "@mariozechner/pi-ai";
+import { RGBA, SyntaxStyle, createCliRenderer, defaultTextareaKeyBindings } from "@opentui/core";
+import { createRoot, useKeyboard, useRenderer, useTerminalDimensions } from "@opentui/react";
+import { heal, init } from "md4x/wasm";
+import { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "@opentui/react/jsx-runtime";
+//#region src/tui/format.ts
+/** Compact token formatter — 12_415 → "12.4k", 1_234_567 → "1.23M". */
+function fmtTokens(n) {
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 2 : 1)}k`;
+	return `${(n / 1e6).toFixed(2)}M`;
+}
+/** Compact relative-time formatter — "just now / 5m / 3h / 2d". */
+function ageString(ts, now = Date.now()) {
+	const m = Math.floor((now - ts) / 6e4);
+	if (m < 1) return "just now";
+	if (m < 60) return `${m}m ago`;
+	const h = Math.floor(m / 60);
+	if (h < 24) return `${h}h ago`;
+	return `${Math.floor(h / 24)}d ago`;
+}
+/** Six-char short form of a session id for headers and lists. */
+function shortId(id) {
+	return id.replace(/-/g, "").slice(0, 6);
+}
+//#endregion
+//#region src/tui/theme.ts
+/**
+* Shared color palette. Kept as plain hex strings so it can be consumed by
+* OpenTUI props that accept `string | RGBA`. The names describe role, not
+* literal hue, so the theme can be swapped without touching call sites.
+*/
+const COLOR = {
+	brand: "#FFCC00",
+	accent: "#00FF88",
+	model: "#88CCFF",
+	warn: "#FFAA66",
+	error: "#FF6666",
+	dim: "#888888",
+	mute: "#555555",
+	border: "#333333",
+	borderActive: "#555555"
+};
+/**
+* Shared select styling — keeps the highlight bar from filling with a
+* different background than the surrounding box. The `▶` marker and the
+* brand-colored selected text carry the focus affordance.
+*/
+const SELECT_THEME = {
+	backgroundColor: "transparent",
+	focusedBackgroundColor: "transparent",
+	selectedBackgroundColor: "transparent",
+	selectedTextColor: COLOR.brand,
+	textColor: COLOR.dim,
+	descriptionColor: COLOR.mute,
+	selectedDescriptionColor: COLOR.dim
+};
+/**
+* Theme for markdown token highlighting. Token names map to Tree-sitter highlight
+* captures emitted by OpenTUI's markdown parser; the `default` entry is the
+* fallback for unstyled text.
+*/
+const MD_STYLE = SyntaxStyle.fromStyles({
+	"default": { fg: RGBA.fromHex("#E6EDF3") },
+	"markup.heading": {
+		fg: RGBA.fromHex(COLOR.brand),
+		bold: true
+	},
+	"markup.heading.1": {
+		fg: RGBA.fromHex(COLOR.brand),
+		bold: true
+	},
+	"markup.heading.2": {
+		fg: RGBA.fromHex("#FFD84D"),
+		bold: true
+	},
+	"markup.heading.3": {
+		fg: RGBA.fromHex("#FFE680"),
+		bold: true
+	},
+	"markup.bold": {
+		fg: RGBA.fromHex("#FFFFFF"),
+		bold: true
+	},
+	"markup.italic": {
+		fg: RGBA.fromHex("#E6EDF3"),
+		italic: true
+	},
+	"markup.link": {
+		fg: RGBA.fromHex(COLOR.model),
+		underline: true
+	},
+	"markup.link.url": {
+		fg: RGBA.fromHex(COLOR.model),
+		underline: true
+	},
+	"markup.list": { fg: RGBA.fromHex(COLOR.warn) },
+	"markup.raw": { fg: RGBA.fromHex("#A5D6FF") },
+	"markup.raw.block": { fg: RGBA.fromHex("#A5D6FF") },
+	"markup.quote": {
+		fg: RGBA.fromHex(COLOR.dim),
+		italic: true
+	},
+	"punctuation": { fg: RGBA.fromHex(COLOR.mute) }
+});
+//#endregion
+//#region src/tui/components.tsx
+/**
+* Memoized so a flush that mutates only the trailing event doesn't force the
+* entire transcript to re-render. Each event holds a stable reference until
+* its content changes (we only ever recreate the streaming-markdown tail).
+*
+* The outer wrapper handles top-margin per kind (and per neighbor) so spacing
+* is the single source of truth for inter-event breathing room.
+*/
+const EventLine = memo(({ event, previous }) => /* @__PURE__ */ jsx("box", {
+	style: { marginTop: marginTopFor(event, previous) },
+	children: /* @__PURE__ */ jsx(EventLineImpl, { event })
+}));
+/**
+* `@opentui/react` extends `React.JSX.IntrinsicElements`, so `onSubmit` on `<input>`
+* gets intersected with the DOM `SubmitEvent` shape and demands an unhelpful overload.
+* The OpenTUI input runtime fires `(value: string) => void`; this helper isolates
+* the cast so each call site stays readable.
+*/
+function onInputSubmit(handler) {
+	return handler;
+}
+function Footer({ hints, picked, context }) {
+	return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "row",
+			height: 1,
+			paddingLeft: 1,
+			paddingRight: 1
+		},
+		children: [
+			/* @__PURE__ */ jsx("text", {
+				fg: COLOR.dim,
+				children: hints.map((h, i) => /* @__PURE__ */ jsxs("span", { children: [
+					i > 0 && /* @__PURE__ */ jsx("span", {
+						fg: COLOR.mute,
+						children: " · "
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.warn,
+						children: h.key
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.dim,
+						children: ` ${h.label}`
+					})
+				] }, i))
+			}),
+			picked && /* @__PURE__ */ jsx(ProviderBadge, { picked }),
+			/* @__PURE__ */ jsx("box", { style: { flexGrow: 1 } }),
+			context && /* @__PURE__ */ jsx(ContextIndicator, { context })
+		]
+	});
+}
+function ProviderBadge({ picked }) {
+	const source = picked.provider.methods[0].source;
+	return /* @__PURE__ */ jsxs("text", {
+		fg: COLOR.dim,
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				fg: COLOR.mute,
+				children: " · "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: COLOR.accent,
+				children: picked.provider.label
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: COLOR.mute,
+				children: " · "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: COLOR.model,
+				children: picked.model
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: COLOR.mute,
+				children: " · "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: source === "oauth" ? COLOR.accent : COLOR.warn,
+				children: source
+			})
+		]
+	});
+}
+function ContextIndicator({ context }) {
+	const ratio = context.max > 0 ? context.used / context.max : 0;
+	const pct = Math.round(ratio * 100);
+	const color = ratio >= .85 ? COLOR.error : ratio >= .6 ? COLOR.warn : COLOR.dim;
+	return /* @__PURE__ */ jsxs("text", {
+		fg: COLOR.dim,
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				fg: COLOR.mute,
+				children: "ctx "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: color,
+				children: fmtTokens(context.used)
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: COLOR.mute,
+				children: ` / ${fmtTokens(context.max)} `
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: color,
+				children: `(${pct}%)`
+			})
+		]
+	});
+}
+const SPINNER_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+const SPINNER_INTERVAL_MS = 80;
+function Spinner({ label }) {
+	const [frame, setFrame] = useState(0);
+	useEffect(() => {
+		const id = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), SPINNER_INTERVAL_MS);
+		return () => clearInterval(id);
+	}, []);
+	return /* @__PURE__ */ jsxs("text", {
+		fg: COLOR.warn,
+		children: [SPINNER_FRAMES[frame], /* @__PURE__ */ jsx("span", {
+			fg: COLOR.dim,
+			children: ` ${label}`
+		})]
+	});
+}
+function Transcript({ events, settings }) {
+	const visible = events.filter((e) => isVisible(e, settings));
+	if (visible.length === 0) return /* @__PURE__ */ jsx(EmptyState$1, {});
+	return /* @__PURE__ */ jsx("scrollbox", {
+		focusable: false,
+		style: {
+			flexGrow: 1,
+			paddingLeft: 1,
+			paddingRight: 1
+		},
+		stickyScroll: true,
+		stickyStart: "bottom",
+		children: visible.map((evt, i) => /* @__PURE__ */ jsx(EventLine, {
+			event: evt,
+			previous: visible[i - 1]
+		}, i))
+	});
+}
+function isVisible(event, settings) {
+	switch (event.kind) {
+		case "thinking": return settings.showThinking;
+		case "tool": return settings.showToolCalls;
+		case "tool-result": return settings.showToolResults;
+		default: return true;
+	}
+}
+function EmptyState$1() {
+	return /* @__PURE__ */ jsx("box", {
+		style: {
+			flexGrow: 1,
+			alignItems: "center",
+			justifyContent: "center"
+		},
+		children: /* @__PURE__ */ jsx("text", {
+			fg: COLOR.mute,
+			children: "no messages yet — type below to start"
+		})
+	});
+}
+/** Left-pad applied per depth level (in columns). */
+const INDENT_PER_DEPTH = 2;
+function indentFor(depth) {
+	return depth && depth > 0 ? depth * INDENT_PER_DEPTH : 0;
+}
+function isChild(event) {
+	return (event.depth ?? 0) > 0;
+}
+/**
+* Default top-margin per kind. Spacing intent:
+*   - `info` / `markdown` / `tool` / `error` / `spawn-start` open a new block
+*     so they each get one row of breathing room above.
+*   - `thinking` / `tool-result` / `spawn-end` continue the previous block
+*     and stay flush.
+*
+* Context-aware overrides live in `marginTopFor` — e.g. consecutive tool
+* round-trips collapse to a tight list regardless of whether outputs are shown.
+*/
+const MARGIN_TOP = {
+	"separator": 0,
+	"info": 1,
+	"thinking": 0,
+	"tool": 1,
+	"tool-result": 0,
+	"error": 1,
+	"markdown": 1,
+	"spawn-start": 1,
+	"spawn-end": 0
+};
+const TOOL_KINDS = new Set(["tool", "tool-result"]);
+/**
+* Resolve the top margin for an event given the one rendered just before it.
+*
+* The only context-aware rule today: a tool/tool-result event that follows
+* another tool/tool-result event collapses its margin to zero, so a chain of
+* tool calls reads as a tight list — whether the user has hidden tool outputs
+* or not, and whether the agent emits back-to-back calls or call→result pairs.
+*
+* Exported so the spacing matrix can be unit-tested without rendering.
+*/
+function marginTopFor(event, previous) {
+	if (TOOL_KINDS.has(event.kind) && previous && TOOL_KINDS.has(previous.kind)) return 0;
+	return MARGIN_TOP[event.kind] ?? 0;
+}
+function EventLineImpl({ event }) {
+	const safeText = event.text === "" ? " " : event.text;
+	const paddingLeft = indentFor(event.depth);
+	const child = isChild(event);
+	switch (event.kind) {
+		case "separator": return /* @__PURE__ */ jsx("text", { children: " " });
+		case "info": return /* @__PURE__ */ jsx(UserPromptBlock, { text: safeText });
+		case "thinking": return /* @__PURE__ */ jsx("box", {
+			style: { paddingLeft },
+			children: /* @__PURE__ */ jsx("text", {
+				fg: COLOR.dim,
+				children: safeText
+			})
+		});
+		case "tool": return /* @__PURE__ */ jsx("box", {
+			style: { paddingLeft },
+			children: /* @__PURE__ */ jsxs("text", {
+				fg: child ? COLOR.dim : COLOR.model,
+				children: [/* @__PURE__ */ jsx("span", {
+					fg: COLOR.mute,
+					children: "↳ "
+				}), safeText]
+			})
+		});
+		case "tool-result": return /* @__PURE__ */ jsx(ToolResultBlock, {
+			text: event.text,
+			indent: paddingLeft
+		});
+		case "error": return /* @__PURE__ */ jsx("box", {
+			style: { paddingLeft },
+			children: /* @__PURE__ */ jsxs("text", {
+				fg: COLOR.error,
+				children: [/* @__PURE__ */ jsx("span", {
+					fg: COLOR.error,
+					children: "✗ "
+				}), safeText]
+			})
+		});
+		case "markdown": return /* @__PURE__ */ jsx("box", {
+			style: { paddingLeft },
+			children: /* @__PURE__ */ jsx(MarkdownBlock, {
+				text: event.text,
+				streaming: event.streaming ?? false,
+				dim: child
+			})
+		});
+		case "spawn-start": return /* @__PURE__ */ jsx("box", {
+			style: { paddingLeft },
+			children: /* @__PURE__ */ jsxs("text", {
+				fg: COLOR.dim,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.accent,
+						children: "🌱 "
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.dim,
+						children: `[${event.childId ?? "child"}] `
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.dim,
+						children: safeText
+					})
+				]
+			})
+		});
+		case "spawn-end": return /* @__PURE__ */ jsx("box", {
+			style: { paddingLeft },
+			children: /* @__PURE__ */ jsxs("text", {
+				fg: COLOR.dim,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.accent,
+						children: "✓ "
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.dim,
+						children: `[${event.childId ?? "child"}] `
+					}),
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.mute,
+						children: safeText
+					})
+				]
+			})
+		});
+		default: return /* @__PURE__ */ jsx("text", { children: safeText });
+	}
+}
+/** User prompt — bordered to rhyme with the prompt input box below. */
+function UserPromptBlock({ text }) {
+	return /* @__PURE__ */ jsx("box", {
+		style: {
+			border: true,
+			borderColor: COLOR.borderActive,
+			paddingLeft: 1,
+			paddingRight: 1
+		},
+		children: /* @__PURE__ */ jsx("text", {
+			fg: COLOR.brand,
+			children: text
+		})
+	});
+}
+/**
+* Markdown block. While `streaming` is true, content is passed through
+* `md4x.heal()` so unclosed delimiters (bold, italic, code, link, table) render
+* as if already complete. OpenTUI's `streaming` prop keeps its parser from
+* committing to the final layout for the trailing block.
+*/
+function MarkdownBlock({ text, streaming, dim }) {
+	return /* @__PURE__ */ jsx("markdown", {
+		content: useMemo(() => streaming ? heal(text) : text, [text, streaming]),
+		syntaxStyle: MD_STYLE,
+		streaming,
+		fg: dim ? COLOR.dim : void 0
+	});
+}
+const TOOL_RESULT_MAX_LINES = 6;
+function ToolResultBlock({ text, indent }) {
+	const lines = text.split("\n");
+	const visible = lines.slice(0, TOOL_RESULT_MAX_LINES);
+	const omitted = Math.max(0, lines.length - TOOL_RESULT_MAX_LINES);
+	return /* @__PURE__ */ jsxs("box", {
+		style: {
+			paddingLeft: indent,
+			flexDirection: "column"
+		},
+		children: [visible.map((line, i) => /* @__PURE__ */ jsxs("text", {
+			fg: COLOR.mute,
+			children: [/* @__PURE__ */ jsx("span", {
+				fg: COLOR.borderActive,
+				children: "┃ "
+			}), line || " "]
+		}, i)), omitted > 0 && /* @__PURE__ */ jsxs("text", {
+			fg: COLOR.mute,
+			children: [/* @__PURE__ */ jsx("span", {
+				fg: COLOR.borderActive,
+				children: "┃ "
+			}), `… ${omitted} more line${omitted === 1 ? "" : "s"}`]
+		})]
+	});
+}
+//#endregion
+//#region src/tui/auth.ts
+const ENV_KEYS = {
+	anthropic: "ANTHROPIC_API_KEY",
+	openai: "OPENAI_CODEX_API_KEY",
+	openrouter: "OPENROUTER_API_KEY",
+	cerebras: "CEREBRAS_API_KEY"
+};
+/** Maps a provider to the credentials.json key written by `bun run auth`. */
+const OAUTH_KEYS = {
+	anthropic: "anthropic",
+	openai: "openai-codex"
+};
+const LABELS = {
+	anthropic: "Anthropic",
+	openai: "OpenAI Codex",
+	openrouter: "OpenRouter",
+	cerebras: "Cerebras"
+};
+function envKeyFor(key) {
+	return ENV_KEYS[key];
+}
+/**
+* Detect available auth across the providers the harness ships with.
+*
+* Mirrors the resolution order used by the providers at runtime:
+*   - explicit env var (highest)
+*   - OAuth credentials in `.credentials.json` (anthropic + openai-codex only)
+*
+* Pure read — never refreshes or rewrites the credentials file.
+*/
+function detectAuth(env = process.env) {
+	const credsPath = resolve(process.cwd(), ".credentials.json");
+	let creds = {};
+	if (existsSync(credsPath)) try {
+		const parsed = JSON.parse(readFileSync(credsPath, "utf-8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) creds = parsed;
+	} catch {}
+	return Object.keys(LABELS).map((key) => {
+		const methods = [];
+		const envKey = ENV_KEYS[key];
+		if (env[envKey]) methods.push({
+			source: "env",
+			detail: envKey
+		});
+		const oauthKey = OAUTH_KEYS[key];
+		if (oauthKey) {
+			const entry = creds[oauthKey];
+			if (entry?.access && entry.refresh) {
+				const detail = entry.expires ? `oauth · expires ${new Date(entry.expires).toLocaleString()}` : "oauth · .credentials.json";
+				methods.push({
+					source: "oauth",
+					detail
+				});
+			}
+		}
+		return {
+			key,
+			label: LABELS[key],
+			available: methods.length > 0,
+			methods
+		};
+	});
+}
+//#endregion
+//#region src/tui/providers.ts
+/**
+* Construct a fresh provider instance for a given key.
+*
+* Providers are cheap to build — credentials are resolved lazily at first
+* stream call — so we instantiate on demand rather than caching a singleton.
+* This also avoids leaking state across session/provider switches.
+*/
+const FACTORIES = {
+	anthropic,
+	openai,
+	openrouter,
+	cerebras
+};
+/** zidane provider key → pi-ai provider id (some don't match 1:1). */
+const PI_PROVIDER_ID = {
+	anthropic: "anthropic",
+	openai: "openai-codex",
+	openrouter: "openrouter",
+	cerebras: "cerebras"
+};
+/**
+* Look up the model's max context window via pi-ai's model registry.
+* Returns `null` when the model isn't known (e.g. a custom openrouter slug);
+* callers should hide the context indicator in that case.
+*/
+function getContextWindow(key, modelId) {
+	try {
+		const providerId = PI_PROVIDER_ID[key];
+		return getModel(providerId, modelId)?.contextWindow ?? null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/tui/store.ts
+function ensureDir(path) {
+	const dir = dirname(path);
+	if (existsSync(dir)) return;
+	try {
+		mkdirSync(dir, { recursive: true });
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Could not create TUI storage directory at "${dir}". Override the location via \`runTui({ storageDir, prefix })\` or the \`ZIDANE_STORAGE_DIR\` env var. Original error: ${message}`);
+	}
+}
+function createTuiStore(dbPath) {
+	ensureDir(dbPath);
+	return createSqliteStore({ path: dbPath });
+}
+function createStateStore(path) {
+	return {
+		load: () => loadState(path),
+		save: (state) => saveState(path, state)
+	};
+}
+function loadState(path) {
+	if (!existsSync(path)) return {};
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf-8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return {};
+}
+function saveState(path, state) {
+	ensureDir(path);
+	const tmp = `${path}.${process.pid}.tmp`;
+	writeFileSync(tmp, JSON.stringify(state, null, 2));
+	renameSync(tmp, path);
+}
+/**
+* Load every session and project it to the compact `SessionMeta` shape used by
+* the picker. Sorted by recency via the underlying store's `list()` contract
+* (sqlite store returns by `updated_at DESC`).
+*/
+async function listSessionMeta(store) {
+	const ids = await store.list();
+	return (await Promise.all(ids.map(async (id) => {
+		const data = await store.load(id);
+		if (!data) return null;
+		return {
+			id,
+			title: titleFromTurns(data.turns) ?? "untitled",
+			turnCount: data.turns.length,
+			updatedAt: data.updatedAt
+		};
+	}))).filter((m) => m !== null);
+}
+/** Derive a short title from the first user message — returns null when empty. */
+function titleFromTurns(turns) {
+	const first = turns.find((t) => t.role === "user");
+	if (!first) return null;
+	for (const block of first.content) if (block.type === "text" && block.text.trim()) {
+		const oneLine = block.text.replace(/\s+/g, " ").trim();
+		return oneLine.length > 60 ? `${oneLine.slice(0, 60)}…` : oneLine;
+	}
+	return null;
+}
+/**
+* Replay persisted turns as a viewable transcript. Mirrors the event shape produced
+* live by the agent hooks so loaded and streaming history render identically.
+*
+* Skips `tool_result` blocks (they're not user-visible by default), and inserts a
+* `separator` event between turn groups so the eye can parse turn boundaries.
+*/
+function eventsFromTurns(turns) {
+	const events = [];
+	for (let i = 0; i < turns.length; i++) {
+		const turn = turns[i];
+		if (i > 0) events.push({
+			kind: "separator",
+			text: ""
+		});
+		if (turn.role === "user") {
+			for (const block of turn.content) if (block.type === "text" && block.text.trim()) events.push({
+				kind: "info",
+				text: `❯ ${block.text}`
+			});
+			else if (block.type === "tool_result") events.push({
+				kind: "tool-result",
+				text: toolResultText(block.output)
+			});
+			continue;
+		}
+		if (turn.role === "assistant") {
+			for (const block of turn.content) if (block.type === "text" && block.text.trim()) events.push({
+				kind: "markdown",
+				text: block.text,
+				streaming: false
+			});
+			else if (block.type === "tool_call") events.push({
+				kind: "tool",
+				text: toolCallPreview(block.name, block.input)
+			});
+		}
+	}
+	return events;
+}
+/** Shared formatter for the `↳ name(args)` line shown on tool calls. */
+function toolCallPreview(name, input) {
+	const args = JSON.stringify(input);
+	return args && args !== "{}" ? `${name}(${args})` : name;
+}
+/** Render tool output as plain text, whether it's a string or structured content. */
+function toolResultText(output) {
+	return typeof output === "string" ? output : toolResultToText(output);
+}
+/** Effective context size of the most recent assistant turn — drives the footer indicator. */
+function lastContextSizeFromTurns(turns) {
+	for (let i = turns.length - 1; i >= 0; i--) {
+		const turn = turns[i];
+		if (turn.role === "assistant" && turn.usage) return (turn.usage.input ?? 0) + (turn.usage.cacheRead ?? 0) + (turn.usage.cacheCreation ?? 0);
+	}
+	return 0;
+}
+//#endregion
+//#region src/tui/config.tsx
+/** Resolve user options into a fully-bound runtime config. Pure aside from disk reads. */
+function resolveConfig(options = {}) {
+	const prefix = options.prefix ?? process.env.ZIDANE_PREFIX ?? ".zidane";
+	const storageDir = options.storageDir ?? process.env.ZIDANE_STORAGE_DIR ?? homedir();
+	const dir = resolve(storageDir, prefix);
+	const paths = {
+		dir,
+		db: resolve(dir, "sessions.db"),
+		state: resolve(dir, "state.json")
+	};
+	const store = options.store ?? createTuiStore(paths.db);
+	const stateStore = createStateStore(paths.state);
+	const initialState = stateStore.load();
+	const providers = {
+		...FACTORIES,
+		...options.providers ?? {}
+	};
+	const preset = options.preset ?? basic_default;
+	const modelsFor = makeModelsResolver(options.models);
+	const resumeProvider = resolveResumeProvider(initialState, providers);
+	const initialPicked = resumeProvider ? pickInitial(resumeProvider, providers, initialState) : null;
+	return {
+		prefix,
+		storageDir,
+		paths,
+		providers,
+		preset,
+		store,
+		stateStore,
+		modelsFor,
+		initialState,
+		initialSettings: initialState.settings ?? {},
+		resumeProvider,
+		initialPicked
+	};
+}
+function makeModelsResolver(custom) {
+	return (key) => {
+		const overridden = custom?.[key];
+		if (overridden) return overridden;
+		try {
+			const piId = PI_PROVIDER_ID[key];
+			return getModels(piId);
+		} catch {
+			return [];
+		}
+	};
+}
+function resolveResumeProvider(state, providers) {
+	if (!state.lastProvider) return null;
+	if (!providers[state.lastProvider]) return null;
+	return detectAuth().find((p) => p.key === state.lastProvider && p.available) ?? null;
+}
+function pickInitial(auth, providers, state) {
+	const factory = providers[auth.key];
+	if (!factory) return null;
+	const provider = factory();
+	return {
+		provider: auth,
+		model: state.lastModelByProvider?.[auth.key] ?? provider.meta.defaultModel
+	};
+}
+const ConfigContext = createContext(null);
+function ConfigProvider({ config, children }) {
+	return /* @__PURE__ */ jsx(ConfigContext.Provider, {
+		value: config,
+		children
+	});
+}
+function useConfig() {
+	const ctx = useContext(ConfigContext);
+	if (!ctx) throw new Error("useConfig must be used inside <ConfigProvider>");
+	return ctx;
+}
+//#endregion
+//#region src/tui/modal.tsx
+const ModalContext = createContext(null);
+function ModalRoot({ children }) {
+	const [active, setActive] = useState(null);
+	const api = useMemo(() => ({
+		open: (node) => setActive(node),
+		close: () => setActive(null),
+		get isOpen() {
+			return active !== null;
+		}
+	}), [active]);
+	return /* @__PURE__ */ jsxs(ModalContext.Provider, {
+		value: api,
+		children: [/* @__PURE__ */ jsx("box", {
+			style: {
+				flexDirection: "column",
+				flexGrow: 1
+			},
+			children
+		}), active && /* @__PURE__ */ jsx("box", {
+			style: {
+				position: "absolute",
+				top: 0,
+				left: 0,
+				right: 0,
+				bottom: 0,
+				alignItems: "center",
+				justifyContent: "center",
+				zIndex: 100
+			},
+			children: active
+		})]
+	});
+}
+function useModal() {
+	const ctx = useContext(ModalContext);
+	if (!ctx) throw new Error("useModal must be used inside <ModalRoot>");
+	return ctx;
+}
+/**
+* Focus computed against the modal layer.
+*
+* Pass a component's preferred focus state and this returns `false` whenever a
+* modal is open — so focused inputs (textarea, selects) release their focus and
+* stop intercepting keys behind the overlay. Pair with `focusable={false}` on
+* "passive" focusables (scrollbox) so the renderer doesn't cycle focus into
+* them when the primary input blurs.
+*/
+function useModalAwareFocus(preferred = true) {
+	const { isOpen } = useModal();
+	return preferred && !isOpen;
+}
+/**
+* Responsive modal — picks a width based on the live terminal size.
+*
+* - On a wide terminal, the modal grows to `maxWidth` so descriptions sit on
+*   one line and don't wrap.
+* - On a narrow terminal, the modal shrinks down to `minWidth`, keeping a
+*   small horizontal margin from the screen edges. Text inside wraps naturally.
+*
+* Uses `useTerminalDimensions()` so it reflows on `SIGWINCH` without remount.
+*/
+function Modal({ title, onClose, children, maxWidth = 92, minWidth = 44, horizontalMargin = 4 }) {
+	const ctx = useContext(ModalContext);
+	const dismiss = onClose ?? ctx?.close;
+	useKeyboard((key) => {
+		if (key.name === "escape") dismiss?.();
+	});
+	const { width: termWidth } = useTerminalDimensions();
+	const width = Math.max(minWidth, Math.min(maxWidth, termWidth - horizontalMargin * 2));
+	return /* @__PURE__ */ jsx("box", {
+		title: title ? ` ${title} ` : void 0,
+		style: {
+			border: true,
+			borderColor: COLOR.borderActive,
+			backgroundColor: "#101010",
+			paddingTop: 1,
+			paddingBottom: 1,
+			paddingLeft: 2,
+			paddingRight: 2,
+			width,
+			flexDirection: "column",
+			gap: 1
+		},
+		children
+	});
+}
+//#endregion
+//#region src/tui/model-picker.tsx
+/** Cap the visible scroll window so a 30-model list doesn't push the modal off-screen. */
+const VISIBLE_ROW_CAP = 12;
+/**
+* Modal that lists the available models for the current provider and lets the
+* user pick one. Options come from `runTui({ models })` if supplied, otherwise
+* from pi-ai's built-in registry.
+*
+* Each row shows: `● selected · name (ctx N · reasoning · vision)`.
+*/
+function ModelPickerModal({ models, currentModelId, onPick }) {
+	const initialIndex = useMemo(() => models.findIndex((m) => m.id === currentModelId), [models, currentModelId]);
+	const options = useMemo(() => models.map((m) => ({
+		name: `${m.id === currentModelId ? "● " : "  "}${m.name ?? m.id}`,
+		description: describeModel(m),
+		value: m.id
+	})), [models, currentModelId]);
+	if (models.length === 0) return /* @__PURE__ */ jsx(EmptyState, {});
+	const visibleRows = Math.min(options.length, VISIBLE_ROW_CAP);
+	const currentMissing = initialIndex < 0;
+	const safeIndex = currentMissing ? 0 : initialIndex;
+	return /* @__PURE__ */ jsxs(Modal, {
+		title: "select model",
+		children: [
+			currentMissing && /* @__PURE__ */ jsx("text", {
+				fg: COLOR.warn,
+				children: `Current model "${currentModelId}" is not in this registry — pick one below to switch.`
+			}),
+			/* @__PURE__ */ jsx("select", {
+				...SELECT_THEME,
+				focused: true,
+				options,
+				wrapSelection: true,
+				selectedIndex: safeIndex,
+				showScrollIndicator: options.length > visibleRows,
+				style: { height: visibleRows },
+				onSelect: (_idx, option) => {
+					if (option) onPick(option.value);
+				}
+			}),
+			/* @__PURE__ */ jsxs("text", {
+				fg: COLOR.mute,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.warn,
+						children: "↑↓"
+					}),
+					" navigate · ",
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.warn,
+						children: "↵"
+					}),
+					" select · ",
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.warn,
+						children: "esc"
+					}),
+					" close"
+				]
+			})
+		]
+	});
+}
+function EmptyState() {
+	return /* @__PURE__ */ jsxs(Modal, {
+		title: "select model",
+		children: [/* @__PURE__ */ jsx("text", {
+			fg: COLOR.dim,
+			children: "No models available for this provider."
+		}), /* @__PURE__ */ jsx("text", {
+			fg: COLOR.mute,
+			children: "Pass a `models` registry to `runTui()` to populate this list."
+		})]
+	});
+}
+/** "ctx 200k · reasoning · vision" — compact per-model description. */
+function describeModel(m) {
+	const parts = [`ctx ${fmtTokens(m.contextWindow)}`];
+	if (m.reasoning) parts.push("reasoning");
+	if (m.input?.includes("image")) parts.push("vision");
+	return parts.join(" · ");
+}
+//#endregion
+//#region src/tui/screens.tsx
+/**
+* Textarea bindings: plain `enter` submits; `shift+enter` inserts a newline.
+* All `return` defaults are stripped and replaced so the user's preferred
+* binding wins regardless of modifier state.
+*/
+const TEXTAREA_BINDINGS = [
+	...defaultTextareaKeyBindings.filter((b) => b.name !== "return"),
+	{
+		name: "return",
+		action: "submit"
+	},
+	{
+		name: "return",
+		shift: true,
+		action: "newline"
+	}
+];
+function AuthScreen({ onPick }) {
+	const { providers: registry } = useConfig();
+	const focused = useModalAwareFocus();
+	const providers = useMemo(() => detectAuth().filter((p) => p.key in registry), [registry]);
+	const available = useMemo(() => providers.filter((p) => p.available), [providers]);
+	if (available.length === 0) return /* @__PURE__ */ jsx(NoAuthScreen, { providers });
+	const options = available.map((p) => ({
+		name: p.label,
+		description: p.methods.map((m) => m.detail).join(" · "),
+		value: p.key
+	}));
+	return /* @__PURE__ */ jsx("box", {
+		title: " pick a provider ",
+		style: {
+			border: true,
+			borderColor: COLOR.border,
+			padding: 1,
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: /* @__PURE__ */ jsx("select", {
+			...SELECT_THEME,
+			focused,
+			options,
+			wrapSelection: true,
+			onSelect: (_idx, option) => {
+				if (!option) return;
+				const provider = available.find((p) => p.key === option.value);
+				if (provider) onPick(provider);
+			},
+			style: { flexGrow: 1 }
+		})
+	});
+}
+function NoAuthScreen({ providers }) {
+	return /* @__PURE__ */ jsxs("box", {
+		title: " no authentication detected ",
+		style: {
+			border: true,
+			borderColor: COLOR.error,
+			padding: 1,
+			flexDirection: "column",
+			gap: 1,
+			flexGrow: 1
+		},
+		children: [
+			/* @__PURE__ */ jsx("text", {
+				fg: COLOR.error,
+				children: "No provider credentials found."
+			}),
+			/* @__PURE__ */ jsx("text", {
+				fg: COLOR.dim,
+				children: "Set one of these env vars (or run `bun run auth` for OAuth):"
+			}),
+			providers.map((p) => /* @__PURE__ */ jsxs("text", {
+				fg: COLOR.dim,
+				children: [
+					"  · ",
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.brand,
+						children: p.label
+					}),
+					" → ",
+					/* @__PURE__ */ jsx("span", {
+						fg: COLOR.model,
+						children: envKeyFor(p.key)
+					})
+				]
+			}, p.key))
+		]
+	});
+}
+const NEW_VALUE = "__new__";
+function SessionsScreen({ sessions, currentId, onPick, onCreate }) {
+	const focused = useModalAwareFocus();
+	const options = useMemo(() => {
+		const items = [{
+			name: "+ new session",
+			description: "start fresh",
+			value: NEW_VALUE
+		}];
+		for (const s of sessions) {
+			const marker = s.id === currentId ? "● " : "  ";
+			const turnLabel = `${s.turnCount} turn${s.turnCount === 1 ? "" : "s"}`;
+			items.push({
+				name: `${marker}${s.title}`,
+				description: `#${shortId(s.id)} · ${turnLabel} · ${ageString(s.updatedAt)}`,
+				value: s.id
+			});
+		}
+		return items;
+	}, [sessions, currentId]);
+	return /* @__PURE__ */ jsx("box", {
+		title: " sessions ",
+		style: {
+			border: true,
+			borderColor: COLOR.border,
+			padding: 1,
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: /* @__PURE__ */ jsx("select", {
+			...SELECT_THEME,
+			focused,
+			options,
+			wrapSelection: true,
+			onSelect: (_idx, option) => {
+				if (!option) return;
+				if (option.value === NEW_VALUE) onCreate();
+				else onPick(option.value);
+			},
+			style: { flexGrow: 1 }
+		})
+	});
+}
+/** Visible content lines: 1 minimum, 5 maximum (textarea scrolls past 5). */
+const MIN_CONTENT_LINES = 1;
+const MAX_CONTENT_LINES = 5;
+function ChatScreen({ events, busy, settings, onSubmit, session }) {
+	const title = useMemo(() => {
+		if (!session) return " untitled ";
+		const turns = `${session.turnCount} turn${session.turnCount === 1 ? "" : "s"}`;
+		return ` ${session.title}  ·  #${shortId(session.id)} · ${turns} `;
+	}, [session]);
+	const userPrompts = useMemo(() => events.filter((e) => e.kind === "info").map((e) => e.text.replace(/^❯ /, "")), [events]);
+	return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: [/* @__PURE__ */ jsx("box", {
+			title,
+			style: {
+				border: true,
+				borderColor: COLOR.border,
+				flexGrow: 1,
+				flexDirection: "column"
+			},
+			children: /* @__PURE__ */ jsx(Transcript, {
+				events,
+				settings
+			})
+		}), busy ? /* @__PURE__ */ jsx(BusyBlock, {}) : /* @__PURE__ */ jsx(PromptBlock, {
+			userPrompts,
+			onSubmit
+		})]
+	});
+}
+function BusyBlock() {
+	return /* @__PURE__ */ jsx("box", {
+		style: {
+			border: true,
+			borderColor: COLOR.warn,
+			paddingLeft: 1,
+			paddingRight: 1,
+			height: 3
+		},
+		children: /* @__PURE__ */ jsx(Spinner, { label: "streaming response — esc to abort" })
+	});
+}
+function PromptBlock({ userPrompts, onSubmit }) {
+	const focused = useModalAwareFocus();
+	const textareaRef = useRef(null);
+	/** Auto-grow: visible content rows the textarea currently occupies (clamped 1..5). */
+	const [contentLines, setContentLines] = useState(MIN_CONTENT_LINES);
+	/**
+	* History navigation state. `null` = not navigating (textarea owns its content).
+	* Once the user enters history (up at top), we snapshot the draft and cycle.
+	*/
+	const historyRef = useRef(null);
+	const syncLines = useCallback(() => {
+		const lines = textareaRef.current?.lineCount ?? MIN_CONTENT_LINES;
+		setContentLines(Math.max(MIN_CONTENT_LINES, lines));
+	}, []);
+	const submit = useCallback(() => {
+		const value = textareaRef.current?.plainText ?? "";
+		if (!value.trim()) return;
+		onSubmit(value);
+		textareaRef.current?.clear();
+		historyRef.current = null;
+		setContentLines(MIN_CONTENT_LINES);
+	}, [onSubmit]);
+	const cycleHistory = useCallback((direction) => {
+		if (userPrompts.length === 0 || !textareaRef.current) return;
+		if (historyRef.current === null) historyRef.current = {
+			idx: userPrompts.length,
+			draft: textareaRef.current.plainText
+		};
+		const nextIdx = historyRef.current.idx + direction;
+		if (nextIdx < 0) return;
+		if (nextIdx >= userPrompts.length) {
+			textareaRef.current.setText(historyRef.current.draft);
+			textareaRef.current.gotoBufferEnd();
+			historyRef.current = null;
+		} else {
+			textareaRef.current.setText(userPrompts[nextIdx]);
+			textareaRef.current.gotoBufferEnd();
+			historyRef.current.idx = nextIdx;
+		}
+		syncLines();
+	}, [userPrompts, syncLines]);
+	/**
+	* Up/Down at the buffer boundary cycles prompt history (fish/zsh pattern).
+	* Mid-buffer up/down move the cursor normally — handled by the default
+	* `move-up` / `move-down` actions in `TEXTAREA_BINDINGS`.
+	*/
+	const onKeyDown = useCallback((event) => {
+		if (event.ctrl || event.shift || event.meta) return;
+		if (event.name !== "up" && event.name !== "down") return;
+		const buffer = textareaRef.current;
+		if (!buffer) return;
+		const cursorRow = buffer.logicalCursor.row;
+		if (event.name === "up" && cursorRow === 0) cycleHistory(-1);
+		else if (event.name === "down" && cursorRow === buffer.lineCount - 1) cycleHistory(1);
+	}, [cycleHistory]);
+	const boxHeight = Math.min(MAX_CONTENT_LINES, contentLines) + 2;
+	return /* @__PURE__ */ jsx("box", {
+		style: {
+			border: true,
+			borderColor: COLOR.borderActive,
+			paddingLeft: 1,
+			paddingRight: 1,
+			height: boxHeight,
+			flexDirection: "column"
+		},
+		children: /* @__PURE__ */ jsx("textarea", {
+			ref: textareaRef,
+			focused,
+			keyBindings: TEXTAREA_BINDINGS,
+			placeholder: "Ask zidane… (enter = send · shift+enter = newline · ↑↓ at edges = history)",
+			style: {
+				flexGrow: 1,
+				height: "100%"
+			},
+			onSubmit: submit,
+			onContentChange: syncLines,
+			onKeyDown
+		})
+	});
+}
+//#endregion
+//#region src/tui/settings.tsx
+const DEFAULT_SETTINGS = {
+	showThinking: true,
+	showToolCalls: true,
+	showToolResults: true
+};
+const SettingsContext = createContext(null);
+function SettingsProvider({ initial, onChange, children }) {
+	const [settings, setSettings] = useState(initial);
+	const toggle = useCallback((key) => {
+		setSettings((prev) => {
+			const next = {
+				...prev,
+				[key]: !prev[key]
+			};
+			onChange?.(next);
+			return next;
+		});
+	}, [onChange]);
+	const value = useMemo(() => ({
+		settings,
+		toggle
+	}), [settings, toggle]);
+	return /* @__PURE__ */ jsx(SettingsContext.Provider, {
+		value,
+		children
+	});
+}
+function useSettings() {
+	const ctx = useContext(SettingsContext);
+	if (!ctx) throw new Error("useSettings must be used inside <SettingsProvider>");
+	return ctx;
+}
+const ROWS = [
+	{
+		key: "showThinking",
+		label: "Thinking blocks",
+		description: "agent reasoning shown inline"
+	},
+	{
+		key: "showToolCalls",
+		label: "Tool calls",
+		description: "the ↳ name(args) lines"
+	},
+	{
+		key: "showToolResults",
+		label: "Tool outputs",
+		description: "the ┃ result blocks under tool calls"
+	}
+];
+function SettingsModal() {
+	const { settings, toggle } = useSettings();
+	const [cursor, setCursor] = useState(0);
+	useKeyboard((key) => {
+		if (key.name === "up" || key.ctrl && key.name === "p") setCursor((c) => Math.max(0, c - 1));
+		else if (key.name === "down" || key.ctrl && key.name === "n") setCursor((c) => Math.min(ROWS.length - 1, c + 1));
+		else if (key.name === "return" || key.name === "space") toggle(ROWS[cursor].key);
+	});
+	return /* @__PURE__ */ jsxs(Modal, {
+		title: "settings",
+		children: [/* @__PURE__ */ jsx("box", {
+			style: { flexDirection: "column" },
+			children: ROWS.map((row, i) => /* @__PURE__ */ jsx(SettingRowView, {
+				row,
+				enabled: settings[row.key],
+				focused: i === cursor
+			}, row.key))
+		}), /* @__PURE__ */ jsxs("text", {
+			fg: COLOR.mute,
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					fg: COLOR.warn,
+					children: "↑↓"
+				}),
+				" navigate · ",
+				/* @__PURE__ */ jsx("span", {
+					fg: COLOR.warn,
+					children: "↵"
+				}),
+				" toggle · ",
+				/* @__PURE__ */ jsx("span", {
+					fg: COLOR.warn,
+					children: "esc"
+				}),
+				" close"
+			]
+		})]
+	});
+}
+/**
+* A single setting row — `▶` marker · checkbox · label · description.
+*
+* Rendered as one `<text>` so OpenTUI's word-wrap handles narrow terminals
+* automatically: on wide screens everything sits on one line; on narrow ones
+* the trailing description wraps under the label without breaking the row's
+* structure.
+*/
+function SettingRowView({ row, enabled, focused }) {
+	return /* @__PURE__ */ jsxs("text", {
+		fg: focused ? COLOR.brand : COLOR.dim,
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				fg: focused ? COLOR.brand : COLOR.mute,
+				children: focused ? "▶ " : "  "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: enabled ? COLOR.accent : COLOR.mute,
+				children: enabled ? "[✓] " : "[ ] "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: focused ? COLOR.brand : COLOR.dim,
+				children: row.label
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: COLOR.mute,
+				children: `  ${row.description}`
+			})
+		]
+	});
+}
+//#endregion
+//#region src/tui/streaming.ts
+/** Target one flush per ~33ms (one frame at the default renderer targetFps=30). */
+const FLUSH_INTERVAL_MS = 33;
+const PARENT_OWNER = "parent";
+function emptyBucket(owner, depth) {
+	return {
+		markdown: "",
+		thinking: "",
+		owner,
+		depth
+	};
+}
+function applyBucket(prev, bucket) {
+	let result = prev;
+	if (bucket.thinking) result = appendThinkingLines(result, bucket.thinking, bucket.owner, bucket.depth);
+	if (bucket.markdown) result = appendMarkdownDelta(result, bucket.markdown, bucket.owner, bucket.depth);
+	return result;
+}
+function appendMarkdownDelta(prev, delta, owner, depth) {
+	const last = prev[prev.length - 1];
+	if (last && last.kind === "markdown" && last.streaming && ownerOf(last) === owner) {
+		const next = prev.slice(0, -1);
+		next.push({
+			...last,
+			text: last.text + delta
+		});
+		return next;
+	}
+	return [...prev, eventWithOwner({
+		kind: "markdown",
+		text: delta,
+		streaming: true
+	}, owner, depth)];
+}
+function appendThinkingLines(prev, delta, owner, depth) {
+	const lines = delta.split("\n");
+	const result = [...prev];
+	const last = result[result.length - 1];
+	if (last && last.kind === "thinking" && ownerOf(last) === owner) result[result.length - 1] = {
+		...last,
+		text: last.text + lines[0]
+	};
+	else if (lines[0] || lines.length > 1) result.push(eventWithOwner({
+		kind: "thinking",
+		text: lines[0]
+	}, owner, depth));
+	for (let i = 1; i < lines.length; i++) result.push(eventWithOwner({
+		kind: "thinking",
+		text: lines[i]
+	}, owner, depth));
+	return result;
+}
+function ownerOf(evt) {
+	return evt.childId ?? PARENT_OWNER;
+}
+function eventWithOwner(evt, owner, depth) {
+	if (owner === PARENT_OWNER) return evt;
+	return {
+		...evt,
+		childId: owner,
+		depth
+	};
+}
+/** Flip any trailing streaming markdown blocks (any owner) to finalized. */
+function finalizeStreamingMarkdown(events) {
+	let changed = false;
+	const next = events.map((e) => {
+		if (e.kind === "markdown" && e.streaming) {
+			changed = true;
+			return {
+				...e,
+				streaming: false
+			};
+		}
+		return e;
+	});
+	return changed ? next : events;
+}
+/** Flip the trailing streaming markdown block for one specific owner. */
+function finalizeStreamingMarkdownForOwner(events, owner) {
+	for (let i = events.length - 1; i >= 0; i--) {
+		const e = events[i];
+		if (e.kind !== "markdown") continue;
+		if (!e.streaming) continue;
+		if (ownerOf(e) !== owner) continue;
+		const next = events.slice();
+		next[i] = {
+			...e,
+			streaming: false
+		};
+		return next;
+	}
+	return events;
+}
+/**
+* Effective context size for a single turn.
+*
+* `usage.input` is misleading on its own when prompt caching is active: providers
+* (Anthropic, OpenRouter→Anthropic, Gemini) report `input` as the *new uncached*
+* tokens only — the cached prefix shows up in `cacheRead`, and newly-cached
+* tokens in `cacheCreation`. The model still saw all three buckets, so the real
+* context-window utilization is their sum.
+*
+* Non-caching providers leave `cacheRead`/`cacheCreation` undefined, so this
+* collapses to plain `input` for them.
+*/
+function turnContextSize(usage) {
+	if (!usage) return 0;
+	return (usage.input ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheCreation ?? 0);
+}
+function useStreamBuffer(setEvents) {
+	const bucketsRef = useRef(/* @__PURE__ */ new Map());
+	const flushTimerRef = useRef(null);
+	const drainPendingInto = useCallback((updater) => {
+		if (flushTimerRef.current) {
+			clearTimeout(flushTimerRef.current);
+			flushTimerRef.current = null;
+		}
+		const buckets = Array.from(bucketsRef.current.values());
+		bucketsRef.current.clear();
+		if (!buckets.some((b) => b.markdown.length > 0 || b.thinking.length > 0) && !updater) return;
+		setEvents((prev) => {
+			let merged = prev;
+			for (const bucket of buckets) merged = applyBucket(merged, bucket);
+			return updater ? updater(merged) : merged;
+		});
+	}, [setEvents]);
+	const flush = useCallback(() => drainPendingInto(), [drainPendingInto]);
+	const flushAndUpdate = useCallback((update) => drainPendingInto(update), [drainPendingInto]);
+	const appendImmediate = useCallback((evt) => drainPendingInto((events) => [...events, evt]), [drainPendingInto]);
+	const queueStreamDelta = useCallback((kind, delta, source) => {
+		if (!delta) return;
+		const owner = source?.childId ?? PARENT_OWNER;
+		const depth = source?.depth ?? 0;
+		let bucket = bucketsRef.current.get(owner);
+		if (!bucket) {
+			bucket = emptyBucket(owner, depth);
+			bucketsRef.current.set(owner, bucket);
+		}
+		bucket[kind] += delta;
+		if (!flushTimerRef.current) flushTimerRef.current = setTimeout(flush, FLUSH_INTERVAL_MS);
+	}, [flush]);
+	const reset = useCallback(() => {
+		if (flushTimerRef.current) {
+			clearTimeout(flushTimerRef.current);
+			flushTimerRef.current = null;
+		}
+		bucketsRef.current.clear();
+	}, []);
+	return useMemo(() => ({
+		queueStreamDelta,
+		appendImmediate,
+		flushAndUpdate,
+		flush,
+		reset
+	}), [
+		queueStreamDelta,
+		appendImmediate,
+		flushAndUpdate,
+		flush,
+		reset
+	]);
+}
+//#endregion
+//#region src/tui/app.tsx
+/**
+* Surface failures that are normally silenced (teardown / save) when the
+* `ZIDANE_DEBUG` env var is set. Logging via `console.error` would otherwise
+* trigger OpenTUI's error console overlay and clutter the UI for end users.
+*/
+const debugLog = process.env.ZIDANE_DEBUG ? (label, err) => console.error(`[zidane/tui] ${label}:`, err) : () => {};
+/**
+* Top-level TUI component. Accepts a fully-resolved `ResolvedConfig` and wires
+* everything (settings, modal layer, screens, footer) underneath it.
+*
+* Hosts can either drive this via `runTui()` for the standard bootstrap or
+* mount `<App config={resolveConfig(...)} />` themselves inside a renderer
+* they already own.
+*/
+function App({ config }) {
+	return /* @__PURE__ */ jsx(ConfigProvider, {
+		config,
+		children: /* @__PURE__ */ jsx(SettingsProvider, {
+			initial: useMemo(() => ({
+				...DEFAULT_SETTINGS,
+				...config.initialSettings
+			}), [config.initialSettings]),
+			onChange: useCallback((settings) => config.stateStore.save({
+				...config.stateStore.load(),
+				settings
+			}), [config.stateStore]),
+			children: /* @__PURE__ */ jsx(ModalRoot, { children: /* @__PURE__ */ jsx(AppShell, {}) })
+		})
+	});
+}
+function AppShell() {
+	const renderer = useRenderer();
+	const modal = useModal();
+	const config = useConfig();
+	const { settings } = useSettings();
+	const { providers: providerRegistry, preset, store, stateStore, modelsFor, resumeProvider, initialPicked, initialState } = config;
+	const lastResumedSessionId = initialState.lastSessionId;
+	const [screen, setScreen] = useState(() => {
+		if (!resumeProvider) return "auth";
+		return lastResumedSessionId ? "chat" : "sessions";
+	});
+	const [picked, setPicked] = useState(() => initialPicked);
+	const [sessions, setSessions] = useState([]);
+	const [currentSession, setCurrentSession] = useState(null);
+	const [events, setEvents] = useState([]);
+	const [busy, setBusy] = useState(false);
+	/** Token count from the most recent assistant turn (caching-aware). */
+	const [lastInputTokens, setLastInputTokens] = useState(0);
+	const agentRef = useRef(null);
+	const sessionRef = useRef(null);
+	const stream = useStreamBuffer(setEvents);
+	const makePicked = useCallback((provider, modelId) => {
+		const factory = providerRegistry[provider.key];
+		if (!factory) return null;
+		const remembered = initialState.lastModelByProvider?.[provider.key];
+		return {
+			provider,
+			model: modelId ?? remembered ?? factory().meta.defaultModel
+		};
+	}, [providerRegistry, initialState]);
+	const buildAgent = useCallback((session, key) => {
+		const factory = providerRegistry[key];
+		if (!factory) throw new Error(`No provider registered for key "${key}"`);
+		const agent = createAgent({
+			...preset,
+			provider: factory(),
+			session
+		});
+		agent.hooks.hook("stream:thinking", ({ delta }) => stream.queueStreamDelta("thinking", delta));
+		agent.hooks.hook("stream:text", ({ delta }) => stream.queueStreamDelta("markdown", delta));
+		agent.hooks.hook("tool:before", ({ name, input }) => {
+			stream.appendImmediate({
+				kind: "tool",
+				text: toolCallPreview(name, input)
+			});
+		});
+		agent.hooks.hook("tool:after", ({ result }) => {
+			stream.appendImmediate({
+				kind: "tool-result",
+				text: toolResultText(result)
+			});
+		});
+		agent.hooks.hook("mcp:tool:after", ({ result }) => {
+			stream.appendImmediate({
+				kind: "tool-result",
+				text: toolResultText(result)
+			});
+		});
+		agent.hooks.hook("turn:after", ({ usage }) => {
+			if (usage) setLastInputTokens(turnContextSize(usage));
+			stream.flushAndUpdate(finalizeStreamingMarkdown);
+		});
+		agent.hooks.hook("spawn:before", ({ id, task, depth }) => {
+			const taskPreview = task.length > 80 ? `${task.slice(0, 80)}…` : task;
+			stream.appendImmediate({
+				kind: "spawn-start",
+				text: taskPreview,
+				childId: id,
+				depth: depth ?? 1
+			});
+		});
+		agent.hooks.hook("spawn:complete", ({ id, depth, status, stats }) => {
+			const tag = status === "aborted" ? "aborted" : status === "error" ? "error" : "done";
+			stream.appendImmediate({
+				kind: "spawn-end",
+				text: `${tag} · ${stats.totalIn} in / ${stats.totalOut} out`,
+				childId: id,
+				depth: depth ?? 1
+			});
+		});
+		agent.hooks.hook("spawn:error", ({ id, depth, error }) => {
+			stream.appendImmediate({
+				kind: "error",
+				text: `[${id}] ${error.message}`,
+				childId: id,
+				depth: depth ?? 1
+			});
+		});
+		agent.hooks.hook("child:stream:thinking", ({ delta, childId, depth }) => {
+			stream.queueStreamDelta("thinking", delta, {
+				childId,
+				depth
+			});
+		});
+		agent.hooks.hook("child:stream:text", ({ delta, childId, depth }) => {
+			stream.queueStreamDelta("markdown", delta, {
+				childId,
+				depth
+			});
+		});
+		agent.hooks.hook("child:tool:before", ({ name, input, childId, depth }) => {
+			stream.appendImmediate({
+				kind: "tool",
+				text: toolCallPreview(name, input),
+				childId,
+				depth
+			});
+		});
+		agent.hooks.hook("child:tool:after", ({ result, childId, depth }) => {
+			stream.appendImmediate({
+				kind: "tool-result",
+				text: toolResultText(result),
+				childId,
+				depth
+			});
+		});
+		agent.hooks.hook("child:stream:end", ({ childId }) => {
+			stream.flushAndUpdate((prev) => finalizeStreamingMarkdownForOwner(prev, childId));
+		});
+		return agent;
+	}, [
+		providerRegistry,
+		preset,
+		stream
+	]);
+	const refreshSessions = useCallback(async () => {
+		const list = await listSessionMeta(store);
+		setSessions(list);
+		return list;
+	}, [store]);
+	const teardown = useCallback(async () => {
+		stream.reset();
+		await agentRef.current?.destroy().catch((err) => debugLog("agent.destroy failed", err));
+		agentRef.current = null;
+		sessionRef.current = null;
+	}, [stream]);
+	const activateSession = useCallback(async (id, key) => {
+		await teardown();
+		const session = (id ? await loadSession(store, id) : null) ?? await createSession({
+			store,
+			...id ? { id } : {}
+		});
+		sessionRef.current = session;
+		agentRef.current = buildAgent(session, key);
+		setEvents(eventsFromTurns(session.turns));
+		setLastInputTokens(lastContextSizeFromTurns(session.turns));
+		setCurrentSession({
+			id: session.id,
+			title: titleFromTurns(session.turns) ?? "untitled",
+			turnCount: session.turns.length,
+			updatedAt: Date.now()
+		});
+		setScreen("chat");
+		stateStore.save({
+			...stateStore.load(),
+			lastProvider: key,
+			lastSessionId: session.id
+		});
+	}, [
+		teardown,
+		buildAgent,
+		store,
+		stateStore
+	]);
+	useEffect(() => {
+		if (!resumeProvider) return;
+		let cancelled = false;
+		(async () => {
+			if (lastResumedSessionId) {
+				const data = await store.load(lastResumedSessionId);
+				if (cancelled) return;
+				if (data) {
+					await activateSession(lastResumedSessionId, resumeProvider.key);
+					return;
+				}
+			}
+			const list = await refreshSessions();
+			if (cancelled) return;
+			if (list.length === 0) await activateSession(null, resumeProvider.key);
+			else setScreen("sessions");
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		activateSession,
+		refreshSessions,
+		resumeProvider,
+		lastResumedSessionId,
+		store
+	]);
+	const onPickProvider = useCallback(async (p) => {
+		const next = makePicked(p);
+		if (!next) return;
+		setPicked(next);
+		stateStore.save({
+			...stateStore.load(),
+			lastProvider: p.key
+		});
+		if ((await refreshSessions()).length === 0) await activateSession(null, p.key);
+		else setScreen("sessions");
+	}, [
+		refreshSessions,
+		activateSession,
+		makePicked,
+		stateStore
+	]);
+	const onCreateSession = useCallback(async () => {
+		if (picked) await activateSession(null, picked.provider.key);
+	}, [picked, activateSession]);
+	const onSwitchSession = useCallback(async (id) => {
+		if (picked) await activateSession(id, picked.provider.key);
+	}, [picked, activateSession]);
+	const onOpenSessions = useCallback(async () => {
+		await refreshSessions();
+		setScreen("sessions");
+	}, [refreshSessions]);
+	const onAbort = useCallback(() => {
+		agentRef.current?.abort();
+	}, []);
+	const onPickModel = useCallback((modelId) => {
+		setPicked((prev) => {
+			if (!prev) return prev;
+			const prior = stateStore.load();
+			stateStore.save({
+				...prior,
+				lastModelByProvider: {
+					...prior.lastModelByProvider,
+					[prev.provider.key]: modelId
+				}
+			});
+			return {
+				...prev,
+				model: modelId
+			};
+		});
+		modal.close();
+	}, [modal, stateStore]);
+	const onSubmitPrompt = useCallback(async (prompt) => {
+		const agent = agentRef.current;
+		const session = sessionRef.current;
+		if (!agent || !session || !picked || !prompt.trim()) return;
+		if (events.length > 0) stream.appendImmediate({
+			kind: "separator",
+			text: ""
+		});
+		stream.appendImmediate({
+			kind: "info",
+			text: `❯ ${prompt}`
+		});
+		setBusy(true);
+		try {
+			await agent.run({
+				model: picked.model,
+				prompt
+			});
+			await session.save().catch((err) => debugLog("session.save failed", err));
+			setCurrentSession((prev) => prev ? {
+				...prev,
+				title: titleFromTurns(session.turns) ?? prev.title,
+				turnCount: session.turns.length,
+				updatedAt: Date.now()
+			} : prev);
+		} catch (err) {
+			stream.appendImmediate({
+				kind: "error",
+				text: err instanceof Error ? err.message : String(err)
+			});
+		} finally {
+			stream.flushAndUpdate(finalizeStreamingMarkdown);
+			setBusy(false);
+		}
+	}, [
+		picked,
+		events.length,
+		stream
+	]);
+	useKeyboard((key) => {
+		if (modal.isOpen) return;
+		if (key.ctrl && key.name === "," && screen !== "auth") {
+			modal.open(/* @__PURE__ */ jsx(SettingsModal, {}));
+			return;
+		}
+		if (key.ctrl && key.name === "m" && screen === "chat" && picked && !busy) {
+			modal.open(/* @__PURE__ */ jsx(ModelPickerModal, {
+				models: modelsFor(picked.provider.key),
+				currentModelId: picked.model,
+				onPick: onPickModel
+			}));
+			return;
+		}
+		if (key.name !== "escape") return;
+		if (busy) return onAbort();
+		if (screen === "chat") return onOpenSessions();
+		if (screen === "sessions") {
+			if (currentSession) setScreen("chat");
+			else renderer.destroy();
+			return;
+		}
+		renderer.destroy();
+	});
+	const hints = useMemo(() => buildHints(screen, busy, currentSession), [
+		screen,
+		busy,
+		currentSession
+	]);
+	const contextUsage = useMemo(() => {
+		if (screen !== "chat" || !picked) return null;
+		const max = modelsFor(picked.provider.key).find((m) => m.id === picked.model)?.contextWindow ?? getContextWindow(picked.provider.key, picked.model);
+		return max ? {
+			used: lastInputTokens,
+			max
+		} : null;
+	}, [
+		screen,
+		picked,
+		lastInputTokens,
+		modelsFor
+	]);
+	useEffect(() => () => {
+		teardown();
+	}, [teardown]);
+	return /* @__PURE__ */ jsxs("box", {
+		style: {
+			flexDirection: "column",
+			flexGrow: 1
+		},
+		children: [/* @__PURE__ */ jsxs("box", {
+			style: {
+				flexDirection: "column",
+				flexGrow: 1,
+				paddingLeft: 1,
+				paddingRight: 1
+			},
+			children: [
+				screen === "auth" && /* @__PURE__ */ jsx(AuthScreen, { onPick: onPickProvider }),
+				screen === "sessions" && /* @__PURE__ */ jsx(SessionsScreen, {
+					sessions,
+					currentId: currentSession?.id ?? null,
+					onPick: onSwitchSession,
+					onCreate: onCreateSession
+				}),
+				screen === "chat" && /* @__PURE__ */ jsx(ChatScreen, {
+					events,
+					busy,
+					settings,
+					onSubmit: onSubmitPrompt,
+					session: currentSession
+				})
+			]
+		}), /* @__PURE__ */ jsx(Footer, {
+			hints,
+			picked,
+			context: contextUsage
+		})]
+	});
+}
+function buildHints(screen, busy, currentSession) {
+	if (busy) return [{
+		key: "esc",
+		label: "abort"
+	}];
+	if (screen === "auth") return [
+		{
+			key: "↑↓",
+			label: "navigate"
+		},
+		{
+			key: "↵",
+			label: "select"
+		},
+		{
+			key: "esc",
+			label: "exit"
+		}
+	];
+	if (screen === "sessions") return [
+		{
+			key: "↑↓",
+			label: "navigate"
+		},
+		{
+			key: "↵",
+			label: "open"
+		},
+		{
+			key: "ctrl+,",
+			label: "settings"
+		},
+		{
+			key: "esc",
+			label: currentSession ? "back" : "exit"
+		}
+	];
+	return [
+		{
+			key: "↵",
+			label: "send"
+		},
+		{
+			key: "ctrl+m",
+			label: "model"
+		},
+		{
+			key: "ctrl+,",
+			label: "settings"
+		},
+		{
+			key: "esc",
+			label: "sessions"
+		}
+	];
+}
+//#endregion
+//#region src/tui/index.tsx
+/**
+* Tracks whether `runTui` has been invoked in this process. `createCliRenderer`
+* installs signal handlers + hijacks stdin; calling it a second time produces
+* undefined behavior. We bail loudly instead.
+*/
+let runTuiInvoked = false;
+/**
+* Boot a full chat TUI with sensible defaults. **Does not return** under
+* normal use — it terminates the host process via `process.exit(0)` once
+* the user dismisses the renderer (Ctrl+C / Esc on the auth screen / a
+* non-zero exit code is mapped via the `catch` path below).
+*
+* **One-shot:** this function may only be invoked once per process. The
+* underlying OpenTUI renderer wires up global terminal state on init.
+*
+* **Why it exits the process:** after the renderer's `destroy()` restores
+* the terminal, React's reconciler and OpenTUI's internal listeners can
+* keep the Node/Bun event loop open indefinitely — the script appears to
+* hang in `bun run`, and under `bun --watch run` the watcher waits forever
+* for the child to exit. Forcing a clean exit here is the contract that
+* makes `runTui` a true one-shot launcher.
+*
+* Hosts that need post-renderer cleanup should mount `<App config={...} />`
+* against their own `createCliRenderer()` instead of calling `runTui()`.
+*
+* Env-var overrides (handy when launching from CI or restricted shells):
+*   - `ZIDANE_STORAGE_DIR` — sets `storageDir`
+*   - `ZIDANE_PREFIX` — sets `prefix`
+*
+* Hosts building on top of `zidane/tui` typically want their own env vars
+* (e.g. `MYAPP_STORAGE_DIR`); read them in your launch script and forward
+* to `runTui({ storageDir, prefix })`.
+*
+* ```ts
+* import { runTui } from 'zidane/tui'
+* import { createRemoteStore } from 'zidane/session'  // for the `store` option
+*
+* await runTui()                                       // ~/.zidane/sessions.db + state.json
+* await runTui({ prefix: '.myapp' })                   // ~/.myapp/...
+* await runTui({ storageDir: '/data', prefix: 'myapp' })
+* await runTui({ providers: { custom: () => myProvider() } })
+* await runTui({ store: createRemoteStore({ url: '…' }) })
+* await runTui({ models: { anthropic: [{ id: 'claude-foo', contextWindow: 200_000 }] } })
+* ```
+*/
+async function runTui(options = {}) {
+	if (runTuiInvoked) throw new Error("runTui() can only be invoked once per process. Compose `<App config={resolveConfig(...)} />` against your own renderer if you need to run multiple TUIs in the same lifetime.");
+	runTuiInvoked = true;
+	await init();
+	const config = resolveConfig(options);
+	let done = () => {};
+	const exited = new Promise((resolve) => {
+		done = resolve;
+	});
+	createRoot(await createCliRenderer({
+		exitOnCtrlC: true,
+		onDestroy: () => done()
+	})).render(/* @__PURE__ */ jsx(App, { config }));
+	await exited;
+	process.exit(0);
+}
+//#endregion
+export { App, AuthScreen, COLOR, ChatScreen, ConfigProvider, DEFAULT_SETTINGS, FACTORIES, Footer, MD_STYLE, Modal, ModalRoot, ModelPickerModal, PI_PROVIDER_ID, SELECT_THEME, SessionsScreen, SettingsModal, SettingsProvider, Spinner, Transcript, ageString, createStateStore, createTuiStore, detectAuth, envKeyFor, eventsFromTurns, finalizeStreamingMarkdown, finalizeStreamingMarkdownForOwner, fmtTokens, getContextWindow, lastContextSizeFromTurns, listSessionMeta, loadState, marginTopFor, onInputSubmit, resolveConfig, runTui, saveState, shortId, titleFromTurns, toolCallPreview, toolResultText, turnContextSize, useConfig, useModal, useModalAwareFocus, useSettings, useStreamBuffer };
+
+//# sourceMappingURL=tui.js.map