@hamp10/agentforge 0.1.0 → 0.1.1

package/src/worker.js

@@ -6,7 +6,7 @@ import { HampAgentCLI } from './HampAgentCLI.js';
 import { OllamaAgent } from './OllamaAgent.js';
 import EventEmitter from 'events';
 import path from 'path';
-import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, statSync, unlinkSync } from 'fs';
+import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, statSync, unlinkSync, openSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { homedir, hostname } from 'os';
 import { spawn } from 'child_process';
@@ -71,9 +71,17 @@ export class AgentForgeWorker extends EventEmitter {
     this.agentProcessing = new Map(); // agentId -> boolean (is currently processing)
     this.processingStartTime = new Map(); // agentId -> timestamp when processing started
     this.PROCESSING_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes max for stale processing state (large projects with Opus can be slow)
+
+    // Browser mutex — only one agent can use the browser (CDP) at a time.
+    // Others wait in a queue. Prevents parallel agents from conflicting on port 9223.
+    this._browserQueue = [];
+    this._browserBusy = false;
     
     // Track running tasks for cancellation
     this.runningTasks = new Map(); // taskId -> { agentId, cancelled }
+
+    // Track last output time per agent — used to detect broken gateway streams after reconnect
+    this.lastOutputTime = new Map(); // agentId -> timestamp
     
     // Queue for messages that couldn't be sent while disconnected
     this.pendingMessages = [];
@@ -83,10 +91,6 @@ export class AgentForgeWorker extends EventEmitter {
     this.recentCompletions = new Set();
     this.completionTTL = 30000; // 30 seconds
     
-    // Track agent activity for stuck detection
-    this.lastAgentActivity = new Map(); // agentId -> timestamp
-    this.pingsSinceActivity = new Map(); // agentId -> count
-    this.STUCK_PING_THRESHOLD = 2; // 2 pings with no activity = stuck (~60s since server pings every 30s)
   }
 
   speakTextOutLoud(utterance) {
@@ -170,17 +174,42 @@ export class AgentForgeWorker extends EventEmitter {
 
   async initialize() {
     this._killOrphanedAgents();
+    await this._startGateway();
     this.installPreviewServer();
     this._startAutoUpdateCheck();
     console.log('✅ Worker initialized');
   }
 
+  async _startGateway() {
+    // Spawn openclaw-gateway as a child of this worker process.
+    // When the worker exits (Ctrl+C in terminal), the gateway dies with it.
+    // No LaunchAgent needed — the terminal session owns everything.
+    const openclaw = process.env.OPENCLAW_PATH ||
+      '/Users/hamp/.npm-global/lib/node_modules/openclaw/dist/index.js';
+    const port = 18789;
+    const logDir = path.join(homedir(), '.openclaw', 'logs');
+    mkdirSync(logDir, { recursive: true });
+    const logOut = openSync(path.join(logDir, 'gateway.log'), 'a');
+    const logErr = openSync(path.join(logDir, 'gateway.err.log'), 'a');
+    const gw = spawn(process.execPath, [openclaw, 'gateway', '--port', String(port)], {
+      stdio: ['ignore', logOut, logErr],
+      env: { ...process.env, NODE_EXTRA_CA_CERTS: '/etc/ssl/cert.pem' },
+      detached: false
+    });
+    gw.on('exit', (code) => {
+      if (code !== null) console.warn(`⚠️  openclaw-gateway exited (code ${code}) — browser tools will fail until worker restarts`);
+    });
+    console.log(`🌐 OpenClaw Gateway started (PID: ${gw.pid}, port: ${port})`);
+    // Brief pause so gateway is listening before first agent task
+    await new Promise(r => setTimeout(r, 1500));
+  }
+
   _killOrphanedAgents() {
     // Kill any openclaw agent processes left over from a previous worker session.
     // Without this, orphaned processes reconnect to the gateway and block the task queue.
     for (const name of ['openclaw-agent', 'openclaw-gateway']) {
       try {
-        const p = spawn('pkill', ['-f', name], { stdio: 'ignore' });
+        const p = spawn('pkill', ['-9', '-f', name], { stdio: 'ignore' });
         p.on('close', (code) => {
           if (code === 0) console.log(`🧹 Killed orphaned ${name} processes`);
         });
@@ -323,6 +352,37 @@ export class AgentForgeWorker extends EventEmitter {
             this.flushPendingMessages();
             this.processAllQueues(); // Kick-start any stalled queues
           }, 500);
+
+          // After 90s, cancel any running tasks that produced zero output since reconnect.
+          // This catches broken gateway streams that went dark during the disconnect.
+          // A healthy agent mid-build produces output continuously (tool calls, writes, etc.)
+          // and never goes 90s silent. Only broken/frozen streams stay silent this long.
+          const tasksAtReconnect = new Map(this.runningTasks);
+          const reconnectTime = Date.now();
+          setTimeout(() => {
+            for (const [tid, taskInfo] of tasksAtReconnect.entries()) {
+              if (taskInfo.cancelled) continue;
+              const current = this.runningTasks.get(tid);
+              if (!current || current.cancelled) continue; // task finished normally
+              const lastOut = this.lastOutputTime.get(taskInfo.agentId) || 0;
+              if (lastOut < reconnectTime) {
+                // No output since the reconnect — stream is dead
+                console.log(`⚠️ Agent ${taskInfo.agentId} produced no output in 45s after reconnect — cancelling (broken stream)`);
+                this.cli.cancelAgent(taskInfo.agentId);
+                this.runningTasks.delete(tid);
+                this.agentProcessing.set(taskInfo.agentId, false);
+                this.processingStartTime.delete(taskInfo.agentId);
+                this.send({
+                  type: 'task_progress',
+                  taskId: tid,
+                  agentId: taskInfo.agentId,
+                  output: '⚠️ Task was interrupted by a connection issue. Please resend your message to continue.',
+                  isChunk: true
+                });
+                this.send({ type: 'task_cancelled', taskId: tid, agentId: taskInfo.agentId });
+              }
+            }
+          }, 90000);
         }
 
         resolve();
@@ -395,22 +455,34 @@ export class AgentForgeWorker extends EventEmitter {
         await this.executeTask(message);
         break;
 
-      case 'task_cancel':
-        // Support cancellation by taskId or agentId
-        console.log(`📨 CANCEL REQUEST: taskId=${message.taskId} agentId=${message.agentId}`);
-        if (message.taskId) {
-          await this.cancelTask(message.taskId);
-        } else if (message.agentId) {
-          await this.cancelTaskByAgent(message.agentId);
-        } else {
-          console.log(`⚠️  task_cancel received without taskId or agentId!`);
+      case 'task_cancel': {
+        const { agentId: cancelAgentId, taskId: cancelTaskId } = message;
+        console.log(`📨 CANCEL REQUEST: taskId=${cancelTaskId} agentId=${cancelAgentId}`);
+        if (!cancelAgentId) {
+          console.log(`⚠️  task_cancel received without agentId!`);
+          break;
         }
+        // Always kill the process immediately by agentId — don't wait for task lookup
+        // Task lookup can fail if taskId is stale (agent moved to a queued message)
+        const killed = this.cli.cancelAgent(cancelAgentId) || this.hampagent?.cancelAgent(cancelAgentId) || false;
+        console.log(`🛑 Direct kill for agent ${cancelAgentId}: ${killed}`);
+        // Clean up all state for this agent
+        this.agentQueues.set(cancelAgentId, []);
+        this.agentProcessing.set(cancelAgentId, false);
+        this.processingStartTime.delete(cancelAgentId);
+        // Mark any tracked tasks for this agent as cancelled
+        for (const [tid, info] of this.runningTasks.entries()) {
+          if (info.agentId === cancelAgentId) {
+            info.cancelled = true;
+            this.runningTasks.delete(tid);
+          }
+        }
+        this.send({ type: 'task_cancelled', taskId: cancelTaskId, agentId: cancelAgentId });
         break;
+      }
 
       case 'ping':
         this.send({ type: 'pong' });
-        // Check for stuck agents - if processing but no activity for 2+ pings
-        this.checkForStuckAgents();
         break;
 
       case 'worker_restart':
@@ -440,6 +512,47 @@ export class AgentForgeWorker extends EventEmitter {
         break;
       }
 
+      case 'get_models': {
+        // Return locally available Ollama models + openclaw.json catalog
+        let ollamaModels = [];
+        let catalogModels = {};
+        try {
+          const resp = await fetch('http://localhost:11434/api/tags', {
+            signal: AbortSignal.timeout(3000),
+          });
+          if (resp.ok) {
+            const data = await resp.json();
+            ollamaModels = (data.models || []).map(m => ({
+              id: `ollama/${m.name}`,
+              name: m.name,
+              size: m.size,
+              tier: 'local',
+            }));
+          }
+        } catch {
+          // Ollama not running — that's fine
+        }
+        let primaryModel = null;
+        try {
+          const cfgPath = path.join(homedir(), '.openclaw', 'openclaw.json');
+          if (existsSync(cfgPath)) {
+            const cfg = JSON.parse(readFileSync(cfgPath, 'utf-8'));
+            catalogModels = cfg?.agents?.defaults?.models || {};
+            primaryModel = cfg?.agents?.defaults?.model?.primary || null;
+          }
+        } catch {
+          // ignore
+        }
+        this.send({
+          type: 'get_models_result',
+          requestId: message.requestId,
+          ollamaModels,
+          catalogModels,
+          primaryModel,
+        });
+        break;
+      }
+
       default:
         console.log(`⚠️  Unknown message type: ${message.type}`);
     }
@@ -470,6 +583,31 @@ export class AgentForgeWorker extends EventEmitter {
     this.processQueue(agentId);
   }
 
+  // Browser mutex — serialises all browser tool access across parallel agents.
+  // Returns a release function; call it when the agent is done with the browser.
+  acquireBrowser(agentId) {
+    return new Promise((resolve) => {
+      const attempt = () => {
+        if (!this._browserBusy) {
+          this._browserBusy = true;
+          console.log(`🌐 [${agentId}] Acquired browser`);
+          resolve(() => {
+            console.log(`🌐 [${agentId}] Released browser`);
+            this._browserBusy = false;
+            if (this._browserQueue.length > 0) {
+              const next = this._browserQueue.shift();
+              next();
+            }
+          });
+        } else {
+          console.log(`🌐 [${agentId}] Waiting for browser (${this._browserQueue.length + 1} in queue)`);
+          this._browserQueue.push(attempt);
+        }
+      };
+      attempt();
+    });
+  }
+
   async processQueue(agentId) {
     // If already processing, check if it's stale
     if (this.agentProcessing.get(agentId)) {
@@ -498,8 +636,9 @@ export class AgentForgeWorker extends EventEmitter {
     }
 
     // Mark as processing with timestamp
+    const myStartTime = Date.now();
     this.agentProcessing.set(agentId, true);
-    this.processingStartTime.set(agentId, Date.now());
+    this.processingStartTime.set(agentId, myStartTime);
     console.log(`🚀 Starting task for ${agentId} (${queue.length} in queue)`);
 
     // Get next task from queue
@@ -584,10 +723,14 @@ export class AgentForgeWorker extends EventEmitter {
       if (queueTimeoutFired && !executeTaskCompleted) {
         console.log(`[${agentId}] ⚠️ Queue timeout won the race - executeTaskNow never completed`);
       }
-      // ALWAYS clear processing state - this is critical
-      console.log(`🧹 Clearing processing state for ${agentId}`);
-      this.agentProcessing.set(agentId, false);
-      this.processingStartTime.delete(agentId);
+      // Only clear processing state if we still own it (a newer task may have taken over)
+      if (this.processingStartTime.get(agentId) === myStartTime) {
+        console.log(`🧹 Clearing processing state for ${agentId}`);
+        this.agentProcessing.set(agentId, false);
+        this.processingStartTime.delete(agentId);
+      } else {
+        console.log(`🧹 Skipping processing state clear for ${agentId} — newer task owns it`);
+      }
 
       // Process next task if queue is not empty
       if (queue.length > 0) {
@@ -604,7 +747,7 @@ export class AgentForgeWorker extends EventEmitter {
     }
   }
 
-  async executeTaskNow({ taskId, agentId, sessionId, message: userMessage, workDir, defaultProjectsPath, image, roomId, roomContext, isMaestro, conversationHistory, browserProfile, agentName, agentEmoji, runnerType }) {
+  async executeTaskNow({ taskId, agentId, sessionId, message: userMessage, workDir, defaultProjectsPath, image, roomId, roomContext, isMaestro, conversationHistory, browserProfile, agentName, agentEmoji, runnerType, agentModel }) {
     const isMaestroTask = isMaestro || agentId === 'maestro';
     console.log(`🤖 Executing task ${taskId} for agent ${agentId}${isMaestroTask ? ' (MAESTRO)' : ''}${browserProfile ? ` [browser: ${browserProfile}]` : ''}`);
     if (sessionId) {
@@ -713,9 +856,8 @@ export class AgentForgeWorker extends EventEmitter {
           if (!taskInfo || taskInfo.cancelled) {
             return; // Task cancelled, drop all output
           }
-          
-          // Record activity to prevent stuck detection from firing
-          this.recordAgentActivity(agentId);
+          // Track last output time for broken-stream detection after reconnect
+          this.lastOutputTime.set(agentId, Date.now());
           
           // Filter out tool error stack traces from room chat
           const text = data.output?.trim();
@@ -827,11 +969,8 @@ export class AgentForgeWorker extends EventEmitter {
       // Set up tool activity streaming (shows what tool agent is using)
       const toolActivityHandler = (data) => {
         if (data.agentId === agentId) {
-          // Record activity to prevent stuck detection from firing
-          this.recordAgentActivity(agentId);
-
           // tts tool is handled natively by openclaw — do not intercept or emit anything
-          
+
           let toolInputPreview;
           if (data.toolInput) {
             try {
@@ -841,6 +980,11 @@ export class AgentForgeWorker extends EventEmitter {
             }
           }
 
+          // Log tool calls to worker.log for always-on visibility
+          if ((data.event === 'tool_start' || data.event === 'start') && data.description) {
+            console.log(`[${agentId}] 🔧 ${data.description}${toolInputPreview ? ` — ${toolInputPreview.slice(0, 120)}` : ''}`);
+          }
+
           this.send({
             type: 'tool_activity',
             taskId,
@@ -858,69 +1002,10 @@ export class AgentForgeWorker extends EventEmitter {
       activeRunner.on('agent_error', errorHandler);
       activeRunner.on('tool_activity', toolActivityHandler);
 
-      // Listen for raw alive signals (any stdout, even filtered) to prevent false stuck detection
-      const aliveHandler = (data) => {
-        if (data.agentId === agentId) {
-          this.recordAgentActivity(agentId);
-        }
-      };
-      activeRunner.on('agent_alive', aliveHandler);
-
-      // Inactivity: warn at 60s, KILL at 10 minutes of silence (no stdout at all)
-      const INACTIVITY_WARN_MS = 60000;
-      const INACTIVITY_KILL_MS = 2 * 60 * 1000; // 2 minutes — kill truly hung openclaw
-      let lastActivityTime = Date.now();
-      let inactivityTimer = null;
-      let inactivityKillTimer = null;
       let currentTool = null; // Track which tool is currently running
-      let promiseSettled = false; // Prevent kill timer from firing after task completes
-
-      // Tools that are expected to take a while - don't warn about these
-      const QUIET_TOOLS = ['Editing file', 'Writing file', 'Reading file', 'edit', 'write', 'read'];
-
-      const clearInactivityTimers = () => {
-        if (inactivityTimer) { clearTimeout(inactivityTimer); inactivityTimer = null; }
-        if (inactivityKillTimer) { clearTimeout(inactivityKillTimer); inactivityKillTimer = null; }
-      };
+      let promiseSettled = false;
 
       const resetInactivityTimer = () => {
-        lastActivityTime = Date.now();
-        // Also reset the ping-based stuck detector so 300s kill doesn't fire during active work
-        this.lastAgentActivity.set(agentId, Date.now());
-        this.pingsSinceActivity.set(agentId, 0);
-        clearInactivityTimers();
-
-        // Warn at 30s
-        inactivityTimer = setTimeout(() => {
-          const taskInfo = this.runningTasks.get(taskId);
-          if (taskInfo && !taskInfo.cancelled) {
-            if (currentTool && QUIET_TOOLS.some(t => currentTool.toLowerCase().includes(t.toLowerCase()))) {
-              resetInactivityTimer(); // quiet tool — just reset and check again later
-              return;
-            }
-            const stuckTool = currentTool ? ` while running "${currentTool}"` : '';
-            this.send({
-              type: 'task_warning',
-              taskId,
-              agentId,
-              roomId,
-              warning: `No activity for ${INACTIVITY_WARN_MS/1000} seconds${stuckTool} - agent may be stuck`,
-              lastTool: currentTool
-            });
-          }
-        }, INACTIVITY_WARN_MS);
-
-        // Kill at 10 minutes — openclaw is definitely hung
-        inactivityKillTimer = setTimeout(() => {
-          if (promiseSettled) return;
-          const taskInfo = this.runningTasks.get(taskId);
-          if (taskInfo && !taskInfo.cancelled) {
-            console.warn(`[${agentId}] ⚠️ No output for ${INACTIVITY_KILL_MS/1000}s — openclaw hung mid-task, killing`);
-            promiseSettled = true;
-            // cancelAgent kills the process tree; OpenClawCLI's close handler will reject runAgentTask
-            activeRunner.cancelAgent(agentId);
-          }
-        }, INACTIVITY_KILL_MS);
       };
       
       // Track tool lifecycle
@@ -944,24 +1029,19 @@ export class AgentForgeWorker extends EventEmitter {
       // Wrap handlers to track activity
       const wrappedOutputHandler = activityWrapper(outputHandler);
       const wrappedToolHandler = activityWrapper(toolActivityHandler);
-      const wrappedAliveHandler = activityWrapper(aliveHandler);
-      
+
       activeRunner.off('agent_output', outputHandler);
       activeRunner.off('tool_activity', toolActivityHandler);
-      activeRunner.off('agent_alive', aliveHandler);
       activeRunner.on('agent_output', wrappedOutputHandler);
       activeRunner.on('tool_activity', wrappedToolHandler);
-      activeRunner.on('agent_alive', wrappedAliveHandler);
 
       // Capture cleanup as a callable closure so both try and catch paths can use it
       _cleanup = () => {
-        promiseSettled = true; // Prevent inactivity kill timer from firing after task ends
-        clearInactivityTimers();
+        promiseSettled = true;
         activeRunner.off('agent_output', wrappedOutputHandler);
         activeRunner.off('agent_error', errorHandler);
         activeRunner.off('tool_activity', wrappedToolHandler);
         activeRunner.off('tool_activity', toolLifecycleHandler);
-        activeRunner.off('agent_alive', wrappedAliveHandler);
         activeRunner.off('agent_image', imageHandler);
       };
 
@@ -981,13 +1061,73 @@ export class AgentForgeWorker extends EventEmitter {
         finalMessage = contextInfo;
       }
 
+      // If taskCwd is set, scan projects folder and auto-inject context for any project
+      // mentioned by name in the user message — so the agent never needs to ask "where is it?"
+      let projectContext = null;
+      if (taskCwd && taskCwd !== agentWorkspaceDir) {
+        try {
+          const projects = readdirSync(taskCwd).filter(e => !e.startsWith('.'));
+          // Find project dirs whose name appears in the user message (case-insensitive)
+          const msg = userMessage.toLowerCase();
+          const matched = projects.filter(p => msg.includes(p.toLowerCase()));
+          if (matched.length > 0) {
+            const snippets = [];
+            for (const proj of matched.slice(0, 2)) {
+              const projPath = path.join(taskCwd, proj);
+              // Read package.json or first README for stack/description
+              for (const fname of ['package.json', 'README.md', 'readme.md']) {
+                const fpath = path.join(projPath, fname);
+                if (existsSync(fpath)) {
+                  try {
+                    const raw = readFileSync(fpath, 'utf-8').slice(0, 800);
+                    snippets.push(`--- ${proj}/${fname} ---\n${raw}`);
+                    break;
+                  } catch { /* skip */ }
+                }
+              }
+              // If nested (e.g. "Faith Guide/Faith Guide App"), go one level deeper
+              if (snippets.length === 0) {
+                try {
+                  const sub = readdirSync(projPath).filter(e => !e.startsWith('.'));
+                  for (const s of sub.slice(0, 4)) {
+                    const subPath = path.join(projPath, s);
+                    // Try package.json first
+                    const pkgPath = path.join(subPath, 'package.json');
+                    if (existsSync(pkgPath)) {
+                      try { snippets.push(`--- ${proj}/${s}/package.json ---\n${readFileSync(pkgPath, 'utf-8').slice(0, 600)}`); break; } catch { /* skip */ }
+                    }
+                    // Detect Swift/iOS (Xcode project)
+                    const xcode = readdirSync(subPath).find(f => f.endsWith('.xcodeproj'));
+                    if (xcode) {
+                      // Read any .md file in this folder for context
+                      const md = readdirSync(subPath).find(f => f.endsWith('.md'));
+                      const mdContent = md ? readFileSync(path.join(subPath, md), 'utf-8').slice(0, 600) : '';
+                      const subContents = readdirSync(subPath).filter(e => !e.startsWith('.')).join(', ');
+                      snippets.push(`--- ${proj}/${s} --- (Swift/iOS Xcode project)\nContents: ${subContents}${mdContent ? '\n\n' + md + ':\n' + mdContent : ''}`);
+                      break;
+                    }
+                  }
+                  if (snippets.length === 0) snippets.push(`--- ${proj}/ ---\nSubfolders: ${sub.join(', ')}`);
+                } catch { /* skip */ }
+              }
+            }
+            if (snippets.length > 0) {
+              projectContext = `[Project context pre-loaded — do NOT ask the user for this info:\n${snippets.join('\n\n')}\n]`;
+            }
+          }
+        } catch { /* non-fatal */ }
+      }
+
       // Inject platform context into EVERY message so the agent always knows:
       // 1. What platform it's running on and its URL
       // 2. Where the user's projects folder is
       // 3. Screenshot capabilities
       const platformContext = [
         `[System context:`,
-        `- Platform: AgentForge.ai. Dashboard: https://agentforgeai-production.up.railway.app/dashboard. CRITICAL: Always use the built-in 'browser' tool for ALL web browsing AND web searches — NEVER use the 'web_search' tool (no API keys are configured), NEVER run shell commands like 'open', 'google-chrome', 'chromium', or any OS command to launch a browser. The browser tool connects to AgentForge Browser (port 9223) automatically. To search: use browser to navigate to google.com or perplexity.ai.`,
+        `- Platform: AgentForge.ai. Dashboard: https://agentforgeai-production.up.railway.app/dashboard. CRITICAL: Always use the built-in 'browser' tool for ALL web browsing AND web searches — NEVER use the 'web_search' tool (no API keys are configured), NEVER run shell commands like 'open', 'google-chrome', 'chromium', or any OS command to launch a browser. The browser tool connects to AgentForge Browser (port 9223) automatically. To search: use browser to navigate to google.com.`,
+        `- VIEWING/TESTING A WEB APP: Always check for a deployed URL first — look in the project for railway.toml, vercel.json, netlify.toml, .env, README.md, or package.json for a live URL. Open the deployed app in the browser. Only spin up a local server if there is genuinely no deployed version. Never default to localhost when a live URL might exist.`,
+        `- LOCAL SERVERS: If you must use localhost, try http://127.0.0.1:PORT if http://localhost:PORT fails. Do not stop and ask — just try both.`,
+        `- CREATING AGENTS AND CHATTING WITH THEM: Open the browser to https://agentforgeai-production.up.railway.app/dashboard. Click + to create a new agent. Click into that new agent's chat panel. Type a message into the chat input and send it — IN THE BROWSER, not via sessions_send. NEVER use sessions_send or sessions_spawn for this — those do not open a visible chat. The entire interaction happens inside the browser UI, start to finish, exactly like a human clicking around the dashboard.`,
         `- Your runner: ${useHampagent ? 'Hampagent' : 'OpenClaw'}.`,
         (!conversationHistory || conversationHistory.length === 0)
           ? `- This is the first message. When greeting, say: "I'm [your name] — your ${useHampagent ? 'Hampagent' : 'OpenClaw'} agent running on AgentForge." Never say "autonomous AI agent". Never list capabilities in an intro.`
@@ -996,14 +1136,28 @@ export class AgentForgeWorker extends EventEmitter {
           ? `- Your name is "${agentName}"${agentEmoji ? ` ${agentEmoji}` : ''}. This is your AgentForge identity. Do not ask the user who you are or what your name is — you already know.`
           : null,
         taskCwd && taskCwd !== agentWorkspaceDir
-          ? `- Working directory: "${taskCwd}" — user's projects folder. Check here first for any project by name.`
+          ? (() => {
+              try {
+                const entries = readdirSync(taskCwd).filter(e => !e.startsWith('.')).sort();
+                return `- Projects folder: "${taskCwd}"\n  Available projects: ${entries.join(', ')}\n  To work on a project, go to "${taskCwd}/<project name>". Folder names may contain spaces — quote paths. Do NOT ask the user where code is or what stack it uses — the project list is above, find it and read the code.`;
+              } catch {
+                return `- Projects folder: "${taskCwd}". Find projects with ls. Do NOT ask the user where code is.`;
+              }
+            })()
           : null,
         agentWorkspaceDir
           ? `- Screenshots: screencapture -x ${agentWorkspaceDir}/ss1.png && sips -Z 1280 ${agentWorkspaceDir}/ss1.png (MUST resize — API rejects images over 5MB). Send to chat with: echo "AGENTFORGE_IMAGE:${agentWorkspaceDir}/ss1.png". Always screenshot visual work before saying done. NEVER use "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless for screenshots — use screencapture only.`
           : `- Screenshots: screencapture -x /tmp/ss1.png && sips -Z 1280 /tmp/ss1.png (MUST resize — API rejects images over 5MB). Send to chat with: echo "AGENTFORGE_IMAGE:/tmp/ss1.png". Always screenshot visual work before saying done. NEVER use "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless for screenshots — use screencapture only.`,
+        `- QUALITY STANDARD FOR VISUAL WORK: Screenshot everything and critique harshly. HARD FAILS: (1) any unreadable contrast. (2) NEVER default to dark background + purple/indigo/blue-gray accent + rounded cards — that specific combination is AI-generated slop. Dark themes are fine when intentional; the ban is on lazy defaults, not dark aesthetics. (3) NEVER use the rounded-square block logo with a centered symbol — teal/orange/blue square with a snowflake, asterisk, key, or geometric shape inside is the single most overused AI logo pattern and is immediately recognizable as LLM output. If the app needs a logo or icon, design something that actually reflects the product concept: wordmarks, custom letterforms, logotypes, or illustrated marks — not a colored square with a centered glyph. Every UI needs a deliberate distinct visual identity: a dominant color that fits the app, strong typographic scale, and one signature visual element that makes it look like a real product. Use actual Google Search for competitors and design research — use \`openclaw browser open "https://www.google.com/search?q=best+[app+type]+app"\` to open a VISIBLE browser tab the user can watch. Do NOT use any internal search command — it must open as a real browser tab. Once loaded: (1) screenshot the full results page including the AI overview at the top, (2) also open \`https://www.google.com/search?q=best+[app+type]+app&tbm=isch\` in another tab to see Google Images of real UI designs and screenshot that too, (3) keep the search tab open while you work — do not close it immediately, (4) then click through to the top-ranked modern products from the actual results. DO NOT pick sites from training data. DO NOT visit Wikipedia, old forums, or anything that is not a live modern product. Trust the search results on screen. NEVER seed or generate fake data in code — no generateSampleHistory(), no sampleData arrays, no initialWorkouts, no seed scripts, no "preloaded" content of any kind. When localStorage/DB is empty, show an empty state. "Realistic sample data pre-loaded" is not a feature, it is a bug. To test the app, open it in the browser and add data through the UI as a real user would.`,
+        `- NARRATE YOUR WORK IN REAL TIME — THIS IS CRITICAL: The user is watching and sees nothing while you work. You must send short chat messages as you go so they know what is happening. Do NOT work silently for minutes then dump everything at the end. After every significant action, write a brief update: what you just did, what you found, what you are doing next. Examples: "Opening Obsidian and Roam to study the UI patterns..." / "Found it — Craft uses warm cream + serif type, very distinct. Stealing that direction." / "Building the graph view now, using D3 force-directed layout." / "Graph is working. Testing bi-directional links next." One or two sentences is enough — just keep the user in the loop continuously. Think of it like pair programming where you narrate out loud. Never go more than 60 seconds without sending an update.`,
+        `- RESEARCH STANDARD: When asked to research before building, visit MINIMUM 5 sources. Navigate to actual live apps and take screenshots — reading a description is not research. Extract specific named UI patterns you are borrowing. Shallow research = shallow output.`,
+        `- BROWSER PROFILE — ALWAYS VISIBLE: ALWAYS use profile="agentforge" on every single browser call: \`browser(action="...", profile="agentforge")\`. NEVER use the default headless openclaw browser — it is invisible to the user. The agentforge profile runs on port 9223 and is a real Chrome window the user can watch. If you omit profile="agentforge", the user cannot see what you are doing.`,
+        `- BROWSER TAB RULE: \`openclaw browser navigate <url>\` loads the URL into the currently focused tab — which is the user's live AgentForge dashboard. Calling navigate with an external URL DESTROYS the user's chat view. Always use \`openclaw browser open <url>\` for any external site — it opens a new tab and leaves the dashboard untouched. When done researching, close those tabs with \`openclaw browser close <id>\` and restore the dashboard with \`openclaw browser focus <id>\`.`,
+        `- CURRENT YEAR IS ${new Date().getFullYear()}. Never hardcode 2024 or 2025 in footers, copyright notices, or anywhere else. Always use ${new Date().getFullYear()}.`,
+        `- BUILD QUALITY — NO LAZY ONE-FILE SETUPS: When asked to build something, build it properly. A real app has a real structure: separate files for server, frontend, styles, and logic. No single-file HTML dumps with everything jammed together. No "simple version" shortcuts. If the user asks for a web app, build a web app — with a backend (Node/Express or equivalent), a real frontend, a database or persistent storage, and proper file organization. The only exception is if the user explicitly asks for a quick prototype or single-file output. When in doubt, build the real thing.`,
         `]`
       ].filter(Boolean).join('\n');
-      finalMessage = platformContext + '\n\n' + finalMessage;
+      finalMessage = platformContext + '\n\n' + (projectContext ? projectContext + '\n\n' : '') + finalMessage;
 
       // If conversation history was loaded from DB (e.g. session expired, worker restarted,
       // or user returning hours later), prepend it so the agent has full context.
@@ -1039,7 +1193,7 @@ export class AgentForgeWorker extends EventEmitter {
             return text.replace(/\[System context:[\s\S]*?\n\]/g, '').trim();
           };
           const historyText = conversationHistory
-            .slice(-5) // last 5 messages — keep context small to prevent API hangs
+            .slice(-50) // last 50 messages of conversation history
             .map(msg => {
               const role = msg.role === 'user' ? 'User' : 'Assistant';
               const content = msg.role === 'user'
@@ -1074,6 +1228,9 @@ export class AgentForgeWorker extends EventEmitter {
       let taskResult;
       let iterationMessage = finalMessage;
 
+      // Agents use the browser concurrently — each tracks its own tab IDs.
+      // No global lock; locking serialized all work behind any single browsing agent.
+
       while (iteration < MAX_ITERATIONS) {
         iteration++;
 
@@ -1092,7 +1249,7 @@ export class AgentForgeWorker extends EventEmitter {
         console.log(`[${taskId}] 🏃 Runner: ${useHampagent ? '⚡ HAMPAGENT' : '🔧 OPENCLAW'} — agent ${agentId} iteration ${iteration}`);
         const runAgentStart = Date.now();
         taskResult = await activeRunner.runAgentTask(
-          agentId, iterationMessage, taskCwd, sessionId, iteration === 1 ? image : null, browserProfile, actualWorkDir
+          agentId, iterationMessage, taskCwd, sessionId, iteration === 1 ? image : null, browserProfile, actualWorkDir, agentModel || null
         );
         const runAgentDuration = Date.now() - runAgentStart;
         console.log(`[${taskId}] runAgentTask iteration ${iteration} returned after ${runAgentDuration}ms, success=${taskResult?.success}`);
@@ -1159,6 +1316,7 @@ export class AgentForgeWorker extends EventEmitter {
         console.log(`[${taskId}] Got identity in ${Date.now() - identityStart}ms: ${identity.identityName}`);
       }
 
+
       // Send completion with identity info, final response text, and sessionId for maestro
       // Filter openclaw's "No reply from agent." placeholder — it appears when the agent only
       // used tools with no text response (e.g. TTS-only tasks). If we send it, the browser's
@@ -1553,17 +1711,9 @@ Review and add specific steps, pitfalls, and patterns that helped succeed.
     }
   }
 
-  // Record that an agent produced output (reset stuck detection)
-  recordAgentActivity(agentId) {
-    this.lastAgentActivity.set(agentId, Date.now());
-    this.pingsSinceActivity.set(agentId, 0);
-  }
-
   // Collect detailed diagnostics for debug agent
   collectDiagnostics(agentId, taskId, error, reason) {
     const taskInfo = this.runningTasks.get(taskId);
-    const lastActivity = this.lastAgentActivity.get(agentId);
-    const pings = this.pingsSinceActivity.get(agentId) || 0;
     const processingTime = this.processingStartTime.get(agentId);
 
     return {
@@ -1577,9 +1727,6 @@ Review and add specific steps, pitfalls, and patterns that helped succeed.
         name: error.name
       } : null,
       activity: {
-        lastActivityTime: lastActivity,
-        timeSinceActivity: lastActivity ? Date.now() - lastActivity : null,
-        pingsSinceActivity: pings,
         processingStartTime: processingTime,
         processingDuration: processingTime ? Date.now() - processingTime : null
       },
@@ -1605,121 +1752,8 @@ Review and add specific steps, pitfalls, and patterns that helped succeed.
     });
   }
 
-  // Check for stuck agents on each ping
-  checkForStuckAgents() {
-    for (const [agentId, isProcessing] of this.agentProcessing.entries()) {
-      if (isProcessing) {
-        // First, check if the process is still alive - if so, it's probably just thinking
-        const agentInfo = this.cli.activeAgents?.get(agentId);
-        const pid = agentInfo?.proc?.pid;
-        if (pid) {
-          try {
-            // process.kill(pid, 0) checks if process exists without killing it
-            process.kill(pid, 0);
-            // Process is alive - record activity to prevent false stuck detection
-            // This handles cases where the CLI is blocking on API calls with no stdout
-            this.recordAgentActivity(agentId);
-          } catch (e) {
-            // Process is dead - let stuck detection proceed
-            console.log(`⚠️  Agent ${agentId} process (PID ${pid}) appears dead`);
-          }
-        }
-
-        // Increment ping counter for this agent
-        const pings = (this.pingsSinceActivity.get(agentId) || 0) + 1;
-        this.pingsSinceActivity.set(agentId, pings);
-        
-        // Check if there's an active task for this agent
-        let hasActiveTask = false;
-        for (const [taskId, taskInfo] of this.runningTasks.entries()) {
-          if (taskInfo.agentId === agentId && !taskInfo.cancelled) {
-            hasActiveTask = true;
-            break;
-          }
-        }
-
-        // Use very long threshold if task is active (10 pings = 300s / 5 min)
-        // OpenClaw embedded agents can spend 2-3+ minutes on complex reasoning
-        // Only mark as stuck if truly unresponsive (no output for 5+ minutes)
-        const threshold = hasActiveTask ? 10 : this.STUCK_PING_THRESHOLD;
-
-        // Log warning when agent is quiet but not yet stuck (helps with debugging)
-        if (pings >= this.STUCK_PING_THRESHOLD && pings < threshold) {
-          console.log(`⚠️  Agent ${agentId} quiet for ${pings} pings (${Math.round((Date.now() - this.lastAgentActivity.get(agentId)) / 1000)}s), but task is active - waiting...`);
-        }
-
-        if (pings >= threshold) {
-          const lastActivity = this.lastAgentActivity.get(agentId);
-          const elapsed = lastActivity ? Math.round((Date.now() - lastActivity) / 1000) : '?';
-          const reason = hasActiveTask ? 'no output for 300s+ AND process dead' : 'no active task';
-          console.log(`🚨 STUCK DETECTED: Agent ${agentId} has had ${pings} pings with no activity (${reason}, last activity: ${elapsed}s ago)`);
-          console.log(`🚨 Force resetting agent ${agentId} to accept new tasks`);
-
-          // Find the task for diagnostics
-          let stuckTaskId = null;
-          for (const [taskId, taskInfo] of this.runningTasks.entries()) {
-            if (taskInfo.agentId === agentId && !taskInfo.cancelled) {
-              stuckTaskId = taskId;
-              break;
-            }
-          }
-
-          // Collect diagnostics before cleanup
-          const diagnostics = this.collectDiagnostics(
-            agentId,
-            stuckTaskId,
-            new Error(`Agent unresponsive for ${elapsed}s`),
-            'stuck'
-          );
-
-          // Force kill the process — try both runners
-          this.cli.cancelAgent(agentId);
-          this.hampagent?.cancelAgent(agentId);
-
-          // Clear all state for this agent
-          this.agentProcessing.set(agentId, false);
-          this.processingStartTime.delete(agentId);
-          this.pingsSinceActivity.set(agentId, 0);
-
-          // Find and cancel any running task for this agent
-          for (const [taskId, taskInfo] of this.runningTasks.entries()) {
-            if (taskInfo.agentId === agentId && !taskInfo.cancelled) {
-              taskInfo.cancelled = true;
-              this.runningTasks.delete(taskId);
-              this.send({
-                type: 'task_failed',
-                taskId,
-                agentId,
-                error: 'Agent became unresponsive (stuck detection triggered)'
-              });
-            }
-          }
-
-          // Send debug report
-          this.sendDebugReport(diagnostics, `Agent ${agentId} became unresponsive after ${elapsed}s with no activity`);
-
-          // Process any queued tasks
-          const queue = this.agentQueues.get(agentId);
-          if (queue && queue.length > 0) {
-            console.log(`📤 Processing ${queue.length} queued tasks after stuck recovery`);
-            setImmediate(() => this.processQueue(agentId));
-          }
-        }
-      }
-    }
-  }
-
   async shutdown() {
     console.log('🛑 Shutting down worker...');
-    // Kill all active agent processes so they don't become orphans on restart
-    if (this.cli && typeof this.cli.cancelAgent === 'function') {
-      for (const agentId of this.agentProcessing.keys()) {
-        if (this.agentProcessing.get(agentId)) {
-          console.log(`🔪 Killing agent process: ${agentId}`);
-          try { this.cli.cancelAgent(agentId); } catch (e) { /* already dead */ }
-        }
-      }
-    }
     if (this.ws) {
       this.ws.close();
     }