chocolatito-code 1.6.14 → 1.6.15

package/README.md

@@ -122,6 +122,12 @@ JavaScript de Node. Por el navegador no hace falta instalar nada.
 terminal queda de monitor. Es a propósito — dos entradas peleándose por el mismo teclado
 es de donde salen los cuelgues raros.
 
+**Desde fuera de tu red**, con un túnel: `cloudflared tunnel --url http://127.0.0.1:4700` y
+después `chocolatito --servir --tunel <el enlace que te dé>`. Esa bandera autoriza **ese**
+dominio y solo ese; sin ella el servidor lo rechaza, que es lo que tiene que hacer con un
+nombre de dominio cualquiera. Ojo: ese enlace sale a internet y lo único que lo protege es
+el token. Ciérralo al acabar.
+
 **Lo que NO hace, a propósito:** no hay HTTPS ni túnel propio. Para entrar desde fuera de
 tu casa, usa Tailscale o `cloudflared`, que ya existen y están auditados. Un túnel casero
 es la parte fácil de una responsabilidad muy grande.
@@ -346,7 +352,20 @@ No hace falta esperar a que termine. Lo que escribas durante una generación apa
 el spinner y, al pulsar Enter, queda en cola: el agente acaba su turno y lo toma como
 siguiente orden, sin que tengas que volver a teclearlo.
 
-`Esc` pausa el turno en curso. `Ctrl+C` una vez interrumpe; dos veces cierra la sesión.
+`Esc` pausa el turno en curso. `Ctrl+C` una vez interrumpe; dos veces cierra la sesión.
+
+---
+
+## ⏪ Volver atrás (`/undo` y `/rewind`)
+
+Antes de tocar un archivo, Chocolatito guarda una copia. `/undo` deshace el último turno y
+`/rewind` enseña la lista para elegir hasta dónde volver.
+
+**Y sobrevive a cerrar la sesión**, que es cuando de verdad hace falta: uno no deshace treinta
+segundos después, sino al día siguiente, al abrir el proyecto y ver que falta algo. Se guarda
+en `.chocolatito/cambios/` de tu proyecto, con los últimos 20 turnos, y con un `.gitignore`
+dentro para que no acabe en tu repositorio. Los archivos de más de 25 MB no se copian: se te
+avisa en el momento, en vez de prometerte una vuelta atrás que no existe.
 
 ---
 

package/dist/agent/historialDeCambios.d.ts

@@ -0,0 +1,77 @@
+import type { Checkpoint, FileSnapshot } from "./undoManager.js";
+/**
+ * EL HISTORIAL DE CAMBIOS, EN DISCO
+ *
+ * DE DONDE SALE
+ *
+ * `/undo` estaba entero en memoria: `private checkpoints: Checkpoint[] = []`.
+ * O sea que la red de seguridad de un agente que edita y borra archivos solo
+ * duraba lo que durase la ventana del terminal. Cierras, o se cierra sola, y ya
+ * no hay vuelta atras de nada de lo que hizo.
+ *
+ * Y es al reves de como se usa: el momento en que uno quiere deshacer no es
+ * treinta segundos despues -ahi todavia estas mirando-, es al dia siguiente,
+ * cuando abres el proyecto y ves que falta algo.
+ *
+ * DONDE SE GUARDA
+ *
+ * En `<proyecto>/.chocolatito/cambios/`, al lado de la memoria del proyecto y
+ * no en el home: lo que se guarda son archivos DE ESE proyecto, y si el
+ * proyecto se borra o se mueve, su historial se va con el. Mezclarlos todos en
+ * el home dejaria copias de codigo de clientes distintos en el mismo cajon.
+ *
+ * QUE SE GUARDA, Y QUE NO
+ *
+ * Un turno es una carpeta: `meta.json` con la lista de rutas y un archivo por
+ * cada copia, numerado. Los bytes se guardan CRUDOS, sin codificar: por aqui
+ * pasan imagenes y videos, y un mp4 convertido a texto vuelve corrupto -ya pasó
+ * una vez con /undo y utf-8-.
+ *
+ * Con dos topes, porque esto crece en el disco de otro:
+ *
+ *  - TAMANO POR ARCHIVO. Copiar un video de 500 MB en cada turno que lo toque
+ *    llena el disco sin que nadie lo pida. Por encima del tope consta como
+ *    "sin copia", que es exactamente lo que es, y se avisa en el momento.
+ *  - CUANTOS TURNOS SE GUARDAN. Los mas viejos se tiran enteros. Veinte es lo
+ *    que cabe en la cabeza de alguien que intenta acordarse de que hizo ayer.
+ */
+/** Por encima de esto no se copia: se anota que no hay copia y se dice. */
+export declare const TOPE_POR_ARCHIVO: number;
+/** Turnos que se conservan. Mas atras, nadie se acuerda de que paso. */
+export declare const TURNOS_GUARDADOS = 20;
+export declare const CARPETA: string;
+export interface TurnoGuardado {
+    id: string;
+    /** ISO, no la hora local: esto se lee al dia siguiente y desde otra zona. */
+    cuando: string;
+    descripcion: string;
+    archivos: Array<{
+        ruta: string;
+        tipo: FileSnapshot["kind"];
+        /** Nombre del blob dentro de la carpeta del turno, si hay copia. */
+        copia?: string;
+        motivo?: string;
+        bytes?: number;
+    }>;
+}
+export declare function carpetaDeCambios(cwd: string): string;
+/**
+ * Guarda un turno. Devuelve lo que NO se pudo copiar, para poder decirlo.
+ *
+ * No lanza nunca: si el disco esta lleno o la carpeta es de solo lectura, el
+ * turno del usuario no se puede caer por culpa del historial.
+ */
+export declare function guardarTurno(cwd: string, punto: Checkpoint): {
+    guardado: boolean;
+    sinCopia: string[];
+};
+/** Los turnos guardados, del mas viejo al mas nuevo. Solo las fichas. */
+export declare function turnosGuardados(cwd: string): TurnoGuardado[];
+/** Recupera un turno con sus bytes, listo para que UndoManager lo deshaga. */
+export declare function leerTurno(cwd: string, id: string): Checkpoint | null;
+/** Un turno ya deshecho no tiene por que quedarse ocupando sitio. */
+export declare function olvidarTurno(cwd: string, id: string): void;
+/** Tira los turnos mas viejos que sobren del tope. */
+export declare function podar(cwd: string, tope?: number): void;
+/** Lo que ocupa el historial, para poder decirlo sin que nadie lo mida a mano. */
+export declare function bytesOcupados(cwd: string): number;

package/dist/agent/historialDeCambios.js

@@ -0,0 +1,220 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * EL HISTORIAL DE CAMBIOS, EN DISCO
+ *
+ * DE DONDE SALE
+ *
+ * `/undo` estaba entero en memoria: `private checkpoints: Checkpoint[] = []`.
+ * O sea que la red de seguridad de un agente que edita y borra archivos solo
+ * duraba lo que durase la ventana del terminal. Cierras, o se cierra sola, y ya
+ * no hay vuelta atras de nada de lo que hizo.
+ *
+ * Y es al reves de como se usa: el momento en que uno quiere deshacer no es
+ * treinta segundos despues -ahi todavia estas mirando-, es al dia siguiente,
+ * cuando abres el proyecto y ves que falta algo.
+ *
+ * DONDE SE GUARDA
+ *
+ * En `<proyecto>/.chocolatito/cambios/`, al lado de la memoria del proyecto y
+ * no en el home: lo que se guarda son archivos DE ESE proyecto, y si el
+ * proyecto se borra o se mueve, su historial se va con el. Mezclarlos todos en
+ * el home dejaria copias de codigo de clientes distintos en el mismo cajon.
+ *
+ * QUE SE GUARDA, Y QUE NO
+ *
+ * Un turno es una carpeta: `meta.json` con la lista de rutas y un archivo por
+ * cada copia, numerado. Los bytes se guardan CRUDOS, sin codificar: por aqui
+ * pasan imagenes y videos, y un mp4 convertido a texto vuelve corrupto -ya pasó
+ * una vez con /undo y utf-8-.
+ *
+ * Con dos topes, porque esto crece en el disco de otro:
+ *
+ *  - TAMANO POR ARCHIVO. Copiar un video de 500 MB en cada turno que lo toque
+ *    llena el disco sin que nadie lo pida. Por encima del tope consta como
+ *    "sin copia", que es exactamente lo que es, y se avisa en el momento.
+ *  - CUANTOS TURNOS SE GUARDAN. Los mas viejos se tiran enteros. Veinte es lo
+ *    que cabe en la cabeza de alguien que intenta acordarse de que hizo ayer.
+ */
+/** Por encima de esto no se copia: se anota que no hay copia y se dice. */
+export const TOPE_POR_ARCHIVO = 25 * 1024 * 1024;
+/** Turnos que se conservan. Mas atras, nadie se acuerda de que paso. */
+export const TURNOS_GUARDADOS = 20;
+export const CARPETA = path.join(".chocolatito", "cambios");
+/**
+ * Que esto no acabe en el repositorio de nadie.
+ *
+ * Son copias de archivos del proyecto: commitearlas seria subir el trabajo dos
+ * veces, y en un repositorio compartido, ensenarle a todo el equipo lo que
+ * habia antes de cada cambio.
+ *
+ * Se pone un .gitignore DENTRO de la carpeta, con un asterisco, en vez de tocar
+ * el .gitignore del usuario: editar un archivo suyo para instalar nuestra basura
+ * es justo lo que no se hace. Y va solo en cambios/, no en .chocolatito/ entero:
+ * la memoria del proyecto de al lado a lo mejor si la quiere commitear.
+ */
+function asegurarQueGitLoIgnora(cwd) {
+    const marca = path.join(carpetaDeCambios(cwd), ".gitignore");
+    try {
+        if (!fs.existsSync(marca))
+            fs.writeFileSync(marca, "*" + String.fromCharCode(10), "utf-8");
+    }
+    catch { }
+}
+export function carpetaDeCambios(cwd) {
+    return path.join(cwd, CARPETA);
+}
+function carpetaDelTurno(cwd, id) {
+    return path.join(carpetaDeCambios(cwd), id);
+}
+/** Un nombre de archivo que no puede salirse de su carpeta ni chocar. */
+function nombreDeCopia(indice, ruta) {
+    const ext = path.extname(ruta).replace(/[^\w.]/g, "").slice(0, 10);
+    return `${String(indice).padStart(3, "0")}${ext}`;
+}
+/**
+ * Guarda un turno. Devuelve lo que NO se pudo copiar, para poder decirlo.
+ *
+ * No lanza nunca: si el disco esta lleno o la carpeta es de solo lectura, el
+ * turno del usuario no se puede caer por culpa del historial.
+ */
+export function guardarTurno(cwd, punto) {
+    const sinCopia = [];
+    try {
+        const dir = carpetaDelTurno(cwd, punto.id);
+        fs.mkdirSync(dir, { recursive: true });
+        asegurarQueGitLoIgnora(cwd);
+        const meta = {
+            id: punto.id,
+            cuando: new Date().toISOString(),
+            descripcion: punto.description,
+            archivos: [],
+        };
+        let indice = 0;
+        for (const foto of punto.snapshots) {
+            indice++;
+            if (foto.kind === "absent") {
+                meta.archivos.push({ ruta: foto.filePath, tipo: "absent" });
+                continue;
+            }
+            if (foto.kind === "unrestorable") {
+                meta.archivos.push({ ruta: foto.filePath, tipo: "unrestorable", motivo: foto.reason });
+                sinCopia.push(`${path.basename(foto.filePath)}: ${foto.reason}`);
+                continue;
+            }
+            if (foto.previousContent.length > TOPE_POR_ARCHIVO) {
+                const motivo = `ocupa ${Math.round(foto.previousContent.length / 1024 / 1024)} MB y el historial no guarda archivos tan grandes`;
+                meta.archivos.push({ ruta: foto.filePath, tipo: "unrestorable", motivo });
+                sinCopia.push(`${path.basename(foto.filePath)}: ${motivo}`);
+                continue;
+            }
+            const copia = nombreDeCopia(indice, foto.filePath);
+            fs.writeFileSync(path.join(dir, copia), foto.previousContent);
+            meta.archivos.push({
+                ruta: foto.filePath,
+                tipo: "file",
+                copia,
+                bytes: foto.previousContent.length,
+            });
+        }
+        fs.writeFileSync(path.join(dir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+        podar(cwd);
+        return { guardado: true, sinCopia };
+    }
+    catch {
+        return { guardado: false, sinCopia };
+    }
+}
+/** Los turnos guardados, del mas viejo al mas nuevo. Solo las fichas. */
+export function turnosGuardados(cwd) {
+    const dir = carpetaDeCambios(cwd);
+    const turnos = [];
+    try {
+        for (const entrada of fs.readdirSync(dir)) {
+            try {
+                const meta = JSON.parse(fs.readFileSync(path.join(dir, entrada, "meta.json"), "utf-8"));
+                if (meta?.id)
+                    turnos.push(meta);
+            }
+            catch {
+                // Una carpeta a medias -se corto la luz al guardar- no puede tumbar la
+                // lista entera: se salta y ya.
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return turnos.sort((a, b) => (a.cuando || "").localeCompare(b.cuando || ""));
+}
+/** Recupera un turno con sus bytes, listo para que UndoManager lo deshaga. */
+export function leerTurno(cwd, id) {
+    const dir = carpetaDelTurno(cwd, id);
+    let meta;
+    try {
+        meta = JSON.parse(fs.readFileSync(path.join(dir, "meta.json"), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    const snapshots = [];
+    for (const a of meta.archivos || []) {
+        if (a.tipo === "absent") {
+            snapshots.push({ filePath: a.ruta, kind: "absent" });
+            continue;
+        }
+        if (a.tipo === "unrestorable" || !a.copia) {
+            snapshots.push({ filePath: a.ruta, kind: "unrestorable", reason: a.motivo || "sin copia" });
+            continue;
+        }
+        try {
+            snapshots.push({ filePath: a.ruta, kind: "file", previousContent: fs.readFileSync(path.join(dir, a.copia)) });
+        }
+        catch {
+            // La copia existia al guardarla y ahora no se puede leer: se dice, no se
+            // inventa un archivo vacio encima del que hay.
+            snapshots.push({
+                filePath: a.ruta,
+                kind: "unrestorable",
+                reason: "la copia del historial no se pudo leer",
+            });
+        }
+    }
+    return { id: meta.id, timestamp: meta.cuando, description: meta.descripcion, snapshots };
+}
+/** Un turno ya deshecho no tiene por que quedarse ocupando sitio. */
+export function olvidarTurno(cwd, id) {
+    try {
+        fs.rmSync(carpetaDelTurno(cwd, id), { recursive: true, force: true });
+    }
+    catch { }
+}
+/** Tira los turnos mas viejos que sobren del tope. */
+export function podar(cwd, tope = TURNOS_GUARDADOS) {
+    const turnos = turnosGuardados(cwd);
+    if (turnos.length <= tope)
+        return;
+    for (const viejo of turnos.slice(0, turnos.length - tope))
+        olvidarTurno(cwd, viejo.id);
+}
+/** Lo que ocupa el historial, para poder decirlo sin que nadie lo mida a mano. */
+export function bytesOcupados(cwd) {
+    let total = 0;
+    const dir = carpetaDeCambios(cwd);
+    try {
+        for (const turno of fs.readdirSync(dir)) {
+            const sub = path.join(dir, turno);
+            try {
+                for (const archivo of fs.readdirSync(sub)) {
+                    try {
+                        total += fs.statSync(path.join(sub, archivo)).size;
+                    }
+                    catch { }
+                }
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return total;
+}

package/dist/agent/salidaDelAgente.d.ts

@@ -30,6 +30,14 @@ export interface SalidaDelAgente {
     /** Escritura sin salto, para separar bloques. Equivale a process.stdout.write. */
     crudo(texto: string): void;
 }
+/**
+ * La copia al navegador, sin que este modulo dependa del servidor web.
+ *
+ * Se registra desde fuera (index.ts, al arrancar --servir). Asi una sesion
+ * normal de terminal no carga nada del servidor ni paga por tenerlo.
+ */
+type Copia = (texto: string) => void;
+export declare function copiarSalidaAlWeb(fn: Copia | null): void;
 /** Lo que usa el bucle. No sabe ni le importa quien esta al otro lado. */
 export declare const salida: SalidaDelAgente;
 /**
@@ -41,3 +49,4 @@ export declare const salida: SalidaDelAgente;
 export declare function dirigirSalidaDelAgente(destino: SalidaDelAgente | null): void;
 /** Quita los codigos de color, para quien pinte el texto a su manera. */
 export declare function sinColores(texto: string): string;
+export {};

package/dist/agent/salidaDelAgente.js

@@ -13,11 +13,30 @@ import { escribirEncimaDelPie } from "../ui/pieFijo.js";
 const A_LA_TERMINAL = {
     linea: (texto) => {
         escribirEncimaDelPie(`${texto}\n`);
+        // Y copia para el navegador, si hay sesion web abierta. Sin esto, lo que
+        // contesta el agente no sale del terminal: en el movil la sesion parece
+        // viva y muda. Ver servidor/captura.ts.
+        copiarAlWeb(`${texto}\n`);
     },
     crudo: (texto) => {
         escribirEncimaDelPie(texto);
+        copiarAlWeb(texto);
     },
 };
+let copia = null;
+export function copiarSalidaAlWeb(fn) {
+    copia = fn;
+}
+function copiarAlWeb(texto) {
+    if (!copia)
+        return;
+    try {
+        copia(texto);
+    }
+    catch {
+        // El navegador no puede tumbar la salida del terminal.
+    }
+}
 let actual = A_LA_TERMINAL;
 /** Lo que usa el bucle. No sabe ni le importa quien esta al otro lado. */
 export const salida = {

package/dist/agent/undoManager.d.ts

@@ -1,3 +1,4 @@
+import { type TurnoGuardado } from "./historialDeCambios.js";
 /**
  * Estado de una ruta justo antes de que el turno la tocara.
  *
@@ -40,6 +41,15 @@ export interface UndoResult {
 export declare class UndoManager {
     private checkpoints;
     private currentTurnSnapshots;
+    /**
+     * La carpeta del proyecto, para saber DONDE vive el historial en disco.
+     *
+     * Se fija desde fuera (index.ts) y se actualiza con /cd: el historial es de
+     * cada proyecto, asi que al cambiar de carpeta se cambia de historial. Si
+     * nadie la fija, esto funciona como siempre y solo en memoria.
+     */
+    private carpeta;
+    fijarCarpeta(cwd: string | null): void;
     /**
      * Fotografia una ruta antes de modificarla o borrarla.
      *
@@ -52,6 +62,17 @@ export declare class UndoManager {
      * Finalizes the current turn and saves a rollback checkpoint
      */
     commitTurn(description: string): void;
+    /** Los turnos que se pueden deshacer, del mas viejo al mas nuevo. */
+    turnos(): TurnoGuardado[];
+    /**
+     * Vuelve a como estaba ANTES de un turno concreto.
+     *
+     * Deshace ese turno y todos los de despues, del mas nuevo al mas viejo. El
+     * orden no es un detalle: si un archivo se toco en tres turnos seguidos, la
+     * copia buena es la del turno MAS VIEJO, y solo se llega a ella deshaciendo
+     * los de encima primero. Al reves quedaria el archivo como estaba a mitad.
+     */
+    volverAntesDe(id: string): UndoResult;
     /**
      * Deshace el ultimo turno de modificaciones.
      *

package/dist/agent/undoManager.js

@@ -1,8 +1,20 @@
 import fs from "node:fs";
 import path from "node:path";
+import { guardarTurno, leerTurno, olvidarTurno, turnosGuardados, } from "./historialDeCambios.js";
 export class UndoManager {
     checkpoints = [];
     currentTurnSnapshots = new Map();
+    /**
+     * La carpeta del proyecto, para saber DONDE vive el historial en disco.
+     *
+     * Se fija desde fuera (index.ts) y se actualiza con /cd: el historial es de
+     * cada proyecto, asi que al cambiar de carpeta se cambia de historial. Si
+     * nadie la fija, esto funciona como siempre y solo en memoria.
+     */
+    carpeta = null;
+    fijarCarpeta(cwd) {
+        this.carpeta = cwd;
+    }
     /**
      * Fotografia una ruta antes de modificarla o borrarla.
      *
@@ -71,18 +83,73 @@ export class UndoManager {
         this.currentTurnSnapshots.forEach((state, filePath) => {
             snapshots.push({ filePath, ...state });
         });
-        this.checkpoints.push({
+        const punto = {
             id: `chk_${Date.now()}`,
             timestamp: new Date().toLocaleTimeString(),
             description,
             snapshots,
-        });
+        };
+        this.checkpoints.push(punto);
+        // Y a disco, para que siga estando manana. Si falla -disco lleno, carpeta
+        // de solo lectura- no se dice nada aqui: el turno del usuario no se puede
+        // caer por culpa del historial, y en memoria sigue estando.
+        if (this.carpeta)
+            guardarTurno(this.carpeta, punto);
         this.currentTurnSnapshots.clear();
         // Keep maximum 10 recent checkpoints in memory
         if (this.checkpoints.length > 10) {
             this.checkpoints.shift();
         }
     }
+    /** Los turnos que se pueden deshacer, del mas viejo al mas nuevo. */
+    turnos() {
+        return this.carpeta ? turnosGuardados(this.carpeta) : [];
+    }
+    /**
+     * Vuelve a como estaba ANTES de un turno concreto.
+     *
+     * Deshace ese turno y todos los de despues, del mas nuevo al mas viejo. El
+     * orden no es un detalle: si un archivo se toco en tres turnos seguidos, la
+     * copia buena es la del turno MAS VIEJO, y solo se llega a ella deshaciendo
+     * los de encima primero. Al reves quedaria el archivo como estaba a mitad.
+     */
+    volverAntesDe(id) {
+        if (!this.carpeta) {
+            return { success: false, message: "No hay historial en disco para este proyecto.", restoredFiles: [], failures: [] };
+        }
+        const guardados = turnosGuardados(this.carpeta);
+        const desde = guardados.findIndex((t) => t.id === id);
+        if (desde < 0) {
+            return { success: false, message: `No encuentro el turno ${id}.`, restoredFiles: [], failures: [] };
+        }
+        const restoredFiles = [];
+        const failures = [];
+        let deshechos = 0;
+        for (let i = guardados.length - 1; i >= desde; i--) {
+            const punto = leerTurno(this.carpeta, guardados[i].id);
+            if (!punto) {
+                failures.push(`(Sin copia) el turno ${guardados[i].id} no se pudo leer`);
+                continue;
+            }
+            this.checkpoints.push(punto);
+            const res = this.undoLast();
+            restoredFiles.push(...res.restoredFiles);
+            failures.push(...res.failures);
+            if (res.success)
+                deshechos++;
+        }
+        const cuando = new Date(guardados[desde].cuando).toLocaleString();
+        return {
+            success: failures.length === 0 && restoredFiles.length > 0,
+            message: failures.length > 0
+                ? `⚠ Vuelta a medias a antes de "${guardados[desde].descripcion}" (${cuando}): ${failures.length} ruta(s) sin restaurar`
+                : restoredFiles.length === 0
+                    ? `Nada que deshacer: los archivos ya estaban como antes de "${guardados[desde].descripcion}".`
+                    : `✔ Vuelto a antes de "${guardados[desde].descripcion}" (${cuando}): ${deshechos} turno(s) deshechos`,
+            restoredFiles,
+            failures,
+        };
+    }
     /**
      * Deshace el ultimo turno de modificaciones.
      *
@@ -91,15 +158,24 @@ export class UndoManager {
      * peor mensaje posible: el usuario da por recuperado lo que ya no existe.
      */
     undoLast() {
-        if (this.checkpoints.length === 0) {
+        // Si en memoria no hay nada, se mira el disco: la sesion de ayer tambien
+        // cuenta. Es justo el caso que importa, porque uno no deshace treinta
+        // segundos despues -ahi todavia esta mirando- sino al dia siguiente.
+        let checkpoint = this.checkpoints.pop();
+        if (!checkpoint && this.carpeta) {
+            const guardados = turnosGuardados(this.carpeta);
+            const ultimo = guardados[guardados.length - 1];
+            if (ultimo)
+                checkpoint = leerTurno(this.carpeta, ultimo.id) ?? undefined;
+        }
+        if (!checkpoint) {
             return {
                 success: false,
-                message: "No hay acciones previas para deshacer en esta sesión.",
+                message: "No hay acciones previas para deshacer.",
                 restoredFiles: [],
                 failures: [],
             };
         }
-        const checkpoint = this.checkpoints.pop();
         const restoredFiles = [];
         const failures = [];
         for (const snap of checkpoint.snapshots) {
@@ -128,6 +204,10 @@ export class UndoManager {
                 failures.push(`(Error restaurando) ${nombre}: ${err?.message}`);
             }
         }
+        // Deshecho es deshecho: la copia ya no pinta nada y ocupa sitio en el
+        // proyecto de otro.
+        if (this.carpeta)
+            olvidarTurno(this.carpeta, checkpoint.id);
         const cabecera = `"${checkpoint.description}" (${checkpoint.timestamp})`;
         if (failures.length > 0) {
             return {