zames_pro 2.20.0 → 2.21.2

package/dist/agent-loop.js

@@ -47,7 +47,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             id = await browser.getCurrentChatId();
         }
         catch {
-            id = null;
+            // keep id = null
         }
         if (id && id !== lastReportedChatId) {
             lastReportedChatId = id;
@@ -56,7 +56,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     };
     await reportChat();
     if (sendSystemPrompt) {
-        let gitText = null;
+        let gitText;
         try {
             const ctx = await getGitContext(workdir);
             gitText = formatGitContext(ctx);
@@ -64,7 +64,7 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         catch (e) {
             gitText = `(git context error: ${e.message})`;
         }
-        let context = null;
+        let context;
         try {
             context = await loadProjectContext(workdir);
         }
@@ -267,7 +267,9 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // A stale answer is discarded only when it does NOT parse as a tool
         // call (see wdStale above); an echo of a call that never ran is a real
         // call and must be executed, not dropped.
-        if (!isFirst && (wdEmpty || wdStale || wdNoCall) && watchdogRetries < MAX_WATCHDOG_RETRIES) {
+        if (!isFirst &&
+            (wdEmpty || wdStale || wdNoCall) &&
+            watchdogRetries < MAX_WATCHDOG_RETRIES) {
             watchdogRetries++;
             transcript?.log('watchdog_nudge', {
                 attempt: watchdogRetries,
@@ -372,7 +374,8 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             // README…" or "Let me run the tests…" and goes silent. If this is taken
             // as final, the agent stalls without doing the work. We ask it to
             // continue and to actually call a tool this time (or respond if truly done).
-            if (looksLikeUnfinishedWork(trimmed) && looksDoneRetries < MAX_LOOKSDONE_RETRIES) {
+            if (looksLikeUnfinishedWork(trimmed) &&
+                looksDoneRetries < MAX_LOOKSDONE_RETRIES) {
                 looksDoneRetries++;
                 unparsedRetries++;
                 transcript?.log('unfinished_retry', {
@@ -454,9 +457,12 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                 // a READABLE report, but say explicitly that the task may be incomplete:
                 // never let a reasoning paragraph masquerade as a finished result.
                 const lastText = (rawResponse || '').trim();
-                return (lastText
-                    ? lastText + String.fromCharCode(10) + String.fromCharCode(10) + '(The model stopped calling tools before finishing. The task may be incomplete - check the DeepSeek chat.)'
-                    : 'The model stopped calling tools before finishing the task.');
+                return lastText
+                    ? lastText +
+                        String.fromCharCode(10) +
+                        String.fromCharCode(10) +
+                        '(The model stopped calling tools before finishing. The task may be incomplete - check the DeepSeek chat.)'
+                    : 'The model stopped calling tools before finishing the task.';
             }
             const suspiciousFinal = responseLooksLikeToolCall(rawResponse) ||
                 looksLikeUnfinishedWork((rawResponse || '').trim()) ||
@@ -608,8 +614,8 @@ export function responseLooksLikeToolCall(rawResponse) {
         // argument key (args/command/path/...). We require the opening bracket at
         // the start (after spaces/prefix) so we don't catch ordinary prose with
         // colons like "path: ...".
-        /^\s*[\[\{]/.test(raw) &&
-            /["']?(?:tool|args|command|path|old_string|content|content_base64)["']?\s*:/.test(raw) ||
+        (/^\s*[\[\{]/.test(raw) &&
+            /["']?(?:tool|args|command|path|old_string|content|content_base64)["']?\s*:/.test(raw)) ||
         /<\s*\|?\s*(DSML|invoke|parameter)/i.test(raw) ||
         /^\s*\[?\s*\{[^}]*$/.test(raw.trim()));
 }
@@ -839,7 +845,7 @@ function parseArgsPermissive(str) {
             break;
         if (str[i] !== '"')
             return null;
-        let keyEnd = str.indexOf('"', i + 1);
+        const keyEnd = str.indexOf('"', i + 1);
         if (keyEnd === -1)
             return null;
         const key = str.slice(i + 1, keyEnd);
@@ -994,7 +1000,9 @@ function parseToolCallPermissive(text) {
         if (braceIdx === -1)
             return null;
         const endBrace = findMatching(text, braceIdx, '{', '}');
-        const objText = endBrace === -1 ? text.slice(braceIdx) : text.slice(braceIdx, endBrace + 1);
+        const objText = endBrace === -1
+            ? text.slice(braceIdx)
+            : text.slice(braceIdx, endBrace + 1);
         const inlineArgs = parseArgsPermissive(objText) || parseArgsGreedy(objText);
         if (!inlineArgs)
             return null;

package/dist/attachments.js

@@ -4,14 +4,23 @@ import os from 'os';
 import { execFileSync } from 'child_process';
 import { extractPathToken } from './path-token.js';
 export { extractPathToken };
-export const IMAGE_EXTS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg', '.ico'];
+export const IMAGE_EXTS = [
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.webp',
+    '.bmp',
+    '.svg',
+    '.ico',
+];
 export const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 function sanitize(name) {
-    return String(name || '')
+    return (String(name || '')
         .replace(/[\u0000-\u001f\u007f]/g, '')
         .replace(/[\\/:*?"<>|]/g, '_')
         .replace(/\s+/g, '_')
-        .slice(0, 80) || 'file';
+        .slice(0, 80) || 'file');
 }
 export function guessMime(name) {
     const ext = path.extname(String(name || '')).toLowerCase();
@@ -74,7 +83,10 @@ export function parseDataUrl(text) {
     if (!m)
         return null;
     try {
-        return { mime: m[1] || 'application/octet-stream', data: Buffer.from(m[2].replace(/\s+/g, ''), 'base64') };
+        return {
+            mime: m[1] || 'application/octet-stream',
+            data: Buffer.from(m[2].replace(/\s+/g, ''), 'base64'),
+        };
     }
     catch {
         return null;
@@ -189,7 +201,9 @@ export function hasClipboardTool() {
     if (process.platform === 'win32' || process.platform === 'darwin')
         return true;
     if (process.platform === 'linux') {
-        return Boolean(tryCommand('xclip', ['-version']) || tryCommand('xsel', ['--version']) || tryCommand('wl-paste', ['--version']));
+        return Boolean(tryCommand('xclip', ['-version']) ||
+            tryCommand('xsel', ['--version']) ||
+            tryCommand('wl-paste', ['--version']));
     }
     return false;
 }
@@ -238,7 +252,9 @@ const PS_GET_FILE_DROP = 'Add-Type -AssemblyName System.Windows.Forms; ' +
     'if($d -and $d.GetDataPresent([System.Windows.Forms.DataFormats]::FileDrop)){' +
     '$f=$d.GetData([System.Windows.Forms.DataFormats]::FileDrop); $f -join [Environment]::NewLine}';
 export async function readClipboardImageDetailed() {
-    if (process.platform === 'linux' || process.platform === 'freebsd' || process.platform === 'openbsd') {
+    if (process.platform === 'linux' ||
+        process.platform === 'freebsd' ||
+        process.platform === 'openbsd') {
         const wayland = process.env.WAYLAND_DISPLAY;
         const x11 = process.env.DISPLAY;
         const attempts = [];
@@ -249,14 +265,34 @@ export async function readClipboardImageDetailed() {
                 return { data: win, via: 'powershell.exe' };
         }
         if (wayland || !x11)
-            attempts.push({ bin: 'wl-paste', args: ['--type', 'image/png', '--no-newline'], via: 'wl-paste' });
+            attempts.push({
+                bin: 'wl-paste',
+                args: ['--type', 'image/png', '--no-newline'],
+                via: 'wl-paste',
+            });
         if (x11 || !wayland) {
-            attempts.push({ bin: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'], via: 'xclip' });
-            attempts.push({ bin: 'xsel', args: ['--clipboard', '--output'], via: 'xsel' });
+            attempts.push({
+                bin: 'xclip',
+                args: ['-selection', 'clipboard', '-t', 'image/png', '-o'],
+                via: 'xclip',
+            });
+            attempts.push({
+                bin: 'xsel',
+                args: ['--clipboard', '--output'],
+                via: 'xsel',
+            });
         }
         // Even if the session env is missing, try the other family as a fallback.
-        attempts.push({ bin: 'wl-paste', args: ['--type', 'image/png', '--no-newline'], via: 'wl-paste' });
-        attempts.push({ bin: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'], via: 'xclip' });
+        attempts.push({
+            bin: 'wl-paste',
+            args: ['--type', 'image/png', '--no-newline'],
+            via: 'wl-paste',
+        });
+        attempts.push({
+            bin: 'xclip',
+            args: ['-selection', 'clipboard', '-t', 'image/png', '-o'],
+            via: 'xclip',
+        });
         const tried = [];
         for (const a of attempts) {
             if (tried.includes(a.via))
@@ -272,7 +308,10 @@ export async function readClipboardImageDetailed() {
     }
     if (process.platform === 'darwin') {
         const data = tryCommand('pngpaste', ['-']);
-        return { data: data && data.length ? data : null, via: data ? 'pngpaste' : 'no-tool:pngpaste' };
+        return {
+            data: data && data.length ? data : null,
+            via: data ? 'pngpaste' : 'no-tool:pngpaste',
+        };
     }
     if (process.platform === 'win32') {
         // PowerShell reads the clipboard image and writes raw PNG bytes to stdout.
@@ -281,8 +320,16 @@ export async function readClipboardImageDetailed() {
             'if($img){$ms=New-Object System.IO.MemoryStream; ' +
             '$img.Save($ms,[System.Drawing.Imaging.ImageFormat]::Png); ' +
             '[Console]::OpenStandardOutput().Write($ms.ToArray(),0,$ms.Length)}';
-        const data = tryCommand('powershell', ['-NoProfile', '-NonInteractive', '-Command', ps]);
-        return { data: data && data.length ? data : null, via: data ? 'powershell' : 'no-tool:powershell' };
+        const data = tryCommand('powershell', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            ps,
+        ]);
+        return {
+            data: data && data.length ? data : null,
+            via: data ? 'powershell' : 'no-tool:powershell',
+        };
     }
     return { data: null, via: 'unsupported-platform' };
 }
@@ -329,7 +376,13 @@ export async function findFileByName(workdir, name) {
 export function readWindowsClipboardFiles() {
     if (!isWsl())
         return [];
-    const out = tryCommand('powershell.exe', ['-STA', '-NoProfile', '-NonInteractive', '-Command', PS_GET_FILE_DROP]);
+    const out = tryCommand('powershell.exe', [
+        '-STA',
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        PS_GET_FILE_DROP,
+    ]);
     if (!out)
         return [];
     const text = out.toString('utf-8');
@@ -360,10 +413,20 @@ export function winPathToWsl(winPath) {
 export async function readWindowsClipboardImage() {
     if (!isWsl())
         return null;
-    const out = tryCommand('powershell.exe', ['-STA', '-NoProfile', '-NonInteractive', '-EncodedCommand', PS_IMAGE_ENCODED]);
+    const out = tryCommand('powershell.exe', [
+        '-STA',
+        '-NoProfile',
+        '-NonInteractive',
+        '-EncodedCommand',
+        PS_IMAGE_ENCODED,
+    ]);
     if (!out)
         return null;
-    const first = out.toString('utf-8').trim().split(String.fromCharCode(10))[0].trim();
+    const first = out
+        .toString('utf-8')
+        .trim()
+        .split(String.fromCharCode(10))[0]
+        .trim();
     if (!first)
         return null;
     const wslPath = winPathToWsl(first);

package/dist/browser.js

@@ -165,7 +165,15 @@ const STOP_SELECTORS = [
 // Otherwise the agent takes a status (Reading...) for an answer and breaks parsing.
 const STATUS_RE = /^(reading|thinking|searching|analyzing|generating|stop|остановить|читаю|думаю|поиск|анализ)[\s.…]*$/i;
 // DeepSeek's answer when the rate limit is exceeded.
-const RATE_LIMIT_RE = /(messages? too frequent|too many requests|rate limit|слишком часто|повторите позже|try again later)/i;
+//
+// IMPORTANT: the generic "try again later" / "повторите позже" tail is NOT
+// part of this pattern. DeepSeek appends it to MANY toasts ("Server busy.
+// Try again later.", "Service unavailable. Try again later."), so matching it
+// here classified every server hiccup as a RATE LIMIT and sent the agent into
+// a 5-minute wait (and, after the finish-loop stopped reading toasts every
+// tick, looked like "the agent hung"). The rate limit is recognized by its
+// specific wording only.
+const RATE_LIMIT_RE = /(messages? too frequent|too many requests|rate limit|слишком часто|сообщени[яе] слишком част)/i;
 // Transient server-side hiccups (DeepSeek overloaded / hiccup). Unlike the
 // rate limit, these usually clear in seconds, so we retry quickly instead of
 // waiting minutes. "Server busy", 503, "temporarily unavailable", etc.
@@ -415,7 +423,7 @@ export class DeepSeekBrowser {
                 try {
                     this.context = await chromium.launchPersistentContext(USER_DATA_DIR, options);
                 }
-                catch (e2) {
+                catch {
                     if (this.debug)
                         console.error('profile: сношу целиком');
                     await nukeProfile();
@@ -501,7 +509,13 @@ export class DeepSeekBrowser {
                 await this.context.close();
         }
         catch { }
-        await this.launch();
+        // A restart must REUSE the existing profile. `launch()` would call
+        // killStaleChrome() and clean Singleton files, which can race with a
+        // sibling agent on the same profile; here we just relaunch the persistent
+        // context in place. A fresh window appears only because the old context was
+        // actually closed — no second window is created while one is alive.
+        await this._launchOnce();
+        await this._fixHeadlessUserAgent();
     }
     async waitForLogin() {
         // 1) Already signed in (session cookie in the persistent profile)?
@@ -1096,7 +1110,11 @@ export class DeepSeekBrowser {
                     })));
                     // Interruptible: Esc/Ctrl+C must cancel this long wait too,
                     // otherwise "stop" stays frozen for up to 5 minutes.
-                    const aborted = await this._sleepInterruptible(this.rateLimitWaitMs);
+                    // The wait is ANIMATED through onSendPause (a live countdown), so the
+                    // operator sees the agent is waiting on the rate limit instead of a
+                    // frozen spinner. `_lastSentAt` is bumped so the countdown renders.
+                    const waitSec = Math.ceil(this.rateLimitWaitMs / 1000);
+                    const aborted = await this._waitRateLimit(waitSec);
                     if (aborted)
                         return '(прервано пользователем)';
                     continue;
@@ -1129,7 +1147,12 @@ export class DeepSeekBrowser {
                         max: this.askRetries,
                         error: e.message,
                     })));
-                if (/closed|crash|Target page|browser/i.test(e.message)) {
+                // Only a genuinely LOST page justifies a restart. "Target page,
+                // context or browser has been closed" means the page is gone for good;
+                // a bare "browser" mention (e.g. a selector error containing the word)
+                // must NOT tear the window down — that was the "a new window opened"
+                // surprise during a resumed chat. We re-open the SAME context instead.
+                if (/target page, context or browser has been closed|page.*has been closed/i.test(e.message)) {
                     console.error(theme.warn(this._t('ds.ask_restart_browser')));
                     try {
                         await this.restart();
@@ -1276,6 +1299,22 @@ export class DeepSeekBrowser {
         // Wait for the upload to finish (the attach preview to appear).
         await this.page.waitForTimeout(2000);
     }
+    // Wait out a rate-limit pause, showing an animated countdown through
+    // onSendPause so the operator sees the agent is alive (not frozen). Returns
+    // true when the wait was cut short by Esc/Ctrl+C.
+    async _waitRateLimit(totalSec) {
+        const tick = (leftMs) => {
+            const secs = Math.max(0, Math.ceil(leftMs / 1000));
+            if (this.onSendPause) {
+                try {
+                    this.onSendPause(secs);
+                }
+                catch { }
+            }
+        };
+        tick(totalSec * 1000);
+        return await this._sleepInterruptible(totalSec * 1000, tick);
+    }
     // Pause between sends. Applied ONLY to agent messages
     // (tool-result, system-prompt) so we don't hit the rate limit.
     // User input is sent without delay.
@@ -1560,20 +1599,24 @@ export class DeepSeekBrowser {
         const deadline = Date.now() + timeout;
         let last = '';
         let stable = 0;
-        let tick = 0;
         while (Date.now() < deadline) {
             if (this._abort) {
                 return last || '(прервано пользователем)';
             }
-            // We check the limit toast not every tick but about once per 5 ticks,
-            // so we don't poke the DOM unnecessarily.
-            if (tick++ % 5 === 0) {
+            // Rate-limit / server-busy toast. The old code only read the toasts
+            // when `tick % 5 === 0` (once per ~2s), and the throw on the rate limit
+            // made the server-busy branch unreachable. A toast that appears and
+            // disappears between those checks was missed entirely, so the run
+            // waited out the whole deadline and threw ds.send_no_new_answer. We now
+            // read the toast on EVERY tick (a cheap, selector-scoped evaluate) and
+            // classify both conditions independently.
+            {
                 const pageText = await this._readPageText();
                 if (isRateLimitText(pageText)) {
                     throw new RateLimitError(pageText.slice(0, 300));
-                    if (isServerBusyText(pageText)) {
-                        throw new ServerBusyError(pageText.slice(0, 300));
-                    }
+                }
+                if (isServerBusyText(pageText)) {
+                    throw new ServerBusyError(pageText.slice(0, 300));
                 }
             }
             const netFresh = !!this._netCapture && this._netCaptureAt >= this._lastSentAt;

package/dist/commands.js

@@ -7,7 +7,10 @@ const CR = String.fromCharCode(13);
 // ---------- /diff ----------
 export function formatDiff(diffText, opts = {}) {
     const maxLines = opts.maxLines ?? 200;
-    const trimmed = String(diffText ?? '').split(CR + NL).join(NL).trimEnd();
+    const trimmed = String(diffText ?? '')
+        .split(CR + NL)
+        .join(NL)
+        .trimEnd();
     if (!trimmed)
         return '(no changes)';
     const lines = trimmed.split(NL);
@@ -17,7 +20,9 @@ export function formatDiff(diffText, opts = {}) {
     const rest = lines.length - maxLines;
     return (head +
         NL +
-        '... [' + rest + ' more lines, use Bash git diff for the full output]');
+        '... [' +
+        rest +
+        ' more lines, use Bash git diff for the full output]');
 }
 export function diffGitArgs(staged = false) {
     return staged ? 'git diff --staged' : 'git diff';

package/dist/config-menu.js

@@ -66,7 +66,9 @@ export function runConfigMenu(opts) {
             }
             const selected = i === cursor;
             const marker = selected ? theme.prompt('\u276f ') : '  ';
-            const label = selected ? theme.prompt(f.labelKey ? t(f.labelKey) : f.path) : t(f.labelKey || f.path);
+            const label = selected
+                ? theme.prompt(f.labelKey ? t(f.labelKey) : f.path)
+                : t(f.labelKey || f.path);
             const val = displayValue(f, get(f.path), t);
             const valText = selected ? theme.assistant(val) : theme.dim(val);
             const pathText = selected ? theme.dim('  ' + f.path) : '';

package/dist/config.js

@@ -85,29 +85,163 @@ function deepMerge(target, source) {
     }
 }
 export const CONFIG_SCHEMA = [
-    { path: 'ui.locale', type: 'enum', values: ['ru', 'en'], labelKey: 'cfg.f.ui_locale', groupKey: 'cfg.group.ui' },
-    { path: 'maxIterations', type: 'number', min: 0, max: 100000, labelKey: 'cfg.f.maxIterations', groupKey: 'cfg.group.agent' },
-    { path: 'headless', type: 'boolean', labelKey: 'cfg.f.headless', groupKey: 'cfg.group.agent' },
-    { path: 'browser.auth.username', type: 'string', labelKey: 'cfg.f.browser_authUsername', groupKey: 'cfg.group.browser' },
-    { path: 'browser.auth.password', type: 'string', labelKey: 'cfg.f.browser_authPassword', groupKey: 'cfg.group.browser' },
-    { path: 'browser.auth.saveSession', type: 'boolean', labelKey: 'cfg.f.browser_authSaveSession', groupKey: 'cfg.group.browser' },
-    { path: 'debug', type: 'boolean', labelKey: 'cfg.f.debug', groupKey: 'cfg.group.agent' },
-    { path: 'hotReload', type: 'boolean', labelKey: 'cfg.f.hotReload', groupKey: 'cfg.group.agent' },
-    { path: 'confirmation.write', type: 'boolean', labelKey: 'cfg.f.confirmation_write', groupKey: 'cfg.group.confirmation' },
-    { path: 'confirmation.edit', type: 'boolean', labelKey: 'cfg.f.confirmation_edit', groupKey: 'cfg.group.confirmation' },
-    { path: 'confirmation.bash', type: 'boolean', labelKey: 'cfg.f.confirmation_bash', groupKey: 'cfg.group.confirmation' },
-    { path: 'undo.enabled', type: 'boolean', labelKey: 'cfg.f.undo_enabled', groupKey: 'cfg.group.undo' },
-    { path: 'undo.maxBackups', type: 'number', min: 1, max: 100000, labelKey: 'cfg.f.undo_maxBackups', groupKey: 'cfg.group.undo' },
-    { path: 'transcript.enabled', type: 'boolean', labelKey: 'cfg.f.transcript_enabled', groupKey: 'cfg.group.transcript' },
-    { path: 'browser.answerTimeoutMs', type: 'number', min: 1000, max: 3600000, labelKey: 'cfg.f.browser_answerTimeoutMs', groupKey: 'cfg.group.browser' },
-    { path: 'browser.askRetries', type: 'number', min: 1, max: 100, labelKey: 'cfg.f.browser_askRetries', groupKey: 'cfg.group.browser' },
-    { path: 'browser.stabilityChecks', type: 'number', min: 1, max: 100, labelKey: 'cfg.f.browser_stabilityChecks', groupKey: 'cfg.group.browser' },
-    { path: 'browser.stabilityDelayMs', type: 'number', min: 0, max: 60000, labelKey: 'cfg.f.browser_stabilityDelayMs', groupKey: 'cfg.group.browser' },
-    { path: 'browser.minSendIntervalMs', type: 'number', min: 0, max: 600000, labelKey: 'cfg.f.browser_minSendIntervalMs', groupKey: 'cfg.group.browser' },
-    { path: 'browser.rateLimitWaitMs', type: 'number', min: 0, max: 3600000, labelKey: 'cfg.f.browser_rateLimitWaitMs', groupKey: 'cfg.group.browser' },
-    { path: 'browser.maxRateLimitRetries', type: 'number', min: 0, max: 100, labelKey: 'cfg.f.browser_maxRateLimitRetries', groupKey: 'cfg.group.browser' },
-    { path: 'browser.deepThinking', type: 'boolean', labelKey: 'cfg.f.browser_deepThinking', groupKey: 'cfg.group.browser' },
-    { path: 'browser.webSearch', type: 'boolean', labelKey: 'cfg.f.browser_webSearch', groupKey: 'cfg.group.browser' },
+    {
+        path: 'ui.locale',
+        type: 'enum',
+        values: ['ru', 'en'],
+        labelKey: 'cfg.f.ui_locale',
+        groupKey: 'cfg.group.ui',
+    },
+    {
+        path: 'maxIterations',
+        type: 'number',
+        min: 0,
+        max: 100000,
+        labelKey: 'cfg.f.maxIterations',
+        groupKey: 'cfg.group.agent',
+    },
+    {
+        path: 'headless',
+        type: 'boolean',
+        labelKey: 'cfg.f.headless',
+        groupKey: 'cfg.group.agent',
+    },
+    {
+        path: 'browser.auth.username',
+        type: 'string',
+        labelKey: 'cfg.f.browser_authUsername',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.auth.password',
+        type: 'string',
+        labelKey: 'cfg.f.browser_authPassword',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.auth.saveSession',
+        type: 'boolean',
+        labelKey: 'cfg.f.browser_authSaveSession',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'debug',
+        type: 'boolean',
+        labelKey: 'cfg.f.debug',
+        groupKey: 'cfg.group.agent',
+    },
+    {
+        path: 'hotReload',
+        type: 'boolean',
+        labelKey: 'cfg.f.hotReload',
+        groupKey: 'cfg.group.agent',
+    },
+    {
+        path: 'confirmation.write',
+        type: 'boolean',
+        labelKey: 'cfg.f.confirmation_write',
+        groupKey: 'cfg.group.confirmation',
+    },
+    {
+        path: 'confirmation.edit',
+        type: 'boolean',
+        labelKey: 'cfg.f.confirmation_edit',
+        groupKey: 'cfg.group.confirmation',
+    },
+    {
+        path: 'confirmation.bash',
+        type: 'boolean',
+        labelKey: 'cfg.f.confirmation_bash',
+        groupKey: 'cfg.group.confirmation',
+    },
+    {
+        path: 'undo.enabled',
+        type: 'boolean',
+        labelKey: 'cfg.f.undo_enabled',
+        groupKey: 'cfg.group.undo',
+    },
+    {
+        path: 'undo.maxBackups',
+        type: 'number',
+        min: 1,
+        max: 100000,
+        labelKey: 'cfg.f.undo_maxBackups',
+        groupKey: 'cfg.group.undo',
+    },
+    {
+        path: 'transcript.enabled',
+        type: 'boolean',
+        labelKey: 'cfg.f.transcript_enabled',
+        groupKey: 'cfg.group.transcript',
+    },
+    {
+        path: 'browser.answerTimeoutMs',
+        type: 'number',
+        min: 1000,
+        max: 3600000,
+        labelKey: 'cfg.f.browser_answerTimeoutMs',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.askRetries',
+        type: 'number',
+        min: 1,
+        max: 100,
+        labelKey: 'cfg.f.browser_askRetries',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.stabilityChecks',
+        type: 'number',
+        min: 1,
+        max: 100,
+        labelKey: 'cfg.f.browser_stabilityChecks',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.stabilityDelayMs',
+        type: 'number',
+        min: 0,
+        max: 60000,
+        labelKey: 'cfg.f.browser_stabilityDelayMs',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.minSendIntervalMs',
+        type: 'number',
+        min: 0,
+        max: 600000,
+        labelKey: 'cfg.f.browser_minSendIntervalMs',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.rateLimitWaitMs',
+        type: 'number',
+        min: 0,
+        max: 3600000,
+        labelKey: 'cfg.f.browser_rateLimitWaitMs',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.maxRateLimitRetries',
+        type: 'number',
+        min: 0,
+        max: 100,
+        labelKey: 'cfg.f.browser_maxRateLimitRetries',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.deepThinking',
+        type: 'boolean',
+        labelKey: 'cfg.f.browser_deepThinking',
+        groupKey: 'cfg.group.browser',
+    },
+    {
+        path: 'browser.webSearch',
+        type: 'boolean',
+        labelKey: 'cfg.f.browser_webSearch',
+        groupKey: 'cfg.group.browser',
+    },
 ];
 export function getConfigField(path) {
     return CONFIG_SCHEMA.find((f) => f.path === path);