micro-models-agent 0.2.39 → 0.2.41

package/dist/agent/loop.js

@@ -17,65 +17,9 @@ import { listThemes, switchTheme } from '../styling/index.js';
 import { loadThemeConfig, installTheme, removeTheme } from '../styling/loader.js';
 import { loadConfig, saveConfig } from '../config/config.js';
 import { buildSystemPrompt } from './system-prompt.js';
-import { logInfo, logWarn, logDebug, logLLMRequest, logLLMResponse, logToolCall, setStatusWriter, writeStatus } from '../logger.js';
-function extractAllToolCalls(response) {
-    const results = [];
-    let text = response;
-    while (true) {
-        const tcStart = text.indexOf('<tool_call>');
-        if (tcStart === -1)
-            break;
-        const tcEnd = text.indexOf('</tool_call>', tcStart);
-        let block;
-        if (tcEnd !== -1) {
-            block = text.slice(tcStart + '<tool_call>'.length, tcEnd);
-            text = text.slice(tcEnd + '</tool_call>'.length);
-        }
-        else {
-            block = text.slice(tcStart + '<tool_call>'.length);
-            text = '';
-        }
-        // Strip markdown code fences
-        block = block.replace(/```(?:json)?\s*/g, '').replace(/```\s*/g, '');
-        // Find JSON object
-        const jsonStart = block.indexOf('{');
-        if (jsonStart === -1)
-            continue;
-        let depth = 0;
-        let inStr = false;
-        let esc = false;
-        for (let i = jsonStart; i < block.length; i++) {
-            const ch = block[i];
-            if (esc) {
-                esc = false;
-                continue;
-            }
-            if (ch === '\\' && inStr) {
-                esc = true;
-                continue;
-            }
-            if (ch === '"') {
-                inStr = !inStr;
-                continue;
-            }
-            if (inStr)
-                continue;
-            if (ch === '{')
-                depth++;
-            if (ch === '}')
-                depth--;
-            if (depth === 0) {
-                results.push(block.slice(jsonStart, i + 1));
-                break;
-            }
-        }
-        // If no closing brace, take everything
-        if (depth > 0 && jsonStart < block.length) {
-            results.push(block.slice(jsonStart));
-        }
-    }
-    return results;
-}
+import { logInfo, logWarn, logError, logDebug, logToolCall, setStatusWriter, writeStatus } from '../logger.js';
+import { buildSubagentContext, runIsolatedLoop, extractAllToolCalls, validateToolCall, doChat } from '../tools/subagent.js';
+// extractAllToolCalls moved to src/tools/subagent.ts
 function extractToolCallFallback(response) {
     const patterns = [
         /"name"\s*:\s*"bash"\s*,\s*"arguments"\s*:\s*\{\s*"cmd"\s*:\s*"((?:[^"\\]|\\.)*)"/,
@@ -92,146 +36,9 @@ function extractToolCallFallback(response) {
     }
     return null;
 }
-function validateToolCall(parsed) {
-    if (!parsed || typeof parsed !== 'object') {
-        return { valid: false, error: 'Not an object' };
-    }
-    const VALID_TOOLS = new Set(['bash', 'plan', 'todo', 'question', 'approve', 'theme', 'user_profile', 'read_file', 'write_file', 'edit_file', 'list_dir', 'create_dir', 'delete_file', 'copy_file', 'move_file', 'file_info', 'glob_search', 'grep_search', 'tree', 'web_search', 'web_fetch']);
-    if (!parsed.name || !VALID_TOOLS.has(parsed.name)) {
-        return { valid: false, error: `Unknown tool: ${parsed.name}` };
-    }
-    if (!parsed.arguments || typeof parsed.arguments !== 'object') {
-        return { valid: false, error: 'Missing arguments' };
-    }
-    if (parsed.name === 'bash') {
-        const cmd = String(parsed.arguments.cmd ?? '').trim();
-        if (!cmd) {
-            return { valid: false, error: 'Empty command' };
-        }
-        return { valid: true, name: parsed.name, cmd };
-    }
-    const REQUIRED_ARGS = {
-        read_file: ['path'],
-        write_file: ['path', 'content'],
-        edit_file: ['path', 'old_string', 'new_string'],
-        list_dir: [],
-        create_dir: ['path'],
-        delete_file: ['path'],
-        copy_file: ['source', 'destination'],
-        move_file: ['source', 'destination'],
-        file_info: ['path'],
-        glob_search: ['pattern'],
-        grep_search: ['pattern'],
-        tree: [],
-        web_search: ['query'],
-        web_fetch: ['url'],
-        user_profile: [],
-    };
-    const required = REQUIRED_ARGS[parsed.name] ?? [];
-    const missing = required.filter(k => {
-        const v = parsed.arguments[k];
-        return v === undefined || v === null || v === '';
-    });
-    if (missing.length > 0) {
-        return { valid: false, error: `Missing required argument(s): ${missing.join(', ')}. Tool "${parsed.name}" requires: ${required.join(', ')}` };
-    }
-    return { valid: true, name: parsed.name };
-}
-async function doChat(provider, messages, renderer, signal, retries = 1, showThinking = false) {
-    for (let attempt = 0; attempt <= retries; attempt++) {
-        const startTime = performance.now();
-        const fullText = [];
-        let started = false;
-        let reasoningBuf = false;
-        if (signal?.aborted)
-            return { response: '', genTimeMs: 0 };
-        const lastMsg = messages[messages.length - 1];
-        logLLMRequest(provider.model, messages.length, lastMsg?.content || '');
-        renderer.writeSpinner();
-        try {
-            let buf = '';
-            for await (const chunk of provider.chat(messages, { temperature: 0.7, max_tokens: 8192, signal, showThinking })) {
-                if (!chunk.content && !chunk.reasoning)
-                    continue;
-                if (chunk.content)
-                    fullText.push(chunk.content);
-                if (!started) {
-                    renderer.clearSpinner();
-                    started = true;
-                }
-                if (chunk.reasoning) {
-                    if (showThinking) {
-                        if (reasoningBuf === false) {
-                            renderer.writeNewline();
-                            renderer.writeDim('┈ reasoning ┈');
-                            reasoningBuf = '';
-                        }
-                        reasoningBuf += chunk.reasoning;
-                    }
-                    continue;
-                }
-                if (reasoningBuf !== false) {
-                    renderer.writeNewline();
-                    renderer.writeDim(reasoningBuf);
-                    reasoningBuf = false;
-                }
-                buf += chunk.content;
-                while (buf.length > 0) {
-                    const tcStart = buf.indexOf('<tool_call>');
-                    const tcEnd = buf.indexOf('</tool_call>');
-                    if (tcStart === -1 && tcEnd === -1) {
-                        if (buf)
-                            renderer.writeMarkdownChunk(buf);
-                        buf = '';
-                        break;
-                    }
-                    if (tcStart !== -1 && (tcEnd === -1 || tcStart < tcEnd)) {
-                        if (tcStart > 0) {
-                            renderer.writeMarkdownChunk(buf.slice(0, tcStart));
-                        }
-                        buf = buf.slice(tcStart);
-                        const closeIdx = buf.indexOf('</tool_call>');
-                        if (closeIdx !== -1) {
-                            buf = buf.slice(closeIdx + '</tool_call>'.length);
-                        }
-                        break;
-                    }
-                    if (tcEnd !== -1 && (tcStart === -1 || tcEnd < tcStart)) {
-                        renderer.writeMarkdownChunk(buf.slice(0, tcEnd));
-                        buf = buf.slice(tcEnd + '</tool_call>'.length);
-                    }
-                }
-            }
-            if (reasoningBuf !== false) {
-                renderer.writeNewline();
-                renderer.writeDim(reasoningBuf);
-            }
-        }
-        catch (e) {
-            if (e.name === 'AbortError') {
-                logLLMResponse(provider.model, 0, performance.now() - startTime, 'Aborted');
-                return { response: '', genTimeMs: 0 };
-            }
-            logLLMResponse(provider.model, 0, performance.now() - startTime, e.message);
-            renderer.writeError(`\n[LLM] ${e.message}`);
-            renderer.writeWarning('[LLM] Check that your server is running (LM Studio on localhost:1234 or Ollama)');
-            return { response: '', genTimeMs: 0 };
-        }
-        const genTimeMs = performance.now() - startTime;
-        const response = fullText.join('');
-        renderer.commitMarkdown();
-        if (response.trim()) {
-            logLLMResponse(provider.model, response.length, genTimeMs);
-            return { response, genTimeMs };
-        }
-        if (attempt < retries) {
-            renderer.writeDim(`[retry ${attempt + 1}/${retries}]`);
-        }
-    }
-    return { response: '', genTimeMs: 0 };
-}
 export async function runAgentLoop(provider, registry, prompt, contextManager, previousMessages, renderer, providerName, options) {
     logInfo('LOOP', `runAgentLoop started: "${prompt.slice(0, 50)}"`);
+    renderer?.resetAbort?.();
     const { prompt: enrichedPrompt, files } = await parseFileRefs(prompt);
     logDebug('LOOP', `parseFileRefs: ${files.length} files, prompt len: ${enrichedPrompt.length}`);
     const quiet = options?.quiet ?? false;
@@ -241,6 +48,19 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
         logInfo('LOOP', `loaded ${loadedSkills.length} skills: ${loadedSkills.map(s => s.name).join(', ')}`);
         renderer?.writeInfo(`  Loaded ${loadedSkills.length} skill(s): ${loadedSkills.map(s => s.name).join(', ')}`);
     }
+    if (options?.mode === 'pro' && !loadedSkillNames.has('grill-me')) {
+        const grill = loadSkill('grill-me', process.cwd());
+        if (grill) {
+            loadedSkills.push(grill);
+            loadedSkillNames.add('grill-me');
+            logInfo('LOOP', 'auto-loaded grill-me skill for pro mode');
+            renderer?.writeInfo('  Auto-loaded @grill-me skill for pro mode');
+        }
+        else {
+            logWarn('LOOP', 'grill-me skill not found for pro mode');
+            renderer?.writeWarning('  Warning: @grill-me skill not found (required for pro mode)');
+        }
+    }
     if (files.length > 0) {
         const totalTokens = files.reduce((sum, f) => sum + f.tokens, 0);
         const totalLines = files.reduce((sum, f) => sum + f.content.split('\n').length, 0);
@@ -251,7 +71,7 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
     setStatusWriter(renderer ? (msg) => renderer.writeDim(`  ${msg}`) : null);
     writeStatus('Initializing...');
     const sysStart = performance.now();
-    const systemPrompt = buildSystemPrompt(loadedSkills.length > 0 ? loadedSkills : undefined);
+    const systemPrompt = buildSystemPrompt(loadedSkills.length > 0 ? loadedSkills : undefined, options?.mode);
     const sysElapsed = ((performance.now() - sysStart) / 1000).toFixed(1);
     writeStatus(`Done (${sysElapsed}s)`);
     setStatusWriter(null);
@@ -267,6 +87,7 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
     let pendingSyntaxError = '';
     let aborted = false;
     let continuationNudges = 0;
+    let directWriteStreak = 0; // consecutive write_file calls without subagent (across steps)
     // Reset abort signal for this run
     if (renderer?.abortSignal === undefined) {
         // Renderer doesn't support abort — fine
@@ -284,6 +105,8 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
             break;
         }
         let skillsAutoLoaded = false;
+        // Track files created/modified in this session for completion reporting
+        const createdFiles = [];
         logDebug('LOOP', `step ${step + 1}/${maxSteps} starting, ${messages.length} messages`);
         await ctx.updateTokens(messages);
         const skillNames = loadedSkills.map(s => s.name).join(', ');
@@ -307,41 +130,45 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
         }
         logInfo('LOOP', `calling doChat, messages: ${messages.length}, options.showThinking: ${options?.showThinking}`);
         const { response } = await doChat(provider, messages, renderer, renderer?.abortSignal, 1, options?.showThinking);
-        // Auto-load skills if model suggested them in response
-        const suggestedSkillRefs = response.matchAll(/@(\w[\w-]*)/g);
-        const newSkillNames = [];
-        for (const match of suggestedSkillRefs) {
-            const name = match[1];
-            if (['email', 'api', 'id', 'json', 'url', 'http', 'https', 'localhost'].includes(name))
-                continue;
-            if (!loadedSkillNames.has(name)) {
-                const skill = loadSkill(name, process.cwd());
-                if (skill) {
-                    newSkillNames.push(name);
-                    loadedSkills.push(skill);
-                    loadedSkillNames.add(name);
+        // Check if aborted during generation
+        if (renderer?.abortSignal?.aborted) {
+            aborted = true;
+            break;
+        }
+        // Auto-load skills if the response contains @skill mentions
+        // Works with or without tool calls — agent can mention skills while working
+        if (options?.mode !== 'fast' && !skillsAutoLoaded) {
+            const suggestedSkillRefs = response.matchAll(/@(\w[\w-]*)/g);
+            const newSkillNames = [];
+            for (const match of suggestedSkillRefs) {
+                const name = match[1];
+                if (['email', 'api', 'id', 'json', 'url', 'http', 'https', 'localhost'].includes(name))
+                    continue;
+                if (!loadedSkillNames.has(name)) {
+                    const skill = loadSkill(name, process.cwd());
+                    if (skill) {
+                        newSkillNames.push(name);
+                        loadedSkills.push(skill);
+                        loadedSkillNames.add(name);
+                    }
                 }
             }
-        }
-        if (newSkillNames.length > 0) {
-            skillsAutoLoaded = true;
-            renderer?.writeInfo(`  Auto-loaded ${newSkillNames.length} skill(s): ${newSkillNames.join(', ')}`);
-            messages[0] = { role: 'system', content: buildSystemPrompt(loadedSkills) };
-            messages.push({ role: 'user', content: `[System: Skills loaded: ${newSkillNames.join(', ')}. They are in your context now. IMPORTANT: Use filesystem tools (write_file, create_dir, edit_file, read_file, etc.) for all file operations — NOT bash. Skills show bash examples for reference only. Create a plan and start working NOW — do NOT wait for user confirmation.]` });
-            // Force model to continue working after skills are loaded
-            continue;
-        }
+            if (newSkillNames.length > 0) {
+                skillsAutoLoaded = true;
+                renderer?.writeInfo(`  Auto-loaded ${newSkillNames.length} skill(s): ${newSkillNames.join(', ')}`);
+                messages[0] = { role: 'system', content: buildSystemPrompt(loadedSkills, options?.mode) };
+                messages.push({ role: 'user', content: `[System: Skills loaded: ${newSkillNames.join(', ')}. Continue your work using these skills where relevant.]` });
+                continue;
+            }
+        } // end fast-mode skill block
         if (!response.trim()) {
             logWarn('LOOP', `empty response #${consecutiveEmpty + 1}`);
             consecutiveEmpty++;
             const lastMsg = messages[messages.length - 1];
-            if (lastMsg?.role === 'tool' && consecutiveEmpty <= 3) {
-                const retryPrompt = consecutiveEmpty === 1
-                    ? 'The tool result is above. Your turn now. Either: (1) call the next tool using <tool_call>{"name":"...","arguments":{...}}</tool_call>, or (2) write a text reply to the user summarizing progress. Do NOT output nothing.'
-                    : 'You returned an empty response again. You MUST write something now. Example of what to write: "File created. Now I will create the next file..." or call another tool. Silence is not allowed.';
-                messages.push({ role: 'user', content: retryPrompt });
+            if (lastMsg?.role === 'user' && consecutiveEmpty <= 2) {
+                messages.push({ role: 'user', content: 'Continue.' });
                 if (!quiet) {
-                    renderer?.writeDim(`  [empty response #${consecutiveEmpty}, retrying]`);
+                    renderer?.writeDim(`  [empty response, retrying]`);
                 }
                 continue;
             }
@@ -387,31 +214,133 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
         }
         if (validCalls.length === 0) {
             if (invalidCalls.length > 0) {
-                const feedback = `[Tool call error(s)]\n${invalidCalls.join('\n')}\n\nFix the tool call format and try again. Use ONLY valid tool names: bash, read_file, write_file, edit_file, list_dir, create_dir, delete_file, copy_file, move_file, file_info, glob_search, grep_search, tree, web_search, web_fetch, plan, todo, question, approve.`;
-                if (!quiet) {
-                    renderer?.writeError(`  [invalid tool call: ${invalidCalls[0]}]`);
+                // If the response has substantial text outside tool_call tags,
+                // it's a description with examples — not a failed tool call attempt.
+                const textOutside = response.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '').trim();
+                if (textOutside.length < 100) {
+                    const feedback = `[Tool call error(s)]\n${invalidCalls.join('\n')}\n\nFix the tool call format and try again. Use ONLY valid tool names: bash, read_file, write_file, edit_file, list_dir, create_dir, delete_file, copy_file, move_file, file_info, glob_search, grep_search, tree, web_search, web_fetch, plan, todo, question, approve, subagent.`;
+                    if (!quiet) {
+                        renderer?.writeError(`  [invalid tool call: ${invalidCalls[0]}]`);
+                    }
+                    messages.push({ role: 'tool', content: feedback, tool_call_id: `invalid-${Date.now()}` });
+                    continue;
                 }
-                messages.push({ role: 'tool', content: feedback, tool_call_id: `invalid-${Date.now()}` });
-                continue;
+                // Text response with example tool calls — just log and proceed
+                logWarn('LOOP', `ignored ${invalidCalls.length} invalid tool call(s) in descriptive text`);
             }
-            // Nudge model to continue working after a tool result
+            // Nudge model to continue working after a tool result — but only if
+            // the agent didn't already write a meaningful text response.
             if (continuationNudges < 2) {
                 const lastThree = messages.slice(-3);
                 const hasRecentToolResult = lastThree.some(m => m.role === 'tool');
-                if (hasRecentToolResult) {
+                const alreadyResponded = response.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '').trim().length > 20;
+                if (hasRecentToolResult && !alreadyResponded) {
                     continuationNudges++;
                     if (!quiet) {
                         renderer?.writeDim(`  [nudge ${continuationNudges}/2: continue working]`);
                     }
-                    messages.push({ role: 'user', content: '[Tool result received. Continue: call the next tool or write the final summary. Do NOT just repeat the plan — take action.]' });
+                    messages.push({ role: 'user', content: '[Tool result received. Write a response to the user. Do NOT call additional tools unless there is actual work to do.]' });
                     continue;
                 }
             }
             if (!skillsAutoLoaded) {
+                // If model claims done but has created files, remind about completeness
+                if (createdFiles.length > 0) {
+                    const textOutside = response.replace(/<tool_call>[\s\S]*?<\/tool_call>/g, '').trim();
+                    const looksLikeDone = /done|готово|создан|выполн|completed|finished/i.test(textOutside);
+                    if (looksLikeDone) {
+                        messages.push({
+                            role: 'user',
+                            content: `Files created: ${createdFiles.join(', ')}. Before finishing — verify all files are complete and connected to each other. If any file is missing or not imported, continue working.`,
+                        });
+                        continuationNudges = 0;
+                        continue;
+                    }
+                }
                 return { messages };
             }
             continue;
         }
+        // Track consecutive read_file calls to the same file for consolidation
+        let lastReadFile = null;
+        // ENFORCEMENT: if plan has 3+ steps, block write_file and force subagent
+        const planSteps = showPlan();
+        const hasMultiStepPlan = !planSteps.startsWith('No active plan') && (planSteps.match(/\n/g) || []).length >= 3;
+        if (hasMultiStepPlan) {
+            const directWrites = validCalls.filter(c => c.parsed.name === 'write_file' || c.parsed.name === 'edit_file');
+            const hasSubagent = validCalls.some(c => c.parsed.name === 'subagent');
+            if (directWrites.length > 0 && !hasSubagent) {
+                // Block direct writes — model must use subagent
+                for (const wc of directWrites) {
+                    const idx = validCalls.indexOf(wc);
+                    if (idx !== -1)
+                        validCalls.splice(idx, 1);
+                    const blockId = `call-${Date.now()}-${step}-${Math.random().toString(36).slice(2, 6)}`;
+                    messages.push({
+                        role: 'tool',
+                        content: `BLOCKED: You have a plan with multiple steps. Use subagent tool instead of write_file. Example: subagent("Create file X. Context: Y already exists.") Each subagent gets fresh context and works independently.`,
+                        tool_call_id: blockId,
+                    });
+                }
+                if (!quiet) {
+                    renderer?.writeWarning(`  [blocked ${directWrites.length} direct writes — use subagent for multi-step plans]`);
+                }
+            }
+        }
+        // ESCALATION: block write_file when creating 3+ files without subagent (no plan case)
+        if (!hasMultiStepPlan) {
+            const hasWrite = validCalls.some(c => c.parsed.name === 'write_file');
+            const hasSubagentNow = validCalls.some(c => c.parsed.name === 'subagent');
+            if (hasSubagentNow) {
+                directWriteStreak = 0;
+            }
+            else if (hasWrite) {
+                const writeCount = validCalls.filter(c => c.parsed.name === 'write_file').length;
+                directWriteStreak += writeCount;
+                if (directWriteStreak >= 3) {
+                    const directWrites = validCalls.filter(c => c.parsed.name === 'write_file');
+                    for (const wc of directWrites) {
+                        const idx = validCalls.indexOf(wc);
+                        if (idx !== -1)
+                            validCalls.splice(idx, 1);
+                        const blockId = `call-${Date.now()}-${step}-${Math.random().toString(36).slice(2, 6)}`;
+                        messages.push({
+                            role: 'tool',
+                            content: `BLOCKED: You're creating file #${directWriteStreak} without subagent. For 3+ new files, use subagent for each one to maintain fresh context. Example: subagent("Create file X. Context: Y already exists.")`,
+                            tool_call_id: blockId,
+                        });
+                    }
+                    if (!quiet) {
+                        renderer?.writeWarning(`  [blocked ${directWrites.length} writes: ${directWriteStreak} files without subagent — use subagent for multi-file projects]`);
+                    }
+                }
+            }
+            else {
+                // Non-write tool calls don't reset the counter but also don't increment
+                const hasNonWriteTool = validCalls.length > 0 && !hasWrite;
+                if (hasNonWriteTool && directWriteStreak > 0) {
+                    // New file creations should not be penalized across different operation types
+                }
+            }
+        }
+        // ENFORCEMENT: one file write at a time — block extra write_file/edit_file calls
+        const writeCalls = validCalls.filter(c => c.parsed.name === 'write_file' || c.parsed.name === 'edit_file');
+        if (writeCalls.length > 1) {
+            // Keep only the first write call, block the rest
+            const blocked = writeCalls.slice(1);
+            validCalls.splice(validCalls.indexOf(blocked[0]), blocked.length);
+            for (const bc of blocked) {
+                const blockId = `call-${Date.now()}-${step}-${Math.random().toString(36).slice(2, 6)}`;
+                messages.push({
+                    role: 'tool',
+                    content: `BLOCKED: Only one file write per response is allowed. You wrote ${writeCalls.length} files at once. Complete the first file, then write the next one.`,
+                    tool_call_id: blockId,
+                });
+            }
+            if (!quiet) {
+                renderer?.writeWarning(`  [blocked ${blocked.length} extra file writes — one at a time]`);
+            }
+        }
         for (const call of validCalls) {
             const { parsed, cmd } = call;
             const isBash = parsed.name === 'bash';
@@ -435,8 +364,12 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
             }
             if (pendingSyntaxError && !isBash) {
                 const isWriteOp = parsed.name === 'write_file' || parsed.name === 'edit_file';
-                if (isWriteOp && String(parsed.arguments.path ?? '') !== pendingSyntaxError) {
-                    const blocked = `BLOCKED: You have a syntax error in ${pendingSyntaxError}. Fix it first before writing new files.`;
+                const newPath = String(parsed.arguments.path ?? '');
+                // Allow editing config files (tsconfig.json, package.json) since they
+                // can fix syntax errors (e.g. missing jsx flag in tsconfig)
+                const isConfig = newPath === 'tsconfig.json' || newPath === 'package.json';
+                if (isWriteOp && newPath !== pendingSyntaxError && !isConfig) {
+                    const blocked = `BLOCKED: You have a syntax error in ${pendingSyntaxError}. Fix it first before writing new files. If the error is about jsx, module resolution, or missing types — edit tsconfig.json (it is exempt from this block).`;
                     if (!quiet) {
                         renderer?.writeError(`  [blocked: fix syntax error in ${pendingSyntaxError} first]`);
                     }
@@ -456,6 +389,14 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
                     renderer?.writeBracketTag('plan', 'create');
                 }
                 toolOutput = createPlan(planName, steps);
+                // If plan has 3+ steps, suggest using subagent for isolation
+                if (steps.length >= 3) {
+                    toolOutput += `\n\nIMPORTANT: Plan has ${steps.length} steps. Use subagent tool for EACH step to work in isolation:\n`;
+                    for (let i = 0; i < steps.length; i++) {
+                        toolOutput += `subagent("Step ${i + 1}: ${steps[i]}. List existing files and packages.")\n`;
+                    }
+                    toolOutput += `This prevents context loss. Do NOT use write_file directly — delegate to subagents.`;
+                }
                 if (!quiet && toolOutput) {
                     renderer?.writeNewline();
                     renderer?.writeLine(toolOutput);
@@ -624,6 +565,38 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
                         toolExitCode = 1;
                 }
             }
+            else if (parsed.name === 'subagent') {
+                // Subagent: isolated context for a single task
+                const task = String(parsed.arguments.task || '');
+                if (!task) {
+                    toolOutput = 'Error: task is required';
+                    toolExitCode = 1;
+                }
+                else {
+                    const autoContext = buildSubagentContext(process.cwd());
+                    logInfo('AGENT', `spawning subagent | task: "${task.slice(0, 150)}"`);
+                    try {
+                        const childResult = await runIsolatedLoop(provider, registry, task, autoContext, process.cwd(), quiet, renderer);
+                        toolOutput = childResult.summary;
+                        logInfo('AGENT', `subagent returned | files: ${childResult.createdFiles.length} | turns: ${childResult.turns} | errors: ${childResult.errors.length}`);
+                        if (childResult.createdFiles.length > 0) {
+                            for (const f of childResult.createdFiles) {
+                                if (!createdFiles.includes(f))
+                                    createdFiles.push(f);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        toolOutput = `Subagent error: ${e.message}`;
+                        toolExitCode = 1;
+                        logError('AGENT', `subagent error: ${e.message}`);
+                    }
+                }
+                const subTime = ((performance.now() - toolStart) / 1000).toFixed(1);
+                if (!quiet) {
+                    renderer?.writeToolResult(subTime, toolExitCode, toolOutput.slice(0, 300));
+                }
+            }
             else if (isBash && cmd.startsWith('plan ')) {
                 const planArgs = cmd.slice(5).trim();
                 const { action, params } = parsePlanCommand(planArgs);
@@ -744,6 +717,40 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
                 autoLearnFromError(hookCmd, toolExitCode !== 0 ? toolOutput : '', '');
             }
             runPostToolUseHooks(process.cwd(), parsed.name, hookCmd, toolOutput, toolExitCode);
+            // Track sequential read_file calls for consolidation
+            if (!isBash && parsed.name === 'read_file' && toolExitCode === 0) {
+                const filePath = String(parsed.arguments.path ?? '');
+                const offset = Math.max(1, Number(parsed.arguments.offset ?? 1));
+                const limit = Math.max(1, Number(parsed.arguments.limit ?? 500));
+                if (lastReadFile && lastReadFile.path === filePath && offset === lastReadFile.offset + lastReadFile.limit) {
+                    // Sequential read — merge with previous result
+                    lastReadFile.content += '\n' + toolOutput;
+                    lastReadFile.offset = offset;
+                    lastReadFile.limit = limit;
+                    // Replace the last tool message content with merged content
+                    for (let i = messages.length - 1; i >= 0; i--) {
+                        if (messages[i].role === 'tool' && messages[i].tool_call_id === lastReadFile.toolId) {
+                            messages[i].content = lastReadFile.content;
+                            break;
+                        }
+                    }
+                    // Remove the trailing "Continue." nudge + the new tool result that would be pushed
+                    while (messages.length > 0 && messages[messages.length - 1].role === 'user' && messages[messages.length - 1].content === 'Continue.') {
+                        messages.pop();
+                    }
+                    if (!quiet) {
+                        renderer?.writeBracketTag('consolidate', `merged read_file chunks for ${filePath}`);
+                    }
+                    continue; // skip pushing this result separately
+                }
+                else {
+                    // New file or non-sequential — start fresh
+                    lastReadFile = { path: filePath, offset, limit, content: toolOutput, toolId };
+                }
+            }
+            else if (!isBash && parsed.name !== 'read_file') {
+                lastReadFile = null;
+            }
             // Syntax check after file write operations
             let hasSyntaxError = false;
             if (toolExitCode === 0) {
@@ -786,7 +793,19 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
                                 }
                             }
                             catch { /* ignore read errors */ }
-                            toolOutput = `SYNTAX ERROR in ${filePath}:\n${syntaxResult}${contextLines}\n\nDo NOT rewrite the entire file. Use edit_file to fix the specific broken line:\n{"name":"edit_file","arguments":{"path":"${filePath}","old_string":"broken code here","new_string":"fixed code here"}}`;
+                            toolOutput = `SYNTAX ERROR in ${filePath}:\n${syntaxResult}${contextLines}`;
+                            // Detect config-related TS errors (missing jsx, module issues, etc.)
+                            const isConfigError = syntaxResult.includes('TS17004')
+                                || syntaxResult.includes('TS2307')
+                                || syntaxResult.includes('Cannot find module')
+                                || syntaxResult.includes('jsx')
+                                || syntaxResult.includes('moduleResolution');
+                            if (isConfigError) {
+                                toolOutput += `\n\nThis looks like a tsconfig.json configuration issue, NOT a code syntax error.\nCheck tsconfig.json — you may need to add "jsx": "react-jsx" or fix module settings.\nDo NOT modify the source code to work around config errors. Edit tsconfig.json instead.`;
+                            }
+                            else {
+                                toolOutput += `\n\nDo NOT rewrite the entire file. Use edit_file to fix the specific broken line:\n{"name":"edit_file","arguments":{"path":"${filePath}","old_string":"broken code here","new_string":"fixed code here"}}`;
+                            }
                             hasSyntaxError = true;
                             pendingSyntaxError = filePath;
                         }
@@ -802,6 +821,10 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
                                 collectCodingStyle(filePath, fullContent);
                             }
                             catch { /* ignore */ }
+                            // Track created/modified files for completion reporting
+                            if (!hasSyntaxError && !createdFiles.includes(filePath)) {
+                                createdFiles.push(filePath);
+                            }
                         }
                     }
                 }
@@ -822,9 +845,18 @@ export async function runAgentLoop(provider, registry, prompt, contextManager, p
             }
             messages.push({
                 role: 'tool',
-                content: toolOutput.slice(0, 4000),
+                content: toolOutput.slice(0, 8000),
                 tool_call_id: toolId,
             });
+            // Push a continuation nudge after every tool result
+            // Include created files list so model doesn't lose track
+            const nudge = createdFiles.length > 0
+                ? `Continue. Created: ${createdFiles.join(', ')}`
+                : 'Continue.';
+            messages.push({
+                role: 'user',
+                content: nudge,
+            });
             if (hasSyntaxError) {
                 break;
             }