zames_pro 2.82.136 → 2.82.138

package/dist/send-runtime.js

@@ -78,11 +78,9 @@ export class SendRuntime {
         if (typeof extra.retryAfterMs === 'number') {
             e.retryAfterMs = extra.retryAfterMs;
         }
-        // A SUCCESS after a rate limit IS the lift of that block. onBlockLifted()
-        // was the only producer of `blockMs`, but no provider's ask() calls it (a
-        // rate limit is retried IN PLACE and the retry simply succeeds), and the
-        // fold below clears `blockedAt` first. The measured duration is therefore
-        // taken HERE, before the state is folded; it is attached to the SAME event
+        // A SUCCESS after a rate limit IS the lift of that block: the retry happens
+        // IN PLACE and simply succeeds. The duration is therefore measured HERE,
+        // before the fold below clears `blockedAt`, and attached to the SAME event
         // line, so one block still yields exactly one sample.
         let blockMs;
         if (outcome === 'ok' &&
@@ -101,11 +99,9 @@ export class SendRuntime {
             this.state = { ...this.state, blocked: true, blockedAt: this.now() };
         }
         if (outcome === 'rate_limit') {
-            // The block START is only known AFTER the fold above (the adaptive path
-            // sets it there). The event itself carries NO duration: a rate-limit
-            // send is not the END of the block, so any value measured here is a
-            // lower bound that would then be averaged together with the real
-            // duration written by onBlockLifted — the same block counted TWICE.
+            // The event carries NO duration: a rate-limit send is not the END of the
+            // block, so a value measured here would be averaged together with the
+            // real duration measured at the lift — the same block counted TWICE.
             if (!this.state.blockedAt) {
                 this.state = { ...this.state, blocked: true, blockedAt: this.now() };
             }

package/dist/send-telemetry.js

@@ -51,14 +51,12 @@ export function summarizeSends(events, now = Date.now()) {
         const age = now - t;
         return age >= 0 && age <= ms;
     }).length;
-    // `blockMs` may arrive as a NUMBER (the writer) or a string (an older
-    // build, a hand-edited file): a numeric string is accepted so the average
-    // is not silently 0 for a file that records the block.
     const blocks = events
-        // `Number(null)`/`Number(undefined)` — 0/NaN, and 0 IS a finite
-        // non-negative number: an event that carries no block duration (the
-        // rate-limit event only records `blockedAt`) was averaged as a ZERO-length
-        // block, halving the reported average. Only a REAL value counts.
+        // `blockMs` may arrive as a NUMBER (the writer) or a string (an older
+        // build, a hand-edited file), so it is coerced. A missing value must NOT
+        // become 0: 0 is a finite non-negative number, and an event without a
+        // block duration (the rate-limit event only records `blockedAt`) was
+        // averaged as a ZERO-length block, halving the reported average.
         .map((e) => e.blockMs === null || e.blockMs === undefined ? NaN : Number(e.blockMs))
         // A finite value is not enough: the SUM of many large durations overflows
         // a JS number (two `Number.MAX_VALUE` entries add up to Infinity), so the

package/dist/send-throttle.js

@@ -39,11 +39,10 @@ function prune(recent, now, windowMs) {
  */
 export function nextWaitMs(state, lastSentAt, now) {
     if (state.forcedWaitMs > 0) {
-        // A forced wait must EXPIRE: a long Retry-After used to block every
-        // send forever (the check was `> 0` only), until another event cleared
-        // it. With the request stamp the remaining time is exact; without one
-        // (a caller-built or restored state) the wait is reported ONCE, from
-        // the current call, and expires on the next.
+        // A forced wait must EXPIRE: with only `forcedWaitMs > 0` a long
+        // Retry-After blocked every send until another event cleared it. The
+        // request stamp makes the remaining time exact; without one (a caller-built
+        // or restored state) the wait is reported ONCE, from the current call.
         if (state.forcedWaitAt) {
             const left = state.forcedWaitMs - (now - state.forcedWaitAt);
             return left > 0 ? left : 0;

package/dist/sessions.js

@@ -133,13 +133,12 @@ function writeIndex({ id, workdir }) {
     }
     catch { }
 }
-// The last session for the working directory. If there is none —
-// we return the last session overall (useful when launched from a new place).
-// The last session for the working directory, restricted to `provider` when
-// given. A chat id only exists on ITS backend, so restoring a DeepSeek chat
-// while the active provider is Qwen (or vice versa) would fail to open — the
-// filter makes auto-restore and /last pick the right one (and fall back to the
-// global last only within the same provider).
+// The last session for the working directory (the last one overall when the
+// directory has none — useful when launched from a new place), restricted to
+// `provider` when given. A chat id only exists on ITS backend, so restoring a
+// DeepSeek chat while the active provider is Qwen (or vice versa) would fail to
+// open; the filter makes auto-restore and /last pick the right one, and fall
+// back to the global last only within the same provider.
 export function loadLastSession(workdir = '', provider) {
     try {
         const index = JSON.parse(fs.readFileSync(INDEX_FILE, 'utf-8'));

package/dist/spinner.js

@@ -152,10 +152,9 @@ export function createSpinner(locale = 'ru') {
             }
             startThinking();
         },
-        // The agent is waiting out the send-interval pause before a real send.
-        // Show it as an ANIMATED status line with the remaining seconds, so the
-        // spinner keeps moving during the pause (previously a static console line
-        // was printed and the dots stayed frozen).
+        // The agent is waiting out the send-interval pause before a real send: an
+        // ANIMATED status with the remaining seconds, so the spinner keeps moving
+        // (a static line made the pause look frozen).
         sendPause: (seconds) => {
             if (pending)
                 return;

package/dist/statusline.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-// N37 statusLine hook. When `ui.statusLineCommand` is set, zames runs it on a
+// 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
@@ -58,10 +58,6 @@ export function runStatusLineCommand(workdir, command, info, timeoutMs = 4000) {
             // (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`
-        // unboundedly and the status row then repainted megabytes. Stop appending
-        // once a short line is buffered (the rest of that line does not matter).
         const timer = setTimeout(() => {
             try {
                 if (process.platform !== 'win32' && child.pid) {
@@ -74,15 +70,15 @@ export function runStatusLineCommand(workdir, command, info, timeoutMs = 4000) {
             catch { }
             finish();
         }, timeoutMs);
-        // A status line is a short badge: cap what is buffered so a chatty
-        // command cannot grow it (and the rendered row) without bound.
+        // Only the FIRST line is shown and the status line is a short badge, so the
+        // buffer is capped: a chatty command (a JSON dump, `ls -R`) would otherwise
+        // grow `out` and make the status row repaint megabytes on every tick.
         const MAX_OUT = 400;
         child.stdout?.on('data', (c) => {
             if (out.length >= MAX_OUT)
                 return;
-            // A chunk can be huge (one 64 KB read); clip it to the remaining space
-            // so the buffer never exceeds MAX_OUT. An unbounded `out` made the
-            // status row repaint megabytes on every tick.
+            // A chunk can be huge (one 64 KB read): clip it to the remaining space so
+            // the buffer never exceeds MAX_OUT.
             out += c.toString().slice(0, MAX_OUT - out.length);
         });
         child.on('error', () => {

package/dist/subagent.js

@@ -178,7 +178,7 @@ export function createSubagentRunner(opts) {
             browser.onSendState = savedHooks.onSendState;
             browser.onNotice = savedHooks.onNotice;
         }
-        // SubagentStop hook (N32): fires after the nested loop finishes, so a hook
+        // SubagentStop hook: fires after the nested loop finishes, so a hook
         // can clean up or notify. Best-effort; its stdout is appended to the report.
         let hookOut = '';
         try {

package/dist/system-prompt.js

@@ -124,7 +124,7 @@ export function renderContextSection(context) {
                 f.content +
                 '\n';
     }
-    // B6: nested AGENTS.md/MEMORY.md from the directories this task touches.
+    // Nested AGENTS.md/MEMORY.md from the directories this task touches.
     // Deliberately a SEPARATE section: these apply only to part of the tree and
     // must not be mistaken for project-wide rules.
     for (const f of context.scopedAgents || []) {

package/dist/tools.js

@@ -104,7 +104,7 @@ export function createTools(workdir, { undo, todos, readOnly = false, subagents
             },
             fn: async ({ path: p, offset, limit, numbered }) => {
                 const file = safe(req(p, 'path'));
-                // Binary guard (N35): reading an image/archive as utf-8 produced
+                // Binary guard: reading an image/archive as utf-8 produced
                 // mojibake the model tried to reason about. Detect a binary buffer
                 // BEFORE decoding and answer with useful metadata instead.
                 // A read FAILURE (a missing file, a directory, EACCES) is answered in

package/dist/tui/widgets.js

@@ -1,6 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-// ---- palette (kept in one place so every menu is consistent) ----
 export const UI = {
     accent: '#c8b06a',
     accentDim: '#7a6b45',

package/package.json

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