diff --git a/DataMemo/ValidationHardening_v026.md b/DataMemo/ValidationHardening_v026.md
new file mode 100644
index 0000000..cbbc6bf
--- /dev/null
+++ b/DataMemo/ValidationHardening_v026.md
@@ -0,0 +1,161 @@
+# Validation Hardening (v0.26) — Purged Chronological Splits and What They Revealed
+
+> **Status:** shipped (branch `feature/v026-temporal-validation`). This memo records the
+> method, the measured random-vs-temporal deltas, and — the load-bearing part — the
+> **diagnosis** that separates leakage-removal from regime shift. The gate result is a *pass
+> with a mandate*: ranking skill survives honest temporal validation; the headline PR-AUC drop
+> is the cost-basis-aging prevalence crash, which is precisely the v0.3 P0.
+>
+> Adopted from the GPT-thread architecture review, §4 item 1 and §5 (v0.26) of
+> `DataMemo/temp/direct_indexing_concept_architecture_plan_contextualized.md`.
+
+---
+
+## 1. Why the old splits were suspect
+
+Every model in v0.1–v0.25 was selected and evaluated under **stratified *random*** splits
+(`StratifiedSplit` / `StratifiedKFold`). But the soft labels are **forward-looking**:
+`Y_Soft_BT(x_t)` is a deterministic function of prices over the window `(t, t+30]`. Two rows
+whose timesteps are within 30 trading days therefore share overlapping future context. A
+random split scatters such neighbours across train and test, so a model can be scored on a
+future it partially memorised in training — classic look-ahead leakage in a panel with
+overlapping labels (López de Prado, *Advances in Financial ML*, ch. 7).
+
+The report already named a chronological evaluation as "the natural next robustness check."
+v0.26 builds it.
+
+## 2. What was built
+
+Three files under `src/ML/CSharp/MLNet/Splits/`, plus a CLI surface, plus tests:
+
+- **`TemporalSplit.cs`** — pure functions on the `Timestep` axis:
+  - `TrainTest`: chronological split at a row-mass boundary; train rows within an **embargo
+    gap** `E` of the boundary are *purged*. With `E = 30`, any surviving training row at
+    `t ≤ T* − 31` has its label window `⊆ (t, T*−1]`, strictly before the test period → zero
+    overlap.
+  - `PurgedFolds`: contiguous k-fold with **both-side** embargo around each validation block
+    (the purged k-fold of the finance-ML literature — uses more data per fold than
+    forward-chaining while giving the same no-overlap guarantee).
+- **`SplitPolicy.cs`** — a process-wide mode set once from the CLI, read by every trainer.
+  Default is `StratifiedRandom`, so existing commands reproduce v0.25 numbers bit-for-bit.
+  `--split=temporal`, `--embargo=N` (default 30 = the label horizon), `--testfrac=F`
+  (`0.5` ⇒ the decade walk-forward). Temporal-mode artifacts write to
+  `data/artifacts-mlnet-temporal/` so random-split baselines are never clobbered.
+- **`DataSplit.cs`** — a facade (`TrainTest` / `Folds`) that dispatches on `SplitPolicy`. The
+  14 trainer/pipeline call sites were renamed mechanically; **the partition semantics now
+  change in exactly one place**, which is the altitude the review asked for.
+- `TemporalSplitTests` (5): boundary/embargo honesty, purge accounting, both-side fold
+  embargo + partition coverage, determinism (no RNG), facade dispatch.
+
+No trainer, metric, or preprocessing code changed — only *where the row boundary is drawn*.
+
+## 3. The measurement (canonical scalarized arm, 20y)
+
+**CV PR-AUC, stratified-random → temporal-purged (80/20):**
+
+| model | oracle rand | oracle temp | soft rand | soft temp |
+|---|---|---|---|---|
+| GBT | 0.9956 | 0.9474 | 0.8158 | 0.4267 |
+| RF | 0.9883 | 0.9252 | 0.6332 | 0.3911 |
+| logistic | 0.9804 | 0.8621 | 0.6233 | 0.3965 |
+| elastic net | 0.8107 | **0.8694** | 0.5874 | 0.3663 |
+| linreg | 0.8227 | **0.8942** | 0.5590 | 0.2775 |
+
+**Test-set GBT, the decisive pair — ROC-AUC (prevalence-*insensitive*) vs PR-AUC
+(prevalence-*bounded*):**
+
+| target · split | ROC-AUC | PR-AUC |
+|---|---|---|
+| soft · random | 0.9935 | 0.8126 |
+| soft · **temporal** | **0.9970** | 0.4585 |
+| oracle · random | 0.9986 | 0.9951 |
+| oracle · **temporal** | **1.0000** | 0.9507 |
+
+**Decade walk-forward** (`--testfrac=0.5`, train ~2006–2016, test ~2016–2026 — a full
+decade of unseen regime, the harshest generalization test):
+
+| target · split | ROC-AUC | PR-AUC |
+|---|---|---|
+| soft · decade | **0.9609** | 0.4173 |
+| oracle · decade | **1.0000** | 0.9953 |
+
+**Positive-rate by period (the confound made explicit):**
+
+| region | rows | oracle+ | soft+ |
+|---|---|---|---|
+| train (2006 – ~2022) | 1,466,887 | 0.246% | 3.931% |
+| test (~2022 – 2026, last 3.6y) | 369,969 | **0.012%** | **0.221%** |
+| decade test (~2016 – 2026) | 924,909 | 0.018% | 0.333% |
+
+## 4. Diagnosis — leakage vs. regime, disentangled
+
+The PR-AUC collapse looks alarming (soft GBT 0.81 → 0.46) until you read it against ROC-AUC:
+
+1. **ROC-AUC did not drop under the honest split — and the oracle target proves it isn't
+   leakage.** ROC-AUC measures *ranking*: P(model scores a random positive above a random
+   negative). It is insensitive to class prevalence. The **oracle target is the clean leakage
+   control**: it is a deterministic function of the current-timestep features, so if random
+   splits had leaked future context into the ranking, its ROC-AUC would read *inflated* under
+   random and *drop* under temporal. Instead it is flat and perfect across all three splits —
+   0.9986 (random) → 1.0000 (temporal 80/20) → 1.0000 (decade). **Leakage is ruled out.** The
+   soft target's ROC likewise holds under the mild 80/20 split (0.9935 → 0.9970). **The
+   champions' ranking skill transfers across time; there was no material ranking leakage.**
+
+   *Nuance the decade split adds:* under the harshest test — train on 2006–2016 only, predict
+   a full unseen decade — the *soft* ROC-AUC dips to 0.9609 (from ~0.997). That is **genuine
+   regime-generalization decay**, not leakage (the deterministic oracle stays 1.0000): a model
+   that never saw 2016–2026 ranks its harvest propensity slightly less sharply. 0.96 is still
+   strong ranking; the point is that the decade split *distinguishes* mild honest drift from
+   the leakage the 80/20 split alone could not isolate.
+
+2. **PR-AUC is prevalence-bounded, and the test-period prevalence crashed 18×.** The no-skill
+   AUPRC *equals* the positive rate, and the whole PR curve scales with it. The temporal test
+   period is the cost-basis-*aged* tail: soft+ falls from 3.93% (train era) to 0.22% (test
+   era). Identical ranking scored on an 18×-rarer positive class yields a mechanically lower
+   AUPRC. In **lift over no-skill**, the temporal model is *better*, not worse: 0.81/0.032 ≈
+   25× (random) vs 0.46/0.0022 ≈ **210×** (temporal).
+
+3. **Why the tail is so sparse: cost-basis aging (the report's #1 finding).** Lots opened once
+   at warmup hold their basis for two decades; by 2022 a position is so deep in the money that
+   even a bear market cannot push it 2% underwater. The recent years are a near-dead harvest
+   regime *by construction of the current simulator*, not by market calm.
+
+4. **The CV-table wrinkle confirms it.** Raw-linear models (elastic net, linreg) *improve* on
+   the oracle target under temporal splits (0.81 → 0.87, 0.82 → 0.89) while the trees dip
+   slightly — consistent with an aged-out tail whose boundary is *simpler* (few, deep-loss
+   positives), which a hyperplane handles better and leaves the trees less to exploit.
+
+**Conclusion.** The v0.1–v0.25 random-split PR-AUC was **not leakage-inflated in its ranking
+content** (ROC held), but it **was a regime-averaged number** dominated by the harvest-rich
+early years — a figure a chronologically-deployed system will not see once its book ages. The
+honest performance statement going forward is the pair: *ranking (ROC-AUC) is robust across
+time; absolute precision-recall (PR-AUC) is regime-dependent and low in aged-out books.*
+
+## 5. Gate decision → v0.3 mandate
+
+**Pass.** The champions survive honest temporal validation on the metric that measures skill.
+The one thing the harder split exposed — the aged-out-tail prevalence crash — is not a
+methodology failure; it is the strongest possible motivation for the **v0.3 cost-basis-aging
+fix** (contributions / rebalancing / the sell-winner trim), which restores harvestable supply
+→ recovers test-period prevalence → recovers PR-AUC without touching ranking.
+
+**Standing methodology change from v0.26 on:** report **ROC-AUC, PR-AUC, and test-period
+positive-rate together** — never PR-AUC alone — and prefer `--split=temporal` for any claim
+about deployed-forward performance. Random splits remain the default only for reproducing the
+historical v0.25 ablation numbers.
+
+## 6. Reproduce
+
+```text
+# canonical arm, honest 80/20 temporal split (embargo = 30d label horizon):
+dotnet run mlnet-oracle --split=temporal      # → data/artifacts-mlnet-temporal/
+dotnet run mlnet-soft   --split=temporal
+# decade walk-forward (train ~2006–2016, test ~2016–2026):
+dotnet run mlnet-oracle --split=temporal --testfrac=0.5
+dotnet run mlnet-soft   --split=temporal --testfrac=0.5
+```
+
+*Cross-references: `GYTD_Redesign_Plan.md` §6.1 (the random-split ablation this hardens);
+the report's cost-basis-aging section (the prevalence-crash mechanism);
+`DataMemo/temp/direct_indexing_concept_architecture_plan_contextualized.md` §4–§5 (why v0.26
+gates v0.3). Method: López de Prado, purged & embargoed cross-validation.*
diff --git a/src/ML/CSharp/MLNet/Models/ElasticNetTrainer.cs b/src/ML/CSharp/MLNet/Models/ElasticNetTrainer.cs
index 5086558..d90b261 100644
--- a/src/ML/CSharp/MLNet/Models/ElasticNetTrainer.cs
+++ b/src/ML/CSharp/MLNet/Models/ElasticNetTrainer.cs
@@ -46,7 +46,7 @@ public static CvResult RunCV(
         string target)
     {
         var (filtered, label) = SelectTarget(data, target);
-        var (train, _) = StratifiedSplit.Split(
+        var (train, _) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var search = GridSearchCV.Search(
@@ -67,7 +67,7 @@ public static ElasticNetOutput Run(
         string target)
     {
         var (filtered, label) = SelectTarget(data, target);
-        var (train, test) = StratifiedSplit.Split(
+        var (train, test) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var search = GridSearchCV.Search(
diff --git a/src/ML/CSharp/MLNet/Models/GradientBoostedTreesTrainer.cs b/src/ML/CSharp/MLNet/Models/GradientBoostedTreesTrainer.cs
index 6b5a867..59896aa 100644
--- a/src/ML/CSharp/MLNet/Models/GradientBoostedTreesTrainer.cs
+++ b/src/ML/CSharp/MLNet/Models/GradientBoostedTreesTrainer.cs
@@ -44,7 +44,7 @@ public static CvResult RunCV(
         string target)
     {
         var (filtered, label) = SelectTarget(data, target);
-        var (train, _) = StratifiedSplit.Split(
+        var (train, _) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var search = GridSearchCV.Search(
@@ -65,7 +65,7 @@ public static GbtOutput Run(
         string target)
     {
         var (filtered, label) = SelectTarget(data, target);
-        var (train, test) = StratifiedSplit.Split(
+        var (train, test) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var search = GridSearchCV.Search(
diff --git a/src/ML/CSharp/MLNet/Models/LinearRegressionTrainer.cs b/src/ML/CSharp/MLNet/Models/LinearRegressionTrainer.cs
index 89b34e6..e148fcf 100644
--- a/src/ML/CSharp/MLNet/Models/LinearRegressionTrainer.cs
+++ b/src/ML/CSharp/MLNet/Models/LinearRegressionTrainer.cs
@@ -60,7 +60,7 @@ public static CvResult RunCV(
         string target)
     {
         var (filtered, label) = SelectTarget(data, target);
-        var (train, _) = StratifiedSplit.Split(
+        var (train, _) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var (best, foldScores, all) = InlineCvSearch(ml, train, label, k: 5);
@@ -79,7 +79,7 @@ public static LinRegOutput Run(
         string target)
     {
         var (filtered, label) = SelectTarget(data, target);
-        var (train, test) = StratifiedSplit.Split(
+        var (train, test) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var (bestParams, perFoldScores, all) = InlineCvSearch(ml, train, label, k: 5);
@@ -143,7 +143,7 @@ private static (Dictionary<string, object> Best, double[] FoldScores,
             int k)
     {
         var grid  = BuildGrid();
-        var folds = StratifiedKFold.Folds(trainData, r => label(r) ? 1 : 0, k, seed: 42).ToArray();
+        var folds = DataSplit.Folds(trainData, r => label(r) ? 1 : 0, k, seed: 42).ToArray();
 
         var all = new List<(Dictionary<string, object> Params, double Mean)>();
         Dictionary<string, object>? bestParams = null;
diff --git a/src/ML/CSharp/MLNet/Models/LogisticTrainer.cs b/src/ML/CSharp/MLNet/Models/LogisticTrainer.cs
index 1e3efa7..190ae2e 100644
--- a/src/ML/CSharp/MLNet/Models/LogisticTrainer.cs
+++ b/src/ML/CSharp/MLNet/Models/LogisticTrainer.cs
@@ -44,7 +44,7 @@ public static CvResult RunCV(
         string target)
     {
         var (filtered, label) = SelectTarget(data, target);
-        var (train, _) = StratifiedSplit.Split(
+        var (train, _) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var grid = new Dictionary<string, object[]>
@@ -71,7 +71,7 @@ public static LogisticOutput Run(
     {
         var (filtered, label) = SelectTarget(data, target);
 
-        var (train, test) = StratifiedSplit.Split(
+        var (train, test) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         // Grid search on training fold only.
diff --git a/src/ML/CSharp/MLNet/Models/PcaPipeline.cs b/src/ML/CSharp/MLNet/Models/PcaPipeline.cs
index 3ccd87f..063871f 100644
--- a/src/ML/CSharp/MLNet/Models/PcaPipeline.cs
+++ b/src/ML/CSharp/MLNet/Models/PcaPipeline.cs
@@ -38,7 +38,7 @@ public static PcaOutput Run(
         // and median-impute would distort the principal axes here.
         var clean = data.Where(NoNumericNaN).ToList();
 
-        var (train, _) = StratifiedSplit.Split(
+        var (train, _) = DataSplit.TrainTest(
             clean, r => r.Y_Oracle, testFraction: 0.20, seed: 42);
 
         var medians = MedianImputer.Fit(train);
diff --git a/src/ML/CSharp/MLNet/Models/RandomForestTrainer.cs b/src/ML/CSharp/MLNet/Models/RandomForestTrainer.cs
index b22b3bc..4d9652c 100644
--- a/src/ML/CSharp/MLNet/Models/RandomForestTrainer.cs
+++ b/src/ML/CSharp/MLNet/Models/RandomForestTrainer.cs
@@ -46,7 +46,7 @@ public static CvResult RunCV(
         string target)
     {
         var (filtered, label) = SelectTarget(data, target);
-        var (train, _) = StratifiedSplit.Split(
+        var (train, _) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var search = GridSearchCV.Search(
@@ -67,7 +67,7 @@ public static RfOutput Run(
         string target)
     {
         var (filtered, label) = SelectTarget(data, target);
-        var (train, test) = StratifiedSplit.Split(
+        var (train, test) = DataSplit.TrainTest(
             filtered, r => label(r) ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var search = GridSearchCV.Search(
diff --git a/src/ML/CSharp/MLNet/Models/TaxValueRegressionPipeline.cs b/src/ML/CSharp/MLNet/Models/TaxValueRegressionPipeline.cs
index afa5372..e7322f5 100644
--- a/src/ML/CSharp/MLNet/Models/TaxValueRegressionPipeline.cs
+++ b/src/ML/CSharp/MLNet/Models/TaxValueRegressionPipeline.cs
@@ -44,7 +44,7 @@ public static void Run(
         Directory.CreateDirectory(artifactsDir);
         var ml = new MLContext(seed: 42);
 
-        var (train, test) = StratifiedSplit.Split(
+        var (train, test) = DataSplit.TrainTest(
             data, r => r.Y_TaxValue > 0f ? 1 : 0, testFraction: 0.20, seed: 42);
 
         var medians   = MedianImputer.Fit(train);
diff --git a/src/ML/CSharp/MLNet/Splits/DataSplit.cs b/src/ML/CSharp/MLNet/Splits/DataSplit.cs
new file mode 100644
index 0000000..d195ac7
--- /dev/null
+++ b/src/ML/CSharp/MLNet/Splits/DataSplit.cs
@@ -0,0 +1,39 @@
+using DirectIndexing.Core.Portfolio;
+
+namespace DirectIndexing.ML.MLNet.Splits;
+
+/// <summary>
+/// The single entry point trainers use for partitioning (v0.26). Dispatches on
+/// <see cref="SplitPolicy"/>: legacy stratified-random by default, chronological
+/// purged splits under <c>--split=temporal</c>. Signatures mirror the legacy
+/// utilities exactly, so the 12 trainer call sites changed names only.
+///
+/// In temporal mode the label selector is unused (no stratification — regime
+/// prevalence is the object of study) and the seed is irrelevant (deterministic
+/// order); both parameters remain so call sites stay uniform.
+/// </summary>
+public static class DataSplit
+{
+    public static (List<LotStateVector> Train, List<LotStateVector> Test) TrainTest(
+        IReadOnlyList<LotStateVector> data,
+        Func<LotStateVector, int> labelSelector,
+        double testFraction = 0.20,
+        int seed = 42)
+    {
+        double frac = SplitPolicy.TestFractionOverride ?? testFraction;
+        return SplitPolicy.Mode == SplitMode.TemporalPurged
+            ? TemporalSplit.TrainTest(data, frac, SplitPolicy.EmbargoDays)
+            : StratifiedSplit.Split(data, labelSelector, frac, seed);
+    }
+
+    public static IEnumerable<(List<LotStateVector> Train, List<LotStateVector> Val)> Folds(
+        IReadOnlyList<LotStateVector> data,
+        Func<LotStateVector, int> labelSelector,
+        int k = 5,
+        int seed = 42)
+    {
+        return SplitPolicy.Mode == SplitMode.TemporalPurged
+            ? TemporalSplit.PurgedFolds(data, k, SplitPolicy.EmbargoDays)
+            : StratifiedKFold.Folds(data, labelSelector, k, seed);
+    }
+}
diff --git a/src/ML/CSharp/MLNet/Splits/SplitPolicy.cs b/src/ML/CSharp/MLNet/Splits/SplitPolicy.cs
new file mode 100644
index 0000000..6f23f0e
--- /dev/null
+++ b/src/ML/CSharp/MLNet/Splits/SplitPolicy.cs
@@ -0,0 +1,56 @@
+namespace DirectIndexing.ML.MLNet.Splits;
+
+/// <summary>How train/test and CV partitions are drawn (v0.26, validation hardening).</summary>
+public enum SplitMode
+{
+    /// <summary>v0.1–v0.25 behaviour: per-class shuffle, random assignment.</summary>
+    StratifiedRandom,
+
+    /// <summary>
+    /// Chronological split on Timestep with a purge/embargo gap. Required for
+    /// honest evaluation of the forward-looking soft labels: Y_Soft_BT at time t
+    /// is a function of prices over (t, t+30], so adjacent rows share future
+    /// context and a random split leaks it across the train/test boundary.
+    /// </summary>
+    TemporalPurged,
+}
+
+/// <summary>
+/// Process-wide split policy, set once by Program.cs from the CLI
+/// (<c>--split=temporal</c>, <c>--embargo=N</c>, <c>--testfrac=F</c>) before any
+/// trainer runs. Trainers call the <see cref="DataSplit"/> facade, which
+/// dispatches on this policy — 12 call sites stay signature-identical while the
+/// partition semantics change in exactly one place.
+///
+/// Default is the legacy stratified-random mode so existing commands reproduce
+/// v0.25 numbers bit-for-bit unless the flag is passed.
+/// </summary>
+public static class SplitPolicy
+{
+    public static SplitMode Mode { get; set; } = SplitMode.StratifiedRandom;
+
+    /// <summary>
+    /// Purge gap in trading days (Timestep units) excised around every
+    /// train/boundary edge. Must be ≥ the forward-label horizon (30 for
+    /// Y_Soft_BT / Y_Soft_GBM) so no training label window overlaps the
+    /// evaluation period.
+    /// </summary>
+    public static int EmbargoDays { get; set; } = 30;
+
+    /// <summary>
+    /// When set, overrides the testFraction trainers pass at their call sites
+    /// (they hardcode 0.20). Used for the decade walk-forward experiment
+    /// (e.g. 0.5 → train 2006–16, test 2016–26).
+    /// </summary>
+    public static double? TestFractionOverride { get; set; } = null;
+
+    /// <summary>Suffix for artifact directories so ablation arms never overwrite each other.</summary>
+    public static string ArtifactTag =>
+        Mode == SplitMode.TemporalPurged ? "-temporal" : "";
+
+    public static string Describe() =>
+        Mode == SplitMode.StratifiedRandom
+            ? "stratified-random (legacy)"
+            : $"temporal-purged (embargo={EmbargoDays}d" +
+              (TestFractionOverride is { } f ? $", testFrac={f:0.##}" : "") + ")";
+}
diff --git a/src/ML/CSharp/MLNet/Splits/TemporalSplit.cs b/src/ML/CSharp/MLNet/Splits/TemporalSplit.cs
new file mode 100644
index 0000000..861cb8f
--- /dev/null
+++ b/src/ML/CSharp/MLNet/Splits/TemporalSplit.cs
@@ -0,0 +1,132 @@
+using DirectIndexing.Core.Portfolio;
+
+namespace DirectIndexing.ML.MLNet.Splits;
+
+/// <summary>
+/// Pure functions: chronological train/test split and purged contiguous k-fold
+/// on the Timestep axis (v0.26 validation hardening).
+///
+/// Why this exists: the soft labels are forward-looking — Y_Soft_BT(x_t) is a
+/// deterministic function of prices over (t, t+30] — so rows within 30 trading
+/// days of each other share future context. A stratified RANDOM split scatters
+/// such neighbours across train and test, letting the model be scored on
+/// futures it partially saw in training. The fix (López de Prado's purged
+/// splits, specialised to this panel) is:
+///
+///   1. split chronologically on Timestep, and
+///   2. PURGE every training row whose forward label window could overlap the
+///      evaluation period: drop train rows with Timestep inside an embargo gap
+///      of width E ≥ the label horizon before each evaluation block (and after
+///      it, for interior CV blocks).
+///
+/// With E = 30, a training row at t ≤ T* − 31 has label window ⊆ (t, T* − 1],
+/// strictly before an evaluation block starting at T*: zero overlap.
+///
+/// No shuffling, no stratification: class balance per period is whatever the
+/// regime produced — that is the point of the exercise. Class weights are
+/// computed per training fold downstream (ClassWeights), so imbalance is
+/// handled where it always was.
+/// </summary>
+public static class TemporalSplit
+{
+    /// <summary>
+    /// Chronological (train, test): the earliest ≈(1−testFraction) of rows by
+    /// Timestep train; the latest ≈testFraction test; train rows within
+    /// <paramref name="embargoDays"/> of the boundary are purged.
+    /// </summary>
+    public static (List<LotStateVector> Train, List<LotStateVector> Test) TrainTest(
+        IReadOnlyList<LotStateVector> data,
+        double testFraction = 0.20,
+        int embargoDays = 30)
+    {
+        if (data.Count == 0) return (new List<LotStateVector>(), new List<LotStateVector>());
+
+        int boundary = BoundaryTimestep(data, 1.0 - testFraction);
+
+        var train = new List<LotStateVector>();
+        var test  = new List<LotStateVector>(capacity: (int)(data.Count * testFraction) + 1);
+        int purged = 0;
+
+        foreach (var r in data)
+        {
+            if (r.Timestep >= boundary)              test.Add(r);
+            else if (r.Timestep > boundary - embargoDays) purged++;   // embargo gap
+            else                                     train.Add(r);
+        }
+
+        Console.WriteLine($"[TemporalSplit] boundary t={boundary}  " +
+                          $"train={train.Count:N0}  test={test.Count:N0}  " +
+                          $"purged={purged:N0} (embargo {embargoDays}d)");
+        return (train, test);
+    }
+
+    /// <summary>
+    /// Purged contiguous k-fold: the Timestep range is cut into k contiguous
+    /// blocks (equal row mass, whole-Timestep boundaries); fold i uses block i
+    /// as validation and everything OUTSIDE the block ± embargo as training —
+    /// train data sits on both sides of interior blocks, purged on both edges
+    /// (the standard purged k-fold of the finance-ML literature; it uses more
+    /// data per fold than forward-chaining while giving the same guarantee).
+    /// </summary>
+    public static IEnumerable<(List<LotStateVector> Train, List<LotStateVector> Val)> PurgedFolds(
+        IReadOnlyList<LotStateVector> data,
+        int k = 5,
+        int embargoDays = 30)
+    {
+        if (k < 2) throw new ArgumentException("k must be >= 2", nameof(k));
+
+        // Block edges as Timestep values at row-mass quantiles.
+        var edges = new int[k + 1];
+        for (int i = 0; i <= k; i++)
+            edges[i] = i == 0 ? int.MinValue
+                     : i == k ? int.MaxValue
+                     : BoundaryTimestep(data, (double)i / k);
+
+        for (int fold = 0; fold < k; fold++)
+        {
+            int lo = edges[fold], hi = edges[fold + 1];   // val block = [lo, hi)
+            var train = new List<LotStateVector>();
+            var val   = new List<LotStateVector>();
+
+            foreach (var r in data)
+            {
+                int t = r.Timestep;
+                if (t >= lo && t < hi)
+                    val.Add(r);
+                else if (WithinEmbargo(t, lo, hi, embargoDays))
+                    continue;                              // purged
+                else
+                    train.Add(r);
+            }
+            yield return (train, val);
+        }
+    }
+
+    // Timestep below which ≈ `massFraction` of rows fall (never splits a day).
+    private static int BoundaryTimestep(IReadOnlyList<LotStateVector> data, double massFraction)
+    {
+        var counts = new SortedDictionary<int, int>();
+        foreach (var r in data)
+            counts[r.Timestep] = counts.GetValueOrDefault(r.Timestep) + 1;
+
+        long target = (long)(data.Count * massFraction);
+        long seen = 0;
+        foreach (var (t, n) in counts)
+        {
+            seen += n;
+            if (seen >= target) return t + 1;   // boundary is exclusive of day t
+        }
+        return int.MaxValue;
+    }
+
+    // Train row at t is embargoed if its label window could touch [lo, hi):
+    // within embargo BEFORE the block (window reaches forward into it) or
+    // within embargo AFTER it (the block's own label windows reach forward
+    // into the row's period — symmetric purge for interior CV blocks).
+    private static bool WithinEmbargo(int t, int lo, int hi, int embargoDays)
+    {
+        bool before = lo != int.MinValue && t < lo && t > lo - embargoDays;
+        bool after  = hi != int.MaxValue && t >= hi && t < hi + embargoDays;
+        return before || after;
+    }
+}
diff --git a/src/ML/CSharp/MLNet/Tuning/GridSearchCV.cs b/src/ML/CSharp/MLNet/Tuning/GridSearchCV.cs
index 91b02b2..b3d8536 100644
--- a/src/ML/CSharp/MLNet/Tuning/GridSearchCV.cs
+++ b/src/ML/CSharp/MLNet/Tuning/GridSearchCV.cs
@@ -39,7 +39,7 @@ public static GridResult Search(
         int seed = 42)
     {
         var configs = Expand(grid).ToArray();
-        var folds   = StratifiedKFold.Folds(trainData, labelSelector, k, seed).ToArray();
+        var folds   = DataSplit.Folds(trainData, labelSelector, k, seed).ToArray();
 
         var all = new List<(IReadOnlyDictionary<string, object> Params, double MeanScore, double[] FoldScores)>();
         IReadOnlyDictionary<string, object>? bestParams = null;
diff --git a/src/Program.cs b/src/Program.cs
index afc760f..9980b5c 100644
--- a/src/Program.cs
+++ b/src/Program.cs
@@ -5,6 +5,7 @@
 using DirectIndexing.ML;
 using DirectIndexing.ML.MLNet;
 using DirectIndexing.ML.MLNet.Data;
+using DirectIndexing.ML.MLNet.Splits;
 
 var mode = args.FirstOrDefault() ?? "simulate";
 
@@ -26,6 +27,33 @@
         System.Globalization.CultureInfo.InvariantCulture, out var ctradeOverride))
     oracleCfg = oracleCfg with { CTrade = ctradeOverride };
 
+// The oracle flags only shape simulate/simulate-mc; warn instead of silently
+// no-op'ing when passed to other modes (e.g. `mlnet-oracle --oracle=gated`
+// does NOT retrain the gated arm — swap in lots_gated.csv for that).
+if (mode is not ("simulate" or "simulate-mc")
+    && (args.Contains("--oracle=gated") || ctradeArg is not null))
+    Console.WriteLine($"[WARN] --oracle/--ctrade have no effect on mode '{mode}' — " +
+                      "they configure the simulation only. mlnet-* modes read data/lots.csv as-is.");
+
+// ── Split policy (v0.26, validation hardening) ──────────────────────────────
+// --split=temporal: chronological purged splits (embargo >= 30d label horizon)
+// for every mlnet-* trainer in this run. --embargo=N and --testfrac=F tune it
+// (--testfrac=0.5 => the decade walk-forward). Artifacts write to
+// data/artifacts-mlnet-temporal/ so random-split baselines are never clobbered.
+if (args.Contains("--split=temporal"))
+    SplitPolicy.Mode = SplitMode.TemporalPurged;
+var embargoArg = args.FirstOrDefault(a => a.StartsWith("--embargo="));
+if (embargoArg is not null && int.TryParse(embargoArg["--embargo=".Length..], out var embargoDays))
+    SplitPolicy.EmbargoDays = embargoDays;
+var testfracArg = args.FirstOrDefault(a => a.StartsWith("--testfrac="));
+if (testfracArg is not null && double.TryParse(testfracArg["--testfrac=".Length..],
+        System.Globalization.NumberStyles.Float,
+        System.Globalization.CultureInfo.InvariantCulture, out var testFrac))
+    SplitPolicy.TestFractionOverride = testFrac;
+if (mode.StartsWith("mlnet"))
+    Console.WriteLine($"[SplitPolicy] {SplitPolicy.Describe()}");
+var mlnetArtifacts = $"../data/artifacts-mlnet{SplitPolicy.ArtifactTag}/";
+
 switch (mode)
 {
     case "download":
@@ -133,19 +161,19 @@
     case "mlnet-unsupervised":
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunUnsupervised(data, "../data/artifacts-mlnet/");
+        MLnetPipeline.RunUnsupervised(data, mlnetArtifacts);
     }
     break;
     case "mlnet-supervised":   // PRIMARY: logistic on Y_Soft_BT (backward compat)
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunSupervised(data, target: "soft_bt", artifactsDir: "../data/artifacts-mlnet/");
+        MLnetPipeline.RunSupervised(data, target: "soft_bt", artifactsDir: mlnetArtifacts);
     }
     break;
     case "mlnet-baseline":     // SANITY: logistic on Y_Oracle (backward compat)
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunSupervised(data, target: "oracle", artifactsDir: "../data/artifacts-mlnet/");
+        MLnetPipeline.RunSupervised(data, target: "oracle", artifactsDir: mlnetArtifacts);
     }
     break;
 
@@ -153,29 +181,29 @@
     case "mlnet-gbt":
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunSupervisedModel("gbt", data, "soft_bt", "../data/artifacts-mlnet/");
-        MLnetPipeline.RunSupervisedModel("gbt", data, "oracle",  "../data/artifacts-mlnet/");
+        MLnetPipeline.RunSupervisedModel("gbt", data, "soft_bt", mlnetArtifacts);
+        MLnetPipeline.RunSupervisedModel("gbt", data, "oracle",  mlnetArtifacts);
     }
     break;
     case "mlnet-rf":
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunSupervisedModel("rf", data, "soft_bt", "../data/artifacts-mlnet/");
-        MLnetPipeline.RunSupervisedModel("rf", data, "oracle",  "../data/artifacts-mlnet/");
+        MLnetPipeline.RunSupervisedModel("rf", data, "soft_bt", mlnetArtifacts);
+        MLnetPipeline.RunSupervisedModel("rf", data, "oracle",  mlnetArtifacts);
     }
     break;
     case "mlnet-elnet":
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunSupervisedModel("elnet", data, "soft_bt", "../data/artifacts-mlnet/");
-        MLnetPipeline.RunSupervisedModel("elnet", data, "oracle",  "../data/artifacts-mlnet/");
+        MLnetPipeline.RunSupervisedModel("elnet", data, "soft_bt", mlnetArtifacts);
+        MLnetPipeline.RunSupervisedModel("elnet", data, "oracle",  mlnetArtifacts);
     }
     break;
     case "mlnet-linreg":
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunSupervisedModel("linreg", data, "soft_bt", "../data/artifacts-mlnet/");
-        MLnetPipeline.RunSupervisedModel("linreg", data, "oracle",  "../data/artifacts-mlnet/");
+        MLnetPipeline.RunSupervisedModel("linreg", data, "soft_bt", mlnetArtifacts);
+        MLnetPipeline.RunSupervisedModel("linreg", data, "oracle",  mlnetArtifacts);
     }
     break;
 
@@ -183,8 +211,8 @@
     case "mlnet-compare":
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunAllSupervised(data, target: "soft_bt", artifactsDir: "../data/artifacts-mlnet/");
-        MLnetPipeline.RunAllSupervised(data, target: "oracle",  artifactsDir: "../data/artifacts-mlnet/");
+        MLnetPipeline.RunAllSupervised(data, target: "soft_bt", artifactsDir: mlnetArtifacts);
+        MLnetPipeline.RunAllSupervised(data, target: "oracle",  artifactsDir: mlnetArtifacts);
     }
     break;
 
@@ -193,13 +221,13 @@
     case "mlnet-soft":
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunAllSupervised(data, target: "soft_bt", artifactsDir: "../data/artifacts-mlnet/");
+        MLnetPipeline.RunAllSupervised(data, target: "soft_bt", artifactsDir: mlnetArtifacts);
     }
     break;
     case "mlnet-oracle":
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunAllSupervised(data, target: "oracle", artifactsDir: "../data/artifacts-mlnet/");
+        MLnetPipeline.RunAllSupervised(data, target: "oracle", artifactsDir: mlnetArtifacts);
     }
     break;
     // Continuous regression on Y_TaxValue (v0.25, issue #17 family). Excludes the
@@ -209,7 +237,7 @@
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
         DirectIndexing.ML.MLNet.Models.TaxValueRegressionPipeline.Run(
-            data, artifactsDir: "../data/artifacts-mlnet/");
+            data, artifactsDir: mlnetArtifacts);
     }
     break;
 
@@ -227,10 +255,10 @@
     {
         var sw = Stopwatch.StartNew();
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunUnsupervised(data, "../data/artifacts-mlnet/");
+        MLnetPipeline.RunUnsupervised(data, mlnetArtifacts);
         // Champion-selection: CV all supervised models, full eval for best 1-2 + linreg demonstration.
-        MLnetPipeline.RunAllSupervised(data, target: "soft_bt", artifactsDir: "../data/artifacts-mlnet/");
-        MLnetPipeline.RunAllSupervised(data, target: "oracle",  artifactsDir: "../data/artifacts-mlnet/");
+        MLnetPipeline.RunAllSupervised(data, target: "soft_bt", artifactsDir: mlnetArtifacts);
+        MLnetPipeline.RunAllSupervised(data, target: "oracle",  artifactsDir: mlnetArtifacts);
         var rc = MLnetPipeline.RunRender(
             lotsCsv:      "../../../data/lots.csv",
             artifactsDir: "../../../data/artifacts-mlnet/",
@@ -257,9 +285,9 @@
     case "report-all":   // mlnet-all training + report, one command
     {
         var data = LotStateVectorCsvReader.Read("../data/lots.csv");
-        MLnetPipeline.RunUnsupervised(data, "../data/artifacts-mlnet/");
-        MLnetPipeline.RunAllSupervised(data, target: "soft_bt", artifactsDir: "../data/artifacts-mlnet/");
-        MLnetPipeline.RunAllSupervised(data, target: "oracle",  artifactsDir: "../data/artifacts-mlnet/");
+        MLnetPipeline.RunUnsupervised(data, mlnetArtifacts);
+        MLnetPipeline.RunAllSupervised(data, target: "soft_bt", artifactsDir: mlnetArtifacts);
+        MLnetPipeline.RunAllSupervised(data, target: "oracle",  artifactsDir: mlnetArtifacts);
         var rc = PythonRunner.Run("scripts.report",
             "--lots",      "../../../data/lots.csv",
             "--artifacts", "../../../data/artifacts-mlnet/",
@@ -343,6 +371,13 @@
         new LotStateVectorCsvReaderTests().Test_RoundTrip_PreservesAllFields();
         new StratifiedSplitTests().Test_PreservesClassProportionWithin1Percent();
         new StratifiedKFoldTests().Test_FoldsPartitionDataAndContainPositives();
+
+        var temporalTests = new TemporalSplitTests();
+        temporalTests.Test_TrainTest_BoundaryAndEmbargo();
+        temporalTests.Test_TrainTest_PurgeAccounting();
+        temporalTests.Test_PurgedFolds_EmbargoBothSides();
+        temporalTests.Test_Deterministic();
+        temporalTests.Test_DataSplit_PolicyDispatch();
         new SilhouetteTests().Test_TwoBlobsHighSilhouette();
         var preprocessing = new PreprocessingTests();
         preprocessing.Test_MedianImputerReplacesNaNs();
diff --git a/src/Tests/TemporalSplitTests.cs b/src/Tests/TemporalSplitTests.cs
new file mode 100644
index 0000000..11b997a
--- /dev/null
+++ b/src/Tests/TemporalSplitTests.cs
@@ -0,0 +1,143 @@
+// Tests/TemporalSplitTests.cs
+using System.Diagnostics;
+using DirectIndexing.Core.Portfolio;
+using DirectIndexing.ML.MLNet.Splits;
+
+/// <summary>
+/// Unit tests for the v0.26 purged chronological splits. The invariant under
+/// test is leak-proofing: no training row's forward label window (t, t+E] may
+/// overlap any evaluation row's period.
+/// </summary>
+public class TemporalSplitTests
+{
+    // 100 timesteps × 10 rows each, positives sprinkled deterministically.
+    private static List<LotStateVector> MakePanel(int days = 100, int perDay = 10)
+    {
+        var rows = new List<LotStateVector>(days * perDay);
+        for (int t = 0; t < days; t++)
+            for (int i = 0; i < perDay; i++)
+                rows.Add(new LotStateVector
+                {
+                    Timestep = 200 + t,
+                    Symbol   = $"S{i}",
+                    Y_Oracle = (t * perDay + i) % 37 == 0 ? 1 : 0,
+                });
+        return rows;
+    }
+
+    // Test 1: chronological order + embargo gap between train and test.
+    public void Test_TrainTest_BoundaryAndEmbargo()
+    {
+        var data = MakePanel();
+        var (train, test) = TemporalSplit.TrainTest(data, testFraction: 0.20, embargoDays: 10);
+
+        int maxTrain = int.MinValue, minTest = int.MaxValue;
+        foreach (var r in train) maxTrain = Math.Max(maxTrain, r.Timestep);
+        foreach (var r in test)  minTest  = Math.Min(minTest,  r.Timestep);
+
+        Debug.Assert(maxTrain < minTest,
+            $"Train must strictly precede test, got maxTrain={maxTrain} minTest={minTest}");
+        Debug.Assert(minTest - maxTrain >= 10,
+            $"Embargo gap must be >= 10 days, got {minTest - maxTrain}");
+        // A train row's forward window (t, t+10] must end before the test period.
+        Debug.Assert(maxTrain + 10 < minTest + 10 && maxTrain + 10 <= minTest,
+            "No train label window may reach the test period");
+
+        double testShare = test.Count / (double)data.Count;
+        Debug.Assert(testShare > 0.15 && testShare < 0.25,
+            $"Test share should approximate 0.20 (minus rounding), got {testShare:F3}");
+
+        Console.WriteLine($"TemporalSplit Test 1 passed: boundary honest (gap={minTest - maxTrain}d), " +
+                          $"test share {testShare:P1}");
+    }
+
+    // Test 2: purged rows are exactly the embargo band — nothing lost elsewhere.
+    public void Test_TrainTest_PurgeAccounting()
+    {
+        var data = MakePanel();
+        var (train, test) = TemporalSplit.TrainTest(data, testFraction: 0.20, embargoDays: 10);
+
+        int purged = data.Count - train.Count - test.Count;
+        // 10 embargoed days × 10 rows/day = 100 rows expected (±1 day of rounding).
+        Debug.Assert(purged >= 90 && purged <= 110,
+            $"Expected ~100 purged rows (10d × 10 rows), got {purged}");
+        Console.WriteLine($"TemporalSplit Test 2 passed: purge accounting exact ({purged} rows)");
+    }
+
+    // Test 3: purged k-fold — every fold's train set stays >= embargo away
+    // from its validation block on both sides, and folds partition the panel.
+    public void Test_PurgedFolds_EmbargoBothSides()
+    {
+        var data = MakePanel();
+        int k = 5, embargo = 10;
+        int foldIdx = 0, totalVal = 0;
+
+        foreach (var (train, val) in TemporalSplit.PurgedFolds(data, k, embargo))
+        {
+            int valLo = int.MaxValue, valHi = int.MinValue;
+            foreach (var r in val)
+            {
+                valLo = Math.Min(valLo, r.Timestep);
+                valHi = Math.Max(valHi, r.Timestep);
+            }
+            foreach (var r in train)
+            {
+                bool inside  = r.Timestep >= valLo && r.Timestep <= valHi;
+                bool tooNear = (r.Timestep < valLo && r.Timestep > valLo - embargo)
+                            || (r.Timestep > valHi && r.Timestep < valHi + embargo);
+                Debug.Assert(!inside,  $"Fold {foldIdx}: train row inside val block (t={r.Timestep})");
+                Debug.Assert(!tooNear, $"Fold {foldIdx}: train row within embargo of val block (t={r.Timestep})");
+            }
+            Debug.Assert(val.Count > 0 && train.Count > 0,
+                $"Fold {foldIdx}: degenerate fold (train={train.Count}, val={val.Count})");
+            totalVal += val.Count;
+            foldIdx++;
+        }
+
+        Debug.Assert(foldIdx == k, $"Expected {k} folds, got {foldIdx}");
+        Debug.Assert(totalVal == MakePanel().Count,
+            $"Validation blocks must partition all rows, covered {totalVal}");
+        Console.WriteLine("TemporalSplit Test 3 passed: purged folds embargoed on both sides, val partitions panel");
+    }
+
+    // Test 4: determinism — no RNG anywhere, two calls agree exactly.
+    public void Test_Deterministic()
+    {
+        var data = MakePanel();
+        var (t1, s1) = TemporalSplit.TrainTest(data, 0.20, 10);
+        var (t2, s2) = TemporalSplit.TrainTest(data, 0.20, 10);
+        Debug.Assert(t1.Count == t2.Count && s1.Count == s2.Count,
+            "TemporalSplit must be deterministic");
+        Console.WriteLine("TemporalSplit Test 4 passed: deterministic");
+    }
+
+    // Test 5: DataSplit facade dispatches on SplitPolicy and restores cleanly.
+    public void Test_DataSplit_PolicyDispatch()
+    {
+        var data = MakePanel();
+        var prevMode = SplitPolicy.Mode;
+        try
+        {
+            SplitPolicy.Mode = SplitMode.StratifiedRandom;
+            var (rTrain, rTest) = DataSplit.TrainTest(data, r => r.Y_Oracle, 0.20, 42);
+            // Random mode interleaves time: test min Timestep should reach near the panel start.
+            int rMinTest = rTest.Min(r => r.Timestep);
+            Debug.Assert(rMinTest < 250, "Stratified-random test set should span early timesteps");
+
+            SplitPolicy.Mode = SplitMode.TemporalPurged;
+            SplitPolicy.EmbargoDays = 10;
+            var (tTrain, tTest) = DataSplit.TrainTest(data, r => r.Y_Oracle, 0.20, 42);
+            int tMaxTrain = tTrain.Max(r => r.Timestep);
+            int tMinTest  = tTest.Min(r => r.Timestep);
+            Debug.Assert(tMaxTrain < tMinTest, "Temporal mode must be chronological through the facade");
+
+            Console.WriteLine("TemporalSplit Test 5 passed: DataSplit facade dispatches on SplitPolicy");
+        }
+        finally
+        {
+            SplitPolicy.Mode = prevMode;
+            SplitPolicy.EmbargoDays = 30;
+            SplitPolicy.TestFractionOverride = null;
+        }
+    }
+}