lichess-org · ornicar · Feb 24, 2026 · Feb 15, 2026 · Feb 16, 2026 · Feb 16, 2026
diff --git a/app/controllers/Tutor.scala b/app/controllers/Tutor.scala
@@ -1,94 +1,119 @@
 package controllers
 
+import play.api.data.Form
 import play.api.mvc.*
 
 import lila.app.{ *, given }
 import lila.common.LilaOpeningFamily
-import lila.core.perf.UserWithPerfs
 import lila.rating.PerfType
-import lila.tutor.{ TutorFullReport, TutorPerfReport, TutorQueue }
+import lila.tutor.{ TutorFullReport, TutorPerfReport, TutorConfig, TutorAvailability }
 
 final class Tutor(env: Env) extends LilaController(env):
 
   def home = Auth { _ ?=> me ?=>
     Redirect(routes.Tutor.user(me.username))
   }
 
-  def user(username: UserStr) = TutorPage(username) { _ ?=> user => av =>
-    Ok.page(views.tutor.home(av, user))
+  def user(username: UserStr) = Auth { _ ?=> _ ?=>
+    WithUser(username): user =>
+      renderUser(user, TutorConfig.form.default)
   }
 
-  def perf(username: UserStr, perf: PerfKey) = TutorPerfPage(username, perf) { _ ?=> user => full => perf =>
-    Ok.page(views.tutor.perf(full.report, perf, user))
+  private def renderUser(user: UserModel, form: Form[?])(using Context) =
+    for
+      withPerfs <- env.user.api.withPerfs(user)
+      av <- env.tutor.api.availability(withPerfs)
+      res <- av match
+        case TutorAvailability.InsufficientGames =>
+          Ok.page(views.tutor.home.insufficientGames(user.id))
+        case TutorAvailability.Available(home) =>
+          home.previews.headOption.ifTrue(getBool("waiting") && home.awaiting.isEmpty) match
+            case Some(done) => Redirect(done.config.url.root).toFuccess
+            case None => Ok.page(views.tutor.home(home, form))
+    yield res
+
+  def report(username: UserStr, range: String) = TutorReport(username, range) { _ ?=> full =>
+    Ok.page(views.tutor.report(full))
+  }
+
+  def perf(username: UserStr, range: String, perf: PerfKey) = TutorPerfPage(username, range, perf) {
+    _ ?=> full => perf =>
+      Ok.page(views.tutor.perf(full, perf))
   }
 
-  def angle(username: UserStr, perf: PerfKey, angle: String) = TutorPerfPage(username, perf) {
-    _ ?=> user => full => perf =>
+  def angle(username: UserStr, range: String, perf: PerfKey, angle: String) =
+    TutorPerfPage(username, range, perf) { _ ?=> full => perf =>
       angle match
-        case "skills" => Ok.page(views.tutor.perf.skills(full.report, perf, user))
-        case "phases" => Ok.page(views.tutor.perf.phases(full.report, perf, user))
-        case "time" => Ok.page(views.tutor.perf.time(full.report, perf, user))
-        case "pieces" => Ok.page(views.tutor.perf.pieces(full.report, perf, user))
-        case "opening" => Ok.page(views.tutor.openingUi.openings(full.report, perf, user))
+        case "skills" => Ok.page(views.tutor.perf.skills(full, perf))
+        case "phases" => Ok.page(views.tutor.perf.phases(full, perf))
+        case "time" => Ok.page(views.tutor.perf.time(full, perf))
+        case "pieces" => Ok.page(views.tutor.perf.pieces(full, perf))
+        case "opening" => Ok.page(views.tutor.openingUi.openings(full, perf))
         case _ => notFound
-  }
+    }
 
-  def opening(username: UserStr, perf: PerfKey, color: Color, opName: String) =
-    TutorPerfPage(username, perf) { _ ?=> user => full => perf =>
+  def opening(username: UserStr, range: String, perf: PerfKey, color: Color, opName: String) =
+    TutorPerfPage(username, range, perf) { _ ?=> full => perf =>
       LilaOpeningFamily
         .find(opName)
         .flatMap(perf.openings(color).find)
-        .fold(Redirect(routes.Tutor.angle(user.username, perf.perf.key, "openings")).toFuccess): family =>
+        .fold(Redirect(full.url.angle(perf.perf, "opening")).toFuccess): family =>
           env.puzzle.opening.find(family.family.key).flatMap { puzzle =>
-            Ok.page(views.tutor.opening(full.report, perf, family, color, user, puzzle))
+            Ok.page(views.tutor.opening(full, perf, family, color, puzzle))
           }
     }
 
-  def refresh(username: UserStr) = TutorPageAvailability(username) { _ ?=> user => availability =>
-    env.tutor.api.request(user, availability).inject(redirHome(user))
+  def compute(username: UserStr) = AuthBody { _ ?=> _ ?=>
+    WithUser(username): user =>
+      bindForm(TutorConfig.form.dates)(
+        err => renderUser(user, err),
+        dates =>
+          val config = dates.config(user.id)
+          env.tutor.api
+            .get(config)
+            .flatMap:
+              case Some(report) => Redirect(report.url.root).toFuccess
+              case None =>
+                for _ <- env.tutor.queue.enqueue(config)
+                yield Redirect(routes.Tutor.user(user.username))
+      )
   }
 
-  private def TutorPageAvailability(
-      username: UserStr
-  )(f: Context ?=> UserModel => TutorFullReport.Availability => Fu[Result]): EssentialAction =
-    Auth { _ ?=> me ?=>
-      def proceed(user: UserWithPerfs) = env.tutor.api.availability(user).flatMap(f(user.user))
-      if me.is(username) then env.user.api.withPerfs(me.value).flatMap(proceed)
+  def delete(username: UserStr, range: String) = TutorReport(username, range) { _ ?=> full =>
+    for _ <- env.tutor.api.delete(full.config)
+    yield Redirect(routes.Tutor.user(username))
+  }
+
+  private def WithUser(username: UserStr)(f: UserModel => Fu[Result])(using
+      me: Me
+  )(using Context): Fu[Result] =
+    val user: Fu[Option[UserModel]] =
+      if me.is(username) then fuccess(me.some)
       else
-        Found(env.user.api.withPerfs(username)): user =>
-          if isGranted(_.SeeInsight) then proceed(user)
-          else
-            user.enabled.yes
-              .so(env.clas.api.clas.isTeacherOf(me, user.id))
-              .flatMap:
-                if _ then proceed(user) else notFound
-    }
+        env.user.api
+          .byId(username.id)
+          .flatMapz: user =>
+            for canSee <- fuccess(isGranted(_.SeeInsight)) >>|
+                user.enabled.yes.so(env.clas.api.clas.isTeacherOf(me, user.id))
+            yield Option.when(canSee)(user)
+    Found(user)(f)
 
-  private def TutorPage(
-      username: UserStr
-  )(f: Context ?=> UserModel => TutorFullReport.Available => Fu[Result]): EssentialAction =
-    TutorPageAvailability(username) { _ ?=> user => availability =>
-      availability match
-        case TutorFullReport.InsufficientGames =>
-          BadRequest.page(views.tutor.home.empty.insufficientGames(user))
-        case TutorFullReport.Empty(in: TutorQueue.InQueue) =>
-          for
-            waitGames <- env.tutor.queue.waitingGames(user)
-            user <- env.user.api.withPerfs(user)
-            page <- renderPage(views.tutor.home.empty.queued(in, user, waitGames))
-          yield Accepted(page)
-        case TutorFullReport.Empty(_) => Accepted.page(views.tutor.home.empty.start(user))
-        case available: TutorFullReport.Available => f(user)(available)
+  private def TutorReport(username: UserStr, range: String)(
+      f: Context ?=> TutorFullReport => Fu[Result]
+  ): EssentialAction =
+    Auth { _ ?=> _ ?=>
+      WithUser(username): _ =>
+        TutorConfig
+          .parse(username.id, range)
+          .so(env.tutor.api.get)
+          .flatMap:
+            case None => Redirect(routes.Tutor.user(username)).toFuccess
+            case Some(full) => f(full)
     }
 
-  private def TutorPerfPage(username: UserStr, perf: PerfKey)(
-      f: Context ?=> UserModel => TutorFullReport.Available => TutorPerfReport => Fu[Result]
+  private def TutorPerfPage(username: UserStr, range: String, perf: PerfKey)(
+      f: Context ?=> TutorFullReport => TutorPerfReport => Fu[Result]
   ): EssentialAction =
-    TutorPage(username) { _ ?=> user => availability =>
-      availability match
-        case full @ TutorFullReport.Available(report, _) =>
-          report(perf).fold(redirHome(user).toFuccess):
-            f(user)(full)
+    TutorReport(username, range) { _ ?=> full =>
+      full(perf).fold(Redirect(full.url.root).toFuccess)(f(full))
     }
-
-  private def redirHome(user: UserModel) = Redirect(routes.Tutor.user(user.username))
diff --git a/app/views/tutor.scala b/app/views/tutor.scala
@@ -4,15 +4,17 @@ import lila.app.UiEnv.{ *, given }
 
 val bits = lila.tutor.ui.TutorBits(helpers)(views.opening.bits.openingUrl)
 val perf = lila.tutor.ui.TutorPerfUi(helpers, bits)
-val home = lila.tutor.ui.TutorHome(helpers, bits, perf)
+val queue = lila.tutor.ui.TutorQueueUi(helpers, bits)
+val reports = lila.tutor.ui.TutorReportsUi(helpers, bits)
+val report = lila.tutor.ui.TutorReportUi(helpers, bits, perf)
+val home = lila.tutor.ui.TutorHomeUi(helpers, bits, queue, reports)
 val openingUi = lila.tutor.ui.TutorOpening(helpers, bits, perf)
 
 def opening(
     full: lila.tutor.TutorFullReport,
     perfReport: lila.tutor.TutorPerfReport,
     report: lila.tutor.TutorOpeningFamily,
     as: Color,
-    user: User,
     puzzle: Option[lila.puzzle.PuzzleOpening.FamilyWithCount]
 )(using Context) =
   val puzzleFrag = puzzle.map: p =>
@@ -21,4 +23,4 @@ def opening(
       dataIcon := Icon.ArcheryTarget,
       href := routes.Puzzle.angleAndColor(p.family.key.value, as.name)
     )("Train with puzzles")
-  openingUi.opening(full, perfReport, report, as, user, puzzleFrag)
+  openingUi.opening(full, perfReport, report, as, puzzleFrag)
diff --git a/bin/mongodb/indexes.js b/bin/mongodb/indexes.js
@@ -328,7 +328,7 @@ db.kaladin_queue.createIndex(
   { partialFilterExpression: { 'response.at': { $exists: true } } },
 );
 db.tutor_queue.createIndex({ requestedAt: 1 });
-db.tutor_report.createIndex({ at: -1 });
+db.tutor_report.createIndex({ 'config.user': 1, at: -1 });
 
 // you may want to run these on the puzzle database
 db.puzzle2_round.createIndex({ p: 1 }, { partialFilterExpression: { t: { $exists: true } } });

diff --git a/bin/mongodb/insight-tutor-test.js b/bin/mongodb/insight-tutor-test.js
diff --git a/bin/mongodb/tutor-dates.js b/bin/mongodb/tutor-dates.js
@@ -0,0 +1,22 @@
+const printDate = d => d.toISOString().split('T')[0];
+db.tutor_report.find({ config: { $exists: 0 } }).forEach(old => {
+  let minDate = new Date();
+  let maxDate = new Date('2023-01-01');
+  old.perfs.forEach(perf => {
+    const dates = perf.stats.dates;
+    if (dates[0] < minDate) minDate = dates[0];
+    if (dates[1] > maxDate) maxDate = dates[1];
+  });
+  const report = {
+    ...old,
+    _id: `${old.user}:${printDate(minDate)}_${printDate(maxDate)}`,
+    config: {
+      user: old.user,
+      from: minDate,
+      to: maxDate,
+    },
+  };
+  delete report.user;
+  db.tutor_report.insertOne(report);
+  db.tutor_report.deleteOne({ _id: old._id });
+});
diff --git a/conf/routes b/conf/routes
@@ -854,11 +854,13 @@ POST  /account/signout/:sessionId      controllers.Account.signout(sessionId)
 GET   /account/now-playing             controllers.Account.nowPlaying
 
 GET   /tutor                           controllers.Tutor.home()
-GET   /tutor/:username                 controllers.Tutor.user(username: UserStr)
-POST  /tutor/:username/refresh         controllers.Tutor.refresh(username: UserStr)
-GET   /tutor/:username/:perf           controllers.Tutor.perf(username: UserStr, perf: PerfKey)
-GET   /tutor/:username/:perf/:angle    controllers.Tutor.angle(username: UserStr, perf: PerfKey, angle)
-GET   /tutor/:username/:perf/opening/:color/:opening controllers.Tutor.opening(username: UserStr, perf: PerfKey, color: Color, opening)
+GET   /tutor/:user                     controllers.Tutor.user(user: UserStr)
+POST  /tutor/:user/compute             controllers.Tutor.compute(user: UserStr)
+GET   /tutor/:user/:range              controllers.Tutor.report(user: UserStr, range)
+POST  /tutor/:user/delete              controllers.Tutor.delete(user: UserStr, range)
+GET   /tutor/:user/:range/:perf        controllers.Tutor.perf(user: UserStr, range, perf: PerfKey)
+GET   /tutor/:user/:range/:perf/:angle controllers.Tutor.angle(user: UserStr, range, perf: PerfKey, angle)
+GET   /tutor/:user/:range/:perf/opening/:color/:opening controllers.Tutor.opening(user: UserStr, range, perf: PerfKey, color: Color, opening: String)
 
 # Recap
 GET   /recap                           controllers.Recap.home

diff --git a/modules/activity/src/main/Activity.scala b/modules/activity/src/main/Activity.scala
@@ -25,7 +25,7 @@ case class Activity(
     stream: Boolean = false
 ):
 
-  def date = id.day.toDate
+  def date = id.day.toInstant
 
   def interval = TimeInterval(date, date.plusDays(1))
 

diff --git a/modules/common/src/main/LichessDay.scala b/modules/common/src/main/LichessDay.scala
@@ -5,7 +5,7 @@ opaque type LichessDay = Int
 
 object LichessDay extends OpaqueInt[LichessDay]:
 
-  extension (day: LichessDay) def toDate = genesis.plusDays(day).withTimeAtStartOfDay
+  extension (day: LichessDay) def toInstant: Instant = genesis.plusDays(day).withTimeAtStartOfDay
 
   val genesis: Instant = instantOf(2010, 1, 1, 0, 0).withTimeAtStartOfDay
 

diff --git a/modules/core/src/main/perf.scala b/modules/core/src/main/perf.scala
@@ -106,12 +106,7 @@ object perf:
   trait PerfStatApi:
     def highestRating(user: UserId, perfKey: PerfKey): Fu[Option[IntRating]]
 
-  case class Perf(
-      glicko: Glicko,
-      nb: Int,
-      recent: List[IntRating],
-      latest: Option[Instant]
-  ):
+  case class Perf(glicko: Glicko, nb: Int, recent: List[IntRating], latest: Option[Instant]):
     export glicko.{ intRating, intDeviation, provisional }
     export latest.{ isEmpty, nonEmpty }
 

diff --git a/modules/game/src/main/GameRepo.scala b/modules/game/src/main/GameRepo.scala
@@ -76,7 +76,7 @@ final class GameRepo(c: Coll)(using Executor) extends lila.core.game.GameRepo(c)
       .dmap:
         _.flatMap(Pov(_, user))
 
-  def recentPovsByUserFromSecondary(user: User, nb: Int, select: Bdoc = $empty): Fu[List[Pov]] =
+  def recentPovsByUserFromSecondary[U: UserIdOf](user: U, nb: Int, select: Bdoc = $empty): Fu[List[Pov]] =
     recentGamesFromSecondaryCursor(Query.user(user) ++ select)
       .list(nb)
       .map { _.flatMap(Pov(_, user)) }

diff --git a/modules/insight/src/main/InsightPerfStatsApi.scala b/modules/insight/src/main/InsightPerfStatsApi.scala
@@ -26,6 +26,7 @@ final class InsightPerfStatsApi(
 
   def apply(
       user: User,
+      period: PairOf[Instant],
       perfTypes: List[PerfType],
       gameIdsPerPerf: Max
   ): Fu[Map[PerfType, InsightPerfStats.WithGameIds]] =
@@ -34,7 +35,10 @@ final class InsightPerfStatsApi(
         import framework.*
         import InsightEntry.BSONFields as F
         val filters = List(lila.insight.Filter(InsightDimension.Perf, perfTypes))
-        Match(InsightStorage.selectUserId(user.id) ++ pipeline.gameMatcher(filters)) -> List(
+        val gameSelector = InsightStorage.selectUserId(user.id) ++
+          pipeline.gameMatcher(filters) ++
+          dateBetween(F.date, period._1.some, period._2.some)
+        Match(gameSelector) -> List(
           Sort(Descending(F.date)),
           Limit(maxGames.value),
           Project(

diff --git a/modules/insight/src/main/PeersRatingRange.scala b/modules/insight/src/main/PeersRatingRange.scala
@@ -9,12 +9,10 @@ object PeersRatingRange extends TotalWrapper[PeersRatingRange, PairOf[IntRating]
 
   private val distribution =
     // > db.insight.estimatedDocumentCount()
-    // 2853219252
+    // 2301257568
     // > db.insight.aggregate([{$sample:{size:50000000}},{$project:{_id:0,mr:1}},{$match:{mr:{$exists:1}}},{$group:{_id:null,ratings:{$avg:'$mr'}}}])
-    // { "_id" : null, "ratings" : 1823.3090773968 }
     // > db.insight.aggregate([{$sample:{size:50000000}},{$project:{_id:0,mr:1}},{$match:{mr:{$exists:1}}},{$group:{_id:null,ratings:{$stdDevSamp:'$mr'}}}])
-    // { "_id" : null, "ratings" : 364.74285981482296 }
-    lila.rating.Gaussian(1823.31, 364.74d)
+    lila.rating.Gaussian(1804.45, 368.24d)
 
   private val minRating = Glicko.minRating
   private val maxRating = IntRating(3200)

diff --git a/modules/insight/src/main/package.scala b/modules/insight/src/main/package.scala
@@ -5,5 +5,5 @@ export lila.common.extensions.*
 
 private val logger = lila.log("insight")
 
-val maxGames = Max(10_000)
+val maxGames = Max(15_000)
 val minDate = instantOf(2023, 1, 1, 0, 0)
diff --git a/modules/storm/src/main/StormJson.scala b/modules/storm/src/main/StormJson.scala
@@ -38,7 +38,7 @@ object StormJson:
   private val dateFormatter = java.time.format.DateTimeFormatter.ofPattern("Y/M/d")
 
   given Writes[StormDay.Id] = Writes { id =>
-    JsString(dateFormatter.print(id.day.toDate))
+    JsString(dateFormatter.print(id.day.toInstant))
   }
   given OWrites[StormDay] = Json.writes
 

diff --git a/modules/storm/src/main/ui/StormUi.scala b/modules/storm/src/main/ui/StormUi.scala
@@ -99,7 +99,7 @@ final class StormUi(helpers: Helpers):
               tbody(cls := "infinite-scroll")(
                 history.currentPageResults.map { day =>
                   tr(
-                    td(showDate(day._id.day.toDate)),
+                    td(showDate(day._id.day.toInstant)),
                     td(numberTag(cls := "score")(day.score)),
                     td(numberTag(day.moves)),
                     td(numberTag(f"${day.accuracyPercent}%1.1f"), "%"),