@phnx-labs/agents-cli 1.22.92 → 1.22.94

package/dist/lib/browser/service.js

@@ -16,12 +16,14 @@ 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 { 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 +231,10 @@ 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();
+    }
     if (!conn.cdp.isOpen)
         return false;
     try {
@@ -242,6 +248,10 @@ async function isConnHealthy(conn, timeoutMs = 1000) {
         return false;
     }
 }
+function requireCdp(conn, capability) {
+    if (conn.backend === 'arc-native')
+        throw new ArcNativeCapabilityError(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 +304,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 +459,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 +536,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') {
             const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
             if (!targetInfos.some((t) => t.type === 'page')) {
                 const created = await this.createPageTarget(conn, {
@@ -538,13 +565,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') {
             const windowId = await this.getOrCreateWindow(conn);
             if (windowId) {
                 const shortId = generateShortId();
@@ -596,7 +633,7 @@ 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 !== 'arc-native' && !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 +644,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 +867,55 @@ 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
-                }
-                // 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 +931,10 @@ export class BrowserService {
                     });
                 }).catch(() => { });
                 if (conn.forkedFrom && conn.tasks.size === 0) {
-                    conn.cdp.close();
-                    killChrome(conn.pid);
+                    if (conn.backend !== 'arc-native') {
+                        conn.cdp.close();
+                        killChrome(conn.pid);
+                    }
                     conn.cleanup?.();
                     this.connections.delete(key);
                     clearProfileRuntime(key);
@@ -908,6 +966,16 @@ 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;
+            }
             conn.cdp.close();
             killChrome(conn.pid);
             conn.cleanup?.();
@@ -934,6 +1002,11 @@ 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);
+        }
+        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 +1108,10 @@ 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);
+        }
+        requireCdp(conn, 'createTab');
         if (conn.electron) {
             throw new Error('Electron apps do not support opening additional tabs');
         }
@@ -1057,12 +1134,27 @@ 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 };
+        }
         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 }));
+        }
+        requireCdp(conn, 'enumerate');
         const targets = (await conn.cdp.send('Target.getTargets'));
         const tabs = [];
         for (const [shortId, cdpId] of Object.entries(task.tabs)) {
@@ -1089,6 +1181,10 @@ 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`);
         // URL substring match
         const targets = (await conn.cdp.send('Target.getTargets'));
         const matches = [];
@@ -1121,12 +1217,16 @@ 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);
             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)
+                    : await this.getTabsForTask(conn.cdp, task);
                 allTabs.push(...tabs);
             }
         }
@@ -1134,6 +1234,30 @@ 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;
+        }
+        requireCdp(conn, 'closeTab');
         if (tabHint !== undefined) {
             const shortId = await this.resolveTabHint(conn, task, tabHint);
             const cdpId = task.tabs[shortId];
@@ -1170,6 +1294,10 @@ 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);
+        }
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target) {
@@ -1199,6 +1327,13 @@ 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.');
+        }
         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 +1394,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 +1423,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 +1625,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 +1710,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 +1725,13 @@ 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;
+        }
+        requireCdp(conn, 'enumerate');
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
@@ -1614,7 +1768,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 +1786,18 @@ 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 } : {};
+        }
+        requireCdp(conn, 'click');
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
@@ -1663,6 +1829,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 +1841,18 @@ 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;
+        }
+        requireCdp(conn, 'type');
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
@@ -1701,6 +1880,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 +1891,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 +1905,13 @@ 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;
+        }
+        requireCdp(conn, 'scroll');
         const cdpTargetId = this.getCdpTargetId(task, shortId);
         const target = await this.getTarget(conn, cdpTargetId);
         if (!target)
@@ -1733,6 +1921,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 +2072,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 +2153,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 +2172,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 +2225,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 +2245,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 +2319,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 +2397,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 +2426,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 +2482,8 @@ export class BrowserService {
             this.recordings.delete(taskId);
         }
         for (const [, conn] of this.connections) {
-            conn.cdp.close();
+            if (conn.backend !== 'arc-native')
+                conn.cdp.close();
             conn.cleanup?.();
         }
         this.connections.clear();
@@ -2310,6 +2509,7 @@ export class BrowserService {
         await cdp.connect(wsUrl);
         await this.enableDomains(cdp);
         const connection = {
+            backend: 'cdp',
             cdp,
             port,
             pid,
@@ -2357,6 +2557,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 +2590,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 +2607,7 @@ export class BrowserService {
             });
             await this.enableDomains(conn.cdp);
             return {
+                backend: 'cdp',
                 cdp: conn.cdp,
                 port: conn.port,
                 pid: conn.pid,
@@ -2427,6 +2630,7 @@ export class BrowserService {
             }
             await this.enableDomains(cdp);
             return {
+                backend: 'cdp',
                 cdp,
                 port: 0,
                 pid: 0,
@@ -2445,6 +2649,7 @@ export class BrowserService {
             await cdp.connect(wsUrl);
             await this.enableDomains(cdp);
             return {
+                backend: 'cdp',
                 cdp,
                 port,
                 pid: 0,
@@ -2455,6 +2660,32 @@ export class BrowserService {
                 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) {
@@ -2660,6 +2891,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 +3022,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 +3045,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 +3053,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 +3062,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 +3071,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 +3109,33 @@ 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,
+            };
+        }
         const existingInfo = getRunningChromeInfo(key);
         const parsed = parseEndpointUrl(resolved.target);
         const port = existingInfo?.port ?? parsed?.port;
@@ -2886,6 +3161,7 @@ export class BrowserService {
                         tasks.set(k, t);
                 }
                 return {
+                    backend: 'cdp',
                     cdp: conn.cdp,
                     port: conn.port,
                     pid: conn.pid,
@@ -2918,6 +3194,7 @@ export class BrowserService {
                     tasks.set(k, t);
             }
             const conn = {
+                backend: 'cdp',
                 cdp,
                 port,
                 pid: existingInfo?.pid ?? 0,
@@ -2975,10 +3252,12 @@ 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();
+            if (conn.backend !== 'arc-native') {
+                try {
+                    conn.cdp.close();
+                }
+                catch { /* best effort */ }
             }
-            catch { /* best effort */ }
         }
         return existing;
     }
@@ -3019,7 +3298,8 @@ export class BrowserService {
             if (registered !== conn)
                 continue;
             try {
-                await this.applyDefaultDownloadBehavior(conn, key);
+                if (conn.backend !== 'arc-native')
+                    await this.applyDefaultDownloadBehavior(conn, key);
             }
             catch {
                 // Non-fatal for rehydrate.
@@ -3080,7 +3360,8 @@ export class BrowserService {
                 conn = this.registerRehydratedConnection(key, attached);
                 if (conn === attached) {
                     try {
-                        await this.applyDefaultDownloadBehavior(conn, key);
+                        if (conn.backend !== 'arc-native')
+                            await this.applyDefaultDownloadBehavior(conn, key);
                     }
                     catch {
                         // Non-fatal.
@@ -3117,6 +3398,41 @@ 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,
+            };
+        }
         // Fetch all targets once for efficiency
         let targets = [];
         try {
@@ -3339,10 +3655,12 @@ export class BrowserService {
             return undefined;
         if (await isConnHealthy(conn))
             return conn;
-        try {
-            conn.cdp.close();
+        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 +3691,219 @@ 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;
+        });
+    }
     /** 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.
+        if (conn.backend !== 'arc-native') {
+            await this.applyDefaultDownloadBehavior(conn, key);
+        }
         return conn;
     }
     /**
@@ -3402,6 +3926,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 +3938,9 @@ 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.');
+        }
         // createPageTarget refuses Arc with an actionable error rather than crashing it.
         const created = await this.createPageTarget(conn, { url });
         this.invalidateTargetCache(conn);