chocolatito-code 1.6.7 → 1.6.9

package/dist/tools/gitAudit.js

@@ -0,0 +1,374 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { ejecutarGit } from "./gitTools.js";
+export const SECRET_PATTERNS = [
+    { name: "Clave de API de OpenAI", pattern: /\bsk-[a-zA-Z0-9]{20,}\b/ },
+    { name: "Clave de API de Anthropic", pattern: /\bsk-ant-[a-zA-Z0-9_-]{20,}\b/ },
+    { name: "Clave de AWS (Access Key)", pattern: /\bAKIA[0-9A-Z]{16}\b/ },
+    { name: "Clave de API de Google", pattern: /\bAIza[0-9A-Za-z\-_]{30,40}\b/ },
+    { name: "Token de acceso de GitHub", pattern: /\bgh[pousr]_[A-Za-z0-9_]{36,}\b/ },
+    { name: "Clave privada (RSA/EC/OpenSSH)", pattern: /-----BEGIN (?:[A-Z ]+)?PRIVATE KEY-----/ },
+    {
+        name: "Asignación genérica de credencial o token",
+        pattern: /(?:secret|password|passwd|api_key|apikey|token|auth_token)\s*[:=]\s*["'][^"'\s]{8,}["']/i,
+    },
+];
+export const SENSITIVE_FILE_PATTERN = /(?:^|[/\\])(\.env(?:\.[a-zA-Z0-9_-]+)?|id_rsa|id_ed25519|.*\.pem)$/i;
+export const DEBUG_PATTERNS = [
+    { name: "console.log", pattern: /\bconsole\.log\s*\(/ },
+    { name: "console.debug", pattern: /\bconsole\.debug\s*\(/ },
+    // `debugger` como PALABRA sale tambien dentro de una frase: el propio aviso
+    // de esta herramienta dice "ni console.log ni debugger" y se denunciaba solo.
+    // Un `debugger` de verdad es una sentencia: lleva punto y coma, o esta sola en
+    // su linea. Eso es lo que se busca.
+    { name: "debugger", pattern: /(?:^|[;{}])\s*debugger\s*(?:;|$)/ },
+    { name: "print()", pattern: /(?<![\w.])print\s*\(/ },
+    { name: "var_dump", pattern: /\bvar_dump\s*\(/ },
+    { name: "dd()", pattern: /(?<![\w.])dd\s*\(/ },
+];
+/**
+ * LA DOCUMENTACION NO ES CODIGO, Y ESO AQUI IMPORTA
+ *
+ * La primera vez que se paso este auditor por su propio repositorio, se denuncio
+ * a si mismo: la linea del README que dice que detecta `console.log`, `debugger`
+ * y `print()` contiene, por fuerza, un `console.log`, un `debugger` y un
+ * `print()`. Cinco avisos de calidad y una "clave privada" que era la cabecera
+ * `-----BEGIN PRIVATE KEY-----` citada dentro de un parrafo.
+ *
+ * Un auditor que grita en cuanto alguien lo documenta es un auditor que se deja
+ * de leer, y entonces no sirve para lo unico que tiene que servir: que el aviso
+ * de verdad se vea. Asi que:
+ *
+ *  - Las sentencias de depuracion solo se buscan en archivos de codigo. Un
+ *    `console.log` dentro de un .md no es un resto de depuracion: es una frase.
+ *  - En documentacion, lo que va entre comillas invertidas es una cita, no una
+ *    credencial. Se quitan esos trozos ANTES de buscar secretos.
+ *
+ * Lo que NO se toca: una clave de verdad pegada en un README sigue saltando. Una
+ * clave real ocupa mil y pico caracteres y llega en un bloque cercado o a pelo,
+ * nunca dentro de un `span` de una linea, que es lo unico que se ignora.
+ */
+const EXTENSIONES_DE_DOCUMENTACION = new Set([
+    "md",
+    "markdown",
+    "mdx",
+    "txt",
+    "rst",
+    "adoc",
+    "org",
+]);
+export function esDocumentacion(archivo) {
+    const ext = archivo.split(".").pop()?.toLowerCase() || "";
+    return EXTENSIONES_DE_DOCUMENTACION.has(ext);
+}
+/** Quita los trozos entre comillas invertidas: `asi` y ``asi``. */
+export function sinCitasEnLinea(texto) {
+    return texto.replace(/``[^`]*``/g, " ").replace(/`[^`]*`/g, " ");
+}
+/**
+ * SE PUEDE CALLAR EL RUIDO, NUNCA UN SECRETO
+ *
+ * En un programa de terminal, `console.log` NO es un resto de depuracion: es la
+ * interfaz. Este repositorio tiene ocho en `src/index.ts` que son justo eso -el
+ * enlace de `--servir`, el aviso de que solo escucha en esta maquina- y salian
+ * los ocho en cada auditoria. Ocho avisos que hay que ignorar a mano cada vez
+ * son ocho razones para dejar de leer la seccion entera.
+ *
+ * Adivinar cual es interfaz y cual es un olvido no se puede hacer desde fuera:
+ * es la misma llamada. Asi que lo dice el proyecto, en un `.chocolatitoauditignore`
+ * al lado del `.gitignore`, una ruta o un patron por linea, y `#` para comentar.
+ *
+ * Con un limite que no se negocia: **esto solo calla la seccion de calidad**. Un
+ * secreto, un archivo sensible o una clave privada se avisan siempre, este la
+ * ruta ignorada o no. Una herramienta que se puede configurar para callarse una
+ * credencial es peor que no tenerla, porque da la tranquilidad sin el aviso.
+ *
+ * Y lo que se calla se cuenta: el informe dice cuantos silencio, para que nadie
+ * descubra el fichero un año despues sin saber que estaba puesto.
+ */
+export const ARCHIVO_DE_IGNORADOS = ".chocolatitoauditignore";
+export function leerPatronesIgnorados(cwd) {
+    try {
+        const crudo = fs.readFileSync(path.join(cwd, ARCHIVO_DE_IGNORADOS), "utf-8");
+        return crudo
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && !l.startsWith("#"));
+    }
+    catch {
+        return [];
+    }
+}
+/** Un patron de `.chocolatitoauditignore` contra una ruta del diff. */
+export function rutaIgnorada(archivo, patrones) {
+    if (!archivo || patrones.length === 0)
+        return false;
+    const ruta = archivo.replace(/\\/g, "/").replace(/^\.\//, "");
+    const base = ruta.split("/").pop() || ruta;
+    for (const crudo of patrones) {
+        const patron = crudo.replace(/\\/g, "/").replace(/^\.\//, "");
+        // Una carpeta: "src/ui/" tapa todo lo que hay dentro.
+        if (patron.endsWith("/")) {
+            if (ruta.startsWith(patron))
+                return true;
+            continue;
+        }
+        // "**" cruza barras, "*" no: src/*.ts no baja a src/ui/marco.ts, src/**/*.ts si.
+        const comoRegex = patron
+            .split("**")
+            .map((trozo) => trozo
+            .replace(/[.+^$(){}|[\]\\]/g, (m) => "\\" + m)
+            .replace(/\*/g, "[^/]*")
+            .replace(/\?/g, "[^/]"))
+            .join(".*");
+        const re = new RegExp(`^${comoRegex}$`);
+        if (re.test(ruta))
+            return true;
+        // Un patron sin barras ("*.min.js") mira tambien solo el nombre.
+        if (!patron.includes("/") && re.test(base))
+            return true;
+        // Una carpeta escrita sin barra final ("src/ui") tapa igual lo de dentro.
+        if (ruta.startsWith(`${patron}/`))
+            return true;
+    }
+    return false;
+}
+export function auditDiffText(rawDiff, changedFiles = [], patronesIgnorados = []) {
+    const secrets = [];
+    const debugLogs = [];
+    const sensitiveFiles = [];
+    let debugSilenciados = 0;
+    for (const f of changedFiles) {
+        if (SENSITIVE_FILE_PATTERN.test(f) && !sensitiveFiles.includes(f)) {
+            sensitiveFiles.push(f);
+        }
+    }
+    let currentFile = "";
+    let currentLine = 0;
+    let insertions = 0;
+    let deletions = 0;
+    const diffFiles = new Set(changedFiles);
+    const lines = rawDiff.split("\n");
+    for (const line of lines) {
+        if (line.startsWith("diff --git ")) {
+            const parts = line.split(" ");
+            currentFile = parts[parts.length - 1]?.replace(/^b\//, "") || "";
+            if (currentFile)
+                diffFiles.add(currentFile);
+            if (SENSITIVE_FILE_PATTERN.test(currentFile) && !sensitiveFiles.includes(currentFile)) {
+                sensitiveFiles.push(currentFile);
+            }
+            continue;
+        }
+        if (line.startsWith("+++ b/")) {
+            currentFile = line.slice(6).trim();
+            if (currentFile)
+                diffFiles.add(currentFile);
+            if (SENSITIVE_FILE_PATTERN.test(currentFile) && !sensitiveFiles.includes(currentFile)) {
+                sensitiveFiles.push(currentFile);
+            }
+            continue;
+        }
+        if (line.startsWith("@@ ")) {
+            const hunkMatch = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+            if (hunkMatch) {
+                currentLine = parseInt(hunkMatch[1], 10) - 1;
+            }
+            continue;
+        }
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            insertions++;
+            currentLine++;
+            const addedContent = line.slice(1).trim();
+            const enDocumentacion = esDocumentacion(currentFile || "");
+            const paraSecretos = enDocumentacion ? sinCitasEnLinea(addedContent) : addedContent;
+            for (const sp of SECRET_PATTERNS) {
+                if (sp.pattern.test(paraSecretos)) {
+                    secrets.push({
+                        type: "secret",
+                        file: currentFile || "diff",
+                        line: currentLine,
+                        message: sp.name,
+                        snippet: addedContent.length > 50 ? `${addedContent.slice(0, 47)}…` : addedContent,
+                    });
+                }
+            }
+            const silenciado = rutaIgnorada(currentFile || "", patronesIgnorados);
+            for (const dp of DEBUG_PATTERNS) {
+                if (enDocumentacion)
+                    break;
+                if (silenciado) {
+                    // Se cuenta aunque no se liste: callar no es esconder.
+                    if (dp.pattern.test(addedContent))
+                        debugSilenciados++;
+                    continue;
+                }
+                if (dp.pattern.test(addedContent)) {
+                    debugLogs.push({
+                        type: "debug",
+                        file: currentFile || "diff",
+                        line: currentLine,
+                        message: dp.name,
+                        snippet: addedContent.length > 50 ? `${addedContent.slice(0, 47)}…` : addedContent,
+                    });
+                }
+            }
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            deletions++;
+        }
+        else {
+            currentLine++;
+        }
+    }
+    const allFiles = Array.from(diffFiles);
+    const clean = allFiles.length === 0 && insertions === 0 && deletions === 0 && secrets.length === 0 && sensitiveFiles.length === 0;
+    const suggestedCommit = suggestConventionalCommit(allFiles, insertions, deletions);
+    return {
+        ok: true,
+        clean,
+        stats: {
+            filesChanged: allFiles.length,
+            insertions,
+            additions: insertions,
+            deletions,
+            files: allFiles,
+        },
+        secrets,
+        debugLogs,
+        residualLogs: debugLogs,
+        debugSilenciados,
+        sensitiveFiles,
+        suggestedCommit,
+        rawDiff,
+    };
+}
+export async function auditGitDiff(cwd = process.cwd(), mockDiff) {
+    if (mockDiff !== undefined) {
+        return auditDiffText(mockDiff);
+    }
+    const statusRes = await ejecutarGit(["status", "--porcelain"], cwd);
+    if (!statusRes.ok) {
+        return {
+            ok: false,
+            clean: true,
+            stats: { filesChanged: 0, insertions: 0, additions: 0, deletions: 0, files: [] },
+            secrets: [],
+            debugLogs: [],
+            residualLogs: [],
+            debugSilenciados: 0,
+            sensitiveFiles: [],
+            suggestedCommit: "chore: update project",
+            rawDiff: statusRes.error,
+        };
+    }
+    const statusLines = statusRes.stdout.split("\n").filter((l) => l.trim().length > 0);
+    if (statusLines.length === 0) {
+        return {
+            ok: true,
+            clean: true,
+            stats: { filesChanged: 0, insertions: 0, additions: 0, deletions: 0, files: [] },
+            secrets: [],
+            debugLogs: [],
+            residualLogs: [],
+            debugSilenciados: 0,
+            sensitiveFiles: [],
+            suggestedCommit: "chore: no pending changes",
+            rawDiff: "",
+        };
+    }
+    const changedFiles = [];
+    for (const sl of statusLines) {
+        const filePath = sl.slice(3).trim().replace(/^.*->\s*/, "");
+        if (filePath) {
+            changedFiles.push(filePath);
+        }
+    }
+    let diffRes = await ejecutarGit(["diff", "HEAD"], cwd);
+    if (!diffRes.ok || !diffRes.stdout) {
+        diffRes = await ejecutarGit(["diff"], cwd);
+    }
+    const rawDiff = diffRes.ok ? diffRes.stdout : "";
+    return auditDiffText(rawDiff, changedFiles, leerPatronesIgnorados(cwd));
+}
+export function suggestConventionalCommit(files, _insertions, _deletions) {
+    if (files.length === 0)
+        return "chore: no pending changes";
+    const allTests = files.every((f) => f.startsWith("tests/") || f.includes(".test.") || f.includes(".spec."));
+    if (allTests) {
+        const mod = files[0].replace(/^tests\//, "").replace(/\.(test|spec)\.[a-zA-Z0-9]+$/, "");
+        return `test(${mod || "suite"}): add comprehensive test coverage`;
+    }
+    const allDocs = files.every((f) => f.endsWith(".md") || f.startsWith("docs/"));
+    if (allDocs) {
+        return "docs: update documentation and project specifications";
+    }
+    const allTools = files.every((f) => f.includes("tools/") || f.includes("tool"));
+    if (allTools) {
+        return "feat(tools): improve CLI tools and execution workflows";
+    }
+    const allUI = files.every((f) => f.includes("ui/") || f.includes("prompt") || f.includes("pie"));
+    if (allUI) {
+        return "feat(ui): refine interactive terminal interface and widgets";
+    }
+    const hasNewFeature = files.some((f) => f.startsWith("src/"));
+    if (hasNewFeature) {
+        return "feat: enhance core functionality and developer experience";
+    }
+    return "chore: update project files";
+}
+export function formatAuditReport(report) {
+    if (report.clean) {
+        return chalk.green("\n✔ Repositorio limpio. No hay cambios pendientes para auditar.\n");
+    }
+    const lines = [];
+    lines.push(chalk.bold.hex("#D97757")("\n🦊 AUDITORÍA DE CAMBIOS (PRE-COMMIT)"));
+    lines.push(chalk.gray(`  ${report.stats.filesChanged} archivos modificados · ${chalk.green(`+${report.stats.insertions}`)} / ${chalk.red(`-${report.stats.deletions}`)}`));
+    lines.push("");
+    if (report.sensitiveFiles.length > 0 || report.secrets.length > 0) {
+        lines.push(chalk.bold.red("  🚨 ADVERTENCIA DE SEGURIDAD:"));
+        for (const sf of report.sensitiveFiles) {
+            lines.push(chalk.red(`    ✖ Archivo sensible detectado: `) + chalk.bold.white(sf));
+        }
+        for (const s of report.secrets) {
+            const loc = s.line ? `:${s.line}` : "";
+            lines.push(chalk.red(`    ✖ [${s.message}] en `) +
+                chalk.bold.white(`${s.file}${loc}`) +
+                chalk.gray(`: "${s.snippet || ""}"`));
+        }
+        lines.push("");
+    }
+    else {
+        lines.push(chalk.green("  ✔ Seguridad: Sin credenciales ni claves de API expuestas en el diff."));
+    }
+    if (report.debugLogs.length > 0) {
+        lines.push(chalk.yellow(`  ⚠ Calidad de código: ${report.debugLogs.length} sentencias de depuración encontradas:`));
+        for (const d of report.debugLogs.slice(0, 5)) {
+            const loc = d.line ? `:${d.line}` : "";
+            lines.push(chalk.gray(`    • [${d.message}] en `) +
+                chalk.white(`${d.file}${loc}`) +
+                chalk.gray(`: "${d.snippet || ""}"`));
+        }
+        if (report.debugLogs.length > 5) {
+            lines.push(chalk.gray(`    ... y ${report.debugLogs.length - 5} más.`));
+        }
+        if (report.debugSilenciados > 0) {
+            lines.push(chalk.gray(`    (${report.debugSilenciados} más en rutas de ${ARCHIVO_DE_IGNORADOS}, sin listar.)`));
+        }
+        lines.push("");
+    }
+    else if (report.debugSilenciados > 0) {
+        lines.push(chalk.green("  ✔ Calidad: Sin rastros nuevos de console.log ni debugger") +
+            chalk.gray(` (${report.debugSilenciados} en rutas de ${ARCHIVO_DE_IGNORADOS}, sin listar).`));
+    }
+    else {
+        lines.push(chalk.green("  ✔ Calidad: Sin rastros de console.log ni debugger en líneas nuevas."));
+    }
+    lines.push("");
+    lines.push(chalk.bold.hex("#A855F7")("  💡 Sugerencia de Commit Semántico (Conventional Commits):"));
+    lines.push(`     ${chalk.bold.white(report.suggestedCommit)}`);
+    lines.push(chalk.gray(`     (Usa: /commit "${report.suggestedCommit}")`));
+    lines.push("");
+    return lines.join("\n");
+}

package/dist/tools/runCommand.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { esWindows, shellPosix } from "../config/plataforma.js";
 import { StringDecoder } from "node:string_decoder";
 /**
  * Ejecucion de comandos de shell.
@@ -108,9 +109,11 @@ export async function runCommand(command, cwd = process.cwd(), timeoutMs) {
         return "Aviso: para esperar, usa 'computer_use' con action 'wait' y ms, en vez de bloquear un shell.";
     }
     const timeout = Math.min(Math.max(timeoutMs || DEFAULT_TIMEOUT_MS, 1_000), MAX_TIMEOUT_MS);
-    const isWindows = process.platform === "win32";
+    const isWindows = esWindows;
     // Se usa de verdad el shell que toca. En Windows, PowerShell.
-    const shellPath = isWindows ? "powershell.exe" : "/bin/bash";
+    // En Unix no se pone "/bin/bash" a pelo: en Termux ese archivo no existe y
+    // fallarian todos los comandos, no solo alguno. Ver config/plataforma.
+    const shellPath = isWindows ? "powershell.exe" : shellPosix("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

package/dist/tools/runner.js

@@ -25,6 +25,7 @@ import { globalUndoManager } from "../agent/undoManager.js";
 import { validateFileSyntax } from "../agent/syntaxValidator.js";
 import { fileTracker } from "../agent/fileTracker.js";
 import { mcpManager } from "../mcp/manager.js";
+import { taskManager } from "./backgroundTask.js";
 import fs from "node:fs";
 import path from "node:path";
 /**
@@ -82,10 +83,12 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
                 break;
             }
             case "save_memory":
-                rawResult = memoryManager.saveMemory(args.topic, args.fact);
+                memoryManager.setCwd(cwd);
+                rawResult = memoryManager.saveMemory(args.topic, args.fact, args.scope);
                 break;
             case "read_memory":
-                rawResult = memoryManager.readMemory(args.topic);
+                memoryManager.setCwd(cwd);
+                rawResult = memoryManager.readMemory(args.topic, args.scope);
                 break;
             case "spawn_agent": {
                 if (!apiKey) {
@@ -201,6 +204,37 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
             case "run_command":
                 rawResult = await runCommand(args.command, cwd, args.timeout);
                 break;
+            case "start_background_task": {
+                const res = await taskManager.startTask(args.command, args.cwd || cwd, args.description);
+                rawResult = `Tarea iniciada en segundo plano:\n- ID: ${res.taskId}\n- PID: ${res.pid}\n- Estado: ${res.status}\n- Log: ${res.logPath}`;
+                break;
+            }
+            case "read_task_output": {
+                const res = taskManager.readTaskOutput(args.taskId, args.lines, args.offset);
+                if (res.status === "not_found") {
+                    rawResult = res.output;
+                }
+                else {
+                    rawResult = `[Tarea ${res.taskId}] Estado: ${res.status} (Exit Code: ${res.exitCode !== null ? res.exitCode : "N/A"})\nTotal de líneas: ${res.totalLines}\n--- Salida ---\n${res.output || "(sin salida aún)"}`;
+                }
+                break;
+            }
+            case "list_background_tasks": {
+                const tasks = taskManager.listTasks();
+                if (tasks.length === 0) {
+                    rawResult = "No hay tareas en segundo plano registradas.";
+                }
+                else {
+                    const lines = tasks.map((t) => `- [${t.taskId}] PID ${t.pid} | ${t.status.toUpperCase()} | Ejecución: ${t.runtimeSeconds}s | Comando: "${t.command}"${t.description ? ` (${t.description})` : ""}${t.exitCode !== null ? ` | Exit code: ${t.exitCode}` : ""}`);
+                    rawResult = `Tareas en segundo plano (${tasks.length}):\n${lines.join("\n")}`;
+                }
+                break;
+            }
+            case "stop_background_task": {
+                const res = await taskManager.stopTask(args.taskId, args.force);
+                rawResult = res.message;
+                break;
+            }
             case "list_dir":
                 rawResult = await listDir(args.dirPath || ".", cwd);
                 break;

package/dist/tools/safety.d.ts

@@ -7,6 +7,7 @@
  * estado. En cambio dos escrituras seguidas SI pueden pisarse, y el orden
  * importa, asi que esas van una detras de otra.
  */
+export declare const READ_ONLY_TOOLS: Set<string>;
 export declare function isReadOnly(toolName: string): boolean;
 /**
  * Un lote solo se paraleliza si TODAS sus llamadas son de solo lectura y hay

package/dist/tools/safety.js

@@ -18,7 +18,10 @@ const READ_ONLY = new Set([
     "web_search",
     "read_memory",
     "use_skill",
+    "read_task_output",
+    "list_background_tasks",
 ]);
+export const READ_ONLY_TOOLS = READ_ONLY;
 export function isReadOnly(toolName) {
     return READ_ONLY.has(toolName);
 }

package/dist/tools/todoTool.d.ts

@@ -5,4 +5,6 @@ export interface TaskItem {
 }
 export declare function setSessionTasks(tasks: TaskItem[]): string;
 export declare function getSessionTasks(): TaskItem[];
+export declare function renderTaskWidget(tasks?: TaskItem[]): string | null;
+export declare function sincronizarTareasConPie(tasks?: TaskItem[]): void;
 export declare function renderTaskList(tasks: TaskItem[]): string;

package/dist/tools/todoTool.js

@@ -1,12 +1,41 @@
 import chalk from "chalk";
+import { fijarSeccion, quitarSeccion } from "../ui/pieFijo.js";
 let sessionTasks = [];
 export function setSessionTasks(tasks) {
     sessionTasks = tasks;
+    sincronizarTareasConPie(sessionTasks);
     return renderTaskList(sessionTasks);
 }
 export function getSessionTasks() {
     return sessionTasks;
 }
+export function renderTaskWidget(tasks) {
+    const list = tasks !== undefined ? tasks : sessionTasks;
+    if (!list || list.length === 0)
+        return null;
+    const total = list.length;
+    const completed = list.filter((t) => t.status === "completed").length;
+    const inProgress = list.find((t) => t.status === "in_progress");
+    return (chalk.hex("#D97757")("⎿") +
+        " " +
+        chalk.green("✔") +
+        ` ${completed}/${total} tareas` +
+        (inProgress
+            ? chalk.gray(" · ") + chalk.hex("#D97757")("En curso: ") + chalk.bold.white(inProgress.text)
+            : completed === total
+                ? chalk.green(" · Completado")
+                : ""));
+}
+export function sincronizarTareasConPie(tasks) {
+    const list = tasks !== undefined ? tasks : sessionTasks;
+    const widget = renderTaskWidget(list);
+    if (widget) {
+        fijarSeccion("tareas", [widget]);
+    }
+    else {
+        quitarSeccion("tareas");
+    }
+}
 export function renderTaskList(tasks) {
     if (tasks.length === 0)
         return "No hay tareas registradas.";

package/dist/tools/toolDefsComputer.js

@@ -111,6 +111,8 @@ export const COMPUTER_USE_TOOL = {
                         "scroll",
                         "type",
                         "key",
+                        "hotkey",
+                        "press",
                         "wait",
                         "wait_change",
                         "cursor_position",
@@ -183,11 +185,14 @@ export const CHROME_TOOL = {
                         "status", "tabs", "open", "select_tab", "navigate", "snapshot",
                         "click", "type", "press", "get_text", "eval", "wait_for",
                         "screenshot", "notice", "close_tab", "done",
+                        "console_logs", "network_errors",
                     ],
                     description: "status: comprueba que la extension esta conectada. tabs: lista las pestanas del usuario. " +
                         "open: abre una pestana nueva SIN quitarle la pantalla al usuario. select_tab: elige una ya abierta. " +
                         "snapshot: LEE la pagina y numera los elementos. click/type: actuan sobre un ref. " +
                         "wait_for: espera un texto o unos ms. screenshot: captura la pestana aunque no este visible y la describe. " +
+                        "console_logs: obtiene errores y advertencias de consola y excepciones no controladas de la pagina. " +
+                        "network_errors: obtiene peticiones de red HTTP fallidas (4xx/5xx o errores de conexion). " +
                         "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." },
@@ -212,6 +217,10 @@ export const CHROME_TOOL = {
                 analyze: { type: "boolean", description: "false para no gastar tokens de vision." },
                 outputPath: { type: "string", description: "Ruta donde guardar la captura." },
                 note: { type: "string", description: "Texto inicial del aviso flotante al abrir la pestana." },
+                clear: {
+                    type: "boolean",
+                    description: "true para limpiar el buffer tras consultar (en console_logs o network_errors).",
+                },
             },
             required: ["action"],
         },

package/dist/tools/win/hostScript.js

@@ -283,9 +283,14 @@ public static class Choco
         double scale = 1.0;
         int longEdge = Math.Max(w, h);
         if (maxLongEdge > 0 && longEdge > maxLongEdge) scale = (double)maxLongEdge / (double)longEdge;
+        ImageFormat fmt = ImageFormat.Png;
+        if (path.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) || path.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase))
+        {
+            fmt = ImageFormat.Jpeg;
+        }
         if (scale >= 0.999)
         {
-            bmp.Save(path, ImageFormat.Png);
+            bmp.Save(path, fmt);
             return 1.0;
         }
         int nw = (int)Math.Round(w * scale), nh = (int)Math.Round(h * scale);
@@ -294,7 +299,7 @@ public static class Choco
         {
             g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
             g.DrawImage(bmp, 0, 0, nw, nh);
-            dst.Save(path, ImageFormat.Png);
+            dst.Save(path, fmt);
         }
         return scale;
     }

package/dist/ui/comandos.js

@@ -35,6 +35,8 @@ export const SLASH_COMMANDS = [
     { name: "/goal", description: "Ejecutar meta compleja autónoma con auto-corrección", args: "<meta>" },
     { name: "/compact", description: "Comprimir contexto y optimizar memoria de la sesión" },
     { name: "/diff", description: "Ver diferencias de código (Git diff) del proyecto" },
+    { name: "/audit", description: "Auditar git diff en busca de secretos, logs residuales y sugerir commit", args: "[review]" },
+    { name: "/review", description: "Revisar cambios pendientes de git (alias de /audit)" },
     { name: "/commit", description: "Crear un commit en Git con mensaje semántico", args: "<mensaje>" },
     { name: "/cd", description: "Cambiar el directorio de trabajo activo", args: "<ruta>" },
     { name: "/uso", description: "Ver cuánto llevas consumido de tu cuenta" },

package/dist/ui/marco.d.ts

@@ -13,6 +13,7 @@ export interface PromptFrameOptions {
     cursorIndex?: number;
     items?: DropdownItem[];
     selectedIndex?: number;
+    taskWidget?: string;
 }
 export interface PromptFrame {
     /** Lineas LOGICAS. Cualquiera puede ocupar mas de una fila fisica. */

package/dist/ui/marco.js

@@ -214,7 +214,9 @@ export function buildPromptFrame(opts) {
     // Dos, no una. Con una, la caja seguia leyendose pegada a lo de arriba: "pusiste
     // una linea de espacio, que sea bien pues". Con dos se separa de verdad, y es
     // el mismo aire que hay al arrancar entre el zorro y el aviso.
-    const lines = ["", "", bar, inputLine, ...dropdownLines, bar, footerLine];
+    const widgetLines = opts.taskWidget && opts.taskWidget.trim().length > 0 ? [opts.taskWidget] : [];
+    const widgetRows = widgetLines.reduce((n, l) => n + physicalRows(l, cols), 0);
+    const lines = ["", "", ...widgetLines, bar, inputLine, ...dropdownLines, bar, footerLine];
     // 4. Donde queda el cursor, en filas fisicas. Antes se hacia cursorCol =
     // total % cols: aplicaba el modulo pero nunca sumaba la fila, asi que en
     // cuanto la entrada se partia el acento se iba a escribir a otra linea.
@@ -222,7 +224,7 @@ export function buildPromptFrame(opts) {
     const segments = typed.split("\n");
     // La fila de aire de arriba cuenta: sin sumarla, el cursor se dibuja una fila
     // por encima de donde se escribe.
-    let cursorRow = 2 + physicalRows(bar, cols);
+    let cursorRow = 2 + widgetRows + physicalRows(bar, cols);
     for (let i = 0; i < segments.length - 1; i++) {
         cursorRow += Math.max(1, Math.ceil(((i === 0 ? symbolWidth : 0) + segments[i].length) / cols));
     }

package/dist/ui/permissionPrompt.d.ts

@@ -26,3 +26,12 @@ export declare function buildPermissionBox(toolName: string, args: Record<string
  * 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[];