@phnx-labs/agents-cli 1.22.38 → 1.22.40

package/dist/lib/browser/service.js

@@ -2,19 +2,20 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { BrowserCdpConnectionError, CDPClient, discoverBrowserWsUrl, verifyBrowserIdentity, } from './cdp.js';
-import { getProfile, getProfileRuntimeDir, getProfileDownloadsDir, getProfileSessionsDir, getBrowserRuntimeDir, listProfiles, extractConfiguredPort, resolveEndpoint, } from './profiles.js';
+import { getProfile, getProfileRuntimeDir, getProfileDownloadsDir, getProfileSessionsDir, getBrowserRuntimeDir, listProfiles, extractConfiguredPort, resolveEndpoint, parseEndpointUrl, } from './profiles.js';
 import { killChrome, getRunningChromeInfo, launchBrowser, allocatePort } from './chrome.js';
 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, generateTaskName, } from './types.js';
+import { generateTaskId, generateShortId, } from './types.js';
 import { reapAbandonedTasks, resolveLiveIdentities, taskOwnerIsGone, } from './hygiene.js';
+import { taskMatchesCaller } from './caller-identity.js';
 import { getRefs, resolveRefToCoords, describeRefs, healRef } from './refs.js';
 import { clickAtCoords, hoverAtCoords, scrollAtCoords, typeText, pressKey, focusNode } from './input.js';
 import { typeEditorText } from './editor.js';
 import { detectUploadPattern, stageUploadFile, uploadToDropTarget, uploadToFileInput, uploadViaFileChooser, } from './upload.js';
-import { emit } from '../events.js';
+import { emit } from '../feed/events.js';
 import { resolveActor } from '../actor.js';
 import { recordBrowserSession } from '../session/db.js';
 import { sshExecAsync } from '../ssh-exec.js';
@@ -238,6 +239,36 @@ async function isConnHealthy(conn, timeoutMs = 1000) {
         return false;
     }
 }
+/** Join error lines so callers get a next command, not a dead-end message. */
+export function actionable(...lines) {
+    return lines.filter((l) => l != null && l !== '').join('\n');
+}
+/** Derive a human label from an explicit title or a navigated URL. */
+export function deriveTaskLabel(opts) {
+    if (opts.title?.trim())
+        return opts.title.trim();
+    if (opts.existing && opts.existing !== 'untitled')
+        return opts.existing;
+    if (opts.url) {
+        try {
+            const host = new URL(opts.url).hostname.replace(/^www\./, '');
+            if (host)
+                return host;
+        }
+        catch {
+            /* unparseable */
+        }
+    }
+    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
@@ -280,14 +311,20 @@ export class BrowserService {
         // 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.
+        //
+        // The YAML profile's bare `name` stays on `profile.name` for status
+        // matching; only the connection/runtime key uses the composite.
         const resolved = resolveEndpoint(profile, opts.endpointName);
         const composite = `${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,
         };
+        const taskId = generateTaskId();
         let taskName;
         if (opts.taskName) {
             if (this.hasTaskNamed(opts.taskName)) {
@@ -296,9 +333,10 @@ export class BrowserService {
             taskName = opts.taskName;
         }
         else {
-            taskName = this.generateUniqueTaskName();
+            // Address by the short machine id — no word-salad. Status shows `label`.
+            taskName = taskId;
         }
-        const taskId = generateTaskId();
+        const taskLabel = deriveTaskLabel({ title: opts.title, url: opts.url });
         let conn = this.connections.get(composite);
         let effectiveProfileName = composite;
         // If we have a cached connection, confirm it's still usable before any
@@ -344,9 +382,12 @@ export class BrowserService {
         else if (!conn) {
             conn = await this.connectProfile(effectiveProfile, resolved.target);
             conn.profileName = composite;
+            conn.bareName = profileName;
             this.connections.set(composite, conn);
             await this.applyDefaultDownloadBehavior(conn, composite);
         }
+        if (conn && !conn.bareName)
+            conn.bareName = 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
@@ -374,6 +415,7 @@ export class BrowserService {
         const task = {
             id: taskId,
             name: taskName,
+            label: taskLabel,
             profile: effectiveProfileName,
             tabs: {},
             currentTabId: undefined,
@@ -574,9 +616,18 @@ export class BrowserService {
         return reapAbandonedTasks(this, opts);
     }
     async stop(taskName) {
+        // Rehydrate from tasks.json when the daemon restarted and lost RAM state.
+        try {
+            await this.findTask(taskName);
+        }
+        catch {
+            // findTask throws when truly gone; fall through to the miss return.
+        }
         for (const [profileName, conn] of this.connections) {
-            const task = conn.tasks.get(taskName);
+            const task = this.lookupTaskOnConn(conn, taskName);
             if (task) {
+                // Map key may be task.name, not the caller-supplied handle.
+                const mapKey = this.taskMapKey(conn, task) ?? taskName;
                 // Get domains from tabs before closing (for history)
                 const domains = new Set();
                 try {
@@ -608,16 +659,16 @@ export class BrowserService {
                     conn.sessionCache.delete(cdpId);
                 }
                 this.invalidateTargetCache(conn);
-                conn.tasks.delete(taskName);
+                conn.tasks.delete(mapKey);
                 await this.saveTaskState(profileName, conn.tasks);
-                emit('browser.close', { profile: profileName, task: taskName });
+                emit('browser.close', { profile: profileName, task: task.name });
                 void import('../analytics/usage-db.js').then(({ recordUsage }) => {
                     recordUsage({
                         kind: 'browser',
                         name: profileName,
                         event: 'close',
                         source: 'browser',
-                        meta: { task: taskName },
+                        meta: { task: task.name },
                     });
                 }).catch(() => { });
                 if (conn.forkedFrom && conn.tasks.size === 0) {
@@ -669,6 +720,7 @@ export class BrowserService {
     }
     async navigate(taskId, url, profileName) {
         const { conn, task } = await this.findTask(taskId, profileName);
+        this.maybeUpdateLabelFromUrl(conn, task, url);
         // If we have a current tab, navigate in it (reuse)
         const currentShortId = task.currentTabId;
         if (currentShortId && task.tabs[currentShortId]) {
@@ -1357,14 +1409,25 @@ export class BrowserService {
         return { path: stageUploadFile(source) };
     }
     async status(profileName) {
+        // 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();
         const statuses = [];
-        const candidates = profileName ? [profileName] : Array.from(this.connections.keys());
+        // 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)
+            : Array.from(this.connections.keys());
         for (const name of candidates) {
             const status = await this.getProfileStatus(name);
             if (status) {
                 statuses.push(status);
                 seen.add(name);
+                if (status.name)
+                    seen.add(status.name);
             }
         }
         if (!profileName) {
@@ -1372,12 +1435,14 @@ export class BrowserService {
             for (const profile of profiles) {
                 if (seen.has(profile.name))
                     continue;
+                if ([...seen].some((s) => connectionKeyMatchesProfile(s, profile.name)))
+                    continue;
                 const reconciled = await this.reconcileFromDisk(profile.name);
                 if (reconciled)
                     statuses.push(reconciled);
             }
         }
-        else if (!seen.has(profileName)) {
+        else if (statuses.length === 0) {
             const reconciled = await this.reconcileFromDisk(profileName);
             if (reconciled)
                 statuses.push(reconciled);
@@ -1385,16 +1450,37 @@ export class BrowserService {
         return statuses;
     }
     async reconcileFromDisk(profileName) {
-        const info = getRunningChromeInfo(profileName);
-        if (!info)
-            return null;
-        const profile = await getProfile(profileName);
-        const tasks = this.loadTaskState(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);
+            if (!info)
+                continue;
+            return this.profileStatusFromDisk(profileName, dirName, 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);
+        const tasks = this.loadTaskState(runtimeKey);
         const taskStatuses = [];
         for (const [, task] of tasks) {
             taskStatuses.push({
                 id: task.id,
                 name: task.name,
+                label: task.label ?? task.name,
                 tabCount: Object.keys(task.tabs).length,
                 currentTabId: task.currentTabId,
                 createdAt: task.createdAt,
@@ -1402,11 +1488,11 @@ export class BrowserService {
         }
         const configuredPort = profile ? extractConfiguredPort(profile) : undefined;
         return {
-            name: profileName,
+            name: runtimeKey,
             running: true,
-            port: info.port,
-            pid: info.pid,
-            configuredPort: configuredPort !== info.port ? configuredPort : undefined,
+            port,
+            pid,
+            configuredPort: configuredPort !== port ? configuredPort : undefined,
             tasks: taskStatuses,
         };
     }
@@ -2009,18 +2095,143 @@ export class BrowserService {
     }
     hasTaskNamed(name) {
         for (const conn of this.connections.values()) {
-            if (conn.tasks.has(name))
+            if (this.lookupTaskOnConn(conn, name))
                 return true;
         }
         return false;
     }
-    generateUniqueTaskName() {
-        for (let attempt = 0; attempt < 8; attempt++) {
-            const candidate = generateTaskName();
-            if (!this.hasTaskNamed(candidate))
-                return candidate;
+    /** Map key for a task on a connection (tasks are keyed by `name`). */
+    taskMapKey(conn, task) {
+        for (const [key, t] of conn.tasks) {
+            if (t === task || t.id === task.id || t.name === task.name)
+                return key;
         }
-        throw new Error('Could not generate unique task name after 8 attempts');
+        return undefined;
+    }
+    /** Find a task by map key, id, or name on one connection. */
+    lookupTaskOnConn(conn, handle) {
+        const direct = conn.tasks.get(handle);
+        if (direct)
+            return direct;
+        for (const task of conn.tasks.values()) {
+            if (task.id === handle || task.name === handle)
+                return task;
+        }
+        return undefined;
+    }
+    maybeUpdateLabelFromUrl(conn, task, url) {
+        if (task.label && task.label !== 'untitled')
+            return;
+        const next = deriveTaskLabel({ url, existing: task.label });
+        if (next === task.label)
+            return;
+        task.label = next;
+        void this.saveTaskState(task.profile, conn.tasks).catch(() => { });
+    }
+    /**
+     * Resolve a task for a page/close verb.
+     *
+     *   - explicit `task` handle → look up (with disk rehydrate on RAM miss)
+     *   - no handle, exactly one live task for this caller → use it
+     *   - no handle, multiple for this caller → error listing them + `--task`
+     *   - no handle, zero for this caller, createIfMissing → start a new task
+     *   - no handle, zero, !createIfMissing → return null (caller reports "nothing to close")
+     */
+    async resolveOrCreateTask(opts) {
+        if (opts.task) {
+            const found = await this.findTask(opts.task, opts.profile);
+            return { ...found, created: false };
+        }
+        // After a daemon restart the connections map is empty while tasks.json still
+        // holds live tasks. Rehydrate before identity matching so done/screenshot
+        // without --task still find the caller's task.
+        await this.rehydrateAllFromDisk();
+        const caller = {
+            sessionId: opts.sessionId,
+            launchId: opts.launchId,
+        };
+        const matches = this.listTasksForCaller(caller);
+        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 };
+        }
+        if (matches.length > 1) {
+            const lines = matches.map((m) => {
+                const ageMs = Date.now() - m.task.createdAt;
+                const age = ageMs < 60_000
+                    ? `${Math.round(ageMs / 1000)}s`
+                    : `${Math.round(ageMs / 60_000)}m`;
+                const label = m.task.label ?? m.task.name;
+                const url = this.currentUrlHint(m.conn, m.task) ?? '-';
+                return `  ${label}  id=${m.task.name}  url=${url}  age=${age}`;
+            });
+            throw new Error(actionable(`Multiple browser tasks for this session — pass --task <name>:`, ...lines, `Next: agents browser status`));
+        }
+        // Zero matches for this caller.
+        if (!opts.createIfMissing)
+            return null;
+        // Implicit start on the default / named profile.
+        let profileName = opts.profile;
+        if (!profileName) {
+            const { ensureDefaultBrowserProfile } = await import('./profiles.js');
+            const detected = await ensureDefaultBrowserProfile();
+            profileName = detected.name;
+        }
+        const started = await this.start(profileName, {
+            url: opts.url,
+            actor: opts.actor,
+            launchId: opts.launchId,
+            sessionId: opts.sessionId,
+            title: opts.title,
+        });
+        return { ...(await this.findTask(started.name, started.profile)), created: true };
+    }
+    listTasksForCaller(caller) {
+        const out = [];
+        const hasIdentity = !!(caller.sessionId || caller.launchId);
+        for (const [key, conn] of this.connections) {
+            for (const task of conn.tasks.values()) {
+                if (hasIdentity) {
+                    if (taskMatchesCaller(task, caller)) {
+                        out.push({ conn, task, profileName: conn.profileName ?? key });
+                    }
+                }
+                else {
+                    // No caller identity: only match tasks that also lack identity
+                    // (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 });
+                    }
+                }
+            }
+        }
+        // No-identity caller with zero unscoped matches: if the daemon holds
+        // exactly one live task that ALSO has no identity (a human-started one),
+        // use it. Never steal a task stamped with another caller's session/launch.
+        if (!hasIdentity && out.length === 0) {
+            const unowned = this.listTasks().filter((t) => !t.task.sessionId && !t.task.launchId);
+            if (unowned.length === 1) {
+                const only = unowned[0];
+                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 });
+                }
+            }
+        }
+        return out;
+    }
+    currentUrlHint(conn, task) {
+        const shortId = task.currentTabId;
+        if (!shortId)
+            return undefined;
+        const cdpId = task.tabs[shortId];
+        if (!cdpId)
+            return undefined;
+        const cached = conn.targetCache?.targets.find((t) => t.targetId === cdpId);
+        return cached?.url;
     }
     /**
      * Mark a task as active, so the reaper's idle window measures time since the
@@ -2059,25 +2270,214 @@ export class BrowserService {
     }
     async findTask(taskId, profileName) {
         if (profileName) {
-            const conn = this.connections.get(profileName);
-            if (!conn) {
-                throw new Error(`Profile "${profileName}" not connected`);
+            // 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);
+            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 };
+                }
             }
-            const task = conn.tasks.get(taskId);
-            if (!task) {
-                throw new Error(`Task "${taskId}" not found on profile "${profileName}"`);
+            // RAM miss → rehydrate from disk for this profile.
+            const rehydrated = await this.rehydrateTaskFromDisk(taskId, profileName);
+            if (rehydrated) {
+                await this.touchTask(rehydrated.conn, rehydrated.task);
+                return rehydrated;
             }
-            await this.touchTask(conn, task);
-            return { conn, task, profileName };
+            throw new Error(actionable(`Task "${taskId}" not found on profile "${profileName}".`, `Next: agents browser status --profile ${profileName}`));
         }
         for (const [key, conn] of this.connections) {
-            const task = conn.tasks.get(taskId);
+            const task = this.lookupTaskOnConn(conn, taskId);
             if (task) {
                 await this.touchTask(conn, task);
                 return { conn, task, profileName: conn.profileName ?? key };
             }
         }
-        throw new Error(`Task "${taskId}" not found`);
+        // RAM miss after a daemon restart: tasks.json still has the task and
+        // meta.json still has the browser pid/port. Reconnect and adopt.
+        const rehydrated = await this.rehydrateTaskFromDisk(taskId);
+        if (rehydrated) {
+            await this.touchTask(rehydrated.conn, rehydrated.task);
+            return rehydrated;
+        }
+        const live = this.listTasks()
+            .map(({ task }) => task.label ?? task.name)
+            .join(', ');
+        throw new Error(actionable(`Task "${taskId}" not found.`, `Active tasks: ${live || 'none'}`, `It may have been closed by the idle reaper (30 min).`, `Next: agents browser status  |  agents browser navigate <url>`));
+    }
+    /**
+     * Soft-attach to an already-running browser for a runtime dir.
+     *
+     * Never launches a browser and never clears pid/port files on failure —
+     * `connectProfile` does both, which made `status()` wipe disk state when
+     * CDP was unreachable (CI / post-reaper) and then return an empty list.
+     * 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;
+        const profile = await getProfile(bare);
+        if (!profile)
+            return null;
+        let resolved;
+        try {
+            resolved = resolveEndpoint(profile, endpointFromKey);
+        }
+        catch {
+            return null;
+        }
+        const existingInfo = getRunningChromeInfo(dirName);
+        const parsed = parseEndpointUrl(resolved.target);
+        const port = existingInfo?.port ?? parsed?.port;
+        if (port === undefined)
+            return null;
+        const host = parsed?.host && parsed.host !== 'localhost' ? parsed.host : 'localhost';
+        // ssh:// endpoints need a tunnel; soft rehydrate only handles local CDP.
+        if (resolved.target.startsWith('ssh:'))
+            return null;
+        try {
+            const { wsUrl, browser } = await discoverBrowserWsUrl(port, host, dirName);
+            verifyBrowserIdentity(browser, profile.browser, port, host);
+            const cdp = new CDPClient();
+            await cdp.connect(wsUrl);
+            await this.enableDomains(cdp);
+            const tasks = this.loadTaskState(dirName);
+            for (const [k, t] of diskTasks) {
+                if (!tasks.has(k))
+                    tasks.set(k, t);
+            }
+            const conn = {
+                cdp,
+                port,
+                pid: existingInfo?.pid ?? 0,
+                electron: profile.electron,
+                targetFilter: resolved.targetFilter ?? profile.targetFilter,
+                profileName: dirName,
+                bareName: bare,
+                tasks,
+                sessionCache: new Map(),
+            };
+            return conn;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Reconnect every profile runtime dir that still has a live browser and
+     * tasks.json entries. Used before identity-based resolution so a daemon
+     * restart does not make the caller's tasks invisible.
+     */
+    async rehydrateAllFromDisk() {
+        const runtimeRoot = getBrowserRuntimeDir();
+        let dirNames = [];
+        try {
+            dirNames = fs.readdirSync(runtimeRoot).filter((d) => {
+                try {
+                    return fs.statSync(path.join(runtimeRoot, d)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch {
+            return;
+        }
+        for (const dirName of dirNames) {
+            if (this.connections.has(dirName))
+                continue;
+            // Skip non-runtime dirs (e.g. profiles/)
+            if (dirName === 'profiles' || dirName === 'sessions' || dirName === 'exports')
+                continue;
+            const tasks = this.loadTaskState(dirName);
+            if (tasks.size === 0)
+                continue;
+            // Soft attach only — never launch / never clear pid files.
+            const conn = await this.attachRunningProfile(dirName, tasks);
+            if (!conn)
+                continue;
+            this.connections.set(dirName, conn);
+            try {
+                await this.applyDefaultDownloadBehavior(conn, dirName);
+            }
+            catch {
+                // Non-fatal for rehydrate.
+            }
+        }
+    }
+    /**
+     * On a RAM miss, scan profile runtime dirs for a tasks.json entry matching
+     * `taskId`, soft-attach when CDP is still up, and register the connection.
+     * Does not launch browsers or clear runtime files.
+     */
+    async rehydrateTaskFromDisk(taskId, profileHint) {
+        const runtimeRoot = getBrowserRuntimeDir();
+        let dirNames = [];
+        try {
+            dirNames = fs.readdirSync(runtimeRoot).filter((d) => {
+                try {
+                    return fs.statSync(path.join(runtimeRoot, d)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch {
+            return null;
+        }
+        if (profileHint) {
+            dirNames = dirNames.filter((d) => d === profileHint || connectionKeyMatchesProfile(d, profileHint));
+        }
+        for (const dirName of dirNames) {
+            if (dirName === 'profiles' || dirName === 'sessions' || dirName === 'exports')
+                continue;
+            const tasks = this.loadTaskState(dirName);
+            let found;
+            for (const task of tasks.values()) {
+                if (task.id === taskId || task.name === taskId) {
+                    found = task;
+                    break;
+                }
+            }
+            // Also allow map-key match
+            if (!found)
+                found = tasks.get(taskId);
+            if (!found)
+                continue;
+            // Already connected under this key?
+            let conn = this.connections.get(dirName);
+            if (!conn) {
+                const attached = await this.attachRunningProfile(dirName, tasks);
+                if (!attached) {
+                    // CDP down — cannot rehydrate a live connection; caller will error.
+                    continue;
+                }
+                conn = attached;
+                this.connections.set(dirName, conn);
+                try {
+                    await this.applyDefaultDownloadBehavior(conn, dirName);
+                }
+                catch {
+                    // Non-fatal.
+                }
+            }
+            const task = this.lookupTaskOnConn(conn, taskId) ?? found;
+            // Ensure the rehydrated task is on the connection map.
+            if (!this.lookupTaskOnConn(conn, task.name)) {
+                conn.tasks.set(task.name, task);
+            }
+            return { conn, task, profileName: conn.profileName ?? dirName };
+        }
+        return null;
     }
     async getTabsForTask(cdp, task) {
         const targets = (await cdp.send('Target.getTargets'));
@@ -2096,7 +2496,19 @@ export class BrowserService {
         return tabs;
     }
     async getProfileStatus(profileName) {
-        const conn = this.connections.get(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;
+                }
+            }
+        }
         if (!conn)
             return null;
         // Fetch all targets once for efficiency
@@ -2134,6 +2546,7 @@ export class BrowserService {
             tasks.push({
                 id: task.id,
                 name: task.name,
+                label: task.label ?? task.name,
                 tabCount: Object.keys(task.tabs).length,
                 currentTabId: task.currentTabId,
                 createdAt: task.createdAt,
@@ -2141,10 +2554,11 @@ export class BrowserService {
                 domains: domainSet.size > 0 ? Array.from(domainSet) : undefined,
             });
         }
-        const profile = await getProfile(profileName);
+        const bare = conn.bareName ?? (resolvedKey.includes('@') ? resolvedKey.split('@')[0] : resolvedKey);
+        const profile = await getProfile(bare);
         const configuredPort = profile ? extractConfiguredPort(profile) : undefined;
         return {
-            name: profileName,
+            name: resolvedKey,
             running: true,
             port: conn.port,
             pid: conn.pid,