cowork-os 0.3.21 → 0.3.25

package/dist/electron/electron/agent/executor.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskExecutor = void 0;
+const types_1 = require("../../shared/types");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const registry_1 = require("./tools/registry");
@@ -46,6 +47,7 @@ const pricing_1 = require("./llm/pricing");
 const custom_skill_loader_1 = require("./custom-skill-loader");
 const MemoryService_1 = require("../memory/MemoryService");
 const security_1 = require("./security");
+const builtin_settings_1 = require("./tools/builtin-settings");
 class AwaitingUserInputError extends Error {
     constructor(message) {
         super(message);
@@ -56,7 +58,7 @@ class AwaitingUserInputError extends Error {
 const LLM_TIMEOUT_MS = 2 * 60 * 1000;
 // Per-step timeout (5 minutes max per step)
 const STEP_TIMEOUT_MS = 5 * 60 * 1000;
-// Per-tool execution timeout (45 seconds - balance responsiveness with heavier tools)
+// Default per-tool execution timeout (overrideable per tool)
 const TOOL_TIMEOUT_MS = 30 * 1000;
 // Maximum consecutive failures for the same tool before giving up
 const MAX_TOOL_FAILURES = 2;
@@ -103,6 +105,22 @@ const INPUT_DEPENDENT_ERROR_PATTERNS = [
     /applescript execution failed/i, // AppleScript errors are input-related
     /user denied/i, // User denied an approval request
 ];
+// Keywords that imply a step wants image verification.
+const IMAGE_VERIFICATION_KEYWORDS = [
+    'image',
+    'photo',
+    'photograph',
+    'picture',
+    'render',
+    'illustration',
+    'png',
+    'jpg',
+    'jpeg',
+    'webp',
+];
+const IMAGE_FILE_EXTENSION_REGEX = /\.(png|jpe?g|webp|gif|bmp)$/i;
+// Allow a small buffer for file timestamp granularity/clock skew.
+const IMAGE_VERIFICATION_TIME_SKEW_MS = 1000;
 /**
  * Check if an error is non-retryable (quota/rate limit related)
  * These errors indicate a systemic problem with the tool/API
@@ -159,27 +177,6 @@ function isAskingQuestion(text) {
     const trimmed = text.trim();
     if (!trimmed)
         return false;
-    // Keep this lightweight and conservative: only pause on questions that
-    // clearly request input/decisions needed to proceed.
-    const blockingQuestionPatterns = [
-        // Direct requests for info or confirmation
-        /(?:^|\n)\s*(?:please\s+)?(?:provide|share|send|upload|enter|paste|specify|clarify|confirm|choose|pick|select)\b/i,
-        /(?:can|could|would)\s+you\s+(?:please\s+)?(?:provide|share|send|upload|enter|paste|specify|clarify|confirm|choose|pick|select)\b/i,
-        // Decision/approval questions
-        /would\s+you\s+like\s+me\s+to\b/i,
-        /would\s+you\s+prefer\b/i,
-        /should\s+i\b/i,
-        /do\s+you\s+want\s+me\s+to\b/i,
-        /do\s+you\s+prefer\b/i,
-        /is\s+it\s+(?:ok|okay|alright)\s+if\s+i\b/i,
-        // Clarifying questions about specifics
-        /\bwhat\s+(?:is|are|was|were|should|would|can|could|do|does|did)\s+(?:the|your|this|that)\b/i,
-        /\bwhat\s+should\s+i\b/i,
-        /\bwhich\s+(?:one|option|approach|method|file|version|environment|format|branch|repo|path)\b/i,
-        /\bwhere\s+(?:is|are|should|can|could)\b/i,
-        /\bwhen\s+(?:is|are|should|can|could)\b/i,
-        /\bhow\s+should\s+i\b/i,
-    ];
     const nonBlockingQuestionPatterns = [
         // Conversational/offboarding prompts that shouldn't pause execution
         /\bwhat\s+(?:else\s+)?can\s+i\s+help\b/i,
@@ -191,21 +188,68 @@ function isAskingQuestion(text) {
         /\bcan\s+i\s+help\s+with\s+anything\s+else\b/i,
         /\bdoes\s+that\s+(?:help|make\s+sense)\b/i,
     ];
-    const isShort = trimmed.length < 1000;
-    if (!isShort)
-        return false;
-    // If we see explicit blocking cues, pause.
-    if (blockingQuestionPatterns.some(pattern => pattern.test(trimmed))) {
+    const maxLengthForAnalysis = 4000;
+    const sample = trimmed.slice(0, maxLengthForAnalysis);
+    const blockingCuePatterns = [
+        /(?:need|required)\s+(?:your|a|the)\b/i,
+        /before\s+i\s+can\s+(?:proceed|continue)\b/i,
+        /to\s+(?:proceed|continue|move\s+forward)\b/i,
+        /i\s+can(?:not|'t)\s+(?:proceed|continue)\b/i,
+        /\bawaiting\s+your\b/i,
+    ];
+    const explicitProceedPatterns = [
+        /\bi\s+(?:will|\'ll)\s+(?:proceed|continue|go\s+ahead|move\s+forward)\b/i,
+        /\bi\s+can\s+(?:proceed|continue|move\s+forward)\b/i,
+        /\bi\s+(?:will|\'ll)\s+assume\b/i,
+        /\bif\s+you\s+do\s+not\s+(?:respond|answer|reply)\b/i,
+        /\bif\s+you\s+don\'t\s+(?:respond|answer|reply)\b/i,
+    ];
+    const questionWordPatterns = [
+        /^(?:who|what|where|when|why|how|which)\b/i,
+    ];
+    const imperativePatterns = [
+        /^(?:please\s+)?(?:provide|share|send|upload|enter|paste|specify|clarify|confirm|choose|pick|select|list|tell|give)\b/i,
+    ];
+    const decisionPatterns = [
+        /^(?:do\s+you\s+want|do\s+you\s+prefer|would\s+you\s+like|would\s+you\s+prefer|should\s+i|is\s+it\s+(?:ok|okay|alright)\s+if\s+i)\b/i,
+    ];
+    const hasBlockingCue = blockingCuePatterns.some(pattern => pattern.test(sample));
+    const hasExplicitProceed = explicitProceedPatterns.some(pattern => pattern.test(sample));
+    if (hasBlockingCue)
         return true;
-    }
-    // If it's a non-blocking conversational prompt, don't pause.
-    const lastLine = trimmed.split('\n').filter(Boolean).pop() ?? trimmed;
+    const lines = sample.split('\n').map(l => l.trim()).filter(Boolean);
+    if (lines.length === 0)
+        return false;
+    const lastLine = lines[lines.length - 1] ?? sample;
     const sentenceMatch = lastLine.match(/[^.!?]+[.!?]*$/);
     const lastSentence = sentenceMatch ? sentenceMatch[0].trim() : lastLine;
-    if (nonBlockingQuestionPatterns.some(pattern => pattern.test(lastSentence))) {
-        return false;
+    const hasNonBlockingTail = nonBlockingQuestionPatterns.some(pattern => pattern.test(lastSentence));
+    const tailLines = lines.slice(-2);
+    let tailQuestion = false;
+    let tailImperative = false;
+    for (const line of tailLines) {
+        const normalized = line.replace(/^[\-\*]?\s*\d*[\).]?\s*/, '').trim();
+        if (!normalized)
+            continue;
+        if (nonBlockingQuestionPatterns.some(pattern => pattern.test(normalized))) {
+            continue;
+        }
+        if (imperativePatterns.some(pattern => pattern.test(normalized)) || decisionPatterns.some(pattern => pattern.test(normalized))) {
+            tailImperative = true;
+        }
+        if (normalized.endsWith('?') || questionWordPatterns.some(pattern => pattern.test(normalized))) {
+            tailQuestion = true;
+        }
+    }
+    if (tailImperative)
+        return true;
+    if (tailQuestion) {
+        if (hasNonBlockingTail)
+            return false;
+        if (hasExplicitProceed)
+            return false;
+        return true;
     }
-    // Default to not pausing on generic questions.
     return false;
 }
 /**
@@ -900,6 +944,11 @@ class TaskExecutor {
         this.waitingForUserInput = false;
         this.conversationHistory = [];
         this.systemPrompt = '';
+        this.toolResultMemory = [];
+        this.lastAssistantOutput = null;
+        this.lastNonVerificationOutput = null;
+        this.toolResultMemoryLimit = 8;
+        this.dispatchedMentionedAgents = false;
         // Plan revision tracking to prevent infinite revision loops
         this.planRevisionCount = 0;
         this.maxPlanRevisions = 5;
@@ -915,7 +964,10 @@ class TaskExecutor {
         // Global turn tracking (across all steps) - similar to Claude Agent SDK's maxTurns
         this.globalTurnCount = 0;
         this.maxGlobalTurns = 100; // Configurable global limit
+        this.lastUserMessage = task.prompt;
         this.requiresTestRun = this.detectTestRequirement(`${task.title}\n${task.prompt}`);
+        // Only main tasks should pause for user input. Sub/parallel tasks should complete and report back.
+        this.shouldPauseForQuestions = !task.parentTaskId && (task.agentType ?? 'main') === 'main';
         // Get base settings
         const settings = llm_1.LLMProviderFactory.loadSettings();
         // Check if task has a model override (for sub-agents)
@@ -927,7 +979,8 @@ class TaskExecutor {
         // Use task's model key if specified, otherwise use global settings
         const effectiveModelKey = taskModelKey || settings.modelKey;
         // Get the model ID
-        this.modelId = llm_1.LLMProviderFactory.getModelId(effectiveModelKey, settings.providerType, settings.ollama?.model, settings.gemini?.model, settings.openrouter?.model, settings.openai?.model);
+        const azureDeployment = settings.azure?.deployment || settings.azure?.deployments?.[0];
+        this.modelId = llm_1.LLMProviderFactory.getModelId(effectiveModelKey, settings.providerType, settings.ollama?.model, settings.gemini?.model, settings.openrouter?.model, settings.openai?.model, azureDeployment, settings.groq?.model, settings.xai?.model, settings.kimi?.model, settings.customProviders);
         this.modelKey = effectiveModelKey;
         // Initialize context manager for handling long conversations
         this.contextManager = new context_manager_1.ContextManager(effectiveModelKey);
@@ -994,6 +1047,9 @@ class TaskExecutor {
                     error.message?.includes('rate limit') ||
                     error.message?.includes('ECONNRESET') ||
                     error.message?.includes('ETIMEDOUT') ||
+                    error.message?.includes('ENOTFOUND') ||
+                    error.message?.includes('EAI_AGAIN') ||
+                    error.message?.includes('ECONNREFUSED') ||
                     error.message?.includes('network') ||
                     error.status === 429 ||
                     error.status === 503 ||
@@ -1046,6 +1102,20 @@ class TaskExecutor {
         this.iterationCount++;
         this.globalTurnCount++; // Track global turns across all steps
     }
+    getToolTimeoutMs(toolName, input) {
+        const settingsTimeout = builtin_settings_1.BuiltinToolsSettingsManager.getToolTimeoutMs(toolName);
+        const normalizedSettingsTimeout = settingsTimeout && settingsTimeout > 0 ? settingsTimeout : null;
+        if (toolName === 'run_command') {
+            const inputTimeout = typeof input?.timeout === 'number'
+                ? input.timeout
+                : undefined;
+            if (typeof inputTimeout === 'number' && Number.isFinite(inputTimeout) && inputTimeout > 0) {
+                return Math.round(inputTimeout);
+            }
+            return normalizedSettingsTimeout ?? TOOL_TIMEOUT_MS;
+        }
+        return normalizedSettingsTimeout ?? TOOL_TIMEOUT_MS;
+    }
     /**
      * Check if a file operation should be blocked (redundant read or duplicate creation)
      * @returns Object with blocked flag, reason, and suggestion if blocked, plus optional cached result
@@ -1188,6 +1258,31 @@ class TaskExecutor {
             this.testRunObserved = true;
         }
     }
+    stepRequiresImageVerification(step) {
+        const description = (step.description || '').toLowerCase();
+        if (!description.includes('verify'))
+            return false;
+        return IMAGE_VERIFICATION_KEYWORDS.some((keyword) => description.includes(keyword));
+    }
+    hasNewImageFromGlobResult(result, since) {
+        const matches = result?.matches;
+        if (!Array.isArray(matches))
+            return false;
+        const threshold = Math.max(0, since - IMAGE_VERIFICATION_TIME_SKEW_MS);
+        for (const match of matches) {
+            const path = typeof match === 'string' ? match : match?.path;
+            if (!path || !IMAGE_FILE_EXTENSION_REGEX.test(path))
+                continue;
+            const modified = typeof match === 'object' ? match?.modified : undefined;
+            if (!modified)
+                continue;
+            const modifiedTime = Date.parse(modified);
+            if (!Number.isNaN(modifiedTime) && modifiedTime >= threshold) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Infer missing parameters for tool calls (helps weaker models)
      * This auto-fills parameters when the LLM fails to provide them but context is available
@@ -1264,8 +1359,62 @@ class TaskExecutor {
             }
             return { input, modified, inference: modified ? inference : undefined };
         }
+        // Handle web_search - normalize region/country inputs
+        if (toolName === 'web_search') {
+            let modified = false;
+            let inference = '';
+            if (!input?.region && input?.country && typeof input.country === 'string') {
+                input.region = input.country;
+                modified = true;
+                inference = 'Normalized country -> region';
+            }
+            if (input?.region && typeof input.region === 'string') {
+                const raw = input.region.trim();
+                const upper = raw.toUpperCase();
+                let normalized = upper;
+                if (upper === 'UK')
+                    normalized = 'GB';
+                if (upper === 'USA')
+                    normalized = 'US';
+                if (normalized !== raw) {
+                    input.region = normalized;
+                    modified = true;
+                    inference = `${inference ? `${inference}; ` : ''}Normalized region "${raw}" -> "${normalized}"`;
+                }
+            }
+            if (modified) {
+                return { input, modified, inference };
+            }
+        }
         return { input, modified: false };
     }
+    async handleCanvasPushFallback(content, assistantText) {
+        if (content.name !== 'canvas_push') {
+            return;
+        }
+        const inputContent = content.input?.content;
+        const hasContent = typeof inputContent === 'string' && inputContent.trim().length > 0;
+        const filename = content.input?.filename;
+        const isHtmlTarget = !filename || filename === 'index.html';
+        if (hasContent || !isHtmlTarget) {
+            return;
+        }
+        const extracted = this.extractHtmlFromText(assistantText);
+        const generated = extracted || await this.generateCanvasHtml(this.lastUserMessage || this.task.prompt);
+        if (!generated) {
+            return;
+        }
+        content.input = {
+            ...(content.input || {}),
+            content: generated,
+        };
+        this.daemon.logEvent(this.task.id, 'parameter_inference', {
+            tool: content.name,
+            inference: extracted
+                ? 'Recovered HTML from assistant text'
+                : 'Auto-generated HTML from latest user request',
+        });
+    }
     /**
      * Get available tools, filtering out disabled ones
      * This prevents the LLM from trying to use tools that have been disabled by the circuit breaker
@@ -1374,6 +1523,7 @@ class TaskExecutor {
         this.systemPrompt = `You are an AI assistant helping with tasks. Use the available tools to complete the work.
 Current time: ${getCurrentDateTimeContext()}
 Workspace: ${this.workspace.path}
+Workspace is temporary: ${this.workspace.isTemp ? 'true' : 'false'}
 Always ask for approval before deleting files or making destructive changes.
 Be concise in your responses. When reading files, only read what you need.
 
@@ -1650,6 +1800,9 @@ You are continuing a previous conversation. The context from the previous conver
         }
         // Reset tool failure tracker (tools might work on retry)
         this.toolFailureTracker = new ToolFailureTracker();
+        this.toolResultMemory = [];
+        this.lastAssistantOutput = null;
+        this.lastNonVerificationOutput = null;
         // Add context for LLM about retry
         this.conversationHistory.push({
             role: 'user',
@@ -1863,6 +2016,368 @@ You are continuing a previous conversation. The context from the previous conver
         }
         return { additionalContext: additionalContext || undefined, taskType };
     }
+    classifyWorkspaceNeed(prompt) {
+        const text = prompt.toLowerCase();
+        const newProjectPatterns = [
+            /from\s+scratch/i,
+            /\bnew\s+project\b/i,
+            /\bcreate\s+(?:a|an)\s+new\b/i,
+            /\bstart\s+(?:a|an)\s+new\b/i,
+            /\bscaffold\b/i,
+            /\bbootstrap\b/i,
+            /\binitialize\b/i,
+            /\binit\b/i,
+            /\bgreenfield\b/i,
+        ];
+        const existingProjectPatterns = [
+            /\bexisting\b/i,
+            /\bcurrent\b/i,
+            /\balready\b/i,
+            /\bin\s+(?:this|the)\s+(?:repo|repository|project|codebase)\b/i,
+            /\bfix\b/i,
+            /\bbug\b/i,
+            /\bdebug\b/i,
+            /\brefactor\b/i,
+            /\bupdate\b/i,
+            /\bmodify\b/i,
+            // Note: 'add' is intentionally omitted - it's ambiguous (could be new or existing)
+            /\bextend\b/i,
+            /\bmigrate\b/i,
+            /\bpatch\b/i,
+        ];
+        const pathOrFilePatterns = [
+            /(?:^|[\s/\\])[\w.\-\/\\]+?\.(ts|tsx|js|jsx|py|rs|go|java|kt|swift|json|yml|yaml|toml|md|sol|c|cpp|h|hpp)\b/i,
+            /\b(?:src|app|apps|packages|programs|frontend|backend|server|client|contracts|lib|services)\//i,
+        ];
+        const codeTaskPatterns = [
+            /\bapp\b/i,
+            /\bdapp\b/i,
+            /\bweb\b/i,
+            /\bfrontend\b/i,
+            /\bbackend\b/i,
+            /\bapi\b/i,
+            /\bservice\b/i,
+            /\bprogram\b/i,
+            /\bsmart\s+contract\b/i,
+            /\bcontract\b/i,
+            /\bblockchain\b/i,
+            /\bsolana\b/i,
+            /\breact\b/i,
+            /\bnode\b/i,
+            /\btypescript\b/i,
+            /\bjavascript\b/i,
+            /\bpython\b/i,
+            /\brust\b/i,
+            /\bgo\b/i,
+            /\bjava\b/i,
+            /\bkotlin\b/i,
+            /\bswift\b/i,
+            /\bdatabase\b/i,
+            /\bschema\b/i,
+            /\bmigration\b/i,
+            /\brepo\b/i,
+            /\brepository\b/i,
+            /\bcodebase\b/i,
+        ];
+        const mentionsNew = newProjectPatterns.some(pattern => pattern.test(text));
+        const isCodeTask = codeTaskPatterns.some(pattern => pattern.test(text));
+        const mentionsExisting = pathOrFilePatterns.some(pattern => pattern.test(text)) ||
+            (existingProjectPatterns.some(pattern => pattern.test(text)) && isCodeTask);
+        if (mentionsExisting)
+            return 'needs_existing';
+        if (mentionsNew)
+            return 'new_ok';
+        if (isCodeTask)
+            return 'ambiguous';
+        return 'none';
+    }
+    getWorkspaceSignals() {
+        const projectMarkers = new Set([
+            'package.json',
+            'pnpm-lock.yaml',
+            'yarn.lock',
+            'package-lock.json',
+            'Cargo.toml',
+            'Anchor.toml',
+            'pyproject.toml',
+            'requirements.txt',
+            'go.mod',
+            'pom.xml',
+            'build.gradle',
+            'settings.gradle',
+            'Gemfile',
+            'composer.json',
+            'mix.exs',
+            'Makefile',
+            'CMakeLists.txt',
+        ]);
+        const codeExtensions = new Set([
+            '.ts', '.tsx', '.js', '.jsx', '.py', '.rs', '.go', '.java', '.kt', '.swift',
+            '.cs', '.cpp', '.c', '.h', '.hpp', '.sol',
+        ]);
+        const appDirs = new Set([
+            'src', 'app', 'apps', 'packages', 'programs', 'frontend', 'backend',
+            'server', 'client', 'contracts', 'lib', 'services', 'web', 'api',
+        ]);
+        try {
+            const entries = fs.readdirSync(this.workspace.path, { withFileTypes: true });
+            let hasProjectMarkers = false;
+            let hasCodeFiles = false;
+            let hasAppDirs = false;
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    if (projectMarkers.has(entry.name)) {
+                        hasProjectMarkers = true;
+                    }
+                    const ext = path.extname(entry.name).toLowerCase();
+                    if (codeExtensions.has(ext)) {
+                        hasCodeFiles = true;
+                    }
+                }
+                else if (entry.isDirectory()) {
+                    if (appDirs.has(entry.name)) {
+                        hasAppDirs = true;
+                    }
+                }
+                if (hasProjectMarkers && hasCodeFiles && hasAppDirs)
+                    break;
+            }
+            return { hasProjectMarkers, hasCodeFiles, hasAppDirs };
+        }
+        catch {
+            return { hasProjectMarkers: false, hasCodeFiles: false, hasAppDirs: false };
+        }
+    }
+    pauseForUserInput(message, reason) {
+        this.waitingForUserInput = true;
+        this.daemon.updateTaskStatus(this.task.id, 'paused');
+        this.daemon.logEvent(this.task.id, 'assistant_message', { message });
+        this.daemon.logEvent(this.task.id, 'task_paused', { message, reason });
+        this.daemon.logEvent(this.task.id, 'progress_update', {
+            phase: 'execution',
+            completedSteps: this.plan?.steps.filter(s => s.status === 'completed').length ?? 0,
+            totalSteps: this.plan?.steps.length ?? 0,
+            progress: 0,
+            message: 'Paused - awaiting user input',
+        });
+        if (this.conversationHistory.length === 0) {
+            this.conversationHistory.push({
+                role: 'user',
+                content: this.task.prompt,
+            });
+        }
+        this.conversationHistory.push({
+            role: 'assistant',
+            content: [{ type: 'text', text: message }],
+        });
+        this.saveConversationSnapshot();
+    }
+    preflightWorkspaceCheck() {
+        const workspaceNeed = this.classifyWorkspaceNeed(this.task.prompt);
+        if (workspaceNeed === 'none')
+            return false;
+        const signals = this.getWorkspaceSignals();
+        const looksLikeProject = signals.hasProjectMarkers || signals.hasCodeFiles || signals.hasAppDirs;
+        const isTemp = this.workspace.isTemp || this.workspace.id === types_1.TEMP_WORKSPACE_ID;
+        if (isTemp && !looksLikeProject) {
+            if (workspaceNeed === 'needs_existing') {
+                this.pauseForUserInput('I am in the temporary workspace, but this task looks like it targets an existing project. ' +
+                    'Please select the project folder or provide its path so I can switch to it. ' +
+                    'If you want a new project created here instead, say so.', 'workspace_required');
+                return true;
+            }
+            if (workspaceNeed === 'ambiguous') {
+                this.pauseForUserInput('I am in the temporary workspace and this task could be a new project or changes to an existing one. ' +
+                    'Choose one:\n' +
+                    '1. Create a new project in the temporary workspace\n' +
+                    '2. Switch to an existing project folder (share the path or select a workspace)', 'workspace_selection');
+                return true;
+            }
+        }
+        if (!isTemp && workspaceNeed === 'needs_existing' && !looksLikeProject) {
+            this.pauseForUserInput('I am in the selected workspace, but I do not see typical project files here. ' +
+                'If this task targets an existing project, please confirm the correct folder or provide its path. ' +
+                'If this is a new project, tell me to scaffold it here.', 'workspace_mismatch');
+            return true;
+        }
+        return false;
+    }
+    summarizeToolResult(toolName, result) {
+        if (!result)
+            return null;
+        if (toolName === 'web_search') {
+            const query = typeof result.query === 'string' ? result.query : '';
+            const items = Array.isArray(result.results) ? result.results : [];
+            if (items.length === 0) {
+                return query ? `query "${query}": no results` : 'no results';
+            }
+            const formatted = items.slice(0, 5).map((item) => {
+                const title = item?.title ? String(item.title).trim() : 'Untitled';
+                const url = item?.url ? String(item.url) : '';
+                let host = '';
+                if (url) {
+                    try {
+                        host = new URL(url).hostname.replace(/^www\./, '');
+                    }
+                    catch {
+                        host = '';
+                    }
+                }
+                return host ? `${title} (${host})` : title;
+            });
+            const prefix = query ? `query "${query}": ` : '';
+            return `${prefix}${formatted.join(' | ')}`;
+        }
+        if (toolName === 'web_fetch') {
+            const url = typeof result.url === 'string' ? result.url : '';
+            const content = typeof result.content === 'string' ? result.content : '';
+            const snippet = content
+                ? content.replace(/\s+/g, ' ').slice(0, 300)
+                : '';
+            if (url && snippet)
+                return `${url} — ${snippet}`;
+            if (url)
+                return url;
+            if (snippet)
+                return snippet;
+            return null;
+        }
+        if (toolName === 'search_files') {
+            const totalFound = typeof result.totalFound === 'number' ? result.totalFound : undefined;
+            if (totalFound !== undefined)
+                return `matches found: ${totalFound}`;
+        }
+        if (toolName === 'glob') {
+            const totalMatches = typeof result.totalMatches === 'number' ? result.totalMatches : undefined;
+            const pattern = typeof result.pattern === 'string' ? result.pattern : '';
+            if (totalMatches !== undefined) {
+                return pattern ? `pattern "${pattern}" matched ${totalMatches} item(s)` : `matched ${totalMatches} item(s)`;
+            }
+        }
+        return null;
+    }
+    recordToolResult(toolName, result) {
+        const summary = this.summarizeToolResult(toolName, result);
+        if (!summary)
+            return;
+        this.toolResultMemory.push({ tool: toolName, summary, timestamp: Date.now() });
+        if (this.toolResultMemory.length > this.toolResultMemoryLimit) {
+            this.toolResultMemory.splice(0, this.toolResultMemory.length - this.toolResultMemoryLimit);
+        }
+    }
+    getRecentToolResultSummary(maxEntries = 6) {
+        if (this.toolResultMemory.length === 0)
+            return '';
+        const entries = this.toolResultMemory.slice(-maxEntries);
+        return entries.map(entry => `- ${entry.tool}: ${entry.summary}`).join('\n');
+    }
+    isVerificationStep(step) {
+        const desc = step.description.toLowerCase().trim();
+        if (desc.startsWith('verify'))
+            return true;
+        if (desc.startsWith('review'))
+            return true;
+        return desc.includes('verify:') || desc.includes('verification') || desc.includes('verify ');
+    }
+    isSummaryStep(step) {
+        const desc = step.description.toLowerCase();
+        return desc.includes('summary') || desc.includes('summarize') || desc.includes('compile') || desc.includes('report');
+    }
+    isLastPlanStep(step) {
+        if (!this.plan || this.plan.steps.length === 0)
+            return false;
+        const last = this.plan.steps[this.plan.steps.length - 1];
+        return last?.id === step.id;
+    }
+    taskLikelyNeedsWebEvidence() {
+        const prompt = `${this.task.title}\n${this.task.prompt}`.toLowerCase();
+        const signals = [
+            'news',
+            'latest',
+            'today',
+            'trending',
+            'breaking',
+            'reddit',
+            'search',
+            'headline',
+            'current events',
+        ];
+        return signals.some(signal => prompt.includes(signal));
+    }
+    taskRequiresTodayContext() {
+        const prompt = `${this.task.title}\n${this.task.prompt}`.toLowerCase();
+        return prompt.includes('today');
+    }
+    hasWebEvidence() {
+        return this.toolResultMemory.some(entry => entry.tool === 'web_search' || entry.tool === 'web_fetch');
+    }
+    normalizeToolName(name) {
+        if (!name)
+            return { name, modified: false, original: name };
+        if (!name.includes('.'))
+            return { name, modified: false, original: name };
+        const [prefix, ...rest] = name.split('.');
+        if (rest.length === 0)
+            return { name, modified: false, original: name };
+        if (['functions', 'tool', 'tools'].includes(prefix)) {
+            const normalized = rest.join('.');
+            return { name: normalized, modified: normalized !== name, original: name };
+        }
+        return { name, modified: false, original: name };
+    }
+    recordAssistantOutput(messages, step) {
+        if (!messages || messages.length === 0)
+            return;
+        const lastAssistant = [...messages].reverse().find(m => m.role === 'assistant');
+        if (!lastAssistant || !lastAssistant.content)
+            return;
+        const text = (Array.isArray(lastAssistant.content) ? lastAssistant.content : [])
+            .filter((item) => item.type === 'text' && item.text)
+            .map((item) => String(item.text))
+            .join('\n')
+            .trim();
+        if (!text)
+            return;
+        const truncated = text.length > 1500 ? `${text.slice(0, 1500)}…` : text;
+        if (!this.isVerificationStep(step)) {
+            this.lastAssistantOutput = truncated;
+            this.lastNonVerificationOutput = truncated;
+        }
+        else {
+            if (!this.lastAssistantOutput) {
+                this.lastAssistantOutput = truncated;
+            }
+            // Preserve lastNonVerificationOutput for future steps/follow-ups.
+        }
+    }
+    isTransientProviderError(error) {
+        if (!error)
+            return false;
+        const message = String(error.message || '').toLowerCase();
+        const code = error.cause?.code || error.code;
+        const retryableCodes = new Set(['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'EAI_AGAIN', 'ECONNREFUSED']);
+        if (code && retryableCodes.has(code))
+            return true;
+        return (message.includes('fetch failed') ||
+            message.includes('network') ||
+            message.includes('timeout') ||
+            message.includes('socket hang up'));
+    }
+    async dispatchMentionedAgentsAfterPlanning() {
+        if (this.dispatchedMentionedAgents)
+            return;
+        if (!this.shouldPauseForQuestions)
+            return;
+        if (!this.plan)
+            return;
+        try {
+            await this.daemon.dispatchMentionedAgents(this.task.id, this.plan);
+            this.dispatchedMentionedAgents = true;
+        }
+        catch (error) {
+            console.warn('[TaskExecutor] Failed to dispatch mentioned agents:', error);
+        }
+    }
     /**
      * Main execution loop
      */
@@ -1895,6 +2410,7 @@ You are continuing a previous conversation. The context from the previous conver
             // Phase 1: Planning
             this.daemon.updateTaskStatus(this.task.id, 'planning');
             await this.createPlan();
+            await this.dispatchMentionedAgentsAfterPlanning();
             if (this.cancelled)
                 return;
             // Phase 2: Execution with Goal Mode retry loop
@@ -1965,6 +2481,12 @@ You are continuing a previous conversation. The context from the previous conver
                 // Status will be updated by the daemon's cancelTask method
                 return;
             }
+            if (this.isTransientProviderError(error)) {
+                const scheduled = this.daemon.handleTransientTaskFailure(this.task.id, error.message || 'Transient LLM error');
+                if (scheduled) {
+                    return;
+                }
+            }
             console.error(`Task execution failed:`, error);
             // Save conversation snapshot even on failure for potential recovery
             this.saveConversationSnapshot();
@@ -1998,6 +2520,7 @@ You are continuing a previous conversation. The context from the previous conver
 
 Current time: ${getCurrentDateTimeContext()}
 You have access to a workspace folder at: ${this.workspace.path}
+Workspace is temporary: ${this.workspace.isTemp ? 'true' : 'false'}
 Workspace permissions: ${JSON.stringify(this.workspace.permissions)}
 
 Available tools:
@@ -2010,6 +2533,12 @@ PLANNING RULES:
 - DO NOT plan to create multiple versions of files - pick ONE target file.
 - DO NOT plan to read the same file multiple times in different steps.
 
+WORKSPACE MODE (CRITICAL):
+- There are two modes: temporary workspace (no user-selected folder) and user-selected workspace.
+- If the workspace is temporary and the task likely targets an existing project, your FIRST step must be to ask for the correct folder or to switch workspaces.
+- If the task could be new or existing, ask the user to choose between scaffolding here or switching to an existing folder.
+- Do NOT assume a repo exists in the temporary workspace unless you find it.
+
 PATH DISCOVERY (CRITICAL):
 - When users mention a folder or path (e.g., "electron/agent folder"), they may give a PARTIAL path, not the full path.
 - NEVER assume a path doesn't exist just because it's not in your workspace root.
@@ -2049,6 +2578,11 @@ WEB RESEARCH & CONTENT EXTRACTION (IMPORTANT):
 - NEVER create a plan that says "cannot be done" if alternative tools are available.
 - NEVER plan to ask the user for content you can extract yourself.
 
+REDDIT POSTS (WHEN UPVOTE COUNTS REQUIRED):
+- Prefer web_fetch against Reddit's JSON endpoints to get reliable titles and upvote counts.
+- Example: https://www.reddit.com/r/<sub>/top/.json?t=day&limit=5
+- Use web_search only to discover the right subreddit if needed, not for score counts.
+
 TOOL SELECTION GUIDE (web tools):
 - web_search: Best for research, news, finding information, exploring topics (PREFERRED for most research)
 - web_fetch: Best for reading a specific known URL without interaction
@@ -2249,27 +2783,32 @@ Format your plan as a JSON object with this structure:
         if (!this.plan) {
             throw new Error('No plan available');
         }
-        const totalSteps = this.plan.steps.length;
-        let completedSteps = 0;
+        if (this.preflightWorkspaceCheck()) {
+            return;
+        }
         // Emit initial progress event
         this.daemon.logEvent(this.task.id, 'progress_update', {
             phase: 'execution',
-            completedSteps,
-            totalSteps,
+            completedSteps: this.plan.steps.filter(s => s.status === 'completed').length,
+            totalSteps: this.plan.steps.length,
             progress: 0,
-            message: `Starting execution of ${totalSteps} steps`,
+            message: `Starting execution of ${this.plan.steps.length} steps`,
         });
-        for (const step of this.plan.steps) {
+        let index = 0;
+        while (index < this.plan.steps.length) {
+            const step = this.plan.steps[index];
             if (this.cancelled)
                 break;
             if (step.status === 'completed') {
-                completedSteps++;
+                index++;
                 continue;
             }
             // Wait if paused
             while (this.paused && !this.cancelled) {
                 await new Promise(resolve => setTimeout(resolve, 100));
             }
+            const completedSteps = this.plan.steps.filter(s => s.status === 'completed').length;
+            const totalSteps = this.plan.steps.length;
             // Emit step starting progress
             this.daemon.logEvent(this.task.id, 'progress_update', {
                 phase: 'execution',
@@ -2324,20 +2863,34 @@ Format your plan as a JSON object with this structure:
                         message: `Step timed out after ${STEP_TIMEOUT_MS / 1000}s`,
                     });
                     // Continue with next step instead of failing entire task
-                    completedSteps++;
+                    const updatedIndex = this.plan.steps.findIndex(s => s.id === step.id);
+                    if (updatedIndex === -1) {
+                        index = Math.min(index + 1, this.plan.steps.length);
+                    }
+                    else {
+                        index = updatedIndex + 1;
+                    }
                     continue;
                 }
                 throw error;
             }
-            completedSteps++;
+            const updatedIndex = this.plan.steps.findIndex(s => s.id === step.id);
+            if (updatedIndex === -1) {
+                index = Math.min(index + 1, this.plan.steps.length);
+            }
+            else {
+                index = updatedIndex + 1;
+            }
+            const completedAfterStep = this.plan.steps.filter(s => s.status === 'completed').length;
+            const totalAfterStep = this.plan.steps.length;
             // Emit step completed progress
             this.daemon.logEvent(this.task.id, 'progress_update', {
                 phase: 'execution',
                 currentStep: step.id,
-                completedSteps,
-                totalSteps,
-                progress: Math.round((completedSteps / totalSteps) * 100),
-                message: `Completed step ${completedSteps}/${totalSteps}`,
+                completedSteps: completedAfterStep,
+                totalSteps: totalAfterStep,
+                progress: totalAfterStep > 0 ? Math.round((completedAfterStep / totalAfterStep) * 100) : 100,
+                message: `Completed step ${step.id}: ${step.description}`,
             });
         }
         // Check if any steps failed
@@ -2350,11 +2903,13 @@ Format your plan as a JSON object with this structure:
             // If critical steps failed (not just verification), this should be marked
             const criticalFailures = failedSteps.filter(s => !s.description.toLowerCase().includes('verify'));
             if (criticalFailures.length > 0) {
+                const totalSteps = this.plan.steps.length;
+                const progress = totalSteps > 0 ? Math.round((successfulSteps.length / totalSteps) * 100) : 0;
                 this.daemon.logEvent(this.task.id, 'progress_update', {
                     phase: 'execution',
                     completedSteps: successfulSteps.length,
                     totalSteps,
-                    progress: Math.round((successfulSteps.length / totalSteps) * 100),
+                    progress,
                     message: `Completed with ${criticalFailures.length} failed step(s)`,
                     hasFailures: true,
                 });
@@ -2365,8 +2920,8 @@ Format your plan as a JSON object with this structure:
         // Emit completion progress (only if no critical failures)
         this.daemon.logEvent(this.task.id, 'progress_update', {
             phase: 'execution',
-            completedSteps,
-            totalSteps,
+            completedSteps: successfulSteps.length,
+            totalSteps: this.plan.steps.length,
             progress: 100,
             message: 'All steps completed',
         });
@@ -2429,6 +2984,11 @@ IMPORTANT INSTRUCTIONS:
 - The delete_file tool has a built-in approval mechanism that will prompt the user. Just call the tool directly.
 - Do NOT ask "Should I proceed?" or wait for permission in text - the tools handle approvals automatically.
 
+USER INPUT GATE (CRITICAL):
+- If you ask the user for required information or a decision, STOP and wait.
+- Do NOT continue executing steps or call tools after asking such questions.
+- If safe defaults exist, state the assumption and proceed without asking.
+
 PATH DISCOVERY (CRITICAL):
 - When a task mentions a folder or path (e.g., "electron/agent folder"), users often give PARTIAL paths.
 - NEVER conclude a path doesn't exist without SEARCHING for it first.
@@ -2518,6 +3078,11 @@ RESEARCH WORKFLOW:
 - Only fall back to browser_navigate if web_fetch fails (e.g., JavaScript-required content)
 - Many sites (X/Twitter, Reddit logged-in content, LinkedIn) require authentication - web_search can still find public discussions
 
+REDDIT POSTS (WHEN UPVOTE COUNTS REQUIRED):
+- Prefer web_fetch against Reddit's JSON endpoints to get reliable titles and upvote counts.
+- Example: https://www.reddit.com/r/<sub>/top/.json?t=day&limit=5
+- Use web_search only to discover the right subreddit if needed, not for score counts.
+
 BROWSER TOOLS (when needed):
 - Treat browser_navigate + browser_get_content as ONE ATOMIC OPERATION
 - For dynamic content, use browser_wait then browser_get_content
@@ -2572,11 +3137,43 @@ SCHEDULING & REMINDERS:
                 stepContext += `\n\nPrevious steps already completed:\n${completedSteps.map(s => `- ${s.description}`).join('\n')}`;
                 stepContext += `\n\nDo NOT repeat work from previous steps. Focus only on: ${step.description}`;
             }
+            const isVerifyStep = this.isVerificationStep(step);
+            const isSummaryStep = this.isSummaryStep(step);
+            const isLastStep = this.isLastPlanStep(step);
             // Add accumulated knowledge from previous steps (discovered files, directories, etc.)
             const knowledgeSummary = this.fileOperationTracker.getKnowledgeSummary();
             if (knowledgeSummary) {
                 stepContext += `\n\nKNOWLEDGE FROM PREVIOUS STEPS (use this instead of re-reading/re-listing):\n${knowledgeSummary}`;
             }
+            const toolResultSummary = this.getRecentToolResultSummary();
+            if (toolResultSummary) {
+                stepContext += `\n\nRECENT TOOL RESULTS (from previous steps; do not look in the filesystem for these):\n${toolResultSummary}`;
+            }
+            const shouldIncludePreviousOutput = !isVerifyStep || !this.lastNonVerificationOutput;
+            if (this.lastAssistantOutput && shouldIncludePreviousOutput) {
+                stepContext += `\n\nPREVIOUS STEP OUTPUT:\n${this.lastAssistantOutput}`;
+            }
+            if (isVerifyStep) {
+                stepContext += `\n\nVERIFICATION MODE:\n- This is a verification step. Keep the response brief (1-3 sentences).\n- Do NOT output a checklist. Do NOT restate the full deliverable.\n- If the deliverable has NOT been provided earlier, provide it now, then add a one-sentence verification note.\n`;
+                if (isLastStep) {
+                    stepContext += `- This is the FINAL step. Include a very short recap (2-4 sentences) of the deliverable before the verification note so the last message still answers the user.\n`;
+                }
+                if (this.lastNonVerificationOutput) {
+                    stepContext += `\n\nMOST RECENT DELIVERABLE (use this for verification):\n${this.lastNonVerificationOutput}`;
+                }
+                else if (this.lastAssistantOutput) {
+                    stepContext += `\n\nMOST RECENT DELIVERABLE (use this for verification):\n${this.lastAssistantOutput}`;
+                }
+            }
+            if (isSummaryStep) {
+                stepContext += `\n\nDELIVERABLE RULES:\n- If you write a file, you MUST also provide the key summary in your response.\n- Do not defer the answer to a verification step.\n`;
+                if (this.taskLikelyNeedsWebEvidence() && !this.hasWebEvidence()) {
+                    stepContext += `\n\nEVIDENCE REQUIRED:\n- No web evidence has been gathered yet. Use web_search/web_fetch now before summarizing.\n- If you find no results, say so explicitly instead of guessing.\n`;
+                }
+                if (this.taskRequiresTodayContext()) {
+                    stepContext += `\n\nDATE REQUIREMENT:\n- This task explicitly asks for “today.” Only present items as “today” if you can confirm the date from sources.\n- If you cannot confirm any items from today, state that clearly, then optionally list the most recent items as “recent (not today)”.\n`;
+                }
+            }
             // Start fresh messages for this step
             let messages = [
                 {
@@ -2591,8 +3188,17 @@ SCHEDULING & REMINDERS:
             let lastFailureReason = ''; // Track the reason for failure
             let hadToolError = false;
             let hadToolSuccessAfterError = false;
+            let hadAnyToolSuccess = false;
+            const toolErrors = new Set();
             let lastToolErrorReason = '';
             let awaitingUserInput = false;
+            let hadRunCommandFailure = false;
+            let hadToolSuccessAfterRunCommandFailure = false;
+            const expectsImageVerification = this.stepRequiresImageVerification(step);
+            const imageVerificationSince = typeof this.task.createdAt === 'number'
+                ? this.task.createdAt
+                : (step.startedAt ?? Date.now());
+            let foundNewImage = false;
             const maxIterations = 5; // Reduced from 10 to prevent excessive iterations per step
             const maxEmptyResponses = 3;
             while (continueLoop && iterationCount < maxIterations) {
@@ -2610,12 +3216,13 @@ SCHEDULING & REMINDERS:
                 this.checkBudgets();
                 // Compact messages if context is getting too large
                 messages = this.contextManager.compactMessages(messages, systemPromptTokens);
+                const availableTools = this.getAvailableTools();
                 // Use retry wrapper for resilient API calls
                 const response = await this.callLLMWithRetry(() => withTimeout(this.provider.createMessage({
                     model: this.modelId,
                     maxTokens: 4096,
                     system: this.systemPrompt,
-                    tools: this.getAvailableTools(),
+                    tools: availableTools,
                     messages,
                     signal: this.abortController.signal,
                 }), LLM_TIMEOUT_MS, 'LLM execution step'), `Step execution (iteration ${iterationCount})`);
@@ -2630,6 +3237,10 @@ SCHEDULING & REMINDERS:
                 }
                 // Log any text responses from the assistant and check if asking a question
                 let assistantAskedQuestion = false;
+                const assistantText = (response.content || [])
+                    .filter((item) => item.type === 'text' && item.text)
+                    .map((item) => item.text)
+                    .join('\n');
                 if (response.content) {
                     for (const content of response.content) {
                         if (content.type === 'text' && content.text) {
@@ -2674,8 +3285,19 @@ SCHEDULING & REMINDERS:
                 const toolResults = [];
                 let hasDisabledToolAttempt = false;
                 let hasDuplicateToolAttempt = false;
+                let hasUnavailableToolAttempt = false;
+                const availableToolNames = new Set(availableTools.map(tool => tool.name));
                 for (const content of response.content || []) {
                     if (content.type === 'tool_use') {
+                        // Normalize tool names like "functions.web_fetch" -> "web_fetch"
+                        const normalizedTool = this.normalizeToolName(content.name);
+                        if (normalizedTool.modified) {
+                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
+                                tool: content.name,
+                                inference: `Normalized tool name "${normalizedTool.original}" -> "${normalizedTool.name}"`,
+                            });
+                            content.name = normalizedTool.name;
+                        }
                         // Check if this tool is disabled (circuit breaker tripped)
                         if (this.toolFailureTracker.isDisabled(content.name)) {
                             const lastError = this.toolFailureTracker.getLastError(content.name);
@@ -2697,6 +3319,37 @@ SCHEDULING & REMINDERS:
                             hasDisabledToolAttempt = true;
                             continue;
                         }
+                        // Validate tool availability before attempting any inference
+                        if (!availableToolNames.has(content.name)) {
+                            console.log(`[TaskExecutor] Tool not available in this context: ${content.name}`);
+                            this.daemon.logEvent(this.task.id, 'tool_error', {
+                                tool: content.name,
+                                error: 'Tool not available in current context or permissions',
+                                blocked: true,
+                            });
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: content.id,
+                                content: JSON.stringify({
+                                    error: `Tool "${content.name}" is not available in this context. Please choose a different tool or check permissions/integrations.`,
+                                    unavailable: true,
+                                }),
+                                is_error: true,
+                            });
+                            hasUnavailableToolAttempt = true;
+                            continue;
+                        }
+                        // Infer missing parameters for weaker models (normalize inputs before deduplication)
+                        const inference = this.inferMissingParameters(content.name, content.input);
+                        if (inference.modified) {
+                            content.input = inference.input;
+                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
+                                tool: content.name,
+                                inference: inference.inference,
+                            });
+                        }
+                        // If canvas_push is missing content, try extracting HTML from assistant text or auto-generate
+                        await this.handleCanvasPushFallback(content, assistantText);
                         // Check for duplicate tool calls (prevents stuck loops)
                         const duplicateCheck = this.toolCallDeduplicator.checkDuplicate(content.name, content.input);
                         if (duplicateCheck.isDuplicate) {
@@ -2767,22 +3420,36 @@ SCHEDULING & REMINDERS:
                             }
                             continue;
                         }
-                        // Infer missing parameters for weaker models
-                        const inference = this.inferMissingParameters(content.name, content.input);
-                        if (inference.modified) {
-                            content.input = inference.input;
-                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
-                                tool: content.name,
-                                inference: inference.inference,
-                            });
-                        }
                         this.daemon.logEvent(this.task.id, 'tool_call', {
                             tool: content.name,
                             input: content.input,
                         });
                         try {
                             // Execute tool with timeout to prevent hanging
-                            const result = await withTimeout(this.toolRegistry.executeTool(content.name, content.input), TOOL_TIMEOUT_MS, `Tool ${content.name}`);
+                            const toolTimeoutMs = this.getToolTimeoutMs(content.name, content.input);
+                            let result = await withTimeout(this.toolRegistry.executeTool(content.name, content.input), toolTimeoutMs, `Tool ${content.name}`);
+                            // Fallback: retry grep without glob if the glob produced an invalid regex
+                            if (content.name === 'grep' && result && result.success === false && content.input?.glob) {
+                                const errorText = String(result.error || '');
+                                if (/invalid regex pattern|nothing to repeat/i.test(errorText)) {
+                                    this.daemon.logEvent(this.task.id, 'tool_fallback', {
+                                        tool: 'grep',
+                                        reason: 'invalid_glob_regex',
+                                        originalGlob: content.input.glob,
+                                    });
+                                    const fallbackInput = { ...content.input };
+                                    delete fallbackInput.glob;
+                                    try {
+                                        const fallbackResult = await withTimeout(this.toolRegistry.executeTool('grep', fallbackInput), toolTimeoutMs, 'Tool grep (fallback)');
+                                        if (fallbackResult && fallbackResult.success !== false) {
+                                            result = fallbackResult;
+                                        }
+                                    }
+                                    catch {
+                                        // Keep original error if fallback fails
+                                    }
+                                }
+                            }
                             // Tool succeeded - reset failure counter
                             this.toolFailureTracker.recordSuccess(content.name);
                             // Record this call for deduplication
@@ -2791,7 +3458,22 @@ SCHEDULING & REMINDERS:
                             // Record file operation for tracking
                             this.recordFileOperation(content.name, content.input, result);
                             this.recordCommandExecution(content.name, content.input, result);
-                            this.recordCommandExecution(content.name, content.input, result);
+                            const toolSucceeded = !(result && result.success === false);
+                            if (toolSucceeded) {
+                                hadAnyToolSuccess = true;
+                                this.recordToolResult(content.name, result);
+                            }
+                            if (content.name === 'run_command' && !toolSucceeded) {
+                                hadRunCommandFailure = true;
+                            }
+                            else if (hadRunCommandFailure && toolSucceeded) {
+                                hadToolSuccessAfterRunCommandFailure = true;
+                            }
+                            if (expectsImageVerification && content.name === 'glob' && !foundNewImage) {
+                                if (this.hasNewImageFromGlobResult(result, imageVerificationSince)) {
+                                    foundNewImage = true;
+                                }
+                            }
                             // Check if the result indicates an error (some tools return error in result)
                             if (result && result.success === false) {
                                 const reason = result.error
@@ -2799,6 +3481,7 @@ SCHEDULING & REMINDERS:
                                     || (typeof result.exitCode === 'number' ? `exit code ${result.exitCode}` : undefined)
                                     || 'unknown error';
                                 hadToolError = true;
+                                toolErrors.add(content.name);
                                 lastToolErrorReason = `Tool ${content.name} failed: ${reason}`;
                                 // Check if this is a non-retryable error
                                 const shouldDisable = this.toolFailureTracker.recordFailure(content.name, result.error || reason);
@@ -2854,7 +3537,11 @@ SCHEDULING & REMINDERS:
                         catch (error) {
                             console.error(`Tool execution failed:`, error);
                             hadToolError = true;
+                            toolErrors.add(content.name);
                             lastToolErrorReason = `Tool ${content.name} failed: ${error.message}`;
+                            if (content.name === 'run_command') {
+                                hadRunCommandFailure = true;
+                            }
                             // Track the failure
                             const shouldDisable = this.toolFailureTracker.recordFailure(content.name, error.message);
                             this.daemon.logEvent(this.task.id, 'tool_error', {
@@ -2882,7 +3569,7 @@ SCHEDULING & REMINDERS:
                     // If all tool attempts were for disabled or duplicate tools, don't continue looping
                     // This prevents infinite retry loops
                     const allToolsFailed = toolResults.every(r => r.is_error);
-                    if ((hasDisabledToolAttempt || hasDuplicateToolAttempt) && allToolsFailed) {
+                    if ((hasDisabledToolAttempt || hasDuplicateToolAttempt || hasUnavailableToolAttempt) && allToolsFailed) {
                         console.log('[TaskExecutor] All tool calls failed, were disabled, or duplicates - stopping iteration');
                         if (hasDuplicateToolAttempt) {
                             // Duplicate detection triggered - step is likely complete
@@ -2899,20 +3586,37 @@ SCHEDULING & REMINDERS:
                         continueLoop = true;
                     }
                 }
-                // If assistant asked a question and there are no tool calls, stop and wait for user
-                if (assistantAskedQuestion && toolResults.length === 0) {
+                // If assistant asked a blocking question, stop and wait for user
+                if (assistantAskedQuestion && this.shouldPauseForQuestions) {
                     console.log('[TaskExecutor] Assistant asked a question, pausing for user input');
                     awaitingUserInput = true;
                     continueLoop = false;
                 }
             }
             if (hadToolError && !hadToolSuccessAfterError) {
+                const nonCriticalErrorTools = new Set(['web_search', 'web_fetch']);
+                const onlyNonCriticalErrors = toolErrors.size > 0 && Array.from(toolErrors).every(t => nonCriticalErrorTools.has(t));
+                if (!(hadAnyToolSuccess && onlyNonCriticalErrors)) {
+                    stepFailed = true;
+                    if (!lastFailureReason) {
+                        lastFailureReason = lastToolErrorReason || 'One or more tools failed without recovery.';
+                    }
+                }
+            }
+            if (hadRunCommandFailure && !hadToolSuccessAfterRunCommandFailure) {
+                stepFailed = true;
+                if (!lastFailureReason) {
+                    lastFailureReason = 'run_command failed and no subsequent tool succeeded.';
+                }
+            }
+            if (expectsImageVerification && !foundNewImage) {
                 stepFailed = true;
                 if (!lastFailureReason) {
-                    lastFailureReason = lastToolErrorReason || 'One or more tools failed without recovery.';
+                    lastFailureReason = 'Verification failed: no newly generated image was found.';
                 }
             }
             // Step completed or failed
+            this.recordAssistantOutput(messages, step);
             // Save conversation history for follow-up messages
             this.conversationHistory = messages;
             if (awaitingUserInput) {
@@ -2993,6 +3697,57 @@ SCHEDULING & REMINDERS:
             });
         }
     }
+    extractHtmlFromText(text) {
+        if (!text)
+            return null;
+        const fenceMatch = text.match(/```html([\s\S]*?)```/i);
+        const raw = fenceMatch ? fenceMatch[1].trim() : text;
+        const doctypeIndex = raw.indexOf('<!DOCTYPE html');
+        if (doctypeIndex >= 0) {
+            const endIndex = raw.lastIndexOf('</html>');
+            if (endIndex > doctypeIndex) {
+                return raw.slice(doctypeIndex, endIndex + '</html>'.length).trim();
+            }
+        }
+        const htmlIndex = raw.indexOf('<html');
+        if (htmlIndex >= 0) {
+            const endIndex = raw.lastIndexOf('</html>');
+            if (endIndex > htmlIndex) {
+                return raw.slice(htmlIndex, endIndex + '</html>'.length).trim();
+            }
+        }
+        return null;
+    }
+    async generateCanvasHtml(prompt) {
+        const system = [
+            'You generate a single self-contained HTML document for an in-app canvas.',
+            'Output ONLY the HTML document (no markdown, no commentary).',
+            'Use inline CSS and JS. Do not reference external assets or remote URLs.',
+            'Keep it reasonably compact and interactive where appropriate.',
+        ].join(' ');
+        try {
+            const response = await this.provider.createMessage({
+                model: this.modelId,
+                maxTokens: 1800,
+                system,
+                messages: [
+                    {
+                        role: 'user',
+                        content: `Build an interactive HTML demo for this request:\n${prompt}`,
+                    },
+                ],
+            });
+            const text = (response.content || [])
+                .filter((c) => c.type === 'text')
+                .map((c) => c.text)
+                .join('\n');
+            return this.extractHtmlFromText(text);
+        }
+        catch (error) {
+            console.error('[TaskExecutor] Failed to auto-generate canvas HTML:', error);
+            return null;
+        }
+    }
     /**
      * Send a follow-up message to continue the conversation
      */
@@ -3001,8 +3756,13 @@ SCHEDULING & REMINDERS:
         const shouldResumeAfterFollowup = previousStatus === 'paused' || this.waitingForUserInput;
         const shouldStartNewCanvasSession = ['completed', 'failed', 'cancelled'].includes(previousStatus);
         let resumeAttempted = false;
+        let pausedForUserInput = false;
         this.waitingForUserInput = false;
         this.paused = false;
+        this.lastUserMessage = message;
+        if (shouldResumeAfterFollowup) {
+            this.task.prompt = `${this.task.prompt}\n\nUSER UPDATE:\n${message}`;
+        }
         this.toolRegistry.setCanvasSessionCutoff(shouldStartNewCanvasSession ? Date.now() : null);
         this.daemon.updateTaskStatus(this.task.id, 'executing');
         this.daemon.logEvent(this.task.id, 'executing', { message: 'Processing follow-up message' });
@@ -3051,6 +3811,11 @@ IMPORTANT INSTRUCTIONS:
 - The delete_file tool has a built-in approval mechanism that will prompt the user. Just call the tool directly.
 - Do NOT ask "Should I proceed?" or wait for permission in text - the tools handle approvals automatically.
 
+USER INPUT GATE (CRITICAL):
+- If you ask the user for required information or a decision, STOP and wait.
+- Do NOT continue executing steps or call tools after asking such questions.
+- If safe defaults exist, state the assumption and proceed without asking.
+
 PATH DISCOVERY (CRITICAL):
 - When a task mentions a folder or path (e.g., "electron/agent folder"), users often give PARTIAL paths.
 - NEVER conclude a path doesn't exist without SEARCHING for it first.
@@ -3198,12 +3963,14 @@ SCHEDULING & REMINDERS:
                 this.checkBudgets();
                 // Compact messages if context is getting too large
                 messages = this.contextManager.compactMessages(messages, systemPromptTokens);
+                const availableTools = this.getAvailableTools();
+                const availableToolNames = new Set(availableTools.map(tool => tool.name));
                 // Use retry wrapper for resilient API calls
                 const response = await this.callLLMWithRetry(() => withTimeout(this.provider.createMessage({
                     model: this.modelId,
                     maxTokens: 4096,
                     system: this.systemPrompt,
-                    tools: this.getAvailableTools(),
+                    tools: availableTools,
                     messages,
                     signal: this.abortController.signal,
                 }), LLM_TIMEOUT_MS, 'LLM message processing'), `Message processing (iteration ${iterationCount})`);
@@ -3216,6 +3983,10 @@ SCHEDULING & REMINDERS:
                 // Log any text responses from the assistant and check if asking a question
                 let assistantAskedQuestion = false;
                 let hasTextInThisResponse = false;
+                const assistantText = (response.content || [])
+                    .filter((item) => item.type === 'text' && item.text)
+                    .map((item) => item.text)
+                    .join('\n');
                 if (response.content) {
                     for (const content of response.content) {
                         if (content.type === 'text' && content.text && content.text.trim().length > 0) {
@@ -3262,8 +4033,18 @@ SCHEDULING & REMINDERS:
                 const toolResults = [];
                 let hasDisabledToolAttempt = false;
                 let hasDuplicateToolAttempt = false;
+                let hasUnavailableToolAttempt = false;
                 for (const content of response.content || []) {
                     if (content.type === 'tool_use') {
+                        // Normalize tool names like "functions.web_fetch" -> "web_fetch"
+                        const normalizedTool = this.normalizeToolName(content.name);
+                        if (normalizedTool.modified) {
+                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
+                                tool: content.name,
+                                inference: `Normalized tool name "${normalizedTool.original}" -> "${normalizedTool.name}"`,
+                            });
+                            content.name = normalizedTool.name;
+                        }
                         // Check if this tool is disabled (circuit breaker tripped)
                         if (this.toolFailureTracker.isDisabled(content.name)) {
                             const lastError = this.toolFailureTracker.getLastError(content.name);
@@ -3285,6 +4066,37 @@ SCHEDULING & REMINDERS:
                             hasDisabledToolAttempt = true;
                             continue;
                         }
+                        // Validate tool availability before attempting any inference
+                        if (!availableToolNames.has(content.name)) {
+                            console.log(`[TaskExecutor] Tool not available in this context: ${content.name}`);
+                            this.daemon.logEvent(this.task.id, 'tool_error', {
+                                tool: content.name,
+                                error: 'Tool not available in current context or permissions',
+                                blocked: true,
+                            });
+                            toolResults.push({
+                                type: 'tool_result',
+                                tool_use_id: content.id,
+                                content: JSON.stringify({
+                                    error: `Tool "${content.name}" is not available in this context. Please choose a different tool or check permissions/integrations.`,
+                                    unavailable: true,
+                                }),
+                                is_error: true,
+                            });
+                            hasUnavailableToolAttempt = true;
+                            continue;
+                        }
+                        // Infer missing parameters for weaker models (normalize inputs before deduplication)
+                        const inference = this.inferMissingParameters(content.name, content.input);
+                        if (inference.modified) {
+                            content.input = inference.input;
+                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
+                                tool: content.name,
+                                inference: inference.inference,
+                            });
+                        }
+                        // If canvas_push is missing content, try extracting HTML from assistant text or auto-generate
+                        await this.handleCanvasPushFallback(content, assistantText);
                         // Check for duplicate tool calls (prevents stuck loops)
                         const duplicateCheck = this.toolCallDeduplicator.checkDuplicate(content.name, content.input);
                         if (duplicateCheck.isDuplicate) {
@@ -3353,22 +4165,14 @@ SCHEDULING & REMINDERS:
                             }
                             continue;
                         }
-                        // Infer missing parameters for weaker models
-                        const inference = this.inferMissingParameters(content.name, content.input);
-                        if (inference.modified) {
-                            content.input = inference.input;
-                            this.daemon.logEvent(this.task.id, 'parameter_inference', {
-                                tool: content.name,
-                                inference: inference.inference,
-                            });
-                        }
                         this.daemon.logEvent(this.task.id, 'tool_call', {
                             tool: content.name,
                             input: content.input,
                         });
                         try {
                             // Execute tool with timeout to prevent hanging
-                            const result = await withTimeout(this.toolRegistry.executeTool(content.name, content.input), TOOL_TIMEOUT_MS, `Tool ${content.name}`);
+                            const toolTimeoutMs = this.getToolTimeoutMs(content.name, content.input);
+                            const result = await withTimeout(this.toolRegistry.executeTool(content.name, content.input), toolTimeoutMs, `Tool ${content.name}`);
                             // Tool succeeded - reset failure counter
                             this.toolFailureTracker.recordSuccess(content.name);
                             // Record this call for deduplication
@@ -3430,7 +4234,7 @@ SCHEDULING & REMINDERS:
                     });
                     // If all tool attempts were for disabled or duplicate tools, don't continue looping
                     const allToolsFailed = toolResults.every(r => r.is_error);
-                    if ((hasDisabledToolAttempt || hasDuplicateToolAttempt) && allToolsFailed) {
+                    if ((hasDisabledToolAttempt || hasDuplicateToolAttempt || hasUnavailableToolAttempt) && allToolsFailed) {
                         console.log('[TaskExecutor] All tool calls failed, were disabled, or duplicates - stopping iteration');
                         continueLoop = false;
                     }
@@ -3438,6 +4242,12 @@ SCHEDULING & REMINDERS:
                         continueLoop = true;
                     }
                 }
+                if (assistantAskedQuestion && shouldResumeAfterFollowup && this.shouldPauseForQuestions) {
+                    console.log('[TaskExecutor] Assistant asked a question during follow-up, pausing for user input');
+                    this.waitingForUserInput = true;
+                    pausedForUserInput = true;
+                    continueLoop = false;
+                }
                 // Check if agent wants to end but hasn't provided a text response yet
                 // If tools were called but no summary was given, request one
                 if (wantsToEnd && !hasTextInThisResponse && hadToolCalls && !hasProvidedTextResponse) {
@@ -3465,6 +4275,13 @@ SCHEDULING & REMINDERS:
             this.daemon.logEvent(this.task.id, 'follow_up_completed', {
                 message: 'Follow-up message processed',
             });
+            if (pausedForUserInput) {
+                this.daemon.updateTaskStatus(this.task.id, 'paused');
+                this.daemon.logEvent(this.task.id, 'task_paused', {
+                    message: 'Paused - awaiting user input',
+                });
+                return;
+            }
             if (shouldResumeAfterFollowup && this.plan) {
                 resumeAttempted = true;
                 await this.resumeAfterPause();