@thirdfy/agent-cli 0.2.43 → 0.2.45

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `@thirdfy/agent-cli` are documented here. The format is b
 
 ## [Unreleased]
 
+## [0.2.45] - 2026-08-06
+
+### Added
+
+- Polymarket provider hints: official Bridge deposit/withdraw actions; Li.Fi `get_bridge_quote` documented as legacy fallback for PM collateral only.
+- `console-mandate` accepts `--chain-id` / `--network` (aligned with MCP `consoleMandateChains`: Gnosis 100, Robinhood 4663, Base 8453). Multi-chain Automations need one mandate per write chain.
+- Chat / mandate network map includes Gnosis, Unichain, Polygon, Arbitrum, Ethereum, Optimism, DogeOS testnet.
+
+### Fixed
+
+- Read-only classifier parity: `create_polymarket_bridge_deposit` and `create_polymarket_bridge_withdraw` route as setup reads (aligned with Thirdfy API `actionContractManifest`).
+
 ## [0.2.43] - 2026-07-31
 
 ### Added

package/README.md

@@ -40,12 +40,14 @@ Run without global install:
 npx @thirdfy/agent-cli --help
 ```
 
-## What's new in v0.2.43
+## What's new in v0.2.45
 
-- Aave earn provider routing (`get_aave_markets`, supply/withdraw, lending beta actions).
-- Polymarket `status`/`setup` return live execute payloads; `prepare_polymarket_onboarding` is read-only.
+- Polymarket official Bridge funding hints (`create_polymarket_bridge_deposit` / withdraw + status).
+- Classifier treats Bridge create actions as setup reads (parity with API and MCP).
+- `console-mandate` accepts `--chain-id` / `--network` for multi-chain Automations (Gnosis, Robinhood, Base).
+- Docs: Li.Fi remains legacy fallback for Polymarket collateral only.
 
-See [CHANGELOG.md](./CHANGELOG.md) for older versions.
+See [CHANGELOG.md](./CHANGELOG.md) and GitHub Releases for older versions.
 
 
 ## Quick start
@@ -325,7 +327,8 @@ Provider and venue guides are kept outside `README` so this page stays stable as
 - Discovery: `catalogs list`, `actions` (optional `--provider`, `--chain-id`; see [`docs/command-reference.md`](./docs/command-reference.md) for trading vs earn vs prediction providers and case-insensitive matching)
 - Execution: `preflight`, `run`, `intent-status`, `jeff preflight`, `jeff trade`, `jeff status`
 - Polymarket: `polymarket status`, `polymarket setup`, `polymarket dry-run`
-- Hummingbot: `hummingbot status`, `hummingbot connectors`, `hummingbot executor-schema`, `hummingbot executor-create`
+- Hummingbot: `hummingbot status`, `connectors`, `executor-schema`, `executor-create`, `executor-stop`, `gateway-networks`, `gateway-connectors`
+- Condor Pattern A: `condor policy-status`, `condor preflight`
 - Managed signer execution: `wallet execute`, `wallet sign`, `wallet submit`, `agent run`
 - Profiles: `profile init`, `profile use`, `profile show`, `whoami`
 - Onboarding: `login email`, `help onboarding`, `doctor auth`, `wallet list`, `bootstrap begin`, `bootstrap complete`, `onboarding begin`, `onboarding complete`, `agent auth challenge`, `agent auth verify`, `agent register`, `agent key rotate`, `agent key revoke`, `developer bootstrap`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thirdfy/agent-cli",
-  "version": "0.2.43",
+  "version": "0.2.45",
   "description": "Thirdfy Agent CLI for onboarding, governance preflight, execute-intent, and status polling.",
   "type": "module",
   "bin": {

package/src/cli/help.mjs

@@ -42,6 +42,11 @@ Core commands:
   thirdfy-agent hummingbot connectors [--org-id <id>] [--json]
   thirdfy-agent hummingbot executor-schema [--org-id <id>] [--executor-type position_executor] [--json]
   thirdfy-agent hummingbot executor-create --agent-api-key <key> --user-did <did> [--org-id <id>] [--connector <name>] [--pair <pair>] [--params <json>] [--json]
+  thirdfy-agent hummingbot executor-stop --agent-api-key <key> --user-did <did> --executor-id <id> [--org-id <id>] [--json]
+  thirdfy-agent hummingbot gateway-networks --agent-api-key <key> --user-did <did> [--org-id <id>] [--json]
+  thirdfy-agent hummingbot gateway-connectors --agent-api-key <key> --user-did <did> [--org-id <id>] [--json]
+  thirdfy-agent condor policy-status --agent-api-key <key> --user-did <did> [--org-id <id>] [--runtime-id <id>] [--json]
+  thirdfy-agent condor preflight --agent-api-key <key> --user-did <did> --estimated-amount-usd <usd> --idempotency-key <key> [--org-id <id>] [--runtime-id <id>] [--connector <name>] [--pair <pair>] [--json]
   thirdfy-agent wallet sign --agent-api-key <key> --action <id> --params <json> [--chain-id <id>] [--json]
   thirdfy-agent wallet submit --signed-tx-hex <hex> [--chain-id <id>] [--rpc-url <url>] [--json]
   thirdfy-agent agent run --agent-api-key <key> --action <id> --params <json> [--signer-method managed_wallet_server|byow|fanout_intent] [--strategy-intent single_wallet|fanout] [--run-mode <mode>] [--user-did <did>] [--json]

package/src/cli/manifest.mjs

@@ -148,6 +148,41 @@ export const CLI_MANIFEST = [
     options: ['auth', 'execution', 'hummingbot'],
     description: 'Governed Hummingbot executor create via Thirdfy proxy',
   },
+  {
+    path: ['hummingbot', 'executor-stop'],
+    handler: 'commandHummingbotExecutorStop',
+    tier: 'online',
+    options: ['auth', 'execution', 'hummingbot'],
+    description: 'Governed Hummingbot executor stop via Thirdfy proxy',
+  },
+  {
+    path: ['hummingbot', 'gateway-networks'],
+    handler: 'commandHummingbotGatewayNetworks',
+    tier: 'online',
+    options: ['auth', 'execution', 'hummingbot'],
+    description: 'Gateway network discovery via catalog read get_hummingbot_gateway_networks',
+  },
+  {
+    path: ['hummingbot', 'gateway-connectors'],
+    handler: 'commandHummingbotGatewayConnectors',
+    tier: 'online',
+    options: ['auth', 'execution', 'hummingbot'],
+    description: 'Gateway connector discovery via catalog read get_hummingbot_gateway_connectors',
+  },
+  {
+    path: ['condor', 'policy-status'],
+    handler: 'commandCondorPolicyStatus',
+    tier: 'online',
+    options: ['auth', 'execution', 'condor'],
+    description: 'Condor Pattern A policy status via catalog read get_condor_policy_status',
+  },
+  {
+    path: ['condor', 'preflight'],
+    handler: 'commandCondorPreflight',
+    tier: 'online',
+    options: ['auth', 'execution', 'condor'],
+    description: 'Condor Pattern A preflight reservation via governance/preflight (condor.executor.create)',
+  },
   // online
   {
     path: ['agent', 'run'],
@@ -388,28 +423,28 @@ export const CLI_MANIFEST = [
     path: ['console-mandate', 'status'],
     handler: 'commandConsoleMandateStatus',
     tier: 'online',
-    options: ['auth', 'delegation'],
+    options: ['auth', 'delegation', 'chains'],
     description: 'Console delegated execution status',
   },
   {
     path: ['console-mandate', 'draft'],
     handler: 'commandConsoleMandateDraft',
     tier: 'online',
-    options: ['auth', 'delegation'],
+    options: ['auth', 'delegation', 'chains'],
     description: 'Create Console mandate draft',
   },
   {
     path: ['console-mandate', 'activate'],
     handler: 'commandConsoleMandateActivate',
     tier: 'online',
-    options: ['auth', 'delegation'],
+    options: ['auth', 'delegation', 'chains'],
     description: 'Activate signed Console mandate',
   },
   {
     path: ['console-mandate', 'revoke'],
     handler: 'commandConsoleMandateRevoke',
     tier: 'online',
-    options: ['auth', 'delegation'],
+    options: ['auth', 'delegation', 'chains'],
     description: 'Revoke Console mandate',
   },
   {

package/src/cli/options/condor.mjs

@@ -0,0 +1,7 @@
+export function attachCondorOptions(cmd) {
+  return cmd
+    .option('--org-id <id>', 'Condor org id (default: HUMMINGBOT_ORG_ID or default)')
+    .option('--runtime-id <id>', 'EarnClaw runtime id for policy scoping')
+    .option('--connector <name>', 'CEX connector for preflight params')
+    .option('--pair <pair>', 'Trading pair for preflight params');
+}

package/src/cli/options/delegation.mjs

@@ -6,6 +6,8 @@ export function attachDelegationOptions(cmd) {
     .option('--max-usd-per-day <usd>', 'max USD per day')
     .option('--period-duration <sec>', 'period duration seconds')
     .option('--expiry-seconds <sec>', 'expiry seconds')
+    // `--chain-id` comes from the `chains` option bundle (avoid duplicate on init-custodial).
+    .option('--network <id>', 'network id (e.g. gnosis-mainnet, robinhood-mainnet)')
     .option('--delegation-manager <addr>', 'delegation manager address')
     .option('--delegation <json>', 'delegation JSON')
     .option('--permission <json>', 'permission JSON')

package/src/cli/options/hummingbot.mjs

@@ -3,6 +3,7 @@ export function attachHummingbotOptions(cmd) {
     .option('--org-id <id>', 'Hummingbot org id (default: HUMMINGBOT_ORG_ID or default)')
     .option('--runtime-id <id>', 'EarnClaw runtime id for health summary scoping')
     .option('--executor-type <type>', 'Hummingbot executor type')
+    .option('--executor-id <id>', 'Hummingbot executor id for stop')
     .option('--connector <name>', 'Hummingbot connector name')
     .option('--pair <pair>', 'Hummingbot trading pair');
 }

package/src/cli/options/index.mjs

@@ -9,6 +9,7 @@ import { attachCredentialsOptions } from './credentials.mjs';
 import { attachAnalyticsOptions } from './analytics.mjs';
 import { attachPolymarketOptions } from './polymarket.mjs';
 import { attachHummingbotOptions } from './hummingbot.mjs';
+import { attachCondorOptions } from './condor.mjs';
 import { attachAgentRegisterOptions } from './agent.mjs';
 import { attachChainOptions } from './chains.mjs';
 import { attachCreditsOptions } from './credits.mjs';
@@ -28,6 +29,7 @@ const BUNDLES = {
   analytics: attachAnalyticsOptions,
   polymarket: attachPolymarketOptions,
   hummingbot: attachHummingbotOptions,
+  condor: attachCondorOptions,
   agent: attachAgentRegisterOptions,
   chains: attachChainOptions,
   credits: attachCreditsOptions,

package/src/commands/chat.mjs

@@ -5,7 +5,14 @@ import { apiGet, safeJsonParse } from '../core/http.mjs';
 const NETWORK_CHAIN_IDS = {
   'base-mainnet': 8453,
   'base-sepolia': 84532,
+  'ethereum-mainnet': 1,
+  'optimism-mainnet': 10,
+  'gnosis-mainnet': 100,
+  'unichain-mainnet': 130,
+  'polygon-mainnet': 137,
+  'arbitrum-mainnet': 42161,
   'robinhood-mainnet': 4663,
+  'dogeos-testnet': 6281971,
 };
 
 const DEFAULT_CHAT_CHAIN_ID = 8453;

package/src/commands/condor.mjs

@@ -0,0 +1,130 @@
+import { apiPost } from '../core/http.mjs';
+import { parseJsonFlag } from '../core/args.mjs';
+import { negotiateCapabilities } from '../core/http.mjs';
+import { resolveConfigAgentKey } from './polymarket.mjs';
+
+function agentApiKeyFromFlags(flags, ctx) {
+  return String(flags.agentApiKey || flags.agent_api_key || ctx?.agentApiKey || '').trim();
+}
+
+function userDidFromFlags(flags) {
+  return String(flags.userDid || flags.user_did || '').trim();
+}
+
+function orgIdFromFlags(flags) {
+  return String(flags.orgId || flags.org_id || process.env.HUMMINGBOT_ORG_ID || 'default').trim();
+}
+
+function runtimeIdFromFlags(flags) {
+  return String(flags.runtimeId || flags.runtime_id || '').trim();
+}
+
+function failMissingIdentity(printEnvelope, ctx, message) {
+  printEnvelope({
+    success: false,
+    code: 'MISSING_AUTH',
+    message,
+    data: {},
+    meta: { apiBase: ctx.apiBase },
+  });
+  process.exit(1);
+}
+
+export function createCondorCommands({ commandRun, printEnvelope }) {
+  async function commandCondorPolicyStatus(ctx, flags) {
+    const agentApiKey = agentApiKeyFromFlags(flags, ctx);
+    const userDid = userDidFromFlags(flags);
+    if (!agentApiKey || !userDid) {
+      failMissingIdentity(
+        printEnvelope,
+        ctx,
+        'Provide --agent-api-key and --user-did for Condor policy status'
+      );
+    }
+    const capabilities = await negotiateCapabilities(ctx);
+    if (!flags.runMode) flags.runMode = 'thirdfy';
+    flags.provider = 'condor';
+    flags.action = 'get_condor_policy_status';
+    const params = parseJsonFlag(flags, 'params') || {};
+    flags.params = JSON.stringify({
+      orgId: orgIdFromFlags(flags),
+      ...(runtimeIdFromFlags(flags) ? { runtimeId: runtimeIdFromFlags(flags) } : {}),
+      ...params,
+    });
+    await commandRun(ctx, flags, capabilities);
+  }
+
+  async function commandCondorPreflight(ctx, flags) {
+    const agentApiKey = agentApiKeyFromFlags(flags, ctx);
+    const userDid = userDidFromFlags(flags);
+    const idempotencyKey = String(flags.idempotencyKey || flags.idempotency_key || '').trim();
+    const estimatedAmountUsd = Number(flags.estimatedAmountUsd || flags.estimated_amount_usd || 0);
+    if (!agentApiKey || !userDid) {
+      failMissingIdentity(
+        printEnvelope,
+        ctx,
+        'Provide --agent-api-key and --user-did for Condor preflight'
+      );
+    }
+    if (!idempotencyKey) {
+      printEnvelope({
+        success: false,
+        code: 'MISSING_IDEMPOTENCY',
+        message: 'Provide --idempotency-key for Condor Pattern A preflight',
+        data: {},
+        meta: { apiBase: ctx.apiBase },
+      });
+      process.exit(1);
+    }
+    if (!Number.isFinite(estimatedAmountUsd) || estimatedAmountUsd <= 0) {
+      printEnvelope({
+        success: false,
+        code: 'MISSING_NOTIONAL',
+        message: 'Provide --estimated-amount-usd greater than zero for Condor preflight',
+        data: {},
+        meta: { apiBase: ctx.apiBase },
+      });
+      process.exit(1);
+    }
+    const params = parseJsonFlag(flags, 'params') || {};
+    const orgId = orgIdFromFlags(flags);
+    const runtimeId = runtimeIdFromFlags(flags);
+    const agentKey = String(flags.agentKey || flags.agent_key || resolveConfigAgentKey(flags) || '').trim();
+    const body = {
+      agentApiKey,
+      action: 'condor.executor.create',
+      userDid,
+      estimatedAmountUsd,
+      idempotencyKey,
+      executionLane: 'validation_only',
+      params: {
+        orgId,
+        ...(runtimeId ? { runtimeId } : {}),
+        ...(agentKey ? { agentKey } : {}),
+        connector: flags.connector || params.connector,
+        tradingPair: flags.pair || flags.tradingPair || params.tradingPair || params.trading_pair,
+        notionalUsd: estimatedAmountUsd,
+        source: 'condor_pattern_a',
+        ...params,
+      },
+    };
+    const data = await apiPost(ctx, '/api/v1/agent/governance/preflight', body, {
+      'x-agent-api-key': agentApiKey,
+    });
+    printEnvelope({
+      success: Boolean(data?.success ?? true),
+      data,
+      meta: {
+        apiBase: ctx.apiBase,
+        orgId,
+        runtimeId: runtimeId || null,
+        action: 'condor.executor.create',
+      },
+    });
+  }
+
+  return {
+    commandCondorPolicyStatus,
+    commandCondorPreflight,
+  };
+}

package/src/commands/consoleMandate.mjs

@@ -1,6 +1,38 @@
 import { requireFlag } from '../core/args.mjs';
 import { apiGet, apiPost } from '../core/http.mjs';
 
+/** Aligned with chat.mjs NETWORK_CHAIN_IDS and thirdfy-mcp consoleMandateChains. */
+const CONSOLE_MANDATE_NETWORK_CHAIN_IDS = {
+  'base-mainnet': 8453,
+  'base-sepolia': 84532,
+  'ethereum-mainnet': 1,
+  'optimism-mainnet': 10,
+  'gnosis-mainnet': 100,
+  'unichain-mainnet': 130,
+  'polygon-mainnet': 137,
+  'arbitrum-mainnet': 42161,
+  'robinhood-mainnet': 4663,
+  'dogeos-testnet': 6281971,
+};
+
+function resolveConsoleMandateChainId(flags) {
+  if (flags.chainId) {
+    const parsed = Number(flags.chainId);
+    if (Number.isFinite(parsed) && parsed > 0) return parsed;
+    throw new Error(`Invalid --chain-id "${flags.chainId}". Must be a positive number.`);
+  }
+  const networkRaw = String(flags.network || '').trim();
+  const network = networkRaw.toLowerCase();
+  if (network) {
+    const chainId = CONSOLE_MANDATE_NETWORK_CHAIN_IDS[network];
+    if (chainId !== undefined) return chainId;
+    throw new Error(
+      `Unknown --network "${networkRaw}". Supported: ${Object.keys(CONSOLE_MANDATE_NETWORK_CHAIN_IDS).join(', ')}`,
+    );
+  }
+  return 8453;
+}
+
 export function createConsoleMandateCommands(deps) {
   const { buildOwnerAuthHeaders, printEnvelope } = deps;
 
@@ -9,7 +41,7 @@ export function createConsoleMandateCommands(deps) {
       flags,
       'Missing --auth-token/--owner-session-token for console mandate status',
     );
-    const chainId = Number(flags.chainId || 8453);
+    const chainId = resolveConsoleMandateChainId(flags);
     const walletAddress = String(flags.walletAddress || flags.ownerAddress || '').trim();
     const query = new URLSearchParams({ chainId: String(chainId) });
     if (walletAddress) query.set('walletAddress', walletAddress);
@@ -25,7 +57,7 @@ export function createConsoleMandateCommands(deps) {
       code: 'CONSOLE_MANDATE_STATUS',
       message: 'Console delegated execution status',
       data: response?.data || response,
-      meta: { apiBase: ctx.apiBase },
+      meta: { apiBase: ctx.apiBase, chainId },
     });
   }
 
@@ -36,7 +68,7 @@ export function createConsoleMandateCommands(deps) {
     );
     const payload = {
       ownerAddress: requireFlag(flags, 'ownerAddress', 'Missing --owner-address'),
-      chainId: Number(flags.chainId || 8453),
+      chainId: resolveConsoleMandateChainId(flags),
       maxUsdPerDay: Number(requireFlag(flags, 'maxUsdPerDay', 'Missing --max-usd-per-day')),
       expirySeconds: Number(flags.expirySeconds || 30 * 24 * 60 * 60),
       tokenAddress: flags.tokenAddress,
@@ -54,7 +86,7 @@ export function createConsoleMandateCommands(deps) {
       code: 'CONSOLE_MANDATE_DRAFT',
       message: 'Console mandate draft created',
       data: response?.data || response,
-      meta: { apiBase: ctx.apiBase },
+      meta: { apiBase: ctx.apiBase, chainId: payload.chainId },
     });
   }
 
@@ -65,7 +97,7 @@ export function createConsoleMandateCommands(deps) {
     );
     const payload = {
       walletAddress: requireFlag(flags, 'walletAddress', 'Missing --wallet-address'),
-      chainId: Number(flags.chainId || 8453),
+      chainId: resolveConsoleMandateChainId(flags),
       delegationManager: requireFlag(flags, 'delegationManager', 'Missing --delegation-manager'),
       delegation: JSON.parse(requireFlag(flags, 'delegation', 'Missing --delegation JSON')),
       signature: requireFlag(flags, 'signature', 'Missing --signature'),
@@ -86,7 +118,7 @@ export function createConsoleMandateCommands(deps) {
       code: 'CONSOLE_MANDATE_ACTIVATED',
       message: 'Console mandate activated',
       data: response?.data || response,
-      meta: { apiBase: ctx.apiBase },
+      meta: { apiBase: ctx.apiBase, chainId: payload.chainId },
     });
   }
 
@@ -97,7 +129,7 @@ export function createConsoleMandateCommands(deps) {
     );
     const payload = {
       walletAddress: flags.walletAddress,
-      chainId: Number(flags.chainId || 8453),
+      chainId: resolveConsoleMandateChainId(flags),
       reason: flags.reason || 'cli_revoked',
     };
     const response = await apiPost(ctx, '/api/v1/console/delegation/revoke', payload, {
@@ -112,7 +144,7 @@ export function createConsoleMandateCommands(deps) {
       code: 'CONSOLE_MANDATE_REVOKED',
       message: 'Console mandate revoked',
       data: response?.data || response,
-      meta: { apiBase: ctx.apiBase },
+      meta: { apiBase: ctx.apiBase, chainId: payload.chainId },
     });
   }
 

package/src/commands/hummingbot.mjs

@@ -1,5 +1,6 @@
 import { apiGet, apiPost } from '../core/http.mjs';
 import { parseJsonFlag } from '../core/args.mjs';
+import { negotiateCapabilities } from '../core/http.mjs';
 import { resolveConfigAgentKey } from './polymarket.mjs';
 
 function orgIdFromFlags(flags) {
@@ -10,7 +11,26 @@ function agentApiKeyFromFlags(flags, ctx) {
   return String(flags.agentApiKey || flags.agent_api_key || ctx?.agentApiKey || '').trim();
 }
 
-export function createHummingbotCommands({ printEnvelope }) {
+function userDidFromFlags(flags) {
+  return String(flags.userDid || flags.user_did || '').trim();
+}
+
+function runtimeIdFromFlags(flags) {
+  return String(flags.runtimeId || flags.runtime_id || '').trim();
+}
+
+function failMissingIdentity(printEnvelope, ctx, message) {
+  printEnvelope({
+    success: false,
+    code: 'MISSING_AUTH',
+    message,
+    data: {},
+    meta: { apiBase: ctx.apiBase },
+  });
+  process.exit(1);
+}
+
+export function createHummingbotCommands({ printEnvelope, commandRun }) {
   async function commandHummingbotStatus(ctx, flags) {
     const orgId = orgIdFromFlags(flags);
     const agentApiKey = agentApiKeyFromFlags(flags, ctx);
@@ -40,16 +60,14 @@ export function createHummingbotCommands({ printEnvelope }) {
   async function commandHummingbotExecutorCreate(ctx, flags) {
     const orgId = orgIdFromFlags(flags);
     const agentApiKey = agentApiKeyFromFlags(flags, ctx);
-    const userDid = String(flags.userDid || flags.user_did || '').trim();
+    const userDid = userDidFromFlags(flags);
     const params = parseJsonFlag(flags, 'params') || {};
     if (!agentApiKey || !userDid) {
-      printEnvelope({
-        success: false,
-        code: 'MISSING_AUTH',
-        message: 'Provide --agent-api-key and --user-did for governed executor create',
-        data: {},
-      });
-      process.exit(1);
+      failMissingIdentity(
+        printEnvelope,
+        ctx,
+        'Provide --agent-api-key and --user-did for governed executor create'
+      );
     }
     const body = {
       ...params,
@@ -60,6 +78,9 @@ export function createHummingbotCommands({ printEnvelope }) {
       estimatedAmountUsd: Number(flags.estimatedAmountUsd || params.estimatedAmountUsd || 0),
       type: flags.executorType || flags.executor_type || params.type || 'position_executor',
     };
+    if (runtimeIdFromFlags(flags)) {
+      body.runtimeId = runtimeIdFromFlags(flags);
+    }
     const data = await apiPost(
       ctx,
       '/api/v1/agent/hummingbot/executors',
@@ -69,11 +90,91 @@ export function createHummingbotCommands({ printEnvelope }) {
     printEnvelope({ success: true, data, meta: { apiBase: ctx.apiBase, orgId } });
   }
 
+  async function commandHummingbotExecutorStop(ctx, flags) {
+    const orgId = orgIdFromFlags(flags);
+    const agentApiKey = agentApiKeyFromFlags(flags, ctx);
+    const userDid = userDidFromFlags(flags);
+    const executorId = String(flags.executorId || flags.executor_id || '').trim();
+    const params = parseJsonFlag(flags, 'params') || {};
+    if (!agentApiKey || !userDid) {
+      failMissingIdentity(printEnvelope, ctx, 'Provide --agent-api-key and --user-did for governed executor stop');
+    }
+    if (!executorId) {
+      printEnvelope({
+        success: false,
+        code: 'MISSING_EXECUTOR_ID',
+        message: 'Provide --executor-id for governed executor stop',
+        data: {},
+        meta: { apiBase: ctx.apiBase, orgId },
+      });
+      process.exit(1);
+    }
+    const body = {
+      ...params,
+      orgId,
+      userDid,
+    };
+    if (runtimeIdFromFlags(flags)) {
+      body.runtimeId = runtimeIdFromFlags(flags);
+    }
+    const data = await apiPost(
+      ctx,
+      `/api/v1/agent/hummingbot/executors/${encodeURIComponent(executorId)}/stop`,
+      body,
+      { 'x-agent-api-key': agentApiKey }
+    );
+    printEnvelope({ success: true, data, meta: { apiBase: ctx.apiBase, orgId, executorId } });
+  }
+
+  async function runHummingbotGatewayCatalogRead(ctx, flags, action) {
+    if (!commandRun) {
+      printEnvelope({
+        success: false,
+        code: 'COMMAND_RUN_UNAVAILABLE',
+        message: 'Gateway catalog reads require the agent run handler',
+        data: {},
+        meta: { apiBase: ctx.apiBase },
+      });
+      process.exit(1);
+    }
+    const agentApiKey = agentApiKeyFromFlags(flags, ctx);
+    const userDid = userDidFromFlags(flags);
+    if (!agentApiKey || !userDid) {
+      failMissingIdentity(
+        printEnvelope,
+        ctx,
+        'Provide --agent-api-key and --user-did for Gateway discovery reads'
+      );
+    }
+    const capabilities = await negotiateCapabilities(ctx);
+    if (!flags.runMode) flags.runMode = 'thirdfy';
+    flags.provider = 'hummingbot';
+    flags.action = action;
+    const params = parseJsonFlag(flags, 'params') || {};
+    flags.params = JSON.stringify({
+      orgId: orgIdFromFlags(flags),
+      ...(runtimeIdFromFlags(flags) ? { runtimeId: runtimeIdFromFlags(flags) } : {}),
+      ...params,
+    });
+    await commandRun(ctx, flags, capabilities);
+  }
+
+  async function commandHummingbotGatewayNetworks(ctx, flags) {
+    await runHummingbotGatewayCatalogRead(ctx, flags, 'get_hummingbot_gateway_networks');
+  }
+
+  async function commandHummingbotGatewayConnectors(ctx, flags) {
+    await runHummingbotGatewayCatalogRead(ctx, flags, 'get_hummingbot_gateway_connectors');
+  }
+
   return {
     commandHummingbotStatus,
     commandHummingbotConnectors,
     commandHummingbotExecutorSchema,
     commandHummingbotExecutorCreate,
+    commandHummingbotExecutorStop,
+    commandHummingbotGatewayNetworks,
+    commandHummingbotGatewayConnectors,
     resolveHummingbotAgentKey: resolveConfigAgentKey,
   };
 }

package/src/commands/index.mjs

@@ -2,6 +2,7 @@ export { createPolymarketCommands, resolveConfigAgentKey } from './polymarket.mj
 export { createHyperliquidHelpers } from './hyperliquid.mjs';
 export { createLighterHelpers } from './lighter.mjs';
 export { createHummingbotCommands } from './hummingbot.mjs';
+export { createCondorCommands } from './condor.mjs';
 export { createExecuteCommands } from './execute.mjs';
 export { createWalletCommands } from './wallet.mjs';
 export { createDelegationCommands } from './delegation.mjs';

package/src/core/readOnlyActions.mjs

@@ -14,6 +14,11 @@ const READ_ONLY_EXACT = new Set([
   'dogeos_laika_read_contract',
   'dogeos_laika_token_state',
   'prepare_polymarket_onboarding',
+  'create_polymarket_bridge_deposit',
+  'create_polymarket_bridge_withdraw',
+  'get_condor_policy_status',
+  'get_hummingbot_gateway_networks',
+  'get_hummingbot_gateway_connectors',
 ]);
 
 export function normalizeActionKey(actionKey) {

package/src/runtime/execution/lanes.mjs

@@ -19,13 +19,21 @@ const OFFCHAIN_VENUE_ORDER_ACTIONS = new Set([
   'update-lighter-margin',
   'place_polymarket_order',
   'place-polymarket-order',
+  'hummingbot_executor_create',
+  'hummingbot-executor-create',
+  'hummingbot_executor_stop',
+  'hummingbot-executor-stop',
+  'condor_executor_create',
+  'condor-executor-create',
+  'condor_executor_stop',
+  'condor-executor-stop',
 ]);
 function enforceOffchainVenueLaneCompatibility(action, runMode) {
   const normalizedAction = String(action || '').trim().toLowerCase();
   if (runMode !== 'self' || !OFFCHAIN_VENUE_ORDER_ACTIONS.has(normalizedAction)) return;
   throw createCliError(
     'OFFCHAIN_VENUE_ORDER_SELF_UNSUPPORTED',
-    'Polymarket CLOB, Hyperliquid perps, and Lighter perps orders are offchain signed API actions, not EVM build-tx actions. Use self for setup/funding signatures, then run venue orders with --run-mode thirdfy, --run-mode hybrid, or --run-mode agent_wallet.',
+    'Polymarket CLOB, Hyperliquid perps, Lighter perps, Hummingbot executor, and Condor executor actions are offchain signed API actions, not EVM build-tx actions. Use self for setup/funding signatures, then run venue orders with --run-mode thirdfy, --run-mode hybrid, or --run-mode agent_wallet.',
     {
       recommendedRunModes: ['thirdfy', 'hybrid', 'agent_wallet'],
       setupOnlyRunMode: 'self',

package/src/runtime/handlers.mjs

@@ -1,6 +1,7 @@
 import { negotiateCapabilities } from '../core/http.mjs';
 import { createPolymarketCommands } from '../commands/polymarket.mjs';
 import { createHummingbotCommands } from '../commands/hummingbot.mjs';
+import { createCondorCommands } from '../commands/condor.mjs';
 import { createHyperliquidHelpers } from '../commands/hyperliquid.mjs';
 import { createLighterHelpers } from '../commands/lighter.mjs';
 import { createExecuteCommands } from '../commands/execute.mjs';
@@ -177,6 +178,12 @@ export function createRuntimeHandlers(deps) {
 
   const __hummingbot = createHummingbotCommands({
     printEnvelope,
+    commandRun: __execute.commandRun,
+  });
+
+  const __condor = createCondorCommands({
+    commandRun: __execute.commandRun,
+    printEnvelope,
   });
 
   const __bootstrap = createBootstrapCommands({
@@ -201,6 +208,7 @@ export function createRuntimeHandlers(deps) {
     ...__consoleMandate,
     ...__polymarket,
     ...__hummingbot,
+    ...__condor,
     ...__bootstrap,
     ...__discovery,
     ...__telemetry,

package/src/runtime/providerHints.mjs

@@ -248,6 +248,8 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
           'get_polymarket_order',
           'get_polymarket_user_orders',
           'get_polymarket_user_positions',
+          'get_polymarket_bridge_supported_assets',
+          'get_polymarket_bridge_status',
         ],
         discoveryFlow: [
           'get_polymarket_tags or search_polymarket',
@@ -255,7 +257,10 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
           'get_polymarket_market or get_polymarket_markets',
           'get_polymarket_order_book',
           'get_polymarket_prices or get_polymarket_price_history',
-          'get_polymarket_setup_status and get_polymarket_onboarding_plan before place_polymarket_order',
+          'get_polymarket_funding_status with agentKey (check deposit pUSD + nested setup status)',
+          'when Base USDC is on execution wallet: create_polymarket_bridge_deposit then execute_polymarket_bridge_deposit with confirm=true',
+          'get_polymarket_bridge_status until pUSD lands',
+          'get_polymarket_setup_status with agentKey (check liveOrderReady + apiExecutionGeoblockReady) before place_polymarket_order',
         ],
         orderManagementActions: [
           'place_polymarket_order',
@@ -267,6 +272,8 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
         setupActions: [
           'get_polymarket_setup_status',
           'get_polymarket_onboarding_plan',
+          'create_polymarket_bridge_deposit',
+          'execute_polymarket_bridge_deposit',
           'agent_wallet_setup:ensure_agent_wallet_deposit_wallet',
           'agent_wallet_setup:deploy_deposit_wallet_and_set_approvals',
           'agent_wallet_setup:create_or_derive_clob_credentials',
@@ -281,15 +288,18 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
         ],
         recoveryActions: [
           'get_polymarket_recovery_status',
+          'create_polymarket_bridge_withdraw',
+          'execute_polymarket_bridge_withdraw',
+          'get_polymarket_bridge_status',
           'withdraw_polymarket_collateral',
         ],
         decommissionExample:
-          'get_polymarket_recovery_status -> withdraw_polymarket_collateral -> withdraw-to-user',
+          'get_polymarket_recovery_status -> create_polymarket_bridge_withdraw -> execute_polymarket_bridge_withdraw -> withdraw-to-user',
         credentialType: 'polymarket_clob',
         credentialUx:
           'Autonomous agents use an agent-owned Privy wallet and Polymarket deposit wallet first: Thirdfy creates the agent wallet, deploys/approves the deposit wallet, and stores encrypted CLOB credentials once Polymarket key creation is available. User-owned browser setup remains optional for interactive capital.',
         funding:
-          'Fund the agent-owned Polymarket deposit wallet with Polygon pUSD after deployment and approvals. If users start with Base USDC, route Base USDC -> Polygon pUSD to the deposit wallet recipient before CLOB order placement.',
+          'Fund the agent-owned Polymarket deposit wallet with Polygon pUSD after deployment and approvals. If users start with Base USDC, use Polymarket official Bridge (create/execute_polymarket_bridge_deposit). Li.Fi is legacy fallback only.',
         laneCompatibility:
           'Use agent_wallet as the preferred autonomous-agent path. Use self only for user-owned setup/funding signatures. CLOB orders should use thirdfy, hybrid, or agent_wallet after polymarket_clob credentials are stored.',
         setupBlockers: [
@@ -490,6 +500,39 @@ export function createProviderHints({ getNegotiatedCapabilitiesCache }) {
         supportedChains: [1, 10, 100, 130, 137, 42220, 8453, 42161, 4663],
       };
     }
+    if (provider === 'hummingbot') {
+      return {
+        provider,
+        category: 'hummingbot',
+        canonicalWriteAction: 'hummingbot_executor_create',
+        readActions: [
+          'get_hummingbot_connectors',
+          'get_hummingbot_executor_schema',
+          'get_hummingbot_gateway_networks',
+          'get_hummingbot_gateway_connectors',
+        ],
+        orderManagementActions: ['hummingbot_executor_create', 'hummingbot_executor_stop'],
+        setupActions: ['get_hummingbot_connectors', 'get_hummingbot_gateway_networks', 'get_hummingbot_gateway_connectors'],
+        laneCompatibility:
+          'Hummingbot executor create/stop and Gateway reads are offchain API actions. Use thirdfy, hybrid, or agent_wallet for writes; self is setup-only.',
+        example:
+          'thirdfy-agent hummingbot gateway-networks && thirdfy-agent hummingbot executor-stop --executor-id <id>',
+      };
+    }
+    if (provider === 'condor') {
+      return {
+        provider,
+        category: 'condor',
+        canonicalWriteAction: 'condor_executor_create',
+        readActions: ['get_condor_policy_status'],
+        orderManagementActions: ['condor_executor_create', 'condor_executor_stop'],
+        setupActions: ['get_condor_policy_status'],
+        laneCompatibility:
+          'Condor Pattern A reserves day notional before executor create. Use thirdfy or agent_wallet for writes; run condor preflight for governance reservation.',
+        example:
+          'thirdfy-agent condor policy-status && thirdfy-agent condor preflight --estimated-amount-usd 25 --idempotency-key <key>',
+      };
+    }
     if (provider === 'market-data') {
       return {
         provider,