lazy-gravity 0.6.0 → 0.6.2

package/dist/services/cdpService.js

@@ -55,6 +55,68 @@ const SELECTORS = {
     /** Keyword to identify message injection target context */
     CONTEXT_URL_KEYWORD: 'cascade-panel',
 };
+const WORKSPACE_STATE_SCRIPT = `(() => {
+    const panel = document.querySelector('.antigravity-agent-side-panel');
+    const scopes = [panel, document].filter(Boolean);
+
+    let isGenerating = false;
+    for (const scope of scopes) {
+        const stopEl = scope.querySelector('[data-tooltip-id="input-send-button-cancel-tooltip"]');
+        if (stopEl) {
+            isGenerating = true;
+            break;
+        }
+    }
+
+    if (!isGenerating) {
+        const normalize = (value) => (value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+        const stopPatterns = [
+            /^stop$/,
+            /^stop generating$/,
+            /^stop response$/,
+            /^停止$/,
+            /^生成を停止$/,
+            /^応答を停止$/,
+        ];
+        for (const scope of scopes) {
+            const buttons = scope.querySelectorAll('button, [role="button"]');
+            for (let i = 0; i < buttons.length; i++) {
+                const btn = buttons[i];
+                const labels = [
+                    btn.textContent || '',
+                    btn.getAttribute('aria-label') || '',
+                    btn.getAttribute('title') || '',
+                ];
+                if (labels.some((label) => stopPatterns.some((re) => re.test(normalize(label))))) {
+                    isGenerating = true;
+                    break;
+                }
+            }
+            if (isGenerating) break;
+        }
+    }
+
+    if (!panel) {
+        return { isGenerating, sessionTitle: '', hasActiveChat: false };
+    }
+
+    const header = panel.querySelector('div[class*="border-b"]');
+    const titleEl = header?.querySelector('div[class*="text-ellipsis"]');
+    const rawTitle = titleEl ? (titleEl.textContent || '').trim() : '';
+    const hasActiveChat = rawTitle.length > 0 && rawTitle !== 'Agent';
+
+    return {
+        isGenerating,
+        sessionTitle: rawTitle || '(Untitled)',
+        hasActiveChat,
+    };
+})()`;
+const CHAT_READY_TIMEOUT_MS = 6000;
+const CHAT_READY_POLL_MS = 250;
+const INJECT_RETRY_READY_TIMEOUT_MS = 2500;
+const INJECT_RETRY_BACKOFF_MS = 500;
+const MODE_READY_TIMEOUT_MS = 4000;
+const MODE_RETRY_READY_TIMEOUT_MS = 2000;
 class CdpService extends events_1.EventEmitter {
     ports;
     isConnectedFlag = false;
@@ -64,6 +126,7 @@ class CdpService extends events_1.EventEmitter {
     idCounter = 1;
     cdpCallTimeout = 30000;
     targetUrl = null;
+    targetId = null;
     /** Number of auto-reconnect attempts on disconnect */
     maxReconnectAttempts;
     /** Delay between reconnect attempts (ms) */
@@ -78,14 +141,34 @@ class CdpService extends events_1.EventEmitter {
     currentWorkspacePath = null;
     /** Workspace switching flag (suppresses disconnected event) */
     isSwitchingWorkspace = false;
+    accountName;
+    accountPorts;
+    accountUserDataDirs;
     constructor(options = {}) {
         super();
-        this.ports = options.portsToScan || [...cdpPorts_1.CDP_PORTS];
+        this.accountName = options.accountName || 'default';
+        this.accountPorts = options.accountPorts || {};
+        this.accountUserDataDirs = options.accountUserDataDirs || {};
+        this.ports = options.portsToScan || this.resolveAccountPorts(this.accountName);
         if (options.cdpCallTimeout)
             this.cdpCallTimeout = options.cdpCallTimeout;
         this.maxReconnectAttempts = options.maxReconnectAttempts ?? 3;
         this.reconnectDelayMs = options.reconnectDelayMs ?? 2000;
     }
+    resolveAccountPorts(accountName) {
+        const explicitPort = this.accountPorts[accountName];
+        if (Number.isInteger(explicitPort) && explicitPort > 0) {
+            return [explicitPort];
+        }
+        return [...cdpPorts_1.CDP_PORTS];
+    }
+    resolveConfiguredUserDataDir(accountName) {
+        const configured = this.accountUserDataDirs[accountName];
+        if (typeof configured === 'string' && configured.trim().length > 0) {
+            return configured.trim();
+        }
+        return null;
+    }
     async getJson(url) {
         return new Promise((resolve, reject) => {
             http.get(url, (res) => {
@@ -141,6 +224,7 @@ class CdpService extends events_1.EventEmitter {
         }
         if (target && target.webSocketDebuggerUrl) {
             this.targetUrl = target.webSocketDebuggerUrl;
+            this.targetId = typeof target.id === 'string' ? target.id : null;
             // Extract workspace name from title (e.g., "ProjectName — Antigravity")
             if (target.title && !this.currentWorkspaceName) {
                 const titleParts = target.title.split(/\\s[—–-]\\s/);
@@ -266,10 +350,48 @@ class CdpService extends events_1.EventEmitter {
         }
         this.isConnectedFlag = false;
         this.contexts = [];
+        this.targetId = null;
         this.currentWorkspacePath = null;
         this.currentWorkspaceName = null;
         this.clearPendingCalls(new Error('disconnect() was called'));
     }
+    async evaluateAcrossContexts(expression, accept, options) {
+        const awaitPromise = options?.awaitPromise ?? true;
+        const contexts = this.getContexts();
+        let firstValue = null;
+        if (contexts.length === 0) {
+            const result = await this.call('Runtime.evaluate', {
+                expression,
+                returnByValue: true,
+                awaitPromise,
+            });
+            return {
+                value: (result?.result?.value ?? null),
+                contextId: null,
+            };
+        }
+        for (const ctx of contexts) {
+            try {
+                const result = await this.call('Runtime.evaluate', {
+                    expression,
+                    returnByValue: true,
+                    awaitPromise,
+                    contextId: ctx.id,
+                });
+                const value = (result?.result?.value ?? null);
+                if (!firstValue) {
+                    firstValue = { value, contextId: ctx.id };
+                }
+                if (accept(value)) {
+                    return { value, contextId: ctx.id };
+                }
+            }
+            catch {
+                // Try the next context.
+            }
+        }
+        return firstValue ?? { value: null, contextId: null };
+    }
     /**
      * Return the currently connected workspace name.
      */
@@ -302,6 +424,19 @@ class CdpService extends events_1.EventEmitter {
             this.isSwitchingWorkspace = false;
         }
     }
+    async openWorkspace(workspacePath) {
+        const projectName = (0, pathUtils_1.extractProjectNameFromPath)(workspacePath);
+        this.currentWorkspacePath = workspacePath;
+        try {
+            return await this.discoverAndConnectForWorkspace(workspacePath);
+        }
+        catch (error) {
+            logger_1.logger.info(`[CdpService] Explicit open requested for workspace "${projectName}" ` +
+                `on account "${this.accountName}" — retrying with launch ` +
+                `(reason: ${error?.message || String(error)})`);
+            return this.launchAndConnectWorkspace(workspacePath, projectName, true);
+        }
+    }
     /**
      * Verify whether the currently attached page still represents the expected workspace.
      */
@@ -386,6 +521,7 @@ class CdpService extends events_1.EventEmitter {
         }
         this.disconnectQuietly();
         this.targetUrl = page.webSocketDebuggerUrl;
+        this.targetId = typeof page.id === 'string' ? page.id : null;
         await this.connect();
         this.currentWorkspaceName = projectName;
         logger_1.logger.debug(`[CdpService] Connected to workspace "${projectName}"`);
@@ -407,6 +543,7 @@ class CdpService extends events_1.EventEmitter {
                 // Temporarily connect to retrieve document.title
                 this.disconnectQuietly();
                 this.targetUrl = page.webSocketDebuggerUrl;
+                this.targetId = typeof page.id === 'string' ? page.id : null;
                 await this.connect();
                 const result = await this.call('Runtime.evaluate', {
                     expression: 'document.title',
@@ -511,20 +648,53 @@ class CdpService extends events_1.EventEmitter {
     /**
      * Launch Antigravity and wait for a new workbench page to appear, then connect.
      */
-    async launchAndConnectWorkspace(workspacePath, projectName) {
+    async launchAndConnectWorkspace(workspacePath, projectName, explicitOpen = false) {
+        const targetPort = this.ports[0] ?? null;
+        const configuredUserDataDir = this.resolveConfiguredUserDataDir(this.accountName);
+        const resolvedUserDataDir = explicitOpen && targetPort !== null
+            ? (configuredUserDataDir ?? await this.resolveRunningUserDataDirForPort(targetPort))
+            : null;
+        if (explicitOpen && this.accountName !== 'default' && targetPort !== null && !resolvedUserDataDir) {
+            throw new Error(`Could not determine user-data-dir for running account "${this.accountName}" ` +
+                `(CDP port ${targetPort}). Make sure that Antigravity instance is already running with that port.`);
+        }
+        if (!explicitOpen && this.accountName !== 'default' && targetPort !== null) {
+            logger_1.logger.warn(`[CdpService] Workspace "${projectName}" not found on account "${this.accountName}" ` +
+                `(port=${targetPort}). Skipping auto-launch to avoid opening the wrong Antigravity instance.`);
+            throw new Error(`Workspace "${projectName}" is not open in account "${this.accountName}" ` +
+                `(CDP port ${targetPort}). Open it with Antigravity Cockpit or use "/project reopen" ` +
+                `command (Telegram: /project_reopen).`);
+        }
         // Open as folder using Antigravity CLI (not as workspace mode).
         // `open -a Antigravity` may open as workspace, resulting in title "Untitled (Workspace)".
         // CLI --new-window opens as folder, immediately reflecting directory name in title.
         const antigravityCli = (0, pathUtils_1.getAntigravityCliPath)();
-        logger_1.logger.debug(`[CdpService] Launching Antigravity: ${antigravityCli} --new-window ${workspacePath}`);
+        const launchArgs = [
+            ...(resolvedUserDataDir ? ['--user-data-dir', resolvedUserDataDir] : []),
+            ...(targetPort !== null ? [`--remote-debugging-port=${targetPort}`] : []),
+            '--new-window',
+            workspacePath,
+        ];
+        logger_1.logger.debug(`[CdpService] Launching Antigravity for account "${this.accountName}" ` +
+            `(port=${targetPort ?? 'unknown'}, userDataDir=${resolvedUserDataDir ?? 'default'}) ` +
+            `${antigravityCli} ${launchArgs.join(' ')}`);
         try {
-            await this.runCommand(antigravityCli, ['--new-window', workspacePath]);
+            await this.runCommand(antigravityCli, launchArgs);
         }
         catch (error) {
             // Fall back to open -a if CLI not found (macOS only)
             logger_1.logger.warn(`[CdpService] CLI launch failed, falling back to open -a (if macOS): ${error?.message || String(error)}`);
             if (process.platform === 'darwin') {
-                await this.runCommand('open', ['-a', 'Antigravity', workspacePath]);
+                const openArgs = [
+                    '-n',
+                    '-a',
+                    'Antigravity',
+                    '--args',
+                    ...(resolvedUserDataDir ? ['--user-data-dir', resolvedUserDataDir] : []),
+                    ...(targetPort !== null ? [`--remote-debugging-port=${targetPort}`] : []),
+                    workspacePath,
+                ];
+                await this.runCommand('open', openArgs);
             }
             else {
                 throw error;
@@ -693,6 +863,62 @@ class CdpService extends events_1.EventEmitter {
             });
         });
     }
+    async resolveRunningUserDataDirForPort(port) {
+        const commandLines = await this.getProcessCommandLines();
+        if (commandLines.length === 0)
+            return null;
+        const portPattern = new RegExp(`--remote-debugging-port(?:=|\\s+)${port}(?:\\s|$)`);
+        for (const line of commandLines) {
+            const lowerLine = line.toLowerCase();
+            if (!lowerLine.includes('antigravity') || !portPattern.test(line) || !line.includes('--user-data-dir')) {
+                continue;
+            }
+            const match = line.match(/--user-data-dir(?:=|\s+)("([^"]+)"|'([^']+)'|([^\s]+))/);
+            const userDataDir = match?.[2] || match?.[3] || match?.[4];
+            if (userDataDir) {
+                logger_1.logger.info(`[CdpService] Resolved user-data-dir for CDP port ${port}: ${userDataDir}`);
+                return userDataDir;
+            }
+        }
+        return null;
+    }
+    async getProcessCommandLines() {
+        const run = (command, args) => new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)(command, args, { windowsHide: true, maxBuffer: 20 * 1024 * 1024 }, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(stdout);
+            });
+        });
+        const parseLines = (output) => output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0);
+        try {
+            if (process.platform === 'win32') {
+                try {
+                    const psOutput = await run('powershell.exe', [
+                        '-NoProfile',
+                        '-Command',
+                        'Get-CimInstance Win32_Process | Select-Object -ExpandProperty CommandLine | Where-Object { $_ }',
+                    ]);
+                    return parseLines(psOutput);
+                }
+                catch {
+                    const wmicOutput = await run('wmic', ['process', 'get', 'CommandLine']);
+                    return parseLines(wmicOutput).filter((line) => line !== 'CommandLine');
+                }
+            }
+            const psOutput = await run('ps', ['-axo', 'command=']);
+            return parseLines(psOutput);
+        }
+        catch (error) {
+            logger_1.logger.warn(`[CdpService] Failed to inspect Antigravity processes: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    }
     /**
      * Quietly disconnect the existing connection (no reconnect attempts).
      * Used during workspace switching.
@@ -711,6 +937,81 @@ class CdpService extends events_1.EventEmitter {
             this.contexts = [];
             this.clearPendingCalls(new Error('Disconnected for workspace switch'));
             this.targetUrl = null;
+            this.targetId = null;
+        }
+    }
+    async closeCurrentTarget() {
+        if (!this.targetId) {
+            return false;
+        }
+        try {
+            await this.call('Target.closeTarget', { targetId: this.targetId });
+            return true;
+        }
+        finally {
+            await this.disconnect();
+        }
+    }
+    async inspectWorkspaceRuntimeState() {
+        const result = await this.evaluateAcrossContexts(WORKSPACE_STATE_SCRIPT, (value) => !!(value && typeof value === 'object' && value.hasActiveChat));
+        const value = result.value;
+        return {
+            isGenerating: !!(value && typeof value === 'object' && value.isGenerating),
+            sessionTitle: value && typeof value === 'object' && typeof value.sessionTitle === 'string'
+                ? value.sessionTitle
+                : '(Untitled)',
+            hasActiveChat: !!(value && typeof value === 'object' && value.hasActiveChat),
+            contextId: result.contextId,
+        };
+    }
+    async closeCurrentTargetGracefully(timeoutMs = 5000) {
+        if (!this.targetId) {
+            return false;
+        }
+        const closingTargetId = this.targetId;
+        try {
+            await this.call('Page.bringToFront', {}).catch(() => { });
+            const modifiers = process.platform === 'darwin' ? 4 : 2;
+            await this.call('Input.dispatchKeyEvent', {
+                type: 'keyDown',
+                key: 'w',
+                code: 'KeyW',
+                modifiers,
+                windowsVirtualKeyCode: 87,
+                nativeVirtualKeyCode: 87,
+            });
+            await this.call('Input.dispatchKeyEvent', {
+                type: 'keyUp',
+                key: 'w',
+                code: 'KeyW',
+                modifiers,
+                windowsVirtualKeyCode: 87,
+                nativeVirtualKeyCode: 87,
+            });
+            const deadline = Date.now() + timeoutMs;
+            while (Date.now() <= deadline) {
+                let stillOpen = false;
+                for (const port of this.ports) {
+                    try {
+                        const list = await this.getJson(`http://127.0.0.1:${port}/json/list`);
+                        if (list.some((page) => page?.id === closingTargetId)) {
+                            stillOpen = true;
+                            break;
+                        }
+                    }
+                    catch {
+                        // Ignore port failures while polling close state.
+                    }
+                }
+                if (!stillOpen) {
+                    return true;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            }
+            return false;
+        }
+        finally {
+            await this.disconnect();
         }
     }
     /**
@@ -896,6 +1197,112 @@ class CdpService extends events_1.EventEmitter {
         }
         return { ok: false, error: 'Chat input field not found' };
     }
+    async waitForChatInputReady(timeoutMs = CHAT_READY_TIMEOUT_MS) {
+        const deadline = Date.now() + timeoutMs;
+        let lastError = 'Chat input field not found';
+        while (Date.now() < deadline) {
+            const focusResult = await this.focusChatInput();
+            if (focusResult.ok) {
+                return focusResult;
+            }
+            lastError = focusResult.error || lastError;
+            await new Promise((r) => setTimeout(r, CHAT_READY_POLL_MS));
+        }
+        return { ok: false, error: lastError };
+    }
+    isTransientInjectError(error) {
+        const message = String(error || '');
+        return [
+            'No editor found',
+            'Chat input field not found',
+            'WebSocket is not connected',
+            'WebSocket disconnected',
+        ].some((fragment) => message.includes(fragment));
+    }
+    async isModeToggleReady() {
+        const expression = '(() => {'
+            + ' const uiNameMap = { fast: "Fast", plan: "Planning" };'
+            + ' const knownModes = Object.values(uiNameMap).map(n => n.toLowerCase());'
+            + ' const allBtns = Array.from(document.querySelectorAll("button"));'
+            + ' const visibleBtns = allBtns.filter(b => b.offsetParent !== null);'
+            + ' const modeToggleBtn = visibleBtns.find(b => {'
+            + '   const text = (b.textContent || "").trim().toLowerCase();'
+            + '   const hasChevron = b.querySelector("svg[class*=\\"chevron\\"]");'
+            + '   return knownModes.some(m => text === m) && hasChevron;'
+            + ' });'
+            + ' return !!modeToggleBtn;'
+            + '})()';
+        try {
+            const contextId = this.getPrimaryContextId();
+            const callParams = {
+                expression,
+                returnByValue: true,
+                awaitPromise: false,
+            };
+            if (contextId !== null)
+                callParams.contextId = contextId;
+            const res = await this.call('Runtime.evaluate', callParams);
+            return Boolean(res?.result?.value);
+        }
+        catch {
+            return false;
+        }
+    }
+    async waitForModeToggleReady(timeoutMs = MODE_READY_TIMEOUT_MS) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (await this.isModeToggleReady()) {
+                return true;
+            }
+            await new Promise((r) => setTimeout(r, CHAT_READY_POLL_MS));
+        }
+        return false;
+    }
+    isTransientModeError(error) {
+        const message = String(error || '');
+        return [
+            'Mode toggle button not found',
+            'WebSocket is not connected',
+            'WebSocket disconnected',
+        ].some((fragment) => message.includes(fragment));
+    }
+    async injectMessageCore(text, imageFilePaths) {
+        const focusResult = await this.waitForChatInputReady();
+        if (!focusResult.ok) {
+            return { ok: false, error: focusResult.error || 'Chat input field not found' };
+        }
+        // Clear any existing text in the input field before injecting.
+        await this.clearInputField();
+        if (imageFilePaths && imageFilePaths.length > 0) {
+            const attachResult = await this.attachImageFiles(imageFilePaths, focusResult.contextId);
+            if (!attachResult.ok) {
+                return { ok: false, error: attachResult.error || 'Failed to attach images' };
+            }
+        }
+        await this.call('Input.insertText', { text });
+        await new Promise(r => setTimeout(r, 200));
+        await this.pressEnterToSend();
+        return {
+            ok: true,
+            method: 'enter',
+            contextId: focusResult.contextId,
+        };
+    }
+    async retryInjectOnce(text, firstError, imageFilePaths) {
+        logger_1.logger.warn(`[CdpService] Initial message injection failed: ${firstError}. Retrying once after readiness check...`);
+        try {
+            await this.reconnectOnDemand(INJECT_RETRY_READY_TIMEOUT_MS);
+        }
+        catch {
+            // Ignore reconnect failures here; readiness check below will produce the final error.
+        }
+        await new Promise((r) => setTimeout(r, INJECT_RETRY_BACKOFF_MS));
+        const ready = await this.waitForChatInputReady(INJECT_RETRY_READY_TIMEOUT_MS);
+        if (!ready.ok) {
+            return { ok: false, error: ready.error || firstError };
+        }
+        return this.injectMessageCore(text, imageFilePaths);
+    }
     /**
      * Select all text in the focused input and delete it to ensure a clean state.
      * Uses Meta+A (select all) then Backspace (delete) via CDP key events.
@@ -1080,18 +1487,11 @@ class CdpService extends events_1.EventEmitter {
         if (!this.isConnectedFlag || !this.ws) {
             throw new Error('Not connected to CDP. Call connect() first.');
         }
-        const focusResult = await this.focusChatInput();
-        if (!focusResult.ok) {
-            return { ok: false, error: focusResult.error || 'Chat input field not found' };
+        const result = await this.injectMessageCore(text);
+        if (result.ok || !this.isTransientInjectError(result.error)) {
+            return result;
         }
-        // Clear any existing text in the input field before injecting
-        await this.clearInputField();
-        // 1. Input text via CDP Input.insertText
-        await this.call('Input.insertText', { text });
-        await new Promise(r => setTimeout(r, 200));
-        // 2. Send via Enter key
-        await this.pressEnterToSend();
-        return { ok: true, method: 'enter', contextId: focusResult.contextId };
+        return this.retryInjectOnce(text, result.error || 'Message injection failed');
     }
     /**
      * Attach image files to the UI and send the specified text.
@@ -1100,20 +1500,11 @@ class CdpService extends events_1.EventEmitter {
         if (!this.isConnectedFlag || !this.ws) {
             throw new Error('Not connected to CDP. Call connect() first.');
         }
-        const focusResult = await this.focusChatInput();
-        if (!focusResult.ok) {
-            return { ok: false, error: focusResult.error || 'Chat input field not found' };
-        }
-        // Clear any existing text in the input field before injecting
-        await this.clearInputField();
-        const attachResult = await this.attachImageFiles(imageFilePaths, focusResult.contextId);
-        if (!attachResult.ok) {
-            return { ok: false, error: attachResult.error || 'Failed to attach images' };
+        const result = await this.injectMessageCore(text, imageFilePaths);
+        if (result.ok || !this.isTransientInjectError(result.error)) {
+            return result;
         }
-        await this.call('Input.insertText', { text });
-        await new Promise(r => setTimeout(r, 200));
-        await this.pressEnterToSend();
-        return { ok: true, method: 'enter', contextId: focusResult.contextId };
+        return this.retryInjectOnce(text, result.error || 'Image message injection failed', imageFilePaths);
     }
     /**
      * Extract images from the latest AI response.
@@ -1351,6 +1742,7 @@ class CdpService extends events_1.EventEmitter {
         if (!this.isConnectedFlag || !this.ws) {
             await this.reconnectOnDemand();
         }
+        await this.waitForModeToggleReady();
         const safeMode = JSON.stringify(modeName);
         // Internal mode name -> Antigravity UI display name mapping
         const uiNameMap = JSON.stringify({ fast: 'Fast', plan: 'Planning' });
@@ -1443,7 +1835,24 @@ class CdpService extends events_1.EventEmitter {
             if (value?.ok) {
                 return { ok: true, mode: value.mode };
             }
-            return { ok: false, error: value?.error || 'UI operation failed (setUiMode)' };
+            const errorMessage = value?.error || 'UI operation failed (setUiMode)';
+            if (!this.isTransientModeError(errorMessage)) {
+                return { ok: false, error: errorMessage };
+            }
+            logger_1.logger.warn(`[CdpService] setUiMode initial attempt failed: ${errorMessage}. Retrying once after readiness check...`);
+            try {
+                await this.reconnectOnDemand(MODE_RETRY_READY_TIMEOUT_MS);
+            }
+            catch {
+                // Fall through to the readiness wait and retry below.
+            }
+            await this.waitForModeToggleReady(MODE_RETRY_READY_TIMEOUT_MS);
+            const retryRes = await this.call('Runtime.evaluate', callParams);
+            const retryValue = retryRes?.result?.value;
+            if (retryValue?.ok) {
+                return { ok: true, mode: retryValue.mode };
+            }
+            return { ok: false, error: retryValue?.error || errorMessage };
         }
         catch (error) {
             return { ok: false, error: error?.message || String(error) };
@@ -1457,26 +1866,152 @@ class CdpService extends events_1.EventEmitter {
             throw new Error('Not connected to CDP.');
         }
         const expression = `(async () => {
-            return Array.from(document.querySelectorAll('div.cursor-pointer'))
-                .map(e => ({text: (e.textContent || '').trim().replace(/New$/, ''), class: e.className}))
-                .filter(e => e.class.includes('px-2 py-1 flex items-center justify-between') || e.text.includes('Gemini') || e.text.includes('GPT') || e.text.includes('Claude'))
-                .map(e => e.text);
+            const normalize = (text) => (text || '').trim().replace(/New$/, '').trim();
+            const isBlockedModelLabel = (text) => /assist|open in terminal|terminal|code change|claude code|\\bchange\\b/i.test(text || '');
+            const looksLikeModel = (text) => {
+                const normalized = normalize(text).toLowerCase();
+                if (!normalized || isBlockedModelLabel(normalized)) return false;
+                return /gemini\\s*\\d|gpt(?:[-\\s]?\\d|[-\\s]?oss)|claude\\s+(?:opus|sonnet|haiku)|(?:opus|sonnet|haiku)\\s*\\d/i.test(normalized);
+            };
+            const isVisible = (el) => {
+                if (!(el instanceof HTMLElement)) return false;
+                const style = window.getComputedStyle(el);
+                const rect = el.getBoundingClientRect();
+                return style.visibility !== 'hidden'
+                    && style.display !== 'none'
+                    && rect.width > 0
+                    && rect.height > 0;
+            };
+            const getLabel = (el) => {
+                if (!(el instanceof HTMLElement)) return '';
+                const parts = [
+                    el.textContent || '',
+                    el.getAttribute('aria-label') || '',
+                    el.getAttribute('title') || '',
+                    el.getAttribute('data-value') || '',
+                ];
+                return normalize(parts.find((part) => normalize(part).length > 0) || '');
+            };
+            const scopeSelectors = [
+                '[role="dialog"]',
+                '[role="listbox"]',
+                '[role="menu"]',
+                '[data-radix-popper-content-wrapper]',
+                '[data-slot*="popover"]',
+                '[data-state="open"]',
+                '[class*="popover"]',
+                '[class*="dropdown"]',
+                '[class*="menu"]',
+            ];
+            const itemSelectors = [
+                '[role="option"]',
+                '[role="menuitem"]',
+                '[aria-selected]',
+                '[aria-checked]',
+                'button',
+                '[role="button"]',
+                'div.cursor-pointer',
+                'div[class*="cursor-pointer"]',
+            ];
+            const getScopes = () => {
+                const scopes = [document];
+                for (const el of document.querySelectorAll(scopeSelectors.join(','))) {
+                    if (isVisible(el)) scopes.push(el);
+                }
+                return Array.from(new Set(scopes));
+            };
+            const hasOpenPicker = () => getScopes().some((scope) => scope !== document);
+            const closePicker = async () => {
+                const active = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+                if (active) active.blur();
+                document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true }));
+                document.dispatchEvent(new KeyboardEvent('keyup', { key: 'Escape', bubbles: true, cancelable: true }));
+                document.body?.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));
+                document.body?.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true }));
+                document.body?.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+                await new Promise((resolve) => setTimeout(resolve, 80));
+            };
+            const collectModels = () => {
+                const seen = new Set();
+                const labels = [];
+                for (const scope of getScopes()) {
+                    for (const el of scope.querySelectorAll(itemSelectors.join(','))) {
+                        if (!isVisible(el)) continue;
+                        const label = getLabel(el);
+                        if (!looksLikeModel(label)) continue;
+                        const key = label.toLowerCase();
+                        if (seen.has(key)) continue;
+                        seen.add(key);
+                        labels.push(label);
+                    }
+                }
+                return labels;
+            };
+            const triggerSelectors = [
+                '[role="combobox"]',
+                '[aria-haspopup="listbox"]',
+                '[aria-haspopup="menu"]',
+                '[aria-expanded]',
+                'button',
+                '[role="button"]',
+                'div.cursor-pointer',
+                'div[class*="cursor-pointer"]',
+            ];
+
+            let models = collectModels();
+            if (models.length > 1) {
+                if (hasOpenPicker()) await closePicker();
+                return models;
+            }
+
+            const triggers = Array.from(document.querySelectorAll(triggerSelectors.join(',')))
+                .filter(isVisible)
+                .filter((el) => {
+                    const label = getLabel(el);
+                    const attrs = normalize([
+                        el.getAttribute('aria-label') || '',
+                        el.getAttribute('title') || '',
+                        el.getAttribute('aria-haspopup') || '',
+                        el.className || '',
+                    ].join(' '));
+                    return looksLikeModel(label) || /model|listbox|combobox|popover|dropdown/.test(attrs);
+                });
+
+            for (const trigger of triggers) {
+                trigger.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+                await new Promise((resolve) => setTimeout(resolve, 300));
+                models = collectModels();
+                if (models.length > 1) {
+                    if (hasOpenPicker()) await closePicker();
+                    return models;
+                }
+            }
+
+            if (hasOpenPicker()) await closePicker();
+            return models;
         })()`;
         try {
-            const contextId = this.getPrimaryContextId();
-            const callParams = {
-                expression,
-                returnByValue: true,
-                awaitPromise: true,
-            };
-            if (contextId !== null)
-                callParams.contextId = contextId;
-            const res = await this.call('Runtime.evaluate', callParams);
-            const value = res?.result?.value;
-            if (Array.isArray(value) && value.length > 0) {
-                // remove duplicates
-                return Array.from(new Set(value));
+            const contexts = this.getContexts();
+            const contextIds = [
+                this.getPrimaryContextId(),
+                ...contexts.map((ctx) => ctx.id),
+            ].filter((value, index, arr) => typeof value === 'number' && arr.indexOf(value) === index);
+            const targets = contextIds.length > 0 ? contextIds : [null];
+            for (const contextId of targets) {
+                const params = {
+                    expression,
+                    returnByValue: true,
+                    awaitPromise: true,
+                };
+                if (typeof contextId === 'number')
+                    params.contextId = contextId;
+                const res = await this.call('Runtime.evaluate', params);
+                const value = res?.result?.value;
+                if (Array.isArray(value) && value.length > 0) {
+                    return Array.from(new Set(value));
+                }
             }
+            logger_1.logger.warn('[CdpService] getUiModels returned no models from any execution context.');
             return [];
         }
         catch (error) {
@@ -1492,17 +2027,81 @@ class CdpService extends events_1.EventEmitter {
             return null;
         }
         const expression = `(() => {
-            return Array.from(document.querySelectorAll('div.cursor-pointer'))
-                .find(e => e.className.includes('px-2 py-1 flex items-center justify-between') && e.className.includes('bg-gray-500/20'))
-                ?.textContent?.trim().replace(/New$/, '') || null;
+            const normalize = (text) => (text || '').trim().replace(/New$/, '').trim();
+            const isBlockedModelLabel = (text) => /assist|open in terminal|terminal|code change|claude code|\\bchange\\b/i.test(text || '');
+            const looksLikeModel = (text) => {
+                const normalized = normalize(text).toLowerCase();
+                if (!normalized || isBlockedModelLabel(normalized)) return false;
+                return /gemini\\s*\\d|gpt(?:[-\\s]?\\d|[-\\s]?oss)|claude\\s+(?:opus|sonnet|haiku)|(?:opus|sonnet|haiku)\\s*\\d/i.test(normalized);
+            };
+            const isVisible = (el) => {
+                if (!(el instanceof HTMLElement)) return false;
+                const style = window.getComputedStyle(el);
+                const rect = el.getBoundingClientRect();
+                return style.visibility !== 'hidden'
+                    && style.display !== 'none'
+                    && rect.width > 0
+                    && rect.height > 0;
+            };
+            const getLabel = (el) => {
+                if (!(el instanceof HTMLElement)) return '';
+                const parts = [
+                    el.textContent || '',
+                    el.getAttribute('aria-label') || '',
+                    el.getAttribute('title') || '',
+                    el.getAttribute('data-value') || '',
+                ];
+                return normalize(parts.find((part) => normalize(part).length > 0) || '');
+            };
+            const getScore = (el) => {
+                if (!(el instanceof HTMLElement)) return 0;
+                let score = 0;
+                if (el.getAttribute('aria-selected') === 'true') score += 5;
+                if (el.getAttribute('aria-checked') === 'true') score += 5;
+                if (el.getAttribute('aria-current') === 'true') score += 4;
+                const dataState = normalize(el.getAttribute('data-state') || '');
+                if (/(checked|active|selected|on|open)/.test(dataState)) score += 4;
+                const classes = normalize(el.className || '');
+                if (classes.includes('bg-gray-500/20')) score += 3;
+                if (classes.includes('selected')) score += 3;
+                if (classes.includes('active')) score += 2;
+                if (el.getAttribute('aria-expanded') === 'true') score += 1;
+                return score;
+            };
+            const candidates = Array.from(document.querySelectorAll(
+                '[role="option"], [role="menuitem"], [role="combobox"], [aria-selected], [aria-checked], ' +
+                '[aria-current], button, [role="button"], div.cursor-pointer, div[class*="cursor-pointer"]'
+            ))
+                .filter(isVisible)
+                .map((el) => ({ el, label: getLabel(el), score: getScore(el) }))
+                .filter((entry) => looksLikeModel(entry.label))
+                .sort((a, b) => b.score - a.score || a.label.length - b.label.length);
+            if (candidates.length === 0) return null;
+            if (candidates[0].score > 0) return candidates[0].label;
+            return candidates[0].label;
         })()`;
         try {
-            const contextId = this.getPrimaryContextId();
-            const res = await this.call('Runtime.evaluate', {
-                expression, returnByValue: true, awaitPromise: true,
-                contextId: contextId || undefined
-            });
-            return res?.result?.value || null;
+            const contexts = this.getContexts();
+            const contextIds = [
+                this.getPrimaryContextId(),
+                ...contexts.map((ctx) => ctx.id),
+            ].filter((value, index, arr) => typeof value === 'number' && arr.indexOf(value) === index);
+            const targets = contextIds.length > 0 ? contextIds : [null];
+            for (const contextId of targets) {
+                const params = {
+                    expression,
+                    returnByValue: true,
+                    awaitPromise: true,
+                };
+                if (typeof contextId === 'number')
+                    params.contextId = contextId;
+                const res = await this.call('Runtime.evaluate', params);
+                const value = res?.result?.value;
+                if (typeof value === 'string' && value.trim().length > 0) {
+                    return value;
+                }
+            }
+            return null;
         }
         catch (e) {
             return null;
@@ -1515,6 +2114,7 @@ class CdpService extends events_1.EventEmitter {
      * @param modelName Model name to set (e.g., 'gpt-4o', 'claude-3-opus')
      */
     async setUiModel(modelName) {
+        logger_1.logger.info(`[CdpService] setUiModel requested account=${this.accountName} target="${modelName}" connected=${this.isConnectedFlag}`);
         if (!this.isConnectedFlag || !this.ws) {
             await this.reconnectOnDemand();
         }
@@ -1525,68 +2125,325 @@ class CdpService extends events_1.EventEmitter {
         const safeModel = JSON.stringify(modelName);
         const expression = `(async () => {
             const targetModel = ${safeModel};
-            
-            // Get all items in the model list
-            const modelItems = Array.from(document.querySelectorAll('div.cursor-pointer'))
-                .filter(e => e.className.includes('px-2 py-1 flex items-center justify-between'));
-            
-            if (modelItems.length === 0) {
-                return { ok: false, error: 'Model list not found. The dropdown may not be open.' };
-            }
-            
-            // Match target model by name (compare after removing New suffix)
-            const targetItem = modelItems.find(el => {
-                const text = (el.textContent || '').trim().replace(/New$/, '').trim();
-                return text === targetModel || text.toLowerCase() === targetModel.toLowerCase();
+            const normalize = (text) => (text || '').trim().replace(/New$/, '').trim();
+            const isBlockedModelLabel = (text) => /assist|open in terminal|terminal|code change|claude code|\\bchange\\b/i.test(text || '');
+            const looksLikeModel = (text) => {
+                const normalized = normalize(text).toLowerCase();
+                if (!normalized || isBlockedModelLabel(normalized)) return false;
+                return /gemini\\s*\\d|gpt(?:[-\\s]?\\d|[-\\s]?oss)|claude\\s+(?:opus|sonnet|haiku)|(?:opus|sonnet|haiku)\\s*\\d/i.test(normalized);
+            };
+            const isVisible = (el) => {
+                if (!(el instanceof HTMLElement)) return false;
+                const style = window.getComputedStyle(el);
+                const rect = el.getBoundingClientRect();
+                return style.visibility !== 'hidden'
+                    && style.display !== 'none'
+                    && rect.width > 0
+                    && rect.height > 0;
+            };
+            const getLabel = (el) => {
+                if (!(el instanceof HTMLElement)) return '';
+                const parts = [
+                    el.textContent || '',
+                    el.getAttribute('aria-label') || '',
+                    el.getAttribute('title') || '',
+                    el.getAttribute('data-value') || '',
+                ];
+                return normalize(parts.find((part) => normalize(part).length > 0) || '');
+            };
+            const itemSelectors = [
+                '[role="option"]',
+                '[role="menuitem"]',
+                '[aria-selected]',
+                '[aria-checked]',
+                'button',
+                '[role="button"]',
+                'div.cursor-pointer',
+                'div[class*="cursor-pointer"]',
+            ];
+            const triggerSelectors = [
+                '[role="combobox"]',
+                '[aria-haspopup="listbox"]',
+                '[aria-haspopup="menu"]',
+                '[aria-expanded]',
+                'button',
+                '[role="button"]',
+                'div.cursor-pointer',
+                'div[class*="cursor-pointer"]',
+            ];
+            const scopeSelectors = [
+                '[role="dialog"]',
+                '[role="listbox"]',
+                '[role="menu"]',
+                '[data-radix-popper-content-wrapper]',
+                '[data-slot*="popover"]',
+                '[data-state="open"]',
+                '[class*="popover"]',
+                '[class*="dropdown"]',
+                '[class*="menu"]',
+            ];
+            const getScopes = () => {
+                const scopes = [document];
+                for (const el of document.querySelectorAll(scopeSelectors.join(','))) {
+                    if (isVisible(el)) scopes.push(el);
+                }
+                return Array.from(new Set(scopes));
+            };
+            const getOpenPickerScopes = () => getScopes().filter((scope) => scope !== document);
+            const hasOpenPicker = () => getOpenPickerScopes().length > 0;
+            const isSelected = (el) => {
+                if (!(el instanceof HTMLElement)) return false;
+                const classes = normalize(el.className || '');
+                const state = normalize(el.getAttribute('data-state') || '');
+                return el.getAttribute('aria-selected') === 'true'
+                    || el.getAttribute('aria-checked') === 'true'
+                    || el.getAttribute('aria-current') === 'true'
+                    || /(checked|active|selected|on)/.test(state)
+                    || classes.includes('bg-gray-500/20')
+                    || classes.includes('selected')
+                    || classes.includes('active');
+            };
+            const isModelTrigger = (el) => {
+                if (!(el instanceof HTMLElement) || !isVisible(el)) return false;
+                const label = getLabel(el);
+                const attrs = normalize([
+                    el.getAttribute('aria-label') || '',
+                    el.getAttribute('title') || '',
+                    el.getAttribute('aria-haspopup') || '',
+                    el.getAttribute('role') || '',
+                    el.getAttribute('data-state') || '',
+                    el.className || '',
+                ].join(' '));
+                return looksLikeModel(label)
+                    || /select model|current:|model|listbox|combobox|dropdown|popover|dialog/.test(attrs);
+            };
+            const collectModelItems = ({ includeClosedTrigger = false } = {}) => {
+                const items = [];
+                const seen = new Set();
+                const openScopes = getOpenPickerScopes();
+                const scopes = openScopes.length > 0
+                    ? openScopes
+                    : includeClosedTrigger
+                        ? [document]
+                        : [];
+                for (const scope of scopes) {
+                    for (const el of scope.querySelectorAll(itemSelectors.join(','))) {
+                        if (!isVisible(el)) continue;
+                        if (scope === document && isModelTrigger(el)) continue;
+                        const label = getLabel(el);
+                        if (!looksLikeModel(label)) continue;
+                        const key = label.toLowerCase() + '::' + normalize((el.getAttribute('role') || '') + ' ' + (el.className || ''));
+                        if (seen.has(key)) continue;
+                        seen.add(key);
+                        items.push({ el, label });
+                    }
+                }
+                return items;
+            };
+            const summarizeElement = (el) => {
+                if (!(el instanceof HTMLElement)) return null;
+                return {
+                    label: getLabel(el),
+                    role: el.getAttribute('role') || '',
+                    ariaLabel: el.getAttribute('aria-label') || '',
+                    title: el.getAttribute('title') || '',
+                    ariaExpanded: el.getAttribute('aria-expanded') || '',
+                    ariaHaspopup: el.getAttribute('aria-haspopup') || '',
+                    ariaSelected: el.getAttribute('aria-selected') || '',
+                    dataState: el.getAttribute('data-state') || '',
+                    className: String(el.className || '').slice(0, 120),
+                };
+            };
+            const diagnostics = () => {
+                const triggers = Array.from(document.querySelectorAll(triggerSelectors.join(',')))
+                    .filter(isVisible)
+                    .map((el) => summarizeElement(el))
+                    .filter((entry) => entry && (looksLikeModel(entry.label) || /select model|current:|model|listbox|combobox|dropdown|popover|dialog/.test(normalize(entry.className + ' ' + entry.ariaLabel + ' ' + entry.title + ' ' + entry.ariaHaspopup))))
+                    .slice(0, 8);
+                const items = collectModelItems({ includeClosedTrigger: true })
+                    .map(({ el }) => summarizeElement(el))
+                    .filter(Boolean)
+                    .slice(0, 12);
+                return JSON.stringify({ triggers, items, openPicker: hasOpenPicker() });
+            };
+            const getCurrentModelLabel = () => {
+                const selectedItem = collectModelItems({ includeClosedTrigger: true }).find(({ el }) => isSelected(el));
+                if (selectedItem) return selectedItem.label;
+                const trigger = Array.from(document.querySelectorAll(triggerSelectors.join(',')))
+                    .filter(isVisible)
+                    .map((el) => ({ el, label: getLabel(el) }))
+                    .find((entry) => isModelTrigger(entry.el) && looksLikeModel(entry.label));
+                return trigger ? trigger.label : null;
+            };
+            const triggerScore = (el) => {
+                if (!(el instanceof HTMLElement)) return -1;
+                const label = getLabel(el);
+                const ariaLabel = normalize(el.getAttribute('aria-label') || '');
+                const title = normalize(el.getAttribute('title') || '');
+                const role = normalize(el.getAttribute('role') || '');
+                const ariaHaspopup = normalize(el.getAttribute('aria-haspopup') || '');
+                const ariaExpanded = normalize(el.getAttribute('aria-expanded') || '');
+                const classes = normalize(el.className || '');
+                let score = 0;
+                if (/select model|current:/.test(ariaLabel)) score += 10;
+                if (ariaHaspopup === 'dialog') score += 8;
+                if (ariaHaspopup === 'listbox' || ariaHaspopup === 'menu') score += 7;
+                if (role === 'combobox') score += 6;
+                if (ariaExpanded === 'false' || ariaExpanded === 'true') score += 4;
+                if (looksLikeModel(label)) score += 3;
+                if (/model|popover|dropdown/.test(title + ' ' + classes)) score += 2;
+                return score;
+            };
+            const activateTrigger = async (trigger) => {
+                if (!(trigger instanceof HTMLElement)) return false;
+                const tryClick = () => {
+                    trigger.focus?.();
+                    trigger.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true, cancelable: true, pointerType: 'mouse' }));
+                    trigger.dispatchEvent(new MouseEvent('mousedown', { bubbles: true, cancelable: true }));
+                    trigger.dispatchEvent(new PointerEvent('pointerup', { bubbles: true, cancelable: true, pointerType: 'mouse' }));
+                    trigger.dispatchEvent(new MouseEvent('mouseup', { bubbles: true, cancelable: true }));
+                    trigger.click?.();
+                    trigger.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+                };
+                tryClick();
+                for (const delay of [250, 450, 700]) {
+                    await new Promise((r) => setTimeout(r, delay));
+                    if (hasOpenPicker()) return true;
+                }
+                if (trigger.parentElement instanceof HTMLElement) {
+                    try {
+                        const rect = trigger.getBoundingClientRect();
+                        const parentRect = trigger.parentElement.getBoundingClientRect();
+                        if (parentRect.width > rect.width && parentRect.height >= rect.height) {
+                            trigger.parentElement.click?.();
+                            trigger.parentElement.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+                        }
+                    } catch {}
+                    for (const delay of [250, 450]) {
+                        await new Promise((r) => setTimeout(r, delay));
+                        if (hasOpenPicker()) return true;
+                    }
+                }
+                return hasOpenPicker();
+            };
+            const clickPossibleTrigger = async () => {
+                const triggers = Array.from(document.querySelectorAll(triggerSelectors.join(',')))
+                    .filter(isVisible)
+                    .filter((el) => isModelTrigger(el))
+                    .sort((a, b) => triggerScore(b) - triggerScore(a));
+                for (const trigger of triggers) {
+                    const opened = await activateTrigger(trigger);
+                    const candidateItems = collectModelItems();
+                    if (opened || candidateItems.length > 0) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+
+            let modelItems = collectModelItems();
+            if (modelItems.length === 0 || (modelItems.length <= 1 && !hasOpenPicker())) {
+                await clickPossibleTrigger();
+                modelItems = collectModelItems();
+            }
+
+            if (modelItems.length === 0 || (modelItems.length <= 1 && !hasOpenPicker())) {
+                return {
+                    ok: false,
+                    error: 'Model list not found. The dropdown may not be open.',
+                    diagnostics: diagnostics(),
+                };
+            }
+
+            const targetLabel = normalize(targetModel).toLowerCase();
+            const targetItem = modelItems.find(({ label }) => {
+                const text = normalize(label).toLowerCase();
+                return text === targetLabel;
             });
-            
+
             if (!targetItem) {
-                const available = modelItems.map(el => (el.textContent || '').trim().replace(/New$/, '').trim()).join(', ');
-                return { ok: false, error: 'Model "' + targetModel + '" not found. Available: ' + available };
+                const available = modelItems.map(({ label }) => normalize(label)).join(', ');
+                return {
+                    ok: false,
+                    error: 'Model "' + targetModel + '" not found. Available: ' + available,
+                    diagnostics: diagnostics(),
+                };
             }
-            
-            // Check if already selected
-            if (targetItem.className.includes('bg-gray-500/20') && !targetItem.className.includes('hover:bg-gray-500/20')) {
+
+            if (isSelected(targetItem.el) || getCurrentModelLabel()?.toLowerCase() === targetLabel) {
                 return { ok: true, model: targetModel, alreadySelected: true };
             }
-            
-            // Click to select model
-            targetItem.click();
+
+            targetItem.el.click();
             await new Promise(r => setTimeout(r, 500));
-            
-            // Verify selection was applied
-            const updatedItems = Array.from(document.querySelectorAll('div.cursor-pointer'))
-                .filter(e => e.className.includes('px-2 py-1 flex items-center justify-between'));
-            const selectedItem = updatedItems.find(el => {
-                const text = (el.textContent || '').trim().replace(/New$/, '').trim();
-                return text === targetModel || text.toLowerCase() === targetModel.toLowerCase();
-            });
-            
-            if (selectedItem && selectedItem.className.includes('bg-gray-500/20') && !selectedItem.className.includes('hover:bg-gray-500/20')) {
+
+            const currentModel = normalize(getCurrentModelLabel() || '').toLowerCase();
+            if (currentModel === targetLabel) {
                 return { ok: true, model: targetModel, verified: true };
             }
-            
-            // Click succeeded but verification failed
-            return { ok: true, model: targetModel, verified: false };
+
+            const updatedTarget = collectModelItems().find(({ label }) => normalize(label).toLowerCase() === targetLabel);
+            if (updatedTarget && isSelected(updatedTarget.el)) {
+                return { ok: true, model: targetModel, verified: true };
+            }
+
+            return {
+                ok: false,
+                error: 'Model click did not update selected state.',
+                diagnostics: diagnostics(),
+            };
         })()`;
         try {
-            const contextId = this.getPrimaryContextId();
-            const callParams = {
-                expression,
-                returnByValue: true,
-                awaitPromise: true,
-            };
-            if (contextId !== null)
-                callParams.contextId = contextId;
-            const res = await this.call('Runtime.evaluate', callParams);
-            const value = res?.result?.value;
-            if (value?.ok) {
-                return { ok: true, model: value.model };
+            const contexts = this.getContexts();
+            const contextIds = [
+                this.getPrimaryContextId(),
+                ...contexts.map((ctx) => ctx.id),
+            ].filter((value, index, arr) => typeof value === 'number' && arr.indexOf(value) === index);
+            const targets = contextIds.length > 0 ? contextIds : [null];
+            let lastError = 'UI operation failed (setUiModel)';
+            for (const contextId of targets) {
+                logger_1.logger.debug(`[CdpService] setUiModel evaluating account=${this.accountName} context=${contextId ?? 'default'} target="${modelName}"`);
+                const params = {
+                    expression,
+                    returnByValue: true,
+                    awaitPromise: true,
+                };
+                if (typeof contextId === 'number')
+                    params.contextId = contextId;
+                const res = await this.call('Runtime.evaluate', params);
+                const value = res?.result?.value;
+                if (value?.ok) {
+                    logger_1.logger.info(`[CdpService] setUiModel result account=${this.accountName} context=${contextId ?? 'default'} ` +
+                        `target="${modelName}" applied="${value.model}" verified=${value.verified === true} ` +
+                        `alreadySelected=${value.alreadySelected === true}`);
+                    if (value.verified === false) {
+                        logger_1.logger.warn(`[CdpService] setUiModel verification did not confirm selection account=${this.accountName} ` +
+                            `context=${contextId ?? 'default'} target="${modelName}"`);
+                    }
+                    return {
+                        ok: true,
+                        model: value.model,
+                        verified: value.verified,
+                        alreadySelected: value.alreadySelected,
+                    };
+                }
+                if (value?.error) {
+                    if (value?.diagnostics) {
+                        logger_1.logger.warn(`[CdpService] setUiModel diagnostics account=${this.accountName} context=${contextId ?? 'default'} ` +
+                            `target="${modelName}" details=${value.diagnostics}`);
+                    }
+                    logger_1.logger.warn(`[CdpService] setUiModel context failure account=${this.accountName} context=${contextId ?? 'default'} ` +
+                        `target="${modelName}" error="${value.error}"`);
+                    lastError = value.error;
+                }
             }
-            return { ok: false, error: value?.error || 'UI operation failed (setUiModel)' };
+            logger_1.logger.warn(`[CdpService] setUiModel failed account=${this.accountName} target="${modelName}" error="${lastError}"`);
+            return { ok: false, error: lastError };
         }
         catch (error) {
-            return { ok: false, error: error?.message || String(error) };
+            const errorMessage = error?.message || String(error);
+            logger_1.logger.error(`[CdpService] setUiModel exception account=${this.accountName} target="${modelName}": ${errorMessage}`);
+            return { ok: false, error: errorMessage };
         }
     }
 }