ft-scout 9.4.5 → 9.4.7

package/bin/src/engine/agentEngine.js

@@ -22,6 +22,8 @@ import { AgentRuntime } from './runtime/index.js';
 import { loadAuthConfig, isProOrHigher } from '../utils/auth.js';
 import { getMCPManager } from '../mcp/index.js';
 import { writeTelemetry } from '../utils/qrBridge.js';
+import { compress, LEVEL_FAST } from 'codrop';
+import { CheckpointManager } from './checkpoints/checkpointManager.js';
 export { AgentRuntime, AgentWorkspace, inferExecutionIntent, resolveDesktopPath, SystemComputerController, MockComputerController };
 const execAsync = promisify(exec);
 export function robustSnippetReplace(origContent, target, replacement) {
@@ -292,6 +294,29 @@ export const AGENT_TOOLS = [
             required: ['text'],
         },
     },
+    {
+        name: 'delegate_subtask',
+        description: 'Delegate a specialized subtask to an autonomous specialist subagent (architect, coder, tester, reviewer, general). Useful for delegating code reviews, test generation, architectural breakdowns, or isolated module implementations to an autonomous worker agent.',
+        parameters: {
+            type: 'object',
+            properties: {
+                role: {
+                    type: 'string',
+                    enum: ['architect', 'coder', 'tester', 'reviewer', 'general'],
+                    description: 'Specialist role for the subagent (architect, coder, tester, reviewer, general)',
+                },
+                task: {
+                    type: 'string',
+                    description: 'The specific subtask instruction or goal for the subagent to complete',
+                },
+                context: {
+                    type: 'string',
+                    description: 'Relevant file paths, error messages, or architectural context to provide to the subagent',
+                },
+            },
+            required: ['role', 'task'],
+        },
+    },
     {
         name: 'task_completed',
         description: 'Signal that the user goal has been fully completed with the full answer, results, and summary.',
@@ -402,10 +427,10 @@ export class AgentExecutionLoop {
         this.mockMode = Boolean(options?.mockMode);
         this.isAudioMode = Boolean(options?.isAudioMode);
         this.userTier = (options?.tier || loadAuthConfig().currentTier || 'free').toLowerCase();
-        // Free tier is bounded to basic direct actions (max 5 steps). Full autonomous multi-step loops require Pro/Enterprise.
+        // Free tier is bounded to basic direct actions (max 5 steps). Full autonomous multi-step loops require Pro/Enterprise (unlimited steps).
         const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
-        const requestedSteps = options?.maxSteps || 30;
-        this.maxSteps = isPaid ? requestedSteps : Math.min(requestedSteps, 5);
+        const requestedSteps = options?.maxSteps;
+        this.maxSteps = isPaid ? (requestedSteps || Infinity) : Math.min(requestedSteps || 5, 5);
         this.taskStateManager = new TaskStateManager(options?.taskId, '', this.cwd);
         this.computerController = options?.computerController || (this.mockMode ? new MockComputerController() : new SystemComputerController(this.cwd));
         this.browserController = options?.browserController || new SemanticBrowserController(this.cwd);
@@ -417,6 +442,9 @@ export class AgentExecutionLoop {
     getUserTier() {
         return this.userTier;
     }
+    isPaidTier() {
+        return this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
+    }
     getExecutionIntent() {
         return this.executionIntent;
     }
@@ -581,7 +609,7 @@ export class AgentExecutionLoop {
         }
     }
     systemPrompt() {
-        const filesList = getDirectoryFiles(this.cwd).slice(0, 100);
+        const filesList = getDirectoryFiles(this.cwd).slice(0, 10);
         const intentInfo = this.executionIntent ? `
 Task Execution Intent & Constraints:
 • Required Applications: ${this.executionIntent.requiredApplications.length > 0 ? this.executionIntent.requiredApplications.join(', ') : 'None specified'}
@@ -590,9 +618,10 @@ Task Execution Intent & Constraints:
 • Target Destination: ${this.executionIntent.targetDestination || 'Default'}
 • Target Artifact: ${this.executionIntent.targetArtifactName || 'None'}
 ` : '';
-        const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
+        const isPaid = this.isPaidTier();
         const tierDirective = isPaid ? `
 PLAN TIER & CAPABILITIES: ${this.userTier.toUpperCase()} (FULL ACCESS UNLOCKED)
+• Unlimited autonomous multi-step loops with no step limits.
 • Autonomous Computer-Use, Browser Automation, and AI Scratchpad Reasoning are fully ENABLED.
 • Use the 'scratchpad' tool to organize multi-step reasoning, break down complex goals, draft hypotheses, and track working memory across turns.
 ` : `
@@ -607,7 +636,7 @@ PLAN TIER & CAPABILITIES: DEVELOPER FREE (BASIC DEVELOPER OPS ONLY)
 `;
         const mcpRouting = getMCPManager().routeTools(this.currentGoal);
         const mcpCapabilitiesSection = mcpRouting.capabilitiesSummary ? `\n${mcpRouting.capabilitiesSummary}\n` : '';
-        const recentSessionsMemory = getRecentSessionsSummary(3);
+        const recentSessionsMemory = getRecentSessionsSummary(1);
         const sessionHistorySection = recentSessionsMemory ? `\n${recentSessionsMemory}\n` : '';
         return `You are Scout Agent, an elite AI Principal Software Engineer & Autonomous Computer-Use Operator (developed by FrontTerrain).
 
@@ -671,7 +700,7 @@ CORE ARCHITECTURAL PRINCIPLES:
      * Light: light_data.energy = 1000.0 (watts)
      * Primitives: bpy.ops.mesh.primitive_uv_sphere_add, primitive_cylinder_add, primitive_cube_add
    - Apply cel-shading or toon materials with vibrant anime colors matching the request (e.g. Genshin Impact aesthetic).
-   - Position camera and lighting, verify the scene with get_scene_info, and finish by calling task_completed with a complete description of the created 3D character.
+   - Position camera and lighting. Immediately after your Blender script creates the 3D model (or after a single quick verification step), you MUST call task_completed with a complete description of the created 3D character and mesh hierarchy. Do NOT run unnecessary repeated polling turns.
 
 When returning tool calls, use standard OpenAI function calling format or JSON tool call payload format:
 \`\`\`json
@@ -820,9 +849,15 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                 content: promptContent,
             });
         }
-        const estTotalSecs = Math.round(this.maxSteps * 12);
-        const estTimeText = estTotalSecs >= 60 ? `~${(estTotalSecs / 60).toFixed(1)}m` : `~${estTotalSecs}s`;
-        console.log(chalk.gray(`Estimated completion time: ${estTimeText} (Max ${this.maxSteps} steps)`));
+        const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
+        if (!isPaid && Number.isFinite(this.maxSteps)) {
+            const estTotalSecs = Math.round(this.maxSteps * 12);
+            const estTimeText = estTotalSecs >= 60 ? `~${(estTotalSecs / 60).toFixed(1)}m` : `~${estTotalSecs}s`;
+            console.log(chalk.gray(`Estimated completion time: ${estTimeText} (Free Tier Max ${this.maxSteps} steps)`));
+        }
+        else {
+            console.log(chalk.gray(`⚡ Autonomous execution loop: Unlimited steps active (${this.userTier.toUpperCase()} plan)`));
+        }
         let step = 0;
         let finalSummary = '';
         const stepDurations = [];
@@ -837,16 +872,21 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
             this.currentStep = step;
             this.taskStateManager.startStep(step);
             const stepStartTime = Date.now();
-            const avgStepMs = stepDurations.length > 0
-                ? stepDurations.reduce((a, b) => a + b, 0) / stepDurations.length
-                : 12000;
-            const remainingSteps = (this.maxSteps - step + 1);
-            const estSecsLeft = Math.max(5, Math.round((remainingSteps * avgStepMs) / 1000));
-            const estLeftStr = estSecsLeft >= 60
-                ? `${Math.floor(estSecsLeft / 60)}m ${estSecsLeft % 60}s`
-                : `${estSecsLeft}s`;
             const stepSpinner = spinner();
-            stepSpinner.start(chalk.cyan(`Scout is Working (Step ${step}/${this.maxSteps} • Est. completion: ~${estLeftStr} left)`));
+            if (isPaid && !Number.isFinite(this.maxSteps)) {
+                stepSpinner.start(chalk.cyan(`Scout is Working (Step ${step})`));
+            }
+            else {
+                const avgStepMs = stepDurations.length > 0
+                    ? stepDurations.reduce((a, b) => a + b, 0) / stepDurations.length
+                    : 12000;
+                const remainingSteps = (this.maxSteps - step + 1);
+                const estSecsLeft = Math.max(5, Math.round((remainingSteps * avgStepMs) / 1000));
+                const estLeftStr = estSecsLeft >= 60
+                    ? `${Math.floor(estSecsLeft / 60)}m ${estSecsLeft % 60}s`
+                    : `${estSecsLeft}s`;
+                stepSpinner.start(chalk.cyan(`Scout is Working (Step ${step}/${this.maxSteps} • Est. completion: ~${estLeftStr} left)`));
+            }
             try {
                 let response;
                 const mcpRouting = getMCPManager().routeTools(userGoal);
@@ -860,7 +900,7 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                     }
                     return {
                         name: mt.originalName,
-                        description: `[MCP: ${mt.serverName}] ${desc.length > 250 ? desc.slice(0, 247) + '...' : desc}`,
+                        description: `[MCP: ${mt.serverName}] ${desc.length > 160 ? desc.slice(0, 157) + '...' : desc}`,
                         parameters: {
                             type: 'object',
                             properties: mt.inputSchema.properties || {},
@@ -871,7 +911,18 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                         mcpServerName: mt.serverName,
                     };
                 });
-                const activeLoopTools = [...this.toolRegistry.getToolsForTier(this.userTier), ...mcpToolDefs];
+                const goalLower = (userGoal || '').toLowerCase();
+                const needsBrowser = goalLower.includes('browser') || goalLower.includes('website') || goalLower.includes('webpage') || goalLower.includes('http') || goalLower.includes('url') || goalLower.includes('scrape') || goalLower.includes('chrome');
+                const needsComputer = goalLower.includes('computer') || goalLower.includes('desktop') || goalLower.includes('mouse') || goalLower.includes('coordinate') || goalLower.includes('drag') || goalLower.includes('double click');
+                let baseTools = this.toolRegistry.getToolsForTier(this.userTier);
+                if (mcpToolDefs.length > 0 && !needsBrowser && !needsComputer) {
+                    const ESSENTIAL_BASE_TOOLS = new Set(['read_file', 'write_file', 'edit_file', 'run_command', 'list_dir', 'grep_search', 'task_completed', 'ask_user', 'speak_text', 'scratchpad', 'computer_open_app']);
+                    baseTools = baseTools.filter((t) => ESSENTIAL_BASE_TOOLS.has(t.name));
+                }
+                else if (!needsBrowser) {
+                    baseTools = baseTools.filter((t) => !t.name.startsWith('browser_'));
+                }
+                const activeLoopTools = [...baseTools, ...mcpToolDefs];
                 try {
                     response = await callOpenAIWithRetry(async (model) => {
                         return await openai.chat.completions.create({
@@ -890,14 +941,15 @@ When returning tool calls, use standard OpenAI function calling format or JSON t
                     if (errStr.includes('tool') || errStr.includes('400') || errStr.includes('not supported') || errStr.includes('reasoning')) {
                         // Model doesn't support native function calling  inject tool-call formatting hint
                         // so extractJsonToolCall can parse the response as a structured tool invocation
+                        const availableToolNames = activeLoopTools.map((t) => t.name).join(', ');
                         const toolHintMsg = {
                             role: 'user',
                             content: `IMPORTANT: This model does not support native function/tool calling. You MUST format your tool invocations as a JSON code block in your response like this:
 \`\`\`json
 { "tool": "tool_name", "args": { ... } }
 \`\`\`
-Available tools: read_file, write_file, edit_file, run_command, list_dir, grep_search, glob_search, tree_view, file_info, multi_edit_file, fetch_url, git_diff, ask_user, speak_text, task_completed.
-You MUST output exactly ONE JSON code block per tool call. Do NOT describe what you would do in plain textoutput the JSON tool call directly!`,
+Available tools: ${availableToolNames}
+You MUST output exactly ONE JSON code block per tool call. Do NOT describe what you would do in plain text — output the JSON tool call directly!`,
                         };
                         const fallbackMessages = [...this.historyMessages, toolHintMsg];
                         response = await callOpenAIWithRetry(async (model) => {
@@ -964,10 +1016,24 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                             const toolResult = await this.dispatchToolCall(fnName, args);
                             this.totalToolCalls++;
                             this.syncTelemetry('running', `scout: [step ${step}] executed tool ${fnName}`);
+                            const toolResStr = String(toolResult.result || '');
+                            let cappedResult = toolResStr;
+                            if (toolResStr.length > 800) {
+                                try {
+                                    const origBytes = Buffer.byteLength(toolResStr, 'utf-8');
+                                    const cdp = compress(Buffer.from(toolResStr, 'utf-8'), LEVEL_FAST);
+                                    const ratio = (origBytes / Math.max(1, cdp.length)).toFixed(1);
+                                    cappedResult = toolResStr.slice(0, 800) + `\n... [Codrop: ${origBytes}B compressed to ${cdp.length}B (${ratio}x ratio) for LLM context]`;
+                                    this.syncTelemetry('running', `scout: [codrop] compressed ${fnName} output (${ratio}x ratio)`);
+                                }
+                                catch {
+                                    cappedResult = toolResStr.slice(0, 800) + '\n... [output truncated for token efficiency]';
+                                }
+                            }
                             this.historyMessages.push({
                                 role: 'user',
                                 tool_call_id: tc.id,
-                                content: `Tool Execution Result (${fnName}):\n${toolResult.result}`,
+                                content: `Tool Execution Result (${fnName}):\n${cappedResult}`,
                             });
                             this.handleToolConsecutiveTracking(fnName, args, step);
                             // Automatic immediate completion for simple app actions (open/close/switch window)
@@ -1022,9 +1088,22 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 const parsedJsonTool = this.extractJsonToolCall(textContent);
                 if (parsedJsonTool) {
                     const toolResult = await this.dispatchToolCall(parsedJsonTool.tool, parsedJsonTool.args);
+                    const jsonResStr = String(toolResult.result || '');
+                    let cappedJsonResult = jsonResStr;
+                    if (jsonResStr.length > 800) {
+                        try {
+                            const origBytes = Buffer.byteLength(jsonResStr, 'utf-8');
+                            const cdp = compress(Buffer.from(jsonResStr, 'utf-8'), LEVEL_FAST);
+                            const ratio = (origBytes / Math.max(1, cdp.length)).toFixed(1);
+                            cappedJsonResult = jsonResStr.slice(0, 800) + `\n... [Codrop: ${origBytes}B compressed to ${cdp.length}B (${ratio}x ratio) for LLM context]`;
+                        }
+                        catch {
+                            cappedJsonResult = jsonResStr.slice(0, 800) + '\n... [output truncated for token efficiency]';
+                        }
+                    }
                     this.historyMessages.push({
                         role: 'user',
-                        content: `Tool Execution Result (${parsedJsonTool.tool}):\n${toolResult.result}`,
+                        content: `Tool Execution Result (${parsedJsonTool.tool}):\n${cappedJsonResult}`,
                     });
                     this.handleToolConsecutiveTracking(parsedJsonTool.tool, parsedJsonTool.args, step);
                     // Automatic immediate completion for simple app actions (open/close/switch window)
@@ -1129,22 +1208,17 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                     content: `Error in previous turn: ${err?.message || String(err)}. Please try alternative steps or call tools.`,
                 });
             }
-            // Step limit check: Auto-extend by +15 steps ONLY for Pro & Enterprise (up to 60 max threshold)
-            const isPaid = this.mockMode || this.userTier === 'pro' || this.userTier === 'enterprise';
-            if (step >= this.maxSteps) {
-                if (isPaid && this.maxSteps < 60) {
-                    this.maxSteps += 15;
-                    safeNote(chalk.bold.yellow(`⚡ Step limit reached while task is in progress. Automatically extending execution by +15 extra steps (New Max Limit: ${this.maxSteps})...`), ' Auto Extra Steps Extension');
-                }
-                else if (!isPaid) {
-                    safeNote(chalk.bold.yellow(`⚡ Free Tier limit reached (${this.maxSteps} steps).\nFree developers can perform basic code editing, creating files/folders, and running commands.\nTo unlock unlimited autonomous multi-step loops and scratchpad reasoning, upgrade to Pro at https://scout.frontterrain.com/plans or run 'scout dashboard'.`), ' Free Tier Step Limit');
-                    break;
-                }
+            // Step limit check: Free tier only. Pro and Enterprise have unlimited steps.
+            if (!isPaid && step >= this.maxSteps) {
+                safeNote(chalk.bold.yellow(`⚡ Free Tier limit reached (${this.maxSteps} steps).\nFree developers can perform basic code editing, creating files/folders, and running commands.\nTo unlock unlimited autonomous multi-step loops and scratchpad reasoning, upgrade to Pro at https://scout.frontterrain.com/plans or run 'scout dashboard'.`), ' Free Tier Step Limit');
+                break;
             }
         }
         return {
             success: false,
-            summary: `Reached max iteration steps limit (${this.maxSteps}). Modified files: ${Array.from(this.modifiedFiles).join(', ')}`,
+            summary: isPaid
+                ? `Task ended after ${step} iteration steps. Modified files: ${Array.from(this.modifiedFiles).join(', ')}`
+                : `Reached max iteration steps limit (${this.maxSteps}). Modified files: ${Array.from(this.modifiedFiles).join(', ')}`,
         };
     }
     extractJsonToolCall(content) {
@@ -1166,7 +1240,7 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             'read_file', 'write_file', 'edit_file', 'run_command', 'list_dir',
             'grep_search', 'glob_search', 'tree_view', 'file_info', 'multi_edit_file',
             'fetch_url', 'git_diff',
-            'ask_user', 'speak_text', 'task_completed', 'scratchpad',
+            'ask_user', 'speak_text', 'delegate_subtask', 'task_completed', 'scratchpad',
         ];
         for (const toolName of knownTools) {
             const tagRegex = new RegExp(`<${toolName}>([\\s\\S]*?)<\\/${toolName}>`, 'i');
@@ -1266,6 +1340,8 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             actionDesc = `Inspecting visible desktop UI`;
         else if (name === 'computer_diagnostic')
             actionDesc = `Running computer control diagnostics`;
+        else if (name === 'delegate_subtask')
+            actionDesc = `Delegating subtask to [${args.role || 'subagent'}]: ${String(args.task || '').slice(0, 40)}`;
         else if (name === 'computer')
             actionDesc = `Computer action: ${args.action || 'action'}`;
         else if (name === 'scratchpad')
@@ -1298,13 +1374,21 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
             }
             if (action === 'write') {
                 fs.writeFileSync(scratchPath, content, 'utf-8');
-                this.taskStateManager.addObservation(name, `Scratchpad updated (${content.length} chars)`, true);
+                try {
+                    fs.writeFileSync(path.join(ftDir, 'scratchpad.cdp'), compress(Buffer.from(content, 'utf-8'), LEVEL_FAST));
+                }
+                catch { }
+                this.taskStateManager.addObservation(name, `Scratchpad updated (${content.length} chars, Codrop .cdp archived)`, true);
                 return { result: `Scratchpad updated successfully:\n${content}` };
             }
             else if (action === 'append') {
                 const updated = currentScratch ? `${currentScratch}\n\n---\n<!-- ${new Date().toISOString()} -->\n${content}` : content;
                 fs.writeFileSync(scratchPath, updated, 'utf-8');
-                this.taskStateManager.addObservation(name, `Appended to scratchpad (${content.length} chars)`, true);
+                try {
+                    fs.writeFileSync(path.join(ftDir, 'scratchpad.cdp'), compress(Buffer.from(updated, 'utf-8'), LEVEL_FAST));
+                }
+                catch { }
+                this.taskStateManager.addObservation(name, `Appended to scratchpad (${content.length} chars, Codrop .cdp archived)`, true);
                 return { result: `Appended to scratchpad. Current contents:\n${updated}` };
             }
             else if (action === 'clear') {
@@ -1456,6 +1540,11 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 this.taskStateManager.addObservation(name, upgradeMsg, false);
                 return { result: upgradeMsg };
             }
+            if (name === 'delegate_subtask') {
+                const upgradeMsg = `[PLAN RESTRICTION]: Autonomous Multi-Agent Swarm Delegation is exclusively available to Pro and Enterprise plan subscribers. Free tier developers can perform code editing, creating files/folders, and running commands. Upgrade to Pro at https://scout.frontterrain.com to unlock autonomous subagents.`;
+                this.taskStateManager.addObservation(name, upgradeMsg, false);
+                return { result: upgradeMsg };
+            }
         }
         switch (name) {
             case 'read_file': {
@@ -1515,6 +1604,10 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                     this.backups.push({ filePath: targetPath, originalContent: '__FT_WAS_NEW__' });
                     fs.mkdirSync(path.dirname(fullPath), { recursive: true });
                 }
+                try {
+                    CheckpointManager.getInstance(this.cwd).createCheckpoint(`Step ${this.currentStep}: write_file ${targetPath}`, [targetPath], this.currentStep, this.taskStateManager.getCurrentState().taskId);
+                }
+                catch { }
                 fs.writeFileSync(fullPath, content, 'utf-8');
                 this.modifiedFiles.add(targetPath);
                 const oldLineCount = origContent !== '__FT_WAS_NEW__' ? origContent.split('\n').length : 0;
@@ -1570,6 +1663,10 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                     return { result: `Error editing "${targetPath}": ${replaceRes.error}` };
                 }
                 this.backups.push({ filePath: targetPath, originalContent: origContent });
+                try {
+                    CheckpointManager.getInstance(this.cwd).createCheckpoint(`Step ${this.currentStep}: edit_file ${targetPath}`, [targetPath], this.currentStep, this.taskStateManager.getCurrentState().taskId);
+                }
+                catch { }
                 fs.writeFileSync(fullPath, replaceRes.updatedContent, 'utf-8');
                 this.modifiedFiles.add(targetPath);
                 const targetLines = target.split('\n').length;
@@ -2196,6 +2293,30 @@ You MUST output exactly ONE JSON code block per tool call. Do NOT describe what
                 };
                 return { result: JSON.stringify(structuredRes, null, 2) };
             }
+            case 'delegate_subtask': {
+                const role = (args.role || 'general');
+                const task = String(args.task || '').trim();
+                const context = args.context ? String(args.context) : undefined;
+                if (!task) {
+                    return { result: JSON.stringify({ success: false, error: 'No task specified for subagent delegation.' }) };
+                }
+                const { SubagentManager } = await import('./subagents/subagentManager.js');
+                const subagentMgr = SubagentManager.getInstance();
+                const subRes = await subagentMgr.delegate({
+                    role,
+                    task,
+                    context,
+                    cwd: this.cwd,
+                    tier: this.userTier,
+                });
+                if (subRes.modifiedFiles && subRes.modifiedFiles.length > 0) {
+                    for (const f of subRes.modifiedFiles) {
+                        this.modifiedFiles.add(f);
+                    }
+                }
+                this.taskStateManager.addObservation('delegate_subtask', `[Subagent ${role.toUpperCase()} Result]: ${subRes.summary}`, subRes.success);
+                return { result: JSON.stringify(subRes, null, 2) };
+            }
             case 'task_completed': {
                 const summaryStr = String(args.summary || 'Task completed successfully.');
                 if (this.executionIntent?.targetDestination === 'Desktop' && this.executionIntent?.targetArtifactName) {