zames_pro 2.82.52 → 2.82.54

package/CHANGELOG.md

@@ -7,6 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.82.54] - 2026-10-23
+
+### Fixed
+
+- **telemetry:** measure a rate-limit block once, at the lift
+- **hooks:** load the config before firing the Stop hook
+- **history:** match fragment types case-insensitively in every parser
+
+## [2.82.53] - 2026-10-23
+
+### Fixed
+
+- **glm:** keep a message without a timestamp in dialogue order
+- **qwen:** keep a message without a timestamp in dialogue order
+- **rewind:** resolve a full checkpoint stamp against the whole index
+
 ## [2.82.52] - 2026-10-23
 
 ### Fixed

package/dist/browser-chats.js

@@ -49,7 +49,11 @@ export function parseHistoryMessages(messages) {
         const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
         let text = '';
         for (const fr of (raw && raw.fragments) || []) {
-            if (!fr || fr.type !== want)
+            // The fragment TYPE is matched case-insensitively, like the role: a
+            // payload spelling it `response`/`request` (a proxy build, a JSON
+            // round-trip through a normalizer) skipped EVERY fragment and the
+            // restored dialogue came back empty although it carried the answer.
+            if (!fr || String(fr.type ?? '').toUpperCase() !== want)
                 continue;
             if (typeof fr.content === 'string')
                 text += fr.content;

package/dist/checkpoint.js

@@ -44,10 +44,30 @@ export function rotateRecords(records, max) {
  * Resolve a `/rewind` selector against records sorted NEWEST FIRST.
  * `1` = most recent; a non-numeric selector is matched as a stamp prefix.
  */
-export function pickRecord(records, selector) {
+/** True for a selector that is exactly a full epoch-ms stamp (13 digits). */
+export function isFullStampSelector(selector) {
+    return /^\d{13}$/.test(String(selector ?? '').trim());
+}
+const isFullStamp = isFullStampSelector;
+export function pickRecord(records, selector, 
+/** The FULL record set, when `records` is only a display window. */
+allRecords) {
     const sel = String(selector ?? '').trim();
     if (!sel)
         return null;
+    // A FULL epoch-ms stamp names exactly ONE checkpoint, wherever it sits in
+    // the index. The command resolves against the newest-10 display window while
+    // restore() searches the WHOLE index, so an older checkpoint picked by its
+    // full stamp used to report "/rewind failed" — and, worse, a stamp that
+    // happened to share its first digits with a NEWER one was resolved to that
+    // WRONG record. A full stamp is therefore matched against the full set
+    // FIRST, and only then treated as an index.
+    if (isFullStamp(sel)) {
+        const pool = allRecords && allRecords.length ? allRecords : records;
+        const exact = pool.find((r) => String(r.stamp) === sel);
+        if (exact)
+            return exact;
+    }
     if (/^\d+$/.test(sel)) {
         const n = Number(sel);
         // A small number is an index (1 = newest).
@@ -60,7 +80,10 @@ export function pickRecord(records, selector) {
         if (sel.length < 2)
             return null;
     }
-    return records.find((r) => String(r.stamp).startsWith(sel)) || null;
+    const pool = allRecords && allRecords.length ? allRecords : records;
+    return (records.find((r) => String(r.stamp).startsWith(sel)) ||
+        pool.find((r) => String(r.stamp).startsWith(sel)) ||
+        null);
 }
 // ---------- tar / fs plumbing ----------
 function runTar(args, cwd, timeout = 60_000) {

package/dist/glm-chats.js

@@ -176,7 +176,19 @@ export function parseGlmHistory(json) {
     };
     const sorted = arr
         .filter((x) => !!x && typeof x === 'object')
-        .sort((a, b) => stampOf(a) - stampOf(b));
+        // Order by INSERTION INDEX first and by stamp only when BOTH messages
+        // carry one. `stampOf` answers 0 for a missing stamp, so a half-stamped
+        // payload pushed every undated turn BEFORE all dated ones and the dialogue
+        // came back as "the model answered before it was asked".
+        .map((m, i) => ({ m, i, t: stampOf(m) }))
+        .sort((a, b) => {
+        const da = a.t !== 0;
+        const db = b.t !== 0;
+        if (da && db && a.t !== b.t)
+            return a.t - b.t;
+        return a.i - b.i;
+    })
+        .map((x) => x.m);
     const out = [];
     for (const m of sorted) {
         // The role comes from `role` (confirmed by the live fixture). Only the
@@ -201,7 +213,11 @@ export function parseGlmHistory(json) {
         else if (Array.isArray(m.fragments)) {
             const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
             for (const fr of m.fragments) {
-                if (fr && fr.type === want && typeof fr.content === 'string') {
+                // Case-insensitive, like the DeepSeek parser: a payload spelling the
+                // fragment type `response`/`request` used to contribute nothing.
+                if (fr &&
+                    String(fr.type ?? '').toUpperCase() === want &&
+                    typeof fr.content === 'string') {
                     text += fr.content;
                 }
             }

package/dist/index.js

@@ -28,7 +28,7 @@ import { handleConfigCommand as runConfigCommand } from './config-command.js';
 import { translate, normalizeLocale, localeDisplayName, isLocale, } from './i18n.js';
 import { Transcript } from './transcript.js';
 import { UndoStore } from './undo.js';
-import { CheckpointStore, pickRecord as pickCheckpoint } from './checkpoint.js';
+import { CheckpointStore, pickRecord as pickCheckpoint, isFullStampSelector, } from './checkpoint.js';
 import { selfReview, selfDiff, selfApply, selfList } from './self-review.js';
 import { performCompact } from './compact.js';
 import { clampGoalCondition } from './goal.js';
@@ -3913,8 +3913,16 @@ async function main() {
             if (editor)
                 editor.lock(t('msg.input_locked'));
             try {
+                // The DISPLAY window is the newest 10, but a FULL stamp must resolve
+                // against the whole index (restore() searches all of it): an older
+                // checkpoint picked by its stamp used to report "/rewind failed", and a
+                // stamp sharing its first digits with a newer one could resolve to
+                // THAT wrong record.
                 const list = await checkpoints.list(10);
-                const target = pickCheckpoint(list, selector);
+                const all = isFullStampSelector(selector)
+                    ? await checkpoints.list(Number.MAX_SAFE_INTEGER)
+                    : list;
+                const target = pickCheckpoint(list, selector, all);
                 if (!target) {
                     console.error(theme.error(t('rewind.failed', { v: selector })));
                     continue;

package/dist/qwen-chats.js

@@ -208,7 +208,28 @@ export function parseQwenHistory(json) {
     // The map is UNORDERED; `timestamp` (seconds) restores the dialogue order.
     const sorted = arr
         .filter((x) => !!x && typeof x === 'object')
-        .sort((a, b) => (Number(a.timestamp) || 0) - (Number(b.timestamp) || 0));
+        // A message WITHOUT a usable timestamp must not be forced to 0: that put
+        // it BEFORE every dated turn, so a partially stamped payload reordered the
+        // dialogue (the operator's question surfaced after the model's answer).
+        // Order by index first — the map is in insertion order — and only then by
+        // stamp; a missing stamp inherits its neighbour's position instead of
+        // jumping to the front. A stable sort keeps the original order on a tie.
+        .map((m, i) => ({ m, i }))
+        .sort((a, b) => {
+        const ta = Number(a.m.timestamp);
+        const tb = Number(b.m.timestamp);
+        const va = Number.isFinite(ta) ? ta : NaN;
+        const vb = Number.isFinite(tb) ? tb : NaN;
+        if (Number.isFinite(va) && Number.isFinite(vb)) {
+            if (va !== vb)
+                return va - vb;
+            return a.i - b.i;
+        }
+        // Only ONE side is dated: keep the insertion order (a half-stamped
+        // payload has no trustworthy clock to sort by).
+        return a.i - b.i;
+    })
+        .map((x) => x.m);
     const out = [];
     for (const m of sorted) {
         // Role detection is DEFENSIVE: the field has been `role` (string,
@@ -245,7 +266,11 @@ export function parseQwenHistory(json) {
         else if (Array.isArray(m.fragments)) {
             const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
             for (const fr of m.fragments) {
-                if (fr && fr.type === want && typeof fr.content === 'string') {
+                // Case-insensitive, like the DeepSeek parser: a payload spelling the
+                // fragment type `response`/`request` used to contribute nothing.
+                if (fr &&
+                    String(fr.type ?? '').toUpperCase() === want &&
+                    typeof fr.content === 'string') {
                     text += fr.content;
                 }
             }

package/dist/run-task.js

@@ -573,8 +573,11 @@ export async function runTask(deps, browser, tools, taskText, workdir, opts, att
         // Stop hook (N32): the whole task (including drained queue messages) is
         // done. A cleanup/notification hook runs here. Best-effort.
         try {
-            const { runLifecycleHooks } = await import('./hooks.js');
-            const out = await runLifecycleHooks(undefined, 'Stop', workdir, {
+            // LOAD the config: `undefined` here made every Stop hook a no-op — the
+            // operator's `.zames/hooks.json` entry never ran, while the PreToolUse
+            // hooks from the SAME file worked (they are loaded separately).
+            const { runLifecycleHooks, loadHooks } = await import('./hooks.js');
+            const out = await runLifecycleHooks(loadHooks(workdir), 'Stop', workdir, {
                 failure: failure ?? '',
             });
             if (out)

package/dist/send-runtime.js

@@ -10,7 +10,7 @@
 // survives across tasks and a provider switch within a session (a new browser
 // object is created, but the operator's decision about the interval does not
 // silently reset mid-session — it is re-derived from this session's events).
-import { DEFAULT_THROTTLE, initialThrottleState, applySendEvent, nextWaitMs, withBlockDuration, } from './send-throttle.js';
+import { DEFAULT_THROTTLE, initialThrottleState, applySendEvent, nextWaitMs, } from './send-throttle.js';
 import { appendSendEvent, } from './send-telemetry.js';
 /**
  * The runtime a provider keeps: the learned interval, the last send and the
@@ -72,7 +72,7 @@ export class SendRuntime {
     onOutcome(outcome, extra = {}) {
         if (!this.pending)
             return;
-        let e = { ...this.pending, outcome };
+        const e = { ...this.pending, outcome };
         if (extra.errorText)
             e.errorText = String(extra.errorText).slice(0, 300);
         if (typeof extra.retryAfterMs === 'number') {
@@ -88,7 +88,14 @@ export class SendRuntime {
             this.state = { ...this.state, blocked: true, blockedAt: this.now() };
         }
         if (outcome === 'rate_limit') {
-            e = withBlockDuration(e, this.state.blockedAt, this.now());
+            // 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.
+            if (!this.state.blockedAt) {
+                this.state = { ...this.state, blocked: true, blockedAt: this.now() };
+            }
         }
         if (this.opts.telemetry) {
             appendSendEvent(this.opts.logsDir, e);

package/package.json

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