@vtxmacro/cli 2026.8.51 → 2026.8.52

package/bin/vtx.js

@@ -5,11 +5,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod2) => function __require() {
-  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+  try {
+    return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+  } catch (e) {
+    throw mod2 = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -38,7 +47,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.8.51",
+      package_version: "2026.8.52",
       codex_package_name: "@openai/codex",
       codex_version: "0.147.0",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -16535,6 +16544,25 @@ async function syncInferenceDirectory(path, platform = process.platform) {
     await handle.close();
   }
 }
+async function replaceAtomicInferencePrivateFile(temporaryPath, destinationPath, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const renameFile = options.renameFile ?? rename;
+  const sleep4 = options.sleep ?? ((milliseconds) => new Promise((resolve6) => setTimeout(resolve6, milliseconds)));
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 40);
+  const retryDelayMs = Math.max(0, options.retryDelayMs ?? 25);
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      await renameFile(temporaryPath, destinationPath);
+      return;
+    } catch (error48) {
+      const code = String(error48.code ?? "");
+      if (platform !== "win32" || !WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES.has(code) || attempt === maxAttempts - 1) {
+        throw error48;
+      }
+      await sleep4(retryDelayMs);
+    }
+  }
+}
 async function writeAtomicInferencePrivateFile(path, contents, dependencies = {}) {
   const platform = dependencies.platform ?? process.platform;
   const runner = dependencies.runner ?? runWindowsPrivateAcl;
@@ -16571,7 +16599,13 @@ async function writeAtomicInferencePrivateFile(path, contents, dependencies = {}
   }
   try {
     invalidateWindowsAclCache(path);
-    await rename(temporary, path);
+    await replaceAtomicInferencePrivateFile(temporary, path, {
+      platform,
+      renameFile: dependencies.renameFile,
+      sleep: dependencies.sleep,
+      maxAttempts: dependencies.replaceMaxAttempts,
+      retryDelayMs: dependencies.replaceRetryDelayMs
+    });
     if (platform === "win32" && hardenedIdentity) {
       await rebindHardenedWindowsAclAfterRename(
         temporary,
@@ -16838,7 +16872,7 @@ async function acquireInferenceHostProcessLock(path, dependencies = {}) {
     }
   };
 }
-var INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS, WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS, SMALL_IDENTITY_COMMAND_TIMEOUT_MS, windowsPowerShellEnvironment, windowsPrivateAclBrokerInvocation, WindowsPrivateAclBroker, defaultWindowsPrivateAclBroker, runWindowsPrivateAcl, windowsAclCache, windowsAclIdentity, aclCacheKey, secureWindowsPrivatePath, invalidateWindowsAclCache, rebindHardenedWindowsAclAfterRename, rebindHardenedWindowsDirectoryAfterOwnedMutation, isDefaultWindowsPrivatePath, secureExistingWindowsPath, linuxProcessIdentity, windowsProcessIdentityInvocation, windowsBootIdentityInvocation, windowsProcessIdentity, darwinProcessIdentity, runSmallIdentityCommand, cachedSystemBootIdentity, readInferenceSystemBootIdentity, defaultProcessIdentity, defaultCurrentProcessIdentity, processLockObservationCache, inferenceProcessIdentitiesMatch, DEFAULT_INFERENCE_HOST_INSTANCE, SAFE_INFERENCE_HOST_INSTANCE, requireNamedInstancePath, credentialStoreIdentity, inferenceHostCredentialContextPath, inferenceHostCredentialContextTransitionPath, credentialContextForConfig;
+var INFERENCE_CREDENTIAL_NAMESPACE, MAX_INFERENCE_PRIVATE_FILE_BYTES, WINDOWS_PRIVATE_ACL_BROKER_SCRIPT, WINDOWS_IDENTITY_COMMAND_TIMEOUT_MS, WINDOWS_PRIVATE_ACL_BROKER_STARTUP_TIMEOUT_MS, SMALL_IDENTITY_COMMAND_TIMEOUT_MS, windowsPowerShellEnvironment, windowsPrivateAclBrokerInvocation, WindowsPrivateAclBroker, defaultWindowsPrivateAclBroker, runWindowsPrivateAcl, windowsAclCache, windowsAclIdentity, aclCacheKey, secureWindowsPrivatePath, invalidateWindowsAclCache, rebindHardenedWindowsAclAfterRename, rebindHardenedWindowsDirectoryAfterOwnedMutation, isDefaultWindowsPrivatePath, secureExistingWindowsPath, linuxProcessIdentity, windowsProcessIdentityInvocation, windowsBootIdentityInvocation, windowsProcessIdentity, darwinProcessIdentity, runSmallIdentityCommand, cachedSystemBootIdentity, readInferenceSystemBootIdentity, defaultProcessIdentity, defaultCurrentProcessIdentity, processLockObservationCache, inferenceProcessIdentitiesMatch, DEFAULT_INFERENCE_HOST_INSTANCE, SAFE_INFERENCE_HOST_INSTANCE, requireNamedInstancePath, credentialStoreIdentity, inferenceHostCredentialContextPath, inferenceHostCredentialContextTransitionPath, credentialContextForConfig, WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES;
 var init_config = __esm({
   "lib/inference-host/config.ts"() {
     "use strict";
@@ -17413,6 +17447,13 @@ while(($line=[Console]::In.ReadLine()) -ne $null) {
       credential_store_mode: config2.credentialStoreMode,
       credential_file_path: config2.credentialStoreMode === "file" ? resolve(config2.credentialFilePath) : null
     });
+    WINDOWS_PRIVATE_FILE_REPLACE_ERROR_CODES = /* @__PURE__ */ new Set([
+      "EACCES",
+      "EBUSY",
+      "EEXIST",
+      "ENOTEMPTY",
+      "EPERM"
+    ]);
   }
 });
 
@@ -38220,7 +38261,18 @@ var init_sort_utils = __esm({
 });
 
 // lib/runtime/hyperliquid-account-mode-contract.ts
-var UNIFIED_MODE_ALIASES, normalizeAccountMode, extractAccountModeFromPayload, extractAccountModeCandidateFromPayload, isUnifiedAccountMode;
+function resolveExactHyperliquidAccountMode(userAbstraction, ...dexEvidence) {
+  const mode = extractCanonicalHyperliquidAccountMode(userAbstraction);
+  if (!mode) {
+    throw new Error("Exact Hyperliquid userAbstraction response is invalid.");
+  }
+  if (mode !== "default" && mode !== "disabled") return mode;
+  if (dexEvidence.length < 1) {
+    throw new Error("Exact Hyperliquid userDexAbstraction response is unavailable.");
+  }
+  return parseExactDexAbstractionEnabled(dexEvidence[0]) ? "dexAbstraction" : mode;
+}
+var UNIFIED_MODE_ALIASES, CANONICAL_ACCOUNT_MODE_ALIASES, EXACT_MODE_KEYS, EXACT_MODE_BOOLEAN_KEYS, isExactTruthyFlag, normalizeCanonicalHyperliquidAccountMode, extractCanonicalHyperliquidAccountMode, parseExactDexAbstractionEnabled, normalizeAccountMode, extractAccountModeFromPayload, extractAccountModeCandidateFromPayload, isUnifiedAccountMode;
 var init_hyperliquid_account_mode_contract = __esm({
   "lib/runtime/hyperliquid-account-mode-contract.ts"() {
     "use strict";
@@ -38231,6 +38283,89 @@ var init_hyperliquid_account_mode_contract = __esm({
       "unified",
       "pm"
     ]);
+    CANONICAL_ACCOUNT_MODE_ALIASES = /* @__PURE__ */ new Map([
+      ["default", "default"],
+      ["standard", "default"],
+      ["classic", "default"],
+      ["disabled", "disabled"],
+      ["unifiedaccount", "unifiedAccount"],
+      ["unified", "unifiedAccount"],
+      ["portfoliomargin", "portfolioMargin"],
+      ["pm", "portfolioMargin"],
+      ["dexabstraction", "dexAbstraction"]
+    ]);
+    EXACT_MODE_KEYS = [
+      "accountMode",
+      "account_mode",
+      "accountType",
+      "account_type",
+      "accountUnificationMode",
+      "account_unification_mode",
+      "abstractionMode",
+      "abstraction_mode",
+      "abstraction",
+      "abstractionState",
+      "dexAbstractionState",
+      "marginMode",
+      "state",
+      "mode",
+      "value"
+    ];
+    EXACT_MODE_BOOLEAN_KEYS = [
+      ["unifiedAccount", ["isUnifiedAccount", "unifiedAccount", "isUnified", "unified", "is_unified_account"]],
+      ["portfolioMargin", ["isPortfolioMargin", "portfolioMargin", "isPm", "pm", "is_portfolio_margin"]],
+      ["dexAbstraction", ["isDexAbstraction", "dexAbstraction", "dexAbstractionEnabled", "is_dex_abstraction"]],
+      ["default", ["isClassic", "classic", "isStandard", "standard"]]
+    ];
+    isExactTruthyFlag = (value) => value === true || value === 1 || typeof value === "string" && value.trim().toLowerCase() === "true";
+    normalizeCanonicalHyperliquidAccountMode = (value) => {
+      if (typeof value !== "string") return null;
+      const key = value.trim().replace(/[_\s-]/g, "").toLowerCase();
+      return CANONICAL_ACCOUNT_MODE_ALIASES.get(key) ?? null;
+    };
+    extractCanonicalHyperliquidAccountMode = (payload, depth = 0) => {
+      if (depth > 6) return null;
+      const direct = normalizeCanonicalHyperliquidAccountMode(payload);
+      if (direct) return direct;
+      if (Array.isArray(payload)) {
+        for (const item of payload) {
+          const mode = extractCanonicalHyperliquidAccountMode(item, depth + 1);
+          if (mode) return mode;
+        }
+        return null;
+      }
+      if (!payload || typeof payload !== "object") return null;
+      const source = payload;
+      for (const key of EXACT_MODE_KEYS) {
+        if (!(key in source)) continue;
+        const mode = normalizeCanonicalHyperliquidAccountMode(source[key]);
+        if (mode) return mode;
+      }
+      for (const [mode, keys] of EXACT_MODE_BOOLEAN_KEYS) {
+        for (const key of keys) {
+          if (isExactTruthyFlag(source[key])) return mode;
+        }
+      }
+      for (const value of Object.values(source)) {
+        const mode = extractCanonicalHyperliquidAccountMode(value, depth + 1);
+        if (mode) return mode;
+      }
+      return null;
+    };
+    parseExactDexAbstractionEnabled = (payload) => {
+      if (payload == null || payload === false) return false;
+      if (payload === true) return true;
+      if (typeof payload === "string") {
+        const normalized = payload.trim().toLowerCase();
+        if (normalized === "true") return true;
+        if (normalized === "false") return false;
+      }
+      if (typeof payload === "number" && Number.isFinite(payload)) {
+        if (payload === 1) return true;
+        if (payload === 0) return false;
+      }
+      throw new Error("Exact Hyperliquid userDexAbstraction response is invalid.");
+    };
     normalizeAccountMode = (mode) => String(mode ?? "").trim().toLowerCase().replace(/[_\s-]/g, "");
     extractAccountModeFromPayload = (payload) => {
       const candidate = extractAccountModeCandidateFromPayload(payload);
@@ -38455,6 +38590,229 @@ var init_hyperliquid_active_asset_contract = __esm({
   }
 });
 
+// lib/runtime/server-prompt-rescue-account-contract.ts
+var STABLE_SYMBOLS, toNumber2, firstNumber2, firstTruthy, spotContainers, extractCanonicalSpotMetrics, sumBalanceValueUsd, approximatelyEqual, balancesMirrorUnifiedAccountValue, computeEffectiveAccountValue, equityFormula, buildServerPromptRescueAccountSummary;
+var init_server_prompt_rescue_account_contract = __esm({
+  "lib/runtime/server-prompt-rescue-account-contract.ts"() {
+    "use strict";
+    init_hyperliquid_account_mode_contract();
+    STABLE_SYMBOLS = /* @__PURE__ */ new Set(["USDC", "USD", "USDT"]);
+    toNumber2 = (value, fallback = 0) => {
+      const numeric = Number(value);
+      return Number.isFinite(numeric) ? numeric : fallback;
+    };
+    firstNumber2 = (values, fallback = 0) => {
+      for (const value of values) {
+        if (value == null || value === "") continue;
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) return numeric;
+      }
+      return fallback;
+    };
+    firstTruthy = (values, fallback) => {
+      for (const value of values) {
+        if (value) return value;
+      }
+      return fallback;
+    };
+    spotContainers = (spotResponse) => {
+      if (!spotResponse || typeof spotResponse !== "object" || Array.isArray(spotResponse)) return [];
+      const response = spotResponse;
+      const containers = [response];
+      for (const key of ["spotState", "userState", "clearinghouseState", "state", "data"]) {
+        const child = response[key];
+        if (child && typeof child === "object" && !Array.isArray(child)) containers.push(child);
+      }
+      return containers;
+    };
+    extractCanonicalSpotMetrics = (spotResponse) => {
+      const response = spotResponse && typeof spotResponse === "object" && !Array.isArray(spotResponse) ? spotResponse : {};
+      const containers = spotContainers(response);
+      let accountValue = 0;
+      let totalMarginUsed = 0;
+      let withdrawable = 0;
+      for (const container of containers) {
+        const marginSummary = container.marginSummary && typeof container.marginSummary === "object" && !Array.isArray(container.marginSummary) ? container.marginSummary : {};
+        accountValue = Math.max(accountValue, toNumber2(marginSummary.accountValue));
+        totalMarginUsed = Math.max(totalMarginUsed, toNumber2(marginSummary.totalMarginUsed));
+        withdrawable = Math.max(withdrawable, toNumber2(container.withdrawable));
+      }
+      if (accountValue <= 0) {
+        for (const key of ["accountValue", "totalValue", "equity", "totalRawUsd", "usdValue", "usdcValue"]) {
+          accountValue = Math.max(accountValue, toNumber2(response[key]));
+        }
+      }
+      const balances = [];
+      const listKeys = ["balances", "tokenBalances", "spotBalances", "assets"];
+      for (const container of containers) {
+        for (const listKey of listKeys) {
+          const bucket = container[listKey];
+          if (!Array.isArray(bucket)) continue;
+          let stableTotal = 0;
+          let anyTotal = 0;
+          for (const rawEntry of bucket) {
+            if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) continue;
+            const entry = rawEntry;
+            const coin = String(firstTruthy([
+              entry.coin,
+              entry.token,
+              entry.asset,
+              entry.symbol
+            ], "")).trim().toUpperCase();
+            if (!coin) continue;
+            const total = toNumber2(firstTruthy([entry.total, entry.balance, entry.amount], "0"));
+            const hold = toNumber2(firstTruthy([entry.hold, entry.locked], "0"));
+            const available = Math.max(
+              0,
+              toNumber2(firstTruthy([entry.available, entry.free, total - hold], "0"))
+            );
+            let valueUsd = toNumber2(firstTruthy([entry.usdValue, entry.usdcValue], "0"));
+            if (valueUsd <= 0 && STABLE_SYMBOLS.has(coin)) {
+              valueUsd = available > 0 ? available : total;
+            }
+            balances.push({ coin, total, hold, available, value_usd: valueUsd });
+            const entryValue = valueUsd > 0 ? valueUsd : total;
+            if (entryValue > 0) {
+              anyTotal += entryValue;
+              if (STABLE_SYMBOLS.has(coin)) stableTotal += entryValue;
+            }
+          }
+          if (accountValue <= 0) {
+            if (stableTotal > 0) accountValue = stableTotal;
+            else if (anyTotal > 0) accountValue = anyTotal;
+          }
+        }
+        if (balances.length > 0) break;
+      }
+      return { accountValue, totalMarginUsed, withdrawable, balances };
+    };
+    sumBalanceValueUsd = (balances) => balances.reduce((total, balance) => {
+      let valueUsd = toNumber2(balance.value_usd);
+      if (valueUsd <= 0 && STABLE_SYMBOLS.has(String(balance.coin || "").trim().toUpperCase())) {
+        valueUsd = toNumber2(balance.total);
+      }
+      return total + Math.max(valueUsd, 0);
+    }, 0);
+    approximatelyEqual = (left, right, absoluteToleranceUsd, relativeTolerance) => {
+      const reference = Math.max(Math.abs(left), Math.abs(right), 1);
+      return Math.abs(left - right) <= Math.max(absoluteToleranceUsd, reference * relativeTolerance);
+    };
+    balancesMirrorUnifiedAccountValue = (input) => input.perpsEquity > 0 && input.spotEquity > 0 && input.balancesEquity > 0 && approximatelyEqual(
+      input.perpsEquity,
+      input.spotEquity,
+      input.absoluteToleranceUsd,
+      input.relativeTolerance
+    ) && approximatelyEqual(
+      input.spotEquity,
+      input.balancesEquity,
+      input.absoluteToleranceUsd,
+      input.relativeTolerance
+    );
+    computeEffectiveAccountValue = (input) => {
+      if (!input.unifiedLike) return input.perpsEquity;
+      if (input.balancesEquity > 0) {
+        if (input.mirrored) {
+          return Math.max(input.perpsEquity, input.spotEquity, input.balancesEquity);
+        }
+        return Math.max(
+          input.perpsEquity + input.balancesEquity,
+          input.spotEquity,
+          input.balancesEquity
+        );
+      }
+      return Math.max(input.perpsEquity, input.spotEquity);
+    };
+    equityFormula = (input) => {
+      if (!input.unifiedLike) return "perps_account_value";
+      if (input.balancesEquity > 0) {
+        if (input.mirrored) return "unified_mirrored_balances_equity";
+        if (input.perpsEquity + input.balancesEquity >= Math.max(input.spotEquity, input.balancesEquity)) return "unified_perps_plus_balances";
+        if (input.spotEquity >= input.balancesEquity) return "unified_spot_account_value";
+        return "unified_balances_equity";
+      }
+      return input.perpsEquity >= input.spotEquity ? "unified_perps_account_value" : "unified_spot_account_value";
+    };
+    buildServerPromptRescueAccountSummary = (perpsResponse, spotResponse, accountMode, options = {}) => {
+      const perps = perpsResponse && typeof perpsResponse === "object" && !Array.isArray(perpsResponse) ? perpsResponse : {};
+      const marginSummary = perps.marginSummary && typeof perps.marginSummary === "object" && !Array.isArray(perps.marginSummary) ? perps.marginSummary : {};
+      const crossMarginSummary = perps.crossMarginSummary && typeof perps.crossMarginSummary === "object" && !Array.isArray(perps.crossMarginSummary) ? perps.crossMarginSummary : {};
+      const rawPerpsAccountValue = toNumber2(marginSummary.accountValue);
+      const perpsAccountValue = Math.max(0, rawPerpsAccountValue);
+      const crossMarginAccountValue = toNumber2(crossMarginSummary.accountValue);
+      let totalMarginUsed = toNumber2(marginSummary.totalMarginUsed);
+      let withdrawable = toNumber2(perps.withdrawable);
+      const spot = accountMode === "disabled" ? { accountValue: 0, totalMarginUsed: 0, withdrawable: 0, balances: [] } : extractCanonicalSpotMetrics(spotResponse);
+      const balances = spot.balances;
+      const balancesEquity = sumBalanceValueUsd(balances);
+      const unifiedLike = isUnifiedAccountMode(accountMode);
+      if (unifiedLike) {
+        totalMarginUsed = Math.max(totalMarginUsed, spot.totalMarginUsed);
+        withdrawable = Math.max(withdrawable, spot.withdrawable);
+      }
+      const absoluteToleranceUsd = firstNumber2([
+        options.mirroredAccountValueAbsoluteToleranceUsd,
+        options.mirrored_account_value_absolute_tolerance_usd
+      ]);
+      const relativeTolerance = firstNumber2([
+        options.mirroredAccountValueRelativeTolerance,
+        options.mirrored_account_value_relative_tolerance
+      ]);
+      const mirrored = balancesMirrorUnifiedAccountValue({
+        perpsEquity: perpsAccountValue,
+        spotEquity: Math.max(spot.accountValue, 0),
+        balancesEquity,
+        absoluteToleranceUsd,
+        relativeTolerance
+      });
+      const formulaInput = {
+        perpsEquity: perpsAccountValue,
+        spotEquity: Math.max(spot.accountValue, 0),
+        balancesEquity,
+        unifiedLike,
+        mirrored
+      };
+      const accountValue = computeEffectiveAccountValue(formulaInput);
+      const maintenanceMargin = toNumber2(perps.crossMaintenanceMarginUsed);
+      const calculatedAvailable = accountValue - totalMarginUsed;
+      const availableMargin = maintenanceMargin > 0 ? Math.max(
+        calculatedAvailable,
+        Math.max(0, accountValue - 4 * maintenanceMargin),
+        withdrawable
+      ) : Math.max(calculatedAvailable, withdrawable);
+      let totalNotional = 0;
+      let totalUnrealizedPnl = 0;
+      const positions = Array.isArray(perps.assetPositions) ? perps.assetPositions : [];
+      for (const entry of positions) {
+        const position = entry && typeof entry === "object" && !Array.isArray(entry) ? entry.position : null;
+        if (!position || typeof position !== "object" || Array.isArray(position)) continue;
+        const size = toNumber2(position.szi);
+        const unrealizedPnl = toNumber2(position.unrealizedPnl);
+        totalUnrealizedPnl += unrealizedPnl;
+        totalNotional += Math.abs(size * toNumber2(position.entryPx) + unrealizedPnl);
+      }
+      return {
+        account_value: accountValue,
+        total_margin_used: totalMarginUsed,
+        available_margin: availableMargin,
+        withdrawable,
+        cross_margin_ratio: accountValue > 0 ? maintenanceMargin / accountValue : 0,
+        maintenance_margin: maintenanceMargin,
+        cross_account_leverage: accountValue > 0 ? totalNotional / accountValue : 0,
+        total_unrealized_pnl: totalUnrealizedPnl,
+        account_mode: accountMode,
+        mode_source: "canonical",
+        balances,
+        raw_account_value: rawPerpsAccountValue,
+        cross_margin_account_value: crossMarginAccountValue,
+        spot_account_value: spot.accountValue,
+        balances_equity: balancesEquity,
+        equity_formula: equityFormula(formulaInput),
+        balance_trust_classification: "trusted_canonical"
+      };
+    };
+  }
+});
+
 // lib/runtime/abort.ts
 var ABORT_MESSAGE_TOKENS, readAbortLikeMessage, isAbortLikeError;
 var init_abort = __esm({
@@ -39021,6 +39379,8 @@ var init_hyperliquid_account_state_adapter = __esm({
     init_sort_utils();
     init_hyperliquid_account_contract();
     init_hyperliquid_active_asset_contract();
+    init_hyperliquid_account_mode_contract();
+    init_server_prompt_rescue_account_contract();
     init_hyperliquid_market_symbol();
     init_network_debug();
     unsupportedUserActiveAssetCache = /* @__PURE__ */ new Set();
@@ -39136,13 +39496,15 @@ var init_hyperliquid_account_state_adapter = __esm({
     buildUserFillsStorageKey = (cacheKey) => {
       return `${USER_FILLS_CACHE_STORAGE_PREFIX}${cacheKey}`;
     };
-    buildAccountStateCacheKey = (apiUrl, walletAddress, symbol2, aggregatePerpDexs, dexNames, includeEffectiveTakerRate) => {
+    buildAccountStateCacheKey = (apiUrl, walletAddress, symbol2, aggregatePerpDexs, dexNames, includeEffectiveTakerRate, includeExactAccountMode, includeActiveAssetData) => {
       return [
         apiUrl.replace(/\/$/, "").toLowerCase(),
         walletAddress.trim().toLowerCase(),
         normalizeHyperliquidMarketSymbol(symbol2),
         aggregatePerpDexs ? "aggregate" : "selected",
         includeEffectiveTakerRate ? "with-effective-taker-rate" : "without-effective-taker-rate",
+        includeExactAccountMode ? "with-exact-account-mode" : "without-exact-account-mode",
+        includeActiveAssetData ? "with-active-asset" : "without-active-asset",
         ...dexNames.map(normalizePerpDexName).sort()
       ].join("::");
     };
@@ -39352,7 +39714,8 @@ var init_hyperliquid_account_state_adapter = __esm({
       accountSummary: { ...result2.accountSummary },
       availableToTrade: { ...result2.availableToTrade },
       positions: result2.positions.map((position) => ({ ...position })),
-      ...result2.takerRate == null ? {} : { takerRate: result2.takerRate }
+      ...result2.takerRate == null ? {} : { takerRate: result2.takerRate },
+      ...result2.promptRescueEvidence == null ? {} : { promptRescueEvidence: { ...result2.promptRescueEvidence } }
     });
     readBrowserAccountStateCache = (cacheKey) => {
       const memoryEntry = browserAccountStateCache.get(cacheKey);
@@ -39382,7 +39745,8 @@ var init_hyperliquid_account_state_adapter = __esm({
             accountSummary: { ...result2.accountSummary || {} },
             availableToTrade: { ...result2.availableToTrade || {} },
             positions: Array.isArray(result2.positions) ? result2.positions.filter((position) => position !== null && typeof position === "object" && !Array.isArray(position)).map((position) => ({ ...position })) : [],
-            ...result2.takerRate == null ? {} : { takerRate: Number(result2.takerRate) }
+            ...result2.takerRate == null ? {} : { takerRate: Number(result2.takerRate) },
+            ...result2.promptRescueEvidence == null ? {} : { promptRescueEvidence: { ...result2.promptRescueEvidence } }
           }
         };
         if (entry.result.takerRate != null && (!Number.isFinite(entry.result.takerRate) || entry.result.takerRate < 0 || entry.result.takerRate >= 1)) {
@@ -39810,6 +40174,8 @@ var init_hyperliquid_account_state_adapter = __esm({
       const activeAssetRequestTypes = getBrowserActiveAssetTypeCandidates(apiUrl, walletAddress, symbol2);
       const aggregatePerpDexs = input.aggregatePerpDexs !== false;
       const includeEffectiveTakerRate = input.includeEffectiveTakerRate === true;
+      const includeExactAccountMode = input.includeExactAccountMode === true;
+      const includeActiveAssetData = input.includeActiveAssetData !== false;
       const dexNames = listPerpDexsForAccountState(input.config, dex, aggregatePerpDexs);
       const cacheKey = buildAccountStateCacheKey(
         apiUrl,
@@ -39817,7 +40183,9 @@ var init_hyperliquid_account_state_adapter = __esm({
         symbol2,
         aggregatePerpDexs,
         dexNames,
-        includeEffectiveTakerRate
+        includeEffectiveTakerRate,
+        includeExactAccountMode,
+        includeActiveAssetData
       );
       const now = Date.now();
       const cached2 = readBrowserAccountStateCache(cacheKey);
@@ -39828,7 +40196,8 @@ var init_hyperliquid_account_state_adapter = __esm({
         "clearinghouseState",
         "spotClearinghouseState",
         ...includeEffectiveTakerRate ? ["userFees"] : [],
-        ...activeAssetRequestTypes
+        ...includeExactAccountMode ? ["userAbstraction", "userDexAbstraction"] : [],
+        ...includeActiveAssetData ? activeAssetRequestTypes : []
       ], now)) {
         return cloneBrowserAccountStateResult(cached2.result);
       }
@@ -39906,20 +40275,29 @@ var init_hyperliquid_account_state_adapter = __esm({
             return prefixHip3PositionCoins(response, dexName);
           })
         );
-        return aggregateClearinghouseResponses([defaultResponse, ...dexResponses]);
+        return {
+          payload: aggregateClearinghouseResponses([defaultResponse, ...dexResponses]),
+          capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
       })();
-      const spotPromise = fetchHyperliquidInfoPayload(
-        apiUrl,
-        { type: "spotClearinghouseState", user: walletAddress },
-        input.signal
-      ).catch((error48) => {
-        recordInfoRateLimitCooldownFromError(apiUrl, error48, staleIf429MaxAgeMs);
-        if (input.forceRefresh || input.includeEffectiveTakerRate === true) {
-          throw error48;
+      const spotPromise = (async () => {
+        let payload;
+        try {
+          payload = await fetchHyperliquidInfoPayload(
+            apiUrl,
+            { type: "spotClearinghouseState", user: walletAddress },
+            input.signal
+          );
+        } catch (error48) {
+          recordInfoRateLimitCooldownFromError(apiUrl, error48, staleIf429MaxAgeMs);
+          if (input.forceRefresh || input.includeEffectiveTakerRate === true) {
+            throw error48;
+          }
+          payload = {};
         }
-        return {};
-      });
-      const activeAssetPromise = (async () => {
+        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 {
@@ -39939,17 +40317,50 @@ var init_hyperliquid_account_state_adapter = __esm({
         }
         throw lastError instanceof Error ? lastError : new Error("Failed to fetch browser active asset data.");
       })();
-      const userFeesPromise = input.includeEffectiveTakerRate === true ? fetchHyperliquidInfoPayload(
-        apiUrl,
-        { type: "userFees", user: walletAddress },
-        input.signal
-      ) : Promise.resolve(null);
-      const [perpsResponse, spotResponse, activeAssetResult, userFeesResponse] = await Promise.all([
+      const userFeesPromise = input.includeEffectiveTakerRate === true ? (async () => ({
+        payload: await fetchHyperliquidInfoPayload(
+          apiUrl,
+          { type: "userFees", user: walletAddress },
+          input.signal
+        ),
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }))() : Promise.resolve(null);
+      const exactAccountModePromise = input.includeExactAccountMode === true ? (async () => {
+        const userAbstraction = await fetchHyperliquidInfoPayload(
+          apiUrl,
+          { type: "userAbstraction", user: walletAddress },
+          input.signal
+        );
+        const preliminaryMode = extractCanonicalHyperliquidAccountMode(userAbstraction);
+        if (!preliminaryMode) {
+          throw new Error("Exact Hyperliquid userAbstraction response is invalid.");
+        }
+        let userDexAbstraction;
+        if (preliminaryMode === "default" || preliminaryMode === "disabled") {
+          userDexAbstraction = await fetchHyperliquidInfoPayload(
+            apiUrl,
+            { type: "userDexAbstraction", user: walletAddress },
+            input.signal
+          );
+        }
+        return {
+          accountMode: resolveExactHyperliquidAccountMode(
+            userAbstraction,
+            userDexAbstraction
+          ),
+          capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      })() : Promise.resolve(null);
+      const [perpsResult, spotResult, activeAssetResult, userFeesResult, exactAccountMode] = await Promise.all([
         perpsPromise,
         spotPromise,
         activeAssetPromise,
-        userFeesPromise
+        userFeesPromise,
+        exactAccountModePromise
       ]);
+      const perpsResponse = perpsResult.payload;
+      const spotResponse = spotResult.payload;
+      const userFeesResponse = userFeesResult?.payload ?? null;
       if (input.includeEffectiveTakerRate === true) {
         requirePromptSpotState(spotResponse);
       }
@@ -39969,20 +40380,32 @@ var init_hyperliquid_account_state_adapter = __esm({
         takerRate = parsedUserCrossRate;
       }
       const accountStateConfig = input.config.client_runtime_hyperliquid_account_state;
-      const normalizedSummary = buildAccountSummaryFromInfoResponses(perpsResponse, spotResponse, {
+      const summaryPerpsResponse = exactAccountMode ? { ...perpsResponse, accountMode: exactAccountMode.accountMode } : perpsResponse;
+      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 normalizedSummary = exactAccountMode ? buildServerPromptRescueAccountSummary(
+        perpsResponse,
+        spotResponse,
+        exactAccountMode.accountMode,
+        accountSummaryOptions
+      ) : buildAccountSummaryFromInfoResponses(
+        summaryPerpsResponse,
+        spotResponse,
+        accountSummaryOptions
+      );
       const accountSummary = {
         ...normalizedSummary,
+        ...exactAccountMode == null ? {} : { account_mode: exactAccountMode.accountMode, mode_source: "canonical" },
         address: walletAddress,
         dex: "all",
         market_type: "perp"
       };
-      const activeAssetPayload = activeAssetResult.payload;
-      const activeAssetType = activeAssetResult.type;
+      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);
@@ -40000,7 +40423,17 @@ var init_hyperliquid_account_state_adapter = __esm({
         accountSummary,
         availableToTrade,
         positions: parseInfoPositions(perpsResponse),
-        ...takerRate == null ? {} : { takerRate }
+        ...takerRate == null ? {} : { takerRate },
+        ...exactAccountMode == null || userFeesResult == null ? {} : {
+          promptRescueEvidence: {
+            capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            perpsCapturedAt: perpsResult.capturedAt,
+            spotCapturedAt: spotResult.capturedAt,
+            feesCapturedAt: userFeesResult.capturedAt,
+            accountModeCapturedAt: exactAccountMode.capturedAt,
+            accountModeSource: "canonical"
+          }
+        }
       };
     };
     fetchBrowserUserFills = async (input) => {
@@ -51158,6 +51591,145 @@ var init_runtime_handoff = __esm({
   }
 });
 
+// lib/runtime/status-contract.ts
+var init_status_contract = __esm({
+  "lib/runtime/status-contract.ts"() {
+    "use strict";
+  }
+});
+
+// lib/runtime/error-surface-contract.ts
+var SENSITIVE_DB_TOKENS, SCHEMA_DISCLOSURE_TOKENS, SQL_STATEMENT_PATTERN, TRACEBACK_PATTERN, DB_SESSION_STATE_PATTERNS, isSensitiveRuntimeErrorDetail, EXECUTION_ERROR_DEFAULTS, isExecutionErrorReasonCode, RuntimeExecutionError, projectExecutionErrorContract;
+var init_error_surface_contract = __esm({
+  "lib/runtime/error-surface-contract.ts"() {
+    "use strict";
+    init_status_contract();
+    init_runtime_redaction();
+    SENSITIVE_DB_TOKENS = [
+      "sqlalchemy",
+      "asyncpg",
+      "psycopg",
+      "dbapi",
+      "programmingerror",
+      "undefinedcolumnerror",
+      "integrityerror",
+      "statementerror",
+      "queuepool",
+      "postgresql",
+      "sqlite"
+    ];
+    SCHEMA_DISCLOSURE_TOKENS = [
+      " column ",
+      " table ",
+      " schema ",
+      " relation ",
+      " constraint "
+    ];
+    SQL_STATEMENT_PATTERN = /\b(select|insert|update|delete)\b[\s\S]{0,300}\bfrom\b/i;
+    TRACEBACK_PATTERN = /traceback \(most recent call last\):/i;
+    DB_SESSION_STATE_PATTERNS = [
+      /\bthis session is in ['"]?\w+['"]? state\b/i,
+      /\bno further sql can be emitted within this transaction\b/i,
+      /\bcan(?:not|'t) reconnect until (?:the )?invalid transaction is rolled back\b/i,
+      /\bthis session(?:'s)? transaction has been rolled back due to a previous exception\b/i,
+      /\bthis transaction is (?:closed|inactive)\b/i,
+      /\bthis session is provisioning a new connection; concurrent operations are not permitted\b/i,
+      /\bthis session has been permanently closed\b/i,
+      /\binvalid savepoint transaction\b/i
+    ];
+    isSensitiveRuntimeErrorDetail = (error48) => {
+      const message = String(error48 || "").trim();
+      if (!message) {
+        return false;
+      }
+      const lowered = message.toLowerCase();
+      if (TRACEBACK_PATTERN.test(lowered) || lowered.includes("[sql:")) {
+        return true;
+      }
+      if (SENSITIVE_DB_TOKENS.some((token) => lowered.includes(token))) {
+        return true;
+      }
+      if (DB_SESSION_STATE_PATTERNS.some((pattern) => pattern.test(message))) {
+        return true;
+      }
+      return SQL_STATEMENT_PATTERN.test(lowered) && SCHEMA_DISCLOSURE_TOKENS.some((token) => ` ${lowered} `.includes(token));
+    };
+    EXECUTION_ERROR_DEFAULTS = {
+      private_node_stale: ["preflight", "not_dispatched"],
+      signer_validation_unavailable: ["preflight", "not_dispatched"],
+      wallet_not_authorized: ["preflight", "not_dispatched"],
+      credentials_missing: ["preflight", "not_dispatched"],
+      local_safety_block: ["preflight", "not_dispatched"],
+      redis_unavailable: ["coordination", "not_dispatched"],
+      exchange_rejected: ["exchange_response", "confirmed_dispatched"],
+      outcome_unknown: ["transport", "outcome_unknown"],
+      internal_execution_error: ["execution", "unknown"]
+    };
+    isExecutionErrorReasonCode = (value) => Object.prototype.hasOwnProperty.call(EXECUTION_ERROR_DEFAULTS, value);
+    RuntimeExecutionError = class extends Error {
+      constructor(message, reasonCode) {
+        super(message);
+        this.name = "RuntimeExecutionError";
+        this.reasonCode = reasonCode;
+        this.executionStage = EXECUTION_ERROR_DEFAULTS[reasonCode][0];
+        this.dispatchOutcome = EXECUTION_ERROR_DEFAULTS[reasonCode][1];
+      }
+    };
+    projectExecutionErrorContract = (input) => {
+      const {
+        error: error48,
+        symbol: symbol2 = null,
+        reasonCode = null
+      } = input;
+      const typed = error48;
+      const rawReason = String(reasonCode || typed?.reasonCode || "internal_execution_error").trim().toLowerCase();
+      const resolvedReason = isExecutionErrorReasonCode(rawReason) ? rawReason : "internal_execution_error";
+      const defaults = EXECUTION_ERROR_DEFAULTS[resolvedReason];
+      const resolvedStage = defaults[0];
+      const resolvedDispatch = defaults[1];
+      const normalizedSymbol = String(symbol2 || "").trim();
+      const orderLabel = normalizedSymbol ? `${normalizedSymbol} order` : "order";
+      const rawMessage = sanitizeRuntimeDiagnosticValue(
+        error48 instanceof Error ? error48.message : String(error48 || "").trim()
+      );
+      let message;
+      if (resolvedReason === "private_node_stale") {
+        message = `\u26A0\uFE0F The ${orderLabel} was not sent: Hyperliquid private account data was too stale to validate the signing key.`;
+      } else if (resolvedReason === "signer_validation_unavailable") {
+        message = `\u26A0\uFE0F The ${orderLabel} was not sent: Hyperliquid's private account service could not validate the signing key.`;
+      } else if (resolvedReason === "wallet_not_authorized") {
+        message = `\u26A0\uFE0F The ${orderLabel} was not sent: the signing key is not authorized for the configured wallet.`;
+      } else if (resolvedReason === "credentials_missing") {
+        message = `\u26A0\uFE0F The ${orderLabel} was not sent: a wallet address and authorized signing key are required for trading.`;
+      } else if (resolvedReason === "local_safety_block") {
+        const detail = isSensitiveRuntimeErrorDetail(rawMessage) ? "Local preflight validation failed." : rawMessage || "Local preflight validation failed.";
+        const canonicalDetail = detail.replace(/^⚠️?\s*The (?:.+ )?order was not sent before exchange dispatch:\s*/i, "").trim() || "Local preflight validation failed.";
+        message = `\u26A0\uFE0F The ${orderLabel} was not sent before exchange dispatch: ${canonicalDetail}`;
+      } else if (resolvedReason === "redis_unavailable") {
+        message = `\u26A0\uFE0F The ${orderLabel} was not sent because execution coordination was unavailable.`;
+      } else if (resolvedReason === "exchange_rejected") {
+        let detail = isSensitiveRuntimeErrorDetail(rawMessage) ? "The exchange did not provide safe rejection details." : rawMessage || "The exchange did not provide safe rejection details.";
+        detail = detail.replace(/^⚠️?\s*Hyperliquid rejected the (?:.+ )?order:\s*/i, "").trim();
+        detail = detail.replace(/^(?:Hyperliquid rejected order:|Order execution failed:|order execution failed:)\s*/, "");
+        detail = detail.replace(/\s+asset=\d+\b\.?/g, "").trim() || "The exchange did not provide safe rejection details.";
+        message = `\u26A0\uFE0F Hyperliquid rejected the ${orderLabel}: ${detail}`;
+      } else if (resolvedReason === "outcome_unknown") {
+        message = `\u26A0\uFE0F VTX could not confirm whether the ${orderLabel} was applied. Check open orders and the current position before retrying.`;
+      } else {
+        const detail = isSensitiveRuntimeErrorDetail(rawMessage) ? "VTX could not complete the exchange operation." : rawMessage || "VTX could not complete the exchange operation.";
+        const canonicalDetail = detail.replace(/^⚠️?\s*VTX could not complete the (?:.+ )?order:\s*/i, "").trim() || "VTX could not complete the exchange operation.";
+        message = `\u26A0\uFE0F VTX could not complete the ${orderLabel}: ${canonicalDetail}`;
+      }
+      return {
+        reason_code: resolvedReason,
+        execution_stage: resolvedStage,
+        dispatch_outcome: resolvedDispatch,
+        message
+      };
+    };
+  }
+});
+
 // lib/runtime/hyperliquid-client.ts
 var HyperliquidExchangeRejectionError, durableMutationAuthorityArgs, assertFreshPreparedExecutionContext, HYPERLIQUID_TERMINAL_ORDER_STATUSES, normalizeSymbol, HYPERLIQUID_NONCE_STORAGE_KEY, HYPERLIQUID_NONCE_LOCK_NAME, lastGeneratedNonce, readBrowserStoredHyperliquidNonce, writeBrowserStoredHyperliquidNonce, browserNonceCoordinator, allocateHyperliquidNonce, generateHyperliquidNonce, roundToSigFigs, normalizeDecimalString, toPlainDecimalString, roundDirectionalDecimalString, formatHyperliquidPerpPriceWire, formatHyperliquidTriggerPriceWire, countSignificantDigits, countDecimalPlaces, validateHyperliquidPerpPriceWire, validateHyperliquidSizeWire, formatSizeWire, inferApiUrl, inferIsTestnet, postHyperliquidInfo, toFiniteNumber, OPEN_ORDER_NUMERIC_STRING, OPEN_ORDER_ID_STRING, parseCanonicalOpenOrderId, parseOpenOrderFiniteNumber, parseOpenOrderPositiveNumber, parseOpenOrderPresentationNumber, readOpenOrderField, firstFiniteNumber2, parseFundingUsdcFromInfoPosition2, isExchangeIsolatedOnly, computeHip3AssetId, getPerpDexIndexMap, buildAssetInfosFromMetaResponse, requireWalletAddress2, assertPositiveInteger, assertPositiveNumber, normalizeOrderSide, normalizeHyperliquidClientOrderId, resolveAssets, findResolvedAsset, normalizeExecutionAssetMetadata, resolveHyperliquidAsset, resolveHyperliquidAssetIndex, fetchBrowserAvailableAssets, fetchBrowserAllMids, fetchBrowserSymbolMidPrice, fetchBrowserOpenOrders, parseCanonicalHyperliquidOrderStatusEvidence, fetchBrowserOrderStatusEvidence, fetchBrowserUserRole, fetchBrowserAccountState2, fetchBrowserPosition, buildHyperliquidOrderWire, buildHyperliquidTriggerOrderWire, signHyperliquidPayload, buildHyperliquidCancelPayload, buildHyperliquidUpdateLeveragePayload, buildHyperliquidMarketOrderPayload, buildHyperliquidTriggerOrderPayload, buildHyperliquidOrderBatchPayload, buildHyperliquidModifyOrderPayload, extractHyperliquidExchangeError, isDefinitiveHyperliquidExchangeResponse, extractDefinitiveHyperliquidOrderId, CANONICAL_POSITIVE_DECIMAL_PATTERN, extractCanonicalHyperliquidOrderStateAcknowledgement, extractCanonicalHyperliquidOrderStateAcknowledgements, extractCanonicalHyperliquidFilledOrderAcknowledgement, extractDefinitiveHyperliquidOrderMemberResults, buildHyperliquidOrderDiagnostics, loadClientExecutionReferenceEvidence, sha256Hex, extractSignedPayloadClientOrderId, extractSignedPayloadMutationCorrelation, assertDurableMutationMatchesSignedAction, submitHyperliquidExchangePayload;
 var init_hyperliquid_client = __esm({
@@ -51171,9 +51743,10 @@ var init_hyperliquid_client = __esm({
     init_runtime_redaction();
     init_exchange_mutation_fence();
     init_runtime_handoff();
-    HyperliquidExchangeRejectionError = class extends Error {
+    init_error_surface_contract();
+    HyperliquidExchangeRejectionError = class extends RuntimeExecutionError {
       constructor(message, orderDiagnostics, clientMutationId = null) {
-        super(message);
+        super(message, "exchange_rejected");
         this.name = "HyperliquidExchangeRejectionError";
         this.orderDiagnostics = orderDiagnostics;
         this.clientMutationId = clientMutationId;
@@ -52871,8 +53444,9 @@ var init_hyperliquid_client = __esm({
               ...durableMutationAuthorityArgs(durableMutation)
             );
             if (beginResult.dispatch_authorized !== true) {
-              throw new Error(
-                "This exchange mutation was already recorded and will not be dispatched again. Durable reconciliation is required before retrying."
+              throw new RuntimeExecutionError(
+                "This exchange mutation was already recorded and will not be dispatched again. Durable reconciliation is required before retrying.",
+                "local_safety_block"
               );
             }
           }
@@ -52895,8 +53469,9 @@ var init_hyperliquid_client = __esm({
                 ...durableMutationAuthorityArgs(durableMutation)
               );
             } catch {
-              throw new Error(
-                "Exchange submission may have completed; durable reconciliation is pending."
+              throw new RuntimeExecutionError(
+                "Exchange submission may have completed; durable reconciliation is pending.",
+                "outcome_unknown"
               );
             }
           };
@@ -52980,7 +53555,10 @@ var init_hyperliquid_client = __esm({
               assertFreshPreparedExecutionContext(input.preparedContext);
             } catch (preparedContextError) {
               await settleDurableMutation("rejected");
-              throw preparedContextError;
+              throw new RuntimeExecutionError(
+                preparedContextError instanceof Error ? preparedContextError.message : "Prepared exchange context expired before dispatch.",
+                "local_safety_block"
+              );
             }
             if (input.signal?.aborted) {
               await settleDurableMutation("rejected");
@@ -53012,8 +53590,9 @@ var init_hyperliquid_client = __esm({
             const payload = await response.json().catch(() => ({}));
             if (!response.ok) {
               await settleDurableMutation("transport_ambiguous");
-              throw new Error(
-                "Exchange submission may have completed; durable reconciliation is pending."
+              throw new RuntimeExecutionError(
+                "Exchange submission may have completed; durable reconciliation is pending.",
+                "outcome_unknown"
               );
             }
             const exchangeError = extractHyperliquidExchangeError(payload);
@@ -53022,8 +53601,9 @@ var init_hyperliquid_client = __esm({
                 exchangeError.partial ? "transport_ambiguous" : "rejected"
               );
               if (exchangeError.partial) {
-                throw new Error(
-                  "Hyperliquid returned a partially applied exchange response; durable reconciliation is pending."
+                throw new RuntimeExecutionError(
+                  "Hyperliquid returned a partially applied exchange response; durable reconciliation is pending.",
+                  "outcome_unknown"
                 );
               }
               throw new HyperliquidExchangeRejectionError(
@@ -53037,8 +53617,9 @@ var init_hyperliquid_client = __esm({
               input.payload.action
             )) {
               await settleDurableMutation("transport_ambiguous");
-              throw new Error(
-                "Hyperliquid returned an incomplete exchange response; durable reconciliation is pending."
+              throw new RuntimeExecutionError(
+                "Hyperliquid returned an incomplete exchange response; durable reconciliation is pending.",
+                "outcome_unknown"
               );
             }
             const exactExchangeOrderId = durableMutation?.operationKind === "order" ? extractDefinitiveHyperliquidOrderId(payload, input.payload.action) : null;
@@ -53060,12 +53641,14 @@ var init_hyperliquid_client = __esm({
               try {
                 await settleDurableMutation("transport_ambiguous");
               } catch {
-                throw new Error(
-                  "Exchange submission may have completed; durable reconciliation is pending."
+                throw new RuntimeExecutionError(
+                  "Exchange submission may have completed; durable reconciliation is pending.",
+                  "outcome_unknown"
                 );
               }
-              throw new Error(
-                "Exchange submission may have completed; durable reconciliation is pending."
+              throw new RuntimeExecutionError(
+                "Exchange submission may have completed; durable reconciliation is pending.",
+                "outcome_unknown"
               );
             }
             throw error48;
@@ -53087,6 +53670,7 @@ var init_hyperliquid_signer_binding = __esm({
     "use strict";
     init_lib2();
     init_hyperliquid_client();
+    init_error_surface_contract();
     normalizeAddress = (value, label) => {
       const normalized = String(value || "").trim().toLowerCase();
       if (!/^0x[0-9a-f]{40}$/.test(normalized)) {
@@ -53109,7 +53693,15 @@ var init_hyperliquid_signer_binding = __esm({
       return null;
     };
     assertBrowserHyperliquidSignerWalletBinding = async (input) => {
-      const walletAddress = normalizeAddress(input.walletAddress, "wallet address");
+      let walletAddress;
+      try {
+        walletAddress = normalizeAddress(input.walletAddress, "wallet address");
+      } catch {
+        throw new RuntimeExecutionError(
+          "A valid Hyperliquid wallet address is required for trading.",
+          "credentials_missing"
+        );
+      }
       let signerAddress;
       try {
         signerAddress = normalizeAddress(
@@ -53117,13 +53709,25 @@ var init_hyperliquid_signer_binding = __esm({
           "signer address"
         );
       } catch {
-        throw new Error("Invalid Hyperliquid signing key.");
+        throw new RuntimeExecutionError(
+          "Invalid Hyperliquid signing key.",
+          "credentials_missing"
+        );
+      }
+      let roleResponse;
+      try {
+        roleResponse = await fetchBrowserUserRole({
+          config: input.config ?? null,
+          walletAddress: signerAddress,
+          signal: input.signal
+        });
+      } catch (error48) {
+        if (input.signal?.aborted) throw error48;
+        throw new RuntimeExecutionError(
+          "Hyperliquid's private account service could not validate the signing key.",
+          "signer_validation_unavailable"
+        );
       }
-      const roleResponse = await fetchBrowserUserRole({
-        config: input.config ?? null,
-        walletAddress: signerAddress,
-        signal: input.signal
-      });
       const signerRole = String(roleResponse.role || "").trim().toLowerCase();
       if (signerRole === "user" && signerAddress === walletAddress) {
         return {
@@ -53145,8 +53749,9 @@ var init_hyperliquid_signer_binding = __esm({
           };
         }
       }
-      throw new Error(
-        "The device Hyperliquid signing key is not authorized for this profile wallet. Stop the runtime and reconnect the wallet."
+      throw new RuntimeExecutionError(
+        "The device Hyperliquid signing key is not authorized for this profile wallet. Stop the runtime and reconnect the wallet.",
+        "wallet_not_authorized"
       );
     };
   }
@@ -53881,6 +54486,7 @@ var init_browser_trading = __esm({
     "use strict";
     init_hyperliquid_client();
     init_hyperliquid_signer_binding();
+    init_error_surface_contract();
     init_vault();
     resolveProfileId = (value) => {
       const profileId = String(value).trim();
@@ -53966,7 +54572,10 @@ var init_browser_trading = __esm({
         }
       }
       if (!signingKey) {
-        throw new Error("Missing required device-local Hyperliquid signing key for this profile. Configure it in System for this device.");
+        throw new RuntimeExecutionError(
+          "Missing required device-local Hyperliquid signing key for this profile. Configure it in System for this device.",
+          "credentials_missing"
+        );
       }
       return signingKey;
     };
@@ -53975,7 +54584,10 @@ var init_browser_trading = __esm({
       const signingKey = explicit || await loadSigningKey(resolveProfileId(input.profileId));
       const walletAddress = String(input.walletAddress || "").trim();
       if (!walletAddress) {
-        throw new Error("Missing wallet address for client Hyperliquid signing.");
+        throw new RuntimeExecutionError(
+          "Missing wallet address for client Hyperliquid signing.",
+          "credentials_missing"
+        );
       }
       await assertBrowserHyperliquidSignerWalletBinding({
         signingKey,
@@ -54484,6 +55096,7 @@ var init_runtime_execution = __esm({
     init_hyperliquid_market_symbol();
     init_network_debug();
     init_runtime_redaction();
+    init_error_surface_contract();
     init_runtime_handoff();
     fetchClientRuntimeOpenOrders = async (request) => {
       const normalizedSymbol = normalizeHyperliquidMarketSymbol(
@@ -55961,6 +56574,7 @@ var init_runtime_execution = __esm({
           }
         }
         for (const candidate of candidates) {
+          const rejectionProjection = error48 instanceof HyperliquidExchangeRejectionError ? projectExecutionErrorContract({ error: error48, symbol: symbol2 }) : null;
           reports.push({
             order_id: null,
             client_mutation_id: error48 instanceof HyperliquidExchangeRejectionError ? error48.clientMutationId ?? candidate.mutationId : candidate.mutationId,
@@ -55968,10 +56582,12 @@ var init_runtime_execution = __esm({
             action: candidate.kind === "sl" ? "AUTO_SL" : "AUTO_TP",
             status: error48 instanceof HyperliquidExchangeRejectionError ? "failed" : "blocked",
             execution_metadata: {
-              reason_code: error48 instanceof HyperliquidExchangeRejectionError ? "execution_error" : "protective_trigger_ack_unresolved",
-              error: getSanitizedRuntimeErrorMessage(error48) || "Protective trigger submission is unresolved.",
+              reason_code: error48 instanceof HyperliquidExchangeRejectionError ? rejectionProjection?.reason_code : "protective_trigger_ack_unresolved",
+              error: rejectionProjection?.message ?? getSanitizedRuntimeErrorMessage(error48) ?? "Protective trigger submission is unresolved.",
               ...error48 instanceof HyperliquidExchangeRejectionError ? {
-                execution_stage: "protective_trigger_order",
+                execution_stage: rejectionProjection?.execution_stage,
+                dispatch_outcome: rejectionProjection?.dispatch_outcome,
+                operation_stage: "protective_trigger_order",
                 entry_order_id: fill.orderId,
                 order_diagnostics: error48.orderDiagnostics
               } : {}
@@ -59030,15 +59646,21 @@ var init_runtime_execution = __esm({
         execution_metadata: _toExecutionMetadata(marketOrderResponse)
       });
       const appendPostEntryProtectionFailure = (error48) => {
-        const message = getSanitizedRuntimeErrorMessage(error48) || "Unknown post-entry protection error.";
+        const projection = projectExecutionErrorContract({
+          error: error48,
+          symbol: input.executionContext.symbol
+        });
+        const message = projection.message;
         executionReports.push({
           order_id: null,
           symbol: input.executionContext.symbol,
           action: "PROTECTIVE_RECONCILIATION",
           status: "failed",
           execution_metadata: {
-            reason_code: "execution_error",
-            execution_stage: "post_entry_protection",
+            reason_code: projection.reason_code,
+            execution_stage: projection.execution_stage,
+            dispatch_outcome: projection.dispatch_outcome,
+            operation_stage: "post_entry_protection",
             entry_order_id: _extractOrderId(marketOrderResponse),
             error: message
           }
@@ -59443,7 +60065,11 @@ var init_runtime_execution = __esm({
               );
             }
           } catch (triggerError) {
-            const message = getSanitizedRuntimeErrorMessage(triggerError) || "Unknown protective trigger order error.";
+            const projection = projectExecutionErrorContract({
+              error: triggerError,
+              symbol: input.executionContext.symbol
+            });
+            const message = projection.message;
             const rejection = triggerError instanceof HyperliquidExchangeRejectionError ? triggerError : null;
             executionReports.push({
               order_id: null,
@@ -59454,8 +60080,10 @@ var init_runtime_execution = __esm({
               execution_metadata: {
                 trigger_price: triggerInput.triggerPrice,
                 is_take_profit: triggerInput.isTakeProfit,
-                reason_code: "execution_error",
-                execution_stage: "protective_trigger_order",
+                reason_code: projection.reason_code,
+                execution_stage: projection.execution_stage,
+                dispatch_outcome: projection.dispatch_outcome,
+                operation_stage: "protective_trigger_order",
                 entry_order_id: _extractOrderId(marketOrderResponse),
                 error: message,
                 ...rejection ? { order_diagnostics: rejection.orderDiagnostics } : {}

package/package.json

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