estela 0.2.4 → 0.3.2

package/README.md

@@ -273,6 +273,61 @@ anything you use on claude.ai or another machine counts too but isn't on this
 one. Copilot is left out because it doesn't record reliable tokens. Everything
 is calculated on your machine.
 
+## Is your Claude plan the right one?
+
+```sh
+estela plan set max5            # pro | max5 | max20; add --since YYYY-MM-DD if you had it before today
+estela plan                     # last 28 days; --days N, --json, --no-color
+```
+
+Answers "is the Claude plan I pay for too big or too small?" with your own data:
+the 5-hour and weekly percentages Claude Code sends to the status line (stored
+since 0.2.4, only in the terminal), and nothing else. Example (made-up data):
+
+```
+estela plan · Max 5x (since 2026-10-01) · 26 days with data
+
+5-hour windows       41 windows · median peak 22% · p90 38% · max 61%
+Caps (≥95%)          0
+Week                 median peak 34% · max 47% · 0 weeks ≥ 90%
+Blocks (429)         0 5-hour · 0 weekly, from Claude Code's transcripts
+
+If you were on…
+  Pro ($20)          equivalent p90 190% · would have blocked you in 29 of 41 windows
+  Max 20x ($200)     no caps, same as now
+
+Recommendation       Your current plan fits your usage.
+```
+
+- **It never invents or estimates a plan's limit.** Other plans are compared only
+  on the 5-hour window, using the per-session multiplier Anthropic publishes
+  (Max 5x = 5 × Pro, Max 20x = 20 × Pro;
+  [source](https://support.claude.com/en/articles/11049741-what-is-the-max-plan)):
+  an equivalent peak is your peak × your multiplier ÷ the other plan's. Anthropic
+  doesn't publish the weekly limit between plans, so that comparison isn't made.
+  It never says how much you have left.
+- A window with a peak of 95% or more is a cap. The time stopped after a cap
+  (from the first sample at 99% to the reset) is an upper bound: we don't know if
+  you kept working.
+- "Blocks (429)" are the rate-limit responses Claude Code wrote in its
+  transcripts. They're official and go back before 0.2.4, but carry no
+  percentage, so they're shown apart and don't enter the calculation.
+- With fewer than 7 days of data there's no recommendation; from 7 to 13 it's
+  provisional. After a plan change only data since then counts.
+- Prices are Anthropic's website prices on the date in the output; check them.
+  Anthropic may change limits: run it again every month.
+
+`--json` returns the same figures with a stable structure (`version: 1`): `plan`,
+`period` (`from`, `to`, `days`, `daysWithData`, `samples`), `dataState`
+(`none` | `insufficient` | `provisional` | `ok`), `fiveHour` (`windows`,
+`medianPeak`, `p90Peak`, `maxPeak`, `caps`, `stoppedMinutesUpperBound`), `week`
+(`weeks`, `medianPeak`, `maxPeak`, `weeksAtOrAbove90`), `blocks429`,
+`alternatives[]` (`plan`, `direction`, `monthlyUsd`, `monthlyDiffUsd`,
+`p90Equivalent`, `maxEquivalent`, `blockedWindows`, `capsAvoided`),
+`recommendation` (`kind`: `tight` | `enough` | `almost` | `fits`, `plan`,
+`provisional`, `text`, or `null`), `weeklyBetweenPlans: "not_published"`,
+`sources` and `plans`. New fields may be added; none change meaning.
+
 ## A line under every Claude Code session
 
 ```sh

package/dist/billing/assign.d.ts

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
-import type { TimeEntry } from "@estela/shared";
+import type { CommitRecord, TimeEntry } from "@estela/shared";
 import { type WorkBlock } from "./sessionize.js";
 /**
  * De bloques de trabajo a imputaciones: a qué proyecto va cada uno y con qué
@@ -39,6 +39,16 @@ export interface AssignmentPlan {
     readonly blocked: readonly RecoveryBlocked[];
 }
 export declare function entryId(projectId: string, day: string, branch: string | null): string;
+/**
+ * Los bloques deducidos solo de commits: los que no se solapan con ninguna
+ * sesión de agente, tampoco con las que ya no están en el disco.
+ *
+ * Claude Code limpia sus transcripts antiguos, así que lo escaneado no es todo
+ * lo que hubo. Comparar solo con eso convertía los commits de esas sesiones en
+ * trabajo sin agente, y sumaba horas estimadas a un trabajo ya medido. La base
+ * guarda todos los turnos: `saveTurns` no borra nada.
+ */
+export declare function commitOnlyBlocks(db: DatabaseSync, commits: readonly CommitRecord[], agentBlocks: readonly WorkBlock[]): WorkBlock[];
 export declare function planEntries(db: DatabaseSync, raw: readonly WorkBlock[], options: {
     readonly recover: boolean;
 }): AssignmentPlan;

package/dist/billing/assign.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.entryId = entryId;
+exports.commitOnlyBlocks = commitOnlyBlocks;
 exports.planEntries = planEntries;
 const shared_1 = require("@estela/shared");
 const store = __importStar(require("../db/store.js"));
@@ -45,6 +46,19 @@ function entryId(projectId, day, branch) {
     const slug = (branch ?? "sin-rama").replace(/[^a-zA-Z0-9]+/g, "-");
     return `te_${projectId}_${day}_${slug}`;
 }
+/**
+ * Los bloques deducidos solo de commits: los que no se solapan con ninguna
+ * sesión de agente, tampoco con las que ya no están en el disco.
+ *
+ * Claude Code limpia sus transcripts antiguos, así que lo escaneado no es todo
+ * lo que hubo. Comparar solo con eso convertía los commits de esas sesiones en
+ * trabajo sin agente, y sumaba horas estimadas a un trabajo ya medido. La base
+ * guarda todos los turnos: `saveTurns` no borra nada.
+ */
+function commitOnlyBlocks(db, commits, agentBlocks) {
+    const saved = (0, sessionize_js_1.sessionize)(store.turnsBetween(db, new Date(0), new Date("9999-12-31")));
+    return (0, sessionize_js_1.withoutOverlap)((0, sessionize_js_1.sessionizeCommits)(commits), [...agentBlocks, ...saved]);
+}
 function planEntries(db, raw, options) {
     const ownerOf = (0, project_of_js_1.ownerResolver)(db);
     const direct = (repo) => (repo ? store.projectForRepo(db, repo) : null);

package/dist/billing/sessionize.d.ts

@@ -113,6 +113,11 @@ export declare function sessionizeCommits(commits: readonly CommitRecord[], opti
  *
  * Sin esto se contaría dos veces el mismo rato: el agente ya cubrió esas horas
  * y el commit que las cerró generaría otro bloque encima.
+ *
+ * Mismo repositorio quiere decir lo mismo que en `attachCommits`: la carpeta
+ * del commit (la raíz) o una subcarpeta suya. Antes se exigía la ruta exacta,
+ * y una sesión abierta en `repo/src/UI` no tapaba el commit hecho en `repo`:
+ * se sumaban 25 minutos estimados encima de una sesión medida.
  */
 export declare function withoutOverlap(commitBlocks: readonly WorkBlock[], agentBlocks: readonly WorkBlock[]): WorkBlock[];
 //# sourceMappingURL=sessionize.d.ts.map

package/dist/billing/sessionize.js

@@ -290,10 +290,20 @@ function sessionizeCommits(commits, options = {}) {
  *
  * Sin esto se contaría dos veces el mismo rato: el agente ya cubrió esas horas
  * y el commit que las cerró generaría otro bloque encima.
+ *
+ * Mismo repositorio quiere decir lo mismo que en `attachCommits`: la carpeta
+ * del commit (la raíz) o una subcarpeta suya. Antes se exigía la ruta exacta,
+ * y una sesión abierta en `repo/src/UI` no tapaba el commit hecho en `repo`:
+ * se sumaban 25 minutos estimados encima de una sesión medida.
  */
 function withoutOverlap(commitBlocks, agentBlocks) {
-    return commitBlocks.filter((c) => !agentBlocks.some((a) => a.repoPath === c.repoPath &&
+    return commitBlocks.filter((c) => !agentBlocks.some((a) => sameRepo(a.repoPath, c.repoPath) &&
         a.startedAt.getTime() < c.endedAt.getTime() &&
         c.startedAt.getTime() < a.endedAt.getTime()));
 }
+function sameRepo(a, b) {
+    if (a === b)
+        return true;
+    return !!a && !!b && ((0, paths_js_1.isSameOrInside)(a, b) || (0, paths_js_1.isSameOrInside)(b, a));
+}
 //# sourceMappingURL=sessionize.js.map

package/dist/cli.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.breakdownOfTurn = void 0;
+const node_os_1 = require("node:os");
 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
@@ -63,6 +64,12 @@ const invoice_pdf_js_1 = require("./export/invoice-pdf.js");
 const share_js_1 = require("./export/share.js");
 const server_js_1 = require("./server.js");
 const updateCheck_js_1 = require("./updateCheck.js");
+const plan_js_1 = require("./metrics/plan.js");
+const plan_blocks_js_1 = require("./plan-blocks.js");
+const plan_prices_js_1 = require("./plan-prices.js");
+const plan_report_js_1 = require("./plan-report.js");
+const rate_history_js_1 = require("./rate-history.js");
+const statusline_cache_js_1 = require("./statusline-cache.js");
 const publish_js_1 = require("./publish.js");
 const sync_js_1 = require("./sync.js");
 const team_js_1 = require("./sync/team.js");
@@ -169,6 +176,15 @@ estela — registro de horas para desarrollo asistido por IA
         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 plan [--days <n>] [--json] [--no-color]
+  estela plan set pro|max5|max20 [--since AAAA-MM-DD]
+        ¿El plan de Claude que pagas te sobra o te falta? Analiza los
+        porcentajes de 5 h y semana que Claude Code manda a la status line
+        (solo en la terminal) y los compara con los otros planes usando el
+        multiplicador por sesión que publica Anthropic. El límite semanal
+        entre planes no se compara: no se publica. Primero declara tu plan
+        con "plan set". Por defecto, los últimos 28 días.
   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,
@@ -262,9 +278,11 @@ estela — registro de horas para desarrollo asistido por IA
                 [--pdf <fichero.pdf>] [--csv <fichero.csv>] [--fx <tipo>]
                 [--number <nº>]
                 [--from-name <tu nombre>] [--from-email <email>]
-                [--from-tax-id <tu NIF/CIF>]
+                [--from-tax-id <tu NIF/CIF>] [--no-amounts]
         Informe de horas y commits para respaldar tu trabajo. No es una
         factura: Estela no emite documentos fiscales.
+        --no-amounts saca el PDF sin tarifa ni importes. En el panel, lo ya
+        emitido se vuelve a descargar con o sin ellos.
         --number fija el número del informe; sin él se numera solo y
         correlativo por año (INF-${new Date().getFullYear()}-001, -002...).
         Los --from-* son tus datos como emisor, en la cabecera del PDF.
@@ -369,6 +387,15 @@ estela — time tracking for AI-assisted development
         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 plan [--days <n>] [--json] [--no-color]
+  estela plan set pro|max5|max20 [--since YYYY-MM-DD]
+        Is your Claude plan too big or too small? It analyses the 5-hour
+        and weekly percentages Claude Code sends to the status line (only
+        in the terminal) and compares them with the other plans using the
+        per-session multiplier Anthropic publishes. The weekly limit isn't
+        compared across plans: it isn't published. Declare your plan first
+        with "plan set". Defaults to the last 28 days.
   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
@@ -464,9 +491,11 @@ estela — time tracking for AI-assisted development
                 [--pdf <file.pdf>] [--csv <file.csv>] [--fx <rate>]
                 [--number <no.>]
                 [--from-name <your name>] [--from-email <email>]
-                [--from-tax-id <your tax ID>]
+                [--from-tax-id <your tax ID>] [--no-amounts]
         Report of hours and commits to back up your work. It isn't an
         invoice: Estela doesn't issue tax documents.
+        --no-amounts leaves the rate and amounts out of the PDF. In the panel,
+        issued reports can be downloaded again with or without them.
         --number sets the report number; without it, reports are numbered
         automatically and sequentially per year (INF-${new Date().getFullYear()}-001, -002...).
         The --from-* flags are your details as the issuer, in the PDF header.
@@ -877,7 +906,7 @@ async function cmdImport(args, dbPath) {
         // compañero se convertirían en tiempo facturable a tu nombre.
         const commitsAll = (0, identity_js_1.onlyMine)(await allCommits(db), mine);
         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 fromCommits = (0, assign_js_1.commitOnlyBlocks)(db, commitsAll, fromAgents);
         const raw = [...fromAgents, ...fromCommits];
         if (fromCommits.length) {
             console.log((0, index_js_1.tr) `  ${fromCommits.length} bloques deducidos solo de commits (sin agente)`);
@@ -1544,6 +1573,90 @@ async function cmdUnpublish(args, dbPath) {
         db.close();
     }
 }
+/**
+ * `estela plan`: ¿el plan de Claude que pagas es el que te conviene?
+ *
+ * Solo con lo que manda Claude Code a la status line (rate-limits.jsonl) y el
+ * multiplicador por sesión que publica Anthropic. Ver metrics/plan.ts.
+ */
+function cmdPlan(args, dbPath) {
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        const declared = store.getClaudePlan(db);
+        const json = args.flags["json"] === true;
+        if (!declared || !(0, plan_prices_js_1.planById)(declared.plan)) {
+            if (json)
+                console.log(JSON.stringify({ version: 1, plan: null }, null, 2));
+            else
+                console.log((0, plan_report_js_1.renderNoPlan)());
+            return;
+        }
+        const days = str(args, "days") === undefined ? 28 : Number(str(args, "days"));
+        if (!Number.isInteger(days) || days < 1 || days > rate_history_js_1.KEEP_DAYS) {
+            throw new UserError((0, index_js_1.tr) `--days tiene que ser un número entero de 1 a ${rate_history_js_1.KEEP_DAYS}.`);
+        }
+        const now = new Date();
+        const file = (0, rate_history_js_1.historyPath)(dbPath);
+        try {
+            (0, rate_history_js_1.pruneSamples)(file, now);
+        }
+        catch { /* sin rotar se analiza igual */ }
+        const all = (0, rate_history_js_1.readSamples)(file);
+        const analysis = (0, plan_js_1.analyzePlan)({ samples: all, plan: declared.plan, since: declared.since, now, days });
+        // Los 429 que Claude Code dejó en sus transcripts, en el mismo período.
+        let blocks = null;
+        try {
+            const found = (0, plan_blocks_js_1.scanBlocks)((0, node_path_1.join)((0, node_os_1.homedir)(), ".claude", "projects"), (0, plan_blocks_js_1.blocksCachePath)(dbPath), now)
+                .filter((b) => b.at >= analysis.from.getTime() && b.at <= now.getTime());
+            blocks = { fiveHour: found.filter((b) => b.type === "five_hour").length,
+                sevenDay: found.filter((b) => b.type === "seven_day").length };
+        }
+        catch { /* sin transcripts legibles, la línea no sale */ }
+        if (json) {
+            console.log(JSON.stringify((0, plan_report_js_1.planToJson)(analysis, { blocks, now }), null, 2));
+            return;
+        }
+        const color = args.flags["no-color"] !== true && !process.env["NO_COLOR"] && process.stdout.isTTY === true;
+        if (analysis.dataState === "none") {
+            // Sin ninguna muestra nunca, y la status line vio entradas sin rate_limits: API key.
+            const apiKey = all.length === 0 && (0, statusline_cache_js_1.loadCache)(dbPath).noLimitsAt !== undefined;
+            console.log((0, plan_report_js_1.renderNoData)(analysis, apiKey, color));
+            return;
+        }
+        console.log((0, plan_report_js_1.renderPlanReport)(analysis, { color, now, blocks }));
+    }
+    finally {
+        db.close();
+    }
+}
+/** `estela plan set pro|max5|max20 [--since AAAA-MM-DD]`. */
+function cmdPlanSet(args, dbPath) {
+    const id = args._[2] ?? "";
+    const plan = (0, plan_prices_js_1.planById)(id);
+    if (!plan)
+        throw new UserError((0, index_js_1.tr) `Plan desconocido: "${id}". Usa pro, max5 o max20.`);
+    const sinceText = str(args, "since");
+    let since = new Date();
+    if (sinceText !== undefined) {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(sinceText) || Number.isNaN(new Date(`${sinceText}T00:00:00`).getTime())) {
+            throw new UserError((0, index_js_1.tr) `--since tiene que ser una fecha AAAA-MM-DD.`);
+        }
+        since = new Date(`${sinceText}T00:00:00`);
+    }
+    const db = (0, schema_js_1.openDatabase)(dbPath);
+    try {
+        store.setClaudePlan(db, plan.id, since);
+        const d = since;
+        const fecha = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+        console.log((0, index_js_1.tr) `Plan declarado: ${plan.name}, desde ${fecha}. El análisis solo usa lo guardado desde esa fecha.`);
+        if (sinceText === undefined) {
+            console.log((0, index_js_1.tr) `Si ya lo tenías antes, indica desde cuándo: estela plan set ${plan.id} --since AAAA-MM-DD`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
 /**
  * `estela sync enable --project <id>` — opt-in explícito, proyecto por
  * proyecto. Sin esta fila, ese proyecto no sale de esta máquina nunca, sea
@@ -2418,6 +2531,7 @@ function cmdInvoice(args, dbPath) {
                     },
                 } : {}),
                 ...(invoice.aiAmortized ? { amortizedAiCost: invoice.aiAmortized } : {}),
+                withAmounts: args.flags["no-amounts"] !== true,
             }));
             (0, node_fs_1.writeFileSync)(pdfPath, pdf);
             console.log((0, index_js_1.tr) `\nPDF: ${pdfPath}  (${(pdf.length / 1024).toFixed(1)} KB, ${invoice.lines.length} conceptos)`);
@@ -2466,7 +2580,10 @@ async function main() {
     (0, client_js_1.setClientVersion)(VERSION);
     const dbPath = str(args, "db") ?? schema_js_1.DEFAULT_DB_PATH;
     // `estela unpublish <panel>` lleva el panel suelto, sin flag: no es un subcomando.
-    const command = args._[0] === "unpublish" ? "unpublish" : args._.join(" ");
+    const command = args._[0] === "unpublish" ? "unpublish"
+        // `estela plan set max5`: el plan va suelto, como el panel de unpublish.
+        : args._[0] === "plan" && args._[1] === "set" ? "plan set"
+            : args._.join(" ");
     // Se llama aquí, no al final: un comando que falla a medias (por ejemplo
     // "estela import" sin repositorios) debe avisar igual de que hay una
     // versión nueva, no solo los que terminan bien.
@@ -2553,6 +2670,12 @@ async function main() {
         case "unpublish":
             await cmdUnpublish(args, dbPath);
             break;
+        case "plan":
+            cmdPlan(args, dbPath);
+            break;
+        case "plan set":
+            cmdPlanSet(args, dbPath);
+            break;
         case "export":
             await cmdExport(args, dbPath);
             break;

package/dist/db/schema.js

@@ -269,6 +269,16 @@ CREATE TABLE IF NOT EXISTS personal_sync_state (
   entity_type   TEXT PRIMARY KEY,
   synced_up_to  TEXT NOT NULL DEFAULT ''
 );
+
+-- El plan de Claude que declara quien usa Estela (estela plan set): el JSON
+-- de la status line no lo dice. Una fila por cambio, para conservar el
+-- historial; el vigente es el de 'since' más reciente.
+CREATE TABLE IF NOT EXISTS claude_plans (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  plan        TEXT NOT NULL,
+  since       TEXT NOT NULL,
+  declared_at TEXT NOT NULL
+);
 `;
 /**
  * Migraciones.

package/dist/db/store.d.ts

@@ -304,4 +304,13 @@ export declare function entryDetailForTeam(db: DatabaseSync, projectId: string):
 }[];
 export declare function getAiConsent(db: DatabaseSync, projectId: string): AiConsentRecord | null;
 export declare function setAiConsent(db: DatabaseSync, projectId: string, requested: boolean, decision: AiConsentDecision): void;
+export interface DeclaredPlan {
+    readonly plan: string;
+    readonly since: Date;
+}
+/** El plan vigente: el de `since` más reciente. null si nunca se declaró. */
+export declare function getClaudePlan(db: DatabaseSync): DeclaredPlan | null;
+/** Añade un cambio de plan; los anteriores se conservan. */
+export declare function setClaudePlan(db: DatabaseSync, plan: string, since: Date, at?: Date): void;
+export declare function listClaudePlans(db: DatabaseSync): DeclaredPlan[];
 //# sourceMappingURL=store.d.ts.map

package/dist/db/store.js

@@ -61,6 +61,9 @@ exports.entryAiByDay = entryAiByDay;
 exports.entryDetailForTeam = entryDetailForTeam;
 exports.getAiConsent = getAiConsent;
 exports.setAiConsent = setAiConsent;
+exports.getClaudePlan = getClaudePlan;
+exports.setClaudePlan = setClaudePlan;
+exports.listClaudePlans = listClaudePlans;
 const node_crypto_1 = require("node:crypto");
 const shared_1 = require("@estela/shared");
 const cost_js_1 = require("../pricing/cost.js");
@@ -557,8 +560,14 @@ function saveTimeEntry(db, entry, at = new Date()) {
     -- Y lo ya facturado es historia. Sin esta condición, un reimport
     -- recalculaba filas que respaldan una factura emitida y dejaba el panel
     -- diciendo una cosa y el PDF del cliente otra.
+    --
+    -- Lo aprobado, igual: aprobar un día es dar por buena esa cifra, y a
+    -- menudo ya se ha compartido (un panel publicado, un avance al cliente).
+    -- Un cambio en cómo se calculan las horas se aplica a lo que viene, no
+    -- reescribe lo que ya se dio por bueno. Para recalcularlo, se desaprueba.
     WHERE time_entries.source IN ('agent', 'commit')
       AND time_entries.invoice_id IS NULL
+      AND time_entries.approved = 0
   `).run(id, entry.projectId, iso(entry.startedAt), (0, shared_1.localDate)(entry.startedAt), iso(entry.endedAt), entry.seconds, entry.description, entry.billable ? 1 : 0, entry.invoiceId, entry.aiCost.microUsd, entry.agentSeconds, entry.commitHashes.join(","), entry.agents.join(","), entry.source, entry.kind, entry.branch, (entry.workItems ?? []).join(","), iso(at));
     return id;
 }
@@ -982,4 +991,19 @@ function setAiConsent(db, projectId, requested, decision) {
       requested = excluded.requested, decision = excluded.decision, decided_at = excluded.decided_at
   `).run(projectId, requested ? 1 : 0, decision, decision === "pending" ? null : iso(new Date()));
 }
+/** El plan vigente: el de `since` más reciente. null si nunca se declaró. */
+function getClaudePlan(db) {
+    const row = db.prepare("SELECT plan, since FROM claude_plans ORDER BY since DESC, id DESC LIMIT 1")
+        .get();
+    return row ? { plan: row.plan, since: new Date(row.since) } : null;
+}
+/** Añade un cambio de plan; los anteriores se conservan. */
+function setClaudePlan(db, plan, since, at = new Date()) {
+    db.prepare("INSERT INTO claude_plans (plan, since, declared_at) VALUES (?, ?, ?)")
+        .run(plan, iso(since), iso(at));
+}
+function listClaudePlans(db) {
+    return db.prepare("SELECT plan, since FROM claude_plans ORDER BY since, id").all()
+        .map((r) => ({ plan: r.plan, since: new Date(r.since) }));
+}
 //# sourceMappingURL=store.js.map

package/dist/export/invoice-pdf.d.ts

@@ -15,6 +15,8 @@ export interface InvoicePdfOptions {
     };
     /** Coste real de IA imputado al periodo (cuota amortizada). Solo informativo. */
     readonly amortizedAiCost?: Money;
+    /** Sin tarifa ni importes: solo las horas. Por defecto, con importes. */
+    readonly withAmounts?: boolean;
     readonly footer?: string;
 }
 export declare function invoiceToPdf(invoice: Invoice, client: Client, project: Project, options?: InvoicePdfOptions): Buffer;

package/dist/export/invoice-pdf.js

@@ -15,6 +15,9 @@ function invoiceToPdf(invoice, client, project, options = {}) {
     // Los importes van con el locale del documento, no con el de la terminal: el
     // cliente lee "€1.254,79" o "€1,254.79" según SU idioma.
     const money = (m) => (0, shared_1.formatMoney)(m, (0, index_js_1.moneyLocale)((0, index_js_1.getLang)()));
+    const withAmounts = options.withAmounts !== false;
+    // Sin tarifa ni importe, el tiempo pasa a ser la última columna.
+    const colTime = withAmounts ? COL_TIME : COL_AMOUNT;
     let y = M;
     // --- Cabecera -------------------------------------------------------------
     doc.text(M, y + 4, (0, index_js_1.tr) `INFORME DE HORAS`, "Helvetica-Bold", 20);
@@ -57,20 +60,22 @@ function invoiceToPdf(invoice, client, project, options = {}) {
     // --- Cabecera de tabla ----------------------------------------------------
     const header = () => {
         doc.text(M, y, (0, index_js_1.tr) `CONCEPTO`, "Helvetica-Bold", 8, 0.45);
-        doc.textRight(COL_TIME, y, (0, index_js_1.tr) `TIEMPO`, "Helvetica-Bold", 8, 0.45);
-        doc.textRight(COL_RATE, y, (0, index_js_1.tr) `TARIFA`, "Helvetica-Bold", 8, 0.45);
-        doc.textRight(COL_AMOUNT, y, (0, index_js_1.tr) `IMPORTE`, "Helvetica-Bold", 8, 0.45);
+        doc.textRight(colTime, y, (0, index_js_1.tr) `TIEMPO`, "Helvetica-Bold", 8, 0.45);
+        if (withAmounts) {
+            doc.textRight(COL_RATE, y, (0, index_js_1.tr) `TARIFA`, "Helvetica-Bold", 8, 0.45);
+            doc.textRight(COL_AMOUNT, y, (0, index_js_1.tr) `IMPORTE`, "Helvetica-Bold", 8, 0.45);
+        }
         y += 7;
         doc.line(M, y, COL_AMOUNT, y, 0.8, 0.3);
         y += 15;
     };
     header();
     // --- Conceptos ------------------------------------------------------------
-    // La columna TIEMPO se alinea a la derecha en COL_TIME, así que su texto crece
+    // La columna TIEMPO se alinea a la derecha en colTime, así que su texto crece
     // hacia la izquierda. Hay que restar el más ancho de esos textos, no un hueco
     // fijo, o la descripción se le mete encima.
     const widestTime = invoice.lines.reduce((max, l) => Math.max(max, pdf_js_1.PdfDocument.measure((0, shared_1.formatDuration)(l.seconds), "Helvetica", 10)), 0);
-    const maxDescWidth = COL_TIME - M - widestTime - 14;
+    const maxDescWidth = colTime - M - widestTime - 14;
     for (const line of invoice.lines) {
         if (y > BOTTOM - 60) {
             doc.newPage();
@@ -79,9 +84,11 @@ function invoiceToPdf(invoice, client, project, options = {}) {
         }
         const text = pdf_js_1.PdfDocument.truncate(line.description, "Helvetica", 10, maxDescWidth);
         doc.text(M, y, text, "Helvetica", 10);
-        doc.textRight(COL_TIME, y, (0, shared_1.formatDuration)(line.seconds), "Helvetica", 10, 0.2);
-        doc.textRight(COL_RATE, y, `${money(line.hourlyRate)}/h`, "Helvetica", 10, 0.4);
-        doc.textRight(COL_AMOUNT, y, money(line.amount), "Helvetica", 10);
+        doc.textRight(colTime, y, (0, shared_1.formatDuration)(line.seconds), "Helvetica", 10, 0.2);
+        if (withAmounts) {
+            doc.textRight(COL_RATE, y, `${money(line.hourlyRate)}/h`, "Helvetica", 10, 0.4);
+            doc.textRight(COL_AMOUNT, y, money(line.amount), "Helvetica", 10);
+        }
         y += 9;
         doc.line(M, y, COL_AMOUNT, y, 0.4, 0.9);
         y += 12;
@@ -95,19 +102,22 @@ function invoiceToPdf(invoice, client, project, options = {}) {
     doc.line(M, y, COL_AMOUNT, y, 0.8, 0.3);
     y += 18;
     doc.text(M, y, invoice.lines.length === 1 ? (0, index_js_1.tr) `1 concepto` : (0, index_js_1.tr) `${invoice.lines.length} conceptos`, "Helvetica", 9, 0.4);
-    doc.textRight(COL_TIME, y, (0, shared_1.formatDuration)(invoice.totalSeconds), "Helvetica-Bold", 10);
-    doc.textRight(COL_AMOUNT, y, money(invoice.subtotal), "Helvetica", 10);
+    doc.textRight(colTime, y, (0, shared_1.formatDuration)(invoice.totalSeconds), "Helvetica-Bold", 10);
+    if (withAmounts)
+        doc.textRight(COL_AMOUNT, y, money(invoice.subtotal), "Helvetica", 10);
     y += 18;
-    if (invoice.aiCostBilled) {
+    if (withAmounts && invoice.aiCostBilled) {
         doc.text(M, y, (0, index_js_1.tr) `Coste de IA repercutido (1 USD = ${invoice.usdFxRate} ${invoice.currency})`, "Helvetica", 9, 0.4);
         doc.textRight(COL_AMOUNT, y, money(invoice.aiCostBilled), "Helvetica", 10);
         y += 18;
     }
-    y += 4;
-    doc.rect(rightCol - 20, y - 14, COL_AMOUNT - rightCol + 20, 32, 0.94);
-    doc.text(rightCol - 8, y + 2, (0, index_js_1.tr) `VALOR`, "Helvetica-Bold", 11);
-    doc.textRight(COL_AMOUNT - 8, y + 3, money(invoice.total), "Helvetica-Bold", 14);
-    y += 46;
+    if (withAmounts) {
+        y += 4;
+        doc.rect(rightCol - 20, y - 14, COL_AMOUNT - rightCol + 20, 32, 0.94);
+        doc.text(rightCol - 8, y + 2, (0, index_js_1.tr) `VALOR`, "Helvetica-Bold", 11);
+        doc.textRight(COL_AMOUNT - 8, y + 3, money(invoice.total), "Helvetica-Bold", 14);
+        y += 46;
+    }
     // Aquí había una "NOTA INTERNA (no se comparte)" con el consumo de IA del
     // periodo. Se quitó: esa frase era un deseo, no un mecanismo. Este PDF es
     // justamente el que se adjunta a la factura del cliente, así que en cuanto

package/dist/i18n/en.js

@@ -579,5 +579,50 @@ exports.EN = {
     "ESTELA_OFFLINE=1: Estela no se conecta a la red. Quita la variable para usar tu cuenta.": "ESTELA_OFFLINE=1: Estela doesn't connect to the network. Unset it to use your account.",
     // ── statusline install: VS Code ──
     "Solo en Claude Code en la terminal: la extensión de VS Code no enseña la status line.": "Only in Claude Code in the terminal: the VS Code extension doesn't show the status line.",
+    // ── estela plan ──
+    "--days tiene que ser un número entero de 1 a {0}.": "--days has to be a whole number from 1 to {0}.",
+    "Plan desconocido: \"{0}\". Usa pro, max5 o max20.": "Unknown plan: \"{0}\". Use pro, max5 or max20.",
+    "--since tiene que ser una fecha AAAA-MM-DD.": "--since has to be a YYYY-MM-DD date.",
+    "Plan declarado: {0}, desde {1}. El análisis solo usa lo guardado desde esa fecha.": "Plan declared: {0}, since {1}. The analysis only uses what was stored from that date.",
+    "Si ya lo tenías antes, indica desde cuándo: estela plan set {0} --since AAAA-MM-DD": "If you had it before, say since when: estela plan set {0} --since YYYY-MM-DD",
+    "Ventanas de 5 h": "5-hour windows",
+    "ninguna completa todavía": "none yet",
+    "{0} ventanas · pico mediano {1} % · p90 {2} % · máximo {3} %": "{0} windows · median peak {1}% · p90 {2}% · max {3}%",
+    "Topes (≥95 %)": "Caps (≥95%)",
+    "Parado tras topes": "Stopped after caps",
+    "hasta {0} (estimado: no sabemos si seguías trabajando)": "up to {0} (estimated: we don't know if you kept working)",
+    "Semana": "Week",
+    "sin datos de la semana": "no weekly data",
+    "pico mediano {0} % · máximo {1} % · {2} semanas ≥ 90 %": "median peak {0}% · max {1}% · {2} weeks ≥ 90%",
+    "Bloqueos (429)": "Blocks (429)",
+    "{0} de 5 h · {1} semanales, según los transcripts de Claude Code": "{0} 5-hour · {1} weekly, from Claude Code's transcripts",
+    "Si estuvieras en…": "If you were on…",
+    "Datos de {0} días. La recomendación necesita al menos 14.": "{0} days of data. The recommendation needs at least 14.",
+    "Recomendación (provisional, {0} días)": "Recommendation (provisional, {0} days)",
+    "Recomendación": "Recommendation",
+    "Límite semanal entre planes: Anthropic no publica la relación. No lo estimamos.": "Weekly limit between plans: Anthropic doesn't publish the ratio. We don't estimate it.",
+    "Basado en el multiplicador por sesión publicado por Anthropic:": "Based on the per-session multiplier published by Anthropic:",
+    "Anthropic puede cambiar los límites; repite el análisis cada mes.": "Anthropic may change the limits; run this again every month.",
+    "Precios según la web de Anthropic a {0}; compruébalo: {1}": "Prices from Anthropic's website as of {0}; check them: {1}",
+    "Esa fecha tiene más de {0} días: los precios pueden estar desactualizados.": "That date is more than {0} days old: prices may be out of date.",
+    "(desde {0})": "(since {0})",
+    "{0} días con datos": "{0} days with data",
+    "sin topes, igual que ahora": "no caps, same as now",
+    "p90 equivalente {0} % · habrías evitado {1} de {2} topes (con el uso que llegó a registrarse)": "equivalent p90 {0}% · you'd have avoided {1} of {2} caps (with the usage that got recorded)",
+    "p90 equivalente {0} % · no te habría bloqueado en ninguna de las {1} ventanas": "equivalent p90 {0}% · wouldn't have blocked you in any of the {1} windows",
+    "p90 equivalente {0} % · te habría bloqueado en {1} de {2} ventanas": "equivalent p90 {0}% · would have blocked you in {1} of {2} windows",
+    "Vas justo con tu plan. Con {0} habrías evitado {1} de {2} topes.": "Your plan is tight for you. With {0} you'd have avoided {1} of {2} caps.",
+    "Vas justo con tu plan.": "Your plan is tight for you.",
+    "Con los datos de estas {0} semanas, el plan {1} te habría bastado en todas las ventanas de 5 h.": "Based on these {0} weeks of data, the {1} plan would have been enough in every 5-hour window.",
+    "El plan {0} te habría bastado casi siempre: te habría bloqueado {1} veces en estas semanas.": "The {0} plan would have been enough almost always: it would have blocked you {1} times in these weeks.",
+    "Tu plan actual encaja con tu uso.": "Your current plan fits your usage.",
+    "{0} menos al mes, según la web de Anthropic a {1}; compruébalo.": "{0} less per month, per Anthropic's website as of {1}; check it.",
+    "{0} más al mes, según la web de Anthropic a {1}; compruébalo.": "{0} more per month, per Anthropic's website as of {1}; check it.",
+    "estela plan compara tu uso real de Claude con los otros planes. Primero dime cuál pagas:": "estela plan compares your real Claude usage with the other plans. First tell it which one you pay for:",
+    "Si ya lo tenías antes de hoy, añade desde cuándo: --since AAAA-MM-DD": "If you had it before today, add since when: --since YYYY-MM-DD",
+    "Este análisis solo funciona con planes Pro o Max.": "This analysis only works with Pro or Max plans.",
+    "Aún no hay datos. Instala la status line (estela statusline install) y vuelve en unos días.": "No data yet. Install the status line (estela statusline install) and come back in a few days.",
+    "Solo se recogen en Claude Code en la terminal: la extensión de VS Code no ejecuta la status line.": "They're only collected in Claude Code in the terminal: the VS Code extension doesn't run the status line.",
+    "{0} $": "${0}",
 };
 //# sourceMappingURL=en.js.map