zames_pro 2.82.66 → 2.82.68

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.82.68] - 2026-10-24
+
+### Fixed
+
+- **tools:** do not drop read-only MCP tools from plan mode
+
+## [2.82.67] - 2026-10-24
+
+### Fixed
+
+- **tui:** Up/Down in a wrapped input keeps the visual column
+
 ## [2.82.66] - 2026-10-24
 
 ### Fixed

package/dist/tools.js

@@ -479,6 +479,10 @@ const MCP_MUTATING_WORDS = new Set(('click type navigate press upload select dra
 // Multi-word verbs are matched as a substring of the normalized name: they
 // never stand alone as ONE `_word_`, so a word-set alone missed them.
 const MCP_MUTATING_PHRASES = ['run_code', 'run_', 'handle_dialog'];
+// Read-only SCOPES that legitimately prefix a verb-like word (`read_...`,
+// `get_...`, `list_...`, `describe_...`): a name like `read_insert_log` is a
+// read action on a log, not an insert. A writer never puts these first.
+const MCP_READ_SCOPES = new Set(['read', 'get', 'list', 'describe', 'fetch']);
 // A camelCase name is split BEFORE it is lowercased: `browserClick` used to
 // become `browserclick` (one word, no verb) and slipped through read-only mode.
 function splitCamelCase(s) {
@@ -494,12 +498,35 @@ export function isMutatingMcpTool(name) {
     if (MCP_MUTATING_PHRASES.some((p) => norm.includes(p)))
         return true;
     const words = norm.split('_').filter(Boolean);
+    // A read SCOPE (`read_…`, `get_…`) makes the whole name a READ even when a
+    // verb-like word follows: `describe_type` describes a type,
+    // `read_insert_log` reads a log. Dropping them from plan mode removed a tool
+    // the model may use. Checked BEFORE the word match, so the scope word wins.
+    if (MCP_READ_SCOPES.has(words[0]))
+        return false;
     if (words.some((w) => MCP_MUTATING_WORDS.has(w)))
         return true;
     // A CONCATENATED style (all lowercase, no separator: `browserclick`,
-    // `pageevaluate`) still hides a writer. A verb as a substring is safe here
-    // because every verb is a whole action word no read-only tool contains.
-    return [...MCP_MUTATING_WORDS].some((v) => norm.includes(v));
+    // `pageevaluate`) still hides a writer. A BARE substring test is too
+    // aggressive, though: `get_settings` contains `set`, `get_keywords`
+    // contains `key`, `read_insert_log` contains `insert`, `describe_type`
+    // contains `type` — genuine READ-ONLY tools were dropped from plan mode.
+    // A concatenated verb is only trusted when it is a PREFIX of the name
+    // (`browserclick` -> after the `browser` scope) or spans the WHOLE name
+    // (`pageevaluate`); a verb buried inside another word is not an action.
+    const compact = norm.replace(/_/g, '');
+    const lastWord = words[words.length - 1];
+    return [...MCP_MUTATING_WORDS].some((v) => {
+        if (lastWord === v)
+            return true;
+        // A concatenated writer glues the verb to a SCOPE word: `fileupload`,
+        // `mouseclick`, `codeexecute`. Only the scope+verb pair counts — a bare
+        // word that merely CONTAINS the letters (`readinsertlog`,
+        // `describetype`) is a read action on a thing, not a write.
+        if (!compact.endsWith(v) || compact === v)
+            return false;
+        return !MCP_READ_SCOPES.has(compact.slice(0, -v.length));
+    });
 }
 // Merge MCP tools into the base set. In read-only (plan) mode the MCP tools
 // must be filtered too: an MCP server (e.g. @playwright/mcp) exposes mutating

package/dist/tui/edit.js

@@ -177,14 +177,37 @@ export function moveVisualRows(s, delta, promptStr, cols) {
         return s;
     const row = lay.rows[target];
     const rowChars = Array.from(row.text);
-    const promptW = visLen(row.prefix);
-    const want = Math.max(0, lay.cursorCol - promptW);
+    // `cursorCol` is the column inside the CURRENT row (prompt + its text). The
+    // row above/below has a DIFFERENT indent (`row.start` differs), so the
+    // offset must be measured from the CURRENT row's own text, not as a raw
+    // `cursorCol - promptW` character count: on a wrapped line that put the
+    // caret past the target row's text and onto the NEXT row entirely.
+    const curRow = lay.rows[lay.cursorRow];
+    const curChars = Array.from(curRow.text);
+    let want = 0;
+    for (let k = 0; k < lay.cursorCol - visLen(curRow.prefix); k++) {
+        want += charWidth(curChars[k]?.codePointAt(0) ?? 32);
+    }
     let idx = row.start;
     let w = 0;
-    while (idx < row.start + rowChars.length && w < want) {
-        w += charWidth(rowChars[idx - row.start].codePointAt(0));
+    // Walk the target row and STOP on the first character that no longer fits.
+    // Landing exactly on `row.start + len` is the NEXT row's first character in
+    // the layout (`cur === row end` is only kept when it is a wrap boundary),
+    // so a caret at the end of a SHORT last row must stay on its last character.
+    while (idx < row.start + rowChars.length) {
+        const cw = charWidth(rowChars[idx - row.start].codePointAt(0));
+        if (w + cw > want)
+            break;
+        w += cw;
         idx++;
     }
+    // Keep the caret INSIDE the target row: the layout moves a caret that sits
+    // on the row end onto the next row, which is exactly the "Up jumps two
+    // rows" bug.
+    if (idx > row.start + rowChars.length)
+        idx = row.start + rowChars.length;
+    if (idx === row.start + rowChars.length && rowChars.length > 0)
+        idx--;
     return { ...s, cursor: idx };
 }
 /** Insert a newline; a trailing «\» before the cursor is removed first. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.82.66",
+  "version": "2.82.68",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen and other web LLMs — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {