zames_pro 2.32.0 → 2.35.0

package/dist/agent-loop.js

@@ -4,7 +4,7 @@ import { getGitContext, formatGitContext } from './gitTools.js';
 import { parseXmlToolCalls } from './xml-toolcall.js';
 import { translate } from './i18n.js';
 import { normText } from './browser.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 0, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onSendPause = () => { }, onSendState = () => { }, onNotice = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', askDeadlineMs = 240_000, maxAfterToolRetries = 6, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, }) {
     // UI callbacks must NEVER break the agent loop. A rendering error (a huge
     // tool result, a broken markdown frame, a closed terminal) used to throw
     // out of the loop right after a tool call — the session looked "stopped
@@ -30,6 +30,9 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // seconds, the UI shows an animated status instead of a frozen line.
     const safeSendPause = safe(onSendPause);
     browser.onSendPause = safeSendPause;
+    // Coarse lifecycle of the send (generating/paused/settled) for the status
+    // line. Same best-effort wiring as the other hooks.
+    browser.onSendState = safe(onSendState);
     // Service notices (rate limit, server busy, resend) must reach the OPERATOR.
     // While a LineEditor is active a raw console.error is overwritten by the
     // editor's repaint, so the operator only saw the spinner. `onNotice` prints

package/dist/browser.js

@@ -400,6 +400,12 @@ export class DeepSeekBrowser {
     // remaining seconds. Lets the UI animate the pause status instead of
     // printing a static line (the dots used to be frozen during the pause).
     onSendPause;
+    // Coarse lifecycle of one send: 'generating' right before the message is
+    // typed, 'paused' while waiting out a throttle/Continue gap, 'settled'
+    // once the answer stopped changing. Lets the UI show an explicit phase
+    // instead of only an on/off spinner (a long reasoning turn and a rate-limit
+    // wait looked identical). Firing this hook does not alter any send timing.
+    onSendState;
     // A service notice for the OPERATOR (rate limit, server busy, resend, …).
     // IMPORTANT: these must NOT go through `console.error` directly — while a
     // LineEditor is active it repaints its own status line and the raw stderr
@@ -458,6 +464,7 @@ export class DeepSeekBrowser {
         this._netHookInstalled = false;
         this.onSendStart = null;
         this.onSendPause = null;
+        this.onSendState = null;
         this.onNotice = null;
         // An explicit UA (config/options) is respected as-is. Otherwise it stays
         // empty here and is derived from the real engine UA after launch — see
@@ -482,6 +489,16 @@ export class DeepSeekBrowser {
         }
         console.error(text);
     }
+    // Report the coarse lifecycle of one send to the UI hook (if wired).
+    // Best-effort: a broken UI callback must never break the send loop.
+    _emitSendState(state) {
+        if (this.onSendState) {
+            try {
+                this.onSendState(state);
+            }
+            catch { }
+        }
+    }
     async launch() {
         // NOTE: we deliberately do NOT kill stray chrome processes here. Per the
         // project rules, an agent must never kill a browser it did not start —
@@ -1606,7 +1623,18 @@ export class DeepSeekBrowser {
             // at the start burns the whole askRetries budget and ask() gives up early.
             while (attempt < this.askRetries) {
                 try {
-                    return await this._askOnce(prompt, { timeout, agent, attachments });
+                    const answer = await this._askOnce(prompt, {
+                        timeout,
+                        agent,
+                        attachments,
+                    });
+                    // The answer has settled (the finish loop returned it): mark the
+                    // lifecycle state so the status line shows "settled" instead of
+                    // still looking like generation.
+                    if (answer !== '(прервано пользователем)') {
+                        this._emitSendState('settled');
+                    }
+                    return answer;
                 }
                 catch (e) {
                     lastErr = e;
@@ -1892,6 +1920,7 @@ export class DeepSeekBrowser {
                 catch { }
             }
         };
+        this._emitSendState('paused');
         tick(totalSec * 1000);
         return await this._sleepInterruptible(totalSec * 1000, tick);
     }
@@ -1937,6 +1966,7 @@ export class DeepSeekBrowser {
             }
         };
         report(gap);
+        this._emitSendState('paused');
         await this._sleepInterruptible(gap, report);
     }
     // Sleep in small slices so Esc/Ctrl+C can cancel the wait promptly.
@@ -2022,6 +2052,7 @@ export class DeepSeekBrowser {
             }
             catch { }
         }
+        this._emitSendState('generating');
         this._netCapture = '';
         this._netCaptureAt = 0;
         this._netNoAnswer = false;

package/dist/commands.js

@@ -35,12 +35,15 @@ export function summarizeTranscript(entries) {
         toolCounts: {},
         durationMs: 0,
         startedAt: null,
+        autoCompacts: 0,
     };
     for (const e of entries) {
         if (!e || typeof e !== 'object')
             continue;
         if (e.type === 'user_task')
             stats.turns++;
+        if (e.type === 'auto_compact_done')
+            stats.autoCompacts++;
         if (e.type === 'tool_call') {
             stats.toolCalls++;
             const tool = String(e.tool ?? '?');
@@ -71,17 +74,20 @@ export function parseTranscript(body) {
     }
     return out;
 }
-export function formatDuration(ms) {
+export const EN_DURATION_UNITS = { h: 'h', m: 'm', s: 's' };
+// Human-readable duration: "8s", "5m 12s", "1h 01m 01s". Seconds are padded
+// only when a larger unit is present, so a lone "45s" is not "45s" padded.
+export function formatDuration(ms, units = EN_DURATION_UNITS) {
     const total = Math.max(0, Math.round(ms / 1000));
     const h = Math.floor(total / 3600);
     const m = Math.floor((total % 3600) / 60);
     const s = total % 60;
     const pad = (n) => String(n).padStart(2, '0');
     if (h > 0)
-        return h + 'h ' + pad(m) + 'm ' + pad(s) + 's';
+        return h + units.h + ' ' + pad(m) + units.m + ' ' + pad(s) + units.s;
     if (m > 0)
-        return m + 'm ' + pad(s) + 's';
-    return s + 's';
+        return m + units.m + ' ' + pad(s) + units.s;
+    return s + units.s;
 }
 export function renderCost(stats, transcriptFile, tokenUsage = null) {
     const lines = [];
@@ -94,6 +100,9 @@ export function renderCost(stats, transcriptFile, tokenUsage = null) {
     }
     lines.push(' tasks: ' + stats.turns);
     lines.push(' tool calls: ' + stats.toolCalls);
+    if (stats.autoCompacts > 0) {
+        lines.push(' auto-compacts: ' + stats.autoCompacts);
+    }
     const top = Object.entries(stats.toolCounts).sort((a, b) => b[1] - a[1]);
     if (top.length) {
         lines.push(' by tool:');
@@ -116,6 +125,15 @@ export function formatExport(entries, meta = {}) {
     if (meta.chatId)
         out.push('- chat: ' + meta.chatId);
     out.push('- exported: ' + new Date().toISOString());
+    // A self-contained summary, so the exported Markdown stands on its own as a
+    // report without opening the transcript or a /cost run.
+    const stats = summarizeTranscript(entries);
+    out.push('- tasks: ' + stats.turns);
+    out.push('- tool calls: ' + stats.toolCalls);
+    out.push('- duration: ' + formatDuration(stats.durationMs));
+    if (stats.autoCompacts > 0) {
+        out.push('- auto-compacts: ' + stats.autoCompacts);
+    }
     out.push('');
     for (const e of entries) {
         const type = String(e.type ?? '?');
@@ -178,6 +196,9 @@ export function renderDoctor(d) {
     if (typeof d.minSendIntervalMs === 'number') {
         row(d.minSendIntervalMs > 0, 'send pause', Math.round(d.minSendIntervalMs / 1000) + 's between agent sends');
     }
+    if (typeof d.sshRemote === 'boolean') {
+        row(true, 'session', d.sshRemote ? 'SSH remote' : 'local terminal');
+    }
     return 'Doctor:' + NL + rows.join(NL);
 }
 export function renderPermissions(p) {
@@ -430,6 +451,95 @@ export function isSlashCommand(text) {
         .trim()
         .startsWith('/');
 }
+export function parseLiveToggle(text) {
+    const m = /^\/(thinking|web|websearch|search)(?:\s+(\S+))?\s*$/i.exec(String(text ?? '').trim());
+    if (!m)
+        return null;
+    const name = m[1].toLowerCase();
+    const kind = name === 'thinking' ? 'thinking' : 'search';
+    const arg = (m[2] || '').toLowerCase();
+    let mode = 'toggle';
+    if (arg === 'on' || arg === '1' || arg === 'true' || arg === 'вкл')
+        mode = 'on';
+    else if (arg === 'off' || arg === '0' || arg === 'false' || arg === 'выкл')
+        mode = 'off';
+    else if (arg !== '')
+        return null;
+    return { kind, mode };
+}
+// Prepend a long-lived session goal to a task message, so the model keeps the
+// big picture even when the goal was set many turns ago. The task is appended
+// AFTER the goal; when there is no goal the task is returned unchanged. The
+// text is agent-facing (English), like the system prompt.
+export function withGoal(goal, task) {
+    const g = String(goal ?? '').trim();
+    if (!g)
+        return task;
+    const NL = String.fromCharCode(10);
+    return ('Session goal (long-lived — keep it in mind for this and every following task):' +
+        NL +
+        g +
+        NL +
+        NL +
+        'Current task:' +
+        NL +
+        task);
+}
+// Parse a `/goal` invocation. Subcommands: 'set' (with text), 'show', 'clear'.
+// Returns null when the text is not a /goal command. Kept pure so the main loop
+// and any future interception share one parser.
+export function parseGoalCommand(text) {
+    const t = String(text ?? '').trim();
+    const m = /^\/goal(?:\s+([\s\S]*))?$/.exec(t);
+    if (!m)
+        return null;
+    const rest = (m[1] ?? '').trim();
+    if (rest === '')
+        return { sub: 'show' };
+    if (rest.toLowerCase() === 'clear' || rest.toLowerCase() === 'off')
+        return { sub: 'clear' };
+    return { sub: 'set', goal: rest };
+}
+// True when a `/config ...` line can be handled LIVE (while the agent is busy):
+// the text subcommands only touch config values, never the chat. The bare
+// `/config` and `/config menu` (which pause the editor and read keys) are NOT
+// live — they must go through the main loop, so a mid-run menu never fights
+// the running task. Pure, so the interception is unit-tested.
+export function isLiveConfigCommand(text) {
+    return /^\/config\s+(?!menu\b|ui\b)\S+/i.test(String(text ?? '').trim());
+}
+// Parse a `/queue` invocation. Returns the subcommand ('list' | 'clear') or
+// null when the text is not a /queue command at all. This runs WHILE the agent
+// is busy (intercepted in the input handler), because the main command loop is
+// blocked on runTask() and a queued /queue would only run after the task —
+// when inspecting/clearing the queue is pointless.
+export function parseQueueCommand(text) {
+    const t = String(text ?? '').trim();
+    const m = /^\/queue(?:\s+(\S+))?\s*$/.exec(t);
+    if (!m)
+        return null;
+    const arg = (m[1] || '').toLowerCase();
+    if (arg === '' || arg === 'list' || arg === 'ls')
+        return { sub: 'list' };
+    if (arg === 'clear' || arg === 'c' || arg === 'clean')
+        return { sub: 'clear' };
+    // An unrecognized subcommand falls through to the normal main-loop handler,
+    // which prints the usage hint.
+    return null;
+}
+// Render the queued messages for the operator (one line per message, text
+// truncated). Pure, so the /queue interception and the main-loop handler share
+// the EXACT same output instead of duplicating the formatting.
+export function formatQueueList(msgs) {
+    return (msgs || []).map((m, i) => {
+        const one = String(m.text || '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        const shown = one.length > 80 ? one.slice(0, 80) + ' …' : one;
+        const att = m.attachments?.length ? ' [+' + m.attachments.length + ']' : '';
+        return '  ' + (i + 1) + '. ' + shown + att;
+    });
+}
 function queuedIsImage(a) {
     return (String(a.mime || '').startsWith('image/') ||
         isImageName(String(a.name || '')));

package/dist/i18n.js

@@ -205,6 +205,78 @@ const CATALOG = {
         ru: '/queue [clear] показать/очистить очередь сообщений',
         en: '/queue [clear] list/clear the pending message queue',
     },
+    'help.cmd.thinking': {
+        ru: '/thinking [on|off] включить/выключить режим размышления (можно во время работы)',
+        en: '/thinking [on|off] toggle Deep thinking (works while the agent is busy)',
+    },
+    'help.cmd.web': {
+        ru: '/web [on|off] включить/выключить поиск в интернете (можно во время работы)',
+        en: '/web [on|off] toggle Smart search (works while the agent is busy)',
+    },
+    'help.cmd.goal': {
+        ru: '/goal [текст|clear] задать долгоживущую цель сессии',
+        en: '/goal [text|clear] set a long-lived session goal',
+    },
+    'help.cmd.loop': {
+        ru: '/loop <интервал> <задача> периодически повторять задачу (напр. 10m)',
+        en: '/loop <interval> <task> repeat a task periodically (e.g. 10m)',
+    },
+    'help.cmd.cron': {
+        ru: '/cron <выражение> <задача> запускать по расписанию (5 полей)',
+        en: '/cron <expr> <task> schedule a task (5-field cron)',
+    },
+    'help.cmd.jobs': {
+        ru: '/jobs [rm <id>|clear] список/удаление запланированных задач',
+        en: '/jobs [rm <id>|clear] list/remove scheduled tasks',
+    },
+    'sched.loop_usage': {
+        ru: 'Использование: /loop <интервал> <задача>, например /loop 10m проверь тесты',
+        en: 'Usage: /loop <interval> <task>, e.g. /loop 10m check the tests',
+    },
+    'sched.cron_usage': {
+        ru: 'Использование: /cron "<мин> <час> <день> <мес> <день недели>" <задача>',
+        en: 'Usage: /cron "<min> <hour> <dom> <month> <dow>" <task>',
+    },
+    'sched.added': {
+        ru: '⏰ Задача #{id} добавлена ({when}): {task}',
+        en: '⏰ Job #{id} added ({when}): {task}',
+    },
+    'sched.title': { ru: 'Запланированные задачи:', en: 'Scheduled jobs:' },
+    'sched.none': { ru: 'Запланированных задач нет.', en: 'No scheduled jobs.' },
+    'sched.fired': {
+        ru: '⏰ Задача #{id} сработала: {task}',
+        en: '⏰ Job #{id} fired: {task}',
+    },
+    'sched.cleared': { ru: 'Задачи очищены: {n}', en: 'Jobs cleared: {n}' },
+    'sched.removed': { ru: 'Задача #{id} удалена.', en: 'Job #{id} removed.' },
+    'sched.rm_usage': {
+        ru: 'Использование: /jobs rm <id>',
+        en: 'Usage: /jobs rm <id>',
+    },
+    'sched.remove_hint': {
+        ru: 'Удалить: /jobs rm <id> · очистить всё: /jobs clear',
+        en: 'Remove: /jobs rm <id> · clear all: /jobs clear',
+    },
+    'goal.set': { ru: '🎯 Цель сессии: {goal}', en: '🎯 Session goal: {goal}' },
+    'goal.loaded': {
+        ru: '🎯 Восстановлена цель сессии: {goal}',
+        en: '🎯 Restored session goal: {goal}',
+    },
+    'goal.current': {
+        ru: '🎯 Цель сессии: {goal}',
+        en: '🎯 Session goal: {goal}',
+    },
+    'goal.none': {
+        ru: 'Цель сессии не задана. /goal <текст>, /goal clear.',
+        en: 'No session goal. /goal <text>, /goal clear.',
+    },
+    'goal.cleared': {
+        ru: '🎯 Цель сессии очищена.',
+        en: '🎯 Session goal cleared.',
+    },
+    'toggle.thinking': { ru: 'Размышление', en: 'Deep thinking' },
+    'toggle.search': { ru: 'Поиск в интернете', en: 'Smart search' },
+    'toggle.set': { ru: '{name}: {state}', en: '{name}: {state}' },
     'compact.auto_trigger': {
         ru: '🗜️ Контекст заполнен на {pct}% ({tokens} токенов) — сжимаю историю и открываю новый чат...',
         en: '🗜️ Context at {pct}% ({tokens} tokens) — compacting the history and opening a fresh chat...',
@@ -374,6 +446,10 @@ const CATALOG = {
         ru: '⚙ выполняю {name}',
         en: '⚙ running {name}',
     },
+    // Send/generation lifecycle indicator in the status line. Unlike the
+    // animated thinking phrase, it says explicitly that a generation is in
+    // flight. 'paused'/'settled' have no label (see LineEditor._stateLabel).
+    'state.generating': { ru: '▶ генерация', en: '▶ generating' },
     'editor.more': { ru: '…ещё {n}', en: '…{n} more' },
     'editor.answer': { ru: '● Ответ', en: '● Answer' },
     // ---------- status ----------
@@ -462,6 +538,13 @@ const CATALOG = {
         en: '⏹ Ctrl+C — aborting generation...',
     },
     'msg.queued': { ru: '📨 В очередь ({n}): ', en: '📨 Queued ({n}): ' },
+    // Shown ONCE per session, the first time a message is queued while the
+    // agent is working. It explains what happens (sent after the current task)
+    // and how to inspect/clear the queue, so the operator knows nothing is lost.
+    'msg.queued_hint': {
+        ru: 'Сообщение в очереди — уйдёт после текущей задачи; /queue покажет и очистит.',
+        en: 'Message queued — it will be sent after the current task; /queue lists or clears it.',
+    },
     'msg.attached_image': {
         ru: '🖼 Вложено изображение {marker} ({size}) — {path}',
         en: '🖼 Attached image {marker} ({size}) — {path}',
@@ -482,10 +565,15 @@ const CATALOG = {
         ru: '   Похоже, вы в контейнере/Dev Container: клипборд Windows отсюда недоступен. Вставьте путь к файлу (например tmp/pic.png) — он приложится к сообщению.',
         en: '   Looks like a container/Dev Container: the Windows clipboard is not reachable from here. Paste a path to a file (e.g. tmp/pic.png) — it will be attached to the message.',
     },
-    'msg.task_summary': {
-        ru: '· задача: {sec}с · инструментов: {tools}',
-        en: '· task: {sec}s · tools: {tools}',
-    },
+    // Per-task summary parts (joined with "·" by index.ts). Split into separate
+    // keys so the tokens part can be omitted when the counter is unknown.
+    'task_sum.dur': { ru: 'длительность: {dur}', en: 'duration: {dur}' },
+    'task_sum.tools': { ru: 'инструментов: {n}', en: 'tools: {n}' },
+    'task_sum.tokens': { ru: 'токенов: {n}', en: 'tokens: {n}' },
+    // Unit labels for the localized task duration (see formatDuration).
+    'dur.h': { ru: 'ч', en: 'h' },
+    'dur.m': { ru: 'м', en: 'm' },
+    'dur.s': { ru: 'с', en: 's' },
     'msg.from_queue': { ru: '▶ Из очереди: ', en: '▶ From queue: ' },
     'msg.from_queue_batch': {
         ru: '▶ Из очереди ({n} сообщ.): ',
@@ -498,7 +586,6 @@ const CATALOG = {
     'msg.queue_title': { ru: 'Очередь сообщений:', en: 'Pending messages:' },
     'msg.queue_empty': { ru: 'Очередь пуста.', en: 'The queue is empty.' },
     'msg.queue_cleared': { ru: 'Очередь очищена.', en: 'Queue cleared.' },
-    'msg.queue_item': { ru: '{n}. {text}', en: '{n}. {text}' },
     'msg.queue_usage': {
         ru: 'Использование: /queue [clear]',
         en: 'Usage: /queue [clear]',
@@ -876,6 +963,10 @@ const CATALOG = {
     },
     'mcp.status_error': { ru: '(ошибка: {v})', en: '(error: {v})' },
     'status.mcp': { ru: 'MCP-инструменты: {v}', en: 'MCP tools: {v}' },
+    'status.toggles': {
+        ru: 'Размышление: {think} · Поиск: {search}',
+        en: 'Deep thinking: {think} · Search: {search}',
+    },
     'status.tokens': {
         ru: 'Контекст (токенов): {v}',
         en: 'Context (tokens): {v}',