@tradejs/node 1.0.9 → 1.0.10

package/dist/cli.js

@@ -1361,11 +1361,11 @@ var require_lodash = __commonJS({
             return isFunction(object[key]);
           });
         }
-        function baseGet(object, path3) {
-          path3 = castPath(path3, object);
-          var index = 0, length = path3.length;
+        function baseGet(object, path4) {
+          path4 = castPath(path4, object);
+          var index = 0, length = path4.length;
           while (object != null && index < length) {
-            object = object[toKey(path3[index++])];
+            object = object[toKey(path4[index++])];
           }
           return index && index == length ? object : undefined2;
         }
@@ -1429,10 +1429,10 @@ var require_lodash = __commonJS({
           });
           return accumulator;
         }
-        function baseInvoke(object, path3, args) {
-          path3 = castPath(path3, object);
-          object = parent(object, path3);
-          var func = object == null ? object : object[toKey(last(path3))];
+        function baseInvoke(object, path4, args) {
+          path4 = castPath(path4, object);
+          object = parent(object, path4);
+          var func = object == null ? object : object[toKey(last(path4))];
           return func == null ? undefined2 : apply(func, object, args);
         }
         function baseIsArguments(value) {
@@ -1588,13 +1588,13 @@ var require_lodash = __commonJS({
             return object === source || baseIsMatch(object, source, matchData);
           };
         }
-        function baseMatchesProperty(path3, srcValue) {
-          if (isKey(path3) && isStrictComparable(srcValue)) {
-            return matchesStrictComparable(toKey(path3), srcValue);
+        function baseMatchesProperty(path4, srcValue) {
+          if (isKey(path4) && isStrictComparable(srcValue)) {
+            return matchesStrictComparable(toKey(path4), srcValue);
           }
           return function(object) {
-            var objValue = get(object, path3);
-            return objValue === undefined2 && objValue === srcValue ? hasIn(object, path3) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+            var objValue = get(object, path4);
+            return objValue === undefined2 && objValue === srcValue ? hasIn(object, path4) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
           };
         }
         function baseMerge(object, source, srcIndex, customizer, stack) {
@@ -1691,23 +1691,23 @@ var require_lodash = __commonJS({
           });
         }
         function basePick(object, paths) {
-          return basePickBy(object, paths, function(value, path3) {
-            return hasIn(object, path3);
+          return basePickBy(object, paths, function(value, path4) {
+            return hasIn(object, path4);
           });
         }
         function basePickBy(object, paths, predicate) {
           var index = -1, length = paths.length, result2 = {};
           while (++index < length) {
-            var path3 = paths[index], value = baseGet(object, path3);
-            if (predicate(value, path3)) {
-              baseSet(result2, castPath(path3, object), value);
+            var path4 = paths[index], value = baseGet(object, path4);
+            if (predicate(value, path4)) {
+              baseSet(result2, castPath(path4, object), value);
             }
           }
           return result2;
         }
-        function basePropertyDeep(path3) {
+        function basePropertyDeep(path4) {
           return function(object) {
-            return baseGet(object, path3);
+            return baseGet(object, path4);
           };
         }
         function basePullAll(array, values2, iteratee2, comparator) {
@@ -1781,14 +1781,14 @@ var require_lodash = __commonJS({
           var array = values(collection);
           return shuffleSelf(array, baseClamp(n, 0, array.length));
         }
-        function baseSet(object, path3, value, customizer) {
+        function baseSet(object, path4, value, customizer) {
           if (!isObject(object)) {
             return object;
           }
-          path3 = castPath(path3, object);
-          var index = -1, length = path3.length, lastIndex = length - 1, nested = object;
+          path4 = castPath(path4, object);
+          var index = -1, length = path4.length, lastIndex = length - 1, nested = object;
           while (nested != null && ++index < length) {
-            var key = toKey(path3[index]), newValue = value;
+            var key = toKey(path4[index]), newValue = value;
             if (key === "__proto__" || key === "constructor" || key === "prototype") {
               return object;
             }
@@ -1796,7 +1796,7 @@ var require_lodash = __commonJS({
               var objValue = nested[key];
               newValue = customizer ? customizer(objValue, key, nested) : undefined2;
               if (newValue === undefined2) {
-                newValue = isObject(objValue) ? objValue : isIndex(path3[index + 1]) ? [] : {};
+                newValue = isObject(objValue) ? objValue : isIndex(path4[index + 1]) ? [] : {};
               }
             }
             assignValue(nested, key, newValue);
@@ -1962,14 +1962,14 @@ var require_lodash = __commonJS({
             }
           return result2;
         }
-        function baseUnset(object, path3) {
-          path3 = castPath(path3, object);
-          var index = -1, length = path3.length;
+        function baseUnset(object, path4) {
+          path4 = castPath(path4, object);
+          var index = -1, length = path4.length;
           if (!length) {
             return true;
           }
           while (++index < length) {
-            var key = toKey(path3[index]);
+            var key = toKey(path4[index]);
             if (key === "__proto__" && !hasOwnProperty.call(object, "__proto__")) {
               return false;
             }
@@ -1977,11 +1977,11 @@ var require_lodash = __commonJS({
               return false;
             }
           }
-          var obj = parent(object, path3);
-          return obj == null || delete obj[toKey(last(path3))];
+          var obj = parent(object, path4);
+          return obj == null || delete obj[toKey(last(path4))];
         }
-        function baseUpdate(object, path3, updater, customizer) {
-          return baseSet(object, path3, updater(baseGet(object, path3)), customizer);
+        function baseUpdate(object, path4, updater, customizer) {
+          return baseSet(object, path4, updater(baseGet(object, path4)), customizer);
         }
         function baseWhile(array, predicate, isDrop, fromRight) {
           var length = array.length, index = fromRight ? length : -1;
@@ -2864,11 +2864,11 @@ var require_lodash = __commonJS({
           var match = source.match(reWrapDetails);
           return match ? match[1].split(reSplitDetails) : [];
         }
-        function hasPath(object, path3, hasFunc) {
-          path3 = castPath(path3, object);
-          var index = -1, length = path3.length, result2 = false;
+        function hasPath(object, path4, hasFunc) {
+          path4 = castPath(path4, object);
+          var index = -1, length = path4.length, result2 = false;
           while (++index < length) {
-            var key = toKey(path3[index]);
+            var key = toKey(path4[index]);
             if (!(result2 = object != null && hasFunc(object, key))) {
               break;
             }
@@ -3070,8 +3070,8 @@ var require_lodash = __commonJS({
             return apply(func, this, otherArgs);
           };
         }
-        function parent(object, path3) {
-          return path3.length < 2 ? object : baseGet(object, baseSlice(path3, 0, -1));
+        function parent(object, path4) {
+          return path4.length < 2 ? object : baseGet(object, baseSlice(path4, 0, -1));
         }
         function reorder(array, indexes) {
           var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array);
@@ -3706,10 +3706,10 @@ var require_lodash = __commonJS({
           }
           return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
         }
-        var invokeMap = baseRest(function(collection, path3, args) {
-          var index = -1, isFunc = typeof path3 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
+        var invokeMap = baseRest(function(collection, path4, args) {
+          var index = -1, isFunc = typeof path4 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
           baseEach(collection, function(value) {
-            result2[++index] = isFunc ? apply(path3, value, args) : baseInvoke(value, path3, args);
+            result2[++index] = isFunc ? apply(path4, value, args) : baseInvoke(value, path4, args);
           });
           return result2;
         });
@@ -4361,15 +4361,15 @@ var require_lodash = __commonJS({
         function functionsIn(object) {
           return object == null ? [] : baseFunctions(object, keysIn(object));
         }
-        function get(object, path3, defaultValue) {
-          var result2 = object == null ? undefined2 : baseGet(object, path3);
+        function get(object, path4, defaultValue) {
+          var result2 = object == null ? undefined2 : baseGet(object, path4);
           return result2 === undefined2 ? defaultValue : result2;
         }
-        function has(object, path3) {
-          return object != null && hasPath(object, path3, baseHas);
+        function has(object, path4) {
+          return object != null && hasPath(object, path4, baseHas);
         }
-        function hasIn(object, path3) {
-          return object != null && hasPath(object, path3, baseHasIn);
+        function hasIn(object, path4) {
+          return object != null && hasPath(object, path4, baseHasIn);
         }
         var invert = createInverter(function(result2, value, key) {
           if (value != null && typeof value.toString != "function") {
@@ -4422,10 +4422,10 @@ var require_lodash = __commonJS({
             return result2;
           }
           var isDeep = false;
-          paths = arrayMap(paths, function(path3) {
-            path3 = castPath(path3, object);
-            isDeep || (isDeep = path3.length > 1);
-            return path3;
+          paths = arrayMap(paths, function(path4) {
+            path4 = castPath(path4, object);
+            isDeep || (isDeep = path4.length > 1);
+            return path4;
           });
           copyObject(object, getAllKeysIn(object), result2);
           if (isDeep) {
@@ -4451,19 +4451,19 @@ var require_lodash = __commonJS({
             return [prop];
           });
           predicate = getIteratee(predicate);
-          return basePickBy(object, props, function(value, path3) {
-            return predicate(value, path3[0]);
+          return basePickBy(object, props, function(value, path4) {
+            return predicate(value, path4[0]);
           });
         }
-        function result(object, path3, defaultValue) {
-          path3 = castPath(path3, object);
-          var index = -1, length = path3.length;
+        function result(object, path4, defaultValue) {
+          path4 = castPath(path4, object);
+          var index = -1, length = path4.length;
           if (!length) {
             length = 1;
             object = undefined2;
           }
           while (++index < length) {
-            var value = object == null ? undefined2 : object[toKey(path3[index])];
+            var value = object == null ? undefined2 : object[toKey(path4[index])];
             if (value === undefined2) {
               index = length;
               value = defaultValue;
@@ -4472,12 +4472,12 @@ var require_lodash = __commonJS({
           }
           return object;
         }
-        function set(object, path3, value) {
-          return object == null ? object : baseSet(object, path3, value);
+        function set(object, path4, value) {
+          return object == null ? object : baseSet(object, path4, value);
         }
-        function setWith(object, path3, value, customizer) {
+        function setWith(object, path4, value, customizer) {
           customizer = typeof customizer == "function" ? customizer : undefined2;
-          return object == null ? object : baseSet(object, path3, value, customizer);
+          return object == null ? object : baseSet(object, path4, value, customizer);
         }
         var toPairs = createToPairs(keys);
         var toPairsIn = createToPairs(keysIn);
@@ -4499,15 +4499,15 @@ var require_lodash = __commonJS({
           });
           return accumulator;
         }
-        function unset(object, path3) {
-          return object == null ? true : baseUnset(object, path3);
+        function unset(object, path4) {
+          return object == null ? true : baseUnset(object, path4);
         }
-        function update2(object, path3, updater) {
-          return object == null ? object : baseUpdate(object, path3, castFunction(updater));
+        function update2(object, path4, updater) {
+          return object == null ? object : baseUpdate(object, path4, castFunction(updater));
         }
-        function updateWith(object, path3, updater, customizer) {
+        function updateWith(object, path4, updater, customizer) {
           customizer = typeof customizer == "function" ? customizer : undefined2;
-          return object == null ? object : baseUpdate(object, path3, castFunction(updater), customizer);
+          return object == null ? object : baseUpdate(object, path4, castFunction(updater), customizer);
         }
         function values(object) {
           return object == null ? [] : baseValues(object, keys(object));
@@ -4893,17 +4893,17 @@ var require_lodash = __commonJS({
         function matches(source) {
           return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
         }
-        function matchesProperty(path3, srcValue) {
-          return baseMatchesProperty(path3, baseClone(srcValue, CLONE_DEEP_FLAG));
+        function matchesProperty(path4, srcValue) {
+          return baseMatchesProperty(path4, baseClone(srcValue, CLONE_DEEP_FLAG));
         }
-        var method = baseRest(function(path3, args) {
+        var method = baseRest(function(path4, args) {
           return function(object) {
-            return baseInvoke(object, path3, args);
+            return baseInvoke(object, path4, args);
           };
         });
         var methodOf = baseRest(function(object, args) {
-          return function(path3) {
-            return baseInvoke(object, path3, args);
+          return function(path4) {
+            return baseInvoke(object, path4, args);
           };
         });
         function mixin(object, source, options) {
@@ -4950,12 +4950,12 @@ var require_lodash = __commonJS({
         var over = createOver(arrayMap);
         var overEvery = createOver(arrayEvery);
         var overSome = createOver(arraySome);
-        function property(path3) {
-          return isKey(path3) ? baseProperty(toKey(path3)) : basePropertyDeep(path3);
+        function property(path4) {
+          return isKey(path4) ? baseProperty(toKey(path4)) : basePropertyDeep(path4);
         }
         function propertyOf(object) {
-          return function(path3) {
-            return object == null ? undefined2 : baseGet(object, path3);
+          return function(path4) {
+            return object == null ? undefined2 : baseGet(object, path4);
           };
         }
         var range = createRange();
@@ -5408,12 +5408,12 @@ var require_lodash = __commonJS({
         LazyWrapper.prototype.findLast = function(predicate) {
           return this.reverse().find(predicate);
         };
-        LazyWrapper.prototype.invokeMap = baseRest(function(path3, args) {
-          if (typeof path3 == "function") {
+        LazyWrapper.prototype.invokeMap = baseRest(function(path4, args) {
+          if (typeof path4 == "function") {
             return new LazyWrapper(this);
           }
           return this.map(function(value) {
-            return baseInvoke(value, path3, args);
+            return baseInvoke(value, path4, args);
           });
         });
         LazyWrapper.prototype.reject = function(predicate) {
@@ -5535,9 +5535,12 @@ __export(cli_exports, {
   cleanFiles: () => cleanFiles,
   cleanRedis: () => cleanRedis,
   drawStatInCLI: () => drawStatInCLI,
+  formatRuntimeCloseNotification: () => formatRuntimeCloseNotification,
   getTickers: () => getTickers,
   loadTradejsConfig: () => loadTradejsConfig,
   makeScreenshots: () => makeScreenshots,
+  sendDocumentToTG: () => sendDocumentToTG,
+  sendRuntimeCloseNotificationsToTG: () => sendRuntimeCloseNotificationsToTG,
   sendTextToTG: () => sendTextToTG,
   sendToAI: () => sendToAI,
   sendToTG: () => sendToTG,
@@ -5545,6 +5548,7 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 var import_promises2 = __toESM(require("fs/promises"));
+var import_path3 = __toESM(require("path"));
 var import_lodash = __toESM(require_lodash());
 var import_progress = __toESM(require("progress"));
 var import_chalk = __toESM(require("chalk"));
@@ -5573,6 +5577,7 @@ var SCREENSHOT_CONCURRENCY_LIMIT = NODE_ENV === "production" ? 1 : 2;
 var import_files = require("@tradejs/infra/files");
 var import_redis3 = require("@tradejs/infra/redis");
 var import_logger5 = require("@tradejs/infra/logger");
+var import_timescale = require("@tradejs/infra/timescale");
 
 // src/ai.ts
 var import_aiLanguages = require("@tradejs/infra/aiLanguages");
@@ -5581,6 +5586,10 @@ var import_userSettings = require("@tradejs/infra/userSettings");
 
 // 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);
@@ -5602,13 +5611,15 @@ var trimSeriesDeep = (value) => {
   }
   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 SESSION_WINDOWS = [
-  { name: "asia", startMinuteUtc: 0, endMinuteUtc: 8 * 60 },
-  { name: "europe", startMinuteUtc: 7 * 60, endMinuteUtc: 16 * 60 },
-  { name: "us", startMinuteUtc: 13 * 60, endMinuteUtc: 22 * 60 }
-];
 var toRecord = (value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return null;
@@ -5619,92 +5630,485 @@ 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 getLastFiniteNumber = (value) => {
-  const numeric = toFiniteNumber(value);
-  if (numeric != null) {
-    return numeric;
-  }
-  if (!Array.isArray(value)) {
-    return null;
-  }
-  for (let i = value.length - 1; i >= 0; i -= 1) {
-    const nested = getLastFiniteNumber(value[i]);
-    if (nested != null) {
-      return nested;
-    }
-  }
-  return null;
-};
 var roundTo = (value, decimals) => {
   const factor = 10 ** decimals;
   return Math.round(value * factor) / factor;
 };
-var isInsideSession = (minuteUtc, startMinuteUtc, endMinuteUtc) => startMinuteUtc <= endMinuteUtc ? minuteUtc >= startMinuteUtc && minuteUtc < endMinuteUtc : minuteUtc >= startMinuteUtc || minuteUtc < endMinuteUtc;
-var buildTradingSessionContext = (timestamp) => {
-  const date = new Date(timestamp);
-  const utcHour = date.getUTCHours();
-  const utcMinute = date.getUTCMinutes();
-  const minuteUtc = utcHour * 60 + utcMinute;
-  const activeSessions = SESSION_WINDOWS.filter(
-    (session) => isInsideSession(minuteUtc, session.startMinuteUtc, session.endMinuteUtc)
-  ).map((session) => session.name);
-  const primarySession = activeSessions.includes("us") ? "us" : activeSessions.includes("europe") ? "europe" : activeSessions.includes("asia") ? "asia" : "off_hours";
-  return {
-    timezone: "UTC",
-    utcHour,
-    utcMinute,
-    primarySession,
-    activeSessions,
-    isOverlap: activeSessions.length > 1,
-    overlap: activeSessions.length > 1 ? `${activeSessions.join("_")}_overlap` : null
-  };
-};
 var buildMissingSpreadContext = () => ({
-  source: "binance_coinbase_btc",
-  indicatorKey: "payload.indicators.spread",
+  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 buildSpreadContextFromValue = (spread) => {
+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 = Math.abs(bps) < 1 ? "flat" : bps > 0 ? "coinbase_premium" : "binance_premium";
+  const bias = absBps < 1 ? "flat" : bps > 0 ? "coinbase_premium" : "binance_premium";
   const severity = absBps >= 20 ? "wide" : absBps >= 5 ? "elevated" : "normal";
   return {
-    source: "binance_coinbase_btc",
-    indicatorKey: "payload.indicators.spread",
+    source: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
+    indicatorKey: "payload.additionalIndicators.baseContext.relative.execution.venueSpread",
     available: true,
     value,
+    zScore,
     bps,
     absBps,
     bias,
     severity
   };
 };
-var readSpreadFromSignal = (signal) => {
-  const indicatorSpread = getLastFiniteNumber(signal.indicators?.spread);
-  if (indicatorSpread != null) {
-    return indicatorSpread;
+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 getLastFiniteNumber(signal.additionalIndicators?.spread);
+  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 buildAiMarketContext = (signal) => {
-  const existingMarketContext = toRecord(
-    signal.additionalIndicators?.marketContext
-  );
-  const existingSpread = toRecord(existingMarketContext?.binanceCoinbaseSpread);
-  const spread = readSpreadFromSignal(signal);
+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 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
+    };
+  }
+  return {
+    source: String(targetVsBtc.source ?? ""),
+    available: true,
+    ratioReturn1h: toFiniteNumber(targetVsBtc.ratioReturn1h),
+    ratioReturn4h: toFiniteNumber(targetVsBtc.ratioReturn4h),
+    ratioReturn24h: toFiniteNumber(targetVsBtc.ratioReturn24h),
+    alphaVsBtc1h: toFiniteNumber(targetVsBtc.alphaVsBtc1h),
+    alphaVsBtc4h: toFiniteNumber(targetVsBtc.alphaVsBtc4h),
+    alphaVsBtc24h: toFiniteNumber(targetVsBtc.alphaVsBtc24h),
+    betaToBtc20: toFiniteNumber(targetVsBtc.betaToBtc20),
+    correlationToBtc20: toFiniteNumber(targetVsBtc.correlationToBtc20),
+    ratioTrend: typeof targetVsBtc.ratioTrend === "string" ? targetVsBtc.ratioTrend : null
+  };
+};
+var buildBtcAltRegimeContextFromSignal = (signal) => {
+  const baseContext = toRecord(signal.additionalIndicators?.baseContext);
+  const relative = toRecord(baseContext?.relative);
+  const btcAltRegime = toRecord(relative?.btcAltRegime);
+  if (!btcAltRegime) {
+    return {
+      source: null,
+      available: false,
+      universe: null,
+      interval: null,
+      stale: null,
+      regime: null,
+      btcReturn24h: null,
+      altBasketReturn24h: null,
+      btcVsAltReturn24h: null,
+      btcTurnoverShare24h: null,
+      btcTurnoverShareChange24h: null,
+      altVolToBtcVol24h: null,
+      altDispersion24h: null
+    };
+  }
+  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 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
+    };
+  }
+  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 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
+    };
+  }
   return {
-    ...existingMarketContext ?? {},
-    tradingSession: buildTradingSessionContext(signal.timestamp),
-    binanceCoinbaseSpread: spread != null ? buildSpreadContextFromValue(spread) : existingSpread ?? buildMissingSpreadContext()
+    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
+    };
+  }
+  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 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
+    };
+  }
+  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),
+    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");
@@ -5713,7 +6117,6 @@ var import_logger2 = require("@tradejs/infra/logger");
 // src/tradejsConfig.ts
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
-var import_module = require("module");
 var import_url = require("url");
 var import_config = require("@tradejs/core/config");
 var import_logger = require("@tradejs/infra/logger");
@@ -5729,6 +6132,7 @@ 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) {
@@ -5758,7 +6162,14 @@ var normalizeConfig = (rawConfig) => {
     ...hooks ? { hooks } : {}
   };
 };
-var getRequireFn = (cwd = getTradejsProjectCwd()) => (0, import_module.createRequire)(import_path.default.join(import_path.default.resolve(cwd), "__tradejs_loader__.js"));
+var getNodeCreateRequire = () => {
+  const builtinModule = process.getBuiltinModule?.("module");
+  if (typeof builtinModule?.createRequire === "function") {
+    return builtinModule.createRequire;
+  }
+  throw new TypeError("module.createRequire is not available");
+};
+var getRequireFn = (cwd = getTradejsProjectCwd()) => getNodeCreateRequire()(import_path.default.join(import_path.default.resolve(cwd), "__tradejs_loader__.js"));
 var ensureTsNodeRegistered = async () => {
   if (tsNodeRegistered) {
     return;
@@ -5768,8 +6179,8 @@ var ensureTsNodeRegistered = async () => {
   tsNode.register?.({
     transpileOnly: true,
     compilerOptions: {
-      module: "commonjs",
-      moduleResolution: "node"
+      module: "Node16",
+      moduleResolution: "node16"
     }
   });
   tsNodeRegistered = true;
@@ -5796,6 +6207,42 @@ var ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
   });
   tsconfigPathsRegisteredByCwd.add(projectRoot);
 };
+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 toImportSpecifier = (moduleName) => {
   if (moduleName.startsWith("file://")) {
     return moduleName;
@@ -5854,7 +6301,18 @@ var importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
   }
   if (isBareModuleSpecifier(normalized)) {
     await ensureTsconfigPathsRegistered(cwd);
-    return requireFn(normalized);
+    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(
@@ -6124,6 +6582,9 @@ var strategies = new Proxy(
   }
 );
 
+// src/strategy/policyProfiles.ts
+var getStrategyProfileAiAdapter = (manifest, profileId) => manifest?.policyProfiles?.find(({ id }) => id === profileId)?.aiAdapter ?? manifest?.aiAdapter;
+
 // src/strategyAdapters/ai.ts
 var toRecord2 = (value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -6151,13 +6612,13 @@ var buildBaseAiPayload = (signal) => {
       }
     },
     figures: trimSeriesDeep(signal.figures ?? {}),
-    indicators: trimSeriesDeep(signal.indicators),
+    indicators: buildCompactAiIndicatorsSnapshot(signal.indicators),
     additionalIndicators: trimSeriesDeep(additionalIndicators)
   };
 };
 var defaultAiAdapter = {};
-var getStrategyAiAdapter = (strategy) => getStrategyManifest(strategy)?.aiAdapter ?? defaultAiAdapter;
-var getSignalAiAdapter = (signal) => getStrategyAiAdapter(signal.strategy);
+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);
@@ -6290,24 +6751,44 @@ Input payload structure:
 - payload.figures:
   strategy-specific figures or geometry when available. Fields vary by strategy.
 - payload.indicators:
-  indicator dictionaries and series for the coin and BTC; all series are already trimmed to the latest 5 values.
+  historical indicator dictionaries and series for the coin and BTC; all series are already trimmed to the latest 5 values. Treat this block as recent-history transport, not as the primary source of the current shared context.
 - payload.additionalIndicators:
-  strategy-specific summary/context fields. This is not noise; it contains derived fields deliberately passed by the strategy to help the decision.
-  Examples: helperFlags, structureContext, spread, correlation, volatilitySummary.
+  strategy-specific summary/context fields plus the canonical current shared context snapshot.
+  This is not noise; it contains derived fields deliberately passed by the strategy to help the decision.
+  Examples: baseContext, helperFlags, structureContext, volatilitySummary.
+  Always inspect \`payload.additionalIndicators.baseContext\` first for the current shared state:
+  \u2022 \`baseContext.raw\`: current MA, ATR, BB, OBV, price stats, levels, BTC correlation.
+  \u2022 \`baseContext.regime\`: derived trend / volatility / momentum / session regime fields.
+  \u2022 \`baseContext.structure\`: local range position, breakout freshness/quality, level-touch counts, rejection wick context.
+  \u2022 \`baseContext.participation\`: volume/turnover participation, effort-vs-result context, and Binance aggTrades trade-flow when available.
+  \u2022 \`baseContext.relative\`: BTC/ETH relative-strength, benchmark MA bias context, Binance alt-basket breadth, and CoinMarketCap historical global/exchange/index context when available.
+  \u2022 \`baseContext.derivatives\`: Coinalyze-aligned derivatives summary when available.
+  \u2022 \`baseContext.mtf\`: compact multi-timeframe summary plus only the latest few candles for each timeframe.
+  \u2022 \`baseContext.gateFeatures\`: direction-aware, normalized fields derived from baseContext; prefer \`setup\`, \`scores\`, \`confirmations\`, \`conflicts\`, \`risk\`, and \`decisionHints\` for quick gate checks before inspecting raw nested context.
   Always inspect \`payload.additionalIndicators.marketContext\` when present:
-  \u2022 \`marketContext.tradingSession\`: UTC session at signal time: asia / europe / us / overlap / off_hours.
-  \u2022 \`marketContext.binanceCoinbaseSpread\`: BTC spread between Coinbase and Binance from \`payload.indicators.spread\`; \`value=(Coinbase-Binance)/Binance\`, \`bps=value*10000\`.
+  \u2022 \`marketContext.execution.binanceCoinbaseSpread\`: AI-friendly BTC spread view projected from \`payload.additionalIndicators.baseContext.relative.execution.venueSpread\`; \`value=(Coinbase-Binance)/Binance\`, \`bps=value*10000\`.
+  \u2022 \`marketContext.participation.trueDelta\`: Binance taker buy/sell volume delta from kline payload when \`source=kline_taker_volume\`; otherwise absent/unavailable.
+  \u2022 \`marketContext.participation.tradeFlow\`: Binance aggTrades buy/sell pressure buckets when available.
+  \u2022 \`marketContext.relative.marketBreadth\`: equal/volume-weighted alt-basket return, advance/decline ratio, and MA breadth for the configured Binance breadth universe.
+  \u2022 \`marketContext.relative.targetVsBtc\`: target/BTC ratio returns, alpha, beta, and short-window correlation; use it to decide whether the target is leading or lagging BTC in the signal direction.
+  \u2022 \`marketContext.relative.btcAltRegime\`: Binance-derived BTC-vs-alt basket regime, BTC/alt 24h returns, BTC turnover share, and alt dispersion; use it as a broad alt-market risk pocket.
+  \u2022 \`marketContext.relative.cmcGlobal\`: historical CoinMarketCap global market metrics: total/alt market cap, total/alt volume, BTC/ETH dominance and 24h changes, active markets, \`interval\`, and \`altLiquidityRegime\`.
+  \u2022 \`marketContext.relative.cmcReferenceAssets\`: historical CoinMarketCap BTC/ETH market-cap and volume context, ETH/BTC market-cap ratio, ETH-vs-BTC volume ratio, \`interval\`, and \`referenceLiquidityRegime\`.
+  \u2022 \`marketContext.relative.cmcExchangeLiquidity\`: historical CoinMarketCap major-exchange liquidity aggregate: total volume, 24h volume change, Binance share, concentration, and \`liquidityRegime\`.
+  \u2022 \`marketContext.relative.cmcFearGreed\`: historical daily CoinMarketCap Fear & Greed sentiment index: value, classification, 24h/7d value changes, and \`sentimentRegime\`.
+  \u2022 \`marketContext.relative.cmcIndexes\`: historical daily CoinMarketCap CMC100/CMC20 index values, 24h changes, top constituents, CMC20/CMC100 ratio, and \`indexRegime\`.
+  \u2022 \`marketContext.relative.referenceTradeFlow\`: BTC/ETH reference trade-flow summary used for broad market pressure when the target symbol itself is not BTC/ETH.
   If those fields exist, use them as a more explicit hint instead of trying to re-derive the same idea from raw lines or points.
-  If \`derivativesContext\` exists, it is a derived Coinalyze summary for the time of the signal. Coinalyze context is built only from \`BTCUSDT\` and \`ETHUSDT\` reference symbols, not for every target coin. \`targetSymbol\` is just the source signal coin. Use BTC/ETH open interest, funding, liquidations, and pressure/riskFlags as positioning context, not as an independent trade idea.
+  If \`baseContext.derivatives\` exists, its top-level \`summary\` and \`intervals\` are the primary BTCUSDT Coinalyze benchmark context for the time of the signal. \`secondaryReferenceSymbol\` identifies the ETHUSDT secondary benchmark, and \`referenceContexts\` contains BTCUSDT/ETHUSDT plus configured extra reference symbols such as BNBUSDT/SOLUSDT/TRXUSDT/XRPUSDT. If \`targetContext\` or \`targetDerived\` exists, those fields are the Coinalyze context for the actual target coin; use them as target-specific positioning evidence, but do not infer target-coin derivatives when they are absent.
   Key patterns:
-  \u2022 coin: \`maFast\`, \`atrPct\`, \`macd...\`, \`candles15m/candles1h/candles4h/candles1d\`, and \`*1h/*4h/*1d\`
-  \u2022 BTC: \`btcMaFast\`, \`btcAtr\`, \`btcMacd...\`, \`btcCandles*\`, and \`btc*1h/*4h/*1d\`
-  \u2022 strategy service keys are possible as well, for example \`correlation\`, \`spread\`, \`touches\`, \`distance\`
+  \u2022 current shared state: prefer \`payload.additionalIndicators.baseContext\`
+  \u2022 recent historical series: \`payload.indicators\`
+  \u2022 strategy service keys are possible as well, for example \`touches\`, \`distance\`, timing flags, and other setup-specific summaries
 
 How to analyze, in order:
 1. Start with price structure and the setup geometry or context in \`payload.figures\`. This has higher priority than indicators.
-2. Then use \`payload.additionalIndicators\` when it contains explicit strategy-specific context such as line state, spread, correlation, and similar fields.
-3. Then assess confirmation or conflict from the current coin indicators.
+2. Then use \`payload.additionalIndicators.baseContext\` and other explicit strategy-specific context fields.
+3. Then assess confirmation or conflict from the current shared state and recent coin indicator history.
 4. Then evaluate BTC context.
 5. Only after that choose \`direction\`, \`quality\`, and whether an extra confirmation level is required.
 6. If strong conflicts exist, reduce quality or set direction to \`null\`.
@@ -6316,13 +6797,24 @@ Explicit conflict rules:
 - If the figure or price structure is invalid or doubtful, indicators must not rescue the setup.
 - If strategy-specific helper fields explicitly say the signal is not confirmed yet, lacks margin, or requires waiting, do not overstate quality.
 - If the structure is acceptable but BTC or key indicators noticeably conflict, quality is usually \`<= 3\`.
-- If \`derivativesContext.referenceContexts\` exists, check \`primaryReferenceSymbol\` first, then compare \`BTCUSDT\` and \`ETHUSDT\` as broad-market derivatives context. Do not search for Coinalyze data for \`targetSymbol\` unless \`targetSymbol\` itself is \`BTCUSDT\` or \`ETHUSDT\`.
-- If \`derivativesContext.summary.riskFlags\` contains \`crowded_long\` for a LONG or \`crowded_short\` for a SHORT, treat that as crowded positioning and do not overstate quality without strong structural confirmation.
-- If \`derivativesContext.summary.directionAligned=false\`, explicitly mention the derivatives conflict in \`confirmations\` or \`qualityReason\`.
-- If \`derivativesContext\` is absent, stale, or \`missing_derivatives\`, do not infer Coinalyze conclusions and do not penalize the signal just because that data is missing.
-- If \`marketContext.tradingSession\` exists, treat the session as a liquidity and volatility regime: asia is often thinner, europe/us are more active, and overlaps can amplify both momentum and noise. Do not reject a signal solely because of session, but mention clear session support or conflict in \`confirmations\` or \`qualityReason\`.
-- If \`marketContext.binanceCoinbaseSpread.available=true\` and \`severity=elevated/wide\`, treat it as cross-exchange divergence or BTC liquidity risk. Do not use the spread as a standalone long/short signal, but reduce confidence or require more confirmation when the rest of the structure is weak or BTC context conflicts.
-- If \`marketContext.binanceCoinbaseSpread\` is missing or \`available=false\`, do not infer anything from Binance/Coinbase spread and do not penalize the signal just because it is absent.
+- If \`baseContext.derivatives.referenceContexts\` exists, check \`primaryReferenceSymbol\` first as the BTC benchmark, then compare \`secondaryReferenceSymbol\`/ETHUSDT and any target-specific \`targetDerived\`. If \`targetDerived\` exists, compare it to the primary reference instead of treating reference pressure as the target coin's own pressure.
+- If top-level \`baseContext.derivatives.summary.riskFlags\` contains \`crowded_long\` for a LONG or \`crowded_short\` for a SHORT, treat that as broad-market crowded positioning. If \`targetDerived.riskFlags\` contains the same directional crowding, treat that as target-specific crowded positioning.
+- If top-level \`baseContext.derivatives.summary.directionAligned=false\`, explicitly mention the broad-market derivatives conflict in \`confirmations\` or \`qualityReason\`. If \`targetDerived.directionAligned=false\`, explicitly mention the target-specific derivatives conflict.
+- If \`baseContext.derivatives\` is absent, stale, or \`missing_derivatives\`, do not infer Coinalyze conclusions and do not penalize the signal just because that data is missing.
+- Use \`baseContext.regime.session\` directly as the canonical session/liquidity regime: asia is often thinner, europe/us are more active, and overlaps can amplify both momentum and noise. Do not reject a signal solely because of session, but mention clear session support or conflict in \`confirmations\` or \`qualityReason\`.
+- If \`marketContext.execution.binanceCoinbaseSpread.available=true\` and \`severity=elevated/wide\`, treat it as cross-exchange divergence or BTC liquidity risk. Do not use the spread as a standalone long/short signal, but reduce confidence or require more confirmation when the rest of the structure is weak or BTC context conflicts.
+- If \`marketContext.execution.binanceCoinbaseSpread\` is missing or \`available=false\`, do not infer anything from Binance/Coinbase spread and do not penalize the signal just because it is absent.
+- If \`marketContext.participation.trueDelta.available=true\`, use it as better participation evidence than OHLCV-derived proxy delta; still do not let delta override invalid price structure.
+- If \`marketContext.participation.tradeFlow.available=true\` and \`stale=false\`, use it as direct lower-timeframe participation evidence. Treat stale or missing tradeFlow as absent, not as negative evidence.
+- If \`marketContext.relative.marketBreadth.available=true\` and \`stale=false\`, use it as broad alt-market support/conflict. Breadth is contextual; do not let it override the target symbol structure.
+- If \`marketContext.relative.targetVsBtc.available=true\`, treat positive target/BTC ratio trend as support for alt LONGs and negative ratio trend as support for alt SHORTs; ignore it when the target structure is stronger and clearly explains the setup.
+- If \`marketContext.relative.btcAltRegime.available=true\` and \`stale=false\`, treat \`alt_lead\`/\`risk_on\` as broad support for alt LONGs and \`btc_lead\`/\`risk_off\` as pressure against alt LONGs or support for cautious alt SHORTs. Do not use it as a standalone entry reason.
+- If \`marketContext.relative.cmcGlobal.available=true\` and \`stale=false\`, use falling alt market cap/volume or rising BTC dominance as broad risk pressure for alt LONGs. Treat missing CMC history as absent context, not a bearish signal.
+- If \`marketContext.relative.cmcReferenceAssets.available=true\` and \`stale=false\`, use \`eth_led\` as broad support for ETH/high-beta alt strength and \`btc_led\`/\`thin\` as broad caution. Do not describe BTC/ETH reference history as target-symbol flow.
+- If \`marketContext.relative.cmcExchangeLiquidity.available=true\` and \`stale=false\`, treat \`contracting\`, \`thin\`, or \`concentrated\` as broad liquidity risk; \`expanding\` or \`balanced\` supports cleaner execution context but is not a standalone entry reason.
+- If \`marketContext.relative.cmcFearGreed.available=true\` and \`stale=false\`, use \`risk_on\` as broad support for LONGs and \`risk_off\`/\`capitulation\` as broad pressure. Treat \`euphoric\` as overheating/chase caution, not as standalone SHORT proof.
+- If \`marketContext.relative.cmcIndexes.available=true\` and \`stale=false\`, use \`top20_led\` as broad support for mega-cap leadership, \`large_cap_led\` as broader CMC100 participation, and \`risk_off\` as broad pressure. Do not use CMC index history as a standalone entry reason.
+- If \`marketContext.relative.referenceTradeFlow.available=true\`, treat BTC/ETH trade-flow as broad market context only. For alt symbols, do not describe it as the target coin's own flow.
 - If the current signal is not confirmed (\`direction=null\`), name the main reason briefly in \`comment\`.
   If you use the structured fields, include the main reason in \`qualityReason\` or \`triggerInvalidation\`.
 
@@ -6373,6 +6865,18 @@ Trade payload:
 ${JSON.stringify(payload)}
 ${buildAiHumanPromptAddonByStrategy(signal, payload)}
 `;
+var getAiInvocationError = (error) => {
+  const details = error instanceof Error && error.message.trim() ? error.message.trim() : String(error);
+  const isEmptyCompletion = error instanceof TypeError && /Cannot read properties of undefined \(reading ['"]message['"]\)/.test(
+    details
+  );
+  const wrapped = new Error(
+    isEmptyCompletion ? "AI provider returned an empty chat completion" : `AI model invocation failed: ${details}`
+  );
+  wrapped.cause = error;
+  return wrapped;
+};
+var isEmptyResponseContent = (content) => typeof content === "string" ? content.trim().length === 0 : Object.keys(content).length === 0;
 var DEFAULT_AI_MODEL = "openai/gpt-5-mini";
 var userSettingsCache = /* @__PURE__ */ new Map();
 var aiModelCache = /* @__PURE__ */ new Map();
@@ -6493,10 +6997,17 @@ var runAiPrompt = async ({ systemPrompt, humanPrompt }, options = {}) => {
       ]
     })
   );
-  const response = await model.invoke(messages);
-  const parsed = parseAIResponse(
-    normalizeResponseContent(response.content)
-  );
+  let response;
+  try {
+    response = await model.invoke(messages);
+  } catch (error) {
+    throw getAiInvocationError(error);
+  }
+  const responseContent = normalizeResponseContent(response?.content);
+  if (isEmptyResponseContent(responseContent)) {
+    throw new Error("AI provider returned an empty chat completion");
+  }
+  const parsed = parseAIResponse(responseContent);
   const normalized = normalizeAnalysis(parsed);
   if (!options.signal) {
     return normalized;
@@ -6533,6 +7044,27 @@ var import_puppeteer = __toESM(require("puppeteer"));
 var import_async = require("@tradejs/core/async");
 var import_logger3 = require("@tradejs/infra/logger");
 var import_redis2 = require("@tradejs/infra/redis");
+
+// src/dashboardUrl.ts
+var buildDashboardUrl = ({
+  baseUrl,
+  provider = "bybit",
+  universe = "crypto",
+  symbol,
+  interval,
+  searchParams = {}
+}) => {
+  const url = new URL(
+    `/routes/dashboard/${provider}/${universe}/${symbol}/${interval}`,
+    baseUrl
+  );
+  for (const [key, value] of Object.entries(searchParams)) {
+    url.searchParams.set(key, value);
+  }
+  return url.toString();
+};
+
+// src/screenshot.ts
 var { APP_URL } = process.env;
 var SCREENSHOT_NAVIGATION_ATTEMPTS = 3;
 var SCREENSHOT_NAVIGATION_RETRY_DELAY_MS = 2e3;
@@ -6641,7 +7173,18 @@ var screenDashboard = async (signal, projectRoot, userName = "root") => {
       `Failed to create screenshot session token for ${userName}`
     );
   }
-  const dashboardUrl = `${screenshotBaseUrl}/routes/dashboard/bybit/${symbol}/${interval}/?signalId=${signalId}&autoZoom=true&screenshot=1&screenshotToken=${encodeURIComponent(screenshotToken)}`;
+  const dashboardUrl = buildDashboardUrl({
+    baseUrl: screenshotBaseUrl,
+    universe: signal.universe ?? "crypto",
+    symbol,
+    interval,
+    searchParams: {
+      signalId,
+      autoZoom: "true",
+      screenshot: "1",
+      screenshotToken
+    }
+  });
   const maskedDashboardUrl = maskTokenInUrl(dashboardUrl);
   import_logger3.logger.info(
     "screenshot start: %s %sm url=%s path=%s",
@@ -6949,6 +7492,25 @@ var describeErrorValue2 = (value) => {
   return String(value);
 };
 var normalizeQuality = (value) => typeof value === "number" ? Math.max(1, Math.min(5, Math.round(value))) : null;
+var formatOrderValue = (value) => {
+  const rounded = Number(value.toFixed(2));
+  return Number.isInteger(rounded) ? String(rounded) : rounded.toFixed(2);
+};
+var getDisplayDecision = (signalDirection, analysis, fallback) => {
+  if (!analysis && !fallback) {
+    return void 0;
+  }
+  if (analysis?.direction != null && analysis.direction !== signalDirection) {
+    return "rejected";
+  }
+  if (analysis?.needRetest === true) {
+    return "pending";
+  }
+  if (analysis?.direction != null && analysis.direction === signalDirection) {
+    return "approved";
+  }
+  return fallback;
+};
 var formatAnalysisLevel = (value) => {
   if (value == null || !Number.isFinite(value)) return null;
   if (Math.abs(value) >= 1e3) {
@@ -6996,24 +7558,17 @@ var formatOrderSkipReason = (reason) => {
   }
   return reason;
 };
-var getLastNumber = (value) => {
-  if (Array.isArray(value)) {
-    const last = value[value.length - 1];
-    return typeof last === "number" ? last : void 0;
-  }
-  return typeof value === "number" ? value : void 0;
-};
-var getAiQualityLine = (analysis) => {
+var getAiQualityLine = (analysis, label = "AI Quality") => {
   const quality = normalizeQuality(analysis?.quality);
   if (!quality) return null;
   const approvedCurrentDirection = analysis?.direction != null && analysis.direction !== null;
   if (quality >= 4 && approvedCurrentDirection) {
-    return `\u{1F7E2} AI Quality: ${quality}/5`;
+    return `\u{1F7E2} ${label}: ${quality}/5`;
   }
   if (quality === 3 && approvedCurrentDirection) {
-    return `\u{1F7E1} AI Quality: ${quality}/5`;
+    return `\u{1F7E1} ${label}: ${quality}/5`;
   }
-  return `\u{1F534} AI Quality: ${quality}/5`;
+  return `\u{1F534} ${label}: ${quality}/5`;
 };
 var getTelegramErrorReason = (data) => {
   if (data && typeof data === "object") {
@@ -7139,26 +7694,59 @@ var sendTextToTG = async (message, options = {}) => {
     chatId
   });
 };
-var formatMessage = (signal, analysis) => {
+var sendDocumentToTG = async (document, options = {}) => {
+  const { token, chatId } = await getTelegramSettings(options.userName);
+  const body = new FormData();
+  const fileContent = typeof document.content === "string" ? document.content : (() => {
+    const bytes = new Uint8Array(document.content.byteLength);
+    bytes.set(document.content);
+    return bytes;
+  })();
+  body.set("chat_id", String(chatId || ""));
+  body.set(
+    "document",
+    new File([fileContent], document.filename, {
+      type: "application/json"
+    })
+  );
+  if (document.caption?.trim()) {
+    body.set("caption", document.caption.trim());
+    body.set("parse_mode", "HTML");
+  }
+  const data = await requestTelegram({
+    method: "sendDocument",
+    token,
+    init: {
+      method: "POST",
+      body
+    }
+  });
+  import_logger4.logger.info(
+    "tg sendDocument: %s",
+    data?.ok ? "sent" : getTelegramErrorReason(data)
+  );
+  return data;
+};
+var formatMessage = (signal, analysis, options = {}) => {
   const {
     symbol,
     direction,
     strategy,
     orderStatus,
     orderSkipReason,
+    orderFailureReason,
+    orderQty,
+    orderValue,
     isConfigFromBacktest,
     ml,
     prices: { currentPrice, takeProfitPrice, stopLossPrice, riskRatio },
-    indicators,
     additionalIndicators
   } = signal;
+  const userName = options.userName || "root";
   try {
     const lines = [];
     const distance = additionalIndicators?.distance;
     const touches = additionalIndicators?.touches;
-    const correlation = getLastNumber(indicators.correlation);
-    const atrPct = getLastNumber(indicators.atrPct);
-    const spread = getLastNumber(indicators.spread);
     const formatPrices = () => {
       const tpPercent = Math.abs(
         (takeProfitPrice - currentPrice) / currentPrice * 100
@@ -7166,8 +7754,10 @@ var formatMessage = (signal, analysis) => {
       const slPercent = Math.abs((stopLossPrice - currentPrice) / currentPrice * 100).toFixed(
         2
       ) + "%";
+      const resolvedOrderValue = typeof orderValue === "number" && Number.isFinite(orderValue) ? orderValue : typeof orderQty === "number" && Number.isFinite(orderQty) ? orderQty * currentPrice : null;
       const prices = [
         `Price: <b>${(0, import_math.formatNumber)(currentPrice)}</b>`,
+        resolvedOrderValue != null ? `Value: <b>${formatOrderValue(resolvedOrderValue)}$</b>` : null,
         `TP: <b>${(0, import_math.formatNumber)(takeProfitPrice)}</b> (${tpPercent})`,
         `SL: <b>${(0, import_math.formatNumber)(stopLossPrice)}</b> (${slPercent})`,
         `R:R = <b>${riskRatio.toFixed(2)}</b>`
@@ -7193,6 +7783,8 @@ var formatMessage = (signal, analysis) => {
           lines.push(
             `Skip reason: <b>${escapeHtml(formatOrderSkipReason(orderSkipReason))}</b>`
           );
+        } else if (orderStatus === "failed" && orderFailureReason) {
+          lines.push(`Reason: <code>${escapeHtml(orderFailureReason)}</code>`);
         }
       }
       if (isConfigFromBacktest) {
@@ -7205,17 +7797,25 @@ var formatMessage = (signal, analysis) => {
           `${ml.passed ? "\u{1F7E2} ML: PASS" : "\u{1F534} ML: FAIL"} (${ml.probability.toFixed(3)} / ${ml.threshold.toFixed(2)})`
         );
       }
-      const aiQualityLine = getAiQualityLine(analysis);
-      if (aiQualityLine) {
-        lines.push(aiQualityLine);
+      const gateAnalysis = analysis?.gateAnalysis && typeof analysis.gateAnalysis === "object" && !Array.isArray(analysis.gateAnalysis) ? analysis.gateAnalysis : null;
+      if (gateAnalysis) {
+        const gateQualityLine = getAiQualityLine(gateAnalysis, "Gate Quality");
+        if (gateQualityLine) {
+          lines.push(gateQualityLine);
+        }
+        const llmQualityLine = getAiQualityLine(analysis, "LLM Quality");
+        if (llmQualityLine) {
+          lines.push(llmQualityLine);
+        }
+      } else {
+        const aiQualityLine = getAiQualityLine(analysis);
+        if (aiQualityLine) {
+          lines.push(aiQualityLine);
+        }
       }
       lines.push("");
-      if (correlation) {
-        lines.push(`BTC correlation: ${correlation}`);
-      }
       const prices = formatPrices();
       if (prices) {
-        lines.push("");
         lines.push(prices);
       }
     };
@@ -7229,9 +7829,17 @@ var formatMessage = (signal, analysis) => {
 var sendSignal = async (signal, imgInterval, analysis, options = {}) => {
   const { symbol, signalId, interval } = signal;
   const { token, chatId } = await getTelegramSettings(options.userName);
-  const message = formatMessage(signal, analysis);
+  const message = formatMessage(signal, analysis, {
+    userName: options.userName
+  });
   const publicAppUrl = APP_URL2?.startsWith("https") ? APP_URL2 : null;
-  const dashboardUrl = publicAppUrl ? `${APP_URL2}/routes/dashboard/bybit/${symbol}/${interval}/?signalId=${signalId}` : null;
+  const dashboardUrl = publicAppUrl ? buildDashboardUrl({
+    baseUrl: publicAppUrl,
+    universe: signal.universe ?? "crypto",
+    symbol,
+    interval,
+    searchParams: { signalId }
+  }) : null;
   const actionButtons = [
     dashboardUrl ? { text: "Dashboard", url: dashboardUrl } : null
   ].filter(Boolean);
@@ -7324,9 +7932,19 @@ var formatAnalysisMessage = (signal, analysis) => {
   if (quality) {
     lines.push(`Quality: <b>${quality}/5</b>`);
   }
-  if (analysis.gateDecision && analysis.llmDecision) {
+  const gateDecision = getDisplayDecision(
+    signal.direction,
+    analysis.gateAnalysis,
+    analysis.gateDecision
+  );
+  const llmDecision = getDisplayDecision(
+    signal.direction,
+    analysis,
+    analysis.llmDecision
+  );
+  if (gateDecision && llmDecision) {
     lines.push(
-      `Gate vs LLM: <b>${analysis.gateContradictsLlm ? "conflict" : "aligned"}</b> (gate ${analysis.gateDecision}, LLM ${analysis.llmDecision})`
+      `Gate vs LLM: <b>${gateDecision === llmDecision ? "aligned" : "conflict"}</b> (gate ${gateDecision}, LLM ${llmDecision})`
     );
   }
   const happeningText = takeUniqueAnalysisText(
@@ -7371,19 +7989,6 @@ var formatAnalysisMessage = (signal, analysis) => {
   if (btcText) {
     lines.push(`BTC context: ${escapeHtml(btcText)}`);
   }
-  const levels = [];
-  if (typeof analysis.takeProfitPrice === "number") {
-    levels.push(`TP <b>${formatAnalysisLevel(analysis.takeProfitPrice)}</b>`);
-  }
-  if (typeof analysis.stopLossPrice === "number") {
-    levels.push(`SL <b>${formatAnalysisLevel(analysis.stopLossPrice)}</b>`);
-  }
-  if (typeof analysis.retestPrice === "number") {
-    levels.push(`Retest <b>${formatAnalysisLevel(analysis.retestPrice)}</b>`);
-  }
-  if (levels.length > 0) {
-    lines.push(`Levels: ${levels.join(" | ")}`);
-  }
   return lines.join("\n");
 };
 var sendSignalAnalysis = async (signal, analysis, options = {}) => {
@@ -7410,10 +8015,35 @@ var sendSignalAnalysis = async (signal, analysis, options = {}) => {
 
 // src/cli.ts
 var getProjectRoot2 = () => getTradejsProjectCwd();
+var escapeHtml2 = (value) => value == null ? "" : String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var formatOptionalNumber = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return "n/a";
+  }
+  const normalized = Number(value.toFixed(8));
+  return Number.isInteger(normalized) ? String(normalized) : String(normalized);
+};
+var formatOptionalTimestamp = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return "n/a";
+  }
+  return new Date(value).toISOString();
+};
+var isEnoentError = (error) => error?.code === "ENOENT";
 var cleanFiles = async (dir) => {
   let completed = 0;
   const projectRoot = getProjectRoot2();
-  const files = await (0, import_files.getFiles)(dir, projectRoot);
+  let files = [];
+  try {
+    files = await (0, import_files.getFiles)(dir, projectRoot);
+  } catch (error) {
+    if (isEnoentError(error)) {
+      import_logger5.logger.info(import_chalk.default.yellow("clean:", dir));
+      import_logger5.logger.info("");
+      return;
+    }
+    throw error;
+  }
   const bar = new import_progress.default(":current/:total [:bar][:percent] :eta(s)", {
     total: files.length,
     width: 30
@@ -7421,12 +8051,18 @@ var cleanFiles = async (dir) => {
   import_logger5.logger.info(import_chalk.default.yellow("clean:", dir));
   for await (const file of files) {
     completed++;
-    const fullPath = `${dir}/${file}`;
-    const stat = await import_promises2.default.lstat(fullPath);
-    if (stat.isDirectory()) {
-      await import_promises2.default.rm(fullPath, { recursive: true, force: true });
-    } else {
-      await import_promises2.default.unlink(fullPath);
+    const fullPath = import_path3.default.join(projectRoot, dir, file);
+    try {
+      const stat = await import_promises2.default.lstat(fullPath);
+      if (stat.isDirectory()) {
+        await import_promises2.default.rm(fullPath, { recursive: true, force: true });
+      } else {
+        await import_promises2.default.unlink(fullPath);
+      }
+    } catch (error) {
+      if (!isEnoentError(error)) {
+        throw error;
+      }
     }
     if (completed % 100 === 0 || completed === files.length) {
       bar.tick(completed === files.length ? completed % 100 : 100);
@@ -7471,28 +8107,58 @@ var update = async (connector, interval, tickers, preloadDays = import_constants
   );
   const preloadEnd = Math.trunc(options.preloadEnd ?? (0, import_time.getTimestamp)());
   const connectorLabel = String(options.connectorLabel || "").trim();
-  const preloadLabel = options.preloadStart != null || options.preloadEnd != null ? `preloadStart=${preloadStart}, preloadEnd=${preloadEnd}` : `preloadDays=${preloadDays}`;
+  const preloadLabel = options.preloadStart != null || options.preloadEnd != null ? `preloadStart=${formatOptionalTimestamp(preloadStart)}, preloadEnd=${formatOptionalTimestamp(preloadEnd)}` : `preloadDays=${preloadDays}`;
   if (preloadStart >= preloadEnd) {
     throw new Error(
       `Invalid update preload window: start (${preloadStart}) must be less than end (${preloadEnd})`
     );
   }
+  let queue = [...new Set(tickers.slice())];
+  if (!queue.includes("BTCUSDT")) {
+    queue.unshift("BTCUSDT");
+  }
+  const intervalMinutes = Number(interval);
+  if (options.skipCovered && connectorLabel && Number.isFinite(intervalMinutes) && intervalMinutes > 0) {
+    const edges = await (0, import_timescale.getDataEdgesForSymbols)(
+      connectorLabel,
+      queue,
+      Math.floor(intervalMinutes)
+    );
+    const initialCount = queue.length;
+    queue = queue.filter((symbol) => {
+      const edge = edges.get(String(symbol).toUpperCase());
+      return !edge || edge.min === void 0 || edge.max === void 0 || edge.min > preloadStart || edge.max < preloadEnd;
+    });
+    const skippedCount = initialCount - queue.length;
+    if (skippedCount > 0) {
+      import_logger5.logger.info(
+        import_chalk.default.gray(
+          `update ${connectorLabel}: skip ${skippedCount}/${initialCount} cached symbols for interval=${interval}`
+        )
+      );
+    }
+  }
+  if (queue.length === 0) {
+    import_logger5.logger.info(
+      import_chalk.default.yellow(
+        `update: 0 (connector=${connectorLabel || "unknown"}, interval=${interval}, klineConcurrency=${KLINE_CONCURRENCY_LIMIT}, ${preloadLabel})`
+      )
+    );
+    import_logger5.logger.info("");
+    return;
+  }
   const bar = new import_progress.default(
     ":current/:total [:bar][:percent] :eta(s) :symbol",
     {
-      total: tickers.length,
+      total: queue.length,
       width: 30
     }
   );
   import_logger5.logger.info(
     import_chalk.default.yellow(
-      `update: ${tickers.length} (connector=${connectorLabel || "unknown"}, klineConcurrency=${KLINE_CONCURRENCY_LIMIT}, ${preloadLabel})`
+      `update: ${queue.length} (connector=${connectorLabel || "unknown"}, interval=${interval}, klineConcurrency=${KLINE_CONCURRENCY_LIMIT}, ${preloadLabel})`
     )
   );
-  const queue = tickers.slice();
-  if (!queue.includes("BTCUSDT")) {
-    queue.unshift("BTCUSDT");
-  }
   await (0, import_async3.runWithConcurrency)(queue, KLINE_CONCURRENCY_LIMIT, async (symbol) => {
     try {
       await connector.kline({
@@ -7521,6 +8187,8 @@ var getCLILevelColor = (level) => {
       return import_chalk.default.green;
     case "warning":
       return import_chalk.default.yellow;
+    case "neutral":
+      return import_chalk.default.gray;
     case "error":
       return import_chalk.default.red;
   }
@@ -7532,18 +8200,18 @@ var drawStatInCLI = (stat, keys) => {
     return color(formatted);
   });
 };
-var scanner = async (connector, limit) => {
-  const data = await connector.getTickers();
+var scanner = async (connector, limit, query) => {
+  const data = await connector.getTickers(query);
   const tickers = (0, import_tickers.getTopTickers)(data, limit);
   return tickers.map(({ value }) => value);
 };
-var getTickers = async (connector, include = "", exclude = "", limit, chunk) => {
+var getTickers = async (connector, include = "", exclude = "", limit, chunk, query) => {
   let tickers;
   const excludeTickers = parseSymbolsFromCLI(exclude);
   if (include) {
     tickers = parseSymbolsFromCLI(include);
   } else {
-    tickers = await scanner(connector, limit);
+    tickers = await scanner(connector, limit, query);
   }
   if (chunk) {
     const [currentChunk, chunksCount] = chunk.split("/").map((c) => parseInt(c));
@@ -7603,7 +8271,79 @@ var sendToAI = async (signals, userName = "root") => {
   });
   import_logger5.logger.info("");
 };
+var formatRuntimeCloseNotification = (event, _userName = event.userName ?? "root") => {
+  const ownership = event.openedByStrategy === event.strategy ? "matched" : `mismatch: opened by ${event.openedByStrategy}`;
+  return [
+    "<b>Strategy self-close</b>",
+    `Symbol: <b>${escapeHtml2(event.symbol)}</b>`,
+    `Strategy: <b>${escapeHtml2(event.strategy)}</b>`,
+    `Direction: <b>${escapeHtml2(event.direction)}</b>`,
+    `Reason: <code>${escapeHtml2(event.code)}</code>`,
+    "",
+    `Opened by journal: <b>${escapeHtml2(event.openedByStrategy)}</b>`,
+    `Ownership: <b>${escapeHtml2(ownership)}</b>`,
+    "",
+    `Entry: <b>${escapeHtml2(formatOptionalNumber(event.entryPrice))}</b> at <code>${escapeHtml2(formatOptionalTimestamp(event.entryTimestamp))}</code>`,
+    `Exit: <b>${escapeHtml2(formatOptionalNumber(event.exitPrice))}</b> at <code>${escapeHtml2(formatOptionalTimestamp(event.exitTimestamp))}</code>`,
+    `Qty: <b>${escapeHtml2(formatOptionalNumber(event.qty))}</b>`,
+    `Closed PnL: <b>${escapeHtml2(formatOptionalNumber(event.closedPnl))}</b>`
+  ].join("\n");
+};
+var sendRuntimeCloseNotificationsToTG = async (events, userName = "root") => {
+  import_logger5.logger.info(import_chalk.default.yellow("close messages:", events.length));
+  if (!events.length) {
+    import_logger5.logger.info("");
+    return;
+  }
+  const bar = new import_progress.default(
+    ":current/:total [:bar][:percent] :eta(s) :symbol",
+    {
+      total: events.length,
+      width: 30
+    }
+  );
+  await (0, import_async3.runWithConcurrency)(events, 1, async (event) => {
+    try {
+      await sendTextToTG(formatRuntimeCloseNotification(event, userName), {
+        userName
+      });
+    } catch (err) {
+      import_logger5.logger.error(
+        "Failed close notification: %s %s",
+        event.symbol,
+        err?.message || String(err)
+      );
+    } finally {
+      bar.tick(1, { symbol: import_chalk.default.gray(event.symbol) });
+    }
+  });
+  import_logger5.logger.info("");
+};
 var sendToTG = async (signals, imgInterval, userName = "root") => {
+  const strategyConfigCache = /* @__PURE__ */ new Map();
+  const resolveStrategyConfig = async (strategyName) => {
+    if (strategyConfigCache.has(strategyName)) {
+      return strategyConfigCache.get(strategyName);
+    }
+    const config = await (0, import_redis3.getData)(
+      `users:${userName}:strategies:${strategyName}:config`,
+      null
+    );
+    strategyConfigCache.set(strategyName, config);
+    return config;
+  };
+  const resolveDecision = (analysis, direction, minQuality = 4) => {
+    if (analysis?.needRetest === true) {
+      return "rejected";
+    }
+    const quality = Number(analysis?.quality);
+    if (!Number.isFinite(quality)) {
+      return "rejected";
+    }
+    const normalized = Math.round(quality);
+    const resolvedQuality = analysis?.direction === direction ? normalized : 0;
+    return resolvedQuality >= minQuality ? "approved" : "rejected";
+  };
   const deliverableSignals = signals.filter(
     (signal) => signal.orderStatus !== "skipped" && signal.orderStatus !== "canceled"
   );
@@ -7621,17 +8361,56 @@ var sendToTG = async (signals, imgInterval, userName = "root") => {
   );
   await (0, import_async3.runWithConcurrency)(deliverableSignals, 1, async (signal) => {
     try {
-      const analysis = await (0, import_redis3.getData)(
+      let analysis = await (0, import_redis3.getData)(
         import_redis3.redisKeys.analysis(signal.symbol, signal.signalId),
         null
       );
+      let shouldSendSignalAnalysis = analysis && typeof analysis === "object" && Object.keys(analysis).length > 0;
+      const strategyConfig = await resolveStrategyConfig(signal.strategy);
+      const aiMode = strategyConfig?.AI_MODE;
+      const gateAnalysis = signal.aiAnalysis;
+      if (aiMode === "gate" && gateAnalysis) {
+        const minQuality = Number(strategyConfig?.MIN_AI_QUALITY) || 4;
+        const gateDecision = resolveDecision(
+          gateAnalysis,
+          signal.direction,
+          minQuality
+        );
+        try {
+          const llmAnalysis = await askAI(signal, { userName });
+          const llmDecision = resolveDecision(
+            llmAnalysis,
+            signal.direction,
+            minQuality
+          );
+          analysis = {
+            ...llmAnalysis ?? {},
+            gateAnalysis,
+            gateDecision,
+            llmDecision,
+            gateContradictsLlm: gateDecision !== llmDecision
+          };
+          shouldSendSignalAnalysis = true;
+        } catch (error) {
+          import_logger5.logger.error(
+            "LLM commentary failed: %s (%s)",
+            signal.symbol,
+            error?.message || String(error)
+          );
+          analysis = {
+            gateAnalysis,
+            gateDecision
+          };
+          shouldSendSignalAnalysis = false;
+        }
+      }
       await sendSignal(signal, imgInterval, analysis, { userName });
-      if (analysis && typeof analysis === "object" && Object.keys(analysis).length > 0) {
+      if (shouldSendSignalAnalysis && analysis && typeof analysis === "object" && Object.keys(analysis).length > 0) {
         await sendSignalAnalysis(signal, analysis, { userName });
       }
     } catch (err) {
       import_logger5.logger.error(
-        "Failed sent: %s %s",
+        "Signal notification failed: %s (%s)",
         signal.symbol,
         err?.message || String(err)
       );
@@ -7646,9 +8425,12 @@ var sendToTG = async (signals, imgInterval, userName = "root") => {
   cleanFiles,
   cleanRedis,
   drawStatInCLI,
+  formatRuntimeCloseNotification,
   getTickers,
   loadTradejsConfig,
   makeScreenshots,
+  sendDocumentToTG,
+  sendRuntimeCloseNotificationsToTG,
   sendTextToTG,
   sendToAI,
   sendToTG,