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

package/dist/runtimeDashboard.js

@@ -784,7 +784,7 @@ var import_time4 = require("@tradejs/core/time");
 var import_logger15 = require("@tradejs/infra/logger");
 var import_runtimeDeploymentEvents = require("@tradejs/infra/runtimeDeploymentEvents");
 var import_tradingAccounts3 = require("@tradejs/infra/tradingAccounts");
-var import_redis4 = require("@tradejs/infra/redis");
+var import_redis5 = require("@tradejs/infra/redis");
 
 // src/connectorsRegistry.ts
 var import_logger4 = require("@tradejs/infra/logger");
@@ -2083,1376 +2083,2156 @@ var syncRuntimeTrades = async ({
 
 // src/runtimeStrategies.ts
 var import_jev8 = require("@tradejs/core/jev");
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 var import_promises2 = require("fs/promises");
 var import_node_path2 = __toESM(require("path"));
 var import_runtimeControls = require("@tradejs/infra/runtimeControls");
 var import_tradingAccounts2 = require("@tradejs/infra/tradingAccounts");
 
-// src/strategyRuntime.ts
-var import_jev6 = require("@tradejs/core/jev");
+// src/strategy/portfolioRuntime.ts
+var import_node_crypto2 = require("crypto");
+var import_portfolio2 = require("@tradejs/core/portfolio");
+var import_redis3 = require("@tradejs/infra/redis");
 
-// src/jev.ts
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __toESM(require("path"));
-var import_jev4 = require("@tradejs/core/jev");
-var import_jev5 = require("@tradejs/infra/jev");
-var import_userSettings = require("@tradejs/infra/userSettings");
-init_jevInput();
-init_jevInput();
-init_jevTraining();
-var resolveJevProvider = async (userName) => {
-  const settings = await (0, import_userSettings.getUserSettings)(userName);
-  const provider = {
-    endpoint: settings.JEV_API_ENDPOINT || import_jev4.JEV_PROVIDERS[0].endpoint,
-    model: settings.JEV_MODEL || import_jev4.JEV_PROVIDERS[0].model
-  };
-  (0, import_jev4.parseJevConfig)({ source: "provider", mode: "observe", provider });
-  if (!settings.JEV_API_KEY)
-    throw new Error("Configure the Jev API key in Account settings");
-  return provider;
-};
-var emptyScores = () => Object.fromEntries(import_jev4.JEV_DIMENSIONS.map((key) => [key, null]));
-var pending = /* @__PURE__ */ new Map();
-var pendingResponses = /* @__PURE__ */ new Map();
-var evaluateJevInput = async ({
-  input,
-  config,
-  userName,
-  projectRoot
-}) => {
-  config = (0, import_jev4.parseJevConfig)(config);
-  const inputHash = (0, import_jev5.jevHash)(input);
-  const questions = questionsForJevInput(input);
-  const questionsHash = (0, import_jev5.jevHash)(questions);
-  const base = {
-    questionSet: import_jev4.JEV_QUESTION_SET,
-    schema: "tradejs-signal-assessment/v5",
-    source: config.source,
-    mode: config.mode,
-    inputHash,
-    questionsHash,
-    geometryStatus: input.geometryStatus,
-    levelsValid: typeof input.features["signal.validLevels"] === "boolean" ? input.features["signal.validLevels"] : null
-  };
-  if (!input.questions.length)
-    return {
-      assessment: {
-        ...base,
-        status: "unavailable",
-        model: "",
-        scores: emptyScores(),
-        confidence: emptyScores()
-      }
-    };
-  if (config.source === "local") {
-    const contents = await import_promises.default.readFile(
-      import_node_path.default.resolve(projectRoot, config.modelFile),
-      "utf8"
-    );
-    if ((0, import_jev5.jevFileHash)(contents) !== config.modelSha256)
-      throw new Error("Local Jev gate checksum mismatch");
-    const { validateJevGateModel: validateJevGateModel2 } = await Promise.resolve().then(() => (init_jevTraining(), jevTraining_exports));
-    const model = validateJevGateModel2(JSON.parse(contents));
-    if (model.strategy !== input.strategy || model.questionsHash !== (0, import_jev5.jevHash)(JEV_QUESTIONS))
-      throw new Error("Local Jev gate strategy or question version mismatch");
-    const scores = Object.fromEntries(
-      import_jev4.JEV_DIMENSIONS.map((key) => [
-        key,
-        input.questions.includes(key) && model.trees[key] ? (0, import_jev4.predictJevTree)(model.trees[key], input.features) : null
-      ])
-    );
-    return {
-      assessment: {
-        ...base,
-        status: "available",
-        model: config.modelSha256,
-        scores,
-        confidence: emptyScores()
+// src/portfolio.ts
+var import_portfolio = require("@tradejs/core/portfolio");
+function createPortfolioCoordinator({
+  policy,
+  strategy,
+  store,
+  execution
+}) {
+  const fingerprint3 = (0, import_portfolio.portfolioFingerprint)(policy, strategy);
+  let cache;
+  async function transact(now2, change, force = false) {
+    for (let attempt = 0; attempt < 16; attempt++) {
+      const previous = await store.read();
+      if (previous && previous.fingerprint !== fingerprint3)
+        throw new Error(
+          "Portfolio policy changed under existing state; reconcile the persisted scope before changing configuration"
+        );
+      const base = previous ?? (0, import_portfolio.createPortfolioState)(fingerprint3);
+      const bucket = Math.floor(now2 / policy.observationIntervalMs);
+      const observation = !force && cache?.revision === base.revision && cache.bucket === bucket ? cache.observation : await execution.observe(now2, base.reservations);
+      const reconciled = (0, import_portfolio.reconcilePortfolio)(
+        policy,
+        strategy,
+        base,
+        observation
+      );
+      for (const intent of base.closing) {
+        if (!observation.positions.some(
+          (p) => p.symbol === intent.position.symbol
+        ))
+          await execution.confirmClosed?.(intent, observation.asOf);
       }
-    };
-  }
-  const provider = config.provider ?? await resolveJevProvider(userName);
-  const id = (0, import_jev5.jevHash)({ inputHash, questionsHash, provider });
-  const dir = import_node_path.default.resolve(projectRoot, config.recordsDir ?? "data/ai/jev");
-  const file = import_node_path.default.join(dir, "records", `${id}.json`);
-  const getRecord = async () => {
-    const existing = await (0, import_jev5.readJevArtifact)(file);
-    if (existing) {
-      if (existing.schema !== "tradejs-jev-record/v4" || existing.id !== id || existing.inputHash !== inputHash || existing.questionsHash !== questionsHash || (0, import_jev5.jevHash)(existing.input) !== inputHash || (0, import_jev5.jevHash)(existing.provider) !== (0, import_jev5.jevHash)(provider))
-        throw new Error("Jev recording identity mismatch");
-      (0, import_jev5.validateJevResponse)(existing.response, input.questions);
-      for (const key of import_jev4.JEV_DIMENSIONS) {
-        const expected = input.questions.includes(key) ? existing.response.answers[key].score / (0, import_jev5.jevScoreMaximum)(key) : null;
-        if (existing.scores[key] !== expected)
-          throw new Error("Jev recording scores do not match the response");
+      const changed = change(reconciled, observation);
+      const next = { ...changed.state, revision: base.revision + 1 };
+      if (await store.compare(previous, next)) {
+        cache = { revision: next.revision, bucket, observation };
+        return { state: next, observation, result: changed.result };
       }
-      return existing;
+      cache = void 0;
     }
-    if (config.source === "recorded")
-      throw new Error(
-        `Missing Jev recording ${id} for ${input.strategy} ${input.symbol} at ${new Date(input.timestamp).toISOString()}. Recorded mode requires the same signal-time facts and provider; a shorter backtest can change warm-up indicators or prior trade state.`
+    throw new Error("Portfolio state contention; entry was not submitted");
+  }
+  async function tick(now2, force = false) {
+    const claimed = await transact(
+      now2,
+      (state, observation) => {
+        const commands = (0, import_portfolio.portfolioCloseCommands)(policy, state, observation);
+        return {
+          state: {
+            ...state,
+            closing: state.closing.map(
+              (c) => commands.some((x) => x.intent.positionId === c.positionId) ? { ...c, lastAttemptAt: observation.asOf } : c
+            )
+          },
+          result: commands
+        };
+      },
+      force
+    );
+    for (const command of claimed.result)
+      await execution.close(
+        command.position,
+        command.intent,
+        claimed.observation.asOf
       );
-    const settings = await (0, import_userSettings.getUserSettings)(userName);
-    if (!settings.JEV_API_KEY)
-      throw new Error("Configure the Jev API key in Account settings");
-    const apiKey = settings.JEV_API_KEY;
-    const configuredProvider = await resolveJevProvider(userName);
-    if (configuredProvider.endpoint !== provider.endpoint)
-      throw new Error(
-        "Jev account endpoint changed; update the frozen provider configuration"
+    if (claimed.result.length) {
+      cache = void 0;
+      const refreshed = await transact(
+        now2,
+        (state) => ({ state, result: void 0 }),
+        true
+      );
+      return (0, import_portfolio.buildPortfolioContext)(
+        policy,
+        strategy,
+        refreshed.state,
+        refreshed.observation
       );
-    const started = Date.now();
-    const state = stateForJevInput(input);
-    const responseId = (0, import_jev5.jevHash)({
-      state,
-      questionsHash,
-      provider,
-      user: (0, import_jev5.jevHash)(userName)
-    });
-    const responseFile = import_node_path.default.join(dir, "responses", `${responseId}.json`);
-    let responsePromise = pendingResponses.get(responseFile);
-    if (!responsePromise) {
-      responsePromise = (async () => {
-        const saved = await (0, import_jev5.readJevArtifact)(responseFile);
-        if (saved) return (0, import_jev5.validateJevResponse)(saved, input.questions);
-        const fresh = await (0, import_jev5.requestJev)(provider, apiKey, state, questions);
-        await (0, import_jev5.writeJevArtifact)(responseFile, fresh);
-        return fresh;
-      })();
-      pendingResponses.set(responseFile, responsePromise);
-    }
-    let response;
-    try {
-      response = await responsePromise;
-    } finally {
-      pendingResponses.delete(responseFile);
     }
-    const scores = Object.fromEntries(
-      import_jev4.JEV_DIMENSIONS.map((key) => [
-        key,
-        input.questions.includes(key) ? response.answers[key].score / (0, import_jev5.jevScoreMaximum)(key) : null
-      ])
+    return (0, import_portfolio.buildPortfolioContext)(
+      policy,
+      strategy,
+      claimed.state,
+      claimed.observation
     );
-    const value = {
-      schema: "tradejs-jev-record/v4",
-      id,
-      inputHash,
-      questionsHash,
-      provider,
-      input,
-      response,
-      scores,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      elapsedMs: Date.now() - started
-    };
-    await (0, import_jev5.writeJevArtifact)(file, value);
-    return await (0, import_jev5.readJevArtifact)(file);
-  };
-  const pendingKey = `${file}:${(0, import_jev5.jevHash)(userName)}`;
-  let promise = pending.get(pendingKey);
-  if (!promise) {
-    promise = getRecord();
-    pending.set(pendingKey, promise);
   }
-  let record;
-  try {
-    record = await promise;
-  } finally {
-    pending.delete(pendingKey);
+  async function updateReservation(now2, id, submitted, qty) {
+    return transact(
+      now2,
+      (s, o) => {
+        const exists = s.reservations.some((r) => r.id === id);
+        const blocked = submitted && (!exists || s.closing.length > 0 || o.asOf <= s.blockedThrough);
+        return {
+          state: {
+            ...s,
+            reservations: s.reservations.flatMap(
+              (r) => r.id !== id ? [r] : submitted && !blocked ? [{ ...r, submitted: true, qty: qty ?? r.qty }] : []
+            )
+          },
+          result: !blocked
+        };
+      },
+      true
+    );
   }
   return {
-    record,
-    assessment: {
-      ...base,
-      status: "available",
-      recordId: id,
-      model: record.response.model,
-      scores: record.scores,
-      confidence: Object.fromEntries(
-        import_jev4.JEV_DIMENSIONS.map((key) => [
-          key,
-          record.response.answers[key]?.confidence ?? null
-        ])
-      )
+    async context(now2) {
+      const state = await store.read() ?? (0, import_portfolio.createPortfolioState)(fingerprint3);
+      if (state.fingerprint !== fingerprint3)
+        throw new Error("Portfolio policy changed under existing state");
+      const observation = await execution.observe(now2, state.reservations);
+      (0, import_portfolio.validatePortfolioObservation)(observation);
+      return (0, import_portfolio.buildPortfolioContext)(policy, strategy, state, observation);
+    },
+    tick,
+    async submit(now2, entry, send) {
+      await tick(now2);
+      const admitted = await transact(
+        now2,
+        (s, o) => {
+          const r = (0, import_portfolio.reservePortfolioEntry)(policy, strategy, s, o, {
+            ...entry,
+            submitted: false,
+            oppositeHandled: false
+          });
+          return { state: r.state, result: r.reason };
+        },
+        true
+      );
+      if (admitted.result) return { reason: admitted.result };
+      let submitted = false;
+      let retry = 0;
+      let attemptId = entry.id;
+      let needsReservation = false;
+      try {
+        const value = await send(
+          async (qty) => {
+            if (!Number.isFinite(qty) || qty <= 0)
+              throw new Error("Invalid submitted portfolio quantity");
+            if (needsReservation) {
+              attemptId = `${entry.id.slice(0, 30)}r${++retry}`;
+              const admission = await transact(
+                now2,
+                (s, o) => {
+                  const r = (0, import_portfolio.reservePortfolioEntry)(policy, strategy, s, o, {
+                    ...entry,
+                    id: attemptId,
+                    qty,
+                    submitted: true,
+                    oppositeHandled: false
+                  });
+                  return { state: r.state, result: r.reason };
+                },
+                true
+              );
+              if (admission.result) throw new Error(admission.result);
+              needsReservation = false;
+              submitted = true;
+              return attemptId;
+            }
+            const update = await updateReservation(now2, attemptId, true, qty);
+            if (!update.result)
+              throw new Error("PORTFOLIO_SUBMISSION_NO_LONGER_ADMITTED");
+            submitted = true;
+            return attemptId;
+          },
+          async (retrying = false) => {
+            await transact(
+              now2,
+              (s) => ({
+                state: {
+                  ...s,
+                  reservations: s.reservations.filter(
+                    (r) => r.id !== attemptId
+                  ),
+                  completedSignals: {
+                    ...Object.fromEntries(
+                      Object.entries(s.completedSignals).filter(
+                        ([id]) => !retrying || id !== entry.signalId
+                      )
+                    ),
+                    ...retrying ? {} : { [entry.signalId]: now2 }
+                  }
+                },
+                result: void 0
+              }),
+              true
+            );
+            submitted = false;
+            needsReservation = retrying;
+          }
+        );
+        if (!submitted) await updateReservation(now2, attemptId, false);
+        else await tick(now2, true);
+        return { value };
+      } catch (error) {
+        if (!submitted) await updateReservation(now2, attemptId, false);
+        throw error;
+      }
     }
   };
-};
-var assessSignalWithJev = async ({
-  signal,
-  config,
-  userName,
-  projectRoot,
-  strict,
-  scope = "runtime"
+}
+function createMemoryPortfolioStore() {
+  let state = null;
+  return {
+    read: async () => state === null ? null : structuredClone(state),
+    compare: async (expected, next) => {
+      if ((state?.revision ?? -1) !== (expected?.revision ?? -1)) return false;
+      state = structuredClone(next);
+      return true;
+    }
+  };
+}
+
+// src/runtimeJournal.ts
+var import_node_crypto = require("crypto");
+var import_constants3 = require("@tradejs/core/constants");
+var import_time3 = require("@tradejs/core/time");
+var import_trade = require("@tradejs/core/trade");
+var import_logger5 = require("@tradejs/infra/logger");
+var import_redis2 = require("@tradejs/infra/redis");
+var now = () => Date.now();
+var toRandomOrderSuffix = () => (0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 12).toLowerCase();
+var calculateClosedPnl = ({
+  direction,
+  entryPrice,
+  exitPrice,
+  qty
 }) => {
-  let assessment;
-  try {
-    const input = buildJevInput(signal);
-    ({ assessment } = await evaluateJevInput({
-      input,
-      config,
-      userName,
-      projectRoot
-    }));
-  } catch (error) {
-    if (strict) throw error;
-    assessment = {
-      questionSet: import_jev4.JEV_QUESTION_SET,
-      schema: "tradejs-signal-assessment/v5",
-      source: config.source,
-      mode: config.mode,
-      status: "unavailable",
-      inputHash: "",
-      questionsHash: "",
-      geometryStatus: "absent",
-      levelsValid: null,
-      model: config.provider?.model ?? config.modelSha256 ?? "",
-      scores: emptyScores(),
-      confidence: emptyScores()
-    };
-  }
-  signal.assessment = assessment;
-  signal.additionalIndicators = {
-    ...signal.additionalIndicators,
-    jev: (0, import_jev4.jevAssessmentFeatures)(assessment)
-  };
-  const identity = {
-    signalId: signal.signalId,
-    strategy: signal.strategy,
-    symbol: signal.symbol,
-    timestamp: signal.timestamp,
-    scope,
-    user: (0, import_jev5.jevHash)(userName),
-    config,
-    assessment
-  };
-  await (0, import_jev5.writeJevArtifact)(
-    import_node_path.default.resolve(
-      projectRoot,
-      config.recordsDir ?? "data/ai/jev",
-      "decisions",
-      `${(0, import_jev5.jevHash)(identity)}.json`
-    ),
-    identity
-  );
-  return assessment;
+  const pnl = direction === "LONG" ? (exitPrice - entryPrice) * qty : (entryPrice - exitPrice) * qty;
+  return Number.isFinite(pnl) ? pnl : null;
 };
-
-// src/strategyRuntime.ts
-var import_constants7 = require("@tradejs/core/constants");
-var import_strategies6 = require("@tradejs/core/strategies");
-var import_logger14 = require("@tradejs/infra/logger");
-
-// src/strategyHelpers/runtime.ts
-var import_logger12 = require("@tradejs/infra/logger");
-var import_constants5 = require("@tradejs/core/constants");
-var import_ml2 = require("@tradejs/infra/ml");
-
-// src/strategy/entrySubmissionValidation.ts
-var import_logger5 = require("@tradejs/infra/logger");
-
-// src/strategy/entryExecutionValidation.ts
-var EntrySubmissionValidationError = class extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "EntrySubmissionValidationError";
+var createRuntimeOrderId = (strategy) => {
+  const prefix = (0, import_trade.createRuntimeOrderLinkPrefix)(strategy);
+  if (prefix === "tjs-") {
+    return `tjs-${(0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 24).toLowerCase()}`;
   }
+  return `${prefix}${toRandomOrderSuffix()}`;
 };
-var resolveEntryExecutionLimits = (config, direction) => {
-  const side = config[direction];
-  const minimum = side && typeof side === "object" && "minRiskRatio" in side ? side.minRiskRatio : void 0;
-  const maximum = config.MAX_LOSS_VALUE;
-  if (minimum == null && maximum == null) return void 0;
-  const minimumNetRiskRatio = minimum == null ? void 0 : Number(minimum);
-  const maxLossValue = maximum == null ? void 0 : Number(maximum);
-  const feeRate = Number(config.RISK_FEE_RATE ?? 0);
-  const slippage = Number(config.RISK_SLIPPAGE_BPS ?? 0);
-  const impact = Number(config.RISK_MARKET_IMPACT_BPS ?? 0);
-  const slippageBps = slippage + impact;
-  if (minimumNetRiskRatio != null && (!Number.isFinite(minimumNetRiskRatio) || minimumNetRiskRatio < 0) || maxLossValue != null && (!Number.isFinite(maxLossValue) || maxLossValue <= 0) || !Number.isFinite(feeRate) || feeRate < 0 || feeRate >= 1 || !Number.isFinite(slippage) || slippage < 0 || !Number.isFinite(impact) || impact < 0 || !Number.isFinite(slippageBps) || slippageBps < 0 || slippageBps >= 1e4)
-    throw new Error("INVALID_ENTRY_EXECUTION_LIMITS");
-  return { minimumNetRiskRatio, maxLossValue, feeRate, slippageBps };
-};
-var validateEntryExecution = ({
-  direction,
-  price,
-  qty,
-  stopLossPrice,
-  takeProfitPrice,
-  limits
-}) => {
-  if (!Number.isFinite(price) || price <= 0 || !Number.isFinite(qty) || qty <= 0 || stopLossPrice == null || !Number.isFinite(stopLossPrice) || stopLossPrice <= 0 || !Number.isFinite(takeProfitPrice) || takeProfitPrice <= 0)
-    throw new EntrySubmissionValidationError(
-      "ENTRY_ECONOMICS_INPUTS_UNAVAILABLE"
-    );
-  const side = direction === "LONG" ? 1 : -1;
-  if (side * (price - stopLossPrice) <= 0 || side * (takeProfitPrice - price) <= 0)
-    throw new EntrySubmissionValidationError(
-      "INVALID_ENTRY_PROTECTION_AT_SUBMISSION"
-    );
-  const slippage = limits.slippageBps / 1e4;
-  const cost = (value, sign) => value * slippage + value * (1 + sign * slippage) * limits.feeRate;
-  const entryCost = cost(price, side);
-  const lossPerUnit = Math.abs(price - stopLossPrice) + entryCost + cost(stopLossPrice, -side);
-  const rewardPerUnit = Math.max(
-    0,
-    Math.abs(takeProfitPrice - price) - entryCost - cost(takeProfitPrice, -side)
-  );
-  const netRiskRatio = rewardPerUnit / lossPerUnit;
-  const plannedLossValue = qty * lossPerUnit;
-  if (!Number.isFinite(netRiskRatio) || !Number.isFinite(plannedLossValue))
-    throw new EntrySubmissionValidationError(
-      "ENTRY_ECONOMICS_INPUTS_UNAVAILABLE"
-    );
-  if (limits.minimumNetRiskRatio != null && netRiskRatio <= limits.minimumNetRiskRatio)
-    throw new EntrySubmissionValidationError(
-      "ENTRY_RR_BELOW_MIN_AT_SUBMISSION"
+var recordRuntimeTradeOpen = async (params) => {
+  const { userName } = params;
+  if (!userName) {
+    return null;
+  }
+  const record = {
+    ...params,
+    entryCount: 1,
+    lastEntryPrice: params.entryPrice,
+    lastEntryQty: params.qty,
+    lastEntryTimestamp: params.entryTimestamp,
+    status: "active",
+    currentPrice: params.entryPrice,
+    currentPnl: 0,
+    closedPnl: null,
+    exitPrice: null,
+    exitTimestamp: null,
+    lastSyncedAt: now()
+  };
+  const dayKey = (0, import_time3.getRuntimeStorageDayKey)(record.entryTimestamp);
+  const runtimeScopeId = record.deploymentId ?? record.accountId;
+  try {
+    await Promise.all([
+      (0, import_redis2.setData)(import_redis2.redisKeys.runtimeTrade(userName, record.orderId), record, {
+        expire: 0
+      }),
+      (0, import_redis2.setHashJsonField)(
+        import_redis2.redisKeys.runtimeTradeBucket(userName, dayKey),
+        record.orderId,
+        record,
+        { expire: 0 }
+      ),
+      (0, import_redis2.setData)(
+        import_redis2.redisKeys.runtimeActiveTrade(userName, record.symbol, runtimeScopeId),
+        { orderId: record.orderId },
+        { expire: 0 }
+      )
+    ]);
+  } catch (error) {
+    import_logger5.logger.error(
+      "runtime trade open journal failed: %s %s",
+      record.symbol,
+      error?.message || String(error)
     );
-  const riskExceeded = limits.maxLossValue != null && plannedLossValue > limits.maxLossValue * (1 + 1e-9);
-  return { netRiskRatio, plannedLossValue, riskExceeded };
+  }
+  return record;
 };
-
-// src/strategy/entrySubmissionValidation.ts
-var MAX_ENTRY_QUOTE_AGE_MS = 5e3;
-var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
-var getOrderArrivalSnapshot = async ({
-  connector,
-  symbol,
-  requireTimestamp = false
-}) => {
-  if (typeof connector.getTopOfBookTicker !== "function") {
-    return {
-      arrivalSnapshotTime: Date.now(),
-      arrivalSource: "unavailable",
-      bid: null,
-      ask: null,
-      arrivalMid: null,
-      spreadBps: null
-    };
+var recordRuntimeTradeIncrease = async (params) => {
+  const {
+    userName,
+    strategy,
+    symbol,
+    direction,
+    resultingQty,
+    resultingEntryPrice,
+    addedQty,
+    addedEntryPrice,
+    entryTimestamp,
+    fee,
+    accountId,
+    deploymentId
+  } = params;
+  if (!userName) {
+    return null;
+  }
+  const existing = await getActiveRuntimeTrade({
+    userName,
+    symbol,
+    accountId,
+    deploymentId
+  });
+  if (!existing || existing.strategy !== strategy || existing.direction !== direction) {
+    return null;
   }
+  const addedFee = typeof fee === "number" && Number.isFinite(fee) ? fee : 0;
+  const openFee = (existing.openFee ?? existing.fee ?? 0) + addedFee;
+  const totalFee = (existing.totalFee ?? existing.fee ?? 0) + addedFee;
+  const next = {
+    ...existing,
+    ...params.orderLeverage ? { orderLeverage: params.orderLeverage } : {},
+    qty: resultingQty,
+    entryPrice: resultingEntryPrice,
+    entryCount: Math.max(1, existing.entryCount ?? 1) + 1,
+    lastEntryPrice: addedEntryPrice,
+    lastEntryQty: addedQty,
+    lastEntryTimestamp: entryTimestamp,
+    currentPrice: resultingEntryPrice,
+    currentPnl: 0,
+    fee: openFee,
+    openFee,
+    totalFee,
+    lastSyncedAt: now()
+  };
+  const dayKey = (0, import_time3.getRuntimeStorageDayKey)(existing.entryTimestamp);
   try {
-    const ticker = await connector.getTopOfBookTicker(symbol);
-    const arrivalSnapshotTime = toFiniteNumberOrNull(ticker?.timestamp);
-    const timestampUnavailable = requireTimestamp && arrivalSnapshotTime == null;
-    const bid = timestampUnavailable ? null : toFiniteNumberOrNull(ticker?.bidPrice);
-    const ask = timestampUnavailable ? null : toFiniteNumberOrNull(ticker?.askPrice);
-    const arrivalMid = bid != null && ask != null ? (bid + ask) / 2 : null;
-    const spreadBps = bid != null && ask != null && arrivalMid != null && arrivalMid > 0 ? (ask - bid) / arrivalMid * 1e4 : null;
-    return {
-      arrivalSnapshotTime: arrivalSnapshotTime ?? Date.now(),
-      arrivalSource: "top_of_book",
-      bid,
-      ask,
-      arrivalMid,
-      spreadBps
-    };
+    await Promise.all([
+      (0, import_redis2.setData)(import_redis2.redisKeys.runtimeTrade(userName, existing.orderId), next, {
+        expire: 0
+      }),
+      (0, import_redis2.setHashJsonField)(
+        import_redis2.redisKeys.runtimeTradeBucket(userName, dayKey),
+        existing.orderId,
+        next,
+        { expire: 0 }
+      )
+    ]);
   } catch (error) {
-    import_logger5.logger.warn(
-      "runtime order arrival snapshot failed: %s %s",
+    import_logger5.logger.error(
+      "runtime trade increase journal failed: %s %s",
       symbol,
       error?.message || String(error)
     );
-    return {
-      arrivalSnapshotTime: Date.now(),
-      arrivalSource: "top_of_book_error",
-      bid: null,
-      ask: null,
-      arrivalMid: null,
-      spreadBps: null
-    };
   }
+  return next;
 };
-var validateEntryProtectionAtArrival = ({
-  direction,
-  signalPrice,
-  bid,
-  ask,
-  arrivalMid,
-  takeProfits,
-  stopLossPrice
-}) => {
-  const entryReference = direction === "LONG" ? ask ?? arrivalMid ?? signalPrice : bid ?? arrivalMid ?? signalPrice;
-  const stopReference = direction === "LONG" ? bid ?? arrivalMid ?? signalPrice : ask ?? arrivalMid ?? signalPrice;
-  if (!Number.isFinite(entryReference) || entryReference <= 0 || !Number.isFinite(stopReference) || stopReference <= 0) {
-    throw new Error("INVALID_ENTRY_REFERENCE_AT_ARRIVAL");
-  }
-  for (const takeProfit of takeProfits) {
-    if (!Number.isFinite(takeProfit.price) || takeProfit.price <= 0 || (direction === "LONG" ? takeProfit.price <= entryReference : takeProfit.price >= entryReference)) {
-      throw new Error("TAKE_PROFIT_CROSSED_BEFORE_ENTRY");
-    }
-  }
-  if (stopLossPrice != null && (!Number.isFinite(stopLossPrice) || stopLossPrice <= 0 || (direction === "LONG" ? stopLossPrice >= stopReference : stopLossPrice <= stopReference))) {
-    throw new Error("STOP_LOSS_CROSSED_BEFORE_ENTRY");
+var getActiveRuntimeTrade = async (params) => {
+  const { userName, symbol, accountId, deploymentId } = params;
+  if (!userName) {
+    return null;
   }
-};
-var createEntrySubmissionValidation = ({
-  connector,
-  symbol,
-  direction,
-  takeProfits,
-  stopLossPrice,
-  limits,
-  onValidated
-}) => {
-  if (!limits) return void 0;
-  if (!connector.capabilities?.orderSubmissionValidation)
-    throw new EntrySubmissionValidationError(
-      "ENTRY_SUBMISSION_VALIDATION_UNSUPPORTED"
-    );
-  return async ({ qty, executionPrice }) => {
-    const simulated = Reflect.get(connector, "__tradejsTestConnector") === true;
-    const snapshot2 = simulated && executionPrice != null ? {
-      arrivalSnapshotTime: Date.now(),
-      arrivalSource: "simulation",
-      bid: executionPrice,
-      ask: executionPrice,
-      arrivalMid: executionPrice,
-      spreadBps: 0
-    } : await getOrderArrivalSnapshot({
-      connector,
-      symbol,
-      requireTimestamp: true
-    });
-    const age = Date.now() - snapshot2.arrivalSnapshotTime;
-    if (snapshot2.bid == null || snapshot2.ask == null || !Number.isFinite(snapshot2.bid) || !Number.isFinite(snapshot2.ask) || snapshot2.bid <= 0 || snapshot2.ask < snapshot2.bid)
-      throw new EntrySubmissionValidationError(
-        "ENTRY_QUOTE_UNAVAILABLE_AT_SUBMISSION"
-      );
-    if (!Number.isFinite(age) || age < -MAX_ENTRY_QUOTE_AGE_MS || age > MAX_ENTRY_QUOTE_AGE_MS)
-      throw new EntrySubmissionValidationError(
-        "ENTRY_QUOTE_STALE_AT_SUBMISSION"
-      );
-    const price = direction === "LONG" ? snapshot2.ask : snapshot2.bid;
-    validateEntryProtectionAtArrival({
-      direction,
-      signalPrice: price,
-      bid: snapshot2.bid,
-      ask: snapshot2.ask,
-      arrivalMid: snapshot2.arrivalMid,
-      takeProfits,
-      stopLossPrice
-    });
-    const prices = takeProfits.map((tp) => tp.price);
-    const economics2 = validateEntryExecution({
-      direction,
-      price,
-      qty,
-      stopLossPrice,
-      takeProfitPrice: direction === "LONG" ? Math.max(...prices) : Math.min(...prices),
-      limits
-    });
-    onValidated?.(snapshot2, economics2);
-  };
-};
-
-// src/ai.ts
-var import_aiLanguages2 = require("@tradejs/core/aiLanguages");
-var import_redis2 = require("@tradejs/infra/redis");
-
-// src/aiShared.ts
-var MAX_AI_SERIES_POINTS = 5;
-var COMPACT_INDICATORS_SNAPSHOT_SYMBOL = /* @__PURE__ */ Symbol.for(
-  "tradejs.indicators.compactSnapshot"
-);
-var COMPACT_INDICATORS_SNAPSHOT_KEY = "__tradejsCompactIndicatorsSnapshot";
-var trimSeriesDeep = (value) => {
-  if (Array.isArray(value)) {
-    const trimmed = value.slice(-MAX_AI_SERIES_POINTS);
-    const isMatrix = trimmed.every((item) => Array.isArray(item));
-    if (isMatrix) {
-      return trimmed;
-    }
-    return trimmed.map(
-      (item) => item && typeof item === "object" ? trimSeriesDeep(item) : item
-    );
+  const activeRef = await (0, import_redis2.getData)(
+    import_redis2.redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId),
+    null
+  );
+  const orderId = String(activeRef?.orderId || "").trim();
+  if (!orderId) {
+    return null;
   }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, nested]) => [
-        key,
-        trimSeriesDeep(nested)
-      ])
+  const existing = await (0, import_redis2.getData)(
+    import_redis2.redisKeys.runtimeTrade(userName, orderId),
+    null
+  );
+  if (!existing || existing.status !== "active") {
+    await (0, import_redis2.delKey)(
+      import_redis2.redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId)
     );
+    return null;
   }
-  return value;
+  return existing;
 };
-var buildCompactAiIndicatorsSnapshot = (value) => {
-  const compactSnapshot = value && typeof value === "object" ? value[COMPACT_INDICATORS_SNAPSHOT_SYMBOL] ?? value[COMPACT_INDICATORS_SNAPSHOT_KEY] : void 0;
-  if (typeof compactSnapshot === "function") {
-    return compactSnapshot({ limit: MAX_AI_SERIES_POINTS });
+var markRuntimeTradeClosed = async (params) => {
+  const {
+    userName,
+    expectedOrderId,
+    symbol,
+    strategy,
+    exitPrice,
+    exitTimestamp,
+    closedPnl,
+    exitType,
+    accountId,
+    deploymentId
+  } = params;
+  if (!userName) {
+    return null;
   }
-  return trimSeriesDeep(value);
-};
-
-// src/aiMarketContext.ts
-var toRecord = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
+  const existing = expectedOrderId ? await (0, import_redis2.getDataStrict)(
+    import_redis2.redisKeys.runtimeTrade(userName, expectedOrderId)
+  ) : await getActiveRuntimeTrade({
+    userName,
+    symbol,
+    accountId,
+    deploymentId
+  });
+  if (!existing || expectedOrderId && existing.orderId !== expectedOrderId) {
     return null;
   }
-  return value;
-};
-var toFiniteNumber = (value) => {
-  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
-  return Number.isFinite(numeric) ? numeric : null;
-};
-var roundTo = (value, decimals) => {
-  const factor = 10 ** decimals;
-  return Math.round(value * factor) / factor;
-};
-var buildMissingSpreadContext = () => ({
-  source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
-  indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
-  available: false,
-  value: null,
-  zScore: null,
-  bps: null,
-  absBps: null,
-  bias: null,
-  severity: null
-});
-var buildSpreadContextFromSignal = (signal) => {
-  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const execution = toRecord(relative?.execution);
-  const spread = toFiniteNumber(execution?.venueSpread);
-  const zScore = toFiniteNumber(execution?.venueSpreadZScore);
-  if (spread == null) {
-    return buildMissingSpreadContext();
+  const orderId = existing.orderId;
+  if (strategy && existing.strategy !== strategy) {
+    return null;
   }
-  const value = roundTo(spread, 8);
-  const bps = roundTo(value * 1e4, 2);
-  const absBps = Math.abs(bps);
-  const bias = absBps < 1 ? "flat" : bps > 0 ? "coinbase_premium" : "binance_premium";
-  const severity = absBps >= 20 ? "wide" : absBps >= 5 ? "elevated" : "normal";
-  return {
-    source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
-    indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
-    available: true,
-    value,
-    zScore,
-    bps,
-    absBps,
-    bias,
-    severity
+  const resolvedExitPrice = typeof exitPrice === "number" && Number.isFinite(exitPrice) ? exitPrice : existing.currentPrice ?? existing.entryPrice;
+  const resolvedClosedPnl = typeof closedPnl === "number" && Number.isFinite(closedPnl) ? closedPnl : typeof resolvedExitPrice === "number" && Number.isFinite(resolvedExitPrice) ? calculateClosedPnl({
+    direction: existing.direction,
+    entryPrice: existing.entryPrice,
+    exitPrice: resolvedExitPrice,
+    qty: existing.qty
+  }) : existing.closedPnl ?? existing.currentPnl ?? null;
+  const next = expectedOrderId && existing.status === "closed" ? existing : {
+    ...existing,
+    status: "closed",
+    currentPrice: resolvedExitPrice,
+    currentPnl: resolvedClosedPnl,
+    closedPnl: resolvedClosedPnl,
+    exitPrice: resolvedExitPrice,
+    exitTimestamp: typeof exitTimestamp === "number" && Number.isFinite(exitTimestamp) ? exitTimestamp : now(),
+    exitType: exitType ?? existing.exitType ?? null,
+    lastSyncedAt: now()
   };
+  const dayKey = (0, import_time3.getRuntimeStorageDayKey)(existing.entryTimestamp);
+  const closeDayKey = (0, import_time3.getRuntimeStorageDayKey)(next.exitTimestamp);
+  try {
+    await Promise.all([
+      (expectedOrderId ? import_redis2.setDataStrict : import_redis2.setData)(
+        import_redis2.redisKeys.runtimeTrade(userName, orderId),
+        next,
+        {
+          expire: import_constants3.TTL_1M
+        }
+      ),
+      (expectedOrderId ? import_redis2.setHashJsonFieldStrict : import_redis2.setHashJsonField)(
+        import_redis2.redisKeys.runtimeTradeBucket(userName, dayKey),
+        orderId,
+        next,
+        { expire: import_constants3.TTL_1M }
+      ),
+      (expectedOrderId ? import_redis2.setHashJsonFieldStrict : import_redis2.setHashJsonField)(
+        import_redis2.redisKeys.runtimeClosedTradeBucket(userName, closeDayKey),
+        orderId,
+        next,
+        { expire: import_constants3.TTL_1M }
+      ),
+      expectedOrderId ? (0, import_redis2.deleteRuntimeTradeReference)(
+        import_redis2.redisKeys.runtimeActiveTrade(
+          userName,
+          symbol,
+          deploymentId ?? accountId
+        ),
+        expectedOrderId
+      ) : (0, import_redis2.delKey)(
+        import_redis2.redisKeys.runtimeActiveTrade(
+          userName,
+          symbol,
+          deploymentId ?? accountId
+        )
+      )
+    ]);
+  } catch (error) {
+    if (expectedOrderId) throw error;
+    import_logger5.logger.error(
+      "runtime trade close journal failed: %s %s",
+      symbol,
+      error?.message || String(error)
+    );
+  }
+  return next;
 };
-var buildTrueDeltaContextFromSignal = (signal) => {
-  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const participation = toRecord(baseContext?.participation);
-  const delta = toRecord(participation?.delta);
-  const source = String(delta?.source ?? "");
-  const isTrueDeltaSource = source === "kline_taker_volume" || source === "agg_trades" || source === "trades";
-  if (!delta || !isTrueDeltaSource) {
-    return {
-      source: source || null,
-      available: false,
-      buyPressurePct: null,
-      buyVolume: null,
-      sellVolume: null,
-      netDelta: null,
-      deltaPct: null,
-      signedVolumeZScore: null
-    };
-  }
+
+// src/strategy/portfolioRuntime.ts
+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 fact2 = await connector.getEntryOrderObservation({
+          symbol: r.symbol,
+          orderId: r.id
+        });
+        if (fact2) return fact2;
+      }
+      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 {
-    source,
-    available: true,
-    buyPressurePct: toFiniteNumber(delta.buyPressurePct),
-    buyVolume: toFiniteNumber(delta.buyVolume),
-    sellVolume: toFiniteNumber(delta.sellVolume),
-    netDelta: toFiniteNumber(delta.netDelta),
-    deltaPct: toFiniteNumber(delta.deltaPct),
-    signedVolumeZScore: toFiniteNumber(delta.signedVolumeZScore)
+    async read() {
+      const value = await import_redis3.portfolioStateStorage.read(key);
+      if (value === null) return null;
+      const state = JSON.parse(value);
+      (0, import_portfolio2.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 import_redis3.portfolioStateStorage.compare(key, expected, JSON.stringify(next));
+    }
   };
-};
-var buildTradeFlowContextFromSignal = (signal) => {
-  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const participation = toRecord(baseContext?.participation);
-  const tradeFlow = toRecord(participation?.tradeFlow);
-  if (!tradeFlow) {
-    return {
-      source: null,
-      available: false,
-      interval: null,
-      stale: null,
-      trades: null,
-      buyPressurePct: null,
-      netBaseDelta: null,
-      netQuoteDelta: null
-    };
-  }
-  return {
-    source: String(tradeFlow.source ?? ""),
-    available: true,
-    interval: String(tradeFlow.interval ?? ""),
-    stale: typeof tradeFlow.stale === "boolean" ? tradeFlow.stale : null,
-    trades: toFiniteNumber(tradeFlow.trades),
-    buyPressurePct: toFiniteNumber(tradeFlow.buyPressurePct),
-    netBaseDelta: toFiniteNumber(tradeFlow.netBaseDelta),
-    netQuoteDelta: toFiniteNumber(tradeFlow.netQuoteDelta)
+}
+function getPortfolioRuntime({
+  value,
+  connectorName,
+  strategy,
+  connector,
+  env,
+  userName,
+  accountId,
+  deploymentId,
+  symbol,
+  canClose
+}) {
+  const policy = (0, import_portfolio2.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
   };
-};
-var buildMarketBreadthContextFromSignal = (signal) => {
-  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const breadth = toRecord(relative?.marketBreadth);
-  if (!breadth) {
-    return {
-      source: null,
-      available: false,
-      universe: null,
-      interval: null,
-      stale: null,
-      symbolsCount: null,
-      advanceDeclineRatio: null,
-      pctAboveMa20: null,
-      pctAboveMa50: null,
-      equalWeightedReturn: null,
-      volumeWeightedReturn: null,
-      dispersion: null
-    };
+  const scope = policy.scope === "strategy" ? strategy : policy.scope === "account" ? "account" : [...policy.scope.strategies].sort();
+  const key = (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify([binding, connectorName, connector.universe, scope])).digest("hex");
+  const fingerprint3 = (0, import_portfolio2.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");
+    if (symbol && canClose)
+      existing.permissions.set(JSON.stringify([strategy, symbol]), canClose);
+    return existing.coordinator;
+  }
+  const permissions = /* @__PURE__ */ new Map();
+  if (symbol && canClose)
+    permissions.set(JSON.stringify([strategy, symbol]), canClose);
+  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) {
+        const permission = permissions.get(
+          JSON.stringify([position.strategy, position.symbol])
+        );
+        if (!permission || !await permission(position, intent, asOf)) return;
+        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, permissions });
+  return coordinator;
+}
+
+// src/strategyHelpers/tickerProfiles.ts
+var import_tickerProfiles = require("@tradejs/infra/tickerProfiles");
+var import_tickerProfiles2 = require("@tradejs/core/tickerProfiles");
+
+// src/strategy/manifests.ts
+var import_indicators = require("@tradejs/core/indicators");
+var SHARED_STRATEGY_REGISTRY_KEY = "__tradejsNodeSharedStrategyRegistryV1__";
+var sharedRegistryScope = globalThis;
+var sharedStrategyRegistry = sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] ?? (sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] = {
+  registryStateByProjectRoot: /* @__PURE__ */ new Map()
+});
+var createStrategyRegistryState = () => ({
+  strategyCreators: /* @__PURE__ */ new Map(),
+  strategyManifestsMap: /* @__PURE__ */ new Map(),
+  strategyEntriesMap: /* @__PURE__ */ new Map(),
+  strategySourcesMap: /* @__PURE__ */ new Map(),
+  strategyModuleResolutions: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot2 = sharedStrategyRegistry.registryStateByProjectRoot;
+var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot2.get(projectRoot);
+  if (!state) {
+    state = createStrategyRegistryState();
+    registryStateByProjectRoot2.set(projectRoot, state);
   }
   return {
-    source: String(breadth.source ?? ""),
-    available: true,
-    universe: String(breadth.universe ?? ""),
-    interval: String(breadth.interval ?? ""),
-    stale: typeof breadth.stale === "boolean" ? breadth.stale : null,
-    symbolsCount: toFiniteNumber(breadth.symbolsCount),
-    advanceDeclineRatio: toFiniteNumber(breadth.advanceDeclineRatio),
-    pctAboveMa20: toFiniteNumber(breadth.pctAboveMa20),
-    pctAboveMa50: toFiniteNumber(breadth.pctAboveMa50),
-    equalWeightedReturn: toFiniteNumber(breadth.equalWeightedReturn),
-    volumeWeightedReturn: toFiniteNumber(breadth.volumeWeightedReturn),
-    dispersion: toFiniteNumber(breadth.dispersion)
+    projectRoot,
+    state
   };
 };
-var buildMarketBreadthsContextFromSignal = (signal) => {
-  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const breadths = toRecord(relative?.marketBreadths);
-  const build = (key) => {
-    const breadth = toRecord(breadths?.[key]);
-    if (!breadth) {
-      return {
-        source: null,
-        available: false,
-        universe: null,
-        interval: null,
-        stale: null,
-        symbolsCount: null,
-        advanceDeclineRatio: null,
-        pctAboveMa20: null,
-        pctAboveMa50: null,
-        equalWeightedReturn: null,
-        volumeWeightedReturn: null,
-        dispersion: null
-      };
-    }
-    return {
-      source: String(breadth.source ?? ""),
-      available: true,
-      universe: String(breadth.universe ?? ""),
-      interval: String(breadth.interval ?? ""),
-      stale: typeof breadth.stale === "boolean" ? breadth.stale : null,
-      symbolsCount: toFiniteNumber(breadth.symbolsCount),
-      advanceDeclineRatio: toFiniteNumber(breadth.advanceDeclineRatio),
-      pctAboveMa20: toFiniteNumber(breadth.pctAboveMa20),
-      pctAboveMa50: toFiniteNumber(breadth.pctAboveMa50),
-      equalWeightedReturn: toFiniteNumber(breadth.equalWeightedReturn),
-      volumeWeightedReturn: toFiniteNumber(breadth.volumeWeightedReturn),
-      dispersion: toFiniteNumber(breadth.dispersion)
-    };
-  };
+var toUniqueModules2 = (modules = []) => [
+  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
+];
+var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
   return {
-    top5: build("top5"),
-    top10: build("top10"),
-    top30: build("top30"),
-    top50: build("top50"),
-    top100: build("top100")
+    strategyModules: toUniqueModules2(config.strategies),
+    indicatorModules: toUniqueModules2(config.indicators)
   };
 };
-var buildTargetVsBtcContextFromSignal = (signal) => {
-  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const targetVsBtc = toRecord(relative?.targetVsBtc);
-  if (!targetVsBtc) {
-    return {
-      source: null,
-      available: false,
-      ratioReturn1h: null,
-      ratioReturn4h: null,
-      ratioReturn24h: null,
-      alphaVsBtc1h: null,
-      alphaVsBtc4h: null,
-      alphaVsBtc24h: null,
-      betaToBtc20: null,
-      correlationToBtc20: null,
-      ratioTrend: null
-    };
+var extractModuleEntries = (moduleExport, key) => {
+  if (!moduleExport || typeof moduleExport !== "object") {
+    return null;
   }
-  return {
-    source: String(targetVsBtc.source ?? ""),
-    available: true,
-    ratioReturn1h: toFiniteNumber(targetVsBtc.ratioReturn1h),
-    ratioReturn4h: toFiniteNumber(targetVsBtc.ratioReturn4h),
-    ratioReturn24h: toFiniteNumber(targetVsBtc.ratioReturn24h),
-    alphaVsBtc1h: toFiniteNumber(targetVsBtc.alphaVsBtc1h),
-    alphaVsBtc4h: toFiniteNumber(targetVsBtc.alphaVsBtc4h),
-    alphaVsBtc24h: toFiniteNumber(targetVsBtc.alphaVsBtc24h),
-    betaToBtc20: toFiniteNumber(targetVsBtc.betaToBtc20),
-    correlationToBtc20: toFiniteNumber(targetVsBtc.correlationToBtc20),
-    ratioTrend: typeof targetVsBtc.ratioTrend === "string" ? targetVsBtc.ratioTrend : null
-  };
-};
-var buildBtcAltRegimeContextFromSignal = (signal) => {
-  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const btcAltRegime = toRecord(relative?.btcAltRegime);
-  if (!btcAltRegime) {
-    return {
-      source: null,
-      available: false,
-      universe: null,
-      interval: null,
-      stale: null,
-      regime: null,
-      btcReturn24h: null,
-      altBasketReturn24h: null,
-      btcVsAltReturn24h: null,
-      btcTurnoverShare24h: null,
-      btcTurnoverShareChange24h: null,
-      altVolToBtcVol24h: null,
-      altDispersion24h: null
-    };
+  const candidate = moduleExport;
+  if (Array.isArray(candidate[key])) {
+    return candidate[key];
   }
-  return {
-    source: String(btcAltRegime.source ?? ""),
-    available: true,
-    universe: String(btcAltRegime.universe ?? ""),
-    interval: String(btcAltRegime.interval ?? ""),
-    stale: typeof btcAltRegime.stale === "boolean" ? btcAltRegime.stale : null,
-    regime: typeof btcAltRegime.regime === "string" ? btcAltRegime.regime : null,
-    btcReturn24h: toFiniteNumber(btcAltRegime.btcReturn24h),
-    altBasketReturn24h: toFiniteNumber(btcAltRegime.altBasketReturn24h),
-    btcVsAltReturn24h: toFiniteNumber(btcAltRegime.btcVsAltReturn24h),
-    btcTurnoverShare24h: toFiniteNumber(btcAltRegime.btcTurnoverShare24h),
-    btcTurnoverShareChange24h: toFiniteNumber(
-      btcAltRegime.btcTurnoverShareChange24h
-    ),
-    altVolToBtcVol24h: toFiniteNumber(btcAltRegime.altVolToBtcVol24h),
-    altDispersion24h: toFiniteNumber(btcAltRegime.altDispersion24h)
-  };
+  const defaultExport = candidate.default;
+  if (defaultExport && Array.isArray(defaultExport[key])) {
+    return defaultExport[key];
+  }
+  return null;
 };
-var buildCmcGlobalContextFromSignal = (signal) => {
-  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const cmcGlobal = toRecord(relative?.cmcGlobal);
-  if (!cmcGlobal) {
-    return {
-      source: null,
-      available: false,
-      interval: null,
-      asOfTs: null,
-      stale: null,
-      totalMarketCapUsd: null,
-      totalVolumeUsd: null,
-      totalVolumeReportedUsd: null,
-      altMarketCapUsd: null,
-      altVolumeUsd: null,
-      altVolumeReportedUsd: null,
-      btcDominancePct: null,
-      ethDominancePct: null,
-      btcDominanceChange24hPct: null,
-      ethDominanceChange24hPct: null,
-      altMarketCapChange24hPct: null,
-      altVolumeChange24hPct: null,
-      activeCryptocurrencies: null,
-      activeExchanges: null,
-      activeMarketPairs: null,
-      altLiquidityRegime: null
+var extractStrategyPluginDefinition = (moduleExport) => {
+  const strategyEntries = extractModuleEntries(
+    moduleExport,
+    "strategyEntries"
+  );
+  return strategyEntries ? { strategyEntries } : null;
+};
+var extractIndicatorPluginDefinition = (moduleExport) => {
+  const indicatorEntries = extractModuleEntries(
+    moduleExport,
+    "indicatorEntries"
+  );
+  return indicatorEntries ? { indicatorEntries } : null;
+};
+var validateStrategyEntries = (moduleName, entries, state) => {
+  const issues = [];
+  const names = /* @__PURE__ */ new Set();
+  entries.forEach((entry, index) => {
+    const entryPath = `${moduleName}.strategyEntries[${index}]`;
+    const strategyName = entry?.manifest?.name;
+    if (typeof strategyName !== "string" || !strategyName.trim()) {
+      issues.push(`${entryPath}: manifest.name is required`);
+    } else if (names.has(strategyName) || state?.strategyEntriesMap.has(strategyName)) {
+      issues.push(`${entryPath}: duplicate strategy ${strategyName}`);
+    } else {
+      names.add(strategyName);
+    }
+    if (!entry || typeof entry !== "object" || !entry.defaults || typeof entry.defaults !== "object" || Array.isArray(entry.defaults)) {
+      issues.push(`${entryPath}: defaults must be an object`);
+    }
+    if (typeof entry?.parseConfig !== "function") {
+      issues.push(`${entryPath}: parseConfig is required`);
+    }
+    if (typeof entry?.createCore !== "function") {
+      issues.push(`${entryPath}: createCore is required`);
+    }
+  });
+  return issues;
+};
+var registerEntries2 = (entries, source, state) => {
+  for (const entry of entries) {
+    const strategyName = entry.manifest.name;
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
+    state.strategyEntriesMap.set(strategyName, entry);
+    state.strategySourcesMap.set(strategyName, source);
+    materializeStrategyCreator(strategyName, state);
+  }
+};
+var materializeStrategyCreator = (strategyName, state) => {
+  if (state.strategyCreators.has(strategyName) || !sharedStrategyRegistry.strategyRuntimeFactory) {
+    return;
+  }
+  const entry = state.strategyEntriesMap.get(strategyName);
+  if (!entry) return;
+  state.strategyCreators.set(
+    strategyName,
+    sharedStrategyRegistry.strategyRuntimeFactory({
+      strategyName,
+      defaults: entry.defaults,
+      createCore: entry.createCore,
+      manifest: entry.manifest,
+      detectorKey: entry.detectorKey,
+      detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
+      resolveRegisteredManifest: (name) => state.strategyManifestsMap.get(name)
+    })
+  );
+};
+var setStrategyRuntimeFactory = (factory) => {
+  sharedStrategyRegistry.strategyRuntimeFactory = factory;
+  for (const state of registryStateByProjectRoot2.values()) {
+    for (const strategyName of state.strategyEntriesMap.keys()) {
+      materializeStrategyCreator(strategyName, state);
+    }
+  }
+};
+var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName, cwd);
+  }
+  return import(
+    /* webpackIgnore: true */
+    moduleName
+  );
+};
+var resolveStrategyModuleEntry = async ({
+  strategyName,
+  moduleName,
+  cwd
+}) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  const source = moduleName.trim();
+  const resolvedModuleName = resolvePluginModuleSpecifier(source, projectRoot);
+  const cacheKey = `${resolvedModuleName}\0${strategyName}`;
+  const cached = state.strategyModuleResolutions.get(cacheKey);
+  if (cached) return cached;
+  const resolution = (async () => {
+    const moduleExport = await importStrategyPluginModule(
+      resolvedModuleName,
+      projectRoot
+    );
+    const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+    if (!pluginDefinition) {
+      throw new Error(`${source}: export { strategyEntries } is missing`);
+    }
+    const issues = validateStrategyEntries(
+      source,
+      pluginDefinition.strategyEntries
+    );
+    if (issues.length > 0) {
+      throw new Error(
+        ["Invalid TradeJS strategy module:", ...issues].join("\n")
+      );
+    }
+    const entry = pluginDefinition.strategyEntries.find(
+      (candidate) => candidate.manifest.name === strategyName
+    );
+    if (!entry) {
+      throw new Error(`${source}: strategy ${strategyName} is missing`);
+    }
+    const factory = sharedStrategyRegistry.strategyRuntimeFactory;
+    if (!factory) {
+      throw new Error("Strategy runtime factory is not configured");
+    }
+    const manifestsByName = new Map(
+      pluginDefinition.strategyEntries.map(
+        (candidate) => [candidate.manifest.name, candidate.manifest]
+      )
+    );
+    return {
+      entry,
+      creator: factory({
+        strategyName,
+        defaults: entry.defaults,
+        createCore: entry.createCore,
+        manifest: entry.manifest,
+        detectorKey: entry.detectorKey,
+        detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
+        resolveRegisteredManifest: (name) => manifestsByName.get(name) ?? state.strategyManifestsMap.get(name)
+      }),
+      source
+    };
+  })();
+  state.strategyModuleResolutions.set(cacheKey, resolution);
+  try {
+    return await resolution;
+  } catch (error) {
+    state.strategyModuleResolutions.delete(cacheKey);
+    throw error;
+  }
+};
+var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
+    state.pluginsLoadPromise = (async () => {
+      const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
+      const strategySet = new Set(strategyModules);
+      const indicatorSet = new Set(indicatorModules);
+      const pluginModuleNames = [
+        .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
+      ];
+      if (!pluginModuleNames.length) {
+        return;
+      }
+      const issues = [];
+      for (const moduleName of pluginModuleNames) {
+        try {
+          const resolvedModuleName = resolvePluginModuleSpecifier(
+            moduleName,
+            projectRoot
+          );
+          const moduleExport = await importStrategyPluginModule(
+            resolvedModuleName,
+            projectRoot
+          );
+          if (strategySet.has(moduleName)) {
+            const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+            if (!pluginDefinition) {
+              issues.push(
+                `${moduleName}: export { strategyEntries } is missing`
+              );
+            } else {
+              const entryIssues = validateStrategyEntries(
+                moduleName,
+                pluginDefinition.strategyEntries,
+                state
+              );
+              issues.push(...entryIssues);
+              if (entryIssues.length === 0) {
+                registerEntries2(
+                  pluginDefinition.strategyEntries,
+                  moduleName,
+                  state
+                );
+              }
+            }
+          }
+          if (indicatorSet.has(moduleName)) {
+            const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+            if (!indicatorPluginDefinition) {
+              issues.push(
+                `${moduleName}: export { indicatorEntries } is missing`
+              );
+            } else {
+              (0, import_indicators.registerIndicatorEntries)(
+                indicatorPluginDefinition.indicatorEntries,
+                moduleName,
+                projectRoot
+              );
+            }
+          }
+          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+            issues.push(`${moduleName}: plugin is not declared in config`);
+          }
+        } catch (error) {
+          issues.push(`${moduleName}: failed to import: ${String(error)}`);
+        }
+      }
+      if (issues.length > 0) {
+        throw new Error(
+          ["Invalid TradeJS plugin catalog:", ...issues].join("\n")
+        );
+      }
+    })();
+  }
+  await state.pluginsLoadPromise;
+};
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).creator;
+  }
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.get(name);
+};
+var getStrategyEntry = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).entry;
+  }
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyEntriesMap.get(name);
+};
+var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).source;
+  }
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategySourcesMap.get(name);
+};
+var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+  if (!name) {
+    return void 0;
+  }
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyManifestsMap.get(name);
+};
+var strategies = new Proxy(
+  {},
+  {
+    get: (_target, property) => {
+      if (typeof property !== "string") {
+        return void 0;
+      }
+      return getStrategyRegistryState().state.strategyCreators.get(property);
+    },
+    ownKeys: () => {
+      return [...getStrategyRegistryState().state.strategyCreators.keys()];
+    },
+    getOwnPropertyDescriptor: () => ({
+      enumerable: true,
+      configurable: true
+    })
+  }
+);
+
+// src/strategyHelpers/tickerProfiles.ts
+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 = (0, import_tickerProfiles2.tickerProfileMonth)(timestamp), key = JSON.stringify([projectRoot, provider, universeId, asOf]);
+  let cached = snapshots.get(key);
+  if (!cached || cached.expires < Date.now()) {
+    const value = (0, import_tickerProfiles.readTickerProfiles)(projectRoot, provider, universeId, asOf).then((envelope) => {
+      if (!envelope) return null;
+      const s = envelope.snapshot;
+      if (!(0, import_tickerProfiles2.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/strategyRuntime.ts
+var import_jev6 = require("@tradejs/core/jev");
+
+// src/jev.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_jev4 = require("@tradejs/core/jev");
+var import_jev5 = require("@tradejs/infra/jev");
+var import_userSettings = require("@tradejs/infra/userSettings");
+init_jevInput();
+init_jevInput();
+init_jevTraining();
+var resolveJevProvider = async (userName) => {
+  const settings = await (0, import_userSettings.getUserSettings)(userName);
+  const provider = {
+    endpoint: settings.JEV_API_ENDPOINT || import_jev4.JEV_PROVIDERS[0].endpoint,
+    model: settings.JEV_MODEL || import_jev4.JEV_PROVIDERS[0].model
+  };
+  (0, import_jev4.parseJevConfig)({ source: "provider", mode: "observe", provider });
+  if (!settings.JEV_API_KEY)
+    throw new Error("Configure the Jev API key in Account settings");
+  return provider;
+};
+var emptyScores = () => Object.fromEntries(import_jev4.JEV_DIMENSIONS.map((key) => [key, null]));
+var pending = /* @__PURE__ */ new Map();
+var pendingResponses = /* @__PURE__ */ new Map();
+var evaluateJevInput = async ({
+  input,
+  config,
+  userName,
+  projectRoot
+}) => {
+  config = (0, import_jev4.parseJevConfig)(config);
+  const inputHash = (0, import_jev5.jevHash)(input);
+  const questions = questionsForJevInput(input);
+  const questionsHash = (0, import_jev5.jevHash)(questions);
+  const base = {
+    questionSet: import_jev4.JEV_QUESTION_SET,
+    schema: "tradejs-signal-assessment/v5",
+    source: config.source,
+    mode: config.mode,
+    inputHash,
+    questionsHash,
+    geometryStatus: input.geometryStatus,
+    levelsValid: typeof input.features["signal.validLevels"] === "boolean" ? input.features["signal.validLevels"] : null
+  };
+  if (!input.questions.length)
+    return {
+      assessment: {
+        ...base,
+        status: "unavailable",
+        model: "",
+        scores: emptyScores(),
+        confidence: emptyScores()
+      }
+    };
+  if (config.source === "local") {
+    const contents = await import_promises.default.readFile(
+      import_node_path.default.resolve(projectRoot, config.modelFile),
+      "utf8"
+    );
+    if ((0, import_jev5.jevFileHash)(contents) !== config.modelSha256)
+      throw new Error("Local Jev gate checksum mismatch");
+    const { validateJevGateModel: validateJevGateModel2 } = await Promise.resolve().then(() => (init_jevTraining(), jevTraining_exports));
+    const model = validateJevGateModel2(JSON.parse(contents));
+    if (model.strategy !== input.strategy || model.questionsHash !== (0, import_jev5.jevHash)(JEV_QUESTIONS))
+      throw new Error("Local Jev gate strategy or question version mismatch");
+    const scores = Object.fromEntries(
+      import_jev4.JEV_DIMENSIONS.map((key) => [
+        key,
+        input.questions.includes(key) && model.trees[key] ? (0, import_jev4.predictJevTree)(model.trees[key], input.features) : null
+      ])
+    );
+    return {
+      assessment: {
+        ...base,
+        status: "available",
+        model: config.modelSha256,
+        scores,
+        confidence: emptyScores()
+      }
+    };
+  }
+  const provider = config.provider ?? await resolveJevProvider(userName);
+  const id = (0, import_jev5.jevHash)({ inputHash, questionsHash, provider });
+  const dir = import_node_path.default.resolve(projectRoot, config.recordsDir ?? "data/ai/jev");
+  const file = import_node_path.default.join(dir, "records", `${id}.json`);
+  const getRecord = async () => {
+    const existing = await (0, import_jev5.readJevArtifact)(file);
+    if (existing) {
+      if (existing.schema !== "tradejs-jev-record/v4" || existing.id !== id || existing.inputHash !== inputHash || existing.questionsHash !== questionsHash || (0, import_jev5.jevHash)(existing.input) !== inputHash || (0, import_jev5.jevHash)(existing.provider) !== (0, import_jev5.jevHash)(provider))
+        throw new Error("Jev recording identity mismatch");
+      (0, import_jev5.validateJevResponse)(existing.response, input.questions);
+      for (const key of import_jev4.JEV_DIMENSIONS) {
+        const expected = input.questions.includes(key) ? existing.response.answers[key].score / (0, import_jev5.jevScoreMaximum)(key) : null;
+        if (existing.scores[key] !== expected)
+          throw new Error("Jev recording scores do not match the response");
+      }
+      return existing;
+    }
+    if (config.source === "recorded")
+      throw new Error(
+        `Missing Jev recording ${id} for ${input.strategy} ${input.symbol} at ${new Date(input.timestamp).toISOString()}. Recorded mode requires the same signal-time facts and provider; a shorter backtest can change warm-up indicators or prior trade state.`
+      );
+    const settings = await (0, import_userSettings.getUserSettings)(userName);
+    if (!settings.JEV_API_KEY)
+      throw new Error("Configure the Jev API key in Account settings");
+    const apiKey = settings.JEV_API_KEY;
+    const configuredProvider = await resolveJevProvider(userName);
+    if (configuredProvider.endpoint !== provider.endpoint)
+      throw new Error(
+        "Jev account endpoint changed; update the frozen provider configuration"
+      );
+    const started = Date.now();
+    const state = stateForJevInput(input);
+    const responseId = (0, import_jev5.jevHash)({
+      state,
+      questionsHash,
+      provider,
+      user: (0, import_jev5.jevHash)(userName)
+    });
+    const responseFile = import_node_path.default.join(dir, "responses", `${responseId}.json`);
+    let responsePromise = pendingResponses.get(responseFile);
+    if (!responsePromise) {
+      responsePromise = (async () => {
+        const saved = await (0, import_jev5.readJevArtifact)(responseFile);
+        if (saved) return (0, import_jev5.validateJevResponse)(saved, input.questions);
+        const fresh = await (0, import_jev5.requestJev)(provider, apiKey, state, questions);
+        await (0, import_jev5.writeJevArtifact)(responseFile, fresh);
+        return fresh;
+      })();
+      pendingResponses.set(responseFile, responsePromise);
+    }
+    let response;
+    try {
+      response = await responsePromise;
+    } finally {
+      pendingResponses.delete(responseFile);
+    }
+    const scores = Object.fromEntries(
+      import_jev4.JEV_DIMENSIONS.map((key) => [
+        key,
+        input.questions.includes(key) ? response.answers[key].score / (0, import_jev5.jevScoreMaximum)(key) : null
+      ])
+    );
+    const value = {
+      schema: "tradejs-jev-record/v4",
+      id,
+      inputHash,
+      questionsHash,
+      provider,
+      input,
+      response,
+      scores,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      elapsedMs: Date.now() - started
+    };
+    await (0, import_jev5.writeJevArtifact)(file, value);
+    return await (0, import_jev5.readJevArtifact)(file);
+  };
+  const pendingKey = `${file}:${(0, import_jev5.jevHash)(userName)}`;
+  let promise = pending.get(pendingKey);
+  if (!promise) {
+    promise = getRecord();
+    pending.set(pendingKey, promise);
+  }
+  let record;
+  try {
+    record = await promise;
+  } finally {
+    pending.delete(pendingKey);
+  }
+  return {
+    record,
+    assessment: {
+      ...base,
+      status: "available",
+      recordId: id,
+      model: record.response.model,
+      scores: record.scores,
+      confidence: Object.fromEntries(
+        import_jev4.JEV_DIMENSIONS.map((key) => [
+          key,
+          record.response.answers[key]?.confidence ?? null
+        ])
+      )
+    }
+  };
+};
+var assessSignalWithJev = async ({
+  signal,
+  config,
+  userName,
+  projectRoot,
+  strict,
+  scope = "runtime"
+}) => {
+  let assessment;
+  try {
+    const input = buildJevInput(signal);
+    ({ assessment } = await evaluateJevInput({
+      input,
+      config,
+      userName,
+      projectRoot
+    }));
+  } catch (error) {
+    if (strict) throw error;
+    assessment = {
+      questionSet: import_jev4.JEV_QUESTION_SET,
+      schema: "tradejs-signal-assessment/v5",
+      source: config.source,
+      mode: config.mode,
+      status: "unavailable",
+      inputHash: "",
+      questionsHash: "",
+      geometryStatus: "absent",
+      levelsValid: null,
+      model: config.provider?.model ?? config.modelSha256 ?? "",
+      scores: emptyScores(),
+      confidence: emptyScores()
     };
   }
-  return {
-    source: String(cmcGlobal.source ?? ""),
-    available: true,
-    interval: typeof cmcGlobal.interval === "string" ? cmcGlobal.interval : null,
-    asOfTs: toFiniteNumber(cmcGlobal.asOfTs),
-    stale: typeof cmcGlobal.stale === "boolean" ? cmcGlobal.stale : null,
-    totalMarketCapUsd: toFiniteNumber(cmcGlobal.totalMarketCapUsd),
-    totalVolumeUsd: toFiniteNumber(cmcGlobal.totalVolumeUsd),
-    totalVolumeReportedUsd: toFiniteNumber(cmcGlobal.totalVolumeReportedUsd),
-    altMarketCapUsd: toFiniteNumber(cmcGlobal.altMarketCapUsd),
-    altVolumeUsd: toFiniteNumber(cmcGlobal.altVolumeUsd),
-    altVolumeReportedUsd: toFiniteNumber(cmcGlobal.altVolumeReportedUsd),
-    btcDominancePct: toFiniteNumber(cmcGlobal.btcDominancePct),
-    ethDominancePct: toFiniteNumber(cmcGlobal.ethDominancePct),
-    btcDominanceChange24hPct: toFiniteNumber(
-      cmcGlobal.btcDominanceChange24hPct
-    ),
-    ethDominanceChange24hPct: toFiniteNumber(
-      cmcGlobal.ethDominanceChange24hPct
-    ),
-    altMarketCapChange24hPct: toFiniteNumber(
-      cmcGlobal.altMarketCapChange24hPct
+  signal.assessment = assessment;
+  signal.additionalIndicators = {
+    ...signal.additionalIndicators,
+    jev: (0, import_jev4.jevAssessmentFeatures)(assessment)
+  };
+  const identity = {
+    signalId: signal.signalId,
+    strategy: signal.strategy,
+    symbol: signal.symbol,
+    timestamp: signal.timestamp,
+    scope,
+    user: (0, import_jev5.jevHash)(userName),
+    config,
+    assessment
+  };
+  await (0, import_jev5.writeJevArtifact)(
+    import_node_path.default.resolve(
+      projectRoot,
+      config.recordsDir ?? "data/ai/jev",
+      "decisions",
+      `${(0, import_jev5.jevHash)(identity)}.json`
     ),
-    altVolumeChange24hPct: toFiniteNumber(cmcGlobal.altVolumeChange24hPct),
-    activeCryptocurrencies: toFiniteNumber(cmcGlobal.activeCryptocurrencies),
-    activeExchanges: toFiniteNumber(cmcGlobal.activeExchanges),
-    activeMarketPairs: toFiniteNumber(cmcGlobal.activeMarketPairs),
-    altLiquidityRegime: typeof cmcGlobal.altLiquidityRegime === "string" ? cmcGlobal.altLiquidityRegime : null
+    identity
+  );
+  return assessment;
+};
+
+// src/strategyRuntime.ts
+var import_constants7 = require("@tradejs/core/constants");
+var import_strategies6 = require("@tradejs/core/strategies");
+var import_logger14 = require("@tradejs/infra/logger");
+
+// src/strategyHelpers/runtime.ts
+var import_logger12 = require("@tradejs/infra/logger");
+var import_constants5 = require("@tradejs/core/constants");
+var import_ml2 = require("@tradejs/infra/ml");
+
+// src/strategy/entrySubmissionValidation.ts
+var import_logger6 = require("@tradejs/infra/logger");
+
+// src/strategy/entryExecutionValidation.ts
+var EntrySubmissionValidationError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "EntrySubmissionValidationError";
+  }
+};
+var resolveEntryExecutionLimits = (config, direction) => {
+  const side = config[direction];
+  const minimum = side && typeof side === "object" && "minRiskRatio" in side ? side.minRiskRatio : void 0;
+  const maximum = config.MAX_LOSS_VALUE;
+  if (minimum == null && maximum == null) return void 0;
+  const minimumNetRiskRatio = minimum == null ? void 0 : Number(minimum);
+  const maxLossValue = maximum == null ? void 0 : Number(maximum);
+  const feeRate = Number(config.RISK_FEE_RATE ?? 0);
+  const slippage = Number(config.RISK_SLIPPAGE_BPS ?? 0);
+  const impact = Number(config.RISK_MARKET_IMPACT_BPS ?? 0);
+  const slippageBps = slippage + impact;
+  if (minimumNetRiskRatio != null && (!Number.isFinite(minimumNetRiskRatio) || minimumNetRiskRatio < 0) || maxLossValue != null && (!Number.isFinite(maxLossValue) || maxLossValue <= 0) || !Number.isFinite(feeRate) || feeRate < 0 || feeRate >= 1 || !Number.isFinite(slippage) || slippage < 0 || !Number.isFinite(impact) || impact < 0 || !Number.isFinite(slippageBps) || slippageBps < 0 || slippageBps >= 1e4)
+    throw new Error("INVALID_ENTRY_EXECUTION_LIMITS");
+  return { minimumNetRiskRatio, maxLossValue, feeRate, slippageBps };
+};
+var validateEntryExecution = ({
+  direction,
+  price,
+  qty,
+  stopLossPrice,
+  takeProfitPrice,
+  limits
+}) => {
+  if (!Number.isFinite(price) || price <= 0 || !Number.isFinite(qty) || qty <= 0 || stopLossPrice == null || !Number.isFinite(stopLossPrice) || stopLossPrice <= 0 || !Number.isFinite(takeProfitPrice) || takeProfitPrice <= 0)
+    throw new EntrySubmissionValidationError(
+      "ENTRY_ECONOMICS_INPUTS_UNAVAILABLE"
+    );
+  const side = direction === "LONG" ? 1 : -1;
+  if (side * (price - stopLossPrice) <= 0 || side * (takeProfitPrice - price) <= 0)
+    throw new EntrySubmissionValidationError(
+      "INVALID_ENTRY_PROTECTION_AT_SUBMISSION"
+    );
+  const slippage = limits.slippageBps / 1e4;
+  const cost = (value, sign) => value * slippage + value * (1 + sign * slippage) * limits.feeRate;
+  const entryCost = cost(price, side);
+  const lossPerUnit = Math.abs(price - stopLossPrice) + entryCost + cost(stopLossPrice, -side);
+  const rewardPerUnit = Math.max(
+    0,
+    Math.abs(takeProfitPrice - price) - entryCost - cost(takeProfitPrice, -side)
+  );
+  const netRiskRatio = rewardPerUnit / lossPerUnit;
+  const plannedLossValue = qty * lossPerUnit;
+  if (!Number.isFinite(netRiskRatio) || !Number.isFinite(plannedLossValue))
+    throw new EntrySubmissionValidationError(
+      "ENTRY_ECONOMICS_INPUTS_UNAVAILABLE"
+    );
+  const belowMinimumNetRiskRatio = limits.minimumNetRiskRatio != null && netRiskRatio <= limits.minimumNetRiskRatio;
+  const riskExceeded = limits.maxLossValue != null && plannedLossValue > limits.maxLossValue * (1 + 1e-9);
+  return {
+    netRiskRatio,
+    plannedLossValue,
+    riskExceeded,
+    belowMinimumNetRiskRatio
+  };
+};
+
+// src/strategy/entrySubmissionValidation.ts
+var MAX_ENTRY_QUOTE_AGE_MS = 5e3;
+var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var getOrderArrivalSnapshot = async ({
+  connector,
+  symbol,
+  requireTimestamp = false
+}) => {
+  if (typeof connector.getTopOfBookTicker !== "function") {
+    return {
+      arrivalSnapshotTime: Date.now(),
+      arrivalSource: "unavailable",
+      bid: null,
+      ask: null,
+      arrivalMid: null,
+      spreadBps: null
+    };
+  }
+  try {
+    const ticker = await connector.getTopOfBookTicker(symbol);
+    const arrivalSnapshotTime = toFiniteNumberOrNull(ticker?.timestamp);
+    const timestampUnavailable = requireTimestamp && arrivalSnapshotTime == null;
+    const bid = timestampUnavailable ? null : toFiniteNumberOrNull(ticker?.bidPrice);
+    const ask = timestampUnavailable ? null : toFiniteNumberOrNull(ticker?.askPrice);
+    const arrivalMid = bid != null && ask != null ? (bid + ask) / 2 : null;
+    const spreadBps = bid != null && ask != null && arrivalMid != null && arrivalMid > 0 ? (ask - bid) / arrivalMid * 1e4 : null;
+    return {
+      arrivalSnapshotTime: arrivalSnapshotTime ?? Date.now(),
+      arrivalSource: "top_of_book",
+      bid,
+      ask,
+      arrivalMid,
+      spreadBps
+    };
+  } catch (error) {
+    import_logger6.logger.warn(
+      "runtime order arrival snapshot failed: %s %s",
+      symbol,
+      error?.message || String(error)
+    );
+    return {
+      arrivalSnapshotTime: Date.now(),
+      arrivalSource: "top_of_book_error",
+      bid: null,
+      ask: null,
+      arrivalMid: null,
+      spreadBps: null
+    };
+  }
+};
+var validateEntryProtectionAtArrival = ({
+  direction,
+  signalPrice,
+  bid,
+  ask,
+  arrivalMid,
+  takeProfits,
+  stopLossPrice
+}) => {
+  const entryReference = direction === "LONG" ? ask ?? arrivalMid ?? signalPrice : bid ?? arrivalMid ?? signalPrice;
+  const stopReference = direction === "LONG" ? bid ?? arrivalMid ?? signalPrice : ask ?? arrivalMid ?? signalPrice;
+  if (!Number.isFinite(entryReference) || entryReference <= 0 || !Number.isFinite(stopReference) || stopReference <= 0) {
+    throw new Error("INVALID_ENTRY_REFERENCE_AT_ARRIVAL");
+  }
+  for (const takeProfit of takeProfits) {
+    if (!Number.isFinite(takeProfit.price) || takeProfit.price <= 0 || (direction === "LONG" ? takeProfit.price <= entryReference : takeProfit.price >= entryReference)) {
+      throw new Error("TAKE_PROFIT_CROSSED_BEFORE_ENTRY");
+    }
+  }
+  if (stopLossPrice != null && (!Number.isFinite(stopLossPrice) || stopLossPrice <= 0 || (direction === "LONG" ? stopLossPrice >= stopReference : stopLossPrice <= stopReference))) {
+    throw new Error("STOP_LOSS_CROSSED_BEFORE_ENTRY");
+  }
+};
+var createEntrySubmissionValidation = ({
+  connector,
+  symbol,
+  direction,
+  takeProfits,
+  stopLossPrice,
+  limits,
+  onValidated
+}) => {
+  if (!limits) return void 0;
+  if (!connector.capabilities?.orderSubmissionValidation)
+    throw new EntrySubmissionValidationError(
+      "ENTRY_SUBMISSION_VALIDATION_UNSUPPORTED"
+    );
+  return async ({ qty, executionPrice }) => {
+    const simulated = Reflect.get(connector, "__tradejsTestConnector") === true;
+    const snapshot2 = simulated && executionPrice != null ? {
+      arrivalSnapshotTime: Date.now(),
+      arrivalSource: "simulation",
+      bid: executionPrice,
+      ask: executionPrice,
+      arrivalMid: executionPrice,
+      spreadBps: 0
+    } : await getOrderArrivalSnapshot({
+      connector,
+      symbol,
+      requireTimestamp: true
+    });
+    const age = Date.now() - snapshot2.arrivalSnapshotTime;
+    if (snapshot2.bid == null || snapshot2.ask == null || !Number.isFinite(snapshot2.bid) || !Number.isFinite(snapshot2.ask) || snapshot2.bid <= 0 || snapshot2.ask < snapshot2.bid)
+      throw new EntrySubmissionValidationError(
+        "ENTRY_QUOTE_UNAVAILABLE_AT_SUBMISSION"
+      );
+    if (!Number.isFinite(age) || age < -MAX_ENTRY_QUOTE_AGE_MS || age > MAX_ENTRY_QUOTE_AGE_MS)
+      throw new EntrySubmissionValidationError(
+        "ENTRY_QUOTE_STALE_AT_SUBMISSION"
+      );
+    const price = direction === "LONG" ? snapshot2.ask : snapshot2.bid;
+    validateEntryProtectionAtArrival({
+      direction,
+      signalPrice: price,
+      bid: snapshot2.bid,
+      ask: snapshot2.ask,
+      arrivalMid: snapshot2.arrivalMid,
+      takeProfits,
+      stopLossPrice
+    });
+    const prices = takeProfits.map((tp) => tp.price);
+    const economics2 = validateEntryExecution({
+      direction,
+      price,
+      qty,
+      stopLossPrice,
+      takeProfitPrice: direction === "LONG" ? Math.max(...prices) : Math.min(...prices),
+      limits
+    });
+    if (economics2.belowMinimumNetRiskRatio) {
+      import_logger6.logger.warn(
+        "entry submission warning: %s %s ENTRY_RR_BELOW_MIN_AT_SUBMISSION (RR %s, threshold %s)",
+        symbol,
+        direction,
+        economics2.netRiskRatio,
+        limits.minimumNetRiskRatio
+      );
+    }
+    onValidated?.(snapshot2, economics2);
   };
 };
-var buildCmcReferenceAssetsContextFromSignal = (signal) => {
+
+// src/ai.ts
+var import_aiLanguages2 = require("@tradejs/core/aiLanguages");
+var import_redis4 = require("@tradejs/infra/redis");
+
+// src/strategyAdapters/ai.ts
+var import_indicators2 = require("@tradejs/core/indicators");
+var import_aiFeatures = require("@tradejs/core/aiFeatures");
+
+// src/aiShared.ts
+var MAX_AI_SERIES_POINTS = 5;
+var COMPACT_INDICATORS_SNAPSHOT_SYMBOL = /* @__PURE__ */ Symbol.for(
+  "tradejs.indicators.compactSnapshot"
+);
+var COMPACT_INDICATORS_SNAPSHOT_KEY = "__tradejsCompactIndicatorsSnapshot";
+var trimSeriesDeep = (value) => {
+  if (Array.isArray(value)) {
+    const trimmed = value.slice(-MAX_AI_SERIES_POINTS);
+    const isMatrix = trimmed.every((item) => Array.isArray(item));
+    if (isMatrix) {
+      return trimmed;
+    }
+    return trimmed.map(
+      (item) => item && typeof item === "object" ? trimSeriesDeep(item) : item
+    );
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [
+        key,
+        trimSeriesDeep(nested)
+      ])
+    );
+  }
+  return value;
+};
+var buildCompactAiIndicatorsSnapshot = (value) => {
+  const compactSnapshot = value && typeof value === "object" ? value[COMPACT_INDICATORS_SNAPSHOT_SYMBOL] ?? value[COMPACT_INDICATORS_SNAPSHOT_KEY] : void 0;
+  if (typeof compactSnapshot === "function") {
+    return compactSnapshot({ limit: MAX_AI_SERIES_POINTS });
+  }
+  return trimSeriesDeep(value);
+};
+
+// src/aiMarketContext.ts
+var toRecord = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+};
+var toFiniteNumber = (value) => {
+  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var roundTo = (value, decimals) => {
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+};
+var buildMissingSpreadContext = () => ({
+  source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+  indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+  available: false,
+  value: null,
+  zScore: null,
+  bps: null,
+  absBps: null,
+  bias: null,
+  severity: null
+});
+var buildSpreadContextFromSignal = (signal) => {
   const baseContext = toRecord(signal.additionalIndicators?.baseContext);
   const relative = toRecord(baseContext?.relative);
-  const cmcReferenceAssets = toRecord(relative?.cmcReferenceAssets);
-  if (!cmcReferenceAssets) {
-    return {
-      source: null,
-      available: false,
-      interval: null,
-      asOfTs: null,
-      stale: null,
-      btcMarketCapUsd: null,
-      ethMarketCapUsd: null,
-      btcVolumeUsd: null,
-      ethVolumeUsd: null,
-      btcVolumeToMarketCap: null,
-      ethVolumeToMarketCap: null,
-      ethBtcMarketCapRatio: null,
-      ethBtcMarketCapRatioChange24hPct: null,
-      ethVsBtcVolumeRatio: null,
-      referenceLiquidityRegime: null
-    };
+  const execution = toRecord(relative?.execution);
+  const spread = toFiniteNumber(execution?.venueSpread);
+  const zScore = toFiniteNumber(execution?.venueSpreadZScore);
+  if (spread == null) {
+    return buildMissingSpreadContext();
   }
+  const value = roundTo(spread, 8);
+  const bps = roundTo(value * 1e4, 2);
+  const absBps = Math.abs(bps);
+  const bias = absBps < 1 ? "flat" : bps > 0 ? "coinbase_premium" : "binance_premium";
+  const severity = absBps >= 20 ? "wide" : absBps >= 5 ? "elevated" : "normal";
   return {
-    source: String(cmcReferenceAssets.source ?? ""),
+    source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+    indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
     available: true,
-    interval: typeof cmcReferenceAssets.interval === "string" ? cmcReferenceAssets.interval : null,
-    asOfTs: toFiniteNumber(cmcReferenceAssets.asOfTs),
-    stale: typeof cmcReferenceAssets.stale === "boolean" ? cmcReferenceAssets.stale : null,
-    btcMarketCapUsd: toFiniteNumber(cmcReferenceAssets.btcMarketCapUsd),
-    ethMarketCapUsd: toFiniteNumber(cmcReferenceAssets.ethMarketCapUsd),
-    btcVolumeUsd: toFiniteNumber(cmcReferenceAssets.btcVolumeUsd),
-    ethVolumeUsd: toFiniteNumber(cmcReferenceAssets.ethVolumeUsd),
-    btcVolumeToMarketCap: toFiniteNumber(
-      cmcReferenceAssets.btcVolumeToMarketCap
-    ),
-    ethVolumeToMarketCap: toFiniteNumber(
-      cmcReferenceAssets.ethVolumeToMarketCap
-    ),
-    ethBtcMarketCapRatio: toFiniteNumber(
-      cmcReferenceAssets.ethBtcMarketCapRatio
-    ),
-    ethBtcMarketCapRatioChange24hPct: toFiniteNumber(
-      cmcReferenceAssets.ethBtcMarketCapRatioChange24hPct
-    ),
-    ethVsBtcVolumeRatio: toFiniteNumber(cmcReferenceAssets.ethVsBtcVolumeRatio),
-    referenceLiquidityRegime: typeof cmcReferenceAssets.referenceLiquidityRegime === "string" ? cmcReferenceAssets.referenceLiquidityRegime : null
+    value,
+    zScore,
+    bps,
+    absBps,
+    bias,
+    severity
   };
 };
-var buildCmcExchangeLiquidityContextFromSignal = (signal) => {
+var buildTrueDeltaContextFromSignal = (signal) => {
   const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const cmcExchangeLiquidity = toRecord(relative?.cmcExchangeLiquidity);
-  if (!cmcExchangeLiquidity) {
+  const participation = toRecord(baseContext?.participation);
+  const delta = toRecord(participation?.delta);
+  const source = String(delta?.source ?? "");
+  const isTrueDeltaSource = source === "kline_taker_volume" || source === "agg_trades" || source === "trades";
+  if (!delta || !isTrueDeltaSource) {
     return {
-      source: null,
+      source: source || null,
       available: false,
-      interval: null,
-      asOfTs: null,
-      stale: null,
-      exchangesCount: null,
-      totalVolumeUsd: null,
-      totalVolumeChange24hPct: null,
-      binanceVolumeUsd: null,
-      binanceVolumeShare: null,
-      topExchangeVolumeShare: null,
-      liquidityRegime: null
+      buyPressurePct: null,
+      buyVolume: null,
+      sellVolume: null,
+      netDelta: null,
+      deltaPct: null,
+      signedVolumeZScore: null
     };
   }
   return {
-    source: String(cmcExchangeLiquidity.source ?? ""),
+    source,
     available: true,
-    interval: typeof cmcExchangeLiquidity.interval === "string" ? cmcExchangeLiquidity.interval : null,
-    asOfTs: toFiniteNumber(cmcExchangeLiquidity.asOfTs),
-    stale: typeof cmcExchangeLiquidity.stale === "boolean" ? cmcExchangeLiquidity.stale : null,
-    exchangesCount: toFiniteNumber(cmcExchangeLiquidity.exchangesCount),
-    totalVolumeUsd: toFiniteNumber(cmcExchangeLiquidity.totalVolumeUsd),
-    totalVolumeChange24hPct: toFiniteNumber(
-      cmcExchangeLiquidity.totalVolumeChange24hPct
-    ),
-    binanceVolumeUsd: toFiniteNumber(cmcExchangeLiquidity.binanceVolumeUsd),
-    binanceVolumeShare: toFiniteNumber(cmcExchangeLiquidity.binanceVolumeShare),
-    topExchangeVolumeShare: toFiniteNumber(
-      cmcExchangeLiquidity.topExchangeVolumeShare
-    ),
-    liquidityRegime: typeof cmcExchangeLiquidity.liquidityRegime === "string" ? cmcExchangeLiquidity.liquidityRegime : null
+    buyPressurePct: toFiniteNumber(delta.buyPressurePct),
+    buyVolume: toFiniteNumber(delta.buyVolume),
+    sellVolume: toFiniteNumber(delta.sellVolume),
+    netDelta: toFiniteNumber(delta.netDelta),
+    deltaPct: toFiniteNumber(delta.deltaPct),
+    signedVolumeZScore: toFiniteNumber(delta.signedVolumeZScore)
   };
 };
-var buildCmcFearGreedContextFromSignal = (signal) => {
+var buildTradeFlowContextFromSignal = (signal) => {
   const baseContext = toRecord(signal.additionalIndicators?.baseContext);
-  const relative = toRecord(baseContext?.relative);
-  const cmcFearGreed = toRecord(relative?.cmcFearGreed);
-  if (!cmcFearGreed) {
+  const participation = toRecord(baseContext?.participation);
+  const tradeFlow = toRecord(participation?.tradeFlow);
+  if (!tradeFlow) {
     return {
       source: null,
       available: false,
       interval: null,
-      asOfTs: null,
       stale: null,
-      value: null,
-      valueChange24h: null,
-      valueChange7d: null,
-      classification: null,
-      sentimentRegime: null
+      trades: null,
+      buyPressurePct: null,
+      netBaseDelta: null,
+      netQuoteDelta: null
     };
   }
   return {
-    source: String(cmcFearGreed.source ?? ""),
+    source: String(tradeFlow.source ?? ""),
     available: true,
-    interval: typeof cmcFearGreed.interval === "string" ? cmcFearGreed.interval : null,
-    asOfTs: toFiniteNumber(cmcFearGreed.asOfTs),
-    stale: typeof cmcFearGreed.stale === "boolean" ? cmcFearGreed.stale : null,
-    value: toFiniteNumber(cmcFearGreed.value),
-    valueChange24h: toFiniteNumber(cmcFearGreed.valueChange24h),
-    valueChange7d: toFiniteNumber(cmcFearGreed.valueChange7d),
-    classification: typeof cmcFearGreed.classification === "string" ? cmcFearGreed.classification : null,
-    sentimentRegime: typeof cmcFearGreed.sentimentRegime === "string" ? cmcFearGreed.sentimentRegime : null
+    interval: String(tradeFlow.interval ?? ""),
+    stale: typeof tradeFlow.stale === "boolean" ? tradeFlow.stale : null,
+    trades: toFiniteNumber(tradeFlow.trades),
+    buyPressurePct: toFiniteNumber(tradeFlow.buyPressurePct),
+    netBaseDelta: toFiniteNumber(tradeFlow.netBaseDelta),
+    netQuoteDelta: toFiniteNumber(tradeFlow.netQuoteDelta)
   };
 };
-var buildCmcIndexesContextFromSignal = (signal) => {
+var buildMarketBreadthContextFromSignal = (signal) => {
   const baseContext = toRecord(signal.additionalIndicators?.baseContext);
   const relative = toRecord(baseContext?.relative);
-  const cmcIndexes = toRecord(relative?.cmcIndexes);
-  if (!cmcIndexes) {
+  const breadth = toRecord(relative?.marketBreadth);
+  if (!breadth) {
     return {
       source: null,
       available: false,
+      universe: null,
       interval: null,
-      asOfTs: null,
       stale: null,
-      cmc100Value: null,
-      cmc100Change24hPct: null,
-      cmc100TopConstituentSymbol: null,
-      cmc100TopConstituentWeightPct: null,
-      cmc20Value: null,
-      cmc20Change24hPct: null,
-      cmc20TopConstituentSymbol: null,
-      cmc20TopConstituentWeightPct: null,
-      cmc20ToCmc100Ratio: null,
-      cmc20ToCmc100RatioChange24hPct: null,
-      indexRegime: null
+      symbolsCount: null,
+      advanceDeclineRatio: null,
+      pctAboveMa20: null,
+      pctAboveMa50: null,
+      equalWeightedReturn: null,
+      volumeWeightedReturn: null,
+      dispersion: null
     };
   }
   return {
-    source: String(cmcIndexes.source ?? ""),
+    source: String(breadth.source ?? ""),
     available: true,
-    interval: typeof cmcIndexes.interval === "string" ? cmcIndexes.interval : null,
-    asOfTs: toFiniteNumber(cmcIndexes.asOfTs),
-    stale: typeof cmcIndexes.stale === "boolean" ? cmcIndexes.stale : null,
-    cmc100Value: toFiniteNumber(cmcIndexes.cmc100Value),
-    cmc100Change24hPct: toFiniteNumber(cmcIndexes.cmc100Change24hPct),
-    cmc100TopConstituentSymbol: typeof cmcIndexes.cmc100TopConstituentSymbol === "string" ? cmcIndexes.cmc100TopConstituentSymbol : null,
-    cmc100TopConstituentWeightPct: toFiniteNumber(
-      cmcIndexes.cmc100TopConstituentWeightPct
-    ),
-    cmc20Value: toFiniteNumber(cmcIndexes.cmc20Value),
-    cmc20Change24hPct: toFiniteNumber(cmcIndexes.cmc20Change24hPct),
-    cmc20TopConstituentSymbol: typeof cmcIndexes.cmc20TopConstituentSymbol === "string" ? cmcIndexes.cmc20TopConstituentSymbol : null,
-    cmc20TopConstituentWeightPct: toFiniteNumber(
-      cmcIndexes.cmc20TopConstituentWeightPct
-    ),
-    cmc20ToCmc100Ratio: toFiniteNumber(cmcIndexes.cmc20ToCmc100Ratio),
-    cmc20ToCmc100RatioChange24hPct: toFiniteNumber(
-      cmcIndexes.cmc20ToCmc100RatioChange24hPct
-    ),
-    indexRegime: typeof cmcIndexes.indexRegime === "string" ? cmcIndexes.indexRegime : null
+    universe: String(breadth.universe ?? ""),
+    interval: String(breadth.interval ?? ""),
+    stale: typeof breadth.stale === "boolean" ? breadth.stale : null,
+    symbolsCount: toFiniteNumber(breadth.symbolsCount),
+    advanceDeclineRatio: toFiniteNumber(breadth.advanceDeclineRatio),
+    pctAboveMa20: toFiniteNumber(breadth.pctAboveMa20),
+    pctAboveMa50: toFiniteNumber(breadth.pctAboveMa50),
+    equalWeightedReturn: toFiniteNumber(breadth.equalWeightedReturn),
+    volumeWeightedReturn: toFiniteNumber(breadth.volumeWeightedReturn),
+    dispersion: toFiniteNumber(breadth.dispersion)
   };
 };
-var buildReferenceTradeFlowContextFromSignal = (signal) => {
+var buildMarketBreadthsContextFromSignal = (signal) => {
   const baseContext = toRecord(signal.additionalIndicators?.baseContext);
   const relative = toRecord(baseContext?.relative);
-  const refs = toRecord(relative?.referenceTradeFlow);
-  const primaryReferenceSymbol = typeof refs?.primaryReferenceSymbol === "string" ? refs.primaryReferenceSymbol : null;
-  const tradeFlowBySymbol = toRecord(refs?.tradeFlowBySymbol);
-  const primaryTradeFlow = primaryReferenceSymbol != null ? toRecord(tradeFlowBySymbol?.[primaryReferenceSymbol]) : null;
-  if (!refs) {
+  const breadths = toRecord(relative?.marketBreadths);
+  const build = (key) => {
+    const breadth = toRecord(breadths?.[key]);
+    if (!breadth) {
+      return {
+        source: null,
+        available: false,
+        universe: null,
+        interval: null,
+        stale: null,
+        symbolsCount: null,
+        advanceDeclineRatio: null,
+        pctAboveMa20: null,
+        pctAboveMa50: null,
+        equalWeightedReturn: null,
+        volumeWeightedReturn: null,
+        dispersion: null
+      };
+    }
     return {
-      source: null,
-      available: false,
-      primaryReferenceSymbol: null,
-      referenceSymbols: [],
-      primaryTradeFlowBuyPressurePct: null,
-      primaryTradeFlowStale: null
+      source: String(breadth.source ?? ""),
+      available: true,
+      universe: String(breadth.universe ?? ""),
+      interval: String(breadth.interval ?? ""),
+      stale: typeof breadth.stale === "boolean" ? breadth.stale : null,
+      symbolsCount: toFiniteNumber(breadth.symbolsCount),
+      advanceDeclineRatio: toFiniteNumber(breadth.advanceDeclineRatio),
+      pctAboveMa20: toFiniteNumber(breadth.pctAboveMa20),
+      pctAboveMa50: toFiniteNumber(breadth.pctAboveMa50),
+      equalWeightedReturn: toFiniteNumber(breadth.equalWeightedReturn),
+      volumeWeightedReturn: toFiniteNumber(breadth.volumeWeightedReturn),
+      dispersion: toFiniteNumber(breadth.dispersion)
     };
-  }
-  return {
-    source: String(refs.source ?? ""),
-    available: true,
-    primaryReferenceSymbol,
-    referenceSymbols: Array.isArray(refs.referenceSymbols) ? refs.referenceSymbols.map(String) : [],
-    primaryTradeFlowBuyPressurePct: toFiniteNumber(
-      primaryTradeFlow?.buyPressurePct
-    ),
-    primaryTradeFlowStale: typeof primaryTradeFlow?.stale === "boolean" ? primaryTradeFlow.stale : null
   };
-};
-var buildAiMarketContext = (signal) => ({
-  execution: {
-    binanceCoinbaseSpread: buildSpreadContextFromSignal(signal)
-  },
-  participation: {
-    trueDelta: buildTrueDeltaContextFromSignal(signal),
-    tradeFlow: buildTradeFlowContextFromSignal(signal)
-  },
-  relative: {
-    marketBreadth: buildMarketBreadthContextFromSignal(signal),
-    marketBreadths: buildMarketBreadthsContextFromSignal(signal),
-    targetVsBtc: buildTargetVsBtcContextFromSignal(signal),
-    btcAltRegime: buildBtcAltRegimeContextFromSignal(signal),
-    cmcGlobal: buildCmcGlobalContextFromSignal(signal),
-    cmcReferenceAssets: buildCmcReferenceAssetsContextFromSignal(signal),
-    cmcExchangeLiquidity: buildCmcExchangeLiquidityContextFromSignal(signal),
-    cmcFearGreed: buildCmcFearGreedContextFromSignal(signal),
-    cmcIndexes: buildCmcIndexesContextFromSignal(signal),
-    referenceTradeFlow: buildReferenceTradeFlowContextFromSignal(signal)
-  }
-});
-
-// src/strategy/manifests.ts
-var import_indicators = require("@tradejs/core/indicators");
-var SHARED_STRATEGY_REGISTRY_KEY = "__tradejsNodeSharedStrategyRegistryV1__";
-var sharedRegistryScope = globalThis;
-var sharedStrategyRegistry = sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] ?? (sharedRegistryScope[SHARED_STRATEGY_REGISTRY_KEY] = {
-  registryStateByProjectRoot: /* @__PURE__ */ new Map()
-});
-var createStrategyRegistryState = () => ({
-  strategyCreators: /* @__PURE__ */ new Map(),
-  strategyManifestsMap: /* @__PURE__ */ new Map(),
-  strategyEntriesMap: /* @__PURE__ */ new Map(),
-  strategySourcesMap: /* @__PURE__ */ new Map(),
-  strategyModuleResolutions: /* @__PURE__ */ new Map(),
-  pluginsLoadPromise: null
-});
-var registryStateByProjectRoot2 = sharedStrategyRegistry.registryStateByProjectRoot;
-var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
-  const projectRoot = getTradejsProjectCwd(cwd);
-  let state = registryStateByProjectRoot2.get(projectRoot);
-  if (!state) {
-    state = createStrategyRegistryState();
-    registryStateByProjectRoot2.set(projectRoot, state);
-  }
   return {
-    projectRoot,
-    state
+    top5: build("top5"),
+    top10: build("top10"),
+    top30: build("top30"),
+    top50: build("top50"),
+    top100: build("top100")
   };
 };
-var toUniqueModules2 = (modules = []) => [
-  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
-];
-var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
-  const config = await loadTradejsConfig(cwd);
+var buildTargetVsReference = (signal, asset) => {
+  const base = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(base?.relative);
+  const target = toRecord(relative?.[`targetVs${asset}`]);
   return {
-    strategyModules: toUniqueModules2(config.strategies),
-    indicatorModules: toUniqueModules2(config.indicators)
+    source: target ? String(target.source ?? "") : null,
+    available: Boolean(target),
+    ratioReturn1h: toFiniteNumber(target?.ratioReturn1h),
+    ratioReturn4h: toFiniteNumber(target?.ratioReturn4h),
+    ratioReturn24h: toFiniteNumber(target?.ratioReturn24h),
+    alpha1h: toFiniteNumber(target?.[`alphaVs${asset}1h`]),
+    alpha4h: toFiniteNumber(target?.[`alphaVs${asset}4h`]),
+    alpha24h: toFiniteNumber(target?.[`alphaVs${asset}24h`]),
+    beta: toFiniteNumber(target?.[`betaTo${asset}20`]),
+    correlation: toFiniteNumber(target?.[`correlationTo${asset}20`]),
+    ratioTrend: typeof target?.ratioTrend === "string" ? target.ratioTrend : null
   };
 };
-var extractModuleEntries = (moduleExport, key) => {
-  if (!moduleExport || typeof moduleExport !== "object") {
-    return null;
-  }
-  const candidate = moduleExport;
-  if (Array.isArray(candidate[key])) {
-    return candidate[key];
-  }
-  const defaultExport = candidate.default;
-  if (defaultExport && Array.isArray(defaultExport[key])) {
-    return defaultExport[key];
-  }
-  return null;
-};
-var extractStrategyPluginDefinition = (moduleExport) => {
-  const strategyEntries = extractModuleEntries(
-    moduleExport,
-    "strategyEntries"
-  );
-  return strategyEntries ? { strategyEntries } : null;
-};
-var extractIndicatorPluginDefinition = (moduleExport) => {
-  const indicatorEntries = extractModuleEntries(
-    moduleExport,
-    "indicatorEntries"
-  );
-  return indicatorEntries ? { indicatorEntries } : null;
-};
-var validateStrategyEntries = (moduleName, entries, state) => {
-  const issues = [];
-  const names = /* @__PURE__ */ new Set();
-  entries.forEach((entry, index) => {
-    const entryPath = `${moduleName}.strategyEntries[${index}]`;
-    const strategyName = entry?.manifest?.name;
-    if (typeof strategyName !== "string" || !strategyName.trim()) {
-      issues.push(`${entryPath}: manifest.name is required`);
-    } else if (names.has(strategyName) || state?.strategyEntriesMap.has(strategyName)) {
-      issues.push(`${entryPath}: duplicate strategy ${strategyName}`);
-    } else {
-      names.add(strategyName);
-    }
-    if (!entry || typeof entry !== "object" || !entry.defaults || typeof entry.defaults !== "object" || Array.isArray(entry.defaults)) {
-      issues.push(`${entryPath}: defaults must be an object`);
-    }
-    if (typeof entry?.parseConfig !== "function") {
-      issues.push(`${entryPath}: parseConfig is required`);
-    }
-    if (typeof entry?.createCore !== "function") {
-      issues.push(`${entryPath}: createCore is required`);
-    }
-  });
-  return issues;
-};
-var registerEntries2 = (entries, source, state) => {
-  for (const entry of entries) {
-    const strategyName = entry.manifest.name;
-    state.strategyManifestsMap.set(strategyName, entry.manifest);
-    state.strategyEntriesMap.set(strategyName, entry);
-    state.strategySourcesMap.set(strategyName, source);
-    materializeStrategyCreator(strategyName, state);
-  }
-};
-var materializeStrategyCreator = (strategyName, state) => {
-  if (state.strategyCreators.has(strategyName) || !sharedStrategyRegistry.strategyRuntimeFactory) {
-    return;
-  }
-  const entry = state.strategyEntriesMap.get(strategyName);
-  if (!entry) return;
-  state.strategyCreators.set(
-    strategyName,
-    sharedStrategyRegistry.strategyRuntimeFactory({
-      strategyName,
-      defaults: entry.defaults,
-      createCore: entry.createCore,
-      manifest: entry.manifest,
-      detectorKey: entry.detectorKey,
-      detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
-      resolveRegisteredManifest: (name) => state.strategyManifestsMap.get(name)
-    })
-  );
+var buildTargetVsBtcContextFromSignal = (signal) => {
+  const { alpha1h, alpha4h, alpha24h, beta, correlation, ...shared } = buildTargetVsReference(signal, "Btc");
+  return {
+    ...shared,
+    alphaVsBtc1h: alpha1h,
+    alphaVsBtc4h: alpha4h,
+    alphaVsBtc24h: alpha24h,
+    betaToBtc20: beta,
+    correlationToBtc20: correlation
+  };
 };
-var setStrategyRuntimeFactory = (factory) => {
-  sharedStrategyRegistry.strategyRuntimeFactory = factory;
-  for (const state of registryStateByProjectRoot2.values()) {
-    for (const strategyName of state.strategyEntriesMap.keys()) {
-      materializeStrategyCreator(strategyName, state);
-    }
-  }
+var buildTargetVsEthContextFromSignal = (signal) => {
+  const { alpha1h, alpha4h, alpha24h, beta, correlation, ...shared } = buildTargetVsReference(signal, "Eth");
+  return {
+    ...shared,
+    alphaVsEth1h: alpha1h,
+    alphaVsEth4h: alpha4h,
+    alphaVsEth24h: alpha24h,
+    betaToEth20: beta,
+    correlationToEth20: correlation
+  };
 };
-var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
-  if (typeof importTradejsModule === "function") {
-    return importTradejsModule(moduleName, cwd);
+var buildBtcAltRegimeContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const btcAltRegime = toRecord(relative?.btcAltRegime);
+  if (!btcAltRegime) {
+    return {
+      source: null,
+      available: false,
+      universe: null,
+      interval: null,
+      stale: null,
+      regime: null,
+      btcReturn24h: null,
+      altBasketReturn24h: null,
+      btcVsAltReturn24h: null,
+      btcTurnoverShare24h: null,
+      btcTurnoverShareChange24h: null,
+      altVolToBtcVol24h: null,
+      altDispersion24h: null
+    };
   }
-  return import(
-    /* webpackIgnore: true */
-    moduleName
-  );
+  return {
+    source: String(btcAltRegime.source ?? ""),
+    available: true,
+    universe: String(btcAltRegime.universe ?? ""),
+    interval: String(btcAltRegime.interval ?? ""),
+    stale: typeof btcAltRegime.stale === "boolean" ? btcAltRegime.stale : null,
+    regime: typeof btcAltRegime.regime === "string" ? btcAltRegime.regime : null,
+    btcReturn24h: toFiniteNumber(btcAltRegime.btcReturn24h),
+    altBasketReturn24h: toFiniteNumber(btcAltRegime.altBasketReturn24h),
+    btcVsAltReturn24h: toFiniteNumber(btcAltRegime.btcVsAltReturn24h),
+    btcTurnoverShare24h: toFiniteNumber(btcAltRegime.btcTurnoverShare24h),
+    btcTurnoverShareChange24h: toFiniteNumber(
+      btcAltRegime.btcTurnoverShareChange24h
+    ),
+    altVolToBtcVol24h: toFiniteNumber(btcAltRegime.altVolToBtcVol24h),
+    altDispersion24h: toFiniteNumber(btcAltRegime.altDispersion24h)
+  };
 };
-var resolveStrategyModuleEntry = async ({
-  strategyName,
-  moduleName,
-  cwd
-}) => {
-  const { projectRoot, state } = getStrategyRegistryState(cwd);
-  const source = moduleName.trim();
-  const resolvedModuleName = resolvePluginModuleSpecifier(source, projectRoot);
-  const cacheKey = `${resolvedModuleName}\0${strategyName}`;
-  const cached = state.strategyModuleResolutions.get(cacheKey);
-  if (cached) return cached;
-  const resolution = (async () => {
-    const moduleExport = await importStrategyPluginModule(
-      resolvedModuleName,
-      projectRoot
-    );
-    const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
-    if (!pluginDefinition) {
-      throw new Error(`${source}: export { strategyEntries } is missing`);
-    }
-    const issues = validateStrategyEntries(
-      source,
-      pluginDefinition.strategyEntries
-    );
-    if (issues.length > 0) {
-      throw new Error(
-        ["Invalid TradeJS strategy module:", ...issues].join("\n")
-      );
-    }
-    const entry = pluginDefinition.strategyEntries.find(
-      (candidate) => candidate.manifest.name === strategyName
-    );
-    if (!entry) {
-      throw new Error(`${source}: strategy ${strategyName} is missing`);
-    }
-    const factory = sharedStrategyRegistry.strategyRuntimeFactory;
-    if (!factory) {
-      throw new Error("Strategy runtime factory is not configured");
-    }
-    const manifestsByName = new Map(
-      pluginDefinition.strategyEntries.map(
-        (candidate) => [candidate.manifest.name, candidate.manifest]
-      )
-    );
+var buildCmcGlobalContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcGlobal = toRecord(relative?.cmcGlobal);
+  if (!cmcGlobal) {
     return {
-      entry,
-      creator: factory({
-        strategyName,
-        defaults: entry.defaults,
-        createCore: entry.createCore,
-        manifest: entry.manifest,
-        detectorKey: entry.detectorKey,
-        detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
-        resolveRegisteredManifest: (name) => manifestsByName.get(name) ?? state.strategyManifestsMap.get(name)
-      }),
-      source
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      totalMarketCapUsd: null,
+      totalVolumeUsd: null,
+      totalVolumeReportedUsd: null,
+      altMarketCapUsd: null,
+      altVolumeUsd: null,
+      altVolumeReportedUsd: null,
+      btcDominancePct: null,
+      ethDominancePct: null,
+      btcDominanceChange24hPct: null,
+      ethDominanceChange24hPct: null,
+      altMarketCapChange24hPct: null,
+      altVolumeChange24hPct: null,
+      activeCryptocurrencies: null,
+      activeExchanges: null,
+      activeMarketPairs: null,
+      altLiquidityRegime: null
     };
-  })();
-  state.strategyModuleResolutions.set(cacheKey, resolution);
-  try {
-    return await resolution;
-  } catch (error) {
-    state.strategyModuleResolutions.delete(cacheKey);
-    throw error;
   }
+  return {
+    source: String(cmcGlobal.source ?? ""),
+    available: true,
+    interval: typeof cmcGlobal.interval === "string" ? cmcGlobal.interval : null,
+    asOfTs: toFiniteNumber(cmcGlobal.asOfTs),
+    stale: typeof cmcGlobal.stale === "boolean" ? cmcGlobal.stale : null,
+    totalMarketCapUsd: toFiniteNumber(cmcGlobal.totalMarketCapUsd),
+    totalVolumeUsd: toFiniteNumber(cmcGlobal.totalVolumeUsd),
+    totalVolumeReportedUsd: toFiniteNumber(cmcGlobal.totalVolumeReportedUsd),
+    altMarketCapUsd: toFiniteNumber(cmcGlobal.altMarketCapUsd),
+    altVolumeUsd: toFiniteNumber(cmcGlobal.altVolumeUsd),
+    altVolumeReportedUsd: toFiniteNumber(cmcGlobal.altVolumeReportedUsd),
+    btcDominancePct: toFiniteNumber(cmcGlobal.btcDominancePct),
+    ethDominancePct: toFiniteNumber(cmcGlobal.ethDominancePct),
+    btcDominanceChange24hPct: toFiniteNumber(
+      cmcGlobal.btcDominanceChange24hPct
+    ),
+    ethDominanceChange24hPct: toFiniteNumber(
+      cmcGlobal.ethDominanceChange24hPct
+    ),
+    altMarketCapChange24hPct: toFiniteNumber(
+      cmcGlobal.altMarketCapChange24hPct
+    ),
+    altVolumeChange24hPct: toFiniteNumber(cmcGlobal.altVolumeChange24hPct),
+    activeCryptocurrencies: toFiniteNumber(cmcGlobal.activeCryptocurrencies),
+    activeExchanges: toFiniteNumber(cmcGlobal.activeExchanges),
+    activeMarketPairs: toFiniteNumber(cmcGlobal.activeMarketPairs),
+    altLiquidityRegime: typeof cmcGlobal.altLiquidityRegime === "string" ? cmcGlobal.altLiquidityRegime : null
+  };
 };
-var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
-  const { projectRoot, state } = getStrategyRegistryState(cwd);
-  if (!state.pluginsLoadPromise) {
-    (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
-    state.pluginsLoadPromise = (async () => {
-      const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
-      const strategySet = new Set(strategyModules);
-      const indicatorSet = new Set(indicatorModules);
-      const pluginModuleNames = [
-        .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
-      ];
-      if (!pluginModuleNames.length) {
-        return;
-      }
-      const issues = [];
-      for (const moduleName of pluginModuleNames) {
-        try {
-          const resolvedModuleName = resolvePluginModuleSpecifier(
-            moduleName,
-            projectRoot
-          );
-          const moduleExport = await importStrategyPluginModule(
-            resolvedModuleName,
-            projectRoot
-          );
-          if (strategySet.has(moduleName)) {
-            const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
-            if (!pluginDefinition) {
-              issues.push(
-                `${moduleName}: export { strategyEntries } is missing`
-              );
-            } else {
-              const entryIssues = validateStrategyEntries(
-                moduleName,
-                pluginDefinition.strategyEntries,
-                state
-              );
-              issues.push(...entryIssues);
-              if (entryIssues.length === 0) {
-                registerEntries2(
-                  pluginDefinition.strategyEntries,
-                  moduleName,
-                  state
-                );
-              }
-            }
-          }
-          if (indicatorSet.has(moduleName)) {
-            const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
-            if (!indicatorPluginDefinition) {
-              issues.push(
-                `${moduleName}: export { indicatorEntries } is missing`
-              );
-            } else {
-              (0, import_indicators.registerIndicatorEntries)(
-                indicatorPluginDefinition.indicatorEntries,
-                moduleName,
-                projectRoot
-              );
-            }
-          }
-          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
-            issues.push(`${moduleName}: plugin is not declared in config`);
-          }
-        } catch (error) {
-          issues.push(`${moduleName}: failed to import: ${String(error)}`);
-        }
-      }
-      if (issues.length > 0) {
-        throw new Error(
-          ["Invalid TradeJS plugin catalog:", ...issues].join("\n")
-        );
-      }
-    })();
+var buildCmcReferenceAssetsContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcReferenceAssets = toRecord(relative?.cmcReferenceAssets);
+  if (!cmcReferenceAssets) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      btcMarketCapUsd: null,
+      ethMarketCapUsd: null,
+      btcVolumeUsd: null,
+      ethVolumeUsd: null,
+      btcVolumeToMarketCap: null,
+      ethVolumeToMarketCap: null,
+      ethBtcMarketCapRatio: null,
+      ethBtcMarketCapRatioChange24hPct: null,
+      ethVsBtcVolumeRatio: null,
+      referenceLiquidityRegime: null
+    };
   }
-  await state.pluginsLoadPromise;
+  return {
+    source: String(cmcReferenceAssets.source ?? ""),
+    available: true,
+    interval: typeof cmcReferenceAssets.interval === "string" ? cmcReferenceAssets.interval : null,
+    asOfTs: toFiniteNumber(cmcReferenceAssets.asOfTs),
+    stale: typeof cmcReferenceAssets.stale === "boolean" ? cmcReferenceAssets.stale : null,
+    btcMarketCapUsd: toFiniteNumber(cmcReferenceAssets.btcMarketCapUsd),
+    ethMarketCapUsd: toFiniteNumber(cmcReferenceAssets.ethMarketCapUsd),
+    btcVolumeUsd: toFiniteNumber(cmcReferenceAssets.btcVolumeUsd),
+    ethVolumeUsd: toFiniteNumber(cmcReferenceAssets.ethVolumeUsd),
+    btcVolumeToMarketCap: toFiniteNumber(
+      cmcReferenceAssets.btcVolumeToMarketCap
+    ),
+    ethVolumeToMarketCap: toFiniteNumber(
+      cmcReferenceAssets.ethVolumeToMarketCap
+    ),
+    ethBtcMarketCapRatio: toFiniteNumber(
+      cmcReferenceAssets.ethBtcMarketCapRatio
+    ),
+    ethBtcMarketCapRatioChange24hPct: toFiniteNumber(
+      cmcReferenceAssets.ethBtcMarketCapRatioChange24hPct
+    ),
+    ethVsBtcVolumeRatio: toFiniteNumber(cmcReferenceAssets.ethVsBtcVolumeRatio),
+    referenceLiquidityRegime: typeof cmcReferenceAssets.referenceLiquidityRegime === "string" ? cmcReferenceAssets.referenceLiquidityRegime : null
+  };
 };
-var getStrategyCreator = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
-  if (moduleName?.trim()) {
-    await ensureStrategyPluginsLoaded(cwd);
-    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).creator;
+var buildCmcExchangeLiquidityContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcExchangeLiquidity = toRecord(relative?.cmcExchangeLiquidity);
+  if (!cmcExchangeLiquidity) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      exchangesCount: null,
+      totalVolumeUsd: null,
+      totalVolumeChange24hPct: null,
+      binanceVolumeUsd: null,
+      binanceVolumeShare: null,
+      topExchangeVolumeShare: null,
+      liquidityRegime: null
+    };
   }
-  await ensureStrategyPluginsLoaded(cwd);
-  const { state } = getStrategyRegistryState(cwd);
-  return state.strategyCreators.get(name);
+  return {
+    source: String(cmcExchangeLiquidity.source ?? ""),
+    available: true,
+    interval: typeof cmcExchangeLiquidity.interval === "string" ? cmcExchangeLiquidity.interval : null,
+    asOfTs: toFiniteNumber(cmcExchangeLiquidity.asOfTs),
+    stale: typeof cmcExchangeLiquidity.stale === "boolean" ? cmcExchangeLiquidity.stale : null,
+    exchangesCount: toFiniteNumber(cmcExchangeLiquidity.exchangesCount),
+    totalVolumeUsd: toFiniteNumber(cmcExchangeLiquidity.totalVolumeUsd),
+    totalVolumeChange24hPct: toFiniteNumber(
+      cmcExchangeLiquidity.totalVolumeChange24hPct
+    ),
+    binanceVolumeUsd: toFiniteNumber(cmcExchangeLiquidity.binanceVolumeUsd),
+    binanceVolumeShare: toFiniteNumber(cmcExchangeLiquidity.binanceVolumeShare),
+    topExchangeVolumeShare: toFiniteNumber(
+      cmcExchangeLiquidity.topExchangeVolumeShare
+    ),
+    liquidityRegime: typeof cmcExchangeLiquidity.liquidityRegime === "string" ? cmcExchangeLiquidity.liquidityRegime : null
+  };
 };
-var getStrategyEntry = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
-  if (moduleName?.trim()) {
-    await ensureStrategyPluginsLoaded(cwd);
-    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).entry;
+var buildCmcFearGreedContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcFearGreed = toRecord(relative?.cmcFearGreed);
+  if (!cmcFearGreed) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      value: null,
+      valueChange24h: null,
+      valueChange7d: null,
+      classification: null,
+      sentimentRegime: null
+    };
   }
-  await ensureStrategyPluginsLoaded(cwd);
-  const { state } = getStrategyRegistryState(cwd);
-  return state.strategyEntriesMap.get(name);
+  return {
+    source: String(cmcFearGreed.source ?? ""),
+    available: true,
+    interval: typeof cmcFearGreed.interval === "string" ? cmcFearGreed.interval : null,
+    asOfTs: toFiniteNumber(cmcFearGreed.asOfTs),
+    stale: typeof cmcFearGreed.stale === "boolean" ? cmcFearGreed.stale : null,
+    value: toFiniteNumber(cmcFearGreed.value),
+    valueChange24h: toFiniteNumber(cmcFearGreed.valueChange24h),
+    valueChange7d: toFiniteNumber(cmcFearGreed.valueChange7d),
+    classification: typeof cmcFearGreed.classification === "string" ? cmcFearGreed.classification : null,
+    sentimentRegime: typeof cmcFearGreed.sentimentRegime === "string" ? cmcFearGreed.sentimentRegime : null
+  };
 };
-var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
-  if (moduleName?.trim()) {
-    await ensureStrategyPluginsLoaded(cwd);
-    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).source;
+var buildCmcIndexesContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const cmcIndexes = toRecord(relative?.cmcIndexes);
+  if (!cmcIndexes) {
+    return {
+      source: null,
+      available: false,
+      interval: null,
+      asOfTs: null,
+      stale: null,
+      cmc100Value: null,
+      cmc100Change24hPct: null,
+      cmc100TopConstituentSymbol: null,
+      cmc100TopConstituentWeightPct: null,
+      cmc20Value: null,
+      cmc20Change24hPct: null,
+      cmc20TopConstituentSymbol: null,
+      cmc20TopConstituentWeightPct: null,
+      cmc20ToCmc100Ratio: null,
+      cmc20ToCmc100RatioChange24hPct: null,
+      indexRegime: null
+    };
   }
-  await ensureStrategyPluginsLoaded(cwd);
-  const { state } = getStrategyRegistryState(cwd);
-  return state.strategySourcesMap.get(name);
+  return {
+    source: String(cmcIndexes.source ?? ""),
+    available: true,
+    interval: typeof cmcIndexes.interval === "string" ? cmcIndexes.interval : null,
+    asOfTs: toFiniteNumber(cmcIndexes.asOfTs),
+    stale: typeof cmcIndexes.stale === "boolean" ? cmcIndexes.stale : null,
+    cmc100Value: toFiniteNumber(cmcIndexes.cmc100Value),
+    cmc100Change24hPct: toFiniteNumber(cmcIndexes.cmc100Change24hPct),
+    cmc100TopConstituentSymbol: typeof cmcIndexes.cmc100TopConstituentSymbol === "string" ? cmcIndexes.cmc100TopConstituentSymbol : null,
+    cmc100TopConstituentWeightPct: toFiniteNumber(
+      cmcIndexes.cmc100TopConstituentWeightPct
+    ),
+    cmc20Value: toFiniteNumber(cmcIndexes.cmc20Value),
+    cmc20Change24hPct: toFiniteNumber(cmcIndexes.cmc20Change24hPct),
+    cmc20TopConstituentSymbol: typeof cmcIndexes.cmc20TopConstituentSymbol === "string" ? cmcIndexes.cmc20TopConstituentSymbol : null,
+    cmc20TopConstituentWeightPct: toFiniteNumber(
+      cmcIndexes.cmc20TopConstituentWeightPct
+    ),
+    cmc20ToCmc100Ratio: toFiniteNumber(cmcIndexes.cmc20ToCmc100Ratio),
+    cmc20ToCmc100RatioChange24hPct: toFiniteNumber(
+      cmcIndexes.cmc20ToCmc100RatioChange24hPct
+    ),
+    indexRegime: typeof cmcIndexes.indexRegime === "string" ? cmcIndexes.indexRegime : null
+  };
 };
-var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
-  if (!name) {
-    return void 0;
+var buildReferenceTradeFlowContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const refs = toRecord(relative?.referenceTradeFlow);
+  const primaryReferenceSymbol = typeof refs?.primaryReferenceSymbol === "string" ? refs.primaryReferenceSymbol : null;
+  const tradeFlowBySymbol = toRecord(refs?.tradeFlowBySymbol);
+  const primaryTradeFlow = primaryReferenceSymbol != null ? toRecord(tradeFlowBySymbol?.[primaryReferenceSymbol]) : null;
+  if (!refs) {
+    return {
+      source: null,
+      available: false,
+      primaryReferenceSymbol: null,
+      referenceSymbols: [],
+      primaryTradeFlowBuyPressurePct: null,
+      primaryTradeFlowStale: null
+    };
   }
-  const { state } = getStrategyRegistryState(cwd);
-  return state.strategyManifestsMap.get(name);
+  return {
+    source: String(refs.source ?? ""),
+    available: true,
+    primaryReferenceSymbol,
+    referenceSymbols: Array.isArray(refs.referenceSymbols) ? refs.referenceSymbols.map(String) : [],
+    primaryTradeFlowBuyPressurePct: toFiniteNumber(
+      primaryTradeFlow?.buyPressurePct
+    ),
+    primaryTradeFlowStale: typeof primaryTradeFlow?.stale === "boolean" ? primaryTradeFlow.stale : null
+  };
 };
-var strategies = new Proxy(
-  {},
-  {
-    get: (_target, property) => {
-      if (typeof property !== "string") {
-        return void 0;
-      }
-      return getStrategyRegistryState().state.strategyCreators.get(property);
-    },
-    ownKeys: () => {
-      return [...getStrategyRegistryState().state.strategyCreators.keys()];
-    },
-    getOwnPropertyDescriptor: () => ({
-      enumerable: true,
-      configurable: true
-    })
+var buildAiMarketContext = (signal) => ({
+  execution: {
+    binanceCoinbaseSpread: buildSpreadContextFromSignal(signal)
+  },
+  participation: {
+    trueDelta: buildTrueDeltaContextFromSignal(signal),
+    tradeFlow: buildTradeFlowContextFromSignal(signal)
+  },
+  relative: {
+    marketBreadth: buildMarketBreadthContextFromSignal(signal),
+    marketBreadths: buildMarketBreadthsContextFromSignal(signal),
+    targetVsBtc: buildTargetVsBtcContextFromSignal(signal),
+    targetVsEth: buildTargetVsEthContextFromSignal(signal),
+    btcAltRegime: buildBtcAltRegimeContextFromSignal(signal),
+    cmcGlobal: buildCmcGlobalContextFromSignal(signal),
+    cmcReferenceAssets: buildCmcReferenceAssetsContextFromSignal(signal),
+    cmcExchangeLiquidity: buildCmcExchangeLiquidityContextFromSignal(signal),
+    cmcFearGreed: buildCmcFearGreedContextFromSignal(signal),
+    cmcIndexes: buildCmcIndexesContextFromSignal(signal),
+    referenceTradeFlow: buildReferenceTradeFlowContextFromSignal(signal)
   }
-);
+});
 
 // src/strategy/policyProfiles.ts
 var profileMatches = (profile, universe, assetClass) => {
@@ -3554,12 +4334,61 @@ var buildBaseAiPayload = (signal) => {
   };
 };
 var defaultAiAdapter = {};
+var tickerProfileFeatureIds = new Set(
+  import_aiFeatures.TICKER_PROFILE_AI_FEATURES.map(({ id }) => id)
+);
 var getStrategyAiAdapter = (strategy, profileId) => getStrategyProfileAiAdapter(getStrategyManifest(strategy), profileId) ?? defaultAiAdapter;
 var getSignalAiAdapter = (signal) => getStrategyAiAdapter(signal.strategy, signal.policyProfileId);
 var buildAiPayloadByStrategy = (signal) => {
   const basePayload = buildBaseAiPayload(signal);
   const adapter = getSignalAiAdapter(signal);
-  return adapter.buildPayload?.({ signal, basePayload }) ?? basePayload;
+  const payload = adapter.buildPayload?.({ signal, basePayload }) ?? basePayload;
+  const custom = getStrategyManifest(signal.strategy)?.aiFeatures ?? [];
+  const frozen = signal.aiFeatureReplay?.snapshot;
+  if (frozen) (0, import_aiFeatures.validateAiFeatureSnapshot)(frozen);
+  const tickerProfile = signal.additionalIndicators?.tickerProfile ?? signal.additionalIndicators?.baseContext?.tickerProfile;
+  const hasProfile = Boolean(
+    tickerProfile || frozen?.definitions.some(({ id }) => tickerProfileFeatureIds.has(id))
+  );
+  const indicatorFeatures = (0, import_indicators2.getRegisteredIndicatorEntries)(
+    getTradejsProjectCwd()
+  ).flatMap((entry) => entry.indicator.enabled ? entry.aiFeatures ?? [] : []);
+  const hasPortfolio = Boolean(
+    signal.additionalIndicators?.portfolioContext || frozen?.definitions.some(
+      ({ id }) => import_aiFeatures.PORTFOLIO_AI_FEATURES.some((d) => d.id === id)
+    )
+  );
+  const definitions = [
+    ...hasPortfolio ? import_aiFeatures.PORTFOLIO_AI_FEATURES : [],
+    ...hasProfile ? import_aiFeatures.TICKER_PROFILE_AI_FEATURES : [],
+    ...indicatorFeatures,
+    ...custom
+  ];
+  if (!definitions.length && !signal.aiFeatureReplay?.snapshot) return payload;
+  (0, import_aiFeatures.validateAiFeatureDefinitions)(definitions);
+  if (signal.aiFeatureReplay && !frozen) {
+    throw new Error(
+      "Dataset has no frozen AI features; regenerate the decision-time export"
+    );
+  }
+  if (frozen && JSON.stringify(frozen.definitions) !== JSON.stringify(definitions)) {
+    throw new Error(
+      "AI feature definition changed; regenerate the decision-time export"
+    );
+  }
+  return {
+    ...payload,
+    featureSnapshot: frozen ?? (0, import_aiFeatures.projectAiFeatures)(definitions, {
+      signal: tickerProfile ? {
+        ...signal,
+        additionalIndicators: {
+          ...signal.additionalIndicators,
+          tickerProfile
+        }
+      } : signal,
+      payload
+    })
+  };
 };
 var buildAiSystemPromptAddonByStrategy = (signal) => getSignalAiAdapter(signal).buildSystemPromptAddon?.({ signal }) ?? "";
 var buildAiHumanPromptAddonByStrategy = (signal, payload) => getSignalAiAdapter(signal).buildHumanPromptAddon?.({
@@ -3945,380 +4774,132 @@ var buildAiPayload = (signal) => buildAiPayloadByStrategy(signal);
 var getDeterministicAiGateContext = (payload) => {
   const additionalIndicators = asRecord(payload.additionalIndicators);
   const candidates = [
-    additionalIndicators,
-    ...Object.values(additionalIndicators ?? {}).map(asRecord)
-  ].filter((value) => Boolean(value));
-  return candidates.find(
-    (candidate) => Array.isArray(candidate.approvalBlockReasons) || Array.isArray(candidate.riskAnnotations) || Array.isArray(candidate.structuralHardBlockReasons) || typeof candidate.approvalAllowedNow === "boolean"
-  ) ?? null;
-};
-var buildAiHumanPrompt = (signal, payload = buildAiPayload(signal)) => `
-Analyze the already computed internal signal for ${signal.symbol}. The original signal direction is ${signal.direction}.
-This is a structure-classification and audit task, not execution advice. Determine whether the current structure confirms the existing signal, how structurally coherent it is right now, whether an extra confirmation level is needed, and whether the already supplied levels in \`payload.signal.prices\` still look internally coherent. Do not replace the original thesis with a new one and do not invent new levels; return only the requested JSON.
-
-Trade payload:
-${JSON.stringify(payload)}
-${buildAiHumanPromptAddonByStrategy(signal, payload)}
-`;
-var runAiPrompt = async ({ systemPrompt, humanPrompt }, options = {}) => {
-  const settings = await getAiUserSettings(options.userName);
-  const responseLanguage = (0, import_aiLanguages2.getAiResponseLanguagePromptName)(
-    settings.AI_RESPONSE_LANGUAGE || import_aiLanguages2.DEFAULT_AI_RESPONSE_LANGUAGE
-  );
-  const response = await invokeAiPromptChat({
-    userName: options.userName,
-    model: options.model,
-    messages: [
-      { role: "system", content: systemPrompt },
-      {
-        role: "system",
-        content: `Write all user-visible text fields in ${responseLanguage}. Keep field names and JSON syntax unchanged.`
-      },
-      { role: "user", content: humanPrompt }
-    ]
-  });
-  const parsed = parseAIResponse(response.content);
-  const normalized = normalizeAnalysis(parsed);
-  if (!options.signal) {
-    return normalized;
-  }
-  return postProcessAiAnalysisByStrategy(
-    options.signal,
-    normalized,
-    options.payload
-  );
-};
-var runAiPromptLocal = async (signal, options = {}) => {
-  const payload = options.payload ?? buildAiPayload(signal);
-  const gateContext = getDeterministicAiGateContext(payload);
-  const signalDirection = getSignalDirection(signal);
-  const deterministicQuality = getDeterministicQuality(gateContext);
-  const approvalAllowedNow = typeof gateContext?.approvalAllowedNow === "boolean" ? gateContext.approvalAllowedNow : deterministicQuality >= 4;
-  return postProcessLocalAiAnalysisByStrategy(
-    signal,
-    {
-      direction: approvalAllowedNow ? signalDirection : null,
-      quality: deterministicQuality,
-      needRetest: !approvalAllowedNow,
-      retestPrice: null,
-      takeProfitPrice: approvalAllowedNow ? signal.prices?.takeProfitPrice ?? null : null,
-      stopLossPrice: approvalAllowedNow ? signal.prices?.stopLossPrice ?? null : null
-    },
-    payload
-  );
-};
-var askAI = async (signal, options = {}) => {
-  const { symbol } = signal;
-  const payload = buildAiPayload(signal);
-  const content = await runAiPrompt(
-    {
-      systemPrompt: buildAiSystemPrompt(signal),
-      humanPrompt: buildAiHumanPrompt(signal, payload)
-    },
-    {
-      ...options,
-      signal,
-      payload
-    }
-  );
-  await (0, import_redis2.setData)(import_redis2.redisKeys.analysis(symbol, signal.signalId), content);
-  return content;
-};
-
-// src/strategyAdapters/ml.ts
-var defaultMlAdapter = {
-  normalizeStrategyConfig: (strategyConfig) => strategyConfig
-};
-var getStrategyMlAdapter = (strategy, profileId) => {
-  const strategyAdapter = getStrategyProfileMlAdapter(
-    getStrategyManifest(strategy),
-    profileId
-  );
-  if (!strategyAdapter) return defaultMlAdapter;
-  return {
-    ...defaultMlAdapter,
-    ...strategyAdapter
-  };
-};
-
-// src/mlPayload.ts
-var normalizeStrategyConfig = (strategyConfig, strategyName, profileId) => {
-  return getStrategyMlAdapter(
-    strategyName,
-    profileId
-  ).normalizeStrategyConfig?.(strategyConfig);
-};
-var buildMlPayload = (payload) => {
-  const strategyName = payload.signal?.strategy ?? payload.context?.strategyName;
-  const profileId = payload.signal?.policyProfileId;
-  const mlAdapter = getStrategyMlAdapter(strategyName, profileId);
-  const normalizedSignal = mlAdapter.normalizeSignal?.(payload.signal) ?? payload.signal;
-  const nextSignal = {
-    ...normalizedSignal,
-    indicators: {
-      ...normalizedSignal?.indicators ?? {}
-    }
-  };
-  const nextContext = payload.context ? {
-    ...payload.context,
-    strategyConfig: normalizeStrategyConfig(
-      payload.context.strategyConfig,
-      strategyName,
-      profileId
-    )
-  } : void 0;
-  return {
-    signal: nextSignal,
-    context: nextContext
-  };
-};
-
-// src/runtimeJournal.ts
-var import_node_crypto = require("crypto");
-var import_constants3 = require("@tradejs/core/constants");
-var import_time3 = require("@tradejs/core/time");
-var import_trade = require("@tradejs/core/trade");
-var import_logger6 = require("@tradejs/infra/logger");
-var import_redis3 = require("@tradejs/infra/redis");
-var now = () => Date.now();
-var toRandomOrderSuffix = () => (0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 12).toLowerCase();
-var calculateClosedPnl = ({
-  direction,
-  entryPrice,
-  exitPrice,
-  qty
-}) => {
-  const pnl = direction === "LONG" ? (exitPrice - entryPrice) * qty : (entryPrice - exitPrice) * qty;
-  return Number.isFinite(pnl) ? pnl : null;
-};
-var createRuntimeOrderId = (strategy) => {
-  const prefix = (0, import_trade.createRuntimeOrderLinkPrefix)(strategy);
-  if (prefix === "tjs-") {
-    return `tjs-${(0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 24).toLowerCase()}`;
-  }
-  return `${prefix}${toRandomOrderSuffix()}`;
-};
-var recordRuntimeTradeOpen = async (params) => {
-  const { userName } = params;
-  if (!userName) {
-    return null;
-  }
-  const record = {
-    ...params,
-    entryCount: 1,
-    lastEntryPrice: params.entryPrice,
-    lastEntryQty: params.qty,
-    lastEntryTimestamp: params.entryTimestamp,
-    status: "active",
-    currentPrice: params.entryPrice,
-    currentPnl: 0,
-    closedPnl: null,
-    exitPrice: null,
-    exitTimestamp: null,
-    lastSyncedAt: now()
-  };
-  const dayKey = (0, import_time3.getRuntimeStorageDayKey)(record.entryTimestamp);
-  const runtimeScopeId = record.deploymentId ?? record.accountId;
-  try {
-    await Promise.all([
-      (0, import_redis3.setData)(import_redis3.redisKeys.runtimeTrade(userName, record.orderId), record, {
-        expire: 0
-      }),
-      (0, import_redis3.setHashJsonField)(
-        import_redis3.redisKeys.runtimeTradeBucket(userName, dayKey),
-        record.orderId,
-        record,
-        { expire: 0 }
-      ),
-      (0, import_redis3.setData)(
-        import_redis3.redisKeys.runtimeActiveTrade(userName, record.symbol, runtimeScopeId),
-        { orderId: record.orderId },
-        { expire: 0 }
-      )
-    ]);
-  } catch (error) {
-    import_logger6.logger.error(
-      "runtime trade open journal failed: %s %s",
-      record.symbol,
-      error?.message || String(error)
-    );
-  }
-  return record;
-};
-var recordRuntimeTradeIncrease = async (params) => {
-  const {
-    userName,
-    strategy,
-    symbol,
-    direction,
-    resultingQty,
-    resultingEntryPrice,
-    addedQty,
-    addedEntryPrice,
-    entryTimestamp,
-    fee,
-    accountId,
-    deploymentId
-  } = params;
-  if (!userName) {
-    return null;
-  }
-  const existing = await getActiveRuntimeTrade({
-    userName,
-    symbol,
-    accountId,
-    deploymentId
-  });
-  if (!existing || existing.strategy !== strategy || existing.direction !== direction) {
-    return null;
-  }
-  const addedFee = typeof fee === "number" && Number.isFinite(fee) ? fee : 0;
-  const openFee = (existing.openFee ?? existing.fee ?? 0) + addedFee;
-  const totalFee = (existing.totalFee ?? existing.fee ?? 0) + addedFee;
-  const next = {
-    ...existing,
-    ...params.orderLeverage ? { orderLeverage: params.orderLeverage } : {},
-    qty: resultingQty,
-    entryPrice: resultingEntryPrice,
-    entryCount: Math.max(1, existing.entryCount ?? 1) + 1,
-    lastEntryPrice: addedEntryPrice,
-    lastEntryQty: addedQty,
-    lastEntryTimestamp: entryTimestamp,
-    currentPrice: resultingEntryPrice,
-    currentPnl: 0,
-    fee: openFee,
-    openFee,
-    totalFee,
-    lastSyncedAt: now()
-  };
-  const dayKey = (0, import_time3.getRuntimeStorageDayKey)(existing.entryTimestamp);
-  try {
-    await Promise.all([
-      (0, import_redis3.setData)(import_redis3.redisKeys.runtimeTrade(userName, existing.orderId), next, {
-        expire: 0
-      }),
-      (0, import_redis3.setHashJsonField)(
-        import_redis3.redisKeys.runtimeTradeBucket(userName, dayKey),
-        existing.orderId,
-        next,
-        { expire: 0 }
-      )
-    ]);
-  } catch (error) {
-    import_logger6.logger.error(
-      "runtime trade increase journal failed: %s %s",
-      symbol,
-      error?.message || String(error)
-    );
-  }
-  return next;
+    additionalIndicators,
+    ...Object.values(additionalIndicators ?? {}).map(asRecord)
+  ].filter((value) => Boolean(value));
+  return candidates.find(
+    (candidate) => Array.isArray(candidate.approvalBlockReasons) || Array.isArray(candidate.riskAnnotations) || Array.isArray(candidate.structuralHardBlockReasons) || typeof candidate.approvalAllowedNow === "boolean"
+  ) ?? null;
 };
-var getActiveRuntimeTrade = async (params) => {
-  const { userName, symbol, accountId, deploymentId } = params;
-  if (!userName) {
-    return null;
-  }
-  const activeRef = await (0, import_redis3.getData)(
-    import_redis3.redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId),
-    null
+var buildAiHumanPrompt = (signal, payload = buildAiPayload(signal)) => `
+Analyze the already computed internal signal for ${signal.symbol}. The original signal direction is ${signal.direction}.
+This is a structure-classification and audit task, not execution advice. Determine whether the current structure confirms the existing signal, how structurally coherent it is right now, whether an extra confirmation level is needed, and whether the already supplied levels in \`payload.signal.prices\` still look internally coherent. Do not replace the original thesis with a new one and do not invent new levels; return only the requested JSON.
+
+Trade payload:
+${JSON.stringify(payload)}
+${buildAiHumanPromptAddonByStrategy(signal, payload)}
+`;
+var runAiPrompt = async ({ systemPrompt, humanPrompt }, options = {}) => {
+  const settings = await getAiUserSettings(options.userName);
+  const responseLanguage = (0, import_aiLanguages2.getAiResponseLanguagePromptName)(
+    settings.AI_RESPONSE_LANGUAGE || import_aiLanguages2.DEFAULT_AI_RESPONSE_LANGUAGE
   );
-  const orderId = String(activeRef?.orderId || "").trim();
-  if (!orderId) {
-    return null;
+  const response = await invokeAiPromptChat({
+    userName: options.userName,
+    model: options.model,
+    messages: [
+      { role: "system", content: systemPrompt },
+      {
+        role: "system",
+        content: `Write all user-visible text fields in ${responseLanguage}. Keep field names and JSON syntax unchanged.`
+      },
+      { role: "user", content: humanPrompt }
+    ]
+  });
+  const parsed = parseAIResponse(response.content);
+  const normalized = normalizeAnalysis(parsed);
+  if (!options.signal) {
+    return normalized;
   }
-  const existing = await (0, import_redis3.getData)(
-    import_redis3.redisKeys.runtimeTrade(userName, orderId),
-    null
+  return postProcessAiAnalysisByStrategy(
+    options.signal,
+    normalized,
+    options.payload
   );
-  if (!existing || existing.status !== "active") {
-    await (0, import_redis3.delKey)(
-      import_redis3.redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId)
-    );
-    return null;
-  }
-  return existing;
 };
-var markRuntimeTradeClosed = async (params) => {
-  const {
-    userName,
-    symbol,
-    strategy,
-    exitPrice,
-    exitTimestamp,
-    closedPnl,
-    exitType,
-    accountId,
-    deploymentId
-  } = params;
-  if (!userName) {
-    return null;
-  }
-  const existing = await getActiveRuntimeTrade({
-    userName,
-    symbol,
-    accountId,
-    deploymentId
-  });
-  if (!existing) {
-    return null;
-  }
-  const orderId = existing.orderId;
-  if (strategy && existing.strategy !== strategy) {
-    return null;
-  }
-  const resolvedExitPrice = typeof exitPrice === "number" && Number.isFinite(exitPrice) ? exitPrice : existing.currentPrice ?? existing.entryPrice;
-  const resolvedClosedPnl = typeof closedPnl === "number" && Number.isFinite(closedPnl) ? closedPnl : typeof resolvedExitPrice === "number" && Number.isFinite(resolvedExitPrice) ? calculateClosedPnl({
-    direction: existing.direction,
-    entryPrice: existing.entryPrice,
-    exitPrice: resolvedExitPrice,
-    qty: existing.qty
-  }) : existing.closedPnl ?? existing.currentPnl ?? null;
-  const next = {
-    ...existing,
-    status: "closed",
-    currentPrice: resolvedExitPrice,
-    currentPnl: resolvedClosedPnl,
-    closedPnl: resolvedClosedPnl,
-    exitPrice: resolvedExitPrice,
-    exitTimestamp: typeof exitTimestamp === "number" && Number.isFinite(exitTimestamp) ? exitTimestamp : now(),
-    exitType: exitType ?? existing.exitType ?? null,
-    lastSyncedAt: now()
+var runAiPromptLocal = async (signal, options = {}) => {
+  const payload = options.payload ?? buildAiPayload(signal);
+  const gateContext = getDeterministicAiGateContext(payload);
+  const signalDirection = getSignalDirection(signal);
+  const deterministicQuality = getDeterministicQuality(gateContext);
+  const approvalAllowedNow = typeof gateContext?.approvalAllowedNow === "boolean" ? gateContext.approvalAllowedNow : deterministicQuality >= 4;
+  return postProcessLocalAiAnalysisByStrategy(
+    signal,
+    {
+      direction: approvalAllowedNow ? signalDirection : null,
+      quality: deterministicQuality,
+      needRetest: !approvalAllowedNow,
+      retestPrice: null,
+      takeProfitPrice: approvalAllowedNow ? signal.prices?.takeProfitPrice ?? null : null,
+      stopLossPrice: approvalAllowedNow ? signal.prices?.stopLossPrice ?? null : null
+    },
+    payload
+  );
+};
+var askAI = async (signal, options = {}) => {
+  const { symbol } = signal;
+  const payload = buildAiPayload(signal);
+  const content = await runAiPrompt(
+    {
+      systemPrompt: buildAiSystemPrompt(signal),
+      humanPrompt: buildAiHumanPrompt(signal, payload)
+    },
+    {
+      ...options,
+      signal,
+      payload
+    }
+  );
+  await (0, import_redis4.setData)(import_redis4.redisKeys.analysis(symbol, signal.signalId), content);
+  return content;
+};
+
+// src/strategyAdapters/ml.ts
+var defaultMlAdapter = {
+  normalizeStrategyConfig: (strategyConfig) => strategyConfig
+};
+var getStrategyMlAdapter = (strategy, profileId) => {
+  const strategyAdapter = getStrategyProfileMlAdapter(
+    getStrategyManifest(strategy),
+    profileId
+  );
+  if (!strategyAdapter) return defaultMlAdapter;
+  return {
+    ...defaultMlAdapter,
+    ...strategyAdapter
+  };
+};
+
+// src/mlPayload.ts
+var normalizeStrategyConfig = (strategyConfig, strategyName, profileId) => {
+  return getStrategyMlAdapter(
+    strategyName,
+    profileId
+  ).normalizeStrategyConfig?.(strategyConfig);
+};
+var buildMlPayload = (payload) => {
+  const strategyName = payload.signal?.strategy ?? payload.context?.strategyName;
+  const profileId = payload.signal?.policyProfileId;
+  const mlAdapter = getStrategyMlAdapter(strategyName, profileId);
+  const normalizedSignal = mlAdapter.normalizeSignal?.(payload.signal) ?? payload.signal;
+  const nextSignal = {
+    ...normalizedSignal,
+    indicators: {
+      ...normalizedSignal?.indicators ?? {}
+    }
+  };
+  const nextContext = payload.context ? {
+    ...payload.context,
+    strategyConfig: normalizeStrategyConfig(
+      payload.context.strategyConfig,
+      strategyName,
+      profileId
+    )
+  } : void 0;
+  return {
+    signal: nextSignal,
+    context: nextContext
   };
-  const dayKey = (0, import_time3.getRuntimeStorageDayKey)(existing.entryTimestamp);
-  const closeDayKey = (0, import_time3.getRuntimeStorageDayKey)(next.exitTimestamp);
-  try {
-    await Promise.all([
-      (0, import_redis3.setData)(import_redis3.redisKeys.runtimeTrade(userName, orderId), next, {
-        expire: import_constants3.TTL_1M
-      }),
-      (0, import_redis3.setHashJsonField)(
-        import_redis3.redisKeys.runtimeTradeBucket(userName, dayKey),
-        orderId,
-        next,
-        { expire: import_constants3.TTL_1M }
-      ),
-      (0, import_redis3.setHashJsonField)(
-        import_redis3.redisKeys.runtimeClosedTradeBucket(userName, closeDayKey),
-        orderId,
-        next,
-        { expire: import_constants3.TTL_1M }
-      ),
-      (0, import_redis3.delKey)(
-        import_redis3.redisKeys.runtimeActiveTrade(
-          userName,
-          symbol,
-          deploymentId ?? accountId
-        )
-      )
-    ]);
-  } catch (error) {
-    import_logger6.logger.error(
-      "runtime trade close journal failed: %s %s",
-      symbol,
-      error?.message || String(error)
-    );
-  }
-  return next;
 };
 
 // src/strategyHelpers/marketContextStages.ts
@@ -4330,7 +4911,7 @@ var import_logger7 = require("@tradejs/infra/logger");
 var import_strategies = require("@tradejs/core/strategies");
 
 // src/binanceBreadthUniverses.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 
 // src/config/binanceBreadthUniverses.json
 var binanceBreadthUniverses_default = {
@@ -4569,7 +5150,7 @@ var BINANCE_BREADTH_UNIVERSE_KEYS = [
   "top50",
   "top100"
 ];
-var fingerprint = (value, length) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
+var fingerprint = (value, length) => (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(value)).digest("hex").slice(0, length);
 var normalizeSymbols = (symbols) => symbols.map((symbol) => symbol.trim().toUpperCase()).filter(Boolean);
 var buildBinanceBreadthUniverseSnapshot = ({
   rankedSymbols,
@@ -5593,7 +6174,7 @@ var enrichSignalWithCoinMarketCapContext = async (params) => {
 };
 
 // src/strategyHelpers/derivativesContext.ts
-var import_indicators2 = require("@tradejs/core/indicators");
+var import_indicators3 = require("@tradejs/core/indicators");
 var import_data3 = require("@tradejs/core/data");
 var import_strategies3 = require("@tradejs/core/strategies");
 var import_constants4 = require("@tradejs/core/constants");
@@ -5627,7 +6208,7 @@ var parseLookbackMs = () => {
 };
 var withHourlyFallbackRows = (rowsByInterval) => ({
   "15m": rowsByInterval["15m"] ?? [],
-  "1h": (0, import_indicators2.buildCoinalyzeHourlyRowsWithFallback)({
+  "1h": (0, import_indicators3.buildCoinalyzeHourlyRowsWithFallback)({
     rows15m: rowsByInterval["15m"],
     fallbackRows1h: rowsByInterval["1h"]
   })
@@ -5755,7 +6336,7 @@ var enrichSignalWithDerivativesContext = async (params) => {
     const targetSymbol = normalizeSymbol(signal.symbol);
     const lookbackMs = parseLookbackMs();
     const decisionTimeMs = signal.timestamp + (0, import_data3.intervalToMs)(signal.interval);
-    const derivativesEndMs = (0, import_indicators2.getLastClosedDerivativesBarStartMs)(
+    const derivativesEndMs = (0, import_indicators3.getLastClosedDerivativesBarStartMs)(
       decisionTimeMs,
       "15m"
     );
@@ -5770,7 +6351,7 @@ var enrichSignalWithDerivativesContext = async (params) => {
         });
         return [
           symbol,
-          (0, import_indicators2.buildDerivativesContext)({
+          (0, import_indicators3.buildDerivativesContext)({
             symbol,
             direction: signal.direction,
             timestamp: derivativesEndMs,
@@ -5797,7 +6378,7 @@ var enrichSignalWithDerivativesContext = async (params) => {
         lookbackMs,
         ...params.abortSignal ? { signal: params.abortSignal } : {}
       });
-      const context = (0, import_indicators2.buildDerivativesContext)({
+      const context = (0, import_indicators3.buildDerivativesContext)({
         symbol: targetSymbol,
         direction: signal.direction,
         timestamp: derivativesEndMs,
@@ -5845,7 +6426,7 @@ var import_hyperliquidWhales2 = require("@tradejs/infra/timescale/hyperliquidWha
 var import_logger10 = require("@tradejs/infra/logger");
 
 // src/hyperliquidWhaleUniverse.ts
-var import_node_crypto3 = require("crypto");
+var import_node_crypto4 = require("crypto");
 
 // src/config/hyperliquidPerpUniverse.json
 var hyperliquidPerpUniverse_default = {
@@ -6017,7 +6598,7 @@ var hyperliquidWhales_default = {
 };
 
 // src/hyperliquidWhaleUniverse.ts
-var fingerprint2 = (value) => (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16);
+var fingerprint2 = (value) => (0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16);
 var validateUnique = (values, label) => {
   if (new Set(values).size !== values.length) {
     throw new Error(`Hyperliquid ${label} snapshot contains duplicates`);
@@ -6504,6 +7085,7 @@ var enrichSignalWithMarketContextStages = async ({
       })
     });
   }
+  await enrichSignalWithTickerProfile(signal);
   const results = [];
   for (const stage of stages) {
     if (abortSignal?.aborted) break;
@@ -6551,12 +7133,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;
     }
@@ -6716,11 +7298,13 @@ var executeEntryOrder = async ({
   beforePlaceOrder,
   recordRuntimeTrade = true,
   leverage,
-  executionLimits
+  executionLimits,
+  markPortfolioSubmitted,
+  rejectPortfolioSubmission
 }) => {
   await beforePlaceOrder?.();
   const previousPosition = positionIntent === "increase" ? await connector.getPosition(symbol) : null;
-  const orderId = signal.orderId || createRuntimeOrderId(signal.strategy);
+  let orderId = signal.orderId || createRuntimeOrderId(signal.strategy);
   const signalTimestamp = signal.timestamp;
   const signalClosePrice = currentPrice;
   signal.orderId = orderId;
@@ -6789,9 +7373,16 @@ 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);
+        return markPortfolioSubmitted?.(context.qty);
+      }
+    } : {}
   });
   const orderAckTime = Date.now();
+  if (markPortfolioSubmitted && signal.orderId) orderId = signal.orderId;
   const placedQty = typeof signal.orderQty === "number" && Number.isFinite(signal.orderQty) && signal.orderQty > 0 ? signal.orderQty : qty;
   const currentPosition = await connector.getPosition(symbol);
   const fillTime = Date.now();
@@ -7777,7 +8368,7 @@ var handleProtectDecision = async ({
   }
   return decision.code;
 };
-var executeEntryDecision = async ({
+var executeAdmittedEntryDecision = async ({
   connector,
   symbol,
   decision,
@@ -7791,7 +8382,9 @@ var executeEntryDecision = async ({
   ai,
   recordRuntimeJournal,
   invokeStageHooks,
-  notifyRuntimeError
+  notifyRuntimeError,
+  markPortfolioSubmitted,
+  rejectPortfolioSubmission
 }) => {
   const signal = decision.signal;
   const beforePlaceOrder = async () => {
@@ -7838,6 +8431,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,
@@ -7978,6 +8573,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(
@@ -8005,6 +8631,7 @@ var createStrategyRuntime = ({
   };
   const creator = async ({
     userName,
+    connectorName,
     config: baseConfig,
     symbol,
     universe: requestedUniverse,
@@ -8043,6 +8670,37 @@ var createStrategyRuntime = ({
     const projectConfig = await loadTradejsConfig(projectRoot);
     const projectHooks = projectConfig.hooks;
     const env = String(config.ENV ?? "BACKTEST");
+    let portfolioMarket;
+    const portfolio = getPortfolioRuntime({
+      symbol,
+      canClose: async (position, intent, asOf) => {
+        if (!portfolioMarket || portfolioMarket.candle.timestamp > asOf || !isRuntimeOrderExecutionEnabled({ config, env, connector }))
+          return false;
+        const gate = await authorizeClose(
+          {
+            kind: "exit",
+            code: intent.reason,
+            closePlan: {
+              direction: position.direction,
+              price: position.markPrice,
+              timestamp: asOf
+            }
+          },
+          portfolioMarket,
+          position.strategy
+        );
+        return gate?.allow !== false;
+      },
+      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))
@@ -8207,7 +8865,10 @@ var createStrategyRuntime = ({
       return invokeHook(stage, hook, params, errorContext);
     };
     const invokeGateHooks = async (stage, hook, params, errorContext = {}) => {
-      const failureResult = stage === "beforeEntryGate" ? { allow: false, reason: "ERROR" } : void 0;
+      const failureResult = {
+        allow: false,
+        reason: "ERROR"
+      };
       const projectResults = await invokeProjectHooks(
         stage,
         params,
@@ -8228,6 +8889,12 @@ var createStrategyRuntime = ({
         failureResult
       );
     };
+    const authorizeClose = (decision, market, owner = strategyName) => invokeGateHooks(
+      "beforeClosePosition",
+      resolveManifest(owner)?.hooks?.beforeClosePosition,
+      { ctx: getHookCtx(owner), market, decision },
+      { decision, market }
+    );
     const applyProjectAfterCoreDecisionHooks = async ({
       hookCtx,
       market,
@@ -8341,6 +9008,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;
         }
@@ -8508,6 +9189,8 @@ var createStrategyRuntime = ({
         runtime: pending2.runtime
       });
       return executeEntryDecision({
+        portfolio,
+        portfolioTime: env === "BACKTEST" || env === "PARITY" ? candle.timestamp : Date.now(),
         connector,
         symbol,
         decision: pending2.decision,
@@ -8525,6 +9208,11 @@ var createStrategyRuntime = ({
       });
     };
     const runWithDecisionOverride = async (candle, btcCandle, options = {}) => {
+      portfolioMarket = { candle, btcCandle };
+      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);
@@ -8627,15 +9315,10 @@ var createStrategyRuntime = ({
         if (!makeOrdersEnabled) {
           return decision.code;
         }
-        const closeGate = await invokeGateHooks(
-          "beforeClosePosition",
-          decisionManifest?.hooks?.beforeClosePosition,
-          {
-            ctx: decisionHookCtx,
-            market,
-            decision
-          },
-          { decision, market }
+        const closeGate = await authorizeClose(
+          decision,
+          market,
+          decisionHookCtx.strategyName
         );
         if (closeGate?.allow === false) {
           return closeGate.reason ? `CLOSE_BLOCKED_BY_HOOK:${closeGate.reason}` : "CLOSE_BLOCKED_BY_HOOK";
@@ -8695,6 +9378,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;
@@ -8934,6 +9624,8 @@ var createStrategyRuntime = ({
         });
       }
       return executeEntryDecision({
+        portfolio,
+        portfolioTime: env === "BACKTEST" || env === "PARITY" ? candle.timestamp : Date.now(),
         connector,
         symbol,
         decision,
@@ -9045,7 +9737,7 @@ var normalizeForCanonicalJson = (value) => {
   }
   return value;
 };
-var revision = (prefix, value) => `${prefix}:${(0, import_node_crypto4.createHash)("sha256").update(JSON.stringify(normalizeForCanonicalJson(value))).digest("hex").slice(0, 16)}`;
+var revision = (prefix, value) => `${prefix}:${(0, import_node_crypto5.createHash)("sha256").update(JSON.stringify(normalizeForCanonicalJson(value))).digest("hex").slice(0, 16)}`;
 var computeStrategyRevision = ({
   strategyName,
   strategyPackage,
@@ -9630,18 +10322,18 @@ var loadRuntimeTrades = async (userName, {
   const [bucketTradeGroups, legacyKeys] = await Promise.all([
     Promise.all(
       dayKeys.map(
-        (dayKey) => (0, import_redis4.getHashJsonValues)(
-          import_redis4.redisKeys.runtimeTradeBucket(userName, dayKey)
+        (dayKey) => (0, import_redis5.getHashJsonValues)(
+          import_redis5.redisKeys.runtimeTradeBucket(userName, dayKey)
         )
       )
     ),
-    (0, import_redis4.getKeys)(import_redis4.redisKeys.runtimeTrades(userName))
+    (0, import_redis5.getKeys)(import_redis5.redisKeys.runtimeTrades(userName))
   ]);
   const legacyTradeKeys = legacyKeys.filter(
-    (key) => !key.startsWith(import_redis4.redisKeys.runtimeTradeBuckets(userName))
+    (key) => !key.startsWith(import_redis5.redisKeys.runtimeTradeBuckets(userName))
   );
   const legacyTrades = await Promise.all(
-    legacyTradeKeys.map((key) => (0, import_redis4.getData)(key, null))
+    legacyTradeKeys.map((key) => (0, import_redis5.getData)(key, null))
   );
   const dedupedTrades = /* @__PURE__ */ new Map();
   for (const trade of [...legacyTrades, ...bucketTradeGroups.flat()]) {
@@ -9728,8 +10420,8 @@ var loadExchangeRange = async ({
   }
 };
 var loadActiveRuntimeOrderIds = async (userName) => {
-  const keys = await (0, import_redis4.getKeys)(import_redis4.redisKeys.runtimeActiveTrades(userName));
-  const refs = await Promise.all(keys.map((key) => (0, import_redis4.getData)(key, null)));
+  const keys = await (0, import_redis5.getKeys)(import_redis5.redisKeys.runtimeActiveTrades(userName));
+  const refs = await Promise.all(keys.map((key) => (0, import_redis5.getData)(key, null)));
   return new Set(
     refs.map(
       (ref) => typeof ref?.orderId === "string" && ref.orderId.trim() ? ref.orderId.trim() : null