zames_pro 2.49.0 → 2.49.2

package/dist/agent-loop.js

@@ -201,6 +201,12 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // the (fresh) chat grows past this plus a margin, so a chat that starts
     // above the threshold does not compact on every tool call.
     let lastAutoCompactTokens = -1;
+    // Set when an auto-compact returned the SAME chat id it started in — i.e.
+    // the "fresh chat" never opened and the compaction did nothing. Without this
+    // guard a broken newChat() (see B2) made the loop compact on EVERY tool call
+    // while the context kept growing. Defense in depth: the root cause is fixed,
+    // but a future regression must not turn into an endless "compacting" loop.
+    let autoCompactDisabled = false;
     // The message of a respond that arrived TOGETHER with real tool calls.
     // It is not delivered immediately (the tools must run first), but if the
     // model then stops without calling respond again, this is the best final
@@ -735,7 +741,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                 // (plus a small margin), so a fresh chat does not compact again on
                 // every tool call.
                 const armed = !firedRecently || tokens > lastAutoCompactTokens + 1;
-                if (pct >= autoCompactPct && armed) {
+                if (pct >= autoCompactPct && armed && !autoCompactDisabled) {
                     lastAutoCompactTokens = tokens;
                     safeWarning(translate(locale)('compact.auto_trigger', {
                         pct: String(Math.round(pct)),
@@ -743,9 +749,23 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                     }));
                     transcript?.log('auto_compact_trigger', { tokens, pct });
                     try {
+                        const beforeChat = await browser
+                            .getCurrentChatId()
+                            .catch(() => null);
                         const newChat = await onAutoCompact();
                         if (newChat) {
-                            transcript?.log('auto_compact_done', { chatId: newChat });
+                            if (beforeChat && newChat === beforeChat) {
+                                // The chat did NOT change: the summary was posted back into
+                                // the old chat and the context was not reset. Warn once and
+                                // stop auto-compacting for the rest of the task instead of
+                                // looping on every tool call.
+                                autoCompactDisabled = true;
+                                safeWarning(translate(locale)('compact.auto_same_chat'));
+                                transcript?.log('auto_compact_same_chat', { chatId: newChat });
+                            }
+                            else {
+                                transcript?.log('auto_compact_done', { chatId: newChat });
+                            }
                             // Continue in the fresh chat. The next send is a tool-result
                             // (agent: true), which is fine: the new chat already holds the
                             // system prompt + carryover. `lastAutoCompactTokens` stays at the

package/dist/i18n.js

@@ -289,6 +289,10 @@ const CATALOG = {
         ru: '🗜️ Контекст заполнен на {pct}% ({tokens} токенов) — сжимаю историю и открываю новый чат...',
         en: '🗜️ Context at {pct}% ({tokens} tokens) — compacting the history and opening a fresh chat...',
     },
+    'compact.auto_same_chat': {
+        ru: '🗜️ Сжатие не открыло новый чат (тот же id) — отключаю авто-сжатие до конца задачи, чтобы не зациклиться.',
+        en: '🗜️ Compaction did not open a fresh chat (same id) — disabling auto-compact for the rest of the task to avoid a loop.',
+    },
     'compact.start': {
         ru: '🗜️ Сжимаю историю чата (DeepSeek)...',
         en: '🗜️ Compacting the chat history (DeepSeek)...',

package/dist/input.js

@@ -93,7 +93,12 @@ export function visRows(s, cols) {
     const len = visLen(s);
     return Math.max(1, Math.ceil(len / width));
 }
-// Visible length of a line without ANSI sequences.
+// Visible length of a line without ANSI sequences. WIDE characters (emoji,
+// CJK) count as 2 columns — a plain code-point count made the status-line
+// arithmetic (right-align, wrapping, block erase) disagree with the real
+// screen, so a status containing an emoji/CJK could wrap past the edge and
+// make the block erase miss (status "stacking"). Combining marks and the
+// zero-width joiner/space/variation selectors count as 0.
 export function visLen(s) {
     s = String(s);
     let n = 0;
@@ -109,11 +114,48 @@ export function visLen(s) {
             }
             continue;
         }
-        n++;
-        i++;
+        const cp = s.codePointAt(i);
+        n += charWidth(cp);
+        i += cp > 0xffff ? 2 : 1;
     }
     return n;
 }
+// Display width of one code point in columns (0, 1 or 2). Based on the
+// conventional wcwidth ranges — good enough for terminal layout, and it makes
+// the emoji used in the status line (🧠🌐) count as 2, while math symbols like
+// ⧗ (U+29D7) stay 1, matching a real terminal.
+export function charWidth(cp) {
+    // Zero width: combining marks, ZWJ/ZWNJ, variation selectors.
+    if (cp === 0x200b ||
+        cp === 0x200c ||
+        cp === 0x200d ||
+        (cp >= 0x0300 && cp <= 0x036f) ||
+        (cp >= 0x1ab0 && cp <= 0x1aff) ||
+        (cp >= 0x1dc0 && cp <= 0x1dff) ||
+        (cp >= 0x20d0 && cp <= 0x20ff) ||
+        (cp >= 0xfe00 && cp <= 0xfe0f) ||
+        (cp >= 0xfe20 && cp <= 0xfe2f)) {
+        return 0;
+    }
+    // Wide: CJK, Hangul, fullwidth forms, emoji.
+    if ((cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0x303e) ||
+        (cp >= 0x3041 && cp <= 0x33ff) ||
+        (cp >= 0x3400 && cp <= 0x4dbf) ||
+        (cp >= 0x4e00 && cp <= 0x9fff) ||
+        (cp >= 0xa000 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe4f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f000 && cp <= 0x1f02f) ||
+        (cp >= 0x1f300 && cp <= 0x1faff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd)) {
+        return 2;
+    }
+    return 1;
+}
 export function layoutInput(promptStr, buf, cursor, cols) {
     const width = Math.max(20, Number(cols) || 80);
     const promptW = visLen(promptStr);
@@ -128,21 +170,29 @@ export function layoutInput(promptStr, buf, cursor, cols) {
         const avail = Math.max(1, width - promptW);
         const start = i;
         // Build the next visual line. First we take as many
-        // characters as fit (count < avail). If we hit the width
+        // characters as fit (columns < avail). If we hit the width
         // and the next character is not the end of the line, we roll back to the
         // last space so we don't split a word in the middle (word-wrap).
+        // Wrapping and the cursor column are measured in COLUMNS (charWidth),
+        // not code points — otherwise a CJK/emoji input would overflow the row
+        // and put the cursor on the wrong cell.
         let text = '';
-        let count = 0;
-        let lastSpace = -1; // index of the space in text (by Array.from)
-        while (i < chars.length && chars[i] !== NL && count < avail) {
+        let widthUsed = 0;
+        let charIdx = 0;
+        let lastSpace = -1; // char index of the space within text
+        while (i < chars.length && chars[i] !== NL) {
+            const w = charWidth(chars[i].codePointAt(0));
+            if (widthUsed + w > avail)
+                break;
             if (chars[i] === ' ')
-                lastSpace = count;
+                lastSpace = charIdx;
             text += chars[i];
             i++;
-            count++;
+            charIdx++;
+            widthUsed += w;
         }
         const atLineEnd = i >= chars.length || chars[i] === NL;
-        if (!atLineEnd && count >= avail && lastSpace > 0) {
+        if (!atLineEnd && widthUsed >= avail && lastSpace > 0) {
             // Move the "tail" of the line to the next visual line.
             const textChars = Array.from(text);
             const tailLen = textChars.length - lastSpace;
@@ -162,7 +212,8 @@ export function layoutInput(promptStr, buf, cursor, cols) {
     let cursorCol = promptW;
     for (let r = 0; r < rows.length; r++) {
         const row = rows[r];
-        const len = Array.from(row.text).length;
+        const rowChars = Array.from(row.text);
+        const len = rowChars.length;
         const from = row.start;
         const to = row.start + len;
         if (cur >= from && cur <= to) {
@@ -170,7 +221,12 @@ export function layoutInput(promptStr, buf, cursor, cols) {
             if (cur === to && next && next.start === to)
                 continue;
             cursorRow = r;
-            cursorCol = promptW + (cur - from);
+            // Cursor column in COLUMNS (wide chars count as 2).
+            let w = 0;
+            for (let k = 0; k < cur - from; k++) {
+                w += charWidth(rowChars[k].codePointAt(0));
+            }
+            cursorCol = promptW + w;
             break;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.49.0",
+  "version": "2.49.2",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {