@phnx-labs/agents-cli 1.22.40 → 1.22.42

package/dist/lib/browser/service.js

@@ -8,7 +8,7 @@ import { connectLocal } from './drivers/local.js';
 import { connectSSH, shellQuote } from './drivers/ssh.js';
 import { clearProfileRuntime, listProfileCacheDirs, readProfileRuntimeMeta, isProcessAlive } from './runtime-state.js';
 import { resolveDomainSkill } from './domain-skills.js';
-import { generateTaskId, generateShortId, } from './types.js';
+import { generateTaskId, generateShortId, connectionKey, 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';
@@ -243,6 +243,17 @@ async function isConnHealthy(conn, timeoutMs = 1000) {
 export function actionable(...lines) {
     return lines.filter((l) => l != null && l !== '').join('\n');
 }
+/**
+ * Arc answers `Browser.getVersion` (so a connection succeeds) but exposes zero
+ * CDP page targets via every discovery method and CRASHES when a new tab is
+ * requested via `Target.createTarget` (verified live, PR #2778). It is therefore
+ * not drivable. This is the single clear, actionable error every tab-creating
+ * path throws instead of crashing the user's Arc window.
+ */
+export function arcNotDrivableError(profileName) {
+    const scope = profileName ? ` (profile "${profileName}")` : '';
+    return new Error(actionable(`Browser "arc"${scope} is not drivable: Arc exposes no CDP page targets and`, 'crashes when a new tab is requested, so `agents browser` cannot control it.', 'Use a Chromium-family browser instead — Comet, Chrome, Chromium, or Brave:', '  agents browser profiles create <name> --browser comet'));
+}
 /** Derive a human label from an explicit title or a navigated URL. */
 export function deriveTaskLabel(opts) {
     if (opts.title?.trim())
@@ -261,14 +272,6 @@ export function deriveTaskLabel(opts) {
     }
     return opts.existing ?? 'untitled';
 }
-/**
- * True when `key` is the bare profile name or one of its composite endpoint
- * keys (`name@endpoint`). Used by status/stop so `comet-local` matches
- * `comet-local@endpoint-0`.
- */
-export function connectionKeyMatchesProfile(key, profileName) {
-    return key === profileName || key.startsWith(`${profileName}@`) || key.startsWith(`${profileName}.`);
-}
 /**
  * Resolve the identity stamped on a task at start: WHO (`owner`) and WHICH run
  * (`launchId`). The forwarded values come from the caller's own CLI process and
@@ -290,6 +293,12 @@ export class BrowserService {
         'rush-app': 'rush-app-',
         'rush-cli': 'rush-cli-',
     };
+    /**
+     * 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.
+     */
     connections = new Map();
     forkingProfiles = new Set();
     // Per-task storage for console, errors, network, downloads
@@ -308,19 +317,18 @@ export class BrowserService {
             throw new Error(`Profile "${profileName}" not found`);
         }
         // Pick the endpoint preset. Throws with the candidate list if the user
-        // passed an unknown name. The composite identifier `<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.
+        // 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.
         //
-        // The YAML profile's bare `name` stays on `profile.name` for status
-        // matching; only the connection/runtime key uses the composite.
+        // `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 = `${profileName}@${resolved.name}`;
+        const composite = connectionKey(profileName, resolved.name);
         const effectiveProfile = {
             ...profile,
-            // Runtime/connect path key — NOT the bare YAML name. Connections and
-            // tasks.json live under this composite so multi-endpoint is safe.
-            name: composite,
             binary: resolved.binary,
             targetFilter: resolved.targetFilter,
         };
@@ -338,7 +346,7 @@ export class BrowserService {
         }
         const taskLabel = deriveTaskLabel({ title: opts.title, url: opts.url });
         let conn = this.connections.get(composite);
-        let effectiveProfileName = composite;
+        let effectiveKey = composite;
         // If we have a cached connection, confirm it's still usable before any
         // caller relies on it. A browser killed externally (Cmd-Q, crash, or a
         // user clearing the profile by hand) leaves a closed WebSocket here.
@@ -361,7 +369,7 @@ export class BrowserService {
                 const existingFork = this.findAvailableFork(composite);
                 if (existingFork) {
                     conn = existingFork.conn;
-                    effectiveProfileName = existingFork.name;
+                    effectiveKey = existingFork.name;
                 }
                 else {
                     throw new Error(`Fork in progress but no available fork found for "${composite}"`);
@@ -370,9 +378,9 @@ export class BrowserService {
             else {
                 this.forkingProfiles.add(composite);
                 try {
-                    const { forkName, connection } = await this.forkElectronProfile(effectiveProfile);
+                    const { forkName, connection } = await this.forkElectronProfile(effectiveProfile, composite);
                     conn = connection;
-                    effectiveProfileName = forkName;
+                    effectiveKey = forkName;
                 }
                 finally {
                     this.forkingProfiles.delete(composite);
@@ -380,14 +388,14 @@ export class BrowserService {
             }
         }
         else if (!conn) {
-            conn = await this.connectProfile(effectiveProfile, resolved.target);
-            conn.profileName = composite;
-            conn.bareName = profileName;
+            conn = await this.connectProfile(effectiveProfile, resolved.target, composite);
+            conn.key = composite;
+            conn.profile = profileName;
             this.connections.set(composite, conn);
             await this.applyDefaultDownloadBehavior(conn, composite);
         }
-        if (conn && !conn.bareName)
-            conn.bareName = profileName;
+        if (conn && !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
         // leave the user staring at a process with zero windows. Recreate the
@@ -404,9 +412,9 @@ export class BrowserService {
         if (!opts.url && !conn.electron) {
             const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
             if (!targetInfos.some((t) => t.type === 'page')) {
-                const created = (await conn.cdp.send('Target.createTarget', {
+                const created = await this.createPageTarget(conn, {
                     url: 'about:blank',
-                }));
+                });
                 startupBlankTargetId = created.targetId;
                 this.invalidateTargetCache(conn);
             }
@@ -416,7 +424,7 @@ export class BrowserService {
             id: taskId,
             name: taskName,
             label: taskLabel,
-            profile: effectiveProfileName,
+            profile: effectiveKey,
             tabs: {},
             currentTabId: undefined,
             createdAt: now,
@@ -445,7 +453,7 @@ export class BrowserService {
             }
         }
         conn.tasks.set(taskName, task);
-        await this.saveTaskState(effectiveProfileName, conn.tasks);
+        await this.saveTaskState(effectiveKey, conn.tasks);
         // Durable identity, written ONCE at start and never deleted (RUSH-2549).
         // tasks.json above stays live state: `stop` drops the task from that map, so
         // anything recorded only there is gone the moment the task ends -- which is
@@ -459,22 +467,23 @@ export class BrowserService {
         try {
             recordBrowserSession({
                 task: taskName,
-                profile: effectiveProfileName,
+                profile: effectiveKey,
                 sessionId: task.sessionId,
                 launchId: task.launchId,
                 actor: task.owner,
                 startedAt: task.createdAt,
-                captureDir: getProfileSessionsDir(effectiveProfileName, taskName),
+                captureDir: getProfileSessionsDir(effectiveKey, taskName),
             });
         }
         catch {
             // Recording is best-effort; the task itself is live either way.
         }
-        emit('browser.launch', { profile: effectiveProfileName, task: taskName, pid: conn.pid });
+        // Feed events and the usage rollup are read by humans: bare name only.
+        emit('browser.launch', { profile: profileName, task: taskName, pid: conn.pid });
         void import('../analytics/usage-db.js').then(({ recordUsage }) => {
             recordUsage({
                 kind: 'browser',
-                name: effectiveProfileName,
+                name: profileName,
                 event: 'launch',
                 source: 'browser',
                 meta: { task: taskName },
@@ -485,19 +494,16 @@ export class BrowserService {
         let tabId;
         if (opts.url && !conn.electron) {
             const adopted = opts.fresh ? undefined : await this.adoptTabShowing(conn, opts.url);
-            const targetId = adopted ??
-                (await conn.cdp.send('Target.createTarget', {
-                    url: opts.url,
-                })).targetId;
+            const targetId = adopted ?? (await this.createPageTarget(conn, { url: opts.url })).targetId;
             const shortId = generateShortId();
             task.tabs[shortId] = targetId;
             task.currentTabId = shortId;
             this.invalidateTargetCache(conn);
-            await this.saveTaskState(effectiveProfileName, conn.tasks);
+            await this.saveTaskState(effectiveKey, conn.tasks);
             tabId = shortId;
         }
         else if (opts.url && conn.electron) {
-            const result = await this.navigate(taskName, opts.url, effectiveProfileName);
+            const result = await this.navigate(taskName, opts.url, effectiveKey);
             tabId = result.tabId;
         }
         // Domain-skill discovery: when a URL is supplied, look up site-specific
@@ -509,7 +515,7 @@ export class BrowserService {
             if (resolved)
                 skill = resolved;
         }
-        return { task: taskId, name: taskName, tabId, profile: effectiveProfileName, skill };
+        return { task: taskId, name: taskName, tabId, profile: profileName, key: effectiveKey, skill };
     }
     /**
      * Reclaim a live page already showing `url` from an ABANDONED task, instead
@@ -543,6 +549,50 @@ export class BrowserService {
      * page that has since redirected elsewhere simply does not match, and the
      * caller opens a tab as before.
      */
+    /** Is this CDP target already registered to any task on the connection? */
+    targetIsClaimed(conn, targetId) {
+        for (const t of conn.tasks.values()) {
+            if (Object.values(t.tabs).includes(targetId))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * The CDP targets a task may CLOSE — its own tabs minus any it merely
+     * borrowed. A borrowed tab existed before the task did (see `Task.borrowedTabs`),
+     * so closing it would remove something the task never opened.
+     */
+    closeableTargetIds(task) {
+        const borrowed = new Set(task.borrowedTabs ?? []);
+        return Object.entries(task.tabs)
+            .filter(([shortId]) => !borrowed.has(shortId))
+            .map(([, cdpId]) => cdpId);
+    }
+    /**
+     * A page target that `navigate` may take over on a browser which cannot create
+     * tabs (Arc). Deliberately narrow: only a tab ALREADY showing the requested URL
+     * -- re-showing that document there is what the caller asked for -- or an empty
+     * new-tab page. A target any task already owns is left alone. Note the honest
+     * limit: reusing a matching tab still RELOADS it, discarding scroll position and
+     * unsaved form state. Arc cannot open a tab at all, so some intrusion is
+     * unavoidable to show the document; a reload is the smallest one, and the tab is
+     * borrowed rather than owned so it is never closed.
+     */
+    async pickReusableTargetWithoutCreate(conn, url) {
+        const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
+        const owned = new Set();
+        for (const t of conn.tasks.values()) {
+            for (const id of Object.values(t.tabs))
+                owned.add(id);
+        }
+        const free = targetInfos.filter((t) => t.type === 'page' && !owned.has(t.targetId));
+        const wanted = canonicalTabUrl(url);
+        const sameUrl = free.find((t) => canonicalTabUrl(t.url) === wanted);
+        if (sameUrl)
+            return sameUrl.targetId;
+        const BLANK = new Set(['', 'about:blank', 'about:newtab', 'chrome://newtab/', 'chrome://new-tab-page/']);
+        return free.find((t) => BLANK.has(t.url))?.targetId;
+    }
     async adoptTabShowing(conn, url) {
         const { targetInfos } = (await conn.cdp.send('Target.getTargets'));
         const wanted = canonicalTabUrl(url);
@@ -553,7 +603,15 @@ export class BrowserService {
             return undefined;
         const candidates = [];
         for (const task of conn.tasks.values()) {
+            const borrowed = new Set(task.borrowedTabs ?? []);
             for (const [shortId, cdpId] of Object.entries(task.tabs)) {
+                // A BORROWED tab is not ours to hand on. The dead task never opened it
+                // (Task.borrowedTabs) -- reclaiming it would register a pre-existing tab
+                // as a fresh task's own, and that task's `done` would close it. Exactly
+                // the "adopting it would make this task's `done` close the user's tab"
+                // case above, arriving one hop later via reclaim instead of directly.
+                if (borrowed.has(shortId))
+                    continue;
                 if (matching.has(cdpId))
                     candidates.push({ task, shortId, targetId: cdpId });
             }
@@ -602,7 +660,7 @@ export class BrowserService {
         const out = [];
         for (const [key, conn] of this.connections) {
             for (const task of conn.tasks.values()) {
-                out.push({ profile: conn.profileName ?? key, task });
+                out.push({ profile: conn.key ?? key, task });
             }
         }
         return out;
@@ -623,7 +681,7 @@ export class BrowserService {
         catch {
             // findTask throws when truly gone; fall through to the miss return.
         }
-        for (const [profileName, conn] of this.connections) {
+        for (const [key, conn] of this.connections) {
             const task = this.lookupTaskOnConn(conn, taskName);
             if (task) {
                 // Map key may be task.name, not the caller-supplied handle.
@@ -651,8 +709,9 @@ export class BrowserService {
                 }
                 // Save to history before closing
                 await this.saveToHistory(task, Array.from(domains));
-                // Close task's tabs (not the window - it's shared)
-                await Promise.all(Object.values(task.tabs).map((cdpId) => conn.cdp.send('Target.closeTarget', { targetId: cdpId }).catch(() => {
+                // 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)) {
@@ -660,12 +719,14 @@ export class BrowserService {
                 }
                 this.invalidateTargetCache(conn);
                 conn.tasks.delete(mapKey);
-                await this.saveTaskState(profileName, conn.tasks);
-                emit('browser.close', { profile: profileName, task: task.name });
+                await this.saveTaskState(key, conn.tasks);
+                // Feed + usage rows are read by humans: bare profile name (RUSH-2709).
+                const bareProfile = conn.profile ?? parseConnectionKey(key).profile;
+                emit('browser.close', { profile: bareProfile, task: task.name });
                 void import('../analytics/usage-db.js').then(({ recordUsage }) => {
                     recordUsage({
                         kind: 'browser',
-                        name: profileName,
+                        name: bareProfile,
                         event: 'close',
                         source: 'browser',
                         meta: { task: task.name },
@@ -675,10 +736,10 @@ export class BrowserService {
                     conn.cdp.close();
                     killChrome(conn.pid);
                     conn.cleanup?.();
-                    this.connections.delete(profileName);
-                    clearProfileRuntime(profileName);
+                    this.connections.delete(key);
+                    clearProfileRuntime(key);
                 }
-                return { ok: true, profile: profileName };
+                return { ok: true, profile: bareProfile };
             }
         }
         return { ok: false };
@@ -686,16 +747,15 @@ export class BrowserService {
     async done(taskName) {
         return this.stop(taskName);
     }
-    async stopProfile(profileName) {
-        // Connections are keyed by the composite `<profile>@<endpoint>` (see start()),
-        // but callers pass the bare profile name (or, occasionally, an exact composite).
-        // A plain `connections.get(profileName)` therefore missed every real remote
-        // connection, so `cleanup()` never ran — leaving the SSH tunnel and, on
-        // Windows, the WMI-spawned browser orphaned on the remote host after every
-        // `browser stop --profile` (#559). Match the exact key AND every
-        // `<profileName>@<endpoint>` composite so all of a profile's live connections
-        // are torn down.
-        const keys = [...this.connections.keys()].filter((k) => k === profileName || k.startsWith(`${profileName}@`));
+    async stopProfile(profileRef) {
+        // Connections are keyed by the runtime key `<profile>@<endpoint>` (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
+        // and, on Windows, the WMI-spawned browser orphaned on the remote host after
+        // every `browser stop --profile` (#559). Same single rule as findTask and
+        // status: exact key, else every key belonging to that profile.
+        const keys = [...this.connections.keys()].filter((k) => k === profileRef || keyBelongsToProfile(k, profileRef));
         for (const key of keys) {
             const conn = this.connections.get(key);
             if (!conn)
@@ -709,7 +769,7 @@ export class BrowserService {
         // Kill stale processes and clean runtime dirs for every composite and
         // fork entry belonging to this profile (including `.N` forks left by
         // earlier daemon sessions that the connection loop above didn't cover).
-        for (const dir of listProfileCacheDirs(profileName)) {
+        for (const dir of listProfileCacheDirs(parseConnectionKey(profileRef).profile)) {
             const dirName = path.basename(dir);
             const meta = readProfileRuntimeMeta(dirName);
             if (meta?.pid && meta.pid !== 0 && isProcessAlive(meta.pid, meta.command)) {
@@ -718,8 +778,8 @@ export class BrowserService {
             clearProfileRuntime(dirName);
         }
     }
-    async navigate(taskId, url, profileName) {
-        const { conn, task } = await this.findTask(taskId, profileName);
+    async navigate(taskId, url, profileRef) {
+        const { conn, task } = await this.findTask(taskId, profileRef);
         this.maybeUpdateLabelFromUrl(conn, task, url);
         // If we have a current tab, navigate in it (reuse)
         const currentShortId = task.currentTabId;
@@ -728,7 +788,7 @@ export class BrowserService {
             const sessionId = await this.getSessionId(conn, cdpTargetId);
             await conn.cdp.send('Page.navigate', { url }, sessionId);
             await this.saveTaskState(task.profile, conn.tasks);
-            emit('browser.navigate', { profile: task.profile, task: task.name, url, tabId: currentShortId, created: false });
+            emit('browser.navigate', { profile: parseConnectionKey(task.profile).profile, task: task.name, url, tabId: currentShortId, created: false });
             return { tabId: currentShortId, url, created: false };
         }
         // No current tab - create one
@@ -743,29 +803,77 @@ export class BrowserService {
             task.tabs[shortId] = cdpTargetId;
             task.currentTabId = shortId;
             await this.saveTaskState(task.profile, conn.tasks);
-            emit('browser.navigate', { profile: task.profile, task: task.name, url, tabId: shortId, created: true });
+            emit('browser.navigate', { profile: parseConnectionKey(task.profile).profile, task: task.name, url, tabId: shortId, created: true });
             return { tabId: shortId, url, created: true };
         }
+        // Arc exposes page targets and honors Page.navigate on them; what it cannot
+        // survive is Target.createTarget (#2778). createPageTarget below therefore
+        // refuses outright, so the document never gets shown AT ALL and callers fall
+        // back to a raw `open` -- a new tab every call, which is the tab-spam #2779
+        // set out to end. Reuse in place instead, the same shape as the Electron
+        // branch above. Measured against a live Arc (#2786): 33 page targets,
+        // Page.navigate reused one, tab count unchanged, no crash.
+        if (conn.browserType === 'arc') {
+            const reusable = await this.pickReusableTargetWithoutCreate(conn, url);
+            if (reusable) {
+                const shortId = generateShortId();
+                const sessionId = await this.getSessionId(conn, reusable);
+                // Check and CLAIM in one synchronous tick, with no await between them --
+                // the ordering `adoptTabShowing` uses (service.ts: the `task.tabs[shortId]
+                // !== targetId` re-check sits immediately before its `delete`). Checking
+                // and then awaiting `Page.navigate` before writing leaves exactly the gap
+                // the check exists to close: a concurrent navigate passes its own check in
+                // that window and both tasks end up driving one tab.
+                if (this.targetIsClaimed(conn, reusable)) {
+                    throw arcNotDrivableError(conn.profile);
+                }
+                task.tabs[shortId] = reusable;
+                // Borrowed, not opened: this tab was in the browser before the task and
+                // must survive `done`. See Task.borrowedTabs.
+                task.borrowedTabs = [...(task.borrowedTabs ?? []), shortId];
+                task.currentTabId = shortId;
+                try {
+                    await conn.cdp.send('Page.navigate', { url }, sessionId);
+                }
+                catch (err) {
+                    // Release the claim we took optimistically, so a failed navigate does
+                    // not leave the task holding a tab it never drove.
+                    delete task.tabs[shortId];
+                    task.borrowedTabs = (task.borrowedTabs ?? []).filter((id) => id !== shortId);
+                    if (task.currentTabId === shortId)
+                        task.currentTabId = undefined;
+                    throw err;
+                }
+                this.invalidateTargetCache(conn);
+                await this.saveTaskState(task.profile, conn.tasks);
+                emit('browser.navigate', {
+                    profile: task.profile,
+                    task: task.name,
+                    url,
+                    tabId: shortId,
+                    created: false,
+                });
+                return { tabId: shortId, url, created: false };
+            }
+            // Nothing safe to reuse -- fall through to the actionable refusal rather
+            // than taking over a page the user is reading.
+        }
         // Chrome: create new tab
-        const result = (await conn.cdp.send('Target.createTarget', {
-            url,
-        }));
+        const result = await this.createPageTarget(conn, { url });
         const shortId = generateShortId();
         task.tabs[shortId] = result.targetId;
         task.currentTabId = shortId;
         this.invalidateTargetCache(conn);
         await this.saveTaskState(task.profile, conn.tasks);
-        emit('browser.navigate', { profile: task.profile, task: task.name, url, tabId: shortId, created: true });
+        emit('browser.navigate', { profile: parseConnectionKey(task.profile).profile, task: task.name, url, tabId: shortId, created: true });
         return { tabId: shortId, url, created: true };
     }
-    async tabAdd(taskId, url, profileName) {
-        const { conn, task } = await this.findTask(taskId, profileName);
+    async tabAdd(taskId, url, profileRef) {
+        const { conn, task } = await this.findTask(taskId, profileRef);
         if (conn.electron) {
             throw new Error('Electron apps do not support opening additional tabs');
         }
-        const result = (await conn.cdp.send('Target.createTarget', {
-            url,
-        }));
+        const result = await this.createPageTarget(conn, { url });
         const shortId = generateShortId();
         task.tabs[shortId] = result.targetId;
         task.currentTabId = shortId; // new tab becomes current
@@ -837,9 +945,9 @@ export class BrowserService {
             throw new Error(`Tab ${shortId} not found`);
         return cdpId;
     }
-    async tabs(taskId, profileName) {
+    async tabs(taskId, profileRef) {
         if (taskId) {
-            const { conn, task } = await this.findTask(taskId, profileName);
+            const { conn, task } = await this.findTask(taskId, profileRef);
             return this.getTabsForTask(conn.cdp, task);
         }
         const allTabs = [];
@@ -857,9 +965,15 @@ export class BrowserService {
             const shortId = await this.resolveTabHint(conn, task, tabHint);
             const cdpId = task.tabs[shortId];
             if (cdpId) {
-                await conn.cdp.send('Target.closeTarget', { targetId: cdpId });
+                // A borrowed tab is released, not closed — it outlives this task.
+                if (!(task.borrowedTabs ?? []).includes(shortId)) {
+                    await conn.cdp.send('Target.closeTarget', { targetId: cdpId });
+                }
                 conn.sessionCache.delete(cdpId);
                 delete task.tabs[shortId];
+                // Drop the borrow record with the tab it names, or it outlives every tab
+                // it ever described and grows unbounded in the persisted task state.
+                task.borrowedTabs = (task.borrowedTabs ?? []).filter((id) => id !== shortId);
                 // Update currentTabId if we closed the current tab
                 if (task.currentTabId === shortId) {
                     const remaining = Object.keys(task.tabs);
@@ -868,12 +982,13 @@ export class BrowserService {
             }
         }
         else {
-            // Close all tabs
-            await Promise.all(Object.values(task.tabs).map((cdpId) => conn.cdp.send('Target.closeTarget', { targetId: cdpId }).catch(() => { })));
+            // Close all tabs the task opened; borrowed ones are only released.
+            await Promise.all(this.closeableTargetIds(task).map((cdpId) => conn.cdp.send('Target.closeTarget', { targetId: cdpId }).catch(() => { })));
             for (const cdpId of Object.values(task.tabs)) {
                 conn.sessionCache.delete(cdpId);
             }
             task.tabs = {};
+            task.borrowedTabs = [];
             task.currentTabId = undefined;
         }
         this.invalidateTargetCache(conn);
@@ -910,7 +1025,7 @@ export class BrowserService {
         return result.result.value;
     }
     async screenshot(taskId, tabHint, outputPath, quality = 'compressed') {
-        const { conn, task, profileName } = await this.findTask(taskId);
+        const { conn, task, key: runtimeKey } = await this.findTask(taskId);
         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);
@@ -943,7 +1058,7 @@ export class BrowserService {
             }
             extension = 'jpg';
         }
-        const sessionsDir = getProfileSessionsDir(profileName, task.name);
+        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 });
@@ -951,7 +1066,7 @@ export class BrowserService {
         const dims = (extension === 'png' ? readPngDimensions(buffer) : readJpegDimensions(buffer)) ??
             { width: 0, height: 0 };
         emit('browser.screenshot', {
-            profile: profileName,
+            profile: parseConnectionKey(runtimeKey).profile,
             task: task.name,
             tabId: shortId,
             path: finalPath,
@@ -970,7 +1085,7 @@ export class BrowserService {
      * — without it, dark-mode pages render on a blank sheet.
      */
     async printToPdf(taskId, tabHint, outputPath) {
-        const { conn, task, profileName } = await this.findTask(taskId);
+        const { conn, task, key: runtimeKey } = await this.findTask(taskId);
         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);
@@ -980,7 +1095,7 @@ export class BrowserService {
         const sessionId = await this.getSessionId(conn, target.targetId);
         const { data } = (await conn.cdp.send('Page.printToPDF', { printBackground: true, preferCSSPageSize: true }, sessionId));
         const buffer = Buffer.from(data, 'base64');
-        const sessionsDir = getProfileSessionsDir(profileName, task.name);
+        const sessionsDir = getProfileSessionsDir(runtimeKey, task.name);
         const automaticPath = path.join(sessionsDir, `${Date.now()}.pdf`);
         const finalPath = resolveScreenshotOutputPath(outputPath, automaticPath);
         await fs.promises.mkdir(path.dirname(finalPath), { recursive: true });
@@ -998,7 +1113,7 @@ export class BrowserService {
         if (this.recordings.has(taskId)) {
             throw new Error(`Task "${taskId}" is already recording. Call record stop first.`);
         }
-        const { conn, task, profileName } = await this.findTask(taskId);
+        const { conn, task, key: runtimeKey } = await this.findTask(taskId);
         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);
@@ -1014,7 +1129,7 @@ export class BrowserService {
             throw new Error('--duration must be between 1 and 3600 seconds');
         if (maxMb < 1 || maxMb > 500)
             throw new Error('--max-mb must be between 1 and 500');
-        const recordingsDir = path.join(getProfileSessionsDir(profileName, task.name), 'recordings');
+        const recordingsDir = path.join(getProfileSessionsDir(runtimeKey, task.name), 'recordings');
         await fs.promises.mkdir(recordingsDir, { recursive: true });
         const outputPath = path.join(recordingsDir, `${Date.now()}.webm`);
         // Resolve ffmpeg lazily so non-recording paths don't pay the import cost.
@@ -1408,34 +1523,37 @@ export class BrowserService {
     stageUpload(source) {
         return { path: stageUploadFile(source) };
     }
-    async status(profileName) {
+    /**
+     * Status for one profile (bare name) or every live profile.
+     *
+     * `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).
+     */
+    async status(profileRef) {
         // Reconnect live browsers after a daemon restart so status is not empty
         // while tasks.json still holds open work.
         await this.rehydrateAllFromDisk();
-        const seen = new Set();
+        // A caller who pasted a runtime key out of an older listing still gets the
+        // profile it belongs to, rather than an empty result.
+        const profileName = profileRef ? parseConnectionKey(profileRef).profile : undefined;
+        const seenProfiles = new Set();
         const statuses = [];
-        // Connections are keyed by composite `<profile>@<endpoint>`. A bare
-        // `--profile comet-local` must still list those tasks (same rule as
-        // stopProfile). Match exact key, bareName, and composite/fork prefixes.
         const candidates = profileName
-            ? [...this.connections.keys()].filter((k) => connectionKeyMatchesProfile(k, profileName) ||
-                this.connections.get(k)?.bareName === profileName)
+            ? [...this.connections.keys()].filter((k) => keyBelongsToProfile(k, profileName))
             : Array.from(this.connections.keys());
-        for (const name of candidates) {
-            const status = await this.getProfileStatus(name);
+        for (const key of candidates) {
+            const status = await this.getProfileStatus(key);
             if (status) {
                 statuses.push(status);
-                seen.add(name);
-                if (status.name)
-                    seen.add(status.name);
+                seenProfiles.add(status.name);
             }
         }
         if (!profileName) {
-            const profiles = await listProfiles();
-            for (const profile of profiles) {
-                if (seen.has(profile.name))
-                    continue;
-                if ([...seen].some((s) => connectionKeyMatchesProfile(s, profile.name)))
+            for (const profile of await listProfiles()) {
+                if (seenProfiles.has(profile.name))
                     continue;
                 const reconciled = await this.reconcileFromDisk(profile.name);
                 if (reconciled)
@@ -1449,31 +1567,28 @@ export class BrowserService {
         }
         return statuses;
     }
+    /**
+     * Rebuild a profile's status from its runtime dirs when no live connection is
+     * registered — a daemon that never connected this profile, or a browser
+     * started by an earlier daemon.
+     *
+     * Takes a BARE profile name and walks every runtime key that belongs to it
+     * ({@link listProfileCacheDirs}), including the legacy pre-composite dir named
+     * exactly the profile.
+     */
     async reconcileFromDisk(profileName) {
-        // Runtime dirs live under the composite (`comet-local@endpoint-0`), not the
-        // bare YAML name. Walk every matching cache dir so bare `status --profile`
-        // sees the same tasks as unscoped `status`.
         const dirs = listProfileCacheDirs(profileName);
-        if (dirs.length === 0) {
-            // Legacy: non-composite dir named exactly the bare profile.
-            const info = getRunningChromeInfo(profileName);
-            if (!info)
-                return null;
-            return this.profileStatusFromDisk(profileName, profileName, info.port, info.pid);
-        }
-        // Prefer a dir that still has a live browser; fall back to the first.
         for (const dir of dirs) {
-            const dirName = path.basename(dir);
-            const info = getRunningChromeInfo(dirName);
+            const key = asConnectionKey(path.basename(dir));
+            const info = getRunningChromeInfo(key);
             if (!info)
                 continue;
-            return this.profileStatusFromDisk(profileName, dirName, info.port, info.pid);
+            return this.profileStatusFromDisk(profileName, key, info.port, info.pid);
         }
         return null;
     }
-    async profileStatusFromDisk(displayName, runtimeKey, port, pid) {
-        const bare = displayName.includes('@') ? displayName.split('@')[0] : displayName;
-        const profile = await getProfile(bare);
+    async profileStatusFromDisk(profileName, runtimeKey, port, pid) {
+        const profile = await getProfile(profileName);
         const tasks = this.loadTaskState(runtimeKey);
         const taskStatuses = [];
         for (const [, task] of tasks) {
@@ -1488,7 +1603,10 @@ export class BrowserService {
         }
         const configuredPort = profile ? extractConfiguredPort(profile) : undefined;
         return {
-            name: runtimeKey,
+            // Bare name for the user; the endpoint travels in its own field.
+            name: profileName,
+            endpoint: parseConnectionKey(runtimeKey).endpoint,
+            key: runtimeKey,
             running: true,
             port,
             pid,
@@ -1800,8 +1918,8 @@ export class BrowserService {
      * effort: a remote CDP endpoint that doesn't expose the Browser domain must not
      * fail the whole connect.
      */
-    async applyDefaultDownloadBehavior(conn, profileName) {
-        const downloadPath = getProfileDownloadsDir(profileName);
+    async applyDefaultDownloadBehavior(conn, key) {
+        const downloadPath = getProfileDownloadsDir(key);
         try {
             await fs.promises.mkdir(downloadPath, { recursive: true });
             await conn.cdp.send('Browser.setDownloadBehavior', {
@@ -1817,7 +1935,7 @@ export class BrowserService {
         }
     }
     async setDownloadPath(taskId, downloadPath, tabHint) {
-        const { conn, task, profileName } = await this.findTask(taskId);
+        const { conn, task, key: runtimeKey } = await this.findTask(taskId);
         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);
@@ -1826,7 +1944,7 @@ export class BrowserService {
         const sessionId = await this.getSessionId(conn, target.targetId);
         // No explicit --path: fall back to the profile's downloads dir, the same
         // destination already set browser-global at connect (applyDefaultDownloadBehavior).
-        const resolvedPath = downloadPath ?? getProfileDownloadsDir(profileName);
+        const resolvedPath = downloadPath ?? getProfileDownloadsDir(runtimeKey);
         await fs.promises.mkdir(resolvedPath, { recursive: true });
         await conn.cdp.send('Browser.setDownloadBehavior', {
             behavior: 'allow',
@@ -1904,20 +2022,20 @@ export class BrowserService {
         }
         this.connections.clear();
     }
-    findAvailableFork(profileName) {
+    findAvailableFork(baseKey) {
         for (const [name, conn] of this.connections) {
-            if (conn.forkedFrom === profileName && conn.tasks.size === 0) {
+            if (conn.forkedFrom === baseKey && conn.tasks.size === 0) {
                 return { name, conn };
             }
         }
         return null;
     }
-    async forkElectronProfile(profile) {
+    async forkElectronProfile(profile, baseKey) {
         let forkNum = 2;
-        while (this.connections.has(`${profile.name}.${forkNum}`)) {
+        while (this.connections.has(asConnectionKey(`${baseKey}.${forkNum}`))) {
             forkNum++;
         }
-        const forkName = `${profile.name}.${forkNum}`;
+        const forkName = asConnectionKey(`${baseKey}.${forkNum}`);
         const port = allocatePort();
         const chromeOpts = { ...profile.chrome, viewport: profile.viewport };
         const { pid, wsUrl } = await launchBrowser(forkName, profile.browser, port, chromeOpts, profile.secrets, profile.binary, profile.electron === true);
@@ -1929,9 +2047,11 @@ export class BrowserService {
             port,
             pid,
             electron: true,
+            browserType: profile.browser,
             targetFilter: profile.targetFilter,
-            profileName: forkName,
-            forkedFrom: profile.name,
+            key: forkName,
+            profile: profile.name,
+            forkedFrom: baseKey,
             tasks: new Map(),
             sessionCache: new Map(),
         };
@@ -1944,12 +2064,13 @@ export class BrowserService {
      * already resolved the endpoint and built the `effectiveProfile` with
      * the per-endpoint binary/targetFilter overrides applied; we just use it.
      *
-     * `effectiveProfile.name` is the composite identifier (`<profile>@<endpoint>`)
-     * so per-endpoint pid/port files don't collide when the same app runs
-     * locally and remotely at the same time.
+     * `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).
      */
-    async connectProfile(effectiveProfile, target) {
-        const existingInfo = getRunningChromeInfo(effectiveProfile.name);
+    async connectProfile(effectiveProfile, target, key) {
+        const existingInfo = getRunningChromeInfo(key);
         if (existingInfo) {
             try {
                 const { wsUrl, browser } = await discoverBrowserWsUrl(existingInfo.port, 'localhost', effectiveProfile.name);
@@ -1957,12 +2078,13 @@ export class BrowserService {
                 const cdp = new CDPClient();
                 await cdp.connect(wsUrl);
                 await this.enableDomains(cdp);
-                const tasks = this.loadTaskState(effectiveProfile.name);
+                const tasks = this.loadTaskState(key);
                 return {
                     cdp,
                     port: existingInfo.port,
                     pid: existingInfo.pid,
                     electron: effectiveProfile.electron,
+                    browserType: effectiveProfile.browser,
                     targetFilter: effectiveProfile.targetFilter,
                     tasks,
                     sessionCache: new Map(),
@@ -1975,38 +2097,40 @@ export class BrowserService {
                 // or because the OS reused the pid for an unrelated process.
                 // Wipe the stale runtime files and fall through to a fresh
                 // connect against the profile's currently-configured endpoint.
-                clearProfileRuntime(effectiveProfile.name);
+                clearProfileRuntime(key);
             }
         }
-        const conn = await this.connectEndpoint(effectiveProfile, target);
+        const conn = await this.connectEndpoint(effectiveProfile, target, key);
         if (!conn) {
             throw new Error(`Could not connect to endpoint ${target} for profile "${effectiveProfile.name}"`);
         }
         return conn;
     }
-    async connectEndpoint(profile, endpoint) {
+    async connectEndpoint(profile, endpoint, key) {
         const url = new URL(endpoint);
         if (url.protocol === 'cdp:') {
-            const conn = await connectLocal(endpoint, profile);
+            const conn = await connectLocal(endpoint, profile, key);
             await this.enableDomains(conn.cdp);
             return {
                 cdp: conn.cdp,
                 port: conn.port,
                 pid: conn.pid,
                 electron: profile.electron,
+                browserType: profile.browser,
                 targetFilter: profile.targetFilter,
-                tasks: conn.pid === 0 ? this.loadTaskState(profile.name) : new Map(),
+                tasks: conn.pid === 0 ? this.loadTaskState(key) : new Map(),
                 sessionCache: new Map(),
             };
         }
         if (url.protocol === 'ssh:') {
-            const conn = await connectSSH(endpoint, profile);
+            const conn = await connectSSH(endpoint, profile, key);
             await this.enableDomains(conn.cdp);
             return {
                 cdp: conn.cdp,
                 port: conn.port,
                 pid: conn.pid,
                 electron: profile.electron,
+                browserType: profile.browser,
                 targetFilter: profile.targetFilter,
                 tasks: new Map(),
                 sessionCache: new Map(),
@@ -2028,8 +2152,9 @@ export class BrowserService {
                 port: 0,
                 pid: 0,
                 electron: profile.electron,
+                browserType: profile.browser,
                 targetFilter: profile.targetFilter,
-                tasks: this.loadTaskState(profile.name),
+                tasks: this.loadTaskState(key),
                 sessionCache: new Map(),
             };
         }
@@ -2045,8 +2170,9 @@ export class BrowserService {
                 port,
                 pid: 0,
                 electron: profile.electron,
+                browserType: profile.browser,
                 targetFilter: profile.targetFilter,
-                tasks: this.loadTaskState(profile.name),
+                tasks: this.loadTaskState(key),
                 sessionCache: new Map(),
             };
         }
@@ -2055,6 +2181,19 @@ export class BrowserService {
     async enableDomains(cdp) {
         await cdp.send('Target.setDiscoverTargets', { discover: true });
     }
+    /**
+     * The single path that opens a new CDP page/window target. It exists so the
+     * Arc guard lives in exactly one place: `Target.createTarget` crashes Arc
+     * (verified, PR #2778), so an Arc connection throws a clear, actionable error
+     * here instead of every call site re-checking. Every drivable Chromium-family
+     * browser goes straight through.
+     */
+    async createPageTarget(conn, params) {
+        if (conn.browserType === 'arc') {
+            throw arcNotDrivableError(conn.profile);
+        }
+        return (await conn.cdp.send('Target.createTarget', params));
+    }
     async getOrCreateWindow(conn) {
         // Already have a window for this profile?
         if (conn.windowId) {
@@ -2086,10 +2225,10 @@ export class BrowserService {
                 `Available page targets:\n${candidates || '  (none)'}`);
         }
         // First ever use - create window
-        const result = (await conn.cdp.send('Target.createTarget', {
+        const result = await this.createPageTarget(conn, {
             url: 'about:blank',
             newWindow: true,
-        }));
+        });
         conn.windowId = result.targetId;
         return result.targetId;
     }
@@ -2154,7 +2293,7 @@ export class BrowserService {
         if (matches.length === 1) {
             const m = matches[0];
             await this.touchTask(m.conn, m.task);
-            return { conn: m.conn, task: m.task, profileName: m.profileName, created: false };
+            return { conn: m.conn, task: m.task, key: m.key, created: false };
         }
         if (matches.length > 1) {
             const lines = matches.map((m) => {
@@ -2194,7 +2333,7 @@ export class BrowserService {
             for (const task of conn.tasks.values()) {
                 if (hasIdentity) {
                     if (taskMatchesCaller(task, caller)) {
-                        out.push({ conn, task, profileName: conn.profileName ?? key });
+                        out.push({ conn, task, key: conn.key ?? key });
                     }
                 }
                 else {
@@ -2202,7 +2341,7 @@ export class BrowserService {
                     // (a human-driven shell). If there is exactly one live task total,
                     // the single-task path still needs that listed — fall through below.
                     if (!task.sessionId && !task.launchId) {
-                        out.push({ conn, task, profileName: conn.profileName ?? key });
+                        out.push({ conn, task, key: conn.key ?? key });
                     }
                 }
             }
@@ -2217,7 +2356,7 @@ export class BrowserService {
                 const conn = this.connections.get(only.profile) ??
                     [...this.connections.entries()].find(([, c]) => c.tasks.has(only.task.name) || [...c.tasks.values()].includes(only.task))?.[1];
                 if (conn) {
-                    out.push({ conn, task: only.task, profileName: only.profile });
+                    out.push({ conn, task: only.task, key: only.profile });
                 }
             }
         }
@@ -2268,33 +2407,34 @@ export class BrowserService {
             // `recordBrowserSession` call in `start` uses for the same reason.
         }
     }
-    async findTask(taskId, profileName) {
-        if (profileName) {
+    async findTask(taskId, profileRef) {
+        if (profileRef) {
             // Accept bare profile names against composite connection keys.
-            const keys = [...this.connections.keys()].filter((k) => k === profileName ||
-                connectionKeyMatchesProfile(k, profileName) ||
-                this.connections.get(k)?.bareName === profileName);
+            // One rule: an exact runtime key, else every key belonging to that bare
+            // profile. Callers pass whichever they hold — the composite is theirs to
+            // ignore (RUSH-2709).
+            const keys = [...this.connections.keys()].filter((k) => k === profileRef || keyBelongsToProfile(k, profileRef));
             for (const key of keys) {
                 const conn = this.connections.get(key);
                 const task = this.lookupTaskOnConn(conn, taskId);
                 if (task) {
                     await this.touchTask(conn, task);
-                    return { conn, task, profileName: conn.profileName ?? key };
+                    return { conn, task, key: conn.key ?? key };
                 }
             }
             // RAM miss → rehydrate from disk for this profile.
-            const rehydrated = await this.rehydrateTaskFromDisk(taskId, profileName);
+            const rehydrated = await this.rehydrateTaskFromDisk(taskId, profileRef);
             if (rehydrated) {
                 await this.touchTask(rehydrated.conn, rehydrated.task);
                 return rehydrated;
             }
-            throw new Error(actionable(`Task "${taskId}" not found on profile "${profileName}".`, `Next: agents browser status --profile ${profileName}`));
+            throw new Error(actionable(`Task "${taskId}" not found on profile "${profileRef}".`, `Next: agents browser status --profile ${parseConnectionKey(profileRef).profile}`));
         }
         for (const [key, conn] of this.connections) {
             const task = this.lookupTaskOnConn(conn, taskId);
             if (task) {
                 await this.touchTask(conn, task);
-                return { conn, task, profileName: conn.profileName ?? key };
+                return { conn, task, key: conn.key ?? key };
             }
         }
         // RAM miss after a daemon restart: tasks.json still has the task and
@@ -2318,11 +2458,8 @@ export class BrowserService {
      * Returns null when nothing is speaking CDP so callers can fall through
      * to disk reconcile.
      */
-    async attachRunningProfile(dirName, diskTasks) {
-        const bare = dirName.includes('@') ? dirName.split('@')[0] : dirName;
-        const endpointFromKey = dirName.includes('@')
-            ? dirName.slice(dirName.indexOf('@') + 1).split('.')[0]
-            : undefined;
+    async attachRunningProfile(key, diskTasks) {
+        const { profile: bare, endpoint: endpointFromKey } = parseConnectionKey(key);
         const profile = await getProfile(bare);
         if (!profile)
             return null;
@@ -2333,7 +2470,7 @@ export class BrowserService {
         catch {
             return null;
         }
-        const existingInfo = getRunningChromeInfo(dirName);
+        const existingInfo = getRunningChromeInfo(key);
         const parsed = parseEndpointUrl(resolved.target);
         const port = existingInfo?.port ?? parsed?.port;
         if (port === undefined)
@@ -2343,12 +2480,12 @@ export class BrowserService {
         if (resolved.target.startsWith('ssh:'))
             return null;
         try {
-            const { wsUrl, browser } = await discoverBrowserWsUrl(port, host, dirName);
+            const { wsUrl, browser } = await discoverBrowserWsUrl(port, host, bare);
             verifyBrowserIdentity(browser, profile.browser, port, host);
             const cdp = new CDPClient();
             await cdp.connect(wsUrl);
             await this.enableDomains(cdp);
-            const tasks = this.loadTaskState(dirName);
+            const tasks = this.loadTaskState(key);
             for (const [k, t] of diskTasks) {
                 if (!tasks.has(k))
                     tasks.set(k, t);
@@ -2358,9 +2495,10 @@ export class BrowserService {
                 port,
                 pid: existingInfo?.pid ?? 0,
                 electron: profile.electron,
+                browserType: profile.browser,
                 targetFilter: resolved.targetFilter ?? profile.targetFilter,
-                profileName: dirName,
-                bareName: bare,
+                key,
+                profile: bare,
                 tasks,
                 sessionCache: new Map(),
             };
@@ -2392,21 +2530,23 @@ export class BrowserService {
             return;
         }
         for (const dirName of dirNames) {
-            if (this.connections.has(dirName))
+            // A runtime dir name IS a connection key — that is what wrote it.
+            const key = asConnectionKey(dirName);
+            if (this.connections.has(key))
                 continue;
             // Skip non-runtime dirs (e.g. profiles/)
             if (dirName === 'profiles' || dirName === 'sessions' || dirName === 'exports')
                 continue;
-            const tasks = this.loadTaskState(dirName);
+            const tasks = this.loadTaskState(key);
             if (tasks.size === 0)
                 continue;
             // Soft attach only — never launch / never clear pid files.
-            const conn = await this.attachRunningProfile(dirName, tasks);
+            const conn = await this.attachRunningProfile(key, tasks);
             if (!conn)
                 continue;
-            this.connections.set(dirName, conn);
+            this.connections.set(key, conn);
             try {
-                await this.applyDefaultDownloadBehavior(conn, dirName);
+                await this.applyDefaultDownloadBehavior(conn, key);
             }
             catch {
                 // Non-fatal for rehydrate.
@@ -2435,12 +2575,13 @@ export class BrowserService {
             return null;
         }
         if (profileHint) {
-            dirNames = dirNames.filter((d) => d === profileHint || connectionKeyMatchesProfile(d, profileHint));
+            dirNames = dirNames.filter((d) => d === profileHint || keyBelongsToProfile(d, profileHint));
         }
         for (const dirName of dirNames) {
             if (dirName === 'profiles' || dirName === 'sessions' || dirName === 'exports')
                 continue;
-            const tasks = this.loadTaskState(dirName);
+            const key = asConnectionKey(dirName);
+            const tasks = this.loadTaskState(key);
             let found;
             for (const task of tasks.values()) {
                 if (task.id === taskId || task.name === taskId) {
@@ -2454,17 +2595,17 @@ export class BrowserService {
             if (!found)
                 continue;
             // Already connected under this key?
-            let conn = this.connections.get(dirName);
+            let conn = this.connections.get(key);
             if (!conn) {
-                const attached = await this.attachRunningProfile(dirName, tasks);
+                const attached = await this.attachRunningProfile(key, tasks);
                 if (!attached) {
                     // CDP down — cannot rehydrate a live connection; caller will error.
                     continue;
                 }
                 conn = attached;
-                this.connections.set(dirName, conn);
+                this.connections.set(key, conn);
                 try {
-                    await this.applyDefaultDownloadBehavior(conn, dirName);
+                    await this.applyDefaultDownloadBehavior(conn, key);
                 }
                 catch {
                     // Non-fatal.
@@ -2475,7 +2616,7 @@ export class BrowserService {
             if (!this.lookupTaskOnConn(conn, task.name)) {
                 conn.tasks.set(task.name, task);
             }
-            return { conn, task, profileName: conn.profileName ?? dirName };
+            return { conn, task, key: conn.key ?? key };
         }
         return null;
     }
@@ -2495,20 +2636,9 @@ export class BrowserService {
         }
         return tabs;
     }
-    async getProfileStatus(profileName) {
-        // Exact composite key first; bare name falls through connectionKeyMatches.
-        let conn = this.connections.get(profileName);
-        let resolvedKey = profileName;
-        if (!conn) {
-            for (const [key, c] of this.connections) {
-                if (connectionKeyMatchesProfile(key, profileName) ||
-                    c.bareName === profileName) {
-                    conn = c;
-                    resolvedKey = key;
-                    break;
-                }
-            }
-        }
+    /** Live status for ONE registered connection, addressed by its runtime key. */
+    async getProfileStatus(key) {
+        const conn = this.connections.get(key);
         if (!conn)
             return null;
         // Fetch all targets once for efficiency
@@ -2554,11 +2684,14 @@ export class BrowserService {
                 domains: domainSet.size > 0 ? Array.from(domainSet) : undefined,
             });
         }
-        const bare = conn.bareName ?? (resolvedKey.includes('@') ? resolvedKey.split('@')[0] : resolvedKey);
+        const parsed = parseConnectionKey(key);
+        const bare = conn.profile ?? parsed.profile;
         const profile = await getProfile(bare);
         const configuredPort = profile ? extractConfiguredPort(profile) : undefined;
         return {
-            name: resolvedKey,
+            name: bare,
+            endpoint: parsed.endpoint,
+            key,
             running: true,
             port: conn.port,
             pid: conn.pid,
@@ -2618,14 +2751,14 @@ export class BrowserService {
     invalidateTargetCache(conn) {
         conn.targetCache = undefined;
     }
-    async saveTaskState(profileName, tasks) {
-        const runtimeDir = getProfileRuntimeDir(profileName);
+    async saveTaskState(key, tasks) {
+        const runtimeDir = getProfileRuntimeDir(key);
         await fs.promises.mkdir(runtimeDir, { recursive: true });
         const state = Object.fromEntries(tasks);
         await fs.promises.writeFile(path.join(runtimeDir, 'tasks.json'), JSON.stringify(state, null, 2));
     }
-    loadTaskState(profileName) {
-        const runtimeDir = getProfileRuntimeDir(profileName);
+    loadTaskState(key) {
+        const runtimeDir = getProfileRuntimeDir(key);
         const tasksFile = path.join(runtimeDir, 'tasks.json');
         if (!fs.existsSync(tasksFile)) {
             return new Map();
@@ -2647,7 +2780,7 @@ export class BrowserService {
                 tasks.set(key, {
                     id: task.id,
                     name: task.name || key,
-                    profile: task.profile,
+                    profile: asConnectionKey(task.profile),
                     tabs,
                     currentTabId: tabIds.length > 0 ? tabIds[tabIds.length - 1] : undefined,
                     createdAt: task.createdAt,
@@ -2689,7 +2822,9 @@ export class BrowserService {
         history.unshift({
             id: task.id,
             name: task.name,
-            profile: task.profile,
+            // `task.profile` is the runtime key; history is a user-facing table, so
+            // it carries the bare name (RUSH-2709).
+            profile: parseConnectionKey(task.profile).profile,
             createdAt: task.createdAt,
             endedAt: Date.now(),
             domains,