estela 0.3.0 → 0.3.3

package/README.md

@@ -117,9 +117,9 @@ Two things trip people up before Estela even starts:
   administrator terminal. `where.exe npm` should list a single path.
 
 A session in a subfolder or a git worktree counts for its repository's
-project. If an import would add hours to what you had already imported, Estela
-shows you how many per project and asks first (`estela import --yes` skips the
-question); it never moves hours between projects or touches an approved day.
+project. Two branches at once in the same project share that time, so the total
+is real time; different projects don't share. An import never moves hours between
+projects or touches an approved day.
 
 ## Reporting to a client
 

package/dist/billing/assign.d.ts

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
-import type { TimeEntry } from "@estela/shared";
+import type { AgentTurn, CommitRecord, TimeEntry } from "@estela/shared";
 import { type WorkBlock } from "./sessionize.js";
 /**
  * De bloques de trabajo a imputaciones: a qué proyecto va cada uno y con qué
@@ -13,7 +13,11 @@ import { type WorkBlock } from "./sessionize.js";
  *     mira primero, así que nada de lo ya asignado cambia de proyecto.
  *  2. Un día aprobado o facturado de ese proyecto no se toca: las horas que se
  *     recuperarían ahí se informan (`blocked`), no se aplican.
- *  3. Recuperar es opcional (`recover`): la primera vez lo confirma la persona.
+ *
+ * Y dos ramas a la vez en el mismo proyecto no suman dos horas por cada hora de
+ * reloj: lo que registra Estela es tiempo real, y ese rato se reparte entre
+ * ellas (ver `sharedSeconds`). Cobrar un precio pactado por encima de lo medido
+ * es un ajuste a mano con su motivo, que conserva lo medido al lado.
  */
 export interface PlannedEntry {
     readonly entry: Omit<TimeEntry, "id"> & {
@@ -37,9 +41,37 @@ export interface AssignmentPlan {
     readonly recovered: ReadonlyMap<string, number>;
     /** Lo que se recuperaría en días aprobados o facturados: no se aplica. */
     readonly blocked: readonly RecoveryBlocked[];
+    /** Imputaciones sin horas propias y sin revisar: se retiran. */
+    readonly stale: readonly string[];
+    /** Las mismas, pero aprobadas, ajustadas o facturadas: no se tocan, se avisa. */
+    readonly protectedDuplicates: readonly string[];
 }
 export declare function entryId(projectId: string, day: string, branch: string | null): string;
-export declare function planEntries(db: DatabaseSync, raw: readonly WorkBlock[], options: {
-    readonly recover: boolean;
-}): AssignmentPlan;
+/**
+ * Los bloques deducidos solo de commits: los que no se solapan con ninguna
+ * sesión de agente, tampoco con las que ya no están en el disco.
+ *
+ * Claude Code limpia sus transcripts antiguos, así que lo escaneado no es todo
+ * lo que hubo. Comparar solo con eso convertía los commits de esas sesiones en
+ * trabajo sin agente, y sumaba horas estimadas a un trabajo ya medido. La base
+ * guarda todos los turnos: `saveTurns` no borra nada.
+ *
+ * `git log --all` desde un worktree trae la historia entera del repo, así que
+ * cada commit queda guardado también bajo la ruta del worktree. Por eso se
+ * compara por raíz git: sin ella, esa copia no la tapa ninguna sesión del repo
+ * y, al recuperar, sumaba horas estimadas a días ya medidos.
+ */
+export declare function commitOnlyBlocks(db: DatabaseSync, commits: readonly CommitRecord[], agentBlocks: readonly WorkBlock[]): WorkBlock[];
+/**
+ * Todos los turnos conocidos: los de la base más los recién leídos.
+ *
+ * Una imputación se reescribe entera, así que hay que calcularla con todo lo
+ * que hubo ese día. Con solo lo leído del disco, un transcript que Claude Code
+ * ya limpió (o un `--since`) dejaba 4 h medidas convertidas en los 25 min del
+ * único commit que quedaba. Lo recién leído manda porque el lector sabe cosas
+ * que la base no: `saveTurns` no reescribe un turno ya guardado, y una versión
+ * nueva puede devolverlo a su carpeta real.
+ */
+export declare function knownTurns(db: DatabaseSync, scanned: readonly AgentTurn[]): AgentTurn[];
+export declare function planEntries(db: DatabaseSync, raw: readonly WorkBlock[]): AssignmentPlan;
 //# sourceMappingURL=assign.d.ts.map

package/dist/billing/assign.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.entryId = entryId;
+exports.commitOnlyBlocks = commitOnlyBlocks;
+exports.knownTurns = knownTurns;
 exports.planEntries = planEntries;
 const shared_1 = require("@estela/shared");
 const store = __importStar(require("../db/store.js"));
@@ -42,10 +44,118 @@ const sessionize_js_1 = require("./sessionize.js");
 function entryId(projectId, day, branch) {
     // Determinista (proyecto + día + rama) para que reimportar actualice en vez
     // de duplicar. La fecha, la LOCAL: la misma que usa el servidor.
-    const slug = (branch ?? "sin-rama").replace(/[^a-zA-Z0-9]+/g, "-");
-    return `te_${projectId}_${day}_${slug}`;
+    return `te_${projectId}_${day}_${branchSlug(branch)}`;
 }
-function planEntries(db, raw, options) {
+function branchSlug(branch) {
+    return (branch ?? "sin-rama").replace(/[^a-zA-Z0-9]+/g, "-");
+}
+/**
+ * Los bloques deducidos solo de commits: los que no se solapan con ninguna
+ * sesión de agente, tampoco con las que ya no están en el disco.
+ *
+ * Claude Code limpia sus transcripts antiguos, así que lo escaneado no es todo
+ * lo que hubo. Comparar solo con eso convertía los commits de esas sesiones en
+ * trabajo sin agente, y sumaba horas estimadas a un trabajo ya medido. La base
+ * guarda todos los turnos: `saveTurns` no borra nada.
+ *
+ * `git log --all` desde un worktree trae la historia entera del repo, así que
+ * cada commit queda guardado también bajo la ruta del worktree. Por eso se
+ * compara por raíz git: sin ella, esa copia no la tapa ninguna sesión del repo
+ * y, al recuperar, sumaba horas estimadas a días ya medidos.
+ */
+function commitOnlyBlocks(db, commits, agentBlocks) {
+    const saved = (0, sessionize_js_1.sessionize)(store.turnsBetween(db, new Date(0), new Date("9999-12-31")));
+    const roots = new Map();
+    const rootOf = (path) => {
+        let root = roots.get(path);
+        if (root === undefined) {
+            root = (0, project_of_js_1.gitRoot)(path) ?? path;
+            roots.set(path, root);
+        }
+        return root;
+    };
+    return (0, sessionize_js_1.withoutOverlap)((0, sessionize_js_1.sessionizeCommits)(commits), [...agentBlocks, ...saved], rootOf);
+}
+/**
+ * Todos los turnos conocidos: los de la base más los recién leídos.
+ *
+ * Una imputación se reescribe entera, así que hay que calcularla con todo lo
+ * que hubo ese día. Con solo lo leído del disco, un transcript que Claude Code
+ * ya limpió (o un `--since`) dejaba 4 h medidas convertidas en los 25 min del
+ * único commit que quedaba. Lo recién leído manda porque el lector sabe cosas
+ * que la base no: `saveTurns` no reescribe un turno ya guardado, y una versión
+ * nueva puede devolverlo a su carpeta real.
+ */
+function knownTurns(db, scanned) {
+    const byId = new Map(store.turnsBetween(db, new Date(0), new Date("9999-12-31")).map((t) => [t.turnId, t]));
+    for (const turn of scanned)
+        byId.set(turn.turnId, turn);
+    return [...byId.values()];
+}
+/**
+ * Imputaciones guardadas que ya no salen en el plan y cuyas horas están dentro
+ * de otras del mismo proyecto.
+ *
+ * El id lleva la rama, y la rama de un bloque es la de su último turno: si la
+ * sesión sigue en otra rama, la siguiente importación crea otra imputación con
+ * el bloque entero y la anterior se quedaba, cobrando dos veces el mismo rato.
+ *
+ * Retirar horas es peor que no hacerlo si se acierta mal, así que se exige todo:
+ *
+ *  - Ningún bloque de ese día lleva esa rama, tenga proyecto o no. Si lo lleva,
+ *    esas horas siguen existiendo, como las de un worktree ya borrado.
+ *  - Los bloques del proyecto cubren lo que dice la imputación, en su horario.
+ *    Si no, son horas de las que no queda otro rastro.
+ *
+ * Lo aprobado, ajustado o facturado no se retira nunca: solo se avisa.
+ */
+function findDuplicates(db, raw, planned, projectOf) {
+    const rows = db.prepare(`SELECT id, project_id, local_date, branch, started_at, ended_at, seconds, approved, invoice_id, adjust_reason
+       FROM time_entries WHERE source IN ('agent', 'commit')`).all();
+    const stale = [];
+    const protectedDuplicates = [];
+    const blocksByDay = new Map();
+    for (const block of raw) {
+        const day = (0, shared_1.localDate)(block.startedAt);
+        const bucket = blocksByDay.get(day);
+        if (bucket)
+            bucket.push(block);
+        else
+            blocksByDay.set(day, [block]);
+    }
+    for (const row of rows) {
+        if (planned.has(row["id"]))
+            continue;
+        const day = blocksByDay.get(row["local_date"]) ?? [];
+        const slug = branchSlug(row["branch"] ?? null);
+        if (day.some((b) => branchSlug(b.branch) === slug))
+            continue;
+        const from = new Date(row["started_at"]).getTime();
+        const to = new Date(row["ended_at"]).getTime();
+        const covered = coveredMs(day.filter((b) => projectOf(b.repoPath) === row["project_id"]), from, to) / 1000;
+        if (covered < row["seconds"] - 60)
+            continue;
+        const locked = row["approved"] === 1 || row["invoice_id"] !== null || row["adjust_reason"] !== null;
+        (locked ? protectedDuplicates : stale).push(row["id"]);
+    }
+    return { stale, protectedDuplicates };
+}
+/** Cuánto de [from, to] cae dentro de los bloques, sin contar dos veces un solape. */
+function coveredMs(blocks, from, to) {
+    const intervals = blocks
+        .map((b) => [Math.max(b.startedAt.getTime(), from), Math.min(b.endedAt.getTime(), to)])
+        .sort((a, b) => a[0] - b[0]);
+    let ms = 0;
+    let until = from;
+    for (const [start, end] of intervals) {
+        const desde = Math.max(start, until);
+        if (end > desde)
+            ms += end - desde;
+        until = Math.max(until, end);
+    }
+    return ms;
+}
+function planEntries(db, raw) {
     const ownerOf = (0, project_of_js_1.ownerResolver)(db);
     const direct = (repo) => (repo ? store.projectForRepo(db, repo) : null);
     const viaRoot = (repo) => {
@@ -54,20 +164,11 @@ function planEntries(db, raw, options) {
         const o = ownerOf(repo);
         return o.kind === "project" ? o.projectId : null;
     };
-    // Lo de siempre: la carpeta tal cual. Se agrupa por PROYECTO, no por ruta:
-    // `repo/` y `repo/src/UI` son el mismo proyecto, y agrupar por ruta daba dos
-    // bloques que luego se pisaban al guardarse con el mismo id.
+    // La carpeta tal cual. Se agrupa por PROYECTO, no por ruta: `repo/` y
+    // `repo/src/UI` son el mismo proyecto, y agrupar por ruta daba dos bloques que
+    // luego se pisaban al guardarse con el mismo id.
     const keyDirect = (b) => direct(b.repoPath) ?? b.repoPath ?? "";
-    const groupedBase = (0, sessionize_js_1.groupByBranchAndDay)(raw, keyDirect);
-    const base = byId(groupedBase, direct);
-    if (!options.recover) {
-        return {
-            entries: [...base.values()].map((g) => ({ entry: toEntry(db, g.projectId, g.block), recoveredSeconds: 0 })),
-            grouped: groupedBase.length,
-            unassigned: groupedBase.filter((b) => !direct(b.repoPath)).length,
-            recovered: new Map(), blocked: [],
-        };
-    }
+    const base = byId((0, sessionize_js_1.groupByBranchAndDay)(raw, keyDirect), direct);
     // Con la raíz git, pero solo para lo que no tenía proyecto (regla 1).
     const assigned = (repo) => direct(repo) ?? viaRoot(repo);
     const keyFull = (b) => assigned(b.repoPath) ?? b.repoPath ?? "";
@@ -91,35 +192,126 @@ function planEntries(db, raw, options) {
         }
         return lockedDays.get(k);
     };
-    const entries = [];
-    const recovered = new Map();
+    // Primero qué filas quedan y con qué bloques, y después el reparto: una sesión
+    // que la regla 2 deja fuera no puede restarle tiempo a la que sí cuenta.
+    const rows = [];
     const blocked = [];
+    const rawByProject = (projectOf) => {
+        const out = new Map();
+        for (const b of raw) {
+            const p = projectOf(b.repoPath);
+            if (!p)
+                continue;
+            const id = entryId(p, (0, shared_1.localDate)(b.startedAt), b.branch);
+            const bucket = out.get(id);
+            if (bucket)
+                bucket.push(b);
+            else
+                out.set(id, [b]);
+        }
+        return out;
+    };
+    const fullBlocks = rawByProject(assigned);
+    const directBlocks = rawByProject(direct);
     for (const [id, g] of full) {
         const before = base.get(id);
-        if (!touched.has(id)) {
-            entries.push({ entry: toEntry(db, g.projectId, g.block), recoveredSeconds: 0 });
-            continue;
-        }
-        const gain = Math.max(0, g.block.seconds - (before?.block.seconds ?? 0));
         const day = (0, shared_1.localDate)(g.block.startedAt);
-        if (locked(g.projectId, day)) {
+        if (touched.has(id) && locked(g.projectId, day)) {
             // Regla 2: el día se queda como estaba; si antes no había nada, nada.
             if (before)
-                entries.push({ entry: toEntry(db, before.projectId, before.block), recoveredSeconds: 0 });
+                rows.push({ id, projectId: before.projectId, block: before.block, blocks: directBlocks.get(id) ?? [], before: null });
+            const gain = Math.max(0, g.block.seconds - (before?.block.seconds ?? 0));
             if (gain > 0)
                 blocked.push({ projectId: g.projectId, day, seconds: gain });
             continue;
         }
-        entries.push({ entry: toEntry(db, g.projectId, g.block), recoveredSeconds: gain });
+        rows.push({ id, projectId: g.projectId, block: g.block, blocks: fullBlocks.get(id) ?? [],
+            before: touched.has(id) ? (before?.block.seconds ?? 0) : null });
+    }
+    const shares = sharedSeconds(rows, lockedEntryIds(db));
+    const entries = [];
+    const recovered = new Map();
+    const empty = [];
+    for (const row of rows) {
+        const seconds = shares.get(row.id) ?? row.block.seconds;
+        if (seconds <= 0) {
+            empty.push(row.id);
+            continue;
+        }
+        const gain = row.before === null ? 0 : Math.max(0, seconds - row.before);
+        entries.push({ entry: toEntry(db, row.projectId, { ...row.block, seconds }), recoveredSeconds: gain });
         if (gain > 0)
-            recovered.set(g.projectId, (recovered.get(g.projectId) ?? 0) + gain);
+            recovered.set(row.projectId, (recovered.get(row.projectId) ?? 0) + gain);
     }
+    const duplicates = findDuplicates(db, raw, new Set(entries.map((e) => e.entry.id)), assigned);
     return {
         entries, grouped: groupedFull.length,
         unassigned: groupedFull.filter((b) => !assigned(b.repoPath)).length,
         recovered, blocked,
+        stale: [...duplicates.stale, ...empty],
+        protectedDuplicates: duplicates.protectedDuplicates,
     };
 }
+/** Las imputaciones cuya cifra ya no puede cambiar. */
+function lockedEntryIds(db) {
+    const rows = db.prepare("SELECT id FROM time_entries WHERE approved = 1 OR invoice_id IS NOT NULL").all();
+    return new Set(rows.map((r) => r.id));
+}
+/**
+ * Los segundos de cada imputación cuando varias ramas del mismo proyecto
+ * coinciden en el reloj: el rato compartido se reparte a partes iguales, y el
+ * total del proyecto es el tiempo real.
+ *
+ * Dos chats en dos worktrees durante una hora son una hora de quien trabaja, no
+ * dos. Proyectos distintos no se reparten entre sí: esa decisión es por cliente.
+ *
+ * Lo aprobado o facturado ya tiene su cifra y no cambia, así que el rato que
+ * cubre ya está cobrado o dado por bueno: las demás no reciben nada de él.
+ */
+function sharedSeconds(rows, lockedIds) {
+    const byProject = new Map();
+    for (const row of rows) {
+        const bucket = byProject.get(row.projectId);
+        if (bucket)
+            bucket.push(row);
+        else
+            byProject.set(row.projectId, [row]);
+    }
+    const ms = new Map();
+    for (const projectRows of byProject.values()) {
+        const events = [];
+        for (const row of projectRows) {
+            for (const b of row.blocks) {
+                events.push({ at: b.startedAt.getTime(), id: row.id, delta: 1 });
+                events.push({ at: b.endedAt.getTime(), id: row.id, delta: -1 });
+            }
+        }
+        events.sort((a, b) => a.at - b.at);
+        const active = new Map();
+        let previous = events[0]?.at ?? 0;
+        for (const event of events) {
+            if (event.at > previous && active.size > 0) {
+                const span = event.at - previous;
+                const ids = [...active.keys()];
+                const lockedHere = ids.filter((id) => lockedIds.has(id));
+                const payees = lockedHere.length ? lockedHere : ids;
+                const share = lockedHere.length ? span : span / ids.length;
+                for (const id of payees)
+                    ms.set(id, (ms.get(id) ?? 0) + share);
+            }
+            previous = event.at;
+            const count = (active.get(event.id) ?? 0) + event.delta;
+            if (count > 0)
+                active.set(event.id, count);
+            else
+                active.delete(event.id);
+        }
+    }
+    const seconds = new Map();
+    for (const row of rows)
+        seconds.set(row.id, Math.round((ms.get(row.id) ?? 0) / 1000));
+    return seconds;
+}
 /** Los bloques agrupados con proyecto, por el id con el que se guardarían. */
 function byId(blocks, projectOf) {
     const out = new Map();

package/dist/billing/sessionize.d.ts

@@ -113,6 +113,14 @@ export declare function sessionizeCommits(commits: readonly CommitRecord[], opti
  *
  * Sin esto se contaría dos veces el mismo rato: el agente ya cubrió esas horas
  * y el commit que las cerró generaría otro bloque encima.
+ *
+ * Mismo repositorio quiere decir lo mismo que en `attachCommits`: la carpeta
+ * del commit (la raíz) o una subcarpeta suya. Antes se exigía la ruta exacta,
+ * y una sesión abierta en `repo/src/UI` no tapaba el commit hecho en `repo`:
+ * se sumaban 25 minutos estimados encima de una sesión medida.
+ *
+ * Un worktree vive fuera del repositorio y las rutas no lo dicen: `rootOf` da
+ * la raíz de cada carpeta, y es esa la que se compara.
  */
-export declare function withoutOverlap(commitBlocks: readonly WorkBlock[], agentBlocks: readonly WorkBlock[]): WorkBlock[];
+export declare function withoutOverlap(commitBlocks: readonly WorkBlock[], agentBlocks: readonly WorkBlock[], rootOf?: (path: string) => string): WorkBlock[];
 //# sourceMappingURL=sessionize.d.ts.map

package/dist/billing/sessionize.js

@@ -118,7 +118,6 @@ function groupByBranchAndDay(blocks, ambito = (b) => b.repoPath ?? "") {
     for (const bucket of groups.values()) {
         bucket.sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime());
         const first = bucket[0];
-        const last = bucket[bucket.length - 1];
         // Ni el lapso de principio a fin —entre bloques hubo huecos en los que no
         // estabas trabajando, y facturarlos sería cobrar de más— ni la suma de
         // duraciones: los segundos de un bloque SON su intervalo de reloj, y dos
@@ -154,7 +153,9 @@ function groupByBranchAndDay(blocks, ambito = (b) => b.repoPath ?? "") {
         }
         merged.push({
             startedAt: first.startedAt,
-            endedAt: last.endedAt,
+            // El último en empezar no es siempre el último en acabar: una sesión en
+            // una subcarpeta puede caer entera dentro de la del repo.
+            endedAt: new Date(Math.max(...bucket.map((b) => b.endedAt.getTime()))),
             seconds,
             repoPath: first.repoPath,
             branch: first.branch,
@@ -290,10 +291,24 @@ function sessionizeCommits(commits, options = {}) {
  *
  * Sin esto se contaría dos veces el mismo rato: el agente ya cubrió esas horas
  * y el commit que las cerró generaría otro bloque encima.
+ *
+ * Mismo repositorio quiere decir lo mismo que en `attachCommits`: la carpeta
+ * del commit (la raíz) o una subcarpeta suya. Antes se exigía la ruta exacta,
+ * y una sesión abierta en `repo/src/UI` no tapaba el commit hecho en `repo`:
+ * se sumaban 25 minutos estimados encima de una sesión medida.
+ *
+ * Un worktree vive fuera del repositorio y las rutas no lo dicen: `rootOf` da
+ * la raíz de cada carpeta, y es esa la que se compara.
  */
-function withoutOverlap(commitBlocks, agentBlocks) {
-    return commitBlocks.filter((c) => !agentBlocks.some((a) => a.repoPath === c.repoPath &&
-        a.startedAt.getTime() < c.endedAt.getTime() &&
-        c.startedAt.getTime() < a.endedAt.getTime()));
+function withoutOverlap(commitBlocks, agentBlocks, rootOf = (path) => path) {
+    const root = (path) => (path ? rootOf(path) : null);
+    return commitBlocks.filter((c) => !agentBlocks.some((a) => a.startedAt.getTime() < c.endedAt.getTime() &&
+        c.startedAt.getTime() < a.endedAt.getTime() &&
+        sameRepo(root(a.repoPath), root(c.repoPath))));
+}
+function sameRepo(a, b) {
+    if (a === b)
+        return true;
+    return !!a && !!b && ((0, paths_js_1.isSameOrInside)(a, b) || (0, paths_js_1.isSameOrInside)(b, a));
 }
 //# sourceMappingURL=sessionize.js.map

package/dist/cli.js

@@ -96,12 +96,12 @@ estela — registro de horas para desarrollo asistido por IA
         Primera ejecución: detecta tus agentes y repositorios, y reconstruye
         tu historial. Dos minutos, sin preguntas y sin cuenta.
 
-  estela import [--since YYYY-MM-DD] [--repo <ruta>] [--yes]
+  estela import [--since YYYY-MM-DD] [--repo <ruta>]
         Reconstruye tu historial desde los transcripts de los agentes y git.
         Una sesión en una subcarpeta o en un worktree cuenta para el
-        proyecto de su repo. La primera vez que eso suma horas a lo ya
-        importado, te enseña cuántas y pregunta (--yes no pregunta). Nunca
-        mueve horas de un proyecto a otro ni toca un día aprobado.
+        proyecto de su repo. Dos ramas a la vez en un proyecto se reparten
+        ese rato: el total es tiempo real. Nunca mueve horas de un proyecto
+        a otro ni toca un día aprobado.
 
   estela client add --id <id> --name <nombre> --currency <EUR|USD|...>
                     [--tax-id <NIF/CIF>] [--email <a@b.com>]
@@ -278,9 +278,11 @@ estela — registro de horas para desarrollo asistido por IA
                 [--pdf <fichero.pdf>] [--csv <fichero.csv>] [--fx <tipo>]
                 [--number <nº>]
                 [--from-name <tu nombre>] [--from-email <email>]
-                [--from-tax-id <tu NIF/CIF>]
+                [--from-tax-id <tu NIF/CIF>] [--no-amounts]
         Informe de horas y commits para respaldar tu trabajo. No es una
         factura: Estela no emite documentos fiscales.
+        --no-amounts saca el PDF sin tarifa ni importes. En el panel, lo ya
+        emitido se vuelve a descargar con o sin ellos.
         --number fija el número del informe; sin él se numera solo y
         correlativo por año (INF-${new Date().getFullYear()}-001, -002...).
         Los --from-* son tus datos como emisor, en la cabecera del PDF.
@@ -305,12 +307,12 @@ estela — time tracking for AI-assisted development
         First run: detects your agents and repositories, and rebuilds your
         history. Two minutes, no questions, no account.
 
-  estela import [--since YYYY-MM-DD] [--repo <path>] [--yes]
+  estela import [--since YYYY-MM-DD] [--repo <path>]
         Rebuilds your history from agent transcripts and git. A session in a
-        subfolder or a worktree counts for its repo's project. The first
-        time that adds hours to what was already imported, it shows how many
-        and asks (--yes skips the question). It never moves hours from one
-        project to another or touches an approved day.
+        subfolder or a worktree counts for its repo's project. Two branches
+        at once in a project share that time: the total is real time. It
+        never moves hours from one project to another or touches an approved
+        day.
 
   estela client add --id <id> --name <name> --currency <EUR|USD|...>
                     [--tax-id <tax ID>] [--email <a@b.com>]
@@ -489,9 +491,11 @@ estela — time tracking for AI-assisted development
                 [--pdf <file.pdf>] [--csv <file.csv>] [--fx <rate>]
                 [--number <no.>]
                 [--from-name <your name>] [--from-email <email>]
-                [--from-tax-id <your tax ID>]
+                [--from-tax-id <your tax ID>] [--no-amounts]
         Report of hours and commits to back up your work. It isn't an
         invoice: Estela doesn't issue tax documents.
+        --no-amounts leaves the rate and amounts out of the PDF. In the panel,
+        issued reports can be downloaded again with or without them.
         --number sets the report number; without it, reports are numbered
         automatically and sequentially per year (INF-${new Date().getFullYear()}-001, -002...).
         The --from-* flags are your details as the issuer, in the PDF header.
@@ -776,18 +780,6 @@ async function cmdSetup(args, dbPath) {
         db.close();
     }
 }
-/** La vista previa de la primera recuperación: horas por proyecto. */
-function printRecoveryPreview(db, plan) {
-    console.log((0, index_js_1.tr) `\nEstela ahora reconoce las sesiones en subcarpetas y worktrees de un repositorio.`);
-    console.log((0, index_js_1.tr) `Estas horas no estaban imputadas y se sumarían a su proyecto:\n`);
-    for (const [projectId, seconds] of [...plan.recovered].sort((a, b) => b[1] - a[1])) {
-        const name = store.getProject(db, projectId)?.name ?? projectId;
-        console.log(`  ${name.padEnd(30)} +${(0, shared_1.formatDuration)(seconds)}`);
-    }
-    console.log((0, index_js_1.tr) `\n  Nada de lo ya imputado cambia de proyecto, y los días aprobados no se tocan.`);
-    printRecoveryBlocked(db, plan.blocked);
-    console.log("");
-}
 /** Lo que se recuperaría en días aprobados o facturados: se avisa, no se aplica. */
 function printRecoveryBlocked(db, blocked) {
     if (blocked.length === 0)
@@ -886,7 +878,12 @@ async function cmdImport(args, dbPath) {
                 continue;
             savedCommits += store.saveCommits(db, await (0, git_js_1.readCommits)(root, since ? { since } : {}));
         }
-        const mine = await (0, identity_js_1.myEmailsByRepo)(db, repos);
+        // Todo lo conocido, no solo lo leído ahora (ver knownTurns). Con --repo, solo
+        // ese repo, que es lo que se ha pedido.
+        const known = (0, assign_js_1.knownTurns)(db, turns).filter((t) => !repoPaths || (t.repoPath !== null && repoPaths.some((p) => (0, paths_js_1.isSameOrInside)(t.repoPath, p))));
+        // Los correos también de los repos sin sesión reciente: sin ellos, un día
+        // antiguo se recalcularía sin sus commits y perdería la descripción.
+        const mine = await (0, identity_js_1.myEmailsByRepo)(db, new Set([...repos, ...known.flatMap((t) => t.repoPath ?? [])]));
         if (rescued > 0) {
             console.log((0, index_js_1.tr) `  ${rescued} turnos de scratchpad devueltos a su repositorio`);
         }
@@ -901,57 +898,42 @@ async function cmdImport(args, dbPath) {
         // Solo TUS commits derivan horas tuyas. Sin este filtro, los commits de un
         // compañero se convertirían en tiempo facturable a tu nombre.
         const commitsAll = (0, identity_js_1.onlyMine)(await allCommits(db), mine);
-        const fromAgents = (0, sessionize_js_1.attachCommits)((0, sessionize_js_1.sessionize)(turns), commitsAll);
-        const fromCommits = (0, sessionize_js_1.withoutOverlap)((0, sessionize_js_1.sessionizeCommits)(commitsAll), fromAgents);
+        const fromAgents = (0, sessionize_js_1.attachCommits)((0, sessionize_js_1.sessionize)(known), commitsAll);
+        const fromCommits = (0, assign_js_1.commitOnlyBlocks)(db, commitsAll, fromAgents);
         const raw = [...fromAgents, ...fromCommits];
         if (fromCommits.length) {
             console.log((0, index_js_1.tr) `  ${fromCommits.length} bloques deducidos solo de commits (sin agente)`);
         }
-        // Horas de sesiones en subcarpetas y worktrees, que antes se quedaban sin
-        // proyecto (ver billing/assign.ts). La primera vez que cambian horas ya
-        // importadas se enseñan antes y se pide confirmación; en una base nueva no
-        // hay nada que cambiar, así que se aplica sin preguntar.
-        const marca = (0, node_path_1.join)((0, node_path_1.dirname)(dbPath), ".recover-git-root");
-        const habiaHoras = db.prepare("SELECT COUNT(*) AS n FROM time_entries").get().n > 0;
-        let plan = (0, assign_js_1.planEntries)(db, raw, { recover: true });
-        const conRaiz = plan;
-        const recuperable = [...plan.recovered.values()].reduce((a, b) => a + b, 0);
-        if (!(0, node_fs_1.existsSync)(marca) && habiaHoras && recuperable > 0) {
-            printRecoveryPreview(db, plan);
-            const ok = args.flags["yes"] === true || await confirm((0, index_js_1.tr) `¿Imputar estas horas? [s/N] `);
-            if (!ok) {
-                plan = (0, assign_js_1.planEntries)(db, raw, { recover: false });
-                console.log((0, index_js_1.tr) `  No se ha tocado nada. Cuando quieras: estela import --yes\n`);
-            }
-            else {
-                (0, node_fs_1.writeFileSync)(marca, new Date().toISOString());
-            }
-        }
-        else {
-            try {
-                (0, node_fs_1.writeFileSync)(marca, new Date().toISOString());
-            }
-            catch { /* sin marca, se volverá a preguntar */ }
-        }
+        // Sesiones en subcarpetas y worktrees incluidas: ver billing/assign.ts.
+        const plan = (0, assign_js_1.planEntries)(db, raw);
         for (const { entry } of plan.entries)
             store.saveTimeEntry(db, entry);
+        // Con --repo el plan no ve el resto de proyectos: nada de retirar.
+        const retired = repoPaths ? 0 : store.deleteStaleEntries(db, plan.stale);
         const entries = plan.entries.length;
         const unassigned = plan.unassigned;
         console.log((0, index_js_1.tr) `Bloques: ${raw.length} detectados → ${plan.grouped} tras agrupar por rama y día · ` +
             (0, index_js_1.tr) `${entries} imputados · ${unassigned} sin proyecto`);
         const aplicadas = [...plan.recovered.values()].reduce((a, b) => a + b, 0);
-        if (aplicadas > 0 && (0, node_fs_1.existsSync)(marca)) {
+        if (aplicadas > 0) {
             console.log((0, index_js_1.tr) `  ${(0, shared_1.formatDuration)(aplicadas)} recuperadas de sesiones en subcarpetas y worktrees`);
         }
         printRecoveryBlocked(db, plan.blocked);
-        // Si no se confirmó, parte de "sin proyecto" son sesiones de subcarpetas y
-        // worktrees: a esas no les falta registrarse, les falta el --yes.
-        const porRaiz = unassigned - conRaiz.unassigned;
-        if (porRaiz > 0) {
-            console.log((0, index_js_1.tr) `\n${porRaiz} de esos bloques son de subcarpetas o worktrees de un proyecto: estela import --yes los imputa.`);
-        }
-        if (unassigned - porRaiz > 0) {
-            console.log((0, index_js_1.tr) `\nHay ${unassigned - porRaiz} bloques sin proyecto asignado. Regístralos con:`);
+        if (retired > 0) {
+            console.log((0, index_js_1.tr) `  ${retired} imputaciones retiradas: sus horas ya estaban en otra rama del mismo día`);
+        }
+        // Estas no se tocan, pero conviene saberlo antes de facturar lo que las repite.
+        const pendientes = plan.protectedDuplicates.filter((id) => {
+            const row = db.prepare("SELECT invoice_id FROM time_entries WHERE id = ?").get(id);
+            return row?.invoice_id === null;
+        });
+        if (pendientes.length) {
+            console.log((0, index_js_1.tr) `\n${pendientes.length} imputaciones aprobadas o ajustadas repiten horas de otra rama. Revísalas antes de facturar:`);
+            for (const id of pendientes.slice(0, 10))
+                console.log(`  ${id}`);
+        }
+        if (unassigned > 0) {
+            console.log((0, index_js_1.tr) `\nHay ${unassigned} bloques sin proyecto asignado. Regístralos con:`);
             console.log((0, index_js_1.tr) `  estela project add --id <id> --client <id> --name <nombre> --repo <ruta>`);
         }
     }
@@ -2472,7 +2454,9 @@ function cmdInvoice(args, dbPath) {
         const cutoffAt = new Date(`${cutoffRaw}T23:59:59Z`);
         if (Number.isNaN(cutoffAt.getTime()))
             throw new UserError((0, index_js_1.tr) `Fecha inválida: ${cutoffRaw}`);
-        const dryRun = args.flags["dry-run"] === true;
+        // Si va seguida de otra palabra, parseArgs la toma como su valor. Una opción
+        // que protege no puede dejar de hacerlo por eso: se emitía el informe de verdad.
+        const dryRun = "dry-run" in args.flags;
         const number = str(args, "number") ?? store.nextInvoiceNumber(db, "INF");
         const fx = str(args, "fx");
         const entries = store.getTimeEntries(db, projectId);
@@ -2527,6 +2511,7 @@ function cmdInvoice(args, dbPath) {
                     },
                 } : {}),
                 ...(invoice.aiAmortized ? { amortizedAiCost: invoice.aiAmortized } : {}),
+                withAmounts: !("no-amounts" in args.flags),
             }));
             (0, node_fs_1.writeFileSync)(pdfPath, pdf);
             console.log((0, index_js_1.tr) `\nPDF: ${pdfPath}  (${(pdf.length / 1024).toFixed(1)} KB, ${invoice.lines.length} conceptos)`);
@@ -2572,6 +2557,12 @@ async function main() {
         console.log(VERSION);
         return;
     }
+    // Igual de pronto: sin esto, "estela import --help" ignoraba la opción y
+    // ejecutaba el comando de verdad. Pedir ayuda no puede tocar los datos.
+    if ("help" in args.flags || argv.includes("-h")) {
+        console.log(helpText());
+        return;
+    }
     (0, client_js_1.setClientVersion)(VERSION);
     const dbPath = str(args, "db") ?? schema_js_1.DEFAULT_DB_PATH;
     // `estela unpublish <panel>` lleva el panel suelto, sin flag: no es un subcomando.

package/dist/db/store.d.ts

@@ -135,6 +135,12 @@ export declare class AdjustError extends Error {
 export declare function adjustEntrySeconds(db: DatabaseSync, id: string, seconds: number, reason: string, at?: Date): void;
 /** Quita el ajuste y devuelve el bloque a lo que mide el agente. */
 export declare function clearEntryAdjustment(db: DatabaseSync, id: string, at?: Date): void;
+/**
+ * Retira imputaciones repetidas (ver `findDuplicates` en billing/assign.ts).
+ * Repite aquí las condiciones de `saveTimeEntry`: lo escrito a mano, lo aprobado,
+ * lo facturado y lo ajustado no se borra desde ningún camino.
+ */
+export declare function deleteStaleEntries(db: DatabaseSync, ids: readonly string[]): number;
 export declare function saveTimeEntry(db: DatabaseSync, entry: Omit<TimeEntry, "id"> & {
     id?: string;
 }, at?: Date): string;

package/dist/db/store.js

@@ -30,6 +30,7 @@ exports.saveCommits = saveCommits;
 exports.logScan = logScan;
 exports.adjustEntrySeconds = adjustEntrySeconds;
 exports.clearEntryAdjustment = clearEntryAdjustment;
+exports.deleteStaleEntries = deleteStaleEntries;
 exports.saveTimeEntry = saveTimeEntry;
 exports.setEntryWorkItems = setEntryWorkItems;
 exports.getTimeEntries = getTimeEntries;
@@ -509,6 +510,21 @@ function clearEntryAdjustment(db, id, at = new Date()) {
     WHERE id = ?
   `).run(iso(at), id);
 }
+/**
+ * Retira imputaciones repetidas (ver `findDuplicates` en billing/assign.ts).
+ * Repite aquí las condiciones de `saveTimeEntry`: lo escrito a mano, lo aprobado,
+ * lo facturado y lo ajustado no se borra desde ningún camino.
+ */
+function deleteStaleEntries(db, ids) {
+    const stmt = db.prepare(`
+    DELETE FROM time_entries WHERE id = ?
+      AND source IN ('agent', 'commit') AND invoice_id IS NULL
+      AND approved = 0 AND adjust_reason IS NULL`);
+    let deleted = 0;
+    for (const id of ids)
+        deleted += Number(stmt.run(id).changes);
+    return deleted;
+}
 function saveTimeEntry(db, entry, at = new Date()) {
     const id = entry.id ?? `te_${(0, node_crypto_1.randomUUID)()}`;
     db.prepare(`
@@ -560,8 +576,14 @@ function saveTimeEntry(db, entry, at = new Date()) {
     -- Y lo ya facturado es historia. Sin esta condición, un reimport
     -- recalculaba filas que respaldan una factura emitida y dejaba el panel
     -- diciendo una cosa y el PDF del cliente otra.
+    --
+    -- Lo aprobado, igual: aprobar un día es dar por buena esa cifra, y a
+    -- menudo ya se ha compartido (un panel publicado, un avance al cliente).
+    -- Un cambio en cómo se calculan las horas se aplica a lo que viene, no
+    -- reescribe lo que ya se dio por bueno. Para recalcularlo, se desaprueba.
     WHERE time_entries.source IN ('agent', 'commit')
       AND time_entries.invoice_id IS NULL
+      AND time_entries.approved = 0
   `).run(id, entry.projectId, iso(entry.startedAt), (0, shared_1.localDate)(entry.startedAt), iso(entry.endedAt), entry.seconds, entry.description, entry.billable ? 1 : 0, entry.invoiceId, entry.aiCost.microUsd, entry.agentSeconds, entry.commitHashes.join(","), entry.agents.join(","), entry.source, entry.kind, entry.branch, (entry.workItems ?? []).join(","), iso(at));
     return id;
 }

package/dist/export/invoice-pdf.d.ts

@@ -15,6 +15,8 @@ export interface InvoicePdfOptions {
     };
     /** Coste real de IA imputado al periodo (cuota amortizada). Solo informativo. */
     readonly amortizedAiCost?: Money;
+    /** Sin tarifa ni importes: solo las horas. Por defecto, con importes. */
+    readonly withAmounts?: boolean;
     readonly footer?: string;
 }
 export declare function invoiceToPdf(invoice: Invoice, client: Client, project: Project, options?: InvoicePdfOptions): Buffer;

package/dist/export/invoice-pdf.js

@@ -15,6 +15,9 @@ function invoiceToPdf(invoice, client, project, options = {}) {
     // Los importes van con el locale del documento, no con el de la terminal: el
     // cliente lee "€1.254,79" o "€1,254.79" según SU idioma.
     const money = (m) => (0, shared_1.formatMoney)(m, (0, index_js_1.moneyLocale)((0, index_js_1.getLang)()));
+    const withAmounts = options.withAmounts !== false;
+    // Sin tarifa ni importe, el tiempo pasa a ser la última columna.
+    const colTime = withAmounts ? COL_TIME : COL_AMOUNT;
     let y = M;
     // --- Cabecera -------------------------------------------------------------
     doc.text(M, y + 4, (0, index_js_1.tr) `INFORME DE HORAS`, "Helvetica-Bold", 20);
@@ -57,20 +60,22 @@ function invoiceToPdf(invoice, client, project, options = {}) {
     // --- Cabecera de tabla ----------------------------------------------------
     const header = () => {
         doc.text(M, y, (0, index_js_1.tr) `CONCEPTO`, "Helvetica-Bold", 8, 0.45);
-        doc.textRight(COL_TIME, y, (0, index_js_1.tr) `TIEMPO`, "Helvetica-Bold", 8, 0.45);
-        doc.textRight(COL_RATE, y, (0, index_js_1.tr) `TARIFA`, "Helvetica-Bold", 8, 0.45);
-        doc.textRight(COL_AMOUNT, y, (0, index_js_1.tr) `IMPORTE`, "Helvetica-Bold", 8, 0.45);
+        doc.textRight(colTime, y, (0, index_js_1.tr) `TIEMPO`, "Helvetica-Bold", 8, 0.45);
+        if (withAmounts) {
+            doc.textRight(COL_RATE, y, (0, index_js_1.tr) `TARIFA`, "Helvetica-Bold", 8, 0.45);
+            doc.textRight(COL_AMOUNT, y, (0, index_js_1.tr) `IMPORTE`, "Helvetica-Bold", 8, 0.45);
+        }
         y += 7;
         doc.line(M, y, COL_AMOUNT, y, 0.8, 0.3);
         y += 15;
     };
     header();
     // --- Conceptos ------------------------------------------------------------
-    // La columna TIEMPO se alinea a la derecha en COL_TIME, así que su texto crece
+    // La columna TIEMPO se alinea a la derecha en colTime, así que su texto crece
     // hacia la izquierda. Hay que restar el más ancho de esos textos, no un hueco
     // fijo, o la descripción se le mete encima.
     const widestTime = invoice.lines.reduce((max, l) => Math.max(max, pdf_js_1.PdfDocument.measure((0, shared_1.formatDuration)(l.seconds), "Helvetica", 10)), 0);
-    const maxDescWidth = COL_TIME - M - widestTime - 14;
+    const maxDescWidth = colTime - M - widestTime - 14;
     for (const line of invoice.lines) {
         if (y > BOTTOM - 60) {
             doc.newPage();
@@ -79,9 +84,11 @@ function invoiceToPdf(invoice, client, project, options = {}) {
         }
         const text = pdf_js_1.PdfDocument.truncate(line.description, "Helvetica", 10, maxDescWidth);
         doc.text(M, y, text, "Helvetica", 10);
-        doc.textRight(COL_TIME, y, (0, shared_1.formatDuration)(line.seconds), "Helvetica", 10, 0.2);
-        doc.textRight(COL_RATE, y, `${money(line.hourlyRate)}/h`, "Helvetica", 10, 0.4);
-        doc.textRight(COL_AMOUNT, y, money(line.amount), "Helvetica", 10);
+        doc.textRight(colTime, y, (0, shared_1.formatDuration)(line.seconds), "Helvetica", 10, 0.2);
+        if (withAmounts) {
+            doc.textRight(COL_RATE, y, `${money(line.hourlyRate)}/h`, "Helvetica", 10, 0.4);
+            doc.textRight(COL_AMOUNT, y, money(line.amount), "Helvetica", 10);
+        }
         y += 9;
         doc.line(M, y, COL_AMOUNT, y, 0.4, 0.9);
         y += 12;
@@ -95,19 +102,22 @@ function invoiceToPdf(invoice, client, project, options = {}) {
     doc.line(M, y, COL_AMOUNT, y, 0.8, 0.3);
     y += 18;
     doc.text(M, y, invoice.lines.length === 1 ? (0, index_js_1.tr) `1 concepto` : (0, index_js_1.tr) `${invoice.lines.length} conceptos`, "Helvetica", 9, 0.4);
-    doc.textRight(COL_TIME, y, (0, shared_1.formatDuration)(invoice.totalSeconds), "Helvetica-Bold", 10);
-    doc.textRight(COL_AMOUNT, y, money(invoice.subtotal), "Helvetica", 10);
+    doc.textRight(colTime, y, (0, shared_1.formatDuration)(invoice.totalSeconds), "Helvetica-Bold", 10);
+    if (withAmounts)
+        doc.textRight(COL_AMOUNT, y, money(invoice.subtotal), "Helvetica", 10);
     y += 18;
-    if (invoice.aiCostBilled) {
+    if (withAmounts && invoice.aiCostBilled) {
         doc.text(M, y, (0, index_js_1.tr) `Coste de IA repercutido (1 USD = ${invoice.usdFxRate} ${invoice.currency})`, "Helvetica", 9, 0.4);
         doc.textRight(COL_AMOUNT, y, money(invoice.aiCostBilled), "Helvetica", 10);
         y += 18;
     }
-    y += 4;
-    doc.rect(rightCol - 20, y - 14, COL_AMOUNT - rightCol + 20, 32, 0.94);
-    doc.text(rightCol - 8, y + 2, (0, index_js_1.tr) `VALOR`, "Helvetica-Bold", 11);
-    doc.textRight(COL_AMOUNT - 8, y + 3, money(invoice.total), "Helvetica-Bold", 14);
-    y += 46;
+    if (withAmounts) {
+        y += 4;
+        doc.rect(rightCol - 20, y - 14, COL_AMOUNT - rightCol + 20, 32, 0.94);
+        doc.text(rightCol - 8, y + 2, (0, index_js_1.tr) `VALOR`, "Helvetica-Bold", 11);
+        doc.textRight(COL_AMOUNT - 8, y + 3, money(invoice.total), "Helvetica-Bold", 14);
+        y += 46;
+    }
     // Aquí había una "NOTA INTERNA (no se comparte)" con el consumo de IA del
     // periodo. Se quitó: esa frase era un deseo, no un mecanismo. Este PDF es
     // justamente el que se adjunta a la factura del cliente, así que en cuanto

package/dist/i18n/en.js

@@ -540,16 +540,12 @@ exports.EN = {
     "{0} turnos de modelos sin precio de lista cuentan como 0 en ese %.": "{0} turns from models without a list price count as 0 in that %.",
     "La ventana de 5 h es la que da Claude Code; el reparto solo incluye lo usado en esta máquina.": "The 5-hour window is the one Claude Code reports; the split only includes what was used on this machine.",
     // ── import: horas de subcarpetas y worktrees ──
-    "\nEstela ahora reconoce las sesiones en subcarpetas y worktrees de un repositorio.": "\nEstela now recognizes sessions in a repository's subfolders and worktrees.",
-    "Estas horas no estaban imputadas y se sumarían a su proyecto:\n": "These hours weren't assigned and would be added to their project:\n",
-    "\n  Nada de lo ya imputado cambia de proyecto, y los días aprobados no se tocan.": "\n  Nothing already assigned changes project, and approved days aren't touched.",
     "\n  Sin tocar, porque ese día ya está aprobado o facturado:": "\n  Left alone, because that day is already approved or invoiced:",
     "    {0} · {1}: {2} recuperables. Revísalo con: estela entries --project {3}": "    {0} · {1}: {2} recoverable. Review it with: estela entries --project {3}",
-    "¿Imputar estas horas? [s/N] ": "Assign these hours? [y/N] ",
-    "  No se ha tocado nada. Cuando quieras: estela import --yes\n": "  Nothing was changed. Whenever you want: estela import --yes\n",
+    "  {0} imputaciones retiradas: sus horas ya estaban en otra rama del mismo día": "  {0} entries removed: their hours were already in another branch that day",
+    "\n{0} imputaciones aprobadas o ajustadas repiten horas de otra rama. Revísalas antes de facturar:": "\n{0} approved or adjusted entries repeat hours from another branch. Review them before invoicing:",
     "  {0} recuperadas de sesiones en subcarpetas y worktrees": "  {0} recovered from sessions in subfolders and worktrees",
     "{0} (sin proyecto)": "{0} (no project)",
-    "\n{0} de esos bloques son de subcarpetas o worktrees de un proyecto: estela import --yes los imputa.": "\n{0} of those blocks are from a project's subfolders or worktrees: estela import --yes assigns them.",
     // ── publish: resumen antes de subir, y unpublish ──
     "No se ha publicado nada. Sin terminal no se puede confirmar: añade --yes para publicar.": "Nothing was published. Without a terminal there's no way to confirm: add --yes to publish.",
     "¿Publicar? [s/N] ": "Publish? [y/N] ",

package/dist/server.js

@@ -128,7 +128,11 @@ async function importOnce(dbPath) {
                 continue;
             store.saveCommits(db, await (0, git_js_1.readCommits)(root, {}));
         }
-        const mine = await (0, identity_js_1.myEmailsByRepo)(db, repos);
+        // 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.
+        const known = (0, assign_js_1.knownTurns)(db, turns);
+        const mine = await (0, identity_js_1.myEmailsByRepo)(db, new Set([...repos, ...store.allProjectRepoPaths(db),
+            ...known.flatMap((t) => t.repoPath ?? [])]));
         const allRepoCommits = db.prepare("SELECT * FROM commits").all()
             .map((r) => ({
             repoPath: r["repo_path"], hash: r["hash"],
@@ -141,18 +145,15 @@ async function importOnce(dbPath) {
         let imputed = 0;
         // Solo tus commits producen horas tuyas.
         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);
-        // 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 });
+        const fromAgents = (0, sessionize_js_1.attachCommits)((0, sessionize_js_1.sessionize)(known), commits);
+        const fromCommits = (0, assign_js_1.commitOnlyBlocks)(db, commits, fromAgents);
+        // Las mismas reglas que `estela import` (billing/assign.ts).
+        const plan = (0, assign_js_1.planEntries)(db, [...fromAgents, ...fromCommits]);
         for (const { entry } of plan.entries) {
             store.saveTimeEntry(db, entry);
             imputed++;
         }
+        store.deleteStaleEntries(db, plan.stale);
         return imputed;
     }
     finally {
@@ -581,11 +582,11 @@ async function api(req, res, url, dbPath) {
         // recalcular nada: el mismo papel que salió el día que se emitió.
         const reimpresion = /^\/api\/invoices\/([A-Za-z0-9-]+)\/pdf$/.exec(path);
         if (reimpresion && req.method === "GET") {
-            return sendStoredInvoicePdf(db, res, reimpresion[1], url.searchParams.get("author") ?? "");
+            return sendStoredInvoicePdf(db, res, reimpresion[1], url.searchParams.get("author") ?? "", url.searchParams.get("amounts") !== "0");
         }
         if (path === "/api/invoice" && req.method === "POST") {
             const body = await readJson(req);
-            return sendInvoice(db, res, String(body["projectId"] ?? ""), String(body["cutoff"] ?? ""), typeof body["author"] === "string" ? body["author"] : "");
+            return sendInvoice(db, res, String(body["projectId"] ?? ""), String(body["cutoff"] ?? ""), typeof body["author"] === "string" ? body["author"] : "", body["withAmounts"] !== false);
         }
         if (path === "/api/entry" && req.method === "POST") {
             const body = await readJson(req);
@@ -1368,7 +1369,7 @@ function sendReport(db, res, projectId, from, to, withAmounts, author) {
  * congeló al emitirla. Es lo que hace que el papel de agosto siga siendo el
  * papel de agosto cuando se pide en diciembre.
  */
-function sendStoredInvoicePdf(db, res, number, author) {
+function sendStoredInvoicePdf(db, res, number, author, withAmounts) {
     const invoice = store.getInvoice(db, number);
     if (!invoice)
         return json(res, 404, { error: "Esa factura no existe." });
@@ -1382,15 +1383,20 @@ function sendStoredInvoicePdf(db, res, number, author) {
     const pdf = (0, index_js_2.withLang)((0, index_js_2.documentLang)({ clientLanguage: client.language }), () => (0, invoice_pdf_js_1.invoiceToPdf)(invoice, client, project, {
         ...(author ? { issuer: { name: author } } : {}),
         ...(invoice.aiAmortized ? { amortizedAiCost: invoice.aiAmortized } : {}),
+        withAmounts,
     }));
     res.writeHead(200, {
         "Content-Type": "application/pdf",
-        "Content-Disposition": `attachment; filename="${invoice.number}.pdf"`,
+        "Content-Disposition": `attachment; filename="${invoicePdfName(invoice.number, withAmounts)}"`,
         "Content-Length": pdf.length,
     });
     res.end(pdf);
 }
-function sendInvoice(db, res, projectId, cutoffRaw, author) {
+/** Con otro nombre, para no confundir al guardarlos juntos cuál lleva importes. */
+function invoicePdfName(number, withAmounts) {
+    return withAmounts ? `${number}.pdf` : `${number}-sin-importes.pdf`;
+}
+function sendInvoice(db, res, projectId, cutoffRaw, author, withAmounts) {
     const project = store.getProject(db, projectId);
     if (!project)
         return json(res, 404, { error: (0, index_js_2.tr) `No existe el proyecto "${projectId}".` });
@@ -1429,8 +1435,9 @@ function sendInvoice(db, res, projectId, cutoffRaw, author) {
     const pdf = (0, index_js_2.withLang)((0, index_js_2.documentLang)({ clientLanguage: client.language }), () => (0, invoice_pdf_js_1.invoiceToPdf)(invoice, client, project, {
         ...(author ? { issuer: { name: author } } : {}),
         ...(invoice.aiAmortized ? { amortizedAiCost: invoice.aiAmortized } : {}),
+        withAmounts,
     }));
-    const filename = `${invoice.number}.pdf`;
+    const filename = invoicePdfName(invoice.number, withAmounts);
     res.writeHead(200, {
         "Content-Type": "application/pdf",
         "Content-Disposition": `attachment; filename="${filename}"`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "estela",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "Time tracking you never fill in: rebuilds your billable hours from Claude Code, Codex and GitHub Copilot sessions and your Git history, and splits what the AI cost per project.",
   "keywords": [
     "time-tracking",

package/web/app.css

@@ -900,6 +900,7 @@ main.wide { max-width: 1180px; }
    subraye y que se centre como el resto. */
 .invoice-dl{flex:0 0 auto;text-decoration:none;display:inline-flex;
   align-items:center;padding:9px 18px;font-size:.9rem}
+.invoice-dls{flex:0 0 auto;display:flex;gap:8px;flex-wrap:wrap}
 @media(max-width:620px){
   .invoice-row{flex-wrap:wrap}
   .invoice-main{flex:1 1 100%}

package/web/app.js

@@ -1469,8 +1469,12 @@ function renderReports() {
           <div class="report-hours">${fmtDuration(f.totalSeconds)}</div>
           <div class="report-amount">${importe}</div>
         </div>
-        <a class="btn-main invoice-dl" download
-           href="/api/invoices/${encodeURIComponent(f.number)}/pdf">${tr("invoices.download")}</a>
+        <div class="invoice-dls">
+          <a class="btn-main invoice-dl" download
+             href="/api/invoices/${encodeURIComponent(f.number)}/pdf">${tr("invoices.withAmounts")}</a>
+          <a class="chip invoice-dl" download
+             href="/api/invoices/${encodeURIComponent(f.number)}/pdf?amounts=0">${tr("invoices.withoutAmounts")}</a>
+        </div>
       </div>`;
     }).join("") + "</div>");
   }
@@ -1535,6 +1539,7 @@ function renderReports() {
       const projectId = form.dataset.project;
       const cutoff = form.querySelector(".rep-to").value;
       const author = form.querySelector(".rep-author").value;
+      const withAmounts = form.querySelector(".rep-amounts").checked;
       const row = (state.reportsOverview?.unbilled || []).find((r) => r.projectId === projectId);
       const proyecto = row ? row.projectName : projectId;
 
@@ -1542,7 +1547,7 @@ function renderReports() {
 
       btn.disabled = true;
       try {
-        await cutoffAndInvoice(projectId, cutoff, author);
+        await cutoffAndInvoice(projectId, cutoff, author, withAmounts);
         toast(tr("toast.invoiced"));
         await loadReports();
       } catch (error) {
@@ -1561,11 +1566,11 @@ function renderReports() {
  * con un enlace sintético — el mismo patrón que usa cualquier app sin
  * framework para esto.
  */
-async function cutoffAndInvoice(projectId, cutoff, author) {
+async function cutoffAndInvoice(projectId, cutoff, author, withAmounts) {
   const res = await fetch("/api/invoice", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ projectId, cutoff, author }),
+    body: JSON.stringify({ projectId, cutoff, author, withAmounts }),
   });
   if (!res.ok) {
     let message = `Error ${res.status}`;

package/web/i18n.js

@@ -308,9 +308,10 @@
       "reports.allbilled.title": "Todo facturado",
       "reports.allbilled.body": "No queda nada pendiente en este periodo. Lo ya emitido está abajo, y se puede volver a descargar.",
       "invoices.title": "Ya facturado",
-      "invoices.note": "Se reimprime tal y como se emitió: los importes y el reparto de IA quedaron congelados ese día.",
+      "invoices.note": "Se reimprime tal y como se emitió, con o sin importes: las cifras quedaron congeladas ese día.",
       "invoices.upto": "Hasta el {date}",
-      "invoices.download": "Descargar",
+      "invoices.withAmounts": "Con importes",
+      "invoices.withoutAmounts": "Sin importes",
       "reports.noMatch": "Ningún proyecto coincide con «{q}».",
       "reports.client": "{client} · {blocks} · todo lo pendiente desde {date}",
       "reports.from": "Desde",
@@ -613,9 +614,10 @@
       "reports.allbilled.title": "All invoiced",
       "reports.allbilled.body": "Nothing pending in this period. What you already issued is below, and can be downloaded again.",
       "invoices.title": "Already invoiced",
-      "invoices.note": "Reprinted exactly as issued: amounts and the AI split were frozen that day.",
+      "invoices.note": "Reprinted exactly as issued, with or without amounts: the figures were frozen that day.",
       "invoices.upto": "Up to {date}",
-      "invoices.download": "Download",
+      "invoices.withAmounts": "With amounts",
+      "invoices.withoutAmounts": "Without amounts",
       "reports.noMatch": "No project matches “{q}”.",
       "reports.client": "{client} · {blocks} · everything pending since {date}",
       "reports.from": "From",