estela 0.3.2 → 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 { CommitRecord, 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,6 +41,10 @@ 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;
 /**
@@ -47,9 +55,23 @@ export declare function entryId(projectId: string, day: string, branch: string |
  * 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[];
-export declare function planEntries(db: DatabaseSync, raw: readonly WorkBlock[], options: {
-    readonly recover: boolean;
-}): AssignmentPlan;
+/**
+ * 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

@@ -35,6 +35,7 @@ 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"));
@@ -43,8 +44,10 @@ 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 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
@@ -54,12 +57,105 @@ function entryId(projectId, day, branch) {
  * 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")));
-    return (0, sessionize_js_1.withoutOverlap)((0, sessionize_js_1.sessionizeCommits)(commits), [...agentBlocks, ...saved]);
+    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()];
 }
-function planEntries(db, raw, options) {
+/**
+ * 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) => {
@@ -68,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 ?? "";
@@ -105,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

@@ -118,6 +118,9 @@ export declare function sessionizeCommits(commits: readonly CommitRecord[], opti
  * 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,
@@ -295,11 +296,15 @@ function sessionizeCommits(commits, options = {}) {
  * 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) => sameRepo(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)

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>]
@@ -307,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>]
@@ -780,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)
@@ -890,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`);
         }
@@ -905,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 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>`);
         }
     }
@@ -2476,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);
@@ -2531,7 +2511,7 @@ function cmdInvoice(args, dbPath) {
                     },
                 } : {}),
                 ...(invoice.aiAmortized ? { amortizedAiCost: invoice.aiAmortized } : {}),
-                withAmounts: args.flags["no-amounts"] !== true,
+                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)`);
@@ -2577,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(`

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 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). 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 });
+        // 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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "estela",
-  "version": "0.3.2",
+  "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",