zidane 4.1.6 → 4.1.7

package/dist/theme-context-MungM3SY.js

@@ -0,0 +1,1713 @@
+import { n as toolResultToText } from "./types-Bx_F8jet.js";
+import { n as formatTokenUsage } from "./stats-BT9l57RS.js";
+import { r as basic_default } from "./presets-BzkJDW1K.js";
+import { i as anthropic, n as openai, r as cerebras, t as openrouter } from "./providers-CCDvIXGJ.js";
+import { createSqliteStore } from "./session/sqlite.js";
+import { spawn } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { anthropicOAuthProvider, openaiCodexOAuthProvider } from "@mariozechner/pi-ai/oauth";
+import { getModel, getModels } from "@mariozechner/pi-ai";
+import { createContext, useCallback, useContext, useMemo, useRef, useState } from "react";
+import { jsx } from "@opentui/react/jsx-runtime";
+//#region src/chat/providers.ts
+/** Convenience accessor — returns `credentialFileKey ?? key`. */
+function credKeyOf(desc) {
+	return desc.credentialFileKey ?? desc.key;
+}
+/** Convenience accessor — returns `piProviderId ?? key`. */
+function piIdOf(desc) {
+	return desc.piProviderId ?? desc.key;
+}
+const anthropicDescriptor = {
+	key: "anthropic",
+	label: "Anthropic",
+	factory: anthropic,
+	defaultModel: "claude-opus-4-7",
+	envKey: "ANTHROPIC_API_KEY",
+	apiKeyPlaceholder: "sk-ant-…",
+	oauthProvider: anthropicOAuthProvider,
+	oauthHint: "Claude Pro/Max subscription"
+};
+const openaiDescriptor = {
+	key: "openai",
+	label: "OpenAI Codex",
+	factory: openai,
+	defaultModel: "gpt-5.4",
+	envKey: "OPENAI_CODEX_API_KEY",
+	credentialFileKey: "openai-codex",
+	piProviderId: "openai-codex",
+	apiKeyPlaceholder: "sk-… or eyJ… (Codex)",
+	oauthProvider: openaiCodexOAuthProvider
+};
+const openrouterDescriptor = {
+	key: "openrouter",
+	label: "OpenRouter",
+	factory: openrouter,
+	defaultModel: "anthropic/claude-sonnet-4-6",
+	envKey: "OPENROUTER_API_KEY",
+	apiKeyPlaceholder: "sk-or-…"
+};
+const cerebrasDescriptor = {
+	key: "cerebras",
+	label: "Cerebras",
+	factory: cerebras,
+	defaultModel: "zai-glm-4.7",
+	envKey: "CEREBRAS_API_KEY",
+	apiKeyPlaceholder: "csk-…"
+};
+/**
+* Default provider registry. Passed verbatim when `runTui` is invoked without
+* an explicit `providers` option. Hosts that want to override per-provider
+* metadata can spread this and replace specific entries:
+*
+* ```ts
+* runTui({ providers: { ...BUILTIN_PROVIDERS, anthropic: myOwnAnthropicDescriptor } })
+* ```
+*/
+const BUILTIN_PROVIDERS = {
+	anthropic: anthropicDescriptor,
+	openai: openaiDescriptor,
+	openrouter: openrouterDescriptor,
+	cerebras: cerebrasDescriptor
+};
+/**
+* Resolve the model list for a given provider. Honors `descriptor.models`
+* when set; otherwise queries pi-ai via `descriptor.piProviderId`. Returns
+* `[]` for descriptors with no known mapping (custom providers without a
+* model list) — callers should hide the model picker in that case.
+*/
+function modelsForDescriptor(descriptor) {
+	if (descriptor.models) return descriptor.models;
+	try {
+		return getModels(piIdOf(descriptor));
+	} catch {
+		return [];
+	}
+}
+/**
+* Look up the model's max context window via the descriptor's model source.
+* Returns `null` when the model isn't known (custom slugs, providers without
+* a registry); callers should hide the context indicator in that case.
+*/
+function getContextWindow(descriptor, modelId) {
+	if (descriptor.models) return descriptor.models.find((m) => m.id === modelId)?.contextWindow ?? null;
+	try {
+		return getModel(piIdOf(descriptor), modelId)?.contextWindow ?? null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/chat/credentials.ts
+/** POSIX mode for the credentials file. Ignored on Windows. */
+const FILE_MODE = 384;
+/**
+* Resolve the credentials file path given the resolved TUI data directory
+* (typically `~/.zidane`, i.e. `config.paths.dir`).
+*
+* Matches the convention used elsewhere in the TUI (sessions.db, state.json)
+* so a single `ZIDANE_STORAGE_DIR` override moves the entire data root.
+*/
+function credentialsPath(dataDir) {
+	return resolve(dataDir, "credentials.json");
+}
+/**
+* Read credentials from disk.
+*
+* Returns `{}` when the file is missing or corrupt (last-ditch tolerance —
+* a hand-edit gone wrong shouldn't lock the user out of re-authing). On first
+* call with no file present, attempts a migration from `cwd/.credentials.json`
+* (the legacy location used by `bun run auth`).
+*/
+function readCredentials(dataDir) {
+	const path = credentialsPath(dataDir);
+	if (!existsSync(path)) {
+		const migrated = migrateLegacyFile(path);
+		if (migrated) return migrated;
+		return {};
+	}
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		return parsed;
+	} catch {
+		return {};
+	}
+}
+/** Read a single provider's credential (translating via the descriptor). */
+function readProviderCredential(dataDir, descriptor) {
+	return readCredentials(dataDir)[credKeyOf(descriptor)];
+}
+/**
+* Write credentials atomically (write-then-rename) with mode 0o600.
+*
+* Atomic on the same filesystem — readers either see the previous file or the
+* new one, never a half-written intermediate. Creates the parent dir if needed
+* (first launch on a fresh machine: `~/.zidane/` may not exist yet).
+*/
+function writeCredentials(dataDir, creds) {
+	const path = credentialsPath(dataDir);
+	mkdirSync(dirname(path), { recursive: true });
+	const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(creds, null, 2)}\n`, { mode: FILE_MODE });
+	renameSync(tmp, path);
+}
+function setProviderCredential(dataDir, descriptor, cred) {
+	const all = readCredentials(dataDir);
+	all[credKeyOf(descriptor)] = cred;
+	writeCredentials(dataDir, all);
+}
+function removeProviderCredential(dataDir, descriptor) {
+	const all = readCredentials(dataDir);
+	const fileKey = credKeyOf(descriptor);
+	if (!(fileKey in all)) return;
+	delete all[fileKey];
+	writeCredentials(dataDir, all);
+}
+/**
+* Inject API-key credentials into `process.env` so the harness providers pick
+* them up via their existing env-var resolution. Called once at TUI launch
+* after the credentials file has been resolved. OAuth credentials are NOT
+* injected — those reach providers via `ZIDANE_CREDENTIALS_PATH` + the file
+* reader in `src/providers/oauth.ts`.
+*
+* Does not overwrite env vars that are already set — explicit user-provided
+* env values win over stored API keys.
+*
+* Descriptors without an `envKey` (OAuth-only providers, custom providers
+* that bypass env-var resolution) are skipped silently.
+*/
+function applyApiKeyEnv(dataDir, registry) {
+	const creds = readCredentials(dataDir);
+	for (const descriptor of Object.values(registry)) {
+		if (!descriptor.envKey || process.env[descriptor.envKey]) continue;
+		const cred = creds[credKeyOf(descriptor)];
+		if (cred?.kind === "apikey" && cred.value) process.env[descriptor.envKey] = cred.value;
+	}
+}
+/**
+* `bun run auth` (pre-TUI) wrote `cwd/.credentials.json` with an entry per
+* provider mapping directly to an OAuthCredentials payload, e.g.:
+*
+*   {
+*     "anthropic":    { "access": "...", "refresh": "...", "expires": 123 },
+*     "openai-codex": { "access": "...", "refresh": "...", "expires": 123, "accountId": "..." }
+*   }
+*
+* We don't delete the legacy file — it might still be used by a host that
+* imports the harness directly. We just copy its contents into the new
+* location under the kind-tagged shape so the TUI picks them up.
+*
+* Migration is provider-agnostic: any top-level entry with an `access` field
+* is preserved verbatim (extras included), under the same key. The TUI's
+* detection then looks them up via the matching descriptor's `credentialFileKey`.
+*
+* Returns the migrated credentials when the migration ran, or `null` when
+* there's no legacy file to migrate.
+*/
+function migrateLegacyFile(targetPath) {
+	const legacyPath = resolve(process.cwd(), ".credentials.json");
+	if (!existsSync(legacyPath)) return null;
+	let legacy;
+	try {
+		legacy = JSON.parse(readFileSync(legacyPath, "utf-8"));
+	} catch {
+		return null;
+	}
+	if (!legacy || typeof legacy !== "object" || Array.isArray(legacy)) return null;
+	const migrated = {};
+	for (const [fileKey, value] of Object.entries(legacy)) {
+		if (!isOAuthLegacy(value)) continue;
+		const { access, refresh, expires, ...extras } = value;
+		migrated[fileKey] = {
+			kind: "oauth",
+			access,
+			...typeof refresh === "string" ? { refresh } : {},
+			...typeof expires === "number" ? { expires } : {},
+			...extras
+		};
+	}
+	if (Object.keys(migrated).length === 0) return null;
+	mkdirSync(dirname(targetPath), { recursive: true });
+	const tmp = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(migrated, null, 2)}\n`, { mode: FILE_MODE });
+	renameSync(tmp, targetPath);
+	return migrated;
+}
+function isOAuthLegacy(value) {
+	return typeof value === "object" && value !== null && "access" in value && typeof value.access === "string";
+}
+//#endregion
+//#region src/chat/auth.ts
+/**
+* Detect available auth for every registered provider.
+*
+* Resolution order per provider (a method appears in `methods` for each
+* layer that has a credential — the agent itself resolves them in the same
+* order via its provider factories):
+*
+*   1. `kind: 'apikey'` from `credentials.json` (injected into env at TUI launch)
+*   2. explicit env var (descriptor's `envKey`)
+*   3. `kind: 'oauth'` from `credentials.json` (or legacy `cwd/.credentials.json`)
+*
+* Pure read — never refreshes or rewrites the credentials file.
+*/
+function detectAuth(dataDir, registry, env = process.env) {
+	const creds = readCredentials(dataDir);
+	return Object.values(registry).map((descriptor) => {
+		const methods = [];
+		const fileEntry = creds[credKeyOf(descriptor)];
+		if (fileEntry?.kind === "apikey" && fileEntry.value) methods.push({
+			source: "apikey",
+			detail: "credentials.json"
+		});
+		if (descriptor.envKey && env[descriptor.envKey]) methods.push({
+			source: "env",
+			detail: descriptor.envKey
+		});
+		if (fileEntry?.kind === "oauth" && fileEntry.access) {
+			const detail = typeof fileEntry.expires === "number" ? `oauth · expires ${new Date(fileEntry.expires).toLocaleString()}` : "oauth · credentials.json";
+			methods.push({
+				source: "oauth",
+				detail
+			});
+		}
+		return {
+			key: descriptor.key,
+			label: descriptor.label,
+			available: methods.length > 0,
+			methods
+		};
+	});
+}
+//#endregion
+//#region src/chat/store.ts
+function ensureDir$1(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$1(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$1(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 — including subagent ancestry when `runs` is supplied.
+*
+* Subagent reconstruction:
+*   - Every turn carries a `runId`. We look that up in `runs` to get the
+*     run's `depth` and tag the resulting events with `{ depth, childId }`
+*     — the same shape the live `child:*` bubble hooks produce.
+*   - We synthesize `spawn-start` / `spawn-end` markers at each child-run
+*     boundary so the transcript reads the same as a live run did
+*     (`🌱 [run-id] task` … child events … `🌳 [run-id] done · tokens`).
+*   - For child runs (`depth > 0`), the user-role "task" text is suppressed
+*     because `spawn-start` already shows it.
+*
+* Without `runs` (legacy callers / tests), the function falls back to the
+* old behavior: depth-0 events with no subagent grouping.
+*/
+function eventsFromTurns(turns, runs = []) {
+	const runById = /* @__PURE__ */ new Map();
+	for (const run of runs) runById.set(run.id, run);
+	const childLabelByRunId = /* @__PURE__ */ new Map();
+	runs.filter((r) => (r.depth ?? 0) > 0).slice().sort((a, b) => a.startedAt - b.startedAt).forEach((r, i) => childLabelByRunId.set(r.id, `child-${i + 1}`));
+	const labelFor = (runId) => childLabelByRunId.get(runId) ?? runId;
+	const toolByCallId = /* @__PURE__ */ new Map();
+	for (const turn of turns) {
+		if (turn.role !== "assistant") continue;
+		for (const block of turn.content) if (block.type === "tool_call") toolByCallId.set(block.id, block.name);
+	}
+	const events = [];
+	let lastRunId;
+	let lastDepth = 0;
+	const closeRun = (runId, depth) => {
+		if (!runId || depth <= 0) return;
+		const run = runById.get(runId);
+		if (!run) return;
+		const tag = run.status === "aborted" || run.status === "error" ? run.status : "done";
+		const usage = formatTokenUsage({
+			totalIn: run.tokensIn ?? run.totalUsage?.input ?? 0,
+			totalOut: run.tokensOut ?? run.totalUsage?.output ?? 0,
+			totalCacheRead: run.totalUsage?.cacheRead ?? 0,
+			totalCacheCreation: run.totalUsage?.cacheCreation ?? 0
+		});
+		events.push({
+			kind: "spawn-end",
+			text: `${tag} ${usage}`,
+			childId: labelFor(runId),
+			depth
+		});
+	};
+	const openRun = (runId, depth) => {
+		if (depth <= 0) return;
+		const run = runById.get(runId);
+		if (!run) return;
+		const taskPreview = run.prompt.length > 80 ? `${run.prompt.slice(0, 80)}…` : run.prompt;
+		events.push({
+			kind: "spawn-start",
+			text: taskPreview,
+			childId: labelFor(runId),
+			depth
+		});
+	};
+	for (let i = 0; i < turns.length; i++) {
+		const turn = turns[i];
+		const depth = (turn.runId ? runById.get(turn.runId) : void 0)?.depth ?? 0;
+		const tag = depth > 0 && turn.runId ? {
+			childId: labelFor(turn.runId),
+			depth
+		} : void 0;
+		if (turn.runId !== lastRunId) {
+			closeRun(lastRunId, lastDepth);
+			if (depth === 0 && lastDepth === 0 && i > 0) events.push({
+				kind: "separator",
+				text: ""
+			});
+			if (turn.runId) openRun(turn.runId, depth);
+			lastRunId = turn.runId;
+			lastDepth = depth;
+		} else if (i > 0 && depth === 0) events.push({
+			kind: "separator",
+			text: ""
+		});
+		if (turn.role === "user") {
+			for (const block of turn.content) if (block.type === "text" && block.text.trim()) {
+				if (depth === 0) events.push({
+					kind: "info",
+					text: `❯ ${block.text}`
+				});
+			} else if (block.type === "tool_result") {
+				const tool = toolByCallId.get(block.callId);
+				const raw = toolResultText(block.output);
+				const text = tool === "spawn" ? stripSpawnTokensLine(raw) : raw;
+				events.push({
+					kind: "tool-result",
+					text,
+					...tool ? { tool } : {},
+					...tag
+				});
+			}
+			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,
+				...tag
+			});
+			else if (block.type === "tool_call") events.push({
+				kind: "tool",
+				text: toolCallPreview(block.name, block.input),
+				tool: block.name,
+				...tag
+			});
+		}
+	}
+	closeRun(lastRunId, lastDepth);
+	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);
+}
+/**
+* Strip the `Tokens: …` line from a spawn tool-result. The spawn-end marker
+* displayed right above already shows the same stats; keeping the line in the
+* rendered tool-result body just produces a visible duplicate (and, on
+* reloaded pre-fix sessions, an *inconsistent* duplicate — the persisted line
+* uses the old `13 in / 4075 out` shape while the freshly synthesized
+* spawn-end uses the cache-aware `in 92615 (cache 92602) / 4075 out` shape).
+*
+* Display-only: the persisted tool_result content is untouched, so the LLM
+* still sees the full string in its context window. Anchored to start-of-line
+* and matches both `Tokens: 13 in / 4075 out` (legacy) and `Tokens: in 13 …`
+* (post-`formatTokenUsage`) shapes.
+*/
+function stripSpawnTokensLine(text) {
+	return text.replace(/^Tokens:[^\n]*\n?/m, "");
+}
+/** 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/chat/config.ts
+/** 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 = options.providers ?? BUILTIN_PROVIDERS;
+	const preset = options.preset ?? basic_default;
+	process.env.ZIDANE_CREDENTIALS_PATH = credentialsPath(dir);
+	applyApiKeyEnv(dir, providers);
+	const modelsFor = makeModelsResolver(providers);
+	const resumeProvider = resolveResumeProvider(initialState, providers, dir);
+	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(registry) {
+	return (key) => {
+		const descriptor = registry[key];
+		return descriptor ? modelsForDescriptor(descriptor) : [];
+	};
+}
+function resolveResumeProvider(state, providers, storageDir) {
+	if (!state.lastProvider) return null;
+	if (!providers[state.lastProvider]) return null;
+	return detectAuth(storageDir, providers).find((p) => p.key === state.lastProvider && p.available) ?? null;
+}
+function pickInitial(auth, providers, state) {
+	const descriptor = providers[auth.key];
+	if (!descriptor) return null;
+	const model = state.lastModelByProvider?.[auth.key] ?? descriptor.defaultModel ?? safeFactoryDefault(descriptor);
+	return model ? {
+		provider: auth,
+		model
+	} : null;
+}
+function safeFactoryDefault(descriptor) {
+	try {
+		return descriptor.factory().meta.defaultModel;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/chat/config-context.tsx
+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/chat/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/chat/oauth.ts
+function supportsOAuth(descriptor) {
+	return descriptor.oauthProvider !== void 0;
+}
+/**
+* Run the OAuth login flow for a provider.
+*
+* Returns the OAuth credentials on success; caller persists them via
+* `setProviderCredential(dataDir, descriptor, { kind: 'oauth', ...credentials })`.
+* Throws when the descriptor has no `oauthProvider` configured.
+*/
+async function runOAuthLogin(descriptor, options) {
+	if (!descriptor.oauthProvider) throw new Error(`OAuth not supported for ${descriptor.label} (${descriptor.key}) — use an API key instead.`);
+	const callbacks = {
+		onAuth: (info) => {
+			options.onUrl(info.url, info.instructions);
+			tryOpenBrowser(info.url);
+		},
+		onPrompt: async () => {
+			if (!options.onCodeRequest) throw new Error("OAuth flow requires manual code input but no handler is wired.");
+			return options.onCodeRequest();
+		},
+		onProgress: options.onProgress,
+		signal: options.signal
+	};
+	return descriptor.oauthProvider.login(callbacks);
+}
+/**
+* Best-effort cross-platform browser open. macOS uses `open`, Linux uses
+* `xdg-open`, Windows uses `start`. Failures are swallowed — the callback
+* server is already listening, and the URL is displayed in the TUI for
+* manual click.
+*
+* Uses `spawn` (not `exec`) so the URL is passed as an argv element rather
+* than interpolated into a shell command — no need to think about quoting
+* URLs that contain `&`, `?`, `"` or other shell metacharacters.
+*/
+function tryOpenBrowser(url) {
+	const [cmd, ...args] = (() => {
+		if (process.platform === "darwin") return ["open", url];
+		if (process.platform === "win32") return [
+			"cmd",
+			"/c",
+			"start",
+			"",
+			url
+		];
+		return ["xdg-open", url];
+	})();
+	try {
+		const child = spawn(cmd, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+}
+//#endregion
+//#region src/chat/safe-mode.ts
+/**
+* Safe-mode storage + matching for the TUI.
+*
+* Lives at `<dataDir>/projects.json` (default `~/.zidane/projects.json`). Each
+* top-level key is an absolute project directory; the value carries that
+* project's persisted tool-call `safelist`.
+*
+* ```json
+* {
+*   "/Users/me/proj-a": { "safelist": ["read_file", "shell:git:*"] }
+* }
+* ```
+*
+* Two granularities for safelist entries:
+*   - **bare tool name** — `"read_file"` matches every `read_file` call.
+*   - **tool + first-arg token + wildcard** — `"shell:git:*"` matches `shell`
+*     calls whose primary string argument starts with the token `git`
+*     (followed by whitespace or end-of-string). Modelled on Claude Code's
+*     `Bash(git:*)` syntax.
+*
+* A short list of read-only tools is **implicitly safe** without being
+* persisted — see {@link IMPLICITLY_SAFE_TOOLS}.
+*/
+/** Resolve `projects.json`'s on-disk path given the TUI data directory. */
+function projectsFilePath(dataDir) {
+	return resolve(dataDir, "projects.json");
+}
+function readProjects(dataDir) {
+	const path = projectsFilePath(dataDir);
+	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 ensureDir(path) {
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+/** Atomic write — tmp + rename so a crash never leaves a half-file. */
+function writeProjects(dataDir, file) {
+	const path = projectsFilePath(dataDir);
+	ensureDir(path);
+	const tmp = `${path}.${process.pid}.tmp`;
+	writeFileSync(tmp, JSON.stringify(file, null, 2));
+	renameSync(tmp, path);
+}
+/**
+* Append `entry` to the safelist for `projectDir`, dedup-aware. Returns the
+* updated entry list (post-write) so callers can render it without re-reading.
+*/
+function addToSafelist(dataDir, projectDir, entry) {
+	const file = readProjects(dataDir);
+	const existing = file[projectDir]?.safelist ?? [];
+	if (existing.includes(entry)) return existing;
+	const next = [...existing, entry];
+	file[projectDir] = {
+		...file[projectDir],
+		safelist: next
+	};
+	writeProjects(dataDir, file);
+	return next;
+}
+/** Read the safelist for one project. Returns `[]` for unknown projects. */
+function getSafelist(dataDir, projectDir) {
+	return readProjects(dataDir)[projectDir]?.safelist ?? [];
+}
+/**
+* Tools that always pass without prompting — pure file/dir reads with no
+* side effects. Users who want to gate them must disable safe-mode entirely
+* (or fork this list in their own embedding).
+*/
+const IMPLICITLY_SAFE_TOOLS = [
+	"read_file",
+	"list_files",
+	"glob",
+	"grep"
+];
+/** Common input keys carrying the "primary argument" we scope safelists on. */
+const PRIMARY_ARG_KEYS = [
+	"command",
+	"path",
+	"pattern",
+	"query"
+];
+function primaryArgValue(input) {
+	for (const key of PRIMARY_ARG_KEYS) {
+		const v = input[key];
+		if (typeof v === "string" && v.length > 0) return v;
+	}
+	return "";
+}
+/** Extract the first whitespace-delimited token of the primary arg. */
+function primaryArgToken(input) {
+	return primaryArgValue(input).split(/\s+/)[0] ?? "";
+}
+/**
+* Shell metacharacters that turn a single command into a compound: pipes,
+* sequencing, redirects, substitutions, line breaks, subshells. A `shell:git:*`
+* entry is meant to greenlight "any git invocation" — without this guard,
+* `git status && rm -rf /` would tokenize to `git` and pass the safelist
+* unchallenged. Reject any command that's not a single program call.
+*
+* The regex is intentionally generous: false positives (e.g. `echo "hi & bye"`)
+* just prompt the user again, which is the safe failure mode.
+*/
+const SHELL_COMPOUND_RE = /[;&|<>`$\n\r()]/;
+function isCompoundShellCommand(command) {
+	return SHELL_COMPOUND_RE.test(command);
+}
+/**
+* Test whether a `{ tool, input }` pair is covered by one safelist entry.
+*
+* Supported entry shapes:
+*   - `"<tool>"` — broad match on tool name. For `shell` this still requires
+*     a single-program command (compound forms always prompt).
+*   - `"<tool>:<token>:*"` — match when the primary arg's first token equals
+*     `<token>`. For `shell`, also requires the command to be free of
+*     metacharacters (`;`, `&&`, `||`, `|`, `$(`, backticks, `>`, `<`,
+*     newlines, subshells) — otherwise a `shell:git:*` entry would silently
+*     greenlight `git status && rm -rf /`.
+*
+* Entries that don't fit either shape are ignored (forward-compat for future
+* pattern syntax — readers shouldn't choke on entries written by a newer
+* version of the TUI).
+*/
+function matchesSafelistEntry(entry, tool, input) {
+	if (tool === "shell") {
+		if (isCompoundShellCommand(typeof input.command === "string" ? input.command : "")) return false;
+	}
+	if (entry === tool) return true;
+	const sep = entry.indexOf(":");
+	if (sep <= 0) return false;
+	if (entry.slice(0, sep) !== tool) return false;
+	const scope = entry.slice(sep + 1);
+	if (scope.endsWith(":*")) return primaryArgToken(input) === scope.slice(0, -2);
+	return false;
+}
+/** True when a call matches ANY entry in the project's safelist (or is implicitly safe). */
+function isOnSafelist(entries, tool, input) {
+	if (IMPLICITLY_SAFE_TOOLS.includes(tool)) return true;
+	return entries.some((e) => matchesSafelistEntry(e, tool, input));
+}
+/**
+* Suggest the safelist entry to write when the user picks "accept and
+* remember" for a `{ tool, input }`. Heuristic:
+*
+*   - `shell` → scope by first command token (`shell:git:*`).
+*   - anything else → bare tool name (broad).
+*
+* Returning a string ensures the UI always has a concrete entry to display
+* as the button label.
+*/
+function suggestSafelistEntry(tool, input) {
+	if (tool === "shell") {
+		const token = primaryArgToken(input);
+		if (token) return `${tool}:${token}:*`;
+	}
+	return tool;
+}
+//#endregion
+//#region src/chat/safe-mode-context.tsx
+const SafeModeQueueContext = createContext([]);
+const SafeModeActionsContext = createContext(null);
+let approvalIdCounter = 0;
+function nextApprovalId() {
+	approvalIdCounter += 1;
+	return `approval-${approvalIdCounter}`;
+}
+/**
+* Owns the queue + actions. Splits the value across two contexts so a queue
+* change doesn't invalidate every callback memo that closes over the actions.
+*/
+function SafeModeProvider({ children }) {
+	const [queue, setQueue] = useState([]);
+	const requestApproval = useCallback((tool, input) => new Promise((resolve) => {
+		setQueue((prev) => [...prev, {
+			id: nextApprovalId(),
+			tool,
+			input,
+			resolve
+		}]);
+	}), []);
+	const resolveHead = useCallback((decision) => {
+		setQueue((prev) => {
+			const [head, ...rest] = prev;
+			if (head) head.resolve(decision);
+			return rest;
+		});
+	}, []);
+	const denyAll = useCallback(() => {
+		setQueue((prev) => {
+			for (const p of prev) p.resolve("deny");
+			return [];
+		});
+	}, []);
+	const actionsRef = useRef(null);
+	if (!actionsRef.current) actionsRef.current = {
+		requestApproval,
+		resolveHead,
+		denyAll
+	};
+	return /* @__PURE__ */ jsx(SafeModeActionsContext.Provider, {
+		value: actionsRef.current,
+		children: /* @__PURE__ */ jsx(SafeModeQueueContext.Provider, {
+			value: queue,
+			children
+		})
+	});
+}
+function useSafeModeQueue() {
+	return useContext(SafeModeQueueContext);
+}
+function useSafeModeActions() {
+	const ctx = useContext(SafeModeActionsContext);
+	if (!ctx) throw new Error("useSafeModeActions must be used inside <SafeModeProvider>");
+	return ctx;
+}
+//#endregion
+//#region src/chat/themes/catppuccin.ts
+const LATTE = {
+	rosewater: "#dc8a78",
+	flamingo: "#dd7878",
+	pink: "#ea76cb",
+	mauve: "#8839ef",
+	red: "#d20f39",
+	maroon: "#e64553",
+	peach: "#fe640b",
+	yellow: "#df8e1d",
+	green: "#40a02b",
+	teal: "#179299",
+	sky: "#04a5e5",
+	sapphire: "#209fb5",
+	blue: "#1e66f5",
+	lavender: "#7287fd",
+	text: "#4c4f69",
+	subtext1: "#5c5f77",
+	subtext0: "#6c6f85",
+	overlay2: "#7c7f93",
+	overlay1: "#8c8fa1",
+	overlay0: "#9ca0b0",
+	surface2: "#acb0be",
+	surface1: "#bcc0cc",
+	surface0: "#ccd0da",
+	base: "#eff1f5",
+	mantle: "#e6e9ef",
+	crust: "#dce0e8"
+};
+const FRAPPE = {
+	rosewater: "#f2d5cf",
+	flamingo: "#eebebe",
+	pink: "#f4b8e4",
+	mauve: "#ca9ee6",
+	red: "#e78284",
+	maroon: "#ea999c",
+	peach: "#ef9f76",
+	yellow: "#e5c890",
+	green: "#a6d189",
+	teal: "#81c8be",
+	sky: "#99d1db",
+	sapphire: "#85c1dc",
+	blue: "#8caaee",
+	lavender: "#babbf1",
+	text: "#c6d0f5",
+	subtext1: "#b5bfe2",
+	subtext0: "#a5adce",
+	overlay2: "#949cbb",
+	overlay1: "#838ba7",
+	overlay0: "#737994",
+	surface2: "#626880",
+	surface1: "#51576d",
+	surface0: "#414559",
+	base: "#303446",
+	mantle: "#292c3c",
+	crust: "#232634"
+};
+const MACCHIATO = {
+	rosewater: "#f4dbd6",
+	flamingo: "#f0c6c6",
+	pink: "#f5bde6",
+	mauve: "#c6a0f6",
+	red: "#ed8796",
+	maroon: "#ee99a0",
+	peach: "#f5a97f",
+	yellow: "#eed49f",
+	green: "#a6da95",
+	teal: "#8bd5ca",
+	sky: "#91d7e3",
+	sapphire: "#7dc4e4",
+	blue: "#8aadf4",
+	lavender: "#b7bdf8",
+	text: "#cad3f5",
+	subtext1: "#b8c0e0",
+	subtext0: "#a5adcb",
+	overlay2: "#939ab7",
+	overlay1: "#8087a2",
+	overlay0: "#6e738d",
+	surface2: "#5b6078",
+	surface1: "#494d64",
+	surface0: "#363a4f",
+	base: "#24273a",
+	mantle: "#1e2030",
+	crust: "#181926"
+};
+const MOCHA = {
+	rosewater: "#f5e0dc",
+	flamingo: "#f2cdcd",
+	pink: "#f5c2e7",
+	mauve: "#cba6f7",
+	red: "#f38ba8",
+	maroon: "#eba0ac",
+	peach: "#fab387",
+	yellow: "#f9e2af",
+	green: "#a6e3a1",
+	teal: "#94e2d5",
+	sky: "#89dceb",
+	sapphire: "#74c7ec",
+	blue: "#89b4fa",
+	lavender: "#b4befe",
+	text: "#cdd6f4",
+	subtext1: "#bac2de",
+	subtext0: "#a6adc8",
+	overlay2: "#9399b2",
+	overlay1: "#7f849c",
+	overlay0: "#6c7086",
+	surface2: "#585b70",
+	surface1: "#45475a",
+	surface0: "#313244",
+	base: "#1e1e2e",
+	mantle: "#181825",
+	crust: "#11111b"
+};
+/**
+* Compose a `Theme` from a Catppuccin palette flavor.
+*
+* Role-color picks follow the upstream Catppuccin styleguide:
+*   - `mauve` is the canonical accent — used here as the brand color.
+*   - `green` / `red` / `yellow` keep their universal semantic meaning.
+*   - `blue` carries function / model identity (matches the VSCode plugin's
+*     `support.function` mapping).
+*   - `subtext1` / `overlay0` form the dim/mute pair (one step apart so the
+*     two tiers stay visually distinct on every flavor).
+*   - `surface1` / `overlay0` give the resting/active border pair.
+*
+* Syntax token mappings line up with the official Catppuccin token rules
+* (keyword = mauve, string = green, function = blue, type = yellow, …) so
+* code fences match what users see in their editor.
+*/
+function catppuccinTheme(id, label, p) {
+	return {
+		id,
+		label,
+		colors: {
+			brand: p.mauve,
+			accent: p.green,
+			model: p.blue,
+			warn: p.yellow,
+			error: p.red,
+			dim: p.subtext1,
+			mute: p.overlay0,
+			border: p.surface1,
+			borderActive: p.overlay0
+		},
+		select: {
+			backgroundColor: "transparent",
+			focusedBackgroundColor: "transparent",
+			selectedBackgroundColor: "transparent",
+			selectedTextColor: p.mauve,
+			textColor: p.subtext1,
+			descriptionColor: p.overlay0,
+			selectedDescriptionColor: p.subtext0
+		},
+		surfaces: { modal: p.mantle },
+		syntax: {
+			"default": { fg: p.text },
+			"markup.heading": {
+				fg: p.mauve,
+				bold: true
+			},
+			"markup.heading.1": {
+				fg: p.mauve,
+				bold: true
+			},
+			"markup.heading.2": {
+				fg: p.lavender,
+				bold: true
+			},
+			"markup.heading.3": {
+				fg: p.blue,
+				bold: true
+			},
+			"markup.bold": {
+				fg: p.text,
+				bold: true
+			},
+			"markup.strong": {
+				fg: p.text,
+				bold: true
+			},
+			"markup.italic": {
+				fg: p.text,
+				italic: true
+			},
+			"markup.link": {
+				fg: p.sky,
+				underline: true
+			},
+			"markup.link.url": {
+				fg: p.sky,
+				underline: true
+			},
+			"markup.list": { fg: p.peach },
+			"markup.raw": { fg: p.green },
+			"markup.raw.block": { fg: p.green },
+			"markup.quote": {
+				fg: p.overlay2,
+				italic: true
+			},
+			"keyword": {
+				fg: p.mauve,
+				bold: true
+			},
+			"keyword.import": {
+				fg: p.pink,
+				bold: true
+			},
+			"keyword.operator": { fg: p.sky },
+			"string": { fg: p.green },
+			"string.escape": {
+				fg: p.pink,
+				bold: true
+			},
+			"character": { fg: p.teal },
+			"comment": {
+				fg: p.overlay1,
+				italic: true
+			},
+			"number": { fg: p.peach },
+			"boolean": { fg: p.peach },
+			"constant": { fg: p.peach },
+			"constant.builtin": { fg: p.peach },
+			"function": { fg: p.blue },
+			"function.call": { fg: p.blue },
+			"function.method": { fg: p.blue },
+			"function.method.call": { fg: p.blue },
+			"function.builtin": { fg: p.blue },
+			"function.macro": { fg: p.teal },
+			"type": { fg: p.yellow },
+			"type.builtin": { fg: p.yellow },
+			"constructor": { fg: p.yellow },
+			"attribute": { fg: p.yellow },
+			"tag": { fg: p.lavender },
+			"variable": { fg: p.text },
+			"variable.builtin": { fg: p.red },
+			"variable.parameter": {
+				fg: p.maroon,
+				italic: true
+			},
+			"variable.member": { fg: p.text },
+			"property": { fg: p.lavender },
+			"operator": { fg: p.sky },
+			"punctuation": { fg: p.overlay2 },
+			"punctuation.bracket": { fg: p.overlay2 },
+			"punctuation.delimiter": { fg: p.overlay2 },
+			"label": { fg: p.sapphire }
+		}
+	};
+}
+const CATPPUCCIN_MOCHA = catppuccinTheme("catppuccin-mocha", "Catppuccin Mocha", MOCHA);
+const CATPPUCCIN_MACCHIATO = catppuccinTheme("catppuccin-macchiato", "Catppuccin Macchiato", MACCHIATO);
+const CATPPUCCIN_FRAPPE = catppuccinTheme("catppuccin-frappe", "Catppuccin Frappé", FRAPPE);
+const CATPPUCCIN_LATTE = catppuccinTheme("catppuccin-latte", "Catppuccin Latte", LATTE);
+//#endregion
+//#region src/chat/themes/vaporwave.ts
+const PALETTE = {
+	pink: "#E95378",
+	pinkBright: "#FF71CE",
+	cyan: "#01CDFE",
+	cyanBright: "#59E1E3",
+	blue: "#94D0FF",
+	green: "#29D398",
+	greenBright: "#09F7A0",
+	yellow: "#FFFB96",
+	red: "#F43E5C",
+	text: "#D5D8DA",
+	textBright: "#EEFFFF",
+	comment: "#BBBBBB",
+	muted: "#6C6F93",
+	surface: "#2E303E",
+	panel: "#232530"
+};
+const VAPORWAVE_THEME = {
+	id: "vaporwave",
+	label: "Vaporwave",
+	colors: {
+		brand: PALETTE.pink,
+		accent: PALETTE.greenBright,
+		model: PALETTE.blue,
+		warn: PALETTE.yellow,
+		error: PALETTE.red,
+		dim: PALETTE.text,
+		mute: PALETTE.muted,
+		border: PALETTE.surface,
+		borderActive: PALETTE.muted
+	},
+	select: {
+		backgroundColor: "transparent",
+		focusedBackgroundColor: "transparent",
+		selectedBackgroundColor: "transparent",
+		selectedTextColor: PALETTE.pink,
+		textColor: PALETTE.text,
+		descriptionColor: PALETTE.muted,
+		selectedDescriptionColor: PALETTE.text
+	},
+	surfaces: { modal: PALETTE.panel },
+	syntax: {
+		"default": { fg: PALETTE.text },
+		"markup.heading": {
+			fg: PALETTE.pink,
+			bold: true
+		},
+		"markup.heading.1": {
+			fg: PALETTE.pink,
+			bold: true
+		},
+		"markup.heading.2": {
+			fg: PALETTE.pinkBright,
+			bold: true
+		},
+		"markup.heading.3": {
+			fg: PALETTE.blue,
+			bold: true
+		},
+		"markup.bold": {
+			fg: PALETTE.textBright,
+			bold: true
+		},
+		"markup.strong": {
+			fg: PALETTE.textBright,
+			bold: true
+		},
+		"markup.italic": {
+			fg: PALETTE.greenBright,
+			italic: true
+		},
+		"markup.link": {
+			fg: PALETTE.yellow,
+			underline: true
+		},
+		"markup.link.url": {
+			fg: PALETTE.yellow,
+			underline: true
+		},
+		"markup.list": { fg: PALETTE.textBright },
+		"markup.raw": { fg: PALETTE.yellow },
+		"markup.raw.block": { fg: PALETTE.yellow },
+		"markup.quote": {
+			fg: PALETTE.yellow,
+			italic: true
+		},
+		"keyword": {
+			fg: PALETTE.pinkBright,
+			bold: true
+		},
+		"keyword.import": {
+			fg: PALETTE.pinkBright,
+			bold: true
+		},
+		"keyword.operator": { fg: PALETTE.comment },
+		"string": { fg: PALETTE.yellow },
+		"string.escape": {
+			fg: PALETTE.greenBright,
+			bold: true
+		},
+		"character": { fg: PALETTE.yellow },
+		"comment": {
+			fg: PALETTE.comment,
+			italic: true
+		},
+		"number": { fg: PALETTE.textBright },
+		"boolean": { fg: PALETTE.textBright },
+		"constant": { fg: PALETTE.textBright },
+		"constant.builtin": { fg: PALETTE.textBright },
+		"function": { fg: PALETTE.greenBright },
+		"function.call": { fg: PALETTE.greenBright },
+		"function.method": { fg: PALETTE.greenBright },
+		"function.method.call": { fg: PALETTE.greenBright },
+		"function.builtin": { fg: PALETTE.greenBright },
+		"function.macro": { fg: PALETTE.greenBright },
+		"type": { fg: PALETTE.greenBright },
+		"type.builtin": { fg: PALETTE.greenBright },
+		"constructor": { fg: PALETTE.greenBright },
+		"attribute": { fg: PALETTE.yellow },
+		"tag": { fg: PALETTE.blue },
+		"variable": { fg: PALETTE.blue },
+		"variable.builtin": { fg: PALETTE.cyanBright },
+		"variable.parameter": { fg: PALETTE.text },
+		"variable.member": { fg: PALETTE.blue },
+		"property": { fg: PALETTE.blue },
+		"operator": { fg: PALETTE.comment },
+		"punctuation": { fg: PALETTE.comment },
+		"punctuation.bracket": { fg: PALETTE.textBright },
+		"punctuation.delimiter": { fg: PALETTE.comment },
+		"label": { fg: PALETTE.cyan }
+	}
+};
+//#endregion
+//#region src/chat/theme.ts
+/**
+* Renderer-agnostic theme system.
+*
+* A `Theme` bundles every variable that can change visually between
+* "themes" — colors, select-row styling, code/markdown syntax highlight
+* tokens, panel backgrounds. Plain JSON: no OpenTUI dependency, no React,
+* no functions. The TUI consumes the theme by reading from `useTheme()`
+* and converting hex strings into OpenTUI's `RGBA`/`SyntaxStyle`; a future
+* GUI consumes the same theme by converting into CSS variables or Tailwind
+* tokens.
+*
+* Components should always read theme values through `useTheme()` /
+* `useColors()` so a runtime theme switch (Settings → Theme) re-paints
+* the whole tree. Importing a raw theme object directly bypasses the
+* context and pins the component to a single look.
+*
+* Built-in flavors (Catppuccin, Vaporwave) live in `./themes/`. This file
+* just defines the shape + the default theme + the registry.
+*/
+const DEFAULT_COLORS = {
+	brand: "#FFCC00",
+	accent: "#00FF88",
+	model: "#88CCFF",
+	warn: "#FFAA66",
+	error: "#FF6666",
+	dim: "#888888",
+	mute: "#555555",
+	border: "#333333",
+	borderActive: "#555555"
+};
+const DEFAULT_THEME = {
+	id: "default",
+	label: "Default",
+	colors: DEFAULT_COLORS,
+	select: {
+		backgroundColor: "transparent",
+		focusedBackgroundColor: "transparent",
+		selectedBackgroundColor: "transparent",
+		selectedTextColor: DEFAULT_COLORS.brand,
+		textColor: DEFAULT_COLORS.dim,
+		descriptionColor: DEFAULT_COLORS.mute,
+		selectedDescriptionColor: DEFAULT_COLORS.dim
+	},
+	surfaces: { modal: "#101010" },
+	syntax: {
+		"default": { fg: "#E6EDF3" },
+		"markup.heading": {
+			fg: DEFAULT_COLORS.brand,
+			bold: true
+		},
+		"markup.heading.1": {
+			fg: DEFAULT_COLORS.brand,
+			bold: true
+		},
+		"markup.heading.2": {
+			fg: "#FFD84D",
+			bold: true
+		},
+		"markup.heading.3": {
+			fg: "#FFE680",
+			bold: true
+		},
+		"markup.bold": {
+			fg: "#FFFFFF",
+			bold: true
+		},
+		"markup.strong": {
+			fg: "#FFFFFF",
+			bold: true
+		},
+		"markup.italic": {
+			fg: "#E6EDF3",
+			italic: true
+		},
+		"markup.link": {
+			fg: DEFAULT_COLORS.model,
+			underline: true
+		},
+		"markup.link.url": {
+			fg: DEFAULT_COLORS.model,
+			underline: true
+		},
+		"markup.list": { fg: DEFAULT_COLORS.warn },
+		"markup.raw": { fg: "#A5D6FF" },
+		"markup.raw.block": { fg: "#A5D6FF" },
+		"markup.quote": {
+			fg: DEFAULT_COLORS.dim,
+			italic: true
+		},
+		"keyword": {
+			fg: "#FF7B72",
+			bold: true
+		},
+		"keyword.import": {
+			fg: "#FF7B72",
+			bold: true
+		},
+		"keyword.operator": { fg: "#FF7B72" },
+		"string": { fg: "#A5D6FF" },
+		"string.escape": {
+			fg: "#A5D6FF",
+			bold: true
+		},
+		"character": { fg: "#A5D6FF" },
+		"comment": {
+			fg: "#8B949E",
+			italic: true
+		},
+		"number": { fg: "#79C0FF" },
+		"boolean": { fg: "#79C0FF" },
+		"constant": { fg: "#79C0FF" },
+		"constant.builtin": { fg: "#79C0FF" },
+		"function": { fg: "#D2A8FF" },
+		"function.call": { fg: "#D2A8FF" },
+		"function.method": { fg: "#D2A8FF" },
+		"function.method.call": { fg: "#D2A8FF" },
+		"function.builtin": { fg: "#D2A8FF" },
+		"function.macro": { fg: "#D2A8FF" },
+		"type": { fg: "#FFA657" },
+		"type.builtin": { fg: "#FFA657" },
+		"constructor": { fg: "#FFA657" },
+		"attribute": { fg: "#FFA657" },
+		"tag": { fg: "#7EE787" },
+		"variable": { fg: "#E6EDF3" },
+		"variable.builtin": { fg: "#79C0FF" },
+		"variable.parameter": { fg: "#FFA657" },
+		"variable.member": { fg: "#79C0FF" },
+		"property": { fg: "#79C0FF" },
+		"operator": { fg: "#FF7B72" },
+		"punctuation": { fg: DEFAULT_COLORS.mute },
+		"punctuation.bracket": { fg: "#F0F6FC" },
+		"punctuation.delimiter": { fg: "#C9D1D9" },
+		"label": { fg: "#79C0FF" }
+	}
+};
+/**
+* Built-in theme registry, keyed by `theme.id`. The TUI looks up the active
+* theme here using `Settings.theme`; unknown ids fall back to
+* `DEFAULT_THEME`. Hosts can extend this by passing additional themes to a
+* future `runTui({ themes })` option (not yet wired).
+*
+* Insertion order is the picker cycle order — keep `default` first so a
+* fresh install (no `theme` in `state.json`) sees the familiar yellow theme
+* before the others.
+*/
+const BUILTIN_THEMES = {
+	[DEFAULT_THEME.id]: DEFAULT_THEME,
+	[CATPPUCCIN_MOCHA.id]: CATPPUCCIN_MOCHA,
+	[CATPPUCCIN_MACCHIATO.id]: CATPPUCCIN_MACCHIATO,
+	[CATPPUCCIN_FRAPPE.id]: CATPPUCCIN_FRAPPE,
+	[CATPPUCCIN_LATTE.id]: CATPPUCCIN_LATTE,
+	[VAPORWAVE_THEME.id]: VAPORWAVE_THEME
+};
+/** Resolve a theme id to its full `Theme`, falling back to default on unknown ids. */
+function resolveTheme(id) {
+	if (id && BUILTIN_THEMES[id]) return BUILTIN_THEMES[id];
+	return DEFAULT_THEME;
+}
+//#endregion
+//#region src/chat/settings-context.tsx
+const DEFAULT_SETTINGS = {
+	showThinking: true,
+	showToolCalls: true,
+	showToolResults: true,
+	safeMode: true,
+	hideSubagentOutput: true,
+	theme: DEFAULT_THEME.id
+};
+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 setSetting = useCallback((key, value) => {
+		setSettings((prev) => {
+			if (prev[key] === value) return prev;
+			const next = {
+				...prev,
+				[key]: value
+			};
+			onChange?.(next);
+			return next;
+		});
+	}, [onChange]);
+	const value = useMemo(() => ({
+		settings,
+		toggle,
+		setSetting
+	}), [
+		settings,
+		toggle,
+		setSetting
+	]);
+	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 SETTINGS_TOGGLES = [
+	{
+		key: "safeMode",
+		label: "Safe mode",
+		description: "prompt before each tool call (unless safelisted)"
+	},
+	{
+		key: "hideSubagentOutput",
+		label: "Hide subagent output",
+		description: "collapse subagent runs to start/done markers"
+	},
+	{
+		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"
+	}
+];
+const SETTINGS_CHOICES = [{
+	key: "theme",
+	label: "Theme",
+	description: "colors + markdown / syntax styles",
+	options: Object.values(BUILTIN_THEMES).map((t) => ({
+		value: t.id,
+		label: t.label
+	}))
+}];
+//#endregion
+//#region src/chat/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/chat/theme-context.tsx
+const ThemeContext = createContext(DEFAULT_THEME);
+function ThemeProvider({ theme, children }) {
+	return /* @__PURE__ */ jsx(ThemeContext.Provider, {
+		value: theme,
+		children
+	});
+}
+function useTheme() {
+	return useContext(ThemeContext);
+}
+/** Color palette only — equivalent to `useTheme().colors`. */
+function useColors() {
+	return useContext(ThemeContext).colors;
+}
+/** Select-row styling — equivalent to `useTheme().select`. */
+function useSelectStyle() {
+	return useContext(ThemeContext).select;
+}
+/** Panel / surface backgrounds — equivalent to `useTheme().surfaces`. */
+function useSurfaces() {
+	return useContext(ThemeContext).surfaces;
+}
+/** Raw syntax style table — `useTheme().syntax`. Renderer converts to its native style type. */
+function useSyntaxStyles() {
+	return useContext(ThemeContext).syntax;
+}
+//#endregion
+export { toolCallPreview as $, isOnSafelist as A, shortId as B, CATPPUCCIN_MOCHA as C, IMPLICITLY_SAFE_TOOLS as D, useSafeModeQueue as E, writeProjects as F, createTuiStore as G, useConfig as H, runOAuthLogin as I, listSessionMeta as J, eventsFromTurns as K, supportsOAuth as L, projectsFilePath as M, readProjects as N, addToSafelist as O, suggestSafelistEntry as P, titleFromTurns as Q, ageString as R, CATPPUCCIN_MACCHIATO as S, useSafeModeActions as T, resolveConfig as U, ConfigProvider as V, createStateStore as W, saveState as X, loadState as Y, stripSpawnTokensLine as Z, DEFAULT_THEME as _, piIdOf as _t, useSyntaxStyles as a, readProviderCredential as at, CATPPUCCIN_FRAPPE as b, finalizeStreamingMarkdownForOwner as c, writeCredentials as ct, DEFAULT_SETTINGS as d, cerebrasDescriptor as dt, toolResultText as et, SETTINGS_CHOICES as f, credKeyOf as ft, BUILTIN_THEMES as g, openrouterDescriptor as gt, useSettings as h, openaiDescriptor as ht, useSurfaces as i, readCredentials as it, matchesSafelistEntry as j, getSafelist as k, turnContextSize as l, BUILTIN_PROVIDERS as lt, SettingsProvider as m, modelsForDescriptor as mt, useColors as n, applyApiKeyEnv as nt, useTheme as o, removeProviderCredential as ot, SETTINGS_TOGGLES as p, getContextWindow as pt, lastContextSizeFromTurns as q, useSelectStyle as r, credentialsPath as rt, finalizeStreamingMarkdown as s, setProviderCredential as st, ThemeProvider as t, detectAuth as tt, useStreamBuffer as u, anthropicDescriptor as ut, resolveTheme as v, SafeModeProvider as w, CATPPUCCIN_LATTE as x, VAPORWAVE_THEME as y, fmtTokens as z };
+
+//# sourceMappingURL=theme-context-MungM3SY.js.map