@vtxmacro/cli 2026.9.42 → 2026.9.43

package/bin/vtx-service-bootstrap.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from "node:url";
 // agent-cli-release.json
 var agent_cli_release_default = {
   package_name: "@vtxmacro/cli",
-  package_version: "2026.9.42",
+  package_version: "2026.9.43",
   codex_package_name: "@openai/codex",
   codex_version: "0.153.3",
   copilot_sdk_package_name: "@github/copilot-sdk",

package/bin/vtx.js

@@ -77,7 +77,7 @@ var init_agent_cli_release = __esm({
   "agent-cli-release.json"() {
     agent_cli_release_default = {
       package_name: "@vtxmacro/cli",
-      package_version: "2026.9.42",
+      package_version: "2026.9.43",
       codex_package_name: "@openai/codex",
       codex_version: "0.153.3",
       copilot_sdk_package_name: "@github/copilot-sdk",
@@ -47620,13 +47620,27 @@ async function runAndReportLocalWorkCycle(options, state, leaseToken, context) {
     ...buildRuntimePayload(state),
     last_run_at: lastRunAt
   };
+  let decisionResponse = null;
   if (result2.decision) {
-    await options.client.reportRuntimeDecision(options.profileId, {
+    decisionResponse = await options.client.reportRuntimeDecision(options.profileId, {
       ...basePayload,
       ...result2.decision
     }, leaseToken);
   }
-  const deferredTradeSync = result2.afterDecision ? await result2.afterDecision() : null;
+  let deferredTradeSync = null;
+  if (result2.afterDecision) {
+    const runtime = objectOrNull2(objectOrNull2(decisionResponse)?.runtime);
+    const decision = runtime?.last_decision;
+    const units = runtime?.last_units;
+    const requestedUnits = Number(result2.decision?.units);
+    if (!result2.decision || !["BUY", "SELL", "HOLD"].includes(String(decision)) || decision !== result2.decision.decision || typeof units !== "number" || !Number.isSafeInteger(units) || units < 0 || !Number.isSafeInteger(requestedUnits) || units > requestedUnits || (decision === "HOLD" ? units !== 0 : units <= 0)) {
+      throw new Error("Runtime decision acceptance is unavailable or inconsistent; execution skipped.");
+    }
+    deferredTradeSync = await result2.afterDecision({
+      decision,
+      units
+    });
+  }
   const tradeSync = deferredTradeSync ? { ...result2.tradeSync ?? {}, ...deferredTradeSync } : result2.tradeSync;
   if (tradeSync) {
     await options.client.reportRuntimeTradeSync(options.profileId, {
@@ -91386,6 +91400,167 @@ var init_runtime_execution = __esm({
   }
 });
 
+// lib/runtime/decision-contract.ts
+var VISIBLE_REASONING_KEYS, VISIBLE_REASONING_KEY_SET, VISIBLE_REASONING_ALIAS_KEY_SET, normalizeDecisionUnits, normalizeDecisionValue;
+var init_decision_contract = __esm({
+  "lib/runtime/decision-contract.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    VISIBLE_REASONING_KEYS = [
+      "reasoning",
+      "final_reasoning",
+      "final_answer",
+      "answer",
+      "output_text",
+      "text",
+      "content"
+    ];
+    VISIBLE_REASONING_KEY_SET = new Set(VISIBLE_REASONING_KEYS);
+    VISIBLE_REASONING_ALIAS_KEY_SET = new Set([
+      ...VISIBLE_REASONING_KEYS,
+      "reason"
+    ].map((key) => key.replace(/[^a-z0-9]+/gi, "").toLowerCase()));
+    normalizeDecisionUnits = (rawUnits, decision) => {
+      const parsedUnits = Number(rawUnits);
+      if (Number.isFinite(parsedUnits) && parsedUnits >= 0) {
+        return Math.trunc(parsedUnits);
+      }
+      return 0;
+    };
+    normalizeDecisionValue = (rawDecision) => {
+      const decisionValue = String(rawDecision || "").trim().toUpperCase();
+      return decisionValue === "BUY" || decisionValue === "SELL" ? decisionValue : "HOLD";
+    };
+  }
+});
+
+// lib/runtime/constraint-contract.ts
+var normalizeOptionalInt, evaluateRuntimeDecisionAcceptance;
+var init_constraint_contract = __esm({
+  "lib/runtime/constraint-contract.ts"() {
+    "use strict";
+    init_define_VTX_EXO_POLICY();
+    init_define_VTX_GROK_POLICY();
+    init_define_VTX_PI_MODEL_POLICY();
+    init_execution_guard_contract();
+    init_decision_contract();
+    normalizeOptionalInt = (value) => {
+      if (value === null || value === void 0) {
+        return null;
+      }
+      const parsed = Number.parseInt(String(value), 10);
+      return Number.isFinite(parsed) ? parsed : null;
+    };
+    evaluateRuntimeDecisionAcceptance = (input) => {
+      const decision = normalizeDecisionValue(input.decision);
+      const units = normalizeDecisionUnits(input.units, decision);
+      if (decision === "HOLD") {
+        return {
+          accepted: true,
+          decision,
+          normalized_units: 0,
+          reason_code: null
+        };
+      }
+      if (input.constraints.runtime_disabled) {
+        return {
+          accepted: false,
+          decision,
+          normalized_units: 0,
+          reason_code: "runtime_disabled"
+        };
+      }
+      if (input.constraints.kill_switch_active) {
+        return {
+          accepted: false,
+          decision,
+          normalized_units: 0,
+          reason_code: "kill_switch_active"
+        };
+      }
+      if (!input.constraints.model_allowed) {
+        return {
+          accepted: false,
+          decision,
+          normalized_units: 0,
+          reason_code: "model_ineligible"
+        };
+      }
+      if (!input.constraints.provider_allowed) {
+        return {
+          accepted: false,
+          decision,
+          normalized_units: 0,
+          reason_code: "provider_ineligible"
+        };
+      }
+      if (units <= 0) {
+        return {
+          accepted: false,
+          decision,
+          normalized_units: 0,
+          reason_code: "invalid_units"
+        };
+      }
+      const maxPerPrompt = Math.max(Math.trunc(Number(input.constraints.max_trades_per_prompt) || 0), 0);
+      if (maxPerPrompt === 0) {
+        return {
+          accepted: false,
+          decision,
+          normalized_units: 0,
+          reason_code: "max_per_prompt_zero"
+        };
+      }
+      const remainingGlobal = normalizeOptionalInt(input.constraints.remaining_global_units);
+      const remainingExchange = normalizeOptionalInt(input.constraints.remaining_exchange_units);
+      const remainingAsset = normalizeOptionalInt(input.constraints.remaining_asset_units);
+      const currentSymbolSignedUnits = normalizeOptionalInt(input.constraints.current_symbol_signed_units) ?? 0;
+      let cappedUnits = Math.min(units, maxPerPrompt);
+      const exposureIncrease = (candidateUnits) => {
+        const classified = classifyExecutionIntent(decision, candidateUnits, currentSymbolSignedUnits);
+        return Math.max(
+          0,
+          Math.abs(classified.targetSignedUnits) - Math.abs(currentSymbolSignedUnits)
+        );
+      };
+      const fitsCapacity = (candidateUnits) => {
+        const increase = exposureIncrease(candidateUnits);
+        if (remainingGlobal !== null && increase > Math.max(remainingGlobal, 0)) {
+          return false;
+        }
+        if (remainingExchange !== null && increase > Math.max(remainingExchange, 0)) {
+          return false;
+        }
+        if (remainingAsset !== null && increase > Math.max(remainingAsset, 0)) {
+          return false;
+        }
+        return true;
+      };
+      while (cappedUnits > 0 && !fitsCapacity(cappedUnits)) {
+        cappedUnits -= 1;
+      }
+      if (cappedUnits <= 0) {
+        const requestedExposureIncrease = exposureIncrease(Math.min(units, maxPerPrompt));
+        const reasonCode = requestedExposureIncrease > 0 && remainingGlobal !== null && remainingGlobal <= 0 ? "global_capacity_reached" : requestedExposureIncrease > 0 && remainingExchange !== null && remainingExchange <= 0 ? "exchange_capacity_reached" : requestedExposureIncrease > 0 && remainingAsset !== null && remainingAsset <= 0 ? "asset_capacity_reached" : "capacity_reached";
+        return {
+          accepted: false,
+          decision,
+          normalized_units: 0,
+          reason_code: reasonCode
+        };
+      }
+      return {
+        accepted: true,
+        decision,
+        normalized_units: cappedUnits,
+        reason_code: cappedUnits < units ? "units_capped" : null
+      };
+    };
+  }
+});
+
 // lib/runtime/provider-observability.ts
 var record4, identifier, count3, normalizeProviderDiagnostics;
 var init_provider_observability = __esm({
@@ -92566,6 +92741,46 @@ function createHeadlessLocalWorker(options) {
         message: `Tradability ${providerDecision.tradability ?? "missing"} is below the ${classifiedIntent === "open" ? "Open" : "Add"} minimum of ${applicableMinimum}. No order was placed.`
       }
     } : null;
+    let executionDecision = { decision: providerDecision.decision, units: providerDecision.units };
+    if (localHyperliquidContext && providerDecision.decision !== "HOLD") {
+      const constraints = objectOrNull3(metadata.constraint_contract) ?? {};
+      const limit = (key) => {
+        const raw = key === "max_trades_per_exchange" && !Object.hasOwn(promptKnobs, key) ? promptKnobs.max_trades_global : promptKnobs[key];
+        if (raw == null) throw new Error(`Missing headless runtime ${key}.`);
+        const value = requireFiniteNumber(raw, key);
+        if (!Number.isSafeInteger(value) || value < 0) throw new Error(`Invalid headless runtime ${key}.`);
+        return value;
+      };
+      const unitSize = localHyperliquidContext.executionContext.unitSizeUsdc;
+      const venue = getHyperliquidMarketDex(symbol2);
+      let globalUsage = 0;
+      let exchangeUsage = 0;
+      let currentSignedUnits = 0;
+      for (const position of localHyperliquidContext.accountState.positions) {
+        if (Number(position.size) === 0) continue;
+        const entryPrice = requirePositiveNumber2(position.entry_price, "position entry price");
+        const signedUnits = signedUnitsFromPosition(Number(position.size), entryPrice, unitSize);
+        globalUsage += Math.abs(signedUnits);
+        if (getHyperliquidMarketDex(position.symbol) === venue) exchangeUsage += Math.abs(signedUnits);
+        if (normalizeRuntimeSymbol(position.symbol) === normalizeRuntimeSymbol(symbol2)) currentSignedUnits = signedUnits;
+      }
+      const accepted = evaluateRuntimeDecisionAcceptance({
+        ...executionDecision,
+        constraints: {
+          runtime_disabled: constraints.runtime_disabled === true,
+          kill_switch_active: constraints.kill_switch_active === true,
+          max_trades_per_prompt: limit("max_trades_per_prompt"),
+          remaining_global_units: limit("max_trades_global") - globalUsage,
+          remaining_exchange_units: limit("max_trades_per_exchange") - exchangeUsage,
+          remaining_asset_units: limit("max_trades_per_asset") - Math.abs(currentSignedUnits),
+          current_symbol_signed_units: currentSignedUnits,
+          model_allowed: constraints.model_allowed !== false,
+          provider_allowed: constraints.provider_allowed !== false
+        }
+      });
+      if (!accepted.accepted) throw new Error(`Headless runtime decision rejected: ${accepted.reason_code}`);
+      executionDecision = { decision: accepted.decision, units: accepted.normalized_units };
+    }
     const envelope = metadata.envelope ?? {};
     const baseTradeSync = {
       analysis_run_id: analysisRunId,
@@ -92585,8 +92800,8 @@ function createHeadlessLocalWorker(options) {
         contract_version: requireText(envelope.contract_version, "contract version"),
         contract_hash: requireText(envelope.contract_hash, "contract hash"),
         policy_generation_id: requireText(envelope.policy_generation_id, "policy generation id"),
-        decision: providerDecision.decision,
-        units: providerDecision.units,
+        decision: executionDecision.decision,
+        units: executionDecision.units,
         final_tradability: providerDecision.tradability,
         reasoning: providerDecision.reasoning,
         model: requireText(prompt.model ?? metadata.model, "model"),
@@ -92612,7 +92827,7 @@ function createHeadlessLocalWorker(options) {
         execution_snapshot_id: tradabilityBlockExecution ? decisionSnapshotId : void 0,
         executions: tradabilityBlockExecution ? [tradabilityBlockExecution] : []
       },
-      afterDecision: localHyperliquidContext ? async () => {
+      afterDecision: localHyperliquidContext ? async (accepted) => {
         const freshProfile = objectOrNull3(await options.client.getSecretStatus(input.profileId));
         const freshWalletAddress = requireText(
           freshProfile?.hyperliquid_wallet_address,
@@ -92631,8 +92846,8 @@ function createHeadlessLocalWorker(options) {
           cycleId: analysisRunId,
           signingKey: localHyperliquidContext.signingKey,
           config: buildHeadlessExchangeConfig(llmConfig),
-          decision: providerDecision.decision,
-          units: providerDecision.units,
+          decision: accepted.decision,
+          units: accepted.units,
           executionContext: localHyperliquidContext.executionContext
         });
         return {
@@ -92655,6 +92870,7 @@ var init_headless_local_worker = __esm({
     init_hyperliquid_account_state_adapter();
     init_hyperliquid_market_symbol();
     init_runtime_execution();
+    init_constraint_contract();
     init_protection_storage();
     init_execution_guard_contract();
     init_inference_observability();

package/package.json

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