supcoflow 0.7.0 → 0.8.0

package/dist/comandos/repo-conectar.js

@@ -17,22 +17,22 @@ function resultadoDelPedido(repo, p, avisar) {
             return {
                 codigo: SALIDA.ok,
                 json: { ok: true, estado: "conectado", repo, repo_canonico: p.repoCanonico, pedido },
-                texto: `${p.repoCanonico ?? repo} está conectado.`,
+                texto: `${p.repoCanonico ?? repo} is connected.`,
             };
         case "repo_fuera_de_alcance": {
-            const message = `La App está instalada pero no alcanza a ${repo}: sumalo en GitHub y volvé a tocar Confirmar (${p.url}).`;
+            const message = `The App is installed but doesn't have access to ${repo}: add it in GitHub and click Confirm again (${p.url}).`;
             return fallo(SALIDA.haceFaltaUnaPersona, "repo_fuera_de_alcance", message, { repo, url: p.url, pedido });
         }
         case "vencido":
-            return fallo(SALIDA.haceFaltaUnaPersona, "pedido_vencido", "El pedido venció. Pedí otro con `supcoflow repo conectar --start`.", { repo, pedido });
+            return fallo(SALIDA.haceFaltaUnaPersona, "pedido_vencido", "The request has expired. Ask for a new one with `supcoflow repo connect --start`.", { repo, pedido });
         case "pendiente": {
             // Un motivo anotado no cierra el pedido: la persona puede reintentar desde la misma página.
             if (p.fallo !== null)
-                avisar(`La última confirmación falló: ${p.fallo}.`);
+                avisar(`The last confirmation failed: ${p.fallo}.`);
             return {
                 codigo: SALIDA.esperandoAUnaPersona,
                 json: { ok: false, esperando: "persona", repo, url: p.url, pedido, ...(p.fallo !== null ? { fallo: p.fallo } : {}) },
-                texto: `Abrí ${p.url}, instalá la App en GitHub si hace falta y tocá Confirmar.`,
+                texto: `Open ${p.url}, install the App on GitHub if needed, and click Confirm.`,
             };
         }
     }
@@ -49,7 +49,7 @@ export async function repoConectarStart(d, flags) {
         return {
             codigo: SALIDA.ok,
             json: { ok: true, dry_run: true, repo, haria: "POST /api/conexiones" },
-            texto: `Con --dry-run no hago nada; sin él, pediría conectar ${repo} (POST /api/conexiones).`,
+            texto: `With --dry-run I do nothing; without it: ask to connect ${repo} (POST /api/conexiones).`,
         };
     }
     const leida = await claveVigente(d.guardado, d.api.origin);
@@ -92,7 +92,7 @@ export async function repoConectarWait(d, flags) {
             return resultadoDeFallo(e);
         }
         if (p === null) {
-            return fallo(SALIDA.entradaInvalida, "sin_conexion_en_curso", `No hay una conexión en curso para ${repo}: empezá con \`supcoflow repo conectar --start\`.`, { repo });
+            return fallo(SALIDA.entradaInvalida, "sin_conexion_en_curso", `There is no connection in progress for ${repo}: start with \`supcoflow repo connect --start\`.`, { repo });
         }
         ultimo = p;
         if (p.estado !== "pendiente")
@@ -110,12 +110,12 @@ export async function repoConectarWait(d, flags) {
 // que nadie va a mirar.
 export async function repoConectarInteractivo(d, flags) {
     if (!d.esTty || flags.json) {
-        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Sin terminal interactiva usá `supcoflow repo conectar --start --json` y después `supcoflow repo conectar --wait --json`.");
+        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Without an interactive terminal, use `supcoflow repo connect --start --json` and then `supcoflow repo connect --wait --json`.");
     }
     const inicio = await repoConectarStart(d, flags);
     if (inicio.codigo !== SALIDA.esperandoAUnaPersona)
         return inicio;
-    d.mostrar(`${inicio.texto} Espero acá…`);
+    d.mostrar(`${inicio.texto} I'll wait here...`);
     let r;
     do {
         r = await repoConectarWait(d, flags);

package/dist/comandos/widget.js

@@ -1,20 +1,24 @@
 import { resultadoDeFallo, SALIDA } from "../contrato.js";
 import { proyectoDelRepo } from "./proyecto-del-repo.js";
 function textoDe(w) {
+    const anteriores = w.nextjs.archivos_anteriores;
     return [
-        "1. Instalá el paquete (con el gestor de la app, la versión exacta):",
+        "1. Install the package (with the app's package manager, the exact version):",
         `   ${w.instalar}`,
         "",
-        `2. Creá el archivo ${w.nextjs.archivo_sugerido} con este contenido (Next.js, ${w.nextjs.estado}):`,
+        `2. Create the file ${w.nextjs.archivo_sugerido} with this content (Next.js, ${w.nextjs.estado}):`,
         w.nextjs.contenido.trimEnd(),
+        ...(anteriores.length > 0
+            ? [`   If the chat is already installed in ${anteriores.join(" or ")}, update that file in place instead of creating a second one.`]
+            : []),
         "",
-        "3. Usalo en el layout que cubre las pantallas donde se traban los usuarios:",
+        "3. Use it in the layout that covers the screens where users get stuck:",
         `   ${w.nextjs.uso}`,
         "",
-        "4. Política de contenido (CSP): si la app tiene `connect-src`, agregale este origen conservando lo que ya tiene:",
+        "4. Content Security Policy (CSP): if the app has `connect-src`, add this origin and keep what it already has:",
         `   ${w.csp}`,
         "",
-        "Alternativa con <script> (disponible, no probada en una app real):",
+        "Alternative with <script> (available, not tested in a real app):",
         `   ${w.script.linea}`,
     ].join("\n");
 }

package/dist/diagnostico.js

@@ -0,0 +1,48 @@
+export const TOTAL_DE_INSTALACION = 6;
+// El orden y los nombres con que se dicen: los ids de los puntos del motor son datos suyos y no cambian.
+const DE_LA_INSTALACION = [
+    { punto: "sign-in", como: "sign-in" },
+    { punto: "repo", como: "repo" },
+    { punto: "instalacion", como: "GitHub App" },
+    { punto: "sitios", como: "allowed sites" },
+    { punto: "chat", como: "chat" },
+    { punto: "guia", como: "guide" },
+];
+const DEL_MOTOR = new Set(["instalacion", "sitios", "chat", "guia"]);
+export const lineaDeLoRevisado = (n) => `Checked ${DE_LA_INSTALACION.map((x) => x.como).slice(0, -1).join(", ")} and ${DE_LA_INSTALACION.at(-1).como}: ${n} of ${TOTAL_DE_INSTALACION}, at no cost.`;
+export const nombreDelPunto = (punto) => DE_LA_INSTALACION.find((x) => x.punto === punto)?.como ?? punto;
+export function puntoDeSesion() {
+    return { punto: "sign-in", ok: true, mensaje: "This request was authenticated: you're signed in.", grupo: "instalacion" };
+}
+export function puntoDelRepo(local, repoDelProyecto) {
+    const mal = (mensaje) => ({ punto: "repo", ok: false, mensaje, grupo: "instalacion" });
+    if (local.repo === null) {
+        if (local.motivo === "sin_git")
+            return mal("This folder isn't a git repo, so I can't tell which repo it is.");
+        if (local.motivo === "sin_origin")
+            return mal("This repo has no «origin» remote, so I can't tell which repo it is.");
+        return mal("The «origin» of this repo isn't a GitHub repo.");
+    }
+    if (local.repo.toLowerCase() !== repoDelProyecto.toLowerCase()) {
+        return mal(`The origin of this folder is ${local.repo}, not the project's repo ${repoDelProyecto}.`);
+    }
+    return { punto: "repo", ok: true, mensaje: `The origin of this folder is ${local.repo}, the project's repo.`, grupo: "instalacion" };
+}
+/** Reparte los puntos del motor en los dos grupos y suma los dos locales al de la instalación. */
+export function agruparPuntos(g, locales) {
+    const delMotor = g.puntos.map((p) => ({ ...p, grupo: p.grupo ?? (DEL_MOTOR.has(p.punto) ? "instalacion" : "prueba") }));
+    const instalacion = [...locales, ...delMotor.filter((p) => p.grupo === "instalacion")];
+    // Un punto del grupo que el motor no mandó no se da por bueno: se dice que falta y cuenta como no ok.
+    for (const { punto } of DE_LA_INSTALACION) {
+        if (!instalacion.some((p) => p.punto === punto)) {
+            instalacion.push({ punto, ok: false, mensaje: "The engine didn't report this point.", grupo: "instalacion" });
+        }
+    }
+    const orden = (p) => {
+        const i = DE_LA_INSTALACION.findIndex((x) => x.punto === p.punto);
+        return i === -1 ? DE_LA_INSTALACION.length : i;
+    };
+    return { instalacion: instalacion.sort((a, b) => orden(a) - orden(b)), prueba: delMotor.filter((p) => p.grupo === "prueba") };
+}
+/** Cuántos de los seis puntos de la instalación están bien (los extras que un motor nuevo sume no cambian el seis). */
+export const contarBuenos = (instalacion) => DE_LA_INSTALACION.filter(({ punto }) => instalacion.some((p) => p.punto === punto && p.ok)).length;

package/dist/entorno.js

@@ -3,11 +3,12 @@
 import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { chmodSync, closeSync, constants, fchmodSync, fstatSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, renameSync, rmSync, writeSync, } from "node:fs";
+import { NO_LEIDO } from "./lectura.js";
 import { homedir, hostname } from "node:os";
 import { basename, dirname, join } from "node:path";
-import { buscarProyecto, canjear, configurar, leerDiagnostico, leerPrueba, leerWidget, pedirPrueba, crearConexion, crearProyecto, elegirOrigen, esClaveDeConsultaDelProyecto, leerCatalogo, leerConfiguracion, leerGuia, leerProyecto, listarClaves, pedirCodigo, quienSoy, revocarPropia, subirLogo, ultimaConexion, urlDeLaApi, publicarGuia, revisarGuia, } from "./api.js";
+import { buscarProyecto, canjear, configurar, leerDiagnostico, leerPrueba, leerWidget, pedirPrueba, crearConexion, crearProyecto, elegirOrigen, esClaveDeConsultaDelProyecto, leerCatalogo, leerConfiguracion, leerGuia, leerProyecto, listarClaves, pedirCodigo, quienSoy, revocarPropia, subirLogo, ultimaConexion, urlDeLaApi, publicarGuia, revisarGuia, leerVersionesDeLaGuia, } from "./api.js";
 import { crearCandados } from "./candado.js";
-import { esCarpetaReal, rutaRealOEnNada } from "./comandos/instalacion.js";
+import { esCarpetaReal, esEnlaceReal, rutaRealOEnNada } from "./comandos/instalacion.js";
 import { DESCRIPCION } from "./comandos/describir.js";
 import { almacenDeArchivo } from "./guardado/archivo.js";
 import { crearGuardado } from "./guardado/index.js";
@@ -51,7 +52,7 @@ export const fsReal = {
             return realpathSync(p);
         }
         catch {
-            throw new Error(`No puedo resolver la ruta real de ${p} (¿un enlace roto?); no guardo nada ahí.`);
+            throw new Error(`I can't resolve the real path of ${p} (a broken symlink?); I'm not saving anything there.`);
         }
     },
     // `lstat` y no `existsSync`: éste sigue el enlace y ante uno roto dice «no existe», y el control
@@ -252,7 +253,7 @@ export const TOPE_DEL_ARCHIVO_DEL_REPO = 64 * 1024;
 // Lo que devuelve `leer` cuando hay ALGO ahí que no se lee (un enlace, una carpeta, algo enorme, sin
 // permiso). No es JSON a propósito: `proyecto crear` lo trata como un archivo distinto (sale 4, «no lo
 // toqué») sin que nada de lo que hay ahí llegue a la salida.
-export const ARCHIVO_QUE_NO_SE_LEE = "\u0000(no se lee)";
+export const ARCHIVO_QUE_NO_SE_LEE = "\u0000(unreadable)";
 // Un archivo que la persona nombra (el logo) con las mismas defensas que los del repo: sin seguir
 // enlaces, sin FIFOs que cuelguen, sólo archivos comunes y con tope (se lee tope + 1 por si crece).
 export function leerArchivoChico(p, tope) {
@@ -262,11 +263,11 @@ export function leerArchivoChico(p, tope) {
     }
     catch (e) {
         const code = e.code;
-        return { error: code === "ENOENT" ? "no existe" : code === "ELOOP" ? "es un enlace" : "no se pudo abrir" };
+        return { error: code === "ENOENT" ? NO_LEIDO.noExiste : code === "ELOOP" ? NO_LEIDO.esUnEnlace : NO_LEIDO.noSePudoAbrir };
     }
     try {
         if (!fstatSync(fd).isFile())
-            return { error: "no es un archivo común" };
+            return { error: NO_LEIDO.noEsComun };
         const buf = Buffer.alloc(tope + 1);
         let n = 0;
         for (;;) {
@@ -275,12 +276,12 @@ export function leerArchivoChico(p, tope) {
                 break;
             n += leidos;
             if (n > tope)
-                return { error: "es demasiado grande" };
+                return { error: NO_LEIDO.demasiadoGrande };
         }
         return { bytes: new Uint8Array(buf.subarray(0, n)) };
     }
     catch {
-        return { error: "no se pudo leer" };
+        return { error: NO_LEIDO.noSePudoLeer };
     }
     finally {
         closeSync(fd);
@@ -299,7 +300,7 @@ export function archivosDelRepo(avisar) {
         }
     };
     const noSeLee = (p, porque) => {
-        avisar(`No leo ${p}: ${porque}.`);
+        avisar(`I can't read ${p}: ${porque}.`);
         return ARCHIVO_QUE_NO_SE_LEE;
     };
     return {
@@ -308,7 +309,7 @@ export function archivosDelRepo(avisar) {
             if (carpeta === "ausente")
                 return null;
             if (carpeta === "ajena")
-                return noSeLee(p, `${basename(dirname(p))} no es una carpeta común (¿un enlace?)`);
+                return noSeLee(p, `${basename(dirname(p))} isn't a regular folder (a symlink?)`);
             let fd;
             try {
                 // O_NOFOLLOW: un enlace en el último tramo falla (ELOOP) en vez de abrir su destino.
@@ -319,14 +320,14 @@ export function archivosDelRepo(avisar) {
                 const code = e.code;
                 if (code === "ENOENT")
                     return null;
-                return noSeLee(p, code === "ELOOP" ? "es un enlace" : "no se pudo abrir");
+                return noSeLee(p, code === "ELOOP" ? NO_LEIDO.esUnEnlace : NO_LEIDO.noSePudoAbrir);
             }
             try {
                 const st = fstatSync(fd);
                 if (!st.isFile())
-                    return noSeLee(p, "no es un archivo común");
+                    return noSeLee(p, NO_LEIDO.noEsComun);
                 if (st.size > TOPE_DEL_ARCHIVO_DEL_REPO)
-                    return noSeLee(p, "es demasiado grande");
+                    return noSeLee(p, NO_LEIDO.demasiadoGrande);
                 // Se lee hasta el tope + 1 y no `st.size`: el archivo puede crecer entre el fstat y la lectura.
                 const buf = Buffer.alloc(TOPE_DEL_ARCHIVO_DEL_REPO + 1);
                 let n = 0;
@@ -336,12 +337,12 @@ export function archivosDelRepo(avisar) {
                         break;
                     n += leidos;
                     if (n > TOPE_DEL_ARCHIVO_DEL_REPO)
-                        return noSeLee(p, "es demasiado grande");
+                        return noSeLee(p, NO_LEIDO.demasiadoGrande);
                 }
                 return buf.subarray(0, n).toString("utf8");
             }
             catch {
-                return noSeLee(p, "no se pudo leer");
+                return noSeLee(p, NO_LEIDO.noSePudoLeer);
             }
             finally {
                 closeSync(fd);
@@ -355,7 +356,7 @@ export function archivosDelRepo(avisar) {
             const dir = dirname(p);
             mkdirSync(dir, { recursive: true });
             if (carpetaPropia(dir) !== "propia")
-                throw new Error(`${dir} no es una carpeta común`);
+                throw new Error(`${dir} isn't a regular folder`);
             const tmp = join(dir, `.${basename(p)}.${randomUUID()}.tmp`);
             try {
                 const fd = openSync(tmp, "wx", 0o644);
@@ -466,7 +467,7 @@ export function entornoReal(env = process.env) {
         guia: {
             ...configurarEnElMotor,
             leerArchivoChico, fetch, gitDeclarado: gitRapido,
-            revisar: revisarGuia, publicar: publicarGuia, ver: leerGuia, elegir: elegirOrigen,
+            revisar: revisarGuia, publicar: publicarGuia, ver: leerGuia, elegir: elegirOrigen, versiones: leerVersionesDeLaGuia,
         },
         claves: {
             ...configurarEnElMotor,
@@ -483,7 +484,7 @@ export function entornoReal(env = process.env) {
         // para lo que la terminal dice de sí misma.
         instalacion: {
             ...configurarEnElMotor,
-            leerArchivoChico, rutaReal: rutaRealOEnNada, esCarpeta: esCarpetaReal,
+            leerArchivoChico, rutaReal: rutaRealOEnNada, esCarpeta: esCarpetaReal, esEnlace: esEnlaceReal,
             escribir: archivosDelRepo(avisar).escribir,
             terminal: DESCRIPCION.version,
         },

package/dist/flags-por-comando.js

@@ -1,30 +1,34 @@
 // Qué comandos aceptan cada flag que no es global. Un flag que no aplica sale 3 en vez de ignorarse:
-// un asistente que pasa `--repo` a `quien-soy` creería que preguntó por ese repo. Vive aparte de
-// `cli.ts` (que corre al importarse) para poder probarse sin lanzar el binario.
+// un asistente que pasa `--repo` a `whoami` creería que preguntó por ese repo. Vive aparte de
+// `cli.ts` (que corre al importarse) para poder probarse sin lanzar el binario. Los nombres de los
+// campos son los de `Flags`; los textos nombran los flags y comandos canónicos.
 const DE_CONFIGURAR_CON_REPO = [
-    "configuracion", "chat prender", "chat apagar", "chat marca", "chat logo", "sitios agregar", "sitios quitar",
-    "datos fijar", "politica fijar", "claves crear", "claves listar", "claves revocar",
-    "guia revisar", "guia publicar", "guia ver", "guia usar",
+    "config", "chat on", "chat off", "chat brand", "chat logo", "sites add", "sites remove",
+    "data set", "policy set", "keys create", "keys list", "keys revoke",
+    "guide check", "guide publish", "guide show", "guide use", "guide versions",
 ];
 export const FLAGS_POR_COMANDO = [
-    { flags: ["start"], comandos: ["login", "repo conectar"], texto: "--start es de `supcoflow login` y `supcoflow repo conectar`." },
-    { flags: ["wait"], comandos: ["login", "repo conectar", "probar"], texto: "--wait es de `supcoflow login`, `supcoflow repo conectar` y `supcoflow probar`." },
+    { flags: ["start"], comandos: ["login", "repo connect"], texto: "--start belongs to `supcoflow login` and `supcoflow repo connect`." },
+    { flags: ["wait"], comandos: ["login", "repo connect", "test"], texto: "--wait belongs to `supcoflow login`, `supcoflow repo connect` and `supcoflow test`." },
     {
-        flags: ["repo"], comandos: ["repo conectar", "proyecto crear", "proyecto ver", ...DE_CONFIGURAR_CON_REPO, "widget", "instalacion anotar", "diagnosticar", "probar"],
-        texto: "--repo es de `supcoflow repo conectar`, `proyecto crear|ver`, `widget`, `instalacion anotar`, `diagnosticar`, `probar` y los comandos que configuran un proyecto (no de `catalogo`).",
+        flags: ["repo"], comandos: ["repo connect", "project create", "project show", ...DE_CONFIGURAR_CON_REPO, "widget", "install record", "diagnose", "test"],
+        texto: "--repo belongs to `supcoflow repo connect`, `project create|show`, `widget`, `install record`, `diagnose`, `test` and the commands that configure a project (not to `catalog`).",
     },
-    { flags: ["install", "test"], comandos: ["proyecto crear"], texto: "--install y --test son de `supcoflow proyecto crear`." },
-    { flags: ["sitio"], comandos: ["sitios agregar", "sitios quitar"], texto: "--sitio es de `supcoflow sitios agregar|quitar`." },
-    { flags: ["titulo", "saludo", "tema"], comandos: ["chat marca"], texto: "--titulo, --saludo y --tema son de `supcoflow chat marca`." },
-    { flags: ["archivo"], comandos: ["chat logo"], texto: "--archivo es de `supcoflow chat logo`." },
-    { flags: ["permitir"], comandos: ["datos fijar"], texto: "--permitir es de `supcoflow datos fijar`." },
-    { flags: ["modo"], comandos: ["politica fijar"], texto: "--modo es de `supcoflow politica fijar`." },
-    { flags: ["nombre", "guardarEn"], comandos: ["claves crear"], texto: "--nombre y --guardar-en son de `supcoflow claves crear`." },
-    { flags: ["origen"], comandos: ["guia usar"], texto: "--origen es de `supcoflow guia usar`." },
-    { flags: ["desdeGithub"], comandos: ["guia publicar"], texto: "--desde-github es de `supcoflow guia publicar`." },
-    { flags: ["id"], comandos: ["claves revocar"], texto: "--id es de `supcoflow claves revocar`." },
-    { flags: ["autorizoGasto", "mensaje", "prueba"], comandos: ["probar"], texto: "--autorizo-gasto, --mensaje y --prueba son de `supcoflow probar`." },
-    { flags: ["skill", "app"], comandos: ["instalacion anotar"], texto: "--skill y --app son de `supcoflow instalacion anotar`." },
+    { flags: ["install", "test"], comandos: ["project create"], texto: "--install and --test belong to `supcoflow project create`." },
+    { flags: ["site"], comandos: ["sites add", "sites remove"], texto: "--site belongs to `supcoflow sites add|remove`." },
+    { flags: ["title", "greeting", "theme"], comandos: ["chat brand"], texto: "--title, --greeting and --theme belong to `supcoflow chat brand`." },
+    { flags: ["file"], comandos: ["chat logo", "install record"], texto: "--file belongs to `supcoflow chat logo` and `supcoflow install record`." },
+    { flags: ["allow"], comandos: ["data set"], texto: "--allow belongs to `supcoflow data set`." },
+    { flags: ["mode"], comandos: ["policy set"], texto: "--mode belongs to `supcoflow policy set`." },
+    { flags: ["name", "saveTo"], comandos: ["keys create"], texto: "--name and --save-to belong to `supcoflow keys create`." },
+    { flags: ["source"], comandos: ["guide use"], texto: "--source belongs to `supcoflow guide use`." },
+    { flags: ["fromGithub"], comandos: ["guide publish"], texto: "--from-github belongs to `supcoflow guide publish`." },
+    { flags: ["id"], comandos: ["keys revoke"], texto: "--id belongs to `supcoflow keys revoke`." },
+    {
+        flags: ["authorizeSpend", "ceiling", "expectPolicy", "message", "testId"], comandos: ["test"],
+        texto: "--authorize-spend, --ceiling, --expect-policy, --message and --test-id belong to `supcoflow test`.",
+    },
+    { flags: ["skill", "app"], comandos: ["install record"], texto: "--skill and --app belong to `supcoflow install record`." },
 ];
 /** El mensaje del primer flag presente que el comando no acepta, o null si todo aplica. */
 export function flagQueNoAplica(comando, presentes) {

package/dist/guardado/archivo.js

@@ -21,7 +21,7 @@ export function almacenDeArchivo(ruta, fs) {
             v = undefined;
         }
         if (typeof v !== "object" || v === null || Array.isArray(v)) {
-            throw new Error(`No entiendo el archivo de credenciales ${ruta}; borralo y volvé a iniciar sesión.`);
+            throw new Error(`I don't understand the credentials file ${ruta}; delete it and log in again.`);
         }
         return v;
     }
@@ -44,7 +44,7 @@ export function almacenDeArchivo(ruta, fs) {
                 return null;
             const r = t[cuenta];
             if (!esRegistro(r))
-                throw new Error(`No entiendo el archivo de credenciales ${ruta}; borralo y volvé a iniciar sesión.`);
+                throw new Error(`I don't understand the credentials file ${ruta}; delete it and log in again.`);
             return { valor: r.valor, escritoEn: r.escritoEn };
         },
         async escribir(cuenta, r) {

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}.`);
             }
         },
     };