@phnx-labs/agents-cli 1.20.51 → 1.20.53

package/dist/lib/browser/login-detection.js

@@ -0,0 +1,274 @@
+/**
+ * Best-effort login-state detection for browser profiles.
+ *
+ * Reads a profile's Chromium cookie store (presence only — never decrypts the
+ * Keychain-encrypted values) to tell which login-gated services have a live
+ * session in that profile. Powers the `agents browser start` guardrail (warn
+ * when an agent opens a logged-out profile for a login-gated URL) and the
+ * `agents browser profiles logins` view.
+ *
+ * Everything here is advisory: any failure (missing DB, locked file, unknown
+ * schema) degrades to "no known session" and NEVER throws to callers — browser
+ * start must not slow down or break because cookie inspection hiccuped.
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import Database from '../sqlite.js';
+import { getBrowserRuntimeDir, listProfiles } from './profiles.js';
+/**
+ * Known login-gated services. Presence of ANY listed cookie on a matching host
+ * (unexpired, or a session cookie) = logged in. Deliberately conservative: a
+ * service absent from this map simply never triggers a warning — we do not
+ * guess. Each cookie name here is the definitive authenticated-session token for
+ * that service (e.g. LinkedIn's `li_at` is only set for a signed-in member;
+ * visitor cookies like `bcookie`/`JSESSIONID` are NOT auth). Services whose
+ * session is not reliably expressed as a recognizable cookie (e.g. Attio, whose
+ * only same-site cookies are third-party analytics) are deliberately omitted so
+ * we never emit a false "logged out" warning. Extend as needed.
+ */
+export const AUTH_SIGNATURES = {
+    linkedin: {
+        hosts: ['linkedin.com'],
+        cookies: ['li_at'],
+        login: { loginUrl: 'https://www.linkedin.com/login', keyPrefix: 'LINKEDIN' },
+    },
+    google: {
+        hosts: ['google.com'],
+        cookies: ['SID', 'SAPISID', '__Secure-1PSID', '__Secure-3PSID'],
+        login: { loginUrl: 'https://accounts.google.com/', keyPrefix: 'GOOGLE' },
+    },
+    x: {
+        hosts: ['x.com', 'twitter.com'],
+        cookies: ['auth_token'],
+        login: { loginUrl: 'https://x.com/login', keyPrefix: 'X' },
+    },
+    reddit: {
+        hosts: ['reddit.com'],
+        cookies: ['reddit_session', 'token_v2'],
+        login: { loginUrl: 'https://www.reddit.com/login', keyPrefix: 'REDDIT' },
+    },
+    github: {
+        hosts: ['github.com'],
+        cookies: ['user_session'],
+        login: { loginUrl: 'https://github.com/login', keyPrefix: 'GITHUB' },
+    },
+};
+/**
+ * The bundle keys a profile's `--secrets` bundle should hold to log into
+ * `service`: `<PREFIX>_USERNAME` / `<PREFIX>_PASSWORD`. Null for services with no
+ * login metadata. Feed a resolved value to the page with
+ * `agents browser type <ref> --secret <bundle>/<KEY>` (never printed).
+ */
+export function credKeysForService(service) {
+    const login = AUTH_SIGNATURES[service]?.login;
+    if (!login)
+        return null;
+    return { user: `${login.keyPrefix}_USERNAME`, pass: `${login.keyPrefix}_PASSWORD` };
+}
+/** The interactive login URL for a service, or null. */
+export function loginUrlForService(service) {
+    return AUTH_SIGNATURES[service]?.login?.loginUrl ?? null;
+}
+/**
+ * Current time as microseconds since 1601-01-01 (Chromium's `expires_utc`
+ * epoch), as a BigInt. Chromium expiries routinely exceed 2^53, so this is
+ * bound into SQL as a BigInt and the comparison happens IN SQLite — the huge
+ * integer never marshals back to JS (node:sqlite throws RangeError if it does).
+ * 11644473600000 = ms between 1601-01-01 and 1970-01-01.
+ */
+function chromeNowMicrosBigInt() {
+    return (BigInt(Date.now()) + 11644473600000n) * 1000n;
+}
+function hostMatches(hostKey, host) {
+    return hostKey === host || hostKey === '.' + host || hostKey.endsWith('.' + host);
+}
+/**
+ * Pure core: given a profile's (already expiry-filtered) cookie rows, return the
+ * services with a live session. Exported for direct unit testing without disk.
+ */
+export function detectServices(rows) {
+    const services = [];
+    for (const [service, sig] of Object.entries(AUTH_SIGNATURES)) {
+        const found = rows.some((r) => sig.cookies.includes(r.name) && sig.hosts.some((h) => hostMatches(r.host_key, h)));
+        if (found)
+            services.push(service);
+    }
+    return services;
+}
+/** Map a URL to a known login-gated service key, or null. */
+export function serviceForUrl(url) {
+    let host;
+    try {
+        host = new URL(url).hostname;
+    }
+    catch {
+        return null;
+    }
+    for (const [service, sig] of Object.entries(AUTH_SIGNATURES)) {
+        if (sig.hosts.some((h) => host === h || host.endsWith('.' + h)))
+            return service;
+    }
+    return null;
+}
+/**
+ * Locate candidate Chromium DBs for a profile at the given relative paths. The
+ * live runtime dir is keyed by the composite `<profile>@<endpoint>` name, so we
+ * scan the browser cache root for `<profile>` and `<profile>@*` dirs and return
+ * every matching DB found, most-recently-modified first.
+ */
+function profileDbCandidates(profileName, relPaths) {
+    const root = getBrowserRuntimeDir();
+    let entries;
+    try {
+        entries = fs.readdirSync(root);
+    }
+    catch {
+        return [];
+    }
+    const dirs = entries.filter((e) => e === profileName || e.startsWith(profileName + '@'));
+    const found = [];
+    for (const d of dirs) {
+        for (const rel of relPaths) {
+            const p = path.join(root, d, ...rel);
+            try {
+                found.push({ p, mtime: fs.statSync(p).mtimeMs });
+            }
+            catch {
+                /* not present */
+            }
+        }
+    }
+    return found.sort((a, b) => b.mtime - a.mtime).map((f) => f.p);
+}
+function cookieDbCandidates(profileName) {
+    return profileDbCandidates(profileName, [
+        ['chrome-data', 'Default', 'Cookies'],
+        ['chrome-data', 'Default', 'Network', 'Cookies'],
+    ]);
+}
+function loginDbCandidates(profileName) {
+    return profileDbCandidates(profileName, [['chrome-data', 'Default', 'Login Data']]);
+}
+/**
+ * Open a Chromium SQLite store safely: copy the DB (and any WAL/SHM sidecars) to
+ * a temp dir first so a running browser's lock never blocks us and we never
+ * touch the live file, run `fn`, then clean up. Returns `fallback` on any error.
+ */
+function withCopiedDb(dbPath, fn, fallback) {
+    let tmpDir = null;
+    try {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agents-browserdb-'));
+        const tmpDb = path.join(tmpDir, 'db');
+        fs.copyFileSync(dbPath, tmpDb);
+        for (const suffix of ['-wal', '-shm']) {
+            if (fs.existsSync(dbPath + suffix))
+                fs.copyFileSync(dbPath + suffix, tmpDb + suffix);
+        }
+        const db = new Database(tmpDb);
+        try {
+            return fn(db);
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return fallback;
+    }
+    finally {
+        if (tmpDir) {
+            try {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch {
+                /* temp cleanup best-effort */
+            }
+        }
+    }
+}
+/** Read (expiry-filtered) cookie rows from a Chromium cookie DB. [] on failure. */
+function readCookieRows(dbPath) {
+    return withCopiedDb(dbPath, (db) => {
+        // Filter expiry in SQL (session cookies have expires_utc = 0; otherwise it
+        // must be in the future) and select only text columns, so the huge
+        // microsecond integer never crosses into JS.
+        const rows = db
+            .prepare('SELECT host_key, name FROM cookies WHERE expires_utc = 0 OR expires_utc > ?')
+            .all(chromeNowMicrosBigInt());
+        return rows.map((r) => ({
+            host_key: String(r.host_key ?? ''),
+            name: String(r.name ?? ''),
+        }));
+    }, []);
+}
+/** Read saved-login rows from a Chromium `Login Data` DB. Skips
+ *  user-blacklisted origins ("never save"). Selects only text columns —
+ *  `password_value` (encrypted) is never touched. [] on failure. */
+function readLoginRows(dbPath) {
+    return withCopiedDb(dbPath, (db) => {
+        const rows = db
+            .prepare('SELECT origin_url, username_value, signon_realm FROM logins WHERE blacklisted_by_user = 0')
+            .all();
+        return rows.map((r) => ({
+            origin_url: String(r.origin_url ?? ''),
+            username_value: String(r.username_value ?? ''),
+            signon_realm: String(r.signon_realm ?? ''),
+        }));
+    }, []);
+}
+/**
+ * Map a profile's saved logins to service → account username (identity, not
+ * session). Best-effort; `{}` if `Login Data` is unreadable. The first non-empty
+ * username per service wins.
+ */
+export async function accountsForProfile(profileName) {
+    const candidates = loginDbCandidates(profileName);
+    if (candidates.length === 0)
+        return {};
+    const rows = readLoginRows(candidates[0]);
+    const out = {};
+    for (const r of rows) {
+        if (!r.username_value)
+            continue;
+        const service = serviceForUrl(r.origin_url) ?? serviceForUrl(r.signon_realm);
+        if (service && !out[service])
+            out[service] = r.username_value;
+    }
+    return out;
+}
+/**
+ * For each service with a LIVE session in the profile (cookie-gated), the
+ * account it is signed in as (from saved logins). Intersecting with live
+ * sessions means a stale saved-login for a service you've since logged out of
+ * never shows.
+ */
+export async function loginsWithAccountsForProfile(profileName) {
+    const active = await loginsForProfile(profileName);
+    if (active.length === 0)
+        return [];
+    const accounts = await accountsForProfile(profileName);
+    return active.map((service) => ({ service, username: accounts[service] }));
+}
+/** Services with a live session in the given profile (best-effort; [] if none
+ *  detected or the cookie store is unreadable). */
+export async function loginsForProfile(profileName) {
+    const candidates = cookieDbCandidates(profileName);
+    if (candidates.length === 0)
+        return [];
+    const rows = readCookieRows(candidates[0]);
+    if (rows.length === 0)
+        return [];
+    return detectServices(rows);
+}
+/** Profile names that have a live session for the given service. */
+export async function profilesLoggedInto(service) {
+    const profiles = await listProfiles();
+    const out = [];
+    for (const p of profiles) {
+        const logins = await loginsForProfile(p.name);
+        if (logins.includes(service))
+            out.push(p.name);
+    }
+    return out;
+}

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

@@ -1,20 +1,29 @@
 import type { BrowserProfile } from './types.js';
 export type { BrowserProfile } from './types.js';
 export declare const DEFAULT_BROWSER_PROFILE_NAME = "default";
+/**
+ * The device-local configured default profile name (set via
+ * `agents browser profiles set-default`), or undefined when unset. When set, it
+ * is the profile `agents browser start` resolves to for BOTH the no-`--profile`
+ * path and an explicit `--profile default`. Stored per-machine — see
+ * `Meta.defaultBrowserProfile`.
+ */
+export declare function getConfiguredDefaultProfileName(): string | undefined;
 export declare function getBrowserRuntimeDir(): string;
 export declare function getProfileRuntimeDir(name: string): string;
 export declare function listProfiles(): Promise<BrowserProfile[]>;
 export declare function getProfile(name: string): Promise<BrowserProfile | null>;
 /**
- * Ensure a `default` profile exists, auto-picking the first installed
- * Chromium-family browser per the platform priority list in chrome.ts.
+ * Resolve the profile `agents browser start` uses when no `--profile` is given.
  *
- * Re-uses an existing `default` profile as-is (we don't second-guess the user
- * if they've already customized it). On first run we walk the priority list
- * (macOS: chrome > brave > edge > chromium > comet; Linux: chrome > chromium >
- * brave > edge; Windows: edge > chrome > brave > comet) and pin the profile to the
- * first match. Throws an actionable error if none of those binaries are
- * installed so the user knows exactly which browsers we'd accept.
+ * Order: (1) the device-local configured default (`agents browser profiles
+ * set-default <name>`) when it names an existing profile; (2) an existing
+ * `default` profile as-is; (3) auto-pick the first installed Chromium-family
+ * browser per the platform priority list in chrome.ts (macOS: chrome > brave >
+ * edge > chromium > comet; Linux: chrome > chromium > brave > edge; Windows:
+ * edge > chrome > brave > comet) and pin a new `default` profile to it. Throws an
+ * actionable error if none of those binaries are installed. A configured default
+ * that no longer exists warns and falls through to (2)/(3) — never a hard fail.
  */
 export declare function ensureDefaultBrowserProfile(): Promise<BrowserProfile>;
 /**

package/dist/lib/browser/profiles.js

@@ -3,6 +3,16 @@ import { getBrowserRuntimeDir as getBrowserRuntimeDirRoot, readMeta, writeMeta,
 import { findBrowserPath, findFirstInstalledBrowser, isPortInUse } from './chrome.js';
 import { DEFAULT_VIEWPORT } from './devices.js';
 export const DEFAULT_BROWSER_PROFILE_NAME = 'default';
+/**
+ * The device-local configured default profile name (set via
+ * `agents browser profiles set-default`), or undefined when unset. When set, it
+ * is the profile `agents browser start` resolves to for BOTH the no-`--profile`
+ * path and an explicit `--profile default`. Stored per-machine — see
+ * `Meta.defaultBrowserProfile`.
+ */
+export function getConfiguredDefaultProfileName() {
+    return readMeta().defaultBrowserProfile || undefined;
+}
 export function getBrowserRuntimeDir() {
     return getBrowserRuntimeDirRoot();
 }
@@ -69,17 +79,26 @@ export async function getProfile(name) {
     return configToProfile(name, config);
 }
 /**
- * Ensure a `default` profile exists, auto-picking the first installed
- * Chromium-family browser per the platform priority list in chrome.ts.
+ * Resolve the profile `agents browser start` uses when no `--profile` is given.
  *
- * Re-uses an existing `default` profile as-is (we don't second-guess the user
- * if they've already customized it). On first run we walk the priority list
- * (macOS: chrome > brave > edge > chromium > comet; Linux: chrome > chromium >
- * brave > edge; Windows: edge > chrome > brave > comet) and pin the profile to the
- * first match. Throws an actionable error if none of those binaries are
- * installed so the user knows exactly which browsers we'd accept.
+ * Order: (1) the device-local configured default (`agents browser profiles
+ * set-default <name>`) when it names an existing profile; (2) an existing
+ * `default` profile as-is; (3) auto-pick the first installed Chromium-family
+ * browser per the platform priority list in chrome.ts (macOS: chrome > brave >
+ * edge > chromium > comet; Linux: chrome > chromium > brave > edge; Windows:
+ * edge > chrome > brave > comet) and pin a new `default` profile to it. Throws an
+ * actionable error if none of those binaries are installed. A configured default
+ * that no longer exists warns and falls through to (2)/(3) — never a hard fail.
  */
 export async function ensureDefaultBrowserProfile() {
+    const configured = getConfiguredDefaultProfileName();
+    if (configured) {
+        const chosen = await getProfile(configured);
+        if (chosen)
+            return chosen;
+        console.warn(`warning: configured default browser profile "${configured}" no longer exists; ` +
+            `falling back to auto-detect. Fix with: agents browser profiles set-default <name>  (or --unset)`);
+    }
     const existing = await getProfile(DEFAULT_BROWSER_PROFILE_NAME);
     if (existing)
         return existing;

package/dist/lib/browser/secret-ref.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parse a `<bundle>/<KEY>` reference (optionally `secret:<bundle>/<KEY>`) used by
+ * `agents browser type --secret` to feed a credential from an `agents secrets`
+ * bundle into a page WITHOUT the value ever crossing stdout or the transcript.
+ * Returns null on a malformed ref.
+ */
+export declare function parseSecretRef(ref: string): {
+    bundle: string;
+    key: string;
+} | null;

package/dist/lib/browser/secret-ref.js

@@ -0,0 +1,14 @@
+/**
+ * Parse a `<bundle>/<KEY>` reference (optionally `secret:<bundle>/<KEY>`) used by
+ * `agents browser type --secret` to feed a credential from an `agents secrets`
+ * bundle into a page WITHOUT the value ever crossing stdout or the transcript.
+ * Returns null on a malformed ref.
+ */
+export function parseSecretRef(ref) {
+    const body = ref.startsWith('secret:') ? ref.slice('secret:'.length) : ref;
+    const slash = body.indexOf('/');
+    // Need a non-empty bundle before the slash and a non-empty key after it.
+    if (slash <= 0 || slash >= body.length - 1)
+        return null;
+    return { bundle: body.slice(0, slash), key: body.slice(slash + 1) };
+}

package/dist/lib/browser/service.js

@@ -8,7 +8,7 @@ import { getProfile, getProfileRuntimeDir, getBrowserRuntimeDir, listProfiles, e
 import { killChrome, getRunningChromeInfo, launchBrowser, allocatePort } from './chrome.js';
 import { connectLocal } from './drivers/local.js';
 import { connectSSH, shellQuote } from './drivers/ssh.js';
-import { clearProfileRuntime } from './runtime-state.js';
+import { clearProfileRuntime, listProfileCacheDirs, readProfileRuntimeMeta, isProcessAlive } from './runtime-state.js';
 import { resolveDomainSkill } from './domain-skills.js';
 import { generateTaskId, generateShortId, generateTaskName, } from './types.js';
 import { getRefs, resolveRefToCoords, describeRefs, healRef } from './refs.js';
@@ -415,6 +415,7 @@ export class BrowserService {
                     killChrome(conn.pid);
                     conn.cleanup?.();
                     this.connections.delete(profileName);
+                    clearProfileRuntime(profileName);
                 }
                 return { ok: true, profile: profileName };
             }
@@ -442,17 +443,18 @@ export class BrowserService {
             killChrome(conn.pid);
             conn.cleanup?.();
             this.connections.delete(key);
-        }
-        const runtimeDir = getProfileRuntimeDir(profileName);
-        const pidFile = path.join(runtimeDir, 'pid');
-        const portFile = path.join(runtimeDir, 'port');
-        if (fs.existsSync(pidFile)) {
-            const pid = parseInt(fs.readFileSync(pidFile, 'utf-8').trim(), 10);
-            killChrome(pid);
-            fs.unlinkSync(pidFile);
-        }
-        if (fs.existsSync(portFile)) {
-            fs.unlinkSync(portFile);
+            clearProfileRuntime(key);
+        }
+        // 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)) {
+            const dirName = path.basename(dir);
+            const meta = readProfileRuntimeMeta(dirName);
+            if (meta?.pid && meta.pid !== 0 && isProcessAlive(meta.pid, meta.command)) {
+                killChrome(meta.pid);
+            }
+            clearProfileRuntime(dirName);
         }
     }
     async navigate(taskId, url, profileName) {

package/dist/lib/cloud/antigravity.d.ts

@@ -31,8 +31,6 @@ interface InteractionResponse {
         message?: string;
     } | string;
 }
-/** Map an Interactions API status string to the canonical CloudTaskStatus. */
-export declare function mapStatus(s: string | undefined): CloudTaskStatus;
 /** Build the Interactions API request body for a fresh dispatch. */
 export declare function buildInteractionBody(prompt: string, model: string): Record<string, unknown>;
 /** Parse an Interactions API response into a CloudTask (minus prompt/timestamps). */

package/dist/lib/cloud/antigravity.js

@@ -19,26 +19,11 @@
  * `cloud.providers.antigravity.secretsBundle` (never from agents.yaml), falling
  * back to GEMINI_API_KEY / GOOGLE_API_KEY in the environment.
  */
-import { resolveDispatchRepos } from './types.js';
+import { resolveDispatchRepos, normalizeProviderStatus } from './types.js';
 import { readAndResolveBundleEnv } from '../secrets/bundles.js';
 const INTERACTIONS_URL = 'https://generativelanguage.googleapis.com/v1beta/interactions';
 const DEFAULT_MODEL = 'antigravity-preview-05-2026';
 const KEY_NAMES = ['GEMINI_API_KEY', 'GOOGLE_API_KEY'];
-/** Map an Interactions API status string to the canonical CloudTaskStatus. */
-export function mapStatus(s) {
-    const lower = (s ?? '').toLowerCase();
-    if (lower.includes('queue') || lower.includes('pending'))
-        return 'queued';
-    if (lower.includes('run') || lower.includes('progress'))
-        return 'running';
-    if (lower.includes('complete') || lower.includes('success'))
-        return 'completed';
-    if (lower.includes('fail') || lower.includes('error'))
-        return 'failed';
-    if (lower.includes('cancel'))
-        return 'cancelled';
-    return 'completed';
-}
 /** Build the Interactions API request body for a fresh dispatch. */
 export function buildInteractionBody(prompt, model) {
     return {
@@ -52,7 +37,7 @@ export function parseInteraction(resp) {
     const id = resp.id ?? resp.interaction_id ?? `antigravity-${Date.now()}`;
     return {
         id,
-        status: mapStatus(resp.status),
+        status: normalizeProviderStatus('antigravity', resp.status),
         summary: resp.output_text,
         environmentId: resp.environment_id,
     };

package/dist/lib/cloud/codex.js

@@ -8,24 +8,9 @@
 import { spawn, execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
-import { resolveDispatchRepos, MissingTargetError } from './types.js';
+import { resolveDispatchRepos, normalizeProviderStatus, MissingTargetError } from './types.js';
 import { getShimsDir } from '../state.js';
 const SHIMS_DIR = getShimsDir();
-/** Map a Codex Cloud status string to the canonical CloudTaskStatus enum. */
-function mapStatus(s) {
-    const lower = s.toLowerCase();
-    if (lower.includes('queued') || lower.includes('pending'))
-        return 'queued';
-    if (lower.includes('running') || lower.includes('in_progress'))
-        return 'running';
-    if (lower.includes('completed') || lower.includes('succeeded') || lower.includes('success'))
-        return 'completed';
-    if (lower.includes('failed') || lower.includes('error'))
-        return 'failed';
-    if (lower.includes('cancelled') || lower.includes('canceled'))
-        return 'cancelled';
-    return 'running';
-}
 /** Locate the codex binary, checking agents-cli shims first then PATH. */
 function findCodexBinary() {
     // Check agents-cli shims first
@@ -77,7 +62,7 @@ function parseTaskFromText(text) {
         }
         return {
             id: result.id || result.task_id,
-            status: result.status ? mapStatus(result.status) : undefined,
+            status: result.status ? normalizeProviderStatus('codex', result.status) : undefined,
             summary: result.summary || result.output,
         };
     }
@@ -186,7 +171,7 @@ export class CodexCloudProvider {
             const tasks = (data.tasks ?? data ?? []).map((t) => ({
                 id: (t.id || t.task_id),
                 provider: 'codex',
-                status: mapStatus(t.status ?? ''),
+                status: normalizeProviderStatus('codex', t.status ?? ''),
                 agent: 'codex',
                 prompt: (t.prompt || t.query || ''),
                 branch: t.branch || undefined,

package/dist/lib/cloud/rush.d.ts

@@ -29,6 +29,21 @@ export interface AccountTokenEntry {
     /** Stringified OAuth credentials JSON (Mac: keychain blob; Linux: .credentials.json). */
     credentials_json: string;
 }
+/**
+ * Read the raw OAuth credentials for one Claude version. On Mac, prefer the
+ * Keychain blob (canonical). On Linux/CI, fall back to `.claude/.credentials.json`
+ * inside the version home (where the Linux Claude CLI stores its OAuth).
+ *
+ * Returns null when no credentials are findable — caller treats as "version
+ * is installed but not signed in" and skips it from the manifest.
+ *
+ * NOTE: the darwin branch returns the UNWRAPPED oauth sub-object (what the Rush
+ * server re-wraps). It is NOT the shape Claude Code reads back from
+ * `.credentials.json`. The lease exporter (crabbox/runtimes.ts) therefore only
+ * reuses the Linux `.credentials.json` branch here and reads the wrapped raw
+ * Keychain payload itself on darwin.
+ */
+export declare function readClaudeCredentialsBlob(home: string): Promise<string | null>;
 /**
  * Build a manifest of the user's local Claude installations to send on every
  * cloud dispatch. The manifest is the contract the server uses to detect when

package/dist/lib/cloud/rush.js

@@ -10,7 +10,7 @@ import * as os from 'os';
 import * as crypto from 'crypto';
 import * as yaml from 'yaml';
 import { getCloudDir } from '../state.js';
-import { resolveDispatchRepos, MAX_IMAGES_PER_DISPATCH } from './types.js';
+import { resolveDispatchRepos, normalizeProviderStatus, MAX_IMAGES_PER_DISPATCH } from './types.js';
 import { parseSSE } from './stream.js';
 import { listInstalledVersions, getVersionHomePath } from '../versions.js';
 import { getAccountInfo } from '../agents.js';
@@ -56,18 +56,6 @@ function recordRushUploadConsent(grantedBy, accountFingerprint) {
         // boundary. Worst case, the user is asked to consent again next dispatch.
     }
 }
-/** Map a Factory Floor status string to the canonical CloudTaskStatus enum. */
-function mapStatus(s) {
-    switch (s) {
-        case 'allocating': return 'allocating';
-        case 'running': return 'running';
-        case 'needs_review': return 'input_required';
-        case 'completed': return 'completed';
-        case 'failed': return 'failed';
-        case 'cancelled': return 'cancelled';
-        default: return 'running';
-    }
-}
 /** Read the Rush session access token from ~/.rush/user.yaml. */
 function readToken() {
     if (!fs.existsSync(USER_YAML)) {
@@ -170,8 +158,14 @@ function parsePromptCode(body) {
  *
  * Returns null when no credentials are findable — caller treats as "version
  * is installed but not signed in" and skips it from the manifest.
+ *
+ * NOTE: the darwin branch returns the UNWRAPPED oauth sub-object (what the Rush
+ * server re-wraps). It is NOT the shape Claude Code reads back from
+ * `.credentials.json`. The lease exporter (crabbox/runtimes.ts) therefore only
+ * reuses the Linux `.credentials.json` branch here and reads the wrapped raw
+ * Keychain payload itself on darwin.
  */
-async function readClaudeCredentialsBlob(home) {
+export async function readClaudeCredentialsBlob(home) {
     if (process.platform === 'darwin') {
         const oauth = await loadClaudeOauth(home);
         if (oauth && oauth.accessToken) {
@@ -446,7 +440,7 @@ export class RushCloudProvider {
         return {
             id: taskId,
             provider: 'rush',
-            status: mapStatus(data.status),
+            status: normalizeProviderStatus('rush', data.status),
             agent: data.agent || undefined,
             prompt: data.prompt || '',
             repo: data.repo_owner && data.repo_name ? `${data.repo_owner}/${data.repo_name}` : undefined,
@@ -471,7 +465,7 @@ export class RushCloudProvider {
         return (data.executions ?? []).map((e) => ({
             id: e.execution_id,
             provider: 'rush',
-            status: mapStatus(e.status),
+            status: normalizeProviderStatus('rush', e.status),
             agent: e.agent || undefined,
             prompt: e.prompt || '',
             repo: e.repo_owner && e.repo_name ? `${e.repo_owner}/${e.repo_name}` : undefined,

package/dist/lib/cloud/stream.js

@@ -179,6 +179,8 @@ function statusLabel(status) {
             return chalk.blue(`[${status}]`);
         case 'running':
             return chalk.yellow(`[${status}]`);
+        case 'idle':
+            return chalk.dim('[idle]');
         case 'completed':
             return chalk.green('[completed]');
         case 'needs_review':

package/dist/lib/cloud/types.d.ts

@@ -27,6 +27,27 @@ export type CloudProviderId = 'rush' | 'codex' | 'factory' | 'antigravity';
  * failed | cancelled` states, which cannot transition back to `running`.
  */
 export type CloudTaskStatus = 'queued' | 'allocating' | 'running' | 'idle' | 'input_required' | 'completed' | 'failed' | 'cancelled';
+/** Cloud backends whose wire status is normalized by `normalizeProviderStatus`. */
+export type StatusNormalizingProvider = 'rush' | 'codex' | 'antigravity';
+/**
+ * Normalize a provider's raw wire status into the canonical `CloudTaskStatus`.
+ *
+ * Each cloud backend speaks its own status vocabulary and had its own copy of
+ * this mapping, which had drifted. This dispatches per provider while keeping
+ * provider-specific defaults explicit:
+ *   - `rush`        — switch over the Factory Floor's known strings; includes
+ *                     `allocating` and stopped/resumable `idle` states, has no
+ *                     `queued`, default `running`.
+ *   - `codex`       — substring match on the lowercased CLI status; default
+ *                     `running`.
+ *   - `antigravity` — substring match on the (possibly `undefined`) Interactions
+ *                     API status; default `completed` (its synchronous response
+ *                     is terminal), and `undefined`-safe.
+ *
+ * Factory's `mapResultStatus` is structurally different (it maps a droid *exit*
+ * result, not a lifecycle string) and deliberately stays in `factory.ts`.
+ */
+export declare function normalizeProviderStatus(provider: StatusNormalizingProvider, wireStatus: string | undefined): CloudTaskStatus;
 /** Snapshot of a dispatched task, stored locally and refreshed from the provider. */
 export interface CloudTask {
     id: string;