zames_pro 2.32.0 → 2.35.0

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, isLiveConfigCommand, 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;
@@ -1353,6 +1466,9 @@ async function main() {
         // The editor pulls the number on every render, so it follows the live
         // DeepSeek counter (accumulated_token_usage) without a polling timer.
         ed.onContextQuery = () => browser.getLastTokenUsage();
+        // Queue badge: show "⧗N" while messages are waiting to be sent after the
+        // current task. Pulled on every render (like the context counter).
+        ed.onQueueQuery = () => pendingQueue.length;
         // Use the configured context window for the fill percentage/color.
         ed.setContextLimit(config.ui.contextLimit);
         // Toggle icons (🧠 deep thinking, 🌐 web search) before the context
@@ -1451,6 +1567,49 @@ 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;
+                }
+                // `/config <sub>` text commands (list/get/set/reset/lang) are safe
+                // mid-run: they only touch config values, never the chat. The
+                // interactive menu (`/config` bare or `menu`) is NOT intercepted —
+                // it pauses the editor and would fight the running task, so it stays
+                // queued. `setConfigRuntime` already applies hot values (locale,
+                // toggles, context limit) to the live objects immediately.
+                if (isLiveConfigCommand(text)) {
+                    void handleConfigCommand(text);
+                    return;
+                }
+            }
             const attachments = (items || []).map((a) => ({
                 path: a.path,
                 name: a.name,
@@ -1458,6 +1617,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 +1744,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 +2327,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 +2656,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'),
             })));
@@ -2466,6 +2780,7 @@ async function main() {
                     ? (await runGit('git remote', currentWorkdir, 5000)).includes('origin')
                     : undefined,
                 minSendIntervalMs: config.browser.minSendIntervalMs,
+                sshRemote: !!(process.env.SSH_CONNECTION || process.env.SSH_TTY),
             })));
             continue;
         }
@@ -2695,6 +3010,7 @@ async function main() {
                 autoCompactPct: config.browser.autoCompactPct,
                 contextLimit: config.ui.contextLimit,
                 getTokenUsage: () => browser.getLastTokenUsage(),
+                goal: sessionGoal,
             }, inputAttachments);
         }
         finally {
@@ -2710,6 +3026,8 @@ async function main() {
     }
     if (editor)
         editor.dispose();
+    if (scheduleTimer)
+        clearInterval(scheduleTimer);
     await browser.close().catch(() => { });
     await mod.closeWeb().catch(() => { });
     if (mcpPool)