estela 0.1.40 → 0.2.1

package/dist/statusline-install.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUR_COMMAND = void 0;
+exports.claudeSettingsPath = claudeSettingsPath;
+exports.isOurs = isOurs;
+exports.shellQuote = shellQuote;
+exports.appendedCommand = appendedCommand;
+exports.planInstall = planInstall;
+exports.planUninstall = planUninstall;
+exports.estelaOnPath = estelaOnPath;
+exports.backupName = backupName;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+/**
+ * `estela statusline install | uninstall`: el bloque `statusLine` de
+ * `~/.claude/settings.json`.
+ *
+ * Ese fichero es de quien usa Claude Code, con sus permisos, sus hooks y sus
+ * plugins. Se toca lo justo: se lee, se cambia una clave y se reescribe el
+ * resto tal cual; antes, una copia. Si ya hay otra status line, no se pisa.
+ *
+ * Funciones puras sobre el texto del fichero: quien llama lee y escribe.
+ */
+exports.OUR_COMMAND = "estela statusline";
+/** Dónde vive la configuración de Claude Code (`CLAUDE_CONFIG_DIR` la mueve). */
+function claudeSettingsPath(env = process.env) {
+    return (0, node_path_1.join)(env["CLAUDE_CONFIG_DIR"] || (0, node_path_1.join)((0, node_os_1.homedir)(), ".claude"), "settings.json");
+}
+function parse(text) {
+    if (text === null || !text.trim())
+        return {};
+    try {
+        const v = JSON.parse(text);
+        return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+function commandOf(statusLine) {
+    if (!statusLine || typeof statusLine !== "object")
+        return null;
+    const c = statusLine["command"];
+    return typeof c === "string" ? c : null;
+}
+function isOurs(command) {
+    return !!command && /(^|[\s/\\])estela(\.cmd)?\s+statusline(\s|$)/.test(command);
+}
+/** Comillas simples de shell: lo que va dentro se pasa tal cual. */
+function shellQuote(text) {
+    return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+/** El comando encadenado dentro de `--append '…'`, si lo hay. */
+function appendedCommand(command) {
+    const m = /--append\s+'((?:[^']|'\\'')*)'\s*$/.exec(command);
+    return m ? m[1].replace(/'\\''/g, "'") : null;
+}
+function write(settings) {
+    return JSON.stringify(settings, null, 2) + "\n";
+}
+function planInstall(text, options = {}) {
+    const settings = parse(text);
+    if (!settings)
+        return { status: "invalid" };
+    const existing = commandOf(settings["statusLine"]);
+    if (existing && isOurs(existing) && !options.force)
+        return { status: "already" };
+    let command = exports.OUR_COMMAND;
+    let status = "installed";
+    if (existing && !isOurs(existing)) {
+        if (options.append) {
+            command = `${exports.OUR_COMMAND} --append ${shellQuote(existing)}`;
+            status = "chained";
+        }
+        else if (options.force)
+            status = "replaced";
+        else
+            return { status: "conflict", existing };
+    }
+    settings["statusLine"] = { type: "command", command, padding: 0 };
+    return { status, text: write(settings), previous: existing };
+}
+function planUninstall(text) {
+    const settings = parse(text);
+    if (!settings)
+        return { status: "invalid" };
+    const existing = commandOf(settings["statusLine"]);
+    if (!existing)
+        return { status: "absent" };
+    if (!isOurs(existing))
+        return { status: "foreign", existing };
+    // Si al instalar se encadenó otra, se devuelve esa: quitar Estela no puede
+    // dejarte sin la status line que ya tenías.
+    const before = appendedCommand(existing);
+    if (before) {
+        settings["statusLine"] = { type: "command", command: before };
+        return { status: "restored", text: write(settings), restored: before };
+    }
+    delete settings["statusLine"];
+    return { status: "removed", text: write(settings), restored: null };
+}
+/** `estela` en el PATH. Con `npx` cada evento tardaría cientos de milisegundos. */
+function estelaOnPath(env = process.env, platform = process.platform) {
+    const names = platform === "win32" ? ["estela.cmd", "estela.exe", "estela"] : ["estela"];
+    return (env["PATH"] ?? "").split(node_path_1.delimiter).filter(Boolean)
+        .some((dir) => names.some((n) => (0, node_fs_1.existsSync)((0, node_path_1.join)(dir, n))));
+}
+/** "settings.json.bak-20261014-161230": una copia por instalación, sin pisar las anteriores. */
+function backupName(path, now = new Date()) {
+    const p = (n) => String(n).padStart(2, "0");
+    return `${path}.bak-${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}-` +
+        `${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
+}
+//# sourceMappingURL=statusline-install.js.map

package/dist/statusline-run.d.ts

@@ -0,0 +1,8 @@
+import { type StatusData, type StatusInput } from "./statusline.js";
+export declare function runStatusline(argv: readonly string[]): Promise<void>;
+/**
+ * Los datos de la línea para un directorio. Sin base de Estela no se crea
+ * ninguna: la status line no es quien debe empezar a guardar datos.
+ */
+export declare function computeStatus(input: StatusInput, dbPath: string, now: Date): StatusData;
+//# sourceMappingURL=statusline-run.d.ts.map

package/dist/statusline-run.js

@@ -0,0 +1,256 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStatusline = runStatusline;
+exports.computeStatus = computeStatus;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const sessionize_js_1 = require("./billing/sessionize.js");
+const schema_js_1 = require("./db/schema.js");
+const store = __importStar(require("./db/store.js"));
+const quota_js_1 = require("./metrics/quota.js");
+const paths_js_1 = require("./paths.js");
+const project_of_js_1 = require("./project-of.js");
+const statusline_cache_js_1 = require("./statusline-cache.js");
+const statusline_js_1 = require("./statusline.js");
+const claude_js_1 = require("./watchers/claude.js");
+async function runStatusline(argv) {
+    try {
+        const flags = parseFlags(argv);
+        const text = await readStdin();
+        const input = text.trim() ? (0, statusline_js_1.parseStatusInput)(text) : manualInput();
+        const extra = flags.append ? runAppended(flags.append, text) : null;
+        const reserved = extra ? (0, statusline_js_1.stripAnsi)(extra).length + 3 : 0;
+        const columns = Number(process.env["COLUMNS"]) || null;
+        const now = new Date();
+        if (input.fiveHourResetsAt) {
+            try {
+                (0, statusline_cache_js_1.recordFiveHourReset)(flags.db, input.fiveHourResetsAt, now);
+            }
+            catch { /* es una caché */ }
+        }
+        const data = computeStatus(input, flags.db, now);
+        const ours = (0, statusline_js_1.renderStatus)(data, { columns, color: flags.color, reserved });
+        process.stdout.write((extra ? `${ours}${flags.color ? "\x1b[90m | \x1b[0m" : " | "}${extra}` : ours) + "\n");
+    }
+    catch {
+        process.stdout.write("estela\n");
+    }
+    process.exitCode = 0;
+}
+function parseFlags(argv) {
+    const value = (name) => {
+        const i = argv.indexOf(`--${name}`);
+        return i >= 0 && i + 1 < argv.length ? argv[i + 1] : null;
+    };
+    return {
+        db: value("db") ?? schema_js_1.DEFAULT_DB_PATH,
+        color: !argv.includes("--no-color") && !process.env["NO_COLOR"],
+        append: value("append"),
+    };
+}
+/** Ejecutado a mano en una terminal, sin nada por stdin: el directorio actual. */
+function manualInput() {
+    return { dir: process.cwd(), transcriptPath: null, fiveHour: null, sevenDay: null, fiveHourResetsAt: null };
+}
+function readStdin() {
+    if (process.stdin.isTTY)
+        return Promise.resolve("");
+    return new Promise((resolve) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", (chunk) => { data += chunk; });
+        process.stdin.on("end", () => resolve(data));
+        process.stdin.on("error", () => resolve(data));
+    });
+}
+/**
+ * Otra status line encadenada (la que había antes de instalar la de Estela).
+ * Recibe el mismo stdin. Si tarda o falla, se enseña solo la nuestra.
+ */
+function runAppended(command, stdin) {
+    try {
+        const r = (0, node_child_process_1.spawnSync)(command, { shell: true, input: stdin, encoding: "utf8", timeout: 1500 });
+        const line = (r.stdout ?? "").split("\n")[0]?.trimEnd();
+        return line ? line : null;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+/**
+ * Los datos de la línea para un directorio. Sin base de Estela no se crea
+ * ninguna: la status line no es quien debe empezar a guardar datos.
+ */
+function computeStatus(input, dbPath, now) {
+    const sinProyecto = (root) => ({
+        project: null, unassignedRoot: root, todaySeconds: 0, projectShare: null,
+        fiveHour: input.fiveHour, sevenDay: input.sevenDay
+    });
+    if (!input.dir)
+        return sinProyecto(null);
+    if (!(0, node_fs_1.existsSync)(dbPath)) {
+        const root = (0, project_of_js_1.gitRoot)(input.dir);
+        return sinProyecto(root ? (0, project_of_js_1.folderName)(root) : null);
+    }
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        // Si `import` o el panel están escribiendo, se espera muy poco y se sigue.
+        db.exec("PRAGMA busy_timeout = 50");
+        const dir = (0, paths_js_1.normalizePath)(input.dir);
+        // La carpeta, y si no, su raíz git (worktrees, subcarpetas): ver project-of.ts.
+        const ownerOf = (0, project_of_js_1.ownerResolver)(db);
+        const owner = ownerOf(dir);
+        if (owner.kind !== "project")
+            return sinProyecto(owner.kind === "folder" && owner.inGit ? owner.name : null);
+        const projectId = owner.projectId;
+        const project = store.getProject(db, projectId);
+        if (!project)
+            return sinProyecto(null);
+        const client = project.kind === "client" ? store.getClient(db, project.clientId) : null;
+        const fresh = input.transcriptPath ? readNewTurns(db, dbPath, input.transcriptPath, dir) : [];
+        const projectOf = (repo) => {
+            const o = ownerOf(repo);
+            return o.kind === "project" ? o.projectId : null;
+        };
+        // Horas medidas de hoy: lo mismo que hace `import` — sessionize y luego
+        // la unión de intervalos por proyecto, día y rama — sobre los turnos de
+        // hoy de este proyecto. Solo medidas: nada estimado ni anotado a mano.
+        const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        const todayTurns = merge(store.turnsBetween(db, today, new Date(now.getTime() + 1)), fresh, today, now)
+            .filter((t) => projectOf(t.repoPath) === projectId);
+        const blocks = (0, sessionize_js_1.groupByBranchAndDay)((0, sessionize_js_1.sessionize)(todayTurns), () => projectId);
+        const todaySeconds = blocks.reduce((s, b) => s + b.seconds, 0);
+        // Parte de la semana: la misma suma de tokens que `estela quota`, solo de
+        // Claude Code (Codex gasta otra cuota).
+        const monday = (0, quota_js_1.weekStart)(now);
+        const week = merge(store.turnsBetween(db, monday, new Date(now.getTime() + 1)), fresh, monday, now)
+            .filter((t) => t.agent === "claude-code");
+        const bucketOf = (repo) => {
+            const p = projectOf(repo);
+            return p ? { kind: "project", projectId: p, projectName: p } : { kind: "none" };
+        };
+        const split = (0, quota_js_1.breakdown)(week, monday, new Date(now.getTime() + 1), bucketOf);
+        const row = split.rows.find((r) => r.bucket.kind === "project" && r.bucket.projectId === projectId);
+        const projectShare = split.total.total > 0 ? (row?.share ?? 0) : null;
+        return {
+            project: { name: project.name, client: client?.name ?? null },
+            todaySeconds, projectShare, fiveHour: input.fiveHour, sevenDay: input.sevenDay,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+/** Los turnos guardados más los recién leídos, sin repetir y dentro del rango. */
+function merge(saved, fresh, from, to) {
+    const seen = new Set(saved.map((t) => t.turnId));
+    return [...saved, ...fresh.filter((t) => !seen.has(t.turnId) && t.at >= from && t.at <= to)]
+        .sort((a, b) => a.at.getTime() - b.at.getTime());
+}
+// ---------------------------------------------------------------------------
+// Lectura incremental del transcript de la sesión
+// ---------------------------------------------------------------------------
+/** Lo más que se lee de un transcript que se ve por primera vez. */
+const FIRST_READ_BYTES = 4 * 1024 * 1024;
+/**
+ * Lee solo lo nuevo del transcript de esta sesión desde la última vez, y lo
+ * guarda en la base.
+ *
+ *  - Se avanza hasta el último salto de línea: Claude Code puede estar
+ *    escribiendo la última, y una línea a medias se leerá entera la próxima.
+ *  - Si el fichero encoge, se empieza de nuevo.
+ *  - La primera vez se leen como mucho los últimos 4 MB: el resto ya lo trajo
+ *    `import`, y una sesión larga no puede costar segundos.
+ *  - `INSERT OR IGNORE` sobre el `turn_id`: el siguiente `import` no duplica.
+ *  - Un turno de scratchpad que no se pudo devolver a su repositorio NO se
+ *    guarda: con esa ruta se quedaría así para siempre, porque el `import`
+ *    que sí sabría devolverlo ya no podría reescribirlo.
+ */
+function readNewTurns(db, dbPath, file, dir) {
+    const cache = (0, statusline_cache_js_1.loadCache)(dbPath);
+    const entry = cache.files[file];
+    let fd;
+    try {
+        fd = (0, node_fs_1.openSync)(file, "r");
+    }
+    catch {
+        return [];
+    }
+    try {
+        const size = (0, node_fs_1.fstatSync)(fd).size;
+        let start = entry && entry.offset <= size ? entry.offset : Math.max(0, size - FIRST_READ_BYTES);
+        const midFile = !entry && start > 0;
+        if (start >= size) {
+            cache.files[file] = { offset: size, seenAt: new Date().toISOString() };
+            (0, statusline_cache_js_1.saveCache)(dbPath, cache);
+            return [];
+        }
+        const buf = Buffer.alloc(size - start);
+        (0, node_fs_1.readSync)(fd, buf, 0, buf.length, start);
+        const lastNl = buf.lastIndexOf(0x0a);
+        if (lastNl < 0)
+            return [];
+        let text = buf.subarray(0, lastNl + 1).toString("utf8");
+        // Empezando a mitad de fichero, la primera línea casi seguro está cortada.
+        if (midFile)
+            text = text.slice(text.indexOf("\n") + 1);
+        const byId = new Map();
+        for (const line of text.split("\n")) {
+            const t = (0, claude_js_1.parseTranscriptLine)(line);
+            if (t && typeof t === "object" && !byId.has(t.turnId))
+                byId.set(t.turnId, t);
+        }
+        const known = [...store.allProjectRepoPaths(db), dir];
+        const turns = (0, claude_js_1.resolveScratchpads)([...byId.values()], known)
+            .filter((t) => !t.repoPath || !(0, claude_js_1.isScratchpad)(t.repoPath));
+        try {
+            store.saveTurns(db, turns);
+            start += lastNl + 1;
+            cache.files[file] = { offset: start, seenAt: new Date().toISOString() };
+            (0, statusline_cache_js_1.saveCache)(dbPath, cache);
+        }
+        catch {
+            // Base ocupada: no se avanza, para volver a intentarlo. Los turnos sirven
+            // igual para esta línea, desde la memoria.
+        }
+        return turns;
+    }
+    finally {
+        (0, node_fs_1.closeSync)(fd);
+    }
+}
+//# sourceMappingURL=statusline-run.js.map

package/dist/statusline.d.ts

@@ -0,0 +1,71 @@
+/**
+ * `estela statusline`: la línea que Claude Code pinta bajo cada sesión.
+ *
+ * Funciones puras, sin disco ni base de datos: qué llega por stdin, qué se
+ * enseña y cómo se recorta. Lo que lee datos vive en `statusline-run.ts`.
+ *
+ * La regla de siempre: nada de "te queda X" ni cuentas atrás. Los porcentajes
+ * de límite son los que manda Claude Code (`rate_limits`), tal cual; si no
+ * los manda, no se enseña nada de límites. Estela no estima ninguno.
+ */
+/** Lo que interesa del JSON que Claude Code pasa por stdin. Todo opcional. */
+export interface StatusInput {
+    readonly dir: string | null;
+    readonly transcriptPath: string | null;
+    /** 0–100, de `rate_limits.five_hour.used_percentage`. */
+    readonly fiveHour: number | null;
+    /** 0–100, de `rate_limits.seven_day.used_percentage`. */
+    readonly sevenDay: number | null;
+    /**
+     * `rate_limits.five_hour.resets_at`. No se enseña nunca (nada de cuentas
+     * atrás): se guarda para que `estela quota` sepa dónde empieza la ventana.
+     */
+    readonly fiveHourResetsAt?: Date | null;
+}
+/**
+ * Lee la entrada. Lanza si no es un objeto JSON: quien llama imprime
+ * "estela" y sale con 0, que es lo que hay que hacer con una entrada rota.
+ */
+export declare function parseStatusInput(text: string): StatusInput;
+/** Lo que se sabe del proyecto del directorio actual. */
+export interface StatusData {
+    /** null: el directorio no es de ningún proyecto de Estela. */
+    readonly project: {
+        readonly name: string;
+        readonly client: string | null;
+    } | null;
+    /**
+     * Sin proyecto: el nombre de la raíz git de la carpeta, para decir cuál
+     * es. null si está fuera de git.
+     */
+    readonly unassignedRoot?: string | null;
+    /** Horas medidas hoy en este proyecto. */
+    readonly todaySeconds: number;
+    /** Parte de los tokens de Claude Code de esta semana que son de este proyecto (0–1), o null si no hubo consumo. */
+    readonly projectShare: number | null;
+    readonly fiveHour: number | null;
+    readonly sevenDay: number | null;
+}
+export interface RenderOptions {
+    /** Ancho del terminal (`COLUMNS`). Sin él, no se recorta. */
+    readonly columns?: number | null;
+    readonly color?: boolean;
+    /** Ancho que ya ocupa otra status line encadenada con --append. */
+    readonly reserved?: number;
+}
+/** Desde qué porcentaje la ventana de 5 h se pinta en ámbar. */
+export declare const FIVE_HOUR_WARN = 80;
+/** "2h14", "3h", "45m": corto, que la línea es estrecha. */
+export declare function compactDuration(seconds: number): string;
+/**
+ * La línea, ya recortada al ancho.
+ *
+ * Orden visual: estela · nombre · hoy · este proyecto · semana · 5 h.
+ * Lo que se quita si no cabe, en este orden: la 5 h, la semana, el nombre se
+ * queda en el cliente y luego se acorta con "…", "este proyecto" y "hoy".
+ * "estela" no se quita nunca: es lo que anuncia la herramienta en cada captura.
+ */
+export declare function renderStatus(data: StatusData, options?: RenderOptions): string;
+/** Lo visible de una cadena con color: para medir y para los tests. */
+export declare function stripAnsi(text: string): string;
+//# sourceMappingURL=statusline.d.ts.map

package/dist/statusline.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIVE_HOUR_WARN = void 0;
+exports.parseStatusInput = parseStatusInput;
+exports.compactDuration = compactDuration;
+exports.renderStatus = renderStatus;
+exports.stripAnsi = stripAnsi;
+const index_js_1 = require("./i18n/index.js");
+/**
+ * Lee la entrada. Lanza si no es un objeto JSON: quien llama imprime
+ * "estela" y sale con 0, que es lo que hay que hacer con una entrada rota.
+ */
+function parseStatusInput(text) {
+    const raw = JSON.parse(text);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new Error("bad-input");
+    const o = raw;
+    const ws = obj(o["workspace"]);
+    const limits = obj(o["rate_limits"]);
+    return {
+        dir: str(ws["project_dir"]) ?? str(ws["current_dir"]) ?? str(o["cwd"]),
+        transcriptPath: str(o["transcript_path"]),
+        fiveHour: pct(obj(limits["five_hour"])["used_percentage"]),
+        sevenDay: pct(obj(limits["seven_day"])["used_percentage"]),
+        fiveHourResetsAt: epoch(obj(limits["five_hour"])["resets_at"]),
+    };
+}
+/** Segundos desde 1970 (lo que manda Claude Code); por si acaso, también milisegundos. */
+function epoch(v) {
+    if (typeof v !== "number" || !Number.isFinite(v) || v <= 0)
+        return null;
+    return new Date(v > 1e12 ? v : v * 1000);
+}
+function obj(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+}
+function str(v) {
+    return typeof v === "string" && v ? v : null;
+}
+function pct(v) {
+    return typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.min(v, 100) : null;
+}
+/** Desde qué porcentaje la ventana de 5 h se pinta en ámbar. */
+exports.FIVE_HOUR_WARN = 80;
+const SEP = " · ";
+const ESC = "\x1b[";
+const JADE = `${ESC}38;2;70;192;167m`; // #46C0A7
+const GRAY = `${ESC}90m`;
+const AMBER = `${ESC}38;2;221;168;90m`; // el ámbar del panel en modo oscuro
+const RESET = `${ESC}0m`;
+/** "2h14", "3h", "45m": corto, que la línea es estrecha. */
+function compactDuration(seconds) {
+    const total = Math.round(seconds / 60);
+    const h = Math.floor(total / 60), m = total % 60;
+    if (h === 0)
+        return `${m}m`;
+    return m === 0 ? `${h}h` : `${h}h${String(m).padStart(2, "0")}`;
+}
+/**
+ * La línea, ya recortada al ancho.
+ *
+ * Orden visual: estela · nombre · hoy · este proyecto · semana · 5 h.
+ * Lo que se quita si no cabe, en este orden: la 5 h, la semana, el nombre se
+ * queda en el cliente y luego se acorta con "…", "este proyecto" y "hoy".
+ * "estela" no se quita nunca: es lo que anuncia la herramienta en cada captura.
+ */
+function renderStatus(data, options = {}) {
+    const color = options.color !== false;
+    const paint = (c, t) => (color ? `${c}${t}${RESET}` : t);
+    const width = options.columns && options.columns > 0
+        ? Math.max(0, options.columns - (options.reserved ?? 0)) : Infinity;
+    const line = (shown, kept) => paint(JADE, "estela") + paint(GRAY, SEP + shown) +
+        kept.map((x) => paint(GRAY, SEP) + paint(x.warn ? AMBER : GRAY, x.text)).join("");
+    const tailOf = (kept) => kept.map((x) => SEP + x.text).join("").length;
+    if (!data.project) {
+        // "estela · web (sin proyecto) · semana 38 % · 5 h 62 % · estela setup".
+        // Fuera de git no hay nombre que dar ni nada que configurar ahí, así que
+        // sin raíz y sin pista: "estela · sin proyecto · semana 38 % · 5 h 62 %".
+        // Se recorta la pista, luego 5 h y semana, y por último se acorta la raíz.
+        const root = data.unassignedRoot ?? null;
+        const segs = [...limitSegments(data), ...(root ? [{ key: "hint", text: "estela setup" }] : [])];
+        const steps = [[], ["hint"], ["hint", "fiveHour"], ["hint", "fiveHour", "week"]];
+        for (const drop of steps) {
+            const kept = segs.filter((x) => !drop.includes(x.key));
+            const shown = root ? (0, index_js_1.tr) `${root} (sin proyecto)` : (0, index_js_1.tr) `sin proyecto`;
+            if ("estela".length + SEP.length + shown.length + tailOf(kept) <= width)
+                return line(shown, kept);
+        }
+        if (root) {
+            const room = width - "estela".length - SEP.length - (0, index_js_1.tr) `${""} (sin proyecto)`.length;
+            if (room >= 2)
+                return line((0, index_js_1.tr) `${root.slice(0, room - 1).trimEnd() + "…"} (sin proyecto)`, []);
+        }
+        return paint(JADE, "estela");
+    }
+    const segs = [{ key: "today", text: (0, index_js_1.tr) `hoy ${compactDuration(data.todaySeconds)}` }];
+    if (data.projectShare !== null)
+        segs.push({ key: "project", text: (0, index_js_1.tr) `este proyecto ${Math.round(data.projectShare * 100)} %` });
+    segs.push(...limitSegments(data));
+    const { name, client } = data.project;
+    const full = client ? `${client} › ${name}` : name;
+    const short = client ?? name;
+    const steps = [
+        { drop: [], name: "full" },
+        { drop: ["fiveHour"], name: "full" },
+        { drop: ["fiveHour", "week"], name: "full" },
+        { drop: ["fiveHour", "week"], name: "short" },
+        { drop: ["fiveHour", "week"], name: "trunc", min: 6 },
+        { drop: ["fiveHour", "week", "project"], name: "trunc", min: 6 },
+        { drop: ["fiveHour", "week", "project", "today"], name: "trunc", min: 2 },
+    ];
+    for (const step of steps) {
+        const kept = segs.filter((s) => !step.drop.includes(s.key));
+        const tail = kept.map((s) => SEP + s.text).join("");
+        const fixed = "estela".length + SEP.length + tail.length;
+        let shown;
+        if (step.name === "full")
+            shown = full;
+        else if (step.name === "short")
+            shown = short;
+        else {
+            const room = width - fixed;
+            if (room < (step.min ?? 1))
+                continue;
+            shown = short.length <= room ? short : short.slice(0, Math.max(0, room - 1)).trimEnd() + "…";
+        }
+        if (fixed + shown.length > width)
+            continue;
+        return line(shown, kept);
+    }
+    return paint(JADE, "estela");
+}
+/**
+ * Los porcentajes de límite que manda Claude Code, tal cual: semana y 5 h, la
+ * de 5 h en ámbar desde el 80 %. Sin rate_limits, ninguno. Los comparten la
+ * línea con proyecto y la de sin proyecto.
+ */
+function limitSegments(data) {
+    const out = [];
+    if (data.sevenDay !== null)
+        out.push({ key: "week", text: (0, index_js_1.tr) `semana ${Math.round(data.sevenDay)} %` });
+    if (data.fiveHour !== null) {
+        out.push({ key: "fiveHour", text: (0, index_js_1.tr) `5 h ${Math.round(data.fiveHour)} %`, warn: data.fiveHour >= exports.FIVE_HOUR_WARN });
+    }
+    return out;
+}
+/** Lo visible de una cadena con color: para medir y para los tests. */
+function stripAnsi(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+//# sourceMappingURL=statusline.js.map

package/dist/watchers/claude.d.ts

@@ -12,6 +12,13 @@ export interface ScanResult {
     readonly report: ParseReport;
 }
 export declare function scanClaudeCode(options?: ScanOptions): Promise<ScanResult>;
+/**
+ * Una línea del transcript: un turno, `"other"` si es de otro tipo (maquinaria
+ * interna que se ignora), `"malformed"` si no se entiende, o null si está en
+ * blanco. Es lo que usan tanto el escaneo completo como `estela statusline`,
+ * que lee solo las líneas nuevas: los dos tienen que entender lo mismo.
+ */
+export declare function parseTranscriptLine(line: string): AgentTurn | "other" | "malformed" | null;
 /**
  * Devuelve al repositorio de origen los turnos ocurridos en un scratchpad.
  *
@@ -30,5 +37,8 @@ export declare function scanClaudeCode(options?: ScanOptions): Promise<ScanResul
  * es generar ese mismo identificador para cada repositorio conocido y ver cuál
  * coincide.
  */
-export declare function resolveScratchpads(turns: readonly AgentTurn[]): AgentTurn[];
+export declare function resolveScratchpads(turns: readonly AgentTurn[], 
+/** Repositorios ya conocidos, para cuando el lote no trae la ruta real (la status line lee pocas líneas). */
+knownRepos?: readonly string[]): AgentTurn[];
+export declare function isScratchpad(path: string): boolean;
 //# sourceMappingURL=claude.d.ts.map