@phnx-labs/agents-cli 1.22.47 → 1.22.49

package/dist/lib/browser/runtime-state.js

@@ -1,8 +1,55 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { execFileSync } from 'child_process';
-import { getProfileRuntimeDir, getBrowserRuntimeDir, listProfilesWithScope, getConfiguredDefaultProfileName, isProfileLaunchableHere, deleteProfile, DEFAULT_BROWSER_PROFILE_NAME, LEGACY_DEFAULT_BROWSER_PROFILE_NAME, misfiledFleetProfile, } from './profiles.js';
+import { getProfileRuntimeDir, getBrowserRuntimeDir, getEndpointPresets, listProfiles, getConfiguredDefaultProfileName, isProfileLaunchableHere, deleteProfile, DEFAULT_BROWSER_PROFILE_NAME, LEGACY_DEFAULT_BROWSER_PROFILE_NAME, } from './profiles.js';
 import { keyBelongsToProfile } from './types.js';
+import { declaringDevices, profileKind } from './registry.js';
+import { machineId } from '../machine-id.js';
+/**
+ * Detect an identity-bearing profile whose stored endpoint is loopback, viewed
+ * from a machine that is NOT the declaring device.
+ *
+ * That is the original `comet-local` bug: five real logins on the declaring
+ * box, a bare logged-out chromium answering to the same name on a worker
+ * because `cdp://localhost:N` is evaluated on the machine running the command.
+ * The daemon now tunnels that shape (`resolve-target.ts`); doctor still flags
+ * it so a worker does not report a green local binary/port for someone else's
+ * browser. Kind comes from the registry (exactly one declaring device), never
+ * from a stored field.
+ */
+export function identityLoopbackMismatch(profile) {
+    if (profileKind(profile.name) !== 'identity')
+        return { misfiled: false };
+    const declaringDevice = declaringDevices(profile.name)[0];
+    if (!declaringDevice || declaringDevice === machineId())
+        return { misfiled: false };
+    const presets = getEndpointPresets(profile);
+    const chosen = profile.defaultEndpoint && presets[profile.defaultEndpoint]
+        ? profile.defaultEndpoint
+        : Object.keys(presets)[0];
+    if (!chosen)
+        return { misfiled: false };
+    const target = presets[chosen].target;
+    if (!target.startsWith('cdp://'))
+        return { misfiled: false };
+    let host;
+    try {
+        host = new URL(target).hostname;
+    }
+    catch {
+        return { misfiled: false };
+    }
+    if (host !== 'localhost' && host !== '127.0.0.1' && host !== '::1' && host !== '[::1]') {
+        return { misfiled: false };
+    }
+    const here = machineId();
+    return {
+        misfiled: true,
+        why: `identity-bearing profile declared on ${declaringDevice}, but "${target}" is a loopback endpoint — ` +
+            `on ${here} that address is this device's own browser, not ${declaringDevice}'s. ` +
+            `Diagnose the real browser on ${declaringDevice}: agents browser profiles doctor ${profile.name}`,
+    };
+}
 const PID_FILE = 'pid';
 const PORT_FILE = 'port';
 const COMMAND_FILE = 'command';
@@ -96,7 +143,7 @@ export function clearProfileRuntime(profileName) {
 }
 /**
  * Recursively remove the whole profile cache (chrome-data, tasks.json,
- * everything). Used by `profiles delete` so an old profile name doesn't
+ * everything). Used by `profiles remove` so an old profile name doesn't
  * leak its history into a freshly-recreated one.
  */
 export function removeProfileCache(profileName) {
@@ -298,8 +345,6 @@ export const PRUNE_REASON_TEXT = {
  *   - **the auto-detected profile** (`auto-chrome`, or the `default` an older
  *     build wrote) — auto-regenerated by `ensureDefaultBrowserProfile`, so
  *     pruning it is pure churn.
- *   - **fleet-synced** — deleting one removes it from EVERY machine, so it takes
- *     the explicit `includeFleet` opt-in.
  *
  * Known limitation: `BrowserProfileConfig` records no creation time, so a
  * profile created seconds ago and not yet started is indistinguishable from an
@@ -312,20 +357,15 @@ export function planProfilePrune(profiles, opts = {}) {
         const keep = (why, misfiled = false) => {
             plan.kept.push(misfiled ? { name, scope, why, misfiled } : { name, scope, why });
         };
-        // Checked FIRST, ahead of every other rule including --fleet. Deleting a
-        // fleet entry deletes it on EVERY machine, and a misfiled profile's defining
-        // symptom is that the browser is absent on whatever box you are standing on
-        // — so `prune --fleet` would otherwise read `binary-missing` and destroy it
-        // fleet-wide, which is the opposite of the repair. The repair is a scope
-        // move; an intentional delete is still available as `profiles delete`.
+        // Checked FIRST. A misfiled identity profile's defining symptom is that the
+        // browser is absent on whatever box you are standing on — pruning it would
+        // delete the declaring device's entry (or throw, for a peer declaration).
+        // The repair is to declare it only on the machine that owns the browser;
+        // an intentional delete is still available as `profiles remove`.
         if (misfiledWhy) {
             keep(`MISFILED — ${misfiledWhy}`, true);
             continue;
         }
-        if (scope === 'fleet' && !opts.includeFleet) {
-            keep('fleet-synced (pass --fleet to include it)');
-            continue;
-        }
         if (name === DEFAULT_BROWSER_PROFILE_NAME || name === LEGACY_DEFAULT_BROWSER_PROFILE_NAME) {
             keep('the auto-detected default profile');
             continue;
@@ -355,17 +395,44 @@ export function planProfilePrune(profiles, opts = {}) {
  * Build the prune plan from live config. Split from {@link planProfilePrune} so
  * the decision rules stay unit-testable without a configured machine.
  */
-export async function buildProfilePrunePlan(opts = {}) {
-    const scoped = await listProfilesWithScope();
-    return planProfilePrune(scoped.map(({ profile, scope }) => {
-        const misfiled = misfiledFleetProfile(profile, scope);
-        return {
-            name: profile.name,
-            scope,
-            launchableHere: isProfileLaunchableHere(profile),
-            misfiledWhy: misfiled.misfiled ? misfiled.why : undefined,
-        };
-    }), { includeFleet: opts.includeFleet, configuredDefault: getConfiguredDefaultProfileName() });
+export async function buildProfilePrunePlan() {
+    const current = machineId();
+    const profiles = await listProfiles();
+    const declaredHere = [];
+    const peerKept = [];
+    for (const profile of profiles) {
+        const scope = profile.devices.length > 1 ? 'fungible' : 'identity';
+        const misfiled = identityLoopbackMismatch(profile);
+        if (profile.devices.includes(current)) {
+            declaredHere.push({
+                name: profile.name,
+                scope,
+                launchableHere: isProfileLaunchableHere(profile),
+                misfiledWhy: misfiled.misfiled ? misfiled.why : undefined,
+            });
+            continue;
+        }
+        if (misfiled.misfiled) {
+            peerKept.push({
+                name: profile.name,
+                scope,
+                why: `MISFILED — ${misfiled.why}`,
+                misfiled: true,
+            });
+        }
+        else {
+            peerKept.push({
+                name: profile.name,
+                scope,
+                why: `declared on ${profile.devices.join(', ')}, not this device`,
+            });
+        }
+    }
+    const plan = planProfilePrune(declaredHere, {
+        configuredDefault: getConfiguredDefaultProfileName(),
+    });
+    plan.kept.push(...peerKept);
+    return plan;
 }
 /**
  * Execute a prune plan: drop each candidate's config entry and wipe its cache

package/dist/lib/browser/service.d.ts

@@ -1,4 +1,5 @@
 import { CDPClient } from './cdp.js';
+import { type DeviceProbe } from './resolve-target.js';
 import { type ResolvedDomainSkill } from './domain-skills.js';
 import { type Task, type TabInfo, type ProfileStatus, type BrowserType, type HistoricalTask, type ReapResult, type ProfileName, type ConnectionKey } from './types.js';
 import { type ReapOptions } from './hygiene.js';
@@ -136,7 +137,8 @@ export declare class BrowserService {
      * Live browsers, keyed by {@link ConnectionKey} — NOT by profile name. The
      * branded key type is what makes `connections.get(someProfileName)` (the
      * RUSH-2709 miss that made `status --profile <name>` return empty for a
-     * running `<name>@endpoint-0`) fail to compile.
+     * running `<name>@<device>`) fail to compile. Keys are `<profile>@<device>`
+     * (legacy leftover `<profile>@endpoint-N` dirs are still recognized).
      */
     private connections;
     private forkingProfiles;
@@ -165,6 +167,8 @@ export declare class BrowserService {
         fleetRemote?: boolean;
         /** Explicit human label (`--title`). */
         title?: string;
+        /** Injected reachability probe — production uses ssh; tests pass a fake. */
+        probe?: DeviceProbe;
     }): Promise<{
         task: string;
         name: string;
@@ -172,8 +176,12 @@ export declare class BrowserService {
         windowId?: string;
         /** BARE profile name — what the caller asked for, never the runtime key. */
         profile: ProfileName;
-        /** Runtime key the task actually landed on (`<profile>@<endpoint>`). */
+        /** Runtime key the task actually landed on (`<profile>@<device>`). */
         key: ConnectionKey;
+        /** Device the daemon connected to. */
+        device: string;
+        /** Set when the daemon picked a remote declaring device. */
+        picked?: string;
         skill?: ResolvedDomainSkill;
     }>;
     /**
@@ -240,7 +248,7 @@ export declare class BrowserService {
     /**
      * Close tasks whose owning agent session is gone, or that have sat untouched
      * past the idle window. The entry point the daemon's periodic tick and
-     * `agents browser gc` both call; the policy lives in `hygiene.ts`.
+     * `agents browser prune` both call; the policy lives in `hygiene.ts`.
      */
     reapAbandoned(opts?: ReapOptions): Promise<ReapResult>;
     stop(taskName: string): Promise<{
@@ -361,8 +369,9 @@ export declare class BrowserService {
      * `profileName` is a {@link ProfileName} — a BARE name, never a runtime key.
      * Every candidate is selected by the one rule ({@link keyBelongsToProfile}),
      * and a scoped query that finds no live connection falls through to disk, so
-     * `status --profile comet-local` reports the LIVE `comet-local@endpoint-0`
-     * instead of the empty list it used to return (RUSH-2709).
+     * `status --profile comet-local` reports the LIVE `comet-local@<device>`
+     * (and leftover `comet-local@endpoint-0` dirs) instead of the empty list
+     * it used to return (RUSH-2709).
      */
     status(profileRef?: ProfileName | ConnectionKey): Promise<ProfileStatus[]>;
     /**
@@ -438,10 +447,9 @@ export declare class BrowserService {
      * already resolved the endpoint and built the `effectiveProfile` with
      * the per-endpoint binary/targetFilter overrides applied; we just use it.
      *
-     * `key` is the runtime key (`<profile>@<endpoint>`) and is what every on-disk
-     * lookup uses, so per-endpoint pid/port files don't collide when the same app
-     * runs locally and remotely at the same time. It is a SEPARATE argument
-     * because `effectiveProfile.name` stays the bare, user-facing name (RUSH-2709).
+     * `key` is the runtime key (`<profile>@<device>`) and is what every on-disk
+     * lookup uses. It is a SEPARATE argument because `effectiveProfile.name`
+     * stays the bare, user-facing name (RUSH-2709).
      */
     private connectProfile;
     private connectEndpoint;
@@ -486,6 +494,8 @@ export declare class BrowserService {
         task: Task;
         key: ConnectionKey;
         created: boolean;
+        picked?: string;
+        device?: string;
     } | null>;
     private listTasksForCaller;
     private currentUrlHint;
@@ -550,6 +560,12 @@ export declare class BrowserService {
      * of killing the daemon.
      */
     private reuseHealthyConnection;
+    /**
+     * Reuse a live connection for this profile: the new `<name>@<device>` key
+     * first, then any leftover `<name>@endpoint-N` key still in the map so a
+     * browser started before the key collapse is not abandoned.
+     */
+    private reuseProfileConnection;
     /** Connect a profile at `target`, register it under `key`, and arm downloads. */
     private openConnection;
     /**
@@ -568,10 +584,13 @@ export declare class BrowserService {
         endpointName?: string;
         fleetRemote?: boolean;
         actor?: string;
+        probe?: DeviceProbe;
     }): Promise<{
         profile: ProfileName;
         key: ConnectionKey;
         tabId: string;
+        device: string;
+        picked?: string;
     }>;
     getHistory(limit?: number): Promise<HistoricalTask[]>;
 }

package/dist/lib/browser/service.js

@@ -7,9 +7,10 @@ import { killChrome, getRunningChromeInfo, launchBrowser, allocatePort } from '.
 import { assertRemoteControlAllowedForRequest } from './remote-control.js';
 import { connectLocal } from './drivers/local.js';
 import { connectSSH, shellQuote } from './drivers/ssh.js';
+import { adoptLegacyRuntimeIfLocal, isLegacyEndpointKey, resolveBrowserTarget, shouldForkProfile, } from './resolve-target.js';
 import { clearProfileRuntime, listProfileCacheDirs, readProfileRuntimeMeta, isProcessAlive } from './runtime-state.js';
 import { resolveDomainSkill } from './domain-skills.js';
-import { generateTaskId, generateShortId, connectionKey, asConnectionKey, parseConnectionKey, keyBelongsToProfile, } from './types.js';
+import { generateTaskId, generateShortId, asConnectionKey, parseConnectionKey, keyBelongsToProfile, } from './types.js';
 import { reapAbandonedTasks, resolveLiveIdentities, taskOwnerIsGone, } from './hygiene.js';
 import { taskMatchesCaller } from './caller-identity.js';
 import { getRefs, resolveRefToCoords, describeRefs, healRef } from './refs.js';
@@ -298,7 +299,8 @@ export class BrowserService {
      * Live browsers, keyed by {@link ConnectionKey} — NOT by profile name. The
      * branded key type is what makes `connections.get(someProfileName)` (the
      * RUSH-2709 miss that made `status --profile <name>` return empty for a
-     * running `<name>@endpoint-0`) fail to compile.
+     * running `<name>@<device>`) fail to compile. Keys are `<profile>@<device>`
+     * (legacy leftover `<profile>@endpoint-N` dirs are still recognized).
      */
     connections = new Map();
     forkingProfiles = new Set();
@@ -318,26 +320,16 @@ export class BrowserService {
         // page verbs that create a browser implicitly (navigate, click, screenshot,
         // …) able to open a browser on a machine whose owner never opted in.
         assertRemoteControlAllowedForRequest(opts.fleetRemote, { actor: opts.actor });
-        const profile = await getProfile(profileName);
-        if (!profile) {
-            throw new Error(`Profile "${profileName}" not found`);
-        }
-        // Pick the endpoint preset. Throws with the candidate list if the user
-        // passed an unknown name. The runtime key `<profile>@<endpoint>` is what
-        // the connection map + per-profile runtime dirs are keyed on, so a single
-        // YAML profile can run at multiple endpoints concurrently.
-        //
-        // `effectiveProfile.name` stays BARE. Overwriting it with the runtime key
-        // here (pre-RUSH-2709) is what leaked `comet-local@endpoint-0` into every
-        // listing and made `status --profile comet-local` miss its own browser.
-        // The key travels as its own argument instead.
-        const resolved = resolveEndpoint(profile, opts.endpointName);
-        const composite = connectionKey(profileName, resolved.name);
-        const effectiveProfile = {
-            ...profile,
-            binary: resolved.binary,
-            targetFilter: resolved.targetFilter,
-        };
+        // Registry decides WHERE. Three outcomes, no fourth: local if this
+        // device declares the name; tunnel to a declaring device otherwise;
+        // fail loud if nobody does. Never auto-create a local browser under a
+        // name that means a logged-in browser somewhere else.
+        const routed = resolveBrowserTarget(profileName, {
+            endpointName: opts.endpointName,
+            probe: opts.probe,
+        });
+        const composite = routed.key;
+        const effectiveProfile = routed.profile;
         const taskId = generateTaskId();
         let taskName;
         if (opts.taskName) {
@@ -351,9 +343,12 @@ export class BrowserService {
             taskName = taskId;
         }
         const taskLabel = deriveTaskLabel({ title: opts.title, url: opts.url });
-        let conn = await this.reuseHealthyConnection(composite);
-        let effectiveKey = composite;
-        if (conn && conn.electron && conn.tasks.size > 0) {
+        const reused = await this.reuseProfileConnection(profileName, composite, routed.local);
+        let conn = reused?.conn;
+        let effectiveKey = reused?.key ?? composite;
+        // Fork is a local Electron chrome-data mint. Never fork a tunnelled
+        // connection — that would launch a logged-out browser on THIS box.
+        if (conn && routed.local && shouldForkProfile(routed.kind, conn)) {
             if (this.forkingProfiles.has(composite)) {
                 while (this.forkingProfiles.has(composite)) {
                     await new Promise((r) => setTimeout(r, 50));
@@ -380,9 +375,14 @@ export class BrowserService {
             }
         }
         else if (!conn) {
-            conn = await this.openConnection(effectiveProfile, resolved.target, composite, profileName);
+            adoptLegacyRuntimeIfLocal(routed.local, profileName, composite, getBrowserRuntimeDir());
+            conn = await this.openConnection(effectiveProfile, routed.target, composite, profileName, { persistRemote: !routed.local });
+            effectiveKey = composite;
         }
-        if (conn && !conn.profile)
+        if (!conn) {
+            throw new Error(`Could not connect to profile "${profileName}"`);
+        }
+        if (!conn.profile)
             conn.profile = profileName;
         // Browsers launch with --no-startup-window (session-cookie persistence,
         // see launchBrowser), so a bare `start` with no --url would otherwise
@@ -503,7 +503,16 @@ export class BrowserService {
             if (resolved)
                 skill = resolved;
         }
-        return { task: taskId, name: taskName, tabId, profile: profileName, key: effectiveKey, skill };
+        return {
+            task: taskId,
+            name: taskName,
+            tabId,
+            profile: profileName,
+            key: effectiveKey,
+            device: routed.device,
+            picked: routed.picked,
+            skill,
+        };
     }
     /**
      * Reclaim a live page already showing `url` from an ABANDONED task, instead
@@ -656,7 +665,7 @@ export class BrowserService {
     /**
      * Close tasks whose owning agent session is gone, or that have sat untouched
      * past the idle window. The entry point the daemon's periodic tick and
-     * `agents browser gc` both call; the policy lives in `hygiene.ts`.
+     * `agents browser prune` both call; the policy lives in `hygiene.ts`.
      */
     async reapAbandoned(opts = {}) {
         return reapAbandonedTasks(this, opts);
@@ -736,7 +745,7 @@ export class BrowserService {
         return this.stop(taskName);
     }
     async stopProfile(profileRef) {
-        // Connections are keyed by the runtime key `<profile>@<endpoint>` (see
+        // Connections are keyed by the runtime key `<profile>@<device>` (see
         // start()) while callers pass the bare profile name (or, occasionally, an
         // exact key). A plain `connections.get(profileRef)` therefore missed every
         // real remote connection, so `cleanup()` never ran — leaving the SSH tunnel
@@ -1517,8 +1526,9 @@ export class BrowserService {
      * `profileName` is a {@link ProfileName} — a BARE name, never a runtime key.
      * Every candidate is selected by the one rule ({@link keyBelongsToProfile}),
      * and a scoped query that finds no live connection falls through to disk, so
-     * `status --profile comet-local` reports the LIVE `comet-local@endpoint-0`
-     * instead of the empty list it used to return (RUSH-2709).
+     * `status --profile comet-local` reports the LIVE `comet-local@<device>`
+     * (and leftover `comet-local@endpoint-0` dirs) instead of the empty list
+     * it used to return (RUSH-2709).
      */
     async status(profileRef) {
         // Reconnect live browsers after a daemon restart so status is not empty
@@ -2052,14 +2062,24 @@ export class BrowserService {
      * already resolved the endpoint and built the `effectiveProfile` with
      * the per-endpoint binary/targetFilter overrides applied; we just use it.
      *
-     * `key` is the runtime key (`<profile>@<endpoint>`) and is what every on-disk
-     * lookup uses, so per-endpoint pid/port files don't collide when the same app
-     * runs locally and remotely at the same time. It is a SEPARATE argument
-     * because `effectiveProfile.name` stays the bare, user-facing name (RUSH-2709).
+     * `key` is the runtime key (`<profile>@<device>`) and is what every on-disk
+     * lookup uses. It is a SEPARATE argument because `effectiveProfile.name`
+     * stays the bare, user-facing name (RUSH-2709).
      */
-    async connectProfile(effectiveProfile, target, key) {
+    async connectProfile(effectiveProfile, target, key, opts = {}) {
         const existingInfo = getRunningChromeInfo(key);
-        if (existingInfo) {
+        const tunnelled = opts.persistRemote || target.startsWith('ssh:');
+        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
+            // here is the original bug. Only a recorded SSH tunnel is ours to
+            // reuse, and connectSSH already does that via isOwnTunnel.
+            const meta = readProfileRuntimeMeta(key);
+            if (meta && meta.kind !== 'tunnel') {
+                clearProfileRuntime(key);
+            }
+        }
+        else if (existingInfo) {
             try {
                 const { wsUrl, browser } = await discoverBrowserWsUrl(existingInfo.port, 'localhost', effectiveProfile.name);
                 verifyBrowserIdentity(browser, effectiveProfile.browser, existingInfo.port);
@@ -2088,13 +2108,13 @@ export class BrowserService {
                 clearProfileRuntime(key);
             }
         }
-        const conn = await this.connectEndpoint(effectiveProfile, target, key);
+        const conn = await this.connectEndpoint(effectiveProfile, target, key, opts);
         if (!conn) {
             throw new Error(`Could not connect to endpoint ${target} for profile "${effectiveProfile.name}"`);
         }
         return conn;
     }
-    async connectEndpoint(profile, endpoint, key) {
+    async connectEndpoint(profile, endpoint, key, opts = {}) {
         const url = new URL(endpoint);
         if (url.protocol === 'cdp:') {
             const conn = await connectLocal(endpoint, profile, key);
@@ -2111,7 +2131,9 @@ export class BrowserService {
             };
         }
         if (url.protocol === 'ssh:') {
-            const conn = await connectSSH(endpoint, profile, key);
+            const conn = await connectSSH(endpoint, profile, key, {
+                persistRemote: opts.persistRemote,
+            });
             await this.enableDomains(conn.cdp);
             return {
                 cdp: conn.cdp,
@@ -2265,6 +2287,15 @@ export class BrowserService {
      *   - no handle, zero, !createIfMissing → return null (caller reports "nothing to close")
      */
     async resolveOrCreateTask(opts) {
+        // Consent gate — the one chokepoint every drive/mutate verb passes through.
+        // ipc.ts routes each PAGE_RESOLVE_VERB and CLOSE_VERB here via bindTask, so
+        // gating at the top refuses a fleet-remote ATTACH (an explicit --task, or a
+        // lone identity match) exactly as it already refused an implicit CREATE.
+        // Gating only the create branch below left tab-add/navigate/done on an
+        // already-running browser ungated, so a remote caller could drive the
+        // owner's authenticated profile with consent off (RUSH-3064). Read the
+        // per-request marker, never the daemon's env — see remote-control.ts.
+        assertRemoteControlAllowedForRequest(opts.fleetRemote, { actor: opts.actor });
         if (opts.task) {
             const found = await this.findTask(opts.task, opts.profile);
             return { ...found, created: false };
@@ -2298,10 +2329,10 @@ export class BrowserService {
         // Zero matches for this caller.
         if (!opts.createIfMissing)
             return null;
-        // Refuse BEFORE ensureDefaultBrowserProfile() below, which probes local
-        // browser installs and may CREATE and persist an `auto-chrome` profile — a
-        // refused request must not leave state behind on the target machine.
-        assertRemoteControlAllowedForRequest(opts.fleetRemote, { actor: opts.actor });
+        // The top-of-function consent gate already refused a fleet-remote create
+        // here — before ensureDefaultBrowserProfile() below can probe local browser
+        // installs and persist an `auto-chrome` profile — so a refused request never
+        // leaves state behind on the target machine.
         // Implicit start on the default / named profile.
         let profileName = opts.profile;
         if (!profileName) {
@@ -2317,7 +2348,12 @@ export class BrowserService {
             sessionId: opts.sessionId,
             title: opts.title,
         });
-        return { ...(await this.findTask(started.name, started.profile)), created: true };
+        return {
+            ...(await this.findTask(started.name, started.profile)),
+            created: true,
+            picked: started.picked,
+            device: started.device,
+        };
     }
     listTasksForCaller(caller) {
         const out = [];
@@ -2458,7 +2494,15 @@ export class BrowserService {
             return null;
         let resolved;
         try {
-            resolved = resolveEndpoint(profile, endpointFromKey);
+            // Legacy keys encode the preset (`endpoint-0`). New keys encode the
+            // declaring device, which is not a preset name — resolve via registry.
+            if (endpointFromKey && /^endpoint-\d+$/.test(endpointFromKey)) {
+                resolved = resolveEndpoint(profile, endpointFromKey);
+            }
+            else {
+                const routed = resolveBrowserTarget(bare);
+                resolved = { name: routed.device, target: routed.target };
+            }
         }
         catch {
             return null;
@@ -2851,9 +2895,35 @@ export class BrowserService {
         this.connections.delete(key);
         return undefined;
     }
+    /**
+     * Reuse a live connection for this profile: the new `<name>@<device>` key
+     * first, then any leftover `<name>@endpoint-N` key still in the map so a
+     * browser started before the key collapse is not abandoned.
+     */
+    async reuseProfileConnection(profileName, preferred, local) {
+        const preferredConn = await this.reuseHealthyConnection(preferred);
+        if (preferredConn)
+            return { conn: preferredConn, key: preferred };
+        // Leftover `@endpoint-N` connections are THIS machine's pre-T2 local
+        // browser. Reusing them on a tunnelled resolve is the original bug.
+        if (!local)
+            return undefined;
+        for (const key of [...this.connections.keys()]) {
+            if (key === preferred)
+                continue;
+            if (!isLegacyEndpointKey(key, profileName))
+                continue;
+            if (parseConnectionKey(key).fork !== undefined)
+                continue;
+            const conn = await this.reuseHealthyConnection(key);
+            if (conn)
+                return { conn, key };
+        }
+        return undefined;
+    }
     /** Connect a profile at `target`, register it under `key`, and arm downloads. */
-    async openConnection(profile, target, key, profileName) {
-        const conn = await this.connectProfile(profile, target, key);
+    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);
@@ -2876,22 +2946,29 @@ export class BrowserService {
         // Same consent gate as start(): this opens a browser, so a fleet-remote
         // caller needs the target machine's opt-in.
         assertRemoteControlAllowedForRequest(opts.fleetRemote, { actor: opts.actor });
-        const profile = await getProfile(profileName);
-        if (!profile)
-            throw new Error(`Profile "${profileName}" not found`);
-        const resolved = resolveEndpoint(profile, opts.endpointName);
-        const key = connectionKey(profileName, resolved.name);
-        const effectiveProfile = {
-            ...profile,
-            binary: resolved.binary,
-            targetFilter: resolved.targetFilter,
-        };
-        const conn = (await this.reuseHealthyConnection(key)) ??
-            (await this.openConnection(effectiveProfile, resolved.target, key, profileName));
+        const routed = resolveBrowserTarget(profileName, {
+            endpointName: opts.endpointName,
+            probe: opts.probe,
+        });
+        const key = routed.key;
+        const effectiveProfile = routed.profile;
+        const reused = await this.reuseProfileConnection(profileName, key, routed.local);
+        let conn = reused?.conn;
+        const effectiveKey = reused?.key ?? key;
+        if (!conn) {
+            adoptLegacyRuntimeIfLocal(routed.local, profileName, key, getBrowserRuntimeDir());
+            conn = await this.openConnection(effectiveProfile, routed.target, key, profileName, { persistRemote: !routed.local });
+        }
         // createPageTarget refuses Arc with an actionable error rather than crashing it.
         const created = await this.createPageTarget(conn, { url });
         this.invalidateTargetCache(conn);
-        return { profile: profileName, key, tabId: created.targetId };
+        return {
+            profile: profileName,
+            key: effectiveKey,
+            tabId: created.targetId,
+            device: routed.device,
+            picked: routed.picked,
+        };
     }
     async getHistory(limit = 10) {
         const historyFile = path.join(getBrowserRuntimeDir(), 'history.json');