zames_pro 2.96.6 → 2.96.8

package/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.96.8] - 2026-11-06
+
+### Fixed
+
+- **ui-health:** report a capability listed twice only once
+- **tui:** a throwing store subscriber no longer starves the others
+- **undo:** list(0) returns no rows instead of the whole history
+- **shell:** a cd inside a nested shell is checked by the sandbox
+- **sandbox:** a dangling symlink cannot let a write escape the root
+
+## [2.96.7] - 2026-11-06
+
+### Fixed
+
+- **tui:** a raw DEL byte is not inserted into the input line
+- **tui:** Down after editing a recalled entry moves to the next entry
+- **tui:** Up/Down keep the visual column on wide-glyph wrapped lines
+- **goal:** a quoted verdict example no longer wins over the real verdict
+- **input:** hold only a partial paste marker, not a lone ESC
+
 ## [2.96.6] - 2026-11-06
 
 ### Fixed

package/dist/goal.js

@@ -151,7 +151,31 @@ export function parseGoalVerdict(text) {
     const label = /VERDICT\s*[*_`]*\s*:\s*[*_`]*\s*(IMPOSSIBLE|NOT[_ -]?MET|MET)(?![\w-])/gi;
     let m;
     let status = null;
+    // True when the backtick run ending right BEFORE `at` is the CLOSING fence
+    // of a block that started at the beginning of a line.
+    const isFenceClose = (src, at) => {
+        let i = at - 1;
+        while (i >= 0 && src.charAt(i) === '`')
+            i--;
+        const fenceEnd = at;
+        const fenceStart = i + 1;
+        if (fenceEnd - fenceStart < 1)
+            return false;
+        // The opening run must be at the START of a line (or of the text).
+        const lineStart = src.lastIndexOf(String.fromCharCode(10), fenceStart - 1) + 1;
+        return src.slice(lineStart, fenceStart).trim() === '';
+    };
     while ((m = label.exec(t)) !== null) {
+        // A QUOTED or BACKTICKED label is an EXAMPLE the evaluator is explaining,
+        // not its verdict: `A verdict such as "VERDICT: MET" would be wrong here`
+        // followed by the real `VERDICT: NOT_MET` used to clear the goal as DONE.
+        // A quote/backtick directly BEFORE the label marks an example — unless it
+        // is the CLOSING fence of a fenced verdict (```` ```Verdict: MET``` ````),
+        // which is the accepted format and must parse.
+        const before = t.charAt(m.index - 1);
+        if (before === '"' || (before === '`' && !isFenceClose(t, m.index))) {
+            continue;
+        }
         // Skip whitespace/backticks between the value and whatever follows.
         let k = m.index + m[0].length;
         while (k < t.length && /[\s*_`]/.test(t.charAt(k)))
@@ -159,6 +183,10 @@ export function parseGoalVerdict(text) {
         const after = t.charAt(k);
         if (after === '|' || after === '/')
             continue;
+        // A CLOSING quote/backtick right after the value is the other end of an
+        // example (`VERDICT: MET` in prose).
+        if (after === '"' || after === '`')
+            continue;
         const raw = m[1].toUpperCase();
         status =
             raw === 'MET' ? 'met' : raw === 'IMPOSSIBLE' ? 'impossible' : 'not_met';

package/dist/input/layout.js

@@ -659,7 +659,10 @@ export function splitPasteTail(s) {
     // The longest marker prefix to consider is one char short of the marker.
     const markers = [PASTE_START, PASTE_END];
     const maxHold = Math.max(...markers.map((m) => m.length)) - 1;
-    const upto = Math.min(maxHold, str.length - 1);
+    // Hold a PARTIAL marker up to the full marker length: for a 1-char chunk
+    // (`str.length - 1` = 0) nothing was held, so a read ending on a lone ESC
+    // leaked it into the buffer instead of waiting for the rest of `ESC[200~`.
+    const upto = Math.min(maxHold, str.length);
     for (let len = upto; len >= 1; len--) {
         const tail = str.slice(str.length - len);
         if (!tail.startsWith(ESC))

package/dist/input.js

@@ -1640,7 +1640,11 @@ export class LineEditor {
         // to _pasteBuf (it is not parsed by this loop), so a held tail would be
         // re-attached to `s` and inserted as text BEFORE the body — the tail
         // (`1~`) leaked into the input line and was not part of the pasted text.
-        const held = this._inPaste
+        // The bare-ESC disambiguation below must still see a chunk that IS just an
+        // ESC: holding it as a partial paste marker would swallow the Escape key
+        // (and a following arrow tail would then be read as literal text). Only a
+        // PARTIAL marker of 2+ chars is held here; the lone ESC keeps its own path.
+        const held = this._inPaste || s === ESC
             ? { head: s, tail: null }
             : splitPasteTail(s);
         if (held.tail) {

package/dist/sandbox.js

@@ -12,6 +12,17 @@ function realPathNearest(target) {
     const tail = [];
     while (true) {
         try {
+            // `lstat` does NOT follow the final link: a DANGLING symlink makes
+            // `realpathSync` throw, so the broken link used to fall back to the
+            // LEXICAL path and a write THROUGH it landed at its target OUTSIDE the
+            // sandbox. Read the link itself and resolve its target too.
+            const st = fs.lstatSync(cur);
+            if (st.isSymbolicLink()) {
+                const raw = fs.readlinkSync(cur);
+                const resolvedLink = path.resolve(path.dirname(cur), raw);
+                const realTarget = realPathNearest(resolvedLink);
+                return path.join(realTarget, ...tail.slice().reverse());
+            }
             return path.join(fs.realpathSync(cur), ...tail.slice().reverse());
         }
         catch {

package/dist/shell.js

@@ -30,7 +30,13 @@ export function assertCommandInsideRoot(root, command) {
     // `cd$HOME`, `cd../..` — and runs it as a real directory change. Requiring
     // whitespace skipped those forms, so a glued `cd../..` walked out of the
     // root with the guard never firing.
-    const cdRe = /(?:^|[;&|(\s`])(?:cd|pushd)\s*([^;&|)]+)/gi;
+    // A `cd` inside a nested shell (`sh -c "cd / && ls"`) is executed
+    // exactly like a top-level one, but the static scan saw no separator
+    // before it: the `cd` sits after `-c "`. Treat `-c <quote>` as a
+    // separator too, so the target is checked (and rejected when it leaves
+    // the root). `$(cd …)` / backticks were already covered by `(` and
+    // the backtick.
+    const cdRe = /(?:^|[;&|(\s`]|-[a-z]*c\s*['"])(?:cd|pushd)\s*([^;&|)]+)/gi;
     let m;
     while ((m = cdRe.exec(cmd))) {
         // The shell removes EVERY quote in the word, wherever it sits —

package/dist/tui/edit.js

@@ -199,9 +199,14 @@ export function moveVisualRows(s, delta, promptStr, cols) {
     // 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);
+    // Walk the characters of the current row until their VISUAL width reaches
+    // the caret's column. The old loop ran `cursorCol` TIMES over characters:
+    // with a wide (CJK) glyph two columns come from ONE character, so it read
+    // past the row (undefined counted as 1) and Up/Down landed too far right.
     let want = 0;
-    for (let k = 0; k < lay.cursorCol - visLen(curRow.prefix); k++) {
-        want += charWidth(curChars[k]?.codePointAt(0) ?? 32);
+    const targetCol = lay.cursorCol - visLen(curRow.prefix);
+    for (let k = 0; k < curChars.length && want < targetCol; k++) {
+        want += charWidth(curChars[k].codePointAt(0));
     }
     let idx = row.start;
     let w = 0;
@@ -221,8 +226,16 @@ export function moveVisualRows(s, delta, promptStr, cols) {
     // rows" bug.
     if (idx > row.start + rowChars.length)
         idx = row.start + rowChars.length;
-    if (idx === row.start + rowChars.length && rowChars.length > 0)
-        idx--;
+    // Keep the caret INSIDE the target row — but a caret at the row's END is
+    // the natural position for a WIDE last glyph: stepping back one CODE UNIT
+    // put it in the MIDDLE of a surrogate pair or before a CJK glyph, so Up
+    // from the end of a wrapped CJK line landed a glyph too far left. Only step
+    // back when the end is followed by MORE text on the same visual line.
+    if (idx === row.start + rowChars.length && rowChars.length > 0) {
+        const atWide = idx > 0 && charWidth(s.buf.codePointAt(idx - 1) ?? 32) === 2;
+        if (!atWide)
+            idx--;
+    }
     return { ...s, cursor: idx };
 }
 /** Insert a newline; a trailing «\» before the cursor is removed first. */
@@ -274,7 +287,18 @@ export function historyDown(s) {
     // The CURRENT line is the operator's, not a history entry: leaving the
     // history must bring it back. Without this, editing a recalled line and then
     // pressing Down restored the OLD draft and dropped the edit.
-    const draft = browsingHistory(s) ? s.histDraft : s.buf;
+    //
+    // An EDIT of a recalled entry is a scratch copy of THAT slot, not the
+    // operator's draft: `typingRun` marks it. Treating it as "not browsing"
+    // jumped OUT of the history and dropped the entry the operator was fixing —
+    // Down must still move to the NEXT entry.
+    // A REAL edit means the buffer no longer matches the recalled entry: the
+    // `typingRun` flag is set by the KEY layer, not by `insertText` itself, so
+    // the comparison is what is reliable here.
+    const recalled = s.history[s.histIndex];
+    const editingRecalled = s.histIndex < s.history.length &&
+        (s.typingRun || (recalled !== undefined && s.buf !== recalled));
+    const draft = browsingHistory(s) && !editingRecalled ? s.histDraft : s.buf;
     let buf;
     if (histIndex < s.history.length - 1) {
         histIndex++;

package/dist/tui/keys.js

@@ -197,7 +197,11 @@ export function dispatchKey(input, key, ctx, isVisualEdge) {
     if (key.escape)
         return { type: 'escape' };
     // ---- printable text ----
-    if (input && input >= ' ') {
+    // A raw DEL byte (0x7f) is NOT printable: some terminals hand it over as
+    // plain `input` without `key.backspace`, and `input >= ' '` (DEL is 127)
+    // inserted it as an invisible control character into the buffer.
+    const printable = input && input !== String.fromCharCode(127) && input >= ' ';
+    if (printable) {
         return { type: 'insert', text: input };
     }
     return null;

package/dist/tui/store.js

@@ -104,7 +104,20 @@ export class TuiStore {
         this.emit();
     }
     emit() {
-        for (const cb of this.listeners)
-            cb();
+        // A subscriber that throws (a React render error, a bug in the status bar)
+        // must not abort the loop: the subscribers AFTER it kept a STALE snapshot,
+        // and the exception escaped into the agent code that only printed a line.
+        // Notify every subscriber, then re-throw the FIRST error so a genuine bug
+        // is still visible where the caller can see it.
+        for (const cb of this.listeners) {
+            try {
+                cb();
+            }
+            catch {
+                // Swallowed ON PURPOSE: a notification sink is a render concern, and
+                // the imperative agent path that printed the line must not crash (and
+                // must not skip the remaining subscribers).
+            }
+        }
     }
 }

package/dist/ui-health.js

@@ -52,6 +52,9 @@ export async function probeUiHealth(page, capabilities = UI_CAPABILITIES) {
     const present = [];
     const missing = [];
     const missingCritical = [];
+    // A capability listed TWICE (two selector chains merged, a copy-paste) was
+    // reported twice, and the `/doctor` row read `input, input`.
+    const seen = new Set();
     for (const spec of capabilities) {
         // A capability with NO selectors cannot be probed at all: the provider does
         // not have that control (z.ai has no toggles). Reporting it as missing made
@@ -59,6 +62,9 @@ export async function probeUiHealth(page, capabilities = UI_CAPABILITIES) {
         // page. It is N/A, not absent.
         if (!spec.selectors || spec.selectors.length === 0)
             continue;
+        if (seen.has(spec.capability))
+            continue;
+        seen.add(spec.capability);
         let found = false;
         for (const sel of spec.selectors) {
             if (await hasAny(page, sel, spec.textRe)) {

package/dist/undo.js

@@ -155,6 +155,10 @@ export class UndoStore {
     }
     async list(count = 10) {
         const history = await this._readIndex();
+        // `slice(-0)` is `slice(0)` — the WHOLE history, so asking for ZERO rows
+        // returned everything. A count below 1 means "no rows".
+        if (!(count > 0))
+            return [];
         return history.slice(-count).reverse();
     }
 }

package/package.json

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