@phnx-labs/agents-cli 1.22.56 → 1.22.58

package/dist/lib/analytics/mix-commands.d.ts

@@ -4,11 +4,13 @@
  * These used to live as the top-level `agents trends` tree. That name was a
  * peer of `agents insights` with overlapping "analytics" meaning, so agents and
  * humans kept picking the wrong verb. The cheap counter path (sessions index +
- * usage.db) still exists — it is now `agents insights mix` and the recipe
- * subcommands below. Latency stays on `agents perf`; quota on `agents view`.
+ * usage.db) still exists — it is now `agents insights mix`. Latency stays on
+ * `agents insights perf`; quota on `agents view`.
  *
- * Former top-level `agents trends` is gone. The nested spelling
- * `agents insights trends` is an alias of `agents insights mix`.
+ * One surface, not five: the board is `agents insights mix`, one section is
+ * `agents insights mix <recipe>`, and `--list` names the recipe ids. The former
+ * per-recipe shortcut commands (`harness-mix`, `model-mix`, …), the `recipes`
+ * lister, and the `trends` alias were removed — `mix` already did all three.
  */
 import type { Command } from 'commander';
 export declare function parseMixDays(raw: string | undefined): number;
@@ -23,9 +25,8 @@ export declare function renderMixDashboard(days: number, asJson: boolean, banner
  *
  * Layout:
  *   <parent> mix                 multi-recipe board
- *   <parent> trends              alias of mix (former top-level `agents trends`)
- *   <parent> recipes             list recipe ids
+ *   <parent> mix <recipe>        one baked recipe (harness-mix, model-mix, …)
+ *   <parent> mix --list          list recipe ids
  *   <parent> query               raw usage.db rows
- *   <parent> harness-mix|…       one baked recipe
  */
 export declare function registerMixCommands(parent: Command): void;

package/dist/lib/analytics/mix-commands.js

@@ -4,11 +4,13 @@
  * These used to live as the top-level `agents trends` tree. That name was a
  * peer of `agents insights` with overlapping "analytics" meaning, so agents and
  * humans kept picking the wrong verb. The cheap counter path (sessions index +
- * usage.db) still exists — it is now `agents insights mix` and the recipe
- * subcommands below. Latency stays on `agents perf`; quota on `agents view`.
+ * usage.db) still exists — it is now `agents insights mix`. Latency stays on
+ * `agents insights perf`; quota on `agents view`.
  *
- * Former top-level `agents trends` is gone. The nested spelling
- * `agents insights trends` is an alias of `agents insights mix`.
+ * One surface, not five: the board is `agents insights mix`, one section is
+ * `agents insights mix <recipe>`, and `--list` names the recipe ids. The former
+ * per-recipe shortcut commands (`harness-mix`, `model-mix`, …), the `recipes`
+ * lister, and the `trends` alias were removed — `mix` already did all three.
  */
 import chalk from 'chalk';
 import { setHelpSections } from '../help.js';
@@ -60,23 +62,53 @@ export function renderMixDashboard(days, asJson, bannerLabel = 'agents insights
  *
  * Layout:
  *   <parent> mix                 multi-recipe board
- *   <parent> trends              alias of mix (former top-level `agents trends`)
- *   <parent> recipes             list recipe ids
+ *   <parent> mix <recipe>        one baked recipe (harness-mix, model-mix, …)
+ *   <parent> mix --list          list recipe ids
  *   <parent> query               raw usage.db rows
- *   <parent> harness-mix|…       one baked recipe
  */
 export function registerMixCommands(parent) {
     const banner = 'agents insights mix';
     const mix = parent
-        .command('mix')
-        .description('Counter recipes — harness/model mix, token ratios, resource frequency (sessions index + usage.db)')
+        .command('mix [recipe]')
+        .description('Counter recipes — harness/model mix, token ratios, resource frequency (sessions index + usage.db). Bare shows the board; pass a recipe id for one section.')
         .option('--days <n>', 'Days of history to include', '7')
+        .option('--list', 'List baked recipe ids and exit')
         .option('--json', 'Emit JSON instead of tables')
-        .action(function summary() {
+        .action(function summary(recipe) {
         // optsWithGlobals(): --json collides by name with the `insights` parent, so
         // commander binds it to the parent and this.opts() never sees it. Merging
-        // ancestor opts is what the per-recipe leaves below already do.
+        // ancestor opts is what the per-recipe path below already does.
         const o = this.optsWithGlobals();
+        if (o.list) {
+            const list = listRecipes();
+            if (o.json) {
+                console.log(JSON.stringify(list, null, 2));
+                return;
+            }
+            for (const r of list) {
+                console.log(`${r.id.padEnd(22)} ${r.store.padEnd(10)} ${r.title}`);
+            }
+            return;
+        }
+        if (recipe) {
+            if (!RECIPE_IDS.includes(recipe)) {
+                console.error(`Unknown recipe '${recipe}'. Known: ${RECIPE_IDS.join(', ')} (or 'agents insights mix --list').`);
+                process.exitCode = 1;
+                return;
+            }
+            const win = analyticsWindow(parseMixDays(o.days));
+            const section = runRecipe(recipe, win);
+            if (o.json) {
+                console.log(JSON.stringify({ window: win, section }, null, 2));
+                return;
+            }
+            if (section.empty) {
+                console.log(chalk.gray(`No data for recipe '${recipe}' in the last ${win.days} days.`));
+                return;
+            }
+            printMixSection(section);
+            return;
+        }
         renderMixDashboard(parseMixDays(o.days), Boolean(o.json), banner);
     });
     setHelpSections(mix, {
@@ -88,36 +120,23 @@ export function registerMixCommands(parent) {
       agents insights mix --days 30
 
       # One recipe as JSON
-      agents insights harness-mix --json
+      agents insights mix harness-mix --json
+
+      # List baked recipe ids
+      agents insights mix --list
 
       # Raw usage events
       agents insights query --kind secret --days 7
-
-      # List baked recipe ids
-      agents insights recipes
     `,
         notes: `
       Session recipes read sessions.db; resource recipes read ~/.agents/.history/analytics/usage.db.
-      Empty recipes are skipped on the default mix board.
+      Empty recipes are skipped on the default mix board. Pass one recipe id
+      (\`agents insights mix harness-mix\`) for just that section; \`--list\` names them.
       This is the cheap counter path. Behavioural report (transcript content, account split)
-      is bare \`agents insights\`. Latency is \`agents perf\`; quota is \`agents view\`.
+      is bare \`agents insights\`. Latency is \`agents insights perf\`; quota is \`agents view\`.
       Skill/slash-command popularity is \`agents sessions stats\`.
     `,
     });
-    parent.command('recipes')
-        .description('List baked mix-recipe ids')
-        .option('--json', 'Emit JSON')
-        .action(function recipes() {
-        const o = this.optsWithGlobals();
-        const list = listRecipes();
-        if (o.json) {
-            console.log(JSON.stringify(list, null, 2));
-            return;
-        }
-        for (const r of list) {
-            console.log(`${r.id.padEnd(22)} ${r.store.padEnd(10)} ${r.title}`);
-        }
-    });
     parent.command('query')
         .description('Raw usage-event query (usage.db)')
         .option('--kind <kind>', `One of: ${USAGE_KINDS.join(', ')}`)
@@ -164,46 +183,4 @@ export function registerMixCommands(parent) {
             })),
         });
     });
-    for (const id of RECIPE_IDS) {
-        parent.command(id)
-            .description(`Mix recipe: ${id}`)
-            .option('--days <n>', 'Days of history', '7')
-            .option('--json', 'Emit JSON')
-            .action(function recipeAction() {
-            // optsWithGlobals() merges the `insights` parent opts, so the name-colliding
-            // --json/--since reach this leaf (see the sibling commands above).
-            const o = this.optsWithGlobals();
-            const win = analyticsWindow(parseMixDays(o.days));
-            const section = runRecipe(id, win);
-            if (o.json) {
-                console.log(JSON.stringify({ window: win, section }, null, 2));
-                return;
-            }
-            if (section.empty) {
-                console.log(chalk.gray(`No data for recipe '${id}' in the last ${win.days} days.`));
-                return;
-            }
-            printMixSection(section);
-        });
-    }
-    // Nested home for the former top-level `agents trends` spelling.
-    const trends = parent
-        .command('trends')
-        .description('Alias of `mix` — former top-level `agents trends`')
-        .option('--days <n>', 'Days of history to include', '7')
-        .option('--json', 'Emit JSON instead of tables')
-        .action(function summary() {
-        const o = this.optsWithGlobals();
-        renderMixDashboard(parseMixDays(o.days), Boolean(o.json), banner);
-    });
-    setHelpSections(trends, {
-        examples: `
-      agents insights trends
-      agents insights mix
-    `,
-        notes: `
-      \`agents insights trends\` is the nested spelling of the former top-level
-      \`agents trends\`. Prefer \`agents insights mix\`.
-    `,
-    });
 }

package/dist/lib/auth-mint.d.ts

@@ -143,7 +143,17 @@ export interface MintAndSeedResult {
  */
 export declare function mintAndSeed(input: MintAndSeedInput): Promise<MintAndSeedResult>;
 export declare function resolveSyncTargets(fleet: boolean, devices: string[]): Promise<string[]>;
-/** True when a Claude setup-token is already seeded on this box (setup status). */
+/**
+ * True when a Claude setup-token is already seeded on this box (setup status).
+ *
+ * Read-only status probe (`agents setup`, `agents doctor`) — the reserved
+ * auth-bundle check below MUST NOT crash the whole command because the
+ * keychain could not be reached (e.g. the macOS Keychain helper source is
+ * unavailable — PHNX-3385); `bundleExists()`/`hasKeychainToken()` document
+ * themselves as failing loud, but that contract is for destructive-write
+ * guards, not a diagnostic. An unreachable keychain here just means "cannot
+ * confirm the reserved bundle," reported honestly rather than propagated.
+ */
 export declare function hasMintedSetupToken(): {
     ready: boolean;
     detail: string;

package/dist/lib/auth-mint.js

@@ -414,18 +414,33 @@ async function syncMintedBundles(accountName, device) {
         return { device, ok: false, message: err instanceof Error ? err.message : String(err) };
     }
 }
-/** True when a Claude setup-token is already seeded on this box (setup status). */
+/**
+ * True when a Claude setup-token is already seeded on this box (setup status).
+ *
+ * Read-only status probe (`agents setup`, `agents doctor`) — the reserved
+ * auth-bundle check below MUST NOT crash the whole command because the
+ * keychain could not be reached (e.g. the macOS Keychain helper source is
+ * unavailable — PHNX-3385); `bundleExists()`/`hasKeychainToken()` document
+ * themselves as failing loud, but that contract is for destructive-write
+ * guards, not a diagnostic. An unreachable keychain here just means "cannot
+ * confirm the reserved bundle," reported honestly rather than propagated.
+ */
 export function hasMintedSetupToken() {
     const records = Object.values(readAccountRegistry().accounts);
     const setup = records.filter((a) => a.auth === 'setup-token' && a.provider === 'anthropic');
     if (setup.length) {
         return { ready: true, detail: `${setup.length} Claude setup-token account${setup.length === 1 ? '' : 's'}` };
     }
-    if (bundleExists(AUTH_BUNDLE) && bundleBackend(AUTH_BUNDLE) === 'file') {
-        const bundle = readBundle(AUTH_BUNDLE);
-        const keys = Object.keys(bundle.vars).filter((k) => k.startsWith('CLAUDE_CODE_OAUTH_TOKEN_'));
-        if (keys.length)
-            return { ready: true, detail: `reserved auth bundle (${keys.length} account key${keys.length === 1 ? '' : 's'})` };
+    try {
+        if (bundleExists(AUTH_BUNDLE) && bundleBackend(AUTH_BUNDLE) === 'file') {
+            const bundle = readBundle(AUTH_BUNDLE);
+            const keys = Object.keys(bundle.vars).filter((k) => k.startsWith('CLAUDE_CODE_OAUTH_TOKEN_'));
+            if (keys.length)
+                return { ready: true, detail: `reserved auth bundle (${keys.length} account key${keys.length === 1 ? '' : 's'})` };
+        }
+    }
+    catch (err) {
+        return { ready: false, detail: `could not check the reserved auth bundle: ${err.message}` };
     }
     return { ready: false, detail: 'no Claude setup-token minted — agents accounts mint claude' };
 }

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

@@ -12,6 +12,14 @@ export declare function getSocketPath(): string;
 /** Is the daemon reachable? A real connect probe on every platform — a socket
  * file existing on disk is not proof a daemon is listening on it. */
 export declare function isDaemonReachable(): Promise<boolean>;
+/**
+ * Is a *reachable* daemon actually responsive, or is its event loop wedged
+ * (PHNX-3411)? Retries {@link probeDaemonResponsive} up to
+ * {@link RESPONSIVENESS_PROBE_ATTEMPTS} times so a single transient miss (a GC
+ * pause) never condemns a healthy daemon; returns true as soon as any attempt
+ * gets a reply, and false only when every attempt fails.
+ */
+export declare function isDaemonResponsive(endpoint?: string, attempts?: number): Promise<boolean>;
 /**
  * Wait until the browser daemon is genuinely reachable, or throw.
  *

package/dist/lib/browser/ipc.js

@@ -92,6 +92,31 @@ const SOCKET_WAIT_TIMEOUT_MS = 15_000;
  * doesn't race a restart it happened to probe mid-flight.
  */
 const SOCKET_WAIT_STABLE_PROBES = 2;
+/**
+ * How long a single {@link probeDaemonResponsive} attempt waits for the daemon to
+ * answer a trivial `version` request before giving up (PHNX-3411).
+ *
+ * A unix-socket `connect` succeeds at the KERNEL level the moment the connection
+ * is queued in the listen backlog — it does NOT require the server's event loop
+ * to run. So a daemon whose event loop is blocked (e.g. a long synchronous burst
+ * on the shared loop) still passes {@link isDaemonReachable}: the socket accepts,
+ * but the request is never serviced. The live symptom on zion was exactly this —
+ * `browser.sock` accepted every connection while the daemon re-indexed sessions,
+ * then never replied, so cross-device browser drives hung or surfaced a confusing
+ * bare socket timeout. Requiring an actual reply is the only probe that tells a
+ * healthy daemon apart from a wedged one.
+ */
+const RESPONSIVENESS_PROBE_TIMEOUT_MS = 1_500;
+/**
+ * Consecutive missed {@link probeDaemonResponsive} attempts before a *reachable*
+ * daemon is declared wedged. One missed reply can be a transient GC pause on an
+ * otherwise-healthy loop, so a single failure never condemns the daemon; a daemon
+ * that cannot answer a trivial `version` request across this whole window has a
+ * genuinely blocked event loop. The added latency (attempts × timeout) is paid
+ * ONLY on the wedged path — where the alternative was an indefinite hang — while
+ * a healthy daemon answers the first attempt in ~1ms.
+ */
+const RESPONSIVENESS_PROBE_ATTEMPTS = 3;
 export class BrowserDaemonNotRunningError extends Error {
     constructor() {
         super(formatBrowserDaemonNotRunningError());
@@ -140,6 +165,57 @@ function probeDaemon(endpoint, timeoutMs = 500) {
 export async function isDaemonReachable() {
     return probeDaemon(getIpcEndpoint());
 }
+/**
+ * Can the daemon actually REPLY right now? Opens a connection and requires a
+ * parseable response to a `version` request within `timeoutMs`. Unlike
+ * {@link probeDaemon} (which resolves on the kernel-level `connect`), this only
+ * succeeds when the daemon's event loop is running and services the request — so
+ * it is the one probe that distinguishes a healthy daemon from a wedged one whose
+ * loop is blocked (PHNX-3411). Resolves false on connect error, timeout, an early
+ * close, or an unparseable reply. `version` is the right probe: its handler is
+ * trivial and synchronous (never touches the browser), so a slow reply means the
+ * loop is blocked, not that a real action is in flight.
+ */
+function probeDaemonResponsive(endpoint, timeoutMs = RESPONSIVENESS_PROBE_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const sock = net.createConnection(endpoint);
+        let buffer = '';
+        let done = false;
+        const finish = (ok) => { if (done)
+            return; done = true; clearTimeout(timer); sock.destroy(); resolve(ok); };
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        sock.on('connect', () => { sock.write(JSON.stringify({ action: 'version' }) + '\n'); });
+        sock.on('data', (data) => {
+            buffer += data.toString();
+            const idx = buffer.indexOf('\n');
+            if (idx === -1)
+                return;
+            try {
+                const resp = JSON.parse(buffer.slice(0, idx));
+                finish(resp.ok === true);
+            }
+            catch {
+                finish(false);
+            }
+        });
+        sock.on('error', () => finish(false));
+        sock.on('close', () => finish(false));
+    });
+}
+/**
+ * Is a *reachable* daemon actually responsive, or is its event loop wedged
+ * (PHNX-3411)? Retries {@link probeDaemonResponsive} up to
+ * {@link RESPONSIVENESS_PROBE_ATTEMPTS} times so a single transient miss (a GC
+ * pause) never condemns a healthy daemon; returns true as soon as any attempt
+ * gets a reply, and false only when every attempt fails.
+ */
+export async function isDaemonResponsive(endpoint = getIpcEndpoint(), attempts = RESPONSIVENESS_PROBE_ATTEMPTS) {
+    for (let i = 0; i < attempts; i++) {
+        if (await probeDaemonResponsive(endpoint))
+            return true;
+    }
+    return false;
+}
 /**
  * Wait until the browser daemon is genuinely reachable, or throw.
  *
@@ -1087,6 +1163,17 @@ async function prepareIPC(action, opts) {
         }
         await new Promise((r) => setTimeout(r, 300));
     }
+    // The socket accepts connections — but a unix-socket `connect` succeeds at the
+    // kernel level even when the daemon's event loop is blocked and never services
+    // the request (PHNX-3411). Require a real reply before treating the daemon as
+    // usable, so a wedged daemon fails LOUD with an accurate, actionable error
+    // instead of the confusing bare socket timeout / indefinite hang the browser
+    // verb would otherwise hit (including inside reconcileDaemonVersion's own
+    // version probe, which has no response timeout). Skipped for callers that opt
+    // out of auto-start — they want the clean BrowserDaemonNotRunningError instead.
+    if (autoStartDaemon && !(await isDaemonResponsive(getIpcEndpoint()))) {
+        throw new Error(actionable('Browser daemon is running but unresponsive — its event loop is blocked, so it accepts the connection but never replies.', `Endpoint: ${getIpcEndpoint()}`, `Log: ${getDaemonLogPath()}`, 'Next: agents browser stop --daemon   (resets the wedged daemon; the next browser command restarts it)'));
+    }
     // Before serving a real request, make sure the daemon isn't running stale
     // code. Skips the internal `version` probe (avoids recursion) and callers
     // that opt out of auto-start. No-ops once reconciled or when versions match.

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

@@ -534,6 +534,25 @@ export declare class BrowserService {
      * tasks.json entries. Used before identity-based resolution so a daemon
      * restart does not make the caller's tasks invisible.
      */
+    /**
+     * Register a freshly-rehydrated connection, unless a concurrent rehydrate won
+     * the race and already registered one for this key. `attachRunningProfile`
+     * awaits an ssh-tunnel spawn / CDP connect, so two commands landing right
+     * after a daemon restart can each build a connection for the same key; the
+     * loser must be released instead of silently overwriting the winner (whose
+     * `cleanup` would then never run).
+     *
+     * The subtlety is the SSH tunnel: when the loser's `connectSSH` landed after
+     * the winner's tunnel had already bound the local port, `isOwnTunnel` makes it
+     * **reuse** that same OS process (`drivers/ssh.ts`) — so both connections carry
+     * the same `pid`/`port`. Calling the loser's `cleanup()` then does
+     * `tunnel.kill()` on the SHARED process and breaks the winner's live CDP. So
+     * when the loser shares the winner's tunnel we close ONLY the loser's own CDP
+     * socket and leave the tunnel to the winner; only a loser that spawned its own
+     * distinct tunnel gets the full `cleanup()` (else it would leak). Returns the
+     * winning connection to use.
+     */
+    private registerRehydratedConnection;
     private rehydrateAllFromDisk;
     /**
      * On a RAM miss, scan profile runtime dirs for a tasks.json entry matching

package/dist/lib/browser/service.js

@@ -2608,9 +2608,45 @@ export class BrowserService {
         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;
+        // ssh:// endpoints: a daemon restart killed this box's tunnel, but the
+        // browser is still running on the FAR side — so the caller's tasks are
+        // valid, only the local hop is gone. Re-establish the tunnel and reconnect
+        // CDP (connectSSH attaches to the already-running remote browser via
+        // isOwnTunnel — it never launches one, so this stays a soft-attach), then
+        // merge the disk tasks. Without this, a remote agent driving a browser host
+        // after a restart got "Unknown browser task" for a tab that was still alive
+        // (PHNX-2663). A failure returns null exactly like the local-CDP path, so
+        // the caller falls through to disk reconcile rather than crashing.
+        if (resolved.target.startsWith('ssh:')) {
+            try {
+                const conn = await connectSSH(resolved.target, profile, key, { persistRemote: true });
+                await this.enableDomains(conn.cdp);
+                const tasks = this.loadTaskState(key);
+                for (const [k, t] of diskTasks) {
+                    if (!tasks.has(k))
+                        tasks.set(k, t);
+                }
+                return {
+                    cdp: conn.cdp,
+                    port: conn.port,
+                    pid: conn.pid,
+                    electron: profile.electron,
+                    browserType: profile.browser,
+                    targetFilter: resolved.targetFilter ?? profile.targetFilter,
+                    key,
+                    profile: bare,
+                    tasks,
+                    sessionCache: new Map(),
+                    // Carry the tunnel teardown so removing this connection kills the
+                    // ssh hop — otherwise it leaks across the next restart (see the
+                    // `cleanup` docblock on ProfileConnection).
+                    cleanup: conn.cleanup,
+                };
+            }
+            catch {
+                return null;
+            }
+        }
         try {
             const { wsUrl, browser } = await discoverBrowserWsUrl(port, host, bare);
             verifyBrowserIdentity(browser, profile.browser, port, host);
@@ -2645,6 +2681,48 @@ export class BrowserService {
      * tasks.json entries. Used before identity-based resolution so a daemon
      * restart does not make the caller's tasks invisible.
      */
+    /**
+     * Register a freshly-rehydrated connection, unless a concurrent rehydrate won
+     * the race and already registered one for this key. `attachRunningProfile`
+     * awaits an ssh-tunnel spawn / CDP connect, so two commands landing right
+     * after a daemon restart can each build a connection for the same key; the
+     * loser must be released instead of silently overwriting the winner (whose
+     * `cleanup` would then never run).
+     *
+     * The subtlety is the SSH tunnel: when the loser's `connectSSH` landed after
+     * the winner's tunnel had already bound the local port, `isOwnTunnel` makes it
+     * **reuse** that same OS process (`drivers/ssh.ts`) — so both connections carry
+     * the same `pid`/`port`. Calling the loser's `cleanup()` then does
+     * `tunnel.kill()` on the SHARED process and breaks the winner's live CDP. So
+     * when the loser shares the winner's tunnel we close ONLY the loser's own CDP
+     * socket and leave the tunnel to the winner; only a loser that spawned its own
+     * distinct tunnel gets the full `cleanup()` (else it would leak). Returns the
+     * winning connection to use.
+     */
+    registerRehydratedConnection(key, conn) {
+        const existing = this.connections.get(key);
+        if (!existing) {
+            this.connections.set(key, conn);
+            return conn;
+        }
+        const sharesTunnel = conn.pid !== 0 && conn.pid === existing.pid && conn.port === existing.port;
+        if (conn.pid !== 0 && !sharesTunnel && conn.cleanup) {
+            // Distinct tunnel — full teardown so this loser's tunnel doesn't leak.
+            try {
+                conn.cleanup();
+            }
+            catch { /* best effort — the winner stays live */ }
+        }
+        else {
+            // Shared/borrowed tunnel (or a local connection with no tunnel): close
+            // only our own CDP client; killing the tunnel would break the winner.
+            try {
+                conn.cdp.close();
+            }
+            catch { /* best effort */ }
+        }
+        return existing;
+    }
     async rehydrateAllFromDisk() {
         const runtimeRoot = getBrowserRuntimeDir();
         let dirNames = [];
@@ -2676,7 +2754,11 @@ export class BrowserService {
             const conn = await this.attachRunningProfile(key, tasks);
             if (!conn)
                 continue;
-            this.connections.set(key, conn);
+            // A concurrent rehydrate may have registered one for this key while we
+            // awaited the attach; keep the winner and tear our loser's tunnel down.
+            const registered = this.registerRehydratedConnection(key, conn);
+            if (registered !== conn)
+                continue;
             try {
                 await this.applyDefaultDownloadBehavior(conn, key);
             }
@@ -2734,13 +2816,16 @@ export class BrowserService {
                     // CDP down — cannot rehydrate a live connection; caller will error.
                     continue;
                 }
-                conn = attached;
-                this.connections.set(key, conn);
-                try {
-                    await this.applyDefaultDownloadBehavior(conn, key);
-                }
-                catch {
-                    // Non-fatal.
+                // Keep whichever connection a concurrent rehydrate registered first and
+                // tear our loser's tunnel down instead of leaking it (see the helper).
+                conn = this.registerRehydratedConnection(key, attached);
+                if (conn === attached) {
+                    try {
+                        await this.applyDefaultDownloadBehavior(conn, key);
+                    }
+                    catch {
+                        // Non-fatal.
+                    }
                 }
             }
             const task = this.lookupTaskOnConn(conn, taskId) ?? found;

package/dist/lib/browser/sessions-list.js

@@ -21,6 +21,7 @@ import { formatBytes } from '../format.js';
 export { formatBytes };
 import * as path from 'path';
 import { getBrowserRuntimeDir, getProfileRuntimeDir } from './profiles.js';
+import { listProfileCacheDirs } from './runtime-state.js';
 import { formatRelativeTime } from '../session/relative-time.js';
 import { getSessionById, listBrowserSessionRecords, pruneToolSessions } from '../session/db.js';
 import { listPidSessionEntries } from '../session/pid-registry.js';
@@ -99,7 +100,15 @@ export function listProfileArtifacts(profile) {
 export function listBrowserSessions(only) {
     let profiles;
     if (only) {
-        profiles = [only];
+        // A profile's live tasks/captures may live under a composite runtime dir
+        // (`<name>@<device>`, `<name>@endpoint-N`, forks) — NOT the bare `<name>`
+        // dir. Resolve `only` to every cache dir that belongs to it, the same rule
+        // status()/findTask use (keyBelongsToProfile), so `--profile comet-local`
+        // surfaces the real `comet-local@zion` store instead of the empty legacy
+        // dir. Keep the requested name when nothing exists on disk yet so a fresh
+        // profile still returns its (empty) entry rather than vanishing.
+        const dirs = listProfileCacheDirs(only).map((d) => path.basename(d));
+        profiles = dirs.length > 0 ? dirs : [only];
     }
     else {
         try {

package/dist/lib/daemon/daemon.js

@@ -41,6 +41,7 @@ import { DeviceProbeService } from './device-probe-service.js';
 import { SelfHealService } from './self-heal-service.js';
 import { KeychainReapService } from './keychain-reap-service.js';
 import { AuthSyncService } from './auth-sync-service.js';
+import { UsageSyncService } from './usage-sync-service.js';
 import { StateDirCheckService } from './state-dir-check-service.js';
 import { SessionStateService } from './session-state-service.js';
 import { WebhookReceiverService } from './webhook-receiver-service.js';
@@ -858,6 +859,10 @@ export async function runDaemon() {
         supervisor.register(new AuthSyncService());
     else
         log('INFO', 'Auth-sync service disabled');
+    if (isEnabled('usage-sync'))
+        supervisor.register(new UsageSyncService());
+    else
+        log('INFO', 'Usage-sync service disabled');
     if (isEnabled('webhook-receiver'))
         supervisor.register(new WebhookReceiverService());
     else

package/dist/lib/daemon/runner.d.ts

@@ -113,6 +113,8 @@ export interface RoutineLaunchPlan {
     /** False when `account` names a harness-native login rather than a durable credential. */
     forwardAccount?: boolean;
 }
+/** Claude's own local auth check; unlike account metadata it cannot mistake identity for a usable login. */
+export declare function claudeVersionIsAuthenticated(version: string): boolean;
 /**
  * Resolve the version/account chain for a routine the same way `agents run`
  * does: honor an explicit `version:` pin; otherwise use the configured run
@@ -130,6 +132,7 @@ export declare function resolveRoutineLaunch(config: JobConfig, cwd?: string, de
     resolveCredentialAccount?: (name: string, host: AgentId) => {
         env: Record<string, string>;
     };
+    claudeVersionIsAuthenticated?: typeof claudeVersionIsAuthenticated;
 }): Promise<RoutineLaunchPlan>;
 /**
  * Rewrite `cmd[0]` to the absolute binary for `agent@version` when installed.