chocolatito-code 1.0.0 → 1.2.0

package/dist/tools/runner.js

@@ -27,7 +27,34 @@ import { fileTracker } from "../agent/fileTracker.js";
 import { mcpManager } from "../mcp/manager.js";
 import fs from "node:fs";
 import path from "node:path";
-const skillManager = new SkillManager();
+/**
+ * Un SkillManager por directorio de trabajo.
+ *
+ * Antes habia una unica instancia de modulo creada con `new SkillManager()`, y
+ * eso rompia use_skill de dos formas a la vez:
+ *
+ *  1. El constructor solo arma la lista de directorios; no escanea. Como nadie
+ *     llamaba a scanSkills() sobre ESTA instancia (la que escanea es la de
+ *     index.ts, que es otro objeto con otro Map), la primera use_skill de cada
+ *     proceso caia en la rama de error y devolvia "no se encontro el skill X"
+ *     seguido de una lista donde X aparecia. Solo acertaba al segundo intento,
+ *     porque la propia rama de error llama a getSkillPromptListing() y esa si
+ *     escanea.
+ *
+ *  2. Se construia con process.cwd() capturado al importar el modulo, asi que
+ *     los skills de proyecto (./skills y ./.skills) se resolvian siempre contra
+ *     el directorio de lanzamiento y nunca seguian a un change_dir.
+ */
+const skillManagers = new Map();
+function getSkillManager(cwd) {
+    const key = path.resolve(cwd);
+    let manager = skillManagers.get(key);
+    if (!manager) {
+        manager = new SkillManager(key);
+        skillManagers.set(key, manager);
+    }
+    return manager;
+}
 const memoryManager = new MemoryManager();
 export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, modelName) {
     try {
@@ -44,6 +71,7 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
                 rawResult = setSessionTasks(args.tasks || []);
                 break;
             case "use_skill": {
+                const skillManager = getSkillManager(cwd);
                 const body = skillManager.loadSkillBody(args.skillName);
                 if (body) {
                     rawResult = `--- INSTRUCCIONES DEL SKILL "${args.skillName}" ---\n${body}\n--- FIN DEL SKILL ---`;
@@ -121,8 +149,22 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
                 break;
             }
             case "write_file": {
+                // Sobreescribir un archivo que ya existe es la edicion mas destructiva
+                // que hay: se lleva por delante TODO el contenido anterior. Aun asi era
+                // el unico camino de escritura que no pasaba por el fileTracker, con lo
+                // que la ruta barata para el modelo era justo la insegura: si edit_file
+                // le bloqueaba por no haber leido el archivo, bastaba con reescribirlo
+                // entero para saltarse la comprobacion.
+                //
+                // checkBeforeEdit devuelve null cuando el archivo no existe, asi que
+                // crear uno nuevo sigue sin pedir permiso a nadie.
+                const risk = fileTracker.checkBeforeEdit(args.path, cwd);
+                if (risk) {
+                    rawResult = `Escritura bloqueada: ${risk}`;
+                    break;
+                }
                 globalUndoManager.snapshotFile(args.path, cwd);
-                rawResult = await writeFile(args.path, args.content, cwd);
+                rawResult = await writeFile(args.path, args.content, cwd, args.modo === "anadir" ? "anadir" : "sobrescribir");
                 fileTracker.markWritten(args.path, cwd);
                 const check = validateFileSyntax(args.path, args.content || "");
                 if (!check.valid && check.warning) {
@@ -131,19 +173,30 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
                 break;
             }
             case "create_image":
+                // Era la unica herramienta con efecto en disco sin snapshot: si el
+                // generador pisaba un archivo que ya existia, /undo no lo recuperaba.
+                // Y /undo es justo lo que justifica que las escrituras no pregunten.
+                globalUndoManager.snapshotFile(args.outputPath, cwd);
                 rawResult = await createImage(args.outputPath, args.generatorScript, cwd);
                 break;
             case "web_search":
                 rawResult = await webSearch(args.query);
                 break;
-            case "delete_file":
-                globalUndoManager.snapshotFile(args.path, cwd);
+            case "delete_file": {
+                // El snapshot dice si hay copia. Sobre un directorio (o un archivo
+                // bloqueado) no la hay, y el borrado es definitivo: se avisa aqui en vez
+                // de dejar que /undo finja despues que lo ha devuelto.
+                const copia = globalUndoManager.snapshotFile(args.path, cwd);
                 rawResult = await deleteFile(args.path, cwd);
+                if (copia === "unrestorable" && !rawResult.startsWith("Error")) {
+                    rawResult += "\n⚠ Sin copia de seguridad: /undo no puede revertir este borrado.";
+                }
                 break;
+            }
             case "move_copy_file":
                 globalUndoManager.snapshotFile(args.sourcePath, cwd);
                 globalUndoManager.snapshotFile(args.destinationPath, cwd);
-                rawResult = await moveCopyFile(args.sourcePath, args.destinationPath, args.operation || "move", cwd);
+                rawResult = await moveCopyFile(args.sourcePath, args.destinationPath, args.operation || "move", cwd, args.overwrite === true);
                 break;
             case "run_command":
                 rawResult = await runCommand(args.command, cwd, args.timeout);

package/dist/tools/toolDefsComputer.js

@@ -141,7 +141,12 @@ export const COMPUTER_USE_TOOL = {
                 y: { type: "integer", description: "Coordenada Y en pixeles fisicos." },
                 start_coordinate: { type: "array", items: { type: "integer" }, description: "[x, y] de inicio del arrastre." },
                 text: { type: "string", description: "Texto a escribir." },
-                keys: { type: "string", description: 'Tecla o atajo (ej. "Return", "Escape", "ctrl+s", "alt+Tab").' },
+                keys: {
+                    type: "string",
+                    description: 'Tecla o atajo (ej. "Return", "Escape", "ctrl+s", "alt+Tab"). ' +
+                        "Un atajo no se puede mandar a una ventana de fondo: si pasas window, esa ventana se trae al frente antes de teclear. " +
+                        "Sin window va a lo que el usuario tenga delante.",
+                },
                 repeat: { type: "integer", description: "Veces que repetir la tecla." },
                 direction: { type: "string", enum: ["up", "down", "left", "right"], description: "Direccion del scroll." },
                 amount: { type: "integer", description: "Cantidad de scroll." },
@@ -182,7 +187,12 @@ export const CHROME_TOOL = {
                         "notice: cambia el texto del aviso flotante. close_tab: cierra una pestaña que abriste. done: cierra el trabajo y quita el aviso.",
                 },
                 url: { type: "string", description: "URL para open o navigate." },
-                tabId: { type: "integer", description: "Pestana concreta; por defecto, en la que se esta trabajando." },
+                tabId: {
+                    type: "integer",
+                    description: "Pestana concreta; por defecto, en la que se esta trabajando. " +
+                        "Si no hay ninguna (aun no has hecho open/select_tab, o ya llamaste a done), " +
+                        "navigate, close_tab, press y eval fallan a proposito: no se actua sobre la pestana del usuario.",
+                },
                 ref: { type: "integer", description: "Numero de elemento devuelto por snapshot." },
                 text: { type: "string", description: "Texto a escribir (type) o a esperar (wait_for)." },
                 submit: { type: "boolean", description: "true para pulsar Enter despues de escribir." },

package/dist/tools/truncator.d.ts

@@ -1,4 +1,27 @@
-export declare const MAX_TOOL_OUTPUT_CHARS = 60000;
+/**
+ * Topes de una salida de herramienta antes de recortarla.
+ *
+ * El limite estaba en 60.000 caracteres, que es entre dos y cuatro veces lo que
+ * usan los demas agentes (opencode 50 KB, Cline 48 K, Crush 30 K). El motivo
+ * por el que importa lo explica bien un comentario de Cline: cada caracter que
+ * devuelve una herramienta se REENVIA al modelo en todas las peticiones
+ * posteriores del turno, y el bucle puede dar treinta vueltas. Una salida
+ * gorda no cuesta lo que ocupa: cuesta lo que ocupa multiplicado por lo que
+ * queda de turno.
+ */
+export declare const MAX_TOOL_OUTPUT_CHARS = 24000;
+/** Un fichero minificado de una sola linea pasaba entero hasta el tope global. */
+export declare const MAX_LINES = 2000;
+export declare const MAX_LINE_CHARS = 2000;
+/**
+ * Guarda la salida entera en disco y devuelve la ruta, o null si no se pudo.
+ *
+ * Lo omitido se perdia para siempre: si el trozo que importaba estaba en el
+ * medio, el agente no tenia forma de recuperarlo y acababa relanzando el mismo
+ * comando —y volviendo a truncarlo igual—. Guardarlo cuesta un fichero y
+ * convierte "se perdio" en "esta ahi, ve a buscarlo".
+ */
+export declare function volcarSalida(contenido: string): string | null;
 /**
  * Recorta la salida de una herramienta conservando el PRINCIPIO Y EL FINAL.
  *
@@ -7,5 +30,8 @@ export declare const MAX_TOOL_OUTPUT_CHARS = 60000;
  * resumen de los tests y el codigo de salida estan al final. El agente veia
  * 25.000 caracteres de compilacion y se perdia la linea que decia por que habia
  * fallado.
+ *
+ * Ahora, ademas, lo que no cabe no se tira: se escribe entero a disco y se le
+ * dice al agente como llegar a ello sin quemarse el contexto.
  */
 export declare function truncateOutput(output: string, maxChars?: number): string;

package/dist/tools/truncator.js

@@ -1,4 +1,80 @@
-export const MAX_TOOL_OUTPUT_CHARS = 60_000;
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+/**
+ * Topes de una salida de herramienta antes de recortarla.
+ *
+ * El limite estaba en 60.000 caracteres, que es entre dos y cuatro veces lo que
+ * usan los demas agentes (opencode 50 KB, Cline 48 K, Crush 30 K). El motivo
+ * por el que importa lo explica bien un comentario de Cline: cada caracter que
+ * devuelve una herramienta se REENVIA al modelo en todas las peticiones
+ * posteriores del turno, y el bucle puede dar treinta vueltas. Una salida
+ * gorda no cuesta lo que ocupa: cuesta lo que ocupa multiplicado por lo que
+ * queda de turno.
+ */
+export const MAX_TOOL_OUTPUT_CHARS = 24_000;
+/** Un fichero minificado de una sola linea pasaba entero hasta el tope global. */
+export const MAX_LINES = 2_000;
+export const MAX_LINE_CHARS = 2_000;
+/** Dias que se conservan los volcados antes de barrerlos. */
+const RETENCION_DIAS = 7;
+function directorioDeVolcados() {
+    return path.join(os.homedir(), ".chocolatito", "outputs");
+}
+/**
+ * Borra los volcados viejos. Se llama al escribir uno nuevo: es el unico
+ * momento en que se sabe que el directorio existe y que a alguien le importa.
+ */
+function barrerVolcadosViejos(dir) {
+    const limite = Date.now() - RETENCION_DIAS * 24 * 60 * 60 * 1000;
+    try {
+        for (const nombre of fs.readdirSync(dir)) {
+            const ruta = path.join(dir, nombre);
+            try {
+                if (fs.statSync(ruta).mtimeMs < limite)
+                    fs.unlinkSync(ruta);
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+/**
+ * Guarda la salida entera en disco y devuelve la ruta, o null si no se pudo.
+ *
+ * Lo omitido se perdia para siempre: si el trozo que importaba estaba en el
+ * medio, el agente no tenia forma de recuperarlo y acababa relanzando el mismo
+ * comando —y volviendo a truncarlo igual—. Guardarlo cuesta un fichero y
+ * convierte "se perdio" en "esta ahi, ve a buscarlo".
+ */
+export function volcarSalida(contenido) {
+    try {
+        const dir = directorioDeVolcados();
+        fs.mkdirSync(dir, { recursive: true });
+        barrerVolcadosViejos(dir);
+        const nombre = `${Date.now()}-${crypto.randomBytes(4).toString("hex")}.txt`;
+        const ruta = path.join(dir, nombre);
+        fs.writeFileSync(ruta, contenido, "utf-8");
+        return ruta;
+    }
+    catch {
+        return null;
+    }
+}
+/** Recorta las lineas absurdamente largas, avisando de cuanto se quito. */
+function recortarLineasLargas(salida) {
+    if (!salida.includes("\n") && salida.length <= MAX_LINE_CHARS)
+        return salida;
+    let tocada = false;
+    const lineas = salida.split("\n").map((linea) => {
+        if (linea.length <= MAX_LINE_CHARS)
+            return linea;
+        tocada = true;
+        return `${linea.slice(0, MAX_LINE_CHARS)}… [+${(linea.length - MAX_LINE_CHARS).toLocaleString()} caracteres en esta linea]`;
+    });
+    return tocada ? lineas.join("\n") : salida;
+}
 /**
  * Recorta la salida de una herramienta conservando el PRINCIPIO Y EL FINAL.
  *
@@ -7,18 +83,48 @@ export const MAX_TOOL_OUTPUT_CHARS = 60_000;
  * resumen de los tests y el codigo de salida estan al final. El agente veia
  * 25.000 caracteres de compilacion y se perdia la linea que decia por que habia
  * fallado.
+ *
+ * Ahora, ademas, lo que no cabe no se tira: se escribe entero a disco y se le
+ * dice al agente como llegar a ello sin quemarse el contexto.
  */
 export function truncateOutput(output, maxChars = MAX_TOOL_OUTPUT_CHARS) {
-    if (!output || output.length <= maxChars) {
+    if (!output)
         return output;
+    const completo = output;
+    let trabajo = recortarLineasLargas(output);
+    const lineas = trabajo.split("\n");
+    const sobranLineas = lineas.length > MAX_LINES;
+    if (sobranLineas) {
+        const cabeza = Math.floor(MAX_LINES * 0.65);
+        const cola = MAX_LINES - cabeza;
+        trabajo =
+            lineas.slice(0, cabeza).join("\n") +
+                `\n\n[... ${(lineas.length - MAX_LINES).toLocaleString()} lineas omitidas del medio ...]\n\n` +
+                lineas.slice(lineas.length - cola).join("\n");
+    }
+    if (trabajo.length <= maxChars && !sobranLineas && trabajo === completo) {
+        return completo;
+    }
+    let recortado = trabajo;
+    let omitidos = 0;
+    if (trabajo.length > maxChars) {
+        // Dos tercios al principio (contexto de lo que se hizo) y un tercio al final
+        // (donde suele estar el desenlace).
+        const headChars = Math.floor(maxChars * 0.65);
+        const tailChars = maxChars - headChars;
+        omitidos = trabajo.length - maxChars;
+        recortado =
+            trabajo.slice(0, headChars) +
+                `\n\n[... ${omitidos.toLocaleString()} caracteres omitidos del medio ` +
+                `para proteger el contexto; se conserva el final ...]\n\n` +
+                trabajo.slice(trabajo.length - tailChars);
     }
-    // Dos tercios al principio (contexto de lo que se hizo) y un tercio al final
-    // (donde suele estar el desenlace).
-    const headChars = Math.floor(maxChars * 0.65);
-    const tailChars = maxChars - headChars;
-    const head = output.slice(0, headChars);
-    const tail = output.slice(output.length - tailChars);
-    const omitted = output.length - maxChars;
-    return (`${head}\n\n[... ${omitted.toLocaleString()} caracteres omitidos del medio ` +
-        `para proteger el contexto; se conserva el final ...]\n\n${tail}`);
+    const ruta = volcarSalida(completo);
+    if (!ruta)
+        return recortado;
+    return (`${recortado}\n\n` +
+        `[Salida completa (${completo.length.toLocaleString()} caracteres) guardada en: ${ruta}\n` +
+        ` Para consultarla sin gastar contexto: grep_search sobre esa ruta, o view_file con startLine/endLine.\n` +
+        ` Si hay que revisarla entera, manda un spawn_agent que la lea y te resuma lo que buscas.\n` +
+        ` No la leas entera tu: volveria a ocupar lo mismo que se acaba de recortar.]`);
 }

package/dist/tools/viewFile.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { binaryExtensionLabel, looksBinary } from "./binary.js";
 export async function viewFile(filePath, startLine, endLine, cwd = process.cwd()) {
     const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
     if (!fs.existsSync(resolved)) {
@@ -9,18 +10,21 @@ export async function viewFile(filePath, startLine, endLine, cwd = process.cwd()
     if (stat.isDirectory()) {
         return `Error: "${filePath}" es un directorio, usa list_dir en su lugar.`;
     }
-    const BINARY_EXTENSIONS = new Set([
-        ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".svgz",
-        ".zip", ".tar", ".gz", ".7z", ".rar",
-        ".pdf", ".exe", ".dll", ".so", ".dylib", ".bin",
-        ".mp4", ".mov", ".avi", ".mkv", ".mp3", ".wav",
-        ".woff", ".woff2", ".ttf", ".eot"
-    ]);
-    const ext = path.extname(resolved).toLowerCase();
-    if (BINARY_EXTENSIONS.has(ext)) {
-        return `Aviso: "${filePath}" es un archivo binario (${ext.slice(1).toUpperCase()}) y no contiene texto plano legible. No intentes leerlo como texto.`;
+    // Esto empezaba por "Aviso:", y runner.ts solo se salta el markRead cuando el
+    // resultado empieza por "Error". O sea que un binario "visto" quedaba marcado
+    // como leido y el fileTracker dejaba pasar el edit_file que lo destruia. Es un
+    // error, no un aviso.
+    const etiqueta = binaryExtensionLabel(resolved);
+    if (etiqueta) {
+        return `Error: "${filePath}" es un archivo binario (${etiqueta}) y no contiene texto plano legible. No intentes leerlo ni editarlo como texto.`;
     }
-    const content = fs.readFileSync(resolved, "utf-8");
+    const buffer = fs.readFileSync(resolved);
+    // La lista de extensiones no cubre lo que no tiene extension o la tiene rara
+    // (un .dat, un volcado sin nombre). Un byte nulo lo delata igual.
+    if (looksBinary(buffer)) {
+        return `Error: "${filePath}" contiene bytes nulos: es binario, no texto. No intentes leerlo ni editarlo como texto.`;
+    }
+    const content = buffer.toString("utf-8");
     const lines = content.split(/\r?\n/);
     const totalLines = lines.length;
     const isUnbounded = !startLine && !endLine;

package/dist/tools/visionBridge.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import { VISION_MODEL } from "../config/constants.js";
 import { createEngineClient } from "../config/engine.js";
+import { apuntarUso } from "../agent/usageMeter.js";
 function client(apiKey) {
     return createEngineClient(apiKey, "vision");
 }
@@ -28,6 +29,12 @@ async function ask(apiKey, prompt, imagePath, maxTokens) {
                 },
             ],
         });
+        // Se apunta aqui, no en quien llama: `usage` se venia devolviendo en el
+        // resultado y no lo leia nadie (computerUse, browserCdp y browserExtension
+        // solo usan el texto), asi que cada captura descrita durante el control del
+        // ordenador —y son muchas, con una imagen entera en el prompt— costaba
+        // dinero y sumaba cero. Contarlo donde se gasta evita repetir el olvido.
+        apuntarUso(res.usage, VISION_MODEL, "vision");
         const msg = res.choices[0]?.message;
         // El modelo de vision razona antes de responder. Si el presupuesto de tokens
         // se agota razonando, 'content' llega vacio y el agente se queda sin ojos sin

package/dist/tools/webSearch.d.ts

@@ -1 +1,22 @@
+/**
+ * Busqueda web contra el HTML de DuckDuckGo.
+ *
+ * Lo que devuelve esto se lo traga el modelo y casi siempre lo encadena con
+ * web_fetch ("busca X y leelo"), asi que cada URL tiene que poder abrirse tal
+ * cual sale de aqui. Antes no se podia ninguna: ver resolverEnlace().
+ */
+interface ResultadoWeb {
+    titulo: string;
+    url: string;
+    resumen: string;
+}
+/**
+ * Separado de la peticion para poder probarlo sin red.
+ *
+ * El titulo sale de result__a. La version anterior leia el href y el texto de
+ * result__url, que no es el titulo sino el dominio de adorno
+ * ("www.speedtest.net"): el modelo nunca llego a ver el titulo de la pagina.
+ */
+export declare function parsearResultados(html: string, maximo?: number): ResultadoWeb[];
 export declare function webSearch(query: string): Promise<string>;
+export {};

package/dist/tools/webSearch.js

@@ -1,3 +1,124 @@
+/**
+ * Busqueda web contra el HTML de DuckDuckGo.
+ *
+ * Lo que devuelve esto se lo traga el modelo y casi siempre lo encadena con
+ * web_fetch ("busca X y leelo"), asi que cada URL tiene que poder abrirse tal
+ * cual sale de aqui. Antes no se podia ninguna: ver resolverEnlace().
+ */
+const ENTIDADES_NOMBRADAS = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"',
+    apos: "'",
+    nbsp: " ",
+};
+/**
+ * Una sola pasada a proposito: si se decodificara "&amp;" antes que el resto, un
+ * "&amp;#x27;" literal acabaria convertido en apostrofe, que no es lo que decia
+ * el HTML.
+ */
+function decodificarEntidades(texto) {
+    return texto.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (completo, entidad) => {
+        const clave = entidad.toLowerCase();
+        if (clave.startsWith("#")) {
+            const codigo = clave.startsWith("#x") ? parseInt(clave.slice(2), 16) : Number(clave.slice(1));
+            if (!Number.isFinite(codigo) || codigo < 0 || codigo > 0x10ffff)
+                return completo;
+            return String.fromCodePoint(codigo);
+        }
+        return clave in ENTIDADES_NOMBRADAS ? ENTIDADES_NOMBRADAS[clave] : completo;
+    });
+}
+/**
+ * Etiquetas fuera primero y entidades despues. Al reves, un "&lt;b&gt;" del
+ * texto se decodificaria a "<b>" y el limpiador se lo comeria como si fuera
+ * marcado de verdad.
+ */
+function aTextoPlano(fragmento) {
+    return decodificarEntidades(fragmento.replace(/<[^>]+>/g, " "))
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/**
+ * En html.duckduckgo.com ningun href apunta al destino: todos van al redirector
+ * de DDG y ademas sin esquema ("//duckduckgo.com/l/?uddg=...&amp;rut=..."). Eso
+ * es inservible para web_fetch por partida doble: fetch() no sabe parsear una
+ * URL protocol-relative ("Failed to parse URL from //duckduckgo.com/...") y el
+ * redirector, aunque se le ponga el "https:" delante, contesta HTTP 400 a quien
+ * no llegue desde el navegador. El destino real esta en el parametro uddg.
+ */
+function resolverEnlace(href) {
+    // El href viene escapado dentro del atributo ("&amp;rut="); sin desescapar,
+    // el separador de parametros no es un "&" y uddg se lleva el rut pegado.
+    const limpio = decodificarEntidades(href.trim());
+    if (!limpio)
+        return null;
+    let redirector;
+    try {
+        redirector = new URL(limpio, "https://html.duckduckgo.com/");
+    }
+    catch {
+        return null;
+    }
+    // searchParams ya hace el decodeURIComponent; repetirlo a mano romperia
+    // cualquier destino con un %25 legitimo.
+    const destinoCrudo = redirector.searchParams.get("uddg") ?? redirector.href;
+    let destino;
+    try {
+        destino = new URL(destinoCrudo);
+    }
+    catch {
+        return null;
+    }
+    if (destino.protocol !== "https:" && destino.protocol !== "http:")
+        return null;
+    // Los primeros huecos de DDG son anuncios, y su uddg no lleva a la pagina
+    // anunciada sino al contador de clics de DDG (/y.js?ad_domain=...). Sin este
+    // filtro, el resultado [1] que ve el modelo es publicidad que encima no se
+    // puede abrir.
+    if (destino.hostname.endsWith("duckduckgo.com") && destino.pathname === "/y.js")
+        return null;
+    return destino.href;
+}
+/**
+ * Separado de la peticion para poder probarlo sin red.
+ *
+ * El titulo sale de result__a. La version anterior leia el href y el texto de
+ * result__url, que no es el titulo sino el dominio de adorno
+ * ("www.speedtest.net"): el modelo nunca llego a ver el titulo de la pagina.
+ */
+export function parsearResultados(html, maximo = 6) {
+    const anclaTitulo = /<a\b([^>]*\bclass="[^"]*\bresult__a\b[^"]*"[^>]*)>([\s\S]*?)<\/a>/g;
+    const anclas = [];
+    let m;
+    while ((m = anclaTitulo.exec(html)) !== null) {
+        anclas.push({ atributos: m[1], titulo: m[2], inicio: m.index, fin: anclaTitulo.lastIndex });
+    }
+    const resultados = [];
+    for (let i = 0; i < anclas.length && resultados.length < maximo; i++) {
+        const ancla = anclas[i];
+        // El orden de los atributos no esta garantizado, asi que el href se saca
+        // aparte en vez de encadenarlo a la clase dentro de la misma regex.
+        const href = /\bhref="([^"]*)"/.exec(ancla.atributos)?.[1];
+        if (!href)
+            continue;
+        const url = resolverEnlace(href);
+        if (!url)
+            continue;
+        const titulo = aTextoPlano(ancla.titulo);
+        if (!titulo)
+            continue;
+        // El resumen se busca solo hasta donde empieza el siguiente resultado: si
+        // uno viene sin snippet, una busqueda perezosa sin tope le robaria el del
+        // siguiente y emparejaria titulo y texto de paginas distintas.
+        const hasta = i + 1 < anclas.length ? anclas[i + 1].inicio : html.length;
+        const trozo = html.slice(ancla.fin, hasta);
+        const resumen = /<a\b[^>]*\bclass="[^"]*\bresult__snippet\b[^"]*"[^>]*>([\s\S]*?)<\/a>/.exec(trozo)?.[1] ?? "";
+        resultados.push({ titulo, url, resumen: aTextoPlano(resumen) });
+    }
+    return resultados;
+}
 export async function webSearch(query) {
     try {
         const encoded = encodeURIComponent(query);
@@ -12,22 +133,12 @@ export async function webSearch(query) {
             return `Error al buscar en la web: HTTP ${res.status}`;
         }
         const html = await res.text();
-        // Parse results from DuckDuckGo HTML
-        const results = [];
-        const regex = /<a class="result__url"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
-        let match;
-        let count = 0;
-        while ((match = regex.exec(html)) !== null && count < 6) {
-            count++;
-            const link = match[1].trim();
-            const title = match[2].replace(/<[^>]+>/g, "").trim();
-            const snippet = match[3].replace(/<[^>]+>/g, "").trim();
-            results.push(`[${count}] ${title}\n    URL: ${link}\n    ${snippet}`);
-        }
-        if (results.length === 0) {
+        const resultados = parsearResultados(html);
+        if (resultados.length === 0) {
             return `No se encontraron resultados directos para "${query}".`;
         }
-        return `Resultados de búsqueda web para "${query}":\n\n${results.join("\n\n")}`;
+        const lineas = resultados.map((r, i) => `[${i + 1}] ${r.titulo}\n    URL: ${r.url}\n    ${r.resumen}`);
+        return `Resultados de búsqueda web para "${query}":\n\n${lineas.join("\n\n")}`;
     }
     catch (err) {
         return `Error en búsqueda web: ${err?.message || String(err)}`;

package/dist/tools/writeFile.d.ts

@@ -1 +1,16 @@
-export declare function writeFile(filePath: string, content: string, cwd?: string): Promise<string>;
+/**
+ * Escribe un archivo, entero o por partes.
+ *
+ * POR QUE EXISTE "anadir"
+ *
+ * La respuesta del modelo tiene un techo de salida. Cuando le piden una pagina
+ * entera, el contenido no cabe, la respuesta se corta a mitad de los argumentos
+ * y no se escribe nada. Se le decia "hazlo en varias llamadas mas pequenas"...
+ * y no habia forma de hacerlo: write_file solo sabia sobrescribir, asi que la
+ * segunda llamada borraba la primera. Le pediamos algo imposible y luego le
+ * echabamos la culpa.
+ *
+ * Con `modo: "anadir"` la instruccion pasa a ser ejecutable: primera llamada
+ * con el principio, las siguientes anadiendo, y el archivo sale entero.
+ */
+export declare function writeFile(filePath: string, content: string, cwd?: string, modo?: "sobrescribir" | "anadir"): Promise<string>;

package/dist/tools/writeFile.js

@@ -1,12 +1,50 @@
 import fs from "node:fs";
 import path from "node:path";
-export async function writeFile(filePath, content, cwd = process.cwd()) {
+import { binaryExtensionLabel, fileLooksBinary } from "./binary.js";
+/**
+ * Escribe un archivo, entero o por partes.
+ *
+ * POR QUE EXISTE "anadir"
+ *
+ * La respuesta del modelo tiene un techo de salida. Cuando le piden una pagina
+ * entera, el contenido no cabe, la respuesta se corta a mitad de los argumentos
+ * y no se escribe nada. Se le decia "hazlo en varias llamadas mas pequenas"...
+ * y no habia forma de hacerlo: write_file solo sabia sobrescribir, asi que la
+ * segunda llamada borraba la primera. Le pediamos algo imposible y luego le
+ * echabamos la culpa.
+ *
+ * Con `modo: "anadir"` la instruccion pasa a ser ejecutable: primera llamada
+ * con el principio, las siguientes anadiendo, y el archivo sale entero.
+ */
+export async function writeFile(filePath, content, cwd = process.cwd(), modo = "sobrescribir") {
     const resolved = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
     const dir = path.dirname(resolved);
+    const isNew = !fs.existsSync(resolved);
+    // write_file es la ruta mas desprotegida del agente: no pasa por
+    // checkBeforeEdit (runner.ts no lo llama en este caso) y no pide confirmacion
+    // en ningun modo de permisos. Volcar un string UTF-8 sobre un png o un mp4 lo
+    // sustituye por basura, y ademas deja el snapshot de /undo apuntando a un
+    // archivo que ya no se puede reconstruir desde texto. Los bytes de un binario
+    // no salen de un string: si de verdad hay que reemplazarlo, se borra primero.
+    const etiqueta = binaryExtensionLabel(resolved);
+    if (etiqueta) {
+        return (`Error: "${filePath}" es un archivo binario (${etiqueta}). write_file escribe texto UTF-8, ` +
+            `asi que lo dejaria corrupto. Genera el archivo con la herramienta que corresponda ` +
+            `(create_image, run_command) o borralo antes si de verdad quieres reemplazarlo.`);
+    }
+    if (!isNew && fileLooksBinary(resolved)) {
+        return (`Error: "${filePath}" contiene bytes nulos: es binario, no texto. write_file lo dejaria corrupto. ` +
+            `Borralo antes si de verdad quieres reemplazarlo.`);
+    }
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
-    const isNew = !fs.existsSync(resolved);
+    if (modo === "anadir") {
+        fs.appendFileSync(resolved, content, "utf-8");
+        const total = fs.statSync(resolved).size;
+        return (`✔ Anadido a "${filePath}" (${content.length} caracteres nuevos, ${total} en total). ` +
+            `Sigue con otra llamada en modo "anadir" si falta contenido.`);
+    }
     fs.writeFileSync(resolved, content, "utf-8");
     const action = isNew ? "creado" : "sobreescrito";
     return `✔ Archivo "${filePath}" ${action} exitosamente (${content.length} caracteres).`;

package/dist/ui/interrupt.d.ts

@@ -1,4 +1,7 @@
-/** Suelta el teclado de cualquier vigilante que lo tenga. Lo llama el prompt. */
+/** Lo llama el prompt al abrirse, despues de coger el modo crudo. */
+export declare function tomarTecladoParaPrompt(): void;
+/** Lo llama el prompt al cerrarse, para que el siguiente turno pueda restaurar. */
+export declare function devolverTecladoDelPrompt(): void;
 export declare function releaseKeyboard(): void;
 export declare class InterruptWatcher {
     private controller;