zames_pro 2.32.0 → 2.35.0

package/dist/input.js

@@ -205,26 +205,32 @@ export function formatTokenStatus(tokens, limit = CONTEXT_LIMIT) {
         return '';
     }
     const n = Math.round(tokens);
-    let compact;
-    if (n >= 1_000_000) {
-        const m = n / 1_000_000;
-        compact = (Number.isInteger(m) ? String(m) : m.toFixed(1)) + 'M';
-    }
-    else if (n >= 1_000) {
-        const k = n / 1_000;
-        compact =
-            (k >= 100 ? String(Math.round(k)) : k.toFixed(1).replace(/\.0$/, '')) +
-                'k';
-    }
-    else {
-        compact = String(n);
-    }
+    const compact = formatCompactTokens(n);
     const pct = Math.max(0, (n / limit) * 100);
     const pctStr = pct >= 10 ? String(Math.round(pct)) : pct.toFixed(1);
     // "ctx:" marks this as the USED context size, so the operator does not have
     // to guess what "302k · 30%" means.
     return 'ctx: ' + compact + ' · ' + pctStr + '%';
 }
+// Compact token count (10k, 125k, 1.5M). Exported so the per-task summary
+// reuses the EXACT same "k/M" formatting as the context counter. Invalid
+// input (null/NaN/negative) renders an empty string.
+export function formatCompactTokens(tokens) {
+    if (typeof tokens !== 'number' || !Number.isFinite(tokens) || tokens < 0) {
+        return '';
+    }
+    const n = Math.round(tokens);
+    if (n >= 1_000_000) {
+        const m = n / 1_000_000;
+        return (Number.isInteger(m) ? String(m) : m.toFixed(1)) + 'M';
+    }
+    if (n >= 1_000) {
+        const k = n / 1_000;
+        return ((k >= 100 ? String(Math.round(k)) : k.toFixed(1).replace(/\.0$/, '')) +
+            'k');
+    }
+    return String(n);
+}
 export class LineEditor {
     promptStr;
     buf;
@@ -251,6 +257,12 @@ export class LineEditor {
     _showHint;
     _dotPhase;
     _thinkBase;
+    // Explicit lifecycle state of the send ('generating' | 'paused' |
+    // 'settled' | ''). The thinking spinner already shows ACTIVITY, but it does
+    // not tell a throttle pause from a real generation — a long reasoning turn
+    // and a wait for the rate-limit slot look identical. Only 'generating' shows
+    // a prefix (see _stateLabel); the field also gates the clean-up in stop().
+    _sendState;
     // The last rendered status row(s) (status + right-aligned context). Cached so
     // a re-render driven by TYPING (the buffer changed, the status did not) can
     // skip erasing and re-printing the status line entirely. On terminals like
@@ -298,6 +310,13 @@ export class LineEditor {
     contextStatus;
     // The raw token count behind contextStatus (for the color level).
     contextTokens;
+    // Number of messages waiting in the queue, shown as a small "⧗N" badge in
+    // the status line so the operator sees that typed-ahead messages are still
+    // pending. 0 hides it. Updated by the caller.
+    queueLength;
+    // A callback the editor calls before every render to read the CURRENT queue
+    // length, so the badge stays live without the caller polling.
+    onQueueQuery;
     // Whether the DeepSeek "Deep thinking" / "Smart search" toggles are ON.
     // Shown as two colored icons before the context counter: a dim gray icon
     // means off, a teal-green icon means on.
@@ -333,6 +352,7 @@ export class LineEditor {
         this._showHint = true;
         this._dotPhase = 0;
         this._thinkBase = '';
+        this._sendState = '';
         this._lastStatusBlock = '';
         this._wasRaw = false;
         this._onData = (b) => this._handle(b);
@@ -375,6 +395,8 @@ export class LineEditor {
         this.contextLimit = CONTEXT_LIMIT;
         this.onToggleQuery = null;
         this.onContextQuery = null;
+        this.queueLength = 0;
+        this.onQueueQuery = null;
     }
     // Refresh the toggle icon states from onToggleQuery (if wired) before a
     // render. A broken callback must never break the render.
@@ -423,6 +445,23 @@ export class LineEditor {
             return theme.warn(ctx);
         return theme.success(ctx);
     }
+    // The queue badge ("⧗N") shown before the context counter when messages are
+    // waiting. Returns '' when the queue is empty, so it never clutters an idle
+    // status line. Refreshed from onQueueQuery before every render when wired.
+    _queueBadge() {
+        if (this.onQueueQuery) {
+            try {
+                const n = this.onQueueQuery();
+                this.queueLength = typeof n === 'number' && n > 0 ? n : 0;
+            }
+            catch {
+                // A broken callback must never break the render.
+            }
+        }
+        if (this.queueLength <= 0)
+            return '';
+        return theme.warn('⧗' + this.queueLength) + ' ';
+    }
     // Icons for the DeepSeek toggles: 🧠 "Deep thinking" and 🌐 "Smart search",
     // shown before the context counter. Only the ENABLED toggles are shown, so
     // the state is unambiguous WITHOUT relying on the terminal coloring the
@@ -658,7 +697,7 @@ export class LineEditor {
         // but the icons are still meaningful.
         const ctxRaw = this._contextText();
         this._refreshToggles();
-        const ctxText = this._toggleIcons() + ctxRaw;
+        const ctxText = this._queueBadge() + this._toggleIcons() + ctxRaw;
         let statusOut = '';
         let top = 0;
         // Never fill a row to the FULL terminal width: on terminals with
@@ -668,31 +707,38 @@ export class LineEditor {
         // free (effective width = cols - 1) for the right-aligned context and for
         // the padded status row.
         const usable = Math.max(1, cols - 1);
-        if (this.statusText) {
+        // An explicit lifecycle phase (generating/settled) is prefixed to the
+        // animated status, so the operator can tell a real generation from a
+        // quiet spinner. Empty when no phase is active (tool running, idle).
+        const stateLabel = this._stateLabel();
+        const statusText = stateLabel
+            ? stateLabel + ' ' + this.statusText
+            : this.statusText;
+        if (statusText) {
             if (ctxText) {
                 // Right-align the context on the SAME row as the status. When the
                 // status is too long to leave room, do NOT cram them together (that
                 // pushed the trailing `%` past the right edge and it got truncated):
                 // put the context on its own line instead.
-                const space = usable - visLen(this.statusText) - visLen(ctxText);
+                const space = usable - visLen(statusText) - visLen(ctxText);
                 if (space >= 2) {
-                    const row = this.statusText + ' '.repeat(space) + ctxText;
+                    const row = statusText + ' '.repeat(space) + ctxText;
                     statusOut = row + NL;
                     top = visRows(row, cols);
                 }
                 else {
-                    statusOut = this.statusText + NL;
-                    top = visRows(this.statusText, cols);
+                    statusOut = statusText + NL;
+                    top = visRows(statusText, cols);
                     const ctxRow = ' '.repeat(Math.max(0, usable - visLen(ctxText))) + ctxText;
                     statusOut += ctxRow + NL;
                     top += visRows(ctxRow, cols);
                 }
             }
             else {
-                statusOut = this.statusText + NL;
+                statusOut = statusText + NL;
                 // The status may wrap onto several lines — we account for this,
                 // otherwise the block erase misses and statuses pile up.
-                top = visRows(this.statusText, cols);
+                top = visRows(statusText, cols);
             }
         }
         else if (ctxText) {
@@ -885,6 +931,28 @@ export class LineEditor {
             return '';
         return theme.dim('  ·  ' + translate(this.locale)('spinner.hint'));
     }
+    // The lifecycle phase prefix for the status line, colored by meaning:
+    // generating (brown). There is NO prefix for 'settled' (the answer block
+    // already marks completion) and none for 'paused' (the base status itself
+    // reads "пауза Ns"). Returns '' when no phase is active, so an idle status
+    // is not prefixed.
+    _stateLabel() {
+        if (this._sendState === 'generating')
+            return (theme.brown(translate(this.locale)('state.generating')) + theme.dim(':'));
+        return '';
+    }
+    // Called by the browser layer at real lifecycle points: right before a
+    // send (generating), during a throttle/Continue pause (paused), and after
+    // the answer settled (settled). Any other value clears the phase.
+    setSendState(state) {
+        const next = state === 'generating' || state === 'paused' || state === 'settled'
+            ? state
+            : '';
+        if (next === this._sendState)
+            return;
+        this._sendState = next;
+        this._render();
+    }
     _startThinking() {
         if (this.pendingText) {
             this.setStatus(theme.prompt('✎ ') + this.pendingText + this._hint());
@@ -945,6 +1013,9 @@ export class LineEditor {
     }
     stop() {
         this._stopDots();
+        // A finished send must not keep prefixing the NEXT status (e.g. a tool
+        // that starts right after the answer) with a stale "settled"/"generating".
+        this._sendState = '';
         this.setStatus('');
     }
     toolCall(name, args) {
@@ -968,30 +1039,16 @@ export class LineEditor {
     assistant(msg) {
         this.stop();
         const rendered = renderMarkdown(msg);
-        // Show the used context size at the END of the answer too. During
-        // generation it lives in the status line, but ui.stop() clears that right
-        // before this call, so the operator lost the number exactly when the
-        // answer arrived. Read it fresh via onContextQuery and append it dimmed
-        // under the answer divider.
-        let ctxLine = '';
-        if (this.onContextQuery) {
-            try {
-                const n = this.onContextQuery();
-                const txt = formatTokenStatus(n, this.contextLimit);
-                if (txt)
-                    ctxLine = NL + theme.dim(txt);
-            }
-            catch {
-                // never break the render
-            }
-        }
+        // The used context is NOT repeated under the answer: `_writeBlock` keeps
+        // showing it right-aligned in the status line even after `stop()` clears
+        // the spinner text (the `else if (ctxText)` branch), so printing it here
+        // again was a duplicate of the same `accumulated_token_usage` number.
         this.printAbove(NL +
             theme.assistant(translate(this.locale)('editor.answer')) +
             NL +
             rendered +
             NL +
-            theme.dim('─'.repeat(60)) +
-            ctxLine);
+            theme.dim('─'.repeat(60)));
     }
     // Warning to the operator (e.g. the agent stopped suspiciously).
     // Printed above the input line without overwriting it.

package/dist/scheduler.js

@@ -0,0 +1,185 @@
+// Pure scheduling logic for the /loop and /cron commands. Kept free of any
+// browser/terminal dependency so it can be unit-tested; index.ts owns the
+// 1-second ticker and the actual enqueue into the message queue.
+// Parse a human interval like "30s", "5m", "2h" or a bare number of seconds.
+// Returns the period in ms, or null when the text is not a valid interval.
+export function parseInterval(text) {
+    const m = /^(\d+)\s*(s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hour|hours)?$/i.exec(String(text ?? '').trim());
+    if (!m)
+        return null;
+    const n = Number(m[1]);
+    if (!Number.isFinite(n) || n <= 0)
+        return null;
+    const unit = (m[2] || 's').toLowerCase();
+    const mult = unit.startsWith('h')
+        ? 3_600_000
+        : unit.startsWith('m')
+            ? 60_000
+            : 1000;
+    return n * mult;
+}
+// Render an interval back to the shortest human form (used in listings).
+export function formatInterval(ms) {
+    if (ms % 3_600_000 === 0)
+        return ms / 3_600_000 + 'h';
+    if (ms % 60_000 === 0)
+        return ms / 60_000 + 'm';
+    if (ms % 1000 === 0)
+        return ms / 1000 + 's';
+    return ms + 'ms';
+}
+// Parse one cron field ("*", "a-b", "*/n", "a,b", "a-b/n") into a value set.
+function parseCronField(field, min, max) {
+    const out = new Set();
+    for (const part of field.split(',')) {
+        const [range, stepStr] = part.split('/');
+        const step = stepStr === undefined ? 1 : Number(stepStr);
+        if (!Number.isInteger(step) || step <= 0)
+            return null;
+        let lo;
+        let hi;
+        if (range === '*') {
+            lo = min;
+            hi = max;
+        }
+        else if (range.includes('-')) {
+            const [a, b] = range.split('-');
+            lo = Number(a);
+            hi = Number(b);
+        }
+        else {
+            lo = Number(range);
+            hi = lo;
+        }
+        if (!Number.isInteger(lo) || !Number.isInteger(hi))
+            return null;
+        if (lo < min || hi > max || lo > hi)
+            return null;
+        for (let v = lo; v <= hi; v += step)
+            out.add(v);
+    }
+    return out.size ? out : null;
+}
+// Parse a 5-field cron expression: minute hour day-of-month month day-of-week.
+// Day-of-week accepts 0-7 (both 0 and 7 mean Sunday). Returns null on a bad
+// expression so the command can report it instead of scheduling silently.
+export function parseCron(expr) {
+    const parts = String(expr ?? '')
+        .trim()
+        .split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const minute = parseCronField(parts[0], 0, 59);
+    const hour = parseCronField(parts[1], 0, 23);
+    const dom = parseCronField(parts[2], 1, 31);
+    const month = parseCronField(parts[3], 1, 12);
+    const dowRaw = parseCronField(parts[4], 0, 7);
+    if (!minute || !hour || !dom || !month || !dowRaw)
+        return null;
+    const dow = new Set();
+    for (const d of dowRaw)
+        dow.add(d === 7 ? 0 : d);
+    return { minute, hour, dom, month, dow };
+}
+// Does the given Date match the cron expression? dom and dow are ANDed (the
+// common, predictable behavior); to schedule "every day" use `*` for one.
+export function cronMatches(expr, date) {
+    const c = parseCron(expr);
+    if (!c)
+        return false;
+    return (c.minute.has(date.getMinutes()) &&
+        c.hour.has(date.getHours()) &&
+        c.dom.has(date.getDate()) &&
+        c.month.has(date.getMonth() + 1) &&
+        c.dow.has(date.getDay()));
+}
+// Next epoch ms at which the expression fires, strictly after `fromMs`. Scans
+// minute by minute (bounded to ~4 years); a one-time cost when a job is
+// created/rescheduled, and the field checks reject almost every minute fast.
+export function nextCronTime(expr, fromMs) {
+    const c = parseCron(expr);
+    if (!c)
+        return null;
+    const d = new Date(fromMs);
+    d.setSeconds(0, 0);
+    d.setMinutes(d.getMinutes() + 1);
+    const limit = fromMs + 4 * 366 * 24 * 60 * 60 * 1000;
+    while (d.getTime() <= limit) {
+        if (cronMatches(expr, d))
+            return d.getTime();
+        d.setMinutes(d.getMinutes() + 1);
+    }
+    return null;
+}
+// Holds the scheduled jobs. Pure: no timers here. index.ts drives it with a
+// 1-second tick and enqueues the tasks that `due()` returns.
+export class Scheduler {
+    jobs = [];
+    nextId = 1;
+    addLoop(intervalMs, task, now) {
+        const job = {
+            id: this.nextId++,
+            kind: 'loop',
+            task,
+            intervalMs,
+            nextAt: now + intervalMs,
+            createdAt: now,
+        };
+        this.jobs.push(job);
+        return job;
+    }
+    addCron(cron, task, now) {
+        const nextAt = nextCronTime(cron, now);
+        if (nextAt === null)
+            return null;
+        const job = {
+            id: this.nextId++,
+            kind: 'cron',
+            task,
+            cron,
+            nextAt,
+            createdAt: now,
+        };
+        this.jobs.push(job);
+        return job;
+    }
+    remove(id) {
+        const i = this.jobs.findIndex((j) => j.id === id);
+        if (i === -1)
+            return false;
+        this.jobs.splice(i, 1);
+        return true;
+    }
+    clear() {
+        const n = this.jobs.length;
+        this.jobs = [];
+        return n;
+    }
+    list() {
+        return this.jobs.slice();
+    }
+    count() {
+        return this.jobs.length;
+    }
+    // Jobs whose nextAt is due at `now`, rescheduled for their NEXT fire so a
+    // single tick never fires the same job twice. A loop that fell behind is
+    // advanced past `now` in one step (missed fires are coalesced, not queued
+    // many times).
+    due(now) {
+        const fired = [];
+        for (const job of this.jobs) {
+            if (job.nextAt > now)
+                continue;
+            fired.push({ ...job });
+            if (job.kind === 'loop' && job.intervalMs && job.intervalMs > 0) {
+                const missed = Math.floor((now - job.nextAt) / job.intervalMs);
+                job.nextAt = job.nextAt + (missed + 1) * job.intervalMs;
+            }
+            else if (job.cron) {
+                const nxt = nextCronTime(job.cron, now);
+                job.nextAt = nxt === null ? Number.POSITIVE_INFINITY : nxt;
+            }
+        }
+        return fired;
+    }
+}

package/dist/theme.js

@@ -23,6 +23,7 @@ export const theme = {
     toolResult: chalk.hex('#8a9bb5'), // gray-blue
     system: chalk.hex('#808896'), // neutral gray
     dim: chalk.hex('#5b616e'), // dark gray
+    taskSummary: chalk.hex('#8fa3c8'), // per-task summary — noticeable but calm, distinct from spinner brown and warn ochre
     warn: chalk.hex('#c9a86a'), // calm ochre
     error: chalk.hex('#c98a80'), // muted terracotta
     success: chalk.hex('#a9c08c'), // soft sage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.32.0",
+  "version": "2.35.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {