zames_pro 2.31.0 → 2.34.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

@@ -71,17 +71,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 = [];
@@ -169,6 +172,15 @@ export function renderDoctor(d) {
     row(!!d.clipboardTool, 'clipboard', d.clipboardTool || 'no tool found (image paste disabled)');
     row(true, 'mcp', d.mcpServers + ' server(s), ' + d.mcpTools + ' tool(s)');
     row(d.transcriptOk, 'transcript', d.transcriptOk ? 'on' : 'off');
+    if (typeof d.contextLimit === 'number' && d.contextLimit > 0) {
+        row(true, 'context', d.contextLimit.toLocaleString('en-US') + ' tokens');
+    }
+    if (d.gitOk && typeof d.hasOrigin === 'boolean') {
+        row(true, 'git remote', d.hasOrigin ? 'origin configured' : 'no origin');
+    }
+    if (typeof d.minSendIntervalMs === 'number') {
+        row(d.minSendIntervalMs > 0, 'send pause', Math.round(d.minSendIntervalMs / 1000) + 's between agent sends');
+    }
     return 'Doctor:' + NL + rows.join(NL);
 }
 export function renderPermissions(p) {
@@ -421,6 +433,86 @@ 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 };
+}
+// 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}',

package/dist/index.js

@@ -8,7 +8,7 @@ import { DeepSeekBrowser } from './browser.js';
 import { createTools } from './tools.js';
 import { runAgentLoop } from './agent-loop.js';
 import { createSpinner } from './spinner.js';
-import { LineEditor, expandPastes, pasteReplacement, } from './input.js';
+import { LineEditor, expandPastes, pasteReplacement, formatCompactTokens, } from './input.js';
 import { parseImagePaste, extForMime, saveToTemp, guessMime, isImageName, formatSize, looksLikeFilePath, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, hasClipboardTool, } from './attachments.js';
 import { loadConfig, DEFAULTS, CONFIG_PATHS, ZAMES_HOME, CONFIG_SCHEMA, getByPath, validateConfigValue, writeConfigValue, resetConfigValue, } from './config.js';
 import { runConfigMenu } from './config-menu.js';
@@ -16,8 +16,9 @@ import { translate, normalizeLocale, localeDisplayName, isLocale, } from './i18n
 import { Transcript } from './transcript.js';
 import { UndoStore } from './undo.js';
 import { selfReview, selfDiff, selfApply, selfList } from './self-review.js';
-import { formatDiff, diffGitArgs, parseTranscript, summarizeTranscript, renderCost, formatExport, defaultExportPath, renderDoctor, renderPermissions, resolveExtraDir, buildReviewPrompt, trimRestoredMessages, RESTORED_HISTORY_LIMIT, mergeMessages, isSlashCommand, ctrlCEscalation, } from './commands.js';
+import { formatDiff, diffGitArgs, parseTranscript, summarizeTranscript, renderCost, formatExport, defaultExportPath, renderDoctor, renderPermissions, resolveExtraDir, buildReviewPrompt, formatDuration, trimRestoredMessages, RESTORED_HISTORY_LIMIT, mergeMessages, isSlashCommand, parseQueueCommand, parseLiveToggle, parseGoalCommand, withGoal, formatQueueList, ctrlCEscalation, } from './commands.js';
 import { performCompact } from './compact.js';
+import { Scheduler, parseInterval, formatInterval, parseCron, } from './scheduler.js';
 import { renderMarkdown } from './markdown.js';
 import { closeWeb } from './web.js';
 import { saveSession, loadLastSession, listSessions, sessionsDir, } from './sessions.js';
@@ -108,6 +109,36 @@ function loadLastChat(workdir = '') {
     const s = loadLastSession(workdir);
     return s ? s.id : null;
 }
+// Persistent per-project session goal (set by /goal). Kept OUT of the session
+// JSON (a session == a DeepSeek chat) because the goal is a property of the
+// PROJECT, not of one chat: it must survive /new and /compact. Best-effort —
+// a missing/unreadable file simply means "no goal".
+function goalFilePath(workdir) {
+    return path.join(workdir, '.zames-goal');
+}
+async function loadGoal(workdir) {
+    try {
+        const txt = await fs.readFile(goalFilePath(workdir), 'utf-8');
+        const trimmed = txt.trim();
+        return trimmed || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function saveGoal(workdir, goal) {
+    try {
+        if (goal && goal.trim()) {
+            await fs.writeFile(goalFilePath(workdir), goal.trim() + '\n', 'utf-8');
+        }
+        else {
+            await fs.rm(goalFilePath(workdir), { force: true });
+        }
+    }
+    catch {
+        // best-effort: a failed write must not break the command
+    }
+}
 // ---------- hot reload ----------
 // We keep references to the logic modules in the mod object. The /reload
 // command re-reads them via a dynamic import with a timestamp query — Node
@@ -287,6 +318,12 @@ ${theme.bold(t('help.commands'))}
  ${t('help.cmd.permissions')}
  ${t('help.cmd.add_dir')}
  ${t('help.cmd.review')}
+ ${t('help.cmd.goal')}
+ ${t('help.cmd.loop')}
+ ${t('help.cmd.cron')}
+ ${t('help.cmd.jobs')}
+ ${t('help.cmd.thinking')}
+ ${t('help.cmd.web')}
  ${t('help.cmd.compact')}
   ${t('help.cmd.queue')}
   ${t('help.cmd.config')}
@@ -344,6 +381,12 @@ const SLASH_COMMANDS = [
     { name: '/permissions', key: 'help.cmd.permissions' },
     { name: '/add-dir', key: 'help.cmd.add_dir' },
     { name: '/review', key: 'help.cmd.review' },
+    { name: '/goal', key: 'help.cmd.goal' },
+    { name: '/loop', key: 'help.cmd.loop' },
+    { name: '/cron', key: 'help.cmd.cron' },
+    { name: '/jobs', key: 'help.cmd.jobs' },
+    { name: '/thinking', key: 'help.cmd.thinking' },
+    { name: '/web', key: 'help.cmd.web' },
     { name: '/compact', key: 'help.cmd.compact' },
     { name: '/queue', key: 'help.cmd.queue' },
     { name: '/config', key: 'help.cmd.config' },
@@ -935,7 +978,7 @@ async function printRestoredHistory(browser, ui, chatId = null) {
 }
 // ---------- task runner ----------
 async function runTask(browser, tools, taskText, workdir, opts, attachments = []) {
-    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, } = opts;
+    const { transcript, freshChat, sendSystemPrompt, queue = [], ui: editor, onChatReady, onAutoCompact = null, autoCompactPct = 95, contextLimit = 1_000_000, getTokenUsage = null, goal = null, } = opts;
     // In TTY mode the UI is a LineEditor: it owns the input (queue, Esc,
     // Ctrl+C) and draws the status ABOVE the permanent input line. In non-TTY
     // mode (pipes) — a regular spinner + watchInput.
@@ -984,15 +1027,20 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
         // the whole pre-send phase (chat creation, throttle wait) with no
         // generation in flight.
         while (true) {
-            // T7: per-task summary (duration + number of tool calls). Counts tools
-            // via the UI callback and reports ONE dim line after the task, so the
-            // operator sees how long it took and how much work happened.
+            // T7: per-task summary (duration + number of tool calls + tokens).
+            // Counts tools via the UI callback and reports ONE line after the task,
+            // so the operator sees how long it took and how much work happened.
             const taskStart = Date.now();
+            // Token delta for THIS task: accumulated_token_usage is cumulative for
+            // the whole chat, so the per-task spend is after - before. Null when the
+            // counter is unknown (fresh chat / no answer yet); the token part is then
+            // omitted from the summary.
+            const tokensBefore = getTokenUsage ? getTokenUsage() : null;
             let taskTools = 0;
             const outcome = await mod.runAgentLoop({
                 browser,
                 tools,
-                task: next.text,
+                task: withGoal(goal, next.text),
                 workdir,
                 maxIterations: maxIter,
                 freshChat: next.freshChat,
@@ -1001,6 +1049,10 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
                 transcript,
                 onThinking: () => ui.thinking(),
                 onSendPause: (seconds) => ui.sendPause(seconds),
+                onSendState: (state) => {
+                    if (editor)
+                        editor.setSendState(state);
+                },
                 onNotice: (msg) => ui.warning(msg),
                 onToolCall: (name, toolArgs) => {
                     taskTools++;
@@ -1034,12 +1086,30 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
                 ui.warning(outcome);
                 transcript?.log('agent_no_answer', { outcome });
             }
-            // T7: one dim summary line per task (duration + tool calls). Printed
-            // even on an abort, so the operator sees what happened.
-            const summary = theme.dim(t('msg.task_summary', {
-                sec: ((Date.now() - taskStart) / 1000).toFixed(1),
-                tools: String(taskTools),
-            }));
+            // T7: one summary line per task (duration + tool calls + tokens spent).
+            // Printed even on an abort, so the operator sees what happened. Duration
+            // is human-readable ("45s", "1m 20s", "1h 12m 45s") with LOCALIZED unit
+            // labels, instead of a raw seconds count like "3129.2s". The token part
+            // is the DELTA of the cumulative counter for THIS task; it is omitted
+            // when the counter is unknown.
+            const tokensAfter = getTokenUsage ? getTokenUsage() : null;
+            const tokenDelta = typeof tokensBefore === 'number' && typeof tokensAfter === 'number'
+                ? Math.max(0, tokensAfter - tokensBefore)
+                : null;
+            const summaryParts = [
+                t('task_sum.dur', {
+                    dur: formatDuration(Date.now() - taskStart, {
+                        h: t('dur.h'),
+                        m: t('dur.m'),
+                        s: t('dur.s'),
+                    }),
+                }),
+                t('task_sum.tools', { n: String(taskTools) }),
+            ];
+            if (tokenDelta !== null) {
+                summaryParts.push(t('task_sum.tokens', { n: formatCompactTokens(tokenDelta) }));
+            }
+            const summary = theme.taskSummary('· ' + summaryParts.join(' · '));
             if (editor)
                 editor.printAbove(summary);
             else
@@ -1101,6 +1171,7 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
         // start a stale spinner.
         browser.onSendStart = null;
         browser.onSendPause = null;
+        browser.onSendState = null;
         browser.onNotice = null;
     }
 }
@@ -1253,11 +1324,53 @@ async function main() {
     let lastChats = [];
     let currentChatId = null;
     let running = true;
+    // Long-lived session goal (set via /goal). Prepended to every task message so
+    // the model keeps the big picture across many turns. Persisted per working
+    // directory in <project>/.zames-goal (best-effort); restored right away.
+    let sessionGoal = await loadGoal(currentWorkdir);
+    if (sessionGoal) {
+        console.log(theme.system(t('goal.loaded', { goal: sessionGoal })));
+    }
+    // Scheduled tasks (/loop, /cron). A pure Scheduler holds the jobs; a
+    // 1-second ticker enqueues a due job's task into the SAME message queue the
+    // operator uses, so it runs when the agent is free (never mid-generation,
+    // never bypassing the send throttle). Started lazily on the first job.
+    const scheduler = new Scheduler();
+    let scheduleTimer = null;
+    const startScheduleTicker = () => {
+        if (scheduleTimer)
+            return;
+        scheduleTimer = setInterval(() => {
+            const due = scheduler.due(Date.now());
+            for (const job of due) {
+                pendingQueue.push({ text: job.task });
+                transcript.log('scheduled_fire', { id: job.id, task: job.task });
+                if (editor) {
+                    editor.printAbove(theme.system(t('sched.fired', { id: String(job.id), task: job.task })));
+                }
+                else {
+                    console.log(theme.system(t('sched.fired', { id: String(job.id), task: job.task })));
+                }
+                // Wake a waiting main loop so a queued job runs even when idle.
+                if (waiter) {
+                    const r = waiter;
+                    waiter = null;
+                    r(pendingQueue.shift() ?? null);
+                }
+            }
+        }, 1000);
+        if (scheduleTimer.unref)
+            scheduleTimer.unref();
+    };
     // Messages the user typed while the agent worked. runTask takes them one
     // by one after the current task finishes.
     const pendingQueue = [];
     // Show the "no clipboard image" hint only once per session.
     let clipboardWarned = false;
+    // Show the "message is queued" hint once per session (the first time the
+    // operator sends while a task runs), so the queue is understood without
+    // spamming the hint on every queued message.
+    let queueHintShown = false;
     // Timestamp of the last Ctrl+C while the agent was busy. Two presses
     // within 2s escalate from "abort the running tool" to "stop the whole run".
     let lastCtrlCAt = 0;
@@ -1451,6 +1564,39 @@ async function main() {
             return att;
         };
         ed.onSubmit = (text, items) => {
+            // While the agent is busy the main command loop is blocked on
+            // `await runTask()`, so ONLY commands that make sense without the main
+            // loop are handled here (a queued slash-command would run too late).
+            if (ed.busy) {
+                const q = parseQueueCommand(text);
+                if (q) {
+                    if (q.sub === 'clear') {
+                        const n = pendingQueue.length;
+                        pendingQueue.length = 0;
+                        ed.printAbove(theme.system(t('msg.queue_cleared') + ' (' + n + ')'));
+                    }
+                    else if (!pendingQueue.length) {
+                        ed.printAbove(theme.dim(t('msg.queue_empty')));
+                    }
+                    else {
+                        ed.printAbove(theme.system(t('msg.queue_title')));
+                        for (const line of formatQueueList(pendingQueue)) {
+                            ed.printAbove(theme.assistant(line));
+                        }
+                        ed.printAbove(theme.dim(t('msg.queue_cleared_hint')));
+                    }
+                    return;
+                }
+                // Toggle Deep thinking / Smart search LIVE. This only flips the
+                // browser's DESIRED state and the status icons; it does not touch the
+                // in-flight generation, so it is safe mid-run. The actual DeepSeek
+                // toggles are applied on the next send by _applyToggles().
+                const tg = parseLiveToggle(text);
+                if (tg) {
+                    applyLiveToggle(tg);
+                    return;
+                }
+            }
             const attachments = (items || []).map((a) => ({
                 path: a.path,
                 name: a.name,
@@ -1458,6 +1604,14 @@ async function main() {
             }));
             const msg = { text, attachments };
             pendingQueue.push(msg);
+            // The operator typed this WHILE the agent was working, so the message is
+            // queued and only sent after the current task. Explain that once per
+            // session (via the editor's own status area) so it is clear nothing was
+            // lost; later queued messages stay as the compact msg.queued banner only.
+            if (ed.busy && !queueHintShown) {
+                queueHintShown = true;
+                ed.printAbove(theme.dim(t('msg.queued_hint')));
+            }
             if (waiter) {
                 const r = waiter;
                 waiter = null;
@@ -1577,6 +1731,40 @@ async function main() {
             }
         }
     }
+    // Apply `/thinking` / `/web` immediately: flip the browser's DESIRED state
+    // and the status icons, and persist to config (so it survives a restart).
+    // The DeepSeek toggles themselves are clicked on the next send by
+    // _applyToggles(), so this is safe even while a generation is in flight.
+    function applyLiveToggle(cmd) {
+        const b = browser;
+        const cur = cmd.kind === 'thinking' ? b.deepThinking : b.webSearch;
+        const next = cmd.mode === 'toggle' ? !cur : cmd.mode === 'on';
+        if (cmd.kind === 'thinking')
+            b.deepThinking = next;
+        else
+            b.webSearch = next;
+        b.setToggleState({
+            deepThinking: b.deepThinking,
+            webSearch: b.webSearch,
+        });
+        const cfgPath = cmd.kind === 'thinking' ? 'browser.deepThinking' : 'browser.webSearch';
+        try {
+            writeConfigValue('home', cfgPath, String(next));
+            setConfigRuntime(cfgPath, next);
+        }
+        catch {
+            // A failed persist must not break the toggle itself.
+        }
+        if (editor)
+            editor.refreshStatus();
+        const label = cmd.kind === 'thinking' ? t('toggle.thinking') : t('toggle.search');
+        const stateText = next ? t('common.on') : t('common.off');
+        const line = t('toggle.set', { name: label, state: stateText });
+        if (editor)
+            editor.printAbove(theme.system(line));
+        else
+            console.log(theme.system(line));
+    }
     function configSetRaw(field, raw) {
         const value = validateConfigValue(field, raw);
         writeConfigValue('home', field.path, raw);
@@ -2126,37 +2314,145 @@ async function main() {
             console.log(theme.system(currentWorkdir));
             continue;
         }
+        if (lower === '/goal' || lower.startsWith('/goal ')) {
+            const g = parseGoalCommand(trimmed);
+            if (g) {
+                if (g.sub === 'clear') {
+                    sessionGoal = null;
+                    await saveGoal(currentWorkdir, null);
+                    console.log(theme.system(t('goal.cleared')));
+                }
+                else if (g.sub === 'show') {
+                    console.log(sessionGoal
+                        ? theme.system(t('goal.current', { goal: sessionGoal }))
+                        : theme.dim(t('goal.none')));
+                }
+                else {
+                    sessionGoal = g.goal;
+                    await saveGoal(currentWorkdir, g.goal);
+                    console.log(theme.system(t('goal.set', { goal: g.goal })));
+                }
+                continue;
+            }
+        }
+        if (lower === '/loop' || lower.startsWith('/loop ')) {
+            const rest = trimmed.slice('/loop'.length).trim();
+            const sp = rest.indexOf(' ');
+            const intervalStr = sp === -1 ? rest : rest.slice(0, sp);
+            const taskStr = sp === -1 ? '' : rest.slice(sp + 1).trim();
+            const ms = parseInterval(intervalStr);
+            if (!ms || !taskStr) {
+                console.error(theme.error(t('sched.loop_usage')));
+                continue;
+            }
+            const job = scheduler.addLoop(ms, taskStr, Date.now());
+            startScheduleTicker();
+            console.log(theme.system(t('sched.added', {
+                id: String(job.id),
+                when: formatInterval(ms),
+                task: taskStr,
+            })));
+            continue;
+        }
+        if (lower === '/cron' || lower.startsWith('/cron ')) {
+            const rest = trimmed.slice('/cron'.length).trim();
+            // A cron expression is exactly 5 whitespace-separated fields; the task
+            // is everything after them.
+            const parts = rest.split(/\s+/);
+            if (parts.length < 6) {
+                console.error(theme.error(t('sched.cron_usage')));
+                continue;
+            }
+            const cronExpr = parts.slice(0, 5).join(' ');
+            const taskStr = parts.slice(5).join(' ').trim();
+            if (!parseCron(cronExpr) || !taskStr) {
+                console.error(theme.error(t('sched.cron_usage')));
+                continue;
+            }
+            const job = scheduler.addCron(cronExpr, taskStr, Date.now());
+            if (!job) {
+                console.error(theme.error(t('sched.cron_usage')));
+                continue;
+            }
+            startScheduleTicker();
+            const nextIn = formatInterval(Math.max(0, job.nextAt - Date.now()));
+            console.log(theme.system(t('sched.added', {
+                id: String(job.id),
+                when: cronExpr + ' (in ~' + nextIn + ')',
+                task: taskStr,
+            })));
+            continue;
+        }
+        if (lower === '/jobs' || lower.startsWith('/jobs ')) {
+            const sub = trimmed.slice('/jobs'.length).trim().toLowerCase();
+            if (sub === 'clear') {
+                const n = scheduler.clear();
+                if (scheduleTimer) {
+                    clearInterval(scheduleTimer);
+                    scheduleTimer = null;
+                }
+                console.log(theme.system(t('sched.cleared', { n: String(n) })));
+                continue;
+            }
+            if (sub.startsWith('rm ') || sub.startsWith('remove ')) {
+                const id = Number(sub.replace(/^(rm|remove)\s+/, ''));
+                if (!Number.isInteger(id) || !scheduler.remove(id)) {
+                    console.error(theme.error(t('sched.rm_usage')));
+                    continue;
+                }
+                if (!scheduler.count() && scheduleTimer) {
+                    clearInterval(scheduleTimer);
+                    scheduleTimer = null;
+                }
+                console.log(theme.system(t('sched.removed', { id: String(id) })));
+                continue;
+            }
+            const jobs = scheduler.list();
+            if (!jobs.length) {
+                console.log(theme.dim(t('sched.none')));
+                continue;
+            }
+            console.log(theme.system(t('sched.title')));
+            for (const j of jobs) {
+                const when = j.kind === 'loop'
+                    ? 'every ' + formatInterval(j.intervalMs || 0)
+                    : j.cron || '';
+                const nextIn = formatInterval(Math.max(0, j.nextAt - Date.now()));
+                console.log(theme.assistant('  #' + j.id + ' [' + when + ', next ~' + nextIn + '] ' + j.task));
+            }
+            console.log(theme.dim(t('sched.remove_hint')));
+            continue;
+        }
         if (lower === '/queue' || lower.startsWith('/queue ')) {
-            const sub = trimmed.slice('/queue'.length).trim().toLowerCase();
-            if (sub === 'clear' || sub === 'c' || sub === 'clean') {
+            const q = parseQueueCommand(trimmed);
+            if (!q) {
+                console.error(theme.error(t('msg.queue_usage')));
+                continue;
+            }
+            if (q.sub === 'clear') {
                 const n = pendingQueue.length;
                 pendingQueue.length = 0;
                 console.log(theme.system(t('msg.queue_cleared') + ' (' + n + ')'));
                 continue;
             }
-            if (sub && sub !== 'list' && sub !== 'ls') {
-                console.error(theme.error(t('msg.queue_usage')));
-                continue;
-            }
             if (!pendingQueue.length) {
                 console.log(theme.dim(t('msg.queue_empty')));
                 continue;
             }
             console.log(theme.system(t('msg.queue_title')));
-            pendingQueue.forEach((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 + ']'
-                    : '';
-                console.log(theme.system('  ') +
-                    theme.assistant(t('msg.queue_item', { n: i + 1, text: shown + att })));
-            });
+            for (const line of formatQueueList(pendingQueue)) {
+                console.log(theme.assistant(line));
+            }
             console.log(theme.dim(t('msg.queue_cleared_hint')));
             continue;
         }
+        if (lower.startsWith('/thinking') || lower.startsWith('/web')) {
+            const tg = parseLiveToggle(trimmed);
+            if (tg) {
+                applyLiveToggle(tg);
+                continue;
+            }
+        }
         if (lower === '/mcp') {
             if (!mcpPool) {
                 console.log(theme.dim(t('mcp.none')));
@@ -2347,6 +2643,11 @@ async function main() {
             console.log(theme.system(t('status.max_iter', { v: maxIter })));
             console.log(theme.system(t('status.headless', { v: headless ? yes : no })));
             console.log(theme.system(t('status.debug', { v: debug ? yes : no })));
+            const statusToggles = browser.getToggleStatesSync();
+            console.log(theme.system(t('status.toggles', {
+                think: statusToggles.deepThinking ? yes : no,
+                search: statusToggles.webSearch ? yes : no,
+            })));
             console.log(theme.system(t('status.undo', {
                 v: config.undo.enabled ? t('common.on') : t('common.off'),
             })));
@@ -2461,6 +2762,11 @@ async function main() {
                 mcpTools: mcpStatus.toolCount,
                 transcriptOk: !!transcript.file,
                 authSaved: authMarkerExists(),
+                contextLimit: config.ui.contextLimit,
+                hasOrigin: gitOk
+                    ? (await runGit('git remote', currentWorkdir, 5000)).includes('origin')
+                    : undefined,
+                minSendIntervalMs: config.browser.minSendIntervalMs,
             })));
             continue;
         }
@@ -2690,6 +2996,7 @@ async function main() {
                 autoCompactPct: config.browser.autoCompactPct,
                 contextLimit: config.ui.contextLimit,
                 getTokenUsage: () => browser.getLastTokenUsage(),
+                goal: sessionGoal,
             }, inputAttachments);
         }
         finally {
@@ -2705,6 +3012,8 @@ async function main() {
     }
     if (editor)
         editor.dispose();
+    if (scheduleTimer)
+        clearInterval(scheduleTimer);
     await browser.close().catch(() => { });
     await mod.closeWeb().catch(() => { });
     if (mcpPool)

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
@@ -333,6 +345,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);
@@ -501,9 +514,25 @@ export class LineEditor {
         // Redraw on terminal resize so the layout follows the new width instead
         // of leaving artifacts from the old one.
         process.stdout.on('resize', this._onResize);
+        // Pin the input block to the BOTTOM of the terminal. A fresh terminal
+        // starts the cursor at the top, so without this the input line sits at
+        // the top and only "descends" as output accumulates. Filling the viewport
+        // with newlines first makes the block start at the bottom, and every
+        // later printAbove() pushes content UP while the input stays put.
+        this._padToBottom();
         this._writeBlock();
         return true;
     }
+    // Fill the current viewport with empty lines so the next _writeBlock()
+    // lands at the BOTTOM of the terminal. Used at start and after clearScreen.
+    // We deliberately emit real newlines (not a cursor-position escape) because
+    // the block height is not known yet and scrolling keeps the block's own
+    // cursor math (`cursorRowFromTop`) correct.
+    _padToBottom() {
+        const rows = process.stdout.rows || 24;
+        if (rows > 1)
+            process.stdout.write(NL.repeat(rows - 1));
+    }
     dispose() {
         const stdin = process.stdin;
         stdin.removeListener('data', this._onData);
@@ -652,31 +681,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) {
@@ -789,6 +825,8 @@ export class LineEditor {
         process.stdout.write(ESC + '[2J' + ESC + '[H');
         this.rendered = false;
         this._lastStatusBlock = '';
+        // Re-pin the block to the bottom after the screen was cleared.
+        this._padToBottom();
         this._writeBlock();
     }
     // Repaint ONLY the input rows, leaving the status/spinner block untouched.
@@ -867,6 +905,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());
@@ -927,6 +987,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) {
@@ -950,30 +1013,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.31.0",
+  "version": "2.34.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {