zames_pro 2.66.1 → 2.67.0

package/dist/gitTools.js

@@ -1,4 +1,4 @@
-import { exec } from 'child_process';
+import { exec, execFile } from 'child_process';
 const BS = String.fromCharCode(92);
 export function runGit(cmd, cwd, timeout = 15_000) {
     return new Promise((resolve) => {
@@ -36,15 +36,44 @@ export function runGit(cmd, cwd, timeout = 15_000) {
         });
     });
 }
-// Safely quotes paths/arguments for passing to the shell.
-// String or array -> a string with double quotes and escaping.
-function quoteArgs(input) {
-    const list = Array.isArray(input) ? input : [input];
-    return list
-        .map((v) => String(v).trim())
-        .filter(Boolean)
-        .map((v) => JSON.stringify(v))
-        .join(' ');
+// Run git with an argument ARRAY (no shell). Use this whenever an argument
+// comes from the model: the shell never sees it, so $(...), backticks and a
+// leading `-` (option injection) cannot turn a read-only call into a command.
+export function runGitArgs(args, cwd, timeout = 15_000) {
+    return new Promise((resolve) => {
+        execFile('git', args, {
+            cwd,
+            timeout,
+            windowsHide: true,
+            maxBuffer: 1024 * 1024 * 8,
+            env: {
+                ...process.env,
+                GIT_TERMINAL_PROMPT: '0',
+                GIT_PAGER: 'cat',
+                PAGER: 'cat',
+            },
+        }, (err, stdout, stderr) => {
+            const out = (stdout || '').toString();
+            const errStr = (stderr || '').toString();
+            if (!err) {
+                const combined = (out + errStr).trim();
+                resolve(combined || '(command produced no output)');
+                return;
+            }
+            const parts = [];
+            if (err.killed)
+                parts.push(`⏱ Timeout ${timeout}ms`);
+            else if (err.code !== undefined && err.code !== null)
+                parts.push(`Exit code: ${err.code}`);
+            else
+                parts.push(`Error: ${err.message}`);
+            if (out.trim())
+                parts.push(out.trim());
+            if (errStr.trim())
+                parts.push(errStr.trim());
+            resolve(parts.join(String.fromCharCode(10)));
+        });
+    });
 }
 export async function getGitContext(workdir) {
     const probe = await runGit('git rev-parse --is-inside-work-tree', workdir, 5000);
@@ -93,7 +122,12 @@ export function formatGitContext(ctx) {
     if (ctx.changedFiles > 0) {
         s += `\n- Uncommitted changes: ${ctx.changedFiles} file(s)
 `;
-        s += '```\n' + ctx.statusPreview + '\n```';
+        // Choose a fence longer than any backtick run in the preview: a filename
+        // containing ``` would otherwise close the block early and corrupt the
+        // system-prompt markdown.
+        const longest = (ctx.statusPreview.match(/`+/g) || []).reduce((a, b) => Math.max(a, b.length), 0);
+        const fence = '`'.repeat(Math.max(3, longest + 1));
+        s += fence + '\n' + ctx.statusPreview + '\n' + fence;
     }
     else {
         s += '\n- Working tree: clean';
@@ -130,12 +164,17 @@ export function createGitTools(workdir) {
                 const err = await ensureRepo();
                 if (err)
                     return err;
-                const parts = ['git diff'];
+                const args = ['diff'];
                 if (staged)
-                    parts.push('--staged');
-                if (p)
-                    parts.push('--', JSON.stringify(p));
-                return runGit(parts.join(' '), workdir, 20_000);
+                    args.push('--staged');
+                if (p) {
+                    const rel = String(p);
+                    if (rel.startsWith('-')) {
+                        return `Error: invalid path: ${rel}`;
+                    }
+                    args.push('--', rel);
+                }
+                return runGitArgs(args, workdir, 20_000);
             },
         },
         {
@@ -159,9 +198,17 @@ export function createGitTools(workdir) {
                 if (err)
                     return err;
                 const r = ref && String(ref).trim() ? String(ref).trim() : 'HEAD';
-                // `stat` gives the cheap file list; the default dumps the full diff.
-                const flag = stat ? '--stat ' : '';
-                return runGit(`git show ${flag}${JSON.stringify(r)}`, workdir, 20_000);
+                // Validate the ref so a value like `--output=/tmp/x` or `HEAD$(...)`
+                // cannot reach git as an option/substitution. `git show` treats `--`
+                // as a paths separator, not a ref separator, so it is NOT used here.
+                if (r.startsWith('-') || !/^[A-Za-z0-9._/~^-]+$/.test(r)) {
+                    return `Error: invalid ref: ${r}`;
+                }
+                const args = ['show'];
+                if (stat)
+                    args.push('--stat');
+                args.push(r);
+                return runGitArgs(args, workdir, 20_000);
             },
         },
         {
@@ -187,9 +234,17 @@ export function createGitTools(workdir) {
                 const err = await ensureRepo();
                 if (err)
                     return err;
-                return runGit(paths && String(paths).trim()
-                    ? 'git add -- ' + quoteArgs(paths)
-                    : 'git add -A', workdir, 20_000);
+                if (paths && String(paths).trim()) {
+                    const list = (Array.isArray(paths) ? paths : [paths])
+                        .map((v) => String(v).trim())
+                        .filter(Boolean);
+                    for (const p of list) {
+                        if (p.startsWith('-'))
+                            return `Error: invalid path: ${p}`;
+                    }
+                    return runGitArgs(['add', '--', ...list], workdir, 20_000);
+                }
+                return runGit('git add -A', workdir, 20_000);
             },
         },
         {
@@ -218,7 +273,7 @@ export function createGitTools(workdir) {
                 const tmp = path.join(os.tmpdir(), `dsa-commit-${Date.now()}.txt`);
                 await fs.writeFile(tmp, msg, 'utf-8');
                 try {
-                    const result = await runGit(`git commit -F ${JSON.stringify(tmp)}`, workdir, 30_000);
+                    const result = await runGitArgs(['commit', '-F', tmp], workdir, 30_000);
                     return `add: ${addResult}\ncommit: ${result}`;
                 }
                 finally {
@@ -246,9 +301,11 @@ export function createGitTools(workdir) {
                 if (!/^[A-Za-z0-9._/-]+$/.test(b) || b.startsWith('-')) {
                     return `Error: invalid branch name: ${b}`;
                 }
-                const flag = setUpstream ? '-u ' : '';
-                const target = quoteArgs(b);
-                return runGit(`git push ${flag}origin ${target}`, workdir, 120_000);
+                const args = ['push'];
+                if (setUpstream)
+                    args.push('-u');
+                args.push('origin', b);
+                return runGitArgs(args, workdir, 120_000);
             },
         },
     ];

package/dist/index.js

@@ -6,7 +6,7 @@ import { existsSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { theme } from './theme.js';
 import { DeepSeekBrowser, headlessUACacheReady } from './browser.js';
-import { createTools } from './tools.js';
+import { createTools, mergeTools } from './tools.js';
 import { createTodoStore, getTodos, setTodos, resetTodos, renderTodos, } from './extraTools.js';
 import { runAgentLoop } from './agent-loop.js';
 import { createSpinner } from './spinner.js';
@@ -994,17 +994,16 @@ async function main() {
         if (debug)
             console.error(e.stack);
         await browser.close().catch(() => { });
-        transcript.close();
+        await transcript.close();
         process.exit(1);
     }
     // One-shot mode
     if (task) {
-        const tools = mod.createTools(currentWorkdir, {
+        const baseTools = mod.createTools(currentWorkdir, {
             undo,
             readOnly: planMode,
         });
-        if (mcpPool)
-            tools.push(...mcpPool.tools);
+        const tools = mergeTools(baseTools, mcpPool?.tools, planMode);
         let freshChat = true;
         let sendSystemPrompt = true;
         // By default we start a new chat. To continue a previous session —
@@ -1031,7 +1030,7 @@ async function main() {
             }
         }
         await autoReload();
-        await mod.runTask(runTaskDeps(), browser, tools, task, currentWorkdir, {
+        const result = await mod.runTask(runTaskDeps(), browser, tools, task, currentWorkdir, {
             transcript,
             freshChat,
             sendSystemPrompt,
@@ -1041,11 +1040,15 @@ async function main() {
                     saveLastChat(chatId, currentWorkdir);
             },
         });
+        // One-shot mode (--task) is documented for scripts/CI. A failed agent run
+        // used to exit 0, so the CI job stayed green; surface it as exit code 1.
+        if (!result.ok)
+            process.exitCode = 1;
         await browser.close();
         await mod.closeWeb().catch(() => { });
         if (mcpPool)
             await mcpPool.close().catch(() => { });
-        transcript.close();
+        await transcript.close();
         return;
     }
     console.log(theme.system(t('msg.interactive')));
@@ -1203,7 +1206,7 @@ async function main() {
         await mod.closeWeb().catch(() => { });
         if (mcpPool)
             await mcpPool.close().catch(() => { });
-        transcript.close();
+        await transcript.close();
         console.log(theme.dim(t('msg.exit_summary', {
             transcript: transcript.file || t('common.off'),
             chat: currentChatId || t('chats.not_created'),
@@ -2817,13 +2820,12 @@ async function main() {
             console.log(theme.system(t('retry.running')));
             // Re-send the last task into the SAME chat (no new chat, no system
             // prompt), so a truncated/empty answer can be retried cheaply.
-            const tools = mod.createTools(currentWorkdir, {
+            const baseTools = mod.createTools(currentWorkdir, {
                 undo,
                 todos: todoStore,
                 readOnly: planMode,
             });
-            if (mcpPool)
-                tools.push(...mcpPool.tools);
+            const tools = mergeTools(baseTools, mcpPool?.tools, planMode);
             if (editor)
                 editor.busy = true;
             try {
@@ -3027,13 +3029,12 @@ async function main() {
                 continue;
             }
             console.log(theme.system(t('improve.start', { id: item.id, title: item.title })));
-            const improveTools = mod.createTools(currentWorkdir, {
+            const improveBase = mod.createTools(currentWorkdir, {
                 undo,
                 todos: todoStore,
                 readOnly: planMode,
             });
-            if (mcpPool)
-                improveTools.push(...mcpPool.tools);
+            const improveTools = mergeTools(improveBase, mcpPool?.tools, planMode);
             if (editor)
                 editor.busy = true;
             try {
@@ -3367,13 +3368,12 @@ async function main() {
             if (cp)
                 transcript.log('checkpoint', { stamp: cp.stamp });
         }
-        const tools = mod.createTools(currentWorkdir, {
+        const baseTools = mod.createTools(currentWorkdir, {
             undo,
             todos: todoStore,
             readOnly: planMode,
         });
-        if (mcpPool)
-            tools.push(...mcpPool.tools);
+        const tools = mergeTools(baseTools, mcpPool?.tools, planMode);
         if (editor)
             editor.busy = true;
         try {
@@ -3450,7 +3450,7 @@ async function main() {
     await mod.closeWeb().catch(() => { });
     if (mcpPool)
         await mcpPool.close().catch(() => { });
-    transcript.close();
+    await transcript.close();
     // One dim line so the operator can find the log and the session after
     // the run (previously the path was only available via /transcript).
     console.log(theme.dim(t('msg.exit_summary', {

package/dist/input.js

@@ -3,12 +3,16 @@ import { renderMarkdown } from './markdown.js';
 import { randomThinkingPhrase, stripEllipsis, DOTS, renderDots, } from './spinner.js';
 import { translate } from './i18n.js';
 import { AttachmentStore, parseImagePaste, looksLikeFilePath, } from './attachments.js';
-import { NL, CR, ESC, PASTE_START, PASTE_END, SUGGEST_PAGE, isSubsequence, pasteReplacement, expandPastes, safeJson, visRows, visLen, layoutInput, formatTokenStatus, tokenStatusLevel, truncateToWidth, CONTEXT_LIMIT, } from './input/layout.js';
+import { NL, CR, ESC, PASTE_START, PASTE_END, SUGGEST_PAGE, isSubsequence, pasteReplacement, expandPastes, safeJson, visRows, visLen, charWidth, layoutInput, formatTokenStatus, tokenStatusLevel, truncateToWidth, CONTEXT_LIMIT, } from './input/layout.js';
 // The pure layout/formatting helpers (visual rows, cursor position, visible
 // width, paste markers, token formatting) live in ./input/layout.js. They are
 // re-exported here so every existing import from './input.js' keeps working,
 // and so tests can import them from either module (C3 step 3).
 export { PASTE_MIN_LINES, SUGGEST_PAGE, isSubsequence, countPasteLines, formatPasteMarker, pasteReplacement, expandPastes, visRows, visLen, charWidth, layoutInput, tokenStatusLevel, formatTokenStatus, formatCompactTokens, truncateToWidth, CONTEXT_LIMIT, CONTEXT_YELLOW_PCT, CONTEXT_RED_PCT, } from './input/layout.js';
+// How long a lone ESC is held before it is treated as the Escape key (and not
+// as the head of a control sequence split across two reads). 40ms is below a
+// human "two Escapes" interval but above typical chunk-split latency.
+export const ESC_DISAMBIGUATE_MS = 40;
 // A permanent input line at the bottom of the terminal + a status/output area above it.
 //
 // Why a custom editor:
@@ -87,6 +91,11 @@ export class LineEditor {
     // is stored so it can be removed in dispose().
     _onResize;
     _resizeTimer;
+    // ESC disambiguation (N29): a read may end on a bare ESC that is really the
+    // head of a control sequence split across two reads. We hold it briefly and
+    // fire onEscape only if no tail arrives.
+    _escPending;
+    _escTimer;
     // History of sent messages (for the up/down arrows).
     history;
     _histIndex;
@@ -195,6 +204,8 @@ export class LineEditor {
         this._wasRaw = false;
         this._onData = (b) => this._handle(b);
         this._resizeTimer = null;
+        this._escPending = false;
+        this._escTimer = null;
         this._onResize = () => {
             // Debounce: a window drag fires a burst of SIGWINCH events. We wait a
             // short moment, then redraw the block at the NEW width.
@@ -462,6 +473,19 @@ export class LineEditor {
         }
         this._renderInputOnly();
     }
+    // PageUp/PageDown: page the suggestion window by a full SUGGEST_PAGE. When
+    // no list is open it is a no-op (PageUp/Down used to be swallowed entirely).
+    _suggestPage(delta) {
+        const sugg = this._suggestions();
+        if (!sugg.length)
+            return;
+        const max = sugg.length - 1;
+        const base = this._suggestSelected < 0 ? 0 : this._suggestSelected;
+        const next = base + delta * SUGGEST_PAGE;
+        this._suggestSelected = Math.max(0, Math.min(max, next));
+        this._suggestOffset = Math.max(0, Math.min(this._suggestSelected, sugg.length - SUGGEST_PAGE));
+        this._renderInputOnly();
+    }
     // Tab: complete the command up to the common prefix; if there is a single
     // match — insert it whole and add a space.
     _completeCommand() {
@@ -526,6 +550,8 @@ export class LineEditor {
         process.stdout.removeListener('resize', this._onResize);
         if (this._resizeTimer)
             clearTimeout(this._resizeTimer);
+        if (this._escTimer)
+            clearTimeout(this._escTimer);
         process.stdout.write(ESC + '[?2004l');
         this._stopDots();
         if (this.rendered)
@@ -1314,36 +1340,54 @@ export class LineEditor {
         const lay = layoutInput(this.promptStr, this.buf, this.cursor, cols);
         return lay.cursorRow === lay.rows.length - 1;
     }
+    // Bare ESC: wait a moment for a possible control-sequence tail before firing
+    // onEscape. Without this a sequence split across two reads (ESC, then "[A")
+    // looked like a lone Escape and aborted the current generation (N29).
+    _scheduleEscape() {
+        this._escPending = true;
+        if (this._escTimer)
+            clearTimeout(this._escTimer);
+        this._escTimer = setTimeout(() => {
+            this._escTimer = null;
+            if (!this._escPending)
+                return;
+            this._escPending = false;
+            if (this.onEscape)
+                this.onEscape();
+        }, ESC_DISAMBIGUATE_MS);
+        if (this._escTimer.unref)
+            this._escTimer.unref();
+    }
+    // Move the cursor `delta` visual rows (not logical lines) and land in the
+    // column closest to the current one. A long line wraps over several visual
+    // rows; the old _up/_down moved by LOGICAL lines only, so on a wrapped row
+    // Up did nothing and Down skipped a whole logical line. The column is
+    // measured in COLUMNS (layoutInput's cursorCol), so wide chars/emoji land on
+    // the right cell. Returns false when the target row is off the buffer.
+    _visualMoveRows(delta) {
+        const cols = process.stdout.columns || 80;
+        const lay = layoutInput(this.promptStr, this.buf, this.cursor, cols);
+        const target = lay.cursorRow + delta;
+        if (target < 0 || target >= lay.rows.length)
+            return false;
+        const row = lay.rows[target];
+        const rowChars = Array.from(row.text);
+        const promptW = visLen(row.prefix);
+        const want = Math.max(0, lay.cursorCol - promptW);
+        let idx = row.start;
+        let w = 0;
+        while (idx < row.start + rowChars.length && w < want) {
+            w += charWidth(rowChars[idx - row.start].codePointAt(0));
+            idx++;
+        }
+        this.cursor = idx;
+        return true;
+    }
     _up() {
-        const chars = Array.from(this.buf);
-        let start = this.cursor;
-        while (start > 0 && chars[start - 1] !== NL)
-            start--;
-        if (start === 0)
-            return;
-        const col = this.cursor - start;
-        const prevEnd = start - 1;
-        let prevStart = prevEnd;
-        while (prevStart > 0 && chars[prevStart - 1] !== NL)
-            prevStart--;
-        this.cursor = prevStart + Math.min(col, prevEnd - prevStart);
+        this._visualMoveRows(-1);
     }
     _down() {
-        const chars = Array.from(this.buf);
-        let end = this.cursor;
-        while (end < chars.length && chars[end] !== NL)
-            end++;
-        if (end >= chars.length)
-            return;
-        let lineStart = this.cursor;
-        while (lineStart > 0 && chars[lineStart - 1] !== NL)
-            lineStart--;
-        const col = this.cursor - lineStart;
-        const nextStart = end + 1;
-        let nextEnd = nextStart;
-        while (nextEnd < chars.length && chars[nextEnd] !== NL)
-            nextEnd++;
-        this.cursor = nextStart + Math.min(col, nextEnd - nextStart);
+        this._visualMoveRows(1);
     }
     // Move one word back (Ctrl+Left / Alt+B): skip spaces
     // on the left, then go to the start of the word.
@@ -1524,9 +1568,22 @@ export class LineEditor {
             }
             return;
         }
+        // A previous read ended on a bare ESC. That is ambiguous: the Escape key
+        // or the head of a control sequence split across reads (arrows, Ctrl+Del).
+        // Reattach the ESC and parse the whole sequence, so a split arrow does not
+        // abort the generation (N29).
+        if (this._escPending) {
+            this._escPending = false;
+            if (this._escTimer) {
+                clearTimeout(this._escTimer);
+                this._escTimer = null;
+            }
+            s = ESC + s;
+        }
         if (!this._inPaste && s === ESC && !this._searchMode) {
-            if (this.onEscape)
-                this.onEscape();
+            // Bare ESC in its own chunk: wait a moment for the possible tail of a
+            // control sequence before treating it as the Escape key.
+            this._scheduleEscape();
             return;
         }
         // While the reverse search (Ctrl+R) is active, the editor is in a modal
@@ -1728,6 +1785,12 @@ export class LineEditor {
                 this._renderInputOnly();
                 continue;
             }
+            if (code === 12) {
+                // Ctrl+L — clear the screen and repaint the input block (the standard
+                // shell binding; it was silently swallowed before).
+                this.clearScreen();
+                continue;
+            }
             if (code === 127 || code === 8) {
                 this._pushUndo(true);
                 this._backspace();
@@ -1780,6 +1843,24 @@ export class LineEditor {
                     this._renderInputOnly();
                     continue;
                 }
+                // Same CSI-u protocol for Delete: Ctrl+Delete is CSI 3;5u (Alt 3;3u),
+                // plain Delete is CSI 3u — without the tilde. Missing these made the
+                // key silently dead on kitty/foot/WezTerm, while the tilde forms above
+                // worked (N27).
+                if (s.startsWith('[3;5u') || s.startsWith('[3;3u')) {
+                    this._pushUndo();
+                    this._deleteWordRight();
+                    s = s.slice(5);
+                    this._renderInputOnly();
+                    continue;
+                }
+                if (s.startsWith('[3u')) {
+                    this._pushUndo(true);
+                    this._delete();
+                    s = s.slice(3);
+                    this._renderInputOnly();
+                    continue;
+                }
                 if (s.startsWith('[D')) {
                     this._left();
                     s = s.slice(2);
@@ -1823,6 +1904,19 @@ export class LineEditor {
                     this._renderInputOnly();
                     continue;
                 }
+                // PageUp / PageDown (ESC[5~ / ESC[6~) — page the slash-command
+                // suggestion list, which is otherwise only reachable with Ctrl+N/P.
+                // Without this the sequence fell through to the generic skip.
+                if (s.startsWith('[5~')) {
+                    this._suggestPage(-1);
+                    s = s.slice(3);
+                    continue;
+                }
+                if (s.startsWith('[6~')) {
+                    this._suggestPage(1);
+                    s = s.slice(3);
+                    continue;
+                }
                 if (s.startsWith('[3~')) {
                     this._pushUndo(true);
                     this._delete();
@@ -1846,6 +1940,16 @@ export class LineEditor {
                 let j = 0;
                 while (j < s.length && !/[A-Za-z~]/.test(s[j]))
                     j++;
+                const skipped = s.slice(0, j + 1);
+                // Surface a swallowed sequence in debug mode: an unrecognized control
+                // sequence used to be skipped SILENTLY, which is how a dead key looked
+                // like a frozen editor with no way to tell why.
+                if (process.env.ZAMES_DEBUG_KEYS && skipped.length > 1) {
+                    process.stderr.write(String.fromCharCode(10) +
+                        '[keys] unhandled: ' +
+                        JSON.stringify(skipped) +
+                        String.fromCharCode(10));
+                }
                 s = s.slice(j + 1);
                 continue;
             }

package/dist/mcp.js

@@ -34,13 +34,6 @@ export function floatingVersionWarnings(servers) {
     }
     return out;
 }
-/** Names of the servers found in a config, before any connection. */
-export async function listConfiguredServers(workdir) {
-    const files = await discoverConfigFiles(workdir);
-    const config = await loadConfigFiles(files);
-    const servers = config.mcpServers || {};
-    return Object.keys(servers).filter((n) => !servers[n].disabled);
-}
 // @playwright/mcp defaults its --user-data-dir to the SAME profile zames uses
 // (~/.zames/profile). Two chromium instances on one profile break each other:
 // the chat page shows "Something went wrong when opening your profile" and
@@ -179,14 +172,32 @@ export function describeParamsExternally(description, schema) {
     }
 }
 /* ---------- result rendering ---------- */
+// Cap on the MCP result string handed to the model. MCP results (e.g.
+// browser_snapshot) can be hundreds of KB; without a cap a single call floods
+// the context and speeds up rate-limiting/truncation. Chosen to match the
+// magnitude of the built-in tools' truncation.
+export const MCP_RESULT_LIMIT = 12_000;
+// Truncate a tool-result string with an explicit marker (the model must be able
+// to tell it is looking at a partial output). Exported for tests.
+export function truncateMcpResult(s, limit = MCP_RESULT_LIMIT) {
+    const str = String(s);
+    if (str.length <= limit)
+        return str;
+    const head = str.slice(0, limit);
+    // Prefer a line boundary so a cut does not split a line in half.
+    const nl = head.lastIndexOf(String.fromCharCode(10));
+    const cut = nl > limit * 0.5 ? head.slice(0, nl + 1) : head;
+    const omitted = str.length - cut.length;
+    return cut + `\n[...truncated ${omitted} chars]`;
+}
 // MCP tool results are a list of content blocks (text, image, resource, ...)
 // and an isError flag. The agent needs a single string for the tool result
 // message. Images are summarized (the model cannot see them through
 // DeepSeek web anyway), text is joined.
-export function renderMcpResult(result) {
+export function renderMcpResult(result, limit = MCP_RESULT_LIMIT) {
     const r = (result || {});
     if (r.toolResult !== undefined && !r.content) {
-        return formatResultString(r.toolResult, r.isError);
+        return truncateMcpResult(formatResultString(r.toolResult, r.isError), limit);
     }
     const parts = [];
     for (const block of r.content || []) {
@@ -236,7 +247,7 @@ export function renderMcpResult(result) {
         .filter((p) => p !== '')
         .join(String.fromCharCode(10) + String.fromCharCode(10))
         .trim();
-    return formatResultString(text || '(MCP tool returned no content)', r.isError);
+    return truncateMcpResult(formatResultString(text || '(MCP tool returned no content)', r.isError), limit);
 }
 function formatResultString(result, isError) {
     const text = typeof result === 'string' ? result : safeJson(result);
@@ -258,6 +269,27 @@ function safeJson(v) {
 export function qualifyToolName(server, tool) {
     return server + '__' + tool.replace(/[^A-Za-z0-9_]/g, '_');
 }
+// Make every tool name unique IN PLACE. agent-loop resolves a call by name and
+// takes the first match, so a duplicate silently shadows the later tool. The
+// qualifier is not injective (see the call site), hence this guard. Pure;
+// exported for tests.
+export function dedupeToolNames(tools) {
+    const seen = new Set();
+    for (const t of tools) {
+        if (!seen.has(t.name)) {
+            seen.add(t.name);
+            continue;
+        }
+        let n = 2;
+        let candidate = `${t.name}_${n}`;
+        while (seen.has(candidate)) {
+            n++;
+            candidate = `${t.name}_${n}`;
+        }
+        t.name = candidate;
+        seen.add(candidate);
+    }
+}
 // Connect to ONE server and return a ready connection (or an error).
 async function connectServer(name, cfg, debug) {
     try {
@@ -352,6 +384,13 @@ export async function createMcpPool(opts) {
             });
         }
     }
+    // Distinct servers can produce the SAME qualified name (server 'a' + tool
+    // 'b__c' vs server 'a__b' + tool 'c'), and agent-loop resolves a call with
+    // tools.find(name) — it takes the FIRST. A duplicate would make the second
+    // tool silently unreachable (the model calls "the right name", a DIFFERENT
+    // tool runs). Rename the later one with a numeric suffix so every name is
+    // unique.
+    dedupeToolNames(tools);
     let closed = false;
     return {
         tools,