supcoflow 0.7.0 → 0.8.1

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

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

package/dist/comandos/repo-conectar.js

@@ -17,22 +17,22 @@ function resultadoDelPedido(repo, p, avisar) {
             return {
                 codigo: SALIDA.ok,
                 json: { ok: true, estado: "conectado", repo, repo_canonico: p.repoCanonico, pedido },
-                texto: `${p.repoCanonico ?? repo} está conectado.`,
+                texto: `${p.repoCanonico ?? repo} is connected.`,
             };
         case "repo_fuera_de_alcance": {
-            const message = `La App está instalada pero no alcanza a ${repo}: sumalo en GitHub y volvé a tocar Confirmar (${p.url}).`;
+            const message = `The App is installed but doesn't have access to ${repo}: add it in GitHub and click Confirm again (${p.url}).`;
             return fallo(SALIDA.haceFaltaUnaPersona, "repo_fuera_de_alcance", message, { repo, url: p.url, pedido });
         }
         case "vencido":
-            return fallo(SALIDA.haceFaltaUnaPersona, "pedido_vencido", "El pedido venció. Pedí otro con `supcoflow repo conectar --start`.", { repo, pedido });
+            return fallo(SALIDA.haceFaltaUnaPersona, "pedido_vencido", "The request has expired. Ask for a new one with `supcoflow repo connect --start`.", { repo, pedido });
         case "pendiente": {
             // Un motivo anotado no cierra el pedido: la persona puede reintentar desde la misma página.
             if (p.fallo !== null)
-                avisar(`La última confirmación falló: ${p.fallo}.`);
+                avisar(`The last confirmation failed: ${p.fallo}.`);
             return {
                 codigo: SALIDA.esperandoAUnaPersona,
                 json: { ok: false, esperando: "persona", repo, url: p.url, pedido, ...(p.fallo !== null ? { fallo: p.fallo } : {}) },
-                texto: `Abrí ${p.url}, instalá la App en GitHub si hace falta y tocá Confirmar.`,
+                texto: `Open ${p.url}, install the App on GitHub if needed, and click Confirm.`,
             };
         }
     }
@@ -49,7 +49,7 @@ export async function repoConectarStart(d, flags) {
         return {
             codigo: SALIDA.ok,
             json: { ok: true, dry_run: true, repo, haria: "POST /api/conexiones" },
-            texto: `Con --dry-run no hago nada; sin él, pediría conectar ${repo} (POST /api/conexiones).`,
+            texto: `With --dry-run I do nothing; without it: ask to connect ${repo} (POST /api/conexiones).`,
         };
     }
     const leida = await claveVigente(d.guardado, d.api.origin);
@@ -92,7 +92,7 @@ export async function repoConectarWait(d, flags) {
             return resultadoDeFallo(e);
         }
         if (p === null) {
-            return fallo(SALIDA.entradaInvalida, "sin_conexion_en_curso", `No hay una conexión en curso para ${repo}: empezá con \`supcoflow repo conectar --start\`.`, { repo });
+            return fallo(SALIDA.entradaInvalida, "sin_conexion_en_curso", `There is no connection in progress for ${repo}: start with \`supcoflow repo connect --start\`.`, { repo });
         }
         ultimo = p;
         if (p.estado !== "pendiente")
@@ -110,12 +110,12 @@ export async function repoConectarWait(d, flags) {
 // que nadie va a mirar.
 export async function repoConectarInteractivo(d, flags) {
     if (!d.esTty || flags.json) {
-        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Sin terminal interactiva usá `supcoflow repo conectar --start --json` y después `supcoflow repo conectar --wait --json`.");
+        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Without an interactive terminal, use `supcoflow repo connect --start --json` and then `supcoflow repo connect --wait --json`.");
     }
     const inicio = await repoConectarStart(d, flags);
     if (inicio.codigo !== SALIDA.esperandoAUnaPersona)
         return inicio;
-    d.mostrar(`${inicio.texto} Espero acá…`);
+    d.mostrar(`${inicio.texto} I'll wait here...`);
     let r;
     do {
         r = await repoConectarWait(d, flags);

package/dist/comandos/widget.js

@@ -1,20 +1,24 @@
 import { resultadoDeFallo, SALIDA } from "../contrato.js";
 import { proyectoDelRepo } from "./proyecto-del-repo.js";
 function textoDe(w) {
+    const anteriores = w.nextjs.archivos_anteriores;
     return [
-        "1. Instalá el paquete (con el gestor de la app, la versión exacta):",
+        "1. Install the package (with the app's package manager, the exact version):",
         `   ${w.instalar}`,
         "",
-        `2. Creá el archivo ${w.nextjs.archivo_sugerido} con este contenido (Next.js, ${w.nextjs.estado}):`,
+        `2. Create the file ${w.nextjs.archivo_sugerido} with this content (Next.js, ${w.nextjs.estado}):`,
         w.nextjs.contenido.trimEnd(),
+        ...(anteriores.length > 0
+            ? [`   If the chat is already installed in ${anteriores.join(" or ")}, update that file in place instead of creating a second one.`]
+            : []),
         "",
-        "3. Usalo en el layout que cubre las pantallas donde se traban los usuarios:",
+        "3. Use it in the layout that covers the screens where users get stuck:",
         `   ${w.nextjs.uso}`,
         "",
-        "4. Política de contenido (CSP): si la app tiene `connect-src`, agregale este origen conservando lo que ya tiene:",
+        "4. Content Security Policy (CSP): if the app has `connect-src`, add this origin and keep what it already has:",
         `   ${w.csp}`,
         "",
-        "Alternativa con <script> (disponible, no probada en una app real):",
+        "Alternative with <script> (available, not tested in a real app):",
         `   ${w.script.linea}`,
     ].join("\n");
 }

package/dist/diagnostico.js

@@ -0,0 +1,51 @@
+import { frasePorQueNoAtaClon } from "./repo-local.js";
+export const TOTAL_DE_INSTALACION = 6;
+// 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" },
+    { punto: "repo", como: "repo" },
+    { punto: "instalacion", como: "GitHub App" },
+    { punto: "sitios", como: "allowed sites" },
+    { punto: "chat", como: "chat" },
+    { punto: "guia", como: "guide" },
+];
+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;
+export function puntoDeSesion() {
+    return { punto: "sign-in", ok: true, mensaje: "This request was authenticated: you're signed in.", grupo: "instalacion" };
+}
+export function puntoDelRepo(local, repoDelProyecto) {
+    const mal = (mensaje) => ({ punto: "repo", ok: false, mensaje, grupo: "instalacion" });
+    if (local.repo === null) {
+        if (local.motivo === "sin_git")
+            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()) {
+        return mal(`The origin of this folder is ${local.repo}, not the project's repo ${repoDelProyecto}.`);
+    }
+    return { punto: "repo", ok: true, mensaje: `The origin of this folder is ${local.repo}, the project's repo.`, grupo: "instalacion" };
+}
+/** 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") }));
+    const instalacion = [...locales, ...delMotor.filter((p) => p.grupo === "instalacion")];
+    // Un punto del grupo que el motor no mandó no se da por bueno: se dice que falta y cuenta como no ok.
+    for (const { punto } of DE_LA_INSTALACION) {
+        if (!instalacion.some((p) => p.punto === punto)) {
+            instalacion.push({ punto, ok: false, mensaje: "The engine didn't report this point.", grupo: "instalacion" });
+        }
+    }
+    const orden = (p) => {
+        const i = DE_LA_INSTALACION.findIndex((x) => x.punto === p.punto);
+        return i === -1 ? DE_LA_INSTALACION.length : i;
+    };
+    return { instalacion: instalacion.sort((a, b) => orden(a) - orden(b)), prueba: delMotor.filter((p) => p.grupo === "prueba") };
+}
+/** Cuántos de los seis puntos de la instalación están bien (los extras que un motor nuevo sume no cambian el seis). */
+export const contarBuenos = (instalacion) => DE_LA_INSTALACION.filter(({ punto }) => instalacion.some((p) => p.punto === punto && p.ok)).length;

package/dist/entorno.js

@@ -2,15 +2,18 @@
 // demás recibe estas piezas inyectadas y se prueba con dobles; acá sólo se enchufan.
 import { execFile, spawn } from "node:child_process";
 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 { accessSync, chmodSync, closeSync, constants, fchmodSync, fstatSync, linkSync, lstatSync, mkdirSync, statSync, openSync, readFileSync, readSync, realpathSync, renameSync, rmSync, writeSync, } from "node:fs";
+import { NO_LEIDO } from "./lectura.js";
 import { homedir, hostname } from "node:os";
 import { basename, dirname, join } from "node:path";
-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 { buscarProyecto, canjear, configurar, leerDiagnostico, leerPrueba, leerWidget, pedirPrueba, crearConexion, crearProyecto, elegirOrigen, esClaveDeConsultaDelProyecto, leerCatalogo, leerConfiguracion, leerGuia, leerProyecto, listarClaves, pedirCodigo, quienSoy, revocarPropia, subirLogo, ultimaConexion, urlDeLaApi, publicarGuia, revisarGuia, leerVersionesDeLaGuia, } from "./api.js";
 import { crearCandados } from "./candado.js";
-import { esCarpetaReal, rutaRealOEnNada } from "./comandos/instalacion.js";
+import { esCarpetaReal, esEnlaceReal, rutaRealOEnNada } from "./comandos/instalacion.js";
 import { DESCRIPCION } from "./comandos/describir.js";
 import { almacenDeArchivo } from "./guardado/archivo.js";
 import { crearGuardado } from "./guardado/index.js";
+import { almacenProtegido } from "./guardado/protegido.js";
+import { revisarElLugar } from "./guardado/lugar.js";
 import { almacenDeLlavero } from "./guardado/llavero.js";
 import { crearGuardaDeSecretos } from "./secreto-a-archivo.js";
 import { crearRegistroDeIdempotencia } from "./idempotencia.js";
@@ -51,7 +54,7 @@ export const fsReal = {
             return realpathSync(p);
         }
         catch {
-            throw new Error(`No puedo resolver la ruta real de ${p} (¿un enlace roto?); no guardo nada ahí.`);
+            throw new Error(`I can't resolve the real path of ${p} (a broken symlink?); I'm not saving anything there.`);
         }
     },
     // `lstat` y no `existsSync`: éste sigue el enlace y ante uno roto dice «no existe», y el control
@@ -67,6 +70,29 @@ export const fsReal = {
         }
     },
 };
+// Lo que el prechequeo de la máquina (src/guardado/lugar.ts) ve del disco, sin escribir. `estado` sigue los enlaces (`stat`): un
+// enlace roto es «no existe» para él, y `existe` (que es `lstat`) lo distingue.
+export const fsDelLugarReal = {
+    ...fsReal,
+    estado(p) {
+        try {
+            const st = statSync(p);
+            return { existe: true, tipo: st.isDirectory() ? "carpeta" : st.isFile() ? "archivo" : "otro", propio: typeof process.getuid !== "function" || st.uid === process.getuid() };
+        }
+        catch {
+            return { existe: false };
+        }
+    },
+    puede(p, que) {
+        try {
+            accessSync(p, que === "leer" ? constants.R_OK : constants.W_OK | constants.X_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+};
 // El candado de `claves crear` (src/candado.ts). `wx` es la exclusión: SÓLO `EEXIST` es «ya hay uno»;
 // cualquier otro error (permisos, disco) se relanza y sale `no_disponible`, nunca «ocupado». La lectura no
 // sigue enlaces: un `.lock` que alguien cambió por un enlace no se lee como si fuera el nuestro.
@@ -252,7 +278,7 @@ export const TOPE_DEL_ARCHIVO_DEL_REPO = 64 * 1024;
 // Lo que devuelve `leer` cuando hay ALGO ahí que no se lee (un enlace, una carpeta, algo enorme, sin
 // permiso). No es JSON a propósito: `proyecto crear` lo trata como un archivo distinto (sale 4, «no lo
 // toqué») sin que nada de lo que hay ahí llegue a la salida.
-export const ARCHIVO_QUE_NO_SE_LEE = "\u0000(no se lee)";
+export const ARCHIVO_QUE_NO_SE_LEE = "\u0000(unreadable)";
 // Un archivo que la persona nombra (el logo) con las mismas defensas que los del repo: sin seguir
 // enlaces, sin FIFOs que cuelguen, sólo archivos comunes y con tope (se lee tope + 1 por si crece).
 export function leerArchivoChico(p, tope) {
@@ -262,11 +288,11 @@ export function leerArchivoChico(p, tope) {
     }
     catch (e) {
         const code = e.code;
-        return { error: code === "ENOENT" ? "no existe" : code === "ELOOP" ? "es un enlace" : "no se pudo abrir" };
+        return { error: code === "ENOENT" ? NO_LEIDO.noExiste : code === "ELOOP" ? NO_LEIDO.esUnEnlace : NO_LEIDO.noSePudoAbrir };
     }
     try {
         if (!fstatSync(fd).isFile())
-            return { error: "no es un archivo común" };
+            return { error: NO_LEIDO.noEsComun };
         const buf = Buffer.alloc(tope + 1);
         let n = 0;
         for (;;) {
@@ -275,12 +301,12 @@ export function leerArchivoChico(p, tope) {
                 break;
             n += leidos;
             if (n > tope)
-                return { error: "es demasiado grande" };
+                return { error: NO_LEIDO.demasiadoGrande };
         }
         return { bytes: new Uint8Array(buf.subarray(0, n)) };
     }
     catch {
-        return { error: "no se pudo leer" };
+        return { error: NO_LEIDO.noSePudoLeer };
     }
     finally {
         closeSync(fd);
@@ -299,7 +325,7 @@ export function archivosDelRepo(avisar) {
         }
     };
     const noSeLee = (p, porque) => {
-        avisar(`No leo ${p}: ${porque}.`);
+        avisar(`I can't read ${p}: ${porque}.`);
         return ARCHIVO_QUE_NO_SE_LEE;
     };
     return {
@@ -308,7 +334,7 @@ export function archivosDelRepo(avisar) {
             if (carpeta === "ausente")
                 return null;
             if (carpeta === "ajena")
-                return noSeLee(p, `${basename(dirname(p))} no es una carpeta común (¿un enlace?)`);
+                return noSeLee(p, `${basename(dirname(p))} isn't a regular folder (a symlink?)`);
             let fd;
             try {
                 // O_NOFOLLOW: un enlace en el último tramo falla (ELOOP) en vez de abrir su destino.
@@ -319,14 +345,14 @@ export function archivosDelRepo(avisar) {
                 const code = e.code;
                 if (code === "ENOENT")
                     return null;
-                return noSeLee(p, code === "ELOOP" ? "es un enlace" : "no se pudo abrir");
+                return noSeLee(p, code === "ELOOP" ? NO_LEIDO.esUnEnlace : NO_LEIDO.noSePudoAbrir);
             }
             try {
                 const st = fstatSync(fd);
                 if (!st.isFile())
-                    return noSeLee(p, "no es un archivo común");
+                    return noSeLee(p, NO_LEIDO.noEsComun);
                 if (st.size > TOPE_DEL_ARCHIVO_DEL_REPO)
-                    return noSeLee(p, "es demasiado grande");
+                    return noSeLee(p, NO_LEIDO.demasiadoGrande);
                 // Se lee hasta el tope + 1 y no `st.size`: el archivo puede crecer entre el fstat y la lectura.
                 const buf = Buffer.alloc(TOPE_DEL_ARCHIVO_DEL_REPO + 1);
                 let n = 0;
@@ -336,12 +362,12 @@ export function archivosDelRepo(avisar) {
                         break;
                     n += leidos;
                     if (n > TOPE_DEL_ARCHIVO_DEL_REPO)
-                        return noSeLee(p, "es demasiado grande");
+                        return noSeLee(p, NO_LEIDO.demasiadoGrande);
                 }
                 return buf.subarray(0, n).toString("utf8");
             }
             catch {
-                return noSeLee(p, "no se pudo leer");
+                return noSeLee(p, NO_LEIDO.noSePudoLeer);
             }
             finally {
                 closeSync(fd);
@@ -355,7 +381,7 @@ export function archivosDelRepo(avisar) {
             const dir = dirname(p);
             mkdirSync(dir, { recursive: true });
             if (carpetaPropia(dir) !== "propia")
-                throw new Error(`${dir} no es una carpeta común`);
+                throw new Error(`${dir} isn't a regular folder`);
             const tmp = join(dir, `.${basename(p)}.${randomUUID()}.tmp`);
             try {
                 const fd = openSync(tmp, "wx", 0o644);
@@ -395,27 +421,31 @@ export function entornoReal(env = process.env) {
     // Al lado de las credenciales y con el mismo almacén (carpeta 0700, archivo 0600, `.tmp` en
     // exclusiva): nunca dentro del repo donde se corre el comando, que la publicaría con un `git add -A`.
     const rutaDeIdempotencia = join(dirname(rutaDelArchivo), "idempotencia.json");
+    // Estos dos registros (y sólo estos) pueden vivir bajo una carpeta personal que es un repo de git: el almacén
+    // protegido comprueba con git, antes de cada escritura y cada borrado, que los deja afuera del repo.
+    const protegido = (ruta) => almacenProtegido(almacenDeArchivo(ruta, fsReal), { ruta, fs: fsReal, git: gitReal });
     const idempotencia = crearRegistroDeIdempotencia({
         origen: api.origin,
-        almacen: almacenDeArchivo(rutaDeIdempotencia, fsReal),
+        almacen: protegido(rutaDeIdempotencia),
         rutaDelArchivo: rutaDeIdempotencia,
-        fs: fsReal,
         generar: randomUUID,
         ahora: Date.now,
         avisar,
     });
-    // El pedido de `probar` (intento + última prueba), con el mismo almacén y la misma regla: fuera de un repo.
+    // El pedido de `probar` (intento + última prueba), con el mismo almacén protegido.
     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,
+        origen: api.origin, almacen: protegido(rutaDePruebas), rutaDelArchivo: rutaDePruebas, ahora: Date.now, avisar,
+        revisarElLugar: () => revisarElLugar({ ruta: rutaDePruebas, fs: fsDelLugarReal, git: gitReal }),
     });
     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.
     const candados = crearCandados(fsDelCandadoReal, join(dirname(rutaDelArchivo), "candados"), process.pid, procesoVivo);
     const secretos = crearGuardaDeSecretos(fsDeSecretosReal);
+    // `archivos`: `proyectoDelRepo` lee `.supcoflow/proyecto.json` del clon con él (fricción 6).
     const configurarEnElMotor = {
-        api, guardado, git: gitReal, cwd, avisar,
+        api, guardado, git: gitReal, cwd, avisar, archivos: archivosDelRepo(avisar),
         buscarProyecto: (a, clave, repo) => buscarProyecto(a, clave, repo, fetch),
         leerConfiguracion: (a, clave, id) => leerConfiguracion(a, clave, id, fetch),
         configurar: (a, clave, ruta, cuerpo, extra) => configurar(a, clave, ruta, cuerpo, fetch, extra),
@@ -453,6 +483,7 @@ export function entornoReal(env = process.env) {
         proyecto: {
             api, guardado, git: gitReal, cwd, idempotencia, archivos: archivosDelRepo(avisar), avisar,
             buscarProyecto: (a, clave, repo) => buscarProyecto(a, clave, repo, fetch),
+            quienSoy: (a, clave) => quienSoy(a, clave, fetch),
             ultimaConexion: (a, clave, repo, plazoMs) => ultimaConexion(a, clave, repo, fetch, plazoMs),
             crearProyecto: (a, clave, conexionId, cuerpo, key) => crearProyecto(a, clave, conexionId, cuerpo, key, fetch),
             leerProyecto: (a, clave, id) => leerProyecto(a, clave, id, fetch),
@@ -466,7 +497,7 @@ export function entornoReal(env = process.env) {
         guia: {
             ...configurarEnElMotor,
             leerArchivoChico, fetch, gitDeclarado: gitRapido,
-            revisar: revisarGuia, publicar: publicarGuia, ver: leerGuia, elegir: elegirOrigen,
+            revisar: revisarGuia, publicar: publicarGuia, ver: leerGuia, elegir: elegirOrigen, versiones: leerVersionesDeLaGuia,
         },
         claves: {
             ...configurarEnElMotor,
@@ -475,7 +506,7 @@ export function entornoReal(env = process.env) {
             idempotencia, candados, secretos,
         },
         widget: {
-            api, guardado, git: gitReal, cwd,
+            api, guardado, git: gitReal, cwd, archivos: archivosDelRepo(avisar),
             buscarProyecto: configurarEnElMotor.buscarProyecto,
             leerWidget: (a, clave, id) => leerWidget(a, clave, id, fetch),
         },
@@ -483,12 +514,12 @@ export function entornoReal(env = process.env) {
         // para lo que la terminal dice de sí misma.
         instalacion: {
             ...configurarEnElMotor,
-            leerArchivoChico, rutaReal: rutaRealOEnNada, esCarpeta: esCarpetaReal,
+            leerArchivoChico, rutaReal: rutaRealOEnNada, esCarpeta: esCarpetaReal, esEnlace: esEnlaceReal,
             escribir: archivosDelRepo(avisar).escribir,
             terminal: DESCRIPCION.version,
         },
         prueba: {
-            api, guardado, git: gitReal, cwd, avisar, pruebas, generar: randomUUID, ahora: Date.now, dormir, tramoMs,
+            api, guardado, git: gitReal, cwd, avisar, archivos: archivosDelRepo(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),