zidane 4.1.8 → 5.0.0

package/dist/turn-operations-5aQu4dJg.js

@@ -0,0 +1,3587 @@
+import { a as multiEdit, c as grep, i as readFile$1, l as glob, n as createSpawnTool, o as listFiles, r as shell, t as writeFile$1, u as edit } from "./tools-CLazLRb4.js";
+import { n as toolResultToText } from "./types-Bx_F8jet.js";
+import { r as normalizeMcpServers } from "./mcp-Dw-fRPVk.js";
+import { a as discoverSkills } from "./interpolate-Ck970-61.js";
+import { n as formatTokenUsage } from "./stats-DZIsGqzu.js";
+import { n as definePreset } from "./presets-BRFH2qsQ.js";
+import { i as anthropic, n as openai, r as cerebras, t as openrouter } from "./providers-CCDvIXGJ.js";
+import { spawn } from "node:child_process";
+import { readdir, stat, writeFile } from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, 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, useEffect, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/chat/agents.ts
+/** Read-only tool slice shared by the Plan profile and any host-built read-only variant. */
+const READ_ONLY_TOOLS = {
+	readFile: readFile$1,
+	listFiles,
+	glob,
+	grep
+};
+/**
+* Build agent — the default profile. Full read/write/shell access plus
+* subagent spawning. Mirrors the legacy `basic` preset so existing TUI
+* behavior is preserved when `agents` is omitted.
+*/
+const BUILD_AGENT = {
+	id: "build",
+	label: "Build",
+	description: "full tool access — read, write, edit, shell, and spawn subagents",
+	accent: "accent",
+	preset: definePreset({
+		name: "build",
+		system: "You are a helpful coding assistant with full access to the workspace: shell, file reading, file writing, surgical and multi-edit tools, directory listing, codebase search, and sub-agent spawning. Prefer `edit` / `multi_edit` for in-place changes and `write_file` for full file overwrites. Spawn subagents for parallelizable work.",
+		tools: {
+			shell,
+			readFile: readFile$1,
+			writeFile: writeFile$1,
+			listFiles,
+			edit,
+			multiEdit,
+			glob,
+			grep,
+			spawn: createSpawnTool({ persist: true })
+		}
+	})
+};
+/**
+* Plan agent — read-only exploration mode. Locked down to file reading and
+* codebase search; no shell, no edits, no spawning. The system prompt
+* frames the conversation as planning rather than execution so the model
+* outputs proposals instead of attempting mutations.
+*/
+const PLAN_AGENT = {
+	id: "plan",
+	label: "Plan",
+	description: "read-only — explore, analyze, and propose without modifying anything",
+	accent: "model",
+	preset: definePreset({
+		name: "plan",
+		system: "You are in PLAN mode. You can read files, list directories, and search the codebase — but you CANNOT modify files, run shell commands, or spawn subagents. Use this mode to investigate, understand the problem, and propose a clear plan in detail. The user will switch to Build mode to execute it.",
+		tools: READ_ONLY_TOOLS
+	})
+};
+/**
+* Default registry shipped with `zidane/tui`. Insertion order = picker order.
+* Hosts that want only one profile can pass `{ agents: { build: BUILD_AGENT } }`,
+* or a fully custom registry of their own profiles.
+*/
+const BUILTIN_AGENTS = {
+	build: BUILD_AGENT,
+	plan: PLAN_AGENT
+};
+/** Id of the profile activated on first launch when nothing is persisted. */
+const DEFAULT_AGENT_ID = "build";
+/**
+* Resolve an agent id against a registry with sensible fallbacks: the
+* requested id wins when present, then `defaultId`, then the first key.
+* Returns `null` when the registry is empty (host misconfiguration —
+* the caller should surface this rather than silently failing).
+*/
+function resolveAgentId(registry, requestedId, defaultId) {
+	if (requestedId && registry[requestedId]) return requestedId;
+	if (defaultId && registry[defaultId]) return defaultId;
+	return Object.keys(registry)[0] ?? null;
+}
+/**
+* Wrap a legacy single `Preset` into a single-profile registry. Used by
+* `resolveConfig` when the host passed `preset` without `agents`, so older
+* call sites keep working — they get a one-entry registry whose picker is
+* a no-op (only one option).
+*/
+function singleAgentRegistry(preset) {
+	return { default: {
+		id: "default",
+		label: typeof preset.name === "string" && preset.name.length > 0 ? preset.name : "Default",
+		description: "host-provided preset",
+		preset,
+		accent: "accent"
+	} };
+}
+//#endregion
+//#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/completion.ts
+/**
+* Prompt autocompletion framework.
+*
+* Renderer-agnostic. Providers plug in by registering a `trigger` character
+* (e.g. `/` for skills, `@` for files) and exposing two operations:
+*
+*   1. `suggest(query)` — return ranked items for the live query.
+*   2. `parseReferences(text)` — find all references to the provider's
+*      items in arbitrary text. Used to highlight in-prompt mentions and
+*      drive submit-time side effects (activate the skill, attach the
+*      file, …).
+*
+* The TUI consumes `useCompletion()` to drive a popover above the textarea.
+* A future GUI consumes the same hook to drive a dropdown. The popup
+* component itself only reads `label` + `description` on each item, so
+* provider-specific typing (`TItem`) stays at the registration boundary
+* and never leaks into the renderer.
+*/
+/**
+* Resolve the provider trigger active at `cursor`, or `null` when none fits.
+*
+* Rules:
+*   - The trigger character must sit at position 0 of the buffer OR be
+*     preceded by whitespace. This prevents `http://` from triggering the
+*     `/`-bound skills provider mid-URL.
+*   - The cursor must be at or past the trigger position.
+*   - Nothing between the trigger and the cursor may be whitespace (the
+*     query is one contiguous token).
+*   - The query length is bounded — `maxQueryLength` defaults to 64 — so
+*     a runaway buffer scan can't pin the renderer.
+*/
+function findActiveTrigger(text, cursor, providers, options = {}) {
+	if (providers.length === 0) return null;
+	const max = options.maxQueryLength ?? 64;
+	const safeCursor = Math.max(0, Math.min(cursor, text.length));
+	const isWhitespace = (ch) => ch === void 0 ? false : /\s/.test(ch);
+	for (let i = safeCursor - 1; i >= 0 && safeCursor - i <= max + 1; i--) {
+		const ch = text[i];
+		if (isWhitespace(ch)) return null;
+		const provider = providers.find((p) => p.trigger === ch);
+		if (!provider) continue;
+		const before = i > 0 ? text[i - 1] : "";
+		if (before !== "" && !isWhitespace(before)) continue;
+		return {
+			provider,
+			query: text.slice(i + 1, safeCursor),
+			span: {
+				start: i,
+				end: safeCursor
+			}
+		};
+	}
+	return null;
+}
+/**
+* Replace `[span.start, span.end)` in `text` with `insertText`. Returns the
+* mutated text and the new cursor position (end of insertion).
+*/
+function applyInsert(text, span, insertText) {
+	return {
+		text: text.slice(0, span.start) + insertText + text.slice(span.end),
+		cursor: span.start + insertText.length
+	};
+}
+/**
+* Merge reference lists from multiple providers into one ordered list with
+* earlier-start-wins disambiguation when spans overlap. Ties broken by
+* insertion order. Spans are sorted ascending so renderers can walk them
+* sequentially with a cursor through the source string.
+*/
+function mergeReferences(refs) {
+	const sorted = [...refs].sort((a, b) => a.start - b.start);
+	const merged = [];
+	let lastEnd = -1;
+	for (const ref of sorted) {
+		if (ref.start < lastEnd) continue;
+		merged.push(ref);
+		lastEnd = ref.end;
+	}
+	return merged;
+}
+/**
+* Collect every provider's references in one pass. Convenience wrapper —
+* the TUI textarea component calls this on every keystroke to highlight
+* in-prompt mentions.
+*/
+function collectReferences(text, providers, cursor = text.length) {
+	const ctx = {
+		text,
+		cursor
+	};
+	const refs = [];
+	for (const p of providers) for (const ref of p.parseReferences(text, ctx)) refs.push(ref);
+	return mergeReferences(refs);
+}
+/**
+* Drive a prompt-completion popover from React state.
+*
+* Inputs are pull-style — the caller owns `text` + `cursor` (typically
+* mirroring an `OpenTUI TextareaRenderable` or a `<textarea>` element) and
+* passes them in each render. Providers are matched by their `trigger`
+* character; the engine picks at most one active provider per cursor
+* position.
+*
+* Asynchronous suggest calls are aborted when the query changes or the
+* popover closes, so providers that hit a backend don't leak.
+*/
+function useCompletion(input, providers, options = {}) {
+	const { text, cursor } = input;
+	const { maxQueryLength } = options;
+	const [dismissedSignature, setDismissedSignature] = useState(null);
+	const active = useMemo(() => {
+		const a = findActiveTrigger(text, cursor, providers, { maxQueryLength });
+		if (!a) return null;
+		if (dismissedSignature === `${text.length}:${cursor}`) return null;
+		return a;
+	}, [
+		text,
+		cursor,
+		providers,
+		maxQueryLength,
+		dismissedSignature
+	]);
+	const [items, setItems] = useState([]);
+	const [loading, setLoading] = useState(false);
+	const [selectedIndex, setSelectedIndex] = useState(0);
+	const abortRef = useRef(null);
+	useEffect(() => {
+		abortRef.current?.abort();
+		if (!active) {
+			setItems([]);
+			setLoading(false);
+			setSelectedIndex(0);
+			return;
+		}
+		const controller = new AbortController();
+		abortRef.current = controller;
+		const ctx = {
+			text,
+			cursor
+		};
+		let cancelled = false;
+		const out = active.provider.suggest(active.query, ctx, controller.signal);
+		if (Array.isArray(out)) {
+			setItems(out);
+			setSelectedIndex(0);
+			setLoading(false);
+			return;
+		}
+		setLoading(true);
+		out.then((next) => {
+			if (cancelled) return;
+			setItems(next);
+			setSelectedIndex(0);
+			setLoading(false);
+		}, () => {
+			if (cancelled) return;
+			setItems([]);
+			setLoading(false);
+		});
+		return () => {
+			cancelled = true;
+			controller.abort();
+		};
+	}, [
+		active,
+		text,
+		cursor
+	]);
+	const references = useMemo(() => collectReferences(text, providers, cursor), [text, providers]);
+	const selectNext = useCallback(() => {
+		setSelectedIndex((i) => items.length === 0 ? 0 : (i + 1) % items.length);
+	}, [items.length]);
+	const selectPrev = useCallback(() => {
+		setSelectedIndex((i) => items.length === 0 ? 0 : (i - 1 + items.length) % items.length);
+	}, [items.length]);
+	const dismiss = useCallback(() => {
+		setDismissedSignature(`${text.length}:${cursor}`);
+	}, [text.length, cursor]);
+	const commit = useCallback(() => {
+		if (!active || items.length === 0) return null;
+		const item = items[Math.min(selectedIndex, items.length - 1)];
+		return applyInsert(text, active.span, item.insertText);
+	}, [
+		active,
+		items,
+		selectedIndex,
+		text
+	]);
+	return useMemo(() => ({
+		active,
+		items,
+		loading,
+		selectedIndex,
+		selectNext,
+		selectPrev,
+		commit,
+		dismiss,
+		references
+	}), [
+		active,
+		items,
+		loading,
+		selectedIndex,
+		selectNext,
+		selectPrev,
+		commit,
+		dismiss,
+		references
+	]);
+}
+//#endregion
+//#region src/chat/completion-files.ts
+/** Trigger character — `@` is the conventional file-mention prefix in chat UIs. */
+const FILES_TRIGGER = "@";
+/** Cap on returned items. Keeps the popover compact + render-cheap. */
+const DEFAULT_RESULT_LIMIT = 50;
+/**
+* Build an `@`-prefixed files completion provider against a *live* catalog.
+*
+* The factory captures a getter so the catalog can be re-scanned (cwd
+* change, manual refresh) without re-instantiating the provider — the
+* App keeps one provider for the lifetime of the prompt block and just
+* mutates the underlying state.
+*
+* `limit` caps the result list so the popover stays bounded on huge
+* monorepos. Filtering is substring on `path` + `name`, case-insensitive;
+* ranking prefers (in order): exact name match, name prefix, name
+* substring, path substring, alphabetical.
+*/
+function createFilesCompletionProvider(opts) {
+	const limit = opts.limit ?? DEFAULT_RESULT_LIMIT;
+	return {
+		id: "files",
+		trigger: "@",
+		label: "Files",
+		suggest(query) {
+			const catalog = opts.getCatalog();
+			const q = query.trim().toLowerCase();
+			const scored = [];
+			for (const file of catalog) {
+				const name = file.name.toLowerCase();
+				const path = file.path.toLowerCase();
+				if (q.length === 0) {
+					scored.push({
+						entry: file,
+						rank: 4
+					});
+					continue;
+				}
+				if (name === q) {
+					scored.push({
+						entry: file,
+						rank: 0
+					});
+					continue;
+				}
+				if (name.startsWith(q)) {
+					scored.push({
+						entry: file,
+						rank: 1
+					});
+					continue;
+				}
+				if (name.includes(q)) {
+					scored.push({
+						entry: file,
+						rank: 2
+					});
+					continue;
+				}
+				if (path.includes(q)) {
+					scored.push({
+						entry: file,
+						rank: 3
+					});
+					continue;
+				}
+			}
+			scored.sort((a, b) => {
+				if (a.rank !== b.rank) return a.rank - b.rank;
+				return a.entry.path.localeCompare(b.entry.path);
+			});
+			return scored.slice(0, limit).map(({ entry }) => ({
+				id: entry.path,
+				label: entry.name,
+				description: parentDir(entry.path),
+				insertText: `@${entry.path} `,
+				data: entry
+			}));
+		},
+		parseReferences(text, _ctx) {
+			const catalog = opts.getCatalog();
+			if (catalog.length === 0) return [];
+			const byPath = /* @__PURE__ */ new Map();
+			for (const file of catalog) byPath.set(file.path, file);
+			const refs = [];
+			const rx = /(^|\s)@(\S+)/g;
+			let m;
+			while ((m = rx.exec(text)) !== null) {
+				const rawCandidate = m[2];
+				const stripped = byPath.has(rawCandidate) ? rawCandidate : rawCandidate.replace(/[.,;:)\]}!?]+$/, "");
+				const file = byPath.get(stripped);
+				if (!file) continue;
+				const start = m.index + m[1].length;
+				const trimmedLen = 1 + stripped.length;
+				refs.push({
+					providerId: "files",
+					start,
+					end: start + trimmedLen,
+					itemId: file.path,
+					data: file
+				});
+			}
+			return refs;
+		}
+	};
+}
+/** Return the parent directory of a forward-slashed path, or `''` for root entries. */
+function parentDir(path) {
+	const lastSlash = path.lastIndexOf("/");
+	return lastSlash <= 0 ? "" : path.slice(0, lastSlash);
+}
+/**
+* Walk a reference list and return the deduplicated set of files in
+* first-mention order — input to "attach these files to the prompt"
+* downstream logic.
+*/
+function uniqueFilesFromReferences(references) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const ref of references) {
+		if (ref.providerId !== "files") continue;
+		if (seen.has(ref.itemId)) continue;
+		seen.add(ref.itemId);
+		out.push(ref.data);
+	}
+	return out;
+}
+//#endregion
+//#region src/chat/completion-skills.ts
+/** Trigger character — slash-commands convention. */
+const SKILLS_TRIGGER = "/";
+/** Valid skill-name shape (matches the parser): lowercase alnum + dashes. */
+const SKILL_NAME_RX = /^[a-z0-9][a-z0-9-]*$/;
+/**
+* Build a slash-command completion provider against a *live* skills
+* catalog. The factory captures a getter so the catalog can change across
+* renders (toggles, reload) without re-instantiating the provider.
+*
+* Pass `getEnabled` to additionally hide skills the user has toggled off
+* — when undefined, every catalog entry is offered.
+*/
+function createSkillsCompletionProvider(opts) {
+	const visible = () => {
+		const all = opts.getCatalog();
+		const enabled = opts.getEnabled?.();
+		if (enabled === void 0) return [...all];
+		const allow = new Set(enabled);
+		return all.filter((s) => allow.has(s.name));
+	};
+	return {
+		id: "skills",
+		trigger: "/",
+		label: "Skills",
+		suggest(query) {
+			const q = query.trim().toLowerCase();
+			return visible().filter((skill) => SKILL_NAME_RX.test(skill.name)).filter((skill) => {
+				if (q.length === 0) return true;
+				return skill.name.toLowerCase().includes(q) || skill.description.toLowerCase().includes(q);
+			}).sort((a, b) => {
+				const an = a.name.toLowerCase();
+				const bn = b.name.toLowerCase();
+				if (q) {
+					const aPrefix = an.startsWith(q);
+					if (aPrefix !== bn.startsWith(q)) return aPrefix ? -1 : 1;
+				}
+				return an.localeCompare(bn);
+			}).map((skill) => ({
+				id: skill.name,
+				label: skill.name,
+				description: skill.description,
+				insertText: `/${skill.name} `,
+				data: skill
+			}));
+		},
+		parseReferences(text, _ctx) {
+			const catalog = visible();
+			if (catalog.length === 0) return [];
+			const byName = /* @__PURE__ */ new Map();
+			for (const skill of catalog) byName.set(skill.name, skill);
+			const refs = [];
+			const rx = /(^|\s)(\/([a-z0-9][a-z0-9-]*))/g;
+			let m;
+			while ((m = rx.exec(text)) !== null) {
+				const name = m[3];
+				const skill = byName.get(name);
+				if (!skill) continue;
+				const start = m.index + m[1].length;
+				refs.push({
+					providerId: "skills",
+					start,
+					end: start + m[2].length,
+					itemId: skill.name,
+					data: skill
+				});
+			}
+			return refs;
+		}
+	};
+}
+/**
+* Walk a parsed prompt for skill references and return the deduplicated
+* list of skill names — input to `agent.activateSkill(name)` calls on
+* submit.
+*/
+function uniqueSkillNamesFromReferences(references) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const ref of references) {
+		if (ref.providerId !== "skills") continue;
+		if (seen.has(ref.itemId)) continue;
+		seen.add(ref.itemId);
+		out.push(ref.itemId);
+	}
+	return out;
+}
+//#endregion
+//#region src/chat/project-root.ts
+/**
+* Git root detection — walks parents from `cwd` looking for a `.git`
+* entry, returning the absolute path of the repo root or `null` when
+* the search reaches the filesystem root.
+*
+* Why parent-walk over `git rev-parse --show-toplevel`:
+*
+*   - Zero dependencies (no shell-out, no git binary requirement,
+*     works even when `git` is missing from `PATH`).
+*   - Pure-sync, deterministic, easy to test against tmp dirs.
+*   - Equally fast in practice — most lookups are a single `existsSync`.
+*
+* Recognizes `.git` as either:
+*
+*   - A directory (standard repo layout).
+*   - A file containing `gitdir: …` (worktrees + submodules).
+*
+* Bare repos (no working tree) are intentionally NOT detected here —
+* the TUI's data dir contract is "project working tree", and a bare
+* repo has no working files to scope sessions against.
+*/
+/**
+* Walk parents of `cwd` looking for a `.git` entry. Returns the
+* absolute path of the directory containing `.git`, or `null` when no
+* git repo is found above `cwd`.
+*
+* Stops at the filesystem root (`/`) — no infinite loop on `dirname`'s
+* idempotent root case (`dirname('/')` returns `/`).
+*/
+function findGitRoot$1(cwd = process.cwd()) {
+	let dir = resolve(cwd);
+	for (let depth = 0; depth < 64; depth++) {
+		if (hasGitMarker(dir)) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+/**
+* `.git` exists as a directory (standard repo) OR as a file containing
+* a `gitdir:` pointer (worktree / submodule). Tolerant on stat failures
+* — a permission error on a parent directory shouldn't crash the walk.
+*/
+function hasGitMarker(dir) {
+	const candidate = resolve(dir, ".git");
+	try {
+		if (!existsSync(candidate)) return false;
+		const stat = statSync(candidate);
+		return stat.isDirectory() || stat.isFile();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/chat/store.ts
+function ensureStateDir(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 state directory at "${dir}". Override the location via \`runTui({ storageDir, prefix })\` or the \`ZIDANE_STORAGE_DIR\` env var. Original error: ${message}`);
+	}
+}
+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) {
+	ensureStateDir(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`).
+*
+* Robust to per-row failures: `Promise.allSettled` so a single corrupt or
+* unreadable row (malformed JSON, partial write, transient I/O error)
+* doesn't take down the entire picker. Failed rows are silently skipped;
+* a stderr line is emitted under `ZIDANE_DEBUG` for diagnosis.
+*/
+async function listSessionMeta(store, filter) {
+	const ids = await store.list(filter);
+	const settled = await Promise.allSettled(ids.map(async (id) => {
+		const data = await store.load(id);
+		if (!data) return null;
+		return {
+			id,
+			title: deriveSessionTitle(data.turns, data.metadata),
+			turnCount: data.turns.length,
+			userMessageCount: data.turns.reduce((n, t) => t.role === "user" ? n + 1 : n, 0),
+			runCount: data.runs.length,
+			...data.projectRoot ? { projectRoot: data.projectRoot } : {},
+			updatedAt: data.updatedAt
+		};
+	}));
+	const metas = [];
+	for (let i = 0; i < settled.length; i++) {
+		const result = settled[i];
+		if (result.status === "fulfilled" && result.value) metas.push(result.value);
+		else if (result.status === "rejected" && process.env.ZIDANE_DEBUG) {
+			const cause = result.reason instanceof Error ? result.reason.message : String(result.reason);
+			process.stderr.write(`[zidane/chat] failed to load session "${ids[i]}": ${cause}\n`);
+		}
+	}
+	return metas;
+}
+/** 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;
+}
+/**
+* Display title for a session — preferred sources, in order:
+*
+*   1. `metadata.title` if it's a non-empty string (typically set by
+*      the session-details modal's "generate title" action).
+*   2. {@link titleFromTurns} — the first user message, one-line + clipped.
+*   3. The literal `'untitled'`.
+*
+* Total / pure / defensive on non-string metadata values.
+*/
+function deriveSessionTitle(turns, metadata) {
+	const stored = typeof metadata?.title === "string" ? metadata.title.trim() : "";
+	if (stored.length > 0) return stored;
+	return titleFromTurns(turns) ?? "untitled";
+}
+/**
+* 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 ancestryOf = (turnRunId) => {
+		if (!turnRunId) return [];
+		const chain = [];
+		let cursor = runById.get(turnRunId);
+		const seen = /* @__PURE__ */ new Set();
+		while (cursor) {
+			if (seen.has(cursor.id)) break;
+			seen.add(cursor.id);
+			if ((cursor.depth ?? 0) > 0) chain.unshift(cursor);
+			cursor = cursor.parentRunId ? runById.get(cursor.parentRunId) : void 0;
+		}
+		return chain;
+	};
+	const events = [];
+	/** Currently-open child runs, root-of-tree first, innermost last. */
+	const openStack = [];
+	/** True iff anything has been emitted at the active depth-0 level. Used to decide separators between top-level turns. */
+	let lastDepthAtEmission = -1;
+	const pushSpawnEnd = (run) => {
+		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(run.id),
+			depth: run.depth ?? 1
+		});
+	};
+	const pushSpawnStart = (run) => {
+		const taskPreview = run.prompt.length > 80 ? `${run.prompt.slice(0, 80)}…` : run.prompt;
+		events.push({
+			kind: "spawn-start",
+			text: taskPreview,
+			childId: labelFor(run.id),
+			depth: run.depth ?? 1
+		});
+	};
+	for (let i = 0; i < turns.length; i++) {
+		const turn = turns[i];
+		const targetChain = ancestryOf(turn.runId);
+		const depth = targetChain.length;
+		let common = 0;
+		while (common < openStack.length && common < targetChain.length && openStack[common].id === targetChain[common].id) common++;
+		while (openStack.length > common) pushSpawnEnd(openStack.pop());
+		while (openStack.length < targetChain.length) {
+			const run = targetChain[openStack.length];
+			pushSpawnStart(run);
+			openStack.push(run);
+		}
+		if (depth === 0 && lastDepthAtEmission === 0) events.push({
+			kind: "separator",
+			text: ""
+		});
+		const subagentTag = depth > 0 && turn.runId ? {
+			childId: labelFor(turn.runId),
+			depth
+		} : void 0;
+		const tag = {
+			turnId: turn.id,
+			...subagentTag
+		};
+		if (turn.role === "user") {
+			for (const block of turn.content) if (block.type === "text" && block.text.trim()) {
+				if (depth === 0) events.push({
+					kind: "user-prompt",
+					text: block.text,
+					turnId: turn.id
+				});
+			} 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
+				});
+			}
+			lastDepthAtEmission = depth;
+			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
+			});
+			lastDepthAtEmission = depth;
+		}
+	}
+	while (openStack.length > 0) pushSpawnEnd(openStack.pop());
+	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(/(^\[sub-agent [^\n]+\n)Tokens:[^\n]*\n?/gm, "$1");
+}
+/**
+* Deduplicated, in-order list of **parent-conversation** turn ids that appear
+* in a rendered transcript — the navigation index for the TUI's select-turn
+* mode. Subagent (`childId` set) events are deliberately skipped:
+*
+*   - With `hideSubagentOutput: true` (default), child events are filtered
+*     out of the transcript by `isVisible`, so allowing the user to "select"
+*     them would highlight nothing and scroll to nowhere.
+*   - With `hideSubagentOutput: false`, child events are visible but they're
+*     nested execution detail; the user's mental model of a "message" is
+*     the conversational exchange, not each spawn turn.
+*
+* Synthetic events (separator, spawn-start, spawn-end) have no `turnId` and
+* are skipped naturally. Pure function over the event stream — no settings
+* dependency, no host concerns — so it composes the same in TUI / SDK
+* consumers.
+*/
+function selectableTurnIds(events) {
+	const seen = /* @__PURE__ */ new Set();
+	const ordered = [];
+	for (const e of events) {
+		if (!e.turnId) continue;
+		if (e.childId) continue;
+		if (seen.has(e.turnId)) continue;
+		seen.add(e.turnId);
+		ordered.push(e.turnId);
+	}
+	return ordered;
+}
+/** Effective context size of the most recent assistant turn — drives the footer indicator. */
+/**
+* Walk from the end of `turns` and return the cache-aware input-token total
+* of the most recent **parent** (depth-0) assistant turn. Subagent turns
+* are skipped because their context window is the child's, not the parent's
+* — surfacing a subagent's `usage.input` as the footer's "context used"
+* after a session ends mid-spawn would be misleading. The next prompt
+* feeds the parent, so the parent's last view is what matters.
+*
+* `runs` is optional for backwards compatibility (older call sites and
+* tests that don't have ancestry info). Without it, this falls back to the
+* pre-fix behavior — depth is unknown so every assistant turn qualifies.
+*/
+function lastContextSizeFromTurns(turns, runs = []) {
+	const childRunIds = /* @__PURE__ */ new Set();
+	for (const run of runs) if ((run.depth ?? 0) > 0) childRunIds.add(run.id);
+	for (let i = turns.length - 1; i >= 0; i--) {
+		const turn = turns[i];
+		if (turn.role !== "assistant" || !turn.usage) continue;
+		if (turn.runId && childRunIds.has(turn.runId)) continue;
+		return (turn.usage.input ?? 0) + (turn.usage.cacheRead ?? 0) + (turn.usage.cacheCreation ?? 0);
+	}
+	return 0;
+}
+Object.freeze({ projectDb: true });
+/**
+* Build the absolute path to `~/.{prefix}/config.json` given a user
+* directory (`<storageDir>/<prefix>`). Exported so callers debugging a
+* "why isn't my override taking effect?" can print the resolved path.
+*/
+function userConfigPath(userDir) {
+	return resolve(userDir, "config.json");
+}
+/**
+* Read + parse the user config file. Returns an empty config (defaults
+* apply) on any failure — the function never throws. Set `ZIDANE_DEBUG`
+* to surface parse failures to stderr.
+*/
+function loadUserConfig(userDir) {
+	const path = userConfigPath(userDir);
+	if (!existsSync(path)) return {};
+	try {
+		const raw = readFileSync(path, "utf8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		return normalizeUserConfig(parsed);
+	} catch (err) {
+		if (process.env.ZIDANE_DEBUG) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`[zidane/chat] user-config: failed to read "${path}": ${msg}\n`);
+		}
+		return {};
+	}
+}
+/**
+* Narrow an arbitrary JSON object to the `UserConfig` shape. Drops
+* unknown keys (so a future zidane version's config field doesn't
+* leak into the typed surface) and validates types per-field.
+*/
+function normalizeUserConfig(raw) {
+	const out = {};
+	if (typeof raw.projectDb === "boolean") out.projectDb = raw.projectDb;
+	return out;
+}
+//#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 paths = resolveStoragePaths({
+		prefix,
+		storageDir,
+		cwd: options.cwd ?? process.cwd(),
+		projectDb: options.projectDb
+	});
+	if (!options.store) throw new Error("resolveConfig: `store` is required. Pass a `SessionStore` instance, or a factory — terminal hosts can use `createTuiStore` from `zidane/session/sqlite`.");
+	const store = typeof options.store === "function" ? options.store(paths) : options.store;
+	const stateStore = createStateStore(paths.state);
+	const initialState = stateStore.load();
+	const providers = options.providers ?? BUILTIN_PROVIDERS;
+	if (options.agents && options.preset) throw new Error("resolveConfig: pass either `preset` (single-agent legacy) or `agents` (multi-profile registry), not both. Migrate `preset` into an entry inside `agents` if you want both worlds.");
+	const agents = options.agents ?? (options.preset ? singleAgentRegistry(options.preset) : BUILTIN_AGENTS);
+	if (Object.keys(agents).length === 0) throw new Error("resolveConfig: `agents` registry is empty — at least one profile is required.");
+	process.env.ZIDANE_CREDENTIALS_PATH = credentialsPath(paths.userDir);
+	applyApiKeyEnv(paths.userDir, providers);
+	const modelsFor = makeModelsResolver(providers);
+	const resumeProvider = resolveResumeProvider(initialState, providers, paths.userDir);
+	const initialPicked = resumeProvider ? pickInitial(resumeProvider, providers, initialState) : null;
+	const initialAgentId = resolveAgentId(agents, initialState.lastAgent, options.defaultAgent ?? "build");
+	if (!initialAgentId) throw new Error("resolveConfig: failed to resolve an initial agent id from a non-empty registry.");
+	return {
+		prefix,
+		storageDir,
+		paths,
+		providers,
+		agents,
+		initialAgentId,
+		store,
+		stateStore,
+		modelsFor,
+		initialState,
+		initialSettings: initialState.settings ?? {},
+		resumeProvider,
+		initialPicked
+	};
+}
+/**
+* Compute the on-disk layout for a single TUI session. Public so hosts
+* (CLI tools, tests, scripted bootstraps) can ask "where will sessions
+* land?" without going through `resolveConfig`'s full machinery.
+*
+* Decision logic for project mode (least → most specific):
+*
+*   1. Default: ON (`projectDb: true`).
+*   2. `~/.{prefix}/config.json` `projectDb` flag (when present).
+*   3. `ZIDANE_PROJECT_DB` env var (`'0'` / `'false'` / `'off'` → off,
+*      anything else true if set).
+*   4. `options.projectDb` (host call site).
+*
+* Project mode activates only when the resolution above lands on
+* `true` AND a git repo is found above `cwd`. Outside git or with the
+* flag off, sessions + state stay at the user dir.
+*
+* Auto-creates the project `.{prefix}/` directory when mode resolves
+* to ON (silent — mirrors `ensureStateDir`). User dir is created
+* lazily by the state-store + credentials writers; we don't pre-touch
+* it here so a read-only invocation stays read-only.
+*/
+function resolveStoragePaths(opts) {
+	const userDir = resolve(opts.storageDir, opts.prefix);
+	const userConfig = loadUserConfig(userDir);
+	const envFlag = parseEnvFlag(process.env.ZIDANE_PROJECT_DB);
+	const gitRoot = opts.projectDb ?? envFlag ?? userConfig.projectDb ?? false ? findGitRoot$1(opts.cwd) : null;
+	const projectDir = gitRoot ? resolve(gitRoot, opts.prefix) : null;
+	if (projectDir && !existsSync(projectDir)) try {
+		mkdirSync(projectDir, { recursive: true });
+	} catch (err) {
+		if (process.env.ZIDANE_DEBUG) {
+			const cause = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`[zidane/chat] project-db: mkdir "${projectDir}" failed: ${cause}\n`);
+		}
+		return userOnlyPaths(userDir);
+	}
+	const effective = projectDir ?? userDir;
+	return {
+		dir: effective,
+		userDir,
+		projectDir,
+		db: resolve(effective, "sessions.db"),
+		state: resolve(effective, "state.json")
+	};
+}
+function userOnlyPaths(userDir) {
+	return {
+		dir: userDir,
+		userDir,
+		projectDir: null,
+		db: resolve(userDir, "sessions.db"),
+		state: resolve(userDir, "state.json")
+	};
+}
+/** Tri-state parse for env-var bools — explicit `null` keeps absence from forcing a default. */
+function parseEnvFlag(raw) {
+	if (raw === void 0) return void 0;
+	const v = raw.trim().toLowerCase();
+	if (v === "0" || v === "false" || v === "off" || v === "no") return false;
+	if (v === "1" || v === "true" || v === "on" || v === "yes") return true;
+}
+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/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,
+			chips: {
+				default: {
+					bg: p.mauve,
+					fg: p.base
+				},
+				skills: {
+					bg: p.mauve,
+					fg: p.base
+				},
+				files: {
+					bg: p.blue,
+					fg: p.base
+				}
+			},
+			selection: p.surface0
+		},
+		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 (light)", 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",
+	/**
+	* ~70% of `text` — used for captions / helper / "dim" text so that
+	*  secondary copy is visually distinct from primary copy. Matches the
+	*  upstream theme's sidebar foreground (`#b7c5d3`) tonality.
+	*/
+	textDim: "#B7C5D3",
+	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.textDim,
+		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,
+		chips: {
+			default: {
+				bg: PALETTE.pink,
+				fg: PALETTE.panel
+			},
+			skills: {
+				bg: PALETTE.pink,
+				fg: PALETTE.panel
+			},
+			files: {
+				bg: PALETTE.cyan,
+				fg: PALETTE.panel
+			}
+		},
+		selection: PALETTE.surface
+	},
+	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.
+*/
+/**
+* Look up the chip color pair for a provider id, falling back to
+* `chips.default` when the theme has no kind-specific entry. Mirrors
+* `resolveChipStyleId` so both rendering surfaces (submitted echo +
+* live textarea) share one canonical lookup rule.
+*/
+function resolveChipColor(chips, providerId) {
+	return chips[providerId] ?? chips.default;
+}
+const DEFAULT_COLORS = {
+	brand: "#2ba6ff",
+	accent: "#22c55e",
+	model: "#8adaff",
+	warn: "#53c4ff",
+	error: "#ef4444",
+	dim: "#a3a3ac",
+	mute: "#525258",
+	border: "#3c3c41",
+	borderActive: "#1488fc"
+};
+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: "#111114",
+		chips: {
+			default: {
+				bg: DEFAULT_COLORS.brand,
+				fg: "#eef9ff"
+			},
+			skills: {
+				bg: DEFAULT_COLORS.brand,
+				fg: "#eef9ff"
+			},
+			files: {
+				bg: "#8adaff",
+				fg: "#122f59"
+			}
+		},
+		selection: "#142737"
+	},
+	syntax: {
+		"default": { fg: "#fefeff" },
+		"markup.heading": {
+			fg: "#2ba6ff",
+			bold: true
+		},
+		"markup.heading.1": {
+			fg: "#2ba6ff",
+			bold: true
+		},
+		"markup.heading.2": {
+			fg: "#53c4ff",
+			bold: true
+		},
+		"markup.heading.3": {
+			fg: "#8adaff",
+			bold: true
+		},
+		"markup.bold": {
+			fg: "#ffffff",
+			bold: true
+		},
+		"markup.strong": {
+			fg: "#ffffff",
+			bold: true
+		},
+		"markup.italic": {
+			fg: "#fefeff",
+			italic: true
+		},
+		"markup.link": {
+			fg: DEFAULT_COLORS.model,
+			underline: true
+		},
+		"markup.link.url": {
+			fg: DEFAULT_COLORS.model,
+			underline: true
+		},
+		"markup.list": { fg: "#fb923c" },
+		"markup.raw": { fg: "#bae7ff" },
+		"markup.raw.block": { fg: "#bae7ff" },
+		"markup.quote": {
+			fg: DEFAULT_COLORS.dim,
+			italic: true
+		},
+		"keyword": {
+			fg: "#f87171",
+			bold: true
+		},
+		"keyword.import": {
+			fg: "#f87171",
+			bold: true
+		},
+		"keyword.operator": { fg: "#f87171" },
+		"string": { fg: "#bae7ff" },
+		"string.escape": {
+			fg: "#bae7ff",
+			bold: true
+		},
+		"character": { fg: "#bae7ff" },
+		"comment": {
+			fg: "#73737b",
+			italic: true
+		},
+		"number": { fg: "#8adaff" },
+		"boolean": { fg: "#8adaff" },
+		"constant": { fg: "#8adaff" },
+		"constant.builtin": { fg: "#8adaff" },
+		"function": { fg: "#86efac" },
+		"function.call": { fg: "#86efac" },
+		"function.method": { fg: "#86efac" },
+		"function.method.call": { fg: "#86efac" },
+		"function.builtin": { fg: "#86efac" },
+		"function.macro": { fg: "#86efac" },
+		"type": { fg: "#fb923c" },
+		"type.builtin": { fg: "#fb923c" },
+		"constructor": { fg: "#fb923c" },
+		"attribute": { fg: "#fb923c" },
+		"tag": { fg: "#4ade80" },
+		"variable": { fg: "#fefeff" },
+		"variable.builtin": { fg: "#8adaff" },
+		"variable.parameter": { fg: "#fb923c" },
+		"variable.member": { fg: "#8adaff" },
+		"property": { fg: "#8adaff" },
+		"operator": { fg: "#f87171" },
+		"punctuation": { fg: DEFAULT_COLORS.mute },
+		"punctuation.bracket": { fg: "#fefeff" },
+		"punctuation.delimiter": { fg: "#d4d4dd" },
+		"label": { fg: "#8adaff" }
+	}
+};
+/**
+* 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,
+	showAllProjects: false
+};
+const SettingsContext = createContext(null);
+function SettingsProvider({ initial, onChange, children }) {
+	const [settings, setSettings] = useState(initial);
+	const onChangeRef = useRef(onChange);
+	onChangeRef.current = onChange;
+	const initialMount = useRef(true);
+	useEffect(() => {
+		if (initialMount.current) {
+			initialMount.current = false;
+			return;
+		}
+		onChangeRef.current?.(settings);
+	}, [settings]);
+	const toggle = useCallback((key) => {
+		setSettings((prev) => ({
+			...prev,
+			[key]: !prev[key]
+		}));
+	}, []);
+	const setSetting = useCallback((key, value) => {
+		setSettings((prev) => prev[key] === value ? prev : {
+			...prev,
+			[key]: value
+		});
+	}, []);
+	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: "showAllProjects",
+		label: "All projects",
+		description: "list sessions from every project (off = current only)"
+	},
+	{
+		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/enabled-toggle-set.ts
+/**
+* Renderer-agnostic state machine for an "enabled allowlist" — the shape
+* used by `settings.enabledSkills` / `settings.enabledMcps` (and any future
+* `enabledX` toggle backed by a `Settings` field).
+*
+* Semantics, kept identical across all three call sites:
+*   - `undefined`  → every catalog entry is enabled (default — user has
+*                    never opened the picker; new entries flow in).
+*   - `[]`         → the whole subsystem is off.
+*   - `[names]`    → explicit allowlist; the persisted shape stays a
+*                    concrete array once the user has toggled anything.
+*
+* The hook exposes a live `enabledSet` (Set<string>) + a `toggle(name)`
+* callback that persists the result through `useSettings().setSetting`.
+* The first toggle seeds the persisted allowlist from the current catalog
+* so newly-added entries don't silently drop on the next launch.
+*
+* Renderer-neutral: works for the TUI's `<ToggleListModal>`, a GUI
+* checkbox list, a CLI flag tool. Hook tests live alongside the chat
+* suite; the rendering layer is tested where it lives.
+*/
+/**
+* Bind an "enabled allowlist" setting to a discovered catalog.
+*
+* `keyOf` extracts the persisted identity from a catalog entry (skill name,
+* MCP server name, …). Pass a stable, collision-free key — the persisted
+* allowlist is keyed against it forever.
+*/
+function useEnabledToggleSet(opts) {
+	const { settings, setSetting } = useSettings();
+	const { catalog, keyOf, settingKey } = opts;
+	const persisted = settings[settingKey];
+	const enabledSet = useMemo(() => {
+		if (persisted === void 0) return new Set(catalog.map(keyOf));
+		return new Set(persisted);
+	}, [
+		persisted,
+		catalog,
+		keyOf
+	]);
+	const catalogKeys = useMemo(() => new Set(catalog.map(keyOf)), [catalog, keyOf]);
+	return {
+		enabledSet,
+		toggle: useCallback((name) => {
+			const next = new Set(enabledSet);
+			if (next.has(name)) next.delete(name);
+			else next.add(name);
+			setSetting(settingKey, [...next].filter((n) => catalogKeys.has(n)).sort());
+		}, [
+			enabledSet,
+			catalogKeys,
+			settingKey,
+			setSetting
+		])
+	};
+}
+//#endregion
+//#region src/chat/files-discovery.ts
+/**
+* Hard cap on the discovered file count. Bigger than any reasonable repo's
+* source tree, small enough that a runaway scan can't pin the renderer's
+* filter. Provider's substring match runs over the full list per
+* keystroke; 10k entries × cheap `.includes()` is well under one frame.
+*/
+const DEFAULT_MAX_FILES = 1e4;
+/**
+* Names skipped during the fs-walk fallback. Mirrors what `git ls-files`
+* would exclude via the default `.gitignore` shipped in most repos —
+* `node_modules`, `dist`, build caches — plus the `.git` dir itself.
+* Best-effort; the git path is the authoritative one.
+*/
+const FS_WALK_SKIP = new Set([
+	".git",
+	".hg",
+	".svn",
+	"node_modules",
+	"dist",
+	"build",
+	"out",
+	"coverage",
+	".next",
+	".nuxt",
+	".cache",
+	".turbo",
+	".parcel-cache",
+	".vercel",
+	".svelte-kit",
+	".expo",
+	".gradle",
+	"target",
+	"__pycache__",
+	".pytest_cache",
+	".venv",
+	"venv",
+	".idea",
+	".vscode-test"
+]);
+/**
+* Discover every non-ignored file under `cwd`. Tries `git ls-files` first;
+* on failure (no git, not a repo, abort) walks the fs with a hand-rolled
+* skip list.
+*
+* Errors are not thrown — the function always returns an array (possibly
+* empty). Callers wanting failure diagnostics can opt into them via
+* `ZIDANE_DEBUG`.
+*/
+async function listProjectFiles(opts = {}) {
+	const cwd = resolve(opts.cwd ?? process.cwd());
+	const maxFiles = opts.maxFiles ?? DEFAULT_MAX_FILES;
+	const signal = opts.signal;
+	try {
+		return toEntries(await listViaGit(cwd, signal), "git", maxFiles);
+	} catch (err) {
+		if (process.env.ZIDANE_DEBUG) {
+			const cause = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`[zidane/chat] git ls-files failed (${cause}) — falling back to fs walk\n`);
+		}
+		try {
+			return toEntries(await listViaFs(cwd, maxFiles, signal), "fs", maxFiles);
+		} catch (fsErr) {
+			if (process.env.ZIDANE_DEBUG) {
+				const cause = fsErr instanceof Error ? fsErr.message : String(fsErr);
+				process.stderr.write(`[zidane/chat] fs walk failed: ${cause}\n`);
+			}
+			return [];
+		}
+	}
+}
+/**
+* Run `git ls-files --cached --others --exclude-standard` and return paths.
+*
+*   - `--cached` — tracked files.
+*   - `--others` — untracked but not ignored.
+*   - `--exclude-standard` — apply `.gitignore`, `.git/info/exclude`, the
+*     user's global excludes file, AND skip files marked `assume-unchanged`.
+*
+* Throws on non-zero exit (not a repo / no git) so the fallback path can
+* pick up. Aborts cleanly on `signal.aborted`.
+*/
+async function listViaGit(cwd, signal) {
+	return new Promise((resolveP, rejectP) => {
+		const child = spawn("git", [
+			"ls-files",
+			"--cached",
+			"--others",
+			"--exclude-standard",
+			"-z"
+		], {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		const onAbort = () => child.kill("SIGTERM");
+		if (signal) {
+			if (signal.aborted) {
+				child.kill("SIGTERM");
+				rejectP(/* @__PURE__ */ new Error("aborted"));
+				return;
+			}
+			signal.addEventListener("abort", onAbort, { once: true });
+		}
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+		child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+		child.on("error", (err) => {
+			signal?.removeEventListener("abort", onAbort);
+			rejectP(err);
+		});
+		child.on("close", (code) => {
+			signal?.removeEventListener("abort", onAbort);
+			if (signal?.aborted) {
+				rejectP(/* @__PURE__ */ new Error("aborted"));
+				return;
+			}
+			if (code !== 0) {
+				rejectP(/* @__PURE__ */ new Error(`git ls-files exited ${code}: ${stderrChunks.join("").trim()}`));
+				return;
+			}
+			resolveP(stdoutChunks.join("").split("\0").filter((p) => p.length > 0));
+		});
+	});
+}
+/**
+* Depth-first fs walk fallback. Used when git is unavailable. Honors a
+* hard-coded skip list; doesn't read `.gitignore`. Acceptable for hosts
+* outside a git checkout (e.g. a freshly-`unzip`ped project).
+*/
+async function listViaFs(cwd, maxFiles, signal) {
+	const out = [];
+	const stack = ["."];
+	while (stack.length > 0) {
+		if (signal?.aborted) throw new Error("aborted");
+		const rel = stack.pop();
+		const abs = rel === "." ? cwd : resolve(cwd, rel);
+		let entries;
+		try {
+			entries = await readdir(abs, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const e of entries) {
+			if (FS_WALK_SKIP.has(e.name)) continue;
+			const childRel = rel === "." ? e.name : `${rel}${sep}${e.name}`;
+			if (e.isDirectory()) stack.push(childRel);
+			else if (e.isFile()) {
+				out.push(toForwardSlash(childRel));
+				if (out.length >= maxFiles) return out;
+			} else if (e.isSymbolicLink()) {
+				let st;
+				try {
+					st = await stat(resolve(abs, e.name));
+				} catch {
+					continue;
+				}
+				if (st.isFile()) {
+					out.push(toForwardSlash(childRel));
+					if (out.length >= maxFiles) return out;
+				}
+			}
+		}
+	}
+	return out;
+}
+function toForwardSlash(p) {
+	return sep === "/" ? p : p.replaceAll(sep, "/");
+}
+function toEntries(paths, source, maxFiles) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const raw of paths) {
+		const path = toForwardSlash(raw);
+		if (path.length === 0 || seen.has(path)) continue;
+		seen.add(path);
+		const lastSlash = path.lastIndexOf("/");
+		const name = lastSlash >= 0 ? path.slice(lastSlash + 1) : path;
+		out.push({
+			path,
+			name,
+			source
+		});
+		if (out.length >= maxFiles) break;
+	}
+	return out;
+}
+//#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);
+}
+/**
+* Compact an absolute path for display: replace the user's `$HOME`
+* prefix with `~` (so `/Users/yael/Code/zidane` → `~/Code/zidane`),
+* and optionally left-truncate with an ellipsis when the result
+* still exceeds `maxWidth` (so the path's *tail* — the part the user
+* recognizes — stays visible: `…/zidane` rather than `/Users/yaeluil…`).
+*
+* `maxWidth` is the maximum *display width* in cells. Omit to skip
+* truncation. Paths outside `$HOME` are returned verbatim modulo
+* truncation. The ellipsis (`…`) counts as one cell.
+*
+* `home` overrides `os.homedir()` for tests; production callers leave
+* it undefined and pay the cheap one-syscall lookup per call.
+*/
+function compactPath(path, maxWidth, home) {
+	const h = home ?? homedir();
+	let display = path;
+	if (h) {
+		if (path === h) display = "~";
+		else if (path.startsWith(`${h}/`)) display = `~${path.slice(h.length)}`;
+	}
+	if (maxWidth !== void 0 && maxWidth > 1 && display.length > maxWidth) return `…${display.slice(display.length - maxWidth + 1)}`;
+	return display;
+}
+//#endregion
+//#region src/chat/generate-title.ts
+/** Hard cap on the result length. Anything longer is truncated client-side. */
+const TITLE_MAX_CHARS = 60;
+/** Default turn count fed to the model. 10 covers most exchanges without bloat. */
+const DEFAULT_MAX_TURNS = 10;
+/** Tokens budgeted for the model's reply. 64 fits any sane title with headroom. */
+const TITLE_RESPONSE_MAX_TOKENS = 64;
+/** Per-turn body cap when assembling the prompt — keeps the request payload tight. */
+const PROMPT_TURN_CHAR_MAX = 2e3;
+/**
+* Drive the provider's `stream()` once and return a concise title for
+* the conversation represented by `turns`. Throws when:
+*   - `turns` contains no text-bearing content (nothing to summarize),
+*   - the provider stream completes with no output text,
+*   - `signal` is aborted (rethrown verbatim).
+*
+* Output is trimmed, single-line, with surrounding quotes / trailing
+* punctuation stripped, and truncated to `TITLE_MAX_CHARS`.
+*/
+async function generateSessionTitle({ provider, model, turns, maxTurns = DEFAULT_MAX_TURNS, signal }) {
+	const transcript = renderTurnsForPrompt(turns.slice(-Math.max(1, maxTurns)));
+	if (!transcript) throw new Error("No text content in the recent turns to summarize.");
+	const system = [
+		"You generate concise, descriptive titles for chat conversations.",
+		"Reply with ONLY the title — no quotes, no markdown, no trailing punctuation,",
+		"no preamble (do not say \"Title:\" or similar).",
+		`Aim for 3 to 7 words and stay under ${TITLE_MAX_CHARS} characters.`
+	].join(" ");
+	const userPrompt = `Generate a title for this conversation:\n\n${transcript}`;
+	let text = "";
+	const result = await provider.stream({
+		model,
+		system,
+		tools: [],
+		messages: [provider.userMessage(userPrompt)],
+		maxTokens: TITLE_RESPONSE_MAX_TOKENS,
+		...signal ? { signal } : {}
+	}, { onText: (delta) => {
+		text += delta;
+	} });
+	return cleanTitle(text.trim().length > 0 ? text : result.text);
+}
+/**
+* Compact a turn list into a transcript-style prompt:
+*
+*   user: …
+*   assistant: …
+*   user: …
+*
+* Tool calls and tool results are summarized to keep the request
+* payload small — the model needs the rough flow of the conversation,
+* not full JSON blobs. Per-turn text is clipped at `PROMPT_TURN_CHAR_MAX`
+* so a single huge code dump doesn't blow the budget.
+*
+* Returns an empty string when the slice has no text-bearing content
+* (e.g. a turn list that's only tool plumbing).
+*/
+function renderTurnsForPrompt(turns) {
+	const lines = [];
+	for (const turn of turns) {
+		const body = textBodyOf(turn);
+		if (!body) continue;
+		const role = turn.role === "assistant" ? "assistant" : turn.role === "user" ? "user" : "system";
+		lines.push(`${role}: ${clip(body, PROMPT_TURN_CHAR_MAX)}`);
+	}
+	return lines.join("\n\n");
+}
+function textBodyOf(turn) {
+	const parts = [];
+	for (const block of turn.content) if (block.type === "text" && block.text.trim()) parts.push(block.text.trim());
+	else if (block.type === "tool_call") parts.push(`[tool: ${block.name}]`);
+	else if (block.type === "tool_result") parts.push(`[tool result]`);
+	return parts.join(" ");
+}
+/**
+* Normalize a model-generated title into the shape we want to persist:
+*
+*   - Collapse internal whitespace + take the first line only (some
+*     models emit "Title: foo\n\nReason: …" despite instructions).
+*   - Strip surrounding quote characters (`"foo"`, `'foo'`, `` `foo` ``).
+*   - Strip a leading `Title:` / `title -` prefix if the model added one.
+*   - Strip trailing punctuation (`.`, `!`, `?`) — titles read cleaner
+*     without it.
+*   - Truncate to `TITLE_MAX_CHARS` with a trailing `…` when over.
+*
+* Exported as `cleanTitle` so tests can pin the normalization rules
+* without going through a mock provider.
+*/
+function cleanTitle(raw) {
+	let s = raw.split("\n")[0]?.trim() ?? "";
+	s = s.replace(/^\s*title\s*[:\-–—]\s*/i, "");
+	if (s.length >= 2) {
+		const first = s.charAt(0);
+		const last = s.charAt(s.length - 1);
+		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`" || first === "“" && last === "”") s = s.slice(1, -1).trim();
+	}
+	s = s.replace(/[.!?]+$/, "").trim();
+	if (s.length === 0) throw new Error("Model returned an empty title.");
+	return s.length > TITLE_MAX_CHARS ? `${s.slice(0, TITLE_MAX_CHARS - 1)}…` : s;
+}
+function clip(text, max) {
+	return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+//#endregion
+//#region src/chat/project-user-paths.ts
+/**
+* Shared search-path builder for project + user config discovery.
+*
+* Both Skills (`skills/<name>/SKILL.md`) and MCP servers (`mcps.json`)
+* follow the same first-found-wins order:
+*
+*   1. `{project-root}/.agents/<sub>`   — project, agnostic convention
+*   2. `{project-root}/.{prefix}/<sub>` — project, zidane (`.zidane` default)
+*   3. `~/.agents/<sub>`                — user, agnostic
+*   4. `~/.{prefix}/<sub>`              — user, zidane
+*
+* `{project-root}` is the git root walked up from `cwd` when present,
+* else `cwd` itself. This pairs with the project-scoped session
+* storage (`resolveStoragePaths`) so all three project-aware surfaces
+* — sessions, mcps, skills — anchor at the same `.{prefix}/`.
+*
+* Centralizing the pattern keeps the four paths in one place — a third
+* discovery surface (hooks, rules, …) gets the same convention for free
+* and stays in lock-step on a prefix bump.
+*/
+/**
+* Resolve the four search paths for a given subdirectory (`skills`,
+* `mcps.json`, …). Returns absolute paths regardless of whether they
+* exist — the caller chooses to `existsSync`-filter or feed straight
+* into a tolerant discovery routine.
+*/
+function projectUserPaths(opts) {
+	const cwd = opts.cwd ?? process.cwd();
+	const home = opts.home ?? homedir();
+	const projectRoot = findGitRoot$1(cwd) ?? cwd;
+	const prefix = (opts.prefix ?? ".zidane").replace(/^\./, "");
+	return [
+		{
+			path: resolve(projectRoot, `.agents/${opts.subPath}`),
+			source: "project"
+		},
+		{
+			path: resolve(projectRoot, `.${prefix}/${opts.subPath}`),
+			source: "project"
+		},
+		{
+			path: resolve(home, `.agents/${opts.subPath}`),
+			source: "user"
+		},
+		{
+			path: resolve(home, `.${prefix}/${opts.subPath}`),
+			source: "user"
+		}
+	];
+}
+//#endregion
+//#region src/chat/mcps-discovery.ts
+/**
+* Search order for `mcps.json` — see {@link projectUserPaths}. Project
+* beats user; the first file found for each (name) wins. Non-existent
+* files are skipped without error.
+*/
+function defaultMcpsConfigPaths(opts = {}) {
+	return projectUserPaths({
+		subPath: "mcps.json",
+		...opts
+	});
+}
+/**
+* Parse one `mcps.json` file. Accepts:
+*   - A raw `McpServerConfig[]` array — host-SDK convention.
+*   - An object with `{ "mcpServers": { name: {...} } }` — Claude Desktop
+*     + many client wrappers. The `mcpServers` value is unwrapped before
+*     normalization (otherwise `normalizeMcpServers` would treat the whole
+*     wrapper as a single server).
+*   - A name-keyed map (`{ fs: {...}, github: {...} }`) — host-SDK
+*     convenience shape.
+*
+* Validation flows through `normalizeMcpServers` so the result matches
+* what `createAgent` accepts. Throws on malformed JSON; the caller decides
+* whether to surface or swallow.
+*/
+function parseMcpsFile(text) {
+	const raw = JSON.parse(text);
+	return normalizeMcpServers(raw && typeof raw === "object" && !Array.isArray(raw) && "mcpServers" in raw ? raw.mcpServers : raw);
+}
+/**
+* Walk the default config paths, parse every file that exists, and return
+* `DiscoveredMcp[]` in source-priority order. Project entries appear
+* before user entries; first occurrence of a `name` wins (later
+* duplicates dropped).
+*
+* Parse errors are logged under `ZIDANE_DEBUG` and the file skipped so a
+* single malformed `mcps.json` can't take down the picker.
+*/
+function discoverProjectMcps(opts = {}) {
+	const paths = defaultMcpsConfigPaths(opts).filter((p) => existsSync(p.path));
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const { path, source } of paths) {
+		let configs;
+		try {
+			configs = parseMcpsFile(readFileSync(path, "utf8"));
+		} catch (err) {
+			if (process.env.ZIDANE_DEBUG) {
+				const cause = err instanceof Error ? err.message : String(err);
+				process.stderr.write(`[zidane/chat] failed to parse "${path}": ${cause}\n`);
+			}
+			continue;
+		}
+		for (const config of configs) {
+			if (seen.has(config.name)) continue;
+			seen.add(config.name);
+			out.push({
+				config,
+				source,
+				path
+			});
+		}
+	}
+	return out;
+}
+/**
+* Map a user-toggled enable list onto the `mcpServers` array the agent
+* receives. Conventions match `buildSkillsConfig`:
+*
+*   - `enabled === undefined` → every discovered server enabled (default).
+*   - `enabled === []`        → no servers (the agent runs MCP-less).
+*   - `enabled === [names]`   → allowlist; servers not in the list are
+*                               dropped.
+*
+* Returns a fresh array — callers can mutate without affecting the
+* underlying discovery list.
+*/
+function buildMcpServers(opts) {
+	if (opts.enabled === void 0) return opts.discovered.map((d) => d.config);
+	if (opts.enabled.length === 0) return [];
+	const allow = new Set(opts.enabled);
+	return opts.discovered.filter((d) => allow.has(d.config.name)).map((d) => d.config);
+}
+//#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/prompt-segments.ts
+/**
+* Split a prompt buffer into word-sized atomic segments suitable for a
+* flex-row + flex-wrap renderer (TUI) or a `display: inline` flow with
+* inline-block chips (GUI). Each chip becomes one segment (atomic —
+* never broken across rows); each plain run is split into "word +
+* trailing space" units so wraps land at clean word boundaries.
+*
+* Robust to:
+*   - Overlapping refs — sorted by start; later refs that overlap are
+*     dropped via the first-wins rule.
+*   - Out-of-bounds refs — dropped entirely when `end > text.length` or
+*     `start >= text.length`. Partial clipping would silently truncate
+*     a chip's label; the caller is in a better position to surface the
+*     mismatch (typically a stale `refs` array referencing a previous text).
+*   - Whitespace-only plain runs — emitted as their own plain segment
+*     so chip-adjacent-to-chip cases keep the original spacing.
+*
+* Word splitter rationale: `\S+\s*` keeps trailing whitespace attached
+* to its preceding word so wrap boundaries land between words (cleanly).
+* A leading-whitespace-only segment is captured by `\s+` so we don't
+* drop it entirely when the plain run starts with a space.
+*/
+function splitPromptSegments(text, refs) {
+	const sorted = [...refs].filter((r) => r.end > r.start && r.start < text.length && r.end <= text.length).sort((a, b) => a.start - b.start);
+	const out = [];
+	let cursor = 0;
+	for (const ref of sorted) {
+		if (ref.start < cursor) continue;
+		if (ref.start > cursor) {
+			const matches = text.slice(cursor, ref.start).match(/\S+\s*|\s+/g) ?? [];
+			for (const m of matches) out.push({
+				kind: "plain",
+				text: m
+			});
+		}
+		out.push({
+			kind: "chip",
+			text: text.slice(ref.start, ref.end),
+			providerId: ref.providerId
+		});
+		cursor = ref.end;
+	}
+	if (cursor < text.length) {
+		const matches = text.slice(cursor).match(/\S+\s*|\s+/g) ?? [];
+		for (const m of matches) out.push({
+			kind: "plain",
+			text: m
+		});
+	}
+	return out;
+}
+//#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/session-export.ts
+const DEFAULT_PREFIX = ".zidane";
+/**
+* Resolve the export target for a session id + format. Pure: no fs
+* write happens here, the caller decides whether to `existsSync` the
+* directory or hand the path to `writeSessionExport`.
+*
+* Anchor selection walks upward from `cwd` looking for a `.git` entry;
+* the first hit anchors to that repo's root (`project`). When the walk
+* exits without finding `.git`, the destination anchors to `home`.
+*
+* @throws RangeError when `sessionId` would resolve to an empty / `..`
+*   filename — defensive guard against malicious or buggy callers
+*   crossing into a sibling directory via the id.
+*/
+function resolveSessionExportTarget(opts) {
+	const cwd = opts.cwd ?? process.cwd();
+	const home = opts.home ?? homedir();
+	const prefix = normalizePrefix(opts.prefix);
+	const filename = exportFilename(opts.sessionId, opts.format);
+	const repoRoot = findGitRoot(cwd);
+	const anchor = repoRoot ? "project" : "home";
+	const dir = resolve(repoRoot ?? home, `.${prefix}`, "sessions");
+	return {
+		dir,
+		filepath: join(dir, filename),
+		anchor
+	};
+}
+/**
+* Render a session into a string in the requested format.
+*
+* `markdown` produces a human-readable transcript: a YAML-free header
+* block with the title and a one-line `id · created · turns` summary,
+* a stats section (turns / runs / tokens / cost / status), then a
+* `## Conversation` block where each turn renders as `### N. role ·
+* run_X · ISO-date` with text, thinking, tool calls, and tool results
+* formatted as appropriate fenced blocks. Useful for sharing a session
+* with a teammate or pasting into an issue tracker.
+*
+* `json` returns a 2-space-indented, deterministic dump of the full
+* `SessionData` blob. Useful for re-importing into the store or for
+* post-hoc analysis tooling.
+*/
+function renderSession(session, format) {
+	if (format === "json") return `${JSON.stringify(session, null, 2)}\n`;
+	return renderMarkdown(session);
+}
+/**
+* Render `session` and write the resulting bytes to disk. Returns the
+* resolved target so the caller can show the user where the file
+* landed. The parent directory is created on demand (`recursive: true`)
+* — first-time exports don't need any pre-flight setup.
+*/
+async function writeSessionExport(opts) {
+	const target = resolveSessionExportTarget({
+		sessionId: opts.session.id,
+		format: opts.format,
+		cwd: opts.cwd,
+		home: opts.home,
+		prefix: opts.prefix
+	});
+	const body = renderSession(opts.session, opts.format);
+	mkdirSync(target.dir, { recursive: true });
+	await writeFile(target.filepath, body, "utf8");
+	return target;
+}
+/**
+* Render a `SessionData` as a clean markdown transcript. Stable across
+* runs (no timestamps or random ids leak into the output beyond what
+* the session itself carries) — diffing two exports of the same
+* session is a no-op.
+*/
+function renderMarkdown(session) {
+	const title = deriveSessionTitle(session.turns, session.metadata);
+	const userTurns = session.turns.filter((t) => t.role === "user").length;
+	const assistantTurns = session.turns.filter((t) => t.role === "assistant").length;
+	const usage = aggregateUsage(session.runs);
+	const lines = [];
+	lines.push(`# ${escapeInline(title)}`);
+	lines.push("");
+	lines.push(`> Session \`${shortId(session.id)}\` · ${session.turns.length} turn${session.turns.length === 1 ? "" : "s"} · ${session.runs.length} run${session.runs.length === 1 ? "" : "s"}`);
+	lines.push("");
+	lines.push("## Metadata");
+	lines.push("");
+	lines.push(`- **id**: \`${session.id}\``);
+	lines.push(`- **created**: ${new Date(session.createdAt).toISOString()}`);
+	lines.push(`- **updated**: ${new Date(session.updatedAt).toISOString()}`);
+	lines.push(`- **status**: ${session.status}`);
+	lines.push(`- **turns**: ${session.turns.length} (${userTurns} user · ${assistantTurns} assistant)`);
+	lines.push(`- **runs**: ${session.runs.length}`);
+	if (usage.total > 0) {
+		const tokenBits = [`in ${fmtTokens(usage.input)}`, `out ${fmtTokens(usage.output)}`];
+		if (usage.cacheRead > 0) tokenBits.push(`cached ${fmtTokens(usage.cacheRead)}`);
+		lines.push(`- **tokens**: ${fmtTokens(usage.total)} (${tokenBits.join(" · ")})`);
+		if (usage.cost > 0) lines.push(`- **cost**: $${usage.cost.toFixed(usage.cost < .01 ? 4 : 2)}`);
+	}
+	lines.push("");
+	lines.push("## Conversation");
+	lines.push("");
+	if (session.turns.length === 0) {
+		lines.push("_No turns recorded yet._");
+		lines.push("");
+		return `${lines.join("\n")}\n`;
+	}
+	session.turns.forEach((turn, idx) => {
+		lines.push(renderTurnHeader(turn, idx + 1));
+		lines.push("");
+		const body = renderTurnBody(turn);
+		if (body) {
+			lines.push(body);
+			lines.push("");
+		}
+	});
+	return `${lines.join("\n").replace(/\n+$/, "\n")}\n`;
+}
+/** `### 1. user · run_1 · 2026-05-13T01:48:29.895Z` */
+function renderTurnHeader(turn, index) {
+	const date = new Date(turn.createdAt).toISOString();
+	const runFragment = turn.runId ? ` · \`${turn.runId}\`` : "";
+	const usageFragment = turn.usage ? ` · ${formatTurnUsage(turn.usage)}` : "";
+	return `### ${index}. ${turn.role}${runFragment} · ${date}${usageFragment}`;
+}
+/** `in 12 · out 48 · cached 1.2k` — only emits non-zero buckets. */
+function formatTurnUsage(usage) {
+	const parts = [];
+	if (usage.input > 0) parts.push(`in ${fmtTokens(usage.input)}`);
+	if (usage.output > 0) parts.push(`out ${fmtTokens(usage.output)}`);
+	if ((usage.cacheRead ?? 0) > 0) parts.push(`cached ${fmtTokens(usage.cacheRead ?? 0)}`);
+	return parts.join(" · ");
+}
+/**
+* Render all blocks of a single turn into a markdown fragment.
+* Block ordering matches the on-disk turn so resume / replay semantics
+* are preserved: tool_call → tool_result pairs stay adjacent, thinking
+* blocks land right before the assistant text they precede.
+*/
+function renderTurnBody(turn) {
+	const parts = [];
+	for (const block of turn.content) {
+		const chunk = renderBlock(block);
+		if (chunk) parts.push(chunk);
+	}
+	return parts.join("\n\n");
+}
+function renderBlock(block) {
+	switch (block.type) {
+		case "text": return block.text.trim() ? block.text.trim() : "";
+		case "thinking": {
+			const text = block.text.trim();
+			if (!text) return "";
+			return `> **thinking**\n>\n${text.split("\n").map((l) => `> ${l}`).join("\n")}`;
+		}
+		case "tool_call": {
+			const args = JSON.stringify(block.input, null, 2);
+			return [
+				`**Tool call** \`${block.name}\` · id \`${block.id}\``,
+				"",
+				"```json",
+				args,
+				"```"
+			].join("\n");
+		}
+		case "tool_result": return [
+			block.isError ? `**Tool result** ✗ error · id \`${block.callId}\`` : `**Tool result** · id \`${block.callId}\``,
+			"",
+			renderToolOutput(block.output)
+		].join("\n");
+		case "image": return `_[image · ${block.mediaType}]_`;
+		default: return "";
+	}
+}
+/**
+* Tool output is either a flat string (the common case) or a structured
+* array of `ToolResultContent` (multimodal tools — screenshots, charts).
+* Strings render as a fenced code block; structured arrays render
+* their text blocks inline with `[image · …]` placeholders for the rest.
+*/
+function renderToolOutput(output) {
+	if (typeof output === "string") {
+		const fence = pickFence(output);
+		return `${fence}\n${output}\n${fence}`;
+	}
+	const segments = [];
+	for (const piece of output) if (piece.type === "text") {
+		const fence = pickFence(piece.text);
+		segments.push(`${fence}\n${piece.text}\n${fence}`);
+	} else segments.push(`_[image · ${piece.mediaType}]_`);
+	return segments.join("\n\n");
+}
+/**
+* Pick a fence (`\`\`\`` or longer) that doesn't collide with any
+* backtick run inside `content`. The CommonMark rule is "a fenced
+* block ends at a fence of the same length or longer made of the same
+* char" — choosing a fence strictly longer than the longest run inside
+* the body avoids accidental termination.
+*/
+function pickFence(content) {
+	let longestRun = 0;
+	let current = 0;
+	for (const ch of content) if (ch === "`") {
+		current++;
+		if (current > longestRun) longestRun = current;
+	} else current = 0;
+	const len = Math.max(3, longestRun + 1);
+	return "`".repeat(len);
+}
+/** Strip control characters from a single-line inline (e.g. the title). */
+function escapeInline(s) {
+	return s.replace(/[\r\n]+/g, " ").trim();
+}
+/**
+* Walk parents of `start` looking for a `.git` entry (file or
+* directory — `.git` is a file inside git worktrees). Returns the
+* directory holding `.git`, or `null` at the filesystem root.
+*/
+function findGitRoot(start) {
+	let dir = resolve(start);
+	for (let i = 0; i < 64; i++) {
+		if (existsSync(join(dir, ".git"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+	return null;
+}
+/** Trim a leading dot from `prefix`. */
+function normalizePrefix(prefix) {
+	return (prefix ?? DEFAULT_PREFIX).replace(/^\./, "");
+}
+/**
+* Compose the on-disk filename for `(sessionId, format)`. Rejects
+* empty ids and path-traversal-ish values so the caller can't escape
+* `.{prefix}/sessions/`.
+*/
+function exportFilename(sessionId, format) {
+	const ext = format === "json" ? "json" : "md";
+	const cleaned = sessionId.trim();
+	if (!cleaned || cleaned.includes("/") || cleaned.includes("\\") || cleaned === "." || cleaned === "..") throw new RangeError(`Refusing to export session — invalid id "${sessionId}"`);
+	return `${cleaned}.${ext}`;
+}
+function aggregateUsage(runs) {
+	const acc = {
+		input: 0,
+		output: 0,
+		cacheRead: 0,
+		cost: 0
+	};
+	for (const run of runs) {
+		if (run.totalUsage) {
+			acc.input += run.totalUsage.input ?? 0;
+			acc.output += run.totalUsage.output ?? 0;
+			acc.cacheRead += run.totalUsage.cacheRead ?? 0;
+		} else if (run.turnUsage) for (const u of run.turnUsage) {
+			acc.input += u.input ?? 0;
+			acc.output += u.output ?? 0;
+			acc.cacheRead += u.cacheRead ?? 0;
+		}
+		if (run.cost) acc.cost += run.cost;
+	}
+	return {
+		...acc,
+		total: acc.input + acc.output
+	};
+}
+//#endregion
+//#region src/chat/skills-discovery.ts
+/**
+* Resolve the default skill scan paths for a project. First-found wins on
+* collision; earlier entries take precedence.
+*
+* Search order — see {@link projectUserPaths}. Non-existent paths are
+* returned so downstream code can choose whether to create them;
+* `discoverSkills` itself skips missing dirs without error.
+*/
+function defaultSkillScanPaths(opts = {}) {
+	return projectUserPaths({
+		subPath: "skills",
+		...opts
+	});
+}
+/**
+* Discover every skill reachable from the default scan paths. Returns
+* parsed `SkillConfig`s with `name`, `description`, frontmatter, and
+* lenient-load diagnostics. Pure I/O — does not activate or write.
+*
+* `signal` is forwarded to `discoverSkills` so the TUI's directory-watch
+* effect can cancel a long scan when the user switches `cwd` rapidly.
+*
+* Errors during parse are surfaced as `diagnostics` on the returned
+* skill, not thrown — keeps the picker usable even when a single
+* SKILL.md is malformed.
+*/
+async function discoverProjectSkills(opts = {}) {
+	return discoverSkills(defaultSkillScanPaths(opts).filter((p) => existsSync(p.path)), opts.signal);
+}
+/**
+* Map a user-toggled enable list onto the format `createAgent` expects.
+*
+* Conventions:
+*   - `enabled === undefined`  → all discovered skills enabled (default).
+*   - `enabled === []`         → fully off; the agent will not scan or
+*                                inject the skills tools.
+*   - `enabled === [names]`    → allowlist; skills not in the list are
+*                                left out of the catalog.
+*
+* `scan` is the resolved scan-path list (passed through verbatim). Pass
+* `defaultSkillScanPaths()` for the standard project + user paths, or
+* supply a host-specific list.
+*/
+function buildSkillsConfig(opts) {
+	const scan = opts.scan.map((p) => p.path);
+	if (opts.enabled !== void 0 && opts.enabled.length === 0) return {
+		scan,
+		enabled: false
+	};
+	return {
+		scan,
+		...opts.enabled ? { enabled: [...opts.enabled] } : {}
+	};
+}
+//#endregion
+//#region src/chat/streaming.ts
+/**
+* Streaming flush cadence. Set to roughly half the renderer's 30fps target
+* (~16fps deltas) so OpenTUI's `MarkdownRenderable` has a full paint frame
+* between content updates. The trailing markdown block is `destroyRecursively`
+* + recreated on every content change while `streaming: true` (parser
+* marks the last 2 blocks unstable); landing those mutations one-per-frame
+* paints partial layout states, which renders as flicker. Pacing at ~60ms
+* gives the renderer time to settle without sacrificing live feel — tokens
+* still appear faster than the user can read.
+*/
+const FLUSH_INTERVAL_MS = 60;
+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, bucket.turnId);
+	if (bucket.markdown) result = appendMarkdownDelta(result, bucket.markdown, bucket.owner, bucket.depth, bucket.turnId);
+	return result;
+}
+function appendMarkdownDelta(prev, delta, owner, depth, turnId) {
+	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, tagEvent({
+		kind: "markdown",
+		text: delta,
+		streaming: true
+	}, owner, depth, turnId)];
+}
+function appendThinkingLines(prev, delta, owner, depth, turnId) {
+	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(tagEvent({
+		kind: "thinking",
+		text: lines[0]
+	}, owner, depth, turnId));
+	for (let i = 1; i < lines.length; i++) result.push(tagEvent({
+		kind: "thinking",
+		text: lines[i]
+	}, owner, depth, turnId));
+	return result;
+}
+function ownerOf(evt) {
+	return evt.childId ?? PARENT_OWNER;
+}
+/**
+* Stamp owner (parent vs subagent) + depth + optional `turnId` onto a
+* freshly-minted event so consumers can identify the producer and the
+* source turn. Parent-owned events leave `childId` / `depth` off to match
+* the prior shape; `turnId` is added whenever the caller provided one.
+*/
+function tagEvent(evt, owner, depth, turnId) {
+	const withTurn = turnId ? {
+		...evt,
+		turnId
+	} : evt;
+	if (owner === PARENT_OWNER) return withTurn;
+	return {
+		...withTurn,
+		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 (source?.turnId) bucket.turnId = source.turnId;
+		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
+//#region src/chat/turn-operations.ts
+/**
+* Fork — keep every turn up to and including `turnId`, then strip any
+* `tool_call` blocks left without a matching `tool_result` in the slice.
+*
+* Semantics:
+*   - Include the selected turn ("branch from HERE" mental model — the
+*     user wants the selected message to be the latest in the fork).
+*   - If the selected turn is an assistant turn with unresolved
+*     `tool_call` blocks (their `tool_result`s live in turns AFTER the
+*     slice), strip those calls. Otherwise the fork would post an
+*     assistant turn with no matching tool results, breaking the next
+*     provider call.
+*   - Drop turns that become empty (all blocks stripped).
+*
+* Returns `null` when `turnId` doesn't exist in `turns` — caller should
+* surface a "turn not found" error rather than silently no-op.
+*/
+function truncateTurnsAt(turns, turnId) {
+	const idx = turns.findIndex((t) => t.id === turnId);
+	if (idx === -1) return null;
+	return stripOrphanToolBlocks(turns.slice(0, idx + 1));
+}
+/**
+* Delete — remove the turn with `turnId` and any tool blocks left
+* orphaned by the removal. Returns `null` when `turnId` doesn't exist.
+*
+* Strategy:
+*   1. Drop the target turn.
+*   2. Scan the remaining turns for `tool_call`s without a matching
+*      `tool_result` (orphaned by removing the user turn that carried
+*      the result), and `tool_result`s without a matching `tool_call`
+*      (orphaned by removing the assistant turn that issued the call).
+*      Strip both sides.
+*   3. Drop turns whose content is now empty.
+*
+* This guarantees the resulting history is protocol-clean — a follow-up
+* `agent.run()` against the modified session can post turns without the
+* provider rejecting the history.
+*/
+function deleteTurnSafely(turns, turnId) {
+	const idx = turns.findIndex((t) => t.id === turnId);
+	if (idx === -1) return null;
+	return stripOrphanToolBlocks([...turns.slice(0, idx), ...turns.slice(idx + 1)]);
+}
+/**
+* Walk a turn list and remove any tool blocks whose counterpart is
+* missing. Drops turns left empty. Used by `truncateTurnsAt` (which can
+* leave `tool_call`s orphaned when their results are past the cut) and
+* `deleteTurnSafely` (which can orphan either side of a pair).
+*
+* Pure / total: returns a new array; never throws.
+*/
+function stripOrphanToolBlocks(turns) {
+	const callIds = /* @__PURE__ */ new Set();
+	const resultIds = /* @__PURE__ */ new Set();
+	for (const turn of turns) for (const block of turn.content) if (block.type === "tool_call") callIds.add(block.id);
+	else if (block.type === "tool_result") resultIds.add(block.callId);
+	const result = [];
+	for (const turn of turns) {
+		const filtered = [];
+		for (const block of turn.content) {
+			if (block.type === "tool_call") {
+				if (!resultIds.has(block.id)) continue;
+			} else if (block.type === "tool_result") {
+				if (!callIds.has(block.callId)) continue;
+			}
+			filtered.push(block);
+		}
+		if (filtered.length === 0) continue;
+		result.push(filtered.length === turn.content.length ? turn : {
+			...turn,
+			content: filtered
+		});
+	}
+	return result;
+}
+/**
+* Serialize a turn's content to a clean text representation suited for
+* the clipboard. Joins text + thinking blocks verbatim; tool calls and
+* tool results get bracketed labels so the user can paste a readable
+* record of what happened without losing structure.
+*
+* Empty turns return `''`.
+*/
+function turnAsText(turn) {
+	const parts = [];
+	for (const block of turn.content) if (block.type === "text" && block.text.trim()) parts.push(block.text);
+	else if (block.type === "thinking" && block.text.trim()) parts.push(`[thinking]\n${block.text}`);
+	else if (block.type === "tool_call") parts.push(`[tool call · ${block.name}]\n${stringifyArgs(block.input)}`);
+	else if (block.type === "tool_result") parts.push(`[tool result]\n${typeof block.output === "string" ? block.output : JSON.stringify(block.output, null, 2)}`);
+	return parts.join("\n\n");
+}
+function stringifyArgs(input) {
+	try {
+		return JSON.stringify(input, null, 2);
+	} catch {
+		return String(input);
+	}
+}
+/**
+* Count turns before / after the one identified by `turnId` in the
+* given list. Returns `null` when the id is missing. Used to label the
+* turn-details modal with `N before · M after`.
+*/
+function countNeighbors(turnIds, turnId) {
+	const idx = turnIds.indexOf(turnId);
+	if (idx === -1) return null;
+	return {
+		before: idx,
+		after: turnIds.length - 1 - idx
+	};
+}
+//#endregion
+export { BUILTIN_THEMES as $, BUILTIN_AGENTS as $t, readProjects as A, applyInsert as At, cleanTitle as B, removeProviderCredential as Bt, useSafeModeQueue as C, findGitRoot$1 as Ct, isOnSafelist as D, FILES_TRIGGER as Dt, getSafelist as E, uniqueSkillNamesFromReferences as Et, supportsOAuth as F, detectAuth as Ft, shortId as G, cerebrasDescriptor as Gt, ageString as H, writeCredentials as Ht, buildMcpServers as I, applyApiKeyEnv as It, DEFAULT_SETTINGS as J, modelsForDescriptor as Jt, listProjectFiles as K, credKeyOf as Kt, defaultMcpsConfigPaths as L, credentialsPath as Lt, writeProjects as M, findActiveTrigger as Mt, splitPromptSegments as N, mergeReferences as Nt, matchesSafelistEntry as O, createFilesCompletionProvider as Ot, runOAuthLogin as P, useCompletion as Pt, useSettings as Q, BUILD_AGENT as Qt, discoverProjectMcps as R, readCredentials as Rt, useSafeModeActions as S, toolResultText as St, addToSafelist as T, createSkillsCompletionProvider as Tt, compactPath as U, BUILTIN_PROVIDERS as Ut, generateSessionTitle as V, setProviderCredential as Vt, fmtTokens as W, anthropicDescriptor as Wt, SETTINGS_TOGGLES as X, openrouterDescriptor as Xt, SETTINGS_CHOICES as Y, openaiDescriptor as Yt, SettingsProvider as Z, piIdOf as Zt, discoverProjectSkills as _, saveState as _t, ThemeProvider as a, CATPPUCCIN_LATTE as at, writeSessionExport as b, titleFromTurns as bt, useSurfaces as c, ConfigProvider as ct, finalizeStreamingMarkdown as d, createStateStore as dt, DEFAULT_AGENT_ID as en, DEFAULT_THEME as et, finalizeStreamingMarkdownForOwner as f, deriveSessionTitle as ft, defaultSkillScanPaths as g, loadState as gt, buildSkillsConfig as h, listSessionMeta as ht, turnAsText as i, CATPPUCCIN_FRAPPE as it, suggestSafelistEntry as j, collectReferences as jt, projectsFilePath as k, uniqueFilesFromReferences as kt, useSyntaxStyles as l, useConfig as lt, useStreamBuffer as m, lastContextSizeFromTurns as mt, deleteTurnSafely as n, resolveAgentId as nn, resolveTheme as nt, useColors as o, CATPPUCCIN_MACCHIATO as ot, turnContextSize as p, eventsFromTurns as pt, useEnabledToggleSet as q, getContextWindow as qt, truncateTurnsAt as r, singleAgentRegistry as rn, VAPORWAVE_THEME as rt, useSelectStyle as s, CATPPUCCIN_MOCHA as st, countNeighbors as t, PLAN_AGENT as tn, resolveChipColor as tt, useTheme as u, resolveConfig as ut, renderSession as v, selectableTurnIds as vt, IMPLICITLY_SAFE_TOOLS as w, SKILLS_TRIGGER as wt, SafeModeProvider as x, toolCallPreview as xt, resolveSessionExportTarget as y, stripSpawnTokensLine as yt, parseMcpsFile as z, readProviderCredential as zt };
+
+//# sourceMappingURL=turn-operations-5aQu4dJg.js.map