@tradejs/node 3.1.29-beta.262 → 3.1.29-beta.264

package/dist/mcp.mjs

@@ -0,0 +1,584 @@
+import "./chunk-JQOLTLEY.mjs";
+import "./chunk-ZUMUI37V.mjs";
+import {
+  getConnectorCreatorByProvider
+} from "./chunk-QVKUROR2.mjs";
+import {
+  listRuntimeDeployments,
+  loadResolvedRuntimeStrategies
+} from "./chunk-BO42QWAB.mjs";
+import "./chunk-SKY2HNZU.mjs";
+import {
+  ensureIndicatorPluginsLoaded
+} from "./chunk-UL5Z46JL.mjs";
+import "./chunk-LZDXRXIU.mjs";
+import "./chunk-YR55Q355.mjs";
+import "./chunk-GHSLOJLE.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/mcp.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { createIndicators } from "@tradejs/core/indicators";
+import { intervalToMs } from "@tradejs/core/data";
+import {
+  getDataStrict as getDataStrict2,
+  getHashData,
+  getHashJsonField,
+  mcpStorage as mcpStorage2,
+  redisKeys as redisKeys2,
+  scanDataKeys,
+  scanHashJson
+} from "@tradejs/infra/redis";
+import { getRuntimeDeploymentHeartbeat } from "@tradejs/infra/runtimeHeartbeats";
+import { getTradingAccount } from "@tradejs/infra/tradingAccounts";
+import { getRuntimeStorageDayKey } from "@tradejs/core/time";
+
+// src/mcpJobs.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import path from "path";
+import { getDataStrict, mcpStorage, redisKeys } from "@tradejs/infra/redis";
+var MCP_JOB_TTL = 7 * 86400;
+var hash = (value) => createHash("sha256").update(value).digest("hex");
+var mcpJobStorageId = (userName, id) => `jobs:${hash(userName)}:${id}`;
+var mcpJobDirectory = (job) => path.join(
+  String(process.env.PROJECT_CWD || process.cwd()),
+  "data/mcp",
+  hash(job.userName),
+  job.id
+);
+var mcpPackageManifestHash = async () => hash(
+  await readFile(
+    path.join(
+      String(process.env.PROJECT_CWD || process.cwd()),
+      "runtime-package-manifest.json"
+    ),
+    "utf8"
+  )
+);
+var assertWindow = (startTime, endTime, maxDays) => {
+  if (!Number.isSafeInteger(startTime) || !Number.isSafeInteger(endTime) || startTime <= 0 || endTime <= startTime || endTime > Date.now() || endTime - startTime > maxDays * 864e5)
+    throw new Error(`Select a past window of at most ${maxDays} days`);
+};
+var enqueueMcpJob = async (principal, kind, request, idempotencyKey) => {
+  if (!/^[A-Za-z0-9_-]{8,100}$/.test(idempotencyKey))
+    throw new Error(
+      "Provide an idempotencyKey of 8\u2013100 letters, digits, underscores or hyphens"
+    );
+  const id = hash(
+    `${principal.userName}:${principal.clientId}:${idempotencyKey}`
+  );
+  const storageId = mcpJobStorageId(principal.userName, id);
+  const existing = await mcpStorage.get(storageId);
+  if (existing) {
+    if (existing.kind !== kind || existing.request.requestFingerprint !== hash(JSON.stringify(request)))
+      throw new Error("Idempotency key was used for another request");
+    return existing;
+  }
+  const worker = await mcpStorage.get(
+    "worker:heartbeat"
+  );
+  if (!worker) throw new Error("MCP worker is unavailable; no job was queued");
+  if (!await mcpStorage.rateLimit(`jobs:${hash(principal.userName)}`, 10, 3600))
+    throw new Error("Hourly job limit reached");
+  const job = {
+    id,
+    userName: principal.userName,
+    clientId: principal.clientId,
+    kind,
+    status: "queued",
+    request: { ...request, requestFingerprint: hash(JSON.stringify(request)) },
+    args: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    logs: [],
+    outputId: id,
+    packageManifestSha256: await mcpPackageManifestHash()
+  };
+  const outputDir = mcpJobDirectory(job);
+  if (kind === "backtest") {
+    assertWindow(Number(request.startTime), Number(request.endTime), 90);
+    const configId = String(request.configId || "");
+    if (!/^[A-Za-z][A-Za-z0-9]*:[A-Za-z0-9_-]+$/.test(configId))
+      throw new Error("Select a named Strategy:config");
+    const grid = await getDataStrict(
+      redisKeys.backtestConfig(principal.userName, configId)
+    );
+    if (!grid || typeof grid !== "object" || Array.isArray(grid))
+      throw new Error("Backtest config not found");
+    const cells = Object.values(grid);
+    if (!cells.length || !cells.every((cell) => Array.isArray(cell) && cell.length > 0) || cells.reduce((n, cell) => n * cell.length, 1) > 8)
+      throw new Error("MCP backtests allow at most eight config combinations");
+    const symbols = request.symbols;
+    if (!Array.isArray(symbols) || !symbols.length || symbols.length > 20 || !symbols.every(
+      (symbol) => typeof symbol === "string" && /^[A-Z0-9._-]{1,40}$/.test(symbol)
+    ))
+      throw new Error("Select 1\u201320 symbols");
+    const frozenConfigId = `${configId.split(":")[0]}:mcp_${id}`;
+    job.request = {
+      ...job.request,
+      resolvedConfig: grid,
+      configSha256: hash(JSON.stringify(grid)),
+      frozenConfigId
+    };
+    job.args = [
+      "backtest",
+      "--user",
+      principal.userName,
+      "--config",
+      frozenConfigId,
+      "--connector",
+      String(request.provider),
+      "--timeframe",
+      String(request.interval),
+      "--startTime",
+      String(request.startTime),
+      "--endTime",
+      String(request.endTime),
+      "--tickers",
+      symbols.join(","),
+      "--parallel",
+      "1",
+      "--cacheOnly",
+      "--fast",
+      "--persistResults"
+    ];
+  } else if (kind === "runtime-evidence") {
+    assertWindow(Number(request.startTime), Number(request.endTime), 7);
+    job.args = [
+      "runtime-evidence",
+      "--user",
+      principal.userName,
+      "--deployment",
+      String(request.deploymentId),
+      "--startTime",
+      String(request.startTime),
+      "--endTime",
+      String(request.endTime),
+      "--publishDir",
+      outputDir
+    ];
+  } else if (kind === "runtime-feedback-replay") {
+    if (!worker.replayAvailable)
+      throw new Error("MCP replay worker requires an isolated Redis host");
+    if (typeof request.verifiedEvidencePath !== "string")
+      throw new Error("Select verified runtime evidence");
+    job.args = [
+      "runtime-feedback-replay",
+      "--runtimeEvidence",
+      request.verifiedEvidencePath,
+      "--outDir",
+      outputDir,
+      "--runId",
+      id
+    ];
+  } else {
+    throw new Error(
+      "Unsupported diagnostic kind; use verified runtime feedback for deployment-bound parity"
+    );
+  }
+  if (!await mcpStorage.put(storageId, job, MCP_JOB_TTL, true)) {
+    const winner = await readMcpJob(principal.userName, id);
+    if (winner.kind !== kind || winner.request.requestFingerprint !== job.request.requestFingerprint)
+      throw new Error("Idempotency key was used for another request");
+    return winner;
+  }
+  return job;
+};
+var readMcpJob = async (userName, id) => {
+  if (!/^[a-f0-9]{64}$/.test(id)) throw new Error("Invalid job id");
+  const job = await mcpStorage.get(mcpJobStorageId(userName, id));
+  if (!job || job.userName !== userName) throw new Error("Job not found");
+  return job;
+};
+var cancelMcpJob = async (principal, id) => {
+  for (let attempt = 0; attempt < 4; attempt++) {
+    const job = await readMcpJob(principal.userName, id);
+    if (job.clientId !== principal.clientId)
+      throw new Error("Only the submitting client can cancel this job");
+    if (!["queued", "running"].includes(job.status)) return job;
+    const next = {
+      ...job,
+      cancelRequested: true,
+      updatedAt: Date.now(),
+      ...job.status === "queued" ? { status: "cancelled", finishedAt: Date.now() } : {}
+    };
+    if (await mcpStorage.compare(
+      mcpJobStorageId(job.userName, job.id),
+      job,
+      next,
+      MCP_JOB_TTL
+    ))
+      return next;
+  }
+  throw new Error("Job changed; retry cancellation");
+};
+var publicMcpJob = (job) => {
+  const { args: _args, logs: _logs, request: _request, ...view } = job;
+  return {
+    ...view,
+    request: Object.fromEntries(
+      Object.entries(job.request).filter(
+        ([key]) => !["verifiedEvidencePath", "resolvedConfig"].includes(key)
+      )
+    ),
+    logLines: job.logs.length
+  };
+};
+
+// src/mcp.ts
+var mcpProjectRoot = () => String(process.env.PROJECT_CWD || process.cwd());
+var isMcpRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var mcpId = (value) => createHash2("sha256").update(value).digest("hex");
+var redactMcpData = (value) => {
+  if (Array.isArray(value)) return value.map(redactMcpData);
+  if (!isMcpRecord(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).filter(
+      ([key]) => !/secret|password|authorization|api.?key|private.?key|access.?token|refresh.?token|bot.?token|cookie|credential/i.test(
+        key
+      )
+    ).map(([key, nested]) => [key, redactMcpData(nested)])
+  );
+};
+var connectorFor = async (userName, provider, universe) => {
+  const creator = await getConnectorCreatorByProvider(
+    provider,
+    mcpProjectRoot()
+  );
+  if (!creator) throw new Error("Unknown market provider");
+  return creator({ userName, universe });
+};
+var readMcpMarket = async (userName, provider, universe, offset, limit, symbol) => {
+  const connector = await connectorFor(userName, provider, universe);
+  const tickers = await connector.getTickers();
+  const rows = symbol ? tickers.filter((row) => row.symbol === symbol) : tickers;
+  return {
+    provider,
+    universe,
+    items: rows.slice(offset, offset + limit),
+    total: rows.length,
+    nextOffset: offset + limit < rows.length ? offset + limit : null,
+    observedAt: Date.now(),
+    source: "connector"
+  };
+};
+var readMcpChart = async (userName, request) => {
+  const connector = await connectorFor(
+    userName,
+    request.provider,
+    request.universe
+  );
+  const width = intervalToMs(request.interval);
+  const end = Math.floor(Math.min(request.endTime, Date.now()) / width) * width;
+  const visibleStart = end - request.bars * width;
+  const start = Math.max(0, visibleStart - 200 * width);
+  const fetched = await connector.kline({
+    symbol: request.symbol,
+    interval: request.interval,
+    start,
+    end,
+    cacheOnly: request.cacheOnly
+  });
+  const candles = fetched.filter(
+    (candle) => candle.timestamp >= start && candle.timestamp < end
+  );
+  const btc = request.universe === "tradfi" ? [] : request.symbol === "BTCUSDT" ? candles : await connector.kline({
+    symbol: "BTCUSDT",
+    interval: request.interval,
+    start,
+    end,
+    cacheOnly: request.cacheOnly
+  });
+  const visibleCandles = candles.filter((candle) => candle.timestamp >= visibleStart).slice(-request.bars);
+  await ensureIndicatorPluginsLoaded(mcpProjectRoot());
+  const allIndicators = createIndicators(
+    candles,
+    btc.filter((candle) => candle.timestamp < end),
+    {
+      includeMlPayload: false,
+      pluginRegistryScope: mcpProjectRoot()
+    }
+  ).result();
+  return {
+    ...request,
+    startTime: visibleStart,
+    historyStartTime: start,
+    warmupBars: 200,
+    endTime: end,
+    candles: visibleCandles,
+    indicators: Object.fromEntries(
+      (request.indicatorNames || ["maFast", "maSlow", "atr", "macd"]).map(
+        (key) => [
+          key,
+          Array.isArray(allIndicators[key]) ? allIndicators[key].slice(
+            -request.bars
+          ) : allIndicators[key] ?? null
+        ]
+      )
+    ),
+    availableIndicators: Object.keys(allIndicators),
+    observedAt: Date.now(),
+    source: request.cacheOnly ? "cached_history" : "connector",
+    closedCandlesOnly: true,
+    coverage: {
+      requestedBars: request.bars,
+      availableBars: candles.filter(
+        (candle) => candle.timestamp >= visibleStart
+      ).length,
+      complete: candles.filter((candle) => candle.timestamp >= visibleStart).length >= request.bars
+    }
+  };
+};
+var readMcpDeployments = async (userName) => {
+  const deployments = await listRuntimeDeployments({
+    userName,
+    projectRoot: mcpProjectRoot()
+  });
+  const allowed = [];
+  for (const deployment of deployments) {
+    if (!await getTradingAccount(userName, deployment.accountId)) continue;
+    allowed.push({
+      ...deployment,
+      heartbeat: await getRuntimeDeploymentHeartbeat(userName, deployment.id)
+    });
+  }
+  return {
+    deployments: allowed,
+    observedAt: Date.now(),
+    source: "project_declaration_and_runtime_storage"
+  };
+};
+var requireMcpDeployment = async (userName, deploymentId) => {
+  const { deployments } = await readMcpDeployments(userName);
+  const deployment = deployments.find((row) => row.id === deploymentId);
+  if (!deployment) throw new Error("Deployment unavailable for this user");
+  return deployment;
+};
+var readMcpStrategies = async (userName, deploymentId) => {
+  const deployment = await requireMcpDeployment(userName, deploymentId);
+  const rows = await loadResolvedRuntimeStrategies({
+    userName,
+    projectRoot: mcpProjectRoot(),
+    deploymentId
+  });
+  return {
+    deploymentId,
+    accountId: deployment.accountId,
+    strategies: rows.map(({ strategyCreator: _creator, ...row }) => row),
+    observedAt: Date.now()
+  };
+};
+var readMcpRuntimePage = async (userName, kind, request) => {
+  const deployment = await requireMcpDeployment(userName, request.deploymentId);
+  const prefix = kind === "signals" ? redisKeys2.runtimeSignalBuckets(userName) : kind === "evaluations" ? redisKeys2.runtimeSignalEvaluationBuckets(userName) : redisKeys2.runtimeTrades(userName);
+  const { cursor: _cursor, ...filters } = request;
+  const binding = mcpId(JSON.stringify({ userName, kind, ...filters }));
+  let state = {
+    binding,
+    scan: "0",
+    keys: [],
+    hash: "0",
+    values: [],
+    scanned: false
+  };
+  if (request.cursor !== "0") {
+    const saved = await mcpStorage2.get(
+      `cursor:${request.cursor}`
+    );
+    if (!saved || saved.binding !== binding)
+      throw new Error("Invalid storage cursor");
+    state = saved;
+  }
+  if (!state.keys.length && !state.values.length && (!state.scanned || state.scan !== "0")) {
+    const page = await scanDataKeys(prefix, state.scan);
+    state = { ...state, scan: page.cursor, keys: page.keys, scanned: true };
+  }
+  if (!state.values.length && state.keys.length) {
+    const key = state.keys[0];
+    if (kind === "orders") {
+      state.keys.shift();
+      if (!key.slice(prefix.length).startsWith("days:"))
+        state.values = [await getDataStrict2(key)];
+    } else {
+      const page = await scanHashJson(key, state.hash);
+      state.values = page.values;
+      state.hash = page.cursor;
+      if (page.cursor === "0") state.keys.shift();
+    }
+  }
+  const items = [];
+  for (let row of state.values.splice(0, 50)) {
+    if (kind === "signals" && isMcpRecord(row) && typeof row.symbol === "string" && typeof row.signalId === "string")
+      row = await getDataStrict2(
+        redisKeys2.storeSignal(row.symbol, row.signalId)
+      );
+    if (!isMcpRecord(row) || row.deploymentId !== request.deploymentId || row.accountId !== deployment.accountId || row.userName !== void 0 && row.userName !== userName || request.strategy && row.strategy !== request.strategy || request.symbol && row.symbol !== request.symbol)
+      continue;
+    const timestamp = Number(
+      row.timestamp ?? row.entryTimestamp ?? row.createdAt
+    );
+    if (timestamp < request.startTime || timestamp >= request.endTime || !Number.isFinite(timestamp))
+      continue;
+    const {
+      figures: _figures,
+      indicators: _indicators,
+      additionalIndicators: _additional,
+      ...summary
+    } = row;
+    items.push(summary);
+  }
+  let next = "0";
+  if (state.values.length || state.keys.length || state.scan !== "0") {
+    next = mcpId(randomUUID());
+    await mcpStorage2.put(`cursor:${next}`, state, 600);
+  }
+  return {
+    items,
+    cursor: next,
+    deploymentId: request.deploymentId,
+    observedAt: Date.now(),
+    source: "runtime_storage",
+    window: { startTime: request.startTime, endTime: request.endTime },
+    coverage: "stored_records_only",
+    note: "Missing records do not prove no evaluation occurred. Continue until cursor is 0; cursors expire after 10 minutes."
+  };
+};
+var readMcpSignal = async (userName, signalId, deploymentId, timestamp, strategy) => {
+  const deployment = await requireMcpDeployment(userName, deploymentId);
+  const ref = await getHashJsonField(
+    redisKeys2.runtimeSignalBucket(
+      userName,
+      getRuntimeStorageDayKey(timestamp),
+      strategy
+    ),
+    signalId,
+    null
+  );
+  if (!isMcpRecord(ref) || typeof ref.symbol !== "string")
+    throw new Error("Signal not found");
+  const signal = await getDataStrict2(
+    redisKeys2.storeSignal(ref.symbol, signalId)
+  );
+  if (!isMcpRecord(signal) || signal.deploymentId !== deploymentId || signal.accountId !== deployment.accountId || signal.userName !== void 0 && signal.userName !== userName)
+    throw new Error("Signal not found");
+  return { signal, observedAt: Date.now(), source: "runtime_storage" };
+};
+var readMcpEvaluationStats = async (userName, deploymentId, cursor) => {
+  await requireMcpDeployment(userName, deploymentId);
+  const page = await scanDataKeys(
+    redisKeys2.runtimeSignalEvaluationStatsBuckets(userName),
+    cursor
+  );
+  const buckets = [];
+  for (const key of page.keys) {
+    const parts = key.slice(redisKeys2.runtimeSignalEvaluationStatsBuckets(userName).length).split(":");
+    if (parts.slice(1, -1).join(":") !== deploymentId) continue;
+    buckets.push({
+      bucket: key.slice(
+        redisKeys2.runtimeSignalEvaluationStatsBuckets(userName).length
+      ),
+      counters: await getHashData(key)
+    });
+  }
+  return {
+    buckets,
+    cursor: page.cursor,
+    observedAt: Date.now(),
+    source: "debug_telemetry",
+    immutableEvidence: false,
+    note: "Aggregate counters are not composition-bound evidence. Detailed skip records may not have been captured."
+  };
+};
+var readMcpBacktestPage = async (userName, kind, cursor) => {
+  const prefix = kind === "configs" ? `users:${userName}:backtests:configs:` : `users:${userName}:backtests:results:`;
+  const page = await scanDataKeys(prefix, cursor);
+  const items = [];
+  for (const key of page.keys) {
+    const value = await getDataStrict2(key);
+    items.push({
+      id: key.slice(prefix.length),
+      value: kind === "results" && isMcpRecord(value) ? {
+        config: value.config,
+        mode: value.mode,
+        startedAt: value.startedAt,
+        finishedAt: value.finishedAt,
+        successTests: value.successTests,
+        errorTests: value.errorTests,
+        resultCount: Array.isArray(value.results) ? value.results.length : 0
+      } : value
+    });
+  }
+  return {
+    items,
+    cursor: page.cursor,
+    observedAt: Date.now(),
+    source: "backtest_storage"
+  };
+};
+var readMcpBacktestResult = async (userName, id, offset = 0, limit = 20) => {
+  if (id.includes("*") || id.includes("?") || id.includes("["))
+    throw new Error("Invalid result identifier");
+  const result = await getDataStrict2(
+    `users:${userName}:backtests:results:${id}`
+  );
+  if (!result) throw new Error("Result not found");
+  const record = isMcpRecord(result) ? result : { results: result };
+  const groups = ["results", "resultsByTickers", "resultsByStrategies"];
+  const pageGroup = (group) => Array.isArray(record[group]) ? record[group].slice(offset, offset + limit) : record[group];
+  const paged = {
+    results: pageGroup("results"),
+    resultsByTickers: pageGroup("resultsByTickers"),
+    resultsByStrategies: pageGroup("resultsByStrategies")
+  };
+  const total = Math.max(
+    0,
+    ...groups.map(
+      (group) => Array.isArray(record[group]) ? record[group].length : 0
+    )
+  );
+  return {
+    id,
+    result: {
+      config: record.config,
+      mode: record.mode,
+      startedAt: record.startedAt,
+      finishedAt: record.finishedAt,
+      successTests: record.successTests,
+      errorTests: record.errorTests,
+      bestConfig: record.bestConfig,
+      mergedConfig: record.mergedConfig,
+      runtimeComparison: record.runtimeComparison,
+      ...paged
+    },
+    offset,
+    total,
+    nextOffset: offset + limit < total ? offset + limit : null,
+    observedAt: Date.now(),
+    source: "backtest_storage"
+  };
+};
+export {
+  MCP_JOB_TTL,
+  cancelMcpJob,
+  enqueueMcpJob,
+  isMcpRecord,
+  mcpId,
+  mcpJobDirectory,
+  mcpJobStorageId,
+  mcpPackageManifestHash,
+  mcpProjectRoot,
+  publicMcpJob,
+  readMcpBacktestPage,
+  readMcpBacktestResult,
+  readMcpChart,
+  readMcpDeployments,
+  readMcpEvaluationStats,
+  readMcpJob,
+  readMcpMarket,
+  readMcpRuntimePage,
+  readMcpSignal,
+  readMcpStrategies,
+  redactMcpData,
+  requireMcpDeployment
+};

package/dist/registry.mjs

@@ -1,3 +1,4 @@
+import "./chunk-JQOLTLEY.mjs";
 import "./chunk-SKY2HNZU.mjs";
 import {
   ensureIndicatorPluginsLoaded,

package/dist/runtimeDashboard.js

@@ -9201,7 +9201,7 @@ var groupRuntimeTradesByIdentity = (trades, identities) => {
   const grouped = /* @__PURE__ */ new Map();
   for (const trade of trades) {
     const matches = [...identities.entries()].filter(([, identity]) => {
-      if (trade.strategy !== identity.strategyName || String(trade.interval) !== String(identity.interval)) {
+      if (trade.strategy !== identity.strategyName || trade.interval != null && String(trade.interval) !== String(identity.interval)) {
         return false;
       }
       if (trade.deploymentId && trade.deploymentId !== identity.deploymentId) {

package/dist/runtimeDashboard.mjs

@@ -1,7 +1,3 @@
-import {
-  listRuntimeDeployments,
-  loadResolvedRuntimeStrategies
-} from "./chunk-BO42QWAB.mjs";
 import {
   buildExchangeFallbackRuntimeTrades,
   takeClosedPnlMatch
@@ -9,6 +5,10 @@ import {
 import {
   getConnectorCreatorByProvider
 } from "./chunk-QVKUROR2.mjs";
+import {
+  listRuntimeDeployments,
+  loadResolvedRuntimeStrategies
+} from "./chunk-BO42QWAB.mjs";
 import "./chunk-SKY2HNZU.mjs";
 import "./chunk-UL5Z46JL.mjs";
 import "./chunk-LZDXRXIU.mjs";
@@ -266,7 +266,7 @@ var groupRuntimeTradesByIdentity = (trades, identities) => {
   const grouped = /* @__PURE__ */ new Map();
   for (const trade of trades) {
     const matches = [...identities.entries()].filter(([, identity]) => {
-      if (trade.strategy !== identity.strategyName || String(trade.interval) !== String(identity.interval)) {
+      if (trade.strategy !== identity.strategyName || trade.interval != null && String(trade.interval) !== String(identity.interval)) {
         return false;
       }
       if (trade.deploymentId && trade.deploymentId !== identity.deploymentId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/node",
-  "version": "3.1.29-beta.262",
+  "version": "3.1.29-beta.264",
   "description": "Node-only runtime for the TradeJS TypeScript framework: strategies, backtests, Pine strategy loading, and plugin registries.",
   "keywords": [
     "tradejs",
@@ -90,14 +90,24 @@
       "types": "./dist/jev.d.ts",
       "import": "./dist/jev.mjs",
       "require": "./dist/jev.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp.d.ts",
+      "import": "./dist/mcp.mjs",
+      "require": "./dist/mcp.js"
+    },
+    "./diagnostics": {
+      "types": "./dist/diagnostics.d.ts",
+      "import": "./dist/diagnostics.mjs",
+      "require": "./dist/diagnostics.js"
     }
   },
   "dependencies": {
     "@langchain/core": "^1.2.3",
     "@langchain/openai": "^1.5.5",
-    "@tradejs/core": "^3.1.29-beta.262",
-    "@tradejs/infra": "^3.1.29-beta.262",
-    "@tradejs/types": "^3.1.29-beta.262",
+    "@tradejs/core": "^3.1.29-beta.264",
+    "@tradejs/infra": "^3.1.29-beta.264",
+    "@tradejs/types": "^3.1.29-beta.264",
     "@types/node": "^24",
     "chalk": "4.1.2",
     "ioredis": "5.11.1",
@@ -110,7 +120,7 @@
     "typescript": "^5.9"
   },
   "devDependencies": {
-    "@tradejs/indicators": "^3.1.29-beta.262",
+    "@tradejs/indicators": "^3.1.29-beta.264",
     "@tradejs/strategy-adaptive-momentum-ribbon": "3.0.2",
     "@tradejs/strategy-hyperliquid-consensus": "3.0.2",
     "@tradejs/strategy-kit": "3.0.6",