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

package/dist/registry.js

@@ -792,1683 +792,2417 @@ __export(registry_exports, {
 });
 module.exports = __toCommonJS(registry_exports);
 
-// 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_redis2 = 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;
+      try {
+        const value = await send(
+          async (qty) => {
+            if (!Number.isFinite(qty) || qty <= 0)
+              throw new Error("Invalid submitted portfolio quantity");
+            submitted = true;
+            const update = await updateReservation(now2, entry.id, true, qty);
+            if (!update.result)
+              throw new Error("PORTFOLIO_SUBMISSION_NO_LONGER_ADMITTED");
+          },
+          async () => {
+            await transact(
+              now2,
+              (s) => ({
+                state: {
+                  ...s,
+                  reservations: s.reservations.filter((r) => r.id !== entry.id),
+                  completedSignals: {
+                    ...s.completedSignals,
+                    [entry.signalId]: now2
+                  }
+                },
+                result: void 0
+              }),
+              true
+            );
+          }
+        );
+        if (!submitted) await updateReservation(now2, entry.id, false);
+        else await tick(now2, true);
+        return { value };
+      } catch (error) {
+        if (!submitted) await updateReservation(now2, entry.id, false);
+        throw error;
+      }
     }
   };
-};
-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()
-    };
-  }
-  signal.assessment = assessment;
-  signal.additionalIndicators = {
-    ...signal.additionalIndicators,
-    jev: (0, import_jev4.jevAssessmentFeatures)(assessment)
+}
+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;
+    }
   };
-  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;
-};
-
-// src/strategyRuntime.ts
-var import_constants5 = require("@tradejs/core/constants");
-var import_strategies6 = require("@tradejs/core/strategies");
-var import_logger11 = require("@tradejs/infra/logger");
-
-// src/strategyHelpers/runtime.ts
-var import_logger9 = require("@tradejs/infra/logger");
-var import_constants3 = require("@tradejs/core/constants");
-var import_ml2 = require("@tradejs/infra/ml");
+}
 
-// src/strategy/entrySubmissionValidation.ts
+// src/runtimeJournal.ts
+var import_node_crypto = require("crypto");
+var import_constants = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
+var import_trade = require("@tradejs/core/trade");
 var import_logger = 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 = ({
+var import_redis = require("@tradejs/infra/redis");
+var now = () => Date.now();
+var toRandomOrderSuffix = () => (0, import_node_crypto.randomUUID)().replace(/-/g, "").slice(0, 12).toLowerCase();
+var calculateClosedPnl = ({
   direction,
-  price,
-  qty,
-  stopLossPrice,
-  takeProfitPrice,
-  limits
+  entryPrice,
+  exitPrice,
+  qty
 }) => {
-  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"
+  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_time.getRuntimeStorageDayKey)(record.entryTimestamp);
+  const runtimeScopeId = record.deploymentId ?? record.accountId;
+  try {
+    await Promise.all([
+      (0, import_redis.setData)(import_redis.redisKeys.runtimeTrade(userName, record.orderId), record, {
+        expire: 0
+      }),
+      (0, import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeTradeBucket(userName, dayKey),
+        record.orderId,
+        record,
+        { expire: 0 }
+      ),
+      (0, import_redis.setData)(
+        import_redis.redisKeys.runtimeActiveTrade(userName, record.symbol, runtimeScopeId),
+        { orderId: record.orderId },
+        { expire: 0 }
+      )
+    ]);
+  } catch (error) {
+    import_logger.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_time.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_redis.setData)(import_redis.redisKeys.runtimeTrade(userName, existing.orderId), next, {
+        expire: 0
+      }),
+      (0, import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeTradeBucket(userName, dayKey),
+        existing.orderId,
+        next,
+        { expire: 0 }
+      )
+    ]);
   } catch (error) {
-    import_logger.logger.warn(
-      "runtime order arrival snapshot failed: %s %s",
+    import_logger.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");
+var getActiveRuntimeTrade = async (params) => {
+  const { userName, symbol, accountId, deploymentId } = params;
+  if (!userName) {
+    return null;
   }
-  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");
-    }
+  const activeRef = await (0, import_redis.getData)(
+    import_redis.redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId),
+    null
+  );
+  const orderId = String(activeRef?.orderId || "").trim();
+  if (!orderId) {
+    return null;
   }
-  if (stopLossPrice != null && (!Number.isFinite(stopLossPrice) || stopLossPrice <= 0 || (direction === "LONG" ? stopLossPrice >= stopReference : stopLossPrice <= stopReference))) {
-    throw new Error("STOP_LOSS_CROSSED_BEFORE_ENTRY");
+  const existing = await (0, import_redis.getData)(
+    import_redis.redisKeys.runtimeTrade(userName, orderId),
+    null
+  );
+  if (!existing || existing.status !== "active") {
+    await (0, import_redis.delKey)(
+      import_redis.redisKeys.runtimeActiveTrade(userName, symbol, deploymentId ?? accountId)
+    );
+    return null;
   }
+  return existing;
 };
-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);
+var markRuntimeTradeClosed = async (params) => {
+  const {
+    userName,
+    expectedOrderId,
+    symbol,
+    strategy,
+    exitPrice,
+    exitTimestamp,
+    closedPnl,
+    exitType,
+    accountId,
+    deploymentId
+  } = params;
+  if (!userName) {
+    return null;
+  }
+  const existing = expectedOrderId ? await (0, import_redis.getDataStrict)(
+    import_redis.redisKeys.runtimeTrade(userName, expectedOrderId)
+  ) : await getActiveRuntimeTrade({
+    userName,
+    symbol,
+    accountId,
+    deploymentId
+  });
+  if (!existing || expectedOrderId && existing.orderId !== expectedOrderId) {
+    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 = 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_time.getRuntimeStorageDayKey)(existing.entryTimestamp);
+  const closeDayKey = (0, import_time.getRuntimeStorageDayKey)(next.exitTimestamp);
+  try {
+    await Promise.all([
+      (expectedOrderId ? import_redis.setDataStrict : import_redis.setData)(
+        import_redis.redisKeys.runtimeTrade(userName, orderId),
+        next,
+        {
+          expire: import_constants.TTL_1M
+        }
+      ),
+      (expectedOrderId ? import_redis.setHashJsonFieldStrict : import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeTradeBucket(userName, dayKey),
+        orderId,
+        next,
+        { expire: import_constants.TTL_1M }
+      ),
+      (expectedOrderId ? import_redis.setHashJsonFieldStrict : import_redis.setHashJsonField)(
+        import_redis.redisKeys.runtimeClosedTradeBucket(userName, closeDayKey),
+        orderId,
+        next,
+        { expire: import_constants.TTL_1M }
+      ),
+      expectedOrderId ? (0, import_redis.deleteRuntimeTradeReference)(
+        import_redis.redisKeys.runtimeActiveTrade(
+          userName,
+          symbol,
+          deploymentId ?? accountId
+        ),
+        expectedOrderId
+      ) : (0, import_redis.delKey)(
+        import_redis.redisKeys.runtimeActiveTrade(
+          userName,
+          symbol,
+          deploymentId ?? accountId
+        )
+      )
+    ]);
+  } catch (error) {
+    if (expectedOrderId) throw error;
+    import_logger.logger.error(
+      "runtime trade close journal failed: %s %s",
+      symbol,
+      error?.message || String(error)
+    );
+  }
+  return next;
 };
 
-// src/ai.ts
-var import_aiLanguages2 = require("@tradejs/core/aiLanguages");
-var import_redis = 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;
+// 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 {
+    async read() {
+      const value = await import_redis2.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_redis2.portfolioStateStorage.compare(key, expected, JSON.stringify(next));
     }
-    return trimmed.map(
-      (item) => item && typeof item === "object" ? trimSeriesDeep(item) : item
+  };
+}
+function getPortfolioRuntime({
+  value,
+  connectorName,
+  strategy,
+  connector,
+  env,
+  userName,
+  accountId,
+  deploymentId
+}) {
+  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 (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, nested]) => [
-        key,
-        trimSeriesDeep(nested)
-      ])
+  if (!replay && (!userName || !accountId || !deploymentId || !connector.getOpenPositionPnl || !connector.getEntryExecutions))
+    throw new Error(
+      "Portfolio runtime requires exact user/account/deployment binding, marks and executions"
     );
+  const binding = {
+    userName,
+    accountId,
+    deploymentId
+  };
+  const scope = policy.scope === "strategy" ? strategy : policy.scope === "account" ? "account" : [...policy.scope.strategies].sort();
+  const key = (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");
+    return existing.coordinator;
+  }
+  const coordinator = createPortfolioCoordinator({
+    policy,
+    strategy,
+    store: replay ? createMemoryPortfolioStore() : persistentStore(key),
+    execution: {
+      async confirmClosed(intent, asOf) {
+        if (replay) return;
+        const position = intent.position;
+        await markRuntimeTradeClosed({
+          ...binding,
+          strategy: position.strategy,
+          expectedOrderId: position.id,
+          symbol: position.symbol,
+          exitPrice: position.markPrice,
+          exitTimestamp: asOf,
+          exitType: "exit"
+        });
+      },
+      observe: (asOf, reservations) => replay ? connector.getPortfolioObservation(asOf, reservations) : observeRuntimePortfolio(connector, binding, asOf, reservations),
+      async close(position, intent, asOf) {
+        if (!replay) {
+          const trade = await getActiveRuntimeTrade({
+            ...binding,
+            symbol: position.symbol
+          });
+          if (!trade || trade.orderId !== position.id)
+            throw new Error("Portfolio close ownership changed");
+        }
+        await connector.closePosition({
+          symbol: position.symbol,
+          direction: position.direction,
+          price: position.markPrice,
+          timestamp: asOf,
+          signal: {
+            signalId: `${position.id}:${intent.reason}`,
+            strategy: position.strategy,
+            symbol: position.symbol,
+            direction: position.direction,
+            interval: "1",
+            timestamp: asOf,
+            prices: {
+              riskRatio: 0,
+              currentPrice: position.markPrice,
+              takeProfitPrice: position.markPrice,
+              stopLossPrice: position.markPrice
+            },
+            figures: {},
+            indicators: {},
+            additionalIndicators: { portfolioExitReason: intent.reason }
+          }
+        });
+      }
+    }
+  });
+  registry.set(cacheKey, { fingerprint: fingerprint3, coordinator });
+  return coordinator;
+}
+
+// src/strategyHelpers/tickerProfiles.ts
+var import_tickerProfiles = require("@tradejs/infra/tickerProfiles");
+var import_tickerProfiles2 = require("@tradejs/core/tickerProfiles");
+
+// src/tradejsConfig.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_url = require("url");
+var import_config = require("@tradejs/core/config");
+var import_logger2 = require("@tradejs/infra/logger");
+var CONFIG_FILE_NAMES = [
+  "tradejs.config.ts",
+  "tradejs.config.mts",
+  "tradejs.config.js",
+  "tradejs.config.mjs",
+  "tradejs.config.cjs"
+];
+var TS_MODULE_RE = /\.(cts|mts|ts)$/i;
+var cachedByCwd = /* @__PURE__ */ new Map();
+var announcedConfigFile = /* @__PURE__ */ new Set();
+var tsNodeRegistered = false;
+var tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
+var tsconfigPathMatchersByCwd = /* @__PURE__ */ new Map();
+var getTradejsProjectCwd = (cwd) => {
+  const explicit = String(cwd ?? "").trim();
+  if (explicit) {
+    return import_path.default.resolve(explicit);
   }
-  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 });
+  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
+  if (fromEnv) {
+    return import_path.default.resolve(fromEnv);
   }
-  return trimSeriesDeep(value);
+  return process.cwd();
 };
-
-// src/aiMarketContext.ts
-var toRecord = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return null;
+var normalizeConfig = (rawConfig) => {
+  if (!rawConfig || typeof rawConfig !== "object") {
+    return {};
   }
-  return value;
+  const config = rawConfig;
+  const strategies2 = Array.isArray(config.strategies) ? config.strategies.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  const indicators = Array.isArray(config.indicators) ? config.indicators.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  const connectors = Array.isArray(config.connectors) ? config.connectors.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  const hooks = (0, import_config.normalizeTradejsConfigHooks)(
+    config.hooks
+  );
+  const runtime = config.runtime && typeof config.runtime === "object" && !Array.isArray(config.runtime) ? config.runtime : void 0;
+  return {
+    strategies: strategies2,
+    indicators,
+    connectors,
+    ...hooks ? { hooks } : {},
+    ...runtime ? { runtime } : {}
+  };
 };
-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 getNodeCreateRequire = () => {
+  const builtinModule = process.getBuiltinModule?.("module");
+  if (typeof builtinModule?.createRequire === "function") {
+    return builtinModule.createRequire;
+  }
+  throw new TypeError("module.createRequire is not available");
 };
-var roundTo = (value, decimals) => {
-  const factor = 10 ** decimals;
-  return Math.round(value * factor) / factor;
+var getRequireFn = (cwd = getTradejsProjectCwd()) => getNodeCreateRequire()(import_path.default.join(import_path.default.resolve(cwd), "__tradejs_loader__.js"));
+var ensureTsNodeRegistered = async () => {
+  if (tsNodeRegistered) {
+    return;
+  }
+  const tsNodeModule = await import("ts-node");
+  const tsNode = tsNodeModule.default ?? tsNodeModule;
+  tsNode.register?.({
+    transpileOnly: true,
+    compilerOptions: {
+      module: "Node16",
+      moduleResolution: "node16"
+    }
+  });
+  tsNodeRegistered = true;
 };
-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();
+var ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  if (tsconfigPathsRegisteredByCwd.has(projectRoot)) {
+    return;
   }
-  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 tsconfigPathsModule = await import("tsconfig-paths");
+  const loadConfig = tsconfigPathsModule.loadConfig;
+  const register = tsconfigPathsModule.register;
+  if (typeof loadConfig !== "function" || typeof register !== "function") {
+    return;
+  }
+  const loadedConfig = loadConfig(projectRoot);
+  if (loadedConfig.resultType !== "success") {
+    return;
+  }
+  register({
+    baseUrl: loadedConfig.absoluteBaseUrl,
+    paths: loadedConfig.paths,
+    addMatchAll: false
+  });
+  tsconfigPathsRegisteredByCwd.add(projectRoot);
 };
-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
-    };
+var resolveTsconfigPathModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  const cachedMatcher = tsconfigPathMatchersByCwd.get(projectRoot);
+  if (cachedMatcher) {
+    const resolved2 = cachedMatcher(moduleName);
+    return resolved2 || null;
   }
-  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)
-  };
+  const tsconfigPathsModule = await import("tsconfig-paths");
+  const loadConfig = tsconfigPathsModule.loadConfig;
+  const createMatchPath = tsconfigPathsModule.createMatchPath;
+  if (typeof loadConfig !== "function" || typeof createMatchPath !== "function") {
+    return null;
+  }
+  const loadedConfig = loadConfig(projectRoot);
+  if (loadedConfig.resultType !== "success") {
+    return null;
+  }
+  const matchPath = createMatchPath(
+    loadedConfig.absoluteBaseUrl,
+    loadedConfig.paths
+  );
+  const matcher = (requestedModule) => matchPath(requestedModule, void 0, import_fs.default.existsSync, [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json"
+  ]) || "";
+  tsconfigPathMatchersByCwd.set(projectRoot, matcher);
+  const resolved = matcher(moduleName);
+  return resolved || null;
 };
-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
-    };
+var toImportSpecifier = (moduleName) => {
+  if (moduleName.startsWith("file://")) {
+    return moduleName;
   }
-  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)
-  };
+  if (import_path.default.isAbsolute(moduleName)) {
+    return (0, import_url.pathToFileURL)(moduleName).href;
+  }
+  return moduleName;
 };
-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
-    };
+var isTsModulePath = (moduleName) => TS_MODULE_RE.test(moduleName.split("?")[0]);
+var isRelativeModulePath = (moduleName) => moduleName.startsWith("./") || moduleName.startsWith("../");
+var isBareModuleSpecifier = (moduleName) => {
+  const normalized = String(moduleName ?? "").trim();
+  if (!normalized) {
+    return false;
   }
-  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)
-  };
+  if (normalized.startsWith("file://") || import_path.default.isAbsolute(normalized) || isRelativeModulePath(normalized)) {
+    return false;
+  }
+  return true;
 };
-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
-      };
+var importConfigFile = async (configFilePath) => {
+  const ext = import_path.default.extname(configFilePath).toLowerCase();
+  const configFileUrl = `${toImportSpecifier(configFilePath)}?t=${Date.now()}`;
+  if (ext === ".ts" || ext === ".mts") {
+    const requireFn = getRequireFn(import_path.default.dirname(configFilePath));
+    await ensureTsNodeRegistered();
+    await ensureTsconfigPathsRegistered(import_path.default.dirname(configFilePath));
+    return requireFn(configFilePath);
+  }
+  return import(
+    /* webpackIgnore: true */
+    configFileUrl
+  );
+};
+var importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  const normalized = String(moduleName ?? "").trim();
+  if (!normalized) {
+    return {};
+  }
+  let modulePath = normalized;
+  if (normalized.startsWith("file://")) {
+    try {
+      modulePath = (0, import_url.fileURLToPath)(normalized);
+    } catch {
+      modulePath = normalized;
     }
-    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)
-    };
-  };
-  return {
-    top5: build("top5"),
-    top10: build("top10"),
-    top30: build("top30"),
-    top50: build("top50"),
-    top100: build("top100")
-  };
+  }
+  const requireFn = getRequireFn(
+    import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : cwd
+  );
+  if (isTsModulePath(modulePath)) {
+    await ensureTsNodeRegistered();
+    await ensureTsconfigPathsRegistered(cwd);
+    return requireFn(modulePath);
+  }
+  if (isBareModuleSpecifier(normalized)) {
+    await ensureTsconfigPathsRegistered(cwd);
+    try {
+      return requireFn(normalized);
+    } catch (error) {
+      const resolvedByTsconfig = await resolveTsconfigPathModule(
+        normalized,
+        cwd
+      );
+      if (resolvedByTsconfig && resolvedByTsconfig !== normalized) {
+        return requireFn(resolvedByTsconfig);
+      }
+      throw error;
+    }
+  }
+  try {
+    return await import(
+      /* webpackIgnore: true */
+      toImportSpecifier(normalized)
+    );
+  } catch (error) {
+    if (isTsModulePath(modulePath)) {
+      await ensureTsNodeRegistered();
+      await ensureTsconfigPathsRegistered(cwd);
+      return requireFn(modulePath);
+    }
+    throw error;
+  }
 };
-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 resolveExportedConfig = (moduleExports) => {
+  const candidate = moduleExports && typeof moduleExports === "object" && "default" in moduleExports ? moduleExports.default : moduleExports;
+  return normalizeConfig(candidate);
+};
+var findConfigFilePath = (cwd) => {
+  let currentDir = import_path.default.resolve(cwd);
+  while (true) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const fullPath = import_path.default.join(currentDir, fileName);
+      if (import_fs.default.existsSync(fullPath) && import_fs.default.statSync(fullPath).isFile()) {
+        return fullPath;
+      }
+    }
+    const parentDir = import_path.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+};
+var resolvePluginModuleSpecifier = (moduleName, cwd = getTradejsProjectCwd()) => {
+  const normalized = String(moduleName ?? "").trim();
+  if (!normalized) {
+    return "";
+  }
+  if (normalized.startsWith("file://")) {
+    try {
+      return (0, import_url.fileURLToPath)(normalized);
+    } catch {
+      return normalized;
+    }
+  }
+  if (import_path.default.isAbsolute(normalized)) {
+    return normalized;
+  }
+  if (isRelativeModulePath(normalized)) {
+    return import_path.default.resolve(cwd, normalized);
+  }
+  return normalized;
+};
+var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
+  const cached = cachedByCwd.get(cwd);
+  if (cached) {
+    return cached;
+  }
+  const configFilePath = findConfigFilePath(cwd);
+  if (!configFilePath) {
+    cachedByCwd.set(cwd, {});
+    return {};
+  }
+  try {
+    const moduleExports = await importConfigFile(configFilePath);
+    const config = resolveExportedConfig(moduleExports);
+    cachedByCwd.set(cwd, config);
+    if (!announcedConfigFile.has(configFilePath)) {
+      announcedConfigFile.add(configFilePath);
+      import_logger2.logger.log("debug", "Loaded TradeJS config: %s", configFilePath);
+    }
+    return config;
+  } catch (error) {
+    import_logger2.logger.log(
+      "warn",
+      "Failed to load TradeJS config from %s: %s",
+      configFilePath,
+      String(error)
+    );
+    cachedByCwd.set(cwd, {});
+    return {};
+  }
+};
+
+// 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 registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
+var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createStrategyRegistryState();
+    registryStateByProjectRoot.set(projectRoot, state);
   }
   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
+    projectRoot,
+    state
   };
 };
-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
-    };
-  }
+var toUniqueModules = (modules = []) => [
+  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
+];
+var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
   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)
+    strategyModules: toUniqueModules(config.strategies),
+    indicatorModules: toUniqueModules(config.indicators)
   };
 };
-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 extractModuleEntries = (moduleExport, key) => {
+  if (!moduleExport || typeof moduleExport !== "object") {
+    return null;
   }
-  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
-  };
+  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 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
-    };
+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 registerEntries = (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);
   }
-  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 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
-    };
+var materializeStrategyCreator = (strategyName, state) => {
+  if (state.strategyCreators.has(strategyName) || !sharedStrategyRegistry.strategyRuntimeFactory) {
+    return;
   }
-  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
-  };
+  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 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
-    };
+var setStrategyRuntimeFactory = (factory) => {
+  sharedStrategyRegistry.strategyRuntimeFactory = factory;
+  for (const state of registryStateByProjectRoot.values()) {
+    for (const strategyName of state.strategyEntriesMap.keys()) {
+      materializeStrategyCreator(strategyName, state);
+    }
   }
-  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 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
-    };
+var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName, cwd);
   }
-  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
-  };
+  return import(
+    /* webpackIgnore: true */
+    moduleName
+  );
 };
-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) {
+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 {
-      source: null,
-      available: false,
-      primaryReferenceSymbol: null,
-      referenceSymbols: [],
-      primaryTradeFlowBuyPressurePct: null,
-      primaryTradeFlowStale: null
+      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;
   }
-  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");
-
-// src/tradejsConfig.ts
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_url = require("url");
-var import_config = require("@tradejs/core/config");
-var import_logger2 = require("@tradejs/infra/logger");
-var CONFIG_FILE_NAMES = [
-  "tradejs.config.ts",
-  "tradejs.config.mts",
-  "tradejs.config.js",
-  "tradejs.config.mjs",
-  "tradejs.config.cjs"
-];
-var TS_MODULE_RE = /\.(cts|mts|ts)$/i;
-var cachedByCwd = /* @__PURE__ */ new Map();
-var announcedConfigFile = /* @__PURE__ */ new Set();
-var tsNodeRegistered = false;
-var tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
-var tsconfigPathMatchersByCwd = /* @__PURE__ */ new Map();
-var getTradejsProjectCwd = (cwd) => {
-  const explicit = String(cwd ?? "").trim();
-  if (explicit) {
-    return import_path.default.resolve(explicit);
-  }
-  const fromEnv = String(process.env.PROJECT_CWD || "").trim();
-  if (fromEnv) {
-    return import_path.default.resolve(fromEnv);
+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) {
+                registerEntries(
+                  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")
+        );
+      }
+    })();
   }
-  return process.cwd();
+  await state.pluginsLoadPromise;
 };
-var normalizeConfig = (rawConfig) => {
-  if (!rawConfig || typeof rawConfig !== "object") {
-    return {};
+var ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).creator;
   }
-  const config = rawConfig;
-  const strategies2 = Array.isArray(config.strategies) ? config.strategies.map((value) => String(value || "").trim()).filter(Boolean) : [];
-  const indicators = Array.isArray(config.indicators) ? config.indicators.map((value) => String(value || "").trim()).filter(Boolean) : [];
-  const connectors = Array.isArray(config.connectors) ? config.connectors.map((value) => String(value || "").trim()).filter(Boolean) : [];
-  const hooks = (0, import_config.normalizeTradejsConfigHooks)(
-    config.hooks
-  );
-  const runtime = config.runtime && typeof config.runtime === "object" && !Array.isArray(config.runtime) ? config.runtime : void 0;
-  return {
-    strategies: strategies2,
-    indicators,
-    connectors,
-    ...hooks ? { hooks } : {},
-    ...runtime ? { runtime } : {}
-  };
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.get(name);
 };
-var getNodeCreateRequire = () => {
-  const builtinModule = process.getBuiltinModule?.("module");
-  if (typeof builtinModule?.createRequire === "function") {
-    return builtinModule.createRequire;
-  }
-  throw new TypeError("module.createRequire is not available");
+var getStrategyDefaults = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyEntriesMap.get(name)?.defaults;
 };
-var getRequireFn = (cwd = getTradejsProjectCwd()) => getNodeCreateRequire()(import_path.default.join(import_path.default.resolve(cwd), "__tradejs_loader__.js"));
-var ensureTsNodeRegistered = async () => {
-  if (tsNodeRegistered) {
-    return;
-  }
-  const tsNodeModule = await import("ts-node");
-  const tsNode = tsNodeModule.default ?? tsNodeModule;
-  tsNode.register?.({
-    transpileOnly: true,
-    compilerOptions: {
-      module: "Node16",
-      moduleResolution: "node16"
-    }
-  });
-  tsNodeRegistered = true;
+var getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
 };
-var ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
-  const projectRoot = getTradejsProjectCwd(cwd);
-  if (tsconfigPathsRegisteredByCwd.has(projectRoot)) {
-    return;
-  }
-  const tsconfigPathsModule = await import("tsconfig-paths");
-  const loadConfig = tsconfigPathsModule.loadConfig;
-  const register = tsconfigPathsModule.register;
-  if (typeof loadConfig !== "function" || typeof register !== "function") {
-    return;
-  }
-  const loadedConfig = loadConfig(projectRoot);
-  if (loadedConfig.resultType !== "success") {
-    return;
-  }
-  register({
-    baseUrl: loadedConfig.absoluteBaseUrl,
-    paths: loadedConfig.paths,
-    addMatchAll: false
-  });
-  tsconfigPathsRegisteredByCwd.add(projectRoot);
+var getRegisteredStrategies = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return Object.fromEntries(state.strategyCreators.entries());
 };
-var resolveTsconfigPathModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
-  const projectRoot = getTradejsProjectCwd(cwd);
-  const cachedMatcher = tsconfigPathMatchersByCwd.get(projectRoot);
-  if (cachedMatcher) {
-    const resolved2 = cachedMatcher(moduleName);
-    return resolved2 || null;
-  }
-  const tsconfigPathsModule = await import("tsconfig-paths");
-  const loadConfig = tsconfigPathsModule.loadConfig;
-  const createMatchPath = tsconfigPathsModule.createMatchPath;
-  if (typeof loadConfig !== "function" || typeof createMatchPath !== "function") {
-    return null;
-  }
-  const loadedConfig = loadConfig(projectRoot);
-  if (loadedConfig.resultType !== "success") {
-    return null;
-  }
-  const matchPath = createMatchPath(
-    loadedConfig.absoluteBaseUrl,
-    loadedConfig.paths
-  );
-  const matcher = (requestedModule) => matchPath(requestedModule, void 0, import_fs.default.existsSync, [
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".json"
-  ]) || "";
-  tsconfigPathMatchersByCwd.set(projectRoot, matcher);
-  const resolved = matcher(moduleName);
-  return resolved || null;
+var getRegisteredManifests = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyManifestsMap.values()];
 };
-var toImportSpecifier = (moduleName) => {
-  if (moduleName.startsWith("file://")) {
-    return moduleName;
-  }
-  if (import_path.default.isAbsolute(moduleName)) {
-    return (0, import_url.pathToFileURL)(moduleName).href;
+var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+  if (!name) {
+    return void 0;
   }
-  return moduleName;
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyManifestsMap.get(name);
 };
-var isTsModulePath = (moduleName) => TS_MODULE_RE.test(moduleName.split("?")[0]);
-var isRelativeModulePath = (moduleName) => moduleName.startsWith("./") || moduleName.startsWith("../");
-var isBareModuleSpecifier = (moduleName) => {
-  const normalized = String(moduleName ?? "").trim();
-  if (!normalized) {
-    return false;
-  }
-  if (normalized.startsWith("file://") || import_path.default.isAbsolute(normalized) || isRelativeModulePath(normalized)) {
-    return false;
-  }
-  return true;
+var isKnownStrategy = (name, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.has(name);
 };
-var importConfigFile = async (configFilePath) => {
-  const ext = import_path.default.extname(configFilePath).toLowerCase();
-  const configFileUrl = `${toImportSpecifier(configFilePath)}?t=${Date.now()}`;
-  if (ext === ".ts" || ext === ".mts") {
-    const requireFn = getRequireFn(import_path.default.dirname(configFilePath));
-    await ensureTsNodeRegistered();
-    await ensureTsconfigPathsRegistered(import_path.default.dirname(configFilePath));
-    return requireFn(configFilePath);
+var registerStrategyEntries = (entries, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  const issues = validateStrategyEntries("runtime", entries, state);
+  if (issues.length > 0) {
+    throw new Error(["Invalid TradeJS plugin catalog:", ...issues].join("\n"));
   }
-  return import(
-    /* webpackIgnore: true */
-    configFileUrl
-  );
+  registerEntries(entries, "runtime", state);
 };
-var importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
-  const normalized = String(moduleName ?? "").trim();
-  if (!normalized) {
-    return {};
-  }
-  let modulePath = normalized;
-  if (normalized.startsWith("file://")) {
-    try {
-      modulePath = (0, import_url.fileURLToPath)(normalized);
-    } catch {
-      modulePath = normalized;
-    }
-  }
-  const requireFn = getRequireFn(
-    import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : cwd
-  );
-  if (isTsModulePath(modulePath)) {
-    await ensureTsNodeRegistered();
-    await ensureTsconfigPathsRegistered(cwd);
-    return requireFn(modulePath);
+var resetStrategyRegistryCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    registryStateByProjectRoot.clear();
+    (0, import_indicators.resetIndicatorRegistryCache)();
+    return;
   }
-  if (isBareModuleSpecifier(normalized)) {
-    await ensureTsconfigPathsRegistered(cwd);
-    try {
-      return requireFn(normalized);
-    } catch (error) {
-      const resolvedByTsconfig = await resolveTsconfigPathModule(
-        normalized,
-        cwd
-      );
-      if (resolvedByTsconfig && resolvedByTsconfig !== normalized) {
-        return requireFn(resolvedByTsconfig);
+  const projectRoot = getTradejsProjectCwd(normalizedCwd);
+  registryStateByProjectRoot.delete(projectRoot);
+  (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
+};
+var strategies = new Proxy(
+  {},
+  {
+    get: (_target, property) => {
+      if (typeof property !== "string") {
+        return void 0;
       }
-      throw error;
-    }
+      return getStrategyRegistryState().state.strategyCreators.get(property);
+    },
+    ownKeys: () => {
+      return [...getStrategyRegistryState().state.strategyCreators.keys()];
+    },
+    getOwnPropertyDescriptor: () => ({
+      enumerable: true,
+      configurable: true
+    })
   }
-  try {
-    return await import(
-      /* webpackIgnore: true */
-      toImportSpecifier(normalized)
+);
+
+// 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"
     );
-  } catch (error) {
-    if (isTsModulePath(modulePath)) {
-      await ensureTsNodeRegistered();
-      await ensureTsconfigPathsRegistered(cwd);
-      return requireFn(modulePath);
-    }
-    throw error;
-  }
-};
-var resolveExportedConfig = (moduleExports) => {
-  const candidate = moduleExports && typeof moduleExports === "object" && "default" in moduleExports ? moduleExports.default : moduleExports;
-  return normalizeConfig(candidate);
+  return { provider, universeId };
 };
-var findConfigFilePath = (cwd) => {
-  let currentDir = import_path.default.resolve(cwd);
-  while (true) {
-    for (const fileName of CONFIG_FILE_NAMES) {
-      const fullPath = import_path.default.join(currentDir, fileName);
-      if (import_fs.default.existsSync(fullPath) && import_fs.default.statSync(fullPath).isFile()) {
-        return fullPath;
-      }
-    }
-    const parentDir = import_path.default.dirname(currentDir);
-    if (parentDir === currentDir) {
-      return null;
+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);
     }
-    currentDir = parentDir;
   }
+  return (await cached.value)?.get(symbol);
 };
-var resolvePluginModuleSpecifier = (moduleName, cwd = getTradejsProjectCwd()) => {
-  const normalized = String(moduleName ?? "").trim();
-  if (!normalized) {
-    return "";
-  }
-  if (normalized.startsWith("file://")) {
-    try {
-      return (0, import_url.fileURLToPath)(normalized);
-    } catch {
-      return normalized;
-    }
-  }
-  if (import_path.default.isAbsolute(normalized)) {
-    return normalized;
-  }
-  if (isRelativeModulePath(normalized)) {
-    return import_path.default.resolve(cwd, normalized);
-  }
-  return normalized;
-};
-var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
-  const cached = cachedByCwd.get(cwd);
-  if (cached) {
-    return cached;
-  }
-  const configFilePath = findConfigFilePath(cwd);
-  if (!configFilePath) {
-    cachedByCwd.set(cwd, {});
-    return {};
-  }
-  try {
-    const moduleExports = await importConfigFile(configFilePath);
-    const config = resolveExportedConfig(moduleExports);
-    cachedByCwd.set(cwd, config);
-    if (!announcedConfigFile.has(configFilePath)) {
-      announcedConfigFile.add(configFilePath);
-      import_logger2.logger.log("debug", "Loaded TradeJS config: %s", configFilePath);
-    }
-    return config;
-  } catch (error) {
-    import_logger2.logger.log(
-      "warn",
-      "Failed to load TradeJS config from %s: %s",
-      configFilePath,
-      String(error)
-    );
-    cachedByCwd.set(cwd, {});
-    return {};
+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/strategy/manifests.ts
-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 registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
-var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
-  const projectRoot = getTradejsProjectCwd(cwd);
-  let state = registryStateByProjectRoot.get(projectRoot);
-  if (!state) {
-    state = createStrategyRegistryState();
-    registryStateByProjectRoot.set(projectRoot, state);
-  }
-  return {
-    projectRoot,
-    state
+// 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 toUniqueModules = (modules = []) => [
-  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
-];
-var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
-  const config = await loadTradejsConfig(cwd);
-  return {
-    strategyModules: toUniqueModules(config.strategies),
-    indicatorModules: toUniqueModules(config.indicators)
+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
   };
-};
-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];
+  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()
+      }
+    };
   }
-  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`);
+  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 (typeof entry?.parseConfig !== "function") {
-      issues.push(`${entryPath}: parseConfig is required`);
+    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);
     }
-    if (typeof entry?.createCore !== "function") {
-      issues.push(`${entryPath}: createCore is required`);
+    let response;
+    try {
+      response = await responsePromise;
+    } finally {
+      pendingResponses.delete(responseFile);
     }
-  });
-  return issues;
-};
-var registerEntries = (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);
+    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 materializeStrategyCreator = (strategyName, state) => {
-  if (state.strategyCreators.has(strategyName) || !sharedStrategyRegistry.strategyRuntimeFactory) {
-    return;
+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()
+    };
   }
-  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)
-    })
+  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;
 };
-var setStrategyRuntimeFactory = (factory) => {
-  sharedStrategyRegistry.strategyRuntimeFactory = factory;
-  for (const state of registryStateByProjectRoot.values()) {
-    for (const strategyName of state.strategyEntriesMap.keys()) {
-      materializeStrategyCreator(strategyName, state);
-    }
+
+// src/strategyRuntime.ts
+var import_constants5 = require("@tradejs/core/constants");
+var import_strategies6 = require("@tradejs/core/strategies");
+var import_logger11 = require("@tradejs/infra/logger");
+
+// src/strategyHelpers/runtime.ts
+var import_logger9 = require("@tradejs/infra/logger");
+var import_constants3 = require("@tradejs/core/constants");
+var import_ml2 = require("@tradejs/infra/ml");
+
+// src/strategy/entrySubmissionValidation.ts
+var import_logger3 = require("@tradejs/infra/logger");
+
+// src/strategy/entryExecutionValidation.ts
+var EntrySubmissionValidationError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.name = "EntrySubmissionValidationError";
   }
 };
-var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
-  if (typeof importTradejsModule === "function") {
-    return importTradejsModule(moduleName, cwd);
-  }
-  return import(
-    /* webpackIgnore: true */
-    moduleName
-  );
+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 resolveStrategyModuleEntry = async ({
-  strategyName,
-  moduleName,
-  cwd
+var validateEntryExecution = ({
+  direction,
+  price,
+  qty,
+  stopLossPrice,
+  takeProfitPrice,
+  limits
 }) => {
-  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 (!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"
     );
-    if (issues.length > 0) {
-      throw new Error(
-        ["Invalid TradeJS strategy module:", ...issues].join("\n")
-      );
-    }
-    const entry = pluginDefinition.strategyEntries.find(
-      (candidate) => candidate.manifest.name === strategyName
+  const side = direction === "LONG" ? 1 : -1;
+  if (side * (price - stopLossPrice) <= 0 || side * (takeProfitPrice - price) <= 0)
+    throw new EntrySubmissionValidationError(
+      "INVALID_ENTRY_PROTECTION_AT_SUBMISSION"
     );
-    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]
-      )
+  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"
     );
-    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);
+  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 {
-    return await resolution;
+    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) {
-    state.strategyModuleResolutions.delete(cacheKey);
-    throw error;
+    import_logger3.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 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) {
-                registerEntries(
-                  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 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");
   }
-  await state.pluginsLoadPromise;
+  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_logger3.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);
+  };
+};
+
+// src/ai.ts
+var import_aiLanguages2 = require("@tradejs/core/aiLanguages");
+var import_redis3 = 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 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: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+    indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+    available: true,
+    value,
+    zScore,
+    bps,
+    absBps,
+    bias,
+    severity
+  };
+};
+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
+    };
+  }
+  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)
+  };
+};
+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)
+  };
+};
+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
+    };
+  }
+  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 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)
+    };
+  };
+  return {
+    top5: build("top5"),
+    top10: build("top10"),
+    top30: build("top30"),
+    top50: build("top50"),
+    top100: build("top100")
+  };
+};
+var buildTargetVsReference = (signal, asset) => {
+  const base = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(base?.relative);
+  const target = toRecord(relative?.[`targetVs${asset}`]);
+  return {
+    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 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 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 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 {
+    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 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
+    };
+  }
+  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 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
+    };
+  }
+  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 ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
-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);
-};
-var getStrategyDefaults = async (name, cwd = getTradejsProjectCwd()) => {
-  await ensureStrategyPluginsLoaded(cwd);
-  const { state } = getStrategyRegistryState(cwd);
-  return state.strategyEntriesMap.get(name)?.defaults;
-};
-var getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
-  await ensureStrategyPluginsLoaded(cwd);
-  const { state } = getStrategyRegistryState(cwd);
-  return [...state.strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
-};
-var getRegisteredStrategies = (cwd = getTradejsProjectCwd()) => {
-  const { state } = getStrategyRegistryState(cwd);
-  return Object.fromEntries(state.strategyCreators.entries());
-};
-var getRegisteredManifests = (cwd = getTradejsProjectCwd()) => {
-  const { state } = getStrategyRegistryState(cwd);
-  return [...state.strategyManifestsMap.values()];
+  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 getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
-  if (!name) {
-    return void 0;
+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
+    };
   }
-  const { state } = getStrategyRegistryState(cwd);
-  return state.strategyManifestsMap.get(name);
-};
-var isKnownStrategy = (name, cwd = getTradejsProjectCwd()) => {
-  const { state } = getStrategyRegistryState(cwd);
-  return state.strategyCreators.has(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 registerStrategyEntries = (entries, cwd = getTradejsProjectCwd()) => {
-  const { state } = getStrategyRegistryState(cwd);
-  const issues = validateStrategyEntries("runtime", entries, state);
-  if (issues.length > 0) {
-    throw new Error(["Invalid TradeJS plugin catalog:", ...issues].join("\n"));
+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
+    };
   }
-  registerEntries(entries, "runtime", state);
+  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 resetStrategyRegistryCache = (cwd) => {
-  const normalizedCwd = String(cwd ?? "").trim();
-  if (!normalizedCwd) {
-    registryStateByProjectRoot.clear();
-    (0, import_indicators.resetIndicatorRegistryCache)();
-    return;
+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 projectRoot = getTradejsProjectCwd(normalizedCwd);
-  registryStateByProjectRoot.delete(projectRoot);
-  (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
+  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) => {
@@ -2570,12 +3304,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?.({
@@ -3037,7 +3820,7 @@ var askAI = async (signal, options = {}) => {
       payload
     }
   );
-  await (0, import_redis.setData)(import_redis.redisKeys.analysis(symbol, signal.signalId), content);
+  await (0, import_redis3.setData)(import_redis3.redisKeys.analysis(symbol, signal.signalId), content);
   return content;
 };
 
@@ -3089,254 +3872,6 @@ var buildMlPayload = (payload) => {
   };
 };
 
-// src/runtimeJournal.ts
-var import_node_crypto = require("crypto");
-var import_constants = require("@tradejs/core/constants");
-var import_time = require("@tradejs/core/time");
-var import_trade = require("@tradejs/core/trade");
-var import_logger3 = 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
-}) => {
-  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_time.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_logger3.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_time.getRuntimeStorageDayKey)(existing.entryTimestamp);
-  try {
-    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_logger3.logger.error(
-      "runtime trade increase journal failed: %s %s",
-      symbol,
-      error?.message || String(error)
-    );
-  }
-  return next;
-};
-var getActiveRuntimeTrade = async (params) => {
-  const { userName, symbol, accountId, deploymentId } = params;
-  if (!userName) {
-    return null;
-  }
-  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;
-  }
-  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 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()
-  };
-  const dayKey = (0, import_time.getRuntimeStorageDayKey)(existing.entryTimestamp);
-  const closeDayKey = (0, import_time.getRuntimeStorageDayKey)(next.exitTimestamp);
-  try {
-    await Promise.all([
-      (0, import_redis2.setData)(import_redis2.redisKeys.runtimeTrade(userName, orderId), next, {
-        expire: import_constants.TTL_1M
-      }),
-      (0, import_redis2.setHashJsonField)(
-        import_redis2.redisKeys.runtimeTradeBucket(userName, dayKey),
-        orderId,
-        next,
-        { expire: import_constants.TTL_1M }
-      ),
-      (0, import_redis2.setHashJsonField)(
-        import_redis2.redisKeys.runtimeClosedTradeBucket(userName, closeDayKey),
-        orderId,
-        next,
-        { expire: import_constants.TTL_1M }
-      ),
-      (0, import_redis2.delKey)(
-        import_redis2.redisKeys.runtimeActiveTrade(
-          userName,
-          symbol,
-          deploymentId ?? accountId
-        )
-      )
-    ]);
-  } catch (error) {
-    import_logger3.logger.error(
-      "runtime trade close journal failed: %s %s",
-      symbol,
-      error?.message || String(error)
-    );
-  }
-  return next;
-};
-
 // src/strategyHelpers/marketContextStages.ts
 var import_logger8 = require("@tradejs/infra/logger");
 
@@ -3346,7 +3881,7 @@ var import_logger4 = 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 = {
@@ -3585,7 +4120,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,
@@ -4609,7 +5144,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_data2 = require("@tradejs/core/data");
 var import_strategies3 = require("@tradejs/core/strategies");
 var import_constants2 = require("@tradejs/core/constants");
@@ -4643,7 +5178,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"]
   })
@@ -4771,7 +5306,7 @@ var enrichSignalWithDerivativesContext = async (params) => {
     const targetSymbol = normalizeSymbol(signal.symbol);
     const lookbackMs = parseLookbackMs();
     const decisionTimeMs = signal.timestamp + (0, import_data2.intervalToMs)(signal.interval);
-    const derivativesEndMs = (0, import_indicators2.getLastClosedDerivativesBarStartMs)(
+    const derivativesEndMs = (0, import_indicators3.getLastClosedDerivativesBarStartMs)(
       decisionTimeMs,
       "15m"
     );
@@ -4786,7 +5321,7 @@ var enrichSignalWithDerivativesContext = async (params) => {
         });
         return [
           symbol,
-          (0, import_indicators2.buildDerivativesContext)({
+          (0, import_indicators3.buildDerivativesContext)({
             symbol,
             direction: signal.direction,
             timestamp: derivativesEndMs,
@@ -4813,7 +5348,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,
@@ -4861,7 +5396,7 @@ var import_hyperliquidWhales2 = require("@tradejs/infra/timescale/hyperliquidWha
 var import_logger7 = 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 = {
@@ -5033,7 +5568,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`);
@@ -5520,6 +6055,7 @@ var enrichSignalWithMarketContextStages = async ({
       })
     });
   }
+  await enrichSignalWithTickerProfile(signal);
   const results = [];
   for (const stage of stages) {
     if (abortSignal?.aborted) break;
@@ -5567,12 +6103,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;
     }
@@ -5732,7 +6268,9 @@ var executeEntryOrder = async ({
   beforePlaceOrder,
   recordRuntimeTrade = true,
   leverage,
-  executionLimits
+  executionLimits,
+  markPortfolioSubmitted,
+  rejectPortfolioSubmission
 }) => {
   await beforePlaceOrder?.();
   const previousPosition = positionIntent === "increase" ? await connector.getPosition(symbol) : null;
@@ -5805,7 +6343,13 @@ var executeEntryOrder = async ({
     ...typeof leverage === "number" && Number.isFinite(leverage) ? { leverage } : {},
     orderId,
     signal,
-    ...beforeSubmit ? { beforeSubmit } : {}
+    ...rejectPortfolioSubmission ? { onRejected: rejectPortfolioSubmission } : {},
+    ...beforeSubmit || markPortfolioSubmitted ? {
+      beforeSubmit: async (context) => {
+        await beforeSubmit?.(context);
+        await markPortfolioSubmitted?.(context.qty);
+      }
+    } : {}
   });
   const orderAckTime = Date.now();
   const placedQty = typeof signal.orderQty === "number" && Number.isFinite(signal.orderQty) && signal.orderQty > 0 ? signal.orderQty : qty;
@@ -6793,7 +7337,7 @@ var handleProtectDecision = async ({
   }
   return decision.code;
 };
-var executeEntryDecision = async ({
+var executeAdmittedEntryDecision = async ({
   connector,
   symbol,
   decision,
@@ -6807,7 +7351,9 @@ var executeEntryDecision = async ({
   ai,
   recordRuntimeJournal,
   invokeStageHooks,
-  notifyRuntimeError
+  notifyRuntimeError,
+  markPortfolioSubmitted,
+  rejectPortfolioSubmission
 }) => {
   const signal = decision.signal;
   const beforePlaceOrder = async () => {
@@ -6854,6 +7400,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,
@@ -6994,6 +7542,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(
@@ -7021,6 +7600,7 @@ var createStrategyRuntime = ({
   };
   const creator = async ({
     userName,
+    connectorName,
     config: baseConfig,
     symbol,
     universe: requestedUniverse,
@@ -7059,6 +7639,17 @@ var createStrategyRuntime = ({
     const projectConfig = await loadTradejsConfig(projectRoot);
     const projectHooks = projectConfig.hooks;
     const env = String(config.ENV ?? "BACKTEST");
+    const portfolio = getPortfolioRuntime({
+      connectorName,
+      value: baseConfig?.PORTFOLIO_POLICY ?? config.PORTFOLIO_POLICY,
+      strategy: strategyName,
+      connector,
+      env,
+      userName,
+      accountId,
+      deploymentId
+    });
+    const portfolioContext = portfolio ? (now2) => isRuntimeOrderExecutionEnabled({ config, env, connector }) ? portfolio.tick(now2) : portfolio.context(now2) : void 0;
     const researchPolicyValue = baseConfig?.RESEARCH_ENTRY_POLICY ?? config.RESEARCH_ENTRY_POLICY;
     const researchEntryPolicy = researchPolicyValue == null ? void 0 : parseResearchEntryPolicy(researchPolicyValue);
     if (researchEntryPolicy && (env !== "BACKTEST" || Reflect.get(connector, "__tradejsTestConnector") !== true))
@@ -7357,6 +7948,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;
         }
@@ -7524,6 +8129,8 @@ var createStrategyRuntime = ({
         runtime: pending2.runtime
       });
       return executeEntryDecision({
+        portfolio,
+        portfolioTime: env === "BACKTEST" || env === "PARITY" ? candle.timestamp : Date.now(),
         connector,
         symbol,
         decision: pending2.decision,
@@ -7541,6 +8148,10 @@ var createStrategyRuntime = ({
       });
     };
     const runWithDecisionOverride = async (candle, btcCandle, options = {}) => {
+      if (portfolioContext)
+        await portfolioContext(
+          env === "BACKTEST" || env === "PARITY" ? candle.timestamp : Date.now()
+        );
       appendCurrentMarketData(candle, btcCandle, options.ethCandle);
       const ethCandle = resolveEthCandle(candle, options.ethCandle);
       indicatorsState.setCurrentBar(candle, btcCandle, ethCandle);
@@ -7711,6 +8322,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;
@@ -7950,6 +8568,8 @@ var createStrategyRuntime = ({
         });
       }
       return executeEntryDecision({
+        portfolio,
+        portfolioTime: env === "BACKTEST" || env === "PARITY" ? candle.timestamp : Date.now(),
         connector,
         symbol,
         decision,