Pre-push review: feature/update-schedule

diff --git a/Asterism/Asterism/ContentView.swift b/Asterism/Asterism/ContentView.swiftindex 7d678e4..c511ae7 100644--- a/Asterism/Asterism/ContentView.swift+++ b/Asterism/Asterism/ContentView.swift@@ -82,8 +82,8 @@ struct ContentView: View {     /// but the Mac: Req 7.2 leaves the iPad's launch behaviour alone, so the     /// mirror and the restore are both gated on `RuntimePlatform.isMac` rather     /// than forked with a conditional that would have to wrap four modifiers.-    @AppStorage(RestoreStorageKey.selectedTab) private var storedTab = AppTab.recent.rawValue-    @AppStorage(RestoreStorageKey.selectedRecentEntryID) private var storedRecentEntryID = ""+    @AppStorage(RestoreStorageKey.selectedTab) private var storedTab = AppTab.today.rawValue+    @AppStorage(RestoreStorageKey.selectedTodayEntryID) private var storedTodayEntryID = ""     @AppStorage(RestoreStorageKey.selectedWorkID) private var storedWorkID = ""      /// Whether the stored place has been read back. Once, at the first@@ -331,9 +331,9 @@ struct ContentView: View {             guard RuntimePlatform.isMac else { return }             storedTab = tab.rawValue         }-        .onChange(of: navigation.selectedRecentEntryID) { _, entryID in+        .onChange(of: navigation.selectedTodayEntryID) { _, entryID in             guard RuntimePlatform.isMac else { return }-            storedRecentEntryID = entryID?.uuidString ?? ""+            storedTodayEntryID = entryID?.uuidString ?? ""         }         .onChange(of: navigation.selectedWorkID) { _, workID in             guard RuntimePlatform.isMac else { return }@@ -344,6 +344,18 @@ struct ContentView: View {         .onChange(of: model.snapshotGeneration) { _, _ in             pruneRestoredSelection()         }+        // `update-schedule` Req 3.7: the current day moved, so a selection that+        // *was* the current day moves with it.+        //+        // **Here, not on the Today screen.** This view is alive whatever tab or+        // tree is showing; `TodayView` is not. A midnight crossed while the+        // reader is on Works, or with the wide tree's Works pane up, would+        // otherwise leave the selection on a day that is no longer current and+        // no longer the day that had been.+        .onChange(of: model.currentDay) { previous, current in+            navigation.normalizeTodaySelection(+                previousCurrentDay: previous, newCurrentDay: current)+        }         // Req 5.6: held suggestions are cheap to recompute and are the first         // thing to go under memory pressure — held proposals likewise, their         // revisions are not covered until a decision commits (Q61). The monitor@@ -424,8 +436,8 @@ struct ContentView: View {     private func restoreSelection() {         guard RuntimePlatform.isMac, !hasRestoredSelection else { return }         hasRestoredSelection = true-        navigation.selectedTab = AppTab(rawValue: storedTab) ?? .recent-        navigation.selectedRecentEntryID = UUID(uuidString: storedRecentEntryID)+        navigation.selectedTab = AppTab(rawValue: storedTab) ?? .today+        navigation.selectedTodayEntryID = UUID(uuidString: storedTodayEntryID)         navigation.restoreWorksSelection(UUID(uuidString: storedWorkID))     } @@ -454,7 +466,7 @@ struct ContentView: View {                 // the whole library first. Searching the groups in place stops                 // at the first hit and allocates nothing (the trap Req 8.1 of                 // `stats-page` records, and `ListDetailPane` again).-                model.recentPresentation.groups.contains { group in+                model.todayPresentation.groups.contains { group in                     group.rows.contains { $0.id == entryID }                 }             },@@ -493,7 +505,7 @@ struct ContentView: View {             // One write, at the top of the window rather than on each screen             // `AppScreens` builds. Both trees declare their             // `navigationDestination`s *outside* those screens — entry detail is-            // pushed from `screens.recent()`'s call site, not from inside it —+            // pushed from `screens.today()`'s call site, not from inside it —             // so a per-screen write would miss a surface on the list. From here             // it reaches both trees, everything they push, and the sheets, which             // inherit the presenting view's environment.@@ -693,7 +705,9 @@ struct ContentView: View {     private var exportSubject: MarkdownExportModel.Subject? {         NavigationActions.exportSubject(             tab: navigation.selectedTab,-            recentEntryID: navigation.selectedRecentEntryID,+            todayEntryID: navigation.selectedTodayEntryID,+            todayWorkID: navigation.workID(on: .today),+            todayChapterEntryID: navigation.chapterEntryID(on: .today),             workID: navigation.selectedWorkID,             worksEntryID: navigation.selectedWorksEntryID,             workChapterEntryID: navigation.selectedWorkChapterEntryID)@@ -783,7 +797,7 @@ struct ContentView: View {     /// The Settings sheet's dismissal hook. The workload is read here, at the     /// moment the route is taken, rather than captured when the sheet opened.     private func takePendingRoute() {-        navigation.takePendingRoute(in: model.recentPresentation.duplicateWorkload)+        navigation.takePendingRoute(in: model.todayPresentation.duplicateWorkload)     } } 

diff --git a/Asterism/Asterism/Layout/AppNavigation.swift b/Asterism/Asterism/Layout/AppNavigation.swiftindex 3d12d7d..3d72b02 100644--- a/Asterism/Asterism/Layout/AppNavigation.swift+++ b/Asterism/Asterism/Layout/AppNavigation.swift@@ -8,7 +8,11 @@ import SwiftUI /// `nonisolated` because the app target defaults to main-actor isolation and a /// main-actor `Hashable` conformance is rejected outright. nonisolated enum AppTab: String, CaseIterable, Hashable, Sendable {-    case recent+    /// `update-schedule` Req 3.1. It was `.recent`, and the raw value moved with+    /// the case: a Mac holding `"recent"` in `@AppStorage` now resolves to nil+    /// and falls back to the default tab, which is this one — the tab is in the+    /// same position, so the reader lands where they were left.+    case today     /// `specs/stats-page/` Decision 2. The third tab falsifies the two-tab     /// shape three documents state; task 16 of that spec annotates each.     case works@@ -19,16 +23,16 @@ nonisolated enum AppTab: String, CaseIterable, Hashable, Sendable {     /// this string.     var title: String {         switch self {-        case .recent: "Recent"+        case .today: "Today"         case .works: "Works"         case .stats: "Stats"         }     } -    /// §8's glyphs: ◷ Recent, ✦ Works, `chart.bar` Stats.+    /// §8's glyphs: a calendar for Today, ✦ Works, `chart.bar` Stats.     var systemImage: String {         switch self {-        case .recent: "clock"+        case .today: "calendar"         case .works: "sparkles"         case .stats: "chart.bar"         }@@ -38,6 +42,42 @@ nonisolated enum AppTab: String, CaseIterable, Hashable, Sendable {     var sidebarIdentifier: String { "sidebar-\(rawValue)" } } +// MARK: - The two route stacks++/// Which typed route stack an operation acts on (`update-schedule` Q38).+///+/// Today has a stack of its own because a release row opens the work *on Today*+/// — Back returns to the selected day rather than to the Works list, and the+/// wide tree's detail column needs a stack anyway for the chapter, series and+/// creator taps inside that work to work at all.+nonisolated enum RouteStack: Hashable, Sendable {+    case works+    case today+}++/// Which day the Today screen is showing (`update-schedule` Q32).+///+/// `.current` resolves to the current civil day *at display time*, so a day+/// change moves the selection with nothing to bookkeep; `.day(_)` stays where+/// the reader put it. A `CivilDay` survives a time-zone change as the same+/// calendar date, which a `startOfDay` instant would not (Req 3.7).+nonisolated enum TodaySelection: Equatable, Sendable {+    case current+    case day(CivilDay)++    /// Which day this selection *is*, against the day that is current now.+    ///+    /// One resolution, here: `AppNavigation`, the screen and the wide tree's+    /// column heading all ask the same question, and three copies of a two-arm+    /// switch are three places for "which day is shown" to drift.+    func day(currentDay: CivilDay) -> CivilDay {+        switch self {+        case .current: currentDay+        case .day(let day): day+        }+    }+}+ /// Every piece of navigation state the app has, and the routes that move it. /// /// **Why it is not `ContentView`'s `@State` any more (Q14, Q21).** Two things@@ -61,9 +101,23 @@ nonisolated enum AppTab: String, CaseIterable, Hashable, Sendable { final class AppNavigation {     // MARK: - Tab and selection -    var selectedTab: AppTab = .recent+    var selectedTab: AppTab = .today -    var selectedRecentEntryID: UUID?+    var selectedTodayEntryID: UUID?++    /// Which day Today is showing (Q32). Not view state: it has to survive a+    /// push and a tab switch, and `.current` is Req 3.7's "the day that had been+    /// current" with no clock bookkeeping at all.+    var todaySelection: TodaySelection = .current++    /// Today's own typed route stack (Q38).+    ///+    /// The same vocabulary the Works tab's stack speaks — a release row opens a+    /// work, that work's related works and series and creators open from it —+    /// but a stack of its own, so Back from a pushed work returns to the+    /// selected day. **Never restored** (Q42): a pushed work on Today is a place+    /// the reader passes through, not one they are left on.+    var todayPath: [WorksRoute] = []      /// The entry the Works *list* opened — the unattached-notes group's route.     /// Its destination is declared at the stack root, which is where it is@@ -99,7 +153,7 @@ final class AppNavigation {     /// routing. A `.chapter` rides on its work, so the answer does not change     /// while a chapter is open — which is what keeps the work's row marked in     /// the list column beside it (Req 1.5).-    var selectedWorkID: UUID? { worksPath.compactMap(\.workID).last }+    var selectedWorkID: UUID? { workID(on: .works) }      /// The chapter entry showing over its work, or nil.     ///@@ -109,9 +163,7 @@ final class AppNavigation {     /// cannot arise. In the **wide** tree it is not a push at all (Q57): the     /// detail column switches its content from the work to the chapter and     /// back. Same route, two arrangements.-    var selectedWorkChapterEntryID: UUID? {-        if case .chapter(let entryID) = worksPath.last { entryID } else { nil }-    }+    var selectedWorkChapterEntryID: UUID? { chapterEntryID(on: .works) }      /// The work row the Works list marks as selected (Req 1.5, and Req 3.6 of     /// `specs/series-and-related-works`).@@ -137,7 +189,7 @@ final class AppNavigation {     /// and creator routes are appends — so `.work` is the arm that has to ask,     /// and it is exactly `pushWork` (from a series member row or a creator's     /// work row) that puts one on top of another route.-    var hasRouteBeneathWorksTop: Bool { worksPath.count > 1 }+    var hasRouteBeneathWorksTop: Bool { hasRouteBeneathTop(on: .works) }      /// What the Works detail column is showing, as one comparable value.     ///@@ -146,17 +198,80 @@ final class AppNavigation {     /// series routes, of which only one carries an id. The unattached-note route     /// is not on the path, so it joins here rather than being a fourth read at     /// the call site.-    var worksDetailSubject: WorksDetailSubject? {-        if let route = worksPath.last { return .route(route) }-        return selectedWorksEntryID.map(WorksDetailSubject.entry)+    var worksDetailSubject: WorksDetailSubject? { detailSubject(on: .works) }++    // MARK: - The stacks, asked by name++    /// The routes on one stack.+    func path(on stack: RouteStack) -> [WorksRoute] {+        switch stack {+        case .works: worksPath+        case .today: todayPath+        }+    }++    /// The last `.work` on a stack — what that tab is *about*.+    func workID(on stack: RouteStack) -> UUID? {+        path(on: stack).compactMap(\.workID).last+    }++    /// The chapter entry showing over its work on a stack, or nil.+    func chapterEntryID(on stack: RouteStack) -> UUID? {+        if case .chapter(let entryID) = path(on: stack).last { entryID } else { nil }     } -    /// Req 3.2 of `specs/polish-and-export`: the Works query is `@State` inside-    /// `WorksView` and survives a tab switch, so the footer's route would-    /// otherwise land the reader on a filtered list that also hides Unattached-    /// Notes. Bumping this token rebuilds `WorksView` with its query back at-    /// `""`.-    var worksResetToken = 0+    /// Whether the route on top of a stack has another route under it — the wide+    /// tree's one question about depth (`work-creators` Q77).+    func hasRouteBeneathTop(on stack: RouteStack) -> Bool { path(on: stack).count > 1 }++    /// What a stack's detail column is showing, as one comparable value:+    /// the chapter, then the work, then the entry the *list* opened.+    func detailSubject(on stack: RouteStack) -> WorksDetailSubject? {+        if let route = path(on: stack).last { return .route(route) }+        return selectedEntryID(on: stack).map(WorksDetailSubject.entry)+    }++    /// The entry a stack's list opened, which is not a route on the path.+    private func selectedEntryID(on stack: RouteStack) -> UUID? {+        switch stack {+        case .works: selectedWorksEntryID+        case .today: selectedTodayEntryID+        }+    }++    /// One stack's routes as a **place** rather than a reader and a writer.+    ///+    /// Every operation below is "take the array, change it, put it back", which+    /// was written out six times over two stored properties. Through a subscript+    /// each one is the mutation it actually is, and the stack it names is stated+    /// once instead of three times.+    private subscript(routes stack: RouteStack) -> [WorksRoute] {+        get { path(on: stack) }+        set {+            switch stack {+            case .works: worksPath = newValue+            case .today: todayPath = newValue+            }+        }+    }++    /// What entering a stack clears.+    ///+    /// The Works stack is a *tab*, so a route onto it switches to that tab and+    /// drops the unattached-note route the list had opened. A `.today` route+    /// never touches `selectedTab` or `selectedWorksEntryID` — the reader is+    /// already on Today, and the other tab's selection is not this one's to+    /// clear — but it does clear Today's own entry selection, which is Req+    /// 10.1's "selecting either kind clears the other".+    private func enter(_ stack: RouteStack) {+        switch stack {+        case .works:+            selectedTab = .works+            selectedWorksEntryID = nil+        case .today:+            selectedTodayEntryID = nil+        }+    }      // MARK: - Sheets @@ -165,7 +280,7 @@ final class AppNavigation {     var showingSettings = false     var showingTeachingForEntryID: UUID? -    /// Req 4.1's route, pushed onto Recent's own stack rather than presented:+    /// Req 4.1's route, pushed onto Today's own list stack rather than presented:     /// the re-teach route it offers is a sheet, and a sheet over a sheet cannot     /// be presented from there.     var showingDiagnostics = false@@ -241,11 +356,11 @@ final class AppNavigation {      /// The sidebar's actionable banner (Req 1.3).     ///-    /// A token, for `searchFocusRequest`'s reason. The banner Recent draws+    /// A token, for `searchFocusRequest`'s reason. The banner Today draws     /// *filters the list to the actionable rows*; the sidebar shows the same     /// banner with the same words, so it has to do the same thing rather than     /// merely switch tab and leave the reader to find the entries themselves.-    /// The filter itself stays `RecentView`'s `@State` — it is a property of+    /// The filter itself stays `TodayView`'s `@State` — it is a property of     /// that list, not of the app's navigation — so what crosses is a request,     /// not the flag.     var actionableFilterRequest = 0@@ -259,26 +374,20 @@ final class AppNavigation {         sidebarVisibility = sidebarVisibility == .detailOnly ? .all : .detailOnly     } -    /// What the sidebar's banner does: Recent, filtered to the rows it counted.+    /// What the sidebar's banner does: Today, filtered to the rows it counted.     func showActionableEntries() {-        selectedTab = .recent+        selectedTab = .today         actionableFilterRequest += 1     }      // MARK: - Routes -    /// Req 3.2's route out of Recent's truncation footer: the Works section at-    /// its root, with no search filter applied.-    ///-    /// The stack is emptied explicitly rather than left to cascade on the next-    /// update — the reader asked to be at the root, and a push that unwinds one-    /// turn later is not that.-    func showWorksRoot() {-        selectedTab = .works-        selectedWorksEntryID = nil-        worksPath = []-        worksResetToken += 1-    }+    // There is deliberately no `showWorksRoot()` here any more, and no+    // `worksResetToken` beside it. Its one route was Recent's truncation+    // footer, which went with the row cap (`update-schedule` Q24, Q33) — and an+    // operation nothing calls is a rule nothing keeps: it survived the cap by+    // one task only because it was thought worth stating. A future route out of+    // Today that means "the Works list, query and all" writes it then.      /// Open a work as the Works stack's whole content: the Works *list* is this     /// stack's root, and this is the route taken from it and from outside the@@ -292,14 +401,26 @@ final class AppNavigation {     /// left behind rather than on the list. ``pushWork(_:)`` is the append, for     /// the routes that are opened *from* a screen already on the stack.     ///-    /// No `worksResetToken` bump, unlike `showWorksRoot()`: this route names a-    /// destination rather than asking for the root, so rebuilding `WorksView`-    /// and discarding its query and scroll position would take Req 1.3's promise-    /// with it.-    func showWork(_ workID: UUID) {-        selectedTab = .works-        selectedWorksEntryID = nil-        worksPath = [.work(workID)]+    /// It names a destination rather than asking for the root, so it leaves+    /// `WorksView` standing: rebuilding it and discarding its query and scroll+    /// position would take Req 1.3's promise with it.+    ///+    /// **The same route on either stack.** A release row tapped in Today's day+    /// list makes the work Today's whole stack for exactly the reasons above+    /// (Req 10.1): in the wide tree that list stays beside the detail column, so+    /// a second release row would otherwise stack a second work on the first and+    /// grow a "Back to {first work}" button over a list the reader never left.+    /// What ``enter(_:)`` clears differs per stack and is stated there — a+    /// `.today` route is not the Works tab's business and does not touch it.+    ///+    /// **Q38 is untouched.** It is about the routes taken *inside* a pushed+    /// work — a related work, a series, a creator — and those still append+    /// through ``pushWork(_:on:)``, which is what makes Back return to the+    /// screen they were opened from. This is the route from the list at the+    /// stack's root, which has nothing to go back to but the list.+    func showWork(_ workID: UUID, on stack: RouteStack = .works) {+        enter(stack)+        self[routes: stack] = [.work(workID)]     }      /// Open a work *from* a screen already on the Works stack — a series member@@ -309,12 +430,15 @@ final class AppNavigation {     /// A trailing `.chapter` goes first: the chapter belongs to the work being     /// left, so it cannot outlive it. Opening the work already on top is not a     /// navigation and does nothing but drop that chapter.-    func pushWork(_ workID: UUID) {-        selectedTab = .works-        selectedWorksEntryID = nil-        dropTrailingChapter()-        guard worksPath.last != .work(workID) else { return }-        worksPath.append(.work(workID))+    func pushWork(_ workID: UUID) { pushWork(workID, on: .works) }++    /// The same route on either stack (Q38). A release row on Today pushes here+    /// with `.today`, which is what makes Back return to the selected day.+    func pushWork(_ workID: UUID, on stack: RouteStack) {+        enter(stack)+        dropTrailingChapter(on: stack)+        guard self[routes: stack].last != .work(workID) else { return }+        self[routes: stack].append(.work(workID))     }      /// The chapter route: an entry opened from the chapter list *inside* a work.@@ -322,27 +446,27 @@ final class AppNavigation {     /// Only ever on top of a work — that is what makes it a chapter rather than     /// a note — so a call with anything else on top is refused rather than     /// stacking an orphan. Re-selecting while a chapter is open replaces it.-    func showChapter(_ entryID: UUID) {-        dropTrailingChapter()-        guard case .work = worksPath.last else { return }-        worksPath.append(.chapter(entryID: entryID))+    func showChapter(_ entryID: UUID) { showChapter(entryID, on: .works) }++    func showChapter(_ entryID: UUID, on stack: RouteStack) {+        dropTrailingChapter(on: stack)+        guard case .work = self[routes: stack].last else { return }+        self[routes: stack].append(.chapter(entryID: entryID))     }      /// The series screen, carrying the work it was opened from where there is     /// one — Req 3.3's "Current work" marker is that field and nothing else.     func showSeries(_ seriesID: UUID, from originWorkID: UUID? = nil) {-        selectedTab = .works-        selectedWorksEntryID = nil-        dropTrailingChapter()-        worksPath.append(.series(id: seriesID, originWorkID: originWorkID))+        showSeries(seriesID, from: originWorkID, on: .works)+    }++    func showSeries(_ seriesID: UUID, from originWorkID: UUID?, on stack: RouteStack) {+        append(.series(id: seriesID, originWorkID: originWorkID), on: stack)     }      /// The series list (Req 1.6), from the Works list's own toolbar.     func showSeriesList() {-        selectedTab = .works-        selectedWorksEntryID = nil-        dropTrailingChapter()-        worksPath.append(.seriesList)+        append(.seriesList, on: .works)     }      /// The creator screen, carrying the work it was opened from where there is@@ -350,19 +474,25 @@ final class AppNavigation {     /// nothing else. `showSeries`' shape, for its reason: a creator screen and a     /// work detail lead to each other without bound, so it appends.     func showCreator(_ creatorID: UUID, from originWorkID: UUID? = nil) {-        selectedTab = .works-        selectedWorksEntryID = nil-        dropTrailingChapter()-        worksPath.append(.creator(id: creatorID, originWorkID: originWorkID))+        showCreator(creatorID, from: originWorkID, on: .works)+    }++    func showCreator(_ creatorID: UUID, from originWorkID: UUID?, on stack: RouteStack) {+        append(.creator(id: creatorID, originWorkID: originWorkID), on: stack)+    }++    /// The shape `showSeries` and `showCreator` share: enter the stack, drop the+    /// chapter of the work being left, append.+    private func append(_ route: WorksRoute, on stack: RouteStack) {+        enter(stack)+        dropTrailingChapter(on: stack)+        self[routes: stack].append(route)     }      /// The creators list (`work-creators` Req 1.6), from the Works list's own     /// toolbar beside the series control.     func showCreatorList() {-        selectedTab = .works-        selectedWorksEntryID = nil-        dropTrailingChapter()-        worksPath.append(.creatorList)+        append(.creatorList, on: .works)     }      /// The Works list's own entry route: the unattached-notes group, tapped at@@ -374,9 +504,11 @@ final class AppNavigation {      /// Back, for the wide tree's `ColumnBackButton` — the compact tree has the     /// navigation bar's own.-    func popWorksRoute() {-        guard !worksPath.isEmpty else { return }-        worksPath.removeLast()+    func popWorksRoute() { popRoute(on: .works) }++    func popRoute(on stack: RouteStack) {+        guard !self[routes: stack].isEmpty else { return }+        self[routes: stack].removeLast()     }      /// Req 4.6: a merge deleted the Work the screen on top is showing, so the@@ -384,16 +516,24 @@ final class AppNavigation {     ///     /// A replacement, not an append: the merged-away work is gone, and leaving     /// it under the survivor would give Back a screen that cannot be drawn.-    func replaceWork(_ workID: UUID) {-        dropTrailingChapter()-        if case .work = worksPath.last { worksPath.removeLast() }-        worksPath.append(.work(workID))+    func replaceWork(_ workID: UUID) { replaceWork(workID, on: .works) }++    func replaceWork(_ workID: UUID, on stack: RouteStack) {+        dropTrailingChapter(on: stack)+        // One write rather than a remove and an append: the intermediate stack,+        // with the work gone and its replacement not yet on, is a state no+        // observer should ever be handed.+        var routes = self[routes: stack]+        if case .work = routes.last { routes.removeLast() }+        routes.append(.work(workID))+        self[routes: stack] = routes     }      /// A work being left takes its chapter with it. The rule `selectedWorkID`'s     /// `didSet` used to hold, now stated once where the routes are.-    private func dropTrailingChapter() {-        if case .chapter = worksPath.last { worksPath.removeLast() }+    func dropTrailingChapter(on stack: RouteStack) {+        guard case .chapter = self[routes: stack].last else { return }+        self[routes: stack].removeLast()     }      /// Q30's fork, in the one place that owns navigation: a divergent Work set@@ -430,7 +570,7 @@ final class AppNavigation {     /// that no longer exists. This is the live-read contract     /// `AppLibraryModel.libraryDiagnosticsModel` states for `pendingConflicts`,     /// and what `ContentView` did before the routes moved here — its-    /// `route(toResolve:)` read `model.recentPresentation.duplicateWorkload`+    /// `route(toResolve:)` read `model.todayPresentation.duplicateWorkload`     /// itself, at tap time.     func resolveRoute(         for recordID: UUID,@@ -460,11 +600,89 @@ final class AppNavigation {             // screen carries every route (resolve, merge, Work URL).             showWork(workID)         case .drainedEntry(let entryID):-            // Recent's own stack takes the entry, by id, so one pushed past-            // Recent's row cap is still reachable (Req 10.3).-            selectedTab = .recent-            selectedRecentEntryID = entryID+            // Today's own stack takes the entry, by id, so an entry on a day the+            // screen is not showing is still reachable (Req 10.3).+            selectedTab = .today+            showTodayEntry(entryID)+        }+    }++    // MARK: - Today: the selected day (`update-schedule` Reqs 3.7, 4.3)++    /// The day Today is showing, resolved against the day that is current now.+    ///+    /// `.current` is resolved here rather than stored, so a day change moves the+    /// selection with nothing to update (Q32).+    func selectedDay(currentDay: CivilDay) -> CivilDay {+        todaySelection.day(currentDay: currentDay)+    }++    /// A strip cell's tap. Storing `.current` when the tapped day *is* the+    /// current one is what makes Req 3.7's normalisation a no-op for the reader+    /// who never left today.+    func selectToday(_ day: CivilDay, currentDay: CivilDay) {+        todaySelection = day == currentDay ? .current : .day(day)+    }++    /// Req 4.3: the week controls move the displayed week by seven days and+    /// select the same weekday in the new week, without bound in either+    /// direction (Q6).+    ///+    /// Day arithmetic through the calendar rather than 7 × 86,400 seconds: a+    /// week containing a DST transition is not 168 hours long, and a selection+    /// that drifted by an hour would land on the wrong date twice a year.+    func pageTodayWeek(by weeks: Int, currentDay: CivilDay, calendar: Calendar) {+        let moved = selectedDay(currentDay: currentDay)+            .adding(days: weeks * 7, calendar: calendar)+        selectToday(moved, currentDay: currentDay)+    }++    /// Req 3.7: the current day moved, so a selection that *was* the current day+    /// moves with it and every other selection stays where the reader put it.+    ///+    /// The range, rather than an equality against `previousCurrentDay`, covers a+    /// device asleep across two midnights — which receives one notification —+    /// and a reader who selected tomorrow and then crossed one midnight. A+    /// **backward** jump (a zone change westward) normalises nothing: the reader+    /// did not sit through a day change, and moving their selection back would+    /// be a change they never asked for.+    func normalizeTodaySelection(previousCurrentDay: CivilDay, newCurrentDay: CivilDay) {+        guard newCurrentDay > previousCurrentDay else { return }+        guard case .day(let selected) = todaySelection else { return }+        guard previousCurrentDay <= selected, selected <= newCurrentDay else { return }+        todaySelection = .current+    }++    // MARK: - Today: the routes++    /// A noted row's entry detail. Today's stack is cleared with it: the entry+    /// is the pane's whole content, exactly as the unattached-note route is on+    /// Works.+    func showTodayEntry(_ entryID: UUID) {+        todayPath = []+        selectedTodayEntryID = entryID+    }++    // A release row tapped in the day list is `showWork(_:on: .today)` — the+    // same route on the other stack, which is where its reasoning lives.++    /// Req 10.1: the detail column clears when the row it is showing is no+    /// longer in the list beside it — a status change, a deletion, a change of+    /// selected day, an active search or banner filter.+    ///+    /// The Today stack is emptied rather than excised: what it can hold is a+    /// work opened from a release row plus whatever was opened from that work,+    /// and removing the `.work` from under them would leave the routes above it+    /// pointing at nothing. Only the stack's **first** route is held to the+    /// visible works — a series or creator screen pushed over it is the reader's+    /// own depth, not a row in this list (`pruneRestoredSelection`'s rule).+    func pruneTodaySelection(visibleEntryIDs: Set<UUID>, visibleWorkIDs: Set<UUID>) {+        if let entryID = selectedTodayEntryID, !visibleEntryIDs.contains(entryID) {+            selectedTodayEntryID = nil         }+        guard case .work(let workID) = todayPath.first, !visibleWorkIDs.contains(workID)+        else { return }+        todayPath = []     }      // MARK: - Relaunch restore (Req 7.2, 4.9)@@ -510,9 +728,9 @@ final class AppNavigation {         entryResolves: (UUID) -> Bool,         workResolves: (UUID) -> Bool     ) {-        selectedRecentEntryID = Self.restoredID(-            selectedRecentEntryID,-            resolves: selectedRecentEntryID.map(entryResolves) ?? false,+        selectedTodayEntryID = Self.restoredID(+            selectedTodayEntryID,+            resolves: selectedTodayEntryID.map(entryResolves) ?? false,             hasEverImported: hasEverImported)         guard let restoredWorkID = selectedWorkID else { return }         let kept = Self.restoredID(

diff --git a/Asterism/Asterism/Layout/AppScreens.swift b/Asterism/Asterism/Layout/AppScreens.swiftindex 007cc43..cd35cbd 100644--- a/Asterism/Asterism/Layout/AppScreens.swift+++ b/Asterism/Asterism/Layout/AppScreens.swift@@ -49,14 +49,20 @@ struct AppScreens {     /// and a pinned copy would route them into the one that has gone. Every     /// resolve route below goes through this.     private func resolve(_ setKey: DuplicateSetKey) {-        navigation.route(toResolve: setKey, in: model.recentPresentation.duplicateWorkload)+        navigation.route(toResolve: setKey, in: model.todayPresentation.duplicateWorkload)     } -    // MARK: - Recent+    // MARK: - Today -    func recent() -> some View {-        RecentView(-            presentation: model.recentPresentation,+    func today() -> some View {+        TodayView(+            presentation: model.todayPresentation,+            // Q28: derived in Core from the same cycle's works snapshot, so a+            // reader sees one moment's rows, schedule and day.+            schedule: model.todaySchedule,+            currentDay: model.currentDay,+            calendar: model.calendar,+            selection: navigation.todaySelection,             capabilities: model.capabilities,             diagnosisRefreshFailed: model.diagnosisRefreshFailed,             sync: model.recentSyncPresentation,@@ -70,15 +76,17 @@ struct AppScreens {             // Req 1.5: the row whose entry is in the detail column beside this             // list wears the selected-row recipe. The compact tree pushes the             // entry instead, so there is no beside and nothing to mark.-            selectedEntryID: isWide ? navigation.selectedRecentEntryID : nil,+            selectedEntryID: isWide ? navigation.selectedTodayEntryID : nil,             // Req 6.1 is the iPad's hardware keyboard as well as the Mac's menu             // bar, and a narrow Split View is the compact tree — so ⌘F reaches             // the search field on both. Per tab: a `SwiftUI.Tab` keeps the             // unselected tab's content alive, so one shared token focused both             // lists' fields and the keyboard came up unasked on the next switch.-            searchFocusRequest: navigation.searchFocusRequest(for: .recent),+            searchFocusRequest: navigation.searchFocusRequest(for: .today),             showsSky: showsSky,-            onSelect: { navigation.selectedRecentEntryID = $0 },+            // A noted row clears the Today stack under it, so the entry is the+            // pane's whole content — the Works list's unattached route's shape.+            onSelect: navigation.showTodayEntry,             // Direct teaching sheet from the inline action (Audit §6).             onTeach: { navigation.showingTeachingForEntryID = $0 },             onShowDiagnostics: { navigation.showingDiagnostics = true },@@ -86,22 +94,74 @@ struct AppScreens {             // toolbar opens, where the condition and its remedy are spelled out.             onShowSyncSettings: showSettings,             onResolveDuplicate: resolve,-            onShowWorks: navigation.showWorksRoot+            // Reqs 4.1, 4.3: the day the strip taps and the week the chevrons+            // page to, resolved against the day this cycle called current.+            onSelectDay: { navigation.selectToday($0, currentDay: model.currentDay) },+            onPageWeek: {+                navigation.pageTodayWeek(+                    by: $0, currentDay: model.currentDay, calendar: model.calendar)+            },+            // Req 5.3, Q38: a release row opens the work on Today's own stack,+            // so Back returns to the selected day — and **replaces** it, the way+            // a Works row does, because in the wide tree this list stays beside+            // the detail column and a second tap would otherwise stack.+            onSelectWork: { navigation.showWork($0, on: .today) },+            // Req 10.1's prune, gated for `selectedEntryID`'s reason: the+            // detail column is the wide tree's, and on the phone a push stays+            // until the reader pops it (Q43).+            onPruneSelection: isWide+                ? { visibility in+                    navigation.pruneTodaySelection(+                        visibleEntryIDs: visibility.entries, visibleWorkIDs: visibility.works)+                }+                : nil         )     } +    // MARK: - A route, on whichever stack asked for it++    /// The route → view switch, once (`update-schedule` task 18).+    ///+    /// It existed twice — `CompactRootView.worksRoute` and+    /// `WideRootView.worksDetail` — and Today's own stack would have made it+    /// four copies of the same six-arm switch.+    ///+    /// **The stack is captured here, at construction, rather than read from+    /// `selectedTab` when a callback returns.** A screen built for Today's stack+    /// pushes onto Today's stack for as long as it is up, whatever tab the+    /// reader has moved to in the meantime — which is what makes the two stacks+    /// independent rather than merely two arrays.+    @ViewBuilder+    func route(_ route: WorksRoute, on stack: RouteStack) -> some View {+        switch route {+        case .work(let workID):+            workDetail(workID, on: stack)+        case .chapter(let entryID):+            EntryDetailRoute(+                model: model, navigation: navigation, entryID: entryID, showsSky: showsSky)+        case .seriesList:+            seriesList(on: stack)+        case .series(let seriesID, let originWorkID):+            series(seriesID, origin: originWorkID, on: stack)+        case .creatorList:+            creatorList(on: stack)+        case .creator(let creatorID, let originWorkID):+            creator(creatorID, origin: originWorkID, on: stack)+        }+    }+     // MARK: - Works      func works() -> some View {         WorksView(             snapshot: model.worksSnapshot,-            duplicateWorkload: model.recentPresentation.duplicateWorkload,+            duplicateWorkload: model.todayPresentation.duplicateWorkload,             titlesByWorkID: model.workTitlesByID,             // `works-list-options` Q14: derived once per snapshot publication             // beside the titles, never in `WorksView.body`.             filterOptions: model.worksFilterOptions,             isAwaitingFirstSync: model.recentSyncPresentation.isAwaitingFirstSync,-            // Req 1.5 again, and gated for `recent()`'s reason. `markedWorkID`+            // Req 1.5 again, and gated for `today()`'s reason. `markedWorkID`             // rather than `selectedWorkID`: a series screen opened from a work             // still has that work under it on the path, and Req 3.6 of             // `series-and-related-works` asks that the list's selection clear@@ -112,7 +172,7 @@ struct AppScreens {             // `showWork` clears the other routes this column can be showing. In             // the compact tree those are already nil at the Works root, so it is             // the same act there — one spelling rather than two.-            onSelectWork: navigation.showWork,+            onSelectWork: { navigation.showWork($0) },             onSelectEntry: navigation.showWorksEntry,             onNewWork: { navigation.showingNewWork = true },             // Req 4.4: the header pushes the series onto the Works stack with@@ -129,13 +189,6 @@ struct AppScreens {                 Task { await model.recordDistinctPair(a, b) }             }         )-        // Req 3.2: the truncation footer's route bumps this, which gives-        // `WorksView` a new identity — so it is rebuilt from scratch with its-        // `@State` query back at "". Rebuilding the whole subtree also discards-        // its scroll position, which is the cost and, for a route whose promise-        // is "the Works root", arguably the point. Nothing else bumps the token,-        // so no ordinary update pays it.-        .id(navigation.worksResetToken)     }      /// A work's detail screen.@@ -146,29 +199,29 @@ struct AppScreens {     /// that route: a plain pushed screen in the compact stack, a measured and     /// sky-cleared one in the wide detail column.     @ViewBuilder-    func workDetail(_ workID: UUID) -> some View {+    func workDetail(_ workID: UUID, on stack: RouteStack) -> some View {         if let detailModel = model.workDetailModel(for: workID) {             WorkDetailView(                 model: detailModel,                 onResolveDuplicate: navigation.resolveRoute(                     for: workID, type: .work,-                    workload: { model.recentPresentation.duplicateWorkload }),-                onSelectEntry: navigation.showChapter,+                    workload: { model.todayPresentation.duplicateWorkload }),+                onSelectEntry: { navigation.showChapter($0, on: stack) },                 // Req 4.6: the merge deleted the Work this route is showing, so                 // the route moves to the one that survived rather than popping                 // to a list.-                onMergeCommitted: navigation.replaceWork,+                onMergeCommitted: { navigation.replaceWork($0, on: stack) },                 // Req 8.1: a related work is opened **from** a screen already on                 // the stack, so it appends — Q49's `pushWork`, which is what                 // makes Back return to the work the reader came from rather                 // than to the list.-                onSelectWork: navigation.pushWork,+                onSelectWork: { navigation.pushWork($0, on: stack) },                 // Req 5.1, with the origin: the series screen marks the row of                 // the work it was opened from (Req 3.3).-                onSelectSeries: { navigation.showSeries($0, from: workID) },+                onSelectSeries: { navigation.showSeries($0, from: workID, on: stack) },                 // `work-creators` Req 4.3, with the origin: the creator screen                 // marks the row of the work it was opened from.-                onSelectCreator: { navigation.showCreator($0, from: workID) },+                onSelectCreator: { navigation.showCreator($0, from: workID, on: stack) },                 exportModel: model.markdownExportModel(forWork: workID),                 showsSky: showsSky,                 // `character-extraction`: the indicator, the review sheet and@@ -190,7 +243,7 @@ struct AppScreens {     /// screen of its own: the Works stack is a path (Decision 7), and that is     /// what makes Back from a series return to this list in both trees.     @ViewBuilder-    func seriesList() -> some View {+    func seriesList(on stack: RouteStack) -> some View {         if let listModel = model.seriesListModel() {             SeriesListView(                 model: listModel,@@ -200,14 +253,14 @@ struct AppScreens {                 showsSky: showsSky,                 // No origin: Req 3.3's "Current work" marker belongs to a series                 // opened *from* a work, and this one was opened from the list.-                onSelectSeries: { navigation.showSeries($0) })+                onSelectSeries: { navigation.showSeries($0, from: nil, on: stack) })         }     }      /// Req 3.1's screen. `origin` is the work the reader came from, which is     /// where Req 3.3's marker comes from.     @ViewBuilder-    func series(_ seriesID: UUID, origin: UUID?) -> some View {+    func series(_ seriesID: UUID, origin: UUID?, on stack: RouteStack) -> some View {         if let detailModel = model.seriesDetailModel(for: seriesID, originWorkID: origin) {             SeriesDetailView(                 model: detailModel,@@ -215,10 +268,10 @@ struct AppScreens {                 showsSky: showsSky,                 // Q49: a member row **pushes**, so Back returns to the series                 // rather than to the list under it.-                onSelectWork: navigation.pushWork,+                onSelectWork: { navigation.pushWork($0, on: stack) },                 // The deleted series takes its screen with it, and the route                 // under it is what the reader came from.-                onDeleted: navigation.popWorksRoute)+                onDeleted: { navigation.popRoute(on: stack) })                 // The identity the screen needs (design §Navigation): a second                 // series opened from the first is the same structural position,                 // and without this SwiftUI would keep the first one's state.@@ -232,7 +285,7 @@ struct AppScreens {     /// the creator route rather than pushing a screen of its own, which is what     /// makes Back from a creator return to this list in both trees.     @ViewBuilder-    func creatorList() -> some View {+    func creatorList(on stack: RouteStack) -> some View {         if let listModel = model.creatorListModel() {             CreatorListView(                 model: listModel,@@ -243,14 +296,14 @@ struct AppScreens {                 // No origin: Req 4.3's "Current work" marker belongs to a                 // creator opened *from* a work, and this one was opened from the                 // list.-                onSelectCreator: { navigation.showCreator($0) })+                onSelectCreator: { navigation.showCreator($0, from: nil, on: stack) })         }     }      /// `work-creators` Req 4.1's screen. `origin` is the work the reader came     /// from, which is where Req 4.3's marker comes from.     @ViewBuilder-    func creator(_ creatorID: UUID, origin: UUID?) -> some View {+    func creator(_ creatorID: UUID, origin: UUID?, on stack: RouteStack) -> some View {         if let detailModel = model.creatorDetailModel(for: creatorID, originWorkID: origin) {             CreatorDetailView(                 model: detailModel,@@ -258,10 +311,10 @@ struct AppScreens {                 showsSky: showsSky,                 // A work row **pushes**, so Back returns to the creator rather                 // than to whatever is under it (Q49 of `ipad-and-mac-layouts`).-                onSelectWork: navigation.pushWork,+                onSelectWork: { navigation.pushWork($0, on: stack) },                 // The deleted creator takes its screen with it, and the route                 // under it is what the reader came from.-                onDeleted: navigation.popWorksRoute)+                onDeleted: { navigation.popRoute(on: stack) })                 // The identity the screen needs (design §Navigation): a second                 // creator opened from the first is the same structural position,                 // and without this SwiftUI would keep the first one's state.@@ -288,7 +341,7 @@ struct AppScreens {             // T-2289: the Works tab's own push, which carries every route a Work             // can need — the merge-blocked sheet deliberately has none, and a             // Work opened from here may itself be torn.-            onOpenWork: navigation.showWork(_:)+            onOpenWork: { navigation.showWork($0) }         ) {             LibraryDiagnosticsView(model: diagnosticsModel, showsSky: showsSky)         }@@ -298,7 +351,7 @@ struct AppScreens {      func stats() -> some View {         StatsView(-            presentation: model.recentPresentation,+            presentation: model.todayPresentation,             works: model.worksSnapshot.works,             snapshotGeneration: model.snapshotGeneration,             // Req 8.1's gate. Q36: `.task(id:)` alone satisfies neither Req 8.1@@ -310,7 +363,7 @@ struct AppScreens {             // heading — and a second one inside it would draw a second bar.             ownsNavigationStack: !isWide,             showsSky: showsSky,-            onOpenWork: navigation.showWork+            onOpenWork: { navigation.showWork($0) }         )     } }

diff --git a/Asterism/Asterism/Layout/CompactRootView.swift b/Asterism/Asterism/Layout/CompactRootView.swiftindex 2f407e2..9db1bcb 100644--- a/Asterism/Asterism/Layout/CompactRootView.swift+++ b/Asterism/Asterism/Layout/CompactRootView.swift@@ -44,14 +44,17 @@ struct CompactRootView: View {     var body: some View {         TabView(selection: $navigation.selectedTab) {             SwiftUI.Tab(-                AppTab.recent.title, systemImage: AppTab.recent.systemImage,-                value: AppTab.recent+                AppTab.today.title, systemImage: AppTab.today.systemImage,+                value: AppTab.today             ) {-                NavigationStack {-                    recentScreen+                // `update-schedule` Q38: Today binds a path exactly as Works+                // does. A release row pushes the work onto *this* stack, so Back+                // returns to the selected day.+                NavigationStack(path: $navigation.todayPath) {+                    todayScreen                 }             }-            .accessibilityIdentifier("tab-recent")+            .accessibilityIdentifier("tab-today")              SwiftUI.Tab(                 AppTab.works.title, systemImage: AppTab.works.systemImage,@@ -64,7 +67,7 @@ struct CompactRootView: View {             .accessibilityIdentifier("tab-works")              // `specs/stats-page/` Req 1.1. The snapshots are passed whole and-            // never pre-flattened: `recentPresentation.allRows` is a computed+            // never pre-flattened: `todayPresentation.allRows` is a computed             // `groups.flatMap(\.rows)`, so taking it in a body would flatten the             // whole library on every republish, for every tab, whether or not             // Stats is on screen (Req 8.1).@@ -90,11 +93,14 @@ struct CompactRootView: View {         // was drawing every system control in the stock accent without it.     } -    // MARK: - Recent+    // MARK: - Today -    private var recentScreen: some View {-        screens.recent()-            .navigationTitle(AppTab.recent.title)+    private var todayScreen: some View {+        // Req 4.4: **no `.navigationTitle` here.** A title set outside the+        // screen is the one closest to the stack and wins, so this was not the+        // fallback the comment it replaces claimed — it was the title, and the+        // screen's own day title never showed. The screen sets the only one.+        screens.today()             .toolbar {                 ToolbarItem(placement: .trailingBar) {                     Button(action: showSettings) {@@ -108,7 +114,12 @@ struct CompactRootView: View {                     .accessibilityLabel("Settings")                 }             }-            .navigationDestination(item: $navigation.selectedRecentEntryID) { entryID in+            // One typed destination for this stack, as Works has — the same+            // vocabulary, a stack of its own.+            .navigationDestination(for: WorksRoute.self) { route in+                screens.route(route, on: .today)+            }+            .navigationDestination(item: $navigation.selectedTodayEntryID) { entryID in                 EntryDetailRoute(model: model, navigation: navigation, entryID: entryID)             }             // Req 4.1's route, pushed onto this stack rather than presented: the@@ -140,28 +151,10 @@ struct CompactRootView: View {         screens.works()             .navigationTitle(AppTab.works.title)             .navigationDestination(for: WorksRoute.self) { route in-                worksRoute(route)+                screens.route(route, on: .works)             }             .navigationDestination(item: $navigation.selectedWorksEntryID) { entryID in                 EntryDetailRoute(model: model, navigation: navigation, entryID: entryID)             }     }--    @ViewBuilder-    private func worksRoute(_ route: WorksRoute) -> some View {-        switch route {-        case .work(let workID):-            screens.workDetail(workID)-        case .chapter(let entryID):-            EntryDetailRoute(model: model, navigation: navigation, entryID: entryID)-        case .seriesList:-            screens.seriesList()-        case .series(let seriesID, let originWorkID):-            screens.series(seriesID, origin: originWorkID)-        case .creatorList:-            screens.creatorList()-        case .creator(let creatorID, let originWorkID):-            screens.creator(creatorID, origin: originWorkID)-        }-    } }

diff --git a/Asterism/Asterism/Layout/EntryDetailRoute.swift b/Asterism/Asterism/Layout/EntryDetailRoute.swiftindex 8bce1ae..2a95c7d 100644--- a/Asterism/Asterism/Layout/EntryDetailRoute.swift+++ b/Asterism/Asterism/Layout/EntryDetailRoute.swift@@ -39,7 +39,7 @@ struct EntryDetailRoute: View {                 // here: this screen holds the closure for its whole life.                 onResolveDuplicate: navigation.resolveRoute(                     for: entryID, type: .entry,-                    workload: { model.recentPresentation.duplicateWorkload }),+                    workload: { model.todayPresentation.duplicateWorkload }),                 exportModel: model.markdownExportModel(forEntry: entryID),                 showsSky: showsSky,                 // T-2301: the two signals are one fact about the host. A pushed

diff --git a/Asterism/Asterism/Layout/ListDetailPane.swift b/Asterism/Asterism/Layout/ListDetailPane.swiftindex d440441..604fe84 100644--- a/Asterism/Asterism/Layout/ListDetailPane.swift+++ b/Asterism/Asterism/Layout/ListDetailPane.swift@@ -46,7 +46,7 @@ struct ListDetailPane<Selection: Equatable, ListContent: View, DetailContent: Vi     ///     /// A closure, evaluated only when the selection actually changes: the title     /// of a Recent row is found by looking through the presentation, and-    /// `recentPresentation.allRows` is a computed `groups.flatMap(\.rows)` that+    /// `todayPresentation.allRows` is a computed `groups.flatMap(\.rows)` that     /// flattens the library every time it is read (Req 8.1 of `stats-page`     /// records the same trap). Evaluated in `body` it would pay that on every     /// update; evaluated here it is paid once per selection.

diff --git a/Asterism/Asterism/Layout/NavigationActions.swift b/Asterism/Asterism/Layout/NavigationActions.swiftindex e40c835..b007777 100644--- a/Asterism/Asterism/Layout/NavigationActions.swift+++ b/Asterism/Asterism/Layout/NavigationActions.swift@@ -96,7 +96,7 @@ struct NavigationActions: Equatable {     /// (Req 1.2, Q5) with no rows and no search field.     private static func hasList(_ tab: AppTab) -> Bool {         switch tab {-        case .recent, .works: true+        case .today, .works: true         case .stats: false         }     }@@ -107,22 +107,31 @@ struct NavigationActions: Equatable {     /// existence is what enables it and the subject itself is what it renders,     /// so an enabled command cannot open an empty save panel.     ///-    /// **The pushed chapter wins.** On Works, a chapter entry opened from a work-    /// is the screen on top — the detail stack's push in the wide tree, the work+    /// **The pushed chapter wins.** A chapter entry opened from a work is the+    /// screen on top — the detail stack's push in the wide tree, the work     /// detail's push in the compact one — so exporting the work underneath it     /// would hand the reader a document they are not looking at. `AppNavigation`-    /// guarantees the chapter id is only set while a work is open (its `didSet`-    /// clears it), so this is strictly "the innermost screen".+    /// only ever holds a chapter route directly above a work route, so this is+    /// strictly "the innermost screen".+    ///+    /// **Both tabs own a stack** since `update-schedule` Q38: Today's release+    /// rows push a work onto `todayPath` and a chapter can be opened inside it,+    /// so the rule is the same on either side and the tab picks which stack's+    /// ids are read.     static func exportSubject(         tab: AppTab,-        recentEntryID: UUID?,+        todayEntryID: UUID?,+        todayWorkID: UUID?,+        todayChapterEntryID: UUID?,         workID: UUID?,         worksEntryID: UUID?,         workChapterEntryID: UUID?     ) -> MarkdownExportModel.Subject? {         switch tab {-        case .recent:-            return recentEntryID.map(MarkdownExportModel.Subject.entry)+        case .today:+            if let todayChapterEntryID { return .entry(todayChapterEntryID) }+            if let todayWorkID { return .work(todayWorkID) }+            return todayEntryID.map(MarkdownExportModel.Subject.entry)         case .works:             if let workChapterEntryID { return .entry(workChapterEntryID) }             if let workID { return .work(workID) }

diff --git a/Asterism/Asterism/Layout/SettingsScreen.swift b/Asterism/Asterism/Layout/SettingsScreen.swiftindex c6c234e..912fac2 100644--- a/Asterism/Asterism/Layout/SettingsScreen.swift+++ b/Asterism/Asterism/Layout/SettingsScreen.swift@@ -153,7 +153,7 @@ struct SettingsScreen: View {             dismissSheet()         } else {             openWindow(id: AsterismApp.mainWindowID)-            navigation.takePendingRoute(in: model.recentPresentation.duplicateWorkload)+            navigation.takePendingRoute(in: model.todayPresentation.duplicateWorkload)         }     } }

diff --git a/Asterism/Asterism/Layout/WideRootView.swift b/Asterism/Asterism/Layout/WideRootView.swiftindex 4523fee..114f74f 100644--- a/Asterism/Asterism/Layout/WideRootView.swift+++ b/Asterism/Asterism/Layout/WideRootView.swift@@ -75,7 +75,7 @@ struct WideRootView: View {     /// Req 1.3's gate, computed here where the capabilities and the presentation     /// already are, so `SidebarView` stays free of the library model.     private var actionableCount: Int? {-        let count = model.recentPresentation.actionableCount+        let count = model.todayPresentation.actionableCount         guard model.capabilities.supportsSegmentTeaching, count > 0 else { return nil }         return count     }@@ -83,8 +83,8 @@ struct WideRootView: View {     @ViewBuilder     private var pane: some View {         switch navigation.selectedTab {-        case .recent:-            recentPane+        case .today:+            todayPane         case .works:             worksPane         case .stats:@@ -106,23 +106,56 @@ struct WideRootView: View {         }     } -    // MARK: - Recent+    // MARK: - Today -    private var recentPane: some View {+    /// `update-schedule` Req 10.1: the pane's selection is whatever the detail+    /// column is showing on Today's *stack* — a noted row's entry, a release+    /// row's work, or a chapter inside it — so Req 8.1's announcement and focus+    /// move fire for a release row exactly as they do for a note.+    private var todayPane: some View {         ListDetailPane(             navigation: navigation,-            title: AppTab.recent.title,-            selection: navigation.selectedRecentEntryID,-            detailAnnouncement: { entryTitle(navigation.selectedRecentEntryID) }+            // Req 4.4: the *day*'s title, not the tab's. This string is what+            // `ColumnTitle` draws on the Mac and what the iPad column's large+            // navigation title is set to — in both cases the screen's own+            // `.navigationTitle` never reaches the heading, so a literal "Today"+            // here left the column headed Today with Yesterday selected.+            title: todayColumnTitle,+            selection: navigation.detailSubject(on: .today),+            detailAnnouncement: { announcement(on: .today) }         ) {-            recentList+            todayList         } detail: {-            recentDetail+            todayDetail         }     } -    private var recentList: some View {-        screens.recent()+    /// Req 4.4's heading for the list column, from the same function the screen+    /// sets its own navigation title with, over the same two inputs — so the+    /// column and the screen cannot name two different days.+    ///+    /// `model.calendar` is the calendar the cycle published, read like any other+    /// published value (Q74): it is both the input that re-evaluates this+    /// heading when a zone or region change republishes the cycle and the+    /// calendar the heading is derived under, so the column and the strip beside+    /// it cannot answer under two different ones.+    private var todayColumnTitle: String {+        Self.todayColumnTitle(+            selection: navigation.todaySelection,+            currentDay: model.currentDay,+            calendar: model.calendar)+    }++    /// The same, as a pure function of its inputs, so what the column is headed+    /// is assertable without building the view.+    static func todayColumnTitle(+        selection: TodaySelection, currentDay: CivilDay, calendar: Calendar+    ) -> String {+        TodayTitleText.title(for: selection, current: currentDay, calendar: calendar)+    }++    private var todayList: some View {+        screens.today()             // Req 1.7: Diagnostics is pushed from the *list* stack, and the             // sidebar stays beside it. What the push does not do is stay inside             // the column — see the measured note on `ListDetailPane`.@@ -135,23 +168,22 @@ struct WideRootView: View {             }     } -    @ViewBuilder-    private var recentDetail: some View {-        // A `switch` on the id, never a push: clearing the selection has to-        // show the placeholder without popping anything, and popping the-        // chapter entry has to land on the work rather than on nothing.-        if let entryID = navigation.selectedRecentEntryID {-            // Req 1.5's actual claim is made assertable by the-            // `entry-detail-<uuid>` marker, which `EntryDetailView` applies from-            // its **own** model rather than from this id (Q57) — so a UI test-            // that follows the tapped `recent-entry-<uuid>` row into this column-            // is looking at what is drawn and not at what was asked for.-            EntryDetailRoute(-                model: model, navigation: navigation, entryID: entryID, showsSky: false)-                .detailMeasure(WideLayoutPolicy.entryMeasure)-        } else {-            DetailPlaceholder(title: "Select a note", systemImage: "clock")-        }+    /// Today's detail column: the stack's last route, else the selected entry,+    /// else the placeholder (`update-schedule` Req 10.1).+    ///+    /// Req 1.5's actual claim is made assertable by the `entry-detail-<uuid>`+    /// marker, which `EntryDetailView` applies from its **own** model rather+    /// than from this id (Q57) — so a UI test that follows the tapped+    /// `recent-entry-<uuid>` row into this column is looking at what is drawn+    /// and not at what was asked for.+    private var todayDetail: some View {+        stackDetail(+            on: .today,+            entryID: navigation.selectedTodayEntryID,+            // A work **or** a note: the day list holds release rows beside the+            // noted ones, and either kind fills this column.+            placeholder: DetailPlaceholder(+                title: "Select a work or note", systemImage: "calendar"))     }      // MARK: - Works@@ -163,8 +195,8 @@ struct WideRootView: View {             // Whatever the column is showing is what Req 8.1 announces and moves             // focus to — the route on top of the Works stack, or the unattached             // note the list opened when there is none.-            selection: navigation.worksDetailSubject,-            detailAnnouncement: worksAnnouncement+            selection: navigation.detailSubject(on: .works),+            detailAnnouncement: { announcement(on: .works) }         ) {             screens.works()         } detail: {@@ -203,70 +235,80 @@ struct WideRootView: View {     ///     /// F4's wider ruling — what a *list-stack* push (Diagnostics) should do — is     /// still open; nothing here touches it.-    @ViewBuilder     private var worksDetail: some View {-        switch navigation.worksPath.last {-        case .work(let workID):-            // Q77: a work is a stacked route too, whenever one sits under it.-            // `pushWork` is how a series member row and a creator's work row-            // open a work, so that work has the screen it was opened from-            // beneath it — and without the button there was no way back to it-            // in the wide tree, where the navigation bar has no back chevron of-            // its own. A work at the stack root has nothing under it and draws-            // none, exactly as before.-            if navigation.hasRouteBeneathWorksTop {-                stackedRoute(measure: WideLayoutPolicy.workMeasure) {-                    screens.workDetail(workID)+        stackDetail(+            on: .works,+            // The Works list's unattached-entry route lands in this column too,+            // and carries the same marker from inside the screen.+            entryID: navigation.selectedWorksEntryID,+            placeholder: DetailPlaceholder(title: "Select a work", systemImage: "sparkles"))+    }++    // MARK: - One detail column, two stacks (`update-schedule` task 18)++    /// What a stack's detail column draws: its last route, else the entry its+    /// list opened, else the placeholder.+    ///+    /// One body for both panes. It was `worksDetail`'s six-arm switch, and+    /// Today's stack speaks the same vocabulary — so a second copy would be a+    /// second place for the measures, the back button and the entry fallback to+    /// drift apart.+    @ViewBuilder+    private func stackDetail(+        on stack: RouteStack, entryID: UUID?, placeholder: DetailPlaceholder+    ) -> some View {+        if let route = navigation.path(on: stack).last {+            if drawsBackButton(route, on: stack) {+                stackedRoute(on: stack, measure: Self.measure(for: route)) {+                    screens.route(route, on: stack)                 }             } else {-                screens.workDetail(workID)-                    .detailMeasure(WideLayoutPolicy.workMeasure)-            }-        case .chapter(let entryID):-            stackedRoute(measure: WideLayoutPolicy.entryMeasure) {-                EntryDetailRoute(-                    model: model, navigation: navigation, entryID: entryID, showsSky: false)-            }-        case .seriesList:-            stackedRoute(measure: WideLayoutPolicy.workMeasure) {-                screens.seriesList()-            }-        case .series(let seriesID, let originWorkID):-            stackedRoute(measure: WideLayoutPolicy.workMeasure) {-                screens.series(seriesID, origin: originWorkID)-            }-        case .creatorList:-            stackedRoute(measure: WideLayoutPolicy.workMeasure) {-                screens.creatorList()-            }-        case .creator(let creatorID, let originWorkID):-            stackedRoute(measure: WideLayoutPolicy.workMeasure) {-                screens.creator(creatorID, origin: originWorkID)-            }-        case .none:-            if let entryID = navigation.selectedWorksEntryID {-                // The Works list's unattached-entry route lands in this column-                // too, and carries the same marker from inside the screen.-                EntryDetailRoute(-                    model: model, navigation: navigation, entryID: entryID, showsSky: false)-                    .detailMeasure(WideLayoutPolicy.entryMeasure)-            } else {-                DetailPlaceholder(title: "Select a work", systemImage: "sparkles")+                screens.route(route, on: stack)+                    .detailMeasure(Self.measure(for: route))             }+        } else if let entryID {+            EntryDetailRoute(+                model: model, navigation: navigation, entryID: entryID, showsSky: false)+                .detailMeasure(WideLayoutPolicy.entryMeasure)+        } else {+            placeholder         }     } -    /// A route drawn *over* something else on the Works stack, with the way back-    /// to it (Q57).+    /// Q77: a work is a stacked route only when one sits under it.+    ///+    /// `pushWork` is how a series member row, a creator's work row and — since+    /// `update-schedule` — a release row open a work, so a work opened that way+    /// has the screen it was opened from beneath it, and without the button+    /// there is no way back to it in the wide tree, where the navigation bar has+    /// no back chevron of its own. A work at the stack root has nothing under it+    /// and draws none, exactly as before. Every other route is an append onto+    /// something, so it always carries the button — including one taken from the+    /// list at the stack root, whose way back *is* that list.+    private func drawsBackButton(_ route: WorksRoute, on stack: RouteStack) -> Bool {+        if case .work = route { return navigation.hasRouteBeneathTop(on: stack) }+        return true+    }++    /// Req 3.4's readable measure, per route: an entry takes the note measure+    /// and every other screen the work one.+    private static func measure(for route: WorksRoute) -> CGFloat {+        if case .chapter = route { return WideLayoutPolicy.entryMeasure }+        return WideLayoutPolicy.workMeasure+    }++    /// A route drawn *over* something else on a stack, with the way back to it+    /// (Q57).     ///     /// The back affordance is drawn in the column rather than in the toolbar     /// because the merged bar puts the detail stack's items at the trailing end,     /// which is not where a back control belongs.     private func stackedRoute(-        measure: CGFloat, @ViewBuilder content: () -> some View+        on stack: RouteStack, measure: CGFloat, @ViewBuilder content: () -> some View     ) -> some View {         VStack(alignment: .leading, spacing: 0) {-            ColumnBackButton(title: worksBackTitle, action: navigation.popWorksRoute)+            ColumnBackButton(+                title: backTitle(on: stack), action: { navigation.popRoute(on: stack) })             content()         }         .detailMeasure(measure)@@ -275,8 +317,8 @@ struct WideRootView: View {     /// What the route underneath the one on top is called — the work a chapter     /// or a series screen was opened from, and the tab's own name where the     /// route was taken from the list at the stack root.-    private var worksBackTitle: String {-        switch navigation.worksPath.dropLast().last {+    private func backTitle(on stack: RouteStack) -> String {+        switch navigation.path(on: stack).dropLast().last {         case .work(let workID):             return model.workTitlesByID[workID] ?? "Work"         case .series, .seriesList:@@ -288,8 +330,8 @@ struct WideRootView: View {         case .chapter, .none:             // A chapter is never underneath anything — it is dropped before a             // route is appended — and nothing underneath at all means the route-            // was taken from the list at the stack root.-            return AppTab.works.title+            // was taken from the list at the stack root, which is the tab.+            return stack == .today ? AppTab.today.title : AppTab.works.title         }     } @@ -299,7 +341,7 @@ struct WideRootView: View {     /// selection changes (see `ListDetailPane.detailAnnouncement`).     private func entryTitle(_ entryID: UUID?) -> String? {         guard let entryID else { return nil }-        guard let row = model.recentPresentation.allRows.first(where: { $0.id == entryID })+        guard let row = model.todayPresentation.allRows.first(where: { $0.id == entryID })         else { return nil }         // The chapter names the screen where there is one, exactly as entry         // detail's own navigation title does; the capture title is what an@@ -307,10 +349,12 @@ struct WideRootView: View {         return row.chapterTitle ?? row.captureTitle     } -    private func worksAnnouncement() -> String? {-        // The same switch the column's own content takes: whatever is drawn is-        // what is announced.-        switch navigation.worksPath.last {+    /// What a stack's detail column is called, for Req 8.1's announcement.+    ///+    /// The same switch the column's own content takes, so whatever is drawn is+    /// what is announced — on either stack.+    private func announcement(on stack: RouteStack) -> String? {+        switch navigation.path(on: stack).last {         case .work(let workID):             return model.workTitlesByID[workID]         case .chapter(let entryID):@@ -327,7 +371,10 @@ struct WideRootView: View {             // name the read resolved; the route carries an identifier alone.             return "Creator"         case .none:-            return entryTitle(navigation.selectedWorksEntryID)+            switch stack {+            case .works: return entryTitle(navigation.selectedWorksEntryID)+            case .today: return entryTitle(navigation.selectedTodayEntryID)+            }         }     } }

diff --git a/Asterism/Asterism/Support/AppLifecycle.swift b/Asterism/Asterism/Support/AppLifecycle.swiftindex 787557b..84aa2c9 100644--- a/Asterism/Asterism/Support/AppLifecycle.swift+++ b/Asterism/Asterism/Support/AppLifecycle.swift@@ -565,6 +565,61 @@ enum AppLifecycle {         #endif     } +    /// Every event that moves what "today" means, in one stream+    /// (`update-schedule` Q44).+    ///+    /// `significantTimeChange` already merges the day, clock and zone+    /// notifications **on macOS**; on iOS `UIApplication`'s single notification+    /// does not reliably carry a zone change on its own, so the zone+    /// notification is merged in there and only there. Two subscriptions — the+    /// shape `StatsView` had — meant two whole-library reads for one zone+    /// change on the Mac, where the zone notification is in both streams.+    ///+    /// The locale notification is merged in on **both** platforms, because Req+    /// 3.7 says "or calendar" and neither platform's time notifications carry+    /// one: changing the region's first weekday or its calendar identifier+    /// fires `NSLocale.currentLocaleDidChangeNotification` and nothing else, so+    /// without it the week strip kept the old first weekday until some+    /// unrelated refresh happened along.+    ///+    /// **Debounced** (Q75). One reader action posts more than one of these: a+    /// zone change posts the zone notification *and* a significant-time change,+    /// and a region edit that moves the first weekday can post the locale one+    /// beside them. Each subscriber's handler is a whole-library re-read — the+    /// app model's `refreshAll` and `StatsView`'s re-derivation — so the+    /// un-debounced stream ran two or three of those for one thing happening.+    /// The handlers are idempotent, so collapsing a burst loses nothing: the+    /// last event carries the calendar now in force, which is the only one any+    /// of them would have read.+    static let temporalChange: AnyPublisher<Void, Never> = makeTemporalChange()++    /// The window a burst is collapsed into. Long enough to cover the+    /// notifications one change posts, short enough that a day rollover the+    /// reader is watching still lands promptly.+    private static let temporalDebounce = DispatchQueue.SchedulerTimeType.Stride.milliseconds(250)++    private static func makeTemporalChange() -> AnyPublisher<Void, Never> {+        let localeChange = NotificationCenter.default+            .publisher(for: NSLocale.currentLocaleDidChangeNotification)+            .map { _ in () }+        #if os(macOS)+        let merged = significantTimeChange.merge(with: localeChange).eraseToAnyPublisher()+        #else+        let merged = significantTimeChange+            .merge(+                with: NotificationCenter.default+                    .publisher(for: .NSSystemTimeZoneDidChange)+                    .map { _ in () },+                localeChange+            )+            .eraseToAnyPublisher()+        #endif+        return+            merged+            .debounce(for: temporalDebounce, scheduler: DispatchQueue.main)+            .eraseToAnyPublisher()+    }+     /// Whether the app is active right now, by the same predicate the pair     /// above is derived from (Req 4.7).     static var isActive: Bool {

diff --git a/Asterism/Asterism/Support/UITestMarker.swift b/Asterism/Asterism/Support/UITestMarker.swiftindex 1e2915e..f615eb5 100644--- a/Asterism/Asterism/Support/UITestMarker.swift+++ b/Asterism/Asterism/Support/UITestMarker.swift@@ -66,7 +66,10 @@ enum LayoutMarker { /// silently never happens. enum RestoreStorageKey {     static let selectedTab = "restore.selectedTab"-    static let selectedRecentEntryID = "restore.selectedRecentEntryID"+    /// `update-schedule` Q42: Today's entry selection is the only Today value+    /// restored. `todayPath` starts empty on every launch, so there is no third+    /// key here for it.+    static let selectedTodayEntryID = "restore.selectedTodayEntryID"     static let selectedWorkID = "restore.selectedWorkID" } 

diff --git a/Asterism/Asterism/Thumbnails/ThumbnailImageCache.swift b/Asterism/Asterism/Thumbnails/ThumbnailImageCache.swiftindex e1e13e7..cbcc4b5 100644--- a/Asterism/Asterism/Thumbnails/ThumbnailImageCache.swift+++ b/Asterism/Asterism/Thumbnails/ThumbnailImageCache.swift@@ -18,7 +18,7 @@ struct DecodedThumbnail: @unchecked Sendable { /// /// **Three things in one object, because they are one seam.** It is the cache; /// it is the loader (it holds the library reference, so a row does not); and it-/// is the environment value `\.thumbnailLoader`, so `WorkRow`, `RecentEntryRow`,+/// is the environment value `\.thumbnailLoader`, so `WorkRow`, `TodayEntryRow`, /// the detail header and the resolution sheet reach it without a single row /// signature changing. ///

diff --git a/Asterism/Asterism/UITestLaunchSupport.swift b/Asterism/Asterism/UITestLaunchSupport.swiftindex 38081c4..34cb422 100644--- a/Asterism/Asterism/UITestLaunchSupport.swift+++ b/Asterism/Asterism/UITestLaunchSupport.swift@@ -24,7 +24,7 @@ enum UITestFixtureKind: Equatable {     /// The same 5,000-Entry composed fixture perturbed into one of Req 1.1's     /// tolerated states. Req 5.3 asks for Recent's publish-to-interactive path to     /// hold its 2 s budget with a second Site row for the fixture's hostname, and-    /// that measurement is a device measurement of the `RecentPublication`+    /// that measurement is a device measurement of the `TodayPresentation`     /// signpost — so the state has to be reachable from a launch environment.     case scaleM4Tolerated(M4ToleratedFixtureState)     /// An .m4 composed-teaching store for the unified surface's UI tests:@@ -93,6 +93,18 @@ enum UITestFixtureKind: Equatable {     /// per-field sync merge or an asset still in flight produces. Every surface     /// has to present it as no cover at all, with nothing said (Req 6.4).     case coveredWorkMissingBytes+    /// A small legal library the Today screen has something to say about+    /// (`update-schedule`): three works carrying release days across the+    /// current weekday and the one before it, one of them on hiatus so it is+    /// scheduled by its days and excluded by its status (Req 6.1), and three+    /// entries — two dated the current day and one dated the day before, so+    /// both the current day and a past day hold a releases section and a noted+    /// section at once. Nothing else in the repository dates an entry on more+    /// than one civil day near the launch clock, so without this the strip's+    /// dots, Req 5.5's two placements and the exclusion are all unreachable+    /// from a launch. `seeded-works-options` and the rest are left alone: their+    /// suites assert exact orders that a fourth work would move.+    case today      /// Whether the seeded shape needs a second open before its diagnoses are     /// complete. `.invalidSiteTuple` is produced only by the full@@ -101,7 +113,7 @@ enum UITestFixtureKind: Equatable {     var requiresReopenAfterSeeding: Bool {         if case .tolerated = self { return true }         // Same reason, and it is load-bearing for the measurement rather than-        // only for the diagnosis screen: `recentPresentation` reads `diagnostics`+        // only for the diagnosis screen: `todayPresentation` reads `diagnostics`         // for the duplicated-hostname set that decides which rows offer an action         // (Q48/Q49). Publishing Recent against the empty-store diagnoses this         // repository opened with would measure the coherent path under a@@ -148,6 +160,9 @@ enum UITestLaunchSupport {     static let seededCoveredWorkScenario = "seeded-covered-work"     /// The same pair with the cover's bytes absent (Req 1.8, Req 6.4).     static let seededCoveredWorkMissingBytesScenario = "seeded-covered-work-missing-bytes"+    /// The three scheduled works and the two dated days the Today journeys run+    /// over.+    static let seededTodayScenario = "seeded-today"     /// One scenario per tolerated state, plus the illegal-tuple state that     /// carries the re-teach route and the empty-library shape Q15 hoists the     /// banner for. Keyed by the fixture's own raw value so a new shape needs no@@ -392,6 +407,8 @@ enum UITestLaunchSupport {             fixture = .coveredWork         case seededCoveredWorkMissingBytesScenario:             fixture = .coveredWorkMissingBytes+        case seededTodayScenario:+            fixture = .today         case let scenario where scenario.hasPrefix(seededScaleM4ToleratedPrefix):             guard let state = M4ToleratedFixtureState(                 rawValue: String(scenario.dropFirst(seededScaleM4ToleratedPrefix.count)))

diff --git a/Asterism/Asterism/ViewModels/AppLibraryModel.swift b/Asterism/Asterism/ViewModels/AppLibraryModel.swiftindex 8fe5596..2076f69 100644--- a/Asterism/Asterism/ViewModels/AppLibraryModel.swift+++ b/Asterism/Asterism/ViewModels/AppLibraryModel.swift@@ -1,8 +1,33 @@ import AsterismCore import AsterismIntelligence+import Combine import Foundation import OSLog +/// The facts about a calendar that change what a published cycle *means*+/// (`update-schedule` Q44, Q74).+///+/// Not the `Calendar` itself: two `Calendar` values differ for reasons a reader+/// never sees, and comparing them would abandon cycles for nothing. These three+/// are what Today is derived under — which calendar system the day components+/// came from, which zone bucketed the entries into days, and where the displayed+/// week starts.+///+/// **This is the abandon gate's comparison and nothing else** (Q74). The+/// calendar a cycle published under is published as the `Calendar` itself, so a+/// screen never has to reconstruct one from three lossy fields.+nonisolated private struct CalendarKey: Equatable, Sendable {+    let identifier: Calendar.Identifier+    let timeZoneIdentifier: String+    let firstWeekday: Int++    init(_ calendar: Calendar) {+        identifier = calendar.identifier+        timeZoneIdentifier = calendar.timeZone.identifier+        firstWeekday = calendar.firstWeekday+    }+}+ /// Root app state driving the loading/ready/unavailable lifecycle. @MainActor @Observable public final class AppLibraryModel {@@ -15,9 +40,18 @@ public final class AppLibraryModel {     }      public private(set) var state: State = .loading-    public private(set) var recentGroups: [DatedEntryGroup] = []-    public private(set) var recentPresentation: RecentPresentation = RecentPresentation(groups: [], actionableCount: 0)+    public private(set) var todayGroups: [DatedEntryGroup] = []+    public private(set) var todayPresentation: TodayPresentation = TodayPresentation(groups: [], actionableCount: 0)     public private(set) var worksSnapshot: WorksSnapshot = WorksSnapshot(works: [], unattachedEntries: [])+    /// Every scheduled work and the weekdays any of them is due on+    /// (`update-schedule` Q28), derived in Core from `worksSnapshot` and+    /// published in the same block as it.+    ///+    /// A published value rather than a derivation in the view: the Today screen+    /// reads it on every body pass, and `TodaySchedule.build` is O(works ++    /// entries) over the whole library.+    public private(set) var todaySchedule: TodaySchedule = TodaySchedule(+        works: [], dueWeekdays: [])     /// Every Work's display title by id, published with the snapshot it is     /// derived from.     ///@@ -66,9 +100,55 @@ public final class AppLibraryModel {     /// Production reaches `.ready` only after `refreshAll()`, so a zero     /// generation in a ready app means that refresh threw.     public private(set) var snapshotGeneration: Int = 0+    /// The calendar the published cycle was built under (`update-schedule` Q44,+    /// Q74).+    ///+    /// Published beside the snapshots and changed only at the publish gate, so+    /// the screens derive from the same calendar the cycle was read under rather+    /// than reaching for `Calendar.current` themselves. The *value* is published,+    /// not a three-field token of it: the locale's symbols and collation are not+    /// recoverable from a token, so a screen holding one would still have to+    /// read a second, possibly different, calendar to format anything.+    ///+    /// `CalendarKey` survives as the abandon gate's comparison only — two+    /// `Calendar` values differ for reasons a reader never sees, and abandoning+    /// a cycle on those would cost cycles for nothing.+    private(set) var calendar: Calendar+    /// The civil day it was `.now` on when the cycle published, under that+    /// calendar (Q39).+    ///+    /// **The app's only clock read for the Today screen.** `TodayView` holds no+    /// clock state of its own and no builder in `AsterismCore` reads one, so a+    /// day change is one thing moving in one place: `temporalChange` fires, the+    /// model re-reads, and every derived value follows the value published here.+    private(set) var currentDay: CivilDay     /// One gate value drives repository validation, navigation, teaching, Backup, and capture UI.     public let capabilities: AsterismCapabilities +    /// Which calendar a cycle is read under. A seam, and production never+    /// passes one: the gate below compares the key captured at entry against+    /// this read again at the publish, and no test can move `Calendar.current`+    /// under a running process.+    ///+    /// **Every calendar read in this type goes through it**, the two values+    /// above included — they used to reach for `Calendar.current` in their own+    /// initialisers, so a test that injected a calendar still got the host's+    /// day and first weekday until the first refresh published. A `let` taken+    /// at construction rather than a `var` set afterwards, for the same reason:+    /// a seam a caller can move mid-life is a seam the published values can be+    /// out of step with.+    @ObservationIgnored private let calendarSource: @MainActor () -> Calendar++    /// The day-change subscription, created once at construction and held for+    /// the life of the model (Q44).+    ///+    /// `AppLibraryModel` owns temporal invalidation rather than the view: the+    /// three values Today is built from — the entry presentation, the works+    /// snapshot and the current day — have to move together, and a view that+    /// re-derived its own day would be reading one of them under a calendar the+    /// other two were not built with.+    @ObservationIgnored private var temporalSubscription: AnyCancellable?+     /// Why the last diagnosis re-derivation failed, or nil when the published     /// diagnoses describe the store as it currently stands (Req 4.3).     ///@@ -167,8 +247,8 @@ public final class AppLibraryModel {     /// The resolved configuration after successful bootstrap.     private var resolvedConfiguration: LibraryConfiguration?     private var repository: (any LibraryProviding)?-    /// Retains the concrete repository for backup export (conforms to BackupV13SnapshotProviding).-    private var backupRepository: (any BackupV13SnapshotProviding)?+    /// Retains the concrete repository for backup export (conforms to BackupV14SnapshotProviding).+    private var backupRepository: (any BackupV14SnapshotProviding)?     /// A pre-bootstrap failure used to fail closed on invalid debug launch input.     private let startupFailureMessage: String?     /// Seeds only a fresh, explicit temporary configuration used by UI tests.@@ -210,8 +290,14 @@ public final class AppLibraryModel {         cloudKitContainerID: String? = nil,         mirroringDeclarationFailure: String? = nil,         locator: any SharedContainerLocating = SystemSharedContainerLocator(),-        capabilities: AsterismCapabilities = .current+        capabilities: AsterismCapabilities = .current,+        calendarSource: @escaping @MainActor () -> Calendar = { Calendar.current }     ) {+        // One read through the seam, seeding both published values (Q39, Q44).+        let calendar = calendarSource()+        self.calendarSource = calendarSource+        self.calendar = calendar+        self.currentDay = CivilDay(.now, calendar: calendar)         self.capabilities = capabilities         self.explicitConfiguration = nil         self.appGroupIdentifier = appGroupIdentifier@@ -220,13 +306,20 @@ public final class AppLibraryModel {         self.locator = locator         self.startupFailureMessage = nil         self.uiTestFixture = nil+        subscribeToTemporalChanges()     }      /// Test/explicit initializer: bypasses locator resolution entirely.     public init(         configuration: LibraryConfiguration,-        capabilities: AsterismCapabilities = .current+        capabilities: AsterismCapabilities = .current,+        calendarSource: @escaping @MainActor () -> Calendar = { Calendar.current }     ) {+        // One read through the seam, seeding both published values (Q39, Q44).+        let calendar = calendarSource()+        self.calendarSource = calendarSource+        self.calendar = calendar+        self.currentDay = CivilDay(.now, calendar: calendar)         self.capabilities = capabilities         self.explicitConfiguration = configuration         self.appGroupIdentifier = nil@@ -235,14 +328,21 @@ public final class AppLibraryModel {         self.locator = SystemSharedContainerLocator()         self.startupFailureMessage = nil         self.uiTestFixture = nil+        subscribeToTemporalChanges()     }      /// Debug UI-test initializer. The caller must provide an isolated temporary configuration.     init(         configuration: LibraryConfiguration,         uiTestFixture: UITestFixtureKind,-        capabilities: AsterismCapabilities = .current+        capabilities: AsterismCapabilities = .current,+        calendarSource: @escaping @MainActor () -> Calendar = { Calendar.current }     ) {+        // One read through the seam, seeding both published values (Q39, Q44).+        let calendar = calendarSource()+        self.calendarSource = calendarSource+        self.calendar = calendar+        self.currentDay = CivilDay(.now, calendar: calendar)         self.capabilities = capabilities         self.explicitConfiguration = configuration         self.appGroupIdentifier = nil@@ -251,6 +351,7 @@ public final class AppLibraryModel {         self.locator = SystemSharedContainerLocator()         self.startupFailureMessage = nil         self.uiTestFixture = uiTestFixture+        subscribeToTemporalChanges()     }      /// Test seam: publishes an already-open repository as `.ready` without a@@ -271,8 +372,14 @@ public final class AppLibraryModel {         readyRepository: any LibraryProviding,         configuration: LibraryConfiguration? = nil,         mirroringDeclarationFailure: String? = nil,-        capabilities: AsterismCapabilities = .current+        capabilities: AsterismCapabilities = .current,+        calendarSource: @escaping @MainActor () -> Calendar = { Calendar.current }     ) {+        // One read through the seam, seeding both published values (Q39, Q44).+        let calendar = calendarSource()+        self.calendarSource = calendarSource+        self.calendar = calendar+        self.currentDay = CivilDay(.now, calendar: calendar)         self.capabilities = capabilities         self.explicitConfiguration = configuration         self.appGroupIdentifier = nil@@ -286,13 +393,20 @@ public final class AppLibraryModel {         self.state = .ready         // The bootstrap's `attach` in one line, for a model that never runs one.         thumbnailLoader.attach(library: readyRepository)+        subscribeToTemporalChanges()     }      /// Constructs a model that can only render an unavailable state.     init(         startupFailureMessage: String,-        capabilities: AsterismCapabilities = .current+        capabilities: AsterismCapabilities = .current,+        calendarSource: @escaping @MainActor () -> Calendar = { Calendar.current }     ) {+        // One read through the seam, seeding both published values (Q39, Q44).+        let calendar = calendarSource()+        self.calendarSource = calendarSource+        self.calendar = calendar+        self.currentDay = CivilDay(.now, calendar: calendar)         self.capabilities = capabilities         self.explicitConfiguration = nil         self.appGroupIdentifier = nil@@ -301,6 +415,24 @@ public final class AppLibraryModel {         self.locator = SystemSharedContainerLocator()         self.startupFailureMessage = startupFailureMessage         self.uiTestFixture = nil+        subscribeToTemporalChanges()+    }++    // MARK: - Temporal ownership (`update-schedule` Q39, Q44)++    /// Subscribes to the one day-change stream, once, for the life of the model.+    ///+    /// The handler is a plain `refreshAll()`: what a day change invalidates is+    /// every calendar-derived value at once — the day buckets the entries fall+    /// into, the works snapshot's schedule and the current day itself — so+    /// re-running the cycle under the calendar now in force is the whole repair.+    /// The guarantee that a *stale* cycle cannot publish over it lives at the+    /// publish gate in `refreshAll`, not in a retry here.+    private func subscribeToTemporalChanges() {+        temporalSubscription = AppLifecycle.temporalChange.sink { [weak self] _ in+            // One refresh, under whatever calendar is in force now.+            Task { @MainActor in await self?.refreshAll() }+        }     }      /// Attempts to open the library; transitions to ready or unavailable.@@ -576,7 +708,7 @@ public final class AppLibraryModel {     /// restart the model sweeps, so `resumeSweeps()` is deliberately absent —     /// a Safari share on the Mac would otherwise start a suggestion pass every     /// time. What it is is a drain and the republish that carries what the-    /// drain committed into `recentPresentation`, which is how the row reaches+    /// drain committed into `todayPresentation`, which is how the row reaches     /// Recent inside Req 4.6's five seconds.     ///     /// The launch budget rather than the pass budget: something just arrived@@ -871,7 +1003,7 @@ public final class AppLibraryModel {      /// Re-derives the diagnoses, then rebuilds every snapshot from them.     ///-    /// Order matters: `recentPresentation` reads `diagnostics` for Req 4.1's+    /// Order matters: `todayPresentation` reads `diagnostics` for Req 4.1's     /// count and for the duplicated-hostname set that decides which rows offer an     /// action, so refreshing snapshots first would publish rows built against the     /// diagnoses of the previous moment.@@ -941,8 +1073,11 @@ public final class AppLibraryModel {             // generation. `StatsView` keys its derivation on that `Int`, so it             // would cache the stale derivation and never correct it.             let entered = snapshotGeneration-            let calendar = Calendar.current-            let presentation = try await repo.recentPresentation(calendar: calendar)+            let calendar = calendarSource()+            // Q44: what this cycle is *about*, captured before the first read+            // and held to at the publish gate below.+            let enteredCalendarKey = CalendarKey(calendar)+            let presentation = try await repo.todayPresentation(calendar: calendar)             let works = try await repo.works()             // `site-display-names` Q2: the name every screen calls a site by,             // read here beside the snapshots so the lookup a reader sees belongs@@ -987,12 +1122,28 @@ public final class AppLibraryModel {                     "Snapshot refresh abandoned: generation moved \(entered, privacy: .public) → \(self.snapshotGeneration, privacy: .public)")                 return nil             }+            // Q44's second gate, and it is unconditional rather than a retry.+            // The calendar moved while this cycle was reading, so every value it+            // holds — the day buckets, the schedule, the day it would call+            // "today" — describes a calendar that is no longer in force. The+            // temporal cycle entered *after* the change is the one that+            // publishes; abandoning here is what keeps a stale `calendar` or+            // `currentDay` from reaching a view for even one cycle.+            guard enteredCalendarKey == CalendarKey(calendarSource()) else {+                Self.logger.notice(+                    "Snapshot refresh abandoned: the calendar moved while it was reading")+                return nil+            }             // No `await` from here to the end of the block: a reader observes             // every value of one cycle, never most of this one beside one of the             // last.-            recentPresentation = presentation-            recentGroups = groups+            todayPresentation = presentation+            todayGroups = groups             worksSnapshot = works+            // Q28: one cycle's works snapshot and one cycle's schedule, so the+            // strip's dots and the releases section can never describe a+            // different moment from the rows beside them.+            todaySchedule = TodaySchedule.build(works: works.works, calendar: calendar)             self.siteNames = siteNames             workTitlesByID = Dictionary(                 works.works.map { ($0.id, $0.displayTitle) }, uniquingKeysWith: { first, _ in first })@@ -1001,6 +1152,11 @@ public final class AppLibraryModel {             // The lookup is passed in rather than read back off `self`, so the             // options are sorted by the names published beside them.             worksFilterOptions = WorksFilterOptions(works: works.works, siteNames: siteNames)+            // Q44: published in the same block as the snapshots they describe,+            // so a reader never holds one cycle's rows beside another cycle's+            // idea of what day it is.+            self.calendar = calendar+            currentDay = CivilDay(Date(), calendar: calendar)             snapshotGeneration += 1             // `work-thumbnails` Req 1.8: a slot's load is keyed on this, so a             // cover whose bytes arrived after its record did is asked for again@@ -1139,7 +1295,7 @@ public final class AppLibraryModel {     ) -> ComposedTeachingViewModel? {         guard capabilities.supportsSegmentTeaching,               let repo = repository,-              let row = recentPresentation.allRows.first(where: { $0.id == entryID }),+              let row = todayPresentation.allRows.first(where: { $0.id == entryID }),               row.actionType != .none else {             return nil         }@@ -1176,7 +1332,7 @@ public final class AppLibraryModel {     ) -> ComposedTeachingViewModel? {         guard capabilities.supportsSegmentTeaching,               let repo = repository,-              let row = recentPresentation.allRows.first(where: { $0.hostname == hostname })+              let row = todayPresentation.allRows.first(where: { $0.hostname == hostname })         else {             return nil         }@@ -1202,7 +1358,7 @@ public final class AppLibraryModel {     public func canComposeTeaching(forHostname hostname: String) -> Bool {         capabilities.supportsSegmentTeaching             && repository != nil-            && recentPresentation.allRows.contains { $0.hostname == hostname }+            && todayPresentation.allRows.contains { $0.hostname == hostname }     }      /// The Sites list (Req 6.1).@@ -1386,7 +1542,7 @@ public final class AppLibraryModel {     /// overlaying them here is what keeps the banner from reporting one moment's     /// sets beside another moment's conflicts.     public var duplicateBannerCount: Int {-        recentPresentation.duplicateWorkload.reviewCount + pendingConflicts.count+        todayPresentation.duplicateWorkload.reviewCount + pendingConflicts.count     }      /// Records a refused write so the banner and Check Library can carry it.@@ -1444,7 +1600,7 @@ public final class AppLibraryModel {     /// and no set will ever mention it, so a sweep would drop it the moment it     /// was recorded, taking the only notice of a preserved edit with it.     private func dropSettledConflicts() {-        let workload = recentPresentation.duplicateWorkload+        let workload = todayPresentation.duplicateWorkload         pendingConflicts.removeAll { pending in             switch pending.conflict {             case .torn, .disclosureStale:@@ -2116,7 +2272,7 @@ public final class AppLibraryModel {         guard let repo = backupRepository, let config = resolvedConfiguration else { return nil }         let stagingDir = config.rootDirectory             .appending(path: "Library/Caches/BackupExports")-        let exporter = BackupV13Exporter(+        let exporter = BackupV14Exporter(             repository: repo,             stagingDirectory: stagingDir         )@@ -2274,6 +2430,7 @@ public final class AppLibraryModel {                     + "below the light.",                 workStatus: reloaded.workStatus, readingStatus: reloaded.readingStatus,                 verdict: reloaded.verdict,+                releaseDays: reloaded.releaseDays,                 membership: reloaded.membership,                 thumbnail: .keep))         Self.logger.debug("Seeded the character-extraction UI test fixture")@@ -2286,16 +2443,25 @@ public final class AppLibraryModel {     /// than by date, so each of the four sorts draws a different list and a     /// journey can tell them apart:     ///-    /// | Work | Site | Captured | Type | Tags | Work status | Reading status | Verdict |-    /// |---|---|---|---|---|---|---|---|-    /// | Marrow Lane | alpha.test | first | — | mystery | ongoing | abandoned | yes |-    /// | Ashfall | beta.test | second | webtoon, then removed | — | hiatus | reading | — |-    /// | Zephyr Court | alpha.test | third | novel | — | finished | finished | yes |-    /// | Quill Harbour | beta.test | no entries | — | — | ongoing | reading | — |+    /// | Work | Site | Captured | Type | Tags | Work status | Reading status | Verdict | Release days |+    /// |---|---|---|---|---|---|---|---|---|+    /// | Marrow Lane | alpha.test | first | — | mystery | ongoing | abandoned | yes | Mon, Thu |+    /// | Ashfall | beta.test | second | webtoon, then removed | — | hiatus | reading | — | Sat |+    /// | Zephyr Court | alpha.test | third | novel | — | finished | finished | yes | — |+    /// | Quill Harbour | beta.test | no entries | — | — | ongoing | reading | — | — |     ///     /// Plus one unattached entry, so the group a filter hides (Q9) is on screen     /// before the filter is chosen.     ///+    /// `update-schedule` Req 11.2 gives two of the four release days and leaves+    /// two without, so the presence filter has both answers in one library. The+    /// days are fixed weekdays rather than ones derived from the launch clock —+    /// nothing here is about Today, and a suite reading the detail screen's+    /// meta line wants a spelling it can assert. **Neither work is scheduled**:+    /// Marrow Lane is abandoned and Ashfall is on hiatus, which is Req 11.2's+    /// point that the statuses play no part in the filter, and Req 6.1's that+    /// days alone do not put a work on Today.+    ///     /// `work-and-reading-status` gives the same four works their statuses, so     /// the one scenario drives the ordering, dimming, glyph, filter and detail     /// journeys as well as the sorts. **Marrow Lane is the abandoned one and@@ -2327,16 +2493,19 @@ public final class AppLibraryModel {             title: "Marrow Lane", hostname: "alpha.test", slug: "marrow",             type: .none, tags: ["mystery"],             workStatus: .ongoing, readingStatus: .abandoned,-            verdict: "Put it down when the fog plot stopped going anywhere.", in: repo)+            verdict: "Put it down when the fog plot stopped going anywhere.",+            releaseDays: [.monday, .thursday], in: repo)         try await seedWorksOptionsWork(             title: "Ashfall", hostname: "beta.test", slug: "ashfall",             type: .configured(webtoon.id), tags: [],-            workStatus: .hiatus, readingStatus: .reading, verdict: "", in: repo)+            workStatus: .hiatus, readingStatus: .reading, verdict: "",+            releaseDays: [.saturday], in: repo)         try await seedWorksOptionsWork(             title: "Zephyr Court", hostname: "alpha.test", slug: "zephyr",             type: .configured(novel.id), tags: [],             workStatus: .finished, readingStatus: .finished,-            verdict: "A tidy ending, and the court scenes earned it.", in: repo)+            verdict: "A tidy ending, and the court scenes earned it.",+            releaseDays: [], in: repo)          // After the assignment, so Ashfall keeps displaying a type the picker         // no longer offers — the `.removed` display the dimmed filter row is@@ -2357,11 +2526,13 @@ public final class AppLibraryModel {     ///     /// The statuses ride on the same final `updateWork` as the type and the     /// tags rather than a second write, so the work is finished before the next-    /// capture starts and the date order stays deterministic.+    /// capture starts and the date order stays deterministic. `update-schedule`+    /// gives the release days the same ride, for the same reason.     private func seedWorksOptionsWork(         title: String, hostname: String, slug: String,         type: WorkTypeAssignment, tags: [String],         workStatus: WorkStatus, readingStatus: ReadingStatus, verdict: String,+        releaseDays: [ReleaseDay],         in repo: LibraryRepository     ) async throws {         let entry = try await repo.capture(CaptureDraft(@@ -2383,10 +2554,179 @@ public final class AppLibraryModel {             draft: WorkMetadataDraft(                 displayTitle: title, typeAssignment: type, genreTags: tags, genericNotes: "",                 workStatus: workStatus, readingStatus: readingStatus, verdict: verdict,+                releaseDays: releaseDays,                 membership: reloaded.membership,                 thumbnail: .keep))     } +    /// `update-schedule`: the smallest library the Today screen has something+    /// to say about.+    ///+    /// Three works on one site, all of them carrying release days, seeded in+    /// this order — so the noted rows of the current day are in a known order+    /// and the works list's title order is not the seeding order:+    ///+    /// | Work | Work status | Reading status | Release days | Its entry |+    /// |---|---|---|---|---|+    /// | Kite Season | ongoing | reading | the current weekday | the current day |+    /// | Salt Harvest | ongoing | reading | the previous weekday | the current day |+    /// | Paper Lantern | hiatus | reading | both of those | **the previous day** |+    ///+    /// What that shape buys, in one scenario:+    ///+    /// - The current day holds a releases section (Kite Season) **and** two+    ///   noted rows, so Req 5.5's releases-first placement has two sections to+    ///   order. Kite Season is in both, which is what gives a release row the+    ///   `notedOnDay` line rather than the `lastNoted` one.+    /// - The previous day holds a releases section (Salt Harvest) and one noted+    ///   row (Paper Lantern), so notes-first placement on a past day is a claim+    ///   about an order rather than about an empty half.+    /// - **Paper Lantern is on hiatus with days on both weekdays**, so it is+    ///   scheduled by its days and excluded by its status on both days at once+    ///   (Req 6.1). It is the only work either day's releases section can be+    ///   wrong about.+    /// - The strip's dots fall on exactly those two weekdays; the other five+    ///   days of the week hold neither a release nor a note, which is where+    ///   both empty lines are reachable.+    ///+    /// - `today.test` is **taught** once the three captures are in, so every+    ///   entry carries a chapter title and every release row has a chapter line+    ///   to show (Req 5.2). See `teachTodaySite`.+    ///+    /// The days and the dates are computed from **the launch clock**, so the+    /// fixture means the same thing whatever day the suite runs on. Everything+    /// is written through the repository's own paths, except the one date that+    /// cannot be: `capture` dates every Entry now, so Paper Lantern's is moved+    /// back afterwards through `backdateEntry` (`TodayFixture`).+    ///+    /// **The previous day can fall in the previous displayed week** — on the+    /// calendar's first weekday it always does. The strip pages both ways with+    /// no bound (Q6), so a journey reaching that day derives it from the launch+    /// clock and pages back when it has to (Q55).+    ///+    /// **The other seeded scenarios are left alone**: their suites assert exact+    /// orders and counts that a fourth work or a second dated day would move.+    private func seedTodayFixture(in repo: LibraryRepository) async throws {+        let operation = "seeding the today UI test fixture"+        // Through the seam like every other calendar read in this type.+        let calendar = calendarSource()+        let now = Date()+        guard+            let previousDate = calendar.date(byAdding: .day, value: -1, to: now),+            let currentWeekday = ReleaseDay(+                calendarWeekday: calendar.component(.weekday, from: now)),+            let previousWeekday = ReleaseDay(+                calendarWeekday: calendar.component(.weekday, from: previousDate))+        else {+            throw LibraryRepositoryError.invalidInput(+                operation: operation,+                reason: "the calendar resolved no previous day for the launch clock")+        }++        _ = try await seedTodayWork(+            title: "Kite Season", slug: "kite", chapter: 12,+            releaseDays: [currentWeekday], workStatus: .ongoing, in: repo)+        _ = try await seedTodayWork(+            title: "Salt Harvest", slug: "salt", chapter: 4,+            releaseDays: [previousWeekday], workStatus: .ongoing, in: repo)+        let lanternEntry = try await seedTodayWork(+            title: "Paper Lantern", slug: "lantern", chapter: 31,+            releaseDays: ReleaseDay.canonical([currentWeekday, previousWeekday]),+            workStatus: .hiatus, in: repo)++        try await teachTodaySite(in: repo, operation: operation)++        #if DEBUG || ASTERISM_PERFORMANCE_TESTING+        try await repo.backdateEntry(id: lanternEntry, to: previousDate)+        #else+        throw LibraryRepositoryError.invalidInput(+            operation: operation, reason: "the today fixture requires a debug build")+        #endif+        Self.logger.debug("Seeded the today UI test fixture")+    }++    /// Teaches `today.test` the one rule that gives the fixture's entries a+    /// chapter line.+    ///+    /// Without it every `ScheduledWork.NotedDay.chapterLine` is nil, and Req+    /// 5.2's two furnished forms — `Noted today · {chapter line}` and+    /// `Last noted {chapter line} · {when}` — are unreachable over this+    /// scenario: a release row would only ever show the bare wording the+    /// chapter-less fallback draws.+    ///+    /// The definition is the `id.test` half of `seedComposedFixture`'s shape:+    /// the **last** segment of a `" - "` title is the work, so+    /// `"Chapter 12 - Kite Season"` parses to work "Kite Season" and chapter+    /// "Chapter 12" — which is the display title the three works already carry,+    /// so nothing is re-attributed. Segment teaching only, no URL rule: the+    /// chapter line is a title fact, and a URL identity rule would mint work+    /// identity the fixture has already decided by hand.+    ///+    /// It runs **after** the three captures rather than before them, because+    /// `capture(_:)` is the conservative door and never consults a rule; a+    /// teaching commit reparses every entry on the hostname, which is what+    /// backfills all three at once. The entries' assignments are protected —+    /// each was moved by hand — so the commit writes chapter titles and nothing+    /// else.+    private func teachTodaySite(+        in repo: LibraryRepository, operation: String+    ) async throws {+        let definition = PatternDefinition.segment(+            work: try SegmentRangeSpec(origin: .end, offset: 0, length: 1), ignored: [])+        let contract = try await repo.projectInitialTeaching(+            hostname: "today.test", patternDefinition: definition)+        switch try await repo.commitTeaching(contract) {+        case .committed:+            return+        case .refreshed:+            throw LibraryRepositoryError.invalidInput(+                operation: operation,+                reason: "a fresh isolated teaching contract unexpectedly became stale")+        case .invalidated(let reason):+            throw LibraryRepositoryError.invalidInput(+                operation: operation,+                reason: "teaching the today fixture's site was invalidated: \(reason)")+        }+    }++    /// One work of that fixture: a capture, a work on the same site, the move+    /// that puts one under the other, and the schedule the Today screen reads.+    ///+    /// Returns the Entry's identifier, which is the only one of the three rows+    /// the caller needs afterwards — to date one of them a day earlier.+    private func seedTodayWork(+        title: String, slug: String, chapter: Int,+        releaseDays: [ReleaseDay], workStatus: WorkStatus,+        in repo: LibraryRepository+    ) async throws -> UUID {+        let hostname = "today.test"+        let entry = try await repo.capture(CaptureDraft(+            captureTitle: "Chapter \(chapter) - \(title)",+            captureTitleSource: .host,+            rawURLString: "https://\(hostname)/\(slug)/\(chapter)"))+        let work = try await repo.createWork(+            NewWorkDraft(displayTitle: title, hostname: hostname))+        let assignment = try await repo.entry(id: entry.id)+        _ = try await repo.moveEntry(+            entry.id,+            basis: EntryAssignmentBasis(entry: assignment),+            to: .existing(work.id))++        let reloaded = try await repo.work(id: work.id)+        _ = try await repo.updateWork(+            id: work.id,+            basis: WorkEditBasis(work: reloaded),+            draft: WorkMetadataDraft(+                displayTitle: title,+                typeAssignment: reloaded.typeDisplay.assignment,+                genreTags: reloaded.genreTags, genericNotes: "",+                workStatus: workStatus, readingStatus: .reading, verdict: "",+                releaseDays: releaseDays,+                membership: reloaded.membership,+                thumbnail: .keep))+        return entry.id+    }+     /// `series-and-related-works`: the smallest library the series screens, the     /// series filter, the group toggle and the related-works section have     /// something to say about (Req 15.1).@@ -2489,6 +2829,7 @@ public final class AppLibraryModel {                 genreTags: [], genericNotes: "",                 workStatus: reloaded.workStatus, readingStatus: readingStatus,                 verdict: readingStatus == .abandoned ? "The fog plot went nowhere." : "",+                releaseDays: reloaded.releaseDays,                 membership: membership,                 thumbnail: .keep))         return work.id@@ -2622,6 +2963,7 @@ public final class AppLibraryModel {                 displayTitle: title, typeAssignment: reloaded.typeDisplay.assignment,                 genreTags: [], genericNotes: "",                 workStatus: reloaded.workStatus, readingStatus: .reading, verdict: "",+                releaseDays: reloaded.releaseDays,                 membership: reloaded.membership,                 // Nil rather than an empty draft for a work with no credits: the                 // two mean the same thing on a work that has none, and nil is@@ -2788,6 +3130,11 @@ public final class AppLibraryModel {             #endif         } +        if fixture == .today {+            try await seedTodayFixture(in: repository)+            return+        }+         if fixture == .composed {             // Production opens through the app-role opener, so the composed             // fixture seeds through the ordinary bootstrap, which creates and

diff --git a/Asterism/Asterism/ViewModels/ArrivingLibraryPresentation.swift b/Asterism/Asterism/ViewModels/ArrivingLibraryPresentation.swiftindex 082f0fc..d8b6f04 100644--- a/Asterism/Asterism/ViewModels/ArrivingLibraryPresentation.swift+++ b/Asterism/Asterism/ViewModels/ArrivingLibraryPresentation.swift@@ -7,7 +7,7 @@ import Foundation /// A Mac (or a second phone) opening against a populated CloudKit library has an /// empty local store for as long as the first import takes. Recent has said so /// since `cloudkit-mirroring` Req 6.5; this type is that decision lifted out of-/// `RecentView` so Works, Stats and backup import make it the same way, with the+/// `TodayView` so Works, Stats and backup import make it the same way, with the /// same words. The difference matters: "No works yet" invites the reader to /// start over, and "Import anyway?" is the question a reader deserves before a /// backup lands on a library still filling itself in.@@ -65,7 +65,7 @@ nonisolated enum ArrivingLibraryPresentation {     static let recentEmptyBranchHasContent = false      /// The wording, in one place so the three screens cannot drift apart. It is-    /// `RecentView`'s, unchanged.+    /// the Today screen's, unchanged.     static let title = "Arriving from iCloud"     static let systemImage = "icloud.and.arrow.down"     static let message =

diff --git a/Asterism/Asterism/ViewModels/RecentRowCap.swift b/Asterism/Asterism/ViewModels/RecentRowCap.swiftdeleted file mode 100644index 0612c30..0000000--- a/Asterism/Asterism/ViewModels/RecentRowCap.swift+++ /dev/null@@ -1,70 +0,0 @@-import AsterismCore-import Foundation--/// Req 1.1's cap on the Recent list: the newest 100 logical rows, with no-/// age-based exclusion (Decision 2).-///-/// A presentation boundary, not a derivation filter (Decision 1). `groups` keeps-/// its meaning — every logical row, ordered, day-grouped — so the library-wide-/// counts, the `allRows` teaching lookups, the banner filters and full-library-/// search all keep reading what they read today. Nothing in `AsterismCore`-/// changes; this is presentation logic over a published DTO, which is exactly-/// what `SearchFilters.swift` beside it already is (Q29).-///-/// Rows arrive ordered `lastSharedAt` descending, so the newest `limit` are a-/// plain prefix of the flattened set. The only real work is mapping that prefix-/// back onto day groups: whole groups, plus at most one truncated group at the-/// tail.-enum RecentRowCap {-    /// The fixed cap (Q3). Not user-configurable, and not a stored property on-    /// the DTO — a second copy of this number is a number that can disagree.-    static let rowLimit = 100--    /// The newest `limit` rows with day grouping preserved — whole groups plus-    /// at most one truncated group — and how many rows fall beyond them.-    ///-    /// One function returning both values rather than two each taking a limit:-    /// two independently defaulted limits could be called with different values-    /// and nothing would catch it (Q30). It also walks the groups once.-    ///-    /// The total is accumulated in the same walk that builds the capped groups,-    /// never from `allRows.count` — `allRows` is `groups.flatMap(\.rows)`, which-    /// would allocate the whole library on every `body` evaluation.-    ///-    /// `limit` must be positive; production always passes `rowLimit`.-    ///-    /// Day groups are assumed non-empty, which is what the derivation's grouping-    /// produces. The assumption is only a documentation one: an empty group-    /// satisfies `rows.count <= remaining` and would be copied into the capped-    /// set unchanged, rendering a day header with nothing under it. If an empty-    /// group ever becomes reachable upstream, drop it here rather than relying-    /// on the view to hide it.-    static func apply(-        to groups: [RecentPresentationGroup], limit: Int = rowLimit-    ) -> (groups: [RecentPresentationGroup], excludedRowCount: Int) {-        precondition(limit > 0, "The Recent cap must keep at least one row")--        var capped: [RecentPresentationGroup] = []-        capped.reserveCapacity(groups.count)-        var total = 0-        var remaining = limit--        for group in groups {-            total += group.rows.count-            guard remaining > 0 else { continue }-            if group.rows.count <= remaining {-                capped.append(group)-                remaining -= group.rows.count-            } else {-                // Req 1.2 accepts a partially shown oldest day group: the rows-                // are already in order, so the kept ones are its prefix.-                capped.append(-                    RecentPresentationGroup(-                        day: group.day, rows: Array(group.rows.prefix(remaining))))-                remaining = 0-            }-        }--        return (capped, max(0, total - limit))-    }-}

diff --git a/Asterism/Asterism/ViewModels/RecentSyncPresentation.swift b/Asterism/Asterism/ViewModels/RecentSyncPresentation.swiftindex 65ae6ad..b8f8a95 100644--- a/Asterism/Asterism/ViewModels/RecentSyncPresentation.swift+++ b/Asterism/Asterism/ViewModels/RecentSyncPresentation.swift@@ -7,7 +7,7 @@ import Foundation /// A pure function of the observed status, computed on every read by /// `AppLibraryModel.recentSyncPresentation`, so Recent moves when the monitor /// does without a relaunch (Req 8.6). The wording lives here rather than in the-/// view, per the `LibraryDiagnosticsModel` precedent — `RecentView` chooses+/// view, per the `LibraryDiagnosticsModel` precedent — `TodayView` chooses /// styling only. /// /// `nonisolated` on the type, not on one member (T-2094). The app target builds

diff --git a/Asterism/Asterism/ViewModels/SearchFilters.swift b/Asterism/Asterism/ViewModels/SearchFilters.swiftindex f8fe10a..7ede743 100644--- a/Asterism/Asterism/ViewModels/SearchFilters.swift+++ b/Asterism/Asterism/ViewModels/SearchFilters.swift@@ -36,13 +36,13 @@ struct RecentSearchFilter: Equatable {      /// Day groups are preserved; a group left with no rows is dropped rather     /// than rendered as an empty header (3.4).-    func apply(to groups: [RecentPresentationGroup]) -> [RecentPresentationGroup] {+    func apply(to groups: [TodayPresentationGroup]) -> [TodayPresentationGroup] {         guard isActive else { return groups }         let needle = self.needle         return groups.compactMap { group in             let rows = group.rows.filter { Self.matches($0, needle: needle) }             guard !rows.isEmpty else { return nil }-            return RecentPresentationGroup(day: group.day, rows: rows)+            return group.withRows(rows)         }     } @@ -50,7 +50,7 @@ struct RecentSearchFilter: Equatable {     /// title matches on its cleaned capture title **in place of** it (3.3) —     /// the row's `captureTitle` is already the cleaned display value, so a     /// junk-suffixed raw title is never the haystack.-    private static func matches(_ row: RecentPresentationRow, needle: String) -> Bool {+    private static func matches(_ row: TodayPresentationRow, needle: String) -> Bool {         contains(row.note, needle)             || contains(row.chapterTitle ?? row.captureTitle, needle)             || contains(row.workDisplayTitle, needle)

diff --git a/Asterism/Asterism/ViewModels/SeriesModels.swift b/Asterism/Asterism/ViewModels/SeriesModels.swiftindex 47e2af2..7b5c8c3 100644--- a/Asterism/Asterism/ViewModels/SeriesModels.swift+++ b/Asterism/Asterism/ViewModels/SeriesModels.swift@@ -600,6 +600,10 @@ public final class SeriesDetailModel {                     workStatus: work.workStatus,                     readingStatus: work.readingStatus,                     verdict: work.verdict,+                    // `update-schedule` Req 1.7: a position edit is a write to+                    // the work's whole metadata, so the schedule has to be sent+                    // back exactly as it was loaded or this save would clear it.+                    releaseDays: work.releaseDays,                     membership: membership,                     thumbnail: .keep))             if case .conflict(let conflict) = outcome {

diff --git a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift b/Asterism/Asterism/ViewModels/SettingsBackupModel.swiftindex 5de502f..a6b356c 100644--- a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift+++ b/Asterism/Asterism/ViewModels/SettingsBackupModel.swift@@ -5,20 +5,20 @@ import OSLog // MARK: - Backup Exporting Protocol  /// Test seam abstracting the exporter's operations needed by the Settings-/// surface. Conforms `BackupV13Exporter` to this protocol via extension below.+/// surface. Conforms `BackupV14Exporter` to this protocol via extension below. ///-/// Settings exports 13/14 (`work-thumbnails` Req 8.1): the archive+/// Settings exports 14/15 (`work-thumbnails` Req 8.1): the archive /// carries the reader's named places and their suppressions, a Work's site /// memberships, the reader's dismissed pairs, citations that name a rule by UUID /// alone, and the Work's two statuses and verdict. It is also the only format /// the app reads, so there is one exporter and one importer. public protocol BackupExporting: Sendable {-    func export(metadata: BackupV13Metadata) async throws -> BackupExportResult+    func export(metadata: BackupV14Metadata) async throws -> BackupExportResult     func cleanup(_ result: BackupExportResult)     func scavengeStaleFiles() } -extension BackupV13Exporter: BackupExporting {}+extension BackupV14Exporter: BackupExporting {}  // MARK: - Settings Backup View Model @@ -79,7 +79,7 @@ public final class SettingsBackupModel {         currentResult = nil          do {-            let metadata = BackupV13Metadata(+            let metadata = BackupV14Metadata(                 appBuild: Self.currentAppBuild(),                 exportedAt: Date()             )@@ -92,7 +92,7 @@ public final class SettingsBackupModel {             state = .failed             // Privacy-safe: log only the error category, never user content             errorMessage = Self.privacySafeMessage(for: error)-            if let exportError = error as? BackupV13ExportError,+            if let exportError = error as? BackupV14ExportError,                case .tornGroups = exportError {                 routesToCheckLibrary = true             }@@ -140,7 +140,7 @@ public final class SettingsBackupModel {         switch error {         case is BackupCodecError:             "Backup export failed due to an encoding error. Please try again."-        case let error as BackupV13ExportError:+        case let error as BackupV14ExportError:             exportMessage(for: error)         default:             "Backup export failed. Please try again."@@ -164,7 +164,7 @@ public final class SettingsBackupModel {     /// (`character-extraction` Req 6.5, Q105). It needs no new sentence: the     /// payload carries a count and a route, not a record kind, and Check Library     /// is where every torn group is resolved.-    private static func exportMessage(for error: BackupV13ExportError) -> String {+    private static func exportMessage(for error: BackupV14ExportError) -> String {         switch error {         case .tornGroups(let payload):             tornGroupsMessage(payload)@@ -181,7 +181,7 @@ public final class SettingsBackupModel {         // whole purpose is to send them to that work. Nothing else about the         // record travels: not the bytes, not the digest, not the shape.         case .unrepresentableValue(let record, let field, _)-        where field == BackupV13ExportError.thumbnailField:+        where field == BackupV14ExportError.thumbnailField:             "\(record) has a cover this backup cannot carry. Remove the cover in the work's "                 + "editor and export again — or, if the work is flagged as a duplicate, "                 + "resolve it first and the cover you keep will be backed up."@@ -219,7 +219,7 @@ public final class SettingsBackupModel {         switch error {         case let e as BackupCodecError:             "codec: \(e)"-        case let e as BackupV13ExportError:+        case let e as BackupV14ExportError:             exportDiagnosticCategory(e)         case let e as LibraryRepositoryError:             "repository: \(e)"@@ -230,7 +230,7 @@ public final class SettingsBackupModel {      /// The export refusals, by **category** rather than by message.     ///-    /// `BackupV13ExportError.description` is written for the reader and names+    /// `BackupV14ExportError.description` is written for the reader and names     /// the record: `Work “<title>”` for a cover (`work-thumbnails` Req 8.3) and     /// `Site <hostname>` for an unrepresentable site mode. The line above is     /// logged `privacy: .public`, so interpolating that description would put a@@ -238,7 +238,7 @@ public final class SettingsBackupModel {     /// process on the device can read. The refusal that names a record     /// therefore logs its **field** — a compile-time constant — and the reader     /// gets the title on screen, where it belongs.-    private static func exportDiagnosticCategory(_ error: BackupV13ExportError) -> String {+    private static func exportDiagnosticCategory(_ error: BackupV14ExportError) -> String {         switch error {         case .unrepresentableValue(_, let field, _):             "export: unrepresentable \(field)"

diff --git a/Asterism/Asterism/ViewModels/StatsDerivation.swift b/Asterism/Asterism/ViewModels/StatsDerivation.swiftindex cc207cb..68def8f 100644--- a/Asterism/Asterism/ViewModels/StatsDerivation.swift+++ b/Asterism/Asterism/ViewModels/StatsDerivation.swift@@ -3,8 +3,8 @@ import Foundation  // The Stats page's derivation (`specs/stats-page/`), and the state machine that // drives it. Presentation logic over two published DTOs, deliberately outside-// any `body` — the same thing `RecentRowCap.swift` and `SearchFilters.swift`-// beside it already are, and for the reason `recent-window-cap` Q26 gives:+// any `body` — the same thing `SearchFilters.swift` beside it already is,+// and for the reason `recent-window-cap` Q26 gives: // no app-layer test instantiates a SwiftUI view, so a rule left in `body` is a // rule nothing can check. //@@ -205,7 +205,7 @@ nonisolated struct StatsPeriodBounds: Equatable, Sendable { /// and which day is selected (Reqs 5.5, 6.7, 6.8, and `stats-period-navigation`). /// /// A value type rather than rules in `StatsView.body`, per Q41 and the-/// `RecentDisplayPlan` precedent: no app-layer test instantiates a SwiftUI view,+/// `TodayDisplayPlan` precedent: no app-layer test instantiates a SwiftUI view, /// so a transition left in `body` is a transition nothing can check. /// /// `scope` is **derived** from the stored fields and never stored, so the unit@@ -628,18 +628,18 @@ nonisolated enum StatsDerivation {      /// The bars for `scope`, and the two lifetime totals beside them.     ///-    /// Takes the `RecentPresentation` whole and reads `allRows` **inside**.+    /// Takes the `TodayPresentation` whole and reads `allRows` **inside**.     /// `allRows` is a computed `groups.flatMap(\.rows)`, so taking it in     /// `ContentView.body` would flatten the whole library on every republish,     /// for every tab, whether or not Stats is on screen — the Req 8.1 cost-    /// re-entering through the parameter list (`RecentRowCap.swift:31` records-    /// the same hazard).+    /// re-entering through the parameter list (`ListDetailPane` records the+    /// same hazard).     ///     /// `works` is the array rather than a count for the reason Decision 5     /// gives: the works total comes from the *other* snapshot, and a bare `Int`     /// would let a future maintainer feed it a number derived from `allRows`.     static func graph(-        presentation: RecentPresentation,+        presentation: TodayPresentation,         works: [WorkSnapshot],         scope: StatsScope,         calendar: Calendar@@ -694,7 +694,7 @@ nonisolated enum StatsDerivation {     }      private static func tally(-        in span: DateInterval, rows: [RecentPresentationRow]+        in span: DateInterval, rows: [TodayPresentationRow]     ) -> SpanTally {         var notes = 0         var workIDs: Set<UUID> = []@@ -770,7 +770,7 @@ nonisolated enum StatsDerivation {     /// single derivation keyed on the selected day would re-bucket every note in     /// the library on every frame (Q35).     static func breakdown(-        presentation: RecentPresentation,+        presentation: TodayPresentation,         day: Date,         calendar: Calendar     ) -> StatsBreakdown {@@ -798,7 +798,7 @@ nonisolated enum StatsDerivation {     // MARK: - Classification      /// Nil where the row carries no usable capture date (Req 3.8).-    private static func usableCaptureDate(_ row: RecentPresentationRow) -> Date? {+    private static func usableCaptureDate(_ row: TodayPresentationRow) -> Date? {         let captured = row.entry.firstCapturedAt         return captured < usableCaptureFloor ? nil : captured     }@@ -806,7 +806,7 @@ nonisolated enum StatsDerivation {     /// Never from `row.attention`, which reports `.workMissing` only when no     /// site-level cause outranks it — so a note whose site is also missing would     /// fall out of Req 6.4's category and silently break Req 6.5's sum (Q22).-    private static func category(of row: RecentPresentationRow) -> StatsCategory {+    private static func category(of row: TodayPresentationRow) -> StatsCategory {         guard let workID = row.entry.workID else { return .unattached }         guard let title = row.workDisplayTitle else { return .unresolvedWork }         return .work(id: workID, title: title)

diff --git a/Asterism/Asterism/ViewModels/WorkDetailModel.swift b/Asterism/Asterism/ViewModels/WorkDetailModel.swiftindex e557d55..5bab2fb 100644--- a/Asterism/Asterism/ViewModels/WorkDetailModel.swift+++ b/Asterism/Asterism/ViewModels/WorkDetailModel.swift@@ -224,6 +224,26 @@ public final class WorkDetailModel {     /// back to `finished`; any other reading change clears it.     public private(set) var autoRevertedReading = false +    // MARK: - The schedule (`update-schedule` Reqs 1.2-1.4, 1.6)++    /// The days the toggles show (Req 1.2).+    ///+    /// A plain bound property, unlike the two statuses above: toggling a day+    /// carries no transition rule, so there is nothing for a setter to enforce.+    /// A `Set` rather than an array because the order a reader taps in is not a+    /// fact about the work — the draft is canonicalised on its way out (Req 7.5).+    public var draftReleaseDays: Set<ReleaseDay> = []++    /// Req 1.4's line under the toggles: a schedule the Today screen will not+    /// list, said once, where the reader is setting it.+    ///+    /// Read off the **drafts**, so a reader who pauses a work and toggles a day+    /// in the same edit is told before they save rather than after.+    public var showsReleaseDaysNote: Bool {+        !draftReleaseDays.isEmpty+            && (draftWorkStatus != .ongoing || draftReadingStatus != .reading)+    }+     // Confirmed Work URL state is independent from metadata submission so a     // failed URL operation does not discard unrelated in-progress edits.     public var draftWorkURL: String = ""@@ -433,6 +453,10 @@ public final class WorkDetailModel {             draftWorkStatus = snapshot.workStatus             draftReadingStatus = snapshot.readingStatus             draftVerdict = snapshot.verdict+            // Req 1.2: the **tolerant** set, so a spelling this build cannot+            // name has no toggle to show. The raw column is what the dirty+            // check reads, which is how that work still offers a Save (Req 1.6).+            draftReleaseDays = Set(snapshot.releaseDays)             // `work-thumbnails`: the cover draft is reassigned **only outside             // edit mode**. A reload while the editor is open — the one a record             // step's commit runs — would otherwise throw away a crop the reader@@ -1817,6 +1841,13 @@ public final class WorkDetailModel {             // `work-thumbnails` Req 2.5: a cover set, replaced or removed is an             // unsaved change of the draft, exactly as an edited title is.             || hasUnsavedThumbnailChange+            // `update-schedule` Req 1.6: against the **raw** column, not the+            // tolerant set. A work carrying a spelling this build cannot name+            // holds more than the toggles can show, so comparing the two+            // tolerant sets would call it unchanged and leave the unknown value+            // standing forever. Compared as raw arrays, both canonical, so the+            // order a reader toggled in is not a change.+            || ReleaseDay.canonical(draftReleaseDays).map(\.rawValue) != work.releaseDaysRaw     }      // MARK: - View mode and edit mode (Decision 5)@@ -1973,6 +2004,9 @@ public final class WorkDetailModel {         draftWorkStatus = work.workStatus         draftReadingStatus = work.readingStatus         draftVerdict = work.verdict+        // Req 1.3's cancel: the toggles go back to what the row holds, as the+        // load seeded them.+        draftReleaseDays = Set(work.releaseDays)         // Q16: the *assignment* is a draft and goes back with the rest. The         // series the reader created from here is a row in the library and         // stays — `seriesOptions` is deliberately not restored.@@ -2471,6 +2505,12 @@ public final class WorkDetailModel {                 workStatus: draftWorkStatus,                 readingStatus: draftReadingStatus,                 verdict: draftVerdict,+                // `update-schedule` Req 1.3: the schedule rides this one commit+                // with the rest of the metadata — what the toggles show, in the+                // one canonical order (Req 7.5). A work carrying a spelling this+                // build cannot name is rewritten without it by exactly this+                // (Req 1.6).+                releaseDays: ReleaseDay.canonical(draftReleaseDays),                 // Req 2.3: the picker's selection and the position field, as one                 // value. A save that never touched either sends back what the                 // load put there, so the membership stays where it was.@@ -2505,7 +2545,14 @@ public final class WorkDetailModel {                     // status fields' reason (Q47). The draft may hold a crop                     // that is not stored anywhere yet; what the edit started                     // from is what a conflict is measured against.-                    thumbnail: thumbnailBaseline.identity)+                    thumbnail: thumbnailBaseline.identity,+                    // `update-schedule` Req 7.4: stated from the same drafts the+                    // draft above sends, for the status fields' reason (Q47) — a+                    // basis quietly holding the empty set would refuse every+                    // write on a scheduled work. This fallback is only reached+                    // with no loaded snapshot, where the toggles are what the+                    // editor showed.+                    releaseDays: ReleaseDay.canonical(draftReleaseDays))             let outcome = try await library.updateWork(id: workID, basis: basis, draft: draft)             if case .conflict(let conflict) = outcome {                 // No optimistic mutation and no draft reset: the edit is the

diff --git a/Asterism/Asterism/ViewModels/WorksListOptions.swift b/Asterism/Asterism/ViewModels/WorksListOptions.swiftindex abdd947..7ad9746 100644--- a/Asterism/Asterism/ViewModels/WorksListOptions.swift+++ b/Asterism/Asterism/ViewModels/WorksListOptions.swift@@ -141,13 +141,12 @@ nonisolated enum WorksSort: String, CaseIterable, Identifiable, Sendable {     /// Display titles by `localizedStandardCompare`, ties broken by the     /// lowercased id string ascending — the tie-break the repository already     /// uses, so two works sharing a title order the same way here as there.+    ///+    /// A forward since `update-schedule`: the comparison itself lives on+    /// `WorkSnapshot.titleOrder`, because Today's releases section orders its+    /// rows by the same collation and one of the two would eventually drift.     private static func titleAscending(_ left: WorkSnapshot, _ right: WorkSnapshot) -> Bool {-        switch left.displayTitle.localizedStandardCompare(right.displayTitle) {-        case .orderedAscending: return true-        case .orderedDescending: return false-        case .orderedSame:-            return left.id.uuidString.lowercased() < right.id.uuidString.lowercased()-        }+        WorkSnapshot.titleOrder(left, right)     } } @@ -208,6 +207,33 @@ nonisolated enum WorksCreatorSelection: Hashable, Sendable {     case creator(UUID) } +/// Whether a release-days filter is asking for the works that carry a schedule+/// or the works that carry none (`update-schedule` Req 11.1).+///+/// A closed two-value vocabulary, like the two statuses: it carries nothing in+/// `WorksFilterOptions` and `pruned(to:)` never touches it, so both answers stay+/// offered whether or not a work answers to either (Req 11.3).+///+/// `noReleaseDays` and `hasReleaseDays` rather than `none` and `some`, for+/// `WorksSeriesSelection.noSeries`' reason (Q51 of `series-and-related-works`):+/// the filter holds this as an `Optional`, where a case called `none` resolves+/// to `Optional.none` wherever the type is inferred — so "works with no+/// schedule" would silently read as "Any". The **raw** values stay `none` and+/// `some`: they are what the menu rows are keyed by, and a spelling in a UI+/// journey should not move because a Swift case had to be renamed.+nonisolated enum ReleaseDayPresence: String, CaseIterable, Hashable, Sendable {+    case noReleaseDays = "none"+    case hasReleaseDays = "some"++    /// What the picker row, the pill and the empty state all call it (Req 11.3).+    var name: String {+        switch self {+        case .noReleaseDays: "No release days"+        case .hasReleaseDays: "Has release days"+        }+    }+}+ /// The Works list's five single-value filters (Req 5, Q3; /// `work-and-reading-status` Req 6.1). ///@@ -231,11 +257,15 @@ nonisolated struct WorksFilter: Equatable, Sendable {     var creator: WorksCreatorSelection?     var workStatus: WorkStatus?     var readingStatus: ReadingStatus?+    /// `update-schedule` Req 11.1. In menu order it sits after the reading+    /// status, which is where the pills and the empty state name it too.+    var releaseDays: ReleaseDayPresence?      init(         type: WorksTypeSelection? = nil, tag: String? = nil, hostname: String? = nil,         series: WorksSeriesSelection? = nil, creator: WorksCreatorSelection? = nil,-        workStatus: WorkStatus? = nil, readingStatus: ReadingStatus? = nil+        workStatus: WorkStatus? = nil, readingStatus: ReadingStatus? = nil,+        releaseDays: ReleaseDayPresence? = nil     ) {         self.type = type         self.tag = tag@@ -244,11 +274,12 @@ nonisolated struct WorksFilter: Equatable, Sendable {         self.creator = creator         self.workStatus = workStatus         self.readingStatus = readingStatus+        self.releaseDays = releaseDays     }      var isActive: Bool {         type != nil || tag != nil || hostname != nil || series != nil || creator != nil-            || workStatus != nil || readingStatus != nil+            || workStatus != nil || readingStatus != nil || releaseDays != nil     }      func apply(to works: [WorkSnapshot]) -> [WorkSnapshot] {@@ -262,9 +293,10 @@ nonisolated struct WorksFilter: Equatable, Sendable {     /// checkmark anywhere in that section, and the reader's only way out is     /// Clear.     ///-    /// The two statuses are deliberately absent (Q30): a closed vocabulary-    /// cannot stop being offered, and Req 6.3 wants a status value selectable-    /// and kept whether or not any work currently carries it.+    /// The two statuses and the release-days presence are deliberately absent+    /// (Q30): a closed vocabulary cannot stop being offered, and Req 6.3 — with+    /// Req 11.3 of `update-schedule` — wants such a value selectable and kept+    /// whether or not any work currently carries it.     func pruned(to options: WorksFilterOptions) -> WorksFilter {         var pruned = self         if let type, !options.types.contains(where: { $0.selection == type }) { pruned.type = nil }@@ -307,6 +339,14 @@ nonisolated struct WorksFilter: Equatable, Sendable {         // (Reqs 1.3, 2.7).         if let workStatus, work.workStatus != workStatus { return false }         if let readingStatus, work.readingStatus != readingStatus { return false }+        // Req 11.2: asked of the *tolerant* set, so a row holding only a+        // spelling this build cannot name answers "No release days" — what the+        // reader can see of the schedule is none. The statuses play no part: a+        // finished work with days set still has a schedule, whether or not+        // Today would ever list it.+        if let releaseDays, work.releaseDays.isEmpty != (releaseDays == .noReleaseDays) {+            return false+        }         return true     } @@ -576,6 +616,10 @@ nonisolated enum WorksFilterPresentation {         if let readingStatus = filter.readingStatus {             labels.append(ReadingStatusPresentation.accessibilityLabel(readingStatus))         }+        // `update-schedule` Req 11.3: last, where the picker sits. Its two names+        // already say which dimension they are about, so unlike the statuses+        // there is nothing to qualify.+        if let releaseDays = filter.releaseDays { labels.append(releaseDays.name) }         return labels     } @@ -669,6 +713,16 @@ nonisolated enum WorksFilterPresentation {     static func readingStatusRowIdentifier(_ status: ReadingStatus) -> String {         "works-filter-reading-status-\(status.rawValue)"     }++    // MARK: - The release-days dimension (`update-schedule` Req 11.1)++    static let anyReleaseDaysRowIdentifier = "works-filter-release-days-any"++    /// Keyed by the raw value, as the two statuses are: it is the spelling a+    /// journey addresses, and it survives a rename of the Swift case.+    static func releaseDaysRowIdentifier(_ presence: ReleaseDayPresence) -> String {+        "works-filter-release-days-\(presence.rawValue)"+    } }  /// One run of rows the Works list draws under one header, or under none

diff --git a/Asterism/Asterism/Views/DuplicateResolutionView.swift b/Asterism/Asterism/Views/DuplicateResolutionView.swiftindex effd47e..c90a0fa 100644--- a/Asterism/Asterism/Views/DuplicateResolutionView.swift+++ b/Asterism/Asterism/Views/DuplicateResolutionView.swift@@ -333,6 +333,16 @@ struct DuplicateResolutionView: View {                     .foregroundStyle(.secondary)                     .accessibilityIdentifier("duplicate-variant-verdict")             }+            // V15 (`update-schedule` Req 7.2): a non-empty schedule is authored,+            // so two copies disagreeing on it are a decision the sheet has to+            // name — and it names the days, because "a different schedule" is+            // not something the reader can choose between.+            if let days = Self.releaseDaysLine(variant, differing: model.differingFields) {+                Text(days)+                    .font(.caption)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("duplicate-variant-release-days")+            }             Text(variant.firstCapturedAt, style: .date)                 .font(.caption2)                 .foregroundStyle(.tertiary)@@ -400,6 +410,27 @@ struct DuplicateResolutionView: View {         return "Series: \(name) · \(SeriesPosition.format(membership.position, locale: locale))"     } +    /// The schedule line (`update-schedule` Req 7.2).+    ///+    /// Labelled like the arms above, and stating "No release days" rather than+    /// going blank for the series line's reason: "this copy has no schedule" is+    /// exactly what one side of the choice says, and an absent line would read+    /// as an omission.+    ///+    /// The abbreviations and their order are `ReleaseDaysText`'s, so the sheet,+    /// the editor's toggles and the meta line read in the reader's own region+    /// (Q11) and cannot come to spell one schedule three ways. The canonical+    /// storage order is never displayed.+    static func releaseDaysLine(+        _ variant: WorkVariantChoice, differing: [DuplicateResolutionField],+        calendar: Calendar = .current+    ) -> String? {+        guard differing.contains(.releaseDays) else { return nil }+        guard !variant.releaseDays.isEmpty else { return "No release days" }+        return "Release days: "+            + ReleaseDaysText.abbreviated(variant.releaseDays, calendar: calendar)+    }+     private func ratingLabel(_ rating: Rating?) -> String {         switch rating {         case .up: "▲"

diff --git a/Asterism/Asterism/Views/ReleaseDaysPresentation.swift b/Asterism/Asterism/Views/ReleaseDaysPresentation.swiftnew file mode 100644index 0000000..7ebc02f--- /dev/null+++ b/Asterism/Asterism/Views/ReleaseDaysPresentation.swift@@ -0,0 +1,198 @@+import AsterismCore+import ConstellationKit+import SwiftUI++// The reader-facing side of a work's schedule (`update-schedule` Reqs 1.2-1.4,+// 2.1, 2.2): how a set of release days is spelled, and the seven toggles that+// set it.+//+// Every order here is `ReleaseDay.ordered(for:)`, which starts at the region's+// first weekday (Q11). The canonical case order is storage and wire only, and+// nothing on this page displays it.++/// How a set of release days reads, in one place so the meta line, the editor+/// and the duplicate sheet cannot come to spell one schedule three ways.+///+/// `nonisolated` for `WorksFilterPresentation`'s reason: pure functions of value+/// types, reachable from anywhere that holds the days.+nonisolated enum ReleaseDaysText {++    /// The three-letter abbreviations in the region's order, joined by ` · `+    /// (Req 2.1) — `Mon · Thu`. The empty set is the empty string; every caller+    /// decides for itself what an unscheduled work says, because the answer+    /// differs: the meta line adds no item at all, the duplicate sheet names the+    /// absence.+    static func abbreviated(_ days: some Sequence<ReleaseDay>, calendar: Calendar) -> String {+        names(days, calendar: calendar, symbols: calendar.shortWeekdaySymbols)+            .joined(separator: " · ")+    }++    /// What assistive technology hears (Req 2.2): "Releases on Monday and+    /// Thursday". The abbreviations of the visible line are for the eye — spoken+    /// aloud, "Mon" is a word the reader has to decode.+    ///+    /// The empty string for an empty set, so a caller that forgets to gate on it+    /// says nothing rather than "Releases on".+    static func spoken(_ days: some Sequence<ReleaseDay>, calendar: Calendar) -> String {+        let full = names(days, calendar: calendar, symbols: calendar.weekdaySymbols)+        guard !full.isEmpty else { return "" }+        return "Releases on " + sentence(full)+    }++    /// One day's full name, for the toggle that sets it.+    static func name(_ day: ReleaseDay, calendar: Calendar) -> String {+        symbol(day, in: calendar.weekdaySymbols)+    }++    /// One day's one-letter abbreviation, the toggle's visible label (Req 1.2).+    static func veryShortName(_ day: ReleaseDay, calendar: Calendar) -> String {+        symbol(day, in: calendar.veryShortWeekdaySymbols)+    }++    /// The days held, in the region's order, named from the given symbol array.+    ///+    /// Taken through a `Set` rather than by filtering the sequence, so a caller+    /// handing over an array in the order the reader toggled in still reads back+    /// in calendar order, and a duplicate cannot be named twice.+    private static func names(+        _ days: some Sequence<ReleaseDay>, calendar: Calendar, symbols: [String]+    ) -> [String] {+        let held = Set(days)+        return ReleaseDay.ordered(for: calendar)+            .filter(held.contains)+            .map { symbol($0, in: symbols) }+    }++    /// Foundation's weekday symbol arrays are **Sunday-first** whatever the+    /// calendar's first weekday is, so the index is the day's weekday number+    /// minus one. An off-by-one here would call the reader's Thursday "Wed" on+    /// every surface at once.+    ///+    /// Internal rather than private for the one caller that has already read the+    /// array: `ReleaseDayToggles` draws seven days from two symbol arrays, and+    /// `Calendar` rebuilds one on every read.+    static func symbol(_ day: ReleaseDay, in symbols: [String]) -> String {+        let index = day.calendarWeekday - 1+        guard symbols.indices.contains(index) else { return day.rawValue }+        return symbols[index]+    }++    /// "Monday", "Monday and Thursday", "Monday, Thursday and Sunday".+    private static func sentence(_ names: [String]) -> String {+        guard let last = names.last else { return "" }+        guard names.count > 1 else { return last }+        return names.dropLast().joined(separator: ", ") + " and " + last+    }+}++/// Req 1.2's seven toggles: one per weekday, in the region's order, each on or+/// off.+///+/// A row of round buttons rather than seven `Toggle`s: the whole point is that+/// a week is seven things seen at once, and seven switches stacked down a card+/// is a form. The recipe is the segmented capsule's selected colours+/// (`docs/asterism-style-guide.md` §7), which is what the reader already reads+/// as "this one is chosen" on the two status capsules directly above.+///+/// Nothing here writes: the binding is the model's draft, and the reader's+/// confirmation is what commits it with the rest of the metadata (Req 1.3).+struct ReleaseDayToggles: View {+    @Binding var selection: Set<ReleaseDay>+    var calendar: Calendar = .current++    /// Req 10.4: at an accessibility content size seven 44 pt targets cannot+    /// share a line, and §10 forbids both shrinking and truncation — so they+    /// wrap. The branch is on the size class rather than on fit, for the week+    /// strip's reason (Q35): a layout that depends on measurement is a layout+    /// that differs between two devices at the same setting.+    @Environment(\.dynamicTypeSize) private var dynamicTypeSize+    /// §11.1: the opaque colour *replaces* the translucent one rather than+    /// sitting beside it. The off state drew `fieldFill` unconditionally, which+    /// is the same near-invisible field the wide layout's search field was.+    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency++    var body: some View {+        Group {+            if dynamicTypeSize.isAccessibilitySize {+                FlowLayout(spacing: 4) { toggles }+            } else {+                HStack(spacing: 4) { toggles }+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        // `children: .contain` so each day stays an element of its own. No+        // label of its own: the only caller wraps this in+        // `constellationCaptionedField("Release days")`, whose caption is a+        // sibling `Text` VoiceOver already reads — a label here made the reader+        // hear "Release days" twice before the first weekday.+        .accessibilityElement(children: .contain)+    }++    private var toggles: some View {+        // Foundation rebuilds both symbol arrays on every read, so they are+        // taken once per body pass rather than twice per toggle.+        let names = calendar.weekdaySymbols+        let letters = calendar.veryShortWeekdaySymbols+        return ForEach(ReleaseDay.ordered(for: calendar), id: \.self) { day in+            toggle(day, name: ReleaseDaysText.symbol(day, in: names),+                letter: ReleaseDaysText.symbol(day, in: letters))+        }+    }++    /// A 40 pt circle inside a 44 pt target (§10), so the visible mark can stay+    /// the size of a day of the week while the thing under the finger does not.+    private func toggle(_ day: ReleaseDay, name: String, letter: String) -> some View {+        let isOn = selection.contains(day)+        return Button {+            if isOn {+                selection.remove(day)+            } else {+                selection.insert(day)+            }+        } label: {+            Text(letter)+                .font(.caption.weight(.semibold))+                .lineLimit(1)+                .foregroundStyle(isOn ? AsterismColors.cyan : AsterismColors.secondaryText)+                .frame(width: 40, height: 40)+                .background {+                    // The selected mark is the segmented capsule's, at a circle+                    // instead of a capsule; the off state is the flat field,+                    // through the rule that swaps it under Reduce Transparency.+                    Circle()+                        .fill(+                            isOn+                                ? AsterismColors.selectedMarkFill+                                : ConstellationField.fill(+                                    reduceTransparency: reduceTransparency)+                        )+                        .overlay {+                            Circle()+                                .strokeBorder(+                                    isOn ? AsterismColors.selectedMarkBorder : Color.clear,+                                    lineWidth: 1.5)+                        }+                }+                .frame(minWidth: 44, minHeight: 44)+                .contentShape(Rectangle())+        }+        // `.plain`, as the segmented capsule's segments are: sibling buttons in+        // one row bleed their hit areas into each other otherwise.+        .buttonStyle(.plain)+        .accessibilityIdentifier(Self.identifier(day))+        // The full name and the state, because the visible letter is neither:+        // "M" is not a word, and a circle's fill is not something to hear.+        .accessibilityLabel("\(name), \(isOn ? "on" : "off")")+    }++    /// The toggle's identifier, keyed by the **stored** spelling — which is+    /// frozen with the column, so a journey addressing a toggle is addressing+    /// the day itself rather than a symbol the region could re-spell.+    static func identifier(_ day: ReleaseDay) -> String {+        "work-detail-release-day-\(day.rawValue)"+    }++    /// Req 1.4's line under the toggles.+    static let noteIdentifier = "work-detail-release-days-note"+    static let note = "Shown on Today only while the work is ongoing and you are reading it"+}

diff --git a/Asterism/Asterism/Views/ScreenSky.swift b/Asterism/Asterism/Views/ScreenSky.swiftindex 1f08351..59d4802 100644--- a/Asterism/Asterism/Views/ScreenSky.swift+++ b/Asterism/Asterism/Views/ScreenSky.swift@@ -8,7 +8,7 @@ extension View {     /// The compact tree has no container above the screen that can hold a sky —     /// each tab is its own stack, and a background applied *outside* a stack     /// renders behind the stack's own opaque backing and never reaches the-    /// screen (`RecentView` records the measurement). So every screen paints its+    /// screen (`TodayView` records the measurement). So every screen paints its     /// own there. The wide tree does have such a container, and Req 3.1 says one     /// layer per window, so it passes `showsSky: false` all the way down and     /// supplies the sky itself through ``windowSky()`` / ``paneSky()``.

diff --git a/Asterism/Asterism/Views/StatsView.swift b/Asterism/Asterism/Views/StatsView.swiftindex 6bc8f54..0b8bd19 100644--- a/Asterism/Asterism/Views/StatsView.swift+++ b/Asterism/Asterism/Views/StatsView.swift@@ -23,7 +23,7 @@ struct StatsView: View {     /// `groups.flatMap(\.rows)`, so reading it in `ContentView.body` would     /// flatten the library on every republish for every tab — the Req 8.1 cost     /// re-entering through the parameter list.-    let presentation: RecentPresentation+    let presentation: TodayPresentation     /// The *other* snapshot. An array rather than a count, per Decision 5: the     /// works total may not be derived from `allRows`.     let works: [WorkSnapshot]@@ -78,17 +78,15 @@ struct StatsView: View {         // selected is neither, and tab lifecycle for the value-based `Tab` API is         // undocumented (Q36), so presentation gets its own trigger.         .onChange(of: isPresented) { _, _ in deriveIfNeeded() }-        // Midnight, DST, carrier time, and the ones queued while suspended. On-        // the Mac the platform has no single such notification, so-        // `AppLifecycle` merges the day/clock/zone three into it.-        .onReceive(AppLifecycle.significantTimeChange) { _ in-            temporal = .current()-        }-        // Q39: two zones can share a UTC offset and differ in week rules, which-        // changes what "This week" means without moving the day stamp.-        .onReceive(-            NotificationCenter.default.publisher(for: .NSSystemTimeZoneDidChange)-        ) { _ in+        // Midnight, DST, carrier time, a zone change, and the ones queued while+        // suspended. One publisher since `update-schedule` Q44: this screen+        // subscribed to `significantTimeChange` and the zone notification+        // separately, and on the Mac the zone notification is in *both* — so one+        // zone change re-derived the period twice. `temporalChange` merges the+        // zone notification on iOS only, which is the platform that needs it.+        // Q39 still holds: two zones can share a UTC offset and differ in week+        // rules, which changes what "This week" means without moving the day.+        .onReceive(AppLifecycle.temporalChange) { _ in             temporal = .current()         }     }

diff --git a/Asterism/Asterism/Views/TodayText.swift b/Asterism/Asterism/Views/TodayText.swiftnew file mode 100644index 0000000..f93b8ee--- /dev/null+++ b/Asterism/Asterism/Views/TodayText.swift@@ -0,0 +1,243 @@+import AsterismCore+import Foundation++// How the Today screen spells a day: its title, its section headers, a release+// row's second line, and the week strip's labels (`update-schedule` Reqs 4.4,+// 4.5, 5.1, 5.2, 5.4).+//+// All of it is app-layer on purpose. `AsterismCore` decides *which* arm a row+// takes — `ReleaseRow.Line`, `RelativeDay` — and this file decides what that arm+// reads like, because the wording is a locale's and the builders are not+// allowed to know one (Q28).+//+// `nonisolated` throughout, for `ReleaseDaysText`' reason: pure functions of+// value types, reachable from anywhere that holds a day.++/// The two date shapes Today spells a day in, both stamped with the calendar in+/// hand (Q73).+///+/// `Date.formatted(date:time:)` reads `Locale.autoupdatingCurrent` and+/// `TimeZone.autoupdatingCurrent` and ignores whatever calendar the caller is+/// deriving under, so a screen built under one calendar would date its rows+/// under another — the failure a `calendar` parameter exists to prevent. This is+/// `StatsPeriodNaming`'s stamping, in the one place Today's date texts share.+///+/// The shapes are constant, so they are built once; only the three stamps move+/// per call.+nonisolated enum TodayDateText {+    private static let completeStyle = Date.FormatStyle(date: .complete, time: .omitted)+    private static let abbreviatedStyle = Date.FormatStyle(date: .abbreviated, time: .omitted)++    /// The full date, weekday included — the title's caption and a strip cell's+    /// accessibility label.+    static func complete(_ day: CivilDay, calendar: Calendar) -> String {+        day.date(in: calendar).formatted(stamped(completeStyle, with: calendar))+    }++    /// The abbreviated date — a release row's fallback `{when}` and a spanning+    /// section's header.+    static func abbreviated(_ day: CivilDay, calendar: Calendar) -> String {+        day.date(in: calendar).formatted(stamped(abbreviatedStyle, with: calendar))+    }++    /// The calendar's system, its zone, and its locale where it carries one. A+    /// nil locale states nothing about language and keeps the formatter's own.+    private static func stamped(+        _ style: Date.FormatStyle, with calendar: Calendar+    ) -> Date.FormatStyle {+        var stamped = style+        stamped.calendar = calendar+        stamped.timeZone = calendar.timeZone+        if let locale = calendar.locale { stamped.locale = locale }+        return stamped+    }+}++/// The screen's title, its caption and its two section headers (Reqs 4.4, 5.1,+/// 5.4).+nonisolated enum TodayTitleText {+    /// `Today`, `Yesterday`, `Tomorrow`, or the weekday's full name (Req 4.4).+    ///+    /// The three relative words cover the days a reader thinks of relatively; a+    /// day further out is named by its weekday, which is what the strip is+    /// pointing at. The full date is the caption's job, not the title's.+    static func title(for day: CivilDay, current: CivilDay, calendar: Calendar) -> String {+        if day == current { return "Today" }+        if day == current.adding(days: -1, calendar: calendar) { return "Yesterday" }+        if day == current.adding(days: 1, calendar: calendar) { return "Tomorrow" }+        return weekday(day, calendar: calendar)+    }++    /// The same title for a *selection*, which is what both the screen's+    /// navigation title and the wide tree's list-column heading are asked for+    /// (Req 4.4).+    ///+    /// One entry point, so the two cannot disagree: the column heading is drawn+    /// outside the screen and never sees its navigation title, and a literal+    /// "Today" there left the column headed Today with Yesterday selected.+    static func title(+        for selection: TodaySelection, current: CivilDay, calendar: Calendar+    ) -> String {+        title(for: selection.day(currentDay: current), current: current, calendar: calendar)+    }++    /// The selected day's full date in the reader's locale, under the title+    /// (Req 4.4).+    static func caption(for day: CivilDay, calendar: Calendar) -> String {+        TodayDateText.complete(day, calendar: calendar)+    }++    /// `Releasing today` for the current day, `Releasing {weekday}` otherwise+    /// (Req 5.1). No count: Q31.+    ///+    /// Never `Released`, even for a past day (Q15): nothing in the library+    /// records that a release *happened*, so the past tense would assert an+    /// event the app never observed.+    static func releasesHeader(+        for day: CivilDay, current: CivilDay, calendar: Calendar+    ) -> String {+        day == current ? "Releasing today" : "Releasing \(weekday(day, calendar: calendar))"+    }++    /// `Noted today` for the current day, `Noted {weekday}` otherwise (Req 5.4).+    static func notedHeader(+        for day: CivilDay, current: CivilDay, calendar: Calendar+    ) -> String {+        day == current ? "Noted today" : "Noted \(weekday(day, calendar: calendar))"+    }++    /// The weekday's full name in the reader's locale.+    static func weekday(_ day: CivilDay, calendar: Calendar) -> String {+        ReleaseDaysText.name(day.weekday(calendar: calendar), calendar: calendar)+    }+}++/// A release row's second line: Req 5.2's closed table, spelled (Q16, Q34,+/// Q37).+nonisolated enum ReleaseLineText {+    /// The line for one arm, against the day being shown.+    ///+    /// The chapter line takes its ` · ` with it when it is absent — the+    /// separator belongs to the *pair*, and the two arms put the pair on+    /// different sides: `Noted today · {chapter}` trails it and+    /// `Last noted {chapter} · {when}` sits between the chapter and the when+    /// (Req 5.2's last sentence).+    static func line(+        _ line: ReleaseRow.Line, selectedDay: CivilDay, currentDay: CivilDay,+        calendar: Calendar+    ) -> String {+        switch line {+        case .notedOnDay(let chapterLine):+            // The same sentence Req 5.4's section header is, so the row and the+            // header it sits under cannot word the day two ways.+            let noted = TodayTitleText.notedHeader(+                for: selectedDay, current: currentDay, calendar: calendar)+            guard let chapter = spelled(chapterLine) else { return noted }+            return "\(noted) · \(chapter)"+        case .lastNoted(let chapterLine, let when):+            let relative = relativeDay(when, calendar: calendar)+            guard let chapter = spelled(chapterLine) else { return "Last noted \(relative)" }+            return "Last noted \(chapter) · \(relative)"+        case .notNotedYet:+            return "Not noted yet"+        }+    }++    /// The chapter line if there is one to show. An entry with neither a chapter+    /// title nor a chapter sequence has none, and an empty string is the same+    /// absence spelled differently.+    private static func spelled(_ chapterLine: String?) -> String? {+        guard let chapterLine, !chapterLine.isEmpty else { return nil }+        return chapterLine+    }++    /// Req 5.2's `{when}`: the closed table, because no relative-date formatter+    /// answers "last week" for a seven-to-thirteen-day gap, and because a+    /// forward-relative phrase on a past day reads as nonsense — so a noted day+    /// later than the selected one is always the date.+    static func relativeDay(_ day: RelativeDay, calendar: Calendar) -> String {+        switch day {+        case .yesterday: "yesterday"+        case .daysAgo(let days): "\(days) days ago"+        case .lastWeek: "last week"+        case .weeksAgo(let weeks): "\(weeks) weeks ago"+        case .date(let civilDay):+            TodayDateText.abbreviated(civilDay, calendar: calendar)+        }+    }+}++/// The week strip's identifiers and labels (Reqs 4.3, 4.5, 10.3).+nonisolated enum WeekStripText {+    /// The seven days of the week containing `day`, in calendar order.+    ///+    /// The week's start comes from `dateInterval(of: .weekOfYear)`, which+    /// honours the region's `firstWeekday`; its days are that start plus 0…6+    /// **days**, so a 23- or 25-hour day inside the week still lands on the+    /// right date.+    static func week(containing day: CivilDay, calendar: Calendar) -> [CivilDay] {+        guard+            let interval = calendar.dateInterval(+                of: .weekOfYear, for: day.date(in: calendar))+        else { return [day] }+        let start = CivilDay(interval.start, calendar: calendar)+        return (0..<7).map { start.adding(days: $0, calendar: calendar) }+    }++    /// One cell's identifier: the day itself, `yyyy-MM-dd`, never a locale's+    /// spelling of it.+    static func cellIdentifier(_ day: CivilDay) -> String { "today-strip-\(day)" }++    static let previousIdentifier = "today-week-previous"+    static let nextIdentifier = "today-week-next"++    /// Req 4.5: the full date, whether the cell is the current day, whether it+    /// is selected, and whether releases are due. The violet dot is described+    /// here rather than exposed as an element of its own (Req 10.3).+    static func label(+        day: CivilDay, isCurrent: Bool, isSelected: Bool, hasReleases: Bool,+        calendar: Calendar+    ) -> String {+        var clauses = [TodayDateText.complete(day, calendar: calendar)]+        if isCurrent { clauses.append("today") }+        if isSelected { clauses.append("selected") }+        if hasReleases { clauses.append("releases due") }+        return clauses.joined(separator: ", ")+    }++    /// The displayed week's date range, between the two chevrons (Req 4.3).+    ///+    /// The strip already holds the week it is drawing, so this takes it rather+    /// than re-deriving it; only its first day is needed, because a week is+    /// seven days from its start whichever array carries it.+    static func range(of week: [CivilDay], calendar: Calendar) -> String {+        guard let first = week.first else { return "" }+        return rangeOfWeek(containing: first, calendar: calendar)+    }++    /// The same range for a day rather than a built week.+    ///+    /// `StatsPeriodNaming.weekText` is the interval this range always was, done+    /// under the calendar in hand instead of the ambient region (Q73): it+    /// resolves the week `day` falls in and formats its first and last day as+    /// one interval, so the separator and the collapsing — `Jun 15 – 21, 2025`+    /// under `en_US`, `10 – 16 Aug 2026` under `en_AU`, rather than two whole+    /// dates joined by a dash this file supplied — are the locale's.+    static func rangeOfWeek(containing day: CivilDay, calendar: Calendar) -> String {+        StatsPeriodNaming.weekText(day.date(in: calendar), calendar: calendar)+    }++    /// Req 4.5: a week control is labelled with the week it moves **to**, not+    /// with the one being left — the label has to answer "where does this take+    /// me".+    ///+    /// The target week is never built: both labels are drawn on every body pass+    /// and only the range is wanted, which `rangeOfWeek` resolves from one day.+    static func pagingLabel(+        weeks: Int, from day: CivilDay, calendar: Calendar+    ) -> String {+        let target = day.adding(days: weeks * 7, calendar: calendar)+        let range = rangeOfWeek(containing: target, calendar: calendar)+        return "\(weeks < 0 ? "Previous" : "Next") week, \(range)"+    }+}

diff --git a/Asterism/Asterism/Views/RecentView.swift b/Asterism/Asterism/Views/TodayView.swiftsimilarity index 57%rename from Asterism/Asterism/Views/RecentView.swiftrename to Asterism/Asterism/Views/TodayView.swiftindex ae17e24..f7b9973 100644--- a/Asterism/Asterism/Views/RecentView.swift+++ b/Asterism/Asterism/Views/TodayView.swift@@ -2,13 +2,48 @@ import AsterismCore import ConstellationKit import SwiftUI -/// Recent tab: shows all entries grouped by day, ordered by lastSharedAt descending.-/// Built from an immutable RecentPresentation DTO (repository-owned derivation).-/// Banner is a 44pt Button that toggles actionable-only filtering.-/// Rows show Work display title (not raw capture title), inline Teach/Re-teach action-/// that opens the composed teaching surface directly (Req 8.1).-struct RecentView: View {-    let presentation: RecentPresentation+/// The Today tab (`update-schedule` Reqs 3–5): one day at a time — the works+/// due to release on it beside the notes taken on it — with a week strip to move+/// between days, and every banner, elsewhere section and search the Recent+/// screen it replaces carried (Q4).+///+/// Built from immutable DTOs: `TodayPresentation` (the entry publication), a+/// `TodaySchedule` derived in Core from the same cycle's works snapshot, and the+/// `CivilDay` that cycle called current. **No clock is read here** (Q39): a day+/// change reaches this screen as a new `currentDay`, published by+/// `AppLibraryModel` beside the rows it describes.+///+/// While a search or a banner filter is active the screen spans every day+/// instead, hiding the week row, the strip and the releases section (Reqs 3.3,+/// 3.4, Q10) — which is `TodayDisplayPlan.spansAllDays`, below.+///+/// # The `recent-*` identifiers are frozen test handles (Q64)+///+/// `recent-list`, `recent-section-header`, `recent-entry-{uuid}`, `recent-empty`,+/// `recent-empty-first-sync` and `recent-search-empty` are **not** stale names+/// left over from the screen this one replaced. They are the handles a large+/// number of UI journeys address, and an accessibility identifier is an API to+/// those journeys: renaming them would be a rename with no reader-visible+/// effect and a wide test diff. Anything this feature *added* is `today-*`.+struct TodayView: View {+    let presentation: TodayPresentation+    /// Every scheduled work and the weekdays any of them is due on, derived in+    /// Core from the same publication's works snapshot (Q28).+    let schedule: TodaySchedule+    /// The day the publishing cycle called current, under the calendar it was+    /// read with.+    let currentDay: CivilDay+    /// The calendar that cycle was built under (Q44, Q74).+    ///+    /// Everything this screen derives from a calendar — the week the strip+    /// shows, the day symbols, the date formats — comes from this value, not+    /// from `Calendar.current`. It is both the input that re-evaluates this body+    /// when the region or zone moves and the calendar the derivation runs under,+    /// so the rows and the dates above them can never describe two calendars.+    let calendar: Calendar+    /// Which day is shown (Q32). `.current` resolves against `currentDay` at+    /// display time, so a day change moves it with nothing written.+    let selection: TodaySelection     let capabilities: AsterismCapabilities     /// Req 4.3: the count beside it was derived at an earlier moment, and     /// `refreshAll` would have swallowed the reason. Shown so a stale count is@@ -27,9 +62,17 @@ struct RecentView: View {     let onShowSyncSettings: (() -> Void)?     /// Req 9.2's inline route: the resolution surface for one duplicate set.     let onResolveDuplicate: ((DuplicateSetKey) -> Void)?-    /// Req 3.2's route out of the truncation footer: the Works section's root,-    /// with no search filter applied. Without it the footer is not rendered.-    let onShowWorks: (() -> Void)?+    /// Req 4.1: a strip cell's tap.+    let onSelectDay: (CivilDay) -> Void+    /// Req 4.3: the week controls, in weeks, either direction.+    let onPageWeek: (Int) -> Void+    /// Req 5.3: a release row opens the work — on Today's own stack (Q38), which+    /// is the caller's business and not this screen's.+    let onSelectWork: (UUID) -> Void+    /// Req 10.1's prune, **on the wide tree only** (Q43): the detail column+    /// clears when the row it is showing is no longer in this list. Nil in the+    /// compact tree, where a push stays until the reader pops it.+    let onPruneSelection: ((TodayVisibility) -> Void)?     /// Req 9.1's count, which is the workload's plus the conflicts the app model     /// is holding — the two halves are published from different places and are     /// overlaid by the caller, not here.@@ -57,6 +100,11 @@ struct RecentView: View {     /// every column and a second layer here would be a column painting its own.     let showsSky: Bool +    /// Q69: at an accessibility size the day chrome scrolls with the list+    /// instead of standing fixed above it. The same branch `WeekStrip` reads for+    /// its 4 + 3 wrap, so one setting decides both.+    @Environment(\.dynamicTypeSize) private var dynamicTypeSize+     @State private var showingActionableOnly = false     @State private var showingDuplicatesOnly = false     /// Req 3.1's query, beside the banner filters because it composes with them@@ -64,7 +112,15 @@ struct RecentView: View {     @State private var searchQuery = ""      init(-        presentation: RecentPresentation,+        presentation: TodayPresentation,+        schedule: TodaySchedule = TodaySchedule(works: [], dueWeekdays: []),+        // No defaults for these two, deliberately: a default would be this+        // screen reading a clock and a calendar of its own, which is exactly+        // what Q39 and Q44 put in `AppLibraryModel`. Both arrive from the cycle+        // that published the rows beside them.+        currentDay: CivilDay,+        calendar: Calendar,+        selection: TodaySelection = .current,         capabilities: AsterismCapabilities = .current,         diagnosisRefreshFailed: Bool = false,         sync: RecentSyncPresentation = .inactive,@@ -79,9 +135,16 @@ struct RecentView: View {         onShowDiagnostics: (() -> Void)? = nil,         onShowSyncSettings: (() -> Void)? = nil,         onResolveDuplicate: ((DuplicateSetKey) -> Void)? = nil,-        onShowWorks: (() -> Void)? = nil+        onSelectDay: @escaping (CivilDay) -> Void = { _ in },+        onPageWeek: @escaping (Int) -> Void = { _ in },+        onSelectWork: @escaping (UUID) -> Void = { _ in },+        onPruneSelection: ((TodayVisibility) -> Void)? = nil     ) {         self.presentation = presentation+        self.schedule = schedule+        self.currentDay = currentDay+        self.calendar = calendar+        self.selection = selection         self.capabilities = capabilities         self.diagnosisRefreshFailed = diagnosisRefreshFailed         self.sync = sync@@ -96,84 +159,70 @@ struct RecentView: View {         self.onShowDiagnostics = onShowDiagnostics         self.onShowSyncSettings = onShowSyncSettings         self.onResolveDuplicate = onResolveDuplicate-        self.onShowWorks = onShowWorks+        self.onSelectDay = onSelectDay+        self.onPageWeek = onPageWeek+        self.onSelectWork = onSelectWork+        self.onPruneSelection = onPruneSelection     }      private var searchFilter: RecentSearchFilter {         RecentSearchFilter(query: searchQuery)     } +    /// Which day is shown (Q32), resolved by the selection itself so that this+    /// screen and `AppNavigation` cannot answer differently.+    private var selectedDay: CivilDay { selection.day(currentDay: currentDay) }++    /// The displayed week: the seven days containing the selected day, starting+    /// at the region's first weekday (Req 4.1).+    private var week: [CivilDay] {+        WeekStripText.week(containing: selectedDay, calendar: calendar)+    }+     /// Every branch, row and summary line this screen renders (Q26). Built once     /// per `body` evaluation and bound to a local below — reading it as a     /// computed property three times would run the filter three times per     /// keystroke.-    private var displayPlan: RecentDisplayPlan {-        RecentDisplayPlan(+    private var displayPlan: TodayDisplayPlan {+        TodayDisplayPlan(             presentation: presentation,+            schedule: schedule,+            selectedDay: selectedDay,+            currentDay: currentDay,+            calendar: calendar,             showingActionableOnly: showingActionableOnly,             showingDuplicatesOnly: showingDuplicatesOnly,             searchFilter: searchFilter,             conflictCount: conflictCount,-            hasWorksRoute: onShowWorks != nil)+            // Req 10.1's prune is the wide tree's (Q43); the phone passes no+            // closure and has no use for the sets.+            needsVisibility: onPruneSelection != nil)     }      var body: some View {         let plan = displayPlan+        // Req 4.1's order, top to bottom: the title (the navigation bar's), its+        // caption, the week row, the strip, the banners, then the sections.+        //         // The banner region sits **above** the empty-library branch (Q15). Two         // Site rows with no Entries yet — the first-sync shape — produce a-        // diagnosis and zero Recent groups, so a banner living in the non-empty-        // branch would leave that library with no route to Req 4.1's screen at-        // all.-        //-        // The banners themselves keep reading `presentation.actionableCount`,-        // `presentation.diagnosisCount` and `duplicateCount` directly: Reqs 2.1-        // and 2.2 hold only while the cap stays out of the counts.+        // diagnosis and zero groups, so a banner living in the non-empty branch+        // would leave that library with no route to Req 4.1's screen at all.         VStack(spacing: 0) {-            banners--            switch plan.branch {-            case .emptyLibrary:-                emptyBranch-            case .searchMiss:-                searchEmptyBranch-            case .list:-                List {-                    ForEach(Array(plan.groups.enumerated()), id: \.element.day) { index, group in-                        Section {-                            ForEach(group.rows) { row in-                                RecentEntryRow(-                                    row: row,-                                    isSelected: row.id == selectedEntryID,-                                    onSelect: onSelect,-                                    onTeach: onTeach,-                                    onResolveDuplicate: onResolveDuplicate,-                                    resolutionKey: duplicateSetKey(for: row)-                                )-                                .constellationListRow()-                            }-                        } header: {-                            // Req 8.4: ✦ cyan on the first section, violet on-                            // the ones after it (§3).-                            ConstellationSectionHeader(-                                group.day.formatted(date: .abbreviated, time: .omitted),-                                accent: index == 0 ? .cyan : .violet-                            )-                            .accessibilityIdentifier("recent-section-header")-                        }-                    }-                    elsewhereSection(plan.elsewhere)-                    if plan.showsFooter { truncationFooter }-                }-                .listStyle(.plain)-                // Req 8.1: the sky is the tab stack's background and the-                // content scrolls over it.-                .scrollContentBackground(.hidden)-                // …and on the Mac the alternating row backgrounds would stripe-                // it, so they go too (`ipad-and-mac-layouts` Req 3.3).-                .macListChrome()-                .accessibilityIdentifier("recent-list")+            // Q69: fixed above the list at the sizes it fits in, and the list's+            // own top content at the accessibility sizes, where it does not.+            if !scrollsChrome(plan) {+                if plan.showsDayChrome { dayChrome }+                banners             }+            content(plan)         }+        // Req 4.4: the tab is called Today and the *screen* is called after the+        // day it is showing. The only title on this stack — the compact tree+        // sets none outside it, because an outer one would win — and the same+        // function the wide tree's list column is headed with.+        .navigationTitle(+            TodayTitleText.title(for: selection, current: currentDay, calendar: calendar))         // Requirement 8.1's fixed layer. On the screen's own root rather than         // on the enclosing `NavigationStack`: a background applied outside the         // stack renders *behind* the stack's own opaque backing, and the sky@@ -208,6 +257,257 @@ struct RecentView: View {                 showingDuplicatesOnly = false             }         }+        // Req 10.1: the wide tree's detail column clears when the row it is+        // showing leaves this list — a status change, a deletion, a change of+        // selected day, a search or a banner filter. `initial: true` because the+        // first publication is itself an answer: a restored selection that the+        // library no longer holds must not survive the first draw.+        .onChange(of: plan.visibility, initial: true) { _, visibility in+            onPruneSelection?(visibility)+        }+    }++    // MARK: - The day's chrome (Reqs 4.1, 4.4)++    /// Whether the chrome is drawn as the list's top content rather than fixed+    /// above it (Q69).+    ///+    /// The accessibility sizes, and only there: at `AccessibilityXXXL` the+    /// title, the search field, the two-line caption, the week row, the wrapped+    /// strip and a banner want more height than the window has, so a fixed+    /// `VStack` compresses them into each other and leaves the `List` a sliver+    /// no gesture can empty. Below that the chrome fits, and staying fixed is+    /// what keeps the day selector permanent (Req 4.1).+    ///+    /// Not on the search-miss branch, which draws a `ContentUnavailableView`+    /// rather than a `List`: there is nothing there for the chrome to scroll+    /// with, and that branch shows no day chrome anyway — only the banners,+    /// which stay above it.+    private func scrollsChrome(_ plan: TodayDisplayPlan) -> Bool {+        dynamicTypeSize.isAccessibilitySize && plan.branch != .searchMiss+    }++    /// The chrome as list rows, for the accessibility sizes (Q69).+    ///+    /// Zero insets, no separator and no row background, so the pieces keep the+    /// padding they carry themselves and the screen looks exactly as it does+    /// above the list at the sizes that fit.+    @ViewBuilder+    private func chromeRows(_ plan: TodayDisplayPlan) -> some View {+        if scrollsChrome(plan) {+            Section {+                if plan.showsDayChrome {+                    dayChrome+                        // A `List` row takes its content's ideal height, so the+                        // compression that overlapped the week row and the strip+                        // in the fixed `VStack` cannot happen here — §10's wrap,+                        // never shrink (Reqs 10.2, 10.4).+                        .fixedSize(horizontal: false, vertical: true)+                        .constellationListRow(insets: Self.chromeRowInsets)+                }+                banners+                    .constellationListRow(insets: Self.chromeRowInsets)+            }+        }+    }++    private static let chromeRowInsets = EdgeInsets(+        top: 0, leading: 0, bottom: 0, trailing: 0)++    /// The caption, the week row and the strip — drawn only while the screen is+    /// showing one day (Reqs 3.3, 3.4).+    private var dayChrome: some View {+        // Bound once, the way `body` binds the plan: `week` walks a calendar+        // interval and seven `adding(days:)` behind it, and the row and the+        // strip below want the same seven days.+        let selectedDay = selectedDay+        let week = week+        return VStack(alignment: .leading, spacing: 8) {+            Text(TodayTitleText.caption(for: selectedDay, calendar: calendar))+                .font(.caption)+                .foregroundStyle(AsterismColors.secondaryText)+                // §10: a date wraps rather than truncating.+                .fixedSize(horizontal: false, vertical: true)+                .accessibilityIdentifier("today-caption")++            WeekRow(week: week, selectedDay: selectedDay, calendar: calendar, onPage: onPageWeek)++            WeekStrip(+                week: week,+                selectedDay: selectedDay,+                currentDay: currentDay,+                dueWeekdays: schedule.dueWeekdays,+                calendar: calendar,+                onSelect: onSelectDay)+        }+        .padding(.horizontal, 16)+        .padding(.vertical, 8)+    }++    // MARK: - The list++    @ViewBuilder+    private func content(_ plan: TodayDisplayPlan) -> some View {+        switch plan.branch {+        case .searchMiss:+            searchEmptyBranch+        case .emptyLibrary, .list:+            // Req 5.8's exception is why `.emptyLibrary` is not its own branch+            // here: an empty library still shows the week row, the strip and the+            // releases section, with the empty-library presentation standing in+            // for the noted section.+            if plan.showsDayChrome {+                dayList(plan)+            } else {+                spanningList(plan)+            }+        }+    }++    /// One day: the releases due on it and the notes taken on it, in the order+    /// `placement` gives (Req 5.5).+    private func dayList(_ plan: TodayDisplayPlan) -> some View {+        // Req 5.7: the first header *actually drawn* is cyan. Not the first+        // section: on the empty-library branch the noted section stands aside+        // for the empty-library presentation and draws no header at all, so a+        // past day — whose placement puts the notes first — had violet as its+        // only header.+        let accents = TodaySectionAccents(+            placement: plan.day.placement, drawsNotedHeader: plan.drawsNotedHeader)+        return List {+            chromeRows(plan)+            switch plan.day.placement {+            case .releasesFirst:+                releasesSection(plan, accent: accents.releases)+                notedSection(plan, accent: accents.noted)+            case .notedFirst:+                notedSection(plan, accent: accents.noted)+                releasesSection(plan, accent: accents.releases)+            }+        }+        .listStyle(.plain)+        .scrollContentBackground(.hidden)+        .macListChrome()+        .accessibilityIdentifier("recent-list")+    }++    /// Req 5.1: the works due on the selected day, one row each.+    @ViewBuilder+    private func releasesSection(+        _ plan: TodayDisplayPlan, accent: ConstellationSectionHeader.Accent+    ) -> some View {+        Section {+            if plan.day.releases.isEmpty {+                // Req 5.6: a shown section with no rows keeps its header and+                // says so in one dim line.+                Text("Nothing releasing")+                    .font(.caption)+                    .foregroundStyle(AsterismColors.secondaryText)+                    .constellationListRow()+                    .accessibilityIdentifier("today-releases-empty")+            } else {+                ForEach(plan.day.releases) { row in+                    ReleaseRowView(+                        row: row,+                        selectedDay: plan.day.day,+                        currentDay: currentDay,+                        calendar: calendar,+                        onSelect: onSelectWork)+                        .constellationListRow()+                }+            }+        } header: {+            ConstellationSectionHeader(+                TodayTitleText.releasesHeader(+                    for: plan.day.day, current: currentDay, calendar: calendar),+                accent: accent+            )+            .accessibilityIdentifier("today-section-releases")+        }+    }++    /// Req 5.4: the entries whose noted day is the selected day. Absent for a+    /// day after the current one, and replaced by the empty-library presentation+    /// where the library holds nothing at all (Req 5.8).+    @ViewBuilder+    private func notedSection(+        _ plan: TodayDisplayPlan, accent: ConstellationSectionHeader.Accent+    ) -> some View {+        if let noted = plan.day.noted {+            if plan.branch == .emptyLibrary {+                // In place of the section, header and all: a reader with nothing+                // captured is told that, rather than shown an empty day.+                Section { emptyBranch.constellationListRow() }+            } else {+                Section {+                    if noted.rows.isEmpty {+                        Text("Nothing noted")+                            .font(.caption)+                            .foregroundStyle(AsterismColors.secondaryText)+                            .constellationListRow()+                            .accessibilityIdentifier("today-noted-empty")+                    } else {+                        ForEach(noted.rows) { row in+                            entryRow(row)+                        }+                    }+                } header: {+                    ConstellationSectionHeader(+                        TodayTitleText.notedHeader(+                            for: plan.day.day, current: currentDay, calendar: calendar),+                        accent: accent+                    )+                    .accessibilityIdentifier("today-section-noted")+                }+            }+        }+    }++    /// Every day at once: what a search or a banner filter shows (Reqs 3.3,+    /// 3.4), grouped and headed exactly as Recent grouped them.+    private func spanningList(_ plan: TodayDisplayPlan) -> some View {+        List {+            chromeRows(plan)+            ForEach(Array(plan.groups.enumerated()), id: \.element.day) { index, group in+                Section {+                    ForEach(group.rows) { row in+                        entryRow(row)+                    }+                } header: {+                    // Req 8.4: ✦ cyan on the first section, violet on the ones+                    // after it (§3).+                    ConstellationSectionHeader(+                        // Q73: through the same helper the rest of the screen's+                        // dates go through, so a spanning header cannot be the+                        // one date on the page under the ambient region.+                        TodayDateText.abbreviated(group.civilDay, calendar: calendar),+                        accent: index == 0 ? .cyan : .violet+                    )+                    .accessibilityIdentifier("recent-section-header")+                }+            }+            elsewhereSection(plan.elsewhere)+        }+        .listStyle(.plain)+        // Req 8.1: the sky is the tab stack's background and the content+        // scrolls over it.+        .scrollContentBackground(.hidden)+        // …and on the Mac the alternating row backgrounds would stripe it, so+        // they go too (`ipad-and-mac-layouts` Req 3.3).+        .macListChrome()+        .accessibilityIdentifier("recent-list")+    }++    private func entryRow(_ row: TodayPresentationRow) -> some View {+        TodayEntryRow(+            row: row,+            isSelected: row.id == selectedEntryID,+            onSelect: onSelect,+            onTeach: onTeach,+            onResolveDuplicate: onResolveDuplicate,+            resolutionKey: duplicateSetKey(for: row)+        )+        .constellationListRow()     }      /// Req 6.5: an empty library that has never received anything from iCloud is@@ -458,35 +758,10 @@ struct RecentView: View {         }     } -    /// Req 3.1's disclosure: the list is capped, and the rest of the library is-    /// in Works. A final row in the same summary shape the Elsewhere lines use —-    /// a row at the end of the list carrying a route, not a new visual idiom.-    ///-    /// "Older" is accurate to the day granularity the list presents; at an exact-    /// timestamp tie the order falls to the identifier tiebreak, which no reader-    /// can observe.-    private var truncationFooter: some View {-        Section {-            summaryRow(-                icon: "sparkles",-                iconTint: AsterismColors.cyan,-                text: "Older entries are in Works",-                showsChevron: true,-                // Nothing is wrong here — the list is simply bounded — so this-                // row takes the plain card rather than the amber attention edge.-                borderColor: nil,-                identifier: "recent-truncation-footer",-                accessibilityLabel: "Older entries are in Works. Tap to open Works."-            ) {-                onShowWorks?()-            }-        }-    }-     /// Where a row's Resolve pill goes (Req 9.2). A deferred set routes at the     /// Work set blocking it (Q45), because its own sheet is unreachable until     /// that one resolves.-    private func duplicateSetKey(for row: RecentPresentationRow) -> DuplicateSetKey? {+    private func duplicateSetKey(for row: TodayPresentationRow) -> DuplicateSetKey? {         guard let route = row.duplicateRoute else { return nil }         switch route {         case .sheet, .merge:@@ -558,8 +833,27 @@ struct RecentView: View {     } } -/// What the Recent screen renders: which branch, which rows, which summary-/// lines, and whether the truncation footer appears.+/// Which rows the detail column may be showing, as one comparable value+/// (`update-schedule` Req 10.1).+///+/// A pair of id sets rather than the rows themselves: what Req 10.1 asks is a+/// membership question, and comparing the rows would deep-compare the day.+nonisolated struct TodayVisibility: Equatable {+    /// The entries actually drawn — the spanning list's rows while a filter or a+    /// query is active, the selected day's noted rows otherwise.+    let entries: Set<UUID>+    /// The works actually drawn, which is the releases section's rows while the+    /// day chrome is shown and nothing at all while it is not.+    let works: Set<UUID>++    init(entries: Set<UUID>, works: Set<UUID>) {+        self.entries = entries+        self.works = works+    }+}++/// What the Today screen renders: which branch, whether it is showing one day or+/// every day, that day's plan, and which rows are on screen. /// /// A value type in the same mould as `RecentDuplicatePlan` because no app-layer /// test can assert which branch a `some View` took (Q26) — a decision left@@ -570,8 +864,9 @@ struct RecentView: View { /// pre-filtered groups and also decided that branch would be circular. /// /// No `Equatable` conformance: nothing compares plans, and a synthesised one-/// would deep-compare up to the whole library.-struct RecentDisplayPlan {+/// would deep-compare up to the whole library. ``visibility`` is the one part+/// that *is* compared, and it is a pair of id sets for that reason.+struct TodayDisplayPlan {     /// `nonisolated` because the app target sets     /// `SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor`, so this enum would otherwise     /// be implicitly `@MainActor` and its synthesised `Equatable` conformance@@ -581,37 +876,77 @@ struct RecentDisplayPlan {     /// the intent instead of relying on it. The enum is a plain value with no     /// isolated state to protect.     nonisolated enum Branch: Equatable {-        /// Req 5.1: the library has nothing in it, whatever is typed.+        /// Req 5.8: the library has nothing in it, whatever is typed.         case emptyLibrary-        /// Req 5.2: a query with nothing behind it.+        /// A query with nothing behind it.         case searchMiss         case list     }      let branch: Branch-    /// The rows to render, scope-selected, banner-filtered and searched.-    let groups: [RecentPresentationGroup]+    /// Whether the screen is showing every day rather than one (Reqs 3.3, 3.4).+    ///+    /// True while a banner filter or the search is active. It was `isBounded`,+    /// inverted and named for what it now means: the cap is gone (Q24), so what+    /// the condition decides is no longer "how many rows" but "one day or all of+    /// them".+    let spansAllDays: Bool+    /// The all-days rows, banner-filtered and searched — empty while the screen+    /// is showing one day, where ``day`` carries the rows instead.+    let groups: [TodayPresentationGroup]     /// The duplicate plan's summary lines, built here so the view does not     /// construct a second `RecentDuplicatePlan` of its own — and empty unless     /// the duplicate filter is active, because the question they answer ("what-    /// did the banner count that Recent holds no row for") is only asked while-    /// that banner is filtering.+    /// did the banner count that this screen holds no row for") is only asked+    /// while that banner is filtering.     let elsewhere: [RecentDuplicatePlan.Elsewhere]-    /// Req 3.1's disclosure that older entries live in Works.-    let showsFooter: Bool+    /// The selected day's releases and notes (Req 5).+    ///+    /// Built only while ``showsDayChrome`` holds, which is exactly when the view+    /// reads it; otherwise it carries the day and its placement with no rows,+    /// because a screen spanning every day has no day's rows to show.+    let day: TodayDayPlan+    /// Whether the week row, the strip and the releases section are drawn (Reqs+    /// 3.3–3.5, 5.8).+    ///+    /// `!spansAllDays`, with Req 5.8's exception: a library with no entries at+    /// all keeps its day chrome whatever is typed in the search field, so a+    /// reader whose library holds only scheduled works still sees them.+    let showsDayChrome: Bool+    /// Whether the noted section draws a header of its own (Req 5.7).+    ///+    /// It does not for a day after the current one, which has no noted section+    /// at all, and it does not on the empty-library branch, where the+    /// empty-library presentation stands in for the section, header and all+    /// (Req 5.8). Either way the releases header is then the first one on the+    /// screen, whatever the placement says — which is what decides the accents.+    var drawsNotedHeader: Bool { day.noted != nil && branch != .emptyLibrary }+    /// Which rows are on screen, for Req 10.1's prune.+    ///+    /// Two empty sets where the caller asked for no prune. The prune is the wide+    /// tree's only (Q43), and on the phone `onPruneSelection` is nil — so every+    /// body pass was building two `Set<UUID>` over every spanning row for an+    /// `onChange` that then compared them and handed them to nobody.+    let visibility: TodayVisibility      /// Takes `conflictCount` and *produces* `elsewhere` rather than taking a     /// pre-computed flag: the view would otherwise build `RecentDuplicatePlan`     /// twice per evaluation, and an input flag admits the contradictory pair     /// `showsElsewhereSection: true` with `showingDuplicatesOnly: false`.     init(-        presentation: RecentPresentation,+        presentation: TodayPresentation,+        schedule: TodaySchedule,+        selectedDay: CivilDay,+        currentDay: CivilDay,+        calendar: Calendar,         showingActionableOnly: Bool,         showingDuplicatesOnly: Bool,         searchFilter: RecentSearchFilter,         conflictCount: Int,-        hasWorksRoute: Bool,-        limit: Int = RecentRowCap.rowLimit+        /// Whether ``visibility`` is wanted at all — true exactly when the+        /// caller passed an `onPruneSelection`. Defaulted false so a test that+        /// says nothing about the prune pays nothing for it.+        needsVisibility: Bool = false     ) {         // Short-circuited, not built and discarded: the plan is O(review items)         // and this initialiser runs on every `body` evaluation — once per@@ -625,64 +960,115 @@ struct RecentDisplayPlan {             : []         self.elsewhere = elsewhere -        // The scope rule, covering Reqs 2.3, 2.4, 2.5, 4.1, 4.2 and 4.3 in one-        // condition: the cap applies only to the plain list. A banner filter and-        // a query each see the whole library, so every counted row stays-        // reachable and note text stays findable however old it is.-        let isBounded =-            !showingActionableOnly && !showingDuplicatesOnly && !searchFilter.isActive-        let scoped: [RecentPresentationGroup]-        let excludedRowCount: Int-        if isBounded {-            let capped = RecentRowCap.apply(to: presentation.groups, limit: limit)-            scoped = capped.groups-            excludedRowCount = capped.excludedRowCount-        } else {-            scoped = presentation.groups-            excludedRowCount = 0-        }--        // Req 9.1's duplicate filter is its own filter rather than a widening of-        // the actionable one: a row can be in a review set without needing-        // teaching, and folding the two together would make the actionable count-        // and the rows it filters to disagree. With both on, the two are a union.-        let bannerFiltered: [RecentPresentationGroup]-        if showingActionableOnly || showingDuplicatesOnly {-            bannerFiltered = scoped.compactMap { group in-                let filtered = group.rows.filter { row in-                    (showingActionableOnly && row.isActionable)-                        || (showingDuplicatesOnly && row.duplicateRoute != nil)+        // Q10: a search and the banner filters each cover the whole history, so+        // a row they counted is never hidden behind the selected day — and the+        // day chrome goes with them, because a strip pointing at one day over a+        // list that spans every day would be pointing at nothing.+        let spansAllDays =+            showingActionableOnly || showingDuplicatesOnly || searchFilter.isActive+        self.spansAllDays = spansAllDays++        var spanning: [TodayPresentationGroup] = []+        if spansAllDays {+            // Req 9.1's duplicate filter is its own filter rather than a+            // widening of the actionable one: a row can be in a review set+            // without needing teaching, and folding the two together would make+            // the actionable count and the rows it filters to disagree. With+            // both on, the two are a union.+            let bannerFiltered: [TodayPresentationGroup]+            if showingActionableOnly || showingDuplicatesOnly {+                bannerFiltered = presentation.groups.compactMap { group in+                    let filtered = group.rows.filter { row in+                        (showingActionableOnly && row.isActionable)+                            || (showingDuplicatesOnly && row.duplicateRoute != nil)+                    }+                    guard !filtered.isEmpty else { return nil }+                    return group.withRows(filtered)                 }-                guard !filtered.isEmpty else { return nil }-                return RecentPresentationGroup(day: group.day, rows: filtered)+            } else {+                bannerFiltered = presentation.groups             }-        } else {-            bannerFiltered = scoped+            // Req 3.3: search runs **after** the banner filters, so both+            // conditions apply. Never before — the unfiltered set would surface+            // a row the banner had deliberately excluded.+            spanning = searchFilter.apply(to: bannerFiltered)         }--        // Req 3.2: search runs **after** the banner filters, so both conditions-        // apply. Never before — the unfiltered set would surface a row the-        // banner had deliberately excluded.-        let searched = searchFilter.apply(to: bannerFiltered)-        groups = searched+        groups = spanning          // The filtered state keeps the list even where the library has no rows         // to show in it: what the duplicate banner counted may live entirely-        // outside Recent, and the Elsewhere lines are the only route to it.+        // outside this screen, and the Elsewhere lines are the only route to it.+        let branch: Branch         if presentation.groups.isEmpty && !showingDuplicatesOnly {             branch = .emptyLibrary-        } else if searchFilter.isActive && searched.isEmpty && elsewhere.isEmpty {+        } else if searchFilter.isActive && spanning.isEmpty && elsewhere.isEmpty {             branch = .searchMiss         } else {             branch = .list         }+        self.branch = branch++        // Req 5.8's exception, stated once: an empty library keeps the strip and+        // the releases section whatever is typed.+        let showsDayChrome = !spansAllDays || branch == .emptyLibrary+        self.showsDayChrome = showsDayChrome++        day =+            showsDayChrome+            ? TodayDayPlan.build(+                day: selectedDay, currentDay: currentDay, schedule: schedule,+                presentation: presentation, calendar: calendar)+            // Nothing reads the rows while the screen spans every day, and+            // building them would filter the schedule for a section that is not+            // drawn. The day and its placement are still the honest answers.+            : TodayDayPlan(+                day: selectedDay,+                placement: selectedDay < currentDay ? .notedFirst : .releasesFirst,+                releases: [],+                noted: nil) -        // The route term matches the convention every other optional route in-        // `RecentView` follows, so the footer is never rendered dead. The count-        // is the one the same `RecentRowCap.apply` call produced.-        showsFooter =-            branch == .list && isBounded && excludedRowCount > 0 && hasWorksRoute+        // **Both halves branch on `showsDayChrome`**, which is what decides+        // which list is drawn — `spansAllDays` differs from it exactly on the+        // empty-library branch, where the screen shows the day after all. The+        // two happen to agree there today, because that branch has no rows of+        // either kind; asking the same question twice is what keeps them from+        // disagreeing when it gains some.+        //+        // Skipped entirely where nobody prunes: the sets are O(rows on screen)+        // and this initialiser runs on every body pass.+        visibility =+            needsVisibility+            ? TodayVisibility(+                entries: Set(+                    showsDayChrome+                        ? (day.noted?.rows ?? []).map(\.id)+                        : spanning.flatMap(\.rows).map(\.id)),+                works: Set(showsDayChrome ? day.releases.map(\.id) : []))+            : TodayVisibility(entries: [], works: [])+    }+}++/// Req 5.7's two accents for one day's section headers.+///+/// The first header **actually drawn** is cyan and every later one violet. That+/// is the placement — except where the noted section draws no header at all: on+/// a future day it has no section, and on Req 5.8's empty-library branch the+/// empty-library presentation stands in for it. In both, the releases header is+/// the first one on the screen even on a past day, whose placement puts the+/// notes first.+///+/// A value rather than two `if`s in the body, so that "which header is first"+/// is decided in one place and can be asserted without drawing anything.+struct TodaySectionAccents: Equatable {+    /// Whether the releases header is the first one drawn.+    let releasesIsFirst: Bool++    init(placement: TodayDayPlan.Placement, drawsNotedHeader: Bool) {+        releasesIsFirst = placement == .releasesFirst || !drawsNotedHeader     }++    var releases: ConstellationSectionHeader.Accent { releasesIsFirst ? .cyan : .violet }+    var noted: ConstellationSectionHeader.Accent { releasesIsFirst ? .violet : .cyan } }  /// What the duplicate banner counts, split into what Recent can show and what it@@ -770,16 +1156,16 @@ struct RecentDuplicatePlan: Equatable {     } } -/// A single row in the Recent list: shows Work display title for taught entries,+/// A single row in the Today screen's noted section: shows Work display title for taught entries, /// raw capture title for untaught. Actionable rows show amber treatment with /// inline Teach/Re-teach pill that opens the composed teaching surface directly.-struct RecentEntryRow: View {+struct TodayEntryRow: View {     /// `site-display-names` Q16: VoiceOver hears the site the way a sighted     /// reader reads it. The row draws no site text of its own — this is the     /// accessibility sentence only.     @Environment(\.siteNames) private var siteNames -    let row: RecentPresentationRow+    let row: TodayPresentationRow     /// `ipad-and-mac-layouts` Req 1.5: this row's entry is the one open in the     /// detail column beside the list. False in the compact tree, which pushes     /// the entry over the list instead and so has nothing to mark.@@ -790,7 +1176,7 @@ struct RecentEntryRow: View {     let resolutionKey: DuplicateSetKey?      init(-        row: RecentPresentationRow,+        row: TodayPresentationRow,         isSelected: Bool = false,         onSelect: @escaping (UUID) -> Void,         onTeach: ((UUID) -> Void)? = nil,@@ -1017,3 +1403,75 @@ struct RecentEntryRow: View {         }     } }++/// One work due on the day being shown (`update-schedule` Reqs 5.2, 5.3).+///+/// A **sibling of `WorkRow`**, not a mode of it (Q34): the two share their+/// cover, serif title, site glyph, type tag and knock-down through+/// `WorkRowHeader`, and differ in what the line under that says — series and+/// status there, the schedule here. A flag on `WorkRow` would have put two+/// unrelated second lines behind one boolean.+struct ReleaseRowView: View {+    /// `site-display-names` Q16: VoiceOver hears the site the way a sighted+    /// reader reads it. The row draws no site text of its own.+    @Environment(\.siteNames) private var siteNames++    let row: ReleaseRow+    /// The day the screen is showing, which is what the line is relative to.+    let selectedDay: CivilDay+    let currentDay: CivilDay+    let calendar: Calendar+    let onSelect: (UUID) -> Void++    /// Req 5.2: the cyan accent for a note taken on the day being shown, and+    /// secondary text for everything else — "you read this one today" is the+    /// state worth an accent.+    private var isNotedOnDay: Bool {+        if case .notedOnDay = row.line { return true }+        return false+    }++    private var line: String {+        ReleaseLineText.line(+            row.line, selectedDay: selectedDay, currentDay: currentDay, calendar: calendar)+    }++    var body: some View {+        // Once per draw: the row shows this sentence and VoiceOver hears it, and+        // building it walks the relative-day table either way.+        let line = line+        return Button {+            onSelect(row.id)+        } label: {+            WorkRowHeader(+                workID: row.id,+                thumbnail: row.thumbnail,+                title: row.title,+                titleLabel: row.title,+                primaryHostname: row.primaryHostname,+                typeDisplay: row.typeDisplay,+                isKnockedDown: false,+                meta: { EmptyView() },+                trailing: { Spacer() },+                detail: {+                    Text(line)+                        .font(.caption)+                        .foregroundStyle(+                            isNotedOnDay ? AsterismColors.cyan : AsterismColors.secondaryText)+                        .lineLimit(2)+                        .accessibilityIdentifier("today-release-line")+                }+            )+            .frame(maxWidth: .infinity, alignment: .leading)+            .contentShape(Rectangle())+        }+        .buttonStyle(.plain)+        .padding(.vertical, 10)+        .padding(.horizontal, 12)+        .constellationCard()+        .accessibilityElement(children: .combine)+        .accessibilityIdentifier("today-release-\(row.id.uuidString)")+        .accessibilityLabel(+            "\(row.title), \(line), from \(siteNames.label(for: row.primaryHostname))")+    }+}