supcoflow 0.7.0 → 0.8.0

package/dist/comandos/probar.js

@@ -1,4 +1,6 @@
 import { resultadoDeFallo, SALIDA } from "../contrato.js";
+import { agruparPuntos, contarBuenos, lineaDeLoRevisado, nombreDelPunto, puntoDeSesion, puntoDelRepo, TOTAL_DE_INSTALACION } from "../diagnostico.js";
+import { leerRepoLocal } from "../repo-local.js";
 import { PLAZO_MINIMO_DE_SONDEO_MS, TRAMO_MAXIMO_MS } from "../sondeo.js";
 import { fallo, rutaDe } from "./configurar.js";
 import { proyectoDelRepo } from "./proyecto-del-repo.js";
@@ -6,6 +8,7 @@ import { proyectoDelRepo } from "./proyecto-del-repo.js";
 // gastar un pedido (ni guardar un intento que el motor va a rechazar); la regla de verdad es la del motor.
 const MAX_MENSAJE = 20_000;
 const ID_DE_PRUEBA = /^prb_[0-9a-f]{16}$/;
+const TECHO = /^\d+(?:\.\d{1,4})?$/;
 const INTERVALO_DE_SEGUIMIENTO_MS = 5_000;
 const PLAZO_MAXIMO_DE_SONDEO_MS = 15_000;
 // La tabla de la prueba (brief M7, «los estados»): qué código sale en cada estado. Lo que no está acá es
@@ -16,7 +19,18 @@ const PIDEN_UNA_PERSONA = new Set([
     "issue_con_cierre_anomalo", "fallido", "cierre_sin_evidencia", "reclamado_sin_run", "arranque_incierto", "esperando_cupo", "sin_despacho",
 ]);
 const usd = (n) => `US$ ${n.toFixed(2)}`;
-const usdONull = (n) => (n === null ? "sin medir" : usd(n));
+const usdONull = (n) => (n === null ? "unmeasured" : usd(n));
+// La política como se dice en inglés; a la API siempre viaja la suya (`relevar` / `guardar`).
+const POLITICA_EN_INGLES = { relevar: "investigate", guardar: "save" };
+const enInglesLaPolitica = (p) => (p === null ? "none" : (POLITICA_EN_INGLES[p] ?? p));
+const aLaPoliticaDeLaApi = (p) => p === "investigate" || p === "relevar" ? "relevar" : p === "save" || p === "guardar" ? "guardar" : null;
+// El comando exacto para retomar un pedido guardado: con lo que se autorizó, no con lo que haya ahora. Un pedido SIN
+// política (lo guardó la 0.7.0, o se pidió con el alias viejo) sólo se retoma por el alias: el comando canónico exige
+// `--expect-policy` (3 falta_politica) y, con una política, ya no es el mismo pedido (4 intento_pendiente). No se inventa
+// una política para él: cambiaría su cuerpo y su clave.
+const comandoDeReintento = (i) => i.politicaEsperada === null
+    ? `supcoflow probar --autorizo-gasto --ceiling ${i.techoUsd}`
+    : `supcoflow test --authorize-spend --ceiling ${i.techoUsd} --expect-policy ${enInglesLaPolitica(i.politicaEsperada)}`;
 function datosDelDiagnostico(g) {
     return {
         listo: g.listo,
@@ -29,7 +43,7 @@ function datosDelDiagnostico(g) {
         prueba_abierta: g.pruebaAbierta,
     };
 }
-const lineasDePuntos = (g) => g.puntos.map((p) => `  [${p.ok ? "ok" : "falta"}] ${p.punto}: ${p.mensaje}`);
+const lineasDePuntos = (puntos, nombre = (p) => p) => puntos.map((p) => `  [${p.ok ? "ok" : "missing"}] ${nombre(p.punto)}: ${p.mensaje}`);
 export async function diagnosticar(d, flags) {
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
@@ -41,43 +55,99 @@ export async function diagnosticar(d, flags) {
     catch (e) {
         return resultadoDeFallo(e);
     }
-    const datos = { proyecto: { id: p.proyecto.id, repo: p.proyecto.repo }, ...datosDelDiagnostico(g) };
-    const resumen = `Saldo del mes ${usdONull(g.saldoUsd)} de ${usdONull(g.topeUsd)}; una prueba autoriza hasta ${usd(g.techoUsd)}. Política: ${g.politica}.`;
-    if (g.listo) {
-        return { codigo: SALIDA.ok, json: { ok: true, ...datos }, texto: [`Todo listo para probar ${p.proyecto.repo}.`, ...lineasDePuntos(g), resumen].join("\n") };
+    // Los dos puntos que sólo la terminal puede ver: la llamada de arriba autenticó (si no, no se llega acá) y el
+    // `origin` de esta carpeta es el repo del proyecto. Sin git o sin origin no se adivina: el punto sale no ok.
+    let local;
+    try {
+        local = await leerRepoLocal(d.git, d.cwd);
+    }
+    catch {
+        local = { repo: null, raiz: null, motivo: "sin_git" };
     }
-    const message = `Hay algo para arreglar antes de probar ${p.proyecto.repo}.`;
-    return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "no_listo", message, ...datos }, texto: [message, ...lineasDePuntos(g), resumen].join("\n") };
+    const { instalacion, prueba } = agruparPuntos(g, [puntoDeSesion(), puntoDelRepo(local, p.proyecto.repo)]);
+    const buenos = contarBuenos(instalacion);
+    const listo = g.listo && instalacion.every((x) => x.ok || !["sign-in", "repo"].includes(x.punto));
+    const datos = {
+        proyecto: { id: p.proyecto.id, repo: p.proyecto.repo },
+        ...datosDelDiagnostico(g),
+        listo,
+        puntos: [...instalacion, ...prueba],
+        instalacion: { ok: buenos, total: TOTAL_DE_INSTALACION, puntos: instalacion },
+        prueba: { listo: g.listo, puntos: prueba },
+    };
+    const resumen = `Monthly balance ${usdONull(g.saldoUsd)} of ${usdONull(g.topeUsd)}; a test authorizes up to ${usd(g.techoUsd)}. Policy: ${enInglesLaPolitica(g.politica)}.`;
+    const motivos = [
+        ...prueba.filter((x) => !x.ok).map((x) => x.mensaje),
+        ...(buenos < TOTAL_DE_INSTALACION ? [`the installation isn't complete (${buenos} of ${TOTAL_DE_INSTALACION})`] : []),
+    ];
+    const listaParaProbar = listo ? "Ready for a test: yes." : `Ready for a test: no, because ${motivos.join("; ") || "the engine says it isn't ready"}`;
+    const cuerpo = [
+        lineaDeLoRevisado(buenos),
+        ...lineasDePuntos(instalacion, nombreDelPunto),
+        listaParaProbar,
+        ...lineasDePuntos(prueba),
+        resumen,
+    ];
+    if (listo)
+        return { codigo: SALIDA.ok, json: { ok: true, ...datos }, texto: cuerpo.join("\n") };
+    const message = `Something needs fixing before testing ${p.proyecto.repo}.`;
+    return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "no_listo", message, ...datos }, texto: [message, ...cuerpo].join("\n") };
 }
 export async function probar(d, flags) {
     // El reloj del tramo arranca con el comando: los 90 s son del comando entero, no sólo de los sondeos.
     const inicio = d.ahora();
     // Todo lo que se puede rechazar sin mirar nada, antes de tocar el motor o lo guardado.
-    if (flags.wait && (flags.autorizoGasto || flags.mensaje !== null)) {
-        return fallo(SALIDA.entradaInvalida, "flags_incompatibles", "`probar --wait` sólo sigue una prueba: sin --autorizo-gasto ni --mensaje. Primero `supcoflow probar --autorizo-gasto` y después `supcoflow probar --wait`.");
+    if (flags.wait && (flags.authorizeSpend || flags.message !== null || flags.ceiling !== null || flags.expectPolicy !== null)) {
+        return fallo(SALIDA.entradaInvalida, "flags_incompatibles", "`test --wait` only follows a test: no --authorize-spend, --ceiling, --expect-policy or --message. First `supcoflow test --authorize-spend --ceiling <usd> --expect-policy <policy>`, then `supcoflow test --wait`.");
+    }
+    if (!flags.wait && flags.testId !== null) {
+        return fallo(SALIDA.entradaInvalida, "flags_incompatibles", "--test-id goes with --wait: `supcoflow test --wait --test-id prb_…`.");
     }
-    if (!flags.wait && flags.prueba !== null) {
-        return fallo(SALIDA.entradaInvalida, "flags_incompatibles", "--prueba va con --wait: `supcoflow probar --wait --prueba prb_…`.");
+    if (!flags.authorizeSpend && !flags.wait && (flags.ceiling !== null || flags.expectPolicy !== null)) {
+        return fallo(SALIDA.entradaInvalida, "flags_incompatibles", "--ceiling and --expect-policy go with --authorize-spend: they say what you authorize.");
     }
-    if (flags.prueba !== null && !ID_DE_PRUEBA.test(flags.prueba)) {
-        return fallo(SALIDA.entradaInvalida, "prueba_invalida", "--prueba es el id que dio `supcoflow probar` (prb_ y 16 caracteres).");
+    if (flags.testId !== null && !ID_DE_PRUEBA.test(flags.testId)) {
+        return fallo(SALIDA.entradaInvalida, "prueba_invalida", "--test-id is the id `supcoflow test` printed (prb_ and 16 characters).");
     }
     let mensaje = null;
-    if (flags.mensaje !== null) {
-        mensaje = flags.mensaje.trim();
+    if (flags.message !== null) {
+        mensaje = flags.message.trim();
         if (mensaje.length === 0 || mensaje.length > MAX_MENSAJE) {
-            return fallo(SALIDA.entradaInvalida, "mensaje_invalido", `--mensaje va con texto, hasta ${MAX_MENSAJE} caracteres.`);
+            return fallo(SALIDA.entradaInvalida, "mensaje_invalido", `--message goes with text, up to ${MAX_MENSAJE} characters.`);
         }
     }
+    // Lo que la persona autorizó: el techo y la política que vio. Sin eso no hay pedido que valga (R5).
+    let autorizado = null;
+    if (flags.authorizeSpend) {
+        if (flags.ceiling === null) {
+            const comoSeEscribe = "`supcoflow test --authorize-spend --ceiling <usd> --expect-policy investigate|save`";
+            return fallo(SALIDA.entradaInvalida, "falta_techo", flags.viejo === true
+                ? `\`probar --autorizo-gasto\` now needs --ceiling <usd>, the number you were shown: an alias can't widen what you authorized. Use ${comoSeEscribe}. (The old behaviour is in supcoflow 0.7.0.)`
+                : `--authorize-spend needs --ceiling <usd>, the number you were shown: ${comoSeEscribe}.`);
+        }
+        if (!TECHO.test(flags.ceiling) || !(Number(flags.ceiling) > 0)) {
+            return fallo(SALIDA.entradaInvalida, "techo_invalido", "--ceiling is a positive number of US dollars, for example 2 or 2.50.");
+        }
+        let politicaEsperada = null;
+        if (flags.expectPolicy !== null) {
+            politicaEsperada = aLaPoliticaDeLaApi(flags.expectPolicy);
+            if (politicaEsperada === null)
+                return fallo(SALIDA.entradaInvalida, "politica_invalida", "--expect-policy is `investigate` or `save`.");
+        }
+        else if (flags.viejo !== true) {
+            return fallo(SALIDA.entradaInvalida, "falta_politica", "--authorize-spend needs --expect-policy investigate|save: the policy you were offered, so a yes to a test that won't investigate can't turn into a paid one.");
+        }
+        autorizado = { techoUsd: Number(flags.ceiling), politicaEsperada };
+    }
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
         return p.resultado;
     const proyecto = p.proyecto;
     const clave = p.clave;
     if (flags.wait)
-        return seguir(d, clave, proyecto.id, flags.prueba, inicio);
+        return seguir(d, clave, proyecto.id, flags.testId, inicio);
     // ── Sin el flag, o con --dry-run: sólo el diagnóstico (gratis). Nada que escriba, ni acá ni en el motor.
-    if (!flags.autorizoGasto || flags.dryRun) {
+    if (autorizado === null || flags.dryRun) {
         let g;
         try {
             g = await d.leerDiagnostico(d.api, clave, proyecto.id);
@@ -87,8 +157,8 @@ export async function probar(d, flags) {
         }
         const datos = { proyecto: { id: proyecto.id, repo: proyecto.repo }, ...datosDelDiagnostico(g) };
         const gasto = g.politica === "guardar"
-            ? `Con la política \`guardar\` la prueba llega hasta el caso guardado y no gasta; el techo que se autoriza igual es ${usd(g.techoUsd)}.`
-            : `Una prueba corre un relevamiento que gasta hasta ${usd(g.techoUsd)} (saldo del mes ${usdONull(g.saldoUsd)} de ${usdONull(g.topeUsd)}).`;
+            ? `With the \`save\` policy the test goes as far as the saved case and spends nothing; the ceiling it authorizes is still ${usd(g.techoUsd)}.`
+            : `A test runs an investigation that spends up to ${usd(g.techoUsd)} (monthly balance ${usdONull(g.saldoUsd)} of ${usdONull(g.topeUsd)}).`;
         if (flags.dryRun) {
             // Lo guardado se mira sólo para decir qué haría; si no se puede leer, el dry-run igual contesta.
             let pendiente = null;
@@ -99,37 +169,39 @@ export async function probar(d, flags) {
                 pendiente = null;
             }
             const ruta = rutaDe(proyecto, "/pruebas");
+            const cuerpo = autorizado === null ? `techo_usd: ${g.techoUsd}` : `techo_usd: ${autorizado.techoUsd}${autorizado.politicaEsperada !== null ? `, politica_esperada: ${autorizado.politicaEsperada}` : ""}`;
             const haria = pendiente
-                ? `reenviaría el pedido guardado sin confirmar (POST ${ruta}, la misma Idempotency-Key)`
-                : `POST ${ruta} {techo_usd: ${g.techoUsd}${mensaje !== null ? ", mensaje" : ""}} con una Idempotency-Key nueva`;
+                ? `would resend the saved request that was never confirmed (POST ${ruta}, the same Idempotency-Key)`
+                : `would send POST ${ruta} {${cuerpo}${mensaje !== null ? ", mensaje" : ""}} with a new Idempotency-Key`;
             return {
                 codigo: SALIDA.ok,
-                json: { ok: true, dry_run: true, autorizado: flags.autorizoGasto, intento_pendiente: pendiente, haria, ...datos },
-                texto: `Con --dry-run no hago nada. ${flags.autorizoGasto ? "Sin --dry-run" : "Con --autorizo-gasto y sin --dry-run"}: ${haria} (proyecto ${proyecto.repo}, política ${g.politica}). ${gasto}`,
+                json: { ok: true, dry_run: true, autorizado: flags.authorizeSpend, intento_pendiente: pendiente, haria, ...datos },
+                texto: `With --dry-run I do nothing. ${flags.authorizeSpend ? "Without --dry-run, I" : "With --authorize-spend and without --dry-run, I"}${haria.replace(/^would/, "")} (project ${proyecto.repo}, policy ${enInglesLaPolitica(g.politica)}). ${gasto}`,
             };
         }
-        const message = `${gasto} Para lanzarla: \`supcoflow probar --autorizo-gasto\`. Antes, \`supcoflow diagnosticar\` dice si está todo listo.`;
+        const lanzar = `supcoflow test --authorize-spend --ceiling ${g.techoUsd} --expect-policy ${enInglesLaPolitica(g.politica)}`;
+        const message = `${gasto} To launch it: \`${lanzar}\`. \`supcoflow diagnose\` first says whether everything is ready.`;
         return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "falta_autorizacion", message, ...datos }, texto: message };
     }
-    // ── Con --autorizo-gasto: el ciclo de la clave.
+    // ── Con --authorize-spend: el ciclo de la clave.
     let intento;
     try {
         const guardado = await d.pruebas.leer(proyecto.id);
         if (guardado.intento !== null) {
-            if (mensaje !== null && mensaje !== guardado.intento.mensaje) {
-                return fallo(SALIDA.haceFaltaUnaPersona, "intento_pendiente", "Hay una prueba pedida sin confirmar; repetí `supcoflow probar --autorizo-gasto` sin `--mensaje` para recuperarla.");
+            const previo = guardado.intento;
+            const igual = Math.abs(previo.techoUsd - autorizado.techoUsd) < 1e-9 && previo.politicaEsperada === autorizado.politicaEsperada;
+            if (mensaje !== null && mensaje !== previo.mensaje) {
+                return fallo(SALIDA.haceFaltaUnaPersona, "intento_pendiente", `There's a test request waiting for confirmation; repeat \`${comandoDeReintento(previo)}\` without --message to recover it.`);
+            }
+            if (!igual) {
+                return fallo(SALIDA.haceFaltaUnaPersona, "intento_pendiente", `There's a test request waiting for confirmation, authorized with a ceiling of ${usd(previo.techoUsd)}; repeat it with exactly that to recover it: \`${comandoDeReintento(previo)}\`.`);
             }
-            intento = guardado.intento;
+            intento = previo;
         }
         else {
-            // El techo que se autoriza es el que dice el motor ahora (D6), no uno escrito en la terminal.
-            const g = await d.leerDiagnostico(d.api, clave, proyecto.id);
-            if (g.pruebaAbierta !== null)
-                return enCurso(g.pruebaAbierta);
-            // No frena (el motor decide lo que acepta), pero quien autorizó tiene que ver lo que falta.
-            for (const punto of g.puntos.filter((x) => !x.ok))
-                d.avisar(`Aviso (${punto.punto}): ${punto.mensaje}`);
-            intento = { clave: d.generar(), mensaje, techoUsd: g.techoUsd };
+            // Lo que se manda es lo que la persona vio (R5): no se relee el diagnóstico para elegirlo. El motor compara
+            // el techo y la política con los de ahora y rechaza si cambiaron.
+            intento = { clave: d.generar(), mensaje, techoUsd: autorizado.techoUsd, politicaEsperada: autorizado.politicaEsperada };
             await d.pruebas.abrir(proyecto.id, intento);
         }
     }
@@ -142,17 +214,17 @@ export async function probar(d, flags) {
             await d.pruebas.confirmar(proyecto.id, r.pruebaId);
         }
         catch {
-            const message = `El motor aceptó la prueba ${r.pruebaId}, pero no pude guardarla en esta máquina. Repetí \`supcoflow probar --autorizo-gasto\` (recupera la misma) o seguila con \`supcoflow probar --wait --prueba ${r.pruebaId}\`.`;
+            const message = `The engine accepted test ${r.pruebaId}, but I couldn't save it on this machine. Repeat \`${comandoDeReintento(intento)}\` (it recovers the same one) or follow it with \`supcoflow test --wait --test-id ${r.pruebaId}\`.`;
             return { codigo: SALIDA.inesperado, json: { ok: false, error: "prueba_no_guardada", message, prueba_id: r.pruebaId, intento_pendiente: true }, texto: message };
         }
         return {
             codigo: SALIDA.esperandoAUnaPersona,
             json: { ok: false, esperando: "relevamiento", prueba_id: r.pruebaId, reporte_id: r.reporteId, estado: r.estado },
-            texto: `Prueba ${r.pruebaId} pedida (${r.estado}). Seguila con \`supcoflow probar --wait\`.`,
+            texto: `Test ${r.pruebaId} requested (${r.estado}). Follow it with \`supcoflow test --wait\`.`,
         };
     }
     if (r.tipo === "ambigua") {
-        const message = `${r.message} El pedido quedó guardado: repetí \`supcoflow probar --autorizo-gasto\` y retomo la misma prueba, sin pedir otra.`;
+        const message = `${r.message} The request was saved: repeat \`${comandoDeReintento(intento)}\` and I'll pick up the same test, without asking for another.`;
         return { codigo: SALIDA.inesperado, json: { ok: false, error: r.error, message, intento_pendiente: true }, texto: message };
     }
     // Un rechazo definitivo: el motor no creó nada con esta clave, así que el intento se cierra.
@@ -160,22 +232,29 @@ export async function probar(d, flags) {
         await d.pruebas.descartar(proyecto.id);
     }
     catch {
-        d.avisar("No pude cerrar el pedido guardado; el próximo `probar --autorizo-gasto` lo va a reenviar.");
+        d.avisar("I couldn't close the saved request; the next `test --authorize-spend` will resend it.");
     }
-    return rechazo(r, d.avisar);
+    return rechazo(r, intento, d.avisar);
 }
 function enCurso(pruebaId) {
-    const message = `Ya hay una prueba de este proyecto sin desenlace (${pruebaId}). Seguila con \`supcoflow probar --wait --prueba ${pruebaId}\`.`;
+    const message = `This project already has a test with no outcome (${pruebaId}). Follow it with \`supcoflow test --wait --test-id ${pruebaId}\`.`;
     return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "prueba_en_curso", message, prueba_id: pruebaId }, texto: message };
 }
-function rechazo(r, avisar) {
+function rechazo(r, intento, avisar) {
     const c = r.cuerpo;
     switch (r.error) {
         case "prueba_en_curso":
             return typeof c.prueba_id === "string" ? enCurso(c.prueba_id) : fallo(SALIDA.haceFaltaUnaPersona, r.error, r.message);
         case "techo_distinto": {
-            const message = `${r.message} Volvé a correr \`supcoflow probar\` para ver el techo vigente y autorizalo.`;
-            return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: r.error, message, techo_usd: c.techo_usd ?? null }, texto: message };
+            // Sin reintentar: lo que se autorizó ya no es lo que hay, y decidir de nuevo es de la persona (con el número nuevo).
+            const nuevo = typeof c.techo_usd === "number" ? c.techo_usd : null;
+            const message = `The ceiling for a test changed${nuevo !== null ? `: it's now ${usd(nuevo)}` : ""}, and you authorized ${usd(intento.techoUsd)}. Nothing was started. Ask again with the new number.`;
+            return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: r.error, message, techo_usd: nuevo, autorizado_usd: intento.techoUsd }, texto: message };
+        }
+        case "politica_distinta": {
+            const ahora = typeof c.politica === "string" ? c.politica : typeof c.politica_actual === "string" ? c.politica_actual : null;
+            const message = `The project's policy changed${ahora !== null ? `: it's now \`${enInglesLaPolitica(ahora)}\`` : ""}, and you authorized a test under \`${enInglesLaPolitica(intento.politicaEsperada)}\`. Nothing was started. Ask again with the current policy.`;
+            return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: r.error, message, politica: ahora, politica_esperada: intento.politicaEsperada }, texto: message };
         }
         case "tope_mensual":
             return {
@@ -184,13 +263,13 @@ function rechazo(r, avisar) {
                 texto: r.message,
             };
         case "requiere_api_key": {
-            const message = `La prueba se pide con tu API key personal (la que deja \`supcoflow login\`), no con una clave de consulta ni con la sesión de la consola. ${r.message}`;
+            const message = `The test is requested with your personal API key (the one \`supcoflow login\` leaves), not with a read-only key or the console session. ${r.message}`;
             return fallo(SALIDA.haceFaltaUnaPersona, r.error, message);
         }
         case "idempotency_key_reusada":
             // No debería pasar: siempre se reenvía lo guardado con su clave. Si pasa, la clave ya no sirve.
-            avisar("El motor dice que la clave del pedido ya se usó con otro contenido; la descarté.");
-            return fallo(SALIDA.inesperado, r.error, `${r.message} Volvé a correr \`supcoflow probar --autorizo-gasto\` para pedir una prueba nueva.`);
+            avisar("The engine says this request's key was already used with other content; I discarded it.");
+            return fallo(SALIDA.inesperado, r.error, `${r.message} Run \`${comandoDeReintento(intento)}\` again to ask for a new test.`);
     }
     if (r.status === 401)
         return fallo(SALIDA.faltaLogin, "clave_invalida", r.message);
@@ -201,14 +280,14 @@ function rechazo(r, avisar) {
 function textoDelCobro(c) {
     // Pendiente y perdido nunca se muestran como cero: el monto todavía no se sabe, la cota es el techo.
     if (c.estado === "leido" && c.usd !== null)
-        return `Costo: ${usd(c.usd)}.`;
+        return `Cost: ${usd(c.usd)}.`;
     if (c.estado === "pendiente")
-        return `Cobro pendiente: se lee unos minutos después del cierre (hasta ${usd(c.techo_usd)}).`;
+        return `Charge pending: it's read a few minutes after the run closes (up to ${usd(c.techo_usd)}).`;
     if (c.estado === "perdido")
-        return `Cobro perdido: no se pudo leer el gasto (hasta ${usd(c.techo_usd)}).`;
+        return `Charge lost: the spend couldn't be read (up to ${usd(c.techo_usd)}).`;
     if (c.estado === null)
         return null;
-    return `Cobro: ${c.estado} (hasta ${usd(c.techo_usd)}).`;
+    return `Charge: ${c.estado} (up to ${usd(c.techo_usd)}).`;
 }
 function resultadoDelSeguimiento(s) {
     const datos = {
@@ -216,24 +295,24 @@ function resultadoDelSeguimiento(s) {
         reporte: s.reporte, run: s.run, issue: s.issue, cobro: s.cobro,
     };
     const lineas = [
-        `Prueba ${s.pruebaId}: ${s.estado}.${s.mensaje ? ` ${s.mensaje}` : ""}`,
+        `Test ${s.pruebaId}: ${s.estado}.${s.mensaje ? ` ${s.mensaje}` : ""}`,
         s.issue ? `Issue #${s.issue.numero}: ${s.issue.url}` : null,
-        s.run?.motivo ? `Motivo del run: ${s.run.motivo}` : null,
+        s.run?.motivo ? `Run reason: ${s.run.motivo}` : null,
         textoDelCobro(s.cobro),
     ];
     if (ABIERTOS.has(s.estado)) {
-        lineas.push("Volvé a correr `supcoflow probar --wait`.");
+        lineas.push("Run `supcoflow test --wait` again.");
         return { codigo: SALIDA.esperandoAUnaPersona, json: { ok: false, esperando: "relevamiento", ...datos }, texto: lineas.filter(Boolean).join("\n") };
     }
     if (CON_DESENLACE_OK.has(s.estado))
         return { codigo: SALIDA.ok, json: { ok: true, ...datos }, texto: lineas.filter(Boolean).join("\n") };
     if (PIDEN_UNA_PERSONA.has(s.estado)) {
         if (s.reporte)
-            lineas.push(`El caso en la consola: ${s.reporte.url}`);
+            lineas.push(`The case in the console: ${s.reporte.url}`);
         const texto = lineas.filter(Boolean).join("\n");
         return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: s.estado, message: s.mensaje ?? texto, ...datos }, texto };
     }
-    const message = `El motor dice que la prueba está en «${s.estado}», un estado que esta versión de la terminal no conoce. Actualizá supcoflow o mirala en la consola.`;
+    const message = `The engine says the test is in «${s.estado}», a state this version of the terminal doesn't know. Update supcoflow or look at it in the console.`;
     return { codigo: SALIDA.inesperado, json: { ok: false, error: "estado_desconocido", message, ...datos }, texto: message };
 }
 async function seguir(d, clave, proyectoId, elegida, inicio) {
@@ -242,17 +321,17 @@ async function seguir(d, clave, proyectoId, elegida, inicio) {
         try {
             const g = await d.pruebas.leer(proyectoId);
             // Un pedido sin confirmar gana sobre la última: seguir la anterior y salir 0 con SU issue se leería
-            // como el desenlace de la prueba recién pedida. Con `--prueba` explícito no se llega acá.
+            // como el desenlace de la prueba recién pedida. Con `--test-id` explícito no se llega acá.
             pruebaId = g.ultima;
             if (g.intento !== null) {
-                return fallo(SALIDA.haceFaltaUnaPersona, "intento_pendiente", "Hay una prueba pedida sin confirmar; repetí `supcoflow probar --autorizo-gasto` sin `--mensaje` para recuperarla, y después `--wait`.");
+                return fallo(SALIDA.haceFaltaUnaPersona, "intento_pendiente", `There's a test request waiting for confirmation; repeat \`${comandoDeReintento(g.intento)}\` without --message to recover it, and then \`--wait\`.`);
             }
         }
         catch (e) {
             return resultadoDeFallo(e);
         }
         if (pruebaId === null) {
-            return fallo(SALIDA.entradaInvalida, "sin_prueba", "No hay una prueba guardada en esta máquina para este proyecto: pedila con `supcoflow probar --autorizo-gasto`, o pasá `--prueba prb_…`.");
+            return fallo(SALIDA.entradaInvalida, "sin_prueba", "There's no saved test on this machine for this project: request one with `supcoflow test --authorize-spend --ceiling <usd> --expect-policy <policy>`, or pass `--test-id prb_…`.");
         }
     }
     // Se aparta lo que puede tardar un sondeo forzado (el primero siempre va, aunque quede poco): así el

package/dist/comandos/proyecto-del-repo.js

@@ -15,7 +15,7 @@ export async function proyectoDelRepo(d, flags) {
     try {
         const proyecto = await d.buscarProyecto(d.api, leida.vigente.clave, repo);
         if (proyecto === null) {
-            const message = `El repo ${repo} todavía no tiene proyecto. Creá el proyecto: \`supcoflow proyecto crear\`.`;
+            const message = `The repo ${repo} doesn't have a project yet. Create the project: \`supcoflow project create\`.`;
             return { ok: false, resultado: { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "sin_proyecto", message, repo }, texto: message } };
         }
         return { ok: true, clave: leida.vigente.clave, proyecto };

package/dist/comandos/proyecto.js

@@ -52,7 +52,7 @@ function mismoArchivo(crudo, p) {
 }
 function resultadoDelProyecto(p, reusado, raiz, d) {
     const nuevo = { id: p.id, slug: p.slug, repo: p.repo };
-    const queda = reusado ? `El proyecto ${p.id} ya existía y lo reusé` : `Creé el proyecto ${p.id}`;
+    const queda = reusado ? `Project ${p.id} already existed and I reused it` : `I created project ${p.id}`;
     let archivo = null;
     if (raiz !== null) {
         archivo = path.join(raiz, ".supcoflow", "proyecto.json");
@@ -63,8 +63,8 @@ function resultadoDelProyecto(p, reusado, raiz, d) {
             // decida. Su contenido NUNCA se copia a la salida (puede traer cualquier cosa, una clave
             // incluida, y `emitir` no sanea): sólo el id, si tiene forma de id.
             const idActual = idDelArchivo(actual);
-            const message = `Ya hay un \`.supcoflow/proyecto.json\` de otro proyecto (${idActual ?? "que no reconozco"}); no lo toqué. `
-                + `${queda} igual (${p.id}): si es el que querés, borrá el archivo y volvé a correr \`supcoflow proyecto crear\`.`;
+            const message = `There is already a \`.supcoflow/proyecto.json\` for another project (${idActual ?? "one I don't recognize"}); I didn't touch it. `
+                + `${queda} anyway: if that's the one you want, delete the file and run \`supcoflow project create\` again.`;
             return fallo(SALIDA.haceFaltaUnaPersona, "archivo_distinto", message, { archivo, id_actual: idActual, nuevo, reusado });
         }
         if (actual === null) {
@@ -72,7 +72,7 @@ function resultadoDelProyecto(p, reusado, raiz, d) {
                 d.archivos.escribir(archivo, contenidoDelArchivo(p));
             }
             catch {
-                const message = `${queda} (${p.id}), pero no pude escribir ${archivo}. Volvé a correr \`supcoflow proyecto crear\`.`;
+                const message = `${queda}, but I couldn't write ${archivo}. Run \`supcoflow project create\` again.`;
                 return fallo(SALIDA.inesperado, "archivo_no_escrito", message, { archivo, nuevo, reusado });
             }
         }
@@ -80,7 +80,7 @@ function resultadoDelProyecto(p, reusado, raiz, d) {
     return {
         codigo: SALIDA.ok,
         json: { ok: true, proyecto: { id: p.id, slug: p.slug, repo: p.repo, rama: p.rama }, reusado, archivo },
-        texto: `${queda}: ${p.repo}, rama ${p.rama}.${archivo !== null ? ` Lo anoté en ${archivo}.` : ""}`,
+        texto: `${queda}: ${p.repo}, branch ${p.rama}.${archivo !== null ? ` Recorded in ${archivo}.` : ""}`,
     };
 }
 export async function proyectoCrear(d, flags) {
@@ -116,18 +116,18 @@ export async function proyectoCrear(d, flags) {
         if (flags.install !== null || flags.test !== null) {
             // Sin copiar los valores: son texto del usuario y el aviso sólo dice qué pasó con ellos. Callarlo
             // haría creer que el proyecto quedó con los comandos pedidos.
-            d.avisar("El proyecto ya existe: ignoré --install/--test. Para cambiar sus comandos hay que configurarlo.");
+            d.avisar("The project already exists: I ignored --install/--test. To change its commands, it has to be configured.");
         }
         return resultadoDelProyecto(existente, true, raiz, d);
     }
     if (conexion === null || conexion.estado !== "conectado") {
-        return fallo(SALIDA.haceFaltaUnaPersona, "repo_sin_conectar", "Conectá el repo primero: `supcoflow repo conectar`.", {
+        return fallo(SALIDA.haceFaltaUnaPersona, "repo_sin_conectar", "Connect the repo first: `supcoflow repo connect`.", {
             repo, ...(conexion !== null ? { estado: conexion.estado } : {}),
         });
     }
     if (flags.dryRun) {
         const haria = `POST /api/conexiones/${conexion.id}/proyecto`;
-        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, repo, haria }, texto: `Con --dry-run no hago nada; sin él, crearía el proyecto de ${repo} (${haria}).` };
+        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, repo, haria }, texto: `With --dry-run I do nothing; without it: create the project for ${repo} (${haria}).` };
     }
     const cuerpo = {};
     if (flags.install !== null)
@@ -153,27 +153,27 @@ export async function proyectoCrear(d, flags) {
             await d.idempotencia.olvidar(OPERACION, repo);
             const install = flags.install ?? "…";
             const test = flags.test ?? "…";
-            const message = `${alta.message || "Faltan comandos del proyecto."} Pasalos a mano: \`supcoflow proyecto crear --install ${comillas(install)} --test ${comillas(test)}\`.`;
+            const message = `${alta.message || "The project is missing commands."} Pass them yourself: \`supcoflow project create --install ${comillas(install)} --test ${comillas(test)}\`.`;
             return fallo(SALIDA.entradaInvalida, "comandos_faltantes", message, { faltantes: alta.faltantes });
         }
         case "no_conectada":
             await d.idempotencia.olvidar(OPERACION, repo);
-            return fallo(SALIDA.haceFaltaUnaPersona, "repo_sin_conectar", alta.message || "Conectá el repo primero: `supcoflow repo conectar`.", { repo });
+            return fallo(SALIDA.haceFaltaUnaPersona, "repo_sin_conectar", alta.message || "Connect the repo first: `supcoflow repo connect`.", { repo });
         case "en_curso":
             // Se conserva: el pedido en curso puede ser el nuestro y el reintento tiene que poder retomarlo.
-            return fallo(SALIDA.inesperado, "en_curso", "Otro pedido con esta clave está en curso; probá en un minuto.");
+            return fallo(SALIDA.inesperado, "en_curso", "Another request with this key is already in progress; try again in a minute.");
         case "clave_reusada":
             // No debería pasar (la clave es por repo y un reintento manda lo mismo); olvidarla deja reintentar limpio.
             await d.idempotencia.olvidar(OPERACION, repo);
-            return fallo(SALIDA.inesperado, "clave_reusada", "El motor rechazó la clave de idempotencia guardada; la descarté, probá de nuevo.");
+            return fallo(SALIDA.inesperado, "clave_reusada", "The engine rejected the saved idempotency key; I discarded it, try again.");
         case "rechazo": {
             // La clave se conserva: tras un rechazo el motor ya la soltó, y el próximo intento la reusa sin
             // chocar. Lo que cambia es el código: no todo rechazo es culpa de lo que se escribió.
-            const message = alta.message || "El motor rechazó el pedido.";
+            const message = alta.message || "The engine rejected the request.";
             if (RECHAZOS_DE_UNA_PERSONA.has(alta.error)) {
                 // Lo arregla alguien con permisos en GitHub (instalar la App, sumarle el repo): reintentar o
                 // cambiar flags no sirve, y un 3 haría que un asistente siguiera probando entradas.
-                return fallo(SALIDA.haceFaltaUnaPersona, alta.error, `${message} Revisá la instalación de la App en GitHub y volvé a conectar con \`supcoflow repo conectar\`.`);
+                return fallo(SALIDA.haceFaltaUnaPersona, alta.error, `${message} Check the App's installation on GitHub and connect again with \`supcoflow repo connect\`.`);
             }
             // Dos altas al mismo tiempo, o un proyecto borrado en el medio: el mismo pedido otra vez anda.
             if (RECHAZOS_TRANSITORIOS.has(alta.error))
@@ -197,14 +197,14 @@ export async function proyectoVer(d, flags) {
     try {
         const encontrado = await d.buscarProyecto(d.api, clave, repo);
         if (encontrado === null) {
-            return { codigo: SALIDA.ok, json: { ok: true, repo, proyecto: null }, texto: "Este repo todavía no tiene proyecto: `supcoflow proyecto crear`." };
+            return { codigo: SALIDA.ok, json: { ok: true, repo, proyecto: null }, texto: "This repo doesn't have a project yet: `supcoflow project create`." };
         }
         const { proyecto: p, github } = await d.leerProyecto(d.api, clave, encontrado.id);
         const proyecto = { id: p.id, slug: p.slug, repo: p.repo, rama: p.rama, install_command: p.installCommand, test_command: p.testCommand };
         return {
             codigo: SALIDA.ok,
             json: { ok: true, proyecto, github: { estado: github.estado, verificado_en: github.verificadoEn } },
-            texto: `${p.id} (${p.repo}, rama ${p.rama}): instala con \`${p.installCommand}\`, prueba con \`${p.testCommand}\`. GitHub: ${github.estado ?? "sin verificar"}.`,
+            texto: `${p.id} (${p.repo}, branch ${p.rama}): installs with \`${p.installCommand}\`, tests with \`${p.testCommand}\`. GitHub: ${github.estado ?? "not verified"}.`,
         };
     }
     catch (e) {

package/dist/comandos/quien-soy.js

@@ -1,4 +1,5 @@
 import { FalloDeLaTerminal, resultadoDeFallo, SALIDA } from "../contrato.js";
+import { NOMBRE_DE_LA_FUENTE } from "../guardado/index.js";
 import { claveVigente } from "./clave-vigente.js";
 export async function comandoQuienSoy(d) {
     const origen = d.api.origin;
@@ -7,20 +8,20 @@ export async function comandoQuienSoy(d) {
         return leida.resultado;
     const vigente = leida.vigente;
     if (!vigente.completa) {
-        const otro = vigente.fuente === "archivo" ? "el llavero del sistema" : "el archivo de credenciales";
-        d.avisar(`Uso la clave de ${vigente.fuente}, pero no pude leer ${otro}: puede haber guardada otra más nueva.`);
+        const otro = vigente.fuente === "archivo" ? NOMBRE_DE_LA_FUENTE.llavero : NOMBRE_DE_LA_FUENTE.archivo;
+        d.avisar(`I'm using the key in ${NOMBRE_DE_LA_FUENTE[vigente.fuente]}, but I couldn't read ${otro}: a newer key may be saved there.`);
     }
     // Leer no cuesta nada y avisa de algo que la persona no vería de otro modo: claves viejas vivas.
     try {
         const { claves, completa } = await d.guardado.leerPorRevocar(origen);
         if (claves.length > 0) {
-            d.avisar(`Hay ${claves.length} clave(s) anterior(es) anotadas para revocar; se reintenta en el próximo login o logout.`);
+            d.avisar(`${claves.length} previous key(s) are noted down to be revoked; I'll try again on the next login or logout.`);
         }
         if (!completa)
-            d.avisar("No pude leer entera la lista de claves por revocar.");
+            d.avisar("I couldn't read the whole list of keys waiting to be revoked.");
     }
     catch {
-        d.avisar("No pude leer entera la lista de claves por revocar.");
+        d.avisar("I couldn't read the whole list of keys waiting to be revoked.");
     }
     let yo;
     try {
@@ -30,7 +31,7 @@ export async function comandoQuienSoy(d) {
         // Con la variable definida, «iniciá sesión de nuevo» no arregla nada: la variable sigue
         // ganándole a la clave nueva. Hay que decir cuál es la que no vale.
         if (e instanceof FalloDeLaTerminal && e.codigo === SALIDA.faltaLogin && vigente.fuente === "env") {
-            return resultadoDeFallo(new FalloDeLaTerminal(e.codigo, e.error, "La clave de SUPCOFLOW_TOKEN no vale: sacala de tu entorno o reemplazala por una vigente."));
+            return resultadoDeFallo(new FalloDeLaTerminal(e.codigo, e.error, "The key in SUPCOFLOW_TOKEN is not valid: remove it from your environment or replace it with a valid one."));
         }
         return resultadoDeFallo(e);
     }
@@ -38,6 +39,6 @@ export async function comandoQuienSoy(d) {
     return {
         codigo: SALIDA.ok,
         json: { ok: true, via: yo.via, equipo: yo.equipo, usuario: yo.usuario, proyecto: yo.proyecto, fuente: vigente.fuente },
-        texto: `${quien} en el equipo ${yo.equipo} (clave en ${vigente.fuente})`,
+        texto: `${quien} in team ${yo.equipo} (key in ${NOMBRE_DE_LA_FUENTE[vigente.fuente]})`,
     };
 }