supcoflow 0.8.0 → 0.9.0

package/README.md

@@ -29,21 +29,56 @@ the English ones.
 | `supcoflow whoami` | Which key the terminal runs with, on whose behalf and in which team. |
 | `supcoflow repo connect` | Connects this folder's repo with the GitHub App: it gives you a link and you confirm it in the console. Without a terminal, `--start` and then `--wait`, like `login`. |
 | `supcoflow project create` | Creates (or reuses) the project of the connected repo and records it in `.supcoflow/proyecto.json`. If the engine can't work out the commands, `--install "…" --test "…"`. |
-| `supcoflow project show` | The repo's project: branch, commands and the state of the GitHub App. |
+| `supcoflow project show` | The repo's project: branch, commands and the state of the GitHub App, starting with who you are: «You're @login in team T; repo O/R; project P (existing)». |
 | `supcoflow guide check` | Checks `.supcoflow/guide.md` against the engine without publishing anything. |
 | `supcoflow guide publish` | Uploads `.supcoflow/guide.md` directly (with the commit and branch your clone declares, not verified in GitHub). `--from-github` verifies against the main branch instead of uploading the file. |
 | `supcoflow guide show` | Shows the active guide, where it comes from, which file it was read from and whether the branch is still up to date. |
 | `supcoflow guide use --source repo\|agent` | Chooses which guide is active. |
 | `supcoflow guide versions` | The guide that governs now and the repo's publications, newest first; at most one says «live». |
 | `supcoflow widget` | What to paste into the app to get the chat (see «Put the chat in the app»). |
-| `supcoflow install record --skill 0.3.0 --file app/_supcoflow/support-chat.tsx` | Records in `.supcoflow/instalacion.json` which versions the chat was installed with and which file it lives in. |
-| `supcoflow diagnose` | Free: how far the installation is (N of 6) and whether a test would go in. |
+| `supcoflow install record --skill 0.3.1 --file app/_supcoflow/support-chat.tsx` | Records in `.supcoflow/instalacion.json` which versions the chat was installed with, what was installed (the widget or the app's own interface), which files it lives in and which presentation contract it follows. |
+| `supcoflow diagnose` | Free: how far the installation is (N of 7) and whether a test would go in (including whether this machine can save the test request). |
 | `supcoflow test` | The end-to-end test (see «Test the installation»). |
 | `supcoflow describe --json` | The whole contract (commands, flags, key capabilities, codes) in one line of JSON. |
 
 `supcoflow --help` (or `supcoflow <command> --help`) shows the help with examples. The repo and project commands
 take the repo from the folder's `origin`; `--repo owner/repo` picks it by hand.
 
+### When the `origin` isn't a GitHub address
+
+The terminal only recognizes `origin` when its host is exactly `github.com` (`https://github.com/o/r`,
+`git@github.com:o/r.git`, `ssh://git@github.com/o/r`). If yours is an SSH alias (`git@github-work:o/r.git`) or
+another server, it never runs `ssh` or reads your SSH configuration (it could run programs of yours). You tell it
+once, in your own clone, which GitHub repo this is:
+
+```bash
+git remote add supcoflow https://github.com/owner/repo.git   # it's never fetched
+```
+
+A remote called `supcoflow` with those same strict forms ties the clone to that repo for every command. If `origin`
+is a GitHub address, `origin` wins. The error says the exact command to run. With `--repo owner/repo`, the commands
+that read or write a file of the clone (`guide check`, `guide publish`, `install record`) only use this clone if it is
+that repo; otherwise they exit 3 saying what the clone is, without asking the engine. (`project create --repo` keeps
+creating or reusing the project; when this clone is not that repo it does so without reading or writing this clone's
+`.supcoflow/proyecto.json`, and when it is that repo it reads and records the file as usual.)
+
+### Is this repo the one for this account?
+
+Every command that acts on the repo's project first checks what it can see, and exits 4 `contexto_incoherente` (with a
+`motivo`) without touching anything when it doesn't add up:
+
+- `proyecto_del_clon_distinto`: `.supcoflow/proyecto.json` notes a project your key doesn't see for this repo. Check
+  which account you signed in with (`supcoflow whoami`), or review that old file.
+- `archivo_del_clon_ilegible`: that file exists but can't be read or understood (its content is never printed).
+- `dueno_distinto_del_login` (only when this repo has no project yet, in `project show` and `project create`; `show` stops the walk-through before `repo connect`): the repo's owner on GitHub isn't the GitHub login of your
+  key. It is a *possible* mismatch (the engine compares GitHub's number, and a login can be renamed): sign in to the
+  console with GitHub again, or as the owner. If your key comes from `SUPCOFLOW_TOKEN`, that variable wins over a new
+  login, and the terminal doesn't touch it.
+- `sin_github` (only when this repo has no project yet, in `project show` and `project create`): the account was signed in by email; connecting a repo needs GitHub.
+
+A project that already exists is never blocked for belonging to another person of the team. This doesn't see a project
+of the same repo in another team when the clone doesn't note it.
+
 ### From zero to a project
 
 1. `supcoflow login`: you approve the code in the console.
@@ -112,9 +147,9 @@ badly formed, that is an error: it never falls back to the old one.
 `supcoflow guide show` shows the active guide, the file it was read from and whether the branch is still up to date
 (`al_dia` in the JSON); `supcoflow guide versions` lists the guide that governs now and the repo's publications;
 `supcoflow guide use --source repo|agent` chooses which one is active when there is one from the repo and one from
-our agent. All of them take the repo from the `origin`, or `--repo owner/repo` (with `check` and `publish`, without a
-local clone of that repo it exits 3 `falta_guia`: the guide is read from the file); `check`, `publish` and `use`
-accept `--dry-run`; `--from-github` is only for `publish`.
+our agent. All of them take the repo from the `origin` (or a `supcoflow` remote, see above), or `--repo owner/repo`
+(with `check` and `publish`, if this clone isn't that repo it exits 3 `falta_guia` saying what the clone is: the guide
+is read from the file); `check`, `publish` and `use` accept `--dry-run`; `--from-github` is only for `publish`.
 
 The format of `.supcoflow/guide.md`:
 
@@ -156,13 +191,61 @@ wrongly copied id leaves the chat invisible without any error). It writes no fil
 The `<script>` line it also shows is available but not tested in a real app, and is not for Next.js.
 `supcoflow widget --json` returns the engine's object as is.
 
-Then, `supcoflow install record --skill <version> [--app <folder>] [--file <path>]` leaves in
+### Your own interface (the app builds the chat)
+
+Supcoflow doesn't have to be the one that draws the chat. When the engine also describes the app's **own interface**
+(`interfaz_propia` in `widget --json`; `Own interface` in the text), the code assistant builds the chat with the
+app's own components, icons and styles, and Supcoflow only says what to install and which contract the interface
+must fulfil. **There is no code to paste** in this form:
+
+| Field (`interfaz_propia`) | What it is |
+|---|---|
+| `estado` | `disponible`, or `sin_publicar` when the package version isn't on npm yet. With `sin_publicar` the text doesn't offer the path (it would be an `npm i` that fails): it says «not published yet; use the widget». The JSON still carries everything. |
+| `paquete`, `version`, `instalar` | The package and its exact version, and the install command. |
+| `tenant_id`, `project_id`, `backend_url`, `opciones_del_nucleo` | The ids and the backend, as the engine has them: don't copy them by hand. |
+| `csp` | The Content Security Policy line to add to `connect-src`. |
+| `contrato` (`version`, `archivo`, `documento`) | The presentation contract the interface has to follow: its version, and where the installed package carries it (`contract.json` and `docs/presentation-contract.md`, paths relative to the folder where `npm i` was run), so it can be read offline. |
+| `entradas`, `documentos` | The package entry points (`@supcoflow/chat/core`, `/react`, `/testing`, `/testing/server`) and the docs inside the package. Names and paths, not code. |
+
+The field is additive: an engine that doesn't send it (production, until the engine's T8 ships) gives exactly the
+object it always gave, and the terminal adds nothing. If the engine sends `interfaz_propia` halfway (a field missing,
+an `estado` it doesn't know, a `contrato.version` that isn't a semver, a path outside the package), the terminal ignores
+that whole part, says so on stderr and shows the widget as always: it never shows half of it, and an optional block never
+takes the widget down. Anything else inside `interfaz_propia` that the terminal doesn't know is not passed on.
+
+Then, `supcoflow install record --skill <version> [--app <folder>] [--shape widget|own-interface] [--file <path>]…` leaves in
 `.supcoflow/instalacion.json` (to commit) which versions it ended up with: the skill, the terminal, the chat declared
-and installed, the project configuration and, with `--file`, the file the chat lives in (a path relative to the repo
-root, with no `..`, and not a symlink). The file is version 2; a version 1 file (from 0.7.0) is read without error as
-«no file recorded». Running it again without `--file` keeps the file already recorded. It never contains a secret or
-a date; repeating it without changes doesn't touch it, and if the file has uncommitted changes it exits 4 and doesn't
-overwrite it.
+and installed, the project configuration and, from version 3 (0.9.0), what the installation is:
+
+- `forma`: `"widget"` or `"interfaz_propia"` (`--shape widget` / `--shape own-interface`), or `null` if not said.
+- `archivos`: the files the chat lives in, relative to the repo root (no `..`, not absolute, not a symlink, up to 20).
+  `--file` can be repeated, in order, and replaces the whole list; the wrapper of the widget is one file, an own
+  interface usually several.
+- `contrato`: the version of the presentation contract the **installed** package carries (its `contract.json`, found the
+  same way as its `package.json`: the closest `node_modules` going up to the repo root, never outside the repo), or `null`
+  if the package has none. A `contract.json` that is there but has no version is an error (`paquete_ilegible`).
+
+Running it again without `--shape` or `--file` keeps the form and the files already recorded; changing `--shape` without
+`--file` leaves `archivos` empty (the wrapper of the widget isn't the own interface, and the other way round). Versions 1 and
+2 are read without error and as a widget, the only form there was: a version 2 `archivo` is read as `archivos: [archivo]`
+(and rewritten as version 3). A file of version 4 or more (written by a newer supcoflow) is never rewritten: `install record`
+exits 4 `escrito_por_una_terminal_mas_nueva` and `diagnose` says to update supcoflow. The JSON of the command keeps `archivo` (the first file) for the skills before 0.9.0 and adds
+`archivos`, `forma` and `contrato`. It never contains a secret or a date; repeating it without changes doesn't touch it,
+and if the file has uncommitted changes it exits 4 and doesn't overwrite it.
+
+**Point 7 of `diagnose` (`interfaz`).** It is local and only reads. If `.supcoflow/instalacion.json` records an own
+interface, it checks that every recorded file is still there, that a contract is recorded and that it isn't older than the
+one the project declares today (`interfaz_propia.contrato.version`, asked from the engine; if that can't be asked, or the
+engine doesn't send it, nothing is compared). Only a new **major** version fails the point (a new requirement comes only with
+a major one): then it says to run the skill again and check that the interface still conforms. A newer minor or patch only
+adds optional points: the point stays ok and says so. To see that a recorded file is still there it doesn't read it. With no
+own interface recorded (no file, the widget, or nothing said) the point is ok («Not applicable»). It is advice: when it
+fails it lowers the «N of 7», it is marked `aviso: true` in the JSON, and it doesn't stop a test.
+
+**Before publishing 0.9.0.** `diagnose` now says «N of 7», and the skill of today (`SKILL.md`, `referencias/prueba.md`)
+asks literally for «6 of 6», but it pins the terminal to 0.8.1 (never `@latest`), so it won't see 0.9.0 until a skill pins it.
+The skill that pins 0.9.0 has to read `instalacion.ok` / `listo` (or `aviso`) instead of a fixed number, and 0.9.0 has to be on
+npm before or together with it.
 
 ## Test the installation
 
@@ -171,8 +254,8 @@ the repo from the `origin`, or `--repo owner/repo`.
 
 | Command | What it does |
 |---|---|
-| `supcoflow diagnose` | Free and writes nothing. It prints «Checked sign-in, repo, GitHub App, allowed sites, chat and guide: N of 6, at no cost.» and, apart, «Ready for a test: yes / no, because …» with the policy, the month's balance and open tests. Exits 0 if everything is ready, 4 if something needs fixing (with each point). `--json` gives `instalacion: { ok, total: 6, puntos }` and `prueba: { listo, puntos }`. |
-| `supcoflow test` | Without `--authorize-spend` it sends nothing: it exits 4 with the test's ceiling, the balance, the cap and what is committed this month, and the exact command to launch it. |
+| `supcoflow diagnose` | Free and writes nothing. It prints «Checked sign-in, repo, GitHub App, allowed sites, chat, guide and interface: N of 7, at no cost.» and, apart, «Ready for a test: yes / no, because …» with the policy, the month's balance and open tests. Exits 0 if everything is ready, 4 if something needs fixing (with each point). `--json` gives `instalacion: { ok, total: 7, puntos }` and `prueba: { listo, puntos }`. The seventh point, `interfaz`, is explained in «Put the chat in the app». |
+| `supcoflow test` | Without `--authorize-spend` it sends nothing: it exits 4 with the test's ceiling, the balance, the cap and what is committed this month, and the exact command to launch it. It also says, before you authorize anything, whether this machine can save the test request (`maquina: { ok, impedimentos }`) and any request still waiting for confirmation (`intento_pendiente: { techo_usd, politica }`). |
 | `supcoflow test --authorize-spend --ceiling 2 --expect-policy investigate` | Requests the test: the problem comes in through the same door as the chat and runs an investigation that **spends** up to the ceiling you authorize (with the `save` policy it goes as far as the saved case and doesn't spend). Exits 5 with the id. `--message "…"` uses your own text. |
 | `supcoflow test --wait` | Follows the last test up to 90 s: 5 while it runs (call it again), 0 with the issue, 4 if it needs a look in the console (it brings the link). The charge is shown as it is: `pendiente` right at the close, never 0. `--test-id prb_…` follows another one. |
 | `supcoflow test --dry-run --authorize-spend --ceiling 2 --expect-policy investigate` | What it would do (project, ceiling, balance, policy), without requesting anything. |
@@ -190,6 +273,17 @@ requesting another. While a request is unconfirmed, another `--message`, `--ceil
 open test per project: another one exits 4 `prueba_en_curso` with the id of the open one. A test's issue stays open and
 is marked as a test.
 
+**If your home folder is a git repo.** The request is saved in `~/.config/supcoflow/pruebas.json` (it carries the
+ceiling, the policy and, if you passed one, your `--message`). That is allowed inside a repo only when git itself says
+it ignores the file and doesn't track it: the first time, the terminal creates a `.gitignore` containing `*` in that
+folder (only if there isn't one; it never edits yours), and then asks git (`git check-ignore`) about the file and its
+`.tmp`, for every repo that contains the written or the real path. A file that is already tracked or added to the index
+is refused with the exact `git rm --cached …` to run (the terminal never runs it or deletes anything of yours), and so
+is a missing or failing git. The same goes for every write or delete of `idempotencia.json`. `diagnose` and `test`
+check all this (and permissions, broken links and unreadable files) **before** you authorize, without writing
+anything: «no obstacle found» is a check, not a promise that the disk won't fill up later. The credentials don't use
+this exception: inside a repo they are still refused.
+
 ## With an assistant
 
 If you use a code assistant such as Claude Code, the Supcoflow skill does the whole path for you: session, project,
@@ -231,11 +325,13 @@ Made to be read by a program, not only by a person:
 - If there is no keychain, in `~/.config/supcoflow/credenciales.json` (or `$XDG_CONFIG_HOME/supcoflow/…`) with `0600`
   permissions, and the terminal warns you.
 - **Never inside a git repo**: if that file would land inside one (a `HOME` that is a dotfiles repo, for example), it
-  saves nothing and asks you to use the keychain or `SUPCOFLOW_TOKEN`.
+  saves nothing and asks you to use the keychain or `SUPCOFLOW_TOKEN`. (The test request and the idempotency key are
+  the only things with an exception: see «Test the installation».)
 - **`SUPCOFLOW_TOKEN`** takes priority over what is saved: it is for CI and the cloud.
 - The key never appears in a log or in a `--json` output.
 - `project create` keeps its idempotency key (it isn't a secret: it only avoids creating twice if the answer is lost)
-  in `idempotencia.json`, next to the credentials and with the same permissions.
+  in `idempotencia.json`, next to the credentials and with the same permissions. Inside a repo it is saved only if git
+  ignores it and doesn't track it; otherwise the terminal says so and goes on without saving it.
 
 When you sign in again, the previous key is revoked only after the new one is saved; if it couldn't be revoked, it is
 noted down and retried on the next `login` or `logout`.

package/dist/api.js

@@ -1,5 +1,6 @@
 // Los pedidos de la terminal al motor. Sin dependencias: `fetch` viene de Node y se inyecta.
 import { FalloDeLaTerminal, SALIDA, taparSecretos } from "./contrato.js";
+import { esSemver } from "./instalacion.js";
 // La URL viene FIJA (§5.2): si un archivo del repo pudiera cambiarla, clonar un repo ajeno y correr
 // `supcoflow` mandaría el token a un servidor ajeno. Sólo el entorno del proceso la mueve, y `http`
 // únicamente contra la propia máquina: contra un host remoto la clave viajaría en claro.
@@ -23,7 +24,7 @@ export function urlDeLaApi(env) {
 }
 // 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.8.0";
+const VERSION = "0.9.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
@@ -318,7 +319,7 @@ export function elegirOrigen(api, clave, proyectoId, 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) {
+function aWidget(v, status, avisar) {
     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);
@@ -332,11 +333,58 @@ function aWidget(v, status) {
         || (n.estado !== "probando" && n.estado !== "soportado") || !archivo || !contenido || !uso
         || s.estado !== "disponible_sin_soporte" || !linea)
         throw inesperada(status);
+    // Un bloque ADITIVO a medias no tumba el widget de siempre (revisión 1, P2-1): se descarta entero, con un aviso, y no se muestra
+    // nada de él (nunca la mitad).
+    let propia = aInterfazPropia(v.interfaz_propia);
+    if (propia === null) {
+        avisar?.("The engine described the app's own interface halfway; I'm ignoring that part.");
+        propia = undefined;
+    }
     return {
         tenant_id: tenantId, project_id: projectId, backend_url: backendUrl, paquete: "@supcoflow/chat", version, instalar,
         nextjs: { estado: n.estado, archivo_sugerido: archivo, archivos_anteriores: anteriores, contenido, uso },
         script: { estado: "disponible_sin_soporte", linea },
         csp,
+        ...(propia === undefined ? {} : { interfaz_propia: propia }),
+    };
+}
+// `undefined` es «el motor no la manda» (producción de hoy; también `null`); `null` es «la mandó a medias»; y una lista cerrada de
+// campos, anidados incluidos: lo que el motor sume mañana dentro de `interfaz_propia` no se copia (como el resto del widget).
+// Sin `\\` tampoco: un `..` escrito con barras invertidas no se vería al partir por `/`.
+const SIN_ESPACIOS_RAROS = /^[\x21-\x5b\x5d-\x7e]+$/;
+const EN_EL_PAQUETE = "node_modules/@supcoflow/chat/";
+const ENTRADA_DEL_PAQUETE = "@supcoflow/chat/";
+// Una ruta o una entrada: un texto sin espacios ni control, que empiece donde tiene que empezar y no suba con `..`.
+const conPrefijo = (v, prefijo) => {
+    const t = texto(v);
+    return t !== null && SIN_ESPACIOS_RAROS.test(t) && t.startsWith(prefijo) && t.length > prefijo.length && !t.split("/").includes("..") ? t : null;
+};
+const objetoONull = (v) => (typeof v === "object" && v !== null && !Array.isArray(v) ? v : null);
+function aInterfazPropia(v) {
+    if (v === undefined || v === null)
+        return undefined;
+    const o = objetoONull(v);
+    const c = objetoONull(o?.contrato), e = objetoONull(o?.entradas), d = objetoONull(o?.documentos), n = objetoONull(o?.opciones_del_nucleo);
+    if (o === null || c === null || e === null || d === null || n === null)
+        return null;
+    const [version, instalar, tenantId, projectId, backendUrl, csp, nucleoTenant, nucleoProyecto] = [o.version, o.instalar, o.tenant_id, o.project_id, o.backend_url, o.csp, n.tenantId, n.projectId].map(texto);
+    const cVersion = texto(c.version);
+    const [cArchivo, cDocumento] = [c.archivo, c.documento].map((x) => conPrefijo(x, EN_EL_PAQUETE));
+    const entradas = [e.nucleo, e.react, e.pruebas, e.servidor_de_pruebas].map((x) => conPrefijo(x, ENTRADA_DEL_PAQUETE));
+    const docs = [d.nucleo, d.react, d.pruebas, d.conformidad, d.protocolo].map((x) => conPrefijo(x, EN_EL_PAQUETE));
+    if ((o.estado !== "sin_publicar" && o.estado !== "disponible") || o.paquete !== "@supcoflow/chat"
+        || !version || !instalar || !tenantId || !projectId || !backendUrl || !csp || !nucleoTenant || !nucleoProyecto
+        || !cVersion || !esSemver(cVersion) || cArchivo === null || cDocumento === null
+        || entradas.includes(null) || docs.includes(null))
+        return null;
+    const [eNucleo, eReact, ePruebas, eServidor] = entradas;
+    const [dNucleo, dReact, dPruebas, dConformidad, dProtocolo] = docs;
+    return {
+        estado: o.estado, paquete: "@supcoflow/chat", version, instalar, tenant_id: tenantId, project_id: projectId, backend_url: backendUrl, csp,
+        opciones_del_nucleo: { tenantId: nucleoTenant, projectId: nucleoProyecto },
+        contrato: { version: cVersion, archivo: cArchivo, documento: cDocumento },
+        entradas: { nucleo: eNucleo, react: eReact, pruebas: ePruebas, servidor_de_pruebas: eServidor },
+        documentos: { nucleo: dNucleo, react: dReact, pruebas: dPruebas, conformidad: dConformidad, protocolo: dProtocolo },
     };
 }
 // Una lista de textos no vacíos; ausente es lista vacía (un motor sin el campo), y cualquier otra forma es null.
@@ -348,11 +396,12 @@ function listaDeTextos(v) {
     const textos = v.map(texto);
     return textos.every((t) => t !== null && t !== "") ? textos : null;
 }
-export async function leerWidget(api, clave, proyectoId, f) {
+// `avisar` recibe lo que la terminal descarta sin tumbar el comando (hoy: una `interfaz_propia` a medias).
+export async function leerWidget(api, clave, proyectoId, f, avisar) {
     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);
+    return aWidget(r.cuerpo, r.status, avisar);
 }
 // ---- La prueba (bloque 7) ----
 const rutaDelProyecto = (proyectoId) => `/api/proyectos/${encodeURIComponent(proyectoId)}`;

package/dist/argumentos.js

@@ -13,8 +13,10 @@ export const COMANDOS_COMPUESTOS = [
 const PRIMERAS_PALABRAS = new Set([...COMANDOS_COMPUESTOS, ...Object.keys(COMANDOS_VIEJOS)].filter((c) => c.includes(" ")).map((c) => c.split(" ")[0]));
 const FLAGS_CON_VALOR = [
     "repo", "install", "test", "site", "title", "greeting", "file", "allow", "mode", "name", "save-to", "id", "source", "skill", "app",
-    "message", "test-id", "ceiling", "expect-policy",
+    "message", "test-id", "ceiling", "expect-policy", "shape",
 ];
+// Los que sí se repiten (cada comando decide cuántos acepta: `cli.ts`, `archivosDeMas`); ninguno va vacío.
+const FLAGS_REPETIBLES = new Set(["file"]);
 const FLAGS_BOOLEANOS = ["json", "dry-run", "help", "start", "wait", "from-github", "authorize-spend"];
 // El flag que el token nombró, ya llevado a su nombre canónico (el viejo y el nuevo cuentan como el mismo).
 const canonico = (nombre) => FLAGS_VIEJOS[nombre] ?? nombre;
@@ -55,7 +57,7 @@ export function leerArgumentos(argv) {
     // nombre viejo y el nuevo de un mismo flag) creería que se usó el primero. Se mira en los tokens y se rechaza.
     for (const nombre of FLAGS_CON_VALOR) {
         const toks = tokens.filter((t) => canonico(t.name) === nombre);
-        if (toks.length > 1 || toks.some((t) => t.value === "")) {
+        if ((toks.length > 1 && !FLAGS_REPETIBLES.has(nombre)) || toks.some((t) => t.value === "")) {
             throw invalida("argumentos_invalidos", `--${nombre} goes once, with a value. Try \`supcoflow --help\`.`);
         }
     }
@@ -86,6 +88,7 @@ export function leerArgumentos(argv) {
         return t === undefined ? null : (t.value ?? null);
     };
     const hay = (nombre) => tokens.some((x) => canonico(x.name) === nombre);
+    const archivos = tokens.filter((t) => canonico(t.name) === "file").map((t) => t.value ?? "");
     return {
         comando,
         viejos,
@@ -111,6 +114,8 @@ export function leerArgumentos(argv) {
             fromGithub: hay("from-github"),
             skill: un("skill"),
             app: un("app"),
+            files: archivos,
+            shape: un("shape"),
             authorizeSpend: hay("authorize-spend"),
             message: un("message"),
             testId: un("test-id"),

package/dist/cli.js

@@ -19,7 +19,7 @@ import { repoConectarInteractivo, repoConectarStart, repoConectarWait } from "./
 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";
+import { archivosDeMas, flagQueNoAplica } from "./flags-por-comando.js";
 const COMANDOS = new Set(DESCRIPCION.comandos.map((c) => c.nombre));
 const invalida = (error, message) => new FalloDeLaTerminal(SALIDA.entradaInvalida, error, message);
 // Los nombres que la terminal tenía antes de la 0.8.0 siguen valiendo (`src/alias.ts`), pero no salen en `describe`.
@@ -42,13 +42,16 @@ async function correr(argv) {
             site: flags.site !== null, title: flags.title !== null, greeting: flags.greeting !== null, theme: flags.theme.length > 0,
             file: flags.file !== null, allow: flags.allow !== null, mode: flags.mode !== null,
             name: flags.name !== null, saveTo: flags.saveTo !== null, id: flags.id !== null, source: flags.source !== null, fromGithub: flags.fromGithub,
-            skill: flags.skill !== null, app: flags.app !== null,
+            skill: flags.skill !== null, app: flags.app !== null, shape: flags.shape !== null,
             authorizeSpend: flags.authorizeSpend, message: flags.message !== null, testId: flags.testId !== null,
             ceiling: flags.ceiling !== null, expectPolicy: flags.expectPolicy !== null,
         };
         const noAplica = flagQueNoAplica(comando, Object.keys(presentes).filter((k) => presentes[k]));
         if (noAplica !== null)
             throw invalida("flag_no_aplica", noAplica);
+        const deMas = archivosDeMas(comando, flags.files.length);
+        if (deMas !== null)
+            throw invalida("argumentos_invalidos", deMas);
         if (flags.start && flags.wait) {
             throw invalida("flags_incompatibles", "--start and --wait go separately: first one and then the other.");
         }

package/dist/comandos/contexto.js

@@ -0,0 +1,102 @@
+// ¿Este repo va con la cuenta en la que estoy? (1A.1, fricción 6). La terminal junta lo que ya sabe y frena, ANTES de
+// conectar, crear o publicar nada, ante lo que no cierra y se puede VER:
+//   - el `.supcoflow/proyecto.json` del clon contra el proyecto que la clave ve para ese repo;
+//   - ese archivo cuando no se entiende;
+//   - al crear un proyecto: el dueño del repo contra el login de GitHub de la clave, y la falta de GitHub.
+// Qué NO cubre: un proyecto del mismo repo en OTRO equipo cuando el clon no tiene su archivo (el motor tendría que mirar
+// en todos los equipos y eso filtra información entre clientes), ni prueba una identidad: el motor compara el número de
+// GitHub y el login es una etiqueta que se puede cambiar. Por eso `dueno_distinto_del_login` es una posible incoherencia.
+import path from "node:path";
+import { SALIDA } from "../contrato.js";
+// 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}$/;
+export const RUTA_DEL_ARCHIVO_DEL_CLON = path.join(".supcoflow", "proyecto.json");
+export 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;
+    }
+}
+/** Los tres estados del archivo del clon. Nunca se imprime su contenido; sólo el id, si tiene forma de id. */
+export function leerElArchivoDelClon(archivos, raiz) {
+    // Sin clon de este repo (un `--repo` ajeno a la carpeta) no hay archivo que le pertenezca.
+    if (archivos === undefined || raiz === null)
+        return { estado: "ausente" };
+    let crudo;
+    try {
+        crudo = archivos.leer(path.join(raiz, RUTA_DEL_ARCHIVO_DEL_CLON));
+    }
+    catch {
+        return { estado: "ilegible" };
+    }
+    if (crudo === null)
+        return { estado: "ausente" };
+    const id = idDelArchivo(crudo);
+    return id === null ? { estado: "ilegible" } : { estado: "valido", id };
+}
+export function contextoIncoherente(motivo, message, extra = {}) {
+    return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "contexto_incoherente", motivo, message, ...extra }, texto: message };
+}
+/**
+ * El clon contra lo que la clave ve (lo que comparten TODOS los comandos que actúan sobre el proyecto del repo).
+ * `null` = coherente. `proyecto` es el que la clave ve para este repo, o null si no ve ninguno.
+ */
+export function coherenciaDelClon(archivo, proyecto, repo) {
+    if (archivo.estado === "ilegible") {
+        return contextoIncoherente("archivo_del_clon_ilegible", "I can't read `.supcoflow/proyecto.json` in this clone; I won't act on this repo until it's readable. Look at it before going on.", { repo, en_el_clon: { estado: "ilegible", id: null } });
+    }
+    if (archivo.estado === "valido" && archivo.id !== proyecto?.id) {
+        return contextoIncoherente("proyecto_del_clon_distinto", `The project noted in this clone (${archivo.id}) isn't the one your account sees for this repo (${proyecto?.id ?? "none"}). `
+            + "Check which account you signed in with (`supcoflow whoami`), or, if that file is old, review it.", { repo, en_el_clon: { estado: "valido", id: archivo.id }, proyecto: proyecto?.id ?? null });
+    }
+    return null;
+}
+export function armarElContexto(d) {
+    const { yo } = d;
+    const soloLectura = yo.via === "clave_de_consulta";
+    const login = yo.usuario?.login ?? null;
+    const tipo = soloLectura ? "clave_de_consulta" : login !== null ? "github" : "email";
+    return {
+        equipo: yo.equipo,
+        identidad: tipo === "github" ? login : tipo,
+        identidad_tipo: tipo,
+        fuente: d.fuente,
+        repo: d.repo,
+        proyecto: d.proyecto?.id ?? null,
+        en_el_clon: { estado: d.archivo.estado, id: d.archivo.estado === "valido" ? d.archivo.id : null },
+    };
+}
+/** La línea que la persona lee: quién es, en qué equipo, qué repo y qué proyecto. */
+export function lineaDelContexto(c, readOnlyDe = null) {
+    const quien = c.identidad_tipo === "github" ? `@${c.identidad}` : c.identidad_tipo === "email" ? "signed in with email (no GitHub)" : `using a read-only key${readOnlyDe ? ` for ${readOnlyDe}` : ""}`;
+    const cuenta = `You're ${quien} in team ${c.equipo}`;
+    const proyecto = c.proyecto !== null ? `project ${c.proyecto} (existing)` : `no project yet (it will be created in team ${c.equipo})`;
+    return `${cuenta}; repo ${c.repo}; ${proyecto}.`;
+}
+/**
+ * Sólo cuando la clave NO ve proyecto para el repo y se va a crear uno: lo que se ve de la cuenta contra el repo.
+ * Una clave de consulta no crea nada, así que no se compara su login con nadie.
+ */
+export function coherenciaAlCrear(d) {
+    if (d.yo.via === "clave_de_consulta")
+        return null;
+    const login = d.yo.usuario?.login ?? null;
+    if (login === null) {
+        return contextoIncoherente("sin_github", "Connecting a repo needs a Supcoflow account signed in with GitHub.", { repo: d.repo });
+    }
+    const dueno = d.repo.split("/")[0];
+    if (dueno.toLowerCase() === login.toLowerCase())
+        return null;
+    const deLaVariable = d.fuente === "env"
+        ? " Your key comes from SUPCOFLOW_TOKEN, which wins over a new login: unset it or replace it first; I don't touch it."
+        : "";
+    return contextoIncoherente("dueno_distinto_del_login", `This repo's owner on GitHub (@${dueno}) isn't the GitHub account your key shows (@${login}). `
+        + `If you renamed your GitHub account, sign in to the Supcoflow console with GitHub again (that updates it) and run this again; otherwise sign in as @${dueno}.${deLaVariable}`, { repo: d.repo, dueno, login, ...(d.fuente === "env" ? { fuente: "env" } : {}) });
+}

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.8.0";
+const VERSION = "0.9.0";
 export const DESCRIPCION = {
     version: VERSION,
     comandos: [
@@ -55,11 +55,11 @@ export const DESCRIPCION = {
         },
         {
             nombre: "project create",
-            resumen: "Creates (or reuses) the already connected repo's project and records it in .supcoflow/proyecto.json; a different existing file is never overwritten (exits 4).",
+            resumen: "Creates (or reuses) the already connected repo's project and records it in .supcoflow/proyecto.json; a different existing file is never overwritten (exits 4). Before connecting or creating anything it checks what it can see and exits 4 contexto_incoherente (motivo proyecto_del_clon_distinto: the clone notes a project your account doesn't see for this repo; archivo_del_clon_ilegible: .supcoflow/proyecto.json can't be read; dueno_distinto_del_login: a possible mismatch, the repo's owner on GitHub isn't the GitHub login of your key; sin_github: the account isn't signed in with GitHub) without touching anything.",
             flags: [
                 "--install \"…\": the install command, when the engine can't work it out",
                 "--test \"…\": the test command, same",
-                "--repo owner/repo: the repo, if it isn't this folder's «origin» (without writing the file)",
+                "--repo owner/repo: the repo, if it isn't this folder's «origin» (without reading or writing this clone's file)",
                 "--dry-run: says what it would create without creating anything",
                 "--json",
             ],
@@ -68,10 +68,10 @@ export const DESCRIPCION = {
         },
         {
             nombre: "project show",
-            resumen: "Shows the repo's project: branch, commands and the GitHub App's state; null if it has none yet.",
+            resumen: "Shows the repo's project: branch, commands and the GitHub App's state; null if it has none yet. It starts with who you are: `contexto` { equipo, identidad (the GitHub login, or «email», or «clave_de_consulta»), identidad_tipo, fuente, repo, proyecto (id or null), en_el_clon { estado: ausente|valido|ilegible, id } }, said as «You're @login in team T; repo O/R; project P (existing)». Exits 4 contexto_incoherente if this clone's .supcoflow/proyecto.json doesn't match what your key sees (proyecto_del_clon_distinto / archivo_del_clon_ilegible) or, when the repo has no project yet, if the account can't create one for it (dueno_distinto_del_login, a possible mismatch / sin_github): it stops BEFORE `repo connect`. The repo comes from the «origin» of this clone; if origin is an SSH alias or not GitHub, from a remote called `supcoflow` that points at https://github.com/owner/repo.git (the first time, `git remote add supcoflow https://github.com/owner/repo.git`: it is never fetched and ssh is never run).",
             flags: ["--repo owner/repo: the repo, if it isn't this folder's «origin»", "--json"],
             ejemplos: ["supcoflow project show --json"],
-            codigos: [0, 1, 2, 3],
+            codigos: [0, 1, 2, 3, 4],
         },
         {
             nombre: "catalog",
@@ -82,7 +82,7 @@ export const DESCRIPCION = {
         },
         {
             nombre: "config",
-            resumen: "Shows the repo's project configuration: chat, sites, brand, problem policy and data agreement. The agreement limits what is saved and what the investigating AI reads; it doesn't cover what the chat's AI sees while it talks.",
+            resumen: "Shows the repo's project configuration: chat, sites, brand, problem policy and data agreement. The agreement limits what is saved and what the investigating AI reads; it doesn't cover what the chat's AI sees while it talks. Like every command that acts on the repo's project, it exits 4 contexto_incoherente without doing anything if this clone's .supcoflow/proyecto.json notes another project than the one your key sees (proyecto_del_clon_distinto) or can't be read (archivo_del_clon_ilegible).",
             flags: ["--repo owner/repo: the repo, if it isn't this folder's «origin»", "--json"],
             ejemplos: ["supcoflow config --json"],
             codigos: [0, 1, 2, 3, 4],
@@ -185,14 +185,14 @@ export const DESCRIPCION = {
         {
             nombre: "guide check",
             resumen: "Checks .supcoflow/guide.md (this clone's root) against the engine, without publishing anything: says whether it's well formed and how many sections it has. It's the step before the commit. If guide.md doesn't exist it reads the old name .supcoflow/guia.md and says so.",
-            flags: ["--repo owner/repo: the repo, if it isn't this folder's «origin» (without a local clone it exits 3 falta_guia: the guide is read from the file)", "--dry-run: says what it would send without sending it", "--json"],
+            flags: ["--repo owner/repo: the repo, if it isn't this folder's «origin» (the guide is read from this clone only if it is that repo: its origin, or a `supcoflow` remote at https://github.com/owner/repo.git; otherwise it exits 3 falta_guia saying what this clone is and the exact `git remote add supcoflow …`, without asking the engine)", "--dry-run: says what it would send without sending it", "--json"],
             ejemplos: ["supcoflow guide check --json"],
             codigos: [0, 1, 2, 3, 4],
         },
         {
             nombre: "guide publish",
             resumen: "Uploads .supcoflow/guide.md directly (or the old name guia.md, only if guide.md doesn't exist): sends the content, the file it read and the commit and branch this clone declares (if there's git and commits; otherwise, no commit). The engine checks it and makes it the active guide; the commit is kept as «declared by the terminal, not verified in GitHub». With --from-github it keeps the earlier route: it sends the fingerprint and the engine compares it with the main branch's; if it isn't pushed to that branch yet (or it's another one), it exits 5.",
-            flags: ["--from-github: doesn't upload the file; verifies against GitHub's main branch (exits 5 guia_no_subida / guia_distinta if it doesn't match)", "--repo owner/repo: the repo, if it isn't this folder's «origin» (without a local clone it exits 3 falta_guia: the guide is read from the file)", "--dry-run: says what it would send (or the fingerprint with --from-github), without requesting anything", "--json"],
+            flags: ["--from-github: doesn't upload the file; verifies against GitHub's main branch (exits 5 guia_no_subida / guia_distinta if it doesn't match)", "--repo owner/repo: the repo, if it isn't this folder's «origin» (the guide is read from this clone only if it is that repo: its origin, or a `supcoflow` remote at https://github.com/owner/repo.git; otherwise it exits 3 falta_guia saying what this clone is and the exact `git remote add supcoflow …`, without asking the engine)", "--dry-run: says what it would send (or the fingerprint with --from-github), without requesting anything", "--json"],
             ejemplos: ["supcoflow guide publish --json"],
             codigos: [0, 1, 2, 3, 4, 5],
         },
@@ -219,35 +219,36 @@ export const DESCRIPCION = {
         },
         {
             nombre: "widget",
-            resumen: "Shows what to paste into the app to get the chat, built by the engine with the project's ids: the package and its exact version, the Next.js wrapper file (`nextjs.contenido`, as is, without rewriting the ids), the file name to use (`nextjs.archivo_sugerido`) and the earlier names the chat may already be installed under (`nextjs.archivos_anteriores`), how to use it, the CSP line and the <script> one (not for Next.js). It writes no files. Exits 4 sin_proyecto if the repo has no project; 1 respuesta_inesperada if the engine sends something halfway.",
-            flags: ["--repo owner/repo: the repo, if it isn't this folder's «origin»", "--json: the engine's object as is"],
+            resumen: "Shows what to paste into the app to get the chat, built by the engine with the project's ids: the package and its exact version, the Next.js wrapper file (`nextjs.contenido`, as is, without rewriting the ids), the file name to use (`nextjs.archivo_sugerido`) and the earlier names the chat may already be installed under (`nextjs.archivos_anteriores`), how to use it, the CSP line and the <script> one (not for Next.js). If the engine describes the app's own interface (`interfaz_propia`: the app builds the chat with its own components; there is no code to paste) it passes it on as the engine sent it: `estado` (`sin_publicar`: the version isn't on npm yet, so the text doesn't offer the path; `disponible`), the package with its exact version, the ids, the backend, the CSP line, the presentation contract (`contrato.version`, `contrato.archivo`, `contrato.documento`), the entry points (`entradas`) and the docs (`documentos`). A halfway `interfaz_propia` is ignored with a warning on stderr and the widget is shown as always. It writes no files. Exits 4 sin_proyecto if the repo has no project; 1 respuesta_inesperada if the engine sends the widget itself halfway.",
+            flags: ["--repo owner/repo: the repo, if it isn't this folder's «origin»", "--json: the engine's object as is (`interfaz_propia` only when the engine sends it)"],
             ejemplos: ["supcoflow widget --json"],
             codigos: [0, 1, 2, 3, 4],
         },
         {
             nombre: "install record",
-            resumen: "Records in .supcoflow/instalacion.json (this clone's root, version 2) which versions the chat was installed with: the skill, this terminal, the chat package (declared in the app's package.json and installed in node_modules), the project configuration and, with --file, the file the chat lives in; never a secret or a date. Repeating without changes doesn't touch it (sin_cambios: true), and running again without --file keeps the file already recorded. It only rewrites it if git already keeps the previous one: with uncommitted changes (or deleted without a commit) it exits 4 cambios_sin_commit; if it exists without being tracked (or ignored), 4 archivo_no_versionado. Others: 3 falta_skill / skill_invalida / archivo_invalido / app_fuera_del_repo / app_inexistente / sin_clon; 4 sin_proyecto / acuerdo_ilegible; 1 paquete_ilegible / configuracion_inesperada / archivo_no_escrito.",
+            resumen: "Records in .supcoflow/instalacion.json (this clone's root, version 3) which versions the chat was installed with: the skill, this terminal, the chat package (declared in the app's package.json and installed in node_modules), the project configuration and what was installed: `forma` (`widget` or `interfaz_propia`, with --shape), `archivos` (the files the chat lives in, with --file) and `contrato` (the version of the presentation contract the installed package carries in its contract.json, or null if it has none); never a secret or a date. A version 1 or 2 file is read without error as a widget (the `archivo` of a 2 is its file). Changing --shape without --file leaves `archivos` empty (the files of the other form aren't inherited). Repeating without changes doesn't touch it (sin_cambios: true), and running again without --shape or --file keeps the form and the files already recorded. The JSON adds `archivos`, `forma` and `contrato`; `archivo` (the first file) stays for the skills before 0.9.0. It only rewrites it if git already keeps the previous one: with uncommitted changes (or deleted without a commit) it exits 4 cambios_sin_commit; if it exists without being tracked (or ignored), 4 archivo_no_versionado. Others: 3 falta_skill / skill_invalida / archivo_invalido / forma_invalida / app_fuera_del_repo / app_inexistente / sin_clon; 4 sin_proyecto / acuerdo_ilegible / escrito_por_una_terminal_mas_nueva (the file is version 4 or more: it doesn't rewrite it); 1 paquete_ilegible / configuracion_inesperada / archivo_no_escrito.",
             flags: [
                 "--skill version: the metadata.version of the skill that installs it (semver, required; without it exits 3 falta_skill without requesting anything)",
-                "--file path: the chat file, relative to the repo root (no `..`, not absolute, not a symlink or through one; otherwise exits 3 archivo_invalido and writes nothing)",
+                "--file path: a file of the chat, relative to the repo root (no `..`, not absolute, not a symlink or through one; otherwise exits 3 archivo_invalido and writes nothing). It can be repeated (up to 20; an own interface lives in several files) and replaces the list already recorded",
+                "--shape widget|own-interface: what was installed: the packaged widget, or a chat the app builds with its own components (`forma: interfaz_propia`); anything else exits 3 forma_invalida. Without it the recorded form is kept",
                 "--app folder: the app's folder, relative to the repo root (the root by default; outside the repo it exits 3 app_fuera_del_repo)",
-                "--repo owner/repo: the repo, if it isn't this folder's «origin» (without a local clone it exits 3 sin_clon: the file goes in the clone)",
+                "--repo owner/repo: the repo, if it isn't this folder's «origin» (the file goes in this clone only if it is that repo: its origin, or a `supcoflow` remote at https://github.com/owner/repo.git; otherwise it exits 3 sin_clon saying what this clone is and the exact `git remote add supcoflow …`, without asking the engine)",
                 "--dry-run: shows the file and the difference without writing anything",
                 "--json",
             ],
-            ejemplos: ["supcoflow install record --skill 0.3.0 --app web --file web/app/_supcoflow/support-chat.tsx --json"],
+            ejemplos: ["supcoflow install record --skill 0.3.1 --app web --file web/app/_supcoflow/support-chat.tsx --json"],
             codigos: [0, 1, 2, 3, 4],
         },
         {
             nombre: "diagnose",
-            resumen: "Says, free of charge and writing nothing, how far the installation is (sign-in, repo, GitHub App, allowed sites, chat and guide: N of 6) and, apart, whether a test of the project would go in and how far it would get: policy, monthly balance against the test's ceiling, open tests and whatever else the engine adds. Exits 0 if everything is ready and 4 if something needs fixing (no_listo), with each point.",
-            flags: ["--repo owner/repo: the repo, if it isn't this folder's «origin»", "--json: { instalacion: { ok, total: 6, puntos }, prueba: { listo, puntos }, … }"],
+            resumen: "Says, free of charge and writing nothing, how far the installation is (sign-in, repo, GitHub App, allowed sites, chat, guide and interface: N of 7) and, apart, whether a test of the project would go in and how far it would get: policy, monthly balance against the test's ceiling, open tests, whether THIS machine can save the test request (the local point `maquina`, checked without writing anything) and whatever else the engine adds. Exits 0 if everything is ready and 4 if something needs fixing (no_listo), with each point; if `maquina` isn't ok, `listo` and `prueba.listo` are false and the N of 7 doesn't change. The seventh point, `interfaz`, is local and only reads: if .supcoflow/instalacion.json records an own interface (`forma: interfaz_propia`) it checks that the recorded files are still there and that the recorded contract is not behind a new major version (the first number) of the one the project declares (`interfaz_propia.contrato.version` in `widget`; a newer minor or patch only adds optional points and stays ok, saying so); without an own interface it is ok («Not applicable»). It is advice, marked `aviso: true` in the JSON: it lowers the N of 7 but doesn't stop a test.",
+            flags: ["--repo owner/repo: the repo, if it isn't this folder's «origin»", "--json: { instalacion: { ok, total: 7, puntos }, prueba: { listo, puntos }, maquina: { ok, impedimentos: [{ codigo, detalle }] }, intento_pendiente: { techo_usd, politica } | null, … }"],
             ejemplos: ["supcoflow diagnose --json"],
             codigos: [0, 1, 2, 3, 4],
         },
         {
             nombre: "test",
-            resumen: "Tests the installation end to end: a problem comes in through the same door as the chat and ends up as an issue. It spends one investigation (up to the ceiling you authorize; with the save policy it goes as far as the saved case and doesn't spend). Without --authorize-spend it sends nothing: it exits 4 falta_autorizacion with techo_usd, saldo_usd, tope_usd and comprometido_usd. With --authorize-spend, --ceiling and --expect-policy it requests the test with exactly those values (it doesn't re-read anything to choose them) and exits 5 with prueba_id; then --wait follows it. If the ceiling or the policy changed in the meantime it exits 4 techo_distinto / politica_distinta with the new values and doesn't retry: ask again. Others: 4 prueba_en_curso (with its id), chat_deshabilitado, requiere_api_key, intento_pendiente; 6 tope_mensual; 1 with intento_pendiente: true if the answer didn't arrive (repeating resumes the same test).",
+            resumen: "Tests the installation end to end: a problem comes in through the same door as the chat and ends up as an issue. It spends one investigation (up to the ceiling you authorize; with the save policy it goes as far as the saved case and doesn't spend). Without --authorize-spend it sends nothing: it exits 4 falta_autorizacion with techo_usd, saldo_usd, tope_usd and comprometido_usd, and, checked before you say yes and without writing anything, `maquina` { ok, impedimentos: [{ codigo, detalle }] } (whether this machine can save the test request: if it isn't ok the message says why first) and `intento_pendiente` { techo_usd, politica } | null (a request waiting for confirmation: only its ceiling and policy, never its message or key). With --authorize-spend, --ceiling and --expect-policy it requests the test with exactly those values (it doesn't re-read anything to choose them) and exits 5 with prueba_id; then --wait follows it. If the ceiling or the policy changed in the meantime it exits 4 techo_distinto / politica_distinta with the new values and doesn't retry: ask again. Others: 4 prueba_en_curso (with its id), chat_deshabilitado, requiere_api_key, intento_pendiente; 6 tope_mensual; 1 with intento_pendiente: true if the answer didn't arrive (repeating resumes the same test).",
             flags: [
                 "--authorize-spend: authorizes the spend of ONE test; without it nothing that writes is sent",
                 "--ceiling usd: the ceiling you authorize, the number you were shown (required with --authorize-spend)",

package/dist/comandos/guia.js

@@ -33,14 +33,15 @@ const AVISOS_DEL_NOMBRE = {
 // error: nunca motivo para leer el viejo). Si están los dos manda `guide.md` y se avisa que el otro se ignora.
 async function leerLaGuia(d, flags) {
     let raiz;
+    let sinClon;
     try {
-        raiz = (await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd })).raiz;
+        ({ raiz, sinClon } = await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd }));
     }
     catch (e) {
         return { ok: false, resultado: resultadoDeFallo(e) };
     }
     if (raiz === null) {
-        return { ok: false, resultado: fallo(SALIDA.entradaInvalida, "falta_guia", `I don't have that repo's clone here, and the guide is read from ${RUTA_DE_LA_GUIA}: stand in the repo's clone.`) };
+        return { ok: false, resultado: fallo(SALIDA.entradaInvalida, "falta_guia", `${sinClon ?? "I don't have that repo's clone here."} The guide is read from ${RUTA_DE_LA_GUIA} in the repo's clone: stand in it.`) };
     }
     let ruta = RUTA_DE_LA_GUIA;
     let aviso = null;