onbuzz 3.4.0 → 3.6.2

package/src/tools/__tests__/webTool.e2e.test.js

@@ -7,17 +7,31 @@
  *
  * NOTE: These tests require network access and a working Puppeteer install.
  * They are slower (~60s total) and are tagged for separate runs.
+ * Skipped on WSL/headless Linux (no display server for Chromium).
  *
- * Run with: npm test -- --testPathPattern=webTool.e2e
+ * Run with: npm run test:e2e
  */
 
 import { describe, test, expect, beforeAll, afterAll } from '@jest/globals';
+import os from 'os';
+import fs from 'fs';
+
+// Skip on WSL (no display) or when SKIP_BROWSER_TESTS is set
+const isWSL = (() => {
+  try {
+    return os.platform() === 'linux' && fs.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft');
+  } catch { return false; }
+})();
+const skipBrowser = isWSL || process.env.SKIP_BROWSER_TESTS === 'true';
+
+const describeIfBrowser = skipBrowser ? describe.skip : describe;
 
 let WebTool;
 let wt;
 const silentLogger = { info() {}, warn() {}, error() {}, debug() {} };
 
 beforeAll(async () => {
+  if (skipBrowser) return;
   const mod = await import('../../tools/webTool.js');
   WebTool = mod.default;
   wt = new WebTool({ logger: silentLogger });
@@ -29,7 +43,7 @@ afterAll(async () => {
 
 // ─── HTTP Status Detection ──────────────────────────────────────────────────
 
-describe('HTTP status detection', () => {
+describeIfBrowser('HTTP status detection', () => {
   test('fetch valid page returns success with HTTP 200', async () => {
     const result = await wt.execute(
       { operation: 'fetch', url: 'https://example.com', formats: ['title'] },
@@ -63,7 +77,7 @@ describe('HTTP status detection', () => {
 
 // ─── Selector Pre-Validation ─────────────────────────────────────────────────
 
-describe('Selector pre-validation', () => {
+describeIfBrowser('Selector pre-validation', () => {
   test('click on non-existent selector returns actionable error', async () => {
     const result = await wt.execute({
       operation: 'interactive',
@@ -174,7 +188,7 @@ describe('Selector pre-validation', () => {
 
 // ─── URL Validation in Interactive ───────────────────────────────────────────
 
-describe('URL validation in interactive actions', () => {
+describeIfBrowser('URL validation in interactive actions', () => {
   test('navigate to invalid URL returns error without crashing', async () => {
     const result = await wt.execute({
       operation: 'interactive',
@@ -212,7 +226,7 @@ describe('URL validation in interactive actions', () => {
 
 // ─── Wait-for Timeout Feedback ───────────────────────────────────────────────
 
-describe('Wait-for timeout feedback', () => {
+describeIfBrowser('Wait-for timeout feedback', () => {
   test('wait-for non-existent element returns timeout error with context', async () => {
     const result = await wt.execute({
       operation: 'interactive',
@@ -253,7 +267,7 @@ describe('Wait-for timeout feedback', () => {
 
 // ─── Successful Operations ───────────────────────────────────────────────────
 
-describe('Successful operations', () => {
+describeIfBrowser('Successful operations', () => {
   test('extract-text on existing element returns content', async () => {
     const result = await wt.execute({
       operation: 'interactive',
@@ -329,7 +343,7 @@ describe('Successful operations', () => {
 
 // ─── Search ──────────────────────────────────────────────────────────────────
 
-describe('Search operations', () => {
+describeIfBrowser('Search operations', () => {
   test('search with valid query returns results', async () => {
     const result = await wt.execute(
       { operation: 'search', query: 'javascript MDN', engine: 'duckduckgo', maxResults: 3 },
@@ -355,7 +369,7 @@ describe('Search operations', () => {
 
 // ─── Multi-Action Chains ─────────────────────────────────────────────────────
 
-describe('Multi-action chains', () => {
+describeIfBrowser('Multi-action chains', () => {
   test('chain of actions reports per-action success/failure', async () => {
     const result = await wt.execute({
       operation: 'interactive',
@@ -409,7 +423,7 @@ describe('Multi-action chains', () => {
 
 // ─── Tab Reuse ───────────────────────────────────────────────────────────────
 
-describe('Tab reuse', () => {
+describeIfBrowser('Tab reuse', () => {
   test('reusing existing tab preserves session and returns reused flag', async () => {
     // First: open tab
     await wt.execute({
@@ -441,7 +455,7 @@ describe('Tab reuse', () => {
 
 // ─── JS Error & Network Failure Detection ────────────────────────────────────
 
-describe('JS error and network failure detection', () => {
+describeIfBrowser('JS error and network failure detection', () => {
   test('JS errors on page are captured in pageErrors tracker', async () => {
     // Open tab first
     await wt.execute({
@@ -518,7 +532,7 @@ describe('JS error and network failure detection', () => {
 
 // ─── Result Structure ────────────────────────────────────────────────────────
 
-describe('Result structure and data consistency', () => {
+describeIfBrowser('Result structure and data consistency', () => {
   test('fetch result has required fields', async () => {
     const result = await wt.execute(
       { operation: 'fetch', url: 'https://example.com', formats: ['title', 'text'] },

package/src/tools/imageTool.js

@@ -479,13 +479,33 @@ export class ImageTool extends BaseTool {
           let imageUrl;
           let isTemporary = false;
 
+          this.logger?.info('Image generation result', {
+            jobId: job.jobId,
+            savedToDisk: result.savedToDisk,
+            resolvedOutputPath: result.resolvedOutputPath,
+            temporaryUrl: result.temporaryUrl?.substring(0, 80),
+            downloadError: result.downloadError,
+            isBase64Response: result.isBase64Response
+          });
+
           if (result.savedToDisk && result.resolvedOutputPath) {
             // Image was saved successfully - use our server endpoint
             imageUrl = this._convertToWebUrl(result.resolvedOutputPath, job.sessionId);
+            this.logger?.info('Using local server URL for image', { imageUrl });
           } else if (result.temporaryUrl) {
             // Download failed - use temporary AI-generated URL (expires in ~1 hour)
             imageUrl = result.temporaryUrl;
             isTemporary = true;
+            this.logger?.warn('Using temporary AI URL for image (local save failed)', {
+              imageUrl: imageUrl.substring(0, 80),
+              downloadError: result.downloadError
+            });
+          } else {
+            this.logger?.error('No image URL available - neither local save nor temporary URL', {
+              jobId: job.jobId,
+              savedToDisk: result.savedToDisk,
+              hasTemporaryUrl: !!result.temporaryUrl
+            });
           }
 
           global.loxiaWebServer.broadcastToSession(job.sessionId, {
@@ -788,11 +808,19 @@ export class ImageTool extends BaseTool {
 
     try {
       if (b64Json) {
-        // Flux response: Save base64 directly to disk
-        this.logger?.info('Saving base64 image directly to disk (Flux response)');
+        // Flux/GPT-Image response: Save base64 directly to disk
+        this.logger?.info(`Saving base64 image to disk: ${resolvedOutputPath}`);
         const imageBuffer = Buffer.from(b64Json, 'base64');
         await fs.writeFile(resolvedOutputPath, imageBuffer);
-        savedToDisk = true;
+
+        // Verify the file was actually written
+        const stat = await fs.stat(resolvedOutputPath);
+        if (stat.size > 0) {
+          savedToDisk = true;
+          this.logger?.info(`Image saved successfully: ${resolvedOutputPath} (${stat.size} bytes)`);
+        } else {
+          this.logger?.warn(`Image file is empty after write: ${resolvedOutputPath}`);
+        }
 
         // For web display, we'll use our local server endpoint (set below)
         displayUrl = null; // Will be converted to web URL later
@@ -800,7 +828,15 @@ export class ImageTool extends BaseTool {
         // URL response: Download from URL
         this.logger?.info(`Downloading image from URL: ${imageUrl.substring(0, 50)}...`);
         await this._downloadImage(imageUrl, resolvedOutputPath);
-        savedToDisk = true;
+
+        // Verify the file was actually written
+        const stat = await fs.stat(resolvedOutputPath);
+        if (stat.size > 0) {
+          savedToDisk = true;
+          this.logger?.info(`Image downloaded successfully: ${resolvedOutputPath} (${stat.size} bytes)`);
+        } else {
+          this.logger?.warn(`Downloaded image file is empty: ${resolvedOutputPath}`);
+        }
         displayUrl = imageUrl;
       }
 
@@ -811,7 +847,7 @@ export class ImageTool extends BaseTool {
     } catch (error) {
       // Save failed, but we might still have a temporary URL
       downloadError = error.message;
-      this.logger?.warn(`Failed to save image to disk: ${error.message}`);
+      this.logger?.error(`Failed to save image to disk at ${resolvedOutputPath}: ${error.message}`);
 
       if (!imageUrl) {
         // No URL fallback for Flux - this is a real failure

package/src/tools/webTool.js

@@ -9,18 +9,13 @@
  * - Screenshot capture and AI-powered analysis
  * - Mouse and keyboard event simulation
  *
- * NOTE: This tool replaces the deprecated BrowserTool (December 2024).
- * WebTool provides equivalent functionality with a singleton browser instance
- * architecture for better resource management.
- *
  * ============================================================================
- * TODO: FEATURES TO ADD (migrated from deprecated BrowserTool)
+ * TODO: FEATURES TO ADD
  * ============================================================================
  *
  * TODO 1: TIME-BASED WAIT ACTION
  * -----------------------------------------------------------------------------
  * Add a time-based wait capability alongside the existing 'wait-for-selector'.
- * The deprecated BrowserTool supported: { "action": "wait", "waitTime": 3000 }
  *
  * Implementation details:
  * - Add new action type: 'wait' or 'delay' (distinct from 'wait-for-selector')
@@ -46,8 +41,7 @@
  * TODO 2: IMPROVED TYPE ACTION WITH ELEMENT WAITING AND CLEARING
  * -----------------------------------------------------------------------------
  * Enhance the 'type' action to automatically wait for the element and optionally
- * clear existing content before typing. The deprecated BrowserTool had better
- * handling for form inputs.
+ * clear existing content before typing.
  *
  * Implementation details:
  * - Before typing, wait for the selector to be visible (with configurable timeout)
@@ -279,7 +273,7 @@ First FETCH the login page to identify form selectors, then authenticate:
 
 1. SEARCH - Search the web
 \`\`\`json
-{"toolId": "web", "operation": "search", "query": "search terms", "engine": "google", "maxResults": 10}
+{"toolId": "web", "operation": "search", "query": "search terms", "engine": "duckduckgo", "maxResults": 10}
 \`\`\`
 
 2. FETCH - Get page content (public pages only)
@@ -404,7 +398,7 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
       switch (params.operation) {
         case 'search':
           params.query = TagParser.extractContent(content, 'query')[0]?.trim();
-          params.engine = TagParser.extractContent(content, 'engine')[0]?.trim() || 'google';
+          params.engine = TagParser.extractContent(content, 'engine')[0]?.trim() || 'duckduckgo';
           const maxResults = TagParser.extractContent(content, 'max-results')[0]?.trim();
           params.maxResults = maxResults ? parseInt(maxResults, 10) : 10;
           // stealthLevel for search (default standard, use maximum if getting blocked)
@@ -666,7 +660,7 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
       switch (operation) {
         case 'search':
           result = await this.search(params.query, {
-            engine: params.engine || 'google',
+            engine: params.engine || 'duckduckgo',
             maxResults: params.maxResults || 10,
             stealthLevel: effectiveStealthLevel,
             agentId
@@ -719,23 +713,63 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
       // Flatten result for easier access (result.title instead of result.result.title)
       // IMPORTANT: Respect the operation's own success flag — don't override it to true
       const operationSuccess = result.success !== undefined ? result.success : true;
+
+      // Surface the FIRST actionable error from nested results so the agent
+      // always sees a top-level error/suggestion on failure — not just success:false.
+      let surfacedError = result.error;
+      let surfacedSuggestion = result.suggestion;
+      let surfacedWarning = result.warning;
+      if (!surfacedError && !operationSuccess && result.results) {
+        for (const tabResult of (Array.isArray(result.results) ? result.results : [])) {
+          // Check tab-level error first
+          if (tabResult.error && !surfacedError) {
+            surfacedError = tabResult.error;
+            if (tabResult.suggestion) surfacedSuggestion = tabResult.suggestion;
+          }
+          // Then check nested action results
+          if (tabResult.results && Array.isArray(tabResult.results)) {
+            for (const actionResult of tabResult.results) {
+              if (actionResult.success === false && actionResult.error && !surfacedError) {
+                surfacedError = actionResult.error;
+                if (actionResult.suggestion) surfacedSuggestion = actionResult.suggestion;
+              }
+            }
+          }
+          if (!surfacedWarning && tabResult.warning) surfacedWarning = tabResult.warning;
+        }
+      }
+
       return {
         success: operationSuccess,
         operation,
         toolUsed: 'web',
         // Spread operation-specific data at top level
         data: result,
+        // Always surface error/suggestion at top level so agent sees why it failed
+        ...(surfacedError && { error: surfacedError }),
+        ...(surfacedSuggestion && { suggestion: surfacedSuggestion }),
+        ...(surfacedWarning && { warning: surfacedWarning }),
         // Also keep common properties at top level for convenience
         ...(result.title !== undefined && { title: result.title }),
         ...(result.text !== undefined && { text: result.text }),
         ...(result.url !== undefined && { url: result.url }),
         ...(result.results !== undefined && { results: result.results }),
         ...(result.resultsCount !== undefined && { resultsCount: result.resultsCount }),
-        ...(result.error !== undefined && { error: result.error }),
-        ...(result.warning !== undefined && { warning: result.warning }),
         ...(result.httpStatus !== undefined && { httpStatus: result.httpStatus }),
-        ...(result.suggestion !== undefined && { suggestion: result.suggestion }),
-        // Surface page-level errors for agent awareness
+        ...(result.stealthNotice !== undefined && { stealthNotice: result.stealthNotice }),
+        // Surface diagnostics (page-level observations separate from tool success)
+        // Check both top-level and nested results for diagnostics
+        ...((() => {
+          const diag = result.diagnostics ? { ...result.diagnostics } : {};
+          if (result.results) {
+            for (const tabResult of (Array.isArray(result.results) ? result.results : [])) {
+              if (tabResult.diagnostics) Object.assign(diag, tabResult.diagnostics);
+            }
+          }
+          return Object.keys(diag).length > 0 ? { diagnostics: diag } : {};
+        })()),
+        ...(result.notice && { notice: result.notice }),
+        // Legacy: also surface flat arrays for backwards compatibility
         ...(result.jsErrors?.length > 0 && { jsErrors: result.jsErrors }),
         ...(result.networkFailures?.length > 0 && { networkFailures: result.networkFailures }),
         ...(result.httpErrors?.length > 0 && { httpErrors: result.httpErrors })
@@ -777,11 +811,25 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         suggestion = 'The page took too long to load. Check your internet connection or try again.';
       }
 
+      // Detect bot detection / CAPTCHA failures — may be stealth-related
+      if (error.message.includes('CAPTCHA') || error.message.includes('blocked') ||
+          error.message.includes('403') || error.message.includes('Access Denied')) {
+        const currentLevel = this.browser?._stealthConfig?.stealthLevel || 'unknown';
+        if (currentLevel === 'standard') {
+          suggestion = (suggestion ? suggestion + ' ' : '') +
+            `Currently running at stealth level 'standard' (headless). This site may require stealthLevel: 'maximum' (visible browser) to bypass bot detection. Close open tabs first if needed.`;
+        }
+      }
+
+      // Include current stealth context so agent can make informed decisions
+      const currentStealthLevel = this.browser?._stealthConfig?.stealthLevel || null;
+
       return {
         success: false,
         operation,
         error: enhancedError,
         ...(suggestion && { suggestion }),
+        ...(currentStealthLevel && { currentStealthLevel }),
         toolUsed: 'web'
       };
     }
@@ -893,7 +941,10 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
     // called it with the appropriate stealth level. This prevents accidentally
     // resetting the browser to 'standard' stealth when 'maximum' is needed.
     if (!this.browser || !this.browser.isConnected()) {
-      throw new Error('Browser not initialized. Call ensureBrowser() first.');
+      throw new Error(
+        'Browser not initialized or connection lost. This can happen if another operation ' +
+        'changed the stealth level and restarted the browser. Retry the operation.'
+      );
     }
 
     const page = await createStealthPage(this.browser, {
@@ -916,7 +967,7 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
    * @returns {Promise<Object>} Search results
    */
   async search(query, options = {}) {
-    const { engine = 'google', maxResults = 10, agentId, humanMode = true, stealthLevel = 'standard' } = options;
+    const { engine = 'duckduckgo', maxResults = 10, agentId, humanMode = true, stealthLevel = 'standard' } = options;
 
     // Validate query
     if (!query || typeof query !== 'string' || query.trim().length === 0) {
@@ -930,8 +981,17 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
 
     this.logger?.info('[WebTool] Performing web search', { query, engine, agentId, humanMode, stealthLevel });
 
-    // Ensure browser with specified stealth level
-    await this.ensureBrowser({ stealthLevel });
+    // Reuse existing browser if running (preserve interactive/auth sessions)
+    let stealthDowngradeNotice = null;
+    if (this.browser && this.browser.isConnected()) {
+      const currentLevel = this.browser._stealthConfig?.stealthLevel || 'standard';
+      if (currentLevel !== stealthLevel) {
+        stealthDowngradeNotice = `Note: Running at stealth level '${currentLevel}' instead of requested '${stealthLevel}' to preserve active browser sessions. If this operation fails due to bot detection, close open tabs first and retry with stealthLevel: '${stealthLevel}'.`;
+        this.logger?.info('[WebTool] search: reusing existing browser', { requested: stealthLevel, actual: currentLevel });
+      }
+    } else {
+      await this.ensureBrowser({ stealthLevel });
+    }
 
     // Create stealth page with optional human-like cursor
     const { page, cursor } = await this.createPage({ humanMode });
@@ -998,6 +1058,10 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         results
       };
 
+      if (stealthDowngradeNotice) {
+        searchResult.stealthNotice = stealthDowngradeNotice;
+      }
+
       // Warn when 0 results — may indicate selector mismatch or CAPTCHA
       if (results.length === 0) {
         searchResult.warning = 'Search returned 0 results. This may indicate: (1) no matching results exist, (2) the search engine blocked the request (CAPTCHA), or (3) the page layout changed and results could not be extracted.';
@@ -1031,8 +1095,17 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
       return { success: false, error: `Invalid URL format: "${url}". Must include protocol (e.g. https://example.com)` };
     }
 
-    // Ensure browser with specified stealth level
-    await this.ensureBrowser({ stealthLevel });
+    // Reuse existing browser if running (preserve interactive/auth sessions)
+    let stealthDowngradeNotice = null;
+    if (this.browser && this.browser.isConnected()) {
+      const currentLevel = this.browser._stealthConfig?.stealthLevel || 'standard';
+      if (currentLevel !== stealthLevel) {
+        stealthDowngradeNotice = `Note: Running at stealth level '${currentLevel}' instead of requested '${stealthLevel}' to preserve active browser sessions. If this operation fails due to bot detection, close open tabs first and retry with stealthLevel: '${stealthLevel}'.`;
+        this.logger?.info('[WebTool] fetch: reusing existing browser', { requested: stealthLevel, actual: currentLevel });
+      }
+    } else {
+      await this.ensureBrowser({ stealthLevel });
+    }
 
     this.logger?.info('Fetching web content', { url, formats, agentId, stealthLevel });
 
@@ -1057,10 +1130,11 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
 
       if (fetchStatus && fetchStatus >= 400) {
         const errorResult = {
-          success: false,
+          success: true,  // Fetch itself executed — page returned error status
           url,
           httpStatus: fetchStatus,
-          error: `Fetch failed with HTTP ${fetchStatus} (${fetchStatus >= 500 ? 'server error' : fetchStatus === 404 ? 'page not found' : fetchStatus === 403 ? 'access forbidden' : 'client error'})`
+          diagnostic: `Page returned HTTP ${fetchStatus} (${fetchStatus >= 500 ? 'server error' : fetchStatus === 404 ? 'page not found' : fetchStatus === 403 ? 'access forbidden' : 'client error'})`,
+          warning: `HTTP ${fetchStatus} — the page loaded but returned an error status. Content may still be available.`
         };
         // Still try to get title for context
         try { errorResult.title = await page.title(); } catch {}
@@ -1102,10 +1176,14 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
 
       this.logger?.info('Fetch completed', { url, formats, agentId });
 
-      return {
+      const fetchResult = {
         success: true,
         ...result
       };
+      if (stealthDowngradeNotice) {
+        fetchResult.stealthNotice = stealthDowngradeNotice;
+      }
+      return fetchResult;
 
     } finally {
       try { await page.close(); } catch {}
@@ -1430,9 +1508,18 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
     // Check for existing session cookies
     const existingSession = vault.getSession(normalizedSiteId);
 
-    // Create or reuse a tab for authentication with specified stealth level
-    // Default to 'maximum' (visible browser) for login pages to avoid detection
-    await this.ensureBrowser({ stealthLevel });
+    // Reuse existing browser if one is running (preserve interactive sessions).
+    // Only use the requested stealthLevel if no browser exists yet.
+    let stealthDowngradeNotice = null;
+    if (this.browser && this.browser.isConnected()) {
+      const currentLevel = this.browser._stealthConfig?.stealthLevel || 'standard';
+      if (currentLevel !== stealthLevel) {
+        stealthDowngradeNotice = `Note: Authenticating at stealth level '${currentLevel}' instead of '${stealthLevel}' to preserve active browser sessions. If login fails due to bot detection, close open tabs first and retry with stealthLevel: '${stealthLevel}'.`;
+        this.logger?.info('[WebTool] authenticate: reusing existing browser', { requested: stealthLevel, actual: currentLevel });
+      }
+    } else {
+      await this.ensureBrowser({ stealthLevel });
+    }
     const { page, cursor } = await this.createPage({ humanMode: true });
 
     try {
@@ -1458,7 +1545,8 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
               success: true,
               message: `Already logged into ${credentials.name || normalizedSiteId} (session restored)`,
               siteId: normalizedSiteId,
-              method: 'session_restore'
+              method: 'session_restore',
+              ...(stealthDowngradeNotice && { stealthNotice: stealthDowngradeNotice })
             };
           } catch {
             // Session invalid, need to login
@@ -1600,7 +1688,8 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
             siteId: normalizedSiteId,
             method: 'credentials',
             tabName,
-            tabKeptOpen: true
+            tabKeptOpen: true,
+            ...(stealthDowngradeNotice && { stealthNotice: stealthDowngradeNotice })
           };
         }
 
@@ -1609,7 +1698,8 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
           success: true,
           message: `Successfully logged into ${credentials.name || normalizedSiteId}`,
           siteId: normalizedSiteId,
-          method: 'credentials'
+          method: 'credentials',
+          ...(stealthDowngradeNotice && { stealthNotice: stealthDowngradeNotice })
         };
       } else {
         await page.close();
@@ -1692,10 +1782,11 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         if (reuseNavStatus && reuseNavStatus >= 400) {
           results.push({
             action: 'navigate',
-            success: false,
+            success: true,
             url: existingTab.page.url(),
             httpStatus: reuseNavStatus,
-            error: `Navigation got HTTP ${reuseNavStatus}`
+            diagnostic: `Page returned HTTP ${reuseNavStatus}`,
+            warning: `HTTP ${reuseNavStatus} — page loaded but returned an error status. Tab is still usable.`
           });
         }
       }
@@ -1726,17 +1817,28 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         if (humanMode) await humanWait('action');
       }
 
-      const anyFailed = results.some(r => r.success === false);
+      const failedActions = results.filter(r => r.success === false);
+      const diagnosticActions = results.filter(r => r.diagnostic);
+      const reusedJsErrors = WebTool._dedupeErrors((existingTab.pageErrors || []).map(e => e.message));
+      const reusedNetFails = WebTool._dedupeErrors((existingTab.networkFailures || []).map(f => `${f.method} ${f.url} → ${f.errorText}`));
+
+      const diagnostics = {};
+      if (reusedJsErrors.length > 0) diagnostics.jsErrors = reusedJsErrors;
+      if (reusedNetFails.length > 0) diagnostics.networkFailures = reusedNetFails;
+      if (diagnosticActions.length > 0) diagnostics.pageIssues = diagnosticActions.map(a => a.diagnostic);
+
       return {
-        success: !anyFailed,
+        success: failedActions.length === 0,
         tabName,
         url: existingTab.page.url(),
         actionsExecuted: results.length,
         results,
         reused: true,
-        ...(anyFailed && { warning: `${results.filter(r => r.success === false).length} of ${results.length} action(s) failed` }),
-        ...((existingTab.pageErrors || []).length > 0 && { jsErrors: WebTool._dedupeErrors(existingTab.pageErrors.map(e => e.message)) }),
-        ...((existingTab.networkFailures || []).length > 0 && { networkFailures: WebTool._dedupeErrors(existingTab.networkFailures.map(f => `${f.method} ${f.url} → ${f.errorText}`)) }),
+        ...(failedActions.length > 0 && { warning: `${failedActions.length} of ${results.length} action(s) failed` }),
+        ...(diagnosticActions.length > 0 && !failedActions.length && {
+          notice: `All actions executed successfully. ${diagnosticActions.length} page-level issue(s) detected — see diagnostics.`
+        }),
+        ...(Object.keys(diagnostics).length > 0 && { diagnostics }),
         ...((existingTab.httpErrors || []).length > 0 && { httpErrors: WebTool._dedupeErrors(existingTab.httpErrors.map(e => `${e.method} ${e.url} → ${e.status}`)) })
       };
     }
@@ -1886,10 +1988,11 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         if (openTabStatus && openTabStatus >= 400) {
           results.push({
             action: 'navigate',
-            success: false,
+            success: true,
             url: tabInfo.url,
             httpStatus: openTabStatus,
-            error: `Initial navigation got HTTP ${openTabStatus}`
+            diagnostic: `Page returned HTTP ${openTabStatus}`,
+            warning: `HTTP ${openTabStatus} — page loaded but returned an error status. Tab is still usable.`
           });
         }
       }
@@ -1934,23 +2037,32 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         }
       }
 
-      const anyFailed = results.some(r => r.success === false);
+      const failedActions = results.filter(r => r.success === false);
+      const diagnosticActions = results.filter(r => r.diagnostic);
       // Summarize all page issues for the agent (deduplicated)
       const allJsErrors = WebTool._dedupeErrors(pageErrors.map(e => e.message));
       const allNetworkFails = WebTool._dedupeErrors(networkFailures.map(f => `${f.method} ${f.url} → ${f.errorText}`));
       const allHttpErrs = WebTool._dedupeErrors(httpErrors.map(e => `${e.method} ${e.url} → ${e.status}`));
 
+      // Collect diagnostics: page-level observations that aren't action failures
+      const diagnostics = {};
+      if (allJsErrors.length > 0) diagnostics.jsErrors = allJsErrors;
+      if (allNetworkFails.length > 0) diagnostics.networkFailures = allNetworkFails;
+      if (allHttpErrs.length > 0) diagnostics.httpErrors = allHttpErrs;
+      if (diagnosticActions.length > 0) diagnostics.pageIssues = diagnosticActions.map(a => a.diagnostic);
+
       return {
-        success: !anyFailed,
+        success: failedActions.length === 0,
         tabName,
         url: tabInfo.url,
         actionsExecuted: results.length,
         results,
-        ...(anyFailed && { warning: `${results.filter(r => r.success === false).length} of ${results.length} action(s) failed` }),
-        // Surface all detected issues at the top level for agent awareness
-        ...(allJsErrors.length > 0 && { jsErrors: allJsErrors }),
-        ...(allNetworkFails.length > 0 && { networkFailures: allNetworkFails }),
-        ...(allHttpErrs.length > 0 && { httpErrors: allHttpErrs })
+        ...(failedActions.length > 0 && { warning: `${failedActions.length} of ${results.length} action(s) failed` }),
+        ...(diagnosticActions.length > 0 && !failedActions.length && {
+          notice: `All actions executed successfully. ${diagnosticActions.length} page-level issue(s) detected — see diagnostics.`
+        }),
+        // Surface diagnostics at top level for agent awareness
+        ...(Object.keys(diagnostics).length > 0 && { diagnostics })
       };
 
     } catch (error) {
@@ -2027,10 +2139,11 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
         }
         if (navStatus && navStatus >= 400) {
           return {
-            success: false,
+            success: true,  // Navigation itself executed — page just returned an error status
             url: tabInfo.url,
             httpStatus: navStatus,
-            error: `Navigation failed with HTTP ${navStatus} (${navStatus >= 500 ? 'server error' : navStatus === 404 ? 'page not found' : navStatus === 403 ? 'access forbidden' : 'client error'})`
+            diagnostic: `Page returned HTTP ${navStatus} (${navStatus >= 500 ? 'server error' : navStatus === 404 ? 'page not found' : navStatus === 403 ? 'access forbidden' : 'client error'})`,
+            warning: `HTTP ${navStatus} — the page loaded but returned an error status. The tab is still usable.`
           };
         }
         return { success: true, url: tabInfo.url, httpStatus: navStatus };