estela 0.1.40 → 0.2.1

package/dist/metrics/quota.js

@@ -9,8 +9,10 @@ exports.weekStart = weekStart;
 exports.sameStretch = sameStretch;
 exports.compareWithHistory = compareWithHistory;
 exports.buildQuota = buildQuota;
+exports.officialWindow = officialWindow;
 exports.quotaRange = quotaRange;
 exports.quotaToJson = quotaToJson;
+const cost_js_1 = require("../pricing/cost.js");
 /**
  * "¿Qué proyecto se come mi cuota?"
  *
@@ -57,29 +59,44 @@ function add(u, t) {
     };
 }
 function bucketKey(b) {
-    return b.kind === "project" ? `p:${b.projectId}` : b.kind === "folder" ? `f:${b.folder}` : "-";
+    return b.kind === "project" ? `p:${b.projectId}` : b.kind === "folder" ? `f:${b.path}` : "-";
+}
+/** Precio de lista de un turno, en micro-USD, o null si su modelo no tiene precio. */
+function listCostOf(t) {
+    if (!t.model)
+        return null;
+    return (0, cost_js_1.costOfTurn)(t.tokens, t.model, t.at)?.microUsd ?? null;
 }
 /**
  * Reparto por proyecto de los turnos con `from <= at < to`, de mayor a menor.
  * Un proyecto sin actividad en el periodo no sale: una fila a cero en una
  * tabla de "quién se come la cuota" es ruido.
  */
-function breakdown(turns, from, to, bucketOf) {
+function breakdown(turns, from, to, bucketOf, options = {}) {
     const acc = new Map();
     let total = ZERO;
+    let listCost = 0;
+    let unpriced = 0;
     for (const t of turns) {
         if (t.at < from || t.at >= to)
             continue;
         const bucket = bucketOf(t.repoPath);
         const key = bucketKey(bucket);
-        const prev = acc.get(key) ?? { bucket, usage: ZERO };
-        acc.set(key, { bucket, usage: add(prev.usage, t.tokens) });
+        const cost = listCostOf(t);
+        if (cost === null)
+            unpriced++;
+        const prev = acc.get(key) ?? { bucket, usage: ZERO, listCost: 0 };
+        acc.set(key, { bucket, usage: add(prev.usage, t.tokens), listCost: prev.listCost + (cost ?? 0) });
         total = add(total, t.tokens);
+        listCost += cost ?? 0;
     }
+    const weighted = options.weighted === true;
+    const base = (r) => (weighted ? r.listCost : r.usage.total);
+    const whole = weighted ? listCost : total.total;
     const rows = [...acc.values()]
-        .map(({ bucket, usage }) => ({ bucket, usage, share: total.total > 0 ? usage.total / total.total : 0 }))
-        .sort((a, b) => b.usage.total - a.usage.total);
-    return { rows, total };
+        .map((r) => ({ ...r, share: whole > 0 ? base(r) / whole : 0 }))
+        .sort((a, b) => base(b) - base(a));
+    return { rows, total, listCost, unpriced, weighted };
 }
 // ---------------------------------------------------------------------------
 // La ventana de 5 horas
@@ -176,20 +193,26 @@ function compareWithHistory(times, firstTurnAt, now) {
  */
 function buildQuota(input) {
     const { now, bucketOf } = input;
+    const opts = { weighted: input.weighted === true };
     const monday = weekStart(now);
     const until = new Date(now.getTime() + 1);
     const turns = input.turns.filter((t) => t.at <= now);
     const agents = [];
     for (const agent of exports.QUOTA_AGENTS) {
         const own = turns.filter((t) => t.agent === agent);
-        const { current, lastEnded } = windowAt(own.map((t) => t.at), now);
-        const week = breakdown(own, monday, until, bucketOf);
+        const official = agent === "claude-code" && input.claudeWindow &&
+            input.claudeWindow.start <= now && now < input.claudeWindow.end ? input.claudeWindow : null;
+        const estimate = windowAt(own.map((t) => t.at), now);
+        const current = official ?? estimate.current;
+        const week = breakdown(own, monday, until, bucketOf, opts);
         if (!current && week.rows.length === 0)
             continue;
         agents.push({
             agent,
-            window: current ? { ...current, ...breakdown(own, current.start, until, bucketOf) } : null,
-            lastWindowEnded: lastEnded,
+            window: current
+                ? { ...current, ...breakdown(own, current.start, until, bucketOf, opts), estimated: !official }
+                : null,
+            lastWindowEnded: current ? null : estimate.lastEnded,
             week,
             comparison: compareWithHistory(own.map((t) => ({ at: t.at, total: add(ZERO, t.tokens).total })), input.firstTurnAt.get(agent) ?? null, now),
         });
@@ -201,6 +224,25 @@ function buildQuota(input) {
         copilotExcluded: turns.some((t) => t.agent === "copilot" && t.at >= monday),
     };
 }
+/**
+ * La ventana de 5 h que dio Claude Code, a partir del último `resets_at` que
+ * vio la status line: empieza 5 h antes de su reinicio.
+ *
+ * Solo vale si el dato tiene menos de 5 h (uno más viejo puede ser de otra
+ * ventana) y si el reinicio aún no ha llegado (pasado ese momento, la ventana
+ * en curso es otra que nadie ha visto). Si no, null: se estima como siempre.
+ */
+function officialWindow(seen, now) {
+    if (!seen)
+        return null;
+    const age = now.getTime() - seen.seenAt.getTime();
+    if (age < 0 || age >= WINDOW_MS)
+        return null;
+    if (seen.resetsAt <= now)
+        return null;
+    const start = new Date(seen.resetsAt.getTime() - WINDOW_MS);
+    return start <= now ? { start, end: seen.resetsAt } : null;
+}
 /** Desde cuándo hay que leer turnos para montar el informe de `now`. */
 function quotaRange(now) {
     return { start: sameStretch(now, exports.HISTORY_WEEKS).start, end: new Date(now.getTime() + 1) };
@@ -219,19 +261,23 @@ function quotaToJson(report) {
         projectName: r.bucket.kind === "project" ? r.bucket.projectName : null,
         folder: r.bucket.kind === "folder" ? r.bucket.folder : null,
         ...r.usage,
+        listCostMicroUsd: r.listCost,
         share: Math.round(r.share * 10_000) / 10_000,
     }));
+    const weighted = report.agents.some((a) => a.week.weighted);
     return {
         generatedAt: report.generatedAt.toISOString(),
         weekStart: report.weekStart.toISOString(),
-        // Para que ningún script lo trate como un dato exacto sin haberlo leído.
-        windowIsEstimate: true,
+        // Para que ningún script lo trate como un dato exacto sin haberlo leído:
+        // false solo si todas las ventanas que salen las dio Claude Code.
+        windowIsEstimate: report.agents.some((a) => !a.window || a.window.estimated),
         windowHours: exports.WINDOW_HOURS,
+        shareBasis: weighted ? "list-price" : "tokens",
         agents: report.agents.map((a) => ({
             agent: a.agent,
             window: a.window
                 ? { start: a.window.start.toISOString(), end: a.window.end.toISOString(),
-                    projects: rows(a.window), total: a.window.total }
+                    estimated: a.window.estimated, projects: rows(a.window), total: a.window.total }
                 : null,
             lastWindowEnded: a.lastWindowEnded?.toISOString() ?? null,
             week: { projects: rows(a.week), total: a.week.total },

package/dist/project-of.d.ts

@@ -0,0 +1,52 @@
+import type { DatabaseSync } from "node:sqlite";
+/**
+ * A qué proyecto pertenece una carpeta de trabajo: lo comparten `estela quota`
+ * y `estela statusline`.
+ *
+ * El `cwd` de una sesión no siempre está dentro de la carpeta registrada:
+ * un worktree vive al lado del repositorio (`../web-feature`), y una sesión
+ * abierta en `repo/src` de un repo sin registrar se llamaba "src". Por eso,
+ * en este orden:
+ *
+ *  1. La carpeta tal cual contra los proyectos registrados (el prefijo más
+ *     largo gana). Cubre `repo/src` y también un subproyecto registrado
+ *     dentro de un monorepo (`repo/packages/x`), que resolviendo antes a la
+ *     raíz git se perdería.
+ *  2. La raíz git — y si es un worktree, la del repositorio principal —
+ *     contra los proyectos registrados.
+ *  3. Si nada coincide, "sin proyecto" con el nombre de la raíz git, nunca
+ *     el de una subcarpeta. Fuera de git, la propia carpeta.
+ */
+export type Owner = {
+    readonly kind: "project";
+    readonly projectId: string;
+}
+/**
+ * `path` agrupa (dos repos pueden llamarse igual); `name` es lo que se
+ * enseña; `inGit` dice si es la raíz de un repo o una carpeta suelta.
+ */
+ | {
+    readonly kind: "folder";
+    readonly path: string;
+    readonly name: string;
+    readonly inGit: boolean;
+} | {
+    readonly kind: "none";
+};
+/** Un resolvedor con caché: una semana tiene miles de turnos y pocas carpetas. */
+export declare function ownerResolver(db: DatabaseSync): (dir: string | null) => Owner;
+/** El nombre de una carpeta para enseñarlo: la última parte de la ruta. */
+export declare function folderName(path: string): string;
+/**
+ * La raíz del repositorio git que contiene `dir`, o null si no está en git.
+ *
+ * Se sube hasta encontrar `.git`. Si es una carpeta, esa es la raíz. Si es un
+ * fichero (`gitdir: …`), es un worktree o un submódulo: un worktree tiene un
+ * `commondir` que apunta al `.git` del repositorio principal, y la raíz es la
+ * de ese; un submódulo no lo tiene, y es su propio repositorio.
+ *
+ * Solo lee el disco, sin ejecutar git: se llama en cada evento de la status
+ * line. Si la carpeta ya no existe (un worktree borrado), sube igualmente.
+ */
+export declare function gitRoot(dir: string): string | null;
+//# sourceMappingURL=project-of.d.ts.map

package/dist/project-of.js

@@ -0,0 +1,124 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownerResolver = ownerResolver;
+exports.folderName = folderName;
+exports.gitRoot = gitRoot;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const store = __importStar(require("./db/store.js"));
+const paths_js_1 = require("./paths.js");
+/** Un resolvedor con caché: una semana tiene miles de turnos y pocas carpetas. */
+function ownerResolver(db) {
+    const cache = new Map();
+    return (dir) => {
+        if (!dir)
+            return { kind: "none" };
+        let owner = cache.get(dir);
+        if (!owner) {
+            owner = resolveOwner(db, dir);
+            cache.set(dir, owner);
+        }
+        return owner;
+    };
+}
+function resolveOwner(db, dir) {
+    const direct = store.projectForRepo(db, dir);
+    if (direct)
+        return { kind: "project", projectId: direct };
+    const root = gitRoot(dir);
+    if (root && root !== dir) {
+        const viaRoot = store.projectForRepo(db, root);
+        if (viaRoot)
+            return { kind: "project", projectId: viaRoot };
+    }
+    const path = root ?? (0, paths_js_1.normalizePath)(dir);
+    return { kind: "folder", path, name: folderName(path), inGit: root !== null };
+}
+/** El nombre de una carpeta para enseñarlo: la última parte de la ruta. */
+function folderName(path) {
+    return (0, node_path_1.basename)(path.replace(/[\\/]+$/, "")) || path;
+}
+/**
+ * La raíz del repositorio git que contiene `dir`, o null si no está en git.
+ *
+ * Se sube hasta encontrar `.git`. Si es una carpeta, esa es la raíz. Si es un
+ * fichero (`gitdir: …`), es un worktree o un submódulo: un worktree tiene un
+ * `commondir` que apunta al `.git` del repositorio principal, y la raíz es la
+ * de ese; un submódulo no lo tiene, y es su propio repositorio.
+ *
+ * Solo lee el disco, sin ejecutar git: se llama en cada evento de la status
+ * line. Si la carpeta ya no existe (un worktree borrado), sube igualmente.
+ */
+function gitRoot(dir) {
+    // Una ruta relativa (o "~/…", como en la demo) se resolvería contra la
+    // carpeta desde la que se ejecuta Estela, y acabaría en el repo de quien la
+    // ejecuta. Los cwd de verdad son absolutos.
+    if (!(0, node_path_1.isAbsolute)(dir))
+        return null;
+    let d = (0, node_path_1.resolve)(dir);
+    for (;;) {
+        const dotGit = (0, node_path_1.join)(d, ".git");
+        try {
+            const st = (0, node_fs_1.statSync)(dotGit);
+            if (st.isDirectory())
+                return (0, paths_js_1.normalizePath)(d);
+            if (st.isFile())
+                return (0, paths_js_1.normalizePath)(worktreeMain(dotGit) ?? d);
+        }
+        catch { /* no hay .git aquí: se sube */ }
+        const parent = (0, node_path_1.dirname)(d);
+        if (parent === d)
+            return null;
+        d = parent;
+    }
+}
+/** La raíz del repositorio principal de un worktree, o null si no lo es. */
+function worktreeMain(dotGitFile) {
+    try {
+        const m = /^gitdir:\s*(.+?)\s*$/m.exec((0, node_fs_1.readFileSync)(dotGitFile, "utf8"));
+        if (!m)
+            return null;
+        const gitdir = (0, node_path_1.isAbsolute)(m[1]) ? m[1] : (0, node_path_1.resolve)((0, node_path_1.dirname)(dotGitFile), m[1]);
+        const common = (0, node_fs_1.readFileSync)((0, node_path_1.join)(gitdir, "commondir"), "utf8").trim();
+        const commonDir = (0, node_path_1.isAbsolute)(common) ? common : (0, node_path_1.resolve)(gitdir, common);
+        // El .git del principal: su carpeta padre es la raíz del repositorio.
+        return (0, node_path_1.basename)(commonDir) === ".git" ? (0, node_path_1.dirname)(commonDir) : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=project-of.js.map

package/dist/quota.d.ts

@@ -4,7 +4,16 @@ import { type QuotaReport } from "./metrics/quota.js";
  * La cuota sobre la base: lo que comparten `estela quota` y el panel web.
  * El cálculo vive en `metrics/quota.ts`; aquí solo se leen los datos.
  */
-export declare function loadQuotaReport(db: DatabaseSync, now?: Date): QuotaReport;
+export interface QuotaLoadOptions {
+    /** % por precio de lista en vez de por tokens (`--weighted`). */
+    readonly weighted?: boolean;
+    /**
+     * La base de la que se lee, para encontrar al lado lo que guardó la status
+     * line (el `resets_at` de Claude Code). Sin ella, la ventana se estima.
+     */
+    readonly dbPath?: string;
+}
+export declare function loadQuotaReport(db: DatabaseSync, now?: Date, options?: QuotaLoadOptions): QuotaReport;
 /**
  * Trae los turnos de esta semana antes de calcular.
  *

package/dist/quota.js

@@ -35,38 +35,32 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadQuotaReport = loadQuotaReport;
 exports.refreshQuotaTurns = refreshQuotaTurns;
-const node_path_1 = require("node:path");
 const store = __importStar(require("./db/store.js"));
 const quota_js_1 = require("./metrics/quota.js");
+const project_of_js_1 = require("./project-of.js");
+const statusline_cache_js_1 = require("./statusline-cache.js");
 const agents_js_1 = require("./watchers/agents.js");
-/**
- * La cuota sobre la base: lo que comparten `estela quota` y el panel web.
- * El cálculo vive en `metrics/quota.ts`; aquí solo se leen los datos.
- */
-function loadQuotaReport(db, now = new Date()) {
+function loadQuotaReport(db, now = new Date(), options = {}) {
     const range = (0, quota_js_1.quotaRange)(now);
     const names = new Map(store.listProjects(db).map((p) => [p.id, p.name]));
-    // Un proyecto por carpeta, una sola vez: `projectForRepo` lee todos los
-    // repos vinculados en cada llamada, y una semana tiene miles de turnos.
-    const cache = new Map();
+    // La carpeta, y si no, su raíz git: ver project-of.ts. Una carpeta sin
+    // proyecto sale con el nombre de su raíz git, no el de una subcarpeta.
+    const ownerOf = (0, project_of_js_1.ownerResolver)(db);
     const bucketOf = (repoPath) => {
-        if (!repoPath)
-            return { kind: "none" };
-        let bucket = cache.get(repoPath);
-        if (!bucket) {
-            const projectId = store.projectForRepo(db, repoPath);
-            bucket = projectId
-                ? { kind: "project", projectId, projectName: names.get(projectId) ?? projectId }
-                : { kind: "folder", folder: (0, node_path_1.basename)(repoPath.replace(/[\\/]+$/, "")) || repoPath };
-            cache.set(repoPath, bucket);
-        }
-        return bucket;
+        const o = ownerOf(repoPath);
+        if (o.kind === "project")
+            return { kind: "project", projectId: o.projectId, projectName: names.get(o.projectId) ?? o.projectId };
+        if (o.kind === "folder")
+            return { kind: "folder", folder: o.name, path: o.path };
+        return { kind: "none" };
     };
     return (0, quota_js_1.buildQuota)({
         turns: store.quotaTurns(db, range.start, range.end),
         firstTurnAt: store.firstTurnByAgent(db),
         now,
         bucketOf,
+        weighted: options.weighted === true,
+        claudeWindow: options.dbPath ? (0, quota_js_1.officialWindow)((0, statusline_cache_js_1.readFiveHourReset)(options.dbPath), now) : null,
     });
 }
 /**

package/dist/server.js

@@ -60,6 +60,7 @@ const identity_js_1 = require("./watchers/identity.js");
 const index_js_2 = require("./i18n/index.js");
 const paths_js_1 = require("./paths.js");
 const localize_js_1 = require("./billing/localize.js");
+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");
@@ -141,32 +142,14 @@ async function importOnce(dbPath) {
         const commits = (0, identity_js_1.onlyMine)(allRepoCommits, mine);
         const fromAgents = (0, sessionize_js_1.attachCommits)((0, sessionize_js_1.sessionize)(turns), commits);
         const fromCommits = (0, sessionize_js_1.withoutOverlap)((0, sessionize_js_1.sessionizeCommits)(commits), fromAgents);
-        // Se agrupa por PROYECTO, no por ruta: el agente abierto en `repo/` y en
-        // `repo/src/UI` son dos rutas del mismo proyecto, y agrupar por ruta
-        // producía dos bloques que luego se pisaban al guardarse con el mismo id.
-        const porProyecto = (b) => (b.repoPath ? store.projectForRepo(db, b.repoPath) ?? b.repoPath : "");
-        for (const block of (0, sessionize_js_1.groupByBranchAndDay)([...fromAgents, ...fromCommits], porProyecto)) {
-            const projectId = block.repoPath ? store.projectForRepo(db, block.repoPath) : null;
-            if (!projectId)
-                continue;
-            const project = store.getProject(db, projectId);
-            const day = (0, shared_1.localDate)(block.startedAt);
-            const slug = (block.branch ?? "sin-rama").replace(/[^a-zA-Z0-9]+/g, "-");
-            store.saveTimeEntry(db, {
-                id: `te_${projectId}_${day}_${slug}`,
-                projectId,
-                startedAt: block.startedAt, endedAt: block.endedAt, seconds: block.seconds,
-                description: (0, sessionize_js_1.describeBlock)(block),
-                billable: project.billable, invoiceId: null,
-                aiCost: block.aiCost,
-                // Sin agente no hay segundos de agente que atribuir.
-                agentSeconds: block.turnCount > 0 ? block.seconds : 0,
-                commitHashes: block.commits.map((c) => c.hash),
-                agents: block.turnCount > 0 ? [...(block.agents ?? ["claude-code"])] : [],
-                source: block.turnCount > 0 ? "agent" : "commit", kind: "development",
-                branch: block.branch,
-                workItems: (0, shared_1.extractWorkItems)(block.branch, block.commits.map((c) => c.subject), project.tracker),
-            });
+        // Las mismas reglas que `estela import` (billing/assign.ts). Las horas de
+        // subcarpetas y worktrees solo se recuperan si ya se confirmó una vez
+        // desde la terminal: el panel no cambia horas importadas en segundo plano
+        // sin que nadie haya visto antes qué iba a cambiar.
+        const recover = (0, node_fs_1.existsSync)((0, node_path_1.join)((0, node_path_1.dirname)(dbPath), ".recover-git-root"));
+        const plan = (0, assign_js_1.planEntries)(db, [...fromAgents, ...fromCommits], { recover });
+        for (const { entry } of plan.entries) {
+            store.saveTimeEntry(db, entry);
             imputed++;
         }
         return imputed;
@@ -325,7 +308,7 @@ async function api(req, res, url, dbPath) {
         // el panel ya importa solo cada pocos minutos, y una petición web no debe
         // ponerse a leer el disco entero.
         if (path === "/api/quota" && req.method === "GET") {
-            return json(res, 200, (0, quota_js_1.quotaToJson)((0, quota_js_2.loadQuotaReport)(db)));
+            return json(res, 200, (0, quota_js_1.quotaToJson)((0, quota_js_2.loadQuotaReport)(db, new Date(), { dbPath })));
         }
         if (path === "/api/day" && req.method === "GET") {
             const date = url.searchParams.get("date") ?? todayIso();

package/dist/statusline-cache.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `statusline.json`, junto a la base: lo que la status line recuerda entre
+ * llamadas.
+ *
+ *  - `files`: hasta qué byte se leyó cada transcript, para leer solo lo nuevo.
+ *  - `fiveHour`: el último `rate_limits.five_hour.resets_at` que mandó Claude
+ *    Code, y cuándo se vio. `estela quota` lo usa para saber dónde empieza de
+ *    verdad la ventana de 5 h en vez de estimarla.
+ *
+ * Es una caché: si se pierde o se corrompe, todo sigue funcionando, solo que
+ * relee más o vuelve a estimar.
+ */
+export interface StatuslineCache {
+    files: Record<string, {
+        offset: number;
+        seenAt: string;
+    }>;
+    fiveHour?: {
+        resetsAt: string;
+        seenAt: string;
+    };
+}
+export declare function cachePath(dbPath: string): string;
+export declare function loadCache(dbPath: string): StatuslineCache;
+export declare function saveCache(dbPath: string, cache: StatuslineCache): void;
+/**
+ * Apunta el `resets_at` de la ventana de 5 h. Solo si existe ya el directorio
+ * de Estela: la status line no es quien empieza a guardar datos.
+ */
+export declare function recordFiveHourReset(dbPath: string, resetsAt: Date, now: Date): void;
+export declare function readFiveHourReset(dbPath: string): {
+    resetsAt: Date;
+    seenAt: Date;
+} | null;
+//# sourceMappingURL=statusline-cache.d.ts.map

package/dist/statusline-cache.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachePath = cachePath;
+exports.loadCache = loadCache;
+exports.saveCache = saveCache;
+exports.recordFiveHourReset = recordFiveHourReset;
+exports.readFiveHourReset = readFiveHourReset;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const MAX_FILES = 30;
+/** Con el mismo reinicio, no se reescribe más a menudo que esto. */
+const FIVE_HOUR_REFRESH_MS = 10 * 60_000;
+function cachePath(dbPath) {
+    return (0, node_path_1.join)((0, node_path_1.dirname)(dbPath), "statusline.json");
+}
+function loadCache(dbPath) {
+    try {
+        const c = JSON.parse((0, node_fs_1.readFileSync)(cachePath(dbPath), "utf8"));
+        return c && typeof c.files === "object" && c.files ? c : { files: {} };
+    }
+    catch {
+        return { files: {} };
+    }
+}
+function saveCache(dbPath, cache) {
+    // Solo los transcripts vistos más recientemente: uno por sesión, y las
+    // sesiones viejas ya no escriben.
+    const files = Object.fromEntries(Object.entries(cache.files)
+        .sort((a, b) => b[1].seenAt.localeCompare(a[1].seenAt)).slice(0, MAX_FILES));
+    try {
+        (0, node_fs_1.writeFileSync)(cachePath(dbPath), JSON.stringify({ ...cache, files }));
+    }
+    catch { /* sin caché, la próxima vez se relee: más lento, no incorrecto */ }
+}
+/**
+ * Apunta el `resets_at` de la ventana de 5 h. Solo si existe ya el directorio
+ * de Estela: la status line no es quien empieza a guardar datos.
+ */
+function recordFiveHourReset(dbPath, resetsAt, now) {
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.dirname)(dbPath)))
+        return;
+    const cache = loadCache(dbPath);
+    const prev = cache.fiveHour;
+    const same = prev && new Date(prev.resetsAt).getTime() === resetsAt.getTime();
+    if (same && now.getTime() - new Date(prev.seenAt).getTime() < FIVE_HOUR_REFRESH_MS)
+        return;
+    cache.fiveHour = { resetsAt: resetsAt.toISOString(), seenAt: now.toISOString() };
+    saveCache(dbPath, cache);
+}
+function readFiveHourReset(dbPath) {
+    const f = loadCache(dbPath).fiveHour;
+    if (!f)
+        return null;
+    const resetsAt = new Date(f.resetsAt), seenAt = new Date(f.seenAt);
+    return Number.isNaN(resetsAt.getTime()) || Number.isNaN(seenAt.getTime()) ? null : { resetsAt, seenAt };
+}
+//# sourceMappingURL=statusline-cache.js.map

package/dist/statusline-install.d.ts

@@ -0,0 +1,52 @@
+/**
+ * `estela statusline install | uninstall`: el bloque `statusLine` de
+ * `~/.claude/settings.json`.
+ *
+ * Ese fichero es de quien usa Claude Code, con sus permisos, sus hooks y sus
+ * plugins. Se toca lo justo: se lee, se cambia una clave y se reescribe el
+ * resto tal cual; antes, una copia. Si ya hay otra status line, no se pisa.
+ *
+ * Funciones puras sobre el texto del fichero: quien llama lee y escribe.
+ */
+export declare const OUR_COMMAND = "estela statusline";
+/** Dónde vive la configuración de Claude Code (`CLAUDE_CONFIG_DIR` la mueve). */
+export declare function claudeSettingsPath(env?: NodeJS.ProcessEnv): string;
+export type InstallResult = {
+    readonly status: "installed" | "replaced" | "chained";
+    readonly text: string;
+    readonly previous: string | null;
+} | {
+    readonly status: "already";
+} | {
+    readonly status: "conflict";
+    readonly existing: string;
+} | {
+    readonly status: "invalid";
+};
+export type UninstallResult = {
+    readonly status: "removed" | "restored";
+    readonly text: string;
+    readonly restored: string | null;
+} | {
+    readonly status: "absent";
+} | {
+    readonly status: "foreign";
+    readonly existing: string;
+} | {
+    readonly status: "invalid";
+};
+export declare function isOurs(command: string | null): boolean;
+/** Comillas simples de shell: lo que va dentro se pasa tal cual. */
+export declare function shellQuote(text: string): string;
+/** El comando encadenado dentro de `--append '…'`, si lo hay. */
+export declare function appendedCommand(command: string): string | null;
+export declare function planInstall(text: string | null, options?: {
+    readonly force?: boolean;
+    readonly append?: boolean;
+}): InstallResult;
+export declare function planUninstall(text: string | null): UninstallResult;
+/** `estela` en el PATH. Con `npx` cada evento tardaría cientos de milisegundos. */
+export declare function estelaOnPath(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
+/** "settings.json.bak-20261014-161230": una copia por instalación, sin pisar las anteriores. */
+export declare function backupName(path: string, now?: Date): string;
+//# sourceMappingURL=statusline-install.d.ts.map