@hoilab/ada-cli 0.85.0 → 0.85.3

package/dist/core/credenciales/pool.js

@@ -27,6 +27,10 @@
  * extensión es cargar/guardar `estado()` a un fichero en `iniciar`/`cerrar`.
  */
 import { clasificarError } from "../errores/proveedor.js";
+import { huellaDeCredencial } from "./ratelimit.js";
+function publica(fila) {
+    return { id: fila.id, proveedor: fila.proveedor, estado: fila.estado, motivoBloqueo: fila.motivoBloqueo };
+}
 export class CredencialPool {
     porId = new Map();
     porProveedor = new Map();
@@ -34,7 +38,11 @@ export class CredencialPool {
     pegajosidad = new Map();
     /** Cursor de reparto round-robin por proveedor, para las peticiones sin pegajosidad. */
     cursores = new Map();
-    constructor(credenciales) {
+    /** Contador de usos reportados por credencial (memoria; alimenta el ranking). */
+    usos = new Map();
+    selector;
+    constructor(credenciales, opciones) {
+        this.selector = opciones?.selector;
         for (const [proveedor, lista] of Object.entries(credenciales)) {
             const filas = lista.map((c) => ({ ...c, proveedor, estado: "activa" }));
             this.porProveedor.set(proveedor, filas);
@@ -67,6 +75,29 @@ export class CredencialPool {
         const activas = filas.filter((f) => f.estado === "activa");
         if (activas.length === 0)
             return null;
+        if (this.selector) {
+            // El hook decide entre las activas y su veredicto es FINAL: si dice
+            // «ninguna sirve» (todas enfriadas por rate-limit, p. ej.), el pool
+            // devuelve null en vez de colarse al round-robin y entregar justo la
+            // cuenta que el proveedor nos pidió descansar. La pegajosa activa
+            // viaja en el contexto; si el hook la fija, se ancla igual que el
+            // camino por defecto — misma promesa de caché de prompts.
+            const pegajosaId = promptCacheKey ? this.filaPegadaActiva(proveedor, promptCacheKey)?.id : undefined;
+            const idDelHook = this.selector(activas.map(publica), {
+                usoReciente: this.usosSnapshot(),
+                rotacion: () => this.siguiente(proveedor, activas).id,
+                huella: (id) => this.huellaDe(id),
+                pegajosaId,
+            });
+            if (!idDelHook)
+                return null;
+            const filaHook = this.porId.get(idDelHook);
+            if (!filaHook || filaHook.estado !== "activa")
+                return null;
+            if (promptCacheKey)
+                this.pegajosidad.set(this.clavePegajosidad(proveedor, promptCacheKey), filaHook.id);
+            return { id: filaHook.id, proveedor, valor: filaHook.valor };
+        }
         if (promptCacheKey) {
             const clave = this.clavePegajosidad(proveedor, promptCacheKey);
             const idPegado = this.pegajosidad.get(clave);
@@ -83,6 +114,25 @@ export class CredencialPool {
         const elegida = this.siguiente(proveedor, activas);
         return { id: elegida.id, proveedor, valor: elegida.valor };
     }
+    filaPegadaActiva(proveedor, promptCacheKey) {
+        const idPegado = this.pegajosidad.get(this.clavePegajosidad(proveedor, promptCacheKey));
+        const fila = idPegado ? this.porId.get(idPegado) : undefined;
+        return fila && fila.estado === "activa" ? fila : undefined;
+    }
+    usosSnapshot() {
+        const tabla = {};
+        for (const [id, n] of this.usos)
+            tabla[id] = n;
+        return tabla;
+    }
+    /**
+     * Huella SHA-256 del valor de una credencial: lo único que sale del valor
+     * hacia registros de rate-limit o diagnóstico. `undefined` = id desconocido.
+     */
+    huellaDe(id) {
+        const fila = this.porId.get(id);
+        return fila ? huellaDeCredencial(fila.valor) : undefined;
+    }
     /**
      * Registra el resultado de usar una credencial ya entregada.
      *
@@ -94,6 +144,10 @@ export class CredencialPool {
         const fila = this.porId.get(id);
         if (!fila)
             return null;
+        // Todo uso reportado cuenta — también el fallo: una cuenta que lleva
+        // tres 429 esta hora está más "usada" que su hermana descansada, y el
+        // ranking por cuota debe verlo.
+        this.usos.set(id, (this.usos.get(id) ?? 0) + 1);
         if (resultado.ok)
             return { clase: "ok", estado: fila.estado };
         const clasificado = clasificarError({ mensaje: resultado.mensaje, estado: resultado.estadoHttp });
@@ -117,12 +171,7 @@ export class CredencialPool {
     }
     /** Vista pública del pool: sin secretos, para `/v1/snapshot`. */
     snapshot() {
-        return [...this.porId.values()].map((f) => ({
-            id: f.id,
-            proveedor: f.proveedor,
-            estado: f.estado,
-            motivoBloqueo: f.motivoBloqueo,
-        }));
+        return [...this.porId.values()].map(publica);
     }
 }
 //# sourceMappingURL=pool.js.map

package/dist/core/credenciales/pool.js.map

@@ -1 +1 @@
-{"version":3,"file":"pool.js","sourceRoot":"","sources":["../../../src/core/credenciales/pool.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Piscina de credenciales por proveedor.\n *\n * El hueco que esto tapa: hoy cada desarrollador tiene sus claves en su propio\n * portátil. `oh-my-pi` (packages/ai/src/auth-broker de ese repo) resuelve esto\n * con un servidor que guarda las credenciales y las reparte; lo que se copia\n * aquí de su diseño son dos decisiones concretas, no el código:\n *\n * 1. **Conmutación a una hermana cuando una cuenta falla de verdad.** Un 401\n *    (`credencial-invalida` o `sin-credencial` en la taxonomía de\n *    `../errores/proveedor.ts`) saca la credencial del pool: la siguiente\n *    petición usa otra. Un 429 (`limite-de-tasa`) NO la saca — la cuenta sigue\n *    siendo buena, solo está ocupada un rato. Confundir los dos es el fallo\n *    que quema cuentas sanas: se ha visto documentado en el propio\n *    `errores/proveedor.ts` como el error más caro de mezclar.\n * 2. **Pegajosidad por sesión vía `prompt_cache_key`.** Sin esto, repartir\n *    entre cuentas rompería el caché de prompts del proveedor en cada turno —\n *    cada petición de la misma conversación pagaría el prefijo entero de\n *    nuevo. Una `prompt_cache_key` se queda pegada a la misma credencial\n *    mientras esa credencial siga activa; solo se realoja cuando la que tenía\n *    pegada se bloquea.\n *\n * Lo que NO se copia: el pool vive en memoria del proceso `ada-cli serve\n * --broker`, no en SQLite. Reiniciar el broker olvida qué estaba bloqueado y\n * la pegajosidad — aceptable para el alcance de hoy (equipos pequeños, un\n * broker por equipo); si hace falta sobrevivir a reinicios, el punto de\n * extensión es cargar/guardar `estado()` a un fichero en `iniciar`/`cerrar`.\n */\n\nimport { clasificarError } from \"../errores/proveedor.ts\";\n\n/** Una credencial tal como la da quien configura el pool: sin estado todavía. */\nexport interface CredencialDelPool {\n\tid: string;\n\tproveedor: string;\n\tvalor: string;\n}\n\nexport type EstadoCredencial = \"activa\" | \"bloqueada\";\n\ninterface Fila extends CredencialDelPool {\n\testado: EstadoCredencial;\n\tmotivoBloqueo?: string;\n\tbloqueadaEn?: number;\n}\n\n/** Lo que se le enseña a un cliente que pide credencial: el secreto, para usarlo. */\nexport interface CredencialElegida {\n\tid: string;\n\tproveedor: string;\n\tvalor: string;\n}\n\n/** Lo que reporta el cliente tras usar una credencial. */\nexport type ResultadoDeUso = { ok: true } | { ok: false; estadoHttp?: number; mensaje: string };\n\n/** Lo que devuelve `marcarUso`: la clase de error (o \"ok\") y el estado resultante. */\nexport interface EfectoDeUso {\n\tclase: string;\n\testado: EstadoCredencial;\n}\n\n/** Fila sin el secreto — lo que se puede enseñar por `/v1/snapshot` sin filtrar nada. */\nexport interface FilaPublica {\n\tid: string;\n\tproveedor: string;\n\testado: EstadoCredencial;\n\tmotivoBloqueo?: string;\n}\n\nexport class CredencialPool {\n\tprivate readonly porId = new Map<string, Fila>();\n\tprivate readonly porProveedor = new Map<string, Fila[]>();\n\t/** `proveedor\\0promptCacheKey` -> id de la credencial pegada a esa sesión. */\n\tprivate readonly pegajosidad = new Map<string, string>();\n\t/** Cursor de reparto round-robin por proveedor, para las peticiones sin pegajosidad. */\n\tprivate readonly cursores = new Map<string, number>();\n\n\tconstructor(credenciales: Record<string, CredencialDelPool[]>) {\n\t\tfor (const [proveedor, lista] of Object.entries(credenciales)) {\n\t\t\tconst filas = lista.map((c): Fila => ({ ...c, proveedor, estado: \"activa\" }));\n\t\t\tthis.porProveedor.set(proveedor, filas);\n\t\t\tfor (const fila of filas) this.porId.set(fila.id, fila);\n\t\t}\n\t}\n\n\tprivate clavePegajosidad(proveedor: string, promptCacheKey: string): string {\n\t\treturn `${proveedor} ${promptCacheKey}`;\n\t}\n\n\tprivate siguiente(proveedor: string, activas: Fila[]): Fila {\n\t\tconst cursor = this.cursores.get(proveedor) ?? 0;\n\t\tthis.cursores.set(proveedor, cursor + 1);\n\t\treturn activas[cursor % activas.length];\n\t}\n\n\t/**\n\t * Elige una credencial activa para `proveedor`.\n\t *\n\t * Sin `promptCacheKey`: reparto round-robin entre las activas. Con\n\t * `promptCacheKey`: si la sesión ya tenía una credencial pegada y sigue\n\t * activa, se reutiliza (no rompe el caché de prompts); si no, se elige una\n\t * nueva y se fija para las próximas llamadas con la misma clave.\n\t *\n\t * `null` = no hay ninguna credencial activa para ese proveedor. Es \"no hay\n\t * nada\", no \"no he podido\" — todas las filas existen, todas están\n\t * bloqueadas, y decirlo así es lo que distingue esto de un fallo del pool.\n\t */\n\telegir(proveedor: string, promptCacheKey?: string): CredencialElegida | null {\n\t\tconst filas = this.porProveedor.get(proveedor) ?? [];\n\t\tconst activas = filas.filter((f) => f.estado === \"activa\");\n\t\tif (activas.length === 0) return null;\n\n\t\tif (promptCacheKey) {\n\t\t\tconst clave = this.clavePegajosidad(proveedor, promptCacheKey);\n\t\t\tconst idPegado = this.pegajosidad.get(clave);\n\t\t\tconst fila = idPegado ? this.porId.get(idPegado) : undefined;\n\t\t\tif (fila && fila.estado === \"activa\") {\n\t\t\t\treturn { id: fila.id, proveedor, valor: fila.valor };\n\t\t\t}\n\t\t\t// Sin pegajosidad válida (primera vez, o la que tenía pegada se bloqueó):\n\t\t\t// elige una hermana y la fija para las próximas peticiones de esta sesión.\n\t\t\tconst elegida = this.siguiente(proveedor, activas);\n\t\t\tthis.pegajosidad.set(clave, elegida.id);\n\t\t\treturn { id: elegida.id, proveedor, valor: elegida.valor };\n\t\t}\n\n\t\tconst elegida = this.siguiente(proveedor, activas);\n\t\treturn { id: elegida.id, proveedor, valor: elegida.valor };\n\t}\n\n\t/**\n\t * Registra el resultado de usar una credencial ya entregada.\n\t *\n\t * `null` = id desconocido (no hay tal credencial en el pool) — se distingue\n\t * de \"la marcó y sigue activa\" para que quien llama pueda contestar 404 en\n\t * vez de fingir un 200.\n\t */\n\tmarcarUso(id: string, resultado: ResultadoDeUso): EfectoDeUso | null {\n\t\tconst fila = this.porId.get(id);\n\t\tif (!fila) return null;\n\n\t\tif (resultado.ok) return { clase: \"ok\", estado: fila.estado };\n\n\t\tconst clasificado = clasificarError({ mensaje: resultado.mensaje, estado: resultado.estadoHttp });\n\n\t\t// Solo un 401/403 de credencial mala saca la fila del pool. Un 429\n\t\t// (`limite-de-tasa`) deja `fila.estado` intacto a propósito: es la\n\t\t// distinción que pide la tarea, y confundirla quema cuentas que solo\n\t\t// estaban ocupadas.\n\t\tif (clasificado.clase === \"credencial-invalida\" || clasificado.clase === \"sin-credencial\") {\n\t\t\tfila.estado = \"bloqueada\";\n\t\t\tfila.motivoBloqueo = clasificado.clase;\n\t\t\tfila.bloqueadaEn = Date.now();\n\t\t\t// Toda sesión pegada a esta credencial se suelta: la próxima `elegir`\n\t\t\t// con la misma prompt_cache_key tiene que caer en una hermana, no\n\t\t\t// seguir devolviendo la que ya sabemos que está mala.\n\t\t\tfor (const [clave, idPegado] of this.pegajosidad) {\n\t\t\t\tif (idPegado === id) this.pegajosidad.delete(clave);\n\t\t\t}\n\t\t}\n\n\t\treturn { clase: clasificado.clase, estado: fila.estado };\n\t}\n\n\t/** Vista pública del pool: sin secretos, para `/v1/snapshot`. */\n\tsnapshot(): FilaPublica[] {\n\t\treturn [...this.porId.values()].map((f) => ({\n\t\t\tid: f.id,\n\t\t\tproveedor: f.proveedor,\n\t\t\testado: f.estado,\n\t\t\tmotivoBloqueo: f.motivoBloqueo,\n\t\t}));\n\t}\n}\n"]}
+{"version":3,"file":"pool.js","sourceRoot":"","sources":["../../../src/core/credenciales/pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAkEpD,SAAS,OAAO,CAAC,IAAU;IAC1B,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC;AAC3G,CAAC;AAED,MAAM,OAAO,cAAc;IACT,KAAK,GAAG,IAAI,GAAG,EAAgB,CAAC;IAChC,YAAY,GAAG,IAAI,GAAG,EAAkB,CAAC;IAC1D,8EAA8E;IAC7D,WAAW,GAAG,IAAI,GAAG,EAAkB,CAAC;IACzD,wFAAwF;IACvE,QAAQ,GAAG,IAAI,GAAG,EAAkB,CAAC;IACtD,iFAAiF;IAChE,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;IACjC,QAAQ,CAAwB;IAEjD,YAAY,YAAiD,EAAE,QAA8C;QAC5G,IAAI,CAAC,QAAQ,GAAG,QAAQ,EAAE,QAAQ,CAAC;QACnC,KAAK,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;YAC/D,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;YAC9E,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YACxC,KAAK,MAAM,IAAI,IAAI,KAAK;gBAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QACzD,CAAC;IACF,CAAC;IAEO,gBAAgB,CAAC,SAAiB,EAAE,cAAsB;QACjE,OAAO,GAAG,SAAS,IAAI,cAAc,EAAE,CAAC;IACzC,CAAC;IAEO,SAAS,CAAC,SAAiB,EAAE,OAAe;QACnD,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QACjD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC;QACzC,OAAO,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,SAAiB,EAAE,cAAuB;QAChD,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACrD,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC;QAC3D,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAEtC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,oEAAoE;YACpE,oEAAoE;YACpE,qEAAqE;YACrE,kEAAkE;YAClE,kEAAkE;YAClE,0DAA0D;YAC1D,MAAM,UAAU,GAAG,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;YACrG,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE;gBACrD,WAAW,EAAE,IAAI,CAAC,YAAY,EAAE;gBAChC,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,EAAE;gBACrD,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACjC,UAAU;aACV,CAAC,CAAC;YACH,IAAI,CAAC,SAAS;gBAAE,OAAO,IAAI,CAAC;YAC5B,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAC3C,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAK,QAAQ;gBAAE,OAAO,IAAI,CAAC;YAC3D,IAAI,cAAc;gBAAE,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;YACxG,OAAO,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;QAC9D,CAAC;QAED,IAAI,cAAc,EAAE,CAAC;YACpB,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;YAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAC7C,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC7D,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;gBACtC,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC;YACtD,CAAC;YACD,0EAA0E;YAC1E,2EAA2E;YAC3E,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;YACnD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;YACxC,OAAO,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC;QAC5D,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACnD,OAAO,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC;IAC5D,CAAC;IAEO,gBAAgB,CAAC,SAAiB,EAAE,cAAsB;QACjE,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC;QACxF,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC7D,OAAO,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5D,CAAC;IAEO,YAAY;QACnB,MAAM,KAAK,GAA2B,EAAE,CAAC;QACzC,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI;YAAE,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAC/C,OAAO,KAAK,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,EAAU;QAClB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAChC,OAAO,IAAI,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1D,CAAC;IAED;;;;;;OAMG;IACH,SAAS,CAAC,EAAU,EAAE,SAAyB;QAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC;QAEvB,qEAAqE;QACrE,sEAAsE;QACtE,gCAAgC;QAChC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAEhD,IAAI,SAAS,CAAC,EAAE;YAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;QAE9D,MAAM,WAAW,GAAG,eAAe,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,UAAU,EAAE,CAAC,CAAC;QAElG,mEAAmE;QACnE,mEAAmE;QACnE,qEAAqE;QACrE,oBAAoB;QACpB,IAAI,WAAW,CAAC,KAAK,KAAK,qBAAqB,IAAI,WAAW,CAAC,KAAK,KAAK,gBAAgB,EAAE,CAAC;YAC3F,IAAI,CAAC,MAAM,GAAG,WAAW,CAAC;YAC1B,IAAI,CAAC,aAAa,GAAG,WAAW,CAAC,KAAK,CAAC;YACvC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAC9B,sEAAsE;YACtE,kEAAkE;YAClE,sDAAsD;YACtD,KAAK,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBAClD,IAAI,QAAQ,KAAK,EAAE;oBAAE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrD,CAAC;QACF,CAAC;QAED,OAAO,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;IAC1D,CAAC;IAED,iEAAiE;IACjE,QAAQ;QACP,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;CACD"}

package/dist/core/credenciales/ranking.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Ranking de credenciales del pool por cuota real.
+ *
+ * El hueco (AUDITORIA-OMP.md, clúster E: «pools multi-cuenta round-robin +
+ * sticky por sesión, ranking por cuota real»): el round-robin reparte al
+ * margen — la cuenta que lleva tres 429 esta hora recibe el mismo tráfico
+ * que su hermana descansada. Este módulo es la capa superior que ordena los
+ * candidatos antes de entregarlos:
+ *
+ * 1. **Disponible ahora** — descarta las enfriadas por rate-limit (huella
+ *    consultada en el registro persistente de `ratelimit.ts`).
+ * 2. **Pegajosa si sigue disponible** — una `prompt_cache_key` ya anclada a
+ *    una credencial sana se queda donde está. Va antes del balanceo a
+ *    propósito: moverla "para equilibrar" rompe el caché de prompts del
+ *    proveedor y cuesta más de lo que ahorra.
+ * 3. **Menor uso reciente** — contador en memoria (`marcarUso` del pool lo
+ *    alimenta); empate → orden de declaración, estable.
+ * 4. **Round-robin del pool como degradación** — sin ningún dato de cuota
+ *    (ningún contador), no inventa señales: delega en el cursor del propio
+ *    pool, que es el comportamiento previo.
+ */
+import type { FilaPublica, SelectorDeCredencial } from "./pool.ts";
+import type { RegistroEnfriamiento } from "./ratelimit.ts";
+/** Candidata al ranking: fila pública + huella opcional para el enfriamiento. */
+export type Candidata = FilaPublica & {
+    huella?: string;
+};
+export interface EstadoEleccion {
+    /** Instante de la decisión (ms). Default: Date.now(). */
+    ahora?: number;
+    /** id -> usos registrados en memoria desde el arranque. */
+    usoReciente?: Record<string, number>;
+    /** huella -> epoch (ms) hasta el que está enfriada por rate-limit. */
+    enfriadasHasta?: Record<string, number>;
+    /** Id de la credencial pegada a la sesión, si existe. */
+    pegajosaId?: string;
+    /**
+     * Siguiente credencial según el round-robin del pool — la degradación
+     * cuando no hay datos de cuota. Puede devolver una enfriada: se valida.
+     */
+    rotacion?: () => Candidata | null;
+}
+/**
+ * Elige una credencial entre `candidatos`, o `null` si ninguna está
+ * disponible (todas enfriadas). Nunca lanza por datos ausentes: cada pieza
+ * de `estado` es opcional y su falta degrada al criterio anterior.
+ */
+export declare function elegirCredencial(candidatos: readonly Candidata[], estado: EstadoEleccion): Candidata | null;
+/**
+ * Adaptador listo para el hook `selector` de `CredencialPool`: traduce el
+ * contexto del pool (contadores, rotación, huellas) al estado del ranking y
+ * consulta el registro de enfriamiento vivo en cada elección — un 429
+ * reportado hace un segundo cambia ya la próxima resolución.
+ */
+export declare function crearSelectorRanking(enfriamiento: RegistroEnfriamiento): SelectorDeCredencial;
+//# sourceMappingURL=ranking.d.ts.map

package/dist/core/credenciales/ranking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ranking.d.ts","sourceRoot":"","sources":["../../../src/core/credenciales/ranking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAqB,WAAW,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACtF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,iFAAiF;AACjF,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1D,MAAM,WAAW,cAAc;IAC9B,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,sEAAsE;IACtE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,SAAS,GAAG,IAAI,CAAC;CAClC;AAQD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,EAAE,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,IAAI,CAkC3G;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,oBAAoB,GAAG,oBAAoB,CAmB7F"}

package/dist/core/credenciales/ranking.js

@@ -0,0 +1,94 @@
+/**
+ * Ranking de credenciales del pool por cuota real.
+ *
+ * El hueco (AUDITORIA-OMP.md, clúster E: «pools multi-cuenta round-robin +
+ * sticky por sesión, ranking por cuota real»): el round-robin reparte al
+ * margen — la cuenta que lleva tres 429 esta hora recibe el mismo tráfico
+ * que su hermana descansada. Este módulo es la capa superior que ordena los
+ * candidatos antes de entregarlos:
+ *
+ * 1. **Disponible ahora** — descarta las enfriadas por rate-limit (huella
+ *    consultada en el registro persistente de `ratelimit.ts`).
+ * 2. **Pegajosa si sigue disponible** — una `prompt_cache_key` ya anclada a
+ *    una credencial sana se queda donde está. Va antes del balanceo a
+ *    propósito: moverla "para equilibrar" rompe el caché de prompts del
+ *    proveedor y cuesta más de lo que ahorra.
+ * 3. **Menor uso reciente** — contador en memoria (`marcarUso` del pool lo
+ *    alimenta); empate → orden de declaración, estable.
+ * 4. **Round-robin del pool como degradación** — sin ningún dato de cuota
+ *    (ningún contador), no inventa señales: delega en el cursor del propio
+ *    pool, que es el comportamiento previo.
+ */
+function enfriadaHasta(candidata, estado) {
+    if (!candidata.huella)
+        return undefined;
+    const hasta = estado.enfriadasHasta?.[candidata.huella];
+    return typeof hasta === "number" ? hasta : undefined;
+}
+/**
+ * Elige una credencial entre `candidatos`, o `null` si ninguna está
+ * disponible (todas enfriadas). Nunca lanza por datos ausentes: cada pieza
+ * de `estado` es opcional y su falta degrada al criterio anterior.
+ */
+export function elegirCredencial(candidatos, estado) {
+    const ahora = estado.ahora ?? Date.now();
+    const disponibles = candidatos.filter((c) => {
+        const hasta = enfriadaHasta(c, estado);
+        // Disponible si no hay enfriamiento o ya venció (hasta <= ahora).
+        return hasta === undefined || hasta <= ahora;
+    });
+    if (disponibles.length === 0)
+        return null;
+    if (estado.pegajosaId) {
+        const pegajosa = disponibles.find((c) => c.id === estado.pegajosaId);
+        if (pegajosa)
+            return pegajosa;
+    }
+    const uso = estado.usoReciente ?? {};
+    const conDatos = disponibles.some((c) => typeof uso[c.id] === "number" && uso[c.id] > 0);
+    if (!conDatos) {
+        // Sin datos de cuota no se inventa señal: round-robin del pool, validado
+        // contra el enfriamiento. Se prueban tantas pasadas como candidatos — el
+        // cursor puede apuntar varias veces seguidas a cuentas enfriadas.
+        for (let i = 0; i < candidatos.length; i++) {
+            const rotada = estado.rotacion?.() ?? null;
+            if (rotada && disponibles.some((c) => c.id === rotada.id))
+                return rotada;
+        }
+        return disponibles[0];
+    }
+    let mejor = disponibles[0];
+    for (const candidata of disponibles) {
+        if ((uso[candidata.id] ?? Number.MAX_SAFE_INTEGER) < (uso[mejor.id] ?? Number.MAX_SAFE_INTEGER)) {
+            mejor = candidata;
+        }
+    }
+    return mejor;
+}
+/**
+ * Adaptador listo para el hook `selector` de `CredencialPool`: traduce el
+ * contexto del pool (contadores, rotación, huellas) al estado del ranking y
+ * consulta el registro de enfriamiento vivo en cada elección — un 429
+ * reportado hace un segundo cambia ya la próxima resolución.
+ */
+export function crearSelectorRanking(enfriamiento) {
+    return (candidatos, contexto) => {
+        const enfriadasHasta = {};
+        for (const entrada of enfriamiento.enfriadas())
+            enfriadasHasta[entrada.huella] = entrada.hasta;
+        const conHuella = candidatos.map((c) => ({ ...c, huella: contexto.huella(c.id) }));
+        const elegida = elegirCredencial(conHuella, {
+            ahora: Date.now(),
+            usoReciente: contexto.usoReciente,
+            enfriadasHasta,
+            pegajosaId: contexto.pegajosaId,
+            rotacion: () => {
+                const id = contexto.rotacion();
+                const encontrada = id ? candidatos.find((c) => c.id === id) : undefined;
+                return encontrada ? { ...encontrada, huella: contexto.huella(encontrada.id) } : null;
+            },
+        });
+        return elegida?.id ?? null;
+    };
+}
+//# sourceMappingURL=ranking.js.map

package/dist/core/credenciales/ranking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ranking.js","sourceRoot":"","sources":["../../../src/core/credenciales/ranking.ts"],"names":[],"mappings":"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"}

package/dist/core/credenciales/ratelimit.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Registro persistente de enfriamiento por rate-limit (429) del pool de
+ * credenciales.
+ *
+ * El hueco que tapa (AUDITORIA-OMP.md, clúster E): el pool en memoria sabe
+ * que un 429 no bloquea la cuenta, pero olvida el enfriamiento al reiniciar
+ * el broker — y una cuenta recién reiniciada vuelve a recibir tráfico que el
+ * proveedor sigue rechazando, quemando el Retry-After. Aquí el enfriamiento
+ * sobrevive a reinicios: JSON atómico (`writeTextAtomicSync`, temporal +
+ * rename + fsync) releído en cada arranque.
+ *
+ * La decisión de privacidad es dura y está probada: en el fichero NUNCA hay
+ * claves — solo huellas SHA-256 del valor. Un disco comprometido revela que
+ * «la cuenta con huella ab12… está enfriada hasta las 14:05», nada más.
+ */
+/** Una entrada del registro: huella (jamás el valor), hasta qué epoch y por qué. */
+export interface EntradaEnfriamiento {
+    huella: string;
+    /** Epoch en milisegundos hasta el que la credencial descansa. */
+    hasta: number;
+    motivo?: string;
+}
+/**
+ * Huella estable de una credencial: SHA-256 del valor, hex. Es lo único que
+ * sale del valor hacia cualquier superficie persistente o consultable — ni
+ * argv, ni campos, ni este fichero ven nunca la clave entera.
+ */
+export declare function huellaDeCredencial(valor: string): string;
+export declare class RegistroEnfriamiento {
+    private readonly entradas;
+    /** Ruta del JSON persistente; `undefined` = solo memoria (tests). */
+    readonly fichero: string | undefined;
+    constructor(fichero?: string);
+    /**
+     * Marca la credencial como enfriada hasta `hastaEpoch` (ms). Si ya había
+     * una entrada, gana la más lejana: dos clientes que reportan 429 con
+     * Retry-After distintos no deben acortar el descanso que el proveedor pidió.
+     */
+    marcarEnfriada(huella: string, hastaEpoch: number, motivo?: string): void;
+    /** `true` si la credencial puede usarse ahora mismo. */
+    disponible(huella: string, ahora?: number): boolean;
+    /** Epoch hasta el que está enfriada, o `undefined` si está disponible. */
+    enfriadaHasta(huella: string, ahora?: number): number | undefined;
+    /** Las credenciales enfriadas AHORA (las expiradas se podan antes). */
+    enfriadas(ahora?: number): EntradaEnfriamiento[];
+    /**
+     * Relee el fichero de disco. Es lo que un reinicio del broker ejecuta vía
+     * constructor; existe como método público porque la prueba de persistencia
+     * simula el reinicio sobre una segunda instancia sin tirar la primera.
+     */
+    recargar(): void;
+    private persistir;
+}
+//# sourceMappingURL=ratelimit.d.ts.map

package/dist/core/credenciales/ratelimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ratelimit.d.ts","sourceRoot":"","sources":["../../../src/core/credenciales/ratelimit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH,oFAAoF;AACpF,MAAM,WAAW,mBAAmB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAOD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,qBAAa,oBAAoB;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;IAEnE,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEzB,OAAO,CAAC,EAAE,MAAM;IAK5B;;;;OAIG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAOzE,wDAAwD;IACxD,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,MAAmB,GAAG,OAAO;IAI/D,0EAA0E;IAC1E,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,MAAmB,GAAG,MAAM,GAAG,SAAS;IAY7E,uEAAuE;IACvE,SAAS,CAAC,KAAK,GAAE,MAAmB,GAAG,mBAAmB,EAAE;IAU5D;;;;OAIG;IACH,QAAQ,IAAI,IAAI;IAuBhB,OAAO,CAAC,SAAS;CAKjB"}

package/dist/core/credenciales/ratelimit.js

@@ -0,0 +1,116 @@
+/**
+ * Registro persistente de enfriamiento por rate-limit (429) del pool de
+ * credenciales.
+ *
+ * El hueco que tapa (AUDITORIA-OMP.md, clúster E): el pool en memoria sabe
+ * que un 429 no bloquea la cuenta, pero olvida el enfriamiento al reiniciar
+ * el broker — y una cuenta recién reiniciada vuelve a recibir tráfico que el
+ * proveedor sigue rechazando, quemando el Retry-After. Aquí el enfriamiento
+ * sobrevive a reinicios: JSON atómico (`writeTextAtomicSync`, temporal +
+ * rename + fsync) releído en cada arranque.
+ *
+ * La decisión de privacidad es dura y está probada: en el fichero NUNCA hay
+ * claves — solo huellas SHA-256 del valor. Un disco comprometido revela que
+ * «la cuenta con huella ab12… está enfriada hasta las 14:05», nada más.
+ */
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { writeTextAtomicSync } from "../utils/atomic-write.js";
+const VERSION_FORMATO = 1;
+/**
+ * Huella estable de una credencial: SHA-256 del valor, hex. Es lo único que
+ * sale del valor hacia cualquier superficie persistente o consultable — ni
+ * argv, ni campos, ni este fichero ven nunca la clave entera.
+ */
+export function huellaDeCredencial(valor) {
+    return createHash("sha256").update(valor, "utf-8").digest("hex");
+}
+export class RegistroEnfriamiento {
+    entradas = new Map();
+    /** Ruta del JSON persistente; `undefined` = solo memoria (tests). */
+    fichero;
+    constructor(fichero) {
+        this.fichero = fichero;
+        this.recargar();
+    }
+    /**
+     * Marca la credencial como enfriada hasta `hastaEpoch` (ms). Si ya había
+     * una entrada, gana la más lejana: dos clientes que reportan 429 con
+     * Retry-After distintos no deben acortar el descanso que el proveedor pidió.
+     */
+    marcarEnfriada(huella, hastaEpoch, motivo) {
+        const previa = this.entradas.get(huella);
+        if (previa && previa.hasta >= hastaEpoch)
+            return;
+        this.entradas.set(huella, { huella, hasta: hastaEpoch, motivo });
+        this.persistir();
+    }
+    /** `true` si la credencial puede usarse ahora mismo. */
+    disponible(huella, ahora = Date.now()) {
+        return !this.enfriadaHasta(huella, ahora);
+    }
+    /** Epoch hasta el que está enfriada, o `undefined` si está disponible. */
+    enfriadaHasta(huella, ahora = Date.now()) {
+        const entrada = this.entradas.get(huella);
+        if (!entrada)
+            return undefined;
+        if (entrada.hasta <= ahora) {
+            // Expiró: se poda al leerla, para que el fichero no engorde para siempre.
+            this.entradas.delete(huella);
+            this.persistir();
+            return undefined;
+        }
+        return entrada.hasta;
+    }
+    /** Las credenciales enfriadas AHORA (las expiradas se podan antes). */
+    enfriadas(ahora = Date.now()) {
+        const vivas = [];
+        for (const entrada of this.entradas.values()) {
+            if (entrada.hasta > ahora)
+                vivas.push(entrada);
+            else
+                this.entradas.delete(entrada.huella);
+        }
+        if (vivas.length !== this.entradas.size)
+            this.persistir();
+        return vivas;
+    }
+    /**
+     * Relee el fichero de disco. Es lo que un reinicio del broker ejecuta vía
+     * constructor; existe como método público porque la prueba de persistencia
+     * simula el reinicio sobre una segunda instancia sin tirar la primera.
+     */
+    recargar() {
+        this.entradas.clear();
+        if (!this.fichero)
+            return;
+        let crudo;
+        try {
+            crudo = readFileSync(this.fichero, "utf-8");
+        }
+        catch {
+            return; // No existe todavía: arranque limpio, nunca bloquea el broker.
+        }
+        try {
+            const datos = JSON.parse(crudo);
+            if (datos.version !== VERSION_FORMATO || !Array.isArray(datos.enfriadas))
+                return;
+            for (const e of datos.enfriadas) {
+                if (typeof e?.huella === "string" && typeof e?.hasta === "number") {
+                    this.entradas.set(e.huella, { huella: e.huella, hasta: e.hasta, motivo: e.motivo });
+                }
+            }
+        }
+        catch {
+            // Fichero corrupto: mejor arrancar sin enfriamientos que sin broker.
+            this.entradas.clear();
+        }
+    }
+    persistir() {
+        if (!this.fichero)
+            return;
+        const cuerpo = { version: VERSION_FORMATO, enfriadas: [...this.entradas.values()] };
+        writeTextAtomicSync(this.fichero, `${JSON.stringify(cuerpo, null, "\t")}\n`);
+    }
+}
+//# sourceMappingURL=ratelimit.js.map

package/dist/core/credenciales/ratelimit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ratelimit.js","sourceRoot":"","sources":["../../../src/core/credenciales/ratelimit.ts"],"names":[],"mappings":"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"}

package/dist/core/credenciales/reposo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reposo.d.ts","sourceRoot":"","sources":["../../../src/core/credenciales/reposo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAMH,OAAO,KAAK,EAAwB,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAG9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAmE7D;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AA4KD;;;;;;GAMG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC/C,YAAY,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAY3C;CACD;AAwJD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CA4BxG;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACrC,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,MAAyC,GACjD,UAAU,GAAG,SAAS,CAUxB;AAED,8EAA6E;AAC7E,wBAAgB,wBAAwB,IAAI,IAAI,CAK/C;AAED,mFAAkF;AAClF,wBAAgB,mCAAmC,IAAI,IAAI,CAY1D","sourcesContent":["/**\n * Cifrado en reposo de `<agentDir>/auth.json`.\n *\n * EL HUECO: vendemos \"vault cifrado con clasificación y auditoría\"\n * (memory-engine/vault.ts) mientras las claves de API y los tokens OAuth de\n * los proveedores viven en auth.json EN CLARO, con permisos 0600 pero\n * legibles por cualquier proceso del usuario. La política de aprobación\n * (aprobacion/politica.ts) ya le impide leerlo a NUESTRO agente; esto le\n * cierra la puerta a cualquier OTRO proceso.\n *\n * DISEÑO — envolver, no sustituir:\n * `auth-storage.ts` es de upstream y el presupuesto de fork está agotado\n * (ver scripts/sync-ada.sh --check). No podemos reescribir su lectura/\n * escritura de fichero ni su bloqueo entre procesos (proper-lockfile) sin\n * pagar hunks que no tenemos. En vez de eso, ENVOLVEMOS su\n * `AuthStorageBackend`: el interior (`FileAuthStorageBackend`) sigue\n * poseyendo el candado y el `ensureFileExists`/`ensureParentDir`; nosotros\n * solo transformamos el CONTENIDO que entra y sale del candado. Todo el\n * cifrado ocurre DENTRO de la sección crítica del candado que ya existía,\n * así que la seguridad frente a otros procesos de Ada no cambia.\n *\n * CLAVE: un secreto aleatorio de 256 bits en el LLAVERO del sistema (no una\n * passphrase memorizable — nadie va a teclear una contraseña para que el\n * CLI arranque). Se deriva de nada: se genera con randomBytes y se guarda\n * en Keychain la primera vez que hace falta. Sin llavero disponible (CI,\n * contenedor, Linux sin secret-service) NO SE CIFRA: una clave que vive en\n * el mismo disco que el fichero que protege es ofuscación, no cifrado, y\n * llamarlo cifrado sería mentir en la única parte del producto donde no se\n * puede mentir. Se avisa una vez, con una línea clara, y se sigue\n * funcionando en claro (mismo comportamiento que hoy).\n *\n * FORMATO: una cabecera literal al principio del fichero distingue claro de\n * cifrado — nunca adivinamos intentando JSON.parse (un fichero cifrado\n * corrupto a medias podría parsear igual como JSON basura y confundirse con\n * \"en claro\", perdiendo credenciales calladamente).\n *\n * MIGRACIÓN: en cada lectura, si el contenido está en claro se devuelve tal\n * cual (nunca bloquea al llamador) y se agenda un recifrado en segundo\n * plano con `setImmediate` — nunca DENTRO del candado que la propia lectura\n * mantiene abierto, porque volver a pedirlo desde dentro se autobloquearía.\n * En cada escritura (a través del wrapper) se cifra antes de tocar disco,\n * con copia de seguridad y escritura atómica (fichero temporal + rename):\n * si esto corrompe auth.json, el usuario pierde el acceso a TODOS sus\n * proveedores, así que no se sustituye el fichero real hasta que el\n * temporal esté completo en disco.\n */\n\nimport { execFileSync } from \"node:child_process\";\nimport { createCipheriv, createDecipheriv, randomBytes } from \"node:crypto\";\nimport { chmodSync, existsSync, readFileSync, renameSync, statSync, writeFileSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport type { AuthOperationOptions, Credential } from \"@earendil-works/pi-ai\";\nimport { getAgentDir } from \"../../config.ts\";\nimport { stripBom } from \"../../utils/text.ts\";\nimport type { AuthStorageBackend } from \"../auth-storage.ts\";\n\n// ─── Formato: cabecera literal, nunca \"adivinada\" por JSON.parse ───────────\n\nconst CABECERA_CIFRADO = \"ADA-AUTHJSON-CIFRADO-V1\\n\";\n\ninterface SobreCifrado {\n\tiv: string; // base64\n\ttag: string; // base64 (GCM auth tag)\n\tdatos: string; // base64\n}\n\nfunction esFormatoCifrado(contenido: string): boolean {\n\treturn contenido.startsWith(CABECERA_CIFRADO);\n}\n\n// ─── Llavero del sistema (macOS Keychain vía `security`, sin bindings nativos) ───\n\nconst SERVICIO_LLAVERO_PRODUCCION = \"ada-cli-credenciales\";\nconst CUENTA_LLAVERO = \"auth-json-clave-maestra\";\nconst TIMEOUT_LLAVERO_MS = 5_000;\n\n/**\n * Bajo qué nombre vive la clave maestra en el llavero REAL de la máquina.\n *\n * Se puede sustituir por entorno porque las pruebas de este módulo necesitan un\n * llavero de verdad —no hay bindings nativos que fingir, y fingir `execFileSync`\n * probaría el mock, no el Keychain— y hasta ahora usaban la entrada de\n * PRODUCCIÓN. Con `__eliminarClaveDeLlaveroParaPruebas()` en su `afterEach`,\n * cada corrida de la suite BORRABA la clave maestra del usuario y creaba otra.\n *\n * Lo que eso deja detrás no es un inconveniente: el `~/.ada/agent/auth.json`\n * del usuario quedó cifrado con la clave anterior, así que pasa a ser\n * indescifrable PARA SIEMPRE, y su `.bak` también (se recifra con la misma\n * clave). Medido en esta máquina, con la huella SHA-256 de la clave del\n * llavero antes y después:\n *\n *     == antes ==                        15900260def30338\n *     npx vitest --run test/commit-mensaje.test.ts\n *     == después ==                      15900260def30338   (intacta)\n *     npx vitest --run test/credenciales-reposo.test.ts\n *     == después ==                      c8b382bb95b2285b   (OTRA)\n *\n * Y AGENTS.md manda ejecutar la suite antes de dar nada por terminado, así que\n * el flujo de trabajo del propio proyecto rompía las credenciales del usuario.\n *\n * Falla CERRADO bajo vitest: si alguien quita el ajuste de `vitest.config.ts`,\n * las pruebas del llavero se caen con este mensaje en vez de volver\n * calladamente a morder la entrada de producción.\n */\nfunction servicioLlavero(): string {\n\tconst propio = process.env.ADA_LLAVERO_SERVICIO;\n\tif (propio) return propio;\n\tif (process.env.VITEST) {\n\t\tthrow new Error(\n\t\t\t\"Una prueba ha intentado usar la entrada de llavero de PRODUCCIÓN \" +\n\t\t\t\t`(\"${SERVICIO_LLAVERO_PRODUCCION}\"). Eso borra la clave maestra del usuario y deja su ` +\n\t\t\t\t\"auth.json indescifrable. Define ADA_LLAVERO_SERVICIO (lo hace vitest.config.ts).\",\n\t\t);\n\t}\n\treturn SERVICIO_LLAVERO_PRODUCCION;\n}\n\nfunction esMacOS(): boolean {\n\treturn typeof process !== \"undefined\" && process.platform === \"darwin\";\n}\n\n/**\n * True cuando hay un llavero de sistema utilizable en esta máquina.\n *\n * `ADA_SIN_LLAVERO=1` fuerza \"no disponible\" aunque estemos en macOS — es la\n * única forma de probar de verdad la rama \"sin llavero\" (headless/CI) sin\n * necesitar una máquina Linux, y también sirve de escape manual para quien\n * quiera desactivar el uso del Keychain explícitamente.\n */\nexport function hayLlaveroDisponible(): boolean {\n\treturn esMacOS() && process.env.ADA_SIN_LLAVERO !== \"1\";\n}\n\n/**\n * Tres estados, y la diferencia entre el segundo y el tercero costó las\n * credenciales de esta máquina.\n *\n * Antes esto devolvía `Buffer | null` y `null` significaba a la vez «todavía no\n * hay clave» y «no he podido leerla». Quien llamaba entendía lo primero,\n * generaba una clave nueva y la guardaba con `-U` (sobrescribir). Un fallo\n * PASAJERO de `security` —un tiempo de espera agotado con la máquina cargada,\n * el llavero bloqueado— bastaba para rotar la clave maestra y dejar\n * PERMANENTEMENTE ilegible todo `auth.json` cifrado con la anterior.\n *\n * Pasó de verdad el 2026-08-24 sobre `~/.ada/agent/auth.json`: seis\n * proveedores perdidos, sin recuperación posible, porque el llavero de macOS no\n * guarda historial.\n *\n * Es la familia de siempre —«no puedo» leído como «no hay»— pero aquí no\n * informa mal: DESTRUYE DATOS. Por eso son tres estados y no dos.\n */\ntype LecturaDeClave =\n\t| { estado: \"leida\"; clave: Buffer }\n\t| { estado: \"no-existe\" }\n\t| { estado: \"error\"; motivo: string };\n\n/** `security` devuelve 44 (errSecItemNotFound) cuando la entrada no está. */\nconst CODIGO_NO_ENCONTRADO = 44;\n\nfunction leerClaveDelLlavero(): LecturaDeClave {\n\tif (!hayLlaveroDisponible()) return { estado: \"no-existe\" };\n\t// Fuera del try a propósito: si `servicioLlavero()` se planta porque una\n\t// prueba iba a morder la entrada de producción, ese error tiene que SALIR.\n\t// Dentro del try acabaría clasificado como un `estado: \"error\"` cualquiera,\n\t// y lo que hay que hacer con él es parar, no seguir sin cifrar.\n\tconst servicio = servicioLlavero();\n\tlet salida: string;\n\ttry {\n\t\tsalida = execFileSync(\n\t\t\t\"/usr/bin/security\",\n\t\t\t[\"find-generic-password\", \"-s\", servicio, \"-a\", CUENTA_LLAVERO, \"-w\"],\n\t\t\t// stdio \"pipe\" en los tres canales: sin esto, `security` hereda\n\t\t\t// nuestro stderr y el \"could not be found in the keychain\" (normal\n\t\t\t// en el primer arranque, antes de crear la clave) se ve como si\n\t\t\t// algo hubiera ido mal.\n\t\t\t{ timeout: TIMEOUT_LLAVERO_MS, encoding: \"utf-8\", windowsHide: true, stdio: [\"pipe\", \"pipe\", \"pipe\"] },\n\t\t).trim();\n\t} catch (error) {\n\t\tconst e = error as NodeJS.ErrnoException & { status?: number | null };\n\t\tif (e.status === CODIGO_NO_ENCONTRADO) return { estado: \"no-existe\" };\n\t\t// Todo lo demás es un fallo del que NO se puede deducir que no haya\n\t\t// clave: tiempo agotado (`ETIMEDOUT`), llavero bloqueado, `security`\n\t\t// que no arranca. Rotar aquí es lo que destruyó las credenciales.\n\t\treturn { estado: \"error\", motivo: e.code ?? `security salió con ${e.status}` };\n\t}\n\tif (!salida) return { estado: \"error\", motivo: \"el llavero devolvió una entrada vacía\" };\n\tconst clave = Buffer.from(salida, \"base64\");\n\t// Una entrada presente pero con el tamaño equivocado también es un error, no\n\t// una ausencia: sobrescribirla tiraría la clave buena si el fallo está en la\n\t// lectura y no en el dato.\n\tif (clave.length !== 32)\n\t\treturn { estado: \"error\", motivo: `la clave del llavero mide ${clave.length} bytes, no 32` };\n\treturn { estado: \"leida\", clave };\n}\n\nfunction guardarClaveEnLlavero(clave: Buffer): boolean {\n\tif (!hayLlaveroDisponible()) return false;\n\tconst servicio = servicioLlavero(); // fuera del try: ver `leerClaveDelLlavero`\n\ttry {\n\t\t// -w sin valor en argv: la contraseña se pasa por stdin para que no quede\n\t\t// visible en `ps`/el historial del proceso (mismo patrón que\n\t\t// memory-engine/keychain.ts). Comprobado a mano: `security` pide el valor\n\t\t// DOS VECES por stdin (password + confirmación) aunque no haya terminal;\n\t\t// una sola línea deja la segunda lectura vacía y falla con \"passwords\n\t\t// don't match\".\n\t\tconst valor = clave.toString(\"base64\");\n\t\texecFileSync(\n\t\t\t\"/usr/bin/security\",\n\t\t\t// SIN `-U`. Con `-U` esto SOBRESCRIBE la entrada existente, y ese es el\n\t\t\t// segundo camino por el que se perdieron las credenciales de esta\n\t\t\t// máquina: un fallo de lectura hacía creer que no había clave y este\n\t\t\t// `-U` remataba tirando la buena. Sin él, `security` falla si ya existe,\n\t\t\t// que es justo la señal que quien llama necesita para releer.\n\t\t\t//\n\t\t\t// El PRIMER camino lo encontró la revisión de `hueco-commit` y es\n\t\t\t// distinto: las pruebas de este módulo borraban la entrada de\n\t\t\t// PRODUCCIÓN en su `afterEach`. Los dos arreglos hacen falta —\n\t\t\t// `servicioLlavero()` impide que una prueba toque la clave real, y esto\n\t\t\t// impide que un fallo pasajero la rote.\n\t\t\t[\"add-generic-password\", \"-s\", servicio, \"-a\", CUENTA_LLAVERO, \"-w\"],\n\t\t\t{\n\t\t\t\ttimeout: TIMEOUT_LLAVERO_MS,\n\t\t\t\twindowsHide: true,\n\t\t\t\tinput: `${valor}\\n${valor}\\n`,\n\t\t\t\tstdio: [\"pipe\", \"pipe\", \"pipe\"],\n\t\t\t},\n\t\t);\n\t\treturn true;\n\t} catch {\n\t\treturn false;\n\t}\n}\n\nlet claveEnCache: Buffer | null | undefined; // undefined = aún no consultada\n\n/**\n * Clave maestra. `null` = no hay llavero en esta máquina (CI, contenedor), que\n * es el caso legítimo de \"no se cifra\". **Lanza** si el llavero está pero no se\n * ha podido leer: ahí seguir sería inventarse una clave nueva y perder lo\n * cifrado con la anterior.\n */\nfunction obtenerOCrearClave(): Buffer | null {\n\tif (!hayLlaveroDisponible()) return null;\n\tif (claveEnCache !== undefined) return claveEnCache;\n\n\tconst lectura = leerClaveDelLlavero();\n\tif (lectura.estado === \"leida\") {\n\t\tclaveEnCache = lectura.clave;\n\t\treturn claveEnCache;\n\t}\n\tif (lectura.estado === \"error\") {\n\t\t// Fallar cerrado. Un error aquí NO se cachea: el fallo puede ser pasajero\n\t\t// y el siguiente intento debe volver a preguntarle al llavero.\n\t\tthrow new Error(\n\t\t\t`No se ha podido leer la clave maestra del llavero (${lectura.motivo}).\\n` +\n\t\t\t\t\"No se genera una nueva a propósito: eso dejaría ilegible para siempre el auth.json\\n\" +\n\t\t\t\t\"ya cifrado. Desbloquea el llavero y vuelve a intentarlo, o exporta ADA_SIN_LLAVERO=1\\n\" +\n\t\t\t\t\"para trabajar sin cifrado en reposo.\",\n\t\t);\n\t}\n\n\t// No existe: primera vez. Se crea SIN `-U`, para que dos procesos a la vez no\n\t// se pisen — quien pierde la carrera relee en vez de sobrescribir.\n\tconst nueva = randomBytes(32);\n\tif (guardarClaveEnLlavero(nueva)) {\n\t\tclaveEnCache = nueva;\n\t\treturn claveEnCache;\n\t}\n\tconst segunda = leerClaveDelLlavero();\n\tif (segunda.estado === \"leida\") {\n\t\tclaveEnCache = segunda.clave;\n\t\treturn claveEnCache;\n\t}\n\t// Ni se pudo crear ni leer: sin llavero utilizable. Se deja sin cifrar, que\n\t// es el comportamiento documentado, y se avisa una vez.\n\tclaveEnCache = null;\n\treturn null;\n}\n\n// ─── AES-256-GCM ────────────────────────────────────────────────────────────\n\nfunction cifrar(contenidoClaro: string, clave: Buffer): string {\n\tconst iv = randomBytes(12);\n\tconst cipher = createCipheriv(\"aes-256-gcm\", clave, iv);\n\tconst datos = Buffer.concat([cipher.update(contenidoClaro, \"utf-8\"), cipher.final()]);\n\tconst sobre: SobreCifrado = {\n\t\tiv: iv.toString(\"base64\"),\n\t\ttag: cipher.getAuthTag().toString(\"base64\"),\n\t\tdatos: datos.toString(\"base64\"),\n\t};\n\treturn CABECERA_CIFRADO + JSON.stringify(sobre);\n}\n\nfunction descifrar(contenidoFichero: string, clave: Buffer): string {\n\tconst sobre = JSON.parse(contenidoFichero.slice(CABECERA_CIFRADO.length)) as SobreCifrado;\n\tconst decipher = createDecipheriv(\"aes-256-gcm\", clave, Buffer.from(sobre.iv, \"base64\"));\n\tdecipher.setAuthTag(Buffer.from(sobre.tag, \"base64\"));\n\tconst claro = Buffer.concat([decipher.update(Buffer.from(sobre.datos, \"base64\")), decipher.final()]);\n\treturn claro.toString(\"utf-8\");\n}\n\n// ─── Error legible: nunca un stack para un fichero dañado ─────────────────\n\n/**\n * auth.json cifrado que no se puede leer: auth tag inválido, JSON del sobre\n * truncado, o llavero sin la clave que lo cifró (p.ej. copiado desde otra\n * máquina). \"no he podido leerlo\" y \"no hay credenciales\" son cosas\n * distintas: esto SIEMPRE es lo primero, nunca se confunde con un auth.json\n * vacío legítimo.\n */\nexport class AuthJsonCorruptoError extends Error {\n\tconstructor(authPath: string, causa: unknown) {\n\t\tsuper(\n\t\t\t`auth.json está cifrado pero no se ha podido leer (${authPath}).\\n` +\n\t\t\t\t`Puede estar dañado, o cifrado con la clave de otra máquina.\\n` +\n\t\t\t\t`Qué hacer:\\n` +\n\t\t\t\t`  1. Si existe una copia de seguridad, restáurala:\\n` +\n\t\t\t\t`       cp \"${authPath}.bak\" \"${authPath}\"\\n` +\n\t\t\t\t`  2. Si no, vuelve a iniciar sesión con cada proveedor:\\n` +\n\t\t\t\t`       ada-cli auth login <proveedor>\\n` +\n\t\t\t\t(causa instanceof Error ? `(detalle técnico: ${causa.message})` : \"\"),\n\t\t);\n\t\tthis.name = \"AuthJsonCorruptoError\";\n\t}\n}\n\n// ─── Escritura: copia de seguridad + atómica (temporal + rename) ──────────\n\nfunction escrituraAtomicaConCopia(authPath: string, contenido: string, contenidoParaCopia?: string): void {\n\t// El permiso del fichero (0600, o 0660 si un administrador lo gestiona) es\n\t// intencional y no es nuestro para decidir — igual que\n\t// AUTH_FILE_WRITE_OPTIONS en auth-storage.ts, que solo fija el modo al\n\t// CREAR. Un rename sustituye el inodo entero, así que sin esto el permiso\n\t// original se perdería silenciosamente en cada recifrado.\n\tconst modoExistente = existsSync(authPath) ? statSync(authPath).mode & 0o777 : 0o600;\n\t// Copia ANTES de tocar el fichero real: si el rename de abajo no llegara a\n\t// completarse (disco lleno a mitad, proceso matado entre write y rename),\n\t// .bak es la única vía para no perder el acceso a TODOS los proveedores.\n\t//\n\t// `contenidoParaCopia` (si se pasa) sustituye lo que hay en disco: la\n\t// primera migración de un auth.json en claro pasa por aquí con el fichero\n\t// TODAVÍA en claro sobre disco, y una copia literal (`readFileSync`)\n\t// dejaría el secreto en claro para siempre en `.bak` — con el mismo modo\n\t// 0600 que el propio auth.json ya tenía, así que no cierra nada: reabre\n\t// exactamente el agujero que este módulo existe para tapar. Quien llama\n\t// (`escribirConCifradoSiHayClave`) cifra ese contenido antes de pasarlo.\n\tif (existsSync(authPath)) {\n\t\tconst backupPath = `${authPath}.bak`;\n\t\twriteFileSync(backupPath, contenidoParaCopia ?? readFileSync(authPath), { mode: modoExistente });\n\t\tchmodSync(backupPath, modoExistente); // mismo motivo que el temporal: el umask no debe recortar el modo\n\t}\n\tconst tmpPath = `${authPath}.tmp-${process.pid}-${Date.now()}`;\n\twriteFileSync(tmpPath, contenido, { encoding: \"utf-8\", mode: modoExistente });\n\t// El `mode` de writeFileSync pasa por el umask del proceso al CREAR un\n\t// fichero (0660 con umask 022 se queda en 0640) — algo que un `writeFileSync`\n\t// normal sobre un fichero YA existente no sufre, porque el modo se ignora\n\t// del todo si no hay creación. Como el temporal siempre es nuevo, hace\n\t// falta un chmod explícito (ignora el umask) para replicar ese mismo\n\t// comportamiento y no perder un modo gestionado por un administrador.\n\tchmodSync(tmpPath, modoExistente);\n\trenameSync(tmpPath, authPath); // rename es atómico dentro del mismo filesystem\n}\n\nlet avisoSinLlaveroMostrado = false;\n\n/** Se llama tanto al detectar un fichero en claro sin poder cifrarlo como al querer escribir sin llavero. */\nfunction avisarSinLlaveroUnaVez(): void {\n\tif (avisoSinLlaveroMostrado) return;\n\tavisoSinLlaveroMostrado = true;\n\tconsole.error(\n\t\t`[ada] auth.json NO se cifra: no hay llavero del sistema disponible en esta máquina ` +\n\t\t\t`(CI, contenedor, o Linux sin secret-service). Una clave guardada en el mismo disco que ` +\n\t\t\t`el fichero que protege sería ofuscación, no cifrado — se deja en claro con permisos 0600, ` +\n\t\t\t`como hasta ahora.`,\n\t);\n}\n\nfunction escribirConCifradoSiHayClave(authPath: string, contenidoClaro: string): void {\n\tconst clave = obtenerOCrearClave();\n\tif (!clave) {\n\t\tavisarSinLlaveroUnaVez();\n\t\tescrituraAtomicaConCopia(authPath, contenidoClaro);\n\t\treturn;\n\t}\n\t// Si lo que hay AHORA en disco está en claro (primera migración), la copia\n\t// de seguridad se cifra también con la misma clave — en vez de dejar que\n\t// `escrituraAtomicaConCopia` copie los bytes tal cual. `.bak` sigue\n\t// sirviendo para recuperar de una escritura a medias: al restaurarlo,\n\t// `decodificarParaLectura` reconoce la cabecera y lo descifra igual que al\n\t// auth.json real.\n\tconst actual = existsSync(authPath) ? readFileSync(authPath, \"utf-8\") : undefined;\n\tconst copiaSegura = actual !== undefined && !esFormatoCifrado(actual) ? cifrar(actual, clave) : actual;\n\tescrituraAtomicaConCopia(authPath, cifrar(contenidoClaro, clave), copiaSegura);\n}\n\nlet avisoCorruptoMostrado = false;\n\n/**\n * `AuthStorage.reload()` (upstream, `auth-storage.ts`) atrapa CUALQUIER error\n * de su backend y lo trata como \"transitorio, conserva el último estado\n * bueno\" — y sin `signal`, `readLatestData()` hace lo mismo. Si solo\n * lanzáramos, ese catch se come el error y el llamador ve \"no hay\n * credenciales\" en vez de \"no he podido leerlas\": exactamente la confusión\n * que no puede pasar (ver AGENTS.md, regla de errores). Por eso esto SIEMPRE\n * imprime la guía en stderr, una vez, ANTES de lanzar: quien atrape la\n * excepción se la queda para sí, pero el aviso ya salió por su cuenta.\n */\nfunction lanzarCorrupto(authPath: string, causa: unknown): never {\n\tconst error = new AuthJsonCorruptoError(authPath, causa);\n\tif (!avisoCorruptoMostrado) {\n\t\tavisoCorruptoMostrado = true;\n\t\tconsole.error(`[ada] ${error.message}`);\n\t}\n\tthrow error;\n}\n\n/** Descifra si hace falta; el contenido en claro se devuelve tal cual, sin adivinar. */\nfunction decodificarParaLectura(authPath: string, contenidoBruto: string | undefined): string | undefined {\n\tif (contenidoBruto === undefined || !esFormatoCifrado(contenidoBruto)) return contenidoBruto;\n\tconst clave = obtenerOCrearClave();\n\tif (!clave) {\n\t\tlanzarCorrupto(\n\t\t\tauthPath,\n\t\t\tnew Error(\"el fichero está cifrado pero no hay llavero disponible para descifrarlo aquí\"),\n\t\t);\n\t}\n\ttry {\n\t\treturn descifrar(contenidoBruto, clave);\n\t} catch (error) {\n\t\tlanzarCorrupto(authPath, error);\n\t}\n}\n\n// ─── Migración en segundo plano (nunca dentro del candado de la lectura) ──\n\nconst migracionEnCursoPara = new Set<string>();\n\nfunction programarMigracionEnSegundoPlano(interno: AuthStorageBackend, authPath: string): void {\n\tif (!hayLlaveroDisponible()) {\n\t\t// Sin llavero no hay nada que recifrar: pedir el candado igualmente\n\t\t// solo para reescribir el mismo texto en claro es trabajo (y contención\n\t\t// entre procesos) sin beneficio. Basta con avisar.\n\t\tavisarSinLlaveroUnaVez();\n\t\treturn;\n\t}\n\tif (migracionEnCursoPara.has(authPath)) return; // ya hay una en vuelo; la lectura repetida no acumula trabajo\n\tmigracionEnCursoPara.add(authPath);\n\t// setImmediate: la lectura que detectó \"en claro\" todavía mantiene el\n\t// candado de `interno` abierto en su propia pila de llamadas. Pedirlo de\n\t// nuevo aquí mismo se autobloquearía; con setImmediate se agenda para\n\t// DESPUÉS de que esa lectura suelte el candado.\n\tsetImmediate(() => {\n\t\tvoid interno\n\t\t\t.withLockAsync(async (actual) => {\n\t\t\t\tif (actual === undefined || esFormatoCifrado(actual)) {\n\t\t\t\t\treturn { result: undefined }; // otro proceso ya migró, o no hay nada que migrar\n\t\t\t\t}\n\t\t\t\tescribirConCifradoSiHayClave(authPath, actual);\n\t\t\t\t// Ya escribimos nosotros mismos (copia + atómico); devolver `next`\n\t\t\t\t// aquí haría que el backend interno reescribiera SIN copia de\n\t\t\t\t// seguridad, pisando la que acabamos de crear.\n\t\t\t\treturn { result: undefined };\n\t\t\t}, {})\n\t\t\t.catch((error) => {\n\t\t\t\tconsole.error(\n\t\t\t\t\t`[ada] no se pudo recifrar auth.json en segundo plano: ${error instanceof Error ? error.message : String(error)}`,\n\t\t\t\t);\n\t\t\t})\n\t\t\t.finally(() => {\n\t\t\t\tmigracionEnCursoPara.delete(authPath);\n\t\t\t});\n\t});\n}\n\n// ─── El wrapper ─────────────────────────────────────────────────────────────\n\n/**\n * Envuelve un `AuthStorageBackend` (normalmente un `FileAuthStorageBackend`\n * ya construido, que sigue poseyendo el candado entre procesos) para que\n * cifre/descifre en reposo de forma transparente para quien lo use.\n */\nexport function envolverBackendCifrado(interno: AuthStorageBackend, authPath: string): AuthStorageBackend {\n\treturn {\n\t\twithLock<T>(fn: (current: string | undefined) => { result: T; next?: string }): T {\n\t\t\treturn interno.withLock((actual) => {\n\t\t\t\tconst claro = decodificarParaLectura(authPath, actual);\n\t\t\t\tif (actual !== undefined && !esFormatoCifrado(actual)) {\n\t\t\t\t\tprogramarMigracionEnSegundoPlano(interno, authPath);\n\t\t\t\t}\n\t\t\t\tconst { result, next } = fn(claro);\n\t\t\t\tif (next !== undefined) escribirConCifradoSiHayClave(authPath, next);\n\t\t\t\treturn { result }; // `next` siempre undefined hacia `interno`: la escritura ya ocurrió arriba\n\t\t\t});\n\t\t},\n\t\tasync withLockAsync<T>(\n\t\t\tfn: (current: string | undefined) => Promise<{ result: T; next?: string }>,\n\t\t\toptions?: AuthOperationOptions,\n\t\t): Promise<T> {\n\t\t\treturn interno.withLockAsync(async (actual) => {\n\t\t\t\tconst claro = decodificarParaLectura(authPath, actual);\n\t\t\t\tif (actual !== undefined && !esFormatoCifrado(actual)) {\n\t\t\t\t\tprogramarMigracionEnSegundoPlano(interno, authPath);\n\t\t\t\t}\n\t\t\t\tconst { result, next } = await fn(claro);\n\t\t\t\tif (next !== undefined) escribirConCifradoSiHayClave(authPath, next);\n\t\t\t\treturn { result };\n\t\t\t}, options);\n\t\t},\n\t};\n}\n\n/**\n * Lectura síncrona de UNA credencial ya guardada, descifrando si hace falta.\n *\n * Sustituye a `readStoredCredential` (upstream, `auth-storage.ts`), exportada\n * en `index.ts` como parte de la API pública del SDK (`@hoilab/ada-cli`) para\n * lecturas puntuales sin instanciar `AuthStorage`. Esa función hace su propio\n * `readFileSync` + `JSON.parse` sin pasar por este módulo: con auth.json ya\n * migrado a cifrado, la cabecera `ADA-AUTHJSON-CIFRADO-V1\\n` delante del JSON\n * hace que `JSON.parse` lance un `SyntaxError` que su `catch { return\n * undefined; }` convierte en \"no hay credencial\" — indistinguible de un\n * proveedor sin configurar, para CUALQUIER consumidor de esta función\n * pública, presente o futuro. Mismo nombre y misma firma (con el mismo valor\n * por defecto de `authPath`) para seguir siendo un reemplazo directo.\n */\nexport function leerCredencialGuardada(\n\tproviderId: string,\n\tauthPath: string = join(getAgentDir(), \"auth.json\"),\n): Credential | undefined {\n\ttry {\n\t\tconst bruto = stripBom(readFileSync(authPath, \"utf-8\"));\n\t\tconst claro = decodificarParaLectura(authPath, bruto);\n\t\tif (claro === undefined) return undefined;\n\t\tconst datos = JSON.parse(claro) as Record<string, Credential>;\n\t\treturn datos[providerId];\n\t} catch {\n\t\treturn undefined;\n\t}\n}\n\n/** Solo para pruebas: limpia el estado en memoria del módulo entre casos. */\nexport function __resetEstadoParaPruebas(): void {\n\tclaveEnCache = undefined;\n\tavisoSinLlaveroMostrado = false;\n\tavisoCorruptoMostrado = false;\n\tmigracionEnCursoPara.clear();\n}\n\n/** Solo para pruebas: borra la clave maestra del llavero real de esta máquina. */\nexport function __eliminarClaveDeLlaveroParaPruebas(): void {\n\tif (!esMacOS()) return;\n\tconst servicio = servicioLlavero(); // fuera del try: ver `leerClaveDelLlavero`\n\ttry {\n\t\texecFileSync(\"/usr/bin/security\", [\"delete-generic-password\", \"-s\", servicio, \"-a\", CUENTA_LLAVERO], {\n\t\t\ttimeout: TIMEOUT_LLAVERO_MS,\n\t\t\twindowsHide: true,\n\t\t\tstdio: [\"pipe\", \"pipe\", \"pipe\"],\n\t\t});\n\t} catch {\n\t\t// no había clave que borrar\n\t}\n}\n"]}
+{"version":3,"file":"reposo.d.ts","sourceRoot":"","sources":["../../../src/core/credenciales/reposo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAMH,OAAO,KAAK,EAAwB,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAG9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAmE7D;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C;AA4KD;;;;;;GAMG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;gBACnC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;CAa5C;AAwJD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,GAAG,kBAAkB,CA4BxG;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACrC,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,MAAyC,GACjD,UAAU,GAAG,SAAS,CAUxB;AAED,6EAA6E;AAC7E,wBAAgB,wBAAwB,IAAI,IAAI,CAK/C;AAED,kFAAkF;AAClF,wBAAgB,mCAAmC,IAAI,IAAI,CAY1D"}