zames_pro 2.71.0 → 2.72.0

package/dist/agent-loop.js

@@ -1,13 +1,12 @@
 import { buildSystemPrompt } from './system-prompt.js';
 import { loadProjectContext } from './context.js';
 import { getGitContext, formatGitContext } from './gitTools.js';
-import { parseXmlToolCalls } from './xml-toolcall.js';
 import { translate } from './i18n.js';
 import { substituteAttachmentMarkers } from './commands.js';
-import { normText } from './browser.js';
-import { loadHooks, runPreToolUse, runPostToolUse, } from './hooks.js';
+import { loadHooks, runPreToolUse, runPostToolUse, runLifecycleHooks, } from './hooks.js';
 import { loadPermissions, decidePermission, } from './permissions.js';
-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, hooks = undefined, permissions = undefined, onAskPermission = undefined, selfImprovement = false, onSubagent = null, }) {
+import { shouldRunDiagnostics, runDiagnostics, } from './diagnostics.js';
+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, hooks = undefined, permissions = undefined, diagnostics = null, onAskPermission = undefined, selfImprovement = false, onSubagent = null, }) {
     // Resolve the hook config ONCE per task: a read per tool call would be
     // wasteful, and a mid-task edit of hooks.json is not something to chase.
     // `undefined` means "read .zames/hooks.json"; an explicit null disables
@@ -66,6 +65,14 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     if (freshChat) {
         await browser.newChat();
         transcript?.log('new_chat');
+        // SessionStart hook (N32): a fresh chat is the start of a session, so a
+        // hook can inject context or set up state. Best-effort, output is logged.
+        try {
+            const out = await runLifecycleHooks(hookConfig, 'SessionStart', workdir);
+            if (out)
+                transcript?.log('hook_session_start', { output: out });
+        }
+        catch { }
     }
     // Report the current chat id to the caller.
     let lastReportedChatId = null;
@@ -270,6 +277,15 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // 300s rate-limit wait or the finish loop) while the next iteration
         // started a SECOND ask() against the same page — two sends / two Continue
         // clicks.
+        // UserPromptSubmit hook (N32): runs right before the prompt is sent. Its
+        // stdout is appended to the outgoing message as extra context, mirroring
+        // Claude Code. Best-effort — a hook failure never blocks the send.
+        try {
+            const inject = await runLifecycleHooks(hookConfig, 'UserPromptSubmit', workdir, { prompt: message });
+            if (inject)
+                message = message + String.fromCharCode(10, 10) + inject;
+        }
+        catch { }
         const askPromise = browser.ask(message, {
             agent: !isFirst,
             attachments: isFirst ? attachments : [],
@@ -704,134 +720,164 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                     'repeat the identical call.';
             continue;
         }
-        for (const call of callsToRun) {
-            // `Task` is a SEAM, not an ordinary tool: it is handled by the caller's
-            // onSubagent callback (a separate chat with its own context). It is not
-            // in `tools` when subagents are disabled, so it is matched by name here
-            // BEFORE the unknown-tool branch. With no callback we answer honestly
-            // instead of pretending the tool exists.
-            if (call.tool === 'Task') {
-                const rawPrompt = typeof call.args.prompt === 'string' ? call.args.prompt.trim() : '';
-                const rawType = String(call.args.subagent_type ?? '').toLowerCase();
-                const subType = rawType === 'explore' ? 'explore' : 'general';
-                const rawDesc = typeof call.args.description === 'string' ? call.args.description : '';
-                if (!onSubagent || !rawPrompt) {
-                    const err = !onSubagent
-                        ? 'Subagents are not available in this run. Do the work yourself with the other tools.'
-                        : 'Task requires a non-empty `prompt` argument.';
-                    safeToolResult(err);
-                    transcript?.log('tool_error', { tool: 'Task', error: err });
-                    results.push({ tool: 'Task', result: err });
-                    continue;
-                }
-                syncToolAbort();
-                safeToolCall('Task', call.args);
-                transcript?.log('subagent_start', {
-                    type: subType,
-                    description: rawDesc,
-                    prompt: rawPrompt,
-                });
-                const poll = setInterval(syncToolAbort, 100);
-                if (typeof poll.unref === 'function')
-                    poll.unref();
-                const subStart = Date.now();
-                let subResult;
+        // N34: several READ-ONLY calls in one batch are independent, so run them
+        // concurrently instead of one-by-one (the model often emits 4-6 Reads in a
+        // single answer and each awaited round-trip added latency). The fast path
+        // is deliberately NARROW: it is taken only when EVERY call is a known
+        // read-only tool, no PreToolUse hook is configured (hooks can block/deny)
+        // and no call matches an `ask` permission rule (a concurrent operator
+        // prompt would race). Anything else keeps the strict sequential loop, so
+        // mutating side effects never reorder.
+        const PARALLEL_SAFE = new Set(['Read', 'Glob', 'Grep', 'LS', 'WebFetch']);
+        const readOnlyBatch = callsToRun.length > 1 &&
+            !(hookConfig.PreToolUse && hookConfig.PreToolUse.length) &&
+            callsToRun.every((c) => PARALLEL_SAFE.has(c.tool) &&
+                tools.some((t) => t.name === c.tool) &&
+                decidePermission(permissionPolicy, c.tool, c.args).action !== 'ask');
+        if (readOnlyBatch) {
+            for (const c of callsToRun) {
+                safeToolCall(c.tool, c.args);
+                transcript?.log('tool_call', { tool: c.tool, args: c.args });
+            }
+            // Results are pushed in the ORIGINAL order below, so the model sees the
+            // batch as before — only the waiting overlaps.
+            const settled = await Promise.all(callsToRun.map(async (c) => {
+                const tool = tools.find((t) => t.name === c.tool);
+                const toolStart = Date.now();
+                let result;
                 try {
-                    subResult = await onSubagent({
-                        prompt: rawPrompt,
-                        description: rawDesc,
-                        type: subType,
-                    });
+                    result = await tool.fn(c.args, { signal: toolAbort.signal });
                 }
                 catch (e) {
-                    subResult = {
-                        ok: false,
-                        text: `Subagent error: ${e.message}`,
-                    };
-                }
-                finally {
-                    clearInterval(poll);
-                }
-                const subText = String(subResult.text || '').trim();
-                const subOut = subResult.ok
-                    ? subText || '(the subagent returned no report)'
-                    : `Subagent failed: ${subText || 'unknown error'}`;
-                safeToolResult(subOut);
-                transcript?.log('subagent_done', {
-                    type: subType,
-                    ok: subResult.ok,
-                    chars: subText.length,
-                    durationMs: Date.now() - subStart,
-                });
-                results.push({ tool: 'Task', result: subOut });
-                // The subagent switched the chat underneath us and the callback has
-                // already restored the parent chat. Clear the stale-echo baseline:
-                // the capture left over from the subagent's chat would otherwise make
-                // the watchdog compare the parent's next answer against IT and fire.
-                lastRaw = '';
-                if (browser._abort || browser._stopped) {
-                    transcript?.log('user_aborted');
-                    return '(прервано пользователем)';
+                    result = `Error: ${e.message}`;
                 }
-                continue;
-            }
-            const tool = tools.find((t) => t.name === call.tool);
-            if (!tool) {
-                const err = `Unknown tool: ${call.tool}`;
-                safeToolResult(err);
-                transcript?.log('tool_error', { tool: call.tool, error: err });
-                results.push({ tool: call.tool, result: err });
-                continue;
-            }
-            // The operator may have pressed Esc while we were parsing/among the
-            // previous calls — make sure the signal reflects it before we start.
-            syncToolAbort();
-            safeToolCall(call.tool, call.args);
-            transcript?.log('tool_call', { tool: call.tool, args: call.args });
-            // PreToolUse hooks run BEFORE the tool. A non-zero exit BLOCKS the call:
-            // its output becomes the tool result and the tool itself never runs.
-            // Best-effort by design — hooks must not be able to kill the loop.
-            const denial = await runPreToolUse(hookConfig, call.tool, call.args, workdir);
-            if (denial !== null) {
-                const blocked = `Blocked by PreToolUse hook: ${denial}`;
-                transcript?.log('hook_pre_deny', { tool: call.tool, reason: denial });
-                safeToolResult(blocked);
+                return { call: c, result, toolMs: Date.now() - toolStart };
+            }));
+            for (const { call: c, result, toolMs } of settled) {
+                safeToolResult(result);
                 transcript?.log('tool_result', {
-                    tool: call.tool,
-                    result: blocked,
+                    tool: c.tool,
+                    result: String(result),
+                    durationMs: toolMs,
                 });
-                results.push({ tool: call.tool, result: blocked });
-                continue;
+                results.push({ tool: c.tool, result });
             }
-            // Approval policy (C1): a `deny` rule blocks the call (like a PreToolUse
-            // denial); an `ask` rule prompts the operator. Hooks stay authoritative
-            // for programmatic guards — this is the human-in-the-loop layer.
-            const decision = decidePermission(permissionPolicy, call.tool, call.args);
-            if (decision.action === 'deny') {
-                const blocked = `Blocked by permission policy: ${decision.reason}`;
-                transcript?.log('permission_deny', {
-                    tool: call.tool,
-                    reason: decision.reason,
-                });
-                safeToolResult(blocked);
-                transcript?.log('tool_result', {
-                    tool: call.tool,
-                    result: blocked,
-                });
-                results.push({ tool: call.tool, result: blocked });
-                continue;
+            // Same abort contract as the sequential loop: an Esc during the batch
+            // must stop before its results are fed to the model.
+            if (browser._abort || browser._stopped) {
+                transcript?.log('user_aborted');
+                return '(прервано пользователем)';
             }
-            if (decision.action === 'ask' && onAskPermission) {
-                let allowed;
-                try {
-                    allowed = await onAskPermission({ ...decision, tool: call.tool });
+        }
+        if (!readOnlyBatch)
+            for (const call of callsToRun) {
+                // `Task` is a SEAM, not an ordinary tool: it is handled by the caller's
+                // onSubagent callback (a separate chat with its own context). It is not
+                // in `tools` when subagents are disabled, so it is matched by name here
+                // BEFORE the unknown-tool branch. With no callback we answer honestly
+                // instead of pretending the tool exists.
+                if (call.tool === 'Task') {
+                    const rawPrompt = typeof call.args.prompt === 'string' ? call.args.prompt.trim() : '';
+                    const rawType = String(call.args.subagent_type ?? '').toLowerCase();
+                    const subType = rawType === 'explore' ? 'explore' : 'general';
+                    const rawDesc = typeof call.args.description === 'string'
+                        ? call.args.description
+                        : '';
+                    if (!onSubagent || !rawPrompt) {
+                        const err = !onSubagent
+                            ? 'Subagents are not available in this run. Do the work yourself with the other tools.'
+                            : 'Task requires a non-empty `prompt` argument.';
+                        safeToolResult(err);
+                        transcript?.log('tool_error', { tool: 'Task', error: err });
+                        results.push({ tool: 'Task', result: err });
+                        continue;
+                    }
+                    syncToolAbort();
+                    safeToolCall('Task', call.args);
+                    transcript?.log('subagent_start', {
+                        type: subType,
+                        description: rawDesc,
+                        prompt: rawPrompt,
+                    });
+                    const poll = setInterval(syncToolAbort, 100);
+                    if (typeof poll.unref === 'function')
+                        poll.unref();
+                    const subStart = Date.now();
+                    let subResult;
+                    try {
+                        subResult = await onSubagent({
+                            prompt: rawPrompt,
+                            description: rawDesc,
+                            type: subType,
+                        });
+                    }
+                    catch (e) {
+                        subResult = {
+                            ok: false,
+                            text: `Subagent error: ${e.message}`,
+                        };
+                    }
+                    finally {
+                        clearInterval(poll);
+                    }
+                    const subText = String(subResult.text || '').trim();
+                    const subOut = subResult.ok
+                        ? subText || '(the subagent returned no report)'
+                        : `Subagent failed: ${subText || 'unknown error'}`;
+                    safeToolResult(subOut);
+                    transcript?.log('subagent_done', {
+                        type: subType,
+                        ok: subResult.ok,
+                        chars: subText.length,
+                        durationMs: Date.now() - subStart,
+                    });
+                    results.push({ tool: 'Task', result: subOut });
+                    // The subagent switched the chat underneath us and the callback has
+                    // already restored the parent chat. Clear the stale-echo baseline:
+                    // the capture left over from the subagent's chat would otherwise make
+                    // the watchdog compare the parent's next answer against IT and fire.
+                    lastRaw = '';
+                    if (browser._abort || browser._stopped) {
+                        transcript?.log('user_aborted');
+                        return '(прервано пользователем)';
+                    }
+                    continue;
                 }
-                catch {
-                    allowed = false;
+                const tool = tools.find((t) => t.name === call.tool);
+                if (!tool) {
+                    const err = `Unknown tool: ${call.tool}`;
+                    safeToolResult(err);
+                    transcript?.log('tool_error', { tool: call.tool, error: err });
+                    results.push({ tool: call.tool, result: err });
+                    continue;
                 }
-                if (!allowed) {
-                    const blocked = `Denied by operator: ${decision.reason}`;
-                    transcript?.log('permission_denied', {
+                // The operator may have pressed Esc while we were parsing/among the
+                // previous calls — make sure the signal reflects it before we start.
+                syncToolAbort();
+                safeToolCall(call.tool, call.args);
+                transcript?.log('tool_call', { tool: call.tool, args: call.args });
+                // PreToolUse hooks run BEFORE the tool. A non-zero exit BLOCKS the call:
+                // its output becomes the tool result and the tool itself never runs.
+                // Best-effort by design — hooks must not be able to kill the loop.
+                const denial = await runPreToolUse(hookConfig, call.tool, call.args, workdir);
+                if (denial !== null) {
+                    const blocked = `Blocked by PreToolUse hook: ${denial}`;
+                    transcript?.log('hook_pre_deny', { tool: call.tool, reason: denial });
+                    safeToolResult(blocked);
+                    transcript?.log('tool_result', {
+                        tool: call.tool,
+                        result: blocked,
+                    });
+                    results.push({ tool: call.tool, result: blocked });
+                    continue;
+                }
+                // Approval policy (C1): a `deny` rule blocks the call (like a PreToolUse
+                // denial); an `ask` rule prompts the operator. Hooks stay authoritative
+                // for programmatic guards — this is the human-in-the-loop layer.
+                const decision = decidePermission(permissionPolicy, call.tool, call.args);
+                if (decision.action === 'deny') {
+                    const blocked = `Blocked by permission policy: ${decision.reason}`;
+                    transcript?.log('permission_deny', {
                         tool: call.tool,
                         reason: decision.reason,
                     });
@@ -843,56 +889,91 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                     results.push({ tool: call.tool, result: blocked });
                     continue;
                 }
-            }
-            let result;
-            // While the tool runs, poll for an Esc/Ctrl+C: the abort flag is a plain
-            // boolean set by stopGeneration(), so the only way to turn it into a
-            // child-process kill is to check it periodically. 100ms is cheap and
-            // makes Esc feel immediate.
-            const poll = setInterval(syncToolAbort, 100);
-            if (typeof poll.unref === 'function')
-                poll.unref();
-            // Time the tool (T-D3): the transcript carries durationMs so /cost can
-            // show where the time goes (frequent Read→Edit cycles vs slow Bash).
-            const toolStart = Date.now();
-            try {
-                result = await tool.fn(call.args, { signal: toolAbort.signal });
-            }
-            catch (e) {
-                result = `Error: ${e.message}`;
-            }
-            finally {
-                clearInterval(poll);
-            }
-            const toolMs = Date.now() - toolStart;
-            // PostToolUse hooks run AFTER the tool; their stdout is appended to the
-            // result (e.g. `prettier` output) before it is fed back to the model.
-            // Best-effort: a hook failure is ignored, the tool result still stands.
-            const post = await runPostToolUse(hookConfig, call.tool, call.args, String(result), workdir);
-            if (post) {
-                transcript?.log('hook_post_output', { tool: call.tool, output: post });
-                result = `${String(result)}
+                if (decision.action === 'ask' && onAskPermission) {
+                    let allowed;
+                    try {
+                        allowed = await onAskPermission({ ...decision, tool: call.tool });
+                    }
+                    catch {
+                        allowed = false;
+                    }
+                    if (!allowed) {
+                        const blocked = `Denied by operator: ${decision.reason}`;
+                        transcript?.log('permission_denied', {
+                            tool: call.tool,
+                            reason: decision.reason,
+                        });
+                        safeToolResult(blocked);
+                        transcript?.log('tool_result', {
+                            tool: call.tool,
+                            result: blocked,
+                        });
+                        results.push({ tool: call.tool, result: blocked });
+                        continue;
+                    }
+                }
+                let result;
+                // While the tool runs, poll for an Esc/Ctrl+C: the abort flag is a plain
+                // boolean set by stopGeneration(), so the only way to turn it into a
+                // child-process kill is to check it periodically. 100ms is cheap and
+                // makes Esc feel immediate.
+                const poll = setInterval(syncToolAbort, 100);
+                if (typeof poll.unref === 'function')
+                    poll.unref();
+                // Time the tool (T-D3): the transcript carries durationMs so /cost can
+                // show where the time goes (frequent Read→Edit cycles vs slow Bash).
+                const toolStart = Date.now();
+                try {
+                    result = await tool.fn(call.args, { signal: toolAbort.signal });
+                }
+                catch (e) {
+                    result = `Error: ${e.message}`;
+                }
+                finally {
+                    clearInterval(poll);
+                }
+                const toolMs = Date.now() - toolStart;
+                // PostToolUse hooks run AFTER the tool; their stdout is appended to the
+                // result (e.g. `prettier` output) before it is fed back to the model.
+                // Best-effort: a hook failure is ignored, the tool result still stands.
+                const post = await runPostToolUse(hookConfig, call.tool, call.args, String(result), workdir);
+                if (post) {
+                    transcript?.log('hook_post_output', { tool: call.tool, output: post });
+                    result = `${String(result)}
 
 [PostToolUse hook]
 ${post}`;
+                }
+                // N38: after a file-mutating tool, run the project's own check and
+                // append its summary, so a type error reaches the model immediately
+                // instead of costing a whole round-trip. Best-effort and capped.
+                if (shouldRunDiagnostics(diagnostics, call.tool)) {
+                    const diag = runDiagnostics(workdir, diagnostics);
+                    if (diag) {
+                        transcript?.log('diagnostics', { tool: call.tool, output: diag });
+                        result = `${String(result)}
+
+[diagnostics]
+${diag}`;
+                    }
+                }
+                safeToolResult(result);
+                transcript?.log('tool_result', {
+                    tool: call.tool,
+                    result: String(result),
+                    durationMs: toolMs,
+                });
+                results.push({ tool: call.tool, result });
+                // The operator pressed Esc/Ctrl+C while the tool was running. The tool
+                // itself has finished (we cannot kill an arbitrary child process from
+                // here), but we must NOT feed its result back to the model and must NOT
+                // run the remaining calls in this batch — that would keep the agent
+                // going after an explicit stop.
+                if (browser._abort || browser._stopped) {
+                    transcript?.log('user_aborted');
+                    return '(прервано пользователем)';
+                }
             }
-            safeToolResult(result);
-            transcript?.log('tool_result', {
-                tool: call.tool,
-                result: String(result),
-                durationMs: toolMs,
-            });
-            results.push({ tool: call.tool, result });
-            // The operator pressed Esc/Ctrl+C while the tool was running. The tool
-            // itself has finished (we cannot kill an arbitrary child process from
-            // here), but we must NOT feed its result back to the model and must NOT
-            // run the remaining calls in this batch — that would keep the agent
-            // going after an explicit stop.
-            if (browser._abort || browser._stopped) {
-                transcript?.log('user_aborted');
-                return '(прервано пользователем)';
-            }
-        }
         // A tool just ran — the next answer is expected to be a fresh tool call.
         // Reset the watchdog so the next empty/repeated answer is nudged.
         justRanTool = true;
@@ -1009,759 +1090,9 @@ ${post}`;
     }
     return 'Iteration limit reached.';
 }
-// Cap a tool result for the model, but make the truncation EXPLICIT: a bare
-// slice() silently hid the tail and the model had no idea it was looking at a
-// partial output (it would act on a half-read file/log).
-export function truncateToolResult(text, limit) {
-    if (text.length <= limit)
-        return text;
-    // Prefer a LINE boundary near the limit so the model does not read a line
-    // cut in half (a half line is easy to misread as the real content). We look
-    // for the last newline within the last 20% of the window; if none, fall back
-    // to the hard char cut.
-    let cut = limit;
-    const NL = String.fromCharCode(10);
-    const searchFrom = Math.floor(limit * 0.8);
-    const nl = text.lastIndexOf(NL, limit);
-    // Cut AFTER the newline (include it) so the kept part is a whole number of
-    // lines — a cut that EXCLUDED the newline left a half line before the marker.
-    if (nl >= searchFrom)
-        cut = nl + 1;
-    const omitted = text.length - cut;
-    return text.slice(0, cut) + NL + `[...truncated ${omitted} chars]`;
-}
-// The answer looks like a tool call, but parseToolCall() did not recognize it.
-// Used as a safeguard against "the agent called a tool and stopped": in that
-// case runAgentLoop asks the model to resend the call instead of finishing the
-// task. We catch both explicit formats and "broken" call heads
-// (`<｜tool": ...`, `**tool**:`, `tool": ...`), and truncated calls.
-export function responseLooksLikeToolCall(rawResponse) {
-    const raw = rawResponse || '';
-    return (
-    // Explicit tool-call format markers: the JSON key "tool", XML/DSML tags,
-    // function_call, etc.
-    /("tool"\s*:|\btool_calls?\b|\binvoke\b|\bparameter\b|DSML|function_call)/i.test(raw) ||
-        // "tool" without an opening quote/bracket, with a junk prefix
-        // (`<｜tool":`, `**tool**:`, `- tool:`): a call key, not prose.
-        /(^|[^A-Za-z0-9_])(?:\*\*)?tool(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/.test(raw) ||
-        // Keys in single quotes or unquoted: {'tool': 'Read', ...}.
-        /[\{\[]\s*['"]?(tool|name|args)['"]?\s*:/.test(raw) ||
-        // Truncated call: starts like a JSON object but is not closed, and has an
-        // 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*\|?\s*(DSML|invoke|parameter)/i.test(raw) ||
-        /^\s*\[?\s*\{[^}]*$/.test(raw.trim()));
-}
-// A respond message is only a real FINAL answer when it carries some meaning.
-// DeepSeek sometimes finishes with a placeholder — "...", "-", "ok", "done",
-// "готово" — which looks like a stop with no report. Such a respond must not
-// end the task silently: it is treated like an empty one (re-ask).
-function isMeaningfulRespond(msg) {
-    const t = (msg || '').trim();
-    if (!t)
-        return false;
-    // Only punctuation/dots/ellipses: "...", "---", "…", "?" — not a report.
-    if (/^[.…–—_*?!/\s-]+$/.test(t))
-        return false;
-    // A bare acknowledgement with no content at all. NOTE: "ok"/"done"/
-    // "готово" are NOT in this list: a short "готово" is a legitimate final
-    // answer for a small task, and dropping it re-opened the loop.
-    if (/^(na|null|undefined)[.!]*$/i.test(t))
-        return false;
-    return true;
-}
-// Normalize an answer for STALE comparison: collapse whitespace AND strip
-// markdown emphasis/code markers. DeepSeek echoes the previous turn with a
-// different emphasis (`**done**` vs `done`), which defeated an exact match and
-// made the loop re-run the same tool ("stopped after a tool call").
-function normForStale(s) {
-    return normText(s)
-        .replace(/[*_`#>]+/g, '')
-        .replace(/[ \t]+/g, ' ')
-        .trim();
-}
-// Text that promises a tool call in the future tense but contains no call
-// itself. DeepSeek regularly "hangs" like this: it writes
-// "Now update README to mention …", "Let me run the tests", "I'll check now"
-// and stops. Such answers must not be taken as final — otherwise the agent
-// stalls without doing the work. We keep the heuristic narrow (future tense /
-// intent) so we don't catch ordinary reports of completed work.
-function looksLikeUnfinishedWork(text) {
-    const t = (text || '').trim();
-    if (!t)
-        return false;
-    // Long answers (reports) are left alone — anything can be in there.
-    if (t.length > 600)
-        return false;
-    // A final marker is already present — treat the answer as complete.
-    if (/\b(done|finished|completed|готово|выполнено|завершено)\b/i.test(t)) {
-        return false;
-    }
-    const en = /\b(now|next|then|let me|let's|i will|i'll|i am going to|i'm going to|going to|about to|will now|time to)\b[^.!?\n]{0,120}\b(update|write|edit|read|run|check|add|fix|create|remove|delete|apply|test|commit|push|install|open|search|look|verify|change|modify|implement|review)\b/i;
-    const ru = /(^|[^а-яё])(проверю|обновлю|исправлю|добавлю|запущу|выполню|посмотрю|прочитаю|изменю|попробую|сделаю)([^а-яё]|$)/i;
-    return en.test(t) || ru.test(t);
-}
-// ============ JSON parsing ============
-function repairRawControlChars(str) {
-    let out = '';
-    let inString = false;
-    let escape = false;
-    for (let i = 0; i < str.length; i++) {
-        const c = str[i];
-        if (escape) {
-            out += c;
-            escape = false;
-            continue;
-        }
-        if (c === '\\') {
-            out += c;
-            escape = true;
-            continue;
-        }
-        if (c === '"') {
-            inString = !inString;
-            out += c;
-            continue;
-        }
-        if (inString) {
-            if (c === '\n') {
-                out += '\\n';
-                continue;
-            }
-            if (c === '\r') {
-                out += '\\r';
-                continue;
-            }
-            if (c === '\t') {
-                out += '\\t';
-                continue;
-            }
-            const code = c.charCodeAt(0);
-            if (code < 0x20) {
-                out += '\\u' + code.toString(16).padStart(4, '0');
-                continue;
-            }
-        }
-        out += c;
-    }
-    return out;
-}
-function tryParse(str) {
-    try {
-        const obj = JSON.parse(str);
-        if (obj &&
-            typeof obj.tool === 'string' &&
-            obj.args &&
-            typeof obj.args === 'object' &&
-            !Array.isArray(obj.args)) {
-            return obj;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-function tryParseArray(str) {
-    try {
-        const arr = JSON.parse(str);
-        if (Array.isArray(arr) &&
-            arr.length > 0 &&
-            arr.every((o) => o &&
-                typeof o.tool === 'string' &&
-                o.args &&
-                typeof o.args === 'object' &&
-                !Array.isArray(o.args))) {
-            return arr;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-function parseArgsGreedy(str) {
-    const result = {};
-    let i = str.indexOf('{') + 1;
-    if (i === 0)
-        return null;
-    const skipWs = () => {
-        while (i < str.length && /[\s,]/.test(str[i]))
-            i++;
-    };
-    while (i < str.length) {
-        skipWs();
-        if (i >= str.length || str[i] === '}')
-            break;
-        if (str[i] !== '"')
-            return null;
-        const keyEnd = str.indexOf('"', i + 1);
-        if (keyEnd === -1)
-            return null;
-        const key = str.slice(i + 1, keyEnd);
-        i = keyEnd + 1;
-        while (i < str.length && /\s/.test(str[i]))
-            i++;
-        if (str[i] !== ':')
-            return null;
-        i++;
-        while (i < str.length && /\s/.test(str[i]))
-            i++;
-        if (str[i] === '"') {
-            let lastEnd = -1;
-            let k = i + 1;
-            while (k < str.length) {
-                if (str.charCodeAt(k) === 92) {
-                    k += 2;
-                    continue;
-                }
-                if (str[k] === '"') {
-                    let t = k + 1;
-                    while (t < str.length && /\s/.test(str[t]))
-                        t++;
-                    if (t >= str.length || str[t] === ',' || str[t] === '}')
-                        lastEnd = k;
-                }
-                k++;
-            }
-            if (lastEnd === -1)
-                return null;
-            result[key] = unescapeValue(str.slice(i + 1, lastEnd));
-            i = lastEnd + 1;
-            continue;
-        }
-        if (str[i] === '{' || str[i] === '[') {
-            const open = str[i];
-            const close = open === '{' ? '}' : ']';
-            const end = findMatching(str, i, open, close);
-            if (end === -1)
-                return null;
-            let parsed = null;
-            try {
-                parsed = JSON.parse(str.slice(i, end + 1));
-            }
-            catch {
-                if (open === '{')
-                    parsed = parseArgsPermissive(str.slice(i, end + 1));
-            }
-            if (parsed === null)
-                return null;
-            result[key] = parsed;
-            i = end + 1;
-            continue;
-        }
-        let j = i;
-        while (j < str.length && !/[,}]/.test(str[j]))
-            j++;
-        const raw = str.slice(i, j).trim();
-        if (raw === 'true')
-            result[key] = true;
-        else if (raw === 'false')
-            result[key] = false;
-        else if (raw === 'null')
-            result[key] = null;
-        else {
-            const n = Number(raw);
-            result[key] = Number.isNaN(n) ? raw : n;
-        }
-        i = j;
-    }
-    return result;
-}
-function parseArgsPermissive(str) {
-    const result = {};
-    let i = 1;
-    while (i < str.length) {
-        while (i < str.length && /[\s,]/.test(str[i]))
-            i++;
-        if (i >= str.length || str[i] === '}')
-            break;
-        if (str[i] !== '"')
-            return null;
-        const keyEnd = str.indexOf('"', i + 1);
-        if (keyEnd === -1)
-            return null;
-        const key = str.slice(i + 1, keyEnd);
-        i = keyEnd + 1;
-        while (i < str.length && /\s/.test(str[i]))
-            i++;
-        if (str[i] !== ':')
-            return null;
-        i++;
-        while (i < str.length && /\s/.test(str[i]))
-            i++;
-        if (str[i] === '"') {
-            let j = i + 1;
-            let value = '';
-            while (j < str.length) {
-                const c = str[j];
-                if (c === '\\' && j + 1 < str.length) {
-                    value += c + str[j + 1];
-                    j += 2;
-                    continue;
-                }
-                if (c === '"') {
-                    let k = j + 1;
-                    while (k < str.length && /\s/.test(str[k]))
-                        k++;
-                    if (k >= str.length ||
-                        str[k] === ',' ||
-                        str[k] === '}' ||
-                        str[k] === ']') {
-                        break;
-                    }
-                    value += '"';
-                    j++;
-                    continue;
-                }
-                value += c;
-                j++;
-            }
-            if (j >= str.length)
-                return null;
-            result[key] = unescapeValue(value);
-            i = j + 1;
-        }
-        else if (str[i] === '{' || str[i] === '[') {
-            const open = str[i];
-            const close = open === '{' ? '}' : ']';
-            const end = findMatching(str, i, open, close);
-            if (end === -1)
-                return null;
-            const frag = str.slice(i, end + 1);
-            let parsedFrag = null;
-            try {
-                parsedFrag = JSON.parse(frag);
-            }
-            catch {
-                if (open === '{')
-                    parsedFrag = parseArgsPermissive(frag);
-            }
-            if (parsedFrag === null)
-                return null;
-            result[key] = parsedFrag;
-            i = end + 1;
-        }
-        else {
-            let j = i;
-            while (j < str.length && !/[,}]/.test(str[j]))
-                j++;
-            const raw = str.slice(i, j).trim();
-            if (raw === 'true')
-                result[key] = true;
-            else if (raw === 'false')
-                result[key] = false;
-            else if (raw === 'null')
-                result[key] = null;
-            else {
-                const n = Number(raw);
-                result[key] = Number.isNaN(n) ? raw : n;
-            }
-            i = j;
-        }
-    }
-    return result;
-}
-function unescapeValue(s) {
-    let out = '';
-    let i = 0;
-    while (i < s.length) {
-        const c = s[i];
-        if (c === '\\' && i + 1 < s.length) {
-            const n = s[i + 1];
-            if (n === 'n') {
-                out += '\n';
-                i += 2;
-                continue;
-            }
-            if (n === 't') {
-                out += '\t';
-                i += 2;
-                continue;
-            }
-            if (n === 'r') {
-                out += '\r';
-                i += 2;
-                continue;
-            }
-            if (n === '"') {
-                out += '"';
-                i += 2;
-                continue;
-            }
-            if (n === '\\') {
-                out += '\\';
-                i += 2;
-                continue;
-            }
-            if (n === '/') {
-                out += '/';
-                i += 2;
-                continue;
-            }
-            if (n === 'u' && i + 5 < s.length) {
-                const hex = s.slice(i + 2, i + 6);
-                if (/^[0-9a-fA-F]{4}$/.test(hex)) {
-                    out += String.fromCharCode(parseInt(hex, 16));
-                    i += 6;
-                    continue;
-                }
-            }
-            out += c + n;
-            i += 2;
-            continue;
-        }
-        out += c;
-        i++;
-    }
-    return out;
-}
-function parseToolCallPermissive(text) {
-    const toolMatch = text.match(/"tool"\s*:\s*"([A-Za-z_][A-Za-z0-9_]*)"/);
-    if (!toolMatch)
-        return null;
-    const tool = toolMatch[1];
-    // The model occasionally puts the argument keys INLINE with "tool" —
-    // {"tool": "Bash", "command": "..."} — with no "args" wrapper at all.
-    // The strict parser rejects it (no obj.args), and the permissive parser
-    // used to bail out too (indexOf('"args"') === -1). Such a call was
-    // reported as malformed and re-asked up to MAX_MALFORMED_RETRIES times;
-    // after the budget ran out the run stopped with the model's text as the
-    // final answer. Flatten the inline keys into args when "args" is absent.
-    if (text.indexOf('"args"') === -1) {
-        const braceIdx = text.indexOf('{');
-        if (braceIdx === -1)
-            return null;
-        const endBrace = findMatching(text, braceIdx, '{', '}');
-        const objText = endBrace === -1
-            ? text.slice(braceIdx)
-            : text.slice(braceIdx, endBrace + 1);
-        const inlineArgs = parseArgsPermissive(objText) || parseArgsGreedy(objText);
-        if (!inlineArgs)
-            return null;
-        delete inlineArgs.tool;
-        // The value may be a string ("command": "...") or a number/bool.
-        return { tool, args: inlineArgs };
-    }
-    const argsIdx = text.indexOf('"args"');
-    if (argsIdx === -1)
-        return null;
-    const openIdx = text.indexOf('{', argsIdx);
-    if (openIdx === -1)
-        return null;
-    const endIdx = findMatching(text, openIdx, '{', '}');
-    if (tool === 'Edit') {
-        const balanced = endIdx === -1 ? null : text.slice(openIdx, endIdx + 1);
-        const tailToEnd = text.slice(openIdx);
-        for (const frag of [balanced, tailToEnd]) {
-            if (!frag)
-                continue;
-            const e = parseEditArgs(frag);
-            if (e)
-                return { tool, args: e };
-        }
-    }
-    const frags = [];
-    if (endIdx !== -1)
-        frags.push(text.slice(openIdx, endIdx + 1));
-    frags.push(text.slice(openIdx));
-    for (const argsStr of frags) {
-        const args = parseArgsPermissive(argsStr);
-        if (args)
-            return { tool, args };
-        const greedy = parseArgsGreedy(argsStr);
-        if (greedy)
-            return { tool, args: greedy };
-    }
-    return null;
-}
-function parseEditArgs(str) {
-    const keyRe = (name) => new RegExp('"' + name + '"\\s*:\\s*"');
-    const readValue = (name, nextNames) => {
-        const m = keyRe(name).exec(str);
-        if (!m)
-            return null;
-        const start = m.index + m[0].length;
-        let end = str.length;
-        for (const n of nextNames) {
-            const mm = keyRe(n).exec(str.slice(start));
-            if (mm) {
-                const absIdx = start + mm.index;
-                if (absIdx < end)
-                    end = absIdx;
-            }
-        }
-        let val = str.slice(start, end);
-        val = val.replace(/"\s*[,}]?\s*$/, '');
-        return val;
-    };
-    const path = readValue('path', ['old_string', 'new_string']);
-    const oldStr = readValue('old_string', ['new_string']);
-    const newStr = readValue('new_string', []);
-    if (path === null || oldStr === null || newStr === null)
-        return null;
-    return { path: path, old_string: oldStr, new_string: newStr };
-}
-function extractJsonObjects(text) {
-    const objects = [];
-    let i = 0;
-    while (i < text.length) {
-        if (text[i] === '{') {
-            const end = findMatching(text, i, '{', '}');
-            if (end !== -1) {
-                objects.push(text.slice(i, end + 1));
-                i = end + 1;
-                continue;
-            }
-        }
-        if (text[i] === '[') {
-            const end = findMatching(text, i, '[', ']');
-            if (end !== -1) {
-                objects.push(text.slice(i, end + 1));
-                i = end + 1;
-                continue;
-            }
-        }
-        i++;
-    }
-    return objects;
-}
-function findMatching(text, openIdx, openCh, closeCh) {
-    let depth = 0;
-    let inString = false;
-    let escape = false;
-    for (let i = openIdx; i < text.length; i++) {
-        const c = text[i];
-        if (escape) {
-            escape = false;
-            continue;
-        }
-        if (c === '\\') {
-            escape = true;
-            continue;
-        }
-        if (c === '"') {
-            inString = !inString;
-            continue;
-        }
-        if (inString)
-            continue;
-        if (c === openCh)
-            depth++;
-        else if (c === closeCh) {
-            depth--;
-            if (depth === 0)
-                return i;
-        }
-    }
-    return -1;
-}
-// The model sometimes returns a tool call with single-quoted keys/strings
-// ("{'tool': 'Read', 'args': {...}}") or unquoted keys
-// ("{tool: \"Read\", args: {...}}"). This is not valid JSON, and without
-// normalization such an answer is silently taken as final — the agent stalls
-// without calling a tool. We normalize it to double quotes.
-function normalizePseudoJson(str) {
-    // Unquoted keys: {tool: ...} or , args: ... → "tool": / "args":
-    let out = str.replace(/([\{\[]\s*)([A-Za-z_][A-Za-z0-9_]*)\s*:/g, '$1"$2":');
-    out = out.replace(/,\s*([A-Za-z_][A-Za-z0-9_]*)\s*:/g, ', "$1":');
-    // Single quotes → double quotes. We don't touch the content of already
-    // double-quoted strings in a row, and escape stray double quotes inside
-    // single quotes.
-    let res = '';
-    let inDouble = false;
-    let inSingle = false;
-    for (let i = 0; i < out.length; i++) {
-        const c = out[i];
-        if (c === '\\' && (inDouble || inSingle)) {
-            res += c;
-            if (i + 1 < out.length) {
-                res += out[i + 1];
-                i++;
-            }
-            continue;
-        }
-        if (c === '"' && !inSingle) {
-            inDouble = !inDouble;
-            res += c;
-            continue;
-        }
-        if (c === "'" && !inDouble) {
-            if (!inSingle) {
-                inSingle = true;
-                res += '"';
-            }
-            else {
-                inSingle = false;
-                res += '"';
-            }
-            continue;
-        }
-        if (inSingle && c === '"') {
-            res += '\\"';
-            continue;
-        }
-        res += c;
-    }
-    return res;
-}
-// The model sometimes corrupts the head of a call: `<｜tool": "Bash", "args": {...}`,
-// `tool": "Read", ...`, `**tool**: ...`, `- tool: ...`. Such answers have no
-// opening `{`, and the `tool` key lost its first quote. If such an answer is
-// taken as final, the agent silently stalls (a frequent "stop").
-// We repair it: trim the junk prefix up to the word tool, add `{` and
-// balance the key quotes.
-function repairToolCallPreamble(text) {
-    const t = (text || '').trim();
-    const m = t.match(/(?:^|[^A-Za-z0-9_])(?:\*\*)?(tool)(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/);
-    if (!m || m.index === undefined)
-        return null;
-    // We look for the start from the first quote/bracket around the key, otherwise from the word tool.
-    let start = m.index;
-    const brace = t.indexOf('{', Math.max(0, start - 1));
-    if (brace !== -1 && brace < start)
-        start = brace;
-    let frag = t.slice(start);
-    // If the fragment does not start with `{` — we add it.
-    if (!frag.startsWith('{')) {
-        // The key may have lost its opening quote: tool": → "tool".
-        // We trim the leading junk up to the word tool and normalize the key quotes.
-        frag = frag.replace(/^[^A-Za-z0-9_]*/, '');
-        frag = frag.replace(/^(?:\*\*)?(["'`\u2018\u2019\u201c\u201d]*)(tool)(?:\*\*)?["'`\u2018\u2019\u201c\u201d]*\s*:/, '"$2":');
-        frag = '{' + frag;
-    }
-    return frag;
-}
-export function parseToolCall(text) {
-    if (!text || typeof text !== 'string')
-        return null;
-    let cleaned = text.trim();
-    cleaned = cleaned
-        .replace(/^```(?:json)?\s*/i, '')
-        .replace(/```$/i, '')
-        .trim();
-    const candidates = extractJsonObjects(cleaned);
-    // We collect EVERY recognized call, not just the first one found. The model
-    // often emits several separate {"tool": ...} objects in one answer instead of
-    // a single JSON array. Returning only one of them used to drop the rest and
-    // could leave the agent "stalled after a tool call" with pending work.
-    const collected = [];
-    const tryCollect = (parsed) => {
-        if (!parsed)
-            return false;
-        if (Array.isArray(parsed))
-            collected.push(...parsed);
-        else
-            collected.push(parsed);
-        return true;
-    };
-    for (let i = 0; i < candidates.length; i++) {
-        const raw = candidates[i];
-        // A JSON array of calls is authoritative: if present, use all of it.
-        const arrFirst = tryParseArray(raw);
-        if (arrFirst)
-            return arrFirst;
-        const arrRepaired = tryParseArray(raw.replace(/\\(?!["\\/bfnrtu])/g, '\\\\'));
-        if (arrRepaired)
-            return arrRepaired;
-        const first = tryParse(raw);
-        if (first) {
-            tryCollect(first);
-            continue;
-        }
-        const repaired = raw.replace(/\\(?!["\\/bfnrtu])/g, '\\\\');
-        const second = tryParse(repaired);
-        if (second) {
-            tryCollect(second);
-            continue;
-        }
-        const ctrl = repairRawControlChars(raw);
-        const third = tryParse(ctrl);
-        if (third) {
-            tryCollect(third);
-            continue;
-        }
-        const ctrlArr = tryParseArray(ctrl);
-        if (ctrlArr)
-            return ctrlArr;
-    }
-    if (collected.length === 1)
-        return collected[0];
-    if (collected.length > 1)
-        return collected;
-    // Pseudo-JSON (single quotes / unquoted keys) — normalize and try to parse
-    // as a regular call before going permissive.
-    if (/['"]?tool['"]?\s*:/.test(cleaned)) {
-        const norm = normalizePseudoJson(cleaned);
-        if (norm !== cleaned) {
-            for (const raw of extractJsonObjects(norm)) {
-                const a = tryParseArray(raw);
-                if (a)
-                    return a;
-                const o = tryParse(raw);
-                if (o)
-                    return o;
-            }
-        }
-    }
-    const permissive = parseToolCallPermissive(cleaned) ||
-        parseToolCallPermissive(repairRawControlChars(cleaned)) ||
-        parseToolCallPermissive(normalizePseudoJson(cleaned));
-    if (permissive)
-        return { ...permissive, _permissive: true };
-    const toolIdx = cleaned.search(/["']?tool["']?\s:/);
-    if (toolIdx > 0) {
-        let tail = cleaned.slice(toolIdx);
-        tail = tail.replace(/<[^>]*>.*$/s, '').trim();
-        const tailPermissive = parseToolCallPermissive('{"' + tail) ||
-            parseToolCallPermissive('{"' + repairRawControlChars(tail));
-        if (tailPermissive)
-            return { ...tailPermissive, _permissive: true };
-    }
-    const xmlCalls = parseXmlToolCalls(cleaned);
-    if (xmlCalls)
-        return Array.isArray(xmlCalls) ? xmlCalls : [xmlCalls];
-    // Last attempt: "fix" a corrupted call head (`<｜tool": ...`,
-    // `tool": ...`, `**tool**: ...`, `- tool: ...`). We do this ONLY as a
-    // fallback, after regular parsing — otherwise it's easy to corrupt valid
-    // JSON (e.g. an array of calls starts with `[`, containing `{"tool":`).
-    const preamble = repairToolCallPreamble(cleaned);
-    if (preamble && preamble !== cleaned) {
-        const reps = [
-            preamble,
-            repairRawControlChars(preamble),
-            normalizePseudoJson(preamble),
-        ];
-        for (const rep of reps) {
-            for (const raw of extractJsonObjects(rep)) {
-                const a = tryParseArray(raw);
-                if (a)
-                    return a;
-                const o = tryParse(raw);
-                if (o)
-                    return o;
-            }
-        }
-        const perm = parseToolCallPermissive(preamble);
-        if (perm)
-            return { ...perm, _permissive: true };
-    }
-    return null;
-}
-function extractPreToolText(text) {
-    if (!text)
-        return '';
-    const patterns = ['{"tool"', '[{"tool"', '{"tool":', '[{"tool":'];
-    let earliest = -1;
-    for (const p of patterns) {
-        const idx = text.indexOf(p);
-        if (idx >= 0 && (earliest === -1 || idx < earliest))
-            earliest = idx;
-    }
-    if (earliest === -1)
-        return '';
-    return text.slice(0, earliest).trim();
-}
+// The pure helpers (tool-call parser + answer heuristics) moved to
+// answer-parse.ts (BACKLOG C3). They are imported for runAgentLoop and
+// RE-EXPORTED, so the public API of this module is unchanged (tests import
+// parseToolCall / responseLooksLikeToolCall / truncateToolResult from here).
+import { parseToolCall, responseLooksLikeToolCall, truncateToolResult, normForStale, looksLikeUnfinishedWork, isMeaningfulRespond, extractPreToolText, } from './answer-parse.js';
+export { parseToolCall, responseLooksLikeToolCall, truncateToolResult };