@phnx-labs/agents-cli 1.22.119 → 1.22.121

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

@@ -1,26 +1,4 @@
-/**
- * Antigravity cloud provider — Google's Antigravity agent via the Gemini
- * **Managed Agents Interactions API**.
- *
- * The `agy` CLI is local-only (`--print` / `--sandbox`); Antigravity's cloud
- * surface is an HTTP endpoint that runs the Antigravity harness in a remote
- * ephemeral Linux sandbox:
- *
- *   POST https://generativelanguage.googleapis.com/v1beta/interactions
- *   x-goog-api-key: <GEMINI_API_KEY>
- *   { "agent": "antigravity-preview-05-2026", "input": "<prompt>", "environment": "remote" }
- *
- * The call is synchronous by default (the response carries `status` +
- * `output_text`), so `dispatch()` awaits it, returns a terminal CloudTask, and
- * `stream()` replays the buffered text + done events — same shape as the Factory
- * provider. It is a raw sandbox: no GitHub repo → PR (that's Rush's job).
- *
- * Auth: the Gemini API key comes from an `agents secrets` bundle named in
- * `cloud.providers.antigravity.secretsBundle` (never from agents.yaml), falling
- * back to GEMINI_API_KEY / GOOGLE_API_KEY in the environment.
- */
 import type { CloudProvider, CloudTask, CloudTaskStatus, CloudEvent, DispatchOptions, ProviderCapabilities } from './types.js';
-/** Shape of the Interactions API response we consume (defensive: all optional). */
 interface InteractionResponse {
     id?: string;
     interaction_id?: string;
@@ -31,9 +9,7 @@ interface InteractionResponse {
         message?: string;
     } | string;
 }
-/** Build the Interactions API request body for a fresh dispatch. */
 export declare function buildInteractionBody(prompt: string, model: string): Record<string, unknown>;
-/** Parse an Interactions API response into a CloudTask (minus prompt/timestamps). */
 export declare function parseInteraction(resp: InteractionResponse): {
     id: string;
     status: CloudTaskStatus;
@@ -50,12 +26,7 @@ export declare class AntigravityCloudProvider implements CloudProvider {
         secretsBundle?: string;
         model?: string;
     });
-    /**
-     * True when a key *source* is configured. Cheap: never resolves the bundle
-     * (which could prompt for biometry) — that happens lazily at dispatch.
-     */
     private hasKeySource;
-    /** Resolve the Gemini API key from the configured bundle or the environment. */
     private resolveApiKey;
     capabilities(): ProviderCapabilities;
     dispatch(options: DispatchOptions): Promise<CloudTask>;

package/dist/lib/cloud/antigravity.js

@@ -1,30 +1,8 @@
-/**
- * Antigravity cloud provider — Google's Antigravity agent via the Gemini
- * **Managed Agents Interactions API**.
- *
- * The `agy` CLI is local-only (`--print` / `--sandbox`); Antigravity's cloud
- * surface is an HTTP endpoint that runs the Antigravity harness in a remote
- * ephemeral Linux sandbox:
- *
- *   POST https://generativelanguage.googleapis.com/v1beta/interactions
- *   x-goog-api-key: <GEMINI_API_KEY>
- *   { "agent": "antigravity-preview-05-2026", "input": "<prompt>", "environment": "remote" }
- *
- * The call is synchronous by default (the response carries `status` +
- * `output_text`), so `dispatch()` awaits it, returns a terminal CloudTask, and
- * `stream()` replays the buffered text + done events — same shape as the Factory
- * provider. It is a raw sandbox: no GitHub repo → PR (that's Rush's job).
- *
- * Auth: the Gemini API key comes from an `agents secrets` bundle named in
- * `cloud.providers.antigravity.secretsBundle` (never from agents.yaml), falling
- * back to GEMINI_API_KEY / GOOGLE_API_KEY in the environment.
- */
 import { resolveDispatchRepos, normalizeProviderStatus } from './types.js';
 import { readAndResolveBundleEnv } from '../secrets-client.js';
 const INTERACTIONS_URL = 'https://generativelanguage.googleapis.com/v1beta/interactions';
 const DEFAULT_MODEL = 'antigravity-preview-05-2026';
 const KEY_NAMES = ['GEMINI_API_KEY', 'GOOGLE_API_KEY'];
-/** Build the Interactions API request body for a fresh dispatch. */
 export function buildInteractionBody(prompt, model) {
     return {
         agent: model,
@@ -32,7 +10,6 @@ export function buildInteractionBody(prompt, model) {
         environment: 'remote',
     };
 }
-/** Parse an Interactions API response into a CloudTask (minus prompt/timestamps). */
 export function parseInteraction(resp) {
     const id = resp.id ?? resp.interaction_id ?? `antigravity-${Date.now()}`;
     return {
@@ -52,25 +29,14 @@ export class AntigravityCloudProvider {
         this.secretsBundle = config?.secretsBundle;
         this.model = config?.model ?? DEFAULT_MODEL;
     }
-    /**
-     * True when a key *source* is configured. Cheap: never resolves the bundle
-     * (which could prompt for biometry) — that happens lazily at dispatch.
-     */
     hasKeySource() {
         if (this.secretsBundle)
             return true;
         return KEY_NAMES.some((k) => Boolean(process.env[k]));
     }
-    /** Resolve the Gemini API key from the configured bundle or the environment. */
     async resolveApiKey() {
         if (this.secretsBundle) {
             try {
-                // Cloud dispatch resolves the key on its own (no human at a sheet), so the
-                // read is always `agentOnly` (SEC-13: never pop Touch ID on its own). A
-                // locked bundle THROWS the actionable "unlock <name>" message, which the
-                // catch below re-raises verbatim — dispatch genuinely needs the key, so it
-                // fails LOUD with the unlock hint rather than swallowing it into a wrong
-                // path. A `never`/no-ACL or broker-held bundle resolves silently.
                 const { env } = await readAndResolveBundleEnv(this.secretsBundle, { caller: 'cloud:antigravity', agentOnly: true });
                 for (const k of KEY_NAMES) {
                     if (env[k])
@@ -105,8 +71,6 @@ export class AntigravityCloudProvider {
         };
     }
     async dispatch(options) {
-        // The Interactions sandbox has no GitHub repo → PR flow. Reject repos
-        // loudly rather than silently ignoring them (point the user at Rush).
         const repos = resolveDispatchRepos(options);
         if (repos.length > 0) {
             throw new Error(`Antigravity cloud is a raw sandbox with no GitHub repo → PR flow. Got repo(s): ${repos.join(', ')}. ` +

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

@@ -1,10 +1,3 @@
-/**
- * Codex Cloud provider -- wraps the `codex` CLI for cloud dispatch.
- *
- * Delegates to `codex cloud exec/status/list` subcommands, parsing their
- * JSON or text output into the unified CloudTask format. Streaming is
- * emulated via polling since Codex Cloud lacks an SSE endpoint.
- */
 import type { CloudProvider, CloudTask, CloudTaskStatus, CloudEvent, DispatchOptions, ProviderCapabilities } from './types.js';
 export declare class CodexCloudProvider implements CloudProvider {
     id: "codex";
@@ -24,5 +17,4 @@ export declare class CodexCloudProvider implements CloudProvider {
     cancel(_taskId: string): Promise<void>;
     message(_taskId: string, _content: string): Promise<void>;
 }
-/** Extract a task ID from codex CLI output (JSON field, key:value line, or UUID pattern). */
 export declare function extractTaskId(output: string): string | undefined;

package/dist/lib/cloud/codex.js

@@ -1,23 +1,13 @@
-/**
- * Codex Cloud provider -- wraps the `codex` CLI for cloud dispatch.
- *
- * Delegates to `codex cloud exec/status/list` subcommands, parsing their
- * JSON or text output into the unified CloudTask format. Streaming is
- * emulated via polling since Codex Cloud lacks an SSE endpoint.
- */
 import { spawn, execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import { resolveDispatchRepos, normalizeProviderStatus, MissingTargetError } from './types.js';
 import { getShimsDir } from '../state.js';
 const SHIMS_DIR = getShimsDir();
-/** Locate the codex binary, checking agents-cli shims first then PATH. */
 function findCodexBinary() {
-    // Check agents-cli shims first
     const shim = path.join(SHIMS_DIR, 'codex');
     if (fs.existsSync(shim))
         return shim;
-    // Check PATH via which
     try {
         return execFileSync('which', ['codex'], { stdio: 'pipe' }).toString().trim() || null;
     }
@@ -25,11 +15,9 @@ function findCodexBinary() {
         return null;
     }
 }
-/** Check whether the codex CLI is installed and reachable. */
 function codexAvailable() {
     return findCodexBinary() !== null;
 }
-/** Spawn the codex CLI with the given arguments and capture its output. */
 function runCodex(args, env) {
     const bin = findCodexBinary();
     if (!bin)
@@ -48,14 +36,11 @@ function runCodex(args, env) {
         });
     });
 }
-/** Best-effort parse of codex CLI output into task fields (tries JSON, then key:value lines). */
 function parseTaskFromText(text) {
-    // Codex cloud list/status output varies. Try JSON first, then parse text.
     try {
         return JSON.parse(text);
     }
     catch {
-        // Parse text output line by line for key: value patterns
         const result = {};
         for (const line of text.split('\n')) {
             const match = line.match(/^\s*(\w[\w\s]*\w)\s*[:=]\s*(.+)\s*$/);
@@ -74,9 +59,6 @@ export class CodexCloudProvider {
     id = 'codex';
     name = 'Codex Cloud';
     targetKind = 'env';
-    // No listTargets: OpenAI ships no non-interactive "list environments"
-    // command. `codex cloud exec` requires --env and the help points at the
-    // interactive `codex cloud` TUI to browse. So discovery is guidance-only.
     defaultEnv;
     constructor(config) {
         this.defaultEnv = config?.env;
@@ -92,10 +74,6 @@ export class CodexCloudProvider {
             cancel: false,
             message: false,
             multiRepo: false,
-            // `codex cloud exec --env <id> <prompt>` is the only dispatch surface the
-            // codex CLI exposes — it has no flag to attach images or ride-along skills,
-            // and the env bundles its own context at creation time. Both stay false
-            // until the upstream CLI grows an attachment surface.
             skills: false,
             images: false,
         };
@@ -107,12 +85,6 @@ export class CodexCloudProvider {
                 'Browse yours with `codex cloud` (interactive), then re-run with --env <id> ' +
                 'or set a default in ~/.agents/agents.yaml under cloud.providers.codex.env.');
         }
-        // Codex envs bundle their own repo list — the repos a task can touch are
-        // fixed at env-creation time, not per-dispatch. Passing 2+ repos here is
-        // almost always a misconfiguration: either the user meant to dispatch to
-        // Rush (which does support multi-repo), or they need to create/pick a
-        // Codex env that already contains those repos. Fail loudly rather than
-        // silently ignore the extras.
         const repos = resolveDispatchRepos(options);
         if (repos.length > 1) {
             throw new Error(`Codex Cloud does not support multi-repo dispatch. Got ${repos.length} repos (${repos.join(', ')}). ` +
@@ -127,13 +99,6 @@ export class CodexCloudProvider {
         if (code !== 0) {
             throw new Error(`codex cloud exec failed: ${stderr || stdout}`);
         }
-        // The task id is the ONLY handle to the just-created execution — status,
-        // list, and the session-index reconcile all key on it. Codex prints it to
-        // stdout (JSON or a task_/id: line); some builds route it to stderr, so scan
-        // both. A synthetic `codex-<ts>` id was the old fallback here — it can never
-        // match the real execution, so it silently broke every follow-up. If the id
-        // genuinely can't be parsed, fail loudly and point at `agents cloud list`
-        // (which recovers the newest execution) rather than persist a bogus id.
         const taskId = extractTaskId(stdout) ?? extractTaskId(stderr);
         if (!taskId) {
             throw new Error('codex cloud exec did not report a task id — the run may have dispatched, but ' +
@@ -203,7 +168,6 @@ export class CodexCloudProvider {
         }
     }
     async *stream(taskId) {
-        // Codex Cloud doesn't have SSE streaming. Poll status until terminal.
         const terminalStatuses = new Set(['completed', 'failed', 'cancelled']);
         let lastStatus = '';
         while (true) {
@@ -230,27 +194,22 @@ export class CodexCloudProvider {
                 };
                 break;
             }
-            // Poll every 5 seconds
             await new Promise((r) => setTimeout(r, 5000));
         }
     }
     async cancel(_taskId) {
-        // Codex Cloud doesn't expose a cancel command via CLI.
         throw new Error('Cancel is not supported for Codex Cloud tasks via CLI.');
     }
     async message(_taskId, _content) {
         throw new Error('Follow-up messages are not supported for Codex Cloud tasks.');
     }
 }
-/** Extract a task ID from codex CLI output (JSON field, key:value line, or UUID pattern). */
 export function extractTaskId(output) {
-    // Try JSON first
     try {
         const data = JSON.parse(output);
         return data.id || data.task_id;
     }
     catch {
-        // Look for UUID-like patterns or task IDs in the text
         const match = output.match(/(?:task[_\s]?id|id)\s*[:=]\s*["']?([a-zA-Z0-9_-]+)/i)
             || output.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i)
             || output.match(/(task_[a-zA-Z0-9]+)/i);

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

@@ -1,4 +1,3 @@
-/** Cursor Cloud Agents provider backed by the public v1 REST API. */
 import type { CloudEvent, CloudProvider, CloudTask, CloudTaskStatus, DispatchOptions, ProviderCapabilities } from './types.js';
 interface CursorAgent {
     id: string;
@@ -46,13 +45,9 @@ interface CursorCreateBody {
     autoCreatePR?: boolean;
     envVars?: Record<string, string>;
 }
-/** Translate unified dispatch options into Cursor's documented v1 create shape. */
 export declare function buildCursorCreateBody(options: DispatchOptions): CursorCreateBody;
-/** Map one Cursor agent/run pair into the provider-neutral task shape. */
 export declare function parseCursorTask(agent: CursorAgent, run: CursorRun, prompt?: string): CloudTask;
-/** Parse one complete SSE frame into a shared cloud event. */
 export declare function parseCursorSseFrame(frame: string): CloudEvent | undefined;
-/** Turn Cursor's structured API errors into actionable provider errors. */
 export declare function cursorApiError(action: string, status: number, text: string): Error;
 export declare class CursorCloudProvider implements CloudProvider {
     id: "cursor";

package/dist/lib/cloud/cursor.js

@@ -1,9 +1,7 @@
-/** Cursor Cloud Agents provider backed by the public v1 REST API. */
 import { normalizeProviderStatus, resolveDispatchRepos } from './types.js';
 import { readAndResolveBundleEnv } from '../secrets-client.js';
 const CURSOR_API_BASE_URL = 'https://api.cursor.com/v1';
 const KEY_NAME = 'CURSOR_API_KEY';
-/** Translate unified dispatch options into Cursor's documented v1 create shape. */
 export function buildCursorCreateBody(options) {
     const repos = resolveDispatchRepos(options);
     const body = { prompt: { text: options.prompt } };
@@ -20,7 +18,6 @@ export function buildCursorCreateBody(options) {
         body.envVars = options.env;
     return body;
 }
-/** Map one Cursor agent/run pair into the provider-neutral task shape. */
 export function parseCursorTask(agent, run, prompt = '') {
     const branch = run.git?.branches?.[0];
     return {
@@ -38,7 +35,6 @@ export function parseCursorTask(agent, run, prompt = '') {
         summary: run.result,
     };
 }
-/** Parse one complete SSE frame into a shared cloud event. */
 export function parseCursorSseFrame(frame) {
     let eventName = 'message';
     const data = [];
@@ -55,7 +51,7 @@ export function parseCursorSseFrame(frame) {
     try {
         value = JSON.parse(raw);
     }
-    catch { /* Cursor may send plain text. */ }
+    catch { }
     const obj = typeof value === 'object' && value !== null ? value : {};
     const timestamp = typeof obj.timestamp === 'string' ? obj.timestamp : undefined;
     if (eventName === 'status') {
@@ -83,13 +79,12 @@ export function parseCursorSseFrame(frame) {
     }
     return { type: 'unknown', name: eventName, data: raw, timestamp };
 }
-/** Turn Cursor's structured API errors into actionable provider errors. */
 export function cursorApiError(action, status, text) {
     let parsed = {};
     try {
         parsed = JSON.parse(text);
     }
-    catch { /* preserve raw body */ }
+    catch { }
     const detail = typeof parsed.error === 'object' ? parsed.error : undefined;
     const code = detail?.code;
     const message = detail?.message ?? (typeof parsed.error === 'string' ? parsed.error : text.slice(0, 500));

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

@@ -1,8 +1,4 @@
 import type { CloudProvider, DispatchOptions } from './types.js';
-/**
- * Resolve the prompt for a cloud dispatch: the raw value, or the contents of
- * the file it points at (with a dim note on TTY). Dies when empty.
- */
 export declare function resolveCloudPrompt(raw: string | undefined, opts: {
     json: boolean;
     hint: string;
@@ -10,19 +6,10 @@ export declare function resolveCloudPrompt(raw: string | undefined, opts: {
 interface ExecuteCloudDispatchParams {
     provider: CloudProvider;
     dispatchOptions: DispatchOptions;
-    /** Image file paths for vision dispatch (checked against provider capability). */
     imagePaths?: string[];
-    /** Raw skill refs (`id` or `id@version`) for ride-along skills. */
     skillIds?: string[];
-    /** Stream the task output after dispatch; false = fire-and-forget. */
     follow: boolean;
     json: boolean;
 }
-/**
- * Dispatch a cloud task and (unless follow=false) stream it to completion.
- * Owns: share-env injection, capability checks, the dispatch spinner +
- * missing-target picker, local persistence, event emission, and the budget
- * kill-switch. Dies on any dispatch failure — callers never see a partial.
- */
 export declare function executeCloudDispatch(params: ExecuteCloudDispatchParams): Promise<void>;
 export {};

package/dist/lib/cloud/dispatch.js

@@ -1,12 +1,3 @@
-/**
- * Shared cloud dispatch core — the ONE path every cloud dispatch goes through.
- *
- * Both `agents cloud run` (commands/cloud.ts) and `agents run <agent> --cloud`
- * (commands/run-cloud.ts) build a DispatchOptions + resolve a provider, then
- * call executeCloudDispatch here. Behavior — capability checks, the missing-
- * target picker, local persistence, event emission, streaming, and the live
- * budget kill-switch — must not diverge between the two surfaces.
- */
 import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -17,7 +8,6 @@ import { renderStream } from './stream.js';
 import { MissingTargetError, MAX_IMAGES_PER_DISPATCH } from './types.js';
 import { emit } from '../feed/events.js';
 import { shareRuntimeEnv } from '../share-runtime.js';
-/** Map a supported image file extension to its wire mimeType. Rejects anything else. */
 function imageMimeFromPath(file) {
     const ext = path.extname(file).toLowerCase();
     if (ext === '.png')
@@ -28,7 +18,6 @@ function imageMimeFromPath(file) {
         return 'image/webp';
     die(`Unsupported image type ${JSON.stringify(ext || file)}. Use .png, .jpg/.jpeg, or .webp.`);
 }
-/** Read one image file into a base64 ImageAttachment, dying with a clear error if it's missing. */
 function readImageAttachment(file) {
     if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
         die(`Image not found: ${file}`);
@@ -36,7 +25,6 @@ function readImageAttachment(file) {
     const mimeType = imageMimeFromPath(file);
     return { data: fs.readFileSync(file).toString('base64'), mimeType };
 }
-/** Parse a `--skill <id>` value (`id` or `id@version`) into a SkillRef. */
 function parseSkillRef(raw) {
     const at = raw.lastIndexOf('@');
     if (at > 0) {
@@ -44,15 +32,10 @@ function parseSkillRef(raw) {
     }
     return { id: raw };
 }
-/**
- * Resolve the prompt for a cloud dispatch: the raw value, or the contents of
- * the file it points at (with a dim note on TTY). Dies when empty.
- */
 export function resolveCloudPrompt(raw, opts) {
     let prompt = raw;
     if (!prompt)
         die('Prompt is required. Pass it as an argument or with --prompt.', 1, { json: opts.json, hint: opts.hint });
-    // If prompt is a file path, read it and tell the user
     if (fs.existsSync(prompt) && fs.statSync(prompt).isFile()) {
         const filePath = prompt;
         const stat = fs.statSync(filePath);
@@ -64,17 +47,6 @@ export function resolveCloudPrompt(raw, opts) {
     }
     return prompt;
 }
-/**
- * After a `MissingTargetError`, try to resolve the target interactively.
- * Returns the chosen id, or undefined when no interactive resolution is
- * possible (non-TTY/JSON, provider can't enumerate, or user cancels) — the
- * caller then prints the error's guidance.
- *
- * Codex has no `listTargets` (no list-environments CLI), so it always returns
- * undefined here and the user sees the `codex cloud` guidance. Factory lists
- * Droid Computers; if listing fails (not signed in) or parses to nothing, we
- * fall back to a free-text prompt so a dispatch is never hard-blocked.
- */
 async function pickMissingTarget(provider, err, json) {
     if (json || !process.stdout.isTTY)
         return undefined;
@@ -101,16 +73,9 @@ async function pickMissingTarget(provider, err, json) {
         return typed || undefined;
     }
     catch {
-        // User hit Ctrl-C / Esc on the prompt.
         return undefined;
     }
 }
-/**
- * Dispatch a cloud task and (unless follow=false) stream it to completion.
- * Owns: share-env injection, capability checks, the dispatch spinner +
- * missing-target picker, local persistence, event emission, and the budget
- * kill-switch. Dies on any dispatch failure — callers never see a partial.
- */
 export async function executeCloudDispatch(params) {
     const { provider, dispatchOptions, follow, json } = params;
     const imagePaths = params.imagePaths ?? [];
@@ -118,9 +83,6 @@ export async function executeCloudDispatch(params) {
     const shareEnv = shareRuntimeEnv();
     if (shareEnv)
         dispatchOptions.env = shareEnv;
-    // Vision attachments + ride-along skills. Only wire them when the resolved
-    // provider advertises support — otherwise fail loud rather than silently
-    // drop the flags the user passed.
     const caps = provider.capabilities();
     if (imagePaths.length > 0) {
         if (!caps.images)
@@ -135,8 +97,6 @@ export async function executeCloudDispatch(params) {
             die(`${provider.name} does not support ride-along skills.`, 1, { json });
         dispatchOptions.skills = skillIds.map(parseSkillRef);
     }
-    // Dispatch. On a missing pre-provisioned target (Codex env / Factory
-    // computer), offer an interactive picker instead of a raw error.
     const dispatchOnce = async () => {
         const spinner = ora({ text: `Dispatching to ${provider.name}...`, stream: process.stderr }).start();
         try {
@@ -171,20 +131,14 @@ export async function executeCloudDispatch(params) {
             die(err.message, 1, { json });
         }
     }
-    // Persist locally
     insertTask(task);
     emit('cloud.dispatch', { module: 'cloud', taskId: task.id, agent: task.agent, provider: task.provider, status: task.status });
     if (json) {
         process.stdout.write(JSON.stringify(task) + '\n');
     }
-    // Stream output unless --no-follow
     if (!follow)
         return;
     try {
-        // Live budget kill-switch (issue #399). Reuses makeLiveSpendWatcher to
-        // feed the provider's `usage` events into a shared watcher; on a cap
-        // breach we call provider.cancel(task.id) mid-stream. Dormant (returns
-        // null) when no caps are configured, so the raw stream flows unchanged.
         const { wrapStreamWithBudgetGate } = await import('../budget/live-cloud.js');
         const gated = wrapStreamWithBudgetGate({
             provider,
@@ -203,11 +157,10 @@ export async function executeCloudDispatch(params) {
         if (gated?.gate.breached()) {
             const b = gated.gate.breach();
             process.stderr.write(`[budget] cap ${b?.cap} exceeded — cancelled cloud task ${task.id}\n`);
-            process.exitCode = 7; // Mirrors BUDGET_KILL_EXIT_CODE for CI/headless.
+            process.exitCode = 7;
         }
     }
     catch (err) {
-        // Stream disconnect is OK — task keeps running
         process.stderr.write(chalk.dim(`\nStream disconnected. Task ${task.id} continues running.\n`));
         process.stderr.write(chalk.dim(`Check status: agents cloud status ${task.id}\n`));
     }

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

@@ -1,69 +1,20 @@
-/**
- * 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 type { CloudProvider, CloudTask, CloudTaskStatus, CloudEvent, CloudTarget, DispatchOptions, ProviderCapabilities, DroidAutonomy } from './types.js';
-/** Normalize an autonomy value, falling back to the safe cloud default (`high`). */
 export declare function resolveAutonomy(value: unknown, fallback?: DroidAutonomy): DroidAutonomy;
-/**
- * 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 declare function parseComputerList(text: string): CloudTarget[];
-/**
- * Build the remote `droid exec` argv. Headless, stream-json output, given
- * autonomy. `sessionId` (when resuming) maps to `-s`.
- */
 export declare function buildExecArgs(prompt: string, opts: {
     autonomy: DroidAutonomy;
     sessionId?: string;
 }): string[];
-/**
- * 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 declare function buildSshArgs(computer: string, remoteBin: string, remoteArgv: string[], opts: {
     droidBin: string;
     user: string;
     port?: string;
     env?: Record<string, string>;
 }): string[];
-/** Map a droid stream-json `result.subtype` / `is_error` to a CloudTaskStatus. */
 export declare function mapResultStatus(line: {
     is_error?: boolean;
     subtype?: string;
 }): CloudTaskStatus;
-/**
- * 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 declare function mapDroidEvent(obj: Record<string, unknown>): CloudEvent;
 export declare class FactoryCloudProvider implements CloudProvider {
     id: "factory";
@@ -71,17 +22,14 @@ export declare class FactoryCloudProvider implements CloudProvider {
     targetKind: "computer";
     private defaultComputer?;
     private defaultAutonomy;
-    /** session_id → buffered run, populated by dispatch, drained by stream. */
     private runs;
     constructor(config?: {
         computer?: string;
         autonomy?: DroidAutonomy;
     });
     capabilities(): ProviderCapabilities;
-    /** Enumerate Droid Computers via `droid computer list`. Throws if not signed in. */
     listTargets(): Promise<CloudTarget[]>;
     dispatch(options: DispatchOptions): Promise<CloudTask>;
-    /** Run the remote droid exec to completion, collecting events + final result. */
     private runRemote;
     status(taskId: string): Promise<CloudTask>;
     list(): Promise<CloudTask[]>;