@vtxmacro/cli 2026.8.50 → 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.50",
+      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"
+    ]);
   }
 });
 
@@ -18058,7 +18099,7 @@ ${body}`;
 });
 
 // lib/inference-host/mcp-client.ts
-var EXTERNAL_INFERENCE_MCP_PROTOCOL_VERSION, EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS, EXTERNAL_INFERENCE_OPERATIONAL_TOOLS, ExternalInferenceMcpError, DEFAULT_REQUEST_TIMEOUT_MS, MAX_RETRY_AFTER_MS, parseRetryAfterMs, identifierSchema2, safeCodeSchema2, hostMutationResultSchema, attemptStartResultSchema, agentConnectResultSchema, agentHeartbeatResultSchema, timestampSchema2, positiveGenerationSchema, jsonObjectSchema, agentAssignmentNextArgumentsSchema, agentAssignmentNextResultSchema, agentAssignmentHeartbeatArgumentsSchema, agentAssignmentHeartbeatResultSchema, agentDataCallArgumentsSchema, agentDataCallResultSchema, agentDecisionSubmitArgumentsSchema, agentDecisionSubmitResultSchema, agentDecisionStatusArgumentsSchema, agentDecisionStatusResultSchema, agentAssignmentReleaseArgumentsSchema, agentAssignmentReleaseResultSchema, jobCompletionResultSchema, jobFailureResultSchema, toolContracts, discoveryResultSchema, toolListResultSchema, inlineStructuredContentSchema, protocolMeta, parseJsonDocument, parseSseDocuments, parseResponseDocuments, exactOperationalInventory, exactJson, invalidBoundResult, verifyToolResult, ExternalInferenceMcpClient;
+var EXTERNAL_INFERENCE_MCP_PROTOCOL_VERSION, EXTERNAL_INFERENCE_AUTOMATED_HOST_TOOLS, EXTERNAL_INFERENCE_OPERATIONAL_TOOLS, ExternalInferenceMcpError, DEFAULT_REQUEST_TIMEOUT_MS, MAX_RETRY_AFTER_MS, parseRetryAfterMs, identifierSchema2, safeCodeSchema2, hostMutationResultSchema, attemptStartResultSchema, agentConnectResultSchema, agentHeartbeatResultSchema, timestampSchema2, positiveGenerationSchema, jsonObjectSchema, agentAssignmentNextArgumentsSchema, agentDataCapabilityDescriptorSchema, agentAssignmentNextResultSchema, agentAssignmentHeartbeatArgumentsSchema, agentAssignmentHeartbeatResultSchema, agentDataCallArgumentsSchema, agentDataCallResultSchema, agentDecisionSubmitArgumentsSchema, agentDecisionSubmitResultSchema, agentDecisionStatusArgumentsSchema, agentDecisionStatusResultSchema, agentAssignmentReleaseArgumentsSchema, agentAssignmentReleaseResultSchema, jobCompletionResultSchema, jobFailureResultSchema, toolContracts, discoveryResultSchema, toolListResultSchema, inlineStructuredContentSchema, protocolMeta, parseJsonDocument, parseSseDocuments, parseResponseDocuments, exactOperationalInventory, exactJson, invalidBoundResult, verifyToolResult, ExternalInferenceMcpClient;
 var init_mcp_client = __esm({
   "lib/inference-host/mcp-client.ts"() {
     "use strict";
@@ -18156,7 +18197,25 @@ var init_mcp_client = __esm({
     agentAssignmentNextArgumentsSchema = external_exports.strictObject({
       operation_id: identifierSchema2,
       host_id: identifierSchema2,
-      requested_at: timestampSchema2
+      requested_at: timestampSchema2,
+      contract_version: external_exports.literal("agent_assignment_v2"),
+      assignment_id: identifierSchema2.optional(),
+      assignment_generation: positiveGenerationSchema.optional()
+    }).superRefine((value, context) => {
+      if (value.assignment_id === void 0 !== (value.assignment_generation === void 0)) {
+        context.addIssue({
+          code: "custom",
+          message: "Agent recovery assignment identity is incomplete.",
+          path: ["assignment_id"]
+        });
+      }
+    });
+    agentDataCapabilityDescriptorSchema = external_exports.strictObject({
+      id: external_exports.string().min(1).max(128),
+      title: external_exports.string().min(1),
+      description: external_exports.string().min(1),
+      input_schema: jsonObjectSchema,
+      input_schema_sha256: external_exports.string().regex(/^[0-9a-f]{64}$/u)
     });
     agentAssignmentNextResultSchema = external_exports.discriminatedUnion("claim_state", [
       external_exports.strictObject({
@@ -18172,6 +18231,11 @@ var init_mcp_client = __esm({
         model_id: identifierSchema2,
         reasoning_effort: safeCodeSchema2,
         allowed_symbols: external_exports.array(external_exports.string().min(1)).min(1),
+        contract_version: external_exports.literal("agent_assignment_v2"),
+        data_contract: external_exports.array(agentDataCapabilityDescriptorSchema).min(1).refine(
+          (value) => new Set(value.map((descriptor) => descriptor.id)).size === value.length,
+          { message: "Agent data capability descriptors must be unique." }
+        ),
         output_schema_version: external_exports.string().min(1),
         output_schema: jsonObjectSchema,
         minimum_wake_seconds: external_exports.number().int().positive().max(Number.MAX_SAFE_INTEGER),
@@ -19743,19 +19807,42 @@ var init_agent_state = __esm({
         "updated_at"
       ])) throw new Error(message);
       const assignment = assertPlainObject(state.assignment, message);
-      if (state.schema_version !== "vtx_codex_agent_runtime_v1" || typeof state.host_id !== "string" || !state.host_id || !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at) || !hasExactKeys(assignment, [
-        "assignment_id",
-        "assignment_generation",
-        "model_id",
-        "reasoning_effort",
-        "bot_mode",
-        "execution_mode",
-        "allowed_symbols",
-        "output_schema",
-        "minimum_wake_seconds",
-        "maximum_wake_seconds",
-        "lease_expires_at"
-      ]) || typeof assignment.assignment_id !== "string" || !assignment.assignment_id || !Number.isSafeInteger(assignment.assignment_generation) || Number(assignment.assignment_generation) < 1 || typeof assignment.model_id !== "string" || !assignment.model_id || typeof assignment.reasoning_effort !== "string" || !assignment.reasoning_effort || !["trader", "assistant"].includes(String(assignment.bot_mode)) || !["server", "client"].includes(String(assignment.execution_mode)) || !Array.isArray(assignment.allowed_symbols) || assignment.allowed_symbols.some((symbol2) => typeof symbol2 !== "string" || !symbol2) || !assignment.output_schema || typeof assignment.output_schema !== "object" || Array.isArray(assignment.output_schema) || !Number.isSafeInteger(assignment.minimum_wake_seconds) || Number(assignment.minimum_wake_seconds) < 1 || !Number.isSafeInteger(assignment.maximum_wake_seconds) || Number(assignment.maximum_wake_seconds) < Number(assignment.minimum_wake_seconds) || !isIsoTimestamp(assignment.lease_expires_at)) throw new Error(message);
+      if (!["vtx_codex_agent_runtime_v1", "vtx_codex_agent_runtime_v2"].includes(
+        String(state.schema_version)
+      ) || typeof state.host_id !== "string" || !state.host_id || !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at) || !hasExactKeys(
+        assignment,
+        [
+          "assignment_id",
+          "assignment_generation",
+          "model_id",
+          "reasoning_effort",
+          "bot_mode",
+          "execution_mode",
+          "allowed_symbols",
+          "output_schema",
+          "minimum_wake_seconds",
+          "maximum_wake_seconds",
+          "lease_expires_at",
+          ...state.schema_version === "vtx_codex_agent_runtime_v2" ? ["data_contract"] : []
+        ]
+      ) || typeof assignment.assignment_id !== "string" || !assignment.assignment_id || !Number.isSafeInteger(assignment.assignment_generation) || Number(assignment.assignment_generation) < 1 || typeof assignment.model_id !== "string" || !assignment.model_id || typeof assignment.reasoning_effort !== "string" || !assignment.reasoning_effort || !["trader", "assistant"].includes(String(assignment.bot_mode)) || !["server", "client"].includes(String(assignment.execution_mode)) || !Array.isArray(assignment.allowed_symbols) || assignment.allowed_symbols.some((symbol2) => typeof symbol2 !== "string" || !symbol2) || !assignment.output_schema || typeof assignment.output_schema !== "object" || Array.isArray(assignment.output_schema) || !Number.isSafeInteger(assignment.minimum_wake_seconds) || Number(assignment.minimum_wake_seconds) < 1 || !Number.isSafeInteger(assignment.maximum_wake_seconds) || Number(assignment.maximum_wake_seconds) < Number(assignment.minimum_wake_seconds) || !isIsoTimestamp(assignment.lease_expires_at)) throw new Error(message);
+      if (state.schema_version === "vtx_codex_agent_runtime_v2") {
+        if (!Array.isArray(assignment.data_contract) || assignment.data_contract.length === 0) {
+          throw new Error(message);
+        }
+        const capabilityIds = assignment.data_contract.map((value2) => {
+          const descriptor = assertPlainObject(value2, message);
+          if (!hasExactKeys(descriptor, [
+            "id",
+            "title",
+            "description",
+            "input_schema",
+            "input_schema_sha256"
+          ]) || typeof descriptor.id !== "string" || !descriptor.id || typeof descriptor.title !== "string" || !descriptor.title || typeof descriptor.description !== "string" || !descriptor.description || !descriptor.input_schema || typeof descriptor.input_schema !== "object" || Array.isArray(descriptor.input_schema) || typeof descriptor.input_schema_sha256 !== "string" || !/^[0-9a-f]{64}$/u.test(descriptor.input_schema_sha256)) throw new Error(message);
+          return descriptor.id;
+        });
+        if (new Set(capabilityIds).size !== capabilityIds.length) throw new Error(message);
+      }
       if (state.thread !== null) {
         const thread = assertPlainObject(state.thread, message);
         if (!hasExactKeys(thread, [
@@ -19909,7 +19996,7 @@ async function logoutCodexSubscription(options) {
     await session.close();
   }
 }
-var CODEX_INFERENCE_PERMISSION_PROFILE, CODEX_AGENT_PERMISSION_PROFILE, CODEX_REASONING_CONTENT_MAX_UTF8_BYTES, CODEX_REASONING_SUMMARY_MAX_UTF8_BYTES, CODEX_ACCOUNT_PLAN_TYPES, CODEX_AGENT_DYNAMIC_TOOLS, CodexAppServerError, objectOrNull, finiteToken, tokenUsageFromBreakdown, usageFromNotification, validPlanType, nonnegativeSafeIntegerOrNull, nonnegativeFiniteNumberOrNull, parseRateLimitWindow, RATE_LIMIT_REACHED_TYPES, DEFAULT_CODEX_QUOTA_COOLDOWN_MS, MAX_CODEX_QUOTA_COOLDOWN_MS, CODEX_TRANSIENT_RATE_LIMIT_COOLDOWN_MS, parseRateLimitSnapshot, codexRateLimitRetryAtMs, codexAccountRateLimitReached, forbiddenMethod, forbiddenTerminalItem, forbiddenAgentMethod, forbiddenAgentTerminalItem, CODEX_AGENT_TOOL_SPECS, classifyCodexTurnFailure, scrubbedCodexEnvironment, killWindowsProcessTree, appServerArgs, GUARDIAN_SCRIPT, WINDOWS_RECEIPT_REPLACE_ERROR_CODES, MAX_RETIRED_RESPONSE_IDS, LATE_RESPONSE_SAFE_METHODS, replaceCodexGuardianReceiptFile, writeCodexGuardianSpawnIntent, parseGuardianReceipt, readCodexGuardianReceipt, waitForCodexGuardianState, defaultSpawn, CodexAppServerSession;
+var CODEX_INFERENCE_PERMISSION_PROFILE, CODEX_AGENT_PERMISSION_PROFILE, CODEX_REASONING_CONTENT_MAX_UTF8_BYTES, CODEX_REASONING_SUMMARY_MAX_UTF8_BYTES, CODEX_ACCOUNT_PLAN_TYPES, CODEX_AGENT_DYNAMIC_TOOLS, CodexAppServerError, objectOrNull, finiteToken, tokenUsageFromBreakdown, usageFromNotification, validPlanType, nonnegativeSafeIntegerOrNull, nonnegativeFiniteNumberOrNull, parseRateLimitWindow, RATE_LIMIT_REACHED_TYPES, DEFAULT_CODEX_QUOTA_COOLDOWN_MS, MAX_CODEX_QUOTA_COOLDOWN_MS, CODEX_TRANSIENT_RATE_LIMIT_COOLDOWN_MS, parseRateLimitSnapshot, codexRateLimitRetryAtMs, codexAccountRateLimitReached, forbiddenMethod, forbiddenTerminalItem, forbiddenAgentMethod, forbiddenAgentTerminalItem, createCodexAgentToolSpecs, classifyCodexTurnFailure, scrubbedCodexEnvironment, killWindowsProcessTree, appServerArgs, GUARDIAN_SCRIPT, WINDOWS_RECEIPT_REPLACE_ERROR_CODES, MAX_RETIRED_RESPONSE_IDS, LATE_RESPONSE_SAFE_METHODS, replaceCodexGuardianReceiptFile, writeCodexGuardianSpawnIntent, parseGuardianReceipt, readCodexGuardianReceipt, waitForCodexGuardianState, defaultSpawn, CodexAppServerSession;
 var init_codex_app_server = __esm({
   "lib/inference-host/codex-app-server.ts"() {
     "use strict";
@@ -20074,41 +20161,62 @@ var init_codex_app_server = __esm({
       "webSearch",
       "contextCompaction"
     ].includes(String(item.type || ""));
-    CODEX_AGENT_TOOL_SPECS = [
-      {
-        name: "vtx_get_data",
-        description: "Request assignment-scoped VTX data. Choose the capability and only the arguments needed for this decision.",
-        inputSchema: {
-          type: "object",
-          additionalProperties: false,
-          required: ["capability", "arguments"],
-          properties: {
-            capability: { type: "string", minLength: 1 },
-            arguments: { type: "object" }
-          }
-        }
-      },
-      {
-        name: "vtx_submit_decision",
-        description: "Submit one VTX structured trading decision candidate using the assignment decision schema.",
-        inputSchema: {
-          type: "object",
-          additionalProperties: false,
-          required: ["candidate"],
-          properties: { candidate: { type: "object" } }
+    createCodexAgentToolSpecs = (dataContract, decisionSchema) => {
+      if (dataContract.length === 0 || Object.keys(decisionSchema).length === 0) {
+        throw new CodexAppServerError({
+          message: "Codex Agent data contract is unavailable.",
+          category: "schema",
+          code: "invalid_agent_data_contract",
+          retryable: false
+        });
+      }
+      const dataRequestBranches = dataContract.map((descriptor) => ({
+        type: "object",
+        additionalProperties: false,
+        required: ["capability", "arguments"],
+        description: descriptor.description,
+        properties: {
+          capability: {
+            type: "string",
+            const: descriptor.id,
+            title: descriptor.title
+          },
+          arguments: descriptor.input_schema
         }
-      },
-      {
-        name: "vtx_decision_status",
-        description: "Resolve the durable status of a previously attempted decision operation.",
-        inputSchema: {
-          type: "object",
-          additionalProperties: false,
-          required: ["operation_id"],
-          properties: { operation_id: { type: "string", minLength: 1 } }
+      }));
+      return [
+        {
+          type: "function",
+          name: "vtx_get_data",
+          description: "Request assignment-scoped VTX data using one exact canonical capability schema.",
+          inputSchema: {
+            oneOf: dataRequestBranches
+          }
+        },
+        {
+          type: "function",
+          name: "vtx_submit_decision",
+          description: "Submit one VTX structured trading decision candidate using the assignment decision schema.",
+          inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["candidate"],
+            properties: { candidate: decisionSchema }
+          }
+        },
+        {
+          type: "function",
+          name: "vtx_decision_status",
+          description: "Resolve the durable status of a previously attempted decision operation.",
+          inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["operation_id"],
+            properties: { operation_id: { type: "string", minLength: 1 } }
+          }
         }
-      }
-    ];
+      ];
+    };
     classifyCodexTurnFailure = (codexErrorInfo, terminalStatus) => {
       if (terminalStatus === "interrupted") {
         return { code: "cancelled", category: "cancelled", retryable: false, httpStatusCode: null };
@@ -20272,7 +20380,7 @@ var init_codex_app_server = __esm({
         });
       });
     };
-    appServerArgs = () => {
+    appServerArgs = (enableAgentCodeModeHost = false) => {
       const args = [
         "app-server",
         "--stdio",
@@ -20295,8 +20403,9 @@ var init_codex_app_server = __esm({
         "memories",
         "image_generation",
         "multi_agent",
-        "code_mode_host"
+        ...enableAgentCodeModeHost ? [] : ["code_mode_host"]
       ]) args.push("--disable", feature);
+      if (enableAgentCodeModeHost) args.push("--enable", "code_mode_host");
       return args;
     };
     GUARDIAN_SCRIPT = String.raw`
@@ -20641,7 +20750,9 @@ child.once('close', async (code, signal) => {
             });
           }
         }
-        const child = spawnProcess(options.binary.path, appServerArgs(), {
+        const child = spawnProcess(options.binary.path, appServerArgs(
+          options.enableAgentCodeModeHost === true
+        ), {
           env: scrubbedCodexEnvironment(options.codexHome),
           stdio: ["pipe", "pipe", "pipe"],
           windowsHide: true,
@@ -21445,7 +21556,7 @@ child.once('close', async (code, signal) => {
           ephemeral: false,
           historyMode: "legacy",
           environments: [],
-          dynamicTools: CODEX_AGENT_TOOL_SPECS,
+          dynamicTools: createCodexAgentToolSpecs(options.dataContract, options.decisionSchema),
           selectedCapabilityRoots: [],
           experimentalRawEvents: false,
           developerInstructions: options.systemPrompt,
@@ -21457,9 +21568,9 @@ child.once('close', async (code, signal) => {
             web_search: "live",
             features: {
               apps: false,
-              code_mode: false,
+              code_mode: true,
               code_mode_buffered_exec: false,
-              code_mode_host: false,
+              code_mode_host: true,
               code_mode_only: false,
               in_app_browser: false,
               js_repl: false,
@@ -23648,6 +23759,7 @@ var init_codex_adapter = __esm({
               deadlineAtMs,
               signal,
               spawnProcess: this.dependencies.spawnProcess,
+              enableAgentCodeModeHost: true,
               guardian: this.guardianProcessToken && this.guardianReceiptPath ? {
                 processToken: this.guardianProcessToken,
                 receiptPath: this.guardianReceiptPath
@@ -23695,6 +23807,8 @@ var init_codex_adapter = __esm({
             systemPrompt: input.systemPrompt,
             requestedModel: input.requestedModel,
             requestedReasoningEffort: input.requestedReasoningEffort,
+            dataContract: input.dataContract,
+            decisionSchema: input.decisionSchema,
             deadlineAtMs: input.deadlineAtMs,
             signal: input.signal
           });
@@ -23707,6 +23821,8 @@ var init_codex_adapter = __esm({
             systemPrompt: input.systemPrompt,
             requestedModel: input.requestedModel,
             requestedReasoningEffort: input.requestedReasoningEffort,
+            dataContract: input.dataContract,
+            decisionSchema: input.decisionSchema,
             deadlineAtMs: input.deadlineAtMs,
             signal: input.signal
           });
@@ -33015,7 +33131,10 @@ var init_runner = __esm({
     };
     createCodexAgentControlClient = (mcp) => ({
       nextAssignment: async (request, options) => {
-        const result2 = await mcp.callTool("inference.agent.assignment.next", request, options);
+        const result2 = await mcp.callTool("inference.agent.assignment.next", {
+          ...request,
+          contract_version: "agent_assignment_v2"
+        }, options);
         if (result2.claim_state === "empty") return null;
         return {
           assignment_id: result2.assignment_id,
@@ -33025,6 +33144,7 @@ var init_runner = __esm({
           bot_mode: result2.bot_mode,
           execution_mode: result2.execution_mode,
           allowed_symbols: result2.allowed_symbols,
+          data_contract: result2.data_contract,
           output_schema: result2.output_schema,
           minimum_wake_seconds: result2.minimum_wake_seconds,
           maximum_wake_seconds: result2.maximum_wake_seconds,
@@ -33119,13 +33239,20 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
       }
       async runOnce(signal) {
         const nowIso = () => new Date(this.now()).toISOString();
-        let state = await readCodexAgentRuntimeState(this.options.statePath);
-        if (state && state.host_id !== this.options.hostId) {
+        const recoveredState = await readCodexAgentRuntimeState(this.options.statePath);
+        if (recoveredState && recoveredState.host_id !== this.options.hostId) {
           throw new InferenceHostRunnerError(
             "agent_recovery_scope_mismatch",
             "Codex Agent recovery state belongs to another host."
           );
         }
+        let state;
+        if (recoveredState?.schema_version === "vtx_codex_agent_runtime_v1") {
+          state = await this.upgradeLegacyRuntimeState(recoveredState, signal);
+          if (!state) return this.now() + (this.options.idlePollMs ?? 5e3);
+        } else {
+          state = recoveredState ?? null;
+        }
         if (!state) {
           const assignment2 = await this.options.controlClient.nextAssignment({
             operation_id: randomUUID(),
@@ -33134,7 +33261,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           }, { signal });
           if (!assignment2) return this.now() + (this.options.idlePollMs ?? 5e3);
           state = {
-            schema_version: "vtx_codex_agent_runtime_v1",
+            schema_version: "vtx_codex_agent_runtime_v2",
             host_id: this.options.hostId,
             assignment: assignment2,
             thread: null,
@@ -33150,8 +33277,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             if (wakeOutcome !== "ready") {
               return this.now() + (this.options.idlePollMs ?? 5e3);
             }
-            state = await readCodexAgentRuntimeState(this.options.statePath);
-            if (!state) return this.now() + (this.options.idlePollMs ?? 5e3);
+            const rereadState = await readCodexAgentRuntimeState(this.options.statePath);
+            if (rereadState?.schema_version !== "vtx_codex_agent_runtime_v2") {
+              return this.now() + (this.options.idlePollMs ?? 5e3);
+            }
+            state = rereadState;
           }
         }
         state = await this.resolvePendingDecision(state, signal);
@@ -33213,6 +33343,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
               bot_mode: assignment.bot_mode,
               execution_mode: assignment.execution_mode,
               allowed_symbols: assignment.allowed_symbols,
+              data_capability_ids: assignment.data_contract.map((descriptor) => descriptor.id),
               output_schema: assignment.output_schema,
               wake_bounds_seconds: {
                 minimum: assignment.minimum_wake_seconds,
@@ -33220,6 +33351,8 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
               }
             }),
             outputSchema: CODEX_AGENT_WAKE_SCHEMA,
+            dataContract: assignment.data_contract,
+            decisionSchema: assignment.output_schema,
             requestedModel: assignment.model_id,
             requestedReasoningEffort: assignment.reasoning_effort,
             deadlineAtMs,
@@ -33232,7 +33365,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
               if (call.tool === "vtx_get_data") {
                 const capability = typeof call.arguments.capability === "string" ? call.arguments.capability.trim() : "";
                 const args = call.arguments.arguments;
-                if (!capability || !args || typeof args !== "object" || Array.isArray(args)) {
+                if (!capability || !assignment.data_contract.some((descriptor) => descriptor.id === capability) || !args || typeof args !== "object" || Array.isArray(args)) {
                   return { success: false, value: { error: "invalid_data_request" } };
                 }
                 const value = await this.options.controlClient.dataCall({
@@ -33368,6 +33501,40 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           await heartbeatTask.catch(() => void 0);
         }
       }
+      async upgradeLegacyRuntimeState(legacyState, signal) {
+        const state = await this.resolveLegacyPendingDecision(legacyState, signal);
+        if (state.pending_decision) return null;
+        if (state.thread) {
+          await this.options.adapter.releaseThread(state.thread).catch(() => void 0);
+        }
+        await clearCodexAgentRuntimeState(this.options.statePath);
+        return null;
+      }
+      async resolveLegacyPendingDecision(state, signal) {
+        const pending = state.pending_decision;
+        if (!pending) return state;
+        const checkedAt = new Date(this.now()).toISOString();
+        const checking = {
+          ...state,
+          pending_decision: { ...pending, last_status_check_at: checkedAt },
+          updated_at: checkedAt
+        };
+        await writeCodexAgentRuntimeState(this.options.statePath, checking);
+        const status = await this.options.controlClient.decisionStatus({
+          host_id: this.options.hostId,
+          assignment_id: state.assignment.assignment_id,
+          assignment_generation: state.assignment.assignment_generation,
+          operation_id: pending.operation_id
+        }, { signal });
+        if (status.status !== "applied" && status.status !== "not_applied") return checking;
+        const resolved = {
+          ...checking,
+          pending_decision: null,
+          updated_at: new Date(this.now()).toISOString()
+        };
+        await writeCodexAgentRuntimeState(this.options.statePath, resolved);
+        return resolved;
+      }
       async resolvePendingDecision(state, signal) {
         const pending = state.pending_decision;
         if (!pending) return state;
@@ -33415,7 +33582,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           if (this.stopped || signal?.aborted) return "stopped";
           if (this.now() >= nextWakeAtMs) return "ready";
           const state = await readCodexAgentRuntimeState(this.options.statePath);
-          if (!state) return "cancelled";
+          if (state?.schema_version !== "vtx_codex_agent_runtime_v2") return "cancelled";
           const requestedAt = new Date(this.now()).toISOString();
           const heartbeat = await this.options.controlClient.heartbeat({
             operation_id: randomUUID(),
@@ -33443,7 +33610,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         let state = await readCodexAgentRuntimeState(this.options.statePath);
         if (!state) return;
         try {
-          state = await this.resolvePendingDecision(state);
+          state = state.schema_version === "vtx_codex_agent_runtime_v1" ? await this.resolveLegacyPendingDecision(state) : await this.resolvePendingDecision(state);
         } catch {
           return;
         }
@@ -38094,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";
@@ -38105,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);
@@ -38329,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({
@@ -38895,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();
@@ -39010,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("::");
     };
@@ -39226,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);
@@ -39256,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)) {
@@ -39684,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,
@@ -39691,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);
@@ -39702,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);
       }
@@ -39780,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 {
@@ -39813,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);
       }
@@ -39843,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);
@@ -39874,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) => {
@@ -51032,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({
@@ -51045,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;
@@ -52745,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"
               );
             }
           }
@@ -52769,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"
               );
             }
           };
@@ -52854,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");
@@ -52886,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);
@@ -52896,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(
@@ -52911,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;
@@ -52934,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;
@@ -52961,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)) {
@@ -52983,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(
@@ -52991,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 {
@@ -53019,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"
       );
     };
   }
@@ -53755,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();
@@ -53840,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;
     };
@@ -53849,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,
@@ -54358,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(
@@ -55835,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,
@@ -55842,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
               } : {}
@@ -58904,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
           }
@@ -59317,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,
@@ -59328,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 } : {}