@wular/coder 0.4.6 → 0.4.8

package/dist/dash/standalone/server/modules-server-server-react-server/src/client/index.8e150ef2bc6a5f4e.js

@@ -0,0 +1,388 @@
+import { CoderError } from "../core/errors.5954bd9bd05e8230.js";
+export class ClientError extends CoderError {
+	authenticate;
+	needs;
+	constructor(status, message, authenticate = "", hint, needs) {
+		super("server", message, {
+			status,
+			...hint ? { hint } : {}
+		});
+		this.authenticate = authenticate;
+		this.needs = needs;
+	}
+}
+export function isLoopbackServer(server) {
+	try {
+		const host = new URL(server).hostname.toLowerCase();
+		return host === "localhost" || host === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(host);
+	} catch {
+		return false;
+	}
+}
+export function validateUrl(raw) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new CoderError("invalid-option", "Give the server as a URL, e.g. https://agents.example.com.");
+	}
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopbackServer(url.origin))) throw new CoderError("invalid-option", "Coder servers require HTTPS unless they are loopback.", { hint: "Use https://, or http://localhost for a local server." });
+	if (url.username || url.password || url.search || url.hash) throw new CoderError("invalid-option", "The server must be an origin without credentials, query, or fragment.");
+	return url.toString().replace(/\/+$/, "");
+}
+const credentialPath = (label, suffix, workspace) => `/admin/credentials/${encodeURIComponent(label)}${suffix}${workspace ? "?workspace" : ""}`;
+const queryPath = (path, options) => {
+	const query = new URLSearchParams();
+	if ("cursor" in options && typeof options.cursor === "string") query.set("cursor", options.cursor);
+	for (const [key, value] of Object.entries(options)) if (key !== "cursor" && value !== undefined && value !== false && value !== "") query.set(key, value === true ? "1" : Array.isArray(value) ? value.join(",") : String(value));
+	return `${path}?${query}`;
+};
+const DONE = new Set([
+	"completed",
+	"failed",
+	"cancelled"
+]);
+/** Typed HTTP routes with bearer or same-origin cookie authentication. */
+export class ServerClient {
+	url;
+	fetchImpl;
+	organization;
+	renewal;
+	onError;
+	token;
+	cookie;
+	constructor(url, auth, options = {}) {
+		this.cookie = "cookie" in auth;
+		this.url = url ? validateUrl(url) : "";
+		if (!this.cookie && !this.url) throw new CoderError("invalid-option", "Bearer clients need a server URL.");
+		this.token = "token" in auth ? auth.token : undefined;
+		this.fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+		this.organization = options.organization;
+		this.renewal = options.renewal;
+		this.onError = options.onError;
+	}
+	request(path, init = {}) {
+		const pending = this.read(path, init);
+		pending.catch(() => {});
+		return pending;
+	}
+	async read(path, init) {
+		if (this.renewal && this.renewal.expiresAt() - Date.now() < 3e4) this.token = await this.renewal.renew();
+		let response = await this.send(path, init);
+		// RFC 6750: an expired or too old token is refreshed once and the call retried.
+		if (response.status === 401 && this.renewal && /invalid_token/.test(response.headers.get("www-authenticate") ?? "")) {
+			this.token = await this.renewal.renew();
+			response = await this.send(path, init);
+		}
+		const text = await response.text().catch(() => "");
+		let body = {};
+		let plain;
+		try {
+			if (text && response.status !== 204) body = JSON.parse(text);
+		} catch {
+			if (response.ok) throw new CoderError("server", `The server answered ${response.status} with a body that is not JSON.`);
+			if (this.cookie && text) plain = text;
+		}
+		if (!response.ok) {
+			const error = new ClientError(response.status, body.error ?? body.message ?? plain ?? `The server answered ${response.status}.`, response.headers.get("www-authenticate") ?? "", body.hint, body.needs === "key" ? body.needs : undefined);
+			this.onError?.(error);
+			throw error;
+		}
+		return body;
+	}
+	send(path, init) {
+		const headers = new Headers(init.headers);
+		if (init.body && !headers.has("content-type")) headers.set("content-type", "application/json");
+		if (!this.cookie) headers.set("authorization", `Bearer ${this.token}`);
+		if (this.organization) headers.set("x-coder-organization", this.organization);
+		return this.fetchImpl(`${this.url}${path}`, {
+			...init,
+			headers,
+			...this.cookie ? { credentials: "same-origin" } : {}
+		}).catch((error) => {
+			if (error instanceof CoderError || error.name === "AbortError") throw error;
+			throw new CoderError("server", this.url ? `No Coder server answers at ${this.url}: ${error.message}` : "The server did not answer. Check the connection and try again.");
+		});
+	}
+	post(path, body) {
+		return this.request(path, {
+			method: "POST",
+			...body !== undefined ? { body: JSON.stringify(body) } : {}
+		});
+	}
+	/** `GET /me`: who the token belongs to. */
+	me() {
+		return this.request("/me");
+	}
+	info() {
+		return this.request("/api/auth/capabilities");
+	}
+	linkAccount(token) {
+		return this.post("/connect", { token });
+	}
+	signOut() {
+		return this.post("/api/auth/sign-out", {});
+	}
+	agents = {
+		list: (options) => this.request(queryPath("/admin/agents", {
+			...options,
+			...options?.connect ? { connect: 1 } : {}
+		})),
+		get: (slug, options) => this.request(queryPath(`/admin/agents/${encodeURIComponent(slug)}`, {
+			...options?.versions === false ? { versions: 0 } : {},
+			...options?.content === false ? { content: 0 } : {},
+			...options?.handles ? { handles: 1 } : {}
+		})),
+		versions: (slug, options = {}) => this.request(queryPath(`/admin/agents/${encodeURIComponent(slug)}/versions`, options)),
+		remove: (slug) => this.request(`/admin/agents/${encodeURIComponent(slug)}`, { method: "DELETE" }),
+		preview: (repo, ref) => this.request(queryPath("/admin/agents/import", {
+			repo,
+			ref
+		})),
+		version: (slug, version) => this.request(`/admin/agents/${encodeURIComponent(slug)}/versions/${version}`),
+		/** Upload one agent's contents; a new version only when something changed. */
+		put: (slug, body) => this.request(`/admin/agents/${encodeURIComponent(slug)}`, {
+			method: "PUT",
+			body: JSON.stringify(body)
+		}).then((result) => ({
+			id: slug,
+			version: result.version,
+			unchanged: result.unchanged,
+			...result.apps?.length ? { apps: result.apps } : {}
+		})),
+		settings: (slug, settings) => this.request(`/admin/agents/${encodeURIComponent(slug)}/settings`, {
+			method: "PATCH",
+			body: JSON.stringify(settings)
+		}),
+		import: (repo, ref, agents) => this.post("/admin/agents/import", {
+			repo,
+			ref,
+			...agents ? { agents } : {}
+		})
+	};
+	/** `GET /admin/composer`: everything the New task composer offers, in one read. */
+	composer() {
+		return this.request("/admin/composer");
+	}
+	folders = {
+		list: () => this.request("/admin/folders"),
+		check: (path) => this.post("/admin/folders/check", { path }),
+		/** Clones an https or ssh git URL with the server machine's git logins, or fetches it again. */
+		clone: (url) => this.post("/admin/folders/clone", { url }),
+		/** Opens the folder dialog on the server's machine; a closed dialog answers `{ ok: false, detail: "" }`. */
+		pick: () => this.post("/admin/folders/pick", {})
+	};
+	tasks = {
+		run: (input) => this.post("/admin/tasks", input),
+		list: (options) => this.request(queryPath("/admin/tasks", {
+			limit: 20,
+			...options,
+			...options?.archived ? { archived: 1 } : {},
+			...options?.summary ? { summary: 1 } : {},
+			...options?.counts ? { counts: 1 } : {}
+		})),
+		get: (id) => this.request(`/admin/tasks/${encodeURIComponent(id)}`),
+		logs: (id, after = -1, limit) => this.request(queryPath(`/admin/tasks/${encodeURIComponent(id)}/logs`, {
+			after,
+			limit
+		})),
+		stream: (id, after = -1, signal) => this.send(`/admin/tasks/${encodeURIComponent(id)}/stream?after=${after}`, {
+			headers: { accept: "text/event-stream" },
+			signal
+		}),
+		/** One stream of the named tasks' changes and every list change in the workspace; `last` resumes after an event id. */
+		events: (ids, last, signal) => this.send(queryPath("/admin/events", { tasks: ids }), {
+			headers: {
+				accept: "text/event-stream",
+				...last ? { "last-event-id": last } : {}
+			},
+			signal
+		}),
+		cancel: (id) => this.post(`/admin/tasks/${encodeURIComponent(id)}/cancel`),
+		/** Steer a running task, or resume a finished one on the same id; overrides apply to a resumed turn. */
+		steer: (id, text, options = {}) => this.post(`/admin/tasks/${encodeURIComponent(id)}/steer`, {
+			text,
+			...options
+		}),
+		ask: (id, question) => this.post(`/admin/tasks/${encodeURIComponent(id)}/ask`, { question }),
+		approve: (id, approvalId, decision) => this.post(`/admin/tasks/${encodeURIComponent(id)}/approve`, {
+			approvalId,
+			decision
+		}),
+		archive: (id) => this.post(`/admin/tasks/${encodeURIComponent(id)}/archive`),
+		delete: (id) => this.request(`/admin/tasks/${encodeURIComponent(id)}`, { method: "DELETE" }),
+		/** Start a task from a prompt, or a flow with `flow` and `args`. */
+		create: (input) => this.post("/admin/tasks", input),
+		/** Follow the task's event stream until it ends; `onLog` sees each log line as it lands. */
+		wait: async (id, options = {}) => {
+			let after = -1;
+			for (;;) {
+				const response = await this.tasks.stream(id, after);
+				if (!response.ok || !response.body) {
+					// `get` renews an expired token before the stream is asked again.
+					const status = await this.tasks.get(id);
+					if (DONE.has(status.status)) return status;
+					if (response.status === 401) continue;
+					throw new CoderError("server", `The task stream answered ${response.status}.`);
+				}
+				let ended = false;
+				for await (const event of serverEvents(response.body)) {
+					if (event.event === "log") {
+						const line = JSON.parse(event.data);
+						after = line.seq;
+						options.onLog?.(line);
+					} else if (event.event === "end") ended = true;
+				}
+				if (ended) return this.tasks.get(id);
+			}
+		}
+	};
+	credentials = {
+		list: (options) => this.request(queryPath("/admin/credentials", options ?? {})),
+		add: (input) => this.post("/admin/credentials", input),
+		remove: (label, { workspace } = {}) => this.request(credentialPath(label, "", workspace), { method: "DELETE" }),
+		setDefault: (label, { workspace } = {}) => this.post(credentialPath(label, "/default", workspace)),
+		login: (engine) => this.post("/admin/logins", { engine }),
+		loginStatus: (id) => this.request(`/admin/logins/${encodeURIComponent(id)}`),
+		loginCode: (id, code) => this.post(`/admin/logins/${encodeURIComponent(id)}`, { code }),
+		cancelLogin: (id) => this.request(`/admin/logins/${encodeURIComponent(id)}`, { method: "DELETE" })
+	};
+	runners = {
+		list: () => this.request("/admin/runners"),
+		add: (input) => this.post("/admin/runners", input),
+		pair: (input) => this.post("/admin/runners/pair", input),
+		update: (id, input) => this.request(`/admin/runners/${encodeURIComponent(id)}`, {
+			method: "PATCH",
+			body: JSON.stringify(input)
+		}),
+		test: (id) => this.post(`/admin/runners/${encodeURIComponent(id)}/test`, {}),
+		remove: (id) => this.request(`/admin/runners/${encodeURIComponent(id)}`, { method: "DELETE" })
+	};
+	integrations = { 
+	/** With `agent`, create steps prefill the platform's form with its name. */
+list: (agent) => this.request(queryPath("/admin/integrations", { agent })) };
+	repositories = {
+		list: () => this.request("/admin/repositories"),
+		refresh: () => this.post("/admin/repositories/refresh", {})
+	};
+	engines = {
+		status: () => this.request("/admin/engines/status"),
+		login: (engine) => this.post(`/admin/engines/${encodeURIComponent(engine)}/login`, {}),
+		logout: (engine) => this.post(`/admin/engines/${encodeURIComponent(engine)}/logout`, {})
+	};
+	apps = {
+		list: (agent) => this.request(queryPath("/admin/apps", { agent })),
+		/** `link` is the installation the new one connects to. */
+		install: (id, back, link) => this.post(queryPath(`/admin/apps/${encodeURIComponent(id)}/install`, {
+			back,
+			link
+		})),
+		/** Forgets a workspace app and its installs; the app itself stays on the platform. */
+		remove: (id) => this.request(`/admin/apps/${encodeURIComponent(id)}`, { method: "DELETE" }),
+		/** Pushes a workspace app to its platform as its agent needs it now, or records that its values were entered there by hand. */
+		update: (id) => this.post(`/admin/apps/${encodeURIComponent(id)}/update`, {}),
+		/** Checks an app Coder cannot push: what to change on its platform by hand. */
+		drift: (id) => this.request(`/admin/apps/${encodeURIComponent(id)}/drift`),
+		/** The transaction a create form posts with to `/create/<integration>/callback`, or the platform's own form to post. */
+		create: (integration, state) => this.post(`/admin/apps/create/${encodeURIComponent(integration)}`, state),
+		/** The same for a create link, whose own transaction may authorize it. */
+		start: (integration, state) => this.post(queryPath(`/create/${encodeURIComponent(integration)}`, state)),
+		/** Posts a create form's values with its transaction; answers where the browser goes next. */
+		finish: (integration, fields) => this.request(`/create/${encodeURIComponent(integration)}/callback`, {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/x-www-form-urlencoded"
+			},
+			body: new URLSearchParams(fields)
+		})
+	};
+	operator = {
+		apps: () => this.request("/admin/operator/apps"),
+		/** The create page for `integration`'s built-in app; `name` is what the platform shows. */
+		setUp: (integration, body) => this.post(`/admin/operator/apps/${encodeURIComponent(integration)}`, body),
+		audit: () => this.request("/admin/operator/audit")
+	};
+	installations = { list: (agent, options = {}) => this.request(queryPath("/admin/installations", {
+		agent,
+		limit: options.limit,
+		...options.active ? { active: 1 } : {}
+	})) };
+	connections = {
+		list: (authorization) => this.request(queryPath("/admin/connections", { authorization })),
+		/** `authorize` is where the browser goes next for an OAuth connection. */
+		add: (body) => this.post("/admin/connections", body),
+		update: (id, body) => this.request(`/admin/connections/${encodeURIComponent(id)}`, {
+			method: "PATCH",
+			body: JSON.stringify(body)
+		}),
+		remove: (id) => this.request(`/admin/connections/${encodeURIComponent(id)}`, { method: "DELETE" }),
+		/** Start OAuth again for a connection that needs reconnecting. */
+		authorize: (id) => this.post(`/admin/connections/${encodeURIComponent(id)}/authorize`)
+	};
+	config = {
+		get: () => this.request("/admin/config"),
+		put: (body) => this.request("/admin/config", {
+			method: "PUT",
+			body: JSON.stringify(body)
+		}),
+		patch: (body) => this.request("/admin/config", {
+			method: "PATCH",
+			headers: { "content-type": "application/merge-patch+json" },
+			body: JSON.stringify(body)
+		})
+	};
+	models = {
+		list: () => this.request("/admin/models"),
+		add: (body) => this.post("/admin/models", body),
+		probe: (body) => this.post("/admin/models/probe", body),
+		remove: (name) => this.request(`/admin/models/${encodeURIComponent(name)}`, { method: "DELETE" }),
+		alias: (name, spec) => this.post(`/admin/models/${encodeURIComponent(name)}/alias`, { spec }),
+		enable: (name) => this.post(`/admin/models/${encodeURIComponent(name)}/enable`),
+		disable: (name) => this.post(`/admin/models/${encodeURIComponent(name)}/disable`)
+	};
+	mcp = { search: (q) => this.request(queryPath("/admin/mcp-registry", { q })) };
+	flows = {
+		list: (repo) => this.request(queryPath("/admin/flows", { repo })),
+		run: (name, body) => this.post(`/admin/flows/${encodeURIComponent(name)}/run`, body)
+	};
+	pulls = { list: (repo) => this.request(queryPath("/admin/pulls", { repo })) };
+	review(body) {
+		return this.post("/admin/review", body);
+	}
+	usage(options = {}) {
+		return this.request(queryPath("/admin/usage/totals", {
+			...options,
+			since: options.since ?? Date.now() - 7 * 24 * 60 * 60 * 1e3
+		}));
+	}
+	usageRows(installation) {
+		return this.request(queryPath("/admin/usage", { installation }));
+	}
+}
+/** Server-Sent Events from a response body, one `{ event, data }` per message. */
+export async function* serverEvents(body) {
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for await (const chunk of body) {
+		buffer += decoder.decode(chunk, { stream: true });
+		let end;
+		while ((end = buffer.indexOf("\n\n")) >= 0) {
+			const block = buffer.slice(0, end);
+			buffer = buffer.slice(end + 2);
+			let event = "message";
+			let id;
+			const data = [];
+			for (const line of block.split("\n")) {
+				if (line.startsWith("event: ")) event = line.slice(7);
+				else if (line.startsWith("data: ")) data.push(line.slice(6));
+				else if (line.startsWith("id: ")) id = line.slice(4);
+			}
+			if (data.length || id) yield {
+				event,
+				data: data.join("\n"),
+				...id ? { id } : {}
+			};
+		}
+	}
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/core/defaults.e6ce0944639198a2.js

@@ -0,0 +1,31 @@
+/** Built-in config every file and flag merges over; import-free so the shipped dashboard can read it. */
+export const DEFAULT_CONFIG = {
+	// Agents are tried in order; the next one is the fallback when the previous
+	// fails to start (missing binary, auth, quota, rate limit).
+	chain: ["codex", "claude"],
+	engines: {
+		codex: {
+			model: "gpt-6.1-sol",
+			effort: "high",
+			permissions: "auto"
+		},
+		claude: {
+			model: "opus",
+			effort: "medium",
+			permissions: "auto"
+		}
+	},
+	models: {},
+	approvals: {
+		escalationTimeoutMs: 12e4,
+		allowedNetworkHosts: []
+	}
+};
+/** The engine an agent runs on when its settings name none. */
+export const DEFAULT_ENGINE = DEFAULT_CONFIG.chain[0];
+/** The default task list's groups: failed first, then active, then other stopped, then completed. */
+export const listRank = (status) => status === "failed" ? 0 : status === "completed" ? 3 : status === "cancelled" ? 2 : 1;
+/** Ids in byte order, as Postgres `collate "C"` compares them. */
+export const byId = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/** The task list order: `listRank` groups, newest start first, ties broken by id. */
+export const byListKey = (a, b) => a.rank - b.rank || b.createdAt - a.createdAt || byId(b.id, a.id);

package/dist/dash/standalone/server/modules-server-server-react-server/src/core/errors.5954bd9bd05e8230.js

@@ -0,0 +1,22 @@
+export class CoderError extends Error {
+	code;
+	hint;
+	taskId;
+	/** chain-exhausted: the run-native-subagent payload the CLI prints on exit 3. */
+	payload;
+	/** approval-pending: the approval to answer. */
+	approval;
+	/** task-failed (flow task()): the failed task's result. */
+	result;
+	/** flow-failed: the run to resume. */
+	runId;
+	/** server: the HTTP status the server answered with. */
+	status;
+	needs;
+	constructor(code, message, extra = {}) {
+		super(message);
+		this.name = "CoderError";
+		this.code = code;
+		Object.assign(this, extra);
+	}
+}

package/dist/dash/standalone/server/modules-server-server-react-server/src/core/task/log-view.871cbff2605b5cfd.js

@@ -0,0 +1,212 @@
+export const isApproval = (kind) => kind.includes("approval") || kind === "sidecar-decision" || kind === "auto-review";
+const ANSI = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+export function stripCwd(text, cwd) {
+	return cwd ? text.split(`${cwd}/`).join("").split(cwd).join(".") : text;
+}
+/** Decode structured runner output without treating arbitrary JSON as an event. */
+export function logEntry(line) {
+	try {
+		const value = JSON.parse(line);
+		if (value && typeof value === "object" && !Array.isArray(value)) {
+			const kind = "kind" in value && typeof value.kind === "string" ? value.kind : undefined;
+			const message = "message" in value && typeof value.message === "string" ? value.message : undefined;
+			if (kind !== undefined || message !== undefined) return {
+				...value,
+				kind,
+				message,
+				at: "at" in value && typeof value.at === "string" ? value.at : undefined
+			};
+		}
+	} catch {}
+	return undefined;
+}
+/** One reducer per transcript, also used by the terminal renderer. */
+export class LogView {
+	cwd;
+	opts;
+	prevKind = null;
+	lastAssistant = "";
+	lastToolText = "";
+	openCalls = [];
+	// Engine invocation ids, so concurrent calls of one tool close with their own results.
+	callIds = new WeakMap();
+	approval;
+	approvals = new Map();
+	lastUsageTotal = 0;
+	constructor(cwd, opts = {}) {
+		this.cwd = cwd;
+		this.opts = opts;
+	}
+	get lastAssistantMessage() {
+		return this.lastAssistant;
+	}
+	/** A result or verdict that completes an earlier call or approval returns that row again, keyed by its seq. */
+	reduce(record) {
+		const entry = record.entry;
+		const sourceKind = entry ? String(entry.kind ?? "status") : "line";
+		const earlier = !entry ? undefined : sourceKind === "tool-result" ? this.close(record, entry) : isApproval(sourceKind) ? this.decide(record, entry, sourceKind) : undefined;
+		if (earlier) {
+			this.prevKind = sourceKind;
+			return [earlier];
+		}
+		const row = {
+			seq: record.seq,
+			at: record.at,
+			kind: "status",
+			title: "",
+			sourceKind,
+			separated: false,
+			tone: "muted"
+		};
+		if (!entry) {
+			row.kind = record.level === "err" ? "error" : record.level === "sys" ? "status" : "line";
+			row.title = stripCwd(record.line, this.cwd);
+			if (record.level === "err") row.tone = "error";
+		} else if (sourceKind === "usage") {
+			const tokens = entry.tokens;
+			if (!tokens) return [];
+			const seeded = this.lastUsageTotal > 0;
+			const grown = tokens.total - this.lastUsageTotal;
+			if (!seeded || grown < Math.max(2e4, this.lastUsageTotal * .2)) {
+				this.lastUsageTotal = Math.max(this.lastUsageTotal, tokens.total);
+				return [];
+			}
+			this.lastUsageTotal = tokens.total;
+			row.kind = "usage";
+			row.tokens = tokens;
+			row.title = `ctx ${tokenCount(tokens.input + tokens.cachedInput)} · out ${tokenCount(tokens.output)}`;
+		} else if (sourceKind === "approval-decision" && entry.decision === "escalate" || sourceKind === "approval-escalated") {
+			const summary = stripCwd(entry.summary ? String(entry.summary) : "", this.cwd);
+			const target = /^(?:run command: |Run command\. |Apply file changes\. |\w+: )?([\s\S]*)$/.exec(summary)[1];
+			const method = String(entry.method ?? "");
+			const name = method && !method.includes("/") ? method : this.openCalls.at(-1)?.tool;
+			const word = target.startsWith("{") ? "" : target.split(/\s+/)[0];
+			const reason = stripCwd(entry.reason ? String(entry.reason) : "", this.cwd);
+			row.kind = "approval";
+			row.title = ["Approval", [name, word].filter(Boolean).join(" ")].filter(Boolean).join(" · ");
+			row.detail = [target, reason && `Policy · ${reason}`].filter(Boolean).join("\n");
+			row.state = sourceKind === "approval-escalated" ? "waiting" : "escalated";
+			if (sourceKind === "approval-escalated") this.approvals.set(String(entry.approvalId), row);
+			else this.approval = row;
+		} else if (isApproval(sourceKind) && (entry.decision || !entry.message)) {
+			row.kind = "approval";
+			const label = sourceKind === "sidecar-decision" ? "sidecar" : sourceKind === "auto-review" ? "auto-review" : "approval";
+			const risk = entry.riskLevel ? `(${String(entry.riskLevel)} risk)` : "";
+			const summary = stripCwd(entry.summary ? String(entry.summary) : "", this.cwd);
+			const target = summary.slice(summary.indexOf(": ") + 2);
+			const shown = summary && target && this.lastToolText.includes(target) ? "" : summary;
+			const method = shown ? "" : String(entry.method ?? "");
+			row.title = `${[
+				label,
+				String(entry.decision ?? ""),
+				risk,
+				method
+			].filter(Boolean).join(" ")}${shown ? ` · ${shown}` : ""}`;
+			row.detail = stripCwd(entry.reason ? String(entry.reason) : "", this.cwd);
+		} else {
+			const raw = entry.message ? String(entry.message) : sourceKind === "tool-result" ? "(no output)" : String(entry.tool || entry.kind || "");
+			if (!raw && !(sourceKind === "tool-result" && (entry.exitCode != null || entry.isError))) return [];
+			row.title = stripCwd(raw, this.cwd);
+			if (sourceKind === "assistant") {
+				row.kind = "assistant";
+				row.tone = undefined;
+				this.lastAssistant = row.title;
+			} else if (sourceKind === "error" || sourceKind === "steer") {
+				row.kind = sourceKind;
+				row.tone = sourceKind === "error" ? "error" : "warning";
+			} else if (sourceKind === "reasoning") {
+				row.kind = "reasoning";
+				row.durationMs = typeof entry.durationMs === "number" ? entry.durationMs : 0;
+			} else if (sourceKind === "tool") {
+				row.kind = "tool";
+				if (entry.tool) row.tool = String(entry.tool);
+				this.lastToolText = row.title;
+				if (entry.callId) this.callIds.set(row, String(entry.callId));
+				this.openCalls.push(row);
+			} else if (sourceKind === "tool-result") {
+				row.kind = "tool-result";
+				row.title = this.output(raw);
+				row.exitCode = typeof entry.exitCode === "number" ? entry.exitCode : undefined;
+				row.tone = row.exitCode !== undefined && row.exitCode !== 0 || entry.isError === true ? "error" : "muted";
+				row.durationMs = typeof entry.durationMs === "number" ? entry.durationMs : 0;
+				if (entry.tool) row.tool = String(entry.tool);
+			}
+		}
+		if (this.prevKind !== null) {
+			row.separated = [
+				"assistant",
+				"error",
+				"steer"
+			].includes(sourceKind) || sourceKind === "reasoning" && this.prevKind !== "reasoning" || sourceKind === "tool" && ["assistant", "reasoning"].includes(this.prevKind);
+		}
+		this.prevKind = sourceKind;
+		return [row];
+	}
+	// A result closes the call with its invocation id; without one, the oldest open call of its tool, or the latest call.
+	close(record, entry) {
+		const tool = entry.tool ? String(entry.tool) : undefined;
+		const byId = entry.callId ? this.openCalls.findIndex((call) => this.callIds.get(call) === String(entry.callId)) : -1;
+		const index = entry.callId ? byId : tool ? this.openCalls.findIndex((call) => call.tool === tool) : this.openCalls.length - 1;
+		if (index < 0) return undefined;
+		const [call] = this.openCalls.splice(index, 1);
+		const exitCode = typeof entry.exitCode === "number" ? entry.exitCode : undefined;
+		const durationMs = typeof entry.durationMs === "number" ? entry.durationMs : record.at - call.at || 0;
+		return {
+			...call,
+			title: entry.callMessage ? stripCwd(String(entry.callMessage), this.cwd) : call.title,
+			result: {
+				ok: !exitCode && entry.isError !== true,
+				exitCode,
+				durationMs: Math.max(0, durationMs),
+				detail: this.output(entry.message ? String(entry.message) : "")
+			}
+		};
+	}
+	// Sidecar verdicts and escalations follow the policy verdict before them; answers carry the approval id.
+	decide(record, entry, kind) {
+		const id = String(entry.approvalId ?? "");
+		const accepted = entry.decision === "accept";
+		if (kind === "sidecar-decision" && this.approval) {
+			const reason = stripCwd(entry.reason ? String(entry.reason) : "", this.cwd);
+			const row = {
+				...this.approval,
+				detail: [this.approval.detail, reason && `Sidecar · ${reason}`].filter(Boolean).join("\n")
+			};
+			if (entry.decision === "escalate") return this.approval = row;
+			this.approval = undefined;
+			return settle(row, record, `${accepted ? "accepted" : "denied"} by sidecar`, accepted);
+		}
+		if (kind === "approval-escalated" && this.approval) {
+			const row = {
+				...this.approval,
+				state: "waiting"
+			};
+			this.approval = undefined;
+			this.approvals.set(id, row);
+			return row;
+		}
+		const open = this.approvals.get(id);
+		if (!open || kind !== "approval-answered" && kind !== "approval-timeout") return undefined;
+		this.approvals.delete(id);
+		return kind === "approval-timeout" ? settle(open, record, "timed out", false) : settle(open, record, `${accepted ? "accepted" : "denied"} by reviewer`, accepted);
+	}
+	output(text) {
+		return stripCwd(this.opts.keepAnsi ? text : text.replace(ANSI, ""), this.cwd);
+	}
+}
+function settle(row, record, state, ok) {
+	return {
+		...row,
+		state,
+		result: {
+			ok,
+			durationMs: Math.max(0, record.at - row.at || 0),
+			detail: ""
+		}
+	};
+}
+function tokenCount(n) {
+	if (n < 1e3) return String(n);
+	if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+	return `${(n / 1e6).toFixed(1)}M`;
+}