@v1nvn/statusline 0.28.0 → 0.30.0

package/dist/index.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename, dirname, join } from "node:path";
-import { Command } from "commander";
+import { delimiter, dirname, join, sep } from "node:path";
 import { execFileSync, spawnSync } from "node:child_process";
+import { Command } from "commander";
 import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
 //#region ../core/dist/index.js
 function parseQuietly(program, args, recover) {
 	try {
@@ -23,6 +24,1090 @@ function printUsageAndExit(program) {
 }
 Number.MAX_SAFE_INTEGER;
 //#endregion
+//#region src/render/git.ts
+var BRANCH_HEAD = "# branch.head ";
+var BRANCH_AB = /^# branch\.ab \+(\d+) -(\d+)$/;
+function gitEnv(env) {
+	return {
+		HOME: env.home,
+		LC_ALL: "C",
+		PATH: process.env.PATH ?? ""
+	};
+}
+function gitText(dir, args, env) {
+	const run = spawnSync("git", [
+		"-C",
+		dir,
+		...args
+	], {
+		encoding: "utf8",
+		env: gitEnv(env)
+	});
+	return run.status === 0 ? run.stdout : null;
+}
+function lineCount(text) {
+	return text === null || text === "" ? 0 : (text.match(/\n/g) ?? []).length;
+}
+function count(text) {
+	const parsed = text === null ? NaN : Number(text.trim());
+	return Number.isFinite(parsed) ? Math.trunc(parsed) : 0;
+}
+function readGit(dir, env) {
+	const facts = {
+		ahead: 0,
+		behind: 0,
+		branch: "",
+		modified: 0,
+		staged: 0,
+		stashes: 0,
+		untracked: 0
+	};
+	if (dir === "") return facts;
+	if (spawnSync("git", [
+		"-C",
+		dir,
+		"rev-parse",
+		"--git-dir"
+	], {
+		encoding: "utf8",
+		env: gitEnv(env)
+	}).status !== 0) return facts;
+	const status = gitText(dir, [
+		"status",
+		"--porcelain=v2",
+		"--branch"
+	], env);
+	for (const line of (status ?? "").split("\n")) {
+		if (line.startsWith(BRANCH_HEAD)) {
+			facts.branch = line.slice(14);
+			continue;
+		}
+		const ab = BRANCH_AB.exec(line);
+		if (ab !== null) {
+			facts.ahead = count(ab[1]);
+			facts.behind = count(ab[2]);
+		} else if ((line.startsWith("1 ") || line.startsWith("2 ")) && line.length >= 4) {
+			if (line[2] !== ".") facts.staged += 1;
+			if (line[3] !== ".") facts.modified += 1;
+		}
+	}
+	if (facts.branch === "(detached)") facts.branch = "";
+	facts.untracked = lineCount(gitText(dir, [
+		"ls-files",
+		"--others",
+		"--exclude-standard"
+	], env));
+	facts.stashes = lineCount(gitText(dir, ["stash", "list"], env));
+	return facts;
+}
+//#endregion
+//#region src/render/items.ts
+var ITEMS = [
+	{
+		alternatives: [
+			"plain",
+			"block",
+			"pill",
+			"zen"
+		],
+		default: "plain",
+		item: "model"
+	},
+	{
+		alternatives: [
+			"plain",
+			"dim",
+			"hidden"
+		],
+		default: "plain",
+		item: "effort"
+	},
+	{
+		alternatives: ["none", "pills"],
+		default: "none",
+		item: "state"
+	},
+	{
+		alternatives: [
+			"init",
+			"full",
+			"tail",
+			"base",
+			"icon"
+		],
+		default: "init",
+		item: "cwd"
+	},
+	{
+		alternatives: [
+			"initials",
+			"full",
+			"last",
+			"icon",
+			"none"
+		],
+		default: "initials",
+		item: "branch"
+	},
+	{
+		alternatives: [
+			"counts",
+			"icons",
+			"none"
+		],
+		default: "counts",
+		item: "status"
+	},
+	{
+		alternatives: ["none", "arrows"],
+		default: "none",
+		item: "ahead"
+	},
+	{
+		alternatives: ["none", "badge"],
+		default: "none",
+		item: "pr"
+	},
+	{
+		alternatives: [
+			"flat",
+			"gauge",
+			"percent",
+			"none",
+			"flat6",
+			"flat4"
+		],
+		default: "flat",
+		item: "bar"
+	},
+	{
+		alternatives: [
+			"full",
+			"compact",
+			"free",
+			"none"
+		],
+		default: "full",
+		item: "tokens"
+	},
+	{
+		alternatives: [
+			"hit",
+			"coldin",
+			"fuse",
+			"none"
+		],
+		default: "hit",
+		item: "cache"
+	},
+	{
+		alternatives: [
+			"plain",
+			"burn",
+			"none"
+		],
+		default: "plain",
+		item: "cost"
+	},
+	{
+		alternatives: [
+			"clock",
+			"hours",
+			"none"
+		],
+		default: "clock",
+		item: "duration"
+	},
+	{
+		alternatives: ["none", "diffstat"],
+		default: "none",
+		item: "lines"
+	},
+	{
+		alternatives: ["none", "strip"],
+		default: "none",
+		item: "rate"
+	},
+	{
+		alternatives: [
+			"plain",
+			"dots",
+			"dim",
+			"bare"
+		],
+		default: "plain",
+		item: "style"
+	}
+];
+var DEFAULT_LAYOUT = "{model effort state} {cwd branch status ahead pr} {bar tokens cache} {cost} {duration} {lines} {rate}";
+var BY_ITEM = new Map(ITEMS.map((spec) => [spec.item, spec]));
+function specFor(item) {
+	return BY_ITEM.get(item);
+}
+var ITEM_IDS = ITEMS.map((spec) => spec.item);
+var DEFAULT_PICKS = Object.fromEntries(ITEMS.map(({ default: alt, item }) => [item, alt]));
+var RUNG_ORDERS = {
+	bar: [
+		"flat",
+		"flat6",
+		"flat4",
+		"percent",
+		"none"
+	],
+	branch: [
+		"icon",
+		"full",
+		"initials",
+		"last",
+		"none"
+	],
+	cache: [
+		"hit",
+		"coldin",
+		"none"
+	],
+	cwd: [
+		"icon",
+		"full",
+		"init",
+		"tail",
+		"base"
+	],
+	duration: [
+		"clock",
+		"hours",
+		"none"
+	],
+	effort: [
+		"plain",
+		"dim",
+		"hidden"
+	],
+	status: [
+		"counts",
+		"icons",
+		"none"
+	],
+	tokens: [
+		"full",
+		"free",
+		"compact",
+		"none"
+	]
+};
+var FULL_STEPS = [
+	["duration", "none"],
+	["cache", "none"],
+	["tokens", "compact"],
+	["bar", "flat6"],
+	["status", "none"],
+	["branch", "initials"],
+	["cwd", "init"],
+	["branch", "last"],
+	["bar", "flat4"],
+	["model", "strip"],
+	["bar", "percent"],
+	["branch", "none"],
+	["cwd", "tail"],
+	["effort", "hidden"],
+	["cwd", "base"],
+	["tokens", "none"]
+];
+var L1_STEPS = [
+	["status", "none"],
+	["branch", "initials"],
+	["cwd", "init"],
+	["branch", "last"],
+	["model", "strip"],
+	["branch", "none"],
+	["cwd", "tail"],
+	["effort", "hidden"],
+	["cwd", "base"]
+];
+var L2_STEPS = [
+	["duration", "none"],
+	["cache", "none"],
+	["tokens", "compact"],
+	["bar", "flat6"],
+	["bar", "flat4"],
+	["tokens", "none"],
+	["bar", "percent"]
+];
+//#endregion
+//#region src/render/layout.ts
+function parseClusters(layout) {
+	const clusters = [];
+	let words = [];
+	let word = "";
+	let open = false;
+	function pushWord() {
+		if (word !== "") {
+			words.push(word);
+			word = "";
+		}
+	}
+	for (const c of layout) if (c === "{") {
+		if (open) throw new Error(`layout '${layout}': '{' inside a cluster`);
+		open = true;
+		words = [];
+	} else if (c === "}") {
+		if (!open) throw new Error(`layout '${layout}': '}' outside a cluster`);
+		pushWord();
+		open = false;
+		if (words.length > 0) clusters.push(words);
+	} else if (c === " ") {
+		if (open) pushWord();
+		else if (word !== "") throw new Error(`layout '${layout}': '${word}' sits outside a cluster`);
+	} else if (/[a-z0-9]/.test(c)) word += c;
+	else throw new Error(`layout '${layout}': '${c}' is not layout grammar (braces, item ids, spaces)`);
+	if (open) throw new Error(`layout '${layout}': unterminated cluster`);
+	if (word !== "") throw new Error(`layout '${layout}': '${word}' sits outside a cluster`);
+	if (clusters.length === 0) throw new Error(`layout '${layout}': no clusters`);
+	return clusters;
+}
+function layoutItemsOf(layout) {
+	const items = [];
+	for (const cluster of parseClusters(layout)) for (const item of cluster) if (!items.includes(item)) items.push(item);
+	return items;
+}
+function layoutItems(layout, valid) {
+	const known = new Set(valid);
+	const items = layoutItemsOf(layout);
+	for (const item of items) if (!known.has(item)) throw new Error(`unknown layout item '${item}' — valid items: ${valid.join(" ")}`);
+	return items;
+}
+//#endregion
+//#region src/render/jq.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function orElse(value, fallback) {
+	return value === void 0 || value === null || value === false ? fallback : value;
+}
+function jqText(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+function tsvEscape(text) {
+	return text.replace(/\\/g, "\\\\").replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+//#endregion
+//#region src/render/payload.ts
+function member(source, key) {
+	return isRecord(source) ? source[key] : void 0;
+}
+function field$1(source, path) {
+	let current = source;
+	for (const key of path.split(".")) current = member(current, key);
+	return current;
+}
+function textOf(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return "";
+}
+function scalar(source, path, fallback) {
+	return textOf(orElse(field$1(source, path), fallback));
+}
+function numberField(source, path) {
+	return Number(scalar(source, path, "0"));
+}
+function pctField(source) {
+	const intPart = scalar(source, "context_window.used_percentage", "0").split(".")[0];
+	return intPart === "" ? 0 : Number(intPart);
+}
+var RATE_LIMITS = [
+	["5h", "five_hour"],
+	["7d", "seven_day"],
+	["spend", "spend_limit"]
+];
+function rateRows(source) {
+	const limits = field$1(source, "rate_limits");
+	const rows = [];
+	for (const [label, key] of RATE_LIMITS) {
+		const limit = member(limits, key);
+		if (!isRecord(limit) || Object.keys(limit).length === 0) continue;
+		rows.push({
+			label,
+			pctText: scalar(limit, "used_percentage", "0"),
+			resets: Number(scalar(limit, "resets_at", "0"))
+		});
+	}
+	return rows;
+}
+function parseRow(payload) {
+	const root = JSON.parse(payload);
+	const hitText = scalar(root, "prompt_cache.hit_ratio", "");
+	return {
+		agent: scalar(root, "agent.name", ""),
+		cost: numberField(root, "cost.total_cost_usd"),
+		ctxSize: numberField(root, "context_window.context_window_size"),
+		dir: scalar(root, "workspace.current_dir", ""),
+		durationMs: numberField(root, "cost.total_duration_ms"),
+		effort: scalar(root, "effort.level", ""),
+		expires: numberField(root, "prompt_cache.expires_at"),
+		hit: hitText === "" ? null : Number(hitText),
+		la: numberField(root, "cost.total_lines_added"),
+		lr: numberField(root, "cost.total_lines_removed"),
+		model: scalar(root, "model.display_name", ""),
+		pct: pctField(root),
+		prn: scalar(root, "pr.number", ""),
+		prs: scalar(root, "pr.review_state", ""),
+		rateRows: rateRows(root),
+		think: scalar(root, "thinking.enabled", "false") === "true",
+		tokens: numberField(root, "context_window.total_input_tokens"),
+		ttl: scalar(root, "prompt_cache.ttl", ""),
+		vim: scalar(root, "vim.mode", ""),
+		warm: scalar(root, "prompt_cache.warm", "false") === "true",
+		wt: scalar(root, "worktree.name", ""),
+		styleName: scalar(root, "output_style.name", "")
+	};
+}
+//#endregion
+//#region src/render/awk.ts
+var TEN = 10n;
+function exactParts(ax) {
+	const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	view.setFloat64(0, ax);
+	const hi = view.getUint32(0);
+	const lo = view.getUint32(4);
+	const biased = hi >>> 20 & 2047;
+	const frac = BigInt(hi & 1048575) << 32n | BigInt(lo);
+	if (biased === 0) return {
+		exp: -1074,
+		mant: frac
+	};
+	return {
+		exp: biased - 1075,
+		mant: frac | 1n << 52n
+	};
+}
+function roundScaled(ax, d) {
+	const { exp, mant } = exactParts(ax);
+	const pow10 = TEN ** BigInt(d);
+	const num = exp >= 0 ? (mant << BigInt(exp)) * pow10 : mant * pow10;
+	const den = exp >= 0 ? 1n : 1n << BigInt(-exp);
+	const q = num / den;
+	const twice = num % den * 2n;
+	if (twice > den || twice === den && q % 2n === 1n) return q + 1n;
+	return q;
+}
+function fmtFixed(x, d) {
+	const q = roundScaled(Math.abs(x), d);
+	const sign = x < 0 && q !== 0n ? "-" : "";
+	const digits = q.toString();
+	if (d === 0) return `${sign}${digits}`;
+	return `${sign}${digits.length <= d ? "0" : digits.slice(0, digits.length - d)}.${digits.padStart(d + 1, "0").slice(-d)}`;
+}
+function pad2(n) {
+	return String(n).padStart(2, "0");
+}
+function fmtK(n, d) {
+	return `${fmtFixed(n / 1e3, d)}k`;
+}
+function fmtM(n) {
+	return `${fmtFixed(n / 1e6, 0)}M`;
+}
+//#endregion
+//#region src/render/segments.ts
+var BLUE = "\x1B[34m";
+var CYAN$1 = "\x1B[36m";
+var DIM = "\x1B[2m";
+var GREEN$1 = "\x1B[32m";
+var PURPLE = "\x1B[35m";
+var RED$1 = "\x1B[31m";
+var RESET$1 = "\x1B[0m";
+var YELLOW$1 = "\x1B[33m";
+var BOLD = "\x1B[1m";
+var GRAY = "\x1B[38;2;68;71;90m";
+var MARK = "\x1B[1;97m";
+var SHORT_AT = 15;
+var PART = [
+	"▏",
+	"▎",
+	"▍",
+	"▌",
+	"▋",
+	"▊",
+	"▉",
+	"█"
+];
+var HEAT = [
+	"\x1B[38;2;48;242;36m",
+	"\x1B[38;2;63;242;36m",
+	"\x1B[38;2;79;242;36m",
+	"\x1B[38;2;95;242;36m",
+	"\x1B[38;2;111;242;36m",
+	"\x1B[38;2;126;242;36m",
+	"\x1B[38;2;142;242;36m",
+	"\x1B[38;2;158;242;36m",
+	"\x1B[38;2;173;242;36m",
+	"\x1B[38;2;189;242;36m",
+	"\x1B[38;2;205;242;36m",
+	"\x1B[38;2;220;242;36m",
+	"\x1B[38;2;236;242;36m",
+	"\x1B[38;2;242;232;36m",
+	"\x1B[38;2;242;216;36m",
+	"\x1B[38;2;242;200;36m",
+	"\x1B[38;2;242;185;36m",
+	"\x1B[38;2;242;169;36m",
+	"\x1B[38;2;242;153;36m",
+	"\x1B[38;2;242;138;36m",
+	"\x1B[38;2;242;122;36m",
+	"\x1B[38;2;242;106;36m",
+	"\x1B[38;2;242;91;36m",
+	"\x1B[38;2;242;75;36m",
+	"\x1B[38;2;242;59;36m",
+	"\x1B[38;2;242;44;36m"
+];
+function trunc(n) {
+	return Math.trunc(n);
+}
+function modelPlain({ model }) {
+	return model === "" ? "" : `${CYAN$1}${model}${RESET$1}`;
+}
+function modelBlock({ model }) {
+	return model === "" ? "" : `\x1b[48;5;61m\x1b[38;5;231m ${model} \x1b[0m`;
+}
+function modelPill({ model }) {
+	return model === "" ? "" : `\x1b[48;5;61m\x1b[38;5;231m\u{e0b6} ${model} \u{e0b4}\x1b[0m`;
+}
+function modelZen({ model }) {
+	return model === "" ? "" : `${DIM}${model.replace(/[A-Z]/g, (c) => c.toLowerCase())}${RESET$1}`;
+}
+function effortPlain({ row }) {
+	return row.effort === "" ? "" : `${CYAN$1}${row.effort}${RESET$1}`;
+}
+function effortDim({ row }) {
+	return row.effort === "" ? "" : `${DIM}${row.effort}${RESET$1}`;
+}
+function statePill(label, bg, fg) {
+	return `\x1b[48;5;${bg}m\x1b[38;5;${fg}m\u{e0b6} ${label} \u{e0b4}\x1b[0m`;
+}
+function statePills({ row }) {
+	let out = "";
+	if (row.vim !== "") out = row.vim === "INSERT" ? statePill(row.vim, 97, 16) : statePill(row.vim, 240, 231);
+	if (row.think) out += ` ${statePill("THINK", 66, 16)}`;
+	if (row.agent !== "") out += ` ${statePill(row.agent, 60, 231)}`;
+	if (row.wt !== "") out += ` ${statePill(`wt:${row.wt}`, 131, 231)}`;
+	if (row.styleName !== "" && row.styleName !== "default") out += ` ${statePill(row.styleName, 95, 16)}`;
+	return out;
+}
+function splitPath(raw, home) {
+	let p = raw;
+	if (home !== "" && p.startsWith(home)) p = `~${p.slice(home.length)}`;
+	return {
+		lead: p.startsWith("/") ? "/" : "",
+		parts: p.split("/").filter((part) => part !== ""),
+		text: p
+	};
+}
+function pathInit(raw, home) {
+	const { lead, parts, text } = splitPath(raw, home);
+	const n = parts.length;
+	if (n <= 2) return text;
+	let out = `${lead}${parts[0]}`;
+	for (let i = 1; i < n - 1; i++) {
+		const ini = parts[i].startsWith(".") ? parts[i].slice(0, 2) : parts[i].slice(0, 1);
+		out += `/${ini}`;
+	}
+	return `${out}/${parts[n - 1]}`;
+}
+function pathTail(raw, home, lim) {
+	const { lead, parts, text } = splitPath(raw, home);
+	const cnt = parts.length;
+	if (cnt <= lim || cnt <= 1) return text;
+	let out = `${lead}${parts[0]}/…`;
+	for (let i = cnt - lim; i < cnt; i++) out += `/${parts[i]}`;
+	return out;
+}
+function cwdInit({ home, row }) {
+	const { text } = splitPath(row.dir, home);
+	return Buffer.byteLength(text, "utf8") > SHORT_AT ? pathInit(row.dir, home) : text;
+}
+function cwdFull({ home, row }) {
+	return splitPath(row.dir, home).text;
+}
+function cwdTail({ home, row }) {
+	return pathTail(row.dir, home, 1);
+}
+function baseName(dir) {
+	return dir.slice(dir.lastIndexOf("/") + 1);
+}
+function cwdBase({ row }) {
+	return baseName(row.dir);
+}
+function cwdIcon({ row }) {
+	return `\u{f07b} ${baseName(row.dir)}`;
+}
+function branchInitials({ git }) {
+	const branch = git.branch;
+	if (branch === "") return "";
+	if (Buffer.byteLength(branch, "utf8") <= SHORT_AT) return branch;
+	const parts = branch.split("/").filter((part) => part !== "");
+	if (parts.length <= 1) return branch;
+	let out = "";
+	for (let i = 0; i < parts.length - 1; i++) out += `${parts[i].slice(0, 1)}/`;
+	return `${out}${parts[parts.length - 1]}`;
+}
+function branchFull({ git }) {
+	return git.branch;
+}
+function branchLast({ git }) {
+	return git.branch.slice(git.branch.lastIndexOf("/") + 1);
+}
+function branchIcon({ git }) {
+	return git.branch === "" ? "" : `\u{e0a0} ${git.branch}`;
+}
+function statusCounts({ git }) {
+	if (git.branch === "") return "";
+	let c = "";
+	if (git.staged > 0) c = `${GREEN$1}+${git.staged}${RESET$1}`;
+	if (git.modified > 0) c = `${c} ${YELLOW$1}~${git.modified}${RESET$1}`;
+	return c;
+}
+function statusIcons({ git }) {
+	if (git.branch === "") return "";
+	let out = "";
+	let sep = "";
+	if (git.staged > 0) {
+		out += `${GREEN$1}●${git.staged}${RESET$1}`;
+		sep = " ";
+	}
+	if (git.modified > 0) {
+		out += `${sep}${YELLOW$1}✎${git.modified}${RESET$1}`;
+		sep = " ";
+	}
+	if (git.untracked > 0) {
+		out += `${sep}${CYAN$1}+${git.untracked}${RESET$1}`;
+		sep = " ";
+	}
+	if (git.stashes > 0) out += `${sep}${PURPLE}⚑${git.stashes}${RESET$1}`;
+	return out;
+}
+function aheadArrows({ git }) {
+	let out = "";
+	if (git.ahead > 0) out = `${GREEN$1}↑${git.ahead}${RESET$1}`;
+	if (git.behind > 0) out += ` ${RED$1}↓${git.behind}${RESET$1}`;
+	return out;
+}
+function prBadge({ row }) {
+	if (row.prn === "") return "";
+	let col;
+	let mark;
+	switch (row.prs) {
+		case "approved":
+			col = GREEN$1;
+			mark = "✓";
+			break;
+		case "changes_requested":
+			col = RED$1;
+			mark = "✗";
+			break;
+		case "pending":
+			col = YELLOW$1;
+			mark = "⏳";
+			break;
+		default:
+			col = "\x1B[90m";
+			mark = "◌";
+	}
+	return `${BLUE}#${row.prn}${RESET$1} ${col}${mark} ${row.prs}${RESET$1}`;
+}
+function barFlatAt(input, w) {
+	const pct = input.row.pct;
+	let f = trunc(pct * w / 100);
+	if (f > w) f = w;
+	return `${pct >= 90 ? RED$1 : pct >= 70 ? YELLOW$1 : GREEN$1}${"█".repeat(f)}${"░".repeat(w - f)}${RESET$1}`;
+}
+function barFlat(input) {
+	return barFlatAt(input, 10);
+}
+function barGauge({ row }) {
+	const pct = row.pct;
+	const p = Math.max(0, Math.min(100, pct));
+	const full = trunc(p * 26 / 100);
+	const idx = trunc(p * 26 % 100 * 8 / 100);
+	const lead = p >= 50 ? `\x1b[38;2;242;${trunc(4845 * (15e3 + 1683 * (100 - p)) / 2e6)};36m` : `\x1b[38;2;${trunc(4845 * (185e3 - 1683 * (100 - p)) / 2e6)};242;36m`;
+	const moon = [
+		"○",
+		"◔",
+		"◑",
+		"◕",
+		"●"
+	][Math.min(trunc(p / 20), 4)];
+	let bar = "";
+	for (let i = 0; i < 26; i++) {
+		let col;
+		let cell;
+		if (i === 20) {
+			col = MARK;
+			cell = i <= full ? "┃" : "│";
+		} else if (i <= full) {
+			col = HEAT[i];
+			cell = i === full ? PART[idx] : "█";
+		} else {
+			col = GRAY;
+			cell = "░";
+		}
+		bar += `${col}${cell}`;
+	}
+	return `${moon} ${lead}${bar}${RESET$1} ${MARK}${pct}%${RESET$1}`;
+}
+function tokensFull({ row }) {
+	const t = row.tokens >= 1e3 ? fmtK(row.tokens, 1) : String(row.tokens);
+	let c = String(row.ctxSize);
+	if (row.ctxSize >= 1e6) c = fmtM(row.ctxSize);
+	else if (row.ctxSize >= 1e3) c = fmtK(row.ctxSize, 0);
+	return `${t}/${c}`;
+}
+function tokensCompact({ row }) {
+	return row.tokens >= 1e3 ? fmtK(row.tokens, 0) : String(row.tokens);
+}
+function tokensFree({ row }) {
+	const free = row.ctxSize - row.tokens;
+	return `${DIM}${free >= 1e3 ? fmtK(free, 0) : String(free)} free${RESET$1}`;
+}
+function cacheHitPct(row) {
+	return row.hit === null ? null : trunc(row.hit * 100);
+}
+function cacheHCol(hp) {
+	return hp >= 90 ? GREEN$1 : hp >= 50 ? YELLOW$1 : RED$1;
+}
+function cacheHit({ row }) {
+	const hp = cacheHitPct(row);
+	return hp === null ? "" : `${cacheHCol(hp)}⚡${hp}%${RESET$1}`;
+}
+function cacheColdin({ now, row }) {
+	const hp = cacheHitPct(row);
+	if (hp === null) return "";
+	if (row.warm && row.expires > now) {
+		const mins = trunc((row.expires - now) / 60);
+		return `${cacheHCol(hp)}⚡${hp}%${RESET$1} ${DIM}· cold in ${mins}m${RESET$1}`;
+	}
+	return `❄ ${DIM}cold · ${hp}%${RESET$1}`;
+}
+function cacheFuse({ now, row }) {
+	if (row.ttl === "" || row.expires === 0) return "";
+	const span = row.ttl === "1h" ? 3600 : 300;
+	let left = row.expires - now;
+	if (left < 0) left = 0;
+	if (left <= 0) return `${RED$1}❄ cold${RESET$1}`;
+	const full = trunc(left * 10 / span);
+	const rem = left * 10 % span;
+	let bar = left * 4 > span ? GREEN$1 : left * 25 > span * 2 ? YELLOW$1 : RED$1;
+	for (let i = 0; i < 10; i++) if (i < full) bar += "▰";
+	else if (i === full && rem * 20 > span) bar += PART[trunc(rem * 8 / span)];
+	else bar += `${DIM}▱`;
+	return `${bar}${RESET$1} ${DIM}${pad2(trunc(left / 60))}:${pad2(left % 60)}${RESET$1}`;
+}
+function costPlain({ row }) {
+	return row.cost >= .005 ? `${YELLOW$1}$${fmtFixed(row.cost, 2)}${RESET$1}` : "";
+}
+function costBurn(input) {
+	const hr = input.row.durationMs / 36e5;
+	const burn = hr > .02 ? fmtFixed(input.row.cost / hr, 2) : "0";
+	let out = costPlain(input);
+	if (burn !== "0.00") out += ` ${DIM}· $${burn}/hr${RESET$1}`;
+	return out;
+}
+function durationClock({ row }) {
+	return `${trunc(row.durationMs / 6e4)}m${pad2(trunc(row.durationMs % 6e4 / 1e3))}s`;
+}
+function durationHours({ row }) {
+	const m = trunc(row.durationMs / 6e4);
+	return `${trunc(m / 60)}h${pad2(m % 60)}m`;
+}
+function linesDiffstat({ row }) {
+	if (row.la <= 0 && row.lr <= 0) return "";
+	return `${GREEN$1}+${row.la}${RESET$1}${DIM}/${RESET$1}${RED$1}−${row.lr}${RESET$1}`;
+}
+function rateStrip({ now, row }) {
+	const segs = [];
+	for (const limit of row.rateRows) {
+		const [intpText, fracp = ""] = limit.pctText.split(".");
+		let f = 0;
+		let scale = 1;
+		for (const digit of fracp) {
+			f = f * 10 + Number(digit);
+			scale *= 10;
+		}
+		const intp = Number(intpText);
+		const value = intp * scale + f;
+		const col = value < 70 * scale ? GREEN$1 : value < 90 * scale ? YELLOW$1 : RED$1;
+		const full = trunc(value * 14 / (100 * scale));
+		const idx = trunc(value * 14 % (100 * scale) * 8 / (100 * scale));
+		let bar = col;
+		for (let i = 0; i < 14; i++) if (i < full) bar += "█";
+		else if (i === full) bar += PART[idx];
+		else bar += `${DIM}░`;
+		const lbl = fracp === "" || f * 2 < scale ? intp : f * 2 > scale ? intp + 1 : intp + intp % 2;
+		const s = limit.resets - now;
+		let dur;
+		if (s >= 3600) dur = `${trunc(s / 3600)}h${pad2(trunc(s % 3600 / 60))}m`;
+		else {
+			const sec = (s % 60 + 60) % 60;
+			dur = `${trunc((s - sec) / 60)}m${pad2(sec)}s`;
+		}
+		segs.push(`${DIM}${limit.label}${RESET$1} ${bar}${RESET$1} ${BOLD}${lbl}%${RESET$1} ${DIM}· resets ${dur}${RESET$1}`);
+	}
+	return segs.join(`  ${DIM}│${RESET$1}  `);
+}
+function emptySegment() {
+	return "";
+}
+function barFlat6(input) {
+	return barFlatAt(input, 6);
+}
+function barFlat4(input) {
+	return barFlatAt(input, 4);
+}
+function barPercent({ row }) {
+	return `${row.pct}%`;
+}
+var SEGMENTS = {
+	ahead: {
+		arrows: aheadArrows,
+		none: emptySegment
+	},
+	bar: {
+		flat4: barFlat4,
+		flat6: barFlat6,
+		flat: barFlat,
+		gauge: barGauge,
+		none: emptySegment,
+		percent: barPercent
+	},
+	branch: {
+		full: branchFull,
+		icon: branchIcon,
+		initials: branchInitials,
+		last: branchLast,
+		none: emptySegment
+	},
+	cache: {
+		coldin: cacheColdin,
+		fuse: cacheFuse,
+		hit: cacheHit,
+		none: emptySegment
+	},
+	cost: {
+		burn: costBurn,
+		none: emptySegment,
+		plain: costPlain
+	},
+	cwd: {
+		base: cwdBase,
+		full: cwdFull,
+		icon: cwdIcon,
+		init: cwdInit,
+		tail: cwdTail
+	},
+	duration: {
+		clock: durationClock,
+		hours: durationHours,
+		none: emptySegment
+	},
+	effort: {
+		dim: effortDim,
+		hidden: emptySegment,
+		plain: effortPlain
+	},
+	lines: {
+		diffstat: linesDiffstat,
+		none: emptySegment
+	},
+	model: {
+		block: modelBlock,
+		pill: modelPill,
+		plain: modelPlain,
+		zen: modelZen
+	},
+	pr: {
+		badge: prBadge,
+		none: emptySegment
+	},
+	rate: {
+		none: emptySegment,
+		strip: rateStrip
+	},
+	state: {
+		none: emptySegment,
+		pills: statePills
+	},
+	status: {
+		counts: statusCounts,
+		icons: statusIcons,
+		none: emptySegment
+	},
+	tokens: {
+		compact: tokensCompact,
+		full: tokensFull,
+		free: tokensFree,
+		none: emptySegment
+	}
+};
+function renderSegment(item, alt, input) {
+	const segment = SEGMENTS[item]?.[alt];
+	return segment === void 0 ? "" : segment(input);
+}
+function styleSeparators(alt) {
+	switch (alt) {
+		case "bare": return {
+			join: "  ",
+			sep: "   "
+		};
+		case "dim": return {
+			join: " ",
+			sep: `${DIM} │ ${RESET$1}`
+		};
+		case "dots": return {
+			join: " · ",
+			sep: " · "
+		};
+		default: return {
+			join: " ",
+			sep: " │ "
+		};
+	}
+}
+//#endregion
+//#region src/render/engine.ts
+var RUNG_ITEMS = Object.keys(RUNG_ORDERS);
+function stripSgr(text) {
+	return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function vlen$1(text) {
+	const plain = stripSgr(text);
+	let n = Array.from(plain).length;
+	for (const ch of plain) if (ch === "⚡") n += 1;
+	return n;
+}
+function warn(message) {
+	process.stderr.write(`${message}\n`);
+}
+function stripModelSuffix(name) {
+	const at = name.lastIndexOf("[");
+	const cut = at === -1 ? name : name.slice(0, at);
+	return cut.endsWith(" ") ? cut.slice(0, -1) : cut;
+}
+function resolvePicks(picks) {
+	const resolved = {};
+	for (const spec of ITEMS) {
+		const pick = picks?.[spec.item] ?? spec.default;
+		if (spec.alternatives.includes(pick)) resolved[spec.item] = pick;
+		else {
+			warn(`statusline: ${spec.item}=${pick} is not available, using ${spec.item}=${spec.default}`);
+			resolved[spec.item] = spec.default;
+		}
+	}
+	return resolved;
+}
+function parseLayout(layout, known) {
+	let parsed;
+	try {
+		parsed = parseClusters(layout);
+	} catch (e) {
+		warn(`statusline: ${e.message}`);
+		return [];
+	}
+	const clusters = [];
+	for (const words of parsed) {
+		const kept = words.filter((word) => {
+			if (known.has(word)) return true;
+			warn(`statusline: layout item '${word}' is not available, skipped`);
+			return false;
+		});
+		if (kept.length > 0) clusters.push(kept);
+	}
+	return clusters;
+}
+function renderStatusline(input) {
+	const row = parseRow(input.payload);
+	const git = readGit(row.dir, { home: input.home });
+	const picks = resolvePicks(input.picks);
+	const { join, sep } = styleSeparators(picks.style);
+	const clusters = parseLayout(input.layout ?? "{model effort state} {cwd branch status ahead pr} {bar tokens cache} {cost} {duration} {lines} {rate}", new Set(ITEMS.map((spec) => spec.item)));
+	const wrapAt = clusters.length > 2 ? 2 : 1;
+	let width = input.columns;
+	if (width === void 0 || !Number.isInteger(width) || width < 0) width = 200;
+	if (width < 20) width = 20;
+	const avail = width - 3;
+	let model = row.model;
+	const initialRungs = RUNG_ITEMS.map((item) => [item, picks[item]]);
+	function segmentInput() {
+		return {
+			git,
+			home: input.home,
+			model,
+			now: input.now,
+			row
+		};
+	}
+	function compose(mode) {
+		const from = mode === "l2" ? wrapAt : 0;
+		const to = mode === "l1" ? wrapAt : clusters.length;
+		let line = "";
+		let first = true;
+		for (let ci = from; ci < to; ci++) {
+			let cseg = "";
+			let cf = true;
+			for (const item of clusters[ci]) {
+				const out = renderSegment(item, picks[item], segmentInput());
+				if (out === "") continue;
+				if (cf) {
+					cseg = out;
+					cf = false;
+				} else cseg += join + out;
+			}
+			if (cseg === "") continue;
+			if (first) {
+				line = cseg;
+				first = false;
+			} else line += sep + cseg;
+		}
+		return line;
+	}
+	function fits(line) {
+		return vlen$1(line) <= avail;
+	}
+	function demote(item, target) {
+		const order = RUNG_ORDERS[item];
+		if (order === void 0) return;
+		const at = order.indexOf(picks[item]);
+		if (at === -1) return;
+		if (order.slice(at + 1).includes(target)) picks[item] = target;
+	}
+	function resetRungs() {
+		model = row.model;
+		for (const [item, pick] of initialRungs) picks[item] = pick;
+	}
+	function applyStep(step) {
+		if (step[0] === "model" && step[1] === "strip") model = stripModelSuffix(model);
+		else demote(step[0], step[1]);
+	}
+	function fit(mode, steps) {
+		let out = compose(mode);
+		if (fits(out)) return out;
+		for (const step of steps) {
+			applyStep(step);
+			out = compose(mode);
+			if (fits(out)) return out;
+		}
+		return out;
+	}
+	function emit(line) {
+		return `${input.noColor === true ? stripSgr(line) : line}\n`;
+	}
+	const full = fit("full", FULL_STEPS);
+	if (fits(full)) return emit(full);
+	resetRungs();
+	const l1 = fit("l1", L1_STEPS);
+	const l2 = fit("l2", L2_STEPS);
+	return emit(l1) + emit(l2);
+}
+//#endregion
 //#region src/themes.ts
 var THEME_NAMES = [
 	"classic",
@@ -31,127 +1116,148 @@ var THEME_NAMES = [
 	"quiet",
 	"rich"
 ];
-var CUSTOM_SEEDS = {
-	branch: "last",
-	cwd: "base",
-	model: "zen",
-	style: "bare"
-};
-function offers(item, variant) {
-	return item.default === variant || item.alternatives.includes(variant);
-}
-function absenceSeed(item) {
-	if (offers(item, "none")) return "none";
-	if (offers(item, "hidden")) return "hidden";
-	const named = CUSTOM_SEEDS[item.item];
-	if (named === void 0) throw new Error(`no absence variant for '${item.item}' — name its seed`);
-	return named;
-}
-function themesFor(runtime) {
-	function variantsOf(pick) {
-		return Object.fromEntries(runtime.items.map((item) => [item.item, pick(item)]));
+var THEMES = {
+	quiet: {
+		layout: "{model cwd}",
+		summary: "model and directory, nothing else",
+		variants: {
+			cwd: "tail",
+			model: "zen",
+			style: "bare"
+		}
+	},
+	classic: {
+		layout: DEFAULT_LAYOUT,
+		summary: "the shipped defaults, named",
+		variants: {}
+	},
+	lean: {
+		layout: DEFAULT_LAYOUT,
+		summary: "text only, no graphics",
+		variants: {
+			model: "plain",
+			effort: "dim",
+			state: "none",
+			cwd: "init",
+			branch: "initials",
+			status: "counts",
+			ahead: "arrows",
+			pr: "badge",
+			bar: "percent",
+			tokens: "full",
+			cache: "hit",
+			cost: "plain",
+			duration: "clock",
+			lines: "diffstat",
+			rate: "none",
+			style: "dots"
+		}
+	},
+	rich: {
+		layout: DEFAULT_LAYOUT,
+		summary: "every gauge and counter",
+		variants: {
+			model: "pill",
+			effort: "plain",
+			state: "pills",
+			cwd: "icon",
+			branch: "icon",
+			status: "icons",
+			ahead: "arrows",
+			pr: "badge",
+			bar: "gauge",
+			tokens: "full",
+			cache: "fuse",
+			cost: "burn",
+			duration: "clock",
+			lines: "diffstat",
+			rate: "strip",
+			style: "plain"
+		}
+	},
+	custom: {
+		layout: DEFAULT_LAYOUT,
+		summary: "bare; you decide everything",
+		variants: {
+			model: "zen",
+			effort: "hidden",
+			state: "none",
+			cwd: "base",
+			branch: "none",
+			status: "none",
+			ahead: "none",
+			pr: "none",
+			bar: "none",
+			tokens: "none",
+			cache: "none",
+			cost: "none",
+			duration: "none",
+			lines: "none",
+			rate: "none",
+			style: "bare"
+		}
 	}
+};
+//#endregion
+//#region src/render/theme.ts
+function resolvePaint(input) {
+	const name = input.theme;
+	const theme = name === void 0 ? void 0 : THEMES[name];
+	if (name !== void 0 && theme === void 0) warn(`statusline: theme=${name} is not a known theme, ignored`);
 	return {
-		quiet: {
-			layout: "{model cwd}",
-			summary: "model and directory, nothing else",
-			variants: {
-				cwd: "tail",
-				model: "zen",
-				style: "bare"
-			}
-		},
-		classic: {
-			layout: runtime.defaultLayout,
-			summary: "the shipped defaults, named",
-			variants: variantsOf((item) => item.default)
-		},
-		lean: {
-			layout: runtime.defaultLayout,
-			summary: "text only, no graphics",
-			variants: {
-				model: "plain",
-				effort: "dim",
-				state: "none",
-				cwd: "init",
-				branch: "initials",
-				status: "counts",
-				ahead: "arrows",
-				pr: "badge",
-				bar: "percent",
-				tokens: "full",
-				cache: "hit",
-				cost: "plain",
-				duration: "clock",
-				lines: "diffstat",
-				rate: "none",
-				style: "dots"
-			}
-		},
-		rich: {
-			layout: runtime.defaultLayout,
-			summary: "every gauge and counter",
-			variants: {
-				model: "pill",
-				effort: "plain",
-				state: "pills",
-				cwd: "icon",
-				branch: "icon",
-				status: "icons",
-				ahead: "arrows",
-				pr: "badge",
-				bar: "gauge",
-				tokens: "full",
-				cache: "fuse",
-				cost: "burn",
-				duration: "clock",
-				lines: "diffstat",
-				rate: "strip",
-				style: "plain"
-			}
-		},
-		custom: {
-			layout: runtime.defaultLayout,
-			summary: "bare; you decide everything",
-			variants: variantsOf(absenceSeed)
+		layout: input.layout ?? theme?.layout ?? "{model effort state} {cwd branch status ahead pr} {bar tokens cache} {cost} {duration} {lines} {rate}",
+		picks: {
+			...theme?.variants ?? {},
+			...input.picks
 		}
 	};
 }
 //#endregion
-//#region src/live-theme.ts
-function sameAssignments(key, theme) {
-	return Object.entries(key).every(([item, variant]) => theme[item] === variant) && Object.entries(theme).every(([item, variant]) => key[item] === variant);
-}
-function liveTheme(key, runtime) {
-	const themes = themesFor(runtime);
-	for (const name of Object.keys(themes)) {
-		const { layout, variants } = themes[name];
-		if (key.layout === layout && sameAssignments(key.values, variants)) return name;
-	}
-}
+//#region src/render/capture.ts
+var DATA_DIR = join(".claude", "plugins", "data", "statusline-agentic");
 //#endregion
 //#region src/resolve.ts
-var DATA_REL = join(".claude", "plugins", "data", "statusline-agentic");
 function capturePath(home, surface) {
-	return join(home, DATA_REL, "captures", `${surface}.json`);
+	return join(home, DATA_DIR, "captures", `${surface}.json`);
 }
 function backupPath(home) {
-	return join(home, DATA_REL, "backup.json");
+	return join(home, DATA_DIR, "backup.json");
+}
+function renderMjsPath(home) {
+	return join(home, DATA_DIR, "render.mjs");
+}
+var RENDER_PROGRAM = `node "$HOME/${DATA_DIR.split(sep).join("/")}/render.mjs"`;
+var PANEL_PROGRAM = `${RENDER_PROGRAM} panel`;
+var KEY_SUFFIX = " || true";
+function keyValue(program, theme, layout, flags) {
+	return `${[
+		program,
+		...theme === null ? [] : [`--theme=${theme}`],
+		...layout === null ? [] : [`--layout='${layout}'`],
+		...flags
+	].join(" ")}${KEY_SUFFIX}`;
+}
+function mainKeyValue(theme, layout, flags) {
+	return keyValue(RENDER_PROGRAM, theme, layout, flags);
+}
+function panelKeyValue(theme, flags) {
+	return keyValue(PANEL_PROGRAM, theme, null, flags);
 }
-var KEY_RESOLVER = "d=$(printf '%s\\n' ~/.claude/plugins/cache/agentic/statusline/*/ | sort -V | tail -1)";
-var MAIN_PREFIX = `${KEY_RESOLVER}; `;
-var MAIN_SUFFIX = "bash \"${d}runtime/statusline.sh\" 2>/dev/null || true";
-function mainKeyValue(layout, assignments) {
-	return `${MAIN_PREFIX}${[`STATUSLINE_LAB_LAYOUT='${layout}'`, ...assignments].join(" ")} ${MAIN_SUFFIX}`;
+function commandMiddle(program, command) {
+	if (!command.startsWith(program) || !command.endsWith(KEY_SUFFIX)) return null;
+	const middle = command.slice(program.length, command.length - 8);
+	return middle === "" || middle.startsWith(" --") ? middle : null;
 }
-var subagentKeyValue = `${KEY_RESOLVER}; bash "\${d}runtime/subagent.sh" 2>/dev/null || true`;
 function isOurMainCommand(command) {
-	return command.startsWith(MAIN_PREFIX) && command.endsWith(` ${MAIN_SUFFIX}`);
+	return commandMiddle(RENDER_PROGRAM, command) !== null;
 }
-function mainKeyMiddle(command) {
-	if (!isOurMainCommand(command)) return null;
-	return command.slice(MAIN_PREFIX.length, command.length - 52 - 1);
+function isOurPanelCommand(command) {
+	return commandMiddle(PANEL_PROGRAM, command) !== null;
 }
+var NO_DECISIONS = {
+	layout: null,
+	values: {}
+};
 function settingsCommand(home) {
 	let raw;
 	try {
@@ -170,106 +1276,43 @@ function settingsCommand(home) {
 	const command = member.command;
 	return typeof command === "string" ? command : null;
 }
-function readKeyConfig(home) {
-	const command = settingsCommand(home);
-	const middle = command === null ? null : mainKeyMiddle(command);
-	if (middle === null) return {
-		layout: null,
-		values: {}
-	};
-	const layout = /^STATUSLINE_LAB_LAYOUT='([^']*)'/.exec(middle);
-	if (layout === null) return {
-		layout: null,
-		values: {}
-	};
+function parseKeyFlags(flags) {
 	const values = {};
-	for (const [, name, alt] of middle.matchAll(/(?:^| )STATUSLINE_LAB_([A-Z][A-Z0-9_]*)=([a-z0-9]+)/g)) values[name.toLowerCase()] = alt;
+	let theme;
+	for (const [, name, alt] of flags.matchAll(/(?:^| )--([a-z][a-z0-9]*)=([a-z0-9]+)/g)) if (name === "theme") theme = alt;
+	else if (name !== "now" && name !== "layout") values[name] = alt;
+	const layout = /--layout='([^']*)'/.exec(flags);
 	return {
-		layout: layout[1],
-		values
+		layout: layout === null ? null : layout[1],
+		values,
+		...theme === void 0 ? {} : { theme }
 	};
 }
-function byVersion(a, b) {
-	const left = a.split(".");
-	const right = b.split(".");
-	for (let i = 0; i < left.length || i < right.length; i += 1) {
-		const delta = (parseInt(left[i] ?? "0", 10) || 0) - (parseInt(right[i] ?? "0", 10) || 0);
-		if (delta !== 0) return delta;
-	}
-	return 0;
-}
-function newestCacheDir(cacheRoot) {
-	let versions;
-	try {
-		versions = readdirSync(cacheRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-	} catch {
-		return null;
-	}
-	if (versions.length === 0) return null;
-	versions.sort(byVersion);
-	return join(cacheRoot, versions[versions.length - 1]);
-}
-function readAlternatives(dir) {
-	const declared = /* @__PURE__ */ new Map();
-	const components = join(dir, "components");
-	for (const file of readdirSync(components).sort()) {
-		if (!file.endsWith(".sh")) continue;
-		for (const line of readFileSync(join(components, file), "utf8").split("\n")) {
-			if (!line.startsWith("#")) break;
-			const match = /alternatives:\s*(.+)$/.exec(line);
-			if (match) declared.set(file.slice(0, -3), match[1].split("|").map((alt) => alt.trim().replace(/\s*\(current\)$/, "")));
-		}
-	}
-	return declared;
-}
-function readItems(dir) {
-	const alternatives = readAlternatives(dir);
-	const defaults = /* @__PURE__ */ new Map();
-	for (const [, item, alt] of readFileSync(join(dir, "lib.sh"), "utf8").matchAll(/([a-z]+)\) echo ([a-z]+) ;;/g)) defaults.set(item, alt);
-	const match = /^COMPS="(.+)"$/m.exec(readFileSync(join(dir, "statusline.sh"), "utf8"));
-	if (match === null) throw new Error(`statusline.sh in ${dir} declares no COMPS order`);
-	return match[1].split(" ").map((item) => {
-		const alt = defaults.get(item);
-		if (alt === void 0) throw new Error(`lib.sh in ${dir} declares no default for '${item}'`);
-		return {
-			alternatives: alternatives.get(item) ?? [],
-			default: alt,
-			item
-		};
-	});
-}
-function readDefaultLayout(dir) {
-	const match = /^export DEFAULT_LAYOUT='(.*)'$/m.exec(readFileSync(join(dir, "lib.sh"), "utf8"));
-	if (match === null) throw new Error(`lib.sh in ${dir} declares no DEFAULT_LAYOUT`);
-	return match[1];
-}
-function resolveRuntimeDir(dir) {
-	return {
-		defaultLayout: readDefaultLayout(dir),
-		dir,
-		items: readItems(dir)
-	};
+function readKeyConfig(home) {
+	const command = settingsCommand(home);
+	const flags = command === null ? null : commandMiddle(RENDER_PROGRAM, command);
+	return flags === null ? NO_DECISIONS : parseKeyFlags(flags);
 }
-function resolveRuntime({ home }) {
-	const pluginDir = newestCacheDir(join(home, ".claude", "plugins", "cache", "agentic", "statusline"));
-	const dir = pluginDir === null ? null : join(pluginDir, "runtime");
-	if (dir === null || !existsSync(join(dir, "statusline.sh"))) throw new Error(`no statusline runtime under ${home} — install the plugin first: claude plugin install statusline@agentic`);
-	return resolveRuntimeDir(dir);
+function parsePanelCommand(command) {
+	const flags = command === null ? null : commandMiddle(PANEL_PROGRAM, command);
+	return flags === null ? NO_DECISIONS : parseKeyFlags(flags);
 }
 //#endregion
 //#region src/catalog.ts
 function catalog(options) {
 	if (options.themes === true && options.items !== void 0) throw new Error("--themes cannot combine with item flags");
-	const runtime = resolveRuntime({ home: options.home });
 	const key = readKeyConfig(options.home);
-	const live = liveTheme(key, runtime);
-	const block = Object.entries(themesFor(runtime)).map(([name, theme]) => `${name}${live === name ? "*" : ""}: ${theme.summary}`);
+	const block = Object.entries(THEMES).map(([name, theme]) => `${name}${key.theme === name ? "*" : ""}: ${theme.summary}`);
 	if (options.themes === true) return block.join("\n");
-	const byItem = new Map(runtime.items.map((item) => [item.item, item]));
-	const itemLines = (options.items ?? runtime.items.map((item) => item.item)).map((item) => {
-		const entry = byItem.get(item);
-		if (entry === void 0) throw new Error(`unknown item '${item}' — valid items: ${[...byItem.keys()].join(" ")}`);
-		const current = key.values[item] ?? entry.default;
+	const resolved = resolvePaint({
+		layout: key.layout ?? void 0,
+		picks: key.values,
+		theme: key.theme
+	});
+	const itemLines = (options.items ?? ITEM_IDS).map((item) => {
+		const entry = specFor(item);
+		if (entry === void 0) throw new Error(`unknown item '${item}' — valid items: ${ITEM_IDS.join(" ")}`);
+		const current = resolved.picks[item] ?? entry.default;
 		return `${item}: ${entry.alternatives.map((alt) => alt === current ? `${alt}*` : alt).join(" | ")}`;
 	});
 	return [
@@ -282,12 +1325,12 @@ function catalog(options) {
 //#region src/cli.ts
 var VERSION = {
 	name: "@v1nvn/statusline",
-	version: "0.28.0",
+	version: "0.30.0",
 	description: "Browse statusline variants and configure the live status line and agent panel — the statusline CLI behind the statusline plugin.",
 	type: "module",
 	bin: "dist/index.js",
 	scripts: {
-		"build": "vite build",
+		"build": "vite build && vite build --mode render",
 		"test": "vitest run",
 		"test:watch": "vitest"
 	},
@@ -318,24 +1361,6 @@ var VERSION = {
 		"vitest": "^4.1.10"
 	}
 }.version;
-var ITEM_IDS = [
-	"model",
-	"effort",
-	"state",
-	"cwd",
-	"branch",
-	"status",
-	"ahead",
-	"pr",
-	"bar",
-	"tokens",
-	"cache",
-	"cost",
-	"duration",
-	"lines",
-	"rate",
-	"style"
-];
 var QUIET = {
 	writeOut: () => void 0,
 	writeErr: () => void 0
@@ -437,46 +1462,17 @@ function parseArgs(args) {
 }
 //#endregion
 //#region src/configure.ts
-var SETTINGS_KEYS = ["statusLine", "subagentStatusLine"];
-function layoutItems(layout, valid) {
-	const known = new Set(valid);
-	const items = [];
-	for (const cluster of parseClusters(layout)) for (const word of cluster) {
-		if (!known.has(word)) throw new Error(`unknown layout item '${word}' — valid items: ${valid.join(" ")}`);
-		if (!items.includes(word)) items.push(word);
-	}
-	return items;
-}
-function parseClusters(layout) {
-	const clusters = [];
-	let words = [];
-	let word = "";
-	let open = false;
-	function pushWord() {
-		if (word !== "") {
-			words.push(word);
-			word = "";
-		}
-	}
-	for (const c of layout) if (c === "{") {
-		if (open) throw new Error(`layout '${layout}': '{' inside a cluster`);
-		open = true;
-		words = [];
-	} else if (c === "}") {
-		if (!open) throw new Error(`layout '${layout}': '}' outside a cluster`);
-		pushWord();
-		open = false;
-		if (words.length > 0) clusters.push(words);
-	} else if (c === " ") {
-		if (open) pushWord();
-		else if (word !== "") throw new Error(`layout '${layout}': '${word}' sits outside a cluster`);
-	} else if (/[a-z0-9]/.test(c)) word += c;
-	else throw new Error(`layout '${layout}': '${c}' is not layout grammar (braces, item ids, spaces)`);
-	if (open) throw new Error(`layout '${layout}': unterminated cluster`);
-	if (word !== "") throw new Error(`layout '${layout}': '${word}' sits outside a cluster`);
-	if (clusters.length === 0) throw new Error(`layout '${layout}': no clusters`);
-	return clusters;
+var BUNDLED_RENDERER = fileURLToPath(new URL("../dist/render.mjs", import.meta.url));
+function syncRenderer(home) {
+	const source = readFileSync(BUNDLED_RENDERER);
+	const dest = renderMjsPath(home);
+	if (existsSync(dest) && readFileSync(dest).equals(source)) return;
+	mkdirSync(dirname(dest), { recursive: true });
+	const tmp = `${dest}.tmp`;
+	writeFileSync(tmp, source);
+	renameSync(tmp, dest);
 }
+var SETTINGS_KEYS = ["statusLine", "subagentStatusLine"];
 function isObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -505,14 +1501,11 @@ function memberCommand(value) {
 function isOurMember(key, value) {
 	const command = memberCommand(value);
 	if (command === null) return false;
-	return key === "statusLine" ? isOurMainCommand(command) : command === subagentKeyValue;
+	return key === "statusLine" ? isOurMainCommand(command) : isOurPanelCommand(command);
 }
-function planSettings(home, mainCommand, force) {
+function planSettings(home, commands, force) {
 	const file = join(home, ".claude", "settings.json");
-	const wanted = {
-		statusLine: mainCommand,
-		subagentStatusLine: subagentKeyValue
-	};
+	const wanted = commands;
 	const raw = readOrNull(file);
 	if (raw === null) return {
 		adds: SETTINGS_KEYS.map((key) => [key, wanted[key]]),
@@ -687,44 +1680,42 @@ function themeNamed(name, themes) {
 	if (theme === void 0) throw new Error(`unknown theme '${name}' — valid themes: ${THEME_NAMES.join(" ")}`);
 	return theme;
 }
-function resolveSelection(runtime, options) {
-	const variants = options.variants ?? {};
-	const themes = themesFor(runtime);
-	const theme = options.theme === void 0 ? void 0 : themeNamed(options.theme, themes);
+function validateSelection(options) {
+	const theme = options.theme === void 0 ? void 0 : themeNamed(options.theme, THEMES);
 	const layout = options.layout ?? theme?.layout;
 	if (layout === void 0) throw new Error("no layout — pass --layout <spec> or --theme <name>");
-	const byItem = new Map(runtime.items.map((item) => [item.item, item]));
-	const items = layoutItems(layout, runtime.items.map((item) => item.item));
-	const values = {
-		...theme?.variants ?? {},
-		...variants
-	};
-	const missing = items.filter((item) => !(item in values));
-	if (missing.length > 0) {
-		const hints = missing.map((item) => `--${item} <alt>`).join(" ");
-		const names = missing.map((item) => `'${item}'`).join(" ");
-		const plural = missing.length > 1 ? "s" : "";
-		throw new Error(theme === void 0 ? `no variant for layout item${plural} ${names} — pass ${hints}, or name a theme: --theme ${THEME_NAMES.join("|")}` : `theme '${options.theme}' has no pick for layout item${plural} ${names} — pass ${hints}, or drop ${missing.length > 1 ? "them" : "it"} from the layout`);
-	}
-	for (const [item, alt] of Object.entries(values)) {
-		const entry = byItem.get(item);
-		if (entry === void 0) throw new Error(`unknown item '${item}' — valid items: ${[...byItem.keys()].join(" ")}`);
+	layoutItems(layout, ITEM_IDS);
+	for (const [item, alt] of Object.entries(options.variants ?? {})) {
+		const entry = specFor(item);
+		if (entry === void 0) throw new Error(`unknown item '${item}' — valid items: ${ITEM_IDS.join(" ")}`);
 		if (!entry.alternatives.includes(alt)) throw new Error(`unknown variant '${alt}' for item '${item}' — valid: ${entry.alternatives.join(" | ")}`);
 	}
-	return {
-		layout,
-		ordered: [...items, ...runtime.items.map((entry) => entry.item).filter((item) => !items.includes(item) && item in values)],
-		values
-	};
+	return theme;
+}
+function decisionFlags(base, decisions) {
+	return ITEMS.flatMap(({ item }) => {
+		const pick = decisions[item];
+		return pick === void 0 || pick === base[item] ? [] : [`--${item}=${pick}`];
+	});
 }
 function configure(options) {
-	const runtime = resolveRuntime({ home: options.home });
 	if (options.theme === void 0 && options.layout === void 0 && Object.keys(options.variants ?? {}).length === 0) throw new Error("no theme and no item flags — on a terminal run 'statusline configure' for the wizard; in Claude Code use the /lab skill");
-	const { layout, ordered, values } = resolveSelection(runtime, options);
-	const assignments = ordered.map((item) => `STATUSLINE_LAB_${item.toUpperCase()}=${values[item]}`);
-	const plan = planSettings(options.home, mainKeyValue(layout, assignments), options.force ?? false);
+	const theme = validateSelection(options);
+	const base = {
+		...DEFAULT_PICKS,
+		...theme?.variants
+	};
+	const decisions = options.variants ?? {};
+	const baseLayout = theme?.layout ?? "{model effort state} {cwd branch status ahead pr} {bar tokens cache} {cost} {duration} {lines} {rate}";
+	const layout = options.layout === void 0 || options.layout === baseLayout ? null : options.layout;
+	const flags = decisionFlags(base, decisions);
+	const plan = planSettings(options.home, {
+		statusLine: mainKeyValue(options.theme ?? null, layout, flags),
+		subagentStatusLine: panelKeyValue(options.theme ?? null, flags.filter((flag) => flag.startsWith("--style=")))
+	}, options.force ?? false);
 	if (plan.adds.length > 0 || plan.repoints.length > 0) writeBackupIfAbsent(options.home, plan);
 	commitSettings(plan);
+	syncRenderer(options.home);
 }
 //#endregion
 //#region src/demo-repo.ts
@@ -869,6 +1860,157 @@ function materializeDemoRepo(home) {
 	return dir;
 }
 //#endregion
+//#region src/render/panel.ts
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var RESET = "\x1B[0m";
+var YELLOW = "\x1B[33m";
+var MS_THRESHOLD = 2e11;
+var STEPS = [
+	["descd", 1],
+	["durd", 1],
+	["statd", 1],
+	["barb", 6],
+	["modeld", 1],
+	["barb", 4],
+	["barb", 0],
+	["modeld", 2],
+	["statd", 2]
+];
+function field(source, key, fallback) {
+	return orElse(source[key], fallback);
+}
+function cell(value) {
+	return tsvEscape(jqText(value));
+}
+function truncateDesc(desc) {
+	const chars = Array.from(desc);
+	return chars.length > 24 ? `${chars.slice(0, 23).join("")}…` : desc;
+}
+function intValue(text) {
+	return /^-?\d+$/.test(text) ? Number(text) : null;
+}
+function stylePick(picks) {
+	const spec = specFor("style");
+	if (spec === void 0) return "plain";
+	const wanted = picks?.style ?? "";
+	const alt = wanted === "" ? spec.default : wanted;
+	if (!spec.alternatives.includes(alt)) {
+		warn(`statusline: style=${alt} is not available, using style=${spec.default}`);
+		return spec.default;
+	}
+	return alt;
+}
+function availColumns(tick) {
+	const text = jqText(isRecord(tick) ? field(tick, "columns", 200) : 200);
+	const columns = /^\d+$/.test(text) ? Number(text) : 200;
+	return Math.max(columns, 20) - 1;
+}
+function extractFields(task) {
+	return {
+		ctx: cell(field(task, "contextWindowSize", 0)),
+		desc: cell(truncateDesc(jqText(field(task, "description", "")))),
+		effort: cell(field(task, "effort", "")),
+		id: cell(field(task, "id", "")),
+		label: cell(field(task, "label", "")),
+		model: cell(field(task, "model", "")),
+		name: cell(field(task, "name", "")),
+		start: cell(field(task, "startTime", 0)),
+		tokens: cell(field(task, "tokenCount", 0))
+	};
+}
+function makeBar(pct, width) {
+	let f = Math.trunc(pct * width / 100);
+	if (f > width) f = width;
+	let bar = "";
+	for (let i = 0; i < width; i++) bar += i < f ? "█" : "░";
+	return bar;
+}
+function duration(startText, now) {
+	const start = intValue(startText);
+	if (start === null || start <= 0) return "";
+	const seconds = start > MS_THRESHOLD ? Math.trunc(start / 1e3) : start;
+	const elapsed = Math.trunc(now) - seconds;
+	if (elapsed < 0) return "";
+	return `${Math.trunc(elapsed / 60)}m${pad2(Math.trunc(elapsed % 60))}s`;
+}
+function rowFormats(fields, now) {
+	const tokens = intValue(fields.tokens) ?? 0;
+	const ctx = intValue(fields.ctx) ?? 0;
+	let ctxText = fields.ctx;
+	if (ctx >= 1e6) ctxText = fmtM(ctx);
+	else if (ctx >= 1e3) ctxText = fmtK(ctx, 0);
+	return {
+		ctx: ctxText,
+		dur: duration(fields.start, now),
+		tickTok: tokens >= 1e3 ? fmtK(tokens, 0) : String(tokens),
+		tokens: tokens >= 1e3 ? fmtK(tokens, 1) : String(tokens)
+	};
+}
+function renderRow(fields, formats, state, sep) {
+	let s = fields.label === "" ? fields.name : fields.label;
+	if (fields.desc !== "" && fields.desc !== fields.label && state.descd === 0) s += ` ${fields.desc}`;
+	if (fields.model !== "") {
+		let name = fields.model;
+		if (state.modeld >= 1) name = stripModelSuffix(name);
+		const effort = state.modeld >= 2 ? "" : fields.effort;
+		if (effort !== "") name += ` ${effort}`;
+		s += `${sep}${CYAN}${name}${RESET}`;
+	}
+	const ctx = intValue(fields.ctx);
+	if (ctx !== null && ctx > 0) {
+		const tokens = intValue(fields.tokens) ?? 0;
+		const pct = Math.trunc(tokens * 100 / ctx);
+		const barColor = pct >= 90 ? RED : pct >= 70 ? YELLOW : GREEN;
+		if (state.barb > 0) s += `${sep}${barColor}${makeBar(pct, state.barb)}${RESET} ${pct}%`;
+		else s += `${sep}${barColor}${pct}%${RESET}`;
+		const stats = state.statd === 1 ? formats.tickTok : state.statd === 2 ? "" : `${formats.tokens}/${formats.ctx}`;
+		if (stats !== "") s += ` ${stats}`;
+	}
+	if (formats.dur !== "" && state.durd === 0) s += `${sep}${formats.dur}`;
+	return s;
+}
+function vlen(text) {
+	return Array.from(stripSgr(text)).length;
+}
+function fitRow(fields, formats, sep, avail) {
+	const state = {
+		barb: 10,
+		descd: 0,
+		durd: 0,
+		modeld: 0,
+		statd: 0
+	};
+	let out = renderRow(fields, formats, state, sep);
+	if (vlen(out) <= avail) return out;
+	for (const [key, value] of STEPS) {
+		state[key] = value;
+		out = renderRow(fields, formats, state, sep);
+		if (vlen(out) <= avail) return out;
+	}
+	return out;
+}
+function emitLine(id, content) {
+	return `{"id":${JSON.stringify(id)},"content":${JSON.stringify(content)}}`;
+}
+function renderPanel(input) {
+	const tick = JSON.parse(input.payload);
+	const avail = availColumns(tick);
+	const sep = styleSeparators(stylePick(input.picks)).sep;
+	const tasks = isRecord(tick) && Array.isArray(tick.tasks) ? tick.tasks : [];
+	let out = "";
+	for (const task of tasks) {
+		if (!isRecord(task)) continue;
+		const fields = extractFields(task);
+		if (fields.id === "") continue;
+		const row = fitRow(fields, rowFormats(fields, input.now), sep, avail);
+		const content = input.noColor === true ? stripSgr(row) : row;
+		out += `${emitLine(fields.id, content)}\n`;
+	}
+	return out;
+}
+//#endregion
 //#region src/payloads.ts
 var PAYLOADS_DIR = fileURLToPath(new URL("../assets/payloads", import.meta.url));
 var TICKS_DIR = fileURLToPath(new URL("../assets/ticks", import.meta.url));
@@ -947,68 +2089,46 @@ function firstPanelRow(output) {
 	const content = JSON.parse(row).content;
 	return typeof content === "string" ? content : "";
 }
-function runtimeRenderer(spec) {
-	const run = spawnSync("bash", [spec.bin], {
-		input: spec.stdin,
-		env: {
-			PATH: process.env.PATH ?? "",
-			...spec.env,
-			LC_ALL: "C",
-			TZ: "UTC"
-		},
-		timeout: 3e4
-	});
-	if (run.status !== 0) throw new Error(`render failed: ${run.stderr.toString("utf8")}`);
-	const stdout = run.stdout.toString("utf8");
-	const warn = run.stderr.toString("utf8").trim();
-	return warn === "" ? stdout : `${stdout}${warn}\n`;
-}
 function renderPreview(bag) {
-	const variantEnv = Object.fromEntries(Object.entries(bag.values).map(([item, alt]) => [`STATUSLINE_LAB_${item.toUpperCase()}`, alt]));
 	const plain = bag.plain === true || (process.env.NO_COLOR ?? "") !== "";
-	const env = {
-		...variantEnv,
-		...plain ? { NO_COLOR: "1" } : {}
-	};
+	const paint = resolvePaint({
+		layout: bag.layout,
+		picks: bag.values,
+		theme: bag.theme
+	});
 	return {
-		line: runtimeRenderer({
-			bin: join(bag.runtime.dir, "statusline.sh"),
-			env: {
-				...env,
-				COLUMNS: String(bag.width ?? 200),
-				HOME: bag.home,
-				NOW: bag.now,
-				STATUSLINE_LAB_LAYOUT: bag.layout
-			},
-			stdin: bag.main
+		line: renderStatusline({
+			home: bag.home,
+			layout: paint.layout,
+			noColor: plain,
+			now: Number(bag.now),
+			payload: bag.main,
+			picks: paint.picks,
+			...bag.width === void 0 ? {} : { columns: bag.width }
 		}).replace(/\n+$/, ""),
-		panel: firstPanelRow(runtimeRenderer({
-			bin: join(bag.runtime.dir, "subagent.sh"),
-			env: {
-				...env,
-				HOME: bag.home,
-				NOW: bag.now
-			},
-			stdin: bag.tick
+		panel: firstPanelRow(renderPanel({
+			noColor: plain,
+			now: Number(bag.now),
+			payload: bag.tick,
+			picks: paint.picks
 		}).replace(/\n+$/, ""))
 	};
 }
 //#endregion
 //#region src/preview.ts
 function preview(options) {
-	const runtime = resolveRuntime({ home: options.home });
-	const { layout, values } = resolveSelection(runtime, options);
+	validateSelection(options);
 	const sources = previewSources(options.home, Number(options.now));
 	try {
 		const { line, panel } = renderPreview({
 			home: options.home,
-			layout,
+			layout: options.layout,
 			main: sources.main,
 			now: options.now,
 			plain: options.plain ?? !process.stdout.isTTY,
-			runtime,
 			tick: sources.tick,
-			values
+			theme: options.theme,
+			values: options.variants
 		});
 		return `preview at 200 columns — nothing written\n${line}\npanel ${panel}\n`;
 	} finally {
@@ -1099,18 +2219,20 @@ function restore(options) {
 			next = null;
 		} else next = text;
 	}
-	const dataDir = join(options.home, DATA_REL);
+	const dataDir = join(options.home, DATA_DIR);
 	const capturesDir = join(dataDir, "captures");
 	const backupFile = backupPath(options.home);
-	if (actions.length === 0 && !existsSync(backupFile) && !existsSync(capturesDir)) return {
+	const rendererFile = renderMjsPath(options.home);
+	if (actions.length === 0 && !existsSync(backupFile) && !existsSync(capturesDir) && !existsSync(rendererFile)) return {
 		mode: "nothing",
-		text: "nothing to restore — no lab keys in settings.json, no backup, no captures"
+		text: "nothing to restore — no lab keys in settings.json, no backup, no captures, no renderer"
 	};
 	if (options.dryRun) {
 		const lines = ["restore plan — nothing written"];
 		for (const action of actions) lines.push(action.kind === "remove" ? `  remove ${action.key} (absent before the lab)` : `  splice the saved ${action.key} value back`);
 		if (deleteFile) lines.push("  delete settings.json (the lab created it and it is now empty)");
 		if (existsSync(capturesDir)) lines.push("  delete captures/");
+		if (existsSync(rendererFile)) lines.push("  delete render.mjs");
 		if (existsSync(backupFile)) lines.push("  delete backup.json");
 		lines.push("  remove the data dir if empty");
 		return {
@@ -1121,6 +2243,7 @@ function restore(options) {
 	if (deleteFile) rmSync(settings, { force: true });
 	else if (next !== null && actions.length > 0) writeFileSync(settings, next);
 	clearCaptures(capturesDir);
+	rmSync(rendererFile, { force: true });
 	rmSync(backupFile, { force: true });
 	rmdirIfEmpty(dataDir);
 	let line;
@@ -1134,7 +2257,6 @@ function restore(options) {
 }
 //#endregion
 //#region src/status.ts
-var INSTALL_FIX = "claude plugin install statusline@agentic";
 function keyState(key, value) {
 	if (value === void 0) return { kind: "absent" };
 	if (isOurMember(key, value)) return { kind: "ours" };
@@ -1148,25 +2270,29 @@ function keyRow(key, state, detail = "") {
 	if (state.kind === "absent") return `${key}: absent — fix: rerun configure --theme classic`;
 	return `${key}: foreign${state.command === null ? "" : ` (${state.command})`} — fix: rerun configure --force --theme classic`;
 }
-function layoutItemsOf(layout) {
-	const items = [];
-	for (const cluster of parseClusters(layout)) for (const item of cluster) if (!items.includes(item)) items.push(item);
-	return items;
+function keyItems(config) {
+	const layout = config.layout === null ? [] : layoutItemsOf(config.layout);
+	return [.../* @__PURE__ */ new Set([...layout, ...Object.keys(config.values)])];
 }
 function configDetail(config) {
-	if (config.layout === null) return "";
-	const assignments = layoutItemsOf(config.layout).filter((item) => Object.hasOwn(config.values, item)).map((item) => `${item}=${config.values[item]}`);
-	return [`layout='${config.layout}'`, ...assignments].join(" ");
+	const assignments = keyItems(config).filter((item) => Object.hasOwn(config.values, item)).map((item) => `${item}=${config.values[item]}`);
+	return [...config.layout === null ? [] : [`layout='${config.layout}'`], ...assignments].join(" ");
+}
+function panelDetail(config) {
+	return [...config.theme === void 0 ? [] : [`theme=${config.theme}`], ...Object.entries(config.values).map(([item, alt]) => `${item}=${alt}`)].join(" ");
+}
+function themeRow(config) {
+	if (config.theme === void 0) return [];
+	const swaps = Object.entries(config.values).map(([item, alt]) => `+${item}=${alt}`);
+	return [`theme: ${[config.theme, ...swaps].join(" ")}`];
 }
 function findingText(finding) {
 	return finding.kind === "unknown-item" ? `unknown item '${finding.item}'` : `unknown variant '${finding.alt}' for '${finding.item}'`;
 }
-function driftFindings(config, runtime) {
-	if (config.layout === null) return [];
-	const byItem = new Map(runtime.items.map((entry) => [entry.item, entry]));
+function driftFindings(config) {
 	const findings = [];
-	for (const item of layoutItemsOf(config.layout)) {
-		const entry = byItem.get(item);
+	for (const item of keyItems(config)) {
+		const entry = specFor(item);
 		if (entry === void 0) {
 			findings.push({
 				item,
@@ -1183,9 +2309,32 @@ function driftFindings(config, runtime) {
 	}
 	return findings;
 }
-function runtimeRow(runtime) {
-	if (runtime === null) return `runtime: missing — fix: ${INSTALL_FIX}`;
-	return `runtime: ${basename(dirname(runtime.dir))} — ${runtime.items.length} items`;
+function nodeOnPath(pathVar) {
+	return pathVar.split(delimiter).filter((dir) => dir !== "").map((dir) => join(dir, "node")).find(existsSync) ?? null;
+}
+function rendererHash(bytes) {
+	return createHash("sha256").update(bytes).digest("hex").slice(0, 12);
+}
+function rendererState(home) {
+	if (!existsSync(BUNDLED_RENDERER)) return { kind: "no-bundle" };
+	const cli = readFileSync(BUNDLED_RENDERER);
+	const dataFile = renderMjsPath(home);
+	if (!existsSync(dataFile)) return { kind: "missing" };
+	const hash = rendererHash(readFileSync(dataFile));
+	return hash === rendererHash(cli) ? {
+		hash,
+		kind: "current"
+	} : {
+		cli: rendererHash(cli),
+		data: hash,
+		kind: "stale"
+	};
+}
+function rendererRow(state) {
+	if (state.kind === "current") return `renderer: current — ${state.hash}`;
+	if (state.kind === "stale") return `renderer: stale — data ${state.data}, this CLI ${state.cli} — fix: rerun configure --force --theme classic`;
+	if (state.kind === "no-bundle") return "renderer: this CLI ships no render.mjs — fix: rerun /lab to refresh the CLI";
+	return "renderer: missing — fix: rerun configure --force --theme classic";
 }
 function configRow(findings) {
 	if (findings.length === 0) return "config: no drift";
@@ -1196,7 +2345,7 @@ function backupRow(home) {
 	try {
 		backup = readBackup(home);
 	} catch {
-		return `backup: unreadable — fix: delete ~/${DATA_REL}/backup.json`;
+		return `backup: unreadable — fix: delete ~/${DATA_DIR}/backup.json`;
 	}
 	if (backup === null) return "backup: absent";
 	const saved = SETTINGS_KEYS.filter((key) => backup.keys[key] !== void 0);
@@ -1225,30 +2374,25 @@ function settingsMembers(home) {
 	const raw = readOrNull(file);
 	return raw === null ? {} : parseSettings(file, raw);
 }
-function resolveOrNull(home) {
-	try {
-		return resolveRuntime({ home });
-	} catch {
-		return null;
-	}
-}
 function status(options) {
-	const runtime = resolveOrNull(options.home);
 	const members = settingsMembers(options.home);
 	const main = keyState("statusLine", members.statusLine);
 	const subagent = keyState("subagentStatusLine", members.subagentStatusLine);
 	const config = readKeyConfig(options.home);
-	const theme = runtime === null ? void 0 : liveTheme(config, runtime);
-	const findings = runtime === null || main.kind !== "ours" ? [] : driftFindings(config, runtime);
+	const panelConfig = parsePanelCommand(memberCommand(members.subagentStatusLine));
+	const findings = main.kind === "ours" ? driftFindings(config) : [];
+	const node = nodeOnPath(options.path ?? process.env.PATH ?? "");
+	const renderer = rendererState(options.home);
 	const rows = [
-		runtimeRow(runtime),
+		node === null ? "node: missing — fix: install node ≥ 18 from nodejs.org, then restart Claude Code" : `node: on PATH (${node})`,
+		rendererRow(renderer),
 		keyRow("statusLine", main, configDetail(config)),
-		keyRow("subagentStatusLine", subagent),
-		...runtime !== null && main.kind === "ours" ? [configRow(findings), ...theme === void 0 ? [] : [`theme: ${theme}`]] : [],
+		keyRow("subagentStatusLine", subagent, panelDetail(panelConfig)),
+		...main.kind === "ours" ? [configRow(findings), ...themeRow(config)] : [],
 		backupRow(options.home),
 		capturesRow(options.home)
 	];
-	const healthy = runtime !== null && main.kind === "ours" && subagent.kind === "ours" && findings.length === 0;
+	const healthy = node !== null && renderer.kind === "current" && main.kind === "ours" && subagent.kind === "ours" && findings.length === 0;
 	return {
 		healthy,
 		rows: [...rows, healthy ? "healthy" : "unhealthy"]
@@ -1326,58 +2470,67 @@ var WIDTHS = [
 ];
 var THEME_KEYMAP = "j/k focus · w width · enter pick · q cancel";
 var REFINE_KEYMAP = "j/k move · h/l variant · s none · t themes · w width · enter save · q cancel";
+var STYLE = "style";
 function opensWizard(args, isTty) {
 	return isTty && args.layout === void 0 && args.theme === void 0 && args.variants === void 0;
 }
 async function createWizard(options, deps) {
-	const runtime = resolveRuntime({ home: options.home });
-	const themes = themesFor(runtime);
-	const names = Object.keys(themes);
-	const byItem = new Map(runtime.items.map((item) => [item.item, item]));
+	const names = Object.keys(THEMES);
 	const sources = previewSources(options.home, Number(options.now));
 	const tickBase = JSON.parse(sources.tick);
 	let pass = "themes";
 	let themeAt = 0;
-	let draftLayout = "";
+	let picked = names[0];
+	let base = DEFAULT_PICKS;
 	let offered = [];
-	const draft = /* @__PURE__ */ new Map();
+	const overrides = /* @__PURE__ */ new Map();
 	let focus = 0;
 	let widthAt = 0;
-	function bag(layout, values) {
+	function bag(theme, layout, values = {}) {
 		return {
 			home: options.home,
-			layout,
+			...layout === void 0 ? {} : { layout },
 			main: sources.main,
 			now: options.now,
-			runtime,
 			tick: `${JSON.stringify({
 				...tickBase,
 				columns: WIDTHS[widthAt]
 			}, null, 2)}\n`,
+			theme,
 			values,
 			width: WIDTHS[widthAt]
 		};
 	}
 	function enterRefine(name) {
-		const theme = themes[name];
-		draftLayout = theme.layout;
-		offered = layoutItems(theme.layout, runtime.items.map((item) => item.item)).flatMap((item) => {
-			const entry = byItem.get(item);
+		picked = name;
+		base = {
+			...DEFAULT_PICKS,
+			...THEMES[name].variants
+		};
+		const items = layoutItems(THEMES[name].layout, ITEM_IDS);
+		offered = [.../* @__PURE__ */ new Set([...items, STYLE])].flatMap((item) => {
+			const entry = specFor(item);
 			return entry === void 0 ? [] : [{
 				alternatives: entry.alternatives,
 				item
 			}];
 		});
-		draft.clear();
-		for (const [item, alt] of Object.entries(theme.variants)) draft.set(item, alt);
+		overrides.clear();
 		focus = 0;
 	}
+	function effectivePick(item) {
+		return overrides.get(item) ?? base[item];
+	}
+	function setPick(item, alt) {
+		if (alt === base[item]) overrides.delete(item);
+		else overrides.set(item, alt);
+	}
 	function cycle(delta) {
 		const focused = offered.at(focus);
 		if (focused === void 0 || focused.alternatives.length === 0) return;
 		const alts = focused.alternatives;
-		const at = alts.indexOf(draft.get(focused.item) ?? "");
-		draft.set(focused.item, alts[(at + delta + alts.length) % alts.length]);
+		const at = alts.indexOf(effectivePick(focused.item));
+		setPick(focused.item, alts[(at + delta + alts.length) % alts.length]);
 	}
 	function step(key) {
 		const down = key === "\x1B[B" || key === "j";
@@ -1393,7 +2546,7 @@ async function createWizard(options, deps) {
 		else if (key === "\x1B[D" || key === "h") cycle(-1);
 		else if (key === "s") {
 			const focused = offered.at(focus);
-			if (focused?.alternatives.includes("none")) draft.set(focused.item, "none");
+			if (focused?.alternatives.includes("none")) setPick(focused.item, "none");
 		}
 		return pass;
 	}
@@ -1402,8 +2555,8 @@ async function createWizard(options, deps) {
 		let panel = "";
 		for (let at = 0; at < names.length; at += 1) {
 			const name = names[at];
-			const theme = themes[name];
-			const surfaces = deps.preview(bag(theme.layout, theme.variants));
+			const theme = THEMES[name];
+			const surfaces = deps.preview(bag(name));
 			const focused = at === themeAt;
 			if (focused) panel = surfaces.panel;
 			rows.push(`${focused ? ">" : " "} ${name}: ${theme.summary}`);
@@ -1422,13 +2575,16 @@ async function createWizard(options, deps) {
 	function drawRefine() {
 		const focused = offered.at(focus);
 		if (focused === void 0) return;
-		const values = Object.fromEntries(draft);
-		const samples = focused.alternatives.map((alt) => deps.preview(bag(`{${focused.item}}`, {
-			...values,
-			[focused.item]: alt
-		})).line);
-		const full = deps.preview(bag(draftLayout, values));
-		const rows = offered.map((entry, at) => `${at === focus ? ">" : " "} ${entry.item.padEnd(9)} ${draft.get(entry.item)}`);
+		const values = Object.fromEntries(overrides);
+		const samples = focused.alternatives.map((alt) => {
+			const surfaces = deps.preview(bag(picked, focused.item === STYLE ? void 0 : `{${focused.item}}`, {
+				...values,
+				[focused.item]: alt
+			}));
+			return focused.item === STYLE ? surfaces.panel : surfaces.line;
+		});
+		const full = deps.preview(bag(picked, void 0, values));
+		const rows = offered.map((entry, at) => `${at === focus ? ">" : " "} ${entry.item.padEnd(9)} ${effectivePick(entry.item)}`);
 		deps.render([
 			`statusline configure · ${WIDTHS[widthAt]} columns (w cycles)`,
 			"",
@@ -1436,7 +2592,7 @@ async function createWizard(options, deps) {
 			`  panel ${full.panel}`,
 			"",
 			`${focused.item}: ${focused.alternatives.join(" | ")}`,
-			...focused.alternatives.map((alt, at) => `  ${alt === draft.get(focused.item) ? "*" : " "} ${samples[at]}`),
+			...focused.alternatives.map((alt, at) => `  ${alt === effectivePick(focused.item) ? "*" : " "} ${samples[at]}`),
 			"",
 			...rows,
 			"",
@@ -1452,8 +2608,8 @@ async function createWizard(options, deps) {
 			configure({
 				force: options.force,
 				home: options.home,
-				layout: draftLayout,
-				variants: Object.fromEntries(draft)
+				theme: picked,
+				variants: Object.fromEntries(overrides)
 			});
 		} catch (e) {
 			deps.render(`save failed: ${e.message}\nfix it and rerun: npx -y @v1nvn/statusline@${VERSION} configure\n`);