supcoflow 0.8.0 → 0.8.1

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 and which file it lives in. |
+| `supcoflow diagnose` | Free: how far the installation is (N of 6) 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`:
 
@@ -172,7 +207,7 @@ 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 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 +225,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 +277,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

@@ -23,7 +23,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.8.1";
 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

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.8.1";
 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],
         },
@@ -231,23 +231,23 @@ export const DESCRIPCION = {
                 "--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)",
                 "--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 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, 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 6 doesn't change.",
+            flags: ["--repo owner/repo: the repo, if it isn't this folder's «origin»", "--json: { instalacion: { ok, total: 6, 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;

package/dist/comandos/instalacion.js

@@ -139,14 +139,15 @@ export async function instalacionAnotar(d, flags) {
     }
     // ─── La raíz y la app, antes de cualquier pedido ───
     let raizGit;
+    let sinClon;
     try {
-        raizGit = (await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd })).raiz;
+        ({ raiz: raizGit, sinClon } = await repoPedido({ flagRepo: flags.repo, git: d.git, cwd: d.cwd }));
     }
     catch (e) {
         return resultadoDeFallo(e);
     }
     if (raizGit === null)
-        return fallo(SALIDA.entradaInvalida, "sin_clon", `I don't have that repo's clone here, and ${RUTA_DE_LA_INSTALACION} goes in the clone: stand in the repo's clone.`);
+        return fallo(SALIDA.entradaInvalida, "sin_clon", `${sinClon ?? "I don't have that repo's clone here."} ${RUTA_DE_LA_INSTALACION} goes in the repo's clone: stand in it.`);
     const raiz = d.rutaReal(raizGit);
     if (raiz === null)
         return fallo(SALIDA.inesperado, "inesperado", "I couldn't resolve the repo's root.");

package/dist/comandos/probar.js

@@ -44,6 +44,26 @@ function datosDelDiagnostico(g) {
     };
 }
 const lineasDePuntos = (puntos, nombre = (p) => p) => puntos.map((p) => `  [${p.ok ? "ok" : "missing"}] ${nombre(p.punto)}: ${p.mensaje}`);
+// Lo que esta máquina puede o no hacer con el pedido de la prueba, visto ANTES del OK de gasto y sin escribir nada. Un
+// prechequeo que falla es «no ok», nunca un error: avisar tarde es justo lo que esto evita.
+async function revisarLaMaquina(d, proyectoId) {
+    try {
+        return await d.pruebas.revisar(proyectoId);
+    }
+    catch {
+        return { maquina: { ok: false, impedimentos: [{ codigo: "no_se_pudo_revisar", detalle: "I couldn't check whether this machine can save the test request." }] }, intentoPendiente: null };
+    }
+}
+const datosDeLaMaquina = (r) => ({ maquina: r.maquina });
+const datosDelIntentoPendiente = (r) => ({
+    intento_pendiente: r.intentoPendiente === null ? null : { techo_usd: r.intentoPendiente.techoUsd, politica: r.intentoPendiente.politica },
+});
+const detalles = (r) => r.maquina.impedimentos.map((i) => i.detalle).join(" ");
+function puntoDeLaMaquina(r) {
+    return r.maquina.ok
+        ? { punto: "maquina", ok: true, mensaje: "No obstacle found to saving the test request on this machine.", grupo: "prueba" }
+        : { punto: "maquina", ok: false, mensaje: `This machine can't save the test request yet: ${detalles(r)}`, grupo: "prueba" };
+}
 export async function diagnosticar(d, flags) {
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
@@ -64,16 +84,23 @@ export async function diagnosticar(d, flags) {
     catch {
         local = { repo: null, raiz: null, motivo: "sin_git" };
     }
-    const { instalacion, prueba } = agruparPuntos(g, [puntoDeSesion(), puntoDelRepo(local, p.proyecto.repo)]);
+    const agrupados = agruparPuntos(g, [puntoDeSesion(), puntoDelRepo(local, p.proyecto.repo)]);
+    const instalacion = agrupados.instalacion;
+    // El punto local de la prueba (1A.1): ¿esta máquina puede guardar el pedido? Si no, la prueba no entra, y se dice acá y
+    // no después del OK de gasto. No cuenta en el «N of 6» de la instalación.
+    const revision = await revisarLaMaquina(d, p.proyecto.id);
+    const prueba = [puntoDeLaMaquina(revision), ...agrupados.prueba];
     const buenos = contarBuenos(instalacion);
-    const listo = g.listo && instalacion.every((x) => x.ok || !["sign-in", "repo"].includes(x.punto));
+    const listo = g.listo && revision.maquina.ok && instalacion.every((x) => x.ok || !["sign-in", "repo"].includes(x.punto));
     const datos = {
         proyecto: { id: p.proyecto.id, repo: p.proyecto.repo },
         ...datosDelDiagnostico(g),
         listo,
         puntos: [...instalacion, ...prueba],
         instalacion: { ok: buenos, total: TOTAL_DE_INSTALACION, puntos: instalacion },
-        prueba: { listo: g.listo, puntos: prueba },
+        prueba: { listo: g.listo && revision.maquina.ok, puntos: prueba },
+        ...datosDeLaMaquina(revision),
+        ...datosDelIntentoPendiente(revision),
     };
     const resumen = `Monthly balance ${usdONull(g.saldoUsd)} of ${usdONull(g.topeUsd)}; a test authorizes up to ${usd(g.techoUsd)}. Policy: ${enInglesLaPolitica(g.politica)}.`;
     const motivos = [
@@ -155,7 +182,9 @@ export async function probar(d, flags) {
         catch (e) {
             return resultadoDeFallo(e);
         }
-        const datos = { proyecto: { id: proyecto.id, repo: proyecto.repo }, ...datosDelDiagnostico(g) };
+        // Lo que esta máquina puede hacer con el pedido, visto ANTES del sí de gasto (fricción 3).
+        const revision = await revisarLaMaquina(d, proyecto.id);
+        const datos = { proyecto: { id: proyecto.id, repo: proyecto.repo }, ...datosDelDiagnostico(g), ...datosDeLaMaquina(revision) };
         const gasto = g.politica === "guardar"
             ? `With the \`save\` policy the test goes as far as the saved case and spends nothing; the ceiling it authorizes is still ${usd(g.techoUsd)}.`
             : `A test runs an investigation that spends up to ${usd(g.techoUsd)} (monthly balance ${usdONull(g.saldoUsd)} of ${usdONull(g.topeUsd)}).`;
@@ -180,8 +209,13 @@ export async function probar(d, flags) {
             };
         }
         const lanzar = `supcoflow test --authorize-spend --ceiling ${g.techoUsd} --expect-policy ${enInglesLaPolitica(g.politica)}`;
-        const message = `${gasto} To launch it: \`${lanzar}\`. \`supcoflow diagnose\` first says whether everything is ready.`;
-        return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "falta_autorizacion", message, ...datos }, texto: message };
+        // Primero lo que impide, si algo: es lo que la persona tiene que saber antes de decir que sí.
+        const impide = revision.maquina.ok ? "" : `This machine can't save the test request yet: ${detalles(revision)} Fix that before authorizing. `;
+        const previo = revision.intentoPendiente;
+        const pendiente = previo === null ? ""
+            : ` There's a test request waiting for confirmation (ceiling ${usd(previo.techoUsd)}, policy ${enInglesLaPolitica(previo.politica)}): to recover that same request, repeat \`${comandoDeReintento({ clave: "", mensaje: null, techoUsd: previo.techoUsd, politicaEsperada: previo.politica })}\`.`;
+        const message = `${impide}${gasto} To launch it: \`${lanzar}\`. \`supcoflow diagnose\` first says whether everything is ready.${pendiente}`;
+        return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "falta_autorizacion", message, ...datos, ...datosDelIntentoPendiente(revision) }, texto: message };
     }
     // ── Con --authorize-spend: el ciclo de la clave.
     let intento;

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

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

package/dist/comandos/proyecto.js

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

package/dist/diagnostico.js

@@ -1,3 +1,4 @@
+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 = [
@@ -21,6 +22,8 @@ export function puntoDelRepo(local, repoDelProyecto) {
             return mal("This folder isn't a git repo, so I can't tell which repo it is.");
         if (local.motivo === "sin_origin")
             return mal("This repo has no «origin» remote, so I can't tell which repo it is.");
+        if (local.motivo === "origin_alias_ssh")
+            return mal(`The «origin» of this repo isn't a GitHub repo. ${frasePorQueNoAtaClon(local, null)}`);
         return mal("The «origin» of this repo isn't a GitHub repo.");
     }
     if (local.repo.toLowerCase() !== repoDelProyecto.toLowerCase()) {

package/dist/entorno.js

@@ -2,7 +2,7 @@
 // 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";
@@ -12,6 +12,8 @@ import { esCarpetaReal, esEnlaceReal, rutaRealOEnNada } from "./comandos/instala
 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";
@@ -68,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.
@@ -396,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),
@@ -454,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),
@@ -476,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),
         },
@@ -489,7 +519,7 @@ export function entornoReal(env = process.env) {
             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),

package/dist/guardado/lugar.js

@@ -0,0 +1,63 @@
+// El prechequeo SIN ESCRITURAS de lo que guardar un registro necesita (1A.1, fricción 3): se llama antes del OK de gasto
+// para que la persona sepa ya si esta máquina va a poder guardar el pedido de la prueba, y no después. Mira lo mismo que
+// `persistir` (src/guardado/archivo.ts) va a pedirle al disco, y lo de git de la fricción 2c.
+//
+// Qué promete y qué no: «no se detectaron impedimentos» no es «se va a poder escribir». Un disco que se llena después, o
+// un cambio al mismo tiempo, no se pueden garantizar sin escribir. El guardado estricto, justo antes del POST, se queda.
+import path from "node:path";
+import { mirarProteccionDeGit, rutaReal } from "./repo.js";
+export async function revisarElLugar(d) {
+    const impedimentos = [];
+    const dir = path.dirname(d.ruta);
+    const nombre = path.basename(d.ruta);
+    const tmp = d.ruta + ".tmp";
+    let real;
+    try {
+        real = rutaReal(path.resolve(dir), d.fs);
+    }
+    catch {
+        // Un enlace roto en el camino: no se sabe dónde se escribiría, y `persistir` fallaría.
+        return [{ codigo: "ruta_irresoluble", detalle: `I can't tell where ${dir} really is (a broken symlink?).` }];
+    }
+    const carpeta = d.fs.estado(real);
+    if (carpeta.existe) {
+        if (carpeta.tipo !== "carpeta") {
+            impedimentos.push({ codigo: "carpeta_no_es_carpeta", detalle: `${dir} exists but isn't a folder.` });
+        }
+        else {
+            if (!carpeta.propio)
+                impedimentos.push({ codigo: "carpeta_ajena", detalle: `${dir} isn't yours, so I can't set its permissions to 0700.` });
+            if (!d.fs.puede(real, "escribir"))
+                impedimentos.push({ codigo: "carpeta_sin_permiso", detalle: `I can't write in ${dir}.` });
+        }
+    }
+    else {
+        // Todavía no existe: el ancestro más cercano que existe tiene que ser una carpeta donde se pueda crear.
+        let ancestro = path.dirname(real);
+        while (!d.fs.estado(ancestro).existe && path.dirname(ancestro) !== ancestro)
+            ancestro = path.dirname(ancestro);
+        const a = d.fs.estado(ancestro);
+        if (!a.existe || a.tipo !== "carpeta" || !d.fs.puede(ancestro, "escribir")) {
+            impedimentos.push({ codigo: "padre_sin_permiso", detalle: `${dir} doesn't exist and I can't create it: ${ancestro} isn't a folder I can write in.` });
+        }
+    }
+    const archivo = d.fs.estado(path.join(real, nombre));
+    if (archivo.existe) {
+        if (archivo.tipo !== "archivo")
+            impedimentos.push({ codigo: "archivo_no_comun", detalle: `${d.ruta} isn't a regular file.` });
+        else if (!d.fs.puede(path.join(real, nombre), "leer"))
+            impedimentos.push({ codigo: "archivo_ilegible", detalle: `I can't read ${d.ruta}.` });
+    }
+    else if (d.fs.existe(path.join(real, nombre))) {
+        impedimentos.push({ codigo: "archivo_no_comun", detalle: `${d.ruta} is a broken symlink.` });
+    }
+    // El `.tmp` se borra antes de escribir (`borrarSiExiste`, sin recursión): si es una carpeta, no se puede.
+    const temporal = d.fs.estado(path.join(real, nombre + ".tmp"));
+    if (temporal.existe && temporal.tipo === "carpeta") {
+        impedimentos.push({ codigo: "tmp_es_carpeta", detalle: `${tmp} is a folder: I remove that name before saving, and I can't remove a folder.` });
+    }
+    const git = await mirarProteccionDeGit({ dir, archivos: [nombre, nombre + ".tmp"], fs: d.fs, git: d.git });
+    if (!git.protegido)
+        impedimentos.push(git.impedimento);
+    return impedimentos;
+}

package/dist/guardado/protegido.js

@@ -0,0 +1,38 @@
+// El almacén de archivo de los dos registros de la terminal que PUEDEN vivir bajo una carpeta personal que es un repo
+// (`pruebas.json` e `idempotencia.json`; 1A.1, fricción 2c). Es un envoltorio fino: cada `escribir` y cada `borrar`
+// pasan por `asegurarProteccionDeGit` ANTES de tocar el disco, porque borrar una entrada reescribe el archivo entero
+// por su `.tmp`. Las credenciales no lo usan: dentro de un repo se siguen negando.
+import path from "node:path";
+import { asegurarProteccionDeGit } from "./repo.js";
+/** Git no garantiza que este archivo quede fuera del repo: no se escribió (ni se borró) nada. */
+export class SinProteccionDeGit extends Error {
+    impedimento;
+    constructor(impedimento) {
+        super(impedimento.detalle);
+        this.impedimento = impedimento;
+    }
+}
+export function almacenProtegido(base, d) {
+    const dir = path.dirname(d.ruta);
+    const archivos = [path.basename(d.ruta), path.basename(d.ruta) + ".tmp"];
+    async function proteger() {
+        const p = await asegurarProteccionDeGit({ dir, archivos, fs: d.fs, git: d.git });
+        if (!p.protegido)
+            throw new SinProteccionDeGit(p.impedimento);
+    }
+    return {
+        nombre: base.nombre,
+        leer: (cuenta, techoMs) => base.leer(cuenta, techoMs),
+        async escribir(cuenta, r, techoMs) {
+            await proteger();
+            await base.escribir(cuenta, r, techoMs);
+        },
+        async borrar(cuenta, techoMs) {
+            // Si no hay nada que borrar, `borrar` no reescribe nada: no hay nada que proteger.
+            if ((await base.leer(cuenta, techoMs)) === null)
+                return;
+            await proteger();
+            await base.borrar(cuenta, techoMs);
+        },
+    };
+}

package/dist/guardado/repo.js

@@ -33,3 +33,101 @@ export function dentroDeUnWorkingTree(dir, fs) {
     }
     return null;
 }
+const CONTENIDO_DEL_GITIGNORE = "# Written by supcoflow: nothing in this folder belongs in git.\n*\n";
+// La raíz del repo (si hay) de cada una de las dos rutas: la escrita y la real. Un tramo enlazado (`stow`)
+// puede hacer que sean dos repos distintos, y cualquiera de los dos publicaría el archivo.
+function raicesQueContienen(dir, fs) {
+    const escrita = path.resolve(dir);
+    const rutas = new Set([escrita, rutaReal(escrita, fs)]);
+    const raices = new Map();
+    for (const ruta of rutas) {
+        let actual = ruta;
+        for (;;) {
+            if (fs.existe(path.join(actual, ".git"))) {
+                raices.set(actual, [...(raices.get(actual) ?? []), ruta]);
+                break;
+            }
+            const padre = path.dirname(actual);
+            if (padre === actual)
+                break;
+            actual = padre;
+        }
+    }
+    return raices;
+}
+const sinProteger = (codigo, detalle) => ({ protegido: false, impedimento: { codigo, detalle } });
+function queHacer(raiz, archivo) {
+    const rel = path.relative(raiz, archivo);
+    return `Take it out of the repo with \`git -C ${raiz} rm --cached -- ${rel}\` or have git ignore it; I won't touch your repo myself.`;
+}
+async function mirar(d, conGitignore) {
+    let raices;
+    try {
+        raices = raicesQueContienen(d.dir, d.fs);
+    }
+    catch {
+        return sinProteger("ruta_irresoluble", `I can't tell where ${d.dir} really is (a broken symlink?).`);
+    }
+    for (const [raiz, carpetas] of raices) {
+        for (const carpeta of carpetas) {
+            const hayGitignore = conGitignore(carpeta);
+            for (const nombre of d.archivos) {
+                const archivo = path.join(carpeta, nombre);
+                if (hayGitignore) {
+                    // 0 = ignorado y no seguido; 1 = no lo es (o está seguido o agregado). Cualquier otra cosa (git ausente,
+                    // `fatal`, tiempo) es «no sé», y no saber no es «protegido».
+                    const r = await d.git(["check-ignore", "-q", "--", archivo], raiz);
+                    if (r.codigo === 1) {
+                        return sinProteger("git_no_lo_ignora", `Git doesn't ignore ${archivo} in the repo ${raiz} (it is tracked or staged, or a .gitignore doesn't cover it). ${queHacer(raiz, archivo)}`);
+                    }
+                    if (r.codigo !== 0)
+                        return sinProteger("git_no_contesta", `I couldn't ask git whether it ignores ${archivo} in the repo ${raiz}.`);
+                }
+                else {
+                    // Sin `.gitignore` todavía: se crearía uno con `*`, que ignora todo lo que no esté seguido ni en el índice.
+                    const r = await d.git(["ls-files", "--", archivo], raiz);
+                    if (r.codigo !== 0)
+                        return sinProteger("git_no_contesta", `I couldn't ask git whether it tracks ${archivo} in the repo ${raiz}.`);
+                    if (r.stdout.trim() !== "") {
+                        return sinProteger("git_lo_sigue", `Git tracks ${archivo} in the repo ${raiz}. ${queHacer(raiz, archivo)}`);
+                    }
+                }
+            }
+        }
+    }
+    return { protegido: true };
+}
+/** Sin escribir nada: lo mismo que `asegurarProteccionDeGit` va a comprobar, para avisar antes. */
+export function mirarProteccionDeGit(d) {
+    return mirar(d, (carpeta) => d.fs.existe(path.join(carpeta, ".gitignore")));
+}
+/**
+ * Antes de CADA escritura o borrado de un registro. Si la carpeta cae en un repo y no tiene `.gitignore`, crea
+ * uno con `*` (en exclusiva: si aparece otro al mismo tiempo no se pisa; y nunca se edita uno que ya estaba),
+ * y después le pregunta a git por cada archivo y su `.tmp`. Falla cerrada.
+ */
+export async function asegurarProteccionDeGit(d) {
+    let raices;
+    try {
+        raices = raicesQueContienen(d.dir, d.fs);
+    }
+    catch {
+        return sinProteger("ruta_irresoluble", `I can't tell where ${d.dir} really is (a broken symlink?).`);
+    }
+    if (raices.size === 0)
+        return { protegido: true };
+    const gitignore = path.join(path.resolve(d.dir), ".gitignore");
+    if (!d.fs.existe(gitignore)) {
+        try {
+            d.fs.crearDir(path.resolve(d.dir), 0o700);
+            d.fs.escribirExclusivo(gitignore, CONTENIDO_DEL_GITIGNORE, 0o600);
+        }
+        catch (e) {
+            // `EEXIST`: otro proceso lo creó entre medio; sirve igual, y no se toca.
+            if (e.code !== "EEXIST") {
+                return sinProteger("no_se_pudo_crear_gitignore", `I couldn't create ${gitignore} to keep this folder out of git.`);
+            }
+        }
+    }
+    return mirar(d, () => true);
+}

package/dist/idempotencia.js

@@ -3,9 +3,8 @@
 // reintento tiene que mandar la MISMA clave para que el motor devuelva lo que ya hizo en vez de
 // hacerlo dos veces. Por eso se escribe ANTES de devolverla, y sólo se olvida cuando el motor ya dio
 // un desenlace que no hace falta repetir.
-import path from "node:path";
 import { FalloDeLaTerminal, SALIDA } from "./contrato.js";
-import { dentroDeUnWorkingTree } from "./guardado/repo.js";
+import { SinProteccionDeGit } from "./guardado/protegido.js";
 export function crearRegistroDeIdempotencia(d) {
     // Por origen, como la clave (un motor local y producción no comparten claves), y el alcance en
     // minúsculas: `D/r` y `d/r` son el mismo repo para GitHub y para el motor.
@@ -15,7 +14,7 @@ export function crearRegistroDeIdempotencia(d) {
     // repo) y el motor lo reusa. Una clave de consulta no tiene clave natural: sin la de idempotencia
     // guardada, el reintento tras una respuesta perdida crea OTRA fila. Mejor no mandar nada y decir qué
     // arreglar. Por eso, en estricto, cada «aviso y sigo» de abajo lanza.
-    const noGuardada = () => new FalloDeLaTerminal(SALIDA.inesperado, "idempotencia_no_guardada", `I couldn't save the retry key in ${d.rutaDelArchivo}; without it, a retry would create another key. Check that file (it can't be inside a repo) and try again.`);
+    const noGuardada = (causa) => new FalloDeLaTerminal(SALIDA.inesperado, "idempotencia_no_guardada", `I couldn't save the retry key in ${d.rutaDelArchivo}; without it, a retry would create another key. Check that file and try again.${causa instanceof SinProteccionDeGit ? ` ${causa.message}` : ""}`);
     return {
         async claveDe(operacion, alcance, opciones = {}) {
             const c = cuenta(operacion, alcance);
@@ -34,33 +33,20 @@ export function crearRegistroDeIdempotencia(d) {
             }
             const nueva = d.generar();
             // Perder la clave no duplica nada: el motor reusa el proyecto por su repo. Por eso un destino
-            // dentro de un repo (misma regla que las credenciales: un `git add -A` la publicaría) o un disco
+            // dentro de un repo que git no garantiza que ignore (el almacén protegido, fricción 2c) o un disco
             // que falla avisan y siguen, en vez de frenar el comando.
-            // `realpath` lanza con un tramo que es un enlace roto (`~/.config/supcoflow` apuntando a un repo
-            // de dotfiles que ya no está): no saber dónde cae el destino es otro «no se puede guardar».
-            let raiz;
-            try {
-                raiz = dentroDeUnWorkingTree(path.dirname(d.rutaDelArchivo), d.fs);
-            }
-            catch {
-                if (opciones.estricta)
-                    throw noGuardada();
-                d.avisar(`I couldn't resolve the path of ${d.rutaDelArchivo}: I'm going on with an idempotency key that isn't saved.`);
-                return nueva;
-            }
-            if (raiz !== null) {
-                if (opciones.estricta)
-                    throw noGuardada();
-                d.avisar(`I'm not saving the idempotency key inside a git repo (${raiz}): a retry will send a different one.`);
-                return nueva;
-            }
             try {
                 await d.almacen.escribir(c, { valor: nueva, escritoEn: d.ahora() });
             }
-            catch {
+            catch (e) {
                 if (opciones.estricta)
-                    throw noGuardada();
-                d.avisar(`I couldn't save the idempotency key in ${d.rutaDelArchivo}: a retry will send a different one.`);
+                    throw noGuardada(e);
+                if (e instanceof SinProteccionDeGit) {
+                    d.avisar(`I'm not saving the idempotency key in ${d.rutaDelArchivo}: a retry will send a different one. ${e.message}`);
+                }
+                else {
+                    d.avisar(`I couldn't save the idempotency key in ${d.rutaDelArchivo}: a retry will send a different one.`);
+                }
             }
             return nueva;
         },
@@ -80,8 +66,10 @@ export function crearRegistroDeIdempotencia(d) {
             try {
                 await d.almacen.borrar(cuenta(operacion, alcance));
             }
-            catch {
-                d.avisar(`I couldn't delete the idempotency key from ${d.rutaDelArchivo}.`);
+            catch (e) {
+                d.avisar(e instanceof SinProteccionDeGit
+                    ? `I didn't delete the idempotency key from ${d.rutaDelArchivo}, so as not to rewrite a file git doesn't ignore. ${e.message}`
+                    : `I couldn't delete the idempotency key from ${d.rutaDelArchivo}.`);
             }
         },
     };

package/dist/pruebas-guardadas.js

@@ -14,9 +14,8 @@
 //
 // Estricto en todo, como `claves crear` en el registro de idempotencia: una prueba no tiene clave natural
 // del lado de la terminal, así que mandar sin el intento guardado arriesga una segunda prueba (que gasta).
-import path from "node:path";
 import { FalloDeLaTerminal, SALIDA } from "./contrato.js";
-import { dentroDeUnWorkingTree } from "./guardado/repo.js";
+import { SinProteccionDeGit } from "./guardado/protegido.js";
 function esIntento(v) {
     if (typeof v !== "object" || v === null)
         return false;
@@ -28,7 +27,7 @@ export function crearRegistroDePruebas(d) {
     // Por origen, como la clave y el registro de idempotencia: un motor local (o el proxy de P4) y
     // producción no comparten intentos. Cambiar de origen entre dos comandos es otra clave.
     const cuenta = (proyectoId) => `${d.origen}#prueba#${proyectoId}`;
-    const noGuardada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `I couldn't ${que} ${d.rutaDelArchivo}; without that, a retry could ask for another test (and spend twice). Check that file (it can't be inside a repo) and try again.`);
+    const noGuardada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `I couldn't ${que} ${d.rutaDelArchivo}; without that, a retry could ask for another test (and spend twice). Check that file and try again.`);
     async function leer(proyectoId) {
         let crudo;
         try {
@@ -58,18 +57,6 @@ export function crearRegistroDePruebas(d) {
         };
     }
     async function escribir(proyectoId, g) {
-        // Misma regla que las credenciales: un destino dentro de un repo se publicaría con un `git add -A`.
-        // No saber dónde cae (un enlace roto) es otro «no se puede guardar».
-        let raiz;
-        try {
-            raiz = dentroDeUnWorkingTree(path.dirname(d.rutaDelArchivo), d.fs);
-        }
-        catch {
-            throw noGuardada("resolve the path of");
-        }
-        if (raiz !== null) {
-            throw new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `I'm not saving the test request inside a git repo (${raiz}); without saving it I won't send it. Point XDG_CONFIG_HOME outside a repo.`);
-        }
         const valor = JSON.stringify({
             intento: g.intento === null
                 ? null
@@ -79,12 +66,37 @@ export function crearRegistroDePruebas(d) {
         try {
             await d.almacen.escribir(cuenta(proyectoId), { valor, escritoEn: d.ahora() });
         }
-        catch {
+        catch (e) {
+            // El almacén protegido no escribe dentro de un repo si git no garantiza que lo deja afuera (fricción 2c):
+            // el mensaje dice qué archivo, qué repo y qué hacer.
+            if (e instanceof SinProteccionDeGit) {
+                throw new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `I'm not saving the test request in ${d.rutaDelArchivo}; without saving it I won't send it. ${e.message}`);
+            }
             throw noGuardada("save to");
         }
     }
+    async function revisar(proyectoId) {
+        const impedimentos = [];
+        try {
+            impedimentos.push(...(await d.revisarElLugar?.() ?? []));
+        }
+        catch {
+            impedimentos.push({ codigo: "no_se_pudo_revisar", detalle: `I couldn't check whether ${d.rutaDelArchivo} can be saved.` });
+        }
+        let intentoPendiente = null;
+        try {
+            const { intento } = await leer(proyectoId);
+            if (intento !== null)
+                intentoPendiente = { techoUsd: intento.techoUsd, politica: intento.politicaEsperada };
+        }
+        catch {
+            impedimentos.push({ codigo: "archivo_ilegible", detalle: `I can't read or understand ${d.rutaDelArchivo}.` });
+        }
+        return { maquina: { ok: impedimentos.length === 0, impedimentos }, intentoPendiente };
+    }
     return {
         leer,
+        revisar,
         async abrir(proyectoId, intento) {
             const antes = await leer(proyectoId);
             await escribir(proyectoId, { intento, ultima: antes.ultima });

package/dist/repo-local.js

@@ -30,6 +30,52 @@ export function repoDelOrigin(url) {
     }
     return null;
 }
+// El `origin` con forma de alias de SSH (`git@github-gf0:dueño/repo`, `ssh://git@github-gf0/dueño/repo`): el host no
+// es github.com, pero el dueño/repo sí tiene la forma de uno de GitHub. NO se resuelve (no se corre `ssh` ni se lee su
+// configuración: `Match exec` ejecutaría programas de la persona): sólo se le dice qué asociar a mano, una vez.
+const FORMAS_DE_ALIAS = [
+    /^[A-Za-z0-9._-]+@([A-Za-z0-9._-]+):([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/,
+    /^ssh:\/\/[A-Za-z0-9._-]+@([A-Za-z0-9._-]+)(?::\d+)?\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/,
+];
+export function aliasDelOrigin(url) {
+    const limpia = url.trim();
+    for (const forma of FORMAS_DE_ALIAS) {
+        const m = forma.exec(limpia);
+        if (!m)
+            continue;
+        const repo = `${m[2]}/${m[3]}`;
+        if (m[1].toLowerCase() === "github.com" || !esRepoValido(repo))
+            return null;
+        return { host: m[1], repo };
+    }
+    return null;
+}
+// Lo que se muestra de un `origin`: nunca el usuario:clave@ de una URL (podría ser un token). Las credenciales se quitan de la
+// URL ENTERA y recién después se limita el tamaño (recortar antes dejaría pasar un `@` lejano con su clave a medias). Lo que no se
+// puede interpretar con seguridad no se muestra crudo: sale un marcador neutro.
+const TOPE_DEL_ORIGEN_MOSTRADO = 200;
+export function origenParaMostrar(url) {
+    const limpia = url.trim();
+    const url_ = /^([A-Za-z][A-Za-z0-9+.-]*:\/\/)([^/\s]*)(.*)$/s.exec(limpia);
+    let mostrable = null;
+    if (url_) {
+        // La autoridad llega hasta la primera `/`; el usuario:clave es todo lo anterior al ÚLTIMO `@` de la autoridad.
+        const arroba = url_[2].lastIndexOf("@");
+        const usuario = arroba === -1 ? "" : url_[2].slice(0, arroba).split(":")[0];
+        const host = arroba === -1 ? url_[2] : url_[2].slice(arroba + 1);
+        mostrable = `${url_[1]}${usuario === "git" ? "git@" : ""}${host}${url_[3]}`;
+    }
+    else if (/^[A-Za-z0-9._-]+@[A-Za-z0-9._-]+:/.test(limpia)) {
+        mostrable = limpia; // `git@host:o/r`: el usuario de un scp no lleva clave
+    }
+    if (mostrable === null || /\s/.test(mostrable))
+        return "(an address I don't recognize)";
+    return mostrable.length > TOPE_DEL_ORIGEN_MOSTRADO ? mostrable.slice(0, TOPE_DEL_ORIGEN_MOSTRADO) + "…" : mostrable;
+}
+// El remoto de asociación explícita: la persona le dice una sola vez a qué repo de GitHub corresponde este clon cuando su
+// `origin` no es una dirección de GitHub (alias de SSH, otro servidor). Con las mismas formas estrictas de `origin`;
+// nunca se usa para traer nada.
+export const REMOTO_DE_ASOCIACION = "supcoflow";
 export async function leerRepoLocal(git, cwd) {
     const top = await git(["rev-parse", "--show-toplevel"], cwd);
     const raiz = top.codigo === 0 ? top.stdout.trim() : "";
@@ -37,32 +83,68 @@ export async function leerRepoLocal(git, cwd) {
         return { repo: null, raiz: null, motivo: "sin_git" };
     const origin = await git(["remote", "get-url", "origin"], cwd);
     const url = origin.codigo === 0 ? origin.stdout.trim() : "";
+    const repoDelOrigen = url ? repoDelOrigin(url) : null;
+    // Si `origin` es de GitHub, gana `origin`, como siempre.
+    if (repoDelOrigen)
+        return { repo: repoDelOrigen, raiz };
+    const asociado = await git(["remote", "get-url", REMOTO_DE_ASOCIACION], cwd);
+    const urlAsociada = asociado.codigo === 0 ? asociado.stdout.trim() : "";
+    const repoAsociado = urlAsociada ? repoDelOrigin(urlAsociada) : null;
+    if (repoAsociado)
+        return { repo: repoAsociado, raiz };
+    const alias = url ? aliasDelOrigin(url) : null;
+    const comun = { repo: null, raiz, ...(url ? { origen: origenParaMostrar(url) } : {}), ...(urlAsociada ? { hayRemotoSupcoflow: true } : {}) };
     if (!url)
-        return { repo: null, raiz, motivo: "sin_origin" };
-    const repo = repoDelOrigin(url);
-    if (!repo)
-        return { repo: null, raiz, motivo: "origin_no_es_github" };
-    return { repo, raiz };
+        return { ...comun, motivo: "sin_origin" };
+    if (alias)
+        return { ...comun, motivo: "origin_alias_ssh", alias };
+    return { ...comun, motivo: "origin_no_es_github" };
+}
+// El comando exacto que asocia este clon con un repo de GitHub. `add` si todavía no hay remoto `supcoflow`; `set-url` si
+// hay uno que no es una dirección de GitHub.
+export function comandoDeAsociacion(repo, hayRemoto) {
+    return `git remote ${hayRemoto ? "set-url" : "add"} ${REMOTO_DE_ASOCIACION} https://github.com/${repo}.git`;
 }
 const MOTIVOS = {
     sin_git: "this folder isn't a git repo",
     sin_origin: "the repo has no remote called \"origin\"",
     origin_no_es_github: "the \"origin\" remote isn't a GitHub repo",
+    origin_alias_ssh: "the \"origin\" remote isn't a GitHub repo",
 };
+// La frase que dice la verdad sobre un clon que no se puede atar a `repo` (owner/repo de GitHub) y cómo atarlo.
+export function frasePorQueNoAtaClon(local, repo) {
+    if (local.motivo === "sin_git")
+        return "This folder isn't a git clone.";
+    const sugerido = repo ?? local.alias?.repo ?? null;
+    const como = sugerido === null ? ""
+        : ` If this is ${sugerido} on GitHub, tell me once: \`${comandoDeAsociacion(sugerido, local.hayRemotoSupcoflow === true)}\` (it's never fetched).`;
+    if (local.motivo === "origin_alias_ssh" && repo === null && local.alias) {
+        return `Your origin uses the SSH alias \`${local.alias.host}\`, which I don't resolve.${como}`;
+    }
+    const clon = local.origen ? `This clone is \`${local.origen}\`, which I can't tie to github.com${repo ? `/${repo}` : ""}.` : "This clone has no \"origin\" remote I can tie to GitHub.";
+    return `${clon}${como}`;
+}
 export async function repoPedido(d) {
     const local = await leerRepoLocal(d.git, d.cwd);
     if (d.flagRepo !== null) {
         if (!esRepoValido(d.flagRepo)) {
             throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "repo_invalido", "The value of --repo must be owner/repo (for example owner/my-app), without the URL.");
         }
-        // La raíz sólo se da si el origin local es ESE repo: con otro, lo que se escriba en esta
+        // La raíz sólo se da si el repo local reconocido es ESE repo: con otro, lo que se escriba en esta
         // carpeta (el archivo del proyecto) no le pertenece.
         const mismo = local.repo !== null && local.repo.toLowerCase() === d.flagRepo.toLowerCase();
-        return { repo: d.flagRepo, raiz: mismo ? local.raiz : null };
+        if (mismo)
+            return { repo: d.flagRepo, raiz: local.raiz };
+        // El mensaje de «no es tu clon» dice por qué, y deja el comando exacto para atarlo si la persona SABE que lo es.
+        const sinClon = local.repo !== null
+            ? `This clone is github.com/${local.repo}, not ${d.flagRepo}.`
+            : frasePorQueNoAtaClon(local, d.flagRepo);
+        return { repo: d.flagRepo, raiz: null, sinClon };
     }
     if (local.repo === null) {
         const porque = local.motivo ? MOTIVOS[local.motivo] : "the folder couldn't be read";
-        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "sin_repo", `I couldn't find a GitHub repo here (${porque}). Pass --repo owner/repo.`);
+        const detalle = local.motivo === "origin_alias_ssh" ? ` ${frasePorQueNoAtaClon(local, null)}` : "";
+        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "sin_repo", `I couldn't find a GitHub repo here (${porque}).${detalle} Pass --repo owner/repo.`);
     }
     return { repo: local.repo, raiz: local.raiz };
 }

package/package.json

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