estela 0.3.4 → 0.4.0

package/dist/db/schema.js

@@ -124,6 +124,49 @@ CREATE TABLE IF NOT EXISTS commits (
 );
 CREATE INDEX IF NOT EXISTS idx_commits_at ON commits(at);
 
+-- Qué cliente de Estela es cada nombre de las etiquetas "cliente:<nombre>"
+-- del gestor de tareas. Sin fila, se prueba con el id y el nombre del cliente.
+CREATE TABLE IF NOT EXISTS client_aliases (
+  label      TEXT PRIMARY KEY,
+  client_id  TEXT NOT NULL REFERENCES clients(id) ON DELETE CASCADE
+);
+
+-- Issues y PRs leídos del gestor de tareas (hoy, GitHub con gh) por
+-- "estela delivery". Se guardan para repetir el informe sin conexión y para
+-- saber que la rama de un PR fusionado con squash está entregada.
+CREATE TABLE IF NOT EXISTS tracker_items (
+  project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  kind        TEXT NOT NULL,
+  key         TEXT NOT NULL,
+  number      INTEGER NOT NULL,
+  title       TEXT NOT NULL,
+  state       TEXT NOT NULL,
+  completed   INTEGER NOT NULL,
+  closed_at   TEXT,
+  branch      TEXT,
+  closes      TEXT NOT NULL DEFAULT '',
+  labels      TEXT NOT NULL DEFAULT '',
+  milestone   TEXT,
+  url         TEXT NOT NULL DEFAULT '',
+  fetched_at  TEXT NOT NULL,
+  PRIMARY KEY (project_id, kind, key)
+);
+
+-- Commits de merge: lo único en git que dice qué rama se integró y con qué PR
+-- ("Merge pull request #12 from ana/login"). La tabla commits los descarta
+-- (--no-merges) porque no son trabajo; aquí se guardan solo para atribuir.
+CREATE TABLE IF NOT EXISTS merges (
+  repo_path      TEXT NOT NULL,
+  hash           TEXT NOT NULL,
+  at             TEXT NOT NULL,
+  -- Rama integrada, tal como la escribe el mensaje. NULL si no lo dice.
+  source_branch  TEXT,
+  -- PR o merge request (github:12, gitlab:45). NULL en un merge local.
+  ref            TEXT,
+  subject        TEXT NOT NULL,
+  PRIMARY KEY (repo_path, hash)
+);
+
 CREATE TABLE IF NOT EXISTS time_entries (
   id              TEXT PRIMARY KEY,
   project_id      TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
@@ -294,6 +337,54 @@ CREATE TABLE IF NOT EXISTS claude_plans (
  * empezar no es una opción de mantenimiento.
  */
 const MIGRATIONS = [
+    {
+        version: 20,
+        describe: "alias de cliente para las etiquetas cliente:<nombre>",
+        run: (db) => {
+            db.exec(`CREATE TABLE IF NOT EXISTS client_aliases (
+        label      TEXT PRIMARY KEY,
+        client_id  TEXT NOT NULL REFERENCES clients(id) ON DELETE CASCADE
+      )`);
+        },
+    },
+    {
+        version: 19,
+        describe: "issues y PRs del gestor de tareas, para planificado frente a entregado",
+        run: (db) => {
+            db.exec(`CREATE TABLE IF NOT EXISTS tracker_items (
+        project_id  TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        kind        TEXT NOT NULL,
+        key         TEXT NOT NULL,
+        number      INTEGER NOT NULL,
+        title       TEXT NOT NULL,
+        state       TEXT NOT NULL,
+        completed   INTEGER NOT NULL,
+        closed_at   TEXT,
+        branch      TEXT,
+        closes      TEXT NOT NULL DEFAULT '',
+        labels      TEXT NOT NULL DEFAULT '',
+        milestone   TEXT,
+        url         TEXT NOT NULL DEFAULT '',
+        fetched_at  TEXT NOT NULL,
+        PRIMARY KEY (project_id, kind, key)
+      )`);
+        },
+    },
+    {
+        version: 18,
+        describe: "commits de merge, para atribuir el coste a su PR",
+        run: (db) => {
+            db.exec(`CREATE TABLE IF NOT EXISTS merges (
+        repo_path      TEXT NOT NULL,
+        hash           TEXT NOT NULL,
+        at             TEXT NOT NULL,
+        source_branch  TEXT,
+        ref            TEXT,
+        subject        TEXT NOT NULL,
+        PRIMARY KEY (repo_path, hash)
+      )`);
+        },
+    },
     {
         version: 17,
         describe: "archivar proyectos",

package/dist/db/store.d.ts

@@ -2,6 +2,8 @@ import type { DatabaseSync } from "node:sqlite";
 import type { AgentKind, AgentTurn, AiConsentDecision, AiConsentRecord, Client, CloudAccount, CommitRecord, Invoice, InvoiceLine, ParseReport, Project, ProjectSync, RatePeriod, Subscription, TimeEntry, WorkItemTracker } from "@estela/shared";
 import type { ConsumptionRow } from "../billing/amortize.js";
 import type { QuotaTurn } from "../metrics/quota.js";
+import type { TrackerItem } from "../delivery/source.js";
+import type { MergeRecord } from "../watchers/git.js";
 export declare function upsertClient(db: DatabaseSync, client: Client): void;
 export declare function upsertProject(db: DatabaseSync, project: Omit<Project, "closedAt">): void;
 /**
@@ -128,6 +130,32 @@ export declare function firstTurnByAgent(db: DatabaseSync): Map<AgentKind, Date>
  * sobrescriben.
  */
 export declare function saveCommits(db: DatabaseSync, commits: readonly CommitRecord[]): number;
+/** Guarda commits de merge. Devuelve cuántos son nuevos. */
+export declare function saveMerges(db: DatabaseSync, merges: readonly MergeRecord[]): number;
+export declare function listMerges(db: DatabaseSync): MergeRecord[];
+/**
+ * El nombre de una etiqueta de cliente, comparable: sin mayúsculas, acentos
+ * ni separadores. "Acme Retail", "acme-retail" y "ACME_RETAIL" son el mismo.
+ */
+export declare function aliasKey(label: string): string;
+export declare function setClientAlias(db: DatabaseSync, label: string, clientId: string): void;
+export declare function removeClientAlias(db: DatabaseSync, label: string): boolean;
+export declare function listClientAliases(db: DatabaseSync): {
+    label: string;
+    clientId: string;
+}[];
+/**
+ * El cliente de Estela de una etiqueta: un alias, o si no, un cliente cuyo id
+ * o nombre coincida. `null` si no se sabe: no se adivina.
+ */
+export declare function clientForLabel(db: DatabaseSync, label: string): string | null;
+/** Guarda lo leído del gestor de tareas. Lo nuevo sustituye a lo anterior de la misma clave. */
+export declare function saveTrackerItems(db: DatabaseSync, projectId: string, items: readonly TrackerItem[], at?: Date): void;
+/** Lo guardado de un proyecto, y cuándo se leyó por última vez. */
+export declare function listTrackerItems(db: DatabaseSync, projectId: string): {
+    items: TrackerItem[];
+    fetchedAt: Date | null;
+};
 export declare function logScan(db: DatabaseSync, source: string, report: ParseReport): void;
 /**
  * Guarda una imputación.

package/dist/db/store.js

@@ -33,6 +33,15 @@ exports.quotaTurns = quotaTurns;
 exports.turnsBetween = turnsBetween;
 exports.firstTurnByAgent = firstTurnByAgent;
 exports.saveCommits = saveCommits;
+exports.saveMerges = saveMerges;
+exports.listMerges = listMerges;
+exports.aliasKey = aliasKey;
+exports.setClientAlias = setClientAlias;
+exports.removeClientAlias = removeClientAlias;
+exports.listClientAliases = listClientAliases;
+exports.clientForLabel = clientForLabel;
+exports.saveTrackerItems = saveTrackerItems;
+exports.listTrackerItems = listTrackerItems;
 exports.logScan = logScan;
 exports.adjustEntrySeconds = adjustEntrySeconds;
 exports.clearEntryAdjustment = clearEntryAdjustment;
@@ -172,7 +181,9 @@ function getProject(db, id) {
  */
 function setProjectTracker(db, projectId, tracker) {
     const changes = db.prepare("UPDATE projects SET tracker = ? WHERE id = ?")
-        .run(tracker ? JSON.stringify({ system: tracker.system, prefixes: tracker.prefixes }) : null, projectId).changes;
+        .run(tracker ? JSON.stringify({ system: tracker.system, prefixes: tracker.prefixes,
+        ...(tracker.planLabel ? { planLabel: tracker.planLabel } : {}),
+        ...(tracker.clientLabel ? { clientLabel: tracker.clientLabel } : {}) }) : null, projectId).changes;
     if (changes === 0)
         throw new Error((0, index_js_1.tr) `No existe el proyecto "${projectId}"`);
 }
@@ -493,6 +504,113 @@ function saveCommits(db, commits) {
     }
     return inserted;
 }
+/** Guarda commits de merge. Devuelve cuántos son nuevos. */
+function saveMerges(db, merges) {
+    const stmt = db.prepare(`
+    INSERT OR IGNORE INTO merges (repo_path, hash, at, source_branch, ref, subject)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+    let inserted = 0;
+    db.exec("BEGIN");
+    try {
+        for (const m of merges) {
+            inserted += Number(stmt.run((0, paths_js_1.normalizePath)(m.repoPath), m.hash, iso(m.at), m.sourceBranch, m.ref, m.subject).changes);
+        }
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+    return inserted;
+}
+function listMerges(db) {
+    return db.prepare("SELECT * FROM merges ORDER BY at").all()
+        .map((r) => ({
+        repoPath: r["repo_path"],
+        hash: r["hash"],
+        at: new Date(r["at"]),
+        sourceBranch: r["source_branch"] ?? null,
+        ref: r["ref"] ?? null,
+        subject: r["subject"],
+    }));
+}
+/**
+ * El nombre de una etiqueta de cliente, comparable: sin mayúsculas, acentos
+ * ni separadores. "Acme Retail", "acme-retail" y "ACME_RETAIL" son el mismo.
+ */
+function aliasKey(label) {
+    return label.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function setClientAlias(db, label, clientId) {
+    db.prepare(`INSERT INTO client_aliases (label, client_id) VALUES (?, ?)
+              ON CONFLICT(label) DO UPDATE SET client_id = excluded.client_id`).run(aliasKey(label), clientId);
+}
+function removeClientAlias(db, label) {
+    return db.prepare("DELETE FROM client_aliases WHERE label = ?").run(aliasKey(label)).changes > 0;
+}
+function listClientAliases(db) {
+    return db.prepare("SELECT label, client_id FROM client_aliases ORDER BY label").all().map((r) => ({ label: r.label, clientId: r.client_id }));
+}
+/**
+ * El cliente de Estela de una etiqueta: un alias, o si no, un cliente cuyo id
+ * o nombre coincida. `null` si no se sabe: no se adivina.
+ */
+function clientForLabel(db, label) {
+    const key = aliasKey(label);
+    if (!key)
+        return null;
+    const alias = db.prepare("SELECT client_id FROM client_aliases WHERE label = ?").get(key);
+    if (alias)
+        return alias.client_id;
+    const match = listClients(db).filter((c) => aliasKey(c.id) === key || aliasKey(c.name) === key);
+    return match.length === 1 ? match[0].id : null;
+}
+/** Guarda lo leído del gestor de tareas. Lo nuevo sustituye a lo anterior de la misma clave. */
+function saveTrackerItems(db, projectId, items, at = new Date()) {
+    const stmt = db.prepare(`
+    INSERT INTO tracker_items (project_id, kind, key, number, title, state, completed, closed_at, branch,
+                               closes, labels, milestone, url, fetched_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(project_id, kind, key) DO UPDATE SET
+      number = excluded.number, title = excluded.title, state = excluded.state,
+      completed = excluded.completed, closed_at = excluded.closed_at, branch = excluded.branch,
+      closes = excluded.closes, labels = excluded.labels, milestone = excluded.milestone,
+      url = excluded.url, fetched_at = excluded.fetched_at
+  `);
+    db.exec("BEGIN");
+    try {
+        for (const i of items) {
+            // Las etiquetas pueden llevar comas: se separan con saltos de línea.
+            stmt.run(projectId, i.kind, i.key, i.number, i.title, i.state, i.completed ? 1 : 0, i.closedAt ? iso(i.closedAt) : null, i.branch, i.closes.join(","), i.labels.join("\n"), i.milestone, i.url, iso(at));
+        }
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+/** Lo guardado de un proyecto, y cuándo se leyó por última vez. */
+function listTrackerItems(db, projectId) {
+    const rows = db.prepare("SELECT * FROM tracker_items WHERE project_id = ?").all(projectId);
+    let fetchedAt = null;
+    const items = rows.map((r) => {
+        const f = r["fetched_at"];
+        if (!fetchedAt || f > fetchedAt)
+            fetchedAt = f;
+        return {
+            key: r["key"], kind: r["kind"], number: r["number"],
+            title: r["title"], state: r["state"], completed: Boolean(r["completed"]),
+            closedAt: r["closed_at"] ? new Date(r["closed_at"]) : null,
+            branch: r["branch"] ?? null,
+            closes: String(r["closes"] || "").split(",").filter(Boolean),
+            labels: String(r["labels"] || "").split("\n").filter(Boolean),
+            milestone: r["milestone"] ?? null, url: r["url"],
+        };
+    });
+    return { items, fetchedAt: fetchedAt ? new Date(fetchedAt) : null };
+}
 function logScan(db, source, report) {
     db.prepare(`
     INSERT INTO scan_log (
@@ -710,6 +828,7 @@ function rowToEntry(r) {
         kind: r["kind"] ?? "development",
         branch: r["branch"] ?? null,
         workItems: String(r["work_items"] || "").split(",").filter(Boolean),
+        workItemsManual: Boolean(r["work_items_manual"]),
     });
 }
 /** Guarda la factura y marca sus imputaciones. Todo o nada. */

package/dist/delivery/clients.d.ts

@@ -0,0 +1,52 @@
+import type { AiCost, Subscription, TimeEntry } from "@estela/shared";
+import type { MergeRecord } from "../watchers/git.js";
+import type { Cost } from "./report.js";
+import type { TrackerItem } from "./source.js";
+/**
+ * Lo pedido por clientes frente al resto: a qué peticiones fue el gasto de IA
+ * de un periodo.
+ *
+ * Una issue o un PR es una petición de un cliente si lleva una etiqueta
+ * `cliente:<nombre>`. Las horas se unen a issues y PRs como en el resto del
+ * informe de entregas (la rama del PR y su número en ramas, commits o a mano),
+ * y un PR hereda las etiquetas de las issues que cierra.
+ *
+ * Nada se reparte: una hora unida a peticiones de dos clientes va a un grupo
+ * propio de los dos, y una hora sin petición va a "el resto". Y aquí no hay
+ * ingresos ni contratos, que Estela no conoce: solo qué gasto sirvió a qué
+ * petición.
+ */
+/** Quién pidió algo, ya resuelto contra los clientes de Estela. */
+export interface Requester {
+    /** Clave estable: el id del cliente, o `?nombre` si no se sabe cuál es. */
+    readonly id: string;
+    /** El cliente de Estela, o `null` si la etiqueta no se pudo mapear. */
+    readonly clientId: string | null;
+    readonly name: string;
+}
+export interface ClientRequestInput {
+    readonly items: readonly TrackerItem[];
+    /** Las imputaciones del periodo. */
+    readonly entries: readonly TimeEntry[];
+    readonly merges: readonly MergeRecord[];
+    /** `cliente:` — se compara sin mayúsculas. */
+    readonly prefix: string;
+    /** De lo que va detrás del prefijo, a quién es. */
+    readonly requesterOf: (name: string) => Requester;
+    readonly subscriptions: readonly Subscription[];
+    readonly monthTotals: ReadonlyMap<string, AiCost>;
+}
+export interface RequestGroup extends Cost {
+    /** Uno, o varios si las mismas horas sirvieron a peticiones de varios. */
+    readonly requesters: readonly Requester[];
+    /** Las peticiones a las que se unieron sus horas. */
+    readonly items: readonly TrackerItem[];
+}
+export interface ClientRequestReport {
+    readonly groups: readonly RequestGroup[];
+    /** Horas sin ninguna petición de cliente. */
+    readonly rest: Cost;
+    readonly total: Cost;
+}
+export declare function clientRequests(input: ClientRequestInput): ClientRequestReport;
+//# sourceMappingURL=clients.d.ts.map

package/dist/delivery/clients.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientRequests = clientRequests;
+const amortize_js_1 = require("../billing/amortize.js");
+const spend_js_1 = require("../metrics/spend.js");
+function clientRequests(input) {
+    const prefix = input.prefix.toLowerCase();
+    const byKey = new Map();
+    const prsByBranch = new Map();
+    for (const i of input.items) {
+        byKey.set(i.key, [...(byKey.get(i.key) ?? []), i]);
+        if (i.kind === "pr" && i.branch)
+            prsByBranch.set(i.branch, [...(prsByBranch.get(i.branch) ?? []), i]);
+    }
+    const prOfBranch = new Map();
+    for (const m of input.merges)
+        if (m.sourceBranch && m.ref)
+            prOfBranch.set(m.sourceBranch, m.ref);
+    /** Las issues y PRs de una imputación, con las issues que cierran sus PRs. */
+    const linked = (e) => {
+        const out = new Set();
+        if (e.branch)
+            for (const pr of prsByBranch.get(e.branch) ?? [])
+                out.add(pr);
+        const keys = [...(e.workItems ?? [])];
+        const merged = e.branch ? prOfBranch.get(e.branch) : undefined;
+        if (merged)
+            keys.push(merged);
+        for (const k of keys)
+            for (const i of byKey.get(k) ?? [])
+                out.add(i);
+        for (const i of [...out]) {
+            if (i.kind !== "pr")
+                continue;
+            for (const k of i.closes)
+                for (const issue of byKey.get(k) ?? [])
+                    if (issue.kind === "issue")
+                        out.add(issue);
+        }
+        return [...out];
+    };
+    const requestersOf = (i) => i.labels
+        .filter((l) => l.toLowerCase().startsWith(prefix))
+        .map((l) => l.slice(prefix.length).trim())
+        .filter(Boolean)
+        .map(input.requesterOf);
+    const assignedByMonth = new Map();
+    for (const e of input.entries) {
+        const m = (0, amortize_js_1.monthOf)(e.startedAt);
+        assignedByMonth.set(m, (assignedByMonth.get(m) ?? 0) + e.aiCost.microUsd);
+    }
+    const cost = (entries) => {
+        const byMonth = new Map();
+        for (const e of entries)
+            byMonth.set((0, amortize_js_1.monthOf)(e.startedAt), (byMonth.get((0, amortize_js_1.monthOf)(e.startedAt)) ?? 0) + e.aiCost.microUsd);
+        const { real, partial } = (0, spend_js_1.realFromMonths)(byMonth, input.subscriptions, (m) => Math.max(input.monthTotals.get(m)?.microUsd ?? 0, assignedByMonth.get(m) ?? 0));
+        return {
+            seconds: entries.reduce((s, e) => s + e.seconds, 0),
+            consumption: { microUsd: entries.reduce((s, e) => s + e.aiCost.microUsd, 0) },
+            real, realPartial: partial,
+        };
+    };
+    const groups = new Map();
+    const rest = [];
+    for (const e of input.entries) {
+        const requested = linked(e).map((i) => ({ i, who: requestersOf(i) })).filter((x) => x.who.length > 0);
+        const who = new Map();
+        for (const { who: list } of requested)
+            for (const r of list)
+                who.set(r.id, r);
+        if (who.size === 0) {
+            rest.push(e);
+            continue;
+        }
+        const requesters = [...who.values()].sort((a, b) => a.name.localeCompare(b.name));
+        const key = requesters.map((r) => r.id).join("+");
+        let g = groups.get(key);
+        if (!g) {
+            g = { requesters, items: new Set(), entries: [] };
+            groups.set(key, g);
+        }
+        g.entries.push(e);
+        for (const { i } of requested)
+            g.items.add(i);
+    }
+    return {
+        groups: [...groups.values()]
+            .map((g) => ({ requesters: g.requesters, items: [...g.items].sort((a, b) => a.number - b.number), ...cost(g.entries) }))
+            .sort((a, b) => b.consumption.microUsd - a.consumption.microUsd),
+        rest: cost(rest),
+        total: cost(input.entries),
+    };
+}
+//# sourceMappingURL=clients.js.map

package/dist/delivery/github.d.ts

@@ -0,0 +1,21 @@
+import type { Availability, FetchQuery, PlanSource, TrackerItem } from "./source.js";
+/**
+ * GitHub, a través de la CLI `gh` que ya tienes instalada y con sesión.
+ *
+ * Sin token propio ni llamada directa a la API: `gh` ya sabe quién eres y a
+ * qué repos tienes acceso, y quien no lo tenga instalado ve el informe sin
+ * esta parte. Se ejecuta en la carpeta del repo, así que `gh` deduce el repo
+ * de GitHub por su remoto.
+ */
+/** Ejecuta `gh` con esos argumentos en esa carpeta y devuelve su salida. Inyectable en los tests. */
+export type GhRunner = (args: readonly string[], cwd: string) => Promise<string>;
+export declare const runGh: GhRunner;
+export declare class GitHubPlanSource implements PlanSource {
+    private readonly cwd;
+    private readonly gh;
+    readonly system: "github";
+    constructor(cwd: string, gh?: GhRunner);
+    availability(): Promise<Availability>;
+    fetch(query: FetchQuery): Promise<TrackerItem[]>;
+}
+//# sourceMappingURL=github.d.ts.map

package/dist/delivery/github.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubPlanSource = exports.runGh = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const run = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const runGh = async (args, cwd) => {
+    const { stdout } = await run("gh", [...args], { cwd, timeout: 60_000, maxBuffer: 64 * 1024 * 1024 });
+    return stdout;
+};
+exports.runGh = runGh;
+// Los campos que se piden a gh. Cambiarlos cambia lo que se guarda.
+const ISSUE_FIELDS = "number,title,state,stateReason,closedAt,labels,milestone,url";
+const PR_FIELDS = "number,title,state,mergedAt,closedAt,headRefName,labels,milestone,closingIssuesReferences,url";
+const LIMIT = "1000";
+class GitHubPlanSource {
+    cwd;
+    gh;
+    system = "github";
+    constructor(cwd, gh = exports.runGh) {
+        this.cwd = cwd;
+        this.gh = gh;
+    }
+    async availability() {
+        try {
+            await this.gh(["--version"], this.cwd);
+        }
+        catch (error) {
+            return { ok: false, reason: "missing", detail: errorText(error) };
+        }
+        try {
+            await this.gh(["auth", "status"], this.cwd);
+        }
+        catch (error) {
+            return { ok: false, reason: "auth", detail: errorText(error) };
+        }
+        try {
+            await this.gh(["repo", "view", "--json", "nameWithOwner"], this.cwd);
+        }
+        catch (error) {
+            return { ok: false, reason: "repo", detail: errorText(error) };
+        }
+        return { ok: true };
+    }
+    async fetch(query) {
+        const lists = [
+            this.gh(["pr", "list", "--state", "merged", "--limit", LIMIT, "--search", `merged:${query.from}..${query.to}`,
+                "--json", PR_FIELDS], this.cwd),
+            this.gh(["issue", "list", "--state", "closed", "--limit", LIMIT, "--search", `closed:${query.from}..${query.to}`,
+                "--json", ISSUE_FIELDS], this.cwd),
+        ];
+        const plan = query.plan;
+        if (plan?.label) {
+            lists.push(this.gh(["issue", "list", "--state", "all", "--limit", LIMIT, "--label", plan.label,
+                "--json", ISSUE_FIELDS], this.cwd));
+            lists.push(this.gh(["pr", "list", "--state", "all", "--limit", LIMIT, "--label", plan.label,
+                "--json", PR_FIELDS], this.cwd));
+        }
+        else if (plan?.milestone) {
+            lists.push(this.gh(["issue", "list", "--state", "all", "--limit", LIMIT, "--milestone", plan.milestone,
+                "--json", ISSUE_FIELDS], this.cwd));
+            lists.push(this.gh(["pr", "list", "--state", "all", "--limit", LIMIT, "--search", `milestone:"${plan.milestone}"`,
+                "--json", PR_FIELDS], this.cwd));
+        }
+        const prefix = query.clientLabelPrefix?.toLowerCase();
+        if (prefix) {
+            // Los PR en curso: uno sin etiqueta que cierra la issue de un cliente
+            // también es trabajo para ese cliente.
+            lists.push(this.gh(["pr", "list", "--state", "open", "--limit", LIMIT, "--json", PR_FIELDS], this.cwd));
+            // GitHub no busca etiquetas por prefijo: primero cuáles existen.
+            const labels = JSON.parse(await this.gh(["label", "list", "--limit", LIMIT, "--json", "name"], this.cwd) || "[]").map((l) => l.name).filter((n) => n.toLowerCase().startsWith(prefix));
+            for (const label of labels) {
+                lists.push(this.gh(["issue", "list", "--state", "all", "--limit", LIMIT, "--label", label,
+                    "--json", ISSUE_FIELDS], this.cwd));
+                lists.push(this.gh(["pr", "list", "--state", "all", "--limit", LIMIT, "--label", label,
+                    "--json", PR_FIELDS], this.cwd));
+            }
+        }
+        // Una issue o un PR puede salir en dos listas: se queda una vez.
+        const items = new Map();
+        for (const text of await Promise.all(lists)) {
+            for (const raw of JSON.parse(text || "[]")) {
+                const item = normalize(raw);
+                items.set(`${item.kind}:${item.key}`, item);
+            }
+        }
+        return [...items.values()];
+    }
+}
+exports.GitHubPlanSource = GitHubPlanSource;
+/** Un PR trae headRefName; una issue, no. */
+function normalize(raw) {
+    const isPr = raw.headRefName !== undefined;
+    const state = raw.state.toUpperCase();
+    const date = (s) => (s ? new Date(s) : null);
+    if (isPr) {
+        const merged = state === "MERGED" || !!raw.mergedAt;
+        return {
+            key: `github:${raw.number}`, kind: "pr", number: raw.number, title: raw.title,
+            state: merged ? "merged" : state === "OPEN" ? "open" : "closed",
+            completed: merged, closedAt: date(raw.mergedAt) ?? date(raw.closedAt),
+            branch: raw.headRefName || null,
+            closes: (raw.closingIssuesReferences ?? []).map((i) => `github:${i.number}`),
+            labels: (raw.labels ?? []).map((l) => l.name), milestone: raw.milestone?.title ?? null, url: raw.url,
+        };
+    }
+    const closed = state === "CLOSED";
+    return {
+        key: `github:${raw.number}`, kind: "issue", number: raw.number, title: raw.title,
+        state: closed ? "closed" : "open",
+        // "NOT_PLANNED" o "DUPLICATE" es cerrar sin hacer. Sin motivo (issues antiguas), se da por hecha.
+        completed: closed && (!raw.stateReason || raw.stateReason.toUpperCase() === "COMPLETED"),
+        closedAt: date(raw.closedAt), branch: null, closes: [],
+        labels: (raw.labels ?? []).map((l) => l.name), milestone: raw.milestone?.title ?? null, url: raw.url,
+    };
+}
+function errorText(error) {
+    const e = error;
+    if (e.code === "ENOENT")
+        return "gh no está instalado";
+    return (e.stderr || e.message || String(error)).trim().split("\n")[0] ?? "";
+}
+//# sourceMappingURL=github.js.map

package/dist/delivery/report.d.ts

@@ -0,0 +1,55 @@
+import type { AiCost, Money, Subscription, TimeEntry } from "@estela/shared";
+import type { MergeRecord } from "../watchers/git.js";
+import type { PlanFilter, TrackerItem } from "./source.js";
+/**
+ * Planificado frente a entregado, con el coste de IA de cada parte.
+ *
+ *  - Planificado y entregado: lo del plan que se cerró como hecho, o cuyo PR
+ *    se fusionó, dentro del periodo.
+ *  - Planificado sin entregar: el resto del plan, con su estado.
+ *  - Entregado sin planificar: PRs fusionados e issues cerradas como hechas en
+ *    el periodo que no son del plan ni lo cierran.
+ *
+ * El coste de una issue o un PR es el de las imputaciones que se le unen:
+ * las de la rama del PR, las que llevan su número (rama, commit o a mano) y,
+ * para una issue, las de los PRs que la cierran. Es el coste de toda esa
+ * entrega, aunque parte se trabajara antes del periodo. Una imputación que se
+ * une a dos cosas a la vez cuenta en las dos líneas, pero una sola vez en el
+ * total de cada bloque.
+ */
+export interface DeliveryInput {
+    readonly items: readonly TrackerItem[];
+    readonly plan: PlanFilter | null;
+    readonly from: string;
+    readonly to: string;
+    readonly entries: readonly TimeEntry[];
+    readonly merges: readonly MergeRecord[];
+    readonly subscriptions: readonly Subscription[];
+    readonly monthTotals: ReadonlyMap<string, AiCost>;
+}
+export interface Cost {
+    readonly seconds: number;
+    readonly consumption: AiCost;
+    readonly real: Money | null;
+    readonly realPartial: boolean;
+}
+export interface DeliveryLine extends Cost {
+    readonly item: TrackerItem;
+    /** PRs del periodo que cierran esta issue. */
+    readonly deliveredBy: readonly TrackerItem[];
+    /** Cómo se unió el coste: "branch" (rama del PR) y/o "item" (número en la rama, un commit o a mano). */
+    readonly basis: readonly ("branch" | "item")[];
+}
+export interface DeliveryBlock extends Cost {
+    readonly lines: readonly DeliveryLine[];
+}
+export interface DeliveryReport {
+    /** `null` sin plan configurado: solo hay entregado. */
+    readonly planned: {
+        readonly delivered: DeliveryBlock;
+        readonly pending: DeliveryBlock;
+    } | null;
+    readonly unplanned: DeliveryBlock;
+}
+export declare function deliveryReport(input: DeliveryInput): DeliveryReport;
+//# sourceMappingURL=report.d.ts.map