@v1nvn/statusline 0.22.0

package/dist/index.js

@@ -0,0 +1,1346 @@
+#!/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, Option } from "commander";
+import { execFileSync, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+//#region ../core/dist/index.js
+function printUsageAndExit(program) {
+	console.error(program.helpInformation());
+	process.exit(1);
+}
+//#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`);
+}
+function backupPath(home) {
+	return join(home, DATA_REL, "backup.json");
+}
+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}`;
+}
+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}`);
+}
+function mainKeyMiddle(command) {
+	if (!isOurMainCommand(command)) return null;
+	return command.slice(MAIN_PREFIX.length, command.length - 52 - 1);
+}
+function settingsCommand(home) {
+	let raw;
+	try {
+		raw = readFileSync(join(home, ".claude", "settings.json"), "utf8");
+	} catch {
+		return null;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	const member = parsed?.statusLine;
+	if (typeof member !== "object" || member === null) return null;
+	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: {}
+	};
+	const values = {};
+	for (const [, name, alt] of middle.matchAll(/(?:^| )STATUSLINE_LAB_([A-Z][A-Z0-9_]*)=([a-z0-9]+)/g)) values[name.toLowerCase()] = alt;
+	return {
+		layout: layout[1],
+		values
+	};
+}
+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 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 {
+		defaultLayout: readDefaultLayout(dir),
+		dir,
+		items: readItems(dir)
+	};
+}
+//#endregion
+//#region src/catalog.ts
+function catalog(options) {
+	const runtime = resolveRuntime({ home: options.home });
+	const live = readKeyConfig(options.home).values;
+	const byItem = new Map(runtime.items.map((item) => [item.item, item]));
+	return (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 = live[item] ?? entry.default;
+		return `${item}: ${entry.alternatives.map((alt) => alt === current ? `${alt}*` : alt).join(" | ")}`;
+	}).join("\n");
+}
+//#endregion
+//#region src/cli.ts
+var VERSION = {
+	name: "@v1nvn/statusline",
+	version: "0.22.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 && chmod +x dist/index.js",
+		"test": "vitest run",
+		"test:watch": "vitest"
+	},
+	keywords: [
+		"claude-code",
+		"statusline",
+		"cli"
+	],
+	author: "v1nvn",
+	license: "MIT",
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/v1nvn/agentic.git",
+		"directory": "packages/statusline"
+	},
+	files: ["dist", "assets"],
+	publishConfig: { "access": "public" },
+	engines: { "node": ">=22" },
+	dependencies: {
+		"@v1nvn/agentic-core": "workspace:^",
+		"commander": "^15.0.0"
+	},
+	devDependencies: {
+		"vite": "^8.1.4",
+		"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
+};
+var HelpRequested = class extends Error {
+	command;
+	constructor(command) {
+		super(`${command} --help`);
+		this.command = command;
+	}
+};
+function quiet(name, command) {
+	return command.exitOverride((err) => {
+		const code = err.code;
+		if (code === "commander.help" || code === "commander.helpDisplayed") throw new HelpRequested(name);
+		throw err;
+	}).configureOutput(QUIET).allowExcessArguments(false);
+}
+function buildProgram(onSubcommand) {
+	const catalog = quiet("catalog", new Command("catalog")).description("print one line per item — * marks the live variant").option("--home <dir>", "operate on this home instead of $HOME");
+	for (const item of ITEM_IDS) catalog.option(`--${item}`, `cut the listing to the ${item} item`);
+	catalog.action((options) => onSubcommand?.("catalog", options));
+	const configure = quiet("configure", new Command("configure")).description("write both settings keys with the inline lab commands").option("--home <dir>", "operate on this home instead of $HOME").option("--layout <spec>", "brace clusters of item ids, e.g. '{cwd branch} {model effort}'").addOption(new Option("--fallback <mode>", "fill unflagged layout items from defaults or the existing config").choices(["default", "existing"])).option("--dry-run", "render both surfaces, write nothing").option("--force", "take over foreign settings keys");
+	for (const item of ITEM_IDS) configure.option(`--${item} <alt>`, `variant for the ${item} item`);
+	configure.action((options) => onSubcommand?.("configure", options));
+	const restore = quiet("restore", new Command("restore")).description("revert both settings keys to their pre-lab values, clean the data dir").option("--home <dir>", "operate on this home instead of $HOME").option("--dry-run", "print the plan, write nothing").option("--force", "splice the saved value over a key changed after the takeover");
+	restore.action((options) => onSubcommand?.("restore", options));
+	const status = quiet("status", new Command("status")).description("check install, keys, config, and backup — exit 0 healthy, 1 when a row needs action").option("--home <dir>", "operate on this home instead of $HOME");
+	status.action((options) => onSubcommand?.("status", options));
+	return new Command().name("statusline").description("Configure the status line and agent panel designs").option("-V, --version", "print the lab version and exit").action(() => void 0).addCommand(catalog).addCommand(configure).addCommand(restore).addCommand(status);
+}
+function subcommandHelp(name) {
+	const command = buildProgram().commands.find((c) => c.name() === name);
+	if (command === void 0) throw new Error(`no '${name}' command to describe`);
+	return command.helpInformation();
+}
+function parseArgs(args) {
+	let chosen;
+	const program = buildProgram((command, options) => {
+		chosen = {
+			command,
+			options
+		};
+	});
+	try {
+		program.allowExcessArguments(false).exitOverride().configureOutput(QUIET).parse([...args], { from: "user" });
+	} catch (e) {
+		if (e instanceof HelpRequested) return {
+			version: false,
+			help: e.command
+		};
+		return;
+	}
+	const { version } = program.opts();
+	if (version) return { version: true };
+	if (chosen === void 0) return;
+	const options = chosen.options;
+	if (chosen.command === "catalog") {
+		const items = ITEM_IDS.filter((item) => options[item] === true);
+		return {
+			version: false,
+			command: "catalog",
+			...items.length > 0 ? { items } : {},
+			...typeof options.home === "string" ? { home: options.home } : {}
+		};
+	}
+	if (chosen.command === "restore") return {
+		version: false,
+		command: "restore",
+		...typeof options.dryRun === "boolean" ? { dryRun: options.dryRun } : {},
+		...typeof options.force === "boolean" ? { force: options.force } : {},
+		...typeof options.home === "string" ? { home: options.home } : {}
+	};
+	if (chosen.command === "status") return {
+		version: false,
+		command: "status",
+		...typeof options.home === "string" ? { home: options.home } : {}
+	};
+	const variants = {};
+	for (const item of ITEM_IDS) if (typeof options[item] === "string") variants[item] = options[item];
+	return {
+		version: false,
+		command: "configure",
+		...Object.keys(variants).length > 0 ? { variants } : {},
+		...typeof options.dryRun === "boolean" ? { dryRun: options.dryRun } : {},
+		...typeof options.fallback === "string" ? { fallback: options.fallback } : {},
+		...typeof options.force === "boolean" ? { force: options.force } : {},
+		...typeof options.home === "string" ? { home: options.home } : {},
+		...typeof options.layout === "string" ? { layout: options.layout } : {}
+	};
+}
+//#endregion
+//#region src/demo-repo.ts
+var NAME = "Lab";
+var EMAIL = "lab@local";
+var D_INIT = "2026-09-01T10:00:00+00:00";
+var D_REMOTE = "2026-09-01T11:00:00+00:00";
+var D_LOCAL1 = "2026-09-02T09:00:00+00:00";
+var D_LOCAL2 = "2026-09-02T09:30:00+00:00";
+var D_STASH = "2026-09-02T10:00:00+00:00";
+var API_INIT = "export const api = {\n  host: 'demo.local',\n};\n";
+function materializeDemoRepo(home) {
+	const dir = join(home, "demo", "atlas-web");
+	for (const sub of [
+		"src",
+		"docs",
+		"scratch",
+		"scripts"
+	]) mkdirSync(join(dir, sub), { recursive: true });
+	function git(args, date) {
+		return execFileSync("git", [
+			"-c",
+			"commit.gpgsign=false",
+			...args
+		], {
+			cwd: dir,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				PATH: process.env.PATH ?? "",
+				HOME: home,
+				LC_ALL: "C",
+				TZ: "UTC",
+				GIT_AUTHOR_NAME: NAME,
+				GIT_AUTHOR_EMAIL: EMAIL,
+				GIT_COMMITTER_NAME: NAME,
+				GIT_COMMITTER_EMAIL: EMAIL,
+				...date ? {
+					GIT_AUTHOR_DATE: date,
+					GIT_COMMITTER_DATE: date
+				} : {}
+			}
+		});
+	}
+	function write(rel, body) {
+		writeFileSync(join(dir, rel), body);
+	}
+	function commit(message, date) {
+		git(["add", "-A"]);
+		git([
+			"commit",
+			"-m",
+			message
+		], date);
+	}
+	git([
+		"init",
+		"-b",
+		"main"
+	]);
+	git([
+		"config",
+		"user.name",
+		NAME
+	]);
+	git([
+		"config",
+		"user.email",
+		EMAIL
+	]);
+	write("README.md", "atlas-web demo repo\n");
+	write("src/index.js", "export function start() {}\n");
+	write("src/api.js", API_INIT);
+	write("src/style.css", "body { margin: 0; }\n");
+	write("src/util.js", "export const id = (x) => x;\n");
+	commit("init", D_INIT);
+	write("src/api.js", `${API_INIT}// remote: pinned host\n`);
+	commit("remote1", D_REMOTE);
+	const originMain = git(["rev-parse", "HEAD"]).trim();
+	git([
+		"checkout",
+		"-b",
+		"feature/login-flow",
+		"HEAD~1"
+	]);
+	write("src/util.js", "export const id = (x) => x;\nexport const tag = (x) => x;\n");
+	commit("local1", D_LOCAL1);
+	write("src/render.js", "export function render() {}\n");
+	commit("local2", D_LOCAL2);
+	git([
+		"update-ref",
+		"refs/remotes/origin/main",
+		originMain
+	]);
+	git([
+		"config",
+		"remote.origin.url",
+		"../atlas-web.git"
+	]);
+	git([
+		"config",
+		"remote.origin.fetch",
+		"+refs/heads/*:refs/remotes/origin/*"
+	]);
+	git([
+		"config",
+		"branch.feature/login-flow.remote",
+		"origin"
+	]);
+	git([
+		"config",
+		"branch.feature/login-flow.merge",
+		"refs/heads/main"
+	]);
+	write("README.md", "atlas-web demo repo (wip)\n");
+	git([
+		"stash",
+		"push",
+		"-m",
+		"wip: context refactor",
+		"--",
+		"README.md"
+	], D_STASH);
+	write("README.md", "atlas-web demo repo\n\nstaged: pin the render loop\n");
+	write("src/index.js", "export function start() {\n  return Promise.resolve();\n}\n");
+	git([
+		"add",
+		"README.md",
+		"src/index.js"
+	]);
+	write("src/api.js", `${API_INIT}// local tweak\n`);
+	write("src/style.css", "body { margin: 0; padding: 0; }\n");
+	write("docs/wip.txt", "");
+	write("scratch/todo.md", "");
+	write("scripts/deploy.sh", "");
+	write("note1.md", "");
+	write("note2.md", "");
+	return dir;
+}
+//#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));
+var P1_WARM_IN = 1920;
+var P1_RESETS_IN = {
+	five_hour: 13830,
+	seven_day: 518400,
+	spend_limit: 950400
+};
+var PANEL_STEP_S = 300;
+function isObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function anchoredP1(repoDir, now) {
+	const payload = JSON.parse(readFileSync(join(PAYLOADS_DIR, "p1.json"), "utf8"));
+	const cache = payload.prompt_cache;
+	if (isObject$1(cache)) {
+		if (cache.warm === true) {
+			cache.expires_at = now + P1_WARM_IN;
+			cache.last_miss_at = now + P1_WARM_IN - 3900;
+		} else {
+			cache.expires_at = now - 10;
+			delete cache.last_miss_at;
+		}
+	}
+	const limits = payload.rate_limits;
+	if (isObject$1(limits)) for (const [limitKey, offset] of Object.entries(P1_RESETS_IN)) {
+		const limit = limits[limitKey];
+		if (isObject$1(limit)) limit.resets_at = now + offset;
+	}
+	payload.workspace.current_dir = repoDir;
+	return `${JSON.stringify(payload, null, 2)}\n`;
+}
+function hasStart(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function anchoredTick(now) {
+	const tick = JSON.parse(readFileSync(join(TICKS_DIR, "multi.json"), "utf8"));
+	const tasks = Array.isArray(tick.tasks) ? tick.tasks : [];
+	let started = 0;
+	const staggered = {
+		...tick,
+		tasks: tasks.map((task) => {
+			if (!hasStart(task.startTime)) return task;
+			started += 1;
+			return {
+				...task,
+				startTime: now - PANEL_STEP_S * started
+			};
+		})
+	};
+	return `${JSON.stringify(staggered, null, 2)}\n`;
+}
+function previewSources(home, now) {
+	const mainCapture = capturePath(home, "main");
+	if (existsSync(mainCapture)) {
+		const tickCapture = capturePath(home, "tick");
+		return {
+			cleanup: () => void 0,
+			main: readFileSync(mainCapture, "utf8"),
+			tick: existsSync(tickCapture) ? readFileSync(tickCapture, "utf8") : anchoredTick(now)
+		};
+	}
+	const demoHome = mkdtempSync(join(tmpdir(), "statusline-preview-"));
+	return {
+		cleanup: () => {
+			rmSync(demoHome, {
+				recursive: true,
+				force: true
+			});
+		},
+		main: anchoredP1(materializeDemoRepo(demoHome), now),
+		tick: anchoredTick(now)
+	};
+}
+function firstPanelRow(output) {
+	const [row] = output.split("\n");
+	if (row === "") return "";
+	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`;
+}
+//#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;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readOrNull(file) {
+	try {
+		return readFileSync(file, "utf8");
+	} catch (e) {
+		if (e.code === "ENOENT") return null;
+		throw e;
+	}
+}
+function parseSettings(file, raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (e) {
+		throw new Error(`${file} is not valid JSON`, { cause: e });
+	}
+	if (!isObject(parsed)) throw new Error(`${file} does not hold a settings object`);
+	return parsed;
+}
+function memberCommand(value) {
+	if (!isObject(value) || value.type !== "command") return null;
+	return typeof value.command === "string" ? value.command : null;
+}
+function isOurMember(key, value) {
+	const command = memberCommand(value);
+	if (command === null) return false;
+	return key === "statusLine" ? isOurMainCommand(command) : command === subagentKeyValue;
+}
+function planSettings(home, mainCommand, force) {
+	const file = join(home, ".claude", "settings.json");
+	const wanted = {
+		statusLine: mainCommand,
+		subagentStatusLine: subagentKeyValue
+	};
+	const raw = readOrNull(file);
+	if (raw === null) return {
+		adds: SETTINGS_KEYS.map((key) => [key, wanted[key]]),
+		file,
+		raw: null,
+		repoints: []
+	};
+	const parsed = parseSettings(file, raw);
+	const adds = [];
+	const repoints = [];
+	for (const key of SETTINGS_KEYS) {
+		const command = wanted[key];
+		const value = parsed[key];
+		if (value === void 0) adds.push([key, command]);
+		else if (memberCommand(value) === command) continue;
+		else if (isOurMember(key, value) || force) repoints.push([key, command]);
+		else throw new Error(`settings.json ${key} is foreign — rerun with --force added to your configuration flags to take it over`);
+	}
+	return {
+		adds,
+		file,
+		raw,
+		repoints
+	};
+}
+function settingsValue(command) {
+	return JSON.stringify({
+		command,
+		type: "command"
+	});
+}
+function skipString(raw, at) {
+	let i = at + 1;
+	while (i < raw.length) if (raw[i] === "\\") i += 2;
+	else if (raw[i] === "\"") return i + 1;
+	else i += 1;
+	throw new Error("unterminated string in settings.json");
+}
+function skipValue(raw, at) {
+	const first = raw[at];
+	if (first === "\"") return skipString(raw, at);
+	if (first === "{" || first === "[") {
+		let depth = 0;
+		let i = at;
+		while (i < raw.length) {
+			const c = raw[i];
+			if (c === "\"") i = skipString(raw, i);
+			else if (c === "{" || c === "[") {
+				depth += 1;
+				i += 1;
+			} else if (c === "}" || c === "]") {
+				depth -= 1;
+				i += 1;
+				if (depth === 0) return i;
+			} else i += 1;
+		}
+		throw new Error("unterminated container in settings.json");
+	}
+	let i = at;
+	while (i < raw.length && !",}]".includes(raw[i] ?? "") && !/\s/.test(raw[i] ?? "~")) i += 1;
+	return i;
+}
+function rootMembers(raw) {
+	const members = [];
+	let i = raw.indexOf("{") + 1;
+	while (i < raw.length) {
+		while (/\s/.test(raw[i] ?? "~")) i += 1;
+		if (raw[i] === "}") break;
+		if (raw[i] !== "\"") throw new Error("malformed member in settings.json");
+		const nameStart = i;
+		const nameEnd = skipString(raw, i);
+		const name = JSON.parse(raw.slice(i, nameEnd));
+		i = nameEnd;
+		while (/\s/.test(raw[i] ?? "~")) i += 1;
+		if (raw[i] !== ":") throw new Error("malformed member in settings.json");
+		i += 1;
+		while (/\s/.test(raw[i] ?? "~")) i += 1;
+		const valueStart = i;
+		const valueEnd = skipValue(raw, i);
+		members.push({
+			name,
+			nameStart,
+			valueEnd,
+			valueStart
+		});
+		i = valueEnd;
+		while (/\s/.test(raw[i] ?? "~")) i += 1;
+		if (raw[i] === ",") i += 1;
+		else if (raw[i] !== "}") throw new Error("malformed member in settings.json");
+	}
+	return members;
+}
+function rootMemberValueSpan(raw, key) {
+	const member = rootMembers(raw).find((m) => m.name === key);
+	return member === void 0 ? null : [member.valueStart, member.valueEnd];
+}
+function removeMembers(raw, keys) {
+	let text = raw;
+	for (const key of keys) {
+		const members = rootMembers(text);
+		const at = members.findIndex((m) => m.name === key);
+		if (at === -1) throw new Error(`cannot find the "${key}" member to remove in settings.json`);
+		if (members.length === 1) return "{}";
+		const member = members[at];
+		if (at > 0) {
+			let start = member.nameStart;
+			while (/\s/.test(text[start - 1] ?? "~")) start -= 1;
+			text = `${text.slice(0, start - 1)}${text.slice(member.valueEnd)}`;
+		} else text = `${text.slice(0, member.nameStart)}${text.slice(members[1].nameStart)}`;
+	}
+	return text;
+}
+function insertMembers(raw, members) {
+	const close = raw.lastIndexOf("}");
+	if (close === -1) throw new Error("settings.json has no closing brace to splice into");
+	let at = close;
+	while (/\s/.test(raw[at - 1] ?? "~")) at -= 1;
+	const rendered = members.map(([key, command]) => `"${key}": ${settingsValue(command)}`).join(",\n  ");
+	const comma = raw.replace(/\s/g, "") === "{}" ? "" : ",";
+	return `${raw.slice(0, at)}${comma}\n  ${rendered}${raw.slice(at)}`;
+}
+function splicedSettings(raw, plan) {
+	let text = plan.adds.length > 0 ? insertMembers(raw, plan.adds) : raw;
+	for (const [key, command] of plan.repoints) {
+		const span = rootMemberValueSpan(text, key);
+		if (span === null) throw new Error(`cannot find the "${key}" member to repoint in settings.json`);
+		text = `${text.slice(0, span[0])}${settingsValue(command)}${text.slice(span[1])}`;
+	}
+	return text;
+}
+function writeBackupIfAbsent(home, plan) {
+	const file = backupPath(home);
+	if (existsSync(file)) return;
+	const keys = {};
+	if (plan.raw !== null) for (const key of SETTINGS_KEYS) {
+		const span = rootMemberValueSpan(plan.raw, key);
+		if (span === null) continue;
+		const memberRaw = plan.raw.slice(span[0], span[1]);
+		if (isOurMember(key, JSON.parse(memberRaw))) continue;
+		keys[key] = memberRaw;
+	}
+	const dir = dirname(file);
+	mkdirSync(dir, { recursive: true });
+	const tmp = `${file}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify({
+		createdFile: plan.raw === null,
+		keys
+	}, null, 2)}\n`);
+	renameSync(tmp, file);
+}
+function commitSettings(plan) {
+	if (plan.raw === null) {
+		mkdirSync(dirname(plan.file), { recursive: true });
+		const members = plan.adds.map(([key, command]) => `"${key}": ${settingsValue(command)}`).join(",\n  ");
+		writeFileSync(plan.file, `{\n  ${members}\n}\n`);
+		return;
+	}
+	if (plan.adds.length === 0 && plan.repoints.length === 0) return;
+	writeFileSync(plan.file, splicedSettings(plan.raw, plan));
+}
+function renderPreview(runtime, home, values, layout, now) {
+	const sources = previewSources(home, Number(now));
+	try {
+		const variantEnv = Object.fromEntries(Object.entries(values).map(([item, alt]) => [`STATUSLINE_LAB_${item.toUpperCase()}`, alt]));
+		return `dry-run at 200 columns — nothing written\n${runtimeRenderer({
+			bin: join(runtime.dir, "statusline.sh"),
+			env: {
+				COLUMNS: "200",
+				HOME: home,
+				NOW: now,
+				STATUSLINE_LAB_LAYOUT: layout,
+				...variantEnv
+			},
+			stdin: sources.main
+		}).replace(/\n+$/, "")}\npanel ${firstPanelRow(runtimeRenderer({
+			bin: join(runtime.dir, "subagent.sh"),
+			env: {
+				COLUMNS: "200",
+				HOME: home,
+				NOW: now
+			},
+			stdin: sources.tick
+		}).replace(/\n+$/, ""))}\n`;
+	} finally {
+		sources.cleanup();
+	}
+}
+function printedConfig(runtime, home) {
+	const existing = readKeyConfig(home);
+	return [...[`layout='${existing.layout ?? runtime.defaultLayout}'`, ...runtime.items.map((item) => `${item.item}=${item.item in existing.values ? existing.values[item.item] : item.default}`)], "nothing written — pass variants (`statusline configure --model block`) or run bare on a TTY for the wizard"].join("\n");
+}
+function existingValue(values, item) {
+	return item in values ? values[item] : void 0;
+}
+function configure(options) {
+	const runtime = resolveRuntime({ home: options.home });
+	const existing = readKeyConfig(options.home);
+	const variants = options.variants ?? {};
+	const explicit = options.layout !== void 0 || Object.keys(variants).length > 0;
+	if (!explicit && options.fallback === void 0 && !options.dryRun) return {
+		mode: "printed",
+		text: printedConfig(runtime, options.home)
+	};
+	const layout = options.layout === void 0 || options.layout === "" ? existing.layout ?? runtime.defaultLayout : options.layout;
+	const byItem = new Map(runtime.items.map((item) => [item.item, item]));
+	const items = layoutItems(layout, runtime.items.map((item) => item.item));
+	for (const item of Object.keys(variants)) {
+		if (!byItem.has(item)) throw new Error(`unknown item '${item}' — valid items: ${[...byItem.keys()].join(" ")}`);
+		if (!items.includes(item)) throw new Error(`variant for '${item}' is not in the layout (layout items: ${items.join(" ")})`);
+	}
+	const values = {};
+	for (const item of items) {
+		let base;
+		if (options.fallback === "default") base = byItem.get(item)?.default;
+		else if (options.fallback === "existing") base = existingValue(existing.values, item);
+		else if (!explicit) base = existingValue(existing.values, item) ?? byItem.get(item)?.default;
+		if (base !== void 0) values[item] = base;
+	}
+	const missing = items.filter((item) => !(item in values) && !(item in variants));
+	if (missing.length > 0) throw new Error(`no variant for layout item${missing.length > 1 ? "s" : ""} ${missing.join(" ")} — pass --<item> <alt> for each or use --fallback=default|existing`);
+	for (const [item, alt] of Object.entries(variants)) values[item] = alt;
+	for (const item of items) {
+		const alt = values[item];
+		const offered = byItem.get(item)?.alternatives ?? [];
+		if (!offered.includes(alt)) throw new Error(`unknown variant '${alt}' for item '${item}' — valid: ${offered.join(" | ")}`);
+	}
+	if (options.dryRun) {
+		const now = String(Math.floor(Date.now() / 1e3));
+		return {
+			mode: "dry-run",
+			text: renderPreview(runtime, options.home, values, layout, now)
+		};
+	}
+	const assignments = items.map((item) => `STATUSLINE_LAB_${item.toUpperCase()}=${values[item]}`);
+	const plan = planSettings(options.home, mainKeyValue(layout, assignments), options.force ?? false);
+	if (plan.adds.length > 0 || plan.repoints.length > 0) writeBackupIfAbsent(options.home, plan);
+	commitSettings(plan);
+	return { mode: "written" };
+}
+//#endregion
+//#region src/restore.ts
+function readBackup(home) {
+	const file = backupPath(home);
+	const raw = readOrNull(file);
+	if (raw === null) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (e) {
+		throw new Error(`${file} is not valid JSON`, { cause: e });
+	}
+	if (!isObject(parsed) || typeof parsed.createdFile !== "boolean" || !isObject(parsed.keys)) throw new Error(`${file} is not a lab backup`);
+	const keys = {};
+	for (const key of SETTINGS_KEYS) {
+		const saved = parsed.keys[key];
+		if (typeof saved === "string") keys[key] = saved;
+	}
+	return {
+		createdFile: parsed.createdFile,
+		keys
+	};
+}
+function rmdirIfEmpty(dir) {
+	try {
+		rmdirSync(dir);
+	} catch (e) {
+		const code = e.code;
+		if (code !== "ENOTEMPTY" && code !== "ENOENT" && code !== "ENOTDIR") throw e;
+	}
+}
+function clearCaptures(dir) {
+	if (!existsSync(dir)) return;
+	for (const entry of readdirSync(dir, { withFileTypes: true })) if (entry.isFile()) rmSync(join(dir, entry.name), { force: true });
+	rmdirIfEmpty(dir);
+}
+function planActions(raw, backup, force) {
+	const actions = [];
+	for (const key of SETTINGS_KEYS) {
+		const span = rootMemberValueSpan(raw, key);
+		if (span === null) continue;
+		const memberRaw = raw.slice(span[0], span[1]);
+		const saved = backup === null ? void 0 : backup.keys[key];
+		if (isOurMember(key, JSON.parse(memberRaw))) actions.push(saved === void 0 ? {
+			kind: "remove",
+			key
+		} : {
+			kind: "splice",
+			key,
+			text: saved
+		});
+		else if (saved !== void 0 && memberRaw !== saved) {
+			if (!force) throw new Error(`settings.json ${key} changed since the lab took it over — rerun with --force to put the saved value back`);
+			actions.push({
+				kind: "splice",
+				key,
+				text: saved
+			});
+		}
+	}
+	return actions;
+}
+function restore(options) {
+	const settings = join(options.home, ".claude", "settings.json");
+	const backup = readBackup(options.home);
+	const raw = readOrNull(settings);
+	const actions = raw === null ? [] : planActions(raw, backup, options.force ?? false);
+	const removals = [];
+	const splices = [];
+	for (const action of actions) if (action.kind === "remove") removals.push(action.key);
+	else splices.push(action);
+	let next = raw;
+	let deleteFile = false;
+	if (actions.length > 0 && raw !== null) {
+		let text = removals.length > 0 ? removeMembers(raw, removals) : raw;
+		for (const splice of splices) {
+			const span = rootMemberValueSpan(text, splice.key);
+			if (span === null) throw new Error(`cannot find the "${splice.key}" member to restore in settings.json`);
+			text = `${text.slice(0, span[0])}${splice.text}${text.slice(span[1])}`;
+		}
+		const membersLeft = Object.keys(JSON.parse(text)).length;
+		if (backup !== null && backup.createdFile && membersLeft === 0) {
+			deleteFile = true;
+			next = null;
+		} else next = text;
+	}
+	const dataDir = join(options.home, DATA_REL);
+	const capturesDir = join(dataDir, "captures");
+	const backupFile = backupPath(options.home);
+	if (actions.length === 0 && !existsSync(backupFile) && !existsSync(capturesDir)) return {
+		mode: "nothing",
+		text: "nothing to restore — no lab keys in settings.json, no backup, no captures"
+	};
+	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(backupFile)) lines.push("  delete backup.json");
+		lines.push("  remove the data dir if empty");
+		return {
+			mode: "dry-run",
+			text: lines.join("\n")
+		};
+	}
+	if (deleteFile) rmSync(settings, { force: true });
+	else if (next !== null && actions.length > 0) writeFileSync(settings, next);
+	clearCaptures(capturesDir);
+	rmSync(backupFile, { force: true });
+	rmdirIfEmpty(dataDir);
+	let line;
+	if (deleteFile) line = "restored — settings.json is gone, exactly as before the lab";
+	else if (actions.length > 0) line = "keys restored — settings.json holds its pre-lab values again";
+	else line = "lab data cleaned — no lab keys in settings.json";
+	return {
+		mode: "restored",
+		text: line
+	};
+}
+//#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" };
+	return {
+		kind: "foreign",
+		command: memberCommand(value)
+	};
+}
+function keyRow(key, state, detail = "") {
+	if (state.kind === "ours") return `${key}: ours${detail === "" ? "" : ` — ${detail}`}`;
+	if (state.kind === "absent") return `${key}: absent — fix: rerun configure --fallback=default`;
+	return `${key}: foreign${state.command === null ? "" : ` (${state.command})`} — fix: rerun configure --force --fallback=default`;
+}
+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 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(" ");
+}
+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]));
+	const findings = [];
+	for (const item of layoutItemsOf(config.layout)) {
+		const entry = byItem.get(item);
+		if (entry === void 0) {
+			findings.push({
+				item,
+				kind: "unknown-item"
+			});
+			continue;
+		}
+		const alt = Object.hasOwn(config.values, item) ? config.values[item] : null;
+		if (alt !== null && !entry.alternatives.includes(alt)) findings.push({
+			alt,
+			item,
+			kind: "unknown-variant"
+		});
+	}
+	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 configRow(findings, runtime) {
+	if (findings.length === 0) return "config: no drift";
+	const fix = findings.some((finding) => finding.kind === "unknown-item") ? `rerun configure --layout '${runtime.defaultLayout}' --fallback=default` : "rerun configure --fallback=default";
+	return `config: drift — ${findings.map(findingText).join(", ")} — fix: ${fix}`;
+}
+function backupRow(home) {
+	let backup;
+	try {
+		backup = readBackup(home);
+	} catch {
+		return `backup: unreadable — fix: delete ~/${DATA_REL}/backup.json`;
+	}
+	if (backup === null) return "backup: absent";
+	const saved = SETTINGS_KEYS.filter((key) => backup.keys[key] !== void 0);
+	return `backup: present — ${[...backup.createdFile ? ["created settings.json"] : [], saved.length > 0 ? `saved ${saved.join(", ")}` : "saved nothing"].join(", ")}`;
+}
+function ageText(ms) {
+	const minutes = Math.floor(ms / 6e4);
+	if (minutes < 1) return `${Math.floor(ms / 1e3)}s`;
+	if (minutes < 60) return `${minutes}m`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h`;
+	return `${Math.floor(hours / 24)}d`;
+}
+function captureText(home, surface) {
+	try {
+		return `${ageText(Date.now() - statSync(capturePath(home, surface)).mtimeMs)} ago`;
+	} catch {
+		return "absent";
+	}
+}
+function capturesRow(home) {
+	return `captures: ${["main", "tick"].map((surface) => `${surface} ${captureText(home, surface)}`).join(", ")}`;
+}
+function settingsMembers(home) {
+	const file = join(home, ".claude", "settings.json");
+	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 findings = runtime === null || main.kind !== "ours" ? [] : driftFindings(config, runtime);
+	const rows = [
+		runtimeRow(runtime),
+		keyRow("statusLine", main, configDetail(config)),
+		keyRow("subagentStatusLine", subagent),
+		...runtime !== null && main.kind === "ours" ? [configRow(findings, runtime)] : [],
+		backupRow(options.home),
+		capturesRow(options.home)
+	];
+	const healthy = runtime !== null && main.kind === "ours" && subagent.kind === "ours" && findings.length === 0;
+	return {
+		healthy,
+		rows: [...rows, healthy ? "healthy" : "unhealthy"]
+	};
+}
+//#endregion
+//#region src/wizard-tui.ts
+function nextKey(buffer) {
+	if (buffer === "") return;
+	const head = buffer[0];
+	if (head !== "\x1B") return [head, buffer.slice(1)];
+	if (buffer.length < 3) return;
+	if (buffer[1] === "[" && "ABCD".includes(buffer[2])) return [buffer.slice(0, 3), buffer.slice(3)];
+	return ["", buffer.slice(1)];
+}
+function terminalDeps(input = process.stdin, output = process.stdout) {
+	return {
+		async *readKeys() {
+			const chunks = [];
+			const waiters = [];
+			const state = { closed: false };
+			function notify() {
+				for (const wake of waiters.splice(0)) wake();
+			}
+			function onData(chunk) {
+				chunks.push(chunk.toString("utf8"));
+				notify();
+			}
+			function onEnd() {
+				state.closed = true;
+				notify();
+			}
+			input.on("data", onData);
+			input.on("end", onEnd);
+			input.on("close", onEnd);
+			if (input.isTTY) input.setRawMode(true);
+			input.resume();
+			try {
+				let buffer = "";
+				for (;;) {
+					for (let chunk = chunks.shift(); chunk !== void 0; chunk = chunks.shift()) buffer += chunk;
+					while (buffer !== "") {
+						const next = nextKey(buffer);
+						if (next === void 0) break;
+						buffer = next[1];
+						if (next[0] !== "") yield next[0];
+					}
+					if (state.closed && chunks.length === 0) return;
+					await new Promise((resolve) => {
+						waiters.push(resolve);
+					});
+				}
+			} finally {
+				if (input.isTTY) input.setRawMode(false);
+				input.pause();
+				input.off("data", onData);
+				input.off("end", onEnd);
+				input.off("close", onEnd);
+			}
+		},
+		render(frame) {
+			output.write(`\x1b[2J\x1b[H${frame}\n`);
+		},
+		preview(spec) {
+			return runtimeRenderer(spec);
+		}
+	};
+}
+//#endregion
+//#region src/wizard.ts
+var WIDTHS = [
+	80,
+	120,
+	200
+];
+var KEYMAP = "j/k move · h/l variant · s none · w width · enter save · q cancel";
+async function createWizard(options, deps) {
+	const runtime = resolveRuntime({ home: options.home });
+	const existing = readKeyConfig(options.home);
+	const layout = existing.layout ?? runtime.defaultLayout;
+	const byItem = new Map(runtime.items.map((item) => [item.item, item]));
+	const names = layoutItems(layout, runtime.items.map((item) => item.item));
+	const offered = [];
+	const draft = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		const entry = byItem.get(name);
+		if (entry === void 0) continue;
+		offered.push({
+			alternatives: entry.alternatives,
+			item: name
+		});
+		draft.set(name, name in existing.values && entry.alternatives.includes(existing.values[name]) ? existing.values[name] : entry.default);
+	}
+	const sources = previewSources(options.home, Number(options.now));
+	const mainBin = join(runtime.dir, "statusline.sh");
+	const panelBin = join(runtime.dir, "subagent.sh");
+	let focus = 0;
+	let widthAt = 0;
+	function variantEnv() {
+		return Object.fromEntries([...draft].map(([item, alt]) => [`STATUSLINE_LAB_${item.toUpperCase()}`, alt]));
+	}
+	function env() {
+		return {
+			COLUMNS: String(WIDTHS[widthAt]),
+			HOME: options.home,
+			NOW: options.now,
+			STATUSLINE_LAB_LAYOUT: layout,
+			...variantEnv()
+		};
+	}
+	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]);
+	}
+	function step(key) {
+		if (key === "\x1B[B" || key === "j") focus = (focus + 1) % offered.length;
+		else if (key === "\x1B[A" || key === "k") focus = (focus + offered.length - 1) % offered.length;
+		else if (key === "\x1B[C" || key === "l") cycle(1);
+		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");
+		} else if (key === "w") widthAt = (widthAt + 1) % WIDTHS.length;
+	}
+	function draw() {
+		const focused = offered.at(focus);
+		if (focused === void 0) return;
+		const samples = focused.alternatives.map((alt) => deps.preview({
+			bin: mainBin,
+			env: {
+				...env(),
+				STATUSLINE_LAB_LAYOUT: `{${focused.item}}`,
+				[`STATUSLINE_LAB_${focused.item.toUpperCase()}`]: alt
+			},
+			stdin: sources.main
+		}).replace(/\n+$/, ""));
+		const line = deps.preview({
+			bin: mainBin,
+			env: env(),
+			stdin: sources.main
+		}).replace(/\n+$/, "");
+		const tick = JSON.parse(sources.tick);
+		tick.columns = WIDTHS[widthAt];
+		const panel = deps.preview({
+			bin: panelBin,
+			env: {
+				COLUMNS: String(WIDTHS[widthAt]),
+				HOME: options.home,
+				NOW: options.now
+			},
+			stdin: `${JSON.stringify(tick, null, 2)}\n`
+		}).replace(/\n+$/, "");
+		const rows = offered.map((entry, at) => `${at === focus ? ">" : " "} ${entry.item.padEnd(9)} ${draft.get(entry.item)}`);
+		deps.render([
+			`statusline configure · ${WIDTHS[widthAt]} columns (w cycles)`,
+			"",
+			`  ${line}`,
+			`  panel ${firstPanelRow(panel)}`,
+			"",
+			`${focused.item}: ${focused.alternatives.join(" | ")}`,
+			...focused.alternatives.map((alt, at) => `  ${alt === draft.get(focused.item) ? "*" : " "} ${samples[at]}`),
+			"",
+			...rows,
+			"",
+			KEYMAP
+		].join("\n"));
+	}
+	function finish() {
+		try {
+			configure({
+				home: options.home,
+				layout,
+				variants: Object.fromEntries(draft)
+			});
+		} catch (e) {
+			deps.render(`save failed: ${e.message}\nfix it and rerun: npx -y @v1nvn/statusline configure\n`);
+			return "save-failed";
+		}
+		deps.render("saved — live on the next paint\n");
+		return "saved";
+	}
+	try {
+		const keys = deps.readKeys();
+		draw();
+		for await (const key of keys) {
+			if (key === "\r") return finish();
+			if (key === "q" || key === "") break;
+			step(key);
+			draw();
+		}
+		deps.render("cancelled — nothing written\n");
+		return "cancelled";
+	} finally {
+		sources.cleanup();
+	}
+}
+//#endregion
+//#region src/index.ts
+var parsed = parseArgs(process.argv.slice(2)) ?? printUsageAndExit(buildProgram());
+function homeOf(flag) {
+	const home = flag ?? process.env.HOME;
+	if (home === void 0 || home === "") throw new Error("no home to operate on: set $HOME or pass --home");
+	return home;
+}
+function run(job) {
+	try {
+		job();
+	} catch (e) {
+		console.error(e.message);
+		process.exitCode = 1;
+	}
+}
+if (parsed.help !== void 0) console.log(subcommandHelp(parsed.help));
+else if (parsed.version) console.log(VERSION);
+else if (parsed.command === "catalog") run(() => {
+	console.log(catalog({
+		home: homeOf(parsed.home),
+		items: parsed.items
+	}));
+});
+else if (parsed.command === "configure") {
+	const home = homeOf(parsed.home);
+	if (parsed.layout === void 0 && parsed.variants === void 0 && parsed.fallback === void 0 && !parsed.dryRun && !parsed.force && process.stdin.isTTY) {
+		if (await createWizard({
+			home,
+			now: String(Math.floor(Date.now() / 1e3))
+		}, terminalDeps()) === "save-failed") process.exitCode = 1;
+	} else run(() => {
+		const result = configure({
+			dryRun: parsed.dryRun,
+			fallback: parsed.fallback,
+			force: parsed.force,
+			home,
+			layout: parsed.layout,
+			variants: parsed.variants
+		});
+		console.log(result.mode === "written" ? "configured — live on the next paint" : result.text);
+	});
+} else if (parsed.command === "restore") run(() => {
+	const result = restore({
+		dryRun: parsed.dryRun,
+		force: parsed.force,
+		home: homeOf(parsed.home)
+	});
+	console.log(result.text);
+});
+else if (parsed.command === "status") run(() => {
+	const result = status({ home: homeOf(parsed.home) });
+	console.log(result.rows.join("\n"));
+	process.exitCode = result.healthy ? 0 : 1;
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=index.js.map