Warrior_EA/Signals/SignalMETA.mqh

//+------------------------------------------------------------------+
//|                                                       Warrior_EA |
//|                                                     AnimateDread |
//|                                                                  |
//+------------------------------------------------------------------+
#include "..\Expert\ExpertSignalAIBase.mqh"
#include "..\Expert\Training\MetaCorpus.mqh"
// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |
//| Title=Signals of indicator 'Meta AI'                             |
//| Type=SignalAdvanced                                              |
//| Name=Meta AI                                                     |
//| ShortName=META                                                   |
//| Class=CSignalMETA                                                |
//| Page=signal_meta                                                 |
//+------------------------------------------------------------------+
// wizard description end
//+------------------------------------------------------------------+
//| Class CSignalMETA - stage S2 of Meta_Labeling_Design.md.         |
//|                                                                  |
//| The meta-labeling head: instead of asking "which way will the    |
//| next bar go" (measured dead - direction-closed verdict), it asks |
//| "given that a SPECIFIC classic-pattern candidate just fired,     |
//| will THAT trade reach its target before its stop, at the EA's    |
//| own geometry, net of cost". One net for all 52 pattern-sides;    |
//| pattern identity rides in as input features.                     |
//|                                                                  |
//| Sample:   CMetaCorpus - preferably swept off THIS chart's own    |
//|           history through the live classic ladders, otherwise    |
//|           the signal DB built by an 18-year backtest with        |
//|           UseDatabaseRanking on (per-side journaling means the   |
//|           DB IS the candidate stream, uncensored).               |
//| Label:    triple-barrier win/loss of the candidate's own side    |
//|           from its fire bar - the side-conditional win caches    |
//|           the label prebuild already computes; the DB's stop-    |
//|           and-reverse outcome is NEVER reused as a label.        |
//| Features: the shared BuildFeatureWindow() output plus a 31-wide  |
//|           setup descriptor appended at the input (26-slot        |
//|           pattern one-hot, side, tanh-squashed netVote, SL/TP    |
//|           in ATR, spread/ATR at fire time). Appended at the      |
//|           input rather than "at the head" because CNet has no    |
//|           concat layer; on the MLP front end the two are         |
//|           equivalent up to one linear layer.                     |
//| Head:     2 outputs, softmax+CE (== logistic/BCE); see the       |
//|           total==2 branches in AI\Impl\NetForward.mqh.           |
//| Front end: MLP only in S2 (AddCustomLayers no-op inherited).     |
//|           Conv/LSTM meta variants would need the descriptor      |
//|           padded to whole pseudo-bars to keep their bar-major    |
//|           window/step geometry - deliberately out of S2 scope.   |
//|                                                                  |
//| S2 trains and reports (coverage x (win rate - break-even) vs the |
//| base-rate null, in Training.mqh's era-end META line). It casts   |
//| NO votes: dPrevSignal never leaves its sentinel, so the base     |
//| LongCondition/ShortCondition return 0.                           |
//|                                                                  |
//| WHAT IT IS INSTEAD (S3, 2026-08-19): a GATE. ScoreProposal()     |
//| scores each vote-cleared entry and vetoes those whose P(win)     |
//| sits under the cost-adjusted break-even. It casts no votes and   |
//| cannot dilute the consensus (VoteCapableWeight/ProspectiveVote   |
//| are 0/false for the meta target).                                |
//|                                                                  |
//| The trading pipeline reaches that through CMetaGate, not through |
//| this class: see Expert\Trading\MetaGate.mqh for why the veto     |
//| stopped being a virtual that every signal in the tree carried.   |
//| This class still EXTENDS the AI signal base, and has to - the    |
//| net, the era loop, the feature windows, the label caches and the |
//| persistence all live there, and MQL5 grants one base class. What |
//| it no longer does is ACT as one on the entry path.               |
//+------------------------------------------------------------------+

//--- Setup descriptor layout (AppendCandidateFeatures): 26 one-hot + side + netVote + SL + TP + spread/ATR.
//--- MetaDescWidth() returns this and the input layer is sized with it - the three MUST stay in step.
#define META_ONE_HOT_SLOTS   26
#define META_DESC_FEATURES   (META_ONE_HOT_SLOTS + 5)

//+------------------------------------------------------------------+
//| The meta head AS A GATE.                                         |
//|                                                                  |
//| CSignalMETA cannot implement CMetaGate itself: it already        |
//| extends CExpertSignalAIBase for the training machinery, and MQL5 |
//| has single inheritance and no interfaces. So the gate role is a  |
//| small bound object the head owns and hands out - the same        |
//| adapter shape CTrainingDataView uses, for the same reason.       |
//|                                                                  |
//| It holds a raw owner pointer deliberately: the owner OWNS the    |
//| adapter, so the adapter can never outlive it.                    |
//+------------------------------------------------------------------+
class CSignalMETA;
class CMetaGateAdapter : public CMetaGate
  {
protected:
   CSignalMETA      *m_owner;
public:
                     CMetaGateAdapter(void) : m_owner(NULL) {}
   void              Bind(CSignalMETA *owner) { m_owner = owner; }
   virtual int       Evaluate(const bool isLong, const double netVote, double &pWin,
                              double &bePct, const int barIdx) override;
  };

class CSignalMETA : public CExpertSignalAIBase
  {
protected:
   //--- The corpus: every journaled pattern instance, filled ONCE per attach - by the on-chart
   //--- ladder sweep below, or from the largest matching signal DB on disk. Timestamps are fixed;
   //--- bar INDICES are re-resolved every era, because a new bar shifts every one of them.
   CMetaCorpus       m_corpus;
   bool              m_prepareReported;   // first-era diagnostics print loudly, later eras verbose
   bool              m_datasetExported;   // one export per attach (Meta_ExportDataset input)
   //--- ON-CHART CANDIDATE SOURCES (the classic filters attached to this same chart). When present,
   //--- the corpus is generated by SWEEPING these real ladders over the chart's own history via the
   //--- StartIndex/EvalShift mechanism - no tester corpus run, no DB dependency, no GMT-offset
   //--- resolution ambiguity (the sweep IS on this chart's bars). The DB loader stays as fallback.
   CExpertSignalCustom *m_srcFilter[4];
   int               m_srcFamily[4];
   int               m_srcCount;
   //--- This head's gate role, bound to `this` in the constructor and never rebound.
   CMetaGateAdapter  m_gateRole;

public:
   //--- The ONE door the trading pipeline uses. It gets a gate, not a signal.
   CMetaGate        *AsMetaGate(void) { return GetPointer(m_gateRole); }
   void              AddCandidateSource(CExpertSignalCustom *filter, const int family)
     {
      if(m_srcCount < 4 && CheckPointer(filter) != POINTER_INVALID)
        {
         m_srcFilter[m_srcCount] = filter;
         m_srcFamily[m_srcCount] = family;
         m_srcCount++;
        }
     }
                     CSignalMETA(void);
   virtual int       MetaDescWidth(void) const override { return META_DESC_FEATURES; }
   virtual bool      MetaPrepareEra(const int bars) override;
   virtual void      AppendCandidateFeatures(const int candId) override;
   //--- S3 (2026-08-19): the scoring behind the gate role. Reached through m_gateRole, whose
   //--- contract is CMetaGate::Evaluate; the honesty notes are in the body's header below.
   int               ScoreProposal(const bool isLong, const double netVote, double &pWin,
                                   double &bePct, const int barIdx);

protected:
   bool              BuildCorpusBySweep(void);
   void              ExportMetaDataset(void);
   //--- Gate-time twin of AppendCandidateFeatures - same width, same slot order, same squash.
   void              AppendLiveDescriptor(const char side, const double netVote, const int barIdx);
   //--- The ladder is SUMMED from the pattern counts in CMetaFamilies, not written out a second
   //--- time here. The bound against META_ONE_HOT_SLOTS stays: the head's input width is this
   //--- class's business, and a taxonomy that grew past it must be caught, not silently truncated.
   int               OneHotSlot(const int family, const int pattern) const
     {
      int slot = CMetaFamilies::OneHotSlot(family, pattern);
      return (slot >= 0 && slot < META_ONE_HOT_SLOTS) ? slot : -1;
     }
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CSignalMETA::CSignalMETA(void) : m_prepareReported(false), m_datasetExported(false), m_srcCount(0)
  {
   SetIdentity("Meta", "META");
   //--- The gate role is a view onto this object; binding here means it is never handed out unbound.
   m_gateRole.Bind(GetPointer(this));
   //--- identity-defining, set once (feeds the |TGT:META fingerprint token and every IsMetaTarget seam)
   m_trainTarget = 1;
   for(int k = 0; k < 4; k++)
     {
      m_srcFilter[k] = NULL;
      m_srcFamily[k] = -1;
     }
  }
//+------------------------------------------------------------------+
//| Generate the candidate corpus by sweeping the REAL classic       |
//| ladders over this chart's own history.                           |
//|                                                                  |
//| Every pattern condition anchors on StartIndex() (verified across |
//| all four signal files), so EvalShift(i) makes the exact live     |
//| code answer "what would you have fired at bar i" - the silent-   |
//| divergence trap that justified the DB corpus does not exist on   |
//| this path, and neither do the tester run, the GMT-offset         |
//| ambiguity, or the DB row caps. Times/prices stored are this      |
//| chart's own bar opens, so MetaPrepareEra's resolution matches at |
//| offset +0 with zero price error by construction.                 |
//|                                                                  |
//| One-time cost at first era: bars x sources Direction() calls -   |
//| a few seconds. Runs on the chart thread like the label prebuild. |
//+------------------------------------------------------------------+
bool CSignalMETA::BuildCorpusBySweep(void)
  {
   if(m_srcCount <= 0)
      return false;
   ENUM_TIMEFRAMES per = (ENUM_TIMEFRAMES)m_period;
   int bars = Bars(_Symbol, per);
   if(bars <= 300)
      return false;
   for(int s = 0; s < m_srcCount; s++)
      if(!m_srcFilter[s].SweepPrepare(bars))
        {
         Print(ID + ": candidate sweep - filter " + m_srcFilter[s].GetFilterID() +
               " could not prepare deep buffers; falling back to a DB corpus.");
         return false;
        }
   //--- skip the indicator warm-up tail at the oldest edge of history (reads there are EMPTY/garbage
   //--- and would fabricate patterns); 150 bars comfortably covers every classic period in use.
   int deepest = bars - 150;
   //--- A HINT, NOT A CAP - the corpus grows itself. A fixed bars*2 ceiling used to be enforced
   //--- here and failed both ways: it silently truncated the corpus when the guard tripped at a
   //--- bar boundary (SP500 filled to exactly cap, dropping the newest bars entirely), and it
   //--- overflowed mid-bar on denser symbols because the guard only reserved room for 2 appends
   //--- (array-out-of-range right here on USDJPY/XAUUSD/XTIUSD, killing the chart at attach).
   //--- The worst case really is m_srcCount*2 appends per bar: state-model patterns stay active
   //--- on most bars, and both sides can fire on one.
   m_corpus.Clear();
   m_corpus.Reserve(bars * 2);
   Print(ID + StringFormat(": sweeping %d classic ladder(s) over %d bars for candidates - the chart"
                           " is busy for a few seconds...", m_srcCount, deepest));
   uint t0 = GetTickCount();
   for(int i = deepest; i >= 2; i--)
     {
      datetime bt = iTime(_Symbol, per, i);
      double bo = iOpen(_Symbol, per, i);
      if(bt <= 0 || bo <= 0.0)
         continue;
      for(int s = 0; s < m_srcCount; s++)
        {
         CExpertSignalCustom *f = m_srcFilter[s];
         f.EvalShift(i);
         f.Direction();
         f.EvalShift(0);
         string pl = f.GetActivePatternLong();
         string ps = f.GetActivePatternShort();
         double nv = f.LastNetVote();
         //--- "Pattern_N" -> N; same per-side, one-candidate-per-bar semantics as live journaling
         if(pl != "NULL")
            m_corpus.Add(bt, (short)1, (short)m_srcFamily[s],
                         (short)StringToInteger(StringSubstr(pl, 8)), nv, bo);
         if(ps != "NULL")
            m_corpus.Add(bt, (short) -1, (short)m_srcFamily[s],
                         (short)StringToInteger(StringSubstr(ps, 8)), nv, bo);
        }
     }
   //--- the reserve above is a guess - trim whatever it over-allocated
   m_corpus.ShrinkToFit();
   Print(ID + StringFormat(": candidate sweep done - %d candidates from %d bars in %.1fs (no tester"
                           " corpus run needed; DB corpus not used).", m_corpus.Count(), deepest,
                           (GetTickCount() - t0) / 1000.0));
   return !m_corpus.Empty();
  }
//+------------------------------------------------------------------+
//| Resolve the corpus onto this era's bar grid.                     |
//|                                                                  |
//| Rows pre-dbVersion-4.0 are GMT, BROKER time since; history is    |
//| server time either way (EET-ish, DST moves                       |
//| it). The offset is MEASURED PER ROW, not assumed: rows are       |
//| journaled at the bar's opening tick with the touchable price, so |
//| the RIGHT offset's bar open matches entryPrice to within the     |
//| spread while a wrong offset lands a full hourly move away. Each  |
//| row takes the offset (0..+4h) minimizing |open - entry| over     |
//| offsets that land on an exact bar, then must pass a tolerance -  |
//| decisive per row, and immune to DST regime changes across an     |
//| 18-year corpus (the histogram printed below shows the winter/    |
//| summer split directly).                                          |
//|                                                                  |
//| The window-span filter kills the pre-2017 daily-backfill regime  |
//| (measured 2026-08-13: hour-0-only rows, one per day): a          |
//| candidate whose m_historyBars-deep window spans more than 4x its |
//| nominal duration is sitting on bars that are not really H1, and  |
//| its geometry/labels would be silently wrong.                     |
//+------------------------------------------------------------------+
bool CSignalMETA::MetaPrepareEra(const int bars)
  {
   //--- corpus source order: the on-chart ladder sweep (self-contained, preferred), then a
   //--- tester-built DB corpus as fallback for charts whose classic filters are disabled.
   //--- m_period, not _Period: the loader's symbol+period filter exists so the rows it returns
   //--- resolve onto the grid this function resolves them onto, and that grid is m_period. The two
   //--- are the same value here (CExpert::Init is given Period()), so this is not a change of
   //--- behaviour - it is the filter naming the thing it is actually filtering for.
   if(m_corpus.Empty() && !BuildCorpusBySweep()
      && m_corpus.LoadLargestOnDisk(_Symbol, (int)m_period, ID) <= 0)
      return false;
   ENUM_TIMEFRAMES per = (ENUM_TIMEFRAMES)m_period;
   //--- one call sizes the grid, reserves the rows and empties the chain - they are one operation
   m_metaCands.Reset(bars, m_corpus.Count());
   int offCount[5] = {0, 0, 0, 0, 0};
   int dropNoBar = 0, dropPrice = 0, dropRegime = 0, dropRange = 0;
   long spanCap = (long)PeriodSeconds(per) * (long)MathMax(m_historyBars, 1) * 4;
   for(int r = 0; r < m_corpus.Count(); r++)
     {
      int bestSh = -1, bestOff = -1;
      double bestDiff = DBL_MAX;
      for(int off = 0; off <= 4; off++)
        {
         int sh = iBarShift(_Symbol, per, m_corpus.Stamp(r) + off * 3600, true);
         if(sh < 0)
            continue;
         double diff = MathAbs(iOpen(_Symbol, per, sh) - m_corpus.EntryPrice(r));
         if(diff < bestDiff)
           {
            bestDiff = diff;
            bestSh = sh;
            bestOff = off;
           }
        }
      if(bestSh < 0)
        {
         dropNoBar++;
         continue;
        }
      //--- price tolerance: right-offset |diff| <= the spread; wrong-offset ~ an hourly move. 15% of
      //--- the bar's ATR separates the two with a wide margin either way; the fallback (5 basis
      //--- points) covers bars where the ATR indicator has no value that deep in history.
      double atr = m_ATR.Main(bestSh);
      double tol = (MathIsValidNumber(atr) && atr > 0.0) ? 0.15 * atr : 0.0005 * m_corpus.EntryPrice(r);
      if(bestDiff > tol)
        {
         dropPrice++;
         continue;
        }
      if(bestSh >= bars)
        {
         dropRange++;
         continue;
        }
      datetime tSh = iTime(_Symbol, per, bestSh);
      datetime tDeep = iTime(_Symbol, per, bestSh + (int)MathMax(m_historyBars, 1));
      if(tSh <= 0 || tDeep <= 0 || (long)(tSh - tDeep) > spanCap)
        {
         dropRegime++;
         continue;
        }
      //--- Add() links the same-bar chain itself. It declines a row it cannot store - a bar off
      //--- the grid (excluded above) or no memory for it - and a declined row is counted, not
      //--- assumed impossible.
      if(m_metaCands.Add(bestSh, (char)m_corpus.Side(r), m_corpus.NetVote(r),
                         m_corpus.Family(r), m_corpus.Pattern(r)) < 0)
        {
         dropRange++;
         continue;
        }
      if(bestOff >= 0 && bestOff <= 4)
         offCount[bestOff]++;
     }
   string line = StringFormat("%s: era candidate resolution - %d of %d corpus rows usable | GMT->server"
                              " offset histogram +0h:%d +1h:%d +2h:%d +3h:%d +4h:%d | dropped: %d no"
                              " exact bar, %d price mismatch (wrong offset/bad data), %d non-H1 regime"
                              " (pre-intraday backfill), %d beyond era grid",
                              ID, m_metaCands.Count(), m_corpus.Count(), offCount[0], offCount[1], offCount[2],
                              offCount[3], offCount[4], dropNoBar, dropPrice, dropRegime, dropRange);
   if(!m_prepareReported)
     {
      m_prepareReported = true;
      Print(line);
     }
   else
      PrintVerbose(line);
   //--- one-shot dataset export for offline pooled training - runs here because this is the first
   //--- moment candidates AND labels both exist on the current bar grid (the label prebuild completed
   //--- before the era start that called us).
   if(Meta_ExportDataset && !m_datasetExported && m_metaCands.Count() > 0)
      ExportMetaDataset();
   return m_metaCands.Count() > 0;
  }
//+------------------------------------------------------------------+
//| Dump the full training set for offline (cross-sectional pooled)  |
//| work: one float32 row per resolved, LABELED candidate -          |
//| [barTime int64][family int32][pattern int32][side int32]         |
//| [won int32][NetInputWidth() floats: window + descriptor].        |
//| The sidecar .meta.csv carries the layout + the geometry/BE the   |
//| labels were computed at, so the offline side never guesses.      |
//| This is EXACTLY what pass 2 trains on - same window builder,     |
//| same descriptor, same caches - so an offline model on this file  |
//| and the EA's own training see byte-equivalent examples.          |
//+------------------------------------------------------------------+
void CSignalMETA::ExportMetaDataset(void)
  {
   m_datasetExported = true;
   const string base = "Warrior_EA\\MetaExport\\" + _Symbol + "_" + IntegerToString((int)m_period);
   int fh = FileOpen(base + ".f32", FILE_BIN | FILE_WRITE | FILE_COMMON | FILE_SHARE_READ | FILE_SHARE_WRITE);
   if(fh == INVALID_HANDLE)
     {
      Print(ID + ": dataset export FAILED - cannot open Common\\Files\\" + base + ".f32 (error " +
            IntegerToString(GetLastError()) + ")");
      return;
     }
   Print(ID + StringFormat(": exporting %d candidates to Common\\Files\\%s.f32 - one pass-1-sized"
                           " sweep, the chart is busy for it...", m_metaCands.Count(), base));
   int width = NetInputWidth();
   int rows = 0, skipLabel = 0, skipWindow = 0;
   for(int cd = 0; cd < m_metaCands.Count(); cd++)
     {
      int idx = m_metaCands.Bar(cd);
      if(idx < 0 || idx >= ArraySize(m_labelCacheHasValue) || !m_labelCacheHasValue[idx])
        {
         skipLabel++;
         continue;
        }
      if(!BuildFeatureWindow(idx))
        {
         skipWindow++;
         continue;
        }
      AppendCandidateFeatures(cd);
      if(TempData.Total() != width)
        {
         skipWindow++;
         continue;
        }
      FileWriteLong(fh, (long)iTime(_Symbol, (ENUM_TIMEFRAMES)m_period, idx));
      FileWriteInteger(fh, (int)m_metaCands.Family(cd));
      FileWriteInteger(fh, (int)m_metaCands.Pattern(cd));
      FileWriteInteger(fh, m_metaCands.Side(cd));
      FileWriteInteger(fh, MetaCandidateWon(cd, idx) ? 1 : 0);
      for(int k = 0; k < width; k++)
         FileWriteFloat(fh, (float)TempData.At(k));
      rows++;
     }
   FileClose(fh);
   double slMult = 0.0, tpMult = 0.0;
   BarrierMultiples(slMult, tpMult);
   double bePct = (slMult + tpMult > 0.0) ? 100.0 * slMult / (slMult + tpMult) : 50.0;
   int mh = FileOpen(base + ".meta.csv", FILE_CSV | FILE_WRITE | FILE_COMMON | FILE_SHARE_READ | FILE_SHARE_WRITE, ',');
   if(mh != INVALID_HANDLE)
     {
      FileWrite(mh, "symbol", "period", "rows", "width", "historyBars", "featuresPerBar", "descWidth",
                "slMult", "tpMult", "breakEvenPct", "horizonBars", "spreadPoints");
      FileWrite(mh, _Symbol, IntegerToString((int)m_period), IntegerToString(rows),
                IntegerToString(width), IntegerToString((int)m_historyBars),
                IntegerToString(m_neuronsCount), IntegerToString(MetaDescWidth()),
                DoubleToString(slMult, 4), DoubleToString(tpMult, 4), DoubleToString(bePct, 2),
                IntegerToString(m_barrierHorizonBars), IntegerToString((int)m_symbol.Spread()));
      FileClose(mh);
     }
   Print(ID + StringFormat(": dataset exported - %d rows (%d skipped: %d unlabeled near the era edge,"
                           " %d unusable windows) x %d floats | geometry %.2f/%.2f BE %.1f%% |"
                           " %s.f32 + .meta.csv", rows, skipLabel + skipWindow, skipLabel, skipWindow,
                           width, slMult, tpMult, bePct, base));
  }
//+------------------------------------------------------------------+
//| The setup descriptor - MUST append exactly META_DESC_FEATURES     |
//| values (the input layer is sized for them; a short append fails   |
//| the NetInputWidth() guard and the sample is skipped, a long one   |
//| would corrupt the forward pass).                                  |
//+------------------------------------------------------------------+
void CSignalMETA::AppendCandidateFeatures(const int candId)
  {
   if(!m_metaCands.Contains(candId))
      return;
   int idx = m_metaCands.Bar(candId);
   int slot = OneHotSlot(m_metaCands.Family(candId), m_metaCands.Pattern(candId));
   for(int k = 0; k < META_ONE_HOT_SLOTS; k++)
      TempData.Add(k == slot ? 1.0 : 0.0);
   TempData.Add((double)m_metaCands.Side(candId));
   //--- netVote is in raw pattern-weight units (+-100ish); tanh(nv/20) keeps resolution where the
   //--- votes actually live while bounding the tails. MQL5 has no MathTanh - via exp.
   double e2 = MathExp(2.0 * (m_metaCands.NetVote(candId) / 20.0));
   TempData.Add((e2 - 1.0) / (e2 + 1.0));
   //--- geometry in ATR units - constant across candidates TODAY (one pinned barrier pair), but the
   //--- design's excursion-head integration makes it per-candidate later, so it rides as a feature.
   double slMult = 0.0, tpMult = 0.0;
   BarrierMultiples(slMult, tpMult);
   TempData.Add(slMult);
   TempData.Add(tpMult);
   //--- spread/ATR at the fire bar (EnsureSpreadSeries copies unconditionally for the meta target)
   double sprAtr = 0.0;
   double atr = m_ATR.Main(idx);
   if(idx >= 0 && idx < m_spreadSeriesBars && MathIsValidNumber(atr) && atr > 0.0)
      sprAtr = (double)m_spreadSeries[idx] * m_symbol.Point() / atr;
   TempData.Add(sprAtr);
  }
//+------------------------------------------------------------------+
//| S3 - THE LIVE META GATE (2026-08-19, user design: "the META NN    |
//| should be integrated into the voting decision pipeline").         |
//|                                                                   |
//| Scores the PROPOSED trade the consensus vote just cleared: the    |
//| shared feature window at barIdx plus a descriptor of the proposal |
//| itself (side, the net vote, the live SL/TP geometry, spread/ATR). |
//| The pattern one-hot is ZEROED - the proposal is the vote, not a   |
//| classic-ladder fire. On the S2 MLP the one-hot columns act as     |
//| additive per-pattern bias vectors into the first layer, so        |
//| zeroing them asks the trained context trunk for its pattern-free  |
//| score. That is an extrapolation by one additive term (no training |
//| row ever had an empty one-hot), so the honest reading is RANKING, |
//| not calibrated probability - which is why the threshold is the    |
//| cost-adjusted break-even (the least arbitrary zero-knob rule) and |
//| the gate ships default-off. The measured next lever is journaling |
//| the vote itself as a candidate family so the head trains on the   |
//| exact stream it gates - see Meta_Labeling_Design.md's S3 note.    |
//|                                                                   |
//| FAIL-OPEN EVERYWHERE: not trained, no net, window unbuildable,    |
//| width mismatch, non-finite forward - all return codes that let    |
//| the trade proceed. The only -1 is a real scored veto. The BN      |
//| freeze save/restore bracket makes the forward a pure function     |
//| (the snapshot rule - the same bracket DisplayInference uses); the |
//| meta front-end is MLP-only, so there is no LSTM state to guard.   |
//| Telemetry is written only for LIVE queries (barIdx == 1): the     |
//| ensemble verdict's historical replays must not inflate the HUD's  |
//| live approve/veto counters.                                       |
//|                                                                   |
//| Return codes are CMetaGate's four, and only META_GATE_VETOED       |
//| blocks anything.                                                  |
//+------------------------------------------------------------------+
int CSignalMETA::ScoreProposal(const bool isLong, const double netVote, double &pWin,
                               double &bePct, const int barIdx)
  {
   pWin = -1.0;
   bePct = CostAdjustedBreakEvenPct();
   bool live = (barIdx == 1);
   //--- One readiness test + transition announcement for every observer - see MetaGateArmedNow.
   if(!MetaGateArmedNow())
      return META_GATE_INACTIVE;
   if(!BuildFeatureWindow(barIdx))
      return META_GATE_FAIL_OPEN;
   AppendLiveDescriptor((char)(isLong ? 1 : -1), netVote, barIdx);
   if(TempData.Total() != NetInputWidth())
      return META_GATE_FAIL_OPEN;
   //--- Save/restore, NOT set/clear: frozen, this forward is a pure function (the snapshot rule).
   bool bnWasFrozen = Net.GetBatchNormFrozen();
   if(!bnWasFrozen)
      Net.SetBatchNormFrozen(true);
   bool fwdOk = Net.feedForward(TempData);
   if(fwdOk)
      Net.getResults(TempData);
   if(!bnWasFrozen)
      Net.SetBatchNormFrozen(false);
   if(!fwdOk)
      return META_GATE_FAIL_OPEN;
   double p = MetaWinProbability();
   if(p < 0.0 || !MathIsValidNumber(p))
      return META_GATE_FAIL_OPEN;
   pWin = p;
   int verdict = (100.0 * p >= bePct) ? META_GATE_APPROVED : META_GATE_VETOED;
   if(live)
      m_metaTelemetry.RecordLive(p, bePct, verdict);
   return verdict;
  }
//+------------------------------------------------------------------+
//| The gate role's one method: forward to the head that owns it.    |
//| Fails open when unbound, on the same doctrine as everything else |
//| on this path - a gate that cannot be reached must not block.     |
//+------------------------------------------------------------------+
int CMetaGateAdapter::Evaluate(const bool isLong, const double netVote, double &pWin,
                               double &bePct, const int barIdx)
  {
   if(CheckPointer(m_owner) == POINTER_INVALID)
     {
      pWin = -1.0;
      bePct = -1.0;
      return META_GATE_INACTIVE;
     }
   return m_owner.ScoreProposal(isLong, netVote, pWin, bePct, barIdx);
  }
//+------------------------------------------------------------------+
//| The gate-time twin of AppendCandidateFeatures: same width, same   |
//| slot order, same squash - MUST stay in step with it and with      |
//| META_DESC_FEATURES. The differences ARE the proposal: zeroed      |
//| one-hot (the vote is not a classic-ladder fire), the caller's     |
//| side and net vote, and spread/ATR at barIdx through the same      |
//| series-or-zero rule training used (a fallback to the current      |
//| quoted spread would feed the net a quantity training never saw    |
//| on unavailable bars).                                             |
//+------------------------------------------------------------------+
void CSignalMETA::AppendLiveDescriptor(const char side, const double netVote, const int barIdx)
  {
   for(int k = 0; k < META_ONE_HOT_SLOTS; k++)
      TempData.Add(0.0);
   TempData.Add((double)side);
   //--- same tanh(nv/20) squash as AppendCandidateFeatures - MQL5 has no MathTanh, via exp
   double e2 = MathExp(2.0 * (netVote / 20.0));
   TempData.Add((e2 - 1.0) / (e2 + 1.0));
   double slMult = 0.0, tpMult = 0.0;
   BarrierMultiples(slMult, tpMult);
   TempData.Add(slMult);
   TempData.Add(tpMult);
   double sprAtr = 0.0;
   double atr = m_ATR.Main(barIdx);
   if(barIdx >= 0 && barIdx < m_spreadSeriesBars && MathIsValidNumber(atr) && atr > 0.0)
      sprAtr = (double)m_spreadSeries[barIdx] * m_symbol.Point() / atr;
   TempData.Add(sprAtr);
  }
//+------------------------------------------------------------------+