@element47/ag 4.5.5 → 4.5.6

package/dist/core/agent.js

@@ -1,10 +1,7 @@
-import { readdirSync, statSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { execFileSync } from 'node:child_process';
 import { AgentEventEmitter } from './events.js';
 import { discoverExtensions, loadExtensions } from './extensions.js';
 import { C } from './colors.js';
-import { loadContext, loadHistory, appendHistory, getStats, clearProject, clearAll, paths, saveGlobalMemory, saveProjectMemory, savePlan, appendPlan, setActivePlan, getActivePlanName, loadGlobalMemory, loadProjectMemory, loadPlan, loadPlanByName, listPlans } from '../memory/memory.js';
+import { loadContext, loadHistory, appendHistory, getStats, clearProject, clearAll, paths, saveGlobalMemory, saveProjectMemory, savePlan, appendPlan, setActivePlan, getActivePlanName, loadGlobalMemory, loadProjectMemory, loadPlan, loadPlanByName, listPlans, cleanupTasks } from '../memory/memory.js';
 import { bashToolFactory } from '../tools/bash.js';
 import { memoryTool } from '../tools/memory.js';
 import { planTool } from '../tools/plan.js';
@@ -17,123 +14,14 @@ import { grepTool } from '../tools/grep.js';
 import { fileTool } from '../tools/file.js';
 import { discoverSkills, buildSkillCatalog, getAlwaysOnContent, loadSkillTools } from './skills.js';
 import { ContextTracker } from './context.js';
+import { startSpinner, fetchWithRetry, truncateToolResult, raceAll } from './utils.js';
+import { getEnvironmentContext, isReadOnlyToolCall, getProjectListing, buildRequestBody } from './prompt.js';
+import { compactMessages, COMPACT_THRESHOLD, COMPACT_HEAD_KEEP, COMPACT_TAIL_KEEP } from './compaction.js';
 export const MAX_ITERATIONS_REACHED = '[Max iterations reached]';
-const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-function startSpinner(label) {
-    if (!process.stderr.isTTY) {
-        // Non-TTY fallback: static status line
-        process.stderr.write(`  ... ${label}\n`);
-        return () => { };
-    }
-    let i = 0;
-    process.stderr.write(`  ${C.dim}${SPINNER_FRAMES[0]} ${label}${C.reset}\n`);
-    const id = setInterval(() => {
-        process.stderr.write(`\x1b[A\x1b[K  ${C.dim}${SPINNER_FRAMES[i++ % SPINNER_FRAMES.length]} ${label}${C.reset}\n`);
-    }, 80);
-    return () => {
-        clearInterval(id);
-        process.stderr.write('\x1b[A\x1b[K');
-    };
-}
+// Re-export extracted functions for backwards compatibility
+export { fetchWithRetry, truncateToolResult, raceAll } from './utils.js';
+export { getEnvironmentContext, isReadOnlyToolCall } from './prompt.js';
 const MAX_MESSAGES = 200;
-const COMPACT_THRESHOLD = 0.9;
-const MAX_TOOL_RESULT_CHARS = 32768;
-const TRUNCATION_HEAD_LINES = 100;
-const TRUNCATION_TAIL_LINES = 100;
-const COMPACT_HEAD_KEEP = 2;
-const COMPACT_TAIL_KEEP = 10;
-const COMPACT_MSG_CHARS = 500;
-const COMPACT_TOTAL_CHARS = 50000;
-const COMPACTION_PROMPT = `Summarize this conversation between a user and a coding assistant. Extract essential context needed to continue working.
-
-You MUST preserve exactly:
-- All file paths that were read, edited, or created (full paths, not abbreviated)
-- All error messages and their causes
-- Decisions made and their rationale
-- Current task: what was asked, what's done, what remains
-- Any user preferences or constraints mentioned
-
-Format as structured bullet points. Be concise but never drop paths, error details, or decision rationale — these are critical for the assistant to continue without re-reading files or re-discovering errors.`;
-export function getEnvironmentContext(cwd) {
-    const lines = ['# Environment'];
-    lines.push(`Date: ${new Date().toISOString().slice(0, 10)}`);
-    lines.push(`OS: ${process.platform}`);
-    lines.push(`CWD: ${cwd}`);
-    // Git info
-    if (existsSync(join(cwd, '.git'))) {
-        try {
-            const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, encoding: 'utf-8', timeout: 3000 }).trim();
-            lines.push(`Git branch: ${branch}`);
-            const dirty = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf-8', timeout: 3000 }).trim();
-            if (dirty) {
-                const count = dirty.split('\n').length;
-                lines.push(`Git status: ${count} changed file(s)`);
-            }
-        }
-        catch { /* not a git repo or git not installed */ }
-    }
-    // Detect stack from config files
-    const detectedStack = [];
-    const stackHints = [
-        ['package.json', 'Node.js'],
-        ['tsconfig.json', 'TypeScript'],
-        ['Cargo.toml', 'Rust'],
-        ['go.mod', 'Go'],
-        ['pyproject.toml', 'Python'],
-        ['requirements.txt', 'Python'],
-        ['Gemfile', 'Ruby'],
-        ['pom.xml', 'Java/Maven'],
-        ['build.gradle', 'Java/Gradle'],
-    ];
-    for (const [file, stack] of stackHints) {
-        if (existsSync(join(cwd, file)))
-            detectedStack.push(stack);
-    }
-    if (detectedStack.length > 0)
-        lines.push(`Stack: ${detectedStack.join(', ')}`);
-    return lines.join('\n');
-}
-/** Tool actions that are read-only and never need confirmation */
-const READ_ONLY_CALLS = {
-    grep: true, // all grep actions are read-only
-    memory: true, // saving memory is safe
-    plan: true, // managing plans is safe
-    skill: true, // activating skills is safe
-    file: new Set(['read', 'list']), // only read/list are safe
-    git: new Set(['status']), // only status is safe
-    web: new Set(['search']), // search is safe, fetch needs confirm
-    task: true, // all task actions are safe (internal state)
-    agent: true, // sub-agent spawning is safe (internal orchestration)
-};
-export function isReadOnlyToolCall(toolName, args) {
-    const rule = READ_ONLY_CALLS[toolName];
-    if (rule === true)
-        return true;
-    if (rule instanceof Set)
-        return rule.has(args.action);
-    return false;
-}
-export function truncateToolResult(result) {
-    if (result.length <= MAX_TOOL_RESULT_CHARS)
-        return result;
-    const lines = result.split('\n');
-    if (lines.length <= TRUNCATION_HEAD_LINES + TRUNCATION_TAIL_LINES)
-        return result;
-    const head = lines.slice(0, TRUNCATION_HEAD_LINES);
-    const tail = lines.slice(-TRUNCATION_TAIL_LINES);
-    const omitted = lines.length - TRUNCATION_HEAD_LINES - TRUNCATION_TAIL_LINES;
-    return [...head, `\n... [${omitted} lines truncated] ...\n`, ...tail].join('\n');
-}
-/** Yield promise results as they resolve (like Promise.all but streaming) */
-export async function* raceAll(promises) {
-    const wrapped = promises.map((p, i) => p.then(v => ({ i, v })));
-    const settled = new Set();
-    while (settled.size < promises.length) {
-        const result = await Promise.race(wrapped.filter((_, idx) => !settled.has(idx)));
-        settled.add(result.i);
-        yield result.v;
-    }
-}
 export class Agent {
     apiKey;
     model;
@@ -159,6 +47,7 @@ export class Agent {
     spinnerControl = null;
     silent;
     noHistory;
+    steerQueue = [];
     constructor(config = {}) {
         this.apiKey = config.apiKey || process.env.OPENROUTER_API_KEY || '';
         if (!this.apiKey)
@@ -197,6 +86,11 @@ export class Agent {
 - Never amend commits or force-push without the user asking.
 - Never commit files that contain secrets (.env, credentials, keys).
 
+# History
+- Your conversation history is stored at the path shown in <history-file>. Each line is JSON with a "ts" timestamp field.
+- When the user asks about past conversations, ALWAYS search it with grep(action=search, path="<the history-file path>", pattern="<search term>"). Pass the exact file path — do not search broadly or omit the path.
+- Use the "ts" field to answer time-based questions (e.g., "what did we discuss last Tuesday?").
+
 # Output
 - Be concise. Short responses, no filler, no trailing summaries of what you just did.
 - When referencing code, include the file path and relevant context.
@@ -216,7 +110,7 @@ export class Agent {
 - plan — create and manage multi-step task plans
 - web(fetch/search) — fetch pages or search the web
 - task(create/list/update/read/remove/clear) — manage tasks for multi-step work
-- agent(prompt, taskId?, model?) — spawn sub-agents for parallel work
+- agent(prompt, taskId?, model?) — spawn sub-agents for parallel work. Always include key findings from sub-agents in your response — the user cannot see tool output in full.
 - skill — activate a skill by name`;
         this.systemPromptSuffix = config.systemPromptSuffix || '';
         this.silent = config.silent ?? false;
@@ -251,6 +145,7 @@ export class Agent {
         // Load recent conversation history for continuity (sub-agents start clean)
         if (!config.noHistory) {
             this.messages = loadHistory(this.cwd);
+            cleanupTasks(this.cwd);
         }
     }
     addTool(tool) {
@@ -298,45 +193,10 @@ export class Agent {
         this.cachedCatalog = buildSkillCatalog(this.allSkills);
         this.cachedAlwaysOn = getAlwaysOnContent(this.allSkills);
     }
-    getProjectListing() {
-        const MAX_ENTRIES = 30;
-        const IGNORE = new Set(['.git', 'node_modules', 'dist', 'build', '.next', '.cache', '__pycache__']);
-        try {
-            const entries = readdirSync(this.cwd, { withFileTypes: true });
-            const lines = [];
-            for (const e of entries) {
-                if (lines.length >= MAX_ENTRIES) {
-                    lines.push(`  ... (${entries.length - MAX_ENTRIES} more)`);
-                    break;
-                }
-                if (IGNORE.has(e.name))
-                    continue;
-                if (e.name.startsWith('.') && e.name !== '.')
-                    continue;
-                if (e.isDirectory()) {
-                    lines.push(`  [dir] ${e.name}/`);
-                }
-                else {
-                    try {
-                        const s = statSync(join(this.cwd, e.name));
-                        const kb = (s.size / 1024).toFixed(1);
-                        lines.push(`  ${e.name} (${kb}KB)`);
-                    }
-                    catch {
-                        lines.push(`  ${e.name}`);
-                    }
-                }
-            }
-            return lines.length > 0 ? `Project files (${this.cwd}):\n${lines.join('\n')}` : '';
-        }
-        catch {
-            return '';
-        }
-    }
     get systemPrompt() {
         const parts = [this.baseSystemPrompt];
         parts.push(getEnvironmentContext(this.cwd));
-        const listing = this.getProjectListing();
+        const listing = getProjectListing(this.cwd);
         if (listing)
             parts.push(listing);
         if (this.cachedContext)
@@ -352,25 +212,14 @@ export class Agent {
             parts.push(this.systemPromptSuffix);
         return parts.join('\n\n');
     }
-    /** Build the JSON request body for chat completions, with prompt caching for supported models */
-    buildRequestBody(stream, overrides) {
-        const sysPrompt = overrides?.systemPrompt ?? this.systemPrompt;
-        const msgs = overrides?.messages ?? this.messages;
-        const body = {
+    getRequestBody(stream, overrides) {
+        return buildRequestBody({
             model: this.model,
-            messages: [{ role: 'system', content: sysPrompt }, ...msgs],
+            systemPrompt: overrides?.systemPrompt ?? this.systemPrompt,
+            messages: overrides?.messages ?? this.messages,
             tools: Array.from(this.tools.values()).map(t => ({ type: t.type, function: t.function })),
-            tool_choice: 'auto',
-        };
-        if (stream) {
-            body.stream = true;
-            body.stream_options = { include_usage: true };
-        }
-        // Enable prompt caching for Anthropic models (top-level cache_control)
-        if (this.model.startsWith('anthropic/') || this.model.includes('claude')) {
-            body.cache_control = { type: 'ephemeral' };
-        }
-        return body;
+            stream,
+        });
     }
     async activateSkill(name) {
         const skill = this.allSkills.find(s => s.name === name);
@@ -393,264 +242,59 @@ export class Agent {
         return `Skill "${name}" activated. Instructions loaded.`;
     }
     async compactConversation(customSummary) {
-        const minMessages = COMPACT_HEAD_KEEP + COMPACT_TAIL_KEEP + 4;
-        if (this.messages.length <= minMessages)
+        const result = await compactMessages(this.messages, { baseURL: this.baseURL, apiKey: this.apiKey, model: this.model }, customSummary);
+        if (!result)
             return;
-        const head = this.messages.slice(0, COMPACT_HEAD_KEEP);
-        const middle = this.messages.slice(COMPACT_HEAD_KEEP, -COMPACT_TAIL_KEEP);
-        const tail = this.messages.slice(-COMPACT_TAIL_KEEP);
-        let summary;
-        if (customSummary) {
-            // Use extension-provided summary instead of LLM call
-            summary = customSummary;
-        }
-        else {
-            // Format middle messages for summarization, capping total size
-            let totalChars = 0;
-            const formatted = [];
-            for (const m of middle) {
-                let line;
-                if (m.tool_calls?.length) {
-                    const names = m.tool_calls.map(tc => tc.function.name).join(', ');
-                    line = `[assistant]: (tool call: ${names})`;
-                }
-                else if (m.role === 'tool') {
-                    line = `[tool result]: ${(m.content || '').slice(0, COMPACT_MSG_CHARS)}`;
-                }
-                else {
-                    line = `[${m.role}]: ${(m.content || '').slice(0, COMPACT_MSG_CHARS)}`;
-                }
-                if (totalChars + line.length > COMPACT_TOTAL_CHARS)
-                    break;
-                totalChars += line.length;
-                formatted.push(line);
-            }
-            const stopSpinner = startSpinner('compacting context');
-            let stopped = false;
-            try {
-                const res = await fetch(`${this.baseURL}/chat/completions`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` },
-                    body: JSON.stringify({
-                        model: this.model,
-                        messages: [
-                            { role: 'system', content: COMPACTION_PROMPT },
-                            { role: 'user', content: formatted.join('\n\n') }
-                        ]
-                    })
-                });
-                if (!res.ok)
-                    throw new Error(`API ${res.status}: ${await res.text()}`);
-                const body = await res.json();
-                summary = body.choices?.[0]?.message?.content;
-                if (!summary)
-                    throw new Error('No summary returned');
-                stopSpinner();
-                stopped = true;
-            }
-            finally {
-                if (!stopped)
-                    stopSpinner();
-            }
-        }
-        const summaryMsg = {
-            role: 'user',
-            content: `[Conversation compacted — summary of ${middle.length} earlier messages]\n\n${summary}`
-        };
-        this.messages = [...head, summaryMsg, ...tail];
-        this.appendToHistory(summaryMsg);
+        this.messages = result.messages;
+        this.appendToHistory(result.summaryMsg);
         // Re-estimate context usage from the compacted messages
         const compactedChars = this.messages.reduce((sum, m) => sum + (m.content?.length ?? 0), 0)
             + this.systemPrompt.length;
         this.contextTracker.estimateFromChars(compactedChars);
-        process.stderr.write(`  ${C.yellow}Context compacted: ${middle.length} messages → summary${C.reset}\n`);
     }
     async chat(content, signal) {
-        // ── input event ──
-        const inputEvent = { content, skip: false };
-        await this.events.emit('input', inputEvent);
-        if (inputEvent.skip)
-            return '';
-        content = inputEvent.content;
-        const userMessage = { role: 'user', content };
-        this.messages.push(userMessage);
-        this.appendToHistory(userMessage);
-        // Cap in-memory messages to prevent unbounded growth
-        if (this.messages.length > MAX_MESSAGES) {
-            this.messages = this.messages.slice(-MAX_MESSAGES);
-        }
-        for (let i = 0; i < this.maxIterations; i++) {
-            if (signal?.aborted) {
-                this.messages.push({ role: 'assistant', content: '[interrupted by user]' });
-                return '[interrupted by user]';
-            }
-            // ── turn_start event ──
-            await this.events.emit('turn_start', { iteration: i, maxIterations: this.maxIterations, messageCount: this.messages.length });
-            const iterLabel = this.maxIterations > 1 ? ` [${i + 1}/${this.maxIterations}]` : '';
-            const stopSpinner = this.silent ? () => { } : startSpinner(`thinking${iterLabel}`);
-            // ── before_compact event ──
-            if (!this.compactionInProgress && this.contextTracker.shouldCompact(COMPACT_THRESHOLD)) {
-                const compactEvent = { messageCount: this.messages.length, cancel: false, customSummary: undefined };
-                await this.events.emit('before_compact', compactEvent);
-                if (!compactEvent.cancel) {
-                    this.compactionInProgress = true;
-                    try {
-                        await this.compactConversation(compactEvent.customSummary);
-                    }
-                    catch (e) {
-                        if (!this.silent)
-                            process.stderr.write(`  ${C.dim}Compaction failed: ${e} — falling back to truncation${C.reset}\n`);
-                        const keep = COMPACT_HEAD_KEEP + COMPACT_TAIL_KEEP;
-                        if (this.messages.length > keep) {
-                            const head = this.messages.slice(0, COMPACT_HEAD_KEEP);
-                            const tail = this.messages.slice(-COMPACT_TAIL_KEEP);
-                            const truncMsg = {
-                                role: 'user',
-                                content: `[Conversation truncated — ${this.messages.length - keep} older messages removed to stay within context limit]`
-                            };
-                            this.messages = [...head, truncMsg, ...tail];
+        let finalContent = '';
+        let stopSpinner = () => { };
+        try {
+            for await (const chunk of this.chatStream(content, signal)) {
+                switch (chunk.type) {
+                    case 'thinking':
+                        stopSpinner();
+                        stopSpinner = this.silent ? () => { } : startSpinner(chunk.content || 'thinking');
+                        break;
+                    case 'text':
+                        stopSpinner();
+                        stopSpinner = () => { };
+                        break;
+                    case 'tool_start':
+                        stopSpinner();
+                        stopSpinner = this.silent ? () => { } : startSpinner(`[${chunk.toolName}] ${(chunk.content || '').slice(0, 80)}`);
+                        break;
+                    case 'tool_end':
+                        stopSpinner();
+                        stopSpinner = () => { };
+                        if (!this.silent) {
+                            const icon = chunk.success ? `${C.green}✓` : `${C.red}✗`;
+                            const preview = (chunk.content || '').slice(0, 150).split('\n')[0];
+                            process.stderr.write(`  ${icon} ${C.dim}[${chunk.toolName}]${C.reset} ${C.dim}${preview}${(chunk.content || '').length > 150 ? '...' : ''}${C.reset}\n`);
                         }
-                    }
-                    finally {
-                        this.compactionInProgress = false;
-                    }
-                }
-            }
-            // ── before_request event ──
-            const reqEvent = { messages: this.messages, systemPrompt: this.systemPrompt, model: this.model, stream: false };
-            await this.events.emit('before_request', reqEvent);
-            let msg;
-            try {
-                const res = await fetch(`${this.baseURL}/chat/completions`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` },
-                    body: JSON.stringify(this.buildRequestBody(false, { messages: reqEvent.messages, systemPrompt: reqEvent.systemPrompt })),
-                    signal
-                });
-                if (!res.ok)
-                    throw new Error(`API ${res.status}: ${await res.text()}`);
-                const body = await res.json();
-                if (!body || typeof body !== 'object' || !Array.isArray(body.choices) || !body.choices[0]?.message) {
-                    throw new Error(`Unexpected API response shape: ${JSON.stringify(body).slice(0, 200)}`);
-                }
-                msg = body.choices[0].message;
-                if (!msg)
-                    throw new Error('No response from model');
-                if (body.usage)
-                    this.contextTracker.update(body.usage);
-            }
-            finally {
-                stopSpinner();
-            }
-            // ── after_response event ──
-            await this.events.emit('after_response', { message: msg, usage: undefined });
-            this.messages.push(msg);
-            this.appendToHistory(msg);
-            if (!msg.tool_calls?.length) {
-                // ── turn_end event (no tools) ──
-                await this.events.emit('turn_end', { iteration: i, hadToolCalls: false, toolCallCount: 0 });
-                return msg.content || '';
-            }
-            // Permission checks — run sequentially so prompts don't overlap
-            const permissionDecisions = new Map();
-            for (const call of msg.tool_calls) {
-                const tool = this.tools.get(call.function.name);
-                if (!tool)
-                    continue;
-                let args;
-                try {
-                    args = JSON.parse(call.function.arguments || '{}');
-                }
-                catch {
-                    continue;
-                }
-                if (this.confirmToolCall && !isReadOnlyToolCall(call.function.name, args)) {
-                    permissionDecisions.set(call.id, await this.confirmToolCall(call.function.name, args, tool.permissionKey));
-                }
-            }
-            // Combined spinner for parallel tools (shows elapsed time)
-            const usesCombinedSpinner = !this.silent && msg.tool_calls.length > 1;
-            let stopCombinedSpinner = () => { };
-            if (usesCombinedSpinner) {
-                const toolNames = msg.tool_calls.map((c) => c.function.name);
-                const unique = [...new Set(toolNames)];
-                const label = unique.length === 1 && unique[0] === 'agent'
-                    ? `${toolNames.length} sub-agents running`
-                    : `${toolNames.length} tools running: ${unique.join(', ')}`;
-                const start = Date.now();
-                stopCombinedSpinner = startSpinner(`${label} (0s)`);
-                const timerId = setInterval(() => {
-                    const elapsed = Math.round((Date.now() - start) / 1000);
-                    // Update spinner label with elapsed time — clear line then rewrite
-                    if (process.stderr.isTTY) {
-                        process.stderr.write(`\x1b[A\x1b[K  ${C.dim}${SPINNER_FRAMES[elapsed % SPINNER_FRAMES.length]} ${label} (${elapsed}s)${C.reset}\n`);
-                    }
-                }, 1000);
-                const origStop = stopCombinedSpinner;
-                stopCombinedSpinner = () => { clearInterval(timerId); origStop(); };
-            }
-            // Execute tool calls in parallel (permissions already resolved)
-            const toolPromises = msg.tool_calls.map(async (call) => {
-                const tool = this.tools.get(call.function.name);
-                if (!tool) {
-                    return { call, content: `Error: unknown tool "${call.function.name}"` };
-                }
-                let args;
-                try {
-                    args = JSON.parse(call.function.arguments || '{}');
-                }
-                catch {
-                    return { call, content: 'Error: malformed tool arguments' };
-                }
-                if (permissionDecisions.get(call.id) === 'deny') {
-                    return { call, content: 'Tool call denied by user.' };
-                }
-                // ── tool_call event ──
-                const tcEvent = { toolName: call.function.name, toolCallId: call.id, args, block: false, blockReason: undefined };
-                await this.events.emit('tool_call', tcEvent);
-                if (tcEvent.block) {
-                    return { call, content: tcEvent.blockReason || 'Blocked by extension' };
-                }
-                args = tcEvent.args;
-                const summary = String(args.command ?? args.action ?? args.prompt ?? JSON.stringify(args)).slice(0, 80);
-                const stopToolSpinner = this.silent || usesCombinedSpinner ? () => { } : startSpinner(`[${call.function.name}] ${summary}`);
-                try {
-                    const rawResult = await tool.execute(args);
-                    let result = truncateToolResult(rawResult);
-                    let isError = result.startsWith('Error:') || result.startsWith('EXIT ');
-                    // ── tool_result event ──
-                    const trEvent = { toolName: call.function.name, toolCallId: call.id, args, content: result, isError };
-                    await this.events.emit('tool_result', trEvent);
-                    result = trEvent.content;
-                    isError = trEvent.isError;
-                    stopToolSpinner();
-                    const isErrorFinal = isError;
-                    return { call, content: result, isError: isErrorFinal };
-                }
-                catch (error) {
-                    stopToolSpinner();
-                    const errMsg = `Tool error: ${error}`;
-                    return { call, content: errMsg, isError: true };
-                }
-            });
-            const results = await Promise.all(toolPromises);
-            stopCombinedSpinner();
-            // Print tool results (deferred until after combined spinner clears)
-            if (!this.silent) {
-                for (const r of results) {
-                    const icon = r.isError ? `${C.red}✗` : `${C.green}✓`;
-                    const preview = r.content.slice(0, 150).split('\n')[0];
-                    process.stderr.write(`  ${icon} ${C.dim}[${r.call.function.name}]${C.reset} ${C.dim}${preview}${r.content.length > 150 ? '...' : ''}${C.reset}\n`);
+                        break;
+                    case 'done':
+                        finalContent = chunk.content || '';
+                        break;
+                    case 'interrupted':
+                        return '[interrupted by user]';
+                    case 'max_iterations':
+                        return MAX_ITERATIONS_REACHED;
+                    case 'steer':
+                        break;
                 }
             }
-            for (const { call, content } of results) {
-                this.messages.push({ role: 'tool', tool_call_id: call.id, content });
-                this.appendToHistory({ role: 'tool', tool_call_id: call.id, content });
-            }
-            // ── turn_end event ──
-            await this.events.emit('turn_end', { iteration: i, hadToolCalls: true, toolCallCount: msg.tool_calls.length });
         }
-        return MAX_ITERATIONS_REACHED;
+        finally {
+            stopSpinner();
+        }
+        return finalContent;
     }
     async *chatStream(content, signal) {
         // ── input event ──
@@ -672,6 +316,14 @@ export class Agent {
                 yield { type: 'interrupted' };
                 return;
             }
+            // ── Inject steer messages before next LLM turn ──
+            while (this.steerQueue.length > 0) {
+                const steer = this.steerQueue.shift();
+                const steerMsg = { role: 'user', content: steer };
+                this.messages.push(steerMsg);
+                this.appendToHistory(steerMsg);
+                yield { type: 'steer', content: steer };
+            }
             // ── turn_start event ──
             await this.events.emit('turn_start', { iteration: i, maxIterations: this.maxIterations, messageCount: this.messages.length });
             const iterLabel = this.maxIterations > 1 ? ` [${i + 1}/${this.maxIterations}]` : '';
@@ -685,7 +337,9 @@ export class Agent {
                     try {
                         await this.compactConversation(compactEvent.customSummary);
                     }
-                    catch {
+                    catch (e) {
+                        if (!this.silent)
+                            process.stderr.write(`  ${C.dim}Compaction failed: ${e} — falling back to truncation${C.reset}\n`);
                         const keep = COMPACT_HEAD_KEEP + COMPACT_TAIL_KEEP;
                         if (this.messages.length > keep) {
                             const head = this.messages.slice(0, COMPACT_HEAD_KEEP);
@@ -705,13 +359,13 @@ export class Agent {
             // ── before_request event ──
             const reqEvent = { messages: this.messages, systemPrompt: this.systemPrompt, model: this.model, stream: true };
             await this.events.emit('before_request', reqEvent);
-            // ── API call with abort signal ──
+            // ── API call with abort signal and retry ──
             let res;
             try {
-                res = await fetch(`${this.baseURL}/chat/completions`, {
+                res = await fetchWithRetry(`${this.baseURL}/chat/completions`, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.apiKey}` },
-                    body: JSON.stringify(this.buildRequestBody(true, { messages: reqEvent.messages, systemPrompt: reqEvent.systemPrompt })),
+                    body: JSON.stringify(this.getRequestBody(true, { messages: reqEvent.messages, systemPrompt: reqEvent.systemPrompt })),
                     signal
                 });
             }
@@ -853,9 +507,11 @@ export class Agent {
                     return JSON.parse(call.function.arguments || '{}');
                 }
                 catch {
-                    return {};
+                    return null;
                 } })();
-                const summary = String(args.command ?? args.action ?? args.prompt ?? call.function.name).slice(0, 80);
+                const summary = args
+                    ? String(args.command ?? args.action ?? args.prompt ?? call.function.name).slice(0, 80)
+                    : `${call.function.name} (malformed arguments)`;
                 yield { type: 'tool_start', toolName: call.function.name, toolCallId: call.id, content: summary };
             }
             // Permission checks — run sequentially so prompts don't overlap
@@ -871,6 +527,7 @@ export class Agent {
                     args = JSON.parse(call.function.arguments || '{}');
                 }
                 catch {
+                    permissionDecisions.set(call.id, 'deny');
                     continue;
                 }
                 if (this.confirmToolCall && !isReadOnlyToolCall(call.function.name, args)) {
@@ -927,6 +584,10 @@ export class Agent {
                 if (signal?.aborted)
                     break;
             }
+            // Re-estimate context so shouldCompact() reflects tool result sizes
+            if (!signal?.aborted) {
+                this.contextTracker.estimateFromChars(this.getTotalContextChars());
+            }
             // Fill placeholders for any tool calls that didn't complete (API requires all tool_call_ids)
             if (signal?.aborted && msg.tool_calls) {
                 for (const call of msg.tool_calls) {
@@ -951,7 +612,7 @@ export class Agent {
         const parts = [];
         parts.push({ label: 'System prompt', chars: this.baseSystemPrompt.length });
         parts.push({ label: 'Environment', chars: getEnvironmentContext(this.cwd).length });
-        const listing = this.getProjectListing();
+        const listing = getProjectListing(this.cwd);
         if (listing)
             parts.push({ label: 'Project files', chars: listing.length });
         // cachedContext contains global memory + project memory + plan, but we want them separate
@@ -1006,12 +667,17 @@ export class Agent {
     getApiKey() { return this.apiKey; }
     getCwd() { return this.cwd; }
     isSilent() { return this.silent; }
+    /** Queue a message to inject before the next LLM turn (non-destructive steering) */
+    queueSteer(message) {
+        this.steerQueue.push(message);
+    }
     setModel(model) { this.model = model; this.contextTracker = new ContextTracker(model); }
     setBaseURL(url) { this.baseURL = url; }
+    getConfirmToolCall() { return this.confirmToolCall; }
     setConfirmToolCall(cb) { this.confirmToolCall = cb; }
     async compactNow() { await this.compactConversation(); }
     async fetchModels(query) {
-        const res = await fetch(`${this.baseURL}/models`, {
+        const res = await fetchWithRetry(`${this.baseURL}/models`, {
             headers: { 'Authorization': `Bearer ${this.apiKey}` }
         });
         if (!res.ok)