@phnx-labs/agents-cli 1.22.93 → 1.22.95

package/dist/lib/browser/service.js

@@ -16,12 +16,15 @@ import { taskMatchesCaller } from './caller-identity.js';
 import { getRefs, resolveRefToCoords, describeRefs, healRef } from './refs.js';
 import { clickAtCoords, hoverAtCoords, scrollAtCoords, typeText, pressKey, focusNode } from './input.js';
 import { typeEditorText } from './editor.js';
+import { arcClickExpression, arcFillExpression, arcRefsExpression, arcScrollExpression, parseArcRefsResult, } from './arc-dom.js';
 import { detectUploadPattern, stageUploadFile, uploadToDropTarget, uploadToFileInput, uploadViaFileChooser, } from './upload.js';
 import { emit } from '../feed/events.js';
 import { resolveActor } from '../actor.js';
 import { recordBrowserSession } from '../session/db.js';
 import { sshExecAsync } from '../ssh-exec.js';
 import { resolveFfmpeg } from './ffmpeg.js';
+import { FirefoxCapabilityError, connectFirefox, bidiTopLevelContexts, bidiCreateTab, bidiNavigate, bidiReload, bidiCloseTab, bidiActivate, bidiEvaluate, bidiScreenshot, bidiClickAt, } from './drivers/firefox.js';
+import { ArcNativeCapabilityError, executeJavaScript, navigateArcTab, closeArcTab, createArcTab, enumerateArcSpaces, isArcRunning, resolveArcTab, restoreArcSelection, selectWindowTab, selectArcTab, } from './drivers/arc.js';
 /**
  * Canonical form for comparing a requested URL against what CDP reports for a
  * live target. `new URL('https://example.com').href` is `https://example.com/`,
@@ -229,6 +232,15 @@ function expandHome(p) {
  * can make; if it doesn't round-trip within 1s the connection is dead.
  */
 async function isConnHealthy(conn, timeoutMs = 1000) {
+    // Native Arc connections: healthy if Arc is still running (no CDP socket to probe).
+    if (conn.backend === 'arc-native') {
+        return isArcRunning();
+    }
+    // Firefox BiDi connections: healthy while the WebSocket is open (a killed
+    // Firefox closes it). No lightweight round-trip verb is needed.
+    if (conn.backend === 'bidi') {
+        return conn.bidi.isOpen;
+    }
     if (!conn.cdp.isOpen)
         return false;
     try {
@@ -242,6 +254,19 @@ async function isConnHealthy(conn, timeoutMs = 1000) {
         return false;
     }
 }
+/**
+ * Narrow `conn` to the CDP backend, or throw the backend's capability error.
+ * Because the union now carries `arc-native` AND `bidi`, every action that
+ * reaches `conn.cdp` without a preceding backend branch fails to type-check —
+ * the compiler is the checklist that no verb silently calls CDP on a
+ * non-CDP connection.
+ */
+function requireCdp(conn, capability) {
+    if (conn.backend === 'arc-native')
+        throw new ArcNativeCapabilityError(capability);
+    if (conn.backend === 'bidi')
+        throw new FirefoxCapabilityError(capability);
+}
 /** Join error lines so callers get a next command, not a dead-end message. */
 export function actionable(...lines) {
     return lines.filter((l) => l != null && l !== '').join('\n');
@@ -294,6 +319,20 @@ export function resolveTaskIdentity(forwarded, resolveLocalActor) {
         sessionId: forwarded.sessionId,
     };
 }
+/**
+ * The unique URL a native Arc tab is created at before it is navigated to its
+ * real target (PHNX-2399). Arc's `make new tab` accepts only http(s) URLs (it
+ * rejects `data:` and `about:` outright), so the marker is an https URL on the
+ * reserved `.invalid` TLD: DNS fails locally, no request leaves the machine,
+ * and the tab keeps the exact URL for the enumerate-and-match that follows.
+ */
+const ARC_CREATE_MARKER_PREFIX = 'https://agents-browser.invalid/';
+export function arcCreateMarker() {
+    return `${ARC_CREATE_MARKER_PREFIX}${crypto.randomUUID()}`;
+}
+export function isArcCreateMarker(url) {
+    return url.startsWith(ARC_CREATE_MARKER_PREFIX);
+}
 export class BrowserService {
     static SOURCE_PREFIX = {
         'rush-app': 'rush-app-',
@@ -435,6 +474,9 @@ export class BrowserService {
             endpointName: opts.endpointName,
             probe: opts.probe,
         });
+        if (!routed.local && routed.commandDispatch) {
+            throw new Error(`Native Arc profile "${profileName}" is owned by ${routed.device}; dispatch the complete browser command there.`);
+        }
         const composite = routed.key;
         const effectiveProfile = routed.profile;
         const taskId = generateTaskId();
@@ -509,7 +551,7 @@ export class BrowserService {
         // pile-up in RUSH-2622. Tabs the daemon did NOT open are still left alone —
         // the branch only fires when the profile has no page target at all.
         let startupBlankTargetId;
-        if (!opts.url && !conn.electron) {
+        if (!opts.url && !conn.electron && conn.backend !== 'arc-native' && conn.backend !== 'bidi') {
             const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
             if (!targetInfos.some((t) => t.type === 'page')) {
                 const created = await this.createPageTarget(conn, {
@@ -538,13 +580,23 @@ export class BrowserService {
             // actor (the RUSH-2020 bug).
             ...resolveTaskIdentity({ actor: opts.actor, launchId: opts.launchId, sessionId: opts.sessionId }, () => resolveActor().id),
         };
+        if (conn.backend === 'arc-native') {
+            const selected = await this.resolveArcSpace(conn.arcProfile);
+            task.arcNative = {
+                profileId: conn.arcProfile.profileId,
+                windowId: selected.windowId,
+                spaceId: selected.spaceId,
+                spaceTitle: selected.spaceTitle,
+                tabs: {},
+            };
+        }
         if (startupBlankTargetId) {
             const shortId = generateShortId();
             task.tabs[shortId] = startupBlankTargetId;
             task.currentTabId = shortId;
         }
         // For Electron, get the existing window as the tab
-        if (conn.electron) {
+        if (conn.electron && conn.backend !== 'arc-native' && conn.backend !== 'bidi') {
             const windowId = await this.getOrCreateWindow(conn);
             if (windowId) {
                 const shortId = generateShortId();
@@ -596,7 +648,14 @@ export class BrowserService {
         // opening a fresh target is created:true.
         let tabId;
         let firstOpen;
-        if (opts.url && !conn.electron && conn.browserType !== 'arc') {
+        if (opts.url && conn.backend === 'bidi') {
+            // Firefox: the implicit first navigate opens a fresh tab (no adopt path —
+            // Firefox tabs aren't shared across abandoned tasks the way CDP ones are).
+            const result = await this.navigate(taskName, opts.url, effectiveKey);
+            tabId = result.tabId;
+            firstOpen = { tabId: result.tabId, created: result.created, refreshed: result.refreshed, message: result.message };
+        }
+        else if (opts.url && conn.backend !== 'arc-native' && conn.backend !== 'bidi' && !conn.electron && conn.browserType !== 'arc') {
             const adopted = opts.fresh ? undefined : await this.adoptTabShowing(conn, opts.url);
             const targetId = adopted ?? (await this.createPageTarget(conn, { url: opts.url })).targetId;
             const shortId = generateShortId();
@@ -607,7 +666,7 @@ export class BrowserService {
             tabId = shortId;
             firstOpen = { tabId: shortId, created: !adopted, refreshed: false };
         }
-        else if (opts.url && (conn.electron || conn.browserType === 'arc')) {
+        else if (opts.url && (conn.backend === 'arc-native' || conn.electron || conn.browserType === 'arc')) {
             // Electron and Arc share the reuse-in-place path: neither may open a fresh
             // tab here (Electron drives its one window; Arc crashes on Target.createTarget),
             // so the implicit first navigate attaches to an existing tab — honoring the
@@ -830,36 +889,70 @@ export class BrowserService {
                 const mapKey = this.taskMapKey(conn, task) ?? taskName;
                 // Get domains from tabs before closing (for history)
                 const domains = new Set();
-                try {
-                    const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
-                    for (const cdpId of Object.values(task.tabs)) {
-                        const target = targetInfos.find((t) => t.targetId === cdpId);
-                        if (target?.url) {
+                if (conn.backend === 'arc-native') {
+                    // Resolve exact durable refs for history. Missing/moved tabs are not
+                    // adopted and never become candidates for a best-effort close.
+                    for (const ref of Object.values(this.requireArcTask(task).tabs)) {
+                        const live = await resolveArcTab(ref);
+                        if (live?.url) {
                             try {
-                                const domain = new URL(target.url).hostname.replace(/^www\./, '');
+                                const domain = new URL(live.url).hostname.replace(/^www\./, '');
                                 if (domain && domain !== 'blank')
                                     domains.add(domain);
                             }
-                            catch {
-                                // invalid URL
-                            }
+                            catch { /* invalid URL */ }
                         }
                     }
+                    await this.saveToHistory(task, Array.from(domains));
+                    await this.closeArcNativeTabs(conn, task);
                 }
-                catch {
-                    // CDP not responding
+                else if (conn.backend === 'bidi') {
+                    try {
+                        for (const tab of await this.listFirefoxTaskTabs(conn, task)) {
+                            try {
+                                const domain = new URL(tab.url).hostname.replace(/^www\./, '');
+                                if (domain && domain !== 'blank')
+                                    domains.add(domain);
+                            }
+                            catch { /* invalid URL */ }
+                        }
+                    }
+                    catch { /* Firefox not responding */ }
+                    await this.saveToHistory(task, Array.from(domains));
+                    await this.closeFirefoxTabs(conn, task);
                 }
-                // Save to history before closing
-                await this.saveToHistory(task, Array.from(domains));
-                // Close task's tabs (not the window - it's shared, and not a tab the
-                // task merely borrowed - that one was open before the task existed).
-                await Promise.all(this.closeableTargetIds(task).map((cdpId) => conn.cdp.send('Target.closeTarget', { targetId: cdpId }).catch(() => {
-                    // Tab already closed
-                })));
-                for (const cdpId of Object.values(task.tabs)) {
-                    conn.sessionCache.delete(cdpId);
+                else {
+                    try {
+                        const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
+                        for (const cdpId of Object.values(task.tabs)) {
+                            const target = targetInfos.find((t) => t.targetId === cdpId);
+                            if (target?.url) {
+                                try {
+                                    const domain = new URL(target.url).hostname.replace(/^www\./, '');
+                                    if (domain && domain !== 'blank')
+                                        domains.add(domain);
+                                }
+                                catch {
+                                    // invalid URL
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // CDP not responding
+                    }
+                    // Save to history before closing
+                    await this.saveToHistory(task, Array.from(domains));
+                    // Close task's tabs (not the window - it's shared, and not a tab the
+                    // task merely borrowed - that one was open before the task existed).
+                    await Promise.all(this.closeableTargetIds(task).map((cdpId) => conn.cdp.send('Target.closeTarget', { targetId: cdpId }).catch(() => {
+                        // Tab already closed
+                    })));
+                    for (const cdpId of Object.values(task.tabs)) {
+                        conn.sessionCache.delete(cdpId);
+                    }
+                    this.invalidateTargetCache(conn);
                 }
-                this.invalidateTargetCache(conn);
                 conn.tasks.delete(mapKey);
                 await this.saveTaskState(key, conn.tasks);
                 // Feed + usage rows are read by humans: bare profile name (RUSH-2709).
@@ -875,8 +968,15 @@ export class BrowserService {
                     });
                 }).catch(() => { });
                 if (conn.forkedFrom && conn.tasks.size === 0) {
-                    conn.cdp.close();
-                    killChrome(conn.pid);
+                    if (conn.backend === 'bidi') {
+                        conn.bidi.close();
+                        if (conn.pid)
+                            killChrome(conn.pid);
+                    }
+                    else if (conn.backend !== 'arc-native') {
+                        conn.cdp.close();
+                        killChrome(conn.pid);
+                    }
                     conn.cleanup?.();
                     this.connections.delete(key);
                     clearProfileRuntime(key);
@@ -908,6 +1008,28 @@ export class BrowserService {
             const conn = this.connections.get(key);
             if (!conn)
                 continue;
+            // Native Arc connections: close owned tabs but NEVER kill the Arc process.
+            // The CLI does not own the Arc process — the user started it.
+            if (conn.backend === 'arc-native') {
+                for (const task of conn.tasks.values()) {
+                    await this.closeArcNativeTabs(conn, task);
+                }
+                this.connections.delete(key);
+                clearProfileRuntime(key);
+                continue;
+            }
+            // Firefox: close the BiDi socket and kill the Firefox WE launched (pid !=
+            // 0). An attached Firefox the user started (pid 0) is left running — the
+            // CLI does not own that process, same as Arc.
+            if (conn.backend === 'bidi') {
+                conn.bidi.close();
+                if (conn.pid)
+                    killChrome(conn.pid);
+                conn.cleanup?.();
+                this.connections.delete(key);
+                clearProfileRuntime(key);
+                continue;
+            }
             conn.cdp.close();
             killChrome(conn.pid);
             conn.cleanup?.();
@@ -934,6 +1056,15 @@ export class BrowserService {
     }
     async navigateLocked(conn, task, url) {
         this.maybeUpdateLabelFromUrl(conn, task, url);
+        // Native Arc backend (PHNX-2399): route through the native driver instead of CDP.
+        if (conn.backend === 'arc-native') {
+            return this.navigateArcNative(conn, task, url);
+        }
+        // Firefox BiDi backend (PHNX-4043).
+        if (conn.backend === 'bidi') {
+            return this.navigateFirefox(conn, task, url);
+        }
+        requireCdp(conn, 'navigate');
         // Same-task reopen (PHNX-2399): the URL is already live in a tab this task
         // owns → reload THAT tab in place and keep its id, before the create/reuse
         // paths below. Chrome and Arc alike; Electron drives one window and never
@@ -1035,6 +1166,13 @@ export class BrowserService {
         return this.runExclusive(`task:${task.profile}:${task.name}`, () => this.tabAddLocked(conn, task, url));
     }
     async tabAddLocked(conn, task, url) {
+        if (conn.backend === 'arc-native') {
+            return this.navigateArcNative(conn, task, url, true);
+        }
+        if (conn.backend === 'bidi') {
+            return this.navigateFirefox(conn, task, url, true);
+        }
+        requireCdp(conn, 'createTab');
         if (conn.electron) {
             throw new Error('Electron apps do not support opening additional tabs');
         }
@@ -1057,12 +1195,38 @@ export class BrowserService {
     async tabFocus(taskId, tabHint) {
         const { conn, task } = await this.findTask(taskId);
         const resolvedTabId = await this.resolveTabHint(conn, task, tabHint);
+        if (conn.backend === 'arc-native') {
+            await this.runExclusive('arc-native:host-app', async () => {
+                const ref = this.requireArcTask(task).tabs[resolvedTabId];
+                if (!ref)
+                    throw new Error(`Tab ${resolvedTabId} not found`);
+                await selectArcTab(ref);
+                task.currentTabId = resolvedTabId;
+                await this.saveTaskState(task.profile, conn.tasks);
+            });
+            return { tabId: resolvedTabId };
+        }
+        if (conn.backend === 'bidi') {
+            await bidiActivate(conn.bidi, this.firefoxContext(task, resolvedTabId));
+            task.currentTabId = resolvedTabId;
+            await this.saveTaskState(task.profile, conn.tasks);
+            return { tabId: resolvedTabId };
+        }
         task.currentTabId = resolvedTabId;
         await this.saveTaskState(task.profile, conn.tasks);
         return { tabId: resolvedTabId };
     }
     async tabList(taskId) {
         const { conn, task } = await this.findTask(taskId);
+        if (conn.backend === 'arc-native') {
+            return (await this.listArcTaskTabs(task)).map((tab) => ({ ...tab, current: tab.current === true }));
+        }
+        if (conn.backend === 'bidi') {
+            return (await this.listFirefoxTaskTabs(conn, task)).map((tab) => ({
+                id: tab.id, url: tab.url, title: tab.title, current: tab.current === true,
+            }));
+        }
+        requireCdp(conn, 'enumerate');
         const targets = (await conn.cdp.send('Target.getTargets'));
         const tabs = [];
         for (const [shortId, cdpId] of Object.entries(task.tabs)) {
@@ -1089,6 +1253,13 @@ export class BrowserService {
         if (byPrefix.length > 1) {
             throw new Error(`Ambiguous tab hint "${hint}" — matches ${byPrefix.length} tabs`);
         }
+        // Native Arc addresses owned tabs only by the task's stable short id. URL
+        // and title are display data and must never become fallback identities.
+        if (conn.backend === 'arc-native')
+            throw new Error(`Tab "${hint}" not found`);
+        // Firefox tabs are addressed by the task's stable short id too.
+        if (conn.backend === 'bidi')
+            throw new Error(`Tab "${hint}" not found`);
         // URL substring match
         const targets = (await conn.cdp.send('Target.getTargets'));
         const matches = [];
@@ -1121,12 +1292,20 @@ export class BrowserService {
     async tabs(taskId, profileRef) {
         if (taskId) {
             const { conn, task } = await this.findTask(taskId, profileRef);
+            if (conn.backend === 'arc-native')
+                return this.listArcTaskTabs(task);
+            if (conn.backend === 'bidi')
+                return this.listFirefoxTaskTabs(conn, task);
             return this.getTabsForTask(conn.cdp, task);
         }
         const allTabs = [];
         for (const [, conn] of this.connections) {
             for (const [, task] of conn.tasks) {
-                const tabs = await this.getTabsForTask(conn.cdp, task);
+                const tabs = conn.backend === 'arc-native'
+                    ? await this.listArcTaskTabs(task)
+                    : conn.backend === 'bidi'
+                        ? await this.listFirefoxTaskTabs(conn, task)
+                        : await this.getTabsForTask(conn.cdp, task);
                 allTabs.push(...tabs);
             }
         }
@@ -1134,6 +1313,54 @@ export class BrowserService {
     }
     async tabClose(taskId, tabHint) {
         const { conn, task } = await this.findTask(taskId);
+        if (conn.backend === 'arc-native') {
+            await this.runExclusive('arc-native:host-app', async () => {
+                await this.reconcileArcCreateIntents(conn, task);
+                const native = this.requireArcTask(task);
+                const ids = tabHint === undefined
+                    ? Object.keys(native.tabs)
+                    : [await this.resolveTabHint(conn, task, tabHint)];
+                for (const shortId of ids) {
+                    const ref = native.tabs[shortId];
+                    if (ref)
+                        await closeArcTab(ref);
+                    delete native.tabs[shortId];
+                    delete task.tabs[shortId];
+                    delete task.refDescriptors?.[shortId];
+                }
+                if (!task.currentTabId || ids.includes(task.currentTabId)) {
+                    const remaining = Object.keys(native.tabs);
+                    task.currentTabId = remaining.at(-1);
+                }
+                await this.saveTaskState(task.profile, conn.tasks);
+            });
+            return;
+        }
+        if (conn.backend === 'bidi') {
+            const borrowed = new Set(task.borrowedTabs ?? []);
+            const ids = tabHint === undefined
+                ? Object.keys(task.tabs)
+                : [await this.resolveTabHint(conn, task, tabHint)];
+            for (const shortId of ids) {
+                const context = task.tabs[shortId];
+                // A borrowed tab is released, not closed — it outlives this task.
+                if (context && !borrowed.has(shortId)) {
+                    try {
+                        await bidiCloseTab(conn.bidi, context);
+                    }
+                    catch { /* already closed */ }
+                }
+                delete task.tabs[shortId];
+                delete task.refDescriptors?.[shortId];
+                task.borrowedTabs = (task.borrowedTabs ?? []).filter((id) => id !== shortId);
+            }
+            if (!task.currentTabId || ids.includes(task.currentTabId)) {
+                task.currentTabId = Object.keys(task.tabs).at(-1);
+            }
+            await this.saveTaskState(task.profile, conn.tasks);
+            return;
+        }
+        requireCdp(conn, 'closeTab');
         if (tabHint !== undefined) {
             const shortId = await this.resolveTabHint(conn, task, tabHint);
             const cdpId = task.tabs[shortId];
@@ -1170,6 +1397,14 @@ export class BrowserService {
     async evaluate(taskId, tabHint, expression) {
         const { conn, task } = await this.findTask(taskId);
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        // Native Arc backend (PHNX-2399): synchronous JS only, isolated world.
+        if (conn.backend === 'arc-native') {
+            return this.evaluateArcNative(conn, task, shortId, expression);
+        }
+        // Firefox BiDi backend (PHNX-4043): async-capable, isolated realm.
+        if (conn.backend === 'bidi') {
+            return this.evaluateFirefox(conn, task, shortId, expression);
+        }
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target) {
@@ -1199,6 +1434,17 @@ export class BrowserService {
     }
     async screenshot(taskId, tabHint, outputPath, quality = 'compressed') {
         const { conn, task, key: runtimeKey } = await this.findTask(taskId);
+        // Native Arc backend: screenshots cannot select/activate the user's tab.
+        if (conn.backend === 'arc-native') {
+            throw new ArcNativeCapabilityError('screenshot', 'Screenshot is unavailable for native Arc automation. ' +
+                'Screenshots require activating the tab, which would disrupt user selection. ' +
+                'This task still belongs to the Arc profile. ' +
+                'Use a Chromium-family browser for screenshot capability.');
+        }
+        // Firefox BiDi backend (PHNX-4043): captureScreenshot on the context.
+        if (conn.backend === 'bidi') {
+            return this.screenshotFirefox(conn, task, runtimeKey, tabHint, outputPath, quality);
+        }
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -1259,6 +1505,7 @@ export class BrowserService {
      */
     async printToPdf(taskId, tabHint, outputPath) {
         const { conn, task, key: runtimeKey } = await this.findTask(taskId);
+        requireCdp(conn, 'pdf');
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -1287,6 +1534,7 @@ export class BrowserService {
             throw new Error(`Task "${taskId}" is already recording. Call record stop first.`);
         }
         const { conn, task, key: runtimeKey } = await this.findTask(taskId);
+        requireCdp(conn, 'screenshot');
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -1488,6 +1736,9 @@ export class BrowserService {
         return { path: outputPath, fps, durationCapSec: durationSec, maxMb };
     }
     async recordStop(taskId, reason = 'manual') {
+        const activeTask = await this.findTask(taskId).catch(() => undefined);
+        if (activeTask)
+            requireCdp(activeTask.conn, 'screenshot');
         const rec = this.recordings.get(taskId);
         if (!rec) {
             throw new Error(`Task "${taskId}" is not currently recording`);
@@ -1570,6 +1821,13 @@ export class BrowserService {
         return { path: rec.outputPath, bytes, durationMs, reason };
     }
     async recordStatus(taskId) {
+        // The idle reaper calls this while deciding whether a task is stale. Do
+        // not route an already-live task through findTask(), which stamps it as
+        // active and defeats idle detection. A cold daemon may still rehydrate for
+        // an explicit user query.
+        const live = this.findTaskByHandle(taskId) ?? await this.findTask(taskId).catch(() => undefined);
+        if (live)
+            requireCdp(live.conn, 'screenshot');
         const rec = this.recordings.get(taskId);
         if (!rec)
             return { recording: false };
@@ -1578,6 +1836,21 @@ export class BrowserService {
     async refs(taskId, tabHint, opts = {}) {
         const { conn, task } = await this.findTask(taskId);
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        if (conn.backend === 'arc-native') {
+            const result = parseArcRefsResult(await this.evaluateArcNative(conn, task, shortId, arcRefsExpression(opts)), opts);
+            this.cacheRefDescriptors(task, shortId, result.nodeMap, result.opts);
+            await this.saveTaskState(task.profile, conn.tasks);
+            return result;
+        }
+        // Firefox BiDi (PHNX-4043): the same DOM-derived accessibility listing Arc
+        // uses, evaluated over BiDi. selector-based refs, no CDP accessibility tree.
+        if (conn.backend === 'bidi') {
+            const result = parseArcRefsResult(await this.evaluateFirefox(conn, task, shortId, arcRefsExpression(opts)), opts);
+            this.cacheRefDescriptors(task, shortId, result.nodeMap, result.opts);
+            await this.saveTaskState(task.profile, conn.tasks);
+            return result;
+        }
+        requireCdp(conn, 'enumerate');
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
@@ -1614,7 +1887,7 @@ export class BrowserService {
         const stillMatches = fresh !== undefined &&
             fresh.role === cached.role &&
             fresh.name === cached.name &&
-            fresh.backendNodeId !== undefined;
+            (fresh.backendNodeId !== undefined || fresh.selector !== undefined);
         if (stillMatches)
             return { targetRef: ref };
         const newRef = healRef(cached, nodeMap);
@@ -1632,6 +1905,31 @@ export class BrowserService {
     async click(taskId, ref, tabHint) {
         const { conn, task } = await this.findTask(taskId);
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        if (conn.backend === 'arc-native') {
+            const snapshot = task.refDescriptors?.[shortId];
+            const buildOpts = snapshot?.opts ?? { interactive: true, limit: 500 };
+            const { nodeMap } = parseArcRefsResult(await this.evaluateArcNative(conn, task, shortId, arcRefsExpression(buildOpts)), buildOpts);
+            const { targetRef, healed } = this.resolveHealedRef(snapshot, nodeMap, ref);
+            const selector = nodeMap.get(targetRef)?.selector;
+            if (!selector)
+                throw new Error(`Ref ${ref} has no DOM selector`);
+            await this.evaluateArcNative(conn, task, shortId, arcClickExpression(selector));
+            return healed ? { healed } : {};
+        }
+        if (conn.backend === 'bidi') {
+            const snapshot = task.refDescriptors?.[shortId];
+            const buildOpts = snapshot?.opts ?? { interactive: true, limit: 500 };
+            const { nodeMap } = parseArcRefsResult(await this.evaluateFirefox(conn, task, shortId, arcRefsExpression(buildOpts)), buildOpts);
+            const { targetRef, healed } = this.resolveHealedRef(snapshot, nodeMap, ref);
+            const selector = nodeMap.get(targetRef)?.selector;
+            if (!selector)
+                throw new Error(`Ref ${ref} has no DOM selector`);
+            const coords = await this.firefoxRefCoords(conn, task, shortId, selector);
+            const context = this.firefoxContext(task, shortId);
+            await bidiClickAt(conn.bidi, context, coords.x, coords.y);
+            return healed ? { healed } : {};
+        }
+        requireCdp(conn, 'click');
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
@@ -1663,6 +1961,7 @@ export class BrowserService {
      */
     async clickAt(taskId, x, y, tabHint) {
         const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'trustedInput');
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -1674,6 +1973,29 @@ export class BrowserService {
     async type(taskId, ref, text, tabHint, clear) {
         const { conn, task } = await this.findTask(taskId);
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        if (conn.backend === 'arc-native') {
+            const snapshot = task.refDescriptors?.[shortId];
+            const buildOpts = snapshot?.opts ?? { interactive: true, limit: 500 };
+            const { nodeMap } = parseArcRefsResult(await this.evaluateArcNative(conn, task, shortId, arcRefsExpression(buildOpts)), buildOpts);
+            const { targetRef } = this.resolveHealedRef(snapshot, nodeMap, ref);
+            const selector = nodeMap.get(targetRef)?.selector;
+            if (!selector)
+                throw new Error(`Ref ${ref} has no DOM selector`);
+            await this.evaluateArcNative(conn, task, shortId, arcFillExpression(selector, text, clear ?? false));
+            return;
+        }
+        if (conn.backend === 'bidi') {
+            const snapshot = task.refDescriptors?.[shortId];
+            const buildOpts = snapshot?.opts ?? { interactive: true, limit: 500 };
+            const { nodeMap } = parseArcRefsResult(await this.evaluateFirefox(conn, task, shortId, arcRefsExpression(buildOpts)), buildOpts);
+            const { targetRef } = this.resolveHealedRef(snapshot, nodeMap, ref);
+            const selector = nodeMap.get(targetRef)?.selector;
+            if (!selector)
+                throw new Error(`Ref ${ref} has no DOM selector`);
+            await this.evaluateFirefox(conn, task, shortId, arcFillExpression(selector, text, clear ?? false));
+            return;
+        }
+        requireCdp(conn, 'type');
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
@@ -1701,6 +2023,7 @@ export class BrowserService {
     }
     async press(taskId, key, tabHint) {
         const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'trustedInput');
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -1711,6 +2034,7 @@ export class BrowserService {
     }
     async hover(taskId, ref, tabHint) {
         const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'trustedInput');
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -1724,6 +2048,17 @@ export class BrowserService {
     async scroll(taskId, deltaX, deltaY, atX, atY, tabHint) {
         const { conn, task } = await this.findTask(taskId);
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        if (conn.backend === 'arc-native') {
+            if (atX !== undefined || atY !== undefined)
+                throw new ArcNativeCapabilityError('trustedInput');
+            await this.evaluateArcNative(conn, task, shortId, arcScrollExpression(deltaX, deltaY));
+            return;
+        }
+        if (conn.backend === 'bidi') {
+            await this.evaluateFirefox(conn, task, shortId, arcScrollExpression(deltaX, deltaY));
+            return;
+        }
+        requireCdp(conn, 'scroll');
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
@@ -1733,6 +2068,7 @@ export class BrowserService {
     }
     async upload(taskId, files, options) {
         const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'upload');
         const shortId = options.tabHint
             ? await this.resolveTabHint(conn, task, options.tabHint)
             : this.resolveCurrentTab(task);
@@ -1883,6 +2219,7 @@ export class BrowserService {
     // ─── Viewport & Device Emulation ──────────────────────────────────────────────
     async setViewport(taskId, width, height, options = {}) {
         const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'viewport');
         const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -1963,6 +2300,7 @@ export class BrowserService {
     }
     async getConsoleLogs(taskId, options = {}) {
         const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'consoleCapture');
         const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -1981,6 +2319,7 @@ export class BrowserService {
     }
     async getErrors(taskId, options = {}) {
         const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'consoleCapture');
         const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -2033,6 +2372,7 @@ export class BrowserService {
     }
     async getNetworkRequests(taskId, options = {}) {
         const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'networkCapture');
         const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -2052,6 +2392,7 @@ export class BrowserService {
     }
     async getResponseBody(taskId, urlPattern, options = {}) {
         const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'networkCapture');
         const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -2125,11 +2466,12 @@ export class BrowserService {
     // ─── Wait Conditions ─────────────────────────────────────────────────────────
     async wait(taskId, type, value, options = {}) {
         const timeout = options.timeout ?? 30000;
+        const { conn, task } = await this.findTask(taskId);
+        requireCdp(conn, 'asyncEvaluate');
         if (type === 'time') {
             await new Promise((r) => setTimeout(r, typeof value === 'number' ? value : parseInt(value, 10)));
             return;
         }
-        const { conn, task } = await this.findTask(taskId);
         const shortId = options.tabHint ? await this.resolveTabHint(conn, task, options.tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -2202,6 +2544,7 @@ export class BrowserService {
     }
     async setDownloadPath(taskId, downloadPath, tabHint) {
         const { conn, task, key: runtimeKey } = await this.findTask(taskId);
+        requireCdp(conn, 'download');
         const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
@@ -2230,6 +2573,8 @@ export class BrowserService {
         return resolvedPath;
     }
     async waitForDownload(taskId, timeout = 60000) {
+        const { conn } = await this.findTask(taskId);
+        requireCdp(conn, 'download');
         const start = Date.now();
         while (Date.now() - start < timeout) {
             const dl = this.pendingDownloads.get(taskId);
@@ -2284,7 +2629,10 @@ export class BrowserService {
             this.recordings.delete(taskId);
         }
         for (const [, conn] of this.connections) {
-            conn.cdp.close();
+            if (conn.backend === 'bidi')
+                conn.bidi.close();
+            else if (conn.backend !== 'arc-native')
+                conn.cdp.close();
             conn.cleanup?.();
         }
         this.connections.clear();
@@ -2310,6 +2658,7 @@ export class BrowserService {
         await cdp.connect(wsUrl);
         await this.enableDomains(cdp);
         const connection = {
+            backend: 'cdp',
             cdp,
             port,
             pid,
@@ -2338,6 +2687,11 @@ export class BrowserService {
     async connectProfile(effectiveProfile, target, key, opts = {}) {
         const existingInfo = getRunningChromeInfo(key);
         const tunnelled = opts.persistRemote || target.startsWith('ssh:');
+        // Native Arc and Firefox BiDi speak their own transport, not CDP — never
+        // route them through the CDP reuse branch (which would probe /json/version
+        // and wipe the runtime meta the Firefox driver wrote). connectEndpoint owns
+        // their attach-or-launch decision.
+        const nativeTransport = target.startsWith('arc-native:') || target.startsWith('firefox-bidi:');
         if (tunnelled) {
             // A leftover local chrome-data / pid file under this key is the
             // pre-T2 logged-out browser on THIS box. Attaching localhost CDP
@@ -2348,7 +2702,7 @@ export class BrowserService {
                 clearProfileRuntime(key);
             }
         }
-        else if (existingInfo) {
+        else if (existingInfo && !nativeTransport) {
             try {
                 const { wsUrl, browser } = await discoverBrowserWsUrl(existingInfo.port, 'localhost', effectiveProfile.name);
                 verifyBrowserIdentity(browser, effectiveProfile.browser, existingInfo.port);
@@ -2357,6 +2711,7 @@ export class BrowserService {
                 await this.enableDomains(cdp);
                 const tasks = this.loadTaskState(key);
                 return {
+                    backend: 'cdp',
                     cdp,
                     port: existingInfo.port,
                     pid: existingInfo.pid,
@@ -2389,6 +2744,7 @@ export class BrowserService {
             const conn = await connectLocal(endpoint, profile, key);
             await this.enableDomains(conn.cdp);
             return {
+                backend: 'cdp',
                 cdp: conn.cdp,
                 port: conn.port,
                 pid: conn.pid,
@@ -2405,6 +2761,7 @@ export class BrowserService {
             });
             await this.enableDomains(conn.cdp);
             return {
+                backend: 'cdp',
                 cdp: conn.cdp,
                 port: conn.port,
                 pid: conn.pid,
@@ -2427,6 +2784,7 @@ export class BrowserService {
             }
             await this.enableDomains(cdp);
             return {
+                backend: 'cdp',
                 cdp,
                 port: 0,
                 pid: 0,
@@ -2445,6 +2803,7 @@ export class BrowserService {
             await cdp.connect(wsUrl);
             await this.enableDomains(cdp);
             return {
+                backend: 'cdp',
                 cdp,
                 port,
                 pid: 0,
@@ -2455,6 +2814,65 @@ export class BrowserService {
                 sessionCache: new Map(),
             };
         }
+        // Firefox BiDi backend (PHNX-4043): `firefox-bidi://127.0.0.1:<port>` connects
+        // over a WebDriver BiDi WebSocket. The driver attaches to a Firefox already
+        // serving the port, else launches one headless bound to the pinned profile
+        // directory, else fails loud (Firefox is single-instance per profile).
+        if (url.protocol === 'firefox-bidi:') {
+            if (!profile.firefox) {
+                throw new Error(`Firefox profile "${profile.name}" has no discovered profile metadata. ` +
+                    `Re-select it with: agents browser use ${profile.name}`);
+            }
+            const profileDir = profile.userDataDir;
+            if (!profileDir) {
+                throw new Error(`Firefox profile "${profile.name}" has no profile directory.`);
+            }
+            const port = parseInt(url.port || '9600', 10);
+            const conn = await connectFirefox(profile, key, port, {
+                profileDir,
+                headless: profile.chrome?.headless,
+            });
+            return {
+                backend: 'bidi',
+                browserType: 'firefox',
+                bidi: conn.bidi,
+                firefoxProfile: profile.firefox,
+                sessionId: conn.sessionId,
+                profileDir,
+                port: conn.port,
+                pid: conn.pid,
+                electron: false,
+                targetFilter: profile.targetFilter,
+                tasks: this.loadTaskState(key),
+                sessionCache: new Map(),
+            };
+        }
+        // Native Arc backend (PHNX-2399): `arc-native:` protocol connects through
+        // Apple Events instead of CDP. No debugging port, no browser launch.
+        if (url.protocol === 'arc-native:') {
+            if (process.platform !== 'darwin') {
+                throw new Error('Native Arc automation is only available on macOS');
+            }
+            if (!(await isArcRunning())) {
+                throw new Error('Arc is not running. Start Arc normally, then retry.\n' +
+                    'Native Arc automation drives your existing browser — it does not launch one.');
+            }
+            if (!profile.arc) {
+                throw new Error(`Native Arc profile "${profile.name}" has no stable native profile metadata. ` +
+                    `Re-select it with: agents browser use arc-<profile-id>`);
+            }
+            return {
+                port: 0,
+                pid: 0,
+                electron: false,
+                browserType: 'arc',
+                targetFilter: profile.targetFilter,
+                tasks: this.loadTaskState(key),
+                sessionCache: new Map(),
+                backend: 'arc-native',
+                arcProfile: profile.arc,
+            };
+        }
         return null;
     }
     async enableDomains(cdp) {
@@ -2471,6 +2889,8 @@ export class BrowserService {
         if (conn.browserType === 'arc') {
             throw arcNotDrivableError(conn.profile);
         }
+        // Firefox opens tabs through the BiDi driver, never Target.createTarget.
+        requireCdp(conn, 'createTab');
         return (await conn.cdp.send('Target.createTarget', params));
     }
     async getOrCreateWindow(conn) {
@@ -2660,6 +3080,7 @@ export class BrowserService {
         const matches = this.listTasksForCaller(caller);
         if (matches.length === 1) {
             const m = matches[0];
+            await this.prepareTask(m.conn, m.task);
             await this.touchTask(m.conn, m.task);
             return { conn: m.conn, task: m.task, key: m.key, created: false };
         }
@@ -2790,6 +3211,18 @@ export class BrowserService {
             // `recordBrowserSession` call in `start` uses for the same reason.
         }
     }
+    async prepareTask(conn, task) {
+        if (conn.backend !== 'arc-native')
+            return;
+        await this.runExclusive('arc-native:host-app', async () => {
+            await this.reconcileArcCreateIntents(conn, task);
+            const native = this.requireArcTask(task);
+            if (native.profileId !== conn.arcProfile.profileId) {
+                throw new Error(`Arc task profile ${JSON.stringify(native.profileId)} does not match connected profile ` +
+                    `${JSON.stringify(conn.arcProfile.profileId)}.`);
+            }
+        });
+    }
     async findTask(taskId, profileRef) {
         if (profileRef) {
             // Accept bare profile names against composite connection keys.
@@ -2801,6 +3234,7 @@ export class BrowserService {
                 const conn = this.connections.get(key);
                 const task = this.lookupTaskOnConn(conn, taskId);
                 if (task) {
+                    await this.prepareTask(conn, task);
                     await this.touchTask(conn, task);
                     return { conn, task, key: conn.key ?? key };
                 }
@@ -2808,6 +3242,7 @@ export class BrowserService {
             // RAM miss → rehydrate from disk for this profile.
             const rehydrated = await this.rehydrateTaskFromDisk(taskId, profileRef);
             if (rehydrated) {
+                await this.prepareTask(rehydrated.conn, rehydrated.task);
                 await this.touchTask(rehydrated.conn, rehydrated.task);
                 return rehydrated;
             }
@@ -2816,6 +3251,7 @@ export class BrowserService {
         for (const [key, conn] of this.connections) {
             const task = this.lookupTaskOnConn(conn, taskId);
             if (task) {
+                await this.prepareTask(conn, task);
                 await this.touchTask(conn, task);
                 return { conn, task, key: conn.key ?? key };
             }
@@ -2824,6 +3260,7 @@ export class BrowserService {
         // meta.json still has the browser pid/port. Reconnect and adopt.
         const rehydrated = await this.rehydrateTaskFromDisk(taskId);
         if (rehydrated) {
+            await this.prepareTask(rehydrated.conn, rehydrated.task);
             await this.touchTask(rehydrated.conn, rehydrated.task);
             return rehydrated;
         }
@@ -2861,6 +3298,71 @@ export class BrowserService {
         catch {
             return null;
         }
+        // Native Arc endpoints (PHNX-2399): reconnect via the native driver if Arc
+        // is still running. No port, no CDP — just verify Arc is alive and restore
+        // the task state.
+        if (resolved.target.startsWith('arc-native:')) {
+            if (process.platform !== 'darwin' || !(await isArcRunning()))
+                return null;
+            const tasks = this.loadTaskState(key);
+            for (const [k, t] of diskTasks) {
+                if (!tasks.has(k))
+                    tasks.set(k, t);
+            }
+            if (!profile.arc)
+                return null;
+            return {
+                port: 0,
+                pid: 0,
+                electron: false,
+                browserType: 'arc',
+                targetFilter: profile.targetFilter,
+                key,
+                profile: bare,
+                tasks,
+                sessionCache: new Map(),
+                backend: 'arc-native',
+                arcProfile: profile.arc,
+            };
+        }
+        // Firefox BiDi endpoints (PHNX-4043): a daemon restart dropped the BiDi
+        // socket, but the Firefox we launched is still serving the port — reattach
+        // by opening a fresh session, then merge the disk tasks. connectFirefox
+        // attaches (never launches) when the port is already served. A failure
+        // returns null like the CDP path, so the caller falls through to disk
+        // reconcile instead of crashing.
+        if (resolved.target.startsWith('firefox-bidi:')) {
+            if (!profile.firefox || !profile.userDataDir)
+                return null;
+            const port = parseEndpointUrl(resolved.target)?.port ?? 9600;
+            try {
+                const ff = await connectFirefox(profile, key, port, { profileDir: profile.userDataDir });
+                const tasks = this.loadTaskState(key);
+                for (const [k, t] of diskTasks) {
+                    if (!tasks.has(k))
+                        tasks.set(k, t);
+                }
+                return {
+                    backend: 'bidi',
+                    browserType: 'firefox',
+                    bidi: ff.bidi,
+                    firefoxProfile: profile.firefox,
+                    sessionId: ff.sessionId,
+                    profileDir: profile.userDataDir,
+                    port: ff.port,
+                    pid: ff.pid,
+                    electron: false,
+                    targetFilter: profile.targetFilter,
+                    key,
+                    profile: bare,
+                    tasks,
+                    sessionCache: new Map(),
+                };
+            }
+            catch {
+                return null;
+            }
+        }
         const existingInfo = getRunningChromeInfo(key);
         const parsed = parseEndpointUrl(resolved.target);
         const port = existingInfo?.port ?? parsed?.port;
@@ -2886,6 +3388,7 @@ export class BrowserService {
                         tasks.set(k, t);
                 }
                 return {
+                    backend: 'cdp',
                     cdp: conn.cdp,
                     port: conn.port,
                     pid: conn.pid,
@@ -2918,6 +3421,7 @@ export class BrowserService {
                     tasks.set(k, t);
             }
             const conn = {
+                backend: 'cdp',
                 cdp,
                 port,
                 pid: existingInfo?.pid ?? 0,
@@ -2974,11 +3478,19 @@ export class BrowserService {
         }
         else {
             // Shared/borrowed tunnel (or a local connection with no tunnel): close
-            // only our own CDP client; killing the tunnel would break the winner.
-            try {
-                conn.cdp.close();
+            // only our own client; killing the tunnel would break the winner.
+            if (conn.backend === 'bidi') {
+                try {
+                    conn.bidi.close();
+                }
+                catch { /* best effort */ }
+            }
+            else if (conn.backend !== 'arc-native') {
+                try {
+                    conn.cdp.close();
+                }
+                catch { /* best effort */ }
             }
-            catch { /* best effort */ }
         }
         return existing;
     }
@@ -3019,7 +3531,8 @@ export class BrowserService {
             if (registered !== conn)
                 continue;
             try {
-                await this.applyDefaultDownloadBehavior(conn, key);
+                if (conn.backend !== 'arc-native' && conn.backend !== 'bidi')
+                    await this.applyDefaultDownloadBehavior(conn, key);
             }
             catch {
                 // Non-fatal for rehydrate.
@@ -3080,7 +3593,8 @@ export class BrowserService {
                 conn = this.registerRehydratedConnection(key, attached);
                 if (conn === attached) {
                     try {
-                        await this.applyDefaultDownloadBehavior(conn, key);
+                        if (conn.backend !== 'arc-native' && conn.backend !== 'bidi')
+                            await this.applyDefaultDownloadBehavior(conn, key);
                     }
                     catch {
                         // Non-fatal.
@@ -3117,6 +3631,80 @@ export class BrowserService {
         const conn = this.connections.get(key);
         if (!conn)
             return null;
+        if (conn.backend === 'arc-native') {
+            const tasks = [];
+            for (const task of conn.tasks.values()) {
+                const tabs = await this.listArcTaskTabs(task);
+                const domains = tabs.flatMap((tab) => {
+                    try {
+                        const domain = new URL(tab.url).hostname.replace(/^www\./, '');
+                        return domain && domain !== 'blank' ? [domain] : [];
+                    }
+                    catch {
+                        return [];
+                    }
+                });
+                tasks.push({
+                    id: task.id,
+                    name: task.name,
+                    label: task.label ?? task.name,
+                    tabCount: Object.keys(task.tabs).length,
+                    currentTabId: task.currentTabId,
+                    createdAt: task.createdAt,
+                    tabs: tabs.length ? tabs : undefined,
+                    domains: [...new Set(domains)],
+                });
+            }
+            const parsed = parseConnectionKey(key);
+            return {
+                name: conn.profile ?? parsed.profile,
+                endpoint: parsed.endpoint,
+                key,
+                running: await isArcRunning(),
+                port: 0,
+                pid: 0,
+                tasks,
+            };
+        }
+        if (conn.backend === 'bidi') {
+            const tasks = [];
+            for (const task of conn.tasks.values()) {
+                let tabs = [];
+                try {
+                    tabs = await this.listFirefoxTaskTabs(conn, task);
+                }
+                catch { /* Firefox down */ }
+                const domains = tabs.flatMap((tab) => {
+                    try {
+                        const domain = new URL(tab.url).hostname.replace(/^www\./, '');
+                        return domain && domain !== 'blank' ? [domain] : [];
+                    }
+                    catch {
+                        return [];
+                    }
+                });
+                tasks.push({
+                    id: task.id,
+                    name: task.name,
+                    label: task.label ?? task.name,
+                    tabCount: Object.keys(task.tabs).length,
+                    currentTabId: task.currentTabId,
+                    createdAt: task.createdAt,
+                    tabs: tabs.length ? tabs.map((t) => ({ id: t.id, url: t.url, title: t.title, current: t.current })) : undefined,
+                    domains: domains.length ? [...new Set(domains)] : undefined,
+                });
+            }
+            const parsed = parseConnectionKey(key);
+            return {
+                name: conn.profile ?? parsed.profile,
+                endpoint: parsed.endpoint,
+                key,
+                running: conn.bidi.isOpen,
+                port: conn.port,
+                pid: conn.pid,
+                tasks,
+            };
+        }
         // Fetch all targets once for efficiency
         let targets = [];
         try {
@@ -3339,10 +3927,18 @@ export class BrowserService {
             return undefined;
         if (await isConnHealthy(conn))
             return conn;
-        try {
-            conn.cdp.close();
+        if (conn.backend === 'bidi') {
+            try {
+                conn.bidi.close();
+            }
+            catch { /* already closed */ }
+        }
+        else if (conn.backend !== 'arc-native') {
+            try {
+                conn.cdp.close();
+            }
+            catch { /* already closed */ }
         }
-        catch { /* already closed */ }
         conn.cleanup?.();
         this.connections.delete(key);
         return undefined;
@@ -3373,13 +3969,410 @@ export class BrowserService {
         }
         return undefined;
     }
+    // ---------------------------------------------------------------------------
+    // Native Arc backend helpers (PHNX-2399)
+    // ---------------------------------------------------------------------------
+    /**
+     * Bind a task to the profile's Space in the visible Arc window that holds it.
+     * The Space is the profile (PHNX-2399); only its live window id is looked up.
+     */
+    async resolveArcSpace(profile) {
+        const live = (await enumerateArcSpaces()).filter((space) => space.spaceId === profile.spaceId);
+        if (live.length !== 1) {
+            throw new Error(live.length === 0
+                ? `Arc Space ${JSON.stringify(profile.spaceTitle)} (${profile.spaceId}) is not open in a visible Arc window.`
+                : `Arc Space ${JSON.stringify(profile.spaceTitle)} is open in more than one window; refusing an ambiguous native address.`);
+        }
+        return {
+            windowId: live[0].windowId,
+            spaceId: live[0].spaceId,
+            spaceTitle: profile.spaceTitle,
+        };
+    }
+    requireArcTask(task) {
+        const native = task.arcNative;
+        if (!native || typeof native.profileId !== 'string' || typeof native.windowId !== 'string' ||
+            typeof native.spaceId !== 'string' || !native.tabs || typeof native.tabs !== 'object') {
+            throw new Error(`Task ${JSON.stringify(task.name)} has no valid durable Arc identity.`);
+        }
+        for (const [shortId, ref] of Object.entries(native.tabs)) {
+            if (!ref || typeof ref.windowId !== 'string' || typeof ref.spaceId !== 'string' ||
+                typeof ref.tabId !== 'string' || ref.windowId !== native.windowId || ref.spaceId !== native.spaceId) {
+                throw new Error(`Owned Arc tab ${JSON.stringify(shortId)} has no stable id in its original window/Space.`);
+            }
+        }
+        for (const [shortId, intent] of Object.entries(native.createIntents ?? {})) {
+            if (!intent || intent.tabId !== shortId || typeof intent.markerUrl !== 'string' ||
+                !isArcCreateMarker(intent.markerUrl) ||
+                typeof intent.targetUrl !== 'string' || typeof intent.createdAt !== 'number') {
+                throw new Error(`Arc creation intent ${JSON.stringify(shortId)} is invalid; refusing recovery.`);
+            }
+            if (intent.ref && (intent.ref.windowId !== native.windowId || intent.ref.spaceId !== native.spaceId ||
+                typeof intent.ref.tabId !== 'string')) {
+                throw new Error(`Arc creation intent ${JSON.stringify(shortId)} left its original window/Space.`);
+            }
+        }
+        return native;
+    }
+    async reconcileArcCreateIntents(conn, task) {
+        const native = this.requireArcTask(task);
+        for (const intent of Object.values(native.createIntents ?? {})) {
+            let ref = intent.ref;
+            if (ref) {
+                const live = await resolveArcTab(ref);
+                if (!live) {
+                    throw new Error(`Owned Arc tab ${intent.tabId} left its original window/Space while creation was incomplete; refusing to adopt it elsewhere.`);
+                }
+                if (live.url === intent.targetUrl) {
+                    native.tabs[intent.tabId] = ref;
+                    task.tabs[intent.tabId] = ref.tabId;
+                    if (intent.previousTabId) {
+                        await restoreArcSelection(ref, intent.previousTabId);
+                    }
+                    delete native.createIntents?.[intent.tabId];
+                    await this.saveTaskState(task.profile, conn.tasks);
+                    continue;
+                }
+                if (live.url !== intent.markerUrl) {
+                    throw new Error(`Owned Arc tab ${intent.tabId} changed outside this task during creation; refusing to navigate it.`);
+                }
+            }
+            else {
+                const originalSpace = (await enumerateArcSpaces()).find((space) => space.windowId === native.windowId && space.spaceId === native.spaceId);
+                if (!originalSpace) {
+                    throw new Error('The original Arc window/Space for this task is no longer present.');
+                }
+                const markerMatches = originalSpace.tabs.filter((tab) => tab.url === intent.markerUrl);
+                if (markerMatches.length > 1) {
+                    throw new Error(`Arc creation marker ${JSON.stringify(intent.markerUrl)} is not unique in the original Space.`);
+                }
+                if (markerMatches[0]) {
+                    ref = markerMatches[0];
+                }
+                else {
+                    try {
+                        ref = await createArcTab({ windowId: native.windowId, spaceId: native.spaceId }, intent.markerUrl);
+                    }
+                    catch (error) {
+                        // Arc selects the Space it was asked to create in even when the
+                        // creation itself fails. Put the owner back on their tab before
+                        // surfacing the error, so a failed agent verb never leaves them
+                        // staring at the wrong Space.
+                        if (intent.previousTabId) {
+                            await selectWindowTab(native.windowId, intent.previousTabId).catch(() => undefined);
+                        }
+                        throw error;
+                    }
+                }
+                intent.ref = ref;
+                native.tabs[intent.tabId] = ref;
+                task.tabs[intent.tabId] = ref.tabId;
+                await this.saveTaskState(task.profile, conn.tasks);
+            }
+            await navigateArcTab(ref, intent.targetUrl);
+            if (intent.previousTabId) {
+                await restoreArcSelection(ref, intent.previousTabId);
+            }
+            delete native.createIntents?.[intent.tabId];
+            task.currentTabId = intent.tabId;
+            await this.saveTaskState(task.profile, conn.tasks);
+        }
+    }
+    async createArcOwnedTab(conn, task, url) {
+        const native = this.requireArcTask(task);
+        const tabId = generateShortId();
+        const markerUrl = arcCreateMarker();
+        const originalSpace = (await enumerateArcSpaces()).find((space) => space.windowId === native.windowId && space.spaceId === native.spaceId);
+        if (!originalSpace)
+            throw new Error('The original Arc window/Space for this task is no longer present.');
+        native.createIntents ??= {};
+        native.createIntents[tabId] = {
+            tabId,
+            markerUrl,
+            targetUrl: url,
+            createdAt: Date.now(),
+            previousTabId: originalSpace.activeTabId,
+        };
+        await this.saveTaskState(task.profile, conn.tasks);
+        await this.reconcileArcCreateIntents(conn, task);
+        return tabId;
+    }
+    async navigateArcNative(conn, task, url, addTab = false) {
+        return this.runExclusive('arc-native:host-app', async () => {
+            await this.reconcileArcCreateIntents(conn, task);
+            const native = this.requireArcTask(task);
+            if (!addTab) {
+                for (const [shortId, ref] of Object.entries(native.tabs)) {
+                    const live = await resolveArcTab(ref);
+                    if (live && canonicalTabUrl(live.url) === canonicalTabUrl(url)) {
+                        await navigateArcTab(ref, url);
+                        task.currentTabId = shortId;
+                        await this.saveTaskState(task.profile, conn.tasks);
+                        return { tabId: shortId, url, created: false, refreshed: true, message: 'Tab already open—refreshed' };
+                    }
+                }
+            }
+            const currentId = task.currentTabId;
+            if (!addTab && currentId) {
+                const ref = native.tabs[currentId];
+                if (!ref || !(await resolveArcTab(ref))) {
+                    throw new Error(`Owned Arc tab ${currentId} is missing from its original window/Space; refusing to adopt a moved tab.`);
+                }
+                await navigateArcTab(ref, url);
+                return { tabId: currentId, url, created: false, refreshed: false };
+            }
+            const tabId = await this.createArcOwnedTab(conn, task, url);
+            return { tabId, url, created: true, refreshed: false };
+        });
+    }
+    /**
+     * Execute JavaScript in a native Arc tab. Sync JS only, isolated world —
+     * async/promise evaluation fails honestly with an AppleScript error.
+     */
+    async evaluateArcNative(conn, task, shortId, expression) {
+        const ref = this.requireArcTask(task).tabs[shortId];
+        if (!ref || !(await resolveArcTab(ref))) {
+            throw new Error(`Owned Arc tab ${shortId} is missing from its original window/Space.`);
+        }
+        return executeJavaScript(ref, expression);
+    }
+    async listArcTaskTabs(task) {
+        const native = this.requireArcTask(task);
+        const tabs = [];
+        for (const [shortId, ref] of Object.entries(native.tabs)) {
+            const live = await resolveArcTab(ref);
+            if (!live) {
+                throw new Error(`Owned Arc tab ${shortId} is missing from its original window/Space; refusing to adopt a moved tab.`);
+            }
+            tabs.push({
+                id: shortId,
+                url: live.url,
+                title: live.title,
+                task: task.name,
+                current: shortId === task.currentTabId,
+            });
+        }
+        return tabs;
+    }
+    /**
+     * Close native Arc tabs owned by a task. Only closes tabs the task created
+     * (not borrowed ones). Never kills Arc. Identifies tabs only by stable ids in
+     * the original window and Space.
+     */
+    async closeArcNativeTabs(conn, task) {
+        await this.runExclusive('arc-native:host-app', async () => {
+            await this.reconcileArcCreateIntents(conn, task);
+            const native = this.requireArcTask(task);
+            for (const [shortId, ref] of Object.entries(native.tabs)) {
+                await closeArcTab(ref);
+                delete native.tabs[shortId];
+                delete task.tabs[shortId];
+                delete task.refDescriptors?.[shortId];
+            }
+            task.currentTabId = undefined;
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Firefox WebDriver BiDi backend helpers (PHNX-4043)
+    // ---------------------------------------------------------------------------
+    /** The BiDi browsing-context id a task owns for `shortId`. */
+    firefoxContext(task, shortId) {
+        const context = task.tabs[shortId];
+        if (!context)
+            throw new Error(`Tab ${shortId} not found`);
+        return context;
+    }
+    /** The context ids currently live in this Firefox (a killed tab drops out). */
+    async firefoxLiveContexts(conn) {
+        const contexts = await bidiTopLevelContexts(conn.bidi);
+        return new Set(contexts.map((c) => c.context));
+    }
+    /**
+     * Same-task reopen for Firefox (mirrors {@link reopenOwnedTab}): the URL is
+     * already live in one of this task's own tabs → reload THAT tab in place and
+     * keep its id, rather than opening a duplicate. Borrowed tabs are excluded —
+     * Firefox never borrows, but the guard keeps parity. Returns the retained
+     * short id, or undefined when nothing matches.
+     */
+    async reopenOwnedFirefoxTab(conn, task, url) {
+        const borrowed = new Set(task.borrowedTabs ?? []);
+        // Read each live tab's URL from browsingContext.getTree metadata rather than
+        // evaluating location.href per tab: the same source the CDP path reads
+        // (Target.getTargets), so a mid-navigation or just-closed sibling tab can
+        // never throw a BiDi "no such frame" and fail an unrelated navigate. A tab
+        // absent from the tree is simply not a reopen candidate.
+        const liveUrlByContext = new Map((await bidiTopLevelContexts(conn.bidi)).map((c) => [c.context, c.url]));
+        const wanted = canonicalTabUrl(url);
+        for (const [shortId, context] of Object.entries(task.tabs)) {
+            if (borrowed.has(shortId))
+                continue;
+            const liveUrl = liveUrlByContext.get(context);
+            if (liveUrl === undefined)
+                continue; // registered but gone from the browser
+            if (canonicalTabUrl(liveUrl) === wanted) {
+                await bidiReload(conn.bidi, context);
+                task.currentTabId = shortId;
+                await this.saveTaskState(task.profile, conn.tasks);
+                return { tabId: shortId };
+            }
+        }
+        return undefined;
+    }
+    async navigateFirefox(conn, task, url, addTab = false) {
+        if (!addTab) {
+            const reopened = await this.reopenOwnedFirefoxTab(conn, task, url);
+            if (reopened) {
+                emit('browser.navigate', { profile: parseConnectionKey(task.profile).profile, task: task.name, url, tabId: reopened.tabId, created: false });
+                return { tabId: reopened.tabId, url, created: false, refreshed: true, message: 'Tab already open—refreshed' };
+            }
+            // Reuse the current tab when there is one — navigate() semantics.
+            const currentShortId = task.currentTabId;
+            if (currentShortId && task.tabs[currentShortId]) {
+                const context = task.tabs[currentShortId];
+                const live = await this.firefoxLiveContexts(conn);
+                if (live.has(context)) {
+                    await bidiNavigate(conn.bidi, context, url);
+                    await this.saveTaskState(task.profile, conn.tasks);
+                    emit('browser.navigate', { profile: parseConnectionKey(task.profile).profile, task: task.name, url, tabId: currentShortId, created: false });
+                    return { tabId: currentShortId, url, created: false, refreshed: false };
+                }
+            }
+        }
+        else {
+            const reopened = await this.reopenOwnedFirefoxTab(conn, task, url);
+            if (reopened) {
+                return { tabId: reopened.tabId, url, created: false, refreshed: true, message: 'Tab already open—refreshed' };
+            }
+        }
+        // Open a fresh tab.
+        const context = await bidiCreateTab(conn.bidi);
+        await bidiNavigate(conn.bidi, context, url);
+        const shortId = generateShortId();
+        task.tabs[shortId] = context;
+        task.currentTabId = shortId;
+        await this.saveTaskState(task.profile, conn.tasks);
+        emit('browser.navigate', { profile: parseConnectionKey(task.profile).profile, task: task.name, url, tabId: shortId, created: true });
+        return { tabId: shortId, url, created: true, refreshed: false };
+    }
+    async evaluateFirefox(conn, task, shortId, expression) {
+        const context = this.firefoxContext(task, shortId);
+        const live = await this.firefoxLiveContexts(conn);
+        if (!live.has(context))
+            throw new Error(`Tab ${shortId} is no longer open in Firefox.`);
+        return bidiEvaluate(conn.bidi, context, expression);
+    }
+    async listFirefoxTaskTabs(conn, task) {
+        const live = await bidiTopLevelContexts(conn.bidi);
+        const byId = new Map(live.map((c) => [c.context, c]));
+        const tabs = [];
+        for (const [shortId, context] of Object.entries(task.tabs)) {
+            const info = byId.get(context);
+            if (!info)
+                continue; // tab closed out from under the task — drop it silently.
+            let title = '';
+            try {
+                title = String(await bidiEvaluate(conn.bidi, context, 'document.title'));
+            }
+            catch {
+                /* about: pages or a mid-navigation context — url is enough */
+            }
+            tabs.push({ id: shortId, url: info.url, title, task: task.name, current: shortId === task.currentTabId });
+        }
+        return tabs;
+    }
+    /**
+     * Close every non-borrowed tab a Firefox task owns. Never kills the Firefox
+     * process (that is `stopProfile`'s job) — a killed browser would take the
+     * user's other tabs with it. A tab already gone is skipped.
+     */
+    async closeFirefoxTabs(conn, task) {
+        const borrowed = new Set(task.borrowedTabs ?? []);
+        const live = await this.firefoxLiveContexts(conn);
+        for (const [shortId, context] of Object.entries(task.tabs)) {
+            if (borrowed.has(shortId))
+                continue;
+            if (live.has(context)) {
+                try {
+                    await bidiCloseTab(conn.bidi, context);
+                }
+                catch { /* already closed */ }
+            }
+        }
+    }
+    /**
+     * Viewport-center coordinates of a selector-addressed element in a Firefox
+     * tab, scrolled into view first — the (x, y) `input.performActions` clicks.
+     * Throws when the element is gone or has zero size (off-screen / display:none).
+     */
+    async firefoxRefCoords(conn, task, shortId, selector) {
+        const expr = `(() => {
+      const el = document.querySelector(${JSON.stringify(selector)});
+      if (!el) throw new Error('DOM ref is missing');
+      el.scrollIntoView({ block: 'center', inline: 'center' });
+      const r = el.getBoundingClientRect();
+      if (r.width === 0 && r.height === 0) throw new Error('DOM ref has no layout box');
+      return JSON.stringify({ x: r.left + r.width / 2, y: r.top + r.height / 2 });
+    })()`;
+        const raw = await this.evaluateFirefox(conn, task, shortId, expr);
+        const parsed = JSON.parse(String(raw));
+        return parsed;
+    }
+    /**
+     * Screenshot a Firefox tab over BiDi. Same output contract as the CDP path:
+     * `raw` is a pixel-faithful PNG; the default is JPEG iteratively downscaled
+     * under 100 KB so chat-injected screenshots stay token-cheap.
+     */
+    async screenshotFirefox(conn, task, runtimeKey, tabHint, outputPath, quality) {
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const context = this.firefoxContext(task, shortId);
+        const live = await this.firefoxLiveContexts(conn);
+        if (!live.has(context))
+            throw new Error(`Tab ${shortId} is no longer open in Firefox.`);
+        let buffer;
+        let extension;
+        if (quality === 'raw') {
+            buffer = await bidiScreenshot(conn.bidi, context, { type: 'image/png' });
+            extension = 'png';
+        }
+        else {
+            buffer = await bidiScreenshot(conn.bidi, context, { type: 'image/jpeg', quality: 0.7 });
+            const MAX_SIZE = 100 * 1024;
+            let q = 0.5;
+            while (buffer.length > MAX_SIZE && q > 0.1) {
+                buffer = await bidiScreenshot(conn.bidi, context, { type: 'image/jpeg', quality: q });
+                q -= 0.1;
+            }
+            extension = 'jpg';
+        }
+        const sessionsDir = getProfileSessionsDir(runtimeKey, task.name);
+        const automaticPath = path.join(sessionsDir, `${Date.now()}.${extension}`);
+        const finalPath = resolveScreenshotOutputPath(outputPath, automaticPath);
+        await fs.promises.mkdir(path.dirname(finalPath), { recursive: true });
+        await fs.promises.writeFile(finalPath, buffer);
+        const dims = (extension === 'png' ? readPngDimensions(buffer) : readJpegDimensions(buffer)) ??
+            { width: 0, height: 0 };
+        emit('browser.screenshot', {
+            profile: parseConnectionKey(runtimeKey).profile,
+            task: task.name,
+            tabId: shortId,
+            path: finalPath,
+            bytes: buffer.length,
+            width: dims.width,
+            height: dims.height,
+            quality,
+        });
+        return { path: finalPath, bytes: buffer.length, width: dims.width, height: dims.height };
+    }
     /** Connect a profile at `target`, register it under `key`, and arm downloads. */
     async openConnection(profile, target, key, profileName, opts = {}) {
         const conn = await this.connectProfile(profile, target, key, opts);
         conn.key = key;
         conn.profile = profileName;
         this.connections.set(key, conn);
-        await this.applyDefaultDownloadBehavior(conn, key);
+        // Download behavior configuration is CDP-specific; skip for native Arc + Firefox.
+        if (conn.backend !== 'arc-native' && conn.backend !== 'bidi') {
+            await this.applyDefaultDownloadBehavior(conn, key);
+        }
         return conn;
     }
     /**
@@ -3402,6 +4395,9 @@ export class BrowserService {
             endpointName: opts.endpointName,
             probe: opts.probe,
         });
+        if (!routed.local && routed.commandDispatch) {
+            throw new Error(`Native Arc profile "${profileName}" is owned by ${routed.device}; dispatch the complete browser command there.`);
+        }
         const key = routed.key;
         const effectiveProfile = routed.profile;
         const reused = await this.reuseProfileConnection(profileName, key, routed.local);
@@ -3411,6 +4407,13 @@ export class BrowserService {
             adoptLegacyRuntimeIfLocal(routed.local, profileName, key, getBrowserRuntimeDir());
             conn = await this.openConnection(effectiveProfile, routed.target, key, profileName, { persistRemote: !routed.local });
         }
+        if (conn.backend === 'arc-native') {
+            throw new ArcNativeCapabilityError('show', 'Task-less viewer tabs are unavailable for native Arc because creation intent cannot be bound to an owning task.');
+        }
+        if (conn.backend === 'bidi') {
+            throw new FirefoxCapabilityError('show', 'Task-less viewer tabs are unavailable for a headless-automation Firefox profile. ' +
+                'Use a Chromium-family profile, or open the URL in your OS browser.');
+        }
         // createPageTarget refuses Arc with an actionable error rather than crashing it.
         const created = await this.createPageTarget(conn, { url });
         this.invalidateTargetCache(conn);