estela 0.2.4 → 0.3.2

package/dist/metrics/plan.d.ts

@@ -0,0 +1,110 @@
+import { type ClaudePlan, type ClaudePlanId } from "../plan-prices.js";
+import type { RateSample } from "../rate-history.js";
+/**
+ * "¿El plan de Claude que pago es el que me conviene?"
+ *
+ * Funciones puras sobre el historial de la status line (rate-limits.jsonl):
+ * entran muestras, salen cifras, y cada cifra tiene su test.
+ *
+ * La regla de siempre, más estricta aquí que en ningún sitio: Estela no
+ * inventa ni estima el límite de ningún plan. Usa solo
+ *
+ *  - los porcentajes que manda Claude Code, tal cual, y
+ *  - el multiplicador por sesión de 5 h que publica Anthropic (plan-prices.ts).
+ *
+ * Por eso la comparación entre planes es solo de la ventana de 5 h: del
+ * límite semanal Anthropic no publica la relación entre planes, y no se
+ * calcula. Y nada de "te quedan X" ni de cuándo te vas a quedar sin cuota.
+ */
+/** Pico desde el que una ventana cuenta como tope. */
+export declare const CAP_AT = 95;
+export declare const MIN_DAYS = 7;
+export declare const FULL_DAYS = 14;
+export interface FiveHourWindow {
+    /** `resets_at` de la ventana (epoch en s). */
+    readonly reset: number;
+    readonly peak: number;
+    readonly samples: number;
+    readonly capped: boolean;
+    /** Desde la primera muestra ≥ 99 % hasta el reinicio (o hasta ahora). Cota superior, estimada. */
+    readonly stoppedMs: number;
+}
+export interface WeekWindow {
+    readonly reset: number;
+    readonly peak: number;
+}
+export interface Alternative {
+    readonly plan: ClaudePlan;
+    readonly direction: "lower" | "higher";
+    readonly p90Equivalent: number;
+    readonly maxEquivalent: number;
+    /** Ventanas cuyo pico equivalente pasa de 100: te habrían bloqueado. */
+    readonly blockedWindows: number;
+    /** Subiendo de plan: topes de ahora cuyo pico equivalente se queda por debajo del tope. */
+    readonly capsAvoided: number;
+}
+export type Recommendation = {
+    readonly kind: "tight";
+    readonly higher: ClaudePlan | null;
+    readonly capsAvoided: number | null;
+} | {
+    readonly kind: "enough";
+    readonly plan: ClaudePlan;
+    readonly weeks: number;
+} | {
+    readonly kind: "almost";
+    readonly plan: ClaudePlan;
+    readonly blocked: number;
+} | {
+    readonly kind: "fits";
+};
+export type DataState = "none" | "insufficient" | "provisional" | "ok";
+export interface PlanAnalysis {
+    readonly plan: ClaudePlan;
+    readonly since: Date;
+    readonly from: Date;
+    readonly to: Date;
+    readonly days: number;
+    readonly daysWithData: number;
+    readonly samples: number;
+    readonly dataState: DataState;
+    readonly fiveHour: {
+        readonly windows: readonly FiveHourWindow[];
+        readonly medianPeak: number | null;
+        readonly p90Peak: number | null;
+        readonly maxPeak: number | null;
+        readonly caps: number;
+        readonly stoppedMs: number;
+    };
+    readonly week: {
+        readonly weeks: readonly WeekWindow[];
+        readonly medianPeak: number | null;
+        readonly maxPeak: number | null;
+        readonly weeksAtOrAbove90: number;
+    };
+    readonly alternatives: readonly Alternative[];
+    /** null con menos de 7 días de datos. */
+    readonly recommendation: Recommendation | null;
+}
+export interface PlanAnalysisInput {
+    readonly samples: readonly RateSample[];
+    readonly plan: ClaudePlanId;
+    readonly since: Date;
+    readonly now: Date;
+    /** Período, en días hacia atrás desde `now`. */
+    readonly days: number;
+    /** Para contar los días con datos en tu zona horaria. Por defecto, la de esta máquina. */
+    readonly localDay?: (ms: number) => string;
+}
+export declare function analyzePlan(input: PlanAnalysisInput): PlanAnalysis;
+/**
+ * Una ventana por `resets_at`, redondeado al minuto: dos sesiones pueden
+ * mandar el mismo reinicio con segundos distintos. Una muestra sin reinicio
+ * no se puede asignar a ninguna ventana y no cuenta.
+ */
+export declare function fiveHourWindows(samples: readonly RateSample[], now: Date): FiveHourWindow[];
+export declare function weekWindows(samples: readonly RateSample[]): WeekWindow[];
+export declare function median(values: readonly number[]): number | null;
+/** Percentil 90 por rango más cercano: siempre es un valor observado. */
+export declare function p90(values: readonly number[]): number | null;
+//# sourceMappingURL=plan.d.ts.map

package/dist/metrics/plan.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FULL_DAYS = exports.MIN_DAYS = exports.CAP_AT = void 0;
+exports.analyzePlan = analyzePlan;
+exports.fiveHourWindows = fiveHourWindows;
+exports.weekWindows = weekWindows;
+exports.median = median;
+exports.p90 = p90;
+const plan_prices_js_1 = require("../plan-prices.js");
+/**
+ * "¿El plan de Claude que pago es el que me conviene?"
+ *
+ * Funciones puras sobre el historial de la status line (rate-limits.jsonl):
+ * entran muestras, salen cifras, y cada cifra tiene su test.
+ *
+ * La regla de siempre, más estricta aquí que en ningún sitio: Estela no
+ * inventa ni estima el límite de ningún plan. Usa solo
+ *
+ *  - los porcentajes que manda Claude Code, tal cual, y
+ *  - el multiplicador por sesión de 5 h que publica Anthropic (plan-prices.ts).
+ *
+ * Por eso la comparación entre planes es solo de la ventana de 5 h: del
+ * límite semanal Anthropic no publica la relación entre planes, y no se
+ * calcula. Y nada de "te quedan X" ni de cuándo te vas a quedar sin cuota.
+ */
+/** Pico desde el que una ventana cuenta como tope. */
+exports.CAP_AT = 95;
+/** Desde aquí se cuenta el tiempo parado tras un tope. */
+const STOPPED_FROM = 99;
+/** Una semana con este pico o más es "ir justo". */
+const TIGHT_WEEK_AT = 90;
+const TIGHT_CAPS_PER_WEEK = 2;
+/** Un plan inferior "basta" si no habría bloqueado nunca y su p90 equivalente no pasa de aquí. */
+const ENOUGH_P90 = 80;
+const ALMOST_MAX_BLOCKS = 3;
+exports.MIN_DAYS = 7;
+exports.FULL_DAYS = 14;
+function analyzePlan(input) {
+    const plan = (0, plan_prices_js_1.planById)(input.plan);
+    if (!plan)
+        throw new Error(`plan desconocido: ${input.plan}`);
+    const to = input.now;
+    const from = new Date(Math.max(input.since.getTime(), to.getTime() - input.days * 86_400_000));
+    const localDay = input.localDay ?? defaultLocalDay;
+    const samples = dedupe(input.samples)
+        .filter((s) => s.ts >= from.getTime() && s.ts <= to.getTime())
+        .sort((a, b) => a.ts - b.ts);
+    const daysWithData = new Set(samples.map((s) => localDay(s.ts))).size;
+    const windows = fiveHourWindows(samples, to);
+    const peaks = windows.map((w) => w.peak);
+    const weeks = weekWindows(samples);
+    const weekPeaks = weeks.map((w) => w.peak);
+    const caps = windows.filter((w) => w.capped).length;
+    const alternatives = plan_prices_js_1.CLAUDE_PLANS.filter((p) => p.id !== plan.id).map((target) => {
+        const factor = plan.sessionMultiplier / target.sessionMultiplier;
+        const eq = windows.map((w) => w.peak * factor);
+        return {
+            plan: target,
+            direction: target.sessionMultiplier < plan.sessionMultiplier ? "lower" : "higher",
+            p90Equivalent: p90(eq) ?? 0,
+            maxEquivalent: eq.length ? Math.max(...eq) : 0,
+            blockedWindows: eq.filter((e) => e > 100).length,
+            capsAvoided: factor < 1 ? windows.filter((w) => w.capped && w.peak * factor < exports.CAP_AT).length : 0,
+        };
+    });
+    const dataState = samples.length === 0 ? "none"
+        : daysWithData < exports.MIN_DAYS ? "insufficient"
+            : daysWithData < exports.FULL_DAYS ? "provisional" : "ok";
+    const analysis = {
+        plan, since: input.since, from, to, days: input.days, daysWithData, samples: samples.length, dataState,
+        fiveHour: {
+            windows, medianPeak: median(peaks), p90Peak: p90(peaks), maxPeak: peaks.length ? Math.max(...peaks) : null,
+            caps, stoppedMs: windows.reduce((s, w) => s + w.stoppedMs, 0),
+        },
+        week: {
+            weeks, medianPeak: median(weekPeaks), maxPeak: weekPeaks.length ? Math.max(...weekPeaks) : null,
+            weeksAtOrAbove90: weekPeaks.filter((p) => p >= TIGHT_WEEK_AT).length,
+        },
+        alternatives,
+    };
+    return {
+        ...analysis,
+        recommendation: dataState === "provisional" || dataState === "ok" ? recommend(analysis) : null,
+    };
+}
+/** Las cuatro reglas, en orden. Conservadoras: ante la duda, el plan actual. */
+function recommend(a) {
+    const weeksOfData = a.daysWithData / 7;
+    const capsPerWeek = weeksOfData > 0 ? a.fiveHour.caps / weeksOfData : 0;
+    if (capsPerWeek >= TIGHT_CAPS_PER_WEEK || a.week.weeksAtOrAbove90 > 0) {
+        const higher = a.alternatives
+            .filter((x) => x.direction === "higher")
+            .sort((x, y) => x.plan.sessionMultiplier - y.plan.sessionMultiplier)[0];
+        return { kind: "tight", higher: higher?.plan ?? null, capsAvoided: higher ? higher.capsAvoided : null };
+    }
+    const lower = a.alternatives
+        .filter((x) => x.direction === "lower")
+        .sort((x, y) => x.plan.monthlyUsd - y.plan.monthlyUsd);
+    const enough = lower.find((x) => x.blockedWindows === 0 && x.p90Equivalent <= ENOUGH_P90);
+    if (enough)
+        return { kind: "enough", plan: enough.plan, weeks: Math.max(1, Math.round(weeksOfData)) };
+    const almost = lower.find((x) => x.blockedWindows >= 1 && x.blockedWindows <= ALMOST_MAX_BLOCKS);
+    if (almost)
+        return { kind: "almost", plan: almost.plan, blocked: almost.blockedWindows };
+    return { kind: "fits" };
+}
+// ---------------------------------------------------------------------------
+/**
+ * Una ventana por `resets_at`, redondeado al minuto: dos sesiones pueden
+ * mandar el mismo reinicio con segundos distintos. Una muestra sin reinicio
+ * no se puede asignar a ninguna ventana y no cuenta.
+ */
+function fiveHourWindows(samples, now) {
+    const groups = new Map();
+    for (const s of samples) {
+        if (s.w5 === undefined || s.w5_reset === undefined)
+            continue;
+        const key = Math.round(s.w5_reset / 60);
+        const g = groups.get(key);
+        if (g)
+            g.push(s);
+        else
+            groups.set(key, [s]);
+    }
+    return [...groups.entries()].sort((a, b) => a[0] - b[0]).map(([key, g]) => {
+        const peak = Math.max(...g.map((s) => s.w5));
+        const capped = peak >= exports.CAP_AT;
+        const first99 = g.filter((s) => s.w5 >= STOPPED_FROM).map((s) => s.ts).sort((a, b) => a - b)[0];
+        const end = Math.min(key * 60_000, now.getTime());
+        return {
+            reset: key * 60, peak, samples: g.length, capped,
+            stoppedMs: capped && first99 !== undefined ? Math.max(0, end - first99) : 0,
+        };
+    });
+}
+function weekWindows(samples) {
+    const peaks = new Map();
+    for (const s of samples) {
+        if (s.w7 === undefined || s.w7_reset === undefined)
+            continue;
+        const key = Math.round(s.w7_reset / 60);
+        peaks.set(key, Math.max(peaks.get(key) ?? -Infinity, s.w7));
+    }
+    return [...peaks.entries()].sort((a, b) => a[0] - b[0]).map(([key, peak]) => ({ reset: key * 60, peak }));
+}
+/** Dos sesiones a la vez pueden escribir la misma muestra. */
+function dedupe(samples) {
+    const seen = new Set();
+    return samples.filter((s) => {
+        const k = `${s.ts}|${s.w5}|${s.w5_reset}|${s.w7}|${s.w7_reset}`;
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return true;
+    });
+}
+function median(values) {
+    if (values.length === 0)
+        return null;
+    const v = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(v.length / 2);
+    return v.length % 2 ? v[mid] : (v[mid - 1] + v[mid]) / 2;
+}
+/** Percentil 90 por rango más cercano: siempre es un valor observado. */
+function p90(values) {
+    if (values.length === 0)
+        return null;
+    const v = [...values].sort((a, b) => a - b);
+    return v[Math.ceil(0.9 * v.length) - 1];
+}
+function defaultLocalDay(ms) {
+    const d = new Date(ms);
+    return `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
+}
+//# sourceMappingURL=plan.js.map

package/dist/plan-blocks.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Los bloqueos que Claude Code dejó escritos en sus transcripts.
+ *
+ * Los transcripts no traen los porcentajes de límite, pero cuando Claude Code
+ * recibe un 429 guarda la respuesta con un bloque `quotaLimits`: qué ventana
+ * fue (`five_hour` o `seven_day`) y cuándo se reinicia. Es un dato oficial y
+ * llega a antes de la 0.2.4, así que `estela plan` lo enseña como una línea
+ * aparte. No entra en el cálculo de equivalencias, que es solo de porcentajes.
+ *
+ * Los transcripts de un mes pueden pesar cientos de MB: se leen una vez y
+ * después solo lo nuevo de cada fichero, con lo visto guardado al lado de la
+ * base (`plan-blocks.json`).
+ */
+export interface RateLimitBlock {
+    readonly type: "five_hour" | "seven_day";
+    /** `resetsAt` (epoch en s). */
+    readonly reset: number;
+    /** El primer 429 de esa ventana (epoch en ms). */
+    readonly at: number;
+}
+export declare function blocksCachePath(dbPath: string): string;
+/** Lee lo nuevo de los transcripts y devuelve todos los bloqueos conocidos. */
+export declare function scanBlocks(root: string, cacheFile: string, now: Date): RateLimitBlock[];
+/** Los bloqueos de un texto JSONL. Solo se parsean las líneas que traen `quotaLimits`. */
+export declare function blocksIn(text: string): RateLimitBlock[];
+//# sourceMappingURL=plan-blocks.d.ts.map

package/dist/plan-blocks.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blocksCachePath = blocksCachePath;
+exports.scanBlocks = scanBlocks;
+exports.blocksIn = blocksIn;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const MAX_AGE_MS = 120 * 86_400_000;
+function blocksCachePath(dbPath) {
+    return (0, node_path_1.join)((0, node_path_1.dirname)(dbPath), "plan-blocks.json");
+}
+/** Lee lo nuevo de los transcripts y devuelve todos los bloqueos conocidos. */
+function scanBlocks(root, cacheFile, now) {
+    let cache = { files: {}, blocks: [] };
+    try {
+        cache = JSON.parse((0, node_fs_1.readFileSync)(cacheFile, "utf8"));
+    }
+    catch { /* primera vez */ }
+    const byKey = new Map(cache.blocks.map((b) => [`${b.type}|${b.reset}`, b]));
+    for (const file of jsonlFiles(root, now.getTime() - MAX_AGE_MS)) {
+        let size;
+        try {
+            size = (0, node_fs_1.statSync)(file).size;
+        }
+        catch {
+            continue;
+        }
+        const offset = cache.files[file] ?? 0;
+        const start = offset <= size ? offset : 0;
+        if (start >= size)
+            continue;
+        const { text, end } = readFrom(file, start, size);
+        for (const b of blocksIn(text)) {
+            const key = `${b.type}|${b.reset}`;
+            const prev = byKey.get(key);
+            if (!prev || b.at < prev.at)
+                byKey.set(key, b);
+        }
+        cache.files[file] = end;
+    }
+    const blocks = [...byKey.values()].filter((b) => b.at >= now.getTime() - MAX_AGE_MS).sort((a, b) => a.at - b.at);
+    try {
+        (0, node_fs_1.writeFileSync)(cacheFile, JSON.stringify({ files: cache.files, blocks }));
+    }
+    catch { /* sin caché se relee */ }
+    return blocks;
+}
+/** Los bloqueos de un texto JSONL. Solo se parsean las líneas que traen `quotaLimits`. */
+function blocksIn(text) {
+    const out = [];
+    let i = text.indexOf('"quotaLimits"');
+    while (i >= 0) {
+        const startLine = text.lastIndexOf("\n", i) + 1;
+        const endLine = text.indexOf("\n", i);
+        const line = text.slice(startLine, endLine < 0 ? text.length : endLine);
+        try {
+            const d = JSON.parse(line);
+            const q = d["quotaLimits"];
+            const type = q?.["rateLimitType"];
+            const reset = q?.["resetsAt"];
+            const at = Date.parse(String(d["timestamp"]));
+            if ((type === "five_hour" || type === "seven_day") && typeof reset === "number" && !Number.isNaN(at) &&
+                (d["apiErrorStatus"] === 429 || q?.["status"] === "rejected")) {
+                out.push({ type, reset, at });
+            }
+        }
+        catch { /* línea rota o a medias */ }
+        i = endLine < 0 ? -1 : text.indexOf('"quotaLimits"', endLine);
+    }
+    return out;
+}
+/** Hasta el último salto de línea: una línea a medias se lee entera la próxima vez. */
+function readFrom(file, start, size) {
+    const fd = (0, node_fs_1.openSync)(file, "r");
+    try {
+        const buf = Buffer.alloc(size - start);
+        (0, node_fs_1.readSync)(fd, buf, 0, buf.length, start);
+        const nl = buf.lastIndexOf(0x0a);
+        if (nl < 0)
+            return { text: "", end: start };
+        return { text: buf.subarray(0, nl + 1).toString("utf8"), end: start + nl + 1 };
+    }
+    finally {
+        (0, node_fs_1.closeSync)(fd);
+    }
+}
+function jsonlFiles(dir, modifiedAfter) {
+    const out = [];
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        const p = (0, node_path_1.join)(dir, e.name);
+        if (e.isDirectory())
+            out.push(...jsonlFiles(p, modifiedAfter));
+        else if (e.name.endsWith(".jsonl")) {
+            try {
+                if ((0, node_fs_1.statSync)(p).mtimeMs >= modifiedAfter)
+                    out.push(p);
+            }
+            catch { /* se borró mientras tanto */ }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=plan-blocks.js.map

package/dist/plan-prices.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Los planes de Claude que analiza `estela plan`: lo único que Estela sabe de
+ * ellos, en un solo sitio y con su fuente.
+ *
+ * - El multiplicador por sesión de 5 h es el que publica Anthropic: Max 5x da
+ *   5 veces la cuota por sesión de Pro, y Max 20x, 20 veces.
+ * - Del límite semanal Anthropic no publica la relación entre planes, así que
+ *   aquí no hay ningún número para él, y no se compara.
+ * - Los precios son los de la suscripción web, en USD al mes, y caducan:
+ *   `estela plan` avisa si la fecha de comprobación tiene más de 90 días.
+ */
+export type ClaudePlanId = "pro" | "max5" | "max20";
+export interface ClaudePlan {
+    readonly id: ClaudePlanId;
+    readonly name: string;
+    /** Veces la cuota por sesión de 5 h de Pro. */
+    readonly sessionMultiplier: number;
+    readonly monthlyUsd: number;
+}
+export declare const CLAUDE_PLANS: readonly ClaudePlan[];
+export declare const MULTIPLIER_SOURCE = "https://support.claude.com/en/articles/11049741-what-is-the-max-plan";
+export declare const PRICES_SOURCE = "https://claude.com/pricing";
+/** Cuándo se comprobaron los precios en `PRICES_SOURCE`. */
+export declare const PRICES_CHECKED_AT = "2026-10-19";
+export declare const PRICES_STALE_DAYS = 90;
+export declare function planById(id: string): ClaudePlan | null;
+//# sourceMappingURL=plan-prices.d.ts.map

package/dist/plan-prices.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Los planes de Claude que analiza `estela plan`: lo único que Estela sabe de
+ * ellos, en un solo sitio y con su fuente.
+ *
+ * - El multiplicador por sesión de 5 h es el que publica Anthropic: Max 5x da
+ *   5 veces la cuota por sesión de Pro, y Max 20x, 20 veces.
+ * - Del límite semanal Anthropic no publica la relación entre planes, así que
+ *   aquí no hay ningún número para él, y no se compara.
+ * - Los precios son los de la suscripción web, en USD al mes, y caducan:
+ *   `estela plan` avisa si la fecha de comprobación tiene más de 90 días.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRICES_STALE_DAYS = exports.PRICES_CHECKED_AT = exports.PRICES_SOURCE = exports.MULTIPLIER_SOURCE = exports.CLAUDE_PLANS = void 0;
+exports.planById = planById;
+exports.CLAUDE_PLANS = [
+    { id: "pro", name: "Pro", sessionMultiplier: 1, monthlyUsd: 20 },
+    { id: "max5", name: "Max 5x", sessionMultiplier: 5, monthlyUsd: 100 },
+    { id: "max20", name: "Max 20x", sessionMultiplier: 20, monthlyUsd: 200 },
+];
+exports.MULTIPLIER_SOURCE = "https://support.claude.com/en/articles/11049741-what-is-the-max-plan";
+exports.PRICES_SOURCE = "https://claude.com/pricing";
+/** Cuándo se comprobaron los precios en `PRICES_SOURCE`. */
+exports.PRICES_CHECKED_AT = "2026-10-19";
+exports.PRICES_STALE_DAYS = 90;
+function planById(id) {
+    return exports.CLAUDE_PLANS.find((p) => p.id === id) ?? null;
+}
+//# sourceMappingURL=plan-prices.js.map

package/dist/plan-report.d.ts

@@ -0,0 +1,96 @@
+import type { PlanAnalysis } from "./metrics/plan.js";
+/**
+ * Lo que enseña `estela plan`: el texto (es/en) y el JSON.
+ *
+ * Aparte de cli.ts para poder comprobar cada frase: ninguna puede decir
+ * cuánto te queda ni hablar de tokens. Lo que hay son los porcentajes que
+ * mandó Claude Code y las equivalencias por el multiplicador publicado.
+ */
+export interface BlockCounts {
+    readonly fiveHour: number;
+    readonly sevenDay: number;
+}
+export interface ReportOptions {
+    readonly color: boolean;
+    readonly now: Date;
+    /** Bloqueos 429 de los transcripts en el período, si se pudieron leer. */
+    readonly blocks: BlockCounts | null;
+}
+export declare function renderPlanReport(a: PlanAnalysis, o: ReportOptions): string;
+export declare function recommendationText(a: PlanAnalysis): string;
+export declare function pricesStale(now: Date): boolean;
+/** Sin plan declarado: cómo declararlo. */
+export declare function renderNoPlan(): string;
+export declare function renderNoData(a: PlanAnalysis, apiKey: boolean, color: boolean): string;
+/**
+ * `estela plan --json`. Estructura estable (documentada en el README):
+ * campos nuevos se pueden añadir, ninguno cambia de nombre ni de significado.
+ */
+export declare function planToJson(a: PlanAnalysis, o: {
+    readonly blocks: BlockCounts | null;
+    readonly now: Date;
+}): {
+    version: number;
+    plan: {
+        id: import("./plan-prices.js").ClaudePlanId;
+        name: string;
+        since: string;
+        sessionMultiplier: number;
+    };
+    period: {
+        from: string;
+        to: string;
+        days: number;
+        daysWithData: number;
+        samples: number;
+    };
+    dataState: import("./metrics/plan.js").DataState;
+    fiveHour: {
+        windows: number;
+        medianPeak: number | null;
+        p90Peak: number | null;
+        maxPeak: number | null;
+        caps: number;
+        stoppedMinutesUpperBound: number;
+    };
+    week: {
+        weeks: number;
+        medianPeak: number | null;
+        maxPeak: number | null;
+        weeksAtOrAbove90: number;
+    };
+    blocks429: BlockCounts | null;
+    alternatives: {
+        plan: import("./plan-prices.js").ClaudePlanId;
+        name: string;
+        direction: "lower" | "higher";
+        monthlyUsd: number;
+        monthlyDiffUsd: number;
+        p90Equivalent: number | null;
+        maxEquivalent: number | null;
+        blockedWindows: number;
+        capsAvoided: number;
+    }[];
+    recommendation: {
+        kind: "tight" | "enough" | "almost" | "fits";
+        provisional: boolean;
+        plan: import("./plan-prices.js").ClaudePlanId | null;
+        blockedWindows: number | null;
+        capsAvoided: number | null;
+        text: string;
+    } | null;
+    weeklyBetweenPlans: string;
+    sources: {
+        sessionMultiplier: string;
+        prices: string;
+        pricesCheckedAt: string;
+        pricesStale: boolean;
+    };
+    plans: {
+        id: import("./plan-prices.js").ClaudePlanId;
+        name: string;
+        sessionMultiplier: number;
+        monthlyUsd: number;
+    }[];
+};
+//# sourceMappingURL=plan-report.d.ts.map