@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/cloud/factory.js

@@ -1,24 +1,3 @@
-/**
- * Factory (Droid) cloud provider.
- *
- * Dispatches to a Factory **Droid Computer** — a persistent cloud VM (managed
- * by Factory, or bring-your-own via `droid computer register`). There is no
- * `droid cloud run`; remote execution = reach the computer over the Droid relay
- * (`droid computer ssh <name>`) and run a headless `droid exec` there.
- *
- * `droid exec` is synchronous (it runs to completion and exits, unlike Codex
- * Cloud which is async server-side). So `dispatch()` runs the remote exec to
- * completion with `--output-format stream-json`, buffers the NDJSON events, and
- * `stream()` replays them. The task id is droid's own `session_id` (captured
- * from the run output), so it lines up with `droid exec -s <id>` for future
- * resume support.
- *
- * Transport note: the exact relay SSH composition (user + ProxyCommand) is
- * built in `buildSshArgs()` and must be confirmed against a live provisioned
- * Droid Computer (Factory auth required). `capabilities().available` gates on
- * the droid binary + a configured computer so the provider fails with a clear
- * message rather than misfiring when unconfigured.
- */
 import { spawn, execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -28,7 +7,6 @@ import { getShimsDir } from '../state.js';
 const SHIMS_DIR = getShimsDir();
 const DEFAULT_AUTONOMY = 'high';
 const VALID_AUTONOMY = new Set(['low', 'medium', 'high']);
-/** Locate the droid binary, checking agents-cli shims first then PATH. */
 function findDroidBinary() {
     const shim = path.join(SHIMS_DIR, 'droid');
     if (fs.existsSync(shim))
@@ -40,13 +18,11 @@ function findDroidBinary() {
         return null;
     }
 }
-/** Normalize an autonomy value, falling back to the safe cloud default (`high`). */
 export function resolveAutonomy(value, fallback = DEFAULT_AUTONOMY) {
     return typeof value === 'string' && VALID_AUTONOMY.has(value)
         ? value
         : fallback;
 }
-/** Run the droid CLI and capture output (used for `computer list`). */
 function runDroid(bin, args) {
     return new Promise((resolve) => {
         const proc = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'] });
@@ -58,13 +34,6 @@ function runDroid(bin, args) {
         proc.on('close', (code) => resolve({ stdout, stderr, code: code ?? 1 }));
     });
 }
-/**
- * Parse `droid computer list` text into targets. Defensive: the exact column
- * layout isn't documented, so we take the first whitespace token of each data
- * row as the computer name and keep the remainder as a label, skipping headers,
- * separators, and status messages. The interactive picker degrades to free-text
- * entry if this yields nothing, so an unexpected layout never blocks a dispatch.
- */
 export function parseComputerList(text) {
     const out = [];
     for (const raw of text.split('\n')) {
@@ -72,11 +41,11 @@ export function parseComputerList(text) {
         if (!line)
             continue;
         if (/^(name|computer|status|id)\b/i.test(line))
-            continue; // header row
+            continue;
         if (/^[-=_\s|]+$/.test(line))
-            continue; // separator rule
+            continue;
         if (/^(no |failed|error|warning)\b/i.test(line))
-            continue; // status message
+            continue;
         const name = line.split(/\s+/)[0];
         if (!name)
             continue;
@@ -85,10 +54,6 @@ export function parseComputerList(text) {
     }
     return out;
 }
-/**
- * Build the remote `droid exec` argv. Headless, stream-json output, given
- * autonomy. `sessionId` (when resuming) maps to `-s`.
- */
 export function buildExecArgs(prompt, opts) {
     const args = ['exec', '--auto', opts.autonomy, '--output-format', 'stream-json'];
     if (opts.sessionId)
@@ -96,15 +61,6 @@ export function buildExecArgs(prompt, opts) {
     args.push(prompt);
     return args;
 }
-/**
- * Build the `ssh` argv that runs a remote command on a Droid Computer through
- * the Droid relay. The relay is used as an OpenSSH ProxyCommand
- * (`droid computer ssh <name> --proxy`), so the connection rides Factory's
- * brokered tunnel rather than a directly reachable host.
- *
- * `remoteArgv` is the already-built remote command (e.g. droid exec argv); it is
- * shell-quoted into a single remote command string.
- */
 export function buildSshArgs(computer, remoteBin, remoteArgv, opts) {
     const envPrefix = Object.entries(opts.env ?? {}).map(([key, value]) => {
         if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
@@ -121,11 +77,9 @@ export function buildSshArgs(computer, remoteBin, remoteArgv, opts) {
         remoteCmd,
     ];
 }
-/** POSIX single-quote a shell argument. */
 function shellQuote(arg) {
     return `'${arg.replace(/'/g, `'\\''`)}'`;
 }
-/** Map a droid stream-json `result.subtype` / `is_error` to a CloudTaskStatus. */
 export function mapResultStatus(line) {
     if (line.is_error)
         return 'failed';
@@ -133,12 +87,6 @@ export function mapResultStatus(line) {
         return 'cancelled';
     return 'completed';
 }
-/**
- * Map one parsed droid stream-json event to a CloudEvent. The stream-json
- * schema is only partially documented, so this is defensive: known shapes map
- * to typed events, everything else surfaces as `unknown` rather than being
- * dropped (mirrors the rest of the cloud event pipeline).
- */
 export function mapDroidEvent(obj) {
     const ts = new Date().toISOString();
     const type = String(obj.type ?? '');
@@ -179,7 +127,6 @@ export function mapDroidEvent(obj) {
     }
     return { type: 'unknown', name: type || 'unknown', data: JSON.stringify(obj), timestamp: ts };
 }
-/** Pull a text string out of the varied droid message shapes. */
 function extractText(obj) {
     if (typeof obj.text === 'string')
         return obj.text;
@@ -201,7 +148,6 @@ export class FactoryCloudProvider {
     targetKind = 'computer';
     defaultComputer;
     defaultAutonomy;
-    /** session_id → buffered run, populated by dispatch, drained by stream. */
     runs = new Map();
     constructor(config) {
         this.defaultComputer = config?.computer;
@@ -211,8 +157,6 @@ export class FactoryCloudProvider {
         const droid = findDroidBinary() !== null;
         const computer = Boolean(this.defaultComputer);
         return {
-            // Reachable only when the droid binary exists AND a computer is set.
-            // (A per-dispatch --computer can still override the missing default.)
             available: droid && computer,
             dispatch: droid,
             status: droid,
@@ -225,7 +169,6 @@ export class FactoryCloudProvider {
             images: false,
         };
     }
-    /** Enumerate Droid Computers via `droid computer list`. Throws if not signed in. */
     async listTargets() {
         const droidBin = findDroidBinary();
         if (!droidBin) {
@@ -233,8 +176,6 @@ export class FactoryCloudProvider {
         }
         const { stdout, stderr, code } = await runDroid(droidBin, ['computer', 'list']);
         if (code !== 0) {
-            // Surface droid's own message verbatim — e.g. "No authenticated user with
-            // organization available" when the user hasn't logged in.
             throw new Error((stderr.trim() || stdout.trim() || `droid computer list exited ${code}`));
         }
         return parseComputerList(stdout);
@@ -270,7 +211,6 @@ export class FactoryCloudProvider {
         this.runs.set(id, { events, task });
         return task;
     }
-    /** Run the remote droid exec to completion, collecting events + final result. */
     runRemote(sshArgs) {
         return new Promise((resolve, reject) => {
             const proc = spawn('ssh', sshArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
@@ -289,7 +229,6 @@ export class FactoryCloudProvider {
                     obj = JSON.parse(trimmed);
                 }
                 catch {
-                    // Non-JSON line (banner, ssh notice) — surface it, don't drop it.
                     events.push({ type: 'unknown', name: 'stdout', data: trimmed, timestamp: new Date().toISOString() });
                     return;
                 }
@@ -315,7 +254,6 @@ export class FactoryCloudProvider {
                 if (stdoutBuf)
                     handleLine(stdoutBuf);
                 if (code !== 0 && events.every((e) => e.type !== 'done')) {
-                    // Surface the auth error verbatim — it's the common first-run failure.
                     const detail = stderr.trim() || `ssh exited ${code}`;
                     reject(new Error(`Factory dispatch failed: ${detail}`));
                     return;
@@ -328,11 +266,9 @@ export class FactoryCloudProvider {
         const run = this.runs.get(taskId);
         if (run)
             return run.task;
-        // No remote task registry — the command layer falls back to the local store.
         throw new Error(`No live status for Factory task ${taskId} (synchronous run; see local cache).`);
     }
     async list() {
-        // Factory has no remote task list; `agents cloud list` reads the local store.
         return [...this.runs.values()].map((r) => r.task);
     }
     async *stream(taskId) {

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

@@ -1,35 +1,10 @@
-/**
- * Host cloud provider — your own machines as a task-execution backend.
- *
- * A thin adapter over the hosts subsystem (lib/hosts/*): `agents cloud run
- * --provider host --device <name>` dispatches through the SAME detached-SSH
- * launch as `agents run --device`, and the resulting task shows up in BOTH
- * `agents cloud ps` and `agents devices ps` — one store (the host-task sidecars
- * under ~/.agents/.cache/hosts/), two views. No new transport, no relay: SSH
- * is the only wire, exactly like the rest of the host design (docs/fleet.md).
- *
- * Status semantics follow reconcile.ts's prime rule: completion is only ever
- * CONFIRMED from the remote `.exit` file — an unreachable host leaves a task
- * `running`, never guessed as failed. The cloud SQLite store row is a cached
- * index (the `cloud list` refresh loop upserts what `status()` returns); the
- * sidecar stays the source of truth. Reachability is memoized per target for
- * the life of the process so a down host costs ONE short timeout, not one per
- * task ("care around the cloud status-refresh path", lib/hosts/tasks.ts).
- */
 import type { CloudEvent, CloudProvider, CloudTarget, CloudTask, CloudTaskStatus, DispatchOptions, ProviderCapabilities } from './types.js';
 import type { HostTask } from '../hosts/tasks.js';
-/** Project a host-task sidecar into the cloud task shape. */
 export declare function hostTaskToCloudTask(task: HostTask): CloudTask;
 export declare class HostCloudProvider implements CloudProvider {
     readonly id: "host";
     readonly name = "Host (your machines)";
     readonly targetKind: "host";
-    /**
-     * Reachability memo, per target, for the life of this process. The cloud
-     * refresh loop calls `status()` once per active task; without the memo a
-     * down host would cost one ~6s ssh timeout PER task instead of one total.
-     * CLI processes are short-lived, so staleness is bounded by the invocation.
-     */
     private reachable;
     capabilities(): ProviderCapabilities;
     dispatch(options: DispatchOptions): Promise<CloudTask>;
@@ -37,23 +12,9 @@ export declare class HostCloudProvider implements CloudProvider {
     list(filter?: {
         status?: CloudTaskStatus;
     }): Promise<CloudTask[]>;
-    /**
-     * `reconcileTask` with the per-process reachability memo folded in: probe a
-     * target at most once per process; a down host leaves its tasks `running`.
-     */
     private reconcileMemoized;
-    /**
-     * Offset-tail the remote log (the same one-round-trip fetch the `run --device`
-     * follow uses) and yield it as `text` events until the `.exit` file lands.
-     */
     stream(taskId: string): AsyncIterable<CloudEvent>;
     cancel(taskId: string): Promise<void>;
-    /**
-     * Follow-up message = resume the run's session on the same host. Only runs
-     * that captured a session id (Claude — the one agent that takes
-     * `--session-id`) can be resumed; others get an actionable refusal.
-     */
     message(taskId: string, content: string): Promise<void>;
-    /** The unified host pool (enrolled hosts ∪ devices), dispatchable ones only. */
     listTargets(): Promise<CloudTarget[]>;
 }

package/dist/lib/cloud/host.js

@@ -1,21 +1,3 @@
-/**
- * Host cloud provider — your own machines as a task-execution backend.
- *
- * A thin adapter over the hosts subsystem (lib/hosts/*): `agents cloud run
- * --provider host --device <name>` dispatches through the SAME detached-SSH
- * launch as `agents run --device`, and the resulting task shows up in BOTH
- * `agents cloud ps` and `agents devices ps` — one store (the host-task sidecars
- * under ~/.agents/.cache/hosts/), two views. No new transport, no relay: SSH
- * is the only wire, exactly like the rest of the host design (docs/fleet.md).
- *
- * Status semantics follow reconcile.ts's prime rule: completion is only ever
- * CONFIRMED from the remote `.exit` file — an unreachable host leaves a task
- * `running`, never guessed as failed. The cloud SQLite store row is a cached
- * index (the `cloud list` refresh loop upserts what `status()` returns); the
- * sidecar stays the source of truth. Reachability is memoized per target for
- * the life of the process so a down host costs ONE short timeout, not one per
- * task ("care around the cloud status-refresh path", lib/hosts/tasks.ts).
- */
 import { MissingTargetError, resolveDispatchRepos } from './types.js';
 import { listTasks, loadTask, terminalPatch, updateTask } from '../hosts/tasks.js';
 import { readRemoteExit } from '../hosts/reconcile.js';
@@ -24,8 +6,6 @@ import { fetchProgress } from '../hosts/progress.js';
 import { dispatchPromptToHost, resolveHostRunTarget } from '../hosts/run-target.js';
 import { listAllHosts } from '../hosts/registry.js';
 import { terminateDispatchedTask } from '../hosts/dispatch.js';
-/** Host-task lifecycle → canonical cloud enum. `unknown` stays `running`
- *  (completion is confirmed, never guessed — reconcile.ts's rule). */
 function toCloudStatus(status) {
     switch (status) {
         case 'completed': return 'completed';
@@ -36,7 +16,6 @@ function toCloudStatus(status) {
             return 'running';
     }
 }
-/** Project a host-task sidecar into the cloud task shape. */
 export function hostTaskToCloudTask(task) {
     return {
         id: task.id,
@@ -53,22 +32,16 @@ export class HostCloudProvider {
     id = 'host';
     name = 'Host (your machines)';
     targetKind = 'host';
-    /**
-     * Reachability memo, per target, for the life of this process. The cloud
-     * refresh loop calls `status()` once per active task; without the memo a
-     * down host would cost one ~6s ssh timeout PER task instead of one total.
-     * CLI processes are short-lived, so staleness is bounded by the invocation.
-     */
     reachable = new Map();
     capabilities() {
         return {
-            available: true, // ssh is the only dependency; per-host reachability is probed at dispatch
+            available: true,
             dispatch: true,
             status: true,
             list: true,
             stream: true,
             cancel: true,
-            message: true, // gated per task: needs the sessionId only Claude runs carry
+            message: true,
             multiRepo: false,
             skills: false,
             images: false,
@@ -86,8 +59,6 @@ export class HostCloudProvider {
         if (options.branch) {
             throw new Error('--branch has no meaning for --provider host (no clone step). Check out the branch on the host, or use --remote-cwd.');
         }
-        // DeviceOffloadUnsupportedError / HostResolutionError propagate — both carry
-        // actionable messages the CLI prints verbatim.
         const host = await resolveHostRunTarget(hostName, {
             any: options.providerOptions?.any === true,
         });
@@ -99,7 +70,7 @@ export class HostCloudProvider {
             timeout: options.timeout,
             remoteCwd: options.providerOptions?.remoteCwd,
             name: options.providerOptions?.name,
-            follow: false, // the cloud pipeline streams via stream(); never block dispatch
+            follow: false,
         });
         return hostTaskToCloudTask(task);
     }
@@ -113,10 +84,6 @@ export class HostCloudProvider {
         const tasks = listTasks().map((t) => hostTaskToCloudTask(this.reconcileMemoized(t)));
         return filter?.status ? tasks.filter((t) => t.status === filter.status) : tasks;
     }
-    /**
-     * `reconcileTask` with the per-process reachability memo folded in: probe a
-     * target at most once per process; a down host leaves its tasks `running`.
-     */
     reconcileMemoized(task) {
         if (task.status !== 'running')
             return task;
@@ -130,10 +97,6 @@ export class HostCloudProvider {
             return task;
         return updateTask(task.id, terminalPatch(st.code)) ?? task;
     }
-    /**
-     * Offset-tail the remote log (the same one-round-trip fetch the `run --device`
-     * follow uses) and yield it as `text` events until the `.exit` file lands.
-     */
     async *stream(taskId) {
         const task = loadTask(taskId);
         if (!task)
@@ -158,11 +121,11 @@ export class HostCloudProvider {
             if (fetched) {
                 if (fetched.logChunk.length > 0) {
                     offset += fetched.logChunk.length;
-                    pollMs = fastPollMs; // output is flowing — snap back to the fast poll
+                    pollMs = fastPollMs;
                     yield { type: 'text', content: fetched.logChunk.toString('utf8') };
                 }
                 else {
-                    pollMs = Math.min(Math.round(pollMs * 1.5), maxPollMs); // idle backoff
+                    pollMs = Math.min(Math.round(pollMs * 1.5), maxPollMs);
                 }
                 const exit = fetched.exit.trim();
                 if (exit !== '') {
@@ -182,11 +145,6 @@ export class HostCloudProvider {
             throw new Error(`Unknown host task: ${taskId}`);
         terminateDispatchedTask(task);
     }
-    /**
-     * Follow-up message = resume the run's session on the same host. Only runs
-     * that captured a session id (Claude — the one agent that takes
-     * `--session-id`) can be resumed; others get an actionable refusal.
-     */
     async message(taskId, content) {
         const task = loadTask(taskId);
         if (!task)
@@ -204,7 +162,6 @@ export class HostCloudProvider {
             follow: false,
         });
     }
-    /** The unified host pool (enrolled hosts ∪ devices), dispatchable ones only. */
     async listTargets() {
         const hosts = await listAllHosts();
         return hosts

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

@@ -1,31 +1,6 @@
-/**
- * Cloud provider registry.
- *
- * Reads the `cloud` section of agents.yaml, lazily instantiates provider
- * implementations, and exposes lookup helpers used by the `agents cloud` commands.
- */
 import type { CloudProvider, CloudProviderId } from './types.js';
-/**
- * The cloud provider an agent dispatches to by default. Reads the canonical
- * `cloudProvider` field on the agent registry entry — one source of truth, no
- * side map. Returns undefined for agents with no native cloud.
- */
 export declare function nativeProviderForAgent(agentId: string): CloudProviderId | undefined;
-/** Look up a provider by ID, throwing if the ID is unknown. */
 export declare function getProvider(id: CloudProviderId): CloudProvider;
-/** Return the user's configured default provider, falling back to 'rush'. */
 export declare function getDefaultProviderId(): CloudProviderId;
-/** Return every registered provider (used by `agents cloud providers`). */
 export declare function getAllProviders(): CloudProvider[];
-/**
- * Resolve the active provider for a dispatch.
- *
- * Precedence: explicit `--provider` > the agent's native cloud
- * (`cloudProvider`) > configured `cloud.default_provider` > `rush`. This is
- * what makes `agents cloud run --agent droid` land on Factory and
- * `--agent codex` land on Codex Cloud without the user naming a provider.
- *
- * Callers that already hold a concrete provider id (e.g. resolving a stored
- * task's provider) pass it as `explicit` and the agent arg is ignored.
- */
 export declare function resolveProvider(explicit?: string, agentId?: string): CloudProvider;

package/dist/lib/cloud/registry.js

@@ -1,9 +1,3 @@
-/**
- * Cloud provider registry.
- *
- * Reads the `cloud` section of agents.yaml, lazily instantiates provider
- * implementations, and exposes lookup helpers used by the `agents cloud` commands.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
@@ -17,7 +11,6 @@ import { getUserAgentsDir } from '../state.js';
 import { AGENTS } from '../agents.js';
 const META_FILE = path.join(getUserAgentsDir(), 'agents.yaml');
 let _config = null;
-/** Parse the `cloud` section from agents.yaml, caching the result for the process lifetime. */
 function loadCloudConfig() {
     if (_config)
         return _config;
@@ -36,7 +29,6 @@ function loadCloudConfig() {
     return _config;
 }
 const providers = new Map();
-/** Instantiate all provider implementations once, keyed by their ID. */
 function initProviders() {
     if (providers.size > 0)
         return;
@@ -46,20 +38,12 @@ function initProviders() {
     providers.set('factory', new FactoryCloudProvider(config.providers?.factory));
     providers.set('antigravity', new AntigravityCloudProvider(config.providers?.antigravity));
     providers.set('cursor', new CursorCloudProvider(config.providers?.cursor));
-    // Your own machines (agents devices) over SSH. No agent
-    // auto-routes here — it's always an explicit --provider host / --host choice.
     providers.set('host', new HostCloudProvider());
 }
-/**
- * The cloud provider an agent dispatches to by default. Reads the canonical
- * `cloudProvider` field on the agent registry entry — one source of truth, no
- * side map. Returns undefined for agents with no native cloud.
- */
 export function nativeProviderForAgent(agentId) {
     const agent = AGENTS[agentId];
     return agent?.cloudProvider;
 }
-/** Look up a provider by ID, throwing if the ID is unknown. */
 export function getProvider(id) {
     initProviders();
     const provider = providers.get(id);
@@ -68,27 +52,14 @@ export function getProvider(id) {
     }
     return provider;
 }
-/** Return the user's configured default provider, falling back to 'rush'. */
 export function getDefaultProviderId() {
     const config = loadCloudConfig();
     return config.default_provider ?? 'rush';
 }
-/** Return every registered provider (used by `agents cloud providers`). */
 export function getAllProviders() {
     initProviders();
     return [...providers.values()];
 }
-/**
- * Resolve the active provider for a dispatch.
- *
- * Precedence: explicit `--provider` > the agent's native cloud
- * (`cloudProvider`) > configured `cloud.default_provider` > `rush`. This is
- * what makes `agents cloud run --agent droid` land on Factory and
- * `--agent codex` land on Codex Cloud without the user naming a provider.
- *
- * Callers that already hold a concrete provider id (e.g. resolving a stored
- * task's provider) pass it as `explicit` and the agent arg is ignored.
- */
 export function resolveProvider(explicit, agentId) {
     const id = (explicit
         ?? (agentId ? nativeProviderForAgent(agentId) : undefined)

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

@@ -1,51 +1,14 @@
-/**
- * Rush Cloud provider -- dispatches tasks to the Factory Floor via api.prix.dev.
- *
- * Auth: reads the session token from ~/.rush/user.yaml (written by `rush login`).
- * Requires the Rush GitHub App installed on the target repo.
- */
 import type { CloudProvider, CloudTask, CloudTaskStatus, CloudEvent, DispatchOptions, ProviderCapabilities, ImageAttachment, SkillRef } from './types.js';
-/**
- * Returns true when ~/.rush/user.yaml exists, carries an access_token, and
- * the token has not passed its expires_at timestamp (Unix milliseconds). A missing
- * expires_at, or `expires_at: 0` (a non-expiring Phoenix `pid_` bearer), is
- * treated as non-expired (see isRushSessionExpired, PHNX-3645). Pass yamlPath
- * to override the default path in tests.
- */
 export declare function isRushSessionValid(yamlPath?: string): boolean;
-/**
- * Read the Rush session access token from ~/.rush/user.yaml. Exported (with an
- * overridable yamlPath, like isRushSessionValid) so the freshness behavior —
- * including the `expires_at: 0` non-expiring case (PHNX-3645) — is directly
- * testable; the class methods call it with the default path.
- */
 export declare function readToken(yamlPath?: string): string;
-/** One version's entry in the account manifest sent on every dispatch. */
 interface AccountManifestEntry {
     version: string;
     email: string;
 }
-/**
- * Manifest of the user's local Claude accounts (version + account email only).
- * Sent on a non-balanced dispatch so the server knows which accounts exist and
- * can route to one. It carries **no credential material** and does NOT read the
- * native OAuth login (RUSH-2527 / SING-1b): agents-cli never reads a harness's
- * interactive login to build this. When the server asks for the underlying token
- * (a new account, or a rotation it can't otherwise resolve), the client does NOT
- * upload it — there is no consented path to copy a native OAuth login to the
- * cloud. Dispatch fails loud and steers to a portable provider account instead
- * (see the 401 handler in `dispatch()`).
- */
 interface AccountManifest {
     fp: string;
     versions: AccountManifestEntry[];
 }
-/**
- * Build the POST body for /api/v1/cloud-runs. Exported so tests can verify
- * the back-compat shape (singular fields + repos[]) without needing real
- * GitHub installations or a live Rush session. `findInstallation` is the
- * only other I/O and it's tested by the cloud proxy integration suite.
- */
 export declare function buildDispatchBody(input: {
     agent?: string;
     prompt: string;
@@ -57,18 +20,8 @@ export declare function buildDispatchBody(input: {
         repo_name: string;
     }>;
     accountManifest?: AccountManifest | null;
-    /**
-     * Skill ride-alongs so the cloud pod isn't context-blind. Forwarded verbatim
-     * as `skills` so the Factory Floor can mount them by id/version before the
-     * agent runs. Omitted when empty.
-     */
     skills?: SkillRef[] | null;
-    /**
-     * Base64 image attachments for vision dispatch. Sliced to
-     * MAX_IMAGES_PER_DISPATCH — extras are dropped, never sent. Omitted when empty.
-     */
     images?: ImageAttachment[] | null;
-    /** Runtime env vars mounted into the cloud agent process. */
     env?: Record<string, string> | null;
 }): Record<string, unknown>;
 export declare class RushCloudProvider implements CloudProvider {