Warrior_EA/Expert/ExpertSignalAIBase.mqh

//+------------------------------------------------------------------+
//|                                                       Warrior_EA |
//|                                                     AnimateDread |
//|                                                                  |
//+------------------------------------------------------------------+
#include "ExpertSignalCustom.mqh"
#include "..\AI\Network.mqh"
#include "..\Variables\IndicatorResources.mqh"
#include "..\Variables\IndicatorTuneRanges.mqh"
#include "..\System\StatusLabel.mqh"
#include "..\System\NewsRelevance.mqh"
#include "..\System\CrossAsset.mqh"
#include "..\System\AltData.mqh"
#include "ADIndicatorTuner.mqh"
//--- Hard 0/1 one-hot targets for the 3-neuron classification head - matches the book's
//--- (nnbook.txt sec. 1.4 "Cross-entropy") cross-entropy formulation, which defines the reference
//--- distribution's occurring-event probability as exactly 1.0 (missing event exactly 0.0), no
//--- smoothing. This used to be softened to 0.9/0.1 (see git history) as a workaround for the OLD
//--- per-neuron independent-sigmoid backward gradient: since that gradient was each neuron's own
//--- raw (target-sigmoid_output) delta with nothing else driving it to zero, a literal 1.0/0.0
//--- target was only ever approached asymptotically, so weights kept growing (up to the MAX_WEIGHT
//--- clamp) chasing it forever. Now that CNet::backProp()/backPropOCL() (AI\Network.mqh) compute a
//--- joint softmax+categorical-cross-entropy gradient (softmax_i - target_i) across all 3 neurons
//--- instead, the winning class's SOFTMAX probability - not any one neuron's raw sigmoid value -
//--- is what needs to approach the target, and softmax can reach very close to 1.0 for the winning
//--- class from ordinary (non-saturated) logit separation, so the old runaway-weight failure mode
//--- is no longer expected to require smoothed targets to avoid. If it resurfaces in practice (the
//--- per-neuron SIGMOID forward pass can still individually saturate before softmax normalizes),
//--- that's the first thing to check before reintroducing smoothing.
// Soft labels keep the classification head from overfitting to hard one-hot targets while still
// preserving a clear target for the true class. The true class gets 0.9 and the others 0.05 each.
#define LABEL_SMOOTH_HIGH 0.9
#define LABEL_SMOOTH_LOW  0.05
//--- Namespace prefix for the directional signal arrows this class draws (DrawObject/DeleteObject). Two
//--- reasons it exists: (1) so PurgeChart() can delete ONLY our arrows and never the user's own manual
//--- chart drawings (a full ObjectsDeleteAll(0) on a client's chart is not acceptable for a commercial
//--- product), and (2) so arrows can survive an EA re-init instead of being wiped on every InitIndicators
//--- - the whole point of keeping them on screen (the panel has a hide toggle if the user wants them gone).
//--- MOVED to Expert\ExpertSignalCustom.mqh (the nearest common ancestor) when the classic signals
//--- started drawing too - this header is included too late for them to see it. Left as a comment
//--- rather than deleted because every reference below still names it and the reader lands here.
//--- Control-panel object namespace. CAppDialog names every control it owns from the dialog name it is
//--- created with, so one prefix covers the whole tree. Declared HERE rather than left as a string
//--- literal at the ExtPanel.Create call site so it can appear in the sweep list below - a prefix that
//--- lives only at its creation site is a prefix nothing cleans up.
#define WARRIOR_PANEL_PREFIX "WarriorCP"
//--- Custom chart-event id space for the training self-event ("study" event). Every instance used to
//--- post id 1 and handle id 1001, which had two consequences on an ensemble chart: (a) CExpertCustom
//--- broadcasts chart events to EVERY filter, so each member's event ran a train chunk in ALL N
//--- members - N events per round times N chunks each = N*N chunks, the chart thread never went idle,
//--- and the control panel's clicks/drags starved behind the queue (observed 2026-08-16 as a completely
//--- dead panel in AI_HYBRID ensemble mode: no buttons, no dragging, no minimize); and (b) id 1 IS the
//--- Standard Library Controls ON_DBL_CLICK code, so a double-click on any panel control also fired a
//--- training chunk. Ids are now assigned per instance from this base, chosen far above the Controls
//--- library's ON_* event range (0..~100) so neither side can ever misread the other's events.
#define STUDY_EVENT_ID_BASE   500
//--- Lost-event watchdog (see ScheduleTrainingIfNeeded): before the per-instance ids, a member whose
//--- armed event vanished (queue overflow) was accidentally rescued by any SIBLING's event clearing its
//--- bEventStudy. Member-scoped ids remove that rescue, so the liveness guarantee has to be explicit:
//--- an event armed this long ago that never arrived is declared lost and re-armed. Generous on purpose
//--- - a legitimately queued event can wait tens of seconds behind a sibling's unchunked warm-up
//--- diagnostics, and while the thread is busy the watchdog cannot run either, so a false trip would
//--- need the thread idle AND the event still missing, which is exactly the failure being covered.
#define STUDY_EVENT_LOST_MS 60000
//--- Next unassigned study-event id, claimed in the constructor. File-scope because each chart runs its
//--- own copy of the program (globals are per-instance in MQL5), so this simply numbers the ensemble
//--- members 0..N-1 in construction order on this chart.
int g_warriorStudyEventSeq = 0;
//+------------------------------------------------------------------+
//| ENSEMBLE CHART-LEVEL SHARED STATE (AIType == AI_HYBRID preset).   |
//|                                                                   |
//| The registry lists every AI signal running as an ensemble member  |
//| on this chart (registered in EnsembleMember()). It exists because |
//| three user-requested behaviours (2026-08-16) are chart-level, not |
//| member-level:                                                     |
//|  1. ERA BARRIER - members advance era by era TOGETHER. A member   |
//|     ahead of the slowest still-training member declines its       |
//|     Train() calls (EnsembleEraBarrierHolds), and its chunk budget |
//|     flows to the laggards (EnsembleActiveTrainers scales          |
//|     TRAIN_TIME_BUDGET_MS), so wall-clock throughput is conserved. |
//|  2. COMBINED-VOTE OOS SCORE - what the ensemble panel reports as  |
//|     THE ensemble's accuracy. Each member's pass-3 OOS scan drops  |
//|     the per-bar VOTE it would have cast (LiveVoteContribution(),  |
//|     not its raw confidence) into the row buffer below             |
//|     (EnsembleOosContribute); when every still-training member has |
//|     finished its scan for the era (EnsembleOosPassComplete), the  |
//|     last one scores the AVERAGED vote against the same            |
//|     win-long/win-short outcomes the members grade themselves on   |
//|     (EnsembleScoreCombinedVote) - the panel line answers "how     |
//|     often is the vote that actually trades right", which no       |
//|     per-member number can.                                        |
//|  3. The auto-tune/MI warm-up sharing (see AutoTune.mqh's          |
//|     g_ensembleChartTuneDone) rides the same identical-inputs      |
//|     argument.                                                     |
//| Solo charts register nothing and none of this runs.               |
//+------------------------------------------------------------------+
class CExpertSignalAIBase;
CExpertSignalAIBase *g_warriorEnsemble[];
//--- Combined-vote OOS row buffer, one row per scored OOS bar of the CURRENT era (g_ensVoteEra; the
//--- era barrier keeps members on the same era, so one stamp suffices - a stale-era contribution
//--- resets the buffer). Sum + bitmasks rather than per-member columns: the vote is an average, so
//--- only the sum and who contributed are needed. Win outcomes are label-cache-derived and identical
//--- across members; the first member to touch a row writes them.
//---
//--- TWO masks, not one, and the difference is the whole union-semantics rule:
//---   g_ensVoteMask      - who EVALUATED this bar (contributed a row at all). Gates the "shared bars
//---                        only" test: a bar one member skipped is a different population.
//---   g_ensVoteVoterMask - who actually VOTED (contributed a NON-ZERO number). This is the divisor,
//---                        because CExpertSignalCustom::Direction() skips abstentions in BOTH the sum
//---                        and the count (`if(direction == 0) continue;` before `number++`), so the
//---                        live vote is a mean over VOTERS, not over members. The gate used to divide
//---                        by the member count, which made an abstention dilute here and not there -
//---                        a strictly different fire set from the one that trades.
datetime g_ensVoteTime[];
double   g_ensVoteSum[];
int      g_ensVoteMask[];
int      g_ensVoteVoterMask[];
//--- Sum of the module weights behind g_ensVoteSum, i.e. the weighted mean's DIVISOR. Carried per
//--- row rather than recomputed at verdict time because a member's m_weight can be rewritten by
//--- UpdateSignalsWeights() between the scan and the verdict, and the divisor has to be the one
//--- that was in force when the numerator was accumulated - otherwise the ratio is of two
//--- different moments. See CExpertSignalCustom::Direction()'s normalization comment.
double   g_ensVoteWeightSum[];
bool     g_ensVoteWinLong[];
bool     g_ensVoteWinShort[];
bool     g_ensVoteDirLabel[];    // bar carried a Buy/Sell label - the coverage floor's base rate
int      g_ensVoteRows = 0;
long     g_ensVoteEra = -1;
int      g_ensVoteDoneMask = 0;
int      g_ensVoteCursor[8];     // per-member monotonic row cursor (members scan bars in the same order)
//--- Population count over the member masks above. Bounded by the 8-slot ensemble, so a plain loop is
//--- both the clearest and the fastest thing here; it runs once per shared OOS row per era.
int EnsembleBitCount(const int mask)
  {
   int n = 0;
   for(int b = 0; b < 8; b++)
      if((mask & (1 << b)) != 0)
         n++;
   return n;
  }
//+------------------------------------------------------------------+
//| ENSEMBLE DEPLOY GATE (user request 2026-08-16: "an ensemble mode  |
//| for the pass gates - at the end of the day they vote together").  |
//|                                                                   |
//| In ensemble mode the UNIT OF EVALUATION IS THE VOTE. Members keep |
//| their own per-era statistics and their own learning-rate dynamics |
//| (regression restore, eta decay - those are per-net training       |
//| mechanics), but four decisions move here, because all four are    |
//| really questions about what gets TRADED:                          |
//|   * which era is "best"      -> best COMBINED-vote era            |
//|   * what gets checkpointed   -> a JOINT snapshot: every member's  |
//|                                 weights at that one era           |
//|   * when the run gives up    -> one shared plateau ladder         |
//|   * whether it may deploy    -> family-wise gate on the VOTE      |
//|                                                                   |
//| WHY A JOINT CHECKPOINT IS THE WHOLE POINT: per-member selection   |
//| picks each net's own best era, and those eras are different. The  |
//| resulting quartet was never measured together at any instant, so  |
//| the vote it casts live is a configuration no OOS number ever      |
//| described. Capturing all four at the era whose VOTE scored best   |
//| makes the deployed ensemble exactly the one that was measured.    |
//|                                                                   |
//| SAFE BY CONSTRUCTION, and it depends on the era barrier: Train()  |
//| runs at most one era per call and a member that finished era N    |
//| is held at the barrier until every member reaches N, so when the  |
//| last member scores the vote, no member's weights have advanced    |
//| past the end of era N. That is what makes a deferred simultaneous |
//| capture correct rather than a race.                               |
//|                                                                   |
//| The statistics mirror the per-member gate one for one (see        |
//| tradeableOK / BestCheckpointSurvivesSelection in Training.mqh):   |
//| same coverage floor, same EDGE_MIN_SIGMAS margin over the same    |
//| always-call-one-direction chance reference, same Sidak correction |
//| over the eras ranked. Only the population changes - the bars the  |
//| VOTE fired on, rather than the bars one member called.            |
//+------------------------------------------------------------------+
double g_ensBestScore      = -1.0;   // best combined-vote selection score (precision x coverage credit)
bool   g_ensBestTradeable  = false;  // did that era clear the vote's own deployability floor
bool   g_ensBestTwoSided   = false;  // did it fire both long and short
double g_ensBestPrecPct    = -1.0;   // the winning era's vote win rate, for the family-wise test
double g_ensBestChancePct  = -1.0;   // and its chance reference
int    g_ensBestCalls      = 0;      // and the n that sets the standard error
long   g_ensBestEra        = -1;
int    g_ensCandidateEras  = 0;      // N for the family-wise correction: eras that COULD have won
int    g_ensErasSinceBest  = 0;      // shared plateau counter
int    g_ensPlateauStage   = 0;      // shared plateau stage
//--- One-shot latch so the collective IS-error plateau announces itself once per run instead of once
//--- per era. Reset with the rest of the shared gate state at the start of a run.
bool   g_ensIsPlateauAnnounced = false;
bool   g_ensDeployApproved = false;  // stage 3 reached AND the vote cleared the family-wise gate
long   g_ensLastVerdictEra = -1;     // guards against scoring one era twice
//--- Lifetime (compounded, never reset per era) combined-vote win-rate over every bar the VOTE
//--- actually fired on, in the SAME shape as a solo model's m_cumOosCorrect/m_cumOosTotal - so the
//--- ensemble panel reads with the identical label and the identical measurement (a persisted OOS
//--- win-rate over called bars) instead of a single era's fired-bar percentage, which is a different,
//--- noisier quantity and used a different label ("Ensemble vote: win X% on Y fired bars"). Not
//--- persisted to disk - like every other g_ens* search-state global, it is chart-session-scoped and
//--- resets on a fresh attach, same as the rest of the ensemble ladder state.
long   g_ensCumOosCorrect  = 0;
long   g_ensCumOosTotal    = 0;
//--- Mirror of the Min_Vote_Open input (the CExpert open threshold), pushed in at registration so the
//--- combined-vote scorer fires on the same criterion the live trade does. Signals themselves only see
//--- their own confidence; the threshold is an EA-level input this header cannot read directly.
//---
//--- UNITS: the 0..100 VOTE scale - the same numbers m_pattern_0..3 carry and the same scale
//--- CExpertSignalCustom::CheckOpenPosition compares m_direction against. It is NOT a confidence
//--- percentage; the scorer used to multiply a 0..1 confidence by 100 to meet it here, which put a head
//--- output and a DB-ranked win-rate weight on the same axis with nothing relating them. See
//--- LiveVoteContribution(). The seed below is only ever read before registration overwrites it, which
//--- happens for every ensemble member (Warrior_EA.mq5) before any verdict can run.
double   g_ensembleVoteThreshold = 60.0;
//--- Set true by AdvancePatternDatabaseBackfill() on completion; consumed by Warrior_EA.mq5's OnTimer
//--- to bypass the hourly DB-ranking throttle ONCE, so filter weights refresh from the freshly
//--- backfilled rows immediately instead of waiting up to an hour to reflect a model that just deployed.
bool     g_forcePatternWeightsRefresh = false;
//--- Set true by RankTiersFromOos() at every pass-3 completion (any member, solo or ensemble);
//--- consumed by Warrior_EA.mq5's timer to (re)arm the filtered-view overlay sweep. A flag rather
//--- than an era-sum comparison because what the sweep needs is "a member's snapshot just got
//--- fresher", which era counters only approximate - and approximating it is how the sweep used to
//--- re-arm against half-built caches.
bool     g_warriorOverlayArmRequest = false;
//+------------------------------------------------------------------+
//| EVERY chart-object namespace this EA creates, in ONE list.        |
//|                                                                   |
//| This exists because the list drifted. PurgeChart()'s own comment  |
//| said it removed "our namespaced signal arrows plus the status-    |
//| label objects" while the code deleted arrows only, and the panel  |
//| prefix was swept at OnInit and nowhere else - so a deinit left    |
//| the status line and any panel straggler on the chart, which is    |
//| exactly the reported symptom. A comment cannot be kept in step    |
//| with three scattered call sites; one array can.                   |
//|                                                                   |
//| Add a prefix here the moment a new object family is introduced.   |
//| Deleting by prefix and never by ObjectsDeleteAll(chart) is        |
//| deliberate: a blanket wipe also removes the user's own drawings   |
//| and other indicators' objects, which is not acceptable on a       |
//| client's chart.                                                   |
//+------------------------------------------------------------------+
int WarriorChartPrefixes(string &out[])
  {
   ArrayResize(out, 7);
   out[0] = SIG_ARROW_PREFIX;         // directional signal arrows - bare prefix, so it also
                                      // matches every per-member namespace (WarSig_PAI_ ...)
   out[1] = STATUS_LABEL_PREFIX;      // status line background + text (System\StatusLabel.mqh)
   out[2] = WARRIOR_PANEL_PREFIX;     // control panel and its whole control tree
   out[3] = "WarriorAltMap_";         // alt-data symbol-mapping dialog (ADM_PREFIX in
                                      // Panel\AltDataMapDialog.mqh - literal here because that
                                      // header is included later in the build order)
   //--- CATCH-ALL, and the reason it is here rather than replacing the four above: the list drifted once
   //--- (see the header) and on 2026-08-17 22:00 it evidently drifted again - all three charts were
   //--- starved on teardown at 21:58 (Abnormal termination, no cleanup-timings line), the init purge then
   //--- removed 993/1373/1557 objects and reported ZERO by-name leftovers, and the charts still came up
   //--- with duplicated panels. "Nothing left that matches our prefixes" and "the chart is clean" are not
   //--- the same statement, and only the first one was ever being checked.
   //--- Every family this EA has ever created is named "Warrior..." except the arrows ("WarSig_"), so one
   //--- bare prefix covers the three named above AND anything a future rename or a stale .ex5 left behind
   //--- under a name nobody remembers. It stays a PREFIX delete, never ObjectsDeleteAll(chart): the
   //--- user's own drawings and other indicators' objects are not ours to remove.
   //--- Harmless to overlap - deleting an already-deleted name is a no-op - and it does NOT defeat
   //--- skipArrows, because "WarSig_" does not start with "Warrior".
   out[4] = "Warrior";
   //--- THE FILTERED VIEW's vote arrows, listed SEPARATELY from SIG_ARROW_PREFIX even though the
   //--- name matches it, and that separation is the whole point: skipArrows protects the per-model
   //--- arrows at deinit because their sidecar is rebuilt by SCANNING them off the chart, so they
   //--- cannot be deleted until that write has run. Vote arrows have NO sidecar - they are a
   //--- reconstruction, rebuilt from scratch on the next attach - so there is nothing to preserve
   //--- them for, and holding them through the early sweep only inflates ObjectsTotal for the two
   //--- expensive scans that follow it (SaveChartSignals per member, then the by-name rescan).
   //--- On a long-history chart that is thousands of extra objects walked, twice, inside the
   //--- teardown budget - which is exactly when the chart cannot afford it. Deleting them here is
   //--- one native prefix call in the first few milliseconds.
   out[5] = SIG_VOTE_PREFIX;
   //--- The vote readout (CExpertSignalCustom::UpdateVoteReadout). Already covered by the "Warrior"
   //--- catch-all above, and listed anyway: the catch-all exists because this list has drifted
   //--- twice, not to make entries optional.
   out[6] = VOTE_HUD_PREFIX;
   return 7;
  }
//+------------------------------------------------------------------+
//| Delete every object in those namespaces from a chart, and verify. |
//|                                                                   |
//| skipArrows leaves the signal arrows alone, for the one caller     |
//| that must: a re-init restores arrows from their sidecar and       |
//| wiping them here would make them flicker off and back on.        |
//|                                                                   |
//| The rescan is not paranoia. ObjectsDeleteAll's return value was   |
//| already observed disagreeing with a by-name scan of the same      |
//| chart microseconds apart, and object commands are QUEUED on the   |
//| chart rather than applied inline - so "the bulk call returned a   |
//| number" is not evidence the objects are gone. Names are collected |
//| before any deletion because deleting while enumerating by index   |
//| renumbers the list being walked.                                  |
//+------------------------------------------------------------------+
int WarriorPurgeChartObjects(long chartID, bool skipArrows, int &leftoverCount)
  {
   string prefixes[];
   int n = WarriorChartPrefixes(prefixes);
   int removed = 0;
   leftoverCount = 0;
   for(int p = 0; p < n; p++)
     {
      if(skipArrows && prefixes[p] == SIG_ARROW_PREFIX)
         continue;
      int r = ObjectsDeleteAll(chartID, prefixes[p]);
      if(r > 0)
         removed += r;
     }
   //--- Typed-blind rescan across EVERY object type: an earlier version filtered on OBJ_ARROW and was
   //--- therefore blind in the same way the bulk delete was, which is how two scans of one chart
   //--- disagreed for three sessions.
   int total = ObjectsTotal(chartID, -1, -1);
   string leftovers[];
   int found = 0;
   if(total > 0)
     {
      ArrayResize(leftovers, total);
      for(int i = 0; i < total; i++)
        {
         string nm = ObjectName(chartID, i, -1, -1);
         for(int p = 0; p < n; p++)
           {
            if(skipArrows && prefixes[p] == SIG_ARROW_PREFIX)
               continue;
            if(StringFind(nm, prefixes[p]) == 0)
              {
               leftovers[found++] = nm;
               break;
              }
           }
        }
     }
   for(int i = 0; i < found; i++)
      ObjectDelete(chartID, leftovers[i]);
   leftoverCount = found;
   return removed + found;
  }
//--- Upper bound on arrows restored from a .arrows file (see LoadChartSignals). Purely a guard against a
//--- corrupt header declaring a garbage count - a long converged run legitimately accumulates a few
//--- thousand, so this sits well above that. Restoring is chunked across timer calls regardless, so a
//--- large-but-valid count costs progressive fill-in, never a frozen OnInit.
#define MAX_RESTORED_ARROWS 50000
//--- How many of the MOST RECENT arrows are kept on the chart and in the .arrows sidecar. Arrows would
//--- otherwise accumulate for the life of the model (a converged SP500 H1 run had reached 2896), which
//--- clutters the chart, slows every save/restore, and preserves history nobody scrolls back to. Both
//--- SaveChartSignals (which also DELETES the pruned objects from the chart) and LoadChartSignals select
//--- by TIME, not by scan order - ObjectsTotal() order is arbitrary, so "the last N scanned" would keep a
//--- random subset rather than the newest.
#define MAX_PERSISTED_ARROWS 1000
//--- Manual "rescan" window (see RescanChartSignals): how many of the MOST RECENT bars get re-inferred
//--- from the currently deployed weights when the operator asks for a fresh signal set. Bounded well
//--- below a full StudyPeriods re-render (which can be years of bars and would freeze the one MQL5 chart
//--- thread, same doctrine as MAX_RESTORED_ARROWS/ARROW_RESTORE_BUDGET_MS) - a rescan is meant to replace
//--- stale old arrows with what the model calls on RECENT history, not reproduce the whole training run.
//--- MOVED to Expert\ExpertSignalCustom.mqh with the historical filtered overlay, which needs the
//--- same bound and lives in the common base (this header is included later - see SIG_ARROW_PREFIX).
//--- Strength of the Beta prior RankTiersFromOos() shrinks each confidence tier toward the model's
//--- pooled holdout win rate, counted in EFFECTIVE observations (see EffectiveSampleSize). A tier
//--- carries roughly 8-15 of those out of one era's OOS window, so at 10 a tier sits about half on
//--- its own evidence and half on the pool. NOT MIN_TRADES_FOR_WIN_RATE (100): that is the classic
//--- ladders' prior, counted in RAW live trades, and applying it to effective counts would pin all
//--- four tiers to the pooled rate forever.
#define TIER_PRIOR_EFF_N 10.0
//--- Wall-clock budget per chunk of the deferred arrow restore. Same doctrine as TRAIN_TIME_BUDGET_MS:
//--- MQL5 gives a chart ONE thread, so "async" here means small time-boxed slices between which the
//--- terminal can service the panel, the chart and the journal - never a single long blocking pass.
//--- 50ms sits between the training chunk (120ms, already tolerated) and the 500ms timer period, so the
//--- restore completes in a handful of slices while leaving ~90% of each timer window free for the UI.
#define ARROW_RESTORE_BUDGET_MS 50
//--- Max allowed |Δ| between the compute backend's and the pure-MQL5 path's outputs for a model to be
//--- marked MQL5-inference-safe (see ValidateCpuInference). The outputs are bounded sigmoid values;
//--- backend-vs-double summation-order noise is ~1e-6 on the CPU-DLL path (double) and stays well under
//--- this even on a float32 OpenCL backend, while a genuine math/port bug shows up as >0.01. Fails safe.
#define CPU_INFERENCE_MAX_DIFF 1.0e-3
//--- g_signalsVisible is declared in ExpertSignalCustom.mqh now, alongside SIG_ARROW_PREFIX.
//--- FILTER-BASED auto-tuner constants (see TuneIndicatorsByFilter). The GA_* / TUNE_POP_* knobs that
//--- lived here are gone with the genetic search they configured.
//--- MI_BINS: equal-frequency bins the feature column is discretised into before the joint histogram.
//--- Mutual information is biased upward as bins increase (each bin holds fewer samples, so noise looks
//--- like structure); 8 bins against MI_SAMPLE_BARS samples keeps ~250 samples per bin per class, which
//--- is comfortably in the regime where that bias is small and equal across candidates - and equal is
//--- what matters, since this score is only ever used to RANK.
#define MI_BINS          8
//--- Bars sampled (evenly spaced across the in-sample window) per candidate evaluation. The whole cost of
//--- tuning is candidates x this x features, so it is the one number that trades accuracy for time.
#define MI_SAMPLE_BARS   2000
#define MI_MIN_SAMPLES   200
//--- Eras the MI diagnostics may wait for the cross-asset panel before reporting without it. Three is
//--- enough for the terminal to finish synchronising auxiliary symbols on a live chart, and short
//--- enough that a tester run - where an un-downloaded reference symbol is permanently absent - is not
//--- left without diagnostics at all.
#define MI_REPORT_MAX_DEFERRALS 3
//--- Largest |k| the label-alignment scan uses. Every MI sample is padded by MiShiftPad() - which is at
//--- least this - at BOTH ends REGARDLESS of the offset being requested, so that every build enumerates
//--- the IDENTICAL bar set with the IDENTICAL stride. That is what makes two builds comparable row by
//--- row. Padding by |offset| instead (as this did until 2026-08-02) shifted the offset build's starting
//--- bar, so the positive control paired rows that were offset+pad apart rather than offset apart: it
//--- reported 0.00307 nats for a pair it called "24 bars apart", which is the value for 48 bars, failed
//--- its own 5x gate, and printed "every mutual-information figure above is void" over perfectly sound
//--- measurements. Verified against an independent computation in research/test_mi_control.py.
#define MI_ALIGN_MAX_SHIFT 5
//--- Coordinate-descent passes. The second pass lets a parameter re-optimise against what the others
//--- moved to; the loop breaks early as soon as a pass changes nothing, so this is a ceiling, not a cost.
#define MI_TUNE_PASSES   2
//--- MI_NOISE_PERMUTATIONS: draws from the null distribution used to test the observed score. Sets the
//--- resolution of the empirical p-value, which can never go below 1/(B+1) - so 200 draws can report
//--- "p<=0.005" and no finer, which is ample for a yes/no on whether a feature set carries signal.
//--- Cheap because BuildMiSample runs ONCE and every draw reuses it (see ScoreMiSample); the cost is a
//--- relabel and 26 histogram passes, not 2000 feature extractions.
//--- Two earlier values were wrong and both are instructive. ONE shuffle answers "is this above a coin
//--- flip's worth of noise" rather than "is this above noise". FIVE looked principled but was not: on
//--- 2026-08-01 all four charts scored the identical 0.00401 nats on identical features and identical
//--- labels, and reported z of +1.3, +2.0, +4.0 and +4.7 - two "noise floor", two "real". With five
//--- draws the standard deviation of the standard-deviation estimate is ~35%, so the denominator of that
//--- z was noisier than the effect it was judging. Counting ranks avoids estimating a spread at all.
#define MI_NOISE_PERMUTATIONS 200
//--- Lag-profile draws, deliberately far below MI_NOISE_PERMUTATIONS: the profile redraws its null at
//--- EVERY lag (see ReportFeatureLagProfile for why a shared floor would be wrong), so the cost is
//--- draws x historyBars, not draws. 40 resolves a p of 0.05 to within about one draw, which is all a
//--- lookback decision needs - this figure never gates a trade.
#define MI_LAG_PERMUTATIONS 40
//--- Per-lag significance, applied against the null of the MAXIMUM over lags rather than against each
//--- lag's own null. The first version did the latter and it was wrong: ~21 lags at 0.05 stars one lag
//--- per run before any signal exists, and on SP500 H1 that produced two opposite verdicts on identical
//--- data hours apart. The alpha stays 0.05; what changed is the null it is measured against.
#define MI_LAG_ALPHA 0.05
//--- WHICH TARGET BuildMiSample() scores the features against. The barrier class is the shipped training
//--- target; the excursion targets exist to answer a question the barrier label cannot, and that every MI
//--- verdict in this project so far has silently conflated.
//---
//--- "Optimal SL/TP" decomposes into two predictions that behave nothing alike:
//---   HOW FAR price travels (the excursions) - essentially a volatility question, and volatility
//---     clustering is about the most robust regularity there is, so expect this to be predictable.
//---   WHICH barrier is reached first (the asymmetry) - direction, which is what the barrier label
//---     measures and what has come back at the noise floor every time.
//--- Expectancy comes ONLY from the second. The first buys position sizing and drawdown control, which
//--- is worth having under prop-firm limits but is not an edge - exit management tested against RANDOM
//--- entries moved the payoff ratio 0.92 -> 5.72 with expectancy FLAT.
//--- Measuring them separately is the point: if size clears and asymmetry does not, the deliverable is
//--- risk control and we should stop looking for edge in the exit.
//--- BARRIER DERIVATION. The stop sits at a HIGH quantile of adverse travel, so only the minority of bars
//--- whose adverse excursion exceeds it ever reach it; the target at the MEDIAN of favourable travel, so
//--- it is reached about half the time inside the horizon by construction. Neither number creates
//--- expectancy (chance precision equals break-even at every geometry) - they make the target reachable
//--- and the stop survivable, which the enum grid {2,3} x {2,3,4,6,8,10} could only do by luck.
//---
//--- THE STOP QUANTILE WAS 0.25 AND THAT WAS BACKWARDS. q25 means 75% of bars exceed the stop, i.e. it is
//--- hit three times in four - the opposite of "ordinary noise does not reach it". Caught by the measured
//--- reachability line the derivation prints ("stop on 75.0% of bars"), which is the entire reason that
//--- figure is reported instead of assumed. A quantile is a threshold, not a rate: to be rarely reached a
//--- stop must sit ABOVE most of the distribution.
//--- 2026-08-17 REPLACED. The pair above read the stop from q75 of ADVERSE travel and the target from
//--- q50 of FAVOURABLE travel. Over one horizon those two distributions are broadly the same shape, so
//--- q75 > q50 MECHANICALLY - the target came out smaller than the stop no matter what the market did.
//--- SP500 H4 shipped stop 3.07 / target 1.70: a 0.55:1 payoff needing a 64.3% win rate. That was never
//--- a measurement, it was two mismatched constants, and the reachability line printed beside it
//--- ("target on 50.0% of bars, stop on 25.0%") is exactly 1-q50 and 1-q75 - tautological, and unable to
//--- disconfirm anything. ReportBarrierGeometryScan will not even SCORE a pairing with the target inside
//--- the stop ("inverts the trade's whole premise"), so the one check that could have caught it was
//--- structurally blind to the geometry that shipped.
//---
//--- WIDTH AND RATIO ARE INDEPENDENT, and only one of them pays.
//---   EV per trade = edge x width, width = stop + target. Ratio is EV-NEUTRAL: chance precision equals
//---   break-even at every ratio (a driftless walk reaches +m before -k with probability k/(k+m), which
//---   IS the break-even rate). What the ratio DOES buy is the shape of the loss distribution, and what
//---   WIDTH buys is cost efficiency - the spread is a fixed 0.047*ATR on this instrument, so a 4.77*ATR
//---   width pays it 21 times per unit of travel where a 9.2*ATR width pays it 11.
//--- So the ratio is a POLICY choice and the scale is a MEASUREMENT. They are set separately below.
//---
//--- RATIO: user policy, 1 risk : 2 reward. Break-even 33.3%.
#define BARRIER_TARGET_RR    2.0
//--- SCALE: the stop is still read off the ADVERSE distribution, so it stays measured and survivable.
//--- The quantile is chosen from this ladder, WIDEST FIRST, taking the first one whose implied target
//--- (RR x stop) is still reached often enough to be a trainable class. That is the honest version of
//--- what the removed min-reward:risk raise got wrong in 2026-08-09: it forced target = 2 x stop with no
//--- reachability test at all, landed on 6.66*ATR reachable on 3.3% of bars, and trained the model to
//--- predict something that essentially never happened. Same ratio here, but the SCALE now retreats
//--- until the data says the target is attainable, instead of the ratio overriding the data.
#define BARRIER_SL_QUANTILE_COUNT 7
const double BARRIER_SL_QUANTILE_LADDER[BARRIER_SL_QUANTILE_COUNT] =
   {0.90, 0.85, 0.80, 0.75, 0.70, 0.60, 0.50};
//--- Retained as the fallback quantile when no rung clears the reachability floor.
#define BARRIER_SL_QUANTILE  0.75
//--- Below this many resolved excursions the quantiles are too noisy to key a training target on, and the
//--- configured multiples stand.
#define BARRIER_DERIVE_MIN_SAMPLES 500
//--- FIRST-PASSAGE LADDER. m_excUpCache/m_excDownCache hold only the MAXIMUM travel each way, and a
//--- maximum cannot say which side was reached FIRST - so a candidate geometry other than the one the
//--- walk actually used is undecidable on exactly the bars where both barriers were touched, which is
//--- ~28% of the sample. Recording the first-touch AGE for a ladder of travel distances makes any pair
//--- of ladder levels evaluable exactly, with no re-walk: long wins iff its target was touched and the
//--- stop either never was or was touched later.
//--- Levels are TRAVEL FROM ENTRY (the bar's close), not barrier prices, so one ladder serves both
//--- directions and the spread is applied analytically when a level is converted back to an SL/TP
//--- multiple: a long fills at close+spread, so reaching its target needs travel = reward + spread and
//--- its stop trips at travel = risk - spread. Storing barrier prices instead would need four ladders
//--- and would bake today's spread into the cache.
//--- CEILING REMOVED 2026-08-17. The ladder used to stop at 5.00 and the expectancy scan's "best
//--- resolvable pair on width alone" came back as stop 5.05 / target 4.95 - i.e. it pinned to the top
//--- rung. A recommendation that lands exactly on the edge of its own search space is not a finding, it
//--- is a boundary, and it cannot distinguish "5 ATR is optimal" from "5 ATR is all we let it consider".
//--- Since EV = edge x width with no upper bound in the arithmetic, the only thing that should stop the
//--- search is the HORIZON failing to resolve the trade - which the scan already tests (decided >= 60%)
//--- and the derivation now tests too (reachability floor). Let those bind instead of a constant.
//--- Extended to 20*ATR with widening spacing: 4x the old reach, and the constraints self-limit.
//--- Cost: m_ladderUpAt/m_ladderDownAt are bars x COUNT ints each (~1.3MB at 11k bars), and the
//--- excursion head widens to 2 x COUNT outputs. Both scale linearly and both are parameterised, so
//--- nothing here needs a matching edit elsewhere.
#define BARRIER_LADDER_COUNT 14
const double BARRIER_LADDER[BARRIER_LADDER_COUNT] =
   {0.50, 0.75, 1.00, 1.50, 2.00, 3.00, 4.00, 5.00, 6.50, 8.00, 10.00, 13.00, 16.00, 20.00};
//--- The derivation is a FIXED-POINT ITERATION, not a one-shot. ComputeBarrierHorizonBars scales the
//--- horizon with the target (first-passage time grows with the band), and the excursions are measured
//--- OVER that horizon - so target -> horizon -> excursions -> target is a loop. Deriving once would set
//--- the target from travel measured under the OLD horizon and quietly mis-state it. Re-measure until the
//--- multiples stop moving, capped so a pathological oscillation cannot spin forever.
#define BARRIER_DERIVE_MAX_PASSES 5
#define BARRIER_DERIVE_TOLERANCE  0.05
//--- Reachability floor for the scale ladder, expressed as a FRACTION OF BREAK-EVEN rather than as an
//--- absolute percentage. It has to scale with BARRIER_TARGET_RR or the knob silently changes how strict
//--- the floor is: break-even for a 1:RR trade is 100/(1+RR), so the old absolute 20% was 0.60x
//--- break-even at RR=2 but would be 0.80x at RR=3 - tightening the test simply because the user asked
//--- for a bigger target. 0.60 reproduces exactly 20.0% at the shipped RR=2, so this is a no-op today
//--- and correct tomorrow.
//--- What it means: a long at this geometry must WIN on at least 60% as often as break-even requires.
//--- Below that the horizon is truncating the trade rather than the market refusing to pay - and the
//--- positive class gets too rare to train on, which is the failure the 2026-08-09 min-RR raise caused.
#define BARRIER_MIN_REACH_FRACTION_OF_BE 0.60
#define BARRIER_MIN_TP_REACH_PCT \
   (BARRIER_MIN_REACH_FRACTION_OF_BE * 100.0 / (1.0 + BARRIER_TARGET_RR))
//--- WHICH END OF THE SCALE LADDER WINS, and it depends on what phase the project is in. This is not a
//--- taste knob; the two objectives are genuinely opposed and each is correct in its own phase.
//---
//--- WIDE is right once an edge is KNOWN. EV per trade = edge x width and the spread is a fixed cost, so
//--- width is pure cost efficiency: at 10.48*ATR the round trip costs 0.9% of the move, at 4.82 it costs
//--- 2.0%.
//---
//--- NARROW is right while the edge still has to be DEMONSTRATED, and the scaling is brutal. Labels
//--- overlap by their lifespan L, so an N-bar window holds N/L independent observations (see
//--- EffectiveSampleSize). First-passage time for the band [-m,+k] grows like m*k, and at a fixed ratio
//--- that is width^2 - so:
//---     SE            ~ sqrt(L/N)      ~ width / sqrt(N)
//---     min detectable edge = 2*SE     ~ width
//---     min detectable EV   = edge x w ~ width^2
//--- DOUBLING THE WIDTH QUADRUPLES THE SMALLEST EV YOU CAN PROVE, while buying only a linear improvement
//--- in cost. Measured 2026-08-17 on SP500 H4: a 4,738-bar OOS window at L=75.6 holds ~63 independent
//--- observations, which puts the deploy gate's required win rate above anything reachable. The run was
//--- not failing to find an edge; it could not have measured one either way.
//---
//--- The exponent above is theory - the measured L came in 4.2x shorter than the m*k formula predicts -
//--- but the DIRECTION does not depend on the exponent: L rises with width under any sane model, so
//--- narrower always buys independent samples. The ladder now prints measured L and the implied
//--- detectable EV per rung (see LadderWinShare), so the exponent is checkable rather than assumed.
#define BARRIER_SCALE_MEASURE 0   // narrowest rung that stays cost-efficient - maximises detectability
#define BARRIER_SCALE_DEPLOY  1   // widest rung that clears reachability - maximises EV per trade
#define BARRIER_SCALE_OBJECTIVE BARRIER_SCALE_MEASURE
//--- The floor that stops MEASURE mode running to the tightest rung, and the mirror of the reachability
//--- floor that stops DEPLOY mode running to the widest. Round-trip cost is 2*spread, so this caps how
//--- much of the move the spread is allowed to eat. At the measured 0.047*ATR spread, 3% admits any
//--- width down to ~3.1*ATR - which is where the ladder should stop, not where a constant happens to.
#define BARRIER_MAX_COST_FRACTION_PCT 3.0
#define MI_TARGET_BARRIER   0   // shipped 3-class triple-barrier label
#define MI_TARGET_EXC_UP    1   // (maxHigh - entry)/ATR over the horizon, 3 equal-frequency bins
#define MI_TARGET_EXC_DOWN  2   // (entry - minLow)/ATR
#define MI_TARGET_EXC_RANGE 3   // up + down: pure realised volatility, the control that SHOULD clear
#define MI_TARGET_EXC_ASYM  4   // up - down: RAW asymmetry - CONFOUNDED BY VOLATILITY, see below
//--- SCALE-FREE asymmetry, and the only one of the two that can support a directional claim.
//--- (up-dn) is NOT scale-free: if sigma is predictable - and RANGE clears at ~4x its null on every
//--- instrument tested - and the directional part is symmetric noise eps, then up-dn ~ sigma*eps, so a
//--- large sigma pushes the value into BOTH outer terciles. A pure volatility predictor therefore scores
//--- positive MI against a 3-bin (up-dn) while carrying no directional information whatsoever, and it
//--- does so consistently across instruments - so replication does not rule it out. Measured 2026-08-07:
//--- raw ASYM cleared on EURUSD and USDCAD at p=0.0050 exactly where RANGE was strongest.
//--- Dividing by (up+dn) removes the scale factor and leaves the question actually being asked: given
//--- that price moved, WHICH WAY did it move further. Bounded in [-1,+1] by construction.
#define MI_TARGET_EXC_ASYM_NORM 5
//--- Significance the indicator tuner's winner must reach, AFTER correcting for having been chosen out of
//--- N candidates. Same 0.05 as elsewhere; what matters is that a gate exists at all, since this selector
//--- overwrites the user's configured indicator settings and forces a fresh topology.
#define MI_TUNE_ALPHA 0.05
//--- WHAT THE TUNER OPTIMISES FOR (re-pointed 2026-08-16). The sweep used to score candidates against
//--- the BARRIER label - direction - which every measurement here puts at the noise floor (best-of-999
//--- at p=1.0000, lag profile empty, normalised asymmetry collapsing on three instruments). Optimising
//--- indicator parameters for MI against a noise target means the winner gate correctly rejects nearly
//--- everything ("no improvement" run after run) - the sweep was climbing a flat landscape. RANGE is
//--- the one target with measured signal (4x its null, p=0.005, WITH a working positive control), and
//--- it is what the excursion head - the component these features actually serve under the
//--- meta-labeling architecture - is trained to predict. So the tuner now selects indicator settings
//--- for how much they know about REALISED VOLATILITY, the channel that prices barriers and sizes
//--- risk. The MI report still scores the barrier label alongside (ReportFeatureLabelInformation is
//--- unchanged) so a directional miracle would still be seen - it just no longer steers the tuner.
#define MI_TUNE_TARGET MI_TARGET_EXC_RANGE
//--- Ceiling on profiled lags, sizing the retained-draw matrix. m_historyBars is derived and could in
//--- principle exceed this; the profile then covers the first MI_LAG_MAX_PROFILE-1 lags and says so via
//--- the lag count it prints, rather than overrunning the buffer.
#define MI_LAG_MAX_PROFILE 32
//--- Draws per candidate in the barrier-geometry scan. Raised from the ranking-only 20 because these draws
//--- now do a second job: they build the FAMILY-WISE null that decides whether the winner is real (see
//--- ReportBarrierGeometryScan). A max-statistic lives in the upper tail of the null, and a tail is exactly
//--- where 20 draws are thinnest. Cost is draws x candidates on an already-extracted sample - the whole
//--- scan ran in 3.2s at 20 draws, so this is single-digit seconds, once, before era 0.
#define MI_GEOMETRY_PERMUTATIONS 40
//--- Family-wise significance for the geometry winner. Stricter than MI_LAG_ALPHA because the two decisions
//--- are not comparable: a lag profile that guesses wrong costs some input width, whereas acting on this
//--- one means RELABELLING and retraining every topology from era 0. The gate must be hard to pass.
#define MI_GEOMETRY_ALPHA 0.05
//--- Ceiling on scanned candidates, sized to the shipped grid (2 stop multiples x 6 target multiples). Only
//--- used to size the fixed draw matrix below; the loop still skips ineligible pairings.
#define MI_GEOMETRY_MAX_CANDIDATES 12
//--- How many standard errors a checkpoint's directional precision must clear chance by before it is
//--- considered deployable - see the edgeFloorPct block in Train(). Two sigma is the conventional
//--- "not a fluke" bar and lands near 1pp at the ~11,000 directional calls a full OOS era produces.
//--- CRITICAL CONTEXT, and the reason chance is the right reference at all: under a driftless random
//--- walk the probability of touching +k*ATR before -m*ATR is m/(m+k), and the break-even win rate for a
//--- k:m reward:risk trade is ALSO m/(m+k). The label's own base rate IS the break-even rate, at every
//--- SL/TP setting. So "beats chance" and "is profitable" are the same test, no SL/TP choice can
//--- manufacture an edge, and this margin is measuring expectancy directly.
#define EDGE_MIN_SIGMAS  2.0
//--- The edge, as a fraction, that the barrier-geometry adoption must at least be ABLE to certify before
//--- it will switch geometries (see the detectability guard in ReportBarrierGeometryScan). Deliberately
//--- GENEROUS - 10pp over break-even is far more than anything this project has ever measured - because
//--- the guard is meant to catch pairings that are hopeless rather than merely hard. A geometry that
//--- cannot support even a 10pp edge on this window is one no amount of training could ever cash.
#define ADOPT_MIN_DETECTABLE_EDGE 0.10
//--- BOTH-DIRECTIONS FLOOR. A model that has stopped calling one side entirely is degenerate, and the
//--- coverage+precision test above cannot see it: coverage counts directional calls without caring
//--- that they are all the same direction, and one-sided precision can sit above chance while the
//--- model is simply riding the sample's drift. Observed 2026-08-09: the perceptron reported
//--- "Sell:0%" in every one of its 41 eras, cleared the floor on Buy alone at 36.6% vs 34% chance,
//--- deployed, and sprayed buy arrows across the chart.
//---
//--- Deliberately far below m_minDirectionalRecallPct (the 40%-per-class diagnostic): that floor is
//--- effectively unreachable on this data and was demoted for exactly that reason, so reusing it here
//--- would block every deployment rather than the pathological ones. 10% only catches a side that has
//--- genuinely gone silent, and it applies to Buy and Sell only - Neutral is the majority class and a
//--- low Neutral recall is a model taking positions, not a broken one.
#define DEPLOY_MIN_SIDE_RECALL_PCT 10.0
//--- FAMILY-WISE DEPLOYMENT GATE. EDGE_MIN_SIGMAS above is a PER-ERA test, and the deployed model is the
//--- MAXIMUM over every era a run produced - which is the one construction this project has repeatedly
//--- proven crowns noise. A 2-sigma one-sided test passes on noise with probability 0.0228 per era, so
//--- over N eras the chance that at least one clears it is 1-(1-0.0228)^N: 34% by era 18, 80% by era 70,
//--- 93% by era 112. The gate was therefore near-certain to open on a long run no matter what the data
//--- contained, and it did - HYBRID deployed on 2026-08-08 at dir-precision 35.5% vs 34% chance, +1.5pp,
//--- selected as the best of 112 eras whose per-era values wandered between 30% and 35.5%.
//--- Every OTHER best-of-N decision in this codebase already carries this correction and every one of
//--- them REJECTS on this data: the barrier-geometry winner ("tested against the null of the maximum over
//--- 6", p=0.3902), the indicator tuner (Sidak "p_family = 1 - (1-p)^N", p=1.0000), the MI lag profile
//--- ("against the null of the MAXIMUM over 21 lags"). The one decision that actually ships a model to a
//--- live account had none. See BestCheckpointSurvivesSelection().
//--- Sidak on the era count, matching the tuner's idiom. NOTE it is CONSERVATIVE here: consecutive eras
//--- share the same OOS bars and differ by one gradient step, so they are nowhere near N independent
//--- draws and the true family-wise error is below this bound. Erring strict is deliberate - this gate
//--- decides what trades real money, and the codebase's whole posture is reject-unless-demonstrated.
#define DEPLOY_FAMILY_WISE_ALPHA 0.05
//--- OVERSAMPLING CONSTANTS REMOVED 2026-07-31 (MAX_OVERSAMPLE_REPLICAS, OVERSAMPLE_PARITY_FRACTION).
//--- Data-level class-balance oversampling is gone; every bar is queued exactly once and the imbalance
//--- is corrected analytically in the gradient by the logit-adjusted loss. See the queueing block in
//--- Expert\AIBase\Training.mqh for the four successive oversampling designs that collapsed before it,
//--- and the class-imbalance audit in Variables\Inputs.mqh for the nine inputs this consolidated.
//--- TRIPLE-BARRIER LABELS (Lopez de Prado, "Advances in Financial Machine Learning", ch. 3).
//--- 2026-08-01: replaced exact-pivot ZigZag labels. ZigZag REMAINS the input-feature source
//--- (m_useSwingContext) and the horizon source below - only the TARGET changed.
//---
//--- Why. The old label marked the single exact bar where a ZigZag pivot confirmed: ~1,164 Buy, ~1,164
//--- Sell, ~35,841 Neutral - a 31:1 imbalance, and every correction mechanism in this file (logit
//--- adjustment, prior EMA, bias seed, recall floor, alternation gate, NMS, four oversampling designs)
//--- was downstream of that one choice. The imbalance was self-inflicted by the target, not a property
//--- of the market: the reference book (references\neuronetworksbook.pdf ch. 3.1/3.3) also uses ZigZag
//--- but targets the DIRECTION TO THE NEXT EXTREMUM on every bar - ~50/50, nothing to correct.
//---
//--- What replaces it. For each bar, place the EA's OWN stop and target around a hypothetical entry at
//--- that bar's close and ask which barrier a real trade would touch first, within a horizon:
//---   long reaches TP before SL, short does not  -> Buy
//---   short reaches TP before SL, long does not  -> Sell
//---   neither resolves in the model's favour     -> Neutral
//--- The barriers come from SL_Mode/TP_Mode (m_sl_mode/m_tp_mode, inherited from CExpertSignalCustom),
//--- so the label and the trade CANNOT drift apart, and `dir-precision` in the era line stops being a
//--- proxy and literally becomes the win rate of the strategy under its own exit rules. That is the
//--- number this project never had. No new user input: the two that shape the label already exist.
//---
//--- Expected balance. At the shipped SL_ATR_x1 / TP_ATR_x3 the gambler's-ruin probability of touching
//--- +3 ATR before -1 ATR is 1/(1+3) = 25% per side, so roughly 25/25/50 - about 2:1 rather than 31:1.
//--- Measured for real at the end of the prebuild; do not assume it.
//---
//--- INTRABAR AMBIGUITY IS RESOLVED PESSIMISTICALLY. When one bar's range spans both barriers, OHLC
//--- cannot say which came first, so the label counts it as the STOP. A win rate built on the
//--- optimistic reading is exactly the kind of number that evaporates live.
#define BARRIER_TIE_GOES_TO_STOP 1
//--- Vertical (time) barrier, in bars. DERIVED, never configured: the median distance between confirmed
//--- ZigZag pivots over the training window - i.e. this symbol/timeframe's own natural swing horizon,
//--- measured from the same indicator the features already read. Snapped to the ladder below so the
//--- estimate has to move ~30% to change the answer; without that quantization a horizon that drifted as
//--- history downloaded would silently relabel a partially-trained model's targets mid-run. Same
//--- measure-once-then-quantize contract as ComputeFirstLayerWidth().
//--- It is deliberately NOT in the weights-filename fingerprint - a filename keyed on a measured
//--- quantity orphans a trained model the moment the measurement moves. See BuildConfigFingerprint.
//--- 2026-08-01: the ladder used to stop at 128 and that ceiling, not the barrier geometry, was the
//--- binding constraint. First-passage time for a driftless walk leaving [-m, +k] is proportional to m*k,
//--- and the measured swing median here is ~12 bars at m*k=1 - so EVERYTHING from 2:6 upward wanted more
//--- than 128 bars and got truncated, including the SHIPPED 2:6 configuration. A truncated label stops
//--- meaning "does the target come before the stop" and quietly becomes "...within 128 bars", while the
//--- deployed EA holds until SL or TP with no bar limit. That is a train/deploy mismatch in the target
//--- itself, and it silently converted the slow winners - exactly the trades a 1:3 barrier exists to
//--- catch - into Neutral. Extended to cover the whole selectable grid: 3:10 needs ~360 bars.
//--- Cost is one embargo of BARRIER_HORIZON_MAX bars out of ~38k, i.e. nothing.
#define BARRIER_HORIZON_LADDER_COUNT 11
#define BARRIER_HORIZON_MIN 12
#define BARRIER_HORIZON_MAX 384
//--- Fallback when the ZigZag scan finds too few pivots to take a median from (a cold history buffer, or
//--- a symbol so quiet that Depth-12 emits almost nothing). Mid-ladder, and it logs when it fires.
#define BARRIER_HORIZON_FALLBACK 32
//--- Minimum confirmed pivots required before the median is trusted rather than the fallback.
#define BARRIER_HORIZON_MIN_SAMPLES 20
//--- Share of bars one class must hold before the era-0 output-bias cold-start seed fires - see the
//--- trigger in AdvanceLabelCachePrebuild(). A +-3.0 bias seed is a correction at a 94%-Neutral prior
//--- and a distortion at a 50% one, so the threshold marks where "dominant" actually starts.
#define COLD_START_SEED_MIN_DOMINANCE 0.70
//--- Reduce-on-regression learning-rate decay. `eta` (AI\Network.mqh) is a plain global read fresh
//--- by every weight-update call on every backend (native/OpenCL/CPU-DLL/DirectML-DLL alike), so
//--- shrinking it here takes effect on the very next backProp() everywhere at once. A fixed step
//--- size that is large enough to escape a bad random init quickly (see the sharp era 5->14 OOS
//--- accuracy climb this was tuned against) is, by the same token, large enough to overshoot once
//--- training gets close to a good solution - the era 14->16 regression right after that climb is
//--- the classic signature of that overshoot, not a structural bug. The existing best-checkpoint
//--- mechanism just below (m_bestOosForecast + CNet::CaptureWeights) already guarantees the FINAL deployed
//--- model can't regress; this constant lets the live training process itself settle down instead
//--- of continuing to oscillate around a good solution once it finds one.
#define ETA_DECAY_REGRESSION_PCT 5.0  // only decay after a real regression, not per-era noise
#define ETA_DECAY_FACTOR         0.7
//--- 1e-5, not the old 1e-4: with the ceiling at 3e-4 the old floor gave the whole decay schedule a
//--- 3x dynamic range - three 0.7x decays and it was pinned, so "reduce LR on regression" could never
//--- actually settle a run that kept oscillating (2026-08-09 audit, F2). 30x leaves the schedule room
//--- to genuinely calm down; the recovery bump still climbs back at 1/0.7 per new best, so a run that
//--- resumes improving is not stuck crawling.
#define ETA_MIN                  0.00001
//--- Balanced accuracy (macro-recall) of a model that puts every bar in ONE class: (0+0+100)/3. It is
//--- the FLOOR of the balanced metric, not a midpoint - any genuinely multi-class model scores above it.
//--- ComputeFirstLayerWidth() constants. SECONDS_PER_YEAR is the mean Julian year (365.25 days), the
//--- same convention MQL5's own date arithmetic uses. MARKET_OPEN_FRACTION allows for closed hours and
//--- weekends - ~0.72 is right for both a 24/5 FX week and an index with extended sessions, and the
//--- ladder in that function makes anything in the 0.6-0.85 range land on the same rung anyway.
//--- FIRST_LAYER_MIN_WIDTH is a floor for degenerate configs (a very short study period, or a symbol
//--- whose history cannot support the requested window) - below this the taper has nothing to work with.
#define SECONDS_PER_YEAR         31557600.0
#define MARKET_OPEN_FRACTION     0.72
//--- Ceiling on how much of the classification head's LOGIT RANGE the logit-adjustment offsets may
//--- consume, as a fraction. The head is SIGMOID, so each output is bounded to [0,1] and the widest
//--- logit difference the net can express between two classes is CLASS_LOGIT_SCALE * (1 - 0) - six,
//--- at the shipped scale. The offsets are tau*log(prior_c), whose spread on a 30:1 imbalance is
//--- log(0.939) - log(0.031) = 3.42, so an untamed tau=1.0 spends 57% of the ENTIRE expressible range
//--- on the prior correction alone. Measured 2026-07-29: every chart did the only thing it could -
//--- saturate its Buy/Sell outputs to 1.0 to overcome a -3.42 handicap during training - and since the
//--- offsets are absent at inference, that surplus made EVERY bar directional. Neutral recall 0%, calls
//--- on ~100% of bars, win rate 5-7% against a ~6% base rate: no information at all, while balanced
//--- accuracy read a flattering 64% because two of its three terms were ~95%.
//--- Menon et al. assume an unbounded logit head, where a 3.42 shift is negligible against the range
//--- the network can reach. It is not negligible here, so the strength has to be expressed relative to
//--- the range actually available. Deliberately a FRACTION rather than a tau ceiling: it stays correct
//--- if CLASS_LOGIT_SCALE changes, if the head becomes unbounded, or on any other symbol/timeframe
//--- whose class imbalance differs - none of which a hardcoded tau would survive.
#define LOGIT_ADJUST_MAX_RANGE_FRACTION 0.20
//--- Minimum directional call rate a checkpoint must reach to be considered deployable, expressed as a
//--- FRACTION OF THE TRUE DIRECTIONAL BASE RATE rather than an absolute percentage - a model that calls
//--- a direction a quarter as often as one actually occurs is sparse but usable; one that calls ten
//--- times a decade is not, however precise those ten calls were. Derived rather than configured so it
//--- adapts to any symbol/timeframe/label rule without a second input to keep in sync.
#define MIN_COVERAGE_FRACTION_OF_BASE_RATE 0.25
//--- DIRECTIONAL CONFIDENCE THRESHOLD (2026-08-09). The training loss and the checkpoint-selection
//--- metric want different things, and until now only the second one knew it. Logit-adjusted
//--- cross-entropy pushes the head to call every class at roughly its adjusted prior - it has no term
//--- for "how often should I trade" - so the model calls a direction on 87-91% of bars. The selection
//--- metric meanwhile is precision x coverage credit, saturating at the coverage floor: above the
//--- floor, extra calls earn NOTHING and only precision counts. So selection wants few, good calls and
//--- the loss produces many mediocre ones, and all selection could do was pick the least-bad era out of
//--- whatever the loss happened to hand it. Nothing pushed the model toward selectivity.
//---
//--- This closes that gap without touching the loss (which is doing its own job correctly - it is
//--- estimating class probabilities, and a probability estimate should not be distorted to encode a
//--- trading policy). The decision RULE gets the policy instead: emit a directional call only when the
//--- softmax margin between the winning direction and its best rival clears a threshold, and pick that
//--- threshold to maximise precision subject to still clearing the same coverage floor the selection
//--- metric uses. Standard cost-sensitive-decision practice (Elkan 2001): estimate probabilities, then
//--- choose the operating point separately.
//---
//--- FITTED ON A HELD-OUT CALIBRATION SLICE, APPLIED TO OOS AND LIVE. It is not enough for the fit to
//--- avoid the graded data (it always did - pass 3 comes after): the curve it reads must also be one the
//--- weights have not MEMORIZED, and harvesting it from pass 2's own backprop samples failed that second
//--- requirement badly. Measured 2026-08-10 by pairing every fit against the same era's OOS result:
//---
//---   PAI era  1  IS 25% coverage @ 66.1% win (-0.8pp)  ->  OOS 64% (-3pp)   gap  +2.1pp
//---   PAI era 24  IS 66% coverage @ 76.4% win (+9.5pp)  ->  OOS 65% (-2pp)   gap +11.4pp
//---   PAI era 76  IS 90% coverage @ 79.6% win (+12.7pp) ->  OOS 65% (-2pp)   gap +14.6pp
//---   LSTM era 9  IS 77% coverage @ 81.6% win (+14.6pp) ->  OOS 63% (-4pp)   gap +18.6pp
//---
//--- The gap grows monotonically with era while OOS stays flat, i.e. the IS curve stops describing the
//--- model's behaviour on unseen bars within a handful of eras. That is fatal HERE specifically, because
//--- FitDirConfThreshold's objective branches on the SIGN of (p - break-even): the memorized curve says
//--- +12pp at 95% coverage, so `coverage x (p - p0)` correctly maximises coverage and returns ~0.02 -
//--- fire on every bar. The `p < p0 -> get more selective` branch, which is the actual regime and the
//--- entire point of 983a6a3, could never fire because IS never showed p < p0.
//---
//--- So the slice below is carved out of the IS span, purged from backprop on BOTH sides by one label
//--- horizon, and scored after pass 2 has finished training. It costs DIR_CONF_CALIB_PCT_OF_IS of the
//--- training data. That is worth paying for a reason beyond honesty: the deploy gate needs
//--- dirPrecPct > chance + EDGE_MIN_SIGMAS*SE, and a threshold pinned near zero DILUTES any edge that is
//--- concentrated in the confident bars across every bar the model calls, driving dirPrecPct toward
//--- chance by construction. A threshold that can actually be selective is the only mechanism by which a
//--- small, concentrated edge could ever clear that gate.
//---
//--- Bin count is a resolution/noise trade-off: the margin lives in [0,1], so 50 bins put each candidate
//--- threshold 0.02 apart, fine enough to sit near the precision peak and coarse enough that each bin
//--- still holds thousands of the ~38k IS bars.
#define DIR_CONF_THRESHOLD_BINS 50
//--- Below this many directional calibration calls the histogram is too sparse to choose an operating
//--- point from, and a threshold fitted on a handful of bars is just the best-of-N error at a smaller
//--- scale. The model then KEEPS THE PREVIOUS ERA'S THRESHOLD rather than falling back to 0.0: "trade
//--- every bar" is the most dangerous setting in the range, so it must never be what a failed
//--- measurement decays to. At era 0 the previous value is 0.0 anyway, so the first-era behaviour is
//--- unchanged.
#define DIR_CONF_MIN_FIT_CALLS  200
//--- Share of the IS span held out to fit the operating point on. 15% of a ~38k-bar IS span is ~5.7k
//--- bars, ~28x DIR_CONF_MIN_FIT_CALLS even before allowing that ~99% of bars resolve directionally
//--- under the measured geometry - so the fit is never sparse, and each of the 50 bins still holds
//--- enough calls to be a rate rather than a coin flip. Larger buys precision in the fit at a direct
//--- cost in training data; smaller makes the operating point itself noisy, which is the failure this
//--- whole mechanism exists to avoid.
#define DIR_CONF_CALIB_PCT_OF_IS 15
//--- (A RANK_SLICE_PCT_OF_OOS constant lived here for a few hours on 2026-08-16, reserving a share of
//--- the OOS window for the pattern-database backfill. It is gone: the CALIBRATION BAND already has
//--- every property it was carving for - see StartPatternDatabaseBackfill. Carving a second reserved
//--- region cost the deploy gate 20% of its sample for nothing, and in its first placement it also
//--- blanked ~10 months of chart arrows, because arrows are only drawn on bars pass 3 grades.)
//--- EXCURSION-SIZE HEAD (see Expert\AIBase\Excursion.mqh for the whole rationale). Hidden width is
//--- deliberately small: the question it asks has a known low-dimensional answer (volatility
//--- clustering), and era time here is taken from a classifier already at ~300 s/era.
#define EXCURSION_HIDDEN_UNITS   24
//--- Below this many held-out bars the Brier skill score is noise and no verdict is printed.
#define EXCURSION_MIN_SCORED     500
//--- Skill (percent) the head must beat before Stage 2 is justified. Not zero: replacing a constant
//--- that cannot fail with a learned quantity that can needs to buy more than a rounding error, and a
//--- Brier skill under a couple of percent is inside the era-to-era wobble of the estimate itself.
#define EXCURSION_SKILL_USEFUL_PCT 2.0
//--- Minimum DISJOINT (non-overlapping-horizon) observations before that tally is allowed to decide
//--- anything. ~16k scored bars over a 64-bar horizon leaves ~250 independent ones, which is the real
//--- sample size; below this the disjoint skill is noise quoted to one decimal place.
#define EXCURSION_MIN_DISJOINT   200
//--- Share of bars whose predicted survival curve is non-monotone. Above this the 8 sigmoids are not
//--- describing one distribution and ExcursionQuantile's first-crossing read is not well defined.
#define EXCURSION_MAX_MONO_VIOL_PCT 5.0
//--- TRAILING-CLIMATOLOGY window, in bars, over RESOLVED outcomes only. This is the real incumbent for
//--- "replace a global ATR multiple": a rolling rung frequency adapts to the volatility regime, which is
//--- exactly the thing the head claims to predict, and it needs no model at all. ~2000 H1 bars is about
//--- three months - long enough that the rate is not noise, short enough to track a regime. The head's
//--- margin over THIS, not over a frozen constant, is what would justify 760 inputs.
#define EXCURSION_TRAIL_WINDOW   2000
//--- Resolved bars the trailing window must hold before its estimate is allowed to score anything.
#define EXCURSION_TRAIL_MIN_N    500
//--- Train the head on one primary bar in this many. Excursion targets are strongly autocorrelated -
//--- neighbouring bars share almost all of their horizon - so consecutive samples are near-duplicates,
//--- and the cost of this net is per-dispatch rather than per-FLOP on every backend.
#define EXCURSION_TRAIN_STRIDE   4
#define FIRST_LAYER_MIN_WIDTH    16
//--- Where the dense taper ENDS. The last hidden layer wants to be small enough to force the network to
//--- commit to a compressed representation, but comfortably wider than the decision itself so it is not
//--- the bottleneck - a few units per class is the usual heuristic. The absolute floor covers the
//--- single-output regression head, where 4x1 would be absurdly narrow.
//--- Conv receptive field, in BARS. The reference (references\MQL5\Experts\EDL\Trajectory.mqh) uses a
//--- window of 2 positions with step 1, stacked twice for an effective field of 3; a value of 2 here
//--- matches it at our bar granularity. Not an input: it is a structural property of the front-end, and
//--- a user who picks it is choosing against the pool and second-conv shapes derived around it.
//---
//--- RE-LANDED 2026-07-31 at 3, WITHOUT the channel pool that came with it the first time.
//--- Why the 34d6aa4 attempt failed, established by reading the reference kernels rather than guessing:
//--- CNeuronConvOCL emits POSITION-MAJOR output - `matrix_o[out + window_out * i]`, i.e.
//--- [pos0 f0..fN][pos1 f0..fN]... (References\MQL5\Experts\NeuroNet_DNG\NeuroNet.cl, FeedForwardConv).
//--- The reference pool (FeedForwardProof) is a flat contiguous max over `window` elements at stride
//--- `step`. On position-major data ANY window <= window_out therefore maxes ACROSS FILTERS INSIDE ONE
//--- POSITION - it cannot pool over time at all. The stage we built used window = step = filterCount,
//--- which is exactly one max over all 8 filters per position: 87.5% of the conv's output discarded, and
//--- only the argmax filter receiving gradient at each position. That is the measured regression (era 5:
//--- 18% dir-precision and 45 live fires at RF=1, versus "no directional calls" and 0 fires at RF=2).
//--- It is a property of the reference's own layout, not a porting mistake, so there is no "correct pool"
//--- to swap in here: pooling over time is not expressible on this layout without a transpose.
//--- The literature answer, already cited elsewhere in this file, is Springenberg et al. ICLR 2015
//--- ("Striving for Simplicity: The All Convolutional Net"): drop pooling, get the hierarchy from strided
//--- convolution instead. So this stage is now a single TRUE convolution - a CONV_RECEPTIVE_FIELD_BARS-bar
//--- window sliding one bar at a time - and nothing else. 3 bars is the smallest window that can express
//--- a turning point (before/at/after), which is what the ZigZag labels mark.
//--- Verify a change here against CNet::LayerLearningReport's per-era norm(d|W|%/|dW|%) line, not against
//--- accuracy: |dW| >> d|W| means the layer is rotating (learning), the two roughly equal with the norm
//--- falling means it is only being decayed away. Reading accuracy is what made the first regression take
//--- a full retrain cycle to spot.
#define CONV_RECEPTIVE_FIELD_BARS 3
//--- Master switch for the sequence-LSTM front-end (AI\Network.mqh CNeuronLSTMOCL).
//--- 1 = the layer is a real recurrence over bars: one shared gate block applied at every timestep,
//---     with backpropagation-through-time. Gradient-checked to 2.3e-10 (DirectML\lstm_seq_gradcheck.cpp)
//---     and signal/gradient-reach-checked (DirectML\lstm_seq_flowcheck.cpp).
//--- 0 = the pre-2026-07-30 layer: ONE gate step over the whole flattened input, no recurrence.
//---
//--- RE-LANDED 2026-07-31, together with a corrected LSTM_FORGET_BIAS_INIT - see that constant, which is
//--- the part that was actually wrong.
//--- The 2026-07-30 attempt reported "flat IS error + Neutral:100%", which reads as "no gradient" but is
//--- equally the signature of an output that does not VARY with the input. The forward path rules the
//--- first out: CPU_LSTMSeqForward starts every sample at h_0 = c_0 = 0 (t==0 takes the nullptr branch),
//--- unrolls T = m_historyBars steps over that sample's own window, and emits h_T. State does not leak
//--- between shuffled samples, so shuffling is not the problem either. What DOES depend on the constant
//--- is saturation: with forget bias b the cell tends to c ~ i*g/(1-sigmoid(b)) over T steps, so b = 2.0
//--- gives c ~ 8*i*g, tanh(c) pins to +/-1, and h_T = o*tanh(c) becomes near-binary and set by the gate
//--- biases rather than by the bars. That is exactly "input-independent output".
//--- The tell in the era line is "OOS raw out B:min..max": a collapsed span there is this failure, not a
//--- gradient failure. Check it and the norm(d|W|%/|dW|%) line together before concluding anything.
#define LSTM_SEQUENCE_MODE 1
#define HIDDEN_TAPER_OUTPUT_MULTIPLE 4
//--- REVERTED to 8 (2026-08-16, same day it was raised to 20). The 20 came from the MQL5 "4 hidden
//--- layers" article, whose floor is load-bearing on ITS first-layer width of 1000: 1000 -> 300 -> 90
//--- -> 27 needs a floor to stop, and 20 is where it stops. This codebase MEASURES the first layer
//--- instead, and on the live SP500 H4 config that measurement is 16 units (32 with a front end) -
//--- already floored, with the capacity budget printing "11360 estimated in-sample bars cannot support
//--- a 800-wide input ... roughly 1.1 weights per training bar - expect overfitting". At 16 units a
//--- floor of 20 makes lastHidden >= m_initialNeuronsCount, so ComputeHiddenLayerCount returns on its
//--- first branch and THE WIDTH TAPER NEVER RUNS - the one part of the derivation that is actually
//--- measured from this symbol's data became dead code on all four ensemble members. See also the
//--- pre-existing note in ComputeLayerWidths, which had already rejected this exact pair of constants.
#define HIDDEN_TAPER_MIN_WIDTH       8
//--- ComputeConvFilterCount()/ComputeLstmHiddenSize() bounds. Both stages used to be inputs with a
//--- hand-picked constant default (16 filters, 32 hidden units) chosen with no reference to how wide the
//--- input actually ended up or how much data there is to fit them - the same defect the first-layer
//--- width had before it was derived. CONV_COMPRESSION_DIVISOR is the ratio the conv stage should
//--- compress a bar's feature vector by: the layer is a per-bar projection (window = step = one bar's
//--- features, see AddConvStage), so filters > features EXPANDS a correlated input at the very bottom of
//--- the stack, which is over-parameterization in its purest form. Halving is the conventional bottleneck
//--- choice and holds at any feature count.
//--- ComputeHiddenLayerCount() bounds. HIDDEN_TAPER_TARGET_RATIO is the per-layer compression the taper
//--- aims for, and depth is however many such steps it takes to get from the derived first-layer width
//--- to the output-tied final width. Two layers is the floor because one dense layer plus the head is a
//--- linear model with a single non-linearity; five is the ceiling because beyond it the per-step
//--- compression is so mild that the extra depth adds vanishing-gradient risk without adding abstraction.
//--- REVERTED to 2.0 (2026-08-16, same day it was changed to 10/3 - the MQL5 article's Pareto 70% cut).
//--- Halving is the conventional funnel and, unlike 10/3, it still produces a taper at the widths this
//--- codebase actually derives. See HIDDEN_TAPER_MIN_WIDTH above for the measurement that decided it.
#define HIDDEN_TAPER_TARGET_RATIO 2.0
#define MIN_HIDDEN_LAYERS         2
#define MAX_HIDDEN_LAYERS         5
//--- EstimatedInSampleBars() fallback for a chart whose history has not finished downloading. Below the
//--- trusted-bar floor the measurement says more about the sync state than about the symbol.
#define TOPOLOGY_BUDGET_MIN_TRUSTED_BARS 500
#define TOPOLOGY_BUDGET_FALLBACK_YEARS   10
#define CONV_COMPRESSION_DIVISOR 2
#define CONV_FILTERS_MIN         4
#define CONV_FILTERS_MAX         32
#define LSTM_HIDDEN_MIN          8
#define LSTM_HIDDEN_MAX          128
#define BALANCED_COLLAPSE_PCT    (100.0 / 3.0)
//--- How far above that floor a best-so-far checkpoint must sit before the regression handler is
//--- allowed to defend it during the pre-recall-pass phase. See the guard's comment in Train(): the
//--- point is to distinguish "the best we have is still basically a collapse, keep exploring freely"
//--- from "we found a real multi-class state and are now sliding off it", which is the case that ran
//--- unchecked for 228 eras on SP500 H1 (2026-07-29).
#define BALANCED_WORTH_DEFENDING_MARGIN_PCT 5.0
//--- PLATEAU LADDER ------------------------------------------------------------------------------
//--- The two branches above only fire on a NEW BEST (isBetterEra) or on a real REGRESSION
//--- (isWorseEra, a drop of more than ETA_DECAY_REGRESSION_PCT below the best). Between them sits a
//--- dead zone - "not better, not meaningfully worse" - where NOTHING happened: no checkpoint, no
//--- restore, no eta change. A run that settles into that band is stuck, and before this ladder
//--- existed it stayed stuck until the era cap (observed 2026-07-25: balanced accuracy pinned in a
//--- 64-69% band for 15 consecutive eras while eta sat frozen and the softmax outputs slowly
//--- compressed toward uniform, with ~970 eras still to burn before the cap would end it).
//---
//--- So: count eras since the last NEW BEST, and escalate when that count says the run has stopped
//--- improving on its own. Two ideas from the literature, in this order:
//---   1. WARM RESTART (Loshchilov & Hutter, SGDR, ICLR 2017). On a plateau the correct move is a
//---      BIGGER step, not a smaller one - decaying eta into a plateau just entrenches whatever basin
//---      the model is sitting in. Note this is the opposite of the isWorseEra branch's decay, and
//---      deliberately so: decay answers overshoot, restart answers stagnation.
//---   2. GAMMA ANNEALING (Mukhoti et al., "Calibrating Deep Neural Networks using Focal Loss",
//---      NeurIPS 2020, which schedules gamma DOWN over training rather than fixing it). Focal loss's
//---      (1-pt)^gamma modulator goes to ~0 on everything the model already classifies well, so late
//---      in a run the surviving gradient comes almost entirely from genuinely ambiguous bars - and
//---      near a pivot, ZigZag labels ARE ambiguous. Meanwhile WEIGHT_DECAY keeps pulling every
//---      weight toward zero on every step regardless (see AI\Network.mqh's note that a weight's
//---      sustainable magnitude is ~ its gradient SNR / WEIGHT_DECAY). Annealing gamma hands the
//---      easy-but-correct bars their gradient back, restoring the signal side of that ratio.
//--- Annealing is MONOTONE (gamma only ever decreases within a run), matching the scheduled-gamma
//--- literature; eta may still be bumped back up by the existing recovery bump.
//---
//--- Escalation is per-stage, every PLATEAU_PATIENCE_ERAS eras without a new best. ANY new best
//--- resets the counter and the stage to 0 (the ladder is a response to stagnation, so evidence the
//--- run is moving again retires it) - except the annealed gamma, which stays where it got to.
#define PLATEAU_PATIENCE_ERAS    8     // eras with no new best balanced accuracy before escalating a stage
#define PLATEAU_STAGE_RESTART    1     // first boosted warm restart (see PLATEAU_RESTART_BOOST)
#define PLATEAU_STAGE_ANNEAL     2     // second boosted warm restart (the gamma anneal it named is gone)
#define PLATEAU_STAGE_DEPLOY     3     // exhausted: deploy the best checkpoint and finish the run
//--- Restart amplitude. Restoring eta merely TO its ceiling was a NO-OP whenever the run plateaued
//--- without ever tripping the regression decay - eta was still AT the ceiling, so stages 1 and 2
//--- assigned the value eta already had and the "ladder" was just a 24-era countdown to deploy
//--- (2026-08-09 audit, F2). Escaping a basin needs a rate LARGER than the one that settled into it:
//--- SGDR restarts span 10-100x; this is deliberately tamer because MAX_WEIGHT_DELTA and the
//--- best-checkpoint restore already bound the blast radius, and 5x the 3e-4 ceiling lands on 1.5e-3 -
//--- inside the ordinary Adam range (Kingma & Ba's own default is 1e-3). The boost is BOUNDED: the
//--- era-end anneal in Train() walks eta geometrically back to the ceiling over PLATEAU_PATIENCE_ERAS
//--- eras (a one-cycle kick, not a new permanent rate), and each restart also resets the optimizer's
//--- moment state (CNet::ResetOptimizerState) so the kick explores rather than replaying the stale
//--- momentum of the plateau it is escaping.
#define PLATEAU_RESTART_BOOST    5.0
//--- IN-SAMPLE EARLY STOP (see the block in Train()). Relative improvement required for the training
//--- error to count as progress, and how much more patient this stop is than the OOS ladder. Training
//--- error is noisy per era - mini-batch order alone moves it - and ending a run that is still learning
//--- costs far more than a few wasted eras, so it waits several times as long before acting.
#define IS_ERROR_IMPROVE_FRAC    0.01
#define IS_ERROR_PATIENCE_MULT   3
//--- PLATEAU_GAMMA_STEP removed 2026-07-31 with focal loss - the ladder escape is the warm restart.
//--- FILE-COMPATIBILITY SHIM for the removed "Min OOS accuracy % (converge)" input (was MinWR, default
//--- PCT_80). Convergence is decided by the plateau ladder now, so the value has no behavioural effect
//--- anywhere - but it still occupies a slot in TWO persisted identities that must not shift:
//---   1. the topology .cfg layout (SaveTopologyConfiguration/LoadAndCompareTopologyConfiguration), and
//---   2. the weights-FILENAME fingerprint (BuildConfigFingerprint) - change the hash and every existing
//---      model silently becomes unreachable and retrains from era 0.
//--- So keep writing/hashing the old default, and stop COMPARING the .cfg field (see that function) so a
//--- model saved under ANY previous MinWR still loads. Models trained with the shipped default 80 keep
//--- their exact filename and resume normally; one trained under a non-default MinWR gets a new filename
//--- and retrains once, which is unavoidable when a fingerprint field stops being a variable.
#define LEGACY_CONVERGE_WR_SLOT  80
//--- Same treatment for the retired StudyPeriods input (removed 2026-07-30 - training now covers all
//--- available history). Its .cfg slot is positional and cannot be deleted without invalidating every
//--- deployed file, so a constant goes in and the field is no longer compared on load.
#define LEGACY_STUDY_PERIOD_SLOT 0
//--- LEGACY SLOT (was m_historyBars, DERIVED since 2026-08-11 - see DeriveHistoryBars). The literal
//--- is the shipped ind_Periods default, so every model trained at it keeps its filename; the real
//--- window lives in the .cfg (adopt-don't-compare, like every other derived shape field). A user
//--- who ran a non-default ind_Periods re-keys once, correctly - their old window is gone.
#define LEGACY_HISTORY_BARS_SLOT 20
//--- Derived-window rule: median confirmed swing leg, snapped DOWN to the ladder, capped. The floor
//--- is the ADZigZag Depth the feature comment always required; the cap is a wall-clock judgment -
//--- era time scales ~linearly with the window on every topology, and with the lag profile at the
//--- noise floor there is no evidence to buy more than ~1.6x today's cost on. Fallback = the old
//--- default, used when history is too thin to trust the measurement (same contract and warning as
//--- TOPOLOGY_BUDGET_MIN_TRUSTED_BARS - a window pinned from a handful of bars lasts a model's life).
#define HISTORY_BARS_FALLBACK    20
#define HISTORY_BARS_FLOOR       12
#define WINDOW_DERIVE_SPAN_BARS  20000
#define WINDOW_DERIVE_MIN_LEGS   30
#define WINDOW_SWING_WING        12
//--- Minimum true OOS samples a class needs this era before its recall is trusted as a real pass -
//--- see directionalRecallOK's declaration comment for the era-44-46 false-convergence this prevents.
//--- 10 is a low bar (still lets a genuinely thin early-run OOS window fall back to "not blocking"
//--- via recallPct==-1), just enough to rule out the zero/near-zero-sample degenerate case.
#define MIN_OOS_CLASS_SAMPLES_FOR_GATE 10
//--- A class this rare cannot be asked to carry the per-class recall floor. Applied to NEUTRAL ONLY -
//--- see the gate itself for why the directional classes are deliberately NOT exempted by prevalence.
//--- First-touch resolution (ce52654) collapsed Neutral from the ~94% majority it was under exact-pivot
//--- labels to a same-bar-tie residue: 250 of 38,261 bars, 0.65%. Demanding >=40% recall on that asks
//--- the model to spend capacity identifying coin-flip ties, and it is unreachable - measured
//--- 2026-08-10, CONV/LSTM/HYBRID all reported "Neutral:0% (need >=40% each)" every era, so no model
//--- could ever satisfy m_objectiveMet and every run was structurally unable to converge.
#define MIN_GATE_CLASS_SHARE_PCT 5.0
//--- Consecutive regressing eras before the checkpoint is restored and eta decayed. Was effectively 1:
//--- every regression rolled the weights back to the same checkpoint, reset the optimizer AND shrank
//--- eta, so the next era restarted from an identical state with a smaller step and regressed again -
//--- a geometric collapse with no exploration between rungs. Measured 2026-08-10 on PAI: eras 2-11 all
//--- regressed against era 1's best, eta fell 0.000594 -> 0.000024, and dW/W read 0.000%/0.000% from
//--- era 2 onward - ten eras that reproduced era 1 exactly and could not have done anything else.
//--- Patience is the standard ReduceLROnPlateau formulation and restores the exploration the rollback
//--- was removing: regress a few eras from the restored point BEFORE concluding the step is too big.
#define ETA_DECAY_PATIENCE_ERAS 3
//--- Bound on FindConfirmedZigZagPivot()'s backward scan (m_useSwingContext feature block) - ADZigZag's
//--- own stock defaults (Depth=12) produce pivots frequently enough in normal conditions that this cap
//--- should rarely bind, but a long, unusually strong single-direction run could genuinely go this long
//--- without a confirmed opposite-type pivot. Generous rather than tight: the scan is cheap (plain array
//--- reads, no indicator recompute) and its result is cached per-bar by BufferTempData()'s feature cache,
//--- so the one-time cost of a long scan is paid at most once per unique bar, not per training pass.
#define SWING_SCAN_CAP_BARS 750
//--- EMA shadow-weight deployment blend rate - see m_shadowNet's declaration comment for the full
//--- rationale. 0.01 matches the Tau range (0.001-0.01) used for target-network soft updates in
//--- Dmitriy Gizlyk's reference NeuroNet_DNG-based RL algorithms (references\MQL5\Experts\*\Study.mq5) -
//--- small enough that no single era's raw weights can move the deployed model far, large enough that
//--- the shadow still tracks real, sustained learning within a few dozen eras rather than lagging
//--- forever.
#define SHADOW_WEIGHT_TAU        0.01
//--- MINI-BATCH SIZE (2026-08-09 audit, F4). Number of samples whose gradients are summed before ONE
//--- optimizer step is taken. 1 restores the exact per-sample behaviour this engine had until now.
//---
//--- Why it existed as a problem: training was pure online SGD - one weight update per bar - so the
//--- gradient driving each update was a single noisy sample and the end-of-era weight state was a
//--- high-variance draw. That is the mechanical source of the era-to-era whipsaw the plateau ladder,
//--- the checkpoint restore and the shadow EMA were all built to cope with downstream. Update noise
//--- falls as ~1/sqrt(B), so 32 cuts it by ~5.7x while taking 32x fewer (much better-estimated) steps.
//---
//--- REVISED 2026-08-09 (32 -> 8) after the first run at 32 regressed every topology. Two lessons,
//--- both measured, both now handled here rather than left implicit:
//---
//---  1. An era is one PASS OVER THE DATA, and everything downstream that counts progress - the
//---     plateau ladder's patience, the selection metric, the eta anneal - is denominated in eras.
//---     Raising B does not change how much data an era sees; it divides how many optimizer STEPS
//---     that era takes. At 32 the perceptron declared convergence at era 41 on ~49k updates, where
//---     the same config had still been finding new bests at era 1028. The ladder had not become
//---     wrong, it had become 32x more impatient in the only unit it can measure.
//---  2. Fewer steps must be paid for with a larger step. For SGD the compensation is linear in B
//---     (Goyal et al. 2017); for ADAPTIVE methods it is sqrt(B) - Krizhevsky 2014, derived for Adam
//---     specifically in Granziol et al. 2022. TrainBatchLrScale() below applies it.
//---
//--- 8 rather than 32 because the two costs compound: after the sqrt(B) LR bump an era still makes
//--- sqrt(B) less progress than the per-sample path, so PLATEAU_PATIENCE_ERAS has to stretch by the
//--- same sqrt(B) to stay equivalent (see TrainPlateauPatienceEras). At 32 that is 8 -> 45 eras per
//--- stage on a topology already taking 70 s/era; at 8 it is 8 -> 23, which is affordable. Noise
//--- still falls as 1/sqrt(B), so 8 keeps ~2.8x of the variance reduction that was the point.
//---
//--- 1 restores the exact per-sample behaviour this engine had until now: no accumulation, no LR
//--- scaling, no patience stretch (every helper below is an identity at B=1).
//---
//--- Compile-time, not an input: it changes training dynamics but not the trained model's SHAPE, so it
//--- has no business in the weights fingerprint, and a user who picks a batch size is tuning something
//--- they cannot measure from the panel. Not every tier can honour it - see CNet::BatchSize.
#define TRAIN_BATCH_SIZE         8
//--- Floor for Train()'s indicator-depth clamp. Above it, a short-but-real history beats livelocking on a
//--- depth the terminal will never serve; below it, a positive-but-tiny BarsCalculated() is far more
//--- likely an indicator part-way through its first calculation than a hard cap, so the clamp stands
//--- down and leaves the case to m_coldSweepTick's backoff. Sized so a clamped era still holds an OOS
//--- window worth measuring rather than a few hundred bars of noise.
#define TRAIN_MIN_CLAMPED_BARS   2000
//--- SettledBars()'s wait. Probe spacing is a compromise: long enough that a busy terminal makes visible
//--- progress between reads (so growth is not mistaken for steadiness), short enough that a chart with
//--- nothing to wait for loses only seconds. Three steady probes ~= 9s of no movement before the depth is
//--- believed, which is cheap next to the 40-minute stalls it replaces.
#define DEPTH_SETTLE_PROBE_MS       3000
#define DEPTH_SETTLE_STABLE_PROBES  3
//--- Hard stop on the wait. A depth that has not settled in 10 minutes is not going to, and training on
//--- the history that IS there beats waiting forever - the give-up is logged as such so a settled depth
//--- is never confused with an abandoned one.
#define DEPTH_SETTLE_TIMEOUT_MS     600000
//--- ERA-BARRIER LIVENESS. How long a member may sit on the same era before the barrier stops treating
//--- it as a member the others must wait for. EnsembleMinTrainingEra()'s exemption list covered only
//--- VOLUNTARY non-participation (deployed / stopped / paused) and its comment claimed "nothing
//--- deadlocks" on that basis - but a member that simply CANNOT finish an era is none of those three,
//--- so it pinned the minimum at its own era forever and every healthy member on the chart waited on it
//--- indefinitely. Observed 2026-08-17: USDJPY and XAUUSD, LSTM and ConvLSTM stuck at era 0 producing
//--- zero usable windows, with Perceptron and Convolutional frozen behind them for 38 minutes and
//--- SILENT while they waited (the hold reset the stall watchdog's clock, so the two members that could
//--- have reported the outage were the two the outage muted).
//--- 12 min: comfortably past the slowest healthy era on the deepest chart, so a slow member is never
//--- mistaken for a dead one.
#define ENSEMBLE_BARRIER_STUCK_MS   720000
//--- How often a member held at the barrier says so in the journal. The panel line is written every
//--- call; this is the durable record, and without it a frozen chart leaves no trace at all.
#define ENSEMBLE_BARRIER_REPORT_MS  120000
//--- Minimum gap between attempts to rebuild a dead indicator handle (see RepairDeadIndicatorHandles).
//--- Long enough that a terminal which is genuinely refusing to create the indicator is not hammered,
//--- short enough that a member recovers within one stall-report interval rather than one era.
#define HANDLE_REPAIR_COOLDOWN_MS   30000
//--- sqrt(B) learning-rate compensation and the matching patience stretch. Both are exactly 1.0 at
//--- B=1, so the whole mini-batch apparatus vanishes when TRAIN_BATCH_SIZE is 1.
//---
//--- Note this is only sound because the Adam second moment was fixed on 2026-08-09 (see
//--- AI\Network.cl's UpdateWeightsAdam): the previous recursion pinned its denominator at ~b2 for any
//--- gradient below unit scale, which made the step size proportional to |g| instead of invariant to
//--- it. Under THAT optimizer, shrinking the gradient by averaging cost a further sqrt(B) on top of
//--- the B fewer steps, and no learning-rate rule stated in terms of B could have compensated.
double TrainBatchLrScale(void)        {  return MathSqrt((double)TRAIN_BATCH_SIZE);  }
int    TrainPlateauPatienceEras(void) {  return (int)MathRound(PLATEAU_PATIENCE_ERAS * MathSqrt((double)TRAIN_BATCH_SIZE));  }
//--- Online continual-learning tunables (see OnlineLearnStep()). Live-chart-only: once a model is
//--- deployed (m_trainingComplete) it keeps adapting to newly-RESOLVED bars as their barrier outcome
//--- becomes known - the same supervised triple-barrier task it was trained on, never trade P&L
//--- (that would be RL).
//--- ONLINE_LEARN_MAX_CATCHUP caps how many newly-confirmed bars one step may backprop, so a weekend
//--- gap or a restart can't stall a tick with an unbounded catch-up loop (excess is picked up over the
//--- next few bars). ONLINE_ACC_SMOOTH is the guardrail EMA horizon (bars) for the rolling predict-
//--- before-learn accuracy - far shorter than CNet::recentAverageSmoothingFactor (10000) so the
//--- guardrail actually reacts within a realistic live sample count. The deployed shadow is only blended
//--- toward Net while that rolling accuracy holds at/above max(ONLINE_LEARN_MIN_ACC, deploy_baseline -
//--- ONLINE_LEARN_ACC_MARGIN); if it drops, Net keeps adapting (so it can recover) but the blend is
//--- FROZEN so drift can never reach live - the conservative "reject the deployment of a bad update"
//--- guardrail (no weight-snapshot/revert needed). Persist every ONLINE_LEARN_PERSIST_EVERY updates so
//--- a crash loses at most that many bars of adaptation.
//---
//--- CLASS IMBALANCE. This path streams the RAW live class distribution one bar at a time, so calling
//--- backProp() at the default sampleWeight of 1.0 makes it a majority-class drift vector by
//--- construction - it would pull a balanced, converged model back toward Neutral. The streaming-safe
//--- correction is COST-level: alpha-balanced focal loss (Lin et al. 2017, "Focal Loss for Dense Object
//--- Detection", eq. 5), weight = alpha_c * (1 - p_t)^gamma, a SINGLE loss designed for exactly this
//--- ratio. alpha_c is inverse class frequency from the persisted priors (m_priorBuy/Sell/Neutral),
//--- majority normalised to 1.0, scaled by ONLINE_LEARN_PARITY and capped; gamma is
//--- ONLINE_LEARN_FOCAL_GAMMA. ONLINE_LEARN_MAX_CLASS_WEIGHT is the uncapped ceiling,
//--- ONLINE_LEARN_ALPHA_CAP the tighter one actually applied.
//--- The two engines deliberately use DIFFERENT corrections. Train() corrects analytically in the
//--- gradient via the logit-adjusted loss, which is NOT available here: ApplyLogitAdjustment() only
//--- runs inside a training run, so a deployed-then-reloaded model carries no offsets and would
//--- otherwise stream skewed data in with no correction at all. These were shared inputs until
//--- 2026-07-31 and are now constants at those inputs' shipped defaults - behaviour is unchanged.
//--- ONLINE_LEARN_ETA_SCALE: this path previously inherited whatever value the GLOBAL `eta` happened to
//--- be left at by the last Train() chunk of ANY model instance (PAI/CONV/LSTM/HYBRID share it), which
//--- is arbitrary. eta is now pinned to this model's own converged rate scaled down for the duration of
//--- the loop, then restored, so a live adaptation step is deliberately gentler than a training step.
#define ONLINE_LEARN_MAX_CATCHUP   64
#define ONLINE_ACC_SMOOTH          50.0
#define ONLINE_LEARN_WARMUP        20
#define ONLINE_LEARN_MIN_ACC       40.0
#define ONLINE_LEARN_ACC_MARGIN    10.0
#define ONLINE_LEARN_PERSIST_EVERY 32
#define ONLINE_LEARN_MAX_CLASS_WEIGHT 5.0
//--- Pinned to the shipped defaults of the removed OversampleParity (90%), ConstrainReplay (true ->
//--- cap 3.0) and FocalLossGamma (1.0) inputs - see the CLASS IMBALANCE note above.
#define ONLINE_LEARN_PARITY        0.9
#define ONLINE_LEARN_ALPHA_CAP     3.0
#define ONLINE_LEARN_FOCAL_GAMMA   1.0
#define ONLINE_LEARN_ETA_SCALE     0.25
//--- Free function, not a class method: needed by CExpertSignalAIBase's constructor init list for
//--- both m_modelEta and m_etaCeiling (see their declaration comments), which runs before member-init
//--- order could safely make one depend on another - this only touches the TrainingOptimizer input
//--- (Variables\Inputs.mqh) and the SgdLearningRate/AdamLearningRate inputs (AI\Network.mqh's `lr`
//--- macro resolves to AdamLearningRate), never class members.
//--- The sqrt(B) mini-batch compensation is applied HERE, at the one point that decides the base rate,
//--- so it reaches m_etaCeiling, m_modelEta, the plateau ladder's boost and its anneal from a single
//--- edit rather than being re-derived at each of them. Identity at TRAIN_BATCH_SIZE 1.
double InitialEtaForOptimizer(void)
  {
   return ((TrainingOptimizer == SGD) ? SgdLearningRate : lr) * TrainBatchLrScale();
  }
//+------------------------------------------------------------------+
//| Uniform random index in [0, n) for Fisher-Yates shuffles.         |
//| MQL5's MathRand() is 15-bit (0..32767). `MathRand() % n` with     |
//| n > 32768 makes the modulo the IDENTITY on the generator's range: |
//| a swap target above 32767 can never be drawn, so any shuffle over |
//| more elements than that - every full-history H1 training queue -  |
//| was provably non-uniform, partially re-admitting the correlated   |
//| same-class gradient runs the shuffle exists to break (2026-08-09  |
//| audit, F1; see AI\Network.mqh's MAX_WEIGHT_DELTA comment for why  |
//| those runs matter). Two draws give 30 uniform bits; the residual  |
//| modulo bias at n ~ 1e5 against 2^30 is ~1e-4 - negligible here.   |
//+------------------------------------------------------------------+
int ShuffleRandomIndex(const int n)
  {
   if(n <= 1)
      return 0;
   int r30 = ((MathRand() & 0x7FFF) << 15) | (MathRand() & 0x7FFF);
   return r30 % n;
  }
class CExpertSignalAIBase : public CExpertSignalCustom
  {
protected:
   string              ID;
   //--- ID with the bracketed config tag stripped - "Hybrid 3L [HYB-9369]" -> "Hybrid 3L". The tag is a
   //--- topology prefix plus a fingerprint hash: it exists to tell one CHART's model files from another's
   //--- when reading the journal or the State\ folders, which is a developer's problem, not an owner's.
   //--- Logs and the VerboseMode panels keep the full ID; the plain-language panels use this. Strips from
   //--- the LAST " [" so a model name containing a bracket could not truncate the whole label.
   string              DisplayName(void) const
     {
      int cut = StringFind(ID, " [");
      int next = cut;
      while(next >= 0)
        {
         cut = next;
         next = StringFind(ID, " [", cut + 1);
        }
      return (cut >= 0 ? StringSubstr(ID, 0, cut) : ID);
     }
   //--- Per-MEMBER arrow namespace: "WarSig_PAI_", "WarSig_CONV_", ... All four ensemble
   //--- members used to share the bare SIG_ARROW_PREFIX + bar-time name, which meant (a) the
   //--- chart showed whichever member rendered LAST, not four opinions; (b) one member's
   //--- Neutral deleted another member's arrow at the same bar; and (c) SaveChartSignals -
   //--- which rebuilds the sidecar by SCANNING the chart - persisted every OTHER member's
   //--- arrows into its own history, the exact cross-model laundering its header warns
   //--- about. Global purges still work: they match on the bare "WarSig_" prefix, which
   //--- prefixes all member namespaces (and any old-format leftovers from earlier builds).
   string              ArrowPrefix(void) const { return SIG_ARROW_PREFIX + m_id + "_"; }
   //--- Yes: every subclass of this one is a neural net. Tells the aggregate's raw-arrow layer that
   //--- this filter draws its OWN arrows (from its cached per-bar scans, which span the whole chart)
   //--- and must not be drawn a second time from the once-per-bar live path. See
   //--- CExpertSignalCustom::IsAIFilter for why this is a virtual and not an id comparison.
   virtual bool        IsAIFilter(void) const override { return true; }
   CiOpen              m_Open;
   CiClose             m_Close;
   CiHigh              m_High;
   CiLow               m_Low;
   CiVolumes           m_Volumes;
   CiTime              m_Time;
   //--- optional classic-indicator input features (m_useMA/m_useRSI/m_useMACD/m_useIchimoku below) -
   //--- independent instances from the ones Signals\SignalMA.mqh/SignalRSI.mqh/SignalMACD.mqh/
   //--- SignalIchimoku.mqh use for trade voting, since this class and those CSignal* classes are
   //--- unrelated hierarchies (feature engineering vs. signal vote). The MA
   //--- feature now uses the SAME unified indicator as the classic vote (CustomIndicators\ADMovingAverage.mq5)
   //--- via CiCustom, so its type/period are tunable (see ADIndicatorTuner maType/maPeriod).
   CiCustom            m_MA;
   CiRSI               m_RSI;
   //--- built-in Ci* wrappers, not CiCustom: MACD is defined on plain EMAs and Ichimoku on plain
   //--- highest/lowest midpoints, so there is no unified AD* custom indicator to route them through the
   //--- way m_MA goes through ADMovingAverage. Periods come from the tuner (macdFast/macdSlow/
   //--- macdSignal, ichiTenkan/ichiKijun/ichiSenkou).
   CiMACD              m_MACDFeature;
   CiIchimoku          m_Ichimoku;
   //--- custom price-action/volume indicators (CustomIndicators\*.mq5), loaded via iCustom/CiCustom
   CiCustom            m_ADCumulativeDelta;
   CiCustom            m_ADShorteningOfThrust;
   CiCustom            m_ADWyckoffEventStream;
   CiCustom            m_ADWyckoffFailedStructure;
   CiCustom            m_ADWyckoffSignificantBarInversion;
   //--- "is this AD indicator still calculating?" probe - see the definition in Features.mqh for
   //--- why cold must be a TRANSIENT rejection and not a zero-fill (2026-08-11)
   bool                ADIndicatorCold(CiCustom &ind, string block);
   //--- GetTickCount() stamp of the last pass-1 sweep in which EVERY window failed on a transient
   //--- cause (cold indicator). Non-zero arms a short era-start backoff so the retry loop stops
   //--- starving the very indicator threads it is waiting on - see Train()'s fresh-era block.
   uint                m_coldSweepTick;
   //--- Last depth ServableBars() had to clamp to because the tunable indicators could not serve what was
   //--- asked. Held only so the explanation prints when the cap CHANGES rather than once per era per call
   //--- site; it depends on BarsCalculated() alone, never on the requested depth, so it is comparable
   //--- across all of them. 0 = never clamped.
   int                 m_indicatorDepthCapBars;
   //--- One-shot latch for the "an enabled tunable indicator reports NO calculated bars" report in
   //--- ServableBars(). Distinct from the cap latch above because it is a different condition: the cap
   //--- means "serves less than asked" (recoverable, train on what there is), this means "serves
   //--- nothing at any index" (a dead handle - there is no depth to clamp to). Cleared as soon as a
   //--- real depth comes back so a second outage is reported rather than swallowed.
   bool                m_indicatorDepthDeadWarned;
   //--- Cooldown between attempts to rebuild a dead indicator handle (see RepairDeadIndicatorHandles).
   //--- Every ServableBars() consumer can reach the repair - the training sweep, live inference on
   //--- every tick, online learning - and a terminal genuinely refusing to create the indicator must
   //--- not be hammered.
   uint                m_handleRepairTick;
   //--- ERA-BARRIER LIVENESS STATE (see ENSEMBLE_BARRIER_STUCK_MS and BarrierEraHeartbeat()).
   //--- Seen/Tick are the era-advance watchdog; Excluded is the latch that takes a non-advancing member
   //--- out of the barrier minimum; HoldReportTick rate-limits the "I am waiting, and on whom" line that
   //--- a held member now writes to the journal - previously a held member wrote nothing anywhere, which
   //--- is why a two-chart outage on 2026-08-17 was visible only through the members that were NOT held.
   long                m_barrierEraSeen;
   uint                m_barrierEraTick;
   bool                m_barrierExcluded;
   uint                m_barrierHoldReportTick;
   //--- One-shot latch for the live-inference hold in RefreshConvergedSignal(), so a held chart says so
   //--- once instead of on every tick. Cleared the moment the depth is available again, so a second
   //--- outage is reported rather than swallowed.
   bool                m_inferenceDepthRefusalWarned;
   //--- One-shot latch for the label-prebuild block message. A prebuild that cannot prepare its buffers
   //--- retries on every scheduled call forever, so this says it once rather than at chart-refresh rate.
   bool                m_prebuildBlockWarned;
   //--- SettledBars() probe state. m_depthSettleStart doubles as the "a wait is in progress" flag (0 =
   //--- none), which is why it is cleared on every path that stops waiting.
   uint                m_depthSettleStart;
   uint                m_depthProbeTick;
   int                 m_depthProbeLast;
   int                 m_depthProbeStable;
   //--- ground truth for the training labels (see m_swingConfirmationBars' declaration comment) -
   //--- CustomIndicators\ADZigZag.mq5, a renamed/rebranded copy of the stock MQL5 ZigZag indicator,
   //--- always created (not gated behind an Enable* input like the AD* feature indicators above,
   //--- since it isn't an optional input feature - it IS the label) and always run at its own stock
   //--- defaults (Depth=12, Deviation=5, Backstep=3) - never touched by AutoTuneIndicators, since
   //--- tuning the ground truth itself alongside the model being scored against it would let a trial
   //--- "improve" its OOS score by cherry-picking an easier target rather than a better model.
   CiCustom            m_ADZigZag;
   //--- currently-active tunable input values for each AD indicator (AutoTuneIndicators search space)
   //--- plus their own flatten/unflatten/perturb/best-tracking logic - see CADIndicatorTuner's
   //--- declaration comment (Expert\ADIndicatorTuner.mqh) for why this is a separate collaborator
   //--- rather than loose fields/methods here: it's entirely self-contained (never touches Net,
   //--- Train()'s state machine, or anything else in this class), unlike TuneIndicatorsAndTrain()
   //--- below, which orchestrates Train()/Net/checkpointing around it and stays here for exactly that
   //--- reason. InpContextMode/InpSessionType/InpSessionCount are session choices, not accuracy
   //--- knobs, and are hardcoded to the indicators' own defaults in InitAD*() rather than stored/
   //--- tuned in the collaborator.
   CADIndicatorTuner   m_indicatorTuner;
   bool                m_autoTuneIndicators;
   //--- rebuilds only the AD* indicator handles (in place) so ReInit picks up updated param structs
   bool                ReInitADIndicators(CIndicators *indicators);
   //--- installs a loaded/saved param set into the tuner and rebuilds the handles ONLY when the set
   //--- actually differs from what the live indicators already run - see the definition for the
   //--- resume-time churn this exists to avoid.
   bool                AdoptIndicatorParams(const double &loaded[], CIndicators *indicators);
   //--- builds a fresh, untrained topology into Net (assumes Net is currently NULL); factored out of
   //--- InitNeuralNetwork() so TuneIndicatorsAndTrain() can rebuild weights per trial without
   //--- re-running indicator init (which would re-Add() the base indicators into indicators a 2nd time)
   bool                BuildFreshTopology();
   //--- CIndicators collection passed into InitNeuralNetwork(), retained so
   //--- TuneIndicatorsAndTrain() can call ReInitADIndicators() between trials
   CIndicators        *m_indicatorsPtr;
   CNet               *Net;
   //--- EMA "shadow" copy of Net, blended a small step (SHADOW_WEIGHT_TAU) toward Net's weights at
   //--- the end of every era (see Train()'s era-end block) rather than replaced outright. Live
   //--- trading/inference (RefreshLatestSignal()) reads from this, not from Net directly, so any
   //--- single era's raw weights - including an Adam overshoot event - can only ever nudge what's
   //--- actually deployed by SHADOW_WEIGHT_TAU, not overwrite it wholesale. Bootstrapped as a clone of
   //--- Net (via the same Save()/Load() pattern m_simOosNet uses) the first time InitNeuralNetwork()
   //--- runs with no prior shadow file, and persisted alongside Net.Save() thereafter. NULL only
   //--- during the brief window before that first bootstrap completes - every read site falls back to
   //--- Net in that case, never blocks on it.
   CNet               *m_shadowNet;
   //--- One-shot latch for EnsureShadowNet()'s clone bootstrap. Cloning a second full net can fail on the
   //--- tester's CPU-DLL compute fallback (the chart's GPU/DirectML path succeeds); without this the
   //--- bootstrap would retry on EVERY bar, re-initialising the compute backend each time - log spam and a
   //--- multi-second-per-bar crawl through an inference-only backtest. A failed/skipped bootstrap is
   //--- harmless: every read site falls back to Net, and a bootstrapped shadow is identical to Net until
   //--- era-end blending diverges it (which never happens in a no-training run). Reset with m_shadowNet.
   bool                m_shadowBootstrapAttempted;
   //--- Online continual-learning state (see OnlineLearnStep(); tunables at ONLINE_LEARN_* above). Live-
   //--- chart-only - a deployed (m_trainingComplete) model keeps learning from newly-confirmed ZigZag
   //--- structure as bars mature, waiting the full m_swingConfirmationBars confirmation delay just like
   //--- training so a still-provisional (repainting) recent bar is NEVER backpropped. m_enableOnlineLearning
   //--- is the input gate. m_onlineLearnedUpToTime is the bar-TIME watermark of the newest bar already
   //--- learned from (indexed by time, not now-relative index, so it survives the per-bar index-frame
   //--- shift); persisted in the .stats sidecar (WST3). m_onlineRollingAcc is the guardrail EMA (0-100)
   //--- of predict-before-learn hits (seeded from the deploy OOS baseline), m_onlineSamples the cumulative
   //--- update count (both persisted). m_onlineBarsSincePersist drives periodic saves (in-memory only).
   bool                m_enableOnlineLearning;
   datetime            m_onlineLearnedUpToTime;
   double              m_onlineRollingAcc;
   long                m_onlineSamples;
   int                 m_onlineBarsSincePersist;
   //--- Latched log state so the guardrail freeze/resume transition prints once per flip, not per bar.
   bool                m_onlineBlendFrozen;
   CArrayDouble       *TempData;
   double              dError;
   double              dUndefine;
   double              dForecast;
   double              dPrevSignal;
   //--- ALTERNATION GATE REMOVED 2026-08-01 with the triple-barrier relabel. m_lastNonNeutralSignal
   //--- suppressed any live Buy following another Buy with no Sell between. That was CORRECT under the
   //--- exact-pivot target (a ZigZag can only emit a new pivot by FLIPPING type, so a repeat was
   //--- provably a false fire) and the premise died with the target: a triple-barrier label is answered
   //--- independently at every bar, so ten consecutive Buy setups inside one trend are simply correct.
   //--- Do not reinstate it. It also meant a one-sided (`Sell:0%`) model got ONE trade per backtest,
   //--- because the awaited opposite signal that reopens the gate never came.
   //--- Inference-path census counters - see PrintInferenceTally() for why these exist. Cheap enough to
   //--- keep unconditionally: three increments per bar against a full feedForward.
   long                m_refreshOk;
   long                m_refreshFailFeatures;
   long                m_refreshFailShort;
   long                m_refreshBuy;
   long                m_refreshSell;
   long                m_refreshNeutral;
   //--- VOTE-GATE census. RefreshLatestSignal() can answer Buy on hundreds of bars while
   //--- LongCondition()/ShortCondition() still return 0 on every one, because those open with a
   //--- readiness gate the refresh path never consults:
   //---     if(!m_trainingComplete && !(m_inferenceOnly && m_modelLoadedFromDisk)) return 0;
   //--- In the tester that reduces to "the seeded _optcache.nnw must have LOADED"; when it has not, the
   //--- run silently produces direction 0.00 on every bar. Without these two the census reads as "the
   //--- model answers Neutral" - false, and it points at a completely different fix. They separate the
   //--- model's ANSWER from whether that answer was allowed to become a vote.
   long                m_voteGateBlocked;   // directional decisions the readiness gate discarded
   long                m_voteGatePassed;    // directional decisions that became a real vote
   //--- Flag pair as of the first vote attempt, latched so the tally can name WHICH half of the gate
   //--- failed rather than just reporting that it did. -1 = no vote was ever attempted.
   int                 m_voteGateCompleteAtFirst;
   int                 m_voteGateLoadedAtFirst;
   //--- m_gateSnapshot removed with the alternation gate above - it existed only to roll that gate back
   //--- when the parent discarded this filter's vote. The AI signal now holds no one-shot vote state, so
   //--- BeginVote()/RevokeVote() fall back to the base class's empty implementations.
   //--- Non-max suppression (NMS) of directional signals. Consecutive H4 bars near a real turn share
   //--- almost their entire feature vector, so a single reversal fires the same class on a whole run of
   //--- adjacent bars - a visual/emission cluster around one event, not several distinct turns.
   //--- DEFAULT OFF since 2026-08-01: suppressing repeats was justified by the exact-pivot target, and
   //--- under triple-barrier labels a run of same-direction setups is real signal, so collapsing it
   //--- DISCARDS trades rather than de-duplicating them. Kept opt-in for one marker per move.
   //--- Keeps only the FIRST (earliest) bar of a same-direction run, dropping same-direction neighbours
   //--- within m_signalClusterWindow bars; 0 disables. Per-direction, so a missed opposite signal never
   //--- blocks a later reversal (unlike the alternation gate), and causal, so the live signal and the
   //--- drawn history declutter identically. Post-processing ON TOP of the model - the raw per-bar
   //--- recall/precision/accuracy stats stay un-NMS'd so they keep measuring the network itself.
   //--- The cluster extends from the last SEEN same-direction bar, not the last KEPT one: measuring
   //--- from the kept bar re-emitted an arrow every window+1 bars inside a long run.
   int                 m_signalClusterWindow;
   //--- Per-bar predicted signed signal for THIS era (index = now-relative bar index; -2 = not scored
   //--- this era). When NMS is on, the scan passes (1/2/3) ONLY record into this cache and draw nothing;
   //--- PruneDirectionalClusters() then renders the whole declustered set once at era end. That is what
   //--- keeps the chart from ever showing the raw mid-era clusters (the passes would otherwise draw every
   //--- above-threshold bar as it scanned, and the sweep only cleaned up at era end). Recording (not
   //--- drawing) also decouples NMS from pass 2's SHUFFLED order, which no inline cursor could dedup.
   //--- Sized to bar count each fresh era.
   double              m_arrowSignalCache[];
   //--- Live-side NMS state: bar TIME of the last SEEN signal per direction (advances on every same-
   //--- direction bar, kept or suppressed, so a contiguous live run collapses to one) plus the cached
   //--- accept/suppress decision for that exact bar (keeps repeated same-bar RefreshLatestSignal calls
   //--- idempotent - re-evaluating the same bar returns its first decision, not a flipped one). 0 = none.
   datetime            m_nmsLiveBuyTime;
   datetime            m_nmsLiveSellTime;
   bool                m_nmsLiveBuyAccept;
   bool                m_nmsLiveSellAccept;
   //--- Last KEPT live signal of either direction, for cross-direction resolution: a Buy and a Sell
   //--- within m_signalClusterWindow bars are flicker at one turn zone (real opposite pivots are a whole
   //--- leg apart), so only the higher-confidence side is kept. Confidence = |signed signal| = winning
   //--- softmax probability. Same rule runs in PruneDirectionalClusters() for the historical chart.
   datetime            m_nmsLiveKeptTime;
   ENUM_SIGNAL         m_nmsLiveKeptDir;
   double              m_nmsLiveKeptConf;
   datetime            dtStudied;
   long                m_eraCount;      // cumulative era counter, persisted in the .nnw so restarts don't look like they reset progress
   bool                m_trainingComplete; // persisted: true only once Train() converged (objective+stability), not just interrupted
   bool                bEventStudy;
   //--- This instance's study-event id (STUDY_EVENT_ID_BASE + construction order) and the tick-count
   //--- when bEventStudy was last armed - see the STUDY_EVENT_ID_BASE comment for why these exist.
   //--- All arming goes through ArmStudyEvent() so the id and the watchdog stamp can never drift apart.
   ushort              m_studyEventId;
   uint                m_studyArmedTick;
   //--- out-of-sample holdout: share (%) of the study period never trained on, used only to
   //--- measure genuine forward accuracy so overfitting shows up in the stats, not just live/OOS trading
   int                 m_oosSplitPct;
   double              dOosError;      // smoothed OOS mismatch rate (0..100), lower is better
   double              dOosForecast;   // smoothed OOS accuracy (0..100)
   int                 m_oosSamples;   // count of OOS predictions evaluated this Train() call
   //--- per-era raw (pre-softmax) output-neuron stats over pass 3's OOS scan, reset at pass 3
   //--- start; surfaced in the era-end log line. The per-bar logit spread (max-min across the 3
   //--- outputs) is the collapse fingerprint: a healthy net differentiates bars (avg spread well
   //--- above 0), a saturated all-one-class net pins all three outputs to the same value on every
   //--- bar (avg spread ~0, mins/maxes flat) - see CLASS_LOGIT_SCALE's comment (AI\Network.mqh).
   double              m_oosOutMin[3];
   double              m_oosOutMax[3];
   double              m_oosOutSpreadSum;
   int                 m_oosOutCount;
   //--- WHY "Neutral" WON, per OOS bar. ApplyClassificationSoftmax() requires a STRICT majority over
   //--- both rivals and sends every tie - 2-way or 3-way - to Neutral. So a reported Neutral is two
   //--- completely different events sharing one label, and they need OPPOSITE fixes:
   //---   strict  - the net really does rank Neutral highest. A class-prior / label problem.
   //---   tie     - the top two are EXACTLY equal, so the net expressed no preference and the
   //---             tie-break reported it as Neutral. A saturation problem: the head is SIGMOID, and
   //---             a saturated sigmoid returns exactly 0.0f or 1.0f in the DLL's float32, so two
   //---             classes pinned to the same rail compare equal and the bar is silently discarded.
   //--- Eras 1-25 of the 2026-08-17 solo PAI run read "Neutral 100%" at spread avg 0.99 (fully
   //--- saturated) and broke out at era 27 as the spread fell to 0.75 - consistent with EITHER story,
   //--- which is exactly why counting them apart is worth four longs. m_oosTieBuySell is the costly
   //--- subset: a Buy-vs-Sell tie at the top is a DIRECTIONAL call destroyed by float equality.
   long                m_oosNeutralStrict;
   long                m_oosNeutralTie;
   long                m_oosTieBuySell;
   long                m_oosRailBars;   // any raw output pinned to a sigmoid rail (<=0+eps or >=1-eps)
   //--- per-era counts of the network's own classification of each bar it fed forward (IS+OOS),
   //--- reset at the start of every era; surfaced in the status label text so class imbalance
   //--- (e.g. the network collapsing to all-Neutral) is visible while training runs
   int                 m_countBuySignals;
   int                 m_countSellSignals;
   int                 m_countNeutralSignals;
   //--- per-era counts of the *true* label of every bar fed forward (IS+OOS), reset alongside the
   //--- predicted counts above. Used both to display the actual class distribution in the status
   //--- label text and, more importantly, to drive IS-sample oversampling in Train() (see backProp calls
   //--- below) - rarer classes get replayed more times so gradient descent doesn't just learn to
   //--- always call the majority (usually Neutral) class.
   int                 m_trueBuyCount;
   int                 m_trueSellCount;
   int                 m_trueNeutralCount;
   //--- snapshot of the class totals above, taken at the end of the PREVIOUS era (see Train()'s
   //--- era-reset block) and held fixed for the whole of the current era. The oversampling ratio
   //--- below is computed from these frozen counts rather than the live, still-accumulating
   //--- m_true*Count values - using the live counts made the ratio order-dependent within a single
   //--- era (chronological, oldest-to-newest bar processing means whichever class happens to be
   //--- numerically behind at any given moment gets amplified up to 5x, even if that's just a
   //--- transient artifact of which regime the era's early bars came from, not the class's true
   //--- overall rarity) - a real source of run-to-run oscillation in the predicted class mix. All
   //--- zero on era 0, when oversampling simply falls back to 1x (see the reps calc in Train()).
   int                 m_prevEraTrueBuyCount;
   int                 m_prevEraTrueSellCount;
   int                 m_prevEraTrueNeutralCount;
   //--- per-era OOS confusion counts, reset each era; used to compute per-class OOS recall (hits/total)
   //--- for the status label text and, more importantly, as an additional convergence gate alongside the
   //--- blended dOosForecast accuracy - a model that "wins" only by calling everything Neutral will
   //--- have high dOosForecast but near-zero Buy/Sell recall, and should NOT be allowed to converge.
   int                 m_oosBuyHits, m_oosBuyTotal;
   int                 m_oosSellHits, m_oosSellTotal;
   int                 m_oosNeutralHits, m_oosNeutralTotal;
   //--- same per-era OOS confusion counts as above but keyed by PREDICTED class instead of true class,
   //--- i.e. per-class precision (of the bars this era where the model called Sell, how many actually
   //--- were Sell?) rather than recall (of the bars that actually were Sell, how many did it catch?).
   //--- Recall alone can't distinguish "the model over-fires Sell and happens to also catch enough real
   //--- Buys/Neutrals to clear their recall floors" from "the model is genuinely well-calibrated" - a
   //--- skewed Predicted-this-era count (see m_countSellSignals) with recall still passing the gate is
   //--- exactly that failure mode, and precision is what would expose it.
   int                 m_oosBuyPredicted, m_oosBuyPredictedHits;
   int                 m_oosSellPredicted, m_oosSellPredictedHits;
   int                 m_oosNeutralPredicted, m_oosNeutralPredictedHits;
   //--- WOULD THE TRADE HAVE PAID. Same predicted-class keying as the *Hits pair above, but scored
   //--- against m_winLongCache/m_winShortCache instead of against label agreement - "the Buy calls whose
   //--- long actually reached target before stop", not "the Buy calls that matched a 3-class label".
   //---
   //--- These two questions coincided only while reward >= risk forced Buy and Sell to partition the
   //--- resolved bars. Removing the minimum-reward:risk raise (2026-08-09) ended that: the measured
   //--- geometry puts the target NEARER than the stop, so both directions can win on the same bar, the
   //--- label can only name one of them, and the other call was being scored as an error despite its
   //--- trade paying in full. The gap is not academic - it moved the zero-skill reference to 37.5% while
   //--- break-even sat at 67.3%, i.e. the gate would happily ship a model that loses on every trade.
   //---
   //--- With this pair, dirPrecPct IS the win rate, and the invariant the gate rests on is restored
   //--- exactly: an always-Buy model wins P(winLong) = m/(m+k) of the time, which is also the break-even
   //--- rate for a k:m trade, so "beats chance" and "is profitable" are once again the same test.
   int                 m_oosBuyPredictedWins;
   int                 m_oosSellPredictedWins;
   //--- Zero-skill denominators, MEASURED rather than assumed from m/(m+k): how many scored bars a long
   //--- (resp. a short) would have won on, regardless of what the model called or what the label says.
   //--- max() of the two is what an always-call-one-direction model scores, which is the reference the
   //--- deploy gate needs. Measured, because the theoretical identity holds for a driftless walk and real
   //--- instruments drift - SP500 makes always-long genuinely better than a coin, and a gate that used
   //--- the textbook value would credit that drift to the model.
   int                 m_oosWinLongTotal;
   int                 m_oosWinShortTotal;
   //--- Confidence calibration: the classification head's forward pass still uses SIGMOID per-neuron
   //--- (see BuildFreshTopology()'s SIGMOID comment - bounded activation, avoids logit runaway), but
   //--- the BACKWARD pass (CNet::backProp/backPropOCL in AI\Network.mqh) now trains all 3 neurons
   //--- jointly against a true softmax+categorical-cross-entropy gradient (softmax_i - target_i), not
   //--- 3 independent binary-cross-entropy targets. ApplyClassificationSoftmax() at READ time
   //--- reproduces the same normalization the loss was actually trained against, so the value it
   //--- returns is now a genuinely loss-consistent probability (still not literature-perfect
   //--- calibration - no temperature scaling/Platt scaling has been applied - but no longer
   //--- structurally decoupled from what was optimized). SignedAIConfidence()/g_AISignedConfidence
   //--- exposes it, and Money\MoneyIntelligent.mqh:AdjustRiskAmount() scales position-sizing risk%
   //--- directly off it.
   //--- m_oosConfidenceSum accumulates MathAbs(dPrevSignal) (the claimed confidence) over every
   //--- classified OOS bar this era; compared against this era's actual OOS accuracy
   //--- ((m_oosBuyHits+m_oosSellHits+m_oosNeutralHits)/m_oosSamples) at era-end to derive
   //--- m_confidenceCalScale - a single empirical multiplier ("the model claims 80% on average but is
   //--- only right 60% of the time -> scale reported confidence by 0.75") applied to the MAGNITUDE
   //--- only, never the sign/class decision, in SignedAIConfidence(). EMA-blended across eras (same
   //--- smoothing factor as dOosForecast) so one noisy era can't swing it, and clamped to [0.3, 1.5]
   //--- so a thin/degenerate OOS window can't drive it to something absurd. Starts at 1.0 (no
   //--- correction) until the first era with OOS samples computes a real value.
   double              m_oosConfidenceSum;
   double              m_confidenceCalScale;
   //--- minimum acceptable OOS recall (%) for the Buy and Sell classes individually before Train() is
   //--- allowed to declare convergence; a class with zero OOS samples this era doesn't block (avoids a
   //--- deadlock when a given era's OOS window happens to contain no examples of that class)
   int                 m_minDirectionalRecallPct;
   //--- THE OPERATIVE per-class floor, derived from the class's own effective sample instead of taken
   //--- from the input above (which survives only as the fallback when the sample is too thin to give
   //--- an SE). `classTrueCount` is that class's RAW true-label count this era; the overlap deflation
   //--- is applied inside via EffectiveSampleSize().
   //---
   //--- WHY IT SITS BELOW CHANCE, which looks wrong at first and is the whole point. This floor's job is
   //--- to refuse to call a COLLAPSED model converged - one that has stopped emitting a class at all -
   //--- and nothing more. It is not a quality bar: the deploy gate is the quality bar, and it is already
   //--- rigorous (chance + EDGE_MIN_SIGMAS x SE on the overlap-deflated sample, Sidak over the candidate
   //--- eras, then the cross-instrument pooled certificate). A convergence gate that ALSO demands
   //--- provably-above-chance recall on all three classes double-counts that job and has failed twice
   //--- here by being unreachable: MinRecall=60 blocked every SP500 H1 run in 2026-07, and the 40 that
   //--- replaced it made Neutral structurally impossible once first-touch resolution cut Neutral to a
   //--- 0.65% residue. A floor nothing can reach does not make the product safer, it stops it converging.
   //---
   //--- So the test is one-sided in the other direction: recall significantly BELOW chance is evidence
   //--- the model is actively AVOIDING that class, which is exactly what collapse looks like and is the
   //--- only thing a fixed 40 was ever reliably catching. Being derived, it also scales the right way -
   //--- it widens on a thin OOS window (where low recall genuinely cannot be distinguished from noise)
   //--- and tightens on a rich one, where a fixed constant is either too strict or too soft depending
   //--- only on which chart it happens to be running.
   //---
   //--- Measured on 2026-08-17: n_eff 195 (USDJPY CONV) -> floor 26.5%, and PAI's Sell recall of 18%
   //--- is correctly blocked as a directional bias; n_eff 42 (SP500) -> floor 18.8%, correctly more
   //--- tolerant. The old constant 40 was, by coincidence, chance + 2 SE at n_eff 195 and chance + 0.9
   //--- SE at n_eff 42 - i.e. it was accidentally calibrated for one chart and wrong on the other.
   double              CollapseRecallFloorPct(int classTrueCount);
   //--- THE EXIT POLICY ACTUALLY IN FORCE, pushed in from the same inputs the live path reads
   //--- (Min_Vote_Close / HoldToBarrier). 0 = no vote-driven exit, which is what ships today.
   //--- The gate has to know this because it certifies a WIN RATE measured on hold-to-resolution
   //--- outcomes: entry, then the barrier decides. Every vote-driven exit closes EARLIER than that, so
   //--- with them enabled the certified number stops describing the traded one. Warrior_EA.mq5 used to
   //--- argue barrier models could keep vote exits because "their label IS the vote's own horizon" -
   //--- it is not: a vote flip at bar 5 of a 64-bar horizon is not the target-before-stop outcome.
   double              m_exitVoteThreshold;
   bool                m_exitHoldToBarrier;
   //--- The model's ADJUSTED signed decision per OOS bar, captured during pass 3 - the same value that
   //--- votes live, 0 where it abstains. Needed because a vote-flip exit at bar t depends on what the
   //--- model SAYS at bar t, which is a future bar relative to the entry being graded, so the outcome
   //--- cannot be precomputed per bar the way the barrier win caches are. In ensemble mode this holds
   //--- the COMBINED vote, because the live exit reads the ensemble average (see
   //--- EnsembleLiveSignedConfidence) and an LSTM entry really can be closed by the ensemble turning
   //--- against it - the coupling the user identified on 2026-08-17.
   double              m_oosDecisionSeries[];
   //--- The trade the EA would ACTUALLY have taken from `entryIdx`, under the policy above: first of
   //--- stop / target / vote reversal / horizon. Returns the outcome in R (risk multiples, so -1 is a
   //--- full stop-out and tpMult/slMult a full target) rather than as a bool, because a vote exit lands
   //--- somewhere in between and a boolean cannot carry that. false = unresolvable bar.
   bool                SimulateTradeOutcome(int entryIdx, bool isLong, double &rMultiple,
                                            int &lifespanBars, bool &endedOnVote);
   //--- Per-era accumulators for the simulated-exit report (see ReportExitPolicyDivergence).
   double              m_simRSum;
   double              m_simRSumSq;
   int                 m_simTrades;
   int                 m_simVoteExits;
   int                 m_simBarrierWins;
   bool                m_exitReplayReported;
   void                ReportExitPolicyDivergence(void);
   //--- Replays every directional call of this era under the live exit policy. Runs AFTER pass 3, never
   //--- inside it: a vote-flip exit for a trade at bar r depends on the decisions at bars r-1, r-2, ...
   //--- which pass 3 has not produced yet when it grades r (it walks oldest-to-newest).
   void                SimulateExitPolicyOutcomes(void);
   //--- ExitPolicy() itself is PUBLIC (with the other Warrior_EA.mq5 setters) - it is pushed in from the
   //--- EA, not called from inside the class. These two are what it writes.
   //--- Mean of the three derived per-class floors, held only so the era log line can print the bar the
   //--- recalls beside it were actually judged against.
   double              m_lastRecallFloorPct;
   //--- Installs an adopted barrier geometry and every side effect that must travel with it: the derived
   //--- pair (the one authority), the legacy mode ints, the live-order globals, the .cfg rewrite, the
   //--- label cache and the horizon latch. ONE function because there are two callers - the member whose
   //--- scan chose it, and every other member on the chart, which learns it second-hand (the MI chain and
   //--- therefore the scan run once per chart, so the siblings never measure it themselves). Duplicating
   //--- eleven side effects across those two paths is exactly how a chart ends up with members training
   //--- on different targets - see g_ensembleChartGeomAdopted.
   void                ApplyAdoptedGeometry(double sl, double tp, int slMode, int tpMode);
   //--- ONE-SHOT DETECTABILITY REPORT: how many calls this configuration must fire before the deploy
   //--- gate could certify an edge of a given size AT ALL, and what share of the OOS window that is.
   //--- The inverse of the DEPLOY BAR line, and the actionable direction of it - "chance + 2 SE = 42%"
   //--- says the bar, this says what it would take to reach it. Purely a report; it gates nothing.
   void                ReportDetectability(int oosBars);
   bool                m_detectabilityReported;
   //--- There is deliberately NO minimum-confidence input here any more, and no member holding one.
   //--- Confidence is expressed through the VOTE WEIGHT (ConfidenceTier() -> PatternWeightForTier()),
   //--- not through a separate entry floor, so a weak call is not blocked at the AI's own boundary - it
   //--- votes weakly and is then filtered by the same Min vote to open threshold that filters a weak
   //--- classic vote. That is what makes ONE input genuinely govern both engines.
   //--- The floor it replaced was a scale mismatch: Min_Vote_Open fed it directly as a 0..1 probability
   //--- while ALSO being the 0..100 averaged-vote threshold, and a 3-class argmax winner is
   //--- arithmetically >= 1/3, so every setting from 0 to 33 gated precisely nothing while every setting
   //--- above that silently re-quartiled the confidence tiers as a side effect. See ConfidenceTier().
   //--- Stops the per-era EMA update of the measured class priors after the first real measurement, so
   //--- the tau*log(prior) offsets stay pinned to the distribution the run started from.
   bool                m_freezePriorCalibration;
   //--- THE class-imbalance correction: tau in Menon et al. 2021's logit adjustment. tau*log(prior_c) is
   //--- added to each class logit in the TRAINING gradient only, so the network absorbs the offset and
   //--- its RAW argmax is already balanced-error-optimal at inference - no second correction at read
   //--- time. 0 disables it. This is the sole survivor of the nine-input imbalance section audited away
   //--- on 2026-07-31 (see Variables\Inputs.mqh); it is the only one of them with a consistency
   //--- guarantee, and it is consistent for exactly the balanced-error metric checkpoint selection
   //--- already ranks on. m_logitAdjustLogged keeps the once-per-run tau/cap report to one line.
   double              m_logitAdjustTau;
   bool                m_logitAdjustLogged;
   //--- Latch for the counterpart warning: the correction DECLINING to install. See ApplyLogitAdjustment().
   bool                m_logitAdjustSkipWarned;

   //--- True class base rates (natural, un-oversampled), measured from the label distribution each era
   //--- (UpdateClassPriors, EMA-blended for stability) and PERSISTED alongside the weights (.stats
   //--- sidecar) so live inference - including after a restart, when no training re-runs - calibrates
   //--- exactly as training did. 0 = not yet measured => AdjustedSignalFromSoftmax falls back to raw.
   double              m_priorBuy, m_priorSell, m_priorNeutral;
   //--- Per-era OOS "fired" confusion counts under the LIVE decision rule: a directional call is counted
   //--- whenever the prior-corrected posterior is non-Neutral, i.e. exactly the bars on which the
   //--- deployed EA would cast a directional vote. m_oosBuyFiredHits/m_oosBuyFired = live Buy precision;
   //--- likewise Sell. This is the metric that predicts forward-trading performance (recall/argmax-
   //--- precision above score the RAW argmax, before the base-rate correction the live decision applies).
   //--- Reset each era. Whether a counted vote also clears Min_Vote_Open against the other filters'
   //--- average is an aggregate question this per-bar scorer cannot see - see its use site.
   int                 m_oosBuyFired, m_oosBuyFiredHits;
   //--- The same live-fired population as above, but BUCKETED BY CONFIDENCE TIER (ConfidenceTier(), 4
   //--- buckets quartiled from the head's structural floor). Exists to answer the one question the
   //--- aggregate precision cannot: whether raising Min_Vote_Open would actually buy precision, and how
   //--- much coverage it would cost. Tier weights are 25/50/75/100, and for an AI-only configuration the
   //--- averaged vote IS the tier weight, so these four rows map directly onto the input: a floor of 50
   //--- keeps tiers 1-3, 75 keeps 2-3, 100 keeps tier 3 alone. Measuring it beats guessing at it - the
   //--- floor is only worth raising if precision actually rises monotonically across the tiers, and if it
   //--- does not, that is itself the finding (the model's confidence is not calibrated to correctness).
   int                 m_oosTierFired[4], m_oosTierHits[4];
   //--- Set by RankTiersFromOos() the first time this model measures its own tiers on held-out
   //--- bars. Gates the signal DB out of this filter's pattern weights from then on.
   bool                m_tiersSelfRanked;
   //--- ERA-END SNAPSHOTS of the arrow cache, taken in RankTiersFromOos() at pass-3 completion -
   //--- the one moment the cache is complete for the era. Everything DISPLAY-side reads these, never
   //--- the live cache, because the live cache is wiped to sentinel at every era start and is
   //--- therefore empty for most of every era (the draw/wipe flicker and the glued-to-one-bar
   //--- readout both traced to exactly that). m_prospectiveSigSnap is the newest scored bar's raw
   //--- signal (-2 = no completed era yet); the array is the newest SIGNAL_RESCAN_LOOKBACK_BARS+16
   //--- cache entries, raw signals, converted to votes at read time so a tier re-rank between eras
   //--- reprices them without a copy.
   double              m_overlaySigSnap[];
   int                 m_overlaySnapBars;
   double              m_prospectiveSigSnap;
   int                 m_oosSellFired, m_oosSellFiredHits;
   //--- Cumulative (compounded, persistent) DIRECTIONAL accuracy = the win-rate of the model's Buy/Sell
   //--- calls: of the bars it actually called Buy or Sell, how many matched the true label. Neutral ("no
   //--- trade") calls are deliberately EXCLUDED - counting them inflates the rate to ~80%+ (Neutral is the
   //--- ~94% majority the model gets right for free) and tells you nothing about trade quality. Summed
   //--- across every era AND carried across restarts via the .stats sidecar (WST5); never reset era-to-era,
   //--- so the panel shows a stable win-rate that only firms up as more pivots confirm. Incremented at the
   //--- IS (pass 2) and OOS (pass 3) hit sites, only when the PREDICTION is directional, skipped for
   //--- Reset only by ResetWeights (a fresh model).
   long                m_cumIsCorrect, m_cumIsTotal;
   long                m_cumOosCorrect, m_cumOosTotal;
   //--- Latest live-fired precision (%) and fire count per direction (-1 = n/a), cached at era end for
   //--- the status panel/log the same way m_lastBuyRecallPct is (see its comment).
   int                 m_lastBuyFiredPrecPct, m_lastSellFiredPrecPct;
   int                 m_lastBuyFired, m_lastSellFired;
   //--- Ceiling on the class-balance sampleWeight multiplier (see its computation in Train(), keyed off
   //--- m_prevEraTrueBuyCount/Sell/Neutral). MAX_WEIGHT_DELTA (AI\Network.mqh/.cl, DirectML\WarriorCPU.cpp)
   //--- bounds how far a SINGLE weight can move in one step, but it does nothing to stop many small
   //--- steps in the same direction from accumulating into a large net swing across an era - with real
   //--- label counts around Buy 1340 / Sell 1312 / Neutral 7013 the uncapped ratio is ~5.3x on every
   //--- single Buy/Sell example, every era. At the old hardcoded 3.0x ceiling that was STILL strong
   //--- enough in practice to let one era's Buy gradients overwrite the separability the previous era
   //--- had just built for Sell (and vice versa) - the observed anti-correlated Buy/Sell recall whipsaw
   //--- (e.g. era 8 Buy:0%/Sell:26% -> era 9 Buy:10%/Sell:57% -> era 10 Buy:1%/Sell:37%), never both
   //--- classes improving together. Was tunable (ClassSampleWeight input, CSW_15/1.5x default) as a
   //--- loss-level multiplier, but that mechanism proved structurally too weak against Adam's near-
   //--- invariance to constant gradient rescaling (Kingma & Ba 2015) - see the m_isTrainQueue queueing
   //--- block's oversampling comment for the full history. Class-balance correction now happens
   //--- entirely via data-level oversampling (repCount in that queueing block); this member is
   //--- currently unread by that path. The ClassSampleWeight INPUT that used to set it was removed
   //--- (it had no effect); the member is kept at its constructor default in case a smaller, additive
   //--- loss-level nudge is ever reintroduced on top of oversampling.
   double              m_maxClassSampleWeight;
   //--- FOCAL LOSS REMOVED 2026-07-31 (was m_focalGamma / the FocalLossGamma input). Lin et al. 2017's
   //--- (1-pt)^gamma is sound, but it corrects the SAME axis as the logit-adjusted loss, and stacking
   //--- two corrections on one axis is the failure Buda et al. 2018 warns about (cited in the queueing
   //--- block). It was also running at gamma*0.125, damped by a replay flag whose path was already dead.
   //--- The ladder's escape is the learning-rate warm restart; the gamma anneal was a monotone step to
   //--- zero, so nothing went with it. Full nine-input audit: the class-imbalance block in Inputs.mqh.
   //--- ZigZag repainting embargo, in bars. The real MQL5 ZigZag (CustomIndicators\ADZigZag.mq5 - a
   //--- renamed, logic-untouched copy of the stock ZigZag.mq5 at its stock defaults: Depth=12,
   //--- Deviation=5 points, Backstep=3) revises its most recent 1-3 legs as new bars arrive (see
   //--- ADZigZag.mq5's own ExtRecalc), so a bar's ADZigZagBuffer value is only trusted once at least
   //--- this many MORE bars have closed after it.
   //--- SCOPE NARROWED 2026-08-01: this used to gate the training LABELS as well, back when the target
   //--- was the exact confirmed pivot. The target is now the triple barrier, whose lookahead is its own
   //--- horizon (m_barrierHorizonBars), so this constant survives for exactly one job - keeping the
   //--- swing-context INPUT FEATURES (m_useSwingContext) from reading a leg that can still change.
   int                 m_swingConfirmationBars;
   //--- Vertical barrier of the triple-barrier label, in bars - see BARRIER_HORIZON_LADDER_COUNT. Derived
   //--- once by ComputeBarrierHorizonBars() at the start of the label prebuild and then held for the run.
   //--- It is ALSO the label's lookahead depth, so it is what the IS/OOS embargo and the online-learning
   //--- confirmation delay must both wait out: a bar's barrier label is not knowable until this many more
   //--- bars have closed after it. That job used to belong to m_swingConfirmationBars, which answered the
   //--- ZigZag question ("has this leg stopped repainting") and no longer answers the label's.
   int                 m_barrierHorizonBars;
   //--- Latch so the invalid-TP fallback in BarrierMultiples() shouts once, not once per labelled bar.
   bool                m_barrierFallbackWarned;
   //--- Did the LAST TripleBarrierLabel() call run out of horizon without either barrier being touched?
   //--- Neutral conflates two very different outcomes - "the trade timed out" and "the stop was hit
   //--- before the target" - and only the first one indicts the horizon. Counting them apart is what
   //--- lets the m*k horizon scaling in ComputeBarrierHorizonBars() be VERIFIED against a real run
   //--- rather than trusted: a high timeout share means the horizon is too short for the configured
   //--- barrier, a high stop-out share just means the barrier is hard.
   bool                m_lastBarrierTimedOut;
   //--- Did the LAST call find BOTH directions' targets reachable inside the horizon? Impossible while
   //--- reward >= risk - the case only opened up when the minimum-reward:risk raise was removed and the
   //--- MEASURED geometry came back with the target (q50 of favourable travel) CLOSER than the stop (q75
   //--- of adverse). It is not an edge case there: it is the whipsaw class, and on SP500 H1 it accounts
   //--- for nearly all of Neutral. Published so the prebuild can count it - see
   //--- m_labelPrebuildBothWonCount for why a bar that wins in either direction must not be labelled
   //--- "do not trade".
   bool                m_lastBarrierBothWon;
   //--- Subset of the above where both targets fell inside the SAME bar, so OHLC cannot say which came
   //--- first. Those stay Neutral, for the same reason intrabar ties score as the stop: the file refuses
   //--- to order two touches it cannot see the order of.
   bool                m_lastBarrierBothWonTied;
   //--- Did a LONG / a SHORT placed at this bar reach its target before its stop? These are the raw
   //--- questions the barrier walk answers, before they are collapsed into one 3-class label, and they
   //--- are what a trade's profitability actually depends on. Kept separately because the collapse is
   //--- LOSSY in exactly the case that now matters: on a both-won bar the label names one direction, but
   //--- BOTH trades would have paid, so scoring the other call as an error understates the model. See
   //--- m_oosWinLongTotal for why the deploy gate had to stop using label agreement as its hit test.
   bool                m_lastWinLong;
   bool                m_lastWinShort;
   //--- Excursions of the bar TripleBarrierLabel() just resolved, in ATR units, published the same way
   //--- m_lastBarrierTimedOut is: the walk that finds them is the walk the label already does, so they
   //--- cost one max and one min per bar rather than a second pass over history.
   double              m_lastExcUp;    // (maxHigh - entry)/ATR over the horizon, >= 0
   double              m_lastExcDown;  // (entry - minLow)/ATR, >= 0
   //--- LABEL LIFESPAN, in bars: how long after entry this bar's label became KNOWABLE - the age of the
   //--- barrier touch that fixed the outcome, or the full horizon when it timed out. Published for the
   //--- bar just walked, exactly like m_lastExcUp.
   //---
   //--- WHY THIS EXISTS, and it is not a diagnostic. Triple-barrier labels on adjacent bars OVERLAP: a
   //--- label that takes L bars to resolve shares L-1 bars of its outcome window with its neighbour, so
   //--- consecutive labels are nowhere near independent draws. Every standard error in this codebase was
   //--- computed as sqrt(p(1-p)/n) on the RAW call count, which is the formula for n independent
   //--- observations - and with L in the hundreds the true error is larger by ~sqrt(L).
   //---
   //--- THE JUSTIFICATION IS THE OVERLAP ITSELF, not a misbehaving gate. Recording this because the
   //--- first version of this comment claimed otherwise and was WRONG: it cited the operating point's
   //--- null-of-the-maximum gate firing on 47 of 73 Perceptron eras (64%) where a family-wise test
   //--- should fire on ~5%. That 73 was the first three minutes of a six-and-a-half-hour run. Over the
   //--- full 6,930 eras the same gate fired 47/3214 = 1.5% (PAI), 2.5% (ConvLSTM), 6.3% (Convolutional),
   //--- 8.2% (LSTM) - all of them at or below the null, i.e. the gate from 7414570 is working exactly as
   //--- designed, and PAI's 47 clears were a cold-start transient it never repeated in 3,141 later fits.
   //--- The operating point it produces is stable too: PAI's threshold over the run's second half has a
   //--- standard deviation of 0.01.
   //---
   //--- So this correction fixes a real statistical error that was NOT, on this evidence, causing an
   //--- observable failure. It is worth having anyway - sqrt(p(1-p)/n) on overlapping labels is simply
   //--- the wrong formula - and it costs nothing today because no model is anywhere near the deploy
   //--- line (all four finished 4-6pp BELOW the always-long chance rate). It will matter on the day one
   //--- is close, and then it will demand a much larger measured edge before certifying anything.
   //---
   //--- The correction is Lopez de Prado's sample uniqueness (Advances in Financial Machine Learning,
   //--- ch. 4) - the same triple-barrier framework this label already implements. With one label started
   //--- per bar and mean lifespan L, average concurrency is ~L and average uniqueness ~1/L, so the
   //--- effective sample size is n/L. See EffectiveSampleSize().
   int                 m_lastLabelLifespan;
   //--- Running mean of the above over every bar the label cache has resolved this process. Rebuilt with
   //--- the cache (a horizon change makes every previous measurement answer a different question), and
   //--- deliberately a plain mean rather than an EMA: it is a property of the geometry, not a time series.
   double              m_labelLifespanSum;
   long                m_labelLifespanCount;
   //--- DERIVED barrier multiples, in ATR units, taken from the measured excursion distribution rather
   //--- than from an enum. Zero means "not derived yet" and BarrierMultiples() falls back to the mode
   //--- constants. Continuous on purpose: the whole point is to stop snapping the geometry to {2,3} x
   //--- {2,3,4,6,8,10}, a grid whose members were guesses.
   double              m_derivedSlMult;
   double              m_derivedTpMult;
   bool                m_geometryDerived;
   //--- DIRECTIONAL CONFIDENCE THRESHOLD - see DIR_CONF_THRESHOLD_BINS for the rationale. The ACTIVE
   //--- value, read by AdjustedSignalFromSoftmax() on every live and pass-3 decision; 0.0 means
   //--- unthresholded (era 0, or an IS histogram too sparse to fit). Refitted at the end of every
   //--- pass 2 from that era's own IS margins, because the margin distribution moves with the weights.
   double              m_dirConfThreshold;
   //--- The value that belongs to the CHECKPOINTED weights. Captured at the same instant as
   //--- Net.CaptureWeights() and restored beside them, because a threshold fitted for one set of
   //--- weights is meaningless against another - deploying era 40's weights under era 63's operating
   //--- point would silently change both coverage and precision away from the numbers the deploy gate
   //--- actually cleared.
   double              m_bestDirConfThreshold;
   //--- Margin histogram for the fit, rebuilt each era from the CALIBRATION slice (see
   //--- DIR_CONF_CALIB_PCT_OF_IS). Index = bin of (winning direction's probability - its best rival's);
   //--- [0] counts directional calls, [1] counts the ones whose implied trade WON. No oversampling
   //--- applies here - the calibration walk visits each bar once, chronologically - so the primary-only
   //--- correction the replay queue needed (see m_cumIsTotal) is structural rather than a filter.
   long                m_dirConfBinCalls[DIR_CONF_THRESHOLD_BINS];
   long                m_dirConfBinHits[DIR_CONF_THRESHOLD_BINS];
   long                m_dirConfPrimaryBars;    // denominator for coverage: every calibration bar scored
   //--- one-shot so the "histogram too sparse" explanation is stated once per run, not once per era
   bool                m_dirConfSparseWarned;
   int                 m_geometryDerivePasses;  // fixed-point iteration counter, capped
   //--- The last ComputeBarrierHorizonBars() ran with FEWER confirmed ZigZag legs than the median
   //--- needs, so the horizon it returned is the fallback, not a measurement. While this is true the
   //--- horizon stays PROVISIONAL (m_barrierHorizonResolved is left false so the next full rebuild
   //--- re-resolves it) and the geometry deriver refuses to run - deriving a permanent, .cfg-pinned
   //--- barrier from excursions measured over a made-up window would pin the artifact, not the market.
   //--- Observed 2026-08-09 22:25: a terminal restart ran the resumed-model pre-scan in the same
   //--- second as OnInit, the ZigZag had 0 calculated legs, and the horizon latched to fallback(32) x
   //--- slMult x tpMult = 384 for the whole process.
   bool                m_barrierHorizonLegStarved;
   bool                m_horizonStarvedWarned;   // one-shot: the starved path can retry every call
   //--- Has THIS process written the derived geometry into the .cfg? The .cfg was only ever written at
   //--- model creation and at weights-reset - both BEFORE era 0's derivation - so the derived pair
   //--- never reached disk, every resumed model read back zeros, adopted nothing, fell back to the
   //--- enum barriers, and (era > 0) never re-derived: trained on 3.33/1.62 all day, relabelled at 2:6
   //--- on the next restart. Set by the post-derivation save, and also by the adoption path (the pair
   //--- is already on disk there).
   bool                m_geometryCfgSaved;
   //--- ADOPTED-GEOMETRY LATCH. True once ReportBarrierGeometryScan has crowned a pairing that cleared
   //--- its family-wise null. Two measurements choose this geometry and until 2026-08-17 they fought:
   //--- DeriveBarrierGeometry re-measures the SCALE off the excursion quantiles on every era-0 pass and
   //--- overwrites m_derivedSl/TpMult, while the scan wrote only the legacy mode ints - which
   //--- BarrierMultiples ranks BELOW the derived pair. So the scan's decision was inert, and had it not
   //--- been it would have been overwritten by the next derive pass anyway.
   //--- The scan wins, and this latch is how. The reason is evidential rather than architectural: the
   //--- scan's winner cleared a permutation test against the null of the MAXIMUM over every eligible
   //--- pairing, and it scores the incumbent derived pair as a peer in that same field. The derive is a
   //--- descriptive quantile read with no significance test attached. A measurement that survived a
   //--- family-wise gate outranks one that was never tested against a null.
   bool                m_geometryAdopted;
   //--- MEASURED DIRECTIONAL EVIDENCE, and the one thing that makes the MI suite a SCREEN rather than a
   //--- commentary. Set when either the feature/label permutation test or the normalised excursion
   //--- asymmetry clears its null; false when neither does. The suite has always printed these verdicts
   //--- and then trained the direction target regardless of what they said - which is the whole gap
   //--- between this and the EdgeFinder discipline the user runs in SQX: measure what the market offers,
   //--- THEN aim. A run with no measured directional information may still train (the research value is
   //--- real and the measurement can be wrong), but it must not DEPLOY: no amount of fitting creates
   //--- information the screen could not find, and every direction verdict this project has closed was
   //--- closed after exactly that was attempted anyway.
   bool                m_dirEvidence;
   string              m_dirEvidenceWhy;
   //--- Median confirmed ZigZag leg in bars, UNSCALED by the barrier. The window excursions are measured
   //--- over, kept independent of the geometry so sizing the geometry from them cannot feed back.
   int                 m_swingMedianBars;
   int                 m_labelPrebuildTimeoutCount;
   //--- Bars where BOTH targets were reached, and the same-bar subset that could not be ordered. Counted
   //--- rather than inferred: the share was first arrived at by subtracting timeouts from Neutral and
   //--- reasoning that both-lost is unreachable, which is sound but is still arithmetic on a log line.
   //--- These two numbers make the label composition readable directly, and the tie count is the one that
   //--- says whether first-touch resolution is doing real work or just relabelling noise.
   int                 m_labelPrebuildBothWonCount;
   int                 m_labelPrebuildBothWonTieCount;
   //--- safety valve: Train()'s do-while loop has no other bound on how many eras it will run
   //--- before giving up, so a config that can't reach the convergence objective (e.g. too few
   //--- swing-confirmed examples for the min recall bar to be reachable) would otherwise loop
   //--- forever, permanently keeping the era-progress status label up instead of the normal per-tick
   //--- info line and burning CPU nonstop. When the cap is hit, the operator is prompted (see
   //--- PromptContinuePastEraCap): CONTINUE resets the era counter and keeps training; STOP deploys
   //--- the best checkpoint found so far (FinalizeTrainRun) and terminates training. Headless
   //--- (tester/optimizer) runs can't prompt, so they take the STOP branch automatically.
   int                 m_maxErasPerRun;
   //--- Train() runs its per-bar loop synchronously, and MQL5 is single-threaded per chart - a
   //--- multi-minute era would otherwise starve the terminal's chart-event queue for that whole
   //--- stretch, including the control panel's own click/drag hit-testing (Panel\ControlPanel.mqh),
   //--- which depends entirely on CHARTEVENT_MOUSE_MOVE being delivered promptly. Train() is
   //--- therefore chunked: each call does at most ~TRAIN_TIME_BUDGET_MS of work, then returns and
   //--- picks back up exactly where it left off on the next call (re-triggered via the same "New
   //--- Bar" custom-event scheduling ScheduleTrainingIfNeeded() already used) - the members below
   //--- are what makes that resumable across calls.
   bool                m_trainRunActive;     // true: a run (schedule -> convergence/stop) is in progress, possibly spanning many Train() calls
   bool                m_eraResumePending;   // true: yielded mid-bar-loop last call - resume the SAME era, don't start a new one
   int                 m_resumeBars;
   int                 m_resumeTotalIter;
   int                 m_resumeOosCutoff;
   int                 m_resumeBarIndex;
   bool                m_resumeAddLoop;
   //--- Pass 2 of the era loop: bar indices pass 1 (sequential feedForward/scoring) queued as
   //--- IS-eligible for backProp, trained on in a freshly shuffled order instead of pass 1's own
   //--- fixed chronological (oldest-to-newest) visitation order. Root cause this targets: Adam's
   //--- momentum (b1, AI\Network.mqh) has an effective memory window of ~1/(1-b1) steps, which lands
   //--- close to the length of the contiguous same-class label runs the target produces (triple-barrier
   //--- labels make those runs LONGER than the exact-pivot ones this was first measured against, since
   //--- adjacent bars share most of their forward window and usually resolve the same way, so the
   //--- argument holds a fortiori) - replaying those runs in the SAME order every single era let momentum lock onto
   //--- whichever run it was currently passing through, with the network's end-of-era state
   //--- disproportionately reflecting whatever it last walked through (recency), not a globally
   //--- balanced fit. Symptom observed in practice: IS error climbing era-over-era (0.16->0.55+ over
   //--- 25 eras on the same fixed dataset) instead of settling, and OOS Buy/Sell recall whipsawing
   //--- between near-0% and 70-100% despite near-equal Buy/Sell label counts. Shuffling is the
   //--- standard SGD fix - see the m_isPass2Active declaration below for how it's sequenced against
   //--- pass 1 within Train()'s existing resumable-chunk machinery.
   int                 m_isTrainQueue[];
   int                 m_isTrainQueueCount;
   //--- Parallel to m_isTrainQueue (same index, kept in lockstep through the Fisher-Yates shuffle
   //--- below) - the per-occurrence weight to apply when this queued slot is trained on in pass 2,
   //--- decided once at queue time (see the queueing block's oversampling comment) rather than
   //--- recomputed in pass 2. Currently always 1.0: class-balance correction is carried entirely by
   //--- repCount (how many times a bar was duplicated into the queue), not by any per-occurrence
   //--- weight scaling - see the queueing block's comment for why stacking a second correction here
   //--- caused two separate training collapses. Kept as a real per-slot array rather than a literal
   //--- 1.0 so a future, smaller/safer supplemental weight could be reintroduced without re-touching
   //--- the queueing or shuffle code.
   double              m_isTrainQueueWeightScale[];
   //--- Parallel to m_isTrainQueue too (same index, same lockstep swap in the shuffle): true on exactly
   //--- ONE occurrence per duplicated bar - the rep-0 slot written at queue time. Its only job is to keep
   //--- the reported IS accuracy (m_cumIsCorrect/m_cumIsTotal) measured on the NATURAL class distribution
   //--- while backProp still trains on the oversampled one.
   //--- Why: the queue duplicates each Buy/Sell bar up to repCount times (~21x at the observed 30.7:1
   //--- imbalance), so counting every occurrence measured IS accuracy over a set that is ~58% directional,
   //--- while the OOS counter measures the real ~6% directional distribution. Both excluded Neutral and
   //--- both used the identical formula, so they LOOKED directly comparable - and reported things like
   //--- "IS 77% / OOS 12%", which reads as catastrophic overfitting when the two numbers were simply
   //--- scored against base rates an order of magnitude apart (77% vs a 58% baseline is a 1.33x lift;
   //--- 12% vs a 6.1% baseline is 1.97x - the OOS side was actually the STRONGER one).
   //--- Counting primaries only puts both metrics on the same footing, so the IS/OOS gap once again means
   //--- what everyone reads it as meaning: generalisation. Training itself is completely unaffected -
   //--- every occurrence still backprops exactly as before; this flag is read only by the counter.
   bool                m_isTrainQueuePrimary[];
   //--- Pass 2's cursor into the (already shuffled) m_isTrainQueue - lets pass 2 itself yield/resume
   //--- mid-queue under the same TRAIN_TIME_BUDGET_MS chunk budget pass 1 already yields under.
   int                 m_isTrainCursor;
   //--- true: pass 1 (sequential) has finished for this era and pass 2 (shuffled backProp) is either
   //--- running or has yielded mid-queue - Train() skips straight past pass 1's loop on resume when
   //--- this is set. Reset to false only at a fresh era's start (never mid-run).
   bool                m_isPass2Active;
   //--- true: pass 2 has already run to natural completion for this era (m_isPass2Active's own
   //--- false state is ambiguous between "not started yet" and "already finished" - both look
   //--- identical to a plain `if(!m_isPass2Active)` check). Needed because pass 3 (OOS scoring) can
   //--- itself yield/resume across multiple Train() calls same as passes 1/2 do; without this flag,
   //--- every resume into an unfinished pass 3 fell through the `if(!m_isPass2Active)` guards on both
   //--- pass 1 and pass 2 and re-ran the ENTIRE shuffled queue again (pass 1 itself was a no-op on
   //--- resume since its own loop cursor `i` was already exhausted, but pass 2 re-shuffled and replayed
   //--- from scratch every single time) - silently multiplying the predicted-class counts (and the
   //--- extra, unintended backProp() calls) once per resume, for as long as pass 3 kept needing more
   //--- than one chunk to finish. Reset to false only at a fresh era's start, alongside m_isPass2Active.
   bool                m_isPass2Done;
   //--- Pass 3: chronological, OOS-region-only re-walk that happens AFTER pass 2 has actually trained
   //--- on this era's IS data - see m_isTrainQueue's declaration comment for why OOS scoring can no
   //--- longer just happen inline during pass 1 (that would score every era's OOS window against
   //--- weights from BEFORE this era's training, one full era stale - and for era 0 specifically,
   //--- against the still-untrained cold-start network, which is why era 0's OOS recall used to show
   //--- a meaningless 100% Neutral / 0% Buy / 0% Sell every time). Cursor walks i downward from
   //--- m_oosScoreStartIndex to 0, mirroring pass 1's own iteration bounds/order for whichever bars
   //--- satisfy isOOS - order matters here (unlike pass 2) since dOosForecast/dOosError are recursive
   //--- EMAs over the visitation sequence, not order-independent.
   bool                m_isPass3Active;
   int                 m_oosScoreIndex;
   int                 m_oosScoreStartIndex;
   //--- Pass 2.5: the CALIBRATION walk. Sits between pass 2 (train) and pass 3 (grade) because that is
   //--- the only position where the operating point can be fitted on data that is neither trained on nor
   //--- graded - see DIR_CONF_CALIB_PCT_OF_IS for the measurement that forced it out of pass 2. Chunked
   //--- and resumable on exactly the same pattern as passes 1-3 (cursor + active/done flags, both reset
   //--- only at a fresh era's start), because at ~5.7k bars it will not finish inside one 120 ms budget.
   //--- The band's bounds are recomputed from oosCutoff on every call rather than stashed in resume
   //--- state: they are a pure function of (totalIter, oosCutoff, horizon), all three of which the resume
   //--- path already restores, so deriving them cannot drift out of step with pass 1's queueing decision.
   bool                m_isCalibActive;
   bool                m_isCalibDone;
   int                 m_calibIndex;
   int                 m_calibStartIndex;
   //--- EXCURSION-SIZE HEAD. A separate small CNet rather than extra outputs on the classifier: adding
   //--- outputs would change m_outputNeuronsCount (branched on in a dozen places), the .nnw shape and
   //--- the weights fingerprint, and would push the output count off 3 - which is the exact condition
   //--- backProp uses to select the joint softmax gradient the 3-class head depends on. Kept separate,
   //--- the classifier is bit-for-bit unaffected and this whole instrument is removable without trace.
   //--- NOT PERSISTED in Stage 1: it is a measurement, it retrains within an era or two, and a second
   //--- weights file is surface area that only earns its place once the skill score justifies Stage 2.
   CNet               *m_excNet;
   bool                m_excHeadFailed;         // one-shot: creation failed, do not retry every bar
   //--- Allocated once, reused every bar. getResults takes CArrayDouble*& and allocates when handed a
   //--- NULL, so locals would mean an allocation per bar across ~32k bars an era.
   CArrayDouble       *m_excTgt;
   CArrayDouble       *m_excOut;
   long                m_excBaseHits[2 * BARRIER_LADDER_COUNT];
   long                m_excBaseTotal;          // rows the base rates were estimated from
   double              m_excBrierHead[2 * BARRIER_LADDER_COUNT];
   double              m_excBrierBase[2 * BARRIER_LADDER_COUNT];
   int                 m_excScored;             // held-out bars scored this era
   //--- Since e2c9593 every scored bar IS a disjoint window (the score step strides by the horizon),
   //--- so m_excBrierHead/m_excOosHits are already the disjoint tally and m_excScoredD just counts it.
   //--- The old parallel *D arrays from the two-tally era were declared and reset but never
   //--- accumulated - dead weight found by the 2026-08-11 audit and replaced by this one:
   //--- the head's Brier accumulated ONLY on the bars the trailing incumbent also scored, so
   //--- skillTrail compares the two predictors on the SAME bars instead of pro-rating the head's
   //--- full-block sum by coverage (which assumed head skill is uniform across the OOS walk while
   //--- the trail-scored subset systematically excludes the warm-up bars).
   double              m_excBrierHeadT[2 * BARRIER_LADDER_COUNT];
   int                 m_excScoredD;
   //--- OOS positives per rung. Feeds the ORACLE control: the best constant achievable ON THE SCORED
   //--- BLOCK, in closed form. Separates "predicts per bar" from "learned a level nearer the OOS rate
   //--- than the frozen IS constant", which scores positive while carrying no per-bar information.
   long                m_excOosHits[2 * BARRIER_LADDER_COUNT];
   //--- Bars whose predicted survival curve rose with distance. P(reach k) must be non-increasing in k;
   //--- nothing constrains 8 independent sigmoids to obey that, and ExcursionQuantile reads the first
   //--- crossing, so a tangled curve is misread exactly where the head is least certain.
   int                 m_excMonoViol;
   long                m_excTrainTick;          // stride counter, on attempts not acceptances
   ulong               m_excUs;                 // head's own microseconds this era - see the era line
   //--- TRAILING CLIMATOLOGY (see EXCURSION_TRAIL_WINDOW). Ring of per-bar outcome bitmasks - 32 rungs
   //--- fit one ulong, so the whole rolling history is one array of longs. Sized horizon + window: the
   //--- newest `horizon` entries are NOT yet resolved (a bar's outcome is only known one horizon later,
   //--- and using it would be lookahead), the next `window` entries are the rolling sample the estimate
   //--- is taken over, and anything older falls out.
   ulong               m_excTrailRing[];
   int                 m_excTrailHead;          // next write position
   int                 m_excTrailCount;         // entries pushed so far, capped at the ring size
   long                m_excTrailHits[2 * BARRIER_LADDER_COUNT];
   long                m_excTrailN;             // resolved bars currently inside the window
   double              m_excBrierTrail[2 * BARRIER_LADDER_COUNT];
   long                m_excTrailScored;        // bars scored while the trailing estimate was usable
   datetime            m_lastBarTime;
   //--- This model's own learning-rate trajectory. `eta` (AI\Network.mqh) is a single file-scope
   //--- global shared by every CNet in the process - PAI/CONV/LSTM each train independently and
   //--- asynchronously (their own Train() calls are interleaved via separate chart-event/timer
   //--- scheduling, not synchronized), but all three previously read AND wrote that one global, so
   //--- one model's era-end regression/recovery decay/recovery of `eta` (see Train()'s era-end
   //--- block) silently changed the learning rate the OTHER two models' very next backProp() call
   //--- used too - an unintended coupling between what's supposed to be three independent training
   //--- trajectories. Train() now restores `eta` from this member right before touching it, and
   //--- saves it back before returning (both at the mid-chunk yield and at the natural end of the
   //--- call) - MQL5 gives one chart's EA a single execution thread and each Train() call runs to
   //--- completion or to its own yield point before another event is dispatched, so this save/
   //--- restore is enough to isolate each model's schedule with no change needed to the neuron-level
   //--- or OpenCL/DirectML call signatures that read the global directly.
   double              m_modelEta;
   //--- Ceiling the era-end recovery bump (Train()'s isBetterEra block) restores `eta` toward - used
   //--- to be the raw `lr` constant unconditionally, which is only correct for ADAM. SGD's own starting
   //--- rate is the separate SgdLearningRate input (AI\Network.mqh) - clamping SGD's recovery bump to
   //--- plain `lr` (AdamLearningRate) would silently cap it back down to Adam's ceiling after the
   //--- first regression+recovery cycle, undoing the whole point of giving SGD its own configured
   //--- rate. Computed once at construction from this model's own m_optimizationAlgo, matching
   //--- m_modelEta's per-instance isolation (see that member's comment).
   double              m_etaCeiling;
   int                 m_erasSinceCooldown;  // eras completed since the last cooldown reset - replaces the old per-call-only "erasThisCall"
   CArrayDouble        m_oosWindow;          // run-scoped OOS stability window (used to be a Train()-local CArrayDouble)
   double              m_bestOosForecast;
   //--- Balanced accuracy (macro-recall: mean of Buy/Sell/Neutral OOS recall) of the era the current
   //--- checkpoint was taken from. This is the metric the checkpoint SELECTION ranks on now, in place
   //--- of the blended dOosForecast - blended accuracy is dominated by Neutral (~96% of bars), so among
   //--- otherwise-acceptable eras it silently preferred the MOST Neutral-leaning weights, deploying a
   //--- model that scores well on paper but under-calls Buy/Sell. Balanced accuracy weights every class
   //--- equally, so "best" now means "most accurate across all three classes" - exactly what a 3-class
   //--- signal product wants. Kept SEPARATE from m_bestOosForecast (which still snapshots the blended
   //--- value at the same checkpoint) because FinalizeTrainRun()/the restore-on-regression branch reset
   //--- dOosForecast to m_bestOosForecast, and that must stay the blended EMA the rest of the machinery
   //--- expects. The directional recall FLOOR (directionalRecallOK) still gates convergence unchanged;
   //--- this only fixes which era gets deployed among the candidates. -1 until the first ranked era.
   double              m_bestBalancedOos;
   //--- whether the era m_bestOosForecast/the checkpoint was taken from also cleared the per-class
   //--- directional recall floor (see directionalRecallOK below) - part of the "best" ranking itself,
   //--- not just a side note, so blended accuracy alone can never outrank a directionally-useful era
   //--- (see the checkpoint/eta-decay comment in Train()'s era-end block for why that matters).
   bool                m_bestPassedRecall;
   //--- Was the checkpointed era calling BOTH directions? Middle tier of the ranking key - see
   //--- isBetterEra. Exists because of a measured failure (2026-08-09, HYBRID era 29): under win-based
   //--- scoring an always-Buy model scores EXACTLY chance (P(winLong), ~67% on drifting SP500) while
   //--- honest two-sided eras score 63-66% (shorts win less often against the drift), so raw score
   //--- ranking crowned the degenerate model, every regression restored back to it, and live NMS
   //--- collapsed its constant signal to ~25 trades per era ("barely trades"). bothSidesLive already
   //--- blocked it from DEPLOYING via tradeableOK, but among not-yet-deployable eras the score alone
   //--- decided - the same phase the coverage credit exists for.
   bool                m_bestBothSidesLive;
   //--- SLOW-ERA HEARTBEAT (2026-08-10). The era passes are silent by construction - pass 1 logs
   //--- nothing and (until tonight) painted nothing for IS bars, pass 2/3 only paint - so when a
   //--- restart left all four charts grinding ~25x slower than the 18:01 baseline (era lines in 86s),
   //--- the outside view was "Getting ready...", four pegged cores, and an empty log for 20+ minutes,
   //--- with the hourly new-bar cache invalidation then cancelling and restarting the unfinished era
   //--- forever. Nothing external (thread stacks need a debugger the VPS lacks) can say WHERE the time
   //--- goes, so training itself must: cumulative per-era timers around the two candidate costs
   //--- (feature-window builds, net forward/backprop) and a heartbeat line that only speaks when an
   //--- era is genuinely slow - a healthy run stays exactly as quiet as before.
   uint                m_eraStartTick;
   ulong               m_passFeatUs;    // cumulative BuildFeatureWindow time this era, microseconds
   ulong               m_passNetUs;     // cumulative feedForward/backProp time this era, microseconds
   int                 m_passHeartbeatPrints;
   uint                m_lastHeartbeatTick;
   //--- How many of pass 1's bars produced a usable feature window, and how many did not. These decide
   //--- whether the era does ANY work: add_loop is just "m_passWindowOk > 0", and when it is false
   //--- pass 2, pass 3, the era counter and the checkpoint are ALL skipped, so Train() returns having
   //--- done nothing and the next call restarts the same era from bar 0 - an infinite, wholly silent
   //--- 0->100% scan loop. Counting both sides makes a partial failure (indicators unavailable over
   //--- the oldest bars, which is normal and harmless) distinguishable from a total one.
   int                 m_passWindowOk;
   int                 m_passWindowFail;
   //--- Consecutive regressing eras since the last new best - the patience counter for the checkpoint
   //--- restore / eta decay (see ETA_DECAY_PATIENCE_ERAS). Reset by any era that improves.
   int                 m_consecutiveRegressions;
   void                TrainHeartbeat(const string tag, int done, int total, const string shortLabel);
   //--- Progress of the pass currently running, and its name, for the simple panel. Published by each
   //--- pass through TrainHeartbeat rather than derived in the UI, because the UI cannot know which
   //--- pass owns the counters it can see - deriving it from pass 2's cursor is what made an entire
   //--- pass-1 scan display "100%".
   int                 m_passProgressPct;
   string              m_passLabel;
   //--- STALL REPORTER. Train() is a state machine with several early-return branches ABOVE the era
   //--- loop (OOS simulation walk, label prebuild, history sync, warm-up, cache invalidation), and
   //--- every one of them is silent. On 2026-08-10 four charts burned a core each for 15 minutes with
   //--- no journal output at all: the pass heartbeats proved the era loop was never reached, and no
   //--- prebuild completion line appeared either, so the work was in a branch that cannot say its own
   //--- name. Externals (per-thread CPU, file writes) cannot see inside one MQL5 thread, and the VPS
   //--- has no debugger - so the state machine has to report itself. m_lastEraCompleteTick is set at
   //--- every era end; when Train() is entered and that is stale, ReportTrainStall() names the branch
   //--- it is about to take, once per STALL_REPORT_INTERVAL.
   uint                m_lastEraCompleteTick;
   uint                m_lastStallReportTick;
   void                ReportTrainStall(const string branch);
   bool                m_haveOosCheckpoint;
   bool                m_oosStable;
   bool                m_objectiveMet;
   //--- RAW inputs to the family-wise deployment gate, snapshotted at the same instant as the checkpoint
   //--- so the test re-runs on the era that will actually ship rather than on whatever the latest era
   //--- happened to score. m_bestBalancedOos alone cannot serve: it is precision already multiplied by
   //--- the coverage credit, and the significance test needs the unweighted precision, the chance rate it
   //--- is measured against, and the call count that sets its standard error. -1 until the first ranked era.
   double              m_bestDirPrecPct;
   double              m_bestChancePrecPct;
   int                 m_bestDirCalls;
   //--- DECLUSTERED OOS tally: the calls that survive NMS, i.e. the ones that actually become positions
   //--- now that live NMS gates the trade (see RefreshLatestSignal). Every other OOS counter here scores
   //--- a population ~8x larger than the EA trades, so this pair is what "would I have made money" reads.
   //--- Era-scoped, reset with the rest of the OOS counters. The three *Nms* cursors are the replay state
   //--- for the same rule PruneDirectionalClusters and NmsLiveAccept use - kept separate from the LIVE
   //--- cursors so a training pass can never disturb the live chart's declustering.
   int                 m_oosNmsFired;
   int                 m_oosNmsHits;
   int                 m_oosNmsLastBuyIdx;
   int                 m_oosNmsLastSellIdx;
   int                 m_oosNmsKeptIdx;
   double              m_oosNmsKeptConf;
   ENUM_SIGNAL         m_oosNmsKeptDir;
   //--- How many eras the maximum was taken over - the N in the Sidak correction. Counts CANDIDATE eras
   //--- (coverage measurable and at least one directional call), not every era, because an era that
   //--- called nothing directional was never in the running to become the best and must not inflate N.
   //--- Run-scoped: reset with the rest of the best-checkpoint tracking at the top of a fresh run.
   int                 m_deployCandidateEras;
   //--- Upper-tail standard normal, Q(z) = P(Z >= z). Abramowitz & Stegun 26.2.17, |error| < 7.5e-8 -
   //--- self-contained rather than pulling in MQL5's Math\Stat, which this project has never included and
   //--- which drags a chain of headers behind it for the sake of one function.
   double              NormalUpperTail(double z);
   //--- THE GATE. Re-tests the checkpoint that is about to deploy against the null of the MAXIMUM over
   //--- m_deployCandidateEras eras, and reports the pieces so the log can show its working. See
   //--- DEPLOY_FAMILY_WISE_ALPHA. Returns false (refuse) whenever the inputs are missing.
   bool                BestCheckpointSurvivesSelection(double &zObs, double &pFamily, int &nTried);
   //--- Logs that verdict WITHOUT enforcing it, for the two deploy paths that are explicit operator
   //--- decisions (the era cap and the panel's Deploy button). Those stay the operator's call; this just
   //--- makes sure the log never lets an authorised deploy read as a validated one.
   void                ReportSelectionGateVerdict(string context);
   //--- Plateau ladder state (see the PLATEAU_* constants). m_erasSinceBestBalanced counts eras since
   //--- the last NEW BEST balanced accuracy; m_plateauStage is how far up the escalation it has climbed.
   //--- Both are run-scoped and deliberately NOT persisted, matching m_modelEta/m_bestBalancedOos, which
   //--- also restart fresh - a resumed run re-earns its patience rather than resuming mid-escalation.
   int                 m_erasSinceBestBalanced;
   int                 m_plateauStage;
   //--- IN-SAMPLE early-stop state (see IS_ERROR_IMPROVE_FRAC). Best training error seen this run and
   //--- eras since it last improved. -1 = nothing measured yet.
   double              m_bestIsError;
   int                 m_erasSinceBestIsError;
   //--- LATCHES when the IN-SAMPLE error stops improving, and it is a separate flag from m_plateauStage
   //--- for one measured reason: EnsembleEraVerdict mirrors the shared ladder onto every member with
   //--- `mm.m_plateauStage = g_ensPlateauStage` on EVERY era, purely so each member's status line reads
   //--- the collective stage. That display mirror was overwriting a DECISION. The IS stop set
   //--- m_plateauStage = PLATEAU_STAGE_DEPLOY, the next verdict stomped it back, and the stop re-fired
   //--- the era after - measured 2026-08-18: SP500 ConvLSTM printed IN-SAMPLE ERROR PLATEAU for 1,299
   //--- consecutive eras and reached era 1,398 without ever ending. That is the exact opposite of what
   //--- the stop is for: every one of those eras was scored out of sample and joined the family the
   //--- deploy gate corrects over, so the run spent fifteen hours RAISING its own bar.
   //--- One-way: set once, cleared only by a fresh run. Nothing in the ladder may reset it.
   bool                m_isErrorPlateaued;
   //--- Eras remaining in the current warm-restart boost window (see PLATEAU_RESTART_BOOST): set to
   //--- PLATEAU_PATIENCE_ERAS by each boosted restart, decremented by the era-end anneal that walks eta
   //--- back to the ceiling, cleared by any new best. Run-scoped and not persisted, same as the ladder
   //--- state above.
   int                 m_restartBoostErasLeft;
   //--- m_focalGammaRuntime removed 2026-07-31 with focal loss itself - see the removal note at the
   //--- former m_focalGamma above. The plateau ladder keeps its learning-rate warm restart, which was
   //--- always the actual escape; the gamma anneal beside it stepped monotonically to zero anyway.
   uint                m_syncWaitStartTick;  // 0 = not waiting on history sync; else GetTickCount() when the wait began
   //--- 3 no-op passes on a fresh start (see InitNeuralNetwork()/ResetWeights()), each its own separately-
   //--- scheduled Train() call (not a tight in-process loop), so the broker/terminal's history sync gets
   //--- several real, wall-clock-separated chances to finish before the era loop commits to a bar count.
   int                 m_warmupPassesRemaining;
   //--- fractal/swing-confirmation/trend-context Buy/Sell label cache: the label at a given now-relative
   //--- bar index only depends on price/ATR history, never on model state, so recomputing it every era
   //--- (as opposed to once per real bar close) is pure waste. Rebuilt fresh whenever `bars` changes
   //--- (see the invalidation check in Train()) rather than incrementally appended, since MQL5 timeseries
   //--- indices are relative to "now" and shift by one on every new candle - a full rebuild on change
   //--- sidesteps needing datetime-keyed/incremental bookkeeping entirely.
   //--- Filled in the same pass as the label caches below and gated by the SAME m_labelCacheHasValue, so
   //--- a bar either has both or neither and no third validity flag can drift out of step with them.
   double              m_excUpCache[];
   double              m_excDownCache[];
   //--- First-passage ladder, flat (idx * BARRIER_LADDER_COUNT + level). Value = bars AFTER the entry
   //--- bar at which travel first reached BARRIER_LADDER[level] in that direction; 0 = never within the
   //--- horizon. Sized and invalidated with the label caches and gated by the same m_labelCacheHasValue,
   //--- so a bar has all of it or none. See BARRIER_LADDER for why this exists and why the levels are
   //--- travel-from-entry rather than barrier prices.
   int                 m_ladderUpAt[];
   int                 m_ladderDownAt[];
   //--- Scratch for the bar TripleBarrierLabel is currently walking, published the same way m_lastExcUp
   //--- is and copied into the caches by AdvanceBarrierLabelState under the label's validity flag.
   int                 m_lastLadderUpAt[BARRIER_LADDER_COUNT];
   int                 m_lastLadderDownAt[BARRIER_LADDER_COUNT];
   //--- Reports expectancy for every ladder pair - see the definition. Measurement only; it does not
   //--- (yet) choose the geometry.
   void                ReportGeometryExpectancyScan(void);
   bool                m_labelCacheBuy[];
   bool                m_labelCacheSell[];
   //--- Per-bar outcome of each DIRECTION taken on its own, cached beside the label under the same
   //--- m_labelCacheHasValue flag. Not derivable from the label: Buy implies winLong, but the converse
   //--- fails on every both-won bar, and those are ~27% of the sample under the measured geometry. This
   //--- is what the deploy gate scores against - see m_oosWinLongTotal.
   bool                m_winLongCache[];
   bool                m_winShortCache[];
   bool                m_labelCacheHasValue[];
   int                 m_labelCacheBars;       // 0 = no cache built yet
   datetime            m_labelCacheAnchorTime; // m_Time.GetData(0) at last (re)build - 2nd invalidation key
   void                ComputeLabelForBar(int i, int bars, bool &buy, bool &sell);
   void                AdvanceBarrierLabelState(int i, int bars);
   //--- The triple-barrier verdict for one bar - the training TARGET. See BARRIER_TIE_GOES_TO_STOP.
   //--- `idx` is a now-relative index; the scan walks FORWARD in time, i.e. toward index 0, and needs
   //--- m_barrierHorizonBars of them to exist, so callers must keep idx >= m_barrierHorizonBars.
   //--- Returns Neutral for any bar it cannot resolve (no ATR, ran out of history), which is the same
   //--- answer as "no setup" and keeps the caller free of a third outcome to handle.
   ENUM_SIGNAL         TripleBarrierLabel(int idx);
   //--- Resolves the SL/TP ATR multiples the label uses from the EA's live SL_Mode/TP_Mode. Split out
   //--- because the INTELLIGENT modes scale with AI confidence, which does not exist at label time -
   //--- see the definition for why the label uses their zero-confidence base instead.
   void                BarrierMultiples(double &slMult, double &tpMult);
   //--- Long win-share at (sl, tp) from the first-passage ladder - the FULL horizon, not the excursion
   //--- cache's much shorter reference window. See the definition for why that distinction is load-bearing.
   //--- effSl/effTp report the rung pair actually measured, which is NOT the pair asked for: the ladder is
   //--- discrete. Callers that compare rungs to each other must log them - see the definition.
   double              LadderWinShare(const int &idxList[], int n, double sl, double tp,
                                      double &effSl, double &effTp);
   //--- Bars this (sl, tp) pair needs before its label means "target before stop" rather than "target
   //--- before stop OR 384 bars, whichever comes first". Identical arithmetic to
   //--- ComputeBarrierHorizonBars' swingMedian * slMult * tpMult, factored out so the scale ladder and
   //--- the horizon resolver cannot drift apart - the 2026-08-17 runaway shipped a geometry needing 613
   //--- bars while the expectancy scan was flagging that same pair as CLAMPED and disqualified.
   int                 RequiredHorizonBars(double slMult, double tpMult);
   //--- Bars it would actually GET: the above, clamped to [MIN, MAX] and snapped DOWN to the ladder.
   //--- These are two different numbers and conflating them is its own trap - the ceiling clamp is what
   //--- ReportGeometryExpectancyScan disqualifies with '!', but the snap-down truncates as well and is
   //--- silent about it (a pair needing 317 bars is granted 256). The scale ladder rejects on the
   //--- ceiling only, matching the scan, and REPORTS the granted figure so the shortfall is visible
   //--- rather than inferred.
   int                 SnapHorizonToLadder(int rawBars);
   int                 GrantedHorizonBars(double slMult, double tpMult);
   //--- Independent-observation count behind `rawN` overlapping triple-barrier labels. See
   //--- m_lastLabelLifespan for the measurement and for what an uncorrected n did to the operating point.
   double              EffectiveSampleSize(double rawN);
   //--- Mean bars-to-resolution over the label cache, or 1.0 before anything has been measured (which
   //--- makes EffectiveSampleSize the identity, i.e. the old behaviour, rather than a guess).
   double              MeanLabelLifespan(void);
   //--- Last era's deploy-gate arithmetic, published purely so the era line can state the bar rather
   //--- than leave it implicit. -1 = not computed this era. See where they are set in Train() for why a
   //--- gate has to publish its own threshold: an unreachable one is otherwise indistinguishable from a
   //--- merely unmet one, and this project spent two days reading the first as the second.
   double              m_lastEdgeFloorPct;
   double              m_lastPrecSE;
   double              m_lastEffN;
   //--- Mean bars-to-resolution at the rung LadderWinShare() last measured - a candidate geometry's
   //--- lifespan, readable without training on it. See the scale ladder's detectability column.
   double              m_lastRungLifespan;
   //--- CROSS-INSTRUMENT CERTIFICATION - see AIBase\PooledGate.mqh for why the deploy bottleneck is
   //--- certification rather than training, and why only the evidence pools while each symbol keeps its
   //--- own model, geometry and chance rate.
   void                PublishPoolRecord(double chancePct, double winPct, double effN);
   int                 ReadPooledEvidence(double &pooledExcessPp, double &seIndep, double &seCorr,
                                          string &detail);
   bool                PooledGatePasses(string &report);
   bool                m_poolWriteWarned;   // one-shot: a pool that cannot be written must say so
   //--- Last era's pooled verdict, cached for the era line. The pool is REPORTED, not folded into
   //--- tradeableOK: the local gate certifies THIS symbol's model, which is what actually trades, while
   //--- the pool answers the different question of whether the strategy has an edge at all. Letting a
   //--- cross-symbol result license a local deploy would ship a model that never cleared its own bar.
   bool                m_lastPoolPasses;
   string              m_lastPoolReport;
   //--- Break-even WITH the spread, which is the bar a model actually has to clear. The frictionless
   //--- SL/(SL+TP) is what every report quoted until 2026-08-17, and on SP500 H4 it read 64.3% while the
   //--- MEASURED zero-skill rate was 62.1% - a 2.2pp gap that is exactly the cost, and that made every
   //--- model look 2.2pp better than it was. A win nets (TP - spread), a loss costs (SL + spread).
   //--- Falls back to frictionless when m_spreadAtr is unset (a loaded model that has not re-derived).
   double              CostAdjustedBreakEvenPct(void);
   //--- Spread in ATR units, averaged over the IS bars - measured in ReportGeometryExpectancyScan, which
   //--- is the only place with both the ATR series and the label cache in hand. 0 = not yet measured.
   double              m_spreadAtr;
   //--- Median confirmed-ZigZag-leg length over the training window, snapped to the horizon ladder.
   int                 ComputeBarrierHorizonBars(int bars);
   //--- Resolves m_barrierHorizonBars exactly once per process, from live buffers. Needed on BOTH paths,
   //--- which is the whole reason it is not simply inlined in the prebuild: a DEPLOYED model never enters
   //--- Train(), so it never reaches StartLabelCachePrebuild() - yet OnlineLearnStep() reads the horizon
   //--- as its confirmation delay. Left unresolved there it would sit at BARRIER_HORIZON_FALLBACK and, on
   //--- any symbol whose real horizon is longer, backprop bars whose barriers had not actually resolved -
   //--- silent lookahead in the one place that writes to a live, trading model.
   void                EnsureBarrierHorizon(int bars);
   bool                m_barrierHorizonResolved;
   //--- full per-bar INPUT feature vector cache (everything BufferTempData() computes: ATR-normalized
   //--- OHLC, time-of-day encoding, volume delta, AD indicator buffers, ...). Same rationale as the
   //--- label cache above - a given now-relative bar index's feature vector only depends on price/
   //--- indicator history, never on model state, so recomputing it is pure waste: BufferTempData()
   //--- used to rebuild every bar from scratch once per historyBars-wide window it appears in, AND
   //--- again on every subsequent era on top of that. Flat array (idx*m_neuronsCount + feature),
   //--- not a true 2D array - MQL5 can't dynamically resize an inner dimension. Shares the label
   //--- cache's invalidation trigger (see EnsureBarCachesCapacity()) since both are keyed on the exact
   //--- same now-relative index frame.
   double              m_featureCache[];
   bool                m_featureCacheHasValue[]; // true once idx has a CACHED SUCCESS (f6150ee: only
                                                  // successes are ever cached - a miss is never stored,
                                                  // in any form; see BufferTempData's comment)
   bool                m_featureCacheValid[];    // paired flag, always true when HasValue is true -
                                                  // kept for the (currently unreachable) cached-miss
                                                  // shape so the cache layout survives f6150ee
   //--- Set by BufferTempDataCompute when it rejected a bar because the data had not ARRIVED yet
   //--- (price buffer EMPTY_VALUE, or an ATR the terminal has not finished calculating) as opposed to
   //--- the bar being genuinely unusable. BufferTempData reads it to decide whether the miss may be
   //--- cached - see both for why a wrongly-cached miss is unrecoverable and what it cost.
   bool                m_featureFailTransient;
   //--- WHICH BLOCK rejected the bar, and at which series index. Cleared per bar alongside
   //--- m_featureFailTransient and written only by a guard that actually returns false, so the healthy
   //--- path costs one string clear against ~52 feature computations and 60-odd Add() calls.
   //---
   //--- This is the line that four sessions of this bug did not have. The pass-1 stall report could say
   //--- "lookback slot 0 REJECTED (window had 24 of 832 values)" and no more, so which guard fired was
   //--- INFERRED - by counting 4 price + 5 swing + 4 range + 4 volume + 6 time + 1 ATR = 24 and
   //--- concluding feature 25 must be the MA. That arithmetic happened to be right and the conclusion
   //--- drawn from it ("the MA handle is short") was wrong five times running, because a value count
   //--- names a POSITION in the vector and the position does not tell you whether the block was cold,
   //--- capped, invalid or reading off the end. Name the block, and print the handle depths beside it.
   string              m_featureFailBlock;
   int                 m_featureFailIdx;
   //--- Why the LAST BuildFeatureWindow failed, so the pass-1 stall report can name a cause instead of
   //--- a count. Slot = which lookback position rejected (-1 = none did and the window was still
   //--- short); Total = how many values had been assembled when it gave up.
   int                 m_windowFailSlot;
   int                 m_windowFailTotal;
   bool                m_featureWidthWarned;    // one-shot: the width contract is a structural fault
   //--- One-shot feature-vector autopsy - see ReportFeatureHealth() for the two silent 2026-08-17
   //--- failures it exists to catch. Runs the first time pass 1 produces usable windows.
   void                ReportFeatureHealth(int bars);
   bool                m_featureHealthReported;
   bool                BufferTempDataCompute(int idx);
   //--- Nearest confirmed (non-repainting) ZigZag pivot at or after fromIdx - see this method's
   //--- definition comment and m_useSwingContext's declaration comment for the repainting-embargo
   //--- rationale callers must apply to fromIdx before calling this.
   bool                FindConfirmedZigZagPivot(int fromIdx, int &pivotIdx, double &pivotPrice, bool &pivotIsLow);
   bool                EnsureBarCachesCapacity(int bars);
   //--- Eager label-cache pre-build + true-label tally, run once per fresh start (see
   //--- m_warmupPassesRemaining) BEFORE era 0's real training loop begins. Without it, era 0 trains with
   //--- m_prevEraTrueBuyCount/Sell/Neutral all still 0, so UpdateClassPriors() has no measured
   //--- distribution and era 0 alone gets ZERO correction for label imbalance. Pre-scanning the whole IS
   //--- window upfront (reusing the same cache/ComputeLabelForBar() the era loop uses) lets era 0 start
   //--- from real measured class base rates.
   bool                m_labelCachePrebuilt;    // true once the one-time pre-scan has completed
   bool                m_labelPrebuildActive;   // true while a chunked pre-scan is in progress
   bool                m_prebuildSeedPending;   // true: era 0's era-start reset must NOT stomp the
                                                 // prebuild-seeded m_prevEraTrue* counts with the
                                                 // still-empty live tally (see Train()'s era-start block)
   int                 m_labelPrebuildBars;
   int                 m_labelPrebuildOosCutoff;
   int                 m_labelPrebuildIndex;
   int                 m_labelPrebuildBuyCount;
   int                 m_labelPrebuildSellCount;
   int                 m_labelPrebuildNeutralCount;
   void                StartLabelCachePrebuild(void);
   void                AdvanceLabelCachePrebuild(void);
   //--- Evaluation-only continual-learning OOS simulation: once the core model converges, a CLONE of its
   //--- weights (never the production Net itself) walks forward through the OOS window bar-by-bar,
   //--- scoring each bar with its current weights THEN learning from it - simulating how the model would
   //--- adapt in live/forward trading. This must never feed back into Net or the real OOS convergence
   //--- metric (dOosForecast/m_oosSamples), so it's tracked in entirely separate members and the clone is
   //--- discarded (never Save()'d) once each walk completes.
   CNet               *m_simOosNet;        // NULL when no simulation is active
   bool                m_simOosRunActive;
   int                 m_simOosCutoff;     // oosCutoff snapshot from the run that converged
   int                 m_simOosBarIndex;   // resume point, m_simOosCutoff-1 down to 0
   double              m_simOosForecast;   // smoothed accuracy - separate from dOosForecast
   int                 m_simOosSamples;
   void                StartOosContinualSimulation(int bars, int oosCutoff);
   void                AdvanceOosSimulationChunk(void);
   //--- ONE-SHOT pattern-database backfill (user request 2026-08-16): "the DB needs to be filled
   //--- during training so I do not have to run a backtest before deploying to live trading". Runs
   //--- once, right after FinalizeTrainRun() has restored the DEPLOYED weights, walking the OOS window
   //--- chronologically oldest->newest (same bounds pass 3 uses) and registering every fired call into
   //--- the SAME per-pattern/direction tables live voting writes to (RegisterSignal/PatternTableName) -
   //--- so UpdateSignalsWeights() has real win-rate history to rank on the instant the model goes live,
   //--- instead of only starting to accumulate it from real trades placed after deployment.
   bool                m_dbBackfillActive;
   bool                m_dbBackfillDone;      // one-shot per deployment - never re-armed by a later call
   int                 m_dbBackfillIndex;     // resume point, descends to 2 (mirrors pass 3's m_oosScoreIndex)
   int                 m_dbBackfillStartIndex;
   int                 m_dbBackfillStopIndex; // inclusive floor - the ranking slice's newest bar
   int                 m_dbBackfillBars;
   int                 m_dbBackfillFired;     // rows written, for the completion log line
   long                m_dbBackfillEra;       // era stamped into the .dbfill marker on completion
   void                StartPatternDatabaseBackfill(int bars, int totalIter, int oosCutoff);
   void                AdvancePatternDatabaseBackfill(void);
   //--- same resumability problem one level up: TuneIndicatorsAndTrain()'s own trial loop calls
   //--- Train() per trial and used to assume each call ran an entire trial to completion synchronously
   int                 m_tuneTrialIndex;     // -1 = no multi-trial tuning run in progress
   double              m_tuneBestOosForecast;
   bool                m_tuneLastTrialWasWin;
   bool                m_tuneHaveBestCheckpoint;
   datetime            m_tuneStartTrainBar;
   //=== Filter-based indicator auto-tuner (see TuneIndicatorsByFilter) =============================
   //--- Replaced a genetic + successive-halving search on 2026-08-01. That search scored every candidate
   //--- by TRAINING a throwaway network on it, which cost 1152 eras (9-48 h depending on topology) before
   //--- the real model started, and its short screening rungs could not separate candidates at all. The
   //--- filter scores candidates by the mutual information between the resulting FEATURES and the LABELS -
   //--- arithmetic over the feature cache, no training - so it finishes in seconds and its cost is
   //--- independent of topology. See TuneIndicatorsByFilter() for the measurements and the honest limit.
   bool                m_tuneFilterDone;      // the one-shot filter pass has run for this model
   //--- Mutual information between one feature column and the 3-class label, and the whole-vector score.
   double              FeatureColumnMI(const double &vals[], const int &labels[], int n);
   //--- Returns the MEAN per-feature marginal MI. Side-effects two more numbers that the mean alone
   //--- cannot express, both read by TuneIndicatorsByFilter's report - MQL5 forbids a default value on a
   //--- reference parameter, so members rather than out-params:
   //---   m_miBestColumn  - the STRONGEST single feature's MI. A mean over 26 columns hides one good
   //---                     column among 25 useless ones, which is exactly the case worth catching.
   //---   m_miLabelEntropy - H(Y) in nats for the sampled labels, so MI can be quoted as a FRACTION of
   //---                     what there is to know. "0.001 nats" means nothing on its own; "0.1% of the
   //---                     label's entropy" is a magnitude anyone can act on.
   double              ScoreCurrentParamsByMI(bool shuffleLabels = false);
   //--- The same work split in two, so the permutation test can extract the sample ONCE and reuse it for
   //--- every null draw. BuildMiSample returns the sample count (or -1); ScoreMiSample shuffles `labels`
   //--- in place when asked, so the observed statistic must always be taken before the first draw.
   //--- labelBarOffset != 0 takes the LABEL from bar i+offset while the features still come from bar i,
   //--- which is what the alignment scan needs. The sampled range is trimmed by MiShiftPad() at both
   //--- ends - a FIXED amount, never by |offset| - so every build enumerates the same bars in the same
   //--- order and two builds can be compared row by row. Returns -1 if the offset exceeds the pad.
   //--- `target` selects WHICH outcome the features are scored against (MI_TARGET_*). Anything other
   //--- than the barrier class is continuous and is discretised into 3 equal-frequency bins at the end
   //--- of the build, so every downstream consumer sees the same 3-class shape it already handles.
   int                 BuildMiSample(double &cols[], int &labels[], int labelBarOffset = 0,
                                     int featureBarOffset = 0, int target = MI_TARGET_BARRIER);
   //--- Is an "optimal SL/TP" head learnable? Scores the features against excursion magnitude and
   //--- asymmetry instead of the barrier class - a different question, see the definition.
   void                ReportExcursionInformation(void);
   //--- Sets the ATR multiples from the measured MFE/MAE quantiles instead of the mode enums. Returns
   //--- false (and leaves the configured pair standing) when there are too few resolved excursions.
   bool                DeriveBarrierGeometry(void);
   //--- LAG PROFILE: how far back the features still say anything about the entry they precede. Prints
   //--- MI at feature lag k = 0..m_historyBars against the same block-permutation null, and returns the
   //--- deepest lag that clears it - i.e. the lookback the data actually supports, rather than the 20 that
   //--- was picked by hand and never measured.
   //--- WHY THIS WAS MISSING AND WHY IT MATTERS: BuildMiSample samples ONE bar. Every "MI is at the noise
   //--- floor" verdict this codebase has produced therefore described the ENTRY BAR's features only, while
   //--- the network is fed m_historyBars of them. If information lived at lag 7 and not lag 0 the report
   //--- would have said "no signal" while the model could still learn - so the diagnostic we have been
   //--- deciding on had a blind spot exactly the width of the input vector.
   int                 ReportFeatureLagProfile(void);
   //--- Bars trimmed from each end of every MI sample. Must cover the largest offset any caller asks
   //--- for: the alignment scan's MI_ALIGN_MAX_SHIFT and the positive control's horizon/4. Expressed
   //--- once here so the control cannot drift out of agreement with the range it is sampled over -
   //--- which is precisely the failure this replaced.
   int                 MiShiftPad(void) const
     {
      //--- Also covers m_historyBars, because the lag profile shifts the FEATURES that far back and every
      //--- build must still enumerate the identical bar set (see BuildMiSample's fixed-pad note - padding
      //--- by the requested offset instead is what voided the positive control on 2026-08-02).
      return MathMax((int)MathMax(m_historyBars, 0),
                     MathMax(MI_ALIGN_MAX_SHIFT, MathMax(m_barrierHorizonBars, 1) / 4));
     }
   double              ScoreMiSample(const double &cols[], int &labels[], int n, bool shuffleLabels);
   //--- The permutation test + verdict, split out of the tuner so it is NOT gated on era 0 with it - see
   //--- the definition. Read-only; runs once per attach, whether or not the sweep did.
   void                ReportFeatureLabelInformation(void);
   //--- Smallest BarsCalculated() across the ENABLED tunable indicators, or -1 when none is on. A handle
   //--- created by IndicatorCreate() calculates asynchronously, so a candidate scored before its handle
   //--- has caught up is scored on an empty or partial buffer. The tuner reports this so "the parameter
   //--- change did not reach the features" can be told apart from "it reached them but they weren't ready".
   int                 TunableBarsCalculated(void);
   //--- Same number, plus HOW MANY tunable indicators were actually consulted. The two have to travel
   //--- together: -1 is returned both when nothing tunable is enabled (no cap, healthy) and when an
   //--- enabled handle answers INVALID (nothing readable at any index, fatal) - and the depth gate used
   //--- to collapse those into one silent `return want`, which is precisely why a build carrying the
   //--- full depth instrumentation logged nothing at all through a 38-minute two-chart outage.
   int                 TunableBarsCalculated(int &enabled);
   //--- Re-Create any ENABLED tunable indicator whose handle the terminal no longer recognises
   //--- (BarsCalculated() < 0). Returns true when something was actually rebuilt.
   //---
   //--- 2026-08-17, and this is the measured fault rather than a theory: XAUUSD H4, ConvLSTM reported
   //--- `Per-indicator depth: price=33982 MA=-1 ZigZag=33982 ATR=33982` - one dead handle, everything
   //--- else at full depth, while LSTM on the SAME chart read the same indicator fine and trained. So
   //--- the buffer was not short and the history was not missing: this member's handle had simply
   //--- stopped existing, some seconds after another member ran the 34-candidate indicator auto-tune
   //--- (whose inner loop is Create-then-IndicatorRelease over handles that all four members share,
   //--- because identical params return the same refcounted handle). WHY it goes invalid is NOT
   //--- established - IndicatorDepthReport() now prints handle NUMBERS so the next occurrence answers
   //--- that directly - but the recovery does not depend on knowing: a member that cannot read its own
   //--- indicator must rebuild it, not sweep 50k bars against a buffer that answers EMPTY_VALUE at
   //--- every index and then discard the era and do it again.
   bool                RepairDeadIndicatorHandles(void);
   //--- `want`, clamped to what the indicators can actually serve. THE single gate in front of every
   //--- ResizeBuffers() call site (train, live inference, chart rescan, research export).
   //---
   //--- Bars() is the PRICE series depth. A CUSTOM indicator's is not: MT5 calculates it in its own
   //--- context, bounded by Tools > Options > Charts > "Max bars in chart" (TERMINAL_MAXBARS), and
   //--- CopyBuffer() past that limit does not return a short read - it FAILS, so CDoubleBuffer keeps
   //--- NOTHING and EVERY index answers EMPTY_VALUE. m_MA (CiCustom, ADMovingAverage) is the only
   //--- custom indicator whose feature block REJECTS the bar on that (m_ADZigZag, also CiCustom,
   //--- neutral-fills; RSI/MACD/Ichimoku/ATR are built-ins, served on demand at any depth) - so the
   //--- symptom is feature 25 of every single bar failing while the 24 price features under it are
   //--- fine. Measured 2026-08-17 with contention ruled out (SP500 was at era 2552 throughout):
   //---   SP500  16,234 bars -> trains      XAUUSD 33,982 bars -> 0 of 33,966 windows, forever
   //---   XTIUSD 16,611 bars -> trains      USDJPY 50,179 bars -> 0 of 50,163 windows, forever
   //--- Returns `want` untouched when nothing is capping, so the no-cap path costs one min().
   int                 ServableBars(int want, string context);
   //--- ServableBars() with a WAIT in front of it, for the paths that can afford one (the training sweep
   //--- and the label prebuild). Returns >0 = the depth to use, or 0 = "not settled, come back later".
   //---
   //--- A short depth is not necessarily a final one: the terminal calculates and extends indicator
   //--- history asynchronously in response to being ASKED, so the request itself is the primer and the
   //--- answer can keep climbing for a while after it. Clamping to the first short reading therefore
   //--- risks pinning training to a partial history that was still growing. So: prime, then poll until
   //--- the count stops changing, and only then decide. Critically, NO SWEEP happens while waiting -
   //--- a 50k-bar feature sweep is what starved the indicator threads being waited on, which is how the
   //--- old failure sustained itself. Bounded by DEPTH_SETTLE_TIMEOUT_MS so a depth that never settles
   //--- still trains on what it has rather than waiting forever.
   int                 SettledBars(int want, string context);
   //--- Per-indicator BarsCalculated(), for the cap/priming/stall lines. The 2026-08-17 outage cost a
   //--- long diagnosis because the logs proved WHICH FEATURE died (feature 25, the MA block) but never
   //--- which HANDLE was short - so the cause had to be inferred, and was guessed wrong twice before
   //--- this existed. It answers that directly.
   string              IndicatorDepthReport(void);
   bool                m_miReportDone;
   //--- Eras the MI report has waited for the cross-asset panel to exist, so it describes the SAME
   //--- feature vector training uses. Bounded, so a terminal that never syncs the reference symbols
   //--- still gets its diagnostics rather than silently getting none.
   int                 m_miReportDeferrals;
   //--- Ranks every selectable SL/TP pairing by how much the SAME features say about THAT barrier
   //--- outcome at ENTRY time - see the definition. Read-only: it relabels a sampled copy, never the
   //--- label cache, and restores the barrier state it borrowed.
   void                ReportBarrierGeometryScan(void);
   //--- Scan overrides consulted by BarrierMultiples(). Both > 0 or neither applies; 0 = off. Live only
   //--- for the duration of ReportBarrierGeometryScan, and nothing persisted is keyed on them.
   double              m_barrierScanSlMult;
   double              m_barrierScanTpMult;
   //--- true => BuildMiSample computes each label with TripleBarrierLabel() instead of reading the cache,
   //--- because a hypothetical geometry's labels are by definition not cached.
   bool                m_barrierScanLiveLabels;
   //--- timed-out labels seen during one geometry's live relabel - see the scan's dir/to columns.
   int                 m_barrierScanTimeouts;
   //--- set by ComputeBarrierHorizonBars: this geometry needs MORE time than BARRIER_HORIZON_MAX allows,
   //--- so its label truncates a trade the EA would hold to SL/TP. Disqualifies it from the scan.
   bool                m_barrierHorizonClamped;
   double              m_miBestColumn;
   double              m_miLabelEntropy;
   //--- bars between two consecutive MI sample rows, set by BuildMiSample - see its note.
   int                 m_miStrideBars;
   //--- independent label blocks the permutation null was built from (rows within one barrier horizon
   //--- move together, so THIS - not the row count - is the sample size the p-value really rests on).
   int                 m_miNullBlocks;
   void                TuneIndicatorsByFilter(void);
   //================================================================================================
   void                FinalizeTrainRun(void);
   //--- The "this is now THE model" persistence sequence, shared by every deploy path so they can't
   //--- drift apart: weights (carrying the current m_trainingComplete flag), the pure-MQL5 inference
   //--- self-check, the calibration sidecar, and the EMA shadow. Callers set m_trainingComplete first -
   //--- the flag is written INTO the .nnw here. Used by FinalizeTrainRun() (ladder/era-cap/stop deploys)
   //--- and by DeployNow()/RetrainDeployed() (the panel buttons).
   void                PersistDeployedModel(void);
   //--- On hitting the per-run era cap: asks the operator whether to keep training (true) or deploy
   //--- the best checkpoint and stop (false). Headless (tester/optimizer) can't show a dialog, so it
   //--- returns false. See m_maxErasPerRun's declaration comment.
   bool                PromptContinuePastEraCap(double bestOos);
   //--- variables
   //--- training control, driven by the control panel (Warrior_EA.mq5); Train()/OnTickHandler
   //--- poll these rather than being torn down/rebuilt, so pausing/stopping never loses in-memory state
   bool                m_trainingPaused;        // true: Train() blocks between eras until unpaused
   bool                m_trainingStopRequested; // true: OnTickHandler stops scheduling new training passes
   //--- true for ANY Strategy Tester run - a single backtest AND every optimization pass (MQL_TESTER):
   //--- the run must NEVER train. It seeds the agent-local cache from the deployed production model (see
   //--- InitNeuralNetwork) and runs pure inference over the window - what a buyer expects from "backtest
   //--- my deployed EA", and what makes optimizing TRADING parameters (SL/TP, filters, MM) fast and
   //--- comparable (the AI is held fixed, not retrained per config). Training + online continual learning
   //--- happen only on a live chart, where this is false.
   bool                m_inferenceOnly;
   //--- true only when the current Net weights came from a saved .nnw on disk, not from a freshly-built
   //--- random topology. Used to let an inference-only tester replay a seeded model even if that model's
   //--- persisted trainingComplete flag is still false, while still blocking the "no model found, built a
   //--- fresh topology" path from placing random-weight trades.
   bool                m_modelLoadedFromDisk;
   //--- Set by EnforceTopologyContract() when a just-loaded .nnw was built by a superseded architecture
   //--- that cannot be repaired in place (currently: a different conv receptive field, whose weight
   //--- tensor is a different SHAPE). InitNeuralNetwork discards the load and retrains. A .nnw persists
   //--- the architecture, not just the weights - see AI\Network.mqh CNet::FirstConvWindow.
   bool                m_topologySuperseded;
   //--- true once ValidateCpuInference() has confirmed this model's pure-MQL5 forward pass matches the
   //--- compute backend's within tolerance (see CNet::SetCpuInference). Persisted in the .stats sidecar
   //--- so an inference-only backtest can run DLL-free; if false (e.g. a conv/LSTM topology not yet
   //--- ported, or a validation miss) the backtest falls back to the DLL. Measured at deploy on the
   //--- chart (where a backend exists to compare against), never in the tester itself.
   bool                m_mqlInferenceValidated;
   string              m_fileName;
   string              m_folderPath;
   //--- which file Train()'s Net.Save() calls (and this method's own Net.Load()) actually target:
   //--- the shared FILE_COMMON production weights normally, or a LOCAL per-agent cache file when
   //--- running inside the Strategy Tester/optimizer (see InitNeuralNetwork) so that repeated
   //--- optimization passes with an unchanged topology can reuse an already-trained model instead of
   //--- re-running every era from scratch, without ever touching the live production .nnw/.cfg.
   string              m_activeFileName;
   bool                m_activeFileCommon;
   //--- Name of the terminal-wide global variable this instance holds as an exclusive claim on
   //--- m_activeFileName, or "" when it holds none. See AcquireConfigLock().
   string              m_configLockName;
   //--- user-settable via Inputs.mqh's TrainingOptimizer (SGD or ADAM), read into this member at
   //--- construction. Honored by all three signal types - PAI/CONV via BuildFreshTopology(), and
   //--- LSTM via CSignalLSTM::AddCustomLayers - since CNeuronLSTMOCL (AI\Network.mqh) now has an
   //--- accelerated SGD+momentum path (LSTM_UpdateWeightsMomentum) alongside its original Adam-only
   //--- one, and CNet::CNet's GPU/DirectML init gate no longer restricts LSTM topologies to ADAM.
   int                 m_optimizationAlgo;
   int                 m_historyBars;
   //--- Input-window derivation for a NEW model (existing models adopt theirs from the .cfg): median
   //--- confirmed swing leg from raw highs/lows - strict local extrema over +/-WINDOW_SWING_WING bars,
   //--- alternation enforced - snapped down to {12,16,20,24,32}. Raw price, not the ZigZag indicator,
   //--- because this runs at init where custom indicators are still cold (see the cold-cache rule).
   int                 DeriveHistoryBars(void);
   int                 m_outputNeuronsCount;
   int                 m_minNeuronsCount;
   int                 m_initialNeuronsCount;
   int                 m_neuronsCount;
   double              m_neuronsReduction;
   int                 m_hiddenLayersCount;
   //--- LSTM-only recurrent hidden-unit count - see LstmHiddenSize's declaration comment
   //--- (Variables\Inputs.mqh). Harmless, unused constant contribution to m_fingerprint for MLP/CONV.
   int                 m_lstmHiddenSize;
   //--- CONV-only convolutional output-filter count - see ConvFilterCount's declaration comment
   //--- (Variables\Inputs.mqh). Harmless, unused constant contribution to m_fingerprint for MLP/LSTM.
   int                 m_convFilterCount;
   int                 m_minTrainYear;
   bool                m_isInitialized;
   //--- true once OnDeinit has begun - see MarkShutdown()/FinalizeTrainRun().
   bool                m_shutdownInProgress;
   int                 m_fractalPeriods;
   //--- "weights" of the 4 CONFIDENCE TIERS a live AI fire can land in (0-100 each), the AI equivalent
   //--- of classic indicators' several geometric m_pattern_N members. ConfidenceTier() buckets the
   //--- live confidence magnitude (CalibratedConfidenceMagnitude()) into 4 equal bands between the
   //--- HEAD'S OWN structural floor and 1.0 - 1/3 for the 3-class softmax, 0.5 for the regression head -
   //--- tier 0 = weakest possible directional call, tier 3 = near-certain. UpdateSignalsWeights()
   //--- (Expert\ExpertSignalCustom.mqh) then calibrates each tier's weight independently from its OWN
   //--- realized win rate, same as any classic pattern.
   //---
   //--- The defaults span the SAME 0-100 conviction scale the classic patterns use, and that is the
   //--- whole mechanism by which one Min vote to open governs both engines. Confidence is expressed as
   //--- vote strength rather than as a separate entry floor, so Min_Vote_Open reads directly as "which
   //--- tier is good enough", with no second scale to reason about:
   //---   25  tier 0  conf 0.333-0.500 (3-class) / 0.500-0.625 (regression)  - a bare plurality
   //---   50  tier 1  conf 0.500-0.667 / 0.625-0.750
   //---   75  tier 2  conf 0.667-0.833 / 0.750-0.875
   //---   100 tier 3  conf 0.833-1.000 / 0.875-1.000                          - near-certain
   //--- So Min_Vote_Open = 50 lets tier 1 and up trade when the AI votes alone, 75 lets tier 2 and up,
   //--- and so on. A near-coin-flip 0.34 argmax is NOT blocked at the AI boundary - it votes 25 and is
   //--- filtered by the vote threshold, exactly as a weight-10 classic confirmation would be. Note these
   //--- are only the DEFAULTS: with UseDatabaseRanking on, each tier's weight moves to its own measured
   //--- win rate, which is precisely why the tiers must be separate patterns rather than one continuous
   //--- confidence-to-weight formula - a formula would leave the ranking system nothing to calibrate.
   //---
   //--- This used to be a single m_pattern_0 covering every fire regardless of confidence. That was a
   //--- real bug, not just a missed opportunity: with only one pattern, UpdateSignalsWeights()'
   //--- averaging step collapses (average of one value is that value), so the SAME win rate got written
   //--- into both the pattern weight AND the module weight (filter.Weight()) - and Direction() multiplies
   //--- them together. A genuine 70%-win-rate model was therefore scored as (0.70*70)=49, not 70 - a
   //--- quadratic, not linear, derating that got harsher the further from 100% the model's real win rate
   //--- was. Classic indicators never hit this because their module weight blends across SEVERAL
   //--- differently-performing patterns, diluting any one pattern's own score instead of squaring it.
   //--- Splitting into 4 genuinely-different tiers restores that same blending for AI signals.
   //---
   //--- The constructor defaults are the 25/50/75/100 table above, NOT the 80/87/93/100 one this
   //--- paragraph used to quote. That older set was written when tier 0 still sat behind a confidence
   //--- floor and an alternation gate, so every tier arrived pre-filtered and belonged in the 80-100
   //--- band; both gates are gone (see LongCondition's comments), tier 0 is now a bare plurality, and
   //--- the table was rebased to span the full conviction scale so Min_Vote_Open can select a tier.
   //--- The stale numbers outlived the change by long enough to be quoted back as fact in a design
   //--- discussion - a second table in the same declaration block is exactly how that happens.
   //--- Ensemble mode uses the same shared weighted-vote path as a solo model; no quorum gate.
   int                 m_pattern_0, m_pattern_1, m_pattern_2, m_pattern_3;
   //--- TRAINING TARGET (Meta_Labeling_Design.md). 0 = per-bar direction via triple barrier (every
   //--- pre-2026-08-15 model); 1 = meta-labeling: one training row per JOURNALED CANDIDATE (a classic
   //--- pattern instance from the signal DB), binary label "did the trade this candidate proposes win
   //--- its triple barrier", 2-output softmax head (set once in CSignalMETA's constructor);
   //--- 2 = fractal direction: per-bar 3-class label = direction to the next confirmed fractal extreme
   //--- (TrainTargetFractal(), driven by the TrainingTarget input). Never mutated after configuration -
   //--- it feeds the fingerprint (|TGT:META1 / |TGT:FRA1 tokens) like any other identity-defining member.
   int                 m_trainTarget;
   //--- True when this signal runs as one of the AI_HYBRID ensemble's members - see EnsembleMember().
   bool                m_ensembleMember;
   //--- Slot in g_warriorEnsemble (registration order, -1 = not an ensemble member). Doubles as the
   //--- bit index in the combined-vote masks and the cursor index - see the registry's header comment.
   int                 m_ensembleIndex;
   //--- CONDITIONAL leg excursions for the fractal target's geometry (user request 2026-08-15:
   //--- "calculate MAE and MFE from a fractal to the next"). One sample per Buy/Sell-labeled IS bar,
   //--- recorded during the label prebuild by FractalDirectionLabel: favourable and adverse travel in
   //--- ATR units measured from the labeled bar's close over the LEG the label points at (every bar up
   //--- to and including the next fractal extreme), not over a fixed horizon. DeriveBarrierGeometry
   //--- reads its quantiles instead of the pooled every-bar excursions, so the stop/target are sized
   //--- for the bars the model actually trades. Safe against circularity ONLY because the fractal
   //--- label does not depend on SL/TP (the barrier label does - never feed it this path). Recording
   //--- stops once geometry is derived (the pair is pinned; later bars must not silently re-shape it).
   double              m_fracLegFav[];
   double              m_fracLegAdv[];
   int                 m_fracLegCount;
   void                RecordFractalLegExcursion(const double fav, const double adv)
     {
      if(fav <= 0.0 && adv <= 0.0)
         return;
      int cap = ArraySize(m_fracLegFav);
      if(m_fracLegCount >= cap)
        {
         cap += cap / 2 + 256;
         ArrayResize(m_fracLegFav, cap);
         ArrayResize(m_fracLegAdv, cap);
        }
      m_fracLegFav[m_fracLegCount] = MathMax(fav, 0.0);
      m_fracLegAdv[m_fracLegCount] = MathMax(adv, 0.0);
      m_fracLegCount++;
     }
   //--- This member's slot in the combined ensemble panel; claimed lazily on first publish (-1 = none).
   int                 m_ensemblePanelSlot;
   //--- Meta candidate store for the CURRENT era's bar grid, populated by MetaPrepareEra() (overridden
   //--- in CSignalMETA; empty and unused for direction models). MQL5 series indices shift on every new
   //--- closed bar, so these are re-resolved from the corpus' fixed bar TIMES at each era start -
   //--- same invalidation reasoning as the label caches.
   int                 m_metaCandBar[];        // series index of the candidate's fire bar
   char                m_metaCandSide[];       // +1 long / -1 short
   double              m_metaCandNetVote[];    // the firing filter's own vote margin (raw weight units)
   short               m_metaCandFamily[];     // 0=MA 1=RSI 2=MACD 3=Ichimoku
   short               m_metaCandPattern[];    // Pattern_N within the family
   int                 m_metaCandCount;
   //--- per-bar chain: m_metaCandHead[barIdx] -> first candidate id at that bar (-1 none),
   //--- m_metaCandNext[candId] -> next candidate at the same bar. Rebuilt with the store.
   int                 m_metaCandHead[];
   int                 m_metaCandNext[];
   //--- Candidate id for each pass-2 queue slot, parallel to m_isTrainQueue (see Training.mqh's
   //--- queueing block); -1 on every slot for direction models. Swapped in lockstep by the shuffle.
   int                 m_isTrainQueueCand[];
   //--- Per-family (0-3) and per-side (0=long 1=short) OOS decomposition of the meta head's era -
   //--- candidates / base wins / operating-point trades / wins among trades. The aggregate META line
   //--- can hide a deployable subset inside a blended 66%: measured 2026-08-13, 350 eras of real
   //--- +1-2pp ranking skill never cleared a 67.5% break-even IN AGGREGATE, and whether any family
   //--- or side clears it alone is exactly what this answers. Reset each era beside m_oosBuyFired.
   int                 m_metaFamCand[4], m_metaFamWins[4], m_metaFamFired[4], m_metaFamFiredWins[4];
   int                 m_metaSideCand[2], m_metaSideWins[2], m_metaSideFired[2], m_metaSideFiredWins[2];
   //--- functions
   virtual bool        InitIndicators(CIndicators *indicators);
   //--- sets ID/m_id/m_folderPath/m_fileName/m_pattern_count from the subclass constructor - defaults
   //--- to 4 (the confidence tiers - see m_pattern_0's declaration comment), not 1
   void                SetIdentity(string id, string shortId, int patternCount = 4);
   //--- hook for neuron-type-specific layers (Conv+Pool, LSTM, ...); default is a plain perceptron (no-op)
   virtual bool        AddCustomLayers(CArrayObj *topology) { return true; }
   //--- Reusable front-end stages, composed by the AddCustomLayers() overrides. Each subclass names the
   //--- stages it wants instead of re-declaring the CLayerDescription fields, so the topologies cannot
   //--- silently drift apart: HYBRID is *defined* as AddConvStage + AddLstmStage, which makes its
   //--- "matches the standalone CONV front-end exactly, then adds LSTM" contract structural rather than
   //--- a comment. (They had already drifted - HYBRID guarded the LSTM step with MathMax(1,...) and
   //--- CSignalLSTM did not, so a historyBars of 1 gave the two a different step.)
   bool                AddConvStage(CArrayObj *topology);
   bool                AddLstmStage(CArrayObj *topology);
   //--- Which front-end stages this subclass's AddCustomLayers() actually appends. Declared once per
   //--- subclass and consumed by everything that has to reason about the built shape (the LSTM capacity
   //--- budget, the startup config line), so those can never disagree with what was constructed. A
   //--- virtual rather than an AIType check, so a future composition cannot silently get the wrong answer.
   virtual bool        UsesConvStage(void) const { return false; }
   virtual bool        UsesLstmStage(void) const { return false; }
   //--- META-TARGET SEAMS (all no-ops for direction models; overridden only by CSignalMETA).
   bool                IsMetaTarget(void) const { return m_trainTarget == 1; }
   //--- FRACTAL TARGET (TrainingTarget input, 2026-08-15 user request: predict swing turns again).
   //--- The label is DIRECTION TO THE NEXT CONFIRMED FRACTAL EXTREME on every bar - the reference
   //--- library's per-bar extremum-direction target, ~balanced by construction. Chosen over ZigZag
   //--- pivots on the user's own point: a strict 5-bar fractal confirms only 2 bars after its extreme
   //--- (no repaint embargo, so labels resolve almost to the present) and fires ~5x more often, which
   //--- keeps the classes balanced without any of the 31:1 machinery the original "is this bar the
   //--- pivot" target needed (b4a704d). Everything else - the barrier walk, measured SL/TP geometry,
   //--- win caches, the era gate's realized-win scoring - runs unchanged, so the deploy decision still
   //--- prices the trade actually placed.
   bool                IsFractalTarget(void) const { return m_trainTarget == 2; }
   //--- Labels.mqh: fractal-direction label for one bar (overrides the barrier verdict in
   //--- AdvanceBarrierLabelState when IsFractalTarget()).
   ENUM_SIGNAL         FractalDirectionLabel(int idx);
   //--- Resolve the candidate corpus onto this era's bar grid (fills the m_metaCand* store). Called at
   //--- every era start, right after the bar grid is sized; returning false aborts the training run.
   virtual bool        MetaPrepareEra(const int bars) { return true; }
   //--- Append the per-candidate setup descriptor to TempData, AFTER BuildFeatureWindow() has filled
   //--- the shared bar window. The input layer is sized historyBars*features + MetaDescWidth(), so
   //--- every feedForward on a meta net MUST run this between window build and forward.
   virtual void        AppendCandidateFeatures(const int candId) {}
   //--- Width of that descriptor; 0 for direction models so NetInputWidth() stays byte-identical.
   virtual int         MetaDescWidth(void) const { return 0; }
   //--- The one true input width every feedForward guard compares against.
   int                 NetInputWidth(void) const { return (int)m_historyBars * m_neuronsCount + MetaDescWidth(); }
   //--- P(win) from the 2-output head's raw activations in TempData (after Net.getResults) - the
   //--- 2-class softmax collapses to a logistic over the logit difference. Same CLASS_LOGIT_SCALE the
   //--- training gradient applies, so the probability is the one the loss was optimizing. -1 = no data.
   double              MetaWinProbability(void)
     {
      if(TempData.Total() < 2)
         return -1.0;
      double z = CLASS_LOGIT_SCALE * (TempData.At(0) - TempData.At(1));
      return 1.0 / (1.0 + MathExp(-z));
     }
   //--- Triple-barrier outcome of the candidate's own side at its fire bar - the meta LABEL. Reads the
   //--- side-conditional win caches the label prebuild already computes for every bar; loss AND
   //--- timeout are both 0, matching the design ("win=1 / loss-or-timeout=0").
   bool                MetaCandidateWon(const int candId, const int barIdx)
     {
      if(barIdx < 0 || barIdx >= ArraySize(m_labelCacheHasValue) || !m_labelCacheHasValue[barIdx])
         return false;
      if(m_metaCandSide[candId] > 0)
         return (barIdx < ArraySize(m_winLongCache)) ? m_winLongCache[barIdx] : false;
      return (barIdx < ArraySize(m_winShortCache)) ? m_winShortCache[barIdx] : false;
     }
   //--- First candidate id at a bar (-1 none) / next in the same-bar chain.
   int                 MetaCandFirst(const int barIdx) const
     { return (barIdx >= 0 && barIdx < ArraySize(m_metaCandHead)) ? m_metaCandHead[barIdx] : -1; }
   int                 MetaCandNext(const int candId) const
     { return (candId >= 0 && candId < ArraySize(m_metaCandNext)) ? m_metaCandNext[candId] : -1; }
   //--- AddConvStage runs BEFORE AddLstmStage wherever both are present (HYBRID), so the LSTM is fed the
   //--- conv feature map rather than the raw flattened input.
   bool                HasConvBeforeLstm(void) const { return UsesConvStage() && UsesLstmStage(); }
   //--- Conv chain shape - see the definitions above AddConvStage. Every consumer reads these rather
   //--- than re-deriving the arithmetic, so the built topology and the logged shape cannot disagree.
   int                 ConvReceptiveFieldBars(void) const;
   int                 ConvFirstStagePositions(void) const;
   bool                HasSecondConvStage(void) const;
   int                 ConvOutputPositions(void) const;
   int                 ConvOutputWidth(void) const;
   //--- Actual input width the LSTM block sees, which is NOT always the flattened input.
   int                 LstmFanIn(void) const;
   //--- " | conv 21->8 x20 bars | lstm 160->32" for the startup config line; "" when neither applies.
   string              FrontEndConfigSummary(void) const;
   //--- Appends a batch-normalization layer, or does nothing (returning success) when EnableBatchNorm is
   //--- off. `units` is advisory only - CNet sizes the layer from whatever sits below it, because a conv
   //--- or pool stage's output width is derived inside the CNet constructor and is not knowable here.
   //--- See AI\NeuronBatchNorm.mqh for what the layer does and why it exists.
   bool                AddBatchNormStage(CArrayObj *topology, int units);
   //--- hardcoded activation for the common tapering Dense hidden-layer stack built by
   //--- BuildFreshTopology() (below AddCustomLayers, above the output layer). PRELU (leaky ReLU,
   //--- 0.01 slope) is the default: it doesn't saturate/vanish the way TANH does across a deep
   //--- taper, and is what the Conv layer itself already uses (see CSignalCONV::AddCustomLayers).
   //--- CSignalLSTM overrides this to TANH instead - these Dense layers sit directly on top of the
   //--- LSTM layer's own TANH-bounded ([-1,1]) output, so keeping them bounded too avoids feeding an
   //--- unbounded activation straight off a bounded recurrent output, which is untested territory
   //--- here and not what the user asked for ("Tanh for LSTM gates").
   virtual ENUM_ACTIVATION HiddenLayerActivation(void) { return PRELU; }
   //--- Single source of truth for the output head's activation. BuildFreshTopology() stamps it into a
   //--- NEW topology; EnforceTopologyContract() re-asserts it after every Load(), because a .nnw
   //--- persists the activation and would otherwise pin a superseded architecture forever (see
   //--- CNet::EnforceOutputActivation's declaration comment in AI\Network.mqh for the incident this
   //--- comes from). Deliberately one expression called from both places - when these were two separate
   //--- literals, changing the head in BuildFreshTopology() silently did nothing to any existing model.
   //--- Regression (1 output): TANH - its native [-1,1] range maps directly onto the -1/0/1
   //--- Sell/Neutral/Buy target convention. Classification (3 outputs): SIGMOID - see the long
   //--- rationale at BuildFreshTopology()'s use of this method for why the head must stay BOUNDED.
   ENUM_ACTIVATION     OutputLayerActivation(void) const { return (m_outputNeuronsCount == 1) ? TANH : SIGMOID; }
   //--- Width of the first dense layer, DERIVED rather than configured. It used to be an input
   //--- (FIRST_LAYER_NEURONS, default 500) whose only sensible value depends entirely on two things the
   //--- user cannot see: how wide the input vector ended up after feature selection, and how much
   //--- in-sample data the study period actually yields. Left to a hand-picked constant it was badly
   //--- wrong - 500 units against a 420-wide input is 210,500 weights, 72% of a 292,583-weight model,
   //--- against ~36,500 training bars of which only ~2,236 are directional. That is ~8 parameters per
   //--- sample, and it EXPANDS a set of highly correlated inputs instead of compressing them. The
   //--- symptom is already in the logs: the shallowest topology consistently beat the deepest, which is
   //--- what over-parameterization looks like from the outside.
   //--- Computed from the STUDY PERIOD rather than from bars currently downloaded, so the answer is a
   //--- deterministic function of the inputs and cannot drift as history fills in - and is then snapped
   //--- to a coarse power-of-two ladder so even a large error in the estimate lands on the same rung.
   //--- Every field it reads is already part of the weights-filename fingerprint, so the derived value
   //--- needs no fingerprint entry of its own. MUST be called before the fingerprint is built and never
   //--- again (see the note on fingerprint-feeding members at the top of this file).
   int                 ComputeFirstLayerWidth(void) const;
   //--- Expected in-sample training rows for the configured study period, split and timeframe. Factored
   //--- out of ComputeFirstLayerWidth so every derived capacity decision spends the SAME budget - three
   //--- stages each guessing at the training-set size independently is how they drift apart.
   double              EstimatedInSampleBars(void) const;
   //--- Conv output-filter count and LSTM hidden width, DERIVED for the same reason the first-layer width
   //--- is. Both were inputs whose defaults (16 filters, 32 units) were fixed constants picked without
   //--- reference to the input width they sit on or the data available to fit them - so on a minimal
   //--- feature set the conv stage EXPANDED the input, and the LSTM block quietly carried more weights
   //--- than the entire dense taper below it. Both MUST be called before the fingerprint is built and
   //--- never again: they assign fingerprint-feeding members (see the note at the top of this file).
   int                 ComputeConvFilterCount(void) const;
   int                 ComputeLstmHiddenSize(void) const;
   //--- Dense-taper DEPTH, derived 2026-07-30 from the two endpoints the taper connects. It was the depth
   //--- suffix on each AI_CHOICE entry (MLP_3L/MLP_4L/..._2L); asking a user to pick a layer count while
   //--- the code derives the widths those layers taper between is asking for half a decision. Reads
   //--- m_initialNeuronsCount, so it MUST be called after ComputeFirstLayerWidth and before the
   //--- fingerprint - see the note on fingerprint-feeding members at the top of this file.
   int                 ComputeHiddenLayerCount(void) const;
   //--- Re-assert everything about a just-loaded net that lives in the FILE but is owned by the CODE.
   //--- Call after every successful Net.Load(); no-ops (and stays silent) when the file already agrees.
   void                EnforceTopologyContract(void);
   //--- common network bootstrap: indicators, topology build/load, training-file bookkeeping
   bool                InitNeuralNetwork(CIndicators *indicators);
   //--- Exclusive per-config claim, so two charts can never train into one set of model files. Every
   //--- retrain-affecting input is already hashed into m_activeFileName, so "same file" IS "same
   //--- config" - which makes the filename the only correct lock identity. Live charts only: each
   //--- tester/optimizer agent is a separate process with its own sandboxed _optcache copy, and they
   //--- are *meant* to run the same config in parallel.
   bool                AcquireConfigLock(void);
   void                ReleaseConfigLock(void);
   void                DrawObject(datetime time, double signal, double high, double low);
   void                DeleteObject(datetime time);
   //--- Time-ordered NMS sweep over m_arrowSignalCache: prunes each same-direction run down to its
   //--- earliest bar (deleting redundant neighbors within m_signalClusterWindow). Run once per era end.
   void                PruneDirectionalClusters(int bars);
   //--- Whether BOTH directions can currently be traded, which is the precondition for the alternation
   //--- rule in the NMS paths: with only one side enabled there is no opposite signal to wait for, so
   //--- requiring alternation would suppress everything after the first call. This build has no
   //--- long-only/short-only input - the AI head emits both and nothing downstream restricts by side -
   //--- so it is constant true. Kept as a named predicate rather than folded away so the precondition
   //--- is stated where the rule reads it, and adding a direction restriction later has one place to
   //--- change instead of three call sites that silently assume both sides.
   bool                BothDirectionsTradeable(void) const { return true; }
   //--- Live newest-bar NMS accept test (time-keyed, idempotent per bar time - see m_signalClusterWindow).
   bool                NmsLiveAccept(datetime barTime, ENUM_SIGNAL dir, double conf)
     {
      if(m_signalClusterWindow <= 0)
         return true;
      if(dir != Buy && dir != Sell)
         return true;
      // Idempotent re-eval of the same bar (RefreshLatestSignal can run more than once per bar).
      if(dir == Buy && m_nmsLiveBuyTime == barTime)
         return m_nmsLiveBuyAccept;
      if(dir == Sell && m_nmsLiveSellTime == barTime)
         return m_nmsLiveSellAccept;
      long minGap = (long)m_signalClusterWindow * PeriodSeconds();
      datetime lastSame = (dir == Buy) ? m_nmsLiveBuyTime : m_nmsLiveSellTime;
      bool accept;
      // 1) Same-direction contiguous collapse: suppress if within the window of the previous SEEN
      // same-direction bar (advance last-seen below either way, so a whole run collapses to one).
      if(lastSame != 0 && (long)(barTime - lastSame) <= minGap)
         accept = false;
      else
        {
         // 2) Cross-direction resolution vs the last KEPT opposite signal: keep the stronger side.
         accept = true;
         if(m_nmsLiveKeptTime != 0 && m_nmsLiveKeptDir != dir &&
            (long)(barTime - m_nmsLiveKeptTime) <= minGap)
           {
            if(conf > m_nmsLiveKeptConf)
               DeleteObject(m_nmsLiveKeptTime);   // this bar is stronger: remove the weaker opposite arrow
            else
               accept = false;                    // the kept opposite is stronger: suppress this bar
           }
         // 3) ALTERNATION. Rule 1 only collapses a same-direction run inside the window; past it, a
         // second Buy is emitted with no Sell in between, giving Buy/Buy/Buy/Sell. When BOTH directions
         // are tradeable that sequence is the model re-entering a move it is already in, not finding a
         // new one. Require the kept sequence to alternate: the first signal of a run passes (nothing
         // to alternate with), and after that a direction only passes if the last KEPT signal was the
         // opposite one.
         // Gated on both directions being enabled - in a long-only or short-only configuration there
         // is no opposite signal to wait for, so this would suppress everything after the first.
         // NOTE this is deliberately a POST-PROCESSING rule, not a change to the label. The barrier
         // target has no "must flip" invariant - consecutive Buy labels are routinely correct - and an
         // earlier alternation gate was removed with the triple-barrier relabel for exactly that
         // reason. What alternates is what gets ACTED ON: arrows, the pass-3 declustered tally the
         // deploy gate grades, and the live trade.
         if(accept && BothDirectionsTradeable() && m_nmsLiveKeptTime != 0 && m_nmsLiveKeptDir == dir)
            accept = false;
        }
      if(dir == Buy)
        {
         m_nmsLiveBuyTime = barTime;
         m_nmsLiveBuyAccept = accept;
        }
      else
        {
         m_nmsLiveSellTime = barTime;
         m_nmsLiveSellAccept = accept;
        }
      if(accept)
        {
         m_nmsLiveKeptTime = barTime;
         m_nmsLiveKeptDir = dir;
         m_nmsLiveKeptConf = conf;
        }
      return accept;
     }
   int                 PurgeChart(void);
   ENUM_SIGNAL         DoubleToSignal(double value);
   //--- Shared status-label formatting for all three of Train()'s era passes (pass 1 sequential scan/
   //--- display, pass 2 shuffled backProp, pass 3 post-training OOS scoring) - see m_isTrainQueue's and
   //--- m_isPass2Active's declaration comments for why the era loop is now three passes instead of one.
   //--- Extracted so the panel keeps updating every bar throughout ALL three passes instead of freezing
   //--- during pass 2/3 the way it did when this was pass 1-only inline code - a stalled-looking panel
   //--- during a still-running era was reported as looking "stuck". Throttled internally (see
   //--- m_lastStatusLabelUpdateTick) - SetStatusLabel() (System\StatusLabel.mqh) does real text-layout
   //--- work (TextGetSize/WrapLineInto per line) AND an unconditional ChartRedraw(0) every call, which
   //--- gets slower as more chart objects accumulate over a long backtest. Calling it unconditionally
   //--- once per bar was already the existing (pass-1-only) behavior; doing that again independently in
   //--- pass 2 AND pass 3 roughly TRIPLED total ChartRedraw() calls per era and was the actual cause of
   //--- a training run observed taking 1.5+ hours without completing era 0 - not the shuffle itself.
   //--- forceRefresh=true bypasses the throttle below - used exactly once per era, right after the
   //--- era-end block (Train()) finalizes m_eraCount/dOosForecast, so the panel's "Era %d"/"OOS Acc"
   //--- fields update in the SAME moment the console's "training in progress - era N" line does.
   //--- Without it, the panel's last real redraw during a normal (throttled) bar-scan call happened
   //--- DURING pass 3, before m_eraCount++ - so it kept showing era N-1's number (with what was, by
   //--- then, already era N's near-final accuracy) for this era's entire duration, only catching up to
   //--- the correct era number once the NEXT era's own bar-scan calls started - a full one-era-behind
   //--- display lag relative to the console log, reported in practice.
   void                UpdateTrainingStatusLabel(const string &progressLine, double neuron0, double neuron1, double neuron2, double signalValue, bool forceRefresh = false);
   //--- Per-instance (NOT a function-local static - see CExpertSignalCustom::Direction()'s declaration
   //--- comment for why that distinction matters for a method shared across PAI/CONV/LSTM instances)
   //--- wall-clock throttle gate for UpdateTrainingStatusLabel()'s ChartRedraw().
   uint                m_lastStatusLabelUpdateTick;
   //--- Last values passed to UpdateTrainingStatusLabel() - cached (updated on EVERY call, throttled
   //--- or not) so the forced era-end refresh above has something real to redraw with instead of a
   //--- stale/zeroed placeholder, since no "current bar" exists once an era's own three passes are done.
   double              m_lastDisplayNeuron0, m_lastDisplayNeuron1, m_lastDisplayNeuron2, m_lastDisplaySignal;
   //--- Latest OOS Buy/Sell recall (-1 = n/a, same convention as logBuyRecallPct etc.), cached the same
   //--- way as m_lastDisplayNeuron0 above so UpdateTrainingStatusLabel() can show it on every call, not
   //--- just the era-end one that actually just computed it. Surfaced on-chart (not just the Experts
   //--- log) because a Buy/Sell-diluted-by-Neutral headline accuracy number is what a trader watching
   //--- the panel sees by default, but Buy/Sell recall is what actually predicts trading performance -
   //--- Neutral is "don't trade," so a model can look good on blended accuracy purely by calling Neutral
   //--- often, while its actual Buy/Sell calls are unreliable.
   int                 m_lastBuyRecallPct, m_lastSellRecallPct;
   //--- turns the classification output layer's 3 values (TempData[0..2], SIGMOID activation - see
   //--- BuildFreshTopology() - each already in [0,1]) into a softmax probability distribution in
   //--- place, and returns the signed dPrevSignal convention (+P(buy), -P(sell), 0.0 exactly for
   //--- neutral) used by both Train()'s live-forecast branch and RefreshLatestSignal(). Softmax is
   //--- monotonic per-element so it can't change which of the 3 wins - it only exists to turn the 3
   //--- independently-trained values into a normalized confidence. Max-subtracted before exp() for
   //--- numerical stability regardless (safe since softmax(x) == softmax(x - max(x))).
   double              ApplyClassificationSoftmax(void);
   //--- Post-hoc logit adjustment / prior correction: reads the raw softmax probabilities
   //--- ApplyClassificationSoftmax() just left in TempData[0..2] and returns the PRIOR-CORRECTED signed
   //--- decision (same +P'(buy)/-P'(sell)/0-neutral convention). This is the exact rule live trading
   //--- fires on and the rule the live-fired precision metric scores. See the definition for the math.
   double              AdjustedSignalFromSoftmax(void);
   //--- Margin between the winning class and its best rival, from the softmax already in TempData.
   //--- Returns <0 when the winner is Neutral (not a directional call, so no operating point applies)
   //--- or when the outputs are unreadable. This is the statistic the threshold is expressed in - NOT
   //--- the winning probability on its own, which moves with how confident the net is overall rather
   //--- than with how CLOSE the decision was, and would therefore drift as calibration changes.
   double              DirectionalMargin(void);
   //--- Reset / accumulate / fit, in the order the calibration walk calls them. See
   //--- DIR_CONF_THRESHOLD_BINS and DIR_CONF_CALIB_PCT_OF_IS.
   //--- EXCURSION-SIZE HEAD - see Expert\AIBase\Excursion.mqh. Predicts how FAR price travels, never
   //--- which way; Stage 1 measures whether it beats a constant ATR multiple and places no orders.
   bool                ExcursionBuildTopology(CArrayObj &topology);
   bool                ExcursionEnsureHead(void);
   bool                ExcursionTargets(int idx);
   void                ExcursionTrainStep(int idx);
   void                ExcursionScoreStep(int idx);
   void                ExcursionTrailPush(void);
   void                ExcursionResetEraScores(void);
   double              ExcursionQuantile(bool upward, double tau);
   void                ExcursionReport(void);
   void                ResetDirConfHistogram(void);
   void                AccumulateDirConfSample(double margin, bool wasCorrect, bool isPrimaryBar);
   void                FitDirConfThreshold(void);
   //--- CALIBRATION BAND BOUNDS, in pass-1 bar indices (0 = newest bar, so LARGER index = OLDER).
   //--- The era's bars lay out, newest to oldest:
   //---
   //---   [0, oosCutoff)                              OOS - graded by pass 3, never trained on
   //---   [oosCutoff, calibLo)                        purge - one label horizon, discarded entirely
   //---   [calibLo, calibHi)                          CALIBRATION - fits the threshold, never trained
   //---                                               on, never graded by pass 3, never seen by the
   //---                                               deploy gate. ALSO the pattern-DB backfill's
   //---                                               source (see StartPatternDatabaseBackfill)
   //---   [calibHi, calibHi + horizon)                purge - one label horizon, discarded entirely
   //---   [calibHi + horizon, ...)                    IS - the backprop queue
   //---
   //--- A purge on BOTH sides, not just the OOS one: a triple-barrier label is decided by the horizon
   //--- bars that FOLLOW its bar, so without the far-side purge the newest training bars would carry
   //--- labels partly determined by price action inside the calibration slice - the same Lopez de Prado
   //--- ch. 7 leak the OOS boundary already guards against, and it would put the memorization straight
   //--- back into the curve this slice exists to keep clean.
   int                 CalibPurgeBars(void) const { return (int)MathMax(m_barrierHorizonBars, 1); }
   int                 CalibLoIndex(int oosCutoff) const { return oosCutoff + CalibPurgeBars(); }
   //--- Zero (an empty band) whenever the era is too short to carve one without eating the training set;
   //--- callers must treat that as "no calibration this era" and leave the threshold where it is.
   int                 CalibBandBars(int totalIter, int oosCutoff) const
     {
      int isSpan = totalIter - CalibLoIndex(oosCutoff) - CalibPurgeBars();
      if(isSpan <= 0)
         return 0;
      return (int)(isSpan * (DIR_CONF_CALIB_PCT_OF_IS / 100.0));
     }
   int                 CalibHiIndex(int totalIter, int oosCutoff) const
     { return CalibLoIndex(oosCutoff) + CalibBandBars(totalIter, oosCutoff); }
   //--- EMA-updates the persisted true class base rates (m_priorBuy/Sell/Neutral) from a just-finished
   //--- era's true class counts. No-op on an empty/degenerate tally.
   void                UpdateClassPriors(long buyCnt, long sellCnt, long neutralCnt);
   //--- Installs tau*log(prior_c) on Net from the freshly measured priors. Called once per era
   //--- start, straight after UpdateClassPriors, so the offsets track the same distribution the
   //--- era is scored against. No-op (and actively clears stale offsets) when the input is off.
   void                ApplyLogitAdjustment(void);
   //--- Small binary sidecar (fileName + ".stats") persisting the calibration state that must survive a
   //--- restart for live trading to behave like training: the true class priors and m_confidenceCalScale.
   bool                SaveModelStats(string fileName, bool common);
   bool                LoadModelStats(string fileName, bool common);
   //--- Deploy-time (chart, backend present) self-check: runs the just-saved deployed model through both
   //--- the backend and a temporary pure-MQL5 (CNet::SetCpuInference) clone on the same input window and
   //--- returns true only if the outputs match within CPU_INFERENCE_MAX_DIFF. Gates whether an
   //--- inference-only backtest may run DLL-free. Fails safe (returns false) on any error/mismatch or an
   //--- architecture whose CPU path isn't ported yet - the caller then keeps the model on the DLL path.
   bool                ValidateCpuInference(void);
   //--- Build the panel's "Buy/Sell accuracy: IS x% OOS y%" line (directional win-rate, Neutral excluded)
   //--- from the cumulative counts (m_cumIsCorrect etc.); returns "...: measuring..." until at least one
   //--- directional call has been validated. Shared by the training and live/complete simple panels.
   string              ComputeCompoundedAccuracyLine(void);
   //--- Persist/restore the drawn directional arrows (the "WarSig_" objects) to a sidecar file so they
   //--- survive an EA remove/re-add, recompile, or restart WITHOUT a retrain - the chart objects are
   //--- destroyed on unload (destructor PurgeChart) and OnInit has no other way to bring them back.
   //--- Stores each arrow's time/code/price and its hide state (OBJPROP_TIMEFRAMES), so the show/hide
   //--- toggle is preserved too. Chart-only (a backtest has no persistent chart to restore to).
   bool                SaveChartSignals(bool pruneChartObjects = true);
   void                LoadChartSignals(void);
   //--- The shutdown half of that pair: persist, THEN clear the chart, and report both counts. See the
   //--- definition for why the order is fixed and why the clear is conditional on the write.
   void                PersistAndClearChartSignals(void);
   //--- How many arrows the last successful SaveChartSignals() wrote - reporting only.
   int                 m_lastArrowsSaved;
   //--- One-shot latch for PurgeChart()'s "saved N but the chart holds none" warning. PurgeChart runs
   //--- twice on a clean removal - once from the shutdown path and again from the destructor, which is
   //--- deliberate (the destructor covers teardowns that never reach OnDeinit) - and the second call
   //--- necessarily finds an already-emptied chart with m_lastArrowsSaved still set. Without this latch
   //--- that harmless second pass would report the discrepancy every single time and train the reader
   //--- to ignore the one case where it is real.
   bool                m_purgeMismatchWarned;
   //--- Wipe this model's drawn arrows AND their .arrows sidecar, plus any deferred restore still in
   //--- flight. Call from every path that discards or replaces the trained weights - see the definition
   //--- for why leaving them behind resurrects a dead model's calls through SaveChartSignals.
   void                ClearPersistedChartSignals(const string reason);
   //--- Deferred ("async") half of LoadChartSignals: LoadChartSignals only PARSES the sidecar into the
   //--- m_arrowRestore* buffers (an ~80KB read - instant) and returns, so OnInit never blocks; this then
   //--- creates the chart objects in ARROW_RESTORE_BUDGET_MS slices, driven by the same 500ms timer that
   //--- already paces training. MQL5 has no threads - a chart runs one thread - so blocking OnInit is what
   //--- made the terminal look frozen (no panel, no status label, no journal) while ~2900 arrows were
   //--- rebuilt. Time-boxed slices give the terminal room to paint the UI between them instead.
   void                AdvanceChartSignalRestore(void);
   //--- parsed-but-not-yet-drawn arrows, consumed by AdvanceChartSignalRestore (see above)
   datetime            m_arrowRestoreTime[];
   int                 m_arrowRestoreCode[];
   double              m_arrowRestorePrice[];
   long                m_arrowRestoreTf[];
   int                 m_arrowRestoreIndex;
   bool                m_arrowRestorePending;
   uint                m_arrowRestoreStartMs;
   //--- Deferred ("async") half of StartChartSignalRescan (public, defined inline further down): drains
   //--- the per-bar inference loop in ARROW_RESTORE_BUDGET_MS slices off PollTraining's timer instead of
   //--- blocking the button-click handler for however long a full lookback scan takes. Internal-only -
   //--- called from PollTraining(), never from outside the class - so this stays protected while
   //--- StartChartSignalRescan()/RescanPending() (which the panel button needs) are public.
   void                AdvanceChartSignalRescan(void);
   int                 m_rescanIndex;
   int                 m_rescanHi;
   int                 m_rescanBarsNow;
   bool                m_rescanPending;
   uint                m_rescanStartMs;
   //--- Raw (PRE prior-correction) argmax tally, accumulated per-bar across AdvanceChartSignalRescan's
   //--- slices - lets the completion log distinguish "the network itself calls Neutral almost everywhere"
   //--- from "the network still discriminates, but AdjustedSignalFromSoftmax's logit-prior correction is
   //--- suppressing it down to Neutral" - both produce an identical all-Neutral m_arrowSignalCache/empty
   //--- chart otherwise.
   int                 m_rescanRawBuy;
   int                 m_rescanRawSell;
   int                 m_rescanRawNeutral;
   bool                ResizeBuffers(int barIndex);
   bool                RefreshData();
#ifdef WARRIOR_EXPORT_FEATURES
   //--- RESEARCH BUILD ONLY, never compiled into a shipped binary. Dumps exactly what the network sees -
   //--- one row per bar: index, time, OHLC, ATR, then the m_neuronsCount feature values - to a CSV under
   //--- Common\Files\Warrior_EA\Research\. Exporting the RAW BARS alongside the features is the point:
   //--- with OHLC+ATR in hand every barrier geometry, horizon and in-trade target can be recomputed
   //--- offline, so a research question costs seconds in Python instead of a compile/attach/read cycle.
   void                ExportFeatureMatrix(void);
   //--- Raw OHLCV for a grid of symbols/timeframes - see the definition for why the grid is worth more
   //--- than the engineered features on their own.
   void                ExportRawRates(void);
#endif
   bool                BufferTempData(int idx);
   //--- Assembles the full m_historyBars-wide input window ending AT bar r into TempData, OLDEST BAR
   //--- FIRST. Use this everywhere instead of hand-rolling the loop: the chronological order is load-
   //--- bearing for the LSTM/HYBRID stacks and cannot be enforced by convention across eight call
   //--- sites. See the definition comment in AIBase\Features.mqh for the measurement behind that.
   bool                BuildFeatureWindow(int r);
   //--- shared by OnTickHandler() and the timer-driven PollTraining() - see definition
   void                ScheduleTrainingIfNeeded(void);
   void                Train(datetime StartTrainBar = 0);
   //--- the training window's start time - shared by Train()'s era start and the label-cache pre-scan
   datetime            TrainWindowStart(datetime startTrainBar);
   //--- outer loop around Train(): when AutoTuneIndicators is on, tries randomized AD indicator
   //--- input variations across m_indicatorTuneTrials calls to Train(), keeping the best-OOS one
   void                TuneIndicatorsAndTrain(datetime StartTrainBar = 0);
   //--- recomputes dPrevSignal/chart arrow for the newest CLOSED bar (bar 1 - see the definition's
   //--- 2026-08-11 parity comment); used after restoring a checkpointed model at the end of Train()
   //--- so the live signal matches the deployed weights. Returns false when the window failed to
   //--- build (dPrevSignal is zeroed, caller should not advance its new-bar watermark).
   bool                RefreshLatestSignal();
   //--- inference-only "new bar" handler used once m_trainingComplete is true - see
   //--- ScheduleTrainingIfNeeded()'s declaration comment for why this must NOT call Net.backProp()
   void                RefreshConvergedSignal(void);
   //--- Online continual-learning step (live chart only) - see its implementation comment and the
   //--- ONLINE_LEARN_* tunables. Backprops the deployed Net on bars whose ZigZag label has just become
   //--- CONFIRMED (m_swingConfirmationBars matured), then blends the shadow under a rolling-accuracy
   //--- guardrail. No-op in the tester/optimizer (m_inferenceOnly) and while training is active.
   void                OnlineLearnStep(void);
   //--- Alpha-balanced focal sample weight (Lin et al. 2017 eq. 5) for ONE streamed bar - see the
   //--- ONLINE_LEARN_* block's CLASS IMBALANCE comment for the derivation. Shared deliberately by
   //--- OnlineLearnStep() (the live path) and AdvanceOosSimulationChunk() (the simulation of that
   //--- path): the simulation's reported accuracy is only a valid forecast of live continual-learning
   //--- behaviour if it optimises the IDENTICAL objective, so the formula must exist in exactly one
   //--- place. p* are this bar's pre-update softmax probabilities, already normalised in place by
   //--- ApplyClassificationSoftmax(). Returns 1.0 for the regression head (no class structure).
   double              OnlineSampleWeight(ENUM_SIGNAL trueSignal, double pBuy, double pSell, double pNeutral);
   //--- lazily bootstraps m_shadowNet if it's still NULL: tries loading a persisted shadow file
   //--- first (continuity across EA restarts), falling back to cloning Net's current weights (via
   //--- the same Save()/Load() pattern StartOosContinualSimulation() uses for m_simOosNet) if no
   //--- compatible shadow file exists yet. No-op if m_shadowNet is already valid. See m_shadowNet's
   //--- declaration comment for the full EMA shadow-weight deployment rationale.
   void                EnsureShadowNet(void);
   //--- persists m_shadowNet alongside every Net.Save() call, using the same run metadata (error/
   //--- undefine/forecast/era/trainingComplete/indicator params) the caller already computed for
   //--- Net.Save() itself - see m_shadowNet's declaration comment. No-op if the shadow isn't
   //--- bootstrapped yet.
   void                SaveShadowNet(const double &indicatorParams[]);
   //--- method of initialization of the indicators
   bool              InitOpen(CIndicators *indicators);
   bool              InitClose(CIndicators *indicators);
   bool              InitHigh(CIndicators *indicators);
   bool              InitLow(CIndicators *indicators);
   bool              InitVolumes(CIndicators *indicators);
   bool              InitTime(CIndicators *indicators);
   //--- addToCollection=false is used by ReInitADIndicators() to rebuild an already-collected
   //--- handle's params (here: a re-tuned period) without re-adding the (same) pointer into
   //--- indicators a second time
   bool              InitMA(CIndicators *indicators, bool addToCollection = true);
   bool              InitRSI(CIndicators *indicators, bool addToCollection = true);
   bool              InitMACDFeature(CIndicators *indicators, bool addToCollection = true);
   bool              InitIchimoku(CIndicators *indicators, bool addToCollection = true);
   bool              InitADCumulativeDelta(CIndicators *indicators, bool addToCollection = true);
   bool              InitADShorteningOfThrust(CIndicators *indicators, bool addToCollection = true);
   bool              InitADWyckoffEventStream(CIndicators *indicators, bool addToCollection = true);
   bool              InitADWyckoffFailedStructure(CIndicators *indicators, bool addToCollection = true);
   bool              InitADWyckoffSignificantBarInversion(CIndicators *indicators, bool addToCollection = true);
   bool              InitADZigZag(CIndicators *indicators, bool addToCollection = true);
   //--- common=false targets a LOCAL (non-shared) file - used by the tester/optimizer per-agent
   //--- weight cache so cross-pass reuse never touches the production FILE_COMMON config/weights.
   bool              SaveTopologyConfiguration(string fileName, int initialNeuronsCount, int hiddenLayersCount, double neuronsReduction, int minNeuronsCount, int optimizationAlgo, int historyBars, int outputNeuronsCount, int neuronsCount, int studyPeriod, int minTrainYear, bool isInitialized, int stopTrainWR, int fractalPeriods, int convFilterCount, int lstmHiddenSize, bool common = true);
   //--- The four DERIVED shape fields are by REFERENCE and are ADOPTED from the .cfg, not compared
   //--- against it. See the block in the definition for why a derived value must never be able to
   //--- mismatch: it is measured from data that legitimately changes, and a mismatch here discards
   //--- a trained model. studyPeriod left the parameter list entirely - the input is gone; its
   //--- on-disk slot is still read positionally and ignored, like the retired MinWR slot.
   bool              LoadAndCompareTopologyConfiguration(string fileName, int &initialNeuronsCount, int &hiddenLayersCount, double neuronsReduction, int minNeuronsCount, int optimizationAlgo, int &historyBars, int outputNeuronsCount, int neuronsCount, int minTrainYear, bool isInitialized, int stopTrainWR, int fractalPeriods, int &convFilterCount, int &lstmHiddenSize, bool common = true);
   //--- Retry helpers for the tester/opt seed-copy race: a live chart's own atomic Save() (write .savetmp,
   //--- then FileMove() over the real file) can hold the source or destination file for a moment, and a
   //--- concurrent FileCopy/FileOpen from a Strategy Tester agent reading the SAME production file can hit
   //--- a transient Windows sharing violation in that narrow window. Both retry a handful of times with a
   //--- short pause rather than silently treating a transient lock as "no model"/"corrupt file" - see their
   //--- call sites in InitNeuralNetwork.
   bool              CopyFileWithRetry(string srcFileName, string dstFileName);
   bool              CopySharedFile(string srcFileName, string dstFileName, bool quiet);
   bool              LoadNetWithRetry(double &indicatorParams[]);
   //--- input data
   bool                m_useVolumes;
   bool                m_useTime;
   bool                m_useATR;
   //--- Uses its own period (m_indicatorTuner.maPeriod), fed as ATR-normalized OHLC distance-from-MA
   //--- (4 values, same convention as the base close-open/high-open/low-open features) plus the MA's
   //--- own bar-over-bar change (1 value, ATR-normalized like every other price-domain feature here -
   //--- not volume's previous-bar-ratio scheme, since a moving average lives in price units and
   //--- already has ATR as its natural scale reference). See BufferTempDataCompute()'s m_useMA block
   //--- for the exact 5 values. maPeriod starts equal to the Classic Signals PeriodMA input (see
   //--- CADIndicatorTuner's constructor) but may diverge from it once AutoTuneIndicators searches a
   //--- trial - the Classic Signals MA vote itself is untouched by that search, since it needs no
   //--- training/warm-up and there is nothing for a tuning trial to validate it against.
   bool                m_useMA;
   //--- RSI is already a 0-100 oscillator, so the only transform needed is /100 to match every other
   //--- feature's roughly [-1,1]/[0,1] scale - no ATR or distance normalization applies. See
   //--- BufferTempDataCompute()'s m_useRSI block for the exact value. Same maPeriod/rsiPeriod
   //--- divergence-from-the-Classic-Signals-input note as m_useMA above applies to rsiPeriod.
   bool                m_useRSI;
   //--- MACD as 3 ATR-normalized values (main line, signal line, histogram) - see
   //--- BufferTempDataCompute()'s m_useMACD block. Deliberately kept to 3 despite MACD being cheap: the
   //--- point of adding it next to m_useMA is the SECOND timescale (m_useMA supplies exactly one moving
   //--- average) and the histogram, which is the only acceleration term anywhere in the feature vector -
   //--- the level information itself is already covered by the MA distances. ATR-normalized rather than
   //--- left raw because the MACD lines live in price units, exactly like the MA feature.
   bool                m_useMACD;
   //--- Ichimoku as 8 values - see BufferTempDataCompute()'s m_useIchimoku block for each. This is the
   //--- widest single classic-indicator feature here and it earns that width by carrying multi-timescale
   //--- support/resistance GEOMETRY (three lookbacks plus a forward-projected cloud) that nothing else in
   //--- the vector encodes: the swing-context block's confirmed pivots are >=m_swingConfirmationBars bars
   //--- stale by construction, and its Donchian/SMA values are single-scale.
   //--- LOOKAHEAD - MT5's iIchimoku stores raw per-bar values and shifts only the DRAWING, so the cloud
   //--- sitting under bar idx is SenkouSpan*(idx + ichiKijun), and the Chikou value plotted at bar idx
   //--- would be Close(idx - ichiKijun) - a FUTURE bar. The feature block applies the +Kijun offset and
   //--- never calls ChinkouSpan(); Signals\SignalIchimoku.mqh's class comment documents the buffer
   //--- convention in full, and the same reasoning governs both.
   bool                m_useIchimoku;
   //--- Normalized ZigZag swing-context features: 5 confirmed-pivot values (direction/magnitude/age of
   //--- the last CONFIRMED swing) plus 4 recent-price-action values (Donchian range position at 20/50
   //--- bars, 20-bar return, 20-bar SMA extension) that give fresh, non-repainting trend/position
   //--- context the >=100-bar-stale pivot anchor can't - see BufferTempDataCompute()'s m_useSwingContext
   //--- block for the exact 9 values. Reads the same
   //--- m_ADZigZag the training labels already come from (see that member's declaration comment) rather
   //--- than a separate indicator instance - NOT gated behind AutoTuneIndicators/ReInitADIndicators like
   //--- the AD* indicators below, since m_ADZigZag itself is deliberately never tuned (same reason as
   //--- the label side: tuning the ground truth alongside the model scored against it would let a trial
   //--- cherry-pick an easier target). Critical correctness constraint, not just a style choice: ZigZag's
   //--- most recent 1-3 legs repaint (see m_swingConfirmationBars' declaration comment), so every read of
   //--- m_ADZigZag for THIS feature - exactly like the label side - must only trust a pivot that is
   //--- already at least m_swingConfirmationBars bars old relative to the bar the feature is being
   //--- computed for. Skipping that embargo would leak future information a live bar couldn't actually
   //--- have had yet - silent lookahead bias inflating backtest/training performance without being real.
   bool                m_useSwingContext;
   //--- see System\NewsRelevance.mqh's declaration comment for what this feature actually encodes
   //--- (event proximity + impact, not actual-vs-forecast deviation) and why the forward-looking half
   //--- of it isn't lookahead bias.
   bool                m_useNews;
   int                 m_newsFeatureWindowMinutes;
   //--- Cross-asset panel: the only feature block here whose inputs are NOT a transform of this
   //--- symbol's own OHLCV series. See System\CrossAsset.mqh for the reasoning; in short, every other
   //--- feature the network sees is a function of one price series, and that whole family measured at
   //--- the noise floor, so the panel exists to give it information a single series cannot contain.
   //--- Built ONCE per training run (BuildCrossAssetPanel) rather than per bar - a per-bar cross-symbol
   //--- lookup would be pairs x bars iBarShift calls.
   bool                m_useCrossAsset;
   CCrossAssetPanel    m_crossAsset;
   bool                BuildCrossAssetPanel(int bars);
   //--- Train->serve parity for the panel (2026-08-11): the pair set is a MEASURED property of the
   //--- terminal, so like the derived barrier pair it is pinned in the .cfg, not the filename hash
   //--- (see BuildConfigFingerprint's XA note). Empty = no set pinned yet; first successful Build
   //--- stamps it and re-saves the .cfg one-shot, exactly the m_geometryCfgSaved pattern.
   string              m_crossAssetPairsPinned;
   bool                m_crossAssetCfgSaved;
   //--- Alternative-data panel (2026-08-16): the second feature block whose inputs are not a
   //--- transform of this symbol's own series, and the first whose inputs are not derivable from
   //--- the terminal at all - COT positioning, the VIX complex, macro series, collected and
   //--- publication-stamped by research/altdata, served as plain CSVs. See System\AltData.mqh for
   //--- the lookahead/degradation/pinning contracts. No use-input: file present = on (the feature
   //--- SET is a measured property, like the derived barrier pair), .cfg name-list pin keeps a
   //--- trained model's inputs meaning what they meant.
   bool                m_useAltData;
   //--- EnableAltData input, distinct from m_useAltData: the input says the OPERATOR wants the block,
   //--- m_useAltData says it is actually contributing features (input on AND file present AND >=1
   //--- column). Gating consumption only - collection (AltDataFetch) runs regardless, so the files
   //--- stay current for the day the operator turns it back on.
   bool                m_altDataEnabled;
   //--- One-shot guard for the "data landed after the model was pinned" warning - the upkeep tick
   //--- runs every 30 minutes and this must not become a recurring line nobody reads.
   bool                m_altDataLateWarned;
   CAltDataPanel       m_altData;
   string              m_altDataNamesPinned;
   string              ReadAltDataPinFromCfg(void);
   //--- Spread as a feature. The only microstructure channel that is BOTH available on FX and
   //--- genuinely historical in the Strategy Tester ("during testing, the spread is not modeled but
   //--- is taken from historical data") - unlike swap (no history at all), signed tick flow
   //--- (TICK_FLAG_BUY/SELL are empty on FX) or depth of market (absent on retail FX, never replayed).
   //--- Measured as the strongest single feature in research/test_spread.py, though see the feature
   //--- block for what it actually encodes and why that is less than it first appears.
   //--- Series is copied ONCE per bar grid, not per bar: CopySpread is a range call, not a lookup.
   bool                m_useSpreadFeature;
   int                 m_spreadSeries[];
   int                 m_spreadSeriesBars;
   //--- Newest bar the copy was anchored to. MQL5 series indices are relative to NOW, so a single
   //--- new closed candle shifts every index by one: a cache keyed only on length would keep serving
   //--- index 0 as a bar that is no longer the newest, silently misaligning the spread series against
   //--- the price buffers it must line up with. Same invalidation key the label/feature bar caches
   //--- use (see EnsureBarCachesCapacity) and the same failure the zero-direction hunt traced.
   datetime            m_spreadSeriesAnchor;
   datetime            m_crossAssetAnchor;
   bool                EnsureSpreadSeries(int bars);
   bool                m_useADCumulativeDelta;
   bool                m_useADShorteningOfThrust;
   bool                m_useADWyckoffEventStream;
   bool                m_useADWyckoffFailedStructure;
   bool                m_useADWyckoffSignificantBarInversion;

public:
                     CExpertSignalAIBase(void);
                    ~CExpertSignalAIBase(void);
   //--- Reload the alt-data panel after CAltDataFetch rebuilt the feature CSV (OnTimer path,
   //--- live only). Content-only refresh: the .cfg name-list pin fixes the width and column
   //--- meanings, so new rows can arrive but the input contract cannot drift. Safe against the
   //--- per-bar feature cache because new alt rows only ever matter to a NEW D1 bar, which
   //--- resets that cache anyway.
   void              AltDataReload(void)
     {
      //--- Gated on the OPERATOR's switch, NOT on m_useAltData. m_useAltData latches false at init
      //--- whenever the CSV was absent, so gating the reload on it made the EA structurally unable to
      //--- consume data IT HAD JUST DOWNLOADED: on the first run after the alt-data folder is wiped -
      //--- the normal pre-test routine here - the models are built ~30s BEFORE the fetch completes, the
      //--- reload became a permanent no-op, and the entire run trained on price alone while a complete
      //--- feature file sat on disk. Measured 2026-08-16 on SP500 H4: models pinned at fingerprint
      //--- 6de8ba37 (0 alt features) at 19:36:40, SP500_D1.csv rebuilt with 13 features at 19:37:13,
      //--- and every era after that trained without them - silently, because nothing looked again.
      if(!m_altDataEnabled)
         return;
      int before = m_altData.FeatureCount();
      m_altData.Load(m_symbol.Name(), (ENUM_TIMEFRAMES)m_period);
      int after = m_altData.FeatureCount();
      //--- Loading here is INERT while m_useAltData is false (both consumption sites gate on it), so
      //--- this cannot widen the feature vector out from under a model whose width is already pinned.
      //--- That pinning is exactly why arriving data cannot be adopted mid-run, and why the only
      //--- honest response is to say so once, loudly, instead of leaving the run looking healthy.
      if(before == 0 && after > 0 && !m_altDataLateWarned)
        {
         m_altDataLateWarned = true;
         Print(ID + ": ALT DATA ARRIVED AFTER THIS MODEL WAS BUILT - " + IntegerToString(after) +
               " features are on disk now, but this model's input width was pinned WITHOUT them, so it"
               " is training on price alone and will keep doing so for the rest of this run."
               " RE-ATTACH THE EA (or reload the chart) to build models that actually train on the"
               " alt-data block. This is what happens when the alt-data folder is empty at attach time"
               " and the EA downloads it moments later.");
        }
     }
   //--- "voting" that price will grow/fall, common to every AI signal (single market model)
   virtual int       LongCondition(void);
   virtual int       ShortCondition(void);
   // |dPrevSignal| is already a 0..1 confidence for classification output (softmax
   // probability of the winning class) and typically bounded for regression output
   // (tanh-activated network); OpenParams() clamps regardless. Scaled by m_confidenceCalScale
   // (classification head only - 1.0/no-op for regression) so callers get an empirically
   // calibrated magnitude instead of the raw, uncalibrated softmax value - see
   // m_confidenceCalScale's declaration comment.
   double            CalibratedConfidenceMagnitude(void) const
     {
      double mag = MathAbs(dPrevSignal);
      if(!MathIsValidNumber(mag))
         return 0.0;
      if(m_outputNeuronsCount == 3)
         mag = MathMin(1.0, mag * m_confidenceCalScale);
      if(!MathIsValidNumber(mag))
         return 0.0;
      return mag;
     }
   virtual double    AIConfidence(void) override { return CalibratedConfidenceMagnitude(); }
   // Signed for direction-aware use (AI-driven early exit): sign matches dPrevSignal's
   // convention (+ buy, - sell, 0 neutral/no signal yet). dPrevSignal == -2 is the
   // "not yet studied" sentinel, not a real sell signal - treat it as no confidence.
   virtual double    SignedAIConfidence(void) override
     {
      if(dPrevSignal == -2)
         return 0.0;
      double sign = (dPrevSignal > 0.0) ? 1.0 : (dPrevSignal < 0.0) ? -1.0 : 0.0;
      if(sign == 0.0)
         return 0.0;
      return sign * CalibratedConfidenceMagnitude();
     }
   //--- event handlers, common to every AI signal
   virtual void      OnTickHandler(void);
   //--- drives the same training-scheduling check as OnTickHandler(), but callable from a timer so
   //--- it isn't dependent on ticks (which don't arrive while the market is closed)
   void              PollTraining(void);
   virtual void      OnChartEventHandler(const int id,
                                          const long &lparam,
                                          const double &dparam,
                                          const string &sparam);
   //--- methods of adjusting "weights" of the 4 confidence-tier market models - see m_pattern_0's
   //--- declaration comment
   void              Pattern_0(int value) { m_pattern_0 = value; }
   void              Pattern_1(int value) { m_pattern_1 = value; }
   void              Pattern_2(int value) { m_pattern_2 = value; }
   void              Pattern_3(int value) { m_pattern_3 = value; }
   virtual void      ApplyPatternWeight(int patternNumber, int weight);
   //--- Re-derives the four tier weights (and the module weight) from THIS era's held-out outcomes.
   //--- Called once per era at the end of pass 3, when m_oosTierFired/Hits are complete.
   void              RankTiersFromOos(void);
   //--- Direct tier setter, deliberately NOT routed through ApplyPatternWeight(): that override
   //--- declines writes once self-ranking is live, which is exactly what must not happen to the
   //--- self-ranker's own writes. Two doors, because they serve opposite purposes.
   void              ApplyTierWeight(const int tier, const int weight)
     {
      switch(tier)
        {
         case 0: Pattern_0(weight); break;
         case 1: Pattern_1(weight); break;
         case 2: Pattern_2(weight); break;
         default: Pattern_3(weight); break;
        }
     }
   //--- True once this model has measured its own tier win rates on held-out bars. While true the
   //--- signal DB's ranking is declined for this filter - see ApplyPatternWeight's comment and
   //--- CExpertSignalCustom::SelfRanked().
   virtual bool      SelfRanked(void) const override { return m_tiersSelfRanked; }
   //--- An AI member's say in the consensus denominator: its module weight once it is ALLOWED to
   //--- vote (the same readiness test LongCondition gates on), zero before that. A model still
   //--- training must not dilute the ensemble it cannot join - four training members and one
   //--- deployed one is a solo chart wearing an ensemble label, and the solo vote must read at
   //--- full strength.
   virtual double    VoteCapableWeight(void) override
     {
      if(!m_trainingComplete && !(m_inferenceOnly && m_modelLoadedFromDisk))
         return 0.0;
      return ModuleWeight();
     }
   //--- Era counter, so the EA can notice an era boundary and rebuild the historical overlay - the
   //--- weights (and every tier weight RankTiersFromOos just re-derived) changed, so the
   //--- reconstruction is stale the instant an era ends.
   long              EraCount(void) const { return m_eraCount; }
   //--- This model's cached decision for bar `idx`, already converted to the signed vote it would
   //--- have cast. No inference runs here - the era scan already wrote every scored bar into
   //--- m_arrowSignalCache, which is why the reconstruction can cover the whole chart cheaply.
   //--- -2.0 is the "never scored" sentinel and returns false: a bar outside the scan is NOT an
   //--- abstention, and counting it as one would let a model that never saw a bar dilute the vote
   //--- there. (An actual Neutral returns true with a 0.0 vote, which the caller drops from both
   //--- sums exactly as the live path does.)
   //--- What this model would vote on the CURRENT bar if it were deployed. Same arithmetic as the
   //--- live path (LiveVoteContribution) and the same arithmetic the historical overlay uses on
   //--- cached bars - deliberately, so the on-chart readout and the reconstructed arrows are the
   //--- same quantity and can be read against each other. The readiness gate in LongCondition() is
   //--- what this bypasses, and ONLY for display: dPrevSignal is the decision, deployed or not.
   //--- The -2 "not yet studied" sentinel falls out safely - DoubleToSignal() returns Undefine for
   //--- it, so LiveVoteContribution() yields 0.0 rather than a spurious Sell.
   virtual bool      ProspectiveVote(double &signedVote, double &weight) override
     {
      signedVote = 0.0;
      weight = 0.0;
      //--- NEWEST CACHED DECISION FIRST, dPrevSignal only as a fallback - and the order is the fix
      //--- for a readout that sat glued to one direction for hours (reported 2026-08-18).
      //---
      //--- dPrevSignal is written ONLY by pass 1, and pass 1 skips the feedForward for any bar a
      //--- later pass will forward anyway (see laterPassForwards) - which is the whole OOS window
      //--- and the calibration band. Pass 3 forwards the newest bars every era but never writes
      //--- dPrevSignal. Net effect: after every era, dPrevSignal holds the model's opinion of the
      //--- newest PURGE-BAND EDGE BAR pass 1 happened to forward - one fixed mid-history bar,
      //--- re-evaluated era after era. Four models staring at the same frozen bar that reads Buy
      //--- is a label glued to Buy, regardless of what any of them think about the market now.
      //---
      //--- The arrow cache is the honest source: pass 3 writes the ADJUSTED decision for the newest
      //--- (OOS) bars each era, so the first non-sentinel entry walking back from the decision bar
      //--- is this model's most recent verdict on near-current data. A cached NEUTRAL stops the walk -
      //--- that is a real decision (vote 0, abstain), not a missing one. The walk is bounded: past
      //--- ~16 bars the answer is no fresher than dPrevSignal and the fallback is fine. Early in an
      //--- era the cache is wiped to the -2 sentinel and everything falls through to dPrevSignal,
      //--- exactly as before, until pass 3 refills the newest rows.
      for(int idx = 1; idx <= 16; idx++)
        {
         if(CachedVoteAt(idx, signedVote))
           {
            weight = ModuleWeight();
            return true;
           }
        }
      //--- Era-end snapshot next - the fallback that actually fires for ~90% of every era, because
      //--- the live cache above is wiped at era start and only refills when pass 3 completes. Before
      //--- this existed the chain fell straight through to dPrevSignal (the frozen purge-band edge
      //--- bar), which is what kept the readout pinned to one direction for hours.
      if(m_prospectiveSigSnap != -2.0 && MathIsValidNumber(m_prospectiveSigSnap))
        {
         signedVote = LiveVoteContribution(m_prospectiveSigSnap);
         weight = ModuleWeight();
         return true;
        }
      signedVote = 0.0;
      if(!MathIsValidNumber(dPrevSignal))
         return false;
      signedVote = LiveVoteContribution(dPrevSignal);
      weight = ModuleWeight();
      return true;
     }
   //--- The sweep's data source - see CExpertSignalCustom::SnapshotVoteAt for why this is a
   //--- snapshot and not the live cache.
   virtual bool      SnapshotVoteAt(const int idx, double &signedVote) override
     {
      signedVote = 0.0;
      if(idx < 0 || idx >= m_overlaySnapBars)
         return false;
      double sig = m_overlaySigSnap[idx];
      if(sig == -2.0 || !MathIsValidNumber(sig))
         return false;
      signedVote = LiveVoteContribution(sig);
      return true;
     }
   virtual bool      CachedVoteAt(const int idx, double &signedVote) override
     {
      signedVote = 0.0;
      if(idx < 0 || idx >= ArraySize(m_arrowSignalCache))
         return false;
      double sig = m_arrowSignalCache[idx];
      if(sig == -2.0 || !MathIsValidNumber(sig))
         return false;
      signedVote = LiveVoteContribution(sig);
      return true;
     }
   //--- buckets the live confidence magnitude into one of the 4 tiers above - see m_pattern_0's
   //--- declaration comment. Public so PollTraining()/status-display code could surface which tier is
   //--- currently active if ever useful, though LongCondition/ShortCondition are the only callers today.
   int               ConfidenceTier(void);
   //--- The same bucketing asked of an ARBITRARY decision value rather than of dPrevSignal. Split out
   //--- so the OOS scan can ask "what tier would this scanned bar have voted at" - it holds the bar's
   //--- decision in a local, and dPrevSignal is the LIVE bar's, which is a different bar entirely.
   int               ConfidenceTierFor(const double signal);
   int               PatternWeightForTier(int tier);
   //--- THE VOTE THIS MEMBER WOULD CAST, in the units CExpertSignalCustom::Direction() actually sums:
   //--- m_weight (0..1, DB-ranked) x the tier's pattern weight (0..100, DB-ranked), signed + for Buy
   //--- and - for Sell, and exactly 0.0 when the decision is Neutral (an abstention, which live drops
   //--- from BOTH the sum and the divisor).
   //---
   //--- This exists because the ensemble deploy gate was scoring a different quantity than the one that
   //--- trades. It contributed the raw signed confidence x100 (a 33..100 number straight off the head)
   //--- while live contributes a win-rate-derived tier weight; the two have no fixed relation, and
   //--- g_ensembleVoteThreshold's own comment claims they fire on the same criterion. Same shape as the
   //--- 2026-08-09 geometry incident: certified on one game, paid on another. One function, called from
   //--- both the live vote path and the gate, is what keeps them from drifting apart again.
   double            LiveVoteContribution(const double signal);
   //--- methods of setting adjustable parameters
   //--- No public setter for m_initialNeuronsCount. It feeds the weights-filename fingerprint, and it is
   //--- now derived exactly once, inside InitNeuralNetwork(), before that fingerprint is built - see
   //--- ComputeFirstLayerWidth(). An external setter could only ever be called after construction and
   //--- would either be ignored (if before init) or silently re-key the model mid-run (if after).
   void              OutputNeuronsCount(int value) { m_outputNeuronsCount = value; }
   //--- No setter: the taper's endpoints are derived, not configured. See BuildFreshTopology()'s taper
   //--- block and the note in Variables\Inputs.mqh. Kept as members only because the .cfg topology
   //--- sidecar's field layout is positional and rewriting it would invalidate every model on disk.
   void              HiddenLayersCount(int value) { m_hiddenLayersCount = value; }
   void              LstmHiddenSize(int value) { m_lstmHiddenSize = value; }
   void              ConvFilterCount(int value) { m_convFilterCount = value; }
   //--- StopTrainWR(int) removed with the MinWR input - there is no absolute accuracy target any more;
   //--- see LEGACY_CONVERGE_WR_SLOT and the plateau ladder.
   void              MinDirectionalRecall(int value) { m_minDirectionalRecallPct = value; }
   //--- MinSignalConfidence(double) removed with the AI entry floor - confidence now reaches the trade
   //--- decision as vote weight (ConfidenceTier), gated by the one Min vote to open threshold that the
   //--- classic votes already answer to. See m_pattern_0's declaration comment.
   //--- The SINGLE class-imbalance control - tau in Menon et al.'s logit adjustment. 0 disables the
   //--- correction entirely. OversampleParity/EnableMinorityReplay/ConstrainReplay/LogitPriorStrength/
   //--- UseLogitAdjustedLoss/FocalLossGamma/UseStaticPrior were removed 2026-07-31; see the
   //--- class-imbalance block in Variables\Inputs.mqh for the audit that found five of them inert.
   void              LogitAdjustTau(double value)     { m_logitAdjustTau = MathMax(0.0, value); }
   void              FreezePriorCalibration(bool value) { m_freezePriorCalibration = value; }
   void              SignalClusterWindow(int value) { m_signalClusterWindow = value; }
   void              SwingConfirmationBars(int value) { m_swingConfirmationBars = value; }
   //--- Called from ConfigureAISignal when the TrainingTarget input selects the fractal label. Guarded
   //--- so CSignalMETA (whose constructor already claimed target 1) can never be flipped: the meta
   //--- head's 2-output topology and candidate pipeline are incompatible with a per-bar 3-class label.
   void              TrainTargetFractal(void) { if(m_trainTarget == 0) m_trainTarget = 2; }
   //--- ENSEMBLE MEMBERSHIP (AIType == AI_HYBRID: all four direction NNs on one chart). Feeds the
   //--- |ENS1 fingerprint token, so an ensemble member's weight files can never collide with a solo
   //--- model of identical settings on another chart of the same symbol - without it, the
   //--- duplicate-chart guard would (correctly) fight the two charts over one .nnw.
   //--- voteThreshold mirrors the Min_Vote_Open input into g_ensembleVoteThreshold (pass -1 to leave
   //--- it untouched) - see that global's comment for why it is pushed in rather than read.
   void              EnsembleMember(bool value, double voteThreshold = -1.0)
     {
      m_ensembleMember = value;
      if(voteThreshold >= 0.0)
         g_ensembleVoteThreshold = voteThreshold;
      if(value && m_ensembleIndex < 0)
        {
         int n = ArraySize(g_warriorEnsemble);
         ArrayResize(g_warriorEnsemble, n + 1);
         g_warriorEnsemble[n] = GetPointer(this);
         m_ensembleIndex = n;
        }
     }
   //--- Minimum era among the ensemble members still genuinely training. Deployed/complete, stopped and
   //--- paused members are exempt (a paused model must not deadlock the rest; when resumed it is behind,
   //--- becomes the min itself, and the others hold until it catches up - the barrier re-syncs on its
   //--- own). Falls back to this member's own era when nothing qualifies, which makes the barrier a
   //--- no-op rather than a lock.
   long              EnsembleMinTrainingEra(void)
     {
      long minEra = LONG_MAX;
      for(int i = 0; i < ArraySize(g_warriorEnsemble); i++)
        {
         CExpertSignalAIBase *mm = g_warriorEnsemble[i];
         if(CheckPointer(mm) == POINTER_INVALID)
            continue;
         if(mm.m_trainingComplete || mm.m_trainingStopRequested || mm.m_trainingPaused || !mm.m_isInitialized)
            continue;
         //--- THE LIVENESS EXEMPTION (see ENSEMBLE_BARRIER_STUCK_MS). The three flags above are all
         //--- VOLUNTARY - a member that chose to stop participating. A member whose era simply will not
         //--- advance sets none of them, and the barrier had no way to tell "slow" from "never", so one
         //--- broken member froze its whole chart with no time limit and no journal line. Excluded
         //--- members keep training (they are still trying to recover) and rejoin the moment they
         //--- complete an era - at which point, being behind, they legitimately become the minimum again
         //--- and the others wait for them to catch up, exactly as a resumed laggard does.
         if(mm.m_barrierExcluded)
            continue;
         if(mm.m_eraCount < minEra)
            minEra = mm.m_eraCount;
        }
      return (minEra == LONG_MAX) ? m_eraCount : minEra;
     }
   //--- How many members are actively consuming training chunks right now: still training AND at the
   //--- barrier's minimum era (a member held ABOVE the min declines its calls, so it costs nothing).
   //--- TRAIN_TIME_BUDGET_MS divides the ensemble budget by this, which is the "faster member donates
   //--- its power to the laggards" behaviour: 4 trainers -> 30ms each, one laggard left -> it gets the
   //--- full 120ms, and the chart thread's UI headroom stays constant either way.
   int               EnsembleActiveTrainers(void)
     {
      if(!m_ensembleMember)
         return 1;
      long minEra = EnsembleMinTrainingEra();
      int active = 0;
      for(int i = 0; i < ArraySize(g_warriorEnsemble); i++)
        {
         CExpertSignalAIBase *mm = g_warriorEnsemble[i];
         if(CheckPointer(mm) == POINTER_INVALID)
            continue;
         if(mm.m_trainingComplete || mm.m_trainingStopRequested || mm.m_trainingPaused || !mm.m_isInitialized)
            continue;
         if(mm.m_eraCount <= minEra)
            active++;
        }
      return MathMax(active, 1);
     }
   //--- True when this member has finished more eras than the slowest still-training member and must
   //--- wait at the era barrier - checked at Train()'s entry (see the barrier note there).
   bool              EnsembleEraBarrierHolds(void)
     {
      if(!m_ensembleMember || m_trainingComplete)
         return false;
      return m_eraCount > EnsembleMinTrainingEra();
     }
   //--- Era-advance watchdog for the barrier, kept SEPARATE from m_lastEraCompleteTick on purpose. That
   //--- one is reset by the barrier-hold branch itself (deliberately - a held member is idle, not
   //--- stalled), so anything derived from it would read every held member as healthy and every holder
   //--- as healthy too. This clock is stamped only by a real change of m_eraCount, so it measures the
   //--- one thing the barrier needs: is this member still making progress?
   //--- Called at Train() entry, before the barrier test, for `this` member only - all members of a
   //--- chart share the one MQL5 thread, so each stamps itself and reads the others.
   void              BarrierEraHeartbeat(void)
     {
      if(!m_ensembleMember)
         return;
      uint nowTick = GetTickCount();
      if(m_barrierEraTick == 0 || m_barrierEraSeen != m_eraCount)
        {
         //--- Progress (or the first observation). Rejoining is unconditional and immediate: a member
         //--- that just completed an era is by definition not stuck, whatever it was doing before.
         if(m_barrierExcluded)
            Print(ID + ": REJOINING THE ERA BARRIER at era " + IntegerToString((int)m_eraCount) +
                  " - it completed an era, so it is training again. It is behind the rest of the"
                  " ensemble, which means it now sets the minimum and the others wait for it to catch"
                  " up. The combined-vote score resumes once every member reports the same era.");
         m_barrierExcluded = false;
         m_barrierEraSeen = m_eraCount;
         m_barrierEraTick = nowTick;
         return;
        }
      //--- Same era as last look. Only a member that is AT the minimum can be the one blocking: a member
      //--- ahead of it is not advancing because the barrier is holding it, which is correct behaviour and
      //--- must never be mistaken for being stuck.
      if(m_barrierExcluded || m_eraCount > EnsembleMinTrainingEra())
         return;
      if(nowTick - m_barrierEraTick < ENSEMBLE_BARRIER_STUCK_MS)
         return;
      m_barrierExcluded = true;
      PrintFormat("%s: RELEASING THE ERA BARRIER - this member has not completed an era in %.0f minutes"
                  " (still at era %d) and every other member on this chart has been waiting on it for"
                  " that entire time. It is excluded from the barrier minimum so the rest can advance;"
                  " it keeps training and rejoins the moment it finishes an era. READ THE TRAIN STALL"
                  " LINE ABOVE for why it is not finishing - the barrier only reports that it is stuck,"
                  " never why. NOTE: while the ensemble is desynchronised the combined-vote OOS score"
                  " cannot be computed (it scores only bars EVERY member contributed at the same era),"
                  " so no ensemble verdict will be published until this member catches up.",
                  ID, (nowTick - m_barrierEraTick) / 60000.0, (int)m_eraCount);
     }
   //--- Pass-3 hook: record the VOTE this member would have cast on this OOS bar into the combined-vote
   //--- buffer. signedVote is in live vote units - m_weight x tier pattern weight, signed by direction
   //--- (see LiveVoteContribution()) - NOT the raw confidence this used to carry. It is 0.0 when the
   //--- member abstains, and an abstention is then excluded from the divisor as well as the sum, which
   //--- is what CExpertSignalCustom::Direction() does live (see g_ensVoteVoterMask).
   void              EnsembleOosContribute(const int barIdx, const double signedVote,
                                           const double voteWeight,
                                           const bool winLong, const bool winShort, const bool dirLabel)
     {
      if(!m_ensembleMember || m_ensembleIndex < 0 || m_ensembleIndex >= 8)
         return;
      datetime t = m_Time.GetData(barIdx);
      if(t <= 0)
         return;
      if(g_ensVoteEra != m_eraCount)
        {
         //--- first contribution of a new era resets the buffer (the era barrier keeps members aligned,
         //--- so a mismatched stamp means "previous era's rows", never "a sibling's different era")
         g_ensVoteEra = m_eraCount;
         g_ensVoteRows = 0;
         g_ensVoteDoneMask = 0;
         ArrayInitialize(g_ensVoteCursor, 0);
        }
      int bit = (1 << m_ensembleIndex);
      //--- monotonic cursor first (members scan bars oldest-to-newest, so the match is O(1) amortized),
      //--- full wrap-around only when per-member window failures desynchronize the sequences
      int row = -1;
      int start = g_ensVoteCursor[m_ensembleIndex];
      if(start > g_ensVoteRows)
         start = 0;
      for(int i = start; i < g_ensVoteRows; i++)
         if(g_ensVoteTime[i] == t) { row = i; break; }
      if(row < 0)
         for(int i = 0; i < start; i++)
            if(g_ensVoteTime[i] == t) { row = i; break; }
      if(row < 0)
        {
         if(g_ensVoteRows >= ArraySize(g_ensVoteTime))
           {
            int cap = g_ensVoteRows + g_ensVoteRows / 2 + 512;
            ArrayResize(g_ensVoteTime, cap);
            ArrayResize(g_ensVoteSum, cap);
            ArrayResize(g_ensVoteMask, cap);
            ArrayResize(g_ensVoteVoterMask, cap);
            ArrayResize(g_ensVoteWeightSum, cap);
            ArrayResize(g_ensVoteWinLong, cap);
            ArrayResize(g_ensVoteWinShort, cap);
            ArrayResize(g_ensVoteDirLabel, cap);
           }
         row = g_ensVoteRows++;
         g_ensVoteTime[row] = t;
         g_ensVoteSum[row] = 0.0;
         g_ensVoteMask[row] = 0;
         g_ensVoteVoterMask[row] = 0;
         g_ensVoteWeightSum[row] = 0.0;
         //--- outcomes and label come from the shared label cache, so they are identical across
         //--- members - whichever member reaches the bar first writes them
         g_ensVoteWinLong[row] = winLong;
         g_ensVoteWinShort[row] = winShort;
         g_ensVoteDirLabel[row] = dirLabel;
        }
      if((g_ensVoteMask[row] & bit) != 0)
         return; // already contributed to this bar this era (defensive - a re-run must not double-count)
      g_ensVoteSum[row] += signedVote;
      g_ensVoteMask[row] |= bit;
      //--- VOTER, not merely present. -0.0 compares equal to 0.0, so an abstention that arrived with a
      //--- negative zero is still correctly excluded here.
      //--- CONSENSUS DENOMINATOR: the member's weight counts because it CONTRIBUTED (it evaluated
      //--- the bar and had a say), not because it voted a direction - a Neutral dilutes the vote
      //--- here exactly as it does live. The voter mask stays direction-only: "did anyone actually
      //--- vote" still gates whether the bar can fire at all.
      g_ensVoteWeightSum[row] += voteWeight;
      if(signedVote != 0.0)
         g_ensVoteVoterMask[row] |= bit;
      g_ensVoteCursor[m_ensembleIndex] = row + 1;
     }
   //--- This member's just-finished era, held until the ensemble verdict can act on it. Members reach
   //--- their era end at different moments within a round, so the last one to arrive needs every
   //--- member's figures - and, if the era wins, commits them as that member's best-checkpoint stats
   //--- (see EnsembleCommitJointCheckpoint). Same quantities the solo gate keeps in m_best*.
   double              m_eraStatPrecPct;
   double              m_eraStatChancePct;
   int                 m_eraStatCalls;
   bool                m_eraStatTradeable;
   bool                m_eraStatTwoSided;
   double              m_eraStatScore;
   double              m_eraStatBlended;
   double              m_eraStatThreshold;
   //--- Which era this member's in-memory snapshot belongs to (-1 = none). The deploy gate requires
   //--- EVERY member to be stamped with the SAME era as the winning vote: without it, a member whose
   //--- capture failed would still be carrying a snapshot from an earlier era and the quartet that
   //--- deployed would be one no combined measurement ever covered - the precise failure the joint
   //--- checkpoint exists to rule out.
   long                m_checkpointEra;
   void              EnsembleStashEraStats(const double precPct, const double chancePct, const int calls,
                                           const bool tradeable, const bool twoSided, const double score,
                                           const double blended)
     {
      m_eraStatPrecPct   = precPct;
      m_eraStatChancePct = chancePct;
      m_eraStatCalls     = calls;
      m_eraStatTradeable = tradeable;
      m_eraStatTwoSided  = twoSided;
      m_eraStatScore     = score;
      m_eraStatBlended   = blended;
      //--- the operating point belongs with the weights it was fitted for - see m_bestDirConfThreshold
      m_eraStatThreshold = m_dirConfThreshold;
     }
   //--- Called once per era from the era-end block, after this member's statistics are final. Marks
   //--- this member done; the LAST still-training member to arrive runs the whole ensemble verdict
   //--- (score the vote, rank the era, capture the joint checkpoint, advance the shared ladder, and
   //--- decide deployment) for every member at once. `etaLocal` is the caller's own live learning rate,
   //--- passed by reference because a shared warm restart has to reach the member that is mid-Train().
   //--- Defined in Training.mqh - it needs NormalUpperTail() and the PLATEAU_* machinery.
   void              EnsembleOosPassComplete(const long votedEra, double &etaLocal);
   //--- The verdict itself, and its pieces. needMask names the members whose reads the vote is built
   //--- from (still-training members only - a paused or deployed member is not voting in training).
   void              EnsembleEraVerdict(const int needMask, const long votedEra, double &etaLocal);
   void              EnsembleCommitJointCheckpoint(const long votedEra);
   //--- Does the best combined-vote era survive having been CHOSEN out of g_ensCandidateEras eras?
   //--- Identical construction to BestCheckpointSurvivesSelection, applied to the vote.
   bool              EnsembleSurvivesSelection(double &zObs, double &pFamily, int &nTried);
   //--- Single choke point for this signal's on-chart status text. Solo charts draw the full panel
   //--- exactly as before; an ensemble member contributes only its headline (first line) to the one
   //--- combined panel - see the ENSEMBLE PANEL block in System\StatusLabel.mqh. Every AI-side
   //--- SetStatusLabel call site routes through here so no mode can regress into four stacked panels.
   void              PublishStatus(const string text, const bool force = false)
     {
      if(!m_ensembleMember)
        {
         SetStatusLabel(text);
         return;
        }
      //--- Called EVERY publish, not just the first. The row is keyed to m_ensembleIndex so the call is
      //--- idempotent and cheap, and re-asserting it refreshes the tag for a member whose ID was not yet
      //--- final when it first published (the config-tag suffix is appended during InitIndicators, after
      //--- EnsembleMember() registers). The old "claim once, first publisher wins the next free row"
      //--- form is what ordered the panel by who was busiest instead of by member index.
      m_ensemblePanelSlot = ClaimEnsemblePanelSlot(DisplayName(), m_ensembleIndex);
      int nl = StringFind(text, "\n");
      PublishEnsembleStatus(m_ensemblePanelSlot, (nl > 0) ? StringSubstr(text, 0, nl) : text, force);
     }
   void              EnableOnlineLearning(bool value) { m_enableOnlineLearning = value; }
   //--- Exit policy, pushed in from Warrior_EA.mq5 so the gate grades the same rule the live path runs.
   //--- voteThreshold is Min_Vote_Close UNSCALED, on the same 0-100 confidence scale as the live
   //--- close threshold (>100 disables it by arithmetic, exactly as live does). The bound moved
   //--- with the 2026-08-18 currency change and MUST track it: while this still clamped at >1.0 a
   //--- caller passing the unscaled input would have had EVERY value above 1 silently collapse to
   //--- 0.0, switching vote exits off in the simulation while live went on running them.
   void              ExitPolicy(double voteThreshold, bool holdToBarrier)
     {
      m_exitVoteThreshold = (voteThreshold > 100.0) ? 0.0 : voteThreshold;
      m_exitHoldToBarrier = holdToBarrier;
     }
   void              MaxErasPerRun(int value) { m_maxErasPerRun = value; }
   void              OOSSplit(int value) { m_oosSplitPct = value; }
   void              HistoryBars(int value) { m_historyBars = value; }
   void              MinTrainYear(int value) { m_minTrainYear = value; }
   void              UseVolumes(bool value) { m_useVolumes = value; }
   void              UseTime(bool value) { m_useTime = value; }
   void              UseATR(bool value) { m_useATR = value; }
   void              UseMA(bool value) { m_useMA = value; }
   void              UseRSI(bool value) { m_useRSI = value; }
   void              UseMACD(bool value) { m_useMACD = value; }
   void              UseIchimoku(bool value) { m_useIchimoku = value; }
   void              UseSwingContext(bool value) { m_useSwingContext = value; }
   void              UseNews(bool value) { m_useNews = value; }
   void              NewsFeatureWindowMinutes(int value) { m_newsFeatureWindowMinutes = value; }
   void              UseCrossAsset(bool value) { m_useCrossAsset = value; }
   void              UseSpreadFeature(bool value) { m_useSpreadFeature = value; }
   void              UseADCumulativeDelta(bool value) { m_useADCumulativeDelta = value; }
   void              UseADShorteningOfThrust(bool value) { m_useADShorteningOfThrust = value; }
   void              UseADWyckoffEventStream(bool value) { m_useADWyckoffEventStream = value; }
   void              UseADWyckoffFailedStructure(bool value) { m_useADWyckoffFailedStructure = value; }
   void              UseADWyckoffSignificantBarInversion(bool value) { m_useADWyckoffSignificantBarInversion = value; }
   void              AutoTuneIndicators(bool value) { m_autoTuneIndicators = value; }
   void              UseAltData(bool value)         { m_altDataEnabled = value; }
   //--- control-panel API (Warrior_EA.mq5): current-config-only training/weights control.
   //--- "current config" == this signal instance's own m_fileName (symbol+period+id+topology),
   //--- never touches another signal type's or another symbol/timeframe's saved files.
   void              PauseTraining(void) { m_trainingPaused = true; PrintVerbose(ID + ": training paused by user (era " + IntegerToString(m_eraCount) + ")"); }
   void              ResumeTraining(void) { m_trainingPaused = false; PrintVerbose(ID + ": training resumed by user (era " + IntegerToString(m_eraCount) + ")"); }
   bool              IsTrainingPaused(void) const { return m_trainingPaused; }
   bool              IsTrainingStopped(void) const { return m_trainingStopRequested; }
   bool              TrainingComplete(void) const { return m_trainingComplete; }
   //--- Set by OnDeinit before it calls StopTraining(), so FinalizeTrainRun() can tell a user-pressed Stop
   //--- (persist the deployed model now - nothing else will) from a shutdown (PersistWeightsOnShutdown is
   //--- moments away and writes the same bytes). See the guard in FinalizeTrainRun.
   void              MarkShutdown(void) { m_shutdownInProgress = true; }
   //--- THE ONE QUESTION every long loop in this class must ask: has this program been asked to stop?
   //--- MetaTrader's ~4,500 ms teardown budget is measured from the STOP REQUEST, not from OnDeinit's
   //--- first line, and OnDeinit cannot even begin until whatever is in flight returns. So a scan that
   //--- runs for three seconds after _StopFlag is raised does not merely delay shutdown - it SPENDS the
   //--- cleanup budget, and the chart keeps the status label, the panel and every arrow because the
   //--- purge never got its turn. Training's bar loops have honoured this since they were written; the
   //--- warm-up scans, the permutation nulls and the label prebuild did not, and they are the longest
   //--- uninterruptible stretches the EA has.
   //--- Deliberately NOT including m_trainingStopRequested: that is the operator's Stop-training button,
   //--- it latches, and a latched flag would permanently disable scans that must still run on the next
   //--- Start. These two are terminal - once either is true the program is going away.
   bool              ShutdownRequested(void) const { return (IsStopped() || m_shutdownInProgress); }
   //--- ONE LINE OF IDENTITY, for the census Warrior_EA.mq5 prints before it acts on g_aiSignals[].
   //--- Public because the EA has to be able to NAME what it is iterating: every panel action loops over
   //--- that registry and, until now, none of them said how many members they reached or which files they
   //--- touched. "The reset only wiped the first model" was therefore impossible to confirm OR refute
   //--- from a log - the loop and a one-member loop produce identical output. This makes them different.
   string            RegistryLine(void) const
     {
      return StringFormat("%s | %s (%s) | era %d | %s%s", ID, m_activeFileName,
                          (m_activeFileCommon ? "common" : "local"), (int)m_eraCount,
                          (m_trainingComplete ? "deployed" : "training"),
                          (m_ensembleMember
                           ? StringFormat(" | ensemble member %d", m_ensembleIndex) : " | solo"));
     }
   //--- SHUTDOWN FLUSH: abandon an in-flight run instead of finishing it, and resume from the last
   //--- COMPLETED, already-persisted era. StopTraining() does the opposite - it finalises synchronously
   //--- (restore the best checkpoint from its file, re-seed live state) and OnDeinit then writes two
   //--- full nets per chart. On four charts that is the bulk of the deinit budget, spent to preserve a
   //--- PARTIAL era that was never scored, never checkpointed and never deployable - and the price of
   //--- overrunning is that the chart cleanup gets killed and strands its arrows and panel in the chart
   //--- profile, where nothing will ever clean them up (see LoadChartSignals' orphan sweep).
   //--- Every completed era is already on disk: the era-end save and the periodic autosave both persist
   //--- independently, so what this discards is bounded by one era of work.
   //--- Returns true if there really was an in-flight run to discard, so the caller can tell a flush
   //--- from a no-op and skip the weight write only when the flush actually applied.
   bool              FlushTrainRun(void)
     {
      bool inFlight = (m_trainRunActive || m_eraResumePending || m_labelPrebuildActive || m_simOosRunActive);
      m_trainingStopRequested = true;
      m_trainingPaused = false;
      //--- Drop the resumable bookkeeping WITHOUT calling FinalizeTrainRun: no checkpoint restore, no
      //--- persist, no dtStudied advance. The next start re-derives all of it from the saved model.
      m_trainRunActive = false;
      m_eraResumePending = false;
      m_haveOosCheckpoint = false;
      m_checkpointEra = -1;   // the joint-checkpoint era stamp goes with the snapshot it describes
      m_labelPrebuildActive = false;
      if(m_simOosRunActive)
        {
         delete m_simOosNet;
         m_simOosNet = NULL;
         m_simOosRunActive = false;
        }
      //--- Leave the net in the same neutral state FinalizeTrainRun leaves it in - a frozen batch-norm or
      //--- a half-filled mini-batch must not be what a later inference path finds. Cheap, unlike the save.
      if(CheckPointer(Net) != POINTER_INVALID)
        {
         Net.SetBatchNormFrozen(false);
         Net.FlushBatch();
         Net.SetBatchSize(1);
        }
      return inFlight;
     }
   void              StopTraining(void)
     {
      m_trainingStopRequested = true;
      m_trainingPaused = false;
      //--- ScheduleTrainingIfNeeded() refuses to schedule another "New Bar" event while
      //--- m_trainingStopRequested is set, so a run interrupted mid-chunk would otherwise never get
      //--- called again to finalize (restore the best checkpoint, persist state) - do it synchronously
      //--- here instead. Safe to block briefly: this is just a checkpoint file restore, not the
      //--- multi-minute bar loop.
      if(m_trainRunActive)
         FinalizeTrainRun();
      Print(ID + ": training stopped by user (era " + IntegerToString(m_eraCount) + ", weights as of last completed era retained)");
      PrintInferenceTally();
     }
   //--- Inference-path census, printed at shutdown. WHY: a 2026-07-31 backtest of a CONVERGED CONV model
   //--- produced "Final directional result: 0.00000000" on every one of 1744 bars and therefore ZERO
   //--- trades, and nothing in the log could distinguish the three candidate causes - RefreshLatestSignal
   //--- never running, running but bailing at one of its two early returns, or running fine and the model
   //--- genuinely answering Neutral every time. Each implies a completely different fix. Counting is the
   //--- cheapest way to tell them apart and it costs nothing per bar.
   //--- Records one directional decision's passage through the readiness gate in LongCondition()/
   //--- ShortCondition(). Called with `directional` = "this condition's own class is what the model
   //--- actually answered", so a Neutral bar counts as neither blocked nor passed - the question being
   //--- measured is what happened to the calls that HAD something to say.
   void              NoteVoteGate(bool directional)
     {
      if(!directional)
         return;
      bool open = m_trainingComplete || (m_inferenceOnly && m_modelLoadedFromDisk);
      if(m_voteGateCompleteAtFirst < 0)
        {
         m_voteGateCompleteAtFirst = (int)m_trainingComplete;
         m_voteGateLoadedAtFirst   = (int)m_modelLoadedFromDisk;
        }
      if(open)
         m_voteGatePassed++;
      else
         m_voteGateBlocked++;
     }
   void              PrintInferenceTally(void)
     {
      long attempts = m_refreshOk + m_refreshFailFeatures + m_refreshFailShort;
      if(attempts <= 0)
        {
         Print(ID + ": inference census - RefreshLatestSignal was NEVER CALLED (0 attempts). The new-bar gate never fired.");
         return;
        }
      Print(ID + ": inference census - ", attempts, " refresh attempts: ", m_refreshOk, " completed, ",
            m_refreshFailFeatures, " bailed in BufferTempData, ", m_refreshFailShort, " bailed on a short feature window",
            " | decisions Buy:", m_refreshBuy, " Sell:", m_refreshSell, " Neutral:", m_refreshNeutral);
      //--- Second half of the census, and the half that separates "the model said nothing" from "the model
      //--- spoke and was not allowed to vote" - see m_voteGateBlocked for why that distinction is the whole
      //--- point. A run with directional decisions above and voteGate passed:0 below is the readiness-gate
      //--- failure, NOT a Neutral model, and the fix is on the model-load path.
      if(m_voteGateCompleteAtFirst < 0)
         Print(ID + ": inference census - vote gate was NEVER REACHED (no directional decision ever hit "
               "LongCondition/ShortCondition). Either every decision was Neutral, or this filter was never polled.");
      else
         Print(ID + ": inference census - vote gate passed:", m_voteGatePassed, " blocked:", m_voteGateBlocked,
               " | at first vote trainingComplete=", (m_voteGateCompleteAtFirst != 0 ? "true" : "false"),
               " modelLoadedFromDisk=", (m_voteGateLoadedAtFirst != 0 ? "true" : "false"),
               " inferenceOnly=", (m_inferenceOnly ? "true" : "false"),
               (m_voteGateBlocked > 0 && m_voteGatePassed == 0
                ? "  <-- EVERY directional call was discarded here. This is the zero-direction cause."
                : ""));
     }
   //--- The ONLY place the study event is posted: arms bEventStudy with THIS instance's id (so the
   //--- handler in OnChartEventHandler(), which matches on m_studyEventId, is the only member that
   //--- runs it) and stamps the lost-event watchdog. sparam tags ("New Bar"/"Init"/"Resume"/...) are
   //--- purely diagnostic.
   bool              ArmStudyEvent(const long lparam, const string tag)
     {
      bEventStudy = EventChartCustom(ChartID(), m_studyEventId, lparam, 0, tag);
      if(bEventStudy)
         m_studyArmedTick = GetTickCount();
      return bEventStudy;
     }
   void              StartTraining(void)
     {
      if(!m_trainingStopRequested && !m_trainingPaused)
         return;
      m_trainingStopRequested = false;
      m_trainingPaused = false;
      if(!bEventStudy)
         ArmStudyEvent((long)dtStudied, "Resume");
      Print(ID + ": training (re)started by user (era " + IntegerToString(m_eraCount) + ")");
     }
   //--- Has an era ever cleared the per-class recall floor and been checkpointed this run? This is the
   //--- same quality bar the plateau ladder's auto-deploy requires (see PLATEAU_STAGE_DEPLOY), exposed so
   //--- the panel can warn before a MANUAL deploy ships a model that ignores Buy or Sell.
   bool              HasRecallPassingCheckpoint(void) const { return m_bestPassedRecall; }
   //--- MANUAL deploy (panel "Deploy Model"): finalise whatever the run has found so far as THE model -
   //--- exactly what the plateau ladder does on its own at stage 3, just triggered early by the operator.
   //--- Restores the best checkpoint (not whatever era the run happened to be mid-way through), persists
   //--- weights + calibration + shadow, and flips to live inference.
   //--- Deliberately does NOT set m_trainingStopRequested: like every other deploy path, a deployed model
   //--- still runs live inference AND online continual learning. A panel Stop is the thing that halts
   //--- everything - see StopTraining()/OnlineLearnStep()'s gate. Reversible via RetrainDeployed().
   bool              DeployNow(void)
     {
      if(CheckPointer(Net) == POINTER_INVALID || !m_isInitialized)
         return false;
      if(m_trainingComplete)
         return true; // already deployed - nothing to do
      //--- Set BEFORE any save below: the flag is written INTO the .nnw, so persisting first would store
      //--- "still training" and a restart would resume the era loop instead of running the deployed model.
      m_trainingComplete = true;
      m_trainingPaused = false;
      m_trainingStopRequested = false;
      if(m_trainRunActive || m_haveOosCheckpoint)
         FinalizeTrainRun(); // restores the best checkpoint, persists, ends the run
      else
        {
         //--- Nothing trained this session (e.g. deploying a model that was just loaded from disk), so
         //--- there is no in-memory checkpoint to restore - persist exactly what is loaded right now.
         PersistDeployedModel();
         SaveChartSignals();
        }
      RefreshLatestSignal();
      Print(ID + ": model DEPLOYED by user at era " + IntegerToString(m_eraCount) +
            " (balanced accuracy " + (m_bestBalancedOos < 0 ? "n/a" : DoubleToString(m_bestBalancedOos, 1) + "%") +
            ", blended OOS " + DoubleToString(dOosForecast, 1) + "%) - training stopped, now running live inference" +
            (m_enableOnlineLearning ? " with online continual learning" : "") +
            ". Use the panel's \"Retrain Model\" to resume training from here.");
      //--- Deliberately reported, not enforced: a manual deploy is the operator overriding the ladder, and
      //--- that override stays available. But the ladder's own verdict on this checkpoint goes in the log
      //--- next to it, so "I shipped this" is never later mistaken for "this passed". See
      //--- DEPLOY_FAMILY_WISE_ALPHA and HasRecallPassingCheckpoint()'s panel warning.
      ReportSelectionGateVerdict("manual deploy");
      return true;
     }
   //--- The inverse of DeployNow(), and the ONLY way back: while m_trainingComplete is set,
   //--- ScheduleTrainingIfNeeded() routes every tick to the converged/inference branch, so StartTraining()
   //--- alone can never revive a deployed model (it clears the stop flag, but the complete flag still wins
   //--- that branch). Clearing it here re-arms the normal training path, continuing from the DEPLOYED
   //--- weights rather than from scratch - "reset weights" is the separate, destructive button for that.
   //--- The plateau ladder, best-checkpoint tracking and annealed gamma all reset themselves when Train()
   //--- starts its next fresh run (see the !m_trainRunActive block), so a retrain does not inherit the
   //--- exhausted stage that deployed the model and immediately re-deploy it.
   void              RetrainDeployed(void)
     {
      if(!m_trainingComplete)
         return;
      m_trainingComplete = false;
      m_trainingStopRequested = false;
      m_trainingPaused = false;
      //--- Persist the cleared flag immediately. Otherwise a terminal restart before the first era
      //--- completes would reload the .nnw still marked complete and silently go back to inference-only,
      //--- looking like the button did nothing.
      PersistDeployedModel();
      if(!bEventStudy)
         ArmStudyEvent((long)dtStudied, "Retrain");
      Print(ID + ": RETRAINING the deployed model from era " + IntegerToString(m_eraCount) +
            " - keeping its current weights as the starting point (use \"Delete & Reset Weights\" to start from scratch instead).");
     }
   //--- Manual "rescan" of the drawn signal arrows: purges every arrow currently on the chart (namespaced
   //--- delete - user drawings untouched) and re-infers the last SIGNAL_RESCAN_LOOKBACK_BARS bars from the
   //--- CURRENTLY deployed weights, then re-runs the same end-of-era NMS declutter (PruneDirectionalClusters)
   //--- used during training so the fresh set matches what a live re-render would have produced. Wired to
   //--- the panel's Hide->Show Signals sequence: without this, "restore" only ever replays whatever was
   //--- last saved to the .arrows sidecar, which for a long-deployed model can be a stale historical render
   //--- from whenever it was last actually trained - years-old arrows crowding out anything recent. Chart-only
   //--- (no persistent chart in the tester/optimizer) and a no-op until a model has something to infer with.
   //--- This only does the cheap setup (buffer resize, arrow purge, cache alloc) and QUEUES the per-bar
   //--- inference loop for AdvanceChartSignalRescan() to drain in time-boxed slices off the timer - see
   //--- that method's comment for why the loop itself must never run in one blocking pass. Returns true
   //--- once a rescan has been queued (check RescanPending() for completion), false if there was nothing
   //--- to rescan (no deployed model, tester/optimizer context, etc).
   bool              StartChartSignalRescan(void)
     {
      if(MQLInfoInteger(MQL_TESTER) || MQLInfoInteger(MQL_OPTIMIZATION) || MQLInfoInteger(MQL_FORWARD))
         return false;
      if(CheckPointer(Net) == POINTER_INVALID || !m_isInitialized || !m_trainingComplete)
         return false;
      if(m_outputNeuronsCount != 1 && m_outputNeuronsCount != 3)
         return false;
      int barsAvail = Bars(m_symbol.Name(), PERIOD_CURRENT);
      int barsNow = MathMin(SIGNAL_RESCAN_LOOKBACK_BARS, barsAvail);
      //--- SIGNAL_RESCAN_LOOKBACK_BARS is 5000 and the SMALLEST "Max bars in chart" setting MT5 offers
      //--- is also 5000, so this call site genuinely can be capped - it would redraw the whole rescan
      //--- window as Neutral (every feature window rejected) and read as "the model calls nothing".
      barsNow = ServableBars(barsNow, "chart rescan");
      if(barsNow <= m_historyBars)
         return false;
      if(!ResizeBuffers(barsNow) || !RefreshData())
         return false;
      EnsureShadowNet();
      //--- Drop only the arrows THIS rescan is about to re-judge - i.e. those within [now, oldest bar of
      //--- the barsNow window] - not every namespaced arrow on the chart. PruneDirectionalClusters below
      //--- only touches indices inside [0, barsNow), so anything older survives untouched either way; the
      //--- previous version called ObjectsDeleteAll(0, SIG_ARROW_PREFIX) unconditionally, which wiped
      //--- EVERY arrow ever drawn (years of history, going back to whenever this EA was first attached)
      //--- and then only ever redrew the last SIGNAL_RESCAN_LOOKBACK_BARS (~7 months on H1) - anything
      //--- older was gone permanently the moment Show Signals was clicked, with no way back short of the
      //--- .arrows sidecar (itself only ever a snapshot from whatever the LAST save happened to catch).
      //--- Reported 2026-07-26: a user's multi-year arrow history vanished down to whatever a stale
      //--- .arrows file held, immediately after their first-ever successful Show Signals click. This scoped
      //--- delete is the fix - older arrows are never in scope to be wiped in the first place.
      datetime rescanCutoffTime = m_Time.GetData(barsNow - 1);
      for(int oi = ObjectsTotal(0, 0, OBJ_ARROW) - 1; oi >= 0; oi--)
        {
         string onm = ObjectName(0, oi, 0, OBJ_ARROW);
         if(StringFind(onm, SIG_ARROW_PREFIX) != 0)
            continue;
         if((datetime)ObjectGetInteger(0, onm, OBJPROP_TIME) >= rescanCutoffTime)
            ObjectDelete(0, onm);
        }
      ArrayResize(m_arrowSignalCache, barsNow);
      ArrayInitialize(m_arrowSignalCache, -2.0);
      m_rescanBarsNow = barsNow;
      m_rescanHi = barsNow - m_historyBars;
      m_rescanIndex = 0;
      m_rescanRawBuy = 0;
      m_rescanRawSell = 0;
      m_rescanRawNeutral = 0;
      m_rescanPending = (m_rescanHi > 0);
      m_rescanStartMs = GetTickCount();
      if(m_rescanPending)
         Print(ID + ": rescanning last " + IntegerToString(m_rescanHi) + " bars against the deployed model (progressive, non-blocking)...");
      return m_rescanPending;
     }
   //--- true while a queued rescan (StartChartSignalRescan above) still has slices left for
   //--- AdvanceChartSignalRescan to drain - polled by Warrior_EA.mq5's FinalizeSignalsRescanIfDone() to
   //--- know when it's safe to (re)apply arrow visibility and report the Show Signals click as complete.
   bool              RescanPending(void) const { return m_rescanPending; }
   //--- forces a save of the network's current in-memory weights/state regardless of era-completion
   //--- state; called from OnDeinit() so shutdown/chart-removal never loses more than the current tick
   //--- of learning, and a subsequent restart's Train() resumes from m_eraCount rather than the last
   //--- fully-completed era only.
   //--- Heavy weight/state persistence ONLY (net weights + calibration sidecar + shadow net). Split out
   //--- from PersistOnShutdown() so OnDeinit() can run the cheap chart save+purge FIRST: on the CPU-DLL
   //--- box this recursive save (two full nets) is the slow/fragile step, and if it ever stalls past MT5's
   //--- deinit budget or faults, the arrows and status panel must already be gone, not stranded on the
   //--- chart (the reported "cleanup not going well - signals/panel stay after Abnormal termination").
   bool              PersistWeightsOnShutdown(void)
     {
      if(CheckPointer(Net) == POINTER_INVALID || !m_isInitialized)
         return false;
      //--- An inference-only run (any Strategy Tester pass - see m_inferenceOnly) trains NOTHING, so there
      //--- is no new state to persist and this save can only do harm. It is exactly what corrupted the
      //--- tester cache on 2026-07-26: when the seeded load failed, the !netLoaded path reset the in-memory
      //--- state to a fresh untrained net (era 0), and this unconditional shutdown save then wrote THAT
      //--- over the good seeded copy - which, because seeding only re-runs when the cache file is absent,
      //--- silently poisoned every subsequent backtest. Skipping it makes the tester cache strictly
      //--- read-only for single backtests: it can only ever be (re)written by the seed copy from
      //--- production, never by a run's own in-memory state.
      if(m_inferenceOnly)
        {
         PrintVerbose(ID + ": inference-only run - skipping the shutdown weight save (nothing was trained; the cached model is left exactly as seeded).");
         return true;
        }
      //--- Nothing trained and nothing loaded => there is no state to persist, and writing anyway is
      //--- actively harmful. This is what defeated the panel's reset-weights button: ResetWeights
      //--- correctly deletes the .nnw/.cfg/.stats/_ckpt/_shadow set and the .arrows sidecar, but if the
      //--- EA is then detached before a single era completes, THIS save immediately re-created a .nnw
      //--- from the freshly-built, never-run net - so the next attach loaded an era-0 stub instead of
      //--- starting clean. For LSTM/HYBRID that stub is worse than useless: a layer that has never run a
      //--- forward pass has m_iInputs<=0, so CNeuronLSTMOCL::Save omits every LSTM buffer (see the note
      //--- in its Load()). m_eraCount==0 && !m_modelLoadedFromDisk is exactly the state ResetWeights
      //--- leaves behind, and also the first-ever-attach state - both cases have nothing worth writing.
      if(m_eraCount == 0 && !m_modelLoadedFromDisk)
        {
         PrintVerbose(ID + ": no era completed and no model loaded - skipping the shutdown weight save (leaving the model files absent so the next attach starts genuinely clean).");
         return true;
        }
      double currentIndicatorParams[];
      m_indicatorTuner.Flatten(currentIndicatorParams);
      bool ok = Net.Save(m_activeFileName + ".nnw", dError, dUndefine, dForecast, dtStudied, m_activeFileCommon, m_eraCount, m_trainingComplete, currentIndicatorParams);
      //--- calibration state (class priors + confidence scale) must travel with the weights so live
      //--- trading behaves like training after a restart - see SaveModelStats().
      if(!SaveModelStats(m_activeFileName, m_activeFileCommon))
         Print(ID + ": ERROR - shutdown SaveModelStats failed for " + m_activeFileName + ". Calibration state not persisted.");
      //--- Deliberately do NOT save the shadow net here. On the CPU-DLL box a second full-net write
      //--- (~18MB) roughly DOUBLES the shutdown cost, and OnDeinit has a limited budget before MT5 reports
      //--- "Abnormal termination" and skips the rest of the teardown. (An earlier revision also blamed that
      //--- overrun for the "failed to allocate layer 0" reloads; that was a misdiagnosis - the real cause
      //--- was a lost virtual override in the read path, see AI\Network.mqh's CLayer::CreateElement note.
      //--- Halving the shutdown cost is still worth it on its own.) The shadow is NOT lost: it is saved
      //--- every era (Train()), at FinalizeTrainRun(), and every ONLINE_LEARN_PERSIST_EVERY bars during
      //--- online learning, and it self-heals (EnsureShadowNet re-blends from the main Net when
      //--- missing/stale). Worst case a
      //--- shutdown loses only the shadow's in-progress-era drift, which re-converges - a far better
      //--- trade than risking the whole model to an over-budget shutdown.
      if(!ok)
         Print(ID + ": ERROR - failed to persist weights on shutdown for " + m_activeFileName + ", error " + IntegerToString(GetLastError()));
      else
         PrintVerbose(ID + ": weights persisted on shutdown (era " + IntegerToString(m_eraCount) + ", trainingComplete=" + (string)m_trainingComplete + ")");
      return ok;
     }
   //--- Persist the drawn arrows to disk, then remove THIS EA's chart visuals (arrows + status label).
   //--- Called early in OnDeinit(), before the heavy weight save, so a later stall/fault in the save can
   //--- never leave the chart littered. Idempotent - the destructor's PurgeChart() then simply no-ops.
   //--- Deliberately NOT part of SaveWeightsNow(): a mid-session manual save must not wipe the chart.
   //---
   //--- 2026-08-01: there used to be a SECOND behaviour here, selected by a `preserveChartArrows` flag the
   //--- caller derived from the deinit reason - on a recompile / input change / template swap / symbol
   //--- change the arrows were deliberately LEFT on the chart, on the theory that an in-process reload
   //--- should not flicker. It is gone, and the flag with it. Three reasons, in order of weight:
   //---   1. It is the reported defect. "The EA removes its panel and label but its signals stay" is what
   //---      that branch does by design, and an operator has no way to tell a deliberate warm-reload
   //---      preserve from a cleanup that failed.
   //---   2. It was only correct when the reload keeps the SAME config. Change an input that feeds the
   //---      weights fingerprint - which is exactly what REASON_PARAMETERS means - and the preserved
   //---      arrows belong to a model this chart is no longer running, with nothing to mark them stale.
   //---   3. The save/restore mechanism it was avoiding already handles this case, progressively and
   //---      without blocking OnInit (LoadChartSignals + AdvanceChartSignalRestore). Keeping a second,
   //---      subtly different route to the same outcome bought a few hundred milliseconds of flicker.
   //--- One path now: persist, clear, restore on the next attach if a model for this config exists.
   void              ShutdownChartCleanup(void)
     {
      PersistAndClearChartSignals();
     }
   //--- Full shutdown persistence (weights + arrows), preserved for the panel's manual "save weights"
   //--- button (SaveWeightsNow) - does NOT purge the chart. OnDeinit no longer calls this; it runs
   //--- ShutdownChartCleanup() then PersistWeightsOnShutdown() so cleanup can't be starved by the save.
   bool              PersistOnShutdown(void)
     {
      bool ok = PersistWeightsOnShutdown();
      //--- Persist the drawn arrows too so a re-add/recompile restores them without a retrain.
      SaveChartSignals();
      return ok;
     }
   //--- explicit manual save, identical persistence to PersistOnShutdown() but user-triggered from the panel
   bool              SaveWeightsNow(void) { return PersistOnShutdown(); }
   //--- reloads this signal's current-config weights file from disk, discarding any unsaved in-memory
   //--- training progress since the last successful save
   bool              LoadWeightsNow(void)
     {
      if(CheckPointer(Net) == POINTER_INVALID)
         return false;
      double loadedIndicatorParams[];
      bool netLoaded = Net.Load(m_activeFileName + ".nnw", dError, dUndefine, dForecast, dtStudied, m_activeFileCommon, m_eraCount, m_trainingComplete, loadedIndicatorParams);
      if(!netLoaded)
        {
         Print(ID + ": ERROR - failed to load weights from " + m_activeFileName + ".nnw, error " + IntegerToString(GetLastError()));
         return false;
        }
         m_modelLoadedFromDisk = true;
      //--- the file may carry a superseded architecture - correct it before anything reads the net
      EnforceTopologyContract();
      //--- restore the calibration state that pairs with these weights (priors + confidence scale) so a
      //--- manual reload keeps live decisions calibrated exactly as the saved model was - see LoadModelStats().
      LoadModelStats(m_activeFileName, m_activeFileCommon);
      if(ArraySize(loadedIndicatorParams) == AD_TUNE_PARAM_COUNT)
        {
         //--- same no-change guard as the resume path - see AdoptIndicatorParams
         if(m_indicatorsPtr != NULL)
            AdoptIndicatorParams(loadedIndicatorParams, m_indicatorsPtr);
         else
            m_indicatorTuner.Unflatten(loadedIndicatorParams);
        }
      //--- this just swapped dtStudied/m_eraCount/Net's weights out from under whatever a chunked
      //--- Train() run (see its declaration comment) had cached for the era/trial it was mid-way
      //--- through - discard that resumable state so the next Train() call starts a fresh era
      //--- against the just-loaded dtStudied instead of resuming bar-loop bookkeeping computed
      //--- against a now-stale one.
      m_trainRunActive = false;
      m_eraResumePending = false;
      m_haveOosCheckpoint = false;
      m_checkpointEra = -1;   // the joint-checkpoint era stamp goes with the snapshot it describes
      m_oosWindow.Clear();
      m_tuneTrialIndex = -1;
      RefreshLatestSignal();
      Print(ID + ": weights reloaded from disk (era " + IntegerToString(m_eraCount) + ", trainingComplete=" + (string)m_trainingComplete + ")");
      return true;
     }
   //--- deletes this signal's current-config saved files only (weights, topology config, in-progress
   //--- checkpoint) and rebuilds a fresh untrained topology in memory so training restarts from era 0.
   //--- Never touches another signal type's or another symbol/timeframe's files - m_fileName already
   //--- embeds symbol+period+id+output-count+opt-algo.
   bool              ResetWeights(void)
     {
      bool stopped = m_trainingStopRequested;
      m_trainingStopRequested = true; // hold off any in-flight Train() scheduling while we reset
      //--- targets whichever file this run is actually training against (see InitNeuralNetwork): the
      //--- shared production weights normally, or the local tester/optimizer cache during a backtest -
      //--- so resetting from the panel during a visual-mode backtest can never wipe the live model.
      int flags = m_activeFileCommon ? FILE_COMMON : 0;
      string nnw = m_activeFileName + ".nnw";
      string cfg = m_activeFileName + ".cfg";
      string ckpt = m_activeFileName + "_ckpt.tmp";
      //--- The calibration/online-learning sidecar (.stats: priors, confidence scale, CPU-inference marker,
      //--- and the online watermark/guardrail - see SaveModelStats) and the deployed EMA shadow
      //--- (_shadow.nnw - see SaveShadowNet) both pair with the weights being erased. Delete them too, or
      //--- a fresh retrain would silently inherit the OLD model's calibration and blend into a stale shadow
      //--- (EnsureShadowNet loads _shadow.nnw from disk before it ever clones the new Net).
      string stats = m_activeFileName + ".stats";
      string shadow = m_activeFileName + "_shadow.nnw";
      //--- EnsureShadowNet clones the live net through this temp file (see CloneNetInto). A crash or a
      //--- reset mid-clone leaves it on disk shaped for the model being erased; sweep it with the rest.
      string shadowClone = m_activeFileName + "_shadowclone.tmp";
      //--- SAY WHAT HAPPENED TO EVERY FILE. Until now this block printed only on a delete FAILURE, so the
      //--- entire success path of a four-member ensemble reset was six silent operations per member and
      //--- one chart-wide Alert - which is precisely why "it only wiped the first model" could not be
      //--- settled from a log. Absent files are reported too: "absent" on a member that should have had a
      //--- .nnw is a completely different fault from "deleted", and they were indistinguishable.
      int filesDeleted = 0, filesAbsent = 0, filesFailed = 0;
      string wipeReport = "";
      string targets[6];
      targets[0] = nnw;
      targets[1] = cfg;
      targets[2] = ckpt;
      targets[3] = stats;
      targets[4] = shadow;
      targets[5] = shadowClone;
      for(int fi = 0; fi < 6; fi++)
        {
         ResetLastError();
         string leaf = targets[fi];
         //--- name the SUFFIX only in the per-file summary; the full path is printed once, below it
         string shortName = StringSubstr(targets[fi], StringLen(m_activeFileName));
         if(!FileIsExist(leaf, flags))
           {
            filesAbsent++;
            wipeReport += StringFormat("%s%s=absent", (wipeReport == "" ? "" : " "), shortName);
            continue;
           }
         if(FileDelete(leaf, flags))
           {
            filesDeleted++;
            wipeReport += StringFormat("%s%s=deleted", (wipeReport == "" ? "" : " "), shortName);
           }
         else
           {
            filesFailed++;
            wipeReport += StringFormat("%s%s=FAILED(%d)", (wipeReport == "" ? "" : " "),
                                       shortName, GetLastError());
            Print(ID + ": ERROR - failed to delete " + leaf + ", error " + IntegerToString(GetLastError()));
           }
        }
      PrintFormat("%s: RESET WIPE of %s - %d deleted, %d already absent, %d FAILED | %s",
                  ID, m_activeFileName, filesDeleted, filesAbsent, filesFailed, wipeReport);
      //--- The drawn signal arrows and their .arrows sidecar belong to the model being erased, exactly
      //--- like the .stats/_shadow sidecars above - see ClearPersistedChartSignals().
      ClearPersistedChartSignals("weights reset from the panel");
      m_eraCount = 0;
      m_trainingComplete = false;
      m_modelLoadedFromDisk = false;
      dtStudied = 0;
      dError = -1;
      dUndefine = 0;
      dForecast = 0;
      dPrevSignal = 0;
      m_nmsLiveBuyTime = 0;
      m_nmsLiveSellTime = 0;
      m_nmsLiveBuyAccept = false;
      m_nmsLiveSellAccept = false;
      m_nmsLiveKeptTime = 0;
      m_nmsLiveKeptDir = Neutral;
      m_nmsLiveKeptConf = 0;
      dOosError = -1;
      dOosForecast = 0;
      m_oosSamples = 0;
      //--- fresh model => wipe the compounded/persistent accuracy history too (it is only reset here; a
      //--- normal restart restores it from .stats, and it survives era-to-era). See m_cumIsCorrect.
      m_cumIsCorrect = 0;
      m_cumIsTotal = 0;
      m_cumOosCorrect = 0;
      m_cumOosTotal = 0;
      //--- ENSEMBLE: the panel's combined-vote accuracy is the same kind of lifetime counter (see
      //--- g_ensCumOosCorrect's declaration comment), so a reset here must wipe it too, or the panel
      //--- would keep quoting a win-rate measured partly against weights that no longer exist.
      if(m_ensembleMember)
        {
         g_ensCumOosCorrect = 0;
         g_ensCumOosTotal = 0;
        }
      //--- discard any in-progress chunked run/tuning state - it references buffers/checkpoints from
      //--- before this reset and must never be resumed into the freshly rebuilt topology below
      m_trainRunActive = false;
      m_eraResumePending = false;
      m_haveOosCheckpoint = false;
      m_checkpointEra = -1;   // the joint-checkpoint era stamp goes with the snapshot it describes
      m_oosWindow.Clear();
      m_syncWaitStartTick = 0;
      m_tuneTrialIndex = -1;
      //--- an explicit reset restarts from era 0 against a fresh topology - re-verify history sync and
      //--- rebuild the label cache too, and drop any in-flight continual-learning OOS simulation, since
      //--- both would otherwise reference bars/weights from before this reset.
      m_warmupPassesRemaining = 3;
      m_labelCacheBars = 0;
      m_labelCacheAnchorTime = 0;
      m_labelCachePrebuilt = false;
      m_labelPrebuildActive = false;
      m_prebuildSeedPending = false;
      if(m_simOosRunActive)
        {
         delete m_simOosNet;
         m_simOosNet = NULL;
         m_simOosRunActive = false;
        }
      //--- Re-seed before building a fresh topology so weight init is genuinely random, not dominated
      //--- by whatever fixed/deterministic seed the genetic tuner's last candidate evaluation left in
      //--- the MQL5 RNG state. Matches the tuner's own post-tune rebuild path
      //--- (line ~5071) and Warrior_EA.mq5's OnInit.
      MathSrand(GetTickCount());
      bool rebuilt = BuildFreshTopology();
      if(!rebuilt)
         Print(ID + ": ERROR - failed to rebuild fresh topology after weights reset");
      else
        {
         //--- Stamp the config fingerprint with isInitialized=FALSE, NOT m_isInitialized. The compare in
         //--- InitNeuralNetwork (and its own fresh-start .cfg write) always run before m_isInitialized is
         //--- set true at the end of init, so they always use false. ResetWeights is invoked from the panel
         //--- AFTER init, where m_isInitialized is true - passing it here would make this the ONLY .cfg on
         //--- disk with isInitialized=true, so the very next attach spuriously fails the compare
         //--- ("Configuration mismatch. Deleting file") and needlessly discards the weights we just reset.
         //--- This flag is runtime lifecycle state, not a topology/input parameter, so it must never gate reuse.
         SaveTopologyConfiguration(m_activeFileName, m_initialNeuronsCount, m_hiddenLayersCount, m_neuronsReduction, m_minNeuronsCount, m_optimizationAlgo, m_historyBars, m_outputNeuronsCount, m_neuronsCount, LEGACY_STUDY_PERIOD_SLOT, m_minTrainYear, false, LEGACY_CONVERGE_WR_SLOT, m_fractalPeriods, m_convFilterCount, m_lstmHiddenSize, m_activeFileCommon);
         Print(ID + ": weights reset - training will restart from era 0 (current config only: " + m_activeFileName + ")");
        }
      m_trainingStopRequested = stopped;
      if(!stopped && !bEventStudy)
         ArmStudyEvent(0, "Reset");
      return rebuilt;
     }
  };
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| IMPLEMENTATION                                                    |
//|                                                                  |
//| CExpertSignalAIBase's method bodies live in these partial files.  |
//| They MUST be included here, after the class declaration above,    |
//| and nowhere else. Order between them does not matter - they are   |
//| all out-of-class definitions of an already-declared class.        |
//|                                                                  |
//| The class was ~8200 lines in one file; this splits the bodies by  |
//| responsibility so a change to, say, chart drawing no longer means |
//| scrolling past the era loop. Nothing was rewritten in the move.   |
//+------------------------------------------------------------------+
#include "AIBase\Training.mqh"
#include "AIBase\Lifecycle.mqh"
#include "AIBase\Topology.mqh"
#include "AIBase\Labels.mqh"
#include "AIBase\OnlineLearning.mqh"
#include "AIBase\AutoTune.mqh"
#include "AIBase\Inference.mqh"
#include "AIBase\Persistence.mqh"
#include "AIBase\ChartUI.mqh"
#include "AIBase\Features.mqh"
#include "AIBase\Excursion.mqh"
#include "AIBase\PooledGate.mqh"
//+------------------------------------------------------------------+