chocolatito-code 1.6.13 → 1.6.15

package/dist/tools/visionBridge.d.ts

@@ -28,10 +28,12 @@ export interface LocateResult {
     found?: boolean;
     reason?: string;
     error?: string;
+    bbox?: [number, number, number, number];
 }
 /**
  * Localiza un elemento y devuelve su centro EN PIXELES DE LA IMAGEN.
- * La conversion a coordenadas de pantalla la hace quien llama, que es el unico
- * que conoce el factor de escala y el origen de la captura.
+ * Soporta modelos multimodales (DeepSeek Vision, GPT-4o, Claude, Gemini Astra/Operator),
+ * coordenadas directas en píxeles, cuadrículas visuales, bounding boxes [x1, y1, x2, y2]
+ * o box_2d normalizado [ymin, xmin, ymax, xmax].
  */
 export declare function locateElement(apiKey: string, imagePath: string, target: string, imageWidth: number, imageHeight: number): Promise<LocateResult>;

package/dist/tools/visionBridge.js

@@ -122,26 +122,29 @@ async function ask(apiKey, prompt, imagePath, maxTokens) {
 /** Describe lo que se ve, orientado a decidir el siguiente paso. */
 export async function describeScreen(apiKey, imagePath, question) {
     const q = question && question.trim().length > 0 ? question.trim() : "Describe el estado actual de la pantalla.";
-    const prompt = `Eres los ojos de un agente que controla este ordenador. Observa la captura y responde en espanol, ` +
-        `de forma concreta y sin adornos.\n\n` +
+    const prompt = `Eres los ojos de un agente avanzado que controla este ordenador (estilo Google Project Astra y OpenAI Operator). ` +
+        `Observa la captura y responde en español, de forma concreta, estructurada y sin adornos.\n\n` +
         `Pregunta: ${q}\n\n` +
-        `Incluye siempre: que aplicacion y que pantalla concreta se ve, que elementos accionables hay ` +
-        `(botones, campos, pestanas) con su texto exacto, y si hay dialogos, errores o cargas en curso. ` +
-        `Si algo esta a medio cargar, dilo explicitamente. No inventes elementos que no aparezcan.\n` +
-        `Se breve: como mucho 12 lineas. Nada de preambulos.`;
+        `Incluye siempre: qué aplicación y qué pantalla o diálogo concreto se ve, qué elementos accionables hay ` +
+        `(botones, campos, pestañas, menús) con su texto exacto, coordenadas de cuadrícula si están visibles, ` +
+        `y si hay diálogos modales, alertas, spinners de carga o errores. ` +
+        `Si algo está a medio cargar, dilo explícitamente. No inventes elementos que no aparezcan.\n` +
+        `Sé conciso: máximo 14 líneas, directo al grano.`;
     return ask(apiKey, prompt, imagePath, 1600);
 }
 /**
  * Localiza un elemento y devuelve su centro EN PIXELES DE LA IMAGEN.
- * La conversion a coordenadas de pantalla la hace quien llama, que es el unico
- * que conoce el factor de escala y el origen de la captura.
+ * Soporta modelos multimodales (DeepSeek Vision, GPT-4o, Claude, Gemini Astra/Operator),
+ * coordenadas directas en píxeles, cuadrículas visuales, bounding boxes [x1, y1, x2, y2]
+ * o box_2d normalizado [ymin, xmin, ymax, xmax].
  */
 export async function locateElement(apiKey, imagePath, target, imageWidth, imageHeight) {
-    const prompt = `Observa la captura de pantalla, de ${imageWidth} x ${imageHeight} pixeles.\n\n` +
+    const prompt = `Observa la captura de pantalla de ${imageWidth} x ${imageHeight} píxeles.\n` +
+        `Si la imagen tiene una cuadrícula de coordenadas con números (x,y), úsalos como referencia precisa.\n\n` +
         `Localiza este elemento: "${target}"\n\n` +
-        `Responde UNICAMENTE con un objeto JSON, sin texto alrededor y sin bloques de codigo:\n` +
-        `{"found": true, "x": <centro horizontal en pixeles>, "y": <centro vertical en pixeles>, "reason": "<que viste>"}\n` +
-        `Si el elemento no aparece en la captura, responde {"found": false, "x": 0, "y": 0, "reason": "<por que>"}.\n` +
+        `Responde ÚNICAMENTE con un objeto JSON, sin texto alrededor y sin bloques de código:\n` +
+        `{"found": true, "x": <centro horizontal en píxeles>, "y": <centro vertical en píxeles>, "reason": "<qué viste>", "bbox": [<x1>, <y1>, <x2>, <y2>]}\n` +
+        `Si el elemento no aparece en la captura, responde {"found": false, "x": 0, "y": 0, "reason": "<por qué>"}.\n` +
         `El origen (0,0) es la esquina superior izquierda de la imagen. No inventes: si dudas, found=false.`;
     const res = await ask(apiKey, prompt, imagePath, 900);
     if (!res.ok)
@@ -152,10 +155,31 @@ export async function locateElement(apiKey, imagePath, target, imageWidth, image
         return { ok: false, error: `El modelo de vision no devolvio JSON: ${raw.slice(0, 200)}` };
     try {
         const parsed = JSON.parse(match[0]);
-        const x = Math.round(Number(parsed.x));
-        const y = Math.round(Number(parsed.y));
+        let x = Number(parsed.x);
+        let y = Number(parsed.y);
+        // Soporte para box_2d estilo Gemini/Astra: [ymin, xmin, ymax, xmax] normalizado 0..1000
+        if ((!Number.isFinite(x) || !Number.isFinite(y) || (x === 0 && y === 0)) && Array.isArray(parsed.box_2d) && parsed.box_2d.length === 4) {
+            const [ymin, xmin, ymax, xmax] = parsed.box_2d.map(Number);
+            x = Math.round(((xmin + xmax) / 2.0 / 1000.0) * imageWidth);
+            y = Math.round(((ymin + ymax) / 2.0 / 1000.0) * imageHeight);
+        }
+        else if (Array.isArray(parsed.bbox) && parsed.bbox.length === 4 && (!Number.isFinite(x) || !Number.isFinite(y))) {
+            const [x1, y1, x2, y2] = parsed.bbox.map(Number);
+            x = Math.round((x1 + x2) / 2.0);
+            y = Math.round((y1 + y2) / 2.0);
+        }
+        // Coordenadas normalizadas 0.0 a 1.0
+        if (x > 0 && x <= 1.0 && y > 0 && y <= 1.0) {
+            x = Math.round(x * imageWidth);
+            y = Math.round(y * imageHeight);
+        }
+        else if (parsed.normalized === true) {
+            x = Math.round((x / 1000.0) * imageWidth);
+            y = Math.round((y / 1000.0) * imageHeight);
+        }
+        x = Math.round(x);
+        y = Math.round(y);
         const found = parsed.found === true && Number.isFinite(x) && Number.isFinite(y);
-        // Un punto fuera de la imagen es una alucinacion, no un acierto.
         const inside = x >= 0 && y >= 0 && x <= imageWidth && y <= imageHeight;
         return {
             ok: true,
@@ -163,6 +187,7 @@ export async function locateElement(apiKey, imagePath, target, imageWidth, image
             x,
             y,
             reason: typeof parsed.reason === "string" ? parsed.reason : "",
+            bbox: Array.isArray(parsed.bbox) ? parsed.bbox : undefined,
         };
     }
     catch (err) {

package/dist/tools/win/hostScript.js

@@ -52,6 +52,8 @@ public static class Choco
     [DllImport("user32.dll")] static extern bool ClientToScreen(IntPtr h, ref POINT p);
     [DllImport("user32.dll")] static extern bool ScreenToClient(IntPtr h, ref POINT p);
     [DllImport("user32.dll")] static extern bool EnumWindows(EnumProc cb, IntPtr l);
+    [DllImport("user32.dll")] static extern bool EnumChildWindows(IntPtr hWndParent, EnumProc lpEnumFunc, IntPtr lParam);
+    [DllImport("user32.dll", CharSet = CharSet.Auto)] static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, StringBuilder lParam);
     [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr h, out uint pid);
     [DllImport("user32.dll")] static extern bool PrintWindow(IntPtr h, IntPtr hdc, uint flags);
     [DllImport("user32.dll")] static extern bool PostMessage(IntPtr h, uint msg, IntPtr w, IntPtr l);
@@ -304,49 +306,102 @@ public static class Choco
         return scale;
     }
 
-    public static string CaptureScreen(string path, int maxLongEdge, bool drawCursor)
+    static void DrawCoordinateGrid(Graphics g, int width, int height, int originX, int originY)
+    {
+        g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
+        using (Pen gridPen = new Pen(Color.FromArgb(100, 230, 60, 60), 1))
+        using (Brush textBrush = new SolidBrush(Color.FromArgb(245, 255, 255, 255)))
+        using (Brush bgBrush = new SolidBrush(Color.FromArgb(160, 20, 20, 20)))
+        using (Font font = new Font(FontFamily.GenericMonospace, 8.5f, FontStyle.Bold))
+        {
+            gridPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
+            int step = 100;
+            for (int x = 0; x < width; x += step)
+            {
+                g.DrawLine(gridPen, x, 0, x, height);
+            }
+            for (int y = 0; y < height; y += step)
+            {
+                g.DrawLine(gridPen, 0, y, width, y);
+            }
+            for (int x = 0; x < width; x += step)
+            {
+                for (int y = 0; y < height; y += step)
+                {
+                    if (x % 200 == 0 && y % 200 == 0 && x + 70 < width && y + 16 < height)
+                    {
+                        string lbl = (originX + x) + "," + (originY + y);
+                        SizeF sz = g.MeasureString(lbl, font);
+                        g.FillRectangle(bgBrush, x + 2, y + 2, sz.Width + 2, sz.Height);
+                        g.DrawString(lbl, font, textBrush, x + 3, y + 2);
+                    }
+                }
+            }
+        }
+    }
+
+    public static string CaptureScreen(string path, int maxLongEdge, bool drawCursor, bool drawGrid, int rx1, int ry1, int rx2, int ry2)
     {
         int vx = GetSystemMetrics(76), vy = GetSystemMetrics(77);
         int vw = GetSystemMetrics(78), vh = GetSystemMetrics(79);
-        using (Bitmap bmp = new Bitmap(vw, vh, PixelFormat.Format32bppArgb))
+        int sx = vx, sy = vy, sw = vw, sh = vh;
+        if (rx2 > rx1 && ry2 > ry1)
+        {
+            sx = vx + rx1; sy = vy + ry1;
+            sw = Math.Min(vw, rx2 - rx1); sh = Math.Min(vh, ry2 - ry1);
+        }
+        if (sw <= 0 || sh <= 0) return "{\"ok\":false,\"error\":\"area invalida para captura\"}";
+
+        using (Bitmap bmp = new Bitmap(sw, sh, PixelFormat.Format32bppArgb))
         {
             using (Graphics g = Graphics.FromImage(bmp))
             {
-                g.CopyFromScreen(vx, vy, 0, 0, new Size(vw, vh), CopyPixelOperation.SourceCopy);
+                g.CopyFromScreen(sx, sy, 0, 0, new Size(sw, sh), CopyPixelOperation.SourceCopy);
                 if (drawCursor)
                 {
                     POINT c; GetCursorPos(out c);
-                    g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
-                    using (Pen p = new Pen(Color.FromArgb(255, 235, 75, 75), 3))
+                    if (c.X >= sx && c.X <= sx + sw && c.Y >= sy && c.Y <= sy + sh)
                     {
-                        g.DrawEllipse(p, c.X - vx - 16, c.Y - vy - 16, 32, 32);
-                        g.DrawLine(p, c.X - vx - 24, c.Y - vy, c.X - vx + 24, c.Y - vy);
-                        g.DrawLine(p, c.X - vx, c.Y - vy - 24, c.X - vx, c.Y - vy + 24);
+                        g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
+                        using (Pen p = new Pen(Color.FromArgb(255, 235, 75, 75), 3))
+                        {
+                            int relX = c.X - sx;
+                            int relY = c.Y - sy;
+                            g.DrawEllipse(p, relX - 16, relY - 16, 32, 32);
+                            g.DrawLine(p, relX - 24, relY, relX + 24, relY);
+                            g.DrawLine(p, relX, relY - 24, relX, relY + 24);
+                        }
                     }
                 }
+                if (drawGrid)
+                {
+                    DrawCoordinateGrid(g, sw, sh, sx, sy);
+                }
             }
             double s = SaveScaled(bmp, path, maxLongEdge);
-            return "{\"ok\":true,\"path\":" + Q(path) + ",\"screenWidth\":" + N(vw) + ",\"screenHeight\":" + N(vh) +
-                   ",\"originX\":" + N(vx) + ",\"originY\":" + N(vy) +
-                   ",\"imageWidth\":" + N((int)Math.Round(vw * s)) + ",\"imageHeight\":" + N((int)Math.Round(vh * s)) +
+            return "{\"ok\":true,\"path\":" + Q(path) + ",\"screenWidth\":" + N(sw) + ",\"screenHeight\":" + N(sh) +
+                   ",\"originX\":" + N(sx) + ",\"originY\":" + N(sy) +
+                   ",\"imageWidth\":" + N((int)Math.Round(sw * s)) + ",\"imageHeight\":" + N((int)Math.Round(sh * s)) +
                    ",\"scale\":" + s.ToString("0.#####", CultureInfo.InvariantCulture) + "}";
-    }
+        }
     }
 
     // Captura UNA ventana concreta sin traerla al frente.
     // PrintWindow(PW_RENDERFULLCONTENT=2) pide a la ventana que se redibuje en
     // nuestro DC, asi funciona aunque este tapada o en segundo plano.
-    public static string CaptureWindow(IntPtr h, string path, int maxLongEdge, bool clientOnly)
+    public static string CaptureWindow(IntPtr h, string path, int maxLongEdge, bool clientOnly, bool drawGrid, int rx1, int ry1, int rx2, int ry2)
     {
         if (h == IntPtr.Zero) return "{\"ok\":false,\"error\":\"ventana no encontrada\"}";
         RECT r;
         if (clientOnly) { GetClientRect(h, out r); } else { GetWindowRect(h, out r); }
         int w = r.Right - r.Left, hh = r.Bottom - r.Top;
         if (w <= 0 || hh <= 0) return "{\"ok\":false,\"error\":\"ventana sin area visible (minimizada?)\"}";
-        using (Bitmap bmp = new Bitmap(w, hh, PixelFormat.Format32bppArgb))
+        RECT wr2; GetWindowRect(h, out wr2);
+
+        using (Bitmap full = new Bitmap(w, hh, PixelFormat.Format32bppArgb))
         {
             bool printed = false;
-            using (Graphics g = Graphics.FromImage(bmp))
+            using (Graphics g = Graphics.FromImage(full))
             {
                 IntPtr hdc = g.GetHdc();
                 try { printed = PrintWindow(h, hdc, 2); }
@@ -354,19 +409,52 @@ public static class Choco
             }
             // Chrome/Electron a veces devuelven negro con PrintWindow: si sale casi
             // todo negro y la ventana esta visible, caemos a copia de pantalla.
-            if (!printed || IsMostlyBlank(bmp))
+            if (!printed || IsMostlyBlank(full))
             {
-                RECT wr; GetWindowRect(h, out wr);
-                using (Graphics g2 = Graphics.FromImage(bmp))
-                    g2.CopyFromScreen(wr.Left, wr.Top, 0, 0, new Size(w, hh), CopyPixelOperation.SourceCopy);
+                using (Graphics g2 = Graphics.FromImage(full))
+                    g2.CopyFromScreen(wr2.Left, wr2.Top, 0, 0, new Size(w, hh), CopyPixelOperation.SourceCopy);
+            }
+
+            int cw = w, ch = hh, cx = 0, cy = 0;
+            if (rx2 > rx1 && ry2 > ry1)
+            {
+                cx = Math.Max(0, rx1); cy = Math.Max(0, ry1);
+                cw = Math.Min(w - cx, rx2 - rx1); ch = Math.Min(hh - cy, ry2 - ry1);
+            }
+            if (cw <= 0 || ch <= 0) return "{\"ok\":false,\"error\":\"region fuera de los limites de la ventana\"}";
+
+            Bitmap targetBmp = full;
+            bool isCropped = (cx > 0 || cy > 0 || cw < w || ch < hh);
+            if (isCropped)
+            {
+                Bitmap crop = new Bitmap(cw, ch, PixelFormat.Format32bppArgb);
+                using (Graphics gCrop = Graphics.FromImage(crop))
+                {
+                    gCrop.DrawImage(full, new Rectangle(0, 0, cw, ch), new Rectangle(cx, cy, cw, ch), GraphicsUnit.Pixel);
+                }
+                targetBmp = crop;
+            }
+
+            try
+            {
+                if (drawGrid)
+                {
+                    using (Graphics gGrid = Graphics.FromImage(targetBmp))
+                    {
+                        DrawCoordinateGrid(gGrid, cw, ch, wr2.Left + cx, wr2.Top + cy);
+                    }
+                }
+                double s = SaveScaled(targetBmp, path, maxLongEdge);
+                return "{\"ok\":true,\"path\":" + Q(path) + ",\"title\":" + Q(Title(h)) +
+                       ",\"windowX\":" + N(wr2.Left + cx) + ",\"windowY\":" + N(wr2.Top + cy) +
+                       ",\"windowWidth\":" + N(cw) + ",\"windowHeight\":" + N(ch) +
+                       ",\"imageWidth\":" + N((int)Math.Round(cw * s)) + ",\"imageHeight\":" + N((int)Math.Round(ch * s)) +
+                       ",\"scale\":" + s.ToString("0.#####", CultureInfo.InvariantCulture) + "}";
+            }
+            finally
+            {
+                if (isCropped && targetBmp != null) targetBmp.Dispose();
             }
-            double s = SaveScaled(bmp, path, maxLongEdge);
-            RECT wr2; GetWindowRect(h, out wr2);
-            return "{\"ok\":true,\"path\":" + Q(path) + ",\"title\":" + Q(Title(h)) +
-                   ",\"windowX\":" + N(wr2.Left) + ",\"windowY\":" + N(wr2.Top) +
-                   ",\"windowWidth\":" + N(w) + ",\"windowHeight\":" + N(hh) +
-                   ",\"imageWidth\":" + N((int)Math.Round(w * s)) + ",\"imageHeight\":" + N((int)Math.Round(hh * s)) +
-                   ",\"scale\":" + s.ToString("0.#####", CultureInfo.InvariantCulture) + "}";
         }
     }
 
@@ -672,6 +760,98 @@ public static class Choco
         }
     }
 
+    public static string WaitVisualChange(IntPtr hwnd, int timeoutMs, int rx1, int ry1, int rx2, int ry2)
+    {
+        if (timeoutMs < 100) timeoutMs = 100;
+        if (timeoutMs > 30000) timeoutMs = 30000;
+        int vx = 0, vy = 0, vw = 0, vh = 0;
+        if (hwnd != IntPtr.Zero)
+        {
+            RECT r; GetWindowRect(hwnd, out r);
+            vx = r.Left; vy = r.Top; vw = r.Right - r.Left; vh = r.Bottom - r.Top;
+        }
+        else
+        {
+            vx = GetSystemMetrics(76); vy = GetSystemMetrics(77);
+            vw = GetSystemMetrics(78); vh = GetSystemMetrics(79);
+        }
+        if (rx2 > rx1 && ry2 > ry1)
+        {
+            vx += rx1; vy += ry1;
+            vw = Math.Min(vw, rx2 - rx1); vh = Math.Min(vh, ry2 - ry1);
+        }
+        if (vw <= 2 || vh <= 2) return "{\"ok\":false,\"error\":\"area invalida para cambio visual\"}";
+
+        int sampleW = Math.Min(vw, 64);
+        int sampleH = Math.Min(vh, 64);
+        byte[] prev = SamplePixels(vx, vy, vw, vh, sampleW, sampleH);
+
+        int elapsed = 0;
+        int interval = 120;
+        while (elapsed < timeoutMs)
+        {
+            Thread.Sleep(interval);
+            elapsed += interval;
+            byte[] curr = SamplePixels(vx, vy, vw, vh, sampleW, sampleH);
+            int diff = 0;
+            int total = curr.Length / 3;
+            for (int i = 0; i < curr.Length; i += 3)
+            {
+                int dr = Math.Abs((int)curr[i] - (int)prev[i]);
+                int dg = Math.Abs((int)curr[i + 1] - (int)prev[i + 1]);
+                int db = Math.Abs((int)curr[i + 2] - (int)prev[i + 2]);
+                if (dr + dg + db > 30) diff++;
+            }
+            double pct = (double)diff / (double)total;
+            if (pct > 0.015)
+            {
+                return "{\"ok\":true,\"changed\":true,\"diffPercent\":" + (pct * 100).ToString("0.#", CultureInfo.InvariantCulture) + ",\"elapsed\":" + N(elapsed) + "}";
+            }
+        }
+        return "{\"ok\":true,\"changed\":false,\"waited\":" + N(timeoutMs) + "}";
+    }
+
+    static byte[] SamplePixels(int x, int y, int w, int h, int sw, int sh)
+    {
+        byte[] bytes = new byte[sw * sh * 3];
+        try
+        {
+            using (Bitmap full = new Bitmap(w, h, PixelFormat.Format24bppRgb))
+            {
+                using (Graphics g = Graphics.FromImage(full))
+                {
+                    g.CopyFromScreen(x, y, 0, 0, new Size(w, h), CopyPixelOperation.SourceCopy);
+                }
+                using (Bitmap thumb = new Bitmap(sw, sh, PixelFormat.Format24bppRgb))
+                {
+                    using (Graphics g2 = Graphics.FromImage(thumb))
+                    {
+                        g2.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.Bilinear;
+                        g2.DrawImage(full, 0, 0, sw, sh);
+                    }
+                    BitmapData bd = thumb.LockBits(new Rectangle(0, 0, sw, sh), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);
+                    try
+                    {
+                        int stride = bd.Stride;
+                        IntPtr ptr = bd.Scan0;
+                        byte[] row = new byte[Math.Abs(stride)];
+                        for (int rowIdx = 0; rowIdx < sh; rowIdx++)
+                        {
+                            Marshal.Copy(new IntPtr(ptr.ToInt64() + (rowIdx * stride)), row, 0, sw * 3);
+                            Array.Copy(row, 0, bytes, rowIdx * sw * 3, sw * 3);
+                        }
+                    }
+                    finally
+                    {
+                        thumb.UnlockBits(bd);
+                    }
+                }
+            }
+        }
+        catch { }
+        return bytes;
+    }
+
     public static string RefRect(int id)
     {
         AutomationElement e = Ref(id);
@@ -702,11 +882,71 @@ public static class Choco
             if (e.TryGetCurrentPattern(SelectionItemPattern.Pattern, out p)) { ((SelectionItemPattern)p).Select(); return "{\"ok\":true,\"via\":\"select\",\"label\":" + Q(label) + "}"; }
             if (e.TryGetCurrentPattern(TogglePattern.Pattern, out p)) { ((TogglePattern)p).Toggle(); return "{\"ok\":true,\"via\":\"toggle\",\"label\":" + Q(label) + "}"; }
             if (e.TryGetCurrentPattern(ExpandCollapsePattern.Pattern, out p)) { ((ExpandCollapsePattern)p).Expand(); return "{\"ok\":true,\"via\":\"expand\",\"label\":" + Q(label) + "}"; }
-            return "{\"ok\":false,\"error\":" + Q("El elemento " + label + " no expone patron activable; usa click sobre sus coordenadas.") + "}";
+            int cx = 0, cy = 0;
+            try {
+                System.Windows.Rect r = e.Current.BoundingRectangle;
+                cx = (int)Math.Round(r.X + r.Width / 2.0);
+                cy = (int)Math.Round(r.Y + r.Height / 2.0);
+            } catch { }
+            return "{\"ok\":false,\"noPattern\":true,\"x\":" + N(cx) + ",\"y\":" + N(cy) + ",\"label\":" + Q(label) + ",\"error\":" + Q("El elemento " + label + " no expone patron activable; usa click sobre sus coordenadas.") + "}";
         }
         catch (Exception ex) { return "{\"ok\":false,\"error\":" + Q(ex.Message) + "}"; }
     }
 
+    // POR QUE: Formularios y listas largas no caben en una sola pantalla. Si un control
+    // soporta ScrollItemPattern, lo traemos al area visible directamente sin mover el raton.
+    public static string RefScrollIntoView(int id)
+    {
+        AutomationElement e = Ref(id);
+        if (e == null) return "{\"ok\":false,\"error\":\"ref inexistente; repite ui_snapshot\"}";
+        try
+        {
+            object sp;
+            if (e.TryGetCurrentPattern(ScrollItemPattern.Pattern, out sp))
+            {
+                ((ScrollItemPattern)sp).ScrollIntoView();
+                return "{\"ok\":true,\"via\":\"scroll_item_pattern\"}";
+            }
+            return "{\"ok\":false,\"error\":\"el elemento no admite ScrollItemPattern\"}";
+        }
+        catch (Exception ex) { return "{\"ok\":false,\"error\":" + Q(ex.Message) + "}"; }
+    }
+
+    // POR QUE: Ventanas antiguas (WinForms, Delphi, MFC) o Electron con accesibilidad rota
+    // devuelven un árbol UIA vacío, dejando al modelo a ciegas. Este método recupera
+    // el texto de los controles nativos Win32 (editores, etiquetas, botones) directamente.
+    public static string ExtractWindowText(IntPtr hwnd)
+    {
+        if (hwnd == IntPtr.Zero) return "{\"ok\":false,\"error\":\"ventana no encontrada\"}";
+        List<string> lines = new List<string>();
+        HashSet<string> seen = new HashSet<string>();
+        string title = Title(hwnd);
+        if (!string.IsNullOrEmpty(title)) { lines.Add(title); seen.Add(title); }
+
+        EnumChildWindows(hwnd, (child, lParam) =>
+        {
+            if (!IsWindowVisible(child)) return true;
+            StringBuilder sb = new StringBuilder(1024);
+            GetWindowText(child, sb, 1024);
+            string txt = sb.ToString().Trim();
+            if (txt.Length == 0)
+            {
+                SendMessage(child, 0x000D, (IntPtr)1024, sb);
+                txt = sb.ToString().Trim();
+            }
+            if (txt.Length > 0 && !seen.Contains(txt))
+            {
+                seen.Add(txt);
+                lines.Add(txt);
+            }
+            return true;
+        }, IntPtr.Zero);
+
+        List<string> escaped = new List<string>();
+        foreach (string line in lines) escaped.Add(Q(line));
+        return "{\"ok\":true,\"title\":" + Q(title) + ",\"lines\":[" + string.Join(",", escaped.ToArray()) + "]}";
+    }
+
     public static string RefSetValue(int id, string text, bool replace)
     {
         AutomationElement e = Ref(id);
@@ -1052,16 +1292,47 @@ while ($true) {
       }
       'wait'          { Start-Sleep -Milliseconds ([int](Get-Prop $cmd 'ms' 1000)); $res = '{"ok":true}' }
       'capture_screen' {
-        $res = [Choco]::CaptureScreen([string](Get-Prop $cmd 'path' ''), [int](Get-Prop $cmd 'maxLongEdge' 1568), [bool](Get-Prop $cmd 'cursor' $true))
+        $res = [Choco]::CaptureScreen(
+          [string](Get-Prop $cmd 'path' ''),
+          [int](Get-Prop $cmd 'maxLongEdge' 1568),
+          [bool](Get-Prop $cmd 'cursor' $true),
+          [bool](Get-Prop $cmd 'grid' $false),
+          [int](Get-Prop $cmd 'rx1' 0),
+          [int](Get-Prop $cmd 'ry1' 0),
+          [int](Get-Prop $cmd 'rx2' 0),
+          [int](Get-Prop $cmd 'ry2' 0)
+        )
       }
       'capture_window' {
-        $res = [Choco]::CaptureWindow((Resolve-Hwnd $cmd), [string](Get-Prop $cmd 'path' ''), [int](Get-Prop $cmd 'maxLongEdge' 1568), [bool](Get-Prop $cmd 'clientOnly' $false))
+        $res = [Choco]::CaptureWindow(
+          (Resolve-Hwnd $cmd),
+          [string](Get-Prop $cmd 'path' ''),
+          [int](Get-Prop $cmd 'maxLongEdge' 1568),
+          [bool](Get-Prop $cmd 'clientOnly' $false),
+          [bool](Get-Prop $cmd 'grid' $false),
+          [int](Get-Prop $cmd 'rx1' 0),
+          [int](Get-Prop $cmd 'ry1' 0),
+          [int](Get-Prop $cmd 'rx2' 0),
+          [int](Get-Prop $cmd 'ry2' 0)
+        )
       }
       'ui_snapshot' {
         $res = [Choco]::Snapshot((Resolve-Hwnd $cmd), [int](Get-Prop $cmd 'max' 250), [string](Get-Prop $cmd 'filter' ''), [bool](Get-Prop $cmd 'interactiveOnly' $true))
       }
       'wait_change'   { $res = [Choco]::WaitChange((Resolve-Hwnd $cmd), [int](Get-Prop $cmd 'timeoutMs' 3000)) }
+      'wait_visual_change' {
+        $res = [Choco]::WaitVisualChange(
+          (Resolve-Hwnd $cmd),
+          [int](Get-Prop $cmd 'timeoutMs' 3000),
+          [int](Get-Prop $cmd 'rx1' 0),
+          [int](Get-Prop $cmd 'ry1' 0),
+          [int](Get-Prop $cmd 'rx2' 0),
+          [int](Get-Prop $cmd 'ry2' 0)
+        )
+      }
       'ui_click'      { $res = [Choco]::RefInvoke([int](Get-Prop $cmd 'ref' 0)) }
+      'ui_scroll_into_view' { $res = [Choco]::RefScrollIntoView([int](Get-Prop $cmd 'ref' 0)) }
+      'extract_text'  { $res = [Choco]::ExtractWindowText((Resolve-Hwnd $cmd)) }
       'ui_set_value'  { $res = [Choco]::RefSetValue([int](Get-Prop $cmd 'ref' 0), [string](Get-Prop $cmd 'text' ''), [bool](Get-Prop $cmd 'replace' $false)) }
       'ui_focus'      { $res = [Choco]::RefFocus([int](Get-Prop $cmd 'ref' 0)) }
       'ui_rect'       { $res = [Choco]::RefRect([int](Get-Prop $cmd 'ref' 0)) }

package/dist/ui/comandos.js

@@ -26,6 +26,7 @@
 export const SLASH_COMMANDS = [
     { name: "/mcp", description: "Ver servidores MCP conectados y sus herramientas" },
     { name: "/undo", description: "Deshacer las últimas modificaciones de archivos de la sesión" },
+    { name: "/rewind", description: "Volver a como estaba antes de un turno (sobrevive a cerrar la sesión)", args: "[n]" },
     { name: "/export", description: "Exportar bitácora de la sesión a archivo Markdown", args: "[nombre.md]" },
     { name: "/plan", description: "Alternar Modo Plan (solo lectura e investigación previa)" },
     { name: "/resume", description: "Reanudar una sesión anterior guardada", args: "[id]" },

package/dist/ui/ink/App.js

@@ -77,8 +77,28 @@ export function App() {
     // un proceso hijo lo suelten por el camino. Ver ink/teclado.ts: es el fallo
     // del "no puedo escribir hasta que pulso Enter".
     useTecladoSiempreNuestro(turno.esperando);
-    const cols = Math.max(20, stdout?.columns || 80);
-    const filas = Math.max(6, stdout?.rows || 24);
+    const [tamano, setTamano] = useState(() => ({
+        cols: Math.max(20, (stdout?.columns && stdout.columns > 0 ? stdout.columns : process.stdout?.columns) || 80),
+        filas: Math.max(6, (stdout?.rows && stdout.rows > 0 ? stdout.rows : process.stdout?.rows) || 24),
+    }));
+    // Adaptar el árbol y todos los marcos dinámicamente cuando se maximiza o redimensiona la terminal
+    useEffect(() => {
+        const alRedimensionar = () => {
+            setTamano({
+                cols: Math.max(20, (stdout?.columns && stdout.columns > 0 ? stdout.columns : process.stdout?.columns) || 80),
+                filas: Math.max(6, (stdout?.rows && stdout.rows > 0 ? stdout.rows : process.stdout?.rows) || 24),
+            });
+            repintar();
+        };
+        stdout?.on("resize", alRedimensionar);
+        process.stdout?.on("resize", alRedimensionar);
+        return () => {
+            stdout?.off("resize", alRedimensionar);
+            process.stdout?.off("resize", alRedimensionar);
+        };
+    }, [stdout]);
+    const cols = tamano.cols;
+    const filas = tamano.filas;
     const permanentes = pendientes();
     const barra = turno.esperando ? [] : lineasDelPie();
     // EL TECHO DE LA ZONA DE ABAJO, Y POR QUÉ SE MIDE TAN DE CERCA
@@ -94,7 +114,7 @@ export function App() {
     const techo = Math.max(1, filas - 1);
     const sitioParaLaCola = Math.max(0, techo - (turno.esperando ? ALTO_DE_LA_CAJA : barra.length));
     const cola = recortarCola(colgando(), cols, sitioParaLaCola);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: permanentes, children: (linea) => _jsx(Text, { children: conCuerpo(linea.texto) }, linea.id) }), _jsxs(Box, { flexDirection: "column", children: [cola.map((linea, i) => (_jsx(Text, { children: conCuerpo(linea) }, `cola-${i}`))), turno.esperando ? (_jsx(Prompt, { alEnviar: turno.responder, alCancelar: () => turno.responder("/exit"), cwd: turno.cwd, promptSymbol: turno.promptSymbol, avisos: [], 
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: permanentes, children: (linea) => _jsx(Text, { children: conCuerpo(linea.texto) }, linea.id) }), _jsxs(Box, { flexDirection: "column", children: [cola.map((linea, i) => (_jsx(Text, { children: conCuerpo(linea) }, `cola-${i}`))), turno.esperando ? (_jsx(Prompt, { cols: cols, filas: filas, alEnviar: turno.responder, alCancelar: () => turno.responder("/exit"), cwd: turno.cwd, promptSymbol: turno.promptSymbol, avisos: [], 
                         // NO SE DESMONTA EL ÁRBOL AL ENVIAR
                         //
                         // El prompt nació montándose y desmontándose en cada vuelta, y para

package/dist/ui/ink/Prompt.d.ts

@@ -56,5 +56,9 @@ export interface PromptProps {
      * como si estuviera solo.
      */
     alto?: number;
+    /** Columnas disponibles en el terminal. */
+    cols?: number;
+    /** Filas totales de la ventana del terminal. */
+    filas?: number;
 }
-export declare function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, cerrarAlEnviar, alto, }: PromptProps): React.ReactElement;
+export declare function Prompt({ alEnviar, alCancelar, cwd, promptSymbol, avisos, cerrarAlEnviar, alto, cols: colsProp, filas: filasProp, }: PromptProps): React.ReactElement;