@vtxmacro/cli 2026.9.52 → 2026.9.54

package/bin/vtx.js

@@ -77,9 +77,9 @@ 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.54",
       codex_package_name: "@openai/codex",
-      codex_version: "0.153.3",
+      codex_version: "0.155.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
       copilot_sdk_version: "1.0.0-beta.8",
       copilot_cli_package_name: "@github/copilot",
@@ -143,13 +143,13 @@ var init_agent_cli_release = __esm({
           package_name: "@openai/codex-linux-x64",
           target: "x86_64-unknown-linux-musl",
           binary_name: "codex",
-          sha256: "f9d4eab23d0e0726340e084ed22d668885c1dcabeb29ec508b8962e5e29b8dc6"
+          sha256: "660e159a49e823ac8e5986cb238f73158ce4b957d40d9292f8de90862644b501"
         },
         "win32-x64": {
           package_name: "@openai/codex-win32-x64",
           target: "x86_64-pc-windows-msvc",
           binary_name: "codex.exe",
-          sha256: "e5ef3c4b81d2fb861f3731c91a773d45a1973c6a0b480d6449f80bc8fd749e96"
+          sha256: "e4c11374bd9de8ad5c3b7617fd4654bb7839901edb0863f9930666863c7a021b"
         }
       },
       pi_coding_agent_package_name: "@earendil-works/pi-coding-agent",
@@ -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
           }
         }
       }
@@ -40287,10 +40297,10 @@ var init_grok_transport_proxy = __esm({
 
 // lib/inference-host/grok-runtime.ts
 import { spawn as spawn7 } from "node:child_process";
-import { randomBytes as randomBytes7 } from "node:crypto";
+import { randomBytes as randomBytes7, randomUUID as randomUUID7 } from "node:crypto";
 import { createServer as createServer4 } from "node:http";
 import { join as join9 } from "node:path";
-import { lstat as lstat6 } from "node:fs/promises";
+import { link, lstat as lstat6, rm as rm8 } from "node:fs/promises";
 var grokObject, grokRuntimeEnvironment, prepareGrokHome, GrokAcpSession, createGrokToolServer;
 var init_grok_runtime = __esm({
   "lib/inference-host/grok-runtime.ts"() {
@@ -40357,6 +40367,28 @@ var init_grok_runtime = __esm({
         env.XDG_STATE_HOME,
         env.XDG_CACHE_HOME
       ]) await ensureInferencePrivateDirectory(path);
+      const agentIdPath = join9(grokHome, "agent_id");
+      let needsAgentId = false;
+      try {
+        await lstat6(agentIdPath);
+      } catch (error48) {
+        if (error48.code !== "ENOENT") throw error48;
+        needsAgentId = true;
+      }
+      if (needsAgentId) {
+        const temporary = join9(grokHome, `.agent-id-${randomUUID7()}.tmp`);
+        try {
+          await writeAtomicInferencePrivateFile(temporary, `${randomUUID7()}
+`);
+          try {
+            await link(temporary, agentIdPath);
+          } catch (error48) {
+            if (error48.code !== "EEXIST") throw error48;
+          }
+        } finally {
+          await rm8(temporary, { force: true });
+        }
+      }
       await writeAtomicInferencePrivateFile(join9(grokHome, "config.toml"), "[claude_compat]\nimported = true\n");
       await writeAtomicInferencePrivateFile(join9(grokHome, "requirements.toml"), [
         "[auth]",
@@ -40576,7 +40608,7 @@ var init_grok_runtime = __esm({
 
 // lib/inference-host/grok-state.ts
 import { constants as constants2 } from "node:fs";
-import { lstat as lstat7, mkdtemp as mkdtemp4, open as open3, readdir as readdir3, realpath as realpath6, rm as rm8, rmdir, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import { lstat as lstat7, mkdtemp as mkdtemp4, open as open3, readdir as readdir3, realpath as realpath6, rm as rm9, rmdir, unlink, writeFile as writeFile3 } from "node:fs/promises";
 import { basename as basename3, dirname as dirname8, join as join10, resolve as resolve6 } from "node:path";
 var markerName, ownedName, invalid, missing, sessionIdValid, directory, nativeDirectory, roots, owner, nativeFile, encodedCwd, nativeSession, removeEmptyNativeGroup, createGrokOwnedWorkspace, bindGrokOwnedSession, validateGrokOwnedThread, releaseGrokOwnedWorkspace, cleanupGrokOwnedState;
 var init_grok_state = __esm({
@@ -40745,7 +40777,7 @@ var init_grok_state = __esm({
         await writeAtomicInferencePrivateFile(join10(workspace, markerName), JSON.stringify(value));
         return workspace;
       } catch (error48) {
-        await rm8(workspace, { recursive: true, force: true });
+        await rm9(workspace, { recursive: true, force: true });
         throw error48;
       }
     };
@@ -40778,11 +40810,11 @@ var init_grok_state = __esm({
       if (session) {
         await owner(options, workspace);
         if (await nativeSession(value, false) !== session) throw invalid();
-        await rm8(session, { recursive: true, force: true });
+        await rm9(session, { recursive: true, force: true });
         await removeEmptyNativeGroup(dirname8(session), workspace);
       }
       await owner(options, workspace);
-      await rm8(workspace, { recursive: true, force: true });
+      await rm9(workspace, { recursive: true, force: true });
     };
     cleanupGrokOwnedState = async (options) => {
       let scope;
@@ -40814,7 +40846,7 @@ var init_grok_state = __esm({
 });
 
 // lib/inference-host/grok-adapter.ts
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 import { join as join11 } from "node:path";
 var unwrap, list, nonempty, integer2, grokModelCapabilities, grokPromptUsage, agentProfile, modelState, assertSelection, GrokBuildAdapter;
 var init_grok_adapter = __esm({
@@ -41080,7 +41112,7 @@ var init_grok_adapter = __esm({
               activeThread = { ...activeThread, effectiveModel: observedModel };
               await agent.onThreadReady?.(activeThread);
             }
-            const callId = randomUUID7();
+            const callId = randomUUID8();
             const tool = name;
             const result3 = await agent.executeTool({ callId, tool, arguments: args });
             evidence.push({ callId, tool, arguments: args, success: result3.success });
@@ -41186,7 +41218,7 @@ var init_grok_adapter = __esm({
             if (update.sessionUpdate === "agent_message_chunk" && firstToken === null) firstToken = Date.now() - startedAt;
             if (update.sessionUpdate === "agent_thought_chunk" && Buffer.byteLength(thought) + Buffer.byteLength(text2) <= 3e5) thought += text2;
           };
-          const promptId = randomUUID7();
+          const promptId = randomUUID8();
           const result2 = await session.request("session/prompt", {
             sessionId,
             prompt: [{ type: "text", text: input.userPrompt }],
@@ -41365,9 +41397,9 @@ var init_grok_auth = __esm({
 
 // lib/inference-host/exo-adapter.ts
 import { spawn as spawn9 } from "node:child_process";
-import { randomUUID as randomUUID8, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+import { randomUUID as randomUUID9, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import { createServer as createServer5 } from "node:http";
-import { access as access3, lstat as lstat8, readdir as readdir4, realpath as realpath7, rm as rm9 } from "node:fs/promises";
+import { access as access3, lstat as lstat8, readdir as readdir4, realpath as realpath7, rm as rm10 } from "node:fs/promises";
 import { basename as basename4, dirname as dirname9, join as join12, resolve as resolve7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var import_ajv3, failure, object4, validModel, receiptUsage, assertOwnedRuntime, cleanupExoOwnedState, ExoForegroundAdapter;
@@ -41429,7 +41461,7 @@ var init_exo_adapter = __esm({
         if (!match || !entry.isDirectory() || entry.isSymbolicLink()) throw failure("exo_state_not_owned");
         await assertOwnedRuntime(join12(root, entry.name), match[1]);
       }
-      await rm9(root, { recursive: true, force: true });
+      await rm10(root, { recursive: true, force: true });
     };
     ExoForegroundAdapter = class {
       constructor(options) {
@@ -41549,7 +41581,7 @@ var init_exo_adapter = __esm({
         const credential = await this.options.credentialStore.read(input.signal);
         const provider = selected.model.split("/")[0];
         if (!credential || credential.provider !== provider) throw failure("exo_credential_required", false, "auth");
-        const id2 = agent?.durableThread?.threadId ?? randomUUID8();
+        const id2 = agent?.durableThread?.threadId ?? randomUUID9();
         const runtimeRoot = agent?.durableThread ? await this.ownedRoot(agent.durableThread) : join12(await realpath7(this.options.stateRoot), `${agent ? "agent" : "attempt"}-${id2}`);
         let thread = { threadId: id2, threadPath: runtimeRoot, effectiveModel: input.requestedModel, effectiveReasoningEffort: input.requestedReasoningEffort };
         const owner2 = agent?.durableThread ? await assertOwnedRuntime(runtimeRoot, id2) : null;
@@ -41563,7 +41595,7 @@ var init_exo_adapter = __esm({
         const relay = () => abort.abort();
         input.signal?.addEventListener("abort", relay, { once: true });
         const timer = setTimeout(relay, Math.max(0, input.deadlineAtMs - started));
-        const token = randomUUID8();
+        const token = randomUUID9();
         let dispatched = false;
         let terminal = null;
         let workerFailure = null;
@@ -41689,7 +41721,7 @@ var init_exo_adapter = __esm({
           }
           await agent?.onThreadReady?.(thread);
           try {
-            await this.command([...args, "conversation", "send", "vtx", "trading", randomUUID8()], env, abort.signal);
+            await this.command([...args, "conversation", "send", "vtx", "trading", randomUUID9()], env, abort.signal);
           } catch (error48) {
             if (!terminal) throw error48;
           }
@@ -41761,11 +41793,11 @@ var init_exo_adapter = __esm({
           this.active.delete(abort);
           server.closeAllConnections();
           await new Promise((done) => server.close(() => done()));
-          if (!agent) await rm9(runtimeRoot, { recursive: true, force: true });
+          if (!agent) await rm10(runtimeRoot, { recursive: true, force: true });
         }
       }
       async releaseThread(thread) {
-        await rm9(await this.ownedRoot(thread), { recursive: true, force: true });
+        await rm10(await this.ownedRoot(thread), { recursive: true, force: true });
       }
       async close() {
         this.closing = true;
@@ -42364,7 +42396,7 @@ var init_durable_adapter = __esm({
 });
 
 // lib/inference-host/service-launcher-state.ts
-import { access as access4, readFile as readFile9, rm as rm10 } from "node:fs/promises";
+import { access as access4, readFile as readFile9, rm as rm11 } from "node:fs/promises";
 import { dirname as dirname12, isAbsolute as isAbsolute5, join as join13, relative as relative3, resolve as resolve10 } from "node:path";
 var launcherSibling, within, launcherSelection, readLauncherSelection, readLauncherState, writeLauncherState, targetForSelection;
 var init_service_launcher_state = __esm({
@@ -42519,6 +42551,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 +42603,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 +42614,7 @@ var init_runtime_policy_generated2 = __esm({
           },
           read_budget: {
             weights: {
+              exchange: 1,
               exchangeStatus: 2,
               clearinghouseState: 2,
               spotClearinghouseState: 2,
@@ -42604,7 +42645,8 @@ var init_runtime_policy_generated2 = __esm({
               authorizedAgents: 20,
               agents: 20,
               apiWallets: 20
-            }
+            },
+            exchange_action_batch_size: 40
           }
         }
       }
@@ -42614,9 +42656,9 @@ var init_runtime_policy_generated2 = __esm({
 
 // lib/inference-host/service.ts
 import { spawn as spawn10 } from "node:child_process";
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { createWriteStream, readFileSync as readFileSync2 } from "node:fs";
-import { access as access5, chmod as chmod3, mkdir as mkdir3, readFile as readFile10, rm as rm11, writeFile as writeFile4 } from "node:fs/promises";
+import { access as access5, chmod as chmod3, mkdir as mkdir3, readFile as readFile10, rm as rm12, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname13, join as join14, resolve as resolve11 } from "node:path";
 var SERVICE_NAME, SYSTEMD_UNIT, LAUNCHD_LABEL, SERVICE_COOPERATIVE_STOP_SECONDS, SERVICE_UPDATE_STARTUP_SECONDS, INFERENCE_HOST_SERVICE_DRAIN_COMMAND, INFERENCE_HOST_SERVICE_QUIESCE_COMMAND, InferenceHostBootstrapRestartRequiredError, inferenceHostServiceChildEnvironment, isWindowsSubsystemForLinux, inferenceHostServiceManifestPath, inferenceHostServiceDesiredPath, inferenceHostServiceLogPath, inferenceHostServiceRuntimePath, xmlEscape, plistEscape, systemdQuote, defaultRunCommand, probeInferenceHostLauncher, managerName, assertRuntimeEnvironment, withoutConcurrencyLimit, assertServicePath, manifestGeneration, assertWorker, assertManifest, assertServiceRuntimeState, assertDesiredState, readInferenceHostServiceManifest, readManifestAcrossAtomicReplacement, readInferenceHostServiceRuntime, readRuntimeAcrossAtomicReplacement, readInferenceHostServiceDesired, readDesiredAcrossAtomicReplacement, writeDesired, runtimeEnvironment, serviceBootstrapArguments, windowsOwnedCommandLine, vbScriptString, windowsServiceLauncher, windowsTaskXml, systemdUnit, launchAgentPlist, sameWorker, sameServiceDefinition, sameWorkerSet, InferenceHostServiceManager, appendServiceLog, spawnInferenceHostServiceChild, runInferenceHostServiceSupervisor;
@@ -42693,7 +42735,7 @@ var init_service = __esm({
       }));
     });
     probeInferenceHostLauncher = async (executable, destination, bytes3, runCommand = defaultRunCommand) => {
-      const probe = `${destination}.${randomUUID9()}.probe.js`;
+      const probe = `${destination}.${randomUUID10()}.probe.js`;
       try {
         await writeAtomicInferencePrivateFile(probe, bytes3);
         const result2 = await runCommand(executable, [probe]);
@@ -42701,7 +42743,7 @@ var init_service = __esm({
           throw new Error("Copied service launcher failed its isolated startup check.");
         }
       } finally {
-        await rm11(probe, { force: true });
+        await rm12(probe, { force: true });
       }
     };
     managerName = (platform) => {
@@ -43197,7 +43239,7 @@ WantedBy=default.target
         const previousRuntimeUpdatedAt = previousRuntime?.manifest_generation === manifest.generation ? Date.parse(previousRuntime.updated_at) : Number.NaN;
         const restoredManifest = preserveGeneration ? manifest : assertManifest({
           ...manifest,
-          generation: randomUUID9(),
+          generation: randomUUID10(),
           installed_at: this.now().toISOString()
         });
         await writeAtomicInferencePrivateFile(
@@ -43354,16 +43396,16 @@ ${cleanup.stderr}`)) {
               );
             }
           }
-          await rm11(this.definitionPath(), { force: true }).catch(() => void 0);
+          await rm12(this.definitionPath(), { force: true }).catch(() => void 0);
           if (this.platform === "win32") {
-            await rm11(this.windowsLauncherPath(), { force: true }).catch(() => void 0);
+            await rm12(this.windowsLauncherPath(), { force: true }).catch(() => void 0);
           }
-          await rm11(this.manifestPath(), { force: true }).catch(() => void 0);
-          await rm11(this.desiredPath(), { force: true }).catch(() => void 0);
-          await rm11(this.runtimePath(), { force: true }).catch(() => void 0);
-          if (!existingRecovery) await rm11(this.serviceBootstrapPath(), { force: true }).catch(() => void 0);
+          await rm12(this.manifestPath(), { force: true }).catch(() => void 0);
+          await rm12(this.desiredPath(), { force: true }).catch(() => void 0);
+          await rm12(this.runtimePath(), { force: true }).catch(() => void 0);
+          if (!existingRecovery) await rm12(this.serviceBootstrapPath(), { force: true }).catch(() => void 0);
           for (const suffix of [".service-launcher.json", ".service-bootstrap.previous.js"]) {
-            if (!existingRecovery) await rm11(launcherSibling(this.manifestPath(), suffix), { force: true }).catch(() => void 0);
+            if (!existingRecovery) await rm12(launcherSibling(this.manifestPath(), suffix), { force: true }).catch(() => void 0);
           }
           if (this.platform === "linux") {
             await this.runCommand("systemctl", ["--user", "daemon-reload"]).catch(() => void 0);
@@ -43515,7 +43557,7 @@ ${cleanup.stderr}`)) {
         ].sort((left, right) => left.instance_name.localeCompare(right.instance_name));
         const manifest = assertManifest({
           schema_version: "vtx_inference_service_v3",
-          generation: randomUUID9(),
+          generation: randomUUID10(),
           installed_at: this.now().toISOString(),
           executable: this.executable,
           script: this.script,
@@ -43738,7 +43780,7 @@ ${result2.stderr}`)) {
           if (remaining.length === 0) return await this.uninstallUnlocked();
           return await this.replaceManifestUnlocked({
             ...manifest,
-            generation: randomUUID9(),
+            generation: randomUUID10(),
             installed_at: this.now().toISOString(),
             workers: remaining
           }, await readInferenceHostServiceDesired(this.desiredPath()));
@@ -43761,20 +43803,20 @@ ${result2.stderr}`)) {
 ${result2.stderr}`)) {
           throw new Error(`Background service uninstall failed: ${result2.stderr.trim()}`);
         }
-        await rm11(this.definitionPath(), { force: true });
-        if (this.platform === "win32") await rm11(this.windowsLauncherPath(), { force: true });
+        await rm12(this.definitionPath(), { force: true });
+        if (this.platform === "win32") await rm12(this.windowsLauncherPath(), { force: true });
         if (this.platform === "linux") await this.runCommand("systemctl", ["--user", "daemon-reload"]);
-        await rm11(this.manifestPath(), { force: true });
-        await rm11(this.desiredPath(), { force: true });
-        await rm11(this.runtimePath(), { force: true });
+        await rm12(this.manifestPath(), { force: true });
+        await rm12(this.desiredPath(), { force: true });
+        await rm12(this.runtimePath(), { force: true });
         if (!preserveRecovery) {
-          await rm11(this.serviceBootstrapPath(), { force: true });
+          await rm12(this.serviceBootstrapPath(), { force: true });
           for (const suffix of [".service-launcher.json", ".service-bootstrap.previous.js"]) {
-            await rm11(launcherSibling(this.manifestPath(), suffix), { force: true });
+            await rm12(launcherSibling(this.manifestPath(), suffix), { force: true });
           }
-          await rm11(this.serviceReleasePath(), { force: true });
-          await rm11(this.serviceReleaseRejectionPath(), { force: true });
-          await rm11(this.serviceReleasesPath(), { recursive: true, force: true });
+          await rm12(this.serviceReleasePath(), { force: true });
+          await rm12(this.serviceReleaseRejectionPath(), { force: true });
+          await rm12(this.serviceReleasesPath(), { recursive: true, force: true });
         }
         return {
           installed: false,
@@ -44237,9 +44279,9 @@ __export(cli_exports, {
   registerInferenceHostServiceControlInput: () => registerInferenceHostServiceControlInput,
   runInferenceHostCli: () => runInferenceHostCli
 });
-import { createHash as createHash12, randomUUID as randomUUID10 } from "node:crypto";
+import { createHash as createHash12, randomUUID as randomUUID11 } from "node:crypto";
 import { spawn as spawn11 } from "node:child_process";
-import { lstat as lstat9, realpath as realpath8, rm as rm12 } from "node:fs/promises";
+import { lstat as lstat9, realpath as realpath8, rm as rm13 } from "node:fs/promises";
 import { hostname as osHostname } from "node:os";
 import { join as join15, resolve as resolve12 } from "node:path";
 async function runInferenceHostCli(argv2, env = process.env, dependencies = {}) {
@@ -44878,7 +44920,7 @@ Durable service:
         runtimeReceiptPath(config2),
         "Inference host runtime receipt file"
       );
-      await rm12(codexGuardianReceiptRoot(config2), { recursive: true, force: true });
+      await rm13(codexGuardianReceiptRoot(config2), { recursive: true, force: true });
       await clearInferencePrivateFile(
         codexRecoveryPath(config2),
         "Codex attempt recovery file"
@@ -45146,7 +45188,7 @@ Waiting for approval...
         await writeInferenceHostCredentialContextTransition(config2, previousCredentialContext);
         await writeInferenceHostCredentialContext(config2);
         const keyPair = generateExternalInferenceEnvelopeKeyPair();
-        const hostId = randomUUID10();
+        const hostId = randomUUID11();
         const beginLogin = dependencies.beginLogin ?? beginInferenceOAuthLogin;
         const loginStore = {
           kind: store.kind,
@@ -46034,7 +46076,7 @@ Waiting for approval...
       }
       return record5;
     };
-    agentOperationId = (kind) => `${kind}-${randomUUID10()}`;
+    agentOperationId = (kind) => `${kind}-${randomUUID11()}`;
     agentSession = async (config2, dependencies, warnings, signal) => {
       if (await readRevocationCheckpoint(config2)) {
         throw new Error("Inference host revocation recovery must finish first.");
@@ -47113,7 +47155,7 @@ Waiting for approval...
         if (recoveryRaw === null && existingTransaction?.phase !== "reconciled") {
           throw new Error("Codex recovery evidence changed before service recovery began.");
         }
-        const transactionId = existingTransaction?.transaction_id ?? randomUUID10();
+        const transactionId = existingTransaction?.transaction_id ?? randomUUID11();
         const backupPath = existingTransaction?.recovery_backup_path ?? recoveryBackupPath(config2, transactionId);
         if (!existingTransaction) {
           await writeAtomicInferencePrivateFile(backupPath, recoveryRaw);
@@ -47261,7 +47303,7 @@ Waiting for approval...
               serviceRecoveryTransactionPath(config2),
               "Inference-host service recovery transaction"
             );
-            await rm12(backupPath, { force: true });
+            await rm13(backupPath, { force: true });
           }
         }
       } finally {
@@ -47536,7 +47578,7 @@ Waiting for approval...
 });
 
 // lib/agent-core/config.ts
-import { mkdir as mkdir5, readFile as readFile11, rm as rm13, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile11, rm as rm14, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname14, join as join16 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function defaultBaseDir() {
@@ -47580,7 +47622,7 @@ async function writeStoredAgentAuth(path, auth) {
 `, { encoding: "utf8", mode: 384 });
 }
 async function clearStoredAgentAuth(path) {
-  await rm13(path, { force: true });
+  await rm14(path, { force: true });
 }
 async function readRuntimeState(path) {
   try {
@@ -47615,7 +47657,7 @@ async function writeRuntimeState(path, state) {
 `, { encoding: "utf8", mode: 384 });
 }
 async function clearRuntimeState(path) {
-  await rm13(path, { force: true });
+  await rm14(path, { force: true });
 }
 var init_config2 = __esm({
   "lib/agent-core/config.ts"() {
@@ -47647,7 +47689,7 @@ var init_types = __esm({
 });
 
 // lib/agent-core/client.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 function normalizeApiUrl(value) {
   const parsed = String(value || "").trim();
   if (!parsed) {
@@ -47914,7 +47956,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/decision", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -47923,7 +47965,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/trade-sync", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -47932,7 +47974,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/error", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -47944,7 +47986,7 @@ var init_client = __esm({
         return this.request("/trading/market-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           body: payload
         });
       }
@@ -47952,7 +47994,7 @@ var init_client = __esm({
         return this.request("/trading/limit-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           body: payload
         });
       }
@@ -47960,7 +48002,7 @@ var init_client = __esm({
         return this.request("/trading/cancel-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           body: payload
         });
       }
@@ -47979,7 +48021,7 @@ var init_client = __esm({
         return this.request("/trading/ai/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           body: payload
         });
       }
@@ -47987,7 +48029,7 @@ var init_client = __esm({
         return this.request("/trading/ai/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           body: {}
         });
       }
@@ -47995,7 +48037,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           body: {}
         });
       }
@@ -48003,7 +48045,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           body: {}
         });
       }
@@ -48011,7 +48053,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/session/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           body: payload
         });
       }
@@ -48022,7 +48064,7 @@ var init_client = __esm({
           return this.request("/trading/ai/runtime/session/stop", {
             method: "POST",
             profileId,
-            idempotencyKey: randomUUID11(),
+            idempotencyKey: randomUUID12(),
             body: payload
           });
         }
@@ -48039,7 +48081,7 @@ var init_client = __esm({
         }).request("/trading/ai/runtime/session/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID11(),
+          idempotencyKey: randomUUID12(),
           body: payload
         });
       }
@@ -48056,7 +48098,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 import { dirname as dirname15 } from "node:path";
 var parseStoredValues, FileBackedProtectionStorage, clientRuntimeProtectionStatePath;
 var init_protection_storage = __esm({
@@ -48116,7 +48158,7 @@ var init_protection_storage = __esm({
         mkdirSync(dirname15(this.path), { recursive: true, mode: 448 });
         const serialized = `${JSON.stringify(values)}
 `;
-        const temporaryPath = `${this.path}.${process.pid}.${randomUUID12()}.tmp`;
+        const temporaryPath = `${this.path}.${process.pid}.${randomUUID13()}.tmp`;
         try {
           writeFileSync(temporaryPath, serialized, {
             encoding: "utf8",
@@ -48143,7 +48185,7 @@ var init_protection_storage = __esm({
 });
 
 // lib/agent-core/headless-runtime.ts
-import { randomUUID as randomUUID13 } from "node:crypto";
+import { randomUUID as randomUUID14 } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 function objectOrNull2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -48255,8 +48297,8 @@ async function runAndReportLocalWorkCycle(options, state, leaseToken, context) {
   return Boolean(result2.decision || tradeSync || result2.afterDecision);
 }
 async function startHeadlessRuntime(options) {
-  const runtimeSessionId = randomUUID13();
-  const deviceId = String(options.deviceId || "").trim() || randomUUID13();
+  const runtimeSessionId = randomUUID14();
+  const deviceId = String(options.deviceId || "").trim() || randomUUID14();
   const startResponse = await options.client.startRuntime(options.profileId, {
     session_id: runtimeSessionId,
     device_id: deviceId,
@@ -48546,7 +48588,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 +48660,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 +48722,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 +48803,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 +48835,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 +50856,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);
@@ -64531,9 +64661,9 @@ var init_fragments = __esm({
         }
         const result2 = [];
         while (this.#offset < top.match - 1) {
-          const link = this.peek().linkNext;
-          result2.push(this.#subTokenString(this.#offset + 1, link));
-          this.#offset = link;
+          const link2 = this.peek().linkNext;
+          result2.push(this.#subTokenString(this.#offset + 1, link2));
+          this.#offset = link2;
         }
         this.#offset = top.match + 1;
         return result2;
@@ -69257,15 +69387,15 @@ var init_contract2 = __esm({
 });
 
 // node_modules/ethers/lib.esm/providers/ens-resolver.js
-function getIpfsLink(link) {
-  if (link.match(/^ipfs:\/\/ipfs\//i)) {
-    link = link.substring(12);
-  } else if (link.match(/^ipfs:\/\//i)) {
-    link = link.substring(7);
+function getIpfsLink(link2) {
+  if (link2.match(/^ipfs:\/\/ipfs\//i)) {
+    link2 = link2.substring(12);
+  } else if (link2.match(/^ipfs:\/\//i)) {
+    link2 = link2.substring(7);
   } else {
-    assertArgument(false, "unsupported IPFS format", "link", link);
+    assertArgument(false, "unsupported IPFS format", "link", link2);
   }
-  return `https://gateway.ipfs.io/ipfs/${link}`;
+  return `https://gateway.ipfs.io/ipfs/${link2}`;
 }
 var MulticoinProviderPlugin, matcherIpfs, matchers, EnsResolver;
 var init_ens_resolver = __esm({
@@ -85510,9 +85640,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 +85677,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");
@@ -92921,7 +93054,7 @@ var headless_local_worker_exports = {};
 __export(headless_local_worker_exports, {
   createHeadlessLocalWorker: () => createHeadlessLocalWorker
 });
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 function objectOrNull3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -93350,7 +93483,7 @@ function createHeadlessLocalWorker(options) {
       const statusMatch = errorText.match(/\b([45]\d{2})\b/);
       const statusCode = statusMatch ? Number(statusMatch[1]) : null;
       const failedInvocation = normalizeAiInvocationTelemetry({
-        client_invocation_id: randomUUID14(),
+        client_invocation_id: randomUUID15(),
         use_case: "trader",
         role: "primary",
         attempt_index: 0,
@@ -93406,7 +93539,7 @@ function createHeadlessLocalWorker(options) {
       billable_cached_input_tokens: normalizedUsage.cached_input_tokens
     };
     const invocation = normalizeAiInvocationTelemetry({
-      client_invocation_id: randomUUID14(),
+      client_invocation_id: randomUUID15(),
       use_case: "trader",
       role: "primary",
       attempt_index: 0,
@@ -93670,7 +93803,7 @@ var vtx_exports = {};
 __export(vtx_exports, {
   runVtxCli: () => runVtxCli
 });
-import { randomUUID as randomUUID15 } from "node:crypto";
+import { randomUUID as randomUUID16 } from "node:crypto";
 import { spawn as spawn12 } from "node:child_process";
 function render2(value, json2) {
   if (json2) {
@@ -94084,8 +94217,8 @@ async function runVtxCli(argv2, env = process.env) {
         });
         return { exitCode: 0, stdout: render2(redactCliOutput(response2), json2), stderr: "" };
       }
-      const runtimeSessionId = randomUUID15();
-      const deviceId = config2.runtimeDeviceId ?? randomUUID15();
+      const runtimeSessionId = randomUUID16();
+      const deviceId = config2.runtimeDeviceId ?? randomUUID16();
       const response = await client.startRuntime(profileId, {
         session_id: runtimeSessionId,
         device_id: deviceId,