@vtxmacro/cli 2026.8.51 → 2026.8.53

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.53",
       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"
+    ]);
   }
 });
 
@@ -19654,32 +19695,60 @@ var init_agent_client = __esm({
 });
 
 // lib/inference-host/agent-state.ts
-async function readCodexAgentRuntimeState(statePath) {
+async function readInferenceAgentRuntimeState(statePath) {
   const raw = await readInferencePrivateFile(
-    codexAgentRuntimeStatePath(statePath),
-    "Codex Agent runtime recovery state"
+    inferenceAgentRuntimeStatePath(statePath),
+    "Inference Agent runtime recovery state"
   );
   if (raw === null) return null;
   try {
-    return assertCodexAgentRuntimeState(JSON.parse(raw));
+    return assertInferenceAgentRuntimeState(JSON.parse(raw));
   } catch (error48) {
     if (error48 instanceof SyntaxError) {
-      throw new Error("Codex Agent runtime recovery state is not valid JSON.");
+      throw new Error("Inference Agent runtime recovery state is not valid JSON.");
     }
     throw error48;
   }
 }
-async function writeCodexAgentRuntimeState(statePath, value) {
+async function writeInferenceAgentRuntimeState(statePath, value) {
   await writeAtomicInferencePrivateFile(
-    codexAgentRuntimeStatePath(statePath),
-    `${JSON.stringify(assertCodexAgentRuntimeState(value), null, 2)}
+    inferenceAgentRuntimeStatePath(statePath),
+    `${JSON.stringify(assertInferenceAgentRuntimeState(value), null, 2)}
 `
   );
 }
-async function clearCodexAgentRuntimeState(statePath) {
+async function clearInferenceAgentRuntimeState(statePath) {
   await clearInferencePrivateFile(
-    codexAgentRuntimeStatePath(statePath),
-    "Codex Agent runtime recovery state"
+    inferenceAgentRuntimeStatePath(statePath),
+    "Inference Agent runtime recovery state"
+  );
+}
+async function readInferenceForegroundAgentControlState(statePath) {
+  const raw = await readInferencePrivateFile(
+    foregroundAgentControlStatePath(statePath),
+    "Foreground Agent control recovery state"
+  );
+  if (raw === null) return null;
+  try {
+    return assertForegroundAgentControlState(JSON.parse(raw));
+  } catch (error48) {
+    if (error48 instanceof SyntaxError) {
+      throw new Error("Foreground Agent control recovery state is not valid JSON.");
+    }
+    throw error48;
+  }
+}
+async function writeInferenceForegroundAgentControlState(statePath, value) {
+  await writeAtomicInferencePrivateFile(
+    foregroundAgentControlStatePath(statePath),
+    `${JSON.stringify(assertForegroundAgentControlState(value), null, 2)}
+`
+  );
+}
+async function clearInferenceForegroundAgentControlState(statePath) {
+  await clearInferencePrivateFile(
+    foregroundAgentControlStatePath(statePath),
+    "Foreground Agent control recovery state"
   );
 }
 async function readInferenceAgentAttemptState(statePath) {
@@ -19738,7 +19807,7 @@ async function clearInferenceAgentNextState(statePath) {
     "Agent-driven inference next recovery state"
   );
 }
-var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, codexAgentRuntimeStatePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertCodexAgentRuntimeState, assertNextState, assertAttemptState;
+var inferenceAgentAttemptStatePath, inferenceAgentNextStatePath, inferenceAgentRuntimeStatePath, isIsoTimestamp, assertPlainObject, hasExactKeys, assertInferenceAgentRuntimeState, readCodexAgentRuntimeState, clearCodexAgentRuntimeState, foregroundAgentControlStatePath, assertRuntimeAssignment, assertForegroundAgentControlState, assertNextState, assertAttemptState;
 var init_agent_state = __esm({
   "lib/inference-host/agent-state.ts"() {
     "use strict";
@@ -19746,18 +19815,20 @@ var init_agent_state = __esm({
     init_external_inference_contract();
     inferenceAgentAttemptStatePath = (statePath) => `${statePath}.agent-attempt.json`;
     inferenceAgentNextStatePath = (statePath) => `${statePath}.agent-next.json`;
-    codexAgentRuntimeStatePath = (statePath) => `${statePath}.codex-agent-runtime.json`;
+    inferenceAgentRuntimeStatePath = (statePath) => `${statePath}.codex-agent-runtime.json`;
     isIsoTimestamp = (value) => typeof value === "string" && Number.isFinite(Date.parse(value));
     assertPlainObject = (value, message) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(message);
       return value;
     };
     hasExactKeys = (record2, keys) => Object.keys(record2).sort().join("\0") === [...keys].sort().join("\0");
-    assertCodexAgentRuntimeState = (value) => {
-      const message = "Codex Agent runtime recovery state is invalid.";
+    assertInferenceAgentRuntimeState = (value) => {
+      const message = "Inference Agent runtime recovery state is invalid.";
       const state = assertPlainObject(value, message);
+      const generic = state.schema_version === "vtx_inference_agent_runtime_v3";
       if (!hasExactKeys(state, [
         "schema_version",
+        ...generic ? ["adapter_id"] : [],
         "host_id",
         "assignment",
         "thread",
@@ -19766,9 +19837,13 @@ var init_agent_state = __esm({
         "updated_at"
       ])) throw new Error(message);
       const assignment = assertPlainObject(state.assignment, message);
-      if (!["vtx_codex_agent_runtime_v1", "vtx_codex_agent_runtime_v2"].includes(
+      if (![
+        "vtx_codex_agent_runtime_v1",
+        "vtx_codex_agent_runtime_v2",
+        "vtx_inference_agent_runtime_v3"
+      ].includes(
         String(state.schema_version)
-      ) || typeof state.host_id !== "string" || !state.host_id || !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at) || !hasExactKeys(
+      ) || generic && (typeof state.adapter_id !== "string" || !/^[a-z0-9][a-z0-9._-]{0,63}$/u.test(state.adapter_id)) || typeof state.host_id !== "string" || !state.host_id || !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at) || !hasExactKeys(
         assignment,
         [
           "assignment_id",
@@ -19782,10 +19857,10 @@ var init_agent_state = __esm({
           "minimum_wake_seconds",
           "maximum_wake_seconds",
           "lease_expires_at",
-          ...state.schema_version === "vtx_codex_agent_runtime_v2" ? ["data_contract"] : []
+          ...state.schema_version !== "vtx_codex_agent_runtime_v1" ? ["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 (state.schema_version !== "vtx_codex_agent_runtime_v1") {
         if (!Array.isArray(assignment.data_contract) || assignment.data_contract.length === 0) {
           throw new Error(message);
         }
@@ -19824,6 +19899,76 @@ var init_agent_state = __esm({
       }
       return state;
     };
+    readCodexAgentRuntimeState = readInferenceAgentRuntimeState;
+    clearCodexAgentRuntimeState = clearInferenceAgentRuntimeState;
+    foregroundAgentControlStatePath = (statePath) => `${statePath}.foreground-agent-control.json`;
+    assertRuntimeAssignment = (value, message) => {
+      const assignment = assertPlainObject(value, message);
+      if (!hasExactKeys(assignment, [
+        "assignment_id",
+        "assignment_generation",
+        "model_id",
+        "reasoning_effort",
+        "bot_mode",
+        "execution_mode",
+        "allowed_symbols",
+        "output_schema",
+        "data_contract",
+        "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) || !Array.isArray(assignment.data_contract) || assignment.data_contract.length === 0 || !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);
+      const ids = 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(ids).size !== ids.length) throw new Error(message);
+      return assignment;
+    };
+    assertForegroundAgentControlState = (value) => {
+      const message = "Foreground Agent control recovery state is invalid.";
+      const state = assertPlainObject(value, message);
+      if (!hasExactKeys(state, [
+        "schema_version",
+        "host_id",
+        "assignment",
+        "pending_next",
+        "pending_decision",
+        "next_wake_at",
+        "updated_at"
+      ]) || state.schema_version !== "vtx_foreground_agent_control_v1" || typeof state.host_id !== "string" || !state.host_id || state.next_wake_at !== null && !isIsoTimestamp(state.next_wake_at) || !isIsoTimestamp(state.updated_at)) throw new Error(message);
+      if (state.assignment !== null) assertRuntimeAssignment(state.assignment, message);
+      if (state.pending_next !== null) {
+        const pending = assertPlainObject(state.pending_next, message);
+        if (!hasExactKeys(pending, ["operation_id", "requested_at"]) || typeof pending.operation_id !== "string" || !pending.operation_id || !isIsoTimestamp(pending.requested_at)) throw new Error(message);
+      }
+      if (state.pending_decision !== null) {
+        if (state.assignment === null) throw new Error(message);
+        const pending = assertPlainObject(state.pending_decision, message);
+        if (!hasExactKeys(pending, [
+          "request",
+          "first_transmit_at",
+          "last_status_check_at"
+        ])) throw new Error(message);
+        const request = assertPlainObject(pending.request, message);
+        if (!hasExactKeys(request, [
+          "assignment_id",
+          "assignment_generation",
+          "operation_id",
+          "candidate",
+          "observed_at",
+          "provenance"
+        ]) || request.assignment_id !== state.assignment.assignment_id || request.assignment_generation !== state.assignment.assignment_generation || typeof request.operation_id !== "string" || !request.operation_id || !request.candidate || typeof request.candidate !== "object" || Array.isArray(request.candidate) || !isIsoTimestamp(request.observed_at) || !request.provenance || typeof request.provenance !== "object" || Array.isArray(request.provenance) || pending.first_transmit_at !== null && !isIsoTimestamp(pending.first_transmit_at) || pending.last_status_check_at !== null && !isIsoTimestamp(pending.last_status_check_at)) throw new Error(message);
+      }
+      return state;
+    };
     assertNextState = (value) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error("Agent-driven inference next recovery state is invalid.");
@@ -23978,15 +24123,17 @@ $items = @(Get-CimInstance Win32_Process | Where-Object { $_.Name -in @('node.ex
 });
 
 // lib/inference-host/copilot-adapter.ts
+import { randomUUID } from "node:crypto";
 import { mkdtemp as mkdtemp2, rm as rm4 } from "node:fs/promises";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join5 } from "node:path";
 import {
   CopilotClient,
-  RuntimeConnection
+  RuntimeConnection,
+  defineTool
 } from "@github/copilot-sdk";
-var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, resolveRuntimePackage, copilotRuntimePackageCandidates, resolvePinnedCopilotCliPath, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, CopilotSubscriptionAdapter;
+var COPILOT_SDK_VERSION, MAX_RESULT_BYTES, resolveRuntimePackage, copilotRuntimePackageCandidates, resolvePinnedCopilotCliPath, createPrivateWorkspace, cleanCopilotEnvironment, defaultClient, modelCapabilities, requiredUsageInteger, optionalUsageInteger, copilotAgentToolDefinitions, CopilotSubscriptionAdapter;
 var init_copilot_adapter = __esm({
   "lib/inference-host/copilot-adapter.ts"() {
     "use strict";
@@ -24082,9 +24229,66 @@ var init_copilot_adapter = __esm({
       }
       return Number(value);
     };
+    copilotAgentToolDefinitions = (input, evidence) => {
+      const execute = async (tool, argumentsValue) => {
+        const argumentsRecord = argumentsValue && typeof argumentsValue === "object" && !Array.isArray(argumentsValue) ? argumentsValue : {};
+        const callId = randomUUID();
+        const result2 = await input.executeTool({
+          callId,
+          tool,
+          arguments: argumentsRecord
+        });
+        evidence.push({ callId, tool, arguments: argumentsRecord, success: result2.success });
+        return result2.success ? result2.value : { error: result2.value };
+      };
+      return [
+        defineTool("vtx_get_data", {
+          description: "Request assignment-scoped VTX data using one exact canonical capability schema.",
+          parameters: {
+            oneOf: input.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
+              }
+            }))
+          },
+          skipPermission: true,
+          handler: async (args) => await execute("vtx_get_data", args)
+        }),
+        defineTool("vtx_submit_decision", {
+          description: "Submit one VTX structured trading decision candidate.",
+          parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["candidate"],
+            properties: { candidate: input.decisionSchema }
+          },
+          skipPermission: true,
+          handler: async (args) => await execute("vtx_submit_decision", args)
+        }),
+        defineTool("vtx_decision_status", {
+          description: "Resolve the durable status of a previously attempted decision operation.",
+          parameters: {
+            type: "object",
+            additionalProperties: false,
+            required: ["operation_id"],
+            properties: { operation_id: { type: "string", minLength: 1 } }
+          },
+          skipPermission: true,
+          handler: async (args) => await execute("vtx_decision_status", args)
+        })
+      ];
+    };
     CopilotSubscriptionAdapter = class {
       constructor(dependencies = {}) {
         this.inFlight = /* @__PURE__ */ new Map();
+        this.agentConnection = null;
+        this.agentWorkspaceCleanups = /* @__PURE__ */ new Map();
+        this.closing = false;
         this.dependencies = dependencies;
       }
       async preflight(signal) {
@@ -24296,6 +24500,224 @@ ${input.outputSchemaJson}`
           await workspace.cleanup();
         }
       }
+      async runTurn(input) {
+        if (this.closing) {
+          throw new CodexAppServerError({
+            message: "Copilot Agent adapter is closing.",
+            category: "transport",
+            code: "transport_closed",
+            retryable: true
+          });
+        }
+        input.signal?.throwIfAborted();
+        if (Date.now() >= input.deadlineAtMs || input.dataContract.length === 0) {
+          throw new CodexAppServerError({
+            message: "Copilot Agent turn input is invalid or expired.",
+            category: Date.now() >= input.deadlineAtMs ? "timeout" : "schema",
+            code: Date.now() >= input.deadlineAtMs ? "deadline_exceeded" : "invalid_agent_turn_input",
+            retryable: false
+          });
+        }
+        const startedAt = (this.dependencies.now ?? Date.now)();
+        const ownedWorkspace = input.durableThread ? null : await (this.dependencies.createAgentWorkspace ?? this.dependencies.createWorkspace ?? createPrivateWorkspace)();
+        const workspacePath = input.durableThread?.threadPath ?? ownedWorkspace.path;
+        if (ownedWorkspace) this.agentWorkspaceCleanups.set(workspacePath, ownedWorkspace.cleanup);
+        const client = (this.dependencies.createClient ?? defaultClient)(workspacePath);
+        let session = null;
+        let durableCheckpointed = input.durableThread !== null;
+        let dispatchEntered = false;
+        const toolEvidence = [];
+        try {
+          await client.start();
+          const tools = copilotAgentToolDefinitions(input, toolEvidence);
+          const sessionConfig = {
+            clientName: "@vtxmacro/cli durable Copilot Agent host",
+            model: input.requestedModel,
+            ...input.requestedReasoningEffort === "none" ? {} : { reasoningEffort: input.requestedReasoningEffort },
+            systemMessage: {
+              mode: "replace",
+              content: `${input.systemPrompt}
+
+Return only one JSON value matching this JSON Schema exactly:
+${JSON.stringify(input.outputSchema)}`
+            },
+            tools,
+            availableTools: tools.map((tool) => tool.name),
+            enableConfigDiscovery: false,
+            streaming: true,
+            workingDirectory: workspacePath,
+            infiniteSessions: { enabled: true }
+          };
+          session = input.durableThread ? await client.resumeSession(input.durableThread.threadId, sessionConfig) : await client.createSession(sessionConfig);
+          this.agentConnection = {
+            client,
+            session,
+            workspacePath,
+            cleanup: ownedWorkspace?.cleanup ?? null
+          };
+          const thread = {
+            threadId: session.sessionId,
+            threadPath: workspacePath,
+            effectiveModel: input.requestedModel,
+            effectiveReasoningEffort: input.requestedReasoningEffort
+          };
+          if (input.onThreadReady) {
+            await input.onThreadReady(thread);
+            durableCheckpointed = true;
+          }
+          const usageEvents = [];
+          session.on((event) => {
+            if (event.type === "assistant.usage" && !event.agentId) usageEvents.push(event);
+          });
+          const onAbort = () => {
+            void session?.abort().catch(() => void 0);
+          };
+          input.signal?.addEventListener("abort", onAbort, { once: true });
+          dispatchEntered = true;
+          let response;
+          try {
+            response = await session.sendAndWait(
+              { prompt: input.userPrompt },
+              Math.max(1, input.deadlineAtMs - Date.now())
+            );
+          } finally {
+            input.signal?.removeEventListener("abort", onAbort);
+          }
+          if (!response?.data.content || Buffer.byteLength(response.data.content, "utf8") > MAX_RESULT_BYTES) {
+            throw new Error("copilot_agent_invalid_result");
+          }
+          const observedModels = /* @__PURE__ */ new Set();
+          const observedEfforts = /* @__PURE__ */ new Set();
+          let inputTokens = 0;
+          let cachedInputTokens = 0;
+          let outputTokens = 0;
+          let reasoningOutputTokens = 0;
+          let cacheWriteInputTokens = 0;
+          let cacheWriteSupported = false;
+          let timeToFirstTokenMs = null;
+          let providerCallId = null;
+          for (const event of usageEvents) {
+            if (event.type !== "assistant.usage") continue;
+            observedModels.add(event.data.model);
+            if (event.data.reasoningEffort) observedEfforts.add(event.data.reasoningEffort);
+            inputTokens += requiredUsageInteger(event.data.inputTokens, "input_tokens");
+            cachedInputTokens += optionalUsageInteger(event.data.cacheReadTokens, "cache_read_tokens");
+            outputTokens += requiredUsageInteger(event.data.outputTokens, "output_tokens");
+            reasoningOutputTokens += optionalUsageInteger(event.data.reasoningTokens, "reasoning_tokens");
+            if (event.data.cacheWriteTokens !== void 0) {
+              cacheWriteSupported = true;
+              cacheWriteInputTokens += optionalUsageInteger(event.data.cacheWriteTokens, "cache_write_tokens");
+            }
+            if (timeToFirstTokenMs === null && Number.isSafeInteger(event.data.timeToFirstTokenMs)) {
+              timeToFirstTokenMs = Number(event.data.timeToFirstTokenMs);
+            }
+            providerCallId = event.data.providerCallId ?? event.data.apiCallId ?? providerCallId;
+          }
+          if (usageEvents.length === 0) throw new Error("copilot_agent_usage_receipt_missing");
+          if (response.data.model) observedModels.add(response.data.model);
+          if (observedModels.size !== 1 || !observedModels.has(input.requestedModel)) {
+            throw new Error("copilot_agent_effective_model_mismatch");
+          }
+          const effectiveEffort = input.requestedReasoningEffort === "none" ? observedEfforts.size === 0 ? "none" : observedEfforts.size === 1 ? [...observedEfforts][0] : null : observedEfforts.size === 1 ? [...observedEfforts][0] : null;
+          if (effectiveEffort !== input.requestedReasoningEffort) {
+            throw new Error("copilot_agent_effective_effort_mismatch");
+          }
+          const usage = {
+            inputTokens,
+            cachedInputTokens: Math.min(cachedInputTokens, inputTokens),
+            outputTokens,
+            reasoningOutputTokens: Math.min(reasoningOutputTokens, outputTokens),
+            totalTokens: inputTokens + outputTokens,
+            cacheWriteInputTokens: cacheWriteSupported ? cacheWriteInputTokens : null,
+            cacheWriteSupported
+          };
+          return {
+            thread,
+            turn: {
+              text: response.data.content,
+              reasoningContent: response.data.reasoningText ?? null,
+              reasoningSummary: null,
+              requestedModel: input.requestedModel,
+              effectiveModel: input.requestedModel,
+              requestedReasoningEffort: input.requestedReasoningEffort,
+              effectiveReasoningEffort: effectiveEffort,
+              adapterRequestId: providerCallId ?? response.data.requestId ?? response.data.messageId,
+              adapterResponseId: response.data.serviceRequestId ?? response.data.messageId,
+              usage,
+              latencyMs: Math.max(0, (this.dependencies.now ?? Date.now)() - startedAt),
+              timeToFirstTokenMs,
+              terminalStatus: "completed",
+              toolCalls: toolEvidence,
+              webSearches: []
+            }
+          };
+        } catch (error48) {
+          if (error48 instanceof CodexAppServerError) throw error48;
+          const cancelled = input.signal?.aborted === true;
+          const deadline = Date.now() >= input.deadlineAtMs;
+          if (dispatchEntered) await session?.abort().catch(() => void 0);
+          if (session && !durableCheckpointed) {
+            const abandonedSession = session;
+            session = null;
+            if (this.agentConnection?.session === abandonedSession) this.agentConnection = null;
+            await abandonedSession.disconnect().catch(() => void 0);
+            await client.deleteSession(abandonedSession.sessionId).catch(() => void 0);
+            const cleanup = this.agentWorkspaceCleanups.get(workspacePath);
+            if (cleanup) {
+              await cleanup().catch(() => void 0);
+              this.agentWorkspaceCleanups.delete(workspacePath);
+            }
+          }
+          throw new CodexAppServerError({
+            message: cancelled ? "Copilot Agent turn was cancelled." : deadline ? "Copilot Agent turn exceeded its deadline." : error48 instanceof Error ? error48.message : "Copilot Agent adapter failed.",
+            category: cancelled ? "cancelled" : deadline ? "timeout" : "adapter",
+            code: cancelled ? "cancelled" : deadline ? "deadline_exceeded" : "copilot_agent_adapter_failure",
+            retryable: false,
+            dispatchOutcome: dispatchEntered ? "confirmed_dispatched" : "not_dispatched",
+            cause: error48
+          });
+        } finally {
+          await session?.disconnect().catch(() => void 0);
+          await client.stop().catch(async () => {
+            await client.forceStop();
+          });
+          if (this.agentConnection?.session === session) this.agentConnection = null;
+        }
+      }
+      async releaseThread(thread) {
+        const active = this.agentConnection;
+        if (active?.session.sessionId === thread.threadId) {
+          await active.session.disconnect().catch(() => void 0);
+          await active.client.stop().catch(async () => {
+            await active.client.forceStop();
+          });
+          this.agentConnection = null;
+        }
+        const client = (this.dependencies.createClient ?? defaultClient)(thread.threadPath);
+        await client.start();
+        try {
+          await client.deleteSession(thread.threadId);
+        } finally {
+          await client.stop().catch(async () => {
+            await client.forceStop();
+          });
+        }
+        const cleanup = this.agentWorkspaceCleanups.get(thread.threadPath);
+        if (cleanup) {
+          await cleanup();
+          this.agentWorkspaceCleanups.delete(thread.threadPath);
+        }
+      }
+      async close() {
+        this.closing = true;
+        const active = this.agentConnection;
+        this.agentConnection = null;
+        if (!active) return;
+        await active.session.disconnect().catch(() => void 0);
+        await active.client.stop().catch(async () => {
+          await active.client.forceStop();
+        });
+      }
     };
   }
 });
@@ -30873,7 +31295,7 @@ var require_ajv = __commonJS({
 });
 
 // lib/inference-host/runner.ts
-import { createHash as createHash6, randomUUID } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
 function createDefaultInferenceHostRunnerDependencies(options) {
   const fetchImpl = options.fetchImpl ?? fetch;
   return {
@@ -30908,7 +31330,7 @@ function createDefaultInferenceHostRunnerDependencies(options) {
     envelopePublicKey: options.envelopePublicKey
   };
 }
-var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createCodexAgentControlClient, CODEX_AGENT_SYSTEM_PROMPT, CODEX_AGENT_WAKE_SCHEMA, parseCodexAgentWake, CodexAgentRuntime;
+var import_ajv, RUNTIME_RECEIPT_SCHEMA_VERSION, ATTEMPT_RECEIPT_SCHEMA_VERSION, DEFAULT_ADVERTISEMENT_TTL_MS, DEFAULT_ADVERTISEMENT_REFRESH_LEAD_MS, DEFAULT_HOST_HEARTBEAT_MS, DEFAULT_PROVIDER_RATE_LIMIT_REFRESH_MS, DEFAULT_ATTEMPT_HEARTBEAT_MS, DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_REMOTE_RETRY_LIMIT, MIN_SLEEP_MS, MIN_HOST_HEARTBEAT_GAP_DIAGNOSTIC_MS, HOST_HEARTBEAT_GAP_DIAGNOSTIC_FACTOR, DEFAULT_CODEX_ACCOUNT_COOLDOWN_MS, MIN_CLAIM_START_WINDOW_MS, MAX_ATTEMPT_START_RETRY_DELAY_MS, UNBOUNDED_AVAILABLE_SLOTS, buildInferenceAdvertisedModels, summarizeInferenceHostRuntimeRecovery, FileInferenceHostRuntimeReceiptStore, InferenceHostRecoveryRequiredError, InferenceHostRunnerError, defaultSleep, abortError, settlesWithin, defaultRegisterSignalHandlers, safeInteger, exactObjectKeys, validIso, validateAttemptReceipt, validateRuntimeReceipt, sha256, stableOperationId, buildAttemptStartRequest, isoAt, providerWeeklyQuotaFromRateLimits, finitePositiveOption, validateRunnerOptions, assertLocalCredentialIdentity, retryableRemoteError, remoteRetryAfterMs, controlPlaneFatal, defaultValidateOutput, objectRecord, positiveUtf8ByteLimit, assertCompilableOutputSchema, parseOutputContract, membershipFailureDisposition, safeFailureCode, attemptStartRetryFallbackMs, exactJson2, runnerIdentityMismatch, assertAdvertisementResult, assertHostHeartbeatResult, assertClaimResult, assertStartResult, assertJobHeartbeatResult, assertTerminalResult, classifyFailure, ambiguousHeartbeatTransport, reportedTokenUsage, reportedUsage, InferenceHostRunner, createInferenceAgentControlClient, INFERENCE_AGENT_SYSTEM_PROMPT, INFERENCE_AGENT_WAKE_SCHEMA, parseInferenceAgentWake, InferenceAgentRuntime;
 var init_runner = __esm({
   "lib/inference-host/runner.ts"() {
     "use strict";
@@ -31292,7 +31714,7 @@ var init_runner = __esm({
           adapterId,
           options.structuredOutput ?? adapterId === "codex",
           options.sameAttemptRecovery ?? adapterId === "codex",
-          options.agentRuntime && adapterId === "codex" ? ["provider", "agent"] : ["provider"]
+          options.agentRuntime ? ["provider", "agent"] : ["provider"]
         ),
         maxConcurrency: options.maxConcurrency === null || options.maxConcurrency === void 0 ? null : finitePositiveOption(options.maxConcurrency, 1, "Maximum concurrency"),
         advertisementTtlMs,
@@ -31747,10 +32169,11 @@ var init_runner = __esm({
             const agentRuntimeSettings = settings.agentRuntime;
             agentLoop = (async () => {
               while (!agentAbort.signal.aborted) {
-                const agentRuntime = new CodexAgentRuntime({
+                const agentRuntime = new InferenceAgentRuntime({
+                  adapterId: settings.adapterId,
                   hostId: localState.host_id,
                   statePath: agentRuntimeSettings.statePath,
-                  controlClient: createCodexAgentControlClient(mcp),
+                  controlClient: createInferenceAgentControlClient(mcp),
                   adapter: agentRuntimeSettings.adapter
                 });
                 try {
@@ -33088,7 +33511,7 @@ var init_runner = __esm({
         }
       }
     };
-    createCodexAgentControlClient = (mcp) => ({
+    createInferenceAgentControlClient = (mcp) => ({
       nextAssignment: async (request, options) => {
         const result2 = await mcp.callTool("inference.agent.assignment.next", {
           ...request,
@@ -33131,9 +33554,9 @@ var init_runner = __esm({
         await mcp.callTool("inference.agent.assignment.release", request, options);
       }
     });
-    CODEX_AGENT_SYSTEM_PROMPT = `You autonomously control one running VTX bot.
+    INFERENCE_AGENT_SYSTEM_PROMPT = `You autonomously control one running VTX bot.
 VTX supplies no trading prompt or prepared market context. At your own cadence, request zero, some, or all assignment-scoped data with vtx_get_data and independently use web search when useful. Submit trading instructions only through vtx_submit_decision, using the assignment's exact decision schema. VTX remains responsible for validating and executing the same structured decision used by normal Server and Client modes. You have no shell, filesystem-write, app, plugin, browser-control, or subagent authority.`;
-    CODEX_AGENT_WAKE_SCHEMA = {
+    INFERENCE_AGENT_WAKE_SCHEMA = {
       type: "object",
       additionalProperties: false,
       required: ["next_wake_seconds", "summary"],
@@ -33142,29 +33565,29 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         summary: { type: "string", minLength: 1, maxLength: 2e3 }
       }
     };
-    parseCodexAgentWake = (text, assignment) => {
+    parseInferenceAgentWake = (text, assignment) => {
       let value;
       try {
         value = JSON.parse(text);
       } catch {
         throw new InferenceHostRunnerError(
           "invalid_agent_wake",
-          "Codex Agent returned invalid wake JSON."
+          "Inference Agent returned invalid wake JSON."
         );
       }
       if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new InferenceHostRunnerError("invalid_agent_wake", "Codex Agent wake is invalid.");
+        throw new InferenceHostRunnerError("invalid_agent_wake", "Inference Agent wake is invalid.");
       }
       const seconds = value.next_wake_seconds;
       if (!Number.isSafeInteger(seconds) || Number(seconds) < 1) {
-        throw new InferenceHostRunnerError("invalid_agent_wake", "Codex Agent wake is invalid.");
+        throw new InferenceHostRunnerError("invalid_agent_wake", "Inference Agent wake is invalid.");
       }
       return Math.max(
         assignment.minimum_wake_seconds,
         Math.min(assignment.maximum_wake_seconds, Number(seconds))
       );
     };
-    CodexAgentRuntime = class {
+    InferenceAgentRuntime = class {
       constructor(options) {
         this.options = options;
         this.stopped = false;
@@ -33198,29 +33621,55 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
       }
       async runOnce(signal) {
         const nowIso = () => new Date(this.now()).toISOString();
-        const recoveredState = await readCodexAgentRuntimeState(this.options.statePath);
+        const recoveredState = await readInferenceAgentRuntimeState(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."
+            "Inference Agent recovery state belongs to another host."
           );
         }
         let state;
         if (recoveredState?.schema_version === "vtx_codex_agent_runtime_v1") {
+          if (this.options.adapterId !== "codex") {
+            throw new InferenceHostRunnerError(
+              "agent_recovery_adapter_mismatch",
+              "Legacy Codex Agent recovery state cannot be opened by another adapter."
+            );
+          }
           state = await this.upgradeLegacyRuntimeState(recoveredState, signal);
           if (!state) return this.now() + (this.options.idlePollMs ?? 5e3);
+        } else if (recoveredState?.schema_version === "vtx_codex_agent_runtime_v2") {
+          if (this.options.adapterId !== "codex") {
+            throw new InferenceHostRunnerError(
+              "agent_recovery_adapter_mismatch",
+              "Legacy Codex Agent recovery state cannot be opened by another adapter."
+            );
+          }
+          state = {
+            ...recoveredState,
+            schema_version: "vtx_inference_agent_runtime_v3",
+            adapter_id: "codex"
+          };
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
         } else {
           state = recoveredState ?? null;
+          if (state && state.adapter_id !== this.options.adapterId) {
+            throw new InferenceHostRunnerError(
+              "agent_recovery_adapter_mismatch",
+              "Inference Agent recovery state belongs to another adapter."
+            );
+          }
         }
         if (!state) {
           const assignment2 = await this.options.controlClient.nextAssignment({
-            operation_id: randomUUID(),
+            operation_id: randomUUID2(),
             host_id: this.options.hostId,
             requested_at: nowIso()
           }, { signal });
           if (!assignment2) return this.now() + (this.options.idlePollMs ?? 5e3);
           state = {
-            schema_version: "vtx_codex_agent_runtime_v2",
+            schema_version: "vtx_inference_agent_runtime_v3",
+            adapter_id: this.options.adapterId,
             host_id: this.options.hostId,
             assignment: assignment2,
             thread: null,
@@ -33228,7 +33677,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             pending_decision: null,
             updated_at: nowIso()
           };
-          await writeCodexAgentRuntimeState(this.options.statePath, state);
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
         } else {
           const persistedWakeAtMs = Date.parse(state.next_wake_at);
           if (persistedWakeAtMs > this.now()) {
@@ -33236,8 +33685,8 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             if (wakeOutcome !== "ready") {
               return this.now() + (this.options.idlePollMs ?? 5e3);
             }
-            const rereadState = await readCodexAgentRuntimeState(this.options.statePath);
-            if (rereadState?.schema_version !== "vtx_codex_agent_runtime_v2") {
+            const rereadState = await readInferenceAgentRuntimeState(this.options.statePath);
+            if (rereadState?.schema_version !== "vtx_inference_agent_runtime_v3" || rereadState.adapter_id !== this.options.adapterId) {
               return this.now() + (this.options.idlePollMs ?? 5e3);
             }
             state = rereadState;
@@ -33246,7 +33695,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         state = await this.resolvePendingDecision(state, signal);
         let assignment = state.assignment;
         const preTurnHeartbeat = await this.options.controlClient.heartbeat({
-          operation_id: randomUUID(),
+          operation_id: randomUUID2(),
           host_id: this.options.hostId,
           assignment_id: assignment.assignment_id,
           assignment_generation: assignment.assignment_generation,
@@ -33261,7 +33710,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           lease_expires_at: preTurnHeartbeat.lease_expires_at
         };
         state = { ...state, assignment, updated_at: nowIso() };
-        await writeCodexAgentRuntimeState(this.options.statePath, state);
+        await writeInferenceAgentRuntimeState(this.options.statePath, state);
         const turnAbort = new AbortController();
         const relayAbort = () => turnAbort.abort();
         signal?.addEventListener("abort", relayAbort, { once: true });
@@ -33271,7 +33720,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         const heartbeatTask = (async () => {
           while (!heartbeatStopped && !turnAbort.signal.aborted) {
             const heartbeat = await this.options.controlClient.heartbeat({
-              operation_id: randomUUID(),
+              operation_id: randomUUID2(),
               host_id: this.options.hostId,
               assignment_id: assignment.assignment_id,
               assignment_generation: assignment.assignment_generation,
@@ -33295,7 +33744,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           const deadlineAtMs = this.now() + (this.options.turnTimeoutMs ?? 10 * 6e4);
           const result2 = await this.options.adapter.runTurn({
             durableThread: state.thread,
-            systemPrompt: CODEX_AGENT_SYSTEM_PROMPT,
+            systemPrompt: INFERENCE_AGENT_SYSTEM_PROMPT,
             userPrompt: JSON.stringify({
               assignment_id: assignment.assignment_id,
               assignment_generation: assignment.assignment_generation,
@@ -33309,7 +33758,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                 maximum: assignment.maximum_wake_seconds
               }
             }),
-            outputSchema: CODEX_AGENT_WAKE_SCHEMA,
+            outputSchema: INFERENCE_AGENT_WAKE_SCHEMA,
             dataContract: assignment.data_contract,
             decisionSchema: assignment.output_schema,
             requestedModel: assignment.model_id,
@@ -33318,7 +33767,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             signal: turnAbort.signal,
             onThreadReady: async (thread) => {
               state = { ...state, thread, updated_at: nowIso() };
-              await writeCodexAgentRuntimeState(this.options.statePath, state);
+              await writeInferenceAgentRuntimeState(this.options.statePath, state);
             },
             executeTool: async (call) => {
               if (call.tool === "vtx_get_data") {
@@ -33328,7 +33777,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   return { success: false, value: { error: "invalid_data_request" } };
                 }
                 const value = await this.options.controlClient.dataCall({
-                  operation_id: randomUUID(),
+                  operation_id: randomUUID2(),
                   host_id: this.options.hostId,
                   assignment_id: assignment.assignment_id,
                   assignment_generation: assignment.assignment_generation,
@@ -33352,12 +33801,12 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   return { success: false, value: { error: "decision_outcome_unresolved" } };
                 }
                 const pending = {
-                  operation_id: randomUUID(),
+                  operation_id: randomUUID2(),
                   candidate,
                   observed_at: nowIso(),
                   provenance: {
-                    source: "codex_agent",
-                    codex_thread_id: liveThread.threadId,
+                    source: "external_agent",
+                    agent_run_id: liveThread.threadId,
                     requested_model: assignment.model_id,
                     effective_model: liveThread.effectiveModel,
                     requested_reasoning_effort: assignment.reasoning_effort,
@@ -33367,13 +33816,13 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   last_status_check_at: null
                 };
                 state = { ...state, pending_decision: pending, updated_at: nowIso() };
-                await writeCodexAgentRuntimeState(this.options.statePath, state);
+                await writeInferenceAgentRuntimeState(this.options.statePath, state);
                 state = {
                   ...state,
                   pending_decision: { ...pending, first_transmit_at: nowIso() },
                   updated_at: nowIso()
                 };
-                await writeCodexAgentRuntimeState(this.options.statePath, state);
+                await writeInferenceAgentRuntimeState(this.options.statePath, state);
                 let submitStatus;
                 try {
                   submitStatus = await this.options.controlClient.submitDecision({
@@ -33390,7 +33839,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                 }
                 if (submitStatus.status === "applied" || submitStatus.status === "not_applied") {
                   state = { ...state, pending_decision: null, updated_at: nowIso() };
-                  await writeCodexAgentRuntimeState(this.options.statePath, state);
+                  await writeInferenceAgentRuntimeState(this.options.statePath, state);
                 }
                 return {
                   success: submitStatus.status === "applied",
@@ -33414,7 +33863,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
                   pending_decision: null,
                   updated_at: nowIso()
                 };
-                await writeCodexAgentRuntimeState(this.options.statePath, state);
+                await writeInferenceAgentRuntimeState(this.options.statePath, state);
               }
               return {
                 success: status.status === "applied" || status.status === "not_applied",
@@ -33422,11 +33871,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
               };
             }
           });
-          const wakeSeconds = parseCodexAgentWake(result2.turn.text, assignment);
+          const wakeSeconds = parseInferenceAgentWake(result2.turn.text, assignment);
           const nextWakeAtMs = this.now() + wakeSeconds * 1e3;
           const scheduledWakeAt = new Date(nextWakeAtMs).toISOString();
           const wakeHeartbeat = await this.options.controlClient.heartbeat({
-            operation_id: randomUUID(),
+            operation_id: randomUUID2(),
             host_id: this.options.hostId,
             assignment_id: assignment.assignment_id,
             assignment_generation: assignment.assignment_generation,
@@ -33436,7 +33885,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           if (wakeHeartbeat.directive === "cancel") {
             if (state.pending_decision) return this.now() + (this.options.idlePollMs ?? 5e3);
             await this.options.adapter.releaseThread(result2.thread).catch(() => void 0);
-            await clearCodexAgentRuntimeState(this.options.statePath);
+            await clearInferenceAgentRuntimeState(this.options.statePath);
             return this.now() + (this.options.idlePollMs ?? 5e3);
           }
           latestLeaseExpiry = wakeHeartbeat.lease_expires_at;
@@ -33447,7 +33896,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             next_wake_at: scheduledWakeAt,
             updated_at: nowIso()
           };
-          await writeCodexAgentRuntimeState(this.options.statePath, state);
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
           return nextWakeAtMs;
         } catch (error48) {
           if (!cancelled) throw error48;
@@ -33466,7 +33915,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         if (state.thread) {
           await this.options.adapter.releaseThread(state.thread).catch(() => void 0);
         }
-        await clearCodexAgentRuntimeState(this.options.statePath);
+        await clearInferenceAgentRuntimeState(this.options.statePath);
         return null;
       }
       async resolveLegacyPendingDecision(state, signal) {
@@ -33478,7 +33927,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: { ...pending, last_status_check_at: checkedAt },
           updated_at: checkedAt
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, checking);
+        await writeInferenceAgentRuntimeState(this.options.statePath, checking);
         const status = await this.options.controlClient.decisionStatus({
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
@@ -33491,7 +33940,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: null,
           updated_at: new Date(this.now()).toISOString()
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, resolved);
+        await writeInferenceAgentRuntimeState(this.options.statePath, resolved);
         return resolved;
       }
       async resolvePendingDecision(state, signal) {
@@ -33503,7 +33952,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: { ...pending, last_status_check_at: checkedAt },
           updated_at: checkedAt
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, checking);
+        await writeInferenceAgentRuntimeState(this.options.statePath, checking);
         const status = await this.options.controlClient.decisionStatus({
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
@@ -33516,7 +33965,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           pending_decision: null,
           updated_at: new Date(this.now()).toISOString()
         };
-        await writeCodexAgentRuntimeState(this.options.statePath, resolved);
+        await writeInferenceAgentRuntimeState(this.options.statePath, resolved);
         return resolved;
       }
       async handleCancelledAssignment(state, signal) {
@@ -33532,7 +33981,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         if (current.thread) {
           await this.options.adapter.releaseThread(current.thread).catch(() => void 0);
         }
-        await clearCodexAgentRuntimeState(this.options.statePath);
+        await clearInferenceAgentRuntimeState(this.options.statePath);
       }
       async waitUntilWake(nextWakeAtMs, signal) {
         const heartbeatIntervalMs = this.options.heartbeatIntervalMs ?? 3e3;
@@ -33540,11 +33989,11 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           await this.sleep(Math.min(heartbeatIntervalMs, nextWakeAtMs - this.now()), signal);
           if (this.stopped || signal?.aborted) return "stopped";
           if (this.now() >= nextWakeAtMs) return "ready";
-          const state = await readCodexAgentRuntimeState(this.options.statePath);
-          if (state?.schema_version !== "vtx_codex_agent_runtime_v2") return "cancelled";
+          const state = await readInferenceAgentRuntimeState(this.options.statePath);
+          if (state?.schema_version !== "vtx_inference_agent_runtime_v3" || state.adapter_id !== this.options.adapterId) return "cancelled";
           const requestedAt = new Date(this.now()).toISOString();
           const heartbeat = await this.options.controlClient.heartbeat({
-            operation_id: randomUUID(),
+            operation_id: randomUUID2(),
             host_id: this.options.hostId,
             assignment_id: state.assignment.assignment_id,
             assignment_generation: state.assignment.assignment_generation,
@@ -33554,7 +34003,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
             await this.handleCancelledAssignment(state, signal);
             return "cancelled";
           }
-          await writeCodexAgentRuntimeState(this.options.statePath, {
+          await writeInferenceAgentRuntimeState(this.options.statePath, {
             ...state,
             assignment: {
               ...state.assignment,
@@ -33566,8 +34015,24 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         return this.stopped || signal?.aborted ? "stopped" : "ready";
       }
       async releaseForHostStop() {
-        let state = await readCodexAgentRuntimeState(this.options.statePath);
-        if (!state) return;
+        const recovered = await readInferenceAgentRuntimeState(this.options.statePath);
+        if (!recovered) return;
+        let state;
+        if (recovered.schema_version === "vtx_codex_agent_runtime_v1") {
+          if (this.options.adapterId !== "codex") return;
+          state = recovered;
+        } else if (recovered.schema_version === "vtx_codex_agent_runtime_v2") {
+          if (this.options.adapterId !== "codex") return;
+          state = {
+            ...recovered,
+            schema_version: "vtx_inference_agent_runtime_v3",
+            adapter_id: "codex"
+          };
+          await writeInferenceAgentRuntimeState(this.options.statePath, state);
+        } else {
+          if (recovered.adapter_id !== this.options.adapterId) return;
+          state = recovered;
+        }
         try {
           state = state.schema_version === "vtx_codex_agent_runtime_v1" ? await this.resolveLegacyPendingDecision(state) : await this.resolvePendingDecision(state);
         } catch {
@@ -33575,7 +34040,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
         }
         if (state.pending_decision) return;
         await this.options.controlClient.releaseAssignment({
-          operation_id: randomUUID(),
+          operation_id: randomUUID2(),
           host_id: this.options.hostId,
           assignment_id: state.assignment.assignment_id,
           assignment_generation: state.assignment.assignment_generation,
@@ -33583,7 +34048,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
           requested_at: new Date(this.now()).toISOString()
         }, {});
         if (state.thread) await this.options.adapter.releaseThread(state.thread);
-        await clearCodexAgentRuntimeState(this.options.statePath);
+        await clearInferenceAgentRuntimeState(this.options.statePath);
       }
     };
   }
@@ -33591,7 +34056,7 @@ VTX supplies no trading prompt or prepared market context. At your own cadence,
 
 // lib/inference-host/service.ts
 import { spawn as spawn6 } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { createWriteStream, readFileSync } from "node:fs";
 import { access as access3, chmod as chmod3, mkdir as mkdir3, readFile as readFile5, rm as rm5, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
@@ -34116,7 +34581,7 @@ WantedBy=default.target
         const previousRuntimeUpdatedAt = previousRuntime?.manifest_generation === manifest.generation ? Date.parse(previousRuntime.updated_at) : Number.NaN;
         const restoredManifest = preserveGeneration ? manifest : assertManifest({
           ...manifest,
-          generation: randomUUID2(),
+          generation: randomUUID3(),
           installed_at: this.now().toISOString()
         });
         await writeAtomicInferencePrivateFile(
@@ -34402,7 +34867,7 @@ ${cleanup.stderr}`)) {
         ].sort((left, right) => left.instance_name.localeCompare(right.instance_name));
         const manifest = assertManifest({
           schema_version: "vtx_inference_service_v3",
-          generation: randomUUID2(),
+          generation: randomUUID3(),
           installed_at: this.now().toISOString(),
           executable: this.executable,
           script: this.script,
@@ -34616,7 +35081,7 @@ ${result2.stderr}`)) {
           if (remaining.length === 0) return await this.uninstallUnlocked();
           return await this.replaceManifestUnlocked({
             ...manifest,
-            generation: randomUUID2(),
+            generation: randomUUID3(),
             installed_at: this.now().toISOString(),
             workers: remaining
           }, await readInferenceHostServiceDesired(this.desiredPath()));
@@ -35006,7 +35471,7 @@ __export(cli_exports, {
   registerInferenceHostServiceControlInput: () => registerInferenceHostServiceControlInput,
   runInferenceHostCli: () => runInferenceHostCli
 });
-import { createHash as createHash7, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash7, randomUUID as randomUUID4 } from "node:crypto";
 import { spawn as spawn7 } from "node:child_process";
 import { lstat as lstat4, realpath as realpath4, rm as rm6 } from "node:fs/promises";
 import { hostname as osHostname } from "node:os";
@@ -35070,6 +35535,42 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
         async () => await agentFail(config2, parsed, dependencies, warnings)
       );
     }
+    if (parsed.command === "agent-assignment-next") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundAssignmentNext(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-assignment-heartbeat") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundAssignmentHeartbeat(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-data-call") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundDataCall(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-decision-submit") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundDecisionSubmit(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-decision-status") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundDecisionStatus(config2, parsed, dependencies, warnings)
+      );
+    }
+    if (parsed.command === "agent-assignment-release") {
+      return await withAgentCommandLock(
+        config2,
+        async () => await foregroundAssignmentRelease(config2, parsed, dependencies, warnings)
+      );
+    }
     if (parsed.command === "service") {
       const mutationActions = /* @__PURE__ */ new Set(["install", "start", "stop", "recover", "uninstall"]);
       if (!parsed.serviceAction || !mutationActions.has(parsed.serviceAction)) {
@@ -35100,7 +35601,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
       return await cleanupLogin(config2, parsed, dependencies, warnings, true);
     }
     throw new Error(
-      "Usage: vtx inference-host <login|codex-login|run|agent-connect|agent-run|agent-next|agent-complete|agent-fail|service|status|doctor|logout|codex-logout|revoke> [--json]"
+      "Usage: vtx inference-host <login|codex-login|run|agent-connect|agent-run|agent-next|agent-complete|agent-fail|agent-assignment-next|agent-assignment-heartbeat|agent-data-call|agent-decision-submit|agent-decision-status|agent-assignment-release|service|status|doctor|logout|codex-logout|revoke> [--json]"
     );
   } catch (error48) {
     return {
@@ -35111,7 +35612,7 @@ async function runInferenceHostCli(argv2, env = process.env, dependencies = {})
     };
   }
 }
-var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, credentialLifecycleLockPath, serviceRecoveryCommandLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, resolveDurableServiceDisplayName, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, preparePortableDurableAdapter, defaultRunPortableDurableAdapter, login, codexLogin, codexLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, agentOperationId, agentSession, agentConnect, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, recoveryBackupPath, serviceRecoveryTransactionPath, readServiceRecoveryTransaction, assertResumableCodexRecoveryEvidence, recoverInstalledCodexService, serviceCommand, hasExplicitCredentialStoreConfiguration, credentialEnvironmentForIdentity, commandRequiresRetainedCredentialStore, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
+var INFERENCE_HOST_CLI_VERSION, runtimeReceiptPath, codexRecoveryPath, codexGuardianReceiptRoot, revocationCheckpointPath, foregroundHostLockPath, credentialLifecycleLockPath, serviceRecoveryCommandLockPath, AGENT_HEARTBEAT_INTERVAL_MS, AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS, retryableAgentHeartbeatError, assertRevocationCheckpoint, readRevocationCheckpoint, writeRevocationCheckpoint, clearRevocationCheckpoint, render, INFERENCE_HOST_HELP, parseHostConcurrency, parseInferenceHostArgs, resolveDurableServiceDisplayName, defaultOpenBrowser, registerInferenceHostServiceControlInput, defaultRegisterLifecycleSignalHandlers, lifecycleCancellation, configuredCredentialStore, restoreInferenceHostCredentialContext, recoverInferenceHostCredentialContextTransition, accountKeyForState, assertCredentialMatchesState2, revocationCheckpointForCredential, assertRevocationCheckpointMatchesLocalIdentity, fileExistsPrivately, inspectCodexAuthentication, clearLocalRuntimeArtifacts, assertDurableServiceUninstalled, assertLocalRuntimeArtifactsMayBeDiscarded, defaultRunForeground, preparePortableDurableAdapter, defaultRunPortableDurableAdapter, login, codexLogin, codexLogout, localStatus, doctor, cleanupLogin, runHost, defaultReadStdin, parseAgentStdin, parseOptionalAgentStdin, agentOperationId, agentSession, agentConnect, foregroundAgentControlState, requireForegroundAgentState, assignmentFromClaim, foregroundAssignmentNext, foregroundAssignmentHeartbeat, foregroundDataCall, foregroundDecisionStatusRequest, foregroundAssignmentLeaseEnded, handleForegroundCancelledAssignment, foregroundDecisionStatus, foregroundDecisionSubmit, foregroundAssignmentRelease, agentRun, agentNext, agentComplete, agentFail, withAgentCommandLock, recoveryBackupPath, serviceRecoveryTransactionPath, readServiceRecoveryTransaction, assertResumableCodexRecoveryEvidence, recoverInstalledCodexService, serviceCommand, hasExplicitCredentialStoreConfiguration, credentialEnvironmentForIdentity, commandRequiresRetainedCredentialStore, commandUsesInstalledServiceCredentials, resolveInferenceHostCommandConfig;
 var init_cli = __esm({
   "lib/inference-host/cli.ts"() {
     "use strict";
@@ -35211,6 +35712,12 @@ Commands:
   agent-next      Claim the next exact VTX inference request
   agent-complete  Submit one completed agent result from stdin
   agent-fail      Submit one truthful agent failure from stdin
+  agent-assignment-next       Claim the assigned Main bot for Agent control
+  agent-assignment-heartbeat  Renew the current Agent assignment
+  agent-data-call             Request allowed assignment-scoped VTX data
+  agent-decision-submit       Submit the normal structured trading decision
+  agent-decision-status       Resolve an uncertain Agent decision submission
+  agent-assignment-release    Release the current Agent assignment
   service         Install and control the durable background host
   status          Inspect local host and credential state
   doctor          Verify credentials, provider runtime, and private state
@@ -35525,6 +36032,7 @@ Durable service:
       );
       await clearInferenceAgentAttemptState(config2.statePath);
       await clearInferenceAgentNextState(config2.statePath);
+      await clearInferenceForegroundAgentControlState(config2.statePath);
       await clearCodexAgentRuntimeState(config2.statePath);
       await clearInferenceHostLocalState(config2.statePath);
     };
@@ -35552,10 +36060,11 @@ Durable service:
       const revocationCheckpointPresent = await readRevocationCheckpoint(config2) !== null;
       const agentAttemptPresent = await readInferenceAgentAttemptState(config2.statePath) !== null;
       const agentNextRecoveryPresent = await readInferenceAgentNextState(config2.statePath) !== null;
+      const foregroundAgentControlPresent = await readInferenceForegroundAgentControlState(config2.statePath) !== null;
       const codexAgentRuntimePresent = await readCodexAgentRuntimeState(config2.statePath) !== null;
-      if (pendingAttempts > 0 || codexRecoveryPresent || serviceRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent || codexAgentRuntimePresent) {
+      if (pendingAttempts > 0 || codexRecoveryPresent || serviceRecoveryPresent || revocationCheckpointPresent || agentAttemptPresent || agentNextRecoveryPresent || foregroundAgentControlPresent || codexAgentRuntimePresent) {
         throw new Error(
-          "Inference host logout refused because attempt recovery is still pending (Codex, agent-driven, or revocation recovery). Rerun agent-next, complete or fail the active attempt, run the automated host to reconcile it, or resume revoke."
+          "Inference host logout refused because attempt recovery is still pending (Codex, Provider, Agent-control, or revocation recovery). Reconcile or release the exact active operation before retrying logout, or resume revoke."
         );
       }
     };
@@ -35628,6 +36137,12 @@ Durable service:
       return { adapter, preflight: await adapter.preflight(signal) };
     };
     defaultRunPortableDurableAdapter = async (options) => {
+      const agentAdapter = options.adapter;
+      if (typeof agentAdapter.runTurn !== "function" || typeof agentAdapter.releaseThread !== "function" || typeof agentAdapter.close !== "function") {
+        throw new Error(
+          `${options.preflight.adapterId} does not implement the durable Agent-control contract.`
+        );
+      }
       const dependencies = createDefaultInferenceHostRunnerDependencies({
         apiUrl: options.config.apiUrl,
         statePath: options.config.statePath,
@@ -35663,6 +36178,10 @@ Durable service:
         maxConcurrency: options.maxConcurrency,
         once: options.once,
         emitDiagnosticEvent: options.emitDiagnosticEvent,
+        agentRuntime: {
+          statePath: options.config.statePath,
+          adapter: agentAdapter
+        },
         signal: options.signal
       }).run();
     };
@@ -35696,7 +36215,7 @@ Durable service:
         await writeInferenceHostCredentialContextTransition(config2, previousCredentialContext);
         await writeInferenceHostCredentialContext(config2);
         const keyPair = generateExternalInferenceEnvelopeKeyPair();
-        const hostId = randomUUID3();
+        const hostId = randomUUID4();
         const beginLogin = dependencies.beginLogin ?? beginInferenceOAuthLogin;
         const loginStore = {
           kind: store.kind,
@@ -36376,7 +36895,27 @@ Waiting for approval...
       }
       return record2;
     };
-    agentOperationId = (kind) => `${kind}-${randomUUID3()}`;
+    parseOptionalAgentStdin = async (dependencies, allowedKeys) => {
+      if (!dependencies.readStdin && process.stdin.isTTY) return {};
+      const raw = await (dependencies.readStdin ?? defaultReadStdin)();
+      if (!raw.trim()) return {};
+      let value;
+      try {
+        value = JSON.parse(raw);
+      } catch {
+        throw new Error("Agent-driven inference stdin must be one JSON object.");
+      }
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Agent-driven inference stdin must be one JSON object.");
+      }
+      const record2 = value;
+      const unexpected = Object.keys(record2).filter((key) => !allowedKeys.includes(key));
+      if (unexpected.length > 0) {
+        throw new Error(`Unsupported agent-driven inference fields: ${unexpected.join(", ")}.`);
+      }
+      return record2;
+    };
+    agentOperationId = (kind) => `${kind}-${randomUUID4()}`;
     agentSession = async (config2, dependencies, warnings, signal) => {
       if (await readRevocationCheckpoint(config2)) {
         throw new Error("Inference host revocation recovery must finish first.");
@@ -36420,11 +36959,419 @@ Waiting for approval...
           reasoning_effort: result2.reasoning_effort,
           lanes: ["main", "review", "screener"],
           response_modes: ["provider_response", "decision_candidate"],
+          control_modes: ["provider", "agent"],
           execution_modes: ["client", "server"],
           next_command: "vtx inference-host agent-next --wait-seconds 50 --json",
+          agent_next_command: "vtx inference-host agent-assignment-next --wait-seconds 50 --json",
           keeper_command: "vtx inference-host agent-run"
         }, parsed.json),
         stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundAgentControlState = (hostId, updatedAt) => ({
+      schema_version: "vtx_foreground_agent_control_v1",
+      host_id: hostId,
+      assignment: null,
+      pending_next: null,
+      pending_decision: null,
+      next_wake_at: null,
+      updated_at: updatedAt
+    });
+    requireForegroundAgentState = async (config2, hostId) => {
+      const state = await readInferenceForegroundAgentControlState(config2.statePath);
+      if (!state?.assignment) {
+        throw new Error("No active foreground Agent assignment. Run agent-assignment-next first.");
+      }
+      if (state.host_id !== hostId) {
+        throw new Error("Foreground Agent assignment belongs to another inference host.");
+      }
+      return state;
+    };
+    assignmentFromClaim = (result2) => ({
+      assignment_id: result2.assignment_id,
+      assignment_generation: result2.assignment_generation,
+      model_id: result2.model_id,
+      reasoning_effort: result2.reasoning_effort,
+      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,
+      lease_expires_at: result2.lease_expires_at
+    });
+    foregroundAssignmentNext = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+      const sleep4 = dependencies.sleep ?? (async (milliseconds) => {
+        await new Promise((resolve6) => setTimeout(resolve6, milliseconds));
+      });
+      const stopAt = now().getTime() + parsed.waitSeconds * 1e3;
+      let state = await readInferenceForegroundAgentControlState(config2.statePath) ?? foregroundAgentControlState(session.localState.host_id, now().toISOString());
+      if (state.host_id !== session.localState.host_id) {
+        throw new Error("Foreground Agent recovery state belongs to another inference host.");
+      }
+      if (state.pending_decision) {
+        throw new Error("Resolve the pending Agent decision before claiming another assignment.");
+      }
+      while (true) {
+        if (!state.pending_next) {
+          const requestedAt = now().toISOString();
+          state = {
+            ...state,
+            pending_next: {
+              operation_id: agentOperationId("agent-assignment-next"),
+              requested_at: requestedAt
+            },
+            updated_at: requestedAt
+          };
+          await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        }
+        const pending = state.pending_next;
+        let result2;
+        try {
+          result2 = await session.client.callTool("inference.agent.assignment.next", {
+            operation_id: pending.operation_id,
+            host_id: session.localState.host_id,
+            requested_at: pending.requested_at,
+            contract_version: "agent_assignment_v2",
+            ...state.assignment ? {
+              assignment_id: state.assignment.assignment_id,
+              assignment_generation: state.assignment.assignment_generation
+            } : {}
+          });
+        } catch (error48) {
+          if (error48 && typeof error48 === "object" && error48.definitivelyNotApplied === true) {
+            state = { ...state, pending_next: null, updated_at: now().toISOString() };
+            await writeInferenceForegroundAgentControlState(config2.statePath, state);
+          }
+          throw error48;
+        }
+        if (result2.claim_state === "claimed") {
+          const assignment = assignmentFromClaim(result2);
+          state = {
+            ...state,
+            assignment,
+            pending_next: null,
+            next_wake_at: null,
+            updated_at: now().toISOString()
+          };
+          await writeInferenceForegroundAgentControlState(config2.statePath, state);
+          return {
+            exitCode: 0,
+            stdout: render({
+              ...result2,
+              instructions: "VTX supplied no trading prompt or prepared context. Choose your own cadence; use agent-data-call zero or more times, submit the exact output_schema through agent-decision-submit, then record the next wake with agent-assignment-heartbeat. Keep agent-run open for liveness.",
+              data_command: "vtx inference-host agent-data-call --json",
+              decision_command: "vtx inference-host agent-decision-submit --json",
+              decision_input: {
+                candidate: "<object matching output_schema>",
+                provenance: {
+                  source: "external_agent",
+                  agent_run_id: "<stable harness run id>",
+                  requested_model: result2.model_id,
+                  effective_model: "<actual model used>",
+                  requested_reasoning_effort: result2.reasoning_effort,
+                  effective_reasoning_effort: "<actual reasoning effort used>"
+                }
+              },
+              heartbeat_command: "vtx inference-host agent-assignment-heartbeat --json",
+              release_command: "vtx inference-host agent-assignment-release --json"
+            }, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
+        state = { ...state, pending_next: null, updated_at: now().toISOString() };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        const remaining = stopAt - now().getTime();
+        if (remaining <= 0 || parsed.waitSeconds === 0) {
+          return {
+            exitCode: 0,
+            stdout: render(result2, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
+        await sleep4(Math.min(remaining, Math.max(50, result2.retry_after_ms)));
+      }
+    };
+    foregroundAssignmentHeartbeat = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const state = await requireForegroundAgentState(
+        config2,
+        session.localState.host_id
+      );
+      const input = await parseOptionalAgentStdin(dependencies, ["next_wake_at"]);
+      const nextWakeAt = input.next_wake_at;
+      if (nextWakeAt !== void 0 && (typeof nextWakeAt !== "string" || !Number.isFinite(Date.parse(nextWakeAt)))) {
+        throw new Error("next_wake_at must be an ISO timestamp.");
+      }
+      const requestedAt = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+      const result2 = await session.client.callTool("inference.agent.assignment.heartbeat", {
+        operation_id: agentOperationId("agent-assignment-heartbeat"),
+        host_id: session.localState.host_id,
+        assignment_id: state.assignment.assignment_id,
+        assignment_generation: state.assignment.assignment_generation,
+        requested_at: requestedAt,
+        ...nextWakeAt === void 0 ? {} : { next_wake_at: nextWakeAt }
+      });
+      if (result2.directive === "cancel") {
+        await handleForegroundCancelledAssignment(config2, session, state, requestedAt);
+      } else {
+        await writeInferenceForegroundAgentControlState(config2.statePath, {
+          ...state,
+          assignment: { ...state.assignment, lease_expires_at: result2.lease_expires_at },
+          next_wake_at: result2.next_wake_at ?? state.next_wake_at,
+          updated_at: requestedAt
+        });
+      }
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundDataCall = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const state = await requireForegroundAgentState(config2, session.localState.host_id);
+      const input = await parseAgentStdin(dependencies, ["capability", "arguments"]);
+      const capability = typeof input.capability === "string" ? input.capability.trim() : "";
+      if (!capability || !state.assignment.data_contract.some((item) => item.id === capability)) {
+        throw new Error("Agent data capability is not allowed by the current assignment.");
+      }
+      if (!input.arguments || typeof input.arguments !== "object" || Array.isArray(input.arguments)) {
+        throw new Error("Agent data arguments must be one JSON object.");
+      }
+      const result2 = await session.client.callTool("inference.agent.data.call", {
+        operation_id: agentOperationId("agent-data-call"),
+        host_id: session.localState.host_id,
+        assignment_id: state.assignment.assignment_id,
+        assignment_generation: state.assignment.assignment_generation,
+        capability,
+        arguments: input.arguments,
+        requested_at: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+      });
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundDecisionStatusRequest = (hostId, state) => ({
+      operation_id: state.pending_decision.request.operation_id,
+      host_id: hostId,
+      assignment_id: state.assignment.assignment_id,
+      assignment_generation: state.assignment.assignment_generation
+    });
+    foregroundAssignmentLeaseEnded = (state, now) => Boolean(state.assignment) && Date.parse(state.assignment.lease_expires_at) <= now.getTime();
+    handleForegroundCancelledAssignment = async (config2, session, state, requestedAt, signal) => {
+      if (!state.pending_decision) {
+        await clearInferenceForegroundAgentControlState(config2.statePath);
+        return;
+      }
+      const cancelledState = {
+        ...state,
+        assignment: {
+          ...state.assignment,
+          lease_expires_at: requestedAt
+        },
+        pending_decision: {
+          ...state.pending_decision,
+          last_status_check_at: requestedAt
+        },
+        next_wake_at: null,
+        updated_at: requestedAt
+      };
+      await writeInferenceForegroundAgentControlState(config2.statePath, cancelledState);
+      try {
+        await session.client.callTool(
+          "inference.agent.decision.status",
+          foregroundDecisionStatusRequest(session.localState.host_id, cancelledState),
+          { signal }
+        );
+      } catch {
+        return;
+      }
+      await clearInferenceForegroundAgentControlState(config2.statePath);
+    };
+    foregroundDecisionStatus = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      let state = await requireForegroundAgentState(config2, session.localState.host_id);
+      if (!state.pending_decision) {
+        throw new Error("No uncertain foreground Agent decision requires status recovery.");
+      }
+      const checkedAt = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+      state = {
+        ...state,
+        pending_decision: { ...state.pending_decision, last_status_check_at: checkedAt },
+        updated_at: checkedAt
+      };
+      await writeInferenceForegroundAgentControlState(config2.statePath, state);
+      const result2 = await session.client.callTool(
+        "inference.agent.decision.status",
+        foregroundDecisionStatusRequest(session.localState.host_id, state)
+      );
+      const assignmentLeaseEnded = foregroundAssignmentLeaseEnded(state, new Date(checkedAt));
+      if (result2.found || assignmentLeaseEnded) {
+        if (assignmentLeaseEnded) {
+          await clearInferenceForegroundAgentControlState(config2.statePath);
+        } else {
+          await writeInferenceForegroundAgentControlState(config2.statePath, {
+            ...state,
+            pending_decision: null,
+            updated_at: checkedAt
+          });
+        }
+      }
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+      };
+    };
+    foregroundDecisionSubmit = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
+      let state = await requireForegroundAgentState(config2, session.localState.host_id);
+      if (!state.pending_decision) {
+        const input = await parseAgentStdin(dependencies, ["candidate", "provenance"]);
+        if (!input.candidate || typeof input.candidate !== "object" || Array.isArray(input.candidate)) {
+          throw new Error("Agent decision candidate must be one JSON object.");
+        }
+        if (!input.provenance || typeof input.provenance !== "object" || Array.isArray(input.provenance)) {
+          throw new Error("Agent decision provenance must be one JSON object.");
+        }
+        const observedAt = now().toISOString();
+        state = {
+          ...state,
+          pending_decision: {
+            request: {
+              assignment_id: state.assignment.assignment_id,
+              assignment_generation: state.assignment.assignment_generation,
+              operation_id: agentOperationId("agent-decision-submit"),
+              candidate: input.candidate,
+              observed_at: observedAt,
+              provenance: input.provenance
+            },
+            first_transmit_at: null,
+            last_status_check_at: null
+          },
+          updated_at: observedAt
+        };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+      } else {
+        const checkedAt = now().toISOString();
+        state = {
+          ...state,
+          pending_decision: { ...state.pending_decision, last_status_check_at: checkedAt },
+          updated_at: checkedAt
+        };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        const status = await session.client.callTool(
+          "inference.agent.decision.status",
+          foregroundDecisionStatusRequest(session.localState.host_id, state)
+        );
+        if (status.found) {
+          await writeInferenceForegroundAgentControlState(config2.statePath, {
+            ...state,
+            pending_decision: null,
+            updated_at: checkedAt
+          });
+          return {
+            exitCode: 0,
+            stdout: render({ ...status, recovered: true }, parsed.json),
+            stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+          };
+        }
+      }
+      const transmittedAt = now().toISOString();
+      state = {
+        ...state,
+        pending_decision: {
+          ...state.pending_decision,
+          first_transmit_at: state.pending_decision.first_transmit_at ?? transmittedAt
+        },
+        updated_at: transmittedAt
+      };
+      await writeInferenceForegroundAgentControlState(config2.statePath, state);
+      try {
+        const result2 = await session.client.callTool(
+          "inference.agent.decision.submit",
+          state.pending_decision.request
+        );
+        await writeInferenceForegroundAgentControlState(config2.statePath, {
+          ...state,
+          pending_decision: null,
+          updated_at: now().toISOString()
+        });
+        return {
+          exitCode: 0,
+          stdout: render(result2, parsed.json),
+          stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+        };
+      } catch (error48) {
+        const checkedAt = now().toISOString();
+        state = {
+          ...state,
+          pending_decision: { ...state.pending_decision, last_status_check_at: checkedAt },
+          updated_at: checkedAt
+        };
+        await writeInferenceForegroundAgentControlState(config2.statePath, state);
+        try {
+          const status = await session.client.callTool(
+            "inference.agent.decision.status",
+            foregroundDecisionStatusRequest(session.localState.host_id, state)
+          );
+          if (status.found) {
+            await writeInferenceForegroundAgentControlState(config2.statePath, {
+              ...state,
+              pending_decision: null,
+              updated_at: checkedAt
+            });
+            return {
+              exitCode: 0,
+              stdout: render({ ...status, recovered: true }, parsed.json),
+              stderr: warnings.length > 0 ? `${warnings.join("\n")}
+` : ""
+            };
+          }
+        } catch {
+        }
+        throw error48;
+      }
+    };
+    foregroundAssignmentRelease = async (config2, parsed, dependencies, warnings) => {
+      const session = await agentSession(config2, dependencies, warnings);
+      const state = await requireForegroundAgentState(config2, session.localState.host_id);
+      if (state.pending_decision) {
+        throw new Error("Resolve the pending Agent decision before releasing its assignment.");
+      }
+      const input = await parseOptionalAgentStdin(dependencies, ["reason_code"]);
+      const reasonCode = input.reason_code === void 0 ? "agent_released" : input.reason_code;
+      if (typeof reasonCode !== "string" || !/^[a-z0-9][a-z0-9._-]{0,95}$/u.test(reasonCode)) {
+        throw new Error("reason_code must be a safe lowercase code.");
+      }
+      const result2 = await session.client.callTool("inference.agent.assignment.release", {
+        operation_id: agentOperationId("agent-assignment-release"),
+        host_id: session.localState.host_id,
+        assignment_id: state.assignment.assignment_id,
+        assignment_generation: state.assignment.assignment_generation,
+        reason_code: reasonCode,
+        requested_at: (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString()
+      });
+      await clearInferenceForegroundAgentControlState(config2.statePath);
+      return {
+        exitCode: 0,
+        stdout: render(result2, parsed.json),
+        stderr: warnings.length > 0 ? `${warnings.join("\n")}
 ` : ""
       };
     };
@@ -36432,6 +37379,7 @@ Waiting for approval...
       const cancellation = lifecycleCancellation(dependencies);
       let keeperLock = null;
       let heartbeatCount = 0;
+      let assignmentHeartbeatCount = 0;
       try {
         keeperLock = await acquireInferenceHostProcessLock(foregroundHostLockPath(config2));
         const store = configuredCredentialStore(config2, dependencies, (message) => {
@@ -36465,6 +37413,7 @@ Waiting for approval...
           }
           if (commandLock) {
             let heartbeatSuppressed = false;
+            let assignmentHeartbeatComplete = true;
             try {
               const active = await readInferenceAgentAttemptState(config2.statePath);
               const pendingNext = await readInferenceAgentNextState(config2.statePath);
@@ -36524,10 +37473,65 @@ Waiting for approval...
                   }
                 }
               }
+              const control = await readInferenceForegroundAgentControlState(config2.statePath);
+              if (control && control.host_id !== session.localState.host_id) {
+                throw new Error("Foreground Agent control state belongs to another inference host.");
+              }
+              if (control?.assignment) {
+                assignmentHeartbeatComplete = false;
+                try {
+                  const requestedAt = (dependencies.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+                  const result2 = await session.client.callTool(
+                    "inference.agent.assignment.heartbeat",
+                    {
+                      operation_id: agentOperationId("agent-assignment-heartbeat"),
+                      host_id: session.localState.host_id,
+                      assignment_id: control.assignment.assignment_id,
+                      assignment_generation: control.assignment.assignment_generation,
+                      requested_at: requestedAt
+                    },
+                    { signal: cancellation.signal }
+                  );
+                  assignmentHeartbeatComplete = true;
+                  assignmentHeartbeatCount += 1;
+                  if (result2.directive === "cancel") {
+                    await handleForegroundCancelledAssignment(
+                      config2,
+                      session,
+                      control,
+                      requestedAt,
+                      cancellation.signal
+                    );
+                  } else {
+                    await writeInferenceForegroundAgentControlState(config2.statePath, {
+                      ...control,
+                      assignment: {
+                        ...control.assignment,
+                        lease_expires_at: result2.lease_expires_at
+                      },
+                      updated_at: requestedAt
+                    });
+                  }
+                } catch (error48) {
+                  if (cancellation.signal.aborted) break;
+                  if (!retryableAgentHeartbeatError(error48)) throw error48;
+                  consecutiveHeartbeatFailures += 1;
+                  retryDelayMs = Math.min(
+                    AGENT_HEARTBEAT_INTERVAL_MS * 2 ** Math.max(0, consecutiveHeartbeatFailures - 1),
+                    AGENT_HEARTBEAT_MAX_RETRY_DELAY_MS
+                  );
+                  emitStderr(parsed.json ? `${JSON.stringify({
+                    status: "assignment_heartbeat_retry",
+                    retry_after_ms: retryDelayMs
+                  })}
+` : `Foreground Agent assignment heartbeat was temporarily unavailable; retrying in ${retryDelayMs}ms.
+`);
+                }
+              }
             } finally {
               await commandLock.release();
             }
-            if (parsed.once && (heartbeatCount > 0 || heartbeatSuppressed)) break;
+            if (parsed.once && (heartbeatCount > 0 || heartbeatSuppressed) && assignmentHeartbeatComplete) break;
           }
           if (parsed.once && !commandLock) break;
           await (dependencies.sleep ?? (async (milliseconds) => {
@@ -36536,7 +37540,11 @@ Waiting for approval...
         }
         return {
           exitCode: 0,
-          stdout: render({ status: "stopped", heartbeats: heartbeatCount }, parsed.json),
+          stdout: render({
+            status: "stopped",
+            heartbeats: heartbeatCount,
+            assignment_heartbeats: assignmentHeartbeatCount
+          }, parsed.json),
           stderr: warnings.length > 0 ? `${warnings.join("\n")}
 ` : ""
         };
@@ -36924,7 +37932,7 @@ Waiting for approval...
         if (recoveryRaw === null && existingTransaction?.phase !== "reconciled") {
           throw new Error("Codex recovery evidence changed before service recovery began.");
         }
-        const transactionId = existingTransaction?.transaction_id ?? randomUUID3();
+        const transactionId = existingTransaction?.transaction_id ?? randomUUID4();
         const backupPath = existingTransaction?.recovery_backup_path ?? recoveryBackupPath(config2, transactionId);
         if (!existingTransaction) {
           await writeAtomicInferencePrivateFile(backupPath, recoveryRaw);
@@ -37445,7 +38453,7 @@ var init_types = __esm({
 });
 
 // lib/agent-core/client.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 function normalizeApiUrl(value) {
   const parsed = String(value || "").trim();
   if (!parsed) {
@@ -37707,7 +38715,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/decision", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -37716,7 +38724,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/trade-sync", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -37725,7 +38733,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/error", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           headers: { "x-client-runtime-lease": leaseToken },
           body: payload
         });
@@ -37737,7 +38745,7 @@ var init_client = __esm({
         return this.request("/trading/market-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37745,7 +38753,7 @@ var init_client = __esm({
         return this.request("/trading/limit-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37753,7 +38761,7 @@ var init_client = __esm({
         return this.request("/trading/cancel-order", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37772,7 +38780,7 @@ var init_client = __esm({
         return this.request("/trading/ai/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37780,7 +38788,7 @@ var init_client = __esm({
         return this.request("/trading/ai/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: {}
         });
       }
@@ -37788,7 +38796,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: {}
         });
       }
@@ -37796,7 +38804,7 @@ var init_client = __esm({
         return this.request("/trading/ai/assistant/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: {}
         });
       }
@@ -37804,7 +38812,7 @@ var init_client = __esm({
         return this.request("/trading/ai/runtime/session/start", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37815,7 +38823,7 @@ var init_client = __esm({
           return this.request("/trading/ai/runtime/session/stop", {
             method: "POST",
             profileId,
-            idempotencyKey: randomUUID4(),
+            idempotencyKey: randomUUID5(),
             body: payload
           });
         }
@@ -37832,7 +38840,7 @@ var init_client = __esm({
         }).request("/trading/ai/runtime/session/stop", {
           method: "POST",
           profileId,
-          idempotencyKey: randomUUID4(),
+          idempotencyKey: randomUUID5(),
           body: payload
         });
       }
@@ -37849,7 +38857,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "node:fs";
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { dirname as dirname6 } from "node:path";
 var parseStoredValues, FileBackedProtectionStorage, clientRuntimeProtectionStatePath;
 var init_protection_storage = __esm({
@@ -37906,7 +38914,7 @@ var init_protection_storage = __esm({
         mkdirSync(dirname6(this.path), { recursive: true, mode: 448 });
         const serialized = `${JSON.stringify(values)}
 `;
-        const temporaryPath = `${this.path}.${process.pid}.${randomUUID5()}.tmp`;
+        const temporaryPath = `${this.path}.${process.pid}.${randomUUID6()}.tmp`;
         try {
           writeFileSync(temporaryPath, serialized, {
             encoding: "utf8",
@@ -37933,7 +38941,7 @@ var init_protection_storage = __esm({
 });
 
 // lib/agent-core/headless-runtime.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
 function objectOrNull2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -38031,8 +39039,8 @@ async function runAndReportLocalWorkCycle(options, state, leaseToken, context) {
   return Boolean(result2.decision || tradeSync || result2.afterDecision);
 }
 async function startHeadlessRuntime(options) {
-  const runtimeSessionId = randomUUID6();
-  const deviceId = String(options.deviceId || "").trim() || randomUUID6();
+  const runtimeSessionId = randomUUID7();
+  const deviceId = String(options.deviceId || "").trim() || randomUUID7();
   const startResponse = await options.client.startRuntime(options.profileId, {
     session_id: runtimeSessionId,
     device_id: deviceId,
@@ -38220,7 +39228,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 +39250,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 +39557,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 +40346,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 +40463,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 +40681,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 +40712,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 +41141,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 +41150,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 +41163,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 +41242,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 +41284,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 +41347,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 +41390,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 +52558,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 +52710,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 +54411,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 +54436,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 +54522,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 +54557,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 +54568,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 +54584,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 +54608,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 +54637,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 +54660,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 +54676,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 +54716,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 +55453,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 +55539,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 +55551,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 +56063,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 +57541,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 +57549,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 +60613,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 +61032,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 +61047,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 } : {}
@@ -59997,7 +61592,7 @@ var headless_local_worker_exports = {};
 __export(headless_local_worker_exports, {
   createHeadlessLocalWorker: () => createHeadlessLocalWorker
 });
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 function objectOrNull3(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -60414,7 +62009,7 @@ function createHeadlessLocalWorker(options) {
       const statusMatch = errorText.match(/\b([45]\d{2})\b/);
       const statusCode = statusMatch ? Number(statusMatch[1]) : null;
       const failedInvocation = normalizeAiInvocationTelemetry({
-        client_invocation_id: randomUUID7(),
+        client_invocation_id: randomUUID8(),
         use_case: "trader",
         role: "primary",
         attempt_index: 0,
@@ -60470,7 +62065,7 @@ function createHeadlessLocalWorker(options) {
       billable_cached_input_tokens: normalizedUsage.cached_input_tokens
     };
     const invocation = normalizeAiInvocationTelemetry({
-      client_invocation_id: randomUUID7(),
+      client_invocation_id: randomUUID8(),
       use_case: "trader",
       role: "primary",
       attempt_index: 0,
@@ -60689,7 +62284,7 @@ var vtx_exports = {};
 __export(vtx_exports, {
   runVtxCli: () => runVtxCli
 });
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { spawn as spawn8 } from "node:child_process";
 function render2(value, json2) {
   if (json2) {
@@ -61103,8 +62698,8 @@ async function runVtxCli(argv2, env = process.env) {
         });
         return { exitCode: 0, stdout: render2(redactCliOutput(response2), json2), stderr: "" };
       }
-      const runtimeSessionId = randomUUID8();
-      const deviceId = config2.runtimeDeviceId ?? randomUUID8();
+      const runtimeSessionId = randomUUID9();
+      const deviceId = config2.runtimeDeviceId ?? randomUUID9();
       const response = await client.startRuntime(profileId, {
         session_id: runtimeSessionId,
         device_id: deviceId,