zames_pro 2.80.0 → 2.80.2

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.80.2] - 2026-10-20
+
+### Fixed
+
+- wrapToWidth keeps the indentation and inner spaces of a line
+- **undo:** derive the backup name hash with sha1 instead of a path prefix
+
+## [2.80.1] - 2026-10-20
+
+### Fixed
+
+- **context:** strip a leading BOM before the SKILL.md frontmatter
+- **statusline:** clip a long status badge to one short row
+- **diagnostics:** keep the summary inside maxChars
+
 ## [2.80.0] - 2026-10-20
 
 ### Fixed

package/dist/context.js

@@ -305,7 +305,13 @@ function parseFrontmatter(raw) {
     };
 }
 export function skillBody(raw) {
-    const norm = raw.replace(CRLF_RE, NL);
+    // A leading BOM (some Windows editors and generators write one) makes the
+    // text NOT start with `---`, so the frontmatter check below missed it and
+    // the model got the raw YAML mixed into the instructions. Drop it first.
+    const bom = String.fromCharCode(0xfeff);
+    const norm = String(raw ?? '')
+        .replace(new RegExp('^' + bom), '')
+        .replace(CRLF_RE, NL);
     if (!norm.startsWith('---'))
         return norm.trim();
     const end = norm.indexOf(NL + '---', 3);

package/dist/diagnostics.js

@@ -47,10 +47,14 @@ export function summarizeDiagnostics(raw, maxChars) {
     const chosen = errLines.length ? errLines : lines;
     let out = chosen.join('\n');
     if (out.length > maxChars) {
+        // The truncation MARKER is part of the cap, so the head must leave room
+        // for it (appending it to a maxChars-long head exceeded the budget).
+        const MARKER = '\n… [diagnostics truncated]';
+        const budget = Math.max(0, maxChars - MARKER.length);
         // Never split a surrogate PAIR (emoji / astral CJK): the high half alone
         // is a lone surrogate in the model's context. Same rule as
         // truncateToolResult (agent-loop) and capReport (subagent).
-        let cut = maxChars;
+        let cut = budget;
         const c = out.charCodeAt(cut - 1);
         if (c >= 0xd800 && c <= 0xdbff)
             cut--;

package/dist/input/layout.js

@@ -183,41 +183,67 @@ export function wrapToWidth(s, maxCols) {
             out.push('');
             continue;
         }
-        let line = '';
-        let lineW = 0;
-        for (const word of raw.split(' ')) {
+        // A line that already fits is returned VERBATIM: wrapping is a width
+        // operation, not a normalizer. Splitting on spaces and re-joining ate the
+        // leading indentation (and emptied a line of only spaces), so an indented
+        // warning / echoed operator line lost its layout.
+        if (visLen(raw) <= width) {
+            out.push(raw);
+            continue;
+        }
+        // Wrapping is a WIDTH operation, not a normalizer: the spaces BETWEEN words
+        // (and the leading indentation) belong to the line and are reproduced
+        // verbatim. The old split(' ')/join(' ') glued the words back with ONE
+        // separator, so `'aaa bbb'` at width 7 became `'aaabbb'` and an indented
+        // warning lost its indent.
+        const words = raw.split(/ +/).filter((w) => w !== '');
+        const indent = raw.slice(0, raw.length - raw.trimStart().length);
+        let line = indent;
+        let lineW = visLen(indent);
+        let first = true;
+        for (let i = 0; i < words.length; i++) {
+            const word = words[i];
             const w = visLen(word);
             // Hard-split a word longer than a whole line.
             if (w > width) {
-                if (line) {
+                if (!first) {
                     out.push(line);
+                    line = '';
+                    lineW = 0;
                 }
                 let piece = '';
                 let pieceW = 0;
                 for (const ch of word) {
                     const cw = charWidth(ch.codePointAt(0));
                     if (pieceW + cw > width) {
-                        out.push(piece);
+                        out.push(line + piece);
+                        line = '';
+                        lineW = 0;
                         piece = '';
                         pieceW = 0;
                     }
                     piece += ch;
                     pieceW += cw;
                 }
-                line = piece;
-                lineW = pieceW;
+                line += piece;
+                lineW += pieceW;
+                first = false;
                 continue;
             }
-            const sep = line ? 1 : 0;
-            if (lineW + sep + w > width) {
+            if (!first && lineW + 1 + w > width) {
                 out.push(line);
                 line = word;
                 lineW = w;
+                first = false;
+                continue;
             }
-            else {
-                line = line ? line + ' ' + word : word;
-                lineW += sep + w;
+            if (!first) {
+                line += ' ';
+                lineW += 1;
             }
+            line += word;
+            lineW += w;
+            first = false;
         }
         out.push(line);
     }

package/dist/statusline.js

@@ -1,4 +1,27 @@
 import { spawn } from 'node:child_process';
+// N37 statusLine hook. When `ui.statusLineCommand` is set, zames runs it on a
+// timer with a JSON status object on stdin and shows the FIRST line of its
+// stdout in the status line (like Claude Code). The command is deliberately
+// run OUT of the render path: a per-render spawn would block typing, so the
+// caller runs it on its own interval and only sets the resulting text.
+//
+// Best-effort: a missing/failing command yields an empty string (the badge is
+// hidden), never an error in the UI.
+// Longest status text that still fits a typical terminal row together with
+// the rest of the status bar.
+export const STATUS_BADGE_MAX = 80;
+/** Clip a status badge to STATUS_BADGE_MAX with an ellipsis (never splits a
+ *  surrogate pair). */
+export function clipBadge(text, max = STATUS_BADGE_MAX) {
+    const s = String(text ?? '');
+    if (s.length <= max)
+        return s;
+    let cut = max - 1;
+    const c = s.charCodeAt(cut - 1);
+    if (c >= 0xd800 && c <= 0xdbff)
+        cut--;
+    return s.slice(0, cut) + '…';
+}
 /** Run the statusLine command and return its first stdout line (trimmed). */
 export function runStatusLineCommand(workdir, command, info, timeoutMs = 4000) {
     return new Promise((resolve) => {
@@ -24,7 +47,10 @@ export function runStatusLineCommand(workdir, command, info, timeoutMs = 4000) {
                 return;
             done = true;
             const first = String(out).split(/\r?\n/)[0].trim();
-            resolve(first);
+            // The status line is rendered as ONE row, unwrapped. A command that
+            // prints a long single line must not push 400 raw columns into it
+            // (the row overflows and the cursor arithmetic drifts).
+            resolve(clipBadge(first));
         };
         // Only the FIRST LINE is shown, so there is no reason to keep collecting a
         // big blob: a chatty command (a JSON dump, `ls -R`) would grow `out`

package/dist/undo.js

@@ -1,7 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
-import { randomBytes } from 'crypto';
+import { randomBytes, createHash } from 'crypto';
 import { writeJsonAtomic } from './fsutil.js';
 const UNDO_DIR = path.join(os.homedir(), '.zames', 'undo');
 const INDEX = path.join(UNDO_DIR, 'index.json');
@@ -42,13 +42,17 @@ export class UndoStore {
                 throw e;
         }
         const stamp = Date.now();
-        const hash = Buffer.from(filePath).toString('hex').slice(0, 16);
+        // The name only needs to be SHORT and unique; the backup name also
+        // carries a random suffix. A 16-hex prefix of the hex-encoded path is
+        // the first 8 BYTES of the path, which for files in one directory is
+        // the SAME string (and identical without the random part).
+        const hash = createHash('sha1').update(filePath).digest('hex').slice(0, 16);
         let backupFile = null;
         if (existed) {
-            // The stamp is only ms-precision and the hash is the first 8 bytes of
-            // the path, so two SIBLING files edited in the same millisecond would
-            // collide and the second write would clobber the first (losing the
-            // backup). Add a random suffix so a backup name is unique.
+            // The stamp is only ms-precision, so two edits in the same
+            // millisecond would share a backup name and the second write would
+            // clobber the first (losing the backup). Add a random suffix so a
+            // backup name is unique.
             const uniq = randomBytes(4).toString('hex');
             backupFile = path.join(UNDO_DIR, `${stamp}-${hash}-${uniq}.bak`);
             await fs.writeFile(backupFile, content);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.80.0",
+  "version": "2.80.2",
   "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": {