Pre-push review: T-2306/work-and-reading-status

diff --git a/Asterism/Asterism/ViewModels/AppLibraryModel.swift b/Asterism/Asterism/ViewModels/AppLibraryModel.swiftindex 2873d12..6c5c471 100644--- a/Asterism/Asterism/ViewModels/AppLibraryModel.swift+++ b/Asterism/Asterism/ViewModels/AppLibraryModel.swift@@ -148,8 +148,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 BackupV8SnapshotProviding).-    private var backupRepository: (any BackupV8SnapshotProviding)?+    /// Retains the concrete repository for backup export (conforms to BackupV9SnapshotProviding).+    private var backupRepository: (any BackupV9SnapshotProviding)?     /// 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.@@ -1942,7 +1942,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 = BackupV8Exporter(+        let exporter = BackupV9Exporter(             repository: repo,             stagingDirectory: stagingDir         )@@ -2088,7 +2088,9 @@ public final class AppLibraryModel {                 typeAssignment: reloaded.typeDisplay.assignment,                 genreTags: reloaded.genreTags,                 genericNotes: "Ada keeps the lighthouse, and the crew call her Nightjar. "-                    + "Brede rows the tender out at dusk."))+                    + "Brede rows the tender out at dusk.",+                workStatus: reloaded.workStatus, readingStatus: reloaded.readingStatus,+                verdict: reloaded.verdict))         Self.logger.debug("Seeded the character-extraction UI test fixture")     } @@ -2099,16 +2101,26 @@ 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 |-    /// |---|---|---|---|---|-    /// | Marrow Lane | alpha.test | first | — | mystery |-    /// | Ashfall | beta.test | second | webtoon, then removed | — |-    /// | Zephyr Court | alpha.test | third | novel | — |-    /// | Quill Harbour | beta.test | no entries | — | — |+    /// | 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 | — |     ///     /// Plus one unattached entry, so the group a filter hides (Q9) is on screen     /// before the filter is chosen.     ///+    /// `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+    /// Ashfall is not** (Q58): Ashfall already wears the removed-type pill's own+    /// knock-down, and a row wearing both dims twice — a pairing the owner's+    /// device check looks at once, not a state every journey should be reading+    /// through. Zephyr Court is finished on both sides, so it is the row wearing+    /// two glyphs; Quill Harbour stays on the defaults, so an unmarked row is+    /// still in the fixture.+    ///     /// **The three works are seeded one whole work at a time**, rather than     /// three captures and then three moves. `works()` orders on the newest     /// entry's `lastSharedAt`, which the clock quantizes to a millisecond and@@ -2128,13 +2140,18 @@ public final class AppLibraryModel {          try await seedWorksOptionsWork(             title: "Marrow Lane", hostname: "alpha.test", slug: "marrow",-            type: .none, tags: ["mystery"], in: repo)+            type: .none, tags: ["mystery"],+            workStatus: .ongoing, readingStatus: .abandoned,+            verdict: "Put it down when the fog plot stopped going anywhere.", in: repo)         try await seedWorksOptionsWork(             title: "Ashfall", hostname: "beta.test", slug: "ashfall",-            type: .configured(webtoon.id), tags: [], in: repo)+            type: .configured(webtoon.id), tags: [],+            workStatus: .hiatus, readingStatus: .reading, verdict: "", in: repo)         try await seedWorksOptionsWork(             title: "Zephyr Court", hostname: "alpha.test", slug: "zephyr",-            type: .configured(novel.id), tags: [], in: repo)+            type: .configured(novel.id), tags: [],+            workStatus: .finished, readingStatus: .finished,+            verdict: "A tidy ending, and the court scenes earned it.", in: repo)          // After the assignment, so Ashfall keeps displaying a type the picker         // no longer offers — the `.removed` display the dimmed filter row is@@ -2152,9 +2169,15 @@ public final class AppLibraryModel {      /// One work of that fixture: a capture, a work on the same site, the move     /// that puts one under the other, and the metadata the filters read.+    ///+    /// 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.     private func seedWorksOptionsWork(         title: String, hostname: String, slug: String,-        type: WorkTypeAssignment, tags: [String], in repo: LibraryRepository+        type: WorkTypeAssignment, tags: [String],+        workStatus: WorkStatus, readingStatus: ReadingStatus, verdict: String,+        in repo: LibraryRepository     ) async throws {         let entry = try await repo.capture(CaptureDraft(             captureTitle: "Chapter 1 - \(title)",@@ -2173,7 +2196,8 @@ public final class AppLibraryModel {             id: work.id,             basis: WorkEditBasis(work: reloaded),             draft: WorkMetadataDraft(-                displayTitle: title, typeAssignment: type, genreTags: tags, genericNotes: ""))+                displayTitle: title, typeAssignment: type, genreTags: tags, genericNotes: "",+                workStatus: workStatus, readingStatus: readingStatus, verdict: verdict))     }      /// Preserves two captures in the disposable root's spool, exactly as the

diff --git a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift b/Asterism/Asterism/ViewModels/SettingsBackupModel.swiftindex de27999..861a87b 100644--- a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift+++ b/Asterism/Asterism/ViewModels/SettingsBackupModel.swift@@ -5,19 +5,20 @@ import OSLog // MARK: - Backup Exporting Protocol  /// Test seam abstracting the exporter's operations needed by the Settings-/// surface. Conforms `BackupV8Exporter` to this protocol via extension below.+/// surface. Conforms `BackupV9Exporter` to this protocol via extension below. ///-/// Settings exports 8/9 (`rule-citation-by-uuid` Req 5.1): the archive carries a-/// Work's site memberships, the reader's dismissed pairs, and citations that-/// name a rule by UUID alone. It is also the only format the app reads, so there-/// is one exporter and one importer.+/// Settings exports 9/10 (`work-and-reading-status` Req 8.1): the archive+/// carries 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: BackupV8Metadata) async throws -> BackupExportResult+    func export(metadata: BackupV9Metadata) async throws -> BackupExportResult     func cleanup(_ result: BackupExportResult)     func scavengeStaleFiles() } -extension BackupV8Exporter: BackupExporting {}+extension BackupV9Exporter: BackupExporting {}  // MARK: - Settings Backup View Model @@ -78,7 +79,7 @@ public final class SettingsBackupModel {         currentResult = nil          do {-            let metadata = BackupV8Metadata(+            let metadata = BackupV9Metadata(                 appBuild: Self.currentAppBuild(),                 exportedAt: Date()             )@@ -91,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? BackupV8ExportError,+            if let exportError = error as? BackupV9ExportError,                case .tornGroups = exportError {                 routesToCheckLibrary = true             }@@ -139,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 BackupV8ExportError:+        case let error as BackupV9ExportError:             exportMessage(for: error)         default:             "Backup export failed. Please try again."@@ -163,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: BackupV8ExportError) -> String {+    private static func exportMessage(for error: BackupV9ExportError) -> String {         switch error {         case .tornGroups(let payload):             tornGroupsMessage(payload)@@ -203,7 +204,7 @@ public final class SettingsBackupModel {         switch error {         case let e as BackupCodecError:             "codec: \(e)"-        case let e as BackupV8ExportError:+        case let e as BackupV9ExportError:             "export: \(e)"         case let e as LibraryRepositoryError:             "repository: \(e)"

diff --git a/Asterism/Asterism/ViewModels/WorkDetailModel.swift b/Asterism/Asterism/ViewModels/WorkDetailModel.swiftindex 365a748..998ffc7 100644--- a/Asterism/Asterism/ViewModels/WorkDetailModel.swift+++ b/Asterism/Asterism/ViewModels/WorkDetailModel.swift@@ -179,6 +179,26 @@ public final class WorkDetailModel {     public var draftTags: [String] = []     public var draftNotes: String = "" +    // MARK: - The two statuses and the verdict (`work-and-reading-status`)++    /// The work's own side, as the capsule shows it (Req 1.2).+    ///+    /// `private(set)`: both status drafts move through their setters below,+    /// because the transitions carry rules — the finished-reading prompt on one+    /// side and Req 3.3's auto-revert on the other. A raw property write from a+    /// control would step past both.+    public private(set) var draftWorkStatus: WorkStatus = .ongoing+    /// The reader's side (Req 2.2).+    public private(set) var draftReadingStatus: ReadingStatus = .reading+    /// The verdict, always written whatever the reading status is (Req 2.5): a+    /// verdict typed and then hidden by a status change is still the reader's+    /// text, and an auto-revert must not erase it.+    public var draftVerdict: String = ""+    /// Whether *this* session's work-status change is what moved the reading+    /// status off `finished` (Req 3.3). Q39 undoes it in full when the work goes+    /// back to `finished`; any other reading change clears it.+    public private(set) var autoRevertedReading = false+     // 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 = ""@@ -233,6 +253,10 @@ public final class WorkDetailModel {             typeOptions = await pickerOptions(carrying: snapshot.typeDisplay)             draftTags = snapshot.genreTags             draftNotes = snapshot.genericNotes+            draftWorkStatus = snapshot.workStatus+            draftReadingStatus = snapshot.readingStatus+            draftVerdict = snapshot.verdict+            autoRevertedReading = false             adoptCharacterDrafts(detail.characters)             // Before the projection below, which is *about* the selected site.             resetWorkURLHostnameIfNeeded()@@ -556,6 +580,12 @@ public final class WorkDetailModel {             || draftAssignment != work.typeDisplay.assignment             || draftTags != work.genreTags             || draftNotes != work.genericNotes+            || draftWorkStatus != work.workStatus+            || draftReadingStatus != work.readingStatus+            // Compared whatever the reading status is (Req 2.5): a verdict the+            // reader typed before hiding the field is a change the checkmark has+            // to be offered for.+            || draftVerdict != work.verdict     }      // MARK: - View mode and edit mode (Decision 5)@@ -613,6 +643,12 @@ public final class WorkDetailModel {     /// the URL after it would be committing a draft that had just been     /// overwritten.     public func commitEditing() async {+        // Req 3.4, and **first**: ahead of the URL step and every other write,+        // so a cancel at the dialog leaves every draft exactly as it was (Q37).+        if let prompt = finishedReadingCommitPrompt() {+            finishedReadingPrompt = prompt+            return+        }         var committedURL = false         if hasUnsavedWorkURLChange {             guard await commitWorkURLDraft() else { return }@@ -649,9 +685,111 @@ public final class WorkDetailModel {         draftAssignment = work.typeDisplay.assignment         draftTags = work.genreTags         draftNotes = work.genericNotes+        draftWorkStatus = work.workStatus+        draftReadingStatus = work.readingStatus+        draftVerdict = work.verdict+        // The session that could have auto-reverted is over.+        autoRevertedReading = false+        finishedReadingPrompt = nil         adoptCharacterDrafts(presentation?.characters ?? [])     } +    // MARK: - The finished-reading rule (Decision 1, Reqs 3.1–3.5)++    /// What the "Mark as finished?" dialog is offering, or nil when none is up.+    ///+    /// Built as a **presented value** rather than a flag beside the model, on+    /// `WorkDeletionPrompt`'s shape and for its reason (Q37): SwiftUI runs a+    /// dialog's `isPresented` setter — the dismissal, which clears this — before+    /// it runs the tapped button's action, so `thenCommits` has to travel on the+    /// value the dialog rendered or the follow-through silently stops happening.+    public private(set) var finishedReadingPrompt: FinishedReadingPrompt?++    /// Req 3.1's transition: `finished` reading on a work that is not itself+    /// finished asks instead of writing, and the draft stays where it was, so+    /// the capsule keeps showing the previous value while the dialog is up.+    ///+    /// Re-selecting the value the draft already holds is a no-op, which is what+    /// keeps a *stored* violating pair (Req 3.5) from raising the dialog by+    /// being tapped.+    public func setDraftReadingStatus(_ status: ReadingStatus) {+        guard status != draftReadingStatus else { return }+        guard status != .finished || draftWorkStatus == .finished else {+            finishedReadingPrompt = FinishedReadingPrompt(id: workID, thenCommits: false)+            return+        }+        draftReadingStatus = status+        // Q39: the restore is only ever the undo of *this* session's revert. A+        // reading status the reader chose afterwards is theirs.+        autoRevertedReading = false+    }++    /// Req 3.3's transition, and Q39's undo of it. Neither raises a dialog: the+    /// revert is the rule keeping `finished` meaningful, and the restore is the+    /// mis-tap being taken back.+    public func setDraftWorkStatus(_ status: WorkStatus) {+        guard status != draftWorkStatus else { return }+        let previous = draftWorkStatus+        draftWorkStatus = status+        if previous == .finished, draftReadingStatus == .finished {+            // Req 2.5: the verdict text stays; only the field goes.+            draftReadingStatus = .reading+            autoRevertedReading = true+            return+        }+        if status == .finished, autoRevertedReading, draftReadingStatus == .reading {+            draftReadingStatus = .finished+            autoRevertedReading = false+        }+    }++    /// Req 3.4's gate (Q20): the pair is checked at the commit as well as at the+    /// pickers, because a work-status edit over a stored violating pair reaches+    /// neither transition. Gated on the draft pair *differing* from the stored+    /// one, so committing Req 3.5's stored violation unchanged writes it back+    /// rather than interrogating the reader about a state they did not create.+    private func finishedReadingCommitPrompt() -> FinishedReadingPrompt? {+        guard let work,+            draftReadingStatus == .finished,+            draftWorkStatus != .finished,+            draftWorkStatus != work.workStatus || draftReadingStatus != work.readingStatus+        else { return nil }+        return FinishedReadingPrompt(id: workID, thenCommits: true)+    }++    /// The dialog's dismissal, and its Cancel. Nothing is restored because+    /// nothing was changed — the transitions above leave the drafts alone until+    /// the reader answers.+    public func cancelFinishedReadingPrompt() {+        finishedReadingPrompt = nil+    }++    /// The reader's answer, over the prompt the dialog rendered.+    ///+    /// The prompt is a parameter rather than a property read, for+    /// `chooseDeletion(_:disposition:)`'s reason: the dismissal has already+    /// cleared the property by the time this runs.+    ///+    /// `async` because of the follow-through — a prompt raised at the commit+    /// resumes it, and the second `commitEditing()` now passes the check. When+    /// that commit stops in the URL step, the resolved statuses stay in the+    /// drafts and the editor stays open, exactly as any other URL refusal+    /// leaves the drafts beside it.+    public func resolveFinishedReadingPrompt(+        _ prompt: FinishedReadingPrompt, choosing resolution: FinishedReadingResolution+    ) async {+        finishedReadingPrompt = nil+        switch resolution {+        case .markWorkFinished:+            draftWorkStatus = .finished+            draftReadingStatus = .finished+        case .abandonInstead:+            draftReadingStatus = .abandoned+        }+        autoRevertedReading = false+        if prompt.thenCommits { await commitEditing() }+    }+     // MARK: - The character edit session (Reqs 3.2, 3.7, 5.3)      /// Whether the reader has a character edit session in progress — staged@@ -886,14 +1024,29 @@ public final class WorkDetailModel {                 displayTitle: draftTitle,                 typeAssignment: draftAssignment,                 genreTags: draftTags,-                genericNotes: draftNotes+                genericNotes: draftNotes,+                // What the capsules show and what the field holds (Q40).+                // `updateWork` writes all three to every row (Req 7.1), so a+                // draft carrying anything but the reader's own values would+                // write their change away with nothing to see.+                workStatus: draftWorkStatus,+                readingStatus: draftReadingStatus,+                verdict: draftVerdict             )             let basis = work.map(WorkEditBasis.init(work:))                 ?? WorkEditBasis(                     displayTitle: draftTitle, typeAssignment: draftAssignment,                     genreTags: draftTags,                     genericNotes: draftNotes, memberships: [],-                    lastParsedTitle: nil, titleProvenance: .manual)+                    lastParsedTitle: nil, titleProvenance: .manual,+                    // Stated rather than left to the parameter defaults (Q47),+                    // from the same drafts the draft above sends — as every+                    // other field of this fallback is. A basis quietly holding+                    // `.ongoing`/`.reading`/`""` here would refuse every write+                    // on a marked work.+                    workStatus: draftWorkStatus,+                    readingStatus: draftReadingStatus,+                    verdict: draftVerdict)             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@@ -1210,6 +1363,41 @@ public final class WorkDetailModel {     } } +/// What the "Mark as finished?" dialog is offering (Req 3.1, Decision 1).+///+/// `WorkDeletionPrompt`'s shape, and for its reason: the value travels to the+/// dialog through `presenting:` and back into the model as a parameter, because+/// SwiftUI runs the dismissal before the tapped button's action.+///+/// `thenCommits` is the one thing the two arms differ by: the prompt raised at a+/// picker leaves the reader in edit mode, and the one raised at the commit+/// resumes the commit the reader had already asked for.+public struct FinishedReadingPrompt: Identifiable, Equatable, Sendable {+    public let id: UUID+    public let thenCommits: Bool++    /// The sentence above the three choices. Wording lives on the value, per the+    /// house convention that models own text and views own layout.+    public var message: String {+        "Finished reading means you read the whole work, and this one is not "+            + "marked finished. "+            + (thenCommits+                ? "Nothing has been saved yet."+                : "Choose what to record.")+    }+}++/// The two answers Req 3.1 offers that *change* something, and nothing else.+///+/// Cancel is not a case here, on `WorkDeletionDisposition`'s shape and for its+/// reason: the dialog's Cancel and its dismissal both go through+/// `cancelFinishedReadingPrompt()`, which is synchronous and has nothing to+/// resolve. A `.cancel` case would only be a second spelling of that call.+public enum FinishedReadingResolution: Equatable, Sendable {+    case markWorkFinished+    case abandonInstead+}+ /// What the Work URL section still shows. /// /// Q57 retired `work-detail-url-save` and `work-detail-url-clear` with the

diff --git a/Asterism/Asterism/ViewModels/WorksListOptions.swift b/Asterism/Asterism/ViewModels/WorksListOptions.swiftindex 9cb9328..06e5609 100644--- a/Asterism/Asterism/ViewModels/WorksListOptions.swift+++ b/Asterism/Asterism/ViewModels/WorksListOptions.swift@@ -68,13 +68,35 @@ enum WorksSort: String, CaseIterable, Identifiable, Sendable {         }     } +    /// The ordering, then `work-and-reading-status` Req 5.3's partition.+    ///+    /// The partition runs last, over whatever the ordering produced, so the rule+    /// costs one line rather than one per sort. `WorksView` then splits the+    /// result by emptiness with `filter`; both steps are stable, so each section+    /// ends with its abandoned works in the active sort's order — under+    /// `.oldest`'s per-section reversal included (Q31).+    func apply(to works: [WorkSnapshot]) -> [WorkSnapshot] {+        Self.abandonedLast(ordered(works))+    }++    /// Abandoned works after everything else, each group in the order it was+    /// handed (Req 5.3).+    ///+    /// Two `filter` calls concatenated rather than `partition(by:)`: the+    /// standard library's partition is **not** stable, so it would scramble the+    /// order the sort above just established.+    private static func abandonedLast(_ works: [WorkSnapshot]) -> [WorkSnapshot] {+        works.filter { $0.readingStatus != .abandoned }+            + works.filter { $0.readingStatus == .abandoned }+    }+     /// The ordering itself, over the repository's order.     ///     /// Oldest first reverses each section separately, so the empty works stay     /// behind the non-empty ones while their own `modifiedAt` order and id     /// tie-break reverse with the rest (Req 1). The title sorts order everything     /// together, because they draw one section.-    func apply(to works: [WorkSnapshot]) -> [WorkSnapshot] {+    private func ordered(_ works: [WorkSnapshot]) -> [WorkSnapshot] {         switch self {         case .newest:             return works@@ -131,24 +153,38 @@ enum WorksTypeSelection: Hashable, Sendable {     } } -/// The Works list's three single-value filters (Req 5, Q3).+/// The Works list's five single-value filters (Req 5, Q3;+/// `work-and-reading-status` Req 6.1). ///-/// One value per dimension, ANDed across the three and with the search query.-/// View state with the query's lifetime rather than a stored preference (Q5): a-/// sort is a preference a reader sets once, a filter is a question they are-/// asking now.+/// One value per dimension, ANDed across them and with the search query. View+/// state with the query's lifetime rather than a stored preference (Q5): a sort+/// is a preference a reader sets once, a filter is a question they are asking+/// now.+///+/// The two status dimensions differ from the other three in one way only: their+/// vocabularies are closed, so they carry nothing in `WorksFilterOptions` and+/// `pruned(to:)` never touches them (Q30). struct WorksFilter: Equatable, Sendable {     var type: WorksTypeSelection?     var tag: String?     var hostname: String?+    var workStatus: WorkStatus?+    var readingStatus: ReadingStatus? -    init(type: WorksTypeSelection? = nil, tag: String? = nil, hostname: String? = nil) {+    init(+        type: WorksTypeSelection? = nil, tag: String? = nil, hostname: String? = nil,+        workStatus: WorkStatus? = nil, readingStatus: ReadingStatus? = nil+    ) {         self.type = type         self.tag = tag         self.hostname = hostname+        self.workStatus = workStatus+        self.readingStatus = readingStatus     } -    var isActive: Bool { type != nil || tag != nil || hostname != nil }+    var isActive: Bool {+        type != nil || tag != nil || hostname != nil || workStatus != nil || readingStatus != nil+    }      func apply(to works: [WorkSnapshot]) -> [WorkSnapshot] {         guard isActive else { return works }@@ -160,6 +196,10 @@ struct WorksFilter: Equatable, Sendable {     /// this the picker holds a selection none of its rows carry, draws no     /// 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.     func pruned(to options: WorksFilterOptions) -> WorksFilter {         var pruned = self         if let type, !options.types.contains(where: { $0.selection == type }) { pruned.type = nil }@@ -180,6 +220,11 @@ struct WorksFilter: Equatable, Sendable {         if let hostname, !work.memberships.contains(where: { $0.hostname == hostname }) {             return false         }+        // Compared against the *resolved* statuses, so a stored spelling this+        // build does not know is filtered as the default it reads as+        // (Reqs 1.3, 2.7).+        if let workStatus, work.workStatus != workStatus { return false }+        if let readingStatus, work.readingStatus != readingStatus { return false }         return true     } }@@ -284,14 +329,25 @@ struct WorksFilterOptions: Equatable, Sendable { /// the values are `Sendable`: pure functions of value types. nonisolated enum WorksFilterPresentation { -    /// The active values in menu order — type, then tag, then site — spelled as-    /// the pickers spell them. A type is named by the option it came from, so a-    /// merged type's pill wears the same first-seen spelling its menu row does.+    /// The active values in menu order — type, tag, site, work status, reading+    /// status — spelled as the pickers spell them. A type is named by the option+    /// it came from, so a merged type's pill wears the same first-seen spelling+    /// its menu row does.+    ///+    /// The two statuses are named **with their dimension** (Q23): both have a+    /// value called "Finished", and a pill row reading "Finished, Finished"+    /// would tell the reader nothing about what is narrowing their list.     static func activeLabels(_ filter: WorksFilter, options: WorksFilterOptions) -> [String] {         var labels: [String] = []         if let type = filter.type { labels.append(options.name(for: type)) }         if let tag = filter.tag { labels.append(tag) }         if let hostname = filter.hostname { labels.append(hostname) }+        if let workStatus = filter.workStatus {+            labels.append(WorkStatusPresentation.accessibilityLabel(workStatus))+        }+        if let readingStatus = filter.readingStatus {+            labels.append(ReadingStatusPresentation.accessibilityLabel(readingStatus))+        }         return labels     } @@ -330,4 +386,19 @@ nonisolated enum WorksFilterPresentation {     static func siteRowIdentifier(_ hostname: String) -> String {         "works-filter-site-\(hostname)"     }++    // MARK: - The two status dimensions (`work-and-reading-status` Req 6.1)++    static let anyWorkStatusRowIdentifier = "works-filter-work-status-any"+    static let anyReadingStatusRowIdentifier = "works-filter-reading-status-any"++    /// Keyed by the raw value, which is the stored spelling and is frozen — so+    /// a UI test addressing a status row is addressing the column itself.+    static func workStatusRowIdentifier(_ status: WorkStatus) -> String {+        "works-filter-work-status-\(status.rawValue)"+    }++    static func readingStatusRowIdentifier(_ status: ReadingStatus) -> String {+        "works-filter-reading-status-\(status.rawValue)"+    } }

diff --git a/Asterism/Asterism/Views/DuplicateResolutionView.swift b/Asterism/Asterism/Views/DuplicateResolutionView.swiftindex 002edfa..ccc8611 100644--- a/Asterism/Asterism/Views/DuplicateResolutionView.swift+++ b/Asterism/Asterism/Views/DuplicateResolutionView.swift@@ -273,6 +273,30 @@ struct DuplicateResolutionView: View {                         .lineLimit(1)                         .foregroundStyle(.secondary)                 }+                // V10 (Req 7.2): a status the copies disagree on is part of the+                // decision, so it is on the row that the reader picks.+                if let line = Self.workStatusLine(variant, differing: model.differingFields) {+                    Text(line)+                        .font(.caption)+                        .foregroundStyle(.secondary)+                        .accessibilityIdentifier("duplicate-variant-work-status")+                }+                if let line = Self.readingStatusLine(variant, differing: model.differingFields) {+                    Text(line)+                        .font(.caption)+                        .foregroundStyle(.secondary)+                        .accessibilityIdentifier("duplicate-variant-reading-status")+                }+            }+            // Q21: shown whatever the reading status. Q7 hides a verdict under+            // `reading` everywhere else, and two copies differing by nothing but+            // that text would otherwise be indistinguishable here.+            if let verdict = Self.verdictLine(variant, differing: model.differingFields) {+                Text(verdict)+                    .font(.caption)+                    .lineLimit(3)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("duplicate-variant-verdict")             }             Text(variant.firstCapturedAt, style: .date)                 .font(.caption2)@@ -281,6 +305,45 @@ struct DuplicateResolutionView: View {         }     } +    // MARK: - The Work variant's status arms (V10 Req 7.2)++    /// The three arms are pure functions of the variant and the differing set so+    /// the words a reader chooses copies by can be pinned without a screen —+    /// `WorkMergeView.identityLine`'s shape.+    ///+    /// Both statuses have a value called "finished", and the row prints bare+    /// names, so each line names its dimension (Q23) — which is exactly what+    /// `WorkStatusPresentation.accessibilityLabel` spells for the row glyphs and+    /// the filter pills. The words were duplicated here only until that table+    /// landed (Q54); this sheet is its fourth consumer, not a second table.+    static func workStatusLine(+        _ variant: WorkVariantChoice, differing: [DuplicateResolutionField]+    ) -> String? {+        guard differing.contains(.workStatus) else { return nil }+        return WorkStatusPresentation.accessibilityLabel(variant.workStatus)+    }++    static func readingStatusLine(+        _ variant: WorkVariantChoice, differing: [DuplicateResolutionField]+    ) -> String? {+        guard differing.contains(.readingStatus) else { return nil }+        return ReadingStatusPresentation.accessibilityLabel(variant.readingStatus)+    }++    /// Labelled like the two status arms, and for the same reason: the line sits+    /// directly under the generic notes, and a bare run of reader prose there is+    /// indistinguishable from another copy's notes.+    ///+    /// Blank rather than `isEmpty`: the fold decides a verdict is worth carrying+    /// with `M2Unicode.isBlank`, so a verdict of nothing but whitespace has to+    /// read as absent on the sheet too.+    static func verdictLine(+        _ variant: WorkVariantChoice, differing: [DuplicateResolutionField]+    ) -> String? {+        guard differing.contains(.verdict), !M2Unicode.isBlank(variant.verdict) else { return nil }+        return "Verdict: \(variant.verdict)"+    }+     private func ratingLabel(_ rating: Rating?) -> String {         switch rating {         case .up: "▲"

diff --git a/Asterism/Asterism/Views/WorkDetailView.swift b/Asterism/Asterism/Views/WorkDetailView.swiftindex b1b1c6f..e55bf14 100644--- a/Asterism/Asterism/Views/WorkDetailView.swift+++ b/Asterism/Asterism/Views/WorkDetailView.swift@@ -317,6 +317,10 @@ struct WorkDetailView: View {                 "This work stops being on \(hostname). Nothing else changes — it "                     + "has no notes from there, and its other sites keep theirs.")         }+        // Req 3.1's three actions, in a modifier of their own: the `List` above+        // already carries five presentations, and one more inline put the+        // builder past what the type checker will solve in reasonable time.+        .finishedReadingDialog(model)     }      // MARK: - View mode@@ -388,6 +392,26 @@ struct WorkDetailView: View {                     .accessibilityIdentifier("work-detail-tags")                 } +                // Req 4.2: the reader's closing thought, between the tags and+                // the work's own notes. Shown only where there is one to show —+                // Req 2.5 keeps a stored verdict but hides it while the reader+                // is back on `reading`.+                if work.readingStatus.isDone, !M2Unicode.isBlank(work.verdict) {+                    VStack(alignment: .leading, spacing: 4) {+                        Text("Verdict")+                            .font(.caption)+                            .foregroundStyle(AsterismColors.secondaryText)+                        Text(work.verdict)+                            .font(.subheadline)+                            .foregroundStyle(AsterismColors.noteText)+                            .lineSpacing(4)+                            .fixedSize(horizontal: false, vertical: true)+                    }+                    .frame(maxWidth: .infinity, alignment: .leading)+                    .accessibilityElement(children: .contain)+                    .accessibilityIdentifier("work-detail-verdict")+                }+                 // The work's own notes read as the lede of the page: a                 // paragraph, no card and no section header of its own. Absent                 // when there are none — an empty field on a read screen invites@@ -492,6 +516,28 @@ struct WorkDetailView: View {                 .foregroundStyle(AsterismColors.violet)                 .accessibilityLabel("\(model.pulse.down) rated down")                 .accessibilityIdentifier("work-detail-pulse-down")++            // Req 4.1: the two statuses as further items on the same line, each+            // a glyph with its name. A status on its default adds nothing —+            // which is what the presentation table's nil symbol says — so the+            // line is unchanged for the works the reader has said nothing about.+            let workStatus = model.work?.workStatus ?? .ongoing+            if let symbol = WorkStatusPresentation.systemImage(workStatus) {+                Label(WorkStatusPresentation.name(workStatus), systemImage: symbol)+                    .font(.caption)+                    .foregroundStyle(WorkStatusPresentation.hue(workStatus))+                    .accessibilityLabel(WorkStatusPresentation.accessibilityLabel(workStatus))+                    .accessibilityIdentifier("work-detail-status-work")+            }+            let readingStatus = model.work?.readingStatus ?? .reading+            if let symbol = ReadingStatusPresentation.systemImage(readingStatus) {+                Label(ReadingStatusPresentation.name(readingStatus), systemImage: symbol)+                    .font(.caption)+                    .foregroundStyle(ReadingStatusPresentation.hue(readingStatus))+                    .accessibilityLabel(+                        ReadingStatusPresentation.accessibilityLabel(readingStatus))+                    .accessibilityIdentifier("work-detail-status-reading")+            }         }         .lineLimit(1)         // `children: .contain` before the identifier, or the group's identifier@@ -538,6 +584,52 @@ struct WorkDetailView: View {             .constellationCard()             .constellationListRow() +            // Reqs 1.2 and 2.2, in the order they are named. Both capsules+            // contain a segment called "Finished" and nothing else on the screen+            // says which is which, so each carries a visible caption rather than+            // relying on position (Q26 chose the capsule over a `Picker`: three+            // short labels are a state to see, not a menu to open).+            captionedCard("Work status") {+                ConstellationSegmentedControl(+                    values: WorkStatus.allCases,+                    selection: Binding(+                        get: { model.draftWorkStatus },+                        set: { model.setDraftWorkStatus($0) }),+                    containerLabel: "Work status",+                    title: WorkStatusPresentation.name,+                    identifier: WorkStatusPresentation.controlIdentifier)+            }++            captionedCard("Reading status") {+                ConstellationSegmentedControl(+                    values: ReadingStatus.allCases,+                    selection: Binding(+                        get: { model.draftReadingStatus },+                        // Req 3.1: the setter is the transition, not an+                        // assignment — choosing `finished` on an unfinished work+                        // raises the dialog and leaves the capsule where it was.+                        set: { model.setDraftReadingStatus($0) }),+                    containerLabel: "Reading status",+                    title: ReadingStatusPresentation.name,+                    identifier: ReadingStatusPresentation.controlIdentifier)+            }++            // Req 2.3: present exactly while the draft reading status is done+            // reading, under the prompt that tells the two verdicts apart. The+            // table returns nil for `reading`, which *is* the absence.+            if let prompt = ReadingStatusPresentation.verdictPrompt(model.draftReadingStatus) {+                captionedCard(prompt) {+                    TextField(prompt, text: $model.draftVerdict, axis: .vertical)+                        .lineLimit(3...6)+                        // Req 10.1: the caption is a sibling `Text`, so the+                        // field carries the same prompt as its placeholder and+                        // its spoken label, and the reader hears which verdict+                        // is being asked for.+                        .accessibilityLabel(prompt)+                        .accessibilityIdentifier("work-detail-verdict-field")+                }+            }+             TextField(                 "Genre tags (comma-separated)",                 text: Binding(@@ -558,6 +650,27 @@ struct WorkDetailView: View {         }     } +    /// One edit-mode card under a visible caption — the recipe the two status+    /// capsules and the verdict field share.+    ///+    /// The caption is a label rather than a placeholder for the verdict's reason+    /// (Q16): a placeholder vanishes the moment the reader types, and here it is+    /// the caption that says what the control is for.+    private func captionedCard(+        _ caption: String, @ViewBuilder content: () -> some View+    ) -> some View {+        VStack(alignment: .leading, spacing: 8) {+            Text(caption)+                .font(.caption.weight(.semibold))+                .foregroundStyle(AsterismColors.secondaryText)+            content()+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(12)+        .constellationCard()+        .constellationListRow()+    }+     /// Req 5.3. Hidden entirely where the work has no entries — the repository     /// decides that by returning no URL, so the screen never has to guess.     @ViewBuilder@@ -1813,6 +1926,44 @@ private struct WorkChapterRowView: View {     } } +// MARK: - The finished-reading dialog (Req 3.1, Decision 1)++extension View {+    /// Req 3.1's dialog, raised either by the reading-status capsule or by the+    /// checkmark (Req 3.4).+    ///+    /// The prompt travels to the buttons as `presenting:` and back into the+    /// model as a parameter (Q37): SwiftUI runs the dismissal — which clears the+    /// model's prompt — before the tapped button's action, so a commit+    /// follow-through read from the model would find nothing to follow.+    ///+    /// A modifier of its own rather than a sixth presentation inline on the+    /// screen's `List`: that expression was already at the edge of what the type+    /// checker will solve, and one more sent it over.+    fileprivate func finishedReadingDialog(_ model: WorkDetailModel) -> some View {+        confirmationDialog(+            "Mark as finished?",+            isPresented: Binding(+                get: { model.finishedReadingPrompt != nil },+                set: { if !$0 { model.cancelFinishedReadingPrompt() } }),+            presenting: model.finishedReadingPrompt+        ) { prompt in+            Button("Mark the work finished too") {+                Task { await model.resolveFinishedReadingPrompt(prompt, choosing: .markWorkFinished) }+            }+            .accessibilityIdentifier("work-detail-finished-mark-work")+            Button("Abandoned instead") {+                Task { await model.resolveFinishedReadingPrompt(prompt, choosing: .abandonInstead) }+            }+            .accessibilityIdentifier("work-detail-finished-abandon")+            Button("Cancel", role: .cancel) { model.cancelFinishedReadingPrompt() }+                .accessibilityIdentifier("work-detail-finished-cancel")+        } message: { prompt in+            Text(prompt.message)+        }+    }+}+ // MARK: - Sort order titles  /// The two orders as the capsule offers them, stated beside the control that

diff --git a/Asterism/Asterism/Views/WorkMergeView.swift b/Asterism/Asterism/Views/WorkMergeView.swiftindex f26d0fa..d7cce1c 100644--- a/Asterism/Asterism/Views/WorkMergeView.swift+++ b/Asterism/Asterism/Views/WorkMergeView.swift@@ -129,8 +129,14 @@ struct WorkMergeView: View {     }      /// One sentence per candidate, naming what the row shows: the title, the-    /// sites, the type where it has one, the note count, and why it cannot be-    /// chosen where it cannot.+    /// sites, the type where it has one, the note count, its status marks, and+    /// why it cannot be chosen where it cannot.+    ///+    /// `work-and-reading-status` Req 5.4/Q32: the picker draws `WorkRow`, so its+    /// rows wear the same glyphs — and a picker row is one button too, so the+    /// clauses reach a reader who cannot see them only through this label. They+    /// sit before the refusal, which is a finished sentence of its own and has+    /// to stay the last thing the row says.     static func destinationLabel(_ work: WorkSnapshot, unavailable: String?) -> String {         var parts = ["Merge into \(work.displayTitle)"]         if !work.memberships.isEmpty {@@ -138,8 +144,14 @@ struct WorkMergeView: View {         }         if let typeName = work.typeDisplay.name { parts.append(typeName) }         parts.append(Pluralisation.count(work.entries.count, "note", "notes"))-        if let unavailable { parts.append(unavailable) }-        return parts.joined(separator: ", ")+        let clause = WorksRowPresentation.statusClause(for: work)+        let described = parts.joined(separator: ", ") + clause+        guard let unavailable else { return described }+        // The refusal is a finished sentence of its own, and so is a status+        // clause (Q32): a comma between them would splice two sentences+        // together. Without a clause the label is still mid-sentence, so it+        // keeps the comma it has always had.+        return described + (clause.isEmpty ? ", " : ". ") + unavailable     }      // MARK: - Confirmation Preview@@ -201,10 +213,10 @@ struct WorkMergeView: View {                             Image(systemName: "checkmark.circle")                                 .foregroundStyle(AsterismColors.cyan)                                 .accessibilityHidden(true)-                            Text(fieldLabel(field))+                            Text(Self.fieldLabel(field))                         }                         .frame(minHeight: AsterismLayout.minHitTarget)-                        .accessibilityLabel("Kept: \(fieldLabel(field))")+                        .accessibilityLabel("Kept: \(Self.fieldLabel(field))")                         .accessibilityIdentifier("merge-retained-\(field.rawValue)")                     }                 }@@ -218,13 +230,17 @@ struct WorkMergeView: View {                             Image(systemName: "archivebox")                                 .foregroundStyle(AsterismColors.amberText)                                 .accessibilityHidden(true)-                            Text(fieldLabel(field))-                            Text("Recorded in merged notes")+                            Text(Self.fieldLabel(field))+                            // Req 7.3: which discarded fields the merged notes+                            // record and which are simply dropped. One caption+                            // for both was a false promise once a dropped status+                            // could appear in this list.+                            Text(Self.discardedCaption(field))                                 .font(.caption)                                 .foregroundStyle(.secondary)                         }                         .frame(minHeight: AsterismLayout.minHitTarget)-                        .accessibilityLabel("Discarded: \(fieldLabel(field)), recorded in merged notes")+                        .accessibilityLabel(Self.discardedRowLabel(field))                         .accessibilityIdentifier("merge-discarded-\(field.rawValue)")                     }                 }@@ -244,7 +260,7 @@ struct WorkMergeView: View {                                 .accessibilityHidden(true)                             Text("Notes will include merge record")                         }-                        .accessibilityLabel("Audit block: discarded values will be recorded in target notes")+                        .accessibilityLabel(Self.auditBlockLabel)                     }                     .accessibilityIdentifier("merge-audit-disclosure")                 }@@ -304,7 +320,9 @@ struct WorkMergeView: View {      // MARK: - Label Helpers -    private func fieldLabel(_ field: WorkMergeField) -> String {+    /// Static and pure, like `identityLine`: the words a reader approves a merge+    /// on are pinned without a screen.+    static func fieldLabel(_ field: WorkMergeField) -> String {         switch field {         case .targetDisplayTitle: "Target title"         case .sourceManualTitle: "Source manual title"@@ -315,9 +333,35 @@ struct WorkMergeView: View {         case .sourceNotes: "Source notes"         case .targetGenreTags: "Target tags"         case .sourceGenreTags: "Source tags"+        case .targetWorkStatus: "Target work status"+        case .targetReadingStatus: "Target reading status"+        case .targetVerdict: "Target verdict"+        case .sourceWorkStatus: "Source work status"+        case .sourceReadingStatus: "Source reading status"+        case .sourceVerdict: "Source verdict"         }     } +    /// What becomes of a discarded field (Req 7.3). The answer is the field's+    /// own, not the section's: a title, a Work URL, notes and a verdict are+    /// written into the merged notes, and a dropped status is not written+    /// anywhere.+    static func discardedCaption(_ field: WorkMergeField) -> String {+        field.recordedInNotes ? "Recorded in merged notes" : "Not carried over"+    }++    /// The discarded row's spoken sentence, composed here rather than at the+    /// call site so the two halves and the comma between them are one pinnable+    /// thing (Req 7.3).+    static func discardedRowLabel(_ field: WorkMergeField) -> String {+        "Discarded: \(fieldLabel(field)), \(discardedCaption(field).lowercased())"+    }++    /// The disclosure's label no longer claims the block holds *every* discarded+    /// value: since V10 the list can carry statuses, which it does not record.+    static let auditBlockLabel =+        "Audit block: the discarded values marked recorded in merged notes are added to the target's notes"+     private func issueLabel(_ issue: WorkMergeIssue) -> String {         switch issue {         case .reviewURLIdentity: "Review URL identity after merge"

diff --git a/Asterism/Asterism/Views/WorkStatusPresentation.swift b/Asterism/Asterism/Views/WorkStatusPresentation.swiftnew file mode 100644index 0000000..5514fc2--- /dev/null+++ b/Asterism/Asterism/Views/WorkStatusPresentation.swift@@ -0,0 +1,114 @@+import AsterismCore+import ConstellationKit+import SwiftUI++/// The one place a `WorkStatus` becomes words, a symbol and a hue (Q36).+///+/// Beside `WorkTypePresentation.swift`, and for its reason: four surfaces —+/// the Works row's glyph and label, the filter menu and its pills, the work+/// page's meta line, and the duplicate sheet's variant lines (Q54) — say the+/// same three things about a status, and a table each is four chances for them+/// to disagree in a way only a reader would notice.+///+/// `nonisolated` throughout: `WorksFilterPresentation` is a pure value-type+/// helper and reads these, so under this target's MainActor-by-default+/// isolation the whole table has to be reachable from outside the actor.+nonisolated enum WorkStatusPresentation {++    /// What the reader is told a status is called — the picker row, the meta+    /// line, and the second half of every label below.+    static func name(_ status: WorkStatus) -> String {+        switch status {+        case .ongoing: "Ongoing"+        case .finished: "Finished"+        case .hiatus: "On hiatus"+        }+    }++    /// The row's mark, or nil where there is nothing to mark (Reqs 4.3, 5.1):+    /// `ongoing` is the default every work starts on, and a glyph on every row+    /// would say nothing.+    ///+    /// Neither symbol is used anywhere else in the app, so neither drags an+    /// existing meaning in with it (Q27).+    static func systemImage(_ status: WorkStatus) -> String? {+        switch status {+        case .ongoing: nil+        case .finished: "flag.checkered"+        case .hiatus: "pause.circle"+        }+    }++    /// The type tag's violet (Q27): the work side of a row already speaks in+    /// violet, and the feature adds no third accent to the design language.+    ///+    /// Takes the value like every other entry in the table, so a call site+    /// reads one shape per column — the hue is per dimension today, and a+    /// signature that said so would have to change if it ever stopped being.+    static func hue(_ status: WorkStatus) -> Color { AsterismColors.violet }++    /// The words the glyph is worth to a reader who cannot see it — and,+    /// unchanged, the filter pill's own visible text and the duplicate sheet's+    /// variant line (Q23, Q54).+    ///+    /// Every value is named with its dimension because both enums have a value+    /// called "Finished": an unqualified pill row would read "Finished,+    /// Finished" and say nothing.+    static func accessibilityLabel(_ status: WorkStatus) -> String { "Work: \(name(status))" }++    /// The edit-mode capsule segment's identifier, spelled here beside the+    /// name so the journeys and the view read one table.+    static func controlIdentifier(_ status: WorkStatus) -> String {+        "work-detail-work-status-\(status.rawValue)"+    }+}++/// The same table for the reader's side of a work (Q36).+nonisolated enum ReadingStatusPresentation {++    static func name(_ status: ReadingStatus) -> String {+        switch status {+        case .reading: "Reading"+        case .finished: "Finished"+        case .abandoned: "Abandoned"+        }+    }++    /// Marked exactly where the verdict exists — `isDone` — because those are+    /// the two states the reader has left behind them. `reading` is the default+    /// and draws nothing (Reqs 4.3, 5.1, 5.2).+    static func systemImage(_ status: ReadingStatus) -> String? {+        switch status {+        case .reading: nil+        case .finished: "checkmark"+        case .abandoned: "book.closed"+        }+    }++    /// The count pill's cyan (Q27), for `WorkStatusPresentation.hue`'s reason:+    /// the reading side of a row already speaks in cyan.+    static func hue(_ status: ReadingStatus) -> Color { AsterismColors.cyan }++    static func accessibilityLabel(_ status: ReadingStatus) -> String {+        "Reading: \(name(status))"+    }++    /// The edit-mode capsule segment's identifier (see `WorkStatusPresentation`).+    static func controlIdentifier(_ status: ReadingStatus) -> String {+        "work-detail-reading-status-\(status.rawValue)"+    }++    /// The label above the verdict field (Req 2.3, Q16). It is the prompt that+    /// tells the two verdicts apart, so it is a label rather than a placeholder+    /// — a placeholder vanishes the moment the reader types.+    ///+    /// Nil exactly where the field is absent: a work still being read has no+    /// verdict to write yet.+    static func verdictPrompt(_ status: ReadingStatus) -> String? {+        switch status {+        case .reading: nil+        case .finished: "How was it?"+        case .abandoned: "Why did you stop?"+        }+    }+}

diff --git a/Asterism/Asterism/Views/WorksView.swift b/Asterism/Asterism/Views/WorksView.swiftindex 24cb6fd..c7e5b8d 100644--- a/Asterism/Asterism/Views/WorksView.swift+++ b/Asterism/Asterism/Views/WorksView.swift@@ -250,6 +250,25 @@ struct WorksView: View {                 tag: \.self,                 identifier: WorksFilterPresentation.siteRowIdentifier             ) { Text($0) }++            // `work-and-reading-status` Req 6.1's two dimensions. They iterate+            // `allCases` rather than a slice of `filterOptions`: the+            // vocabularies are closed, so every value is offered whether or not+            // a work currently carries it (Req 6.3, Q30).+            filterPicker(+                "Work status", options: WorkStatus.allCases, selection: $filter.workStatus,+                anyIdentifier: WorksFilterPresentation.anyWorkStatusRowIdentifier,+                tag: \.self,+                identifier: WorksFilterPresentation.workStatusRowIdentifier+            ) { Text(WorkStatusPresentation.name($0)) }++            filterPicker(+                "Reading status", options: ReadingStatus.allCases,+                selection: $filter.readingStatus,+                anyIdentifier: WorksFilterPresentation.anyReadingStatusRowIdentifier,+                tag: \.self,+                identifier: WorksFilterPresentation.readingStatusRowIdentifier+            ) { Text(ReadingStatusPresentation.name($0)) }         } label: {             // Req 6: filled while any filter is active. The sort alone does not             // change it — every list has a sort, so a permanently filled icon@@ -267,8 +286,8 @@ struct WorksView: View {      /// One filter dimension: "Any" — the one selection that is not a value, so     /// it cannot be drawn from the options — then every value the snapshot-    /// offers. Stated once for the three dimensions so the "Any" row and the-    /// identifiers cannot be spelled three ways.+    /// offers. Stated once for every dimension so the "Any" row and the+    /// identifiers cannot be spelled a different way per filter.     private func filterPicker<Option: Hashable, Tag: Hashable, RowLabel: View>(         _ title: String,         options: [Option],@@ -576,8 +595,53 @@ enum WorksRowPresentation {     /// rather than "from ", which is what a joined empty list would say.     static func openLabel(for work: WorkSnapshot) -> String {         let hostnames = work.memberships.map(\.hostname)-        guard !hostnames.isEmpty else { return "Open Work \(work.displayTitle)" }-        return "Open Work \(work.displayTitle) from \(hostnames.joined(separator: ", "))"+        let sited = hostnames.isEmpty+            ? "Open Work \(work.displayTitle)"+            : "Open Work \(work.displayTitle) from \(hostnames.joined(separator: ", "))"+        return sited + statusClause(for: work)+    }++    /// `work-and-reading-status` Req 5.5: what the row's glyphs are worth to a+    /// reader who cannot see them.+    ///+    /// `WorkRow` is one button, so VoiceOver never reaches a child element's+    /// own label — the row's single label is the marks' only channel, and the+    /// merge picker's row (Req 5.4) needs the same words through its own.+    ///+    /// Empty on a work at both defaults, so an unmarked row reads exactly as it+    /// did before the statuses existed.+    ///+    /// A label appears exactly where the row draws a glyph: the table's+    /// `systemImage` is the one rule for "this value is marked", so the words+    /// and the mark cannot drift apart.+    private static func statusLabels(for work: WorkSnapshot) -> [String] {+        var labels: [String] = []+        if WorkStatusPresentation.systemImage(work.workStatus) != nil {+            labels.append(WorkStatusPresentation.accessibilityLabel(work.workStatus))+        }+        if ReadingStatusPresentation.systemImage(work.readingStatus) != nil {+            labels.append(ReadingStatusPresentation.accessibilityLabel(work.readingStatus))+        }+        return labels+    }++    /// The clauses as they trail a label, or "" where there are none.+    ///+    /// Joined with ". " rather than ", " (Q32): the label already lists several+    /// hostnames comma-separated, so a comma here would read as one more site.+    /// The separator also keeps the clauses behind the " from " the UI+    /// journeys' title parser reads up to.+    static func statusClause(for work: WorkSnapshot) -> String {+        let labels = statusLabels(for: work)+        guard !labels.isEmpty else { return "" }+        return ". " + labels.joined(separator: ". ")+    }++    /// The `work-title` element's own label (Req 5.5). An abandoned row states+    /// its state in words as well as in colour and opacity, which are the two+    /// channels Req 5.2 dims it through.+    static func titleLabel(for work: WorkSnapshot) -> String {+        work.displayTitle + statusClause(for: work)     }      /// One "Not the same work" pill: the Work it names, and what to call it.@@ -635,6 +699,11 @@ struct WorkRow: View {     /// row is one line and Req 9.2's glyph is the site.     var showsAllSites: Bool = false +    /// `work-and-reading-status` Req 5.2: an abandoned work is one the reader+    /// put down, so its row steps back out of the active library rather than+    /// leaving it.+    private var isAbandoned: Bool { work.readingStatus == .abandoned }+     var body: some View {         VStack(alignment: .leading, spacing: 4) {             // Req 11.3: single-line work names truncate, never wrap.@@ -642,8 +711,12 @@ struct WorkRow: View {                 .font(AsterismTypography.serifRowTitle)                 .lineLimit(1)                 .truncationMode(.tail)-                .foregroundStyle(AsterismColors.primaryText)+                .foregroundStyle(+                    isAbandoned ? AsterismColors.secondaryText : AsterismColors.primaryText)                 .accessibilityIdentifier("work-title")+                // Req 5.5: the dimming is colour and opacity, neither of which+                // is a channel every reader has.+                .accessibilityLabel(WorksRowPresentation.titleLabel(for: work))              HStack(spacing: 6) {                 if showsAllSites {@@ -674,6 +747,22 @@ struct WorkRow: View {                         .accessibilityIdentifier("work-type-tag")                 } +                // Req 5.1's marks, after the type tag and before the Spacer.+                // Drawn in the pill's own text font so a glyph is no taller+                // than the tag beside it, whatever the Dynamic Type size.+                if let symbol = WorkStatusPresentation.systemImage(work.workStatus) {+                    statusGlyph(+                        symbol, hue: WorkStatusPresentation.hue(work.workStatus),+                        label: WorkStatusPresentation.accessibilityLabel(work.workStatus),+                        identifier: "work-status-glyph")+                }+                if let symbol = ReadingStatusPresentation.systemImage(work.readingStatus) {+                    statusGlyph(+                        symbol, hue: ReadingStatusPresentation.hue(work.readingStatus),+                        label: ReadingStatusPresentation.accessibilityLabel(work.readingStatus),+                        identifier: "reading-status-glyph")+                }+                 Spacer()                  // §7's count pill: cyan text on a cyan .12 fill.@@ -683,6 +772,22 @@ struct WorkRow: View {             }         }         .frame(minHeight: AsterismLayout.minHitTarget)+        // Req 5.2: the whole row steps back, the way an ignored teach chip does+        // — the design language's one knock-down, not a second amount.+        .opacity(isAbandoned ? ConstellationRecipes.knockdownOpacity : 1)+    }++    /// One status mark. `.caption` semibold is `constellationPill`'s own text+    /// font, so the symbol's height sits inside the padded height of the type+    /// tag beside it (Req 5.1).+    private func statusGlyph(+        _ systemImage: String, hue: Color, label: String, identifier: String+    ) -> some View {+        Image(systemName: systemImage)+            .font(.caption.weight(.semibold))+            .foregroundStyle(hue)+            .accessibilityIdentifier(identifier)+            .accessibilityLabel(label)     } } 

diff --git a/Asterism/AsterismTests/DuplicateSurfaceTests.swift b/Asterism/AsterismTests/DuplicateSurfaceTests.swiftindex e61a30d..ad38ab4 100644--- a/Asterism/AsterismTests/DuplicateSurfaceTests.swift+++ b/Asterism/AsterismTests/DuplicateSurfaceTests.swift@@ -151,6 +151,59 @@ struct DuplicateSurfaceTests {         #expect(model.workVariants.count == 2)     } +    // MARK: - The Work variant's status arms (V10 Req 7.2)++    /// Each arm is a line the sheet prints only where the set differs in that+    /// field, so both halves — the gate and the wording — are pinned here.+    ///+    /// The words name their dimension because both statuses have a value called+    /// "finished" (Q23), and a copy on `reading` still shows its verdict,+    /// because Q21 makes the sheet the one place the text Q7 hides is visible.+    @Test("The Work variant's three arms print only where the set differs, naming the dimension")+    func workVariantStatusArms() {+        let variant = Self.workVariant(+            workStatus: .hiatus, readingStatus: .reading, verdict: "put it down")++        #expect(+            DuplicateResolutionView.workStatusLine(variant, differing: [.workStatus])+                == "Work: On hiatus")+        #expect(+            DuplicateResolutionView.readingStatusLine(variant, differing: [.readingStatus])+                == "Reading: Reading")+        #expect(+            DuplicateResolutionView.verdictLine(variant, differing: [.verdict])+                == "Verdict: put it down")++        // A field the set agrees on is not a decision, so its arm prints+        // nothing — the sheet's standing rule for every other field.+        #expect(DuplicateResolutionView.workStatusLine(variant, differing: [.verdict]) == nil)+        #expect(DuplicateResolutionView.readingStatusLine(variant, differing: [.verdict]) == nil)+        #expect(DuplicateResolutionView.verdictLine(variant, differing: [.workStatus]) == nil)+        // An empty verdict has nothing to show even where the set differs in it,+        // and neither has a blank one — the fold's own test for a verdict worth+        // carrying is `M2Unicode.isBlank`, so the sheet's has to be too.+        #expect(+            DuplicateResolutionView.verdictLine(+                Self.workVariant(verdict: ""), differing: [.verdict]) == nil)+        #expect(+            DuplicateResolutionView.verdictLine(+                Self.workVariant(verdict: " \u{2028}\t"), differing: [.verdict]) == nil)+    }++    @Test("Every status value has a word in the sheet's arms")+    func workVariantStatusArmsNameEveryValue() {+        #expect(+            WorkStatus.allCases.map {+                DuplicateResolutionView.workStatusLine(+                    Self.workVariant(workStatus: $0), differing: [.workStatus])+            } == ["Work: Ongoing", "Work: Finished", "Work: On hiatus"])+        #expect(+            ReadingStatus.allCases.map {+                DuplicateResolutionView.readingStatusLine(+                    Self.workVariant(readingStatus: $0), differing: [.readingStatus])+            } == ["Reading: Reading", "Reading: Finished", "Reading: Abandoned"])+    }+     // MARK: - EntryDetailModel (Reqs 2.8, 2.10)      @Test("A torn record is read-only and its unavailability names the review")@@ -559,6 +612,7 @@ struct DuplicateSurfaceTests {                 id: VariantID(rawValue: "work-variant-\(index)"),                 displayTitle: "Serial", manualTitle: nil, genericNotes: "notes \(index)",                 workURLString: nil, genreTags: [], typeDisplay: .untyped,+                workStatus: .ongoing, readingStatus: .reading, verdict: "",                 firstCapturedAt: Date(timeIntervalSince1970: 1_800_000_000 + Double(index)))         }         return .work(@@ -566,6 +620,19 @@ struct DuplicateSurfaceTests {             variants: variants, differingFields: [.genericNotes], preselected: variants[0].id)     } +    private static func workVariant(+        workStatus: WorkStatus = .ongoing,+        readingStatus: ReadingStatus = .reading,+        verdict: String = ""+    ) -> WorkVariantChoice {+        WorkVariantChoice(+            id: VariantID(rawValue: "work-variant"),+            displayTitle: "Serial", manualTitle: nil, genericNotes: "",+            workURLString: nil, genreTags: [], typeDisplay: .untyped,+            workStatus: workStatus, readingStatus: readingStatus, verdict: verdict,+            firstCapturedAt: Date(timeIntervalSince1970: 1_800_000_000))+    }+     private static func teachingDetail(         _ entry: EntrySnapshot, _ groupState: RecordGroupState<EntryAuthoredContent>     ) -> EntryTeachingDetail {

diff --git a/Asterism/AsterismTests/Helpers/MockLibraryProvider.swift b/Asterism/AsterismTests/Helpers/MockLibraryProvider.swiftindex c7ef790..0bb21cf 100644--- a/Asterism/AsterismTests/Helpers/MockLibraryProvider.swift+++ b/Asterism/AsterismTests/Helpers/MockLibraryProvider.swift@@ -58,6 +58,11 @@ final class MockLibraryProvider: LibraryProviding, @unchecked Sendable {     var lastMoveDestination: WorkDestination?     var lastUpdateEntryBasis: EntryEditBasis?     var lastUpdateWorkBasis: WorkEditBasis?+    /// What the editor actually sent. Recorded beside the basis because+    /// `updateWork` writes every field of the draft to every row of the group+    /// (Req 7.1 of `work-and-reading-status`): a draft that quietly carried a+    /// default status would reset a reader's value with nothing to see.+    var lastUpdateWorkDraft: WorkMetadataDraft?     var lastMoveEntryBasis: EntryAssignmentBasis?      enum MockError: Error, LocalizedError {@@ -142,6 +147,7 @@ final class MockLibraryProvider: LibraryProviding, @unchecked Sendable {     ) async throws -> LibraryWriteOutcome {         updateWorkCallCount += 1         lastUpdateWorkBasis = basis+        lastUpdateWorkDraft = draft         return try updateWorkResult.get()     } 

diff --git a/Asterism/AsterismTests/Helpers/TestFixtures.swift b/Asterism/AsterismTests/Helpers/TestFixtures.swiftindex a1d0f33..061faa7 100644--- a/Asterism/AsterismTests/Helpers/TestFixtures.swift+++ b/Asterism/AsterismTests/Helpers/TestFixtures.swift@@ -174,7 +174,13 @@ enum TestFixtures {         entries: [EntrySnapshot] = [],         createdAt: Date = fixedDate,         modifiedAt: Date = fixedDate,-        groupState: RecordGroupState<WorkAuthoredContent> = .single+        groupState: RecordGroupState<WorkAuthoredContent> = .single,+        /// Defaulted like the snapshot's own three (Q40): a fixture that says+        /// nothing about status describes a work on the defaults, so every case+        /// written before V10 keeps meaning what it meant.+        workStatus: WorkStatus = .ongoing,+        readingStatus: ReadingStatus = .reading,+        verdict: String = ""     ) -> WorkSnapshot {         WorkSnapshot(             id: id,@@ -189,7 +195,10 @@ enum TestFixtures {             createdAt: createdAt,             modifiedAt: modifiedAt,             entries: entries,-            groupState: groupState+            groupState: groupState,+            workStatus: workStatus,+            readingStatus: readingStatus,+            verdict: verdict         )     } }

diff --git a/Asterism/AsterismTests/IntegrationSafetyNetTests.swift b/Asterism/AsterismTests/IntegrationSafetyNetTests.swiftindex a831bd3..845f184 100644--- a/Asterism/AsterismTests/IntegrationSafetyNetTests.swift+++ b/Asterism/AsterismTests/IntegrationSafetyNetTests.swift@@ -144,15 +144,16 @@ struct IntegrationSafetyNetTests {                 typeAssignment: .configured(                     UUID(uuidString: "0E7A0000-0000-4000-8000-0000000000A1")!),                 genreTags: ["science fiction", "serial"],-                genericNotes: "Work-level notes"+                genericNotes: "Work-level notes",+                workStatus: .ongoing, readingStatus: .reading, verdict: ""             )         )          let stagingDirectory = fixture.baseDirectory.appending(path: "validated-backups")-        let exporter = BackupV8Exporter(repository: repository, stagingDirectory: stagingDirectory)+        let exporter = BackupV9Exporter(repository: repository, stagingDirectory: stagingDirectory)         let exportedAt = Date(timeIntervalSince1970: 1_784_246_400)         let result = try await exporter.export(-            metadata: BackupV8Metadata(+            metadata: BackupV9Metadata(                 appBuild: "integration-1",                 exportedAt: exportedAt             )@@ -160,8 +161,8 @@ struct IntegrationSafetyNetTests {         defer { exporter.cleanup(result) }          let encoded = try Data(contentsOf: result.fileURL)-        let decoded = try BackupV8Codec.decode(encoded)-        let source = try await repository.backupV8Snapshot()+        let decoded = try BackupV9Codec.decode(encoded)+        let source = try await repository.backupV9Snapshot()          #expect(decoded.payload == source)         #expect(decoded.payload.entries.count == 1)@@ -234,12 +235,13 @@ struct IntegrationSafetyNetTests {                     Issue.record("Expected Backup export for \(environment) \(capabilities.gate.rawValue)")                     continue                 }-                // Settings writes 8/9 now (Req 5.1): the archive has to carry a-                // Work's site memberships, the reader's dismissed pairs and-                // version-free citations, so the round-trip is reachable from-                // the surface the reader uses. The gate the file declares is-                // still the running one.-                let document = try BackupV8Codec.decode(Data(contentsOf: backupURL))+                // Settings writes 9/10 now (Req 8.1): the archive has to carry+                // a Work's site memberships, the reader's dismissed pairs,+                // version-free citations and the Work's two statuses and+                // verdict, so the round-trip is reachable from the surface the+                // reader uses. The gate the file declares is still the running+                // one.+                let document = try BackupV9Codec.decode(Data(contentsOf: backupURL))                 #expect(document.capabilityGate == AsterismCapabilities.current.gate.rawValue)                 backup.handleShareCancellation()             }@@ -324,9 +326,9 @@ struct IntegrationSafetyNetTests {         try await sourceRepo.moveEntry(entry.id, to: .existing(work.id))          let stagingDir = fixture.baseDirectory.appending(path: "export-stage")-        let exporter = BackupV8Exporter(repository: sourceRepo, stagingDirectory: stagingDir)+        let exporter = BackupV9Exporter(repository: sourceRepo, stagingDirectory: stagingDir)         let exportResult = try await exporter.export(-            metadata: BackupV8Metadata(appBuild: "fill-test", exportedAt: Date())+            metadata: BackupV9Metadata(appBuild: "fill-test", exportedAt: Date())         )         defer { exporter.cleanup(exportResult) }         let backupData = try Data(contentsOf: exportResult.fileURL)@@ -389,9 +391,9 @@ struct IntegrationSafetyNetTests {             )         )         let stagingDir = fixture.baseDirectory.appending(path: "restore-stage")-        let exporter = BackupV8Exporter(repository: sourceRepo, stagingDirectory: stagingDir)+        let exporter = BackupV9Exporter(repository: sourceRepo, stagingDirectory: stagingDir)         let exportResult = try await exporter.export(-            metadata: BackupV8Metadata(appBuild: "restore-test", exportedAt: Date())+            metadata: BackupV9Metadata(appBuild: "restore-test", exportedAt: Date())         )         defer { exporter.cleanup(exportResult) }         let plan = try BackupImporter.plan(from: try Data(contentsOf: exportResult.fileURL))@@ -684,7 +686,8 @@ struct IntegrationSafetyNetTests {                 displayTitle: "Source Work Manual",                 typeAssignment: .none,                 genreTags: ["tag-a"],-                genericNotes: "Source notes to audit"+                genericNotes: "Source notes to audit",+                workStatus: .ongoing, readingStatus: .reading, verdict: ""             )         ) @@ -896,15 +899,15 @@ struct IntegrationSafetyNetTests {         )          let stagingDir = fixture.baseDirectory.appending(path: "corrupt-stage")-        let exporter = BackupV8Exporter(repository: repo, stagingDirectory: stagingDir)+        let exporter = BackupV9Exporter(repository: repo, stagingDirectory: stagingDir)         let exportResult = try await exporter.export(-            metadata: BackupV8Metadata(appBuild: "corrupt-test", exportedAt: Date())+            metadata: BackupV9Metadata(appBuild: "corrupt-test", exportedAt: Date())         )         defer { exporter.cleanup(exportResult) }          // Verify good backup decodes         let goodData = try Data(contentsOf: exportResult.fileURL)-        let decoded = try BackupV8Codec.decode(goodData)+        let decoded = try BackupV9Codec.decode(goodData)         #expect(decoded.payload.entries.count == 1)          // Corrupt the data by flipping bytes in the payload area@@ -917,7 +920,7 @@ struct IntegrationSafetyNetTests {          // Corrupted backup should fail decode/checksum         do {-            _ = try BackupV8Codec.decode(corruptData)+            _ = try BackupV9Codec.decode(corruptData)             Issue.record("Expected corrupted backup to fail validation")         } catch {             // Expected: checksum or decode failure@@ -1004,13 +1007,13 @@ struct IntegrationSafetyNetTests {          // Export the archive         let stagingDir = fixture.baseDirectory.appending(path: "url-backup-stage")-        let exporter = BackupV8Exporter(repository: repo, stagingDirectory: stagingDir)+        let exporter = BackupV9Exporter(repository: repo, stagingDirectory: stagingDir)         let exportResult = try await exporter.export(-            metadata: BackupV8Metadata(appBuild: "url-backup-test", exportedAt: Date())+            metadata: BackupV9Metadata(appBuild: "url-backup-test", exportedAt: Date())         )         defer { exporter.cleanup(exportResult) }         let backupData = try Data(contentsOf: exportResult.fileURL)-        let decoded = try BackupV8Codec.decode(backupData)+        let decoded = try BackupV9Codec.decode(backupData)          // Site should be present in the payload.         let site = decoded.payload.sites.first { $0.hostname == "backupurl.test" }

diff --git a/Asterism/AsterismTests/SettingsBackupModelTests.swift b/Asterism/AsterismTests/SettingsBackupModelTests.swiftindex 578a0f4..4be4da1 100644--- a/Asterism/AsterismTests/SettingsBackupModelTests.swift+++ b/Asterism/AsterismTests/SettingsBackupModelTests.swift@@ -213,7 +213,7 @@ struct SettingsBackupModelTests {     @MainActor func tornGroupsMessageStatesTheCount() async {         let mock = MockBackupExporting()         mock.exportResult = .failure(-            BackupV8ExportError.tornGroups(+            BackupV9ExportError.tornGroups(                 TornGroupsPayload(count: 3, blockingWorkSet: nil)))          let model = SettingsBackupModel(exporter: mock)@@ -234,7 +234,7 @@ struct SettingsBackupModelTests {     @MainActor func tornGroupsMessageReadsSingular() async {         let mock = MockBackupExporting()         mock.exportResult = .failure(-            BackupV8ExportError.tornGroups(+            BackupV9ExportError.tornGroups(                 TornGroupsPayload(count: 1, blockingWorkSet: nil)))          let model = SettingsBackupModel(exporter: mock)@@ -252,7 +252,7 @@ struct SettingsBackupModelTests {     @MainActor func tornGroupsMessagePointsAtTheBlockingWorkSet() async {         let mock = MockBackupExporting()         mock.exportResult = .failure(-            BackupV8ExportError.tornGroups(+            BackupV9ExportError.tornGroups(                 TornGroupsPayload(                     count: 1,                     blockingWorkSet: DuplicateSetKey(@@ -288,7 +288,7 @@ struct SettingsBackupModelTests {          let mock = MockBackupExporting()         mock.exportResult = .failure(-            BackupV8ExportError.tornGroups(+            BackupV9ExportError.tornGroups(                 TornGroupsPayload(count: 1, blockingWorkSet: nil)))         let model = SettingsBackupModel(exporter: mock)         await model.startExport()@@ -302,19 +302,19 @@ struct SettingsBackupModelTests {         #expect(!model.routesToCheckLibrary)     } -    // MARK: - Archive generation 8/9 (rule-citation-by-uuid Req 5.1)+    // MARK: - Archive generation 9/10 (work-and-reading-status Req 8.1)      /// The Settings surface is the only place the app *writes* an archive, so a-    /// repository that reaches 8/9 while this seam still asks for 7/8 leaves the+    /// repository that reaches 9/10 while this seam still asks for 8/9 leaves the     /// round-trip `multi-site-works` Req 9.2 promises unreachable. The metadata     /// type is the tell: the exporter this model holds is the one whose payload-    /// carries version-free citations.-    @Test("The export surface asks the 8/9 exporter for the archive")-    @MainActor func exportsArchiveGenerationEightNine() async {+    /// carries a Work's statuses and verdict.+    @Test("The export surface asks the 9/10 exporter for the archive")+    @MainActor func exportsArchiveGenerationNineTen() async {         let tempDir = FileManager.default.temporaryDirectory.appending(path: UUID().uuidString)         try? FileManager.default.createDirectory(at: tempDir, withIntermediateDirectories: true)         defer { try? FileManager.default.removeItem(at: tempDir) }-        let fakeURL = tempDir.appending(path: "Asterism-backup-89.json")+        let fakeURL = tempDir.appending(path: "Asterism-backup-910.json")         try? Data("{}".utf8).write(to: fakeURL)          let mock = MockBackupExporting()@@ -323,7 +323,7 @@ struct SettingsBackupModelTests {         let model = SettingsBackupModel(exporter: mock)         await model.startExport() -        let metadata: BackupV8Metadata? = mock.lastMetadata+        let metadata: BackupV9Metadata? = mock.lastMetadata         #expect(metadata != nil)         #expect(metadata?.appBuild.isEmpty == false)     }@@ -331,14 +331,14 @@ struct SettingsBackupModelTests {     /// Req 6.5, through Q105: a torn **character** group refuses the export the     /// same way a torn Work or Entry does, and the reader is sent to the same     /// place. The payload carries a count, not a record kind, so what this pins-    /// is that the 8/9 refusal reaches a message arm at all — an unhandled case+    /// is that the 9/10 refusal reaches a message arm at all — an unhandled case     /// would fall through to the generic "please try again", which is the dead     /// end Decision 20 already removed once.-    @Test("An 8/9 torn refusal routes the reader to Check Library")-    @MainActor func eightNineTornRefusalRoutes() async {+    @Test("A 9/10 torn refusal routes the reader to Check Library")+    @MainActor func nineTenTornRefusalRoutes() async {         let mock = MockBackupExporting()         mock.exportResult = .failure(-            BackupV8ExportError.tornGroups(+            BackupV9ExportError.tornGroups(                 TornGroupsPayload(count: 2, blockingWorkSet: nil)))          let model = SettingsBackupModel(exporter: mock)@@ -351,18 +351,18 @@ struct SettingsBackupModelTests {         #expect(model.routesToCheckLibrary)     } -    /// Every case of the 8/9 refusal has a message of its own. A case that fell+    /// Every case of the 9/10 refusal has a message of its own. A case that fell     /// through to the default arm would be indistinguishable from an error the     /// app has never heard of.-    @Test("Every 8/9 export refusal has its own message", arguments: [-        BackupV8ExportError.referencesStillArriving(detail: "rule 1"),-        BackupV8ExportError.unrepresentableValue(+    @Test("Every 9/10 export refusal has its own message", arguments: [+        BackupV9ExportError.referencesStillArriving(detail: "rule 1"),+        BackupV9ExportError.unrepresentableValue(             record: "Character", field: "factsData", value: "…"),-        BackupV8ExportError.snapshotFailed(reason: "read"),-        BackupV8ExportError.encodingFailed(reason: "encode"),-        BackupV8ExportError.stagingFailed(reason: "stage"),+        BackupV9ExportError.snapshotFailed(reason: "read"),+        BackupV9ExportError.encodingFailed(reason: "encode"),+        BackupV9ExportError.stagingFailed(reason: "stage"),     ])-    @MainActor func everyEightNineRefusalHasAMessage(error: BackupV8ExportError) async {+    @MainActor func everyNineTenRefusalHasAMessage(error: BackupV9ExportError) async {         let mock = MockBackupExporting()         mock.exportResult = .failure(error) @@ -397,12 +397,12 @@ final class MockBackupExporting: BackupExporting, @unchecked Sendable {     var cleanupCallCount = 0     var scavengeCallCount = 0     var lastCleanupURL: URL?-    var lastMetadata: BackupV8Metadata?+    var lastMetadata: BackupV9Metadata?      var exportResult: Result<BackupExportResult, Error> = .failure(MockBackupError.notConfigured)     var exportDelay: Duration? -    func export(metadata: BackupV8Metadata) async throws -> BackupExportResult {+    func export(metadata: BackupV9Metadata) async throws -> BackupExportResult {         exportCallCount += 1         lastMetadata = metadata         if let delay = exportDelay {

diff --git a/Asterism/AsterismTests/SettingsImportTests.swift b/Asterism/AsterismTests/SettingsImportTests.swiftindex 729e579..f2f3095 100644--- a/Asterism/AsterismTests/SettingsImportTests.swift+++ b/Asterism/AsterismTests/SettingsImportTests.swift@@ -62,14 +62,14 @@ enum MockSetupError: Error, LocalizedError { @Suite("SettingsBackupImportModel") struct SettingsBackupImportModelTests { -    /// A real 8/9 document, because the model plans the bytes it is handed —+    /// A real 9/10 document, because the model plans the bytes it is handed —     /// stubbing the planner would leave the preview untested.     static let minimalBackupData: Data = {         let hostname = "settings-import.example"         let rawURL = "https://\(hostname)/read?chapter=1"-        let payload = BackupV8Payload(+        let payload = BackupV9Payload(             entries: [-                BackupV8Entry(+                BackupV9Entry(                     id: UUID(), captureTitle: "Chapter 1", captureTitleSource: .host,                     rawURL: rawURL, canonicalURL: nil, hostname: hostname,                     entryIdentityKey: rawURL,@@ -84,14 +84,14 @@ struct SettingsBackupImportModelTests {             ],             works: [],             sites: [-                BackupV8Site(+                BackupV9Site(                     hostname: hostname, displayName: hostname, mode: .untaught,                     junkSuffixRule: nil)             ],             titlePatterns: [], urlRules: [], workTypes: [])-        return try! BackupV8Codec.encode(+        return try! BackupV9Codec.encode(             payload: payload,-            metadata: BackupV8Metadata(+            metadata: BackupV9Metadata(                 appBuild: "test", exportedAt: Date(timeIntervalSince1970: 1_800_000_000)))     }() 

diff --git a/Asterism/AsterismTests/WorkDetailModelTests.swift b/Asterism/AsterismTests/WorkDetailModelTests.swiftindex 67eb628..5c9b0cc 100644--- a/Asterism/AsterismTests/WorkDetailModelTests.swift+++ b/Asterism/AsterismTests/WorkDetailModelTests.swift@@ -894,6 +894,407 @@ struct WorkDetailModelTests {         #expect(model.chapterRows(for: .newest).map(\.id) == rows.map(\.id))         #expect(model.chapterRows(for: .newest).map(\.id) == model.chapterRows.map(\.id))     }++    // MARK: - The two statuses, the verdict, and the finished-reading rule+    //         (`work-and-reading-status` Reqs 1.2, 2.2–2.5, 3.1–3.5, 7.1)++    /// Req 3.1 and Decision 1: `finished` reading means the reader read the whole+    /// work, so choosing it on a work that is not itself finished asks rather+    /// than writes. The capsule keeps showing the previous value while the+    /// dialog is up — the draft is deliberately not moved.+    @MainActor @Test(+        "Choosing finished reading on an unfinished work raises the prompt and moves nothing",+        arguments: [WorkStatus.ongoing, .hiatus], [ReadingStatus.reading, .abandoned])+    func finishedReadingOnAnUnfinishedWorkPrompts(+        work workStatus: WorkStatus, reading readingStatus: ReadingStatus+    ) async {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: workStatus, readingStatus: readingStatus))+        await model.load()+        model.beginEditing()++        model.setDraftReadingStatus(.finished)++        #expect(model.finishedReadingPrompt?.thenCommits == false)+        #expect(model.draftReadingStatus == readingStatus)+        #expect(model.draftWorkStatus == workStatus)+        #expect(mock.updateWorkCallCount == 0)+    }++    /// Req 3.5: a stored pair that violates the rule is shown as stored. Tapping+    /// the segment it is already on is not a change, so it must not ask.+    @MainActor @Test("Re-selecting the reading status a stored violating pair already has is a no-op")+    func reSelectingTheStoredFinishedReadingDoesNotPrompt() async {+        let (model, _, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .ongoing, readingStatus: .finished))+        await model.load()+        model.beginEditing()++        model.setDraftReadingStatus(.finished)++        #expect(model.finishedReadingPrompt == nil)+        #expect(model.draftReadingStatus == .finished)+    }++    /// Req 3.3 and Q7: a work that stops being finished cannot leave a finished+    /// reading behind it, and the reader is not punished for the mis-tap with a+    /// dialog. Req 2.5: the verdict text survives the revert — it is only hidden.+    @MainActor @Test("Leaving a finished work reverts finished reading and keeps the verdict")+    func leavingAFinishedWorkRevertsTheReading() async {+        let (model, _, _) = makeSUT(+            work: TestFixtures.makeWork(+                workStatus: .finished, readingStatus: .finished, verdict: "worth the wait"))+        await model.load()+        model.beginEditing()++        model.setDraftWorkStatus(.hiatus)++        #expect(model.draftReadingStatus == .reading)+        #expect(model.draftVerdict == "worth the wait")+        #expect(model.finishedReadingPrompt == nil)+        #expect(model.autoRevertedReading)+    }++    /// Q39: the mis-tap Q7 protects is undone in full. Putting the work back on+    /// `finished` in the same session restores the reading status the revert+    /// took, rather than costing the reader a second selection.+    @MainActor @Test("A work put back on finished restores the reading status the revert took")+    func returningToFinishedRestoresTheAutoRevertedReading() async {+        let (model, _, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .finished, readingStatus: .finished))+        await model.load()+        model.beginEditing()+        model.setDraftWorkStatus(.ongoing)+        #expect(model.draftReadingStatus == .reading)++        model.setDraftWorkStatus(.finished)++        #expect(model.draftReadingStatus == .finished)+        #expect(!model.autoRevertedReading)+        #expect(model.finishedReadingPrompt == nil)+    }++    /// Q39's other half: any other reading change clears the flag, so the+    /// restore never overwrites a value the reader chose after the revert.+    @MainActor @Test("A reading status chosen after the revert is not overwritten by the restore")+    func aChosenReadingStatusSurvivesTheReturnToFinished() async {+        let (model, _, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .finished, readingStatus: .finished))+        await model.load()+        model.beginEditing()+        model.setDraftWorkStatus(.ongoing)+        model.setDraftReadingStatus(.abandoned)++        model.setDraftWorkStatus(.finished)++        #expect(model.draftReadingStatus == .abandoned)+    }++    /// Req 3.5 and Q20: the commit-time check is gated on the draft pair+    /// differing from the stored one, so committing a stored violating pair+    /// unchanged writes it back rather than interrogating the reader about a+    /// state they did not create.+    @MainActor @Test("Committing a stored violating pair unchanged writes it back without a prompt")+    func committingAStoredViolatingPairWritesItBack() async {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .ongoing, readingStatus: .finished))+        await model.load()+        model.beginEditing()+        model.draftNotes = "a note, and nothing about either status"++        await model.commitEditing()++        #expect(model.finishedReadingPrompt == nil)+        #expect(mock.updateWorkCallCount == 1)+        #expect(mock.lastUpdateWorkDraft?.workStatus == .ongoing)+        #expect(mock.lastUpdateWorkDraft?.readingStatus == .finished)+        #expect(!model.isEditing)+    }++    /// Req 3.4: the same pair, but the reader moved the *work* side — Q20's case,+    /// which no picker transition catches. The check runs first in+    /// `commitEditing()`, so nothing is written and no other step has run.+    @MainActor @Test("Editing the work side of a violating pair raises the prompt at commit")+    func commitPromptsWhenTheDraftPairDiffers() async {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .ongoing, readingStatus: .finished))+        await model.load()+        model.beginEditing()+        model.setDraftWorkStatus(.hiatus)++        await model.commitEditing()++        #expect(model.finishedReadingPrompt?.thenCommits == true)+        #expect(mock.updateWorkCallCount == 0)+        #expect(model.isEditing)+    }++    /// Req 3.4's first action: apply the change, then commit.+    @MainActor @Test("Marking the work finished at the commit prompt applies both and saves")+    func commitPromptMarkWorkFinishedFollowsThrough() async throws {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .ongoing, readingStatus: .finished))+        await model.load()+        model.beginEditing()+        model.setDraftWorkStatus(.hiatus)+        await model.commitEditing()+        let prompt = try #require(model.finishedReadingPrompt)++        await model.resolveFinishedReadingPrompt(prompt, choosing: .markWorkFinished)++        #expect(model.finishedReadingPrompt == nil)+        #expect(mock.updateWorkCallCount == 1)+        // What was *sent*, not what the drafts hold afterwards: a committed save+        // reloads the screen, and the drafts are then the store's again.+        #expect(mock.lastUpdateWorkDraft?.workStatus == .finished)+        #expect(mock.lastUpdateWorkDraft?.readingStatus == .finished)+        #expect(!model.isEditing)+    }++    /// Req 3.4's second action: `abandoned` leaves the work status alone.+    @MainActor @Test("Abandoned instead at the commit prompt records abandoned and saves")+    func commitPromptAbandonInsteadFollowsThrough() async throws {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .ongoing, readingStatus: .finished))+        await model.load()+        model.beginEditing()+        model.setDraftWorkStatus(.hiatus)+        await model.commitEditing()+        let prompt = try #require(model.finishedReadingPrompt)++        await model.resolveFinishedReadingPrompt(prompt, choosing: .abandonInstead)++        #expect(mock.updateWorkCallCount == 1)+        // The work status is left alone; only the reading side moves.+        #expect(mock.lastUpdateWorkDraft?.workStatus == .hiatus)+        #expect(mock.lastUpdateWorkDraft?.readingStatus == .abandoned)+        #expect(!model.isEditing)+    }++    /// Req 3.4's third: cancel returns to edit mode with nothing written. The+    /// drafts were never moved by the prompt, so there is nothing to restore —+    /// which is why the check runs ahead of the URL step.+    ///+    /// Driven through `cancelFinishedReadingPrompt()` because that is the only+    /// way the dialog cancels: both its Cancel button and its dismissal call it,+    /// and the resolution enum has no `.cancel` case to reach.+    @MainActor @Test("Cancelling the prompt leaves the drafts as they were and writes nothing")+    func cancellingThePromptWritesNothing() async throws {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .ongoing, readingStatus: .finished))+        await model.load()+        model.beginEditing()+        model.setDraftWorkStatus(.hiatus)+        model.draftVerdict = "not yet decided"+        await model.commitEditing()+        _ = try #require(model.finishedReadingPrompt)++        model.cancelFinishedReadingPrompt()++        #expect(model.finishedReadingPrompt == nil)+        #expect(model.draftWorkStatus == .hiatus)+        #expect(model.draftReadingStatus == .finished)+        #expect(model.draftVerdict == "not yet decided")+        #expect(mock.updateWorkCallCount == 0)+        #expect(model.isEditing)+    }++    /// Req 3.2's first action on the *picker* arm: the same two answers, but the+    /// prompt was raised by the capsule rather than the checkmark, so the drafts+    /// move and the reader stays in the editor with nothing saved.+    @MainActor @Test("Marking the work finished at the picker prompt moves both drafts without saving")+    func pickerPromptMarkWorkFinishedMovesTheDrafts() async throws {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .ongoing, readingStatus: .reading))+        await model.load()+        model.beginEditing()+        model.draftVerdict = "a keeper"+        model.setDraftReadingStatus(.finished)+        let prompt = try #require(model.finishedReadingPrompt)+        #expect(prompt.thenCommits == false)++        await model.resolveFinishedReadingPrompt(prompt, choosing: .markWorkFinished)++        #expect(model.finishedReadingPrompt == nil)+        #expect(model.draftWorkStatus == .finished)+        #expect(model.draftReadingStatus == .finished)+        // The verdict the reader had already typed is theirs to keep.+        #expect(model.draftVerdict == "a keeper")+        #expect(mock.updateWorkCallCount == 0)+        #expect(model.isEditing)+    }++    /// Req 3.2's second: `abandoned` leaves the work status where it was, and+    /// still writes nothing — the checkmark is the reader's next step.+    @MainActor @Test("Abandoned instead at the picker prompt records abandoned without saving")+    func pickerPromptAbandonInsteadMovesOnlyTheReading() async throws {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .ongoing, readingStatus: .reading))+        await model.load()+        model.beginEditing()+        model.setDraftReadingStatus(.finished)+        let prompt = try #require(model.finishedReadingPrompt)++        await model.resolveFinishedReadingPrompt(prompt, choosing: .abandonInstead)++        #expect(model.finishedReadingPrompt == nil)+        #expect(model.draftReadingStatus == .abandoned)+        #expect(model.draftWorkStatus == .ongoing)+        #expect(mock.updateWorkCallCount == 0)+        #expect(model.isEditing)+    }++    /// The follow-through is an ordinary commit, so it meets the ordinary URL+    /// refusal: the editor stays open with the reader's choice visible in the+    /// capsules rather than silently dropped, and nothing is written.+    @MainActor @Test("A URL refused on the follow-through keeps the resolved statuses in the drafts")+    func aURLRefusalOnTheFollowThroughKeepsTheResolvedDrafts() async throws {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .ongoing, readingStatus: .finished))+        await model.load()+        model.beginEditing()+        model.setDraftWorkStatus(.hiatus)+        model.draftWorkURL = "ftp://example.com/work"+        await model.commitEditing()+        let prompt = try #require(model.finishedReadingPrompt)++        await model.resolveFinishedReadingPrompt(prompt, choosing: .markWorkFinished)++        #expect(model.draftWorkStatus == .finished)+        #expect(model.draftReadingStatus == .finished)+        #expect(model.workURLStatusMessage != nil)+        #expect(mock.updateWorkCallCount == 0)+        #expect(model.isEditing)+    }++    /// Req 1.2 and 2.2: a status is a metadata change like any other, so the+    /// checkmark appears for it.+    @MainActor @Test("A status-only change is an unsaved change")+    func aStatusOnlyChangeIsDirty() async {+        let (model, _, _) = makeSUT()+        await model.load()+        model.beginEditing()+        #expect(!model.hasUnsavedChanges)++        model.setDraftWorkStatus(.hiatus)++        #expect(model.hasUnsavedChanges)+    }++    /// Req 2.3: so is the verdict on its own.+    @MainActor @Test("A verdict-only change is an unsaved change")+    func aVerdictOnlyChangeIsDirty() async {+        let (model, _, _) = makeSUT(+            work: TestFixtures.makeWork(readingStatus: .abandoned))+        await model.load()+        model.beginEditing()+        #expect(!model.hasUnsavedChanges)++        model.draftVerdict = "lost the thread around chapter 40"++        #expect(model.hasUnsavedChanges)+    }++    /// Req 2.5: a verdict typed and then hidden by a status change is still a+    /// change, and still the reader's text. Dropping it because the field went+    /// away would lose typing to a tap on an unrelated control.+    @MainActor @Test("A verdict typed and then hidden by a status change is kept and still dirty")+    func aHiddenVerdictIsKeptAndStillDirty() async {+        let (model, _, _) = makeSUT(+            work: TestFixtures.makeWork(workStatus: .finished, readingStatus: .finished))+        await model.load()+        model.beginEditing()+        model.draftVerdict = "a great ending"++        model.setDraftWorkStatus(.ongoing)++        #expect(model.draftReadingStatus == .reading)+        #expect(model.draftVerdict == "a great ending")+        #expect(model.hasUnsavedChanges)+    }++    /// The X is a discard: all three go back to what the screen loaded.+    @MainActor @Test("Cancelling the editor restores both statuses and the verdict")+    func cancellingTheEditorRestoresTheStatuses() async {+        let (model, _, _) = makeSUT(+            work: TestFixtures.makeWork(+                workStatus: .hiatus, readingStatus: .abandoned, verdict: "stalled"))+        await model.load()+        model.beginEditing()+        model.setDraftWorkStatus(.ongoing)+        model.setDraftReadingStatus(.reading)+        model.draftVerdict = "typed and abandoned"++        model.cancelEditing()++        #expect(model.draftWorkStatus == .hiatus)+        #expect(model.draftReadingStatus == .abandoned)+        #expect(model.draftVerdict == "stalled")+        #expect(!model.hasUnsavedChanges)+    }++    /// Req 7.1 and Q40: the draft carries what the capsules show, not what the+    /// screen loaded — a draft holding the loaded values would write a reader's+    /// change away. The basis carries the loaded values, which is what makes a+    /// post-collapse redirect refuse (Req 7.4).+    @MainActor @Test("Save sends the drafted statuses and verdict, over the loaded basis")+    func saveSendsTheDraftedStatuses() async {+        let (model, mock, _) = makeSUT(+            work: TestFixtures.makeWork(+                workStatus: .finished, readingStatus: .reading, verdict: ""))+        await model.load()+        model.beginEditing()+        model.setDraftWorkStatus(.hiatus)+        model.setDraftReadingStatus(.abandoned)+        model.draftVerdict = "gave up at the timeskip"++        await model.commitEditing()++        #expect(mock.lastUpdateWorkDraft?.workStatus == .hiatus)+        #expect(mock.lastUpdateWorkDraft?.readingStatus == .abandoned)+        #expect(mock.lastUpdateWorkDraft?.verdict == "gave up at the timeskip")+        #expect(mock.lastUpdateWorkBasis?.workStatus == .finished)+        #expect(mock.lastUpdateWorkBasis?.readingStatus == .reading)+        #expect(mock.lastUpdateWorkBasis?.verdict == "")+    }++    /// Q47: with no snapshot to build a basis from, the fallback states all+    /// three from the drafts. A fallback quietly taking the parameter defaults+    /// would send `ongoing`/`reading`/`""` and refuse every write on a marked+    /// work.+    @MainActor @Test("The nil-snapshot fallback basis states the drafted statuses")+    func theFallbackBasisStatesTheStatuses() async {+        let (model, mock, _) = makeSUT()+        mock.workDetailResult = .failure(+            MockLibraryProvider.MockError.simulatedFailure("no detail"))+        await model.load()+        #expect(model.work == nil)+        model.setDraftWorkStatus(.finished)+        model.setDraftReadingStatus(.finished)+        model.draftVerdict = "read it twice"++        await model.save()++        #expect(mock.lastUpdateWorkBasis?.workStatus == .finished)+        #expect(mock.lastUpdateWorkBasis?.readingStatus == .finished)+        #expect(mock.lastUpdateWorkBasis?.verdict == "read it twice")+        #expect(mock.lastUpdateWorkDraft?.workStatus == .finished)+        #expect(mock.lastUpdateWorkDraft?.readingStatus == .finished)+        #expect(mock.lastUpdateWorkDraft?.verdict == "read it twice")+    }++    /// The two prompts say different things: one is a choice about a control,+    /// the other is a choice about a save that has not happened.+    @MainActor @Test("The prompt's message names the rule and says whether anything is saved")+    func thePromptMessageReadsForBothArms() {+        let atThePicker = FinishedReadingPrompt(id: UUID(), thenCommits: false)+        let atTheCommit = FinishedReadingPrompt(id: UUID(), thenCommits: true)++        #expect(atThePicker.message.contains("not marked finished"))+        #expect(atTheCommit.message.contains("not marked finished"))+        #expect(atTheCommit.message.contains("Nothing has been saved"))+        #expect(atThePicker.message != atTheCommit.message)+    } }  /// The work detail screen on a Work that is on more than one site

diff --git a/Asterism/AsterismTests/WorkMergeModelTests.swift b/Asterism/AsterismTests/WorkMergeModelTests.swiftindex e4e5301..9d04c5f 100644--- a/Asterism/AsterismTests/WorkMergeModelTests.swift+++ b/Asterism/AsterismTests/WorkMergeModelTests.swift@@ -81,6 +81,64 @@ struct WorkMergeModelTests {         #expect(model.outcome?.discardedFields.contains(.sourceWorkURL) == true)     } +    // MARK: - What the discarded list says (V10 Req 7.3)++    /// The preview used to caption every discarded field "Recorded in merged+    /// notes", which was only ever true of the title, the URL and the notes.+    /// With two statuses that are dropped outright it became a false statement,+    /// so the caption reads the field's own answer (Q13).+    @Test("A discarded field is captioned by whether the merged notes record it")+    func discardedCaptionsFollowTheField() {+        #expect(+            WorkMergeView.discardedCaption(.sourceVerdict) == "Recorded in merged notes")+        #expect(WorkMergeView.discardedCaption(.sourceNotes) == "Recorded in merged notes")+        #expect(WorkMergeView.discardedCaption(.sourceManualTitle) == "Recorded in merged notes")+        #expect(WorkMergeView.discardedCaption(.sourceWorkURL) == "Recorded in merged notes")+        #expect(WorkMergeView.discardedCaption(.sourceWorkStatus) == "Not carried over")+        #expect(WorkMergeView.discardedCaption(.sourceReadingStatus) == "Not carried over")+        // `.sourceGenreTags` is not pinned here: the fold only ever *retains*+        // it (`WorkVariantUnion.fold`), so no caption of it is ever shown and+        // "not carried over" would be the wrong words for tags that are.+    }++    /// Req 7.3's other two sentences. The disclosure label and the discarded+    /// row's spoken line are the only places the preview *promises* what the+    /// merged notes will hold, so the words are pinned rather than left to a+    /// screen nobody reads back.+    @Test("The audit disclosure and the discarded row say what Req 7.3 promises")+    func auditAndDiscardedRowWording() {+        #expect(+            WorkMergeView.auditBlockLabel+                == "Audit block: the discarded values marked recorded in merged notes are added to the target's notes"+        )+        #expect(+            WorkMergeView.discardedRowLabel(.sourceVerdict)+                == "Discarded: Source verdict, recorded in merged notes")+        #expect(+            WorkMergeView.discardedRowLabel(.sourceNotes)+                == "Discarded: Source notes, recorded in merged notes")+        // The half the label exists to keep honest: a dropped status is listed+        // beside the recorded ones and says so.+        #expect(+            WorkMergeView.discardedRowLabel(.sourceWorkStatus)+                == "Discarded: Source work status, not carried over")+        #expect(+            WorkMergeView.discardedRowLabel(.sourceReadingStatus)+                == "Discarded: Source reading status, not carried over")+    }++    @Test("The six status and verdict fields have labels of their own")+    func statusFieldLabels() {+        #expect(WorkMergeView.fieldLabel(.targetWorkStatus) == "Target work status")+        #expect(WorkMergeView.fieldLabel(.targetReadingStatus) == "Target reading status")+        #expect(WorkMergeView.fieldLabel(.targetVerdict) == "Target verdict")+        #expect(WorkMergeView.fieldLabel(.sourceWorkStatus) == "Source work status")+        #expect(WorkMergeView.fieldLabel(.sourceReadingStatus) == "Source reading status")+        #expect(WorkMergeView.fieldLabel(.sourceVerdict) == "Source verdict")+        // No field goes unlabelled: the preview lists whatever the fold names.+        #expect(WorkMergeField.allCases.allSatisfy { !WorkMergeView.fieldLabel($0).isEmpty })+    }+     // MARK: - Audit disclosure      @Test("Outcome exposes exact audit block for preview before confirmation")@@ -479,6 +537,41 @@ struct MergeDestinationPickerTests {         #expect(refused.contains("Needs attention."))     } +    /// `work-and-reading-status` Req 5.4, Q22: the picker draws the same glyphs+    /// the library row does, and its rows are buttons too — so the same trailing+    /// clauses have to reach the reader who cannot see them. A destination that+    /// was abandoned is worth knowing before merging into it.+    @Test("A candidate's label trails the status clauses the row's glyphs draw")+    @MainActor func theCandidateLabelTrailsTheStatusClauses() {+        let work = TestFixtures.makeWork(+            displayTitle: "Zephyr", hostname: "a.example",+            entries: [TestFixtures.makeEntry(hostname: "a.example")],+            workStatus: .hiatus, readingStatus: .abandoned)++        #expect(+            WorkMergeView.destinationLabel(work, unavailable: nil)+                == "Merge into Zephyr, on a.example, 1 note. Work: On hiatus. Reading: Abandoned")++        // The refusal is a capitalised sentence of its own, so it follows the+        // last clause behind a full stop rather than a comma splice.+        #expect(+            WorkMergeView.destinationLabel(+                work,+                unavailable:+                    "a.example needs attention in Check Library before this Work can be merged into."+            )+                == "Merge into Zephyr, on a.example, 1 note. Work: On hiatus. Reading: Abandoned. "+                + "a.example needs attention in Check Library before this Work can be merged into.")++        // A work on both defaults reads exactly as it did before V10.+        let plain = TestFixtures.makeWork(+            displayTitle: "Zephyr", hostname: "a.example",+            entries: [TestFixtures.makeEntry(hostname: "a.example")])+        #expect(+            WorkMergeView.destinationLabel(plain, unavailable: nil)+                == "Merge into Zephyr, on a.example, 1 note")+    }+     /// Req 4.1 asks the picker for the membership **hostnames**, not only their     /// colours. The row is `WorkRow(showsAllSites: true)`, which draws a     /// `SiteLabel` — glyph *and* hostname text — per membership, each addressed

diff --git a/Asterism/AsterismTests/WorkStatusPresentationTests.swift b/Asterism/AsterismTests/WorkStatusPresentationTests.swiftnew file mode 100644index 0000000..be38c16--- /dev/null+++ b/Asterism/AsterismTests/WorkStatusPresentationTests.swift@@ -0,0 +1,125 @@+import AsterismCore+import ConstellationKit+import Foundation+import Testing++@testable import Asterism++/// The one table the row label, the filter pills, the meta line and the merge+/// picker all read (Q36). Pinned here because four surfaces spelling a status+/// four ways is exactly what the table exists to prevent, and because the UI+/// journeys address these strings by name.+@Suite("Work and reading status presentation")+struct WorkStatusPresentationTests {++    // MARK: - Names (Req 1.1, 2.1)++    @Test("Every work status has a name, and every reading status has one")+    func namesCoverEveryCase() {+        #expect(+            WorkStatus.allCases.map(WorkStatusPresentation.name)+                == ["Ongoing", "Finished", "On hiatus"])+        #expect(+            ReadingStatus.allCases.map(ReadingStatusPresentation.name)+                == ["Reading", "Finished", "Abandoned"])+    }++    // MARK: - Glyphs (Reqs 4.3, 5.1, 5.2, Q27)++    /// The four symbols of Q27, and the two values that draw nothing: a work+    /// still running and a reader still reading are the defaults, and a glyph+    /// on every row would say nothing.+    @Test("Only the non-default values carry a glyph, and each carries its own")+    func glyphsAreDistinctAndDefaultsHaveNone() {+        #expect(WorkStatusPresentation.systemImage(.ongoing) == nil)+        #expect(WorkStatusPresentation.systemImage(.finished) == "flag.checkered")+        #expect(WorkStatusPresentation.systemImage(.hiatus) == "pause.circle")++        #expect(ReadingStatusPresentation.systemImage(.reading) == nil)+        #expect(ReadingStatusPresentation.systemImage(.finished) == "checkmark")+        #expect(ReadingStatusPresentation.systemImage(.abandoned) == "book.closed")++        // Req 4.3: distinct per value across both dimensions — a shared symbol+        // would make "finished work" and "finished reading" one mark.+        let symbols =+            WorkStatus.allCases.compactMap(WorkStatusPresentation.systemImage)+            + ReadingStatus.allCases.compactMap(ReadingStatusPresentation.systemImage)+        #expect(Set(symbols).count == 4)+    }++    /// Q27: no third hue. Work glyphs take the type tag's violet, reading glyphs+    /// the count pill's cyan, so the row's marks stay inside the two accents the+    /// row already uses.+    @Test("Work glyphs are violet and reading glyphs are cyan")+    func huesFollowTheRowsExistingAccents() {+        for status in WorkStatus.allCases {+            #expect(WorkStatusPresentation.hue(status) == AsterismColors.violet)+        }+        for status in ReadingStatus.allCases {+            #expect(ReadingStatusPresentation.hue(status) == AsterismColors.cyan)+        }+    }++    // MARK: - Accessibility labels (Reqs 5.5, 6.2, Q23)++    /// Both dimensions have a value called "Finished", so every label names its+    /// dimension. The same strings are the filter pills' visible text.+    @Test("Every label names its dimension and its value")+    func labelsNameTheirDimension() {+        #expect(+            WorkStatus.allCases.map(WorkStatusPresentation.accessibilityLabel)+                == ["Work: Ongoing", "Work: Finished", "Work: On hiatus"])+        #expect(+            ReadingStatus.allCases.map(ReadingStatusPresentation.accessibilityLabel)+                == ["Reading: Reading", "Reading: Finished", "Reading: Abandoned"])+    }++    // MARK: - Verdict prompts (Req 2.3, Q16)++    /// The prompt is what tells the two verdicts apart — "How was it?" over a+    /// book finished, "Why did you stop?" over one dropped. A work still being+    /// read has no verdict field, so it has no prompt.+    @Test("Each done-reading value has its own prompt, and reading has none")+    func verdictPromptsPerCase() {+        #expect(ReadingStatusPresentation.verdictPrompt(.reading) == nil)+        #expect(ReadingStatusPresentation.verdictPrompt(.finished) == "How was it?")+        #expect(ReadingStatusPresentation.verdictPrompt(.abandoned) == "Why did you stop?")+        // The prompt exists exactly where the field does (Req 2.3).+        for status in ReadingStatus.allCases {+            #expect((ReadingStatusPresentation.verdictPrompt(status) != nil) == status.isDone)+        }+    }++    // MARK: - The duplicate sheet reads the same table (Q54)++    /// `DuplicateResolutionView` carried its own copy of these words from task+    /// 11 until this table existed. The copy is gone; the sheet's arms are the+    /// table's labels, so a re-spelling cannot land on three surfaces and miss+    /// the fourth.+    @Test("The duplicate sheet's status arms are the table's labels")+    @MainActor func duplicateSheetArmsComeFromTheTable() {+        for status in WorkStatus.allCases {+            #expect(+                DuplicateResolutionView.workStatusLine(+                    Self.variant(workStatus: status), differing: [.workStatus])+                    == WorkStatusPresentation.accessibilityLabel(status))+        }+        for status in ReadingStatus.allCases {+            #expect(+                DuplicateResolutionView.readingStatusLine(+                    Self.variant(readingStatus: status), differing: [.readingStatus])+                    == ReadingStatusPresentation.accessibilityLabel(status))+        }+    }++    private static func variant(+        workStatus: WorkStatus = .ongoing, readingStatus: ReadingStatus = .reading+    ) -> WorkVariantChoice {+        WorkVariantChoice(+            id: VariantID(rawValue: "work-variant"),+            displayTitle: "Serial", manualTitle: nil, genericNotes: "",+            workURLString: nil, genreTags: [], typeDisplay: .untyped,+            workStatus: workStatus, readingStatus: readingStatus, verdict: "",+            firstCapturedAt: Date(timeIntervalSince1970: 1_800_000_000))+    }+}

diff --git a/Asterism/AsterismTests/WorksFilterPresentationTests.swift b/Asterism/AsterismTests/WorksFilterPresentationTests.swiftindex 0f8275a..b91775f 100644--- a/Asterism/AsterismTests/WorksFilterPresentationTests.swift+++ b/Asterism/AsterismTests/WorksFilterPresentationTests.swift@@ -78,6 +78,74 @@ struct WorksFilterPresentationTests {         #expect(options.name(for: .named(WorkTypeName.normalize("Manga"))) == "Manga")     } +    // MARK: - The two status dimensions (`work-and-reading-status` Req 6.2, Q23)++    /// Both dimensions have a value called "Finished" and the pill row prints+    /// bare names, so an unqualified pill would read "Finished, Finished".+    @Test("A status pill names its dimension as well as its value")+    @MainActor func statusPillsNameTheirDimension() {+        let options = WorksFilterOptions(works: [Self.work()])+        #expect(+            WorksFilterPresentation.activeLabels(+                WorksFilter(workStatus: .finished), options: options) == ["Work: Finished"])+        #expect(+            WorksFilterPresentation.activeLabels(+                WorksFilter(readingStatus: .finished), options: options) == ["Reading: Finished"])+        #expect(+            WorksFilterPresentation.activeLabels(+                WorksFilter(workStatus: .hiatus), options: options) == ["Work: On hiatus"])+    }++    /// Menu order: type, tag, site, then the two statuses, in the order the+    /// pickers sit in the menu.+    @Test("The status pills follow the site pill, in menu order")+    @MainActor func statusPillsFollowTheSite() {+        let options = WorksFilterOptions(works: [+            Self.work(typeDisplay: Self.typed("Manga"), tags: ["shonen"], hostnames: ["a.example"])+        ])+        let filter = WorksFilter(+            type: .named(WorkTypeName.normalize("Manga")), tag: "shonen", hostname: "a.example",+            workStatus: .hiatus, readingStatus: .abandoned)+        #expect(+            WorksFilterPresentation.activeLabels(filter, options: options)+                == ["Manga", "shonen", "a.example", "Work: On hiatus", "Reading: Abandoned"])+    }++    /// Req 6.2: the empty sentence names the filters as the pills do, so the+    /// dead end a status filter reaches explains itself in the same words.+    @Test("The empty sentence carries the qualified status names")+    @MainActor func emptySentenceCarriesQualifiedStatusNames() {+        let options = WorksFilterOptions(works: [Self.work()])+        let labels = WorksFilterPresentation.activeLabels(+            WorksFilter(workStatus: .finished, readingStatus: .abandoned), options: options)+        #expect(+            WorksFilterPresentation.emptyDescription(labels: labels, query: nil)+                == "No works match Work: Finished, Reading: Abandoned.")+    }++    /// Req 6.1's fixed order, addressed the way the existing dimensions are —+    /// one row identifier per value plus the "Any" row.+    @Test("Every status row is addressable, Any included")+    @MainActor func statusRowsAreAddressable() {+        #expect(+            WorkStatus.allCases.map(WorksFilterPresentation.workStatusRowIdentifier) == [+                "works-filter-work-status-ongoing",+                "works-filter-work-status-finished",+                "works-filter-work-status-hiatus",+            ])+        #expect(+            ReadingStatus.allCases.map(WorksFilterPresentation.readingStatusRowIdentifier) == [+                "works-filter-reading-status-reading",+                "works-filter-reading-status-finished",+                "works-filter-reading-status-abandoned",+            ])+        #expect(+            WorksFilterPresentation.anyWorkStatusRowIdentifier == "works-filter-work-status-any")+        #expect(+            WorksFilterPresentation.anyReadingStatusRowIdentifier+                == "works-filter-reading-status-any")+    }+     // MARK: - The empty state (Req 8)      @Test("With no query the sentence names the filters alone")

diff --git a/Asterism/AsterismTests/WorksListOptionsTests.swift b/Asterism/AsterismTests/WorksListOptionsTests.swiftindex 88398d8..0329169 100644--- a/Asterism/AsterismTests/WorksListOptionsTests.swift+++ b/Asterism/AsterismTests/WorksListOptionsTests.swift@@ -128,6 +128,70 @@ struct WorksSortTests {             #expect(sort.apply(to: []).isEmpty)         }     }++    // MARK: - Abandoned last (`work-and-reading-status` Req 5.3, Q31)++    private func abandoned(_ index: Int, _ title: String) -> WorkSnapshot {+        TestFixtures.makeWork(+            id: id(index), displayTitle: title,+            entries: [TestFixtures.makeEntry(workID: id(index))],+            readingStatus: .abandoned)+    }++    /// The partition runs last, over whatever the sort produced, so every sort+    /// gets the rule from one line rather than four.+    @Test("Abandoned works follow the rest under every sort")+    func abandonedWorksComeLastUnderEverySort() {+        let works = [work(1, "B"), abandoned(2, "A"), work(3, "C"), abandoned(4, "D")]+        let expected: [WorksSort: [UUID]] = [+            .newest: [id(1), id(3), id(2), id(4)],+            .oldest: [id(3), id(1), id(4), id(2)],+            .aToZ: [id(1), id(3), id(2), id(4)],+            .zToA: [id(3), id(1), id(4), id(2)],+        ]+        for sort in WorksSort.allCases {+            #expect(sort.apply(to: works).map(\.id) == expected[sort], "\(sort)")+        }+    }++    /// Req 5.3's harder half: `.oldest` reverses each *emptiness* section, and+    /// the partition then runs over that result. Both steps are stable, so the+    /// abandoned works trail while keeping the reversed order among themselves —+    /// and the empty works still trail the non-empty ones once the view splits.+    @Test("Abandoned last composes with oldest first's per-section reversal")+    func abandonedLastComposesWithTheOldestReversal() {+        let works = [+            work(1, "A"), abandoned(2, "B"), work(3, "C"), abandoned(4, "D"),+            emptyWork(5, "E"), emptyWork(6, "F"),+        ]+        let sorted = WorksSort.oldest.apply(to: works)+        // The partition is over the whole result, so the abandoned pair trails+        // the empty works here — and the view's own emptiness `filter`, being+        // stable too, puts each section back in the order Req 5.3 asks for.+        #expect(sorted.map(\.id) == [id(3), id(1), id(6), id(5), id(4), id(2)])+        #expect(sorted.filter { !$0.entries.isEmpty }.map(\.id) == [id(3), id(1), id(4), id(2)])+        #expect(sorted.filter { $0.entries.isEmpty }.map(\.id) == [id(6), id(5)])+    }++    /// A partition, not a sort: the abandoned works keep the order the sort gave+    /// them. `partition(by:)` is unstable and would scramble them.+    @Test("The partition is stable among the abandoned works")+    func thePartitionIsStable() {+        let works = [abandoned(3, "C"), abandoned(1, "A"), abandoned(2, "B")]+        #expect(WorksSort.newest.apply(to: works).map(\.id) == [id(3), id(1), id(2)])+        #expect(WorksSort.aToZ.apply(to: works).map(\.id) == [id(1), id(2), id(3)])+    }++    /// The other two reading statuses are one class, not three: a finished read+    /// is still a read the reader did, and only `abandoned` steps back (Req 5.2).+    @Test("Only abandoned steps back — a finished read keeps its place")+    func onlyAbandonedIsMovedBack() {+        let finished = TestFixtures.makeWork(+            id: id(1), displayTitle: "A", entries: [TestFixtures.makeEntry(workID: id(1))],+            readingStatus: .finished)+        let works = [finished, abandoned(2, "B"), work(3, "C")]+        #expect(WorksSort.newest.apply(to: works).map(\.id) == [id(1), id(3), id(2)])+    } }  @Suite("Works filter")@@ -138,12 +202,15 @@ struct WorksFilterTests {         title: String = "Work",         typeDisplay: WorkTypeDisplay = .untyped,         tags: [String] = [],-        hostnames: [String] = ["example.com"]+        hostnames: [String] = ["example.com"],+        workStatus: WorkStatus = .ongoing,+        readingStatus: ReadingStatus = .reading     ) -> WorkSnapshot {         TestFixtures.makeWork(             id: id(index), displayTitle: title,             memberships: TestFixtures.makeMemberships(hostnames),-            typeDisplay: typeDisplay, genreTags: tags)+            typeDisplay: typeDisplay, genreTags: tags,+            workStatus: workStatus, readingStatus: readingStatus)     }      // MARK: - Activity (Req 5)@@ -161,6 +228,20 @@ struct WorksFilterTests {         #expect(WorksFilter(type: .untyped).isActive)         #expect(WorksFilter(tag: "shonen").isActive)         #expect(WorksFilter(hostname: "example.com").isActive)+        #expect(WorksFilter(workStatus: .ongoing).isActive)+        #expect(WorksFilter(readingStatus: .reading).isActive)+    }++    /// The two new dimensions are nil-defaulted like the other three, so every+    /// call site written before V10 still describes an unfiltered list.+    @Test("The init defaults every dimension to nothing chosen")+    func initDefaultsToNothingChosen() {+        let filter = WorksFilter()+        #expect(filter.type == nil)+        #expect(filter.tag == nil)+        #expect(filter.hostname == nil)+        #expect(filter.workStatus == nil)+        #expect(filter.readingStatus == nil)     }      // MARK: - Type (Q7)@@ -225,25 +306,75 @@ struct WorksFilterTests {         #expect(WorksFilter(hostname: "example.com").apply(to: works).isEmpty)     } +    // MARK: - Work and reading status (`work-and-reading-status` Req 6.1)++    @Test("A work status matches works carrying exactly that value")+    func workStatusMatchesItsValue() {+        let works = [+            work(1, workStatus: .ongoing),+            work(2, workStatus: .finished),+            work(3, workStatus: .hiatus),+        ]+        #expect(WorksFilter(workStatus: .finished).apply(to: works).map(\.id) == [id(2)])+        #expect(WorksFilter(workStatus: .ongoing).apply(to: works).map(\.id) == [id(1)])+        #expect(WorksFilter(workStatus: .hiatus).apply(to: works).map(\.id) == [id(3)])+    }++    @Test("A reading status matches works carrying exactly that value")+    func readingStatusMatchesItsValue() {+        let works = [+            work(1, readingStatus: .reading),+            work(2, readingStatus: .finished),+            work(3, readingStatus: .abandoned),+        ]+        #expect(WorksFilter(readingStatus: .finished).apply(to: works).map(\.id) == [id(2)])+        #expect(WorksFilter(readingStatus: .abandoned).apply(to: works).map(\.id) == [id(3)])+    }++    /// Both dimensions have a value spelled `finished`, and they are separate+    /// questions: a finished work the reader is still reading answers one and+    /// not the other.+    @Test("The two finished values are two different questions")+    func theTwoFinishedValuesAreDistinct() {+        let works = [+            work(1, workStatus: .finished, readingStatus: .reading),+            work(2, workStatus: .ongoing, readingStatus: .finished),+        ]+        #expect(WorksFilter(workStatus: .finished).apply(to: works).map(\.id) == [id(1)])+        #expect(WorksFilter(readingStatus: .finished).apply(to: works).map(\.id) == [id(2)])+    }+     // MARK: - AND across dimensions (Q3) -    @Test("The three dimensions are ANDed")+    @Test("The five dimensions are ANDed")     func dimensionsAreANDed() {         let match = work(             1, typeDisplay: typed("Manga", kind: .active), tags: ["shonen"],-            hostnames: ["a.example"])+            hostnames: ["a.example"], workStatus: .finished, readingStatus: .abandoned)         let wrongTag = work(             2, typeDisplay: typed("Manga", kind: .active), tags: ["seinen"],-            hostnames: ["a.example"])+            hostnames: ["a.example"], workStatus: .finished, readingStatus: .abandoned)         let wrongSite = work(             3, typeDisplay: typed("Manga", kind: .active), tags: ["shonen"],-            hostnames: ["b.example"])-        let wrongType = work(4, tags: ["shonen"], hostnames: ["a.example"])+            hostnames: ["b.example"], workStatus: .finished, readingStatus: .abandoned)+        let wrongType = work(+            4, tags: ["shonen"], hostnames: ["a.example"], workStatus: .finished,+            readingStatus: .abandoned)+        let wrongWorkStatus = work(+            5, typeDisplay: typed("Manga", kind: .active), tags: ["shonen"],+            hostnames: ["a.example"], workStatus: .hiatus, readingStatus: .abandoned)+        let wrongReadingStatus = work(+            6, typeDisplay: typed("Manga", kind: .active), tags: ["shonen"],+            hostnames: ["a.example"], workStatus: .finished, readingStatus: .finished)         let filter = WorksFilter(             type: .named(WorkTypeName.normalize("Manga")), tag: "shonen",-            hostname: "a.example")+            hostname: "a.example", workStatus: .finished, readingStatus: .abandoned)         #expect(-            filter.apply(to: [match, wrongTag, wrongSite, wrongType]).map(\.id) == [id(1)])+            filter.apply(+                to: [+                    match, wrongTag, wrongSite, wrongType, wrongWorkStatus, wrongReadingStatus,+                ]+            ).map(\.id) == [id(1)])     }      @Test("A combination nothing matches returns nothing")@@ -276,12 +407,26 @@ struct WorksFilterTests {         #expect(pruned.hostname == "a.example")     } -    @Test("Pruning against an empty snapshot clears every value")+    @Test("Pruning against an empty snapshot clears every open vocabulary")     func pruningAgainstEmptyClearsAll() {         let filter = WorksFilter(type: .untyped, tag: "t", hostname: "h")         #expect(filter.pruned(to: .empty) == WorksFilter())     } +    /// Req 6.3, Q30: the two status vocabularies are closed, so a value cannot+    /// stop being offered — pruning them would drop a live question the moment+    /// the last work carrying it left the library.+    @Test("Pruning leaves a status alone, even against an empty snapshot")+    func pruningLeavesStatusesAlone() {+        let filter = WorksFilter(+            type: .untyped, tag: "t", hostname: "h", workStatus: .hiatus,+            readingStatus: .abandoned)+        let pruned = filter.pruned(to: .empty)+        #expect(pruned.workStatus == .hiatus)+        #expect(pruned.readingStatus == .abandoned)+        #expect(pruned == WorksFilter(workStatus: .hiatus, readingStatus: .abandoned))+    }+     @Test("A filter the options still cover is returned unchanged")     func pruningKeepsCoveredFilter() {         let options = WorksFilterOptions(works: [work(1, tags: ["t"], hostnames: ["h"])])

diff --git a/Asterism/AsterismTests/WorksRowPresentationTests.swift b/Asterism/AsterismTests/WorksRowPresentationTests.swiftindex 029a70a..57b8821 100644--- a/Asterism/AsterismTests/WorksRowPresentationTests.swift+++ b/Asterism/AsterismTests/WorksRowPresentationTests.swift@@ -36,6 +36,72 @@ struct WorksRowPresentationTests {         #expect(WorksRowPresentation.openLabel(for: work) == "Open Work Orphan")     } +    // MARK: - Status clauses (`work-and-reading-status` Req 5.5, Q32)++    /// `WorkRow` is one button, so a glyph's own label is never spoken: the+    /// row's single label is the only channel the marks have. The clauses are+    /// joined with ". " because the label already lists hostnames with ", ".+    @Test("The status clauses trail the site list, separated from it by a period")+    @MainActor func statusClausesTrailTheSiteList() {+        let work = TestFixtures.makeWork(+            displayTitle: "Zephyr",+            memberships: TestFixtures.makeMemberships(["a.example", "b.example"]),+            workStatus: .finished, readingStatus: .abandoned)++        #expect(+            WorksRowPresentation.openLabel(for: work)+                == "Open Work Zephyr from a.example, b.example. Work: Finished. "+                + "Reading: Abandoned")+    }++    /// The clauses mirror the glyphs (Req 5.1): a work still running and a+    /// reader still reading are the defaults, so they add nothing to the label.+    @Test("A work on both defaults adds no clause")+    @MainActor func defaultsAddNoClause() {+        let work = TestFixtures.makeWork(displayTitle: "Zephyr", hostname: "a.example")+        #expect(WorksRowPresentation.openLabel(for: work) == "Open Work Zephyr from a.example")+    }++    @Test("Each dimension contributes its clause on its own")+    @MainActor func eachDimensionContributesAlone() {+        let hiatus = TestFixtures.makeWork(+            displayTitle: "Zephyr", hostname: "a.example", workStatus: .hiatus)+        #expect(+            WorksRowPresentation.openLabel(for: hiatus)+                == "Open Work Zephyr from a.example. Work: On hiatus")++        let read = TestFixtures.makeWork(+            displayTitle: "Zephyr", hostname: "a.example", readingStatus: .finished)+        #expect(+            WorksRowPresentation.openLabel(for: read)+                == "Open Work Zephyr from a.example. Reading: Finished")+    }++    /// Req 5.2: the abandoned row's reduced emphasis is colour and opacity, so+    /// the title element carries the state in words as well.+    @Test("The title element carries the same clauses")+    @MainActor func theTitleElementCarriesTheClauses() {+        let abandoned = TestFixtures.makeWork(+            displayTitle: "Zephyr", hostname: "a.example", readingStatus: .abandoned)+        #expect(WorksRowPresentation.titleLabel(for: abandoned) == "Zephyr. Reading: Abandoned")++        let plain = TestFixtures.makeWork(displayTitle: "Zephyr", hostname: "a.example")+        #expect(WorksRowPresentation.titleLabel(for: plain) == "Zephyr")+    }++    /// The UI journeys read a listed title as the substring before " from ",+    /// so the clauses must stay behind the site list.+    @Test("The clauses leave the title parser's substring alone")+    @MainActor func theTitleParserIsUnaffected() throws {+        let work = TestFixtures.makeWork(+            displayTitle: "Zephyr", hostname: "a.example", workStatus: .finished,+            readingStatus: .abandoned)+        let label = WorksRowPresentation.openLabel(for: work)+        let opened = try #require(label.range(of: "Open Work "))+        let site = try #require(label.range(of: " from "))+        #expect(String(label[opened.upperBound..<site.lowerBound]) == "Zephyr")+    }+     // MARK: - The dismiss pill (Req 5.5)      /// The record is of an unordered **pair**, so what one pill names is the

diff --git a/Asterism/AsterismUITests/AccessibilityJourneyUITests.swift b/Asterism/AsterismUITests/AccessibilityJourneyUITests.swiftindex 982c548..35f4eeb 100644--- a/Asterism/AsterismUITests/AccessibilityJourneyUITests.swift+++ b/Asterism/AsterismUITests/AccessibilityJourneyUITests.swift@@ -305,6 +305,22 @@ final class AccessibilityJourneyUITests: XCTestCase {         scrollToElement(row, attempts: 8)         assertContentControl(row, named: "A work row under the filter pills") +        // `work-and-reading-status` Req 10.2: a status filter is chosen through+        // the same menu at this size, and the row it leaves wears a work-status+        // glyph and a reading-status glyph — the row that has to stay hittable.+        // ANDed with the site filter above, it is Zephyr Court alone.+        chooseWorksOption("works-filter-work-status-finished", labelled: "Finished", in: app)+        let marked = app.buttons.matching(+            NSPredicate(format: "label BEGINSWITH %@", "Open Work Zephyr Court")).firstMatch+        XCTAssertTrue(+            marked.waitForExistence(timeout: 15),+            "A status filter narrows the list at largest Dynamic Type")+        scrollToElement(marked, attempts: 8)+        assertContentControl(marked, named: "A row wearing both status glyphs")+        XCTAssertTrue(+            marked.label.hasSuffix(". Work: Finished. Reading: Finished"),+            "Req 5.5: the row names both marks — was \(marked.label)")+         // The menu still opens with the pills on screen, which is the state a         // reader is in when they go back to change or clear the filter.         menu.tap()@@ -313,6 +329,134 @@ final class AccessibilityJourneyUITests: XCTestCase {             sortRow.waitForExistence(timeout: 10), "The menu reopens over a filtered list")     } +    /// `work-and-reading-status` Req 10.2, the edit-mode half: at the largest+    /// Dynamic Type size the two status capsules and the verdict field are still+    /// reachable and operable, and Req 3.1's dialog still offers all three of+    /// its actions — the third of them as the platform's own cancel rather than+    /// the declared button, see the comment at the assertion.+    ///+    /// The capsules are the risk. `ConstellationSegmentedControl` lays its three+    /// segments across a row and falls back to a stacked layout through+    /// `ViewThatFits` when they no longer fit — at `accessibility5` on a phone+    /// they do not, so this case is the one that walks the stacked arm. Marrow+    /// Lane is the fixture's abandoned work, so the verdict field is on screen+    /// before anything is tapped and choosing `finished` reading raises the+    /// dialog.+    @MainActor+    func testTheStatusControlsAndDialogStayOperableAtLargestDynamicType() {+        launchSeeded(+            scenario: "seeded-works-options",+            extraArguments: [+                "-UIPreferredContentSizeCategoryName", "UICTContentSizeCategoryAccessibilityXXXL"+            ]+        )++        let works = app.tabControl(.works)+        XCTAssertTrue(works.waitForExistence(timeout: 30), "The Works tab is reachable")+        works.tap()+        XCTAssertTrue(+            app.collectionViews["works-list"].waitForExistence(timeout: 15),+            "Works lists the seeded library")++        let abandoned = app.buttons.matching(+            NSPredicate(format: "label BEGINSWITH %@", "Open Work Marrow Lane")).firstMatch+        XCTAssertTrue(abandoned.waitForExistence(timeout: 15), "The abandoned work is listed")+        scrollToElement(abandoned, attempts: 8)+        assertContentControl(abandoned, named: "The abandoned row at largest Dynamic Type")+        abandoned.tap()++        let edit = app.buttons["work-detail-edit-button"]+        XCTAssertTrue(edit.waitForExistence(timeout: 20), "The work page opens")+        assertSystemControl(edit, named: "The editor at largest Dynamic Type")+        edit.tap()+        XCTAssertTrue(+            app.textFields["work-detail-title-field"].waitForExistence(timeout: 15),+            "The editor is open")++        // Req 10.1/10.2: every new control carries an identifier and a label,+        // and at this size it still owns a 44 pt target.+        for identifier in [+            "work-detail-work-status-ongoing", "work-detail-work-status-finished",+            "work-detail-work-status-hiatus", "work-detail-reading-status-reading",+            "work-detail-reading-status-abandoned",+        ] {+            let segment = app.buttons[identifier]+            // Two scrolls, and both are needed: the editor is a lazy `List`, so+            // a row below the fold is not in the tree at all until it is+            // scrolled in — and at this size the stacked capsules are tall+            // enough that a segment can exist while still sitting under the+            // keyboard-free bottom of the window.+            scrollUntilPresent(segment, in: app, "The editor offers \(identifier) at this size")+            scrollToElement(segment, attempts: 8)+            assertContentControl(segment, named: "\(identifier) at largest Dynamic Type")+        }++        let verdict = app.anyElement("work-detail-verdict-field")+        scrollUntilPresent(verdict, in: app, "The verdict field is reachable at this size")+        scrollToElement(verdict, attempts: 8)+        XCTAssertEqual(+            verdict.label, "Why did you stop?",+            "Req 10.1: the field is labelled by its prompt rather than its placeholder")++        // Req 3.1's dialog, at the size where three actions are most likely to+        // clip. The capsule's own segment is tapped to raise it, which is also+        // the assertion that the segment is operable and not merely present.+        scrollUntilTappableAndTap(+            app.buttons["work-detail-reading-status-finished"], in: app,+            "The reading-status capsule is operable at largest Dynamic Type")+        for identifier in [+            "work-detail-finished-mark-work", "work-detail-finished-abandon",+        ] {+            let action = app.dialogButton(identifier)+            XCTAssertTrue(+                action.waitForExistence(timeout: 10),+                "Req 10.2: the dialog presents \(identifier) at largest Dynamic Type")+            assertSystemControl(action, named: "\(identifier) in the dialog")+        }+        // The third action is the one the platform draws for itself: iOS renders+        // this dialog as an anchored popover, and a popover-presented dialog+        // **omits** the declared cancel button because a tap outside is the+        // platform's cancel. Measured at `accessibility5` here and at the+        // default size on the phone — `work-detail-finished-cancel` exists at+        // neither, the popover holds exactly the two action buttons — and the+        // same fact `declineConfirmationDialog` records for the delete dialog.+        // So the third action is asserted as what it is, a way out that works,+        // through the helper that prefers the identified control wherever the+        // platform draws one; the assertions under the call are what say the way+        // out was a *cancel*.+        declineConfirmationDialog(+            cancel: "work-detail-finished-cancel", dismissing: "work-detail-finished-mark-work",+            in: app)++        // Req 3.2: what makes that a *cancel* rather than a dismissal is that+        // the drafts are where they were — the same pair `WorkDetailStatusUITests`+        // asserts at compact width. Without it the check above says only that+        // the dialog closed, which it also does when an action is taken.+        let abandonedSegment = app.buttons["work-detail-reading-status-abandoned"]+        scrollUntilPresent(+            abandonedSegment, in: app, "The reading capsule is back on screen after the cancel")+        XCTAssertTrue(+            abandonedSegment.isSelected,+            "Req 3.2: cancelling restores the reading status the picker showed")+        let ongoingSegment = app.buttons["work-detail-work-status-ongoing"]+        scrollUntilPresent(ongoingSegment, in: app, "…as is the work-status capsule")+        XCTAssertTrue(+            ongoingSegment.isSelected, "…and the work status was never touched")++        // Req 10.2 for the verdict field, which the read above only labels: the+        // same operability the five segments are held to, and a tap to prove it+        // is reachable and not merely laid out. Last in the case deliberately —+        // the tap raises the keyboard, which would stand over the capsule the+        // dialog is raised from.+        scrollUntilPresent(verdict, in: app, "The verdict field is still on screen")+        scrollToElement(verdict, attempts: 8)+        assertContentControl(verdict, named: "The verdict field at largest Dynamic Type")+        verdict.tap()+        XCTAssertEqual(+            verdict.label, "Why did you stop?",+            "…and tapping it changes neither the field nor what it is asking for")+    }+     // MARK: - Constellation visual pass (Reqs 8–11)      /// The Works tab and Work detail in dark, walked through the surfaces the

diff --git a/Asterism/AsterismUITests/UIJourneySupport.swift b/Asterism/AsterismUITests/UIJourneySupport.swiftindex c7a5c8d..26a1b55 100644--- a/Asterism/AsterismUITests/UIJourneySupport.swift+++ b/Asterism/AsterismUITests/UIJourneySupport.swift@@ -154,15 +154,64 @@ extension XCTestCase {         if cancel.exists, cancel.isHittable {             cancel.tap()         } else {-            // Mid-screen, below the popover and above the tab bar; the dimming-            // layer absorbs the tap rather than passing it through.-            app.coordinate(withNormalizedOffset: CGVector(dx: 0.5, dy: 0.55)).tap()+            app.coordinate(withNormalizedOffset: outsidePopoverOffset(in: app)).tap()         }         waitUntilGone(             app.dialogButton(witnessIdentifier), "The declined dialog closes", timeout: 10,             file: file, line: line)     } +    /// Where to tap to decline a popover-presented dialog: outside the popover,+    /// on the dimming layer, which absorbs the tap rather than passing it+    /// through.+    ///+    /// Mid-screen — below the popover and above the tab bar — is the answer at+    /// the ordinary text sizes, and is what every caller has always got. **It+    /// stops being the answer at the accessibility sizes.** The popover then+    /// fills all but a sliver of the window: measured at `accessibility5` on a+    /// 402×874 window, the popover is 366×758 at y 72, and the mid-screen point+    /// (201, 480) is inside the dialog's first action button. A tap there closes+    /// the dialog by *taking* that action, so `waitUntilGone` is satisfied and+    /// the decline quietly does the opposite of declining — which is how the+    /// largest-Dynamic-Type status journey came up green while both statuses had+    /// been written to `finished`.+    ///+    /// So the default point is kept wherever the popover does not contain it —+    /// every caller at the ordinary sizes is unaffected — and only where it does+    /// is the tap moved into one of the margins the popover leaves.+    ///+    /// **The band above the popover is not one of them**, though at+    /// `accessibility5` it is the tallest: those 72 pt are the status bar, which+    /// is a system window over the app, and a tap there never reaches the+    /// dimming layer at all (measured — the dialog stayed up). The margin below+    /// is 44 pt of app, tab bar included, and the dimming layer is over all of+    /// it. The sides are tried after it and the top last, so a popover anchored+    /// against the bottom still has somewhere to go.+    private func outsidePopoverOffset(in app: XCUIApplication) -> CGVector {+        let midScreen = CGVector(dx: 0.5, dy: 0.55)+        let popover = app.popovers.firstMatch+        let window = app.windows.firstMatch+        guard popover.exists, window.exists, window.frame.height > 0 else { return midScreen }+        let frame = window.frame+        let point = CGPoint(+            x: frame.minX + frame.width * midScreen.dx,+            y: frame.minY + frame.height * midScreen.dy)+        guard popover.frame.contains(point) else { return midScreen }++        // Each margin as the point at its middle, with the span that has to+        // clear a finger for it to be usable at all.+        let dialog = popover.frame+        let margins: [(span: CGFloat, point: CGPoint)] = [+            (frame.maxY - dialog.maxY, CGPoint(x: point.x, y: (dialog.maxY + frame.maxY) / 2)),+            (dialog.minX - frame.minX, CGPoint(x: (frame.minX + dialog.minX) / 2, y: point.y)),+            (frame.maxX - dialog.maxX, CGPoint(x: (dialog.maxX + frame.maxX) / 2, y: point.y)),+            (dialog.minY - frame.minY, CGPoint(x: point.x, y: (frame.minY + dialog.minY) / 2)),+        ]+        guard let chosen = margins.first(where: { $0.span >= 24 })?.point else { return midScreen }+        return CGVector(+            dx: (chosen.x - frame.minX) / frame.width, dy: (chosen.y - frame.minY) / frame.height)+    }+     /// Scrolls entry detail's form up by one screenful.     ///     /// **Not `app.swipeUp()`.** That swipes from the middle of the screen, which

diff --git a/Asterism/AsterismUITests/WideLayoutUITests.swift b/Asterism/AsterismUITests/WideLayoutUITests.swiftindex a8afb45..bb7d109 100644--- a/Asterism/AsterismUITests/WideLayoutUITests.swift+++ b/Asterism/AsterismUITests/WideLayoutUITests.swift@@ -444,6 +444,46 @@ final class WideLayoutUITests: XCTestCase {         waitFor(app.anyElement("sidebar-recent"), "And the sidebar stays where it is")     } +    /// `work-and-reading-status` Req 10.3: the statuses are the wide layout's+    /// too, with no platform-specific omission.+    ///+    /// The work page's meta line is where the two dimensions are stated in full+    /// (Req 4.1), and it is the one status surface whose layout differs between+    /// the phone and the iPad — on the phone it is a pushed screen's header, here+    /// it is the detail column's. So this case reads the two items and checks+    /// they are laid out inside that column rather than across the pane, which is+    /// the shape a push takes here (Req 1.7 and the Diagnostics case above).+    ///+    /// Zephyr Court is the fixture's work that is finished on both sides, so both+    /// items are drawn; the row-level glyphs and the filters are the phone+    /// suites', unchanged.+    func testTheWorkPageNamesBothStatusesInTheDetailColumn() {+        launch("seeded-works-options", orientation: .landscapeLeft)+        waitForLibrary()++        selectTab(.works, in: app)+        waitFor(app.collectionViews["works-list"], "Works lists the seeded library")+        waitFor(+            app.buttons.matching(+                NSPredicate(format: "label BEGINSWITH %@", "Open Work Zephyr Court")).firstMatch,+            "The doubly marked work is listed"+        ).tap()+        waitFor(app.anyElement("work-detail-pulse"), "The work fills the detail column")++        let detailColumn = waitFor(+            app.anyElement("wide-detail-column"), "The detail column is laid out")+        let workItem = waitFor(+            app.anyElement("work-detail-status-work"),+            "Req 4.1: the meta line names the work status on iPad too")+        XCTAssertEqual(workItem.label, "Work: Finished", "…with its dimension (Q23)")+        let readingItem = waitFor(+            app.anyElement("work-detail-status-reading"), "…and the reading status beside it")+        XCTAssertEqual(readingItem.label, "Reading: Finished", "…qualified the same way")++        assertInsideColumn(workItem, column: detailColumn, what: "The work-status meta item")+        assertInsideColumn(readingItem, column: detailColumn, what: "The reading-status meta item")+    }+     func testSelectingStatsFillsThePaneWithTheSidebarStillShowing() {         launch("seeded-taught", orientation: .landscapeLeft)         waitForLibrary()

diff --git a/Asterism/AsterismUITests/WorkDetailStatusUITests.swift b/Asterism/AsterismUITests/WorkDetailStatusUITests.swiftnew file mode 100644index 0000000..3b767d8--- /dev/null+++ b/Asterism/AsterismUITests/WorkDetailStatusUITests.swift@@ -0,0 +1,256 @@+import XCTest++/// The two statuses and the verdict on the work page (`work-and-reading-status`+/// Reqs 3.1, 3.2, 4.1, 4.2, 5.4), driven from app launch.+///+/// The transitions themselves are `WorkDetailModel`'s and have their own unit+/// tests; what only a journey can prove is that the capsules are reachable in+/// edit mode, that choosing `finished` on an unfinished work actually raises the+/// dialog on screen, that its buttons write what they say, and that a committed+/// edit comes back as meta-line items and a verdict paragraph the reader can+/// see.+///+/// `seeded-works-options` is the fixture, shared with `WorksListOptionsUITests`+/// so one seeded scenario carries the whole feature: **Marrow Lane** is+/// abandoned with a verdict and is the work this suite edits, **Zephyr Court**+/// is finished on both sides, **Ashfall** is on hiatus, and **Quill Harbour** is+/// on the defaults.+final class WorkDetailStatusUITests: XCTestCase {+    let app = XCUIApplication()++    override func setUp() {+        continueAfterFailure = false+        XCUIDevice.shared.orientation = .portrait+        terminateAndWaitForExit(app)+    }++    override func tearDown() {+        terminateAndWaitForExit(app)+    }++    // MARK: - Driving++    private func launch() {+        app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = "seeded-works-options"+        app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString+        app.launch()+    }++    private var workRows: XCUIElementQuery {+        app.elements(withIdentifierPrefix: "work-row-")+    }++    /// One row, by the work it opens: the `work-row-` identifiers carry a uuid+    /// the test cannot know, so the label is where the title is.+    private func row(titled title: String) -> XCUIElement {+        workRows.matching(NSPredicate(format: "label BEGINSWITH %@", "Open Work \(title) "))+            .firstMatch+    }++    private func openWork(_ title: String) {+        waitFor(app.collectionViews["recent-list"], "The library opens", timeout: 60)+        selectTab(.works, in: app)+        waitFor(app.collectionViews["works-list"], "Works lists the seeded library")+        waitFor(row(titled: title), "\(title) is listed").tap()+        waitFor(app.anyElement("work-detail-pulse"), "\(title) opens", timeout: 20)+    }++    /// Decision 5 of `polish-and-export`: the fields live in edit mode, so every+    /// journey that wants a status capsule enters the editor first.+    private func enterEditMode() {+        waitFor(app.buttons["work-detail-edit-button"], "View mode offers the editor").tap()+        waitFor(app.textFields["work-detail-title-field"], "The editor is open")+    }++    // MARK: - The dialog and the round trip (Reqs 3.1, 3.2, 4.1, 4.2)++    /// The journey the feature is named for: an abandoned work the reader+    /// decides they did finish after all.+    ///+    /// Marrow Lane is stored `ongoing` / `abandoned`, so choosing `finished`+    /// reading raises Req 3.1's dialog rather than writing — and "Mark the work+    /// finished too" is the arm that records both sides at the moment the reader+    /// knows them. The commit then has to come back as two meta-line items and+    /// the verdict paragraph, which is Req 4.1 and 4.2.+    func testMarkingAnAbandonedWorkFinishedMeetsTheDialogAndShowsBothStatuses() {+        launch()+        openWork("Marrow Lane")+        enterEditMode()++        // The stored pair, as the editor shows it before anything is touched.+        let abandoned = app.buttons["work-detail-reading-status-abandoned"]+        scrollUntilPresent(abandoned, in: app, "The editor offers the reading-status capsule")+        XCTAssertTrue(abandoned.isSelected, "The editor opens on the stored reading status")+        XCTAssertTrue(+            app.buttons["work-detail-work-status-ongoing"].isSelected,+            "…and on the stored work status")+        // Req 2.3: the verdict field is present because the work is done being+        // read, under the prompt that says which verdict is being asked for.+        let verdictField = app.anyElement("work-detail-verdict-field")+        waitFor(verdictField, "An abandoned work shows its verdict field")+        XCTAssertEqual(+            verdictField.label, "Why did you stop?",+            "Q16: the prompt is the field's label, not its placeholder")++        // Req 3.1: `finished` reading on a work that is not finished asks.+        scrollUntilTappableAndTap(+            app.buttons["work-detail-reading-status-finished"], in: app,+            "The reading-status capsule offers Finished")+        let markWork = waitFor(+            app.dialogButton("work-detail-finished-mark-work"),+            "Req 3.1: the dialog offers marking the work finished too")+        waitFor(+            app.dialogButton("work-detail-finished-abandon"),+            "…using abandoned instead")+        markWork.tap()++        // Req 3.2's first arm: both drafts move, and the verdict's prompt turns+        // into the finished one without the text going anywhere.+        let finishedWork = app.buttons["work-detail-work-status-finished"]+        scrollUntilPresent(finishedWork, in: app, "The work-status capsule is still on screen")+        let bothFinished = XCTNSPredicateExpectation(+            predicate: NSPredicate { _, _ in+                finishedWork.isSelected+                    && self.app.buttons["work-detail-reading-status-finished"].isSelected+            }, object: nil)+        XCTAssertEqual(+            XCTWaiter().wait(for: [bothFinished], timeout: 10), .completed,+            "Req 3.2: marking the work finished sets both drafts to finished")+        XCTAssertEqual(+            app.anyElement("work-detail-verdict-field").label, "How was it?",+            "Req 2.3: the prompt follows the reading status")++        // Commit. The pair no longer violates the rule, so the commit-time check+        // (Req 3.4) has nothing to ask and the editor closes on the first tap.+        waitFor(app.buttons["work-detail-save-button"], "The checkmark commits the editor").tap()+        waitUntilGone(+            app.textFields["work-detail-title-field"], "A committed editor returns to view mode")+        waitFor(app.anyElement("work-detail-pulse"), "View mode is back")++        // Req 4.1: two further items on the meta line, each a glyph with its name.+        let workItem = waitFor(+            app.anyElement("work-detail-status-work"), "The meta line names the work status")+        XCTAssertEqual(workItem.label, "Work: Finished", "…with its dimension (Q23)")+        let readingItem = waitFor(+            app.anyElement("work-detail-status-reading"),+            "…and the reading status beside it")+        XCTAssertEqual(readingItem.label, "Reading: Finished", "…qualified the same way")++        // Req 4.2: the verdict the work already carried is still the reader's,+        // and it is shown now that the status is done reading again.+        let verdict = app.anyElement("work-detail-verdict")+        scrollUntilPresent(verdict, in: app, "The verdict is shown as a paragraph")+        // The paragraph is an accessibility *container* (`children: .contain`),+        // so the words are on the text inside it rather than on the element the+        // identifier is on. Scoped to that container's own descendants rather+        // than asked of the app: an app-wide match says only that the words are+        // somewhere on screen, which they would be if the paragraph were drawn+        // anywhere else — or not drawn at all and the editor still open.+        let verdictTexts = verdict.descendants(matching: .staticText)+        XCTAssertTrue(+            verdictTexts.matching(NSPredicate(format: "label CONTAINS %@", "fog plot"))+                .firstMatch.exists,+            "…and it is the text the work already held, kept through the status change")+        XCTAssertTrue(+            verdictTexts.matching(NSPredicate(format: "label == %@", "Verdict"))+                .firstMatch.exists,+            "Req 4.2: the paragraph is captioned, so the words read as the verdict "+                + "rather than as one more note")+    }++    /// Req 3.2's third action. Cancelling has to leave the capsule exactly where+    /// it was, because the transition never wrote anything: the draft stays put+    /// while the dialog is up, which is what makes cancel free.+    func testCancellingTheFinishedReadingDialogLeavesTheDraftAlone() {+        launch()+        openWork("Marrow Lane")+        enterEditMode()++        scrollUntilTappableAndTap(+            app.buttons["work-detail-reading-status-finished"], in: app,+            "The reading-status capsule offers Finished")+        waitFor(+            app.dialogButton("work-detail-finished-mark-work"), "The dialog is up")+        declineConfirmationDialog(+            cancel: "work-detail-finished-cancel", dismissing: "work-detail-finished-mark-work",+            in: app)++        let abandoned = app.buttons["work-detail-reading-status-abandoned"]+        scrollUntilPresent(abandoned, in: app, "The editor is still on screen")+        XCTAssertTrue(+            abandoned.isSelected,+            "Req 3.2: cancelling restores the reading status the picker showed")+        XCTAssertTrue(+            app.buttons["work-detail-work-status-ongoing"].isSelected,+            "…and the work status was never touched")+    }++    /// Req 3.3, the transition with no dialog: a work that stops being finished+    /// cannot leave a reader "finished" with it, so the reading status steps back+    /// to `reading` and the verdict field goes with it (Req 2.5 keeps the text).+    func testUnfinishingTheWorkStepsTheReadingStatusBack() {+        launch()+        openWork("Zephyr Court")+        enterEditMode()++        let hiatus = app.buttons["work-detail-work-status-hiatus"]+        scrollUntilTappableAndTap(hiatus, in: app, "The work-status capsule offers On hiatus")++        let steppedBack = XCTNSPredicateExpectation(+            predicate: NSPredicate { _, _ in+                self.app.buttons["work-detail-reading-status-reading"].isSelected+            }, object: nil)+        XCTAssertEqual(+            XCTWaiter().wait(for: [steppedBack], timeout: 10), .completed,+            "Req 3.3: an unfinished work cannot be finished reading")+        XCTAssertFalse(+            app.dialogButton("work-detail-finished-mark-work").exists,+            "…and the step back is not a question")+        waitUntilGone(+            app.anyElement("work-detail-verdict-field"),+            "Req 2.3: the verdict field goes with the done-reading status")+    }++    // MARK: - The merge destination picker (Req 5.4)++    /// Req 5.4/Q32: the picker draws the library's own row, so its rows wear the+    /// same glyphs — and a picker row is one button, so the marks reach a reader+    /// who cannot see them only through the row's own label (Q59 puts the+    /// clauses after the note count).+    func testTheMergePickerNamesEachDestinationsStatuses() {+        launch()+        openWork("Ashfall")+        enterEditMode()+        scrollUntilTappableAndTap(+            app.buttons["work-detail-merge-button"], in: app, "The editor offers Merge")++        let destinations = app.elements(withIdentifierPrefix: "merge-destination-")+        waitFor(destinations.firstMatch, "The picker lists the other works", timeout: 20)+        let labels = (0..<destinations.count).map { destinations.element(boundBy: $0).label }++        // Both suffix matches depend on the destination being **available**.+        // Q59 has `destinationLabel` append the refusal *after* the status+        // clauses, because a refusal is a finished sentence and has to stay the+        // last thing the row says — so an unavailable row ends on+        // "…before this Work can be merged into." and `hasSuffix` fails for a+        // reason that has nothing to do with the statuses. What keeps these rows+        // available is the fixture: `seeded-works-options` quarantines no+        // hostname and leaves no Work in differing copies, which are the two+        // things `unavailableMessage(for:)` refuses on.+        XCTAssertTrue(+            labels.contains { $0.hasPrefix("Merge into Marrow Lane") && $0.hasSuffix(". Reading: Abandoned") },+            "An abandoned destination says so — was \(labels)")+        XCTAssertTrue(+            labels.contains {+                $0.hasPrefix("Merge into Zephyr Court")+                    && $0.hasSuffix(". Work: Finished. Reading: Finished")+            },+            "…and a doubly marked one names both dimensions — was \(labels)")+        XCTAssertTrue(+            labels.contains { $0.hasPrefix("Merge into Quill Harbour") && !$0.contains("Reading:") },+            "…while a destination on both defaults reads as it always did — was \(labels)")++        waitFor(app.buttons["merge-cancel-button"], "The sheet offers the way out").tap()+        waitUntilGone(destinations.firstMatch, "Cancelling closes the picker")+    }+}

diff --git a/Asterism/AsterismUITests/WorksListOptionsUITests.swift b/Asterism/AsterismUITests/WorksListOptionsUITests.swiftindex 797af0e..0b64f69 100644--- a/Asterism/AsterismUITests/WorksListOptionsUITests.swift+++ b/Asterism/AsterismUITests/WorksListOptionsUITests.swift@@ -11,11 +11,17 @@ import XCTest /// blank list. /// /// `seeded-works-options` is the fixture with something to sort: **Marrow-/// Lane** (alpha.test, tagged `mystery`, untyped), **Ashfall** (beta.test,-/// wearing the removed `webtoon` type) and **Zephyr Court** (alpha.test,-/// `novel`) captured in that order — so the date order is the reverse of it and-/// disagrees with the alphabet at every position — plus the entry-less **Quill-/// Harbour** (beta.test) and one unattached entry.+/// Lane** (alpha.test, tagged `mystery`, untyped, reading `abandoned` with a+/// verdict), **Ashfall** (beta.test, wearing the removed `webtoon` type, work+/// status `hiatus`) and **Zephyr Court** (alpha.test, `novel`, finished on both+/// sides with a verdict) captured in that order — so the date order is the+/// reverse of it and disagrees with the alphabet at every position — plus the+/// entry-less **Quill Harbour** (beta.test, both statuses on their defaults)+/// and one unattached entry.+///+/// `work-and-reading-status` rides on that one scenario rather than a second+/// fixture, which is why the four order constants below sink Marrow Lane: Req+/// 5.3's abandoned-last partition applies to every sort. final class WorksListOptionsUITests: XCTestCase {     let app = XCUIApplication() @@ -23,10 +29,17 @@ final class WorksListOptionsUITests: XCTestCase {     /// from every other one, so an assertion here cannot pass against the wrong     /// sort — and the empty work moves out of its own trailing section under     /// the title sorts (Req 2).+    ///+    /// **Marrow Lane is last of its section in all four**+    /// (`work-and-reading-status` Req 5.3, Q31): the partition runs after the+    /// ordering and before the view splits the sections, and both steps are+    /// stable, so the abandoned work sinks inside the section it was already in+    /// while everything else keeps the sort's own order. Under Newest first it+    /// was already there, which is why only three of the four constants moved.     private let newestOrder = ["Zephyr Court", "Ashfall", "Marrow Lane", "Quill Harbour"]-    private let oldestOrder = ["Marrow Lane", "Ashfall", "Zephyr Court", "Quill Harbour"]-    private let aToZOrder = ["Ashfall", "Marrow Lane", "Quill Harbour", "Zephyr Court"]-    private let zToAOrder = ["Zephyr Court", "Quill Harbour", "Marrow Lane", "Ashfall"]+    private let oldestOrder = ["Ashfall", "Zephyr Court", "Marrow Lane", "Quill Harbour"]+    private let aToZOrder = ["Ashfall", "Quill Harbour", "Zephyr Court", "Marrow Lane"]+    private let zToAOrder = ["Zephyr Court", "Quill Harbour", "Ashfall", "Marrow Lane"]      override func setUp() {         continueAfterFailure = false@@ -40,9 +53,16 @@ final class WorksListOptionsUITests: XCTestCase {      // MARK: - Driving -    private func launch() {+    /// `textSize` is a `UIContentSizeCategory` name — the+    /// `UICTContentSizeCategoryAccessibility{M,L,XL,XXL,XXXL}` spelling, since+    /// an unrecognised name is not an error and silently launches at the default+    /// size (`WideLayoutAccessibilityUITests` measured that).+    private func launch(textSize: String? = nil) {         app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = "seeded-works-options"         app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString+        if let textSize {+            app.launchArguments += ["-UIPreferredContentSizeCategoryName", textSize]+        }         app.launch()     } @@ -134,6 +154,11 @@ final class WorksListOptionsUITests: XCTestCase {         assertListed(aToZOrder, "A to Z draws one alphabetical section")         chooseOption("works-sort-zToA", labelled: "Z to A")         assertListed(zToAOrder, "Z to A is that alphabet reversed")+        // `work-and-reading-status` Req 5.3: whichever of the four is on, the+        // abandoned work is the last of the works that have notes.+        XCTAssertEqual(+            listedTitles().last, "Marrow Lane",+            "The abandoned work sinks under every sort")         chooseOption("works-sort-newest", labelled: "Newest first")         assertListed(newestOrder, "…and the reader can put it back") @@ -246,4 +271,237 @@ final class WorksListOptionsUITests: XCTestCase {             app.elements(withIdentifierPrefix: "recent-entry-").count, 4,             "Three attached chapters and the unattached note")     }++    // MARK: - `work-and-reading-status`: the statuses on the list (Reqs 5, 6)++    /// Req 5.3's other two clauses — the partition holds **with a query** and+    /// **with a filter** — and Req 5.2/5.5's abandoned row saying so in words.+    ///+    /// Both narrowings are asserted under A to Z rather than Newest first,+    /// because that is where the partition is visible: under the date sorts+    /// Marrow Lane is the oldest capture and would trail the list anyway, so a+    /// missing partition would pass. Under the alphabet it sits second, and only+    /// Req 5.3 moves it.+    func testTheAbandonedWorkSinksUnderAQueryAndAFilterAndSaysSo() {+        launch()+        waitFor(app.collectionViews["recent-list"], "The library opens", timeout: 60)+        selectTab(.works, in: app)+        waitFor(app.collectionViews["works-list"], "Works lists the seeded library")++        // Req 5.5: the knock-down is colour and opacity, which XCUI cannot read+        // and a reader may not have. The words are the assertable channel, and+        // the requirement is that they are there.+        let abandoned = row(titled: "Marrow Lane")+        waitFor(abandoned, "The abandoned work is listed")+        XCTAssertTrue(+            abandoned.label.hasSuffix(". Reading: Abandoned"),+            "Req 5.5: the row says it is abandoned — was \(abandoned.label)")+        let marked = row(titled: "Zephyr Court")+        XCTAssertTrue(+            marked.label.hasSuffix(". Work: Finished. Reading: Finished"),+            "…and a row wearing both marks names both — was \(marked.label)")+        XCTAssertEqual(+            row(titled: "Quill Harbour").label, "Open Work Quill Harbour from beta.test",+            "A work on both defaults reads exactly as it did before the statuses existed")++        chooseOption("works-sort-aToZ", labelled: "A to Z")+        assertListed(aToZOrder, "A to Z sinks the abandoned work to the end")++        // With a filter: alpha.test is Marrow Lane and Zephyr Court, which the+        // alphabet on its own would order the other way round.+        chooseOption("works-filter-site-alpha.test", labelled: "alpha.test")+        assertListed(+            ["Zephyr Court", "Marrow Lane"],+            "Req 5.3: the partition holds with a filter on top of the sort")+        app.anyElement("works-filter-clear").tap()+        assertListed(aToZOrder, "The filter is cleared before the query goes on")++        // And with a query: the title search keeps three of the four, and the+        // abandoned one is still last of them. Typed last, so the field never+        // has to be cleared again.+        let field = searchField(in: app)+        field.tap()+        field.typeText("a")+        assertListed(+            ["Ashfall", "Quill Harbour", "Marrow Lane"],+            "Req 5.3: the partition holds with a query on top of the sort")+    }++    /// Req 6.1's two new dimensions, Req 6.2's qualified pill and empty state,+    /// and Req 6.3's value that no work carries — one walk, for the reason the+    /// main journey is one walk.+    func testTheStatusFiltersNarrowTheListAndNameTheirDimension() {+        launch()+        waitFor(app.collectionViews["recent-list"], "The library opens", timeout: 60)+        selectTab(.works, in: app)+        waitFor(app.collectionViews["works-list"], "Works lists the seeded library")++        // Work status: the fixture's one work on hiatus.+        chooseOption("works-filter-work-status-hiatus", labelled: "On hiatus")+        assertListed(["Ashfall"], "A work-status filter keeps the works carrying it")+        waitFor(pill("Work: On hiatus"), "Req 6.2: the pill names the dimension it filtered")+        XCTAssertEqual(+            optionsMenu.label, "Sort and filter works, filters active",+            "…and the menu icon fills as it does for the other three dimensions")++        // Reading status, on its own: Clear first, so the two are not ANDed into+        // a miss neither dimension is responsible for.+        app.anyElement("works-filter-clear").tap()+        assertListed(newestOrder, "Clear removes the status filter as it does any other")++        chooseOption("works-filter-reading-status-abandoned", labelled: "Abandoned")+        assertListed(["Marrow Lane"], "A reading-status filter keeps the works carrying it")+        waitFor(pill("Reading: Abandoned"), "…under its own qualified pill")++        // Req 6.3: the two dimensions are not faceted and their vocabularies are+        // closed, so a pair no work carries is reachable — and the empty state+        // names both dimensions rather than reading "Finished, Abandoned".+        chooseOption("works-filter-work-status-finished", labelled: "Finished")+        waitFor(+            app.anyElement("works-filter-empty"),+            "A combination no work carries is reachable and explains itself")+        let explanation = app.staticTexts.matching(+            NSPredicate(format: "label BEGINSWITH %@", "No works match")).firstMatch+        waitFor(explanation, "The empty state names what is narrowing the list")+        XCTAssertTrue(+            explanation.label.contains("Work: Finished")+                && explanation.label.contains("Reading: Abandoned"),+            "Req 6.2: both dimensions are named — was \(explanation.label)")++        // Q23's whole reason: both vocabularies have a value called "Finished",+        // and with the pair the fixture does carry, both pills are on screen at+        // once and have to be tellable apart.+        chooseOption("works-filter-reading-status-finished", labelled: "Finished")+        assertListed(["Zephyr Court"], "The pair one work does carry lists it")+        waitFor(pill("Work: Finished"), "The work side's Finished names itself")+        waitFor(pill("Reading: Finished"), "…and the reading side's names itself too")+    }++    /// Req 5.1, the one thing a unit test cannot see (Q61): **where** the glyphs+    /// are drawn and what they cost the row.+    ///+    /// Zephyr Court wears both marks beside a type tag; Quill Harbour wears+    /// neither and is the row the height is measured against. Frames are read+    /// after the list has settled on the opening sort, so both rows are laid out+    /// in the same pass.+    ///+    /// The "where" is a default-size fact and stays here; the height comparison+    /// is made twice, because at the default size it cannot fail — see+    /// `assertGlyphsCostNoHeightAtLargestDynamicType`, which relaunches at+    /// `accessibility5` and repeats it there.+    func testTheRowGlyphsFollowTheTypeTagAndCostTheRowNoHeight() throws {+        launch()+        waitFor(app.collectionViews["recent-list"], "The library opens", timeout: 60)+        selectTab(.works, in: app)+        waitFor(app.collectionViews["works-list"], "Works lists the seeded library")+        assertListed(newestOrder, "The list has settled before any frame is read")++        let marked = waitFor(row(titled: "Zephyr Court"), "The doubly marked row is listed")+        let unmarked = waitFor(row(titled: "Quill Harbour"), "…as is the unmarked one")+        scrollUntilPresent(unmarked, in: app, "Both rows are on screen together")++        let typeTag = try XCTUnwrap(+            element("work-type-tag", inside: marked), "The marked row wears its type tag")+        let workGlyph = try XCTUnwrap(+            element("work-status-glyph", inside: marked), "…and the finished-work glyph")+        let readingGlyph = try XCTUnwrap(+            element("reading-status-glyph", inside: marked), "…and the finished-reading glyph")++        // "After the type tag", read as the layout fact it is: the work glyph+        // starts where the tag ends, and the reading glyph after that.+        XCTAssertGreaterThanOrEqual(+            workGlyph.frame.minX, typeTag.frame.maxX - 1,+            "Req 5.1: the work-status glyph follows the type tag")+        XCTAssertGreaterThanOrEqual(+            readingGlyph.frame.minX, workGlyph.frame.maxX - 1,+            "Req 5.1: the reading-status glyph follows it")+        XCTAssertTrue(+            marked.frame.contains(workGlyph.frame) && marked.frame.contains(readingGlyph.frame),+            "Both glyphs are drawn inside the row, not beside it")++        // "No taller than the type tag", and the row no taller for them.+        XCTAssertLessThanOrEqual(+            workGlyph.frame.height, typeTag.frame.height + 1,+            "Req 5.1: a glyph is no taller than the tag beside it")+        XCTAssertLessThanOrEqual(+            readingGlyph.frame.height, typeTag.frame.height + 1,+            "…either of them")+        XCTAssertLessThanOrEqual(+            marked.frame.height, unmarked.frame.height + 1,+            "Req 5.1: a row wearing two glyphs is no taller than one wearing none")++        assertGlyphsCostNoHeightAtLargestDynamicType()+    }++    /// The height half of Req 5.1, at the size where it can fail.+    ///+    /// **At the default size the comparison above cannot discriminate.** Every+    /// row carries the entry-count pill whatever else it wears, and the row+    /// floors at `AsterismLayout.minHitTarget`; between them the height is+    /// settled before a glyph is drawn, so a glyph twice the tag's height would+    /// still leave the two rows equal. At `accessibility5` the content is what+    /// sets the height, so a glyph that does not follow the pill's text font+    /// shows up as a taller row — which is the failure the requirement is about.+    ///+    /// Read under **A to Z**, not the opening sort: the two rows have to be laid+    /// out in the same pass, and at this size only adjacent ones fit on screen+    /// together. Newest first puts Zephyr Court first and Quill Harbour last, in+    /// its own trailing no-notes section; A to Z puts them side by side.+    private func assertGlyphsCostNoHeightAtLargestDynamicType() {+        terminateAndWaitForExit(app)+        launch(textSize: "UICTContentSizeCategoryAccessibilityXXXL")+        waitFor(+            app.collectionViews["recent-list"], "The library opens at largest Dynamic Type",+            timeout: 60)+        selectTab(.works, in: app)+        waitFor(app.collectionViews["works-list"], "Works lists the seeded library again")+        chooseOption("works-sort-aToZ", labelled: "A to Z")++        let marked = row(titled: "Zephyr Court")+        scrollUntilPresent(+            marked, in: app, "The doubly marked row is reachable at largest Dynamic Type")+        let unmarked = row(titled: "Quill Harbour")+        XCTAssertTrue(+            unmarked.exists,+            "…with the unmarked control row laid out in the same pass, so the two "+                + "heights are comparable")+        XCTAssertLessThanOrEqual(+            marked.frame.height, unmarked.frame.height + 1,+            "Req 5.1: at largest Dynamic Type, where the row height follows its content, "+                + "two glyphs still cost the row nothing")+    }++    // MARK: - Row helpers++    /// One row, by the work it opens. `work-row-` identifiers carry a uuid the+    /// test cannot know, and the row's own label is the only place the title is.+    private func row(titled title: String) -> XCUIElement {+        workRows.matching(NSPredicate(format: "label BEGINSWITH %@", "Open Work \(title) "))+            .firstMatch+    }++    /// One active-filter pill, by the words on it. Every pill carries the same+    /// identifier — one per value, which is what the row is — so the label is+    /// what tells two of them apart.+    private func pill(_ text: String) -> XCUIElement {+        app.descendants(matching: .any).matching(+            NSPredicate(+                format: "identifier == %@ AND label == %@", "works-filter-pills", text)+        ).firstMatch+    }++    /// An element inside a given row, found by frame containment.+    ///+    /// A row's children all share their identifiers with the other rows'+    /// (`work-type-tag` is on every typed row), so the query has to be narrowed+    /// by geometry rather than by index — the index depends on the sort.+    private func element(_ identifier: String, inside row: XCUIElement) -> XCUIElement? {+        let matches = app.descendants(matching: .any).matching(identifier: identifier)+        let rowFrame = row.frame+        for index in 0..<matches.count {+            let candidate = matches.element(boundBy: index)+            if rowFrame.contains(candidate.frame) { return candidate }+        }+        return nil+    } }

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 46236f1..f77ceb3 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,6 +8,188 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).  ### Changed +- **Work and reading status is documented and verified+  (work-and-reading-status, phase "Documentation and verification",+  T-2306 — spec complete).** The style guide's §7 and §8 carry the+  meta-line items, the row glyphs, the abandoned knock-down, the two+  captions and the four symbols; `docs/asterism-design.md` §5.2 and §6+  describe the two statuses and the finished-reading rule; the+  `schema-migration` and `testing` agent notes are rewritten for V10+  live over a frozen V9, markers `"9"` and `"10"`, the+  `V9RecordedStore` pair and `MarkerGenerationTenTests`, with their+  Phase 1 banners gone; `rule-wire-format` names `BackupV9*`; the+  design doc records the landed dialog shape (Q62) and the popover+  presentation (Q65). `specs/work-and-reading-status/verification-run.md`+  records the full run: `make test-core` (one known-flake rerun),+  `make test-quick` with the Mac build, `make test-ui` (its only+  failures the pre-existing `M4ScaleRecentPerformanceUITests` trio),+  `make test-ui-ipad`, and `make test-performance-m4` at eight known+  issues with no ceiling left — the capture-projection arms moved+  0.160–0.170 s to 0.169–0.176 s for the three wider `Work` columns,+  which `CLAUDE.md`'s performance paragraph now states. No device+  target was run and the Mac app was never launched; the owner's+  device checks and the `prerequisites.md` steps are listed in the+  record, and the specs overview marks the feature Done.++- **The works-options fixture carries statuses and the UI journeys+  read them (work-and-reading-status, phase "UI fixture and journeys",+  T-2306).** `seedWorksOptionsWork` seeds Marrow Lane abandoned with a+  verdict, Ashfall on hiatus, Zephyr Court finished and finished with a+  verdict, and Quill Harbour on the defaults (Q58 keeps the removed-type+  pill and the abandoned row on different works). `WorksListOptionsUITests`+  proves the abandoned row sinks under a query and a filter and says so,+  both status filters narrow the list with dimension-qualified pills,+  and the glyphs follow the type tag at no row height cost, measured at+  default type and at accessibility5 (Q68). A new+  `WorkDetailStatusUITests` walks the finished-reading dialog, marks the+  work finished, saves and reads both meta-line items and the verdict,+  cancels, steps a finished reading back with no dialog, and reads a+  merge destination's status clause. The XXXL accessibility journey+  covers a status filter, both capsules, the verdict field, the dialog+  and a row wearing both glyphs; the iPad wide-layout suite reads both+  meta-line items. Two findings: on iOS 26 the dialog is an anchored+  popover at every size and its declared Cancel is never drawn on the+  phone, so the third action is the dismiss region (Q65, proposed, the+  requirement wording is the owner's call), and the shared+  `declineConfirmationDialog` helper was tapping inside a button at+  accessibility5, a false green now fixed and swept over every caller+  (Q66). Req 5.2's dimming is the owner's device check (Q67). The+  three `M4ScaleRecentPerformanceUITests` failures in `make test-ui`+  are pre-existing on this machine, as `ipad-and-mac-layouts` recorded.++- **The work detail screen edits both statuses and enforces the+  finished-reading rule (work-and-reading-status, phase "Work detail and+  the finished-reading rule", T-2306).** `WorkDetailModel` carries a+  work-status draft, a reading-status draft and a verdict draft, seeded+  on load, compared in `hasUnsavedChanges` (the verdict untrimmed, like+  the title, Q63), restored with the other drafts, and sent by `save`+  in the draft and in the nil-snapshot fallback basis (Q40, Q47). The+  transition table lands as designed: reading → finished over an+  unfinished work raises the "Mark as finished?" dialog on the picker+  (Req 3.1, 3.2), moving the work off finished auto-reverts a finished+  reading to reading (Q7) and returning it before commit restores the+  reverted value (Q39), abandoned is never prompted (Q5), a re-tap is a+  no-op, and `commitEditing()` runs the same gate first, only when the+  pair changed this session, so a cancel leaves every draft intact and+  a stored violating pair with an unrelated edit writes back unchanged+  (Q20, Q37). The dialog is a `presenting:` value on the delete+  prompt's shape — `resolveFinishedReadingPrompt(_:choosing:)` carries+  the prompt and Cancel is the sync `cancelFinishedReadingPrompt()`+  (Q62), with the message wording recorded in Q64. Edit mode gains two+  captioned segmented capsules and a verdict field between Type and+  Tags (Q26), the verdict field speaking its caption for VoiceOver+  (Req 10.1); the meta line shows the two statuses as items from the+  presentation table and a `Verdict` paragraph sits between the tag row+  and the notes while the reading is finished or abandoned.++- **The Works list shows, dims, sorts and filters by status+  (work-and-reading-status, phase "Works list and filters", T-2306).**+  A new `WorkStatusPresentation` / `ReadingStatusPresentation` table+  beside `WorkTypePresentation` carries every name, symbol, hue,+  qualified accessibility label and verdict prompt (Q36), and the+  duplicate-resolution sheet's interim words now delegate to it (Q54).+  `WorkRow` draws a glyph after the type tag for each non-default value+  (`flag.checkered` / `pause.circle` in violet, `checkmark` /+  `book.closed` in cyan, Q27), knocks an abandoned row down to the+  style guide's opacity with a secondary-text title (Req 5.2; a removed+  type's pill double-dims, accepted per Q58), and `WorksSort.apply`+  ends with an abandoned-last partition that keeps every sort's order+  inside each half (Q31). `WorksFilter` gains a work-status and a+  reading-status dimension with nil defaults and dimension-qualified+  pills (Q23, Q30); `pruned` leaves the closed vocabularies alone. The+  row's open label and the merge picker's destination label append+  "Work: …" and "Reading: …" clauses, the merge label placing them+  before the refusal with a full stop between (Q59). Req 5.1's glyph+  placement is carried by a task 18 journey (Q61).++- **The backup archive moves to 9 over 10 and carries the three status+  fields (work-and-reading-status, phase "Backup archive 9 over 10",+  T-2306).** The `BackupV8*` set is renamed `BackupV9*` as a tracked+  rename following the `rule-citation-by-uuid` precedent, with+  `formatVersion 9` over `schemaVersion 10`, the `multi-site` gate and+  the `v9` staged filename unchanged. `BackupV9Work` carries+  `workStatus`, `readingStatus` and `verdict` as required wire fields+  (Q34), pinned by a test that a 9/10 record omitting them fails to+  decode; export projects the carrier's values and refuses an unknown or+  empty status raw by name beside the `titleProvenance` refusal+  (Req 8.3, Q57); import writes all three to every row of a non-torn+  group and the verdict verbatim (Q55). An 8/9 archive is refused by+  version naming both pairs (Req 8.2, Q17) and the 8/9 importer is+  gone, which closes Req 2.6's status-less-record arm by construction+  (Q56). `backup-8-9-golden.json` is deleted and `backup-9-10-golden.json`+  recorded from a golden library that now holds a work on hiatus,+  abandoned, with a verdict. The Q46 transient state — a schema-10 store+  stamping an 8/9 archive — is closed.++- **Duplicate resolution and merge carry the three status fields+  (work-and-reading-status, phase "Duplicate resolution and merge",+  T-2306).** `DuplicateResolutionField` and `WorkVariantChoice` gain+  `workStatus`, `readingStatus` and `verdict`; `differingWorkFields`+  names them, so a status-only tear now raises a review card that says+  which field differs, and a resolution writes the carrier's three to+  every surviving row. `WorkVariantSide` carries them as required+  parameters (Q52) and the shared `WorkVariantUnion.fold` keeps the+  target's values, lists a source status as discarded only when it is+  non-default and differs (Q38), and records a differing non-blank source+  verdict as a `Verdict:` line in the audit block on both the merge and+  the resolution path (Q41), escaped like the merged-from header so a+  multi-line verdict cannot forge a block boundary (Q53).+  `WorkMergeField` gains six cases and `recordedInNotes`, and the merge+  preview's "recorded in merged notes" caption and audit-block label are+  now truthful per field. The duplicate-resolution sheet shows the+  work status, the reading status and a `Verdict:` line, with its own+  words until task 15's presentation table lands (Q54). The outcome's+  three target values are carried but unrendered (Q51).++- **The three status fields ride the authored-content write chain+  (work-and-reading-status, phase "Authored-content write chain",+  T-2306).** `WorkAuthoredContent` carries `workStatus`, `readingStatus`+  and `verdict` with three `orderComponents` slots, `isBare` treats the+  defaults and an empty verdict as bare, and `authoredContent(of:)` stays+  the single producer. `WorkSnapshot` and both `snapshot` arms (the split+  arm reads the carrier) surface them; `WorkMetadataDraft` takes them as+  required parameters (Q40) while `WorkEditBasis` defaults them (Q47),+  with `init(work:)` and `matches` covering all three and the detail+  model's nil-snapshot fallback basis stating them explicitly.+  `updateWork` writes all three to every row of the group and trims the+  verdict there and nowhere else (Q33); an all-whitespace verdict leaves+  the work bare. `DuplicateReconciler.apply` gains the `genreTags`-shaped+  non-default guard so a carrier on the defaults never overwrites a+  sibling's status. A captured and a manually created work read+  ongoing / reading / `""` on both doors. Until task 17 the detail model+  sends the loaded values back on save, so a save from a stale screen+  writes them over another device's change (Q49, last write wins as for+  every field); a status-only tear raises a review card that lists no+  differing field until task 11 lands. Req 7.2's "only the default+  statuses" means a bare row (Q48) and the backup-import creation-defaults+  arm moved to task 13 (Q50).++- **Schema V10, the two status enums and marker generation 10+  (work-and-reading-status, phase "Schema V10 and bootstrap", T-2306).**+  `Work` gains three defaulted columns — `workStatusRaw` (`"ongoing"`),+  `readingStatusRaw` (`"reading"`) and `verdict` (`""`) — read through two+  `ToleratedEnum` accessors so an unknown or empty raw reads as the default,+  with `WorkStatus` (ongoing, finished, hiatus) and `ReadingStatus`+  (reading, finished, abandoned; `isDone`) in `DomainEnums`.+  `AsterismSchemaV9` is now the frozen snapshot, verified column for column+  against the pre-feature models; `AsterismSchemaV10` carries the ten+  models and `AsterismV10MigrationPlan` is `[V9, V10]` with one lightweight+  stage (Q18). `AsterismSchemaV8` and the `V8RecordedStore*` pair are+  deleted (Q43) and a `V9RecordedStoreFixture`/`V9RecordedStoreTests` pair+  takes their place. The readiness markers move to `"9"` lagging and+  `"10"` published — the first two-character marker; no read path assumed+  one — and an `"8"` store is refused naming the digit. The tests'+  unrecognised-marker literal moved from `"10"` to `"99"` (Q28), the+  marker suites moved one generation (`MarkerGenerationTenTests`), three+  suites the task list did not name moved with them (Q44), and+  `library-graph-baseline.txt` is at format 7 (Q35). The design review+  retired the orphaned `WorkType` enum (Q42) and trimmed a version pin+  that contradicted its own comment (Q45). **Not releasable on its own**:+  the archive still stamps `8/9` over a schema-10 store until the+  backup phase renames the set (Q46). The owner-side `Development` run+  that publishes the three fields to the dev CloudKit container is now+  due (`prerequisites.md`).+ - **Pre-push review fixes for background-export (T-2052).** An   activation after a pass had deferred arrivals ran the diagnosis and   snapshot refresh twice, and an ordinary arrival never cleared the

diff --git a/CLAUDE.md b/CLAUDE.mdindex ad318ed..32fee26 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -58,7 +58,7 @@ invocations where a target exists. - `make test-quick` — unit-test bundle only (simulator), preceded by `build-mac`: a macOS compile failure fails it (Req 9.1). The Mac build is never installed or launched. `SKIP_MAC=1` drops that dependency loudly and owes a clean `make build-mac` before the push. - `make test` / `make test-ui` — full suites (simulator, iPhone); they skip the iPad-only suites by name - `make test-ui-ipad` — the wide-layout and wide-layout-accessibility suites on `IPAD_SIMULATOR` (simulator, safe)-- `make test-performance-m4` — M4 Core budgets, host only, no device, safe to run. **~21 minutes** (1,093 s of test time measured 2026-08-28, and 1,120 s over 28 tests on 2026-08-30 after `character-ranking` added its own, plus a ~190 s release build): most of it is the worst-case single-hostname consolidation in `M4ScalePerformanceTests` (5 samples, each paying its own ~40 s divert before a ~40 s measurement) and the Req 10.1 settling pass (10 samples, each re-seeding 1,350 duplicate rows plus an untimed observation pass). The V4→V5 migration measurement is **gone** — `retire-migration-chain` deleted the pass it timed along with the suite. **The target exits 0**, with the accepted breaches reported as `withKnownIssue` known issues rather than failures — **eight** since `drop-superseded-columns` (four before `multi-site-works`, nine after it). Four are long-standing: Req 10.1's settling pass and Req 5.5's three diagnosis re-derivations. Three are Req 5.4's capture-projection arms (0.093–0.102 s pre-V8 → 0.160–0.170 s, the one on a path the reader waits on). The eighth is the **full**-tier no-op reconcile, and V9 recovered most of it: 1.07 s → **0.0296–0.0302 s** once `V8PopulationPass` was deleted with the columns and `MembershipReconciler.heal` was gated on the diagnosis, which is still 3.0× a 10 ms ceiling drawn before the library had a membership table. Req 10.1's *observation* pass **retired** with that fall (2.69 s → 1.01 s, back inside its 2 s budget). Every one has a regression ceiling asserted *outside* its known-issue block, so a run that drifts further still fails; `RUNS=3` completes all three runs. See `specs/drop-superseded-columns/verification-run.md` for the current numbers, `specs/multi-site-works/verification-run.md` §4 and §7 for the previous ones, and `docs/agent-notes/testing.md` for recording a band.+- `make test-performance-m4` — M4 Core budgets, host only, no device, safe to run. **~21 minutes** (1,093 s of test time measured 2026-08-28, and 1,120 s over 28 tests on 2026-08-30 after `character-ranking` added its own, plus a ~190 s release build): most of it is the worst-case single-hostname consolidation in `M4ScalePerformanceTests` (5 samples, each paying its own ~40 s divert before a ~40 s measurement) and the Req 10.1 settling pass (10 samples, each re-seeding 1,350 duplicate rows plus an untimed observation pass). The V4→V5 migration measurement is **gone** — `retire-migration-chain` deleted the pass it timed along with the suite. **The target exits 0**, with the accepted breaches reported as `withKnownIssue` known issues rather than failures — **eight** since `drop-superseded-columns` (four before `multi-site-works`, nine after it). Four are long-standing: Req 10.1's settling pass and Req 5.5's three diagnosis re-derivations. Three are Req 5.4's capture-projection arms (0.093–0.102 s pre-V8 → 0.160–0.170 s at V9 → **0.169–0.176 s at V10**, the one on a path the reader waits on; the three new `Work` columns and the wider `orderComponents` cost them 3–6%, still well inside a 250 ms ceiling). The eighth is the **full**-tier no-op reconcile, and V9 recovered most of it: 1.07 s → **0.0296–0.0302 s** once `V8PopulationPass` was deleted with the columns and `MembershipReconciler.heal` was gated on the diagnosis, which is still 3.0× a 10 ms ceiling drawn before the library had a membership table; V10 left it there (0.0301 s). Req 10.1's *observation* pass **retired** with that fall (2.69 s → 1.01 s, back inside its 2 s budget, and 1.02 s at V10). Every one has a regression ceiling asserted *outside* its known-issue block, so a run that drifts further still fails; `RUNS=3` completes all three runs. See `specs/work-and-reading-status/verification-run.md` §4 for the current numbers, `specs/drop-superseded-columns/verification-run.md` and `specs/multi-site-works/verification-run.md` §4 and §7 for the previous ones, and `docs/agent-notes/testing.md` for recording a band. - `make test-performance-chunks` — host-only calibration sweep of the shared bulk chunk constant (import commits and the reconciler re-pin). No device, safe to run, but gated on `ASTERISM_RUN_CHUNK_SWEEP=1` and **~20 minutes per run**, so it is deliberately *not* part of `make test-performance-m4`. It asserts nothing — a calibration is reported, not budgeted. Re-run it when the bulk write paths change (Q53 and the task 25 section of `specs/cloudkit-mirroring/implementation.md`). - `make test-performance-m4-recent` — **physical device, see above** 

diff --git a/Packages/AsterismCore/Sources/AsterismCore/ArchiveRecordBuilders.swift b/Packages/AsterismCore/Sources/AsterismCore/ArchiveRecordBuilders.swiftindex eabfaa6..4062b59 100644--- a/Packages/AsterismCore/Sources/AsterismCore/ArchiveRecordBuilders.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/ArchiveRecordBuilders.swift@@ -25,7 +25,7 @@ import SwiftData /// archive's own. internal enum ArchiveRecordBuilders { -    static func makeSite(_ record: BackupV8Site) -> Site {+    static func makeSite(_ record: BackupV9Site) -> Site {         let site = Site(hostname: record.hostname, displayName: record.displayName)         site.modeRaw = record.mode.rawValue         site.junkSuffixRule = record.junkSuffixRule@@ -33,7 +33,7 @@ internal enum ArchiveRecordBuilders {     }      static func makeTitlePattern(-        _ record: BackupV8TitlePattern, site: Site?+        _ record: BackupV9TitlePattern, site: Site?     ) throws -> TitlePattern {         return try TitlePattern(             id: record.id,@@ -48,7 +48,7 @@ internal enum ArchiveRecordBuilders {     }      static func makeURLRule(-        _ record: BackupV8URLRule, site: Site?+        _ record: BackupV9URLRule, site: Site?     ) throws -> URLRulePattern {         try URLRulePattern(             id: record.id,@@ -64,7 +64,7 @@ internal enum ArchiveRecordBuilders {     /// The wire timestamps are what an import-created row carries on both fields     /// (Q33), and an unrecognised state coerces to `.active` rather than     /// refusing — a type row from a later build's wider set is legal data.-    static func makeWorkType(_ record: BackupV8WorkType) -> WorkTypeEntity {+    static func makeWorkType(_ record: BackupV9WorkType) -> WorkTypeEntity {         makeWorkType(             id: record.id, name: record.name,             state: ToleratedEnum.read(record.stateRaw, default: .active),@@ -91,7 +91,7 @@ internal enum ArchiveRecordBuilders {     /// Work has no site column to name: its site presence is its     /// `WorkSiteMembership`, which `makeMembership` below builds from the     /// archive's own records.-    static func makeWork(_ record: BackupV8Work) -> Work {+    static func makeWork(_ record: BackupV9Work) -> Work {         let work = Work(             id: record.id,             displayTitle: record.displayTitle,@@ -105,7 +105,7 @@ internal enum ArchiveRecordBuilders {     /// carries it. `workID` travels whether or not the Work is there (Q37), so an     /// orphan re-attaches when its Work arrives (Req 8.3, 9.5).     static func makeMembership(-        _ record: BackupV8Membership, work: Work?, site: Site?+        _ record: BackupV9Membership, work: Work?, site: Site?     ) -> WorkSiteMembership {         WorkSiteMembership(             id: record.id,@@ -123,13 +123,13 @@ internal enum ArchiveRecordBuilders {     /// One dismissed pair. The record's ids are already in the canonical sorted     /// order — `BackupImportPayload` normalises them at the door — so nothing     /// here re-sorts and then disagrees about which end is which.-    static func makeDistinctPair(_ record: BackupV8DistinctPair) -> WorkDistinctPair {+    static func makeDistinctPair(_ record: BackupV9DistinctPair) -> WorkDistinctPair {         WorkDistinctPair(             id: record.id, lowerWorkID: record.lowerWorkID,             higherWorkID: record.higherWorkID, recordedAt: record.recordedAt)     } -    static func makeEntry(_ record: BackupV8Entry) -> Entry {+    static func makeEntry(_ record: BackupV9Entry) -> Entry {         let entry = Entry(             id: record.id,             captureTitle: record.captureTitle,@@ -144,7 +144,7 @@ internal enum ArchiveRecordBuilders {         return entry     } -    static func makeCharacter(_ record: BackupV8Character) -> CharacterRecord {+    static func makeCharacter(_ record: BackupV9Character) -> CharacterRecord {         let character = CharacterRecord(             id: record.id, name: record.name, nameKey: record.nameKey,             aliases: record.aliases, note: record.note, facts: record.facts,@@ -156,7 +156,7 @@ internal enum ArchiveRecordBuilders {     /// The raw columns travel verbatim, so a value written by a later build's     /// wider set survives the round trip rather than being coerced to this     /// build's default.-    static func makeSuppression(_ record: BackupV8Suppression) -> CharacterSuppression {+    static func makeSuppression(_ record: BackupV9Suppression) -> CharacterSuppression {         let row = CharacterSuppression(             id: record.id, kind: record.kind, nameKey: record.nameKey,             source: record.source, evidence: record.evidence, status: record.status,

diff --git a/Packages/AsterismCore/Sources/AsterismCore/AsterismCapabilities.swift b/Packages/AsterismCore/Sources/AsterismCore/AsterismCapabilities.swiftindex 31495c8..e6d41e9 100644--- a/Packages/AsterismCore/Sources/AsterismCore/AsterismCapabilities.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/AsterismCapabilities.swift@@ -12,13 +12,14 @@ public struct AsterismCapabilities: Codable, Equatable, Sendable {         case m3 = "m3"         case m4 = "m4"         /// V8's gate (`multi-site-works` Q29): a Work holds site memberships,-        /// and the archive it writes is format 8 over schema 9. Nothing about a+        /// and the archive it writes is format 9 over schema 10. Nothing about a         /// *rule form* changes with it — every `supports…` answer below is m4's         /// — so the case exists to name the store shape and the rule-form set,-        /// which is what `BackupV8Codec` stamps. The literal did not move when-        /// the archive did: 8/9 changes neither of those two things (Q19), and-        /// the generation is named by its format and schema numbers, which are-        /// what the importer gates on.+        /// which is what `BackupV9Codec` stamps. The literal has not moved with+        /// either archive generation since: neither 8/9 nor 9/10 changes those+        /// two things (`rule-citation-by-uuid` Q19), and the generation is named+        /// by its format and schema numbers, which are what the importer gates+        /// on.         case multiSite = "multi-site"     } @@ -31,7 +32,7 @@ public struct AsterismCapabilities: Codable, Equatable, Sendable {     public static let multiSite = AsterismCapabilities(gate: .multiSite)      /// The current runtime gate is `.multiSite` (`multi-site-works` Q29).-    /// `BackupV8Codec` stamps the literal `"multi-site"` rather than reading+    /// `BackupV9Codec` stamps the literal `"multi-site"` rather than reading     /// this value, so the archive's gate is independent of the runtime's.     /// Earlier gates stay available because the schema and teaching suites still     /// exercise them — `CapabilityGatingTests`, `PhraseParsingTests`,

diff --git a/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV10.swift b/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV10.swiftnew file mode 100644index 0000000..3f610e9--- /dev/null+++ b/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV10.swift@@ -0,0 +1,67 @@+import Foundation+import SwiftData++/// The runtime schema. Its body is `Models.swift`, which opens+/// `extension AsterismSchemaV10`.+///+/// V10 is V9 **plus** three defaulted `Work` columns — `workStatusRaw`,+/// `readingStatusRaw` and `verdict` — the reader-entered statuses and the+/// verdict text `work-and-reading-status` adds. Nothing else moves: no table is+/// added or removed, no column changes type, and no relationship changes shape.+///+/// **This is the first version in this project to add a non-optional scalar to+/// an existing table under a bare lightweight stage.** The property initialiser+/// is what SwiftData turns into the Core Data attribute default, and that+/// default is what fills the three columns on every existing row inside+/// `ModelContainer.init` (Req 9.1). `V9RecordedStoreTests` therefore asserts the+/// **raw columns** after conversion rather than the accessors: an accessor+/// reading `ToleratedEnum.read(_, default:)` would answer `.ongoing` even if the+/// default never landed.+///+/// The entity *list* is unchanged: V10 adds no table and removes none.+public enum AsterismSchemaV10: VersionedSchema {+    public static let versionIdentifier = Schema.Version(10, 0, 0)++    public static var models: [any PersistentModel.Type] {+        [Entry.self, Work.self, Site.self, TitlePattern.self, URLRulePattern.self,+         WorkTypeEntity.self, Character.self, CharacterSuppression.self,+         WorkSiteMembership.self, WorkDistinctPair.self]+    }+}++/// The migration plan: `[V9, V10]`, one lightweight stage.+///+/// **The V8 → V9 stage is retired** (Q18 of `work-and-reading-status`). Every+/// device is confirmed at marker `"9"` on 2026-09-04, which is+/// `retire-migration-chain` Decision 6's population precondition, so+/// `AsterismSchemaV8` went with the stage that named it. A store older than V9+/// fails closed — `NSCocoaErrorDomain` 134504, "Cannot use staged migration with+/// an unknown model version" — and the recovery is the backup archive, which is+/// what `V4RecordedStoreTests` pins.+///+/// The single stage is `.lightweight`, and it purely **adds**. There is no data+/// pass behind it: the three columns are defaulted, so the conversion is the+/// attribute defaults being written, and what certifies it is the converted+/// store validating (`BootstrapState.markerLagging`'s arm). `.custom` is not an+/// option here for the reason it never is: a custom stage would also run inside+/// the share extension, which must never migrate, and the extension is kept out+/// by the marker instead.+///+/// One consequence worth stating, because it is new at V10: the live stored+/// shape is no longer a **subset** of the frozen one. Until now every stage+/// either added tables that the frozen snapshot simply lacked or removed columns+/// the live classes no longer declared, and a stale snapshot registration in+/// SwiftData's global entity registry could at worst cost a column that would+/// not save. An adding version loses that, so `V9RecordedStoreFixture`'s+/// create-seed-save-**release** ordering is the only thing holding the registry+/// coherent, together with `make test-core`'s `--no-parallel`+/// (`docs/agent-notes/schema-migration.md`).+public enum AsterismV10MigrationPlan: SchemaMigrationPlan {+    public static var schemas: [any VersionedSchema.Type] {+        [AsterismSchemaV9.self, AsterismSchemaV10.self]+    }++    public static var stages: [MigrationStage] {+        [.lightweight(fromVersion: AsterismSchemaV9.self, toVersion: AsterismSchemaV10.self)]+    }+}

diff --git a/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV8.swift b/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV8.swiftdeleted file mode 100644index fdf9fc8..0000000--- a/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV8.swift+++ /dev/null@@ -1,285 +0,0 @@-import Foundation-import SwiftData--/// The frozen `multi-site-works` schema — the shape every installed library was-/// written by before `drop-superseded-columns`, and the `from` version of the-/// V8 → V9 lightweight stage.-///-/// V8 is V7 plus the `WorkSiteMembership` and `WorkDistinctPair` tables and the-/// two Codable blob columns `Entry.citationsData` and-/// `TitlePattern.definitionData`. **It only added**: the columns those three-/// superseded stayed in the stored shape, because the lightweight stage runs-/// inside `ModelContainer.init` and a stage that dropped them would have-/// destroyed the source before `V8PopulationPass` could copy it. This snapshot-/// is what that shape looked like — `Work`'s six site/identity/URL columns and-/// `typeRaw`, `Entry.identityKeyVersion` and its seventeen citation columns,-/// `TitlePattern`'s ten definition columns, `Site.urlIdentityRule`, and the-/// `Work.site` ↔ `Site.works` inverse pair — all of which V9 drops.-///-/// V8 is frozen for the same reason V5, V6 and V7 were: *any* edit to its body-/// makes a V8-recorded store refuse to open with `NSCocoaErrorDomain` 134504,-/// "Cannot use staged migration with an unknown model version". The live classes-/// therefore moved to `AsterismSchemaV9`, and this declaration exists only to-/// give `AsterismV9MigrationPlan` a `from` version — and to let-/// `V8RecordedStoreFixture` seed a genuinely 8.0.0-recorded store in-process.-///-/// The classes are nested so they can carry the same SwiftData entity names-/// ("Entry", "Site", …) as the live V9 classes without a top-level collision:-/// the only top-level references are typealiases, and two *top-level* `@Model`s-/// sharing an entity name crash `ModelContext`-/// (`docs/agent-notes/schema-migration.md`). Nothing reads a V8-shaped object at-/// runtime, so these carry stored columns only — no accessors, no business-/// logic.-///-/// # These snapshots are frozen *by reference*, not only by file-///-/// The nesting freezes the class bodies; it does **not** freeze anything a body-/// *names*. Editing one of those changes the stored shape of this frozen schema-/// silently — and that is exactly what makes a recorded store refuse to open-/// (134504). Two families of referent, both live and both shared with V9:-///-/// * **The stored value types.** `SegmentRangeSpec`, `SegmentPositionSpec`,-///   `URLIdentityRule` and `JunkSuffixRule` are top-level types in-///   `ValueObjects.swift`. Their stored properties are this schema's stored-///   properties.-/// * **Every enum whose raw value is baked into a default.** A default is part-///   of the shape, so `WorkType.other.rawValue`, `PatternForm.segment.rawValue`,-///   `FieldProvenanceKind.none.rawValue`, `WorkURLIdentityState.none.rawValue`,-///   `SiteMode.untaught.rawValue`, `CaptureTitleSource.manual.rawValue`,-///   `EntryIdentityBasis.conservative.rawValue`, `TitleProvenance.manual`,-///   `URLRuleOrigin.readerTaught`, `WorkTypeState.active`,-///   `CharacterSuppressionKind.candidate` and-///   `CharacterSuppressionStatus.active` are all frozen *spellings* here, not-///   merely frozen references. Renaming a case, or reordering one whose raw-///   value is derived rather than written out, edits this file without touching-///   it.-///-///   `WorkType` is the one to watch: V9 dropped `Work.typeRaw`, so this-///   snapshot's default is the enum's **only** live referent. Nothing else in-///   the package reads it, which makes it look unused to every tool and to-///   every reader who has not read this paragraph. It is not — it is a frozen-///   persisted default, and it may not be edited or deleted while a store-///   recorded at 8.0.0 can still exist.-public enum AsterismSchemaV8: VersionedSchema {-    public static let versionIdentifier = Schema.Version(8, 0, 0)--    public static var models: [any PersistentModel.Type] {-        [Entry.self, Work.self, Site.self, TitlePattern.self, URLRulePattern.self,-         WorkTypeEntity.self, Character.self, CharacterSuppression.self,-         WorkSiteMembership.self, WorkDistinctPair.self]-    }-}--extension AsterismSchemaV8 {-    @Model-    public final class Entry {-        public var id: UUID = UUID()-        public var captureTitle: String = ""-        public var captureTitleSourceRaw: String = CaptureTitleSource.manual.rawValue-        public var rawURLString: String = ""-        public var canonicalURLString: String?-        public var hostname: String = ""-        public var site: Site?-        public var entryIdentityKey: String = ""-        public var identityKeyVersion: Int = 1-        public var conservativeIdentityKey: String = ""-        public var identityBasisRaw: String = EntryIdentityBasis.conservative.rawValue-        public var identityURLRuleID: UUID?-        public var identityURLRuleVersion: Int?-        public var identityNameTitleRuleID: UUID?-        public var identityNameTitleRuleVersion: Int?-        public var urlWorkIdentity: String?-        public var urlWorkRuleID: UUID?-        public var urlWorkRuleVersion: Int?-        public var chapterSequence: String?-        public var chapterSequenceRuleID: UUID?-        public var chapterSequenceRuleVersion: Int?-        public var chapterTitle: String?-        public var chapterTitleProvenanceRaw: String = FieldProvenanceKind.none.rawValue-        public var chapterPatternID: UUID?-        public var chapterPatternVersion: Int?-        public var note: String = ""-        public var ratingRaw: String?-        public var firstCapturedAt: Date = Date(timeIntervalSince1970: 0)-        public var lastSharedAt: Date = Date(timeIntervalSince1970: 0)-        public var modifiedAt: Date = Date(timeIntervalSince1970: 0)-        public var work: Work?-        public var workAssignmentProvenanceRaw: String = FieldProvenanceKind.none.rawValue-        public var workPatternID: UUID?-        public var workPatternVersion: Int?-        public var workURLRuleID: UUID?-        public var workURLRuleVersion: Int?-        public var workURLAssignmentKindRaw: String?-        public var intentionallyUnattached: Bool = false-        public var characterExtractionFingerprint: String?-        public var citationsData: Data?--        public init() {}-    }--    @Model-    public final class Work {-        public var id: UUID = UUID()-        public var displayTitle: String = ""-        public var lastParsedTitle: String?-        public var siteHostname: String = ""-        public var site: Site?-        public var urlIdentity: String?-        public var urlIdentityStateRaw: String = WorkURLIdentityState.none.rawValue-        public var urlIdentityRuleID: UUID?-        public var urlIdentityRuleVersion: Int?-        public var workURLString: String?-        public var genericNotes: String = ""-        public var typeRaw: String = WorkType.other.rawValue-        public var workTypeID: UUID?-        public var genreTags: [String] = []-        public var titleProvenanceRaw: String = TitleProvenance.manual.rawValue-        public var createdAt: Date = Date(timeIntervalSince1970: 0)-        public var modifiedAt: Date = Date(timeIntervalSince1970: 0)-        public var genericNotesExtractionFingerprint: String?-        @Relationship(deleteRule: .nullify, inverse: \Entry.work)-        public var entries: [Entry]?-        @Relationship(deleteRule: .nullify, inverse: \Character.work)-        public var characters: [Character]?-        @Relationship(deleteRule: .nullify, inverse: \CharacterSuppression.work)-        public var characterSuppressions: [CharacterSuppression]?-        @Relationship(deleteRule: .nullify, inverse: \WorkSiteMembership.work)-        public var siteMemberships: [WorkSiteMembership]? = []--        public init() {}-    }--    @Model-    public final class Site {-        public var hostname: String = ""-        public var displayName: String = ""-        public var modeRaw: String = SiteMode.untaught.rawValue-        @Relationship(deleteRule: .cascade, inverse: \TitlePattern.site)-        public var patterns: [TitlePattern]?-        @Relationship(deleteRule: .cascade, inverse: \URLRulePattern.site)-        public var urlRules: [URLRulePattern]?-        /// Inverse of `Entry.site`, present only because CloudKit requires every-        /// relationship to have one. Internal for the same reason the live class-        /// keeps it internal (Q17): traversing it faults every Entry for a-        /// hostname.-        @Relationship(deleteRule: .nullify, inverse: \Entry.site)-        var entries: [Entry]?-        /// Inverse of `Work.site`. Same reasoning as `entries`. **V9 drops both-        /// halves of this pair**, which is the one relationship change the-        /// V8 → V9 stage makes.-        @Relationship(deleteRule: .nullify, inverse: \Work.site)-        var works: [Work]?-        /// Inverse of `WorkSiteMembership.site`. Same reasoning again.-        @Relationship(deleteRule: .nullify, inverse: \WorkSiteMembership.site)-        var workMemberships: [WorkSiteMembership]?-        public var urlIdentityRule: URLIdentityRule?-        public var junkSuffixRule: JunkSuffixRule?--        public init() {}-    }--    @Model-    public final class TitlePattern {-        public var id: UUID = UUID()-        public var version: Int = 1-        public var isActive: Bool = false-        public var createdAt: Date = Date(timeIntervalSince1970: 0)-        public var formRaw: String = PatternForm.segment.rawValue-        public var segmentWorkAnchor: SegmentRangeSpec?-        public var segmentIgnoredAnchors: [SegmentPositionSpec]?-        public var phrasePrefix: String?-        public var phraseSeparator: String?-        public var phraseSuffix: String?-        public var fieldOrderRaw: String?-        public var trimPrefix: String?-        public var trimSuffix: String?-        public var chapterless: Bool = false-        public var definitionData: Data?-        public var site: Site?--        public init() {}-    }--    @Model-    public final class URLRulePattern {-        public var id: UUID = UUID()-        public var version: Int = 1-        public var isCurrent: Bool = false-        public var createdAt: Date = Date(timeIntervalSince1970: 0)-        public var originRaw: String = URLRuleOrigin.readerTaught.rawValue-        public var definitionData: Data = Data()-        public var site: Site?--        public init() {}-    }--    @Model-    public final class WorkTypeEntity {-        public var id: UUID = UUID()-        public var name: String = ""-        public var nameModifiedAt: Date = Date(timeIntervalSince1970: 0)-        public var stateRaw: String = WorkTypeState.active.rawValue-        public var stateModifiedAt: Date = Date(timeIntervalSince1970: 0)-        public var canonicalID: UUID?-        public var createdAt: Date = Date(timeIntervalSince1970: 0)-        public var modifiedAt: Date = Date(timeIntervalSince1970: 0)--        public init() {}-    }--    @Model-    public final class Character {-        public var id: UUID = UUID()-        public var name: String = ""-        public var nameKey: String = ""-        public var aliases: [String] = []-        public var note: String = ""-        public var factsData: Data?-        public var createdAt: Date = Date(timeIntervalSince1970: 0)-        public var modifiedAt: Date = Date(timeIntervalSince1970: 0)-        public var work: Work?--        public init() {}-    }--    @Model-    public final class CharacterSuppression {-        public var id: UUID = UUID()-        public var work: Work?-        public var kindRaw: String = CharacterSuppressionKind.candidate.rawValue-        public var nameKey: String = ""-        public var sourceKindRaw: String?-        public var sourceEntryID: UUID?-        public var evidence: String?-        public var statusRaw: String = CharacterSuppressionStatus.active.rawValue-        public var actionAt: Date = Date(timeIntervalSince1970: 0)--        public init() {}-    }--    @Model-    public final class WorkSiteMembership {-        public var id: UUID = UUID()-        public var hostname: String = ""-        public var createdAt: Date = Date(timeIntervalSince1970: 0)-        public var urlIdentity: String?-        public var urlIdentityStateRaw: String = WorkURLIdentityState.none.rawValue-        public var urlIdentityRuleID: UUID?-        public var workURLString: String?-        public var workID: UUID?-        public var work: Work?-        public var site: Site?--        public init() {}-    }--    @Model-    public final class WorkDistinctPair {-        public var id: UUID = UUID()-        public var lowerWorkID: UUID = UUID()-        public var higherWorkID: UUID = UUID()-        public var recordedAt: Date = Date(timeIntervalSince1970: 0)--        public init() {}-    }-}

diff --git a/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV9.swift b/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV9.swiftindex af16be9..98b8f54 100644--- a/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV9.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV9.swift@@ -1,24 +1,59 @@ import Foundation import SwiftData -/// The runtime schema. Its body is `Models.swift`, which opens-/// `extension AsterismSchemaV9`.+/// The frozen `drop-superseded-columns` schema — the shape every installed+/// library was written by before `work-and-reading-status`, and the `from`+/// version of the V9 → V10 lightweight stage. ///-/// V9 is V8 **minus** everything V8 superseded but could not drop. The-/// `WorkSiteMembership` row is a Work's site presence, the `Entry.citationsData`-/// blob is its citations and `TitlePattern.definitionData` is a pattern's-/// definition surface — so `Work`'s six site/identity/URL columns and its-/// `typeRaw`, `Entry.identityKeyVersion` and its seventeen citation columns,-/// `TitlePattern`'s ten definition columns and `Site.urlIdentityRule` are gone,-/// along with the `Work.site` ↔ `Site.works` inverse pair.+/// V9 was V8 **minus** everything V8 superseded but could not drop: `Work`'s six+/// site/identity/URL columns and its `typeRaw`, `Entry.identityKeyVersion` and+/// its seventeen citation/provenance columns, `TitlePattern`'s ten definition+/// columns, `Site.urlIdentityRule`, and the `Work.site` ↔ `Site.works` inverse+/// pair. Nothing here names any of them; this is the narrowed shape they left+/// behind, and V10 adds three `Work` columns to it. ///-/// The drop is safe only because the population it undoes is finished: the-/// readiness marker read `"8"` on every device before this schema shipped, which-/// is `V8PopulationPass`'s completion certificate (decision_log.md Q2 of-/// `drop-superseded-columns`). The pass itself is deleted — it had nothing left-/// to convert from.+/// V9 is frozen for the same reason V5, V6, V7 and V8 were: *any* edit to its+/// body makes a V9-recorded store refuse to open with `NSCocoaErrorDomain`+/// 134504, "Cannot use staged migration with an unknown model version". The live+/// classes therefore moved to `AsterismSchemaV10`, and this declaration exists+/// only to give `AsterismV10MigrationPlan` a `from` version — and to let+/// `V9RecordedStoreFixture` seed a genuinely 9.0.0-recorded store in-process. ///-/// The entity *list* is unchanged: V9 adds no table and removes none.+/// The classes are nested so they can carry the same SwiftData entity names+/// ("Entry", "Site", …) as the live V10 classes without a top-level collision:+/// the only top-level references are typealiases, and two *top-level* `@Model`s+/// sharing an entity name crash `ModelContext`+/// (`docs/agent-notes/schema-migration.md`). Nothing reads a V9-shaped object at+/// runtime, so these carry stored columns only — no accessors, no business+/// logic.+///+/// # These snapshots are frozen *by reference*, not only by file+///+/// The nesting freezes the class bodies; it does **not** freeze anything a body+/// *names*. Editing one of those changes the stored shape of this frozen schema+/// silently — and that is exactly what makes a recorded store refuse to open+/// (134504). Two families of referent, both live and both shared with V10:+///+/// * **The stored value types.** `JunkSuffixRule` is a top-level type in+///   `ValueObjects.swift`; its stored properties are this schema's stored+///   properties. (`URLIdentityRule`, `SegmentRangeSpec` and `SegmentPositionSpec`+///   were V8's, on columns V9 dropped, and are no longer named by any snapshot.)+/// * **Every enum whose raw value is baked into a default.** A default is part+///   of the shape, so `CaptureTitleSource.manual.rawValue`,+///   `EntryIdentityBasis.conservative.rawValue`, `TitleProvenance.manual`,+///   `SiteMode.untaught.rawValue`, `URLRuleOrigin.readerTaught`,+///   `WorkTypeState.active`, `CharacterSuppressionKind.candidate`,+///   `CharacterSuppressionStatus.active` and `WorkURLIdentityState.none` are all+///   frozen *spellings* here, not merely frozen references. Renaming a case, or+///   reordering one whose raw value is derived rather than written out, edits+///   this file without touching it.+///+///   V10 adds two more of these to the live `Work` —+///   `WorkStatus.ongoing.rawValue` and `ReadingStatus.reading.rawValue`, the+///   defaults the V9 → V10 stage fills every existing row with. They are not in+///   *this* snapshot, and they become frozen spellings the moment V10 is frozen+///   in its turn; `work-and-reading-status`'s design says so, so the next freeze+///   does not have to rediscover it. public enum AsterismSchemaV9: VersionedSchema {     public static let versionIdentifier = Schema.Version(9, 0, 0) @@ -29,31 +64,174 @@ public enum AsterismSchemaV9: VersionedSchema {     } } -/// The migration plan: `[V8, V9]`, one lightweight stage.-///-/// **Every stage below V8 is retired** (decision_log.md Q2 of-/// `drop-superseded-columns`). Every device is confirmed at marker `"8"`, which-/// is `retire-migration-chain` Decision 6's population precondition for each of-/// them, so `AsterismSchemaV5`, `AsterismSchemaV6` and `AsterismSchemaV7` went-/// with the stages that named them. A store older than V8 fails closed —-/// `NSCocoaErrorDomain` 134504, "Cannot use staged migration with an unknown-/// model version" — and the recovery is the backup archive, which is what-/// `V4RecordedStoreTests` pins.-///-/// The single stage is `.lightweight`. **This is the first stage that removes-/// anything**: 36 attributes and one inverse relationship pair. It runs inside-/// `ModelContainer.init`, which is why the columns had to be unwritten and every-/// reader moved onto the blob and the membership *before* this schema existed —-/// the conversion has no chance to read what it is about to destroy. `.custom`-/// is not an option: a custom stage would also run inside the share extension,-/// which must never migrate, and the extension is kept out by the marker instead-/// (Q3).-public enum AsterismV9MigrationPlan: SchemaMigrationPlan {-    public static var schemas: [any VersionedSchema.Type] {-        [AsterismSchemaV8.self, AsterismSchemaV9.self]-    }--    public static var stages: [MigrationStage] {-        [.lightweight(fromVersion: AsterismSchemaV8.self, toVersion: AsterismSchemaV9.self)]+extension AsterismSchemaV9 {+    @Model+    public final class Entry {+        public var id: UUID = UUID()+        public var captureTitle: String = ""+        public var captureTitleSourceRaw: String = CaptureTitleSource.manual.rawValue+        public var rawURLString: String = ""+        public var canonicalURLString: String?+        public var hostname: String = ""+        public var site: Site?+        public var entryIdentityKey: String = ""+        public var conservativeIdentityKey: String = ""+        public var identityBasisRaw: String = EntryIdentityBasis.conservative.rawValue+        public var urlWorkIdentity: String?+        public var chapterSequence: String?+        public var chapterTitle: String?+        public var note: String = ""+        public var ratingRaw: String?+        public var firstCapturedAt: Date = Date(timeIntervalSince1970: 0)+        public var lastSharedAt: Date = Date(timeIntervalSince1970: 0)+        public var modifiedAt: Date = Date(timeIntervalSince1970: 0)+        public var work: Work?+        public var intentionallyUnattached: Bool = false+        public var characterExtractionFingerprint: String?+        public var citationsData: Data?++        public init() {}+    }++    @Model+    public final class Work {+        public var id: UUID = UUID()+        public var displayTitle: String = ""+        public var lastParsedTitle: String?+        public var genericNotes: String = ""+        public var workTypeID: UUID?+        public var genreTags: [String] = []+        public var titleProvenanceRaw: String = TitleProvenance.manual.rawValue+        public var createdAt: Date = Date(timeIntervalSince1970: 0)+        public var modifiedAt: Date = Date(timeIntervalSince1970: 0)+        public var genericNotesExtractionFingerprint: String?+        @Relationship(deleteRule: .nullify, inverse: \Entry.work)+        public var entries: [Entry]?+        @Relationship(deleteRule: .nullify, inverse: \Character.work)+        public var characters: [Character]?+        @Relationship(deleteRule: .nullify, inverse: \CharacterSuppression.work)+        public var characterSuppressions: [CharacterSuppression]?+        @Relationship(deleteRule: .nullify, inverse: \WorkSiteMembership.work)+        public var siteMemberships: [WorkSiteMembership]? = []++        public init() {}+    }++    @Model+    public final class Site {+        public var hostname: String = ""+        public var displayName: String = ""+        public var modeRaw: String = SiteMode.untaught.rawValue+        @Relationship(deleteRule: .cascade, inverse: \TitlePattern.site)+        public var patterns: [TitlePattern]?+        @Relationship(deleteRule: .cascade, inverse: \URLRulePattern.site)+        public var urlRules: [URLRulePattern]?+        /// Inverse of `Entry.site`, present only because CloudKit requires every+        /// relationship to have one. Internal for the same reason the live class+        /// keeps it internal (Q17): traversing it faults every Entry for a+        /// hostname.+        @Relationship(deleteRule: .nullify, inverse: \Entry.site)+        var entries: [Entry]?+        /// Inverse of `WorkSiteMembership.site`. Same reasoning again.+        @Relationship(deleteRule: .nullify, inverse: \WorkSiteMembership.site)+        var workMemberships: [WorkSiteMembership]?+        public var junkSuffixRule: JunkSuffixRule?++        public init() {}+    }++    @Model+    public final class TitlePattern {+        public var id: UUID = UUID()+        public var version: Int = 1+        public var isActive: Bool = false+        public var createdAt: Date = Date(timeIntervalSince1970: 0)+        public var definitionData: Data?+        public var site: Site?++        public init() {}+    }++    @Model+    public final class URLRulePattern {+        public var id: UUID = UUID()+        public var version: Int = 1+        public var isCurrent: Bool = false+        public var createdAt: Date = Date(timeIntervalSince1970: 0)+        public var originRaw: String = URLRuleOrigin.readerTaught.rawValue+        public var definitionData: Data = Data()+        public var site: Site?++        public init() {}+    }++    @Model+    public final class WorkTypeEntity {+        public var id: UUID = UUID()+        public var name: String = ""+        public var nameModifiedAt: Date = Date(timeIntervalSince1970: 0)+        public var stateRaw: String = WorkTypeState.active.rawValue+        public var stateModifiedAt: Date = Date(timeIntervalSince1970: 0)+        public var canonicalID: UUID?+        public var createdAt: Date = Date(timeIntervalSince1970: 0)+        public var modifiedAt: Date = Date(timeIntervalSince1970: 0)++        public init() {}+    }++    @Model+    public final class Character {+        public var id: UUID = UUID()+        public var name: String = ""+        public var nameKey: String = ""+        public var aliases: [String] = []+        public var note: String = ""+        public var factsData: Data?+        public var createdAt: Date = Date(timeIntervalSince1970: 0)+        public var modifiedAt: Date = Date(timeIntervalSince1970: 0)+        public var work: Work?++        public init() {}+    }++    @Model+    public final class CharacterSuppression {+        public var id: UUID = UUID()+        public var work: Work?+        public var kindRaw: String = CharacterSuppressionKind.candidate.rawValue+        public var nameKey: String = ""+        public var sourceKindRaw: String?+        public var sourceEntryID: UUID?+        public var evidence: String?+        public var statusRaw: String = CharacterSuppressionStatus.active.rawValue+        public var actionAt: Date = Date(timeIntervalSince1970: 0)++        public init() {}+    }++    @Model+    public final class WorkSiteMembership {+        public var id: UUID = UUID()+        public var hostname: String = ""+        public var createdAt: Date = Date(timeIntervalSince1970: 0)+        public var urlIdentity: String?+        public var urlIdentityStateRaw: String = WorkURLIdentityState.none.rawValue+        public var urlIdentityRuleID: UUID?+        public var workURLString: String?+        public var workID: UUID?+        public var work: Work?+        public var site: Site?++        public init() {}+    }++    @Model+    public final class WorkDistinctPair {+        public var id: UUID = UUID()+        public var lowerWorkID: UUID = UUID()+        public var higherWorkID: UUID = UUID()+        public var recordedAt: Date = Date(timeIntervalSince1970: 0)++        public init() {}     } }

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupArchiveProjection.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupArchiveProjection.swiftindex 6e1d817..97535b3 100644--- a/Packages/AsterismCore/Sources/AsterismCore/BackupArchiveProjection.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/BackupArchiveProjection.swift@@ -4,7 +4,7 @@ import SwiftData  private let exportLogger = Logger(subsystem: "AsterismCore", category: "BackupExport") -// The record projection every 8/9 export runs through, and the three refusals it+// The record projection every 9/10 export runs through, and the three refusals it // names. It stood in the 4/4 exporter while three generations shared it; // those generations are gone and this is the live export path, so it stands on // its own.@@ -15,14 +15,14 @@ private let exportLogger = Logger(subsystem: "AsterismCore", category: "BackupEx /// the Work mapper, plus the identity groups it needs. internal struct ArchiveCommonProjection {     let groups: BackupGroupProjection.Projection-    let entries: [BackupV8Entry]-    let sites: [BackupV8Site]-    let titlePatterns: [BackupV8TitlePattern]-    let urlRules: [BackupV8URLRule]+    let entries: [BackupV9Entry]+    let sites: [BackupV9Site]+    let titlePatterns: [BackupV9TitlePattern]+    let urlRules: [BackupV9URLRule]     /// One record per Work and hostname (Req 9.1), enumerated whole rather than     /// works→children (Q17): a membership whose Work has not arrived exports     /// naming the Work it belongs to instead of vanishing from the backup.-    let memberships: [BackupV8Membership]+    let memberships: [BackupV9Membership] }  /// Every Entry row's citations, decoded **once** for the whole projection.@@ -125,7 +125,7 @@ extension LibraryRepository {         var additionalPatterns: [String: [TitlePattern]] = [:]         for pattern in archivablePatterns where pattern.site == nil {             guard let hostname = citers[pattern.id] else {-                throw BackupV8ExportError.referencesStillArriving(+                throw BackupV9ExportError.referencesStillArriving(                     detail: "title rule \(pattern.id) has no site and no entry naming one")             }             additionalPatterns[hostname, default: []].append(pattern)@@ -133,7 +133,7 @@ extension LibraryRepository {         var additionalURLRules: [String: [URLRulePattern]] = [:]         for rule in archivableURLRules where rule.site == nil {             guard let hostname = citers[rule.id] else {-                throw BackupV8ExportError.referencesStillArriving(+                throw BackupV9ExportError.referencesStillArriving(                     detail: "URL rule \(rule.id) has no site and no record naming one")             }             additionalURLRules[hostname, default: []].append(rule)@@ -160,25 +160,25 @@ extension LibraryRepository {             ruleMembership: .oneRowPerIdentityGroup)         try requireProjectedTuplesRepresentable(projected) -        var wireSites: [BackupV8Site] = []-        var wirePatterns: [BackupV8TitlePattern] = []-        var wireRules: [BackupV8URLRule] = []+        var wireSites: [BackupV9Site] = []+        var wirePatterns: [BackupV9TitlePattern] = []+        var wireRules: [BackupV9URLRule] = []         for site in projected {-            wireSites.append(mapV8SiteRecord(site))+            wireSites.append(mapV9SiteRecord(site))             for projectedPattern in site.patterns             where !omittedTitlePatternIDs.contains(projectedPattern.pattern.id) {                 wirePatterns.append(-                    try mapV8TitlePatternRecord(projectedPattern, hostname: site.hostname))+                    try mapV9TitlePatternRecord(projectedPattern, hostname: site.hostname))             }             for projectedRule in site.urlRules             where !omittedURLRuleIDs.contains(projectedRule.rule.id) {-                wireRules.append(try mapV8URLRuleRecord(projectedRule, hostname: site.hostname))+                wireRules.append(try mapV9URLRuleRecord(projectedRule, hostname: site.hostname))             }         }          return ArchiveCommonProjection(             groups: groups,-            entries: try groups.entries.map { try mapV8EntryRecord($0, citations: citations) },+            entries: try groups.entries.map { try mapV9EntryRecord($0, citations: citations) },             sites: wireSites.sorted { $0.hostname < $1.hostname },             titlePatterns: wirePatterns.sorted { $0.id.uuidString < $1.id.uuidString },             urlRules: wireRules.sorted { $0.id.uuidString < $1.id.uuidString },@@ -191,8 +191,9 @@ extension LibraryRepository {     /// they read it — several of them coerce (`?? .conservative`) rather than     /// throw, and a coerced value is silent data loss in a backup.     ///-    /// A Work's `typeRaw` is deliberately absent (Q8, Q34): V8 derives a type-    /// from the work-type identity alone, so the column is not read at all.+    /// A Work's `typeRaw` is deliberately absent (Q8, Q34): the live schema+    /// (since V8) derives a type from the work-type identity alone, so the+    /// column is not read at all.     ///     /// The Entry's three provenance raws used to be checked here, because a row     /// whose `citationsData` was nil fell back to the columns and read all three@@ -220,7 +221,7 @@ extension LibraryRepository {             // than reached by a mapper that would throw a raw `DecodingError`.             do { _ = try citations.value(of: entry) }             catch {-                throw BackupV8ExportError.unrepresentableValue(+                throw BackupV9ExportError.unrepresentableValue(                     record: record, field: "citations", value: String(describing: error))             }         }@@ -228,6 +229,14 @@ extension LibraryRepository {             let record = "Work \(work.id)"             try require(TitleProvenance(rawValue: work.titleProvenanceRaw),                 record, "title provenance", work.titleProvenanceRaw)+            // Req 8.3. Both accessors read through `ToleratedEnum` so the app+            // can present a spelling a newer build wrote (Req 1.3, 2.7); the+            // archive may not, because writing the default back would record a+            // status the reader never chose as though they had.+            try require(WorkStatus(rawValue: work.workStatusRaw),+                record, "work status", work.workStatusRaw)+            try require(ReadingStatus(rawValue: work.readingStatusRaw),+                record, "reading status", work.readingStatusRaw)         }         for membership in memberships {             // The identity state moved to the membership with the value it@@ -244,13 +253,14 @@ extension LibraryRepository {         }         for pattern in patterns {             let record = "Title rule \(pattern.id)"-            // V8 stores the whole arm as one blob (Q25), so the form is derived-            // rather than a raw column of its own: a definition that decodes is-            // a form the wire can spell, and one that does not is named here by-            // its bytes rather than by a `formRaw` that no longer exists.+            // The live schema has stored the whole arm as one blob since V8+            // (Q25), so the form is derived rather than a raw column of its+            // own: a definition that decodes is a form the wire can spell, and+            // one that does not is named here by its bytes rather than by a+            // `formRaw` that no longer exists.             do { _ = try pattern.storedDefinition }             catch {-                throw BackupV8ExportError.unrepresentableValue(+                throw BackupV9ExportError.unrepresentableValue(                     record: record, field: "definition", value: String(describing: error))             }         }@@ -288,7 +298,7 @@ extension LibraryRepository {         var omitted: Set<UUID> = []         for (id, rule) in unreadable.sorted(by: { $0.key.uuidString < $1.key.uuidString }) {             guard !cited.contains(id) else {-                throw BackupV8ExportError.unrepresentableValue(+                throw BackupV9ExportError.unrepresentableValue(                     record: "URL rule \(id)", field: "definition",                     value: "\(rule.definitionData.count) bytes that do not decode")             }@@ -339,7 +349,7 @@ extension LibraryRepository {         var omitted: Set<UUID> = []         for (id, pattern) in unreadable.sorted(by: { $0.key.uuidString < $1.key.uuidString }) {             guard !pattern.isActive, !cited.contains(id) else {-                throw BackupV8ExportError.unrepresentableValue(+                throw BackupV9ExportError.unrepresentableValue(                     record: "Title rule \(id)", field: "definition",                     value: pattern.definitionData.map { "\($0.count) bytes that do not decode" }                         ?? "no stored definition")@@ -395,7 +405,7 @@ extension LibraryRepository {         _ value: Value?, _ record: String, _ field: String, _ raw: String     ) throws {         guard value == nil else { return }-        throw BackupV8ExportError.unrepresentableValue(record: record, field: field, value: raw)+        throw BackupV9ExportError.unrepresentableValue(record: record, field: field, value: raw)     }      /// Req 3.7's third face: a hostname whose *projected* tuple the archive@@ -421,7 +431,7 @@ extension LibraryRepository {             switch site.mode {             case .taught:                 guard activePatterns != 1 else { continue }-                throw BackupV8ExportError.referencesStillArriving(+                throw BackupV9ExportError.referencesStillArriving(                     detail: "site \(site.hostname) is taught, and the one active title rule "                         + "that state needs is not in the library")             case .untaught:@@ -429,12 +439,12 @@ extension LibraryRepository {                     $0.rule.origin == .importedV2 && !$0.isCurrent                 }                 guard !site.patterns.isEmpty || currentRules > 0 || !historyOnly else { continue }-                throw BackupV8ExportError.referencesStillArriving(+                throw BackupV9ExportError.referencesStillArriving(                     detail: "site \(site.hostname) is untaught while still holding rules, "                         + "so the teaching that owns them has not arrived")             case .articles:                 guard activePatterns > 0 || currentRules > 0 else { continue }-                throw BackupV8ExportError.referencesStillArriving(+                throw BackupV9ExportError.referencesStillArriving(                     detail: "site \(site.hostname) reads as articles while still holding an "                         + "active rule, so the change that cleared them has not arrived")             }@@ -455,10 +465,10 @@ extension LibraryRepository {     /// problem surfacing as a broken file, which is exactly what this gate     /// exists to say first.     internal static func requireCitationsResolve(-        entries: [BackupV8Entry],-        memberships: [BackupV8Membership],-        titlePatterns: [BackupV8TitlePattern],-        urlRules: [BackupV8URLRule]+        entries: [BackupV9Entry],+        memberships: [BackupV9Membership],+        titlePatterns: [BackupV9TitlePattern],+        urlRules: [BackupV9URLRule]     ) throws {         let rulesByID = Dictionary(urlRules.map { ($0.id, $0) }, uniquingKeysWith: { lhs, _ in lhs })         let patternHostnames = Dictionary(@@ -498,14 +508,14 @@ extension LibraryRepository {      private static func crossSiteCitation(         _ record: String, _ field: String, taughtFor hostname: String-    ) -> BackupV8ExportError {+    ) -> BackupV9ExportError {         .referencesStillArriving(             detail: "\(record) names \(field), which is taught for \(hostname)")     }      private static func missingCitation(         _ record: String, _ field: String-    ) -> BackupV8ExportError {+    ) -> BackupV9ExportError {         .referencesStillArriving(             detail: "\(record) names \(field), which the library does not hold")     }@@ -533,7 +543,7 @@ extension LibraryRepository {         return map     } -    // MARK: - V8 Record Mappers+    // MARK: - V9 Record Mappers      /// The record an Entry identity group archives as (Req 8.2): the     /// representative row's capture evidence, the **group's** authored content,@@ -552,9 +562,9 @@ extension LibraryRepository {     /// a citation of a rule the projection renumbered was archived at the     /// version the archive actually held (Decision 7). A citation is a UUID     /// (T-2281) and nothing renumbers, so the map and the parameter are gone.-    internal static func mapV8EntryRecord(+    internal static func mapV9EntryRecord(         _ group: EntryGroup, citations cache: EntryCitationsCache-    ) throws -> BackupV8Entry {+    ) throws -> BackupV9Entry {         let snap = try snapshot(group)         let entry = group.representative         let carrier = group.carrier@@ -564,7 +574,7 @@ extension LibraryRepository {             citations.chapterTitle = carried.chapterTitle             citations.workAssignment = carried.workAssignment         }-        return BackupV8Entry(+        return BackupV9Entry(             id: snap.id,             captureTitle: snap.captureTitle,             captureTitleSource: snap.captureTitleSource,@@ -607,11 +617,11 @@ extension LibraryRepository {     /// pointer to an entry the library does not hold exports verbatim with     /// `typeName: nil` (Q24) — refusing there would fail an export at exactly     /// the moment sync has not settled.-    internal static func mapV8WorkRecord(+    internal static func mapV9WorkRecord(         _ group: WorkGroup,         canonicalWorkIDs: [UUID: UUID],         types: WorkTypeDirectory-    ) throws -> BackupV8Work {+    ) throws -> BackupV9Work {         let snap = try snapshot(group, canonicalWorkIDs: canonicalWorkIDs, types: types)         let assignment = WorkTypeAssignment.assignment(of: group.carrier)         let workTypeID: UUID?@@ -622,13 +632,18 @@ extension LibraryRepository {         case .configured(let id):             (workTypeID, typeName) = (id, types.resolve(id)?.name)         }-        return BackupV8Work(+        return BackupV9Work(             id: snap.id,             displayTitle: snap.displayTitle,             lastParsedTitle: snap.lastParsedTitle,             genericNotes: snap.genericNotes,             genreTags: snap.genreTags,             titleProvenance: snap.titleProvenance,+            // Req 8.1: the carrier's three, as `snapshot` already resolved them+            // for a split group (Req 7.2).+            workStatus: snap.workStatus,+            readingStatus: snap.readingStatus,+            verdict: snap.verdict,             workTypeID: workTypeID,             typeName: typeName,             createdAt: snap.createdAt,@@ -653,7 +668,7 @@ extension LibraryRepository {     /// there.     private static func mapMembershipRecords(         _ rows: [WorkSiteMembership]-    ) -> [BackupV8Membership] {+    ) -> [BackupV9Membership] {         var byKey: [MembershipReconciler.Key: [WorkSiteMembership]] = [:]         var unattributed: [WorkSiteMembership] = []         for row in rows {@@ -664,8 +679,8 @@ extension LibraryRepository {             byKey[MembershipReconciler.Key(workID: workID, hostname: row.hostname), default: []]                 .append(row)         }-        func record(_ row: WorkSiteMembership, workURLString: String?) -> BackupV8Membership {-            BackupV8Membership(+        func record(_ row: WorkSiteMembership, workURLString: String?) -> BackupV9Membership {+            BackupV9Membership(                 id: row.id, workID: row.resolvedWorkID, hostname: row.hostname,                 createdAt: row.createdAt, urlIdentity: row.urlIdentity,                 urlIdentityState: row.urlIdentityState,@@ -680,7 +695,7 @@ extension LibraryRepository {         // [4.2](../../../../specs/wrong-host-work-url-heal/requirements.md#42)         // cannot survive. Nothing is written back: the fold returns the value         // and the record carries it (Q54).-        var records: [BackupV8Membership] = []+        var records: [BackupV9Membership] = []         for rows in byKey.values {             let ordered = MembershipReconciler.survivorFirst(rows)             guard let keeper = ordered.first else { continue }@@ -709,7 +724,7 @@ extension LibraryRepository {     /// nothing: a Work is not distinct from itself.     internal static func projectDistinctPairs(         context: ModelContext-    ) throws -> [BackupV8DistinctPair] {+    ) throws -> [BackupV9DistinctPair] {         var byKey: [WorkPairKey: [WorkDistinctPair]] = [:]         for row in try context.fetch(FetchDescriptor<WorkDistinctPair>())         where row.lowerWorkID != row.higherWorkID {@@ -721,7 +736,7 @@ extension LibraryRepository {             guard let survivor = MembershipReconciler.survivorFirstPairs(rows).first else {                 return nil             }-            return BackupV8DistinctPair(+            return BackupV9DistinctPair(                 id: survivor.id, lowerWorkID: key.lower, higherWorkID: key.higher,                 recordedAt: survivor.recordedAt)         }@@ -731,10 +746,10 @@ extension LibraryRepository {     /// The wire Site for a hostname: exactly one, whatever the store holds     /// (Q38). It names no children (Req 9.3) — the union still decides which     /// rules are archived, and each of them names this hostname back.-    internal static func mapV8SiteRecord(+    internal static func mapV9SiteRecord(         _ projected: SiteUnionProjection.ProjectedSite-    ) -> BackupV8Site {-        BackupV8Site(+    ) -> BackupV9Site {+        BackupV9Site(             hostname: projected.hostname,             displayName: projected.displayName,             mode: projected.mode,@@ -742,10 +757,10 @@ extension LibraryRepository {         )     } -    internal static func mapV8TitlePatternRecord(+    internal static func mapV9TitlePatternRecord(         _ projected: SiteUnionProjection.ProjectedTitlePattern, hostname: String-    ) throws -> BackupV8TitlePattern {-        BackupV8TitlePattern(+    ) throws -> BackupV9TitlePattern {+        BackupV9TitlePattern(             id: projected.pattern.id,             siteHostname: hostname,             // The version stored on the row the per-UUID reduction kept, without@@ -760,17 +775,17 @@ extension LibraryRepository {     /// `throws` because the definition does (Req 4.5): the mapper needs a typed     /// `URLRuleDefinition` for every row it writes, so a row that will not     /// decode cannot be archived at all.-    internal static func mapV8URLRuleRecord(+    internal static func mapV9URLRuleRecord(         _ projected: SiteUnionProjection.ProjectedURLRule, hostname: String-    ) throws -> BackupV8URLRule {+    ) throws -> BackupV9URLRule {         let definition: URLRuleDefinition         do { definition = try projected.rule.definition }         catch {-            throw BackupV8ExportError.unrepresentableValue(+            throw BackupV9ExportError.unrepresentableValue(                 record: "URL rule \(projected.rule.id)", field: "definition",                 value: "\(projected.rule.definitionData.count) bytes that do not decode")         }-        return BackupV8URLRule(+        return BackupV9URLRule(             id: projected.rule.id,             version: projected.rule.version,             isCurrent: projected.isCurrent,

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupArchiveReferenceChecks.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupArchiveReferenceChecks.swiftindex 1718cdc..4b53ab3 100644--- a/Packages/AsterismCore/Sources/AsterismCore/BackupArchiveReferenceChecks.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/BackupArchiveReferenceChecks.swift@@ -24,13 +24,13 @@ internal enum BackupArchiveReferenceChecks {     ///   refusal — the one message here that has to say which archive format it     ///   is talking about.     static func validate(-        entries: [BackupV8Entry],-        works: [BackupV8Work],-        memberships: [BackupV8Membership],-        distinctPairs: [BackupV8DistinctPair],-        sites: [BackupV8Site],-        titlePatterns: [BackupV8TitlePattern],-        urlRules: [BackupV8URLRule],+        entries: [BackupV9Entry],+        works: [BackupV9Work],+        memberships: [BackupV9Membership],+        distinctPairs: [BackupV9DistinctPair],+        sites: [BackupV9Site],+        titlePatterns: [BackupV9TitlePattern],+        urlRules: [BackupV9URLRule],         formatLabel: String     ) throws {         let siteHostnames = Set(sites.map(\.hostname))@@ -138,9 +138,9 @@ internal enum BackupArchiveReferenceChecks {     // MARK: Site closed tuple (supersedes M3 8.1)      private static func validateSiteTuple(-        _ site: BackupV8Site,-        patterns: [BackupV8TitlePattern],-        rules: [BackupV8URLRule]+        _ site: BackupV9Site,+        patterns: [BackupV9TitlePattern],+        rules: [BackupV9URLRule]     ) throws {         let id = site.hostname         guard !M2Unicode.isBlank(site.hostname) else { throw invalid("Site", id, "hostname is blank") }@@ -205,9 +205,9 @@ internal enum BackupArchiveReferenceChecks {     /// (Req 9.5, Q22); its own tuple is still checked, because an orphan is a     /// row like any other.     private static func validateMembership(-        _ membership: BackupV8Membership,+        _ membership: BackupV9Membership,         siteHostnames: Set<String>,-        rulesByID: [UUID: BackupV8URLRule]+        rulesByID: [UUID: BackupV9URLRule]     ) throws {         let id = membership.id.uuidString         guard !M2Unicode.isBlank(membership.hostname) else {@@ -236,12 +236,12 @@ internal enum BackupArchiveReferenceChecks {     // MARK: Entry (Entry-state enumeration, supersedes M3 8.12)      private static func validateEntry(-        _ entry: BackupV8Entry,+        _ entry: BackupV9Entry,         siteHostnames: Set<String>,         workIDs: Set<UUID>,         hostnamesByWork: [UUID: Set<String>],-        patternsByID: [UUID: BackupV8TitlePattern],-        rulesByID: [UUID: BackupV8URLRule]+        patternsByID: [UUID: BackupV9TitlePattern],+        rulesByID: [UUID: BackupV9URLRule]     ) throws {         let id = entry.id.uuidString         guard siteHostnames.contains(entry.hostname) else {@@ -322,15 +322,15 @@ internal enum BackupArchiveReferenceChecks {     /// dangling citation is an unresolved reference — so the predicate is stated     /// once and each caller names its own failure.     private static func resolvesSameSite(-        _ cited: CitedRule, entry: BackupV8Entry, rulesByID: [UUID: BackupV8URLRule]+        _ cited: CitedRule, entry: BackupV9Entry, rulesByID: [UUID: BackupV9URLRule]     ) -> Bool {         rulesByID[cited.id]?.siteHostname == entry.hostname     }      private static func requireSameSiteRule(         _ cited: CitedRule,-        entry: BackupV8Entry,-        rulesByID: [UUID: BackupV8URLRule]+        entry: BackupV9Entry,+        rulesByID: [UUID: BackupV9URLRule]     ) throws {         guard resolvesSameSite(cited, entry: entry, rulesByID: rulesByID) else {             throw invalid(@@ -340,10 +340,10 @@ internal enum BackupArchiveReferenceChecks {     }      private static func validateEntryRuleReference(-        _ entry: BackupV8Entry,+        _ entry: BackupV9Entry,         field: String,         cited: CitedRule?,-        rulesByID: [UUID: BackupV8URLRule]+        rulesByID: [UUID: BackupV9URLRule]     ) throws {         guard let cited else { return }         guard resolvesSameSite(cited, entry: entry, rulesByID: rulesByID) else {

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupExporter.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupExporter.swiftindex 85d1ada..4c8782b 100644--- a/Packages/AsterismCore/Sources/AsterismCore/BackupExporter.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/BackupExporter.swift@@ -1,7 +1,7 @@ import Foundation  /// The file a completed backup export produced, handed to the share sheet and-/// cleaned up afterwards. `BackupV8Exporter` is the only producer.+/// cleaned up afterwards. `BackupV9Exporter` is the only producer. public struct BackupExportResult: Sendable {     public let fileURL: URL 

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupGroupProjection.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupGroupProjection.swiftindex f3d00d4..1c9df35 100644--- a/Packages/AsterismCore/Sources/AsterismCore/BackupGroupProjection.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/BackupGroupProjection.swift@@ -72,7 +72,7 @@ enum BackupGroupProjection {         let characters: [CharacterGroup]     } -    /// - Throws: `BackupV8ExportError.tornGroups` when the store holds a torn+    /// - Throws: `BackupV9ExportError.tornGroups` when the store holds a torn     ///   group — the biconditional of Req 8.1, since nothing else here refuses.     /// - Parameter distinctPairs: the reader's recorded "not the same work"     ///   dismissals (Req 5.6). **Not defaulted**: an export that cannot see them@@ -103,7 +103,7 @@ enum BackupGroupProjection {         // no site at all and a torn character would export one variant silently.         let tornCharacters = characterGroups.values.filter(\.isTorn)         guard tornEntries.isEmpty, tornWorks.isEmpty, tornCharacters.isEmpty else {-            throw BackupV8ExportError.tornGroups(+            throw BackupV9ExportError.tornGroups(                 tornGroupsPayload(                     tornEntries: tornEntries, tornWorks: tornWorks,                     tornCharacters: tornCharacters,

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupImportCharacters.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupImportCharacters.swiftindex 0b1a12d..1436f82 100644--- a/Packages/AsterismCore/Sources/AsterismCore/BackupImportCharacters.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/BackupImportCharacters.swift@@ -116,7 +116,7 @@ extension LibraryRepository {     /// `nameKey` travels rather than being re-derived: it is retained through     /// renames (Q19/Q46), and recomputing it from `name` would silently re-key     /// every character an archive restored.-    internal static func apply(_ record: BackupV8Character, to character: CharacterRecord) {+    internal static func apply(_ record: BackupV9Character, to character: CharacterRecord) {         character.name = record.name         character.nameKey = record.nameKey         character.aliases = record.aliases@@ -126,7 +126,7 @@ extension LibraryRepository {         character.modifiedAt = record.modifiedAt     } -    internal static func apply(_ record: BackupV8Suppression, to row: CharacterSuppression) {+    internal static func apply(_ record: BackupV9Suppression, to row: CharacterSuppression) {         row.kindRaw = record.kindRaw         row.nameKey = record.nameKey         row.sourceKindRaw = record.sourceKindRaw

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupImportWorkTypes.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupImportWorkTypes.swiftindex e74caf8..6f2e5d3 100644--- a/Packages/AsterismCore/Sources/AsterismCore/BackupImportWorkTypes.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/BackupImportWorkTypes.swift@@ -31,8 +31,8 @@ extension LibraryRepository {     ///     restore of an entry this library already held. That one write is the     ///     reader acting now, and it has to assert over a removal older than it.     internal static func mergeImportedWorkTypes(-        workTypes: [BackupV8WorkType],-        works: [BackupV8Work],+        workTypes: [BackupV9WorkType],+        works: [BackupV9Work],         exportedAt: Date,         importedAt: Date,         context: ModelContext,@@ -171,7 +171,7 @@ extension LibraryRepository {     /// Returned in identifier order, so an interrupted import resumes into the     /// same shape on any device.     private static func archivedTypeIdentities(-        _ records: [BackupV8WorkType]+        _ records: [BackupV9WorkType]     ) -> [ArchivedTypeIdentity] {         let directory = WorkTypeDirectory(             rows: records.map {@@ -266,7 +266,7 @@ extension LibraryRepository {     /// A citation with no snapshot is deliberately absent: it stays on the work     /// as unresolved rather than being invented a name (Q24).     private static func unresolvedTypeCitations(-        _ works: [BackupV8Work], in local: WorkTypeDirectory+        _ works: [BackupV9Work], in local: WorkTypeDirectory     ) -> [ArchivedTypeCitation] {         var seen: Set<UUID> = []         var citations: [ArchivedTypeCitation] = []