@vtxmacro/cli 2026.8.59 → 2026.9.2

package/bin/vtx.js

@@ -47,7 +47,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.8.59",
+      package_version: "2026.9.2",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -14827,6 +14827,7 @@ var init_external_inference_contract = __esm({
       authenticated_account_email: authenticatedAccountEmailSchema.nullable().optional(),
       authenticated_account_plan: safeCodeSchema.nullable().optional(),
       protocol_version: protocolVersionSchema,
+      host_runtime_version: protocolVersionSchema.optional(),
       envelope_public_key: base64Url32BytesSchema,
       health: external_exports.enum(["healthy", "degraded", "draining"]),
       advertised_at: timestampSchema,
@@ -15500,6 +15501,7 @@ var init_external_inference_contract = __esm({
       outcome: adapterOutcomeEvidenceSchema,
       latency_ms: nonNegativeSafeIntegerSchema,
       time_to_first_token_ms: nonNegativeSafeIntegerSchema.nullable(),
+      provider_dispatch_freshness_remaining_ms: nonNegativeSafeIntegerSchema.nullable().optional(),
       finish_reason: safeCodeSchema.nullable(),
       refusal_status: external_exports.enum(["none", "refused", "blocked", "unknown"]),
       completed_at: timestampSchema
@@ -15614,6 +15616,7 @@ var init_external_inference_contract = __esm({
       failure_category: safeCodeSchema,
       failure_code: safeCodeSchema,
       retryable: external_exports.boolean(),
+      provider_dispatch_freshness_remaining_ms: nonNegativeSafeIntegerSchema.nullable().optional(),
       process_exit: codexProcessExitDiagnosticsSchema.nullable().optional(),
       membership_disposition: external_exports.enum([
         "retry_same_host",
@@ -18250,7 +18253,8 @@ var init_mcp_client = __esm({
       job_id: identifierSchema2,
       attempt_id: identifierSchema2,
       attempt_index: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
-      state: safeCodeSchema2
+      state: safeCodeSchema2,
+      provider_dispatch_freshness_remaining_ms: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).nullable().optional()
     });
     agentConnectResultSchema = external_exports.strictObject({
       host: hostStatusReadSchema,
@@ -21267,6 +21271,15 @@ child.once('close', async (code, signal) => {
             retryable: false
           });
         }
+        if (options.notAfterMs !== void 0 && Date.now() > options.notAfterMs) {
+          throw new CodexAppServerError({
+            message: "Server account context expired before provider dispatch.",
+            category: "adapter",
+            code: "server_account_context_expired_before_provider_dispatch",
+            retryable: false,
+            dispatchOutcome: "not_dispatched"
+          });
+        }
         return await new Promise((resolve6, reject) => {
           const pending = { resolve: resolve6, reject, timer: null, abortCleanup: null };
           pending.timer = setTimeout(() => {
@@ -22182,6 +22195,7 @@ child.once('close', async (code, signal) => {
             }, {
               timeoutMs: remaining(),
               signal: request.signal,
+              notAfterMs: "providerDispatchNotAfterMs" in request ? request.providerDispatchNotAfterMs : void 0,
               beforeWrite: async (id2) => {
                 requestId = id2;
                 try {
@@ -22204,6 +22218,7 @@ child.once('close', async (code, signal) => {
               onWritten: (id2) => {
                 requestWritten = true;
                 requestId = id2;
+                if ("onProviderDispatch" in request) request.onProviderDispatch?.();
               }
             });
           } catch (error48) {
@@ -22994,6 +23009,14 @@ var init_codex_adapter = __esm({
           retryable: false
         });
       }
+      if (input.providerDispatchNotAfterMs !== void 0 && !Number.isSafeInteger(input.providerDispatchNotAfterMs)) {
+        throw new CodexAppServerError({
+          message: "Codex provider-dispatch freshness deadline is invalid.",
+          category: "adapter",
+          code: "server_provider_dispatch_fence_invalid",
+          retryable: false
+        });
+      }
       if (!CODEX_MODEL_NAME_PATTERN.test(input.requestedModel) || !CODEX_REASONING_EFFORT_PATTERN.test(input.requestedReasoningEffort)) {
         throw new CodexAppServerError({
           message: "Codex model selection is not a valid catalog identity.",
@@ -23781,6 +23804,8 @@ var init_codex_adapter = __esm({
             requestedModel: input.requestedModel,
             requestedReasoningEffort: input.requestedReasoningEffort,
             deadlineAtMs: input.deadlineAtMs,
+            providerDispatchNotAfterMs: input.providerDispatchNotAfterMs,
+            onProviderDispatch: input.onProviderDispatch,
             signal: input.signal,
             onDispatchState: async (state) => {
               currentDispatchOutcome = state.dispatchOutcome;
@@ -23823,7 +23848,7 @@ var init_codex_adapter = __esm({
             }
           }
           if (error48 instanceof CodexAppServerError) {
-            const dispatchOutcome = error48.dispatchOutcome === "not_dispatched" ? currentDispatchOutcome : error48.dispatchOutcome;
+            const dispatchOutcome = error48.code === "server_account_context_expired_before_provider_dispatch" ? "not_dispatched" : error48.dispatchOutcome === "not_dispatched" ? currentDispatchOutcome : error48.dispatchOutcome;
             if (baseCheckpoint && !completedResult) {
               latestCheckpoint = {
                 ...baseCheckpoint,
@@ -24531,6 +24556,16 @@ ${input.outputSchemaJson}`
             void session?.abort().catch(() => void 0);
           };
           input.signal?.addEventListener("abort", onAbort, { once: true });
+          if (input.providerDispatchNotAfterMs !== void 0 && Date.now() > input.providerDispatchNotAfterMs) {
+            throw new CodexAppServerError({
+              message: "Server account context expired before provider dispatch.",
+              category: "adapter",
+              code: "server_account_context_expired_before_provider_dispatch",
+              retryable: false,
+              dispatchOutcome: "not_dispatched"
+            });
+          }
+          input.onProviderDispatch?.();
           dispatchEntered = true;
           let response;
           try {
@@ -25345,6 +25380,14 @@ var init_deepseek_harness_adapter = __esm({
           const blocks = [];
           let usage = null;
           let finish = null;
+          if (input.providerDispatchNotAfterMs !== void 0 && Date.now() > input.providerDispatchNotAfterMs) {
+            throw nonDispatchedError(
+              "Server account context expired before provider dispatch.",
+              "transport",
+              "server_account_context_expired_before_provider_dispatch"
+            );
+          }
+          input.onProviderDispatch?.();
           for await (const chunk of adapter.stream({
             provider: "deepseek-official",
             model: input.requestedModel,
@@ -32458,7 +32501,7 @@ function createDefaultInferenceHostRunnerDependencies(options) {
     envelopePublicKey: options.envelopePublicKey
   };
 }
-var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS, DEFAULT_AGENT_QUOTA_COOLDOWN_MS, DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, publicServerFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, isDefinitiveCompletionEvidenceExpiry, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createInferenceAgentControlClient, INFERENCE_AGENT_SYSTEM_PROMPT, INFERENCE_AGENT_WAKE_SCHEMA, parseInferenceAgentWake, InferenceAgentRuntime;
+var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, DEFAULT_AGENT_RATE_LIMIT_COOLDOWN_MS, DEFAULT_AGENT_QUOTA_COOLDOWN_MS, DEFAULT_AGENT_TRANSIENT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, serverProviderDispatchNotAfterMs, membershipFailureDisposition, safeFailureCode, publicServerFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, isDefinitiveCompletionEvidenceExpiry, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createInferenceAgentControlClient, INFERENCE_AGENT_SYSTEM_PROMPT, INFERENCE_AGENT_WAKE_SCHEMA, parseInferenceAgentWake, InferenceAgentRuntime;
 var init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -32815,7 +32858,7 @@ var init_runner = __esm({
       if (!options.displayName.trim() || options.displayName.length > 128) {
         throw new InferenceHostRunnerError("invalid_configuration", "Inference host display name is invalid.");
       }
-      if (!options.protocolVersion.trim() || !options.adapterRuntimeVersion.trim()) {
+      if (!options.protocolVersion.trim() || !options.adapterRuntimeVersion.trim() || options.hostRuntimeVersion !== void 0 && !options.hostRuntimeVersion.trim()) {
         throw new InferenceHostRunnerError("invalid_configuration", "Inference host version metadata is required.");
       }
       const advertisementTtlMs = finitePositiveOption(
@@ -32836,6 +32879,7 @@ var init_runner = __esm({
       }
       return {
         adapterId,
+        hostRuntimeVersion: options.hostRuntimeVersion ?? options.adapterRuntimeVersion,
         usageSource: options.usageSource ?? (adapterId === "codex" ? "codex_app_server" : adapterId),
         sameAttemptRecovery: options.sameAttemptRecovery ?? adapterId === "codex",
         agentRuntime: options.agentRuntime ?? null,
@@ -33023,10 +33067,37 @@ var init_runner = __esm({
         providerReasoningSummarySupported
       };
     };
+    serverProviderDispatchNotAfterMs = (jobInput) => {
+      if (jobInput.execution_mode !== "server") return void 0;
+      let context;
+      try {
+        context = JSON.parse(jobInput.context_json);
+      } catch {
+        throw new InferenceHostRunnerError(
+          "server_provider_dispatch_fence_invalid",
+          "The Server provider-dispatch freshness fence is invalid."
+        );
+      }
+      const contextObject = objectRecord(context);
+      if (!contextObject || !("server_provider_dispatch_fence" in contextObject)) {
+        return void 0;
+      }
+      const fence = objectRecord(contextObject.server_provider_dispatch_fence);
+      const rawNotAfter = fence?.provider_dispatch_not_after;
+      const notAfterMs = typeof rawNotAfter === "string" ? Date.parse(rawNotAfter) : NaN;
+      if (!Number.isFinite(notAfterMs)) {
+        throw new InferenceHostRunnerError(
+          "server_provider_dispatch_fence_invalid",
+          "The Server provider-dispatch freshness deadline is invalid."
+        );
+      }
+      return notAfterMs;
+    };
     membershipFailureDisposition = (failure) => {
       if (failure.dispatchOutcome === "outcome_unknown") return "quarantine_ambiguous";
       if (failure.category === "auth" || ["auth_expired", "managed_chatgpt_auth_required", "invalid_account_metadata"].includes(failure.code)) return "cascade_disable";
       if (failure.category === "quota" || ["quota_exceeded", "codex_rate_limited", "provider_rate_limited"].includes(failure.code)) return "cascade_cooldown";
+      if (failure.code === "codex_server_overloaded") return "cascade_cooldown";
       if (failure.retryable && (["adapter", "network", "transport"].includes(failure.category) || failure.code === "rpc_timeout")) return "retry_same_host";
       if (["model_unavailable", "reasoning_effort_unavailable"].includes(failure.code)) return "cascade_cooldown";
       if ([
@@ -33534,6 +33605,7 @@ var init_runner = __esm({
                   authenticated_account_email: this.options.authenticatedAccountEmail ?? null,
                   authenticated_account_plan: this.options.authenticatedAccountPlan ?? null,
                   protocol_version: this.options.protocolVersion,
+                  host_runtime_version: settings.hostRuntimeVersion,
                   envelope_public_key: envelopePublicKey,
                   health,
                   advertised_at: isoAt(advertisedAt),
@@ -33724,13 +33796,14 @@ var init_runner = __esm({
               const heartbeatAttemptedAt = now();
               const attemptedAdvertisementGeneration = receipt.advertisement_generation;
               try {
-                const expiresAt = receipt.advertisement_expires_at ? Date.parse(receipt.advertisement_expires_at) : 0;
-                const refreshPendingAcrossExpiry = receipt.pending_advertisement !== null && expiresAt <= heartbeatAttemptedAt;
                 await hostHeartbeat(
                   "healthy",
                   { signal: hostHeartbeatAbort.signal },
                   false,
-                  refreshPendingAcrossExpiry,
+                  // The server evaluates advertisement expiry when it receives
+                  // the heartbeat. A request sent just before expiry can therefore
+                  // truthfully return offline; the advertisement loop owns repair.
+                  true,
                   0,
                   attemptedAdvertisementGeneration
                 );
@@ -33884,6 +33957,15 @@ var init_runner = __esm({
                   active_attempts: active.size
                 });
               },
+              onProviderDispatch: (observation) => {
+                emitDiagnostic("provider_dispatch_freshness_passed", {
+                  ...observation,
+                  job_id: claim.job_id,
+                  attempt_id: attemptId,
+                  requested_model: claim.requested_model,
+                  active_attempts: active.size
+                });
+              },
               startRetryCount: nextStartRetryCount,
               onAttemptStartRetry: (observation) => {
                 attemptStartRetryCounts.set(attemptId, observation.retry_count);
@@ -34288,6 +34370,11 @@ var init_runner = __esm({
           credential.x25519_private_key,
           claim
         );
+        const serverProviderDispatchDeadlineMs = serverProviderDispatchNotAfterMs(jobInput);
+        let providerDispatchNotAfterMs = serverProviderDispatchDeadlineMs === void 0 ? void 0 : now() - 1;
+        let serverReportedFreshnessRemainingMs = null;
+        let startRoundTripMs = 0;
+        let providerDispatchFreshnessRemainingMs = null;
         const startRequest = options.resumeReceipt?.start_request ?? buildAttemptStartRequest(claim, attemptId, isoAt(now()));
         let attemptReceipt = options.resumeReceipt ? validateAttemptReceipt(options.resumeReceipt) : {
           schema_version: ATTEMPT_RECEIPT_SCHEMA_VERSION,
@@ -34311,19 +34398,7 @@ var init_runner = __esm({
             "The persisted same-attempt recovery scope is invalid."
           );
         }
-        if (!options.resumeReceipt) {
-          await options.updateReceipt((current) => {
-            const pendingClaimRequest = options.claimRequest && current.pending_claim_request?.claim_request_id === options.claimRequest.claim_request_id ? null : current.pending_claim_request ?? null;
-            return {
-              ...current,
-              pending_claim_request: pendingClaimRequest,
-              attempts: { ...current.attempts, [attemptId]: attemptReceipt },
-              updated_at: isoAt(now())
-            };
-          });
-          options.onClaimPersisted?.();
-        }
-        const updateAttempt = async (changes) => {
+        const persistAttempt = async (changes, clearPendingClaim = false) => {
           const nextAttemptReceipt = validateAttemptReceipt({
             ...attemptReceipt,
             ...changes,
@@ -34332,9 +34407,11 @@ var init_runner = __esm({
           attemptReceipt = nextAttemptReceipt;
           await options.updateReceipt((current) => ({
             ...current,
+            pending_claim_request: clearPendingClaim && options.claimRequest && current.pending_claim_request?.claim_request_id === options.claimRequest.claim_request_id ? null : current.pending_claim_request ?? null,
             attempts: { ...current.attempts, [attemptId]: nextAttemptReceipt },
             updated_at: isoAt(now())
           }));
+          if (clearPendingClaim) options.onClaimPersisted?.();
         };
         const removeAttempt = async () => {
           await options.updateReceipt((current) => {
@@ -34342,11 +34419,21 @@ var init_runner = __esm({
             delete attempts[attemptId];
             return {
               ...current,
+              pending_claim_request: options.claimRequest && current.pending_claim_request?.claim_request_id === options.claimRequest.claim_request_id ? null : current.pending_claim_request ?? null,
               attempts,
               updated_at: isoAt(now())
             };
           });
+          options.onClaimPersisted?.();
         };
+        let outputContract = null;
+        let inputValidationError;
+        try {
+          this.validateImmutableSelection(jobInput);
+          outputContract = parseOutputContract(jobInput);
+        } catch (error48) {
+          inputValidationError = error48;
+        }
         if (attemptReceipt.phase === "claimed") {
           const attemptDeadlineAtMs = Math.min(
             Date.parse(claim.deadline_at),
@@ -34357,6 +34444,7 @@ var init_runner = __esm({
             return "failed";
           }
           let startResult;
+          const startCallStartedAtMs = now();
           try {
             startResult = await retryExact(() => mcp.callTool(
               "inference.job.start",
@@ -34364,6 +34452,16 @@ var init_runner = __esm({
               { signal, deadlineAtMs: attemptDeadlineAtMs }
             ), { signal, deadlineAtMs: attemptDeadlineAtMs });
           } catch (error48) {
+            if (error48 instanceof ExternalInferenceMcpError && error48.serverFailureCode === "server_account_context_expired_before_provider_dispatch") {
+              await removeAttempt();
+              options.onAttemptOutcome?.({
+                outcome: "freshness_rejected_before_provider_dispatch",
+                failure_category: "freshness",
+                failure_code: error48.serverFailureCode,
+                dispatch_outcome: "not_dispatched"
+              });
+              return "failed";
+            }
             if (attemptDeadlineAtMs <= now() + MIN_CLAIM_START_WINDOW_MS) {
               await removeAttempt();
               return "failed";
@@ -34395,11 +34493,37 @@ var init_runner = __esm({
               retry_count: retryCount,
               next_delay_ms: retryDelayMs
             });
+            if (!options.resumeReceipt) {
+              await persistAttempt({ phase: "claimed" }, true);
+            }
             await options.sleep(retryDelayMs, signal);
             return "retry_claimed";
           }
           assertStartResult(startRequest, startResult);
-          await updateAttempt({ phase: "started" });
+          if (serverProviderDispatchDeadlineMs !== void 0) {
+            const serverRemaining = startResult.provider_dispatch_freshness_remaining_ms;
+            if (!Number.isSafeInteger(serverRemaining) || Number(serverRemaining) < 0) {
+              throw new InferenceHostRunnerError(
+                "provider_dispatch_freshness_receipt_invalid",
+                "The Server provider-dispatch freshness receipt is unavailable."
+              );
+            }
+            const startCallCompletedAtMs = now();
+            startRoundTripMs = Math.max(0, startCallCompletedAtMs - startCallStartedAtMs);
+            serverReportedFreshnessRemainingMs = Number(serverRemaining);
+            const conservativeRemainingMs = Math.max(
+              0,
+              serverReportedFreshnessRemainingMs - startRoundTripMs
+            );
+            providerDispatchNotAfterMs = startCallCompletedAtMs + conservativeRemainingMs;
+          }
+        }
+        if (attemptReceipt.phase !== "dispatched") {
+          const providerDispatchable = inputValidationError === void 0 && outputContract !== null;
+          await persistAttempt({
+            phase: providerDispatchable ? "dispatched" : "started",
+            dispatch_outcome: providerDispatchable ? "outcome_unknown" : "not_dispatched"
+          }, !options.resumeReceipt);
         }
         let adapterResult;
         let heartbeatFailure;
@@ -34432,7 +34556,7 @@ var init_runner = __esm({
               sequence,
               observed_at: isoAt(now())
             };
-            await updateAttempt({ job_heartbeat_sequence: sequence });
+            await persistAttempt({ job_heartbeat_sequence: sequence });
             const heartbeatDeadlineAtMs = Date.parse(claim.deadline_at);
             const directive = await retryExact(
               () => mcp.callTool(
@@ -34466,12 +34590,13 @@ var init_runner = __esm({
           await heartbeatLoop;
         };
         try {
-          this.validateImmutableSelection(jobInput);
-          const outputContract = parseOutputContract(jobInput);
-          await updateAttempt({
-            phase: "dispatched",
-            dispatch_outcome: "outcome_unknown"
-          });
+          if (inputValidationError !== void 0) throw inputValidationError;
+          if (outputContract === null) {
+            throw new InferenceHostRunnerError(
+              "invalid_output_schema",
+              "The external inference output contract is unavailable."
+            );
+          }
           if (options.resumeReceipt?.phase === "dispatched" && !sameAttemptRecovery) {
             throw new CodexAppServerError({
               message: `${adapterId} cannot prove the exact result of the interrupted attempt.`,
@@ -34490,9 +34615,24 @@ var init_runner = __esm({
             requestedModel: jobInput.requested_model,
             requestedReasoningEffort: jobInput.requested_reasoning_effort,
             deadlineAtMs: Date.parse(jobInput.deadline_at),
+            ...providerDispatchNotAfterMs === void 0 ? {} : { providerDispatchNotAfterMs },
+            ...providerDispatchNotAfterMs === void 0 ? {} : {
+              onProviderDispatch: () => {
+                providerDispatchFreshnessRemainingMs = Math.max(
+                  0,
+                  providerDispatchNotAfterMs - now()
+                );
+                options.onProviderDispatch?.({
+                  cycle_id: jobInput.runtime_binding?.cycle_id ?? "unavailable",
+                  freshness_remaining_ms: providerDispatchFreshnessRemainingMs,
+                  server_reported_remaining_ms: serverReportedFreshnessRemainingMs ?? 0,
+                  start_round_trip_ms: startRoundTripMs
+                });
+              }
+            },
             signal: attemptAbort.signal
           });
-          await updateAttempt({
+          await persistAttempt({
             phase: "dispatched",
             dispatch_outcome: "confirmed_dispatched"
           });
@@ -34598,6 +34738,7 @@ var init_runner = __esm({
             },
             latency_ms: adapterResult.latencyMs,
             time_to_first_token_ms: adapterResult.timeToFirstTokenMs,
+            provider_dispatch_freshness_remaining_ms: providerDispatchFreshnessRemainingMs,
             finish_reason: finishReason,
             refusal_status: refusalStatus,
             completed_at: isoAt(now())
@@ -34611,7 +34752,7 @@ var init_runner = __esm({
             response_mode: "decision_candidate",
             decision_candidate_sha256: resultEnvelope.plaintext_sha256
           });
-          await updateAttempt({
+          await persistAttempt({
             phase: "terminal_pending",
             terminal_operation_id: completionId,
             terminal_request: completion
@@ -34683,7 +34824,7 @@ var init_runner = __esm({
             effectiveEffort: adapterResult?.effectiveReasoningEffort ?? classified.effectiveEffort
           } : classified;
           const dispatchOutcome = heartbeatAmbiguous ? "outcome_unknown" : error48 instanceof CodexAppServerError ? error48.dispatchOutcome : failure.dispatchOutcome;
-          await updateAttempt({
+          await persistAttempt({
             phase: dispatchOutcome === "not_dispatched" ? "started" : "dispatched",
             dispatch_outcome: dispatchOutcome
           });
@@ -34727,6 +34868,7 @@ var init_runner = __esm({
             failure_category: failure.category,
             failure_code: failure.code,
             retryable: failure.retryable,
+            provider_dispatch_freshness_remaining_ms: providerDispatchFreshnessRemainingMs,
             ...processExit ? { process_exit: processExit } : {},
             membership_disposition: membershipFailureDisposition({
               ...failure,
@@ -34734,7 +34876,7 @@ var init_runner = __esm({
             }),
             failed_at: isoAt(now())
           });
-          await updateAttempt({
+          await persistAttempt({
             phase: "terminal_pending",
             terminal_operation_id: failureId,
             terminal_request: failureRequest
@@ -37494,6 +37636,7 @@ Durable service:
         codexModelCapabilities: options.codexModelCapabilities,
         protocolVersion: EXTERNAL_INFERENCE_CONTRACT_VERSION,
         adapterRuntimeVersion: INFERENCE_HOST_CLI_VERSION,
+        hostRuntimeVersion: INFERENCE_HOST_CLI_VERSION,
         maxConcurrency: options.maxConcurrency,
         once: options.once,
         emitDiagnosticEvent: options.emitDiagnosticEvent,
@@ -37549,6 +37692,7 @@ Durable service:
         codexModelCapabilities: options.preflight.modelCapabilities,
         protocolVersion: EXTERNAL_INFERENCE_CONTRACT_VERSION,
         adapterRuntimeVersion: options.preflight.runtimeVersion,
+        hostRuntimeVersion: INFERENCE_HOST_CLI_VERSION,
         maxConcurrency: options.maxConcurrency,
         once: options.once,
         emitDiagnosticEvent: options.emitDiagnosticEvent,
@@ -43421,8 +43565,142 @@ var init_local_breadcrumbs = __esm({
   }
 });
 
+// lib/api/shared.ts
+function getProfileHeaders(baseHeaders = {}, explicitProfileId) {
+  const headers = { ...baseHeaders };
+  const profileId = explicitProfileId !== void 0 ? explicitProfileId : activeProfileId;
+  if (profileId) headers["x-profile-id"] = profileId.toString();
+  return headers;
+}
+var getApiUrl, API_URL, sleep2, isTransientNetworkFetchError, createIdempotencyKey, getErrorMessage, getErrorPayloadOrEmpty, getErrorPayloadOrFallbackDetail, getErrorMessageFromResponse, activeProfileId, PROFILE_STORAGE_KEY;
+var init_shared = __esm({
+  "lib/api/shared.ts"() {
+    "use strict";
+    init_abort();
+    getApiUrl = () => {
+      if (typeof window === "undefined") {
+        return process.env.API_URL_SERVER || process.env.NEXT_PUBLIC_API_URL || "http://api:8000";
+      }
+      if (process.env.NODE_ENV === "development") {
+        const hostname3 = window.location.hostname;
+        const isLocalNetworkIP = hostname3.startsWith("192.168.") || hostname3.startsWith("10.") || hostname3.startsWith("172.") && parseInt(hostname3.split(".")[1]) >= 16 && parseInt(hostname3.split(".")[1]) <= 31;
+        if (isLocalNetworkIP) {
+          return `http://${hostname3}:8000`;
+        }
+        if (hostname3 === "localhost" || hostname3 === "127.0.0.1") {
+          return `http://${hostname3}:8000`;
+        }
+      }
+      if (process.env.NEXT_PUBLIC_API_URL) {
+        return process.env.NEXT_PUBLIC_API_URL;
+      }
+      try {
+        const hostname3 = window.location.hostname;
+        const protocol = window.location.protocol;
+        const baseHost = hostname3.startsWith("www.") ? hostname3.slice(4) : hostname3;
+        const apiHost = baseHost.startsWith("api.") ? baseHost : `api.${baseHost}`;
+        return `${protocol}//${apiHost}`;
+      } catch {
+        return "http://localhost:8000";
+      }
+    };
+    API_URL = getApiUrl();
+    sleep2 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
+    isTransientNetworkFetchError = (error48) => {
+      const message = error48 instanceof Error ? error48.message : String(error48 || "");
+      const normalized = message.toLowerCase();
+      return message === "Failed to fetch" || message === "TypeError: Failed to fetch" || normalized.includes("network error") || normalized.includes("failed to fetch");
+    };
+    createIdempotencyKey = (action) => {
+      const suffix = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+      return `web-${action}-${suffix}`;
+    };
+    getErrorMessage = (error48, defaultMessage) => {
+      const extractRateLimitMessage = (raw) => {
+        if (!/rate\s*limit|429|cooling\s*down/i.test(raw)) return null;
+        const match = raw.match(/cooling\s*down\s*for\s*([0-9]+(?:\.[0-9]+)?)s/i);
+        return match ? `Hyperliquid is rate-limited. Please retry in ~${match[1]}s.` : "Hyperliquid is rate-limited. Please wait a moment and retry.";
+      };
+      if (error48?.message === "Failed to fetch" || error48?.message === "TypeError: Failed to fetch" || error48?.message?.includes("network error")) {
+        return "Network error. Please check your connection.";
+      }
+      const fromMessage = extractRateLimitMessage(String(error48?.message || ""));
+      if (fromMessage) return fromMessage;
+      if (error48?.detail) {
+        const fromDetail = extractRateLimitMessage(String(error48.detail));
+        if (fromDetail) return fromDetail;
+        if (Array.isArray(error48.detail)) {
+          return error48.detail.map((item) => `${item.loc ? item.loc.join(".") : "Field"}: ${item.msg}`).join(", ");
+        }
+        if (typeof error48.detail === "object") {
+          const detailMessage = error48.detail.message;
+          if (typeof detailMessage === "string" && detailMessage.trim()) return detailMessage;
+        }
+        return typeof error48.detail === "string" ? error48.detail : JSON.stringify(error48.detail);
+      }
+      return defaultMessage;
+    };
+    getErrorPayloadOrEmpty = async (response) => response.json().catch(() => ({}));
+    getErrorPayloadOrFallbackDetail = async (response, fallbackDetail) => response.json().catch(() => ({ detail: fallbackDetail }));
+    getErrorMessageFromResponse = async (response, defaultMessage, options) => {
+      const error48 = options?.fallbackDetail ? await getErrorPayloadOrFallbackDetail(response, defaultMessage) : await getErrorPayloadOrEmpty(response);
+      return getErrorMessage(error48, defaultMessage);
+    };
+    activeProfileId = null;
+    PROFILE_STORAGE_KEY = "vtx_active_profile_id";
+    if (typeof window !== "undefined") {
+      const stored = sessionStorage.getItem(PROFILE_STORAGE_KEY);
+      if (stored) {
+        const parsed = parseInt(stored, 10);
+        if (Number.isFinite(parsed) && parsed > 0) activeProfileId = parsed;
+      }
+    }
+  }
+});
+
+// lib/api/billing.ts
+var init_billing = __esm({
+  "lib/api/billing.ts"() {
+    "use strict";
+    init_shared();
+  }
+});
+
+// lib/api/market-data.ts
+async function getExecutionAssetMetadata(exchange, symbol2, options) {
+  const params = new URLSearchParams();
+  if (options?.includePrivateContext) params.set("include_private_context", "true");
+  const query = params.size > 0 ? `?${params.toString()}` : "";
+  const url2 = `${API_URL}/trading/execution-metadata/${encodeURIComponent(exchange)}/${encodeURIComponent(symbol2)}${query}`;
+  const response = await fetch(url2, {
+    headers: getProfileHeaders({}, options?.profileId),
+    credentials: "include",
+    cache: "no-store"
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch execution asset metadata: ${response.status} ${response.statusText}`);
+  }
+  return response.json();
+}
+var init_market_data = __esm({
+  "lib/api/market-data.ts"() {
+    "use strict";
+    init_abort();
+    init_network_debug();
+    init_shared();
+  }
+});
+
+// lib/api/screener.ts
+var init_screener = __esm({
+  "lib/api/screener.ts"() {
+    "use strict";
+    init_shared();
+  }
+});
+
 // lib/runtime/server-runtime-lease.ts
-var CLIENT_RUNTIME_SERVER_LEASE_STORAGE_KEY, canUseStorage, normalizeProfileId, parseLeaseRecord, readPersistedLeaseMap, writePersistedLeaseMap, isLeaseExpired, getPersistedClientRuntimeServerLease, persistExistingClientRuntimeServerLease, persistClientRuntimeServerLease, clearPersistedClientRuntimeServerLease;
+var CLIENT_RUNTIME_SERVER_LEASE_STORAGE_KEY, canUseStorage, normalizeProfileId, normalizeLeaseGeneration, parseLeaseRecord, readPersistedLeaseMap, writePersistedLeaseMap, isLeaseExpired, getPersistedClientRuntimeServerLease, persistExistingClientRuntimeServerLease, persistClientRuntimeServerLease, clearPersistedClientRuntimeServerLease;
 var init_server_runtime_lease = __esm({
   "lib/runtime/server-runtime-lease.ts"() {
     "use strict";
@@ -43431,6 +43709,10 @@ var init_server_runtime_lease = __esm({
     normalizeProfileId = (profileId) => {
       return String(profileId ?? "").trim();
     };
+    normalizeLeaseGeneration = (value) => {
+      const generation = Number(value);
+      return Number.isSafeInteger(generation) && generation > 0 ? generation : null;
+    };
     parseLeaseRecord = (value, profileId) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;
@@ -43475,8 +43757,10 @@ var init_server_runtime_lease = __esm({
         leaseId: String(record2.leaseId),
         runtimeSessionId: String(record2.runtimeSessionId),
         deviceId: String(record2.deviceId),
+        schedulerInstanceId: String(record2.schedulerInstanceId ?? "").trim() || null,
         mode: record2.mode,
         scope: "trade-runtime",
+        leaseGeneration: normalizeLeaseGeneration(record2.leaseGeneration),
         issuedAt: String(record2.issuedAt),
         expiresAt: String(record2.expiresAt),
         renewableUntil: String(record2.renewableUntil),
@@ -43579,8 +43863,10 @@ var init_server_runtime_lease = __esm({
         leaseId: String(lease.lease_id),
         runtimeSessionId: String(lease.runtime_session_id),
         deviceId: String(lease.device_id),
+        schedulerInstanceId: String(lease.scheduler_instance_id ?? "").trim() || null,
         mode: lease.mode,
         scope: "trade-runtime",
+        leaseGeneration: normalizeLeaseGeneration(lease.lease_generation),
         issuedAt: String(lease.issued_at),
         expiresAt: String(lease.expires_at),
         renewableUntil: String(lease.renewable_until),
@@ -43592,6 +43878,21 @@ var init_server_runtime_lease = __esm({
         savedAt: Date.now()
       };
       const leaseMap = readPersistedLeaseMap();
+      const existingLease = leaseMap[profileId] ?? null;
+      if (existingLease && record2.leaseId !== existingLease.leaseId) {
+        const incomingGeneration = record2.leaseGeneration ?? null;
+        const existingGeneration = existingLease.leaseGeneration ?? null;
+        if (existingGeneration !== null && incomingGeneration === null || existingGeneration !== null && incomingGeneration !== null && incomingGeneration <= existingGeneration) {
+          return existingLease;
+        }
+        if (existingGeneration === null && incomingGeneration === null) {
+          const incomingIssuedAtMs = Date.parse(record2.issuedAt);
+          const existingIssuedAtMs = Date.parse(existingLease.issuedAt);
+          if (Number.isFinite(incomingIssuedAtMs) && Number.isFinite(existingIssuedAtMs) && incomingIssuedAtMs < existingIssuedAtMs) {
+            return existingLease;
+          }
+        }
+      }
       leaseMap[profileId] = record2;
       writePersistedLeaseMap(leaseMap);
       return record2;
@@ -43613,31 +43914,6 @@ var init_server_runtime_lease = __esm({
 });
 
 // lib/api.ts
-async function getExecutionAssetMetadata(exchange, symbol2, options) {
-  const params = new URLSearchParams();
-  if (options?.includePrivateContext) {
-    params.set("include_private_context", "true");
-  }
-  const query = params.size > 0 ? `?${params.toString()}` : "";
-  const url2 = `${API_URL}/trading/execution-metadata/${encodeURIComponent(exchange)}/${encodeURIComponent(symbol2)}${query}`;
-  const response = await fetch(url2, {
-    headers: getProfileHeaders({}, options?.profileId),
-    credentials: "include",
-    cache: "no-store"
-  });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch execution asset metadata: ${response.status} ${response.statusText}`);
-  }
-  return response.json();
-}
-function getProfileHeaders(baseHeaders = {}, explicitProfileId) {
-  const headers = { ...baseHeaders };
-  const pid = explicitProfileId !== void 0 ? explicitProfileId : _activeProfileId;
-  if (pid) {
-    headers["x-profile-id"] = pid.toString();
-  }
-  return headers;
-}
 async function getClientRuntimeSecrets(profileId, options) {
   const params = new URLSearchParams();
   if (options?.activeProvider) {
@@ -43683,7 +43959,9 @@ async function postClientRuntime(path, profileId, body, options) {
   const signal = options?.signal;
   const parsedRequestTimeoutMs = Number(options?.requestTimeoutMs);
   const requestTimeoutMs = Number.isFinite(parsedRequestTimeoutMs) && parsedRequestTimeoutMs > 0 ? Math.round(parsedRequestTimeoutMs) : null;
-  const maxAttempts = keepalive ? 1 : 3;
+  const parsedDeadlineAtMs = Number(options?.deadlineAtMs);
+  const deadlineAtMs = path === "/runtime/decision" && Number.isFinite(parsedDeadlineAtMs) && parsedDeadlineAtMs > 0 ? Math.round(parsedDeadlineAtMs) : null;
+  let maxAttempts = keepalive ? 1 : deadlineAtMs === null ? 3 : Math.max(3, Math.ceil(Math.max(0, deadlineAtMs - Date.now()) / 250) + 1);
   const requestContext = parseClientRuntimeRequestContext(body);
   const explicitIdempotencyKey = String(options?.idempotencyKey ?? "").trim();
   const idempotencyKey = shouldAttachRuntimeIdempotencyKey(path) ? explicitIdempotencyKey || createIdempotencyKey(`runtime-${path.replace(/\//g, "-")}`) : null;
@@ -43695,19 +43973,64 @@ async function postClientRuntime(path, profileId, body, options) {
     options?.runtimeLeaseToken,
     options?.omitRuntimeLeaseToken
   );
+  const resolvedSchedulerInstanceId = String(
+    options?.schedulerInstanceId ?? requestContext.schedulerInstanceId ?? ""
+  ).trim() || null;
+  const persistedRuntimeLease = getPersistedClientRuntimeServerLease(numericProfileId);
+  if (resolvedRuntimeLeaseToken && persistedRuntimeLease?.schedulerInstanceId && !resolvedSchedulerInstanceId) {
+    resolvedRuntimeLeaseToken = void 0;
+  }
   attachRuntimeLeaseHeader(requestHeaders, resolvedRuntimeLeaseToken);
+  attachRuntimeSchedulerInstanceHeader(
+    requestHeaders,
+    resolvedSchedulerInstanceId
+  );
   if (idempotencyKey) {
     requestHeaders["X-Idempotency-Key"] = idempotencyKey;
   }
   let lastNetworkError = null;
   let missingRuntimeLeaseRecoveryAttempted = false;
+  let replacementLeaseRetryUsed = false;
+  const deadlineError = (attempt, cause) => annotateRuntimeRequestError(
+    Object.assign(
+      new Error("Client runtime decision persistence deadline exceeded after the AI run completed."),
+      cause && (typeof cause === "object" || typeof cause === "function") ? { cause } : {}
+    ),
+    {
+      path,
+      method: "POST",
+      attempt,
+      maxAttempts: null,
+      status: Number.isFinite(Number(cause?.status)) ? Number(cause.status) : null,
+      keepalive,
+      hadRuntimeLeaseToken: Boolean(resolvedRuntimeLeaseToken),
+      deadlineAtMs,
+      deadlineExceeded: true
+    }
+  );
+  const waitBeforeRetry = async (delayMs, attempt, cause) => {
+    if (deadlineAtMs === null) {
+      await sleep2(delayMs);
+      return;
+    }
+    const remainingMs = deadlineAtMs - Date.now();
+    if (remainingMs <= delayMs) {
+      throw deadlineError(attempt, cause);
+    }
+    await sleep2(delayMs);
+  };
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    const deadlineRemainingMs = deadlineAtMs === null ? null : deadlineAtMs - Date.now();
+    if (deadlineRemainingMs !== null && deadlineRemainingMs <= 0) {
+      throw deadlineError(Math.max(0, attempt - 1), lastNetworkError);
+    }
     let response = null;
     let requestTimedOut = false;
     let timeoutId = null;
     let relayCallerAbort = null;
     let requestSignal = signal;
-    if (requestTimeoutMs !== null) {
+    const attemptTimeoutMs = deadlineRemainingMs === null ? requestTimeoutMs : requestTimeoutMs === null ? deadlineRemainingMs : Math.min(requestTimeoutMs, deadlineRemainingMs);
+    if (attemptTimeoutMs !== null) {
       const timeoutController = new AbortController();
       relayCallerAbort = () => timeoutController.abort(signal?.reason);
       if (signal?.aborted) {
@@ -43718,7 +44041,7 @@ async function postClientRuntime(path, profileId, body, options) {
       timeoutId = globalThis.setTimeout(() => {
         requestTimedOut = true;
         timeoutController.abort(new DOMException("Runtime request timeout reached.", "TimeoutError"));
-      }, requestTimeoutMs);
+      }, Math.max(1, attemptTimeoutMs));
       requestSignal = timeoutController.signal;
     }
     const trace = startRuntimeNetworkDebugTrace({
@@ -43752,19 +44075,41 @@ async function postClientRuntime(path, profileId, body, options) {
             continue;
           }
         }
-        const shouldClearLease = Boolean(
+        const leaseInvalidatingError = Boolean(
           resolvedRuntimeLeaseToken && shouldClearPersistedRuntimeLeaseOnError(response.status, error48.message)
         );
-        if (shouldClearLease) {
-          clearPersistedClientRuntimeServerLease(numericProfileId);
+        let leaseCleared = false;
+        if (leaseInvalidatingError) {
+          const currentLease = getPersistedClientRuntimeServerLease(numericProfileId);
+          const replacementLeaseToken = currentLease?.runtimeSessionId === requestContext.sessionId && currentLease.deviceId === requestContext.deviceId && currentLease.mode === (requestContext.mode ?? "trader") && currentLease.runtimeLeaseToken !== resolvedRuntimeLeaseToken ? currentLease.runtimeLeaseToken : null;
+          if (replacementLeaseToken) {
+            resolvedRuntimeLeaseToken = replacementLeaseToken;
+            attachRuntimeLeaseHeader(requestHeaders, resolvedRuntimeLeaseToken);
+            if (attempt >= maxAttempts && !replacementLeaseRetryUsed) {
+              replacementLeaseRetryUsed = true;
+              maxAttempts += 1;
+            }
+            if (attempt >= maxAttempts) {
+              throw error48;
+            }
+            continue;
+          }
+          if (currentLease?.runtimeLeaseToken === resolvedRuntimeLeaseToken) {
+            clearPersistedClientRuntimeServerLease(numericProfileId);
+            leaseCleared = true;
+          }
         }
         recordRuntimeAuthFailureBreadcrumb(path, numericProfileId, requestContext, response.status, error48.message, {
           keepalive,
           hadRuntimeLeaseToken: Boolean(resolvedRuntimeLeaseToken),
-          leaseCleared: shouldClearLease
+          leaseCleared
         });
-        if (!keepalive && attempt < maxAttempts && !shouldClearLease && (shouldRetryClientRuntimeHttpStatus(path, response.status) || isRuntimeIdempotencyInProgressError(response.status, error48.message) || Boolean(idempotencyKey) && isRetryableRuntimeConflictError(response.status, error48))) {
-          await sleep2(resolveClientRuntimeRetryDelayMs(attempt, response.headers.get("Retry-After")));
+        if (!keepalive && attempt < maxAttempts && !leaseInvalidatingError && (shouldRetryClientRuntimeHttpStatus(path, response.status) || isRuntimeIdempotencyInProgressError(response.status, error48.message) || Boolean(idempotencyKey) && isRetryableRuntimeConflictError(response.status, error48))) {
+          await waitBeforeRetry(
+            resolveClientRuntimeRetryDelayMs(attempt, response.headers.get("Retry-After")),
+            attempt,
+            error48
+          );
           continue;
         }
         throw error48;
@@ -43781,18 +44126,26 @@ async function postClientRuntime(path, profileId, body, options) {
       const requestError = requestTimedOut && !signal?.aborted ? new TypeError("Runtime request timeout reached.") : error48;
       lastNetworkError = requestError;
       trace.completeError(requestError, response?.status ?? null);
+      if (deadlineAtMs !== null && Date.now() >= deadlineAtMs) {
+        throw deadlineError(attempt, requestError);
+      }
       if (signal?.aborted || !requestTimedOut && !isTransientNetworkFetchError(requestError) || attempt >= maxAttempts) {
         throw annotateRuntimeRequestError(requestError, {
           path,
           method: "POST",
           attempt,
-          maxAttempts,
+          maxAttempts: deadlineAtMs === null ? maxAttempts : null,
           status: response?.status ?? null,
           keepalive,
-          hadRuntimeLeaseToken: Boolean(resolvedRuntimeLeaseToken)
+          hadRuntimeLeaseToken: Boolean(resolvedRuntimeLeaseToken),
+          deadlineAtMs
         });
       }
-      await sleep2(resolveClientRuntimeRetryDelayMs(attempt, null));
+      await waitBeforeRetry(
+        resolveClientRuntimeRetryDelayMs(attempt, null),
+        attempt,
+        requestError
+      );
       continue;
     } finally {
       if (timeoutId !== null) {
@@ -43808,20 +44161,22 @@ async function postClientRuntime(path, profileId, body, options) {
       path,
       method: "POST",
       attempt: maxAttempts,
-      maxAttempts,
+      maxAttempts: deadlineAtMs === null ? maxAttempts : null,
       status: Number.isFinite(Number(lastNetworkError.status)) ? Number(lastNetworkError.status) : null,
       keepalive,
-      hadRuntimeLeaseToken: Boolean(resolvedRuntimeLeaseToken)
+      hadRuntimeLeaseToken: Boolean(resolvedRuntimeLeaseToken),
+      deadlineAtMs
     });
   }
   throw new Error("Client runtime request failed");
 }
-async function beginClientRuntimeExchangeMutation(profileId, payload, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId) {
+async function beginClientRuntimeExchangeMutation(profileId, payload, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId, explicitSchedulerInstanceId) {
   const authority = resolveClientExchangeMutationAuthority(
     profileId,
     requiredRuntimeSessionId,
     explicitRuntimeLeaseToken,
-    explicitRuntimeDeviceId
+    explicitRuntimeDeviceId,
+    explicitSchedulerInstanceId
   );
   const requestBegin = () => postClientRuntime(
     "/runtime/exchange-mutations/begin",
@@ -43902,12 +44257,13 @@ async function beginClientRuntimeExchangeMutation(profileId, payload, requiredRu
   }
   return result2;
 }
-async function reportClientRuntimeExchangeAttemptTransition(profileId, mutationId, payload, signal, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId) {
+async function reportClientRuntimeExchangeAttemptTransition(profileId, mutationId, payload, signal, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId, explicitSchedulerInstanceId) {
   const authority = resolveClientExchangeMutationAuthority(
     profileId,
     requiredRuntimeSessionId,
     explicitRuntimeLeaseToken,
-    explicitRuntimeDeviceId
+    explicitRuntimeDeviceId,
+    explicitSchedulerInstanceId
   );
   return postClientRuntime(
     `/runtime/exchange-mutations/${encodeURIComponent(mutationId)}/attempt`,
@@ -43923,12 +44279,13 @@ async function reportClientRuntimeExchangeAttemptTransition(profileId, mutationI
     }
   );
 }
-async function settleClientRuntimeExchangeMutation(profileId, mutationId, payload, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId) {
+async function settleClientRuntimeExchangeMutation(profileId, mutationId, payload, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId, explicitSchedulerInstanceId) {
   const authority = resolveClientExchangeMutationAuthority(
     profileId,
     requiredRuntimeSessionId,
     explicitRuntimeLeaseToken,
-    explicitRuntimeDeviceId
+    explicitRuntimeDeviceId,
+    explicitSchedulerInstanceId
   );
   try {
     const result2 = await postClientRuntime(
@@ -44003,7 +44360,7 @@ async function reconcileActiveClientRuntimeExchangeMutation(profileId, requestOp
   }
   return rememberCompletedDeferredClientRuntimeStop(profileId, result2);
 }
-var getApiUrl, API_URL, sleep2, isTransientNetworkFetchError, createIdempotencyKey, getErrorMessage, getErrorPayloadOrEmpty, getErrorPayloadOrFallbackDetail, getErrorMessageFromResponse, _activeProfileId, PROFILE_STORAGE_KEY, preferencesWriteQueue, CLIENT_SUPPORTED_PROMPT_CONTRACT_VERSION, completedDeferredClientRuntimeStops, rememberCompletedDeferredClientRuntimeStop, toNumericProfileId, shouldAttachRuntimeIdempotencyKey, attachRuntimeLeaseHeader, resolveRuntimeLeaseToken, persistRuntimeLeaseFromPayload, persistRuntimeLeaseStatusMetadata, shouldClearPersistedRuntimeLeaseOnError, isMissingRuntimeLeaseError, createRuntimeRequestError, parseClientRuntimeRequestContext, recordRuntimeAuthFailureBreadcrumb, classifyRuntimeRequestError, annotateRuntimeRequestError, parseRuntimeRetryAfterMs, shouldRecoverMissingRuntimeLease, recoverMissingRuntimeLease, isRetryableClientRuntimeStatus, shouldRetryClientRuntimeHttpStatus, isRuntimeIdempotencyInProgressError, isRetryableRuntimeConflictError, resolveClientRuntimeRetryDelayMs, CLIENT_EXCHANGE_AUTHORITY_DEVICE_KEY, CLIENT_EXCHANGE_AUTHORITY_SESSION_KEY, getOrCreateClientExchangeAuthorityIdentity, resolveClientExchangeMutationAuthority, clientExchangeMutationAuthorityBody, isPendingClientExchangeMutationError, clientExchangeMutationReconciliationTimers, MAX_CLIENT_EXCHANGE_RECONCILIATION_DELAY_MS, CLIENT_EXCHANGE_RECONCILIATION_CLOCK_SKEW_MS, ClientExchangeMutationRebuildRequiredError, isTerminalClientExchangeMutation, clientExchangeMutationReconciliationKey, clearScheduledClientExchangeMutationReconciliation, snapshotClientExchangeMutationReconciliationAuthority, postClientExchangeMutationReconciliation, scheduleClientExchangeMutationReconciliation;
+var preferencesWriteQueue, CLIENT_SUPPORTED_PROMPT_CONTRACT_VERSION, completedDeferredClientRuntimeStops, rememberCompletedDeferredClientRuntimeStop, toNumericProfileId, shouldAttachRuntimeIdempotencyKey, attachRuntimeLeaseHeader, attachRuntimeSchedulerInstanceHeader, resolveRuntimeLeaseToken, persistRuntimeLeaseFromPayload, persistRuntimeLeaseStatusMetadata, shouldClearPersistedRuntimeLeaseOnError, isMissingRuntimeLeaseError, createRuntimeRequestError, parseClientRuntimeRequestContext, recordRuntimeAuthFailureBreadcrumb, classifyRuntimeRequestError, annotateRuntimeRequestError, parseRuntimeRetryAfterMs, shouldRecoverMissingRuntimeLease, runtimeLeaseRecoveries, recoverMissingRuntimeLeaseDirect, recoverMissingRuntimeLease, isRetryableClientRuntimeStatus, shouldRetryClientRuntimeHttpStatus, isRuntimeIdempotencyInProgressError, isRetryableRuntimeConflictError, resolveClientRuntimeRetryDelayMs, CLIENT_EXCHANGE_AUTHORITY_DEVICE_KEY, CLIENT_EXCHANGE_AUTHORITY_SESSION_KEY, getOrCreateClientExchangeAuthorityIdentity, resolveClientExchangeMutationAuthority, clientExchangeMutationAuthorityBody, isPendingClientExchangeMutationError, clientExchangeMutationReconciliationTimers, MAX_CLIENT_EXCHANGE_RECONCILIATION_DELAY_MS, CLIENT_EXCHANGE_RECONCILIATION_CLOCK_SKEW_MS, ClientExchangeMutationRebuildRequiredError, isTerminalClientExchangeMutation, clientExchangeMutationReconciliationKey, clearScheduledClientExchangeMutationReconciliation, snapshotClientExchangeMutationReconciliationAuthority, postClientExchangeMutationReconciliation, scheduleClientExchangeMutationReconciliation;
 var init_api2 = __esm({
   "lib/api.ts"() {
     "use strict";
@@ -44019,99 +44376,12 @@ var init_api2 = __esm({
     init_network_debug();
     init_local_breadcrumbs();
     init_abort();
+    init_shared();
+    init_shared();
+    init_billing();
+    init_market_data();
+    init_screener();
     init_server_runtime_lease();
-    getApiUrl = () => {
-      if (typeof window === "undefined") {
-        return process.env.API_URL_SERVER || process.env.NEXT_PUBLIC_API_URL || "http://api:8000";
-      }
-      if (process.env.NODE_ENV === "development") {
-        const hostname3 = window.location.hostname;
-        const isLocalNetworkIP = hostname3.startsWith("192.168.") || hostname3.startsWith("10.") || hostname3.startsWith("172.") && parseInt(hostname3.split(".")[1]) >= 16 && parseInt(hostname3.split(".")[1]) <= 31;
-        if (isLocalNetworkIP) {
-          return `http://${hostname3}:8000`;
-        }
-        if (hostname3 === "localhost" || hostname3 === "127.0.0.1") {
-          return `http://${hostname3}:8000`;
-        }
-      }
-      if (process.env.NEXT_PUBLIC_API_URL) {
-        return process.env.NEXT_PUBLIC_API_URL;
-      }
-      try {
-        const hostname3 = window.location.hostname;
-        const protocol = window.location.protocol;
-        const baseHost = hostname3.startsWith("www.") ? hostname3.slice(4) : hostname3;
-        const apiHost = baseHost.startsWith("api.") ? baseHost : `api.${baseHost}`;
-        return `${protocol}//${apiHost}`;
-      } catch {
-        return "http://localhost:8000";
-      }
-    };
-    API_URL = getApiUrl();
-    sleep2 = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
-    isTransientNetworkFetchError = (error48) => {
-      const message = error48 instanceof Error ? error48.message : String(error48 || "");
-      const normalized = message.toLowerCase();
-      return message === "Failed to fetch" || message === "TypeError: Failed to fetch" || normalized.includes("network error") || normalized.includes("failed to fetch");
-    };
-    createIdempotencyKey = (action) => {
-      const suffix = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-      return `web-${action}-${suffix}`;
-    };
-    getErrorMessage = (error48, defaultMessage) => {
-      const extractRateLimitMessage = (raw) => {
-        if (!/rate\s*limit|429|cooling\s*down/i.test(raw)) return null;
-        const cooldownMatch = raw.match(/cooling\s*down\s*for\s*([0-9]+(?:\.[0-9]+)?)s/i);
-        if (cooldownMatch) {
-          return `Hyperliquid is rate-limited. Please retry in ~${cooldownMatch[1]}s.`;
-        }
-        return "Hyperliquid is rate-limited. Please wait a moment and retry.";
-      };
-      if (error48?.message === "Failed to fetch" || error48?.message === "TypeError: Failed to fetch" || error48?.message?.includes("network error")) {
-        return "Network error. Please check your connection.";
-      }
-      const fromMessage = extractRateLimitMessage(String(error48?.message || ""));
-      if (fromMessage) return fromMessage;
-      if (error48?.detail) {
-        const fromDetail = extractRateLimitMessage(String(error48.detail));
-        if (fromDetail) return fromDetail;
-        if (Array.isArray(error48.detail)) {
-          return error48.detail.map((err) => {
-            const field = err.loc ? err.loc.join(".") : "Field";
-            return `${field}: ${err.msg}`;
-          }).join(", ");
-        }
-        if (typeof error48.detail === "object") {
-          const detailMessage = error48.detail.message;
-          if (typeof detailMessage === "string" && detailMessage.trim()) {
-            return detailMessage;
-          }
-        }
-        return typeof error48.detail === "string" ? error48.detail : JSON.stringify(error48.detail);
-      }
-      return defaultMessage;
-    };
-    getErrorPayloadOrEmpty = async (response) => {
-      return response.json().catch(() => ({}));
-    };
-    getErrorPayloadOrFallbackDetail = async (response, fallbackDetail) => {
-      return response.json().catch(() => ({ detail: fallbackDetail }));
-    };
-    getErrorMessageFromResponse = async (response, defaultMessage, options) => {
-      const error48 = options?.fallbackDetail ? await getErrorPayloadOrFallbackDetail(response, defaultMessage) : await getErrorPayloadOrEmpty(response);
-      return getErrorMessage(error48, defaultMessage);
-    };
-    _activeProfileId = null;
-    PROFILE_STORAGE_KEY = "vtx_active_profile_id";
-    if (typeof window !== "undefined") {
-      const stored = sessionStorage.getItem(PROFILE_STORAGE_KEY);
-      if (stored) {
-        const parsed = parseInt(stored, 10);
-        if (Number.isFinite(parsed) && parsed > 0) {
-          _activeProfileId = parsed;
-        }
-      }
-    }
     preferencesWriteQueue = Promise.resolve();
     CLIENT_SUPPORTED_PROMPT_CONTRACT_VERSION = String(
       process.env.NEXT_PUBLIC_CLIENT_RUNTIME_PROMPT_CONTRACT_VERSION || "2026-08-24.1"
@@ -44140,6 +44410,13 @@ var init_api2 = __esm({
       }
       requestHeaders["x-client-runtime-lease"] = normalized;
     };
+    attachRuntimeSchedulerInstanceHeader = (requestHeaders, schedulerInstanceId) => {
+      const normalized = String(schedulerInstanceId ?? "").trim();
+      if (!normalized) {
+        return;
+      }
+      requestHeaders["x-client-runtime-instance"] = normalized;
+    };
     resolveRuntimeLeaseToken = (profileId, runtimeLeaseToken, omitRuntimeLeaseToken) => {
       if (omitRuntimeLeaseToken === true) {
         return void 0;
@@ -44229,11 +44506,13 @@ var init_api2 = __esm({
         const parsed = JSON.parse(body);
         const sessionId = typeof parsed.session_id === "string" && parsed.session_id.trim().length > 0 ? parsed.session_id.trim() : null;
         const deviceId = typeof parsed.device_id === "string" && parsed.device_id.trim().length > 0 ? parsed.device_id.trim() : null;
+        const schedulerInstanceId = typeof parsed.scheduler_instance_id === "string" && parsed.scheduler_instance_id.trim().length > 0 ? parsed.scheduler_instance_id.trim() : null;
         const mode = parsed.mode === "assistant" ? "assistant" : parsed.mode === "trader" ? "trader" : null;
         const lastRunAt = typeof parsed.last_run_at === "string" && parsed.last_run_at.trim().length > 0 ? parsed.last_run_at.trim() : null;
         return {
           sessionId,
           deviceId,
+          schedulerInstanceId,
           mode,
           lastRunAt
         };
@@ -44241,6 +44520,7 @@ var init_api2 = __esm({
         return {
           sessionId: null,
           deviceId: null,
+          schedulerInstanceId: null,
           mode: null,
           lastRunAt: null
         };
@@ -44297,6 +44577,12 @@ var init_api2 = __esm({
       target.runtimeRequestTransientNetwork = isTransientNetworkFetchError(error48);
       target.runtimeRequestKeepalive = metadata.keepalive;
       target.runtimeRequestHadLeaseToken = metadata.hadRuntimeLeaseToken;
+      if (metadata.deadlineAtMs !== void 0) {
+        target.runtimeRequestDeadlineAtMs = metadata.deadlineAtMs;
+      }
+      if (metadata.deadlineExceeded !== void 0) {
+        target.runtimeRequestDeadlineExceeded = metadata.deadlineExceeded;
+      }
       return error48;
     };
     parseRuntimeRetryAfterMs = (value) => {
@@ -44322,7 +44608,8 @@ var init_api2 = __esm({
       }
       return path === "/runtime/heartbeat" || path === "/runtime/analyze" || path === "/runtime/prompt-contract/metadata" || path === "/runtime/prompt-contract/derived-context" || path === "/runtime/prompt" || path === "/runtime/decision" || path === "/runtime/error" || path === "/runtime/trade-sync";
     };
-    recoverMissingRuntimeLease = async (profileId, requestContext, signal) => {
+    runtimeLeaseRecoveries = /* @__PURE__ */ new Map();
+    recoverMissingRuntimeLeaseDirect = async (profileId, requestContext, signal) => {
       if (!requestContext.sessionId || !requestContext.deviceId) {
         return null;
       }
@@ -44330,6 +44617,7 @@ var init_api2 = __esm({
         "Content-Type": "application/json",
         "X-Idempotency-Key": createIdempotencyKey("runtime-lease-recovery")
       }, profileId);
+      attachRuntimeSchedulerInstanceHeader(headers, requestContext.schedulerInstanceId);
       let payload;
       try {
         const response = await fetch(`${getApiUrl()}/trading/ai/runtime/session/start`, {
@@ -44341,6 +44629,7 @@ var init_api2 = __esm({
           body: JSON.stringify({
             session_id: requestContext.sessionId,
             device_id: requestContext.deviceId,
+            ...requestContext.schedulerInstanceId ? { scheduler_instance_id: requestContext.schedulerInstanceId } : {},
             mode: requestContext.mode ?? null,
             last_run_at: requestContext.lastRunAt ?? null,
             force_takeover: false,
@@ -44357,14 +44646,100 @@ var init_api2 = __esm({
         }
         return null;
       }
-      persistRuntimeLeaseFromPayload(payload);
+      const recoveredLease = payload?.lease;
+      if (!recoveredLease || typeof recoveredLease !== "object" || Array.isArray(recoveredLease)) {
+        return null;
+      }
+      const recoveredLeasePayload = recoveredLease;
+      const expectedMode = requestContext.mode ?? "trader";
+      const recoveredToken = String(recoveredLeasePayload.runtime_lease_token ?? "").trim();
+      if (!recoveredToken || Number(recoveredLeasePayload.profile_id) !== profileId || String(recoveredLeasePayload.runtime_session_id ?? "").trim() !== requestContext.sessionId || String(recoveredLeasePayload.device_id ?? "").trim() !== requestContext.deviceId || String(recoveredLeasePayload.mode ?? "").trim().toLowerCase() !== expectedMode || requestContext.schedulerInstanceId != null && String(recoveredLeasePayload.scheduler_instance_id ?? "").trim() !== requestContext.schedulerInstanceId) {
+        return null;
+      }
+      const currentLease = getPersistedClientRuntimeServerLease(profileId);
+      if (currentLease && (currentLease.runtimeSessionId !== requestContext.sessionId || currentLease.deviceId !== requestContext.deviceId || currentLease.mode !== expectedMode || requestContext.schedulerInstanceId != null && currentLease.schedulerInstanceId !== requestContext.schedulerInstanceId)) {
+        return null;
+      }
+      const selectedLease = persistClientRuntimeServerLease(
+        recoveredLease
+      );
       persistRuntimeLeaseStatusMetadata(profileId, payload);
-      const lease = getPersistedClientRuntimeServerLease(profileId);
-      if (lease?.runtimeSessionId === requestContext.sessionId && lease.deviceId === requestContext.deviceId && lease.runtimeLeaseToken) {
-        return lease.runtimeLeaseToken;
+      if (selectedLease?.runtimeSessionId === requestContext.sessionId && selectedLease.deviceId === requestContext.deviceId && selectedLease.mode === expectedMode && (requestContext.schedulerInstanceId == null || selectedLease.schedulerInstanceId === requestContext.schedulerInstanceId) && selectedLease.runtimeLeaseToken) {
+        return selectedLease.runtimeLeaseToken;
       }
       return null;
     };
+    recoverMissingRuntimeLease = async (profileId, requestContext, signal) => {
+      if (!requestContext.sessionId || !requestContext.deviceId) {
+        return null;
+      }
+      const recoveryKey = JSON.stringify([
+        profileId,
+        requestContext.sessionId,
+        requestContext.deviceId,
+        requestContext.mode ?? "trader",
+        requestContext.schedulerInstanceId
+      ]);
+      let recovery = runtimeLeaseRecoveries.get(recoveryKey);
+      if (!recovery) {
+        const controller = new AbortController();
+        const created = {
+          controller,
+          promise: Promise.resolve(null),
+          waiters: 0
+        };
+        created.promise = (async () => {
+          try {
+            return await recoverMissingRuntimeLeaseDirect(
+              profileId,
+              requestContext,
+              controller.signal
+            );
+          } finally {
+            if (runtimeLeaseRecoveries.get(recoveryKey) === created) {
+              runtimeLeaseRecoveries.delete(recoveryKey);
+            }
+          }
+        })();
+        runtimeLeaseRecoveries.set(recoveryKey, created);
+        recovery = created;
+      }
+      recovery.waiters += 1;
+      try {
+        if (!signal) {
+          return await recovery.promise;
+        }
+        if (signal.aborted) {
+          throw signal.reason ?? new DOMException("Runtime lease recovery aborted.", "AbortError");
+        }
+        return await new Promise((resolve6, reject) => {
+          let settled = false;
+          const finish = (callback) => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            signal.removeEventListener("abort", onAbort);
+            callback();
+          };
+          const onAbort = () => finish(() => reject(
+            signal.reason ?? new DOMException("Runtime lease recovery aborted.", "AbortError")
+          ));
+          signal.addEventListener("abort", onAbort, { once: true });
+          recovery.promise.then(
+            (token) => finish(() => resolve6(token)),
+            (error48) => finish(() => reject(error48))
+          );
+        });
+      } finally {
+        recovery.waiters = Math.max(0, recovery.waiters - 1);
+        if (recovery.waiters === 0 && runtimeLeaseRecoveries.get(recoveryKey) === recovery && !recovery.controller.signal.aborted) {
+          recovery.controller.abort(
+            signal?.reason ?? new DOMException("Runtime lease recovery has no active waiters.", "AbortError")
+          );
+        }
+      }
+    };
     isRetryableClientRuntimeStatus = (status) => status === 408 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
     shouldRetryClientRuntimeHttpStatus = (path, status) => {
       if (!isRetryableClientRuntimeStatus(status)) {
@@ -44376,7 +44751,7 @@ var init_api2 = __esm({
       return true;
     };
     isRuntimeIdempotencyInProgressError = (status, message) => status === 409 && (message.toLowerCase().includes("duplicate request already in progress") || message.toLowerCase().includes("duplicate request in-flight"));
-    isRetryableRuntimeConflictError = (status, error48) => status === 409 && error48.retryable === true && (error48.code === "profile_runtime_contract_busy" || error48.code === "runtime_trade_sync_finalizing");
+    isRetryableRuntimeConflictError = (status, error48) => status === 409 && error48.retryable === true && (error48.code === "profile_runtime_contract_busy" || error48.code === "runtime_decision_finalizing" || error48.code === "runtime_trade_sync_finalizing");
     resolveClientRuntimeRetryDelayMs = (attempt, retryAfterHeader) => {
       const retryAfterMs = parseRuntimeRetryAfterMs(retryAfterHeader);
       if (retryAfterMs != null) {
@@ -44398,12 +44773,13 @@ var init_api2 = __esm({
       storage.setItem(key, generated);
       return generated;
     };
-    resolveClientExchangeMutationAuthority = (profileId, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId) => {
+    resolveClientExchangeMutationAuthority = (profileId, requiredRuntimeSessionId, explicitRuntimeLeaseToken, explicitRuntimeDeviceId, explicitSchedulerInstanceId) => {
       const numericProfileId = toNumericProfileId(profileId);
       const lease = getPersistedClientRuntimeServerLease(numericProfileId);
       const requiredSessionId = String(requiredRuntimeSessionId ?? "").trim();
       const explicitLeaseToken = String(explicitRuntimeLeaseToken ?? "").trim();
       const explicitDeviceId = String(explicitRuntimeDeviceId ?? "").trim();
+      const schedulerInstanceId = String(explicitSchedulerInstanceId ?? "").trim();
       if (requiredSessionId && explicitLeaseToken && explicitDeviceId) {
         return {
           numericProfileId,
@@ -44411,18 +44787,20 @@ var init_api2 = __esm({
           deviceId: explicitDeviceId,
           mode: "trader",
           requestOptions: {
-            runtimeLeaseToken: explicitLeaseToken
+            runtimeLeaseToken: explicitLeaseToken,
+            schedulerInstanceId: schedulerInstanceId || void 0
           }
         };
       }
-      if (lease?.runtimeLeaseToken && lease.runtimeSessionId && lease.deviceId && lease.mode === "trader" && (!requiredSessionId || lease.runtimeSessionId === requiredSessionId)) {
+      if (lease?.runtimeLeaseToken && lease.runtimeSessionId && lease.deviceId && lease.mode === "trader" && !lease.schedulerInstanceId && (!requiredSessionId || lease.runtimeSessionId === requiredSessionId)) {
         return {
           numericProfileId,
           sessionId: lease.runtimeSessionId,
           deviceId: lease.deviceId,
           mode: lease.mode,
           requestOptions: {
-            runtimeLeaseToken: lease.runtimeLeaseToken
+            runtimeLeaseToken: lease.runtimeLeaseToken,
+            schedulerInstanceId: schedulerInstanceId || void 0
           }
         };
       }
@@ -44454,11 +44832,15 @@ var init_api2 = __esm({
         }
       };
     };
-    clientExchangeMutationAuthorityBody = (authority) => ({
-      session_id: authority.sessionId,
-      device_id: authority.deviceId,
-      mode: authority.mode
-    });
+    clientExchangeMutationAuthorityBody = (authority) => {
+      const schedulerInstanceId = String(authority.requestOptions.schedulerInstanceId ?? "").trim();
+      return {
+        session_id: authority.sessionId,
+        device_id: authority.deviceId,
+        mode: authority.mode,
+        ...schedulerInstanceId ? { scheduler_instance_id: schedulerInstanceId } : {}
+      };
+    };
     isPendingClientExchangeMutationError = (error48) => {
       const status = Number(error48?.status);
       const message = error48 instanceof Error ? error48.message : String(error48 ?? "");
@@ -44481,7 +44863,8 @@ var init_api2 = __esm({
     };
     snapshotClientExchangeMutationReconciliationAuthority = (requestOptions) => {
       const runtimeLeaseToken = String(requestOptions?.runtimeLeaseToken ?? "").trim();
-      return runtimeLeaseToken ? { runtimeLeaseToken } : { omitRuntimeLeaseToken: true };
+      const schedulerInstanceId = String(requestOptions?.schedulerInstanceId ?? "").trim();
+      return runtimeLeaseToken ? { runtimeLeaseToken, schedulerInstanceId: schedulerInstanceId || void 0 } : { omitRuntimeLeaseToken: true, schedulerInstanceId: schedulerInstanceId || void 0 };
     };
     postClientExchangeMutationReconciliation = async (profileId, mutationId, requestOptions) => {
       const result2 = await postClientRuntime(
@@ -54249,14 +54632,19 @@ var init_hyperliquid_client = __esm({
       const runtimeSessionId = String(durableMutation.requiredRuntimeSessionId ?? "").trim();
       const runtimeLeaseToken = String(durableMutation.runtimeLeaseToken ?? "").trim();
       const runtimeDeviceId = String(durableMutation.runtimeDeviceId ?? "").trim();
-      const presentCount = [runtimeSessionId, runtimeLeaseToken, runtimeDeviceId].filter(Boolean).length;
-      if (presentCount === 0) {
+      const schedulerInstanceId = String(durableMutation.schedulerInstanceId ?? "").trim();
+      const coreAuthority = [runtimeSessionId, runtimeLeaseToken, runtimeDeviceId];
+      const corePresentCount = coreAuthority.filter(Boolean).length;
+      if (corePresentCount === 0 && !schedulerInstanceId) {
         return [];
       }
-      if (presentCount !== 3) {
+      if (corePresentCount !== 3) {
         throw new Error("Incomplete client runtime mutation authority.");
       }
-      return [runtimeSessionId, runtimeLeaseToken, runtimeDeviceId];
+      if (!schedulerInstanceId) {
+        return [runtimeSessionId, runtimeLeaseToken, runtimeDeviceId];
+      }
+      return [runtimeSessionId, runtimeLeaseToken, runtimeDeviceId, schedulerInstanceId];
     };
     assertFreshPreparedExecutionContext = (preparedContext) => {
       if (!preparedContext) {
@@ -57147,6 +57535,7 @@ var init_browser_trading = __esm({
           requiredRuntimeSessionId: input.runtimeSessionId,
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           mutationId: mutation.mutationId,
           operationKind: "leverage",
           symbol: input.symbol
@@ -57185,6 +57574,7 @@ var init_browser_trading = __esm({
           requiredRuntimeSessionId: input.runtimeSessionId,
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           mutationId: mutation.mutationId,
           operationKind: "order",
           symbol: input.symbol,
@@ -57221,6 +57611,7 @@ var init_browser_trading = __esm({
           requiredRuntimeSessionId: input.runtimeSessionId,
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           mutationId: mutation.mutationId,
           operationKind: "order",
           symbol: input.symbol,
@@ -57251,6 +57642,7 @@ var init_browser_trading = __esm({
           requiredRuntimeSessionId: input.runtimeSessionId,
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           mutationId: mutation.mutationId,
           operationKind: "order",
           symbol: input.symbol,
@@ -57291,6 +57683,7 @@ var init_browser_trading = __esm({
           requiredRuntimeSessionId: input.runtimeSessionId,
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           mutationId: mutation.mutationId,
           operationKind: "order",
           symbol: input.symbol,
@@ -57320,6 +57713,7 @@ var init_browser_trading = __esm({
           requiredRuntimeSessionId: input.runtimeSessionId,
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           mutationId: mutation.mutationId,
           operationKind: "cancel",
           symbol: input.symbol,
@@ -57349,6 +57743,7 @@ var init_browser_trading = __esm({
         runtimeSessionId: input.runtimeSessionId,
         runtimeLeaseToken: input.runtimeLeaseToken,
         runtimeDeviceId: input.runtimeDeviceId,
+        schedulerInstanceId: input.schedulerInstanceId,
         walletAddress: input.walletAddress,
         config: input.config ?? null,
         signal: input.signal,
@@ -58610,6 +59005,7 @@ var init_runtime_execution = __esm({
           runtimeSessionId: request.sessionId || "__missing_runtime_session__",
           runtimeLeaseToken: request.runtimeLeaseToken,
           runtimeDeviceId: request.runtimeDeviceId,
+          schedulerInstanceId: request.schedulerInstanceId,
           walletAddress: request.executionContext.walletAddress,
           config: request.config ?? null,
           signal: request.signal,
@@ -59005,6 +59401,7 @@ var init_runtime_execution = __esm({
             runtimeSessionId: request.sessionId || "__missing_runtime_session__",
             runtimeLeaseToken: request.runtimeLeaseToken,
             runtimeDeviceId: request.runtimeDeviceId,
+            schedulerInstanceId: request.schedulerInstanceId,
             walletAddress: request.executionContext.walletAddress,
             config: request.config ?? null,
             signal: request.signal,
@@ -59037,6 +59434,7 @@ var init_runtime_execution = __esm({
             runtimeSessionId: request.sessionId || "__missing_runtime_session__",
             runtimeLeaseToken: request.runtimeLeaseToken,
             runtimeDeviceId: request.runtimeDeviceId,
+            schedulerInstanceId: request.schedulerInstanceId,
             walletAddress: request.executionContext.walletAddress,
             config: request.config ?? null,
             signal: request.signal,
@@ -60042,6 +60440,7 @@ var init_runtime_execution = __esm({
                 runtimeSessionId: request.sessionId || "__missing_runtime_session__",
                 runtimeLeaseToken: request.runtimeLeaseToken,
                 runtimeDeviceId: request.runtimeDeviceId,
+                schedulerInstanceId: request.schedulerInstanceId,
                 walletAddress: request.executionContext.walletAddress,
                 config: request.config ?? null,
                 signal: request.signal,
@@ -60740,6 +61139,7 @@ var init_runtime_execution = __esm({
               runtimeSessionId: request.sessionId || "__missing_runtime_session__",
               runtimeLeaseToken: request.runtimeLeaseToken,
               runtimeDeviceId: request.runtimeDeviceId,
+              schedulerInstanceId: request.schedulerInstanceId,
               walletAddress: request.executionContext.walletAddress,
               config: request.config ?? null,
               signal: request.signal,
@@ -61179,6 +61579,7 @@ var init_runtime_execution = __esm({
             runtimeSessionId: request.sessionId || "__missing_runtime_session__",
             runtimeLeaseToken: request.runtimeLeaseToken,
             runtimeDeviceId: request.runtimeDeviceId,
+            schedulerInstanceId: request.schedulerInstanceId,
             walletAddress: request.executionContext.walletAddress,
             config: request.config ?? null,
             signal: request.signal,
@@ -61705,6 +62106,7 @@ var init_runtime_execution = __esm({
           runtimeSessionId: input.sessionId || "__missing_runtime_session__",
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           walletAddress: input.executionContext.walletAddress,
           config: input.config ?? null,
           signal: input.signal,
@@ -61722,6 +62124,7 @@ var init_runtime_execution = __esm({
           runtimeSessionId: input.sessionId || "__missing_runtime_session__",
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           walletAddress: input.executionContext.walletAddress,
           config: input.config ?? null,
           signal: input.signal,
@@ -61793,6 +62196,7 @@ var init_runtime_execution = __esm({
           runtimeSessionId: input.sessionId || "__missing_runtime_session__",
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           walletAddress: input.executionContext.walletAddress,
           config: input.config ?? null,
           signal: input.signal,
@@ -61911,6 +62315,7 @@ var init_runtime_execution = __esm({
           runtimeSessionId: input.sessionId || "__missing_runtime_session__",
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           walletAddress: input.executionContext.walletAddress,
           config: input.config ?? null,
           signal: input.signal,
@@ -62069,6 +62474,7 @@ var init_runtime_execution = __esm({
           runtimeSessionId: input.sessionId || "__missing_runtime_session__",
           runtimeLeaseToken: input.runtimeLeaseToken,
           runtimeDeviceId: input.runtimeDeviceId,
+          schedulerInstanceId: input.schedulerInstanceId,
           walletAddress: input.executionContext.walletAddress,
           config: input.config ?? null,
           signal: input.signal,
@@ -62392,6 +62798,7 @@ var init_runtime_execution = __esm({
               runtimeSessionId: input.sessionId || "__missing_runtime_session__",
               runtimeLeaseToken: input.runtimeLeaseToken,
               runtimeDeviceId: input.runtimeDeviceId,
+              schedulerInstanceId: input.schedulerInstanceId,
               walletAddress: input.executionContext.walletAddress,
               config: input.config ?? null,
               signal: input.signal,