chocolatito-code 1.6.8 → 1.6.10

package/README.md

@@ -1,4 +1,4 @@
-# 🦊 Chocolatito Code (v1.0.0)
+# 🦊 Chocolatito Code
 
 > **Agente Autónomo de Programación para la Terminal**, desarrollado por **Chocolatito** con la arquitectura del **Motor Espectro**.
 
@@ -200,6 +200,77 @@ Configuración compatible con Claude Code en `.mcp.json` (ver `.mcp.json.ejemplo
 
 Las herramientas aparecen como `mcp__<servidor>__<herramienta>`. Usa `/mcp` para ver el estado.
 
+## 🎒 Kits: móntatelo a tu manera (y pásaselo a otro)
+
+Chocolatito se puede enseñar. Cuatro cosas cambian cómo trabaja, y hasta ahora vivían
+cada una en su carpeta:
+
+| | |
+| --- | --- |
+| **Skills** | procedimientos que sabe hacer, y que carga solo cuando hacen falta |
+| **Reglas** | cómo quieres que trabaje: tu tono, tus formatos, tus manías |
+| **MCP** | los programas de fuera a los que se conecta |
+| **Memoria** | lo que tiene que saber de ti desde el minuto uno |
+
+Un **kit** es una carpeta con las cuatro dentro. Se instala de una vez, se quita de una
+vez, y se le pasa a otro por WhatsApp.
+
+```bash
+/kit                          # qué tienes puesto
+/kit instalar ./kits/diseno   # poner uno
+/kit crear mi-kit             # empaquetar lo tuyo para repartirlo
+/kit quitar diseno            # quitarlo entero, sin restos
+```
+
+### Qué lleva dentro
+
+```
+mi-kit/
+  kit.json        nombre, título, descripción      ← lo único obligatorio
+  skills/         una carpeta por skill, con su SKILL.md
+  reglas.md       cómo trabajar contigo
+  mcp.json        los servidores que necesita
+  memoria/        lo que tiene que saber de entrada
+```
+
+Instalar **no pisa nada sin decírtelo**: lo que choca con algo tuyo se salta y se te
+nombra (`--forzar` si de verdad quieres reemplazarlo). Los skills entran con el nombre
+del kit delante (`diseno--lote-de-imagenes`), así dos kits pueden traer uno que se llame
+igual, y quitar un kit no se lleva por delante lo que escribiste tú.
+
+Y cuando empaquetas lo tuyo con `/kit crear`, **tu memoria no viaja dentro** salvo que lo
+pidas con `--con-memoria`: ahí hay nombres, rutas y a qué te dedicas, y eso no se manda
+sin querer.
+
+### Enseñarle algo nuevo: `/aprende`
+
+Esta es la parte que de verdad lo hace tuyo. Cuando acabéis de resolver algo que se va a
+repetir:
+
+```
+/aprende
+/aprende exportar los assets del cliente como los pide siempre
+```
+
+Escribe un skill con **los pasos que funcionaron de verdad** —los comandos exactos, las
+rutas, lo que salió mal por el camino— y lo guarda en `~/.chocolatito/skills`. La próxima
+vez basta con nombrarlo. Repítelo un mes y tendrás un Chocolatito que trabaja como tú;
+mételo en un kit y tu equipo entero trabaja así.
+
+### El kit de diseño, de ejemplo
+
+Viene uno hecho, y no es de programación: `kits/diseno` trae lotes de imágenes con
+ImageMagick, las medidas de todas las redes (con las zonas seguras de historias, que es
+lo que nadie recuerda), y variantes de una misma pieza desde un CSV —cuarenta
+certificados con su nombre, sin una sola errata—.
+
+```bash
+/kit instalar ./kits/diseno
+```
+
+Sirve de plantilla: cópialo, cambia las reglas por las tuyas y ya tienes el kit de tu
+oficio.
+
 ## 🪝 Hooks
 
 Reglas propias que el agente no puede saltarse, en `.chocolatito/settings.json`:
@@ -278,6 +349,16 @@ Antes de hacer un commit o desplegar cambios, corre `/audit` o `/review`:
 - **Limpieza de depuración:** localiza sentencias residuales como `console.log`, `debugger;` o `print()`.
 - **Sugerencia de Conventional Commits:** genera automáticamente la propuesta de commit semántico según los archivos modificados (ej. `feat(tools): ...`, `test: ...`).
 
+Y se le puede decir dónde callarse. En una herramienta de terminal, `console.log` no es
+un olvido: es la salida del programa. Las rutas que pongas en un `.chocolatitoauditignore`
+—una por línea, `#` para comentar— dejan de salir en la sección de calidad, y el informe
+dice cuántas calló, para que nadie se encuentre el fichero un año después sin saberlo.
+
+**Lo que ese fichero NO puede callar: un secreto.** Una clave, un `.env` o una clave
+privada se avisan siempre, esté la ruta ignorada o no. Una herramienta que se deja
+configurar para callarse una credencial es peor que no tenerla, porque da la
+tranquilidad sin el aviso.
+
 ---
 
 ## 📌 Widget de Tareas en Vivo y Selector /resume

package/dist/agent/context.js

@@ -4,6 +4,7 @@ import { execa } from "execa";
 import { RULES_FILE_NAME } from "../config/constants.js";
 import { construirMapa } from "./repoMap.js";
 import { nombreDelSistema } from "../config/plataforma.js";
+import { leerReglasGlobales } from "../kits/manager.js";
 /** Tokens que puede ocupar el mapa dentro del prompt de sistema. */
 const PRESUPUESTO_MAPA = 4_000;
 /**
@@ -120,6 +121,16 @@ export async function getProjectContext(cwd = process.cwd()) {
             rulesContent = modularText;
         }
     }
+    // Reglas globales del usuario (~/.chocolatito/reglas/*.md), que es donde
+    // aterrizan las de los kits. Van DELANTE de las del proyecto a proposito: son
+    // como trabajas tu siempre, y lo que diga el repositorio que tienes abierto
+    // manda por encima de eso cuando los dos hablan de lo mismo.
+    const reglasGlobales = leerReglasGlobales();
+    if (reglasGlobales) {
+        rulesContent = rulesContent?.trim()
+            ? `${reglasGlobales}\n\n${rulesContent.trim()}`
+            : reglasGlobales;
+    }
     // 2. Git branch & status detection
     let gitBranch = null;
     try {

package/dist/index.js

@@ -32,6 +32,7 @@ import { HookManager } from "./hooks/manager.js";
 import { SessionManager } from "./sessions/manager.js";
 import { prepararRestauracion, formatearOpcionesDeSesion } from "./sessions/resume.js";
 import { auditGitDiff, formatAuditReport } from "./tools/gitAudit.js";
+import { instalarKit, listarKits, quitarKit, crearKit } from "./kits/manager.js";
 import { globalUndoManager } from "./agent/undoManager.js";
 import { setAutoApprove } from "./ui/permissionPrompt.js";
 import { onModeChange, getMode, modeAnnouncement } from "./ui/modes.js";
@@ -615,6 +616,91 @@ ${sessionData}
             console.log("");
             continue;
         }
+        if (trimmed === "/kit" || trimmed.startsWith("/kit ")) {
+            const partes = trimmed.split(/s+/).slice(1);
+            const accion = (partes[0] || "").toLowerCase();
+            const resto = partes.slice(1).filter((p) => !p.startsWith("--")).join(" ").trim().replace(/^["']|["']$/g, "");
+            if (!accion || accion === "lista" || accion === "listar") {
+                const kits = listarKits();
+                console.log(chalk.bold.hex("#D97757")("\n🎒 KITS INSTALADOS:"));
+                if (kits.length === 0) {
+                    console.log(chalk.gray("  Ninguno todavia.\n"));
+                    console.log(chalk.gray("  Un kit es una carpeta con skills, reglas, servidores MCP y memoria"));
+                    console.log(chalk.gray("  dentro. Sirve para montarte tu Chocolatito y pasarselo a otro.\n"));
+                    console.log(`  ${chalk.white("/kit instalar <carpeta>")}  ${chalk.gray("pone uno")}`);
+                    console.log(`  ${chalk.white("/kit crear <nombre>")}      ${chalk.gray("empaqueta lo que ya tienes")}\n`);
+                }
+                else {
+                    for (const k of kits) {
+                        const cuenta = (tipo) => (k.piezas || []).filter((p) => p.tipo === tipo).length;
+                        const trozos = [
+                            cuenta("skill") ? `${cuenta("skill")} skills` : "",
+                            cuenta("reglas") ? "reglas" : "",
+                            cuenta("mcp") ? `${cuenta("mcp")} MCP` : "",
+                            cuenta("memoria") ? `${cuenta("memoria")} notas` : "",
+                        ].filter(Boolean);
+                        console.log(`  ${chalk.hex("#A855F7")("•")} ${chalk.bold.white(k.titulo || k.nombre)} ${chalk.gray("(" + k.nombre + ")")}`);
+                        if (k.descripcion)
+                            console.log(`    ${chalk.gray(k.descripcion)}`);
+                        console.log(`    ${chalk.gray(trozos.join(" · ") || "sin piezas")}`);
+                    }
+                    console.log("");
+                }
+                continue;
+            }
+            if (accion === "instalar" || accion === "poner") {
+                if (!resto) {
+                    console.log(chalk.yellow("\n  Dime la carpeta: /kit instalar ./kits/diseno\n"));
+                    continue;
+                }
+                const carpeta = path.isAbsolute(resto) ? resto : path.resolve(agent.currentCwd, resto);
+                const res = instalarKit(carpeta, { forzar: partes.includes("--forzar") });
+                if (!res.ok) {
+                    console.log(chalk.red(`\n  ${res.error}\n`));
+                    continue;
+                }
+                console.log(chalk.green(`\n  ✔ Kit "${res.kit?.titulo || res.kit?.nombre}" instalado.`));
+                for (const p of res.instaladas)
+                    console.log(`    ${chalk.gray("+")} ${p.tipo} ${chalk.white(p.nombre)}`);
+                for (const sa of res.saltadas)
+                    console.log(`    ${chalk.yellow("·")} ${chalk.gray("se salto " + sa)}`);
+                for (const av of res.avisos)
+                    console.log(`    ${chalk.yellow("!")} ${chalk.gray(av)}`);
+                console.log(chalk.gray("\n  Los skills ya se pueden nombrar. Las reglas entran en la proxima sesion.\n"));
+                continue;
+            }
+            if (accion === "quitar" || accion === "borrar") {
+                const res = quitarKit(resto);
+                if (!res.ok) {
+                    console.log(chalk.red(`\n  ${res.error}\n`));
+                }
+                else {
+                    console.log(chalk.green(`\n  ✔ Kit "${resto}" quitado.`));
+                    for (const q of res.quitadas)
+                        console.log(`    ${chalk.gray("-")} ${q}`);
+                    console.log("");
+                }
+                continue;
+            }
+            if (accion === "crear" || accion === "empaquetar") {
+                const nombre = resto || "mi-kit";
+                const destino = path.resolve(agent.currentCwd, "kits", nombre);
+                const res = crearKit(destino, { nombre, titulo: nombre }, { incluirMemoria: partes.includes("--con-memoria") });
+                if (!res.ok) {
+                    console.log(chalk.red(`\n  ${res.error}\n`));
+                    continue;
+                }
+                console.log(chalk.green(`\n  ✔ Kit empaquetado en ${destino}`));
+                for (const i of res.incluidas)
+                    console.log(`    ${chalk.gray("+")} ${i}`);
+                if (res.incluidas.length === 0)
+                    console.log(chalk.gray("    (de momento vacio: crea skills o reglas y vuelve)"));
+                console.log(chalk.gray("\n  Tu memoria NO va dentro salvo que pongas --con-memoria.\n"));
+                continue;
+            }
+            console.log(chalk.yellow("\n  /kit · /kit instalar <carpeta> · /kit crear <nombre> · /kit quitar <nombre>\n"));
+            continue;
+        }
         if (trimmed === "/skills") {
             const skills = skillManager.scanSkills();
             console.log(chalk.bold.hex("#D97757")("\n🧩 SKILLS DISPONIBLES (Carga diferida):"));

package/dist/kits/manager.d.ts

@@ -0,0 +1,134 @@
+/**
+ * KITS: ARMAR TU PROPIO CHOCOLATITO, Y REGALARSELO A OTRO
+ *
+ * DE DONDE SALE
+ *
+ * Todas las piezas para que esto no sea solo una herramienta de programadores ya
+ * estaban puestas, cada una por su lado:
+ *
+ *   - los skills se buscan en cinco carpetas (skills/manager.ts:22)
+ *   - los MCP se leen de cuatro sitios (mcp/manager.ts:39)
+ *   - las reglas salen de CHOCOLATITO.md o .chocolatitorules (agent/context.ts)
+ *   - la memoria vive en ~/.chocolatito/memory
+ *
+ * Lo que faltaba era la capa de encima: una forma de mover las CUATRO a la vez.
+ * Hoy, para dejar a alguien el Chocolatito que tu te has montado, hay que
+ * explicarle cuatro carpetas distintas por WhatsApp. Nadie hace eso.
+ *
+ * QUE ES UN KIT
+ *
+ * Una carpeta con las cuatro cosas dentro y un `kit.json` que la nombra:
+ *
+ *   mi-kit/
+ *     kit.json          nombre, titulo, descripcion, autor
+ *     skills/           una carpeta por skill, con su SKILL.md
+ *     reglas.md         como quieres que trabaje (tono, formatos, manias)
+ *     mcp.json          los servidores MCP que necesita
+ *     memoria/          lo que tiene que saber de ti desde el minuto uno
+ *
+ * Todo es opcional menos `kit.json`. Un kit que solo trae reglas es un kit.
+ *
+ * TRES DECISIONES QUE NO SON OBVIAS
+ *
+ *  1. INSTALAR NO PISA NADA SIN DECIRLO. Un kit que llega de fuera no puede
+ *     tapar un skill que ya usas ni cambiarte un servidor MCP por otro en
+ *     silencio. Lo que choca se salta y se dice; con `forzar` se reemplaza.
+ *
+ *  2. LOS SKILLS SE INSTALAN CON EL NOMBRE DEL KIT DELANTE (`diseno--lote`).
+ *     Asi dos kits pueden traer un skill que se llama igual, y sobre todo: se
+ *     puede QUITAR un kit entero sin llevarse por delante lo que escribiste tu.
+ *
+ *  3. QUEDA CONSTANCIA DE QUIEN PUSO QUE. `~/.chocolatito/kits/<nombre>.json`
+ *     guarda la lista exacta de lo que se instalo. Sin eso, desinstalar es
+ *     adivinar, y adivinar borrando archivos ajenos es justo lo que no se hace.
+ */
+export interface KitManifiesto {
+    nombre: string;
+    titulo?: string;
+    descripcion?: string;
+    autor?: string;
+    version?: string;
+    /** Programas que el kit da por instalados. Solo se avisa; no se instala nada. */
+    requiere?: string[];
+}
+export interface PiezaInstalada {
+    tipo: "skill" | "reglas" | "mcp" | "memoria";
+    nombre: string;
+    ruta?: string;
+}
+export interface ResultadoInstalacion {
+    ok: boolean;
+    kit?: KitManifiesto;
+    instaladas: PiezaInstalada[];
+    saltadas: string[];
+    avisos: string[];
+    error?: string;
+}
+export interface KitInstalado extends KitManifiesto {
+    instaladoEl: string;
+    origen: string;
+    piezas: PiezaInstalada[];
+}
+export declare function raizChocolatito(home?: string): string;
+export declare function carpetaDeSkills(home?: string): string;
+export declare function carpetaDeReglas(home?: string): string;
+export declare function carpetaDeKits(home?: string): string;
+export declare function rutaDeMcp(home?: string): string;
+export declare function carpetaDeMemoria(home?: string): string;
+/** Lee y valida el kit.json de una carpeta. */
+export declare function leerManifiesto(carpetaKit: string): KitManifiesto | null;
+/**
+ * Instala un kit desde una carpeta.
+ *
+ * `home` se inyecta para poder probar esto sin tocar el ordenador de nadie.
+ */
+export declare function instalarKit(carpetaKit: string, opciones?: {
+    home?: string;
+    forzar?: boolean;
+}): ResultadoInstalacion;
+/** Los kits instalados, por orden de instalacion. */
+export declare function listarKits(home?: string): KitInstalado[];
+/**
+ * Quita un kit: borra SOLO lo que consta en su registro.
+ *
+ * Un servidor MCP que el usuario edito a mano despues de instalarlo se queda:
+ * el kit lo trajo, pero la version que hay ahora es suya.
+ */
+export declare function quitarKit(nombre: string, home?: string): {
+    ok: boolean;
+    quitadas: string[];
+    error?: string;
+};
+/**
+ * Empaqueta lo que ya tienes puesto en una carpeta que se puede pasar a otro.
+ *
+ * Se copia lo TUYO -lo que hay en ~/.chocolatito- y no lo que trajo otro kit:
+ * los skills con `--` en el nombre vienen de un kit ajeno y no son tuyos para
+ * repartirlos.
+ */
+export declare function crearKit(destino: string, manifiesto: KitManifiesto, opciones?: {
+    home?: string;
+    incluirMemoria?: boolean;
+}): {
+    ok: boolean;
+    incluidas: string[];
+    error?: string;
+};
+/**
+ * Guarda un skill nuevo. Es lo que hay detras de "aprende esto".
+ *
+ * Un skill es un SKILL.md con dos lineas de cabecera que el buscador ya sabe
+ * leer (skills/manager.ts:parseFrontmatter). Se escribe entero aqui para que
+ * el modelo no tenga que acordarse del formato ni pueda equivocarse con el.
+ */
+export declare function guardarSkill(nombre: string, descripcion: string, contenido: string, opciones?: {
+    home?: string;
+    cwd?: string;
+    ambito?: "global" | "proyecto";
+}): {
+    ok: boolean;
+    ruta?: string;
+    error?: string;
+};
+/** Las reglas globales del usuario, que los kits tambien alimentan. */
+export declare function leerReglasGlobales(home?: string): string;

package/dist/kits/manager.js

@@ -0,0 +1,329 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const NOMBRE_VALIDO = /^[a-z0-9][a-z0-9_-]{0,48}$/i;
+export function raizChocolatito(home = os.homedir()) {
+    return path.join(home, ".chocolatito");
+}
+export function carpetaDeSkills(home) {
+    return path.join(raizChocolatito(home), "skills");
+}
+export function carpetaDeReglas(home) {
+    return path.join(raizChocolatito(home), "reglas");
+}
+export function carpetaDeKits(home) {
+    return path.join(raizChocolatito(home), "kits");
+}
+export function rutaDeMcp(home) {
+    return path.join(raizChocolatito(home), "mcp.json");
+}
+export function carpetaDeMemoria(home) {
+    return path.join(raizChocolatito(home), "memory");
+}
+function asegurar(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function leerJson(ruta) {
+    try {
+        return JSON.parse(fs.readFileSync(ruta, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Lee y valida el kit.json de una carpeta. */
+export function leerManifiesto(carpetaKit) {
+    const manifiesto = leerJson(path.join(carpetaKit, "kit.json"));
+    if (!manifiesto || typeof manifiesto.nombre !== "string")
+        return null;
+    if (!NOMBRE_VALIDO.test(manifiesto.nombre))
+        return null;
+    return manifiesto;
+}
+function copiarArchivo(origen, destino) {
+    asegurar(path.dirname(destino));
+    fs.copyFileSync(origen, destino);
+}
+function copiarCarpeta(origen, destino) {
+    asegurar(destino);
+    for (const entrada of fs.readdirSync(origen, { withFileTypes: true })) {
+        const de = path.join(origen, entrada.name);
+        const a = path.join(destino, entrada.name);
+        if (entrada.isDirectory())
+            copiarCarpeta(de, a);
+        else if (entrada.isFile())
+            fs.copyFileSync(de, a);
+    }
+}
+/**
+ * Instala un kit desde una carpeta.
+ *
+ * `home` se inyecta para poder probar esto sin tocar el ordenador de nadie.
+ */
+export function instalarKit(carpetaKit, opciones = {}) {
+    const { home, forzar = false } = opciones;
+    const instaladas = [];
+    const saltadas = [];
+    const avisos = [];
+    if (!fs.existsSync(carpetaKit) || !fs.statSync(carpetaKit).isDirectory()) {
+        return { ok: false, instaladas, saltadas, avisos, error: `No existe la carpeta ${carpetaKit}.` };
+    }
+    const kit = leerManifiesto(carpetaKit);
+    if (!kit) {
+        return {
+            ok: false,
+            instaladas,
+            saltadas,
+            avisos,
+            error: `En ${carpetaKit} no hay un kit.json valido (hace falta al menos {"nombre": "..."}).`,
+        };
+    }
+    // ---------------------------------------------------------------- skills
+    const dirSkillsKit = path.join(carpetaKit, "skills");
+    if (fs.existsSync(dirSkillsKit)) {
+        const destinoBase = asegurar(carpetaDeSkills(home));
+        for (const entrada of fs.readdirSync(dirSkillsKit, { withFileTypes: true })) {
+            const esCarpetaConSkill = entrada.isDirectory() && fs.existsSync(path.join(dirSkillsKit, entrada.name, "SKILL.md"));
+            const esArchivoMd = entrada.isFile() && entrada.name.endsWith(".md");
+            if (!esCarpetaConSkill && !esArchivoMd)
+                continue;
+            const nombreSkill = esArchivoMd ? entrada.name.replace(/\.md$/, "") : entrada.name;
+            const destino = path.join(destinoBase, `${kit.nombre}--${nombreSkill}`);
+            if (fs.existsSync(destino) && !forzar) {
+                saltadas.push(`skill ${kit.nombre}--${nombreSkill} (ya estaba; usa forzar para reemplazar)`);
+                continue;
+            }
+            if (esCarpetaConSkill) {
+                copiarCarpeta(path.join(dirSkillsKit, entrada.name), destino);
+            }
+            else {
+                copiarArchivo(path.join(dirSkillsKit, entrada.name), path.join(destino, "SKILL.md"));
+            }
+            instaladas.push({ tipo: "skill", nombre: `${kit.nombre}--${nombreSkill}`, ruta: destino });
+        }
+    }
+    // ---------------------------------------------------------------- reglas
+    const reglasKit = path.join(carpetaKit, "reglas.md");
+    if (fs.existsSync(reglasKit)) {
+        const destino = path.join(asegurar(carpetaDeReglas(home)), `${kit.nombre}.md`);
+        if (fs.existsSync(destino) && !forzar) {
+            saltadas.push(`reglas de ${kit.nombre} (ya estaban)`);
+        }
+        else {
+            copiarArchivo(reglasKit, destino);
+            instaladas.push({ tipo: "reglas", nombre: `${kit.nombre}.md`, ruta: destino });
+        }
+    }
+    // ------------------------------------------------------------------- mcp
+    const mcpKit = leerJson(path.join(carpetaKit, "mcp.json"));
+    if (mcpKit?.mcpServers && Object.keys(mcpKit.mcpServers).length > 0) {
+        const destino = rutaDeMcp(home);
+        const actual = leerJson(destino) || {};
+        const servidores = { ...(actual.mcpServers || {}) };
+        for (const [nombre, cfg] of Object.entries(mcpKit.mcpServers)) {
+            if (servidores[nombre] && !forzar) {
+                saltadas.push(`servidor MCP "${nombre}" (ya tenias uno con ese nombre)`);
+                continue;
+            }
+            servidores[nombre] = cfg;
+            instaladas.push({ tipo: "mcp", nombre, ruta: destino });
+        }
+        asegurar(path.dirname(destino));
+        fs.writeFileSync(destino, JSON.stringify({ ...actual, mcpServers: servidores }, null, 2), "utf-8");
+    }
+    // --------------------------------------------------------------- memoria
+    const dirMemoriaKit = path.join(carpetaKit, "memoria");
+    if (fs.existsSync(dirMemoriaKit)) {
+        const destinoBase = asegurar(carpetaDeMemoria(home));
+        for (const entrada of fs.readdirSync(dirMemoriaKit, { withFileTypes: true })) {
+            if (!entrada.isFile() || !entrada.name.endsWith(".md"))
+                continue;
+            if (entrada.name.toUpperCase() === "MEMORY.MD")
+                continue; // el indice es del usuario
+            const destino = path.join(destinoBase, `${kit.nombre}--${entrada.name}`);
+            if (fs.existsSync(destino) && !forzar) {
+                saltadas.push(`nota de memoria ${entrada.name} (ya estaba)`);
+                continue;
+            }
+            copiarArchivo(path.join(dirMemoriaKit, entrada.name), destino);
+            instaladas.push({ tipo: "memoria", nombre: entrada.name, ruta: destino });
+        }
+    }
+    // Lo que el kit da por instalado en el sistema. No se instala nada solo:
+    // bajar programas a la maquina de alguien porque lo pide un fichero de fuera
+    // es exactamente lo que no debe hacer un instalador de kits.
+    if (kit.requiere?.length) {
+        avisos.push(`Este kit da por hecho que tienes: ${kit.requiere.join(", ")}.`);
+    }
+    const registro = {
+        ...kit,
+        instaladoEl: new Date().toISOString(),
+        origen: path.resolve(carpetaKit),
+        piezas: instaladas,
+    };
+    const dirKits = asegurar(carpetaDeKits(home));
+    fs.writeFileSync(path.join(dirKits, `${kit.nombre}.json`), JSON.stringify(registro, null, 2), "utf-8");
+    return { ok: true, kit, instaladas, saltadas, avisos };
+}
+/** Los kits instalados, por orden de instalacion. */
+export function listarKits(home) {
+    const dir = carpetaDeKits(home);
+    if (!fs.existsSync(dir))
+        return [];
+    const kits = [];
+    for (const archivo of fs.readdirSync(dir)) {
+        if (!archivo.endsWith(".json"))
+            continue;
+        const k = leerJson(path.join(dir, archivo));
+        if (k?.nombre)
+            kits.push(k);
+    }
+    return kits.sort((a, b) => (a.instaladoEl || "").localeCompare(b.instaladoEl || ""));
+}
+/**
+ * Quita un kit: borra SOLO lo que consta en su registro.
+ *
+ * Un servidor MCP que el usuario edito a mano despues de instalarlo se queda:
+ * el kit lo trajo, pero la version que hay ahora es suya.
+ */
+export function quitarKit(nombre, home) {
+    const registroPath = path.join(carpetaDeKits(home), `${nombre}.json`);
+    const registro = leerJson(registroPath);
+    if (!registro)
+        return { ok: false, quitadas: [], error: `No hay ningun kit instalado con el nombre "${nombre}".` };
+    const quitadas = [];
+    for (const pieza of registro.piezas || []) {
+        try {
+            if (pieza.tipo === "mcp") {
+                const destino = rutaDeMcp(home);
+                const actual = leerJson(destino);
+                if (actual?.mcpServers && actual.mcpServers[pieza.nombre]) {
+                    delete actual.mcpServers[pieza.nombre];
+                    fs.writeFileSync(destino, JSON.stringify(actual, null, 2), "utf-8");
+                    quitadas.push(`servidor MCP ${pieza.nombre}`);
+                }
+                continue;
+            }
+            if (pieza.ruta && fs.existsSync(pieza.ruta)) {
+                fs.rmSync(pieza.ruta, { recursive: true, force: true });
+                quitadas.push(`${pieza.tipo} ${pieza.nombre}`);
+            }
+        }
+        catch { }
+    }
+    try {
+        fs.rmSync(registroPath, { force: true });
+    }
+    catch { }
+    return { ok: true, quitadas };
+}
+/**
+ * Empaqueta lo que ya tienes puesto en una carpeta que se puede pasar a otro.
+ *
+ * Se copia lo TUYO -lo que hay en ~/.chocolatito- y no lo que trajo otro kit:
+ * los skills con `--` en el nombre vienen de un kit ajeno y no son tuyos para
+ * repartirlos.
+ */
+export function crearKit(destino, manifiesto, opciones = {}) {
+    const { home, incluirMemoria = false } = opciones;
+    if (!NOMBRE_VALIDO.test(manifiesto.nombre || "")) {
+        return { ok: false, incluidas: [], error: "El nombre del kit solo admite letras, numeros, guion y guion bajo." };
+    }
+    const incluidas = [];
+    asegurar(destino);
+    fs.writeFileSync(path.join(destino, "kit.json"), JSON.stringify({ version: "1.0.0", ...manifiesto }, null, 2), "utf-8");
+    const dirSkills = carpetaDeSkills(home);
+    if (fs.existsSync(dirSkills)) {
+        for (const entrada of fs.readdirSync(dirSkills, { withFileTypes: true })) {
+            if (!entrada.isDirectory() || entrada.name.includes("--"))
+                continue;
+            copiarCarpeta(path.join(dirSkills, entrada.name), path.join(destino, "skills", entrada.name));
+            incluidas.push(`skill ${entrada.name}`);
+        }
+    }
+    const dirReglas = carpetaDeReglas(home);
+    if (fs.existsSync(dirReglas)) {
+        const propias = fs
+            .readdirSync(dirReglas)
+            .filter((a) => a.endsWith(".md") && !listarKits(home).some((k) => `${k.nombre}.md` === a));
+        if (propias.length > 0) {
+            const texto = propias
+                .map((a) => fs.readFileSync(path.join(dirReglas, a), "utf-8").trim())
+                .join("\n\n");
+            fs.writeFileSync(path.join(destino, "reglas.md"), `${texto}\n`, "utf-8");
+            incluidas.push("reglas");
+        }
+    }
+    const mcp = leerJson(rutaDeMcp(home));
+    if (mcp?.mcpServers && Object.keys(mcp.mcpServers).length > 0) {
+        fs.writeFileSync(path.join(destino, "mcp.json"), JSON.stringify({ mcpServers: mcp.mcpServers }, null, 2), "utf-8");
+        incluidas.push(`${Object.keys(mcp.mcpServers).length} servidores MCP`);
+    }
+    // La memoria NO va por defecto, y es a proposito: ahi dentro hay cosas tuyas
+    // -nombres, rutas, a que te dedicas- que no pensabas repartir al mandar un kit.
+    if (incluirMemoria) {
+        const dirMemoria = carpetaDeMemoria(home);
+        if (fs.existsSync(dirMemoria)) {
+            for (const archivo of fs.readdirSync(dirMemoria)) {
+                if (!archivo.endsWith(".md") || archivo.toUpperCase() === "MEMORY.MD")
+                    continue;
+                copiarArchivo(path.join(dirMemoria, archivo), path.join(destino, "memoria", archivo));
+                incluidas.push(`memoria ${archivo}`);
+            }
+        }
+    }
+    return { ok: true, incluidas };
+}
+/**
+ * Guarda un skill nuevo. Es lo que hay detras de "aprende esto".
+ *
+ * Un skill es un SKILL.md con dos lineas de cabecera que el buscador ya sabe
+ * leer (skills/manager.ts:parseFrontmatter). Se escribe entero aqui para que
+ * el modelo no tenga que acordarse del formato ni pueda equivocarse con el.
+ */
+export function guardarSkill(nombre, descripcion, contenido, opciones = {}) {
+    const limpio = (nombre || "").trim().toLowerCase().replace(/\s+/g, "-");
+    if (!NOMBRE_VALIDO.test(limpio)) {
+        return { ok: false, error: "El nombre del skill solo admite letras, numeros, guion y guion bajo." };
+    }
+    if (!descripcion?.trim()) {
+        return { ok: false, error: "Un skill sin descripcion no se encuentra nunca: es lo que se lee para elegirlo." };
+    }
+    if (!contenido?.trim()) {
+        return { ok: false, error: "Falta el contenido del skill." };
+    }
+    const ambito = opciones.ambito || "global";
+    const base = ambito === "proyecto"
+        ? path.join(opciones.cwd || process.cwd(), ".skills")
+        : carpetaDeSkills(opciones.home);
+    const carpeta = asegurar(path.join(base, limpio));
+    const ruta = path.join(carpeta, "SKILL.md");
+    const texto = `---\nname: ${limpio}\ndescription: ${descripcion.trim().replace(/\s+/g, " ")}\n---\n\n${contenido.trim()}\n`;
+    try {
+        fs.writeFileSync(ruta, texto, "utf-8");
+        return { ok: true, ruta };
+    }
+    catch (err) {
+        return { ok: false, error: err?.message || String(err) };
+    }
+}
+/** Las reglas globales del usuario, que los kits tambien alimentan. */
+export function leerReglasGlobales(home) {
+    const dir = carpetaDeReglas(home);
+    if (!fs.existsSync(dir))
+        return "";
+    const trozos = [];
+    for (const archivo of fs.readdirSync(dir).sort()) {
+        if (!archivo.endsWith(".md"))
+            continue;
+        try {
+            const texto = fs.readFileSync(path.join(dir, archivo), "utf-8").trim();
+            if (texto)
+                trozos.push(`[~/.chocolatito/reglas/${archivo}]:\n${texto}`);
+        }
+        catch { }
+    }
+    return trozos.join("\n\n");
+}

package/dist/tools/definitions.js

@@ -50,6 +50,38 @@ export const TOOLS = [
             },
         },
     },
+    {
+        type: "function",
+        function: {
+            name: "save_skill",
+            description: "Guarda un procedimiento aprendido como skill reutilizable, para repetirlo en sesiones futuras con solo nombrarlo. " +
+                "Usalo cuando el usuario diga 'aprende esto', 'recuerda como se hace' o cuando acabes de resolver algo que se va a repetir. " +
+                "Escribe los PASOS que funcionaron, con los comandos exactos, no un resumen de lo que paso.",
+            parameters: {
+                type: "object",
+                properties: {
+                    nombre: {
+                        type: "string",
+                        description: "Nombre corto en minusculas y con guiones (ej. 'exportar-para-instagram').",
+                    },
+                    descripcion: {
+                        type: "string",
+                        description: "Una linea que diga CUANDO usar este skill. Es lo unico que se ve al elegirlo, asi que tiene que describir la situacion, no el contenido.",
+                    },
+                    contenido: {
+                        type: "string",
+                        description: "Las instrucciones completas en Markdown: pasos, comandos exactos, avisos y ejemplos.",
+                    },
+                    ambito: {
+                        type: "string",
+                        enum: ["global", "proyecto"],
+                        description: "'global' (~/.chocolatito/skills, sirve en todas partes) o 'proyecto' (.skills/ de esta carpeta). Por defecto global.",
+                    },
+                },
+                required: ["nombre", "descripcion", "contenido"],
+            },
+        },
+    },
     {
         type: "function",
         function: {

package/dist/tools/gitAudit.d.ts

@@ -19,6 +19,8 @@ export interface AuditReport {
     secrets: AuditFinding[];
     debugLogs: AuditFinding[];
     residualLogs: AuditFinding[];
+    /** Cuantas sentencias se callaron por `.chocolatitoauditignore`. Se dice siempre. */
+    debugSilenciados: number;
     sensitiveFiles: string[];
     suggestedCommit: string;
     rawDiff: string;
@@ -35,7 +37,32 @@ export declare const DEBUG_PATTERNS: Array<{
 export declare function esDocumentacion(archivo: string): boolean;
 /** Quita los trozos entre comillas invertidas: `asi` y ``asi``. */
 export declare function sinCitasEnLinea(texto: string): string;
-export declare function auditDiffText(rawDiff: string, changedFiles?: string[]): AuditReport;
+/**
+ * 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 declare const ARCHIVO_DE_IGNORADOS = ".chocolatitoauditignore";
+export declare function leerPatronesIgnorados(cwd: string): string[];
+/** Un patron de `.chocolatitoauditignore` contra una ruta del diff. */
+export declare function rutaIgnorada(archivo: string, patrones: string[]): boolean;
+export declare function auditDiffText(rawDiff: string, changedFiles?: string[], patronesIgnorados?: string[]): AuditReport;
 export declare function auditGitDiff(cwd?: string, mockDiff?: string): Promise<AuditReport>;
 export declare function suggestConventionalCommit(files: string[], _insertions: number, _deletions: number): string;
 export declare function formatAuditReport(report: AuditReport): string;

package/dist/tools/gitAudit.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import chalk from "chalk";
 import { ejecutarGit } from "./gitTools.js";
 export const SECRET_PATTERNS = [
@@ -16,7 +18,11 @@ export const SENSITIVE_FILE_PATTERN = /(?:^|[/\\])(\.env(?:\.[a-zA-Z0-9_-]+)?|id
 export const DEBUG_PATTERNS = [
     { name: "console.log", pattern: /\bconsole\.log\s*\(/ },
     { name: "console.debug", pattern: /\bconsole\.debug\s*\(/ },
-    { name: "debugger", pattern: /\bdebugger\b/ },
+    // `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*\(/ },
@@ -60,10 +66,79 @@ export function esDocumentacion(archivo) {
 export function sinCitasEnLinea(texto) {
     return texto.replace(/``[^`]*``/g, " ").replace(/`[^`]*`/g, " ");
 }
-export function auditDiffText(rawDiff, changedFiles = []) {
+/**
+ * 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);
@@ -119,9 +194,16 @@ export function auditDiffText(rawDiff, changedFiles = []) {
                     });
                 }
             }
+            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",
@@ -156,6 +238,7 @@ export function auditDiffText(rawDiff, changedFiles = []) {
         secrets,
         debugLogs,
         residualLogs: debugLogs,
+        debugSilenciados,
         sensitiveFiles,
         suggestedCommit,
         rawDiff,
@@ -174,6 +257,7 @@ export async function auditGitDiff(cwd = process.cwd(), mockDiff) {
             secrets: [],
             debugLogs: [],
             residualLogs: [],
+            debugSilenciados: 0,
             sensitiveFiles: [],
             suggestedCommit: "chore: update project",
             rawDiff: statusRes.error,
@@ -188,6 +272,7 @@ export async function auditGitDiff(cwd = process.cwd(), mockDiff) {
             secrets: [],
             debugLogs: [],
             residualLogs: [],
+            debugSilenciados: 0,
             sensitiveFiles: [],
             suggestedCommit: "chore: no pending changes",
             rawDiff: "",
@@ -205,7 +290,7 @@ export async function auditGitDiff(cwd = process.cwd(), mockDiff) {
         diffRes = await ejecutarGit(["diff"], cwd);
     }
     const rawDiff = diffRes.ok ? diffRes.stdout : "";
-    return auditDiffText(rawDiff, changedFiles);
+    return auditDiffText(rawDiff, changedFiles, leerPatronesIgnorados(cwd));
 }
 export function suggestConventionalCommit(files, _insertions, _deletions) {
     if (files.length === 0)
@@ -268,8 +353,15 @@ export function formatAuditReport(report) {
         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."));
     }

package/dist/tools/runner.js

@@ -26,6 +26,7 @@ import { validateFileSyntax } from "../agent/syntaxValidator.js";
 import { fileTracker } from "../agent/fileTracker.js";
 import { mcpManager } from "../mcp/manager.js";
 import { taskManager } from "./backgroundTask.js";
+import { guardarSkill } from "../kits/manager.js";
 import fs from "node:fs";
 import path from "node:path";
 /**
@@ -82,6 +83,18 @@ export async function executeToolCall(name, args, cwd = process.cwd(), apiKey, m
                 }
                 break;
             }
+            case "save_skill": {
+                // Aprender algo no puede depender de que el modelo se acuerde del
+                // formato del SKILL.md: la cabecera la escribe guardarSkill().
+                const res = guardarSkill(args.nombre, args.descripcion, args.contenido, {
+                    cwd,
+                    ambito: args.ambito === "proyecto" ? "proyecto" : "global",
+                });
+                rawResult = res.ok
+                    ? `Skill "${args.nombre}" guardado en ${res.ruta}. Ya se puede usar por su nombre en cualquier sesion.`
+                    : `No se pudo guardar el skill: ${res.error}`;
+                break;
+            }
             case "save_memory":
                 memoryManager.setCwd(cwd);
                 rawResult = memoryManager.saveMemory(args.topic, args.fact, args.scope);

package/dist/ui/comandos.js

@@ -30,6 +30,8 @@ export const SLASH_COMMANDS = [
     { name: "/plan", description: "Alternar Modo Plan (solo lectura e investigación previa)" },
     { name: "/resume", description: "Reanudar una sesión anterior guardada", args: "[id]" },
     { name: "/skills", description: "Ver skills disponibles y cómo usarlos" },
+    { name: "/kit", description: "Montar tu Chocolatito: instalar, crear o quitar kits (skills + reglas + MCP)", args: "[instalar|crear|quitar] [nombre]" },
+    { name: "/aprende", description: "Guardar lo que acabamos de hacer como skill reutilizable", args: "[en pocas palabras]" },
     { name: "/memory", description: "Consultar la memoria persistente transversal (~/.chocolatito/memory/)" },
     { name: "/effort", description: "Regular potencia del motor (1.0, 1.5, 2.0, 2.5)", args: "[nivel]" },
     { name: "/goal", description: "Ejecutar meta compleja autónoma con auto-corrección", args: "<meta>" },

package/extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "minimum_chrome_version": "102",
   "name": "Chocolatito Code",
-  "version": "1.6.8",
+  "version": "1.6.10",
   "description": "Deja que Chocolatito Code trabaje dentro de tu Chrome, en segundo plano y con tus sesiones ya iniciadas.",
   "permissions": [
     "tabs",

package/kits/diseno/kit.json

@@ -0,0 +1,8 @@
+{
+  "nombre": "diseno",
+  "titulo": "Diseño gráfico",
+  "descripcion": "Lotes de imágenes, exportación para redes y variantes de una misma pieza. Para quien trabaja con archivos, no con código.",
+  "autor": "Chocolatito",
+  "version": "1.0.0",
+  "requiere": ["ImageMagick (magick)", "ffmpeg"]
+}

package/kits/diseno/reglas.md

@@ -0,0 +1,26 @@
+# Cómo trabajar conmigo
+
+No soy programador. No me expliques el código que vas a escribir ni me pegues
+scripts para que los revise: dime qué vas a hacer con mis archivos, en una línea,
+y hazlo.
+
+## Lo que no se toca
+
+- **Nunca sobreescribas un original.** Todo lo que proceses va a una carpeta
+  nueva (`salida/`, `export/`, `2048/`), y si esa carpeta ya existe, pregunta.
+- Antes de un lote de más de veinte archivos, **haz uno solo y enséñamelo.** Si
+  ese está bien, sigue con el resto sin volver a preguntar.
+- Si un archivo da error, sáltalo y sigue. Al final dime cuáles fallaron. No
+  pares el lote entero por uno roto.
+
+## Cómo enseñarme el resultado
+
+Dime la ruta de la carpeta y cuántos archivos salieron, con su peso. Si algo
+cambió de proporción o se recortó, avísame: eso es lo que se ve mal luego.
+
+## Palabras que uso
+
+- "para web" = 72 ppp, sRGB, y comprimido de verdad (que pese poco).
+- "para imprenta" = 300 ppp, sin tocar el color, sin recomprimir.
+- "cuadrado" = recorte centrado, no deformar. Nunca estires una imagen.
+- "limpio" = sin fondo, PNG con transparencia.

package/kits/diseno/skills/exportar-para-redes/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: exportar-para-redes
+description: Usar cuando haya que sacar una misma pieza en los tamaños de Instagram, TikTok, YouTube, LinkedIn o historias — el clásico "dame esto en todos los formatos".
+---
+
+# Exportar para redes
+
+Las medidas, que son lo que nadie se acuerda:
+
+| Sitio | Medida | Notas |
+| --- | --- | --- |
+| Instagram feed | 1080 × 1350 | El vertical 4:5 ocupa más pantalla que el cuadrado |
+| Instagram cuadrado | 1080 × 1080 | |
+| Historias / Reels / TikTok | 1080 × 1920 | 9:16 |
+| YouTube miniatura | 1280 × 720 | Menos de 2 MB |
+| YouTube Short | 1080 × 1920 | |
+| LinkedIn | 1200 × 627 | |
+| X / Twitter | 1600 × 900 | |
+| Portada de Facebook | 1640 × 856 | |
+
+## Imagen
+
+Todas de una vez, sin deformar nada:
+
+```bash
+for m in 1080x1350 1080x1080 1080x1920 1280x720; do
+  magick original.jpg -resize ${m}^ -gravity center -extent $m -quality 88 "redes/${m}.jpg"
+done
+```
+
+**La zona segura importa más que la medida.** En historias y Reels, la interfaz
+se come unos 250 px arriba y 350 abajo: si el texto va ahí, queda tapado por el
+nombre de la cuenta o los botones. Cuando recortes a 9:16 desde algo horizontal,
+dilo — casi siempre hay que recolocar el texto, y eso no lo arregla el recorte.
+
+## Vídeo
+
+Vertical desde un horizontal, recortando por el centro:
+
+```bash
+ffmpeg -i entrada.mp4 -vf "crop=ih*9/16:ih,scale=1080:1920" -c:a copy salida.mp4
+```
+
+Con desenfoque a los lados en vez de recortar (se pierde menos):
+
+```bash
+ffmpeg -i entrada.mp4 -lavfi "[0:v]scale=1080:-1,boxblur=20[fondo];[0:v]scale=1080:-1[primero];[fondo][primero]overlay=(W-w)/2:(H-h)/2" -c:a copy salida.mp4
+```
+
+Límites que hacen que te rechacen la subida: TikTok y Reels, **menos de 90 s**
+para que no baje la calidad; miniatura de YouTube, **menos de 2 MB**.
+
+## Al terminar
+
+Enseña la carpeta con cada archivo y su peso, y avisa de cualquiera que se haya
+recortado de forma que pueda comerse algo importante.

package/kits/diseno/skills/lote-de-imagenes/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: lote-de-imagenes
+description: Usar cuando haya que procesar muchas imágenes de una carpeta a la vez — redimensionar, recortar, convertir de formato, comprimir para web, renombrar en serie o quitar el fondo.
+---
+
+# Lote de imágenes
+
+Un lote es cualquier cosa que el usuario diría como "a todas las de esta
+carpeta". La herramienta es **ImageMagick** (`magick`), y el trabajo va por
+`run_command`.
+
+## Antes de empezar, siempre
+
+1. Comprueba que ImageMagick está: `magick -version`. Si no está, dilo y para —
+   en Windows se instala con `winget install ImageMagick.ImageMagick`.
+2. Cuenta lo que hay: `magick identify -format "%f %wx%h\n" *.jpg | wc -l`.
+3. **Crea la carpeta de salida.** Nunca escribas encima del original.
+4. **Haz el primero y enséñalo.** Solo entonces sigue con el resto.
+
+## Recetas que funcionan
+
+**Redimensionar cabiendo dentro de una caja** (no deforma nunca):
+
+```bash
+magick mogrify -path salida/ -resize 2048x2048\> -quality 85 *.jpg
+```
+
+El `\>` es la parte importante: encoge lo que es más grande y **no agranda** lo
+que ya es pequeño, que es lo que arruina una foto.
+
+**Cuadrado recortando por el centro**, para una cuadrícula de Instagram:
+
+```bash
+magick mogrify -path salida/ -resize 1080x1080^ -gravity center -extent 1080x1080 *.jpg
+```
+
+`^` llena la caja y `-extent` corta lo que sobra. Sin `^` quedan bandas.
+
+**Comprimir para web de verdad** (esto es lo que baja el peso, no el tamaño):
+
+```bash
+magick mogrify -path web/ -strip -interlace Plane -sampling-factor 4:2:0 -quality 82 *.jpg
+```
+
+`-strip` quita los metadatos (a veces la mitad del archivo). Para WebP, que pesa
+un tercio: `-format webp -quality 80`.
+
+**A PNG con transparencia, quitando un fondo liso:**
+
+```bash
+magick entrada.jpg -fuzz 12% -transparent white salida.png
+```
+
+Sube el `-fuzz` si el fondo no es un blanco perfecto. Para fondos complejos esto
+no vale: hace falta una herramienta de recorte por IA, dilo y no lo intentes.
+
+**Renombrar en serie con numeración:**
+
+```bash
+magick mogrify -path salida/ -format jpg *.HEIC   # y de paso convierte
+```
+
+## Al terminar
+
+Di cuántos salieron, cuánto pesaban antes y cuánto ahora:
+
+```bash
+du -sh original/ salida/
+```
+
+Y nombra los que fallaron, si hubo alguno. No hace falta explicar por qué falló
+cada uno: la ruta y "no se pudo" basta.

package/kits/diseno/skills/variantes-de-pieza/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: variantes-de-pieza
+description: Usar cuando haya que hacer muchas versiones de una misma pieza cambiando el texto, el color o el idioma — banners por producto, certificados con nombres, carteles por ciudad, tarjetas por persona.
+---
+
+# Variantes de una misma pieza
+
+El encargo clásico: "la misma pieza, pero con estos cuarenta nombres". A mano son
+dos horas; aquí son dos minutos y **ninguna errata**, porque el texto sale del
+archivo de datos y no de copiar y pegar.
+
+## Cómo se hace
+
+1. **Pide los datos en una tabla.** Un CSV con una columna por cosa que cambia
+   (`nombre,cargo,ciudad`). Si el usuario los tiene en Excel, que exporte a CSV;
+   si los tiene sueltos, escríbelos tú en un CSV y enséñaselo antes de seguir.
+2. **La plantilla, en SVG.** Es texto plano, así que sustituir es trivial y el
+   resultado sale nítido a cualquier tamaño. Si el usuario trae un PNG o un JPG
+   de fondo, se incrusta dentro del SVG y el texto va encima.
+3. **Una variante primero.** Enséñala. Ahí se ven el tipo de letra, el encuadre y
+   si el texto largo se sale.
+4. El resto de golpe.
+
+## Plantilla y sustitución
+
+```svg
+<svg xmlns="http://www.w3.org/2000/svg" width="1080" height="1080">
+  <image href="fondo.jpg" width="1080" height="1080"/>
+  <text x="540" y="600" text-anchor="middle" font-family="Inter, sans-serif"
+        font-size="72" font-weight="700" fill="#ffffff">{{NOMBRE}}</text>
+</svg>
+```
+
+Genera un SVG por fila sustituyendo `{{NOMBRE}}`, y conviértelos:
+
+```bash
+magick -density 300 salida/variante-01.svg salida/variante-01.png
+```
+
+Usa `create_image` con SVG cuando la pieza sea sencilla, y `run_command` con un
+script cuando sean muchas.
+
+## Lo que se rompe siempre
+
+- **El texto largo se sale.** Mira el nombre más largo del CSV ANTES de lanzar el
+  lote y ajusta el tamaño de letra a ese, no al primero.
+- **Las tildes y las ñ.** El SVG va en UTF-8; si salen cuadraditos, es la fuente.
+- **La fuente de marca.** Si no está instalada, el sistema pone otra y todas las
+  piezas salen mal a la vez. Compruébalo en la primera: `magick -list font | grep -i <fuente>`.
+- **Nombres de archivo con acentos o barras** rompen el lote. Numera: `pieza-01`,
+  `pieza-02`, y aparte una tabla que diga cuál es cuál.
+
+## Al terminar
+
+Una hoja de contactos para revisarlo todo de un vistazo:
+
+```bash
+magick montage salida/*.png -tile 5x -geometry 300x300+8+8 revision.jpg
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chocolatito-code",
-  "version": "1.6.8",
+  "version": "1.6.10",
   "description": "Agente autónomo de programación para la terminal, con control real del ordenador y del navegador. Desarrollado por Chocolatito.",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
     "dist",
     "extension",
     "skills",
+    "kits",
     "LICENSE",
     "README.md",
     "COMPUTER-USE.md",