{
  "$defs": {
    "BackwardScheduler": {
      "description": "Backward-pass scheduler and its scheduler-specific parameters\n(`config.json → training.parallelism.backward_scheduler`).\n\nThe `method` key selects the scheduler, and each scheduler accepts only its\nown parameters: a parameter of another scheduler is a load-time error.",
      "oneOf": [
        {
          "additionalProperties": false,
          "description": "By-scenario backward scheduling (the default): each parallel work\nunit claims one whole trial point (a row of the backward work\nrectangle).",
          "properties": {
            "method": {
              "const": "by_scenario",
              "type": "string"
            }
          },
          "required": [
            "method"
          ],
          "type": "object"
        },
        {
          "additionalProperties": false,
          "description": "By-node backward scheduling: each parallel work unit claims one\n(trial point, opening-block) tile of the backward work rectangle.",
          "properties": {
            "block_size": {
              "default": null,
              "description": "Openings per block. Absent resolves per stage to `⌈|Ω_s|/2⌉` (half\nthe openings, rounded up); a set value is clamped to\n`min(|Ω_s|, block_size)`.",
              "format": "uint",
              "minimum": 1,
              "type": [
                "integer",
                "null"
              ]
            },
            "method": {
              "const": "by_node",
              "type": "string"
            }
          },
          "required": [
            "method"
          ],
          "type": "object"
        }
      ]
    },
    "BoundaryPolicy": {
      "additionalProperties": false,
      "description": "Boundary-row configuration for terminal-stage FCF coupling.\n\nWhen present, the solver loads rows from a source Novomodelo policy\ncheckpoint and injects them as fixed boundary conditions at the\nterminal stage of the current study. The loader selects the source pool\nwhose priced state date equals this study's last stage `end_date`.",
      "properties": {
        "path": {
          "description": "Path to the source policy checkpoint directory (a different study's\noutput). Resolved relative to the case (input) directory, like every\nother input; an absolute path is used as-is. NOT relative to this run's\noutput directory.",
          "type": "string"
        },
        "strict": {
          "default": false,
          "description": "A source slot pricing an entity or commitment this study does not\nmodel is dropped during reconciliation either way. Left `false`, the\ndrop is recorded in the reconciliation report and the load proceeds;\nset `true`, the load is rejected, naming every dropping family and\nits count.",
          "type": "boolean"
        }
      },
      "required": [
        "path"
      ],
      "type": "object"
    },
    "CheckpointingConfig": {
      "additionalProperties": false,
      "description": "Periodic checkpoint settings (`config.json → policy.checkpointing`). Each periodic checkpoint replaces the previous one in the policy directory, so only the latest is kept.",
      "properties": {
        "compress": {
          "default": null,
          "description": "Reserved and not read: checkpoint files are written uncompressed whatever its value.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "enabled": {
          "default": null,
          "description": "Write periodic checkpoints during training. Off when absent. When true, `interval_iterations` must be at least 1.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "initial_iteration": {
          "default": null,
          "description": "Iteration that writes the first periodic checkpoint. Defaults to `interval_iterations`. Iteration numbers are absolute: a resumed run continues the numbering of the run it resumes.",
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "interval_iterations": {
          "default": null,
          "description": "Iterations between periodic checkpoints, counted from `initial_iteration`. Required, and at least 1, when `enabled` is true.",
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "store_basis": {
          "default": null,
          "description": "Reserved and not read: a checkpoint holds the LP bases of the run's scenarios whatever its value.",
          "type": [
            "boolean",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "CorrelationTarget": {
      "description": "Series the estimated spatial inflow correlation is computed from.",
      "oneOf": [
        {
          "const": "residuals",
          "description": "Residuals of the fitted PAR lags.",
          "type": "string"
        },
        {
          "const": "inflows",
          "description": "Standardized historical inflows.",
          "type": "string"
        }
      ]
    },
    "DualEdgeWeight": {
      "description": "Dual simplex edge-weight (pricing) strategy.",
      "oneOf": [
        {
          "const": "devex",
          "description": "Devex approximate edge weights.",
          "type": "string"
        },
        {
          "const": "steepest_edge",
          "description": "Exact steepest-edge weights.",
          "type": "string"
        },
        {
          "const": "dantzig",
          "description": "Dantzig most-negative-reduced-cost rule.",
          "type": "string"
        }
      ]
    },
    "EstimationConfig": {
      "additionalProperties": false,
      "description": "Time series estimation settings (`config.json → estimation`).\n\nControls automatic parameter estimation when historical inflow data is\nprovided without explicit model statistics or coefficients.",
      "properties": {
        "correlation_target": {
          "$ref": "#/$defs/CorrelationTarget",
          "default": "inflows",
          "description": "Series the spatial inflow correlation is estimated from when no\n`scenarios/correlation.json` is supplied: `\"inflows\"` (default) or `\"residuals\"`.\n\nEvaluation option, expected to be removed once evaluated."
        },
        "history_years": {
          "anyOf": [
            {
              "$ref": "#/$defs/HistoricalYearRange"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Years of `scenarios/inflow_history.parquet` the inflow model is estimated\nfrom, as an inclusive `{\"from\", \"to\"}` range of the years season\noccurrences start in. Absent: every year. A range reaching outside the\nfile's years is refused. The historical scenario scheme and the initial\nconditions still read the whole file."
        },
        "max_coefficient_magnitude": {
          "default": null,
          "description": "Maximum allowed absolute magnitude for any AR coefficient.\n\nWhen set, any (entity, season) pair with `|coefficient| > threshold`\nis immediately reduced to order 0 before the contribution analysis\nruns. This acts as a fast-path safety net for the most extreme\nexplosive models. Absent by default (disabled; contribution analysis\nis the primary guard).",
          "format": "double",
          "type": [
            "number",
            "null"
          ]
        },
        "max_order": {
          "default": 6,
          "description": "Maximum lag order considered during autoregressive model fitting.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "min_observations_per_season": {
          "default": 30,
          "description": "Minimum number of observations required per (entity, season) group\nto proceed with estimation. Groups below this threshold are skipped.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "order_selection": {
          "$ref": "#/$defs/OrderSelectionMethod",
          "default": "pacf",
          "description": "Order selection criterion. Accepts `\"pacf\"` (classical PACF, default)\nor `\"pacf_annual\"` (PACF augmented with an annual component, PAR(p)-A)."
        }
      },
      "type": "object"
    },
    "ExportsConfig": {
      "additionalProperties": false,
      "description": "Export flags controlling which outputs are written to disk\n(`config.json → exports`).\n\nOnly the active fields below are accepted. Legacy keys (`training`, `cuts`,\n`vertices`, `simulation`, `forward_detail`, `backward_detail`,\n`compression`) must be removed from existing `config.json` files before\nloading — they are now rejected as unknown fields.",
      "properties": {
        "fpha_deviation_points": {
          "default": false,
          "description": "Export the per-sampled-point computed-FPHA fit-deviation table to\n`output/hydro_models/fpha_deviation_points.parquet`.\n\nOpt-in (default `false`) purely for size: it emits one row per\n`(hydro, stage, V, Q)` grid point at spillage = 0. Off ⇒ no file and a\nbyte-identical run; the table is additive and never enters the parity\nhash. The values are deterministic (a pure function of geometry + config),\nso the file is reproducible when emitted.",
          "type": "boolean"
        },
        "states": {
          "default": false,
          "description": "Store the trial state of each row the run adds, under every selection\nmethod, and write the stored states to the policy checkpoint. Each row\npool that receives rows stores the states of its own rows, at its own\nstate dimension: the first stage's pool, which keeps every state, and\nthe pool of each stage strictly between the first and the last, which\nunder `level1` with `lookback_iterations` keeps only the states inside\nthe window. A `level1` run stores and writes the states of the pools it\nselects whether or not this is set, since a resume reads them. Storing\nthe states changes no result of the run; the policy then marks its\nrows `scored`, which a later `level1` run that loads it selects like\nits own rows.",
          "type": "boolean"
        },
        "stochastic": {
          "default": false,
          "description": "Export stochastic preprocessing artifacts to `output/stochastic/`.",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "HistoricalYearRange": {
      "additionalProperties": false,
      "description": "Inclusive `{\"from\", \"to\"}` year range.",
      "properties": {
        "from": {
          "description": "First year (inclusive).",
          "format": "int32",
          "type": "integer"
        },
        "to": {
          "description": "Last year (inclusive).",
          "format": "int32",
          "type": "integer"
        }
      },
      "required": [
        "from",
        "to"
      ],
      "type": "object"
    },
    "InflowNonNegativityConfig": {
      "additionalProperties": false,
      "description": "Inflow non-negativity treatment settings.",
      "properties": {
        "method": {
          "$ref": "#/$defs/InflowNonNegativityMethod",
          "default": "truncation_with_penalty",
          "description": "Method: `\"none\"`, `\"truncation\"`, `\"penalty\"`, or `\"truncation_with_penalty\"`.\n\nDefault: `\"truncation_with_penalty\"`. Under `\"penalty\"` and\n`\"truncation_with_penalty\"` the correction's cost is\n`penalties.json → hydro.inflow_nonnegativity_cost` (default 1000.0 when absent);\nunder `\"truncation\"` it has no cost."
        }
      },
      "type": "object"
    },
    "InflowNonNegativityMethod": {
      "description": "Method string for inflow non-negativity enforcement.\n\nAccepted values in `config.json → modeling.inflow_non_negativity.method`:\n\n- `\"none\"` — no enforcement; the PAR(p) inflow may be negative.\n- `\"truncation\"` — the PAR(p) value stays raw: it is the incremental inflow, and the\n  inflow lags of later stages are built from it (aggregated over the lag's period when\n  the period spans several stages). A per-hydro correction fixed at `max(−r, 0)`, at no\n  cost, lifts the local inflow to zero.\n- `\"penalty\"` — an unbounded correction priced by\n  `penalties.json → hydro.inflow_nonnegativity_cost`.\n- `\"truncation_with_penalty\"` — the PAR(p) value stays raw; a correction between 0 and\n  `max(−r, 0)`, priced by `penalties.json → hydro.inflow_nonnegativity_cost`.\n\nUnder the two truncation methods the correction depends on the incoming state, so the\nlower bound can exceed the upper bound, and a `gap` stopping rule can then report\nconvergence that has not occurred (Larroyd et al. (2022), the paper's §2.5).",
      "oneOf": [
        {
          "const": "none",
          "description": "No enforcement; the inflow may be negative.",
          "type": "string"
        },
        {
          "const": "truncation",
          "description": "Raw PAR(p) value; correction fixed at the truncation amount, at no cost.",
          "type": "string"
        },
        {
          "const": "penalty",
          "description": "Unbounded correction priced by `penalties.json → hydro.inflow_nonnegativity_cost`.",
          "type": "string"
        },
        {
          "const": "truncation_with_penalty",
          "description": "Raw PAR(p) value; priced correction capped at the truncation amount.",
          "type": "string"
        }
      ]
    },
    "LipschitzConfig": {
      "additionalProperties": false,
      "description": "Lipschitz constant settings for inner approximation.",
      "properties": {
        "fallback_value": {
          "default": null,
          "description": "Fallback value when automatic computation fails.",
          "format": "double",
          "type": [
            "number",
            "null"
          ]
        },
        "mode": {
          "default": null,
          "description": "Computation mode: `\"auto\"`.",
          "type": [
            "string",
            "null"
          ]
        },
        "scale_factor": {
          "default": null,
          "description": "Multiplicative safety margin applied to computed Lipschitz constants.",
          "format": "double",
          "type": [
            "number",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "ModelingConfig": {
      "additionalProperties": false,
      "description": "Modeling options (`config.json → modeling`).",
      "properties": {
        "cost_scale_factor": {
          "default": null,
          "description": "Divisor applied to every non-theta objective coefficient at template\nbuild time, multiplied back at every cost-domain reporting boundary.\nDefault `1_000_000.0` — the value every golden parity baseline is pinned at.\n\nObjective conditioning only — results are identical in exact arithmetic;\nthis does not alter the model, unlike `modeling`'s other fields. The\neffective dual tolerance in currency units is\n`dual_feasibility_tolerance × this factor`: raising the factor without\nlowering `dual_feasibility_tolerance` proportionally loosens optimality\nin currency terms even though the configured tolerance value is\nunchanged — the inverse-direction trap a name cannot carry.\n\nAbsent uses the default. Must be finite and `> 0`; a value outside\n`[1.0, 1e12]` is accepted but logs an advisory warning.",
          "format": "double",
          "type": [
            "number",
            "null"
          ]
        },
        "inflow_non_negativity": {
          "$ref": "#/$defs/InflowNonNegativityConfig",
          "default": {
            "method": "truncation_with_penalty"
          },
          "description": "Strategy for handling non-negative inflow constraints."
        }
      },
      "type": "object"
    },
    "MomentMatching": {
      "description": "How generated openings are corrected after the correlation is applied.",
      "oneOf": [
        {
          "const": "none",
          "description": "Keep the openings as drawn.",
          "type": "string"
        },
        {
          "const": "per_coordinate",
          "description": "Shift and scale each hydro's openings to mean 0 and the variance of its correlated noise.",
          "type": "string"
        }
      ]
    },
    "Openings": {
      "description": "Where a stage's openings originate (`config.json` scenario-source `source`).\n\nThe tag key is `source` and the field is `openings`, deliberately distinct\nfrom the per-class `scheme` key: `openings.source` selects where a stage's\nopenings come from, while `scheme` selects how a class's noise is modelled.\nA single word would otherwise carry both axes. An absent `openings`\ndeclaration is equivalent to `generated`.",
      "oneOf": [
        {
          "additionalProperties": false,
          "description": "Openings come from noise generation (the default when `openings` is absent).",
          "properties": {
            "moment_matching": {
              "$ref": "#/$defs/MomentMatching",
              "default": "per_coordinate",
              "description": "`per_coordinate` (default) shifts and scales each generated stage's\ninflow openings so that every hydro's opening mean is 0 and its\nvariance is that of its correlated noise: 1, or more where factoring\nthe correlation clips a negative eigenvalue; `none` keeps the\nopenings as drawn. Stages using `historical_residuals`, stages with\none opening and hydros whose openings are all equal are left as\ndrawn; load and non-controllable-source noise is never matched.\n\nEvaluation option, expected to be removed once evaluated."
            },
            "source": {
              "const": "generated",
              "type": "string"
            }
          },
          "required": [
            "source"
          ],
          "type": "object"
        },
        {
          "additionalProperties": false,
          "description": "Openings come from the conventional `scenarios/noise_openings.parquet` file.",
          "properties": {
            "source": {
              "const": "file",
              "type": "string"
            }
          },
          "required": [
            "source"
          ],
          "type": "object"
        }
      ]
    },
    "OrderSelectionMethod": {
      "description": "Order selection criterion for autoregressive model fitting.\n\nControls how the lag order is chosen when fitting a time series model.\nTwo variants are accepted:\n\n- `\"pacf\"` — classical periodic Yule-Walker with PACF-based order\n  selection. Default.\n- `\"pacf_annual\"` — extends `\"pacf\"` with an annual component (PAR(p)-A),\n  adding one extra coefficient ψ per (entity, season) that multiplies\n  the rolling 12-month average of past observations.",
      "oneOf": [
        {
          "const": "pacf",
          "description": "Periodic Yule-Walker partial autocorrelation method (PACF).",
          "type": "string"
        },
        {
          "const": "pacf_annual",
          "description": "Periodic Yule-Walker order selection augmented with an annual component.\n\nWhen selected, the estimation pipeline performs four steps beyond the\nclassical `pacf` path:\n\n1. **Extended Yule-Walker fitting** — the system is augmented with a\n   cross-correlation term between the current-season inflow and the\n   rolling 12-month average, yielding the annual coefficient ψ\n   alongside the classical AR coefficients.\n2. **Annual-stats computation** — per-season sample mean μ^A and\n   population standard deviation σ^A of the rolling 12-month\n   average are computed for each hydro plant.\n3. **Parquet emission** — the triple (ψ, μ^A, σ^A) is written to\n   `inflow_annual_component.parquet` in the output directory.\n4. **Widened LP lag stride** — the noise-column layout in the LP is\n   extended to accommodate the annual term alongside the classical lags.",
          "type": "string"
        }
      ]
    },
    "ParallelismConfig": {
      "additionalProperties": false,
      "description": "Parallel-execution settings (`config.json → training.parallelism`).\n\nGroups the result-preserving knobs that shape how training work is\nscheduled across workers, apart from the algorithm-semantics fields at the\n`training` root. Thread count itself stays a CLI concern (`--threads`).",
      "properties": {
        "backward_scheduler": {
          "$ref": "#/$defs/BackwardScheduler",
          "default": {
            "method": "by_scenario"
          },
          "description": "Backward-pass scheduler selection."
        }
      },
      "type": "object"
    },
    "PhaseSolverProfileConfig": {
      "additionalProperties": false,
      "description": "Per-phase LP solver profile (`config.json → training.solver.backward` /\n`.forward`, and `simulation.solver`).\n\nBackend-agnostic. Every field is optional: an absent field leaves the\ncorresponding option at the phase's built-in tuned-profile value.",
      "properties": {
        "cost_perturbation": {
          "default": null,
          "description": "Dual simplex cost-perturbation multiplier override.",
          "format": "double",
          "type": [
            "number",
            "null"
          ]
        },
        "dual_edge_weight": {
          "anyOf": [
            {
              "$ref": "#/$defs/DualEdgeWeight"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Dual simplex edge-weight strategy override."
        },
        "dual_feasibility_tolerance": {
          "default": null,
          "description": "Dual feasibility tolerance override.",
          "format": "double",
          "type": [
            "number",
            "null"
          ]
        },
        "factor_pivot_threshold": {
          "default": null,
          "description": "Matrix factorization pivot-threshold override.",
          "format": "double",
          "type": [
            "number",
            "null"
          ]
        },
        "presolve": {
          "anyOf": [
            {
              "$ref": "#/$defs/PresolveMode"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Presolve mode override. Warm-started solves skip presolve regardless\nof this setting, so it affects only genuinely cold solves."
        },
        "price": {
          "anyOf": [
            {
              "$ref": "#/$defs/PriceStrategy"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Simplex pricing strategy override."
        },
        "primal_feasibility_tolerance": {
          "default": null,
          "description": "Primal feasibility tolerance override.",
          "format": "double",
          "type": [
            "number",
            "null"
          ]
        },
        "scale": {
          "anyOf": [
            {
              "$ref": "#/$defs/ScaleStrategy"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Constraint-matrix scaling strategy override."
        },
        "simplex_update_limit": {
          "default": null,
          "description": "Simplex update-count limit override before a refactorization.",
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "steepest_edge_devex_fallback_threshold": {
          "default": null,
          "description": "Dual steepest-edge weight log-error threshold override above which the\nsolver falls back to Devex pricing.",
          "format": "double",
          "type": [
            "number",
            "null"
          ]
        },
        "use_warm_start": {
          "default": null,
          "description": "Warm-start override. By default forward and backward solves warm-start\nfrom the stored basis and simulation solves are cold.",
          "type": [
            "boolean",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "PolicyConfig": {
      "additionalProperties": false,
      "description": "Policy directory settings (`config.json → policy`).",
      "properties": {
        "boundary": {
          "anyOf": [
            {
              "$ref": "#/$defs/BoundaryPolicy"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Optional boundary-row policy for terminal-stage coupling."
        },
        "checkpointing": {
          "$ref": "#/$defs/CheckpointingConfig",
          "default": {
            "compress": null,
            "enabled": null,
            "initial_iteration": null,
            "interval_iterations": null,
            "store_basis": null
          },
          "description": "Checkpoint settings."
        },
        "mode": {
          "$ref": "#/$defs/PolicyMode",
          "default": "fresh",
          "description": "Initialization mode: `\"fresh\"`, `\"warm_start\"`, or `\"resume\"`.\n\nA `resume` is refused at load when the checkpoint cannot continue the run as the run that wrote it would have: it was written with another number of forward passes; the run uses `level1` on a study with a stage strictly between the first and the last, and the checkpoint holds no trial-state history, or holds a window while the run keeps every trial state, or holds a shorter window than the run's `lookback_iterations`; the run sets `max_active_per_stage` or the `dynamic` method and the checkpoint holds no binding records; or the run that wrote it ended in an error, which makes it a partial policy. A `warm_start` is not refused for any of these."
        },
        "path": {
          "default": "./policy",
          "description": "Policy directory, resolved against the output directory unless absolute. A checkpoint write replaces the whole directory, so an empty path, `.`, `..`, the output directory and its ancestors are refused. So is a directory that names or contains one a run clears before writing its outputs, such as `simulation/solver` or `training/solver`, or that lies inside one a run removes whole, such as `simulation/costs`.\n\nThis directory only holds whole checkpoints. A run whose training ends in an error writes its policy to the sibling directory `<path>.partial`, replacing one already there, and leaves this directory as the last whole checkpoint left it; a later run leaves that sibling in place. A run reads the sibling only when `policy.path` names it, and a `resume` of it is refused.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "PolicyMode": {
      "description": "Policy initialization mode (`config.json → policy.mode`).\n\nControls whether the training phase starts from scratch, warm-starts from\na prior policy's rows, or resumes a checkpointed training run.",
      "oneOf": [
        {
          "const": "fresh",
          "description": "Start training from an empty future-cost function.",
          "type": "string"
        },
        {
          "const": "warm_start",
          "description": "Load rows from a prior policy checkpoint and continue training.",
          "type": "string"
        },
        {
          "const": "resume",
          "description": "Resume a previously interrupted training run from its checkpoint and\ncontinue it as that run would have continued: the iteration numbering,\neach row's role, binding record and stored trial state, and each\nscenario's own LP basis are restored.",
          "type": "string"
        }
      ]
    },
    "PresolveMode": {
      "description": "Presolve mode for a solver profile.",
      "oneOf": [
        {
          "const": "on",
          "description": "Presolve enabled.",
          "type": "string"
        },
        {
          "const": "off",
          "description": "Presolve disabled.",
          "type": "string"
        },
        {
          "const": "choose",
          "description": "Solver decides whether to presolve.",
          "type": "string"
        }
      ]
    },
    "PriceStrategy": {
      "description": "Simplex pricing (column-selection) strategy.",
      "oneOf": [
        {
          "const": "row",
          "description": "Row-wise pricing.",
          "type": "string"
        },
        {
          "const": "row_hyper_sparse",
          "description": "Row-wise pricing with hyper-sparse updates.",
          "type": "string"
        }
      ]
    },
    "RawClassConfigEntry": {
      "additionalProperties": false,
      "description": "A single per-class scenario scheme in `config.json`.",
      "properties": {
        "scheme": {
          "$ref": "#/$defs/RawSamplingScheme",
          "description": "Forward-pass scenario scheme for this class."
        }
      },
      "required": [
        "scheme"
      ],
      "type": "object"
    },
    "RawHistoricalYearsConfig": {
      "anyOf": [
        {
          "description": "Explicit list of year integers.",
          "items": {
            "format": "int32",
            "type": "integer"
          },
          "type": "array"
        },
        {
          "$ref": "#/$defs/HistoricalYearRange",
          "description": "Inclusive range shorthand."
        }
      ],
      "description": "`historical_years` in `config.json`: an array of years, such as\n`[1940, 1953, 1971]`, or an inclusive range, such as\n`{\"from\": 1940, \"to\": 2010}`."
    },
    "RawSamplingScheme": {
      "description": "Per-class forward-pass scenario scheme (`config.json` scenario-source `scheme`).",
      "oneOf": [
        {
          "const": "in_sample",
          "description": "Reuse the backward-pass opening tree for the forward pass.",
          "type": "string"
        },
        {
          "const": "out_of_sample",
          "description": "Draw fresh noise from the same distribution with an independent seed.",
          "type": "string"
        },
        {
          "const": "external",
          "description": "Draw from an externally supplied scenario file.",
          "type": "string"
        },
        {
          "const": "historical",
          "description": "Replay historical realisations.",
          "type": "string"
        }
      ]
    },
    "RawScenarioSourceConfig": {
      "additionalProperties": false,
      "description": "Per-class scenario source configuration in `config.json`.\n\nUsed by `training.scenario_source` and `simulation.scenario_source`.",
      "properties": {
        "historical_years": {
          "anyOf": [
            {
              "$ref": "#/$defs/RawHistoricalYearsConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Historical year pool. Absent: the years are discovered at validation time."
        },
        "inflow": {
          "anyOf": [
            {
              "$ref": "#/$defs/RawClassConfigEntry"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Inflow class scenario config. Absent defaults to `in_sample`."
        },
        "load": {
          "anyOf": [
            {
              "$ref": "#/$defs/RawClassConfigEntry"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Load class scenario config. Absent defaults to `in_sample`."
        },
        "ncs": {
          "anyOf": [
            {
              "$ref": "#/$defs/RawClassConfigEntry"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "NCS class scenario config. Absent defaults to `in_sample`."
        },
        "openings": {
          "anyOf": [
            {
              "$ref": "#/$defs/Openings"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Where a stage's openings come from. Absent defaults to `generated`,\npreserving generation-sourced openings."
        },
        "seed": {
          "default": null,
          "description": "Required when any class uses the `out_of_sample` or `external` scheme.",
          "format": "int64",
          "type": [
            "integer",
            "null"
          ]
        }
      },
      "type": "object"
    },
    "RowSelectionConfig": {
      "additionalProperties": false,
      "description": "Row-selection settings (`config.json → training.cut_selection`).\n\n`selection` chooses the method and carries only that method's parameters;\nomitting it (the default) disables row selection.",
      "properties": {
        "max_active_per_stage": {
          "default": null,
          "description": "Cap on the active rows that the current run has added to a stage's row\npool. Absent (default): no cap.\n\nThe cap applies to the row pool of every stage strictly between the\nfirst and the last; the pools of the first stage and of the last stage\nare not capped. Where the policy graph has several nodes at such a\nstage, each node has its own pool and the cap applies to each pool\nseparately. Rows loaded from a policy (`policy.mode` set to\n`warm_start`, or `policy.boundary`) are never evicted and do not count\ntoward the cap, so a pool can hold more active rows than the cap. Under\n`resume` each reloaded row keeps the role it had in the run that wrote\nthe checkpoint: the rows that run added count toward the cap and can be\nevicted, and the rows it loaded do not.\n\nThe cap is applied in every training iteration, after that iteration's\nrows have been added, whether or not a selection method is configured;\nin an iteration where the selection method runs its periodic pass, the\ncap is applied after that pass. Rows added in the current iteration\ncount toward the cap and are never evicted, so the count stays above\nthe cap when those rows alone exceed it.\n\nWhen the count exceeds the cap, the excess is evicted from the rows\nadded in earlier iterations, in ascending order of the iteration in\nwhich a row was last binding; ties go to the row that was binding in\nfewer solves, then to the row at the lower position in the pool. A row\nthat has never been binding ranks by the iteration that added it.\n`row_activity_tolerance` decides whether a row is binding.\n\nThe cap is rejected at load when set together with\n`training.cut_selection.selection.method` = `dynamic` or with\n`training.selection.method` set to `enumerated`.\n\nEviction deactivates a row and keeps it in the pool. With no selection\nmethod an evicted row does not become active again during training.\nWith `level1`, a later selection pass may reactivate it, and the cap is\nthen applied again in the same iteration.",
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "row_activity_tolerance": {
          "default": 1e-6,
          "description": "Binding threshold for activity tracking: a constraint row counts as\nbinding at a solution point when its dual multiplier is strictly greater\nthan this value (a signed comparison; a multiplier equal to the\nthreshold does not bind). In one solve the multipliers of a stage's pool\nrows are non-negative weights whose sum is at most that stage's discount\nfactor, so the threshold is dimensionless. The recorded activity is read\nonly by `max_active_per_stage` and by the `seed_window` of the `dynamic`\nmethod, and it is recorded, and written to the policy checkpoint, only\nwhen one of them is configured. Must be `>= 0`. A value of `0` counts a\nmultiplier at solver rounding level as binding.",
          "format": "double",
          "type": "number"
        },
        "selection": {
          "anyOf": [
            {
              "$ref": "#/$defs/SelectionMethod"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Active selection method and its parameters. Absent/`null` (default)\ndisables row selection."
        }
      },
      "type": "object"
    },
    "ScaleStrategy": {
      "description": "LP constraint-matrix scaling strategy.",
      "oneOf": [
        {
          "const": "off",
          "description": "No scaling.",
          "type": "string"
        },
        {
          "const": "solver_scaling",
          "description": "Solver-managed scaling.",
          "type": "string"
        }
      ]
    },
    "SelectionMethod": {
      "description": "Row-selection method and its method-specific parameters.\n\nThe `method` key selects the method, and each method accepts only its own\nparameters: a parameter of another method, a misspelled `method` and a\nremoved `method` are load-time errors.",
      "oneOf": [
        {
          "additionalProperties": false,
          "description": "Level 1: every row the run adds to the row pool of a stage strictly\nbetween the first and the last is scored: the pool stores the trial\nstate the row was computed at, for the whole run or, with\n`lookback_iterations`, for the iterations that key sets. A row loaded\nfrom a policy is scored when the policy records it so (`scored`), which\nit does for the rows its writing run added to a pool that stored trial\nstates, under `level1` or with `exports.states`; the state the policy\nholds for such a row, if any, is stored with it. At each stored state,\nthe row with the highest value there owns the state, among the scored\nrows of that pool, active or not, and its other loaded rows that are\nactive; of rows whose values there are exactly equal, the one at the\nlowest pool position owns it. Every `check_frequency` iterations, a\nscored row of such a pool is deactivated when it owns no stored state\nand reactivated when it is inactive and owns one, also once its own\nstate has been dropped. Values are compared exactly, with no tolerance,\nand a row of the current iteration is judged like any other. A loaded\nrow that is not scored keeps the activity it was loaded with. Under\n`resume` a reloaded row is selected as it would have been in the run\nthat wrote the checkpoint.",
          "properties": {
            "check_frequency": {
              "default": 5,
              "description": "Iterations between periodic pruning checks. Default `5`.",
              "format": "uint32",
              "minimum": 1,
              "type": "integer"
            },
            "lookback_iterations": {
              "default": null,
              "description": "Iterations of the current run whose rows keep their trial states.\nAbsent (default): the trial state of every row the run added is\nkept, and the memory of a run grows with its row count. A value `w`\nkeeps the trial states of the rows added in the last `w` iterations\nof the current run and drops the older states, never a row: a row\nwhose state was dropped stays in the pool and still competes at the\nstates that remain. A state loaded with a row under `warm_start`\ncounts as one from before the run's first iteration, so it leaves\nthe window at the run's iteration `w`; under `resume` a reloaded\nstate leaves it when it would have in the run that wrote the\ncheckpoint. The memory holding the trial states of a pool is then\nbounded by `(lookback_iterations + check_frequency)` times the most\nrows the run can add to that pool in one iteration, times the state\ndimension, times 8 bytes, plus the states loaded with its rows. Must\nbe at least `check_frequency`.",
              "format": "uint32",
              "minimum": 1,
              "type": [
                "integer",
                "null"
              ]
            },
            "method": {
              "const": "level1",
              "type": "string"
            }
          },
          "required": [
            "method"
          ],
          "type": "object"
        },
        {
          "additionalProperties": false,
          "description": "Dynamic: a per-solve lazy loop, this software's own lazy row generation.\nFrom `start_iteration` on, each training solve starts with the seed rows\ndescribed under `seed_window`, adds the candidate rows that its solution\nviolates, at most `max_added_per_round` per round, and solves again; it\nreturns when no candidate is violated. After a fixed number of rounds\nthe per-round limit is lifted. A simulation solve starts with every\nactive row, so `seed_window` and `candidate_recency` apply to training\nonly. The method never deactivates a row, and the pool keeps every row.",
          "properties": {
            "candidate_recency": {
              "default": null,
              "description": "Absent (default): every active row is a candidate and a solve returns\nthe optimum over them. A value `n` restricts the candidates to the\nrows added in the last `n` iterations and loaded rows, and the result\nis then the optimum over those rows together with the seed rows.\nUnder `resume` a reloaded row is a loaded row only when the run that\nwrote the checkpoint loaded it.",
              "format": "uint32",
              "minimum": 1,
              "type": [
                "integer",
                "null"
              ]
            },
            "max_added_per_round": {
              "default": 10,
              "description": "Maximum rows added per lazy-solve round. Default `10`.",
              "format": "uint32",
              "minimum": 1,
              "type": "integer"
            },
            "method": {
              "const": "dynamic",
              "type": "string"
            },
            "seed_window": {
              "default": 5,
              "description": "A solve starts with the active rows whose last binding was at most\n`seed_window` iterations ago (a row that has not bound counts from\nthe iteration that added it), plus the rows added in the current\niteration. `row_activity_tolerance` decides whether a row binds. `0`\nseeds the rows of the current iteration and those that bound in it.\nA row loaded from a policy counts from the start of the run under\n`warm_start` and for `policy.boundary` rows. Under `resume` a\nreloaded row counts as it did in the run that wrote the checkpoint,\nwhich stores each row's binding record. Default `5`.",
              "format": "uint32",
              "minimum": 0,
              "type": "integer"
            },
            "start_iteration": {
              "default": 2,
              "description": "First 1-based iteration at which the lazy loop becomes active. Default `2`.",
              "format": "uint32",
              "minimum": 1,
              "type": "integer"
            },
            "violation_tolerance": {
              "default": null,
              "description": "A relative factor: a candidate row is added when its value exceeds\nthe future-cost value by more than the factor times the larger of\nthe two magnitudes. Absent (default): each phase uses the primal\nfeasibility tolerance of its solver profile. A value must be finite\nand greater than `0`. It must also be less than 1 and at least the\nprimal feasibility tolerance of every phase's solver profile.",
              "format": "double",
              "type": [
                "number",
                "null"
              ]
            }
          },
          "required": [
            "method"
          ],
          "type": "object"
        }
      ]
    },
    "SimulationConfig": {
      "additionalProperties": false,
      "description": "Post-training simulation settings (`config.json → simulation`).",
      "properties": {
        "cut_set": {
          "$ref": "#/$defs/SimulationRowSet",
          "default": "all",
          "description": "Which rows of each stage's row pool the simulation loads into the stage\nLP. `all` loads every row a training run added to the pool, including\nrows the selection method deactivated and rows `max_active_per_stage`\nevicted, so a simulation LP can be larger than the training LPs.\n`active` loads only the rows active when training ended.\n\nA run with training disabled loads each row of the policy with the role\nit had in the run that wrote it, so `all` loads what that run's `all`\nheld and `active` the rows active when it ended; a `resume` does the\nsame. Under `warm_start` and for `policy.boundary` rows, `all` loads a\nrow the policy records as `scored` (its writing run stored the trial\nstate the row was computed at, under `exports.states` or `level1`)\nwhatever its active flag, and any other loaded row only when that flag\nis set. The exported `is_active` flag records the last selection.\n\nA run with `training.cut_selection.selection.method` set to `dynamic`\nthat simulates under `all` is refused at load when it would hold a row\nthat `all` includes and that is not active, in the policy it loads under\n`warm_start` or `resume` or with training disabled, or in the rows of\n`policy.boundary`; set `active`, or use the `level1` method."
        },
        "enabled": {
          "default": false,
          "description": "Enable post-training simulation.",
          "type": "boolean"
        },
        "io_channel_capacity": {
          "default": 64,
          "description": "Bounded channel capacity between simulation threads and the I/O writer thread.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "scenario_source": {
          "anyOf": [
            {
              "$ref": "#/$defs/RawScenarioSourceConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Scenario source configuration for the post-training simulation forward pass.\nWhen absent, falls back to the training scenario source."
        },
        "selection": {
          "anyOf": [
            {
              "$ref": "#/$defs/SimulationSelection"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Phase-level scenario selection. Absent resolves to the default sampled\ncount."
        },
        "solver": {
          "anyOf": [
            {
              "$ref": "#/$defs/PhaseSolverProfileConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Simulation solver profile. Absent leaves the phase's built-in\ntuned profile."
        }
      },
      "type": "object"
    },
    "SimulationRowSet": {
      "description": "The rows of a stage's row pool a simulation loads\n(`config.json → simulation.cut_set`).",
      "oneOf": [
        {
          "const": "all",
          "description": "Every row a training run added, whatever its active flag.",
          "type": "string"
        },
        {
          "const": "active",
          "description": "Only the rows active when training ended.",
          "type": "string"
        }
      ]
    },
    "SimulationSelection": {
      "description": "Post-training scenario selection and its method-specific parameters\n(`config.json → simulation.selection`).\n\nThe `method` key selects how scenarios are chosen: `sampled` draws\n`num_scenarios` trajectories; `enumerated` walks the scenario set\nexhaustively. Each method accepts only its own parameters, so pairing a\ncount with `enumerated` is a parse error.",
      "oneOf": [
        {
          "additionalProperties": false,
          "description": "Sampled scenarios: draw `num_scenarios` trajectories.",
          "properties": {
            "method": {
              "const": "sampled",
              "type": "string"
            },
            "num_scenarios": {
              "description": "Number of simulation trajectories to draw.",
              "format": "uint32",
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "method",
            "num_scenarios"
          ],
          "type": "object"
        },
        {
          "additionalProperties": false,
          "description": "Exhaustive enumeration of the scenario set.",
          "properties": {
            "method": {
              "const": "enumerated",
              "type": "string"
            }
          },
          "required": [
            "method"
          ],
          "type": "object"
        }
      ]
    },
    "StoppingMode": {
      "description": "How multiple stopping rules combine into a single stop decision\n(`config.json → training.stopping_mode`).",
      "oneOf": [
        {
          "const": "any",
          "description": "Stop when any configured rule triggers (OR).",
          "type": "string"
        },
        {
          "const": "all",
          "description": "Stop when every configured rule other than `iteration_limit` triggers at\nthe same iteration (AND); the largest `iteration_limit` caps the run.",
          "type": "string"
        }
      ]
    },
    "StoppingRuleConfig": {
      "description": "One entry of `training.stopping_rules`. The `type` key selects the rule; a key that belongs to another rule type is a load-time error.",
      "oneOf": [
        {
          "additionalProperties": false,
          "description": "Stop after a fixed number of iterations. **Mandatory** — every rule set must\ncontain at least one `iteration_limit` rule.",
          "properties": {
            "limit": {
              "description": "Maximum iteration count.",
              "format": "uint32",
              "minimum": 0,
              "type": "integer"
            },
            "type": {
              "const": "iteration_limit",
              "type": "string"
            }
          },
          "required": [
            "type",
            "limit"
          ],
          "type": "object"
        },
        {
          "additionalProperties": false,
          "description": "Stop after a wall-clock time limit.",
          "properties": {
            "seconds": {
              "description": "Time limit in seconds.",
              "format": "double",
              "type": "number"
            },
            "type": {
              "const": "time_limit",
              "type": "string"
            }
          },
          "required": [
            "type",
            "seconds"
          ],
          "type": "object"
        },
        {
          "additionalProperties": false,
          "description": "Stop when the lower bound stalls (relative improvement falls below tolerance).",
          "properties": {
            "iterations": {
              "description": "Window size (number of past iterations to compare).",
              "format": "uint32",
              "minimum": 0,
              "type": "integer"
            },
            "tolerance": {
              "description": "Relative improvement threshold.",
              "format": "double",
              "type": "number"
            },
            "type": {
              "const": "bound_stalling",
              "type": "string"
            }
          },
          "required": [
            "type",
            "iterations",
            "tolerance"
          ],
          "type": "object"
        },
        {
          "additionalProperties": false,
          "description": "Stop when the exact upper bound is within tolerance of the lower\nbound. At least one of `tolerance` / `relative_tolerance` must be\npresent (checked at `from_config`). Admissible only under enumerated\nforward selection, where the upper bound is the exact bound a gap rule\nrequires rather than a statistical estimate.",
          "properties": {
            "relative_tolerance": {
              "default": null,
              "description": "Relative gap tolerance in percent (e.g. `0.01` means 0.01%), compared\nagainst `100·gap / max(1, |lower_bound|)` — the same convention the\nreported `gap_percent` uses.",
              "format": "double",
              "type": [
                "number",
                "null"
              ]
            },
            "tolerance": {
              "default": null,
              "description": "Absolute gap tolerance, canonical R$.",
              "format": "double",
              "type": [
                "number",
                "null"
              ]
            },
            "type": {
              "const": "gap",
              "type": "string"
            }
          },
          "required": [
            "type"
          ],
          "type": "object"
        }
      ]
    },
    "TrainingConfig": {
      "additionalProperties": false,
      "description": "Training parameters (`config.json → training`).\n\n`selection` and `stopping_rules` are required; the loader rejects a\nconfiguration that omits either.",
      "properties": {
        "cut_selection": {
          "$ref": "#/$defs/RowSelectionConfig",
          "default": {
            "max_active_per_stage": null,
            "row_activity_tolerance": 1e-6,
            "selection": null
          },
          "description": "Row-selection settings."
        },
        "enabled": {
          "default": true,
          "description": "Enable the training phase. When `false`, skip directly to simulation.",
          "type": "boolean"
        },
        "parallelism": {
          "$ref": "#/$defs/ParallelismConfig",
          "default": {
            "backward_scheduler": {
              "method": "by_scenario"
            }
          },
          "description": "Parallel-execution settings."
        },
        "scenario_source": {
          "anyOf": [
            {
              "$ref": "#/$defs/RawScenarioSourceConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Scenario source configuration for the training forward pass.\nWhen absent, all classes default to `in_sample`."
        },
        "selection": {
          "description": "Phase-level scenario selection. The forward-pass count lives in the\n`sampled` arm; absent is a missing-count load error.",
          "oneOf": [
            {
              "additionalProperties": false,
              "description": "Sampled forward passes: `forward_passes` trajectories per iteration.",
              "properties": {
                "forward_passes": {
                  "description": "Number of forward-pass trajectories per iteration.",
                  "format": "uint32",
                  "minimum": 0,
                  "type": "integer"
                },
                "method": {
                  "const": "sampled",
                  "type": "string"
                }
              },
              "required": [
                "method",
                "forward_passes"
              ],
              "type": "object"
            },
            {
              "additionalProperties": false,
              "description": "Exhaustive enumeration of the scenario openings.",
              "properties": {
                "method": {
                  "const": "enumerated",
                  "type": "string"
                }
              },
              "required": [
                "method"
              ],
              "type": "object"
            }
          ]
        },
        "solver": {
          "$ref": "#/$defs/TrainingSolverConfig",
          "default": {
            "backward": null,
            "forward": null,
            "retry_max_attempts": 5,
            "retry_time_budget_seconds": 30.0
          },
          "description": "LP solver retry settings and optional per-phase solver profiles."
        },
        "stopping_mode": {
          "$ref": "#/$defs/StoppingMode",
          "default": "any",
          "description": "How multiple stopping rules combine: `any` (OR) or `all` (AND over every\nrule except `iteration_limit`, which caps the run)."
        },
        "stopping_rules": {
          "contains": {
            "properties": {
              "type": {
                "const": "iteration_limit"
              }
            },
            "required": [
              "type"
            ]
          },
          "description": "List of stopping rule configurations.\n\n**Mandatory** — no default. Must contain at least one `iteration_limit` rule.",
          "items": {
            "$ref": "#/$defs/StoppingRuleConfig"
          },
          "type": "array"
        },
        "tree_seed": {
          "default": null,
          "description": "Random seed for the opening scenario tree (reproducible training).",
          "format": "int64",
          "type": [
            "integer",
            "null"
          ]
        }
      },
      "required": [
        "stopping_rules",
        "selection"
      ],
      "type": "object"
    },
    "TrainingSolverConfig": {
      "additionalProperties": false,
      "description": "LP solver settings (`config.json → training.solver`): retry policy plus\noptional per-phase solver profiles.",
      "properties": {
        "backward": {
          "anyOf": [
            {
              "$ref": "#/$defs/PhaseSolverProfileConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Backward-pass solver profile. Absent leaves the phase's built-in\ntuned profile."
        },
        "forward": {
          "anyOf": [
            {
              "$ref": "#/$defs/PhaseSolverProfileConfig"
            },
            {
              "type": "null"
            }
          ],
          "default": null,
          "description": "Forward-pass solver profile. Absent leaves the phase's built-in\ntuned profile."
        },
        "retry_max_attempts": {
          "default": 5,
          "description": "Maximum solver retry attempts before propagating a hard error.",
          "format": "uint32",
          "minimum": 0,
          "type": "integer"
        },
        "retry_time_budget_seconds": {
          "default": 30.0,
          "description": "Total time budget in seconds across all retry attempts for one solve.",
          "format": "double",
          "type": "number"
        }
      },
      "type": "object"
    },
    "UpperBoundEvaluationConfig": {
      "additionalProperties": false,
      "description": "Upper-bound evaluation settings (`config.json → upper_bound_evaluation`).",
      "properties": {
        "enabled": {
          "default": null,
          "description": "Enable vertex-based inner approximation for upper bound computation.",
          "type": [
            "boolean",
            "null"
          ]
        },
        "initial_iteration": {
          "default": null,
          "description": "First iteration to compute the upper bound.",
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "interval_iterations": {
          "default": null,
          "description": "Iterations between upper-bound evaluations.",
          "format": "uint32",
          "minimum": 0,
          "type": [
            "integer",
            "null"
          ]
        },
        "lipschitz": {
          "$ref": "#/$defs/LipschitzConfig",
          "default": {
            "fallback_value": null,
            "mode": null,
            "scale_factor": null
          },
          "description": "Lipschitz constant settings."
        }
      },
      "type": "object"
    }
  },
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "description": "Root object of `config.json`.\n\nEvery section except `training` is optional; an absent section takes its defaults.",
  "properties": {
    "$schema": {
      "description": "JSON schema URI — informational, not validated.",
      "type": [
        "string",
        "null"
      ]
    },
    "estimation": {
      "$ref": "#/$defs/EstimationConfig",
      "default": {
        "correlation_target": "inflows",
        "history_years": null,
        "max_coefficient_magnitude": null,
        "max_order": 6,
        "min_observations_per_season": 30,
        "order_selection": "pacf"
      },
      "description": "Time series estimation settings for automatic model parameter fitting."
    },
    "exports": {
      "$ref": "#/$defs/ExportsConfig",
      "default": {
        "fpha_deviation_points": false,
        "states": false,
        "stochastic": false
      },
      "description": "Export flags controlling which outputs are written to disk."
    },
    "modeling": {
      "$ref": "#/$defs/ModelingConfig",
      "default": {
        "cost_scale_factor": null,
        "inflow_non_negativity": {
          "method": "truncation_with_penalty"
        }
      },
      "description": "Modeling options (inflow non-negativity treatment)."
    },
    "policy": {
      "$ref": "#/$defs/PolicyConfig",
      "default": {
        "boundary": null,
        "checkpointing": {
          "compress": null,
          "enabled": null,
          "initial_iteration": null,
          "interval_iterations": null,
          "store_basis": null
        },
        "mode": "fresh",
        "path": "./policy"
      },
      "description": "Policy directory settings (warm-start / resume)."
    },
    "simulation": {
      "$ref": "#/$defs/SimulationConfig",
      "default": {
        "cut_set": "all",
        "enabled": false,
        "io_channel_capacity": 64,
        "scenario_source": null,
        "selection": null,
        "solver": null
      },
      "description": "Post-training simulation settings."
    },
    "training": {
      "$ref": "#/$defs/TrainingConfig",
      "description": "Training parameters — contains mandatory fields."
    },
    "upper_bound_evaluation": {
      "$ref": "#/$defs/UpperBoundEvaluationConfig",
      "default": {
        "enabled": null,
        "initial_iteration": null,
        "interval_iterations": null,
        "lipschitz": {
          "fallback_value": null,
          "mode": null,
          "scale_factor": null
        }
      },
      "description": "Upper-bound evaluation via inner approximation."
    }
  },
  "required": [
    "training"
  ],
  "title": "Config",
  "type": "object"
}