@phnx-labs/agents-cli 1.16.0 → 1.17.1

package/dist/index.js

@@ -36,6 +36,7 @@ import { registerRulesCommands } from './commands/rules.js';
 import { registerPermissionsCommands } from './commands/permissions.js';
 import { registerMcpCommands } from './commands/mcp.js';
 import { registerVersionsCommands } from './commands/versions.js';
+import { registerImportCommand } from './commands/import.js';
 import { registerPackagesCommands } from './commands/packages.js';
 import { registerDaemonCommands } from './commands/daemon.js';
 import { registerRoutinesCommands } from './commands/routines.js';
@@ -46,6 +47,7 @@ import { registerTrashCommands } from './commands/trash.js';
 import { registerDoctorCommand } from './commands/doctor.js';
 import { registerSubagentsCommands } from './commands/subagents.js';
 import { registerPluginsCommands } from './commands/plugins.js';
+import { registerWorkflowsCommands } from './commands/workflows.js';
 import { registerSyncCommand } from './commands/sync.js';
 import { registerRefreshRulesCommand } from './commands/refresh-rules.js';
 import { registerDriveCommands } from './commands/drive.js';
@@ -60,8 +62,8 @@ import { registerBetaCommands } from './commands/beta.js';
 import { applyGlobalHelpConventions } from './lib/help.js';
 import { isPromptCancelled } from './commands/utils.js';
 import { AGENTS } from './lib/agents.js';
-import { getGlobalDefault } from './lib/versions.js';
-import { addShimsToPath, ensureShimCurrent, getPathShadowingExecutable, getPathSetupInstructions, hasAliasShadowingShim, isShimsInPath, listAgentsWithInstalledVersions, removeLegacyUserShim, } from './lib/shims.js';
+import { getGlobalDefault, listInstalledVersions } from './lib/versions.js';
+import { addShimsToPath, ensureShimCurrent, ensureVersionedAliasCurrent, getPathShadowingExecutable, getPathSetupInstructions, hasAliasShadowingShim, isShimsInPath, listAgentsWithInstalledVersions, removeLegacyUserShim, } from './lib/shims.js';
 const program = new Command();
 program
     .name('agents')
@@ -86,9 +88,11 @@ Quick start:
 
 Agent versions:
   add <agent>[@version]           Install an agent CLI (e.g. agents add codex)
+  import <agent>                  Adopt an existing global install (npm/homebrew) into agents-cli
   remove <agent>[@version]        Uninstall a version
   use <agent>@<version>           Set the default version
-  prune [target]                  Remove orphan resources (commands/skills/hooks) and/or older duplicate version installs
+  prune [target]                  Remove orphan resources and older duplicate version installs (targets: commands, sessions, runs, trash)
+  trash                           Inspect and restore soft-deleted version directories
   view [agent[@version]]          List versions, or inspect one in detail
 
 Agent configuration (synced across versions):
@@ -97,7 +101,7 @@ Agent configuration (synced across versions):
   skills                          Knowledge packs (SKILL.md + supporting files)
   mcp                             MCP servers (stdio or HTTP)
   permissions                     Allow/deny rules for tool calls
-  hooks                           Shell scripts that run on agent events
+  hooks                           Shell scripts that run on agent events (hooks.yaml in agents.yaml)
   subagents                       Named sub-agent definitions
   plugins                         Bundles of skills, hooks, and scripts
 
@@ -105,19 +109,30 @@ Packages:
   search <query>                  Find MCP servers and skills in registries
   install <pkg>                   Install from registry (mcp:name, skill:user/repo)
 
-Run agents:
+Run and dispatch:
   run <agent|profile> [prompt]    Run an agent. Omit prompt for interactive mode.
   teams                           Coordinate multiple agents on shared work
   routines                        Run agents on a cron schedule (scheduler auto-starts)
-  sessions                        Browse and replay past runs
+  sessions                        Browse, search, and replay past runs (live-search in TTY; grouped by workspace)
+  browser                         Automate a browser — navigate, click, screenshot, console, network
+  pty                             Drive interactive terminal programs (REPLs, TUIs) via a persistent PTY session
 
-Credentials:
+Credentials and profiles:
   profiles                        Bundles of (host CLI, endpoint, model, auth)
-  secrets                         Keychain-backed env bundles injected at spawn
+  secrets                         Keychain-backed env bundles; use 'secrets exec <bundle> -- <cmd>' to inject into a subprocess
 
-Helpers:
-  beta                            Enable preview features like drive and factory
-  pty                             Drive interactive terminal programs (REPLs, TUIs)
+Diagnostics:
+  doctor [agent[@version]]        Diagnose CLI availability, sync status, and resource divergence
+  usage [agent]                   Show rate-limit and quota usage per agent
+
+Config sync:
+  drive                           Sync session history across machines via rsync
+  pull                            Clone or pull the system repo at ~/.agents-system/
+  repo init --path <dir>          Scaffold your own editable repo from a template
+  repo add <path|gh:user/repo>    Merge an extra repo after the system repo
+
+Beta features:
+  beta                            Enable preview features (factory, drive, and more)
 
 Automation tips:
   Pass explicit names/IDs         Avoid pickers: agents sessions <id> --markdown
@@ -126,11 +141,6 @@ Automation tips:
   Use agent@version targets       e.g. --agents claude@2.1.79,codex@default
   Non-TTY shells apply defaults   Omitted required selections fail with a plain hint
 
-Config sync (portable setup via git):
-  pull                            Clone or pull the system repo at ~/.agents-system/
-  repo init --path <dir>          Scaffold your own editable repo from a template
-  repo add <path|gh:user/repo>    Merge an extra repo after the system repo
-
 Options:
   -V, --version                   Show version number
   -h, --help                      Show help
@@ -335,6 +345,12 @@ async function maybeBootstrapShimIntegration(requestedCommand) {
         if (status !== 'current') {
             createdOrUpdated.push(`${status === 'created' ? 'Created' : 'Updated'} ${AGENTS[agent].cliCommand} shim`);
         }
+        for (const version of listInstalledVersions(agent)) {
+            const aliasStatus = ensureVersionedAliasCurrent(agent, version);
+            if (aliasStatus !== 'current') {
+                createdOrUpdated.push(`${aliasStatus === 'created' ? 'Created' : 'Updated'} ${AGENTS[agent].cliCommand}@${version} alias`);
+            }
+        }
     }
     for (const notice of createdOrUpdated) {
         console.log(chalk.green(notice));
@@ -444,7 +460,9 @@ program
 registerMcpCommands(program);
 registerSubagentsCommands(program);
 registerPluginsCommands(program);
+registerWorkflowsCommands(program);
 registerVersionsCommands(program);
+registerImportCommand(program);
 registerPackagesCommands(program);
 registerDaemonCommands(program);
 registerRoutinesCommands(program);

package/dist/lib/browser/cdp.js

@@ -101,10 +101,13 @@ export function verifyBrowserIdentity(reported, expected, port, host = 'localhos
         return;
     const matches = {
         chrome: ['chrome', 'google-chrome', 'headlesschrome'],
-        chromium: ['chromium', 'headlesschrome'],
-        comet: ['comet'],
-        brave: ['brave', 'brave-browser'],
-        edge: ['edge', 'microsoft-edge', 'msedge'],
+        chromium: ['chromium', 'headlesschrome', 'chrome'],
+        // Comet reports itself as plain "Chrome/<version>" in /json/version — it
+        // doesn't override the Chromium branding. Accept chrome here so attaching
+        // to a Comet instance doesn't trip a false "identity mismatch".
+        comet: ['comet', 'chrome'],
+        brave: ['brave', 'brave-browser', 'chrome'],
+        edge: ['edge', 'microsoft-edge', 'msedge', 'chrome'],
     };
     const accepted = matches[expected] || [expected];
     if (accepted.includes(reported))

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

@@ -14,3 +14,13 @@ export declare function getRunningChromeInfo(profileName: string): {
     port: number;
 } | null;
 export declare function allocatePort(): number;
+export interface PortOccupant {
+    pid: number;
+    command: string;
+}
+/**
+ * Identify the process listening on a TCP port via lsof. Returns null when nothing is bound.
+ * Used for clearer error messages when a profile's configured port is taken by a non-debug
+ * process (e.g. Comet running without --remote-debugging-port).
+ */
+export declare function getPortOccupant(port: number): PortOccupant | null;

package/dist/lib/browser/chrome.js

@@ -69,6 +69,7 @@ export async function launchBrowser(profileName, browserType, port, options = {}
     const runtimeDir = getProfileRuntimeDir(profileName);
     const userDataDir = path.join(runtimeDir, 'chrome-data');
     fs.mkdirSync(userDataDir, { recursive: true });
+    const viewport = options.viewport ?? { width: 1512, height: 982 };
     const args = [
         `--remote-debugging-port=${port}`,
         `--user-data-dir=${userDataDir}`,
@@ -77,7 +78,10 @@ export async function launchBrowser(profileName, browserType, port, options = {}
         '--disable-backgrounding-occluded-windows',
         '--disable-renderer-backgrounding',
         ...(options.headless ? ['--headless=new'] : []),
-        ...(options.viewport ? [`--window-size=${options.viewport.width},${options.viewport.height}`] : []),
+        `--window-size=${viewport.width},${viewport.height}`,
+        ...(viewport.x !== undefined && viewport.y !== undefined
+            ? [`--window-position=${viewport.x},${viewport.y}`]
+            : []),
         ...(options.args || []),
     ];
     let env = { ...process.env };
@@ -150,7 +154,11 @@ function isProcessRunning(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch {
+    catch (err) {
+        // EPERM means the process exists but we lack permission to signal it —
+        // treat as alive. ESRCH means the process does not exist.
+        if (err && err.code === 'EPERM')
+            return true;
         return false;
     }
 }
@@ -170,3 +178,30 @@ export function allocatePort() {
     }
     throw new Error('No available ports in range 9200-9300');
 }
+/**
+ * Identify the process listening on a TCP port via lsof. Returns null when nothing is bound.
+ * Used for clearer error messages when a profile's configured port is taken by a non-debug
+ * process (e.g. Comet running without --remote-debugging-port).
+ */
+export function getPortOccupant(port) {
+    try {
+        const out = execSync(`lsof -nP -iTCP:${port} -sTCP:LISTEN -Fpcn`, {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        let pid = 0;
+        let command = '';
+        for (const line of out.split('\n')) {
+            if (line.startsWith('p'))
+                pid = parseInt(line.slice(1), 10) || 0;
+            else if (line.startsWith('c') && !command)
+                command = line.slice(1);
+        }
+        if (!pid)
+            return null;
+        return { pid, command: command || 'unknown' };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/browser/drivers/local.js

@@ -1,5 +1,5 @@
 import { CDPClient, discoverBrowserWsUrl, verifyBrowserIdentity } from '../cdp.js';
-import { launchBrowser, allocatePort } from '../chrome.js';
+import { launchBrowser, getPortOccupant } from '../chrome.js';
 export async function connectLocal(endpoint, profile) {
     const url = new URL(endpoint);
     if (url.protocol !== 'cdp:') {
@@ -17,7 +17,18 @@ export async function connectLocal(endpoint, profile) {
         if (err instanceof Error && err.message.startsWith('Browser identity mismatch')) {
             throw err;
         }
-        const newPort = allocatePort();
+        // Distinguish "nothing listening on this port" (fine to launch fresh) from
+        // "something is listening but it's not a debuggable browser" (bail loudly —
+        // silently launching on a different port leads to confusing `pid 0` and
+        // `CDP connection not open` errors downstream).
+        const occupant = getPortOccupant(port);
+        if (occupant) {
+            throw new Error(`Port ${port} is occupied by ${occupant.command} (pid ${occupant.pid}) but is ` +
+                `not serving the Chrome DevTools Protocol. Either stop that process ` +
+                `(\`kill ${occupant.pid}\`) or restart it with \`--remote-debugging-port=${port}\` ` +
+                `so profile "${profile.name}" can attach.`);
+        }
+        const newPort = port;
         const chromeOpts = { ...profile.chrome, viewport: profile.viewport };
         const { pid, wsUrl } = await launchBrowser(profile.name, profile.browser, newPort, chromeOpts, profile.secrets, profile.binary);
         const cdp = new CDPClient();

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

@@ -1,6 +1,7 @@
 import type { CDPClient } from './cdp.js';
 export declare function clickAtCoords(cdp: CDPClient, sessionId: string, x: number, y: number): Promise<void>;
 export declare function hoverAtCoords(cdp: CDPClient, sessionId: string, x: number, y: number): Promise<void>;
+export declare function scrollAtCoords(cdp: CDPClient, sessionId: string, x: number, y: number, deltaX: number, deltaY: number): Promise<void>;
 export declare function typeText(cdp: CDPClient, sessionId: string, text: string): Promise<void>;
 export declare function pressKey(cdp: CDPClient, sessionId: string, keyName: string): Promise<void>;
 export declare function focusNode(cdp: CDPClient, sessionId: string, backendNodeId: number): Promise<void>;

package/dist/lib/browser/input.js

@@ -5,6 +5,9 @@ export async function clickAtCoords(cdp, sessionId, x, y) {
 export async function hoverAtCoords(cdp, sessionId, x, y) {
     await cdp.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y }, sessionId);
 }
+export async function scrollAtCoords(cdp, sessionId, x, y, deltaX, deltaY) {
+    await cdp.send('Input.dispatchMouseEvent', { type: 'mouseWheel', x, y, deltaX, deltaY }, sessionId);
+}
 export async function typeText(cdp, sessionId, text) {
     for (const char of text) {
         await cdp.send('Input.dispatchKeyEvent', { type: 'keyDown', text: char }, sessionId);

package/dist/lib/browser/ipc.js

@@ -78,6 +78,13 @@ export class BrowserIPCServer {
                     windowTargetId: result.windowId,
                 };
             }
+            case 'launch-profile': {
+                if (!request.profile) {
+                    return { ok: false, error: 'Profile required' };
+                }
+                const result = await this.service.launchProfile(request.profile);
+                return { ok: true, port: result.port, pid: result.pid };
+            }
             case 'done': {
                 if (!request.task) {
                     return { ok: false, error: 'Task required' };
@@ -191,6 +198,13 @@ export class BrowserIPCServer {
                 await this.service.hover(request.task, request.ref, request.tabId);
                 return { ok: true };
             }
+            case 'scroll': {
+                if (!request.task) {
+                    return { ok: false, error: 'Task required' };
+                }
+                await this.service.scroll(request.task, request.scrollX ?? 0, request.scrollY ?? 0, request.scrollAtX, request.scrollAtY, request.tabId);
+                return { ok: true };
+            }
             case 'set-viewport': {
                 if (!request.task || !request.width || !request.height) {
                     return { ok: false, error: 'Task, width, and height required' };

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

@@ -4,6 +4,11 @@ export declare function getBrowserRuntimeDir(): string;
 export declare function getProfileRuntimeDir(name: string): string;
 export declare function listProfiles(): Promise<BrowserProfile[]>;
 export declare function getProfile(name: string): Promise<BrowserProfile | null>;
+/**
+ * Find a port in 9222–9399 that is not already claimed by another profile
+ * and is not currently in use by any OS process.
+ */
+export declare function findFreeProfilePort(): Promise<number>;
 export declare function createProfile(profile: BrowserProfile): Promise<void>;
 export declare function updateProfile(profile: BrowserProfile): Promise<void>;
 export declare function deleteProfile(name: string): Promise<void>;

package/dist/lib/browser/profiles.js

@@ -1,5 +1,7 @@
 import * as path from 'path';
+import { execSync } from 'child_process';
 import { getBrowserRuntimeDir as getBrowserRuntimeDirRoot, readMeta, writeMeta, } from '../state.js';
+import { findBrowserPath } from './chrome.js';
 export function getBrowserRuntimeDir() {
     return getBrowserRuntimeDirRoot();
 }
@@ -51,11 +53,54 @@ export async function getProfile(name) {
         return null;
     return configToProfile(name, config);
 }
+/**
+ * Find a port in 9222–9399 that is not already claimed by another profile
+ * and is not currently in use by any OS process.
+ */
+export async function findFreeProfilePort() {
+    const profiles = await listProfiles();
+    const usedByProfile = new Set();
+    for (const p of profiles) {
+        const port = extractConfiguredPort(p);
+        if (port !== undefined)
+            usedByProfile.add(port);
+    }
+    for (let port = 9222; port <= 9399; port++) {
+        if (usedByProfile.has(port))
+            continue;
+        try {
+            execSync(`lsof -i :${port}`, { stdio: 'ignore' });
+            // lsof succeeded → something is listening → port is in use
+        }
+        catch {
+            // lsof threw → nothing on this port → it's free
+            return port;
+        }
+    }
+    throw new Error('No available ports in range 9222-9399');
+}
 export async function createProfile(profile) {
     const meta = readMeta();
     if (meta.browser?.[profile.name]) {
         throw new Error(`Profile "${profile.name}" already exists`);
     }
+    // Check for port collision with existing profiles
+    const newPort = extractConfiguredPort(profile);
+    if (newPort !== undefined && meta.browser) {
+        for (const [existingName, existingConfig] of Object.entries(meta.browser)) {
+            const existingProfile = configToProfile(existingName, existingConfig);
+            const existingPort = extractConfiguredPort(existingProfile);
+            if (existingPort === newPort) {
+                throw new Error(`Port ${newPort} is already used by profile "${existingName}". ` +
+                    `Each profile must own a unique port. Use a different port or omit --endpoint to auto-assign.`);
+            }
+        }
+    }
+    // Resolve the browser binary at create time. Fails fast with an actionable
+    // error ("Comet not installed at /Applications/Comet.app") rather than
+    // deferring the failure to the first task. `findBrowserPath` short-circuits
+    // for browser=custom without a binary by throwing — same outcome.
+    findBrowserPath(profile.browser, profile.binary);
     meta.browser = meta.browser ?? {};
     meta.browser[profile.name] = profileToConfig(profile);
     writeMeta(meta);

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

@@ -17,6 +17,15 @@ export declare class BrowserService {
         tabId?: string;
         windowId?: string;
     }>;
+    /**
+     * Launch (or attach to) the profile's browser without creating a task. Used by
+     * `agents browser profiles launch <name>` so users can warm up the browser —
+     * including the first-run onboarding flow — before any automation starts.
+     */
+    launchProfile(profileName: string): Promise<{
+        port: number;
+        pid: number;
+    }>;
     stop(taskName: string): Promise<{
         ok: boolean;
         profile?: string;
@@ -60,6 +69,7 @@ export declare class BrowserService {
     type(taskId: string, ref: number, text: string, tabHint?: string): Promise<void>;
     press(taskId: string, key: string, tabHint?: string): Promise<void>;
     hover(taskId: string, ref: number, tabHint?: string): Promise<void>;
+    scroll(taskId: string, deltaX: number, deltaY: number, atX?: number, atY?: number, tabHint?: string): Promise<void>;
     status(profileName?: string): Promise<ProfileStatus[]>;
     private reconcileFromDisk;
     setViewport(taskId: string, width: number, height: number, options?: {

package/dist/lib/browser/service.js

@@ -7,7 +7,7 @@ import { connectLocal } from './drivers/local.js';
 import { connectSSH } from './drivers/ssh.js';
 import { generateTaskId, generateShortId, generateFunName, } from './types.js';
 import { getRefs, resolveRefToCoords } from './refs.js';
-import { clickAtCoords, hoverAtCoords, typeText, pressKey, focusNode } from './input.js';
+import { clickAtCoords, hoverAtCoords, scrollAtCoords, typeText, pressKey, focusNode } from './input.js';
 import { emit } from '../events.js';
 export class BrowserService {
     connections = new Map();
@@ -97,6 +97,24 @@ export class BrowserService {
         }
         return { task: taskId, name: taskName, tabId };
     }
+    /**
+     * Launch (or attach to) the profile's browser without creating a task. Used by
+     * `agents browser profiles launch <name>` so users can warm up the browser —
+     * including the first-run onboarding flow — before any automation starts.
+     */
+    async launchProfile(profileName) {
+        const profile = await getProfile(profileName);
+        if (!profile) {
+            throw new Error(`Profile "${profileName}" not found`);
+        }
+        let conn = this.connections.get(profileName);
+        if (!conn) {
+            conn = await this.connectProfile(profile);
+            this.connections.set(profileName, conn);
+        }
+        emit('browser.launch', { profile: profileName, task: '', pid: conn.pid });
+        return { port: conn.port, pid: conn.pid };
+    }
     async stop(taskName) {
         for (const [profileName, conn] of this.connections) {
             const task = conn.tasks.get(taskName);
@@ -424,6 +442,16 @@ export class BrowserService {
         const { x, y } = await resolveRefToCoords(conn.cdp, sessionId, nodeMap, ref);
         await hoverAtCoords(conn.cdp, sessionId, x, y);
     }
+    async scroll(taskId, deltaX, deltaY, atX, atY, tabHint) {
+        const { conn, task } = await this.findTask(taskId);
+        const shortId = tabHint ? await this.resolveTabHint(conn, task, tabHint) : this.resolveCurrentTab(task);
+        const cdpTargetId = this.getCdpTargetId(task, shortId);
+        const target = await this.getTarget(conn, cdpTargetId);
+        if (!target)
+            throw new Error(`Tab ${shortId} not found`);
+        const sessionId = await this.getSessionId(conn, target.targetId);
+        await scrollAtCoords(conn.cdp, sessionId, atX ?? 0, atY ?? 0, deltaX, deltaY);
+    }
     async status(profileName) {
         const seen = new Set();
         const statuses = [];

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

@@ -11,6 +11,8 @@ export interface BrowserProfile {
     viewport?: {
         width: number;
         height: number;
+        x?: number;
+        y?: number;
     };
 }
 export interface ChromeOptions {
@@ -19,6 +21,8 @@ export interface ChromeOptions {
     viewport?: {
         width: number;
         height: number;
+        x?: number;
+        y?: number;
     };
 }
 export interface Task {
@@ -69,7 +73,7 @@ export interface HistoricalTask {
     domains: string[];
     tabCount: number;
 }
-export type IPCAction = 'start' | 'done' | 'stop' | 'status' | 'history' | 'navigate' | 'tab-add' | 'tab-focus' | 'tab-close' | 'tab-list' | 'evaluate' | 'screenshot' | 'refs' | 'click' | 'type' | 'press' | 'hover' | 'set-viewport' | 'set-device' | 'console' | 'errors' | 'requests' | 'response-body' | 'wait' | 'set-download-path' | 'wait-download';
+export type IPCAction = 'start' | 'launch-profile' | 'done' | 'stop' | 'status' | 'history' | 'navigate' | 'tab-add' | 'tab-focus' | 'tab-close' | 'tab-list' | 'evaluate' | 'screenshot' | 'refs' | 'click' | 'type' | 'press' | 'hover' | 'scroll' | 'set-viewport' | 'set-device' | 'console' | 'errors' | 'requests' | 'response-body' | 'wait' | 'set-download-path' | 'wait-download';
 export interface IPCRequest {
     action: IPCAction;
     task?: string;
@@ -82,6 +86,10 @@ export interface IPCRequest {
     ref?: number;
     text?: string;
     key?: string;
+    scrollX?: number;
+    scrollY?: number;
+    scrollAtX?: number;
+    scrollAtY?: number;
     interactive?: boolean;
     limit?: number;
     width?: number;
@@ -111,6 +119,8 @@ export interface IPCResponse {
     result?: unknown;
     path?: string;
     refs?: string;
+    port?: number;
+    pid?: number;
     logs?: ConsoleEntry[];
     errors?: ErrorEntry[];
     requests?: NetworkRequest[];

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

@@ -5,6 +5,8 @@
  * Requires the Rush GitHub App installed on the target repo.
  */
 import type { CloudProvider, CloudTask, CloudTaskStatus, CloudEvent, DispatchOptions, ProviderCapabilities } from './types.js';
+export declare const RUSH_CONSENT_PATH: string;
+export declare function hasRushUploadConsent(opts?: DispatchOptions): boolean;
 /** One version's entry in the account manifest sent on every dispatch. */
 export interface AccountManifestEntry {
     version: string;
@@ -35,7 +37,7 @@ export interface AccountTokenEntry {
  * Returns null when no Claude versions are signed in (the dispatch falls back
  * to the platform-wide key, current behavior).
  */
-export declare function buildAccountManifest(): Promise<AccountManifest | null>;
+export declare function buildAccountManifest(strategy?: string): Promise<AccountManifest | null>;
 /**
  * Re-load OAuth blobs for the given versions so they can be uploaded to the
  * server on a retry. Only the versions named in the manifest are loaded — we
@@ -52,6 +54,7 @@ export declare function buildDispatchBody(input: {
     agent?: string;
     prompt: string;
     mode?: string;
+    strategy?: string;
     resolvedRepos: Array<{
         installation_id: number;
         repo_owner: string;
@@ -60,6 +63,30 @@ export declare function buildDispatchBody(input: {
     accountManifest?: AccountManifest | null;
     accountTokens?: AccountTokenEntry[] | null;
 }): Record<string, unknown>;
+/** A single account registered in Rush Cloud's multi-account rotation pool. */
+export interface RemoteAccount {
+    id: string;
+    provider: string;
+    email: string | null;
+    subscription_type: string | null;
+    five_hour_pct: number | null;
+    seven_day_pct: number | null;
+    usage_fetched_at: string | null;
+    created_at: string;
+}
+/** Fetch all Claude accounts in this user's Rush Cloud rotation pool (no tokens). */
+export declare function listRemoteAccounts(): Promise<RemoteAccount[]>;
+/**
+ * Register a CLAUDE_CODE_OAUTH_TOKEN with Rush Cloud's rotation pool.
+ * The server validates the token against the Anthropic usage API and stores it
+ * encrypted in Vault. Returns the account metadata (no token).
+ */
+export declare function addRemoteAccount(provider: string, pastedToken: string): Promise<RemoteAccount & {
+    five_hour_pct: number | null;
+    seven_day_pct: number | null;
+}>;
+/** Remove a Claude account from Rush Cloud's rotation pool by its ID. */
+export declare function removeRemoteAccount(id: string): Promise<void>;
 export declare class RushCloudProvider implements CloudProvider {
     id: "rush";
     name: string;