SolvJump Configurator: Examples

Machine code, seat file, version — before any sweep

-- Act 1 - What you are doing --
  -> Customer wheels are license-enforced. You print a machine code, paste it into the Resonix portal, download a .lic, and activate it. Dev CMake builds with SOLVJUMP_LICENSE_OPTIONAL=ON skip the seat file — production wheels do not.

-- Act 2 - Load the native library --
  -> load_library() finds libsolvjump next to the wheel or via SOLVJUMP_C_LIB.
  python_package: 0.3.0
  native: 0.2.0

-- Act 3 - Machine code --
  -> Bare `python -m solvjump` is the same as `solvjump license` — status plus the 64-character code the portal wants. There is no `python -m solvjump activate` or `python -m solvjump status` command.
  machine_code: 
  install_path: <home>\AppData\Roaming\solvjump\license.dat

-- Act 4 - Is a seat active? --
  -> Activate with: solvjump license activate /path/to/solvjump.lic (copies into the platform folder above). Override discovery with SOLVJUMP_LICENSE_FILE.
  license_active: True
  info: 
  days_remaining: -1

-- Act 5 - What this is not --
  -> After the seat is valid, Journey 02 scaffolds a model and dry-runs a study without integrating. Integration is CLI plus the Python Session API.

-- Run complete --

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/01_license_and_status.py
 
# Production one-liner — same API call you ship:
python -m solvjump

A runnable model.py + study.yaml without integrating yet

-- Act 1 - What you are doing --
  -> solvjump init writes a damped-oscillator template with make_rhs and terminal_metrics. You validate the contract, then --dry-run prints grid size and strategy without spending SolvSRK budget.

-- Act 2 - Scaffold --
  -> Writing into _journey02_demo/ (throwaway — safe to delete).
  model: <product-root>\python\examples\_journey02_demo\demo_study\model.py
  study: <product-root>\python\examples\_journey02_demo\demo_study\study.yaml

-- Act 3 - check-model / inspect_model --
  -> The CLI wraps inspect_model(). Ranking/adaptive need terminal_metrics; make_rhs alone is enough to sweep trajectories.
  make_rhs: True
  terminal_metrics: True
  supports_ranking: True
  result: OK
  -> no finalist_sort_key(metrics) hook - using the default ordering (comm_ok/mission_ok gates, else 'rank', else insertion order).

-- Act 4 - Dry-run --
  -> plan_study / solvjump run --dry-run never integrates. Use it in CI to catch YAML mistakes. Dry run only - no session created. Re-run without --dry-run to execute.
  model: <product-root>\python\examples\_journey02_demo\demo_study\model.py:make_rhs
  dynamics_params: k in [0.5, 5], c in [0, 1]
  t_span: [0.0, 10.0]
  sweep_horizon: 10.0 (steps 200 x dt 0.05)
  strategy: adaptive (operator-free MFBO, SRK-verified finalists)
  grid_points: 256
  est_srk_solves: 64 (25% of grid)
  acquisition: auto
  history_mode: auto
  finalists: 50
  -> Warm-start: no prior observations for this family yet (first run)
  study: study.yaml
  model: <product-root>\python\examples\_journey02_demo\demo_study\model.py:make_rhs
  dynamics_params: k in [0.5, 5], c in [0, 1]
  t_span: [0.0, 10.0]
  sweep_horizon: 10.0
  horizon_aligned: True
  solvtune_objective: balanced
  noise_type: gaussian
  grid_points: 256
  strategy_requested: adaptive
  strategy_resolved: adaptive
  warm_start_observations: 0

-- Act 5 - Next --
  -> Journey 03 runs a real 9-point Brusselator study. Delete examples/_journey02_demo whenever you like.

-- Run complete --

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/02_init_check_dry_run.py
 
# Production one-liner — same API call you ship:
solvjump init demo_study

Brusselator example | 9 design points

-- Act 1 - What you are doing --
  -> You have a model with two knobs (a and b). SolvJump tries combinations and writes a CSV of results under your user session folder. Jump is a speed shortcut when physics gates pass; if they fail, the study still completes on an honest SolvSRK fallback.

-- Act 2 - What runs --
  -> The study file is brusselator_study.yaml. Flags you will use later: --json for CI, --quiet (same as SOLVJUMP_QUIET=1) to suppress this narration. Jump recommendation: confidence=exact, cache_ref=<operator_id>, mode=auto SRK collection done - 60 train pairs from 3 trajectories (0 failed, need >=8 train) Fitted nominal+guard kernels - train median SCD=2.79, holdout median SCD=1.68 (n=8/8) Rollout validation - SCD by chain depth [1:1.68, 10:0.77, 20:0.56], max_valid_chain=1 (single_step_only) Accuracy gate passed (operator <operator_id>) SRK timing sample: 3 point(s) integrated for comparison Horizon aligned: 20 jumps x 0.25 s = 5.0 s (jump_lag matches dt) SRK top-50 in jump top-500: 9/9 (100% recall) SRK top-100 in jump top-500: 9/9 (100% recall) top-50 overlap: skipped (sample size 9 < top_n 50) top-100 overlap: skipped (sample size 9 < top_n 100) steady_ok agreement (jump vs SRK): 78% Report: <session-dir>\rank_verification_report.json SRK shortlist (verified ranking for HPC handoff): <session-dir>\srk_shortlist.csv SRK ground truth (authoritative): <session-dir>\finalists_ground_truth_top9.csv Authoritative deliverable: finalists_ground_truth_top9.csv (SRK ground truth — use this for HPC handoff)
  product_json: solvjump run examples/brusselator_study.yaml --json
  product_quiet: solvjump run examples/brusselator_study.yaml --quiet
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dynamics_params: a in [0.8, 1.2], b in [2.5, 3.5]
  y0: [1.0, 3.0]
  t_span: [0.0, 10.0]
  mode: auto
  calibration_seeds: 12
  jump_lags: [0.1, 0.5, 1.0]
  safety_margin: 1.5
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dim: 2
  stiffness_nom: S1
  horizon: [0.0, 10.0]
  problem_set_operators: 256
  -> kepler | dim=2 | stiffness=S0 | dynamics=conservative
  seeds: 12
  reason: no exact cache match for this model
  -> Collecting trajectory training pairs: jump lag=0.25s, SolvTune arm=solvsrk, objective=balanced, target chain=20
  method: grid
  grid_points: 9
  steps: 20
  dt: 0.25
  compare_brute_srk: True
  finalists: 0
  -> Sweep finished - example params {'a': 1.0, 'b': 3.0}, final state ~ [0.7101, 3.3821]
  ! Degeneracy guard tripped on 1 grid point(s) - sweep mode: jump_anchored
  srk_sample_n: 9
  full_grid_truth: True
  min_spearman: 0.85
  -> Full-grid SRK truth: 9/9 rankable in 0.7 s
  grid_points: 9
  srk_ranked: 9
  export: finalists_ground_truth_top9.csv
  srk_best_jump_rank: 4
  -> SRK top-10 in jump top-500: 9/9 (100% recall)
  verified_rows: 9/9 jump-ranked rows
  spearman_rho: 0.817 (gate >= 0.85)
  srk_verify_time: 0.6 s
  best_srk_jump_rank: #4 (regret 3)
  verdict: FAIL — do not cite ranking to clients
  -> top-10 overlap: skipped (sample size 9 < top_n 10)

-- Act 3 - Check the fast path --
  -> See whether SolvJump could fit a speed shortcut for this model. SolvJump fitted a fast approximation and checked it against full SolvSRK — it passed.
  accuracy_check: acceptable quality
  operator_id: <operator_id>
  fit_time: 1.9 s (one-time before the sweep)

-- Act 4 - Read the results --
  -> Corner and mid-range samples plus how long the run took. Mid:  params={'a': 1.0, 'b': 3.0} High: params={'a': 1.2, 'b': 3.5} All results CSV: <session-dir>\sweep_results.csv status, params, final_state ok, {"a": 0.8, "b": 2.5}, [0.3102350523907921, 4.258525612805089] ok, {"a": 0.8, "b": 3.0}, [-6114.664964719156, 6723.456720803129] ok, {"a": 0.8, "b": 3.5}, [-0.6829517125726813, 7.29228994410521] SolvJump used the fast jump path: fit a shortcut, swept the whole grid quickly, and saved results under your session folder. Ranking check vs full SolvSRK: passed. Run your first parameter study from YAML — no custom integration loop to write. Explore all Brusselator (a, b) pairs in one command and get a ranked shortlist. Save a calibrated operator and session for live what-if in Journey 05.
  completed: 9 parameter sets
  skipped: 0
  -> Low:  params={'a': 0.8, 'b': 2.5}
  search_method: fast jump sweep
  grid_size: 9
  operator_fit: 1.9 s
  fast_sweep: 42 ms
  this_run_total: 2.0 s
  vs_full_SolvSRK_on_every_study_point: ~720 ms for all 9 points in this study (extrapolated from 3 spot checks — not a larger search)
  speedup_vs_full_grid: ~17.1× (jump sweep vs brute estimate)
  -> Best candidates file: <session-dir>\finalists_ground_truth_top9.csv

-- Act 5 - Where files live --
  -> Open <session-dir> for CSVs and receipts. Journey 05 (what-if) needs a calibrated jump operator — if this run fell back to srk_only, use a later calibrated session (Robertson often calibrates).

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 9 ok, 0 skipped (of 9)
  fast_sweep: 42.0 ms
  timing_sample: 240.1 ms (3 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~720 ms for all 9 points in this study (from 3 spot checks — not a larger search)
  speedup: ~17.1× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top9.csv
  -- Act 3 - Check the fast path --
  -- Operator setup --
  accuracy_check: acceptable quality
  operator_id: <operator_id>
  fit_time: 1.9 s (one-time before the sweep)
  -- Act 4 - Read the results --
  -- Sweep results --
  completed: 9 parameter sets
  skipped: 0
  -- How long did this take? --
  search_method: fast jump sweep
  grid_size: 9
  operator_fit: 1.9 s
  fast_sweep: 42 ms
  this_run_total: 2.0 s
  vs_full_SolvSRK_on_every_study_point: ~720 ms for all 9 points in this study (extrapolated from 3 spot checks — not a larger search)
  speedup_vs_full_grid: ~17.1× (jump sweep vs brute estimate)
  -- Sweep CSV preview --
  -- What happened --
  -- Why run SolvJump here? --
  -- Act 5 - Where files live --
  -- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 9 ok, 0 skipped (of 9)
  fast_sweep: 42.0 ms
  timing_sample: 240.1 ms (3 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~720 ms for all 9 points in this study (from 3 spot checks — not a larger search)
  speedup: ~17.1× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top9.csv

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/03_first_study.py
 
# Production one-liner — same API call you ship:
solvjump run examples/brusselator_study.yaml

Same Brusselator physics | grid then Latin hypercube

-- Act 1 - Why a Python Session --
  -> YAML is the production path. Session.from_model is the same routing/calibration with knobs in code: param_schema, y0, t_span, stiffness_nom, solvtune_objective, mode, seeds, catalog_slug.
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  parameters: a in [0.8, 1.2], b in [2.5, 3.5]
  method_first: grid n=4

-- Act 2 - Calibrate once --
  -> One Session, two sweeps — grid then LHS — sharing the operator if gates passed. Jump recommendation: confidence=exact, cache_ref=<operator_id>, mode=auto SRK collection done - 24 train pairs from 3 trajectories (0 failed, need >=8 train) Fitted nominal+guard kernels - train median SCD=2.41, holdout median SCD=2.20 (n=8/8) Rollout validation - SCD by chain depth [1:2.20, 4:1.36], max_valid_chain=4 (single_step_only) Accuracy gate passed (operator <operator_id>) SolvJump fitted a fast approximation and checked it against full SolvSRK — it passed.
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dim: 2
  stiffness_nom: S1
  horizon: [0.0, 10.0]
  problem_set_operators: 256
  -> kepler | dim=2 | stiffness=S0 | dynamics=conservative
  seeds: 8
  reason: no exact cache match for this model
  -> Collecting trajectory training pairs: jump lag=0.25s, SolvTune arm=solvsrk, objective=balanced, target chain=4
  accuracy_check: acceptable quality
  operator_id: <operator_id>
  fit_time: 1.3 s (one-time before the sweep)

-- Act 3 - Tensor grid --
  -> sweep(method='grid', n=4) builds a small tensor product. Sweep finished - example params {'a': 1.2, 'b': 2.5}, final state ~ [2.5436, 1.016] SRK timing sample: 3 point(s) integrated for comparison Horizon aligned: 4 jumps x 0.25 s = 1.0 s (jump_lag matches dt) Mid:  params={'a': 0.8, 'b': 3.5} High: params={'a': 1.2, 'b': 3.5}
  completed: 4 parameter sets
  skipped: 0
  -> Low:  params={'a': 0.8, 'b': 2.5}
  search_method: fast jump sweep
  grid_size: 4
  operator_fit: 1.3 s
  fast_sweep: 1 ms
  this_run_total: 1.3 s
  vs_full_SolvSRK_on_every_study_point: ~141 ms for all 4 points in this study (extrapolated from 3 spot checks — not a larger search)
  speedup_vs_full_grid: ~99.5× (jump sweep vs brute estimate)
  -> All results CSV: <session-dir>\sweep_results.csv

-- Act 4 - Latin hypercube --
  -> method='lhs' spreads the same n points through the box. Production YAML: brusselator_study_lhs.yaml (sweep.method: lhs). Jump recommendation: confidence=exact, cache_ref=<operator_id>, mode=auto SRK collection done - 24 train pairs from 3 trajectories (0 failed, need >=8 train) Fitted nominal+guard kernels - train median SCD=2.41, holdout median SCD=2.20 (n=8/8) Rollout validation - SCD by chain depth [1:2.20, 4:1.36], max_valid_chain=4 (single_step_only) Accuracy gate passed (operator <operator_id>) SRK timing sample: 2 point(s) integrated for comparison Horizon aligned: 4 jumps x 0.25 s = 1.0 s (jump_lag matches dt) SRK top-50 in jump top-500: 8/8 (100% recall) SRK top-100 in jump top-500: 8/8 (100% recall) top-50 overlap: skipped (sample size 8 < top_n 50) top-100 overlap: skipped (sample size 8 < top_n 100) steady_ok agreement (jump vs SRK): 100% Report: <session-dir>\rank_verification_report.json SRK shortlist (verified ranking for HPC handoff): <session-dir>\srk_shortlist.csv SRK ground truth (authoritative): <session-dir>\finalists_ground_truth_top8.csv Authoritative deliverable: finalists_ground_truth_top8.csv (SRK ground truth — use this for HPC handoff)
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dynamics_params: a in [0.8, 1.2], b in [2.5, 3.5]
  y0: [1.0, 3.0]
  t_span: [0.0, 10.0]
  mode: auto
  calibration_seeds: 8
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dim: 2
  stiffness_nom: S1
  horizon: [0.0, 10.0]
  problem_set_operators: 256
  -> kepler | dim=2 | stiffness=S0 | dynamics=conservative
  seeds: 8
  reason: no exact cache match for this model
  -> Collecting trajectory training pairs: jump lag=0.25s, SolvTune arm=solvsrk, objective=balanced, target chain=4
  method: lhs
  grid_points: 8
  steps: 4
  dt: 0.25
  compare_brute_srk: True
  finalists: 0
  -> Sweep finished - example params {'a': np.float64(1.077181249573271), 'b': np.float64(3.208828051836704)}, final state ~ [0.9899, 3.1069]
  srk_sample_n: 8
  full_grid_truth: True
  min_spearman: 0.85
  -> Full-grid SRK truth: 8/8 rankable in 0.1 s
  grid_points: 8
  srk_ranked: 8
  export: finalists_ground_truth_top8.csv
  srk_best_jump_rank: 4
  -> SRK top-10 in jump top-500: 8/8 (100% recall)
  verified_rows: 8/8 jump-ranked rows
  spearman_rho: 0.833 (gate >= 0.85)
  srk_verify_time: 0.1 s
  best_srk_jump_rank: #4 (regret 3)
  verdict: FAIL — do not cite ranking to clients
  -> top-10 overlap: skipped (sample size 8 < top_n 10)

-- Act 5 - Takeaway --
  -> Pick grid when you want corners; pick LHS when you want space-filling coverage at the same budget. Next: reuse a calibrated session for live what-if. Build the business case: measured jump sweep vs extrapolated brute SRK on the same grid. Take timing receipts to a design review instead of arguing from intuition. About 128× faster than full SolvSRK on every grid point (jump sweep vs brute estimate).

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 8 ok, 0 skipped (of 8)
  fast_sweep: 0.8 ms
  timing_sample: 24.4 ms (2 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~98 ms for all 8 points in this study (from 2 spot checks — not a larger search)
  speedup: ~128.3× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top8.csv
  -- Sweep results --
  completed: 8 parameter sets
  skipped: 0
  -- How long did this take? --
  search_method: fast jump sweep
  grid_size: 8
  operator_fit: 828 ms
  fast_sweep: 1 ms
  this_run_total: 828 ms
  vs_full_SolvSRK_on_every_study_point: ~98 ms for all 8 points in this study (extrapolated from 2 spot checks — not a larger search)
  speedup_vs_full_grid: ~128.3× (jump sweep vs brute estimate)
  -- Act 5 - Takeaway --
  -- Why run SolvJump here? --
  -- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 8 ok, 0 skipped (of 8)
  fast_sweep: 0.8 ms
  timing_sample: 24.4 ms (2 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~98 ms for all 8 points in this study (from 2 spot checks — not a larger search)
  speedup: ~128.3× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top8.csv

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/04_python_session.py
 
# Production one-liner — same API call you ship:
solvjump run examples/brusselator_study_lhs.yaml

Reload a calibrated operator — no new fit

-- Act 1 - The situation --
  -> Yesterday you ran a study. In today's review someone asks: 'what if this knob moves a little?' You reload the session — no recalibration. propagate() is Python-only; the CLI is sessions list / show.

-- Act 2 - Inventory --
  -> solvjump sessions list — every session under ~/.solvjump/sessions.
  id: 439c8ae64112...
  tier: calibrated
  model: brusselator_model.py:make_rhs
  id: 74465eb894b3...
  tier: calibrated
  model: brusselator_model.py:make_rhs
  id: 87957655899d...
  tier: calibrated
  model: brusselator_model.py:make_rhs
  -> Using most recent calibrated session: <session_id>
  model_ref: <product-root>\python\examples\brusselator_model.py:make_rhs
  problem_id: 29c89c6449dd0461
  stiffness_nom: S1
  y0: [1.0, 3.0]
  t_span: [0.0, 10.0]
  parameters: a in [0.8, 1.2], b in [2.5, 3.5]
  tier: calibrated
  operator_id: <operator_id>
  calibration: <session-dir>\calibration_receipt.json
  sweep: <session-dir>\sweep_receipt.json

-- Act 3 - The what-if --
  -> Four steps of 0.25 s. Each step prints safety mode (nominal / guard / anchor / srk_fallback) and a micro-verify digit count.
  step: 1/4
  mode: nominal
  sim_time: 0.25 s
  state: [0.9588, 3.0465]
  micro_verify_scd: n/a
  step: 2/4
  mode: nominal
  sim_time: 0.50 s
  state: [0.9160, 3.1053]
  micro_verify_scd: n/a
  step: 3/4
  mode: nominal
  sim_time: 0.75 s
  state: [0.8757, 3.1720]
  micro_verify_scd: n/a
  step: 4/4
  mode: nominal
  sim_time: 1.00 s
  state: [0.8412, 3.2424]
  micro_verify_scd: n/a

-- Act 4 - Answer in the meeting --
  -> At params={'a': 1.0, 'b': 3.2}, state after 1.0 s is [np.float64(0.8411567983241416), np.float64(3.2423550195766753)]. Modes stayed in nominal/guard/anchor — operator still valid for this what-if.

-- Act 5 - After the meeting --
  -> Log the session id. Formal sign-off is Journey 11 golden, not propagate(). Answer live what-if questions in a review without recalibrating — reuse yesterday's operator from a saved session. Each propagate step shows safety mode and accuracy check so you can explain the answer, not just quote a number. Turn a hallway question into a receipted answer in seconds instead of scheduling another overnight sweep.

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/05_sessions_and_whatif.py
 
# Production one-liner — same API call you ship:
solvjump sessions list

Robertson (S3) | cache disabled | no terminal_metrics

-- Act 1 - The situation --
  -> Rate constants come from in-house experiments. SOLVJUMP_DISABLE_CACHE=1 forces a fresh calibration instead of a pack hit. robertson_model.py has no terminal_metrics — you read yields from CSV, and adaptive ranking is unavailable.
  make_rhs: True
  terminal_metrics: False
  supports_ranking: False

-- Act 2 - cache_only miss --
  -> mode: cache_only refuses to calibrate. brusselator_study_cache_only.yaml uses a slug that is not in the pack — the product command should error. Jump recommendation: confidence=exact, cache_ref=<operator_id>, mode=cache_only Expected refusal: RecalibrationRequired: no cache operator for fingerprint
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dynamics_params: a in [0.8, 1.2], b in [2.5, 3.5]
  y0: [1.0, 3.0]
  t_span: [0.0, 10.0]
  mode: cache_only
  calibration_seeds: 20
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dim: 2
  stiffness_nom: S1
  horizon: [0.0, 10.0]
  problem_set_operators: not loaded
  -> kepler | dim=2 | stiffness=S0 | dynamics=conservative

-- Act 3 - Wire the model --
  -> k2 spanning 8k-12k. Species A starts at 100%. Jump recommendation: confidence=exact, cache_ref=<operator_id>, mode=auto SRK collection done - 48 train pairs from 3 trajectories (0 failed, need >=8 train) Fitted nominal+guard kernels - train median SCD=6.51, holdout median SCD=6.42 (n=8/8) Rollout validation - SCD by chain depth [1:6.42, 10:5.44, 50:2.80], max_valid_chain=50 (short_chain) Accuracy gate passed (operator <operator_id>) SolvJump fitted a fast approximation and checked it against full SolvSRK — it passed.
  model: <product-root>\python\examples\robertson_model.py:make_rhs
  parameters: k1=0.04, k2 in [8000, 12000]
  cache: SOLVJUMP_DISABLE_CACHE=1
  model: <product-root>\python\examples\robertson_model.py:make_rhs
  dim: 3
  stiffness_nom: S3
  horizon: [0.0, 100.0]
  problem_set_operators: not loaded
  -> robertson | dim=3 | stiffness=S2 | dynamics=relaxation
  seeds: 12
  reason: no exact cache match for this model
  -> Collecting trajectory training pairs: jump lag=0.1s, SolvTune arm=solvsrk, objective=balanced, target chain=unknown
  accuracy_check: excellent quality
  operator_id: <operator_id>
  fit_time: 908 ms (one-time before the sweep)

-- Act 4 - Sweep k2 --
  -> 10 points; 50 steps x 0.5 s. If jump refused, fallback is full-grid SRK screen. Sweep finished - example params {'k1': 0.04, 'k2': 8000.0}, final state ~ [0.736, 0.0, 0.264] SRK timing sample: 3 point(s) integrated for comparison Mid:  params={'k1': 0.04, 'k2': 10000.0} High: params={'k1': 0.04, 'k2': 12000.0}
  ! Horizon mismatch: operator jump_lag=0.1 s but sweep dt=0.5 s — ranking vs SRK will be unreliable
  ! Degeneracy guard tripped on 4 grid point(s) - sweep mode: srk_fallback
  completed: 5 parameter sets
  skipped: 4 outside safe bounds
  -> Low:  params={'k1': 0.04, 'k2': 8000.0}
  search_method: fast jump sweep
  grid_size: 9
  operator_fit: 908 ms
  fast_sweep: 266 ms
  this_run_total: 1.2 s
  vs_full_SolvSRK_on_every_study_point: ~299 ms for all 9 points in this study (extrapolated from 3 spot checks — not a larger search)
  speedup_vs_full_grid: ~1.1× (jump sweep vs brute estimate)
  -> All results CSV: <session-dir>\sweep_results.csv
  highest_C_yield_k2: 8000.0
  center_candidate: {'k1': 0.04, 'k2': 8000.0}

-- Act 5 - Deliverables --
  -> Receipts under <session-dir>. No ranked finalists CSV on this model. If this session is calibrated, Journey 05 can propagate it. Calibrate a jump operator on proprietary stiff kinetics the warm-start pack does not know — your RHS stays in your repo. Map k2 across the design window (5 points) without hand-rolling SRK dispatch. Kill gate blocks a bad operator before you trust an overnight 100-point study. Every parameter set gets a trajectory row — compare yields from CSV even without a ranking hook on this model. Stiff S3 chemistry is where jump pays off at scale — small grids understate the gap.

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 5 ok, 0 skipped (of 9)
  fast_sweep: 265.6 ms
  timing_sample: 99.6 ms (3 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~299 ms for all 9 points in this study (from 3 spot checks — not a larger search)
  speedup: ~1.1× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/06_proprietary_chemistry.py
 
# Production one-liner — same API call you ship:
$env:SOLVJUMP_DISABLE_CACHE=1; solvjump run examples/robertson_study.yaml

256-point drone envelope | mission_ok | 45 min coupled model

-- Act 1 - The customer question --
  -> Can we complete a 45-minute delivery across payload, temperature, headwind, and pack-aging corners? terminal_metrics() turns each trajectory into a ranked row.

-- Act 2 - Scoring vs dynamics --
  -> Every key under params: affects the ODE. scoring_params: (shown on satellite) change only the ranking hook — they do not re-integrate.

-- Act 3 - Run the envelope --
  -> Study file: battery_mission_study.yaml Jump recommendation: confidence=exact, cache_ref=<operator_id>, mode=auto SRK collection done - 144 train pairs from 3 trajectories (0 failed, need >=8 train) Fitted nominal+guard kernels - train median SCD=3.59, holdout median SCD=1.75 (n=8/8) Rollout validation - SCD by chain depth [1:1.75, 10:1.04, 50:0.45], max_valid_chain=1 (single_step_only) Accuracy gate passed (operator <operator_id>) SRK timing sample: 3 point(s) integrated for comparison Horizon aligned: 108 jumps x 25.0 s = 2700.0 s (jump_lag matches dt) #1 mission margin: payload=0.27 kg, temp=40 C -> SOC=50.0%, V=21.2 V SRK top-50 in jump top-500: 50/50 (100% recall) SRK top-100 in jump top-500: 87/87 (100% recall) top-50 overlap: 50/50 (100%) top-100 overlap: skipped (sample size 50 < top_n 100) mission_ok agreement (jump vs SRK): 100% Report: <session-dir>\rank_verification_report.json SRK shortlist (verified ranking for HPC handoff): <session-dir>\srk_shortlist.csv SRK ground truth (authoritative): <session-dir>\finalists_ground_truth_top87.csv Authoritative deliverable: finalists_ground_truth_top87.csv (SRK ground truth — use this for HPC handoff)
  model: <product-root>\python\examples\battery_mission_model.py:make_rhs
  dynamics_params: payload_kg in [0, 0.8], temp_C in [-10, 40], headwind_mps in [0, 12], pack_cycles in [0, 400]
  y0: [1.0, 0.0, 0.0, 0.0, 0.35]
  t_span: [0.0, 2700.0]
  mode: auto
  calibration_seeds: 12
  jump_lags: [0.1, 0.5, 1.0]
  safety_margin: 1.5
  model: <product-root>\python\examples\battery_mission_model.py:make_rhs
  dim: 5
  stiffness_nom: S1
  horizon: [0.0, 2700.0]
  problem_set_operators: 256
  -> piecewise_linear_3regime | dim=5 | stiffness=S1 | dynamics=relaxation
  seeds: 12
  reason: no exact cache match for this model
  -> Collecting trajectory training pairs: jump lag=25.0s, SolvTune arm=solvsrk, objective=balanced, target chain=108
  method: grid
  grid_points: 256
  steps: 108
  dt: 25.0
  compare_brute_srk: True
  finalists: 50
  -> Sweep finished - example params {'payload_kg': 0.5333333333333333, 'temp_C': 23.333333333333336, 'headwind_mps': 0.0, 'pack_cycles': 0.0}, final state ~ [0.406, 0.2413, 0.6995, 0.7196, 0.5559]
  ! Degeneracy guard tripped on 65 grid point(s) - sweep mode: srk_fallback
  -> Jump pool (NOT SRK truth): top 50 of 87 by jump metrics -> finalists_top50.csv
  srk_sample_n: 50
  full_grid_truth: True
  min_spearman: 0.85
  -> Full-grid SRK truth: 87/191 rankable in 109.6 s
  grid_points: 256
  srk_ranked: 87
  export: finalists_ground_truth_top87.csv
  srk_best_jump_rank: 1
  -> SRK top-10 in jump top-500: 10/10 (100% recall)
  verified_rows: 50/87 jump-ranked rows
  spearman_rho: 1.000 (gate >= 0.85)
  srk_verify_time: 29.7 s
  best_srk_jump_rank: #1 (regret 0)
  verdict: PASS — safe to cite finalist ranking
  -> top-10 overlap: 10/10 (100%)

-- Act 4 - Next --
  -> If jump was untrusted, Journey 08 runs the same physics with strategy: adaptive so every finalist is a real SolvSRK integration. Map a 45-minute delivery envelope (191 payload/temperature/headwind corners) in one workshop run. Leave with a ranked shortlist of mission-feasible parameter sets for the RFP. See which corners fail mission_ok before committing hardware or schedule.

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 191 ok, 0 skipped (of 256)
  fast_sweep: 123402.9 ms
  timing_sample: 1710.0 ms (3 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~2.4 min for all 256 points in this study (from 3 spot checks — not a larger search)
  speedup: ~1.2× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_jump_pool: <session-dir>\finalists_top50.csv
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top87.csv
  -- Operator setup --
  accuracy_check: acceptable quality
  operator_id: <operator_id>
  fit_time: 7.9 s (one-time before the sweep)
  mission_criteria: SOC >= 20%, V >= 18 V, thermal limits after 45 min delivery profile
  pass_count: 87/191 Monte Carlo samples
  fail_count: 104
  -- Sweep results --
  completed: 191 parameter sets
  skipped: 65 outside safe bounds
  -- How long did this take? --
  ! Speedup under ~1.5× — jump is not buying much wall clock on this study. Common on cheap S0 models, long jump chains, or when the degeneracy guard falls back to full SolvSRK on many points.
  search_method: fast jump sweep
  grid_size: 256
  operator_fit: 7.9 s
  fast_sweep: 2.1 min
  this_run_total: 2.2 min
  vs_full_SolvSRK_on_every_study_point: ~2.4 min for all 256 points in this study (extrapolated from 3 spot checks — not a larger search)
  speedup_vs_full_grid: ~1.2× (jump sweep vs brute estimate)
  -- Act 4 - Next --
  -- Why run SolvJump here? --
  -- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 191 ok, 0 skipped (of 256)
  fast_sweep: 123402.9 ms
  timing_sample: 1710.0 ms (3 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~2.4 min for all 256 points in this study (from 3 spot checks — not a larger search)
  speedup: ~1.2× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_jump_pool: <session-dir>\finalists_top50.csv
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top87.csv

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/07_ranked_mission.py
 
# Production one-liner — same API call you ship:
solvjump run examples/battery_mission_study.yaml

Variant: battery | 128-point drone envelope, 25% SRK budget

-- Act 1 - Why adaptive exists --
  -> Jump is fast only when holdout + rollout pass. Adaptive skips calibration: it integrates ~budget_frac of the grid at full SolvSRK. Finalists are SRK-native — no separate rank-verify pass. CLI: --strategy adaptive.

-- Act 2 - YAML knobs --
  -> sweep.strategy, budget_frac, top_k, acquisition, history_mode. CLI --strategy overrides YAML.

-- Act 3 - Run --
  -> Study: battery_mission_study_adaptive.yaml Adaptive finalists are SRK-intrinsic (each is a full-SolvSRK solve) - no separate rank verification needed
  model: <product-root>\python\examples\battery_mission_model.py:make_rhs
  dynamics_params: payload_kg in [0, 0.8], temp_C in [-10, 40], headwind_mps in [0, 12], pack_cycles in [0, 400]
  y0: [1.0, 0.0, 0.0, 0.0, 0.35]
  t_span: [0.0, 2700.0]
  mode: auto
  calibration_seeds: 20
  grid_points: 128
  budget_frac: 0.25
  top_k: 10
  acquisition: auto
  history_mode: auto
  acquisition: lcb
  integrated: 20/81 (25% budget)
  rounds: 5
  history: mode=auto supplied=0 trust=None
  best_scalar: -0.5905953484532385
  -> Authoritative deliverable: finalists_ground_truth_top25.csv (SRK ground truth from adaptive search — use this for HPC handoff)

-- Act 4 - Evidence store --
  -> There is no `solvjump evidence list` subcommand. Bare `solvjump evidence` lists families. Pass a YAML to count one family. History warm-starts the next adaptive run. Stored families (1): 8a384ff3f2c515e2: 19 observation(s)
  this_family: 8a384ff3f2c515e2
  observations: 19

-- Act 5 - What to tell the customer --
  -> Every row in finalists_ground_truth_topN.csv is a real full-SolvSRK integration. Get a ranked shortlist when jump calibration is unavailable or untrusted. Every finalist is a real full-SolvSRK integration — no separate verify pass needed. Search 81 scenarios by integrating a budgeted sample, not the full grid blindly. Full SolvSRK on ~25% of the grid instead of every point — ranking stays integration-native.

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 19 ok, 0 skipped (of 19)
  search_method: smart search (sampled full SolvSRK points)
  this_run: 11080.4 ms
  vs_full_SolvSRK_on_every_study_point: ~44876 ms for all 81 points in this study (extrapolated from 20 sampled points — not a larger search)
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_finalists: <session-dir>\finalists_ground_truth_top25.csv
  mission_criteria: SOC >= 20%, V >= 18 V, thermal limits after 45 min delivery profile
  pass_count: 19/19 Monte Carlo samples
  fail_count: 0
  -- What happened --
  -- Act 4 - Evidence store --
  this_family: 8a384ff3f2c515e2
  observations: 19
  -- Act 5 - What to tell the customer --
  -- Why run SolvJump here? --
  -- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 19 ok, 0 skipped (of 19)
  search_method: smart search (sampled full SolvSRK points)
  this_run: 11080.4 ms
  vs_full_SolvSRK_on_every_study_point: ~44876 ms for all 81 points in this study (extrapolated from 20 sampled points — not a larger search)
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_finalists: <session-dir>\finalists_ground_truth_top25.csv

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/08_adaptive_and_evidence.py
 
# Production one-liner — same API call you ship:
solvjump run examples/battery_mission_study_adaptive.yaml --strategy adaptive

balanced | precision | survival | efficiency — same ODE, different SRK config

-- Act 1 - Why objective matters --
  -> SolvTune's flat corpus is keyed by objective × noise. Calibration and golden runs use the matching SolvSRK backend. CLI --objective overrides YAML solvtune_objective.

-- Act 2 - Noise and horizon hints --
  -> YAML: noise_type (gaussian|fixed_path), deployment_noise_sigma, horizon_multiplier_hint. Same fields exist on Session.from_model.

-- Act 3 - Accmode --
  -> SolvTune may recommend continuation_backend=acmode. That needs an accmode-capable SolvSRK wheel. Without it, Jump warns and continues with the mapped fields the installed wheel supports — it does not silently invent a backend.

-- Act 4 - Run precision --
  -> Equivalent YAML: brusselator_study_objective.yaml Jump recommendation: confidence=exact, cache_ref=<operator_id>, mode=auto SRK collection done - 60 train pairs from 3 trajectories (0 failed, need >=8 train) Fitted nominal+guard kernels - train median SCD=2.79, holdout median SCD=1.68 (n=8/8) Rollout validation - SCD by chain depth [1:1.68, 10:0.77, 20:0.56], max_valid_chain=1 (single_step_only) Accuracy gate passed (operator <operator_id>) SRK timing sample: 3 point(s) integrated for comparison Horizon aligned: 20 jumps x 0.25 s = 5.0 s (jump_lag matches dt) SRK top-50 in jump top-500: 9/9 (100% recall) SRK top-100 in jump top-500: 9/9 (100% recall) top-50 overlap: skipped (sample size 9 < top_n 50) top-100 overlap: skipped (sample size 9 < top_n 100) steady_ok agreement (jump vs SRK): 78% Report: <session-dir>\rank_verification_report.json SRK shortlist (verified ranking for HPC handoff): <session-dir>\srk_shortlist.csv SRK ground truth (authoritative): <session-dir>\finalists_ground_truth_top9.csv Authoritative deliverable: finalists_ground_truth_top9.csv (SRK ground truth — use this for HPC handoff)
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dynamics_params: a in [0.8, 1.2], b in [2.5, 3.5]
  y0: [1.0, 3.0]
  t_span: [0.0, 10.0]
  mode: auto
  calibration_seeds: 12
  jump_lags: [0.1, 0.5, 1.0]
  safety_margin: 1.5
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dim: 2
  stiffness_nom: S1
  horizon: [0.0, 10.0]
  problem_set_operators: 256
  -> kepler | dim=2 | stiffness=S0 | dynamics=conservative
  seeds: 12
  reason: no exact cache match for this model
  -> Collecting trajectory training pairs: jump lag=0.25s, SolvTune arm=solvsrk, objective=precision, target chain=20
  method: grid
  grid_points: 9
  steps: 20
  dt: 0.25
  compare_brute_srk: True
  finalists: 0
  -> Sweep finished - example params {'a': 1.0, 'b': 3.0}, final state ~ [0.7101, 3.3821]
  ! Degeneracy guard tripped on 1 grid point(s) - sweep mode: jump_anchored
  srk_sample_n: 9
  full_grid_truth: True
  min_spearman: 0.85
  -> Full-grid SRK truth: 9/9 rankable in 0.4 s
  grid_points: 9
  srk_ranked: 9
  export: finalists_ground_truth_top9.csv
  srk_best_jump_rank: 4
  -> SRK top-10 in jump top-500: 9/9 (100% recall)
  verified_rows: 9/9 jump-ranked rows
  spearman_rho: 0.817 (gate >= 0.85)
  srk_verify_time: 0.4 s
  best_srk_jump_rank: #4 (regret 3)
  verdict: FAIL — do not cite ranking to clients
  -> top-10 overlap: skipped (sample size 9 < top_n 10)

-- Act 5 - Takeaway --
  -> Pick the objective that matches the question (precision vs survival vs cost). Do not mix objectives when comparing two studies. Run your first parameter study from YAML — no custom integration loop to write. Explore all Brusselator (a, b) pairs in one command and get a ranked shortlist. Save a calibrated operator and session for live what-if in Journey 05.

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 9 ok, 0 skipped (of 9)
  fast_sweep: 38.7 ms
  timing_sample: 114.6 ms (3 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~344 ms for all 9 points in this study (from 3 spot checks — not a larger search)
  speedup: ~8.9× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top9.csv
  -- Operator setup --
  accuracy_check: acceptable quality
  operator_id: <operator_id>
  fit_time: 1.1 s (one-time before the sweep)
  -- Sweep results --
  completed: 9 parameter sets
  skipped: 0
  -- How long did this take? --
  search_method: fast jump sweep
  grid_size: 9
  operator_fit: 1.1 s
  fast_sweep: 39 ms
  this_run_total: 1.1 s
  vs_full_SolvSRK_on_every_study_point: ~344 ms for all 9 points in this study (extrapolated from 3 spot checks — not a larger search)
  speedup_vs_full_grid: ~8.9× (jump sweep vs brute estimate)
  -- What happened --
  solvtune_objective: precision
  noise_type: gaussian
  -- Act 5 - Takeaway --
  -- Why run SolvJump here? --
  -- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 9 ok, 0 skipped (of 9)
  fast_sweep: 38.7 ms
  timing_sample: 114.6 ms (3 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~344 ms for all 9 points in this study (from 3 spot checks — not a larger search)
  speedup: ~8.9× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top9.csv

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/09_solvtune_objective.py
 
# Production one-liner — same API call you ship:
solvjump run examples/brusselator_study.yaml --objective precision

Brusselator long chain | strategy: full -> adaptive fallback

-- Act 1 - The physics gate --
  -> Jump operators must pass holdout SCD and chained rollout (no fixed-point collapse). This YAML asks for a 20-step chain at dt=0.25 — a regime where Brusselator often fails rollout even if a single step looks fine.

-- Act 2 - What we request --
  -> brusselator_study_refuse.yaml uses strategy: full. Because brusselator_model.py defines terminal_metrics(), a refusal auto-runs adaptive MFBO instead of dead-ending.

-- Act 3 - Contrast with Robertson (Journey 06) --
  -> robertson_model.py has NO terminal_metrics(). If jump refused there, fallback is full-grid SRK screen with no ranked CSV — see COVERAGE.md §4. Jump recommendation: confidence=exact, cache_ref=<operator_id>, mode=auto SRK collection done - 60 train pairs from 3 trajectories (0 failed, need >=8 train) Fitted nominal+guard kernels - train median SCD=2.79, holdout median SCD=1.68 (n=8/8) Rollout validation - SCD by chain depth [1:1.68, 10:0.77, 20:0.56], max_valid_chain=1 (single_step_only) Accuracy gate passed (operator <operator_id>) Horizon aligned: 20 jumps x 0.25 s = 5.0 s (jump_lag matches dt) SRK top-50 in jump top-500: 9/9 (100% recall) SRK top-100 in jump top-500: 9/9 (100% recall) top-50 overlap: skipped (sample size 9 < top_n 50) top-100 overlap: skipped (sample size 9 < top_n 100) steady_ok agreement (jump vs SRK): 78% Report: <session-dir>\rank_verification_report.json SRK shortlist (verified ranking for HPC handoff): <session-dir>\srk_shortlist.csv SRK ground truth (authoritative): <session-dir>\finalists_ground_truth_top9.csv Authoritative deliverable: finalists_ground_truth_top9.csv (SRK ground truth — use this for HPC handoff)
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dynamics_params: a in [0.8, 1.2], b in [2.5, 3.5]
  y0: [1.0, 3.0]
  t_span: [0.0, 10.0]
  mode: auto
  calibration_seeds: 12
  jump_lags: [0.1, 0.5, 1.0]
  safety_margin: 1.5
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dim: 2
  stiffness_nom: S1
  horizon: [0.0, 10.0]
  problem_set_operators: 256
  -> kepler | dim=2 | stiffness=S0 | dynamics=conservative
  seeds: 12
  reason: no exact cache match for this model
  -> Collecting trajectory training pairs: jump lag=0.25s, SolvTune arm=solvsrk, objective=balanced, target chain=20
  method: grid
  grid_points: 9
  steps: 20
  dt: 0.25
  compare_brute_srk: False
  finalists: 10
  -> Sweep finished - example params {'a': 1.0, 'b': 3.0}, final state ~ [0.7101, 3.3821]
  ! Degeneracy guard tripped on 1 grid point(s) - sweep mode: jump_anchored
  -> Jump pool (NOT SRK truth): top 9 of 9 by jump metrics -> finalists_top10.csv
  srk_sample_n: 9
  full_grid_truth: True
  min_spearman: 0.85
  -> Full-grid SRK truth: 9/9 rankable in 0.5 s
  grid_points: 9
  srk_ranked: 9
  export: finalists_ground_truth_top9.csv
  srk_best_jump_rank: 4
  -> SRK top-10 in jump top-500: 9/9 (100% recall)
  verified_rows: 9/9 jump-ranked rows
  spearman_rho: 0.817 (gate >= 0.85)
  srk_verify_time: 0.4 s
  best_srk_jump_rank: #4 (regret 3)
  verdict: FAIL — do not cite ranking to clients
  -> top-10 overlap: skipped (sample size 9 < top_n 10)

-- Act 4 - Takeaway --
  -> Product coverage = any ODE study completes. Jump speed is the bonus when physics allows. For client ranking claims on jump sweeps that DID succeed, still run Journey 12 (verify-ranking). The study completes even when jump refuses — ops is not blocked. Jump succeeded on this run — you get fast screening plus ranked comm windows. Models with terminal_metrics get adaptive fallback; without it you only get a slow full-grid screen. Same YAML path covers both fast jump and honest fallback — no dead-end workflow.

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 9 ok, 0 skipped (of 9)
  fast_sweep: 62.6 ms
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_jump_pool: <session-dir>\finalists_top10.csv
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top9.csv
  -- What happened --
  session_tier: calibrated
  operator_id: <operator_id>
  -- Act 4 - Takeaway --
  -- Why run SolvJump here? --
  -- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 9 ok, 0 skipped (of 9)
  fast_sweep: 62.6 ms
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_jump_pool: <session-dir>\finalists_top10.csv
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top9.csv

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/10_when_jump_refuses.py
 
# Production one-liner — same API call you ship:
solvjump run examples/brusselator_study_refuse.yaml

Explore, then prove one finalist with full-horizon SolvSRK

-- Act 1 - The situation --
  -> You cannot ship a config based on jump alone. YAML golden.enabled: true runs a multi-seed SolvSRK proof after the sweep. The Python Session.golden() API does the same on a chosen point.

-- Act 2 - Exploration + YAML golden --
  -> Study file: brusselator_study_golden.yaml Jump recommendation: confidence=exact, cache_ref=<operator_id>, mode=auto SRK collection done - 24 train pairs from 3 trajectories (0 failed, need >=8 train) Fitted nominal+guard kernels - train median SCD=2.41, holdout median SCD=2.20 (n=8/8) Rollout validation - SCD by chain depth [1:2.20, 4:1.36], max_valid_chain=4 (single_step_only) Accuracy gate passed (operator <operator_id>) SRK timing sample: 2 point(s) integrated for comparison Horizon aligned: 4 jumps x 0.25 s = 1.0 s (jump_lag matches dt) SRK top-50 in jump top-500: 9/9 (100% recall) SRK top-100 in jump top-500: 9/9 (100% recall) top-50 overlap: skipped (sample size 9 < top_n 50) top-100 overlap: skipped (sample size 9 < top_n 100) steady_ok agreement (jump vs SRK): 100% Report: <session-dir>\rank_verification_report.json SRK shortlist (verified ranking for HPC handoff): <session-dir>\srk_shortlist.csv SRK ground truth (authoritative): <session-dir>\finalists_ground_truth_top9.csv Authoritative deliverable: finalists_ground_truth_top9.csv (SRK ground truth — use this for HPC handoff)
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dynamics_params: a in [0.8, 1.2], b in [2.5, 3.5]
  y0: [1.0, 3.0]
  t_span: [0.0, 10.0]
  mode: auto
  calibration_seeds: 8
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  dim: 2
  stiffness_nom: S1
  horizon: [0.0, 10.0]
  problem_set_operators: 256
  -> kepler | dim=2 | stiffness=S0 | dynamics=conservative
  seeds: 8
  reason: no exact cache match for this model
  -> Collecting trajectory training pairs: jump lag=0.25s, SolvTune arm=solvsrk, objective=balanced, target chain=4
  method: grid
  grid_points: 9
  steps: 4
  dt: 0.25
  compare_brute_srk: True
  finalists: 0
  -> Sweep finished - example params {'a': 1.0, 'b': 3.0}, final state ~ [1.0753, 2.8878]
  seeds: 3
  params: {'a': 1.0, 'b': 3.0}
  t_span: [0.0, 10.0]
  srk_sample_n: 9
  full_grid_truth: True
  min_spearman: 0.85
  -> Full-grid SRK truth: 9/9 rankable in 0.2 s
  grid_points: 9
  srk_ranked: 9
  export: finalists_ground_truth_top9.csv
  srk_best_jump_rank: 1
  -> SRK top-10 in jump top-500: 9/9 (100% recall)
  verified_rows: 9/9 jump-ranked rows
  spearman_rho: 0.983 (gate >= 0.85)
  srk_verify_time: 0.2 s
  best_srk_jump_rank: #1 (regret 0)
  verdict: PASS — safe to cite finalist ranking
  -> top-10 overlap: skipped (sample size 9 < top_n 10)

-- Act 3 - Python golden on a mid-grid point --
  -> session.golden(params={'a': 1.0, 'b': 3.0}, seeds=3) over t=(0.0, 10.0). YAML already requested golden on a=1,b=3; this second call shows the API.
  passed: True
  median_scd: 3.00 digits
  survival_rate: 100%
  receipt: <session-dir>\golden_run_gol_e36461a79b614313.json
  decision: APPROVED for handoff to SolvSRK-Edge

-- Act 4 - Package for review --
  -> Attach calibration, sweep, and golden receipts from <session-dir>. Explore the design space fast with jump; reserve full SolvSRK for sign-off only. Run multi-seed golden proof on one finalist — not on the whole grid. Package calibration + sweep + golden receipts for flight or analytical review. Golden proof passed — hand off the finalist config with integration evidence.

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 9 ok, 0 skipped (of 9)
  fast_sweep: 0.9 ms
  timing_sample: 33.3 ms (2 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~150 ms for all 9 points in this study (from 2 spot checks — not a larger search)
  speedup: ~159.9× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_golden: <session-dir>\golden_run_gol_b5165065d36146aa.json
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top9.csv
  -- Operator setup --
  accuracy_check: acceptable quality
  operator_id: <operator_id>
  fit_time: 697 ms (one-time before the sweep)
  -- Sweep results --
  completed: 9 parameter sets
  skipped: 0
  -- How long did this take? --
  search_method: fast jump sweep
  grid_size: 9
  operator_fit: 697 ms
  fast_sweep: 1 ms
  this_run_total: 698 ms
  vs_full_SolvSRK_on_every_study_point: ~150 ms for all 9 points in this study (extrapolated from 2 spot checks — not a larger search)
  speedup_vs_full_grid: ~159.9× (jump sweep vs brute estimate)
  -- Act 3 - Python golden on a mid-grid point --
  passed: True
  median_scd: 3.00 digits
  survival_rate: 100%
  receipt: <session-dir>\golden_run_gol_e36461a79b614313.json
  decision: APPROVED for handoff to SolvSRK-Edge
  -- Act 4 - Package for review --
  -- Why run SolvJump here? --
  -- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 9 ok, 0 skipped (of 9)
  fast_sweep: 0.9 ms
  timing_sample: 33.3 ms (2 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~150 ms for all 9 points in this study (from 2 spot checks — not a larger search)
  speedup: ~159.9× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_golden: <session-dir>\golden_run_gol_e36461a79b614313.json
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top9.csv

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/11_golden_proof.py
 
# Production one-liner — same API call you ship:
solvjump run examples/brusselator_study_golden.yaml

Prove jump order vs full SolvSRK — do not re-run the grid

-- Act 1 - The client question --
  -> Jump-ranked finalists_topN.csv is an extrapolation. verify-ranking re-scores a stratified sample with SolvSRK. Thresholds: --srk-sample-n, --min-spearman, --min-top-n-overlap. Using session <session_id> (<product-root>\python\examples\brusselator_model.py:make_rhs)

-- Act 2 - Run the gate --
  -> Same as: solvjump verify-ranking <id> --srk-sample-n 20 top-50 overlap: skipped (sample size 9 < top_n 50) top-100 overlap: skipped (sample size 9 < top_n 100) steady_ok agreement (jump vs SRK): 78% Report: <session-dir>\rank_verification_report.json SRK shortlist (verified ranking for HPC handoff): <session-dir>\srk_shortlist.csv
  verified_rows: 9/9 jump-ranked rows
  spearman_rho: 0.817 (gate >= 0.85)
  srk_verify_time: 0.8 s
  best_srk_jump_rank: #4 (regret 3)
  verdict: FAIL — do not cite ranking to clients
  -> top-10 overlap: skipped (sample size 9 < top_n 10)

-- Act 3 - Read the report --
  -> Check rank_verification_report.json before citing 'best' rows. top-10 overlap: skipped (sample size 9 < top_n 10) top-50 overlap: skipped (sample size 9 < top_n 50) top-100 overlap: skipped (sample size 9 < top_n 100)
  passed: False
  spearman_rho: 0.8166666666666667
  rank_regret: 3
  srk_verified_rows: 9
  verdict: FAIL — do not cite ranking
  -> Full report: <session-dir>\rank_verification_report.json

-- Act 4 - Next --
  -> Journey 13 scales a comm-window search and shows why HPC still exists.

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/12_rank_verification.py
 
# Production one-liner — same API call you ship:
solvjump verify-ranking <session_id>

Tier: quick | 512 scenarios | 6 h @ 5 min steps

-- Act 1 - Ops cadence --
  -> 72 x 300 s (5-minute planning steps). 50 s micro-steps trigger srk_fallback and erase the speed story — do not use them for this demo.

-- Act 2 - Can SolvJump replace HPC? --
  -> No. It gates the cluster: explore the ODE envelope on the ground, queue only finalists for high-fidelity confirmation.

-- Act 3 - Run the comm-window study --
  -> Study file: satellite_comm_study_quick.yaml Jump recommendation: confidence=recalibrate_required, cache_ref=(none), mode=auto SRK collection done - 144 train pairs from 3 trajectories (0 failed, need >=8 train) Fitted nominal+guard kernels - train median SCD=8.01, holdout median SCD=7.12 (n=8/8) Rollout validation - SCD by chain depth [1:7.12, 10:5.55, 50:4.49, 72:4.52], max_valid_chain=72 (short_chain) Accuracy gate passed (operator <operator_id>) SRK timing sample: 3 point(s) integrated for comparison Horizon aligned: 72 jumps x 300.0 s = 21600.0 s (jump_lag matches dt) Jump pool (NOT SRK truth): top 500 of 512 by jump metrics -> finalists_top500.csv #1 comm window: gs_lon=-77 deg, inj_error=-21.4 deg, drag_scale=0.71 -> pass in 0 min, peak el=89.9 deg SRK top-10 in jump top-500: 10/10 (100% recall) SRK top-50 in jump top-500: 50/50 (100% recall) SRK top-100 in jump top-500: 100/100 (100% recall) top-50 overlap: 50/50 (100%) comm_ok agreement (jump vs SRK): 100% Report: <session-dir>\rank_verification_report.json SRK shortlist (verified ranking for HPC handoff): <session-dir>\srk_shortlist.csv SRK ground truth (authoritative): <session-dir>\finalists_ground_truth_top100.csv Authoritative deliverable: finalists_ground_truth_top100.csv (SRK ground truth — use this for HPC handoff)
  model: <product-root>\python\examples\satellite_comm_model.py:make_rhs
  dynamics_params: inj_error_deg in [-30, 30], drag_scale in [0.5, 2]
  y0: [0.0, 500.0]
  t_span: [0.0, 21600.0]
  mode: auto
  calibration_seeds: 24
  scoring_params: gs_lon_deg in [-180, 180]
  jump_lags: [0.1, 0.5, 1.0, 300.0]
  safety_margin: 2.0
  model: <product-root>\python\examples\satellite_comm_model.py:make_rhs
  dim: 2
  stiffness_nom: S0
  horizon: [0.0, 21600.0]
  problem_set_operators: 256
  -> flame_propagation | dim=2 | stiffness=S2 | dynamics=unknown
  seeds: 24
  reason: no exact cache match for this model
  -> Collecting trajectory training pairs: jump lag=300.0s, SolvTune arm=solvsrk, objective=balanced, target chain=72
  method: grid
  grid_points: 512
  steps: 72
  dt: 300.0
  compare_brute_srk: True
  finalists: 500
  -> Sweep finished - example params {'inj_error_deg': 4.285714285714285, 'drag_scale': 0.5, 'gs_lon_deg': -180.0}, final state ~ [23.9546, 497.3764]
  srk_sample_n: 50
  full_grid_truth: True
  min_spearman: 0.85
  -> Full-grid SRK truth: 512/512 rankable in 275.9 s
  grid_points: 512
  srk_ranked: 512
  export: finalists_ground_truth_top100.csv
  srk_best_jump_rank: 1
  -> SRK #1: gs_lon=-77 deg, window=0 s
  verified_rows: 50/512 jump-ranked rows
  spearman_rho: 1.000 (gate >= 0.85)
  srk_verify_time: 24.8 s
  best_srk_jump_rank: #1 (regret 0)
  verdict: PASS — safe to cite finalist ranking
  -> top-10 overlap: 10/10 (100%)

-- Act 4 - Extrapolate to cluster scale --
  -> Using measured per-point cost — not a fake multi-hour local run. Workflow: SolvJump sweep on the ground, rank with terminal_metrics(), write finalists_ground_truth_top100.csv — queue those rows to HPC for high-fidelity confirmation. Using SRK ground-truth finalists (authoritative ranking). SolvJump helps HPC by shrinking what you submit — not by magically making cluster jobs milliseconds. Golden SolvSRK + your HPC toolchain still prove finalists.
  anchor: Measured on this laptop: 512 pts, 527 ms/pt brute, 1.9 ms/pt jump
  cluster_exploration: 100,000 scenarios (single revision)
  brute_srk_single_machine: 14.6 h
  solvjump_single_machine: 3.3 min
  design_revisions: 20 program iterations
  brute_revisions_total: 292.6 h
  solvjump_revisions_total: 1.1 h
  finalists_file: <session-dir>\finalists_ground_truth_top100.csv
  finalists_in_file: 100 ranked rows (top 500 requested)
  -> SolvJump does not replace your cluster solver or CFD/FEA jobs. It runs on an engineer workstation and searches your ODE parameter envelope fast.
  hpc_jobs_without_gate: 100,000 full jobs @ 0.05 core-h each = 5,000 core-hours
  hpc_jobs_with_gate: 500 finalist jobs = 25 core-hours
  core_hours_saved: 4,975 core-hours not queued (exploration on ground)
  -> Brute SRK across 20 revisions at cluster scale is 292.6 h on one machine — that is the 'hours/days' waste when teams re-run full grids every time a bound moves.

-- Act 5 - Recommendation --
  -> SolvJump on the laptop; HPC for rows in the finalists CSV, not 100k exploration jobs. Optional: --tier standard / full. Next: Journey 14 maps remaining Python exports. Search station longitude, injection error, and drag for a downlink window — one command, no custom solver loop. Screen 512 six-hour propagations in ~6.8 s instead of full SolvSRK on every grid point. About 270× faster than full SolvSRK on every grid point (jump sweep vs brute estimate). Leave with a ranked list of comm windows — pick a ground station and orbit correction before the pass closes. Sweep ground-station longitude in scoring only; dynamics runs are not repeated when you shift lon across the grid. Jump ranking matches full SolvSRK on a sample — safe to cite the order in a review. Quickly generates a verified parameter shortlist for HPC handoff, avoiding full brute-force sweeps on the cluster. Same workflow scales to 2k–16k scenarios with --tier standard or full. Estimate cluster cost from a laptop anchor sweep before queueing 100k-point jobs. Explore the ODE envelope on the ground; queue HPC only for finalists worth confirming. Avoid burning core-hours on parameter regions you could have ruled out locally. About 270× faster than full SolvSRK on every grid point (jump sweep vs brute estimate).

-- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 512 ok, 0 skipped (of 512)
  fast_sweep: 997.8 ms
  timing_sample: 1579.9 ms (3 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~4.5 min for all 512 points in this study (from 3 spot checks — not a larger search)
  speedup: ~270.2× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_jump_pool: <session-dir>\finalists_top500.csv
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top100.csv
  -- Operator setup --
  accuracy_check: excellent quality
  operator_id: <operator_id>
  fit_time: 5.8 s (one-time before the sweep)
  comm_criteria: Elevation >= 10 deg within 2 h of plan time
  windows_found: 512/512 station-orbit combinations
  no_window: 0
  -- Sweep results --
  completed: 512 parameter sets
  skipped: 0
  -- How long did this take? --
  search_method: fast jump sweep
  grid_size: 512
  operator_fit: 5.8 s
  fast_sweep: 998 ms
  this_run_total: 6.8 s
  vs_full_SolvSRK_on_every_study_point: ~4.5 min for all 512 points in this study (extrapolated from 3 spot checks — not a larger search)
  speedup_vs_full_grid: ~270.2× (jump sweep vs brute estimate)
  -- Batch economics (ops week (5 re-sweeps)) --
  scenario: 5 re-sweeps x 512 points = 2,560 full integrates
  brute_srk_total: 22.5 min
  solvjump_total: 10.8 s
  marginal_re_sweep: 998 ms
  -- Act 4 - Extrapolate to cluster scale --
  -- HPC gate (ground SolvJump before you queue) --
  anchor: Measured on this laptop: 512 pts, 527 ms/pt brute, 1.9 ms/pt jump
  cluster_exploration: 100,000 scenarios (single revision)
  brute_srk_single_machine: 14.6 h
  solvjump_single_machine: 3.3 min
  design_revisions: 20 program iterations
  brute_revisions_total: 292.6 h
  solvjump_revisions_total: 1.1 h
  finalists_file: <session-dir>\finalists_ground_truth_top100.csv
  finalists_in_file: 100 ranked rows (top 500 requested)
  -- What SolvJump does for HPC (honest) --
  hpc_jobs_without_gate: 100,000 full jobs @ 0.05 core-h each = 5,000 core-hours
  hpc_jobs_with_gate: 500 finalist jobs = 25 core-hours
  core_hours_saved: 4,975 core-hours not queued (exploration on ground)
  -- Act 5 - Recommendation --
  -- Why run SolvJump here? --
  -- Why run SolvJump here? --
  -- Run complete --
  session_id: <session_id>
  results_folder: <session-dir>
  points_completed: 512 ok, 0 skipped (of 512)
  fast_sweep: 997.8 ms
  timing_sample: 1579.9 ms (3 full-SolvSRK spot checks)
  vs_full_SolvSRK_on_every_study_point: ~4.5 min for all 512 points in this study (from 3 spot checks — not a larger search)
  speedup: ~270.2× vs full SolvSRK on every grid point
  receipt_calibration: <session-dir>\calibration_receipt.json
  receipt_sweep: <session-dir>\sweep_receipt.json
  receipt_jump_pool: <session-dir>\finalists_top500.csv
  receipt_rank_verification: <session-dir>\rank_verification_report.json
  receipt_srk_shortlist: <session-dir>\srk_shortlist.csv
  receipt_finalists: <session-dir>\finalists_ground_truth_top100.csv

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/13_scale_and_hpc.py --tier quick
 
# Production one-liner — same API call you ship:
solvjump run examples/satellite_comm_study_quick.yaml

inspect_model · EvidenceStore · RankSurrogate · MFBOConfig

-- Act 1 - The rest of the public package --
  -> You have already used Session, run_study, propagate, golden, and verify_ranking. This tour names the remaining exports customers actually import. The product is CLI plus importable Python.

-- Act 2 - inspect_model --
  -> Same contract as solvjump check-model.
  model: <product-root>\python\examples\brusselator_model.py:make_rhs
  make_rhs: True
  terminal_metrics: True
  supports_ranking: True
  ok: True

-- Act 3 - EvidenceStore --
  -> Family-keyed JSONL under ~/.solvjump/evidence (SOLVJUMP_EVIDENCE_DIR). SOLVJUMP_DISABLE_EVIDENCE=1 turns it off. Journey 08 writes records; this lists them.
  family_count: 1
  -> 8a384ff3f2c515e2: 19 observation(s)

-- Act 4 - RankSurrogate, MFBOConfig, mfbo_search --
  -> Adaptive search (Journey 08) calls these internally. You can fit a theta→score map yourself. head='poly2' is numpy-only; 'gbm' needs pip install solvjump[surrogate]. mfbo_search is the low-level loop Session.sweep_adaptive wraps. Surrogate ranking is still not a client claim until you verify against SolvSRK.
  mfbo_budget_frac: 0.2
  acquisition: auto
  history_mode: auto
  available_heads: ('poly2', 'gbm', 'rf')
  mfbo_search: True
  poly2_predictions: [0.337, 1.072]

-- Act 5 - Env and leftover knobs --
  -> SOLVJUMP_LICENSE_FILE, SOLVJUMP_C_LIB, SOLVJUMP_SESSION_DIR, SOLVJUMP_QUIET, SOLVJUMP_DISABLE_CACHE, SOLVJUMP_DEV_RECEIPTS=1 (keeps diagnostic fields in receipts). Session.recalibrate() refits an operator on an existing session. That is the full customer surface: CLI plus Python Session.

-- Run complete --

cd python
# Guided tour — narrated scenario walkthrough (recommended first run):
python examples/journeys/14_advanced_python.py
 
# Production one-liner — same API call you ship:
solvjump check-model examples/brusselator_model.py:make_rhs