zidane 5.3.0 → 5.3.1

package/dist/{turn-operations-Y7e15gJf.js → turn-operations-D9HvatsR.js}

@@ -1,11 +1,11 @@
-import { a as multiEdit, c as grep, d as resolveOldString, f as styleReplacementForVia, 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-CMVruxF0.js";
-import { o as errorMessage } from "./errors-COmsomd5.js";
+import { a as multiEdit, c as grep, d as resolveOldString, f as styleReplacementForVia, 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-CWEDS2ZT.js";
+import { s as errorMessage } from "./errors-Byb0F8B9.js";
 import { n as toolResultToText } from "./types-IcokUOyC.js";
-import { r as normalizeMcpServers } from "./mcp-B1psg7jf.js";
-import { a as discoverSkills } from "./interpolate-BhmHKD6x.js";
+import { r as normalizeMcpServers } from "./mcp-ZsSFo4Dp.js";
+import { a as discoverSkills } from "./interpolate-ERgZUxgg.js";
 import { n as formatTokenUsage } from "./stats-DgOvY7wd.js";
-import { n as definePreset } from "./presets-tvD28pCu.js";
-import { a as writeFileAtomic, i as anthropic, n as openai, r as cerebras, t as openrouter } from "./providers-v1Rn2rqG.js";
+import { n as definePreset, t as composePresets } from "./presets-h5i3kpOP.js";
+import { a as writeFileAtomic, i as anthropic, n as openai, r as cerebras, t as openrouter } from "./providers-x3LZByR5.js";
 import { spawn } from "node:child_process";
 import { readdir, stat, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
@@ -253,6 +253,581 @@ function joinPrompt(parts) {
 	return parts.filter((p) => typeof p === "string" && p.length > 0).join("\n\n");
 }
 //#endregion
+//#region src/chat/todos.ts
+const TODOWRITE_TOOL = "todowrite";
+const TODOREAD_TOOL = "todoread";
+/** True when `name` is one of the todo tool canonical names. */
+function isTodoTool(name) {
+	return name === "todowrite" || name === "todoread";
+}
+/** `session.metadata[TODOS_METADATA_KEY]: TodosBag` — see {@link TodosBag}. */
+const TODOS_METADATA_KEY = "todos";
+/** `session.metadata[TODO_WRITE_COUNTS_METADATA_KEY]: CountsBag` — mirrors `TodosBag` shape. */
+const TODO_WRITE_COUNTS_METADATA_KEY = "todoWriteCounts";
+const TODO_STATUS_VALUES = [
+	"pending",
+	"in_progress",
+	"completed",
+	"cancelled"
+];
+const TODO_STATUS_GLYPHS = {
+	pending: "☐",
+	in_progress: "◐",
+	completed: "☑",
+	cancelled: "☒"
+};
+const WRITE_DESCRIPTION = "Replace the active task list. Pass the **full** list of items every call — there is no partial update. The list persists across user prompts in the same session, so an aborted run with `in_progress` items reads back on the next `todoread` and you can pick up where you left off. When every item is `completed`, the list auto-clears so the next prompt starts fresh.\n\nUse the `status` field to track progress: `pending` (queued), `in_progress` (currently working), `completed` (done), `cancelled` (no longer relevant).\n\nOnly checkpoint at significant transitions:\n  1. When the user gives you a multi-step task — write the initial plan with everything `pending`.\n  2. When you transition between steps — mark the previous one `completed` and the next one `in_progress`.\n  3. When the user asks for the current status — re-emit the list unchanged so they can see it.\n\nDo NOT call this on every action. The list is for the user's situational awareness, not for self-narrating.";
+const READ_DESCRIPTION = "Return the current active task list. Returns an empty list if nothing has been written yet, or if the previous batch was auto-cleared after all items completed. Use sparingly — you already see the latest list in your own `todowrite` tool_result above.";
+function defaultReminder(count) {
+	return `(You've called todowrite ${count} times. Make sure each checkpoint reflects real progress; avoid re-planning every step.)`;
+}
+/**
+* `true` when the run with `runId` is a subagent (has a `parentRunId`).
+* Top-level runs return `false`; an unknown / missing run also returns
+* `false` (defensive — should never happen in practice, but treating an
+* orphan as top-level is the right fallback since the session slot is
+* the more general bucket).
+*/
+function isSubagentRun(session, runId) {
+	return !!session.runs.find((r) => r.id === runId)?.parentRunId;
+}
+/**
+* Read the active list for `runId`. Top-level runs see the session-shared
+* slot; subagent runs see their own. Returns a fresh `[]` (not stored in
+* metadata) when no slot exists — the caller can mutate the result
+* without affecting state.
+*/
+function getTodosForRun(session, runId) {
+	const bag = readTodosBag(session);
+	if (isSubagentRun(session, runId)) {
+		const items = bag.byRun?.[runId];
+		return Array.isArray(items) ? [...items] : [];
+	}
+	return Array.isArray(bag.session) ? [...bag.session] : [];
+}
+/**
+* Replace the active list for `runId`. Routes to the session-shared slot
+* for top-level runs and to the per-run slot for subagents. Empty arrays
+* delete the slot entirely so persisted metadata stays clean.
+*
+* Side effect: a **non-empty** write also stashes the same list into
+* `bag.archive` (same routing). Empty writes never touch the archive —
+* clearing the live list (whether explicitly or via the tool's auto-
+* clear) preserves the "last shown" snapshot so UI surfaces can keep
+* rendering what was just completed. See {@link getArchivedTodosForRun}.
+*/
+function setTodosForRun(session, runId, items) {
+	const bag = readTodosBag(session);
+	const normalized = items.map(normalizeItem);
+	const subagent = isSubagentRun(session, runId);
+	if (subagent) {
+		const byRun = { ...bag.byRun ?? {} };
+		if (normalized.length === 0) delete byRun[runId];
+		else byRun[runId] = normalized;
+		bag.byRun = byRun;
+	} else if (normalized.length === 0) delete bag.session;
+	else bag.session = normalized;
+	if (normalized.length > 0) {
+		const archive = { ...bag.archive ?? {} };
+		if (subagent) {
+			const archiveByRun = { ...archive.byRun ?? {} };
+			archiveByRun[runId] = normalized;
+			archive.byRun = archiveByRun;
+		} else archive.session = normalized;
+		bag.archive = archive;
+	}
+	writeTodosBag(session, bag);
+}
+/**
+* Read the archived (most-recent non-empty) list for `runId`. Same slot
+* routing as {@link getTodosForRun}, but reads `bag.archive` instead of
+* the live slot. Returns a fresh `[]` when no archive exists.
+*
+* UI surfaces use this to keep showing "what was just completed" after
+* the live list auto-clears. The model never sees the archive — it's a
+* read-only sidecar for human-facing rendering.
+*/
+function getArchivedTodosForRun(session, runId) {
+	const archive = readTodosBag(session).archive;
+	if (!archive) return [];
+	if (isSubagentRun(session, runId)) {
+		const items = archive.byRun?.[runId];
+		return Array.isArray(items) ? [...items] : [];
+	}
+	return Array.isArray(archive.session) ? [...archive.session] : [];
+}
+/**
+* Reconcile `session.metadata.todos.byRun` (live + archive) against
+* `session.runs`. Drops subagent slots whose runId isn't in the run
+* list. The top-level `session` slot is unaffected — it's session-
+* scoped, not per-run, so there's no orphan to GC.
+*
+* Useful after `session.setRuns()` (fork / restore) or to GC stale
+* metadata mutated by an external caller. Also prunes the parallel
+* counter bag so the two don't drift.
+*
+* `dropped` reports the live-byRun orphans only (archive-only orphans
+* are silently swept). The live half is the contract callers actually
+* observe.
+*/
+function pruneTodosByRun(session) {
+	const validRunIds = new Set(session.runs.map((r) => r.id));
+	const dropped = [];
+	const bag = readTodosBag(session);
+	let bagChanged = false;
+	if (bag.byRun) {
+		const nextByRun = {};
+		for (const [runId, items] of Object.entries(bag.byRun)) if (validRunIds.has(runId)) nextByRun[runId] = items;
+		else {
+			dropped.push(runId);
+			bagChanged = true;
+		}
+		if (Object.keys(nextByRun).length !== Object.keys(bag.byRun).length) bag.byRun = nextByRun;
+	}
+	if (bag.archive?.byRun) {
+		const nextByRun = {};
+		let archiveChanged = false;
+		for (const [runId, items] of Object.entries(bag.archive.byRun)) if (validRunIds.has(runId)) nextByRun[runId] = items;
+		else archiveChanged = true;
+		if (archiveChanged) {
+			bag.archive = {
+				...bag.archive,
+				byRun: nextByRun
+			};
+			bagChanged = true;
+		}
+	}
+	if (bagChanged) writeTodosBag(session, bag);
+	const counts = readCountsBag(session);
+	if (counts.byRun) {
+		const nextByRun = {};
+		let changed = false;
+		for (const [runId, n] of Object.entries(counts.byRun)) if (validRunIds.has(runId)) nextByRun[runId] = n;
+		else changed = true;
+		if (changed) {
+			counts.byRun = nextByRun;
+			writeCountsBag(session, counts);
+		}
+	}
+	return { dropped };
+}
+/**
+* Build a `Preset` carrying the `{ todowrite, todoread }` tool pair.
+* Identical-payload dedup is handled inside the tool body — the
+* comparison resolves against the active slot (session-shared for
+* top-level runs, per-run for subagents) and intentionally does NOT
+* plumb through `behavior.dedupTools`. See the `dedupIdentical` option
+* doc for the rationale.
+*
+* By default the preset adds **no** `toolBudgets` entry — `todowrite`
+* is a state-transition tool, so a hard cap is the wrong abstraction
+* (it punishes the legitimate "finish the N-item plan" path). Hosts
+* that want a ceiling pass `maxWritesPerRun: N` explicitly; the
+* factory then plumbs a `behavior.toolBudgets.todowrite` entry
+* through.
+*
+* Returning a `Preset` (not a bare tool map) lets the result flow
+* through {@link composePresets} unchanged — todos compose with any
+* other preset the same way every other preset does. `toolBudgets` is
+* a tool-name-keyed record that `composePresets` deep-merges, so a
+* caller's custom budget entries for other tools survive the
+* layering, and a caller's override for `todowrite` itself wins by
+* being placed later in the chain.
+*
+* ```ts
+* import { basic, composePresets } from 'zidane/presets'
+* import { createTodoTools } from 'zidane/chat'
+*
+* // Default: no budget — relies on the in-band reminder + dedup.
+* createAgent({ ...composePresets(basic, createTodoTools()), provider })
+*
+* // Opt-in hard cap: refuse > 20 writes per run.
+* createAgent({
+*   ...composePresets(basic, createTodoTools({ maxWritesPerRun: 20 })),
+*   provider,
+* })
+* ```
+*
+* For the trivial "just add the tools to an existing config" case, plain
+* spread is also fine since the returned `Preset` only sets `tools`
+* (and `behavior` when a budget is opted in):
+*
+* ```ts
+* createAgent({ ...basic, ...createTodoTools(), provider })
+* ```
+*/
+function createTodoTools(options = {}) {
+	const maxItems = options.maxItems ?? 100;
+	const remindAfter = options.remindAfter ?? 3;
+	const reminderText = options.reminderText ?? ((count, _items) => defaultReminder(count));
+	const dedupIdentical = options.dedupIdentical ?? true;
+	const maxWritesPerRun = options.maxWritesPerRun ?? 0;
+	const onMaxWrites = options.onMaxWrites ?? "steer";
+	const tools = {
+		[TODOWRITE_TOOL]: createTodoWriteTool({
+			maxItems,
+			remindAfter,
+			reminderText,
+			dedupIdentical,
+			description: options.writeDescription ?? WRITE_DESCRIPTION
+		}),
+		[TODOREAD_TOOL]: createTodoReadTool({ description: options.readDescription ?? READ_DESCRIPTION })
+	};
+	const behavior = {};
+	if (maxWritesPerRun > 0) behavior.toolBudgets = { [TODOWRITE_TOOL]: {
+		max: maxWritesPerRun,
+		onExceed: onMaxWrites
+	} };
+	return definePreset(Object.keys(behavior).length > 0 ? {
+		tools,
+		behavior
+	} : { tools });
+}
+function createTodoWriteTool(opts) {
+	return {
+		spec: {
+			name: TODOWRITE_TOOL,
+			description: opts.description,
+			inputSchema: {
+				type: "object",
+				properties: { todos: {
+					type: "array",
+					description: "The complete task list. Replaces the prior list in full.",
+					maxItems: opts.maxItems,
+					items: {
+						type: "object",
+						properties: {
+							id: {
+								type: "string",
+								description: "Stable identifier (the model picks)."
+							},
+							content: {
+								type: "string",
+								description: "One-line task summary."
+							},
+							status: {
+								type: "string",
+								enum: [...TODO_STATUS_VALUES],
+								description: "`pending`, `in_progress`, `completed`, or `cancelled`."
+							}
+						},
+						required: [
+							"id",
+							"content",
+							"status"
+						]
+					}
+				} },
+				required: ["todos"]
+			}
+		},
+		async execute(input, ctx) {
+			const { session, runId } = requireSessionAndRun(ctx, TODOWRITE_TOOL);
+			const rawItems = Array.isArray(input.todos) ? input.todos : [];
+			const items = sanitizeItems(rawItems, opts.maxItems);
+			const dropped = rawItems.length - items.length;
+			const byId = /* @__PURE__ */ new Map();
+			for (const item of items) byId.set(item.id, item);
+			const normalized = [...byId.values()];
+			const current = getTodosForRun(session, runId);
+			const unchanged = opts.dedupIdentical && todosEqual(current, normalized);
+			const count = incrementCount(session, runId);
+			const allCompleted = normalized.length > 0 && normalized.every((t) => t.status === "completed");
+			if (!unchanged) if (allCompleted) {
+				setTodosForRun(session, runId, normalized);
+				setTodosForRun(session, runId, []);
+			} else setTodosForRun(session, runId, normalized);
+			return formatWriteResult({
+				items: normalized,
+				dropped,
+				count,
+				unchanged,
+				cleared: allCompleted && !unchanged,
+				opts
+			});
+		}
+	};
+}
+function formatWriteResult(input) {
+	const { items, dropped, count, unchanged, cleared, opts } = input;
+	const lines = [];
+	const n = items.length;
+	const suffix = n === 1 ? "" : "s";
+	if (cleared) lines.push(`Marked ${n} item${suffix} complete — list cleared.`);
+	else if (unchanged) lines.push(`No change — ${n} todo item${suffix} already tracked.`);
+	else lines.push(`Updated ${n} todo item${suffix}.`);
+	if (!cleared) {
+		const tally = summarizeStatuses(items);
+		if (tally) lines.push(tally);
+	}
+	if (dropped > 0) lines.push(`Dropped ${dropped} malformed item${dropped === 1 ? "" : "s"}.`);
+	const reminder = opts.remindAfter > 0 && count >= opts.remindAfter ? opts.reminderText(count, items) : void 0;
+	if (reminder && reminder.length > 0) lines.push(reminder);
+	return lines.join("\n");
+}
+function createTodoReadTool(opts) {
+	return {
+		spec: {
+			name: TODOREAD_TOOL,
+			description: opts.description,
+			inputSchema: {
+				type: "object",
+				properties: {}
+			}
+		},
+		async execute(_input, ctx) {
+			const { session, runId } = requireSessionAndRun(ctx, TODOREAD_TOOL);
+			const items = getTodosForRun(session, runId);
+			if (items.length === 0) return "No todos yet — call todowrite to start tracking tasks.";
+			return JSON.stringify({ todos: items });
+		}
+	};
+}
+/**
+* Both tool bodies need a `Session` + `runId`. Centralize the guards so the
+* error messages stay symmetric and one fix lands in both places.
+*/
+function requireSessionAndRun(ctx, toolName) {
+	if (!ctx.session) throw new Error(`${toolName}: no session on tool context — todos require a session via createSession().`);
+	if (!ctx.runId) throw new Error(`${toolName}: no runId on tool context.`);
+	return {
+		session: ctx.session,
+		runId: ctx.runId
+	};
+}
+/** Read the todos bag from session metadata, normalizing the live shape. */
+function readTodosBag(session) {
+	const raw = session.metadata[TODOS_METADATA_KEY];
+	if (!isPlainObject(raw)) return {};
+	const archive = isPlainObject(raw.archive) ? {
+		session: Array.isArray(raw.archive.session) ? raw.archive.session : void 0,
+		byRun: isPlainObject(raw.archive.byRun) ? raw.archive.byRun : void 0
+	} : void 0;
+	return {
+		session: Array.isArray(raw.session) ? raw.session : void 0,
+		byRun: isPlainObject(raw.byRun) ? raw.byRun : void 0,
+		archive
+	};
+}
+function writeTodosBag(session, bag) {
+	const clean = {};
+	if (bag.session && bag.session.length > 0) clean.session = bag.session;
+	if (bag.byRun && Object.keys(bag.byRun).length > 0) clean.byRun = bag.byRun;
+	if (bag.archive) {
+		const archive = {};
+		if (bag.archive.session && bag.archive.session.length > 0) archive.session = bag.archive.session;
+		if (bag.archive.byRun && Object.keys(bag.archive.byRun).length > 0) archive.byRun = bag.archive.byRun;
+		if (archive.session || archive.byRun) clean.archive = archive;
+	}
+	session.setMeta(TODOS_METADATA_KEY, clean);
+}
+function readCountsBag(session) {
+	const raw = session.metadata[TODO_WRITE_COUNTS_METADATA_KEY];
+	if (!isPlainObject(raw)) return {};
+	return {
+		session: typeof raw.session === "number" ? raw.session : void 0,
+		byRun: isPlainObject(raw.byRun) ? raw.byRun : void 0
+	};
+}
+function writeCountsBag(session, bag) {
+	const clean = {};
+	if (typeof bag.session === "number" && bag.session > 0) clean.session = bag.session;
+	if (bag.byRun && Object.keys(bag.byRun).length > 0) clean.byRun = bag.byRun;
+	session.setMeta(TODO_WRITE_COUNTS_METADATA_KEY, clean);
+}
+/**
+* Bump the call counter for the active slot and return the new value.
+* Top-level runs increment `bag.session` (cumulative across prompts);
+* subagent runs increment their own entry under `bag.byRun`. Same
+* keying as {@link setTodosForRun} so the counter and the data move
+* together — a freshly seeded run's count starts at 1 on its first
+* write, a continuing top-level run's count picks up from where the
+* prior prompt left off.
+*/
+function incrementCount(session, runId) {
+	const bag = readCountsBag(session);
+	let next;
+	if (isSubagentRun(session, runId)) {
+		const byRun = { ...bag.byRun ?? {} };
+		next = (byRun[runId] ?? 0) + 1;
+		byRun[runId] = next;
+		bag.byRun = byRun;
+	} else {
+		next = (bag.session ?? 0) + 1;
+		bag.session = next;
+	}
+	writeCountsBag(session, bag);
+	return next;
+}
+/** Narrow guard — `Record<string, unknown>` excluding arrays / null. */
+function isPlainObject(v) {
+	return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function normalizeItem(item) {
+	return {
+		id: item.id,
+		content: item.content,
+		status: item.status
+	};
+}
+function sanitizeItems(raw, cap) {
+	const out = [];
+	for (const item of raw) {
+		if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+		const obj = item;
+		const id = typeof obj.id === "string" ? obj.id : void 0;
+		const content = typeof obj.content === "string" ? obj.content : void 0;
+		const status = typeof obj.status === "string" && TODO_STATUS_VALUES.includes(obj.status) ? obj.status : void 0;
+		if (!id || !content || !status) continue;
+		out.push({
+			id,
+			content,
+			status
+		});
+		if (out.length >= cap) break;
+	}
+	return out;
+}
+function summarizeStatuses(items) {
+	if (items.length === 0) return void 0;
+	const counts = {
+		pending: 0,
+		in_progress: 0,
+		completed: 0,
+		cancelled: 0
+	};
+	for (const item of items) counts[item.status] += 1;
+	const parts = [];
+	if (counts.completed) parts.push(`${counts.completed} completed`);
+	if (counts.in_progress) parts.push(`${counts.in_progress} in progress`);
+	if (counts.pending) parts.push(`${counts.pending} pending`);
+	if (counts.cancelled) parts.push(`${counts.cancelled} cancelled`);
+	return parts.length > 0 ? parts.join(" · ") : void 0;
+}
+/**
+* Order-sensitive structural equality on todo lists. Used by the
+* `dedupIdentical` short-circuit to decide whether an incoming payload
+* matches the current run's stored slot.
+*
+* Order-sensitive on purpose: re-ordering the list is a meaningful state
+* change ("the model reprioritized") and should NOT collapse to a no-op.
+* Three-field comparison is exhaustive for `TodoItem` — `normalizeItem`
+* strips any extra fields before they reach the slot, so we never need to
+* compare beyond `{ id, content, status }`.
+*/
+function todosEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		const x = a[i];
+		const y = b[i];
+		if (x.id !== y.id || x.status !== y.status || x.content !== y.content) return false;
+	}
+	return true;
+}
+const EMPTY_TALLY = {
+	pending: 0,
+	in_progress: 0,
+	completed: 0,
+	cancelled: 0
+};
+const EMPTY_ACTIVE = {
+	runId: null,
+	todos: [],
+	archive: [],
+	inProgress: null,
+	tally: EMPTY_TALLY
+};
+/**
+* Pick the "active" run for UI surfaces that show one slot at a time
+* (todos indicator, todos modal, footer ctx indicator). The resolved
+* runId then routes through {@link getTodosForRun} — top-level runs
+* land on the session-shared slot, subagent runs on their own.
+*
+* - A currently-running run wins (latest-started one if several).
+* - Otherwise the most recently appended run wins.
+* - `null` when the session has no runs.
+*
+* Mirrors the "most recent thing that mattered" policy that drives
+* `lastContextSizeFromTurns` — but walks `session.runs` rather than
+* `session.turns` because the active todo slot is a function of the
+* run, not of message history.
+*/
+function pickActiveRunId(session) {
+	if (!session) return null;
+	const runs = session.runs;
+	if (!runs || runs.length === 0) return null;
+	let latestRunning = null;
+	for (let i = runs.length - 1; i >= 0; i--) if (runs[i].status === "running") {
+		latestRunning = runs[i].id;
+		break;
+	}
+	if (latestRunning) return latestRunning;
+	return runs[runs.length - 1].id;
+}
+/**
+* Pure selector — derive the active-todos state from a session snapshot.
+* Used by {@link useActiveTodos} and directly testable without React.
+*
+* Resolves both `todos` (live, model-facing) and `archive` (last
+* non-empty snapshot for UI fallback). The tally folds over whichever
+* list is non-empty; `inProgress` is sourced strictly from `todos`
+* because an archived in-progress item is by definition stale.
+*/
+function selectActiveTodos(session) {
+	const runId = pickActiveRunId(session);
+	if (!session || !runId) return EMPTY_ACTIVE;
+	const todos = getTodosForRun(session, runId);
+	const archive = getArchivedTodosForRun(session, runId);
+	const display = todos.length > 0 ? todos : archive;
+	if (display.length === 0) return {
+		runId,
+		todos,
+		archive,
+		inProgress: null,
+		tally: EMPTY_TALLY
+	};
+	const tally = {
+		pending: 0,
+		in_progress: 0,
+		completed: 0,
+		cancelled: 0
+	};
+	let inProgress = null;
+	for (const t of display) tally[t.status] += 1;
+	if (todos.length > 0) {
+		for (const t of todos) if (t.status === "in_progress") {
+			inProgress = t;
+			break;
+		}
+	}
+	return {
+		runId,
+		todos,
+		archive,
+		inProgress,
+		tally
+	};
+}
+/**
+* React hook — active-todos state for the supplied session. Recomputes
+* on every parent re-render; the work is O(runs + todos), both bounded
+* by small constants in practice.
+*
+* Why no memoization: `Session.runs` is mutated in place by `completeRun`
+* / `abortRun` (status flips without changing array length or item
+* identity), so any memo keyed off length / bag identity would silently
+* return stale state when e.g. a child subagent run completes and the
+* "active" run should reflow to the parent. The selector is cheap
+* enough that running it every parent render is the simpler, correct
+* answer — see `selectActiveTodos` for the O(n) cost.
+*
+* The hook lives in `chat/` so a GUI consumer can mount it verbatim.
+* Renderer-agnostic — no `@opentui/*` imports.
+*/
+function useActiveTodos(session) {
+	return selectActiveTodos(session);
+}
+//#endregion
 //#region src/chat/agents.ts
 /**
 * Resolve a profile's `accent` token to a concrete hex color via the
@@ -314,7 +889,9 @@ const DEFAULT_PERSIST_EXCLUDE_TOOLS = [
 	"skills_read",
 	"present_plan",
 	"ask_user",
-	"spawn"
+	"spawn",
+	"todowrite",
+	"todoread"
 ];
 /**
 * Token-saving `AgentBehavior` defaults shared by the built-in profiles.
@@ -370,7 +947,7 @@ const BUILD_AGENT = {
 	label: "Build",
 	description: "full tool access — read, write, edit, shell, and spawn subagents",
 	accent: "accent",
-	preset: definePreset({
+	preset: composePresets(definePreset({
 		name: "build",
 		system: buildBuildSystem(),
 		behavior: { ...SHARED_BEHAVIOR },
@@ -378,7 +955,7 @@ const BUILD_AGENT = {
 			...BUILD_TOOLS,
 			spawn: createSpawnTool({ persist: true })
 		}
-	})
+	}), createTodoTools())
 };
 /**
 * Plan agent — read-only exploration mode. Locked down to file reading and
@@ -1548,6 +2125,12 @@ const KEYBINDING_DEFS = [
 		label: "effort",
 		description: "open the reasoning-effort picker (when the active model supports it)"
 	},
+	{
+		action: "openTodos",
+		default: "ctrl+t",
+		label: "todos",
+		description: "open the active run's todo list (the agent's `todowrite` checkpoints)"
+	},
 	{
 		action: "cycleAgent",
 		default: "shift+tab",
@@ -2599,10 +3182,6 @@ function eventsFromTurns(turns, runs = []) {
 			pushSpawnStart(run);
 			openStack.push(run);
 		}
-		if (depth === 0 && lastDepthAtEmission === 0) events.push({
-			kind: "separator",
-			text: ""
-		});
 		const subagentTag = depth > 0 && turn.runId ? {
 			childId: labelFor(turn.runId),
 			depth
@@ -2613,11 +3192,17 @@ function eventsFromTurns(turns, runs = []) {
 		};
 		if (turn.role === "user") {
 			for (const block of turn.content) if (block.type === "text" && block.text.trim()) {
-				if (depth === 0) events.push({
-					kind: "user-prompt",
-					text: block.text,
-					turnId: turn.id
-				});
+				if (depth === 0) {
+					if (lastDepthAtEmission === 0) events.push({
+						kind: "separator",
+						text: ""
+					});
+					events.push({
+						kind: "user-prompt",
+						text: block.text,
+						turnId: turn.id
+					});
+				}
 			} else if (block.type === "tool_result") {
 				const tool = toolByCallId.get(block.callId);
 				const raw = toolResultText(block.output);
@@ -4137,7 +4722,9 @@ const DEFAULT_SETTINGS = {
 	showEditDiffs: true,
 	targetFps: 60,
 	allowInteraction: true,
-	smoothStreaming: true
+	smoothStreaming: true,
+	showTodoIndicator: true,
+	showThrobber: false
 };
 /**
 * Hard-clamp a `targetFps` value to a safe range before handing it to
@@ -4252,6 +4839,16 @@ const SETTINGS_TOGGLES = [
 		key: "smoothStreaming",
 		label: "Smooth streaming",
 		description: "drip-feed streamed text character-by-character at a steady cadence (typewriter effect)"
+	},
+	{
+		key: "showTodoIndicator",
+		label: "Todo indicator",
+		description: "show the subtle \"in progress\" todo line above the prompt (modal stays accessible regardless)"
+	},
+	{
+		key: "showThrobber",
+		label: "Streaming throbber",
+		description: "animated gradient glyphs at the transcript tail while the assistant is working"
 	}
 ];
 const SETTINGS_CHOICES = [
@@ -5981,7 +6578,7 @@ function getSafelist(dataDir, projectDir) {
 	return readProjects(dataDir)[projectDir]?.safelist ?? [];
 }
 /**
-* Tools that always pass without prompting. Two categories:
+* Tools that always pass without prompting. Three categories:
 *
 *   - **Pure reads** (`read_file`, `list_files`, `glob`, `grep`) — no
 *     side effects on disk or the model's own state.
@@ -5989,6 +6586,12 @@ function getSafelist(dataDir, projectDir) {
 *     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.
+*   - **Todos** (`todowrite`, `todoread`) — write to a slot on
+*     `session.metadata.todos` and nothing else. No shell, no disk, no
+*     network. The model uses these for checkpointing every few steps;
+*     a per-call approval prompt would drown the conversation in
+*     interruptions that buy no safety since the tool's surface is
+*     read/write on a metadata bag we already trust the agent with.
 *
 * Users who want to gate any of these must disable safe-mode entirely
 * (or fork this list in their own embedding).
@@ -5999,7 +6602,9 @@ const IMPLICITLY_SAFE_TOOLS = [
 	"glob",
 	"grep",
 	"ask_user",
-	"present_plan"
+	"present_plan",
+	"todowrite",
+	"todoread"
 ];
 /** Common input keys carrying the "primary argument" we scope safelists on. */
 const PRIMARY_ARG_KEYS = [
@@ -6515,15 +7120,16 @@ const TICK_INTERVAL_MS = 16;
 /**
 * Smooth-streaming display rate, in characters per second.
 *
-* - {@link SMOOTH_BASE_CPS} — the cap for "calm" streaming, when the
-*   buffer is close to caught-up to the provider. ~200 CPS is a fast
-*   typist's pace; comfortably readable without feeling like a deliberate
+* - {@link SMOOTH_BASE_CPS} — calm-state cap. ~200 CPS is a fast typist's
+*   pace; comfortably readable without feeling like a deliberate
 *   typewriter performance.
-* - {@link SMOOTH_BURST_CPS} — when the buffer has been falling behind
-*   the provider (backlog > {@link SMOOTH_BURST_BACKLOG_CHARS}), the
-*   ticker accelerates to drain ~3x as fast. Keeps the typewriter feel
-*   while preventing the display from lagging multiple seconds behind
-*   the actual response.
+* - {@link SMOOTH_BURST_CPS} — cap once the buffer is the full
+*   {@link SMOOTH_BURST_BACKLOG_CHARS} behind the provider. The rate
+*   ramps continuously from base to burst across that range (see
+*   {@link smoothCharsForTick}) so the typewriter cadence never visibly
+*   "steps up" mid-stream — the old step function (BASE for <100,
+*   BURST for ≥100) tripled the chars-per-frame the instant the
+*   threshold was crossed, which read as the text jumping.
 * - {@link SMOOTH_INSTANT_BACKLOG_CHARS} — failsafe. If the buffer
 *   somehow accumulates >2K chars (paste-heavy responses, model dumping
 *   pre-computed text, etc.) the ticker stops smoothing entirely for
@@ -6532,7 +7138,7 @@ const TICK_INTERVAL_MS = 16;
 */
 const SMOOTH_BASE_CPS = 200;
 const SMOOTH_BURST_CPS = 600;
-const SMOOTH_BURST_BACKLOG_CHARS = 100;
+const SMOOTH_BURST_BACKLOG_CHARS = 400;
 const SMOOTH_INSTANT_BACKLOG_CHARS = 2e3;
 const PARENT_OWNER = "parent";
 function emptyBucket(owner, depth) {
@@ -6656,11 +7262,19 @@ function turnContextSize(usage) {
 * current backlog of one bucket. Caps at the bucket length (never
 * over-drains) and bypasses smoothing entirely once the backlog goes
 * past {@link SMOOTH_INSTANT_BACKLOG_CHARS}.
+*
+* The CPS ramps continuously from {@link SMOOTH_BASE_CPS} at zero backlog
+* to {@link SMOOTH_BURST_CPS} at {@link SMOOTH_BURST_BACKLOG_CHARS},
+* then plateaus at burst up to the instant cliff. Continuous (vs. the
+* legacy step at the burst threshold) so the chars-per-frame count never
+* jumps mid-stream — visible jumps in the typewriter cadence read as the
+* text itself jumping.
 */
 function smoothCharsForTick(backlog) {
 	if (backlog <= 0) return 0;
 	if (backlog >= SMOOTH_INSTANT_BACKLOG_CHARS) return backlog;
-	return Math.max(1, Math.min(backlog, Math.ceil((backlog >= SMOOTH_BURST_BACKLOG_CHARS ? SMOOTH_BURST_CPS : SMOOTH_BASE_CPS) * TICK_INTERVAL_MS / 1e3)));
+	const cps = SMOOTH_BASE_CPS + Math.min(1, backlog / SMOOTH_BURST_BACKLOG_CHARS) * (SMOOTH_BURST_CPS - SMOOTH_BASE_CPS);
+	return Math.max(1, Math.min(backlog, Math.ceil(cps * TICK_INTERVAL_MS / 1e3)));
 }
 /**
 * Slice `n` chars off the front of `buf` without splitting a UTF-16
@@ -7044,6 +7658,37 @@ const TOOL_DISPLAY = {
 			};
 		}
 	},
+	todowrite: {
+		displayName: "Todos",
+		format: (input) => {
+			const todos = Array.isArray(input.todos) ? input.todos : null;
+			if (!todos) return null;
+			const counts = {
+				pending: 0,
+				in_progress: 0,
+				completed: 0,
+				cancelled: 0
+			};
+			for (const t of todos) {
+				if (!t || typeof t !== "object") continue;
+				const status = t.status;
+				if (typeof status === "string" && status in counts) counts[status] += 1;
+			}
+			const meta = [];
+			if (counts.completed) meta.push(`${counts.completed} done`);
+			if (counts.in_progress) meta.push(`${counts.in_progress} in progress`);
+			if (counts.pending) meta.push(`${counts.pending} pending`);
+			if (counts.cancelled) meta.push(`${counts.cancelled} cancelled`);
+			return {
+				target: `${todos.length} item${todos.length === 1 ? "" : "s"}`,
+				meta
+			};
+		}
+	},
+	todoread: {
+		displayName: "Todos",
+		format: () => ({ target: "read" })
+	},
 	ask_user: {
 		displayName: "Ask user",
 		format: (input) => {
@@ -7288,6 +7933,6 @@ function countNeighbors(turnIds, turnId) {
 	};
 }
 //#endregion
-export { useMcpAuthDispatch as $, bootTick as $n, isVisible as $t, getSafelist as A, KEYBINDING_DEF_BY_ACTION as An, ACTIONS_WITH_CARE_DOCTRINE as Ar, clampFps as At, supportsOAuth as B, uniqueSkillNamesFromReferences as Bn, buildBuildSystem as Br, CATPPUCCIN_MOCHA as Bt, resolveSessionExportTarget as C, maskToOutcomeKinds as Cn, BUILTIN_AGENTS as Cr, shortId as Ct, useSafeModeQueue as D, findGitRoot$1 as Dn, accentColor as Dr, SETTINGS_CHOICES as Dt, useSafeModeActions as E, summarizeOutcomes as En, PLAN_AGENT as Er, DEFAULT_SETTINGS as Et, suggestSafelistEntry as F, parseBindingSpec as Fn, INTERACTION_GUIDANCE_NO_PROMPTS as Fr, resolveTheme as Ft, defaultMcpsConfigPaths as G, collectReferences as Gn, ConfigProvider as Gt, filterModelCatalog as H, createFilesCompletionProvider as Hn, envSection as Hr, DiscoveryProvider as Ht, writeProjects as I, readKeybindings as In, PLAN_MODE_DOCTRINE as Ir, VAPORWAVE_THEME as It, projectUserPaths as J, useCompletion as Jn, createStateStore as Jt, discoverProjectMcps as K, findActiveTrigger as Kn, useConfig as Kt, splitPromptSegments as L, stripJsonComments as Ln, PLAN_MODE_DOCTRINE_NO_PROMPTS as Lr, CATPPUCCIN_FRAPPE as Lt, matchesSafelistEntry as M, keybindingsPath as Mn, DOING_TASKS_DOCTRINE as Mr, BUILTIN_THEMES as Mt, projectsFilePath as N, matchesBinding as Nn, IDENTITY_PREFIX as Nr, DEFAULT_THEME as Nt, IMPLICITLY_SAFE_TOOLS as O, DEFAULT_KEYBINDINGS as On, resolveAgentId as Or, SETTINGS_TOGGLES as Ot, readProjects as P, mergeKeybindings as Pn, INTERACTION_GUIDANCE as Pr, resolveChipColor as Pt, McpAuthProvider as Q, bootProfileEnabled as Qn, isTurnHighlighted as Qt, formatPathForCwd as R, SKILLS_TRIGGER as Rn, SUBAGENT_GUIDANCE as Rr, CATPPUCCIN_LATTE as Rt, renderSession as S, buildEditOutcomesAnnotation as Sn, BUILD_AGENT as Sr, fmtTokens as St, SafeModeProvider as T, resolveApprovalForPayload as Tn, DEFAULT_PERSIST_EXCLUDE_TOOLS as Tr, useEnabledToggleSet as Tt, indexOfEntry as U, uniqueFilesFromReferences as Un, useDiscovery as Ut, buildModelCatalog as V, FILES_TRIGGER as Vn, buildPlanSystem as Vr, createDiscoverySlot as Vt, buildMcpServers as W, applyInsert as Wn, useDiscoveryOptional as Wt, mcpCredentialsPath as X, buildLinearRamp as Xn, eventsFromTurns as Xt, createFileMcpCredentialStore as Y, blendHsl as Yn, deriveSessionTitle as Yt, patchMcpCredential as Z, tryOpenBrowser as Zn, isEditErrorResult as Zt, turnContextSize as _, extractEditPayload as _n, modelSupportsReasoning as _r, truncateTrailing as _t, computeTurnAnchors as a, selectableTurnIds as an, readProviderCredential as ar, InteractionsProvider as at, defaultSkillScanPaths as b, splitLines as bn, openrouterDescriptor as br, ageString as bt, formatToolCall as c, titleFromTurns as cn, writeCredentials as cr, createInteractionTools as ct, useSelectStyle as d, turnSelectionOwnership as dn, anthropicDescriptor as dr, pendingInteractionsFromTurns as dt, lastContextSizeFromTurns as en, shouldAutoCompact as er, useMcpAuthState as et, useSurfaces as f, applyEditPayload as fn, cerebrasDescriptor as fr, serializeInteractionResponse as ft, finalizeStreamingMarkdownForOwner as g, computeLineDiff as gn, getModelInfo as gr, hintsLength as gt, finalizeStreamingMarkdown as h, computeInlineDiff as hn, getContextWindow as hr, clipHintsToWidth as ht, turnAsText as i, saveState as in, readCredentials as ir, ASK_USER_TOOL as it, isOnSafelist as j, ensureKeybindingsFile as jn, COMMUNICATION_DOCTRINE as jr, useSettings as jt, addToSafelist as k, KEYBINDING_DEFS as kn, singleAgentRegistry as kr, SettingsProvider as kt, ThemeProvider as l, toolCallPreview as ln, BUILTIN_PROVIDERS as lr, isInteractionTool as lt, useTheme as m, buildUnifiedDiff as mn, effectiveContextWindow as mr, useInteractionsQueue as mt, deleteTurnSafely as n, loadState as nn, applyApiKeyEnv as nr, reduceMcpAuth as nt, TOOL_DISPLAY as o, stripSpawnTokensLine as on, removeProviderCredential as or, PRESENT_PLAN_TOOL as ot, useSyntaxStyles as p, buildContextualDiff as pn, credKeyOf as pr, useInteractionsActions as pt, parseMcpsFile as q, mergeReferences as qn, resolveConfig as qt, truncateTurnsAt as r, marginTopFor as rn, credentialsPath as rr, splitMarkdownCodeBlocks as rt, displayNameFor as s, sumRunCosts as sn, setProviderCredential as sr, buildResumedToolResultsTurn as st, countNeighbors as t, listSessionMeta as tn, detectAuth as tr, getMcpAuthStatus as tt, useColors as u, toolResultText as un, OUTPUT_RESERVE_TOKENS as ur, makeRequestInteraction as ut, useStreamBuffer as v, filetypeFromPath as vn, modelsForDescriptor as vr, cleanTitle as vt, writeSessionExport as w, parseEditOutcomesFromResult as wn, DEFAULT_AGENT_ID as wr, listProjectFiles as wt, discoverProjectSkills as x, tokenize as xn, piIdOf as xr, compactPath as xt, buildSkillsConfig as y, previewEditPayload as yn, openaiDescriptor as yr, generateSessionTitle as yt, runOAuthLogin as z, createSkillsCompletionProvider as zn, TOKEN_DISCIPLINE_DOCTRINE as zr, CATPPUCCIN_MACCHIATO as zt };
+export { useMcpAuthDispatch as $, bootTick as $n, TOKEN_DISCIPLINE_DOCTRINE as $r, isVisible as $t, getSafelist as A, KEYBINDING_DEF_BY_ACTION as An, TODOREAD_TOOL as Ar, clampFps as At, supportsOAuth as B, uniqueSkillNamesFromReferences as Bn, pruneTodosByRun as Br, CATPPUCCIN_MOCHA as Bt, resolveSessionExportTarget as C, maskToOutcomeKinds as Cn, BUILTIN_AGENTS as Cr, shortId as Ct, useSafeModeQueue as D, findGitRoot$1 as Dn, accentColor as Dr, SETTINGS_CHOICES as Dt, useSafeModeActions as E, summarizeOutcomes as En, PLAN_AGENT as Er, DEFAULT_SETTINGS as Et, suggestSafelistEntry as F, parseBindingSpec as Fn, createTodoTools as Fr, resolveTheme as Ft, defaultMcpsConfigPaths as G, collectReferences as Gn, COMMUNICATION_DOCTRINE as Gr, ConfigProvider as Gt, filterModelCatalog as H, createFilesCompletionProvider as Hn, setTodosForRun as Hr, DiscoveryProvider as Ht, writeProjects as I, readKeybindings as In, getArchivedTodosForRun as Ir, VAPORWAVE_THEME as It, projectUserPaths as J, useCompletion as Jn, INTERACTION_GUIDANCE as Jr, createStateStore as Jt, discoverProjectMcps as K, findActiveTrigger as Kn, DOING_TASKS_DOCTRINE as Kr, useConfig as Kt, splitPromptSegments as L, stripJsonComments as Ln, getTodosForRun as Lr, CATPPUCCIN_FRAPPE as Lt, matchesSafelistEntry as M, keybindingsPath as Mn, TODOWRITE_TOOL as Mr, BUILTIN_THEMES as Mt, projectsFilePath as N, matchesBinding as Nn, TODO_STATUS_GLYPHS as Nr, DEFAULT_THEME as Nt, IMPLICITLY_SAFE_TOOLS as O, DEFAULT_KEYBINDINGS as On, resolveAgentId as Or, SETTINGS_TOGGLES as Ot, readProjects as P, mergeKeybindings as Pn, TODO_WRITE_COUNTS_METADATA_KEY as Pr, resolveChipColor as Pt, McpAuthProvider as Q, bootProfileEnabled as Qn, SUBAGENT_GUIDANCE as Qr, isTurnHighlighted as Qt, formatPathForCwd as R, SKILLS_TRIGGER as Rn, isTodoTool as Rr, CATPPUCCIN_LATTE as Rt, renderSession as S, buildEditOutcomesAnnotation as Sn, BUILD_AGENT as Sr, fmtTokens as St, SafeModeProvider as T, resolveApprovalForPayload as Tn, DEFAULT_PERSIST_EXCLUDE_TOOLS as Tr, useEnabledToggleSet as Tt, indexOfEntry as U, uniqueFilesFromReferences as Un, useActiveTodos as Ur, useDiscovery as Ut, buildModelCatalog as V, FILES_TRIGGER as Vn, selectActiveTodos as Vr, createDiscoverySlot as Vt, buildMcpServers as W, applyInsert as Wn, ACTIONS_WITH_CARE_DOCTRINE as Wr, useDiscoveryOptional as Wt, mcpCredentialsPath as X, buildLinearRamp as Xn, PLAN_MODE_DOCTRINE as Xr, eventsFromTurns as Xt, createFileMcpCredentialStore as Y, blendHsl as Yn, INTERACTION_GUIDANCE_NO_PROMPTS as Yr, deriveSessionTitle as Yt, patchMcpCredential as Z, tryOpenBrowser as Zn, PLAN_MODE_DOCTRINE_NO_PROMPTS as Zr, isEditErrorResult as Zt, turnContextSize as _, extractEditPayload as _n, modelSupportsReasoning as _r, truncateTrailing as _t, computeTurnAnchors as a, selectableTurnIds as an, readProviderCredential as ar, InteractionsProvider as at, defaultSkillScanPaths as b, splitLines as bn, openrouterDescriptor as br, ageString as bt, formatToolCall as c, titleFromTurns as cn, writeCredentials as cr, createInteractionTools as ct, useSelectStyle as d, turnSelectionOwnership as dn, anthropicDescriptor as dr, pendingInteractionsFromTurns as dt, buildBuildSystem as ei, lastContextSizeFromTurns as en, shouldAutoCompact as er, useMcpAuthState as et, useSurfaces as f, applyEditPayload as fn, cerebrasDescriptor as fr, serializeInteractionResponse as ft, finalizeStreamingMarkdownForOwner as g, computeLineDiff as gn, getModelInfo as gr, hintsLength as gt, finalizeStreamingMarkdown as h, computeInlineDiff as hn, getContextWindow as hr, clipHintsToWidth as ht, turnAsText as i, saveState as in, readCredentials as ir, ASK_USER_TOOL as it, isOnSafelist as j, ensureKeybindingsFile as jn, TODOS_METADATA_KEY as jr, useSettings as jt, addToSafelist as k, KEYBINDING_DEFS as kn, singleAgentRegistry as kr, SettingsProvider as kt, ThemeProvider as l, toolCallPreview as ln, BUILTIN_PROVIDERS as lr, isInteractionTool as lt, useTheme as m, buildUnifiedDiff as mn, effectiveContextWindow as mr, useInteractionsQueue as mt, deleteTurnSafely as n, envSection as ni, loadState as nn, applyApiKeyEnv as nr, reduceMcpAuth as nt, TOOL_DISPLAY as o, stripSpawnTokensLine as on, removeProviderCredential as or, PRESENT_PLAN_TOOL as ot, useSyntaxStyles as p, buildContextualDiff as pn, credKeyOf as pr, useInteractionsActions as pt, parseMcpsFile as q, mergeReferences as qn, IDENTITY_PREFIX as qr, resolveConfig as qt, truncateTurnsAt as r, marginTopFor as rn, credentialsPath as rr, splitMarkdownCodeBlocks as rt, displayNameFor as s, sumRunCosts as sn, setProviderCredential as sr, buildResumedToolResultsTurn as st, countNeighbors as t, buildPlanSystem as ti, listSessionMeta as tn, detectAuth as tr, getMcpAuthStatus as tt, useColors as u, toolResultText as un, OUTPUT_RESERVE_TOKENS as ur, makeRequestInteraction as ut, useStreamBuffer as v, filetypeFromPath as vn, modelsForDescriptor as vr, cleanTitle as vt, writeSessionExport as w, parseEditOutcomesFromResult as wn, DEFAULT_AGENT_ID as wr, listProjectFiles as wt, discoverProjectSkills as x, tokenize as xn, piIdOf as xr, compactPath as xt, buildSkillsConfig as y, previewEditPayload as yn, openaiDescriptor as yr, generateSessionTitle as yt, runOAuthLogin as z, createSkillsCompletionProvider as zn, pickActiveRunId as zr, CATPPUCCIN_MACCHIATO as zt };
 
-//# sourceMappingURL=turn-operations-Y7e15gJf.js.map
+//# sourceMappingURL=turn-operations-D9HvatsR.js.map