chocolatito-code 1.6.10 → 1.6.12

package/README.md

@@ -262,7 +262,9 @@ mételo en un kit y tu equipo entero trabaja así.
 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—.
+certificados con su nombre, sin una sola errata—. Y carruseles: partir una panorámica en
+diapositivas que deslizan como una sola imagen, numeradas con ceros para que se suban en
+orden (`slide-1, slide-10, slide-2` es el error que aparece con el carrusel ya publicado).
 
 ```bash
 /kit instalar ./kits/diseno

package/dist/agent/huecos.d.ts

@@ -56,3 +56,27 @@ export declare function liberarHuecos(): void;
  * que hacer nada: es lo unico que se arregla solo con esperar.
  */
 export declare function mensajeDeEspera(segundos: number): string;
+/**
+ * Espera a que se libere el hueco, en vez de devolverle la pared al usuario.
+ *
+ * DE DONDE SALE
+ *
+ * La misma sesion, un paso mas alla. Ya no se gastaba una peticion por intento
+ * -eso lo arreglo lo de arriba-, pero el usuario seguia atrapado:
+ *
+ *     > sigue
+ *     ⏸  Faltan 144s.
+ *     > sigoe
+ *     ⏸  Faltan 133s.
+ *
+ * Tecleando contra una pared que el programa sabia medir. Si sabemos que faltan
+ * 133 segundos, esperarlos es trabajo del programa, no del que paga. Se avisa,
+ * se cuenta hacia atras y se sigue solo; con Esc se deja.
+ *
+ * Vuelve `true` si ya hay hueco y `false` si el usuario corto.
+ */
+export declare function esperarAlHueco(opciones: {
+    signal?: AbortSignal;
+    alPasarUnSegundo?: (quedan: number) => void;
+    dormir?: (ms: number) => Promise<void>;
+}): Promise<boolean>;

package/dist/agent/huecos.js

@@ -79,3 +79,37 @@ export function mensajeDeEspera(segundos) {
         "No llamo al motor porque la respuesta seria la misma y cada intento puede alargar la espera. " +
         "No hace falta que hagas nada: el hueco se libera solo.");
 }
+/**
+ * Espera a que se libere el hueco, en vez de devolverle la pared al usuario.
+ *
+ * DE DONDE SALE
+ *
+ * La misma sesion, un paso mas alla. Ya no se gastaba una peticion por intento
+ * -eso lo arreglo lo de arriba-, pero el usuario seguia atrapado:
+ *
+ *     > sigue
+ *     ⏸  Faltan 144s.
+ *     > sigoe
+ *     ⏸  Faltan 133s.
+ *
+ * Tecleando contra una pared que el programa sabia medir. Si sabemos que faltan
+ * 133 segundos, esperarlos es trabajo del programa, no del que paga. Se avisa,
+ * se cuenta hacia atras y se sigue solo; con Esc se deja.
+ *
+ * Vuelve `true` si ya hay hueco y `false` si el usuario corto.
+ */
+export async function esperarAlHueco(opciones) {
+    const { signal, alPasarUnSegundo } = opciones;
+    const dormir = opciones.dormir || ((ms) => new Promise((r) => setTimeout(r, ms)));
+    // Se relee en cada vuelta en vez de contar desde un numero fijo: si algo
+    // libera los huecos antes -otra respuesta del motor-, se sale en el acto.
+    let quedan = segundosDeEspera();
+    while (quedan > 0) {
+        if (signal?.aborted)
+            return false;
+        alPasarUnSegundo?.(quedan);
+        await dormir(1000);
+        quedan = segundosDeEspera();
+    }
+    return !signal?.aborted;
+}

package/dist/agent/loop.js

@@ -8,7 +8,7 @@ import { CONTEXT_WINDOW, MAX_OUTPUT_TOKENS, COMPACT_THRESHOLD_TOKENS, } from "..
 import { withRetry, isContextOverflow, esDemasiadasEnCurso } from "./retry.js";
 import { canRunInParallel } from "../tools/safety.js";
 import { createEngineClient, explicarErrorDelMotor, motivoDeParadaDelError, } from "../config/engine.js";
-import { anotarHuecosOcupados, liberarHuecos, mensajeDeEspera, segundosDeEspera } from "./huecos.js";
+import { anotarHuecosOcupados, esperarAlHueco, liberarHuecos, mensajeDeEspera, segundosDeEspera, } from "./huecos.js";
 import { MarkdownStream } from "../ui/markdownStream.js";
 import { checkQuota, recordUsage, mensajeDeCorte, quotaBadge } from "../config/quota.js";
 import { ReasoningStream } from "../ui/reasoningStream.js";
@@ -461,9 +461,43 @@ export class AgentLoop {
         // llamada es justo la que puede refrescar la reserva y alargar la espera.
         const espera = segundosDeEspera();
         if (espera > 0) {
+            // ESPERAR ES TRABAJO DEL PROGRAMA, NO DEL QUE PAGA
+            //
+            // Antes esto devolvia el aviso y cortaba el turno. El usuario escribia
+            // "sigue", se llevaba "faltan 144s", escribia otra vez y se llevaba
+            // "faltan 133s": tecleando contra una pared que el programa sabia medir.
+            // Si sabemos cuanto falta, se espera y se sigue solo. Con Esc se deja.
             const aviso = mensajeDeEspera(espera);
-            salida.linea(chalk.yellow(`\n⏸  ${aviso}\n`));
-            return parada("ocupado", aviso);
+            // SOLO SE ESPERA SI HAY ALGUIEN DELANTE.
+            //
+            // Esperar tres minutos es una pausa cuando se ve la cuenta atras y se
+            // puede cortar con Esc. Sin terminal -CI, `chocolatito "haz X"`, una
+            // tuberia- es un cuelgue mudo de tres minutos que nadie puede parar, y
+            // ademas ahi no hay nadie a quien ahorrarle el teclear. Se dice y se
+            // corta, como antes.
+            if (!process.stdin.isTTY) {
+                salida.linea(chalk.yellow(`\n⏸  ${aviso}\n`));
+                return parada("ocupado", aviso);
+            }
+            salida.linea(chalk.yellow(`\n⏸  ${aviso}`));
+            salida.linea(chalk.gray("   Espero y sigo solo cuando se libere. Esc para dejarlo.\n"));
+            const vigilante = new InterruptWatcher();
+            const senal = vigilante.start();
+            const spinnerEspera = new DynamicSpinner();
+            spinnerEspera.start();
+            const hayHueco = await esperarAlHueco({
+                signal: senal,
+                alPasarUnSegundo: (quedan) => {
+                    spinnerEspera.setPrefijo(`Esperando hueco de la licencia (quedan ${quedan}s)`);
+                },
+            });
+            spinnerEspera.stop();
+            vigilante.stop();
+            if (!hayHueco) {
+                salida.linea(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                return parada("interrumpido");
+            }
+            salida.linea(chalk.green("  ✔ Hueco libre. Sigo.\n"));
         }
         // Cuota ANTES de gastar. Si no queda margen, se dice y no se llama al motor:
         // avisar despues de haber gastado no sirve de nada.
@@ -742,6 +776,18 @@ export class AgentLoop {
             // porque la conexion estaba bien.
             if (!llegoElFinal) {
                 watcher.stop();
+                // SE CIERRA LA PETICION MUERTA, Y ESTO NO ES LIMPIEZA: ES EL HUECO.
+                //
+                // El cuerpo se corto, pero por lo que respecta al proxy la peticion
+                // sigue en curso y sigue ocupando uno de los cuatro huecos de la
+                // licencia hasta que ALGO la cierre. Por eso el mensaje del proxy dice
+                // "si acabas de interrumpir una, el hueco se libera solo en 206s": son
+                // tres minutos y medio de servicio perdido por una conexion que ya
+                // estaba muerta de este lado. Abortando aqui se suelta en el momento.
+                try {
+                    stream?.controller?.abort();
+                }
+                catch { }
                 // Lo que llego se guarda, pero MARCADO. Sin la marca, en el turno
                 // siguiente el modelo lee su propia frase a medias como algo que decidio
                 // dejar asi, y responde a un texto que nadie escribio.

package/dist/ui/spinner.d.ts

@@ -7,6 +7,12 @@ export declare class DynamicSpinner {
     private prefix;
     tokenCount: number;
     constructor(prefix?: string);
+    /**
+     * Cambia el texto mientras gira. Hace falta para las esperas con cuenta
+     * atras: el prefijo se fijaba al arrancar y el numero de segundos que faltan
+     * cambia cada vuelta.
+     */
+    setPrefijo(prefijo: string): void;
     start(initialPrefix?: string): void;
     private tick;
     /**

package/dist/ui/spinner.js

@@ -42,6 +42,14 @@ export class DynamicSpinner {
     constructor(prefix = "") {
         this.prefix = prefix;
     }
+    /**
+     * Cambia el texto mientras gira. Hace falta para las esperas con cuenta
+     * atras: el prefijo se fijaba al arrancar y el numero de segundos que faltan
+     * cambia cada vuelta.
+     */
+    setPrefijo(prefijo) {
+        this.prefix = prefijo;
+    }
     start(initialPrefix) {
         if (this.isRunning)
             return;

package/extension/manifest.json

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

package/kits/diseno/skills/carruseles-y-flyers/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: carruseles-y-flyers
+description: Usar para carruseles de Instagram o LinkedIn y para flyers comerciales — partir una panorámica en diapositivas, sacar el mismo flyer en varias versiones (precio, sucursal, fecha, idioma), numerar para que suban en orden y preparar el envío al cliente.
+---
+
+# Carruseles y flyers
+
+El trabajo repetido de una pieza comercial: **el diseñador hace una buena, y aquí
+salen las otras treinta y nueve y todos los formatos.** Nada de esto decide la
+composición ni elige la tipografía — eso es suyo.
+
+## Medidas
+
+| | |
+| --- | --- |
+| Carrusel Instagram | 1080 × 1350 (4:5, ocupa más pantalla que el cuadrado) |
+| Carrusel LinkedIn | 1080 × 1350, se sube como **PDF** de varias páginas |
+| Máximo de diapositivas | 20 en Instagram; 10 es lo que la gente aguanta |
+| Flyer digital | 1080 × 1350 feed · 1080 × 1920 historia |
+| Flyer imprenta A5 | 148 × 210 mm a 300 ppp = 1748 × 2480 px, con 3 mm de sangre |
+
+## Partir una panorámica en diapositivas, sin costuras
+
+El carrusel que se desliza como una sola imagen. La panorámica tiene que medir
+`1080 × n` de ancho exacto: para 5 diapositivas, **5400 × 1350**.
+
+Con ImageMagick, de una vez:
+
+```bash
+magick pano.png -crop 1080x1350 +repage slide-%02d.png
+```
+
+Sin ImageMagick, con ffmpeg (comprobado: salen las 5 a 1080×1350 clavadas):
+
+```bash
+for i in 0 1 2 3 4; do
+  ffmpeg -y -i pano.png -vf "crop=1080:1350:$((i*1080)):0" "slide-$(printf %02d $((i+1))).png"
+done
+```
+
+**Antes de cortar, comprueba el ancho.** Si la panorámica no es múltiplo exacto de
+1080, la última diapositiva sale corta y se nota: reescala o recorta primero, y
+dilo.
+
+## Los ceros de la numeración no son estética
+
+`slide-1, slide-2 … slide-10` se sube en el orden `1, 10, 2, 3…` porque el
+selector de archivos ordena por texto. **Siempre `%02d`:** `slide-01`,
+`slide-02`. Este es el error que aparece con el carrusel ya publicado.
+
+## El mismo flyer en varias versiones
+
+Precio distinto, sucursal distinta, fecha distinta, idioma distinto. Es el mismo
+método que `variantes-de-pieza`: una tabla CSV con lo que cambia, una plantilla
+SVG con `{{PRECIO}}`, `{{SUCURSAL}}`, y una pieza por fila.
+
+Dos cosas que rompen el lote comercial en particular:
+
+- **El precio largo.** `$9` y `$1.299.990` no ocupan lo mismo. Mira el más largo
+  del CSV antes de lanzar, y ajusta el tamaño de letra a ese.
+- **La fecha.** Escríbela en el CSV tal y como tiene que verse. No la formatees
+  tú: "5 de marzo", "05/03" y "Marzo 5" no son intercambiables en una pieza.
+
+## Colores que se apagan al subir
+
+Instagram convierte todo a **sRGB**. Si la pieza sale en Adobe RGB o P3, los
+colores se apagan al publicar y el cliente lo nota en el rojo de su logo:
+
+```bash
+magick pieza.png -colorspace sRGB -quality 90 pieza-feed.jpg
+```
+
+Para imprenta es al revés: **no toques el color y no recomprimas**. Si el cliente
+pide CMYK, avisa de que una conversión sin el perfil de la imprenta cambia el
+tono, y que el archivo bueno sale del programa de maquetación, no de aquí.
+
+## Zona segura del carrusel
+
+Los puntitos del paso de página y la flecha de "siguiente" se comen los bordes:
+deja **60 px libres abajo** y unos 40 a los lados. La primera diapositiva es la
+que decide si alguien desliza, y la última es la llamada a la acción — si el CSV
+no las trae aparte, pregunta en vez de repetir la plantilla.
+
+## Revisar y entregar
+
+Todo de un vistazo antes de mandarlo:
+
+```bash
+magick montage slide-*.png -tile 5x -geometry 300x300+8+8 revision.jpg
+```
+
+Carrusel de LinkedIn (va en PDF, una página por diapositiva):
+
+```bash
+magick slide-*.png -quality 95 carrusel.pdf
+```
+
+Y el envío: una carpeta por formato, nombres sin acentos ni espacios, y un ZIP.
+Al terminar di cuántos archivos salieron y cuánto pesa el ZIP — si pasa de 25 MB
+no entra en un correo, y más vale saberlo antes de mandarlo.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chocolatito-code",
-  "version": "1.6.10",
+  "version": "1.6.12",
   "description": "Agente autónomo de programación para la terminal, con control real del ordenador y del navegador. Desarrollado por Chocolatito.",
   "type": "module",
   "bin": {