@thirdfy/agent-cli 0.2.73 → 0.2.76

package/CHANGELOG.md

@@ -2,7 +2,26 @@
 
 All notable changes to `@thirdfy/agent-cli` are documented here. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.2.76] - 2026-09-23
+
+### Fixed
+
+- Managed writes (perps orders, TP/SL updates, closes) use a 90s HTTP timeout instead of the 30s default. They sign, broadcast, and wait for a receipt in one API call. Reads keep the base timeout; onboarding, earn, and bridge actions keep 180s. Override: `THIRDFY_CLI_WRITE_TIMEOUT_MS` (or `THIRDFY_API_WRITE_TIMEOUT_MS`).
+- `requestJson` resends a timed-out request only when it is a GET, a validation-only preview (`validationOnly` or `executionLane: validation_only`), or marked `writeAction: false` (read rail, build-tx, telemetry, governance preflight, execute-intent preflight). Every other POST (venue fund, delegation, onboarding) returns `WRITE_OUTCOME_UNKNOWN` instead of a second send. Read/write classification uses catalog metadata when the resolved action is available.
+- Avantis market open/close (`place_avantis_perps_order`, `close_avantis_position`) use the 180s long timeout; the API streams, then polls, for up to about 180s.
+- A write whose request times out is not resent. The retry could double a trade that already executed. The CLI throws `WRITE_OUTCOME_UNKNOWN` (`nextAction: reread_state_before_retry`). Preflight (`validationOnly`) and reads still retry once. Pin: `test/actionTimeouts.test.cjs`. Pairs with `thirdfy-mcp` **0.0.125**.
+
+## [0.2.75] - 2026-09-21
+
+### Fixed
+
+- World ID complete commands no longer attach the tracking option bundle, which duplicated `--network` and `--proof` and crashed CLI startup. Deposit begin registers `--runtime-id`, `--amount-usd`, and `--destination-address`. Chain id comes from the chains bundle. Pairs with `thirdfy-mcp` **0.0.124**.
+
+## [0.2.74] - 2026-09-21
+
+### Added
+
+- World ID deposit proof commands: `delegation world-id-begin`, `delegation world-id-complete`, `delegation world-id-deposit-begin`, `delegation world-id-deposit-complete`. Pins: `test/delegation-world-id.test.cjs`. Pairs with `thirdfy-mcp` **0.0.124** and Thirdfy API deposit receipt routes.
 
 ## [0.2.73] - 2026-09-21
 

package/README.md

@@ -40,10 +40,10 @@ Run without global install:
 npx @thirdfy/agent-cli --help
 ```
 
-## What's new in v0.2.73
+## What's new in v0.2.76
 
-- Hyperliquid Circle CCTP ids `quote_hyperliquid_cctp_deposit` and `deposit_hyperliquid_cctp`. Managed execute signs those on `params.sourceChainId` with no default chain.
-- Provider hints follow API `setupHints` and `get_hyperliquid_funding_status` `nextAction` instead of hardcoded Arbitrum / Li.Fi.
+- Writes (orders, TP/SL updates, closes) get a 90s HTTP timeout instead of 30s. Override with `THIRDFY_CLI_WRITE_TIMEOUT_MS`.
+- A write whose request times out is no longer resent. The CLI reports `WRITE_OUTCOME_UNKNOWN`: re-read positions before retrying.
 - See [CHANGELOG.md](./CHANGELOG.md) and GitHub Releases for older versions.
 
 ## Quick start

package/package.json

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

package/src/cli/help.mjs

@@ -30,6 +30,10 @@ Core commands:
   thirdfy-agent delegation balance [--auth-token <token> | --owner-session-token <token>] --agent-key <key> [--chain-id <id>] [--json]
   thirdfy-agent delegation revoke [--auth-token <token> | --owner-session-token <token>] --agent-key <key> [--reason <text>] [--chain-id <id>] [--json]
   thirdfy-agent delegation redeem --agent-api-key <key> --action <id> --params <json> [--run-mode thirdfy|hybrid|agent_wallet] [--estimated-amount-usd <usd>] [--json]
+  thirdfy-agent delegation world-id-begin [--auth-token <token> | --owner-session-token <token>] --agent-key <key> [--chain-id <id>] [--json]
+  thirdfy-agent delegation world-id-complete [--auth-token <token> | --owner-session-token <token>] --agent-key <key> --proof <json> [--chain-id <id>] [--json]
+  thirdfy-agent delegation world-id-deposit-begin [--auth-token <token> | --owner-session-token <token>] --org-id <uuid> --runtime-id <uuid> [--amount-usd <usd>] [--destination-address <addr>] [--deposit-signal <id>] [--chain-id <id>] [--json]
+  thirdfy-agent delegation world-id-deposit-complete [--auth-token <token> | --owner-session-token <token>] --org-id <uuid> --proof <json> [--chain-id <id>] [--json]
   thirdfy-agent managed wallet init [--auth-token <token> | --owner-session-token <token>] [--chain-id <id>] [--json]
   thirdfy-agent managed wallet grant [--auth-token <token> | --owner-session-token <token>] --agent-key <key> --token-address <addr> --max-usd-per-day <usd> [--chain-id <id>] [--period-duration <sec>] [--expiry-seconds <sec>] [--json]
   thirdfy-agent managed setup [--auth-token <token> | --owner-session-token <token>] --agent-key <key> [--run-mode thirdfy|hybrid|agent_wallet] [--token-address <addr>] [--max-usd-per-day <usd>] [--chain-id <id>] [--json]

package/src/cli/manifest.mjs

@@ -412,6 +412,34 @@ export const CLI_MANIFEST = [
     options: ['auth', 'delegation'],
     description: 'Revoke delegation',
   },
+  {
+    path: ['delegation', 'world-id-begin'],
+    handler: 'commandDelegationWorldIdBegin',
+    tier: 'online',
+    options: ['auth', 'delegation', 'chains'],
+    description: 'Begin World ID proof for an agent delegation',
+  },
+  {
+    path: ['delegation', 'world-id-complete'],
+    handler: 'commandDelegationWorldIdComplete',
+    tier: 'online',
+    options: ['auth', 'delegation', 'chains'],
+    description: 'Complete World ID proof for an agent delegation',
+  },
+  {
+    path: ['delegation', 'world-id-deposit-begin'],
+    handler: 'commandDelegationWorldIdDepositBegin',
+    tier: 'online',
+    options: ['auth', 'delegation', 'chains'],
+    description: 'Begin World ID deposit proof for an organization',
+  },
+  {
+    path: ['delegation', 'world-id-deposit-complete'],
+    handler: 'commandDelegationWorldIdDepositComplete',
+    tier: 'online',
+    options: ['auth', 'delegation', 'chains'],
+    description: 'Complete World ID deposit proof for an organization',
+  },
   {
     path: ['delegation', 'redeem'],
     handler: 'commandDelegationRedeem',

package/src/cli/options/delegation.mjs

@@ -20,5 +20,11 @@ export function attachDelegationOptions(cmd) {
     .option('--verify', 'verify on-chain')
     .option('--include-onchain', 'include on-chain data')
     .option('--onchain', 'alias for include on-chain')
-    .option('--reason <text>', 'revoke reason');
+    .option('--reason <text>', 'revoke reason')
+    .option('--org-id <id>', 'EarnOrg organization id')
+    .option('--runtime-id <id>', 'EarnOrg runtime id')
+    .option('--amount-usd <usd>', 'deposit amount in USD')
+    .option('--destination-address <addr>', 'agent destination address')
+    .option('--deposit-signal <signal>', 'deposit proof signal (deposit:...)')
+    .option('--proof <json>', 'World ID proof JSON');
 }

package/src/commands/condor.mjs

@@ -108,7 +108,8 @@ export function createCondorCommands({ commandRun, printEnvelope }) {
         ...params,
       },
     };
-    const data = await apiPost(ctx, '/api/v1/agent/governance/preflight', body, {
+    // Preflight only evaluates policy, so a timed-out request is safe to resend.
+    const data = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/governance/preflight', body, {
       'x-agent-api-key': agentApiKey,
     });
     printEnvelope({

package/src/commands/delegation.mjs

@@ -326,6 +326,101 @@ async function commandDelegationBalance(ctx, flags, capabilities) {
 }
 
 
+async function commandDelegationWorldIdBegin(ctx, flags, capabilities) {
+  const authHeaders = buildOwnerAuthHeaders(
+    flags,
+    'Missing --auth-token/--owner-session-token (or THIRDFY_AUTH_TOKEN/THIRDFY_OWNER_SESSION_TOKEN) for delegation world-id-begin'
+  );
+  const payload = {
+    agentKey: requireFlag(flags, 'agentKey', 'Missing --agent-key'),
+    chainId: Number(flags.chainId || 8453),
+  };
+  const response = await apiPost(ctx, '/api/v1/agent/delegation/world-id/begin', payload, {
+    ...authHeaders,
+  });
+  const success = Boolean(response?.success !== false);
+  printEnvelope({
+    success,
+    code: success ? 'DELEGATION_WORLD_ID_BEGIN_OK' : 'DELEGATION_WORLD_ID_BEGIN_FAILED',
+    message: response?.message || (success ? 'World ID agent challenge started' : 'World ID agent begin failed'),
+    data: response,
+    meta: { apiBase: ctx.apiBase, capabilitiesVersion: capabilities?.contractVersion || null },
+  });
+}
+
+async function commandDelegationWorldIdComplete(ctx, flags, capabilities) {
+  const authHeaders = buildOwnerAuthHeaders(
+    flags,
+    'Missing --auth-token/--owner-session-token (or THIRDFY_AUTH_TOKEN/THIRDFY_OWNER_SESSION_TOKEN) for delegation world-id-complete'
+  );
+  const payload = {
+    agentKey: requireFlag(flags, 'agentKey', 'Missing --agent-key'),
+    chainId: Number(flags.chainId || 8453),
+    proof: parseJsonFlag(flags, 'proof'),
+  };
+  const response = await apiPost(ctx, '/api/v1/agent/delegation/world-id/complete', payload, {
+    ...authHeaders,
+  });
+  const success = Boolean(response?.success !== false);
+  printEnvelope({
+    success,
+    code: success ? 'DELEGATION_WORLD_ID_COMPLETE_OK' : 'DELEGATION_WORLD_ID_COMPLETE_FAILED',
+    message: response?.message || (success ? 'World ID agent proof recorded' : 'World ID agent complete failed'),
+    data: response,
+    meta: { apiBase: ctx.apiBase, capabilitiesVersion: capabilities?.contractVersion || null },
+  });
+}
+
+async function commandDelegationWorldIdDepositBegin(ctx, flags, capabilities) {
+  const authHeaders = buildOwnerAuthHeaders(
+    flags,
+    'Missing --auth-token/--owner-session-token (or THIRDFY_AUTH_TOKEN/THIRDFY_OWNER_SESSION_TOKEN) for delegation world-id-deposit-begin'
+  );
+  const payload = {
+    orgId: requireFlag(flags, 'orgId', 'Missing --org-id'),
+    chainId: Number(flags.chainId || 8453),
+  };
+  if (flags.runtimeId) payload.runtimeId = String(flags.runtimeId).trim();
+  if (flags.amountUsd != null) payload.amountUsd = Number(flags.amountUsd);
+  if (flags.destinationAddress) payload.destinationAddress = String(flags.destinationAddress).trim();
+  if (flags.depositSignal) payload.depositSignal = String(flags.depositSignal).trim();
+  if (flags.idempotencyKey) payload.idempotencyKey = String(flags.idempotencyKey).trim();
+  const response = await apiPost(ctx, '/api/v1/agent/delegation/world-id/deposit/begin', payload, {
+    ...authHeaders,
+  });
+  const success = Boolean(response?.success !== false);
+  printEnvelope({
+    success,
+    code: success ? 'DELEGATION_WORLD_ID_DEPOSIT_BEGIN_OK' : 'DELEGATION_WORLD_ID_DEPOSIT_BEGIN_FAILED',
+    message: response?.message || (success ? 'World ID deposit challenge started' : 'World ID deposit begin failed'),
+    data: response,
+    meta: { apiBase: ctx.apiBase, capabilitiesVersion: capabilities?.contractVersion || null },
+  });
+}
+
+async function commandDelegationWorldIdDepositComplete(ctx, flags, capabilities) {
+  const authHeaders = buildOwnerAuthHeaders(
+    flags,
+    'Missing --auth-token/--owner-session-token (or THIRDFY_AUTH_TOKEN/THIRDFY_OWNER_SESSION_TOKEN) for delegation world-id-deposit-complete'
+  );
+  const payload = {
+    orgId: requireFlag(flags, 'orgId', 'Missing --org-id'),
+    chainId: Number(flags.chainId || 8453),
+    proof: parseJsonFlag(flags, 'proof'),
+  };
+  const response = await apiPost(ctx, '/api/v1/agent/delegation/world-id/deposit/complete', payload, {
+    ...authHeaders,
+  });
+  const success = Boolean(response?.success !== false);
+  printEnvelope({
+    success,
+    code: success ? 'DELEGATION_WORLD_ID_DEPOSIT_COMPLETE_OK' : 'DELEGATION_WORLD_ID_DEPOSIT_COMPLETE_FAILED',
+    message: response?.message || (success ? 'World ID deposit proof recorded' : 'World ID deposit complete failed'),
+    data: response,
+    meta: { apiBase: ctx.apiBase, capabilitiesVersion: capabilities?.contractVersion || null },
+  });
+}
+
 async function commandDelegationRedeem(ctx, flags, capabilities) {
   const selectedRunMode = getEffectiveRunMode(ctx, flags);
   if (!['thirdfy', 'hybrid', 'agent_wallet'].includes(selectedRunMode)) {
@@ -350,6 +445,10 @@ async function commandDelegationRedeem(ctx, flags, capabilities) {
     commandDelegationInspect,
     commandDelegationRevoke,
     commandDelegationBalance,
+    commandDelegationWorldIdBegin,
+    commandDelegationWorldIdComplete,
+    commandDelegationWorldIdDepositBegin,
+    commandDelegationWorldIdDepositComplete,
     commandDelegationRedeem,
   };
 }

package/src/commands/telemetry.mjs

@@ -122,7 +122,7 @@ async function commandTrackAction(ctx, flags, capabilities) {
   if (flags.decision) payload.decision = parseJsonFlag(flags, 'decision');
   if (flags.proof) payload.proof = parseJsonFlag(flags, 'proof');
 
-  const response = await apiPost(ctx, '/api/v1/agent/telemetry/actions', payload);
+  const response = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/telemetry/actions', payload);
   printEnvelope({
     success: Boolean(response?.success !== false),
     code: response?.success === false ? 'TRACK_ACTION_FAILED' : 'TRACK_ACTION_OK',

package/src/core/actionTimeouts.mjs

@@ -1,4 +1,12 @@
 import { DEFAULT_TIMEOUT_MS } from './constants.mjs';
+import { isReadOnlyActionName, isReadOnlyResolvedAction } from './readOnlyActions.mjs';
+
+/**
+ * Default HTTP timeout for managed writes. A perps order or TP/SL update signs, broadcasts, and waits
+ * for a receipt inside one API call; that routinely takes longer than a read. Mirrors thirdfy-mcp
+ * `THIRDFY_API_WRITE_TIMEOUT_MS`.
+ */
+const DEFAULT_WRITE_TIMEOUT_MS = 90_000;
 
 const LONG_RUNNING_ACTIONS = new Set([
   'complete_avantis_onboarding',
@@ -21,6 +29,10 @@ const LONG_RUNNING_ACTIONS = new Set([
   'swap',
   'execute_optimal_swap',
   'deposit_hyperliquid_cctp',
+  // Avantis market open/close: the API streams the batched order for up to 90s, then polls its
+  // tracking status for up to 90s more before it answers.
+  'place_avantis_perps_order',
+  'close_avantis_position',
 ]);
 
 function normalizeActionId(action) {
@@ -30,17 +42,51 @@ function normalizeActionId(action) {
     .toLowerCase();
 }
 
-/** Longer HTTP timeout for Avantis/Lighter onboarding, Avantis setup-status compose, and Morpho/Aave earn writes. */
-export function resolveActionTimeoutMs(action, baseTimeoutMs = DEFAULT_TIMEOUT_MS) {
+function positiveEnvMs(...names) {
+  for (const name of names) {
+    const value = Number(process.env[name]);
+    if (Number.isFinite(value) && value > 0) return value;
+  }
+  return null;
+}
+
+/** True when the action changes state (anything the read-only classifier does not claim). */
+export function isWriteAction(action) {
+  const key = normalizeActionId(action);
+  return Boolean(key) && !isReadOnlyActionName(key);
+}
+
+/**
+ * HTTP timeout for one action. Long-running onboarding, earn, bridge, and compose actions get the
+ * long timeout. Other writes get the write timeout (90s). Reads keep the base timeout. Pass
+ * `options.write` when the caller already classified the action (catalog metadata).
+ */
+export function resolveActionTimeoutMs(action, baseTimeoutMs = DEFAULT_TIMEOUT_MS, options = {}) {
   const base = Number.isFinite(baseTimeoutMs) && baseTimeoutMs > 0 ? baseTimeoutMs : DEFAULT_TIMEOUT_MS;
-  if (!LONG_RUNNING_ACTIONS.has(normalizeActionId(action))) return base;
-  const longMs = Number(
-    process.env.THIRDFY_CLI_LONG_TIMEOUT_MS || process.env.THIRDFY_API_LONG_TIMEOUT_MS || 180_000,
-  );
-  const resolvedLong = Number.isFinite(longMs) && longMs > 0 ? longMs : 180_000;
-  return Math.max(base, resolvedLong);
+  if (LONG_RUNNING_ACTIONS.has(normalizeActionId(action))) {
+    const longMs = positiveEnvMs('THIRDFY_CLI_LONG_TIMEOUT_MS', 'THIRDFY_API_LONG_TIMEOUT_MS') ?? 180_000;
+    return Math.max(base, longMs);
+  }
+  const write = typeof options.write === 'boolean' ? options.write : isWriteAction(action);
+  if (write) {
+    const writeMs =
+      positiveEnvMs('THIRDFY_CLI_WRITE_TIMEOUT_MS', 'THIRDFY_API_WRITE_TIMEOUT_MS') ?? DEFAULT_WRITE_TIMEOUT_MS;
+    return Math.max(base, writeMs);
+  }
+  return base;
 }
 
-export function withActionTimeout(ctx, action) {
-  return { ...ctx, timeoutMs: resolveActionTimeoutMs(action, ctx.timeoutMs) };
+/**
+ * Context for one action's HTTP calls. Accepts the action id or the resolved catalog action, whose
+ * metadata can mark a read the name does not. `writeAction` tells `requestJson` not to resend a
+ * write whose request timed out: the API may have broadcast it, so the outcome is unknown until
+ * state is re-read.
+ */
+export function withActionTimeout(ctx, actionOrResolved) {
+  const resolved = actionOrResolved && typeof actionOrResolved === 'object' ? actionOrResolved : null;
+  const action = resolved ? resolved.resolvedAction : actionOrResolved;
+  const write = resolved
+    ? Boolean(normalizeActionId(action)) && !isReadOnlyResolvedAction(resolved)
+    : isWriteAction(action);
+  return { ...ctx, timeoutMs: resolveActionTimeoutMs(action, ctx.timeoutMs, { write }), writeAction: write };
 }

package/src/core/http.mjs

@@ -12,6 +12,44 @@ function isRetryableApiStatus(statusCode) {
   return statusCode === 502 || statusCode === 503 || statusCode === 504;
 }
 
+function isTimeoutError(error) {
+  const message = String(error?.message || '').toLowerCase();
+  return error?.name === 'AbortError' || message.includes('abort') || message.includes('timeout');
+}
+
+/**
+ * A write whose request timed out may already be on chain. Resending it can double a trade, so the
+ * caller gets `WRITE_OUTCOME_UNKNOWN` and re-reads state before any retry.
+ */
+function writeOutcomeUnknownError(route, ctx, cause) {
+  const error = new Error(
+    `WRITE_OUTCOME_UNKNOWN: ${route} timed out after ${ctx.timeoutMs}ms; the write may have executed. Re-read state before retrying.`,
+  );
+  error.code = 'WRITE_OUTCOME_UNKNOWN';
+  error.statusCode = 504;
+  error.payload = { error: 'WRITE_OUTCOME_UNKNOWN', nextAction: 'reread_state_before_retry', timeoutMs: ctx.timeoutMs };
+  error.cause = cause;
+  return error;
+}
+
+/**
+ * Whether a request that timed out may be sent again. GETs, validation-only previews, and calls the
+ * caller marks `writeAction: false` are safe. Preflight sends `executionLane: validation_only`
+ * (not a `validationOnly` field). Any other POST changes state (an order, a venue funding, a
+ * delegation grant), so the default is not to resend it.
+ */
+function resendAfterTimeoutIsSafe(ctx, init) {
+  if (ctx?.writeAction === true) return false;
+  if (ctx?.writeAction === false) return true;
+  if (String(init?.method || 'GET').toUpperCase() !== 'POST') return true;
+  try {
+    const body = JSON.parse(String(init?.body || '{}'));
+    return body?.validationOnly === true || body?.executionLane === 'validation_only';
+  } catch {
+    return false;
+  }
+}
+
 function isRetryableApiError(error) {
   const statusCode = Number(error?.statusCode || 0);
   const message = String(error?.message || '').toLowerCase();
@@ -77,6 +115,9 @@ export async function requestJson(ctx, route, init) {
       return await requestJsonOnce(ctx, route, init);
     } catch (error) {
       lastError = error;
+      if (isTimeoutError(error) && !resendAfterTimeoutIsSafe(ctx, init)) {
+        throw writeOutcomeUnknownError(route, ctx, error);
+      }
       if (attempt === 0 && isRetryableApiError(error)) {
         await sleep(250 + Math.floor(Math.random() * 250));
         continue;

package/src/runtime/execution/runners.mjs

@@ -192,7 +192,7 @@ async function runPreflightByMode(runMode, ctx, flags, resolved, options = {}) {
         runMode: 'self',
         mirrorOnly: false,
       });
-      const response = await apiPost(ctx, '/api/v1/agent/execute-intent', payload);
+      const response = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/execute-intent', payload);
       const normalized = normalizeIntentResponse(response);
       const blockedCount = normalized.blocked || 0;
       if (!normalized.success || blockedCount > 0) {
@@ -240,7 +240,7 @@ async function runPreflightByMode(runMode, ctx, flags, resolved, options = {}) {
         mirrorOnly: false,
         hybridWalletMode: options.hybridWalletMode,
       });
-      const response = await apiPost(ctx, '/api/v1/agent/execute-intent', payload);
+      const response = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/execute-intent', payload);
       const normalized = normalizeIntentResponse(response);
       const blockedCount = normalized.blocked || 0;
       if (!normalized.success || blockedCount > 0) {
@@ -267,7 +267,7 @@ async function runPreflightByMode(runMode, ctx, flags, resolved, options = {}) {
         mirrorOnly: false,
         hybridWalletMode: 'agent_wallet',
       });
-      const managedResponse = await apiPost(ctx, '/api/v1/agent/execute-intent', managedPayload);
+      const managedResponse = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/execute-intent', managedPayload);
       const managedNormalized = normalizeIntentResponse(managedResponse);
       const mirrorPayload = buildIntentPayload(flags, {
         validationOnly: true,
@@ -277,7 +277,7 @@ async function runPreflightByMode(runMode, ctx, flags, resolved, options = {}) {
         mirrorOnly: true,
         hybridWalletMode: 'agent_wallet',
       });
-      const mirrorResponse = await apiPost(ctx, '/api/v1/agent/execute-intent', mirrorPayload);
+      const mirrorResponse = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/execute-intent', mirrorPayload);
       const mirrorNormalized = normalizeIntentResponse(mirrorResponse);
       return {
         message:
@@ -304,7 +304,7 @@ async function runPreflightByMode(runMode, ctx, flags, resolved, options = {}) {
     runMode,
     mirrorOnly: runMode === 'hybrid',
   });
-  const response = await apiPost(ctx, '/api/v1/agent/execute-intent', payload);
+  const response = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/execute-intent', payload);
   const normalized = normalizeIntentResponse(response);
   return {
     message: normalized.success
@@ -403,7 +403,7 @@ async function runExecutionByMode(runMode, ctx, flags, resolved, options) {
 
 async function executeThirdfyRun(ctx, flags, resolved, options, runMode = 'thirdfy') {
   const skipPreflight = Boolean(options?.skipPreflight);
-  const actionCtx = withActionTimeout(ctx, resolved.resolvedAction);
+  const actionCtx = withActionTimeout(ctx, resolved);
   if (!skipPreflight) {
     const preflightPayload = buildIntentPayload(flags, {
       validationOnly: true,
@@ -413,7 +413,12 @@ async function executeThirdfyRun(ctx, flags, resolved, options, runMode = 'third
       mirrorOnly: false,
       hybridWalletMode: options?.hybridWalletMode,
     });
-    const preflight = await apiPost(actionCtx, '/api/v1/agent/execute-intent', preflightPayload);
+    // validationOnly never writes, so a timed-out preflight is safe to resend.
+    const preflight = await apiPost(
+      { ...actionCtx, writeAction: false },
+      '/api/v1/agent/execute-intent',
+      preflightPayload,
+    );
     const preflightNormalized = normalizeIntentResponse(preflight);
     const blockedCount = preflightNormalized.blocked || 0;
     if (!preflightNormalized.success || blockedCount > 0) {
@@ -503,7 +508,7 @@ async function executeManagedWalletRun(ctx, flags, resolved, options) {
     runMode: 'agent_wallet',
     forceIdempotency: true,
   });
-  const actionCtx = withActionTimeout(ctx, resolved.resolvedAction);
+  const actionCtx = withActionTimeout(ctx, resolved);
   const response = await apiPost(actionCtx, '/api/v1/agent/execute', payload);
   if (shouldFallbackAgentWalletToExecuteIntent(resolved, response)) {
     const intentResult = await runReadOnlyActionViaIntentRail(ctx, flags, resolved, options, preflight);
@@ -539,7 +544,7 @@ async function executeSelfRun(ctx, flags, resolved, options) {
       runMode: 'self',
       mirrorOnly: false,
     });
-    const preflight = await apiPost(ctx, '/api/v1/agent/execute-intent', preflightPayload);
+    const preflight = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/execute-intent', preflightPayload);
     const preflightNormalized = normalizeIntentResponse(preflight);
     const blockedCount = preflightNormalized.blocked || 0;
     if (!preflightNormalized.success || blockedCount > 0) {
@@ -561,7 +566,8 @@ async function executeSelfRun(ctx, flags, resolved, options) {
     return normalized;
   }
   const buildTxPayload = buildBuildTxPayload(flags, resolved.resolvedAction);
-  const buildTx = await apiPost(ctx, '/api/v1/agent/build-tx', buildTxPayload);
+  // build-tx returns an unsigned transaction; nothing is broadcast, so a timeout may be resent.
+  const buildTx = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/build-tx', buildTxPayload);
   return normalizeIntentResponse({
     ...buildTx,
     status: buildTx?.status || 'ready',
@@ -598,7 +604,7 @@ async function executeHybridRun(ctx, flags, resolved, options) {
       mirrorOnly: true,
       hybridWalletMode,
     });
-    const mirrorResponse = await apiPost(ctx, '/api/v1/agent/execute-intent', mirrorPayload);
+    const mirrorResponse = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/execute-intent', mirrorPayload);
     const mirrorNormalized = normalizeIntentResponse(mirrorResponse);
     return normalizeIntentResponse({
       success: Boolean(managedResult.success && mirrorNormalized.success),
@@ -624,7 +630,7 @@ async function executeHybridRun(ctx, flags, resolved, options) {
     runMode: 'hybrid',
     mirrorOnly: true,
   });
-  const mirrorResponse = await apiPost(ctx, '/api/v1/agent/execute-intent', mirrorPayload);
+  const mirrorResponse = await apiPost({ ...ctx, writeAction: false }, '/api/v1/agent/execute-intent', mirrorPayload);
   const mirrorNormalized = normalizeIntentResponse(mirrorResponse);
   return normalizeIntentResponse({
     success: Boolean(selfResult.success && mirrorNormalized.success),