@iowarp/clio-coder 0.4.1 → 0.4.3

package/src/domains/middleware/skills-reminder.ts

@@ -24,7 +24,7 @@ export const SKILLS_REMINDER_REGISTRATION_ID = "observer.skills-reminder";
 
 export { SKILL_SUGGESTION_ANCHOR };
 
-export function skillsReminderMessage(installed: number, installable = 0): string {
+export function skillsReminderMessage(installed: number, installable = 0, modelActivation = false): string {
 	// Unconditional imperative, deliberately: the skill-mastery batteries
 	// showed literal local models comply with "list and check" but never act
 	// on wording that first asks them to classify the task as skill-shaped.
@@ -37,6 +37,17 @@ export function skillsReminderMessage(installed: number, installable = 0): strin
 	// operator" as the whole job, spent a 40-second turn deliberating over the
 	// suggestion, and ended without one repository read. The suggestion is one
 	// line, the task continues in the same turn, and only the operator loads.
+	// At auto-edit and full-auto the model activates installed skills itself,
+	// so the reminder must not repeat "only the operator loads a skill": the
+	// literal models this line exists for act on it over the listing footer.
+	if (modelActivation) {
+		return (
+			`[Skills] ${counts}. Start this task by listing them with context(scope="skills") ` +
+			'and checking for a match; if one matches, load it with context(scope="skills", name="<name>") and ' +
+			"continue the task in the same turn. A marketplace skill is not installed and is offered for install " +
+			"when the operator runs it. If none match, do not mention skills and continue with the task."
+		);
+	}
 	return (
 		`[Skills] ${counts}. Start this task by listing them with context(scope="skills") ` +
 		"and checking for a match; if one matches, open your reply with the line " +
@@ -55,6 +66,12 @@ export interface SkillsReminderDeps {
 	 * zero. Either count above zero arms the reminder.
 	 */
 	countInstallableSkills?(): number;
+	/**
+	 * True when the session's autonomy level lets the model activate an
+	 * installed skill itself. Absent reads as false, the operator-gated wording
+	 * every surface taught before the level became the opt-in.
+	 */
+	modelMayActivateSkills?(): boolean;
 }
 
 const NO_EFFECTS: ReadonlyArray<MiddlewareEffect> = [];
@@ -211,7 +228,19 @@ export function createSkillsReminderRegistration(deps: SkillsReminderDeps): Midd
 				return NO_EFFECTS;
 			}
 			if (installed <= 0 && installable <= 0) return NO_EFFECTS;
-			return [{ kind: "inject_reminder", severity: "info", message: skillsReminderMessage(installed, installable) }];
+			let modelActivation = false;
+			try {
+				modelActivation = deps.modelMayActivateSkills?.() ?? false;
+			} catch {
+				// An unreadable autonomy level falls back to the operator-gated wording.
+			}
+			return [
+				{
+					kind: "inject_reminder",
+					severity: "info",
+					message: skillsReminderMessage(installed, installable, modelActivation),
+				},
+			];
 		},
 	};
 }

package/src/domains/middleware/snapshot.ts

@@ -1,13 +1,14 @@
 import { createHookBudgetTracker, resolveHookBudgetsFromEnv, resolveHookBudgetTunablesFromEnv } from "./budget.js";
 import type { MiddlewareContract } from "./contract.js";
+import { createMiddlewareRegistrationTable } from "./registrations.js";
 import { cloneMiddlewareRule, listMiddlewareRuleDefinitions, listMiddlewareRules } from "./rules.js";
 import {
 	cloneMiddlewareEffect,
 	type MiddlewareDiagnosticSink,
-	type MiddlewareHookRegistration,
 	type MiddlewareRuleDefinition,
 	registrationFromRuleDefinition,
 	runMiddlewareRegistrations,
+	writeMiddlewareDiagnosticToStderr,
 } from "./runtime.js";
 import type { MiddlewareRule, MiddlewareSnapshot } from "./types.js";
 
@@ -39,15 +40,20 @@ export function createMiddlewareContractFromSnapshot(snapshot: MiddlewareSnapsho
 		if (builtin?.predicate !== undefined) definition.predicate = builtin.predicate;
 		return definition;
 	});
-	const registrations: MiddlewareHookRegistration[] = definitions.map(registrationFromRuleDefinition);
-	const registeredIds = new Set(registrations.map((registration) => registration.id));
+	let diagnosticSink: MiddlewareDiagnosticSink | undefined;
+	// Workers never receive owned registrations; the table exists so the
+	// worker contract satisfies the same interface with the same semantics.
+	const table = createMiddlewareRegistrationTable({
+		fixed: definitions.map(registrationFromRuleDefinition),
+		diagnosticSink: () => diagnosticSink ?? writeMiddlewareDiagnosticToStderr,
+	});
 	const budgetTracker = createHookBudgetTracker({
 		budgets: resolveHookBudgetsFromEnv(),
 		...resolveHookBudgetTunablesFromEnv(),
 	});
-	let diagnosticSink: MiddlewareDiagnosticSink | undefined;
 	return {
 		runHook(input) {
+			const registrations = table.list();
 			return runMiddlewareRegistrations(input, registrations, {
 				budgetTracker,
 				...(diagnosticSink !== undefined ? { onDiagnostic: diagnosticSink } : {}),
@@ -60,12 +66,19 @@ export function createMiddlewareContractFromSnapshot(snapshot: MiddlewareSnapsho
 			return createMiddlewareSnapshot(definitions.map((definition) => definition.rule));
 		},
 		registerHook(registration) {
-			if (registeredIds.has(registration.id)) return;
-			registeredIds.add(registration.id);
-			registrations.push(registration);
+			table.registerHook(registration);
 		},
 		setDiagnosticSink(sink) {
 			diagnosticSink = sink;
 		},
+		prepareRegistrationReplacement(owner, generation, registrations) {
+			return table.prepareReplacement(owner, generation, registrations);
+		},
+		replaceRegistrations(owner, generation, registrations) {
+			return table.replaceRegistrations(owner, generation, registrations);
+		},
+		ownedGeneration(owner) {
+			return table.ownedGeneration(owner);
+		},
 	};
 }

package/src/domains/mux/contract.ts

@@ -119,6 +119,20 @@ export interface MuxContract extends DomainContract {
 	focusPane(paneId: string): Promise<boolean>;
 	/** Zoom one Clio-created pane on, off, or toggled. Zooming steals focus; same rule as focusPane. */
 	zoomPane(paneId: string, mode: "on" | "off" | "toggle"): Promise<boolean>;
+	/**
+	 * Bring keyboard focus back to Clio's own hosting pane. This is the return
+	 * half of every explicit pane interaction: a pick in the files pane, a
+	 * toggle that closed a pane the operator was looking at. False outside
+	 * guest mode, without an anchor pane, or below the pane.focus floor.
+	 */
+	focusSelf(): Promise<boolean>;
+	/**
+	 * Leave zoom on the tab that hosts Clio, so a dock split from the anchor is
+	 * visible again. A zoomed tab hides every pane but one; opening or focusing
+	 * the files pane behind a zoom would report success for a pane the operator
+	 * cannot see. False when nothing was zoomed or the tier is absent.
+	 */
+	unzoomSelf(): Promise<boolean>;
 	/** Set a dock's share of its axis. False when the slot has no dock or the tier is absent. */
 	resizeDock(slot: DockSlot, share: number): Promise<boolean>;
 	/** Live dock geometry states, for `/panes` status. */
@@ -425,6 +439,30 @@ export function createMuxRuntime(options: MuxRuntimeOptions): MuxRuntime {
 			);
 		},
 
+		async focusSelf(): Promise<boolean> {
+			if (anchorPaneId === null || !muxSupportsMethod(detection.server, "pane.focus")) return false;
+			return await attempt(
+				"focusSelf",
+				async (live) => {
+					await live.paneFocus(anchorPaneId);
+					return true;
+				},
+				false,
+			);
+		},
+
+		async unzoomSelf(): Promise<boolean> {
+			if (anchorPaneId === null || !muxSupportsMethod(detection.server, "pane.zoom")) return false;
+			return await attempt(
+				"unzoomSelf",
+				async (live) => {
+					const result = await live.paneZoom(anchorPaneId, "off");
+					return result.changed;
+				},
+				false,
+			);
+		},
+
 		async resizeDock(slot: DockSlot, share: number): Promise<boolean> {
 			if (!docks) return false;
 			return await attempt("resizeDock", () => docks.resize(slot, share), false);

package/src/domains/mux/detect.ts

@@ -126,19 +126,12 @@ export async function detectMux(options: DetectMuxOptions = {}): Promise<MuxDete
 		return { detection: none("panes are turned off"), client: null };
 	}
 	if (enabled === "embedded") {
-		// Phase 5 owns the session bootstrap. Until then the honest answer is that
-		// Clio cannot provide panes, not that it failed to find them, and the
-		// operator hears it: this degrade is marked a refusal so the boot says so
-		// out loud rather than logging a debug line nobody reads. The reason also
-		// names the rung that does work, because `embedded` costs guest mode too.
-		return {
-			detection: none(
-				"embedded mode is not implemented yet; it ships in phase 5, so this session has no panes at all. Set panes.enabled=auto for guest mode inside a herdr session.",
-				[],
-				true,
-			),
-			client: null,
-		};
+		// Embedded mode (Clio owning the pane host) is not implemented yet. An
+		// operator who picked it wanted panes, so the rung degrades to guest
+		// detection instead of refusing everything; the notice below says which
+		// mode actually runs. When the guest ladder also fails, that failure is
+		// reported on its own terms.
+		log("info", "interface.panes.enabled=embedded is not implemented yet; detecting a guest pane host instead");
 	}
 	if (env.HERDR_ENV !== "1") {
 		return { detection: none("HERDR_ENV is not 1, so Clio is not running inside a pane host"), client: null };

package/src/domains/mux/index.ts

@@ -113,4 +113,4 @@ export {
 	type YaziSessionOptions,
 	type YaziSessionSnapshot,
 } from "./yazi/session.js";
-export { renderYaziTheme } from "./yazi/theme.js";
+export { renderHerdrThemeBlock, renderYaziTheme } from "./yazi/theme.js";

package/src/domains/mux/operations.ts

@@ -14,13 +14,19 @@
  * shell-escape territory (spec 4.8, and the risk register's "tool misuse" row).
  */
 
-/** Utility pane presets, in the order `/panes open` lists them. */
+/**
+ * Utility pane presets, in the order `/panes open` lists them.
+ *
+ * The files preset is a Clio Coder surface named for what it does; yazi is
+ * the engine behind it and shows up only in the install command, because
+ * that is the registry id an operator types.
+ */
 export const PANES_PRESETS = [
 	{
-		id: "yazi",
+		id: "files",
 		/** Probed through the toolchain resolution ladder before the pane is split. */
 		binary: "yazi",
-		summary: "file manager rooted at the workspace",
+		summary: "file view rooted at the workspace; picks land in the composer",
 		/** Printed verbatim when the probe finds nothing. */
 		installHint: "clio-coder tools install yazi",
 	},
@@ -42,10 +48,23 @@ export type PanesPresetId = (typeof PANES_PRESETS)[number]["id"];
 
 export const PANES_PRESET_IDS: ReadonlyArray<PanesPresetId> = PANES_PRESETS.map((preset) => preset.id);
 
-export function isPanesPresetId(value: string): value is PanesPresetId {
+function isPanesPresetId(value: string): value is PanesPresetId {
 	return PANES_PRESETS.some((preset) => preset.id === value);
 }
 
+/**
+ * Retired preset spellings that still parse. The files preset shipped as
+ * `yazi` in 0.4.0 and 0.4.1, so an operator's muscle memory and any script
+ * that says `/panes open yazi` keeps working and lands on the same pane.
+ */
+export const PANES_PRESET_ALIASES: Readonly<Record<string, PanesPresetId>> = { yazi: "files" };
+
+/** The canonical preset id for an operator-typed name, or null when it is not a preset. */
+export function resolvePanesPresetId(value: string): PanesPresetId | null {
+	if (isPanesPresetId(value)) return value;
+	return PANES_PRESET_ALIASES[value] ?? null;
+}
+
 /** One pane Clio owns, flattened for display. */
 export interface PanesInventoryEntry {
 	paneId: string;
@@ -135,7 +154,8 @@ export interface PanesWatchController {
 }
 
 export type PanesOpenResult =
-	| { status: "opened"; label: string; paneId: string | null }
+	/** `existing` is true when the preset already had a live pane and it was focused instead of split again. */
+	| { status: "opened"; label: string; paneId: string | null; existing?: boolean }
 	| { status: "missing-binary"; preset: string; binary: string; installHint: string; detail: string }
 	| { status: "refused"; reason: string }
 	| { status: "unavailable"; reason: string };
@@ -166,9 +186,21 @@ export interface PanesYaziController {
 		| { status: "profile-error"; reason: string }
 		| { status: "unavailable"; reason: string }
 	>;
+	/** Close the files pane if it is open; false when nothing was open. */
+	close(): Promise<boolean>;
+	/** True while a files pane the host still reports is open. */
+	isOpen(): boolean;
 	status(): Readonly<PanesYaziStatus>;
 }
 
+/** What `/files` and the files keybinding settle to. */
+export type PanesFilesResult =
+	| { status: "opened"; paneId: string | null; existing: boolean }
+	| { status: "closed" }
+	| { status: "missing-binary"; binary: string; installHint: string; detail: string }
+	| { status: "refused"; reason: string }
+	| { status: "unavailable"; reason: string };
+
 /**
  * The operations both callers drive. The tool sees a narrower door: its schema
  * has no argv field at all, and `open` refuses one even if a caller fabricates
@@ -185,6 +217,13 @@ export interface PanesOperations {
 	 */
 	zoom(target: string): Promise<PanesZoomResult>;
 	close(target: string): Promise<PanesCloseResult>;
+	/**
+	 * The files pane as one operator verb. `toggle` opens it when closed and
+	 * closes it when open, which is what a keybinding needs; `open` and
+	 * `close` are the explicit halves; `pick` borrows the pane for one
+	 * selection and closes it afterwards.
+	 */
+	files(action: "toggle" | "open" | "close" | "pick"): Promise<PanesFilesResult>;
 	/** Bind the composer-facing Yazi bridge without rebuilding this shared object. */
 	attachYazi(controller: PanesYaziController): () => void;
 	/** Bind the workers-view watch controller; `show` routes runs through it. */

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/session.ts

@@ -1,6 +1,6 @@
 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";
@@ -107,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)();
@@ -125,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)({
@@ -163,10 +195,19 @@ 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.
@@ -174,7 +215,10 @@ export async function createYaziSession(options: YaziSessionOptions): Promise<Ya
 		...(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;
@@ -188,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") {
@@ -204,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")}"
 `;
 }