estela 0.3.3 → 0.4.0

package/dist/db/schema.js

@@ -47,6 +47,8 @@ CREATE TABLE IF NOT EXISTS projects (
   ai_budget_micro_usd INTEGER,
   -- NULL = activo. Ver la migración 12 para por qué cerrar no bloquea nada.
   closed_at         TEXT,
+  -- NULL = visible. Archivado: fuera del panel y sin captar horas.
+  archived_at       TEXT,
   -- Gestor de tareas en JSON ({"system":"jira","prefixes":["PROJ"]}). NULL =
   -- sin configurar: solo se reconocen los tickets inequívocos.
   tracker           TEXT
@@ -122,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,
@@ -292,6 +337,61 @@ 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",
+        run: (db) => {
+            addColumn(db, "projects", "archived_at", "TEXT");
+        },
+    },
     {
         version: 16,
         describe: "rutas de Windows iguales vengan de donde vengan",

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;
 /**
@@ -32,6 +34,19 @@ export declare function setProjectTracker(db: DatabaseSync, projectId: string, t
 export declare function closeProject(db: DatabaseSync, id: string, at?: Date): void;
 /** Reabre un proyecto cerrado. Sin efecto si ya estaba abierto. */
 export declare function reopenProject(db: DatabaseSync, id: string): void;
+/** Archiva un proyecto: sale del panel y deja de captar. No borra nada. */
+export declare function archiveProject(db: DatabaseSync, id: string, at?: Date): void;
+export declare function restoreProject(db: DatabaseSync, id: string): void;
+export declare function listArchivedProjects(db: DatabaseSync): Project[];
+/** Por qué no se puede eliminar un proyecto, o null si se puede. */
+export declare function projectDeleteBlocker(db: DatabaseSync, id: string): "invoiced" | "shared" | null;
+/**
+ * Elimina un proyecto y sus imputaciones, tarifas y vínculos. Los turnos y los
+ * commits se quedan: son de la máquina, no del proyecto, y si el repo se vuelve
+ * a registrar sus horas reaparecen. Lo facturado o compartido no se elimina.
+ */
+export declare function deleteProject(db: DatabaseSync, id: string): void;
+/** Los proyectos a la vista. Los archivados, con `listArchivedProjects`. */
 export declare function listProjects(db: DatabaseSync): Project[];
 export declare function listClients(db: DatabaseSync): Client[];
 export declare function getRates(db: DatabaseSync, projectId: string): RatePeriod[];
@@ -76,6 +91,11 @@ export declare function listPublications(db: DatabaseSync): Publication[];
 export declare function authorsByRepo(db: DatabaseSync): Map<string, string[]>;
 /** Encuentra el proyecto al que pertenece una ruta de repositorio. */
 export declare function projectForRepo(db: DatabaseSync, repoPath: string): string | null;
+/**
+ * Como `projectForRepo`, contando los archivados. Para lo que ofrece registrar
+ * un repo: uno archivado ya tiene dueño, y ofrecerlo otra vez lo resucitaría.
+ */
+export declare function ownerOfRepo(db: DatabaseSync, repoPath: string): string | null;
 /**
  * Todos los repositorios que ya están vinculados a algún proyecto, sin
  * importar cómo llegaron ahí (un transcript de agente, `estela project add`,
@@ -110,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

@@ -10,6 +10,11 @@ exports.getProject = getProject;
 exports.setProjectTracker = setProjectTracker;
 exports.closeProject = closeProject;
 exports.reopenProject = reopenProject;
+exports.archiveProject = archiveProject;
+exports.restoreProject = restoreProject;
+exports.listArchivedProjects = listArchivedProjects;
+exports.projectDeleteBlocker = projectDeleteBlocker;
+exports.deleteProject = deleteProject;
 exports.listProjects = listProjects;
 exports.listClients = listClients;
 exports.getRates = getRates;
@@ -21,12 +26,22 @@ exports.forgetPublication = forgetPublication;
 exports.listPublications = listPublications;
 exports.authorsByRepo = authorsByRepo;
 exports.projectForRepo = projectForRepo;
+exports.ownerOfRepo = ownerOfRepo;
 exports.allProjectRepoPaths = allProjectRepoPaths;
 exports.saveTurns = saveTurns;
 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;
@@ -155,6 +170,7 @@ function getProject(db, id) {
         aiCostPolicy: row["ai_cost_policy"],
         kind: row["kind"] ?? "client",
         closedAt: row["closed_at"] ? new Date(row["closed_at"]) : null,
+        archivedAt: row["archived_at"] ? new Date(row["archived_at"]) : null,
         tracker: row["tracker"] ? JSON.parse(row["tracker"]) : null,
     };
 }
@@ -165,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}"`);
 }
@@ -183,8 +201,45 @@ function closeProject(db, id, at = new Date()) {
 function reopenProject(db, id) {
     db.prepare("UPDATE projects SET closed_at = NULL WHERE id = ?").run(id);
 }
+/** Archiva un proyecto: sale del panel y deja de captar. No borra nada. */
+function archiveProject(db, id, at = new Date()) {
+    db.prepare("UPDATE projects SET archived_at = ? WHERE id = ? AND archived_at IS NULL").run(iso(at), id);
+}
+function restoreProject(db, id) {
+    db.prepare("UPDATE projects SET archived_at = NULL WHERE id = ?").run(id);
+}
+function listArchivedProjects(db) {
+    const rows = db.prepare("SELECT id FROM projects WHERE archived_at IS NOT NULL ORDER BY name").all();
+    return rows.map((r) => getProject(db, r.id));
+}
+/** Por qué no se puede eliminar un proyecto, o null si se puede. */
+function projectDeleteBlocker(db, id) {
+    const count = (sql) => db.prepare(sql).get(id).n;
+    if (count("SELECT COUNT(*) AS n FROM invoices WHERE project_id = ?") > 0)
+        return "invoiced";
+    if (count("SELECT COUNT(*) AS n FROM time_entries WHERE project_id = ? AND invoice_id IS NOT NULL") > 0)
+        return "invoiced";
+    // Lo que hay fuera de esta máquina se quedaría sin dueño aquí.
+    if (count("SELECT COUNT(*) AS n FROM publications WHERE project_id = ?") > 0)
+        return "shared";
+    if (count("SELECT COUNT(*) AS n FROM project_sync WHERE project_id = ?") > 0)
+        return "shared";
+    return null;
+}
+/**
+ * Elimina un proyecto y sus imputaciones, tarifas y vínculos. Los turnos y los
+ * commits se quedan: son de la máquina, no del proyecto, y si el repo se vuelve
+ * a registrar sus horas reaparecen. Lo facturado o compartido no se elimina.
+ */
+function deleteProject(db, id) {
+    const blocker = projectDeleteBlocker(db, id);
+    if (blocker)
+        throw new Error(`project ${id} cannot be deleted: ${blocker}`);
+    db.prepare("DELETE FROM projects WHERE id = ?").run(id);
+}
+/** Los proyectos a la vista. Los archivados, con `listArchivedProjects`. */
 function listProjects(db) {
-    const rows = db.prepare("SELECT id FROM projects ORDER BY name").all();
+    const rows = db.prepare("SELECT id FROM projects WHERE archived_at IS NULL ORDER BY name").all();
     return rows.map((r) => getProject(db, r.id)).filter(Boolean);
 }
 function listClients(db) {
@@ -299,8 +354,18 @@ function authorsByRepo(db) {
 }
 /** Encuentra el proyecto al que pertenece una ruta de repositorio. */
 function projectForRepo(db, repoPath) {
-    const rows = db.prepare("SELECT project_id, repo_path FROM project_repos")
-        .all();
+    return matchRepo(db, repoPath, `SELECT r.project_id, r.repo_path FROM project_repos r
+    JOIN projects p ON p.id = r.project_id WHERE p.archived_at IS NULL`);
+}
+/**
+ * Como `projectForRepo`, contando los archivados. Para lo que ofrece registrar
+ * un repo: uno archivado ya tiene dueño, y ofrecerlo otra vez lo resucitaría.
+ */
+function ownerOfRepo(db, repoPath) {
+    return matchRepo(db, repoPath, "SELECT project_id, repo_path FROM project_repos");
+}
+function matchRepo(db, repoPath, sql) {
+    const rows = db.prepare(sql).all();
     // El prefijo más largo gana: permite anidar un subproyecto dentro de un monorepo.
     // isSameOrInside y no startsWith: en Windows la misma carpeta llega con \ o
     // con /, y con la unidad en mayúscula o minúscula.
@@ -439,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 (
@@ -656,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. */
@@ -951,7 +1124,8 @@ function listTeamSyncedProjects(db) {
 function listPersonalSyncCandidates(db) {
     const rows = db.prepare(`
     SELECT id FROM projects
-    WHERE id NOT IN (SELECT project_id FROM project_sync WHERE scope = 'team')
+    WHERE archived_at IS NULL
+      AND id NOT IN (SELECT project_id FROM project_sync WHERE scope = 'team')
   `).all();
     return rows.map((r) => r.id);
 }

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