zames_pro 2.54.0 → 2.58.0

package/dist/self-review.js

@@ -61,6 +61,45 @@ async function copyDirJsFiles(from, to) {
     }
     return copied;
 }
+// Root files and folders a review often needs but that are NOT part of the
+// editable src/ set (scripts, lint/ts configs). They are copied into a
+// read-only `_context/` subfolder so the reviewer can READ them while the
+// .ts-only diff/apply logic stays untouched (a stray edit here would never be
+// applied back and would only confuse the report).
+const CONTEXT_FILES = [
+    'package.json',
+    'eslint.config.js',
+    '.prettierrc',
+    'tsconfig.json',
+    'tsconfig.build.json',
+];
+async function copyContextFiles(srcDir, snapDir) {
+    const repoRoot = path.resolve(srcDir, '..');
+    const ctxDir = path.join(snapDir, '_context');
+    for (const rel of CONTEXT_FILES) {
+        const data = await fs
+            .readFile(path.join(repoRoot, rel), 'utf-8')
+            .catch(() => null);
+        if (data === null)
+            continue;
+        await ensureDir(ctxDir);
+        await fs.writeFile(path.join(ctxDir, rel), data, 'utf-8');
+    }
+    const scripts = await fs
+        .readdir(path.join(repoRoot, 'scripts'))
+        .catch(() => []);
+    if (scripts.length) {
+        await ensureDir(path.join(ctxDir, 'scripts'));
+        for (const f of scripts) {
+            const data = await fs
+                .readFile(path.join(repoRoot, 'scripts', f), 'utf-8')
+                .catch(() => null);
+            if (data === null)
+                continue;
+            await fs.writeFile(path.join(ctxDir, 'scripts', f), data, 'utf-8');
+        }
+    }
+}
 // ---------- /self-review ----------
 export async function selfReview({ browser, focus, transcript, locale, }) {
     const t = translator(locale);
@@ -74,12 +113,9 @@ export async function selfReview({ browser, focus, transcript, locale, }) {
         console.error(theme.error('\n✖ ' + t('self.no_src', { dir: SRC_DIR })));
         throw new Error(t('self.no_src_err'));
     }
-    // Copy package.json for context — so the agent sees the dependencies
-    try {
-        const pkg = await fs.readFile(path.resolve(SRC_DIR, '..', 'package.json'), 'utf-8');
-        await fs.writeFile(path.join(snapDir, 'package.json'), pkg, 'utf-8');
-    }
-    catch { }
+    // Copy root configs/scripts into a read-only _context/ subfolder so the
+    // reviewer can read them (the editable set stays .ts-only).
+    await copyContextFiles(SRC_DIR, snapDir);
     console.log(theme.system('\n' + t('self.snapshot', { dir: snapDir })));
     console.log(theme.system(t('self.files', { n: copied.length, list: copied.join(', ') })));
     console.log(theme.system(t('self.starting') + '\n'));
@@ -248,6 +284,8 @@ function buildReviewPrompt({ focus, snapDir, }) {
     return `You are a senior JavaScript/Node.js engineer. You are reviewing your own source code — a Playwright-based coding agent that talks to the DeepSeek web chat as an LLM backend.
 
 All source files are in your working directory: ${snapDir}
+Root configs and scripts (package.json, tsconfig, eslint, scripts/) are copied
+into the read-only _context/ subfolder there — read them when relevant.
 ${focusLine}
 ## Your job
 

package/dist/sessions.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { writeJsonAtomic } from './fsutil.js';
 // We store sessions (DeepSeek chats) in a separate folder so they aren't lost
 // after a process restart. Each session is a separate JSON file
 // <id>.json in ~/.zames/.sessions. last.json points to the last
@@ -8,11 +9,6 @@ import os from 'os';
 const SESSIONS_DIR = path.join(os.homedir(), '.zames', '.sessions');
 const INDEX_FILE = path.join(SESSIONS_DIR, 'last.json');
 export const SESSIONS_FORMAT_VERSION = 1;
-function atomicWriteJson(file, value) {
-    const tmp = file + '.tmp-' + process.pid;
-    fs.writeFileSync(tmp, JSON.stringify(value, null, 2), 'utf-8');
-    fs.renameSync(tmp, file);
-}
 function ensureDir() {
     fs.mkdirSync(SESSIONS_DIR, { recursive: true });
 }
@@ -46,7 +42,7 @@ export function saveSession({ id, title = '', workdir = '', todos, }) {
         const nextTodos = todos !== undefined ? todos : prev.todos;
         if (nextTodos !== undefined)
             data.todos = nextTodos;
-        atomicWriteJson(file, data);
+        writeJsonAtomic(file, data);
         writeIndex({ id, workdir: data.workdir });
         return data;
     }
@@ -71,7 +67,7 @@ function writeIndex({ id, workdir }) {
         index.byWorkdir[key] = id;
         index.last = id;
         index.updatedAt = new Date().toISOString();
-        atomicWriteJson(INDEX_FILE, index);
+        writeJsonAtomic(INDEX_FILE, index);
     }
     catch { }
 }
@@ -154,7 +150,7 @@ export function saveHistory(history) {
     try {
         ensureDir();
         const trimmed = history.slice(-HISTORY_LIMIT);
-        atomicWriteJson(HISTORY_FILE, trimmed);
+        writeJsonAtomic(HISTORY_FILE, trimmed);
     }
     catch { }
 }

package/dist/shell.js

@@ -0,0 +1,72 @@
+import { exec } from 'child_process';
+import path from 'path';
+// Shared shell runner for the Bash tool and the operator's `!command` escape.
+// Kept in its own module so both call sites use the SAME sandbox guard and the
+// SAME abort wiring; a second, ad-hoc runner would drift from the real one.
+// Sandbox (option A): don't let a shell command go above the project root.
+// This is a protective barrier, not full OS isolation.
+export function assertCommandInsideRoot(root, command) {
+    const cmd = String(command || '');
+    const cdRe = /(?:^|[;&|]|\s)(?:cd|pushd)\s+([^;&|]+)/gi;
+    let m;
+    while ((m = cdRe.exec(cmd))) {
+        const raw = m[1].trim();
+        if (!raw || raw === '-')
+            continue;
+        const target = path.resolve(root, raw);
+        const rel = path.relative(root, target);
+        if (rel.startsWith('..') || path.isAbsolute(rel)) {
+            throw new Error('Sandbox: leaving ' + root + ' is forbidden (cd ' + raw + ')');
+        }
+    }
+}
+export function runShell(workdir, command, timeout = 30_000, signal) {
+    return new Promise((resolve) => {
+        const options = {
+            cwd: workdir,
+            timeout,
+            maxBuffer: 1024 * 1024 * 8,
+            windowsHide: true,
+            env: { ...process.env },
+            // Abort the child process when the operator pressed Esc/Ctrl+C.
+            // Without it a long `npm test` kept running even after the stop.
+            signal,
+        };
+        if (process.platform === 'win32') {
+            options.shell = process.env.ComSpec || 'C:\\Windows\\System32\\cmd.exe';
+        }
+        else {
+            options.shell = '/bin/sh';
+        }
+        exec(command, options, (err, stdout, stderr) => {
+            const out = (stdout || '').toString();
+            const errStr = (stderr || '').toString();
+            if (!err) {
+                const combined = (out + errStr).trim();
+                resolve(combined || '(command produced no output)');
+                return;
+            }
+            const parts = [];
+            if (err.killed) {
+                parts.push('\u23f1 Timeout after ' + timeout + 'ms \u2014 process killed.');
+            }
+            else if (err.code === 'ABORT_ERR') {
+                parts.push('(aborted by the operator)');
+            }
+            else if (err.code !== undefined && err.code !== null) {
+                parts.push('Exit code: ' + err.code);
+            }
+            else if (err.signal) {
+                parts.push('Killed by signal: ' + err.signal);
+            }
+            else {
+                parts.push('Error: ' + err.message);
+            }
+            if (out.trim())
+                parts.push('stdout:\n' + out.trim());
+            if (errStr.trim())
+                parts.push('stderr:\n' + errStr.trim());
+            resolve(parts.join('\n'));
+        });
+    });
+}

package/dist/spinner.js

@@ -27,6 +27,9 @@ export function renderDots(n) {
     return theme.brown(d + DOTS_PAD.slice(d.length));
 }
 export function createSpinner(locale = 'ru') {
+    // Set by the caller (index.ts) to the same todos summary the LineEditor
+    // shows, so the non-TTY path has parity.
+    let onTasksQuery = null;
     let spinner = null;
     let dotTimer = null;
     let dotPhase = 0;
@@ -37,6 +40,10 @@ export function createSpinner(locale = 'ru') {
     // zero every second and look frozen on a single dot.
     let animBase = '';
     let animating = false;
+    // When the current animated phase began, so a long reasoning turn can show
+    // "12s" / "2m 05s" instead of looking identical to a hung one. Parity with
+    // the LineEditor status line (src/input.ts).
+    let animStart = 0;
     const start = (text) => {
         if (!spinner)
             spinner = ora(text).start();
@@ -59,9 +66,34 @@ export function createSpinner(locale = 'ru') {
     // "running" dot sequence. Shared by the thinking spinner and the send-pause
     // indicator, so the pause is animated too (before, it was a static line and
     // the dots did not move — the operator saw a frozen spinner).
+    // Elapsed label of the current animated phase ("0s", "45s", "2m 05s").
+    // Empty when nothing is animating. Localized units come from the catalog.
+    const elapsedLabel = () => {
+        if (!animating || !animStart)
+            return '';
+        const sec = Math.floor((Date.now() - animStart) / 1000);
+        const m = Math.floor(sec / 60);
+        const s = sec % 60;
+        const text = m > 0 ? m + 'm ' + String(s).padStart(2, '0') + 's' : s + 's';
+        return theme.dim(' · ' + text);
+    };
+    // Task-list badge, refreshed from onTasksQuery on every animation tick.
+    // Mirrors the LineEditor so the non-TTY spinner shows the same "tasks: 2/5".
+    const tasksBadge = () => {
+        if (!onTasksQuery)
+            return '';
+        try {
+            const s = onTasksQuery();
+            return s ? theme.system(s) + ' ' : '';
+        }
+        catch {
+            return '';
+        }
+    };
     const startAnimated = (baseText) => {
         animBase = theme.brown(stripEllipsis(baseText));
-        start(animBase + renderDots(0) + HINT);
+        animStart = Date.now();
+        start(animBase + renderDots(0) + elapsedLabel() + tasksBadge() + HINT);
         dotPhase = 0;
         if (dotTimer)
             clearInterval(dotTimer);
@@ -69,7 +101,8 @@ export function createSpinner(locale = 'ru') {
             if (!spinner)
                 return;
             dotPhase = (dotPhase + 1) % DOTS.length;
-            spinner.text = animBase + renderDots(dotPhase) + HINT;
+            spinner.text =
+                animBase + renderDots(dotPhase) + elapsedLabel() + tasksBadge() + HINT;
         }, 400);
         animating = true;
         if (dotTimer.unref)
@@ -93,6 +126,12 @@ export function createSpinner(locale = 'ru') {
         spinner.text = theme.prompt('✎ ') + pending + HINT;
     };
     return {
+        get onTasksQuery() {
+            return onTasksQuery;
+        },
+        set onTasksQuery(fn) {
+            onTasksQuery = fn;
+        },
         thinking: () => {
             if (pending) {
                 showPending();
@@ -112,7 +151,7 @@ export function createSpinner(locale = 'ru') {
             // so the countdown refreshes without resetting the dots.
             if (animating && dotTimer && spinner) {
                 animBase = theme.brown(stripEllipsis(label));
-                spinner.text = animBase + renderDots(dotPhase) + HINT;
+                spinner.text = animBase + renderDots(dotPhase) + elapsedLabel() + HINT;
                 return;
             }
             startAnimated(label);

package/dist/system-prompt.js

@@ -128,6 +128,19 @@ You have access to the following tools:
 
 ${toolDescriptions}
 ${gitSection}${attachSection}${contextSection}
+## Choosing the right tool
+
+Prefer the most specific tool; a wrong choice wastes a turn:
+
+- Several small edits in ONE file -> MultiEdit (applied atomically), not
+  several Edit calls.
+- Changes across SEVERAL files -> ApplyPatch (V4A), not a series of writes.
+- One exact replacement -> Edit. Creating or overwriting a whole file -> Write.
+- Searching file CONTENT -> Grep; finding files by NAME -> Glob; listing a
+  directory -> LS.
+- Git operations -> the Git* tools, not Bash.
+- Reading a file whose path you already know -> Read, not Bash cat.
+
 ## MCP tools
 
 Some tools are provided by external MCP servers and their names look

package/dist/tools.js

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { exec } from 'child_process';
+import { assertCommandInsideRoot, runShell } from './shell.js';
 import { createGitTools } from './gitTools.js';
 import { createWebTools } from './web.js';
 import { createExtraTools } from './extraTools.js';
@@ -8,7 +8,7 @@ import { createExtraTools } from './extraTools.js';
 // user-facing. They must be in ENGLISH (like Claude Code / Codex). Only the
 // strings the OPERATOR sees (help, spinner, service messages) are localized —
 // those live in src/i18n.ts (CATALOG) and are picked by the locale setting.
-export function createTools(workdir, { undo, todos } = {}) {
+export function createTools(workdir, { undo, todos, readOnly = false, } = {}) {
     const root = path.resolve(workdir);
     const safe = (p) => {
         const resolved = path.resolve(root, p);
@@ -20,71 +20,6 @@ export function createTools(workdir, { undo, todos } = {}) {
         }
         return resolved;
     };
-    // Sandbox (option A): don't let the command go above root.
-    // This is a protective barrier, not full OS isolation.
-    const assertCommandInsideRoot = (command) => {
-        const cmd = String(command || '');
-        const cdRe = /(?:^|[;&|]|\s)(?:cd|pushd)\s+([^;&|]+)/gi;
-        let m;
-        while ((m = cdRe.exec(cmd))) {
-            const raw = m[1].trim();
-            if (!raw || raw === '-')
-                continue;
-            const target = path.resolve(root, raw);
-            const rel = path.relative(root, target);
-            if (rel.startsWith('..') || path.isAbsolute(rel)) {
-                throw new Error('Sandbox: leaving ' + root + ' is forbidden (cd ' + raw + ')');
-            }
-        }
-    };
-    const runShell = (command, timeout = 30_000, signal) => new Promise((resolve) => {
-        const options = {
-            cwd: workdir,
-            timeout,
-            maxBuffer: 1024 * 1024 * 8,
-            windowsHide: true,
-            env: { ...process.env },
-            // Abort the child process when the operator pressed Esc/Ctrl+C.
-            // Without it a long `npm test` kept running even after the stop.
-            signal,
-        };
-        if (process.platform === 'win32') {
-            options.shell = process.env.ComSpec || 'C:\\Windows\\System32\\cmd.exe';
-        }
-        else {
-            options.shell = '/bin/sh';
-        }
-        exec(command, options, (err, stdout, stderr) => {
-            const out = (stdout || '').toString();
-            const errStr = (stderr || '').toString();
-            if (!err) {
-                const combined = (out + errStr).trim();
-                resolve(combined || '(command produced no output)');
-                return;
-            }
-            const parts = [];
-            if (err.killed) {
-                parts.push(`⏱ Timeout after ${timeout}ms — process killed.`);
-            }
-            else if (err.code === 'ABORT_ERR') {
-                parts.push('(aborted by the operator)');
-            }
-            else if (err.code !== undefined && err.code !== null) {
-                parts.push(`Exit code: ${err.code}`);
-            }
-            else if (err.signal) {
-                parts.push(`Killed by signal: ${err.signal}`);
-            }
-            else {
-                parts.push(`Error: ${err.message}`);
-            }
-            if (out.trim())
-                parts.push(`stdout:\n${out.trim()}`);
-            if (errStr.trim())
-                parts.push(`stderr:\n${errStr.trim()}`);
-            resolve(parts.join('\n'));
-        });
-    });
     // Extracts text from content/content_base64. base64 is needed because the
     // channel that delivers the model's answer may corrupt characters ($,
     // backslashes, newlines). base64 consists only of [A-Za-z0-9+/=] and is not
@@ -202,8 +137,8 @@ export function createTools(workdir, { undo, todos } = {}) {
                 'For git use the Git* tools. For the web use WebFetch / WebSearch.',
             parameters: { command: 'string', timeout: 'number?' },
             fn: async ({ command, timeout }, ctx) => {
-                assertCommandInsideRoot(req(command, 'command'));
-                return runShell(req(command, 'command'), timeout, ctx?.signal);
+                assertCommandInsideRoot(root, req(command, 'command'));
+                return runShell(workdir, req(command, 'command'), timeout, ctx?.signal);
             },
         },
         {
@@ -229,7 +164,8 @@ export function createTools(workdir, { undo, todos } = {}) {
         {
             name: 'Grep',
             description: 'Search file contents (regular expression). include — file name ' +
-                'filter (e.g. "*.ts"). output: content (default, matching lines with ' +
+                'filter, a single glob or a comma-separated list (e.g. "*.ts" or ' +
+                '"*.ts,*.tsx"). output: content (default, matching lines with ' +
                 'numbers), files_only (paths only), count (match count per file).',
             parameters: {
                 pattern: 'string',
@@ -240,16 +176,22 @@ export function createTools(workdir, { undo, todos } = {}) {
             fn: async ({ pattern, path: searchPath, include, output }) => {
                 const pat = req(pattern, 'pattern');
                 const target = searchPath ? safe(String(searchPath)) : workdir;
-                const inc = include ? String(include).trim() : '';
+                // include may be a single glob or a comma-separated list.
+                const incs = (include ? String(include) : '')
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
                 const mode = String(output || 'content').toLowerCase();
                 if (process.platform === 'win32') {
                     const escaped = pat.replace(/"/g, '\\"');
                     const scope = searchPath ? '"' + target + '\\*' : '*';
-                    return runShell(`findstr /s /n /r /c:"${escaped}" ` + scope);
+                    return runShell(workdir, `findstr /s /n /r /c:"${escaped}" ` + scope);
                 }
                 const flags = mode === 'files_only' ? '-rlE' : mode === 'count' ? '-rcE' : '-rnE';
-                const includeArg = inc ? ' --include=' + JSON.stringify(inc) : '';
-                return runShell(`grep ${flags}${includeArg} ${JSON.stringify(pat)} ` +
+                const includeArg = incs
+                    .map((g) => ' --include=' + JSON.stringify(g))
+                    .join('');
+                return runShell(workdir, `grep ${flags}${includeArg} ${JSON.stringify(pat)} ` +
                     `${JSON.stringify(target)} || true`);
             },
         },
@@ -263,5 +205,31 @@ export function createTools(workdir, { undo, todos } = {}) {
         parameters: { message: 'string' },
         fn: async ({ message }) => message,
     };
-    return [...baseTools, ...extraTools, ...gitTools, ...webTools, respondTool];
+    const all = [
+        ...baseTools,
+        ...extraTools,
+        ...gitTools,
+        ...webTools,
+        respondTool,
+    ];
+    return readOnly ? filterToolsForReadOnly(all) : all;
+}
+// Tools that mutate the working tree or run arbitrary commands. In "plan"
+// (read-only) mode they are REMOVED from the tool set entirely, so the model
+// cannot write by accident while it is still investigating. Removing (rather
+// than rejecting at call time) is the honest signal: the agent never sees a
+// tool it is not allowed to use, so it does not waste a turn trying.
+export const MUTATING_TOOLS = new Set([
+    'Write',
+    'Edit',
+    'MultiEdit',
+    'ApplyPatch',
+    'Bash',
+    'GitAdd',
+    'GitCommit',
+    'GitPush',
+]);
+/** Drop mutating tools for read-only / plan mode. Pure; unit-tested. */
+export function filterToolsForReadOnly(tools) {
+    return tools.filter((t) => !MUTATING_TOOLS.has(t.name));
 }

package/dist/transcript.js

@@ -5,11 +5,13 @@ export class Transcript {
     file;
     stream;
     startedAt;
-    constructor({ dir, enabled = true, sessionName = 'session', }) {
+    onLine;
+    constructor({ dir, enabled = true, sessionName = 'session', onLine = null, }) {
         this.enabled = enabled;
         this.file = null;
         this.stream = null;
         this.startedAt = Date.now();
+        this.onLine = onLine;
         if (!enabled)
             return;
         try {
@@ -30,16 +32,24 @@ export class Transcript {
         }
     }
     log(type, data = {}) {
-        if (!this.enabled || !this.stream)
-            return;
         const entry = {
             ts: new Date().toISOString(),
             elapsed: Date.now() - this.startedAt,
             type,
             ...data,
         };
+        const line = JSON.stringify(entry) + String.fromCharCode(10);
+        // The mirror runs even when the file is disabled (jsonl mode).
+        if (this.onLine) {
+            try {
+                this.onLine(line);
+            }
+            catch { }
+        }
+        if (!this.enabled || !this.stream)
+            return;
         try {
-            this.stream.write(JSON.stringify(entry) + String.fromCharCode(10));
+            this.stream.write(line);
         }
         catch { }
     }

package/dist/undo.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import { writeJsonAtomic } from './fsutil.js';
 const UNDO_DIR = path.join(os.homedir(), '.zames', 'undo');
 const INDEX = path.join(UNDO_DIR, 'index.json');
 export class UndoStore {
@@ -23,9 +24,7 @@ export class UndoStore {
     }
     async _writeIndex(history) {
         // Atomic write: a crash mid-write must not corrupt the undo history.
-        const tmp = `${INDEX}.tmp-${process.pid}`;
-        await fs.writeFile(tmp, JSON.stringify(history, null, 2));
-        await fs.rename(tmp, INDEX);
+        writeJsonAtomic(INDEX, history);
     }
     async backup(filePath) {
         if (!this.enabled)
@@ -63,15 +62,18 @@ export class UndoStore {
         return { originalPath: filePath, existed, stamp };
     }
     async undoLast() {
+        // Machine codes, NOT prose: the caller (index.ts) localizes them through
+        // the i18n catalog. Hardcoding a Russian reason here leaked Russian into
+        // an English UI (`/undo` with an empty history).
         if (!this.enabled)
-            return { ok: false, reason: 'undo отключён в конфиге' };
+            return { ok: false, reason: 'disabled' };
         await this._ensure();
         const history = await this._readIndex();
         if (!history.length)
-            return { ok: false, reason: 'история пуста' };
+            return { ok: false, reason: 'empty' };
         const record = history.pop();
         if (!record)
-            return { ok: false, reason: 'история пуста' };
+            return { ok: false, reason: 'empty' };
         const { originalPath, existed, backupFile } = record;
         try {
             if (existed && backupFile) {

package/dist/web.js

@@ -118,6 +118,30 @@ async function assertPublicUrl(rawUrl) {
     }
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// True for content types whose bodies are not meant to be shown as text.
+// WebFetch dumps the body into the context, so a PDF or an image would flood
+// the model with garbage; the caller returns a short human note instead.
+export function isBinaryContentType(contentType) {
+    const ct = String(contentType || '')
+        .toLowerCase()
+        .split(';')[0]
+        .trim();
+    if (!ct)
+        return false;
+    if (ct.startsWith('text/'))
+        return false;
+    // Textual application/* types must stay readable.
+    if (/^(application\/(json|xml|xhtml\+xml|javascript|ecmascript|x-httpd-php|rtf|sql|graphql|x-sh|x-yaml|yaml|toml|ld\+json|x-ndjson))$/.test(ct)) {
+        return false;
+    }
+    if (/\+(json|xml)$/.test(ct))
+        return false;
+    if (/^(image|audio|video|font|model)\//.test(ct) ||
+        /^application\/(pdf|zip|gzip|x-gzip|x-tar|octet-stream|msword|vnd\.|x-7z|x-rar|x-bzip|x-protobuf|wasm)/.test(ct)) {
+        return true;
+    }
+    return false;
+}
 // fetch with retries for transient network errors and 5xx responses.
 async function httpFetchWithRetry(url, opts = {}, retries = 2) {
     let lastErr;
@@ -231,6 +255,13 @@ export function createWebTools() {
                         return formatResult(r.status, r.url, text, limit);
                     }
                     const r = await httpFetchWithRetry(String(url));
+                    // Binary content (PDF, images, archives, ...) must NOT be dumped
+                    // into the context as raw bytes — tell the model what it is instead.
+                    if (isBinaryContentType(r.contentType)) {
+                        return (`HTTP ${r.status}  ${r.url}\n` +
+                            `Content-Type: ${r.contentType}\n\n` +
+                            `(binary content is not returned as text; content-type: ${r.contentType})`);
+                    }
                     // If it's JSON/plain text — return as is
                     if (/application\/json|text\/plain|text\/markdown/i.test(r.contentType)) {
                         const trimmed = r.body.slice(0, limit);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zames_pro",
-  "version": "2.54.0",
-  "description": "Terminal coding agent over chat.deepseek.com via Playwright",
+  "version": "2.58.0",
+  "description": "Terminal coding agent that drives chat.deepseek.com through Playwright: reads and edits files, runs commands, commits to git.",
   "type": "module",
   "bin": {
     "zames": "dist/index.js"
@@ -10,13 +10,16 @@
     "dist",
     "scripts",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "logo.jpg"
   ],
   "scripts": {
     "start": "node ./dist/index.js",
     "dev": "ZAMES_NET_DEBUG=1 tsx ./src/index.ts --dev --headed",
-    "build": "tsc -p tsconfig.build.json",
+    "clean": "node scripts/clean-dist.mjs",
+    "build": "node scripts/clean-dist.mjs && tsc -p tsconfig.build.json",
+    "coverage:gate": "node scripts/coverage-gate.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "node scripts/eslint-ts6.mjs",
     "lint:fix": "node scripts/eslint-ts6.mjs --fix",
@@ -34,12 +37,19 @@
     "ai",
     "deepseek",
     "cli",
-    "coding-agent"
+    "coding-agent",
+    "claude-code",
+    "codex",
+    "terminal",
+    "playwright",
+    "llm",
+    "automation"
   ],
   "license": "MIT",
   "engines": {
     "node": ">=20"
   },
+  "packageManager": "npm@11.19.0",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.1",
     "chalk": "^5.3.0",

package/scripts/clean-dist.mjs

@@ -0,0 +1,17 @@
+import { rmSync, existsSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// tsc emits into dist/ without clearing it, so a source file DELETED from
+// src/ leaves an orphan .js in the published tree (this really happened:
+// dist/confirm.js survived after src/confirm.ts was removed). Wipe dist/ first
+// so the build output mirrors src/ exactly.
+//
+// Cross-platform: use node's fs.rm instead of a shell `rm -rf` (Windows has no
+// rm) and never touch anything outside this repo.
+const here = path.dirname(fileURLToPath(import.meta.url))
+const dist = path.resolve(here, '..', 'dist')
+if (existsSync(dist)) {
+  rmSync(dist, { recursive: true, force: true })
+  console.log('clean-dist: removed', dist)
+}