@tradejs/node 3.1.29-beta.290 → 3.1.29-beta.291

package/dist/backtest.mjs

@@ -10,11 +10,12 @@ import {
   evaluateResearchEntryPolicy,
   matchesResearchEntryRules,
   parseResearchEntryPolicy
-} from "./chunk-PB2KHBGH.mjs";
+} from "./chunk-HRON2EAI.mjs";
+import "./chunk-UUNEWAT4.mjs";
 import {
   buildAiPayload,
   getStrategyCreator
-} from "./chunk-UL5Z46JL.mjs";
+} from "./chunk-PYJWXAYR.mjs";
 import {
   getTradejsProjectCwd
 } from "./chunk-LZDXRXIU.mjs";

package/dist/{chunk-PB2KHBGH.mjs → chunk-HRON2EAI.mjs}

@@ -1,3 +1,7 @@
+import {
+  createMemoryPortfolioStore,
+  createPortfolioCoordinator
+} from "./chunk-UUNEWAT4.mjs";
 import {
   askAI,
   buildAiPayload,
@@ -7,7 +11,7 @@ import {
   resolveStrategyPolicyProfile,
   runAiPromptLocal,
   setStrategyRuntimeFactory
-} from "./chunk-UL5Z46JL.mjs";
+} from "./chunk-PYJWXAYR.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig
@@ -72,12 +76,14 @@ var validateEntryExecution = ({
     throw new EntrySubmissionValidationError(
       "ENTRY_ECONOMICS_INPUTS_UNAVAILABLE"
     );
-  if (limits.minimumNetRiskRatio != null && netRiskRatio <= limits.minimumNetRiskRatio)
-    throw new EntrySubmissionValidationError(
-      "ENTRY_RR_BELOW_MIN_AT_SUBMISSION"
-    );
+  const belowMinimumNetRiskRatio = limits.minimumNetRiskRatio != null && netRiskRatio <= limits.minimumNetRiskRatio;
   const riskExceeded = limits.maxLossValue != null && plannedLossValue > limits.maxLossValue * (1 + 1e-9);
-  return { netRiskRatio, plannedLossValue, riskExceeded };
+  return {
+    netRiskRatio,
+    plannedLossValue,
+    riskExceeded,
+    belowMinimumNetRiskRatio
+  };
 };
 
 // src/strategy/entrySubmissionValidation.ts
@@ -209,6 +215,15 @@ var createEntrySubmissionValidation = ({
       takeProfitPrice: direction === "LONG" ? Math.max(...prices) : Math.min(...prices),
       limits
     });
+    if (economics.belowMinimumNetRiskRatio) {
+      logger.warn(
+        "entry submission warning: %s %s ENTRY_RR_BELOW_MIN_AT_SUBMISSION (RR %s, threshold %s)",
+        symbol,
+        direction,
+        economics.netRiskRatio,
+        limits.minimumNetRiskRatio
+      );
+    }
     onValidated?.(snapshot2, economics);
   };
 };
@@ -2278,6 +2293,10 @@ import { createRuntimeOrderLinkPrefix } from "@tradejs/core/trade";
 import { logger as logger5 } from "@tradejs/infra/logger";
 import {
   delKey,
+  deleteRuntimeTradeReference,
+  getDataStrict,
+  setDataStrict,
+  setHashJsonFieldStrict,
   getData,
   redisKeys,
   setData,
@@ -2444,6 +2463,7 @@ var getActiveRuntimeTrade = async (params) => {
 var markRuntimeTradeClosed = async (params) => {
   const {
     userName,
+    expectedOrderId,
     symbol,
     strategy,
     exitPrice,
@@ -2456,13 +2476,15 @@ var markRuntimeTradeClosed = async (params) => {
   if (!userName) {
     return null;
   }
-  const existing = await getActiveRuntimeTrade({
+  const existing = expectedOrderId ? await getDataStrict(
+    redisKeys.runtimeTrade(userName, expectedOrderId)
+  ) : await getActiveRuntimeTrade({
     userName,
     symbol,
     accountId,
     deploymentId
   });
-  if (!existing) {
+  if (!existing || expectedOrderId && existing.orderId !== expectedOrderId) {
     return null;
   }
   const orderId = existing.orderId;
@@ -2476,7 +2498,7 @@ var markRuntimeTradeClosed = async (params) => {
     exitPrice: resolvedExitPrice,
     qty: existing.qty
   }) : existing.closedPnl ?? existing.currentPnl ?? null;
-  const next = {
+  const next = expectedOrderId && existing.status === "closed" ? existing : {
     ...existing,
     status: "closed",
     currentPrice: resolvedExitPrice,
@@ -2491,22 +2513,33 @@ var markRuntimeTradeClosed = async (params) => {
   const closeDayKey = getRuntimeStorageDayKey(next.exitTimestamp);
   try {
     await Promise.all([
-      setData(redisKeys.runtimeTrade(userName, orderId), next, {
-        expire: TTL_1M
-      }),
-      setHashJsonField(
+      (expectedOrderId ? setDataStrict : setData)(
+        redisKeys.runtimeTrade(userName, orderId),
+        next,
+        {
+          expire: TTL_1M
+        }
+      ),
+      (expectedOrderId ? setHashJsonFieldStrict : setHashJsonField)(
         redisKeys.runtimeTradeBucket(userName, dayKey),
         orderId,
         next,
         { expire: TTL_1M }
       ),
-      setHashJsonField(
+      (expectedOrderId ? setHashJsonFieldStrict : setHashJsonField)(
         redisKeys.runtimeClosedTradeBucket(userName, closeDayKey),
         orderId,
         next,
         { expire: TTL_1M }
       ),
-      delKey(
+      expectedOrderId ? deleteRuntimeTradeReference(
+        redisKeys.runtimeActiveTrade(
+          userName,
+          symbol,
+          deploymentId ?? accountId
+        ),
+        expectedOrderId
+      ) : delKey(
         redisKeys.runtimeActiveTrade(
           userName,
           symbol,
@@ -2515,6 +2548,7 @@ var markRuntimeTradeClosed = async (params) => {
       )
     ]);
   } catch (error) {
+    if (expectedOrderId) throw error;
     logger5.error(
       "runtime trade close journal failed: %s %s",
       symbol,
@@ -2524,6 +2558,93 @@ var markRuntimeTradeClosed = async (params) => {
   return next;
 };
 
+// src/strategyHelpers/tickerProfiles.ts
+import { readTickerProfiles } from "@tradejs/infra/tickerProfiles";
+import {
+  isTickerProfileSnapshot,
+  tickerProfileMonth
+} from "@tradejs/core/tickerProfiles";
+var snapshots = /* @__PURE__ */ new Map();
+var resolveTickerProfileSource = (strategy) => {
+  const declared = getStrategyManifest(strategy)?.contextRequirements?.tickerProfiles;
+  if (declared) return declared;
+  const provider = process.env.TICKER_PROFILES_PROVIDER?.trim();
+  const universeId = process.env.TICKER_PROFILES_UNIVERSE?.trim();
+  if (!provider && !universeId) return void 0;
+  if (!provider || !universeId)
+    throw new Error(
+      "Set both TICKER_PROFILES_PROVIDER and TICKER_PROFILES_UNIVERSE"
+    );
+  return { provider, universeId };
+};
+var loadTickerProfileContext = async ({
+  projectRoot,
+  provider,
+  universeId,
+  symbol,
+  timestamp
+}) => {
+  const asOf = tickerProfileMonth(timestamp), key = JSON.stringify([projectRoot, provider, universeId, asOf]);
+  let cached = snapshots.get(key);
+  if (!cached || cached.expires < Date.now()) {
+    const value = readTickerProfiles(projectRoot, provider, universeId, asOf).then((envelope) => {
+      if (!envelope) return null;
+      const s = envelope.snapshot;
+      if (!isTickerProfileSnapshot(s) || s.asOf !== asOf || s.provider !== provider || s.universeId !== universeId)
+        throw new Error("Ticker profile identity/schema mismatch");
+      const entry = snapshots.get(key);
+      if (entry) entry.expires = Infinity;
+      return new Map(
+        s.profiles.map((p) => [
+          p.symbol,
+          Object.freeze({
+            ...p,
+            definition: s.definition,
+            provider,
+            universeId,
+            snapshotId: envelope.snapshotId
+          })
+        ])
+      );
+    }).catch((error) => {
+      snapshots.delete(key);
+      throw error;
+    });
+    cached = { expires: Date.now() + 6e4, value };
+    snapshots.set(key, cached);
+    if (snapshots.size > 24) {
+      const oldest = snapshots.keys().next().value;
+      if (oldest) snapshots.delete(oldest);
+    }
+  }
+  return (await cached.value)?.get(symbol);
+};
+var withTickerProfile = (baseContext, profile) => Object.defineProperty(
+  Object.create(
+    Object.getPrototypeOf(baseContext),
+    Object.getOwnPropertyDescriptors(baseContext)
+  ),
+  "tickerProfile",
+  { enumerable: true, configurable: true, value: profile }
+);
+var enrichSignalWithTickerProfile = async (signal) => {
+  const source = resolveTickerProfileSource(signal.strategy);
+  if (!source || signal.universe === "tradfi" || !signal.symbol.endsWith("USDT"))
+    return;
+  const profile = await loadTickerProfileContext({
+    ...source,
+    projectRoot: getTradejsProjectCwd(),
+    symbol: signal.symbol,
+    timestamp: signal.timestamp
+  });
+  if (profile) {
+    signal.additionalIndicators = {
+      ...signal.additionalIndicators,
+      tickerProfile: profile
+    };
+  }
+};
+
 // src/strategyHelpers/marketContextStages.ts
 import { logger as logger7 } from "@tradejs/infra/logger";
 
@@ -2884,6 +3005,7 @@ var enrichSignalWithMarketContextStages = async ({
       })
     });
   }
+  await enrichSignalWithTickerProfile(signal);
   const results = [];
   for (const stage of stages) {
     if (abortSignal?.aborted) break;
@@ -2931,12 +3053,12 @@ var findReplayAiAnalysis = ({
   direction,
   ai
 }) => {
-  const snapshots = ai?.replayAnalyses;
-  if (!Array.isArray(snapshots) || !snapshots.length) {
+  const snapshots2 = ai?.replayAnalyses;
+  if (!Array.isArray(snapshots2) || !snapshots2.length) {
     return void 0;
   }
   let best = null;
-  for (const snapshot2 of snapshots) {
+  for (const snapshot2 of snapshots2) {
     if (snapshot2.symbol !== signal.symbol || snapshot2.direction !== direction || snapshot2.strategy && snapshot2.strategy !== signal.strategy) {
       continue;
     }
@@ -3109,7 +3231,9 @@ var executeEntryOrder = async ({
   beforePlaceOrder,
   recordRuntimeTrade = true,
   leverage,
-  executionLimits
+  executionLimits,
+  markPortfolioSubmitted,
+  rejectPortfolioSubmission
 }) => {
   await beforePlaceOrder?.();
   const previousPosition = positionIntent === "increase" ? await connector.getPosition(symbol) : null;
@@ -3182,7 +3306,13 @@ var executeEntryOrder = async ({
     ...typeof leverage === "number" && Number.isFinite(leverage) ? { leverage } : {},
     orderId,
     signal,
-    ...beforeSubmit ? { beforeSubmit } : {}
+    ...rejectPortfolioSubmission ? { onRejected: rejectPortfolioSubmission } : {},
+    ...beforeSubmit || markPortfolioSubmitted ? {
+      beforeSubmit: async (context) => {
+        await beforeSubmit?.(context);
+        await markPortfolioSubmitted?.(context.qty);
+      }
+    } : {}
   });
   const orderAckTime = Date.now();
   const placedQty = typeof signal.orderQty === "number" && Number.isFinite(signal.orderQty) && signal.orderQty > 0 ? signal.orderQty : qty;
@@ -3457,6 +3587,191 @@ var evaluateResearchEntryPolicy = async (policy, signal, onDecision) => {
   return allowed;
 };
 
+// src/strategy/portfolioRuntime.ts
+import { createHash as createHash3 } from "crypto";
+import {
+  parsePortfolioPolicy,
+  assertPortfolioState,
+  portfolioFingerprint
+} from "@tradejs/core/portfolio";
+import { portfolioStateStorage } from "@tradejs/infra/redis";
+var coordinators = /* @__PURE__ */ new WeakMap();
+async function observeRuntimePortfolio(connector, binding, asOf, reservations, observedNow = Date.now) {
+  if (!connector.getOpenPositionPnl || !connector.getEntryExecutions)
+    throw new Error(
+      "Portfolio policies require position marks and entry executions"
+    );
+  const orders = await Promise.all(
+    reservations.map(async (r) => {
+      if (r.submitted && connector.getEntryOrderObservation) {
+        const fact = await connector.getEntryOrderObservation({
+          symbol: r.symbol,
+          orderId: r.id
+        });
+        if (fact) return fact;
+      }
+      const executions = r.submitted ? await connector.getEntryExecutions({
+        symbol: r.symbol,
+        startTime: r.timestamp,
+        endTime: asOf
+      }) : [];
+      const filledQty = executions.filter(
+        (e) => (e.orderLinkId === r.id || e.orderId === r.id) && e.direction === r.direction
+      ).reduce((sum, e) => sum + e.qty, 0);
+      return {
+        id: r.id,
+        status: filledQty >= r.qty ? "filled" : filledQty > 0 ? "partial" : "pending",
+        filledQty,
+        positionId: r.id
+      };
+    })
+  );
+  const snapshots2 = await connector.getOpenPositionPnl();
+  const positions = await Promise.all(
+    snapshots2.map(async (p) => {
+      const reserved = reservations.find(
+        (r) => r.symbol === p.symbol && r.direction === p.direction && orders.some(
+          (o) => o.id === r.id && o.filledQty > 0 && p.qty <= o.filledQty * (1 + 1e-8)
+        )
+      );
+      const trade = await getActiveRuntimeTrade({
+        ...binding,
+        symbol: p.symbol
+      });
+      const owner = trade && trade.direction === p.direction && p.qty <= trade.qty * (1 + 1e-8) && Math.abs(p.price - (trade.actualEntryPrice ?? trade.entryPrice)) <= p.price * 1e-8 ? trade : null;
+      return {
+        id: reserved?.id ?? owner?.orderId ?? `unknown:${p.symbol}:${p.direction}`,
+        strategy: reserved?.strategy ?? owner?.strategy ?? null,
+        symbol: p.symbol,
+        direction: p.direction,
+        qty: p.qty,
+        entryPrice: p.price,
+        markPrice: p.currentPrice,
+        markedAt: p.observedAt ?? null,
+        stopLossPrice: p.slPrice ?? p.stopLossPrice ?? null
+      };
+    })
+  );
+  return { asOf: Math.max(asOf, observedNow()), positions, orders };
+}
+function persistentStore(key) {
+  const raw = /* @__PURE__ */ new WeakMap();
+  return {
+    async read() {
+      const value = await portfolioStateStorage.read(key);
+      if (value === null) return null;
+      const state = JSON.parse(value);
+      assertPortfolioState(state);
+      raw.set(state, value);
+      return state;
+    },
+    async compare(previous, next) {
+      const expected = previous === null ? null : raw.get(previous);
+      if (expected === void 0)
+        throw new Error("Portfolio CAS requires a storage snapshot");
+      return portfolioStateStorage.compare(key, expected, JSON.stringify(next));
+    }
+  };
+}
+function getPortfolioRuntime({
+  value,
+  connectorName,
+  strategy,
+  connector,
+  env,
+  userName,
+  accountId,
+  deploymentId
+}) {
+  const policy = parsePortfolioPolicy(value);
+  if (!policy) return void 0;
+  const replay = (env === "BACKTEST" || env === "PARITY") && Reflect.get(connector, "__tradejsReplayConnector") === true;
+  if ((env === "BACKTEST" || env === "PARITY") && (!replay || !connector.getPortfolioObservation))
+    throw new Error(
+      "Portfolio policies require shared portfolio replay; isolated symbol backtests are unsupported"
+    );
+  if (!replay && (!userName || !accountId || !deploymentId || !connector.getOpenPositionPnl || !connector.getEntryExecutions))
+    throw new Error(
+      "Portfolio runtime requires exact user/account/deployment binding, marks and executions"
+    );
+  const binding = {
+    userName,
+    accountId,
+    deploymentId
+  };
+  const scope = policy.scope === "strategy" ? strategy : policy.scope === "account" ? "account" : [...policy.scope.strategies].sort();
+  const key = createHash3("sha256").update(JSON.stringify([binding, connectorName, connector.universe, scope])).digest("hex");
+  const fingerprint3 = portfolioFingerprint(policy, strategy);
+  const cacheKey = key;
+  let registry = coordinators.get(connector);
+  if (!registry) {
+    registry = /* @__PURE__ */ new Map();
+    coordinators.set(connector, registry);
+  }
+  const existing = registry.get(cacheKey);
+  if (existing) {
+    if (existing.fingerprint !== fingerprint3)
+      throw new Error("Conflicting portfolio configuration for the same scope");
+    return existing.coordinator;
+  }
+  const coordinator = createPortfolioCoordinator({
+    policy,
+    strategy,
+    store: replay ? createMemoryPortfolioStore() : persistentStore(key),
+    execution: {
+      async confirmClosed(intent, asOf) {
+        if (replay) return;
+        const position = intent.position;
+        await markRuntimeTradeClosed({
+          ...binding,
+          strategy: position.strategy,
+          expectedOrderId: position.id,
+          symbol: position.symbol,
+          exitPrice: position.markPrice,
+          exitTimestamp: asOf,
+          exitType: "exit"
+        });
+      },
+      observe: (asOf, reservations) => replay ? connector.getPortfolioObservation(asOf, reservations) : observeRuntimePortfolio(connector, binding, asOf, reservations),
+      async close(position, intent, asOf) {
+        if (!replay) {
+          const trade = await getActiveRuntimeTrade({
+            ...binding,
+            symbol: position.symbol
+          });
+          if (!trade || trade.orderId !== position.id)
+            throw new Error("Portfolio close ownership changed");
+        }
+        await connector.closePosition({
+          symbol: position.symbol,
+          direction: position.direction,
+          price: position.markPrice,
+          timestamp: asOf,
+          signal: {
+            signalId: `${position.id}:${intent.reason}`,
+            strategy: position.strategy,
+            symbol: position.symbol,
+            direction: position.direction,
+            interval: "1",
+            timestamp: asOf,
+            prices: {
+              riskRatio: 0,
+              currentPrice: position.markPrice,
+              takeProfitPrice: position.markPrice,
+              stopLossPrice: position.markPrice
+            },
+            figures: {},
+            indicators: {},
+            additionalIndicators: { portfolioExitReason: intent.reason }
+          }
+        });
+      }
+    }
+  });
+  registry.set(cacheKey, { fingerprint: fingerprint3, coordinator });
+  return coordinator;
+}
+
 // src/strategyRuntime.ts
 import { parseJevConfig } from "@tradejs/core/jev";
 import {
@@ -4192,7 +4507,7 @@ var handleProtectDecision = async ({
   }
   return decision.code;
 };
-var executeEntryDecision = async ({
+var executeAdmittedEntryDecision = async ({
   connector,
   symbol,
   decision,
@@ -4206,7 +4521,9 @@ var executeEntryDecision = async ({
   ai,
   recordRuntimeJournal,
   invokeStageHooks,
-  notifyRuntimeError
+  notifyRuntimeError,
+  markPortfolioSubmitted,
+  rejectPortfolioSubmission
 }) => {
   const signal = decision.signal;
   const beforePlaceOrder = async () => {
@@ -4253,6 +4570,8 @@ var executeEntryDecision = async ({
         ...Number.isFinite(Number(hookCtx.strategyConfig.LEVERAGE)) ? { leverage: Number(hookCtx.strategyConfig.LEVERAGE) } : {},
         signal,
         beforePlaceOrder,
+        markPortfolioSubmitted,
+        rejectPortfolioSubmission,
         recordRuntimeTrade: recordRuntimeJournal,
         executionLimits: resolveEntryExecutionLimits(
           hookCtx.strategyConfig,
@@ -4393,6 +4712,37 @@ var executeEntryDecision = async ({
   }
   return signal ?? decision.code;
 };
+async function executeEntryDecision(params) {
+  if (!params.portfolio) return executeAdmittedEntryDecision(params);
+  const { decision, portfolio } = params;
+  const signal = decision.signal;
+  if (!signal || decision.orderPlan.positionIntent === "increase")
+    return "PORTFOLIO_REQUIRES_NEW_SIGNAL_POSITION";
+  signal.orderId ??= createRuntimeOrderId(signal.strategy);
+  const result = await portfolio.submit(
+    params.portfolioTime ?? decision.entryContext.timestamp,
+    {
+      id: signal.orderId,
+      signalId: signal.signalId,
+      strategy: signal.strategy,
+      symbol: params.symbol,
+      direction: decision.entryContext.direction,
+      qty: decision.orderPlan.qty,
+      timestamp: decision.entryContext.timestamp
+    },
+    (markPortfolioSubmitted, rejectPortfolioSubmission) => executeAdmittedEntryDecision({
+      ...params,
+      markPortfolioSubmitted,
+      rejectPortfolioSubmission
+    })
+  );
+  if (result.reason) {
+    signal.orderStatus = "failed";
+    signal.orderFailureReason = result.reason;
+    return signal;
+  }
+  return result.value;
+}
 
 // src/strategyRuntime.ts
 var cloneWithPropertyDescriptors = (value) => Object.create(
@@ -4420,6 +4770,7 @@ var createStrategyRuntime = ({
   };
   const creator = async ({
     userName,
+    connectorName,
     config: baseConfig,
     symbol,
     universe: requestedUniverse,
@@ -4458,6 +4809,17 @@ var createStrategyRuntime = ({
     const projectConfig = await loadTradejsConfig(projectRoot);
     const projectHooks = projectConfig.hooks;
     const env = String(config.ENV ?? "BACKTEST");
+    const portfolio = getPortfolioRuntime({
+      connectorName,
+      value: baseConfig?.PORTFOLIO_POLICY ?? config.PORTFOLIO_POLICY,
+      strategy: strategyName,
+      connector,
+      env,
+      userName,
+      accountId,
+      deploymentId
+    });
+    const portfolioContext = portfolio ? (now2) => isRuntimeOrderExecutionEnabled({ config, env, connector }) ? portfolio.tick(now2) : portfolio.context(now2) : void 0;
     const researchPolicyValue = baseConfig?.RESEARCH_ENTRY_POLICY ?? config.RESEARCH_ENTRY_POLICY;
     const researchEntryPolicy = researchPolicyValue == null ? void 0 : parseResearchEntryPolicy(researchPolicyValue);
     if (researchEntryPolicy && (env !== "BACKTEST" || Reflect.get(connector, "__tradejsTestConnector") !== true))
@@ -4756,6 +5118,20 @@ var createStrategyRuntime = ({
         interval: decisionInterval
       }) => {
         if (!baseContext) return void 0;
+        const profileSource = strategyManifest?.contextRequirements?.tickerProfiles;
+        if (profileSource) {
+          const profile = await loadTickerProfileContext({
+            ...profileSource,
+            projectRoot,
+            symbol: decisionSymbol,
+            timestamp: candle.timestamp
+          });
+          if (!profile)
+            throw new Error(
+              "Required ticker profile is unavailable at decision time"
+            );
+          baseContext = withTickerProfile(baseContext, profile);
+        }
         if (!coreContextRequirements.has("hyperliquidWhales")) {
           return baseContext;
         }
@@ -4923,6 +5299,8 @@ var createStrategyRuntime = ({
         runtime: pending.runtime
       });
       return executeEntryDecision({
+        portfolio,
+        portfolioTime: env === "BACKTEST" || env === "PARITY" ? candle.timestamp : Date.now(),
         connector,
         symbol,
         decision: pending.decision,
@@ -4940,6 +5318,10 @@ var createStrategyRuntime = ({
       });
     };
     const runWithDecisionOverride = async (candle, btcCandle, options = {}) => {
+      if (portfolioContext)
+        await portfolioContext(
+          env === "BACKTEST" || env === "PARITY" ? candle.timestamp : Date.now()
+        );
       appendCurrentMarketData(candle, btcCandle, options.ethCandle);
       const ethCandle = resolveEthCandle(candle, options.ethCandle);
       indicatorsState.setCurrentBar(candle, btcCandle, ethCandle);
@@ -5110,6 +5492,13 @@ var createStrategyRuntime = ({
       });
       const signal = decision.signal;
       if (signal) {
+        if (portfolio)
+          signal.additionalIndicators = {
+            ...signal.additionalIndicators,
+            portfolioContext: await portfolioContext(
+              env === "BACKTEST" || env === "PARITY" ? decision.entryContext.timestamp : Date.now()
+            )
+          };
         if (runtimeLineage) signal.runtimeLineage = runtimeLineage;
         if (universe) signal.universe = universe;
         if (assetClass) signal.assetClass = assetClass;
@@ -5349,6 +5738,8 @@ var createStrategyRuntime = ({
         });
       }
       return executeEntryDecision({
+        portfolio,
+        portfolioTime: env === "BACKTEST" || env === "PARITY" ? candle.timestamp : Date.now(),
         connector,
         symbol,
         decision,