@phnx-labs/agents-cli 1.22.16 → 1.22.18

package/dist/commands/run-cloud.d.ts

@@ -0,0 +1,26 @@
+import type { Command } from 'commander';
+import type { CloudProvider } from '../lib/cloud/types.js';
+/** Error type for run --cloud validation failures (exit 1, red message). */
+export declare class RunCloudError extends Error {
+    constructor(message: string);
+}
+/** Flags the user passed that cannot ride a cloud placement. */
+export declare function runCloudConflicts(options: Record<string, unknown>): string[];
+/** Cloud-only flags passed without the --cloud placement. */
+export declare function cloudFlagsWithoutCloud(options: Record<string, unknown>): string[];
+/** Agents that route to a native cloud provider (the registry's truth). */
+export declare function cloudCapableAgentIds(): string[];
+/**
+ * Resolve the cloud provider for a run: explicit --provider wins, else the
+ * agent's native cloud. An agent with no native cloud fails loud with the
+ * capable list — never a silent ride onto the configured default.
+ */
+export declare function resolveRunCloudProvider(agentId: string, explicitProvider?: string): CloudProvider;
+/** Validate the agent half of `agents run <agent> --cloud` and return the registry id. */
+export declare function resolveRunCloudAgent(agentSpec: string): string;
+/**
+ * Handle `agents run <agent> [prompt] --cloud`. Validation lives in the
+ * exported helpers above (unit-tested); this wires them to the shared
+ * dispatch core and dies on any validation failure.
+ */
+export declare function handleRunCloud(agentSpec: string, prompt: string | undefined, options: Record<string, unknown>, command: Command): Promise<void>;

package/dist/commands/run-cloud.js

@@ -0,0 +1,162 @@
+/**
+ * `agents run <agent> [prompt] --cloud` — the vendor-cloud placement for a run.
+ *
+ * One of three run placements: local (default), machine (--host/--device,
+ * --lease), cloud (--cloud). Routing goes through the cloud provider registry
+ * exactly like `agents cloud run --agent <agent>`: the agent's native
+ * `cloudProvider` wins, `--provider` overrides. The dispatch itself is the
+ * shared core in lib/cloud/dispatch.ts — this module only validates the run
+ * surface and translates run flags into a DispatchOptions.
+ */
+import chalk from 'chalk';
+import { AGENTS, resolveAgentName, isAgentHardDeprecated, hardDeprecationError } from '../lib/agents.js';
+import { RUN_AUTO_KEYWORD } from '../lib/types.js';
+import { resolveProvider, nativeProviderForAgent } from '../lib/cloud/registry.js';
+import { resolveCloudPrompt, executeCloudDispatch } from '../lib/cloud/dispatch.js';
+/** Error type for run --cloud validation failures (exit 1, red message). */
+export class RunCloudError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RunCloudError';
+    }
+}
+/**
+ * Run flags that are meaningless on a cloud placement. Each entry maps the
+ * option field to the flag the user typed. Cloud tasks run in the provider's
+ * workspace on the provider's accounts, so local-run knobs (account strategy,
+ * secrets injection, loop guards, resume, terminal handoff, cwd) have nothing
+ * to act on — passing one is an error, never a silent ignore.
+ */
+const RUN_CLOUD_CONFLICTS = [
+    { field: 'terminal', flag: '--terminal', set: (v) => v !== undefined && v !== false },
+    { field: 'interactive', flag: '--interactive', set: (v) => v === true },
+    { field: 'acp', flag: '--acp', set: (v) => v === true },
+    { field: 'loop', flag: '--loop', set: (v) => v === true },
+    { field: 'resumeCheckpoint', flag: '--resume-checkpoint', set: (v) => v !== undefined },
+    { field: 'maxIterations', flag: '--max-iterations', set: (v) => v !== undefined },
+    { field: 'budget', flag: '--budget', set: (v) => v !== undefined },
+    { field: 'until', flag: '--until', set: (v) => v !== undefined },
+    { field: 'interval', flag: '--interval', set: (v) => v !== undefined },
+    { field: 'resume', flag: '--resume', set: (v) => v !== undefined && v !== false },
+    { field: 'sessionId', flag: '--session-id', set: (v) => v !== undefined },
+    { field: 'secrets', flag: '--secrets', set: (v) => Array.isArray(v) && v.length > 0 },
+    { field: 'secretsKeys', flag: '--secrets-keys', set: (v) => v !== undefined },
+    { field: 'allowExpired', flag: '--allow-expired', set: (v) => v === true },
+    { field: 'autoSecrets', flag: '--no-auto-secrets', set: (v) => v === false },
+    { field: 'copyCreds', flag: '--copy-creds', set: (v) => v === true },
+    { field: 'fallback', flag: '--fallback', set: (v) => v !== undefined },
+    { field: 'strategy', flag: '--strategy', set: (v) => v !== undefined },
+    { field: 'balanced', flag: '--balanced', set: (v) => v === true },
+    { field: 'cwd', flag: '--cwd', set: (v) => v !== undefined },
+    { field: 'project', flag: '--project', set: (v) => v !== undefined },
+    { field: 'addDir', flag: '--add-dir', set: (v) => Array.isArray(v) && v.length > 0 },
+    { field: 'remoteCwd', flag: '--remote-cwd', set: (v) => v !== undefined },
+    { field: 'env', flag: '--env', set: (v) => Array.isArray(v) && v.length > 0 },
+    { field: 'notify', flag: '--notify', set: (v) => v === true },
+    // effort defaults to 'auto' on run; only an explicit non-default value is a
+    // conflict (no provider consumes an effort option — it would be dropped).
+    { field: 'effort', flag: '--effort', set: (v) => v !== undefined && v !== 'auto' },
+    // --name seeds the LOCAL session label; a cloud task has no local session.
+    { field: 'name', flag: '--name', set: (v) => v !== undefined },
+];
+/** Flags that refine a cloud dispatch; meaningless without the placement. */
+const CLOUD_ONLY_FLAGS = [
+    { field: 'provider', flag: '--provider', set: (v) => v !== undefined },
+    { field: 'repo', flag: '--repo', set: (v) => Array.isArray(v) && v.length > 0 },
+    { field: 'branch', flag: '--branch', set: (v) => v !== undefined },
+    { field: 'cloudEnv', flag: '--cloud-env', set: (v) => v !== undefined },
+];
+/** Flags the user passed that cannot ride a cloud placement. */
+export function runCloudConflicts(options) {
+    return RUN_CLOUD_CONFLICTS.filter((c) => c.set(options[c.field])).map((c) => c.flag);
+}
+/** Cloud-only flags passed without the --cloud placement. */
+export function cloudFlagsWithoutCloud(options) {
+    return CLOUD_ONLY_FLAGS.filter((c) => c.set(options[c.field])).map((c) => c.flag);
+}
+/** Agents that route to a native cloud provider (the registry's truth). */
+export function cloudCapableAgentIds() {
+    return Object.values(AGENTS)
+        .filter((a) => a.cloudProvider)
+        .map((a) => a.id)
+        .sort();
+}
+/**
+ * Resolve the cloud provider for a run: explicit --provider wins, else the
+ * agent's native cloud. An agent with no native cloud fails loud with the
+ * capable list — never a silent ride onto the configured default.
+ */
+export function resolveRunCloudProvider(agentId, explicitProvider) {
+    if (explicitProvider)
+        return resolveProvider(explicitProvider);
+    if (!nativeProviderForAgent(agentId)) {
+        throw new RunCloudError(`${agentId} has no native cloud. Cloud-capable agents: ${cloudCapableAgentIds().join(', ')}. ` +
+            `Override with --provider <id> (rush | codex | factory | antigravity | host).`);
+    }
+    return resolveProvider(undefined, agentId);
+}
+/** Validate the agent half of `agents run <agent> --cloud` and return the registry id. */
+export function resolveRunCloudAgent(agentSpec) {
+    if (agentSpec === RUN_AUTO_KEYWORD || agentSpec.startsWith(`${RUN_AUTO_KEYWORD}@`)) {
+        throw new RunCloudError(`agents run auto --cloud: auto harness-pick is a local-run feature. ` +
+            `Name a cloud-capable agent: ${cloudCapableAgentIds().join(', ')}.`);
+    }
+    if (agentSpec.includes('@')) {
+        throw new RunCloudError(`Version pins (<agent>@<version>) do not apply to --cloud — the provider runs its own agent version. ` +
+            `Drop the pin: agents run ${agentSpec.split('@')[0]} "<task>" --cloud.`);
+    }
+    const agentId = resolveAgentName(agentSpec);
+    if (!agentId) {
+        throw new RunCloudError(`Unknown agent: ${agentSpec}. Cloud-capable agents: ${cloudCapableAgentIds().join(', ')}.`);
+    }
+    if (isAgentHardDeprecated(agentId)) {
+        throw new RunCloudError(hardDeprecationError(agentId));
+    }
+    return agentId;
+}
+/**
+ * Handle `agents run <agent> [prompt] --cloud`. Validation lives in the
+ * exported helpers above (unit-tested); this wires them to the shared
+ * dispatch core and dies on any validation failure.
+ */
+export async function handleRunCloud(agentSpec, prompt, options, command) {
+    const json = options.json === true;
+    try {
+        const agentId = resolveRunCloudAgent(agentSpec);
+        const provider = resolveRunCloudProvider(agentId, options.provider);
+        const resolvedPrompt = resolveCloudPrompt(prompt, {
+            json,
+            hint: `agents run ${agentId} "<task>" --cloud${agentId === 'claude' ? ' --repo <owner/repo>' : ''}`,
+        });
+        const repoValues = Array.isArray(options.repo) ? options.repo : [];
+        const dispatchOptions = {
+            prompt: resolvedPrompt,
+            agent: agentId,
+            repo: repoValues[0],
+            repos: repoValues.length > 0 ? repoValues : undefined,
+            branch: options.branch,
+            timeout: options.timeout,
+            model: options.model,
+            providerOptions: {},
+        };
+        if (options.cloudEnv)
+            dispatchOptions.providerOptions.env = options.cloudEnv;
+        // --mode defaults to 'plan' on run; forward it only when the user set it.
+        if (command.getOptionValueSource('mode') === 'cli') {
+            dispatchOptions.providerOptions.mode = options.mode;
+        }
+        await executeCloudDispatch({
+            provider,
+            dispatchOptions,
+            follow: options.follow !== false,
+            json,
+        });
+    }
+    catch (err) {
+        if (err instanceof RunCloudError) {
+            console.error(chalk.red(err.message));
+            process.exit(1);
+        }
+        throw err;
+    }
+}

package/dist/commands/versions.js

@@ -438,8 +438,10 @@ export function registerVersionsCommands(program) {
                         console.log(chalk.gray(`  Created shim: ${getShimsDir()}/${agentConfig.cliCommand}`));
                     }
                     // Seed the fresh version home with user settings from the current
-                    // default version (settings.json, keybindings, codex config/auth).
-                    // Gap-filling only — never overwrites what the new home has.
+                    // default version (settings.json, keybindings, codex config).
+                    // Credentials are deliberately excluded so each version keeps its own
+                    // login (see SETTINGS_MANIFEST). Gap-filling only — never overwrites
+                    // what the new home has.
                     const carrySource = getGlobalDefault(agent);
                     if (carrySource && carrySource !== installedVersion) {
                         const carried = carryForwardSettings(agent, getVersionHomePath(agent, carrySource), getVersionHomePath(agent, installedVersion));

package/dist/commands/view.js

@@ -10,8 +10,7 @@ import { machineId } from '../lib/machine-id.js';
 import { authCacheKey, formatCheckedAge, readAuthHealthCache } from '../lib/auth-health.js';
 import { agentReportsUsage, deriveUsageStatusFromSnapshot, formatUsageSection, formatUsageSummary, formatUsageStatusBadge, getUsageInfoForIdentity, getUsageInfoByIdentity, getUsageLookupKey, } from '../lib/usage.js';
 import { readManifest } from '../lib/manifest.js';
-import { listInstalledVersions, listInstalledVersionDirs, getGlobalDefault, getVersionHomePath, getVersionDir, getAvailableResources, getActuallySyncedResources, getNewResources, getProjectOnlyResources, hasNewResources, promptNewResourceSelection, syncResourcesToVersion, removeVersion, printTrashFooter, reconcileStaleLatestForAgent, isGlobalBinaryAgent, getLiveVersion, isVersionIsolated, getIsolatedDefault, } from '../lib/versions.js';
-import { formatKeptProjectResources } from '../lib/project-resources.js';
+import { listInstalledVersions, listInstalledVersionDirs, getGlobalDefault, getVersionHomePath, getVersionDir, removeVersion, printTrashFooter, reconcileStaleLatestForAgent, isGlobalBinaryAgent, getLiveVersion, isVersionIsolated, getIsolatedDefault, } from '../lib/versions.js';
 import { ensureVersionedAliasCurrent, removeShim, } from '../lib/shims.js';
 import { getAgentResources } from '../lib/resources.js';
 import { renderMergedResources } from '../lib/merged-resources.js';
@@ -29,7 +28,6 @@ import { resolveConfiguredModel } from '../lib/models.js';
 import { listProfiles, profileExists, profileSummary, readProfile } from '../lib/profiles.js';
 import { getByokUsageForHarness, hasByokProvider, renderByokBar } from '../lib/byok-usage.js';
 import { renderHarnessDetail } from './harness.js';
-import { loadManifest, isStale } from '../lib/staleness/index.js';
 import { confirm } from '@inquirer/prompts';
 import { formatPath, isInteractiveTerminal, isPromptCancelled } from './utils.js';
 import { terminalWidth, truncateToWidth, stringWidth, padToWidth } from '../lib/session/width.js';
@@ -781,57 +779,6 @@ async function showInstalledVersions(filterAgentId, viewOpts) {
     if (!filterAgentId) {
         renderHostClisSection(process.cwd());
     }
-    // Check for new resources when viewing a specific agent
-    if (filterAgentId && versionManaged.length > 0) {
-        const defaultVersion = getGlobalDefault(filterAgentId);
-        if (defaultVersion) {
-            const manifest = loadManifest(filterAgentId, defaultVersion);
-            const cwd = process.cwd();
-            if (manifest && !isStale(manifest, filterAgentId, defaultVersion, cwd)) {
-                return;
-            }
-            const available = getAvailableResources();
-            const synced = getActuallySyncedResources(filterAgentId, defaultVersion);
-            const projectOnly = getProjectOnlyResources();
-            const newResources = getNewResources(available, synced, projectOnly);
-            if (hasNewResources(newResources, filterAgentId, defaultVersion)) {
-                try {
-                    const selection = await promptNewResourceSelection(filterAgentId, newResources, defaultVersion);
-                    if (selection && Object.keys(selection).length > 0) {
-                        const result = syncResourcesToVersion(filterAgentId, defaultVersion, selection);
-                        const synced = [];
-                        if (result.commands)
-                            synced.push('commands');
-                        if (result.skills)
-                            synced.push('skills');
-                        if (result.hooks)
-                            synced.push('hooks');
-                        if (result.memory.length > 0)
-                            synced.push('memory');
-                        if (result.permissions)
-                            synced.push('permissions');
-                        if (result.mcp.length > 0)
-                            synced.push('mcp');
-                        if (result.plugins.length > 0)
-                            synced.push('plugins');
-                        if (result.workflows.length > 0)
-                            synced.push('workflows');
-                        if (synced.length > 0) {
-                            console.log(chalk.green(`\nSynced to ${agentLabel(filterAgentId)}@${defaultVersion}: ${synced.join(', ')}`));
-                        }
-                        const kept = formatKeptProjectResources(result.projectSkipped);
-                        if (kept)
-                            console.log(chalk.gray(kept));
-                    }
-                }
-                catch (err) {
-                    if (isPromptCancelled(err))
-                        return;
-                    throw err;
-                }
-            }
-        }
-    }
 }
 /**
  * Show detailed resources for a specific agent version.

package/dist/lib/agents.js

@@ -212,8 +212,10 @@ export const AGENTS = {
         format: 'markdown',
         variableSyntax: '$ARGUMENTS',
         supportsHooks: true,
-        // Claude Code has no headless Anthropic-hosted dispatch CLI (only
-        // --remote-control, which bridges a *local* session). Its cloud is Rush.
+        // Claude Code grew a native `claude --cloud "<prompt>"` (Anthropic-managed
+        // infra, claude.ai/code; requires claude.ai subscription auth). Routing
+        // still goes to Rush Cloud deliberately — it keeps cloud tasks in one
+        // tracked fleet (agents cloud list/status/logs) regardless of harness.
         cloudProvider: 'rush',
         capabilities: { hooks: true, mcp: true, mcpHttp: true, mcpHeaders: true, allowlist: true, skills: true, commands: true, plugins: true, subagents: true, rules: { file: 'CLAUDE.md' }, workflows: true, memory: true, modes: ['plan', 'edit', 'auto', 'skip'], rulesImports: true, interactiveRepl: true },
     },

package/dist/lib/channels/providers/rush.d.ts

@@ -3,4 +3,6 @@ export type RushChannel = 'telegram' | 'imessage' | 'slack' | 'discord';
 export declare const RUSH_CHANNELS: RushChannel[];
 /** Build the `rush send` argv (exported for tests). */
 export declare function buildRushSendArgs(channel: RushChannel, text: string, opts: SendOptions): string[];
+/** Build the owner-scoped iMessage argv. */
+export declare function buildRushOwnerMessageArgs(text: string): string[];
 export declare const rushProviders: ChannelProvider[];

package/dist/lib/channels/providers/rush.js

@@ -1,10 +1,9 @@
 /**
- * Rush-daemon channel providers — telegram / imessage / slack / discord.
+ * Rush channel providers — telegram / imessage / slack / discord.
  *
- * These shell out to the already-built `rush send` CLI, which routes through the
- * rush daemon's live channel gateways over ~/.rush/daemon.sock. We do NOT import
- * rush's Go internals (different repo, internal package) — the CLI boundary is
- * the contract. `rush send --json` prints {"ok":true,"channel":..,"id":..}.
+ * Addressable channels use `rush send`, which routes through the daemon's live
+ * gateways. Owner-scoped iMessage uses `rush message send`; it is backed by the
+ * verified Rush owner account and does not require a daemon channel registration.
  */
 import { execFile } from 'child_process';
 import { promisify } from 'util';
@@ -19,6 +18,10 @@ export function buildRushSendArgs(channel, text, opts) {
         args.push('--attachment', a);
     return args;
 }
+/** Build the owner-scoped iMessage argv. */
+export function buildRushOwnerMessageArgs(text) {
+    return ['message', 'send', '--text', text];
+}
 function rushProvider(channel) {
     return {
         name: channel,
@@ -34,6 +37,18 @@ function rushProvider(channel) {
                 return { ok: false, channel, id: opts.target, error: 'rush CLI not found on PATH' };
             }
             try {
+                if (channel === 'imessage' && opts.ownerScoped) {
+                    if ((opts.attachments?.length ?? 0) > 0) {
+                        return {
+                            ok: false,
+                            channel,
+                            id: opts.target,
+                            error: 'owner-scoped iMessage does not support attachments',
+                        };
+                    }
+                    await execFileAsync('rush', buildRushOwnerMessageArgs(text));
+                    return { ok: true, channel, id: opts.target };
+                }
                 const { stdout } = await execFileAsync('rush', buildRushSendArgs(channel, text, opts));
                 const parsed = JSON.parse(stdout);
                 return {

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

@@ -17,6 +17,8 @@ export interface SendOptions {
     attachments?: string[];
     /** Sender label (used by the mailbox provider). */
     from?: string;
+    /** Destination was resolved through the verified owner alias. */
+    ownerScoped?: boolean;
     /** Resolve + build the delivery but do not actually send. */
     dryRun?: boolean;
 }

package/dist/lib/channels/send.d.ts

@@ -3,7 +3,7 @@
  *
  * One primitive: resolve a destination (channel + target), compose text + urls +
  * attachments, hand off to a channel provider. `notify` is the same path with
- * destination defaulted to `notify.owner` in agents.yaml — owner is an address
+ * destination defaulted from `humans.yaml` — owner is an address
  * alias (`--to owner`), not a separate stack.
  *
  * Agent control (`agents message`, `sessions inject`) stays outside this module.
@@ -18,6 +18,7 @@ export interface SendEnvelope {
     thread?: string;
     attachments?: string[];
     from?: string;
+    ownerScoped?: boolean;
     dryRun?: boolean;
 }
 export interface ResolveSendInput {
@@ -60,8 +61,8 @@ export declare function isOwnerAlias(to: string | undefined): boolean;
 /** Compose body + optional URL lines (skip urls already present in the body). */
 export declare function composeSendText(text: string, urls?: string[]): string;
 /**
- * Read the owner destination; humans.yaml is the primary source, agents.yaml
- * notify.owner is the fallback. Returns null when neither is set.
+ * Read the owner destination. humans.yaml is canonical; notify.owner remains a
+ * migration fallback for installations that have not run the schema migration.
  */
 export declare function readOwnerDest(meta: Meta): {
     channel: string;

package/dist/lib/channels/send.js

@@ -18,19 +18,16 @@ export function composeSendText(text, urls) {
     return body ? `${body}\n${extra.join('\n')}` : extra.join('\n');
 }
 /**
- * Read the owner destination; humans.yaml is the primary source, agents.yaml
- * notify.owner is the fallback. Returns null when neither is set.
+ * Read the owner destination. humans.yaml is canonical; notify.owner remains a
+ * migration fallback for installations that have not run the schema migration.
  */
 export function readOwnerDest(meta) {
-    const humansOwner = getOwnerNotifyFromHumans();
-    if (humansOwner)
-        return humansOwner;
-    const owner = meta.notify?.owner;
-    const channel = owner?.channel?.trim();
-    const to = owner?.to?.trim();
-    if (!channel || !to)
-        return null;
-    return { channel, to };
+    const canonical = getOwnerNotifyFromHumans();
+    if (canonical)
+        return canonical;
+    const channel = meta.notify?.owner?.channel?.trim();
+    const to = meta.notify?.owner?.to?.trim();
+    return channel && to ? { channel, to } : null;
 }
 /**
  * Resolve CLI/config into a send envelope. Pure except for reading `meta` —
@@ -55,16 +52,14 @@ export function resolveSendEnvelope(input, meta) {
         };
     }
     // Owner defaults fill only missing fields (and expand the bare "owner" alias).
-    // humans.yaml is the primary source; notify.owner in agents.yaml is the
-    // fallback for the migration window. Explicit --channel/--to always win.
+    // humans.yaml is the canonical source. Explicit --channel/--to always win.
     let channel = (input.channel ?? '').trim();
     let to = (input.to ?? '').trim();
     const usedOwnerAlias = isOwnerAlias(to);
     if (input.ownerMode || usedOwnerAlias) {
-        const humansOwner = getOwnerNotifyFromHumans();
-        const fallbackOwner = meta.notify?.owner;
-        const ownerChannel = humansOwner?.channel ?? fallbackOwner?.channel?.trim() ?? '';
-        const ownerTo = humansOwner?.to ?? fallbackOwner?.to?.trim() ?? '';
+        const owner = getOwnerNotifyFromHumans() ?? meta.notify?.owner;
+        const ownerChannel = owner?.channel ?? '';
+        const ownerTo = owner?.to ?? '';
         if (!channel)
             channel = ownerChannel;
         if (!to || usedOwnerAlias)
@@ -72,7 +67,7 @@ export function resolveSendEnvelope(input, meta) {
     }
     if (!channel || !to) {
         const hint = input.ownerMode || usedOwnerAlias
-            ? 'Set notify.{channel,to} in humans.yaml (or notify.owner in agents.yaml), or pass --channel and --to explicitly.'
+            ? 'Set owner.channels and owner.policy.normal in humans.yaml, or pass --channel and --to explicitly.'
             : 'Need --channel and --to (or --to owner with notify.owner configured). ' +
                 'Example: agents send --channel desktop --to local --text "hi"';
         return { ok: false, error: hint };
@@ -91,6 +86,7 @@ export function resolveSendEnvelope(input, meta) {
             thread: input.thread?.trim() || undefined,
             attachments: attachments.length ? attachments : undefined,
             from: input.from?.trim() || undefined,
+            ownerScoped: usedOwnerAlias || (input.ownerMode === true && !input.to?.trim()),
             dryRun: input.dryRun,
         },
     };
@@ -107,6 +103,7 @@ export async function deliverEnvelope(envelope, meta) {
         thread: envelope.thread,
         attachments: envelope.attachments,
         from: envelope.from,
+        ownerScoped: envelope.ownerScoped,
         dryRun: envelope.dryRun,
     });
 }

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

@@ -0,0 +1,27 @@
+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;
+}): string;
+export 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>;