supcoflow 0.5.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 y configurar el chat.
+crear su proyecto, configurar el chat, ponerlo en la app y probar que un problema llega hasta un issue.
 
 ## Instalar
 
@@ -30,6 +30,8 @@ npx supcoflow login
 | `supcoflow guia publicar` | Sube `.supcoflow/guia.md` directo (con el commit y la rama que declara tu clon, no verificados en GitHub). `--desde-github` verifica contra la rama principal en vez de subir el archivo. |
 | `supcoflow guia ver` | Muestra la guía activa, de dónde viene y si la rama sigue al día. |
 | `supcoflow guia usar --origen repo\|agente` | Elige cuál guía queda activa. |
+| `supcoflow widget` | Lo que hay que pegar en la app para tener el chat (ver «Poner el chat en la app»). |
+| `supcoflow instalacion anotar --skill 0.1.0` | Anota en `.supcoflow/instalacion.json` con qué versiones se instaló el chat. |
 | `supcoflow describir --json` | Todo el contrato (comandos, flags, facultades de la clave, códigos) en una línea de JSON. |
 
 `supcoflow --help` (o `supcoflow <comando> --help`) muestra la ayuda con ejemplos. Los comandos de
@@ -117,6 +119,60 @@ Problemas comunes:                                            ← opcional; hast
 - Texto antes del primer `## ` que no sea el `# ` del título → error. Una etiqueta repetida en una sección →
   error. Una línea con `<` o `>` → error. Más de 64 KB → `guia_muy_grande`.
 
+## Poner el chat en la app
+
+`supcoflow widget` muestra lo que hay que pegar, armado por el motor con los ids de tu proyecto (no los
+copies a mano: un id mal copiado deja el chat invisible sin ningún error). No escribe archivos de la app:
+
+1. El paquete con su versión exacta (`npm i @supcoflow/chat@… --save-exact`, o lo mismo con tu gestor).
+2. **Next.js (App Router):** un archivo envoltorio en la ruta que sugiere el motor
+   (`app/_supcoflow/chat-de-soporte.tsx`; si la app usa `src/app`, dentro de `src/app`), con el contenido
+   tal cual. Hace falta porque el componente del chat usa hooks de React y no trae `"use client"`, y un
+   `layout.tsx` es de servidor por defecto: importarlo directo ahí no anda. El envoltorio es esa directiva
+   más el componente con los ids.
+3. Usar el envoltorio en el layout que cubre las pantallas donde se traban tus usuarios.
+4. Si la app tiene una política de contenido (CSP) con `connect-src`, agregarle el origen del chat
+   conservando lo que ya tiene (una segunda `connect-src` se ignora).
+
+La línea de `<script>` que también muestra está disponible pero no probada en una app real, y no es
+para Next.js. `supcoflow widget --json` devuelve el objeto del motor tal cual.
+
+Después, `supcoflow instalacion anotar --skill <versión> [--app <carpeta>]` deja en
+`.supcoflow/instalacion.json` (para commitear) con qué versiones quedó: la skill, la terminal, el chat
+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
+por vos: sesión, proyecto, configuración, guía, el chat en la app y el resumen.
+
+```bash
+npx skills add supcoflow/skills
+```
+
+Y en el asistente: `/supcoflow go`. Las decisiones sobre los datos de tus usuarios y qué pasa con cada
+problema te las pregunta siempre; no sube nada a GitHub.
+
 ## El contrato
 
 Pensado para que lo lea un programa, no sólo una persona:
@@ -126,7 +182,7 @@ Pensado para que lo lea un programa, no sólo una persona:
 - **Sin preguntas sin terminal interactiva** (o con `--json`): si falta un dato, sale 3 diciendo qué
   flag usar. `supcoflow login` sin terminal sale 3 y te indica el camino en dos pasos.
 - **`--dry-run`** donde se puede simular (`login`, `login --start`, `logout`, `repo conectar --start`,
-  `proyecto crear`, `guia revisar`, `guia publicar`, `guia usar`). `login --wait
+  `proyecto crear`, `guia revisar`, `guia publicar`, `guia usar`, `instalacion anotar`). `login --wait
   --dry-run` sale 3: sondear consume el código y no hay cómo simularlo.
 
 | Código | Quiere decir |

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.5.0); sólo identifica a la terminal
-// en los logs del motor, no decide nada.
-const VERSION = "0.5.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
@@ -312,3 +312,111 @@ export function leerGuia(api, clave, proyectoId, f) {
 export function elegirOrigen(api, clave, proyectoId, origen, f) {
     return conClave(api, clave, `${rutaDeLaGuia(proyectoId)}/origen`, { method: "POST", headers: JSON_BODY, body: JSON.stringify({ origen }) }, f);
 }
+// Se valida campo a campo: lo que se le pasa a la persona (y de ahí a un archivo de su app) no puede
+// ser algo a medias. `contenido` se guarda tal cual, sin tocarlo: los ids ya vienen puestos por el motor.
+function aWidget(v, status) {
+    const n = (typeof v.nextjs === "object" && v.nextjs !== null ? v.nextjs : {});
+    const s = (typeof v.script === "object" && v.script !== null ? v.script : {});
+    const [tenantId, projectId, backendUrl, version, instalar, csp] = [v.tenant_id, v.project_id, v.backend_url, v.version, v.instalar, v.csp].map(texto);
+    const [archivo, contenido, uso] = [n.archivo_sugerido, n.contenido, n.uso].map(texto);
+    const linea = texto(s.linea);
+    if (!tenantId || !projectId || !backendUrl || !version || !instalar || !csp || v.paquete !== "@supcoflow/chat"
+        || (n.estado !== "probando" && n.estado !== "soportado") || !archivo || !contenido || !uso
+        || s.estado !== "disponible_sin_soporte" || !linea)
+        throw inesperada(status);
+    return {
+        tenant_id: tenantId, project_id: projectId, backend_url: backendUrl, paquete: "@supcoflow/chat", version, instalar,
+        nextjs: { estado: n.estado, archivo_sugerido: archivo, contenido, uso },
+        script: { estado: "disponible_sin_soporte", linea },
+        csp,
+    };
+}
+export async function leerWidget(api, clave, proyectoId, f) {
+    const r = await conClave(api, clave, `/api/proyectos/${encodeURIComponent(proyectoId)}/widget`, { method: "GET" }, f);
+    if (r.status !== 200)
+        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

@@ -5,11 +5,13 @@ export const COMANDOS_COMPUESTOS = [
     "chat prender", "chat apagar", "chat marca", "chat logo", "sitios agregar", "sitios quitar",
     "datos fijar", "politica fijar", "claves crear", "claves listar", "claves revocar",
     "guia revisar", "guia publicar", "guia ver", "guia usar",
+    "instalacion anotar",
 ];
 // Sólo estas primeras palabras admiten una segunda: cualquier otro par sigue siendo «de más».
 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",
+    "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ó.
@@ -40,6 +42,11 @@ export function leerArgumentos(argv) {
                 id: { type: "string" },
                 origen: { type: "string" },
                 "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,
@@ -97,6 +104,11 @@ export function leerArgumentos(argv) {
             id: v.id ?? null,
             origen: v.origen ?? null,
             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

@@ -7,13 +7,16 @@ import { leerArgumentos } from "./argumentos.js";
 import { clavesCrear, clavesListar, clavesRevocar } from "./comandos/claves.js";
 import { chatLogo, chatMarca, chatPrenderApagar, comandoConfiguracion, sitios } from "./comandos/configurar.js";
 import { guiaPublicar, guiaRevisar, guiaUsar, guiaVer } from "./comandos/guia.js";
+import { instalacionAnotar } from "./comandos/instalacion.js";
 import { comandoCatalogo, datosFijar, politicaFijar } from "./comandos/datos-y-politica.js";
 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";
+import { widget } from "./comandos/widget.js";
 import { emitir, FalloDeLaTerminal, resultadoDeFallo, SALIDA } from "./contrato.js";
 import { entornoReal } from "./entorno.js";
 import { flagQueNoAplica } from "./flags-por-comando.js";
@@ -38,6 +41,8 @@ async function correr(argv) {
             sitio: flags.sitio !== null, titulo: flags.titulo !== null, saludo: flags.saludo !== null, tema: flags.tema.length > 0,
             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)
@@ -123,6 +128,14 @@ async function correr(argv) {
                 return { r: await guiaVer(e.guia, flags), json };
             case "guia usar":
                 return { r: await guiaUsar(e.guia, flags), json };
+            case "widget":
+                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.5.0";
+const VERSION = "0.7.0";
 export const DESCRIPCION = {
     version: VERSION,
     comandos: [
@@ -210,6 +210,48 @@ export const DESCRIPCION = {
             ejemplos: ["supcoflow guia usar --origen repo --json"],
             codigos: [0, 1, 2, 3, 4],
         },
+        {
+            nombre: "widget",
+            resumen: "Muestra lo que hay que pegar en la app para tener el chat, armado por el motor con los ids del proyecto: el paquete y su versión exacta, el archivo envoltorio de Next.js (`nextjs.contenido`, tal cual, sin reescribir los ids), cómo usarlo, la línea de CSP y la de <script> (no para Next.js). No escribe archivos. Sale 4 sin_proyecto si el repo no tiene proyecto; 1 respuesta_inesperada si el motor manda algo a medias.",
+            flags: ["--repo owner/repo: el repo, si no es el «origin» de esta carpeta", "--json: el objeto del motor tal cual"],
+            ejemplos: ["supcoflow widget --json"],
+            codigos: [0, 1, 2, 3, 4],
+        },
+        {
+            nombre: "instalacion anotar",
+            resumen: "Anota en .supcoflow/instalacion.json (la raíz de este clon) con qué versiones se instaló el chat: la skill, esta terminal, el paquete del chat (declarado en el package.json de la app e instalado en node_modules) y la configuración del proyecto; nunca un secreto ni una fecha. Repetir sin cambios no lo toca (sin_cambios: true). Lo reescribe sólo si git ya guarda el anterior: si tiene cambios sin commit (o está borrado sin commit) sale 4 cambios_sin_commit; si existe sin estar versionado (o ignorado), 4 archivo_no_versionado. Otros: 3 falta_skill / skill_invalida / app_fuera_del_repo / app_inexistente / sin_clon; 4 sin_proyecto / acuerdo_ilegible; 1 paquete_ilegible / configuracion_inesperada / archivo_no_escrito.",
+            flags: [
+                "--skill versión: la metadata.version de la skill que instala (semver, obligatorio; sin él sale 3 falta_skill sin pedir nada)",
+                "--app carpeta: la carpeta de la app, relativa a la raíz del repo (por defecto la raíz; fuera del repo sale 3 app_fuera_del_repo)",
+                "--repo owner/repo: el repo, si no es el «origin» de esta carpeta (sin clon local sale 3 sin_clon: el archivo va en el clon)",
+                "--dry-run: muestra el archivo y la diferencia sin escribir nada",
+                "--json",
+            ],
+            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/instalacion.js

@@ -0,0 +1,207 @@
+// src/comandos/instalacion.ts
+// `instalacion anotar --skill <versión> [--app <carpeta>] [--dry-run]` (bloque 6): deja en
+// `.supcoflow/instalacion.json` con qué versiones se instaló el chat. Lee la configuración del motor y los
+// `package.json` de la app y del paquete instalado; nunca ejecuta nada del repo (ni `npm ls` ni `node`).
+//
+// La regla de §13 («no pisa archivos ni cambios sin commit») adaptada a un archivo que tiene que poder cambiar
+// (decisión 11): se reescribe sólo si git ya guarda el anterior. El control se hace ANTES de escribir; si la
+// persona edita el archivo entre el control y el `rename`, su cambio se pierde. Esa carrera se acepta: es una
+// persona instalando, y el archivo lo escribe sólo este comando.
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { resultadoDeFallo, SALIDA, taparSecretos } from "../contrato.js";
+import { armarInstalacion, esSemver, PAQUETE_DEL_CHAT, RUTA_DE_LA_INSTALACION, serializar } from "../instalacion.js";
+import { repoPedido } from "../repo-local.js";
+import { fallo } from "./configurar.js";
+import { proyectoDelRepo } from "./proyecto-del-repo.js";
+export function esCarpetaReal(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function rutaRealOEnNada(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return null;
+    }
+}
+// Los package.json son chicos; uno de más de 1 MB no es el de una app ni el de un paquete.
+const TOPE_DEL_PACKAGE_JSON = 1024 * 1024;
+const TOPE_DEL_ARCHIVO = 64 * 1024;
+const adentro = (raiz, p) => p === raiz || p.startsWith(raiz + path.sep);
+const limpio = (t) => taparSecretos(t.replace(/[\u0000-\u001f\u007f-\u009f]/g, ""));
+function leerJson(d, p, nombre) {
+    const leido = d.leerArchivoChico(p, TOPE_DEL_PACKAGE_JSON);
+    if ("error" in leido) {
+        if (leido.error === "no existe")
+            return { ok: false, noExiste: true };
+        return { ok: false, noExiste: false, resultado: fallo(SALIDA.inesperado, "paquete_ilegible", `No leo ${nombre}: ${limpio(leido.error)}.`) };
+    }
+    try {
+        return { ok: true, valor: JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(leido.bytes)) };
+    }
+    catch {
+        return { ok: false, noExiste: false, resultado: fallo(SALIDA.inesperado, "paquete_ilegible", `${nombre} no es JSON válido.`) };
+    }
+}
+// Como lo resuelve Node desde la app (revisión externa, hallazgo 4): el primer `node_modules/@supcoflow/chat`
+// subiendo desde <app> hasta la raíz del repo. En un monorepo npm lo deja en la raíz; pnpm enlaza a
+// `node_modules/.pnpm/…`, adentro del repo. Si la ruta real sale del repo, no se lee: lo que hay afuera no es
+// de esta instalación y la terminal no lee fuera del repo por un enlace que el repo eligió.
+function paqueteInstalado(d, raiz, app, avisos) {
+    for (let dir = app;; dir = path.dirname(dir)) {
+        const candidato = path.join(dir, "node_modules", ...PAQUETE_DEL_CHAT.split("/"), "package.json");
+        const real = d.rutaReal(candidato);
+        if (real !== null) {
+            if (!adentro(raiz, real)) {
+                const aviso = `${path.relative(raiz, candidato)} apunta fuera del repo; no lo leo y anoto el chat instalado como null.`;
+                avisos.push(aviso);
+                d.avisar(aviso);
+                return { ok: true, valor: null };
+            }
+            const j = leerJson(d, real, `el package.json de ${PAQUETE_DEL_CHAT} instalado`);
+            if (j.ok)
+                return j;
+            // Existía hace un instante: si ahora no está, tampoco se anota «no está».
+            return { ok: false, resultado: j.noExiste ? fallo(SALIDA.inesperado, "paquete_ilegible", `No leo el package.json de ${PAQUETE_DEL_CHAT} instalado.`) : j.resultado };
+        }
+        if (dir === raiz || path.dirname(dir) === dir)
+            return { ok: true, valor: null };
+    }
+}
+async function estadoDelArchivo(d, raizGit, existe) {
+    const git = async (args) => {
+        const r = await d.git(args, raizGit);
+        if (r.codigo !== 0)
+            throw new Error(`git ${args[0]} falló; no escribo ${RUTA_DE_LA_INSTALACION} sin saber si tiene cambios.`);
+        return r.stdout;
+    };
+    const lineas = (await git(["status", "--porcelain", "--ignored", "--", RUTA_DE_LA_INSTALACION])).split("\n").filter((l) => l.trim() !== "");
+    if (lineas.some((l) => !l.startsWith("??") && !l.startsWith("!!")))
+        return "cambios_sin_commit";
+    if (lineas.length > 0)
+        return "archivo_no_versionado";
+    const versionado = (await git(["ls-files", "--", RUTA_DE_LA_INSTALACION])).trim() !== "";
+    return versionado || !existe ? "escribir" : "archivo_no_versionado";
+}
+// Un diff de líneas (LCS) para el texto: los dos lados son chicos. El anterior lo escribió quien sea, así que
+// sale limpio de control y de secretos; el JSON nunca lo lleva.
+function diff(antes, despues) {
+    if (antes === null)
+        return ["--- (no había archivo)", "+++ " + RUTA_DE_LA_INSTALACION, ...despues.trimEnd().split("\n").map((l) => "+ " + l)].join("\n");
+    const a = antes.replace(/\r\n?/g, "\n").replace(/\n$/, "").split("\n").map(limpio);
+    const b = despues.trimEnd().split("\n");
+    const n = a.length, m = b.length;
+    const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--)
+        for (let j = m - 1; j >= 0; j--)
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+    const lineas = ["--- " + RUTA_DE_LA_INSTALACION + " (antes)", "+++ " + RUTA_DE_LA_INSTALACION];
+    let i = 0, j = 0;
+    while (i < n || j < m) {
+        if (i < n && j < m && a[i] === b[j])
+            lineas.push("  " + a[i++]), j++;
+        else if (j < m && (i === n || lcs[i][j + 1] >= lcs[i + 1][j]))
+            lineas.push("+ " + b[j++]);
+        else
+            lineas.push("- " + a[i++]);
+    }
+    return lineas.join("\n");
+}
+const resumen = (x) => `skill ${x.skill}, terminal ${x.terminal}, chat declarado ${x.chat.declarado ?? "—"} / instalado ${x.chat.instalado ?? "—"}`;
+export async function instalacionAnotar(d, flags) {
+    if (flags.skill === null)
+        return fallo(SALIDA.entradaInvalida, "falta_skill", "Falta la versión de la skill: `supcoflow instalacion anotar --skill 0.1.0`.");
+    if (!esSemver(flags.skill))
+        return fallo(SALIDA.entradaInvalida, "skill_invalida", "--skill va con una versión semver (por ejemplo 0.1.0).");
+    // ─── La raíz y la app, antes de cualquier pedido ───
+    let raizGit;
+    try {
+        raizGit = (await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd })).raiz;
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+    if (raizGit === null)
+        return fallo(SALIDA.entradaInvalida, "sin_clon", `No tengo el clon de ese repo acá, y ${RUTA_DE_LA_INSTALACION} va en el clon: parate en el clon del repo.`);
+    const raiz = d.rutaReal(raizGit);
+    if (raiz === null)
+        return fallo(SALIDA.inesperado, "inesperado", "No pude resolver la raíz del repo.");
+    // `realpath` DESPUÉS de resolver: un `--app` que es un enlace hacia afuera tiene que quedar afuera (Review Focus 4).
+    const app = d.rutaReal(path.resolve(raiz, flags.app ?? "."));
+    if (app === null)
+        return fallo(SALIDA.entradaInvalida, "app_inexistente", "La carpeta de --app no existe (va relativa a la raíz del repo).");
+    if (!adentro(raiz, app))
+        return fallo(SALIDA.entradaInvalida, "app_fuera_del_repo", "--app tiene que ser una carpeta dentro del repo (relativa a su raíz).");
+    // Un archivo no es una app: sin esto, leer `<archivo>/package.json` daba ENOTDIR y salía `paquete_ilegible`.
+    if (!d.esCarpeta(app))
+        return fallo(SALIDA.entradaInvalida, "app_inexistente", "--app tiene que ser una carpeta (la de la app), no un archivo.");
+    // ─── Proyecto → configuración → package.json de la app → paquete instalado → armar ───
+    const p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    let configuracion;
+    try {
+        configuracion = await d.leerConfiguracion(d.api, p.clave, p.proyecto.id);
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+    const deLaApp = leerJson(d, path.join(app, "package.json"), "el package.json de la app");
+    if (!deLaApp.ok && !deLaApp.noExiste)
+        return deLaApp.resultado;
+    const avisos = [];
+    const instalado = paqueteInstalado(d, raiz, app, avisos);
+    if (!instalado.ok)
+        return instalado.resultado;
+    let x;
+    try {
+        x = armarInstalacion({ skill: flags.skill, terminal: d.terminal, paqueteDeLaApp: deLaApp.ok ? deLaApp.valor : null, paqueteInstalado: instalado.valor, configuracion });
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+    const nuevo = serializar(x);
+    // ─── ¿Se puede escribir? ───
+    const archivo = path.join(raiz, RUTA_DE_LA_INSTALACION);
+    // Una `.supcoflow` que es un enlace hacia afuera: ni se lee (el diff mostraría un archivo de afuera) ni se escribe.
+    const carpeta = d.rutaReal(path.dirname(archivo));
+    if (carpeta !== null && !adentro(raiz, carpeta))
+        return fallo(SALIDA.inesperado, "inesperado", `${path.dirname(RUTA_DE_LA_INSTALACION)} no es una carpeta del repo (¿un enlace?); no escribo ahí.`);
+    const actual = d.leerArchivoChico(archivo, TOPE_DEL_ARCHIVO);
+    const existe = !("error" in actual) || actual.error !== "no existe";
+    const json = { ok: true, ruta: RUTA_DE_LA_INSTALACION, instalacion: x, ...(avisos.length > 0 ? { avisos } : {}) };
+    if ("bytes" in actual && Buffer.from(actual.bytes).equals(Buffer.from(nuevo, "utf8"))) {
+        return { codigo: SALIDA.ok, json: { ...json, ...(flags.dryRun ? { dry_run: true } : {}), sin_cambios: true }, texto: `${RUTA_DE_LA_INSTALACION} ya dice eso (${resumen(x)}); no lo toqué.` };
+    }
+    let estado;
+    try {
+        estado = await estadoDelArchivo(d, raizGit, existe);
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+    if (estado === "cambios_sin_commit") {
+        return fallo(SALIDA.haceFaltaUnaPersona, "cambios_sin_commit", `${RUTA_DE_LA_INSTALACION} tiene cambios sin commit (o se borró sin commit); no lo toqué. Commitealos o descartalos y volvé a correr.`);
+    }
+    if (estado === "archivo_no_versionado") {
+        return fallo(SALIDA.haceFaltaUnaPersona, "archivo_no_versionado", `Ya hay un ${RUTA_DE_LA_INSTALACION} que git no guarda (sin commit o ignorado); no lo pisé. Commitealo o borralo y volvé a correr.`);
+    }
+    const antes = "bytes" in actual ? Buffer.from(actual.bytes).toString("utf8") : null;
+    const cambios = existe && antes === null ? `(el archivo anterior no se lee)\n${diff(null, nuevo)}` : diff(antes, nuevo);
+    if (flags.dryRun) {
+        return { codigo: SALIDA.ok, json: { ...json, dry_run: true, sin_cambios: false }, texto: `Con --dry-run no escribo; sin él anotaría (${resumen(x)}):\n${cambios}` };
+    }
+    try {
+        d.escribir(archivo, nuevo);
+    }
+    catch {
+        return fallo(SALIDA.inesperado, "archivo_no_escrito", `No pude escribir ${RUTA_DE_LA_INSTALACION}. Volvé a correr \`supcoflow instalacion anotar\`.`);
+    }
+    return { codigo: SALIDA.ok, json: { ...json, sin_cambios: false }, texto: `Anoté ${RUTA_DE_LA_INSTALACION} (${resumen(x)}); commitealo cuando quieras.\n${cambios}` };
+}

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/comandos/widget.js

@@ -0,0 +1,32 @@
+import { resultadoDeFallo, SALIDA } from "../contrato.js";
+import { proyectoDelRepo } from "./proyecto-del-repo.js";
+function textoDe(w) {
+    return [
+        "1. Instalá el paquete (con el gestor de la app, la versión exacta):",
+        `   ${w.instalar}`,
+        "",
+        `2. Creá el archivo ${w.nextjs.archivo_sugerido} con este contenido (Next.js, ${w.nextjs.estado}):`,
+        w.nextjs.contenido.trimEnd(),
+        "",
+        "3. Usalo en el layout que cubre las pantallas donde se traban los usuarios:",
+        `   ${w.nextjs.uso}`,
+        "",
+        "4. Política de contenido (CSP): si la app tiene `connect-src`, agregale este origen conservando lo que ya tiene:",
+        `   ${w.csp}`,
+        "",
+        "Alternativa con <script> (disponible, no probada en una app real):",
+        `   ${w.script.linea}`,
+    ].join("\n");
+}
+export async function widget(d, flags) {
+    const p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    try {
+        const w = await d.leerWidget(d.api, p.clave, p.proyecto.id);
+        return { codigo: SALIDA.ok, json: { ok: true, ...w }, texto: textoDe(w) };
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+}

package/dist/entorno.js

@@ -5,13 +5,16 @@ 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, 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";
 import { almacenDeArchivo } from "./guardado/archivo.js";
 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.
@@ -401,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.
@@ -466,5 +474,25 @@ export function entornoReal(env = process.env) {
             esClaveDeConsultaDelProyecto: (a, clave, id) => esClaveDeConsultaDelProyecto(a, clave, id, fetch),
             idempotencia, candados, secretos,
         },
+        widget: {
+            api, guardado, git: gitReal, cwd,
+            buscarProyecto: configurarEnElMotor.buscarProyecto,
+            leerWidget: (a, clave, id) => leerWidget(a, clave, id, fetch),
+        },
+        // La versión que se anota es la de `describir` (pinzada contra package.json por test): una sola fuente
+        // para lo que la terminal dice de sí misma.
+        instalacion: {
+            ...configurarEnElMotor,
+            leerArchivoChico, rutaReal: rutaRealOEnNada, esCarpeta: esCarpetaReal,
+            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],
-        texto: "--repo es de `supcoflow repo conectar`, `proyecto crear|ver` 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,8 @@ 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. */
 export function flagQueNoAplica(comando, presentes) {

package/dist/instalacion.js

@@ -0,0 +1,86 @@
+// `.supcoflow/instalacion.json` (bloque 6, decisión 3): con qué versiones se hizo la instalación, anotado en el
+// repo de quien instala. Supcoflow no lo guarda ni lo ve. Puro: recibe lo ya leído y arma el archivo.
+//
+// El archivo queda en el repo y se commitea: un secreto acá se publica con el primer `push`. Por eso se arma con
+// una LISTA CERRADA de campos, cada uno validado por separado; nunca un `...configuracion` (la configuración del
+// motor trae `fijado_por`, `publicada_por`, huellas y lo que el motor agregue mañana: nada de eso es de este archivo).
+import { FalloDeLaTerminal, SALIDA, taparSecretos } from "./contrato.js";
+export const RUTA_DE_LA_INSTALACION = ".supcoflow/instalacion.json";
+export const PAQUETE_DEL_CHAT = "@supcoflow/chat";
+// SemVer 2.0 tal cual, con tope de largo: la versión de la skill la escribe un asistente y queda en el repo.
+const SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+export const esSemver = (s) => s.length <= 64 && SEMVER.test(s);
+const objeto = (v) => (typeof v === "object" && v !== null && !Array.isArray(v) ? v : null);
+const entero = (v) => typeof v === "number" && Number.isInteger(v) && v >= 1;
+const ilegible = (message) => new FalloDeLaTerminal(SALIDA.inesperado, "paquete_ilegible", message);
+const inesperada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "configuracion_inesperada", `El motor contestó la configuración con ${que} que no entiendo; no anoto nada a medias. Probá de nuevo en un rato.`);
+// Lo declarado en el `package.json` de la app lo escribió quien escribió el repo: puede ser un rango, un alias o
+// cualquier cosa. Se copia tal cual sólo si es texto imprimible y corto; si no, no se adivina (`paquete_ilegible`).
+// `taparSecretos` igual, por si alguien pegó una clave ahí: el archivo nuevo no la repite.
+function declaradoEn(app) {
+    const a = objeto(app);
+    if (a === null)
+        return null;
+    const v = objeto(a.dependencies)?.[PAQUETE_DEL_CHAT] ?? objeto(a.devDependencies)?.[PAQUETE_DEL_CHAT];
+    if (v === undefined || v === null)
+        return null;
+    if (typeof v !== "string" || v.length === 0 || v.length > 200 || !/^[\x20-\x7e]+$/.test(v)) {
+        throw ilegible(`La versión de ${PAQUETE_DEL_CHAT} en el package.json de la app no se entiende; no la anoto.`);
+    }
+    return taparSecretos(v);
+}
+// `null` es «no está instalado». Un archivo que existe pero sin versión válida NO es null: diría que no está.
+function instaladoEn(paquete) {
+    if (paquete === null)
+        return null;
+    const v = objeto(paquete)?.version;
+    if (typeof v !== "string" || !esSemver(v))
+        throw ilegible(`El package.json de ${PAQUETE_DEL_CHAT} instalado no trae una versión que entienda.`);
+    return v;
+}
+function acuerdoDe(c) {
+    if (c.acuerdo === null)
+        return null;
+    const a = objeto(c.acuerdo);
+    // Ilegible es un estado conocido del motor (aplica cerrado), no «sin acuerdo»: anotarlo como null mentiría.
+    if (a?.ilegible === true) {
+        throw new FalloDeLaTerminal(SALIDA.haceFaltaUnaPersona, "acuerdo_ilegible", "El acuerdo de datos está fijado pero no se lee: revisalo en la consola y volvé a correr.");
+    }
+    if (a === null || !entero(a.version))
+        throw inesperada("un acuerdo");
+    return a.version;
+}
+function politicaDe(c) {
+    const modo = objeto(c.politica)?.modo;
+    if (modo !== "relevar" && modo !== "guardar")
+        throw inesperada("una política");
+    return modo;
+}
+function guiaDe(c) {
+    if (c.guia === null)
+        return null;
+    const g = objeto(c.guia);
+    if (g?.origen === "repo") {
+        if (g.procedencia !== "terminal" && g.procedencia !== "github")
+            throw inesperada("una guía");
+        if (g.commit !== null && (typeof g.commit !== "string" || !/^[0-9a-f]{40}$/.test(g.commit)))
+            throw inesperada("una guía");
+        return { origen: "repo", procedencia: g.procedencia, commit: g.commit };
+    }
+    if (g?.origen === "agente" && entero(g.version))
+        return { origen: "agente", version: g.version };
+    throw inesperada("una guía");
+}
+export function armarInstalacion(i) {
+    return {
+        version: 1,
+        skill: i.skill,
+        terminal: i.terminal,
+        chat: { declarado: declaradoEn(i.paqueteDeLaApp), instalado: instaladoEn(i.paqueteInstalado) },
+        configuracion: { acuerdo_version: acuerdoDe(i.configuracion), politica: politicaDe(i.configuracion), guia: guiaDe(i.configuracion) },
+    };
+}
+// El orden de las claves es el de `armarInstalacion`: el mismo estado da los mismos bytes, y eso es `sin_cambios`.
+export function serializar(x) {
+    return JSON.stringify(x, null, 2) + "\n";
+}

package/dist/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.5.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" },