chocolatito-code 1.0.0 → 1.2.0

package/dist/tools/patchCascade.js

@@ -0,0 +1,338 @@
+/**
+ * Cascada de estrategias para localizar el fragmento que el modelo quiere
+ * reemplazar.
+ *
+ * El problema real no es que el modelo invente el codigo: es que copia bien las
+ * lineas y se come la sangria, o se deja una linea en blanco delante, o resume
+ * el interior de un bloque largo. Con una unica busqueda exacta, todos esos
+ * casos son un fallo y una iteracion perdida; Aider y opencode los resuelven
+ * probando estrategias cada vez mas flexibles y parando en la primera que casa.
+ *
+ * Reglas que se mantienen en TODAS las estrategias, porque son lo que separa
+ * "tolerante" de "escribe donde le parece":
+ *
+ *  - Si una estrategia encuentra mas de un sitio posible, no elige: falla. La
+ *    ambiguedad se resuelve pidiendo mas contexto, no adivinando.
+ *  - Una coincidencia desproporcionada (mucho mas grande que lo buscado) se
+ *    rechaza aunque sea unica. Es el fallo mas caro: un anclaje laxo que se
+ *    come medio archivo y responde "editado exitosamente".
+ */
+export function esRechazo(r) {
+    return !!r && r.ambiguo === true;
+}
+/**
+ * Normalizacion de puntuacion Unicode a ASCII.
+ *
+ * Es el cuarto nivel de la escalera de Codex CLI, y es el que mas rinde en
+ * castellano. Cuando el modelo devuelve un fragmento, muy a menudo lo reescribe
+ * con la puntuacion "bonita": el guion largo del archivo vuelve como guion
+ * normal, las comillas rectas vuelven curvas, y un espacio duro se convierte en
+ * un espacio corriente. Ninguna de esas diferencias se ve al leer el diff, pero
+ * las cuatro estrategias anteriores comparan texto y fallan todas.
+ *
+ * La tabla esta copiada de `seek_sequence.rs`: siete guiones tipograficos, las
+ * comillas simples y dobles curvas, y once espacios raros.
+ */
+const EQUIVALENCIAS = [
+    [/[‐‑‒–—―−]/g, "-"],
+    [/[‘’‚‛]/g, "'"],
+    [/[“”„‟]/g, '"'],
+    [/[            　]/g, " "],
+];
+export function normalizarPuntuacion(texto) {
+    let salida = texto;
+    for (const [patron, ascii] of EQUIVALENCIAS)
+        salida = salida.replace(patron, ascii);
+    return salida;
+}
+/** true si el texto tiene algo que normalizar; evita recorrer el archivo en balde. */
+export function tienePuntuacionRara(texto) {
+    return EQUIVALENCIAS.some(([patron]) => {
+        patron.lastIndex = 0;
+        return patron.test(texto);
+    });
+}
+/** Offset de caracter donde empieza cada linea. */
+function offsetsDeLinea(lineas) {
+    const offsets = [];
+    let acumulado = 0;
+    for (const linea of lineas) {
+        offsets.push(acumulado);
+        acumulado += linea.length + 1; // +1 por el "\n"
+    }
+    return offsets;
+}
+/**
+ * Sangria comun que hay que ANADIR a `parte` para que coincida con `trozo`.
+ *
+ * Devuelve null si el texto sin sangria no coincide, o si el desfase no es el
+ * mismo en todas las lineas: un desfase distinto por linea significa que el
+ * modelo cambio la estructura, no solo la sangria, y ahi ya no se puede
+ * reconstruir sin inventar.
+ */
+function desfaseDeSangria(trozo, parte) {
+    if (trozo.length !== parte.length)
+        return null;
+    for (let i = 0; i < trozo.length; i++) {
+        if (trozo[i].trimStart() !== parte[i].trimStart())
+            return null;
+    }
+    const prefijos = new Set();
+    for (let i = 0; i < trozo.length; i++) {
+        if (!trozo[i].trim())
+            continue; // las lineas en blanco no dicen nada
+        const sobra = trozo[i].length - parte[i].length;
+        if (sobra < 0)
+            return null;
+        prefijos.add(trozo[i].slice(0, sobra));
+    }
+    if (prefijos.size !== 1)
+        return null;
+    return prefijos.values().next().value ?? "";
+}
+/** Quita a los dos bloques la sangria minima que comparten. */
+function desangrar(lineas, otras) {
+    const sangrias = [];
+    for (const l of [...lineas, ...otras]) {
+        if (!l.trim())
+            continue;
+        sangrias.push(l.length - l.trimStart().length);
+    }
+    const minimo = sangrias.length > 0 ? Math.min(...sangrias) : 0;
+    if (minimo === 0)
+        return { lineas, otras };
+    const recortar = (l) => (l.trim() ? l.slice(minimo) : l);
+    return { lineas: lineas.map(recortar), otras: otras.map(recortar) };
+}
+/**
+ * Rechaza un tramo que abarque mucho mas de lo buscado.
+ *
+ * Los umbrales son los de opencode: mas del doble de lineas (o tres de mas), o
+ * cuatro veces los caracteres (o 500 de mas).
+ */
+export function esDesproporcionada(buscado, encontrado) {
+    const lineasBuscadas = buscado.split("\n").length;
+    const lineasEncontradas = encontrado.split("\n").length;
+    if (lineasEncontradas >= Math.max(lineasBuscadas + 3, lineasBuscadas * 2))
+        return true;
+    if (encontrado.length > Math.max(buscado.length + 500, buscado.length * 4))
+        return true;
+    return false;
+}
+/** 1. Coincidencia exacta. Es la unica que puede casar texto a media linea. */
+function exacta(contenido, viejo, nuevo, _original) {
+    if (!viejo)
+        return null;
+    const primera = contenido.indexOf(viejo);
+    if (primera === -1)
+        return null;
+    const segunda = contenido.indexOf(viejo, primera + viejo.length);
+    if (segunda !== -1) {
+        let ocurrencias = 2;
+        let desde = segunda + viejo.length;
+        while (true) {
+            const at = contenido.indexOf(viejo, desde);
+            if (at === -1)
+                break;
+            ocurrencias++;
+            desde = at + viejo.length;
+        }
+        return { ambiguo: true, estrategia: "exacta", ocurrencias };
+    }
+    return { inicio: primera, fin: primera + viejo.length, textoNuevo: nuevo, estrategia: "exacta" };
+}
+/**
+ * 2. Sangria uniforme desplazada.
+ *
+ * El error mas comun del modelo: copia las lineas correctas pero con menos
+ * sangria de la que tienen (o con ninguna). Se compara el texto sin sangria y
+ * se exige que el desfase sea IDENTICO en todas las lineas; ese mismo prefijo
+ * se le devuelve al texto de reemplazo.
+ */
+function sangriaUniforme(contenido, viejo, nuevo, original = contenido) {
+    const lineasArchivo = contenido.split("\n");
+    // La sangria que se vuelve a escribir se toma del archivo REAL, no de la
+    // version normalizada con la que se busca. Es la unica estrategia que
+    // reconstruye texto a partir del contenido, y sin esta distincion una pasada
+    // de normalizacion podria convertir en espacios normales una sangria que en
+    // el archivo eran otros caracteres.
+    const lineasOriginales = original === contenido ? lineasArchivo : original.split("\n");
+    const sinSangria = desangrar(viejo.split("\n"), nuevo.split("\n"));
+    const parte = sinSangria.lineas;
+    const reemplazo = sinSangria.otras;
+    if (parte.length === 0)
+        return null;
+    const offsets = offsetsDeLinea(lineasArchivo);
+    let encontrado = null;
+    let ocurrencias = 0;
+    for (let i = 0; i + parte.length <= lineasArchivo.length; i++) {
+        const prefijo = desfaseDeSangria(lineasArchivo.slice(i, i + parte.length), parte);
+        if (prefijo === null)
+            continue;
+        ocurrencias++;
+        if (ocurrencias > 1)
+            return { ambiguo: true, estrategia: "sangria-uniforme", ocurrencias };
+        encontrado = { i, prefijo };
+    }
+    if (!encontrado)
+        return null;
+    const inicio = offsets[encontrado.i];
+    const ultima = encontrado.i + parte.length - 1;
+    const fin = offsets[ultima] + lineasArchivo[ultima].length;
+    const lineaReal = lineasOriginales[encontrado.i] ?? lineasArchivo[encontrado.i];
+    const prefijo = lineaReal.slice(0, encontrado.prefijo.length);
+    const textoNuevo = reemplazo.map((l) => (l.trim() ? prefijo + l : l)).join("\n");
+    return { inicio, fin, textoNuevo, estrategia: "sangria-uniforme" };
+}
+/**
+ * 3. Coincidencia por lineas ignorando espacios al final.
+ *
+ * Estaba ya en edit_file y aguanta bien: cubre el espacio de mas al final de
+ * linea, que ni el match exacto ni la sangria uniforme perdonan.
+ */
+function lineasRecortadas(contenido, viejo, nuevo, _original) {
+    const lineasArchivo = contenido.split("\n");
+    const objetivo = viejo.split("\n").map((l) => l.trimEnd());
+    if (objetivo.length === 0)
+        return null;
+    const offsets = offsetsDeLinea(lineasArchivo);
+    let encontrado = -1;
+    let ocurrencias = 0;
+    for (let i = 0; i + objetivo.length <= lineasArchivo.length; i++) {
+        let casa = true;
+        for (let j = 0; j < objetivo.length; j++) {
+            if (lineasArchivo[i + j].trimEnd() !== objetivo[j]) {
+                casa = false;
+                break;
+            }
+        }
+        if (!casa)
+            continue;
+        ocurrencias++;
+        if (ocurrencias > 1)
+            return { ambiguo: true, estrategia: "lineas-recortadas", ocurrencias };
+        encontrado = i;
+    }
+    if (encontrado === -1)
+        return null;
+    const inicio = offsets[encontrado];
+    const ultima = encontrado + objetivo.length - 1;
+    const fin = offsets[ultima] + lineasArchivo[ultima].length;
+    return { inicio, fin, textoNuevo: nuevo, estrategia: "lineas-recortadas" };
+}
+/**
+ * 4. Ancla de bloque: primera y ultima linea.
+ *
+ * Para bloques de tres lineas o mas. El modelo resume el interior o lo recuerda
+ * de memoria con alguna diferencia, pero los bordes casi siempre los copia
+ * bien. Se ancla en ellos y se acepta que el interior no coincida, con dos
+ * cerrojos: el numero de lineas del tramo no puede desviarse mas de un 25%, y
+ * el ancla tiene que ser unica.
+ */
+function anclaDeBloque(contenido, viejo, nuevo, _original) {
+    const objetivo = viejo.split("\n");
+    if (objetivo.length < 3)
+        return null;
+    const primera = objetivo[0].trim();
+    const ultima = objetivo[objetivo.length - 1].trim();
+    if (!primera || !ultima)
+        return null;
+    const lineasArchivo = contenido.split("\n");
+    const offsets = offsetsDeLinea(lineasArchivo);
+    const desvioMax = Math.max(1, Math.floor(objetivo.length * 0.25));
+    let encontrado = null;
+    let ocurrencias = 0;
+    for (let i = 0; i < lineasArchivo.length; i++) {
+        if (lineasArchivo[i].trim() !== primera)
+            continue;
+        const desde = Math.max(i + 2, i + objetivo.length - 1 - desvioMax);
+        const hasta = Math.min(lineasArchivo.length - 1, i + objetivo.length - 1 + desvioMax);
+        for (let j = desde; j <= hasta; j++) {
+            if (lineasArchivo[j].trim() !== ultima)
+                continue;
+            ocurrencias++;
+            if (ocurrencias > 1)
+                return { ambiguo: true, estrategia: "ancla-de-bloque", ocurrencias };
+            encontrado = { i, j };
+            break;
+        }
+    }
+    if (!encontrado)
+        return null;
+    const inicio = offsets[encontrado.i];
+    const fin = offsets[encontrado.j] + lineasArchivo[encontrado.j].length;
+    return { inicio, fin, textoNuevo: nuevo, estrategia: "ancla-de-bloque" };
+}
+/**
+ * Orden de la cascada, de mas estricta a mas flexible. Se para en la primera
+ * que devuelve algo: una estrategia mas laxa no puede mejorar lo que ya acerto
+ * una mas estricta.
+ *
+ * Un rechazo por ambiguedad NO deja pasar a la siguiente estrategia. Si el
+ * fragmento aparece dos veces exactas, encontrar un tercer sitio "parecido" no
+ * arregla nada: lo que hay que hacer es pedir mas contexto.
+ */
+export function localizarFragmento(contenidoNormalizado, viejoNormalizado, nuevoNormalizado) {
+    const estrategias = [exacta, sangriaUniforme, lineasRecortadas, anclaDeBloque];
+    /**
+     * Cada pasada aplica la cascada entera sobre una version distinta del texto.
+     * El orden va de menos a mas permisivo, igual que dentro de la cascada.
+     *
+     *   `contenido` es contra que se BUSCA; `nuevo` es lo que se ESCRIBE. Las
+     *   transformaciones de busqueda no tocan nunca el texto de reemplazo: si el
+     *   modelo escribio una comilla curva a proposito, ahi se queda.
+     *
+     * Las dos transformaciones conservan la longitud caracter a caracter, asi que
+     * los indices que devuelve una pasada valen tal cual sobre el contenido de
+     * verdad. Eso es lo que permite buscar en un texto y recortar en otro.
+     */
+    const pasadas = [
+        { contenido: contenidoNormalizado, viejo: viejoNormalizado, nuevo: nuevoNormalizado, sufijo: "" },
+    ];
+    // Los modelos anteponen una linea en blanco al fragmento mas de lo que
+    // parece.
+    const sinBlanco = /^[ \t]*\n/.test(viejoNormalizado)
+        ? {
+            viejo: viejoNormalizado.replace(/^[ \t]*\n/, ""),
+            nuevo: nuevoNormalizado.replace(/^[ \t]*\n/, ""),
+        }
+        : null;
+    if (sinBlanco) {
+        pasadas.push({ contenido: contenidoNormalizado, ...sinBlanco, sufijo: "+sin-blanco-inicial" });
+    }
+    // Ultimo recurso: comparar con la puntuacion normalizada a ASCII. Es el nivel
+    // que salva las ediciones en texto en castellano, donde el modelo devuelve un
+    // guion normal donde el archivo tiene uno largo, o comillas curvas donde hay
+    // rectas. Va el ultimo porque es el que mas relaja la comparacion.
+    if (tienePuntuacionRara(contenidoNormalizado) || tienePuntuacionRara(viejoNormalizado)) {
+        const contenidoAscii = normalizarPuntuacion(contenidoNormalizado);
+        pasadas.push({
+            contenido: contenidoAscii,
+            viejo: normalizarPuntuacion(viejoNormalizado),
+            nuevo: nuevoNormalizado,
+            sufijo: "+puntuacion",
+        });
+        if (sinBlanco) {
+            pasadas.push({
+                contenido: contenidoAscii,
+                viejo: normalizarPuntuacion(sinBlanco.viejo),
+                nuevo: sinBlanco.nuevo,
+                sufijo: "+puntuacion+sin-blanco-inicial",
+            });
+        }
+    }
+    for (const pasada of pasadas) {
+        for (const estrategia of estrategias) {
+            const r = estrategia(pasada.contenido, pasada.viejo, pasada.nuevo, contenidoNormalizado);
+            if (!r)
+                continue;
+            if (esRechazo(r))
+                return r;
+            const encontrado = pasada.contenido.slice(r.inicio, r.fin);
+            if (esDesproporcionada(pasada.viejo, encontrado))
+                continue;
+            return { ...r, estrategia: r.estrategia + pasada.sufijo };
+        }
+    }
+    return null;
+}

package/dist/tools/runCommand.js

@@ -1,8 +1,9 @@
-import { execa } from "execa";
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
 /**
  * Ejecucion de comandos de shell.
  *
- * Tres fallos que tenia la version anterior:
+ * Cuatro fallos que tenia esto, y el cuarto explica por que ya no se usa execa:
  *
  *  1. Calculaba el shell correcto y luego NO lo usaba: pasaba `shell: true`, que
  *     en Windows significa cmd.exe. Cualquier comando con sintaxis de PowerShell
@@ -16,9 +17,88 @@ import { execa } from "execa";
  *     "Exit code: null", y concluia lo que le parecia. Un comando que no termino
  *     no es un comando que fallo, y confundirlos lleva a "arreglar" cosas que no
  *     estaban rotas.
+ *
+ *  4. El timeout no mataba nada. Con `shell: "powershell.exe"`, Node lanza
+ *     `powershell.exe -c <comando>`, asi que el proceso de verdad (node, npm,
+ *     python, git) es un NIETO. El kill del timeout cae sobre el hijo directo y
+ *     en Windows eso es un TerminateProcess de ese PID: no hay job object ni
+ *     grupo de procesos, y el nieto sobrevive con el pipe de stdout heredado
+ *     abierto. Como execa espera al EOF de stdio antes de resolver, la promesa
+ *     volvia cuando el nieto terminaba por su cuenta -- y si era un servidor o
+ *     un watcher, no volvia jamas. Medido: con timeout de 2 s, un `node -e` de
+ *     8 s devolvia a los 8,2 s; con `npm run dev`, nunca.
+ *
+ *     Los daños colaterales eran peores que el sintoma: loop.ts lanza el lote de
+ *     tool calls con Promise.all, asi que un run_command colgado congela a todas
+ *     las demas; el InterruptWatcher no cubre la ejecucion de herramientas, o
+ *     sea que ni Esc salva; y el servidor quedaba huerfano ocupando el puerto.
+ *     Ademas el flag `timedOut` se ponia igual aunque el comando hubiera
+ *     terminado entero, asi que se etiquetaba de "salida incompleta" una salida
+ *     completa, sin imprimir Exit code, y el agente relanzaba un comando que ya
+ *     habia funcionado.
+ *
+ * Por eso aqui se baja a `child_process.spawn` y se hace a mano lo que execa no
+ * puede garantizar por encima de un shell que no hace exec:
+ *
+ *   - la salida se acumula segun llega, no al final, asi que lo ya impreso se
+ *     conserva aunque haya que matar el proceso a mitad;
+ *   - el temporizador es nuestro y mata el ARBOL (taskkill /T en Windows, el
+ *     grupo de procesos en Unix), no solo al hijo directo;
+ *   - despues de matar se espera un margen corto a que cierren los pipes y se
+ *     devuelve igualmente. El tiempo total esta acotado SIEMPRE: nunca mas de
+ *     timeout + KILL_GRACE_MS, pase lo que pase con los descendientes.
  */
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_TIMEOUT_MS = 600_000;
+/**
+ * Margen tras matar el arbol para que cierren los pipes. Si un nieto reparentado
+ * los sigue teniendo, se devuelve igual: esperar mas no aporta nada y colgarse
+ * es exactamente el fallo que se esta arreglando.
+ */
+const KILL_GRACE_MS = 2_000;
+/**
+ * Margen tras la muerte del shell para recoger lo que quede en los pipes. Casi
+ * siempre 'close' llega en el mismo tick; si no llega es que el comando dejo
+ * algo en segundo plano, y eso no justifica bloquear el turno.
+ */
+const DRAIN_MS = 500;
+const MAX_OUTPUT_CHARS = 20 * 1024 * 1024;
+/**
+ * Mata al proceso Y a sus descendientes. Matar solo al pid es inutil aqui: el
+ * shell casi nunca es la carga de trabajo, solo el que la lanzo.
+ */
+function killTree(pid) {
+    if (process.platform === "win32") {
+        // /T recorre la cadena de padres y se lleva a los nietos. Sin /T se mata
+        // powershell.exe y el node/npm/python real sigue vivo, escribiendo a disco.
+        try {
+            const t = spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
+                stdio: "ignore",
+                windowsHide: true,
+            });
+            t.on("error", () => { });
+        }
+        catch { }
+        return;
+    }
+    // En Unix el hijo se lanza con detached, o sea que es lider de su propio
+    // grupo: el pid en negativo alcanza tambien a lo que haya forkeado (tuberias,
+    // npm lanzando node). Sin grupo, bash exec-a el comando simple y el kill
+    // funciona, pero un comando compuesto filtra huerfanos igual que en Windows.
+    const enviar = (sig) => {
+        try {
+            process.kill(-pid, sig);
+        }
+        catch {
+            try {
+                process.kill(pid, sig);
+            }
+            catch { }
+        }
+    };
+    enviar("SIGTERM");
+    setTimeout(() => enviar("SIGKILL"), 1_000).unref();
+}
 export async function runCommand(command, cwd = process.cwd(), timeoutMs) {
     const trimmed = command.trim();
     if (!trimmed)
@@ -29,31 +109,139 @@ export async function runCommand(command, cwd = process.cwd(), timeoutMs) {
     }
     const timeout = Math.min(Math.max(timeoutMs || DEFAULT_TIMEOUT_MS, 1_000), MAX_TIMEOUT_MS);
     const isWindows = process.platform === "win32";
+    // Se usa de verdad el shell que toca. En Windows, PowerShell.
+    const shellPath = isWindows ? "powershell.exe" : "/bin/bash";
+    const shellArgs = isWindows
+        ? // -NoProfile para que el perfil del usuario no ensucie la salida ni cueste
+            // medio segundo, y -NonInteractive para que cualquier prompt sea un error
+            // en el sitio en vez de una espera eterna por un teclado que aqui no hay.
+            ["-NoProfile", "-NonInteractive", "-Command", trimmed]
+        : ["-c", trimmed];
     try {
-        const result = await execa(trimmed, {
-            cwd,
-            // Se usa de verdad el shell que toca. En Windows, PowerShell.
-            shell: isWindows ? "powershell.exe" : "/bin/bash",
-            timeout,
-            reject: false,
-            all: false,
-            maxBuffer: 20 * 1024 * 1024,
-            env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+        return await new Promise((resolve) => {
+            const child = spawn(shellPath, shellArgs, {
+                cwd,
+                env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+                windowsHide: true,
+                // stdin cerrado: un comando que pida confirmacion muere en el sitio en
+                // vez de esperar para siempre a nadie. detached solo en Unix, para tener
+                // un grupo de procesos al que matar; en Windows no existe equivalente y
+                // el arbol se derriba con taskkill.
+                stdio: ["ignore", "pipe", "pipe"],
+                detached: !isWindows,
+            });
+            const decOut = new StringDecoder("utf8");
+            const decErr = new StringDecoder("utf8");
+            let stdout = "";
+            let stderr = "";
+            let recortada = false;
+            let resuelto = false;
+            let salio = false;
+            let porTiempo = false;
+            let colaDeFondo = false;
+            let exitCode = null;
+            let temporizador;
+            let margen;
+            const acumular = (trozo, cual) => {
+                if (stdout.length + stderr.length >= MAX_OUTPUT_CHARS) {
+                    recortada = true;
+                    return;
+                }
+                // StringDecoder y no toString() porque un chunk puede partir un
+                // caracter multibyte por la mitad.
+                if (cual === "out")
+                    stdout += decOut.write(trozo);
+                else
+                    stderr += decErr.write(trozo);
+            };
+            child.stdout?.on("data", (d) => acumular(d, "out"));
+            child.stderr?.on("data", (d) => acumular(d, "err"));
+            // Un pipe roto tras matar el arbol es lo esperado, no un error que contar.
+            child.stdout?.on("error", () => { });
+            child.stderr?.on("error", () => { });
+            const acabar = () => {
+                if (resuelto)
+                    return;
+                resuelto = true;
+                if (temporizador)
+                    clearTimeout(temporizador);
+                if (margen)
+                    clearTimeout(margen);
+                const limpio = (s) => s.replace(/\r?\n$/, "");
+                const partes = [];
+                if (stdout)
+                    partes.push(`STDOUT:\n${limpio(stdout)}`);
+                if (stderr)
+                    partes.push(`STDERR:\n${limpio(stderr)}`);
+                if (recortada) {
+                    partes.push(`(salida recortada: paso de ${MAX_OUTPUT_CHARS} caracteres)`);
+                }
+                if (porTiempo) {
+                    partes.push(
+                    // Con toFixed(0) un timeout de 1500 ms se anunciaba como "2s", que
+                    // no es lo que se pidio ni lo que se espero.
+                    `TIEMPO AGOTADO: el comando seguia corriendo tras ${(timeout / 1000).toFixed(timeout % 1000 === 0 ? 0 : 1)}s ` +
+                        `y se ha matado junto con todos sus procesos descendientes.\n` +
+                        `La salida de arriba esta incompleta y NO significa que el comando fallara. ` +
+                        `Si necesita mas tiempo, vuelve a lanzarlo con un 'timeout' mayor (hasta ${MAX_TIMEOUT_MS / 1000}s).`);
+                    resolve(partes.join("\n\n"));
+                    return;
+                }
+                // Fuera de la rama de timeout SIEMPRE se dice el codigo de salida: sin
+                // el, el agente no puede distinguir un exito silencioso de un fallo.
+                partes.push(`Exit code: ${exitCode}`);
+                if (colaDeFondo) {
+                    partes.push("Aviso: el comando termino pero dejo algo corriendo en segundo plano con la " +
+                        "salida abierta. Se dejo de leer ahi: lo que imprima a partir de ahora no se vera.");
+                }
+                resolve(partes.join("\n\n"));
+            };
+            child.on("error", (error) => {
+                // No llego a arrancar (shell inexistente, cwd que no existe...). No hay
+                // proceso que matar, pero si una promesa que resolver.
+                if (resuelto)
+                    return;
+                resuelto = true;
+                if (temporizador)
+                    clearTimeout(temporizador);
+                if (margen)
+                    clearTimeout(margen);
+                resolve(`Error al ejecutar comando: ${error?.message || String(error)}`);
+            });
+            child.on("exit", (code) => {
+                salio = true;
+                exitCode = code;
+                // Si ya se mato por tiempo, el margen del kill esta corriendo y manda el.
+                if (porTiempo || resuelto)
+                    return;
+                margen = setTimeout(() => {
+                    colaDeFondo = true;
+                    acabar();
+                }, DRAIN_MS);
+            });
+            // 'close' es el unico evento que garantiza que ya se leyo todo. Puede no
+            // llegar nunca si un nieto heredo el pipe: de ahi los dos temporizadores.
+            child.on("close", (code) => {
+                if (code !== null)
+                    exitCode = code;
+                acabar();
+            });
+            temporizador = setTimeout(() => {
+                if (resuelto)
+                    return;
+                // Murio justo en la frontera y solo faltaba drenar: eso no es un
+                // timeout, y llamarlo asi era la mentira que hacia relanzar comandos que
+                // habian terminado bien.
+                if (salio) {
+                    acabar();
+                    return;
+                }
+                porTiempo = true;
+                if (typeof child.pid === "number")
+                    killTree(child.pid);
+                margen = setTimeout(acabar, KILL_GRACE_MS);
+            }, timeout);
         });
-        const parts = [];
-        if (result.stdout)
-            parts.push(`STDOUT:\n${result.stdout}`);
-        if (result.stderr)
-            parts.push(`STDERR:\n${result.stderr}`);
-        if (result.timedOut) {
-            parts.push(`TIEMPO AGOTADO: el comando seguia corriendo tras ${(timeout / 1000).toFixed(0)}s y se detuvo.\n` +
-                `La salida de arriba esta incompleta y NO significa que el comando fallara. ` +
-                `Si necesita mas tiempo, vuelve a lanzarlo con un 'timeout' mayor (hasta ${MAX_TIMEOUT_MS / 1000}s).`);
-            return parts.join("\n\n");
-        }
-        parts.push(`Exit code: ${result.exitCode}`);
-        const output = parts.join("\n\n");
-        return output || "Comando ejecutado sin salida (código 0).";
     }
     catch (error) {
         return `Error al ejecutar comando: ${error?.message || String(error)}`;