@phnx-labs/agents-cli 1.22.45 → 1.22.46

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 1.22.46
+
+- **`agents auth` returns, against Phoenix ID instead of a sibling product's backend (RUSH-2581).** 1.22.45 removed the account layer that authenticated against Rush's `api.prix.dev`. It comes back pointed at **Phoenix ID** (`phnx-labs/phoenix-id`), agents-cli's own account service: `agents auth login` runs a device-code flow whose browser page is Phoenix-branded and Google-only, `agents auth whoami` reports the signed-in account, `agents auth logout` clears **this machine** and nothing else, and the team surface nests as `agents auth space` (`list`/`create`/`members`/`invite`/`role`/`remove`). Everything goes through one new seam, `lib/identity/` — one base URL (`PHOENIX_ID_BASE`), one session file, one HTTP funnel, one error type — replacing the shape that had the backend URL hardcoded in five files and the session token re-read by seven separate functions. agents-cli reads no other product's credentials: there is no `~/.rush/user.yaml` fallback. Source: `apps/cli/src/lib/identity/{client,index}.ts`, `apps/cli/src/commands/auth.ts`.
+
+- **`agents auth` points at the deployed Phoenix ID service (RUSH-2581).** The `PHOENIX_ID_BASE` default shipped naming `id.phnx.sh`, a domain that was never registered, so every `agents auth login` would have failed DNS with nothing behind it. It now defaults to the live service (a `workers.dev` URL until a custom hostname is attached). Override it with `PHOENIX_ID_BASE` to point at a local backend. Source: `apps/cli/src/lib/identity/client.ts`.
+
+- **The menu-bar prepack gate hard-fails on an unstapled or thin helper on any OS (RUSH-3031).** `verify-menubar-helper.sh`'s notarization check used to silently no-op when `xcrun` was absent — the exact case a Linux attestation-producer box hits — which let 1.22.44 ship a Dev-ID-signed but un-stapled, thin (single-arch) `MenubarHelper.app` that Gatekeeper rejected on every Mac. The gate now hard-fails when the stapled ticket (`Contents/CodeResources`) is missing and `xcrun` is unavailable, and hard-fails when the bundled executable is not a universal (fat) Mach-O binary, checked portably with `od` on any platform. Source: `apps/cli/scripts/verify-menubar-helper.sh`.
+- **The release-attestation producer no longer arms the real-`~/.agents` hermeticity guards it needs to get vitest's extended timeout profile (RUSH-3007).** `CI=true` used to control both the vitest hookTimeout/ignore-pool-error profile AND `tests/setup.ts`'s leak tripwires against the real developer home — so a producer run on a box with a live daemon (e.g. mac-mini) false-failed 129/129 test files on a fully green, 12,559/12,559-test suite. `release-attestation-produce.sh` now sets `AGENTS_ATTEST_PRODUCER=1` (and unsets any ambient `CI`) to opt into the timeout profile without arming the guards; a genuine CI runner's behavior is unchanged. Source: `apps/cli/scripts/release-attestation-produce.sh`, `apps/cli/tests/hermetic-guards.ts`, `apps/cli/tests/setup.ts`, `apps/cli/vitest.config.ts`.
+
+- **Rotation remembers a tokens/credits-exhausted account instead of re-picking it every launch (RUSH-3018).**
+  A rate limit resets on a clock; running *out of credits / hitting a spend cap*
+  does not — yet the two were conflated. A billing refusal (`out of usage credits`,
+  `monthly spend limit`) was detected only to trigger one failover and then
+  forgotten, so balanced rotation re-picked the dead account on the next launch,
+  it refused again, failed over again — burning a launch each time. It now
+  persists a clock-less `out_of_credits` marker per account
+  (`noteClaudeOutOfCredits`), which the rotation eligibility gate treats as
+  blocking until a later **successful** run on that account clears it
+  (`clearClaudeAccountRefusal`) — never a timestamp. Session/rate limits are
+  unchanged (still recover on their reset). Source:
+  `apps/cli/src/lib/accounting/usage.ts`, `apps/cli/src/lib/exec.ts`.
+
+- **Harness capability probes can no longer leak grandchild processes (RUSH-3028).** The version probe behind `agents view` (`<cli> --version`) and the async manifest `check:` runner executed third-party binaries whose own forked children could outlive the probe — the GitHub Copilot npm wrapper forks a platform-binary downloader into `~/Library/Caches/copilot`, and under a redirected test HOME that survivor raced teardown `rm` (the dominant residual ENOTEMPTY suite flake after RUSH-3021). Probes now run in their own process group via `probeCapture`, and the whole group is reaped when the probe settles — on clean exit, on timeout, and on parent death (a `process.on('exit')` hook covers the CLI's hard-exit SIGINT path). On win32, where process groups don't apply, the direct child is killed on settle, matching the old `execFile` timeout behavior. Source: `apps/cli/src/lib/probe.ts`, `apps/cli/src/lib/agent-spec/agents.ts`, `apps/cli/src/lib/cli-resources.ts`.
+
 ## 1.22.45
 
 - **BREAKING: the Prix-coupled account layer is removed — `agents auth`, `agents org`, and the plan-tier gates (RUSH-2581).** 1.22.42 shipped `agents auth login/whoami/logout` and `agents org` against the Rush product's backend (`api.prix.dev`), with `entitlement.ts` reading the Rush billing tier to cap accounts at 3-per-harness on free and to gate the `agents insights` friction sections. agents-cli's identity must not ride a separate product's login and database, so all of it is removed: `auth` and `org` are retired top-level names (they fail loudly, no auto-correct), account registration is uncapped again, `agents accounts` output drops the `dormant` field/suffix, and `agents insights` renders the full report with no `plan`/`notice` JSON fields. The Rush *feature* integrations are untouched (`cloud/rush.ts` dispatch, the opt-in secrets sync driver, the owner-notify transport). The replacement — agents-cli's own account backend with Phoenix branding, built for later Phoenix-ID consolidation — is tracked in RUSH-2581. Source: `apps/cli/src/lib/{prix-account,entitlement}.ts` (deleted), `apps/cli/src/commands/{auth,org}.ts` (deleted), `apps/cli/src/commands/{accounts,insights}.ts`, `apps/cli/src/{bootstrap.ts,cli/command-registry.ts,lib/startup/command-registry.ts}`.

package/README.md

@@ -81,6 +81,7 @@ Also available as `ag` -- all commands work with both `agents` and `ag`.
 - [Plugins](#plugins)
 - [Make it yours](#make-it-yours)
 - [Browser](#browser)
+- [Sign in](#sign-in)
 - [Accounts](#accounts)
 - [Secrets](#secrets)
 - [Routines](#routines)
@@ -1002,6 +1003,29 @@ agents browser profiles create cloud \
 
 ---
 
+## Sign in
+
+`agents auth` signs this machine in to **Phoenix ID** — the Phoenix Labs account layer that spaces and plan tiers hang off. Sign-in is Google-only and runs a device-code flow: the CLI shows a code, your browser confirms it, and the CLI picks the session up.
+
+```bash
+agents auth login                        # shows a code, opens a Phoenix-branded page
+agents auth whoami                       # who this machine is signed in as (--json)
+agents auth logout                       # clears THIS machine; no other device is touched
+
+agents auth space create "Design Team"   # spaces are the team primitive
+agents auth space list                   # spaces you belong to
+agents auth space invite ada@example.com --role member
+agents auth space members                # who is in it
+agents auth space role ada@example.com admin
+agents auth space remove ada@example.com # or remove yourself to leave
+```
+
+The session lives in this machine's agents state dir, so `logout` here signs out nothing else. `whoami` and every `space` subcommand take `--json`. `PHOENIX_ID_BASE` points the CLI at a different account service (a local one, for instance); it defaults to the deployed Phoenix ID service.
+
+Distinct from **Accounts** below: this is *your human identity*; those are the *harness credentials* an agent runs under.
+
+---
+
 ## Accounts
 
 Give a provider credential a durable name once, reuse it everywhere -- across harnesses, across machines.

package/dist/cli/command-registry.d.ts

@@ -90,6 +90,7 @@ export declare const loadWebhooks: ModuleLoader;
 export declare const loadHumans: ModuleLoader;
 export declare const loadAccounts: ModuleLoader;
 export declare const loadDaemon: ModuleLoader;
+export declare const loadAuth: ModuleLoader;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are
  * registered AFTER `applyGlobalHelpConventions` (mirroring main's order: help

package/dist/cli/command-registry.js

@@ -93,6 +93,7 @@ export const loadWebhooks = async () => (await import('../commands/webhook.js'))
 export const loadHumans = async () => (await import('../commands/humans.js')).registerHumansCommands;
 export const loadAccounts = async () => (await import('../commands/accounts.js')).registerAccountsCommand;
 export const loadDaemon = async () => (await import('../commands/daemon.js')).registerDaemonCommand;
+export const loadAuth = async () => (await import('../commands/auth.js')).registerAuthCommand;
 /**
  * Commands whose modules pull in the SQLite-backed session/cloud stack. They are
  * registered AFTER `applyGlobalHelpConventions` (mirroring main's order: help
@@ -207,6 +208,7 @@ export const COMMAND_LOADERS = {
     webhooks: [loadWebhooks],
     humans: [loadHumans],
     daemon: [loadDaemon],
+    auth: [loadAuth],
 };
 /**
  * Register every module in {@link COMMAND_LOADERS} onto one fresh program and

package/dist/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerAuthCommand(program: Command): void;

package/dist/commands/auth.js

@@ -0,0 +1,227 @@
+import chalk from 'chalk';
+import { PhoenixApiError, clearSession, createSpace, createSpaceInvite, fetchWhoAmI, listSpaceMembers, listSpaces, pollDeviceToken, readSession, removeSpaceMember, resolveMemberFromList, resolveSpaceFromList, slugify, startDeviceAuthorization, updateSpaceMemberRole, writeSession, } from '../lib/identity/index.js';
+import { setHelpSections } from '../lib/help.js';
+import { runOrDie } from '../lib/format.js';
+/**
+ * `agents auth` — sign in to Phoenix ID, the account layer behind teams and
+ * plan tiers. Everything here goes through `lib/identity`; this file builds no
+ * URLs and reads no credential files of its own.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function login() {
+    const grant = await startDeviceAuthorization();
+    console.log('');
+    console.log(`  Your code:  ${chalk.bold.cyan(grant.user_code)}`);
+    console.log(`  Open:       ${chalk.underline(grant.verification_uri_complete)}`);
+    console.log('');
+    console.log(chalk.gray('  Waiting for you to approve it in the browser…'));
+    // The server sets the pace; `slow_down` widens it (RFC 8628 §3.5).
+    let interval = Math.max(1, grant.interval) * 1000;
+    const deadline = Date.now() + grant.expires_in * 1000;
+    while (Date.now() < deadline) {
+        await sleep(interval);
+        const poll = await pollDeviceToken(grant.device_code);
+        if (poll.status === 'authorized') {
+            writeSession({ access_token: poll.access_token, email: poll.user.email, userId: poll.user.id });
+            console.log(chalk.green(`\n  Signed in as ${poll.user.email}.`));
+            return;
+        }
+        if (poll.status === 'slow_down') {
+            interval += 5000;
+            continue;
+        }
+        if (poll.status === 'denied')
+            throw new Error('Sign-in was denied in the browser.');
+        if (poll.status === 'expired')
+            throw new Error("That code expired. Run 'agents auth login' again.");
+    }
+    throw new Error("Timed out waiting for approval. Run 'agents auth login' again.");
+}
+async function whoami(json) {
+    const session = readSession();
+    if (!session) {
+        if (json) {
+            console.log(JSON.stringify({ signedIn: false }, null, 2));
+            return;
+        }
+        console.log(chalk.gray("Not signed in. Run 'agents auth login'."));
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const me = await fetchWhoAmI();
+        if (json) {
+            console.log(JSON.stringify({ signedIn: true, ...me }, null, 2));
+            return;
+        }
+        console.log(`${chalk.bold(me.email)}  ${chalk.gray(me.userId)}`);
+    }
+    catch (err) {
+        if (err instanceof PhoenixApiError && err.status === 401) {
+            throw new Error("Your session is no longer valid. Run 'agents auth login' again.");
+        }
+        throw err;
+    }
+}
+function printSpaces(spaces) {
+    if (!spaces.length) {
+        console.log(chalk.gray("  No spaces yet. Create one with 'agents auth space create <name>'."));
+        return;
+    }
+    for (const space of spaces) {
+        console.log(`  ${chalk.cyan(space.slug)}  ${space.name}  ${chalk.gray(space.user_role)}`);
+    }
+}
+/** Resolve a space reference (or the caller's only space) to a concrete space. */
+async function requireSpace(ref) {
+    const spaces = await listSpaces();
+    const space = resolveSpaceFromList(spaces, ref);
+    if (space)
+        return space;
+    if (!ref) {
+        throw new Error(spaces.length
+            ? `You are in ${spaces.length} spaces — name one: ${spaces.map((s) => s.slug).join(', ')}.`
+            : "You are not in a space yet. Create one with 'agents auth space create <name>'.");
+    }
+    throw new Error(`No space named '${ref}'.`);
+}
+export function registerAuthCommand(program) {
+    const auth = program
+        .command('auth')
+        .description('Sign in to Phoenix ID — the account layer behind spaces and plan tiers');
+    setHelpSections(auth, {
+        examples: `agents auth login                         # device-code sign-in via your browser
+agents auth whoami                        # who this machine is signed in as
+agents auth space create "Design Team"    # start a space
+agents auth space invite ada@example.com  # add a teammate
+agents auth logout                        # clear this machine only`,
+        notes: `Sign-in is Google-only and opens a Phoenix-branded page; the CLI never sees a password.
+The session lives in this machine's agents state dir, so logging out here signs out nothing else.
+Point at a different backend with PHOENIX_ID_BASE (defaults to the production service).`,
+    });
+    auth
+        .command('login')
+        .description('Sign in with the device-code flow')
+        .action(() => runOrDie(() => login()));
+    auth
+        .command('whoami')
+        .description('Show the signed-in account')
+        .option('--json', 'Machine-readable output')
+        .action((o, command) => {
+        const json = !!o.json || !!command.optsWithGlobals().json;
+        return runOrDie(() => whoami(json), { json });
+    });
+    auth
+        .command('logout')
+        .description("Clear this machine's session (no other device is affected)")
+        .action(() => runOrDie(() => {
+        const session = readSession();
+        clearSession();
+        console.log(session ? chalk.green(`Signed out ${session.email ?? 'this machine'}.`) : chalk.gray('Already signed out.'));
+    }));
+    const space = auth.command('space').description('Spaces — share work with teammates');
+    space
+        .command('list', { isDefault: true })
+        .description('Spaces you belong to')
+        .option('--json', 'Machine-readable output')
+        .action((o, command) => {
+        const json = !!o.json || !!command.optsWithGlobals().json;
+        return runOrDie(async () => {
+            const spaces = await listSpaces();
+            if (json)
+                return console.log(JSON.stringify(spaces, null, 2));
+            printSpaces(spaces);
+        }, { json });
+    });
+    space
+        .command('create <name>')
+        .description('Create a space')
+        .option('--slug <slug>', 'URL-safe name (defaults to a slug of <name>)')
+        .option('--json', 'Machine-readable output')
+        .action((name, o, command) => {
+        const json = !!o.json || !!command.optsWithGlobals().json;
+        return runOrDie(async () => {
+            const created = await createSpace({ name, slug: o.slug ?? slugify(name) });
+            if (json)
+                return console.log(JSON.stringify(created, null, 2));
+            console.log(chalk.green(`Created ${created.name} (${created.slug}).`));
+        }, { json });
+    });
+    space
+        .command('members [space]')
+        .description('Who is in a space')
+        .option('--json', 'Machine-readable output')
+        .action((ref, o, command) => {
+        const json = !!o.json || !!command.optsWithGlobals().json;
+        return runOrDie(async () => {
+            const target = await requireSpace(ref);
+            const members = await listSpaceMembers(target.id);
+            if (json)
+                return console.log(JSON.stringify(members, null, 2));
+            for (const m of members)
+                console.log(`  ${m.email}  ${chalk.gray(m.role)}`);
+        }, { json });
+    });
+    space
+        .command('invite <email>')
+        .description('Invite someone to a space')
+        .option('--space <space>', 'Which space (defaults to your only one)')
+        .option('--role <role>', 'admin or member', 'member')
+        .option('--json', 'Machine-readable output')
+        .action((email, o, command) => {
+        const json = !!o.json || !!command.optsWithGlobals().json;
+        return runOrDie(async () => {
+            if (o.role !== 'admin' && o.role !== 'member') {
+                throw new Error(`--role must be admin or member (got '${o.role}').`);
+            }
+            const target = await requireSpace(o.space);
+            const result = await createSpaceInvite(target.id, { email, role: o.role });
+            if (json)
+                return console.log(JSON.stringify(result, null, 2));
+            console.log(result.member_added
+                ? chalk.green(`Added ${email} to ${target.name} as ${o.role}.`)
+                : chalk.green(`Invited ${email} to ${target.name} as ${o.role}. Invite code: ${result.invite_code}`));
+        }, { json });
+    });
+    space
+        .command('role <email> <role>')
+        .description('Change a member\'s role (owner only for admin)')
+        .option('--space <space>', 'Which space (defaults to your only one)')
+        .option('--json', 'Machine-readable output')
+        .action((email, role, o, command) => {
+        const json = !!o.json || !!command.optsWithGlobals().json;
+        return runOrDie(async () => {
+            if (role !== 'admin' && role !== 'member') {
+                throw new Error(`role must be admin or member (got '${role}').`);
+            }
+            const target = await requireSpace(o.space);
+            const member = resolveMemberFromList(await listSpaceMembers(target.id), email);
+            if (!member)
+                throw new Error(`${email} is not in ${target.name}.`);
+            const updated = await updateSpaceMemberRole(target.id, member.user_id, role);
+            if (json)
+                return console.log(JSON.stringify(updated, null, 2));
+            console.log(chalk.green(`${email} is now ${role} in ${target.name}.`));
+        }, { json });
+    });
+    space
+        .command('remove <email>')
+        .description('Remove a member (or yourself) from a space')
+        .option('--space <space>', 'Which space (defaults to your only one)')
+        .option('--json', 'Machine-readable output')
+        .action((email, o, command) => {
+        const json = !!o.json || !!command.optsWithGlobals().json;
+        return runOrDie(async () => {
+            const target = await requireSpace(o.space);
+            const member = resolveMemberFromList(await listSpaceMembers(target.id), email);
+            if (!member)
+                throw new Error(`${email} is not in ${target.name}.`);
+            await removeSpaceMember(target.id, member.user_id);
+            if (json)
+                return console.log(JSON.stringify({ removed: true, email, space: target.slug }, null, 2));
+            console.log(chalk.green(`Removed ${email} from ${target.name}.`));
+        }, { json });
+    });
+}

package/dist/commands/view.js

@@ -1314,7 +1314,7 @@ export async function collectAgentsJson(filterAgentId, resourceSections) {
             unavailable: snapshot?.unavailable
                 ? {
                     reason: snapshot.unavailable.reason,
-                    resetsAt: snapshot.unavailable.resetsAt.toISOString(),
+                    resetsAt: snapshot.unavailable.resetsAt?.toISOString(),
                 }
                 : undefined,
             lastActive: info.lastActive ? info.lastActive.toISOString() : null,

package/dist/lib/accounting/usage.d.ts

@@ -91,10 +91,16 @@ export interface UsageSnapshot {
     capturedAt: Date | null;
     windows: UsageWindow[];
     plan?: string | null;
-    /** A refusal observed from a real harness run, independent of API windows. */
+    /**
+     * A refusal observed from a real harness run, independent of API windows.
+     * `session_limit` recovers on a clock (`resetsAt`). `out_of_credits` is a
+     * tokens/balance exhaustion that does NOT reset on a clock — it has no
+     * `resetsAt` and is cleared only by a later successful run on the account
+     * (clearClaudeAccountRefusal). Both exclude the account from rotation while set.
+     */
     unavailable?: {
-        reason: 'session_limit';
-        resetsAt: Date;
+        reason: 'session_limit' | 'out_of_credits';
+        resetsAt?: Date;
     };
 }
 /** Usage data plus any error encountered while fetching. */
@@ -515,6 +521,19 @@ export declare function readClaudeUsageCache(usageKey: string, cachePath?: strin
 export declare function pruneExpiredClaudeUsageCacheEntry(usageKey: string, cachePath?: string, now?: Date): void;
 /** Write a usage snapshot to the on-disk cache. */
 export declare function writeClaudeUsageCache(usageKey: string, snapshot: UsageSnapshot, cachePath?: string): void;
+/**
+ * Persist a Claude tokens/credits exhaustion (`out of usage credits` / `monthly
+ * spend limit`) from a real run. Unlike a rate/session limit this does NOT reset
+ * on a clock, so no reset time is stored — rotation excludes the account until a
+ * later successful run clears it via {@link clearClaudeAccountRefusal}.
+ */
+export declare function noteClaudeOutOfCredits(usageKey: string, cachePath?: string): void;
+/**
+ * Clear any persisted refusal marker for an account after a run SUCCEEDS on it.
+ * This is the recovery path for `out_of_credits` (which has no clock) and also
+ * proactively clears a stale `session_limit` the moment the account serves again.
+ */
+export declare function clearClaudeAccountRefusal(usageKey: string, cachePath?: string): void;
 /**
  * Persist a Claude session-limit refusal from a real run until its stated reset.
  * This quota is not part of Anthropic's five-hour/weekly usage response.

package/dist/lib/accounting/usage.js

@@ -398,7 +398,10 @@ export function formatUsageSummary(plan, snapshot, planWidth = 3, opts) {
         parts.push(chalk.gray(plan.padEnd(planWidth)));
     }
     if (snapshot) {
-        if (snapshot.unavailable?.reason === 'session_limit') {
+        if (snapshot.unavailable?.reason === 'out_of_credits') {
+            parts.push(chalk.red('out of credits'));
+        }
+        else if (snapshot.unavailable?.reason === 'session_limit' && snapshot.unavailable.resetsAt) {
             parts.push(chalk.yellow(`session-limited (${formatResetHint(snapshot.unavailable.resetsAt)})`));
         }
         // Compact rows show BLOCKING windows — the same set
@@ -472,8 +475,14 @@ export function formatUsageSummary(plan, snapshot, planWidth = 3, opts) {
 export function deriveUsageStatusFromSnapshot(snapshot) {
     if (!snapshot)
         return null;
-    if (snapshot.unavailable && snapshot.unavailable.resetsAt.getTime() > Date.now()) {
-        return 'rate_limited';
+    if (snapshot.unavailable) {
+        // out_of_credits has no clock — it stays blocking until a successful run
+        // clears it. session_limit blocks only until its reset time.
+        if (snapshot.unavailable.reason === 'out_of_credits')
+            return 'rate_limited';
+        if (snapshot.unavailable.resetsAt && snapshot.unavailable.resetsAt.getTime() > Date.now()) {
+            return 'rate_limited';
+        }
     }
     if (snapshot.windows.length === 0)
         return null;
@@ -1487,12 +1496,9 @@ export function writeClaudeUsageCache(usageKey, snapshot, cachePath = getClaudeU
             // refresh cannot drop another account's row (lost update).
             const cache = readClaudeUsageCacheFile(cachePath);
             const prior = cache[usageKey];
-            const priorReset = parseDateValue(prior?.unavailable?.resetsAt);
             cache[usageKey] = serializeClaudeUsageSnapshot({
                 ...snapshot,
-                unavailable: priorReset && priorReset.getTime() > Date.now()
-                    ? { reason: 'session_limit', resetsAt: priorReset }
-                    : snapshot.unavailable,
+                unavailable: carryForwardUnavailable(prior?.unavailable, snapshot.unavailable),
             });
             atomicWriteFileSync(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
         });
@@ -1530,7 +1536,10 @@ function serializeClaudeUsageSnapshot(snapshot) {
         capturedAt: snapshot.capturedAt?.toISOString() || null,
         plan: snapshot.plan ?? null,
         unavailable: snapshot.unavailable
-            ? { reason: snapshot.unavailable.reason, resetsAt: snapshot.unavailable.resetsAt.toISOString() }
+            ? {
+                reason: snapshot.unavailable.reason,
+                resetsAt: snapshot.unavailable.resetsAt?.toISOString(),
+            }
             : undefined,
         windows: snapshot.windows.map((window) => ({
             key: window.key,
@@ -1565,10 +1574,7 @@ function deserializeClaudeUsageSnapshot(snapshot, now) {
         windowMinutes: window.windowMinutes,
     }))
         .filter((window) => isCachedUsageWindowFresh(window, capturedAt, now));
-    const unavailableReset = parseDateValue(snapshot.unavailable?.resetsAt);
-    const unavailable = unavailableReset && unavailableReset.getTime() > now.getTime()
-        ? { reason: 'session_limit', resetsAt: unavailableReset }
-        : undefined;
+    const unavailable = deserializeUnavailable(snapshot.unavailable, now);
     if (windows.length === 0 && !unavailable) {
         return null;
     }
@@ -1581,6 +1587,82 @@ function deserializeClaudeUsageSnapshot(snapshot, now) {
         unavailable,
     };
 }
+/**
+ * Carry a prior refusal marker forward across a daemon usage refresh, and drop
+ * an expired one. A live `snapshot.unavailable` (a refusal just observed) wins.
+ * `out_of_credits` survives refreshes with no reset — only a successful run
+ * clears it (clearClaudeAccountRefusal). A `session_limit` survives only while
+ * its reset time is still in the future.
+ */
+function carryForwardUnavailable(prior, live) {
+    if (live)
+        return live;
+    if (!prior)
+        return undefined;
+    if (prior.reason === 'out_of_credits')
+        return { reason: 'out_of_credits' };
+    const reset = parseDateValue(prior.resetsAt);
+    return reset && reset.getTime() > Date.now()
+        ? { reason: 'session_limit', resetsAt: reset }
+        : undefined;
+}
+/**
+ * Deserialize a cached `unavailable` marker, dropping an expired session_limit
+ * but keeping a clock-less out_of_credits.
+ */
+function deserializeUnavailable(cached, now) {
+    if (!cached)
+        return undefined;
+    if (cached.reason === 'out_of_credits')
+        return { reason: 'out_of_credits' };
+    const reset = parseDateValue(cached.resetsAt);
+    return reset && reset.getTime() > now.getTime()
+        ? { reason: 'session_limit', resetsAt: reset }
+        : undefined;
+}
+/**
+ * Persist a Claude tokens/credits exhaustion (`out of usage credits` / `monthly
+ * spend limit`) from a real run. Unlike a rate/session limit this does NOT reset
+ * on a clock, so no reset time is stored — rotation excludes the account until a
+ * later successful run clears it via {@link clearClaudeAccountRefusal}.
+ */
+export function noteClaudeOutOfCredits(usageKey, cachePath = getClaudeUsageCachePath()) {
+    try {
+        ensureLockTarget(cachePath, '{}');
+        withFileLock(cachePath, () => {
+            const cache = readClaudeUsageCacheFile(cachePath);
+            const existing = cache[usageKey] ?? { capturedAt: null, windows: [] };
+            cache[usageKey] = { ...existing, unavailable: { reason: 'out_of_credits' } };
+            atomicWriteFileSync(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+        });
+    }
+    catch {
+        /* best-effort cache write — lock busy or disk full */
+    }
+}
+/**
+ * Clear any persisted refusal marker for an account after a run SUCCEEDS on it.
+ * This is the recovery path for `out_of_credits` (which has no clock) and also
+ * proactively clears a stale `session_limit` the moment the account serves again.
+ */
+export function clearClaudeAccountRefusal(usageKey, cachePath = getClaudeUsageCachePath()) {
+    try {
+        if (!fs.existsSync(cachePath))
+            return;
+        withFileLock(cachePath, () => {
+            const cache = readClaudeUsageCacheFile(cachePath);
+            const existing = cache[usageKey];
+            if (!existing?.unavailable)
+                return;
+            const { unavailable: _drop, ...rest } = existing;
+            cache[usageKey] = rest;
+            atomicWriteFileSync(cachePath, JSON.stringify(cache, null, 2), 'utf-8');
+        });
+    }
+    catch {
+        /* best-effort cache write */
+    }
+}
 /**
  * Persist a Claude session-limit refusal from a real run until its stated reset.
  * This quota is not part of Anthropic's five-hour/weekly usage response.

package/dist/lib/agent-spec/agents.js

@@ -21,6 +21,7 @@ import chalk from 'chalk';
 import { execFileShellSpec } from '../platform/index.js';
 import { latestFileMtimeMs } from '../fs-walk.js';
 import { damerauLevenshtein } from '../fuzzy.js';
+import { probeCapture } from '../probe.js';
 import { getCacheDir, getVersionsDir, getShimsDir, getHistoryDir, getCliVersionCachePath } from '../state.js';
 import { resolveVersion, getVersionHomePath, getBinaryPath } from '../installations/versions.js';
 import { supports } from '../capabilities.js';
@@ -1194,7 +1195,11 @@ async function getCachedVersionForBinary(agentId, binaryPath) {
     const agent = AGENTS[agentId];
     let version = null;
     try {
-        const { stdout } = await execFileAsync(agent.cliCommand, ['--version'], { timeout: 3000 });
+        // probeCapture, not bare execFileAsync: a probed harness can fork its own
+        // children (copilot's platform-binary downloader), and a timeout kill of
+        // the direct child would orphan them mid-write (RUSH-3028). The probe runs
+        // in its own process group and the whole group is reaped on settle.
+        const { stdout } = await probeCapture(agent.cliCommand, ['--version'], 3000);
         const versionRe = agent.versionStdoutMatch === 'openclaw'
             ? /openclaw\/(\d+\.\d+\.\d+)/
             : /(\d+\.\d+\.\d+)/;

package/dist/lib/cli-resources.js

@@ -21,6 +21,7 @@ import * as path from 'path';
 import { spawnSync, execFile } from 'child_process';
 import * as yaml from 'yaml';
 import { listResources, resolveResource } from './resources.js';
+import { probeCapture } from './probe.js';
 import { composeWin32CommandLine } from './platform/index.js';
 import { localBinDir } from './platform/posixpath.js';
 // ─── Validation primitives ───────────────────────────────────────────────────
@@ -318,22 +319,23 @@ export function isCliInstalledAsync(manifest) {
         cmdExistsCache.delete(c.cmd);
         return Promise.resolve(hasCommand(c.cmd));
     }
-    return new Promise((resolve) => {
-        execFile(c.cmd, c.args, { timeout: 10_000 }, (err) => {
-            if (!err)
-                return resolve(true);
-            // A spawn failure (as opposed to a non-zero exit) surfaces as a string
-            // errno code (ENOENT/EINVAL); a non-zero exit surfaces as a numeric code.
-            // On Windows a `.cmd`/`.bat` shim spawn-fails without a shell — retry once
-            // through the shell, exactly as the sync path does.
-            const spawnFailed = typeof err.code === 'string';
-            if (process.platform === 'win32' && spawnFailed) {
-                const line = composeWin32CommandLine(c.cmd, c.args);
+    // probeCapture, not bare execFile: a checked CLI can fork children of its
+    // own (copilot's platform-binary downloader), and settling without reaping
+    // the probe's process group would orphan them mid-write (RUSH-3028).
+    return probeCapture(c.cmd, c.args, 10_000).then(() => true, (err) => {
+        // A spawn failure (as opposed to a non-zero exit) surfaces as a string
+        // errno code (ENOENT/EINVAL) on the rejection; a non-zero exit or
+        // timeout carries no errno. On Windows a `.cmd`/`.bat` shim spawn-fails
+        // without a shell — retry once through the shell, exactly as the sync
+        // path does.
+        const spawnFailed = typeof err.code === 'string';
+        if (process.platform === 'win32' && spawnFailed) {
+            const line = composeWin32CommandLine(c.cmd, c.args);
+            return new Promise((resolve) => {
                 execFile(line, { timeout: 10_000, shell: true }, (retryErr) => resolve(!retryErr));
-                return;
-            }
-            resolve(false);
-        });
+            });
+        }
+        return false;
     });
 }
 // ─── Method selection ────────────────────────────────────────────────────────

package/dist/lib/devices/harness-inventory.js

@@ -27,15 +27,32 @@ import { listNativeAccounts } from '../account-registry.js';
  */
 export function summarizeQuota(snapshot, unavailableReason = null, accountStatus = null) {
     if (!snapshot || snapshot.windows.length === 0) {
-        const status = accountStatus;
+        // An active refusal marker (persisted out_of_credits, or an unexpired
+        // session_limit) blocks even when there are no live utilization windows —
+        // which is the normal state hours/days after a run, once cached windows
+        // expire. Check it BEFORE trusting the coarse account status, which is
+        // hardcoded 'available' for a signed-in Claude; otherwise a tokens-exhausted
+        // account reads ready:true here (RUSH-3018 finding, `agents devices harnesses`).
+        const marker = snapshot?.unavailable;
+        let status = accountStatus;
+        let reason = unavailableReason;
+        if (marker?.reason === 'out_of_credits') {
+            status = 'out_of_credits';
+            reason = 'out of credits';
+        }
+        else if (marker?.reason === 'session_limit' &&
+            (!marker.resetsAt || marker.resetsAt.getTime() > Date.now())) {
+            status = 'rate_limited';
+            reason = 'session-limited';
+        }
         return {
             status,
             verdict: status ?? 'unavailable',
             usedPercent: null,
             stale: false,
             capturedAt: snapshot?.capturedAt?.toISOString() ?? null,
-            resetsAt: null,
-            unavailableReason: status ? null : (unavailableReason ?? 'usage unavailable'),
+            resetsAt: marker?.resetsAt?.toISOString() ?? null,
+            unavailableReason: status ? null : (reason ?? 'usage unavailable'),
         };
     }
     const blocking = snapshot.windows.filter((w) => w.key !== 'sonnet_week');

package/dist/lib/exec.d.ts

@@ -482,6 +482,26 @@ export declare const UNKNOWN_OUTCOME_EXIT_CODE = 1;
 export declare const RATE_LIMIT_PATTERNS: RegExp[];
 /** Return true if the text contains any known rate-limit or overload indicator. */
 export declare function detectRateLimit(text: string): boolean;
+export declare function detectOutOfCredits(text: string): boolean;
+/**
+ * Classify what a Claude run's output + exit code means for the account's
+ * persisted refusal marker. Pure and exported so the persist/clear decision is
+ * unit-tested on the real path (runWithFallback can't be driven with a real
+ * `claude` spawn in tests). Precedence: a session-limit reset wins (it carries a
+ * clock), then a clock-less billing exhaustion, then a clean success clears any
+ * stale marker; anything else leaves the marker untouched.
+ */
+export type ClaudeRefusalAction = {
+    action: 'note_session';
+    resetsAt: Date;
+} | {
+    action: 'note_out_of_credits';
+} | {
+    action: 'clear';
+} | {
+    action: 'none';
+};
+export declare function classifyClaudeRunRefusal(output: string, exitCode: number): ClaudeRefusalAction;
 /**
  * Patterns that indicate an authentication failure — the agent is logged out,
  * its token was revoked, or the session expired. These are the user-visible

package/dist/lib/exec.js

@@ -38,7 +38,7 @@ import { applyActiveRulesPresetAtRun } from './rules/run-sync.js';
 import { resolveHarnessAdapter, stripForeignConfigDir } from './harness/index.js';
 import { resolveConfigVersion } from './harness/exec-config-version.js';
 import { getAccountInfo } from './agents.js';
-import { getUsageLookupKey, noteClaudeSessionLimit, parseClaudeSessionLimitReset } from './accounting/usage.js';
+import { getUsageLookupKey, noteClaudeSessionLimit, noteClaudeOutOfCredits, clearClaudeAccountRefusal, parseClaudeSessionLimitReset } from './accounting/usage.js';
 /**
  * Map a raw mode string (CLI flag, YAML field, env var) to the canonical Mode.
  *
@@ -1865,6 +1865,29 @@ export const RATE_LIMIT_PATTERNS = [
 export function detectRateLimit(text) {
     return RATE_LIMIT_PATTERNS.some(pattern => pattern.test(text));
 }
+/**
+ * Narrow detector for a BILLING exhaustion — tokens/credits run out or the
+ * monthly spend cap is hit — as opposed to a time-window rate limit. This class
+ * does NOT recover on a clock, so rotation must remember it per-account
+ * (noteClaudeOutOfCredits) until a later successful run clears it.
+ */
+const OUT_OF_CREDITS_PATTERNS = [
+    /out of (?:usage )?credits/i,
+    /spend[\s-]?limit/i,
+];
+export function detectOutOfCredits(text) {
+    return OUT_OF_CREDITS_PATTERNS.some(pattern => pattern.test(text));
+}
+export function classifyClaudeRunRefusal(output, exitCode) {
+    const sessionLimitReset = parseClaudeSessionLimitReset(output);
+    if (sessionLimitReset)
+        return { action: 'note_session', resetsAt: sessionLimitReset };
+    if (detectOutOfCredits(output))
+        return { action: 'note_out_of_credits' };
+    if (exitCode === 0)
+        return { action: 'clear' };
+    return { action: 'none' };
+}
 /**
  * Patterns that indicate an authentication failure — the agent is logged out,
  * its token was revoked, or the session expired. These are the user-visible
@@ -2086,12 +2109,26 @@ export async function runWithFallback(options) {
             throw err;
         }
         const output = `${result.stderr}\n${result.stdout}`;
+        // Persist a per-account refusal marker so rotation stops re-picking a
+        // known-dead account: a session-limit recovers on its clock, a billing
+        // exhaustion (tokens/credits) recovers only on a later successful run, and a
+        // clean run clears any stale marker. Decision extracted + unit-tested in
+        // classifyClaudeRunRefusal.
         const sessionLimitReset = agent === 'claude' ? parseClaudeSessionLimitReset(output) : null;
-        if (sessionLimitReset && version) {
-            const account = await getAccountInfo(agent, getVersionHomePath(agent, version));
-            const usageKey = getUsageLookupKey(account);
-            if (usageKey)
-                noteClaudeSessionLimit(usageKey, sessionLimitReset);
+        if (agent === 'claude' && version) {
+            const refusal = classifyClaudeRunRefusal(output, result.exitCode ?? 1);
+            if (refusal.action !== 'none') {
+                const account = await getAccountInfo(agent, getVersionHomePath(agent, version));
+                const usageKey = getUsageLookupKey(account);
+                if (usageKey) {
+                    if (refusal.action === 'note_session')
+                        noteClaudeSessionLimit(usageKey, refusal.resetsAt);
+                    else if (refusal.action === 'note_out_of_credits')
+                        noteClaudeOutOfCredits(usageKey);
+                    else if (refusal.action === 'clear')
+                        clearClaudeAccountRefusal(usageKey);
+                }
+            }
         }
         if (result.exitCode === 0 && !sessionLimitReset)
             return 0;

package/dist/lib/identity/client.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The ONE place agents-cli talks to its account backend (Phoenix ID).
+ *
+ * Why a seam at all: the removed Prix-coupled layer (RUSH-2581) had no single
+ * entry point — the backend URL was hardcoded in five files and the session
+ * token was re-read from `~/.rush/user.yaml` by seven separate functions, so
+ * re-pointing identity meant editing a dozen call sites and rewriting error
+ * strings scattered through the tree. This module is the correction: one base
+ * URL, one token reader, one HTTP funnel, one error type. Commands import from
+ * here and nothing else.
+ *
+ * The shape mirrors the seams this repo already proved elsewhere —
+ * `SyncBackend` (`lib/secrets/sync-backend.ts`) and `CloudProvider`
+ * (`lib/cloud/types.ts`) — so a second identity backend, if one is ever
+ * needed, is a swap here rather than a sweep across commands.
+ */
+/**
+ * Where the account backend lives. Config, never a literal at a call site.
+ *
+ * The default is the deployed Phoenix ID Worker. It is a `workers.dev` URL
+ * rather than a vanity hostname because no custom domain is attached yet — and
+ * a default naming an unregistered domain is worse than an ugly one: every
+ * `agents auth login` would fail DNS with nothing to point at.
+ */
+export declare const PHOENIX_ID_BASE: string;
+/** Our own session file. agents-cli never reads another product's credentials. */
+export declare function sessionFilePath(): string;
+export interface PhoenixSession {
+    access_token: string;
+    email?: string;
+    userId?: string;
+    /** Unix ms; absent means the server did not scope the token's lifetime. */
+    expires_at?: number;
+}
+export declare function readSession(): PhoenixSession | null;
+export declare function writeSession(session: PhoenixSession): void;
+export declare function clearSession(): void;
+/** An error carrying the server's status and message, so callers can branch on it. */
+export declare class PhoenixApiError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+interface RequestOptions {
+    body?: unknown;
+    /** Send the stored session token. Default true; the device-flow start does not. */
+    auth?: boolean;
+    /** Use this token instead of the stored one (mid-login, before the write). */
+    token?: string;
+    timeoutMs?: number;
+}
+/** The single HTTP funnel. Every request to the account backend goes through here. */
+export declare function phoenixRequest<T>(method: 'GET' | 'POST' | 'PATCH' | 'DELETE', route: string, opts?: RequestOptions): Promise<T>;
+export {};

package/dist/lib/identity/client.js

@@ -0,0 +1,106 @@
+/**
+ * The ONE place agents-cli talks to its account backend (Phoenix ID).
+ *
+ * Why a seam at all: the removed Prix-coupled layer (RUSH-2581) had no single
+ * entry point — the backend URL was hardcoded in five files and the session
+ * token was re-read from `~/.rush/user.yaml` by seven separate functions, so
+ * re-pointing identity meant editing a dozen call sites and rewriting error
+ * strings scattered through the tree. This module is the correction: one base
+ * URL, one token reader, one HTTP funnel, one error type. Commands import from
+ * here and nothing else.
+ *
+ * The shape mirrors the seams this repo already proved elsewhere —
+ * `SyncBackend` (`lib/secrets/sync-backend.ts`) and `CloudProvider`
+ * (`lib/cloud/types.ts`) — so a second identity backend, if one is ever
+ * needed, is a swap here rather than a sweep across commands.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getRuntimeStateDir } from '../state.js';
+/**
+ * Where the account backend lives. Config, never a literal at a call site.
+ *
+ * The default is the deployed Phoenix ID Worker. It is a `workers.dev` URL
+ * rather than a vanity hostname because no custom domain is attached yet — and
+ * a default naming an unregistered domain is worse than an ugly one: every
+ * `agents auth login` would fail DNS with nothing to point at.
+ */
+export const PHOENIX_ID_BASE = process.env.PHOENIX_ID_BASE ?? 'https://phoenix-id.muqsitnawaz.workers.dev';
+/** Our own session file. agents-cli never reads another product's credentials. */
+export function sessionFilePath() {
+    return path.join(getRuntimeStateDir(), 'phoenix-session.json');
+}
+export function readSession() {
+    try {
+        const raw = fs.readFileSync(sessionFilePath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed.access_token ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeSession(session) {
+    const file = sessionFilePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(session, null, 2), { mode: 0o600 });
+}
+export function clearSession() {
+    try {
+        fs.rmSync(sessionFilePath(), { force: true });
+    }
+    catch {
+        // Already gone: logging out twice is not an error.
+    }
+}
+/** An error carrying the server's status and message, so callers can branch on it. */
+export class PhoenixApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'PhoenixApiError';
+    }
+}
+/** The single HTTP funnel. Every request to the account backend goes through here. */
+export async function phoenixRequest(method, route, opts = {}) {
+    const headers = { 'Content-Type': 'application/json' };
+    if (opts.auth !== false) {
+        const token = opts.token ?? readSession()?.access_token;
+        if (!token)
+            throw new PhoenixApiError("Not signed in. Run 'agents auth login'.", 401);
+        headers.Authorization = `Bearer ${token}`;
+    }
+    let response;
+    try {
+        response = await fetch(`${PHOENIX_ID_BASE}${route}`, {
+            method,
+            headers,
+            body: opts.body === undefined ? undefined : JSON.stringify(opts.body),
+            signal: AbortSignal.timeout(opts.timeoutMs ?? 15_000),
+        });
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new PhoenixApiError(`Could not reach the account service (${detail}).`, 0);
+    }
+    if (response.status === 204)
+        return undefined;
+    const text = await response.text();
+    let payload = null;
+    if (text) {
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = null;
+        }
+    }
+    if (!response.ok) {
+        const message = payload && typeof payload === 'object' && 'error' in payload
+            ? String(payload.error)
+            : `${response.status} ${response.statusText}`;
+        throw new PhoenixApiError(message, response.status);
+    }
+    return payload;
+}

package/dist/lib/identity/index.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Phoenix ID — the typed surface commands use. Every route the account backend
+ * exposes is a function here; no command builds a URL or reads a token itself.
+ */
+import { type PhoenixSession } from './client.js';
+export { PHOENIX_ID_BASE, PhoenixApiError, clearSession, readSession, sessionFilePath, writeSession, type PhoenixSession, } from './client.js';
+export interface DeviceAuthorization {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete: string;
+    expires_in: number;
+    interval: number;
+}
+export interface WhoAmI {
+    userId: string;
+    email: string;
+    valid: true;
+}
+/**
+ * RFC 8628 poll outcomes. `pending` and `slow_down` are normal states of a
+ * login in progress, not failures — the server signals them through the error
+ * body, and this is where that wire detail stops.
+ */
+export type DevicePoll = {
+    status: 'authorized';
+    access_token: string;
+    user: {
+        email: string;
+        id: string;
+    };
+} | {
+    status: 'pending';
+} | {
+    status: 'slow_down';
+} | {
+    status: 'expired';
+} | {
+    status: 'denied';
+};
+export declare function startDeviceAuthorization(): Promise<DeviceAuthorization>;
+export declare function pollDeviceToken(deviceCode: string): Promise<DevicePoll>;
+export declare function fetchWhoAmI(token?: string): Promise<WhoAmI>;
+export interface SpaceSummary {
+    id: string;
+    slug: string;
+    name: string;
+    organization_id: string | null;
+    owner_user_id: string;
+    invite_code?: string;
+    user_role: 'owner' | 'admin' | 'member';
+    created_at: string;
+}
+export interface SpaceMember {
+    user_id: string;
+    email: string;
+    name?: string;
+    avatar_url?: string;
+    role: 'owner' | 'admin' | 'member';
+    joined_at: string;
+}
+export interface SpaceInvite {
+    id: string;
+    space_id: string;
+    email: string;
+    role: 'admin' | 'member';
+    invite_code: string;
+    created_at: string;
+}
+export type CreateInviteResult = {
+    invited: true;
+    email: string;
+    role: string;
+    member_added: true;
+} | {
+    invited: true;
+    email: string;
+    role: string;
+    invite_code: string;
+    member_added: false;
+};
+export declare const listSpaces: () => Promise<SpaceSummary[]>;
+export declare const createSpace: (input: {
+    name: string;
+    slug: string;
+}) => Promise<SpaceSummary>;
+export declare const getSpace: (id: string) => Promise<SpaceSummary>;
+export declare const listSpaceMembers: (id: string) => Promise<SpaceMember[]>;
+export declare const createSpaceInvite: (id: string, input: {
+    email: string;
+    role: "admin" | "member";
+}) => Promise<CreateInviteResult>;
+export declare const listSpaceInvites: (id: string) => Promise<SpaceInvite[]>;
+export declare const revokeSpaceInvite: (id: string, inviteId: string) => Promise<{
+    revoked: true;
+}>;
+export declare const updateSpaceMemberRole: (id: string, userId: string, role: "admin" | "member") => Promise<{
+    user_id: string;
+    role: string;
+    updated: true;
+}>;
+export declare const removeSpaceMember: (id: string, userId: string) => Promise<void>;
+export declare const deleteSpace: (id: string) => Promise<void>;
+export interface Subscription {
+    tierName?: string;
+    [key: string]: unknown;
+}
+export declare const fetchSubscription: (agent?: string) => Promise<Subscription>;
+/** `Design Team` → `design-team`; the slug a space gets when the user gives only a name. */
+export declare function slugify(name: string): string;
+/** Resolve a space by id, slug, or name from a list the caller already fetched. */
+export declare function resolveSpaceFromList(spaces: SpaceSummary[], ref?: string): SpaceSummary | null;
+/** Resolve a member by email or user id from a list the caller already fetched. */
+export declare function resolveMemberFromList(members: SpaceMember[], ref: string): SpaceMember | null;
+export type { PhoenixSession as Session };

package/dist/lib/identity/index.js

@@ -0,0 +1,82 @@
+/**
+ * Phoenix ID — the typed surface commands use. Every route the account backend
+ * exposes is a function here; no command builds a URL or reads a token itself.
+ */
+import { phoenixRequest, PhoenixApiError } from './client.js';
+export { PHOENIX_ID_BASE, PhoenixApiError, clearSession, readSession, sessionFilePath, writeSession, } from './client.js';
+export function startDeviceAuthorization() {
+    return phoenixRequest('POST', '/api/v1/auth/device/authorization', {
+        auth: false,
+        body: {},
+    });
+}
+export async function pollDeviceToken(deviceCode) {
+    try {
+        return await phoenixRequest('POST', '/api/v1/auth/device/token', {
+            auth: false,
+            body: {
+                grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+                device_code: deviceCode,
+            },
+        });
+    }
+    catch (err) {
+        if (!(err instanceof PhoenixApiError))
+            throw err;
+        // The server encodes poll state in the error body (RFC 8628 §3.5).
+        if (err.message.includes('authorization_pending'))
+            return { status: 'pending' };
+        if (err.message.includes('slow_down'))
+            return { status: 'slow_down' };
+        if (err.message.includes('expired_token'))
+            return { status: 'expired' };
+        if (err.message.includes('access_denied'))
+            return { status: 'denied' };
+        throw err;
+    }
+}
+export function fetchWhoAmI(token) {
+    return phoenixRequest('GET', '/api/v1/auth/me', { token });
+}
+export const listSpaces = () => phoenixRequest('GET', '/api/v1/spaces');
+export const createSpace = (input) => phoenixRequest('POST', '/api/v1/spaces', { body: input });
+export const getSpace = (id) => phoenixRequest('GET', `/api/v1/spaces/${encodeURIComponent(id)}`);
+export const listSpaceMembers = (id) => phoenixRequest('GET', `/api/v1/spaces/${encodeURIComponent(id)}/members`);
+export const createSpaceInvite = (id, input) => phoenixRequest('POST', `/api/v1/spaces/${encodeURIComponent(id)}/invites`, {
+    body: input,
+});
+export const listSpaceInvites = (id) => phoenixRequest('GET', `/api/v1/spaces/${encodeURIComponent(id)}/invites`);
+export const revokeSpaceInvite = (id, inviteId) => phoenixRequest('DELETE', `/api/v1/spaces/${encodeURIComponent(id)}/invites/${encodeURIComponent(inviteId)}`);
+export const updateSpaceMemberRole = (id, userId, role) => phoenixRequest('PATCH', `/api/v1/spaces/${encodeURIComponent(id)}/members/${encodeURIComponent(userId)}`, {
+    body: { role },
+});
+export const removeSpaceMember = (id, userId) => phoenixRequest('DELETE', `/api/v1/spaces/${encodeURIComponent(id)}/members/${encodeURIComponent(userId)}`);
+export const deleteSpace = (id) => phoenixRequest('DELETE', `/api/v1/spaces/${encodeURIComponent(id)}`);
+export const fetchSubscription = (agent = 'agents-cli') => phoenixRequest('GET', `/api/v1/billing/subscription?agent=${encodeURIComponent(agent)}`);
+// ─── Helpers shared by the commands ──────────────────────────────────────────
+/** `Design Team` → `design-team`; the slug a space gets when the user gives only a name. */
+export function slugify(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 63);
+}
+/** Resolve a space by id, slug, or name from a list the caller already fetched. */
+export function resolveSpaceFromList(spaces, ref) {
+    if (!ref)
+        return spaces.length === 1 ? spaces[0] : null;
+    const needle = ref.trim().toLowerCase();
+    return (spaces.find((s) => s.id === ref) ??
+        spaces.find((s) => s.slug.toLowerCase() === needle) ??
+        spaces.find((s) => s.name.toLowerCase() === needle) ??
+        null);
+}
+/** Resolve a member by email or user id from a list the caller already fetched. */
+export function resolveMemberFromList(members, ref) {
+    const needle = ref.trim().toLowerCase();
+    return (members.find((m) => m.user_id === ref) ??
+        members.find((m) => m.email.toLowerCase() === needle) ??
+        null);
+}

package/dist/lib/probe.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Async probe capturing stdout. Rejects on spawn error, non-zero exit, or
+ * timeout — matching the `execFileAsync` contract the version probe had — and
+ * reaps the probe's whole process group on every settle path.
+ */
+export declare function probeCapture(cmd: string, args: string[], timeoutMs: number): Promise<{
+    stdout: string;
+}>;

package/dist/lib/probe.js

@@ -0,0 +1,105 @@
+/**
+ * Spawn helpers for CAPABILITY PROBES — short-lived invocations of third-party
+ * binaries (`copilot --version`, a manifest's `check:` command) whose only job
+ * is an exit status or a line of stdout.
+ *
+ * A probed binary may fork children of its own: the copilot npm wrapper forks
+ * a platform-binary downloader into `~/Library/Caches/copilot` on first run
+ * under a fresh HOME. Node's `timeout:` option kills only the DIRECT child, so
+ * such grandchildren outlive the probe and keep writing — under a test's temp
+ * HOME that race is the ENOTEMPTY teardown class (RUSH-3028; residual after
+ * RUSH-3021 gated the daemon autostart). Every probe here therefore runs in
+ * its OWN process group (`detached`), and the whole group is reaped once the
+ * probe settles, so nothing a probe spawned can outlive it.
+ *
+ * Group semantics are POSIX only: on win32 `detached` means a new console and
+ * negative-pid group kills are unsupported, so there the DIRECT child is
+ * killed on settle instead — the same guarantee `execFileAsync`'s `timeout:`
+ * gave (the grandchild leak class is a darwin/linux temp-HOME teardown race).
+ *
+ * The parent dying mid-probe is covered too: a detached probe leaves the
+ * terminal's foreground group, so a Ctrl-C that hard-exits the CLI
+ * (`process.exit(130)` in index.ts) would strand it. Live probe groups are
+ * tracked in LIVE_GROUPS and a `process.on('exit')` hook — which runs on
+ * every `process.exit` path, including that SIGINT handler — reaps them
+ * synchronously.
+ */
+import { spawn } from 'child_process';
+const GROUP_REAP = process.platform !== 'win32';
+const LIVE_GROUPS = new Set();
+let exitHookInstalled = false;
+function ensureExitHook() {
+    if (exitHookInstalled)
+        return;
+    exitHookInstalled = true;
+    process.on('exit', () => {
+        for (const pid of LIVE_GROUPS) {
+            try {
+                process.kill(-pid, 'SIGKILL');
+            }
+            catch {
+                /* group already fully exited */
+            }
+        }
+    });
+}
+function reapGroup(pid) {
+    if (!GROUP_REAP || !pid)
+        return;
+    LIVE_GROUPS.delete(pid);
+    try {
+        process.kill(-pid, 'SIGKILL');
+    }
+    catch {
+        /* group already fully exited */
+    }
+}
+/**
+ * Async probe capturing stdout. Rejects on spawn error, non-zero exit, or
+ * timeout — matching the `execFileAsync` contract the version probe had — and
+ * reaps the probe's whole process group on every settle path.
+ */
+export function probeCapture(cmd, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            detached: GROUP_REAP,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        });
+        if (GROUP_REAP && child.pid) {
+            LIVE_GROUPS.add(child.pid);
+            ensureExitHook();
+        }
+        let out = '';
+        let settled = false;
+        const settle = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reapGroup(child.pid);
+            // win32 has no group to reap: kill the direct child so a timed-out
+            // probe still dies, matching execFile's `timeout:` behavior. No-op
+            // after a clean exit.
+            if (!GROUP_REAP)
+                child.kill('SIGKILL');
+            if (err)
+                reject(err);
+            else
+                resolve({ stdout: out });
+        };
+        const timer = setTimeout(() => settle(new Error(`probe timed out after ${timeoutMs}ms: ${cmd} ${args.join(' ')}`)), timeoutMs);
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (d) => {
+            out += d;
+        });
+        child.on('error', (e) => settle(e));
+        // 'exit', not 'close': a forked grandchild inherits the stdout pipe, and
+        // 'close' waits for EVERY holder of that pipe to exit — exactly the
+        // process this helper exists to reap. Settle when the probed binary
+        // itself exits; one tick's grace lets its final stdout chunks land.
+        child.on('exit', (code) => {
+            setImmediate(() => settle(code === 0 ? null : new Error(`probe exited ${code}: ${cmd} ${args.join(' ')}`)));
+        });
+    });
+}

package/dist/lib/startup/command-registry.d.ts

@@ -30,8 +30,9 @@ export declare const KNOWN_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
  * read-only local web companion + `--control` anchor) was removed with the
  * unshipped iOS Fleet Cockpit it existed for (RUSH-3001). `apply` nested under
  * `agents fleet apply` / `agents devices apply`. `beta` nested under
- * `agents setup beta` (RUSH-2981). `auth` and `org` (the Prix-coupled account
- * layer) were removed pending the Phoenix-backed replacement (RUSH-2581).
+ * `agents setup beta` (RUSH-2981). `org` (the Prix-coupled account layer) was
+ * removed; `agents auth` returned against Phoenix ID with `auth space` as the
+ * team surface (RUSH-2581).
  */
 export declare const RETIRED_TOP_LEVEL_COMMANDS: ReadonlySet<string>;
 export declare function isKnownTopLevelCommand(name: string): boolean;

package/dist/lib/startup/command-registry.js

@@ -1,5 +1,5 @@
 const LOADED_COMMAND_NAMES = [
-    'accounts', 'view', 'inspect', 'feedback', 'commands', 'hooks', 'skills', 'rules', 'memory',
+    'accounts', 'auth', 'view', 'inspect', 'feedback', 'commands', 'hooks', 'skills', 'rules', 'memory',
     'permissions', 'mcp', 'clis', 'subagents', 'plugins', 'workflows', 'add', 'use', 'list',
     'remove', 'rm', 'purge', 'update', 'prune', 'import', 'registry', 'search', 'install',
     'routines', 'monitors', 'projects', 'run', 'open', 'reconnect', 'fork', 'config',
@@ -50,12 +50,12 @@ export const KNOWN_TOP_LEVEL_COMMANDS = new Set([
  * read-only local web companion + `--control` anchor) was removed with the
  * unshipped iOS Fleet Cockpit it existed for (RUSH-3001). `apply` nested under
  * `agents fleet apply` / `agents devices apply`. `beta` nested under
- * `agents setup beta` (RUSH-2981). `auth` and `org` (the Prix-coupled account
- * layer) were removed pending the Phoenix-backed replacement (RUSH-2581).
+ * `agents setup beta` (RUSH-2981). `org` (the Prix-coupled account layer) was
+ * removed; `agents auth` returned against Phoenix ID with `auth space` as the
+ * team surface (RUSH-2581).
  */
 export const RETIRED_TOP_LEVEL_COMMANDS = new Set([
     'webhook',
-    'auth',
     'org',
     'serve',
     'login',

package/dist/lib/view-types.d.ts

@@ -28,8 +28,8 @@ export interface ViewJsonVersion {
         resetsAt: string | null;
     }>;
     unavailable?: {
-        reason: 'session_limit';
-        resetsAt: string;
+        reason: 'session_limit' | 'out_of_credits';
+        resetsAt?: string;
     };
     lastActive: string | null;
     path: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.45",
+  "version": "1.22.46",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",