chocolatito-code 1.6.6 → 1.6.8

package/dist/ui/pantalla.js

@@ -1,139 +1,197 @@
 import process from "node:process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
+import { format } from "node:util";
 import { redirigirDibujo } from "./salida.js";
-import { apuntar } from "./historial.js";
+import { anotar } from "./ink/transcripcion.js";
 import { habilitarPie } from "./pieFijo.js";
+import { limpiarLaPantalla } from "./ink/montarApp.js";
 /**
- * LA PANTALLA ALTERNATIVA
+ * QUIÉN ES DUEÑO DE LA PANTALLA
  *
- * La barra de abajo sube al hacer scroll porque ES una línea del historial del
- * terminal, no una capa encima. Ninguna secuencia de escape la clava ahí; lo
- * único que lo consigue es que el programa tome la pantalla entera, como hacen
- * vim o htop.
+ * LO QUE HABÍA AQUÍ ANTES, Y POR QUÉ SE FUE
  *
- * QUÉ CAMBIA AL ENTRAR
+ * Este archivo tomaba la pantalla alternativa —la de vim o htop— para clavar la
+ * barra de abajo. Es la única forma de clavarla de verdad, y se pidió cinco
+ * veces, así que se hizo. Se publicó rota dos veces: "no sale nada, se bugea" y
+ * "sale una barra y lo demás negro, escribo y se cierra".
  *
- * El terminal deja de guardar historial: la rueda del ratón no sirve y al salir
- * la sesión desaparece de la consola. Por eso, mientras dura, TODO lo que se
- * imprime se guarda en memoria (historial.ts) y lo pinta el árbol de Ink.
+ * Y resultó que además era la arquitectura equivocada. Claude Code, que era el
+ * ejemplo a copiar, NO usa la pantalla alternativa: renderiza en el buffer
+ * normal y emite la conversación con `<Static>` de Ink, que la escribe una vez y
+ * la deja en el historial del terminal. Por eso allí la rueda del ratón funciona.
+ * Y por eso allí la barra tampoco se queda quieta si subes: se va con el resto.
  *
- * Y por eso hay que interceptar también `console.log`. Aquí no vale con desviar
- * el conducto de dibujo: media docena de sitios —el arranque, la licencia, los
- * avisos— siguen imprimiendo directo, y en la pantalla alternativa eso escribe
- * encima de lo que Ink acaba de dibujar y descuadra el árbol entero.
+ * QUÉ HACE AHORA
  *
- * EL INTERCAMBIO
+ * Enciende el modo de árbol único: un solo componente de Ink vivo toda la
+ * sesión, en la pantalla de siempre. Lo que cambia respecto al modo clásico:
  *
- * Cambiar el historial del terminal por uno propio no es gratis: quien use la
- * rueda del ratón para releer sale perdiendo, y a cambio se recorre con Re Pág
- * y Av Pág. Se pidió así cinco veces, así que va de serie;
- * CHOCOLATITO_PANTALLA=normal devuelve lo de antes.
+ *   - El dibujo del agente deja de ir al terminal y entra en la transcripción,
+ *     que es lo que `<Static>` va escribiendo (ink/transcripcion.ts).
+ *   - `pieFijo` deja de pintar. Sigue guardando el spinner y la línea de
+ *     razonamiento, pero quien los dibuja pasa a ser el árbol. Dos dueños del
+ *     mismo trozo de pantalla es el problema que esto viene a quitar.
+ *
+ * Y SE SIGUE INTERCEPTANDO `console`, PERO POR OTRO MOTIVO
+ *
+ * Ink trae su propio `patchConsole`, y hace lo correcto: borra su marco, escribe
+ * el mensaje y repinta debajo. Aquí no se usa, y no es por desconfianza: es por
+ * el ORDEN.
+ *
+ * Lo que escribe el agente entra en la transcripción y sale cuando React confirma
+ * el dibujado. Un `console.log` con el parche de Ink sale en el acto. Dos caminos
+ * con tiempos distintos para el mismo hilo de conversación, y entonces el aviso
+ * de un hook puede aparecer por encima de la frase que lo provocó. Es de los
+ * fallos que no se notan hasta que confundes a alguien.
+ *
+ * Mandando los dos por la transcripción hay una sola cola y el orden es el de
+ * verdad. Se cubren `log`, `error`, `warn` e `info` —el parche de antes solo
+ * cubría `log`— y se formatea con `util.format`, que es lo que hace `console` de
+ * serie: sin eso, un `console.log("%s pruebas", 12)` sale con el `%s` puesto.
  */
-const ENTRAR = "\x1b[?1049h";
-const SALIR = "\x1b[?1049l";
 let dentro = false;
-let logOriginal = null;
+const original = {};
 /**
- * Fija SOLO SI SE PIDE. Van dos veces que la pongo de serie y se rompe.
+ * De serie SÍ, desde la 1.6.7, y con salida de emergencia.
+ *
+ * DOS VECES ESTUVO AQUÍ Y DOS VECES SALIÓ ROTO
  *
- * La segunda: "ahora sale una barra y lo demas negro, escribo y se cierra".
+ * La 1.6.0 salió en negro ("no sale nada, se bugea") y la 1.6.5 con "una barra y
+ * lo demás negro, escribo y se cierra". Las dos veces pasaban las 820 pruebas:
+ * un emulador prueba lo que sabe emular, y una consola de verdad hace cosas que
+ * no sabe.
  *
- * La regla que saco de esto, y que no pienso volver a saltarme: esto no vuelve
- * a ser lo normal hasta que el dueño confirme que lo ha visto funcionar en SU
- * consola con la variable puesta. Un emulador -por bueno que sea, y el de
- * tests/terminal.test.mjs lo es- prueba lo que sabe emular. Ha hecho falta que
- * falle dos veces para aprenderlo.
+ * Esta vez el orden fue el otro: se entregó detrás de la variable, el dueño lo
+ * corrió en SU consola, y solo después pasó a ser lo normal. Lo hizo, y lo
+ * aprobó sabiendo lo que no le iba a gustar: que la caja no se queda clavada al
+ * hacer scroll. No se queda porque es texto del terminal, y en Claude Code
+ * tampoco se queda. Es el precio de recuperar la rueda del ratón y el historial.
+ *
+ * CHOCOLATITO_PANTALLA=normal devuelve la interfaz clásica. Existe porque una
+ * consola rara —una que no sea la suya ni la mía— puede seguir haciendo algo que
+ * no habíamos visto, y entonces el usuario necesita poder trabajar hoy, no
+ * esperar al parche.
  */
 export function pantallaFijaPedida() {
-    return process.env.CHOCOLATITO_PANTALLA === "fija";
+    return process.env.CHOCOLATITO_PANTALLA !== "normal";
 }
 /** `null` = manda el estado real. Las pruebas lo fuerzan. */
 let forzado = null;
-/**
- * Enciende o apaga el modo a mano, SIN tocar el terminal.
- *
- * Las pruebas lo necesitan: entrar de verdad escribiría la secuencia de la
- * pantalla alternativa en la consola de quien corre las pruebas y le dejaría el
- * informe en una pantalla que desaparece al acabar.
- */
 export function forzarPantallaFija(valor) {
     forzado = valor;
 }
 export function enPantallaFija() {
     return forzado ?? dentro;
 }
+/**
+ * Enciende el modo de árbol único. Devuelve si de verdad se encendió.
+ *
+ * EL BOOLEANO NO SOBRA, Y SE VOLVIÓ IMPRESCINDIBLE AL PONERLO POR DEFECTO
+ *
+ * Sin terminal —una salida redirigida a un archivo, un `chocolatito "tarea"` en
+ * un script, CI— aquí no se entra. Pero quien llama montaba el árbol de todas
+ * formas, y Ink sin terminal escribe su marco como texto suelto: la salida del
+ * programa sale con la caja de escribir dentro.
+ *
+ * Mientras esto iba detrás de una variable no pasaba nunca, porque nadie la pone
+ * en un script. De serie, es el caso normal.
+ */
 export function entrarEnPantallaFija() {
-    if (dentro || !process.stdout.isTTY)
-        return;
+    if (dentro)
+        return true;
+    if (!process.stdout.isTTY)
+        return false;
     dentro = true;
-    process.stdout.write(ENTRAR);
-    // Lo que se dibujaba en el terminal pasa a ser historial nuestro.
-    redirigirDibujo((texto) => apuntar(texto));
-    // Y el pie deja de pintar. Sigue guardando sus secciones -el spinner y la
-    // linea de razonamiento publican ahi sin enterarse de nada- pero quien las
-    // dibuja pasa a ser el arbol. Dos dueños del mismo trozo de pantalla es
-    // exactamente el problema que esto viene a quitar.
+    // Lo que el agente dibuja pasa a ser texto de la transcripción. De ahí lo
+    // recoge <Static> y lo escribe en el historial del terminal, una sola vez.
+    redirigirDibujo((texto) => anotar(texto));
     habilitarPie(false);
-    logOriginal = console.log;
-    console.log = (...args) => {
-        apuntar(args.map((a) => (typeof a === "string" ? a : String(a))).join(" ") + "\n");
+    interceptarConsola();
+    return true;
+}
+const CANALES = ["log", "error", "warn", "info"];
+/**
+ * `console.clear` va aparte porque no es un mensaje, es una orden al terminal.
+ *
+ * Y estaba fuera de la lista, que era un agujero de los caros: /clear, /cd y el
+ * Ctrl+L del prompt clásico llaman a `console.clear()`, y con el árbol montado
+ * eso borra filas que Ink cree suyas. A partir de ahí Ink repinta sobre un sitio
+ * que ya no existe y lo que se ve es basura.
+ *
+ * Se manda a `limpiarLaPantalla`, que hace lo mismo pero en el orden que no
+ * rompe nada. Ver ui/ink/montarApp.tsx.
+ */
+let clearOriginal = null;
+/**
+ * Manda `console` a la transcripción.
+ *
+ * Se exporta para poder probarlo: `entrarEnPantallaFija` no se puede llamar en
+ * las pruebas porque exige un terminal de verdad, y un parche de consola sin
+ * probar es de las cosas que fallan en silencio —lo que se pierde no se ve, que
+ * es justo el problema—.
+ */
+export function interceptarConsola() {
+    if (original.log)
+        return;
+    clearOriginal = console.clear;
+    console.clear = () => {
+        limpiarLaPantalla();
     };
+    for (const nombre of CANALES) {
+        original[nombre] = console[nombre];
+        console[nombre] = (...args) => {
+            anotar(`${format(...args)}\n`);
+        };
+    }
+}
+export function devolverConsola() {
+    if (clearOriginal) {
+        console.clear = clearOriginal;
+        clearOriginal = null;
+    }
+    for (const nombre of CANALES) {
+        const previo = original[nombre];
+        if (previo)
+            console[nombre] = previo;
+        delete original[nombre];
+    }
 }
 /**
  * Devuelve el terminal como estaba.
  *
- * Se llama al salir del programa, y también si algo revienta: quedarse en la
- * pantalla alternativa deja al usuario en una consola en blanco sin su prompt,
- * y la única salida es cerrar la ventana.
+ * Aquí ya no hay ninguna pantalla que abandonar —esa era la versión de antes—,
+ * pero sí hay que devolver el conducto de dibujo y el pie: si el proceso sigue
+ * vivo después de esto (una prueba, una sesión que cambia de modo) y el dibujo
+ * se queda desviado, todo lo que se escriba va a una transcripción que ya no
+ * pinta nadie.
  */
 export function salirDePantallaFija() {
     if (!dentro)
         return;
     dentro = false;
-    if (logOriginal) {
-        console.log = logOriginal;
-        logOriginal = null;
-    }
     redirigirDibujo(null);
     habilitarPie(null);
-    try {
-        process.stdout.write(SALIR);
-    }
-    catch { }
+    devolverConsola();
 }
 process.on("exit", salirDePantallaFija);
-/**
- * UN ERROR DENTRO DE LA PANTALLA ALTERNATIVA SE PIERDE
+/*
+ * AQUÍ HABÍA UN `unhandledRejection` QUE MATABA EL PROGRAMA. SE HA QUITADO.
+ *
+ * Existía para que un error dentro de la pantalla alternativa no se perdiera al
+ * salir de ella. Pero se registraba al importar el módulo, o sea SIEMPRE, con
+ * pantalla fija o sin ella, y hacía `process.exit(1)`.
  *
- * Y esa es la razon de que no haya podido diagnosticar el negro en dos intentos.
- * Si algo revienta despues de montar el arbol, el mensaje se imprime DENTRO de
- * la pantalla alternativa; acto seguido el proceso sale, `salirDePantallaFija`
- * devuelve la pantalla normal, y el error se va con la que lo contenia.
+ * index.ts tiene su propia red de seguridad para lo mismo, y su criterio es el
+ * contrario y el bueno: "una promesa sin capturar no debería costarle al usuario
+ * la sesión entera, con todo su contexto. Se avisa y se sigue." Node ejecuta los
+ * dos manejadores, pero el de aquí se registraba antes y salía, así que ganaba
+ * siempre.
  *
- * Desde fuera se ve exactamente como lo conto el dueño: una barra, todo negro, y
- * se cierra sin decir nada.
+ * Consecuencia en la versión publicada: cualquier promesa de fondo que fallara
+ * —un servidor MCP que no levanta, el chequeo de licencia, la comprobación de
+ * actualizaciones— cerraba Chocolatito de golpe. Sin mensaje, y sin tener nada
+ * que ver con la interfaz.
  *
- * Aqui se sale de la pantalla PRIMERO y se escribe despues, para que el mensaje
- * quede donde se puede leer. Y se guarda ademas en un archivo, porque en una
- * consola que se cierra sola no da tiempo ni a mirarlo.
+ * Con el buffer normal el motivo original ya no existe: un error impreso se
+ * queda en pantalla, porque no hay ninguna pantalla que se lleve el mensaje al
+ * cerrarse.
  */
-function contarLoQueFallo(err) {
-    salirDePantallaFija();
-    const detalle = err instanceof Error ? `${err.message}\n${err.stack ?? ""}` : String(err);
-    try {
-        fs.writeFileSync(path.join(os.homedir(), ".chocolatito-error.txt"), `${new Date().toISOString()}\n${detalle}\n`, "utf-8");
-    }
-    catch { }
-    process.stderr.write(`\nChocolatito se cerro por un error:\n${detalle}\n`);
-    process.stderr.write(`Guardado en ${path.join(os.homedir(), ".chocolatito-error.txt")}\n`);
-}
-process.on("uncaughtException", (err) => {
-    contarLoQueFallo(err);
-    process.exit(1);
-});
-process.on("unhandledRejection", (err) => {
-    contarLoQueFallo(err);
-    process.exit(1);
-});

package/dist/ui/permissionPrompt.d.ts

@@ -4,23 +4,6 @@ export interface PermissionPromptResult {
     userFeedback?: string;
 }
 export declare function setAutoApprove(value: boolean): void;
-/**
- * DIALOGO DE PERMISO
- *
- * La version anterior tenia dos fallos visibles en cuanto se usaba:
- *
- *  1. Al mover la seleccion subia el cursor 12 lineas fijas, pero la caja mide
- *     entre 10 y 14 segun cuantos detalles tenga. Cada flecha dejaba media caja
- *     huerfana en pantalla, y por eso salian marcos vacios apilados.
- *
- *  2. El titulo llevaba un simbolo de anchura ambigua. El terminal lo pinta
- *     ocupando dos columnas y el calculo del ancho contaba una, asi que el borde
- *     derecho quedaba descuadrado justo en esa linea.
- *
- * Aqui se dibuja la caja a mano, con anchura conocida, y se repinta subiendo
- * exactamente las lineas que se escribieron.
- */
-export declare function askToolPermission(toolName: string, args: Record<string, any>, cwd?: string): Promise<PermissionPromptResult>;
 export declare const PERMISSION_OPTIONS: {
     label: string;
     hint: string;
@@ -33,3 +16,22 @@ export declare const PERMISSION_OPTIONS: {
  * derecho no se ve leyendo el codigo, solo ejecutandolo.
  */
 export declare function buildPermissionBox(toolName: string, args: Record<string, any>, cwd: string, selectedIndex: number, width?: number): string[];
+/**
+ * Se pide el terminal prestado antes de abrir esto.
+ *
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
+ */
+export declare function askToolPermission(toolName: string, args: Record<string, any>, cwd?: string): Promise<PermissionPromptResult>;
+/**
+ * El mismo contenido del dialogo del terminal, sin color y sin marco, para
+ * pintarlo en HTML.
+ *
+ * Se reutiliza `details()` a proposito: dos sitios decidiendo por separado que
+ * hay que enseñar antes de aprobar un borrado acaban discrepando, y el que
+ * discrepa siempre es el que menos se mira.
+ */
+export declare function detallesEnTextoPlano(toolName: string, args: Record<string, any>, cwd?: string): string[];

package/dist/ui/permissionPrompt.js

@@ -3,6 +3,8 @@ import process from "node:process";
 import chalk from "chalk";
 import { cycleMode, describeMode, getMode, modeAnnouncement } from "./modes.js";
 import { isOutsideProject, isSvgSource } from "../config/permissions.js";
+import { conElTerminalPrestado } from "./ink/prestamo.js";
+import { pedirPermisoWeb } from "../servidor/puente.js";
 /**
  * Aprobacion automatica: se activa con --yes / -y o con la variable de entorno
  * CHOCOLATITO_AUTO_APPROVE. Pensada para modo no interactivo y CI.
@@ -27,7 +29,7 @@ export function setAutoApprove(value) {
  * Aqui se dibuja la caja a mano, con anchura conocida, y se repinta subiendo
  * exactamente las lineas que se escribieron.
  */
-export async function askToolPermission(toolName, args, cwd = process.cwd()) {
+async function askToolPermissionDirecto(toolName, args, cwd = process.cwd()) {
     if (autoApprove) {
         return { approved: true };
     }
@@ -351,3 +353,44 @@ function details(toolName, args, cwd, width) {
     out.push({ text: "", length: 0 });
     return out;
 }
+/**
+ * Se pide el terminal prestado antes de abrir esto.
+ *
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
+ */
+export function askToolPermission(toolName, args, cwd = process.cwd()) {
+    // --yes primero: si ya se aprobo todo a mano, no hay que molestar a nadie ni
+    // abrir en el movil un dialogo que se contestaria solo.
+    if (autoApprove)
+        return Promise.resolve({ approved: true });
+    // Con `--servir` y alguien conectado, la pregunta va al navegador. Devuelve
+    // null cuando no hay ningun cliente, y entonces esto sigue como siempre: al
+    // terminal, que es donde hay un humano. Lo que NO pasa nunca es que se apruebe
+    // algo por no tener a quien preguntar.
+    const porWeb = pedirPermisoWeb(toolName, detallesEnTextoPlano(toolName, args, cwd), PERMISSION_OPTIONS);
+    if (porWeb)
+        return porWeb;
+    return conElTerminalPrestado(() => askToolPermissionDirecto(toolName, args, cwd));
+}
+/**
+ * El mismo contenido del dialogo del terminal, sin color y sin marco, para
+ * pintarlo en HTML.
+ *
+ * Se reutiliza `details()` a proposito: dos sitios decidiendo por separado que
+ * hay que enseñar antes de aprobar un borrado acaban discrepando, y el que
+ * discrepa siempre es el que menos se mira.
+ */
+export function detallesEnTextoPlano(toolName, args, cwd = process.cwd()) {
+    const sinColor = (t) => t.replace(/\u001b\[[0-9;]*m/g, "");
+    const kind = classify(toolName, args);
+    return [
+        sinColor(kind.title).trim(),
+        ...details(toolName, args, cwd, 72)
+            .map((d) => sinColor(d.text).trim())
+            .filter((t) => t.length > 0),
+    ];
+}

package/dist/ui/pieFijo.d.ts

@@ -3,7 +3,7 @@
  * pintara donde le tocara, dos productores independientes -el razonamiento y el
  * spinner llegan por caminos distintos- se turnarian el sitio y el pie bailaria.
  */
-declare const ORDEN: readonly ["razonamiento", "spinner", "entrada"];
+declare const ORDEN: readonly ["tareas", "razonamiento", "spinner", "entrada"];
 export type SeccionDelPie = (typeof ORDEN)[number];
 /**
  * Enciende o apaga el pie a mano. Con `null` vuelve a mandar el terminal.

package/dist/ui/pieFijo.js

@@ -54,7 +54,7 @@ const MOSTRAR_CURSOR = "\x1b[?25h";
  * pintara donde le tocara, dos productores independientes -el razonamiento y el
  * spinner llegan por caminos distintos- se turnarian el sitio y el pie bailaria.
  */
-const ORDEN = ["razonamiento", "spinner", "entrada"];
+const ORDEN = ["tareas", "razonamiento", "spinner", "entrada"];
 const secciones = new Map();
 /**
  * Texto permanente que aun no ha recibido su salto de linea.
@@ -219,10 +219,24 @@ function anotar(nombre, lineas) {
  * veces por segundo y la barra de escribir casi nunca cambia entre dos.
  */
 export function fijarSeccion(nombre, lineas) {
-    if (!pieUsable())
-        return;
-    if (anotar(nombre, lineas))
-        repintar("");
+    // DELEGA, Y ESO ARREGLA UN FALLO GORDO
+    //
+    // Antes empezaba con `if (!pieUsable()) return;`, o sea que con el pie apagado
+    // -que es exactamente lo que pasa cuando manda el arbol de Ink- esta funcion no
+    // hacia NADA. Ni guardaba la seccion ni avisaba a quien la pinta.
+    //
+    // Dos consecuencias, las dos visibles:
+    //
+    //   - La linea de razonamiento (el 💭) es el unico sitio que llama aqui
+    //     (ui/reasoningStream.ts:122). Con el arbol montado no salia nunca.
+    //   - `quitarSeccion` pasa por aqui. Asi que `quitarSeccion("spinner")` al
+    //     acabar el turno tampoco hacia nada: el "✳ Trabajando…" se quedaba
+    //     puesto para siempre, mucho despues de que el agente hubiera terminado.
+    //     Eso es lo que se ve como "se queda trabado".
+    //
+    // `fijarSecciones` ya distingue bien las dos cosas -guardar y avisar SIEMPRE,
+    // pintar solo si el pie esta encendido-, asi que aqui basta con delegar.
+    fijarSecciones([[nombre, lineas]]);
 }
 /**
  * Varias secciones de una vez, con UN solo repintado.
@@ -312,6 +326,14 @@ export function soltarPie() {
         return;
     secciones.clear();
     repintar("");
+    // Y se avisa, que si no el arbol sigue pintando una barra que ya no existe
+    // hasta que otra cosa cualquiera le haga redibujar.
+    for (const cb of alCambiarElPie) {
+        try {
+            cb();
+        }
+        catch { }
+    }
 }
 /**
  * Olvida el estado sin tocar la pantalla.

package/dist/ui/renderer.js

@@ -179,6 +179,14 @@ export function formatToolName(name) {
             return "Move";
         case "run_command":
             return "Bash";
+        case "start_background_task":
+            return "BgTask";
+        case "read_task_output":
+            return "TaskOutput";
+        case "list_background_tasks":
+            return "ListTasks";
+        case "stop_background_task":
+            return "StopTask";
         case "list_dir":
             return "ListDir";
         case "grep_search":

package/dist/ui/selector.d.ts

@@ -28,10 +28,12 @@ export interface OpcionDeLista {
     detalle?: string;
 }
 /**
- * Enseña la lista y devuelve el id elegido. `null` si se sale con Esc.
+ * Se pide el terminal prestado antes de abrir esto.
  *
- * Sin terminal no hay nada que elegir: devuelve null en el acto en vez de
- * quedarse esperando una tecla que no va a llegar nunca. Es lo que pasaria al
- * correrlo desde un script o dentro de las pruebas.
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
  */
 export declare function elegirDeLista(titulo: string, opciones: OpcionDeLista[], indiceInicial?: number): Promise<string | null>;

package/dist/ui/selector.js

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import process from "node:process";
 import readline from "node:readline";
 import { dibujar } from "./salida.js";
+import { conElTerminalPrestado } from "./ink/prestamo.js";
 /**
  * Enseña la lista y devuelve el id elegido. `null` si se sale con Esc.
  *
@@ -9,7 +10,7 @@ import { dibujar } from "./salida.js";
  * quedarse esperando una tecla que no va a llegar nunca. Es lo que pasaria al
  * correrlo desde un script o dentro de las pruebas.
  */
-export async function elegirDeLista(titulo, opciones, indiceInicial = 0) {
+async function elegirDeListaDirecto(titulo, opciones, indiceInicial = 0) {
     if (opciones.length === 0)
         return null;
     if (!process.stdin.isTTY)
@@ -89,3 +90,15 @@ export async function elegirDeLista(titulo, opciones, indiceInicial = 0) {
         process.stdin.on("keypress", alPulsar);
     });
 }
+/**
+ * Se pide el terminal prestado antes de abrir esto.
+ *
+ * Con el árbol de Ink montado hay un dueño de la pantalla, y esta función es de
+ * las que necesitan el teclado para ellas solas: escribe directo a stdout y abre
+ * su propia lectura de teclas. Sin el préstamo, las dos cuentas de filas se pisan
+ * y el marco de Ink no se recupera. Sin árbol, `conElTerminalPrestado` ejecuta la
+ * tarea tal cual y no cuesta nada. Ver ui/ink/prestamo.ts.
+ */
+export function elegirDeLista(titulo, opciones, indiceInicial = 0) {
+    return conElTerminalPrestado(() => elegirDeListaDirecto(titulo, opciones, indiceInicial));
+}

package/extension/background.js

@@ -431,6 +431,68 @@ async function setTabOverlay(tabId, activo) {
   }
 }
 
+// Telemetría de red: errores HTTP (>=400) y fallos de conexión por pestaña
+const MAX_NETWORK_ERRORS = 100;
+/** tabId -> Array<{ method: string, url: string, status?: number, error?: string, timestamp: number }> */
+const networkErrorsByTab = new Map();
+
+function registrarErrorRed(tabId, info) {
+  if (!tabId || tabId < 0) return;
+  let lista = networkErrorsByTab.get(tabId);
+  if (!lista) {
+    lista = [];
+    networkErrorsByTab.set(tabId, lista);
+  }
+  lista.push({
+    method: info.method || "GET",
+    url: info.url || "",
+    status: info.status !== undefined ? info.status : (info.statusCode !== undefined ? info.statusCode : undefined),
+    error: info.error || undefined,
+    timestamp: info.timestamp || Date.now(),
+  });
+  if (lista.length > MAX_NETWORK_ERRORS) {
+    lista.shift();
+  }
+}
+
+try {
+  if (typeof chrome !== "undefined" && chrome.webRequest && chrome.webRequest.onCompleted && typeof chrome.webRequest.onCompleted.addListener === "function") {
+    chrome.webRequest.onCompleted.addListener(
+      (details) => {
+        if (details && details.tabId > 0 && details.statusCode >= 400) {
+          registrarErrorRed(details.tabId, {
+            method: details.method,
+            url: details.url,
+            status: details.statusCode,
+            error: `HTTP ${details.statusCode}`,
+            timestamp: Math.round(details.timeStamp || Date.now()),
+          });
+        }
+      },
+      { urls: ["<all_urls>"] }
+    );
+  }
+} catch (_) {}
+
+try {
+  if (typeof chrome !== "undefined" && chrome.webRequest && chrome.webRequest.onErrorOccurred && typeof chrome.webRequest.onErrorOccurred.addListener === "function") {
+    chrome.webRequest.onErrorOccurred.addListener(
+      (details) => {
+        if (details && details.tabId > 0) {
+          registrarErrorRed(details.tabId, {
+            method: details.method,
+            url: details.url,
+            status: undefined,
+            error: details.error || "net::ERR_FAILED",
+            timestamp: Math.round(details.timeStamp || Date.now()),
+          });
+        }
+      },
+      { urls: ["<all_urls>"] }
+    );
+  }
+} catch (_) {}
+
 // D8: Detección y reporte de descargas disparadas por acciones del agente
 const descargasRecientes = [];
 try {
@@ -1012,6 +1074,23 @@ async function handle(msg, st) {
     return res;
   }
 
+  if (cmd === "getConsoleLogs") {
+    const { tabId } = await readTab(msg.tabId, st);
+    const res = await tell(tabId, 0, { cmd: "getConsoleLogs", clear: msg.clear === true });
+    if (!res || !res.ok) throw new Error((res && res.error) || "no se pudieron obtener los logs de consola");
+    return { ok: true, tabId, logs: res.logs || [] };
+  }
+
+  if (cmd === "getNetworkErrors") {
+    const { tabId } = await readTab(msg.tabId, st);
+    const lista = networkErrorsByTab.get(tabId) || [];
+    const errors = [...lista];
+    if (msg.clear === true) {
+      networkErrorsByTab.delete(tabId);
+    }
+    return { ok: true, tabId, errors };
+  }
+
   if (cmd === "eval") {
     // eval ejecuta JavaScript arbitrario en la pagina: puede pulsar, enviar
     // formularios y leerlo todo. Es actuacion, no lectura.
@@ -1138,6 +1217,7 @@ async function handle(msg, st) {
 try {
   chrome.tabs.onRemoved.addListener((tabId) => {
     setTabOverlay(tabId, false);
+    networkErrorsByTab.delete(tabId);
     for (const link of links.values()) {
       if (!link.state) continue;
       link.state.propias.delete(tabId);