space-statusline 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oscar Angel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+# space-statusline
+
+Un status line **space-synthwave** ("Outrun Horizon") para
+[Claude Code](https://claude.com/claude-code), **configurable mediante un wizard CLI**.
+
+El render corre en **bash** (rápido, sin cold-start) · la configuración se hace en
+**Node + TypeScript** · **truecolor 24-bit** · glifos **Nerd Font** con fallback Unicode.
+
+## Cómo se ve
+
+Tres líneas (en modo `multi`, el default):
+
+1. Directorio + estado de git (rama, archivos nuevos/modificados, ahead/behind).
+2. Regla-horizonte con gradiente synthwave.
+3. Modelo · barra de contexto · costo · tokens · hora.
+
+También hay un modo de **una sola línea** (`single`).
+
+## Requisitos
+
+- [Claude Code](https://claude.com/claude-code).
+- `bash` 4+, `jq` y `git` para el render (el wizard necesita Node ≥ 20).
+- Una **Nerd Font** (p. ej. Cascadia Code NF) y una terminal con **truecolor** para la
+  estética completa. Hay fallbacks: sin `jq` cae a una línea mínima; con glifos
+  Unicode no hace falta Nerd Font; sin truecolor degrada a 256 colores.
+
+## Instalación
+
+Una vez publicado en npm:
+
+```bash
+pnpm dlx space-statusline init      # wizard + opción de instalar en Claude Code
+# o instalación global:
+pnpm add -g space-statusline && space-statusline init
+```
+
+Desde el código (mientras tanto):
+
+```bash
+git clone <repo> && cd space-statusline
+pnpm install && pnpm build
+node dist/cli.js init
+```
+
+El wizard escribe la config y ofrece **instalarse en Claude Code** (gestiona solo la
+clave `statusLine` de `~/.claude/settings.json`, con backup; nunca toca permisos).
+
+## Uso
+
+| Comando | Qué hace |
+|---|---|
+| `init` | Wizard completo (tema, secciones, glifos, layout, preview) + opción de instalar. |
+| `config` | Re-ejecuta el wizard para editar la config existente. |
+| `theme <name>` | Cambio rápido de preset: `outrun-horizon`, `sunset`, `vaporwave`, `mono`. |
+| `install` | Conecta el status line a Claude Code (merge seguro de `settings.json`). |
+| `uninstall` | Quita la entrada `statusLine` (deja un backup). |
+| `preview` | Renderiza con un input de ejemplo para ver el resultado. |
+| `doctor` | Verifica `jq`, `git`, soporte truecolor y Nerd Font. |
+
+## Configuración
+
+La config vive en `~/.config/space-statusline/config.json` (ruta XDG; se puede
+sobrescribir con `$SPACE_STATUSLINE_CONFIG`). El schema se valida con `zod` y permite
+ajustar:
+
+- **Tema** — preset o gradiente custom (start/end en hex) + paleta de colores.
+- **Secciones** — cuáles mostrar (`dir`, `git`, `model`, `context`, `cost`, `tokens`,
+  `clock`) y en qué orden.
+- **Glifos** — `nerdfont` o `unicode`, personalizables.
+- **Layout** — `multi`/`single`, separador, ancho del horizonte y de la barra de
+  contexto, uppercase, formato de hora (strftime).
+- **Umbrales** — porcentajes de contexto para los colores de aviso/peligro.
+
+El bash lee ese JSON en cada render; si falta o es inválido, usa defaults embebidos.
+
+## Temas
+
+`outrun-horizon` (default, violeta→magenta) · `sunset` (cálido, naranja→rosa) ·
+`vaporwave` (frío, cian→violeta) · `mono` (minimal, grises). Más `custom` desde el
+wizard.
+
+## Terminal recomendada (Windows Terminal)
+
+Para que el gradiente y los glifos se vean como en la captura, usá
+**CaskaydiaCove Nerd Font** y el esquema de color **Outrun Horizon**.
+
+1. Agregá este esquema en `settings.json` de Windows Terminal, dentro de `"schemes"`:
+
+```json
+{
+  "name": "Outrun Horizon",
+  "background": "#0D0A17",
+  "foreground": "#E7DEFB",
+  "cursorColor": "#FF6CF0",
+  "selectionBackground": "#7A3CFF",
+  "black":   "#1A1622",
+  "red":     "#FF5FB4",
+  "green":   "#62E6B0",
+  "yellow":  "#FFB86B",
+  "blue":    "#A96BFF",
+  "purple":  "#FF6CF0",
+  "cyan":    "#4BE4E8",
+  "white":   "#E7DEFB",
+  "brightBlack":  "#5C5181",
+  "brightRed":    "#FF7AC0",
+  "brightGreen":  "#7DF5C4",
+  "brightYellow": "#FFC98A",
+  "brightBlue":   "#C08BFF",
+  "brightPurple": "#FF8FF4",
+  "brightCyan":   "#74EEF1",
+  "brightWhite":  "#FFFFFF"
+}
+```
+
+2. Aplicalo en `"defaults"` (afecta a todos los perfiles) o en un perfil puntual:
+
+```json
+"defaults": {
+  "colorScheme": "Outrun Horizon",
+  "font": { "face": "CaskaydiaCove Nerd Font", "size": 11 },
+  "opacity": 92,
+  "useAcrylic": true
+}
+```
+
+## Cómo funciona
+
+El render se mantiene en **bash + jq** porque Claude Code lo invoca muy seguido y
+arrancar Node en cada render añadiría cold-start. El wizard (Node/TS) **no
+reimplementa el render**: solo edita la config JSON que el bash consume. El puente
+entre ambos es ese archivo. El render apunta a < 50 ms.
+
+## Desarrollo
+
+```bash
+pnpm install
+pnpm build       # tsc -> dist/
+pnpm typecheck   # tsc --noEmit
+pnpm lint        # eslint
+```
+
+Probar el runtime directamente:
+
+```bash
+echo '{"model":{"display_name":"Opus 4.1"},"workspace":{"current_dir":"'"$PWD"'"},"context_window":{"used_percentage":58},"cost":{"total_cost_usd":1.24}}' | bash runtime/statusline.sh
+```
+
+## Licencia
+
+MIT — ver [`LICENSE`](./LICENSE).

package/dist/claude.js

@@ -0,0 +1,98 @@
+import { copyFileSync, chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { getConfigDir } from './config.js';
+import { getRuntimeScriptPath } from './preview.js';
+/**
+ * Keys the installer must NEVER create, change, or remove. The merge only ever
+ * touches `statusLine`; this list is asserted before/after as defense in depth
+ * (SPEC §5.5, §9 RNF3).
+ */
+const PROTECTED_KEYS = ['permissions', 'defaultMode', 'skipAutoPermissionPrompt'];
+export function getClaudeDir() {
+    return join(homedir(), '.claude');
+}
+export function getClaudeSettingsPath() {
+    return join(getClaudeDir(), 'settings.json');
+}
+/** Stable location the runtime script is copied to, independent of the npm install dir. */
+export function getInstalledScriptPath() {
+    return join(getConfigDir(), 'statusline.sh');
+}
+/** Parses settings.json, returning {} if it does not exist. Throws on invalid JSON. */
+function readSettings(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = readFileSync(path, 'utf8');
+    if (raw.trim().length === 0)
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`${path} is not valid JSON. Refusing to touch it — fix or remove it first.`);
+    }
+}
+/** Snapshot of the protected keys, used to assert they are never modified. */
+function snapshotProtected(settings) {
+    const subset = {};
+    for (const key of PROTECTED_KEYS) {
+        if (key in settings)
+            subset[key] = settings[key];
+    }
+    return JSON.stringify(subset);
+}
+/** Backs up an existing settings.json to a timestamped sibling. Returns its path. */
+function backupSettings(path) {
+    if (!existsSync(path))
+        return null;
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = `${path}.bak.${stamp}`;
+    copyFileSync(path, backupPath);
+    return backupPath;
+}
+/** Serializes and writes settings as pretty JSON with a trailing newline. */
+function writeSettings(path, settings) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+}
+/**
+ * Copies the runtime script to a stable path and points Claude Code's
+ * `statusLine` at it, preserving every other settings key. Backs up first.
+ */
+export function install() {
+    const scriptPath = getInstalledScriptPath();
+    mkdirSync(dirname(scriptPath), { recursive: true });
+    copyFileSync(getRuntimeScriptPath(), scriptPath);
+    chmodSync(scriptPath, 0o755);
+    const settingsPath = getClaudeSettingsPath();
+    const settings = readSettings(settingsPath);
+    const before = snapshotProtected(settings);
+    const backupPath = backupSettings(settingsPath);
+    // Touch ONLY statusLine; every other key is preserved by reference.
+    settings.statusLine = { type: 'command', command: `bash ${scriptPath}` };
+    assertProtectedUnchanged(before, settings, settingsPath);
+    writeSettings(settingsPath, settings);
+    return { settingsPath, scriptPath, backupPath };
+}
+/** Removes the `statusLine` key, preserving everything else. Backs up first. */
+export function uninstall() {
+    const settingsPath = getClaudeSettingsPath();
+    const settings = readSettings(settingsPath);
+    const hadStatusLine = 'statusLine' in settings;
+    const before = snapshotProtected(settings);
+    if (!hadStatusLine) {
+        return { settingsPath, backupPath: null, hadStatusLine: false };
+    }
+    const backupPath = backupSettings(settingsPath);
+    delete settings.statusLine;
+    assertProtectedUnchanged(before, settings, settingsPath);
+    writeSettings(settingsPath, settings);
+    return { settingsPath, backupPath, hadStatusLine: true };
+}
+/** Throws if any protected key changed between the snapshot and now. */
+function assertProtectedUnchanged(before, settings, path) {
+    if (snapshotProtected(settings) !== before) {
+        throw new Error(`Aborted: a protected key would have changed in ${path}. No write performed.`);
+    }
+}

package/dist/cli.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import pc from 'picocolors';
+import * as p from '@clack/prompts';
+import { getConfigPath, getDefaults, saveConfig, tryLoadConfig } from './config.js';
+import { PRESET_NAMES, presets } from './themes.js';
+import { runWizard } from './wizard.js';
+import { install, uninstall } from './claude.js';
+import { renderPreview } from './preview.js';
+import { runDoctor } from './doctor.js';
+/** Reads this package's version from package.json (one level above dist/). */
+function readVersion() {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return pkg.version;
+}
+/** `init`: run the full wizard from scratch (pre-filled if a config exists). */
+async function runInit() {
+    const existing = tryLoadConfig();
+    const config = await runWizard(existing);
+    if (!config)
+        return;
+    const path = getConfigPath();
+    saveConfig(config, path);
+    const wantsInstall = await p.confirm({ message: 'Install into Claude Code now?', initialValue: true });
+    if (p.isCancel(wantsInstall) || !wantsInstall) {
+        p.outro(`${pc.green('Saved')} ${pc.dim(path)}\n  Run ${pc.cyan('space-statusline install')} when you're ready.`);
+        return;
+    }
+    const result = install();
+    p.outro(`${pc.green('Installed.')} ${pc.dim(result.settingsPath)}` +
+        (result.backupPath ? `\n  Backup: ${pc.dim(result.backupPath)}` : ''));
+}
+/** `install`: connect the status line to Claude Code (safe merge of settings.json). */
+function runInstall() {
+    const result = install();
+    console.log(pc.green('Installed.'));
+    console.log(`  Script:   ${pc.dim(result.scriptPath)}`);
+    console.log(`  Settings: ${pc.dim(result.settingsPath)}`);
+    if (result.backupPath)
+        console.log(`  Backup:   ${pc.dim(result.backupPath)}`);
+}
+/** `uninstall`: remove the statusLine entry, preserving everything else. */
+function runUninstall() {
+    const result = uninstall();
+    if (!result.hadStatusLine) {
+        console.log(pc.yellow('No statusLine entry found — nothing to remove.'));
+        return;
+    }
+    console.log(pc.green('Uninstalled the statusLine entry.'));
+    if (result.backupPath) {
+        console.log(`  A backup of your previous settings is at ${pc.dim(result.backupPath)}`);
+    }
+}
+/** `config`: edit an existing config (errors if there is none yet). */
+async function runConfig() {
+    const existing = tryLoadConfig();
+    if (!existing) {
+        console.error(pc.yellow(`No config found at ${getConfigPath()}.`));
+        console.error(`Run ${pc.cyan('space-statusline init')} first.`);
+        process.exitCode = 1;
+        return;
+    }
+    const config = await runWizard(existing);
+    if (!config)
+        return;
+    const path = getConfigPath();
+    saveConfig(config, path);
+    p.outro(`${pc.green('Saved')} ${pc.dim(path)}`);
+}
+/** `theme [name]`: quickly switch to a preset without the full wizard. */
+function runTheme(args) {
+    const name = args[0];
+    const valid = PRESET_NAMES;
+    if (!name || !valid.includes(name)) {
+        console.error(name ? pc.red(`Unknown theme: ${name}`) : pc.yellow('Usage: space-statusline theme <name>'));
+        console.error(`Available: ${PRESET_NAMES.join(', ')}`);
+        process.exitCode = 1;
+        return;
+    }
+    const config = tryLoadConfig() ?? getDefaults();
+    const preset = name;
+    config.theme = { preset, ...presets[preset] };
+    const path = getConfigPath();
+    saveConfig(config, path);
+    console.log(`${pc.green('Theme set to')} ${pc.magenta(name)} ${pc.dim('— ' + path)}`);
+}
+/** `preview`: render the current config (or defaults) with mock input. */
+function runPreview() {
+    const config = tryLoadConfig() ?? undefined;
+    process.stdout.write(renderPreview(config));
+    process.stdout.write('\n');
+}
+const commands = {
+    init: runInit,
+    config: runConfig,
+    theme: runTheme,
+    install: runInstall,
+    uninstall: runUninstall,
+    preview: runPreview,
+    doctor: runDoctor,
+};
+function printHelp() {
+    const title = pc.magenta(pc.bold('space-statusline'));
+    console.log(`
+${title} — synthwave status line for Claude Code
+
+${pc.bold('Usage:')} space-statusline <command> [options]
+
+${pc.bold('Commands:')}
+  ${pc.cyan('init')}        Run the full wizard and optionally install into Claude Code
+  ${pc.cyan('config')}      Re-run the wizard to edit the existing config
+  ${pc.cyan('theme')} ${pc.dim('[name]')}  Quickly switch to a preset theme
+  ${pc.cyan('install')}     Connect the status line to Claude Code (settings.json)
+  ${pc.cyan('uninstall')}   Remove the status line entry and offer to restore a backup
+  ${pc.cyan('preview')}     Render with mock input to preview the result
+  ${pc.cyan('doctor')}      Check the environment (jq, git, truecolor, Nerd Font)
+
+${pc.bold('Options:')}
+  -h, --help     Show this help
+  -v, --version  Show the version
+`);
+}
+async function main() {
+    const [, , command, ...rest] = process.argv;
+    if (!command || command === 'help' || command === '--help' || command === '-h') {
+        printHelp();
+        return;
+    }
+    if (command === 'version' || command === '--version' || command === '-v') {
+        console.log(readVersion());
+        return;
+    }
+    const handler = commands[command];
+    if (!handler) {
+        console.error(pc.red(`Unknown command: ${command}`));
+        printHelp();
+        process.exitCode = 1;
+        return;
+    }
+    await handler(rest);
+}
+main().catch((error) => {
+    console.error(pc.red(error instanceof Error ? error.message : String(error)));
+    process.exitCode = 1;
+});

package/dist/config.js

@@ -0,0 +1,176 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+import { PRESET_NAMES, presets } from './themes.js';
+// ── Schema (mirrors SPEC §5.2) ──────────────────────────────────────────────
+const HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
+const hexColor = z.string().regex(HEX_COLOR, 'Expected a hex color like #RRGGBB');
+/** The renderable sections, in their canonical (default) order. */
+export const SECTION_KEYS = ['dir', 'git', 'model', 'context', 'cost', 'tokens', 'clock'];
+const sectionKey = z.enum(SECTION_KEYS);
+// A theme's `preset` is a built-in name or the synthetic "custom".
+const presetOrCustom = [...PRESET_NAMES, 'custom'];
+const themeSchema = z.strictObject({
+    preset: z.enum(presetOrCustom),
+    gradient: z.strictObject({ start: hexColor, end: hexColor }),
+    colors: z.strictObject({
+        accent: hexColor,
+        magenta: hexColor,
+        cyan: hexColor,
+        green: hexColor,
+        amber: hexColor,
+        dim: hexColor,
+        ctxWarn: hexColor,
+        ctxDanger: hexColor,
+    }),
+});
+const sectionsSchema = z.strictObject({
+    // `order` is a full permutation of SECTION_KEYS; `enabled` gates visibility.
+    // Keeping order total keeps the bash assembler simple.
+    order: z
+        .array(sectionKey)
+        .refine((order) => order.length === SECTION_KEYS.length && new Set(order).size === order.length, 'order must list each section exactly once'),
+    enabled: z.strictObject({
+        dir: z.boolean(),
+        git: z.boolean(),
+        model: z.boolean(),
+        context: z.boolean(),
+        cost: z.boolean(),
+        tokens: z.boolean(),
+        clock: z.boolean(),
+    }),
+});
+const glyphsSchema = z.strictObject({
+    mode: z.enum(['nerdfont', 'unicode']),
+    repo: z.string(),
+    branch: z.string(),
+    clock: z.string(),
+    model: z.string(),
+    added: z.string(),
+    modified: z.string(),
+    ahead: z.string(),
+    behind: z.string(),
+});
+const layoutSchema = z.strictObject({
+    lines: z.enum(['multi', 'single']),
+    separator: z.string().min(1),
+    // Capped: the gradient renders char-by-char, so very wide values hurt the
+    // < 50ms render budget (SPEC §9 RNF1).
+    horizonWidth: z.int().min(1).max(120),
+    ctxBarWidth: z.int().min(1).max(60),
+    uppercase: z.boolean(),
+    timeFormat: z.string().min(1),
+});
+const thresholdsSchema = z
+    .strictObject({
+    ctxWarn: z.int().min(0).max(100),
+    ctxDanger: z.int().min(0).max(100),
+})
+    .refine((t) => t.ctxDanger >= t.ctxWarn, 'ctxDanger must be >= ctxWarn');
+export const configSchema = z.strictObject({
+    version: z.literal(1),
+    theme: themeSchema,
+    sections: sectionsSchema,
+    glyphs: glyphsSchema,
+    layout: layoutSchema,
+    thresholds: thresholdsSchema,
+});
+// ── Defaults (must stay in sync with the embedded defaults in the bash) ──────
+export const DEFAULT_PRESET = 'outrun-horizon';
+/**
+ * Nerd Font glyphs (Cascadia Code NF / CaskaydiaCove). The original runtime had
+ * lost the repo/branch/clock codepoints (rendered empty); these restore them.
+ */
+export const NERDFONT_GLYPHS = {
+    mode: 'nerdfont',
+    repo: '\u{f07b}', // nf-fa-folder
+    branch: '\u{e0a0}', // powerline git branch
+    clock: '\u{f017}', // nf-fa-clock_o
+    model: '\u{2726}', // ✦
+    added: '\u{271a}', // ✚
+    modified: '\u{00b1}', // ±
+    ahead: '\u{21e1}', // ⇡
+    behind: '\u{21e3}', // ⇣
+};
+/** Plain-Unicode glyphs for terminals without a Nerd Font. */
+export const UNICODE_GLYPHS = {
+    mode: 'unicode',
+    repo: '\u{25b0}', // ▰
+    branch: '\u{2387}', // ⎇
+    clock: '\u{25f7}', // ◷
+    model: '\u{2726}', // ✦
+    added: '\u{271a}', // ✚
+    modified: '\u{00b1}', // ±
+    ahead: '\u{21e1}', // ⇡
+    behind: '\u{21e3}', // ⇣
+};
+/** A complete, valid default config (the Outrun Horizon look). */
+export function getDefaults() {
+    return {
+        version: 1,
+        theme: { preset: DEFAULT_PRESET, ...presets[DEFAULT_PRESET] },
+        sections: {
+            order: [...SECTION_KEYS],
+            enabled: {
+                dir: true,
+                git: true,
+                model: true,
+                context: true,
+                cost: true,
+                tokens: true,
+                clock: true,
+            },
+        },
+        glyphs: { ...NERDFONT_GLYPHS },
+        layout: {
+            lines: 'multi',
+            separator: '░', // ░
+            horizonWidth: 54,
+            ctxBarWidth: 14,
+            uppercase: true,
+            timeFormat: '%H:%M',
+        },
+        thresholds: { ctxWarn: 50, ctxDanger: 80 },
+    };
+}
+// ── Paths (XDG) ──────────────────────────────────────────────────────────────
+/** Directory that holds config.json and the installed statusline.sh copy. */
+export function getConfigDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const base = xdg && xdg.length > 0 ? xdg : join(homedir(), '.config');
+    return join(base, 'space-statusline');
+}
+/** Resolved config path, honoring the $SPACE_STATUSLINE_CONFIG override. */
+export function getConfigPath() {
+    const override = process.env.SPACE_STATUSLINE_CONFIG;
+    if (override && override.length > 0)
+        return override;
+    return join(getConfigDir(), 'config.json');
+}
+// ── Load / save ──────────────────────────────────────────────────────────────
+/** Reads and validates the config at `path`. Throws on missing/invalid. */
+export function loadConfig(path = getConfigPath()) {
+    const raw = readFileSync(path, 'utf8');
+    const parsed = JSON.parse(raw);
+    const result = configSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new Error(`Invalid config at ${path}:\n${z.prettifyError(result.error)}`);
+    }
+    return result.data;
+}
+/** Like loadConfig but returns null when the file does not exist. */
+export function tryLoadConfig(path = getConfigPath()) {
+    if (!existsSync(path))
+        return null;
+    return loadConfig(path);
+}
+/** Validates and writes the config as pretty JSON, creating the dir as needed. */
+export function saveConfig(config, path = getConfigPath()) {
+    const result = configSchema.safeParse(config);
+    if (!result.success) {
+        throw new Error(`Refusing to save invalid config:\n${z.prettifyError(result.error)}`);
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(result.data, null, 2) + '\n', 'utf8');
+}

package/dist/doctor.js

@@ -0,0 +1,33 @@
+import { spawnSync } from 'node:child_process';
+import pc from 'picocolors';
+/** True when `bin --version` runs (i.e. the binary is on PATH). */
+function hasBinary(bin) {
+    const result = spawnSync(bin, ['--version'], { stdio: 'ignore' });
+    return !result.error;
+}
+/** Runs environment checks and prints a human-readable report. */
+export function runDoctor() {
+    const checks = [];
+    checks.push(hasBinary('jq')
+        ? { name: 'jq', status: 'ok', detail: 'found' }
+        : { name: 'jq', status: 'fail', detail: 'not found — the status line degrades to a minimal line' });
+    checks.push(hasBinary('git')
+        ? { name: 'git', status: 'ok', detail: 'found' }
+        : { name: 'git', status: 'warn', detail: 'not found — the git section will be hidden' });
+    const colorterm = process.env.COLORTERM ?? '';
+    checks.push(/truecolor|24bit/.test(colorterm)
+        ? { name: 'truecolor', status: 'ok', detail: `COLORTERM=${colorterm}` }
+        : { name: 'truecolor', status: 'warn', detail: 'COLORTERM not truecolor — colors degrade to 256' });
+    checks.push({
+        name: 'Nerd Font',
+        status: 'warn',
+        detail: 'cannot auto-detect — check the sample below',
+    });
+    console.log(pc.bold('space-statusline doctor') + '\n');
+    for (const c of checks) {
+        const icon = c.status === 'ok' ? pc.green('✓') : c.status === 'warn' ? pc.yellow('!') : pc.red('✗');
+        console.log(`  ${icon} ${c.name.padEnd(11)} ${pc.dim(c.detail)}`);
+    }
+    console.log(`\n  Nerd Font sample:  \u{f07b}  \u{e0a0}  \u{f017}   ${pc.dim('(folder · branch · clock)')}`);
+    console.log(pc.dim('  If those show as boxes, run the wizard and pick the Unicode glyph set.'));
+}

package/dist/preview.js

@@ -0,0 +1,45 @@
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Absolute path to the bundled runtime script. `runtime/` ships next to `dist/`,
+ * so from dist/preview.js it is one level up.
+ */
+export function getRuntimeScriptPath() {
+    return join(dirname(fileURLToPath(import.meta.url)), '..', 'runtime', 'statusline.sh');
+}
+/** A representative mock of the JSON Claude Code feeds the status line on stdin. */
+export function buildMockInput() {
+    return JSON.stringify({
+        model: { display_name: 'Opus 4.1' },
+        workspace: { current_dir: process.cwd() },
+        context_window: { used_percentage: 58, total_input_tokens: 12000, total_output_tokens: 3400 },
+        cost: { total_cost_usd: 1.24 },
+    });
+}
+/**
+ * Renders the status line with the given config (or embedded defaults when
+ * omitted) by invoking the real bash runtime with a mock stdin payload.
+ * Returns the raw ANSI output so callers can print it verbatim.
+ */
+export function renderPreview(config, mockInput = buildMockInput()) {
+    const env = { ...process.env };
+    if (config) {
+        const dir = mkdtempSync(join(tmpdir(), 'space-statusline-'));
+        const configPath = join(dir, 'config.json');
+        writeFileSync(configPath, JSON.stringify(config), 'utf8');
+        env.SPACE_STATUSLINE_CONFIG = configPath;
+    }
+    else {
+        // Force the embedded defaults by pointing at a path that does not exist.
+        env.SPACE_STATUSLINE_CONFIG = '/nonexistent';
+    }
+    const result = spawnSync('bash', [getRuntimeScriptPath()], {
+        input: mockInput,
+        env,
+        encoding: 'utf8',
+    });
+    return result.stdout ?? '';
+}

package/dist/themes.js

@@ -0,0 +1,65 @@
+// Theme presets. A preset defines only the color identity of the status line:
+// the synthwave gradient (used for the horizon rule, the dir name and the
+// context bar) plus the semantic palette. Everything else (sections, glyphs,
+// layout, thresholds) lives in the config-level defaults in config.ts.
+/** Names of the built-in presets (excludes the synthetic "custom"). */
+export const PRESET_NAMES = ['outrun-horizon', 'sunset', 'vaporwave', 'mono'];
+/** Built-in palettes. `outrun-horizon` is the default and matches the runtime. */
+export const presets = {
+    // The original synthwave look: violet → magenta horizon.
+    'outrun-horizon': {
+        gradient: { start: '#7A3CFF', end: '#FF6CF0' },
+        colors: {
+            accent: '#A96BFF',
+            magenta: '#FF6CF0',
+            cyan: '#4BE4E8',
+            green: '#62E6B0',
+            amber: '#FFB86B',
+            dim: '#5C5180',
+            ctxWarn: '#FFB86B',
+            ctxDanger: '#FF5F8C',
+        },
+    },
+    // Warm dusk: orange → hot pink.
+    sunset: {
+        gradient: { start: '#FF7A3C', end: '#FF3CA8' },
+        colors: {
+            accent: '#FFA552',
+            magenta: '#FF5FA0',
+            cyan: '#FFC27A',
+            green: '#7BD88F',
+            amber: '#FFB86B',
+            dim: '#6B5560',
+            ctxWarn: '#FFB86B',
+            ctxDanger: '#FF4D6D',
+        },
+    },
+    // Cool vaporwave: cyan → violet.
+    vaporwave: {
+        gradient: { start: '#2BD9FF', end: '#9A6BFF' },
+        colors: {
+            accent: '#6CC0FF',
+            magenta: '#C77DFF',
+            cyan: '#4BE4E8',
+            green: '#5BE8C2',
+            amber: '#8AB6FF',
+            dim: '#46557F',
+            ctxWarn: '#FFD27A',
+            ctxDanger: '#FF6B9D',
+        },
+    },
+    // Minimal monochrome: low-chroma greys with a single soft accent.
+    mono: {
+        gradient: { start: '#6E7488', end: '#C2C7D6' },
+        colors: {
+            accent: '#C2C7D6',
+            magenta: '#AEB3C2',
+            cyan: '#9AA0B3',
+            green: '#A8B6A0',
+            amber: '#C9BD93',
+            dim: '#4A4E5A',
+            ctxWarn: '#C9BD93',
+            ctxDanger: '#D88A8A',
+        },
+    },
+};

package/dist/wizard.js

@@ -0,0 +1,195 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { SECTION_KEYS, NERDFONT_GLYPHS, UNICODE_GLYPHS, getDefaults, configSchema, } from './config.js';
+import { PRESET_NAMES, presets } from './themes.js';
+import { renderPreview } from './preview.js';
+const HEX_COLOR = /^#[0-9a-fA-F]{6}$/;
+/** Aborts the wizard cleanly if the user cancels a prompt (Ctrl-C / Esc). */
+function requireValue(value) {
+    if (p.isCancel(value)) {
+        p.cancel('Wizard cancelled — no changes were made.');
+        process.exit(0);
+    }
+    return value;
+}
+/** Human-readable label for each section, shown in the multiselect. */
+const SECTION_LABELS = {
+    dir: 'Directory name',
+    git: 'Git branch & status',
+    model: 'Model name',
+    context: 'Context usage bar',
+    cost: 'Session cost',
+    tokens: 'Token count',
+    clock: 'Clock',
+};
+/**
+ * Runs the interactive wizard. `existing` pre-fills answers when editing an
+ * existing config; pass null for a from-scratch run. Returns the validated
+ * config, or null if the user chose not to save at the preview step.
+ */
+export async function runWizard(existing) {
+    const base = existing ?? getDefaults();
+    p.intro(pc.magenta(pc.bold('space-statusline')) + pc.dim('  ·  synthwave status line'));
+    // ── 1. Theme ───────────────────────────────────────────────────────────────
+    const presetChoice = requireValue(await p.select({
+        message: 'Theme',
+        initialValue: base.theme.preset,
+        options: [
+            ...PRESET_NAMES.map((name) => ({
+                value: name,
+                label: name,
+                hint: name === 'outrun-horizon' ? 'default' : undefined,
+            })),
+            { value: 'custom', label: 'custom', hint: 'pick your own gradient' },
+        ],
+    }));
+    let theme;
+    if (presetChoice === 'custom') {
+        const start = requireValue(await p.text({
+            message: 'Gradient start color (hex)',
+            placeholder: '#7A3CFF',
+            initialValue: base.theme.gradient.start,
+            validate: (v) => (HEX_COLOR.test(v ?? '') ? undefined : 'Use a hex color like #7A3CFF'),
+        }));
+        const end = requireValue(await p.text({
+            message: 'Gradient end color (hex)',
+            placeholder: '#FF6CF0',
+            initialValue: base.theme.gradient.end,
+            validate: (v) => (HEX_COLOR.test(v ?? '') ? undefined : 'Use a hex color like #FF6CF0'),
+        }));
+        // Derive a palette: gradient endpoints drive accent/magenta, the rest keeps
+        // the proven Outrun semantic colors so git/context stay legible.
+        const fallback = presets['outrun-horizon'].colors;
+        theme = {
+            preset: 'custom',
+            gradient: { start, end },
+            colors: { ...fallback, accent: start, magenta: end },
+        };
+    }
+    else {
+        theme = { preset: presetChoice, ...presets[presetChoice] };
+    }
+    // ── 2. Sections: which are enabled, then their order ─────────────────────────
+    const enabledList = requireValue(await p.multiselect({
+        message: 'Sections to show',
+        options: SECTION_KEYS.map((key) => ({ value: key, label: SECTION_LABELS[key] })),
+        initialValues: SECTION_KEYS.filter((k) => base.sections.enabled[k]),
+        required: true,
+    }));
+    const orderInput = requireValue(await p.text({
+        message: 'Section order (comma-separated, all sections)',
+        placeholder: SECTION_KEYS.join(', '),
+        initialValue: base.sections.order.join(', '),
+        validate: (v) => {
+            const items = (v ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+            const valid = new Set(SECTION_KEYS);
+            if (items.length !== SECTION_KEYS.length)
+                return `List all ${SECTION_KEYS.length} sections exactly once`;
+            if (new Set(items).size !== items.length)
+                return 'No duplicates allowed';
+            for (const it of items)
+                if (!valid.has(it))
+                    return `Unknown section: ${it}`;
+            return undefined;
+        },
+    }));
+    const order = orderInput.split(',').map((s) => s.trim()).filter(Boolean);
+    const enabledSet = new Set(enabledList);
+    const enabled = Object.fromEntries(SECTION_KEYS.map((k) => [k, enabledSet.has(k)]));
+    // ── 3. Glyphs ────────────────────────────────────────────────────────────────
+    const glyphMode = requireValue(await p.select({
+        message: 'Glyph set',
+        initialValue: base.glyphs.mode,
+        options: [
+            { value: 'nerdfont', label: 'Nerd Font', hint: 'needs a patched font (e.g. Cascadia Code NF)' },
+            { value: 'unicode', label: 'Unicode', hint: 'works without a Nerd Font' },
+        ],
+    }));
+    let glyphs = glyphMode === 'nerdfont' ? { ...NERDFONT_GLYPHS } : { ...UNICODE_GLYPHS };
+    const customizeGlyphs = requireValue(await p.confirm({ message: 'Customize individual glyphs?', initialValue: false }));
+    if (customizeGlyphs) {
+        const keys = [
+            'repo',
+            'branch',
+            'clock',
+            'model',
+        ];
+        for (const key of keys) {
+            const value = requireValue(await p.text({
+                message: `Glyph for ${key}`,
+                initialValue: glyphs[key],
+            }));
+            glyphs = { ...glyphs, [key]: value };
+        }
+    }
+    // ── 4. Layout ──────────────────────────────────────────────────────────────
+    const lines = requireValue(await p.select({
+        message: 'Layout',
+        initialValue: base.layout.lines,
+        options: [
+            { value: 'multi', label: 'Multi-line', hint: 'directory · horizon · metrics' },
+            { value: 'single', label: 'Single line' },
+        ],
+    }));
+    const separator = requireValue(await p.text({
+        message: 'Section separator',
+        initialValue: base.layout.separator,
+        validate: (v) => ((v ?? '').length >= 1 ? undefined : 'Separator cannot be empty'),
+    }));
+    const horizonWidth = requireValue(await p.text({
+        message: 'Horizon width (1–120)',
+        initialValue: String(base.layout.horizonWidth),
+        validate: (v) => validateInt(v ?? '', 1, 120),
+    }));
+    const ctxBarWidth = requireValue(await p.text({
+        message: 'Context bar width (1–60)',
+        initialValue: String(base.layout.ctxBarWidth),
+        validate: (v) => validateInt(v ?? '', 1, 60),
+    }));
+    const uppercase = requireValue(await p.confirm({ message: 'Uppercase labels?', initialValue: base.layout.uppercase }));
+    const timeFormat = requireValue(await p.text({
+        message: 'Clock format (strftime)',
+        initialValue: base.layout.timeFormat,
+        validate: (v) => ((v ?? '').length >= 1 ? undefined : 'Format cannot be empty'),
+    }));
+    const layout = {
+        lines,
+        separator,
+        horizonWidth: Number(horizonWidth),
+        ctxBarWidth: Number(ctxBarWidth),
+        uppercase,
+        timeFormat,
+    };
+    // ── Assemble & validate ──────────────────────────────────────────────────────
+    const candidate = {
+        version: 1,
+        theme,
+        sections: { order, enabled },
+        glyphs,
+        layout,
+        thresholds: base.thresholds,
+    };
+    const parsed = configSchema.safeParse(candidate);
+    if (!parsed.success) {
+        p.cancel('Internal error: built an invalid config. Please report this.');
+        process.exit(1);
+    }
+    const config = parsed.data;
+    // ── 5. Live preview + confirm ────────────────────────────────────────────────
+    p.note(renderPreview(config), 'Preview');
+    const save = requireValue(await p.confirm({ message: 'Save this configuration?', initialValue: true }));
+    if (!save) {
+        p.outro(pc.dim('Nothing saved.'));
+        return null;
+    }
+    return config;
+}
+/** Validator: an integer within [min, max]. Returns an error string or undefined. */
+function validateInt(value, min, max) {
+    const n = Number(value);
+    if (!Number.isInteger(n))
+        return 'Enter a whole number';
+    if (n < min || n > max)
+        return `Must be between ${min} and ${max}`;
+    return undefined;
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "space-statusline",
+  "version": "0.1.0",
+  "description": "Configurable space-synthwave (Outrun Horizon) status line for Claude Code, set up via an interactive CLI wizard.",
+  "type": "module",
+  "bin": {
+    "space-statusline": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "runtime",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "claude-code",
+    "statusline",
+    "cli",
+    "synthwave",
+    "outrun",
+    "terminal",
+    "wizard"
+  ],
+  "author": "Oscar Angel",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Oscaraag/Space-Statusline.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Oscaraag/Space-Statusline/issues"
+  },
+  "homepage": "https://github.com/Oscaraag/Space-Statusline#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "^11.1.1",
+      "onFail": "download"
+    }
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.5.1",
+    "picocolors": "^1.1.1",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.9.3",
+    "eslint": "^10.5.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.61.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src"
+  }
+}

package/runtime/statusline.sh

@@ -0,0 +1,298 @@
+#!/usr/bin/env bash
+# ════════════════════════════════════════════════════════════════
+#  OUTRUN HORIZON · status line para Claude Code
+#  Estilo space-synthwave · truecolor 24-bit · Nerd Font (Cascadia Code NF)
+#  Requiere: bash 4+, jq, git   ·   Pensado para WSL2 / Linux / macOS
+#
+#  Config-driven: lee su apariencia desde
+#    $SPACE_STATUSLINE_CONFIG  o  ${XDG_CONFIG_HOME:-~/.config}/space-statusline/config.json
+#  Sin config (o config inválida) usa los defaults embebidos (look Outrun).
+#
+#  Probar sin Claude Code:
+#    echo '{"model":{"display_name":"Opus 4.1"},"workspace":{"current_dir":"'"$PWD"'"},"context_window":{"used_percentage":58},"cost":{"total_cost_usd":1.24}}' | bash runtime/statusline.sh
+# ════════════════════════════════════════════════════════════════
+
+input=$(cat)
+
+# ── Fallback RNF2: sin jq → línea mínima, sin color, nunca rompe ─
+if ! command -v jq >/dev/null 2>&1; then
+  m=$(printf '%s' "$input" | grep -oE '"display_name"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed -E 's/.*"([^"]*)"$/\1/')
+  d=$(printf '%s' "$input" | grep -oE '"current_dir"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 | sed -E 's/.*"([^"]*)"$/\1/')
+  p=$(printf '%s' "$input" | grep -oE '"used_percentage"[[:space:]]*:[[:space:]]*[0-9]+' | head -1 | grep -oE '[0-9]+$')
+  printf '%s · %s · %s%%' "$(basename "${d:-$PWD}")" "${m:-Claude}" "${p:-0}"
+  exit 0
+fi
+
+# ── Resolución de la config (XDG) ───────────────────────────────
+CONFIG_PATH="${SPACE_STATUSLINE_CONFIG:-${XDG_CONFIG_HOME:-$HOME/.config}/space-statusline/config.json}"
+
+# Defaults embebidos (espejo de getDefaults() en src/config.ts). Glifos y
+# separador como escapes \u para mantener el script ASCII-puro; jq los expande.
+DEFAULTS='{
+  "theme": {
+    "gradient": { "start": "#7A3CFF", "end": "#FF6CF0" },
+    "colors": {
+      "accent": "#A96BFF", "magenta": "#FF6CF0", "cyan": "#4BE4E8",
+      "green": "#62E6B0", "amber": "#FFB86B", "dim": "#5C5180",
+      "ctxWarn": "#FFB86B", "ctxDanger": "#FF5F8C"
+    }
+  },
+  "sections": {
+    "order": ["dir","git","model","context","cost","tokens","clock"],
+    "enabled": { "dir": true, "git": true, "model": true, "context": true,
+                 "cost": true, "tokens": true, "clock": true }
+  },
+  "glyphs": {
+    "mode": "nerdfont",
+    "repo": "\uf07b", "branch": "\ue0a0", "clock": "\uf017", "model": "\u2726",
+    "added": "\u271a", "modified": "\u00b1", "ahead": "\u21e1", "behind": "\u21e3"
+  },
+  "layout": {
+    "lines": "multi", "separator": "\u2591", "horizonWidth": 54,
+    "ctxBarWidth": 14, "uppercase": true, "timeFormat": "%H:%M"
+  },
+  "thresholds": { "ctxWarn": 50, "ctxDanger": 80 }
+}'
+
+# Lee la config del usuario (si existe). Si no es JSON válido, el primer jq
+# falla y reintentamos con defaults — nunca rompe.
+US=$'\x1f'
+usercfg='{}'
+[[ -r "$CONFIG_PATH" ]] && usercfg=$(cat "$CONFIG_PATH" 2>/dev/null)
+[[ -z "$usercfg" ]] && usercfg='{}'
+
+# ── Una sola pasada de jq ────────────────────────────────────────
+# deep-merge (defaults*user) + parseo del stdin de Claude Code. Emite 4
+# líneas US-joined: escalares de config, orden, habilitadas, datos del stdin.
+read_all(){
+  jq -r --argjson def "$DEFAULTS" --argjson usr "$1" '
+    ($def * $usr) as $c
+    | ([ $c.theme.gradient.start, $c.theme.gradient.end,
+         $c.theme.colors.accent, $c.theme.colors.magenta, $c.theme.colors.cyan,
+         $c.theme.colors.green, $c.theme.colors.amber, $c.theme.colors.dim,
+         $c.theme.colors.ctxWarn, $c.theme.colors.ctxDanger,
+         ($c.thresholds.ctxWarn|tostring), ($c.thresholds.ctxDanger|tostring),
+         ($c.layout.horizonWidth|tostring), ($c.layout.ctxBarWidth|tostring),
+         $c.layout.separator, $c.layout.timeFormat,
+         ($c.layout.uppercase|tostring), $c.layout.lines,
+         $c.glyphs.mode, $c.glyphs.repo, $c.glyphs.branch, $c.glyphs.clock,
+         $c.glyphs.model, $c.glyphs.added, $c.glyphs.modified,
+         $c.glyphs.ahead, $c.glyphs.behind
+       ] | join("")),
+      ($c.sections.order | join("")),
+      ($c.sections.enabled | to_entries | map(select(.value).key) | join("")),
+      ([ (.model.display_name // "Claude"),
+         (.workspace.current_dir // .cwd // ""),
+         ((.context_window.used_percentage // 0)|floor|tostring),
+         ((.cost.total_cost_usd // 0)|tostring),
+         ((.context_window.total_input_tokens // 0)|tostring),
+         ((.context_window.total_output_tokens // 0)|tostring)
+       ] | join(""))
+  ' <<<"$input" 2>/dev/null
+}
+
+cfg=$(read_all "$usercfg")
+[[ -z "$cfg" ]] && cfg=$(read_all '{}')
+
+mapfile -t CFG_LINES <<<"$cfg"
+IFS="$US" read -r \
+  GS GE C_ACCENT C_MAG C_CYAN C_GREEN C_AMBER C_DIM C_CTXW C_CTXD \
+  T_WARN T_DANGER HORIZON_W CTXBAR_W SEPARATOR TIME_FMT UPPER LINES_MODE \
+  G_MODE G_REPO G_BR G_CLK G_MDL G_ADD G_MOD G_AH G_BH \
+  <<<"${CFG_LINES[0]}"
+IFS="$US" read -ra ORDER   <<<"${CFG_LINES[1]:-}"
+IFS="$US" read -ra ENABLED <<<"${CFG_LINES[2]:-}"
+IFS="$US" read -r MODEL CWD PCT COST TIN TOUT <<<"${CFG_LINES[3]:-}"
+: "${G_MODE:=nerdfont}"
+: "${MODEL:=Claude}"; : "${PCT:=0}"; : "${COST:=0}"; : "${TIN:=0}"; : "${TOUT:=0}"
+TOK=$(( TIN + TOUT ))
+
+# ── Capacidades: truecolor (degradar a 256 si COLORTERM lo niega) ─
+TRUECOLOR=1
+case "${COLORTERM:-}" in
+  truecolor|24bit|"") TRUECOLOR=1 ;;
+  *) TRUECOLOR=0 ;;
+esac
+
+# ── Helpers de color ─────────────────────────────────────────────
+RESET=$'\033[0m'
+BOLD=$'\033[1m'
+
+# Print an SGR foreground escape for an RGB triple (24-bit, or the xterm-256
+# color cube when truecolor is unavailable). Prints inline — no subshell.
+fg(){
+  if (( TRUECOLOR )); then printf '\033[38;2;%d;%d;%dm' "$1" "$2" "$3"
+  else printf '\033[38;5;%dm' "$(( 16 + 36*($1*5/255) + 6*($2*5/255) + ($3*5/255) ))"; fi
+}
+# Same, but assign the escape into a variable via printf -v (avoids the $() fork).
+mkfg(){
+  if (( TRUECOLOR )); then printf -v "$1" '\033[38;2;%d;%d;%dm' "$2" "$3" "$4"
+  else printf -v "$1" '\033[38;5;%dm' "$(( 16 + 36*($2*5/255) + 6*($3*5/255) + ($4*5/255) ))"; fi
+}
+
+# Parse #RRGGBB into R G B globals; falls back to $2 $3 $4 on a bad value.
+hex2rgb(){
+  local h=${1#\#}
+  if [[ $h =~ ^[0-9A-Fa-f]{6}$ ]]; then
+    R=$(( 16#${h:0:2} )); G=$(( 16#${h:2:2} )); B=$(( 16#${h:4:2} ))
+  else
+    R=${2:-255}; G=${3:-255}; B=${4:-255}
+  fi
+}
+
+# ── Gradiente: endpoints desde la config ─────────────────────────
+hex2rgb "$GS" 122 60 255;  GS_R=$R GS_G=$G GS_B=$B
+hex2rgb "$GE" 255 108 240; GE_R=$R GE_G=$G GE_B=$B
+
+lerp(){ # $1 = t (0..1000) -> define R G B sobre el gradiente
+  R=$(( GS_R + (GE_R-GS_R)*$1/1000 ))
+  G=$(( GS_G + (GE_G-GS_G)*$1/1000 ))
+  B=$(( GS_B + (GE_B-GS_B)*$1/1000 ))
+}
+
+# Texto con gradiente, carácter a carácter.
+grad(){
+  local s=$1 n=${#1} i t
+  (( n==0 )) && return
+  for (( i=0; i<n; i++ )); do
+    t=$(( n>1 ? i*1000/(n-1) : 0 )); lerp "$t"
+    fg "$R" "$G" "$B"; printf '%s' "${s:i:1}"
+  done
+  printf '%s' "$RESET"
+}
+
+# Regla-horizonte: gradiente + desvanecido en los extremos.
+horizon(){
+  local w=${1:-46} i t d f m=$(( (${1:-46}-1)/2 ))
+  for (( i=0; i<w; i++ )); do
+    t=$(( w>1 ? i*1000/(w-1) : 0 )); lerp "$t"
+    d=$(( i>m ? i-m : m-i ))
+    f=$(( 100 - d*38/(m>0?m:1) ))
+    fg $(( R*f/100 )) $(( G*f/100 )) $(( B*f/100 )); printf '─'
+  done
+  printf '%s' "$RESET"
+}
+
+# Barra de contexto: medios-bloques (sub-resolución) + gradiente.
+ctxbar(){
+  local pct=$1 w=${2:-14} parts=("" "▏" "▎" "▍" "▌" "▋" "▊" "▉") i cell t
+  local eighths=$(( pct*w*8/100 ))
+  for (( i=0; i<w; i++ )); do
+    t=$(( w>1 ? i*1000/(w-1) : 0 )); lerp "$t"
+    cell=$(( eighths - i*8 ))
+    if   (( cell >= 8 )); then fg "$R" "$G" "$B"; printf '█'
+    elif (( cell >  0 )); then fg "$R" "$G" "$B"; printf '%s' "${parts[cell]}"
+    else                       printf '%s░' "$TRACK"
+    fi
+  done
+  printf '%s' "$RESET"
+}
+
+fmtk(){ local n=$1; (( n>=1000 )) && printf '%d.%dk' $(( n/1000 )) $(( (n%1000)/100 )) || printf '%d' "$n"; }
+# Uppercase a variable in place when layout.uppercase is on (bash builtin, no fork).
+upcase(){ local v=${!1}; [[ $UPPER == true ]] && v=${v^^}; printf -v "$1" '%s' "$v"; }
+
+# ── Paleta (desde la config) ─────────────────────────────────────
+hex2rgb "$C_ACCENT" 169 107 255; mkfg PUR  "$R" "$G" "$B"
+hex2rgb "$C_MAG"    255 108 240; mkfg MAG  "$R" "$G" "$B"
+hex2rgb "$C_CYAN"    75 228 232; mkfg CYAN "$R" "$G" "$B"
+hex2rgb "$C_GREEN"   98 230 176; mkfg GRN  "$R" "$G" "$B"
+hex2rgb "$C_AMBER"  255 184 107; mkfg AMB  "$R" "$G" "$B"
+hex2rgb "$C_DIM"     92  81 128; mkfg DIM  "$R" "$G" "$B"; DIM_R=$R DIM_G=$G DIM_B=$B
+hex2rgb "$C_CTXW"   255 184 107; mkfg CTXW "$R" "$G" "$B"
+hex2rgb "$C_CTXD"   255  95 140; mkfg CTXD "$R" "$G" "$B"
+# Empty context-bar track: a dimmer shade of `dim`.
+mkfg TRACK $(( DIM_R*63/100 )) $(( DIM_G*63/100 )) $(( DIM_B*63/100 ))
+SEP="  ${DIM}${SEPARATOR}${RESET}  "
+
+# Color del % de contexto según umbrales.
+if   (( PCT >= T_DANGER )); then PC=$CTXD
+elif (( PCT >= T_WARN   )); then PC=$CTXW
+else                             PC=$GRN
+fi
+
+# ── Carpeta / repo ───────────────────────────────────────────────
+NAME=${CWD%/}; NAME=${NAME##*/}; [ -z "$NAME" ] && NAME="~"
+upcase NAME
+upcase MODEL
+
+# ── Datos de git ────────────────────────────────────────────────
+GIT=0; BRANCH=""; NEWC=0; MODC=0; AHEAD=0; BEHIND=0
+if git -C "$CWD" rev-parse --is-inside-work-tree &>/dev/null; then
+  GIT=1
+  BRANCH=$(git -C "$CWD" branch --show-current 2>/dev/null)
+  [ -z "$BRANCH" ] && BRANCH=$(git -C "$CWD" rev-parse --short HEAD 2>/dev/null)
+  st=$(git -C "$CWD" status --porcelain 2>/dev/null)
+  if [ -n "$st" ]; then
+    NEWC=$(grep -c '^??' <<<"$st")
+    MODC=$(( $(grep -c . <<<"$st") - NEWC ))
+  fi
+  ab=$(git -C "$CWD" rev-list --left-right --count '@{u}...HEAD' 2>/dev/null)
+  if [ -n "$ab" ]; then BEHIND=${ab%%[[:space:]]*}; AHEAD=${ab##*[[:space:]]}; fi
+  upcase BRANCH
+fi
+
+# ── Fragmentos por sección ───────────────────────────────────────
+sec_dir(){ printf '%s%s %s' "$PUR" "$G_REPO" "${RESET}${BOLD}"; grad "$NAME"; }
+sec_git(){
+  (( GIT )) || return
+  printf '%s%s %s%s' "$MAG" "$G_BR" "$BRANCH" "$RESET"
+  local g=""
+  (( NEWC   > 0 )) && g+=" ${AMB}${G_ADD}${NEWC}${RESET}"
+  (( MODC   > 0 )) && g+=" ${CYAN}${G_MOD}${MODC}${RESET}"
+  (( AHEAD  > 0 )) && g+=" ${GRN}${G_AH}${AHEAD}${RESET}"
+  (( BEHIND > 0 )) && g+=" ${AMB}${G_BH}${BEHIND}${RESET}"
+  [ -n "$g" ] && printf '  %s' "${g# }"
+}
+sec_model(){   printf '%s%s %s%s' "${PUR}${BOLD}" "$G_MDL" "$MODEL" "$RESET"; }
+sec_context(){ printf '%sCTX%s ' "$DIM" "$RESET"; ctxbar "$PCT" "$CTXBAR_W"; printf ' %s%s%%%s' "$PC" "$PCT" "$RESET"; }
+sec_cost(){    printf '%s$%.2f%s' "$GRN" "$COST" "$RESET"; }
+sec_tokens(){  printf '%s' "$DIM"; fmtk "$TOK"; printf '%s' "$RESET"; }
+sec_clock(){   printf '%s%s ' "$CYAN" "$G_CLK"; printf "%(${TIME_FMT})T" -1; printf '%s' "$RESET"; }
+
+render_section(){
+  case "$1" in
+    dir)     sec_dir ;;
+    git)     sec_git ;;
+    model)   sec_model ;;
+    context) sec_context ;;
+    cost)    sec_cost ;;
+    tokens)  sec_tokens ;;
+    clock)   sec_clock ;;
+  esac
+}
+
+# Print the given sections (by name) joined with the separator, directly to
+# stdout — no per-section subshell.
+print_group(){
+  local first=1 s
+  for s in "$@"; do
+    (( first )) || printf '%s' "$SEP"
+    first=0
+    render_section "$s"
+  done
+}
+
+# ── Ensamblado según order/enabled + layout ──────────────────────
+declare -A IS_EN; for s in "${ENABLED[@]}"; do IS_EN[$s]=1; done
+
+# Sections to render, in order; git collapses to nothing when not a repo.
+# loc = location group (line 1), met = metrics group (line 3) for multiline.
+visible=(); loc=(); met=()
+for s in "${ORDER[@]}"; do
+  [[ ${IS_EN[$s]:-} ]] || continue
+  [[ $s == git && $GIT -eq 0 ]] && continue
+  visible+=("$s")
+  case "$s" in
+    dir|git) loc+=("$s") ;;
+    *)       met+=("$s") ;;
+  esac
+done
+
+if [[ $LINES_MODE == single ]]; then
+  print_group "${visible[@]}"
+else
+  if (( ${#loc[@]} )); then print_group "${loc[@]}"; printf '\n'; fi
+  horizon "$HORIZON_W"; printf '\n'
+  print_group "${met[@]}"
+fi