estela 0.3.4 → 0.4.0

package/dist/delivery/report.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliveryReport = deliveryReport;
+const shared_1 = require("@estela/shared");
+const amortize_js_1 = require("../billing/amortize.js");
+const spend_js_1 = require("../metrics/spend.js");
+function deliveryReport(input) {
+    const inPeriod = (d) => {
+        if (!d)
+            return false;
+        const day = (0, shared_1.localDate)(d);
+        return day >= input.from && day <= input.to;
+    };
+    const isPlanned = (i) => !!input.plan && ((input.plan.label !== undefined && i.labels.includes(input.plan.label)) ||
+        (input.plan.milestone !== undefined && i.milestone === input.plan.milestone));
+    const prsDelivered = input.items.filter((i) => i.kind === "pr" && i.completed && inPeriod(i.closedAt));
+    const closersOf = (issue) => prsDelivered.filter((pr) => pr.closes.includes(issue.key));
+    const deliveredInPeriod = (i) => i.kind === "pr"
+        ? i.completed && inPeriod(i.closedAt)
+        : (i.completed && inPeriod(i.closedAt)) || closersOf(i).length > 0;
+    // Lo que se cerró antes del periodo ya no es plan de este periodo.
+    const planned = input.items.filter((i) => isPlanned(i) && !(i.closedAt && (0, shared_1.localDate)(i.closedAt) < input.from
+        && !deliveredInPeriod(i)));
+    const plannedKeys = new Set(planned.map((i) => i.key));
+    const unplanned = input.items.filter((i) => {
+        if (isPlanned(i) || !deliveredInPeriod(i))
+            return false;
+        // Un PR que entrega algo del plan es la entrega de ese plan, no un extra.
+        if (i.kind === "pr" && i.closes.some((k) => plannedKeys.has(k)))
+            return false;
+        // Una issue cerrada por un PR extra ya va con su PR.
+        if (i.kind === "issue" && closersOf(i).length > 0)
+            return false;
+        return true;
+    });
+    const costs = new EntryIndex(input);
+    const line = (item) => {
+        const deliveredBy = item.kind === "issue" ? closersOf(item) : [];
+        const { ids, basis } = costs.entriesOf(item, deliveredBy);
+        return { item, deliveredBy, basis, ...costs.cost(ids) };
+    };
+    const block = (items) => {
+        const lines = items.map(line).sort((a, b) => b.consumption.microUsd - a.consumption.microUsd
+            || a.item.number - b.item.number);
+        const ids = new Set();
+        for (const i of items)
+            for (const id of costs.entriesOf(i, i.kind === "issue" ? closersOf(i) : []).ids)
+                ids.add(id);
+        return { lines, ...costs.cost(ids) };
+    };
+    return {
+        planned: input.plan ? {
+            delivered: block(planned.filter(deliveredInPeriod)),
+            pending: block(planned.filter((i) => !deliveredInPeriod(i))),
+        } : null,
+        unplanned: block(unplanned),
+    };
+}
+// ---------------------------------------------------------------------------
+/** Qué imputaciones se unen a cada issue o PR, y lo que cuestan. */
+class EntryIndex {
+    input;
+    byId = new Map();
+    byBranch = new Map();
+    byItem = new Map();
+    assignedByMonth = new Map();
+    constructor(input) {
+        this.input = input;
+        const push = (map, k, id) => {
+            const list = map.get(k) ?? [];
+            if (!list.includes(id))
+                list.push(id);
+            map.set(k, list);
+        };
+        // El PR de un merge registrado en git también une su rama con su número.
+        const prOfBranch = new Map();
+        for (const m of input.merges)
+            if (m.sourceBranch && m.ref)
+                prOfBranch.set(m.sourceBranch, m.ref);
+        for (const e of input.entries) {
+            this.byId.set(e.id, e);
+            if (e.branch)
+                push(this.byBranch, e.branch, e.id);
+            for (const k of e.workItems ?? [])
+                push(this.byItem, k, e.id);
+            const pr = e.branch ? prOfBranch.get(e.branch) : undefined;
+            if (pr)
+                push(this.byItem, pr, e.id);
+            const month = (0, amortize_js_1.monthOf)(e.startedAt);
+            this.assignedByMonth.set(month, (this.assignedByMonth.get(month) ?? 0) + e.aiCost.microUsd);
+        }
+    }
+    entriesOf(item, deliveredBy) {
+        const ids = new Set();
+        const basis = new Set();
+        for (const i of [item, ...deliveredBy]) {
+            const fromBranch = i.kind === "pr" && i.branch ? this.byBranch.get(i.branch) ?? [] : [];
+            const fromItem = this.byItem.get(i.key) ?? [];
+            if (fromBranch.length)
+                basis.add("branch");
+            if (fromItem.length)
+                basis.add("item");
+            for (const id of [...fromBranch, ...fromItem])
+                ids.add(id);
+        }
+        // Siempre en el mismo orden: la rama primero.
+        return { ids, basis: ["branch", "item"].filter((b) => basis.has(b)) };
+    }
+    cost(ids) {
+        let seconds = 0;
+        let micro = 0;
+        const byMonth = new Map();
+        for (const id of ids) {
+            const e = this.byId.get(id);
+            seconds += e.seconds;
+            micro += e.aiCost.microUsd;
+            const month = (0, amortize_js_1.monthOf)(e.startedAt);
+            byMonth.set(month, (byMonth.get(month) ?? 0) + e.aiCost.microUsd);
+        }
+        const { real, partial } = (0, spend_js_1.realFromMonths)(byMonth, this.input.subscriptions, (month) => Math.max(this.input.monthTotals.get(month)?.microUsd ?? 0, this.assignedByMonth.get(month) ?? 0));
+        return { seconds, consumption: { microUsd: micro }, real, realPartial: partial };
+    }
+}
+//# sourceMappingURL=report.js.map

package/dist/delivery/source.d.ts

@@ -0,0 +1,68 @@
+import type { TrackerSystem } from "@estela/shared";
+/**
+ * De dónde sale lo planificado y lo entregado de un periodo.
+ *
+ * Una interfaz y no GitHub a pelo: el plan de un equipo vive en GitHub, en
+ * Linear o en Jira, y lo que Estela hace con él (compararlo con lo entregado y
+ * ponerle el coste de IA) es lo mismo en los tres. Hoy solo existe GitHub.
+ *
+ * Una fuente es la única parte de Estela que habla con un servicio externo, y
+ * solo cuando quien la usa ejecuta el comando en un proyecto que la tiene
+ * configurada. Lo que lee se guarda en la base (tracker_items) para poder
+ * repetir el informe sin conexión.
+ */
+/** Una issue o un PR, ya normalizado. */
+export interface TrackerItem {
+    /** Clave como las de los tickets de las imputaciones: `github:12`. */
+    readonly key: string;
+    readonly kind: "issue" | "pr";
+    readonly number: number;
+    readonly title: string;
+    readonly state: "open" | "closed" | "merged";
+    /** Cerrada como hecha (issue) o fusionado (PR). Cerrar como "no se hará" no es entregar. */
+    readonly completed: boolean;
+    /** Cuándo se cerró o se fusionó. */
+    readonly closedAt: Date | null;
+    /** Rama del PR. Es lo que une un squash con el trabajo de su rama. */
+    readonly branch: string | null;
+    /** Issues que cierra este PR (`github:12`). */
+    readonly closes: readonly string[];
+    readonly labels: readonly string[];
+    readonly milestone: string | null;
+    readonly url: string;
+}
+/** Qué cuenta como planificado: una etiqueta o un milestone. */
+export interface PlanFilter {
+    readonly label?: string;
+    readonly milestone?: string;
+}
+export interface FetchQuery {
+    /** Fechas locales, inclusive. */
+    readonly from: string;
+    readonly to: string;
+    readonly plan: PlanFilter | null;
+    /**
+     * Prefijo de las etiquetas de cliente (`cliente:`). Con él se traen también
+     * las issues y PRs que las llevan, en cualquier estado: lo pedido por un
+     * cliente cuesta mientras se trabaja, no solo al entregarse.
+     */
+    readonly clientLabelPrefix?: string;
+}
+export type Availability = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: "missing" | "auth" | "repo";
+    readonly detail: string;
+};
+export interface PlanSource {
+    readonly system: TrackerSystem;
+    /** Si se puede leer ahora: instalado, con sesión y con un repo que la fuente entienda. */
+    availability(): Promise<Availability>;
+    /**
+     * Lo planificado (según el filtro, en cualquier estado) más lo entregado en
+     * el periodo (PRs fusionados e issues cerradas).
+     */
+    fetch(query: FetchQuery): Promise<TrackerItem[]>;
+}
+//# sourceMappingURL=source.d.ts.map

package/dist/delivery/source.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=source.js.map

package/dist/export/csv.d.ts

@@ -1,9 +1,23 @@
 import type { Client, Invoice, Project, TimeEntry } from "@estela/shared";
 import { formatMoney } from "@estela/shared";
+import type { SpendBy, SpendProject, SpendProjectReport } from "../metrics/spend.js";
+import { type UndeliveredReport } from "../metrics/undelivered.js";
 export declare function timeEntriesToCsv(entries: readonly TimeEntry[], project: Project, client: Client, hourlyRateOf: (at: Date) => {
     amount: number;
     currency: string;
 } | null): string;
 export declare function invoiceToCsv(invoice: Invoice, client: Client, project: Project): string;
+/**
+ * `estela ai-cost --by … --csv`: una fila por rama o ticket. "Sin atribuir"
+ * va con la unidad vacía y atribuido = no, para que una tabla dinámica no la
+ * confunda con una rama que se llame así.
+ */
+export declare function spendToCsv(reports: readonly SpendProjectReport[], by: SpendBy): string;
+/**
+ * `estela ai-cost --undelivered --csv`: una fila por bloque y por rama. La
+ * columna "cuenta" dice si suma al gasto sin entrega: las ramas abiertas o de
+ * estado desconocido se listan, pero no cuentan.
+ */
+export declare function undeliveredToCsv(reports: readonly UndeliveredReport[], projects: ReadonlyMap<string, SpendProject>): string;
 export { formatMoney };
 //# sourceMappingURL=csv.d.ts.map

package/dist/export/csv.js

@@ -3,10 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatMoney = void 0;
 exports.timeEntriesToCsv = timeEntriesToCsv;
 exports.invoiceToCsv = invoiceToCsv;
+exports.spendToCsv = spendToCsv;
+exports.undeliveredToCsv = undeliveredToCsv;
 const shared_1 = require("@estela/shared");
 Object.defineProperty(exports, "formatMoney", { enumerable: true, get: function () { return shared_1.formatMoney; } });
 const localize_js_1 = require("../billing/localize.js");
 const index_js_1 = require("../i18n/index.js");
+const undelivered_js_1 = require("../metrics/undelivered.js");
 /**
  * Export a CSV.
  *
@@ -33,6 +36,14 @@ const COLUMNS = {
         lineHeader: ["concepto", "horas", "tarifa", "importe"],
         subtotal: "subtotal", aiBilled: "coste_ia_repercutido", total: "total",
         aiUsage: "consumo_ia_usd_equiv_api",
+        spend: ["proyecto", "cliente", "unidad", "atribuido", "ramas", "tickets", "pr", "segun", "horas",
+            "coste_ia_usd_equiv_api", "gasto_real", "moneda", "gasto_real_parcial", "incluye_copilot_sin_coste"],
+        undelivered: ["proyecto", "cliente", "bloque", "detalle", "cuenta", "dias_sin_actividad",
+            "coste_ia_usd_equiv_api", "gasto_real", "moneda", "gasto_real_parcial", "pct_del_gasto"],
+        blocks: { total: "gasto_del_periodo", sessions: "sesiones_sin_commit", later: "de_ellas_con_commit_despues",
+            unverifiable: "sesiones_sin_datos_de_commits",
+            unmerged: "rama_sin_fusionar", open: "rama_abierta", unknown: "rama_desconocida",
+            undelivered: "sin_entrega_total" },
     },
     en: {
         entries: ["date", "start", "end", "hours", "description", "project", "client",
@@ -44,6 +55,14 @@ const COLUMNS = {
         lineHeader: ["item", "hours", "rate", "amount"],
         subtotal: "subtotal", aiBilled: "ai_cost_passed_on", total: "total",
         aiUsage: "ai_usage_usd_api_equiv",
+        spend: ["project", "client", "unit", "attributed", "branches", "tickets", "pr", "basis", "hours",
+            "ai_cost_usd_api_equiv", "real_spend", "currency", "real_spend_partial", "includes_unpriced_copilot"],
+        undelivered: ["project", "client", "block", "detail", "counts", "idle_days",
+            "ai_cost_usd_api_equiv", "real_spend", "currency", "real_spend_partial", "pct_of_spend"],
+        blocks: { total: "period_spend", sessions: "sessions_without_commit", later: "of_which_committed_later",
+            unverifiable: "sessions_without_commit_data",
+            unmerged: "unmerged_branch", open: "open_branch", unknown: "unknown_branch",
+            undelivered: "undelivered_total" },
     },
 };
 /** Escapa un campo. Sin esto, un commit con una coma parte la fila en dos. */
@@ -113,4 +132,63 @@ function invoiceToCsv(invoice, client, project) {
     lines.push([c.aiUsage, "", "", (invoice.aiCost.microUsd / 1_000_000).toFixed(4)]);
     return rows(lines);
 }
+/**
+ * `estela ai-cost --by … --csv`: una fila por rama o ticket. "Sin atribuir"
+ * va con la unidad vacía y atribuido = no, para que una tabla dinámica no la
+ * confunda con una rama que se llame así.
+ */
+function spendToCsv(reports, by) {
+    const c = COLUMNS[(0, index_js_1.getLang)()];
+    const lines = [[...c.spend]];
+    for (const r of reports) {
+        for (const u of r.units) {
+            lines.push([
+                r.project.name,
+                r.project.clientName,
+                u.key === null ? "" : by === "branch" ? u.key : u.items.map(shared_1.formatWorkItem).join(" "),
+                u.key === null ? c.no : c.yes,
+                u.branches.join(" "),
+                u.items.map(shared_1.formatWorkItem).join(" "),
+                u.prs.map(shared_1.formatWorkItem).join(" "),
+                u.basis.join(" "),
+                (u.seconds / 3600).toFixed(4),
+                (u.consumption.microUsd / 1_000_000).toFixed(4),
+                u.real ? (u.real.amount / 10 ** shared_1.MINOR_UNIT_DIGITS[u.real.currency]).toFixed(shared_1.MINOR_UNIT_DIGITS[u.real.currency]) : "",
+                u.real?.currency ?? "",
+                u.realPartial ? c.yes : c.no,
+                u.unpricedAgents ? c.yes : c.no,
+            ]);
+        }
+    }
+    return rows(lines);
+}
+/**
+ * `estela ai-cost --undelivered --csv`: una fila por bloque y por rama. La
+ * columna "cuenta" dice si suma al gasto sin entrega: las ramas abiertas o de
+ * estado desconocido se listan, pero no cuentan.
+ */
+function undeliveredToCsv(reports, projects) {
+    const c = COLUMNS[(0, index_js_1.getLang)()];
+    const lines = [[...c.undelivered]];
+    const amount = (s) => s.real
+        ? (s.real.amount / 10 ** shared_1.MINOR_UNIT_DIGITS[s.real.currency]).toFixed(shared_1.MINOR_UNIT_DIGITS[s.real.currency]) : "";
+    for (const r of reports) {
+        const p = projects.get(r.projectId);
+        const push = (block, detail, counts, idle, s) => lines.push([
+            p?.name ?? r.projectId, p?.clientName ?? "", block, detail, counts ? c.yes : c.no, idle ?? "",
+            (s.consumption.microUsd / 1_000_000).toFixed(4), amount(s), s.real?.currency ?? "",
+            s.realPartial ? c.yes : c.no, (0, undelivered_js_1.shareOf)(s, r.total)?.toFixed(2) ?? "",
+        ]);
+        push(c.blocks.total, "", false, null, r.total);
+        push(c.blocks.sessions, String(r.sessionsWithoutCommit.count), true, null, r.sessionsWithoutCommit);
+        push(c.blocks.later, String(r.sessionsWithoutCommit.laterCommitted.count), false, null, r.sessionsWithoutCommit.laterCommitted);
+        push(c.blocks.unverifiable, String(r.unverifiable.count), false, null, r.unverifiable);
+        for (const b of r.unmerged.branches)
+            push(c.blocks.unmerged, b.branch, true, b.idleDays, b);
+        for (const b of r.notCounted)
+            push(b.state === "open" ? c.blocks.open : c.blocks.unknown, b.branch, false, b.idleDays, b);
+        push(c.blocks.undelivered, "", false, null, r.undelivered);
+    }
+    return rows(lines);
+}
 //# sourceMappingURL=csv.js.map

package/dist/export/finance.d.ts

@@ -0,0 +1,79 @@
+import type { Currency } from "@estela/shared";
+import type { Cost } from "../delivery/report.js";
+/**
+ * El informe para finanzas: el gasto de IA de un periodo contado para alguien
+ * que no programa.
+ *
+ * Los titulares hablan de dinero pagado, clientes y entregas; "tokens",
+ * "sesiones" y "precio de API" solo aparecen al final, en cómo se calcula.
+ * Junta lo que ya calculan los demás informes (ai-cost --by, --undelivered,
+ * delivery) sin calcular nada nuevo: aquí solo se ordena y se escribe.
+ */
+export interface FinanceProject {
+    readonly id: string;
+    readonly name: string;
+    readonly cost: Cost;
+}
+export interface FinanceClient {
+    readonly id: string;
+    readonly name: string;
+    readonly cost: Cost;
+    readonly projects: readonly FinanceProject[];
+}
+export interface FinanceDelivery {
+    readonly label: string;
+    readonly cost: Cost;
+}
+export interface FinanceDeliveries {
+    readonly projectName: string;
+    readonly clientName: string;
+    /** "github": lo leído de GitHub con `estela delivery`; "git": solo merges y squash. */
+    readonly source: "github" | "git";
+    readonly fetchedAt: Date | null;
+    readonly delivered: readonly FinanceDelivery[];
+    readonly plan: {
+        readonly label: string;
+        readonly delivered: number;
+        readonly total: number;
+        readonly pending: Cost;
+        readonly unplanned: Cost;
+    } | null;
+    readonly requests: readonly {
+        readonly name: string;
+        readonly mapped: boolean;
+        readonly cost: Cost;
+    }[] | null;
+    readonly requestsRest: Cost | null;
+}
+export interface FinanceUndelivered {
+    readonly projectName: string;
+    readonly total: Cost;
+    readonly undelivered: Cost;
+    readonly withoutCommit: Cost;
+    readonly unmergedBranches: Cost;
+    readonly unmergedCount: number;
+}
+export interface FinanceSummary {
+    readonly from: string;
+    readonly to: string;
+    /** La moneda de la cuota; `null` sin suscripción registrada (todo va a precio de API). */
+    readonly currency: Currency | null;
+    /** Todo el gasto de la máquina en el periodo, con o sin proyecto. */
+    readonly paid: Cost;
+    readonly unassigned: Cost;
+    readonly clients: readonly FinanceClient[];
+    readonly deliveries: readonly FinanceDeliveries[];
+    readonly undelivered: readonly FinanceUndelivered[];
+    readonly staleDays: number;
+    /** Hubo trabajo con Copilot, cuyo coste no se conoce. */
+    readonly unpricedAgents: boolean;
+}
+/** "octubre de 2026" si el periodo es un mes entero; si no, las dos fechas. */
+export declare function periodName(from: string, to: string): string;
+export declare function financeToMarkdown(s: FinanceSummary): string;
+/** Suma dos costes. El importe real se suma solo si los dos están en la misma moneda. */
+export declare function sum(a: Cost, b: Cost): Cost;
+/** Una fila por cifra, con la sección delante: se filtra en una hoja de cálculo. */
+export declare function financeToCsv(s: FinanceSummary): string;
+export declare function financeToJson(s: FinanceSummary): unknown;
+//# sourceMappingURL=finance.d.ts.map

package/dist/export/finance.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.periodName = periodName;
+exports.financeToMarkdown = financeToMarkdown;
+exports.sum = sum;
+exports.financeToCsv = financeToCsv;
+exports.financeToJson = financeToJson;
+const shared_1 = require("@estela/shared");
+const index_js_1 = require("../i18n/index.js");
+// ---------------------------------------------------------------------------
+/** El importe que encabeza: lo pagado si hay cuota; si no, el valor a precio de API. */
+function amount(c, s) {
+    if (!s.currency)
+        return (0, shared_1.formatAiCost)(c.consumption);
+    return (c.real ? (0, shared_1.formatMoney)(c.real) : (0, shared_1.formatMoney)({ amount: 0, currency: s.currency })) + (c.realPartial ? "†" : "");
+}
+function pct(part, total, s) {
+    const p = s.currency ? part.real?.amount ?? 0 : part.consumption.microUsd;
+    const t = s.currency ? total.real?.amount ?? 0 : total.consumption.microUsd;
+    return t === 0 ? "—" : `${((p / t) * 100).toFixed(1)} %`;
+}
+const hours = (c) => (c.seconds ? (0, shared_1.formatDuration)(c.seconds) : "—");
+/** "octubre de 2026" si el periodo es un mes entero; si no, las dos fechas. */
+function periodName(from, to) {
+    const month = from.slice(0, 7);
+    const last = new Date(Date.UTC(Number(month.slice(0, 4)), Number(month.slice(5, 7)), 0)).getUTCDate();
+    if (from === `${month}-01` && (to === `${month}-${last}` || to === `${month}-31`)) {
+        const locale = (0, index_js_1.getLang)() === "en" ? "en-GB" : "es-ES";
+        return new Date(`${month}-15T12:00:00Z`).toLocaleDateString(locale, { month: "long", year: "numeric", timeZone: "UTC" });
+    }
+    return `${from} → ${to}`;
+}
+/** Una celda de tabla Markdown: sin barras ni saltos que la rompan. */
+const md = (text) => text.replace(/\|/g, "\\|").replace(/\s*\n\s*/g, " ");
+function financeToMarkdown(s) {
+    const out = [];
+    const projectsCount = s.clients.reduce((n, c) => n + c.projects.length, 0);
+    const undelivered = s.undelivered.reduce((acc, u) => sum(acc, u.undelivered), zero());
+    const projectsSpend = s.undelivered.reduce((acc, u) => sum(acc, u.total), zero());
+    const assigned = s.clients.reduce((acc, c) => sum(acc, c.cost), zero());
+    out.push((0, index_js_1.tr) `# Gasto en IA · ${periodName(s.from, s.to)}`, "");
+    out.push((0, index_js_1.tr) `## Resumen`, "");
+    out.push(s.currency
+        ? (0, index_js_1.tr) `- **Pagado en IA:** ${amount(s.paid, s)}, la cuota de las herramientas de IA repartida según su uso.`
+        : (0, index_js_1.tr) `- **Gasto en IA:** ${(0, shared_1.formatAiCost)(s.paid.consumption)} a precio de lista. No hay cuota registrada, así que es una estimación, no lo pagado.`);
+    const proyectos = projectsCount === 1 ? (0, index_js_1.tr) `1 proyecto` : (0, index_js_1.tr) `${projectsCount} proyectos`;
+    const clientes = s.clients.length === 1 ? (0, index_js_1.tr) `1 cliente` : (0, index_js_1.tr) `${s.clients.length} clientes`;
+    out.push((0, index_js_1.tr) `- **Horas de trabajo con IA:** ${hours(assigned)} en ${proyectos} de ${clientes}.`);
+    if (s.unassigned.consumption.microUsd > 0) {
+        out.push((0, index_js_1.tr) `- **Fuera de proyectos:** ${amount(s.unassigned, s)} (${pct(s.unassigned, s.paid, s)}) en trabajo que no es de ningún proyecto registrado.`);
+    }
+    if (projectsSpend.consumption.microUsd > 0) {
+        out.push((0, index_js_1.tr) `- **Sin entregar todavía:** ${pctApi(undelivered, projectsSpend)} del gasto en proyectos. Es una señal para revisar, no un juicio: explorar y descartar también es trabajo.`);
+    }
+    out.push("");
+    out.push((0, index_js_1.tr) `## Por cliente`, "");
+    out.push((0, index_js_1.tr) `| Cliente | Proyecto | Horas | Gasto | % del total |`, "|---|---|---:|---:|---:|");
+    for (const c of s.clients) {
+        for (const p of c.projects) {
+            out.push(`| ${md(c.name)} | ${md(p.name)} | ${hours(p.cost)} | ${amount(p.cost, s)} | ${pct(p.cost, s.paid, s)} |`);
+        }
+        if (c.projects.length > 1) {
+            out.push((0, index_js_1.tr) `| **${md(c.name)}** | **total** | **${hours(c.cost)}** | **${amount(c.cost, s)}** | **${pct(c.cost, s.paid, s)}** |`);
+        }
+    }
+    if (s.unassigned.consumption.microUsd > 0) {
+        out.push((0, index_js_1.tr) `| Fuera de proyectos | — | — | ${amount(s.unassigned, s)} | ${pct(s.unassigned, s.paid, s)} |`);
+    }
+    out.push((0, index_js_1.tr) `| **Total** | | **${hours(assigned)}** | **${amount(s.paid, s)}** | **100 %** |`, "");
+    const conEntregas = s.deliveries.filter((d) => d.delivered.length || d.plan);
+    if (conEntregas.length) {
+        out.push((0, index_js_1.tr) `## Qué se entregó`, "");
+        for (const d of conEntregas) {
+            out.push(`### ${md(d.projectName)} · ${md(d.clientName)}`, "");
+            if (d.plan) {
+                out.push((0, index_js_1.tr) `Del plan (${d.plan.label}) se entregaron ${d.plan.delivered} de ${d.plan.total}. Lo pendiente lleva ${amount(d.plan.pending, s)} de gasto; lo entregado fuera del plan, ${amount(d.plan.unplanned, s)}.`, "");
+            }
+            if (d.delivered.length) {
+                out.push((0, index_js_1.tr) `| Entrega | Horas | Gasto |`, "|---|---:|---:|");
+                for (const l of d.delivered.slice(0, 15))
+                    out.push(`| ${md(l.label)} | ${hours(l.cost)} | ${amount(l.cost, s)} |`);
+                if (d.delivered.length > 15)
+                    out.push((0, index_js_1.tr) `| … y ${d.delivered.length - 15} más | | |`);
+                out.push("");
+            }
+            out.push(d.source === "github"
+                ? (0, index_js_1.tr) `_Fuente: GitHub, leído el ${d.fetchedAt ? d.fetchedAt.toISOString().slice(0, 10) : "—"} con estela delivery._`
+                : (0, index_js_1.tr) `_Fuente: el historial de git (PR fusionados). Sin GitHub no se sabe qué estaba planificado._`, "");
+        }
+    }
+    const conPeticiones = s.deliveries.filter((d) => d.requests?.length);
+    if (conPeticiones.length) {
+        out.push((0, index_js_1.tr) `## Trabajo pedido por clientes`, "");
+        out.push((0, index_js_1.tr) `Qué parte del gasto fue a peticiones concretas de un cliente. No incluye ingresos ni contratos: Estela no los conoce.`, "");
+        out.push((0, index_js_1.tr) `| Proyecto | Quién lo pidió | Horas | Gasto |`, "|---|---|---:|---:|");
+        for (const d of conPeticiones) {
+            for (const r of d.requests) {
+                out.push(`| ${md(d.projectName)} | ${md(r.mapped ? r.name : (0, index_js_1.tr) `${r.name} (sin identificar)`)} | ${hours(r.cost)} | ${amount(r.cost, s)} |`);
+            }
+            if (d.requestsRest)
+                out.push((0, index_js_1.tr) `| ${md(d.projectName)} | sin petición de cliente | ${hours(d.requestsRest)} | ${amount(d.requestsRest, s)} |`);
+        }
+        out.push("");
+    }
+    if (s.undelivered.length) {
+        out.push((0, index_js_1.tr) `## Gasto que no ha llegado a entregarse`, "");
+        out.push((0, index_js_1.tr) `Trabajo que todavía no está en la versión principal del producto. Es una señal para revisar, no un juicio: explorar, probar y descartar también es trabajo, y parte llegará más adelante.`, "");
+        out.push((0, index_js_1.tr) `| Proyecto | Sin entregar | % del proyecto | Trabajo sin consolidar | Líneas de trabajo paradas |`, "|---|---:|---:|---:|---:|");
+        for (const u of s.undelivered) {
+            out.push(`| ${md(u.projectName)} | ${amount(u.undelivered, s)} | ${pctApi(u.undelivered, u.total)} | ${amount(u.withoutCommit, s)} | ${amount(u.unmergedBranches, s)} (${u.unmergedCount}) |`);
+        }
+        out.push("");
+    }
+    out.push((0, index_js_1.tr) `## Cómo se calcula`, "");
+    out.push((0, index_js_1.tr) `- Las herramientas de IA (Claude Code, Codex, Copilot) dejan en el ordenador un registro de cada conversación. Estela lo lee junto con git, sin enviar nada fuera.`);
+    out.push(s.currency
+        ? (0, index_js_1.tr) `- **Gasto:** la cuota mensual de las suscripciones registradas, repartida según el uso (tokens a precio de lista) de cada proyecto ese mes. El precio de lista sirve solo para repartir: con cuota fija no es lo que se paga.`
+        : (0, index_js_1.tr) `- **Gasto:** tokens a precio de lista de cada modelo. Si se paga una cuota fija, el gasto real es la cuota: regístrala con estela subscription add.`);
+    out.push((0, index_js_1.tr) `- **Valor de uso a precio de lista:** ${(0, shared_1.formatAiCost)(s.paid.consumption)} en todo el periodo.`);
+    out.push((0, index_js_1.tr) `- **Horas:** el tiempo entre mensajes de cada sesión de trabajo, sin contar pausas de más de 30 minutos. Dos tareas a la vez se reparten el mismo rato.`);
+    out.push((0, index_js_1.tr) `- **Entregas:** las horas se unen a una issue o un PR por la rama del PR y por su número en ramas o commits. Lo que no se une a nada no se reparte.`);
+    out.push((0, index_js_1.tr) `- **Sin entregar:** sesiones sin ningún commit y ramas sin fusionar tras ${s.staleDays} días. Lo que no se puede saber (una rama borrada que pudo fusionarse con squash) no cuenta.`);
+    if (s.unpricedAgents)
+        out.push((0, index_js_1.tr) `- Copilot no registra tokens: sus horas cuentan, pero su coste no se conoce y no está sumado.`);
+    if (s.paid.realPartial)
+        out.push((0, index_js_1.tr) `- † Algún mes no tenía cuota registrada: el importe solo cuenta los meses con cuota.`);
+    return out.join("\n") + "\n";
+}
+const pctApi = (part, total) => total.consumption.microUsd === 0 ? "—"
+    : `${((part.consumption.microUsd / total.consumption.microUsd) * 100).toFixed(1)} %`;
+function zero() { return { seconds: 0, consumption: { microUsd: 0 }, real: null, realPartial: false }; }
+/** Suma dos costes. El importe real se suma solo si los dos están en la misma moneda. */
+function sum(a, b) {
+    let real = a.real ?? b.real;
+    if (a.real && b.real && a.real.currency === b.real.currency)
+        real = { amount: a.real.amount + b.real.amount, currency: a.real.currency };
+    return { seconds: a.seconds + b.seconds, consumption: { microUsd: a.consumption.microUsd + b.consumption.microUsd },
+        real, realPartial: a.realPartial || b.realPartial };
+}
+// ---------------------------------------------------------------------------
+const CSV = {
+    es: { header: ["seccion", "cliente", "proyecto", "concepto", "horas", "gasto", "moneda", "valor_uso_usd_precio_lista", "pct"],
+        summary: "resumen", client: "cliente", delivery: "entrega", request: "peticion", undelivered: "sin_entrega",
+        paid: "pagado", unassigned: "fuera_de_proyectos", project: "proyecto", rest: "sin_peticion", total: "sin_entregar" },
+    en: { header: ["section", "client", "project", "item", "hours", "spend", "currency", "usage_value_usd_list_price", "pct"],
+        summary: "summary", client: "client", delivery: "delivery", request: "request", undelivered: "undelivered",
+        paid: "paid", unassigned: "outside_projects", project: "project", rest: "no_request", total: "undelivered" },
+};
+/** Una fila por cifra, con la sección delante: se filtra en una hoja de cálculo. */
+function financeToCsv(s) {
+    const c = CSV[(0, index_js_1.getLang)()];
+    const cell = (v) => {
+        const t = v === null || v === undefined ? "" : String(v);
+        return /[",\n\r]/.test(t) ? `"${t.replace(/"/g, '""')}"` : t;
+    };
+    const money = (x) => {
+        if (!s.currency)
+            return ["", ""];
+        const m = x.real ?? { amount: 0, currency: s.currency };
+        const d = shared_1.MINOR_UNIT_DIGITS[m.currency];
+        return [(m.amount / 10 ** d).toFixed(d), m.currency];
+    };
+    const pctOf = (part, total) => {
+        const p = s.currency ? part.real?.amount ?? 0 : part.consumption.microUsd;
+        const t = s.currency ? total.real?.amount ?? 0 : total.consumption.microUsd;
+        return t === 0 ? "" : ((p / t) * 100).toFixed(2);
+    };
+    const rows = [[...c.header]];
+    const row = (section, client, project, item, x, p) => rows.push([section, client, project, item, (x.seconds / 3600).toFixed(4), ...money(x),
+        (x.consumption.microUsd / 1_000_000).toFixed(4), p]);
+    row(c.summary, "", "", c.paid, s.paid, "100.00");
+    row(c.summary, "", "", c.unassigned, s.unassigned, pctOf(s.unassigned, s.paid));
+    for (const cl of s.clients)
+        for (const p of cl.projects)
+            row(c.client, cl.name, p.name, c.project, p.cost, pctOf(p.cost, s.paid));
+    for (const d of s.deliveries) {
+        for (const l of d.delivered)
+            row(c.delivery, d.clientName, d.projectName, l.label, l.cost, "");
+        for (const r of d.requests ?? [])
+            row(c.request, d.clientName, d.projectName, r.name, r.cost, "");
+        if (d.requests?.length && d.requestsRest)
+            row(c.request, d.clientName, d.projectName, c.rest, d.requestsRest, "");
+    }
+    for (const u of s.undelivered)
+        row(c.undelivered, "", u.projectName, c.total, u.undelivered, pctApi(u.undelivered, u.total).replace(" %", ""));
+    // BOM para que Excel abra los acentos y el euro sin destrozarlos.
+    return "" + rows.map((r) => r.map(cell).join(",")).join("\r\n") + "\r\n";
+}
+function financeToJson(s) {
+    const cost = (x) => ({ seconds: x.seconds, apiMicroUsd: x.consumption.microUsd,
+        real: x.real ? { amountMinor: x.real.amount, currency: x.real.currency } : null, realPartial: x.realPartial });
+    return {
+        period: { from: s.from, to: s.to }, currency: s.currency, staleDays: s.staleDays, unpricedAgents: s.unpricedAgents,
+        paid: cost(s.paid), unassigned: cost(s.unassigned),
+        clients: s.clients.map((c) => ({ id: c.id, name: c.name, ...cost(c.cost),
+            projects: c.projects.map((p) => ({ id: p.id, name: p.name, ...cost(p.cost) })) })),
+        deliveries: s.deliveries.map((d) => ({
+            project: d.projectName, client: d.clientName, source: d.source, fetchedAt: d.fetchedAt?.toISOString() ?? null,
+            delivered: d.delivered.map((l) => ({ label: l.label, ...cost(l.cost) })),
+            plan: d.plan ? { ...d.plan, pending: cost(d.plan.pending), unplanned: cost(d.plan.unplanned) } : null,
+            requests: d.requests?.map((r) => ({ name: r.name, mapped: r.mapped, ...cost(r.cost) })) ?? null,
+            requestsRest: d.requestsRest ? cost(d.requestsRest) : null,
+        })),
+        undelivered: s.undelivered.map((u) => ({ project: u.projectName, total: cost(u.total), undelivered: cost(u.undelivered),
+            withoutCommit: cost(u.withoutCommit), unmergedBranches: cost(u.unmergedBranches), unmergedCount: u.unmergedCount })),
+    };
+}
+//# sourceMappingURL=finance.js.map