zames_pro 2.80.5 → 2.81.0

package/dist/send-telemetry.js

@@ -0,0 +1,99 @@
+// Send TELEMETRY — one JSONL line per agent send, per provider.
+//
+// WHY: the send interval is currently a hand-tuned constant (DeepSeek 15 s,
+// Qwen 4 s, GLM 0) and the real limits are only visible in the OUTCOME of a
+// send: a rate limit, a busy server, a truncated turn. Recording every send
+// with its pause and its outcome turns "what is the limit?" into data instead
+// of a guess, and feeds the adaptive throttle (src/send-throttle.ts).
+//
+// NOTHING about the prompt or the answer is recorded: only timing, the mode
+// flags, and the error code/headers a server returned. The file is rotated so
+// an unattended run cannot grow it without bound.
+//
+// The module is PURE apart from the append/rotate helpers, which take the
+// directory as an argument (unit-tested with a temp dir).
+import fs from 'fs';
+import path from 'path';
+/** One line of the telemetry file (PURE). */
+export function formatSendEvent(e) {
+    return JSON.stringify(e);
+}
+/**
+ * PURE: parse the raw JSONL text into events, skipping a broken line (a
+ * half-written last line is expected after a crash and must not poison the
+ * statistics).
+ */
+export function parseSendEvents(raw) {
+    const out = [];
+    for (const line of String(raw || '').split(String.fromCharCode(10))) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        try {
+            const obj = JSON.parse(t);
+            if (obj && typeof obj === 'object' && typeof obj.outcome === 'string') {
+                out.push(obj);
+            }
+        }
+        catch { }
+    }
+    return out;
+}
+/** PURE: aggregate the last events for the /limits view. */
+export function summarizeSends(events, now = Date.now()) {
+    const within = (ms) => events.filter((e) => {
+        const t = Date.parse(e.at);
+        return Number.isFinite(t) && now - t <= ms;
+    }).length;
+    const blocks = events
+        .filter((e) => e.outcome === 'rate_limit' && typeof e.blockMs === 'number')
+        .map((e) => e.blockMs);
+    const avgBlockMs = blocks.length
+        ? Math.round(blocks.reduce((a, b) => a + b, 0) / blocks.length)
+        : 0;
+    return {
+        last10m: within(10 * 60_000),
+        last30m: within(30 * 60_000),
+        last60m: within(60 * 60_000),
+        rateLimits: events.filter((e) => e.outcome === 'rate_limit').length,
+        avgBlockMs,
+    };
+}
+/** `~/.zames/logs/sends-<provider>.jsonl`. */
+export function sendLogPath(logsDir, provider) {
+    return path.join(logsDir, 'sends-' + provider + '.jsonl');
+}
+/** Keep at most `keep` sends-*.jsonl files (rotate the oldest away). */
+export function rotateSendLogs(logsDir, keep = 5) {
+    try {
+        const files = fs
+            .readdirSync(logsDir)
+            .filter((f) => /^sends-.*\.jsonl$/.test(f))
+            .map((f) => ({ f, t: fs.statSync(path.join(logsDir, f)).mtimeMs }))
+            .sort((a, b) => b.t - a.t);
+        for (const old of files.slice(keep)) {
+            try {
+                fs.unlinkSync(path.join(logsDir, old.f));
+            }
+            catch { }
+        }
+    }
+    catch { }
+}
+/** Append one event. Best-effort: a logging failure never breaks a send. */
+export function appendSendEvent(logsDir, e) {
+    try {
+        fs.mkdirSync(logsDir, { recursive: true });
+        fs.appendFileSync(sendLogPath(logsDir, e.provider), formatSendEvent(e) + String.fromCharCode(10), 'utf-8');
+    }
+    catch { }
+}
+/** Read the recent events for one provider (best-effort, [] on failure). */
+export function readSendEvents(logsDir, provider) {
+    try {
+        return parseSendEvents(fs.readFileSync(sendLogPath(logsDir, provider), 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/send-throttle.js

@@ -0,0 +1,108 @@
+// Adaptive SEND THROTTLE — how long to wait before the next agent send.
+//
+// WHY: a fixed interval is wrong in both directions. Too small and the site
+// answers with a rate limit whose PENALTY grows with the overrun (DeepSeek: a
+// zero-gap burst ran ~30 min, then a ~30 min block). Too large and every turn
+// pays a pause that is usually unnecessary. The throttle learns from the
+// telemetry: it stays below a soft budget, backs off on a real limit and
+// recovers gradually after a run of successes.
+//
+// The module is PURE: it takes the current state and one event and returns the
+// next state + the wait. The browser owns the state, so switching providers or
+// finishing a task does not reset what was learned.
+export const DEFAULT_THROTTLE = {
+    windowMs: 10 * 60_000,
+    // Off until the operator has data: an infinite budget never fires.
+    budget: Number.POSITIVE_INFINITY,
+    recoverAfter: 3,
+    maxMs: 60_000,
+    limitFloorMs: 2000,
+};
+export function initialThrottleState(cfg) {
+    return {
+        intervalMs: Math.max(0, cfg.baseMs),
+        okStreak: 0,
+        blocked: false,
+        blockedAt: 0,
+        forcedWaitMs: 0,
+        recent: [],
+    };
+}
+/** Drop sends older than the window (keeps the state small). */
+function prune(recent, now, windowMs) {
+    return recent.filter((t) => now - t <= windowMs);
+}
+/**
+ * PURE: the wait before the next send, given the state and `now`. A blocked
+ * throttle waits out the forced pause; otherwise the learned interval applies
+ * since the last send.
+ */
+export function nextWaitMs(state, lastSentAt, now) {
+    if (state.forcedWaitMs > 0)
+        return state.forcedWaitMs;
+    if (!lastSentAt)
+        return 0;
+    const gap = state.intervalMs - (now - lastSentAt);
+    return gap > 0 ? gap : 0;
+}
+/**
+ * PURE: fold one telemetry event into the state.
+ *
+ * Rules (the operator's strategy):
+ *  - a soft budget: too many sends in the window GROW the interval smoothly,
+ *    ahead of a ban;
+ *  - a rate limit: wait the server's own Retry-After when present, else the
+ *    configured pause; after it lifts the interval doubles (from a floor);
+ *  - after `recoverAfter` successes in a row the interval halves, down to the
+ *    base.
+ */
+export function applySendEvent(state, event, cfg, now = Date.now()) {
+    const next = { ...state, recent: [...state.recent] };
+    const at = Date.parse(event.at);
+    const stamp = Number.isFinite(at) ? at : now;
+    if (event.outcome === 'ok') {
+        next.recent.push(stamp);
+        next.recent = prune(next.recent, now, cfg.windowMs);
+        next.okStreak = state.okStreak + 1;
+        if (next.okStreak >= cfg.recoverAfter) {
+            next.intervalMs = Math.max(cfg.baseMs, Math.floor(next.intervalMs / 2));
+            next.okStreak = 0;
+        }
+        next.blocked = false;
+        next.blockedAt = 0;
+        next.forcedWaitMs = 0;
+    }
+    else if (event.outcome === 'rate_limit') {
+        next.blocked = true;
+        next.blockedAt = state.blocked ? state.blockedAt || stamp : stamp;
+        next.okStreak = 0;
+        next.forcedWaitMs =
+            typeof event.retryAfterMs === 'number' && event.retryAfterMs > 0
+                ? event.retryAfterMs
+                : cfg.rateLimitWaitMs;
+        const floor = Math.max(cfg.baseMs, cfg.limitFloorMs);
+        next.intervalMs = Math.min(cfg.maxMs, Math.max(next.intervalMs, floor) * 2);
+    }
+    else {
+        // busy / incomplete / guest_limit: not a rate signal, keep the interval.
+        next.recent.push(stamp);
+        next.recent = prune(next.recent, now, cfg.windowMs);
+    }
+    // Soft budget: a smooth growth once the window is over budget.
+    if (Number.isFinite(cfg.budget) && next.recent.length > cfg.budget) {
+        const over = next.recent.length - cfg.budget;
+        next.intervalMs = Math.min(cfg.maxMs, Math.max(next.intervalMs, cfg.baseMs) + over * 1000);
+    }
+    return next;
+}
+/**
+ * PURE: a rate limit was observed and the block ended — record its duration on
+ * the event so the telemetry can average it.
+ */
+export function withBlockDuration(event, blockedAt, liftedAt) {
+    if (event.outcome !== 'rate_limit')
+        return event;
+    if (!blockedAt)
+        return event;
+    return { ...event, blockMs: Math.max(0, liftedAt - blockedAt) };
+}

package/dist/system-prompt.js

@@ -195,7 +195,7 @@ export function renderToolSection(tools) {
         .map((t2) => `### ${t2.name}\n${t2.description}\nParameters: ${JSON.stringify(t2.parameters)}`)
         .join('\n\n');
 }
-export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], context = null, selfImprovement = false, }) {
+export function buildSystemPrompt({ workdir, tools, gitContext = null, locale = 'ru', attachments = [], context = null, selfImprovement = false, provider, }) {
     const t = translate(locale);
     const toolDescriptions = renderToolSection(tools);
     // Emit the subagent guidance ONLY when the Task tool is actually in the set
@@ -208,6 +208,27 @@ export function buildSystemPrompt({ workdir, tools, gitContext = null, locale =
     const askUserSection = tools.some((x) => x.name === 'AskUser')
         ? ASKUSER_SECTION
         : '';
+    // GLM runs on chat.z.ai, whose OWN agent mode used to execute tool calls in
+    // a cloud sandbox instead of the operator's machine. The provider neutralises
+    // that mode (see glm-browser.ts), but the model must also be TOLD where it
+    // runs: otherwise it asks for a sandbox ("Limit Sandbox Concurrency") or
+    // claims it ran something it did not.
+    const runtimeSection = provider === 'glm'
+        ? '\n## You run on the OPERATOR\'S MACHINE (GLM)\n\n' +
+            'The tools above execute on the operator\'s computer, in the working ' +
+            'directory shown at the top. They are the ONLY way to touch files or ' +
+            'run commands.\n\n' +
+            '- There is NO cloud sandbox for you. Do NOT request or use a z.ai ' +
+            'sandbox/VM; a "Limit Sandbox Concurrency" page is a leftover of the ' +
+            "site's own agent mode and is NOT part of this task.\n" +
+            '- Never claim a command ran unless you emitted its tool call and ' +
+            'received a tool result. If you have not called the tool, say so.\n' +
+            '- Paths like `/home/z/...` or `/mnt/data` are NOT the operator\'s ' +
+            'machine.\n' +
+            '- Do NOT use web search / WebSearch unless the task explicitly asks ' +
+            'for current web information: it is slow, it burns the account quota ' +
+            'and it is not needed to read or edit files.\n'
+        : '';
     const gitSection = gitContext
         ? `\n## Git context\n\n${gitContext}\n`
         : '\n## Git context\n\nNot a git repository (or git is not installed).\n';
@@ -269,7 +290,7 @@ task is done (or when you must ask the operator), not between tool calls.
 You have access to the following tools:
 
 ${toolDescriptions}
-${gitSection}${attachSection}${contextSection}${selfSection}
+${runtimeSection}${gitSection}${attachSection}${contextSection}${selfSection}
 ## Choosing the right tool
 
 Prefer the most specific tool; a wrong choice wastes a turn:

package/dist/transcript.js

@@ -1,5 +1,36 @@
 import fs from 'fs';
 import path from 'path';
+// A transcript file is appended per RUN and never deleted, so ~/.zames/logs
+// grew without bound (177 files / 138 MB observed). On WSL the directory sits
+// inside ext4.vhdx: the space of deleted files is not returned to the Windows
+// host, so a big log dir is also a host-disk problem. Rotate on start-up: keep
+// the newest MAX_TRANSCRIPT_FILES and drop the rest.
+const MAX_TRANSCRIPT_FILES = 200;
+// The constructor is SYNCHRONOUS (it opens the stream right away), so the
+// rotation that must happen before the create has to be sync as well.
+export function rotateTranscripts(dir, keep = MAX_TRANSCRIPT_FILES) {
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((n) => n.endsWith('.jsonl'));
+    }
+    catch {
+        // A missing/unreadable dir must not break the run: the transcript is
+        // created right after and mkdirSync has its own error handling.
+        return 0;
+    }
+    if (names.length <= keep)
+        return 0;
+    names.sort();
+    let removed = 0;
+    for (const n of names.slice(0, names.length - keep)) {
+        try {
+            fs.rmSync(path.join(dir, n), { force: true });
+            removed++;
+        }
+        catch { }
+    }
+    return removed;
+}
 function transcriptErrorLine(e) {
     return `transcript: failed to create file: ${e.message}`;
 }
@@ -27,6 +58,9 @@ export class Transcript {
             const safeName = String(sessionName)
                 .replace(/[\\/:*?"<>|\u0000-\u001f]/g, '_')
                 .trim() || 'session';
+            // Rotation BEFORE the create: the new file then has the newest stamp,
+            // so the current run's transcript is never a deletion candidate.
+            rotateTranscripts(dir);
             this.file = path.join(dir, `${safeName}-${stamp}.jsonl`);
             this.stream = fs.createWriteStream(this.file, { flags: 'a' });
             // Write errors (disk full, file deleted, etc.) arrive as an 'error'

package/dist/tui/edit.js

@@ -74,9 +74,12 @@ export function del(s) {
 export function deleteWordLeft(s) {
     const chars = charsOf(s);
     let i = s.cursor;
-    while (i > 0 && /\s/.test(chars[i - 1]))
+    // A NEWLINE is a hard boundary: at the start of a line the key does
+    // nothing instead of eating the break and the previous line's word
+    // (deleteWordRight and wordLeft already stop at a newline).
+    while (i > 0 && chars[i - 1] !== NL && /\s/.test(chars[i - 1]))
         i--;
-    while (i > 0 && !/\s/.test(chars[i - 1]))
+    while (i > 0 && chars[i - 1] !== NL && !/\s/.test(chars[i - 1]))
         i--;
     chars.splice(i, s.cursor - i);
     return { ...s, buf: chars.join(''), cursor: i };
@@ -137,9 +140,11 @@ export function moveEnd(s) {
 export function wordLeft(s) {
     const chars = charsOf(s);
     let i = s.cursor;
-    while (i > 0 && /\s/.test(chars[i - 1]))
+    // Stop at a newline (mirrors deleteWordLeft/deleteWordRight): the cursor
+    // must not jump to the previous LINE, only to the previous word.
+    while (i > 0 && chars[i - 1] !== NL && /\s/.test(chars[i - 1]))
         i--;
-    while (i > 0 && !/\s/.test(chars[i - 1]))
+    while (i > 0 && chars[i - 1] !== NL && !/\s/.test(chars[i - 1]))
         i--;
     return i === s.cursor ? s : { ...s, cursor: i };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.80.5",
+  "version": "2.81.0",
   "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": {
@@ -41,7 +41,8 @@
     "render-how": "tsx scripts/render-how-it-works.mts",
     "build:readme": "tsx scripts/build-readme.mts",
     "postinstall": "node scripts/postinstall.mjs",
-    "prepare": "husky"
+    "prepare": "husky",
+    "glm-smoke": "tsx scripts/glm-smoke.mts"
   },
   "keywords": [
     "agent",