@vtxmacro/cli 2026.9.56 → 2026.9.58

package/bin/vtx-service-bootstrap.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 // agent-cli-release.json
 var agent_cli_release_default = {
   package_name: "@vtxmacro/cli",
-  package_version: "2026.9.56",
+  package_version: "2026.9.58",
   codex_package_name: "@openai/codex",
   codex_version: "0.155.0",
   copilot_sdk_package_name: "@github/copilot-sdk",
@@ -203,6 +203,8 @@ var runtime_policy_generated_default = {
       },
       server_runtime: {
         prompt_rescue: {
+          snapshot_max_age_seconds: 5,
+          snapshot_component_max_skew_seconds: 2,
           client_long_poll_seconds: 20,
           client_claim_http_timeout_milliseconds: 25e3,
           client_presence_heartbeat_interval_milliseconds: 3e4,

package/bin/vtx-service-launcher.js

@@ -86,6 +86,8 @@ var runtime_policy_generated_default = {
       },
       server_runtime: {
         prompt_rescue: {
+          snapshot_max_age_seconds: 5,
+          snapshot_component_max_skew_seconds: 2,
           client_long_poll_seconds: 20,
           client_claim_http_timeout_milliseconds: 25e3,
           client_presence_heartbeat_interval_milliseconds: 3e4,

package/bin/vtx.js

@@ -77,7 +77,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.56",
+      package_version: "2026.9.58",
       codex_package_name: "@openai/codex",
       codex_version: "0.155.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -20544,6 +20544,8 @@ var init_runtime_policy_generated = __esm({
           },
           server_runtime: {
             prompt_rescue: {
+              snapshot_max_age_seconds: 5,
+              snapshot_component_max_skew_seconds: 2,
               client_long_poll_seconds: 20,
               client_claim_http_timeout_milliseconds: 25e3,
               client_presence_heartbeat_interval_milliseconds: 3e4,
@@ -42604,6 +42606,8 @@ var init_runtime_policy_generated2 = __esm({
           },
           server_runtime: {
             prompt_rescue: {
+              snapshot_max_age_seconds: 5,
+              snapshot_component_max_skew_seconds: 2,
               client_long_poll_seconds: 20,
               client_claim_http_timeout_milliseconds: 25e3,
               client_presence_heartbeat_interval_milliseconds: 3e4,
@@ -48954,6 +48958,17 @@ var init_hyperliquid_public_read = __esm({
       let outcome = "cancelled";
       let settled;
       let acquiring = false;
+      let observedRateLimit;
+      let pendingPhase = null;
+      const setPendingPhase = (next) => {
+        if (next === pendingPhase) return;
+        const previous = pendingPhase;
+        pendingPhase = next;
+        try {
+          options.reservation?.onPendingPhaseChange?.(previous, next);
+        } catch {
+        }
+      };
       try {
         checkAbort(signal);
         if (ttlMs) {
@@ -48962,6 +48977,7 @@ var init_hyperliquid_public_read = __esm({
             if (existing) return existing;
             const running = pending2.get(key);
             if (!running) break;
+            setPendingPhase("cache");
             await new Promise((resolve13, reject) => {
               const aborted2 = () => {
                 signal.removeEventListener("abort", aborted2);
@@ -48981,6 +48997,7 @@ var init_hyperliquid_public_read = __esm({
         }
         if (options.reservation?.closed) throw new DOMException("Hyperliquid account read was cancelled.", "AbortError");
         acquiring = true;
+        setPendingPhase("admission");
         permit = await admit(apiUrl, requestType, signal, void 0, deadline);
         acquiring = false;
         armDeadline(Math.min(deadline, permit?.expiresAt ?? Infinity));
@@ -48997,6 +49014,7 @@ var init_hyperliquid_public_read = __esm({
             signal.addEventListener("abort", transportAborted, { once: true });
           });
           const transport = (async () => {
+            setPendingPhase("transport");
             const received = await fetch(`${apiUrl}/info`, {
               method: "POST",
               headers: { "Content-Type": "application/json" },
@@ -49005,8 +49023,9 @@ var init_hyperliquid_public_read = __esm({
             });
             checkAbort(signal);
             if (received.status === 429) {
+              observedRateLimit = new HyperliquidPublicReadError("public_rate_limited", "Hyperliquid public API returned HTTP 429.", requestType, 429);
               await cooldown(apiUrl, received.headers.get("Retry-After"));
-              throw new HyperliquidPublicReadError("public_rate_limited", "Hyperliquid public API returned HTTP 429.", requestType, 429);
+              throw observedRateLimit;
             }
             const receivedPayload = await received.json().catch((error48) => {
               if (error48 instanceof SyntaxError) return {};
@@ -49017,6 +49036,7 @@ var init_hyperliquid_public_read = __esm({
           })();
           ({ response, payload } = await Promise.race([transport, aborted2]));
         } finally {
+          setPendingPhase(null);
           if (transportAborted) signal.removeEventListener("abort", transportAborted);
         }
         if (!response.ok) {
@@ -49034,6 +49054,7 @@ var init_hyperliquid_public_read = __esm({
         }
         return result2;
       } catch (error48) {
+        if (observedRateLimit) throw observedRateLimit;
         if (options.signal?.aborted) {
           outcome = "cancelled";
           throw abortError2(options.signal);
@@ -49044,6 +49065,7 @@ var init_hyperliquid_public_read = __esm({
         if (error48 instanceof Error && (error48.name === "TimeoutError" || error48.name === "AbortError")) throw new HyperliquidPublicReadError("public_timeout", "Hyperliquid public request timed out.", requestType);
         throw error48;
       } finally {
+        setPendingPhase(null);
         clearTimeout(timer);
         options.signal?.removeEventListener("abort", callerAborted);
         controller.abort();
@@ -50151,7 +50173,7 @@ var init_network_debug = __esm({
 });
 
 // lib/runtime/hyperliquid-account-state-adapter.ts
-var unsupportedUserActiveAssetCache, MAX_UNSUPPORTED_USER_ACTIVE_ASSET_CACHE_KEYS, UNSUPPORTED_USER_ACTIVE_ASSET_STORAGE_KEY, USER_FILLS_CACHE_STORAGE_PREFIX, ACCOUNT_STATE_CACHE_STORAGE_PREFIX, browserUserFillsCache, browserUserFillsInFlight, HYPERLIQUID_USER_FILLS_PROVIDER_PAGE_CAP, browserAccountStateCache, browserAccountStateInFlight, UNSUPPORTED_USER_ACTIVE_ASSET_DETAIL_PATTERNS, unsupportedUserActiveAssetCacheHydrated, hydrateUnsupportedUserActiveAssetCache, persistUnsupportedUserActiveAssetCache, toPositiveFinite, toFinite, firstFiniteNumber, parseFundingUsdcFromInfoPosition, buildActiveAssetCacheKey, buildUserFillsCacheKey, buildUserFillsStorageKey, buildAccountStateCacheKey, buildAccountStateStorageKey, hasActiveInfoRateLimitCooldown, requireNonNegativeConfigSeconds, requireAccountStateCacheConfig, requireUserFillsCacheConfig, normalizeFillSymbol, buildSymbolFilter, filterFillsBySymbols, readBrowserUserFillsCache, writeBrowserUserFillsCache, cloneBrowserAccountStateResult, withAccountStateEvidence, readBrowserAccountStateCache, writeBrowserAccountStateCache, isRateLimitError, createAbortError, waitForSharedBrowserRequest, waitForSharedBrowserUserFills, getBrowserActiveAssetTypeCandidates, normalizeHyperliquidErrorDetail, isUnsupportedUserActiveAssetError, rememberUnsupportedUserActiveAssetKey, parseInfoPositions, requireFinitePromptMetric, requirePromptClearinghouseState, requirePromptSpotState, normalizePerpDexName, listConfiguredPerpDexs, listPerpDexsForAccountState, prefixHip3PositionCoins, aggregateClearinghouseResponses, hasCompletePerpDexAccountMetrics, normalizeBrowserFillToTradeHistory, isPerpFill, awaitAccountReads, fetchHyperliquidInfoPayload, requireHyperliquidApiUrl, requireWalletAddress, parseInfoPositionSnapshot, fetchBrowserAccountState, fetchBrowserAccountStateUncached, fetchBrowserUserFills, fetchBrowserPositionSnapshot;
+var unsupportedUserActiveAssetCache, MAX_UNSUPPORTED_USER_ACTIVE_ASSET_CACHE_KEYS, UNSUPPORTED_USER_ACTIVE_ASSET_STORAGE_KEY, USER_FILLS_CACHE_STORAGE_PREFIX, ACCOUNT_STATE_CACHE_STORAGE_PREFIX, browserUserFillsCache, browserUserFillsInFlight, HYPERLIQUID_USER_FILLS_PROVIDER_PAGE_CAP, browserAccountStateCache, browserAccountStateInFlight, UNSUPPORTED_USER_ACTIVE_ASSET_DETAIL_PATTERNS, unsupportedUserActiveAssetCacheHydrated, hydrateUnsupportedUserActiveAssetCache, persistUnsupportedUserActiveAssetCache, toPositiveFinite, toFinite, firstFiniteNumber, parseFundingUsdcFromInfoPosition, buildActiveAssetCacheKey, buildUserFillsCacheKey, buildUserFillsStorageKey, buildAccountStateCacheKey, buildAccountStateStorageKey, hasActiveInfoRateLimitCooldown, requireNonNegativeConfigSeconds, requireAccountStateCacheConfig, requireUserFillsCacheConfig, normalizeFillSymbol, buildSymbolFilter, filterFillsBySymbols, readBrowserUserFillsCache, writeBrowserUserFillsCache, cloneBrowserAccountStateResult, withAccountStateEvidence, readBrowserAccountStateCache, writeBrowserAccountStateCache, isRateLimitError, createAbortError, waitForSharedBrowserRequest, waitForSharedBrowserUserFills, getBrowserActiveAssetTypeCandidates, normalizeHyperliquidErrorDetail, isUnsupportedUserActiveAssetError, rememberUnsupportedUserActiveAssetKey, parseInfoPositions, requireFinitePromptMetric, requirePromptClearinghouseState, requirePromptSpotState, normalizePerpDexName, listConfiguredPerpDexs, listPerpDexsForAccountState, prefixHip3PositionCoins, aggregateClearinghouseResponses, hasCompletePerpDexAccountMetrics, normalizeBrowserFillToTradeHistory, isPerpFill, settleAccountReads, fetchHyperliquidInfoRead, fetchHyperliquidInfoPayload, requireHyperliquidApiUrl, requireWalletAddress, parseInfoPositionSnapshot, fetchBrowserAccountState, fetchBrowserAccountStateUncached, fetchBrowserUserFills, fetchBrowserPositionSnapshot;
 var init_hyperliquid_account_state_adapter = __esm({
   "lib/runtime/hyperliquid-account-state-adapter.ts"() {
     "use strict";
@@ -50167,6 +50189,7 @@ var init_hyperliquid_account_state_adapter = __esm({
     init_hyperliquid_fee_contract();
     init_hyperliquid_market_symbol();
     init_network_debug();
+    init_runtime_policy_generated();
     unsupportedUserActiveAssetCache = /* @__PURE__ */ new Set();
     MAX_UNSUPPORTED_USER_ACTIVE_ASSET_CACHE_KEYS = 512;
     UNSUPPORTED_USER_ACTIVE_ASSET_STORAGE_KEY = "vtx:hyperliquid:unsupported-user-active-asset:v1";
@@ -50818,30 +50841,30 @@ var init_hyperliquid_account_state_adapter = __esm({
       }
       return true;
     };
-    awaitAccountReads = async (reads) => {
+    settleAccountReads = async (reads, controller) => {
       try {
         return await Promise.all(reads);
       } catch (error48) {
-        if (error48 instanceof HyperliquidPublicReadError && error48.code === "public_cooldown_active") {
-          const settled = await Promise.allSettled(reads);
-          for (const result2 of settled) {
-            if (result2.status === "rejected" && result2.reason instanceof HyperliquidPublicReadError && result2.reason.code === "public_rate_limited") throw result2.reason;
-          }
+        controller.abort(error48);
+        const settled = await Promise.allSettled(reads);
+        for (const result2 of settled) {
+          if (result2.status === "rejected" && result2.reason instanceof HyperliquidPublicReadError && result2.reason.code === "public_rate_limited") throw result2.reason;
         }
         throw error48;
       }
     };
-    fetchHyperliquidInfoPayload = async (apiUrl, body, signal, reservation) => {
+    fetchHyperliquidInfoRead = async (apiUrl, body, signal, reservation) => {
       const trace = startRuntimeNetworkDebugTrace({ kind: "exchange", label: `hyperliquid_info:${String(body.type)}`, method: "POST", url: `${apiUrl.replace(/\/$/, "")}/info` });
       try {
         const result2 = await readHyperliquidPublicInfo(apiUrl, body, { signal, reservation });
         trace.completeSuccess(200);
-        return result2.payload;
+        return result2;
       } catch (error48) {
         trace.completeError(error48, error48?.status ?? null);
         throw error48;
       }
     };
+    fetchHyperliquidInfoPayload = async (apiUrl, body, signal, reservation) => (await fetchHyperliquidInfoRead(apiUrl, body, signal, reservation)).payload;
     requireHyperliquidApiUrl = (config2) => {
       const apiUrl = String(config2.client_runtime_exchange_endpoints?.hyperliquid_api_url || "").trim();
       if (!apiUrl) {
@@ -50984,6 +51007,26 @@ var init_hyperliquid_account_state_adapter = __esm({
           { type: "userDexAbstraction", user: walletAddress }
         ] : []
       ], input.signal, { cacheAccountMode: true, cacheValidUntilMs: input.publicReadDeadlineMs });
+      if (input.onPublicReadPendingChange) {
+        const pending3 = { cache: 0, admission: 0, transport: 0 };
+        const reportPending = input.onPublicReadPendingChange;
+        reservation.onPendingPhaseChange = (previous, next) => {
+          if (previous) pending3[previous] -= 1;
+          if (next) pending3[next] += 1;
+          reportPending({ ...pending3 });
+        };
+        try {
+          reportPending({ ...pending3 });
+        } catch {
+        }
+      }
+      const parentSignal = input.signal;
+      const readController = new AbortController();
+      const cancelReads = () => readController.abort(parentSignal?.reason);
+      parentSignal?.addEventListener("abort", cancelReads, { once: true });
+      if (parentSignal?.aborted) cancelReads();
+      input = { ...input, signal: readController.signal };
+      const awaitAccountReads = (reads) => settleAccountReads(reads, readController);
       try {
         const userFeesPromise = input.includeEffectiveTakerRate === true ? (async () => ({
           ...await readHyperliquidPublicInfo(apiUrl, { type: "userFees", user: walletAddress }, { signal: input.signal, reservation }).catch((error48) => {
@@ -51025,67 +51068,56 @@ var init_hyperliquid_account_state_adapter = __esm({
             }
           }));
         }
-        const perpsPromise = (async () => {
-          const defaultResponse = await fetchHyperliquidInfoPayload(
-            apiUrl,
-            { type: "clearinghouseState", user: walletAddress },
-            input.signal,
-            reservation
-          );
-          if (input.includeEffectiveTakerRate === true) {
-            requirePromptClearinghouseState(defaultResponse, "default");
-          }
-          const dexResponses = await awaitAccountReads(
-            dexNames.map(async (dexName) => {
-              const response = await fetchHyperliquidInfoPayload(
-                apiUrl,
-                { type: "clearinghouseState", user: walletAddress, dex: dexName },
-                input.signal,
-                reservation
-              );
+        const dynamicPromise = (async () => {
+          const perpsDexes = ["", ...dexNames];
+          const components = [
+            ...perpsDexes.map((dex) => ({ dex, body: { type: "clearinghouseState", user: walletAddress, ...dex ? { dex } : {} } })),
+            { body: { type: "spotClearinghouseState", user: walletAddress } }
+          ];
+          const capture = async (component) => {
+            try {
+              const read = await fetchHyperliquidInfoRead(apiUrl, component.body, input.signal, reservation);
               if (input.includeEffectiveTakerRate === true) {
-                requirePromptClearinghouseState(response, dexName);
+                if (component.dex == null) requirePromptSpotState(read.payload);
+                else requirePromptClearinghouseState(read.payload, component.dex || "default");
               }
-              return {
-                dex: dexName,
-                payload: prefixHip3PositionCoins(response, dexName),
-                rawPayload: response
-              };
-            })
-          );
-          const selectedPayload = selectedDex ? dexResponses.find((entry) => entry.dex === selectedDex)?.payload : defaultResponse;
-          if (!selectedPayload) {
-            throw new Error(`Missing selected Hyperliquid clearinghouse state for DEX ${selectedDex}.`);
-          }
-          return {
-            payload: aggregateClearinghouseResponses([
-              defaultResponse,
-              ...dexResponses.map((entry) => entry.payload)
-            ]),
-            selectedPayload,
-            dexPayloads: [
-              { dex: "", payload: defaultResponse },
-              ...dexResponses.map(({ dex, rawPayload }) => ({ dex, payload: rawPayload }))
-            ],
-            capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+              component.read = read;
+            } catch (error48) {
+              if (component.dex != null || input.forceRefresh || input.includeEffectiveTakerRate === true) throw error48;
+              component.read = { payload: {}, fetchedAtMs: Date.now() };
+            }
           };
-        })();
-        const spotPromise = (async () => {
-          let payload;
-          try {
-            payload = await fetchHyperliquidInfoPayload(
-              apiUrl,
-              { type: "spotClearinghouseState", user: walletAddress },
-              input.signal,
-              reservation
-            );
-          } catch (error48) {
-            if (input.forceRefresh || input.includeEffectiveTakerRate === true) {
-              throw error48;
+          await awaitAccountReads(components.map(capture));
+          if (input.publicReadDeadlineMs != null && input.includeEffectiveTakerRate === true && input.includeExactAccountMode === true) {
+            const freshness = runtime_policy_generated_default.trading.engine.server_runtime.prompt_rescue;
+            const horizonMs = Math.min(freshness.snapshot_max_age_seconds, freshness.snapshot_component_max_skew_seconds) * 1e3;
+            for (; ; ) {
+              const now = Date.now();
+              const stale = components.filter(({ read }) => now - read.fetchedAtMs > horizonMs);
+              if (!stale.length) break;
+              if (now >= input.publicReadDeadlineMs) {
+                throw new HyperliquidPublicReadError("public_timeout", "Hyperliquid public request timed out.", "clearinghouseState");
+              }
+              await awaitAccountReads(stale.map(capture));
             }
-            payload = {};
           }
-          return { payload, capturedAt: (/* @__PURE__ */ new Date()).toISOString() };
+          const perpsReads = components.slice(0, perpsDexes.length).map((component) => ({
+            dex: component.dex,
+            payload: component.read.payload,
+            fetchedAtMs: component.read.fetchedAtMs
+          }));
+          const selectedRead = perpsReads.find(({ dex }) => dex === selectedDex);
+          if (!selectedRead) throw new Error(`Missing selected Hyperliquid clearinghouse state for DEX ${selectedDex}.`);
+          const spotRead = components[perpsDexes.length].read;
+          return {
+            perpsResult: {
+              payload: aggregateClearinghouseResponses(perpsReads.map(({ dex, payload }) => dex ? prefixHip3PositionCoins(payload, dex) : payload)),
+              selectedPayload: selectedDex ? prefixHip3PositionCoins(selectedRead.payload, selectedDex) : selectedRead.payload,
+              dexPayloads: perpsReads.map(({ dex, payload }) => ({ dex, payload })),
+              capturedAt: new Date(Math.min(...perpsReads.map(({ fetchedAtMs }) => fetchedAtMs))).toISOString()
+            },
+            spotResult: { payload: spotRead.payload, capturedAt: new Date(spotRead.fetchedAtMs).toISOString() }
+          };
         })();
         const activeAssetPromise = input.includeActiveAssetData === false ? Promise.resolve(null) : (async () => {
           let lastError = null;
@@ -51108,9 +51140,8 @@ var init_hyperliquid_account_state_adapter = __esm({
           }
           throw lastError instanceof Error ? lastError : new Error("Failed to fetch browser active asset data.");
         })();
-        const [perpsResult, spotResult, activeAssetResult, userFeesResult, exactAccountMode] = await awaitAccountReads([
-          perpsPromise,
-          spotPromise,
+        const [{ perpsResult, spotResult }, activeAssetResult, userFeesResult, exactAccountMode] = await awaitAccountReads([
+          dynamicPromise,
           activeAssetPromise,
           userFeesPromise,
           exactAccountModePromise
@@ -51235,7 +51266,7 @@ var init_hyperliquid_account_state_adapter = __esm({
           ...effectiveTakerRates == null ? {} : { effectiveTakerRates },
           ...exactAccountMode == null || userFeesResult == null ? {} : {
             promptRescueEvidence: {
-              capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              capturedAt: new Date(Math.min(Date.parse(perpsResult.capturedAt), Date.parse(spotResult.capturedAt))).toISOString(),
               perpsCapturedAt: perpsResult.capturedAt,
               spotCapturedAt: spotResult.capturedAt,
               feesCapturedAt: userFeesResult.capturedAt,
@@ -51245,6 +51276,8 @@ var init_hyperliquid_account_state_adapter = __esm({
           }
         };
       } finally {
+        parentSignal?.removeEventListener("abort", cancelReads);
+        readController.abort();
         await releaseHyperliquidPublicReadReservation(reservation);
       }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtxmacro/cli",
-  "version": "2026.9.56",
+  "version": "2026.9.58",
   "description": "VTX Macro CLI, MCP server, and durable external inference host.",
   "type": "module",
   "license": "UNLICENSED",