@vtxmacro/cli 2026.9.52 → 2026.9.53

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.52",
+  package_version: "2026.9.53",
   codex_package_name: "@openai/codex",
   codex_version: "0.153.3",
   copilot_sdk_package_name: "@github/copilot-sdk",
@@ -200,6 +200,14 @@ var runtime_policy_generated_default = {
           host_liveness_heartbeat_interval_ms: 3e4,
           host_liveness_recovery_nudge_ttl_ms: 1e4
         }
+      },
+      server_runtime: {
+        prompt_rescue: {
+          client_long_poll_seconds: 20,
+          client_claim_http_timeout_milliseconds: 25e3,
+          client_presence_heartbeat_interval_milliseconds: 3e4,
+          client_presence_http_timeout_milliseconds: 5e3
+        }
       }
     }
   },
@@ -244,7 +252,7 @@ var runtime_policy_generated_default = {
   exchange: {
     hyperliquid: {
       client_public_read_budget: {
-        max_weight: 900,
+        max_weight: 1200,
         window_seconds: 60,
         cooldown_seconds: 60,
         metadata_ttl_seconds: 300,
@@ -255,6 +263,7 @@ var runtime_policy_generated_default = {
       },
       read_budget: {
         weights: {
+          exchange: 1,
           exchangeStatus: 2,
           clearinghouseState: 2,
           spotClearinghouseState: 2,
@@ -285,7 +294,8 @@ var runtime_policy_generated_default = {
           authorizedAgents: 20,
           agents: 20,
           apiWallets: 20
-        }
+        },
+        exchange_action_batch_size: 40
       }
     }
   }

package/bin/vtx-service-launcher.js

@@ -83,6 +83,14 @@ var runtime_policy_generated_default = {
           host_liveness_heartbeat_interval_ms: 3e4,
           host_liveness_recovery_nudge_ttl_ms: 1e4
         }
+      },
+      server_runtime: {
+        prompt_rescue: {
+          client_long_poll_seconds: 20,
+          client_claim_http_timeout_milliseconds: 25e3,
+          client_presence_heartbeat_interval_milliseconds: 3e4,
+          client_presence_http_timeout_milliseconds: 5e3
+        }
       }
     }
   },
@@ -127,7 +135,7 @@ var runtime_policy_generated_default = {
   exchange: {
     hyperliquid: {
       client_public_read_budget: {
-        max_weight: 900,
+        max_weight: 1200,
         window_seconds: 60,
         cooldown_seconds: 60,
         metadata_ttl_seconds: 300,
@@ -138,6 +146,7 @@ var runtime_policy_generated_default = {
       },
       read_budget: {
         weights: {
+          exchange: 1,
           exchangeStatus: 2,
           clearinghouseState: 2,
           spotClearinghouseState: 2,
@@ -168,7 +177,8 @@ var runtime_policy_generated_default = {
           authorizedAgents: 20,
           agents: 20,
           apiWallets: 20
-        }
+        },
+        exchange_action_batch_size: 40
       }
     }
   }

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.52",
+      package_version: "2026.9.53",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -20541,6 +20541,14 @@ var init_runtime_policy_generated = __esm({
               host_liveness_heartbeat_interval_ms: 3e4,
               host_liveness_recovery_nudge_ttl_ms: 1e4
             }
+          },
+          server_runtime: {
+            prompt_rescue: {
+              client_long_poll_seconds: 20,
+              client_claim_http_timeout_milliseconds: 25e3,
+              client_presence_heartbeat_interval_milliseconds: 3e4,
+              client_presence_http_timeout_milliseconds: 5e3
+            }
           }
         }
       },
@@ -20585,7 +20593,7 @@ var init_runtime_policy_generated = __esm({
       exchange: {
         hyperliquid: {
           client_public_read_budget: {
-            max_weight: 900,
+            max_weight: 1200,
             window_seconds: 60,
             cooldown_seconds: 60,
             metadata_ttl_seconds: 300,
@@ -20596,6 +20604,7 @@ var init_runtime_policy_generated = __esm({
           },
           read_budget: {
             weights: {
+              exchange: 1,
               exchangeStatus: 2,
               clearinghouseState: 2,
               spotClearinghouseState: 2,
@@ -20626,7 +20635,8 @@ var init_runtime_policy_generated = __esm({
               authorizedAgents: 20,
               agents: 20,
               apiWallets: 20
-            }
+            },
+            exchange_action_batch_size: 40
           }
         }
       }
@@ -42519,6 +42529,14 @@ var init_runtime_policy_generated2 = __esm({
               host_liveness_heartbeat_interval_ms: 3e4,
               host_liveness_recovery_nudge_ttl_ms: 1e4
             }
+          },
+          server_runtime: {
+            prompt_rescue: {
+              client_long_poll_seconds: 20,
+              client_claim_http_timeout_milliseconds: 25e3,
+              client_presence_heartbeat_interval_milliseconds: 3e4,
+              client_presence_http_timeout_milliseconds: 5e3
+            }
           }
         }
       },
@@ -42563,7 +42581,7 @@ var init_runtime_policy_generated2 = __esm({
       exchange: {
         hyperliquid: {
           client_public_read_budget: {
-            max_weight: 900,
+            max_weight: 1200,
             window_seconds: 60,
             cooldown_seconds: 60,
             metadata_ttl_seconds: 300,
@@ -42574,6 +42592,7 @@ var init_runtime_policy_generated2 = __esm({
           },
           read_budget: {
             weights: {
+              exchange: 1,
               exchangeStatus: 2,
               clearinghouseState: 2,
               spotClearinghouseState: 2,
@@ -42604,7 +42623,8 @@ var init_runtime_policy_generated2 = __esm({
               authorizedAgents: 20,
               agents: 20,
               apiWallets: 20
-            }
+            },
+            exchange_action_batch_size: 40
           }
         }
       }
@@ -48546,7 +48566,7 @@ var init_runtime_redaction = __esm({
 });
 
 // lib/runtime/hyperliquid-public-read.ts
-var policy, weights, budgets, unpersistedBudgets, cache, pending2, PREFIX, abortError2, checkAbort, wait, storage, loadBudget, saveBudget, withBudgetLock, admit, cooldown, reserveHyperliquidPublicReads, readHyperliquidPublicInfo;
+var policy, weights, budgets, unpersistedBudgets, cache, pending2, PREFIX, abortError2, checkAbort, wait, storage, loadBudget, saveBudget, withBudgetLock, HyperliquidPublicReadError, cooldownError, admit, cooldown, cacheTtlMs, eligibleCache, reserveHyperliquidPublicReads, releaseHyperliquidPublicReadReservation, admitHyperliquidExchangeRequest, recordHyperliquidExchangeResponse, readHyperliquidPublicInfo;
 var init_hyperliquid_public_read = __esm({
   "lib/runtime/hyperliquid-public-read.ts"() {
     "use strict";
@@ -48618,31 +48638,54 @@ var init_hyperliquid_public_read = __esm({
       }
       return work();
     };
-    admit = async (apiUrl, requestType, signal, bundleWeight, bundleId) => {
+    HyperliquidPublicReadError = class extends Error {
+      constructor(code, message, requestType, status, retryAfterMs, requiredWeight, usedWeight, maxWeight) {
+        super(message);
+        this.code = code;
+        this.requestType = requestType;
+        this.status = status;
+        this.retryAfterMs = retryAfterMs;
+        this.requiredWeight = requiredWeight;
+        this.usedWeight = usedWeight;
+        this.maxWeight = maxWeight;
+        this.name = "HyperliquidPublicReadError";
+      }
+    };
+    cooldownError = (requestType, until) => new HyperliquidPublicReadError(
+      "public_cooldown_active",
+      "Hyperliquid public request cooldown is active.",
+      requestType,
+      void 0,
+      Math.max(0, until - Date.now())
+    );
+    admit = async (apiUrl, requestType, signal, bundleWeight, bundleId, deadlineMs) => {
       const key = `${PREFIX}${apiUrl}`;
       const weight = bundleWeight ?? weights[requestType] ?? policy.default_request_weight;
-      if (!(weight > 0 && weight <= policy.max_weight)) throw new Error("Invalid Hyperliquid public read weight.");
+      if (!(weight > 0 && weight <= policy.max_weight)) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public request exceeds the available allowance.", requestType, void 0, void 0, weight, void 0, policy.max_weight);
       for (; ; ) {
         checkAbort(signal);
-        const delay2 = await withBudgetLock(key, signal, () => {
+        const { delay: delay2, usedWeight } = await withBudgetLock(key, signal, () => {
           const now = Date.now();
           const budget = loadBudget(key);
           budget.reservations = budget.reservations.filter((r) => r.at > now - policy.window_seconds * 1e3);
-          if (budget.cooldownUntil > now) throw Object.assign(new Error("Hyperliquid public read rate-limit cooldown."), { status: 429, requestType });
+          if (budget.cooldownUntil > now) throw cooldownError(requestType, budget.cooldownUntil);
           let used = budget.reservations.reduce((sum, r) => sum + r.weight, 0);
+          const usedWeight2 = used;
           if (used + weight <= policy.max_weight) {
             budget.reservations.push({ at: now, weight, ...bundleId ? { id: bundleId } : {} });
             saveBudget(key, budget);
-            return 0;
+            return { delay: 0, usedWeight: usedWeight2 };
           }
           for (const reservation of budget.reservations) {
             used -= reservation.weight;
-            if (used + weight <= policy.max_weight) return Math.max(1, reservation.at + policy.window_seconds * 1e3 - now);
+            if (used + weight <= policy.max_weight) return { delay: Math.max(1, reservation.at + policy.window_seconds * 1e3 - now), usedWeight: usedWeight2 };
           }
           throw new Error("Invalid Hyperliquid public read budget.");
         });
         if (!delay2) return;
-        if (bundleWeight != null) throw Object.assign(new Error("Hyperliquid public read bundle budget exhausted."), { code: "public_budget_exhausted" });
+        if (bundleWeight != null || deadlineMs != null && Date.now() + delay2 >= deadlineMs) {
+          throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid local public request allowance is exhausted.", requestType, void 0, delay2, weight, usedWeight, policy.max_weight);
+        }
         await wait(delay2, signal);
       }
     };
@@ -48657,29 +48700,70 @@ var init_hyperliquid_public_read = __esm({
         saveBudget(key, budget);
       });
     };
-    reserveHyperliquidPublicReads = async (endpoint, bodies, signal) => {
+    cacheTtlMs = (body, options) => {
+      const requestType = String(body.type);
+      return (["meta", "spotMeta", "perpDexs"].includes(requestType) ? policy.metadata_ttl_seconds : requestType === "userFees" ? policy.user_fees_ttl_seconds : options.cacheAccountMode && ["userAbstraction", "userDexAbstraction"].includes(requestType) ? policy.account_mode_ttl_seconds : 0) * 1e3;
+    };
+    eligibleCache = (apiUrl, body, options) => {
+      const ttl = cacheTtlMs(body, options);
+      const existing = cache.get(`${apiUrl}:${JSON.stringify(body)}`);
+      const horizon = Math.max(Date.now(), options.cacheValidUntilMs ?? Date.now());
+      return ttl > 0 && existing && Date.now() >= existing.fetchedAtMs && horizon - existing.fetchedAtMs < ttl ? existing : void 0;
+    };
+    reserveHyperliquidPublicReads = async (endpoint, bodies, signal, options = {}) => {
       const apiUrl = endpoint.replace(/\/$/, "");
-      const weight = bodies.reduce((sum, body) => sum + (weights[String(body.type)] ?? policy.default_request_weight), 0);
-      const id2 = crypto.randomUUID();
-      const admittedAtMs = Date.now();
-      await admit(apiUrl, "bundle", signal, weight, id2);
+      const cached2 = /* @__PURE__ */ new Map();
       const remaining = /* @__PURE__ */ new Map();
+      let weight = 0;
       for (const body of bodies) {
         const key = JSON.stringify(body);
+        const hit = eligibleCache(apiUrl, body, options);
+        if (hit) {
+          cached2.set(key, hit);
+          continue;
+        }
         remaining.set(key, (remaining.get(key) ?? 0) + 1);
+        weight += weights[String(body.type)] ?? policy.default_request_weight;
       }
-      return { id: id2, endpoint: apiUrl, expiresAtMs: admittedAtMs + policy.window_seconds * 1e3, remaining };
+      const id2 = crypto.randomUUID();
+      const admittedAtMs = Date.now();
+      if (weight) await admit(apiUrl, "bundle", signal, weight, id2, options.cacheValidUntilMs);
+      return { id: id2, closed: false, endpoint: apiUrl, expiresAtMs: admittedAtMs + policy.window_seconds * 1e3, remaining, cached: cached2, cacheValidUntilMs: options.cacheValidUntilMs };
+    };
+    releaseHyperliquidPublicReadReservation = async (reservation) => {
+      reservation.closed = true;
+      const key = `${PREFIX}${reservation.endpoint}`;
+      await withBudgetLock(key, void 0, () => {
+        const budget = loadBudget(key);
+        const row = budget.reservations.find((entry) => entry.id === reservation.id);
+        if (row) {
+          const unused = [...reservation.remaining].reduce((sum, [body, count4]) => sum + (weights[String(JSON.parse(body).type)] ?? policy.default_request_weight) * count4, 0);
+          row.weight = Math.max(0, row.weight - unused);
+          budget.reservations = budget.reservations.filter((entry) => entry.weight > 0);
+          saveBudget(key, budget);
+        }
+        reservation.remaining.clear();
+      });
+    };
+    admitHyperliquidExchangeRequest = async (endpoint, action, signal) => {
+      const batchLength = Math.max(0, ...[action.orders, action.cancels, action.modifies].filter(Array.isArray).map((value) => value.length));
+      const weight = weights.exchange + Math.floor(batchLength / runtime_policy_generated_default.exchange.hyperliquid.read_budget.exchange_action_batch_size);
+      await admit(endpoint.replace(/\/$/, ""), "exchange", signal, weight);
+    };
+    recordHyperliquidExchangeResponse = async (endpoint, response) => {
+      if (response.status === 429) await cooldown(endpoint.replace(/\/$/, ""), response.headers.get("Retry-After"));
     };
     readHyperliquidPublicInfo = async (endpoint, body, options = {}) => {
       const apiUrl = endpoint.replace(/\/$/, "");
       const requestType = String(body.type ?? "info");
-      const ttlSeconds = ["meta", "spotMeta", "perpDexs"].includes(requestType) ? policy.metadata_ttl_seconds : requestType === "userFees" ? policy.user_fees_ttl_seconds : options.cacheAccountMode && ["userAbstraction", "userDexAbstraction"].includes(requestType) ? policy.account_mode_ttl_seconds : 0;
+      const cacheOptions = { ...options, cacheValidUntilMs: options.reservation?.cacheValidUntilMs ?? options.cacheValidUntilMs };
+      const ttlMs = cacheTtlMs(body, cacheOptions);
       const key = `${apiUrl}:${JSON.stringify(body)}`;
       checkAbort(options.signal);
-      if (ttlSeconds) {
+      if (ttlMs) {
         for (; ; ) {
-          const existing = cache.get(key);
-          if (existing && Date.now() - existing.fetchedAtMs >= 0 && Date.now() - existing.fetchedAtMs < ttlSeconds * 500) return existing;
+          const existing = options.reservation?.cached.get(JSON.stringify(body)) ?? eligibleCache(apiUrl, body, cacheOptions);
+          if (existing) return existing;
           const running = pending2.get(key);
           if (!running) break;
           await new Promise((resolve13, reject) => {
@@ -48697,26 +48781,31 @@ var init_hyperliquid_public_read = __esm({
         }
       }
       let settled;
-      if (ttlSeconds) pending2.set(key, new Promise((resolve13) => {
+      if (ttlMs) pending2.set(key, new Promise((resolve13) => {
         settled = resolve13;
       }));
       try {
         const reservedKey = JSON.stringify(body);
         const remaining = options.reservation?.remaining.get(reservedKey) ?? 0;
         if (options.reservation?.endpoint === apiUrl && remaining > 0) {
-          if (Date.now() >= options.reservation.expiresAtMs) throw Object.assign(new Error("Hyperliquid public read reservation expired."), { code: "public_budget_exhausted" });
+          if (Date.now() >= options.reservation.expiresAtMs) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public read reservation expired.", requestType);
           await withBudgetLock(`${PREFIX}${apiUrl}`, options.signal, () => {
+            if (options.reservation.closed) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public read bundle is closed.", requestType);
+            if ((options.reservation.remaining.get(reservedKey) ?? 0) <= 0) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid request is outside its admitted bundle.", requestType);
             const budget = loadBudget(`${PREFIX}${apiUrl}`);
             const row = budget.reservations.find((entry) => entry.id === options.reservation.id);
-            if (!row || Date.now() >= options.reservation.expiresAtMs) throw Object.assign(new Error("Hyperliquid public read reservation expired."), { code: "public_budget_exhausted" });
+            if (!row || Date.now() >= options.reservation.expiresAtMs) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public read reservation expired.", requestType);
             row.at = Date.now();
             budget.reservations.sort((a, b2) => a.at - b2.at);
+            options.reservation.remaining.set(reservedKey, (options.reservation.remaining.get(reservedKey) ?? 0) - 1);
             saveBudget(`${PREFIX}${apiUrl}`, budget);
           });
-          options.reservation.remaining.set(reservedKey, remaining - 1);
-        } else await admit(apiUrl, requestType, options.signal);
+        } else if (options.reservation) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid request is outside its admitted bundle.", requestType);
+        else await admit(apiUrl, requestType, options.signal, void 0, void 0, options.deadlineMs);
         checkAbort(options.signal);
-        if (loadBudget(`${PREFIX}${apiUrl}`).cooldownUntil > Date.now()) throw Object.assign(new Error("Hyperliquid public read rate-limit cooldown."), { status: 429, requestType });
+        if (options.reservation?.closed) throw new HyperliquidPublicReadError("public_budget_exhausted", "Hyperliquid public read bundle is closed.", requestType);
+        const cooldownUntil = loadBudget(`${PREFIX}${apiUrl}`).cooldownUntil;
+        if (cooldownUntil > Date.now()) throw cooldownError(requestType, cooldownUntil);
         const response = await fetch(`${apiUrl}/info`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
@@ -48724,22 +48813,31 @@ var init_hyperliquid_public_read = __esm({
           signal: options.signal
         });
         if (response.status === 429) await cooldown(apiUrl, response.headers.get("Retry-After"));
-        const payload = await response.json().catch(() => ({}));
+        const payload = await response.json().catch((error48) => {
+          if (error48 instanceof SyntaxError) return {};
+          throw error48;
+        });
         if (!response.ok) {
           const detail = sanitizeRuntimeDiagnosticValue(typeof payload?.response === "string" ? payload.response : typeof payload?.detail === "string" ? payload.detail : "");
+          if (response.status === 429) throw new HyperliquidPublicReadError("public_rate_limited", "Hyperliquid public API returned HTTP 429.", requestType, 429);
           throw Object.assign(new Error(`Hyperliquid info request failed (${response.status}) request_type=${requestType}.${detail ? ` ${detail}` : ""}`), {
             status: response.status,
             requestType
           });
         }
         const result2 = { payload, fetchedAtMs: Date.now() };
-        if (ttlSeconds) {
+        if (ttlMs) {
           cache.set(key, result2);
           while (cache.size > policy.cache_max_entries) cache.delete(cache.keys().next().value);
         }
         return result2;
+      } catch (error48) {
+        if (options.signal?.aborted || error48 instanceof HyperliquidPublicReadError) throw error48;
+        if (error48 instanceof TypeError) throw new HyperliquidPublicReadError("public_network_error", "Hyperliquid public request network failure.", requestType);
+        if (error48 instanceof Error && (error48.name === "TimeoutError" || error48.name === "AbortError")) throw new HyperliquidPublicReadError("public_timeout", "Hyperliquid public request timed out.", requestType);
+        throw error48;
       } finally {
-        if (ttlSeconds) {
+        if (ttlMs) {
           pending2.delete(key);
           settled?.();
         }
@@ -50736,273 +50834,283 @@ var init_hyperliquid_account_state_adapter = __esm({
       dexNames,
       staleIf429MaxAgeMs
     }) => {
-      const userFeesPromise = input.includeEffectiveTakerRate === true ? (async () => ({
-        ...await readHyperliquidPublicInfo(apiUrl, { type: "userFees", user: walletAddress }, { signal: input.signal }).catch((error48) => {
-          if (input.signal?.aborted) throw error48;
-          return { payload: null, fetchedAtMs: Date.now() };
-        }).then((result2) => ({ payload: result2.payload, capturedAt: new Date(result2.fetchedAtMs).toISOString() }))
-      }))() : Promise.resolve(null);
-      const exactAccountModePromise = input.includeExactAccountMode === true ? (async () => {
-        const abstractionRead = await readHyperliquidPublicInfo(apiUrl, { type: "userAbstraction", user: walletAddress }, { signal: input.signal, cacheAccountMode: true });
-        const userAbstraction = abstractionRead.payload;
-        let capturedAtMs = abstractionRead.fetchedAtMs;
-        const preliminaryMode = extractCanonicalHyperliquidAccountMode(userAbstraction);
-        if (!preliminaryMode) {
-          throw new Error("Exact Hyperliquid userAbstraction response is invalid.");
-        }
-        let userDexAbstraction;
-        if (preliminaryMode === "default" || preliminaryMode === "disabled") {
-          const dexRead = await readHyperliquidPublicInfo(apiUrl, { type: "userDexAbstraction", user: walletAddress }, { signal: input.signal, cacheAccountMode: true });
-          userDexAbstraction = dexRead.payload;
-          capturedAtMs = Math.min(capturedAtMs, dexRead.fetchedAtMs);
-        }
-        return {
-          accountMode: resolveExactHyperliquidAccountMode(
-            userAbstraction,
-            userDexAbstraction
-          ),
-          capturedAt: new Date(capturedAtMs).toISOString()
-        };
-      })() : Promise.resolve(null);
-      await Promise.all([userFeesPromise, exactAccountModePromise]);
-      const metadataByDex = /* @__PURE__ */ new Map();
-      if (input.includeEffectiveTakerRate === true) {
-        await Promise.all(["", ...dexNames].map(async (dex) => {
-          try {
-            metadataByDex.set(dex, await fetchHyperliquidInfoPayload(apiUrl, { type: "meta", ...dex ? { dex } : {} }, input.signal));
-          } catch (error48) {
-            if (input.signal?.aborted) throw error48;
-            metadataByDex.set(dex, null);
-          }
-        }));
-      }
+      const metadataBodies = input.includeEffectiveTakerRate === true ? ["", ...dexNames].map((dex) => ({ type: "meta", ...dex ? { dex } : {} })) : [];
       const reservation = await reserveHyperliquidPublicReads(apiUrl, [
         { type: "clearinghouseState", user: walletAddress },
         ...dexNames.map((dex) => ({ type: "clearinghouseState", user: walletAddress, dex })),
         { type: "spotClearinghouseState", user: walletAddress },
-        ...input.includeActiveAssetData === false ? [] : activeAssetRequestTypes.map((type) => ({ type, user: walletAddress, coin: symbol2 }))
-      ], input.signal);
-      const perpsPromise = (async () => {
-        const defaultResponse = await fetchHyperliquidInfoPayload(
-          apiUrl,
-          { type: "clearinghouseState", user: walletAddress },
-          input.signal,
-          reservation
-        );
+        ...input.includeActiveAssetData === false ? [] : activeAssetRequestTypes.map((type) => ({ type, user: walletAddress, coin: symbol2 })),
+        ...input.includeEffectiveTakerRate === true ? [{ type: "userFees", user: walletAddress }, ...metadataBodies] : [],
+        ...input.includeExactAccountMode === true ? [
+          { type: "userAbstraction", user: walletAddress },
+          { type: "userDexAbstraction", user: walletAddress }
+        ] : []
+      ], input.signal, { cacheAccountMode: true, cacheValidUntilMs: input.publicReadDeadlineMs });
+      try {
+        const userFeesPromise = input.includeEffectiveTakerRate === true ? (async () => ({
+          ...await readHyperliquidPublicInfo(apiUrl, { type: "userFees", user: walletAddress }, { signal: input.signal, reservation }).catch((error48) => {
+            if (input.signal?.aborted || error48 instanceof HyperliquidPublicReadError || isRateLimitError(error48)) throw error48;
+            return { payload: null, fetchedAtMs: Date.now() };
+          }).then((result2) => ({ payload: result2.payload, capturedAt: new Date(result2.fetchedAtMs).toISOString() }))
+        }))() : Promise.resolve(null);
+        const exactAccountModePromise = input.includeExactAccountMode === true ? (async () => {
+          const abstractionRead = await readHyperliquidPublicInfo(apiUrl, { type: "userAbstraction", user: walletAddress }, { signal: input.signal, reservation, cacheAccountMode: true });
+          const userAbstraction = abstractionRead.payload;
+          let capturedAtMs = abstractionRead.fetchedAtMs;
+          const preliminaryMode = extractCanonicalHyperliquidAccountMode(userAbstraction);
+          if (!preliminaryMode) {
+            throw new Error("Exact Hyperliquid userAbstraction response is invalid.");
+          }
+          let userDexAbstraction;
+          if (preliminaryMode === "default" || preliminaryMode === "disabled") {
+            const dexRead = await readHyperliquidPublicInfo(apiUrl, { type: "userDexAbstraction", user: walletAddress }, { signal: input.signal, reservation, cacheAccountMode: true });
+            userDexAbstraction = dexRead.payload;
+            capturedAtMs = Math.min(capturedAtMs, dexRead.fetchedAtMs);
+          }
+          return {
+            accountMode: resolveExactHyperliquidAccountMode(
+              userAbstraction,
+              userDexAbstraction
+            ),
+            capturedAt: new Date(capturedAtMs).toISOString()
+          };
+        })() : Promise.resolve(null);
+        await Promise.all([userFeesPromise, exactAccountModePromise]);
+        const metadataByDex = /* @__PURE__ */ new Map();
         if (input.includeEffectiveTakerRate === true) {
-          requirePromptClearinghouseState(defaultResponse, "default");
-        }
-        const dexResponses = await Promise.all(
-          dexNames.map(async (dexName) => {
-            const response = await fetchHyperliquidInfoPayload(
-              apiUrl,
-              { type: "clearinghouseState", user: walletAddress, dex: dexName },
-              input.signal,
-              reservation
-            );
-            if (input.includeEffectiveTakerRate === true) {
-              requirePromptClearinghouseState(response, dexName);
+          await Promise.all(["", ...dexNames].map(async (dex) => {
+            try {
+              metadataByDex.set(dex, await fetchHyperliquidInfoPayload(apiUrl, { type: "meta", ...dex ? { dex } : {} }, input.signal, reservation));
+            } catch (error48) {
+              if (input.signal?.aborted || error48 instanceof HyperliquidPublicReadError || isRateLimitError(error48)) throw error48;
+              metadataByDex.set(dex, null);
             }
-            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()
-        };
-      })();
-      const spotPromise = (async () => {
-        let payload;
-        try {
-          payload = await fetchHyperliquidInfoPayload(
+        const perpsPromise = (async () => {
+          const defaultResponse = await fetchHyperliquidInfoPayload(
             apiUrl,
-            { type: "spotClearinghouseState", user: walletAddress },
+            { type: "clearinghouseState", user: walletAddress },
             input.signal,
             reservation
           );
-        } catch (error48) {
-          recordInfoRateLimitCooldownFromError(apiUrl, error48, staleIf429MaxAgeMs);
-          if (input.forceRefresh || input.includeEffectiveTakerRate === true) {
-            throw error48;
+          if (input.includeEffectiveTakerRate === true) {
+            requirePromptClearinghouseState(defaultResponse, "default");
+          }
+          const dexResponses = await Promise.all(
+            dexNames.map(async (dexName) => {
+              const response = await fetchHyperliquidInfoPayload(
+                apiUrl,
+                { type: "clearinghouseState", user: walletAddress, dex: dexName },
+                input.signal,
+                reservation
+              );
+              if (input.includeEffectiveTakerRate === true) {
+                requirePromptClearinghouseState(response, dexName);
+              }
+              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}.`);
           }
-          payload = {};
-        }
-        return { payload, capturedAt: (/* @__PURE__ */ new Date()).toISOString() };
-      })();
-      const activeAssetPromise = input.includeActiveAssetData === false ? Promise.resolve(null) : (async () => {
-        let lastError = null;
-        for (const typeName of activeAssetRequestTypes) {
+          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()
+          };
+        })();
+        const spotPromise = (async () => {
+          let payload;
           try {
-            const payload = await fetchHyperliquidInfoPayload(
+            payload = await fetchHyperliquidInfoPayload(
               apiUrl,
-              { type: typeName, user: walletAddress, coin: symbol2 },
+              { type: "spotClearinghouseState", user: walletAddress },
               input.signal,
               reservation
             );
-            return { payload, type: typeName };
           } catch (error48) {
-            lastError = error48;
             recordInfoRateLimitCooldownFromError(apiUrl, error48, staleIf429MaxAgeMs);
-            if (isRateLimitError(error48)) throw error48;
-            if (typeName === "userActiveAssetData" && isUnsupportedUserActiveAssetError(error48)) {
-              rememberUnsupportedUserActiveAssetKey(activeAssetCacheKey);
+            if (input.forceRefresh || input.includeEffectiveTakerRate === true) {
+              throw error48;
             }
+            payload = {};
           }
-        }
-        throw lastError instanceof Error ? lastError : new Error("Failed to fetch browser active asset data.");
-      })();
-      const [perpsResult, spotResult, activeAssetResult, userFeesResult, exactAccountMode] = await Promise.all([
-        perpsPromise,
-        spotPromise,
-        activeAssetPromise,
-        userFeesPromise,
-        exactAccountModePromise
-      ]);
-      const perpsResponse = perpsResult.payload;
-      const accountSummaryPerpsResponse = input.scopeAccountSummaryToSelectedDex === true ? perpsResult.selectedPayload : perpsResponse;
-      const spotResponse = spotResult.payload;
-      const userFeesResponse = userFeesResult?.payload ?? null;
-      if (input.includeEffectiveTakerRate === true) {
-        requirePromptSpotState(spotResponse);
-      }
-      let takerRate;
-      if (input.includeEffectiveTakerRate === true) {
-        const raw = userFeesResponse?.userCrossRate;
-        if ((typeof raw === "number" || typeof raw === "string" && raw.trim() !== "") && Number.isFinite(Number(raw)) && Number(raw) >= 0 && Number(raw) < 1) takerRate = Number(raw);
-      }
-      let effectiveTakerRates;
-      if (input.includeEffectiveTakerRate === true) {
-        const feeSymbols = [...new Set([
-          ...input.feeSymbols ?? [symbol2],
-          ...parseInfoPositions(perpsResponse).filter((position) => Number(position.size) !== 0).map((position) => position.symbol)
-        ].map(normalizeHyperliquidMarketSymbol).filter(Boolean))].sort();
-        const feeDexes = [...new Set(feeSymbols.map(getHyperliquidMarketDex))];
-        const metadata = await Promise.all(feeDexes.map(async (dex) => {
-          try {
-            const payload = metadataByDex.get(dex) ?? null;
-            return [dex, payload];
-          } catch (error48) {
-            if (input.signal?.aborted) throw error48;
-            return [dex, null];
+          return { payload, capturedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        })();
+        const activeAssetPromise = input.includeActiveAssetData === false ? Promise.resolve(null) : (async () => {
+          let lastError = null;
+          for (const typeName of activeAssetRequestTypes) {
+            try {
+              const payload = await fetchHyperliquidInfoPayload(
+                apiUrl,
+                { type: typeName, user: walletAddress, coin: symbol2 },
+                input.signal,
+                reservation
+              );
+              return { payload, type: typeName };
+            } catch (error48) {
+              lastError = error48;
+              recordInfoRateLimitCooldownFromError(apiUrl, error48, staleIf429MaxAgeMs);
+              if (isRateLimitError(error48)) throw error48;
+              if (typeName === "userActiveAssetData" && isUnsupportedUserActiveAssetError(error48)) {
+                rememberUnsupportedUserActiveAssetKey(activeAssetCacheKey);
+              }
+            }
           }
-        }));
-        effectiveTakerRates = effectiveHyperliquidTakerRates(feeSymbols, userFeesResponse ?? {}, Object.fromEntries(metadata));
-      }
-      const accountStateConfig = input.config.client_runtime_hyperliquid_account_state;
-      const summaryPerpsResponse = exactAccountMode ? { ...accountSummaryPerpsResponse, accountMode: exactAccountMode.accountMode } : accountSummaryPerpsResponse;
-      const accountSummaryOptions = {
-        spotDominatesMinTotalUsd: accountStateConfig?.spot_dominates_min_total_usd,
-        spotDominatesPerpsMultiplier: accountStateConfig?.spot_dominates_perps_multiplier,
-        mirroredAccountValueAbsoluteToleranceUsd: accountStateConfig?.mirrored_account_value_absolute_tolerance_usd,
-        mirroredAccountValueRelativeTolerance: accountStateConfig?.mirrored_account_value_relative_tolerance
-      };
-      const walletSummary = exactAccountMode && input.scopeAccountSummaryToSelectedDex !== true ? buildServerPromptRescueAccountSummary(
-        perpsResponse,
-        spotResponse,
-        exactAccountMode.accountMode,
-        accountSummaryOptions
-      ) : buildAccountSummaryFromInfoResponses(
-        perpsResponse,
-        spotResponse,
-        accountSummaryOptions
-      );
-      const normalizedSummary = input.scopeAccountSummaryToSelectedDex === true ? {
-        ...buildAccountSummaryFromInfoResponses(
+          throw lastError instanceof Error ? lastError : new Error("Failed to fetch browser active asset data.");
+        })();
+        const [perpsResult, spotResult, activeAssetResult, userFeesResult, exactAccountMode] = await Promise.all([
+          perpsPromise,
+          spotPromise,
+          activeAssetPromise,
+          userFeesPromise,
+          exactAccountModePromise
+        ]);
+        const perpsResponse = perpsResult.payload;
+        const accountSummaryPerpsResponse = input.scopeAccountSummaryToSelectedDex === true ? perpsResult.selectedPayload : perpsResponse;
+        const spotResponse = spotResult.payload;
+        const userFeesResponse = userFeesResult?.payload ?? null;
+        if (input.includeEffectiveTakerRate === true) {
+          requirePromptSpotState(spotResponse);
+        }
+        let takerRate;
+        if (input.includeEffectiveTakerRate === true) {
+          const raw = userFeesResponse?.userCrossRate;
+          if ((typeof raw === "number" || typeof raw === "string" && raw.trim() !== "") && Number.isFinite(Number(raw)) && Number(raw) >= 0 && Number(raw) < 1) takerRate = Number(raw);
+        }
+        let effectiveTakerRates;
+        if (input.includeEffectiveTakerRate === true) {
+          const feeSymbols = [...new Set([
+            ...input.feeSymbols ?? [symbol2],
+            ...parseInfoPositions(perpsResponse).filter((position) => Number(position.size) !== 0).map((position) => position.symbol)
+          ].map(normalizeHyperliquidMarketSymbol).filter(Boolean))].sort();
+          const feeDexes = [...new Set(feeSymbols.map(getHyperliquidMarketDex))];
+          const metadata = await Promise.all(feeDexes.map(async (dex) => {
+            try {
+              const payload = metadataByDex.get(dex) ?? null;
+              return [dex, payload];
+            } catch (error48) {
+              if (input.signal?.aborted) throw error48;
+              return [dex, null];
+            }
+          }));
+          effectiveTakerRates = effectiveHyperliquidTakerRates(feeSymbols, userFeesResponse ?? {}, Object.fromEntries(metadata));
+        }
+        const accountStateConfig = input.config.client_runtime_hyperliquid_account_state;
+        const summaryPerpsResponse = exactAccountMode ? { ...accountSummaryPerpsResponse, accountMode: exactAccountMode.accountMode } : accountSummaryPerpsResponse;
+        const accountSummaryOptions = {
+          spotDominatesMinTotalUsd: accountStateConfig?.spot_dominates_min_total_usd,
+          spotDominatesPerpsMultiplier: accountStateConfig?.spot_dominates_perps_multiplier,
+          mirroredAccountValueAbsoluteToleranceUsd: accountStateConfig?.mirrored_account_value_absolute_tolerance_usd,
+          mirroredAccountValueRelativeTolerance: accountStateConfig?.mirrored_account_value_relative_tolerance
+        };
+        const walletSummary = exactAccountMode && input.scopeAccountSummaryToSelectedDex !== true ? buildServerPromptRescueAccountSummary(
+          perpsResponse,
+          spotResponse,
+          exactAccountMode.accountMode,
+          accountSummaryOptions
+        ) : buildAccountSummaryFromInfoResponses(
+          perpsResponse,
+          spotResponse,
+          accountSummaryOptions
+        );
+        const normalizedSummary = input.scopeAccountSummaryToSelectedDex === true ? {
+          ...buildAccountSummaryFromInfoResponses(
+            summaryPerpsResponse,
+            {},
+            accountSummaryOptions
+          ),
+          balances: walletSummary.balances
+        } : exactAccountMode ? buildServerPromptRescueAccountSummary(
+          accountSummaryPerpsResponse,
+          spotResponse,
+          exactAccountMode.accountMode,
+          accountSummaryOptions
+        ) : buildAccountSummaryFromInfoResponses(
           summaryPerpsResponse,
-          {},
+          spotResponse,
           accountSummaryOptions
-        ),
-        balances: walletSummary.balances
-      } : exactAccountMode ? buildServerPromptRescueAccountSummary(
-        accountSummaryPerpsResponse,
-        spotResponse,
-        exactAccountMode.accountMode,
-        accountSummaryOptions
-      ) : buildAccountSummaryFromInfoResponses(
-        summaryPerpsResponse,
-        spotResponse,
-        accountSummaryOptions
-      );
-      const accountSummary = {
-        ...normalizedSummary,
-        ...input.scopeAccountSummaryToSelectedDex === true ? {} : {
-          perp_dex_accounts: perpsResult.dexPayloads.filter(({ payload }) => hasCompletePerpDexAccountMetrics(payload)).map(({ dex, payload }) => {
-            const summary = buildServerPromptRescueAccountSummary({
-              ...payload,
-              crossMaintenanceMarginUsed: firstFiniteNumber([
-                payload.crossMaintenanceMarginUsed,
-                payload.marginSummary?.crossMaintenanceMarginUsed,
-                payload.marginSummary?.totalMaintenanceMargin
-              ])
-            }, {}, "disabled", accountSummaryOptions);
-            const accountValue = Number(payload.marginSummary.accountValue);
-            const calculatedAvailable = accountValue - summary.total_margin_used;
-            const availableMargin = summary.maintenance_margin > 0 ? Math.max(calculatedAvailable, Math.max(0, accountValue - 4 * summary.maintenance_margin), summary.withdrawable) : Math.max(calculatedAvailable, summary.withdrawable);
-            return {
-              dex,
-              account_value: accountValue,
-              total_margin_used: summary.total_margin_used,
-              available_margin: availableMargin,
-              withdrawable: summary.withdrawable,
-              maintenance_margin: summary.maintenance_margin,
-              cross_account_leverage: summary.cross_account_leverage,
-              total_unrealized_pnl: summary.total_unrealized_pnl ?? 0
-            };
-          })
-        },
-        ...exactAccountMode == null ? {} : { account_mode: exactAccountMode.accountMode, mode_source: "canonical" },
-        address: walletAddress,
-        dex: input.scopeAccountSummaryToSelectedDex === true ? selectedDex : "all",
-        market_type: "perp"
-      };
-      const activeAssetPayload = activeAssetResult?.payload ?? null;
-      const activeAssetType = activeAssetResult?.type ?? "promptAccountState";
-      const normalizedActiveAsset = normalizeActiveAssetData(activeAssetPayload, symbol2);
-      const markPrice = toPositiveFinite(normalizedActiveAsset.mark_price, toPositiveFinite(input.tickerPrice));
-      const fallbackLeverage = toPositiveFinite(input.leverage, 1);
-      const availableBase = Math.max(0, toFinite(accountSummary.available_margin, 0));
-      const availableToTrade = {
-        symbol: symbol2,
-        available_to_trade_buy: Math.max(0, toFinite(normalizedActiveAsset.available_to_trade_buy, availableBase)),
-        available_to_trade_sell: Math.max(0, toFinite(normalizedActiveAsset.available_to_trade_sell, availableBase)),
-        max_trade_size_buy: Math.max(0, toFinite(normalizedActiveAsset.max_trade_size_buy, availableBase * fallbackLeverage)),
-        max_trade_size_sell: Math.max(0, toFinite(normalizedActiveAsset.max_trade_size_sell, availableBase * fallbackLeverage)),
-        mark_price: markPrice,
-        source: `browser_exchange:${activeAssetType}`
-      };
-      return {
-        accountSummary,
-        availableToTrade,
-        positions: parseInfoPositions(perpsResponse),
-        ...takerRate == null ? {} : { takerRate },
-        ...effectiveTakerRates == null ? {} : { effectiveTakerRates },
-        ...exactAccountMode == null || userFeesResult == null ? {} : {
-          promptRescueEvidence: {
-            capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            perpsCapturedAt: perpsResult.capturedAt,
-            spotCapturedAt: spotResult.capturedAt,
-            feesCapturedAt: userFeesResult.capturedAt,
-            accountModeCapturedAt: exactAccountMode.capturedAt,
-            accountModeSource: "canonical"
+        );
+        const accountSummary = {
+          ...normalizedSummary,
+          ...input.scopeAccountSummaryToSelectedDex === true ? {} : {
+            perp_dex_accounts: perpsResult.dexPayloads.filter(({ payload }) => hasCompletePerpDexAccountMetrics(payload)).map(({ dex, payload }) => {
+              const summary = buildServerPromptRescueAccountSummary({
+                ...payload,
+                crossMaintenanceMarginUsed: firstFiniteNumber([
+                  payload.crossMaintenanceMarginUsed,
+                  payload.marginSummary?.crossMaintenanceMarginUsed,
+                  payload.marginSummary?.totalMaintenanceMargin
+                ])
+              }, {}, "disabled", accountSummaryOptions);
+              const accountValue = Number(payload.marginSummary.accountValue);
+              const calculatedAvailable = accountValue - summary.total_margin_used;
+              const availableMargin = summary.maintenance_margin > 0 ? Math.max(calculatedAvailable, Math.max(0, accountValue - 4 * summary.maintenance_margin), summary.withdrawable) : Math.max(calculatedAvailable, summary.withdrawable);
+              return {
+                dex,
+                account_value: accountValue,
+                total_margin_used: summary.total_margin_used,
+                available_margin: availableMargin,
+                withdrawable: summary.withdrawable,
+                maintenance_margin: summary.maintenance_margin,
+                cross_account_leverage: summary.cross_account_leverage,
+                total_unrealized_pnl: summary.total_unrealized_pnl ?? 0
+              };
+            })
+          },
+          ...exactAccountMode == null ? {} : { account_mode: exactAccountMode.accountMode, mode_source: "canonical" },
+          address: walletAddress,
+          dex: input.scopeAccountSummaryToSelectedDex === true ? selectedDex : "all",
+          market_type: "perp"
+        };
+        const activeAssetPayload = activeAssetResult?.payload ?? null;
+        const activeAssetType = activeAssetResult?.type ?? "promptAccountState";
+        const normalizedActiveAsset = normalizeActiveAssetData(activeAssetPayload, symbol2);
+        const markPrice = toPositiveFinite(normalizedActiveAsset.mark_price, toPositiveFinite(input.tickerPrice));
+        const fallbackLeverage = toPositiveFinite(input.leverage, 1);
+        const availableBase = Math.max(0, toFinite(accountSummary.available_margin, 0));
+        const availableToTrade = {
+          symbol: symbol2,
+          available_to_trade_buy: Math.max(0, toFinite(normalizedActiveAsset.available_to_trade_buy, availableBase)),
+          available_to_trade_sell: Math.max(0, toFinite(normalizedActiveAsset.available_to_trade_sell, availableBase)),
+          max_trade_size_buy: Math.max(0, toFinite(normalizedActiveAsset.max_trade_size_buy, availableBase * fallbackLeverage)),
+          max_trade_size_sell: Math.max(0, toFinite(normalizedActiveAsset.max_trade_size_sell, availableBase * fallbackLeverage)),
+          mark_price: markPrice,
+          source: `browser_exchange:${activeAssetType}`
+        };
+        return {
+          accountSummary,
+          availableToTrade,
+          positions: parseInfoPositions(perpsResponse),
+          ...takerRate == null ? {} : { takerRate },
+          ...effectiveTakerRates == null ? {} : { effectiveTakerRates },
+          ...exactAccountMode == null || userFeesResult == null ? {} : {
+            promptRescueEvidence: {
+              capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              perpsCapturedAt: perpsResult.capturedAt,
+              spotCapturedAt: spotResult.capturedAt,
+              feesCapturedAt: userFeesResult.capturedAt,
+              accountModeCapturedAt: exactAccountMode.capturedAt,
+              accountModeSource: "canonical"
+            }
           }
-        }
-      };
+        };
+      } finally {
+        await releaseHyperliquidPublicReadReservation(reservation);
+      }
     };
     fetchBrowserUserFills = async (input) => {
       configureHyperliquidMarketSymbolCasing(input.config.client_runtime_hyperliquid_case_sensitive_symbols);
@@ -85510,9 +85618,11 @@ var init_hyperliquid_client = __esm({
               }
             }
             try {
+              await admitHyperliquidExchangeRequest(apiUrl, input.payload.action, input.signal);
               assertFreshPreparedExecutionContext(input.preparedContext);
             } catch (preparedContextError) {
               await settleDurableMutation("rejected");
+              if (isAbortLikeError(preparedContextError) || preparedContextError instanceof HyperliquidPublicReadError) throw preparedContextError;
               throw new RuntimeExecutionError(
                 preparedContextError instanceof Error ? preparedContextError.message : "Prepared exchange context expired before dispatch.",
                 "local_safety_block"
@@ -85545,6 +85655,7 @@ var init_hyperliquid_client = __esm({
               body: serializedPayload
             });
             responseStatus = response.status;
+            await recordHyperliquidExchangeResponse(apiUrl, response);
             const payload = await response.json().catch(() => ({}));
             if (!response.ok) {
               await settleDurableMutation("transport_ambiguous");

package/package.json

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