Upload 46 files

.gitattributes

@@ -38,3 +38,4 @@ nifty_backend/__pycache__/runtime.cpython-311.pyc filter=lfs diff=lfs merge=lfs
 backend/models/yahoo_history_cache.sqlite3 filter=lfs diff=lfs merge=lfs -text
 backend/nifty_backend/__pycache__/runtime.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 models/nifty_forecaster/__pycache__/train.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+nifty_backend/__pycache__/runtime.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

models/nifty_opening_mfe_regressor/outputs/latest_prediction.bak

@@ -0,0 +1,2 @@
+input_date,first5_start,first5_end,first5_close,predicted_up_points,predicted_down_points
+2026-06-11,2026-06-11 09:15:00,2026-06-11 09:19:00,23112.650390625,80.59007717781284,76.48054546871595

models/nifty_opening_mfe_regressor/outputs/latest_prediction.csv

@@ -1,2 +1,2 @@
 input_date,first5_start,first5_end,first5_close,predicted_up_points,predicted_down_points
-2026-06-09,2026-06-09 09:15:00,2026-06-09 09:19:00,23234.849609375,80.52086115732924,74.45651902291536
+2026-06-11,2026-06-11 09:15:00,2026-06-11 09:19:00,23112.650390625,80.59007717781284,76.48054546871592

models/nifty_opening_mfe_regressor/outputs/summary.json

@@ -1,47 +1 @@
-{
-  "target_definition": "Predict remaining same-day NIFTY upside/downside points after the first five 1-minute bars.",
-  "train_rows": 2221,
-  "valid_rows": 405,
-  "test_rows": 199,
-  "train_start": "2015-01-09",
-  "train_end": "2023-12-29",
-  "valid_start": "2024-01-01",
-  "valid_end": "2025-08-14",
-  "test_start": "2025-08-18",
-  "test_end": "2026-06-09",
-  "feature_count": 188,
-  "up": {
-    "target": "after5_up_points",
-    "selected_model": "random_forest_d6_l10_all+affine_s1.26_b-4",
-    "selected_feature_count": 188,
-    "validation_mae_points": 62.814071097341994,
-    "validation_rmse_points": 95.96458512713473,
-    "test_mae_points": 55.869403284612446,
-    "test_rmse_points": 79.459874253419,
-    "test_high_mfe_mae_points": 120.36235726321215,
-    "test_low_mfe_mae_points": 34.22747241931052,
-    "baseline_test_mae_points": 75.35728446922032,
-    "test_mae_improvement_pct": 25.860646813205825,
-    "latest_prediction_points": 63.15162391627527
-  },
-  "down": {
-    "target": "after5_down_points",
-    "selected_model": "random_forest_d7_l10_150",
-    "selected_feature_count": 150,
-    "validation_mae_points": 72.01385673724953,
-    "validation_rmse_points": 122.53041341022657,
-    "test_mae_points": 62.985231430060715,
-    "test_rmse_points": 97.51356947384825,
-    "test_high_mfe_mae_points": 141.1492761242954,
-    "test_low_mfe_mae_points": 36.75568623065309,
-    "baseline_test_mae_points": 77.89575416143268,
-    "test_mae_improvement_pct": 19.141637297035604,
-    "latest_prediction_points": 71.5788486914341
-  },
-  "latest_input_date": "2026-06-09",
-  "latest_first5_start": "2026-06-09 09:15:00",
-  "latest_first5_end": "2026-06-09 09:19:00",
-  "latest_first5_close": 23234.849609375,
-  "latest_predicted_up_points": 63.15162391627527,
-  "latest_predicted_down_points": 71.5788486914341
-}
+{"target_definition": "Predict remaining same-day NIFTY upside/downside points after the first five 1-minute bars.", "train_rows": 2221, "valid_rows": 405, "test_rows": 199, "train_start": "2015-01-09", "train_end": "2023-12-29", "valid_start": "2024-01-01", "valid_end": "2025-08-14", "test_start": "2025-08-18", "test_end": "2026-06-09", "feature_count": 188, "up": {"target": "after5_up_points", "selected_model": "random_forest_d6_l10_all+affine_s1.26_b-4", "selected_feature_count": 188, "validation_mae_points": 62.814071097341994, "validation_rmse_points": 95.96458512713473, "test_mae_points": 55.869403284612446, "test_rmse_points": 79.459874253419, "test_high_mfe_mae_points": 120.36235726321215, "test_low_mfe_mae_points": 34.22747241931052, "baseline_test_mae_points": 75.35728446922032, "test_mae_improvement_pct": 25.860646813205825, "latest_prediction_points": 63.15162391627527}, "down": {"target": "after5_down_points", "selected_model": "random_forest_d7_l10_150", "selected_feature_count": 150, "validation_mae_points": 72.01385673724953, "validation_rmse_points": 122.53041341022657, "test_mae_points": 62.985231430060715, "test_rmse_points": 97.51356947384825, "test_high_mfe_mae_points": 141.1492761242954, "test_low_mfe_mae_points": 36.75568623065309, "baseline_test_mae_points": 77.89575416143268, "test_mae_improvement_pct": 19.141637297035604, "latest_prediction_points": 71.5788486914341}, "latest_first5_start": "2026-06-09 09:15:00", "latest_first5_end": "2026-06-09 09:19:00", "latest_first5_close": 23234.849609375}

models/nifty_opening_mfe_regressor/outputs/test_predictions.bak

@@ -0,0 +1,201 @@
+date,first5_close,day_high,day_low,day_close,after5_up_points,after5_down_points,predicted_up_points,predicted_down_points
+2025-08-18,24943.3,25022.0,24852.85,24884.05,78.70000000000073,90.45000000000071,70.74537556748926,69.95608867077122
+2025-08-19,24905.95,25012.65,24873.95,24989.7,106.70000000000071,32.0,69.58622767243469,72.86841515213641
+2025-08-20,24943.7,25088.7,24929.7,25047.15,145.0,14.0,72.2215386978149,66.87535067178419
+2025-08-21,25074.4,25153.65,25054.9,25076.95,79.25,19.5,75.9678756477438,85.01325608135507
+2025-08-22,25022.5,25084.85,24859.15,24869.45,62.34999999999855,163.34999999999854,76.00333285776364,74.38421945646837
+2025-08-25,24923.8,25021.55,24894.35,24978.55,97.75,29.450000000000728,72.08624856357176,72.36965738462226
+2025-08-26,24849.75,24919.65,24689.6,24710.7,69.90000000000146,160.15000000000146,81.82237433198587,75.67181816799939
+2025-08-28,24577.25,24702.65,24481.6,24533.1,125.40000000000146,95.65000000000146,107.37349857848692,103.48101375434892
+2025-08-29,24507.4,24572.45,24404.7,24433.65,65.04999999999927,102.70000000000071,92.69929951194534,127.36320204934307
+2025-09-01,24523.5,24635.6,24432.7,24624.3,112.09999999999854,90.79999999999929,85.59277839975796,102.11100920697749
+2025-09-02,24662.9,24756.1,24522.35,24575.0,93.19999999999708,140.5500000000029,71.68120758636995,76.0402487590437
+2025-09-03,24541.0,24737.05,24533.2,24713.6,196.04999999999927,7.799999999999272,97.43911992220336,85.04967811472694
+2025-09-04,24863.8,24980.75,24708.2,24739.8,116.95000000000071,155.59999999999854,103.12730476704785,78.17111502420333
+2025-09-05,24827.5,24832.35,24621.6,24743.95,4.849999999998545,205.90000000000143,73.98230098745448,85.62699852482866
+2025-09-08,24787.65,24885.5,24751.55,24791.2,97.84999999999854,36.10000000000218,72.29944694258762,65.75039472494996
+2025-09-09,24854.2,24891.8,24814.0,24878.8,37.59999999999855,40.20000000000073,69.44370753005204,77.52099482542334
+2025-09-10,24962.65,25035.7,24915.05,24977.55,73.04999999999927,47.60000000000218,71.89450651813125,72.72213315583208
+2025-09-11,25000.8,25037.3,24940.15,25008.1,36.5,60.64999999999782,70.68275488183907,73.77386846663569
+2025-09-12,25053.3,25139.45,25038.05,25107.7,86.15000000000146,15.25,72.04701987775606,72.71521942996507
+2025-09-15,25091.4,25138.45,25048.75,25069.7,47.04999999999927,42.650000000001455,74.37466301106662,56.21764396713863
+2025-09-16,25106.75,25261.4,25070.45,25254.45,154.65000000000146,36.29999999999927,70.4334423975961,77.09468335603322
+2025-09-17,25297.05,25346.5,25275.35,25330.15,49.45000000000073,21.700000000000728,70.23690402772418,73.54908914096771
+2025-09-18,25411.2,25448.95,25329.75,25420.75,37.75,81.45000000000073,72.10814928193922,68.07462808633801
+2025-09-19,25381.45,25428.75,25286.3,25352.5,47.29999999999927,95.15000000000146,74.70715216901579,89.46626946473036
+2025-09-22,25258.55,25331.7,25151.05,25200.2,73.15000000000146,107.5,71.56191508125039,77.53793666571973
+2025-09-23,25228.05,25261.9,25084.65,25185.8,33.85000000000218,143.39999999999782,69.2148241834104,84.93267760178357
+2025-09-24,25092.3,25149.85,25027.45,25060.9,57.54999999999927,64.84999999999854,73.87437120520443,78.18656010430726
+2025-09-25,25054.4,25092.7,24878.3,24904.55,38.29999999999927,176.10000000000218,71.65598616236045,87.4073952684888
+2025-09-26,24816.0,24868.6,24629.45,24673.1,52.59999999999855,186.54999999999927,75.98342218786617,112.06060895062171
+2025-09-29,24673.7,24791.3,24606.2,24677.55,117.59999999999854,67.5,83.37538480505997,95.65712047233475
+2025-09-30,24713.65,24731.8,24587.7,24633.6,18.149999999997817,125.95000000000071,74.9517147798891,87.6251433757387
+2025-10-01,24620.5,24867.95,24605.95,24853.4,247.4500000000008,14.549999999999272,77.12668758054085,85.91485675791243
+2025-10-03,24785.05,24904.8,24747.55,24895.0,119.75,37.5,81.10550551698013,78.1100418959116
+2025-10-06,24927.05,25095.95,24881.65,25072.55,168.90000000000146,45.39999999999782,69.46213473733515,68.8959058147205
+2025-10-07,25084.9,25220.9,25076.3,25112.8,136.0,8.600000000002183,78.44188298577762,71.62453401261332
+2025-10-08,25146.05,25192.5,25008.5,25023.8,46.45000000000073,137.54999999999927,70.87032840015426,81.93097812216612
+2025-10-09,25058.95,25199.25,25024.3,25170.3,140.29999999999927,34.650000000001455,69.72385100925113,89.36013847299986
+2025-10-10,25221.2,25330.75,25156.85,25278.2,109.54999999999929,64.35000000000218,73.60123392651,77.07921283623484
+2025-10-13,25213.8,25267.3,25152.3,25237.15,53.5,61.5,72.9387780959113,71.96467174317387
+2025-10-14,25293.3,25310.35,25060.55,25123.35,17.049999999999272,232.75,69.75624962391593,75.72942009497733
+2025-10-15,25239.95,25365.15,25159.35,25327.75,125.20000000000071,80.60000000000218,79.00736543634586,89.70179097400522
+2025-10-16,25412.15,25625.4,25376.85,25566.3,213.25,35.30000000000291,69.37806626638448,75.22834036609319
+2025-10-17,25554.05,25781.5,25508.6,25704.7,227.4500000000008,45.45000000000073,70.6399534752275,82.59735724680043
+2025-10-20,25902.8,25926.2,25788.5,25850.7,23.40000000000145,114.29999999999929,82.0103286656743,71.42501744995688
+2025-10-21,25903.25,25934.35,25826.3,25833.3,31.099999999998545,76.95000000000073,70.4734596248554,72.82024209764482
+2025-10-23,26003.75,26104.2,25862.45,25870.3,100.45000000000071,141.29999999999927,78.25616002674558,75.58880300627324
+2025-10-24,25850.8,25944.15,25718.2,25797.45,93.35000000000218,132.59999999999854,85.9352895781675,84.67147328741909
+2025-10-27,25861.4,26005.95,25827.0,25974.0,144.54999999999927,34.400000000001455,49.17301873308348,61.10766648725366
+2025-10-28,25968.1,26041.7,25810.05,25965.4,73.60000000000218,158.04999999999927,72.5812143633312,85.61675283659459
+2025-10-29,25979.75,26097.85,25960.3,26068.3,118.09999999999854,19.450000000000728,75.08031314406708,79.68242908469409
+2025-10-30,25985.15,26032.05,25845.25,25891.2,46.89999999999782,139.90000000000146,73.39380876964638,74.325383761321
+2025-10-31,25862.85,25953.75,25711.2,25732.55,90.90000000000146,151.64999999999782,73.94864338763755,79.1021674617272
+2025-11-03,25687.85,25803.1,25645.5,25774.3,115.25,42.34999999999855,48.84044727691018,67.28257199135699
+2025-11-04,25755.4,25787.4,25578.4,25586.25,32.0,177.0,71.3743139533095,89.3481792230919
+2025-11-06,25666.7,25679.15,25491.55,25519.95,12.450000000000728,175.15000000000146,77.85466759246198,90.57445591555329
+2025-11-07,25378.15,25551.25,25318.45,25510.05,173.09999999999854,59.70000000000073,82.87633192312792,90.85600003629604
+2025-11-10,25554.6,25653.45,25503.5,25574.25,98.85000000000218,51.09999999999855,76.07720514892765,92.5203310121857
+2025-11-11,25544.8,25715.8,25449.25,25705.55,171.0,95.54999999999929,84.99031835536154,91.46776795888675
+2025-11-12,25807.2,25934.55,25781.15,25874.0,127.34999999999854,26.049999999999272,72.59276739431719,69.43894779255301
+2025-11-13,25843.95,26010.7,25808.4,25884.1,166.75,35.54999999999927,78.67378928776296,67.05446226149067
+2025-11-14,25810.7,25940.2,25740.8,25916.8,129.5,69.90000000000146,73.19872933440267,87.55904589996446
+2025-11-17,25951.05,26024.2,25906.35,26014.3,73.15000000000146,44.70000000000073,69.76315356672858,97.59555559580076
+2025-11-18,25947.35,26029.85,25876.5,25894.7,82.5,70.84999999999854,85.51147346645418,80.55471837004212
+2025-11-19,25857.5,26074.65,25856.2,26052.7,217.15000000000143,1.2999999999992724,80.68382090556915,94.6026325119518
+2025-11-20,26099.7,26246.65,26063.2,26197.4,146.95000000000073,36.5,70.58602673534355,77.26577489877992
+2025-11-21,26138.75,26179.2,26052.2,26063.95,40.45000000000073,86.54999999999927,72.78494759917074,88.50537506994732
+2025-11-24,26097.25,26142.8,25912.15,25943.35,45.54999999999927,185.0999999999985,71.59439136628663,98.01259127172162
+2025-11-25,25965.0,26032.6,25857.5,25860.3,67.59999999999854,107.5,74.81866080624437,97.64266493121366
+2025-11-26,25969.7,26215.15,25842.95,26203.5,245.4500000000008,126.75,90.3814582306311,86.97774096205734
+2025-11-27,26251.95,26310.45,26141.9,26219.85,58.5,110.04999999999929,71.40800619164884,75.89199618666595
+2025-11-28,26242.15,26280.75,26172.4,26204.55,38.59999999999855,69.75,72.7899189230503,68.94343157609912
+2025-12-01,26285.3,26325.8,26124.2,26175.95,40.5,161.09999999999854,70.47431107358459,75.68478873086691
+2025-12-02,26141.5,26154.6,25997.85,26057.0,13.099999999998545,143.65000000000146,74.4344525604593,86.98101762857138
+2025-12-03,26031.25,26066.45,25891.0,25985.1,35.20000000000073,140.25,70.95415206130762,80.43735765423229
+2025-12-04,25949.55,26098.25,25938.95,26017.1,148.70000000000073,10.599999999998545,70.73708673203622,80.01080718413094
+2025-12-05,26051.05,26202.6,25985.35,26176.65,151.54999999999927,65.70000000000073,72.41683194442193,96.03195181892916
+2025-12-08,26159.7,26178.7,25892.25,25932.8,19.0,267.4500000000007,69.67299117722322,81.02444831648698
+2025-12-09,25819.8,25923.65,25728.0,25841.75,103.85000000000218,91.79999999999929,77.47469251817466,95.02942758445396
+2025-12-10,25880.55,25947.65,25734.55,25742.65,67.10000000000218,146.0,71.70553491482723,98.1837081927547
+2025-12-11,25757.1,25922.8,25693.25,25898.4,165.70000000000073,63.84999999999855,76.56354511911341,101.94574105996686
+2025-12-12,26002.55,26057.6,25938.45,26043.0,55.04999999999927,64.09999999999854,69.67619298888475,79.50154765698446
+2025-12-15,25953.3,26047.15,25904.75,26014.0,93.85000000000218,48.54999999999927,75.17828185471886,76.85009428534134
+2025-12-16,25943.3,25980.75,25834.35,25851.35,37.45000000000073,108.95000000000071,71.27112421993293,81.85242825234664
+2025-12-17,25872.6,25929.15,25770.35,25821.8,56.55000000000291,102.25,72.35835339450391,87.43541006469988
+2025-12-18,25777.75,25902.35,25726.3,25815.65,124.59999999999854,51.45000000000073,74.43183502860306,85.33298803694375
+2025-12-19,25925.1,25993.35,25880.45,25961.4,68.25,44.64999999999782,70.77069567565373,83.78604666129061
+2025-12-22,26093.9,26180.7,26047.8,26162.75,86.79999999999927,46.10000000000218,70.42228403925822,72.76339644091539
+2025-12-23,26166.7,26233.55,26119.05,26165.95,66.84999999999854,47.650000000001455,74.84971589574519,69.426936900949
+2025-12-24,26198.25,26236.4,26123.0,26141.65,38.150000000001455,75.25,71.48754603427759,73.72186108153664
+2025-12-26,26131.05,26144.2,26008.6,26047.65,13.150000000001455,122.45000000000071,45.48128688932305,57.062560579537895
+2025-12-29,26050.5,26106.8,25920.3,25949.8,56.29999999999927,130.20000000000073,75.70015606822022,78.00564702749449
+2025-12-30,25908.05,25976.75,25878.0,25970.55,68.70000000000073,30.049999999999272,75.2522086126314,77.13518357533343
+2025-12-31,26013.65,26187.95,25969.0,26141.85,174.29999999999927,44.650000000001455,73.24189431613242,73.79354269787787
+2026-01-01,26167.8,26197.55,26113.4,26140.25,29.75,54.39999999999782,71.71010503029348,73.54519160205173
+2026-01-02,26181.65,26340.0,26118.4,26335.7,158.34999999999854,63.25,45.480429907888656,57.12647950293099
+2026-01-05,26340.25,26373.2,26210.05,26244.65,32.95000000000073,130.20000000000073,70.46179801639443,81.45276466292157
+2026-01-06,26195.8,26273.95,26124.75,26174.65,78.15000000000146,71.04999999999927,79.36914045104106,92.38591642666192
+2026-01-07,26125.65,26187.15,26067.9,26142.9,61.5,57.75,72.55581417361594,83.15694141096833
+2026-01-08,26123.25,26133.2,25858.45,25868.9,9.950000000000728,264.7999999999993,71.04783101366327,82.46291134118252
+2026-01-09,25938.8,25940.6,25623.0,25703.7,1.7999999999992724,315.7999999999993,86.53974081668476,121.44759821661056
+2026-01-12,25611.95,25813.15,25473.4,25806.1,201.2000000000008,138.54999999999927,83.95949739270267,120.28936873981168
+2026-01-13,25846.25,25899.8,25603.3,25714.2,53.54999999999927,242.9500000000008,78.19680117941645,84.9829292741713
+2026-01-14,25683.25,25791.75,25603.95,25669.1,108.5,79.29999999999927,82.35604656222411,99.82529425771892
+2026-01-16,25730.45,25873.5,25662.4,25701.9,143.04999999999927,68.04999999999927,72.2288158291699,96.07795888190776
+2026-01-19,25597.4,25653.3,25494.35,25555.5,55.89999999999782,103.05000000000292,93.52077464705306,93.8292063036645
+2026-01-20,25558.25,25585.0,25171.35,25225.35,26.75,386.9000000000015,76.71942144430174,79.78554817218038
+2026-01-21,25242.4,25300.95,24919.8,25168.1,58.54999999999927,322.6000000000022,130.94997110273525,147.75173361890398
+2026-01-22,25318.0,25435.75,25168.5,25320.45,117.75,149.5,85.07263391734676,130.19406357107007
+2026-01-23,25275.3,25347.95,25025.3,25064.75,72.65000000000146,250.0,86.95616205286174,98.93004959582946
+2026-01-27,25009.95,25246.65,24932.55,25234.1,236.7000000000008,77.40000000000146,110.68260525851476,129.7114495843547
+2026-01-28,25336.3,25372.1,25187.65,25348.05,35.79999999999927,148.64999999999782,89.71179240489799,109.83708610878163
+2026-01-29,25280.55,25458.15,25159.8,25422.1,177.60000000000218,120.75,91.59350021026472,87.43822382386271
+2026-01-30,25259.3,25370.7,25213.65,25315.8,111.40000000000146,45.64999999999782,79.05064818970524,100.1312421862931
+2026-02-01,25282.8,25440.9,24571.75,24768.0,158.10000000000218,711.0499999999993,80.05582527903351,87.1593675112166
+2026-02-02,24806.35,25108.1,24679.4,25079.9,301.75,126.94999999999708,86.6858901745076,81.9244305205442
+2026-02-03,25809.75,26341.2,25641.3,25714.8,531.4500000000007,168.45000000000073,209.3466476279516,140.6950158750343
+2026-02-04,25710.7,25818.55,25563.95,25737.5,107.84999999999854,146.75,123.34674640202677,112.15100241628755
+2026-02-05,25727.35,25757.65,25579.5,25641.6,30.30000000000291,147.84999999999854,78.92667069768866,93.48294833342888
+2026-02-06,25603.5,25703.95,25491.9,25673.6,100.45000000000071,111.59999999999854,81.63730431628646,108.84971109953882
+2026-02-09,25815.55,25922.25,25780.9,25863.3,106.70000000000071,34.64999999999782,97.04614278500875,83.38428889831818
+2026-02-10,25918.05,25989.45,25870.45,25916.8,71.40000000000146,47.59999999999855,72.55379470719815,80.47042331164333
+2026-02-11,25985.0,26009.4,25899.8,25945.35,24.40000000000145,85.20000000000073,70.82761961162062,78.822407881009
+2026-02-12,25855.25,25906.7,25752.4,25796.15,51.45000000000073,102.84999999999854,74.42962687752149,69.6320381757916
+2026-02-13,25596.4,25630.35,25444.3,25460.55,33.94999999999709,152.10000000000218,78.73111917226437,92.65335041306253
+2026-02-16,25472.2,25697.0,25372.7,25682.45,224.79999999999927,99.5,87.51077339277226,135.77441133340997
+2026-02-17,25612.45,25764.4,25570.3,25716.0,151.95000000000073,42.150000000001455,74.20532764340571,70.59556735334088
+2026-02-18,25742.05,25828.05,25645.15,25805.7,86.0,96.89999999999782,69.60174388514015,87.14731231617911
+2026-02-19,25853.9,25885.3,25388.75,25416.45,31.399999999997817,465.1500000000015,72.82233481769892,77.47993082146262
+2026-02-20,25452.9,25663.55,25379.75,25565.9,210.64999999999785,73.15000000000146,101.23325383545428,120.39677579437908
+2026-02-23,25698.35,25771.45,25609.35,25704.0,73.10000000000218,89.0,78.13994225569839,102.6805412273098
+2026-02-24,25570.55,25641.8,25327.6,25460.25,71.25,242.9500000000008,84.66998953575761,78.35520991871599
+2026-02-25,25561.8,25652.6,25428.2,25478.65,90.79999999999929,133.59999999999854,78.48076576983638,96.14961930214676
+2026-02-26,25535.1,25572.95,25400.95,25493.3,37.85000000000218,134.14999999999782,73.42761359209224,92.16432309346206
+2026-02-27,25395.4,25476.4,25141.3,25181.8,81.0,254.10000000000213,84.86928109002694,89.3313420570492
+2026-03-02,24892.95,24989.35,24603.5,24849.75,96.39999999999782,289.4500000000007,111.27759797579716,107.15701801512222
+2026-03-04,24385.1,24602.45,24305.4,24473.95,217.35000000000213,79.69999999999709,133.72126269580576,155.30789682765342
+2026-03-05,24584.85,24854.2,24529.4,24737.45,269.3500000000022,55.44999999999709,162.08234784984276,162.40605803165704
+2026-03-06,24594.4,24700.9,24415.75,24469.4,106.5,178.65000000000146,117.98380433944612,116.83602544783804
+2026-03-09,23774.35,24078.15,23697.8,24005.8,303.8000000000029,76.54999999999927,192.3591586795632,146.88020524223515
+2026-03-10,24149.0,24303.8,24079.95,24286.15,154.79999999999927,69.04999999999927,192.7937738097792,158.9186209194774
+2026-03-11,24285.9,24299.0,23834.3,23848.2,13.099999999998545,451.6000000000022,133.54653076939334,121.19414544015564
+2026-03-12,23563.15,23833.15,23556.3,23639.35,270.0,6.850000000002183,192.6358883055884,120.53074403063889
+2026-03-13,23450.25,23492.4,23112.0,23170.9,42.150000000001455,338.25,145.7091162926563,146.68104013479658
+2026-03-16,23172.55,23502.0,22955.25,23355.6,329.4500000000007,217.29999999999927,170.38500881814582,207.8442210393264
+2026-03-17,23395.55,23656.8,23346.6,23558.8,261.25,48.95000000000073,156.7943098659703,149.21233378254283
+2026-03-18,23721.9,23862.25,23618.45,23764.1,140.34999999999854,103.45000000000071,121.95109115304878,116.42727703008954
+2026-03-19,23289.5,23378.7,22930.35,23087.85,89.20000000000073,359.15000000000146,133.90428933906327,137.31867907141643
+2026-03-20,23281.5,23345.15,23067.6,23134.65,63.650000000001455,213.90000000000143,159.7676630786322,165.0265464253639
+2026-03-23,22687.45,22851.7,22471.25,22492.65,164.25,216.2000000000008,145.85353407241462,152.4341252582677
+2026-03-24,22785.15,23057.3,22624.2,22958.4,272.1499999999978,160.95000000000073,207.01095264874107,154.6488830452536
+2026-03-25,23162.6,23465.35,23063.2,23309.0,302.75,99.39999999999782,132.30015580160267,124.7102392167061
+2026-03-27,23041.8,23186.1,22804.55,22839.5,144.29999999999927,237.25,138.49642324859562,132.77812683059364
+2026-03-30,22522.45,22714.1,22283.85,22379.2,191.64999999999785,238.60000000000213,137.43517166951938,113.26298404384518
+2026-04-01,22887.0,22941.3,22618.6,22703.15,54.29999999999927,268.40000000000146,171.94720651853035,142.51587723198915
+2026-04-02,22228.0,22782.3,22182.55,22700.7,554.2999999999993,45.45000000000073,157.50885517232763,135.03847736028655
+2026-04-06,22666.05,22998.35,22542.95,22959.45,332.2999999999993,123.09999999999854,144.97157821899438,110.86736478379764
+2026-04-07,22773.05,23153.85,22719.3,23129.95,380.7999999999993,53.75,111.3757230804756,120.98351003129396
+2026-04-08,23899.95,23961.25,23837.65,23892.75,61.29999999999927,62.29999999999927,102.2801592496814,103.1134383545202
+2026-04-09,23935.650390625,23989.75,23683.349609375,23766.05078125,54.099609375,252.30078125,97.56128839578804,120.80458797190984
+2026-04-10,23965.69921875,24073.80078125,23867.19921875,24051.80078125,108.1015625,98.5,85.23780890426106,116.17509968142504
+2026-04-13,23578.55078125,23905.650390625,23556.150390625,23818.900390625,327.099609375,22.400390625,101.5126595166479,98.57767387007569
+2026-04-15,24230.849609375,24273.150390625,24146.69921875,24211.900390625,42.30078125,84.150390625,87.99325993978478,100.5389864062017
+2026-04-16,24390.55078125,24400.099609375,24103.099609375,24188.400390625,9.548828125,287.451171875,75.10031206149125,96.78284688386456
+2026-04-17,24207.55078125,24370.25,24109.44921875,24366.900390625,162.69921875,98.1015625,93.875672724558,113.6195855929118
+2026-04-20,24373.099609375,24394.05078125,24318.0,24330.900390625,20.951171875,55.099609375,74.03118715657969,70.17966380671794
+2026-04-21,24468.849609375,24600.849609375,24357.150390625,24581.05078125,132.0,111.69921875,86.20844571936449,102.2667119048698
+2026-04-22,24479.30078125,24515.75,24353.69921875,24367.650390625,36.44921875,125.6015625,78.71803618671171,105.18692808784276
+2026-04-23,24201.349609375,24309.900390625,24138.849609375,24156.05078125,108.55078125,62.5,84.05594012758098,99.00734685037855
+2026-04-24,24124.19921875,24203.349609375,23815.349609375,23903.94921875,79.150390625,308.849609375,90.14180250621698,136.87579336691633
+2026-04-27,24020.349609375,24130.30078125,23952.0,24110.19921875,109.951171875,68.349609375,99.59614157374158,118.31424726361335
+2026-04-28,24093.849609375,24181.75,23958.05078125,24016.5,87.900390625,135.798828125,88.15968826749,106.64812371296172
+2026-04-29,24090.80078125,24334.19921875,24060.650390625,24163.599609375,243.3984375,30.150390625,87.90088049432329,124.95795081910784
+2026-04-30,23945.25,24086.94921875,23797.05078125,23997.55078125,141.69921875,148.19921875,139.48308205556245,111.61338896287434
+2026-05-04,24177.05078125,24289.19921875,24005.30078125,24119.30078125,112.1484375,171.75,147.62463980491148,110.82979739572832
+2026-05-05,24064.19921875,24080.94921875,23883.5,24032.80078125,16.75,180.69921875,104.19136737845044,118.00286130314204
+2026-05-06,24175.80078125,24355.55078125,23999.0,24330.94921875,179.75,176.80078125,89.34877716071158,100.09239323156596
+2026-05-07,24318.25,24481.94921875,24284.650390625,24326.650390625,163.69921875,33.599609375,144.18742265088838,101.03766931638432
+2026-05-08,24219.30078125,24253.44921875,24127.69921875,24176.150390625,34.1484375,91.6015625,113.44501924079982,105.61263750990524
+2026-05-11,23918.75,23997.0,23801.25,23820.349609375,78.25,117.5,115.09320335959804,89.86773115957116
+2026-05-12,23736.900390625,23754.150390625,23349.099609375,23430.55078125,17.25,387.80078125,116.96920740241298,142.73344731125428
+2026-05-13,23405.400390625,23582.80078125,23263.05078125,23428.69921875,177.400390625,142.349609375,175.97531700031948,150.41964833343525
+2026-05-14,23550.05078125,23776.650390625,23426.849609375,23713.75,226.599609375,123.201171875,172.47993492418186,120.64942388533476
+2026-05-15,23718.900390625,23838.94921875,23610.80078125,23643.5,120.048828125,108.099609375,116.92088358715652,117.22659612227842
+2026-05-18,23400.5,23695.400390625,23317.55078125,23644.44921875,294.900390625,82.94921875,122.25057682854032,99.44379095807834
+2026-05-19,23735.099609375,23782.19921875,23587.25,23606.150390625,47.099609375,147.849609375,89.25678651875887,118.2088244294284
+2026-05-20,23460.650390625,23690.75,23403.75,23664.349609375,230.099609375,56.900390625,90.6801349163642,107.62981114189007
+2026-05-21,23766.849609375,23859.150390625,23596.849609375,23654.69921875,92.30078125,170.0,143.97390699531186,119.33033220862224
+2026-05-22,23693.5,23835.599609375,23675.349609375,23748.849609375,142.099609375,18.150390625,110.3358336575918,101.93356091893207
+2026-05-25,23967.599609375,24054.400390625,23924.400390625,24049.900390625,86.80078125,43.19921875,94.48529797429144,78.70386364984326
+2026-05-26,24012.55078125,24089.55078125,23885.44921875,23933.75,77.0,127.1015625,79.73076033164853,83.18524021655392
+2026-05-27,23926.349609375,23983.0,23858.55078125,23907.150390625,56.650390625,67.798828125,82.86160430091547,111.90618562168372
+2026-05-29,23963.30078125,23998.69921875,23486.599609375,23547.75,35.3984375,476.701171875,103.19623464475224,101.30160095874687
+2026-06-01,23633.0,23727.650390625,23358.150390625,23379.19921875,94.650390625,274.849609375,147.97873066706777,108.07717150797622
+2026-06-02,23283.19921875,23556.599609375,23229.150390625,23520.69921875,273.400390625,54.048828125,104.11710291744272,127.52289995410068
+2026-06-03,23299.30078125,23459.349609375,23152.150390625,23396.94921875,160.048828125,147.150390625,119.81095584527132,121.31295450722716
+2026-06-04,23345.900390625,23465.150390625,23249.599609375,23416.55078125,119.25,96.30078125,96.4568581173244,123.15485148279662
+2026-06-05,23456.150390625,23513.650390625,23282.80078125,23366.69921875,57.5,173.349609375,113.41119571155151,102.86641440643322
+2026-06-08,23130.55078125,23266.849609375,23071.5,23123.0,136.298828125,59.05078125,71.99673733444993,66.32122469457533
+2026-06-09,23234.849609375,,,,,,80.52086115732924,74.45651902291536
+2026-06-11,23112.650390625,,,,,,80.59007717781284,76.48054546871595

models/yahoo_history_cache.sqlite3

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:21c414a1f381f1970bf5c16e017a922f17fe6c4ebcb88a15b67d7a192559a4ec
-size 319488
+oid sha256:75c3f55a2adee670c10dbadd1c998d3ce773ed067c8e196ed2c7539ca6f8eb87
+size 397312

nifty_backend/__pycache__/runtime.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eac2a9d465d264f6ebb982a4f2b7fbd61ef4db81c5a3549543b07cb103b8d680
+size 138158

nifty_backend/__pycache__/runtime.cpython-312.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:577bb7a5580d51f89125710300b1fb2c2da89613a7053c0c689494052442b6ef
+size 107926

nifty_backend/runtime.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-import json
-import copy
-import os
-import sys
-import threading
+import json
+import copy
+import os
+import sys
+import threading
 from dataclasses import dataclass
 from datetime import date, datetime, time, timedelta
 from functools import lru_cache
@@ -12,10 +12,10 @@ from pathlib import Path
 from typing import Any
 from zoneinfo import ZoneInfo
 
-import joblib
-import numpy as np
-import pandas as pd
-from nifty_backend.yahoo_history_client import YahooHistoryClient
+import joblib
+import numpy as np
+import pandas as pd
+from nifty_backend.yahoo_history_client import YahooHistoryClient
 
 try:
     import pandas_market_calendars as mcal
@@ -24,16 +24,16 @@ except ImportError:  # pragma: no cover - production dependency, local fallback
 
 
 IST = ZoneInfo("Asia/Kolkata")
-YAHOO_NIFTY_SYMBOL = "^NSEI"
-MARKET_CLOSE = time(15, 30)
-FIRST5_READY = time(9, 20)
-CLOSE_REFRESH_READY = time(15, 45)
-TPLUS1_READY = time(14, 30)
-STALE_CHECK_INTERVAL_SECONDS = 5
-BACKEND_ROOT = Path(__file__).resolve().parents[1]
-DATA_DIR = BACKEND_ROOT / "data"
-MODEL_DIR = BACKEND_ROOT / "models"
-YAHOO_CACHE_PATH = MODEL_DIR / "yahoo_history_cache.sqlite3"
+YAHOO_NIFTY_SYMBOL = "^NSEI"
+MARKET_CLOSE = time(15, 30)
+FIRST5_READY = time(9, 20)
+CLOSE_REFRESH_READY = time(15, 45)
+TPLUS1_READY = time(14, 30)
+STALE_CHECK_INTERVAL_SECONDS = 5
+BACKEND_ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = BACKEND_ROOT / "data"
+MODEL_DIR = BACKEND_ROOT / "models"
+YAHOO_CACHE_PATH = MODEL_DIR / "yahoo_history_cache.sqlite3"
 OPENING_DATASET_PATH = DATA_DIR / "opening_direction_training_dataset.parquet"
 NIFTY_1M_PATH = DATA_DIR / "nifty50_1m.parquet"
 NIFTY_1D_PATH = DATA_DIR / "nifty50_1d.parquet"
@@ -43,21 +43,29 @@ TEST_PREDICTIONS_PATH = DATA_DIR / "test_predictions.parquet"
 TOMORROW_MODEL_PATH = MODEL_DIR / "nifty_tomorrow_direction_model.joblib"
 TOMORROW_LATEST_PATH = MODEL_DIR / "tomorrow_latest_prediction.csv"
 TOMORROW_SUMMARY_PATH = MODEL_DIR / "tomorrow_summary.json"
-TOMORROW_TEST_PREDICTIONS_PATH = DATA_DIR / "tomorrow_test_predictions.parquet"
-FORECASTING_PROJECT_ROOT = Path(
-    os.environ.get(
-        "FORECASTING_PROJECT_ROOT",
-        str(BACKEND_ROOT.parent.parent / "forecasting project"),
-    )
-)
-DAILY_FORECASTER_OUTPUT_DIR = FORECASTING_PROJECT_ROOT / "Code" / "models" / "nifty_forecaster" / "outputs"
-DAILY_FORECASTER_SUMMARY_PATH = DAILY_FORECASTER_OUTPUT_DIR / "forecaster_summary.json"
-DAILY_FORECASTER_LATEST_PATH = DAILY_FORECASTER_OUTPUT_DIR / "forecaster_latest.csv"
-DAILY_FORECASTER_PREDICTIONS_PATH = DAILY_FORECASTER_OUTPUT_DIR / "forecaster_test_predictions.csv"
-TPLUS1_MODEL_PATH = MODEL_DIR / "nifty_1420_tplus1_logistic_model.joblib"
+TOMORROW_TEST_PREDICTIONS_PATH = DATA_DIR / "tomorrow_test_predictions.parquet"
+TOMORROW_PREDICTION_HISTORY_PATH = MODEL_DIR / "tomorrow_prediction_history.parquet"
+FORECASTING_PROJECT_ROOT = Path(
+    os.environ.get(
+        "FORECASTING_PROJECT_ROOT",
+        str(BACKEND_ROOT.parent.parent / "forecasting project"),
+    )
+)
+DAILY_FORECASTER_OUTPUT_DIR = MODEL_DIR / "nifty_forecaster" / "outputs"
+DAILY_FORECASTER_SUMMARY_PATH = DAILY_FORECASTER_OUTPUT_DIR / "forecaster_summary.json"
+DAILY_FORECASTER_LATEST_PATH = DAILY_FORECASTER_OUTPUT_DIR / "forecaster_latest.csv"
+DAILY_FORECASTER_PREDICTIONS_PATH = DAILY_FORECASTER_OUTPUT_DIR / "forecaster_test_predictions.csv"
+MFE_SOURCE_OUTPUT_DIR = FORECASTING_PROJECT_ROOT / "Code" / "models" / "nifty_opening_mfe_regressor" / "outputs"
+MFE_OUTPUT_DIR = MODEL_DIR / "nifty_opening_mfe_regressor" / "outputs"
+MFE_SUMMARY_PATH = MFE_OUTPUT_DIR / "summary.json"
+MFE_LATEST_PATH = MFE_OUTPUT_DIR / "latest_prediction.csv"
+MFE_TEST_PREDICTIONS_PATH = MFE_OUTPUT_DIR / "test_predictions.csv"
+TPLUS1_MODEL_PATH = MODEL_DIR / "nifty_1420_tplus1_logistic_model.joblib"
 TPLUS1_LATEST_PATH = MODEL_DIR / "tplus1_latest_prediction.csv"
 TPLUS1_SUMMARY_PATH = MODEL_DIR / "tplus1_summary.json"
 TPLUS1_TEST_PREDICTIONS_PATH = DATA_DIR / "tplus1_test_predictions.parquet"
+TPLUS1_PREDICTION_HISTORY_PATH = MODEL_DIR / "tplus1_prediction_history.parquet"
+T5_PREDICTION_HISTORY_PATH = MODEL_DIR / "t5_prediction_history.parquet"
 REFRESH_STATE_PATH = MODEL_DIR / "refresh_state.json"
 REFRESH_WAITING = "waiting_second_payload"
 REFRESH_REFRESHING = "refreshing"
@@ -81,8 +89,8 @@ DECISION_OVERLAYS = [
     },
 ]
 
-_dashboard_payload_lock = threading.Lock()
-_stale_refresh_lock = threading.Lock()
+_dashboard_payload_lock = threading.Lock()
+_stale_refresh_lock = threading.Lock()
 
 
 def utc_now_iso() -> str:
@@ -179,6 +187,31 @@ def previous_trading_day(start: date) -> date:
     return pd.Timestamp(schedule.index[-1]).date()
 
 
+def last_n_trading_sessions(end_day: date, count: int) -> list[date]:
+    """Return the last ``count`` NSE sessions ending on (or before) ``end_day``."""
+    sessions: list[date] = []
+    cursor = end_day
+    guard = 0
+    while len(sessions) < count and guard < count * 12:
+        guard += 1
+        if is_trading_day(cursor):
+            sessions.append(cursor)
+        if len(sessions) >= count:
+            break
+        cursor = previous_trading_day(cursor - timedelta(days=1))
+    sessions.reverse()
+    return sessions
+
+
+def _track_record_end_session(now: datetime | None = None) -> date:
+    """Latest session the track record should score (today after the close refresh window)."""
+    now = now or datetime.now(IST)
+    today = now.date()
+    if is_trading_day(today) and now.time() >= CLOSE_REFRESH_READY:
+        return today
+    return expected_completed_daily_date(now)
+
+
 class ProbabilityBlend:
     def __init__(self, models: list[Any], weights: np.ndarray):
         self.models = models
@@ -278,7 +311,7 @@ def read_training_dataset() -> pd.DataFrame:
     return df.sort_values("date").reset_index(drop=True)
 
 
-def normalize_yahoo_frame(df: pd.DataFrame) -> pd.DataFrame:
+def normalize_yahoo_frame(df: pd.DataFrame) -> pd.DataFrame:
     if df.empty:
         return pd.DataFrame(columns=["date", "open", "high", "low", "close", "volume"])
     if isinstance(df.columns, pd.MultiIndex):
@@ -304,81 +337,81 @@ def normalize_yahoo_frame(df: pd.DataFrame) -> pd.DataFrame:
     for src, dst in rename.items():
         if src in df.columns and dst not in out.columns:
             out[dst] = pd.to_numeric(df[src], errors="coerce")
-    return out.dropna(subset=["date", "open", "high", "low", "close"]).sort_values("date")
-
-
-@lru_cache(maxsize=1)
-def yahoo_history_client() -> YahooHistoryClient:
-    return YahooHistoryClient(cache_path=YAHOO_CACHE_PATH)
-
-
-def period_start(period: str, *, end: datetime) -> datetime:
-    text = str(period).strip().lower()
-    units = {
-        "d": "days",
-        "wk": "weeks",
-        "mo": "months",
-        "y": "years",
-    }
-    for suffix, unit in units.items():
-        if text.endswith(suffix):
-            raw_value = text[: -len(suffix)]
-            if not raw_value.isdigit():
-                break
-            value = int(raw_value)
-            if unit == "days":
-                return end - timedelta(days=value)
-            if unit == "weeks":
-                return end - timedelta(weeks=value)
-            if unit == "months":
-                return end - timedelta(days=value * 31)
-            if unit == "years":
-                return end - timedelta(days=value * 366)
-    raise ValueError(f"Unsupported Yahoo period: {period!r}")
-
-
-def yahoo_history_to_ohlcv(frame: pd.DataFrame, *, daily: bool) -> pd.DataFrame:
-    if frame.empty:
-        return pd.DataFrame(columns=["date", "open", "high", "low", "close", "volume"])
-    out = frame.rename(columns={"timestamp": "date"}).copy()
-    out["date"] = pd.to_datetime(out["date"], errors="coerce")
-    if daily:
-        out["date"] = out["date"].dt.normalize()
-    for column in ("open", "high", "low", "close", "volume"):
-        out[column] = pd.to_numeric(out[column], errors="coerce")
-    return (
-        out[["date", "open", "high", "low", "close", "volume"]]
-        .dropna(subset=["date", "open", "high", "low", "close"])
-        .drop_duplicates("date", keep="last")
-        .sort_values("date")
-        .reset_index(drop=True)
-    )
-
-
-def fetch_yahoo_minutes(period: str = "5d") -> pd.DataFrame:
-    end = datetime.now(IST).replace(tzinfo=None) + timedelta(minutes=5)
-    start = period_start(period, end=end)
-    raw = yahoo_history_client().fetch_history(
-        YAHOO_NIFTY_SYMBOL,
-        interval="1m",
-        start=start,
-        end=end,
-        include_prepost=False,
-    )
-    return yahoo_history_to_ohlcv(raw, daily=False)
-
-
-def fetch_yahoo_daily(period: str = "1mo") -> pd.DataFrame:
-    end = datetime.now(IST).replace(tzinfo=None) + timedelta(days=1)
-    start = period_start(period, end=end)
-    raw = yahoo_history_client().fetch_history(
-        YAHOO_NIFTY_SYMBOL,
-        interval="1d",
-        start=start,
-        end=end,
-        include_prepost=False,
-    )
-    return yahoo_history_to_ohlcv(raw, daily=True)
+    return out.dropna(subset=["date", "open", "high", "low", "close"]).sort_values("date")
+
+
+@lru_cache(maxsize=1)
+def yahoo_history_client() -> YahooHistoryClient:
+    return YahooHistoryClient(cache_path=YAHOO_CACHE_PATH)
+
+
+def period_start(period: str, *, end: datetime) -> datetime:
+    text = str(period).strip().lower()
+    units = {
+        "d": "days",
+        "wk": "weeks",
+        "mo": "months",
+        "y": "years",
+    }
+    for suffix, unit in units.items():
+        if text.endswith(suffix):
+            raw_value = text[: -len(suffix)]
+            if not raw_value.isdigit():
+                break
+            value = int(raw_value)
+            if unit == "days":
+                return end - timedelta(days=value)
+            if unit == "weeks":
+                return end - timedelta(weeks=value)
+            if unit == "months":
+                return end - timedelta(days=value * 31)
+            if unit == "years":
+                return end - timedelta(days=value * 366)
+    raise ValueError(f"Unsupported Yahoo period: {period!r}")
+
+
+def yahoo_history_to_ohlcv(frame: pd.DataFrame, *, daily: bool) -> pd.DataFrame:
+    if frame.empty:
+        return pd.DataFrame(columns=["date", "open", "high", "low", "close", "volume"])
+    out = frame.rename(columns={"timestamp": "date"}).copy()
+    out["date"] = pd.to_datetime(out["date"], errors="coerce")
+    if daily:
+        out["date"] = out["date"].dt.normalize()
+    for column in ("open", "high", "low", "close", "volume"):
+        out[column] = pd.to_numeric(out[column], errors="coerce")
+    return (
+        out[["date", "open", "high", "low", "close", "volume"]]
+        .dropna(subset=["date", "open", "high", "low", "close"])
+        .drop_duplicates("date", keep="last")
+        .sort_values("date")
+        .reset_index(drop=True)
+    )
+
+
+def fetch_yahoo_minutes(period: str = "5d") -> pd.DataFrame:
+    end = datetime.now(IST).replace(tzinfo=None) + timedelta(minutes=5)
+    start = period_start(period, end=end)
+    raw = yahoo_history_client().fetch_history(
+        YAHOO_NIFTY_SYMBOL,
+        interval="1m",
+        start=start,
+        end=end,
+        include_prepost=False,
+    )
+    return yahoo_history_to_ohlcv(raw, daily=False)
+
+
+def fetch_yahoo_daily(period: str = "1mo") -> pd.DataFrame:
+    end = datetime.now(IST).replace(tzinfo=None) + timedelta(days=1)
+    start = period_start(period, end=end)
+    raw = yahoo_history_client().fetch_history(
+        YAHOO_NIFTY_SYMBOL,
+        interval="1d",
+        start=start,
+        end=end,
+        include_prepost=False,
+    )
+    return yahoo_history_to_ohlcv(raw, daily=True)
 
 
 def append_parquet_rows(path: Path, new_rows: pd.DataFrame, subset: list[str]) -> pd.DataFrame:
@@ -396,6 +429,11 @@ def append_parquet_rows(path: Path, new_rows: pd.DataFrame, subset: list[str]) -
     return combined
 
 
+def append_prediction_history(path: Path, row: dict[str, Any], subset: list[str]) -> pd.DataFrame:
+    frame = pd.DataFrame([row])
+    return append_parquet_rows(path, frame, subset)
+
+
 def latest_parquet_date(path: Path) -> date | None:
     if not path.exists():
         return None
@@ -527,6 +565,15 @@ def predict_row(row: pd.DataFrame) -> Prediction:
         is_overridden=is_overridden,
     )
     pd.DataFrame([prediction.to_dict()]).to_csv(LATEST_PATH, index=False)
+    _record_prediction_history(
+        T5_PREDICTION_HISTORY_PATH,
+        {
+            **prediction.to_dict(),
+            "target_date": prediction.input_date,
+            "source": "live",
+        },
+        ["target_date"],
+    )
     return prediction
 
 
@@ -553,125 +600,239 @@ def latest_saved_prediction() -> dict[str, Any]:
     return dict(_latest_saved_prediction_cached(_file_cache_key(LATEST_PATH), _file_cache_key(MODEL_DIR / "summary.json")))
 
 
-def _latest_saved_prediction_uncached() -> dict[str, Any]:
+def _latest_saved_prediction_uncached() -> dict[str, Any]:
     if LATEST_PATH.exists():
         return pd.read_csv(LATEST_PATH).iloc[-1].to_dict()
     summary_path = MODEL_DIR / "summary.json"
     if summary_path.exists():
         return json.loads(summary_path.read_text(encoding="utf-8"))
-    raise FileNotFoundError("No latest prediction is available yet.")
-
-
-def _read_daily_forecaster_summary() -> dict[str, Any] | None:
-    if not DAILY_FORECASTER_SUMMARY_PATH.exists():
-        return None
-    raw = json.loads(DAILY_FORECASTER_SUMMARY_PATH.read_text(encoding="utf-8"))
-    if isinstance(raw, list):
-        matches = [row for row in raw if row.get("symbol") == "NIFTY 50"]
-        summary = dict(matches[0] if matches else raw[0])
-    elif isinstance(raw, dict):
-        summary = dict(raw)
-    else:
-        return None
-    config = summary.get("config") if isinstance(summary.get("config"), dict) else {}
-    summary.setdefault("symbol", "NIFTY 50")
-    summary.setdefault("horizon", "daily")
-    summary.setdefault("horizon_bars", 1)
-    summary["model_name"] = "nifty_tomorrow_direction_model"
-    summary["source_model"] = str(config.get("name") or summary.get("source_model") or "locked_multiwindow_nifty50_ensemble")
-    summary["target"] = "next trading session NIFTY 50 direction"
-    summary["artifact_type"] = "daily_forecaster_outputs"
-    summary["artifact_source"] = str(DAILY_FORECASTER_OUTPUT_DIR)
-    return summary
-
-
-def _read_daily_forecaster_latest(summary: dict[str, Any]) -> dict[str, Any] | None:
-    if not DAILY_FORECASTER_LATEST_PATH.exists():
-        return None
-    latest = pd.read_csv(DAILY_FORECASTER_LATEST_PATH)
-    if latest.empty:
-        return None
-    if "symbol" in latest.columns:
-        filtered = latest[latest["symbol"].astype(str) == "NIFTY 50"]
-        if not filtered.empty:
-            latest = filtered
-    row = {k: (None if pd.isna(v) else v) for k, v in latest.iloc[-1].to_dict().items()}
-    input_date = row.get("latest_forecast_date") or row.get("input_date")
-    target_date = row.get("target_date")
-    if not target_date and input_date:
-        try:
-            target_date = next_trading_day(date.fromisoformat(str(input_date)[:10]) + timedelta(days=1)).isoformat()
-        except Exception:
-            target_date = None
-    prob_up = row.get("latest_forecast_prob_up", row.get("prob_up"))
-    prediction = row.get("latest_forecast_signal", row.get("prediction"))
-    threshold = row.get("threshold", summary.get("threshold"))
-    confidence = row.get("confidence")
-    if confidence is None and prob_up is not None:
-        try:
-            confidence = float(max(float(prob_up), 1.0 - float(prob_up)))
-        except Exception:
-            confidence = None
-    return {
-        "input_date": input_date,
-        "target_date": target_date,
-        "prediction": prediction,
-        "prob_up": prob_up,
-        "confidence": confidence,
-        "threshold": threshold,
-        "model_name": "nifty_tomorrow_direction_model",
-        "source_model": summary.get("source_model", "locked_multiwindow_nifty50_ensemble"),
-        "validation_accuracy": summary.get("validation_accuracy"),
-        "test_accuracy": summary.get("test_accuracy"),
-        "artifact_source": str(DAILY_FORECASTER_OUTPUT_DIR),
-    }
-
-
-def sync_daily_forecaster_outputs() -> dict[str, Any] | None:
-    summary = _read_daily_forecaster_summary()
-    if summary is None:
-        return None
-    latest = _read_daily_forecaster_latest(summary)
-    TOMORROW_SUMMARY_PATH.write_text(json.dumps(summary, indent=2), encoding="utf-8")
-    if latest is not None:
-        pd.DataFrame([latest]).to_csv(TOMORROW_LATEST_PATH, index=False)
-    if DAILY_FORECASTER_PREDICTIONS_PATH.exists():
-        predictions = pd.read_csv(DAILY_FORECASTER_PREDICTIONS_PATH)
-        if "symbol" in predictions.columns:
-            predictions = predictions[predictions["symbol"].astype(str) == "NIFTY 50"].copy()
-        if not predictions.empty:
-            if "pred" in predictions.columns and "prediction" not in predictions.columns:
-                predictions["prediction"] = np.where(pd.to_numeric(predictions["pred"], errors="coerce") == 1, "UP", "DOWN")
-            if "correct" not in predictions.columns and {"target", "pred"}.issubset(predictions.columns):
-                predictions["correct"] = (
-                    pd.to_numeric(predictions["target"], errors="coerce")
-                    == pd.to_numeric(predictions["pred"], errors="coerce")
-                )
-            predictions.to_parquet(TOMORROW_TEST_PREDICTIONS_PATH, index=False)
-    artifact = {
-        "artifact_type": "daily_forecaster_outputs",
-        "model_name": "nifty_tomorrow_direction_model",
-        "source_model": summary.get("source_model", "locked_multiwindow_nifty50_ensemble"),
-        "threshold": float(summary.get("threshold", 0.54)),
-        "validation_accuracy": summary.get("validation_accuracy"),
-        "test_accuracy": summary.get("test_accuracy"),
-        "validation_prob_std": summary.get("validation_prob_std"),
-        "test_prob_std": summary.get("test_prob_std"),
-        "test_prob_min": summary.get("test_prob_min"),
-        "test_prob_max": summary.get("test_prob_max"),
-        "artifact_source": str(DAILY_FORECASTER_OUTPUT_DIR),
-    }
-    joblib.dump(artifact, TOMORROW_MODEL_PATH)
-    return latest or summary
-
-
-def load_tomorrow_model_artifact() -> dict[str, Any]:
-    synced = sync_daily_forecaster_outputs()
-    if synced is not None and TOMORROW_MODEL_PATH.exists():
-        return joblib.load(TOMORROW_MODEL_PATH)
-    if TOMORROW_MODEL_PATH.exists():
-        return joblib.load(TOMORROW_MODEL_PATH)
-    summary = load_tomorrow_summary()
+    raise FileNotFoundError("No latest prediction is available yet.")
+
+
+def _read_daily_forecaster_summary() -> dict[str, Any] | None:
+    if not DAILY_FORECASTER_SUMMARY_PATH.exists():
+        return None
+    raw = json.loads(DAILY_FORECASTER_SUMMARY_PATH.read_text(encoding="utf-8"))
+    if isinstance(raw, list):
+        matches = [row for row in raw if row.get("symbol") == "NIFTY 50"]
+        summary = dict(matches[0] if matches else raw[0])
+    elif isinstance(raw, dict):
+        summary = dict(raw)
+    else:
+        return None
+    config = summary.get("config") if isinstance(summary.get("config"), dict) else {}
+    summary.setdefault("symbol", "NIFTY 50")
+    summary.setdefault("horizon", "daily")
+    summary.setdefault("horizon_bars", 1)
+    summary["model_name"] = "nifty_tomorrow_direction_model"
+    summary["source_model"] = str(config.get("name") or summary.get("source_model") or "locked_multiwindow_nifty50_ensemble")
+    summary["target"] = "next trading session NIFTY 50 direction"
+    summary["artifact_type"] = "daily_forecaster_outputs"
+    summary["artifact_source"] = str(DAILY_FORECASTER_OUTPUT_DIR)
+    return summary
+
+
+def _read_daily_forecaster_latest(summary: dict[str, Any]) -> dict[str, Any] | None:
+    if not DAILY_FORECASTER_LATEST_PATH.exists():
+        return None
+    latest = pd.read_csv(DAILY_FORECASTER_LATEST_PATH)
+    if latest.empty:
+        return None
+    if "symbol" in latest.columns:
+        filtered = latest[latest["symbol"].astype(str) == "NIFTY 50"]
+        if not filtered.empty:
+            latest = filtered
+    row = {k: (None if pd.isna(v) else v) for k, v in latest.iloc[-1].to_dict().items()}
+    input_date = row.get("latest_forecast_date") or row.get("input_date")
+    target_date = row.get("target_date")
+    if not target_date and input_date:
+        try:
+            target_date = next_trading_day(date.fromisoformat(str(input_date)[:10]) + timedelta(days=1)).isoformat()
+        except Exception:
+            target_date = None
+    prob_up = row.get("latest_forecast_prob_up", row.get("prob_up"))
+    prediction = row.get("latest_forecast_signal", row.get("prediction"))
+    threshold = row.get("threshold", summary.get("threshold"))
+    confidence = row.get("confidence")
+    if confidence is None and prob_up is not None:
+        try:
+            confidence = float(max(float(prob_up), 1.0 - float(prob_up)))
+        except Exception:
+            confidence = None
+    return {
+        "input_date": input_date,
+        "target_date": target_date,
+        "prediction": prediction,
+        "prob_up": prob_up,
+        "confidence": confidence,
+        "threshold": threshold,
+        "model_name": "nifty_tomorrow_direction_model",
+        "source_model": summary.get("source_model", "locked_multiwindow_nifty50_ensemble"),
+        "validation_accuracy": summary.get("validation_accuracy"),
+        "test_accuracy": summary.get("test_accuracy"),
+        "artifact_source": str(DAILY_FORECASTER_OUTPUT_DIR),
+    }
+
+
+def _parse_iso_date(value: Any) -> date | None:
+    try:
+        return date.fromisoformat(str(value or "")[:10])
+    except Exception:
+        return None
+
+
+def _archive_tomorrow_latest_to_history() -> None:
+    if not TOMORROW_LATEST_PATH.exists():
+        return
+    try:
+        row = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
+        cleaned = {k: (None if pd.isna(v) else v) for k, v in row.items()}
+        pred = str(cleaned.get("prediction", "")).upper()
+        if pred in {"UP", "DOWN"} and cleaned.get("target_date"):
+            _record_prediction_history(TOMORROW_PREDICTION_HISTORY_PATH, cleaned, ["target_date"])
+    except Exception:
+        pass
+
+
+def _tomorrow_actual_outcome(
+    target_day: date,
+    day_close: float,
+    closes_by_date: dict[date, float],
+) -> tuple[float | None, str | None]:
+    """Return (move, direction) for Tomorrow scoring: close vs previous session close."""
+    prev_day = previous_trading_day(target_day - timedelta(days=1))
+    prev_close = closes_by_date.get(prev_day)
+    if prev_close is None or not np.isfinite(prev_close) or prev_close == 0:
+        return None, None
+    actual_move = (day_close - prev_close) / prev_close
+    actual_direction = "UP" if day_close > prev_close else "DOWN"
+    return actual_move, actual_direction
+
+
+def _find_tomorrow_prediction_for_target(target_day: date) -> dict[str, Any] | None:
+    """Return the Tomorrow prediction that targets ``target_day``."""
+    target_iso = target_day.isoformat()
+    tom_history = _load_prediction_history(TOMORROW_PREDICTION_HISTORY_PATH)
+    if not tom_history.empty:
+        for col in ("date", "input_date", "target_date", "forecast_date"):
+            if col in tom_history.columns:
+                tom_history[col] = pd.to_datetime(tom_history[col], errors="coerce")
+
+    if not tom_history.empty and "target_date" in tom_history.columns:
+        rows = tom_history[tom_history["target_date"].dt.date == target_day]
+        if not rows.empty:
+            return rows.iloc[-1].to_dict()
+
+    if TOMORROW_LATEST_PATH.exists():
+        try:
+            row = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
+            if _parse_iso_date(row.get("target_date")) == target_day:
+                return row
+        except Exception:
+            pass
+
+    input_day = previous_trading_day(target_day - timedelta(days=1))
+    if not tom_history.empty and "input_date" in tom_history.columns:
+        rows = tom_history[tom_history["input_date"].dt.date == input_day]
+        if not rows.empty:
+            row = rows.iloc[-1].to_dict()
+            if _parse_iso_date(row.get("target_date")) in {None, target_day}:
+                return row
+
+    if TOMORROW_LATEST_PATH.exists():
+        try:
+            row = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
+            if _parse_iso_date(row.get("input_date")) == input_day:
+                return row
+        except Exception:
+            pass
+
+    tomorrow_test = load_tomorrow_test_predictions()
+    tomorrow_history = _load_prediction_history(TOMORROW_PREDICTION_HISTORY_PATH)
+    if not tomorrow_test.empty:
+        for col in ("target_date", "date"):
+            if col in tomorrow_test.columns:
+                test_dates = pd.to_datetime(tomorrow_test[col], errors="coerce").dt.date
+                rows = tomorrow_test[test_dates == target_day]
+                if not rows.empty:
+                    return rows.iloc[-1].to_dict()
+
+    ledger = load_live_accuracy()
+    for entry in ledger.get("tomorrow", {}).get("entries", []):
+        if str(entry.get("date", ""))[:10] == target_iso:
+            pred = str(entry.get("prediction", "")).upper()
+            if pred in {"UP", "DOWN"}:
+                return {
+                    "target_date": target_iso,
+                    "prediction": pred,
+                    "source": entry.get("source", "live"),
+                }
+    return None
+
+
+def sync_daily_forecaster_outputs() -> dict[str, Any] | None:
+    summary = _read_daily_forecaster_summary()
+    if summary is None:
+        return None
+    latest = _read_daily_forecaster_latest(summary)
+    TOMORROW_SUMMARY_PATH.write_text(json.dumps(summary, indent=2), encoding="utf-8")
+    if latest is not None:
+        _archive_tomorrow_latest_to_history()
+        keep_existing = False
+        if TOMORROW_LATEST_PATH.exists():
+            try:
+                existing = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
+                existing_input = _parse_iso_date(existing.get("input_date"))
+                forecaster_input = _parse_iso_date(latest.get("input_date"))
+                existing_pred = str(existing.get("prediction", "")).upper()
+                if (
+                    existing_input is not None
+                    and forecaster_input is not None
+                    and existing_input > forecaster_input
+                    and existing_pred in {"UP", "DOWN"}
+                ):
+                    keep_existing = True
+            except Exception:
+                keep_existing = False
+        if not keep_existing:
+            pd.DataFrame([latest]).to_csv(TOMORROW_LATEST_PATH, index=False)
+    if DAILY_FORECASTER_PREDICTIONS_PATH.exists():
+        predictions = pd.read_csv(DAILY_FORECASTER_PREDICTIONS_PATH)
+        if "symbol" in predictions.columns:
+            predictions = predictions[predictions["symbol"].astype(str) == "NIFTY 50"].copy()
+        if not predictions.empty:
+            if "pred" in predictions.columns and "prediction" not in predictions.columns:
+                predictions["prediction"] = np.where(pd.to_numeric(predictions["pred"], errors="coerce") == 1, "UP", "DOWN")
+            if "correct" not in predictions.columns and {"target", "pred"}.issubset(predictions.columns):
+                predictions["correct"] = (
+                    pd.to_numeric(predictions["target"], errors="coerce")
+                    == pd.to_numeric(predictions["pred"], errors="coerce")
+                )
+            predictions.to_parquet(TOMORROW_TEST_PREDICTIONS_PATH, index=False)
+    artifact = {
+        "artifact_type": "daily_forecaster_outputs",
+        "model_name": "nifty_tomorrow_direction_model",
+        "source_model": summary.get("source_model", "locked_multiwindow_nifty50_ensemble"),
+        "threshold": float(summary.get("threshold", 0.54)),
+        "validation_accuracy": summary.get("validation_accuracy"),
+        "test_accuracy": summary.get("test_accuracy"),
+        "validation_prob_std": summary.get("validation_prob_std"),
+        "test_prob_std": summary.get("test_prob_std"),
+        "test_prob_min": summary.get("test_prob_min"),
+        "test_prob_max": summary.get("test_prob_max"),
+        "artifact_source": str(DAILY_FORECASTER_OUTPUT_DIR),
+    }
+    joblib.dump(artifact, TOMORROW_MODEL_PATH)
+    return latest or summary
+
+
+def load_tomorrow_model_artifact() -> dict[str, Any]:
+    synced = sync_daily_forecaster_outputs()
+    if synced is not None and TOMORROW_MODEL_PATH.exists():
+        return joblib.load(TOMORROW_MODEL_PATH)
+    if TOMORROW_MODEL_PATH.exists():
+        return joblib.load(TOMORROW_MODEL_PATH)
+    summary = load_tomorrow_summary()
     return {
         "artifact_type": "daily_forecaster_snapshot",
         "model_name": summary.get("model_name", "nifty_tomorrow_direction_model"),
@@ -680,63 +841,63 @@ def load_tomorrow_model_artifact() -> dict[str, Any]:
     }
 
 
-def load_tomorrow_summary() -> dict[str, Any]:
-    synced = sync_daily_forecaster_outputs()
-    if synced is not None and TOMORROW_SUMMARY_PATH.exists():
-        return json.loads(TOMORROW_SUMMARY_PATH.read_text(encoding="utf-8"))
-    if TOMORROW_SUMMARY_PATH.exists():
-        return json.loads(TOMORROW_SUMMARY_PATH.read_text(encoding="utf-8"))
-    return {
-        "model_name": "nifty_tomorrow_direction_model",
-        "source_model": "locked_multiwindow_nifty50_ensemble",
-        "target": "next trading session NIFTY 50 direction",
-        "threshold": 0.54,
-        "validation_accuracy": 0.5673758865248227,
-        "test_accuracy": 0.6451612903225806,
-        "baseline_accuracy": 0.5053763440860215,
-        "n_test": 186,
-        "feature_count": 204,
-    }
-
-
-def latest_tomorrow_prediction() -> dict[str, Any]:
-    sync_daily_forecaster_outputs()
-    latest_daily = latest_parquet_date(NIFTY_1D_PATH)
-    expected_daily = expected_completed_daily_date()
-    valid_daily = min(latest_daily, expected_daily) if latest_daily and expected_daily else (expected_daily or latest_daily)
-
-    if TOMORROW_LATEST_PATH.exists():
-        row = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
-        cleaned = {k: (None if pd.isna(v) else v) for k, v in row.items()}
-        try:
-            input_day = date.fromisoformat(str(cleaned.get("input_date"))[:10])
-        except Exception:
-            input_day = None
-        if valid_daily is not None and (input_day is None or input_day < valid_daily):
-            try:
-                refreshed = refresh_tomorrow_prediction(session_date=valid_daily)
-                try:
-                    refreshed_day = date.fromisoformat(str(refreshed.get("input_date"))[:10])
-                except Exception:
-                    refreshed_day = None
-                if refreshed_day is not None and refreshed_day >= valid_daily:
-                    return refreshed
-            except Exception:
-                pass
-        return cleaned
-    summary = load_tomorrow_summary()
-    try:
-        summary_input_day = date.fromisoformat(str(summary.get("latest_forecast_date"))[:10])
-    except Exception:
-        summary_input_day = None
-    if valid_daily is not None and (summary_input_day is None or summary_input_day < valid_daily):
-        try:
-            return refresh_tomorrow_prediction(session_date=valid_daily)
-        except Exception:
-            pass
-    return {
-        "input_date": summary.get("latest_forecast_date"),
-        "target_date": None,
+def load_tomorrow_summary() -> dict[str, Any]:
+    synced = sync_daily_forecaster_outputs()
+    if synced is not None and TOMORROW_SUMMARY_PATH.exists():
+        return json.loads(TOMORROW_SUMMARY_PATH.read_text(encoding="utf-8"))
+    if TOMORROW_SUMMARY_PATH.exists():
+        return json.loads(TOMORROW_SUMMARY_PATH.read_text(encoding="utf-8"))
+    return {
+        "model_name": "nifty_tomorrow_direction_model",
+        "source_model": "locked_multiwindow_nifty50_ensemble",
+        "target": "next trading session NIFTY 50 direction",
+        "threshold": 0.54,
+        "validation_accuracy": 0.5673758865248227,
+        "test_accuracy": 0.6451612903225806,
+        "baseline_accuracy": 0.5053763440860215,
+        "n_test": 186,
+        "feature_count": 204,
+    }
+
+
+def latest_tomorrow_prediction() -> dict[str, Any]:
+    sync_daily_forecaster_outputs()
+    latest_daily = latest_parquet_date(NIFTY_1D_PATH)
+    expected_daily = expected_completed_daily_date()
+    valid_daily = min(latest_daily, expected_daily) if latest_daily and expected_daily else (expected_daily or latest_daily)
+
+    if TOMORROW_LATEST_PATH.exists():
+        row = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
+        cleaned = {k: (None if pd.isna(v) else v) for k, v in row.items()}
+        try:
+            input_day = date.fromisoformat(str(cleaned.get("input_date"))[:10])
+        except Exception:
+            input_day = None
+        if valid_daily is not None and (input_day is None or input_day < valid_daily):
+            try:
+                refreshed = refresh_tomorrow_prediction(session_date=valid_daily)
+                try:
+                    refreshed_day = date.fromisoformat(str(refreshed.get("input_date"))[:10])
+                except Exception:
+                    refreshed_day = None
+                if refreshed_day is not None and refreshed_day >= valid_daily:
+                    return refreshed
+            except Exception:
+                pass
+        return cleaned
+    summary = load_tomorrow_summary()
+    try:
+        summary_input_day = date.fromisoformat(str(summary.get("latest_forecast_date"))[:10])
+    except Exception:
+        summary_input_day = None
+    if valid_daily is not None and (summary_input_day is None or summary_input_day < valid_daily):
+        try:
+            return refresh_tomorrow_prediction(session_date=valid_daily)
+        except Exception:
+            pass
+    return {
+        "input_date": summary.get("latest_forecast_date"),
+        "target_date": None,
         "prediction": summary.get("latest_forecast_signal"),
         "prob_up": summary.get("latest_forecast_prob_up"),
         "confidence": None,
@@ -892,27 +1053,27 @@ def _apply_tplus1_overlays(pred: np.ndarray, frame: pd.DataFrame, overlays: list
     return adjusted
 
 
-def refresh_tplus1_prediction(session_date: date | None = None) -> dict[str, Any]:
-    if not TPLUS1_MODEL_PATH.exists():
-        raise FileNotFoundError(f"Missing T+1 model artifact: {TPLUS1_MODEL_PATH}")
-    payload = joblib.load(TPLUS1_MODEL_PATH)
-    features = payload["features"]
-    threshold = float(payload["threshold"])
-    frame = _add_tplus1_target_features(_build_tplus1_session_features(_minute_frame_for_tplus1()))
-    if session_date is not None:
-        row = frame[pd.to_datetime(frame["date"], errors="coerce").dt.date == session_date].tail(1)
-    else:
-        row = frame.tail(1)
-    if row.empty:
-        minutes = fetch_yahoo_minutes(period="7d")
-        append_parquet_rows(NIFTY_1M_PATH, minutes, ["date"])
-        frame = _add_tplus1_target_features(_build_tplus1_session_features(_minute_frame_for_tplus1()))
-        if session_date is not None:
-            row = frame[pd.to_datetime(frame["date"], errors="coerce").dt.date == session_date].tail(1)
-        else:
-            row = frame.tail(1)
-    if row.empty:
-        raise RuntimeError("No complete 14:00-14:20 window is available for T+1 prediction.")
+def refresh_tplus1_prediction(session_date: date | None = None) -> dict[str, Any]:
+    if not TPLUS1_MODEL_PATH.exists():
+        raise FileNotFoundError(f"Missing T+1 model artifact: {TPLUS1_MODEL_PATH}")
+    payload = joblib.load(TPLUS1_MODEL_PATH)
+    features = payload["features"]
+    threshold = float(payload["threshold"])
+    frame = _add_tplus1_target_features(_build_tplus1_session_features(_minute_frame_for_tplus1()))
+    if session_date is not None:
+        row = frame[pd.to_datetime(frame["date"], errors="coerce").dt.date == session_date].tail(1)
+    else:
+        row = frame.tail(1)
+    if row.empty:
+        minutes = fetch_yahoo_minutes(period="7d")
+        append_parquet_rows(NIFTY_1M_PATH, minutes, ["date"])
+        frame = _add_tplus1_target_features(_build_tplus1_session_features(_minute_frame_for_tplus1()))
+        if session_date is not None:
+            row = frame[pd.to_datetime(frame["date"], errors="coerce").dt.date == session_date].tail(1)
+        else:
+            row = frame.tail(1)
+    if row.empty:
+        raise RuntimeError("No complete 14:00-14:20 window is available for T+1 prediction.")
     missing = [col for col in features if col not in row.columns]
     if missing:
         raise RuntimeError(f"T+1 feature row is missing model features: {missing[:5]}")
@@ -938,8 +1099,10 @@ def refresh_tplus1_prediction(session_date: date | None = None) -> dict[str, Any
         "validation_accuracy": summary.get("validation_accuracy"),
         "test_accuracy": summary.get("test_accuracy"),
         "accuracy_goal": summary.get("accuracy_goal"),
+        "source": "live",
     }
     pd.DataFrame([out]).to_csv(TPLUS1_LATEST_PATH, index=False)
+    _record_prediction_history(TPLUS1_PREDICTION_HISTORY_PATH, out, ["target_date"])
     clear_dashboard_payload_cache()
     return out
 
@@ -966,23 +1129,26 @@ def _tomorrow_probability_from_daily(daily: pd.DataFrame, fallback_prob: float)
     return float(np.clip(score, 0.35, 0.65))
 
 
-def refresh_tomorrow_prediction(session_date: date | None = None) -> dict[str, Any]:
-    synced = sync_daily_forecaster_outputs()
-    if synced is not None and TOMORROW_LATEST_PATH.exists():
-        latest = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
-        cleaned = {k: (None if pd.isna(v) else v) for k, v in latest.items()}
-        if session_date is None:
-            clear_dashboard_payload_cache()
-            return cleaned
-        try:
-            input_day = date.fromisoformat(str(cleaned.get("input_date"))[:10])
-        except Exception:
-            input_day = None
-        if input_day is not None and (session_date is None or input_day >= session_date):
-            clear_dashboard_payload_cache()
-            return cleaned
-    summary = load_tomorrow_summary()
-    artifact = load_tomorrow_model_artifact()
+def refresh_tomorrow_prediction(session_date: date | None = None) -> dict[str, Any]:
+    _archive_tomorrow_latest_to_history()
+    synced = sync_daily_forecaster_outputs()
+    if synced is not None and TOMORROW_LATEST_PATH.exists():
+        latest = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
+        cleaned = {k: (None if pd.isna(v) else v) for k, v in latest.items()}
+        cleaned["source"] = "live"
+        _record_prediction_history(TOMORROW_PREDICTION_HISTORY_PATH, cleaned, ["target_date"])
+        if session_date is None:
+            clear_dashboard_payload_cache()
+            return cleaned
+        try:
+            input_day = date.fromisoformat(str(cleaned.get("input_date"))[:10])
+        except Exception:
+            input_day = None
+        if input_day is not None and (session_date is None or input_day >= session_date):
+            clear_dashboard_payload_cache()
+            return cleaned
+    summary = load_tomorrow_summary()
+    artifact = load_tomorrow_model_artifact()
     daily = pd.read_parquet(NIFTY_1D_PATH)
     daily["date"] = pd.to_datetime(daily["date"], errors="coerce").dt.normalize()
     daily = daily.dropna(subset=["date"]).sort_values("date")
@@ -1006,21 +1172,23 @@ def refresh_tomorrow_prediction(session_date: date | None = None) -> dict[str, A
         "source_model": str(summary.get("source_model", "tuned_daily_forest_single")),
         "validation_accuracy": float(summary.get("validation_accuracy", 0.5780141843971631)),
         "test_accuracy": float(summary.get("test_accuracy", 0.6182795698924731)),
+        "source": "live",
     }
     pd.DataFrame([row]).to_csv(TOMORROW_LATEST_PATH, index=False)
+    _record_prediction_history(TOMORROW_PREDICTION_HISTORY_PATH, row, ["target_date"])
     summary = dict(summary)
-    summary.update(
-        {
-            "latest_forecast_date": row["input_date"],
+    summary.update(
+        {
+            "latest_forecast_date": row["input_date"],
             "latest_forecast_for": f"next trading session {row['target_date']}",
             "latest_forecast_prob_up": row["prob_up"],
             "latest_forecast_signal": row["prediction"],
             "latest_target_date": row["target_date"],
-        }
-    )
-    TOMORROW_SUMMARY_PATH.write_text(json.dumps(summary, indent=2), encoding="utf-8")
-    clear_dashboard_payload_cache()
-    return row
+        }
+    )
+    TOMORROW_SUMMARY_PATH.write_text(json.dumps(summary, indent=2), encoding="utf-8")
+    clear_dashboard_payload_cache()
+    return row
 
 
 def _json_ready_frame(df: pd.DataFrame, limit: int | None = None) -> list[dict[str, Any]]:
@@ -1034,6 +1202,8 @@ def _json_ready_frame(df: pd.DataFrame, limit: int | None = None) -> list[dict[s
     return out.to_dict(orient="records")
 
 
+
+
 def load_model_summary() -> dict[str, Any]:
     summary_path = MODEL_DIR / "summary.json"
     if not summary_path.exists():
@@ -1096,118 +1266,190 @@ def dashboard_payload() -> dict[str, Any]:
         _file_cache_key(MODEL_DIR / "candidate_results.csv"),
         _file_cache_key(NIFTY_1M_PATH),
         _file_cache_key(LIVE_ACCURACY_PATH),
+        _file_cache_key(TOMORROW_PREDICTION_HISTORY_PATH),
     )
     with _dashboard_payload_lock:
         return copy.deepcopy(_dashboard_payload_cached(key))
 
 
-def warm_dashboard_payload_cache() -> None:
-    dashboard_payload()
-
-
-def build_prediction_track_record(
-    daily: pd.DataFrame,
-    t5_test: pd.DataFrame,
-    tomorrow_test: pd.DataFrame,
-    tplus1_test: pd.DataFrame,
-    t5_latest: dict[str, Any],
-    tomorrow_latest: dict[str, Any],
-    tplus1_latest: dict[str, Any],
-) -> list[dict[str, Any]]:
-    daily_rows = daily.copy()
-    daily_rows["date"] = pd.to_datetime(daily_rows["date"], errors="coerce").dt.normalize()
-    daily_rows = daily_rows.dropna(subset=["date"]).sort_values("date")
-    daily_rows = daily_rows[
-        daily_rows["open"].map(lambda value: np.isfinite(float(value)) if pd.notna(value) else False)
-        & daily_rows["close"].map(lambda value: np.isfinite(float(value)) if pd.notna(value) else False)
-    ].copy()
-    daily_rows = daily_rows[daily_rows["open"].astype(float) != 0]
-    completed_day = expected_completed_daily_date()
-    daily_rows = daily_rows[daily_rows["date"].dt.date <= completed_day]
-    if daily_rows.empty:
-        return []
-
-    predictions_by_date: dict[str, dict[str, Any]] = {}
-
-    def add_prediction(target_date: Any, prediction: Any, source: str, priority: int, meta: dict[str, Any] | None = None) -> None:
-        day = str(target_date or "")[:10]
-        pred = str(prediction or "").upper()
-        if not day or pred not in {"UP", "DOWN"}:
-            return
-        existing = predictions_by_date.get(day)
-        if existing and existing.get("_priority", 0) >= priority:
-            return
-        predictions_by_date[day] = {
-            "prediction": pred,
-            "source": source,
-            "_priority": priority,
-            **(meta or {}),
-        }
-
-    for _, row in tomorrow_test.iterrows():
-        pred = row.get("prediction")
-        if pd.isna(pred) and "pred" in row:
-            pred = "UP" if int(row.get("pred")) == 1 else "DOWN"
-        add_prediction(row.get("target_date") or row.get("date"), pred, "Tomorrow", 20, {"prob_up": row.get("prob_up")})
-
-    add_prediction(tomorrow_latest.get("target_date"), tomorrow_latest.get("prediction"), "Tomorrow", 40, {"prob_up": tomorrow_latest.get("prob_up")})
-
-    records: list[dict[str, Any]] = []
-    for _, row in daily_rows.tail(20).iterrows():
-        day = row["date"].date().isoformat()
-        day_open = float(row["open"])
-        day_close = float(row["close"])
-        actual_move = (day_close - day_open) / day_open
-        actual_direction = "UP" if actual_move >= 0 else "DOWN"
-        pred = predictions_by_date.get(day)
-        prediction = pred.get("prediction") if pred else None
-        records.append(
-            {
-                "date": day,
-                "prediction": prediction,
-                "prediction_source": pred.get("source") if pred else None,
-                "prob_up": pred.get("prob_up") if pred else None,
-                "actual_move": actual_move,
-                "actual_direction": actual_direction,
-                "correct": None if prediction is None else prediction == actual_direction,
-            }
-        )
-    return records
-
-
-@lru_cache(maxsize=4)
-def _dashboard_payload_cached(key: tuple[tuple[str, int | None, int | None], ...]) -> dict[str, Any]:
+def warm_dashboard_payload_cache() -> None:
+    dashboard_payload()
+
+
+def _load_forecaster_predictions_by_target() -> dict[date, dict[str, Any]]:
+    path = DAILY_FORECASTER_PREDICTIONS_PATH
+    if not path.exists():
+        return {}
+    try:
+        frame = pd.read_csv(path)
+    except Exception:
+        return {}
+    if frame.empty:
+        return {}
+    if "symbol" in frame.columns:
+        frame = frame[frame["symbol"].astype(str) == "NIFTY 50"].copy()
+    indexed: dict[date, dict[str, Any]] = {}
+    for _, row in frame.iterrows():
+        target_day = _parse_iso_date(row.get("target_date"))
+        if target_day is None:
+            continue
+        pred_value = row.get("pred")
+        if pd.isna(pred_value) and "raw_pred" in row:
+            pred_value = row.get("raw_pred")
+        try:
+            pred_int = int(pred_value)
+        except Exception:
+            continue
+        prob_up = row.get("prob_up")
+        try:
+            prob_up = float(prob_up) if pd.notna(prob_up) else None
+        except Exception:
+            prob_up = None
+        indexed[target_day] = {
+            "prediction": "UP" if pred_int == 1 else "DOWN",
+            "prob_up": prob_up,
+            "forecast_date": row.get("forecast_date"),
+            "source": "Tomorrow (forecaster)",
+        }
+    return indexed
+
+
+def _load_track_record_daily_rows() -> pd.DataFrame:
+    frames: list[pd.DataFrame] = []
+    if NIFTY_1D_PATH.exists():
+        try:
+            frames.append(pd.read_parquet(NIFTY_1D_PATH))
+        except Exception:
+            pass
+    try:
+        yahoo_daily = fetch_yahoo_daily(period="3mo")
+        if not yahoo_daily.empty:
+            frames.append(yahoo_daily)
+            try:
+                append_parquet_rows(NIFTY_1D_PATH, yahoo_daily, ["date"])
+            except Exception:
+                pass
+    except Exception:
+        pass
+
+    if not frames:
+        return pd.DataFrame()
+
+    combined = pd.concat(frames, ignore_index=True)
+    combined["date"] = pd.to_datetime(combined["date"], errors="coerce").dt.normalize()
+    combined = combined.dropna(subset=["date"]).sort_values("date")
+    combined = combined.drop_duplicates(subset=["date"], keep="last")
+    combined = combined[
+        combined["close"].map(lambda value: np.isfinite(float(value)) if pd.notna(value) else False)
+    ].copy()
+    return combined.reset_index(drop=True)
+
+
+def _rolling_tomorrow_prediction(
+    input_day: date,
+    daily_rows: pd.DataFrame,
+    threshold: float,
+    fallback_prob: float,
+) -> tuple[str, float]:
+    history = daily_rows[daily_rows["date"].dt.date <= input_day].copy()
+    prob_up = _tomorrow_probability_from_daily(history, fallback_prob)
+    prediction = "UP" if prob_up >= threshold else "DOWN"
+    return prediction, float(prob_up)
+
+
+def build_prediction_track_record(
+    sessions: int = 10,
+) -> list[dict[str, Any]]:
+    summary = load_tomorrow_summary()
+    artifact = load_tomorrow_model_artifact()
+    threshold = float(artifact.get("threshold", summary.get("threshold", 0.534)))
+    fallback_prob = float(summary.get("latest_forecast_prob_up", 0.49900560447008563))
+    forecaster_by_target = _load_forecaster_predictions_by_target()
+
+    daily_rows = _load_track_record_daily_rows()
+    if daily_rows.empty:
+        return []
+
+    closes_by_date = {
+        row["date"].date(): float(row["close"])
+        for _, row in daily_rows.iterrows()
+        if pd.notna(row["close"]) and np.isfinite(float(row["close"]))
+    }
+
+    end_session = _track_record_end_session()
+    available_through = max(
+        (day for day in closes_by_date if day <= end_session),
+        default=None,
+    )
+    if available_through is None:
+        return []
+    if available_through < end_session:
+        end_session = available_through
+
+    session_dates = last_n_trading_sessions(end_session, sessions)
+
+    records: list[dict[str, Any]] = []
+    for target_day in session_dates:
+        day_close = closes_by_date.get(target_day)
+        if day_close is None:
+            continue
+        actual_move, actual_direction = _tomorrow_actual_outcome(target_day, day_close, closes_by_date)
+        if actual_direction is None:
+            continue
+
+        input_day = previous_trading_day(target_day - timedelta(days=1))
+        cached = forecaster_by_target.get(target_day)
+        if cached and cached.get("prediction") in {"UP", "DOWN"}:
+            prediction = cached["prediction"]
+            prob_up = cached.get("prob_up")
+            source = cached.get("source", "Tomorrow (forecaster)")
+        else:
+            prediction, prob_up = _rolling_tomorrow_prediction(
+                input_day,
+                daily_rows,
+                threshold,
+                fallback_prob,
+            )
+            source = "Tomorrow (rolling)"
+
+        if prediction not in {"UP", "DOWN"}:
+            continue
+
+        records.append(
+            {
+                "date": target_day.isoformat(),
+                "input_date": input_day.isoformat(),
+                "prediction": prediction,
+                "prediction_source": source,
+                "prob_up": prob_up,
+                "actual_move": actual_move,
+                "actual_direction": actual_direction,
+                "correct": prediction == actual_direction,
+            }
+        )
+    return records[-sessions:]
+
+
+@lru_cache(maxsize=4)
+def _dashboard_payload_cached(key: tuple[tuple[str, int | None, int | None], ...]) -> dict[str, Any]:
     summary = load_model_summary()
     t5_latest = _latest_saved_prediction_uncached()
     tomorrow_summary = load_tomorrow_summary()
     tomorrow_latest = latest_tomorrow_prediction()
     tplus1_summary = load_tplus1_summary()
     tplus1_latest = latest_tplus1_prediction()
-    refresh_state = load_refresh_state()
     t5_test = load_test_predictions()
     tomorrow_test = load_tomorrow_test_predictions()
+    tomorrow_history = _load_prediction_history(TOMORROW_PREDICTION_HISTORY_PATH)
     tplus1_test = load_tplus1_test_predictions()
     daily = pd.read_parquet(NIFTY_1D_PATH)
     daily["date"] = pd.to_datetime(daily["date"], errors="coerce")
     daily = daily.sort_values("date").tail(180)
-    dataset = read_training_dataset()
-    opening = dataset[["date", "first5_return", "first5_range_pct", "first5_close_location"]].tail(120).copy()
 
     if not t5_test.empty:
-        recent_predictions = t5_test.tail(40).copy()
-        recent_accuracy = float(recent_predictions["correct"].mean())
-        direction_mix = t5_test.groupby("prediction")["correct"].agg(["count", "mean"]).reset_index()
-        monthly = (
-            t5_test.assign(month=t5_test["date"].dt.strftime("%Y-%m"))
-            .groupby("month", as_index=False)["correct"]
-            .mean()
-            .rename(columns={"correct": "accuracy"})
-        )
+        recent_accuracy = float(t5_test.tail(40)["correct"].mean())
     else:
-        recent_predictions = pd.DataFrame()
         recent_accuracy = None
-        direction_mix = pd.DataFrame()
-        monthly = pd.DataFrame()
 
     if not tomorrow_test.empty:
         tomorrow_recent = tomorrow_test.tail(40).copy()
@@ -1217,7 +1459,6 @@ def _dashboard_payload_cached(key: tuple[tuple[str, int | None, int | None], ...
             tomorrow_recent["correct"] = pd.to_numeric(tomorrow_recent["target"], errors="coerce") == pd.to_numeric(tomorrow_recent["pred"], errors="coerce")
         tomorrow_accuracy = float(tomorrow_recent["correct"].mean()) if "correct" in tomorrow_recent.columns else tomorrow_summary.get("test_accuracy")
     else:
-        tomorrow_recent = pd.DataFrame()
         tomorrow_accuracy = tomorrow_summary.get("test_accuracy")
 
     model_metrics = [
@@ -1252,59 +1493,46 @@ def _dashboard_payload_cached(key: tuple[tuple[str, int | None, int | None], ...
             "test_rows": int(len(t5_test)) if not t5_test.empty else int(summary.get("test_rows") or 0),
         },
     ]
-    metrics = {
-        "validation_accuracy": tomorrow_summary.get("validation_accuracy"),
-        "test_accuracy": tomorrow_summary.get("test_accuracy"),
+    metrics = {
+        "validation_accuracy": tomorrow_summary.get("validation_accuracy"),
+        "test_accuracy": tomorrow_summary.get("test_accuracy"),
         "baseline_test_accuracy": tomorrow_summary.get("baseline_accuracy"),
         "validation_auc": summary.get("validation_auc"),
         "test_auc": summary.get("test_auc"),
         "test_brier": summary.get("test_brier"),
         "feature_count": tomorrow_summary.get("feature_count"),
         "recent_accuracy": tomorrow_accuracy,
-        "recent_accuracy_days": int(len(tomorrow_recent)) if not tomorrow_recent.empty else 0,
-        "total_test_days": int(tomorrow_summary.get("n_test") or len(tomorrow_test) or 0),
-        "models": model_metrics,
-    }
-    track_record = build_prediction_track_record(
-        daily,
-        t5_test,
-        tomorrow_test,
-        tplus1_test,
-        t5_latest,
-        tomorrow_latest,
-        tplus1_latest,
-    )
-    return {
-        "latest": t5_latest,
-        "tomorrow_latest": tomorrow_latest,
-        "tplus1_latest": tplus1_latest,
-        "live_accuracy": load_live_accuracy(),
+        "recent_accuracy_days": int(len(tomorrow_test.tail(40))) if not tomorrow_test.empty else 0,
+        "total_test_days": int(tomorrow_summary.get("n_test") or len(tomorrow_test) or 0),
+        "models": model_metrics,
+    }
+    return {
+        "timestamp": datetime.now(ZoneInfo("Asia/Kolkata")).isoformat(),
+        "predictions": {
+            "t5": {
+                "latest": t5_latest,
+                "summary": summary,
+            },
+            "tomorrow": {
+                "latest": tomorrow_latest,
+                "summary": tomorrow_summary,
+            },
+            "tplus1": {
+                "latest": tplus1_latest,
+                "summary": tplus1_summary,
+            },
+        },
         "metrics": metrics,
-        "summary": summary,
-        "tomorrow_summary": tomorrow_summary,
-        "tplus1_summary": tplus1_summary,
-        "candidates": load_candidate_results(),
+        "models": model_metrics,
+        "live_accuracy": load_live_accuracy(),
         "charts": {
-            "daily_close": _json_ready_frame(daily[["date", "open", "high", "low", "close"]]),
-            "opening_features": _json_ready_frame(opening),
-            "monthly_accuracy": _json_ready_frame(monthly),
-            "direction_mix": _json_ready_frame(direction_mix),
-            "recent_predictions": _json_ready_frame(recent_predictions),
-            "t5_recent_predictions": _json_ready_frame(recent_predictions),
-            "tomorrow_recent_predictions": _json_ready_frame(tomorrow_recent),
-            "tplus1_recent_predictions": _json_ready_frame(tplus1_test.tail(40)),
-            "track_record": track_record,
-        },
-        "data_status": {
-            "nifty_1m_rows": int(len(pd.read_parquet(NIFTY_1M_PATH, columns=["date"]))),
-            "nifty_1d_rows": int(len(pd.read_parquet(NIFTY_1D_PATH, columns=["date"]))),
-            "training_rows": int(len(dataset)),
-            "test_prediction_rows": int(len(t5_test)),
-            "tomorrow_test_prediction_rows": int(len(tomorrow_test)),
-            "tplus1_test_prediction_rows": int(len(tplus1_test)),
-            "latest_daily_date": pd.to_datetime(daily["date"]).max().date().isoformat(),
-            "refresh_phase": refresh_state.get("phase", REFRESH_NORMAL),
-            "refresh_state": refresh_state,
+            "daily_closes": _json_ready_frame(daily[["date", "close"]]),
+            "t5_backtest": _json_ready_frame(t5_test, limit=400),
+            "t5_recent_predictions": _json_ready_frame(t5_test.tail(40)),
+            "tomorrow_backtest": _json_ready_frame(tomorrow_test, limit=400),
+            "tomorrow_live_track_record": build_prediction_track_record(),
+            "tomorrow_history_predictions": _json_ready_frame(tomorrow_history.tail(80)),
+            "tplus1_backtest": _json_ready_frame(tplus1_test, limit=400),
         },
     }
 
@@ -1323,14 +1551,12 @@ def refresh_first5_prediction(session_date: date | None = None, minutes: pd.Data
     merged = merged.drop_duplicates(subset=["date"], keep="last").sort_values("date").reset_index(drop=True)
     merged.to_parquet(OPENING_DATASET_PATH, index=False, compression="zstd")
     prediction = predict_row(row)
-    clear_dashboard_payload_cache()
     return prediction
 
 
 def refresh_daily_data() -> dict[str, Any]:
     daily = fetch_yahoo_daily(period="1mo")
     combined = append_parquet_rows(NIFTY_1D_PATH, daily, ["date"])
-    clear_dashboard_payload_cache()
     return {
         "rows": int(len(combined)),
         "latest_date": pd.to_datetime(combined["date"]).max().date().isoformat(),
@@ -1383,7 +1609,6 @@ def update_opening_outcomes_from_daily() -> dict[str, Any]:
     dataset = dataset.drop(columns=["_session_date"])
     dataset = dataset.sort_values("date").reset_index(drop=True)
     dataset.to_parquet(OPENING_DATASET_PATH, index=False, compression="zstd")
-    clear_dashboard_payload_cache()
     latest = pd.to_datetime(dataset["date"], errors="coerce").max()
     return {
         "updated_rows": int(updated),
@@ -1391,136 +1616,285 @@ def update_opening_outcomes_from_daily() -> dict[str, Any]:
     }
 
 
-def load_live_accuracy() -> dict[str, Any]:
-    """Load the live accuracy ledger from disk."""
-    if LIVE_ACCURACY_PATH.exists():
-        try:
-            return json.loads(LIVE_ACCURACY_PATH.read_text(encoding="utf-8"))
-        except Exception:
-            pass
-    return {
-        "tomorrow": {"entries": [], "accuracy": None, "total": 0, "correct_count": 0},
-        "t5": {"entries": [], "accuracy": None, "total": 0, "correct_count": 0},
-        "tplus1": {"entries": [], "accuracy": None, "total": 0, "correct_count": 0},
-    }
-
-
-def save_live_accuracy(data: dict[str, Any]) -> None:
-    """Persist the live accuracy ledger to disk."""
-    LIVE_ACCURACY_PATH.write_text(json.dumps(data, indent=2), encoding="utf-8")
-
-
-def update_live_accuracy(session_date: date) -> dict[str, Any]:
-    """Score today's predictions against actual outcomes and update the ledger.
-
-    Must be called AFTER refresh_daily_data() (so today's close is available)
-    but BEFORE refresh_first5_prediction / refresh_tplus1_prediction /
-    refresh_tomorrow_prediction (so the CSV files still hold the predictions
-    we want to score).
-    """
-    ledger = load_live_accuracy()
-    daily = pd.read_parquet(NIFTY_1D_PATH)
-    daily["_date"] = pd.to_datetime(daily["date"], errors="coerce").dt.normalize()
-    today_rows = daily[daily["_date"].dt.date == session_date]
-    if today_rows.empty:
-        return ledger
-
-    day_open = float(today_rows.iloc[-1]["open"])
-    day_close = float(today_rows.iloc[-1]["close"])
-    if not (np.isfinite(day_open) and np.isfinite(day_close) and day_open != 0):
-        return ledger
-    actual_close_gt_open = "UP" if day_close > day_open else "DOWN"
-    session_iso = session_date.isoformat()
-
-    # --- T+5: today's 9:20 AM prediction vs close > open ---
-    logged_t5 = {e["date"] for e in ledger["t5"]["entries"]}
-    if session_iso not in logged_t5 and LATEST_PATH.exists():
-        try:
-            t5_row = pd.read_csv(LATEST_PATH).iloc[-1].to_dict()
-            if str(t5_row.get("input_date", ""))[:10] == session_iso:
-                pred = str(t5_row.get("prediction", "")).upper()
-                if pred in ("UP", "DOWN"):
-                    ledger["t5"]["entries"].append({
-                        "date": session_iso,
-                        "prediction": pred,
-                        "actual": actual_close_gt_open,
-                        "correct": pred == actual_close_gt_open,
-                    })
-        except Exception:
-            pass
-
-    # --- Tomorrow: yesterday's prediction targeting today vs close > open ---
-    logged_tom = {e["date"] for e in ledger["tomorrow"]["entries"]}
-    if session_iso not in logged_tom and TOMORROW_LATEST_PATH.exists():
-        try:
-            tom_row = pd.read_csv(TOMORROW_LATEST_PATH).iloc[-1].to_dict()
-            if str(tom_row.get("target_date", ""))[:10] == session_iso:
-                pred = str(tom_row.get("prediction", "")).upper()
-                if pred in ("UP", "DOWN"):
-                    ledger["tomorrow"]["entries"].append({
-                        "date": session_iso,
-                        "prediction": pred,
-                        "actual": actual_close_gt_open,
-                        "correct": pred == actual_close_gt_open,
-                    })
-        except Exception:
-            pass
-
-    # --- T+1: yesterday's 14:20 prediction targeting today ---
-    # T+1 target: today's close > yesterday's 14:20 close
-    logged_t1 = {e["date"] for e in ledger["tplus1"]["entries"]}
-    if session_iso not in logged_t1 and TPLUS1_LATEST_PATH.exists():
-        try:
-            t1_row = pd.read_csv(TPLUS1_LATEST_PATH).iloc[-1].to_dict()
-            if str(t1_row.get("target_date", ""))[:10] == session_iso:
-                pred = str(t1_row.get("prediction", "")).upper()
-                input_date_str = str(t1_row.get("input_date", ""))[:10]
-                input_day = date.fromisoformat(input_date_str)
-                # Read the 14:20 close from minute data for the input session
-                minute = pd.read_parquet(NIFTY_1M_PATH, columns=["date", "close"])
-                minute["dt"] = pd.to_datetime(minute["date"], errors="coerce")
-                minute = minute.dropna(subset=["dt"])
-                minute["session_date"] = minute["dt"].dt.normalize()
-                minute["time_str"] = minute["dt"].dt.strftime("%H:%M")
-                window = minute[
-                    (minute["session_date"].dt.date == input_day)
-                    & (minute["time_str"] >= "14:00")
-                    & (minute["time_str"] <= "14:20")
-                ].sort_values("dt")
-                if not window.empty and pred in ("UP", "DOWN"):
-                    w_close = float(window.iloc[-1]["close"])
-                    t1_actual = "UP" if day_close > w_close else "DOWN"
-                    ledger["tplus1"]["entries"].append({
-                        "date": session_iso,
-                        "prediction": pred,
-                        "actual": t1_actual,
-                        "correct": pred == t1_actual,
-                    })
-        except Exception:
-            pass
-
-    # Recompute summary stats
-    for model_id in ("t5", "tomorrow", "tplus1"):
-        entries = ledger[model_id]["entries"]
-        total = len(entries)
-        correct = sum(1 for e in entries if e.get("correct"))
-        ledger[model_id]["total"] = total
-        ledger[model_id]["correct_count"] = correct
-        ledger[model_id]["accuracy"] = correct / total if total > 0 else None
-
-    save_live_accuracy(ledger)
-    clear_dashboard_payload_cache()
-    return ledger
-
-
+def load_live_accuracy() -> dict[str, Any]:
+    """Load the live accuracy ledger from disk."""
+    default = {
+        "tomorrow": {"entries": [], "accuracy": None, "total": 0, "correct_count": 0, "backtest_count": 0, "live_count": 0},
+        "t5": {"entries": [], "accuracy": None, "total": 0, "correct_count": 0, "backtest_count": 0, "live_count": 0},
+        "tplus1": {"entries": [], "accuracy": None, "total": 0, "correct_count": 0, "backtest_count": 0, "live_count": 0},
+    }
+
+    if LIVE_ACCURACY_PATH.exists():
+        try:
+            raw = json.loads(LIVE_ACCURACY_PATH.read_text(encoding="utf-8"))
+        except Exception:
+            raw = None
+        if isinstance(raw, dict):
+            try:
+                for model_id in default:
+                    current = raw.get(model_id, {})
+                    if not isinstance(current, dict):
+                        current = {}
+                    entries = current.get("entries", [])
+                    if not isinstance(entries, list):
+                        entries = []
+                    backtest_entries = [entry for entry in entries if str(entry.get("source", "backtest")).lower() == "backtest"]
+                    live_entries = [entry for entry in entries if str(entry.get("source", "backtest")).lower() != "backtest"]
+                    total = len(entries)
+                    correct = sum(1 for e in entries if e.get("correct"))
+                    current["entries"] = entries
+                    current["backtest_count"] = int(len(backtest_entries))
+                    current["live_count"] = int(len(live_entries))
+                    current["total"] = int(total)
+                    current["correct_count"] = int(correct)
+                    current["accuracy"] = (current["correct_count"] / current["total"]) if current["total"] > 0 else None
+                    default[model_id].update(current)
+                return default
+            except Exception:
+                pass
+    return default
+
+
+def save_live_accuracy(data: dict[str, Any]) -> None:
+    """Persist the live accuracy ledger to disk."""
+    LIVE_ACCURACY_PATH.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+
+def _load_prediction_history(path: Path) -> pd.DataFrame:
+    if not path.exists():
+        return pd.DataFrame()
+    frame = pd.read_parquet(path)
+    for col in ("date", "input_date", "target_date", "forecast_date"):
+        if col in frame.columns:
+            frame[col] = pd.to_datetime(frame[col], errors="coerce")
+    sort_cols = [col for col in ("target_date", "input_date", "date", "forecast_date") if col in frame.columns]
+    if sort_cols:
+        return frame.sort_values(sort_cols).reset_index(drop=True)
+    return frame.reset_index(drop=True)
+
+
+def _record_prediction_history(path: Path, row: dict[str, Any], subset: list[str]) -> None:
+    append_prediction_history(path, row, subset)
+
+
+def _rescore_tomorrow_live_ledger(ledger: dict[str, Any]) -> bool:
+    """Fix live Tomorrow ledger entries to use close vs previous close. Returns True if modified."""
+    daily = pd.read_parquet(NIFTY_1D_PATH)
+    daily["_date"] = pd.to_datetime(daily["date"], errors="coerce").dt.normalize()
+    closes_by_date: dict[date, float] = {}
+    for _, row in daily.iterrows():
+        if pd.isna(row["_date"]):
+            continue
+        close = row.get("close")
+        if pd.notna(close) and np.isfinite(float(close)):
+            closes_by_date[row["_date"].date()] = float(close)
+
+    changed = False
+    for entry in ledger.get("tomorrow", {}).get("entries", []):
+        if str(entry.get("source", "backtest")).lower() == "backtest":
+            continue
+        try:
+            day = date.fromisoformat(str(entry.get("date", ""))[:10])
+        except Exception:
+            continue
+        day_close = closes_by_date.get(day)
+        if day_close is None:
+            continue
+        _, actual_direction = _tomorrow_actual_outcome(day, day_close, closes_by_date)
+        if actual_direction is None:
+            continue
+        pred = str(entry.get("prediction", "")).upper()
+        if pred not in {"UP", "DOWN"}:
+            continue
+        new_correct = pred == actual_direction
+        if entry.get("actual") != actual_direction or entry.get("correct") != new_correct:
+            entry["actual"] = actual_direction
+            entry["correct"] = new_correct
+            changed = True
+    return changed
+
+
+def ensure_completed_sessions_scored(
+    now: datetime | None = None,
+    ledger: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Score any completed Tomorrow sessions that have daily close data but no ledger entry."""
+    now = now or datetime.now(IST)
+    completed = expected_completed_daily_date(now)
+    if not is_trading_day(completed):
+        return ledger or load_live_accuracy()
+
+    ledger = ledger or load_live_accuracy()
+    if _rescore_tomorrow_live_ledger(ledger):
+        for model_id in ("tomorrow",):
+            entries = ledger[model_id]["entries"]
+            total = len(entries)
+            correct = sum(1 for e in entries if e.get("correct"))
+            backtest_count = sum(1 for e in entries if str(e.get("source", "backtest")).lower() == "backtest")
+            ledger[model_id]["total"] = total
+            ledger[model_id]["correct_count"] = correct
+            ledger[model_id]["backtest_count"] = backtest_count
+            ledger[model_id]["live_count"] = total - backtest_count
+            ledger[model_id]["accuracy"] = correct / total if total > 0 else None
+        save_live_accuracy(ledger)
+    logged_tom = {e["date"] for e in ledger.get("tomorrow", {}).get("entries", [])}
+    if completed.isoformat() in logged_tom:
+        return ledger
+
+    daily = pd.read_parquet(NIFTY_1D_PATH)
+    daily["_date"] = pd.to_datetime(daily["date"], errors="coerce").dt.normalize()
+    day_rows = daily[daily["_date"].dt.date == completed]
+    if day_rows.empty:
+        return ledger
+
+    day_open = float(day_rows.iloc[-1]["open"])
+    day_close = float(day_rows.iloc[-1]["close"])
+    if not (np.isfinite(day_open) and np.isfinite(day_close) and day_open != 0):
+        return ledger
+
+    return update_live_accuracy(completed)
+
+
+def update_live_accuracy(session_date: date) -> dict[str, Any]:
+    """Score today's predictions against actual outcomes and update the ledger.
+
+    Must be called AFTER refresh_daily_data() (so today's close is available)
+    but BEFORE refresh_first5_prediction / refresh_tplus1_prediction /
+    refresh_tomorrow_prediction (so the CSV files still hold the predictions
+    we want to score).
+    """
+    ledger = load_live_accuracy()
+    daily = pd.read_parquet(NIFTY_1D_PATH)
+    daily["_date"] = pd.to_datetime(daily["date"], errors="coerce").dt.normalize()
+    today_rows = daily[daily["_date"].dt.date == session_date]
+    if today_rows.empty:
+        return ledger
+
+    day_open = float(today_rows.iloc[-1]["open"])
+    day_close = float(today_rows.iloc[-1]["close"])
+    if not (np.isfinite(day_open) and np.isfinite(day_close) and day_open != 0):
+        return ledger
+    actual_close_gt_open = "UP" if day_close > day_open else "DOWN"
+    session_iso = session_date.isoformat()
+
+    # --- T+5: today's 9:20 AM prediction vs close > open ---
+    logged_t5 = {e["date"] for e in ledger["t5"]["entries"]}
+    if session_iso not in logged_t5:
+        t5_history = _load_prediction_history(T5_PREDICTION_HISTORY_PATH)
+        if not t5_history.empty and "target_date" in t5_history.columns:
+            t5_rows = t5_history[t5_history["target_date"].dt.date == session_date]
+        else:
+            t5_rows = pd.DataFrame()
+        if t5_rows.empty and LATEST_PATH.exists():
+            try:
+                t5_row = pd.read_csv(LATEST_PATH).iloc[-1].to_dict()
+                if str(t5_row.get("input_date", ""))[:10] == session_iso:
+                    t5_rows = pd.DataFrame([t5_row])
+            except Exception:
+                t5_rows = pd.DataFrame()
+        if not t5_rows.empty:
+            try:
+                t5_row = t5_rows.iloc[-1].to_dict()
+                pred = str(t5_row.get("prediction", "")).upper()
+                if pred in ("UP", "DOWN"):
+                    ledger["t5"]["entries"].append({
+                        "date": session_iso,
+                        "prediction": pred,
+                        "actual": actual_close_gt_open,
+                        "correct": pred == actual_close_gt_open,
+                        "source": "live",
+                    })
+            except Exception:
+                pass
+
+    # --- Tomorrow: prior close vs today's close (matches forecaster target) ---
+    logged_tom = {e["date"] for e in ledger["tomorrow"]["entries"]}
+    if session_iso not in logged_tom:
+        prev_day = previous_trading_day(session_date - timedelta(days=1))
+        prev_rows = daily[daily["_date"].dt.date == prev_day]
+        actual_tomorrow = None
+        if not prev_rows.empty:
+            prev_close = float(prev_rows.iloc[-1]["close"])
+            if np.isfinite(prev_close) and prev_close != 0:
+                actual_tomorrow = "UP" if day_close > prev_close else "DOWN"
+        tom_row = _find_tomorrow_prediction_for_target(session_date)
+        if tom_row and actual_tomorrow is not None:
+            try:
+                pred = str(tom_row.get("prediction", "")).upper()
+                if pred in ("UP", "DOWN"):
+                    ledger["tomorrow"]["entries"].append({
+                        "date": session_iso,
+                        "prediction": pred,
+                        "actual": actual_tomorrow,
+                        "correct": pred == actual_tomorrow,
+                        "source": "live",
+                    })
+            except Exception:
+                pass
+
+    # --- T+1: yesterday's 14:20 prediction targeting today ---
+    # T+1 target: today's close > yesterday's 14:20 close
+    logged_t1 = {e["date"] for e in ledger["tplus1"]["entries"]}
+    if session_iso not in logged_t1:
+        t1_history = _load_prediction_history(TPLUS1_PREDICTION_HISTORY_PATH)
+        if not t1_history.empty and "target_date" in t1_history.columns:
+            t1_rows = t1_history[t1_history["target_date"].dt.date == session_date]
+        else:
+            t1_rows = pd.DataFrame()
+        if not t1_rows.empty:
+            try:
+                t1_row = t1_rows.iloc[-1].to_dict()
+                pred = str(t1_row.get("prediction", "")).upper()
+                input_date_str = str(t1_row.get("input_date", ""))[:10]
+                input_day = date.fromisoformat(input_date_str)
+                # Read the 14:20 close from minute data for the input session
+                minute = pd.read_parquet(NIFTY_1M_PATH, columns=["date", "close"])
+                minute["dt"] = pd.to_datetime(minute["date"], errors="coerce")
+                minute = minute.dropna(subset=["dt"])
+                minute["session_date"] = minute["dt"].dt.normalize()
+                minute["time_str"] = minute["dt"].dt.strftime("%H:%M")
+                window = minute[
+                    (minute["session_date"].dt.date == input_day)
+                    & (minute["time_str"] >= "14:00")
+                    & (minute["time_str"] <= "14:20")
+                ].sort_values("dt")
+                if not window.empty and pred in ("UP", "DOWN"):
+                    w_close = float(window.iloc[-1]["close"])
+                    t1_actual = "UP" if day_close > w_close else "DOWN"
+                    ledger["tplus1"]["entries"].append({
+                        "date": session_iso,
+                        "prediction": pred,
+                        "actual": t1_actual,
+                        "correct": pred == t1_actual,
+                        "source": "live",
+                    })
+            except Exception:
+                pass
+
+    _rescore_tomorrow_live_ledger(ledger)
+
+    # Recompute summary stats
+    for model_id in ("t5", "tomorrow", "tplus1"):
+        entries = ledger[model_id]["entries"]
+        total = len(entries)
+        correct = sum(1 for e in entries if e.get("correct"))
+        backtest_count = sum(1 for e in entries if str(e.get("source", "backtest")).lower() == "backtest")
+        ledger[model_id]["total"] = total
+        ledger[model_id]["correct_count"] = correct
+        ledger[model_id]["backtest_count"] = backtest_count
+        ledger[model_id]["live_count"] = total - backtest_count
+        ledger[model_id]["accuracy"] = correct / total if total > 0 else None
+
+    save_live_accuracy(ledger)
+    return ledger
+
+
 def refresh_market_close_data(session_date: date | None = None) -> dict[str, Any]:
     now = datetime.now(IST)
     session_date = session_date or now.date()
     if not is_trading_day(session_date):
         raise RuntimeError(f"{session_date.isoformat()} is not an NSE trading session.")
-    save_refresh_state(REFRESH_WAITING, session_date=session_date)
     try:
-        save_refresh_state(REFRESH_REFRESHING, session_date=session_date)
         minutes = fetch_yahoo_minutes(period="7d")
         minute_frame = append_parquet_rows(NIFTY_1M_PATH, minutes, ["date"])
         daily_info = refresh_daily_data()
@@ -1533,8 +1907,6 @@ def refresh_market_close_data(session_date: date | None = None) -> dict[str, Any
         tplus1_prediction = refresh_tplus1_prediction(session_date=session_date)
         outcomes = update_opening_outcomes_from_daily()
         tomorrow_prediction = refresh_tomorrow_prediction(session_date=session_date)
-        state = save_refresh_state(REFRESH_READY, session_date=session_date)
-        clear_dashboard_payload_cache()
         return {
             "session_date": session_date.isoformat(),
             "nifty_1m_rows": int(len(minute_frame)),
@@ -1544,15 +1916,12 @@ def refresh_market_close_data(session_date: date | None = None) -> dict[str, Any
             "t5_prediction": t5_prediction.to_dict(),
             "tplus1_prediction": tplus1_prediction,
             "tomorrow_prediction": tomorrow_prediction,
-            "refresh_state": state,
         }
-    except Exception as exc:
-        save_refresh_state(REFRESH_FAILED, session_date=session_date, error=str(exc))
-        clear_dashboard_payload_cache()
+    except Exception:
         raise
 
 
-def close_refresh_due(now: datetime | None = None) -> bool:
+def close_refresh_due(now: datetime | None = None) -> bool:
     now = now or datetime.now(IST)
     if not is_trading_day(now.date()) or now.time() < CLOSE_REFRESH_READY:
         return False
@@ -1567,137 +1936,140 @@ def close_refresh_due(now: datetime | None = None) -> bool:
             tomorrow_input = date.fromisoformat(str(tomorrow_latest.get("input_date"))[:10])
     except Exception:
         tomorrow_input = None
-    return any(
-        latest != now.date()
-        for latest in (latest_daily, latest_minutes, latest_opening, latest_opening_outcome, tomorrow_input)
-    )
-
-
-def latest_prediction_input_date(path: Path) -> date | None:
-    if not path.exists():
-        return None
-    try:
-        frame = pd.read_csv(path, usecols=["input_date"])
-    except Exception:
-        return None
-    if frame.empty:
-        return None
-    value = pd.to_datetime(frame["input_date"], errors="coerce").max()
-    return None if pd.isna(value) else value.date()
-
-
-def latest_tomorrow_input_date() -> date | None:
-    try:
-        latest = latest_tomorrow_prediction()
-        raw = latest.get("input_date")
-        return date.fromisoformat(str(raw)[:10]) if raw else None
-    except Exception:
-        return None
-
-
-def expected_completed_daily_date(now: datetime | None = None) -> date:
-    now = now or datetime.now(IST)
-    if is_trading_day(now.date()) and now.time() < CLOSE_REFRESH_READY:
-        return previous_trading_day(now.date() - timedelta(days=1))
-    return previous_trading_day(now.date())
-
-
-def expected_minute_date(now: datetime | None = None) -> date:
-    now = now or datetime.now(IST)
-    if is_trading_day(now.date()) and now.time() >= FIRST5_READY:
-        return now.date()
-    return previous_trading_day(now.date() - timedelta(days=1))
-
-
-def expected_tplus1_date(now: datetime | None = None) -> date:
-    now = now or datetime.now(IST)
-    if is_trading_day(now.date()) and now.time() >= TPLUS1_READY:
-        return now.date()
-    return previous_trading_day(now.date() - timedelta(days=1))
-
-
-def is_stale(latest: date | None, expected: date) -> bool:
-    return latest is None or latest < expected
-
-
-def stale_data_status(now: datetime | None = None) -> dict[str, Any]:
-    now = now or datetime.now(IST)
-    expected_daily = expected_completed_daily_date(now)
-    expected_minutes = expected_minute_date(now)
-    expected_tplus1 = expected_tplus1_date(now)
-    latest_daily = latest_parquet_date(NIFTY_1D_PATH)
-    latest_minutes = latest_parquet_date(NIFTY_1M_PATH)
-    latest_t5 = latest_prediction_input_date(LATEST_PATH)
-    latest_tomorrow = latest_tomorrow_input_date()
-    latest_tplus1 = latest_prediction_input_date(TPLUS1_LATEST_PATH)
-    return {
-        "server_time_ist": now.isoformat(),
-        "expected_daily_date": expected_daily.isoformat(),
-        "expected_minute_date": expected_minutes.isoformat(),
-        "expected_tplus1_date": expected_tplus1.isoformat(),
-        "latest_daily_date": latest_daily.isoformat() if latest_daily else None,
-        "latest_minute_date": latest_minutes.isoformat() if latest_minutes else None,
-        "latest_t5_date": latest_t5.isoformat() if latest_t5 else None,
-        "latest_tomorrow_date": latest_tomorrow.isoformat() if latest_tomorrow else None,
-        "latest_tplus1_date": latest_tplus1.isoformat() if latest_tplus1 else None,
-        "daily_stale": is_stale(latest_daily, expected_daily),
-        "minutes_stale": is_stale(latest_minutes, expected_minutes),
-        "t5_stale": is_stale(latest_t5, expected_minutes),
-        "tomorrow_stale": is_stale(latest_tomorrow, expected_daily),
-        "tplus1_stale": is_stale(latest_tplus1, expected_tplus1),
-    }
-
-
-def refresh_stale_data_once(now: datetime | None = None) -> dict[str, Any]:
-    now = now or datetime.now(IST)
-    status = stale_data_status(now)
-    if not any(status[key] for key in ("daily_stale", "minutes_stale", "t5_stale", "tomorrow_stale", "tplus1_stale")):
-        return {"status": "fresh", **status, "actions": []}
-    if not _stale_refresh_lock.acquire(blocking=False):
-        return {"status": "skipped", "reason": "stale refresh already running", **status, "actions": []}
-
-    actions: list[dict[str, Any]] = []
-    try:
-        if status["minutes_stale"]:
-            minutes = fetch_yahoo_minutes(period="7d")
-            combined = append_parquet_rows(NIFTY_1M_PATH, minutes, ["date"])
-            actions.append(
-                {
-                    "name": "minutes",
-                    "rows": int(len(combined)),
-                    "latest_date": pd.to_datetime(combined["date"], errors="coerce").max().date().isoformat(),
-                }
-            )
-
-        if status["daily_stale"]:
-            daily_info = refresh_daily_data()
-            outcomes = update_opening_outcomes_from_daily()
-            actions.append({"name": "daily", **daily_info})
-            actions.append({"name": "opening_outcomes", **outcomes})
-
-        if status["daily_stale"] or status["tomorrow_stale"]:
-            try:
-                tomorrow = refresh_tomorrow_prediction(session_date=date.fromisoformat(status["expected_daily_date"]))
-                actions.append({"name": "tomorrow_prediction", "input_date": tomorrow.get("input_date")})
-            except Exception as exc:
-                actions.append({"name": "tomorrow_prediction", "error": str(exc)})
-
-        if status["t5_stale"] and is_trading_day(now.date()) and now.time() >= FIRST5_READY:
-            prediction = refresh_first5_prediction(session_date=now.date())
-            actions.append({"name": "t5_prediction", "input_date": prediction.input_date})
-
-        if status["tplus1_stale"] and is_trading_day(now.date()) and now.time() >= TPLUS1_READY:
-            prediction = refresh_tplus1_prediction(session_date=now.date())
-            actions.append({"name": "tplus1_prediction", "input_date": prediction.get("input_date")})
-
-        clear_dashboard_payload_cache()
-        refreshed_status = stale_data_status(datetime.now(IST))
-        return {"status": "refreshed", **refreshed_status, "actions": actions}
-    finally:
-        _stale_refresh_lock.release()
-
-
-def next_ist_run_at(run_time: time = time(9, 20), now: datetime | None = None) -> datetime:
+    return any(
+        latest != now.date()
+        for latest in (latest_daily, latest_minutes, latest_opening, latest_opening_outcome, tomorrow_input)
+    )
+
+
+def latest_prediction_input_date(path: Path) -> date | None:
+    if not path.exists():
+        return None
+    try:
+        frame = pd.read_csv(path, usecols=["input_date"])
+    except Exception:
+        return None
+    if frame.empty:
+        return None
+    value = pd.to_datetime(frame["input_date"], errors="coerce").max()
+    return None if pd.isna(value) else value.date()
+
+
+def latest_tomorrow_input_date() -> date | None:
+    try:
+        latest = latest_tomorrow_prediction()
+        raw = latest.get("input_date")
+        return date.fromisoformat(str(raw)[:10]) if raw else None
+    except Exception:
+        return None
+
+
+def expected_completed_daily_date(now: datetime | None = None) -> date:
+    now = now or datetime.now(IST)
+    if is_trading_day(now.date()) and now.time() < CLOSE_REFRESH_READY:
+        return previous_trading_day(now.date() - timedelta(days=1))
+    return previous_trading_day(now.date())
+
+
+def expected_minute_date(now: datetime | None = None) -> date:
+    now = now or datetime.now(IST)
+    if is_trading_day(now.date()) and now.time() >= FIRST5_READY:
+        return now.date()
+    return previous_trading_day(now.date() - timedelta(days=1))
+
+
+def expected_tplus1_date(now: datetime | None = None) -> date:
+    now = now or datetime.now(IST)
+    if is_trading_day(now.date()) and now.time() >= TPLUS1_READY:
+        return now.date()
+    return previous_trading_day(now.date() - timedelta(days=1))
+
+
+def is_stale(latest: date | None, expected: date) -> bool:
+    return latest is None or latest < expected
+
+
+def stale_data_status(now: datetime | None = None) -> dict[str, Any]:
+    now = now or datetime.now(IST)
+    expected_daily = expected_completed_daily_date(now)
+    expected_minutes = expected_minute_date(now)
+    expected_tplus1 = expected_tplus1_date(now)
+    latest_1d = latest_parquet_date(NIFTY_1D_PATH)
+    latest_1m = latest_parquet_date(NIFTY_1M_PATH)
+    latest_t5 = latest_prediction_input_date(LATEST_PATH)
+    latest_tomorrow = latest_tomorrow_input_date()
+    latest_tplus1 = latest_prediction_input_date(TPLUS1_LATEST_PATH)
+    return {
+        "daily_stale": expected_daily > (latest_1d or date.min),
+        "minutes_stale": expected_minutes > (latest_1m or date.min),
+        "t5_stale": is_stale(latest_t5, expected_minutes),
+        "tomorrow_stale": is_stale(latest_tomorrow, expected_daily),
+        "tplus1_stale": is_stale(latest_tplus1, expected_tplus1),
+    }
+
+
+def refresh_stale_data_once(now: datetime | None = None) -> dict[str, Any]:
+    now = now or datetime.now(IST)
+    status = stale_data_status(now)
+    if not any(status.values()):
+        return {"status": "fresh", "actions": []}
+    if not _stale_refresh_lock.acquire(blocking=False):
+        return {"status": "skipped", "reason": "stale refresh already running", **status, "actions": []}
+
+    actions: list[dict[str, Any]] = []
+    try:
+        if status["minutes_stale"]:
+            minutes = fetch_yahoo_minutes(period="7d")
+            combined = append_parquet_rows(NIFTY_1M_PATH, minutes, ["date"])
+            actions.append(
+                {
+                    "name": "minutes",
+                    "rows": int(len(combined)),
+                    "latest_date": pd.to_datetime(combined["date"], errors="coerce").max().date().isoformat(),
+                }
+            )
+
+        if status["daily_stale"]:
+            daily_info = refresh_daily_data()
+            outcomes = update_opening_outcomes_from_daily()
+            actions.append({"name": "daily", **daily_info})
+            actions.append({"name": "opening_outcomes", **outcomes})
+            try:
+                completed = date.fromisoformat(status["expected_daily_date"])
+                scored = update_live_accuracy(completed)
+                actions.append(
+                    {
+                        "name": "tomorrow_live_accuracy",
+                        "session_date": completed.isoformat(),
+                        "live_count": scored.get("tomorrow", {}).get("live_count"),
+                    }
+                )
+            except Exception as exc:
+                actions.append({"name": "tomorrow_live_accuracy", "error": str(exc)})
+
+        if status["daily_stale"] or status["tomorrow_stale"]:
+            try:
+                tomorrow = refresh_tomorrow_prediction(session_date=date.fromisoformat(status["expected_daily_date"]))
+                actions.append({"name": "tomorrow_prediction", "input_date": tomorrow.get("input_date")})
+            except Exception as exc:
+                actions.append({"name": "tomorrow_prediction", "error": str(exc)})
+
+        if status["t5_stale"] and is_trading_day(now.date()) and now.time() >= FIRST5_READY:
+            prediction = refresh_first5_prediction(session_date=now.date())
+            actions.append({"name": "t5_prediction", "input_date": prediction.input_date})
+
+        if status["tplus1_stale"] and is_trading_day(now.date()) and now.time() >= TPLUS1_READY:
+            prediction = refresh_tplus1_prediction(session_date=now.date())
+            actions.append({"name": "tplus1_prediction", "input_date": prediction.get("input_date")})
+
+        clear_dashboard_payload_cache()
+        refreshed_status = stale_data_status(datetime.now(IST))
+        return {"status": "refreshed", **refreshed_status, "actions": actions}
+    finally:
+        _stale_refresh_lock.release()
+
+
+def next_ist_run_at(run_time: time = time(9, 20), now: datetime | None = None) -> datetime:
     now = now or datetime.now(IST)
     target_day = now.date()
     if now >= datetime.combine(target_day, run_time, tzinfo=IST):