@phnx-labs/agents-cli 1.22.44 → 1.22.46

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/menubar/MenubarHelper.app/Contents/Info.plist

@@ -7,7 +7,11 @@
     <key>CFBundleIdentifier</key>
     <string>com.phnx-labs.agents-menubar</string>
     <key>CFBundleName</key>
-    <string>Agents Menu Bar</string>
+    <string>AGI Menu</string>
+    <key>CFBundleDisplayName</key>
+    <string>AGI Menu</string>
+    <key>CFBundleIconFile</key>
+    <string>AppIcon</string>
     <key>CFBundlePackageType</key>
     <string>APPL</string>
     <key>CFBundleShortVersionString</key>

package/dist/lib/menubar/MenubarHelper.app/Contents/_CodeSignature/CodeResources

@@ -3,9 +3,22 @@
 <plist version="1.0">
 <dict>
 	<key>files</key>
-	<dict/>
+	<dict>
+		<key>Resources/AppIcon.icns</key>
+		<data>
+		jOjZVimcFRHoP2VPzgn8uM8mjkA=
+		</data>
+	</dict>
 	<key>files2</key>
-	<dict/>
+	<dict>
+		<key>Resources/AppIcon.icns</key>
+		<dict>
+			<key>hash2</key>
+			<data>
+			GFvSLeNYJ3ASxW3OzcuiB4aID0gZUBkpozmWZkbTFNw=
+			</data>
+		</dict>
+	</dict>
 	<key>rules</key>
 	<dict>
 		<key>^Resources/</key>

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,7 +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).
+ * `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', 'auth', 'org', '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,10 +50,13 @@ 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).
+ * `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',
+    'org',
     'serve',
     'login',
     'logout',

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.44",
+  "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",

package/dist/commands/org.d.ts

@@ -1,11 +0,0 @@
-import type { Command } from 'commander';
-/** `--role` defaults to member when omitted; anything present must be a real role — never silently coerced. */
-export declare function resolveInviteRole(raw: string | undefined): 'admin' | 'member';
-/** Validate a role argument before any network call — same rule the backend enforces server-side. */
-export declare function parseRole(raw: string): 'admin' | 'member';
-/** One-line deprecation for the leftover top-level `agents org` spelling. */
-export declare function printOrgDeprecation(): void;
-/** Canonical home: `agents auth space …`. */
-export declare function registerAuthSpaceCommand(auth: Command): void;
-/** Leftover top-level spelling — same tree, deprecation on every path. */
-export declare function registerOrgCommand(program: Command): void;

package/dist/commands/org.js

@@ -1,228 +0,0 @@
-import chalk from 'chalk';
-import { setHelpSections } from '../lib/help.js';
-import { runOrDie } from '../lib/format.js';
-import { createSpace, createSpaceInvite, fetchWhoAmI, listSpaceMembers, listSpaces, removeSpaceMember, resolveMemberFromList, resolvePrixToken, resolveSpaceFromList, slugify, updateSpaceMemberRole, } from '../lib/prix-account.js';
-/** Every `agents org` subcommand needs a token up front — one place to say so. */
-function requireToken() {
-    if (!resolvePrixToken())
-        throw new Error("Not signed in. Run 'agents auth login' first.");
-}
-async function resolveSpace(explicit) {
-    const spaces = await listSpaces();
-    return resolveSpaceFromList(spaces, explicit);
-}
-function printSpace(space) {
-    console.log(`${chalk.bold(space.name)}  ${chalk.gray(space.slug)}  ${chalk.gray(space.id)}`);
-    console.log(`  role: ${space.user_role}${space.organization_id ? `  org: ${space.organization_id}` : ''}`);
-}
-function printMembers(members) {
-    if (!members.length) {
-        console.log(chalk.gray('  No members.'));
-        return;
-    }
-    for (const m of members)
-        console.log(`  ${chalk.cyan(m.email)}  ${m.role}  ${chalk.gray(m.user_id)}`);
-}
-async function runCreate(name, o) {
-    requireToken();
-    const space = await createSpace({ name, slug: o.slug ?? slugify(name), description: o.description });
-    if (o.json) {
-        console.log(JSON.stringify(space, null, 2));
-        return;
-    }
-    console.log(chalk.green(`Created space '${space.name}' (${space.slug}).`));
-    printSpace(space);
-}
-async function runList(o) {
-    requireToken();
-    const spaces = await listSpaces();
-    if (o.json) {
-        console.log(JSON.stringify(spaces, null, 2));
-        return;
-    }
-    if (!spaces.length) {
-        console.log(chalk.gray("No spaces. Create one with 'agents auth space create <name>'."));
-        return;
-    }
-    for (const space of spaces)
-        printSpace(space);
-}
-async function runView(spaceArg, o) {
-    requireToken();
-    const space = await resolveSpace(spaceArg);
-    if (o.json) {
-        console.log(JSON.stringify(space, null, 2));
-        return;
-    }
-    printSpace(space);
-}
-/** `--role` defaults to member when omitted; anything present must be a real role — never silently coerced. */
-export function resolveInviteRole(raw) {
-    return raw === undefined ? 'member' : parseRole(raw);
-}
-async function runInvite(email, o) {
-    requireToken();
-    const role = resolveInviteRole(o.role);
-    const space = await resolveSpace(o.space);
-    const result = await createSpaceInvite(space.id, email, role);
-    if (o.json) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    if (result.member_added)
-        console.log(chalk.green(`Added ${email} to '${space.name}' as ${role}.`));
-    else
-        console.log(chalk.green(`Invited ${email} to '${space.name}' as ${role}. They'll get an email.`));
-}
-async function runMembers(spaceArg, o) {
-    requireToken();
-    const space = await resolveSpace(spaceArg);
-    const members = await listSpaceMembers(space.id);
-    if (o.json) {
-        console.log(JSON.stringify(members, null, 2));
-        return;
-    }
-    console.log(chalk.bold(`${space.name} (${members.length} member${members.length === 1 ? '' : 's'})`));
-    printMembers(members);
-}
-/** Validate a role argument before any network call — same rule the backend enforces server-side. */
-export function parseRole(raw) {
-    if (raw === 'admin' || raw === 'member')
-        return raw;
-    throw new Error(`role must be 'admin' or 'member', got '${raw}'.`);
-}
-async function runRole(email, roleRaw, o) {
-    requireToken();
-    const role = parseRole(roleRaw);
-    const space = await resolveSpace(o.space);
-    const members = await listSpaceMembers(space.id);
-    const member = resolveMemberFromList(members, email);
-    const result = await updateSpaceMemberRole(space.id, member.user_id, role);
-    if (o.json) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-    }
-    console.log(chalk.green(`${email} is now ${role} in '${space.name}'.`));
-}
-async function runRemove(email, o) {
-    requireToken();
-    const space = await resolveSpace(o.space);
-    const members = await listSpaceMembers(space.id);
-    const member = resolveMemberFromList(members, email);
-    await removeSpaceMember(space.id, member.user_id);
-    if (o.json) {
-        console.log(JSON.stringify({ removed: email, space: space.slug }, null, 2));
-        return;
-    }
-    console.log(chalk.green(`Removed ${email} from '${space.name}'.`));
-}
-async function runLeave(spaceArg, o) {
-    requireToken();
-    const resolved = resolvePrixToken();
-    if (!resolved)
-        throw new Error("Not signed in. Run 'agents auth login' first.");
-    const who = await fetchWhoAmI(resolved.token);
-    const space = await resolveSpace(spaceArg);
-    if (space.owner_user_id === who.userId) {
-        throw new Error(`You own '${space.name}'. Transfer ownership or delete the space instead of leaving it.`);
-    }
-    await removeSpaceMember(space.id, who.userId);
-    if (o.json) {
-        console.log(JSON.stringify({ left: space.slug }, null, 2));
-        return;
-    }
-    console.log(chalk.green(`Left '${space.name}'.`));
-}
-/** One-line deprecation for the leftover top-level `agents org` spelling. */
-export function printOrgDeprecation() {
-    console.error(chalk.yellow('agents org is deprecated — use `agents auth space`.'));
-}
-/** Shared space CRUD tree — canonical under `auth space`, leftover under `org`. */
-function attachSpaceCommands(parent, opts) {
-    const before = () => {
-        if (opts.deprecated)
-            printOrgDeprecation();
-    };
-    const jsonFlag = (o, command) => !!(o.json || command.optsWithGlobals().json);
-    parent.command('create <name>').description('Create a space (free tier: 1 owned space)')
-        .option('--slug <slug>', 'Override the derived slug')
-        .option('--description <text>', 'Optional description')
-        .option('--json', 'Machine-readable output')
-        .action((name, o, command) => {
-        before();
-        const json = jsonFlag(o, command);
-        return runOrDie(() => runCreate(name, { ...o, json }), { json });
-    });
-    parent.command('list').description('List spaces you own or belong to').option('--json', 'Machine-readable output')
-        .action((o, command) => {
-        before();
-        const json = jsonFlag(o, command);
-        return runOrDie(() => runList({ json }), { json });
-    });
-    parent.command('view [space]').description('Show one space (defaults to your only space)').option('--json', 'Machine-readable output')
-        .action((space, o, command) => {
-        before();
-        const json = jsonFlag(o, command);
-        return runOrDie(() => runView(space, { json }), { json });
-    });
-    parent.command('invite <email>').description('Invite (or directly add) a member')
-        .option('--role <role>', 'admin | member', 'member')
-        .option('--space <id-or-slug>', 'Space to invite into (defaults to your only space)')
-        .option('--json', 'Machine-readable output')
-        .action((email, o, command) => {
-        before();
-        const json = jsonFlag(o, command);
-        return runOrDie(() => runInvite(email, { ...o, json }), { json });
-    });
-    parent.command('members [space]').description("List a space's members").option('--json', 'Machine-readable output')
-        .action((space, o, command) => {
-        before();
-        const json = jsonFlag(o, command);
-        return runOrDie(() => runMembers(space, { json }), { json });
-    });
-    parent.command('role <email> <role>').description("Change a member's role (owner-only for admin)")
-        .option('--space <id-or-slug>', 'Space to change (defaults to your only space)')
-        .option('--json', 'Machine-readable output')
-        .action((email, role, o, command) => {
-        before();
-        const json = jsonFlag(o, command);
-        return runOrDie(() => runRole(email, role, { ...o, json }), { json });
-    });
-    parent.command('remove <email>').description('Remove a member from a space')
-        .option('--space <id-or-slug>', 'Space to remove from (defaults to your only space)')
-        .option('--json', 'Machine-readable output')
-        .action((email, o, command) => {
-        before();
-        const json = jsonFlag(o, command);
-        return runOrDie(() => runRemove(email, { ...o, json }), { json });
-    });
-    parent.command('leave [space]').description('Leave a space you do not own').option('--json', 'Machine-readable output')
-        .action((space, o, command) => {
-        before();
-        const json = jsonFlag(o, command);
-        return runOrDie(() => runLeave(space, { json }), { json });
-    });
-    setHelpSections(parent, {
-        examples: `${opts.prefix} create acme-team
-${opts.prefix} list
-${opts.prefix} view acme-team
-${opts.prefix} invite dev@example.com --role admin
-${opts.prefix} members
-${opts.prefix} role dev@example.com admin
-${opts.prefix} remove dev@example.com
-${opts.prefix} leave acme-team`,
-        notes: opts.deprecated
-            ? 'Deprecated alias of `agents auth space`. Maps to the Rush backend\'s /api/v1/spaces (the free-tier team primitive), not /api/v1/orgs. Free tier: 1 owned space, 3 members per space. Every command needs `agents auth login` (or a `rush login` session) first. `--space` is only needed once you belong to more than one space.'
-            : 'Maps to the Rush backend\'s /api/v1/spaces (the free-tier team primitive), not /api/v1/orgs. Free tier: 1 owned space, 3 members per space. Every command needs `agents auth login` (or a `rush login` session) first. `--space` is only needed once you belong to more than one space. The leftover `agents org` spelling still works and prints a deprecation line.',
-    });
-}
-/** Canonical home: `agents auth space …`. */
-export function registerAuthSpaceCommand(auth) {
-    const space = auth.command('space').description('Create and manage a Prix space (invite collaborators)');
-    attachSpaceCommands(space, { prefix: 'agents auth space' });
-}
-/** Leftover top-level spelling — same tree, deprecation on every path. */
-export function registerOrgCommand(program) {
-    const org = program.command('org').description('Deprecated alias of `agents auth space` — create and manage a Prix space');
-    attachSpaceCommands(org, { prefix: 'agents org', deprecated: true });
-}