estela 0.1.39 → 0.2.0

package/dist/cli.js

@@ -36,6 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.breakdownOfTurn = void 0;
 const node_path_1 = require("node:path");
+const node_readline_1 = require("node:readline");
 // `node:sqlite` avisa de que es experimental en cada arranque. Es ruido para
 // quien solo quiere su factura, y el aviso no le dice nada accionable.
 process.removeAllListeners("warning");
@@ -75,6 +76,11 @@ const agents_js_1 = require("./watchers/agents.js");
 const git_js_1 = require("./watchers/git.js");
 const identity_js_1 = require("./watchers/identity.js");
 const index_js_1 = require("./i18n/index.js");
+const dates_js_1 = require("./export/dates.js");
+const quota_js_1 = require("./metrics/quota.js");
+const quota_js_2 = require("./quota.js");
+const assign_js_1 = require("./billing/assign.js");
+const statusline_install_js_1 = require("./statusline-install.js");
 const labels_js_1 = require("./i18n/labels.js");
 const HELP_ES = `
 estela — registro de horas para desarrollo asistido por IA
@@ -83,8 +89,12 @@ estela — registro de horas para desarrollo asistido por IA
         Primera ejecución: detecta tus agentes y repositorios, y reconstruye
         tu historial. Dos minutos, sin preguntas y sin cuenta.
 
-  estela import [--since YYYY-MM-DD] [--repo <ruta>]
+  estela import [--since YYYY-MM-DD] [--repo <ruta>] [--yes]
         Reconstruye tu historial desde los transcripts de los agentes y git.
+        Una sesión en una subcarpeta o en un worktree cuenta para el
+        proyecto de su repo. La primera vez que eso suma horas a lo ya
+        importado, te enseña cuántas y pregunta (--yes no pregunta). Nunca
+        mueve horas de un proyecto a otro ni toca un día aprobado.
 
   estela client add --id <id> --name <nombre> --currency <EUR|USD|...>
                     [--tax-id <NIF/CIF>] [--email <a@b.com>]
@@ -143,6 +153,32 @@ estela — registro de horas para desarrollo asistido por IA
   estela entry link --entry <id> --items PROJ-12[,AB#1234] | --clear
         Pone a mano los tickets de un bloque. El import ya no los cambia.
   estela ai-cost                      Reparto de tu cuota entre proyectos.
+  estela quota [--json] [--no-refresh] [--weighted]
+        ¿Qué proyecto se come tu cuota de Claude Code o Codex? Tokens por
+        proyecto en la ventana de 5 h actual y en la semana (de lunes a
+        hoy), y esta semana frente a la media de tus 4 anteriores en el
+        mismo tramo. Solo consumo real: no dice cuánto te queda, porque
+        Anthropic y OpenAI no publican los límites. La ventana de 5 h es
+        una estimación: no se sabe cómo redondean su inicio, y lo que uses
+        en claude.ai u otro equipo también cuenta y Estela no lo ve.
+        Si la status line de Estela está instalada, la ventana de Claude
+        Code es la que da Claude Code, no una estimación. Una sesión en un
+        worktree o en una subcarpeta cuenta para el proyecto de su repo.
+        --weighted reparte el % por precio de lista del modelo en vez de
+        por tokens (no es cómo el proveedor cuenta tu límite).
+        Copilot queda fuera: no guarda tokens fiables. Antes de calcular
+        lee los transcripts desde el lunes (--no-refresh lo evita).
+        A diferencia de ai-cost, que reparte dinero, esto reparte tokens.
+  estela statusline install [--force | --append]
+        Una línea bajo cada sesión de Claude Code: proyecto, horas medidas
+        hoy, la parte de tu consumo de la semana que es de este proyecto y,
+        si Claude Code los manda, sus porcentajes de límite de la semana y
+        de 5 h (tal cual, sin estimar nada). Se calcula en tu máquina en
+        unos 50 ms. Añade el bloque a ~/.claude/settings.json sin tocar lo
+        demás, y antes deja una copia. Si ya tienes otra status line no la
+        pisa: --force la sustituye y --append la encadena detrás.
+  estela statusline uninstall
+        La quita. Si la instalaste con --append, deja la que tenías.
   estela badge [--project <id>]
         Badge para el README: horas medidas y coste de IA del proyecto.
         Sin --project, el del repositorio en el que estás.
@@ -242,8 +278,12 @@ estela — time tracking for AI-assisted development
         First run: detects your agents and repositories, and rebuilds your
         history. Two minutes, no questions, no account.
 
-  estela import [--since YYYY-MM-DD] [--repo <path>]
-        Rebuilds your history from agent transcripts and git.
+  estela import [--since YYYY-MM-DD] [--repo <path>] [--yes]
+        Rebuilds your history from agent transcripts and git. A session in a
+        subfolder or a worktree counts for its repo's project. The first
+        time that adds hours to what was already imported, it shows how many
+        and asks (--yes skips the question). It never moves hours from one
+        project to another or touches an approved day.
 
   estela client add --id <id> --name <name> --currency <EUR|USD|...>
                     [--tax-id <tax ID>] [--email <a@b.com>]
@@ -302,6 +342,34 @@ estela — time tracking for AI-assisted development
   estela entry link --entry <id> --items PROJ-12[,AB#1234] | --clear
         Sets a block's tickets by hand. Imports won't change them anymore.
   estela ai-cost                      How your subscription splits across projects.
+  estela quota [--json] [--no-refresh] [--weighted]
+        Which project is eating your Claude Code or Codex quota? Tokens per
+        project in the current 5-hour window and this week (Monday to
+        today), and this week against the average of your previous 4 over
+        the same stretch. Real usage only: it never says how much you have
+        left, because Anthropic and OpenAI don't publish the limits. The
+        5-hour window is an estimate: how its start is rounded isn't public,
+        and anything you use on claude.ai or another machine also counts and
+        Estela can't see it. With Estela's status line installed, the
+        Claude Code window is the one Claude Code reports, not an estimate.
+        A session in a worktree or a subfolder counts for its repo's
+        project. --weighted splits the % by the model's list price instead
+        of by tokens (not how the provider counts your limit). Copilot is
+        left out: it doesn't record reliable tokens. Before calculating it reads transcripts since Monday
+        (--no-refresh skips that). Unlike ai-cost, which splits money, this
+        splits tokens.
+  estela statusline install [--force | --append]
+        A line under every Claude Code session: project, hours measured
+        today, this project's share of your usage this week and, if Claude
+        Code sends them, its weekly and 5-hour limit percentages (as they
+        come, nothing estimated). Calculated on your machine in about
+        50 ms. It adds the block to ~/.claude/settings.json without touching
+        anything else, after making a backup. If you already have another
+        status line it won't overwrite it: --force replaces it and --append
+        chains it after Estela's.
+  estela statusline uninstall
+        Removes it. If you installed it with --append, your previous one
+        is put back.
   estela badge [--project <id>]
         Badge for your README: the project's measured hours and AI cost.
         Without --project, the one for the repository you're in.
@@ -661,6 +729,41 @@ async function cmdSetup(args, dbPath) {
         db.close();
     }
 }
+/** La vista previa de la primera recuperación: horas por proyecto. */
+function printRecoveryPreview(db, plan) {
+    console.log((0, index_js_1.tr) `\nEstela ahora reconoce las sesiones en subcarpetas y worktrees de un repositorio.`);
+    console.log((0, index_js_1.tr) `Estas horas no estaban imputadas y se sumarían a su proyecto:\n`);
+    for (const [projectId, seconds] of [...plan.recovered].sort((a, b) => b[1] - a[1])) {
+        const name = store.getProject(db, projectId)?.name ?? projectId;
+        console.log(`  ${name.padEnd(30)} +${(0, shared_1.formatDuration)(seconds)}`);
+    }
+    console.log((0, index_js_1.tr) `\n  Nada de lo ya imputado cambia de proyecto, y los días aprobados no se tocan.`);
+    printRecoveryBlocked(db, plan.blocked);
+    console.log("");
+}
+/** Lo que se recuperaría en días aprobados o facturados: se avisa, no se aplica. */
+function printRecoveryBlocked(db, blocked) {
+    if (blocked.length === 0)
+        return;
+    console.log((0, index_js_1.tr) `\n  Sin tocar, porque ese día ya está aprobado o facturado:`);
+    for (const b of [...blocked].sort((x, y) => x.day.localeCompare(y.day))) {
+        const name = store.getProject(db, b.projectId)?.name ?? b.projectId;
+        console.log((0, index_js_1.tr) `    ${b.day} · ${name}: ${(0, shared_1.formatDuration)(b.seconds)} recuperables. Revísalo con: estela entries --project ${b.projectId}`);
+    }
+}
+/** Una pregunta de sí o no. Sin terminal (un script, CI) la respuesta es no. */
+async function confirm(question) {
+    if (!process.stdin.isTTY)
+        return false;
+    const rl = (0, node_readline_1.createInterface)({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await new Promise((res) => rl.question(question, res))).trim().toLowerCase();
+        return ["s", "si", "sí", "y", "yes"].includes(answer);
+    }
+    finally {
+        rl.close();
+    }
+}
 /**
  * La estrella se pide una vez, al terminar bien el primer setup: es cuando se
  * acaba de ver funcionar. Casi todo el que instala lo hace por npm y nunca
@@ -754,57 +857,54 @@ async function cmdImport(args, dbPath) {
         const fromAgents = (0, sessionize_js_1.attachCommits)((0, sessionize_js_1.sessionize)(turns), commitsAll);
         const fromCommits = (0, sessionize_js_1.withoutOverlap)((0, sessionize_js_1.sessionizeCommits)(commitsAll), fromAgents);
         const raw = [...fromAgents, ...fromCommits];
-        // Se agrupa por PROYECTO, no por ruta: el agente abierto en `repo/` y en
-        // `repo/src/UI` son dos rutas del mismo proyecto, y agrupar por ruta
-        // producía dos bloques que luego se pisaban al guardarse con el mismo id.
-        const porProyecto = (b) => (b.repoPath ? store.projectForRepo(db, b.repoPath) ?? b.repoPath : "");
-        const blocks = (0, sessionize_js_1.groupByBranchAndDay)(raw, porProyecto);
         if (fromCommits.length) {
             console.log((0, index_js_1.tr) `  ${fromCommits.length} bloques deducidos solo de commits (sin agente)`);
         }
-        let entries = 0;
-        let unassigned = 0;
-        for (const block of blocks) {
-            const projectId = block.repoPath ? store.projectForRepo(db, block.repoPath) : null;
-            if (!projectId) {
-                unassigned++;
-                continue;
+        // Horas de sesiones en subcarpetas y worktrees, que antes se quedaban sin
+        // proyecto (ver billing/assign.ts). La primera vez que cambian horas ya
+        // importadas se enseñan antes y se pide confirmación; en una base nueva no
+        // hay nada que cambiar, así que se aplica sin preguntar.
+        const marca = (0, node_path_1.join)((0, node_path_1.dirname)(dbPath), ".recover-git-root");
+        const habiaHoras = db.prepare("SELECT COUNT(*) AS n FROM time_entries").get().n > 0;
+        let plan = (0, assign_js_1.planEntries)(db, raw, { recover: true });
+        const conRaiz = plan;
+        const recuperable = [...plan.recovered.values()].reduce((a, b) => a + b, 0);
+        if (!(0, node_fs_1.existsSync)(marca) && habiaHoras && recuperable > 0) {
+            printRecoveryPreview(db, plan);
+            const ok = args.flags["yes"] === true || await confirm((0, index_js_1.tr) `¿Imputar estas horas? [s/N] `);
+            if (!ok) {
+                plan = (0, assign_js_1.planEntries)(db, raw, { recover: false });
+                console.log((0, index_js_1.tr) `  No se ha tocado nada. Cuando quieras: estela import --yes\n`);
             }
-            const project = store.getProject(db, projectId);
-            const entry = {
-                projectId,
-                startedAt: block.startedAt,
-                endedAt: block.endedAt,
-                seconds: block.seconds,
-                description: (0, sessionize_js_1.describeBlock)(block),
-                billable: project.billable,
-                invoiceId: null,
-                aiCost: block.aiCost,
-                // Un bloque deducido solo de commits no tuvo agente: ni segundos de
-                // agente ni agente al que atribuirlos.
-                agentSeconds: block.turnCount > 0 ? block.seconds : 0,
-                commitHashes: block.commits.map((c) => c.hash),
-                agents: block.turnCount > 0 ? [...(block.agents ?? ["claude-code"])] : [],
-                source: block.turnCount > 0 ? "agent" : "commit",
-                kind: "development",
-                branch: block.branch,
-                // El ticket se saca aquí y no más tarde: en la base solo quedan los
-                // hashes de los commits, y es en sus mensajes donde va el `AB#1234`.
-                workItems: (0, shared_1.extractWorkItems)(block.branch, block.commits.map((c) => c.subject), project.tracker),
-            };
-            // El id es determinista (proyecto + día + rama) para que reimportar
-            // actualice la imputación en vez de duplicarla. La fecha tiene que ser la
-            // LOCAL y la misma que usa el servidor: con toISOString() se generaba un
-            // id distinto para el mismo bloque y el día se contaba dos veces.
-            const day = (0, shared_1.localDate)(block.startedAt);
-            const slug = (block.branch ?? "sin-rama").replace(/[^a-zA-Z0-9]+/g, "-");
-            store.saveTimeEntry(db, { ...entry, id: `te_${projectId}_${day}_${slug}` });
-            entries++;
-        }
-        console.log((0, index_js_1.tr) `Bloques: ${raw.length} detectados → ${blocks.length} tras agrupar por rama y día · ` +
+            else {
+                (0, node_fs_1.writeFileSync)(marca, new Date().toISOString());
+            }
+        }
+        else {
+            try {
+                (0, node_fs_1.writeFileSync)(marca, new Date().toISOString());
+            }
+            catch { /* sin marca, se volverá a preguntar */ }
+        }
+        for (const { entry } of plan.entries)
+            store.saveTimeEntry(db, entry);
+        const entries = plan.entries.length;
+        const unassigned = plan.unassigned;
+        console.log((0, index_js_1.tr) `Bloques: ${raw.length} detectados → ${plan.grouped} tras agrupar por rama y día · ` +
             (0, index_js_1.tr) `${entries} imputados · ${unassigned} sin proyecto`);
-        if (unassigned > 0) {
-            console.log((0, index_js_1.tr) `\nHay ${unassigned} bloques sin proyecto asignado. Regístralos con:`);
+        const aplicadas = [...plan.recovered.values()].reduce((a, b) => a + b, 0);
+        if (aplicadas > 0 && (0, node_fs_1.existsSync)(marca)) {
+            console.log((0, index_js_1.tr) `  ${(0, shared_1.formatDuration)(aplicadas)} recuperadas de sesiones en subcarpetas y worktrees`);
+        }
+        printRecoveryBlocked(db, plan.blocked);
+        // Si no se confirmó, parte de "sin proyecto" son sesiones de subcarpetas y
+        // worktrees: a esas no les falta registrarse, les falta el --yes.
+        const porRaiz = unassigned - conRaiz.unassigned;
+        if (porRaiz > 0) {
+            console.log((0, index_js_1.tr) `\n${porRaiz} de esos bloques son de subcarpetas o worktrees de un proyecto: estela import --yes los imputa.`);
+        }
+        if (unassigned - porRaiz > 0) {
+            console.log((0, index_js_1.tr) `\nHay ${unassigned - porRaiz} bloques sin proyecto asignado. Regístralos con:`);
             console.log((0, index_js_1.tr) `  estela project add --id <id> --client <id> --name <nombre> --repo <ruta>`);
         }
     }
@@ -1910,6 +2010,198 @@ async function cmdBadge(args, dbPath) {
         db.close();
     }
 }
+/**
+ * `estela statusline install` — la línea de Estela en Claude Code. La lógica
+ * del fichero está en `statusline-install.ts`; aquí, leer, escribir y contar.
+ */
+function cmdStatuslineInstall(args) {
+    const path = (0, statusline_install_js_1.claudeSettingsPath)();
+    const before = (0, node_fs_1.existsSync)(path) ? (0, node_fs_1.readFileSync)(path, "utf8") : null;
+    const plan = (0, statusline_install_js_1.planInstall)(before, { force: args.flags["force"] === true, append: args.flags["append"] === true });
+    if (plan.status === "invalid") {
+        throw new UserError((0, index_js_1.tr) `${path} no es un JSON válido. No lo toco: arréglalo y vuelve a intentarlo.`);
+    }
+    if (plan.status === "already") {
+        console.log((0, index_js_1.tr) `La status line de Estela ya está instalada en ${path}.`);
+        return;
+    }
+    if (plan.status === "conflict") {
+        console.log((0, index_js_1.tr) `Ya tienes otra status line en ${path}:\n`);
+        console.log(`  ${plan.existing}\n`);
+        console.log((0, index_js_1.tr) `No la toco. Elige:`);
+        console.log((0, index_js_1.tr) `  estela statusline install --append   enseña las dos, la de Estela primero`);
+        console.log((0, index_js_1.tr) `  estela statusline install --force    sustituye la tuya por la de Estela`);
+        process.exitCode = 1;
+        return;
+    }
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+    if (before !== null) {
+        const copia = (0, statusline_install_js_1.backupName)(path);
+        (0, node_fs_1.copyFileSync)(path, copia);
+        console.log((0, index_js_1.tr) `Copia de seguridad: ${copia}`);
+    }
+    (0, node_fs_1.writeFileSync)(path, plan.text);
+    console.log(plan.status === "chained"
+        ? (0, index_js_1.tr) `Status line de Estela instalada, con la tuya detrás: ${plan.previous ?? ""}`
+        : plan.status === "replaced"
+            ? (0, index_js_1.tr) `Status line de Estela instalada en lugar de: ${plan.previous ?? ""}`
+            : (0, index_js_1.tr) `Status line de Estela instalada en ${path}.`);
+    console.log((0, index_js_1.tr) `Se verá en la próxima sesión de Claude Code (o al reiniciar la actual).`);
+    if (!(0, statusline_install_js_1.estelaOnPath)()) {
+        console.log((0, index_js_1.tr) `\nAviso: "estela" no está en tu PATH, así que Claude Code no podrá ejecutarla.`);
+        console.log((0, index_js_1.tr) `Instálala de forma global: npm install -g estela`);
+    }
+}
+function cmdStatuslineUninstall() {
+    const path = (0, statusline_install_js_1.claudeSettingsPath)();
+    if (!(0, node_fs_1.existsSync)(path)) {
+        console.log((0, index_js_1.tr) `No hay status line de Estela que quitar.`);
+        return;
+    }
+    const plan = (0, statusline_install_js_1.planUninstall)((0, node_fs_1.readFileSync)(path, "utf8"));
+    if (plan.status === "invalid") {
+        throw new UserError((0, index_js_1.tr) `${path} no es un JSON válido. No lo toco: arréglalo y vuelve a intentarlo.`);
+    }
+    if (plan.status === "absent") {
+        console.log((0, index_js_1.tr) `No hay status line de Estela que quitar.`);
+        return;
+    }
+    if (plan.status === "foreign") {
+        console.log((0, index_js_1.tr) `La status line de ${path} no es la de Estela, así que no la toco:\n\n  ${plan.existing}`);
+        return;
+    }
+    const copia = (0, statusline_install_js_1.backupName)(path);
+    (0, node_fs_1.copyFileSync)(path, copia);
+    (0, node_fs_1.writeFileSync)(path, plan.text);
+    console.log((0, index_js_1.tr) `Copia de seguridad: ${copia}`);
+    console.log(plan.status === "restored"
+        ? (0, index_js_1.tr) `Status line de Estela quitada; vuelve a estar la que tenías: ${plan.restored ?? ""}`
+        : (0, index_js_1.tr) `Status line de Estela quitada.`);
+}
+/**
+ * `estela quota` — qué proyecto se come la cuota. El cálculo vive en
+ * `metrics/quota.ts`; aquí solo se presenta.
+ */
+async function cmdQuota(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const now = new Date();
+        // Sobre la base de la demo no se lee nada tuyo: mezclaría tus turnos
+        // reales con los inventados, justo lo que la demo promete no hacer.
+        const esDemo = (0, node_path_1.basename)(dbPath) === "estela-demo.db";
+        if (args.flags["no-refresh"] !== true && !esDemo) {
+            try {
+                await (0, quota_js_2.refreshQuotaTurns)(db, (0, quota_js_1.weekStart)(now));
+            }
+            catch {
+                // Sin refrescar se sigue: lo guardado sigue valiendo, solo más viejo.
+                if (args.flags["json"] !== true)
+                    console.log((0, index_js_1.tr) `(No se pudieron leer los transcripts de esta semana; se usa lo ya guardado.)`);
+            }
+        }
+        const report = (0, quota_js_2.loadQuotaReport)(db, now, { dbPath, weighted: args.flags["weighted"] === true });
+        if (args.flags["json"] === true) {
+            console.log(JSON.stringify((0, quota_js_1.quotaToJson)(report), null, 2));
+            return;
+        }
+        printQuota(report, store.firstTurnByAgent(db).size > 0);
+    }
+    finally {
+        db.close();
+    }
+}
+function printQuota(report, hayTurnos) {
+    console.log((0, index_js_1.tr) `\nConsumo de cuota · lo calcula Estela en tu máquina; no es el límite de tu plan\n`);
+    if (report.agents.length === 0) {
+        console.log(hayTurnos
+            ? (0, index_js_1.tr) `Sin consumo de Claude Code ni Codex esta semana.`
+            : (0, index_js_1.tr) `Sin turnos de agente guardados. Empieza con: estela setup`);
+    }
+    for (const a of report.agents) {
+        const nombre = agentName(a.agent);
+        if (a.window) {
+            console.log(a.window.estimated
+                ? (0, index_js_1.tr) `${nombre} — ventana de 5 h actual (estimada): desde las ${hhmm(a.window.start)}, termina a las ${hhmm(a.window.end)}`
+                : (0, index_js_1.tr) `${nombre} — ventana de 5 h actual: desde las ${hhmm(a.window.start)}, termina a las ${hhmm(a.window.end)}`);
+            printQuotaTable(a.window);
+        }
+        else if (a.lastWindowEnded) {
+            console.log((0, index_js_1.tr) `${nombre} — sin ventana de 5 h abierta ahora; la última terminó ${cuando(a.lastWindowEnded, report.generatedAt)}.\n`);
+        }
+        console.log((0, index_js_1.tr) `${nombre} — esta semana (${diaCorto(report.weekStart)} → hoy)`);
+        printQuotaTable(a.week);
+        console.log(`  ${comparacion(a, report.generatedAt)}\n`);
+    }
+    if (report.copilotExcluded)
+        console.log((0, index_js_1.tr) `Copilot no guarda tokens fiables y queda fuera de este cálculo.`);
+    if (report.agents.some((a) => a.week.weighted)) {
+        console.log((0, index_js_1.tr) `Ponderado por precio de lista; no es cómo el proveedor cuenta tu límite.`);
+        const sinPrecio = report.agents.reduce((n, a) => n + a.week.unpriced, 0);
+        if (sinPrecio > 0)
+            console.log((0, index_js_1.tr) `${sinPrecio} turnos de modelos sin precio de lista cuentan como 0 en ese %.`);
+    }
+    // La ventana estimada lo dice; la que dio Claude Code no lo necesita, pero
+    // el reparto sigue siendo solo de esta máquina.
+    if (report.agents.some((a) => a.window?.estimated)) {
+        console.log((0, index_js_1.tr) `La ventana de 5 h es una estimación: no se publica cómo se redondea su inicio, y lo que`);
+        console.log((0, index_js_1.tr) `uses en claude.ai u otro equipo también consume cuota y Estela no lo ve.`);
+    }
+    else if (report.agents.some((a) => a.window)) {
+        console.log((0, index_js_1.tr) `La ventana de 5 h es la que da Claude Code; el reparto solo incluye lo usado en esta máquina.`);
+    }
+}
+function printQuotaTable(b) {
+    const filas = b.rows.map((r) => [nombreDeFila(r.bucket), r.usage, pct(r.share)]);
+    const ancho = Math.min(28, Math.max((0, index_js_1.tr) `Proyecto`.length, (0, index_js_1.tr) `Total`.length, ...filas.map((f) => f[0].length)));
+    const cabeza = [(0, index_js_1.tr) `Entrada`, (0, index_js_1.tr) `Salida`, (0, index_js_1.tr) `Lect. caché`, (0, index_js_1.tr) `Escr. caché`, (0, index_js_1.tr) `Total`];
+    const col = Math.max(10, ...cabeza.map((c) => c.length + 2));
+    const celdas = (u) => [u.input, u.output, u.cacheRead, u.cacheWrite, u.total].map((n) => fmtTokens(n).padStart(col)).join("");
+    const nombre = (t) => (t.length > ancho ? t.slice(0, ancho - 1) + "…" : t).padEnd(ancho);
+    console.log(`  ${nombre((0, index_js_1.tr) `Proyecto`)}${cabeza.map((c) => c.padStart(col)).join("")}${"%".padStart(7)}`);
+    for (const [n, u, p] of filas)
+        console.log(`  ${nombre(n)}${celdas(u)}${p.padStart(7)}`);
+    console.log(`  ${nombre((0, index_js_1.tr) `Total`)}${celdas(b.total)}\n`);
+}
+function nombreDeFila(b) {
+    if (b.kind === "project")
+        return b.projectName;
+    if (b.kind === "folder")
+        return (0, index_js_1.tr) `sin proyecto · ${b.folder}`;
+    return (0, index_js_1.tr) `sin carpeta`;
+}
+function comparacion(a, now) {
+    const c = a.comparison;
+    if (c.status === "insufficient") {
+        return (0, index_js_1.tr) `Sin historial suficiente para comparar: hacen falta ${quota_js_1.HISTORY_WEEKS} semanas completas y hay ${c.completeWeeks}.`;
+    }
+    const tramo = (0, index_js_1.tr) `lunes → ${dates_js_1.DAYS[(0, index_js_1.getLang)()][now.getDay()]} ${hhmm(now)}`;
+    if (c.ratio === null) {
+        return (0, index_js_1.tr) `Frente a tu historial: ${fmtTokens(c.current)} esta semana; en el mismo tramo (${tramo}) de las ${c.weeks} semanas anteriores no hubo consumo.`;
+    }
+    const diff = Math.round((c.ratio - 1) * 100);
+    const cuanto = diff > 0 ? (0, index_js_1.tr) `un ${diff} % más` : diff < 0 ? (0, index_js_1.tr) `un ${-diff} % menos` : (0, index_js_1.tr) `lo mismo`;
+    return (0, index_js_1.tr) `Frente a tu historial: ${fmtTokens(c.current)} esta semana, y una media de ${fmtTokens(c.average)} en el mismo tramo (${tramo}) de las ${c.weeks} semanas anteriores: ${cuanto}.`;
+}
+/** Tokens con el formato corto del idioma: "22,7 M" o "22.7M". */
+function fmtTokens(n) {
+    return new Intl.NumberFormat((0, index_js_1.getLang)() === "en" ? "en-US" : "es-ES", { notation: "compact", maximumFractionDigits: 1 }).format(n);
+}
+function pct(share) {
+    return (0, index_js_1.tr) `${Math.round(share * 100)} %`;
+}
+function hhmm(d) {
+    return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+/** "lun 5 oct" o "Mon Oct 5". */
+function diaCorto(d) {
+    const dia = dates_js_1.DAYS[(0, index_js_1.getLang)()][d.getDay()].slice(0, 3);
+    const mes = dates_js_1.MONTHS[(0, index_js_1.getLang)()][d.getMonth()].slice(0, 3);
+    return (0, index_js_1.getLang)() === "en" ? `${dia} ${mes} ${d.getDate()}` : `${dia} ${d.getDate()} ${mes}`;
+}
+/** "a las 14:00" si fue hoy; si no, con su día. */
+function cuando(d, now) {
+    return (0, shared_1.localDate)(d) === (0, shared_1.localDate)(now) ? (0, index_js_1.tr) `a las ${hhmm(d)}` : (0, index_js_1.tr) `el ${diaCorto(d)} a las ${hhmm(d)}`;
+}
 function cmdReceipt(args, dbPath) {
     const db = (0, schema_js_1.openDatabase)(dbPath);
     try {
@@ -2106,6 +2398,15 @@ async function main() {
         case "ai-cost":
             cmdAiCost(dbPath);
             break;
+        case "quota":
+            await cmdQuota(args, dbPath);
+            break;
+        case "statusline install":
+            cmdStatuslineInstall(args);
+            break;
+        case "statusline uninstall":
+            cmdStatuslineUninstall();
+            break;
         case "badge":
             await cmdBadge(args, dbPath);
             break;