estela 0.3.3 → 0.4.0

package/dist/metrics/spend.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spendByUnit = spendByUnit;
+exports.realFromMonths = realFromMonths;
+const shared_1 = require("@estela/shared");
+const amortize_js_1 = require("../billing/amortize.js");
+const index_js_1 = require("../i18n/index.js");
+const paths_js_1 = require("../paths.js");
+/** Agentes cuyo transcript no trae tokens: su trabajo cuenta horas pero no coste. */
+const UNPRICED_AGENTS = new Set(["copilot"]);
+function spendByUnit(input, by) {
+    const reports = [];
+    // Como en `amortize`: el denominador nunca baja de lo imputado ese mes, o un
+    // mes sin turnos guardados le daría la cuota entera a cada unidad.
+    const assignedByMonth = new Map();
+    for (const e of input.entries) {
+        const month = (0, amortize_js_1.monthOf)(e.startedAt);
+        assignedByMonth.set(month, (assignedByMonth.get(month) ?? 0) + e.aiCost.microUsd);
+    }
+    for (const project of input.projects) {
+        const entries = input.entries.filter((e) => e.projectId === project.id);
+        if (entries.length === 0)
+            continue;
+        const prsByBranch = mergedPrs(input.merges, project.repoPaths);
+        const groups = new Map();
+        for (const entry of entries) {
+            const a = attribute(entry, project.tracker ?? null, prsByBranch);
+            const key = by === "branch" ? entry.branch : a.items.length ? a.items.join(",") : null;
+            const id = key ?? "\u0000";
+            let acc = groups.get(id);
+            if (!acc) {
+                acc = newAcc(key);
+                groups.set(id, acc);
+            }
+            add(acc, entry, a, by);
+        }
+        const units = [...groups.values()].map((acc) => finish(acc, input, assignedByMonth));
+        units.sort((x, y) => (x.key === null ? 1 : 0) - (y.key === null ? 1 : 0)
+            || y.consumption.microUsd - x.consumption.microUsd || y.seconds - x.seconds);
+        reports.push({ project, units, total: sumUnits(units) });
+    }
+    return reports;
+}
+/** PRs fusionados por rama, de los merges de los repos del proyecto. */
+function mergedPrs(merges, repos) {
+    const out = new Map();
+    for (const m of merges) {
+        if (!m.sourceBranch || !m.ref)
+            continue;
+        if (!repos.some((r) => (0, paths_js_1.isSameOrInside)(m.repoPath, r) || (0, paths_js_1.isSameOrInside)(r, m.repoPath)))
+            continue;
+        const list = out.get(m.sourceBranch) ?? [];
+        if (!list.includes(m.ref))
+            list.push(m.ref);
+        out.set(m.sourceBranch, list);
+    }
+    return out;
+}
+/**
+ * Los tickets de una imputación y en qué se basan. Primero los que ya tiene
+ * (rama, commits o a mano); si no tiene ninguno, el PR con que se fusionó su
+ * rama. Un PR no sustituye a un ticket que ya se conoce: son cosas distintas.
+ */
+function attribute(entry, tracker, prsByBranch) {
+    const prs = entry.branch ? prsByBranch.get(entry.branch) ?? [] : [];
+    const known = entry.workItems ?? [];
+    if (known.length) {
+        const fromBranch = new Set((0, shared_1.extractWorkItems)(entry.branch, [], tracker));
+        const itemBasis = entry.workItemsManual
+            ? ["manual"]
+            : known.map((k) => (fromBranch.has(k) ? "branch-name" : "commit-message"));
+        return { items: [...known], prs, itemBasis };
+    }
+    if (prs.length)
+        return { items: [...prs], prs, itemBasis: ["merge"] };
+    return { items: [], prs, itemBasis: [] };
+}
+function newAcc(key) {
+    return { key, branches: new Set(), items: new Set(), prs: new Set(), basis: new Set(),
+        seconds: 0, microUsd: 0, byMonth: new Map(), unpricedAgents: false };
+}
+function add(acc, entry, a, by) {
+    acc.seconds += entry.seconds;
+    acc.microUsd += entry.aiCost.microUsd;
+    // El mes de started_at, el mismo que usa `estela ai-cost` para repartir.
+    const month = (0, amortize_js_1.monthOf)(entry.startedAt);
+    acc.byMonth.set(month, (acc.byMonth.get(month) ?? 0) + entry.aiCost.microUsd);
+    if (entry.agents.some((x) => UNPRICED_AGENTS.has(x)))
+        acc.unpricedAgents = true;
+    if (entry.branch)
+        acc.branches.add(entry.branch);
+    // Por rama, los PRs van en su sitio: el del merge no se repite como ticket.
+    const fromMerge = a.itemBasis.length === 1 && a.itemBasis[0] === "merge";
+    if (by === "item" || !fromMerge)
+        for (const i of a.items)
+            acc.items.add(i);
+    for (const p of a.prs)
+        acc.prs.add(p);
+    if (by === "branch") {
+        if (entry.branch)
+            acc.basis.add(entry.agents.length ? "agent-branch" : "commit-branch");
+    }
+    else if (a.items.length) {
+        for (const b of a.itemBasis)
+            acc.basis.add(b);
+    }
+}
+/**
+ * Dinero real: la cuota del mes por la fracción de todo el consumo de ese mes
+ * que es de esta parte. La fórmula de `amortize`, solo que con una parte
+ * cualquiera (una rama, unas sesiones) en vez del proyecto; redondea por parte,
+ * así que la suma puede diferir en un céntimo de la de `ai-cost`.
+ *
+ * `partial`: algún mes con consumo no tenía cuota, y `real` cuenta solo el resto.
+ */
+function realFromMonths(byMonth, subscriptions, monthTotal) {
+    let real = null;
+    let partial = false;
+    if (!subscriptions.length)
+        return { real, partial };
+    for (const [month, micro] of byMonth) {
+        const fee = (0, amortize_js_1.feeForMonth)(subscriptions, month);
+        if (!fee) {
+            if (micro > 0)
+                partial = true;
+            continue;
+        }
+        const total = Math.max(monthTotal(month), micro);
+        const part = total === 0 ? 0 : Math.round(fee.amount * (micro / total));
+        if (real && real.currency !== fee.currency) {
+            throw new TypeError((0, index_js_1.tr) `Suscripciones en monedas distintas en el periodo (${real.currency} y ${fee.currency}). ` +
+                (0, index_js_1.tr) `Unifica la moneda de las suscripciones: no se convierten automáticamente.`);
+        }
+        real = (0, shared_1.money)((real?.amount ?? 0) + part, fee.currency);
+    }
+    return { real, partial };
+}
+function finish(acc, input, assignedByMonth) {
+    const { real, partial } = realFromMonths(acc.byMonth, input.subscriptions, (month) => Math.max(input.monthTotals.get(month)?.microUsd ?? 0, assignedByMonth.get(month) ?? 0));
+    return {
+        key: acc.key,
+        branches: [...acc.branches].sort(),
+        items: [...acc.items],
+        prs: [...acc.prs],
+        basis: [...acc.basis],
+        seconds: acc.seconds,
+        consumption: { microUsd: acc.microUsd },
+        real,
+        realPartial: partial,
+        unpricedAgents: acc.unpricedAgents,
+    };
+}
+function sumUnits(units) {
+    let real = null;
+    for (const u of units) {
+        if (u.real)
+            real = (0, shared_1.money)((real?.amount ?? 0) + u.real.amount, u.real.currency);
+    }
+    return {
+        seconds: units.reduce((s, u) => s + u.seconds, 0),
+        consumption: { microUsd: units.reduce((s, u) => s + u.consumption.microUsd, 0) },
+        real,
+        realPartial: units.some((u) => u.realPartial),
+        unpricedAgents: units.some((u) => u.unpricedAgents),
+    };
+}
+//# sourceMappingURL=spend.js.map

package/dist/metrics/undelivered.d.ts

@@ -0,0 +1,104 @@
+import type { AiCost, AgentKind, Money, Subscription } from "@estela/shared";
+/**
+ * Gasto de IA sin entrega: lo que no ha llegado (todavía) a la rama principal.
+ *
+ * Es una señal para revisar, no un juicio. Explorar, probar y descartar es
+ * trabajo, y una sesión en la que Claude cambia algo cinco veces antes de que
+ * lo des por bueno vale lo mismo aunque aún no tenga commit. Por eso nada de
+ * esto resta horas ni toca imputaciones: solo pone una cifra al lado.
+ *
+ * Se mide sobre los turnos, no sobre las imputaciones: una sesión es un rato
+ * de un chat, y una imputación es un día de una rama que puede juntar varias.
+ * Dos bloques que no se pisan:
+ *
+ *  1. Sesiones sin commit: un rato de trabajo de un chat (sin pausas de más de
+ *     30 min) en el que no hiciste ningún commit en ese repo, ni en los 30 min
+ *     siguientes. Se separan las que luego sí tuvieron commit en su rama. Las
+ *     anteriores a tu primer commit conocido en el repo no se juzgan: quizá
+ *     commiteabas con otro correo.
+ *  2. Ramas sin fusionar: el resto del coste de una rama que sigue existiendo,
+ *     no está integrada y lleva N días sin actividad. Una rama borrada sin
+ *     merge registrado puede ser un squash: su estado es "desconocido" y no
+ *     cuenta, porque contarla inflaría la cifra.
+ */
+export interface UndeliveredTurn {
+    readonly projectId: string;
+    readonly sessionId: string;
+    readonly at: Date;
+    /** Raíz git (el repo principal, también para un worktree). */
+    readonly root: string;
+    readonly branch: string | null;
+    readonly microUsd: number;
+    readonly agent: AgentKind;
+}
+/** Un commit tuyo, con su raíz git ya resuelta igual que la de los turnos. */
+export interface CommitFact {
+    readonly root: string;
+    readonly at: Date;
+    readonly branch: string | null;
+}
+export interface BranchFacts {
+    /** Integrada: la rama base, `git branch --merged` o un commit de merge. */
+    readonly merged: boolean;
+    /** `null` si el repo ya no se puede leer: no se sabe. */
+    readonly exists: boolean | null;
+}
+export interface UndeliveredInput {
+    readonly turns: readonly UndeliveredTurn[];
+    readonly commits: readonly CommitFact[];
+    readonly branchFacts: (root: string, branch: string) => BranchFacts;
+    readonly staleDays: number;
+    readonly now: Date;
+    /** Fechas locales; sin ellas, todo. Se mira la fecha de inicio de la sesión. */
+    readonly from?: string;
+    readonly to?: string;
+    readonly subscriptions: readonly Subscription[];
+    readonly monthTotals: ReadonlyMap<string, AiCost>;
+}
+export interface Spend {
+    readonly consumption: AiCost;
+    readonly real: Money | null;
+    readonly realPartial: boolean;
+}
+export type BranchState = "unmerged" | "open" | "unknown";
+export interface BranchLine extends Spend {
+    readonly branch: string;
+    readonly state: BranchState;
+    /** Días desde la última actividad (turno o commit) en la rama. */
+    readonly idleDays: number;
+}
+export interface UndeliveredReport {
+    readonly projectId: string;
+    /** Todo el gasto del periodo en el proyecto: la base del porcentaje. */
+    readonly total: Spend;
+    /**
+     * Sesiones sin commit que no se pueden juzgar: no se conoce ningún commit tuyo
+     * en ese repo, o la sesión es anterior al primero. Puede ser que commitearas
+     * con otro correo (ver `estela author`), así que no cuentan.
+     */
+    readonly unverifiable: Spend & {
+        readonly count: number;
+    };
+    readonly sessionsWithoutCommit: Spend & {
+        readonly count: number;
+        /** De ellas, las que luego tuvieron commit en su rama (dentro de N días). */
+        readonly laterCommitted: Spend & {
+            readonly count: number;
+        };
+    };
+    /** Ramas que cuentan: sin fusionar tras N días. */
+    readonly unmerged: Spend & {
+        readonly branches: readonly BranchLine[];
+    };
+    /** No cuentan: abiertas hace menos de N días, o de estado desconocido. */
+    readonly notCounted: readonly BranchLine[];
+    /** Suma de los dos bloques que cuentan. */
+    readonly undelivered: Spend;
+    readonly unpricedAgents: boolean;
+}
+/** Ramas donde se integra: trabajar directamente en ellas ya es entregar. */
+export declare const BASE_BRANCHES: Set<string>;
+export declare function undeliveredSpend(input: UndeliveredInput): UndeliveredReport[];
+/** El porcentaje de una parte sobre el total, en tanto por ciento. `null` sin total. */
+export declare function shareOf(part: Spend, total: Spend): number | null;
+//# sourceMappingURL=undelivered.d.ts.map

package/dist/metrics/undelivered.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_BRANCHES = void 0;
+exports.undeliveredSpend = undeliveredSpend;
+exports.shareOf = shareOf;
+const shared_1 = require("@estela/shared");
+const amortize_js_1 = require("../billing/amortize.js");
+const spend_js_1 = require("./spend.js");
+/** El mismo hueco que separa bloques de trabajo (ver sessionize). */
+const GAP_MS = 30 * 60_000;
+const DAY_MS = 86_400_000;
+const UNPRICED_AGENTS = new Set(["copilot"]);
+/** Ramas donde se integra: trabajar directamente en ellas ya es entregar. */
+exports.BASE_BRANCHES = new Set(["main", "master", "develop", "trunk"]);
+function undeliveredSpend(input) {
+    const byProject = new Map();
+    for (const t of input.turns) {
+        const list = byProject.get(t.projectId) ?? [];
+        list.push(t);
+        byProject.set(t.projectId, list);
+    }
+    const reports = [];
+    for (const [projectId, turns] of byProject) {
+        const report = projectReport(projectId, turns, input);
+        if (report.total.consumption.microUsd > 0 || report.unpricedAgents)
+            reports.push(report);
+    }
+    return reports.sort((a, b) => a.projectId.localeCompare(b.projectId));
+}
+function projectReport(projectId, all, input) {
+    const inPeriod = (d) => {
+        const day = (0, shared_1.localDate)(d);
+        return (!input.from || day >= input.from) && (!input.to || day <= input.to);
+    };
+    const spend = new SpendAcc(input);
+    // Ratos de cada chat: mismo session_id y repo, cortados por pausas largas.
+    const sittings = [];
+    const bySession = new Map();
+    for (const t of all) {
+        const key = `${t.sessionId}\0${t.root}`;
+        const list = bySession.get(key) ?? [];
+        list.push(t);
+        bySession.set(key, list);
+    }
+    for (const list of bySession.values()) {
+        list.sort((a, b) => a.at.getTime() - b.at.getTime());
+        let current = [];
+        for (const t of list) {
+            const last = current[current.length - 1];
+            if (last && t.at.getTime() - last.at.getTime() > GAP_MS) {
+                sittings.push({ turns: current, root: last.root });
+                current = [];
+            }
+            current.push(t);
+        }
+        if (current.length)
+            sittings.push({ turns: current, root: current[0].root });
+    }
+    // El primer commit tuyo de cada repo: antes de él, no hay con qué comparar.
+    const firstCommit = new Map();
+    for (const c of input.commits) {
+        firstCommit.set(c.root, Math.min(firstCommit.get(c.root) ?? Infinity, c.at.getTime()));
+    }
+    const total = spend.empty();
+    const unverifiable = spend.empty();
+    let unverifiableCount = 0;
+    const noCommit = spend.empty();
+    const later = spend.empty();
+    let noCommitCount = 0;
+    let laterCount = 0;
+    const counted = new Set();
+    for (const s of sittings) {
+        const first = s.turns[0];
+        if (!inPeriod(first.at))
+            continue;
+        for (const t of s.turns)
+            spend.add(total, t);
+        const start = first.at.getTime();
+        const end = s.turns[s.turns.length - 1].at.getTime();
+        const committed = input.commits.some((c) => c.root === s.root && c.at.getTime() >= start && c.at.getTime() <= end + GAP_MS);
+        if (committed)
+            continue;
+        if (start < (firstCommit.get(s.root) ?? Infinity)) {
+            unverifiableCount++;
+            for (const t of s.turns) {
+                spend.add(unverifiable, t);
+                counted.add(t);
+            }
+            continue;
+        }
+        noCommitCount++;
+        for (const t of s.turns) {
+            spend.add(noCommit, t);
+            counted.add(t);
+        }
+        const branches = new Set(s.turns.map((t) => t.branch).filter((b) => !!b));
+        const afterwards = input.commits.some((c) => c.root === s.root && c.branch !== null
+            && branches.has(c.branch) && c.at.getTime() > end && c.at.getTime() <= end + input.staleDays * DAY_MS);
+        if (afterwards) {
+            laterCount++;
+            for (const t of s.turns)
+                spend.add(later, t);
+        }
+    }
+    // Ramas: el coste que no está ya en una sesión sin commit.
+    const lastActivity = new Map();
+    const touch = (root, branch, at) => {
+        const k = `${root}\0${branch}`;
+        lastActivity.set(k, Math.max(lastActivity.get(k) ?? 0, at.getTime()));
+    };
+    for (const t of all)
+        if (t.branch)
+            touch(t.root, t.branch, t.at);
+    const roots = new Set(all.map((t) => t.root));
+    for (const c of input.commits)
+        if (c.branch && roots.has(c.root))
+            touch(c.root, c.branch, c.at);
+    const lines = new Map();
+    for (const s of sittings) {
+        if (!inPeriod(s.turns[0].at))
+            continue;
+        for (const t of s.turns) {
+            if (counted.has(t) || !t.branch || t.branch === "HEAD" || exports.BASE_BRANCHES.has(t.branch))
+                continue;
+            const k = `${t.root}\0${t.branch}`;
+            let line = lines.get(k);
+            if (!line) {
+                line = { branch: t.branch, root: t.root, acc: spend.empty() };
+                lines.set(k, line);
+            }
+            spend.add(line.acc, t);
+        }
+    }
+    const unmergedAcc = spend.empty();
+    const unmergedLines = [];
+    const notCounted = [];
+    for (const [k, { branch, root, acc }] of lines) {
+        const facts = input.branchFacts(root, branch);
+        if (facts.merged)
+            continue;
+        const idleDays = Math.floor((input.now.getTime() - (lastActivity.get(k) ?? 0)) / DAY_MS);
+        const state = facts.exists !== true ? "unknown" : idleDays >= input.staleDays ? "unmerged" : "open";
+        const line = { branch, state, idleDays, ...spend.finish(acc) };
+        if (state === "unmerged") {
+            unmergedLines.push(line);
+            spend.merge(unmergedAcc, acc);
+        }
+        else {
+            notCounted.push(line);
+        }
+    }
+    const byCost = (a, b) => b.consumption.microUsd - a.consumption.microUsd;
+    const undelivered = spend.empty();
+    spend.merge(undelivered, noCommit);
+    spend.merge(undelivered, unmergedAcc);
+    return {
+        projectId,
+        total: spend.finish(total),
+        unverifiable: { ...spend.finish(unverifiable), count: unverifiableCount },
+        sessionsWithoutCommit: {
+            ...spend.finish(noCommit), count: noCommitCount,
+            laterCommitted: { ...spend.finish(later), count: laterCount },
+        },
+        unmerged: { ...spend.finish(unmergedAcc), branches: unmergedLines.sort(byCost) },
+        notCounted: notCounted.sort(byCost),
+        undelivered: spend.finish(undelivered),
+        unpricedAgents: total.unpriced,
+    };
+}
+/** Suma coste por mes, para repartir la cuota igual que `ai-cost`. */
+class SpendAcc {
+    input;
+    constructor(input) {
+        this.input = input;
+    }
+    empty() { return { microUsd: 0, byMonth: new Map(), unpriced: false }; }
+    add(acc, t) {
+        acc.microUsd += t.microUsd;
+        const month = (0, amortize_js_1.monthOf)(t.at);
+        acc.byMonth.set(month, (acc.byMonth.get(month) ?? 0) + t.microUsd);
+        if (UNPRICED_AGENTS.has(t.agent))
+            acc.unpriced = true;
+    }
+    merge(into, from) {
+        into.microUsd += from.microUsd;
+        for (const [m, v] of from.byMonth)
+            into.byMonth.set(m, (into.byMonth.get(m) ?? 0) + v);
+        into.unpriced ||= from.unpriced;
+    }
+    finish(acc) {
+        const { real, partial } = (0, spend_js_1.realFromMonths)(acc.byMonth, this.input.subscriptions, (month) => this.input.monthTotals.get(month)?.microUsd ?? 0);
+        return { consumption: { microUsd: acc.microUsd }, real, realPartial: partial };
+    }
+}
+/** El porcentaje de una parte sobre el total, en tanto por ciento. `null` sin total. */
+function shareOf(part, total) {
+    return total.consumption.microUsd === 0 ? null : (part.consumption.microUsd / total.consumption.microUsd) * 100;
+}
+//# sourceMappingURL=undelivered.js.map

package/dist/server.js

@@ -65,6 +65,8 @@ const assign_js_1 = require("./billing/assign.js");
 const quota_js_1 = require("./metrics/quota.js");
 const quota_js_2 = require("./quota.js");
 const labels_js_1 = require("./i18n/labels.js");
+/** Las imputaciones de un proyecto archivado no salen en ninguna vista del panel. */
+const VISIBLE = "project_id NOT IN (SELECT id FROM projects WHERE archived_at IS NOT NULL)";
 /**
  * Servidor local del dashboard.
  *
@@ -127,6 +129,7 @@ async function importOnce(dbPath) {
             if (!root)
                 continue;
             store.saveCommits(db, await (0, git_js_1.readCommits)(root, {}));
+            store.saveMerges(db, await (0, git_js_1.readMerges)(root, {}));
         }
         // Todo lo conocido, no solo lo leído ahora (ver knownTurns), y los correos
         // de todos esos repos: sin ellos, un día antiguo perdería sus commits.
@@ -323,7 +326,7 @@ async function api(req, res, url, dbPath) {
             const projectId = url.searchParams.get("project");
             const rows = db.prepare(`
         SELECT local_date AS d, COUNT(*) AS n FROM time_entries
-        WHERE approved = 0 AND invoice_id IS NULL
+        WHERE approved = 0 AND invoice_id IS NULL AND ${VISIBLE}
           ${projectId ? "AND project_id = ?" : ""}
         GROUP BY local_date ORDER BY local_date DESC
       `).all(...(projectId ? [projectId] : []));
@@ -352,6 +355,49 @@ async function api(req, res, url, dbPath) {
             const body = await readJson(req);
             return json(res, 200, { id: createProject(db, body) });
         }
+        if (path === "/api/project-archive" && req.method === "POST") {
+            const body = await readJson(req);
+            const projectId = String(body["projectId"] ?? "");
+            if (!store.getProject(db, projectId)) {
+                return json(res, 404, { error: (0, index_js_2.tr) `No existe el proyecto "${projectId}".` });
+            }
+            store.archiveProject(db, projectId);
+            return json(res, 200, { ok: true });
+        }
+        if (path === "/api/project-restore" && req.method === "POST") {
+            const body = await readJson(req);
+            const projectId = String(body["projectId"] ?? "");
+            if (!store.getProject(db, projectId)) {
+                return json(res, 404, { error: (0, index_js_2.tr) `No existe el proyecto "${projectId}".` });
+            }
+            store.restoreProject(db, projectId);
+            // Lo trabajado mientras estuvo archivado sigue en los turnos: se imputa ya.
+            const status = await runImport(dbPath);
+            return json(res, 200, { ok: true, importing: status.pending === true });
+        }
+        /* Borrar no tiene vuelta atrás: se exige haberlo archivado antes y escribir
+           su nombre, también aquí y no solo en la página. */
+        if (path === "/api/project-delete" && req.method === "POST") {
+            const body = await readJson(req);
+            const projectId = String(body["projectId"] ?? "");
+            const project = store.getProject(db, projectId);
+            if (!project)
+                return json(res, 404, { error: (0, index_js_2.tr) `No existe el proyecto "${projectId}".` });
+            if (!project.archivedAt)
+                return json(res, 409, { error: (0, index_js_2.tr) `Archiva el proyecto antes de eliminarlo.` });
+            if (String(body["confirmName"] ?? "") !== project.name) {
+                return json(res, 400, { error: (0, index_js_2.tr) `El nombre no coincide: no se ha eliminado nada.` });
+            }
+            const blocker = store.projectDeleteBlocker(db, projectId);
+            if (blocker === "invoiced") {
+                return json(res, 409, { error: (0, index_js_2.tr) `Tiene horas facturadas: se puede archivar, pero no eliminar.` });
+            }
+            if (blocker === "shared") {
+                return json(res, 409, { error: (0, index_js_2.tr) `Está publicado o sincronizado: se puede archivar, pero no eliminar.` });
+            }
+            store.deleteProject(db, projectId);
+            return json(res, 200, { ok: true });
+        }
         /* Con quién está compartido cada panel. El panel local no habla con la
            base de la nube: pregunta a la API con el token de este dispositivo,
            igual que hace para publicar. Sin cuenta vinculada no hay nada que
@@ -627,6 +673,7 @@ function buildOverview(db, from = "", to = "") {
            SUM(ai_micro_usd) AS micro,
            SUM(approved) AS approved
     FROM time_entries
+    WHERE ${VISIBLE}
     GROUP BY date
     ORDER BY date DESC
     LIMIT 30
@@ -649,7 +696,7 @@ function buildOverview(db, from = "", to = "") {
     SELECT project_id, SUM(seconds) AS seconds, SUM(ai_micro_usd) AS micro, COUNT(*) AS blocks,
            MIN(local_date) AS first_day, MAX(local_date) AS last_day
     FROM time_entries
-    WHERE billable = 1 AND invoice_id IS NULL
+    WHERE billable = 1 AND invoice_id IS NULL AND ${VISIBLE}
       ${ranged ? "AND local_date >= ? AND local_date <= ?" : ""}
     GROUP BY project_id
   `).all(...(ranged ? [from, to] : []));
@@ -678,7 +725,7 @@ function buildOverview(db, from = "", to = "") {
         ? db.prepare(`
         SELECT COALESCE(SUM(seconds),0) AS seconds, COUNT(*) AS blocks
         FROM time_entries
-        WHERE billable = 1 AND invoice_id IS NULL
+        WHERE billable = 1 AND invoice_id IS NULL AND ${VISIBLE}
           AND (local_date < ? OR local_date > ?)
       `).get(from, to)
         : { seconds: 0, blocks: 0 };
@@ -713,7 +760,7 @@ function buildSummary(db, from, to) {
            MAX(local_date)   AS last_day,
            COUNT(DISTINCT local_date) AS days
     FROM time_entries
-    WHERE local_date >= ? AND local_date <= ?
+    WHERE local_date >= ? AND local_date <= ? AND ${VISIBLE}
     GROUP BY project_id
   `).all(from, to);
     const projects = new Map(store.listProjects(db).map((p) => [p.id, p]));
@@ -753,7 +800,7 @@ function buildSummary(db, from, to) {
     const byDay = db.prepare(`
     SELECT local_date AS date, SUM(seconds) AS seconds
     FROM time_entries
-    WHERE local_date >= ? AND local_date <= ?
+    WHERE local_date >= ? AND local_date <= ? AND ${VISIBLE}
     GROUP BY local_date ORDER BY local_date
   `).all(from, to);
     const totalSeconds = items.reduce((s, i) => s + i.seconds, 0);
@@ -820,7 +867,7 @@ async function buildTeam(db, from, to, projectId) {
     // de qué fiarse, y ninguna otra cifra de la pantalla lo dice.
     const composition = db.prepare(`
     SELECT project_id, source, SUM(seconds) AS seconds
-    FROM time_entries WHERE local_date >= ? AND local_date <= ?
+    FROM time_entries WHERE local_date >= ? AND local_date <= ? AND ${VISIBLE}
     GROUP BY project_id, source
   `).all(from, to);
     const byProject = new Map();
@@ -934,7 +981,7 @@ function buildDay(db, date) {
     SELECT t.*, i.number AS invoice_number
     FROM time_entries t
     LEFT JOIN invoices i ON i.id = t.invoice_id
-    WHERE t.local_date = ?
+    WHERE t.local_date = ? AND t.${VISIBLE}
     ORDER BY t.started_at
   `).all(date);
     const projects = new Map(store.listProjects(db).map((p) => [p.id, p]));
@@ -1174,6 +1221,14 @@ function buildProjects(db) {
             staleBlocks: pub.staleBlocks,
             daysAgo: Math.floor((Date.now() - pub.publishedAt.getTime()) / 86_400_000),
         })),
+        archived: store.listArchivedProjects(db).map((p) => {
+            const totals = db.prepare("SELECT COUNT(*) AS blocks, SUM(seconds) AS seconds FROM time_entries WHERE project_id = ?").get(p.id);
+            return {
+                id: p.id, name: p.name, clientName: clients.get(p.clientId)?.name ?? "—",
+                blocks: totals.blocks, seconds: totals.seconds ?? 0,
+                deleteBlocker: store.projectDeleteBlocker(db, p.id),
+            };
+        }),
         projects: store.listProjects(db).map((p) => {
             const client = clients.get(p.clientId);
             const rates = store.getRates(db, p.id);
@@ -1196,6 +1251,7 @@ function buildProjects(db) {
                 hourlyMinor: current?.amount ?? null,
                 blocks: totals.blocks,
                 seconds: totals.seconds ?? 0,
+                unbilledSeconds: db.prepare("SELECT COALESCE(SUM(seconds), 0) AS s FROM time_entries WHERE project_id = ? AND billable = 1 AND invoice_id IS NULL").get(p.id).s,
                 // El historial completo: subir la tarifa no reescribe lo ya trabajado,
                 // así que conviene poder verlo.
                 rateHistory: rates.map((r) => ({
@@ -1216,7 +1272,7 @@ function unassignedRepos(db) {
     GROUP BY repo_path ORDER BY turns DESC
   `).all();
     return rows
-        .filter((r) => store.projectForRepo(db, r.repo_path) === null)
+        .filter((r) => store.ownerOfRepo(db, r.repo_path) === null)
         .slice(0, 40)
         .map((r) => ({
         path: r.repo_path,
@@ -1247,6 +1303,10 @@ function createProject(db, body) {
         }
     }
     const id = String(body["id"] ?? "").trim() || slug(name);
+    // Volver a crearlo no lo sacaría del archivo: quedaría oculto y sin explicación.
+    if (store.getProject(db, id)?.archivedAt) {
+        throw new Error((0, index_js_2.tr) `Ya hay un proyecto archivado con ese nombre: restáuralo.`);
+    }
     const repo = String(body["repoPath"] ?? "").trim();
     const kind = (String(body["kind"] ?? "client"));
     store.upsertProject(db, {

package/dist/setup.js

@@ -96,7 +96,7 @@ async function planSetup(db, repoPaths, myEmailGuess) {
     }
     const plans = [];
     for (const root of roots) {
-        const already = store.projectForRepo(db, root);
+        const already = store.ownerOfRepo(db, root);
         const { id, name } = projectFromRepo(root);
         if (already) {
             plans.push({ repoPath: root, projectId: already, name, emails: [], existing: true });