@iowarp/clio-coder 0.4.0 → 0.4.2

package/src/domains/mux/socket-client.ts

@@ -36,14 +36,18 @@ import {
 	MuxError,
 	type MuxEvent,
 	type MuxEventKind,
+	type MuxLayoutNode,
+	type MuxLayoutTree,
 	type MuxLog,
 	type MuxNotificationSound,
 	type MuxPane,
+	type MuxRect,
 	type MuxReportableAgentState,
 	MuxRequestTimeout,
 	type MuxServerInfo,
 	type MuxSnapshot,
 	type MuxTab,
+	type MuxTabGeometry,
 	type MuxWorktree,
 	type MuxWorktreeSource,
 	muxErrorKind,
@@ -192,8 +196,32 @@ export interface MuxClient {
 	/** Set the pane's operator-facing label. Available on herdr protocol 17. */
 	paneRename(paneId: string, label: string): Promise<void>;
 	paneClose(paneId: string): Promise<void>;
-	/** Pane ids sharing a tab with `paneId`, read off the tab's layout snapshot. */
-	paneLayout(paneId?: string): Promise<ReadonlyArray<string>>;
+	/**
+	 * Cell-precise geometry of the tab holding `paneId` (the server's focused
+	 * pane when omitted): outer area, pane rects, and live split ratios.
+	 */
+	paneLayout(paneId?: string): Promise<MuxTabGeometry>;
+	/**
+	 * Focus a pane. This switches the focused tab as well as the pane (verified
+	 * on 0.8.2), so it is only ever driven by an explicit "show me" request,
+	 * never by background bookkeeping.
+	 */
+	paneFocus(paneId: string): Promise<void>;
+	/** Zoom a pane. Zooming an unfocused pane steals focus; same rule as paneFocus. */
+	paneZoom(paneId: string, mode: "on" | "off" | "toggle"): Promise<{ changed: boolean; focusChanged: boolean }>;
+	/** Portable layout tree for a tab, or the tab holding `paneId`. */
+	layoutExport(request?: { tabId?: string; paneId?: string }): Promise<MuxLayoutTree>;
+	/**
+	 * Set one split's ratio, addressed by a boolean path from the root split
+	 * (`false` descends first, `true` second; `[]` is the root). Returns the
+	 * updated tree.
+	 */
+	layoutSetSplitRatio(request: {
+		tabId?: string;
+		paneId?: string;
+		path: ReadonlyArray<boolean>;
+		ratio: number;
+	}): Promise<MuxLayoutTree>;
 	worktreeList(request?: MuxWorktreeListRequest): Promise<MuxWorktreeListResult>;
 	worktreeCreate(request: MuxWorktreeCreateRequest): Promise<MuxWorktreeCreatedResult>;
 	worktreeOpen(request: MuxWorktreeOpenRequest): Promise<MuxWorktreeOpenedResult>;
@@ -410,8 +438,93 @@ function readSnapshot(value: unknown): MuxSnapshot {
 	};
 }
 
+function requireNumber(source: Record<string, unknown>, key: string, context: string): number {
+	const value = source[key];
+	if (typeof value !== "number") {
+		throw new MuxError("protocol", `mux ${context} response is missing number field ${key}`);
+	}
+	return value;
+}
+
+function readRect(value: unknown, context: string): MuxRect {
+	const source = asRecord(value);
+	if (!source) throw new MuxError("protocol", `mux ${context} rect is not an object`);
+	return {
+		x: requireNumber(source, "x", context),
+		y: requireNumber(source, "y", context),
+		width: requireNumber(source, "width", context),
+		height: requireNumber(source, "height", context),
+	};
+}
+
+function readSplitDirection(value: unknown, context: string): "right" | "down" {
+	if (value === "right" || value === "down") return value;
+	throw new MuxError("protocol", `mux ${context} split direction is not right/down`);
+}
+
+/** Parses a `PaneLayoutSnapshot`: the shape `pane.layout` and `layout_updated` both carry. */
+function readTabGeometry(value: unknown): MuxTabGeometry {
+	const source = asRecord(value);
+	if (!source) throw new MuxError("protocol", "mux layout snapshot is not an object");
+	return {
+		workspaceId: requireString(source, "workspace_id", "layout"),
+		tabId: requireString(source, "tab_id", "layout"),
+		zoomed: source.zoomed === true,
+		area: readRect(source.area, "layout"),
+		focusedPaneId: optionalString(source, "focused_pane_id"),
+		panes: readArray(source, "panes").map((entry) => {
+			const pane = asRecord(entry);
+			if (!pane) throw new MuxError("protocol", "mux layout pane entry is not an object");
+			return {
+				paneId: requireString(pane, "pane_id", "layout pane"),
+				focused: pane.focused === true,
+				rect: readRect(pane.rect, "layout pane"),
+			};
+		}),
+		splits: readArray(source, "splits").map((entry) => {
+			const split = asRecord(entry);
+			if (!split) throw new MuxError("protocol", "mux layout split entry is not an object");
+			return {
+				direction: readSplitDirection(split.direction, "layout"),
+				ratio: requireNumber(split, "ratio", "layout split"),
+				rect: readRect(split.rect, "layout split"),
+			};
+		}),
+	};
+}
+
+function readLayoutNode(value: unknown): MuxLayoutNode {
+	const source = asRecord(value);
+	if (!source) throw new MuxError("protocol", "mux layout node is not an object");
+	if (source.type === "pane") {
+		return { type: "pane", paneId: optionalString(source, "pane_id"), label: optionalString(source, "label") };
+	}
+	if (source.type === "split") {
+		return {
+			type: "split",
+			direction: readSplitDirection(source.direction, "layout tree"),
+			ratio: requireNumber(source, "ratio", "layout tree split"),
+			first: readLayoutNode(source.first),
+			second: readLayoutNode(source.second),
+		};
+	}
+	throw new MuxError("protocol", "mux layout node has an unknown type");
+}
+
+function readLayoutTree(value: unknown): MuxLayoutTree {
+	const source = asRecord(value);
+	if (!source) throw new MuxError("protocol", "mux layout tree is not an object");
+	return {
+		workspaceId: requireString(source, "workspace_id", "layout tree"),
+		tabId: requireString(source, "tab_id", "layout tree"),
+		zoomed: source.zoomed === true,
+		focusedPaneId: optionalString(source, "focused_pane_id"),
+		root: readLayoutNode(source.root),
+	};
+}
+
 /** herdr names lifecycle event kinds with underscores on the wire and dots in subscriptions. */
-const EVENT_KIND_BY_WIRE: Readonly<Record<string, MuxEventKind>> = {
+const PANE_LEAVE_KIND_BY_WIRE: Readonly<Record<string, "pane.closed" | "pane.exited">> = {
 	pane_closed: "pane.closed",
 	pane_exited: "pane.exited",
 };
@@ -419,14 +532,37 @@ const EVENT_KIND_BY_WIRE: Readonly<Record<string, MuxEventKind>> = {
 function readEvent(line: Record<string, unknown>): MuxEvent | null {
 	const wireKind = line.event;
 	if (typeof wireKind !== "string") return null;
-	const kind = EVENT_KIND_BY_WIRE[wireKind];
-	if (!kind) return null;
 	const data = asRecord(line.data);
 	if (!data) return null;
-	const paneId = data.pane_id;
-	const workspaceId = data.workspace_id;
-	if (typeof paneId !== "string" || typeof workspaceId !== "string") return null;
-	return { kind, paneId, workspaceId };
+	const leaveKind = PANE_LEAVE_KIND_BY_WIRE[wireKind];
+	if (leaveKind) {
+		const paneId = data.pane_id;
+		const workspaceId = data.workspace_id;
+		if (typeof paneId !== "string" || typeof workspaceId !== "string") return null;
+		return { kind: leaveKind, paneId, workspaceId };
+	}
+	if (wireKind === "pane_moved") {
+		// The move rewrites the pane id; the payload carries the new pane record
+		// plus the id it replaced, and consumers continue from the new one.
+		const pane = asRecord(data.pane);
+		const previousPaneId = data.previous_pane_id;
+		if (!pane || typeof previousPaneId !== "string") return null;
+		const paneId = pane.pane_id;
+		const tabId = pane.tab_id;
+		const workspaceId = pane.workspace_id;
+		if (typeof paneId !== "string" || typeof tabId !== "string" || typeof workspaceId !== "string") return null;
+		return { kind: "pane.moved", paneId, previousPaneId, tabId, workspaceId };
+	}
+	if (wireKind === "layout_updated") {
+		// The push already carries the full tab geometry, so a consumer never
+		// has to answer a layout event with a layout request.
+		try {
+			return { kind: "layout.updated", geometry: readTabGeometry(data.layout) };
+		} catch {
+			return null;
+		}
+	}
+	return null;
 }
 
 /** Drops undefined entries so an optional field is absent rather than `null` on the wire. */
@@ -693,17 +829,29 @@ export function createMuxClient(options: MuxClientOptions): MuxClient {
 		async paneClose(paneId: string): Promise<void> {
 			await call("pane.close", { pane_id: paneId });
 		},
-		async paneLayout(paneId?: string): Promise<ReadonlyArray<string>> {
+		async paneLayout(paneId?: string): Promise<MuxTabGeometry> {
 			const result = await callObject("pane.layout", params({ pane_id: paneId }));
-			const layout = asRecord(result.layout);
-			if (!layout) throw new MuxError("protocol", "mux pane.layout returned no layout");
-			const ids: string[] = [];
-			for (const entry of readArray(layout, "panes")) {
-				const pane = asRecord(entry);
-				const id = pane ? pane.pane_id : undefined;
-				if (typeof id === "string") ids.push(id);
-			}
-			return ids;
+			return readTabGeometry(result.layout);
+		},
+		async paneFocus(paneId: string): Promise<void> {
+			await call("pane.focus", { pane_id: paneId });
+		},
+		async paneZoom(paneId: string, mode: "on" | "off" | "toggle"): Promise<{ changed: boolean; focusChanged: boolean }> {
+			const result = await callObject("pane.zoom", { pane_id: paneId, mode });
+			const zoom = asRecord(result.zoom);
+			if (!zoom) throw new MuxError("protocol", "mux pane.zoom returned no zoom result");
+			return { changed: zoom.changed === true, focusChanged: zoom.focus_changed === true };
+		},
+		async layoutExport(request = {}): Promise<MuxLayoutTree> {
+			const result = await callObject("layout.export", params({ tab_id: request.tabId, pane_id: request.paneId }));
+			return readLayoutTree(result.layout);
+		},
+		async layoutSetSplitRatio(request): Promise<MuxLayoutTree> {
+			const result = await callObject(
+				"layout.set_split_ratio",
+				params({ tab_id: request.tabId, pane_id: request.paneId, path: [...request.path], ratio: request.ratio }),
+			);
+			return readLayoutTree(result.layout);
 		},
 		async worktreeList(request = {}): Promise<MuxWorktreeListResult> {
 			const result = await callObject("worktree.list", params({ workspace_id: request.workspaceId, cwd: request.cwd }));

package/src/domains/mux/types.ts

@@ -97,14 +97,57 @@ export interface MuxSnapshot {
 	tabs: ReadonlyArray<MuxTab>;
 }
 
-/** Lifecycle event kinds Phase 1 subscribes to. */
-export type MuxEventKind = "pane.closed" | "pane.exited";
+/** Lifecycle event kinds the pane layer can subscribe to. */
+export type MuxEventKind = "pane.closed" | "pane.exited" | "pane.moved" | "layout.updated";
 
-/** One pushed lifecycle event. */
-export interface MuxEvent {
-	kind: MuxEventKind;
-	paneId: string;
+/**
+ * One pushed lifecycle event. A discriminated union because the payloads
+ * differ: pane leave events carry the pane, a move carries the id rewrite
+ * herdr performs, and a layout update carries the whole tab geometry so a
+ * consumer does not have to turn around and fetch what the push already said.
+ */
+export type MuxEvent =
+	| { kind: "pane.closed" | "pane.exited"; paneId: string; workspaceId: string }
+	| { kind: "pane.moved"; paneId: string; previousPaneId: string; tabId: string; workspaceId: string }
+	| { kind: "layout.updated"; geometry: MuxTabGeometry };
+
+/** One rectangle in terminal cells, as herdr's layout snapshots report them. */
+export interface MuxRect {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+}
+
+/**
+ * Cell-precise geometry of one tab: the outer area, every pane's rect, and
+ * every split with its live ratio. This is what dock sizing converges on.
+ */
+export interface MuxTabGeometry {
+	workspaceId: string;
+	tabId: string;
+	zoomed: boolean;
+	area: MuxRect;
+	focusedPaneId: string | null;
+	panes: ReadonlyArray<{ paneId: string; focused: boolean; rect: MuxRect }>;
+	splits: ReadonlyArray<{ direction: "right" | "down"; ratio: number; rect: MuxRect }>;
+}
+
+/**
+ * One node of a portable tab layout tree, as `layout.export` describes it.
+ * Split ratio is the share of the axis the `first` child keeps.
+ */
+export type MuxLayoutNode =
+	| { type: "pane"; paneId: string | null; label: string | null }
+	| { type: "split"; direction: "right" | "down"; ratio: number; first: MuxLayoutNode; second: MuxLayoutNode };
+
+/** A whole tab's portable layout tree. */
+export interface MuxLayoutTree {
 	workspaceId: string;
+	tabId: string;
+	zoomed: boolean;
+	focusedPaneId: string | null;
+	root: MuxLayoutNode;
 }
 
 /** Where Clio's own pane lives, read from the herdr environment. */

package/src/domains/mux/yazi/assets/yazi.toml

@@ -1,5 +1,5 @@
-# Yazi config for orchestration TUI
-# Git status integration
+# Clio Coder files pane: engine configuration. The pane host lists the pane by
+# the label Clio sets ("files"); this file only shapes what the engine shows.
 
 [mgr]
 show_hidden = true

package/src/domains/mux/yazi/event-stream.ts

@@ -3,6 +3,8 @@ import { StringDecoder } from "node:string_decoder";
 
 export const YAZI_STREAM_POLL_MS = 250;
 export const YAZI_STREAM_MAX_BYTES = 1024 * 1024;
+export const YAZI_PICK_EVENT = "clio-coder-pick";
+export const LEGACY_YAZI_PICK_EVENT = "clio-pick";
 
 export interface YaziCdEvent {
 	kind: "cd";
@@ -13,7 +15,7 @@ export interface YaziCdEvent {
 }
 
 export interface YaziPickEvent {
-	kind: "clio-pick";
+	kind: typeof YAZI_PICK_EVENT;
 	receiver: string;
 	sender: string;
 	values: ReadonlyArray<string>;
@@ -61,7 +63,7 @@ export function parseYaziEventLine(line: string): YaziEvent | null {
 	const third = second < 0 ? -1 : line.indexOf(",", second + 1);
 	if (first <= 0 || second <= first + 1 || third <= second + 1) return null;
 	const kind = line.slice(0, first);
-	if (kind !== "cd" && kind !== "clio-pick") return null;
+	if (kind !== "cd" && kind !== YAZI_PICK_EVENT && kind !== LEGACY_YAZI_PICK_EVENT) return null;
 	const receiver = line.slice(first + 1, second);
 	const sender = line.slice(second + 1, third);
 	try {
@@ -73,7 +75,7 @@ export function parseYaziEventLine(line: string): YaziEvent | null {
 			return { kind, receiver, sender, tab: String(tab), cwd: body.url };
 		}
 		if (!Array.isArray(body) || !body.every((value) => typeof value === "string")) return null;
-		return { kind, receiver, sender, values: body };
+		return { kind: YAZI_PICK_EVENT, receiver, sender, values: body };
 	} catch {
 		return null;
 	}
@@ -152,7 +154,7 @@ export function createYaziEventStream(options: YaziEventStreamOptions): YaziEven
 				const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
 				if (line.length === 0) continue;
 				const kind = line.slice(0, line.indexOf(","));
-				if (kind !== "cd" && kind !== "clio-pick") continue;
+				if (kind !== "cd" && kind !== YAZI_PICK_EVENT && kind !== LEGACY_YAZI_PICK_EVENT) continue;
 				const event = parseYaziEventLine(line);
 				if (!event) {
 					state.malformedLines += 1;

package/src/domains/mux/yazi/profile.ts

@@ -119,7 +119,7 @@ function shellQuote(value: string): string {
 
 /** Render the one Clio key chord, with an absolute `ya` path for vendored installs. */
 export function renderYaziKeymap(yaPath: string): string {
-	const command = `shell -- ${shellQuote(yaPath)} pub-to "$YAZI_ID" clio-pick --list "$CLIO_YAZI_PICK_TOKEN" %s`;
+	const command = `shell -- ${shellQuote(yaPath)} pub-to "$YAZI_ID" clio-coder-pick --list "$CLIO_CODER_YAZI_PICK_TOKEN" %s`;
 	return `# Generated by Clio Coder. Changes are replaced when the managed profile regenerates.
 
 [[mgr.prepend_keymap]]

package/src/domains/mux/yazi/session.ts

@@ -1,13 +1,21 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { namingCompatibilityEnvironment } from "../../../core/naming-compat.js";
 import { clioCacheDir } from "../../../core/xdg.js";
 import { findPinnedTool } from "../../toolchain/registry.js";
 import { describeResolution, resolveToolBinary, toolStatus } from "../../toolchain/resolve.js";
 import type { MuxContract } from "../contract.js";
 import type { MuxPaneRef } from "../types.js";
-import { createYaziEventStream, YAZI_STREAM_POLL_MS, type YaziEvent, type YaziEventStream } from "./event-stream.js";
+import {
+	createYaziEventStream,
+	LEGACY_YAZI_PICK_EVENT,
+	YAZI_PICK_EVENT,
+	YAZI_STREAM_POLL_MS,
+	type YaziEvent,
+	type YaziEventStream,
+} from "./event-stream.js";
 import { ensureYaziProfile, type YaziProfile, yaziProfileDir } from "./profile.js";
 
 export type YaziSessionMode = "companion" | "chooser";
@@ -55,6 +63,11 @@ export interface YaziSessionOptions {
 	mode: YaziSessionMode;
 	profileMode: YaziProfileMode;
 	cwd: string;
+	/**
+	 * Files-dock share of the height. Set by the interactive bridge from
+	 * `interface.panes.files.ratio`; absent it, the dock spec's default governs.
+	 */
+	dockShare?: number;
 	onEvent: (event: YaziEvent) => void;
 	onChooser: (result: YaziChooserResult) => void;
 	onStopped?: (reason: string) => void;
@@ -94,6 +107,37 @@ function readOptional(path: string): string {
 	}
 }
 
+/** Transport files older than this are leftovers of a process that never reached its cleanup. */
+export const YAZI_STALE_TRANSPORT_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Drop transport files no live session can own. A crash, a kill, or a
+ * release before cleanup existed leaves `.stream`, `.chooser`, and `.cwd`
+ * files behind; a day is long past any pane's life, so anything older goes.
+ */
+export function sweepStaleTransportFiles(sessionsDir: string, now: number = Date.now()): number {
+	let removed = 0;
+	let entries: string[];
+	try {
+		entries = readdirSync(sessionsDir);
+	} catch {
+		return 0;
+	}
+	for (const name of entries) {
+		if (!/\.(stream|chooser|cwd)$/u.test(name)) continue;
+		const path = join(sessionsDir, name);
+		try {
+			if (now - statSync(path).mtimeMs > YAZI_STALE_TRANSPORT_MS) {
+				rmSync(path, { force: true });
+				removed += 1;
+			}
+		} catch {
+			// A file that vanished between readdir and stat was someone else's to remove.
+		}
+	}
+	return removed;
+}
+
 /** Open one mux-hosted Yazi process and own its DDS or chooser-file transport. */
 export async function createYaziSession(options: YaziSessionOptions): Promise<YaziSessionOpenResult> {
 	const binaries = (options.resolveBinaries ?? resolveYaziBinaries)();
@@ -112,6 +156,7 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 	const sessionId = options.sessionId ?? randomUUID();
 	const sessionsDir = join(cacheDir, "yazi", "sessions");
 	mkdirSync(sessionsDir, { recursive: true });
+	sweepStaleTransportFiles(sessionsDir);
 	const managedProfile =
 		options.profileMode === "managed"
 			? (options.ensureProfile ?? ensureYaziProfile)({
@@ -130,13 +175,19 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 	const token = options.mode === "companion" ? (options.pickToken ?? randomUUID()) : null;
 	const env: Record<string, string> = {
 		...(managedProfile ? { YAZI_CONFIG_HOME: managedProfile.dir } : {}),
-		...(token ? { CLIO_YAZI_PICK_TOKEN: token } : {}),
+		...(token ? namingCompatibilityEnvironment("CLIO_CODER_YAZI_PICK_TOKEN", "CLIO_YAZI_PICK_TOKEN", token) : {}),
 	};
 	let argv: ReadonlyArray<string>;
 	let stdoutPath: string | undefined;
 	if (options.mode === "companion") {
 		writeFileSync(streamPath, "");
-		argv = [binaries.yaziPath, "--local-events", "cd,clio-pick", "--remote-events", "clio-pick"];
+		argv = [
+			binaries.yaziPath,
+			"--local-events",
+			`cd,${YAZI_PICK_EVENT},${LEGACY_YAZI_PICK_EVENT}`,
+			"--remote-events",
+			`${YAZI_PICK_EVENT},${LEGACY_YAZI_PICK_EVENT}`,
+		];
 		stdoutPath = streamPath;
 	} else {
 		writeFileSync(chooserPath, "");
@@ -144,14 +195,30 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 		argv = [binaries.yaziPath, options.cwd, "--chooser-file", chooserPath, "--cwd-file", cwdPath];
 	}
 
+	// Transport files are per session and worthless once it ends: a pick has
+	// already been consumed by the bridge, and a chooser file has been read.
+	// Removing them here is what keeps `<cache>/yazi/sessions` from growing by
+	// three files per open for the life of the install.
+	const removeTransportFiles = (): void => {
+		for (const path of [streamPath, chooserPath, cwdPath]) rmSync(path, { force: true });
+	};
+
 	const pane = await options.mux.openUtilityPane({
 		argv,
 		cwd: options.cwd,
-		label: "yazi",
+		label: "files",
+		title: "files",
+		// The files dock: split down from the anchor at the configured share.
+		// Degrades to a plain split inside the contract when the layout tier is
+		// absent.
+		dock: { slot: "files", ...(options.dockShare === undefined ? {} : { share: options.dockShare }) },
 		...(Object.keys(env).length > 0 ? { env } : {}),
 		...(stdoutPath ? { stdoutPath } : {}),
 	});
-	if (!pane) return { status: "unavailable", reason: "pane host refused to open yazi" };
+	if (!pane) {
+		removeTransportFiles();
+		return { status: "unavailable", reason: "the pane host refused to open the files pane" };
+	}
 
 	let paneCwd = options.cwd;
 	let instanceId: string | null = null;
@@ -165,6 +232,7 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 		if (chooserTimer) clearInterval(chooserTimer);
 		chooserTimer = null;
 		options.onStopped?.(reason);
+		removeTransportFiles();
 	};
 
 	if (options.mode === "companion") {
@@ -181,7 +249,11 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 				options.onEvent(event);
 			},
 		});
-		void stream.done.then((reason) => stop(reason));
+		void stream.done.then((reason) => {
+			// A stream that ended on its own means the pane is gone or the file
+			// was lost; either way the session is over and says so.
+			stop(reason);
+		});
 	} else {
 		const pollChooser = (): void => {
 			if (stopped || alive()) return;

package/src/domains/mux/yazi/theme.ts

@@ -1,30 +1,130 @@
 import { tokenHex } from "../../../core/theme-token-hex.js";
 
-/** Render the deliberately small Clio overlay on Yazi's pinned preset theme. */
+/**
+ * Render the Clio overlay on Yazi's pinned preset theme.
+ *
+ * Every color comes from Clio's own token palette (`core/theme-token-hex.ts`),
+ * read when the managed profile is generated, which happens on the open that
+ * finds no current profile. The profile stamp carries this file's output hash,
+ * so a palette change regenerates the profile on the next open rather than
+ * leaving a pane in last release's colors. Only keys Yazi 26.8 documents are
+ * set; the rest of the preset stays, because a wrong key here is rejected by
+ * the validation open in `profile.ts` and would leave the operator with no
+ * files pane at all.
+ */
 export function renderYaziTheme(): string {
-	return `# Generated by Clio Coder. Changes are replaced when the managed profile regenerates.
+	const accent = tokenHex("accent");
+	const action = tokenHex("action");
+	const success = tokenHex("success");
+	const warning = tokenHex("warning");
+	const error = tokenHex("error");
+	const info = tokenHex("info");
+	const dim = tokenHex("dim");
+	const muted = tokenHex("muted");
+	const frame = tokenHex("frame");
+	const frameStrong = tokenHex("frameStrong");
+	return `# Generated by Clio Coder from its theme tokens. Changes are replaced when the managed profile regenerates.
 
 [mgr]
-cwd = { fg = "${tokenHex("accent")}" }
-find_keyword = { fg = "${tokenHex("warning")}" }
-marker_selected = { fg = "${tokenHex("success")}", bg = "${tokenHex("success")}" }
-marker_copied = { fg = "${tokenHex("accent")}", bg = "${tokenHex("accent")}" }
-marker_cut = { fg = "${tokenHex("error")}", bg = "${tokenHex("error")}" }
-border_style = { fg = "${tokenHex("frame")}" }
+cwd = { fg = "${accent}" }
+hovered = { reversed = true }
+preview_hovered = { underline = true }
+find_keyword = { fg = "${warning}", bold = true }
+find_position = { fg = "${action}", italic = true }
+marker_selected = { fg = "${success}", bg = "${success}" }
+marker_copied = { fg = "${accent}", bg = "${accent}" }
+marker_cut = { fg = "${error}", bg = "${error}" }
+marker_marked = { fg = "${info}", bg = "${info}" }
+count_copied = { fg = "${accent}", bg = "${frame}" }
+count_cut = { fg = "${error}", bg = "${frame}" }
+count_selected = { fg = "${success}", bg = "${frame}" }
+border_style = { fg = "${frame}" }
+syntect_theme = ""
 
 [mode]
-normal_main = { bg = "${tokenHex("accent")}" }
-normal_alt = { fg = "${tokenHex("accent")}" }
-select_main = { bg = "${tokenHex("action")}" }
-select_alt = { fg = "${tokenHex("action")}" }
-unset_main = { bg = "${tokenHex("error")}" }
-unset_alt = { fg = "${tokenHex("error")}" }
+normal_main = { bg = "${accent}", bold = true }
+normal_alt = { fg = "${accent}" }
+select_main = { bg = "${action}", bold = true }
+select_alt = { fg = "${action}" }
+unset_main = { bg = "${error}", bold = true }
+unset_alt = { fg = "${error}" }
 
 [tabs]
-active = { bg = "${tokenHex("accent")}" }
-inactive = { fg = "${tokenHex("accent")}" }
+active = { bg = "${accent}", bold = true }
+inactive = { fg = "${accent}" }
 
 [status]
-perm_sep = { fg = "${tokenHex("dim")}" }
+perm_type = { fg = "${accent}" }
+perm_read = { fg = "${warning}" }
+perm_write = { fg = "${error}" }
+perm_exec = { fg = "${success}" }
+perm_sep = { fg = "${dim}" }
+progress_label = { bold = true }
+progress_normal = { fg = "${accent}" }
+progress_error = { fg = "${error}" }
+
+[which]
+cols = 3
+mask = { bg = "${frame}" }
+cand = { fg = "${accent}" }
+rest = { fg = "${muted}" }
+desc = { fg = "${action}" }
+separator_style = { fg = "${dim}" }
+
+[confirm]
+border = { fg = "${frameStrong}" }
+title = { fg = "${accent}" }
+btn_yes = { reversed = true }
+btn_no = {}
+
+[pick]
+border = { fg = "${frameStrong}" }
+active = { fg = "${action}", bold = true }
+
+[input]
+border = { fg = "${frameStrong}" }
+title = { fg = "${accent}" }
+selected = { reversed = true }
+
+[cmp]
+border = { fg = "${frameStrong}" }
+active = { reversed = true }
+
+[tasks]
+border = { fg = "${frameStrong}" }
+title = { fg = "${accent}" }
+hovered = { fg = "${action}", underline = true }
+
+[help]
+on = { fg = "${accent}" }
+run = { fg = "${action}" }
+footer = { fg = "${muted}" }
+
+[notify]
+title_info = { fg = "${info}" }
+title_warn = { fg = "${warning}" }
+title_error = { fg = "${error}" }
+`;
+}
+
+/**
+ * The same palette as a herdr `[theme.custom]` block.
+ *
+ * herdr themes its chrome (sidebar, tab bar, borders, agent rows) from its own
+ * config.toml and has no per-pane styling on the wire, so Clio cannot color
+ * the panes it opens. What it can do is hand the operator the block that makes
+ * herdr's chrome match Clio, to paste into herdr's config; Clio never writes
+ * another program's configuration itself.
+ */
+export function renderHerdrThemeBlock(): string {
+	return `# Clio Coder theme tokens for herdr. Paste into ~/.config/herdr/config.toml, then run \`herdr server reload-config\`.
+[theme.custom]
+accent = "${tokenHex("accent")}"
+green = "${tokenHex("success")}"
+blue = "${tokenHex("info")}"
+red = "${tokenHex("error")}"
+yellow = "${tokenHex("warning")}"
+selection_bg = "${tokenHex("frame")}"
+active_row_bg = "${tokenHex("frame")}"
 `;
 }