supcoflow 0.6.0 → 0.7.0

package/README.md

@@ -4,7 +4,7 @@ La terminal de [Supcoflow](https://app.supcoflow.dev): iniciar sesión y manejar
 desde la consola, o desde un asistente de código que corre comandos por vos.
 
 Trae iniciar y cerrar sesión, ver con qué cuenta estás, conectar el repo con la App de GitHub,
-crear su proyecto, configurar el chat y ponerlo en la app.
+crear su proyecto, configurar el chat, ponerlo en la app y probar que un problema llega hasta un issue.
 
 ## Instalar
 
@@ -142,6 +142,25 @@ Después, `supcoflow instalacion anotar --skill <versión> [--app <carpeta>]` de
 declarado e instalado, y la configuración del proyecto. Nunca lleva un secreto ni una fecha; repetirlo
 sin cambios no lo toca, y si el archivo tiene cambios sin commit sale 4 y no lo pisa.
 
+## Probar la instalación
+
+Con el chat puesto, dos comandos dicen si un problema que entra por el chat llega hasta un issue. Los dos
+toman el repo del `origin`, o `--repo owner/repo`.
+
+| Comando | Qué hace |
+|---|---|
+| `supcoflow diagnosticar` | Gratis y sin escribir nada: revisa instalación de GitHub, sitios, chat, guía, política, saldo del mes y pruebas abiertas. Sale 0 si está todo listo, 4 si algo hay que arreglar (con cada punto). |
+| `supcoflow probar` | Sin `--autorizo-gasto` no manda nada: sale 4 con el techo de la prueba, el saldo, el tope y lo comprometido del mes. |
+| `supcoflow probar --autorizo-gasto` | Pide la prueba: el problema entra por la misma puerta que el chat y corre un relevamiento que **gasta** hasta el techo que mostró el motor (con la política `guardar` llega hasta el caso guardado y no gasta). Sale 5 con el id. `--mensaje "…"` usa un texto propio. |
+| `supcoflow probar --wait` | Sigue la última prueba hasta 90 s: 5 mientras corre (volvé a llamarlo), 0 con el issue, 4 si hay que mirarla en la consola (trae el enlace). El cobro se muestra como esté: `pendiente` justo al cerrar, nunca 0. `--prueba prb_…` sigue otra. |
+| `supcoflow probar --dry-run --autorizo-gasto` | Lo que haría (proyecto, techo, saldo, política), sin pedir nada. |
+
+Si la respuesta del motor no llega, el pedido queda guardado en esta máquina (fuera del repo, junto a las
+credenciales): repetir `supcoflow probar --autorizo-gasto` retoma **la misma** prueba en vez de pedir otra.
+Mientras haya un pedido sin confirmar, otro `--mensaje` sale 4 `intento_pendiente`. La prueba va con la clave
+personal de `supcoflow login`; una clave de consulta no puede pedirla. Una sola prueba abierta por proyecto: otra
+sale 4 `prueba_en_curso` con el id de la abierta. El issue de una prueba queda abierto y rotulado como prueba.
+
 ## Con un asistente
 
 Si usás un asistente de código como Claude Code, la skill de Supcoflow hace todo el camino

package/dist/api.js

@@ -21,9 +21,9 @@ export function urlDeLaApi(env) {
         return new URL(u.origin);
     throw invalida();
 }
-// A mano a propósito: tiene que coincidir con package.json (0.6.0); sólo identifica a la terminal
-// en los logs del motor, no decide nada.
-const VERSION = "0.6.0";
+// A mano a propósito: tiene que coincidir con package.json (lo pinza test/describir.test.ts); sólo
+// identifica a la terminal en los logs del motor, no decide nada.
+const VERSION = "0.7.0";
 const PLAZO_POR_DEFECTO_MS = 15_000;
 // Los dos POST que crean algo: detrás, el motor acuña con Vercel Connect y le pregunta a GitHub varias
 // veces (instalación, repos, comandos, rama). Con 15 s una respuesta lenta pero buena se cortaba y
@@ -337,3 +337,86 @@ export async function leerWidget(api, clave, proyectoId, f) {
         throw rechazada(r);
     return aWidget(r.cuerpo, r.status);
 }
+// ---- La prueba (bloque 7) ----
+const rutaDelProyecto = (proyectoId) => `/api/proyectos/${encodeURIComponent(proyectoId)}`;
+const numeroONull = (v) => (v === null ? null : typeof v === "number" && Number.isFinite(v) ? v : undefined);
+export async function leerDiagnostico(api, clave, proyectoId, f) {
+    const r = await conClave(api, clave, `${rutaDelProyecto(proyectoId)}/diagnostico`, { method: "GET" }, f);
+    if (r.status !== 200)
+        throw rechazada(r);
+    const c = r.cuerpo;
+    const puntos = Array.isArray(c.puntos) ? c.puntos.map((x) => objeto(x, r.status)) : null;
+    const [saldo, tope, comprometido] = [c.saldo_usd, c.tope_usd, c.comprometido_usd].map(numeroONull);
+    if (typeof c.listo !== "boolean" || puntos === null || !texto(c.politica) || typeof c.techo_usd !== "number"
+        || saldo === undefined || tope === undefined || comprometido === undefined
+        || (c.prueba_abierta !== null && !texto(c.prueba_abierta))
+        || puntos.some((p) => !texto(p.punto) || typeof p.ok !== "boolean" || typeof p.mensaje !== "string"))
+        throw inesperada(r.status);
+    return {
+        listo: c.listo,
+        puntos: puntos.map((p) => ({ punto: p.punto, ok: p.ok, mensaje: taparSecretos(p.mensaje) })),
+        politica: c.politica,
+        techoUsd: c.techo_usd,
+        saldoUsd: saldo, topeUsd: tope, comprometidoUsd: comprometido,
+        pruebaAbierta: texto(c.prueba_abierta),
+    };
+}
+// Sin `conClave`: su 401/403/5xx lanzan, y acá cada uno tiene que decidir qué pasa con el intento.
+// `idempotency_en_curso` es ambigua: otro intento con la misma clave sigue corriendo y puede crearla.
+// Un 503 de la pausa de despachos (D10) también: el motor no guardó nada, pero conservar el intento no
+// cuesta (el reintento con la misma clave crea la prueba una sola vez) y un 503 genérico no se distingue.
+export async function pedirPrueba(api, clave, proyectoId, intento, f) {
+    const cuerpo = { techo_usd: intento.techoUsd };
+    if (intento.mensaje !== null)
+        cuerpo.mensaje = intento.mensaje;
+    let r;
+    try {
+        r = await pedir(api, `${rutaDelProyecto(proyectoId)}/pruebas`, {
+            method: "POST", headers: { ...JSON_BODY, ...bearer(clave), "idempotency-key": intento.clave }, body: JSON.stringify(cuerpo),
+        }, f, PLAZO_DE_ALTA_MS);
+    }
+    catch (e) {
+        const fallo = e instanceof FalloDeLaTerminal ? e : new FalloDeLaTerminal(SALIDA.inesperado, "motor_inalcanzable", "No pude comunicarme con el motor.");
+        return { tipo: "ambigua", error: fallo.error, message: fallo.message };
+    }
+    const error = texto(r.cuerpo.error);
+    const message = taparSecretos(texto(r.cuerpo.message) ?? `El motor respondió ${r.status}.`);
+    if (r.status === 202 || r.status === 200 || r.status === 201) {
+        const [pruebaId, reporteId, estado] = [r.cuerpo.prueba_id, r.cuerpo.reporte_id, r.cuerpo.estado].map(texto);
+        if (pruebaId && /^prb_[0-9a-f]{16}$/.test(pruebaId) && reporteId && estado)
+            return { tipo: "aceptada", pruebaId, reporteId, estado };
+        return { tipo: "ambigua", error: "respuesta_inesperada", message: `El motor respondió ${r.status} sin la prueba.` };
+    }
+    if (r.status >= 500 || (r.status === 409 && error === "idempotency_en_curso")) {
+        return { tipo: "ambigua", error: error ?? "motor_inalcanzable", message };
+    }
+    if (r.status >= 400)
+        return { tipo: "rechazo", status: r.status, error: error ?? "rechazado", message, cuerpo: r.cuerpo };
+    return { tipo: "ambigua", error: "respuesta_inesperada", message: `El motor respondió ${r.status} con algo que no esperaba.` };
+}
+export async function leerPrueba(api, clave, proyectoId, pruebaId, f, plazoMs) {
+    const r = await conClave(api, clave, `${rutaDelProyecto(proyectoId)}/pruebas/${encodeURIComponent(pruebaId)}`, { method: "GET" }, f, plazoMs);
+    if (r.status !== 200)
+        throw rechazada(r);
+    const c = r.cuerpo;
+    const cobro = objeto(c.cobro, r.status);
+    const usd = numeroONull(cobro.usd);
+    if (!texto(c.prueba_id) || !texto(c.estado) || typeof cobro.techo_usd !== "number" || usd === undefined
+        || (cobro.estado !== null && !texto(cobro.estado)))
+        throw inesperada(r.status);
+    const rep = c.reporte === null || c.reporte === undefined ? null : objeto(c.reporte, r.status);
+    const run = c.run === null || c.run === undefined ? null : objeto(c.run, r.status);
+    const issue = c.issue === null || c.issue === undefined ? null : objeto(c.issue, r.status);
+    if (issue !== null && (typeof issue.numero !== "number" || !texto(issue.url)))
+        throw inesperada(r.status);
+    return {
+        pruebaId: c.prueba_id,
+        estado: c.estado,
+        abierta: typeof c.abierta === "boolean" ? c.abierta : null,
+        mensaje: texto(c.mensaje) === null ? null : taparSecretos(c.mensaje),
+        reporte: rep === null || !texto(rep.id) || !texto(rep.url) ? null : { id: rep.id, url: rep.url },
+        run: run === null ? null : { id: String(run.id), status: String(run.status), motivo: texto(run.motivo) },
+        issue: issue === null ? null : { numero: issue.numero, url: issue.url },
+        cobro: { estado: texto(cobro.estado), usd, techo_usd: cobro.techo_usd },
+    };
+}

package/dist/argumentos.js

@@ -11,6 +11,7 @@ export const COMANDOS_COMPUESTOS = [
 const PRIMERAS_PALABRAS = new Set(COMANDOS_COMPUESTOS.map((c) => c.split(" ")[0]));
 const FLAGS_CON_VALOR = [
     "repo", "install", "test", "sitio", "titulo", "saludo", "archivo", "permitir", "modo", "nombre", "guardar-en", "id", "origen", "skill", "app",
+    "mensaje", "prueba",
 ];
 // strict: un flag mal escrito (`--estart`) no se ignora en silencio: un asistente creería que
 // pidió algo que no pidió.
@@ -43,6 +44,9 @@ export function leerArgumentos(argv) {
                 "desde-github": { type: "boolean" },
                 skill: { type: "string" },
                 app: { type: "string" },
+                "autorizo-gasto": { type: "boolean" },
+                mensaje: { type: "string" },
+                prueba: { type: "string" },
                 tema: { type: "string", multiple: true },
             },
             tokens: true,
@@ -102,6 +106,9 @@ export function leerArgumentos(argv) {
             desdeGithub: v["desde-github"] === true,
             skill: v.skill ?? null,
             app: v.app ?? null,
+            autorizoGasto: v["autorizo-gasto"] === true,
+            mensaje: v.mensaje ?? null,
+            prueba: v.prueba ?? null,
             tema: v.tema ?? [],
         },
     };

package/dist/cli.js

@@ -12,6 +12,7 @@ import { comandoCatalogo, datosFijar, politicaFijar } from "./comandos/datos-y-p
 import { ayuda, comandoDescribir, DESCRIPCION } from "./comandos/describir.js";
 import { loginInteractivo, loginStart, loginWait } from "./comandos/login.js";
 import { comandoLogout } from "./comandos/logout.js";
+import { diagnosticar, probar } from "./comandos/probar.js";
 import { proyectoCrear, proyectoVer } from "./comandos/proyecto.js";
 import { comandoQuienSoy } from "./comandos/quien-soy.js";
 import { repoConectarInteractivo, repoConectarStart, repoConectarWait } from "./comandos/repo-conectar.js";
@@ -41,6 +42,7 @@ async function correr(argv) {
             archivo: flags.archivo !== null, permitir: flags.permitir !== null, modo: flags.modo !== null,
             nombre: flags.nombre !== null, guardarEn: flags.guardarEn !== null, id: flags.id !== null, origen: flags.origen !== null, desdeGithub: flags.desdeGithub,
             skill: flags.skill !== null, app: flags.app !== null,
+            autorizoGasto: flags.autorizoGasto, mensaje: flags.mensaje !== null, prueba: flags.prueba !== null,
         };
         const noAplica = flagQueNoAplica(comando, Object.keys(presentes).filter((k) => presentes[k]));
         if (noAplica !== null)
@@ -130,6 +132,10 @@ async function correr(argv) {
                 return { r: await widget(e.widget, flags), json };
             case "instalacion anotar":
                 return { r: await instalacionAnotar(e.instalacion, flags), json };
+            case "diagnosticar":
+                return { r: await diagnosticar(e.prueba, flags), json };
+            case "probar":
+                return { r: await probar(e.prueba, flags), json };
         }
         throw new Error(`comando sin despacho: ${comando}`);
     }

package/dist/comandos/describir.js

@@ -3,7 +3,7 @@
 // ayuda pensada para personas. La ayuda se arma desde acá: una sola fuente, así no se desfasan.
 import { SALIDA } from "../contrato.js";
 // A mano a propósito, como en api.ts: tiene que coincidir con package.json (lo pinza un test).
-const VERSION = "0.6.0";
+const VERSION = "0.7.0";
 export const DESCRIPCION = {
     version: VERSION,
     comandos: [
@@ -230,6 +230,28 @@ export const DESCRIPCION = {
             ejemplos: ["supcoflow instalacion anotar --skill 0.1.0 --app web --json"],
             codigos: [0, 1, 2, 3, 4],
         },
+        {
+            nombre: "diagnosticar",
+            resumen: "Dice, gratis y sin escribir nada, si una prueba del proyecto entraría y hasta dónde llegaría: instalación de GitHub, sitios, chat, guía, política, saldo del mes contra el techo de la prueba, pruebas abiertas y lo que el motor sume. Sale 0 si está todo listo y 4 si algo hay que arreglar (no_listo), con cada punto.",
+            flags: ["--repo owner/repo: el repo, si no es el «origin» de esta carpeta", "--json"],
+            ejemplos: ["supcoflow diagnosticar --json"],
+            codigos: [0, 1, 2, 3, 4],
+        },
+        {
+            nombre: "probar",
+            resumen: "Prueba la instalación de punta a punta: un problema entra por la misma puerta que el chat y termina en un issue. Gasta un relevamiento (hasta el techo que dice el motor; con la política guardar llega hasta el caso guardado y no gasta). Sin --autorizo-gasto no manda nada: sale 4 falta_autorizacion con techo_usd, saldo_usd, tope_usd y comprometido_usd. Con --autorizo-gasto pide la prueba y sale 5 con prueba_id; después --wait la sigue. Otros: 4 prueba_en_curso (con su id), techo_distinto, chat_deshabilitado, requiere_api_key, intento_pendiente; 6 tope_mensual; 1 con intento_pendiente: true si la respuesta no llegó (repetir retoma la misma prueba).",
+            flags: [
+                "--autorizo-gasto: autoriza el gasto de UNA prueba, hasta el techo que mostró el motor; sin él no se manda nada que escriba",
+                "--mensaje \"…\": el texto del problema de la prueba (por defecto, uno fijo del motor); con un pedido sin confirmar, otro --mensaje sale 4 intento_pendiente",
+                "--wait: sigue la última prueba hasta 90 s; sale 5 mientras corre, 0 con el issue (o guardado), 4 si hace falta mirarla (con el enlace a la bandeja); el cobro sale como esté (pendiente nunca es 0)",
+                "--prueba prb_…: con --wait, sigue esa prueba en vez de la última guardada",
+                "--repo owner/repo: el repo, si no es el «origin» de esta carpeta",
+                "--dry-run: dice qué haría (proyecto, techo, saldo, política) sin pedir nada que escriba",
+                "--json",
+            ],
+            ejemplos: ["supcoflow probar --json", "supcoflow probar --autorizo-gasto --json", "supcoflow probar --wait --json", "supcoflow probar --dry-run --autorizo-gasto --json"],
+            codigos: [0, 1, 2, 3, 4, 5, 6],
+        },
     ],
     flags_globales: ["--json: el resultado en una línea de JSON por stdout; los avisos van por stderr", "--help, -h: la ayuda con ejemplos"],
     facultades: [

package/dist/comandos/probar.js

@@ -0,0 +1,280 @@
+import { resultadoDeFallo, SALIDA } from "../contrato.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 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 ? "sin medir" : usd(n));
+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 = (g) => g.puntos.map((p) => `  [${p.ok ? "ok" : "falta"}] ${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);
+    }
+    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") };
+    }
+    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") };
+}
+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.prueba !== null) {
+        return fallo(SALIDA.entradaInvalida, "flags_incompatibles", "--prueba va con --wait: `supcoflow probar --wait --prueba prb_…`.");
+    }
+    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).");
+    }
+    let mensaje = null;
+    if (flags.mensaje !== null) {
+        mensaje = flags.mensaje.trim();
+        if (mensaje.length === 0 || mensaje.length > MAX_MENSAJE) {
+            return fallo(SALIDA.entradaInvalida, "mensaje_invalido", `--mensaje va con texto, hasta ${MAX_MENSAJE} caracteres.`);
+        }
+    }
+    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);
+    // ── 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) {
+        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"
+            ? `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)}).`;
+        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 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`;
+            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}`,
+            };
+        }
+        const message = `${gasto} Para lanzarla: \`supcoflow probar --autorizo-gasto\`. Antes, \`supcoflow diagnosticar\` dice si está todo listo.`;
+        return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "falta_autorizacion", message, ...datos }, texto: message };
+    }
+    // ── Con --autorizo-gasto: 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.");
+            }
+            intento = guardado.intento;
+        }
+        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 };
+            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 = `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}\`.`;
+            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\`.`,
+        };
+    }
+    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.`;
+        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("No pude cerrar el pedido guardado; el próximo `probar --autorizo-gasto` lo va a reenviar.");
+    }
+    return rechazo(r, d.avisar);
+}
+function enCurso(pruebaId) {
+    const message = `Ya hay una prueba de este proyecto sin desenlace (${pruebaId}). Seguila con \`supcoflow probar --wait --prueba ${pruebaId}\`.`;
+    return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "prueba_en_curso", message, prueba_id: pruebaId }, texto: message };
+}
+function rechazo(r, 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 };
+        }
+        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 = `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}`;
+            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.`);
+    }
+    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 `Costo: ${usd(c.usd)}.`;
+    if (c.estado === "pendiente")
+        return `Cobro pendiente: se lee unos minutos después del cierre (hasta ${usd(c.techo_usd)}).`;
+    if (c.estado === "perdido")
+        return `Cobro perdido: no se pudo leer el gasto (hasta ${usd(c.techo_usd)}).`;
+    if (c.estado === null)
+        return null;
+    return `Cobro: ${c.estado} (hasta ${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 = [
+        `Prueba ${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,
+        textoDelCobro(s.cobro),
+    ];
+    if (ABIERTOS.has(s.estado)) {
+        lineas.push("Volvé a correr `supcoflow probar --wait`.");
+        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}`);
+        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.`;
+    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 `--prueba` 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`.");
+            }
+        }
+        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_…`.");
+        }
+    }
+    // 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);
+}

package/dist/entorno.js

@@ -5,7 +5,7 @@ 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 { homedir, hostname } from "node:os";
 import { basename, dirname, join } from "node:path";
-import { buscarProyecto, canjear, configurar, leerWidget, 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, } from "./api.js";
 import { crearCandados } from "./candado.js";
 import { esCarpetaReal, rutaRealOEnNada } from "./comandos/instalacion.js";
 import { DESCRIPCION } from "./comandos/describir.js";
@@ -14,6 +14,7 @@ import { crearGuardado } from "./guardado/index.js";
 import { almacenDeLlavero } from "./guardado/llavero.js";
 import { crearGuardaDeSecretos } from "./secreto-a-archivo.js";
 import { crearRegistroDeIdempotencia } from "./idempotencia.js";
+import { crearRegistroDePruebas } from "./pruebas-guardadas.js";
 import { TRAMO_MAXIMO_MS } from "./sondeo.js";
 // El `.tmp` se crea en exclusiva (`wx`: falla si quedó algo, enlace incluido, en vez de escribir a
 // través de él) y el `fchmod` va aparte porque el modo de `open` pasa por la umask del proceso.
@@ -403,6 +404,11 @@ export function entornoReal(env = process.env) {
         ahora: Date.now,
         avisar,
     });
+    // El pedido de `probar` (intento + última prueba), con el mismo almacén y la misma regla: fuera de un repo.
+    const rutaDePruebas = join(dirname(rutaDelArchivo), "pruebas.json");
+    const pruebas = crearRegistroDePruebas({
+        origen: api.origin, almacen: almacenDeArchivo(rutaDePruebas, fsReal), rutaDelArchivo: rutaDePruebas, fs: fsReal, ahora: Date.now, avisar,
+    });
     const dormir = (ms) => new Promise((r) => setTimeout(r, ms));
     const cwd = process.cwd();
     // Los candados de `claves crear` viven al lado de las credenciales, nunca en un repo.
@@ -481,5 +487,12 @@ export function entornoReal(env = process.env) {
             escribir: archivosDelRepo(avisar).escribir,
             terminal: DESCRIPCION.version,
         },
+        prueba: {
+            api, guardado, git: gitReal, cwd, avisar, pruebas, generar: randomUUID, ahora: Date.now, dormir, tramoMs,
+            buscarProyecto: configurarEnElMotor.buscarProyecto,
+            leerDiagnostico: (a, clave, id) => leerDiagnostico(a, clave, id, fetch),
+            pedirPrueba: (a, clave, id, intento) => pedirPrueba(a, clave, id, intento, fetch),
+            leerPrueba: (a, clave, id, pruebaId, plazoMs) => leerPrueba(a, clave, id, pruebaId, fetch, plazoMs),
+        },
     };
 }

package/dist/flags-por-comando.js

@@ -7,10 +7,11 @@ const DE_CONFIGURAR_CON_REPO = [
     "guia revisar", "guia publicar", "guia ver", "guia usar",
 ];
 export const FLAGS_POR_COMANDO = [
-    { flags: ["start", "wait"], comandos: ["login", "repo conectar"], texto: "--start y --wait son de `supcoflow login` y `supcoflow repo conectar`." },
+    { 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: ["repo"], comandos: ["repo conectar", "proyecto crear", "proyecto ver", ...DE_CONFIGURAR_CON_REPO, "widget", "instalacion anotar"],
-        texto: "--repo es de `supcoflow repo conectar`, `proyecto crear|ver`, `widget`, `instalacion anotar` y los comandos que configuran un proyecto (no de `catalogo`).",
+        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: ["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`." },
@@ -22,6 +23,7 @@ export const FLAGS_POR_COMANDO = [
     { 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`." },
 ];
 /** El mensaje del primer flag presente que el comando no acepta, o null si todo aplica. */

package/dist/pruebas-guardadas.js

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

package/package.json

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