supcoflow 0.6.0 → 0.8.0

package/dist/guardado/index.js

@@ -4,6 +4,10 @@ import path from "node:path";
 import { FalloDeLaTerminal, SALIDA } from "../contrato.js";
 import { LlaveroAusente, TECHO_DEL_LLAVERO_MS } from "./llavero.js";
 import { dentroDeUnWorkingTree } from "./repo.js";
+// Cómo se nombra cada fuente en un texto para la persona; el valor `fuente` del JSON sigue siendo el de arriba.
+export const NOMBRE_DE_LA_FUENTE = {
+    llavero: "the system keychain", archivo: "the credentials file", env: "SUPCOFLOW_TOKEN",
+};
 // La cuenta ES el origen de la API que emitió lo guardado (Review Focus 3): una clave acuñada por
 // un motor en `localhost` queda en otra cuenta que la de producción, y la terminal apuntada a
 // producción simplemente no la encuentra (sale 2) en vez de mandarla a un servidor que no la emitió.
@@ -71,8 +75,8 @@ export function crearGuardado(d) {
     }
     const leerCuenta = async (cuenta, queda) => (await leerCuentaCompleta(cuenta, queda)).mejor;
     const errorDeBorrado = (fallidos) => {
-        const donde = fallidos.map((n) => (n === "llavero" ? "del llavero del sistema" : `de ${d.rutaDelArchivo}`)).join(" ni ");
-        return new FalloDeLaTerminal(SALIDA.inesperado, "no_se_pudo_borrar", `No pude borrar la clave guardada ${donde}.`);
+        const donde = fallidos.map((n) => (n === "llavero" ? NOMBRE_DE_LA_FUENTE.llavero : d.rutaDelArchivo)).join(" or from ");
+        return new FalloDeLaTerminal(SALIDA.inesperado, "no_se_pudo_borrar", `I couldn't delete the saved key from ${donde}.`);
     };
     // El chequeo del repo va ANTES de escribir (Review Focus 1): una vez escrita, la clave ya está a
     // un `git add -A` de publicarse, y borrarla después no deshace un commit. Mira la ruta REAL además
@@ -81,10 +85,10 @@ export function crearGuardado(d) {
     async function escribirEnArchivo(cuenta, r, que) {
         const raiz = dentroDeUnWorkingTree(path.dirname(d.rutaDelArchivo), d.fs);
         if (raiz !== null) {
-            throw new FalloDeLaTerminal(SALIDA.inesperado, "destino_dentro_de_un_repo", `No guardo ${que} dentro de un repo de git (${raiz}). Usá el llavero del sistema o exportá SUPCOFLOW_TOKEN.`);
+            throw new FalloDeLaTerminal(SALIDA.inesperado, "destino_dentro_de_un_repo", `I won't save ${que} inside a git repo (${raiz}). Use the system keychain or export SUPCOFLOW_TOKEN.`);
         }
         await d.archivo.escribir(cuenta, r);
-        d.avisar(`No hay llavero del sistema: guardé ${que} en ${d.rutaDelArchivo} con permisos 0600.`);
+        d.avisar(`There is no system keychain: I saved ${que} in ${d.rutaDelArchivo} with 0600 permissions.`);
     }
     async function escribirCuenta(cuenta, valor, que, techoMs) {
         const queda = plazo(techoMs);
@@ -145,7 +149,7 @@ export function crearGuardado(d) {
             return { valor: mejor === null ? null : { clave: mejor.r.valor, fuente: mejor.fuente }, completa };
         },
         async guardarClave(origen, clave, techoMs) {
-            return { donde: await escribirCuenta(cuentaDeClave(origen), clave, "la clave", techoMs) };
+            return { donde: await escribirCuenta(cuentaDeClave(origen), clave, "the key", techoMs) };
         },
         async borrarClave(origen) {
             // Un borrado a medias de una clave no se informa como hecho: la que quedó sigue sirviendo.
@@ -174,7 +178,7 @@ export function crearGuardado(d) {
             }
         },
         async guardarPendiente(origen, p, techoMs) {
-            await escribirCuenta(cuentaDePendiente(origen), JSON.stringify(p), "el inicio de sesión en curso", techoMs);
+            await escribirCuenta(cuentaDePendiente(origen), JSON.stringify(p), "the login in progress", techoMs);
         },
         async borrarPendiente(origen, techoMs) {
             // Nunca lanza: un pendiente viejo es inofensivo (su device_code ya se consumió o vence en
@@ -217,7 +221,7 @@ export function crearGuardado(d) {
                 const r = { valor: JSON.stringify([...l.valor, clave]), escritoEn: d.ahora() };
                 if (a.nombre === "archivo") {
                     try {
-                        await escribirEnArchivo(cuenta, r, "las claves por revocar");
+                        await escribirEnArchivo(cuenta, r, "the keys to revoke");
                         return;
                     }
                     catch (e) {
@@ -229,7 +233,7 @@ export function crearGuardado(d) {
                 if ((await intentar(a, queda, (x, t) => x.escribir(cuenta, r, t))).estado === "ok")
                     return;
             }
-            throw new FalloDeLaTerminal(SALIDA.inesperado, "no_se_pudo_anotar", "No pude anotar la clave anterior como «por revocar» ni en el llavero ni en el archivo.");
+            throw new FalloDeLaTerminal(SALIDA.inesperado, "no_se_pudo_anotar", "I couldn't note down the previous key as \"to revoke\" in either the keychain or the file.");
         },
         // Quitar sólo achica la lista, así que no pasa por el control del repo: no agrega ningún secreto.
         // Un almacén presente que falla deja `completo = false`: la clave puede seguir anotada ahí, el

package/dist/guardado/llavero.js

@@ -9,7 +9,7 @@ export const TECHO_DEL_LLAVERO_MS = 5_000;
 // nada que borrar en él; uno que está y falla puede tener datos adentro.
 export class LlaveroAusente extends Error {
     constructor(bin) {
-        super(`No hay llavero del sistema (falta ${bin}).`);
+        super(`There is no system keychain (${bin} is missing).`);
         this.name = "LlaveroAusente";
     }
 }
@@ -26,14 +26,14 @@ function decodificar(s) {
         v = undefined;
     }
     if (!esRegistro(v))
-        throw new Error("El llavero devolvió algo que no entiendo.");
+        throw new Error("The keychain returned something I don't understand.");
     return { valor: v.valor, escritoEn: v.escritoEn };
 }
 // La cuenta viaja en una línea de `security -i`, que también parte por espacios y entiende comillas:
 // una cuenta con algo de eso se leería distinta de lo que se escribió. Un origen nunca lo tiene.
 function cuentaSegura(cuenta) {
     if (!/^[A-Za-z0-9:/.\[\]#_-]+$/.test(cuenta))
-        throw new Error("Cuenta del llavero inválida.");
+        throw new Error("Invalid keychain account.");
     return cuenta;
 }
 // La ruta ABSOLUTA: un `security` del PATH podría ser otro programa (un `node_modules/.bin`, un
@@ -79,10 +79,10 @@ export function almacenDeLlavero(plataforma, correr, existe = existsSync) {
         if (r.ausente)
             throw new LlaveroAusente(bin);
         if (r.vencido)
-            throw new Error(`El llavero no contestó en ${Math.round(techoMs / 1000)} s.`);
+            throw new Error(`The keychain did not respond within ${Math.round(techoMs / 1000)} s.`);
         return r;
     }
-    const fallo = (codigo) => new Error(`El llavero falló (código ${codigo}).`);
+    const fallo = (codigo) => new Error(`The keychain failed (code ${codigo}).`);
     return {
         nombre: "llavero",
         async leer(cuenta, techoMs = TECHO_DEL_LLAVERO_MS) {

package/dist/guia.js

@@ -1,6 +1,8 @@
 // La guía del producto que vive en el repo del cliente. Sin dependencias: sólo `node:crypto`.
 import { createHash } from "node:crypto";
-export const RUTA_DE_LA_GUIA = ".supcoflow/guia.md";
+// El nombre canónico desde la 0.8.0; `guia.md` es el viejo y se sigue leyendo SÓLO si `guide.md` no existe.
+export const RUTA_DE_LA_GUIA = ".supcoflow/guide.md";
+export const RUTA_VIEJA_DE_LA_GUIA = ".supcoflow/guia.md";
 export const MAX_BYTES_DE_LA_GUIA = 64 * 1024;
 // La misma regla que el motor (`src/guia/formato.ts`), copiada a propósito y clavada con los vectores
 // de `test/vectores/huella.json` (idénticos en los dos repos). Se normaliza antes de hashear porque un

package/dist/idempotencia.js

@@ -15,7 +15,7 @@ export function crearRegistroDeIdempotencia(d) {
     // repo) y el motor lo reusa. Una clave de consulta no tiene clave natural: sin la de idempotencia
     // guardada, el reintento tras una respuesta perdida crea OTRA fila. Mejor no mandar nada y decir qué
     // arreglar. Por eso, en estricto, cada «aviso y sigo» de abajo lanza.
-    const noGuardada = () => new FalloDeLaTerminal(SALIDA.inesperado, "idempotencia_no_guardada", `No pude guardar la clave de reintento en ${d.rutaDelArchivo}; sin ella, un reintento crearía otra clave. Revisá ese archivo (no puede estar dentro de un repo) y probá de nuevo.`);
+    const noGuardada = () => new FalloDeLaTerminal(SALIDA.inesperado, "idempotencia_no_guardada", `I couldn't save the retry key in ${d.rutaDelArchivo}; without it, a retry would create another key. Check that file (it can't be inside a repo) and try again.`);
     return {
         async claveDe(operacion, alcance, opciones = {}) {
             const c = cuenta(operacion, alcance);
@@ -29,7 +29,7 @@ export function crearRegistroDeIdempotencia(d) {
                     throw noGuardada();
                 // Un archivo que no se entiende no se reescribe (perdería otras claves); se sigue sin guardar.
                 const nueva = d.generar();
-                d.avisar(`No pude leer ${d.rutaDelArchivo}: sigo con una clave de idempotencia sin guardar.`);
+                d.avisar(`I couldn't read ${d.rutaDelArchivo}: I'm going on with an idempotency key that isn't saved.`);
                 return nueva;
             }
             const nueva = d.generar();
@@ -45,13 +45,13 @@ export function crearRegistroDeIdempotencia(d) {
             catch {
                 if (opciones.estricta)
                     throw noGuardada();
-                d.avisar(`No pude resolver la ruta de ${d.rutaDelArchivo}: sigo con una clave de idempotencia sin guardar.`);
+                d.avisar(`I couldn't resolve the path of ${d.rutaDelArchivo}: I'm going on with an idempotency key that isn't saved.`);
                 return nueva;
             }
             if (raiz !== null) {
                 if (opciones.estricta)
                     throw noGuardada();
-                d.avisar(`No guardo la clave de idempotencia dentro de un repo de git (${raiz}): un reintento mandará otra.`);
+                d.avisar(`I'm not saving the idempotency key inside a git repo (${raiz}): a retry will send a different one.`);
                 return nueva;
             }
             try {
@@ -60,7 +60,7 @@ export function crearRegistroDeIdempotencia(d) {
             catch {
                 if (opciones.estricta)
                     throw noGuardada();
-                d.avisar(`No pude guardar la clave de idempotencia en ${d.rutaDelArchivo}: un reintento mandará otra.`);
+                d.avisar(`I couldn't save the idempotency key in ${d.rutaDelArchivo}: a retry will send a different one.`);
             }
             return nueva;
         },
@@ -81,7 +81,7 @@ export function crearRegistroDeIdempotencia(d) {
                 await d.almacen.borrar(cuenta(operacion, alcance));
             }
             catch {
-                d.avisar(`No pude borrar la clave de idempotencia de ${d.rutaDelArchivo}.`);
+                d.avisar(`I couldn't delete the idempotency key from ${d.rutaDelArchivo}.`);
             }
         },
     };

package/dist/instalacion.js

@@ -1,4 +1,4 @@
-// `.supcoflow/instalacion.json` (bloque 6, decisión 3): con qué versiones se hizo la instalación, anotado en el
+// `.supcoflow/instalacion.json` (bloque 6, decisión 3; v2 en la 0.8.0): con qué versiones se hizo la instalación, anotado en el
 // repo de quien instala. Supcoflow no lo guarda ni lo ve. Puro: recibe lo ya leído y arma el archivo.
 //
 // El archivo queda en el repo y se commitea: un secreto acá se publica con el primer `push`. Por eso se arma con
@@ -13,7 +13,7 @@ export const esSemver = (s) => s.length <= 64 && SEMVER.test(s);
 const objeto = (v) => (typeof v === "object" && v !== null && !Array.isArray(v) ? v : null);
 const entero = (v) => typeof v === "number" && Number.isInteger(v) && v >= 1;
 const ilegible = (message) => new FalloDeLaTerminal(SALIDA.inesperado, "paquete_ilegible", message);
-const inesperada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "configuracion_inesperada", `El motor contestó la configuración con ${que} que no entiendo; no anoto nada a medias. Probá de nuevo en un rato.`);
+const inesperada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "configuracion_inesperada", `The engine answered the configuration with ${que} I don't understand; I'm not recording anything halfway. Try again in a while.`);
 // Lo declarado en el `package.json` de la app lo escribió quien escribió el repo: puede ser un rango, un alias o
 // cualquier cosa. Se copia tal cual sólo si es texto imprimible y corto; si no, no se adivina (`paquete_ilegible`).
 // `taparSecretos` igual, por si alguien pegó una clave ahí: el archivo nuevo no la repite.
@@ -25,7 +25,7 @@ function declaradoEn(app) {
     if (v === undefined || v === null)
         return null;
     if (typeof v !== "string" || v.length === 0 || v.length > 200 || !/^[\x20-\x7e]+$/.test(v)) {
-        throw ilegible(`La versión de ${PAQUETE_DEL_CHAT} en el package.json de la app no se entiende; no la anoto.`);
+        throw ilegible(`The version of ${PAQUETE_DEL_CHAT} in the app's package.json isn't understandable; I'm not recording it.`);
     }
     return taparSecretos(v);
 }
@@ -35,7 +35,7 @@ function instaladoEn(paquete) {
         return null;
     const v = objeto(paquete)?.version;
     if (typeof v !== "string" || !esSemver(v))
-        throw ilegible(`El package.json de ${PAQUETE_DEL_CHAT} instalado no trae una versión que entienda.`);
+        throw ilegible(`The installed package.json of ${PAQUETE_DEL_CHAT} has no version I understand.`);
     return v;
 }
 function acuerdoDe(c) {
@@ -44,16 +44,16 @@ function acuerdoDe(c) {
     const a = objeto(c.acuerdo);
     // Ilegible es un estado conocido del motor (aplica cerrado), no «sin acuerdo»: anotarlo como null mentiría.
     if (a?.ilegible === true) {
-        throw new FalloDeLaTerminal(SALIDA.haceFaltaUnaPersona, "acuerdo_ilegible", "El acuerdo de datos está fijado pero no se lee: revisalo en la consola y volvé a correr.");
+        throw new FalloDeLaTerminal(SALIDA.haceFaltaUnaPersona, "acuerdo_ilegible", "The data agreement is set but can't be read: check it in the console and run again.");
     }
     if (a === null || !entero(a.version))
-        throw inesperada("un acuerdo");
+        throw inesperada("an agreement");
     return a.version;
 }
 function politicaDe(c) {
     const modo = objeto(c.politica)?.modo;
     if (modo !== "relevar" && modo !== "guardar")
-        throw inesperada("una política");
+        throw inesperada("a policy");
     return modo;
 }
 function guiaDe(c) {
@@ -62,24 +62,63 @@ function guiaDe(c) {
     const g = objeto(c.guia);
     if (g?.origen === "repo") {
         if (g.procedencia !== "terminal" && g.procedencia !== "github")
-            throw inesperada("una guía");
+            throw inesperada("a guide");
         if (g.commit !== null && (typeof g.commit !== "string" || !/^[0-9a-f]{40}$/.test(g.commit)))
-            throw inesperada("una guía");
+            throw inesperada("a guide");
         return { origen: "repo", procedencia: g.procedencia, commit: g.commit };
     }
     if (g?.origen === "agente" && entero(g.version))
         return { origen: "agente", version: g.version };
-    throw inesperada("una guía");
+    throw inesperada("a guide");
 }
 export function armarInstalacion(i) {
     return {
-        version: 1,
+        version: 2,
         skill: i.skill,
         terminal: i.terminal,
         chat: { declarado: declaradoEn(i.paqueteDeLaApp), instalado: instaladoEn(i.paqueteInstalado) },
         configuracion: { acuerdo_version: acuerdoDe(i.configuracion), politica: politicaDe(i.configuracion), guia: guiaDe(i.configuracion) },
+        archivo: i.archivo ?? null,
     };
 }
+// ─── El archivo del chat (`install record --file`) ───
+const MAX_LARGO_DEL_ARCHIVO = 300;
+// Pura: una ruta RELATIVA a la raíz del repo, sin `..`, sin ruta absoluta. Se devuelve normalizada (separador `/`, sin
+// `./` ni barras de más), que es como queda anotada. Que no sea un enlace simbólico lo mira el comando, con el disco.
+export function validarElArchivoDelChat(crudo) {
+    if (crudo.length === 0 || crudo.length > MAX_LARGO_DEL_ARCHIVO || /[\u0000-\u001f\u007f]/.test(crudo)) {
+        return { ok: false, motivo: `--file goes with a path of up to ${MAX_LARGO_DEL_ARCHIVO} printable characters.` };
+    }
+    if (crudo.startsWith("/") || crudo.startsWith("\\") || /^[A-Za-z]:/.test(crudo)) {
+        return { ok: false, motivo: "--file is a path relative to the repo root, not an absolute one." };
+    }
+    const partes = crudo.split(/[\\/]/).filter((x) => x !== "" && x !== ".");
+    if (partes.includes(".."))
+        return { ok: false, motivo: "--file can't go out of the repo: no `..` in the path." };
+    if (partes.length === 0)
+        return { ok: false, motivo: "--file is the chat file, not a folder: say its path." };
+    return { ok: true, ruta: partes.join("/") };
+}
+/** El `archivo` anotado en un `instalacion.json` ya existente: v1 y cualquier cosa ilegible o inválida dan null (nunca un error). */
+export function archivoAnotado(texto) {
+    if (texto === null)
+        return null;
+    let v;
+    try {
+        v = JSON.parse(texto);
+    }
+    catch {
+        return null;
+    }
+    // AD9: un v1 se reconoce por `version: 1` (lo escribe la terminal 0.7.0) y no tiene archivo, aunque el campo aparezca.
+    if (objeto(v)?.version === 1)
+        return null;
+    const a = objeto(v)?.archivo;
+    if (typeof a !== "string")
+        return null;
+    const r = validarElArchivoDelChat(a);
+    return r.ok && r.ruta === a ? a : null;
+}
 // El orden de las claves es el de `armarInstalacion`: el mismo estado da los mismos bytes, y eso es `sin_cambios`.
 export function serializar(x) {
     return JSON.stringify(x, null, 2) + "\n";

package/dist/lectura.js

@@ -0,0 +1,10 @@
+// Por qué `leerArchivoChico` no pudo leer un archivo. Son frases sueltas que van después de «I can't read X:», y
+// los comandos comparan contra estas constantes (nunca contra el texto a mano).
+export const NO_LEIDO = {
+    noExiste: "it doesn't exist",
+    esUnEnlace: "it's a symlink",
+    noSePudoAbrir: "it couldn't be opened",
+    noEsComun: "it isn't a regular file",
+    demasiadoGrande: "it's too large",
+    noSePudoLeer: "it couldn't be read",
+};

package/dist/pruebas-guardadas.js

@@ -0,0 +1,101 @@
+// Lo que `probar` guarda en esta máquina, por origen y por proyecto (bloque 7, hallazgo 5): el INTENTO
+// (`{clave, mensaje, techo_usd}`) y la última prueba confirmada. Fuera del repo, al lado de las credenciales.
+//
+// Por qué no alcanza el registro de idempotencia (src/idempotencia.ts): ése guarda sólo la clave. El motor
+// compara la huella del pedido (proyecto, techo, mensaje) y una misma clave con otro mensaje es
+// `idempotency_key_reusada`; para que el reintento tras una respuesta perdida recupere la MISMA prueba hay
+// que reenviar la clave con el mensaje y el techo que llevó. Por eso se guarda el intento entero.
+//
+// Por qué una sola cuenta con las dos cosas: «guardar el id» y «cerrar el intento» son UNA escritura
+// atómica (el `rename` del almacén). Si falla, el archivo queda como estaba: el intento sigue abierto, el
+// próximo comando reenvía la misma clave, recibe la misma prueba y vuelve a intentar (R14d). Con dos
+// escrituras, un corte entre medio dejaba la última guardada y el intento abierto, y la próxima «prueba
+// nueva» sería en realidad un reintento de la vieja.
+//
+// Estricto en todo, como `claves crear` en el registro de idempotencia: una prueba no tiene clave natural
+// del lado de la terminal, así que mandar sin el intento guardado arriesga una segunda prueba (que gasta).
+import path from "node:path";
+import { FalloDeLaTerminal, SALIDA } from "./contrato.js";
+import { dentroDeUnWorkingTree } from "./guardado/repo.js";
+function esIntento(v) {
+    if (typeof v !== "object" || v === null)
+        return false;
+    const i = v;
+    const politica = i.politica_esperada === undefined || i.politica_esperada === null || i.politica_esperada === "relevar" || i.politica_esperada === "guardar";
+    return typeof i.clave === "string" && i.clave.length > 0 && (i.mensaje === null || typeof i.mensaje === "string") && typeof i.techo_usd === "number" && politica;
+}
+export function crearRegistroDePruebas(d) {
+    // Por origen, como la clave y el registro de idempotencia: un motor local (o el proxy de P4) y
+    // producción no comparten intentos. Cambiar de origen entre dos comandos es otra clave.
+    const cuenta = (proyectoId) => `${d.origen}#prueba#${proyectoId}`;
+    const noGuardada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `I couldn't ${que} ${d.rutaDelArchivo}; without that, a retry could ask for another test (and spend twice). Check that file (it can't be inside a repo) and try again.`);
+    async function leer(proyectoId) {
+        let crudo;
+        try {
+            crudo = (await d.almacen.leer(cuenta(proyectoId)))?.valor ?? null;
+        }
+        catch {
+            throw noGuardada("read");
+        }
+        if (crudo === null)
+            return { intento: null, ultima: null };
+        let v;
+        try {
+            v = JSON.parse(crudo);
+        }
+        catch {
+            throw noGuardada("understand");
+        }
+        const o = (typeof v === "object" && v !== null ? v : {});
+        const intentoOk = o.intento === null || esIntento(o.intento);
+        const ultimaOk = o.ultima === null || typeof o.ultima === "string";
+        if (!intentoOk || !ultimaOk)
+            throw noGuardada("understand");
+        const i = o.intento;
+        return {
+            intento: i === null ? null : { clave: i.clave, mensaje: i.mensaje, techoUsd: i.techo_usd, politicaEsperada: i.politica_esperada ?? null },
+            ultima: o.ultima,
+        };
+    }
+    async function escribir(proyectoId, g) {
+        // Misma regla que las credenciales: un destino dentro de un repo se publicaría con un `git add -A`.
+        // No saber dónde cae (un enlace roto) es otro «no se puede guardar».
+        let raiz;
+        try {
+            raiz = dentroDeUnWorkingTree(path.dirname(d.rutaDelArchivo), d.fs);
+        }
+        catch {
+            throw noGuardada("resolve the path of");
+        }
+        if (raiz !== null) {
+            throw new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `I'm not saving the test request inside a git repo (${raiz}); without saving it I won't send it. Point XDG_CONFIG_HOME outside a repo.`);
+        }
+        const valor = JSON.stringify({
+            intento: g.intento === null
+                ? null
+                : { clave: g.intento.clave, mensaje: g.intento.mensaje, techo_usd: g.intento.techoUsd, politica_esperada: g.intento.politicaEsperada },
+            ultima: g.ultima,
+        });
+        try {
+            await d.almacen.escribir(cuenta(proyectoId), { valor, escritoEn: d.ahora() });
+        }
+        catch {
+            throw noGuardada("save to");
+        }
+    }
+    return {
+        leer,
+        async abrir(proyectoId, intento) {
+            const antes = await leer(proyectoId);
+            await escribir(proyectoId, { intento, ultima: antes.ultima });
+        },
+        async confirmar(proyectoId, pruebaId) {
+            await leer(proyectoId);
+            await escribir(proyectoId, { intento: null, ultima: pruebaId });
+        },
+        async descartar(proyectoId) {
+            const antes = await leer(proyectoId);
+            await escribir(proyectoId, { intento: null, ultima: antes.ultima });
+        },
+    };
+}

package/dist/repo-local.js

@@ -45,15 +45,15 @@ export async function leerRepoLocal(git, cwd) {
     return { repo, raiz };
 }
 const MOTIVOS = {
-    sin_git: "esta carpeta no es un repo de git",
-    sin_origin: "el repo no tiene un remoto «origin»",
-    origin_no_es_github: "el «origin» no es un repo de GitHub",
+    sin_git: "this folder isn't a git repo",
+    sin_origin: "the repo has no remote called \"origin\"",
+    origin_no_es_github: "the \"origin\" remote isn't a GitHub repo",
 };
 export async function repoPedido(d) {
     const local = await leerRepoLocal(d.git, d.cwd);
     if (d.flagRepo !== null) {
         if (!esRepoValido(d.flagRepo)) {
-            throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "repo_invalido", "El valor de --repo tiene que ser owner/repo (por ejemplo duenio/mi-app), sin la URL.");
+            throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "repo_invalido", "The value of --repo must be owner/repo (for example owner/my-app), without the URL.");
         }
         // La raíz sólo se da si el origin local es ESE repo: con otro, lo que se escriba en esta
         // carpeta (el archivo del proyecto) no le pertenece.
@@ -61,8 +61,8 @@ export async function repoPedido(d) {
         return { repo: d.flagRepo, raiz: mismo ? local.raiz : null };
     }
     if (local.repo === null) {
-        const porque = local.motivo ? MOTIVOS[local.motivo] : "no se pudo leer";
-        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "sin_repo", `No encontré un repo de GitHub acá (${porque}). Pasá --repo owner/repo.`);
+        const porque = local.motivo ? MOTIVOS[local.motivo] : "the folder couldn't be read";
+        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "sin_repo", `I couldn't find a GitHub repo here (${porque}). Pass --repo owner/repo.`);
     }
     return { repo: local.repo, raiz: local.raiz };
 }

package/dist/secreto-a-archivo.js

@@ -22,7 +22,7 @@ import { dentroDeUnWorkingTree } from "./guardado/repo.js";
 // Una clave ocupa 85 caracteres: 4 KB es de sobra, y algo más grande ya no es una clave.
 const TOPE = 4 * 1024;
 const CLAVE = /^scf_([0-9a-f]{16})_[0-9a-f]{64}$/;
-const OCUPADO = { error: "el archivo ya tiene otra cosa; borralo o elegí otro destino", codigo: 4 };
+const OCUPADO = { error: "the file already has something else; delete it or pick another destination", codigo: 4 };
 export function crearGuardaDeSecretos(fs) {
     function borrarTemporal(tmp) {
         try {
@@ -50,10 +50,10 @@ export function crearGuardaDeSecretos(fs) {
             raiz = dentroDeUnWorkingTree(path.dirname(destino), fs);
         }
         catch {
-            return { error: "no pude resolver la ruta real de la carpeta (¿un enlace roto?)", codigo: 3 };
+            return { error: "I couldn't resolve the folder's real path (a broken link?)", codigo: 3 };
         }
         if (raiz !== null)
-            return { error: `cae dentro del repo de git ${raiz}, y una clave en un repo termina commiteada; elegí un destino fuera`, codigo: 3 };
+            return { error: `it falls inside the git repo ${raiz}, and a key in a repo ends up committed; pick a destination outside it`, codigo: 3 };
         return null;
     }
     return {
@@ -67,7 +67,7 @@ export function crearGuardaDeSecretos(fs) {
                 return invalido;
             const hay = fs.leerSinSeguir(destino, TOPE);
             if (hay.tipo === "enlace")
-                return { error: "el destino es un enlace; elegí un archivo común", codigo: 3 };
+                return { error: "the destination is a symlink; pick a regular file", codigo: 3 };
             if (hay.tipo !== "ausente") {
                 const actual = leer(destino);
                 if (actual.estado !== "clave" || actual.claveId !== claveId)
@@ -90,7 +90,7 @@ export function crearGuardaDeSecretos(fs) {
             catch {
                 // El mensaje del sistema no se reenvía: podría traer la ruta del temporal o algo peor.
                 borrarTemporal(tmp);
-                return { error: "no se pudo escribir ahí (¿la carpeta existe y tenés permiso?)", codigo: 3 };
+                return { error: "it couldn't be written there (does the folder exist, and do you have permission?)", codigo: 3 };
             }
             // Después de publicar, el temporal es un nombre de más (con `link`) o ya no existe (con `rename`): no
             // borrarlo no cambia que la clave quedó en el destino, y convertir eso en un fallo dejaría una clave
@@ -101,7 +101,7 @@ export function crearGuardaDeSecretos(fs) {
                 return OCUPADO;
             // Sin caer a `rename`: eso reabre la carrera que `link` cierra. Otro destino, en otro disco, sirve.
             if (publicado === "sin_enlaces") {
-                return { error: "el disco de esa carpeta no admite enlaces duros (¿FAT, exFAT o una carpeta de red?), y sin ellos no puedo escribir sin riesgo de pisar otra clave; elegí un destino en otro disco", codigo: 3 };
+                return { error: "that folder's disk doesn't support hard links (FAT, exFAT or a network folder?), and without them I can't write without risking overwriting another key; pick a destination on another disk", codigo: 3 };
             }
             return "guardado";
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supcoflow",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "La terminal de Supcoflow: iniciar sesión y manejar el chat de soporte desde la consola o un asistente.",
   "type": "module",
   "bin": { "supcoflow": "dist/cli.js" },