supcoflow 0.8.0 → 0.9.0

package/dist/comandos/instalacion.js

@@ -1,8 +1,9 @@
 // src/comandos/instalacion.ts
-// `install record --skill <versión> [--app <carpeta>] [--file <ruta>] [--dry-run]` (bloque 6 y 0.8.0): deja en
-// `.supcoflow/instalacion.json` con qué versiones se instaló el chat y, desde la 0.8.0 (v2), en qué archivo quedó
-// (`--file`). 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`).
+// `install record --skill <versión> [--app <carpeta>] [--file <ruta>]... [--shape widget|own-interface] [--dry-run]`
+// (bloque 6, 0.8.0 y 0.9.0): deja en `.supcoflow/instalacion.json` con qué versiones se instaló el chat y, desde la 0.9.0
+// (v3, T8), qué se instaló (`--shape`: el widget o una interfaz propia de la app), en qué archivos quedó (`--file`, repetible)
+// y qué versión del contrato de presentación trae el paquete instalado (su `contract.json`). Lee la configuración del motor y
+// los `package.json` y `contract.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
@@ -11,11 +12,13 @@
 import { lstatSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 import { resultadoDeFallo, SALIDA, taparSecretos } from "../contrato.js";
-import { archivoAnotado, armarInstalacion, esSemver, PAQUETE_DEL_CHAT, RUTA_DE_LA_INSTALACION, serializar, validarElArchivoDelChat } from "../instalacion.js";
+import { anotadoEn, armarInstalacion, leerInstalacionAnotada, esSemver, PAQUETE_DEL_CHAT, RUTA_DE_LA_INSTALACION, serializar, validarLosArchivos } from "../instalacion.js";
 import { NO_LEIDO } from "../lectura.js";
 import { repoPedido } from "../repo-local.js";
 import { fallo } from "./configurar.js";
 import { proyectoDelRepo } from "./proyecto-del-repo.js";
+// `--shape` en inglés; al archivo va el nombre de la API (como `--mode save` y `guardar`).
+const FORMA_DE_LA_FLAG = { widget: "widget", "own-interface": "interfaz_propia" };
 export function esEnlaceReal(p) {
     try {
         return lstatSync(p).isSymbolicLink();
@@ -59,10 +62,22 @@ function leerJson(d, p, nombre) {
         return { ok: false, noExiste: false, resultado: fallo(SALIDA.inesperado, "paquete_ilegible", `${nombre} isn't valid JSON.`) };
     }
 }
-// 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 contratoDelPaquete(d, raiz, carpetaReal, avisos) {
+    const candidato = path.join(carpetaReal, "contract.json");
+    const real = d.rutaReal(candidato);
+    if (real === null)
+        return { ok: true, valor: null };
+    if (!adentro(raiz, real)) {
+        const aviso = `${path.relative(raiz, candidato)} points outside the repo; I don't read it and I record the contract as null.`;
+        avisos.push(aviso);
+        d.avisar(aviso);
+        return { ok: true, valor: null };
+    }
+    const j = leerJson(d, real, `the contract.json of ${PAQUETE_DEL_CHAT}`);
+    if (j.ok)
+        return j;
+    return { ok: false, resultado: j.noExiste ? fallo(SALIDA.inesperado, "paquete_ilegible", `I can't read the contract.json of ${PAQUETE_DEL_CHAT}.`) : j.resultado };
+}
 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");
@@ -72,16 +87,18 @@ function paqueteInstalado(d, raiz, app, avisos) {
                 const aviso = `${path.relative(raiz, candidato)} points outside the repo; I don't read it and I record the installed chat as null.`;
                 avisos.push(aviso);
                 d.avisar(aviso);
-                return { ok: true, valor: null };
+                return { ok: true, valor: null, contrato: null };
             }
             const j = leerJson(d, real, `the installed package.json of ${PAQUETE_DEL_CHAT}`);
-            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", `I can't read the installed package.json of ${PAQUETE_DEL_CHAT}.`) : j.resultado };
+            if (!j.ok) {
+                // 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", `I can't read the installed package.json of ${PAQUETE_DEL_CHAT}.`) : j.resultado };
+            }
+            const c = contratoDelPaquete(d, raiz, path.dirname(real), avisos);
+            return c.ok ? { ok: true, valor: j.valor, contrato: c.valor } : c;
         }
         if (dir === raiz || path.dirname(dir) === dir)
-            return { ok: true, valor: null };
+            return { ok: true, valor: null, contrato: null };
     }
 }
 async function estadoDelArchivo(d, raizGit, existe) {
@@ -123,30 +140,41 @@ function diff(antes, despues) {
     }
     return lineas.join("\n");
 }
-const resumen = (x) => `skill ${x.skill}, terminal ${x.terminal}, chat declared ${x.chat.declarado ?? "—"} / installed ${x.chat.instalado ?? "—"}${x.archivo !== null ? `, file ${x.archivo}` : ""}`;
+const resumen = (x) => `skill ${x.skill}, terminal ${x.terminal}, chat declared ${x.chat.declarado ?? "—"} / installed ${x.chat.instalado ?? "—"}`
+    + `${x.forma === null ? "" : `, ${x.forma === "widget" ? "widget" : "own interface"}`}`
+    + `${x.archivos.length === 0 ? "" : `, ${x.archivos.length === 1 ? "file" : "files"} ${x.archivos.join(", ")}`}`
+    + `${x.contrato === null ? "" : `, contract ${x.contrato}`}`;
 export async function instalacionAnotar(d, flags) {
     if (flags.skill === null)
         return fallo(SALIDA.entradaInvalida, "falta_skill", "The skill version is missing: `supcoflow install record --skill 0.1.0`.");
     if (!esSemver(flags.skill))
         return fallo(SALIDA.entradaInvalida, "skill_invalida", "--skill goes with a semver version (for example 0.1.0).");
-    // El archivo del chat se mira antes de cualquier pedido: una ruta imposible no gasta una vuelta al motor.
-    let archivoPedido = null;
-    if (flags.file !== undefined && flags.file !== null) {
-        const v = validarElArchivoDelChat(flags.file);
+    // La forma y los archivos del chat se miran antes de cualquier pedido: algo imposible no gasta una vuelta al motor.
+    let formaPedida = null;
+    if (flags.shape !== undefined && flags.shape !== null) {
+        formaPedida = Object.hasOwn(FORMA_DE_LA_FLAG, flags.shape) ? FORMA_DE_LA_FLAG[flags.shape] : null;
+        if (formaPedida === null)
+            return fallo(SALIDA.entradaInvalida, "forma_invalida", "--shape goes with `widget` (the packaged widget) or `own-interface` (a chat the app builds with its own components).");
+    }
+    const crudos = flags.files !== undefined && flags.files.length > 0 ? flags.files : flags.file !== undefined && flags.file !== null ? [flags.file] : [];
+    let archivosPedidos = null;
+    if (crudos.length > 0) {
+        const v = validarLosArchivos(crudos);
         if (!v.ok)
             return fallo(SALIDA.entradaInvalida, "archivo_invalido", v.motivo);
-        archivoPedido = v.ruta;
+        archivosPedidos = v.rutas;
     }
     // ─── La raíz y la app, antes de cualquier pedido ───
     let raizGit;
+    let sinClon;
     try {
-        raizGit = (await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd })).raiz;
+        ({ raiz: raizGit, sinClon } = await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd }));
     }
     catch (e) {
         return resultadoDeFallo(e);
     }
     if (raizGit === null)
-        return fallo(SALIDA.entradaInvalida, "sin_clon", `I don't have that repo's clone here, and ${RUTA_DE_LA_INSTALACION} goes in the clone: stand in the repo's clone.`);
+        return fallo(SALIDA.entradaInvalida, "sin_clon", `${sinClon ?? "I don't have that repo's clone here."} ${RUTA_DE_LA_INSTALACION} goes in the repo's clone: stand in it.`);
     const raiz = d.rutaReal(raizGit);
     if (raiz === null)
         return fallo(SALIDA.inesperado, "inesperado", "I couldn't resolve the repo's root.");
@@ -161,7 +189,7 @@ export async function instalacionAnotar(d, flags) {
         return fallo(SALIDA.entradaInvalida, "app_inexistente", "--app has to be a folder (the app's), not a file.");
     // `--file`: ni un enlace simbólico ni un camino que pase por uno (saldría del repo sin que se vea). El archivo todavía
     // puede no existir (con `--dry-run` se anota antes de escribirlo), pero ninguna carpeta del camino puede ser un enlace.
-    if (archivoPedido !== null) {
+    for (const archivoPedido of archivosPedidos ?? []) {
         const partes = archivoPedido.split("/");
         for (let i = 1; i <= partes.length; i++) {
             if (d.esEnlace(path.join(raiz, ...partes.slice(0, i)))) {
@@ -196,18 +224,32 @@ export async function instalacionAnotar(d, flags) {
     const actual = d.leerArchivoChico(archivo, TOPE_DEL_ARCHIVO);
     const existe = !("error" in actual) || actual.error !== NO_LEIDO.noExiste;
     const antes = "bytes" in actual ? Buffer.from(actual.bytes).toString("utf8") : null;
-    // Re-correr sin `--file` no borra el archivo que ya se anotó; un v1 (sin `archivo`) da null, sin error.
-    const archivoDelChat = archivoPedido ?? archivoAnotado(antes);
+    // Re-correr sin `--shape` ni `--file` no borra lo que ya se anotó (v2: su `archivo` es el widget; v1: nada, sin error).
+    // `--file` reemplaza la lista entera y `--shape` la forma: lo que se pide manda, lo que no, se conserva.
+    // Un archivo de una terminal más nueva no se reescribe: se perdería lo que esa versión anotó.
+    if (leerInstalacionAnotada(antes).estado === "mas_nueva") {
+        return fallo(SALIDA.haceFaltaUnaPersona, "escrito_por_una_terminal_mas_nueva", `${RUTA_DE_LA_INSTALACION} was written by a newer supcoflow than this one; I didn't touch it. Update supcoflow (\`npx supcoflow@latest\`) and run again.`);
+    }
+    const anotado = anotadoEn(antes);
+    // Cambiar la forma sin decir los archivos no hereda los de la forma anterior (el envoltorio del widget no es la interfaz propia).
+    const cambiaLaForma = formaPedida !== null && anotado.forma !== null && formaPedida !== anotado.forma;
     let x;
     try {
-        x = armarInstalacion({ skill: flags.skill, terminal: d.terminal, paqueteDeLaApp: deLaApp.ok ? deLaApp.valor : null, paqueteInstalado: instalado.valor, configuracion, archivo: archivoDelChat });
+        x = armarInstalacion({
+            skill: flags.skill, terminal: d.terminal, paqueteDeLaApp: deLaApp.ok ? deLaApp.valor : null, paqueteInstalado: instalado.valor, configuracion,
+            forma: formaPedida ?? anotado.forma, archivos: archivosPedidos ?? (cambiaLaForma ? [] : anotado.archivos), contrato: instalado.contrato,
+        });
     }
     catch (e) {
         return resultadoDeFallo(e);
     }
     const nuevo = serializar(x);
     // ─── ¿Se puede escribir? ───
-    const json = { ok: true, ruta: RUTA_DE_LA_INSTALACION, instalacion: x, archivo: x.archivo, ...(avisos.length > 0 ? { avisos } : {}) };
+    // `archivo` (el primero) sigue en el JSON por las skills de antes de la 0.9.0; lo nuevo es `archivos`, `forma` y `contrato`.
+    const json = {
+        ok: true, ruta: RUTA_DE_LA_INSTALACION, instalacion: x, archivo: x.archivos[0] ?? null, archivos: x.archivos, forma: x.forma, contrato: x.contrato,
+        ...(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} already says that (${resumen(x)}); I didn't touch it.` };
     }

package/dist/comandos/probar.js

@@ -1,5 +1,30 @@
+// `supcoflow diagnose` y `supcoflow test` (bloque 7, la prueba): ¿un problema que entra por el
+// chat llega hasta un issue? El diagnóstico es gratis y sólo lee. La prueba gasta un relevamiento (techo
+// del motor, hoy US$ 2): sin `--authorize-spend` no se manda nada que escriba (R6).
+//
+// Lo que la persona vio es lo que viaja (R5, 0.8.0): `--authorize-spend` exige `--ceiling` (el número que se le
+// mostró) y `--expect-policy` (la política con la que se le ofreció) y manda esos dos valores; no relee el
+// diagnóstico para elegirlos. El motor los compara con los de ahora: `techo_distinto` / `politica_distinta` salen
+// 4 con los valores nuevos y sin reintentar, y la persona decide de nuevo. El alias viejo `probar --autorizo-gasto`
+// exige también `--ceiling` (un alias no puede ampliar lo autorizado) pero no `--expect-policy`.
+//
+// El ciclo de la clave (hallazgo 5), en el orden en que se lee abajo:
+//   1. Sin intento guardado: clave nueva, y el intento ENTERO guardado antes del POST (estricto).
+//   2. Con intento guardado: es un reintento; misma clave, mismo mensaje, mismo techo, misma política. Otro
+//      `--message`, otro `--ceiling` u otra `--expect-policy` sale 4 `intento_pendiente` sin mandar nada.
+//   3. 202: la última prueba = la del motor y el intento cerrado, en una escritura (src/pruebas-guardadas.ts).
+//      Si falla, sale 1 con el id y el intento sigue abierto: el próximo recibe la misma prueba.
+//   4. Ambigua (sin respuesta, 5xx, pausa, otro intento en curso): el intento se conserva. Rechazo
+//      definitivo: se cierra, el motor no creó nada con esa clave.
+//   5. Una prueba nueva es `test --authorize-spend` sin intento abierto: clave nueva aunque el mensaje
+//      sea el mismo.
+//
+// `--wait` sigue la prueba por tramos (≤ 90 s el comando entero, como `login --wait`): el estado lo deriva
+// el motor en cada llamada y acá sólo se traduce a un código de salida con la tabla de la prueba.
+import path from "node:path";
 import { resultadoDeFallo, SALIDA } from "../contrato.js";
-import { agruparPuntos, contarBuenos, lineaDeLoRevisado, nombreDelPunto, puntoDeSesion, puntoDelRepo, TOTAL_DE_INSTALACION } from "../diagnostico.js";
+import { agruparPuntos, contarBuenos, lineaDeLoRevisado, nombreDelPunto, puntoDeLaInterfaz, puntoDeSesion, puntoDelRepo, TOTAL_DE_INSTALACION } from "../diagnostico.js";
+import { leerInstalacionAnotada, RUTA_DE_LA_INSTALACION } from "../instalacion.js";
 import { leerRepoLocal } from "../repo-local.js";
 import { PLAZO_MINIMO_DE_SONDEO_MS, TRAMO_MAXIMO_MS } from "../sondeo.js";
 import { fallo, rutaDe } from "./configurar.js";
@@ -44,6 +69,61 @@ function datosDelDiagnostico(g) {
     };
 }
 const lineasDePuntos = (puntos, nombre = (p) => p) => puntos.map((p) => `  [${p.ok ? "ok" : "missing"}] ${nombre(p.punto)}: ${p.mensaje}`);
+// Lo que esta máquina puede o no hacer con el pedido de la prueba, visto ANTES del OK de gasto y sin escribir nada. Un
+// prechequeo que falla es «no ok», nunca un error: avisar tarde es justo lo que esto evita.
+async function revisarLaMaquina(d, proyectoId) {
+    try {
+        return await d.pruebas.revisar(proyectoId);
+    }
+    catch {
+        return { maquina: { ok: false, impedimentos: [{ codigo: "no_se_pudo_revisar", detalle: "I couldn't check whether this machine can save the test request." }] }, intentoPendiente: null };
+    }
+}
+const datosDeLaMaquina = (r) => ({ maquina: r.maquina });
+const datosDelIntentoPendiente = (r) => ({
+    intento_pendiente: r.intentoPendiente === null ? null : { techo_usd: r.intentoPendiente.techoUsd, politica: r.intentoPendiente.politica },
+});
+const detalles = (r) => r.maquina.impedimentos.map((i) => i.detalle).join(" ");
+function puntoDeLaMaquina(r) {
+    return r.maquina.ok
+        ? { punto: "maquina", ok: true, mensaje: "No obstacle found to saving the test request on this machine.", grupo: "prueba" }
+        : { punto: "maquina", ok: false, mensaje: `This machine can't save the test request yet: ${detalles(r)}`, grupo: "prueba" };
+}
+// El punto 7 (T8): lee `.supcoflow/instalacion.json` del clon y, sólo si hay una interfaz propia anotada, mira que sus archivos
+// sigan y le pregunta al proyecto qué contrato declara hoy. Todo lo que no se pueda mirar queda «sin mirar», nunca en contra.
+async function puntoDeLaInterfazDeEsteClon(d, local, proyecto, clave) {
+    const esElClon = local.raiz !== null && local.repo !== null && local.repo.toLowerCase() === proyecto.repo.toLowerCase();
+    if (!esElClon || d.archivos === undefined)
+        return puntoDeLaInterfaz({ lectura: null, faltan: [], delProyecto: null });
+    let lectura;
+    try {
+        lectura = leerInstalacionAnotada(d.archivos.leer(path.join(local.raiz, RUTA_DE_LA_INSTALACION)));
+    }
+    catch {
+        lectura = { estado: "ilegible" };
+    }
+    if (lectura.estado !== "leida" || lectura.forma !== "interfaz_propia")
+        return puntoDeLaInterfaz({ lectura, faltan: [], delProyecto: null });
+    const faltan = lectura.archivos.filter((f) => {
+        try {
+            const completo = path.join(local.raiz, f);
+            return d.existe !== undefined ? !d.existe(completo) : d.archivos.leer(completo) === null;
+        }
+        catch {
+            return true;
+        }
+    });
+    let delProyecto = null;
+    if (d.leerWidget !== undefined) {
+        try {
+            delProyecto = (await d.leerWidget(d.api, clave, proyecto.id)).interfaz_propia?.contrato.version ?? null;
+        }
+        catch {
+            delProyecto = null; // no se pudo preguntar: no se compara
+        }
+    }
+    return puntoDeLaInterfaz({ lectura, faltan, delProyecto });
+}
 export async function diagnosticar(d, flags) {
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
@@ -64,16 +144,23 @@ export async function diagnosticar(d, flags) {
     catch {
         local = { repo: null, raiz: null, motivo: "sin_git" };
     }
-    const { instalacion, prueba } = agruparPuntos(g, [puntoDeSesion(), puntoDelRepo(local, p.proyecto.repo)]);
+    const agrupados = agruparPuntos(g, [puntoDeSesion(), puntoDelRepo(local, p.proyecto.repo), await puntoDeLaInterfazDeEsteClon(d, local, p.proyecto, p.clave)]);
+    const instalacion = agrupados.instalacion;
+    // El punto local de la prueba (1A.1): ¿esta máquina puede guardar el pedido? Si no, la prueba no entra, y se dice acá y
+    // no después del OK de gasto. No cuenta en el «N of 7» de la instalación.
+    const revision = await revisarLaMaquina(d, p.proyecto.id);
+    const prueba = [puntoDeLaMaquina(revision), ...agrupados.prueba];
     const buenos = contarBuenos(instalacion);
-    const listo = g.listo && instalacion.every((x) => x.ok || !["sign-in", "repo"].includes(x.punto));
+    const listo = g.listo && revision.maquina.ok && instalacion.every((x) => x.ok || !["sign-in", "repo"].includes(x.punto));
     const datos = {
         proyecto: { id: p.proyecto.id, repo: p.proyecto.repo },
         ...datosDelDiagnostico(g),
         listo,
         puntos: [...instalacion, ...prueba],
         instalacion: { ok: buenos, total: TOTAL_DE_INSTALACION, puntos: instalacion },
-        prueba: { listo: g.listo, puntos: prueba },
+        prueba: { listo: g.listo && revision.maquina.ok, puntos: prueba },
+        ...datosDeLaMaquina(revision),
+        ...datosDelIntentoPendiente(revision),
     };
     const resumen = `Monthly balance ${usdONull(g.saldoUsd)} of ${usdONull(g.topeUsd)}; a test authorizes up to ${usd(g.techoUsd)}. Policy: ${enInglesLaPolitica(g.politica)}.`;
     const motivos = [
@@ -155,7 +242,9 @@ export async function probar(d, flags) {
         catch (e) {
             return resultadoDeFallo(e);
         }
-        const datos = { proyecto: { id: proyecto.id, repo: proyecto.repo }, ...datosDelDiagnostico(g) };
+        // Lo que esta máquina puede hacer con el pedido, visto ANTES del sí de gasto (fricción 3).
+        const revision = await revisarLaMaquina(d, proyecto.id);
+        const datos = { proyecto: { id: proyecto.id, repo: proyecto.repo }, ...datosDelDiagnostico(g), ...datosDeLaMaquina(revision) };
         const gasto = g.politica === "guardar"
             ? `With the \`save\` policy the test goes as far as the saved case and spends nothing; the ceiling it authorizes is still ${usd(g.techoUsd)}.`
             : `A test runs an investigation that spends up to ${usd(g.techoUsd)} (monthly balance ${usdONull(g.saldoUsd)} of ${usdONull(g.topeUsd)}).`;
@@ -180,8 +269,13 @@ export async function probar(d, flags) {
             };
         }
         const lanzar = `supcoflow test --authorize-spend --ceiling ${g.techoUsd} --expect-policy ${enInglesLaPolitica(g.politica)}`;
-        const message = `${gasto} To launch it: \`${lanzar}\`. \`supcoflow diagnose\` first says whether everything is ready.`;
-        return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "falta_autorizacion", message, ...datos }, texto: message };
+        // Primero lo que impide, si algo: es lo que la persona tiene que saber antes de decir que sí.
+        const impide = revision.maquina.ok ? "" : `This machine can't save the test request yet: ${detalles(revision)} Fix that before authorizing. `;
+        const previo = revision.intentoPendiente;
+        const pendiente = previo === null ? ""
+            : ` There's a test request waiting for confirmation (ceiling ${usd(previo.techoUsd)}, policy ${enInglesLaPolitica(previo.politica)}): to recover that same request, repeat \`${comandoDeReintento({ clave: "", mensaje: null, techoUsd: previo.techoUsd, politicaEsperada: previo.politica })}\`.`;
+        const message = `${impide}${gasto} To launch it: \`${lanzar}\`. \`supcoflow diagnose\` first says whether everything is ready.${pendiente}`;
+        return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "falta_autorizacion", message, ...datos, ...datosDelIntentoPendiente(revision) }, texto: message };
     }
     // ── Con --authorize-spend: el ciclo de la clave.
     let intento;

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

@@ -1,10 +1,12 @@
 import { resultadoDeFallo, SALIDA } from "../contrato.js";
 import { repoPedido } from "../repo-local.js";
 import { claveVigente } from "./clave-vigente.js";
+import { coherenciaDelClon, leerElArchivoDelClon } from "./contexto.js";
 export async function proyectoDelRepo(d, flags) {
     let repo;
+    let raiz;
     try {
-        repo = (await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd })).repo;
+        ({ repo, raiz } = await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd }));
     }
     catch (e) {
         return { ok: false, resultado: resultadoDeFallo(e) };
@@ -12,8 +14,16 @@ export async function proyectoDelRepo(d, flags) {
     const leida = await claveVigente(d.guardado, d.api.origin);
     if (!leida.ok)
         return { ok: false, resultado: leida.resultado };
+    // El archivo del clon se lee ANTES de actuar: un `proyecto.json` que no se entiende frena sin tocar nada, y uno que anota
+    // otro proyecto que el que la clave ve también (ningún pedido parcial actúa sobre un proyecto distinto del que anota el clon).
+    const archivo = leerElArchivoDelClon(d.archivos, raiz);
+    if (archivo.estado === "ilegible")
+        return { ok: false, resultado: coherenciaDelClon(archivo, null, repo) };
     try {
         const proyecto = await d.buscarProyecto(d.api, leida.vigente.clave, repo);
+        const incoherente = coherenciaDelClon(archivo, proyecto, repo);
+        if (incoherente !== null)
+            return { ok: false, resultado: incoherente };
         if (proyecto === null) {
             const message = `The repo ${repo} doesn't have a project yet. Create the project: \`supcoflow project create\`.`;
             return { ok: false, resultado: { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "sin_proyecto", message, repo }, texto: message } };

package/dist/comandos/proyecto.js

@@ -5,11 +5,9 @@ import path from "node:path";
 import { resultadoDeFallo, SALIDA } from "../contrato.js";
 import { repoPedido } from "../repo-local.js";
 import { claveVigente } from "./clave-vigente.js";
+import { armarElContexto, coherenciaAlCrear, coherenciaDelClon, idDelArchivo, leerElArchivoDelClon, lineaDelContexto } from "./contexto.js";
 const PLAZO_DE_LECTURA_MS = 15_000;
 const OPERACION = "proyecto_crear";
-// Lo único que se lee de un `.supcoflow/proyecto.json` ajeno es su id, y sólo si tiene esta forma:
-// así lo que salga a la terminal no puede ser otra cosa que un id (Review Focus 11).
-const FORMA_DEL_ID = /^proj_[a-z0-9-]{1,80}$/;
 // Los 422/409 del alta que el plan no listaba (alta-desde-conexion.ts del motor).
 const RECHAZOS_DE_UNA_PERSONA = new Set(["instalacion_no_verificada", "repo_fuera_de_la_instalacion"]);
 const RECHAZOS_TRANSITORIOS = new Set(["slug_ocupado", "repo_ya_conectado"]);
@@ -23,18 +21,6 @@ const comillas = (s) => `"${s.replace(/["\\]/g, "\\$&")}"`;
 function contenidoDelArchivo(p) {
     return JSON.stringify({ id: p.id, slug: p.slug, repo: p.repo }, null, 2) + "\n";
 }
-function idDelArchivo(crudo) {
-    try {
-        const v = JSON.parse(crudo);
-        if (typeof v !== "object" || v === null)
-            return null;
-        const id = v.id;
-        return typeof id === "string" && FORMA_DEL_ID.test(id) ? id : null;
-    }
-    catch {
-        return null;
-    }
-}
 // Mismo contenido aunque el formato cambie (otra indentación, otro orden): no es «otro proyecto».
 function mismoArchivo(crudo, p) {
     if (crudo === contenidoDelArchivo(p))
@@ -96,12 +82,24 @@ export async function proyectoCrear(d, flags) {
     if (!leida.ok)
         return leida.resultado;
     const clave = leida.vigente.clave;
+    // Antes de conectar o crear nada (fricción 6): el archivo del clon contra lo que la clave ve, y, si va a haber un alta, el
+    // dueño del repo contra la cuenta. Sale 4 `contexto_incoherente` sin tocar nada.
+    const archivo = leerElArchivoDelClon(d.archivos, raiz);
+    if (archivo.estado === "ilegible")
+        return coherenciaDelClon(archivo, null, repo);
     let existente;
     let conexion = null;
     try {
         existente = await d.buscarProyecto(d.api, clave, repo);
-        if (existente === null)
+        const incoherente = coherenciaDelClon(archivo, existente, repo);
+        if (incoherente !== null)
+            return incoherente;
+        if (existente === null) {
+            const alCrear = coherenciaAlCrear({ yo: await d.quienSoy(d.api, clave), fuente: leida.vigente.fuente, repo });
+            if (alCrear !== null)
+                return alCrear;
             conexion = await d.ultimaConexion(d.api, clave, repo, PLAZO_DE_LECTURA_MS);
+        }
     }
     catch (e) {
         return resultadoDeFallo(e);
@@ -184,8 +182,9 @@ export async function proyectoCrear(d, flags) {
 }
 export async function proyectoVer(d, flags) {
     let repo;
+    let raiz;
     try {
-        repo = (await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd })).repo;
+        ({ repo, raiz } = await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd }));
     }
     catch (e) {
         return resultadoDeFallo(e);
@@ -194,17 +193,32 @@ export async function proyectoVer(d, flags) {
     if (!leida.ok)
         return leida.resultado;
     const clave = leida.vigente.clave;
+    const archivo = leerElArchivoDelClon(d.archivos, raiz);
+    if (archivo.estado === "ilegible")
+        return coherenciaDelClon(archivo, null, repo);
     try {
         const encontrado = await d.buscarProyecto(d.api, clave, repo);
+        const incoherente = coherenciaDelClon(archivo, encontrado, repo);
+        if (incoherente !== null)
+            return incoherente;
+        // Quién soy, en qué equipo, qué repo y qué proyecto: la línea que la persona lee al empezar, también cuando todo cierra.
+        const yo = await d.quienSoy(d.api, clave);
+        const contexto = armarElContexto({ yo, fuente: leida.vigente.fuente, repo, proyecto: encontrado, archivo });
+        const linea = lineaDelContexto(contexto, yo.proyecto);
         if (encontrado === null) {
-            return { codigo: SALIDA.ok, json: { ok: true, repo, proyecto: null }, texto: "This repo doesn't have a project yet: `supcoflow project create`." };
+            // Sin proyecto, el recorrido sigue con `repo connect`: el freno por cuenta (dueño distinto, sin GitHub) tiene que llegar ANTES,
+            // no al crear. Con proyecto existente no se compara nada, y con una clave de consulta tampoco.
+            const alCrear = coherenciaAlCrear({ yo, fuente: leida.vigente.fuente, repo });
+            if (alCrear !== null)
+                return alCrear;
+            return { codigo: SALIDA.ok, json: { ok: true, repo, proyecto: null, contexto }, texto: `${linea} This repo doesn't have a project yet: \`supcoflow project create\`.` };
         }
         const { proyecto: p, github } = await d.leerProyecto(d.api, clave, encontrado.id);
         const proyecto = { id: p.id, slug: p.slug, repo: p.repo, rama: p.rama, install_command: p.installCommand, test_command: p.testCommand };
         return {
             codigo: SALIDA.ok,
-            json: { ok: true, proyecto, github: { estado: github.estado, verificado_en: github.verificadoEn } },
-            texto: `${p.id} (${p.repo}, branch ${p.rama}): installs with \`${p.installCommand}\`, tests with \`${p.testCommand}\`. GitHub: ${github.estado ?? "not verified"}.`,
+            json: { ok: true, proyecto, github: { estado: github.estado, verificado_en: github.verificadoEn }, contexto },
+            texto: `${linea} ${p.id} (${p.repo}, branch ${p.rama}): installs with \`${p.installCommand}\`, tests with \`${p.testCommand}\`. GitHub: ${github.estado ?? "not verified"}.`,
         };
     }
     catch (e) {

package/dist/comandos/widget.js

@@ -1,5 +1,30 @@
 import { resultadoDeFallo, SALIDA } from "../contrato.js";
 import { proyectoDelRepo } from "./proyecto-del-repo.js";
+// La forma «interfaz propia» (T8): sin código para pegar. La app arma el chat con sus propios componentes; esto es lo que
+// hay que instalar y el contrato que la interfaz tiene que cumplir. Todo sale del motor, tal cual (también las rutas). Con
+// `sin_publicar` la versión todavía no está en npm: no se ofrece el camino (ni un `npm i` que fallaría); el JSON sí lo dice.
+function textoDeLaInterfazPropia(p) {
+    if (p.estado !== "disponible") {
+        return ["", `Own interface: not published yet (${p.paquete}@${p.version} is not on npm); use the widget above.`];
+    }
+    return [
+        "",
+        "Own interface (build the chat with the app's own components, instead of steps 2 and 3; there is no code to paste):",
+        "   Install the package (the exact version):",
+        `   ${p.instalar}`,
+        `   tenantId: ${p.opciones_del_nucleo.tenantId}`,
+        `   projectId: ${p.opciones_del_nucleo.projectId}`,
+        `   backendUrl: ${p.backend_url}`,
+        "   Content Security Policy (CSP): if the app has `connect-src`, add this origin and keep what it already has:",
+        `   ${p.csp}`,
+        `   Presentation contract: ${p.contrato.version}. Once the package is installed, read it offline (paths relative to the folder where you ran npm i):`,
+        `   ${p.contrato.archivo}`,
+        `   ${p.contrato.documento}`,
+        "   What the interface must do is in the contract; how it looks is the app's.",
+        `   Entry points: ${p.entradas.nucleo} (core), ${p.entradas.react} (React), ${p.entradas.pruebas} and ${p.entradas.servidor_de_pruebas} (test bench).`,
+        `   Docs: ${p.documentos.nucleo}, ${p.documentos.react}, ${p.documentos.pruebas}, ${p.documentos.conformidad}, ${p.documentos.protocolo}.`,
+    ];
+}
 function textoDe(w) {
     const anteriores = w.nextjs.archivos_anteriores;
     return [
@@ -20,6 +45,7 @@ function textoDe(w) {
         "",
         "Alternative with <script> (available, not tested in a real app):",
         `   ${w.script.linea}`,
+        ...(w.interfaz_propia === undefined ? [] : textoDeLaInterfazPropia(w.interfaz_propia)),
     ].join("\n");
 }
 export async function widget(d, flags) {

package/dist/diagnostico.js

@@ -1,4 +1,5 @@
-export const TOTAL_DE_INSTALACION = 6;
+import { compararSemver, RUTA_DE_LA_INSTALACION } from "./instalacion.js";
+import { frasePorQueNoAtaClon } from "./repo-local.js";
 // El orden y los nombres con que se dicen: los ids de los puntos del motor son datos suyos y no cambian.
 const DE_LA_INSTALACION = [
     { punto: "sign-in", como: "sign-in" },
@@ -7,7 +8,9 @@ const DE_LA_INSTALACION = [
     { punto: "sitios", como: "allowed sites" },
     { punto: "chat", como: "chat" },
     { punto: "guia", como: "guide" },
+    { punto: "interfaz", como: "interface" },
 ];
+export const TOTAL_DE_INSTALACION = DE_LA_INSTALACION.length;
 const DEL_MOTOR = new Set(["instalacion", "sitios", "chat", "guia"]);
 export const lineaDeLoRevisado = (n) => `Checked ${DE_LA_INSTALACION.map((x) => x.como).slice(0, -1).join(", ")} and ${DE_LA_INSTALACION.at(-1).como}: ${n} of ${TOTAL_DE_INSTALACION}, at no cost.`;
 export const nombreDelPunto = (punto) => DE_LA_INSTALACION.find((x) => x.punto === punto)?.como ?? punto;
@@ -21,6 +24,8 @@ export function puntoDelRepo(local, repoDelProyecto) {
             return mal("This folder isn't a git repo, so I can't tell which repo it is.");
         if (local.motivo === "sin_origin")
             return mal("This repo has no «origin» remote, so I can't tell which repo it is.");
+        if (local.motivo === "origin_alias_ssh")
+            return mal(`The «origin» of this repo isn't a GitHub repo. ${frasePorQueNoAtaClon(local, null)}`);
         return mal("The «origin» of this repo isn't a GitHub repo.");
     }
     if (local.repo.toLowerCase() !== repoDelProyecto.toLowerCase()) {
@@ -28,6 +33,46 @@ export function puntoDelRepo(local, repoDelProyecto) {
     }
     return { punto: "repo", ok: true, mensaje: `The origin of this folder is ${local.repo}, the project's repo.`, grupo: "instalacion" };
 }
+/**
+ * El punto 7 (T8): la interfaz propia de la app. Puro: recibe lo ya leído. Es un AVISO local: baja el «N of 7» pero no frena una
+ * prueba (la prueba mira que un problema llegue a un issue, no cómo se ve el chat). Sin interfaz propia anotada no aplica y
+ * cuenta como ok. El contenido de `instalacion.json` nunca se copia al mensaje.
+ *  · `lectura`: lo que dice el archivo (o `null` si no se miró: el clon no es el del repo del proyecto).
+ *  · `faltan`: los archivos anotados que ya no están.
+ *  · `delProyecto`: el contrato que declara el proyecto hoy (`interfaz_propia.contrato.version`), o null si no se supo.
+ */
+const mayor = (v) => Number(v.split(".")[0]);
+export function puntoDeLaInterfaz(i) {
+    const punto = (ok, mensaje) => ({ punto: "interfaz", ok, mensaje, grupo: "instalacion", aviso: true });
+    if (i.lectura === null)
+        return punto(true, "Not checked: this folder isn't a clone of the project's repo, so I don't read its installation record.");
+    const l = i.lectura;
+    if (l.estado === "ausente")
+        return punto(true, `Not applicable: there's no ${RUTA_DE_LA_INSTALACION}, so no own interface is recorded.`);
+    if (l.estado === "mas_nueva")
+        return punto(false, `${RUTA_DE_LA_INSTALACION} was written by a newer supcoflow than this one: update supcoflow (\`npm i -g supcoflow@latest\` or \`npx supcoflow@latest\`) to read it.`);
+    if (l.estado === "ilegible")
+        return punto(false, `I can't read ${RUTA_DE_LA_INSTALACION}: run \`supcoflow install record\` again.`);
+    if (l.forma !== "interfaz_propia") {
+        return punto(true, l.forma === "widget" ? "Not applicable: the chat is recorded as the packaged widget, which has no interface contract to check." : "Not applicable: no own interface is recorded.");
+    }
+    if (l.archivos.length === 0)
+        return punto(false, "The installation says the chat is an own interface but records none of its files: run `supcoflow install record --file …` again.");
+    if (i.faltan.length > 0)
+        return punto(false, `These files of the interface are recorded but gone: ${i.faltan.join(", ")}. Run the skill again to update the record.`);
+    if (l.contrato === null) {
+        return punto(false, "The interface doesn't record which presentation contract it follows (the installed @supcoflow/chat has no contract.json): update the package and run `supcoflow install record` again.");
+    }
+    const archivos = `${l.archivos.length} ${l.archivos.length === 1 ? "file" : "files"}`;
+    if (i.delProyecto !== null && compararSemver(i.delProyecto, l.contrato) > 0) {
+        // Un obligatorio nuevo sólo llega con una versión MAYOR del contrato (plan §2.5.8): una menor o de parche suma lo opcional.
+        if (mayor(i.delProyecto) > mayor(l.contrato)) {
+            return punto(false, `The interface (${archivos}) follows contract ${l.contrato}, and the project now declares ${i.delProyecto}, a new major version: run the skill again to see what changed and check that the interface still conforms.`);
+        }
+        return punto(true, `The interface (${archivos}) follows contract ${l.contrato}; the project declares ${i.delProyecto}, which only adds optional points: run the skill again to see them.`);
+    }
+    return punto(true, `The interface (${archivos}) follows contract ${l.contrato}${i.delProyecto === l.contrato ? ", the one the project declares" : ""}.`);
+}
 /** Reparte los puntos del motor en los dos grupos y suma los dos locales al de la instalación. */
 export function agruparPuntos(g, locales) {
     const delMotor = g.puntos.map((p) => ({ ...p, grupo: p.grupo ?? (DEL_MOTOR.has(p.punto) ? "instalacion" : "prueba") }));