supcoflow 0.0.0-stage → 0.1.0

package/dist/guardado/index.js

@@ -0,0 +1,258 @@
+// Dónde vive la clave de la terminal (§5.2): el llavero del sistema; si no hay, un archivo 0600
+// avisando; `SUPCOFLOW_TOKEN` por encima de los dos; y nunca un destino dentro de un repo de git.
+import path from "node:path";
+import { FalloDeLaTerminal, SALIDA } from "../contrato.js";
+import { LlaveroAusente, TECHO_DEL_LLAVERO_MS } from "./llavero.js";
+import { dentroDeUnWorkingTree } from "./repo.js";
+// La cuenta ES el origen de la API que emitió lo guardado (Review Focus 3): una clave acuñada por
+// un motor en `localhost` queda en otra cuenta que la de producción, y la terminal apuntada a
+// producción simplemente no la encuentra (sale 2) en vez de mandarla a un servidor que no la emitió.
+// Y la clave y el login en curso son cuentas DISTINTAS (Review Focus 7): empezar o abandonar un login
+// escribe sólo `#pendiente` y nunca puede pisar la clave vigente.
+const cuentaDeClave = (origen) => origen;
+const cuentaDePendiente = (origen) => `${origen}#pendiente`;
+const cuentaPorRevocar = (origen) => `${origen}#por_revocar`;
+function esPendiente(v) {
+    if (typeof v !== "object" || v === null)
+        return false;
+    const p = v;
+    return typeof p.deviceCode === "string" && typeof p.userCode === "string" && typeof p.verificationUriComplete === "string"
+        && typeof p.venceEn === "number" && typeof p.intervaloS === "number"
+        && (p.ultimoSondeoEn === null || typeof p.ultimoSondeoEn === "number");
+}
+function listaDeClaves(s) {
+    try {
+        const v = JSON.parse(s);
+        return Array.isArray(v) && v.every((x) => typeof x === "string") ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function crearGuardado(d) {
+    const almacenes = () => (d.llavero ? [d.llavero, d.archivo] : [d.archivo]);
+    // El techo es de la operación ENTERA (Review Focus 10): un vencimiento absoluto calculado al
+    // entrar, que leer, escribir y limpiar se reparten. Si cada llamada tuviera su propio techo, una
+    // operación «de 5 s» podían ser 10 y la reserva del tramo del login no cerraba.
+    function plazo(techoMs = TECHO_DEL_LLAVERO_MS) {
+        const fin = d.ahora() + techoMs;
+        return () => fin - d.ahora();
+    }
+    // El plazo sólo corta al llavero: el archivo es local y no se cuelga, y es el último recurso para
+    // guardar una clave que no tiene otra copia. Un plazo agotado no espera al llavero: es una falla.
+    async function intentar(a, queda, op) {
+        if (a === null)
+            return { estado: "ausente" };
+        const techo = queda();
+        if (a.nombre === "llavero" && techo <= 0)
+            return { estado: "fallo" };
+        try {
+            return { estado: "ok", valor: await op(a, Math.max(techo, 1)) };
+        }
+        catch (e) {
+            return e instanceof LlaveroAusente ? { estado: "ausente" } : { estado: "fallo" };
+        }
+    }
+    // Gana el `escritoEn` más alto, no el almacén (Review Focus 8): si el llavero falla una vez, la
+    // clave nueva cae al archivo; cuando el llavero vuelve, todavía tiene la VIEJA. Preferir el
+    // llavero por ser el llavero devolvería una clave ya reemplazada (y quizás revocada).
+    async function leerCuentaCompleta(cuenta, queda) {
+        let mejor = null;
+        let completa = true;
+        for (const a of almacenes()) {
+            const i = await intentar(a, queda, (x, t) => x.leer(cuenta, t));
+            if (i.estado === "fallo")
+                completa = false;
+            if (i.estado === "ok" && i.valor !== null && (mejor === null || i.valor.escritoEn > mejor.r.escritoEn)) {
+                mejor = { r: i.valor, fuente: a.nombre };
+            }
+        }
+        return { mejor, completa };
+    }
+    const leerCuenta = async (cuenta, queda) => (await leerCuentaCompleta(cuenta, queda)).mejor;
+    const errorDeBorrado = (fallidos) => {
+        const donde = fallidos.map((n) => (n === "llavero" ? "del llavero del sistema" : `de ${d.rutaDelArchivo}`)).join(" ni ");
+        return new FalloDeLaTerminal(SALIDA.inesperado, "no_se_pudo_borrar", `No pude borrar la clave guardada ${donde}.`);
+    };
+    // El chequeo del repo va ANTES de escribir (Review Focus 1): una vez escrita, la clave ya está a
+    // un `git add -A` de publicarse, y borrarla después no deshace un commit. Mira la ruta REAL además
+    // de la escrita (Review Focus 6): con `~/.config` enlazado a un repo de dotfiles, la escrita no
+    // cae en ningún repo y la real sí.
+    async function escribirEnArchivo(cuenta, r, que) {
+        const raiz = dentroDeUnWorkingTree(path.dirname(d.rutaDelArchivo), d.fs);
+        if (raiz !== null) {
+            throw new FalloDeLaTerminal(SALIDA.inesperado, "destino_dentro_de_un_repo", `No guardo ${que} dentro de un repo de git (${raiz}). Usá el llavero del sistema o exportá SUPCOFLOW_TOKEN.`);
+        }
+        await d.archivo.escribir(cuenta, r);
+        d.avisar(`No hay llavero del sistema: guardé ${que} en ${d.rutaDelArchivo} con permisos 0600.`);
+    }
+    async function escribirCuenta(cuenta, valor, que, techoMs) {
+        const queda = plazo(techoMs);
+        const r = { valor, escritoEn: d.ahora() };
+        const ll = await intentar(d.llavero, queda, (x, t) => x.escribir(cuenta, r, t));
+        if (ll.estado === "ok") {
+            // Best-effort: si queda algo viejo en el archivo, la regla del `escritoEn` lo deja atrás.
+            await intentar(d.archivo, queda, (x, t) => x.borrar(cuenta, t));
+            return "llavero";
+        }
+        await escribirEnArchivo(cuenta, r, que);
+        // No se limpia el llavero: si acaba de fallar (o vencer su techo) no se lo vuelve a esperar, y
+        // si está ausente no tiene nada. Lo viejo que quede ahí pierde por `escritoEn`.
+        return "archivo";
+    }
+    // Devuelve de qué almacenes PRESENTES no se pudo borrar; un llavero ausente no guarda nada.
+    async function borrarCuenta(cuenta, techoMs) {
+        const queda = plazo(techoMs);
+        const fallidos = [];
+        for (const a of almacenes()) {
+            if ((await intentar(a, queda, (x, t) => x.borrar(cuenta, t))).estado === "fallo")
+                fallidos.push(a.nombre);
+        }
+        return fallidos;
+    }
+    async function leerLista(a, cuenta, queda) {
+        const i = await intentar(a, queda, (x, t) => x.leer(cuenta, t));
+        if (i.estado !== "ok")
+            return i;
+        if (i.valor === null)
+            return { estado: "ok", valor: [] };
+        const lista = listaDeClaves(i.valor.valor);
+        return lista === null ? { estado: "fallo" } : { estado: "ok", valor: lista };
+    }
+    const guardado = {
+        async leerClave(origen) {
+            // Quien exporta la variable decide: se usa sin mirar el origen.
+            const env = d.env.SUPCOFLOW_TOKEN;
+            if (env)
+                return { clave: env, fuente: "env" };
+            return guardado.leerClaveGuardada(origen);
+        },
+        async leerClaveGuardada(origen) {
+            const l = await leerCuenta(cuentaDeClave(origen), plazo());
+            return l === null ? null : { clave: l.r.valor, fuente: l.fuente };
+        },
+        async leerClaveCompleta(origen) {
+            const env = d.env.SUPCOFLOW_TOKEN;
+            if (env)
+                return { valor: { clave: env, fuente: "env" }, completa: true };
+            return guardado.leerClaveGuardadaCompleta(origen);
+        },
+        // Las de arriba tragan un almacén que no contesta como «no hay»; ésta lo dice, porque quien va a
+        // PISAR o BORRAR la clave necesita saber si leyó todo (Review Focus 12 y 14): con A en un llavero
+        // bloqueado, «no hay» deja que un login la reemplace sin revocarla.
+        async leerClaveGuardadaCompleta(origen, techoMs) {
+            const { mejor, completa } = await leerCuentaCompleta(cuentaDeClave(origen), plazo(techoMs));
+            return { valor: mejor === null ? null : { clave: mejor.r.valor, fuente: mejor.fuente }, completa };
+        },
+        async guardarClave(origen, clave, techoMs) {
+            return { donde: await escribirCuenta(cuentaDeClave(origen), clave, "la clave", techoMs) };
+        },
+        async borrarClave(origen) {
+            // Un borrado a medias de una clave no se informa como hecho: la que quedó sigue sirviendo.
+            const fallidos = await borrarCuenta(cuentaDeClave(origen));
+            if (fallidos.length > 0)
+                throw errorDeBorrado(fallidos);
+        },
+        // Para cuando la lectura fue incompleta: se borra sólo la copia que se leyó y se revocó. La del
+        // almacén que no contestó puede ser OTRA clave, viva; borrarla a ciegas la olvidaría sin revocar.
+        async borrarClaveDe(origen, almacen) {
+            const a = almacen === "llavero" ? d.llavero : d.archivo;
+            if ((await intentar(a, plazo(), (x, t) => x.borrar(cuentaDeClave(origen), t))).estado === "fallo") {
+                throw errorDeBorrado([almacen]);
+            }
+        },
+        async leerPendiente(origen) {
+            const l = await leerCuenta(cuentaDePendiente(origen), plazo());
+            if (l === null)
+                return null;
+            try {
+                const v = JSON.parse(l.r.valor);
+                return esPendiente(v) ? v : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        async guardarPendiente(origen, p, techoMs) {
+            await escribirCuenta(cuentaDePendiente(origen), JSON.stringify(p), "el inicio de sesión en curso", techoMs);
+        },
+        async borrarPendiente(origen, techoMs) {
+            // Nunca lanza: un pendiente viejo es inofensivo (su device_code ya se consumió o vence en
+            // 10 min; el próximo `--start` lo pisa y un `--wait` sobre él recibe `invalid_grant` y lo limpia).
+            try {
+                return (await borrarCuenta(cuentaDePendiente(origen), techoMs)).length === 0;
+            }
+            catch {
+                return false;
+            }
+        },
+        // La lista «por revocar» NO sigue la regla del `escritoEn` (Review Focus 15): es la UNIÓN de los
+        // dos almacenes. Con «gana la más reciente», A anotada en el llavero y B en el archivo mientras
+        // el llavero no respondía daría [B], y A quedaría vigente para siempre sin que nadie la revoque.
+        async leerPorRevocar(origen) {
+            const queda = plazo();
+            const claves = new Set();
+            let completa = true;
+            for (const a of almacenes()) {
+                const l = await leerLista(a, cuentaPorRevocar(origen), queda);
+                if (l.estado === "ok")
+                    l.valor.forEach((c) => claves.add(c));
+                else if (l.estado === "fallo")
+                    completa = false;
+            }
+            return { claves: [...claves], completa };
+        },
+        // Se escribe SÓLO en un almacén, sobre la lista que se acaba de leer de ESE almacén: nunca se
+        // reemplaza la del otro, que puede tener claves que ahora no se pueden leer. Y un almacén que no
+        // se pudo leer no se pisa a ciegas.
+        async anotarPorRevocar(origen, clave, techoMs) {
+            const queda = plazo(techoMs);
+            const cuenta = cuentaPorRevocar(origen);
+            for (const a of almacenes()) {
+                const l = await leerLista(a, cuenta, queda);
+                if (l.estado !== "ok")
+                    continue;
+                if (l.valor.includes(clave))
+                    return;
+                const r = { valor: JSON.stringify([...l.valor, clave]), escritoEn: d.ahora() };
+                if (a.nombre === "archivo") {
+                    try {
+                        await escribirEnArchivo(cuenta, r, "las claves por revocar");
+                        return;
+                    }
+                    catch (e) {
+                        if (e instanceof FalloDeLaTerminal)
+                            throw e;
+                        break;
+                    }
+                }
+                if ((await intentar(a, queda, (x, t) => x.escribir(cuenta, r, t))).estado === "ok")
+                    return;
+            }
+            throw new FalloDeLaTerminal(SALIDA.inesperado, "no_se_pudo_anotar", "No pude anotar la clave anterior como «por revocar» ni en el llavero ni en el archivo.");
+        },
+        // Quitar sólo achica la lista, así que no pasa por el control del repo: no agrega ningún secreto.
+        // Un almacén presente que falla deja `completo = false`: la clave puede seguir anotada ahí, el
+        // próximo reintento la vuelve a revocar, el motor contesta `ya_no_valia` y se quita entonces.
+        async quitarPorRevocar(origen, clave) {
+            const queda = plazo();
+            const cuenta = cuentaPorRevocar(origen);
+            let completo = true;
+            for (const a of almacenes()) {
+                const l = await leerLista(a, cuenta, queda);
+                if (l.estado === "fallo")
+                    completo = false;
+                if (l.estado !== "ok" || !l.valor.includes(clave))
+                    continue;
+                const resto = l.valor.filter((c) => c !== clave);
+                const op = resto.length === 0
+                    ? (x, t) => x.borrar(cuenta, t)
+                    : (x, t) => x.escribir(cuenta, { valor: JSON.stringify(resto), escritoEn: d.ahora() }, t);
+                if ((await intentar(a, queda, op)).estado !== "ok")
+                    completo = false;
+            }
+            return { completo };
+        },
+    };
+    return guardado;
+}

package/dist/guardado/llavero.js

@@ -0,0 +1,110 @@
+// El llavero del sistema: Keychain en macOS (`security`), Secret Service en Linux (`secret-tool`).
+// Sin dependencias: se habla con el binario del sistema, inyectado como `Correr` para los tests.
+import { existsSync } from "node:fs";
+import { esRegistro } from "./archivo.js";
+// Un anillo bloqueado que pide desbloqueo, o un Linux sin D-Bus, deja al binario esperando para
+// siempre: cada llamada tiene techo y vencerlo es una falla, nunca un comando colgado (Review Focus 2).
+export const TECHO_DEL_LLAVERO_MS = 5_000;
+// AUSENTE no es FALLIDO (Review Focus 12): un binario que no existe no guarda nada, así que no hay
+// nada que borrar en él; uno que está y falla puede tener datos adentro.
+export class LlaveroAusente extends Error {
+    constructor(bin) {
+        super(`No hay llavero del sistema (falta ${bin}).`);
+        this.name = "LlaveroAusente";
+    }
+}
+const SERVICIO = "supcoflow";
+// El base64url no tiene espacios: el modo `-i` de `security` parte la línea por espacios, y una
+// clave en JSON los tiene (o podría tenerlos). Con base64url el secreto es un único argumento.
+const codificar = (r) => Buffer.from(JSON.stringify(r)).toString("base64url");
+function decodificar(s) {
+    let v;
+    try {
+        v = JSON.parse(Buffer.from(s.trim(), "base64url").toString("utf8"));
+    }
+    catch {
+        v = undefined;
+    }
+    if (!esRegistro(v))
+        throw new Error("El llavero devolvió algo que no entiendo.");
+    return { valor: v.valor, escritoEn: v.escritoEn };
+}
+// La cuenta viaja en una línea de `security -i`, que también parte por espacios y entiende comillas:
+// una cuenta con algo de eso se leería distinta de lo que se escribió. Un origen nunca lo tiene.
+function cuentaSegura(cuenta) {
+    if (!/^[A-Za-z0-9:/.\[\]#_-]+$/.test(cuenta))
+        throw new Error("Cuenta del llavero inválida.");
+    return cuenta;
+}
+// La ruta ABSOLUTA: un `security` del PATH podría ser otro programa (un `node_modules/.bin`, un
+// directorio del repo en el PATH) y recibiría la clave. El secreto va con `-i` por stdin porque en
+// `argv` lo ve cualquiera con `ps` mientras el comando corre; leer y borrar no llevan secreto.
+const MACOS = {
+    bins: ["/usr/bin/security"],
+    escribir: (cuenta, secreto) => ({
+        args: ["-i"],
+        stdin: `add-generic-password -U -s ${SERVICIO} -a ${cuenta} -w ${secreto}\n`,
+    }),
+    leer: (cuenta) => ["find-generic-password", "-s", SERVICIO, "-a", cuenta, "-w"],
+    borrar: (cuenta) => ["delete-generic-password", "-s", SERVICIO, "-a", cuenta],
+    // 44 = errSecItemNotFound.
+    noEncontrado: (codigo) => codigo === 44,
+};
+// `secret-tool store` lee el secreto de stdin cuando no hay terminal: nunca en `argv`.
+//
+// Rutas ABSOLUTAS y no `secret-tool` por el PATH, por la misma razón que `security` arriba: un
+// `node_modules/.bin/secret-tool` plantado recibiría cada clave por stdin.
+const LINUX = {
+    bins: ["/usr/bin/secret-tool", "/bin/secret-tool", "/usr/local/bin/secret-tool"],
+    escribir: (cuenta, secreto) => ({
+        args: ["store", "--label=Supcoflow", "servicio", SERVICIO, "cuenta", cuenta],
+        stdin: secreto,
+    }),
+    leer: (cuenta) => ["lookup", "servicio", SERVICIO, "cuenta", cuenta],
+    borrar: (cuenta) => ["clear", "servicio", SERVICIO, "cuenta", cuenta],
+    // `secret-tool` sale 1 sin salida también sin D-Bus o con el anillo bloqueado: lo único que
+    // distingue «no está» de «no pude mirar» es que, cuando no está, no dice nada por stderr.
+    noEncontrado: (codigo, stdout, stderr) => codigo === 1 && stdout.trim() === "" && stderr.trim() === "",
+};
+export function almacenDeLlavero(plataforma, correr, existe = existsSync) {
+    const c = plataforma === "darwin" ? MACOS : plataforma === "linux" ? LINUX : null;
+    if (c === null)
+        return null;
+    // Ni el stdout, ni el stdin, ni el stderr van al mensaje: pueden llevar el secreto.
+    async function ejecutar(args, stdin, techoMs) {
+        const bin = c.bins.find((b) => existe(b));
+        if (bin === undefined)
+            throw new LlaveroAusente(c.bins[0]);
+        const r = await correr(bin, args, stdin, techoMs);
+        if (r.ausente)
+            throw new LlaveroAusente(bin);
+        if (r.vencido)
+            throw new Error(`El llavero no contestó en ${Math.round(techoMs / 1000)} s.`);
+        return r;
+    }
+    const fallo = (codigo) => new Error(`El llavero falló (código ${codigo}).`);
+    return {
+        nombre: "llavero",
+        async leer(cuenta, techoMs = TECHO_DEL_LLAVERO_MS) {
+            const r = await ejecutar(c.leer(cuentaSegura(cuenta)), null, techoMs);
+            if (c.noEncontrado(r.codigo, r.stdout, r.stderr ?? ""))
+                return null;
+            if (r.codigo !== 0)
+                throw fallo(r.codigo);
+            return decodificar(r.stdout);
+        },
+        async escribir(cuenta, registro, techoMs = TECHO_DEL_LLAVERO_MS) {
+            const { args, stdin } = c.escribir(cuentaSegura(cuenta), codificar(registro));
+            const r = await ejecutar(args, stdin, techoMs);
+            if (r.codigo !== 0)
+                throw fallo(r.codigo);
+        },
+        async borrar(cuenta, techoMs = TECHO_DEL_LLAVERO_MS) {
+            const r = await ejecutar(c.borrar(cuentaSegura(cuenta)), null, techoMs);
+            if (c.noEncontrado(r.codigo, r.stdout, r.stderr ?? ""))
+                return;
+            if (r.codigo !== 0)
+                throw fallo(r.codigo);
+        },
+    };
+}

package/dist/guardado/repo.js

@@ -0,0 +1,35 @@
+// ¿Cae este destino dentro de un repo de git? Si la respuesta es sí, la clave no se escribe ahí:
+// un `git add -A` distraído (o un repo de dotfiles que se sube a GitHub) la publicaría (§5.2).
+import path from "node:path";
+// La ruta escrita engaña cuando un tramo es un enlace (`~/.config` armado con `stow` desde un repo
+// de dotfiles): se resuelve el ancestro existente más cercano y se le suman los segmentos que todavía
+// no existen, porque `realpath` de algo que no existe lanza (Review Focus 6).
+export function rutaReal(p, fs) {
+    let actual = path.resolve(p);
+    const faltan = [];
+    while (!fs.existe(actual)) {
+        const padre = path.dirname(actual);
+        if (padre === actual)
+            break;
+        faltan.unshift(path.basename(actual));
+        actual = padre;
+    }
+    return path.join(fs.realpath(actual), ...faltan);
+}
+// Seguido o no: basta que exista `.git`, directorio o archivo (un worktree tiene un archivo `.git`).
+// Se miran las dos rutas porque cualquiera de las dos puede ser la que cae dentro del repo.
+export function dentroDeUnWorkingTree(dir, fs) {
+    const escrita = path.resolve(dir);
+    for (const inicio of new Set([escrita, rutaReal(escrita, fs)])) {
+        let actual = inicio;
+        for (;;) {
+            if (fs.existe(path.join(actual, ".git")))
+                return actual;
+            const padre = path.dirname(actual);
+            if (padre === actual)
+                break;
+            actual = padre;
+        }
+    }
+    return null;
+}

package/dist/sondeo.js

@@ -0,0 +1,47 @@
+import { TECHO_DEL_LLAVERO_MS } from "./guardado/llavero.js";
+// 90 s para el comando ENTERO, guardado y revocación incluidos, no sólo para los sondeos: quien
+// llama suele ser un asistente cuya herramienta de terminal corta a los 2 min (Claude Code), y un
+// comando cortado a mitad de cierre puede dejar la clave nueva sin guardar o la vieja sin revocar.
+// Por la misma razón (P13 del motor) nada espera en silencio más que eso: se parte en tramos.
+export const TRAMO_MAXIMO_MS = 90_000;
+// Lo que se aparta del tramo para cerrar después de recibir el token. La secuencia de cierre tiene a
+// lo sumo cuatro operaciones lentas, cada una con techo de 5 s: guardar la nueva (el llavero; si
+// vence, el archivo es local e inmediato), revocar la anterior en el motor, anotarla «por revocar»
+// si no se pudo, y borrar el pendiente. 4 × 5 s + 2 s de margen = 22 s. La clave anterior se lee
+// ANTES de sondear (no consume reserva), y el pendiente sólo se persiste tras respuestas no finales.
+export const RESERVA_PARA_CERRAR_MS = 22_000;
+// Una operación de cierre opcional (revocar la anterior, borrar el pendiente) con menos que esto
+// no se intenta: con medio segundo no contesta ni un motor sano, y lo que no se hace queda anotado.
+export const PLAZO_MINIMO_MS = 500;
+// Un sondeo con menos plazo que esto casi seguro vence sin respuesta: mejor salir 5 y que el
+// próximo `--wait` sondee con un tramo entero.
+export const PLAZO_MINIMO_DE_SONDEO_MS = 2_000;
+const PLAZO_MAXIMO_DE_CANJE_MS = 15_000;
+export async function sondearUnTramo(inicial, d) {
+    let p = inicial;
+    for (;;) {
+        // El intervalo se cuenta desde el último sondeo GUARDADO, no desde que arrancó este comando
+        // (Review Focus 4): un `--wait` enseguida de otro espera lo que falta, en vez de ganarse un
+        // `slow_down` del motor.
+        const ahora = d.ahora();
+        const proximo = p.ultimoSondeoEn === null ? ahora : Math.max(ahora, p.ultimoSondeoEn + p.intervaloS * 1000);
+        if (proximo >= p.venceEn)
+            return { tipo: "vencido" };
+        if (d.finDeSondeos - proximo < PLAZO_MINIMO_DE_SONDEO_MS)
+            return { tipo: "sigue", pendiente: p };
+        if (proximo > ahora)
+            await d.dormir(proximo - ahora);
+        const c = await d.canjear(p.deviceCode, Math.min(PLAZO_MAXIMO_DE_CANJE_MS, d.finDeSondeos - d.ahora()));
+        // El token es la ÚNICA copia de la clave (el motor no la reentrega): no espera a ninguna
+        // escritura del pendiente, que podría colgarse o lanzar y perderla (Review Focus 13).
+        if (c.tipo === "token")
+            return { tipo: "token", clave: c.clave, equipo: c.equipo };
+        if (c.tipo !== "pendiente" && c.tipo !== "slow_down")
+            return { tipo: c.tipo };
+        // El último sondeo se fecha con la RESPUESTA: el motor lo vio a más tardar entonces, así que
+        // contar desde ahí nunca adelanta el próximo. Y se guarda ANTES de seguir (Review Focus 11):
+        // si la red se cae en el sondeo siguiente, el intervalo nuevo de un `slow_down` ya quedó escrito.
+        p = { ...p, ultimoSondeoEn: d.ahora(), intervaloS: p.intervaloS + (c.tipo === "slow_down" ? 5 : 0) };
+        await d.persistir(p, Math.min(TECHO_DEL_LLAVERO_MS, Math.max(PLAZO_MINIMO_MS, d.finDeSondeos - d.ahora())));
+    }
+}

package/package.json

@@ -1,6 +1,13 @@
 {
   "name": "supcoflow",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "La terminal de Supcoflow: iniciar sesión y manejar el chat de soporte desde la consola o un asistente.",
+  "type": "module",
+  "bin": { "supcoflow": "dist/cli.js" },
+  "files": ["dist"],
+  "engines": { "node": ">=24" },
+  "scripts": { "build": "tsc -p tsconfig.json && chmod +x dist/cli.js", "test": "vitest run", "typecheck": "tsc --noEmit" },
+  "dependencies": {},
+  "devDependencies": { "@types/node": "^24.0.0", "typescript": "^5.9.0", "vitest": "^4.0.0" },
+  "license": "UNLICENSED"
+}