zidane 6.6.4 → 7.0.1

package/dist/{turn-operations-mMxDRgLY.js → turn-operations-CZLsNgw-.js}

@@ -1,6 +1,7 @@
 import { i as resolveOldString, o as styleReplacementForVia } from "./context-segments-CJCtJ9sU.js";
 import { r as utf8ByteLength } from "./utils-ngQzYzZD.js";
-import { l as shortId, t as ageString } from "./format-BF745pLL.js";
+import { a as formatDuration, i as fmtTokens, l as shortId, t as ageString } from "./format-BF745pLL.js";
+import { t as escapeXml } from "./xml-D5HBhJle.js";
 import { t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
 import { a as searchHighlightRanges } from "./history-search-C4bk1Wz_.js";
 import { Fzf } from "fzf";
@@ -1011,6 +1012,510 @@ function filetypeFromPath(path) {
 	const ext = cleaned.slice(lastDot + 1).toLowerCase();
 	return FILETYPE_BY_EXT[ext];
 }
+/** `1.2k` / `48k` / `1.3M` — token counts are read at a glance, not counted. */
+function formatTokenCount(tokens) {
+	if (tokens >= 1e6) return `${(tokens / 1e6).toFixed(1)}M`;
+	if (tokens >= 1e3) return `${(tokens / 1e3).toFixed(tokens >= 1e4 ? 0 : 1)}k`;
+	return String(tokens);
+}
+/** `2m18s` / `48s` / `<1s` / `1h05m`. Compact — this is a receipt, not a profiler. */
+function formatRunDuration(ms) {
+	if (ms < 1e3) return "<1s";
+	const s = Math.round(ms / 1e3);
+	if (s < 60) return `${s}s`;
+	const m = Math.floor(s / 60);
+	const rest = s % 60;
+	if (m < 60) return rest ? `${m}m${String(rest).padStart(2, "0")}s` : `${m}m`;
+	return `${Math.floor(m / 60)}h${String(m % 60).padStart(2, "0")}m`;
+}
+/** `$0.04`, or four decimals under a cent so a cheap run is not shown as `$0.00`. */
+function formatCostUsd(cost) {
+	return `$${cost.toFixed(cost < .01 ? 4 : 2)}`;
+}
+/**
+* Build the receipt for a run record. `now` stands in for `endedAt` when the
+* record is not finalized yet (`run:end` is broadcast a beat before it is).
+*/
+function runReceiptFromRun(run, now = Date.now()) {
+	const sumIn = (u) => u.input + (u.cacheRead ?? 0) + (u.cacheCreation ?? 0);
+	const usage = run.totalUsage ? {
+		input: sumIn(run.totalUsage),
+		output: run.totalUsage.output
+	} : run.turnUsage?.reduce((acc, u) => ({
+		input: acc.input + sumIn(u),
+		output: acc.output + u.output
+	}), {
+		input: 0,
+		output: 0
+	});
+	const models = (run.turnUsage ?? []).map((u) => u.modelId).filter((m) => typeof m === "string" && m.length > 0);
+	const modelId = models.at(-1);
+	const otherModels = modelId ? new Set(models).size - 1 : 0;
+	const durationMs = (run.endedAt ?? now) - run.startedAt;
+	const cost = run.cost ?? run.turnUsage?.reduce((n, u) => n + (u.cost ?? 0), 0) ?? 0;
+	const turns = run.turns ?? run.turnUsage?.length ?? 0;
+	let genMs = 0;
+	let genOut = 0;
+	for (const u of run.turnUsage ?? []) {
+		if (u.streamDurationMs === void 0 || u.output <= 0) continue;
+		const ms = u.streamDurationMs - (u.timeToFirstTokenMs ?? 0);
+		if (ms <= 0) continue;
+		genMs += ms;
+		genOut += u.output;
+	}
+	const tokensPerSecond = genMs > 0 && genOut > 0 ? genOut * 1e3 / genMs : void 0;
+	return {
+		...modelId ? { modelId } : {},
+		...otherModels > 0 ? { otherModels } : {},
+		...durationMs > 0 ? { durationMs } : {},
+		...turns > 0 ? { turns } : {},
+		...cost > 0 ? { costUsd: cost } : {},
+		...usage && usage.input > 0 ? { tokensIn: usage.input } : {},
+		...usage && usage.output > 0 ? { tokensOut: usage.output } : {},
+		...tokensPerSecond !== void 0 ? { tokensPerSecond } : {}
+	};
+}
+/** `42 tk/s`; one decimal under 10 so a slow model is not shown as `0 tk/s`. */
+function formatTokensPerSecond(tps) {
+	return `${tps < 10 ? tps.toFixed(1) : Math.round(tps).toString()} tk/s`;
+}
+/**
+* The receipt's cells, in display order. Renderers join them with their own
+* separator, tint them by `kind`, and truncate to their own width; the CONTENT
+* is fixed here.
+*/
+function formatRunReceiptCells(r) {
+	const cells = [];
+	if (r.modelId) cells.push({
+		kind: "model",
+		text: r.otherModels ? `${r.modelId} +${r.otherModels}` : r.modelId
+	});
+	if (r.durationMs !== void 0) cells.push({
+		kind: "duration",
+		text: formatRunDuration(r.durationMs)
+	});
+	if (r.turns !== void 0) cells.push({
+		kind: "turns",
+		text: `↻${r.turns}`
+	});
+	if (r.costUsd !== void 0) cells.push({
+		kind: "cost",
+		text: formatCostUsd(r.costUsd)
+	});
+	if (r.tokensIn !== void 0 || r.tokensOut !== void 0) {
+		const segments = [{
+			kind: "tokens-in",
+			text: `↑${formatTokenCount(r.tokensIn ?? 0)}`
+		}, {
+			kind: "tokens-out",
+			text: `↓${formatTokenCount(r.tokensOut ?? 0)}`
+		}];
+		cells.push({
+			kind: "tokens",
+			text: segments.map((seg) => seg.text).join(" "),
+			segments
+		});
+	}
+	if (r.tokensPerSecond !== void 0) cells.push({
+		kind: "speed",
+		text: formatTokensPerSecond(r.tokensPerSecond)
+	});
+	return cells;
+}
+/** The glyph that leads the line on every surface. */
+const RUN_RECEIPT_GLYPH = "≡";
+/**
+* Fit cells to `width` columns for a tinted renderer: returns the cells that
+* fit whole, plus whether the last one was cut. A cut cell is truncated with
+* `…`; anything after it is dropped. Never wraps. `prefix` is the columns the
+* renderer already spent (glyph + space).
+*/
+function fitRunReceiptCells(cells, width, prefix = 0) {
+	let used = prefix;
+	const out = [];
+	for (const cell of cells) {
+		const need = (out.length ? 3 : 0) + cell.text.length;
+		if (used + need <= width) {
+			out.push(cell);
+			used += need;
+			continue;
+		}
+		const room = width - used - (out.length ? 3 : 0);
+		if (room >= 2) out.push({
+			kind: cell.kind,
+			text: `${cell.text.slice(0, room - 1).trimEnd()}…`
+		});
+		break;
+	}
+	return out;
+}
+/** One line, ` · `-joined, ellipsized to `width` columns. Never wraps. */
+function formatRunReceiptLine(r, width = Number.POSITIVE_INFINITY) {
+	const line = formatRunReceiptCells(r).map((c) => c.text).join(" · ");
+	if (line.length <= width) return line;
+	if (width <= 1) return width === 1 ? "…" : "";
+	return `${line.slice(0, width - 1).trimEnd()}…`;
+}
+/** Anything to show? A run with no record data renders no line at all. */
+function hasRunReceipt(r) {
+	return formatRunReceiptCells(r).length > 0;
+}
+//#endregion
+//#region src/chat/orchestration.ts
+/**
+* Orchestration — the pure model for a "main" session that drives others.
+*
+* A main session is an ordinary session with a role, and a worker is an
+* ordinary session with a parent pointer. Both are `metadata` keys, so every
+* existing surface (sidebar, history, attach, search, replay) works on them
+* with no special cases; only the surfaces that WANT to treat them specially
+* (pinning, the event row, the jump shortcut) read these keys.
+*
+* This is deliberately not `spawn`. A spawned child is ephemeral, inline, and
+* dies with the parent's run; a worker is a persistent, resumable session with
+* its own cwd, model chain, todos and history, visible in every window, and it
+* outlives the main's run. The parent pointer is what makes them a tree.
+*
+* Node-free: re-exported from `zidane/chat/pure` for the Electron renderer,
+* which needs `isMainSession` / `orchestratedBy` for pinning and the event row.
+*/
+/** Title the main session is created with. Users can rename it; the ROLE is what matters. */
+const MAIN_SESSION_TITLE = "Main";
+/** `session.metadata.role` — present and `'main'` on the one orchestrating session. */
+const SESSION_ROLE_KEY = "role";
+/** `session.metadata.orchestratedBy` — the main session's id, on a worker. */
+const ORCHESTRATED_BY_KEY = "orchestratedBy";
+/** Type guard over untrusted metadata. */
+function isMainSession(metadata) {
+	return metadata?.[SESSION_ROLE_KEY] === "main";
+}
+/** The main session id a worker reports to, or `null` for an ordinary session. */
+function orchestratedBy(metadata) {
+	const value = metadata?.[ORCHESTRATED_BY_KEY];
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+/** Tools whose `path` input means "this file changed". */
+const CHANGE_TOOLS = /* @__PURE__ */ new Set([
+	"edit",
+	"multi_edit",
+	"write_file"
+]);
+const ARTIFACT_PATH_CAP = 12;
+/**
+* What a run touched, read off its assistant turns' tool calls. Only the
+* tools that MUTATE count as "changed" — reads are not artifacts. Capped so a
+* refactor across a hundred files does not turn the event into a manifest;
+* the count still tells the truth.
+*/
+function artifactsFromTurns(turns) {
+	const changed = [];
+	const seen = /* @__PURE__ */ new Set();
+	let commands = 0;
+	let toolCalls = 0;
+	for (const turn of turns) {
+		if (turn.role !== "assistant") continue;
+		for (const block of turn.content) {
+			if (block.type !== "tool_call" || !block.name) continue;
+			toolCalls++;
+			if (block.name === "shell") commands++;
+			if (CHANGE_TOOLS.has(block.name)) {
+				const path = block.input?.path;
+				if (typeof path === "string" && path && !seen.has(path)) {
+					seen.add(path);
+					changed.push(path);
+				}
+			}
+		}
+	}
+	if (toolCalls === 0) return void 0;
+	return {
+		changed: changed.slice(0, ARTIFACT_PATH_CAP),
+		commands,
+		toolCalls
+	};
+}
+const STATUSES = [
+	"done",
+	"error",
+	"cancelled",
+	"needs-attention"
+];
+/**
+* Wire format between the harness and the model — and, because it is persisted
+* inside the user turn's text block, between a live session and its replay.
+*
+* Follows `<task-notification>` exactly: child-tag XML, one block per event,
+* escaped with `escapeXml`. The model already knows this shape as "the harness
+* telling me something", which is the point — a main that mistook a worker
+* report for a human instruction would act on it as one. `eventsFromTurns`
+* detects the block on replay and re-synthesizes the structured row instead of
+* painting the raw XML as a user prompt.
+*/
+function renderSessionEventXml(event) {
+	const tag = (name, value) => value === void 0 ? [] : [`  <${name}>${escapeXml(String(value))}</${name}>`];
+	return [
+		"<session-event>",
+		...tag("session-id", event.sessionId),
+		...tag("title", event.title),
+		...tag("status", event.status),
+		...tag("at", event.at),
+		...tag("cwd", event.cwd ?? ""),
+		...tag("cost-usd", event.costUsd),
+		...tag("duration-ms", event.durationMs),
+		...tag("tokens", event.tokens),
+		...tag("turns", event.turns),
+		...tag("worker", event.worker === void 0 ? void 0 : String(event.worker)),
+		...tag("seq", event.seq),
+		...tag("finish-reason", event.finishReason),
+		...tag("error", event.error),
+		...tag("detail", event.detail),
+		...tag("goal", event.goal),
+		...event.artifacts ? [
+			`  <artifacts tool-calls="${event.artifacts.toolCalls}" commands="${event.artifacts.commands}">`,
+			...event.artifacts.changed.map((p) => `    <changed>${escapeXml(p)}</changed>`),
+			"  </artifacts>"
+		] : [],
+		...tag("summary", event.summary),
+		"</session-event>"
+	].join("\n");
+}
+const SESSION_EVENT_RE = /^\s*<session-event>([\s\S]*?)<\/session-event>\s*$/;
+const FIELD = {
+	sessionId: /<session-id>([\s\S]*?)<\/session-id>/,
+	title: /<title>([\s\S]*?)<\/title>/,
+	status: /<status>([\s\S]*?)<\/status>/,
+	at: /<at>([\s\S]*?)<\/at>/,
+	cwd: /<cwd>([\s\S]*?)<\/cwd>/,
+	costUsd: /<cost-usd>([\s\S]*?)<\/cost-usd>/,
+	durationMs: /<duration-ms>([\s\S]*?)<\/duration-ms>/,
+	tokens: /<tokens>([\s\S]*?)<\/tokens>/,
+	turns: /<turns>([\s\S]*?)<\/turns>/,
+	worker: /<worker>([\s\S]*?)<\/worker>/,
+	error: /<error>([\s\S]*?)<\/error>/,
+	detail: /<detail>([\s\S]*?)<\/detail>/,
+	seq: /<seq>([\s\S]*?)<\/seq>/,
+	goal: /<goal>([\s\S]*?)<\/goal>/,
+	finishReason: /<finish-reason>([\s\S]*?)<\/finish-reason>/,
+	artifacts: /<artifacts tool-calls="(\d+)" commands="(\d+)">([\s\S]*?)<\/artifacts>/,
+	summary: /<summary>([\s\S]*?)<\/summary>/
+};
+const CHANGED_RE = /<changed>([\s\S]*?)<\/changed>/g;
+const FINISH_REASONS = /* @__PURE__ */ new Set([
+	"length",
+	"pause",
+	"content-filter"
+]);
+/**
+* Inverse of {@link renderSessionEventXml}. Untrusted input — it comes off disk
+* and outlives this module's versions — so it validates each field and returns
+* `null` for anything malformed, in which case the turn replays as the plain
+* user text it structurally is.
+*/
+function parseSessionEventXml(text) {
+	const m = text.match(SESSION_EVENT_RE);
+	if (!m) return null;
+	const body = m[1];
+	const pick = (re) => {
+		const inner = body.match(re);
+		return inner ? unescapeXml(inner[1].trim()) : void 0;
+	};
+	const sessionId = pick(FIELD.sessionId);
+	const title = pick(FIELD.title);
+	const status = pick(FIELD.status);
+	const at = Number(pick(FIELD.at));
+	const summary = pick(FIELD.summary);
+	if (!sessionId || title === void 0 || summary === void 0) return null;
+	if (!status || !STATUSES.includes(status)) return null;
+	if (!Number.isFinite(at)) return null;
+	const cost = Number(pick(FIELD.costUsd));
+	const cwd = pick(FIELD.cwd);
+	const positive = (raw) => {
+		const n = Number(raw);
+		return Number.isFinite(n) && n > 0 ? n : void 0;
+	};
+	const durationMs = positive(pick(FIELD.durationMs));
+	const tokens = positive(pick(FIELD.tokens));
+	const turns = positive(pick(FIELD.turns));
+	const worker = pick(FIELD.worker);
+	const error = pick(FIELD.error);
+	const detail = pick(FIELD.detail);
+	const seq = positive(pick(FIELD.seq));
+	const goal = pick(FIELD.goal);
+	const finishReason = pick(FIELD.finishReason);
+	const art = body.match(FIELD.artifacts);
+	const artifacts = art ? {
+		toolCalls: Number(art[1]),
+		commands: Number(art[2]),
+		changed: [...art[3].matchAll(CHANGED_RE)].map((m) => unescapeXml(m[1].trim()))
+	} : void 0;
+	return {
+		sessionId,
+		title,
+		status,
+		summary,
+		at,
+		...Number.isFinite(cost) && cost > 0 ? { costUsd: cost } : {},
+		...cwd !== void 0 ? { cwd } : {},
+		...durationMs !== void 0 ? { durationMs } : {},
+		...tokens !== void 0 ? { tokens } : {},
+		...turns !== void 0 ? { turns } : {},
+		...worker === "true" ? { worker: true } : worker === "false" ? { worker: false } : {},
+		...error ? { error } : {},
+		...detail ? { detail } : {},
+		...seq !== void 0 ? { seq } : {},
+		...goal ? { goal } : {},
+		...finishReason && FINISH_REASONS.has(finishReason) ? { finishReason } : {},
+		...artifacts ? { artifacts } : {}
+	};
+}
+function unescapeXml(s) {
+	return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+/**
+* The short label a transcript row shows — `api-refactor · done`. Status words
+* are chosen to read as a verb phrase after the title.
+*/
+function sessionEventLabel(event) {
+	return `${event.title} ${{
+		"done": "finished",
+		"error": "failed",
+		"cancelled": "was cancelled",
+		"needs-attention": "needs attention"
+	}[event.status]}`;
+}
+/**
+* Status → how it reads. `needs-attention` is deliberately the loudest: it is
+* the one status where the human, not the main, has to act.
+*/
+const SESSION_EVENT_STATUS_STYLE = {
+	"done": {
+		glyph: "✓",
+		tone: "accent",
+		verb: "finished"
+	},
+	"error": {
+		glyph: "✗",
+		tone: "error",
+		verb: "failed"
+	},
+	"cancelled": {
+		glyph: "⊘",
+		tone: "dim",
+		verb: "was cancelled"
+	},
+	"needs-attention": {
+		glyph: "!",
+		tone: "warn",
+		verb: "needs your input"
+	}
+};
+/**
+* The directory name a session lives in — the same basename label the sidebar
+* groups by. `undefined` for a directory-less session (the main) or no cwd.
+*/
+function sessionDirLabel(cwd) {
+	if (!cwd) return void 0;
+	const parts = cwd.split(/[\\/]+/).filter(Boolean);
+	return parts[parts.length - 1];
+}
+/** Short, stable id fragment for the header — enough to disambiguate, not to read. */
+function shortSessionId(id) {
+	return id.length <= 8 ? id : id.slice(0, 8);
+}
+/**
+* The header's metadata cells, in display order, omitting anything unknown.
+* Renderers join them with their own separator; the CONTENT is fixed here so
+* both surfaces show the same receipt for the same run.
+*
+* The session id is deliberately NOT a cell: it is the least legible datum and
+* exists only to disambiguate. Renderers append `shortSessionId` LAST and
+* dimmer than the rest.
+*/
+function sessionEventMeta(event) {
+	const cells = [];
+	const dir = sessionDirLabel(event.cwd);
+	if (dir) cells.push(dir);
+	if (event.durationMs !== void 0) cells.push(formatRunDuration(event.durationMs));
+	if (event.tokens !== void 0) cells.push(`${formatTokenCount(event.tokens)} tok`);
+	if (event.turns !== void 0) cells.push(`${event.turns} turn${event.turns === 1 ? "" : "s"}`);
+	if (event.costUsd !== void 0) cells.push(formatCostUsd(event.costUsd));
+	return cells;
+}
+/**
+* The dimmed second line: the last thing the session said, collapsed to one
+* paragraph and capped. Renderers may clamp further (line-clamp in the GUI,
+* width in the TUI); this is the upper bound and the shared ellipsis rule.
+*/
+function sessionEventExcerpt(event, max = 240) {
+	const flat = (event.status === "needs-attention" && event.detail ? event.detail : event.status === "error" && event.error ? event.error : event.summary).replace(/\s+/g, " ").trim();
+	return flat.length <= max ? flat : `${flat.slice(0, max - 1).trimEnd()}…`;
+}
+/** Ellipsize a title to `max` characters; titles are user text and can be a paragraph. */
+function truncateTitle(title, max = 48) {
+	const flat = title.replace(/\s+/g, " ").trim();
+	return flat.length <= max ? flat : `${flat.slice(0, max - 1).trimEnd()}…`;
+}
+/**
+* System-prompt fragment appended to every WORKER's agent. A worker's last
+* message becomes the main's `summary`, so it must be a report, not a sign-off
+* — the main should be able to act on it without reading the transcript.
+*/
+const WORKER_REPORT_FRAGMENT = `You are a worker session created by an orchestrating main session. Your final message of a run is delivered to it verbatim as your report, so end every run with a short structured report:
+
+## Report
+- **Goal**: what you were asked, in one line
+- **Outcome**: done / partial / blocked — one line, and why if not done
+- **Changed**: files or artifacts touched (paths), or "none"
+- **Checks**: what you ran and the result (tests, typecheck, lint), or "none"
+- **Open questions**: anything the main or a human must decide, or "none"
+- **Next**: the concrete next step you recommend, or "none"
+
+Keep it factual and under ~15 lines. This block is what the main decides on; prose before it is fine, prose instead of it is not.`;
+/**
+* System-prompt fragment appended to the MAIN's agent: how to delegate without
+* wasting calls. The `sessions` tool description says what each verb does;
+* this says which one to reach for, and when not to call at all.
+*/
+const MAIN_PLAYBOOK_FRAGMENT = `You are the main session: an orchestrator. Work happens in worker sessions; you brief them, integrate their reports, and keep the human informed. Do not do the workers' work here.
+
+Work efficiently with the \`sessions\` tool:
+- Never poll. After create or send you WILL receive a <session-event> when the worker finishes, fails, or blocks. Do not read or list a worker that has not reported yet.
+- Reuse before creating. To continue work in a project, send to its existing idle session (listed under Projects below; its context is already warm). Create a worker only for a new, independent unit of work, or when the project has no suitable session.
+- You already know the ids. Take them from Projects below, from a <session-event>, or from an earlier list. Do not list just to find an id you have.
+- send vs steer: send when the worker is idle or the new prompt should queue after its current run; steer only to change course mid-run.
+- Fire-and-forget when you can. For work you will not act on when it lands (docs, cleanup, low-stakes checks), pass wake: false on create or send; the report still reaches your history, you just are not woken for it.
+- Brief completely. A worker prompt states the goal, the constraints, what to check (tests, typecheck, lint), and that it must end with its report. Follow-up questions cost a full round trip.
+- read is cheap (last message); transcript is not. Use transcript only when a report is unclear.
+- Report to the human briefly: what went where, what came back, what needs a decision. Do not re-narrate worker reports.`;
+/**
+* The main's "Projects" briefing: which directories have ongoing work and
+* the session to address in each, so the main does not rediscover them with
+* a list call every run. Snapshot at agent start — live state is one `list`
+* away and the text says so.
+*/
+function renderProjectsBriefing(projects, now) {
+	const lines = ["## Projects", "Known as of this session's start; live state comes from `sessions list`. Directory-less sessions are omitted."];
+	if (projects.length === 0) {
+		lines.push("- none yet");
+		return lines.join("\n");
+	}
+	for (const p of projects) {
+		const cells = [`${p.sessions} session${p.sessions === 1 ? "" : "s"}`, `last active ${agoLabel(now - p.lastActiveAt)}`];
+		if (p.active > 0) cells.push(`${p.active} active`);
+		lines.push(`- ${sessionDirLabel(p.root) ?? p.root} — ${p.root} · ${cells.join(" · ")}`);
+		lines.push(`  latest: ${p.latest.sessionId} "${truncateTitle(p.latest.title, 60)}" (${p.latest.state})`);
+	}
+	return lines.join("\n");
+}
+/** Coarse relative time for the briefing: `just now`, `12m ago`, `3h ago`, `5d ago`. */
+function agoLabel(elapsedMs) {
+	const m = Math.floor(Math.max(0, elapsedMs) / 6e4);
+	if (m < 1) return "just now";
+	if (m < 60) return `${m}m ago`;
+	const h = Math.floor(m / 60);
+	if (h < 48) return `${h}h ago`;
+	return `${Math.floor(h / 24)}d ago`;
+}
 //#endregion
 //#region src/chat/turn-selection.ts
 /** Tools whose `tool-result` event is suppressed when `showEditDiffs` is on. */
@@ -1111,24 +1616,48 @@ function promptHistoryFromEvents(events) {
 * can cheaply skip a re-render.
 */
 function retagUserPromptEvents(events, appendedTurns) {
+	return retagUserPromptEventsFromRefs(events, promptTurnRefs(appendedTurns));
+}
+/**
+* Reduce persisted turns to the prompt refs the retag needs, dropping
+* non-prompt turns (assistant, tool results) entirely.
+*
+* Shared by the in-process path and the daemon broadcast so both select the
+* same turns as "prompts" — a divergence here would make a prompt selectable
+* on one surface and not the other.
+*/
+function promptTurnRefs(turns) {
 	const isMediaBlock = (b) => b.type === "document" || b.type === "image" || b.type === "audio" || b.type === "video";
 	const hasPromptText = (t) => t.content.some((b) => b.type === "text" && b.text.trim().length > 0);
 	const isAttachmentOnly = (t) => t.content.some(isMediaBlock) && !t.content.some((b) => b.type === "tool_result");
-	const promptTurns = appendedTurns.filter((t) => t.role === "user" && (hasPromptText(t) || isAttachmentOnly(t)));
-	if (promptTurns.length === 0) return events;
+	return turns.filter((t) => t.role === "user" && (hasPromptText(t) || isAttachmentOnly(t))).map((turn) => ({
+		id: turn.id,
+		texts: [...turn.content.filter((b) => b.type === "text").map((b) => b.text), ...turn.display ? [turn.display] : []],
+		attachmentOnly: !hasPromptText(turn) && isAttachmentOnly(turn)
+	}));
+}
+/**
+* Attach persisted turn ids to the live `user-prompt` events they correspond
+* to, so a just-sent prompt becomes selectable (hover, click, edit, delete)
+* without waiting for a session reload.
+*
+* Matching is newest-first and one-to-one: identical prompt text sent twice
+* must bind to two different turns, so each ref consumes exactly one untagged
+* event.
+*/
+function retagUserPromptEventsFromRefs(events, refs) {
+	if (refs.length === 0) return events;
 	let changed = false;
 	const next = [...events];
-	for (const turn of promptTurns) {
-		const texts = new Set(turn.content.filter((b) => b.type === "text").map((b) => b.text));
-		if (turn.display) texts.add(turn.display);
-		const matchesBlank = !hasPromptText(turn) && isAttachmentOnly(turn);
+	for (const ref of refs) {
+		const texts = new Set(ref.texts);
 		for (let i = next.length - 1; i >= 0; i--) {
 			const e = next[i];
 			if (e.kind !== "user-prompt" || e.turnId) continue;
-			if (texts.has(e.text) || matchesBlank && e.text.trim().length === 0 && (e.attachments?.length ?? 0) > 0) {
+			if (texts.has(e.text) || ref.attachmentOnly && e.text.trim().length === 0 && (e.attachments?.length ?? 0) > 0) {
 				next[i] = {
 					...e,
-					turnId: turn.id
+					turnId: ref.id
 				};
 				changed = true;
 				break;
@@ -1172,6 +1701,7 @@ function isVisible(event, settings) {
 		case "thinking": return settings.showThinking;
 		case "tool": return settings.toolCallDisplay !== "hidden" || isUserBashEvent(event);
 		case "tool-result": return settings.showToolResults || isUserBashEvent(event);
+		case "run-summary": return settings.showRunReceipt;
 		default: return true;
 	}
 }
@@ -1835,6 +2365,254 @@ function uniqueSkillNamesFromReferences(references) {
 	return out;
 }
 //#endregion
+//#region src/chat/model-chain.ts
+/** Identity of a chain entry — the pair, not object identity. */
+function chainEntryKey(entry) {
+	return `${entry.provider}\u0000${entry.model}`;
+}
+/** Toggle `entry`: absent → appended, present → removed. Pure. */
+function toggleKeyed(chain, entry, keyOf) {
+	const key = keyOf(entry);
+	const idx = chain.findIndex((e) => keyOf(e) === key);
+	if (idx === -1) return [...chain, entry];
+	return [...chain.slice(0, idx), ...chain.slice(idx + 1)];
+}
+/**
+* Make `entry` the primary (position 0), keeping the rest in order. Inserts
+* when absent, promotes when present; no-op when it already leads.
+*
+* This is `↵` in the picker. It exists because toggling APPENDS: with a chain
+* of `[current]`, toggling a new model produced `[current, new]` — the pick
+* became a fallback and the active model never changed. "Highlight and ↵"
+* means "use this one", so that gesture promotes; building a fallback list is
+* the secondary gesture (`⇥`) and keeps toggle semantics.
+*/
+function pickPrimaryKeyed(chain, entry, keyOf) {
+	const key = keyOf(entry);
+	return [entry, ...chain.filter((e) => keyOf(e) !== key)];
+}
+/** 1-based position of `key` in the chain, or `null` when absent. */
+function positionKeyed(chain, key, keyOf) {
+	const idx = chain.findIndex((e) => keyOf(e) === key);
+	return idx === -1 ? null : idx + 1;
+}
+/** Same entries in the same order. */
+function chainsEqualKeyed(a, b, keyOf) {
+	return a.length === b.length && a.every((e, i) => keyOf(e) === keyOf(b[i]));
+}
+/** Move the entry with `key` by one priority slot; boundary or missing = identity. */
+function reorderKeyed(chain, key, delta, keyOf) {
+	const from = chain.findIndex((e) => keyOf(e) === key);
+	const to = from + delta;
+	if (from < 0 || to < 0 || to >= chain.length) return chain;
+	const next = [...chain];
+	const [entry] = next.splice(from, 1);
+	next.splice(to, 0, entry);
+	return next;
+}
+function toggleChainEntry(chain, entry) {
+	return toggleKeyed(chain, entry, chainEntryKey);
+}
+function pickChainPrimary(chain, entry) {
+	return pickPrimaryKeyed(chain, entry, chainEntryKey);
+}
+/** 1-based chain position of a provider+model pair, or `null` when not in the chain. */
+function chainPositionOf(chain, provider, model) {
+	return positionKeyed(chain, chainEntryKey({
+		provider,
+		model
+	}), chainEntryKey);
+}
+function chainsEqual(a, b) {
+	return chainsEqualKeyed(a, b, chainEntryKey);
+}
+/**
+* Did the SET of provider keys change between two chains? The agent is
+* built with one provider instance per distinct chain key, so a set
+* change requires a session re-activation (rebuild); a pure model /
+* order change within the same providers does not.
+*/
+function providerKeySetChanged(prev, next) {
+	const prevKeys = new Set(prev.map((e) => e.provider));
+	const nextKeys = new Set(next.map((e) => e.provider));
+	if (prevKeys.size !== nextKeys.size) return true;
+	for (const k of nextKeys) if (!prevKeys.has(k)) return true;
+	return false;
+}
+/**
+* Assemble the `agent.run` `model` option from a chain.
+*
+* - Single-entry chain → the bare model id string (byte-identical to the
+*   pre-chain behavior).
+* - Multi-entry chain → pinned `{ provider, model }` targets, where
+*   `provider` is the runtime `Provider.name` resolved via
+*   `providerNameFor` (chain entries carry chat-level `ProviderKey`s,
+*   which need not equal the instance names the agent loop matches on).
+*
+* Throws only on an empty chain — a programmer error, since chains
+* always carry a primary. Stale or unresolvable entries degrade
+* defensively instead (never throw, never produce an entry the agent
+* would reject):
+* - Entries whose key has no resolvable name (provider not constructed
+*   into the current agent) are dropped.
+* - If the PRIMARY itself doesn't resolve, or fewer than two entries
+*   survive, fall back to the bare primary model string.
+*
+* `contextWindowFor` (optional) stamps each target with its model's
+* context window from the host catalog, so the loop re-bases the
+* auto-compact trigger when a fallback advances onto it (the host's
+* explicit window is sized for the PRIMARY otherwise).
+*/
+function buildRunModel(chain, providerNameFor, contextWindowFor) {
+	const primary = chain[0];
+	if (!primary) throw new Error("buildRunModel: chain must not be empty");
+	if (chain.length === 1 || providerNameFor(primary.provider) === void 0) return primary.model;
+	const resolved = [];
+	for (const entry of chain) {
+		const name = providerNameFor(entry.provider);
+		if (name === void 0) continue;
+		const contextWindow = contextWindowFor?.(entry);
+		resolved.push({
+			provider: name,
+			model: entry.model,
+			...typeof contextWindow === "number" && contextWindow > 0 ? { contextWindow } : {}
+		});
+	}
+	return resolved.length > 1 ? resolved : primary.model;
+}
+/**
+* Validate a persisted chain read back from `state.json`. The state file
+* is user-editable JSON, so the value can be arbitrarily malformed —
+* return only the well-shaped `{ provider, model }` entries (both
+* non-empty strings), or `[]` for anything else. Never throws.
+*/
+function sanitizeModelChain(value) {
+	if (!Array.isArray(value)) return [];
+	const entries = [];
+	for (const item of value) {
+		if (typeof item !== "object" || item === null || !("provider" in item) || !("model" in item)) continue;
+		const { provider, model } = item;
+		if (typeof provider === "string" && provider.length > 0 && typeof model === "string" && model.length > 0) entries.push({
+			provider,
+			model
+		});
+	}
+	return entries;
+}
+/**
+* Restore the fallback tail of a persisted chain for a resolved primary
+* pair. Returns entries 1+ only when the persisted chain's entry 0
+* matches `primary` — a divergent chain belongs to a different selection
+* (e.g. a `--model` launch override) and silently attaching it would
+* surprise. Entries whose provider isn't registered, entries equal to
+* the primary, and exact duplicates drop. Accepts the raw persisted
+* value (`state.json` is user-editable) — shape validation included.
+*/
+function restoreChainFallbacks(saved, primary, isRegistered) {
+	const chain = sanitizeModelChain(saved);
+	const head = chain[0];
+	if (chain.length < 2 || !head || head.provider !== primary.provider || head.model !== primary.model) return [];
+	return filterChainFallbacks(chain.slice(1), primary, isRegistered);
+}
+/**
+* Filter candidate fallback entries against a primary pair, preserving
+* picked order: entries whose provider `isAvailable` rejects, entries
+* equal to the primary, and exact duplicates drop. Shared by the
+* picker's apply path (live-auth availability) and persisted-chain
+* restore (registry availability).
+*/
+function filterChainFallbacks(entries, primary, isAvailable) {
+	const fallbacks = [];
+	for (const entry of entries) {
+		if (!isAvailable(entry.provider)) continue;
+		if (entry.provider === primary.provider && entry.model === primary.model) continue;
+		if (fallbacks.some((f) => f.provider === entry.provider && f.model === entry.model)) continue;
+		fallbacks.push({
+			provider: entry.provider,
+			model: entry.model
+		});
+	}
+	return fallbacks;
+}
+//#endregion
+//#region src/chat/daemon-health.ts
+const DAEMON_HEALTH_GLYPH = "●";
+const DAEMON_HEALTH_STYLE = {
+	connected: {
+		tone: "accent",
+		label: "daemon connected"
+	},
+	connecting: {
+		tone: "warn",
+		label: "connecting to daemon…"
+	},
+	disconnected: {
+		tone: "error",
+		label: "daemon unreachable"
+	}
+};
+//#endregion
+//#region src/chat/footer-chips.ts
+/**
+* Abbreviate a re-billed token count: `1200` → `1.2k`, `800` → `800`.
+* Thousands only — a cache prefix large enough to need `M` would be past any
+* provider's window.
+*/
+function formatTokens(tokens) {
+	return tokens >= 1e3 ? `${(tokens / 1e3).toFixed(1)}k` : String(tokens);
+}
+/**
+* Build the chip for a cache break.
+*
+* `costUsd` is OPTIONAL and omitted entirely on a rate miss — never rendered
+* as `$0.00`. A fabricated zero would read as "this was free", which is the
+* opposite of what the chip exists to say. When present it is prefixed `~`
+* because it is an estimate (registry rates × re-billed prefix), and clamped
+* to `<0.01` rather than rounding a real charge down to nothing.
+*/
+function cacheBreakChip(info) {
+	const rebilled = formatTokens(info.rebilledTokens);
+	const cost = info.costUsd !== void 0 ? ` · ~$${info.costUsd < .01 ? "<0.01" : info.costUsd.toFixed(2)}` : "";
+	if (info.changed.length === 0) return {
+		tone: "dim",
+		glyph: "⚡",
+		label: `cache expired · +${rebilled} tok${cost}`
+	};
+	return {
+		tone: "warn",
+		glyph: "⚡",
+		label: `cache break · ${info.changed.join(",")} · +${rebilled} tok${cost}`
+	};
+}
+/**
+* Provider-retry label — `retrying 2/5`, or `retrying 2/5 · child-3` when the
+* stalled stream belongs to a subagent rather than the parent.
+*
+* Naming the source matters: with subagents in flight, an unattributed
+* "retrying" leaves the user unable to tell whether their own turn is stuck or
+* a delegated worker is.
+*/
+function retryLabel(info) {
+	const suffix = info.source === "parent" ? "" : ` · ${info.source}`;
+	return `retrying ${info.attempt}/${info.max}${suffix}`;
+}
+/**
+* Footer label while a compaction summary is being generated:
+* `Compacting...`, then `~12k` once the loop reports a token estimate, then
+* ` · 8s` once a second has passed. Same rule on every surface so a
+* minutes-long compaction of a large transcript reads as progress — not a
+* hang — identically in the TUI and the GUI.
+*
+* `now` is injectable so callers driving a 1 Hz tick don't have to re-read
+* the clock, and so tests are deterministic.
+*/
+function compactingLabel(estTokens, startedAt, now = Date.now()) {
+	const base = "Compacting...";
+	const elapsedMs = typeof startedAt === "number" ? now - startedAt : 0;
+	const elapsed = elapsedMs >= 1e3 ? ` · ${formatDuration(elapsedMs)}` : "";
+	return typeof estTokens === "number" && estTokens > 0 ? `${base} ~${fmtTokens(estTokens)}${elapsed}` : `${base}${elapsed}`;
+}
+//#endregion
 //#region src/chat/markdown-segments.ts
 /**
 * Split markdown text into alternating prose / fenced-code segments.
@@ -2412,6 +3190,60 @@ function splitPromptSegments(text, refs) {
 	return out;
 }
 //#endregion
+//#region src/chat/provider-usage-format.ts
+/**
+* The window closest to its ceiling, which is the one that will bite first and
+* the only one a single-line indicator has room for. `null` when the snapshot
+* carries no windows.
+*/
+function mostConstrainedWindow(snapshot) {
+	let worst = null;
+	for (const win of snapshot.windows) if (!worst || win.usedPercent > worst.usedPercent) worst = win;
+	return worst;
+}
+/**
+* Percent for display: integers print bare, fractions keep one decimal (so a
+* status bar never reads `100%` for `99.9`).
+*/
+function formatUsagePercent(usedPercent) {
+	return Number.isInteger(usedPercent) ? String(usedPercent) : usedPercent.toFixed(1);
+}
+function usageTone(usedPercent) {
+	if (usedPercent >= 85) return "error";
+	if (usedPercent >= 60) return "warn";
+	return "ok";
+}
+/**
+* Time to reset, coarsened to whole days past 24h. `null` when the provider
+* reported no reset, `resetting` once it is due.
+*
+* Every step rounds DOWN, like the percent: 36h reads as `1d`, not `2d`.
+* Overstating the headroom left on a window is the wrong direction to be
+* wrong in.
+*/
+function resetLabel(resetsAt, now = Date.now()) {
+	if (resetsAt === null) return null;
+	const remaining = resetsAt - now;
+	if (remaining <= 0) return "resetting";
+	const minutes = Math.floor(remaining / 6e4);
+	if (minutes < 60) return `resets in ${Math.max(1, minutes)}m`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) {
+		const remMinutes = minutes % 60;
+		return `resets in ${hours}h${remMinutes > 0 ? `${remMinutes}m` : ""}`;
+	}
+	return `resets in ${Math.max(1, Math.floor(hours / 24))}d`;
+}
+/** Balances are dollars for OpenRouter and opaque units elsewhere. */
+function formatCredits(value) {
+	return value >= 100 ? value.toFixed(0) : value.toFixed(2);
+}
+/** `20.00 / 25.00`, or just the remainder when no total is reported. */
+function formatBalance(credits) {
+	const remaining = formatCredits(credits.remaining);
+	return credits.total === null ? remaining : `${remaining} / ${formatCredits(credits.total)}`;
+}
+//#endregion
 //#region src/chat/streaming-pure.ts
 const PARENT_OWNER = "parent";
 function ownerOf(event) {
@@ -2582,6 +3414,15 @@ function capTranscriptEvents(events, max = MAX_TRANSCRIPT_EVENTS, trimTo = TRANS
 * the same shape in their own style. Lives in `zidane/chat` because
 * it has no rendering concerns; the TUI just consumes it.
 */
+const SESSIONS_VERB_LABEL = {
+	create: "Create session",
+	send: "Send to session",
+	steer: "Steer session",
+	cancel: "Cancel session",
+	read: "Read session",
+	transcript: "Session transcript",
+	list: "List sessions"
+};
 const TOOL_DISPLAY = {
 	read_file: {
 		displayName: "Read",
@@ -2815,6 +3656,50 @@ const TOOL_DISPLAY = {
 			if (!title) return null;
 			return { target: title };
 		}
+	},
+	sessions: {
+		displayName: (input) => SESSIONS_VERB_LABEL[stringField(input ?? {}, "verb") ?? ""] ?? "Sessions",
+		format: (input) => {
+			const verb = stringField(input, "verb");
+			const id = stringField(input, "sessionId");
+			const limit = numberField(input, "limit");
+			const ref = id ? {
+				target: shortSessionId(id),
+				sessionId: id
+			} : null;
+			switch (verb) {
+				case "create": {
+					const prompt = stringField(input, "prompt");
+					if (!prompt) return null;
+					const cwd = stringField(input, "cwd");
+					return {
+						target: stringField(input, "title") ?? "new worker",
+						meta: cwd ? [`in ${cwd}`] : [],
+						detail: prompt
+					};
+				}
+				case "send":
+				case "steer": {
+					const text = stringField(input, verb === "send" ? "prompt" : "message");
+					if (!text || !ref) return null;
+					return {
+						...ref,
+						detail: text
+					};
+				}
+				case "cancel":
+				case "read": return ref;
+				case "transcript": return ref ? {
+					...ref,
+					meta: limit !== void 0 ? [`last ${limit} turns`] : []
+				} : null;
+				case "list": return {
+					target: "all sessions",
+					meta: limit !== void 0 ? [`limit ${limit}`] : []
+				};
+				default: return null;
+			}
+		}
 	}
 };
 /**
@@ -3000,6 +3885,6 @@ function countNeighbors(turnIds, turnId) {
 	};
 }
 //#endregion
-export { applyEditPayload as $, SKILLS_TRIGGER as A, BASH_CALL_ID_PREFIX as B, MARKDOWN_RENDER_CHUNK_TARGET_BYTES as C, normalizeMarkdownCodeFences as D, codeTokenHasClosingFence as E, uniqueFilesFromReferences as F, isVisible as G, isEditErrorResult as H, COMMANDS_TRIGGER as I, retagUserPromptEvents as J, isVisibleDuringSearch as K, createCommandsCompletionProvider as L, uniqueSkillNamesFromReferences as M, FILES_TRIGGER as N, splitMarkdownCodeBlocks as O, createFilesCompletionProvider as P, turnSelectionOwnership as Q, blendHsl as R, parseCustomModelQuery as S, uniqueChatIdsFromReferences as St, closeDanglingCodeFence as T, isTurnHighlighted as U, EDIT_TOOL_NAMES as V, isUserBashEvent as W, selectionAfterTurnRemoval as X, selectableTurnIds as Y, streamEventSearchText as Z, turnContextSize as _, stripEditOutcomesAnnotation as _t, TOOL_DISPLAY as a, extractEditPayload as at, filterModelCatalog as b, chatReferenceTokensFromText as bt, MAX_TRANSCRIPT_EVENTS as c, splitLines as ct, finalizeStreamingMarkdown as d, buildEditOutcomesAnnotation as dt, buildContextualDiff as et, finalizeStreamingMarkdownForOwner as f, maskToOutcomeKinds as ft, revealEarlierTranscriptEvents as g, rewriteMultiEditHeader as gt, replaceTranscriptTurnEvents as h, resolveApprovalForPayload as ht, turnAsText as i, computeLineDiff as it, createSkillsCompletionProvider as j, stripHtmlCommentsOutsideCode as k, TRANSCRIPT_TRIM_TO_EVENTS as l, summarizeEditPayload as lt, ownerOf as m, parseEditOutcomesFromResult as mt, deleteTurnSafely as n, clipDiffForRender as nt, displayNameFor as o, filetypeFromPath as ot, hiddenEarlierTranscriptCount as p, mergeApprovalAndBodyOutcomes as pt, promptHistoryFromEvents as q, truncateTurnsAt as r, computeInlineDiff as rt, formatToolCall as s, previewEditPayload as st, countNeighbors as t, buildUnifiedDiff as tt, capTranscriptEvents as u, tokenize as ut, splitPromptSegments as v, summarizeOutcomes as vt, chunkMarkdownForRender as w, indexOfEntry as x, createChatsCompletionProvider as xt, buildModelCatalog as y, CHATS_TRIGGER as yt, buildLinearRamp as z };
+export { sanitizeModelChain as $, hasRunReceipt as $t, chunkMarkdownForRender as A, SESSION_EVENT_STATUS_STYLE as At, DAEMON_HEALTH_STYLE as B, sessionEventExcerpt as Bt, usageTone as C, createChatsCompletionProvider as Cn, selectableTurnIds as Ct, indexOfEntry as D, MAIN_PLAYBOOK_FRAGMENT as Dt, filterModelCatalog as E, turnSelectionOwnership as Et, stripHtmlCommentsOutsideCode as F, orchestratedBy as Ft, chainsEqualKeyed as G, RUN_RECEIPT_GLYPH as Gt, chainEntryKey as H, sessionEventMeta as Ht, cacheBreakChip as I, parseSessionEventXml as It, pickPrimaryKeyed as J, formatRunDuration as Jt, filterChainFallbacks as K, fitRunReceiptCells as Kt, compactingLabel as L, renderProjectsBriefing as Lt, codeTokenHasClosingFence as M, WORKER_REPORT_FRAGMENT as Mt, normalizeMarkdownCodeFences as N, artifactsFromTurns as Nt, parseCustomModelQuery as O, MAIN_SESSION_TITLE as Ot, splitMarkdownCodeBlocks as P, isMainSession as Pt, restoreChainFallbacks as Q, formatTokensPerSecond as Qt, retryLabel as R, renderSessionEventXml as Rt, resetLabel as S, chatReferenceTokensFromText as Sn, retagUserPromptEventsFromRefs as St, buildModelCatalog as T, streamEventSearchText as Tt, chainPositionOf as U, shortSessionId as Ut, buildRunModel as V, sessionEventLabel as Vt, chainsEqual as W, truncateTitle as Wt, providerKeySetChanged as X, formatRunReceiptLine as Xt, positionKeyed as Y, formatRunReceiptCells as Yt, reorderKeyed as Z, formatTokenCount as Zt, turnContextSize as _, resolveApprovalForPayload as _n, isVisible as _t, TOOL_DISPLAY as a, computeInlineDiff as an, FILES_TRIGGER as at, formatUsagePercent as b, summarizeOutcomes as bn, promptTurnRefs as bt, MAX_TRANSCRIPT_EVENTS as c, filetypeFromPath as cn, COMMANDS_TRIGGER as ct, finalizeStreamingMarkdown as d, summarizeEditPayload as dn, buildLinearRamp as dt, runReceiptFromRun as en, toggleChainEntry as et, finalizeStreamingMarkdownForOwner as f, tokenize as fn, BASH_CALL_ID_PREFIX as ft, revealEarlierTranscriptEvents as g, parseEditOutcomesFromResult as gn, isUserBashEvent as gt, replaceTranscriptTurnEvents as h, mergeApprovalAndBodyOutcomes as hn, isTurnHighlighted as ht, turnAsText as i, clipDiffForRender as in, uniqueSkillNamesFromReferences as it, closeDanglingCodeFence as j, SESSION_ROLE_KEY as jt, MARKDOWN_RENDER_CHUNK_TARGET_BYTES as k, ORCHESTRATED_BY_KEY as kt, TRANSCRIPT_TRIM_TO_EVENTS as l, previewEditPayload as ln, createCommandsCompletionProvider as lt, ownerOf as m, maskToOutcomeKinds as mn, isEditErrorResult as mt, deleteTurnSafely as n, buildContextualDiff as nn, SKILLS_TRIGGER as nt, displayNameFor as o, computeLineDiff as on, createFilesCompletionProvider as ot, hiddenEarlierTranscriptCount as p, buildEditOutcomesAnnotation as pn, EDIT_TOOL_NAMES as pt, pickChainPrimary as q, formatCostUsd as qt, truncateTurnsAt as r, buildUnifiedDiff as rn, createSkillsCompletionProvider as rt, formatToolCall as s, extractEditPayload as sn, uniqueFilesFromReferences as st, countNeighbors as t, applyEditPayload as tn, toggleKeyed as tt, capTranscriptEvents as u, splitLines as un, blendHsl as ut, formatBalance as v, rewriteMultiEditHeader as vn, isVisibleDuringSearch as vt, splitPromptSegments as w, uniqueChatIdsFromReferences as wn, selectionAfterTurnRemoval as wt, mostConstrainedWindow as x, CHATS_TRIGGER as xn, retagUserPromptEvents as xt, formatCredits as y, stripEditOutcomesAnnotation as yn, promptHistoryFromEvents as yt, DAEMON_HEALTH_GLYPH as z, sessionDirLabel as zt };
 
-//# sourceMappingURL=turn-operations-mMxDRgLY.js.map
+//# sourceMappingURL=turn-operations-CZLsNgw-.js.map