estela 0.1.40 → 0.2.1

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");
@@ -78,6 +79,8 @@ 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
@@ -86,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>]
@@ -146,7 +153,7 @@ 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]
+  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
@@ -154,9 +161,24 @@ estela — registro de horas para desarrollo asistido por IA
         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.
@@ -256,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>]
@@ -316,7 +342,7 @@ 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]
+  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
@@ -324,10 +350,26 @@ estela — time tracking for AI-assisted development
         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. Copilot is left out: it doesn't record reliable
-        tokens. Before calculating it reads transcripts since Monday
+        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.
@@ -687,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
@@ -780,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>`);
         }
     }
@@ -1936,6 +2010,74 @@ 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.
@@ -1957,7 +2099,7 @@ async function cmdQuota(args, dbPath) {
                     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);
+        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;
@@ -1978,7 +2120,9 @@ function printQuota(report, hayTurnos) {
     for (const a of report.agents) {
         const nombre = agentName(a.agent);
         if (a.window) {
-            console.log((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)}`);
+            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) {
@@ -1990,8 +2134,21 @@ function printQuota(report, hayTurnos) {
     }
     if (report.copilotExcluded)
         console.log((0, index_js_1.tr) `Copilot no guarda tokens fiables y queda fuera de este cálculo.`);
-    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.`);
+    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)]);
@@ -2244,6 +2401,12 @@ async function main() {
         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;

package/dist/db/store.d.ts

@@ -92,6 +92,8 @@ export declare function saveTurns(db: DatabaseSync, turns: readonly AgentTurn[])
  * `saveTurns` los guarda con el `turn_id` del origen como clave.
  */
 export declare function quotaTurns(db: DatabaseSync, from: Date, to: Date): QuotaTurn[];
+/** Turnos completos con `from <= at < to`: lo que necesita `sessionize`. */
+export declare function turnsBetween(db: DatabaseSync, from: Date, to: Date): AgentTurn[];
 /** El primer turno guardado de cada agente: hasta dónde llega su historial. */
 export declare function firstTurnByAgent(db: DatabaseSync): Map<AgentKind, Date>;
 /**

package/dist/db/store.js

@@ -23,6 +23,7 @@ exports.projectForRepo = projectForRepo;
 exports.allProjectRepoPaths = allProjectRepoPaths;
 exports.saveTurns = saveTurns;
 exports.quotaTurns = quotaTurns;
+exports.turnsBetween = turnsBetween;
 exports.firstTurnByAgent = firstTurnByAgent;
 exports.saveCommits = saveCommits;
 exports.logScan = logScan;
@@ -347,12 +348,13 @@ function saveTurns(db, turns) {
  */
 function quotaTurns(db, from, to) {
     const rows = db.prepare(`
-    SELECT agent, at, repo_path, tok_input, tok_output, tok_cache_read, tok_cache_w5m, tok_cache_w1h
+    SELECT agent, at, model, repo_path, tok_input, tok_output, tok_cache_read, tok_cache_w5m, tok_cache_w1h
     FROM agent_turns WHERE at >= ? AND at < ?
   `).all(iso(from), iso(to));
     return rows.map((r) => ({
         agent: r["agent"],
         at: new Date(r["at"]),
+        model: r["model"],
         repoPath: r["repo_path"] ?? null,
         tokens: {
             input: r["tok_input"], output: r["tok_output"],
@@ -361,6 +363,27 @@ function quotaTurns(db, from, to) {
         },
     }));
 }
+/** Turnos completos con `from <= at < to`: lo que necesita `sessionize`. */
+function turnsBetween(db, from, to) {
+    const rows = db.prepare(`
+    SELECT * FROM agent_turns WHERE at >= ? AND at < ? ORDER BY at
+  `).all(iso(from), iso(to));
+    return rows.map((r) => ({
+        agent: r["agent"],
+        turnId: r["turn_id"],
+        sessionId: r["session_id"],
+        at: new Date(r["at"]),
+        model: r["model"],
+        repoPath: r["repo_path"] ?? null,
+        branch: r["branch"] ?? null,
+        tokens: {
+            input: r["tok_input"], output: r["tok_output"],
+            cacheRead: r["tok_cache_read"],
+            cacheWrite5m: r["tok_cache_w5m"], cacheWrite1h: r["tok_cache_w1h"],
+        },
+        producerVersion: r["producer_version"] ?? null,
+    }));
+}
 /** El primer turno guardado de cada agente: hasta dónde llega su historial. */
 function firstTurnByAgent(db) {
     const rows = db.prepare("SELECT agent, MIN(at) AS first FROM agent_turns GROUP BY agent")

package/dist/demo.js

@@ -289,7 +289,7 @@ function turnosDeCuota(ahora, hoy) {
                 break;
             out.push({
                 agent: "codex", turnId: `demo_quota_codex_${n++}`, sessionId: `demo-codex-${d}`,
-                at, model: "gpt-5-codex", repoPath: RUTA(repo), branch: "main",
+                at, model: "gpt-5.6-sol", repoPath: RUTA(repo), branch: "main",
                 tokens: { input: entre(800, 6000), output: entre(200, 2400), cacheRead: entre(8_000, 60_000),
                     cacheWrite5m: 0, cacheWrite1h: 0 },
                 producerVersion: "0.46.0",

package/dist/i18n/en.js

@@ -511,5 +511,44 @@ exports.EN = {
     "{0} %": "{0}%",
     "a las {0}": "at {0}",
     "el {0} a las {1}": "on {0} at {1}",
+    // ── estela statusline ──
+    "{0} no es un JSON válido. No lo toco: arréglalo y vuelve a intentarlo.": "{0} isn't valid JSON. I'm not touching it: fix it and try again.",
+    "La status line de Estela ya está instalada en {0}.": "Estela's status line is already installed in {0}.",
+    "Ya tienes otra status line en {0}:\n": "You already have another status line in {0}:\n",
+    "No la toco. Elige:": "I won't touch it. Choose:",
+    "  estela statusline install --append   enseña las dos, la de Estela primero": "  estela statusline install --append   show both, Estela's first",
+    "  estela statusline install --force    sustituye la tuya por la de Estela": "  estela statusline install --force    replace yours with Estela's",
+    "Copia de seguridad: {0}": "Backup: {0}",
+    "Status line de Estela instalada, con la tuya detrás: {0}": "Estela's status line installed, with yours after it: {0}",
+    "Status line de Estela instalada en lugar de: {0}": "Estela's status line installed instead of: {0}",
+    "Status line de Estela instalada en {0}.": "Estela's status line installed in {0}.",
+    "Se verá en la próxima sesión de Claude Code (o al reiniciar la actual).": "You'll see it in your next Claude Code session (or after restarting the current one).",
+    "\nAviso: \"estela\" no está en tu PATH, así que Claude Code no podrá ejecutarla.": "\nWarning: \"estela\" isn't on your PATH, so Claude Code won't be able to run it.",
+    "Instálala de forma global: npm install -g estela": "Install it globally: npm install -g estela",
+    "No hay status line de Estela que quitar.": "There's no Estela status line to remove.",
+    "La status line de {0} no es la de Estela, así que no la toco:\n\n  {1}": "The status line in {0} isn't Estela's, so I won't touch it:\n\n  {1}",
+    "Status line de Estela quitada; vuelve a estar la que tenías: {0}": "Estela's status line removed; your previous one is back: {0}",
+    "Status line de Estela quitada.": "Estela's status line removed.",
+    "sin proyecto": "no project",
+    "hoy {0}": "today {0}",
+    "este proyecto {0} %": "this project {0}%",
+    "semana {0} %": "week {0}%",
+    "5 h {0} %": "5h {0}%",
+    // ── quota: ventana oficial y --weighted ──
+    "{0} — ventana de 5 h actual: desde las {1}, termina a las {2}": "{0} — current 5-hour window: from {1}, ends at {2}",
+    "Ponderado por precio de lista; no es cómo el proveedor cuenta tu límite.": "Weighted by list price; this is not how the provider counts your limit.",
+    "{0} turnos de modelos sin precio de lista cuentan como 0 en ese %.": "{0} turns from models without a list price count as 0 in that %.",
+    "La ventana de 5 h es la que da Claude Code; el reparto solo incluye lo usado en esta máquina.": "The 5-hour window is the one Claude Code reports; the split only includes what was used on this machine.",
+    // ── import: horas de subcarpetas y worktrees ──
+    "\nEstela ahora reconoce las sesiones en subcarpetas y worktrees de un repositorio.": "\nEstela now recognizes sessions in a repository's subfolders and worktrees.",
+    "Estas horas no estaban imputadas y se sumarían a su proyecto:\n": "These hours weren't assigned and would be added to their project:\n",
+    "\n  Nada de lo ya imputado cambia de proyecto, y los días aprobados no se tocan.": "\n  Nothing already assigned changes project, and approved days aren't touched.",
+    "\n  Sin tocar, porque ese día ya está aprobado o facturado:": "\n  Left alone, because that day is already approved or invoiced:",
+    "    {0} · {1}: {2} recuperables. Revísalo con: estela entries --project {3}": "    {0} · {1}: {2} recoverable. Review it with: estela entries --project {3}",
+    "¿Imputar estas horas? [s/N] ": "Assign these hours? [y/N] ",
+    "  No se ha tocado nada. Cuando quieras: estela import --yes\n": "  Nothing was changed. Whenever you want: estela import --yes\n",
+    "  {0} recuperadas de sesiones en subcarpetas y worktrees": "  {0} recovered from sessions in subfolders and worktrees",
+    "{0} (sin proyecto)": "{0} (no project)",
+    "\n{0} de esos bloques son de subcarpetas o worktrees de un proyecto: estela import --yes los imputa.": "\n{0} of those blocks are from a project's subfolders or worktrees: estela import --yes assigns them.",
 };
 //# sourceMappingURL=en.js.map

package/dist/metrics/quota.d.ts

@@ -38,6 +38,8 @@ export interface QuotaTurn {
     readonly at: Date;
     readonly repoPath: string | null;
     readonly tokens: TokenUsage;
+    /** Solo para ponderar por precio (`--weighted`). Sin él, el turno no tiene precio. */
+    readonly model?: string;
 }
 /**
  * Consumo en tokens. La escritura de caché va junta (5 min + 1 h): para la
@@ -59,28 +61,42 @@ export type QuotaBucket = {
     readonly kind: "project";
     readonly projectId: string;
     readonly projectName: string;
-} | {
+}
+/** `folder` es el nombre que se enseña; `path`, la raíz git que agrupa. */
+ | {
     readonly kind: "folder";
     readonly folder: string;
+    readonly path: string;
 } | {
     readonly kind: "none";
 };
 export interface QuotaRow {
     readonly bucket: QuotaBucket;
     readonly usage: QuotaUsage;
-    /** Parte del total del periodo, entre 0 y 1. */
+    /** Lo que valdrían sus tokens a precio de lista, en micro-USD. */
+    readonly listCost: number;
+    /**
+     * Parte del total del periodo, entre 0 y 1: por tokens, o por precio de
+     * lista si se pidió ponderar.
+     */
     readonly share: number;
 }
 export interface QuotaBreakdown {
     readonly rows: readonly QuotaRow[];
     readonly total: QuotaUsage;
+    readonly listCost: number;
+    /** Turnos de un modelo sin precio en el catálogo: al ponderar cuentan como 0. */
+    readonly unpriced: number;
+    readonly weighted: boolean;
 }
 /**
  * Reparto por proyecto de los turnos con `from <= at < to`, de mayor a menor.
  * Un proyecto sin actividad en el periodo no sale: una fila a cero en una
  * tabla de "quién se come la cuota" es ruido.
  */
-export declare function breakdown(turns: readonly QuotaTurn[], from: Date, to: Date, bucketOf: (repoPath: string | null) => QuotaBucket): QuotaBreakdown;
+export declare function breakdown(turns: readonly QuotaTurn[], from: Date, to: Date, bucketOf: (repoPath: string | null) => QuotaBucket, options?: {
+    readonly weighted?: boolean;
+}): QuotaBreakdown;
 export declare const WINDOW_HOURS = 5;
 export interface QuotaWindow {
     readonly start: Date;
@@ -150,7 +166,13 @@ export declare function compareWithHistory(times: readonly {
 }[], firstTurnAt: Date | null, now: Date): QuotaComparison;
 export interface AgentQuota {
     readonly agent: QuotaAgent;
-    readonly window: (QuotaWindow & QuotaBreakdown) | null;
+    /**
+     * `estimated: false` cuando la ventana la dio Claude Code (`resets_at`, que
+     * guarda la status line); si no, es la estimación de `fiveHourWindows`.
+     */
+    readonly window: (QuotaWindow & QuotaBreakdown & {
+        readonly estimated: boolean;
+    }) | null;
     /** Si no hay ventana abierta, cuándo acabó la última de los datos. */
     readonly lastWindowEnded: Date | null;
     readonly week: QuotaBreakdown;
@@ -174,7 +196,25 @@ export declare function buildQuota(input: {
     readonly firstTurnAt: ReadonlyMap<AgentKind, Date>;
     readonly now: Date;
     readonly bucketOf: (repoPath: string | null) => QuotaBucket;
+    /**
+     * La ventana de 5 h de Claude Code tal como la dio Claude Code (ver
+     * `officialWindow`). Solo vale para Claude Code: Codex tiene la suya.
+     */
+    readonly claudeWindow?: QuotaWindow | null;
+    readonly weighted?: boolean;
 }): QuotaReport;
+/**
+ * La ventana de 5 h que dio Claude Code, a partir del último `resets_at` que
+ * vio la status line: empieza 5 h antes de su reinicio.
+ *
+ * Solo vale si el dato tiene menos de 5 h (uno más viejo puede ser de otra
+ * ventana) y si el reinicio aún no ha llegado (pasado ese momento, la ventana
+ * en curso es otra que nadie ha visto). Si no, null: se estima como siempre.
+ */
+export declare function officialWindow(seen: {
+    readonly resetsAt: Date;
+    readonly seenAt: Date;
+} | null, now: Date): QuotaWindow | null;
 /** Desde cuándo hay que leer turnos para montar el informe de `now`. */
 export declare function quotaRange(now: Date): QuotaWindow;
 /**