supcoflow 0.6.0 → 0.8.0

package/dist/comandos/login.js

@@ -1,7 +1,8 @@
 import { FalloDeLaTerminal, resultadoDeFallo, SALIDA, taparSecretos } from "../contrato.js";
+import { NOMBRE_DE_LA_FUENTE } from "../guardado/index.js";
 import { PLAZO_MINIMO_MS, RESERVA_PARA_CERRAR_MS, sondearUnTramo, TRAMO_MAXIMO_MS } from "../sondeo.js";
 const TECHO_DE_UN_PASO_MS = 5_000;
-const VOLVER_A_EMPEZAR = "Volvé a empezar con `supcoflow login --start`.";
+const VOLVER_A_EMPEZAR = "Start over with `supcoflow login --start`.";
 const fallo = (codigo, error, message, extra = {}) => ({
     codigo, json: { ok: false, error, message, ...extra }, texto: message,
 });
@@ -12,7 +13,7 @@ const motivo = (e) => e instanceof FalloDeLaTerminal ? e.message : taparSecretos
 export async function reintentarPorRevocar(d, limite) {
     const origen = d.api.origin;
     const noSe = () => {
-        d.avisar("No pude leer entera la lista de claves por revocar (el llavero no respondió); la reintento la próxima vez.");
+        d.avisar("I couldn't read the whole list of keys waiting to be revoked (the keychain didn't respond); I'll try again next time.");
     };
     let lectura;
     try {
@@ -54,8 +55,8 @@ export async function reintentarPorRevocar(d, limite) {
 export async function loginStart(d, flags) {
     const origen = d.api.origin;
     if (flags.dryRun) {
-        const haria = `pedir un código de dispositivo a ${origen}`;
-        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `Con --dry-run no hago nada; sin él, iría a ${haria}.` };
+        const haria = `ask ${origen} for a device code`;
+        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `With --dry-run I do nothing; without it: ${haria}.` };
     }
     await reintentarPorRevocar(d, d.ahora() + 15_000);
     let c;
@@ -75,7 +76,7 @@ export async function loginStart(d, flags) {
         await d.guardado.guardarPendiente(origen, pendiente);
     }
     catch (e) {
-        return fallo(SALIDA.inesperado, e instanceof FalloDeLaTerminal ? e.error : "no_se_pudo_guardar", `No pude guardar el inicio de sesión en curso: ${motivo(e)}`);
+        return fallo(SALIDA.inesperado, e instanceof FalloDeLaTerminal ? e.error : "no_se_pudo_guardar", `I couldn't save the login in progress: ${motivo(e)}`);
     }
     return {
         codigo: SALIDA.esperandoAUnaPersona,
@@ -83,7 +84,7 @@ export async function loginStart(d, flags) {
             ok: false, esperando: "persona", verification_uri: c.verificationUri,
             verification_uri_complete: c.verificationUriComplete, user_code: c.userCode, expires_in: c.expiresIn,
         },
-        texto: `Abrí ${c.verificationUriComplete} y confirmá el código ${c.userCode}. Después corré \`supcoflow login --wait\`.`,
+        texto: `Open ${c.verificationUriComplete} and confirm the code ${c.userCode}. Then run \`supcoflow login --wait\`.`,
     };
 }
 export async function loginWait(d) {
@@ -96,7 +97,7 @@ export async function loginWait(d) {
     const techo = () => Math.max(0, Math.min(TECHO_DE_UN_PASO_MS, limite - d.ahora()));
     const p = await d.guardado.leerPendiente(origen);
     if (p === null) {
-        return fallo(SALIDA.entradaInvalida, "sin_login_en_curso", "No hay un inicio de sesión en curso: empezá con `supcoflow login --start`.");
+        return fallo(SALIDA.entradaInvalida, "sin_login_en_curso", "There is no login in progress: start with `supcoflow login --start`.");
     }
     // La anterior se lee ANTES de sondear, así no consume la reserva del cierre. Se pide por
     // `leerClaveCompleta` para saber de paso si SUPCOFLOW_TOKEN está definida (sin costo: la variable
@@ -110,9 +111,9 @@ export async function loginWait(d) {
     // y sin borrar el pendiente, así el mismo `--wait` sirve cuando el llavero vuelva.
     if (!lectura.completa) {
         const salida = conVariable
-            ? "desbloqueá el llavero y volvé a llamar `supcoflow login --wait`."
-            : "desbloqueá el llavero y volvé a llamar `supcoflow login --wait` (o, sin login, exportá SUPCOFLOW_TOKEN con una clave vigente).";
-        return fallo(SALIDA.inesperado, "no_pude_leer_la_clave", `No pude leer tu clave guardada (el llavero no respondió), y sin saber cuál es no la puedo reemplazar sin dejarla viva: ${salida}`);
+            ? "unlock the keychain and run `supcoflow login --wait` again."
+            : "unlock the keychain and run `supcoflow login --wait` again (or, without logging in, export SUPCOFLOW_TOKEN with a valid key).";
+        return fallo(SALIDA.inesperado, "no_pude_leer_la_clave", `I couldn't read your saved key (the keychain didn't respond), and without knowing which one it is I can't replace it without leaving it active: ${salida}`);
     }
     const anterior = lectura.valor;
     let fin;
@@ -132,26 +133,26 @@ export async function loginWait(d) {
             return {
                 codigo: SALIDA.esperandoAUnaPersona,
                 json: { ok: false, esperando: "persona", user_code: fin.pendiente.userCode, verification_uri_complete: fin.pendiente.verificationUriComplete },
-                texto: `Todavía no se confirmó. Abrí ${fin.pendiente.verificationUriComplete} y confirmá el código ${fin.pendiente.userCode}; después volvé a correr \`supcoflow login --wait\`.`,
+                texto: `Not confirmed yet. Open ${fin.pendiente.verificationUriComplete} and confirm the code ${fin.pendiente.userCode}; then run \`supcoflow login --wait\` again.`,
             };
         case "token": {
             const r = await reemplazarClave(d, { clave: fin.clave, equipo: fin.equipo }, anterior?.clave ?? null, limite);
             // Va acá y no adentro de `reemplazarClave` porque es acá donde se supo, antes de sondear, sin
             // gastar reserva: preguntarlo al final costaría otra lectura lenta del guardado.
             if (conVariable && r.json.guardada_en !== undefined) {
-                d.avisar("SUPCOFLOW_TOKEN está definida y tiene prioridad sobre la clave que acabo de guardar.");
+                d.avisar("SUPCOFLOW_TOKEN is set and takes priority over the key I just saved.");
             }
             return r;
         }
         case "rechazado":
             await d.guardado.borrarPendiente(origen, techo());
-            return fallo(SALIDA.haceFaltaUnaPersona, "acceso_rechazado", "Rechazaron el acceso desde la consola; tu sesión anterior, si había, sigue igual.");
+            return fallo(SALIDA.haceFaltaUnaPersona, "acceso_rechazado", "Access was denied in the console; your previous session, if there was one, is unchanged.");
         case "vencido":
             await d.guardado.borrarPendiente(origen, techo());
-            return fallo(SALIDA.faltaLogin, "codigo_vencido", `El código venció. ${VOLVER_A_EMPEZAR}`);
+            return fallo(SALIDA.faltaLogin, "codigo_vencido", `The code has expired. ${VOLVER_A_EMPEZAR}`);
         case "invalido":
             await d.guardado.borrarPendiente(origen, techo());
-            return fallo(SALIDA.faltaLogin, "codigo_invalido", `El código ya no vale. ${VOLVER_A_EMPEZAR}`);
+            return fallo(SALIDA.faltaLogin, "codigo_invalido", `The code is no longer valid. ${VOLVER_A_EMPEZAR}`);
     }
 }
 // El login de una persona frente a la terminal: los mismos dos pasos, encadenados. Sin TTY (o con
@@ -160,14 +161,14 @@ export async function loginWait(d) {
 const PAUSA_ENTRE_TRAMOS_MS = 1_000;
 export async function loginInteractivo(d, flags) {
     if (!d.esTty || flags.json) {
-        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Sin terminal interactiva usá `supcoflow login --start --json` y después `supcoflow login --wait --json`.");
+        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Without an interactive terminal, use `supcoflow login --start --json` and then `supcoflow login --wait --json`.");
     }
     const inicio = await loginStart(d, flags);
     if (inicio.codigo !== SALIDA.esperandoAUnaPersona)
         return inicio;
     // El texto de `--start` le dice a la persona que corra `--wait`; acá eso lo hace el comando solo.
     const { verification_uri_complete: url, user_code: codigo } = inicio.json;
-    d.mostrar(`Abrí ${String(url)} y confirmá el código ${String(codigo)}. Espero acá…`);
+    d.mostrar(`Open ${String(url)} and confirm the code ${String(codigo)}. I'll wait here...`);
     // Cada tramo termina por su cuenta (≤ 90 s) y el código vence a los pocos minutos, así que el
     // bucle tiene fin aunque la persona nunca conteste: termina en `codigo_vencido`.
     let r;
@@ -206,9 +207,9 @@ export async function reemplazarClave(d, nueva, anterior, limite) {
             revocada = false;
         }
         const despues = revocada
-            ? "La revoqué para que no quede viva; tu sesión anterior, si había, sigue como estaba."
-            : "Tampoco pude revocarla: revocala en la consola, en «Accesos desde la terminal».";
-        return fallo(SALIDA.inesperado, "no_se_pudo_guardar", `No pude guardar la clave nueva (${motivo(e)}). ${despues}`);
+            ? "I revoked it so it doesn't stay active; your previous session, if there was one, is as it was."
+            : "I couldn't revoke it either: revoke it in the console, under \"Accesos desde la terminal\" (the console is in Spanish).";
+        return fallo(SALIDA.inesperado, "no_se_pudo_guardar", `I couldn't save the new key (${motivo(e)}). ${despues}`);
     }
     // 2. Revocar la anterior, o anotarla.
     let anteriorRevocada = null;
@@ -228,10 +229,10 @@ export async function reemplazarClave(d, nueva, anterior, limite) {
             try {
                 await d.guardado.anotarPorRevocar(origen, anterior, techo());
                 quedaPorRevocar = true;
-                d.avisar("No pude revocar tu clave anterior; quedó anotada y la reintento en el próximo login o logout.");
+                d.avisar("I couldn't revoke your previous key; it's noted down and I'll try again on the next login or logout.");
             }
             catch {
-                const message = "No pude revocar ni anotar tu clave anterior: revocala en la consola, en «Accesos desde la terminal».";
+                const message = "I couldn't revoke or note down your previous key: revoke it in the console, under \"Accesos desde la terminal\" (the console is in Spanish).";
                 d.avisar(message);
                 if (queda() >= PLAZO_MINIMO_MS)
                     await d.guardado.borrarPendiente(origen, techo());
@@ -245,10 +246,10 @@ export async function reemplazarClave(d, nueva, anterior, limite) {
     // 3. Borrar el pendiente; su `false` no cambia nada.
     if (queda() >= PLAZO_MINIMO_MS)
         await d.guardado.borrarPendiente(origen, techo());
-    const donde = guardadaEn === "llavero" ? "el llavero del sistema" : "el archivo de credenciales";
+    const donde = guardadaEn === "llavero" ? NOMBRE_DE_LA_FUENTE.llavero : NOMBRE_DE_LA_FUENTE.archivo;
     return {
         codigo: SALIDA.ok,
         json: { ok: true, equipo: nueva.equipo, guardada_en: guardadaEn, anterior_revocada: anteriorRevocada, queda_por_revocar: quedaPorRevocar },
-        texto: `Sesión iniciada en el equipo ${nueva.equipo}; la clave quedó en ${donde}.`,
+        texto: `Logged in to team ${nueva.equipo}; the key is saved in ${donde}.`,
     };
 }

package/dist/comandos/logout.js

@@ -2,6 +2,7 @@
 // (Review Focus 9 y 14). Borrar sin revocar dejaría la clave sirviendo en el motor y sin nadie que
 // la recuerde: por eso, si el motor no confirma, no se borra nada y el comando sale 1.
 import { FalloDeLaTerminal, SALIDA, taparSecretos } from "../contrato.js";
+import { NOMBRE_DE_LA_FUENTE } from "../guardado/index.js";
 import { reintentarPorRevocar } from "./login.js";
 const motivo = (e) => e instanceof FalloDeLaTerminal ? e.message : taparSecretos(e instanceof Error ? e.message : String(e));
 export async function comandoLogout(d, flags) {
@@ -9,7 +10,7 @@ export async function comandoLogout(d, flags) {
     // Sin nada legible y un almacén que no contestó, no se sabe si hay sesión: decir «no había»
     // dejaría creer que no queda ninguna clave viva (Review Focus 12).
     const noPudeLeer = (extra = {}) => {
-        const message = "No pude leer la clave guardada (el llavero no respondió); no cerré nada. Probá de nuevo.";
+        const message = "I couldn't read the saved key (the keychain didn't respond); I didn't log out. Try again.";
         return { codigo: SALIDA.inesperado, json: { ok: false, error: "no_pude_leer_la_clave", message, ...extra }, texto: message };
     };
     if (flags.dryRun) {
@@ -18,20 +19,20 @@ export async function comandoLogout(d, flags) {
         if (vigente === null && !lectura.completa)
             return noPudeLeer({ dry_run: true });
         if (vigente === null) {
-            return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, habia_sesion: false }, texto: "No hay sesión iniciada: no haría nada." };
+            return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, habia_sesion: false }, texto: "You are not logged in: there is nothing to do." };
         }
-        const haria = `revocar la clave de ${vigente.fuente} en ${origen}` + (vigente.fuente !== "env" ? " y borrarla" : "");
-        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `Con --dry-run no hago nada; sin él, iría a ${haria}.` };
+        const haria = `revoke the key in ${NOMBRE_DE_LA_FUENTE[vigente.fuente]} at ${origen}` + (vigente.fuente !== "env" ? " and delete it" : "");
+        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `With --dry-run I do nothing; without it: ${haria}.` };
     }
     // Lo pendiente de antes va primero: un logout es justo cuando la persona espera que no quede
     // ninguna clave suya viva, y es la última oportunidad que tiene la terminal de revocarlas.
     const { quedan } = await reintentarPorRevocar(d, d.ahora() + 15_000);
     // `null` es «no lo pude comprobar» y se dice así: un 0 haría creer que no queda nada vivo.
     if (quedan === null) {
-        d.avisar("No pude comprobar cuántas claves quedan por revocar; las que haya siguen anotadas y las reintento en el próximo login o logout.");
+        d.avisar("I couldn't check how many keys are left to revoke; any that exist are still noted down and I'll try again on the next login or logout.");
     }
     else if (quedan > 0) {
-        d.avisar(`Quedan ${quedan} clave(s) anterior(es) sin revocar; siguen anotadas y las reintento en el próximo login o logout.`);
+        d.avisar(`${quedan} previous key(s) are still not revoked; they are noted down and I'll try again on the next login or logout.`);
     }
     const lectura = await d.guardado.leerClaveCompleta(origen);
     const vigente = lectura.valor;
@@ -40,22 +41,22 @@ export async function comandoLogout(d, flags) {
     const conPendientes = (json) => ({ ...json, quedan_por_revocar: quedan, ...(lectura.completa ? {} : { lectura_completa: false }) });
     if (vigente === null) {
         await d.guardado.borrarPendiente(origen);
-        return { codigo: SALIDA.ok, json: conPendientes({ ok: true, habia_sesion: false }), texto: "No había sesión iniciada." };
+        return { codigo: SALIDA.ok, json: conPendientes({ ok: true, habia_sesion: false }), texto: "You were not logged in." };
     }
     let revocada;
     try {
         revocada = (await d.revocarPropia(d.api, vigente.clave)) === "revocada";
     }
     catch (e) {
-        const cual = vigente.fuente === "env" ? "la clave de SUPCOFLOW_TOKEN sigue viva" : "la clave sigue guardada";
-        const message = `No pude revocar la clave, así que no cerré la sesión (${motivo(e)}); ${cual}. Probá de nuevo.`;
+        const cual = vigente.fuente === "env" ? "the key in SUPCOFLOW_TOKEN is still active" : "the key is still saved";
+        const message = `I couldn't revoke the key, so I didn't log out (${motivo(e)}); ${cual}. Try again.`;
         const error = e instanceof FalloDeLaTerminal ? e.error : "inesperado";
         return { codigo: SALIDA.inesperado, json: conPendientes({ ok: false, error, message }), texto: message };
     }
     // La variable no es nuestra: se revoca la clave que trae, pero lo guardado es OTRA credencial,
     // que sólo se cierra revocándola a ella. Borrarla acá la dejaría viva y olvidada.
     if (vigente.fuente === "env") {
-        d.avisar("Revoqué la clave de SUPCOFLOW_TOKEN; sacala de tu entorno.");
+        d.avisar("I revoked the key in SUPCOFLOW_TOKEN; remove it from your environment.");
         // `undefined` = no se pudo leer: no se afirma que no haya, el json lleva `null` en vez de mentir.
         let guardada;
         try {
@@ -66,19 +67,19 @@ export async function comandoLogout(d, flags) {
             guardada = undefined;
         }
         if (guardada) {
-            d.avisar(`Sigue guardada otra clave en ${guardada.fuente}; para cerrarla, corré \`supcoflow logout\` sin SUPCOFLOW_TOKEN.`);
+            d.avisar(`Another key is still saved in ${NOMBRE_DE_LA_FUENTE[guardada.fuente]}; to log it out, run \`supcoflow logout\` without SUPCOFLOW_TOKEN.`);
         }
         return {
             codigo: SALIDA.ok,
             json: conPendientes({ ok: true, revocada, fuente: "env", queda_clave_guardada: guardada === undefined ? null : guardada !== null }),
-            texto: "Revoqué la clave de SUPCOFLOW_TOKEN.",
+            texto: "I revoked the key in SUPCOFLOW_TOKEN.",
         };
     }
     // Con la lectura incompleta se borra sólo la copia que se leyó y se acaba de revocar: la del
     // almacén que no contestó puede ser otra clave, viva, y borrarla sin revocarla la olvidaría.
     if (!lectura.completa) {
-        const otro = vigente.fuente === "archivo" ? "el llavero del sistema" : "el archivo de credenciales";
-        d.avisar(`Cierro la clave de ${vigente.fuente}, pero no pude leer ${otro}: puede quedar otra copia guardada ahí; cuando responda, volvé a correr \`supcoflow logout\`.`);
+        const otro = vigente.fuente === "archivo" ? NOMBRE_DE_LA_FUENTE.llavero : NOMBRE_DE_LA_FUENTE.archivo;
+        d.avisar(`I'm logging out the key in ${NOMBRE_DE_LA_FUENTE[vigente.fuente]}, but I couldn't read ${otro}: another copy may still be saved there; when it responds, run \`supcoflow logout\` again.`);
     }
     try {
         if (lectura.completa)
@@ -88,9 +89,9 @@ export async function comandoLogout(d, flags) {
     }
     catch (e) {
         // La clave ya no sirve en el motor, pero quedó escrita: el comando no puede decir que terminó bien.
-        const message = `La clave quedó revocada pero no pude borrarla: ${motivo(e)}`;
+        const message = `The key was revoked but I couldn't delete it: ${motivo(e)}`;
         return { codigo: SALIDA.inesperado, json: conPendientes({ ok: false, error: "no_se_pudo_borrar", message }), texto: message };
     }
     await d.guardado.borrarPendiente(origen);
-    return { codigo: SALIDA.ok, json: conPendientes({ ok: true, revocada }), texto: "Sesión cerrada." };
+    return { codigo: SALIDA.ok, json: conPendientes({ ok: true, revocada }), texto: "Logged out." };
 }

package/dist/comandos/probar.js

@@ -0,0 +1,359 @@
+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";
+// Las cotas de `BugReportSchema` del motor (D2): el mensaje es el cuerpo del reporte. Se mira acá para no
+// 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
+// un estado que esta terminal no conoce: sale 1, nunca se adivina.
+const ABIERTOS = new Set(["en_curso", "creada"]);
+const CON_DESENLACE_OK = new Set(["issue_creado", "guardado"]);
+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 ? "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,
+        puntos: g.puntos,
+        politica: g.politica,
+        techo_usd: g.techoUsd,
+        saldo_usd: g.saldoUsd,
+        tope_usd: g.topeUsd,
+        comprometido_usd: g.comprometidoUsd,
+        prueba_abierta: g.pruebaAbierta,
+    };
+}
+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)
+        return p.resultado;
+    let g;
+    try {
+        g = await d.leerDiagnostico(d.api, p.clave, p.proyecto.id);
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+    // 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 { 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.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.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.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.message !== null) {
+        mensaje = flags.message.trim();
+        if (mensaje.length === 0 || mensaje.length > MAX_MENSAJE) {
+            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.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 (autorizado === null || flags.dryRun) {
+        let g;
+        try {
+            g = await d.leerDiagnostico(d.api, clave, proyecto.id);
+        }
+        catch (e) {
+            return resultadoDeFallo(e);
+        }
+        const datos = { proyecto: { id: proyecto.id, repo: proyecto.repo }, ...datosDelDiagnostico(g) };
+        const gasto = g.politica === "guardar"
+            ? `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;
+            try {
+                pendiente = (await d.pruebas.leer(proyecto.id)).intento !== null;
+            }
+            catch {
+                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
+                ? `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.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 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 --authorize-spend: el ciclo de la clave.
+    let intento;
+    try {
+        const guardado = await d.pruebas.leer(proyecto.id);
+        if (guardado.intento !== null) {
+            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 = previo;
+        }
+        else {
+            // 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);
+        }
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+    const r = await d.pedirPrueba(d.api, clave, proyecto.id, intento);
+    if (r.tipo === "aceptada") {
+        try {
+            await d.pruebas.confirmar(proyecto.id, r.pruebaId);
+        }
+        catch {
+            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: `Test ${r.pruebaId} requested (${r.estado}). Follow it with \`supcoflow test --wait\`.`,
+        };
+    }
+    if (r.tipo === "ambigua") {
+        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.
+    try {
+        await d.pruebas.descartar(proyecto.id);
+    }
+    catch {
+        d.avisar("I couldn't close the saved request; the next `test --authorize-spend` will resend it.");
+    }
+    return rechazo(r, intento, d.avisar);
+}
+function enCurso(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, 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": {
+            // 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 {
+                codigo: SALIDA.topeAlcanzado,
+                json: { ok: false, error: r.error, message: r.message, comprometido_usd: c.comprometido_usd ?? null, tope_usd: c.tope_usd ?? null },
+                texto: r.message,
+            };
+        case "requiere_api_key": {
+            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("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);
+    if (r.status === 403 || r.error === "chat_deshabilitado")
+        return fallo(SALIDA.haceFaltaUnaPersona, r.error, r.message);
+    return fallo(SALIDA.entradaInvalida, r.error, r.message);
+}
+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 `Cost: ${usd(c.usd)}.`;
+    if (c.estado === "pendiente")
+        return `Charge pending: it's read a few minutes after the run closes (up to ${usd(c.techo_usd)}).`;
+    if (c.estado === "perdido")
+        return `Charge lost: the spend couldn't be read (up to ${usd(c.techo_usd)}).`;
+    if (c.estado === null)
+        return null;
+    return `Charge: ${c.estado} (up to ${usd(c.techo_usd)}).`;
+}
+function resultadoDelSeguimiento(s) {
+    const datos = {
+        prueba_id: s.pruebaId, estado: s.estado, abierta: s.abierta, mensaje: s.mensaje,
+        reporte: s.reporte, run: s.run, issue: s.issue, cobro: s.cobro,
+    };
+    const lineas = [
+        `Test ${s.pruebaId}: ${s.estado}.${s.mensaje ? ` ${s.mensaje}` : ""}`,
+        s.issue ? `Issue #${s.issue.numero}: ${s.issue.url}` : null,
+        s.run?.motivo ? `Run reason: ${s.run.motivo}` : null,
+        textoDelCobro(s.cobro),
+    ];
+    if (ABIERTOS.has(s.estado)) {
+        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(`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 = `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) {
+    let pruebaId = elegida;
+    if (pruebaId === null) {
+        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 `--test-id` explícito no se llega acá.
+            pruebaId = g.ultima;
+            if (g.intento !== null) {
+                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", "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
+    // comando entero no pasa de 90 s aunque resolver el proyecto haya tardado.
+    const limite = inicio + Math.min(d.tramoMs ?? TRAMO_MAXIMO_MS, TRAMO_MAXIMO_MS) - PLAZO_MINIMO_DE_SONDEO_MS;
+    let ultimo = null;
+    for (;;) {
+        const plazoMs = Math.min(PLAZO_MAXIMO_DE_SONDEO_MS, limite - d.ahora());
+        if (plazoMs < PLAZO_MINIMO_DE_SONDEO_MS && ultimo !== null)
+            break;
+        try {
+            // Un fallo del motor a mitad del tramo sale 1 y no se reintenta en silencio (P13): quien llama decide.
+            ultimo = await d.leerPrueba(d.api, clave, proyectoId, pruebaId, Math.max(plazoMs, PLAZO_MINIMO_DE_SONDEO_MS));
+        }
+        catch (e) {
+            return resultadoDeFallo(e);
+        }
+        if (!ABIERTOS.has(ultimo.estado))
+            break;
+        if (limite - (d.ahora() + INTERVALO_DE_SEGUIMIENTO_MS) < PLAZO_MINIMO_DE_SONDEO_MS)
+            break;
+        await d.dormir(INTERVALO_DE_SEGUIMIENTO_MS);
+    }
+    return resultadoDelSeguimiento(ultimo);
+}