jiva-core 0.3.43 → 0.3.44-dev.72622a6

package/dist/code/agent.js

@@ -60,7 +60,7 @@ const CODE_MODE_INDICATOR = '[CODE MODE]';
 // Default token threshold for in-loop compaction (90K leaves ~38K headroom in a 128K model)
 const DEFAULT_COMPACTION_THRESHOLD = 90_000;
 /** System prompt for code mode — focused on precision and persistence (ported from opencode beast.txt) */
-const getSystemPrompt = (workspaceDir, directive) => {
+const _getSystemPromptBase = (workspaceDir, directive, skillsBlock, mcpToolNames) => {
     const base = `You are a precise, highly capable coding assistant operating in code mode.
 You have direct access to code tools — use them to explore, understand, and modify code.
 
@@ -76,6 +76,7 @@ PERSISTENCE AND COMPLETION:
 - Always tell the user what you are going to do before making a tool call with a single concise sentence.
 - If the user says "resume", "continue", or "try again", check the conversation history to find the last incomplete step and continue from there.
 - Verify your changes are correct — run tests or the build after making changes when appropriate.
+- If a tool call fails or returns an error, DO NOT STOP. Analyse the error, try a different approach or arguments, and keep going. Errors are expected — your job is to recover and complete the task.
 
 TOOLS AVAILABLE:
 - read_file: Read an existing file or list a directory. Only needed before editing an existing file.
@@ -94,11 +95,19 @@ CODING PRINCIPLES — READ CAREFULLY:
 5. After editing, check LSP errors in the tool result and fix them.
 6. Verify your changes work by running tests or the build when appropriate.
 7. Use bash only for shell commands (tests, builds, git) — NOT for reading files.
-8. LARGE FILES (100+ lines): write in stages — never try to generate a complete large file in one call.
-   - Stage 1: write_file with the skeleton/structure only (HTML tags, empty <style>, empty <script>)
-   - Stage 2: edit_file to add CSS content into the <style> block
-   - Stage 3: edit_file to add JS content into the <script> block
-   - Each individual call must be short enough to fit in one model response.
+8. LARGE FILES — ALWAYS WORK IN SMALL CHUNKS (applies to ALL file types: TS, Python, HTML, CSS, JSON…):
+   "Large" means any file or edit whose total new content exceeds ~80 lines.
+   BEFORE writing or editing: mentally estimate the line count. If > 80 lines, apply the rules below.
+   EDITING large files:
+   - Break every edit into chunks of 50–80 lines maximum.
+   - Never pass a new_string longer than ~80 lines to edit_file.
+   - Split large edits into multiple sequential edit_file calls, one section at a time.
+   CREATING new large files (skeleton-first approach — mandatory for any file > 80 lines):
+   - Stage 1: write_file with a skeleton/scaffold only — class/function stubs, empty bodies,
+     placeholder comments like "// TODO: implement X". Keep the skeleton under 60 lines.
+   - Stage 2+: edit_file to replace each placeholder/stub with the real implementation,
+     50–80 lines per call. Never implement more than one function or section per call.
+   - Reason: model output longer than ~100 lines gets truncated mid-JSON, silently corrupting the file.
 
 TOOL SELECTION RULES (follow exactly):
 - To CREATE a new file → write_file immediately (no reads needed first)
@@ -113,15 +122,61 @@ WHEN TO EXPLORE (only when actually needed):
 - You need to find where a function, class, or variable is defined.
 - You are debugging or tracing code through multiple files.
 - Do NOT explore before creating brand-new files — just write them directly.`;
-    if (directive) {
-        return `${base}\n\n${directive}`;
+    const parts = [base];
+    if (mcpToolNames && mcpToolNames.length > 0) {
+        parts.push(`MCP TOOLS (external servers — call these like any other tool):\n` +
+            mcpToolNames.map((n) => `- ${n}`).join('\n') + '\n\n' +
+            `Use MCP tools when the built-in tools cannot satisfy the request (e.g. browser automation, database queries). ` +
+            `Prefer built-in tools for all file and shell operations.`);
     }
-    return base;
+    if (skillsBlock)
+        parts.push(skillsBlock);
+    if (directive)
+        parts.push(directive);
+    return parts.join('\n\n');
 };
+/**
+ * Wrap selected MCP server tools as ICodeTool adapters so CodeAgent can call them
+ * using the same dispatch path as built-in tools.
+ * Only servers listed in `serverNames` are exposed — keeps context lean.
+ */
+function buildMCPAdapters(mcpManager, serverNames) {
+    if (!mcpManager || serverNames.length === 0)
+        return [];
+    const adapters = [];
+    const client = mcpManager.getClient();
+    for (const serverName of serverNames) {
+        const serverTools = client.getServerTools(serverName);
+        for (const tool of serverTools) {
+            // tool.name is already prefixed as "serverName__toolName" by MCPClient
+            adapters.push({
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+                async execute(args) {
+                    try {
+                        const result = await client.executeTool(tool.name, args);
+                        if (typeof result === 'string')
+                            return result;
+                        if (result && typeof result === 'object' && 'text' in result) {
+                            return result.text;
+                        }
+                        return JSON.stringify(result, null, 2);
+                    }
+                    catch (e) {
+                        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+                    }
+                },
+            });
+        }
+    }
+    return adapters;
+}
 export class CodeAgent {
     orchestrator;
     workspace;
     conversationManager;
+    personaManager;
     maxIterations;
     compactionThreshold;
     lsp;
@@ -129,11 +184,14 @@ export class CodeAgent {
     maxDepth;
     history = [];
     tools;
+    _mcpManager;
+    _mcpServerNames = [];
     _stopped = false;
     constructor(config) {
         this.orchestrator = config.orchestrator;
         this.workspace = config.workspace;
         this.conversationManager = config.conversationManager;
+        this.personaManager = config.personaManager;
         this.maxIterations = config.maxIterations ?? DEFAULT_MAX_ITERATIONS;
         this.compactionThreshold = config.compactionThreshold ?? DEFAULT_COMPACTION_THRESHOLD;
         this.depth = config.depth ?? 0;
@@ -142,6 +200,8 @@ export class CodeAgent {
             root: config.workspace.getWorkspaceDir(),
             enabled: config.lspEnabled ?? true,
         });
+        this._mcpManager = config.mcpManager;
+        this._mcpServerNames = config.mcpServerNames ?? [];
         this.tools = [
             ReadFileTool,
             EditFileTool,
@@ -150,6 +210,7 @@ export class CodeAgent {
             GrepTool,
             BashTool,
             ...(this.depth < this.maxDepth ? [SpawnCodeAgentTool] : []),
+            ...buildMCPAdapters(config.mcpManager, config.mcpServerNames ?? []),
         ];
     }
     /**
@@ -269,7 +330,11 @@ ${directive ? `\n${directive}` : ''}`;
     async chat(userMessage, onChunk) {
         const toolsUsed = [];
         const directive = this.workspace.getDirectivePrompt();
-        const systemPrompt = getSystemPrompt(this.workspace.getWorkspaceDir(), directive || undefined);
+        const skillsBlock = this.personaManager?.getSystemPromptAddition() || undefined;
+        const mcpToolNames = this._mcpManager
+            ? this.tools.filter((t) => t.name.includes('__')).map((t) => t.name)
+            : undefined;
+        const systemPrompt = _getSystemPromptBase(this.workspace.getWorkspaceDir(), directive || undefined, skillsBlock, mcpToolNames);
         // Build message history: system + history + new user message
         const messages = [
             { role: 'developer', content: systemPrompt },
@@ -446,16 +511,16 @@ ${directive ? `\n${directive}` : ''}`;
                         logger.warn(`[CodeAgent] ${isEditFile ? 'edit_file' : 'write_file'}${targetFile} content truncated (exceeded output token limit) — asking model to write in stages`);
                         const correctionContent = isEditFile
                             ? `Your edit_file call${targetFile} failed: new_string was too large and the response was cut off mid-JSON.\n\n` +
-                                `MAXIMUM 20 LINES per edit_file call. Write one tiny chunk at a time:\n` +
-                                `  - For JavaScript: add just ONE or TWO functions per call\n` +
-                                `  - For HTML: add just one row of buttons per call\n\n` +
+                                `MAXIMUM 20 LINES per edit_file call. Implement one function or section at a time:\n` +
+                                `  - Split the change into smaller pieces and call edit_file once per piece.\n` +
+                                `  - Never pass more than 20 lines as new_string.\n\n` +
                                 `Call edit_file now with a new_string of at most 20 lines.`
                             : `Your write_file call${targetFile} failed: the file content was too large and was cut off mid-JSON.\n\n` +
-                                `Write the file in stages — NEVER put CSS or JavaScript in the initial write_file:\n` +
-                                `  Stage 1: write_file — HTML skeleton ONLY (empty <style></style> and empty <script></script>) — MAX 20 lines\n` +
-                                `  Stage 2: edit_file — add CSS (max 20 lines at a time)\n` +
-                                `  Stage 3: edit_file — add JavaScript ONE function at a time\n\n` +
-                                `Start with Stage 1 NOW: write_file with just the bare HTML skeleton (20 lines max).`;
+                                `Use the skeleton-first approach — write the file in stages:\n` +
+                                `  Stage 1: write_file — skeleton/scaffold ONLY (stubs, empty function bodies, TODO placeholders) — MAX 20 lines\n` +
+                                `  Stage 2+: edit_file — implement one function or section at a time (max 20 lines per call)\n` +
+                                `  Never implement more than one major section per call.\n\n` +
+                                `Start with Stage 1 NOW: write_file with just the bare skeleton (20 lines max).`;
                         messages.push({ role: 'user', content: correctionContent });
                         consecutiveToolCallErrors = 0;
                         emptyResponseCount = 0; // reset so model has fresh recovery budget for staged CSS/JS edits
@@ -517,184 +582,229 @@ ${directive ? `\n${directive}` : ''}`;
                 logger.warn(`[CodeAgent] API error ${consecutiveApiErrors}/${MAX_CONSECUTIVE_API_ERRORS}: ${msg}`);
                 continue;
             }
-            // Add assistant response to messages, preserving the full structure needed for the next turn.
-            //
-            // Three cases:
-            //   1. Harmony mode: store rawHarmony string (contains <|call|> tokens the model needs).
-            //   2. Standard tool-calling with tool calls: store content + tool_calls so subsequent
-            //      role:'tool' results can be matched by tool_call_id (required by OpenAI-compatible APIs).
-            //   3. Text-only response: store content as-is.
-            const rawHarmony = response.raw?.parsedHarmony?.rawResponse;
-            if (rawHarmony) {
-                messages.push({ role: 'assistant', content: rawHarmony });
-            }
-            else if (response.toolCalls && response.toolCalls.length > 0) {
-                // Preserve tool_calls so tool results are properly matched in the next turn
-                messages.push({
-                    role: 'assistant',
-                    content: response.content || null,
-                    tool_calls: response.toolCalls,
-                });
-            }
-            else {
-                messages.push({ role: 'assistant', content: response.content });
-            }
-            // Stream the visible (final-channel) text output if callback provided
-            if (response.content && onChunk) {
-                onChunk(response.content);
-            }
-            // ── In-loop context compaction ──────────────────────────────────────────
-            // Check if we're approaching the context window limit and compact if needed.
-            // Triggered once per turn (compactedThisTurn flag) to avoid thrashing.
-            // Only runs when: threshold > 0, orchestrator available, not already compacted,
-            // and the response carried token usage data.
-            const promptTokens = response.usage?.promptTokens ?? 0;
-            if (this.compactionThreshold > 0 &&
-                promptTokens > this.compactionThreshold &&
-                !compactedThisTurn &&
-                this.conversationManager &&
-                response.toolCalls && response.toolCalls.length > 0) {
-                logger.warn(`[CodeAgent] Context at ${promptTokens} tokens (threshold: ${this.compactionThreshold}) — compacting in-loop history`);
-                compactedThisTurn = true;
-                try {
-                    const compacted = await this.compactInLoopMessages(messages, systemPrompt);
-                    // Replace messages in-place, preserving the system prompt at index 0
-                    messages.splice(0, messages.length, ...compacted);
-                    logger.info(`[CodeAgent] In-loop compaction complete: ${messages.length} messages after compaction`);
-                }
-                catch (compactErr) {
-                    // Non-fatal: log and continue with uncompacted messages
-                    logger.error('[CodeAgent] In-loop compaction failed, continuing without compaction', compactErr);
-                }
-            }
-            // ────────────────────────────────────────────────────────────────────────
-            // No tool calls → model is done (or gave up)
-            if (!response.toolCalls || response.toolCalls.length === 0) {
-                if (!response.content && emptyResponseCount < MAX_EMPTY_RESPONSES) {
-                    // Model returned empty content with no tool calls — it got stuck or confused.
-                    // Inject an escalating recovery nudge and let it try again.
-                    emptyResponseCount++;
-                    logger.warn(`[CodeAgent] Empty response with no tool calls (${emptyResponseCount}/${MAX_EMPTY_RESPONSES}) — injecting recovery nudge`);
-                    // Escalate urgency with each retry so the model doesn't keep ignoring it
-                    let nudgeContent;
-                    if (emptyResponseCount <= 2) {
-                        nudgeContent =
-                            'Your last response was empty. Please continue working on the task.\n\n' +
-                                '- If you need to CREATE a file → call write_file now.\n' +
-                                '- If you need to EDIT a file → call read_file then edit_file.\n' +
-                                '- If the task is already complete → provide a brief summary of what was done.';
-                    }
-                    else {
-                        nudgeContent =
-                            `IMPORTANT (attempt ${emptyResponseCount}/${MAX_EMPTY_RESPONSES}): Your response is empty again — you have not called any tools.\n\n` +
-                                `You MUST call a tool NOW. Do not output plain text without a tool call.\n` +
-                                `  • To CREATE a new file → call write_file immediately with the file content.\n` +
-                                `  • To EDIT an existing file → call edit_file with old_string and new_string.\n` +
-                                `  • To LIST files → call read_file on the directory.\n\n` +
-                                `Make a tool call in your very next response. Do not explain — just call the tool.`;
-                    }
-                    messages.push({ role: 'user', content: nudgeContent });
-                    continue;
-                }
-                finalContent = response.content || '[No response content]';
-                break;
-            }
-            // Execute tool calls
-            for (const toolCall of response.toolCalls) {
-                const toolName = toolCall.function.name;
-                let toolArgs = {};
-                try {
-                    toolArgs = JSON.parse(toolCall.function.arguments);
-                }
-                catch {
-                    // malformed args
-                }
-                // Consecutive reads tracker — any non-read tool resets the streak
-                if (toolName === 'read_file') {
-                    consecutiveReadCount++;
-                }
-                else {
-                    consecutiveReadCount = 0;
+            // Wrap all post-API processing in a try/catch so an unexpected exception during tool
+            // execution or message construction doesn't crash the entire chat() call.  Instead,
+            // inject the error as a user message and let the model recover on the next iteration.
+            let _postApiError = false;
+            try {
+                // Add assistant response to messages, preserving the full structure needed for the next turn.
+                //
+                // Three cases:
+                //   1. Harmony mode: store rawHarmony string (contains <|call|> tokens the model needs).
+                //   2. Standard tool-calling with tool calls: store content + tool_calls so subsequent
+                //      role:'tool' results can be matched by tool_call_id (required by OpenAI-compatible APIs).
+                //   3. Text-only response: store content as-is.
+                const rawHarmony = response.raw?.parsedHarmony?.rawResponse;
+                if (rawHarmony) {
+                    messages.push({ role: 'assistant', content: rawHarmony });
                 }
-                // Doom loop check
-                const callSig = `${toolName}:${JSON.stringify(toolArgs)}`;
-                recentCalls.push(callSig);
-                if (recentCalls.length > DOOM_LOOP_THRESHOLD)
-                    recentCalls.shift();
-                if (recentCalls.length === DOOM_LOOP_THRESHOLD &&
-                    recentCalls.every((c) => c === recentCalls[0])) {
-                    logger.warn(`[CodeAgent] Doom loop detected for tool: ${toolName}`);
+                else if (response.toolCalls && response.toolCalls.length > 0) {
+                    // Preserve tool_calls so tool results are properly matched in the next turn
                     messages.push({
-                        role: 'user',
-                        content: `STOP: You are calling \`${toolName}\` with the same arguments repeatedly. This action is not making progress. Stop and reassess your approach — try a different strategy or report what is blocking you.`,
+                        role: 'assistant',
+                        content: response.content || null,
+                        tool_calls: response.toolCalls,
                     });
-                    break;
-                }
-                logger.info(`[CodeAgent] Tool: ${toolName}`);
-                toolsUsed.push(toolName);
-                const tool = this.tools.find((t) => t.name === toolName);
-                let toolResult;
-                if (!tool) {
-                    toolResult = `Error: Unknown tool "${toolName}". Available tools: ${this.tools.map((t) => t.name).join(', ')}`;
                 }
                 else {
+                    messages.push({ role: 'assistant', content: response.content });
+                }
+                // Stream the visible (final-channel) text output if callback provided
+                if (response.content && onChunk) {
+                    onChunk(response.content);
+                }
+                // ── In-loop context compaction ──────────────────────────────────────────
+                // Check if we're approaching the context window limit and compact if needed.
+                // Triggered once per turn (compactedThisTurn flag) to avoid thrashing.
+                // Only runs when: threshold > 0, orchestrator available, not already compacted,
+                // and the response carried token usage data.
+                const promptTokens = response.usage?.promptTokens ?? 0;
+                if (this.compactionThreshold > 0 &&
+                    promptTokens > this.compactionThreshold &&
+                    !compactedThisTurn &&
+                    this.conversationManager &&
+                    response.toolCalls && response.toolCalls.length > 0) {
+                    logger.warn(`[CodeAgent] Context at ${promptTokens} tokens (threshold: ${this.compactionThreshold}) — compacting in-loop history`);
+                    compactedThisTurn = true;
                     try {
-                        const ctx = {
-                            workspaceDir: this.workspace.getWorkspaceDir(),
-                            lsp: this.lsp,
-                            depth: this.depth,
-                            maxDepth: this.maxDepth,
-                            spawnChildAgent: this.depth < this.maxDepth
-                                ? async (task, context) => {
-                                    const child = new CodeAgent({
-                                        orchestrator: this.orchestrator,
-                                        workspace: this.workspace,
-                                        maxIterations: this.maxIterations,
-                                        lspEnabled: true,
-                                        depth: this.depth + 1,
-                                        maxDepth: this.maxDepth,
-                                    });
-                                    // Share the parent's LSP manager so servers don't restart
-                                    child.lsp = this.lsp;
-                                    const taskMsg = context ? `${task}\n\nContext: ${context}` : task;
-                                    const result = await child.chat(taskMsg);
-                                    return result.content;
-                                }
-                                : undefined,
-                        };
-                        toolResult = await tool.execute(toolArgs, ctx);
+                        const compacted = await this.compactInLoopMessages(messages, systemPrompt);
+                        // Replace messages in-place, preserving the system prompt at index 0
+                        messages.splice(0, messages.length, ...compacted);
+                        logger.info(`[CodeAgent] In-loop compaction complete: ${messages.length} messages after compaction`);
                     }
-                    catch (e) {
-                        toolResult = `Error executing ${toolName}: ${e instanceof Error ? e.message : String(e)}`;
+                    catch (compactErr) {
+                        // Non-fatal: log and continue with uncompacted messages
+                        logger.error('[CodeAgent] In-loop compaction failed, continuing without compaction', compactErr);
                     }
                 }
-                // Add tool result to messages (using Harmony format helper)
-                const toolMessage = formatToolResult(toolCall.id, toolName, toolResult);
-                messages.push(toolMessage);
-                // Reset empty response budget after any productive (mutating) tool call.
-                // This gives the model a fresh set of recovery nudges for each new work phase
-                // (e.g., after writing the skeleton, it gets 4 more chances to add CSS/JS).
-                if (toolName === 'write_file' || toolName === 'edit_file' || toolName === 'bash') {
-                    emptyResponseCount = 0;
+                // ────────────────────────────────────────────────────────────────────────
+                // No tool calls → model is done (or gave up)
+                if (!response.toolCalls || response.toolCalls.length === 0) {
+                    // Detect a truncated XML tool call: the model started a <tool_call> block but the
+                    // response was cut off before </tool_call> (token limit hit mid-content).
+                    // The XML parser in parseHarmonyResponse requires the closing tag, so nothing was
+                    // extracted — but we can still detect the open tag and inject the staged-write correction.
+                    const truncatedXml = response.content &&
+                        response.content.includes('<tool_call>') &&
+                        !response.content.includes('</tool_call>');
+                    if (truncatedXml) {
+                        const isEditFile = response.content.includes('edit_file') && !response.content.includes('write_file');
+                        const fpMatch = response.content.match(/<arg_key>file_path<\/arg_key>\s*<arg_value>([^<]+)<\/arg_value>/);
+                        const targetFile = fpMatch ? ` for \`${fpMatch[1]}\`` : '';
+                        logger.warn(`[CodeAgent] Truncated XML tool call${targetFile} — injecting staged-writing correction`);
+                        const correctionContent = isEditFile
+                            ? `Your edit_file call${targetFile} failed: the response was cut off before the tool call completed.\n\n` +
+                                `MAXIMUM 20 LINES per edit_file call. Implement one function or section at a time:\n` +
+                                `  - Split the change into smaller pieces and call edit_file once per piece.\n` +
+                                `  - Never pass more than 20 lines as new_string.\n\n` +
+                                `Call edit_file now with a new_string of at most 20 lines.`
+                            : `Your write_file call${targetFile} failed: the file content was too large and was cut off mid-response.\n\n` +
+                                `Use the skeleton-first approach — write the file in stages:\n` +
+                                `  Stage 1: write_file — skeleton/scaffold ONLY (stubs, empty function bodies, TODO placeholders) — MAX 20 lines\n` +
+                                `  Stage 2+: edit_file — implement one function or section at a time (max 20 lines per call)\n` +
+                                `  Never implement more than one major section per call.\n\n` +
+                                `Start with Stage 1 NOW: write_file with just the bare skeleton (20 lines max).`;
+                        messages.push({ role: 'user', content: correctionContent });
+                        emptyResponseCount = 0;
+                        continue;
+                    }
+                    if (!response.content && emptyResponseCount < MAX_EMPTY_RESPONSES) {
+                        // Model returned empty content with no tool calls — it got stuck or confused.
+                        // Inject an escalating recovery nudge and let it try again.
+                        emptyResponseCount++;
+                        logger.warn(`[CodeAgent] Empty response with no tool calls (${emptyResponseCount}/${MAX_EMPTY_RESPONSES}) — injecting recovery nudge`);
+                        // Escalate urgency with each retry so the model doesn't keep ignoring it
+                        let nudgeContent;
+                        if (emptyResponseCount <= 2) {
+                            nudgeContent =
+                                'Your last response was empty. Please continue working on the task.\n\n' +
+                                    '- If you need to CREATE a file → call write_file now.\n' +
+                                    '- If you need to EDIT a file → call read_file then edit_file.\n' +
+                                    '- If the task is already complete → provide a brief summary of what was done.';
+                        }
+                        else {
+                            nudgeContent =
+                                `IMPORTANT (attempt ${emptyResponseCount}/${MAX_EMPTY_RESPONSES}): Your response is empty again — you have not called any tools.\n\n` +
+                                    `You MUST call a tool NOW. Do not output plain text without a tool call.\n` +
+                                    `  • To CREATE a new file → call write_file immediately with the file content.\n` +
+                                    `  • To EDIT an existing file → call edit_file with old_string and new_string.\n` +
+                                    `  • To LIST files → call read_file on the directory.\n\n` +
+                                    `Make a tool call in your very next response. Do not explain — just call the tool.`;
+                        }
+                        messages.push({ role: 'user', content: nudgeContent });
+                        continue;
+                    }
+                    finalContent = response.content || '[No response content]';
+                    break;
                 }
-                // Excessive reads nudge — model is re-reading without making any changes.
-                // Fires after MAX_CONSECUTIVE_READS consecutive read_file calls; resets the count
-                // so the model gets a fresh budget after each nudge (prevents spamming).
-                if (consecutiveReadCount >= MAX_CONSECUTIVE_READS) {
-                    logger.warn(`[CodeAgent] ${consecutiveReadCount} consecutive read_file calls without edits — nudging model to act`);
-                    consecutiveReadCount = 0;
-                    messages.push({
-                        role: 'user',
-                        content: `You have called read_file ${MAX_CONSECUTIVE_READS}+ times in a row without making any changes.\n\n` +
-                            `STOP READING — you have enough context. Make a concrete change NOW:\n` +
-                            `  • To ADD or CHANGE content in an existing file → call edit_file with old_string and new_string\n` +
-                            `  • To CREATE a new file → call write_file\n` +
-                            `  • If the task is fully complete → provide a final summary (no more tool calls needed)\n\n` +
-                            `Do NOT call read_file again until you have made at least one edit_file or write_file call.`,
-                    });
-                    break; // exit inner tool loop — model sees the nudge on the next outer iteration
+                // Execute tool calls
+                for (const toolCall of response.toolCalls) {
+                    const toolName = toolCall.function.name;
+                    let toolArgs = {};
+                    try {
+                        toolArgs = JSON.parse(toolCall.function.arguments);
+                    }
+                    catch {
+                        // malformed args
+                    }
+                    // Consecutive reads tracker — any non-read tool resets the streak
+                    if (toolName === 'read_file') {
+                        consecutiveReadCount++;
+                    }
+                    else {
+                        consecutiveReadCount = 0;
+                    }
+                    // Doom loop check
+                    const callSig = `${toolName}:${JSON.stringify(toolArgs)}`;
+                    recentCalls.push(callSig);
+                    if (recentCalls.length > DOOM_LOOP_THRESHOLD)
+                        recentCalls.shift();
+                    if (recentCalls.length === DOOM_LOOP_THRESHOLD &&
+                        recentCalls.every((c) => c === recentCalls[0])) {
+                        logger.warn(`[CodeAgent] Doom loop detected for tool: ${toolName}`);
+                        messages.push({
+                            role: 'user',
+                            content: `STOP: You are calling \`${toolName}\` with the same arguments repeatedly. This action is not making progress. Stop and reassess your approach — try a different strategy or report what is blocking you.`,
+                        });
+                        break;
+                    }
+                    logger.info(`[CodeAgent] Tool: ${toolName}`);
+                    toolsUsed.push(toolName);
+                    const tool = this.tools.find((t) => t.name === toolName);
+                    let toolResult;
+                    if (!tool) {
+                        toolResult = `Error: Unknown tool "${toolName}". Available tools: ${this.tools.map((t) => t.name).join(', ')}`;
+                    }
+                    else {
+                        try {
+                            const ctx = {
+                                workspaceDir: this.workspace.getWorkspaceDir(),
+                                lsp: this.lsp,
+                                depth: this.depth,
+                                maxDepth: this.maxDepth,
+                                spawnChildAgent: this.depth < this.maxDepth
+                                    ? async (task, context) => {
+                                        const child = new CodeAgent({
+                                            orchestrator: this.orchestrator,
+                                            workspace: this.workspace,
+                                            maxIterations: this.maxIterations,
+                                            lspEnabled: true,
+                                            depth: this.depth + 1,
+                                            maxDepth: this.maxDepth,
+                                        });
+                                        // Share the parent's LSP manager so servers don't restart
+                                        child.lsp = this.lsp;
+                                        const taskMsg = context ? `${task}\n\nContext: ${context}` : task;
+                                        const result = await child.chat(taskMsg);
+                                        return result.content;
+                                    }
+                                    : undefined,
+                            };
+                            toolResult = await tool.execute(toolArgs, ctx);
+                        }
+                        catch (e) {
+                            toolResult = `Error executing ${toolName}: ${e instanceof Error ? e.message : String(e)}`;
+                        }
+                    }
+                    // Add tool result to messages (using Harmony format helper)
+                    const toolMessage = formatToolResult(toolCall.id, toolName, toolResult);
+                    messages.push(toolMessage);
+                    // Reset empty response budget after any productive (mutating) tool call.
+                    // This gives the model a fresh set of recovery nudges for each new work phase
+                    // (e.g., after writing the skeleton, it gets 4 more chances to add CSS/JS).
+                    if (toolName === 'write_file' || toolName === 'edit_file' || toolName === 'bash') {
+                        emptyResponseCount = 0;
+                    }
+                    // Excessive reads nudge — model is re-reading without making any changes.
+                    // Fires after MAX_CONSECUTIVE_READS consecutive read_file calls; resets the count
+                    // so the model gets a fresh budget after each nudge (prevents spamming).
+                    if (consecutiveReadCount >= MAX_CONSECUTIVE_READS) {
+                        logger.warn(`[CodeAgent] ${consecutiveReadCount} consecutive read_file calls without edits — nudging model to act`);
+                        consecutiveReadCount = 0;
+                        messages.push({
+                            role: 'user',
+                            content: `You have called read_file ${MAX_CONSECUTIVE_READS}+ times in a row without making any changes.\n\n` +
+                                `STOP READING — you have enough context. Make a concrete change NOW:\n` +
+                                `  • To ADD or CHANGE content in an existing file → call edit_file with old_string and new_string\n` +
+                                `  • To CREATE a new file → call write_file\n` +
+                                `  • If the task is fully complete → provide a final summary (no more tool calls needed)\n\n` +
+                                `Do NOT call read_file again until you have made at least one edit_file or write_file call.`,
+                        });
+                        break; // exit inner tool loop — model sees the nudge on the next outer iteration
+                    }
                 }
             }
+            catch (unexpectedError) {
+                _postApiError = true;
+                const errMsg = unexpectedError instanceof Error ? unexpectedError.message : String(unexpectedError);
+                logger.error(`[CodeAgent] Unexpected error during tool processing: ${errMsg}`);
+                messages.push({
+                    role: 'user',
+                    content: `An unexpected internal error occurred: "${errMsg}". Please try a different approach to continue the task.`,
+                });
+            }
+            if (_postApiError)
+                continue;
         }
         if (!finalContent) {
             finalContent = '[Max iterations reached without a final response]';
@@ -729,7 +839,7 @@ ${directive ? `\n${directive}` : ''}`;
             // Nothing meaningful to compact
             return messages;
         }
-        const systemMsg = messages[0]; // developer/system prompt
+        const systemMsg = { role: 'developer', content: systemPrompt };
         const recentMessages = messages.slice(-KEEP_RECENT);
         const middleMessages = messages.slice(1, -KEEP_RECENT);
         if (middleMessages.length === 0)
@@ -823,7 +933,28 @@ Keep the summary concise but complete. Focus on what would help continue the wor
         return this.workspace;
     }
     getMCPManager() {
-        // CodeAgent uses in-process tools, not MCP. Return a stub that reflects built-in tools.
+        if (this._mcpManager) {
+            const allowedNames = this._mcpServerNames;
+            const fullManager = this._mcpManager;
+            const builtinTools = this.tools.filter((t) => !t.name.includes('__'));
+            return {
+                getServerStatus: () => [
+                    // Always report the built-in code tools as the first entry
+                    { name: 'code-tools', connected: true, enabled: true, toolCount: builtinTools.length },
+                    // Then the opted-in MCP servers only
+                    ...fullManager.getServerStatus().filter((s) => allowedNames.includes(s.name)),
+                ],
+                getClient: () => ({
+                    getAllTools: () => [
+                        // Built-in code tools
+                        ...builtinTools.map((t) => ({ name: t.name, description: t.description })),
+                        // Opted-in MCP tools only
+                        ...fullManager.getClient().getAllTools().filter((t) => allowedNames.some((n) => t.name.startsWith(`${n}__`))),
+                    ],
+                }),
+            };
+        }
+        // Fallback stub when no MCP manager is configured — reflects built-in tools only.
         const tools = this.tools;
         return {
             getServerStatus: () => [{