Pre-push review: polish-and-export (M5)

diff --git a/Asterism/Asterism.xcodeproj/project.pbxproj b/Asterism/Asterism.xcodeproj/project.pbxprojindex b9472ec..5b430c9 100644--- a/Asterism/Asterism.xcodeproj/project.pbxproj+++ b/Asterism/Asterism.xcodeproj/project.pbxproj@@ -11,6 +11,9 @@ 		A10000000000000000000002 /* AsterismCore in Frameworks */ = {isa = PBXBuildFile; productRef = A10000000000000000000012 /* AsterismCore */; }; 		A10000000000000000000003 /* AsterismShareExtension.appex in Embed App Extensions */ = {isa = PBXBuildFile; fileRef = A10000000000000000000004 /* AsterismShareExtension.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; }; 		A10000000000000000000014 /* AsterismCore in Frameworks */ = {isa = PBXBuildFile; productRef = A10000000000000000000013 /* AsterismCore */; };+		A10000000000000000000018 /* ConstellationKit in Frameworks */ = {isa = PBXBuildFile; productRef = A1000000000000000000001B /* ConstellationKit */; };+		A10000000000000000000019 /* ConstellationKit in Frameworks */ = {isa = PBXBuildFile; productRef = A1000000000000000000001C /* ConstellationKit */; };+		A1000000000000000000001A /* ConstellationKit in Frameworks */ = {isa = PBXBuildFile; productRef = A1000000000000000000001D /* ConstellationKit */; }; /* End PBXBuildFile section */  /* Begin PBXContainerItemProxy section */@@ -110,6 +113,7 @@ 			buildActionMask = 2147483647; 			files = ( 				A10000000000000000000002 /* AsterismCore in Frameworks */,+				A10000000000000000000019 /* ConstellationKit in Frameworks */, 			); 			runOnlyForDeploymentPostprocessing = 0; 		};@@ -118,6 +122,7 @@ 			buildActionMask = 2147483647; 			files = ( 				A10000000000000000000001 /* AsterismCore in Frameworks */,+				A10000000000000000000018 /* ConstellationKit in Frameworks */, 			); 			runOnlyForDeploymentPostprocessing = 0; 		};@@ -126,6 +131,7 @@ 			buildActionMask = 2147483647; 			files = ( 				A10000000000000000000014 /* AsterismCore in Frameworks */,+				A1000000000000000000001A /* ConstellationKit in Frameworks */, 			); 			runOnlyForDeploymentPostprocessing = 0; 		};@@ -183,6 +189,7 @@ 			name = AsterismShareExtension; 			packageProductDependencies = ( 				A10000000000000000000012 /* AsterismCore */,+				A1000000000000000000001C /* ConstellationKit */, 			); 			productName = AsterismShareExtension; 			productReference = A10000000000000000000004 /* AsterismShareExtension.appex */;@@ -209,6 +216,7 @@ 			name = Asterism; 			packageProductDependencies = ( 				A10000000000000000000011 /* AsterismCore */,+				A1000000000000000000001B /* ConstellationKit */, 			); 			productName = Asterism; 			productReference = D4A9C79430091593004199A5 /* Asterism.app */;@@ -233,6 +241,7 @@ 			name = AsterismTests; 			packageProductDependencies = ( 				A10000000000000000000013 /* AsterismCore */,+				A1000000000000000000001D /* ConstellationKit */, 			); 			productName = AsterismTests; 			productReference = D4A9C7A530091595004199A5 /* AsterismTests.xctest */;@@ -890,6 +899,21 @@ 			package = A10000000000000000000010 /* XCLocalSwiftPackageReference "../Packages/AsterismCore" */; 			productName = AsterismCore; 		};+		A1000000000000000000001B /* ConstellationKit */ = {+			isa = XCSwiftPackageProductDependency;+			package = A10000000000000000000010 /* XCLocalSwiftPackageReference "../Packages/AsterismCore" */;+			productName = ConstellationKit;+		};+		A1000000000000000000001C /* ConstellationKit */ = {+			isa = XCSwiftPackageProductDependency;+			package = A10000000000000000000010 /* XCLocalSwiftPackageReference "../Packages/AsterismCore" */;+			productName = ConstellationKit;+		};+		A1000000000000000000001D /* ConstellationKit */ = {+			isa = XCSwiftPackageProductDependency;+			package = A10000000000000000000010 /* XCLocalSwiftPackageReference "../Packages/AsterismCore" */;+			productName = ConstellationKit;+		}; /* End XCSwiftPackageProductDependency section */ 	}; 	rootObject = D4A9C78C30091593004199A5 /* Project object */;

diff --git a/Asterism/Asterism/AsterismApp.swift b/Asterism/Asterism/AsterismApp.swiftindex 6e4b381..13f21ac 100644--- a/Asterism/Asterism/AsterismApp.swift+++ b/Asterism/Asterism/AsterismApp.swift@@ -6,13 +6,37 @@ //  import AsterismCore+import ConstellationKit import SwiftUI+import UIKit  @main struct AsterismApp: App {+    init() {+        Self.applySerifNavigationTitles()+    }+     var body: some Scene {         WindowGroup {             ContentView()         }     }++    /// Requirement 8.3's serif navigation large titles.+    ///+    /// The `UINavigationBar` appearance proxy is the only API for a serif+    /// navigation title, and **only `largeTitleTextAttributes` is set** (Q27):+    /// in-process system controllers — `UIActivityViewController` above all,+    /// which the markdown export and backup share sheets present — draw+    /// standard-title bars, which that attribute does not touch. Setting+    /// `titleTextAttributes` too would leak the app's face into them.+    ///+    /// The font is scaled through `UIFontMetrics` (Q31, requirement 11.3), so+    /// the title honours Dynamic Type rather than pinning the style guide's+    /// 33 pt.+    private static func applySerifNavigationTitles() {+        var attributes = UINavigationBar.appearance().largeTitleTextAttributes ?? [:]+        attributes[.font] = AsterismTypography.scaledSerifLargeTitleFont()+        UINavigationBar.appearance().largeTitleTextAttributes = attributes+    } }

diff --git a/Asterism/Asterism/ContentView.swift b/Asterism/Asterism/ContentView.swiftindex 33d44b8..16bbb0d 100644--- a/Asterism/Asterism/ContentView.swift+++ b/Asterism/Asterism/ContentView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import OSLog import SwiftUI @@ -17,7 +18,7 @@ struct ContentView: View {     /// the re-teach route it offers is a sheet, and a sheet over a sheet cannot     /// be presented from here.     @State private var showingDiagnostics = false-    @State private var showingTeachingForHostname: String?+    @State private var showingTeachingForHostname: PendingReteach?     /// Req 9.2's route. Keyed by the *set*, because that is what the resolution     /// is about — the surviving row is the app's to compute (Q21), so no record     /// id would name the right thing.@@ -28,9 +29,11 @@ struct ContentView: View {     /// Set by the Settings-hosted Check Library screen, which has to close     /// Settings before a sheet of its own can present.     @State private var pendingResolveSet: DuplicateSetKey?-    /// Set by the Settings-hosted diagnosis screen, which has to close Settings-    /// before the teaching sheet can present.-    @State private var pendingReteachHostname: String?+    /// Set by the Settings-hosted diagnosis and Sites screens, which have to+    /// close Settings before the teaching sheet can present. Carries the+    /// articles-conversion flag, because only one of those two routes may set it+    /// (Decision 3).+    @State private var pendingReteachHostname: PendingReteach?      enum AppTab {         case recent@@ -209,10 +212,12 @@ struct ContentView: View {                     }                     .navigationDestination(isPresented: $showingDiagnostics) {                         if let diagnosticsModel = model.libraryDiagnosticsModel(-                            onReteach: { hostname in showingTeachingForHostname = hostname },+                            onReteach: { hostname in+                                showingTeachingForHostname = PendingReteach(hostname: hostname)+                            },                             onResolveDuplicate: route(toResolve:)                         ) {-                            LibraryDiagnosticsView(model: diagnosticsModel)+                            LibraryDiagnosticsView(model: diagnosticsModel, showsSky: true)                         }                     }                 }@@ -234,7 +239,8 @@ struct ContentView: View {                         if let detailModel = model.workDetailModel(for: workID) {                             WorkDetailView(                                 model: detailModel,-                                onResolveDuplicate: resolveRoute(forWork: workID))+                                onResolveDuplicate: resolveRoute(forWork: workID),+                                exportModel: model.markdownExportModel(forWork: workID))                         }                     }                     .navigationDestination(item: $selectedWorksEntryID) { entryID in@@ -244,6 +250,10 @@ struct ContentView: View {             }             .accessibilityIdentifier("tab-works")         }+        // Requirement 9.3: the native tab bar is already the floating glass+        // capsule on iOS 26; the active item's cyan is the one token it takes.+        // The dark-mode icon glow is the accepted Q16 deviation.+        .tint(AsterismColors.cyan)         .sheet(isPresented: $showingNewWork) {             if let newWorkModel = model.newWorkModel() {                 NewWorkView(model: newWorkModel)@@ -278,7 +288,12 @@ struct ContentView: View {         // still says why the fields are off; the way in is the Works tab pill.         .sheet(item: $mergingWorkID) { presented in             if let detailModel = model.workDetailModel(for: presented.id) {-                NavigationStack { WorkDetailView(model: detailModel) }+                NavigationStack {+                    WorkDetailView(+                        model: detailModel,+                        exportModel: model.markdownExportModel(forWork: presented.id),+                        showsSky: false)+                }             }         }         .sheet(isPresented: $showingSettings, onDismiss: presentPendingResolution) {@@ -292,7 +307,7 @@ struct ContentView: View {                         // here, and this view is covered while Settings is up.                         diagnosticsModel: model.libraryDiagnosticsModel(                             onReteach: { hostname in-                                pendingReteachHostname = hostname+                                pendingReteachHostname = PendingReteach(hostname: hostname)                                 showingSettings = false                             },                             onResolveDuplicate: { setKey in@@ -301,7 +316,19 @@ struct ContentView: View {                             }                         ),                         syncModel: model.settingsSyncModel(),-                        interruptedImportNotice: model.interruptedImportNotice+                        interruptedImportNotice: model.interruptedImportNotice,+                        sitesModel: model.sitesListModel(),+                        // Req 6.2 rides the same pending-route plumbing Library+                        // Check uses. The flag is Decision 3's one exception,+                        // and this is the only route that ever sets it.+                        siteDetailModel: { site in+                            model.siteDetailModel(for: site) { hostname, permits in+                                pendingReteachHostname = PendingReteach(+                                    hostname: hostname,+                                    permitsArticlesConversion: permits)+                                showingSettings = false+                            }+                        }                     )                     .toolbar {                         ToolbarItem(placement: .confirmationAction) {@@ -328,17 +355,13 @@ struct ContentView: View {                 ComposedTeachingContainerView(model: teachModel)             }         }-        // The diagnosis screen's re-teach route (Req 4.5). Keyed by hostname-        // rather than Entry: a diagnosed Site's rows carry no action, so there is-        // no pill to enter it from.-        .sheet(-            isPresented: Binding(-                get: { showingTeachingForHostname != nil },-                set: { if !$0 { showingTeachingForHostname = nil } }-            )-        ) {-            if let hostname = showingTeachingForHostname,-               let teachModel = model.composedTeachingModel(forHostname: hostname) {+        // The diagnosis and Sites screens' re-teach route (Reqs 4.5, 6.2).+        // Keyed by hostname rather than Entry: a diagnosed Site's rows carry no+        // action, so there is no pill to enter it from.+        .sheet(item: $showingTeachingForHostname) { pending in+            if let teachModel = model.composedTeachingModel(+                forHostname: pending.hostname,+                permitsArticlesConversion: pending.permitsArticlesConversion) {                 ComposedTeachingContainerView(model: teachModel)             }         }@@ -348,9 +371,9 @@ struct ContentView: View {     /// actually gone. Presenting both in the same turn drops the second     /// presentation.     private func presentPendingReteach() {-        guard let hostname = pendingReteachHostname else { return }+        guard let pending = pendingReteachHostname else { return }         pendingReteachHostname = nil-        showingTeachingForHostname = hostname+        showingTeachingForHostname = pending     }      private func presentPendingResolution() {@@ -393,7 +416,8 @@ struct ContentView: View {                 onMoveTo: { showingMoveTo = entryID },                 onResolveDuplicate: model.recentPresentation.duplicateWorkload                     .item(for: entryID, type: .entry)-                    .map { item in { route(toResolve: item.key) } }+                    .map { item in { route(toResolve: item.key) } },+                exportModel: model.markdownExportModel(forEntry: entryID)             )         }     }@@ -410,6 +434,17 @@ private struct PresentedWork: Identifiable, Equatable {     let id: UUID } +/// A re-teach route waiting for Settings to close, or presented directly.+///+/// The flag travels with the hostname rather than beside it so a route can+/// never be dispatched having lost it — Decision 3's gate is only as good as+/// the one place that sets it.+private struct PendingReteach: Identifiable, Equatable {+    let hostname: String+    var permitsArticlesConversion = false+    var id: String { hostname }+}+ // An explicit configuration, not the production initializer (Q19): a preview // agent's `Bundle.main` is not the app bundle and no build check governs it, so // production resolution here could hit the Req 2.3 trap as a false positive.

diff --git a/Asterism/Asterism/Style/AsterismStyle.swift b/Asterism/Asterism/Style/AsterismStyle.swiftdeleted file mode 100644index 1cece8b..0000000--- a/Asterism/Asterism/Style/AsterismStyle.swift+++ /dev/null@@ -1,54 +0,0 @@-import SwiftUI--/// Semantic color tokens for the Constellation design language.-/// See docs/asterism-style-guide.md §2 for oklch definitions.-enum AsterismColors {-    // MARK: - Accent: Cyan (primary/positive)--    static let cyanDark = Color(red: 0.45, green: 0.82, blue: 0.92)-    static let cyanLight = Color(red: 0.10, green: 0.45, blue: 0.58)-    static var cyan: Color { cyanDark }--    // MARK: - Accent: Violet (secondary/negative)--    static let violetDark = Color(red: 0.78, green: 0.52, blue: 0.92)-    static let violetLight = Color(red: 0.42, green: 0.18, blue: 0.58)-    static var violet: Color { violetDark }--    // MARK: - Accent: Amber (teaching only)--    static let amberDark = Color(red: 0.92, green: 0.78, blue: 0.35)-    static let amberLight = Color(red: 0.58, green: 0.45, blue: 0.12)--    // MARK: - Neutrals--    static let primaryTextDark = Color(red: 0.91, green: 0.93, blue: 0.96)-    static let primaryTextLight = Color(red: 0.11, green: 0.12, blue: 0.17)-    static let secondaryTextDark = Color(red: 0.56, green: 0.59, blue: 0.68)-    static let secondaryTextLight = Color(red: 0.40, green: 0.43, blue: 0.51)-    static let noteTextDark = Color(red: 0.71, green: 0.74, blue: 0.82)-    static let noteTextLight = Color(red: 0.24, green: 0.26, blue: 0.34)--    // MARK: - Opaque fallbacks (Reduce Transparency)--    static let opaqueCardDark = Color(red: 0.07, green: 0.09, blue: 0.16)-    static let opaqueCardLight = Color(red: 0.95, green: 0.95, blue: 0.97)-}--/// Semantic typography helpers.-enum AsterismTypography {-    /// Serif font for work titles and screen titles (New York / SF Serif).-    static func serifTitle(_ size: CGFloat, weight: Font.Weight = .medium) -> Font {-        .system(size: size, weight: weight, design: .serif)-    }--    /// Section header style: 11pt, bold, uppercase.-    static let sectionHeader: Font = .system(size: 11, weight: .bold, design: .default)-}--/// Common shape/sizing constants.-enum AsterismLayout {-    static let cardRadius: CGFloat = 20-    static let buttonRadius: CGFloat = 21-    static let minHitTarget: CGFloat = 44-}

diff --git a/Asterism/Asterism/ViewModels/AppLibraryModel.swift b/Asterism/Asterism/ViewModels/AppLibraryModel.swiftindex 21dd792..a980632 100644--- a/Asterism/Asterism/ViewModels/AppLibraryModel.swift+++ b/Asterism/Asterism/ViewModels/AppLibraryModel.swift@@ -465,7 +465,13 @@ public final class AppLibraryModel {     /// Returns nil when no Entry exists on the hostname: the composed surface is     /// entered from an Entry, so a diagnosed Site with nothing captured from it     /// has nothing to teach against. The screen still lists the diagnosis.-    public func composedTeachingModel(forHostname hostname: String) -> ComposedTeachingViewModel? {+    /// `permitsArticlesConversion` is Decision 3's one exception: only the+    /// Sites screen's re-teach route sets it, and only with it will the+    /// projection and commit accept an articles Site.+    public func composedTeachingModel(+        forHostname hostname: String,+        permitsArticlesConversion: Bool = false+    ) -> ComposedTeachingViewModel? {         guard capabilities.supportsSegmentTeaching,               let repo = repository,               let row = recentPresentation.allRows.first(where: { $0.hostname == hostname })@@ -477,12 +483,47 @@ public final class AppLibraryModel {             library: repo,             capabilities: capabilities,             entryContext: .titleFocused,+            permitsArticlesConversion: permitsArticlesConversion,             onMutation: { [weak self] in                 await self?.refreshDiagnosesAndSnapshots()             }         )     } +    /// Whether the composed teaching surface can be entered for a hostname —+    /// the same question `composedTeachingModel(forHostname:)` answers by+    /// returning nil, asked without building a model to throw away.+    ///+    /// The Sites screen needs the answer *before* the reader taps, so it can+    /// disable the action and say why (Req 6.2).+    public func canComposeTeaching(forHostname hostname: String) -> Bool {+        capabilities.supportsSegmentTeaching+            && repository != nil+            && recentPresentation.allRows.contains { $0.hostname == hostname }+    }++    /// The Sites list (Req 6.1).+    public func sitesListModel() -> SitesListModel? {+        guard let repo = repository else { return nil }+        return SitesListModel(library: repo)+    }++    /// One site's screen (Reqs 6.2–6.4). The caller supplies the re-teach route+    /// because navigation is its concern — the Settings host has to dismiss+    /// itself before the teaching sheet can present.+    public func siteDetailModel(+        for site: SiteSnapshot,+        onReteach: @escaping @MainActor (String, Bool) -> Void+    ) -> SiteDetailModel? {+        guard let repo = repository else { return nil }+        return SiteDetailModel(+            site: site,+            library: repo,+            canReteach: canComposeTeaching(forHostname: site.hostname),+            onReteach: onReteach,+            onMutation: { [weak self] in await self?.refreshDiagnosesAndSnapshots() })+    }+     /// The diagnosis surface's model (Req 4.1, 4.2, and Req 9.3's duplicate     /// rows). The caller supplies the re-teach route because navigation is its     /// concern, not the model's.@@ -932,6 +973,29 @@ public final class AppLibraryModel {         return SettingsBackupModel(exporter: exporter)     } +    /// The per-entry markdown export model (Req 1.5), staged beside the backup+    /// exporter's own directory but in its own so the two scavengers never see+    /// each other's files.+    public func markdownExportModel(forEntry entryID: UUID) -> MarkdownExportModel? {+        markdownExportModel(subject: .entry(entryID))+    }++    /// The per-work markdown export model (Req 2.4).+    public func markdownExportModel(forWork workID: UUID) -> MarkdownExportModel? {+        markdownExportModel(subject: .work(workID))+    }++    private func markdownExportModel(+        subject: MarkdownExportModel.Subject+    ) -> MarkdownExportModel? {+        guard let repo = repository, let config = resolvedConfiguration else { return nil }+        return MarkdownExportModel(+            subject: subject,+            library: repo,+            stagingDirectory: MarkdownExportModel.stagingDirectory(+                inRoot: config.rootDirectory))+    }+     /// Provides a settings backup import model for restoring into a ready library.     public func settingsBackupImportModel() -> SettingsBackupImportModel? {         guard let repo = repository else { return nil }

diff --git a/Asterism/Asterism/ViewModels/ComposedTeachingViewModel.swift b/Asterism/Asterism/ViewModels/ComposedTeachingViewModel.swiftindex 061ee7e..d4dd777 100644--- a/Asterism/Asterism/ViewModels/ComposedTeachingViewModel.swift+++ b/Asterism/Asterism/ViewModels/ComposedTeachingViewModel.swift@@ -116,6 +116,12 @@ public final class ComposedTeachingViewModel {     private let library: any LibraryProviding     private let capabilities: AsterismCapabilities     private let entryContext: EntryContext+    /// Decision 3: whether this surface may re-teach an **articles** site.+    ///+    /// False everywhere but the Sites screen's route. Both teaching gates refuse+    /// an articles site without it, which is what keeps an inbox-driven teach+    /// from converting one by accident.+    private let permitsArticlesConversion: Bool     private let onMutation: (@Sendable () async -> Void)?      private var contract: ComposedTeachingContract?@@ -247,12 +253,14 @@ public final class ComposedTeachingViewModel {         library: any LibraryProviding,         capabilities: AsterismCapabilities = .m4,         entryContext: EntryContext = .titleFocused,+        permitsArticlesConversion: Bool = false,         onMutation: (@Sendable () async -> Void)? = nil     ) {         self.entry = entry         self.library = library         self.capabilities = capabilities         self.entryContext = entryContext+        self.permitsArticlesConversion = permitsArticlesConversion         self.onMutation = onMutation     } @@ -706,7 +714,8 @@ public final class ComposedTeachingViewModel {             trimPrefix: title.trimPrefix,             trimSuffix: title.trimSuffix,             urlDefinition: urlRuleDefinition,-            acknowledgeUnsettled: acknowledgedUnsettled)+            acknowledgeUnsettled: acknowledgedUnsettled,+            permitsArticlesConversion: permitsArticlesConversion)     }      // MARK: - Projection@@ -717,7 +726,8 @@ public final class ComposedTeachingViewModel {     ) async throws -> ComposedTeachingContract {         let request = ComposedTeachingRequest(             titleDefinition: titleDefinition, trimPrefix: trimPrefix, trimSuffix: trimSuffix,-            urlDefinition: urlDefinition, acknowledgeUnsettled: acknowledge)+            urlDefinition: urlDefinition, acknowledgeUnsettled: acknowledge,+            permitsArticlesConversion: permitsArticlesConversion)         return try await library.projectComposedTeaching(hostname: entry.hostname, request: request)     } 

diff --git a/Asterism/Asterism/ViewModels/EntryDetailModel.swift b/Asterism/Asterism/ViewModels/EntryDetailModel.swiftindex c707366..2cff52f 100644--- a/Asterism/Asterism/ViewModels/EntryDetailModel.swift+++ b/Asterism/Asterism/ViewModels/EntryDetailModel.swift@@ -196,13 +196,24 @@ public final class EntryDetailModel {         var disclosedIDs: Set<VariantID> { Set(variants.map(\.id)) }          /// One line per copy, in the order the sheet would present them.-        public var lines: [String] {-            variants.map { variant in-                let note = variant.content.note.isEmpty-                    ? "(no note)" : variant.content.note-                let rating = variant.content.rating.map { $0 == .up ? " ▲" : " ▼" } ?? ""-                return note + rating-            }+        public var lines: [String] { EntryDetailModel.disclosureLines(variants) }+    }++    /// How a torn Entry group's copies are worded in a disclosure.+    ///+    /// Work deletion discloses the same copies from its own alert+    /// (`WorkDetailModel.WorkDeleteDisclosure`), and the two alerts have to read+    /// identically — a reader shown a copy one way here and another way there+    /// cannot tell they are the same copy. One spelling, as with+    /// ``conflictMessage(_:)``.+    static func disclosureLines(+        _ variants: [AuthoredVariant<EntryAuthoredContent>]+    ) -> [String] {+        variants.map { variant in+            let note = variant.content.note.isEmpty+                ? "(no note)" : variant.content.note+            let rating = variant.content.rating.map { $0 == .up ? " ▲" : " ▼" } ?? ""+            return note + rating         }     } 

diff --git a/Asterism/Asterism/ViewModels/MarkdownExportModel.swift b/Asterism/Asterism/ViewModels/MarkdownExportModel.swiftnew file mode 100644index 0000000..2bef439--- /dev/null+++ b/Asterism/Asterism/ViewModels/MarkdownExportModel.swift@@ -0,0 +1,152 @@+import AsterismCore+import Foundation+import OSLog++/// Drives a per-entry or per-work markdown export (Reqs 1.5, 2.4).+///+/// The third layer of the export split (Q17): the repository resolves the input,+/// `MarkdownExport` renders it, and this model stages the result as a `.md` file+/// and drives the share sheet. Sibling of `SettingsBackupModel` and deliberately+/// the same shape — same `.idle/.exporting/.sharing/.failed` machine, same+/// privacy-safe message discipline, same cleanup-on-dismiss — because the reader+/// meets both through the identical `ShareSheet`.+@MainActor @Observable+public final class MarkdownExportModel {+    private static let logger = Logger(+        subsystem: "me.nore.ig.Asterism", category: "MarkdownExportModel")++    /// What is being exported. One model per invocation, so the subject is+    /// fixed at construction.+    public enum Subject: Equatable, Sendable {+        case entry(UUID)+        case work(UUID)+    }++    public enum State: Equatable, Sendable {+        case idle+        case exporting+        case sharing+        case failed+    }++    public private(set) var state: State = .idle+    public private(set) var exportedFileURL: URL?+    public private(set) var errorMessage: String?++    private let subject: Subject+    private let library: any LibraryProviding+    private let stagingDirectory: URL+    private let locale: Locale+    private var isExporting = false++    /// Creates the model and clears anything a previous session abandoned.+    public init(+        subject: Subject,+        library: any LibraryProviding,+        stagingDirectory: URL,+        locale: Locale = .current+    ) {+        self.subject = subject+        self.library = library+        self.stagingDirectory = stagingDirectory+        self.locale = locale+        scavengeStaleFiles()+    }++    /// Where exports are staged, given the library's root (design: under+    /// `Library/Caches`, beside the backup exporter's own directory).+    public nonisolated static func stagingDirectory(inRoot rootDirectory: URL) -> URL {+        rootDirectory.appending(path: "Library/Caches/MarkdownExports")+    }++    // MARK: - Export++    /// Reads the input, renders it, stages the file, and hands it to the share+    /// sheet. Suppresses a second submission while one is in flight.+    public func startExport() async {+        guard !isExporting else { return }+        isExporting = true+        state = .exporting+        errorMessage = nil+        exportedFileURL = nil++        do {+            let (document, filename) = try await renderDocument()+            exportedFileURL = try stage(document, as: filename)+            state = .sharing+            Self.logger.debug("Markdown export staged")+        } catch {+            state = .failed+            errorMessage = Self.privacySafeMessage(for: error)+            Self.logger.error(+                "Markdown export failed: \(Self.diagnosticCategory(for: error), privacy: .public)")+        }++        isExporting = false+    }++    /// Rendering never fails — the inputs are total and escaping is total — so+    /// the only thing that can throw here is the read.+    private func renderDocument() async throws -> (document: String, filename: String) {+        switch subject {+        case .entry(let id):+            let input = try await library.entryExportInput(entryID: id, locale: locale)+            return (MarkdownExport.renderEntry(input), MarkdownExport.filename(for: input))+        case .work(let id):+            let input = try await library.workExportInput(workID: id, locale: locale)+            return (MarkdownExport.renderWork(input), MarkdownExport.filename(for: input))+        }+    }++    private func stage(_ document: String, as filename: String) throws -> URL {+        try FileManager.default.createDirectory(+            at: stagingDirectory, withIntermediateDirectories: true)+        let fileURL = stagingDirectory.appending(path: filename)+        try ExportStaging.write(Data(document.utf8), to: fileURL)+        return fileURL+    }++    // MARK: - Share lifecycle++    public func handleShareCompletion() { cleanupAndReset() }++    public func handleShareCancellation() { cleanupAndReset() }++    private func cleanupAndReset() {+        if let exportedFileURL {+            try? FileManager.default.removeItem(at: exportedFileURL)+        }+        exportedFileURL = nil+        state = .idle+    }++    /// Removes abandoned exports older than 24 hours.+    ///+    /// By directory rather than by filename prefix, which is what the backup+    /// exporter keys on: markdown filenames come from the reader's own titles+    /// (Q11) and share no prefix, and this directory holds nothing else (Q40).+    private func scavengeStaleFiles() {+        ExportStaging.scavenge(directory: stagingDirectory) { $0.pathExtension == "md" }+    }++    // MARK: - Messages++    /// Never a title, a URL, a path, or an identifier — the same rule+    /// `SettingsBackupModel` holds to, for the same reason: an export failure is+    /// reported on screen and must not be a way for content to leak out of it.+    private static func privacySafeMessage(for error: Error) -> String {+        if let repositoryError = error as? LibraryRepositoryError,+           case .recordNotFound = repositoryError {+            return "This note is no longer in your library, so there was nothing to export."+        }+        return "The markdown export could not be prepared. Please try again."+    }++    private static func diagnosticCategory(for error: Error) -> String {+        switch error {+        case let error as LibraryRepositoryError: "repository: \(error)"+        case let error as CocoaError: "staging: \(error.code.rawValue)"+        default: "unknown: \(type(of: error))"+        }+    }+}

diff --git a/Asterism/Asterism/ViewModels/SearchFilters.swift b/Asterism/Asterism/ViewModels/SearchFilters.swiftnew file mode 100644index 0000000..e7ac12d--- /dev/null+++ b/Asterism/Asterism/ViewModels/SearchFilters.swift@@ -0,0 +1,83 @@+import AsterismCore+import Foundation++// Search on both tabs (Reqs 3, 4).+//+// Pure in-memory filtering over the presentation types the two tabs already+// render (Q19): both are functions of one repository read that carries every+// searchable field, and diacritic-insensitive matching could not be a store+// predicate anyway. Structs rather than view code so the requirement is+// testable without a view.++/// Case- and diacritic-insensitive containment, the one matching rule both+/// filters use (Reqs 3.1, 4.1).+private func contains(_ haystack: String?, _ needle: String) -> Bool {+    guard let haystack, !haystack.isEmpty else { return false }+    return haystack.range(of: needle, options: [.caseInsensitive, .diacriticInsensitive]) != nil+}++/// The Recent tab's search (Req 3).+///+/// Takes the **already banner-filtered** groups and narrows them further, which+/// is what makes the two conditions AND rather than replace one another (3.2,+/// Q6). Elsewhere lines are not this type's business: they carry no titles to+/// match and stay visible under an active query (Q13), so the view renders them+/// outside the filtered rows.+struct RecentSearchFilter: Equatable {+    let query: String++    private var needle: String {+        query.trimmingCharacters(in: .whitespacesAndNewlines)+    }++    /// Whether the query narrows anything. A blank query restores the list to+    /// its prior state, banner filter included (3.5).+    var isActive: Bool { !needle.isEmpty }++    /// Day groups are preserved; a group left with no rows is dropped rather+    /// than rendered as an empty header (3.4).+    func apply(to groups: [RecentPresentationGroup]) -> [RecentPresentationGroup] {+        guard isActive else { return groups }+        let needle = self.needle+        return groups.compactMap { group in+            let rows = group.rows.filter { Self.matches($0, needle: needle) }+            guard !rows.isEmpty else { return nil }+            return RecentPresentationGroup(day: group.day, rows: rows)+        }+    }++    /// Note text, chapter title, and work title (3.1). An entry with no chapter+    /// title matches on its cleaned capture title **in place of** it (3.3) —+    /// the row's `captureTitle` is already the cleaned display value, so a+    /// junk-suffixed raw title is never the haystack.+    private static func matches(_ row: RecentPresentationRow, needle: String) -> Bool {+        contains(row.note, needle)+            || contains(row.chapterTitle ?? row.captureTitle, needle)+            || contains(row.workDisplayTitle, needle)+    }+}++/// The Works tab's search (Req 4).+///+/// Work display titles only. While a query is active the unattached group is+/// hidden outright (4.2, Q12): those entries have no work title to match, and+/// Recent's search is where their content is searchable.+struct WorksSearchFilter: Equatable {+    let query: String++    private var needle: String {+        query.trimmingCharacters(in: .whitespacesAndNewlines)+    }++    var isActive: Bool { !needle.isEmpty }++    /// Filtering only — never reordering, so the list's existing order,+    /// including empty works sinking, survives (4.1).+    func apply(to snapshot: WorksSnapshot) -> WorksSnapshot {+        guard isActive else { return snapshot }+        let needle = self.needle+        return WorksSnapshot(+            works: snapshot.works.filter { contains($0.displayTitle, needle) },+            unattachedEntries: [])+    }+}

diff --git a/Asterism/Asterism/ViewModels/SitesModels.swift b/Asterism/Asterism/ViewModels/SitesModels.swiftnew file mode 100644index 0000000..1b2d682--- /dev/null+++ b/Asterism/Asterism/ViewModels/SitesModels.swift@@ -0,0 +1,241 @@+import AsterismCore+import Foundation+import Observation+import OSLog++// The Sites settings screen's two models (Req 6).+//+// Every sentence the screen shows is built here, following the+// `LibraryDiagnosticsModel` convention: the views choose rows and styling, never+// wording. That is also what makes the screen's language testable.++/// The list of every site the library knows (Req 6.1).+@MainActor @Observable+public final class SitesListModel {+    private static let logger = Logger(subsystem: "me.nore.ig.Asterism", category: "SitesListModel")++    public enum State: Equatable, Sendable {+        case loading+        case ready+        case error(message: String)+    }++    /// One site, as the list presents it. Keyed by hostname, which is what the+    /// read returns one row per (Q24).+    public struct Row: Identifiable, Equatable, Sendable {+        public let site: SiteSnapshot++        public var id: String { site.hostname }+        public var hostname: String { site.hostname }+        public var displayName: String { site.displayName }+        public var modeLabel: String { SiteModePresentation.label(for: site.mode) }+        /// Whether the name line adds anything the hostname line does not.+        public var showsHostnameSeparately: Bool { site.displayName != site.hostname }+    }++    public private(set) var state: State = .loading+    public private(set) var rows: [Row] = []++    /// Why the list is empty. A library with no sites has captured nothing yet,+    /// which is a different thing from a failed read.+    public let emptyMessage =+        "No sites yet. Share a page to Asterism and the site it came from appears here."++    private let library: any LibraryProviding++    public init(library: any LibraryProviding) {+        self.library = library+    }++    public func load() async {+        state = .loading+        do {+            rows = try await library.sites().map(Row.init(site:))+            state = .ready+        } catch {+            rows = []+            state = .error(message: error.localizedDescription)+            Self.logger.error("Sites read failed: \(String(describing: error), privacy: .public)")+        }+    }+}++/// One site's screen: what mode it is in, the re-teach route, and — for a site+/// not already in articles mode — the one-way switch (Reqs 6.2–6.4).+@MainActor @Observable+public final class SiteDetailModel {+    private static let logger = Logger(subsystem: "me.nore.ig.Asterism", category: "SiteDetailModel")++    /// What the articles confirmation is offering, built from the projection so+    /// the count it names is the one the commit will apply.+    ///+    /// The contract rides **on the presented value**, not beside it in the+    /// model, for the reason `WorkDetailModel.WorkDeletionPrompt` records:+    /// SwiftUI runs a dialog's `isPresented` setter — the dismissal, which is+    /// `cancelArticlesSwitch()` — *before* it runs the tapped button's action,+    /// so a confirm that re-read a model property found it already cleared and+    /// committed nothing, silently.+    public struct ArticlesPrompt: Equatable, Sendable {+        public let contract: ArticlesContract+        public let entryCount: Int++        public var message: String {+            let subject = Pluralisation.count(+                entryCount, "note from this site becomes", "notes from this site become")+            return "\(subject) independent articles: they stop being chapters of a work, "+                + "and the site's title and URL rules are retired. This cannot be undone from "+                + "here — the way back is to teach the site again."+        }+    }++    public let site: SiteSnapshot+    public private(set) var articlesPrompt: ArticlesPrompt?+    public private(set) var errorMessage: String?+    public private(set) var isSubmitting = false+    /// Set once the switch commits, so the screen can leave.+    public private(set) var didSwitchToArticles = false++    private let library: any LibraryProviding+    private let onReteach: @MainActor (String, Bool) -> Void+    private let onMutation: @Sendable () async -> Void++    /// Whether a re-teach can be entered at all.+    ///+    /// The composed teaching surface is entered from an Entry, so a site with+    /// nothing captured from it has nothing to teach against — which is exactly+    /// when `AppLibraryModel.composedTeachingModel(forHostname:)` returns nil.+    /// The host answers that question; this model only reports it.+    public let canReteach: Bool++    public init(+        site: SiteSnapshot,+        library: any LibraryProviding,+        canReteach: Bool,+        onReteach: @escaping @MainActor (String, Bool) -> Void,+        onMutation: @escaping @Sendable () async -> Void+    ) {+        self.site = site+        self.library = library+        self.canReteach = canReteach+        self.onReteach = onReteach+        self.onMutation = onMutation+    }++    // MARK: - Wording++    public var modeLabel: String { SiteModePresentation.label(for: site.mode) }++    public var modeExplanation: String {+        switch site.mode {+        case .untaught:+            "Asterism has not been taught how this site names its pages, so its notes keep "+                + "their page titles."+        case .taught:+            "Asterism reads a work and a chapter out of this site's page titles."+        case .articles:+            "Every page from this site stands on its own. Teaching the site again returns it "+                + "to reading works and chapters."+        }+    }++    public var reteachLabel: String {+        site.mode == .untaught ? "Teach site" : "Re-teach site"+    }++    /// The line beside a disabled re-teach. Nil when the action is available —+    /// an explanation for something that works is noise.+    public var reteachUnavailableMessage: String? {+        canReteach+            ? nil+            : "Asterism has no notes from this site yet, so there is nothing to teach it with."+    }++    /// Req 6.3: articles mode is one-way, so a site already in it is not offered+    /// the switch; its way out is the re-teach above (Decision 3).+    public var canSwitchToArticles: Bool { site.mode != .articles }++    // MARK: - Re-teach (Req 6.2, 6.3)++    /// Routes to the composed teaching surface.+    ///+    /// The flag is what makes this screen the one place an articles site can be+    /// re-taught (Decision 3): every other entry point leaves it false, and the+    /// projection and commit refuse an articles site without it.+    public func reteach() {+        guard canReteach else { return }+        onReteach(site.hostname, site.mode == .articles)+    }++    // MARK: - Articles switch (Req 6.3, 6.4)++    /// Projects the switch and raises its confirmation. Nothing is written.+    public func requestArticlesSwitch() async {+        guard canSwitchToArticles, !isSubmitting else { return }+        errorMessage = nil+        do {+            present(try await library.projectArticles(+                hostname: site.hostname, junkSuffixRule: nil))+        } catch {+            errorMessage = error.localizedDescription+            Self.logger.error(+                "Articles projection failed: \(String(describing: error), privacy: .public)")+        }+    }++    public func cancelArticlesSwitch() {+        articlesPrompt = nil+    }++    /// Commits the projected contract — the same one teach mode commits, so the+    /// retroactive semantics are identical by construction (Req 6.4).+    ///+    /// The contract comes from the prompt the dialog rendered, never from this+    /// model: SwiftUI has already run the dismissal by the time this action+    /// fires (see `ArticlesPrompt`).+    public func confirmArticlesSwitch(_ prompt: ArticlesPrompt) async {+        guard !isSubmitting else { return }+        isSubmitting = true+        errorMessage = nil+        defer { isSubmitting = false }++        do {+            switch try await library.commitArticles(prompt.contract) {+            case .committed:+                articlesPrompt = nil+                didSwitchToArticles = true+                await onMutation()+            case .refreshed(let fresh):+                // The confirmation named a count; something moved under it, so+                // the reader answers the current one rather than the old one.+                present(fresh)+                errorMessage =+                    "This site changed while you were deciding. Check what will happen and "+                    + "confirm again."+            case .invalidated(let reason):+                errorMessage = reason+            }+        } catch {+            errorMessage = error.localizedDescription+            Self.logger.error(+                "Articles commit failed: \(String(describing: error), privacy: .public)")+        }+    }++    private func present(_ contract: ArticlesContract) {+        articlesPrompt = ArticlesPrompt(+            contract: contract,+            entryCount: contract.outcome.plan.entryProjections.count)+    }+}++/// The one place a site mode is turned into words, so the list row and the+/// detail screen cannot describe the same site differently.+enum SiteModePresentation {+    static func label(for mode: SiteMode) -> String {+        switch mode {+        case .untaught: "Not taught"+        case .taught: "Taught"+        case .articles: "Articles"+        }+    }+}

diff --git a/Asterism/Asterism/ViewModels/WorkDetailModel.swift b/Asterism/Asterism/ViewModels/WorkDetailModel.swiftindex a54a25f..e0adda0 100644--- a/Asterism/Asterism/ViewModels/WorkDetailModel.swift+++ b/Asterism/Asterism/ViewModels/WorkDetailModel.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import Foundation import Observation import OSLog@@ -15,7 +16,20 @@ public final class WorkDetailModel {     }      public private(set) var state: State = .loading-    public private(set) var work: WorkSnapshot?+    /// The whole §6 read (Reqs 5.1–5.4), from one call so the counts, the+    /// last-noted URL and the chapter rows describe one moment of the store.+    public private(set) var presentation: WorkDetailPresentation?+    /// The Work the presentation describes. Read off the presentation rather+    /// than stored beside it: two fields set from one load are two fields that+    /// can disagree, and every other §6 read on this model is already derived.+    public var work: WorkSnapshot? { presentation?.work }++    /// Req 5.2's three counts, over logical records.+    public var pulse: RatingPulse { presentation?.pulse ?? RatingPulse(notes: 0, up: 0, down: 0) }+    /// Req 5.3: nil hides the action; the repository decides, not the screen.+    public var lastNotedURLString: String? { presentation?.lastNotedURLString }+    /// Req 5.4, newest-first with cleaned display titles.+    public var chapterRows: [WorkChapterRow] { presentation?.chapterRows ?? [] }      /// Req 2.8, mirrored from Entry detail: a torn Work's authored fields are     /// read-only until its resolution. The repository refuses the write either@@ -68,8 +82,9 @@ public final class WorkDetailModel {     public func load() async {         state = .loading         do {-            let snapshot = try await library.work(id: workID)-            work = snapshot+            let detail = try await library.workDetail(id: workID)+            presentation = detail+            let snapshot = detail.work             draftTitle = snapshot.displayTitle             draftType = snapshot.type             draftTags = snapshot.genreTags@@ -159,6 +174,20 @@ public final class WorkDetailModel {         )     } +    /// Whether the drafts differ from the loaded snapshot.+    ///+    /// §6 puts the title, type, tags and notes on the screen itself, so Save is+    /// a toolbar confirmation shown only while there is something to save — a+    /// permanently-visible Save on a presentation-first screen reads as an+    /// unfinished form.+    public var hasUnsavedChanges: Bool {+        guard let work else { return false }+        return draftTitle != work.displayTitle+            || draftType != work.type+            || draftTags != work.genreTags+            || draftNotes != work.genericNotes+    }+     /// Commits metadata edit. Suppresses duplicate submissions.     public func save() async {         guard !isSubmitting else { return }@@ -204,6 +233,194 @@ public final class WorkDetailModel {         isSubmitting = false     } +    // MARK: - Deletion (Req 7)++    /// What the confirmation dialog is offering, or nil when none is up.+    ///+    /// Built from a **projection**, not from the loaded snapshot: the count the+    /// dialog names is the one the commit re-verifies (Q28), and the loaded+    /// snapshot's entry list describes an earlier moment.+    public struct WorkDeletionPrompt: Identifiable, Equatable, Sendable {+        public let id: UUID+        /// The projection the dialog was built from, **carried on the presented+        /// value rather than held beside it in the model**.+        ///+        /// SwiftUI runs a dialog's `isPresented` setter — the dismissal, which+        /// is `cancelDelete()` — *before* it runs the tapped button's action, so+        /// a `chooseDeletion` that re-read a model property found it already+        /// cleared and deleted nothing, silently. Entry detail records the same+        /// hazard on `EntryDetailModel.confirmDelete(_:)`. Taking the contract+        /// from the prompt is both the fix and the stronger statement: the count+        /// the message names and the contract the commit takes are one value.+        public let contract: WorkDeletionContract++        /// How many logical notes the work owns outright — shared groups are+        /// repointed rather than deleted (Q25, Q35), so they are not counted.+        public var entryCount: Int { contract.entryGroupIDs.count }++        /// The sentence above the two choices. Wording lives here, per the+        /// house convention that models own text and views own layout.+        public var message: String {+            guard entryCount > 0 else {+                return "This work has no notes. Deleting it cannot be undone."+            }+            return "This work has \(Pluralisation.count(entryCount, "note", "notes")). "+                + "Choose what happens to \(entryCount == 1 ? "it" : "them") — "+                + "this cannot be undone."+        }+    }++    /// What a torn-group disclosure alert is showing (Req 7.2).+    ///+    /// **This value is the disclosure**, exactly as on entry deletion: the+    /// variants travel from the alert that rendered them into the commit, so+    /// what the commit re-verifies is what the reader was shown. It carries the+    /// disposition too, because the reader has already chosen one and the alert+    /// is the second half of that single answer.+    public struct WorkDeleteDisclosure: Identifiable, Equatable, Sendable {+        public let id: UUID+        public let disposition: WorkDeletionDisposition+        /// The contract travels with the disclosure for the same reason it+        /// travels with the prompt: the alert's dismissal runs before its+        /// button's action, so nothing the commit needs may live in the model.+        public let contract: WorkDeletionContract+        public let variants: [AuthoredVariant<EntryAuthoredContent>]++        var disclosedIDs: Set<VariantID> { Set(variants.map(\.id)) }++        /// One line per copy, in the order the resolution sheet would show them+        /// — worded by `EntryDetailModel`, which owns the wording for both+        /// alerts, as it already owns `conflictMessage`.+        public var lines: [String] { EntryDetailModel.disclosureLines(variants) }+    }++    public private(set) var deletionPrompt: WorkDeletionPrompt?+    public private(set) var deleteDisclosure: WorkDeleteDisclosure?+    /// Whether the work is gone, which is the screen's cue to leave.+    public private(set) var isDeleted = false++    /// Req 7.1's entry point: project, then offer the two dispositions.+    public func requestDelete() async {+        errorMessage = nil+        await projectDeletion()+    }++    /// The projection itself, which the stale-disclosure path re-runs. It leaves+    /// `errorMessage` alone: on that path the message explaining the+    /// re-presentation is the one thing the reader needs to keep.+    private func projectDeletion() async {+        do {+            present(try await library.projectWorkDeletion(workID: workID))+        } catch {+            errorMessage = error.localizedDescription+            state = .error(message: error.localizedDescription)+            Self.logger.error(+                "Work deletion projection failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// The dialog's dismissal. It may clear anything it likes: every button+    /// action takes what it needs as a parameter, so nothing here can strand a+    /// commit that is about to run.+    public func cancelDelete() {+        deletionPrompt = nil+        deleteDisclosure = nil+    }++    /// The reader's choice of disposition, over the prompt the dialog rendered.+    /// A torn owned group stops here and discloses; everything else commits.+    public func chooseDeletion(+        _ prompt: WorkDeletionPrompt, disposition: WorkDeletionDisposition+    ) async {+        deletionPrompt = nil+        let contract = prompt.contract+        let variants = Self.disclosableVariants(of: contract)+        guard variants.isEmpty else {+            deleteDisclosure = WorkDeleteDisclosure(+                id: workID, disposition: disposition, contract: contract, variants: variants)+            return+        }+        await performDelete(contract, disposition: disposition, disclosing: nil)+    }++    /// The disclosure alert's destructive action. Takes the rendered value as a+    /// parameter rather than re-reading `deleteDisclosure`, which SwiftUI has+    /// already cleared by the time the action runs.+    public func confirmDeletion(_ disclosure: WorkDeleteDisclosure) async {+        deleteDisclosure = nil+        await performDelete(+            disclosure.contract, disposition: disclosure.disposition,+            disclosing: disclosure.disclosedIDs)+    }++    public func cancelDeletionDisclosure() {+        deleteDisclosure = nil+    }++    private func present(_ contract: WorkDeletionContract) {+        deletionPrompt = WorkDeletionPrompt(id: workID, contract: contract)+    }++    /// Sorted so the alert's lines and the disclosed set are derived from one+    /// stable order — an alert listing copies in a different order each time+    /// would be a different disclosure each time.+    private static func disclosableVariants(+        of contract: WorkDeletionContract+    ) -> [AuthoredVariant<EntryAuthoredContent>] {+        contract.tornEntryVariants+            .sorted { $0.key.uuidString < $1.key.uuidString }+            .flatMap(\.value)+    }++    private func performDelete(+        _ contract: WorkDeletionContract,+        disposition: WorkDeletionDisposition,+        disclosing disclosed: Set<VariantID>?+    ) async {+        guard !isSubmitting else { return }+        isSubmitting = true+        state = .submitting+        errorMessage = nil+        defer { isSubmitting = false }++        do {+            let outcome = try await library.commitWorkDeletion(+                contract, disposition: disposition, disclosedVariants: disclosed)+            switch outcome {+            case .committed:+                isDeleted = true+                state = .ready+                await onMutation()+            case .refreshed(let fresh):+                // The prompt named a count; something changed under it, so the+                // whole dialog is presented again rather than the commit+                // silently taking more than was confirmed (Q28).+                present(fresh)+                errorMessage =+                    "This work changed while you were deciding. Check what will happen and "+                    + "confirm again."+                state = .ready+            case .conflict(let conflict):+                errorMessage = EntryDetailModel.conflictMessage(conflict)+                state = .error(message: errorMessage ?? "")+                await onConflict(conflict)+                // A stale disclosure means a copy arrived while the alert was+                // up. Re-projecting is what puts the current copies in front of+                // the reader instead of the ones they already answered over.+                if case .disclosureStale = conflict { await projectDeletion() }+            case .invalidated(let reason):+                errorMessage = reason+                state = .error(message: reason)+                await load()+            }+        } catch {+            errorMessage = error.localizedDescription+            state = .error(message: error.localizedDescription)+            Self.logger.error(+                "Work deletion failed: \(String(describing: error), privacy: .public)")+        }+    }+     private func commitWorkURL(request: WorkURLRequest) async {         guard !isWorkURLSubmitting else { return }         isWorkURLSubmitting = true

diff --git a/Asterism/Asterism/Views/ComposedTeachingPresentation.swift b/Asterism/Asterism/Views/ComposedTeachingPresentation.swiftindex 8bfe807..b4353a8 100644--- a/Asterism/Asterism/Views/ComposedTeachingPresentation.swift+++ b/Asterism/Asterism/Views/ComposedTeachingPresentation.swift@@ -6,8 +6,6 @@ import SwiftUI /// and the URL details editor (Req 8.2–8.4). These survive the deletion of the M3 /// `URLTeachingView`, which owned the equivalent URL helpers. public enum ComposedTeachingPresentation {-    public static let minimumHitTarget: CGFloat = AsterismLayout.minHitTarget-     // Disclosure copy (Req 8.2; final copy set by the visual design pass).     public static let disclosureLabel = "Add URL details"     public static let disclosureBenefit = "Identify Works and chapters from the page URL for re-share matching."

diff --git a/Asterism/Asterism/Views/ComposedTeachingView.swift b/Asterism/Asterism/Views/ComposedTeachingView.swiftindex 53d22f5..854e7bf 100644--- a/Asterism/Asterism/Views/ComposedTeachingView.swift+++ b/Asterism/Asterism/Views/ComposedTeachingView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// The unified teaching surface (Req 8.1). One screen composes a title rule and@@ -91,7 +92,7 @@ struct ComposedTeachingView: View {         VStack(alignment: .leading, spacing: 4) {             Text("Example Title").font(.caption).foregroundStyle(.secondary)             Text(model.exampleTitle)-                .font(AsterismTypography.serifTitle(15))+                .font(AsterismTypography.serifRowTitle)                 .accessibilityIdentifier("composed-teaching-example-title")         }         .frame(maxWidth: .infinity, alignment: .leading)@@ -130,20 +131,23 @@ struct ComposedTeachingView: View {                 // is one static-text element VoiceOver reads.                 Label(notice, systemImage: "exclamationmark.circle")                     .font(.caption)-                    .foregroundStyle(AsterismColors.amberDark)+                    .foregroundStyle(AsterismColors.amberText)                     .accessibilityIdentifier("composed-title-selection-notice")             } +            // Q36: the previews wear the same §2/§7 mapping as the chips they+            // preview — the Work reads cyan, the chapter amber.             LabeledContent("Work will be named") {                 Text(model.workNamePreview)                     .font(.subheadline)-                    .foregroundStyle(AsterismColors.amberDark)+                    .foregroundStyle(AsterismColors.cyan)             }             .accessibilityIdentifier("composed-work-name-preview")              if let chapter = model.chapterNamePreview {                 LabeledContent("Chapter will be named") {-                    Text(chapter).font(.subheadline).foregroundStyle(AsterismColors.cyanDark)+                    // Req 11.4: amber *text* is always the lifted token.+                    Text(chapter).font(.subheadline).foregroundStyle(AsterismColors.amberText)                 }                 .accessibilityIdentifier("composed-chapter-name-preview")             }@@ -190,7 +194,7 @@ struct ComposedTeachingView: View {                 .frame(minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("composed-articles-stepper")             if let message = model.articleValidationMessage {-                Text(message).font(.caption).foregroundStyle(.red)+                Text(message).font(.caption).foregroundStyle(AsterismColors.amberText)             }             if let count = model.articlesPreviewEntryCount {                 Text("^[\(count) entry](inflect: true) will become independent articles.")@@ -203,8 +207,8 @@ struct ComposedTeachingView: View {                 .accessibilityIdentifier("composed-articles-cancel")         }         .padding(12)-        .background(.fill.quaternary)-        .clipShape(RoundedRectangle(cornerRadius: 8))+        // §4: flat field fill for content inside a sheet.+        .constellationField(cornerRadius: AsterismLayout.cardRadius)         .accessibilityElement(children: .contain)         .accessibilityIdentifier("composed-articles-confirmation")     }@@ -217,7 +221,7 @@ struct ComposedTeachingView: View {                 .font(.headline)                 .frame(maxWidth: .infinity, minHeight: AsterismLayout.minHitTarget)         }-        .buttonStyle(.borderedProminent)+        .buttonStyle(.constellationPrimary)         .disabled(!model.canConfirmArticles)         .accessibilityIdentifier("composed-articles-confirm")     }@@ -254,7 +258,7 @@ struct ComposedTeachingView: View {                     // The disclosure is the remedy, not a passive hint beside a                     // collapsed section (Req 8.2 as amended); it auto-expands.                     Text(ComposedTeachingPresentation.chapterRemedyHint)-                        .font(.caption).foregroundStyle(AsterismColors.amberDark)+                        .font(.caption).foregroundStyle(AsterismColors.amberText)                         .accessibilityIdentifier("composed-url-remedy-hint")                 } else {                     Text(ComposedTeachingPresentation.disclosureBenefit)@@ -278,21 +282,21 @@ struct ComposedTeachingView: View {             }             if !outcome.prospectiveWorks.isEmpty {                 Text("Creates: \(outcome.prospectiveWorks.map(\.displayTitle.value).joined(separator: ", "))")-                    .font(.caption).foregroundStyle(AsterismColors.cyanDark)+                    .font(.caption).foregroundStyle(AsterismColors.cyan)                     .accessibilityIdentifier("composed-preview-creates")             }             if !outcome.issues.isEmpty {                 ForEach(Array(outcome.issues.enumerated()), id: \.offset) { _, issue in                     let row = ConflictPresentation.row(for: issue)                     Label(row.text, systemImage: row.symbol)-                        .font(.caption).foregroundStyle(.orange)+                        .font(.caption).foregroundStyle(AsterismColors.amberText)                 }             }         }         .frame(maxWidth: .infinity, alignment: .leading)         .padding(12)-        .background(.fill.quaternary)-        .clipShape(RoundedRectangle(cornerRadius: 8))+        // §4: flat field fill for content inside a sheet.+        .constellationField(cornerRadius: AsterismLayout.cardRadius)         .accessibilityIdentifier(isCurrent ? "composed-preview-complete" : "composed-preview-stale")     } @@ -300,17 +304,18 @@ struct ComposedTeachingView: View {     private func entryRow(_ projection: ComposedEntryProjection, index: Int) -> some View {         VStack(alignment: .leading, spacing: 2) {             HStack(spacing: 4) {+                // Q36: work = cyan, chapter = amber, as the chips read.                 if let name = projection.workName {-                    Text(name).font(.caption).foregroundStyle(AsterismColors.amberDark).lineLimit(1)+                    Text(name).font(.caption).foregroundStyle(AsterismColors.cyan).lineLimit(1)                 }                 if let chapter = projection.projectedChapterTitle {-                    Text("· \(chapter)").font(.caption).foregroundStyle(AsterismColors.cyanDark).lineLimit(1)+                    Text("· \(chapter)").font(.caption).foregroundStyle(AsterismColors.amberText).lineLimit(1)                 } else if let sequence = projection.projectedChapterSequence {-                    Text("· #\(sequence)").font(.caption).foregroundStyle(AsterismColors.cyanDark).lineLimit(1)+                    Text("· #\(sequence)").font(.caption).foregroundStyle(AsterismColors.amberText).lineLimit(1)                 }             }             if projection.actionableAfter {-                Text("Still needs attention").font(.caption2).foregroundStyle(.orange)+                Text("Still needs attention").font(.caption2).foregroundStyle(AsterismColors.amberText)             }         }         .accessibilityElement(children: .combine)@@ -323,7 +328,7 @@ struct ComposedTeachingView: View {         VStack(alignment: .leading, spacing: 12) {             Label("Chapters will stay unsettled", systemImage: "exclamationmark.triangle")                 .font(.subheadline.weight(.semibold))-                .foregroundStyle(AsterismColors.amberDark)+                .foregroundStyle(AsterismColors.amberText)             Text("This title names the Work but does not identify a chapter, and no chapter comes from the URL. Add URL details to source the chapter, or teach anyway and leave chapters unsettled.")                 .font(.footnote).foregroundStyle(.secondary)             Button {@@ -333,12 +338,13 @@ struct ComposedTeachingView: View {                     .font(.headline)                     .frame(maxWidth: .infinity, minHeight: AsterismLayout.minHitTarget)             }-            .buttonStyle(.borderedProminent)+            .buttonStyle(.constellationPrimary)             .accessibilityIdentifier("composed-acknowledge-confirm")         }         .padding(12)-        .background(AsterismColors.amberDark.opacity(0.1))-        .clipShape(RoundedRectangle(cornerRadius: 8))+        // Decision 1: an interstitial the reader has to clear is an+        // actionable-attention surface — amber fill and border.+        .constellationAttentionSurface()         // Without `children: .contain` the identifier collapses the panel into a         // single element and hides its own confirm button from assistive tech.         .accessibilityElement(children: .contain)@@ -352,17 +358,16 @@ struct ComposedTeachingView: View {             Task { await model.confirm() }         } label: {             Text("Teach")-                .font(.headline)-                .frame(maxWidth: .infinity, minHeight: AsterismLayout.minHitTarget)         }-        .buttonStyle(.borderedProminent)+        // Req 9.1: the teaching sheet's one gradient control.+        .buttonStyle(.constellationPrimary)         .disabled(!model.canConfirm)         .accessibilityIdentifier("composed-teaching-confirm")     }      private var committedContent: some View {         VStack(spacing: 12) {-            Image(systemName: "checkmark.circle.fill").font(.largeTitle).foregroundStyle(.green)+            Image(systemName: "checkmark.circle.fill").font(.largeTitle).foregroundStyle(AsterismColors.cyan)                 .accessibilityHidden(true)             Text("Taught successfully").font(.headline)             Button("Done") { dismiss() }@@ -379,7 +384,7 @@ struct ComposedTeachingView: View {                 .font(.subheadline)             if let outcome = model.previewOutcome { previewSection(outcome) }             Button("Confirm Again") { Task { await model.reconfirm() } }-                .buttonStyle(.borderedProminent)+                .buttonStyle(.constellationPrimary)                 .frame(maxWidth: .infinity, minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("composed-teaching-reconfirm")         }@@ -388,7 +393,7 @@ struct ComposedTeachingView: View {      private var invalidatedContent: some View {         VStack(spacing: 12) {-            Image(systemName: "xmark.circle").font(.largeTitle).foregroundStyle(.red).accessibilityHidden(true)+            Image(systemName: "xmark.circle").font(.largeTitle).foregroundStyle(AsterismColors.amberText).accessibilityHidden(true)             Text("Cannot apply teaching").font(.headline)             if let reason = model.invalidationReason {                 Text(reason).font(.subheadline).foregroundStyle(.secondary).multilineTextAlignment(.center)@@ -403,12 +408,12 @@ struct ComposedTeachingView: View {      private var errorContent: some View {         VStack(spacing: 12) {-            Image(systemName: "exclamationmark.triangle.fill").font(.largeTitle).foregroundStyle(.red).accessibilityHidden(true)+            Image(systemName: "exclamationmark.triangle.fill").font(.largeTitle).foregroundStyle(AsterismColors.amberText).accessibilityHidden(true)             if let message = model.errorMessage {                 Text(message).font(.subheadline).multilineTextAlignment(.center)             }             Button("Try Again") { Task { await model.retry() } }-                .buttonStyle(.borderedProminent)+                .buttonStyle(.constellationPrimary)                 .frame(minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("composed-teaching-retry")         }

diff --git a/Asterism/Asterism/Views/ComposedURLDetailsEditor.swift b/Asterism/Asterism/Views/ComposedURLDetailsEditor.swiftindex ca64617..f4fdf5f 100644--- a/Asterism/Asterism/Views/ComposedURLDetailsEditor.swift+++ b/Asterism/Asterism/Views/ComposedURLDetailsEditor.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// One selected raw URL component: a whole path component or a query item.@@ -192,7 +193,7 @@ struct ComposedURLDetailsEditor: View {                 publish(nil)             }             .font(.footnote)-            .frame(minHeight: ComposedTeachingPresentation.minimumHitTarget)+            .frame(minHeight: AsterismLayout.minHitTarget)             .accessibilityIdentifier("composed-url-clear")         }     }@@ -218,15 +219,14 @@ struct ComposedURLDetailsEditor: View {             HStack(spacing: 4) {                 Text(chipSymbol(for: role))                     .font(.caption.monospaced().bold())-                    .foregroundStyle(chipColor(for: role))-                Text(text).font(.subheadline).lineLimit(1)+                Text(text).lineLimit(1)             }-            .padding(.horizontal, 12)-            .padding(.vertical, 8)-            .frame(minHeight: ComposedTeachingPresentation.minimumHitTarget)-            .background(chipColor(for: role).opacity(0.12))-            .clipShape(Capsule())-            .overlay(Capsule().stroke(chipColor(for: role).opacity(0.4), lineWidth: 1))+            .frame(minHeight: AsterismLayout.minHitTarget)+            // §7: URL chips are the chip recipe in SF Mono at radius 12.+            .constellationChip(+                role: chipRole(for: role),+                isSelected: role == .work || role == .sequence,+                isMonospaced: true)         }         .buttonStyle(.plain)         .disabled(isBlank)@@ -252,11 +252,13 @@ struct ComposedURLDetailsEditor: View {         }     } -    private func chipColor(for role: ChipRole) -> Color {+    /// Q36: the style guide's §7 mapping — the Work component is cyan, the+    /// chapter-sequence component amber. The shipped inverse is superseded.+    private func chipRole(for role: ChipRole) -> ConstellationChipRole {         switch role {-        case .work: AsterismColors.amberDark-        case .sequence: AsterismColors.cyanDark-        case .empty, .none: .secondary+        case .work: .work+        case .sequence: .chapter+        case .empty, .none: .ignored         }     } @@ -299,7 +301,7 @@ struct ComposedURLDetailsEditor: View {                         Text("Split “\(text)” into a Work part and a chapter part.")                             .font(.footnote).foregroundStyle(.secondary)                     }-                    .frame(maxWidth: .infinity, minHeight: ComposedTeachingPresentation.minimumHitTarget, alignment: .leading)+                    .frame(maxWidth: .infinity, minHeight: AsterismLayout.minHitTarget, alignment: .leading)                     .contentShape(Rectangle())                 }                 .buttonStyle(.plain)@@ -315,7 +317,8 @@ struct ComposedURLDetailsEditor: View {                 .font(.caption).foregroundStyle(.secondary)             splitTokenRow(text: text, split: split)             if let splitErrorMessage {-                Text(splitErrorMessage).font(.caption).foregroundStyle(.red)+                // Q37: amber, not system red — the palette has no error colour.+                Text(splitErrorMessage).font(.caption).foregroundStyle(AsterismColors.amberText)                     .accessibilityIdentifier("composed-url-split-error")             }             Button("Use the whole component instead") {@@ -324,12 +327,13 @@ struct ComposedURLDetailsEditor: View {                 dispatchRuleDefinition()             }             .font(.footnote)-            .frame(minHeight: ComposedTeachingPresentation.minimumHitTarget)+            .frame(minHeight: AsterismLayout.minHitTarget)             .accessibilityIdentifier("composed-url-unsplit-button")         }         .padding(12)-        .background(Color(.secondarySystemBackground))-        .clipShape(RoundedRectangle(cornerRadius: 12))+        // §4: content inside a sheet sits on the flat field fill — no border,+        // no blur, no shadow.+        .constellationField()         .accessibilityElement(children: .contain)         .accessibilityIdentifier("composed-url-split-editor")     }@@ -344,19 +348,19 @@ struct ComposedURLDetailsEditor: View {                     let tokenText = String(characters[tokenRange])                     let isWork = tokenRange.overlaps(split.work)                     let isSequence = tokenRange.overlaps(split.sequence)-                    let color: Color = isWork ? AsterismColors.amberDark : isSequence ? AsterismColors.cyanDark : .secondary+                    // Q36's mapping again: Work cyan, chapter sequence amber.+                    let tokenRole: ConstellationChipRole =+                        isWork ? .work : isSequence ? .chapter : .ignored                     Button {                         toggleSplitToken(at: index, tokens: tokens)                     } label: {                         Text(tokenText)-                            .font(.footnote.monospaced())                             .lineLimit(1)-                            .padding(.horizontal, 10)-                            .padding(.vertical, 6)-                            .frame(minHeight: ComposedTeachingPresentation.minimumHitTarget)-                            .background(color.opacity(0.12))-                            .clipShape(Capsule())-                            .overlay(Capsule().stroke(color.opacity(0.4), lineWidth: 1))+                            .frame(minHeight: AsterismLayout.minHitTarget)+                            .constellationChip(+                                role: tokenRole,+                                isSelected: isWork || isSequence,+                                isMonospaced: true)                     }                     .buttonStyle(.plain)                     .accessibilityIdentifier("composed-url-split-token-\(index)")

diff --git a/Asterism/Asterism/Views/DuplicateResolutionView.swift b/Asterism/Asterism/Views/DuplicateResolutionView.swiftindex 8b7dea7..8be2332 100644--- a/Asterism/Asterism/Views/DuplicateResolutionView.swift+++ b/Asterism/Asterism/Views/DuplicateResolutionView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// The resolution sheet (Requirement 4, and Req 5.4's Work half).@@ -74,7 +75,7 @@ struct DuplicateResolutionView: View {                         "Another copy arrived while this was open, so these are the copies as they stand now."                     )                     .font(.caption)-                    .foregroundStyle(AsterismColors.amberDark)+                    .foregroundStyle(AsterismColors.amberText)                     .accessibilityIdentifier("duplicate-resolution-refreshed-notice")                 }             }@@ -87,7 +88,14 @@ struct DuplicateResolutionView: View {                     variantRow(id: variant.id) { workVariantContent(variant) }                 }             } header: {+                // Decision 1 and Q46: duplicate review is an+                // actionable-attention surface, and this header is the sheet's+                // question rather than a label for a list — so it keeps the+                // section-header font in amber, in sentence case and without+                // the ✦ prefix. The one documented exception to 8.4.                 Text("Which copy do you want to keep?")+                    .font(AsterismTypography.sectionHeader)+                    .foregroundStyle(AsterismColors.amberText)                     .accessibilityIdentifier("duplicate-resolution-header")             } @@ -109,20 +117,20 @@ struct DuplicateResolutionView: View {              if let errorMessage = model.errorMessage {                 Section {+                    // Q37: amber, not system red.                     Text(errorMessage)-                        .foregroundStyle(.red)+                        .foregroundStyle(AsterismColors.amberText)                         .accessibilityIdentifier("duplicate-resolution-error-message")                 }             }              Section {+                // Req 9.1: the sheet's one primary action.                 Button("Keep this copy") {                     Task { await model.confirm() }                 }+                .buttonStyle(.constellationPrimary)                 .disabled(!model.canConfirm)-                .frame(-                    minWidth: AsterismLayout.minHitTarget,-                    minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("duplicate-resolution-confirm")             } footer: {                 Text("The other copies are removed. Nothing happens until you tap this.")@@ -142,7 +150,7 @@ struct DuplicateResolutionView: View {                     systemName: model.selectedVariantID == id                         ? "largecircle.fill.circle" : "circle"                 )-                .foregroundStyle(AsterismColors.cyanDark)+                .foregroundStyle(AsterismColors.cyan)                 .accessibilityHidden(true)                 content()                 Spacer(minLength: 0)@@ -171,7 +179,7 @@ struct DuplicateResolutionView: View {                 if model.differingFields.contains(.chapterTitle), let chapter = variant.chapterTitle {                     Text(chapter)                         .font(.caption)-                        .foregroundStyle(AsterismColors.cyanDark)+                        .foregroundStyle(AsterismColors.cyan)                 }                 if model.differingFields.contains(.workAssignment) {                     Text(variant.workTitle ?? "Not assigned")@@ -196,7 +204,7 @@ struct DuplicateResolutionView: View {     private func workVariantContent(_ variant: WorkVariantChoice) -> some View {         VStack(alignment: .leading, spacing: 4) {             Text(variant.displayTitle)-                .font(AsterismTypography.serifTitle(15))+                .font(AsterismTypography.serifRowTitle)                 .accessibilityIdentifier("duplicate-variant-title")             if !variant.genericNotes.isEmpty {                 Text(variant.genericNotes)@@ -208,7 +216,7 @@ struct DuplicateResolutionView: View {                 if model.differingFields.contains(.type) {                     Text(variant.type.rawValue)                         .font(.caption2.weight(.semibold))-                        .foregroundStyle(AsterismColors.violetDark)+                        .foregroundStyle(AsterismColors.violet)                 }                 if model.differingFields.contains(.genreTags), !variant.genreTags.isEmpty {                     Text(variant.genreTags.joined(separator: ", "))

diff --git a/Asterism/Asterism/Views/EntryDetailView.swift b/Asterism/Asterism/Views/EntryDetailView.swiftindex 3a68591..df98b27 100644--- a/Asterism/Asterism/Views/EntryDetailView.swift+++ b/Asterism/Asterism/Views/EntryDetailView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// Entry detail: shows entry metadata and provides note/rating editing, assignment,@@ -8,6 +9,10 @@ struct EntryDetailView: View {     @Environment(\.dismiss) private var dismiss     @State private var showingComposedTeaching = false     @State private var showingReparse = false+    /// Req 1.5's staging model. `@State`-owned like `SettingsView`'s: it holds+    /// the staged file, and a fresh instance per re-render would lose track of+    /// what there is to clean up.+    @State private var exportModel: MarkdownExportModel?     let onMoveTo: () -> Void     /// Req 9.2's route out of a torn record, or nil where the caller has no     /// sheet to open (previews, and the surfaces that host this without one).@@ -16,10 +21,12 @@ struct EntryDetailView: View {     init(         model: EntryDetailModel,         onMoveTo: @escaping () -> Void,-        onResolveDuplicate: (() -> Void)? = nil+        onResolveDuplicate: (() -> Void)? = nil,+        exportModel: MarkdownExportModel? = nil     ) {         self.onResolveDuplicate = onResolveDuplicate         _model = State(initialValue: model)+        _exportModel = State(initialValue: exportModel)         self.onMoveTo = onMoveTo     } @@ -46,26 +53,38 @@ struct EntryDetailView: View {             }         }         .navigationTitle("Entry")+        // Requirement 8.1's fixed layer. On the screen's own root rather than+        // on the enclosing `NavigationStack`: a background applied outside the+        // stack renders behind the stack's own opaque backing and never+        // reaches the screen.+        .background { ConstellationBackground() }         .task { await model.load() }     }      @ViewBuilder     private func entryContent(_ entry: EntrySnapshot) -> some View {         Form {-            Section("Details") {+            Section {                 LabeledContent("Title") {+                    // Req 8.3: the chapter heading is the serif face.                     Text(model.teachingDetail?.displayTitle ?? entry.captureTitle)-                        .font(AsterismTypography.serifTitle(17))+                        .font(AsterismTypography.serifHeading)+                        .foregroundStyle(AsterismColors.primaryText)                 }                 .accessibilityIdentifier("entry-detail-title")                  LabeledContent("Site") {-                    Text(entry.hostname)+                    HStack(spacing: 6) {+                        SiteGlyph(hostname: entry.hostname, size: 18)+                        Text(entry.hostname)+                            .foregroundStyle(AsterismColors.secondaryText)+                    }                 }                 .accessibilityIdentifier("entry-detail-hostname")                  LabeledContent("Shared") {                     Text(entry.lastSharedAt, style: .date)+                        .foregroundStyle(AsterismColors.secondaryText)                 }                 .accessibilityIdentifier("entry-detail-shared") @@ -74,15 +93,19 @@ struct EntryDetailView: View {                         .frame(minHeight: AsterismLayout.minHitTarget)                         .accessibilityIdentifier("entry-detail-link")                 }+            } header: {+                ConstellationSectionHeader("Details")             }              if model.supportsTitleRecovery,                let detail = model.teachingDetail,                !detail.availableActions.isEmpty {-                Section("Title Recovery") {+                Section {                     ForEach(detail.availableActions, id: \.self) { action in                         actionButton(for: action)                     }+                } header: {+                    ConstellationSectionHeader("Title Recovery", accent: .violet)                 }             } @@ -92,39 +115,50 @@ struct EntryDetailView: View {              if model.isReadOnly { duplicateReviewSection } -            Section("Note") {+            Section {                 TextEditor(text: $model.draftNote)                     .frame(minHeight: 80)+                    .scrollContentBackground(.hidden)+                    .padding(8)+                    .constellationField()                     .disabled(model.isReadOnly)                     .accessibilityIdentifier("entry-detail-note-editor")                     .accessibilityLabel("Entry note")+            } header: {+                ConstellationSectionHeader("Note", accent: .violet)             } -            Section("Rating") {+            Section {                 HStack(spacing: 16) {                     ratingButton(.up)                     ratingButton(.down)                     Spacer()                 }                 .disabled(model.isReadOnly)+            } header: {+                ConstellationSectionHeader("Rating", accent: .violet)             }              if let errorMessage = model.errorMessage {                 Section {+                    // Q37: amber, not system red — the palette has no error+                    // colour and the failure is recoverable.                     Text(errorMessage)-                        .foregroundStyle(.red)+                        .foregroundStyle(AsterismColors.amberText)                         .accessibilityIdentifier("entry-detail-error")                 }             }              Section {+                // Req 9.1: this screen's single gradient control. Move to,+                // Export, and Delete stay ordinary rows.                 Button("Update") {                     Task { await model.update() }                 }+                .buttonStyle(.constellationPrimary)                 // Req 2.8: a torn record's authored fields are read-only until                 // its resolution. Deleting stays available — it discloses first.                 .disabled(model.state == .submitting || model.isReadOnly)-                .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("entry-detail-update-button")                  Button("Move to") {@@ -134,6 +168,11 @@ struct EntryDetailView: View {                 .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("entry-detail-move-to-button") +                // Req 1.1. Available on a torn record too, unlike the editing+                // actions: export never refuses over duplicate state (1.8), it+                // renders the same carrier the screen above is showing.+                exportRow+                 Button("Delete Entry", role: .destructive) {                     Task {                         await model.delete()@@ -145,6 +184,8 @@ struct EntryDetailView: View {                 .accessibilityIdentifier("entry-detail-delete-button")             }         }+        // Req 8.1: the tab stack's sky shows through this pushed screen.+        .scrollContentBackground(.hidden)         // Req 2.8's disclosure. The alert lists the copies that differ, and its         // destructive button is the *only* way the delete gets a disclosure to         // hand the commit — so a group cannot go while the reader has been told@@ -188,6 +229,32 @@ struct EntryDetailView: View {                 ReparseView(model: reparseModel)             }         }+        .markdownExportShare(+            model: exportModel, sheetIdentifier: "entry-detail-export-share-sheet")+    }++    /// Req 1.1's action, and the failure line beside it.+    ///+    /// Wording comes from the model, which owns the privacy rule — this view+    /// never composes a message about an export.+    @ViewBuilder+    private var exportRow: some View {+        if let exportModel {+            Button(exportModel.state == .exporting ? "Preparing export…" : "Export") {+                Task { await exportModel.startExport() }+            }+            .disabled(exportModel.state == .exporting)+            .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+            .accessibilityIdentifier("entry-detail-export-button")+            .accessibilityLabel("Export this note as markdown")++            if exportModel.state == .failed, let message = exportModel.errorMessage {+                Text(message)+                    .font(.caption)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("entry-detail-export-error")+            }+        }     }      @ViewBuilder@@ -224,20 +291,24 @@ struct EntryDetailView: View {     /// and offer the route that turns them back on.     private var duplicateReviewSection: some View {         Section {-            VStack(alignment: .leading, spacing: 6) {+            VStack(alignment: .leading, spacing: 8) {                 Text("This entry arrived \(model.rowCount) times and the copies differ.")                     .font(.callout)+                    .foregroundStyle(AsterismColors.primaryText)                 Text("Editing is off until you choose which one to keep — nothing has been lost.")                     .font(.caption)-                    .foregroundStyle(.secondary)+                    .foregroundStyle(AsterismColors.secondaryText)                 if let onResolveDuplicate {                     Button("Resolve copies") { onResolveDuplicate() }-                        .frame(-                            minWidth: AsterismLayout.minHitTarget,-                            minHeight: AsterismLayout.minHitTarget)+                        .buttonStyle(.constellationSecondary)                         .accessibilityIdentifier("entry-detail-resolve-duplicate-button")                 }             }+            .frame(maxWidth: .infinity, alignment: .leading)+            .padding(12)+            // Decision 1: duplicate review is actionable attention → amber.+            .constellationCard(borderColor: AsterismColors.attentionBorder)+            .constellationListRow()             .accessibilityIdentifier("entry-detail-duplicate-notice")         }     }@@ -252,11 +323,10 @@ struct EntryDetailView: View {         return ([opening] + disclosure.lines).joined(separator: "\n\n")     } +    /// §7's rating toggle: a 48×42 capsule, accent fill and glow when active.     @ViewBuilder     private func ratingButton(_ rating: Rating) -> some View {         let isSelected = model.draftRating == rating-        let label = rating == .up ? "▲" : "▼"-        let color = rating == .up ? AsterismColors.cyanDark : AsterismColors.violetDark          Button {             if model.draftRating == rating {@@ -265,12 +335,12 @@ struct EntryDetailView: View {                 model.draftRating = rating             }         } label: {-            Text(label)+            Text(rating == .up ? "▲" : "▼")                 .font(.title3)-                .foregroundStyle(isSelected ? color : .secondary)-                .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)         }-        .buttonStyle(.plain)+        .buttonStyle(+            .constellationRatingToggle(rating == .up ? .up : .down, isActive: isSelected)+        )         .accessibilityIdentifier("entry-detail-rating-\(rating.rawValue)")         .accessibilityLabel(rating == .up ? "Rate up" : "Rate down")         .accessibilityAddTraits(isSelected ? .isSelected : [])@@ -278,6 +348,8 @@ struct EntryDetailView: View {      // MARK: - Provenance disclosure +    /// §7's provenance disclosure: quieter-than-card fill, SF Mono 11 pt, dim,+    /// labels slightly brighter, collapsed by default.     @ViewBuilder     private func provenanceSection(_ entry: EntrySnapshot) -> some View {         Section {@@ -285,19 +357,19 @@ struct EntryDetailView: View {                 VStack(alignment: .leading, spacing: 8) {                     LabeledContent("Capture Title") {                         Text(entry.captureTitle)-                            .font(.caption)+                            .font(AsterismTypography.mono)                     }                     .accessibilityIdentifier("provenance-capture-title")                      LabeledContent("Source") {                         Text(entry.captureTitleSource.rawValue)-                            .font(.caption)+                            .font(AsterismTypography.mono)                     }                     .accessibilityIdentifier("provenance-title-source")                      LabeledContent("URL") {                         Text(entry.rawURLString)-                            .font(.caption)+                            .font(AsterismTypography.mono)                             .lineLimit(2)                     }                     .accessibilityIdentifier("provenance-raw-url")@@ -305,7 +377,7 @@ struct EntryDetailView: View {                     if let canonical = entry.canonicalURLString {                         LabeledContent("Canonical URL") {                             Text(canonical)-                                .font(.caption)+                                .font(AsterismTypography.mono)                                 .lineLimit(2)                         }                         .accessibilityIdentifier("provenance-canonical-url")@@ -314,20 +386,20 @@ struct EntryDetailView: View {                     // Chapter provenance with settlement reason                     LabeledContent("Chapter") {                         Text(entry.chapterTitle ?? "—")-                            .font(.caption)+                            .font(AsterismTypography.mono)                     }                     .accessibilityIdentifier("provenance-chapter")                      if let detail = model.teachingDetail {                         LabeledContent("Chapter Settlement") {                             Text(settlementLabel(detail.chapterSettlement))-                                .font(.caption)+                                .font(AsterismTypography.mono)                         }                         .accessibilityIdentifier("provenance-chapter-settlement")                          LabeledContent("Assignment Settlement") {                             Text(settlementLabel(detail.assignmentSettlement))-                                .font(.caption)+                                .font(AsterismTypography.mono)                         }                         .accessibilityIdentifier("provenance-assignment-settlement") @@ -344,20 +416,25 @@ struct EntryDetailView: View {                         // Fallback when detail not yet loaded                         LabeledContent("Chapter Provenance") {                             Text(provenanceKindLabel(entry.chapterTitleProvenance))-                                .font(.caption)+                                .font(AsterismTypography.mono)                         }                         .accessibilityIdentifier("provenance-chapter-kind")                          LabeledContent("Assignment Provenance") {                             Text(provenanceKindLabel(entry.workAssignmentProvenance))-                                .font(.caption)+                                .font(AsterismTypography.mono)                         }                         .accessibilityIdentifier("provenance-assignment-kind")                     }                 }+                .foregroundStyle(AsterismColors.secondaryText)+                .frame(maxWidth: .infinity, alignment: .leading)+                .padding(10)+                .constellationProvenanceSurface()             } label: {                 Text("Provenance")                     .font(.subheadline)+                    .foregroundStyle(AsterismColors.primaryText)             }         }         .accessibilityIdentifier("entry-detail-provenance")@@ -368,20 +445,23 @@ struct EntryDetailView: View {         VStack(alignment: .leading, spacing: 4) {             Text(label)                 .font(.caption2)-                .foregroundStyle(.secondary)+                .foregroundStyle(AsterismColors.secondaryText)             Text(summary.plainLanguageRule)-                .font(.caption)+                .font(AsterismTypography.mono)             HStack {                 Text("ID: \(summary.id.uuidString.prefix(8))…")-                    .font(.caption2.monospaced())-                    .foregroundStyle(.secondary)+                    .font(AsterismTypography.mono)+                    .foregroundStyle(AsterismColors.secondaryText)                 Text("v\(summary.version)")-                    .font(.caption2.monospaced())-                    .foregroundStyle(.secondary)+                    .font(AsterismTypography.mono)+                    .foregroundStyle(AsterismColors.secondaryText)+                // Q37: the positive/active marker is cyan, not system green —+                // §2 gives cyan the "yes/active" role and §11 forbids a fourth+                // accent hue.                 if summary.isActive {                     Text("active")                         .font(.caption2)-                        .foregroundStyle(.green)+                        .foregroundStyle(AsterismColors.cyan)                 }             }         }

diff --git a/Asterism/Asterism/Views/MaintenanceViews.swift b/Asterism/Asterism/Views/MaintenanceViews.swiftindex d48d2fe..7000f89 100644--- a/Asterism/Asterism/Views/MaintenanceViews.swift+++ b/Asterism/Asterism/Views/MaintenanceViews.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// The `Review URL identity` maintenance surface (Req 7.2), reached from Work@@ -48,7 +49,7 @@ struct URLIdentityReviewView: View {     private var reviewContent: some View {         Form {             if let projection = model.projection {-                Section("Summary") {+                Section(header: ConstellationSectionHeader("Summary", accent: .cyan)) {                     LabeledContent("Entries evaluated") { Text("\(projection.entries.count)") }                         .accessibilityIdentifier("review-entry-count")                     LabeledContent("Works evaluated") { Text("\(projection.works.count)") }@@ -58,11 +59,11 @@ struct URLIdentityReviewView: View {                 if projection.issues.isEmpty {                     Section {                         Label("No conflicts", systemImage: "checkmark.circle")-                            .foregroundStyle(.green)+                            .foregroundStyle(AsterismColors.cyan)                             .accessibilityIdentifier("review-no-issues")                     }                 } else {-                    Section("Conflicts") {+                    Section(header: ConstellationSectionHeader("Conflicts", accent: .violet)) {                         ForEach(Array(projection.issues.enumerated()), id: \.offset) { index, issue in                             let row = ConflictPresentation.row(for: issue)                             Label(row.text, systemImage: row.symbol)@@ -73,7 +74,7 @@ struct URLIdentityReviewView: View {                     }                 } -                Section("Work evidence") {+                Section(header: ConstellationSectionHeader("Work evidence", accent: .violet)) {                     ForEach(Array(projection.works.enumerated()), id: \.offset) { index, work in                         LabeledContent(evidenceLabel(work.evidence)) {                             Text(work.workID.uuidString.prefix(8) + "…")@@ -116,9 +117,14 @@ struct URLIdentityReviewView: View { /// nested stack would swallow the back affordance on either. struct LibraryDiagnosticsView: View {     @State private var model: LibraryDiagnosticsModel+    /// Requirement 8.1 puts the sky behind tab-stack content only, and this+    /// screen is pushed from two places: Recent's stack (sky) and the Settings+    /// sheet (no sky — a sheet is its own glass layer, §4). The host says which.+    private let showsSky: Bool -    init(model: LibraryDiagnosticsModel) {+    init(model: LibraryDiagnosticsModel, showsSky: Bool = false) {         _model = State(initialValue: model)+        self.showsSky = showsSky     }      var body: some View {@@ -142,6 +148,7 @@ struct LibraryDiagnosticsView: View {         }         .navigationTitle("Library Check")         .navigationBarTitleDisplayMode(.inline)+        .background { if showsSky { ConstellationBackground() } }         .task { await model.load() }     } @@ -153,7 +160,7 @@ struct LibraryDiagnosticsView: View {                         .font(.headline)                         // Q21: damage is not a routine count, and the colour is a                         // reinforcement of the wording, never the only signal.-                        .foregroundStyle(model.suggestsDamage ? AnyShapeStyle(Color.red) : AnyShapeStyle(.primary))+                        .foregroundStyle(model.suggestsDamage ? AnyShapeStyle(AsterismColors.amberText) : AnyShapeStyle(AsterismColors.primaryText))                     Text(model.detail)                         .font(.footnote)                         .foregroundStyle(.secondary)@@ -238,17 +245,17 @@ struct RecalculateView: View {                 case .confirming:                     ProgressView("Recalculating…").accessibilityIdentifier("recalculate-confirming")                 case .committed:-                    terminal(symbol: "checkmark.circle.fill", color: .green, title: "Recalculated",+                    terminal(symbol: "checkmark.circle.fill", color: AsterismColors.cyan, title: "Recalculated",                              id: "recalculate-committed")                 case .noChanges:-                    terminal(symbol: "equal.circle", color: .secondary, title: "Nothing to recalculate",+                    terminal(symbol: "equal.circle", color: AsterismColors.secondaryText, title: "Nothing to recalculate",                              id: "recalculate-no-changes")                 case .invalidated:-                    terminal(symbol: "xmark.circle", color: .red,+                    terminal(symbol: "xmark.circle", color: AsterismColors.amberText,                              title: model.invalidationReason ?? "Recalculation is no longer valid",                              id: "recalculate-invalidated")                 case .error:-                    terminal(symbol: "exclamationmark.triangle.fill", color: .red,+                    terminal(symbol: "exclamationmark.triangle.fill", color: AsterismColors.amberText,                              title: model.errorMessage ?? "An error occurred", id: "recalculate-error")                 }             }@@ -275,16 +282,18 @@ struct RecalculateView: View {                 }             }             if let outcome = model.previewOutcome {-                Section("Preview (\(outcome.entries.count) entries)") {+                Section(header: ConstellationSectionHeader("Preview (\(outcome.entries.count) entries)", accent: .violet)) {                     ForEach(Array(outcome.entries.prefix(8).enumerated()), id: \.offset) { index, projection in                         VStack(alignment: .leading, spacing: 2) {+                            // Q36: work = cyan, chapter = amber, as the teach+                            // chips read.                             if let name = projection.workName {-                                Text(name).font(.caption).foregroundStyle(AsterismColors.amberDark).lineLimit(1)+                                Text(name).font(.caption).foregroundStyle(AsterismColors.cyan).lineLimit(1)                             }                             if let chapter = projection.projectedChapterTitle {-                                Text(chapter).font(.caption2).foregroundStyle(AsterismColors.cyanDark)+                                Text(chapter).font(.caption2).foregroundStyle(AsterismColors.amberText)                             } else if let sequence = projection.projectedChapterSequence {-                                Text("#\(sequence)").font(.caption2).foregroundStyle(AsterismColors.cyanDark)+                                Text("#\(sequence)").font(.caption2).foregroundStyle(AsterismColors.amberText)                             }                         }                         .accessibilityElement(children: .combine)@@ -292,7 +301,7 @@ struct RecalculateView: View {                     }                 }                 if !outcome.issues.isEmpty {-                    Section("Conflicts") {+                    Section(header: ConstellationSectionHeader("Conflicts", accent: .violet)) {                         ForEach(Array(outcome.issues.enumerated()), id: \.offset) { _, issue in                             let row = ConflictPresentation.row(for: issue)                             Label(row.text, systemImage: row.symbol).font(.caption)@@ -304,7 +313,7 @@ struct RecalculateView: View {                 Button(model.state == .refreshed ? "Confirm Again" : "Recalculate") {                     Task { await model.confirm() }                 }-                .buttonStyle(.borderedProminent)+                .buttonStyle(.constellationPrimary)                 .disabled(!model.canConfirm && model.state != .refreshed)                 .frame(maxWidth: .infinity, minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("recalculate-confirm")

diff --git a/Asterism/Asterism/Views/MoveToView.swift b/Asterism/Asterism/Views/MoveToView.swiftindex 06fd2e7..57edfe5 100644--- a/Asterism/Asterism/Views/MoveToView.swift+++ b/Asterism/Asterism/Views/MoveToView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// Move-to sheet: same-host Works, New Work, and Leave unattached.@@ -42,13 +43,15 @@ struct MoveToView: View {     private var destinationsList: some View {         List {             if !model.destinations.isEmpty {-                Section("Same-host Works") {+                Section {                     ForEach(model.destinations, id: \.id) { work in                         Button {                             Task { await model.moveToExisting(work.id) }                         } label: {                             Text(work.displayTitle)-                                .font(AsterismTypography.serifTitle(15))+                                .font(AsterismTypography.serifRowTitle)+                                .lineLimit(1)+                                .truncationMode(.tail)                         }                         .disabled(model.state == .submitting)                         .frame(@@ -58,6 +61,8 @@ struct MoveToView: View {                         .accessibilityIdentifier("move-to-work-destination")                         .accessibilityLabel("Move to \(work.displayTitle)")                     }+                } header: {+                    ConstellationSectionHeader("Same-host Works")                 }             } @@ -93,7 +98,7 @@ struct MoveToView: View {             if let errorMessage = model.errorMessage {                 Section {                     Text(errorMessage)-                        .foregroundStyle(.red)+                        .foregroundStyle(AsterismColors.amberText)                         .accessibilityIdentifier("move-to-error")                 }             }

diff --git a/Asterism/Asterism/Views/NewWorkView.swift b/Asterism/Asterism/Views/NewWorkView.swiftindex 8e484b3..4cd79ad 100644--- a/Asterism/Asterism/Views/NewWorkView.swift+++ b/Asterism/Asterism/Views/NewWorkView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// New Work form: title and hostname fields with explicit Create action.@@ -13,7 +14,7 @@ struct NewWorkView: View {     var body: some View {         NavigationStack {             Form {-                Section("New Work") {+                Section {                     TextField("Title", text: $model.draftTitle)                         .accessibilityIdentifier("new-work-title-field") @@ -21,25 +22,28 @@ struct NewWorkView: View {                         .textInputAutocapitalization(.never)                         .autocorrectionDisabled()                         .accessibilityIdentifier("new-work-hostname-field")+                } header: {+                    ConstellationSectionHeader("New Work")                 }                  if let errorMessage = model.errorMessage {                     Section {                         Text(errorMessage)-                            .foregroundStyle(.red)+                            .foregroundStyle(AsterismColors.amberText)                             .accessibilityIdentifier("new-work-error")                     }                 }                  Section {+                    // Req 9.1: the sheet's one gradient control.                     Button("Create") {                         Task {                             await model.create()                             if case .created = model.state { dismiss() }                         }                     }+                    .buttonStyle(.constellationPrimary)                     .disabled(model.state == .submitting)-                    .frame(minHeight: AsterismLayout.minHitTarget)                     .accessibilityIdentifier("new-work-create-button")                 }             }

diff --git a/Asterism/Asterism/Views/PostTeachingWorkURLView.swift b/Asterism/Asterism/Views/PostTeachingWorkURLView.swiftindex a74190b..5de05ff 100644--- a/Asterism/Asterism/Views/PostTeachingWorkURLView.swift+++ b/Asterism/Asterism/Views/PostTeachingWorkURLView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// Post-teaching Work URL confirmation queue: each affected Work's candidate@@ -44,9 +45,9 @@ struct PostTeachingWorkURLView: View {                     .accessibilityIdentifier("post-teaching-progress")             } -            Section("Work") {+            Section(header: ConstellationSectionHeader("Work", accent: .cyan)) {                 Text(candidate.workTitle)-                    .font(AsterismTypography.serifTitle(17))+                    .font(AsterismTypography.serifHeading)                     .accessibilityIdentifier("post-teaching-work-title")                  switch candidate.candidate {@@ -68,7 +69,7 @@ struct PostTeachingWorkURLView: View {             if let errorMessage = model.errorMessage {                 Section {                     Text(errorMessage)-                        .foregroundStyle(.red)+                        .foregroundStyle(AsterismColors.amberText)                         .accessibilityIdentifier("post-teaching-error")                 }             }@@ -104,7 +105,7 @@ struct PostTeachingWorkURLView: View {         VStack(spacing: 16) {             Image(systemName: "checkmark.circle.fill")                 .font(.largeTitle)-                .foregroundStyle(.green)+                .foregroundStyle(AsterismColors.cyan)                 .accessibilityHidden(true)             Text("Work URLs reviewed")                 .font(.headline)@@ -112,7 +113,7 @@ struct PostTeachingWorkURLView: View {                 .font(.subheadline)                 .foregroundStyle(.secondary)             Button("Done") { onDone() }-                .buttonStyle(.borderedProminent)+                .buttonStyle(.constellationPrimary)                 .frame(minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("post-teaching-complete-done")         }

diff --git a/Asterism/Asterism/Views/RecentView.swift b/Asterism/Asterism/Views/RecentView.swiftindex 2afcdb1..ffea745 100644--- a/Asterism/Asterism/Views/RecentView.swift+++ b/Asterism/Asterism/Views/RecentView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// Recent tab: shows all entries grouped by day, ordered by lastSharedAt descending.@@ -37,6 +38,9 @@ struct RecentView: View {      @State private var showingActionableOnly = false     @State private var showingDuplicatesOnly = false+    /// Req 3.1's query, beside the banner filters because it composes with them+    /// rather than replacing them (3.2, Q6).+    @State private var searchQuery = ""      init(         presentation: RecentPresentation,@@ -82,7 +86,37 @@ struct RecentView: View {         }     } +    private var searchFilter: RecentSearchFilter {+        RecentSearchFilter(query: searchQuery)+    }++    /// Req 3.2: search runs **after** the banner filters, so both conditions+    /// apply. Never before — the unfiltered set would surface a row the banner+    /// had deliberately excluded.+    private var searchedGroups: [RecentPresentationGroup] {+        searchFilter.apply(to: displayGroups)+    }++    /// Q13: the Elsewhere lines are summary sentences with no titles to match,+    /// so a query never hides them. That also decides the search-empty branch:+    /// while those lines are on screen the banner's count is still accounted+    /// for, and replacing the list with an empty state would break the "every+    /// counted item is a row or a line" invariant (Q39).+    private var showsElsewhereSection: Bool {+        showingDuplicatesOnly && !duplicatePlan.elsewhere.isEmpty+    }++    /// Req 3.4: a query with no matches gets a message, not a blank list. The+    /// empty branch above cannot serve — it keys on the library being empty and+    /// never fires for a no-match query.+    private func showsSearchEmptyState(for groups: [RecentPresentationGroup]) -> Bool {+        searchFilter.isActive && groups.isEmpty && !showsElsewhereSection+    }+     var body: some View {+        // Computed once per body evaluation: the empty check and the ForEach+        // below both consume it, and the filter runs per keystroke.+        let searchedGroups = self.searchedGroups         // The banner region sits **above** the empty-library branch (Q15). Two         // Site rows with no Entries yet — the first-sync shape — produce a         // diagnosis and zero Recent groups, so a banner living in the non-empty@@ -96,34 +130,49 @@ struct RecentView: View {             // outside Recent, and the section below is the only route to it.             if presentation.groups.isEmpty && !showingDuplicatesOnly {                 emptyBranch+            } else if showsSearchEmptyState(for: searchedGroups) {+                searchEmptyBranch             } else {                 List {-                    ForEach(displayGroups, id: \.day) { group in+                    ForEach(Array(searchedGroups.enumerated()), id: \.element.day) { index, group in                         Section {                             ForEach(group.rows) { row in                                 RecentEntryRow(                                     row: row,                                     onSelect: onSelect,                                     onTeach: onTeach,-                                    onResolveDuplicate: onResolveDuplicate.map { resolve in-                                        { key in resolve(key) }-                                    },+                                    onResolveDuplicate: onResolveDuplicate,                                     resolutionKey: duplicateSetKey(for: row)                                 )+                                .constellationListRow()                             }                         } header: {-                            Text(group.day, style: .date)-                                .font(AsterismTypography.sectionHeader)-                                .textCase(.uppercase)-                                .accessibilityIdentifier("recent-section-header")+                            // Req 8.4: ✦ cyan on the first section, violet on+                            // the ones after it (§3).+                            ConstellationSectionHeader(+                                group.day.formatted(date: .abbreviated, time: .omitted),+                                accent: index == 0 ? .cyan : .violet+                            )+                            .accessibilityIdentifier("recent-section-header")                         }                     }                     if showingDuplicatesOnly { elsewhereSection }                 }                 .listStyle(.plain)+                // Req 8.1: the sky is the tab stack's background and the+                // content scrolls over it.+                .scrollContentBackground(.hidden)                 .accessibilityIdentifier("recent-list")             }         }+        // Requirement 8.1's fixed layer. On the screen's own root rather than+        // on the enclosing `NavigationStack`: a background applied outside the+        // stack renders *behind* the stack's own opaque backing, and the sky+        // never reaches the screen (verified in the simulator — pure black).+        .background { ConstellationBackground() }+        // On the VStack, not the List: the List is swapped out for the empty+        // branches, and a search field attached to it would go with them.+        .searchable(text: $searchQuery, prompt: "Search notes")         .onChange(of: presentation.actionableCount) { _, newCount in             if newCount == 0 {                 showingActionableOnly = false@@ -161,6 +210,14 @@ struct RecentView: View {         }     } +    /// Req 3.4's message. Distinct from `emptyBranch`, which describes a library+    /// with nothing in it — this one describes a query with nothing behind it,+    /// and the difference matters to a reader who has just typed.+    private var searchEmptyBranch: some View {+        ContentUnavailableView.search(text: searchQuery)+            .accessibilityIdentifier("recent-search-empty")+    }+     /// The actionable banner ranks first when both apply: its action is the     /// routine one, and the diagnosis banner reports something the reader is not     /// expected to be doing every day (Q15).@@ -215,23 +272,33 @@ struct RecentView: View {             HStack(spacing: 6) {                 Image(systemName: icon)                     .font(.caption)-                    .foregroundStyle(AsterismColors.amberDark)+                    .foregroundStyle(AsterismColors.amberText)                     .accessibilityHidden(true)                 Text(text)                     .font(.caption)-                    .foregroundStyle(AsterismColors.amberDark)+                    .foregroundStyle(AsterismColors.amberText)                 Spacer()                 if let trailing {                     Text(trailing)                         .font(.caption.bold())-                        .foregroundStyle(AsterismColors.amberDark)+                        .foregroundStyle(AsterismColors.amberText)                 }+                // §7: the banner ends in a chevron — it always goes somewhere,+                // even when its call-to-action word is absent.+                Image(systemName: "chevron.right")+                    .font(.caption2.weight(.semibold))+                    .foregroundStyle(AsterismColors.amberText)+                    .accessibilityHidden(true)             }             .padding(.horizontal)-            .frame(minHeight: AsterismLayout.minHitTarget)-            .background(AsterismColors.amberDark.opacity(0.1))+            // §7's amber-tinted glass capsule, replacing the flat tint these+            // banners carried. Amber covers both teaching and duplicate review+            // here (Decision 1).+            .constellationBanner()         }         .buttonStyle(.plain)+        .padding(.horizontal, 16)+        .padding(.vertical, 4)         .accessibilityElement(children: .combine)         .accessibilityIdentifier(identifier)         .accessibilityLabel(accessibilityLabel)@@ -239,8 +306,11 @@ struct RecentView: View {      private var actionableBanner: some View {         bannerButton(+            // §7/§8: the inbox banner's glyph is the app's ✦ mark. The filter+            // symbol replaces it only while the banner is the active filter,+            // where it reports state rather than identity.             icon: showingActionableOnly-                ? "line.3.horizontal.decrease.circle.fill" : "star.fill",+                ? "line.3.horizontal.decrease.circle.fill" : "sparkle",             text: showingActionableOnly                 ? "Showing \(presentation.actionableCount) actionable"                 : "\(presentation.actionableCount) entries need teaching",@@ -273,9 +343,8 @@ struct RecentView: View {     }      private var duplicateBannerText: String {-        duplicateCount == 1-            ? "1 duplicate needs your decision"-            : "\(duplicateCount) duplicates need your decision"+        Pluralisation.count(duplicateCount, "duplicate needs", "duplicates need")+            + " your decision"     }      /// What the banner counted that Recent holds no row for (Req 9.1).@@ -303,22 +372,26 @@ struct RecentView: View {                         HStack(spacing: 8) {                             Image(systemName: "square.on.square.dashed")                                 .font(.caption)-                                .foregroundStyle(AsterismColors.amberDark)+                                .foregroundStyle(AsterismColors.amberText)                                 .accessibilityHidden(true)                             Text(item.text)                                 .font(.callout)+                                .foregroundStyle(AsterismColors.noteText)                             Spacer()                         }                         .frame(minHeight: AsterismLayout.minHitTarget)+                        .padding(.horizontal, 12)+                        // An actionable-attention row (Decision 1), so it takes+                        // the amber border the unparsed rows wear.+                        .constellationCard(borderColor: AsterismColors.amber.opacity(0.3))                     }                     .buttonStyle(.plain)+                    .constellationListRow()                     .accessibilityIdentifier("duplicate-elsewhere-row")                     .accessibilityLabel(item.text)                 }             } header: {-                Text("Elsewhere")-                    .font(AsterismTypography.sectionHeader)-                    .textCase(.uppercase)+                ConstellationSectionHeader("Elsewhere", accent: .violet)                     .accessibilityIdentifier("duplicate-elsewhere-header")             }         }@@ -368,9 +441,8 @@ struct RecentView: View {     }      private var diagnosisBannerText: String {-        presentation.diagnosisCount == 1-            ? "1 record could not be resolved"-            : "\(presentation.diagnosisCount) records could not be resolved"+        Pluralisation.count(presentation.diagnosisCount, "record", "records")+            + " could not be resolved"     }      /// Req 4.3. `refreshAll` swallows its errors; the diagnosis count must not@@ -380,16 +452,21 @@ struct RecentView: View {         HStack(spacing: 6) {             Image(systemName: "arrow.trianglehead.2.clockwise.rotate.90")                 .font(.caption)-                .foregroundStyle(.secondary)+                .foregroundStyle(AsterismColors.secondaryText)                 .accessibilityHidden(true)             Text("Asterism could not re-check your library. Any count shown may be out of date.")                 .font(.caption)-                .foregroundStyle(.secondary)+                .foregroundStyle(AsterismColors.secondaryText)             Spacer()         }         .padding(.horizontal)         .frame(minHeight: AsterismLayout.minHitTarget)-        .background(Color.secondary.opacity(0.1))+        // Neutral, not amber: requirement 8.6 reserves amber for states the+        // reader can act on, and there is nothing to tap here — the line+        // reports that a count may be stale.+        .constellationCard(cornerRadius: AsterismLayout.bannerRadius)+        .padding(.horizontal, 16)+        .padding(.vertical, 4)         .accessibilityElement(children: .combine)         .accessibilityIdentifier("diagnosis-refresh-failed-banner")     }@@ -549,17 +626,11 @@ struct RecentEntryRow: View {                 Button {                     onResolveDuplicate(resolutionKey)                 } label: {+                    // §7's pill recipe, shared with Teach per Decision 1.                     Text("Resolve")-                        .font(.caption.bold())-                        .foregroundStyle(AsterismColors.amberDark)-                        .padding(.horizontal, 8)-                        .padding(.vertical, 10)-                        .frame(minHeight: AsterismLayout.minHitTarget)-                        .background(AsterismColors.amberDark.opacity(0.15))-                        .clipShape(Capsule())+                        .constellationPill(.attention)                 }                 .buttonStyle(.plain)-                .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("resolve-duplicate-pill")                 .accessibilityLabel(                     row.duplicateRoute?.blockingWorkSet == nil@@ -573,43 +644,40 @@ struct RecentEntryRow: View {                     onTeach(row.id)                 } label: {                     Text(row.actionType == .teach ? "Teach" : "Re-teach")-                        .font(.caption.bold())-                        .foregroundStyle(AsterismColors.amberDark)-                        .padding(.horizontal, 8)-                        .padding(.vertical, 10)-                        .frame(minHeight: AsterismLayout.minHitTarget)-                        .background(AsterismColors.amberDark.opacity(0.15))-                        .clipShape(Capsule())+                        .constellationPill(.attention)                 }                 .buttonStyle(.plain)-                .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("teach-pill")                 .accessibilityLabel(row.actionType == .teach ? "Teach title pattern" : "Re-teach title pattern")             }         }-        .padding(.vertical, 4)+        .padding(.vertical, 10)+        .padding(.horizontal, 12)         .frame(minHeight: AsterismLayout.minHitTarget)-        .overlay {-            // Q38: driven by `attention`, not `isActionable`. An attention row is-            // deliberately *not* actionable — its action was withdrawn because it-            // could not succeed — so keying the edge to `isActionable` would leave-            // exactly the rows that need marking unmarked.-            if row.isActionable || row.attention != nil || row.duplicateRoute != nil {-                RoundedRectangle(cornerRadius: 6)-                    .stroke(AsterismColors.amberDark.opacity(0.3), lineWidth: 1)-                    .allowsHitTesting(false)-            }-        }+        // §7's unparsed row: the ordinary card, with the amber border.+        //+        // Q38: driven by `attention`, not `isActionable`. An attention row is+        // deliberately *not* actionable — its action was withdrawn because it+        // could not succeed — so keying the edge to `isActionable` would leave+        // exactly the rows that need marking unmarked.+        .constellationCard(borderColor: needsAttention ? AsterismColors.attentionBorder : nil)+    }++    private var needsAttention: Bool {+        row.isActionable || row.attention != nil || row.duplicateRoute != nil     }      private var entryContent: some View {         VStack(alignment: .leading, spacing: 4) {             HStack {                 // Show Work display title if available, else capture title+                // Req 11.3: one line, ellipsis, never wrapped.                 Text(row.workDisplayTitle ?? row.captureTitle)-                    .font(AsterismTypography.serifTitle(15))+                    .font(AsterismTypography.serifRowTitle)                     .lineLimit(1)-                    .foregroundStyle(row.isActionable ? AsterismColors.amberDark : .primary)+                    .truncationMode(.tail)+                    .foregroundStyle(+                        row.isActionable ? AsterismColors.amberText : AsterismColors.primaryText)                     .accessibilityIdentifier("entry-title")                  Spacer()@@ -619,7 +687,7 @@ struct RecentEntryRow: View {             if let chapterTitle = row.chapterTitle {                 Text(chapterTitle)                     .font(.caption)-                    .foregroundStyle(AsterismColors.cyanDark)+                    .foregroundStyle(AsterismColors.cyan)                     .lineLimit(1)                     .accessibilityIdentifier("entry-chapter")             }@@ -631,11 +699,11 @@ struct RecentEntryRow: View {                 HStack(spacing: 4) {                     Image(systemName: "exclamationmark.triangle")                         .font(.caption2)-                        .foregroundStyle(AsterismColors.amberDark)+                        .foregroundStyle(AsterismColors.amberText)                         .accessibilityHidden(true)                     Text(Self.attentionLabel(attention))                         .font(.caption)-                        .foregroundStyle(AsterismColors.amberDark)+                        .foregroundStyle(AsterismColors.amberText)                         .lineLimit(2)                 }                 .accessibilityIdentifier("entry-attention")@@ -646,41 +714,47 @@ struct RecentEntryRow: View {                 HStack(spacing: 4) {                     Image(systemName: "exclamationmark.triangle")                         .font(.caption2)-                        .foregroundStyle(AsterismColors.amberDark)+                        .foregroundStyle(AsterismColors.amberText)                         .accessibilityHidden(true)                     Text(candidate)                         .font(.caption)-                        .foregroundStyle(AsterismColors.amberDark)+                        .foregroundStyle(AsterismColors.amberText)                         .lineLimit(1)                 }                 .accessibilityIdentifier("entry-unresolved-candidate")             }              HStack(spacing: 6) {-                Text(row.hostname)-                    .font(.caption)-                    .foregroundStyle(.secondary)-                    .accessibilityIdentifier("entry-hostname")+                // Req 9.2: a row that showed the hostname as plain text shows+                // the glyph instead. The hostname is still spoken — the row+                // button's accessibility label names it.+                SiteGlyph(+                    hostname: row.hostname,+                    kind: row.workDisplayTitle == nil ? .unknown : .site,+                    size: 18+                )+                .accessibilityIdentifier("entry-hostname")                  Spacer() +                // §5: rating glyphs in rows never glow — plain accent text.                 if let rating = row.rating {                     Text(rating == .up ? "▲" : "▼")                         .font(.caption)-                        .foregroundStyle(rating == .up ? AsterismColors.cyanDark : AsterismColors.violetDark)+                        .foregroundStyle(rating == .up ? AsterismColors.cyan : AsterismColors.violet)                         .accessibilityIdentifier("entry-rating")                 }                  Text(row.lastSharedAt, style: .time)                     .font(.caption2)-                    .foregroundStyle(.secondary)+                    .foregroundStyle(AsterismColors.secondaryText)                     .accessibilityIdentifier("entry-time")             }              if !row.note.isEmpty {                 Text(row.note)                     .font(.caption)-                    .foregroundStyle(.tertiary)+                    .foregroundStyle(AsterismColors.noteText)                     .lineLimit(2)                     .accessibilityIdentifier("entry-note-preview")             }

diff --git a/Asterism/Asterism/Views/ReparseView.swift b/Asterism/Asterism/Views/ReparseView.swiftindex b37bc70..4265f6b 100644--- a/Asterism/Asterism/Views/ReparseView.swift+++ b/Asterism/Asterism/Views/ReparseView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// Re-parse sheet: shows before→after chapter, Work outcome,@@ -50,7 +51,7 @@ struct ReparseView: View {         Form {             // Before/After chapter             if let projection = model.projection, let before = model.entryBefore {-                Section("Chapter") {+                Section(header: ConstellationSectionHeader("Chapter", accent: .cyan)) {                     LabeledContent("Before") {                         Text(before.chapterTitle ?? "—")                             .font(.caption)@@ -65,7 +66,7 @@ struct ReparseView: View {                 }                  // Work outcome-                Section("Work Assignment") {+                Section(header: ConstellationSectionHeader("Work Assignment", accent: .violet)) {                     if let workTitle = projection.projectedWorkTitle {                         LabeledContent("Projected Work") {                             Text(workTitle)@@ -93,7 +94,7 @@ struct ReparseView: View {                  // Protections                 if projection.chapterProtected || projection.assignmentProtected {-                    Section("Protections") {+                    Section(header: ConstellationSectionHeader("Protections", accent: .violet)) {                         if projection.chapterProtected {                             Label("Chapter: manual protection (preserved)", systemImage: "lock.fill")                                 .font(.caption)@@ -108,7 +109,7 @@ struct ReparseView: View {                 }                  // Provenance-                Section("Projected Provenance") {+                Section(header: ConstellationSectionHeader("Projected Provenance", accent: .violet)) {                     LabeledContent("Chapter Provenance") {                         Text(provenanceLabel(projection.chapterProvenance))                             .font(.caption)@@ -124,27 +125,27 @@ struct ReparseView: View {                  // Parse errors                 if let parseFailure = projection.parseFailure {-                    Section("Parse Error") {+                    Section(header: ConstellationSectionHeader("Parse Error", accent: .violet)) {                         Text(String(describing: parseFailure))                             .font(.caption)-                            .foregroundStyle(.red)+                            .foregroundStyle(AsterismColors.amberText)                             .accessibilityIdentifier("reparse-parse-error")                     }                 }                  // Ambiguous candidates                 if model.hasAmbiguity {-                    Section("Ambiguous Work Candidates") {+                    Section(header: ConstellationSectionHeader("Ambiguous Work Candidates", accent: .violet)) {                         Text("Multiple Works match the parsed title. Assignment will remain unresolved.")                             .font(.caption)-                            .foregroundStyle(.orange)+                            .foregroundStyle(AsterismColors.amberText)                             .accessibilityIdentifier("reparse-ambiguity-warning")                     }                 }                  // Works to create                 if !model.worksToCreate.isEmpty {-                    Section("Works to Create") {+                    Section(header: ConstellationSectionHeader("Works to Create", accent: .violet)) {                         ForEach(model.worksToCreate, id: \.self) { title in                             Text(title)                                 .font(.caption)@@ -155,23 +156,30 @@ struct ReparseView: View {             }              // Confirm / Reconfirm+            //+            // Req 9.1: whichever of the two is on screen is this sheet's one+            // gradient control — they are exclusive branches, never both.             Section {                 if model.requiresReconfirmation {                     Button("Reconfirm") {                         Task { await model.reconfirm() }                     }-                    .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+                    .buttonStyle(.constellationPrimary)                     .accessibilityIdentifier("reparse-reconfirm-button")+                    .constellationListRow(+                        insets: EdgeInsets(top: 8, leading: 16, bottom: 8, trailing: 16))                      Text("The projection was refreshed. Please review and reconfirm.")                         .font(.caption)-                        .foregroundStyle(.orange)+                        .foregroundStyle(AsterismColors.amberText)                 } else {                     Button("Confirm") {                         Task { await model.confirm() }                     }-                    .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+                    .buttonStyle(.constellationPrimary)                     .accessibilityIdentifier("reparse-confirm-button")+                    .constellationListRow(+                        insets: EdgeInsets(top: 8, leading: 16, bottom: 8, trailing: 16))                 }             }         }@@ -182,7 +190,7 @@ struct ReparseView: View {         VStack(spacing: 16) {             Image(systemName: "checkmark.circle.fill")                 .font(.largeTitle)-                .foregroundStyle(.green)+                .foregroundStyle(AsterismColors.cyan)             Text("Re-parse committed successfully.")             Button("Done") { dismiss() }                 .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)@@ -196,7 +204,7 @@ struct ReparseView: View {         VStack(spacing: 16) {             Image(systemName: "exclamationmark.triangle.fill")                 .font(.largeTitle)-                .foregroundStyle(.orange)+                .foregroundStyle(AsterismColors.amberText)             Text("Re-parse invalidated")                 .font(.headline)             Text(reason)@@ -216,7 +224,7 @@ struct ReparseView: View {         VStack(spacing: 16) {             Image(systemName: "xmark.circle.fill")                 .font(.largeTitle)-                .foregroundStyle(.red)+                .foregroundStyle(AsterismColors.amberText)             Text("Error")                 .font(.headline)             Text(message)

diff --git a/Asterism/Asterism/Views/SettingsBackupImportView.swift b/Asterism/Asterism/Views/SettingsBackupImportView.swiftindex 92aa3cf..1192527 100644--- a/Asterism/Asterism/Views/SettingsBackupImportView.swift+++ b/Asterism/Asterism/Views/SettingsBackupImportView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI import UniformTypeIdentifiers @@ -93,7 +94,7 @@ struct SettingsBackupImportView: View {                 Button("Import") {                     Task { await model.confirmImport() }                 }-                .buttonStyle(.borderedProminent)+                .buttonStyle(.constellationPrimary)                 .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("settings-confirm-import-button") @@ -122,7 +123,7 @@ struct SettingsBackupImportView: View {         VStack(spacing: 12) {             HStack {                 Image(systemName: "checkmark.circle.fill")-                    .foregroundStyle(.green)+                    .foregroundStyle(AsterismColors.cyan)                 Text("Import complete")             }             Text("Your library now holds \(counts.entries) entries and \(counts.works) works.")@@ -142,7 +143,7 @@ struct SettingsBackupImportView: View {         VStack(spacing: 12) {             HStack {                 Image(systemName: "exclamationmark.triangle.fill")-                    .foregroundStyle(.red)+                    .foregroundStyle(AsterismColors.amberText)                 Text("Import Failed")             }             Text(message)

diff --git a/Asterism/Asterism/Views/SettingsView.swift b/Asterism/Asterism/Views/SettingsView.swiftindex 7a0d0f2..bc2e923 100644--- a/Asterism/Asterism/Views/SettingsView.swift+++ b/Asterism/Asterism/Views/SettingsView.swift@@ -1,3 +1,5 @@+import AsterismCore+import ConstellationKit import SwiftUI  /// Settings surface presenting backup export and import actions.@@ -26,19 +28,30 @@ struct SettingsView: View {     /// and the one action it names — import the backup again — is the section     /// it sits beside.     private let interruptedImportNotice: String?+    /// Req 6.1's list. A plain `let` like `diagnosticsModel`: the screen it+    /// pushes owns the loaded state, so nothing here needs to survive a+    /// re-render.+    private let sitesModel: SitesListModel?+    /// Built by the host, because the site screen's re-teach route has to close+    /// Settings before the teaching sheet can present.+    private let siteDetailModel: (@MainActor (SiteSnapshot) -> SiteDetailModel?)?      init(         model: SettingsBackupModel,         importModel: SettingsBackupImportModel? = nil,         diagnosticsModel: LibraryDiagnosticsModel? = nil,         syncModel: SettingsSyncModel? = nil,-        interruptedImportNotice: String? = nil+        interruptedImportNotice: String? = nil,+        sitesModel: SitesListModel? = nil,+        siteDetailModel: (@MainActor (SiteSnapshot) -> SiteDetailModel?)? = nil     ) {         _model = State(initialValue: model)         _importModel = State(initialValue: importModel)         _syncModel = State(initialValue: syncModel)         self.diagnosticsModel = diagnosticsModel         self.interruptedImportNotice = interruptedImportNotice+        self.sitesModel = sitesModel+        self.siteDetailModel = siteDetailModel     }      var body: some View {@@ -53,14 +66,16 @@ struct SettingsView: View {                 backupRow                 diagnosticsRow             } header: {-                Text("Data")+                ConstellationSectionHeader("Data", accent: .violet)             } +            sitesSection+             if let importModel {                 Section {                     SettingsBackupImportView(model: importModel)                 } header: {-                    Text("Import")+                    ConstellationSectionHeader("Import", accent: .violet)                 }             }         }@@ -134,7 +149,7 @@ struct SettingsView: View {                         .accessibilityIdentifier("settings-sync-counts-line")                 }             } header: {-                Text("iCloud")+                ConstellationSectionHeader("iCloud")             }         }     }@@ -145,7 +160,7 @@ struct SettingsView: View {                 Image(systemName: failure.isBannerWorthy                     ? "exclamationmark.triangle.fill" : "exclamationmark.circle")                     .font(.caption)-                    .foregroundStyle(failure.isBannerWorthy ? AsterismColors.amberDark : .secondary)+                    .foregroundStyle(failure.isBannerWorthy ? AsterismColors.amberText : .secondary)                     .accessibilityHidden(true)                 Text(failure.condition)                     .font(.callout)@@ -174,7 +189,7 @@ struct SettingsView: View {             HStack(alignment: .firstTextBaseline, spacing: 6) {                 Image(systemName: "exclamationmark.circle")                     .font(.caption)-                    .foregroundStyle(AsterismColors.amberDark)+                    .foregroundStyle(AsterismColors.amberText)                     .accessibilityHidden(true)                 Text(interruptedImportNotice)                     .font(.callout)@@ -184,6 +199,26 @@ struct SettingsView: View {         }     } +    // MARK: - Sites (Req 6.1)++    /// After Data: sync and the backup actions are what a reader opens Settings+    /// for; the site list is where they go when a *particular* site is wrong.+    @ViewBuilder+    private var sitesSection: some View {+        if let sitesModel, let siteDetailModel {+            Section {+                NavigationLink {+                    SitesListView(model: sitesModel, detailModel: siteDetailModel)+                } label: {+                    Label("Sites", systemImage: "globe")+                }+                .accessibilityIdentifier("settings-sites-button")+            } header: {+                ConstellationSectionHeader("Sites", accent: .violet)+            }+        }+    }+     // MARK: - Library Check Row (Req 4.2)      /// Reachable whether or not anything is diagnosed: the reader should be able@@ -226,7 +261,7 @@ struct SettingsView: View {         case .sharing:             HStack {                 Image(systemName: "checkmark.circle.fill")-                    .foregroundStyle(AsterismColors.cyanDark)+                    .foregroundStyle(AsterismColors.cyan)                 Text("Backup ready")                     .foregroundStyle(.secondary)             }@@ -236,7 +271,7 @@ struct SettingsView: View {             VStack(alignment: .leading, spacing: 8) {                 HStack {                     Image(systemName: "exclamationmark.triangle.fill")-                        .foregroundStyle(.red)+                        .foregroundStyle(AsterismColors.amberText)                     Text("Backup Failed")                 }                 .accessibilityIdentifier("settings-backup-failed")@@ -291,20 +326,3 @@ struct SettingsView: View {         }     } }--// MARK: - System Share Sheet (UIKit bridge)--/// Wraps UIActivityViewController for presenting the backup file through the system share interface.-private struct ShareSheet: UIViewControllerRepresentable {-    let fileURL: URL--    func makeUIViewController(context: Context) -> UIActivityViewController {-        let controller = UIActivityViewController(-            activityItems: [fileURL],-            applicationActivities: nil-        )-        return controller-    }--    func updateUIViewController(_ uiViewController: UIActivityViewController, context: Context) {}-}

diff --git a/Asterism/Asterism/Views/ShareSheet.swift b/Asterism/Asterism/Views/ShareSheet.swiftnew file mode 100644index 0000000..90f2bb6--- /dev/null+++ b/Asterism/Asterism/Views/ShareSheet.swift@@ -0,0 +1,54 @@+import SwiftUI++/// Wraps `UIActivityViewController` for handing a staged file to the system+/// share interface.+///+/// Lifted out of `SettingsView`, where it was `private`, when markdown export+/// gained its own share flows (Reqs 1.5, 2.4): Settings, Work detail, and Entry+/// detail all present a staged file, and one wrapper is what keeps the three+/// presentations identical.+struct ShareSheet: UIViewControllerRepresentable {+    let fileURL: URL++    func makeUIViewController(context: Context) -> UIActivityViewController {+        UIActivityViewController(activityItems: [fileURL], applicationActivities: nil)+    }++    func updateUIViewController(_ uiViewController: UIActivityViewController, context: Context) {}+}++/// Presents a staged markdown export in the system share sheet, driven by the+/// export model's own state (Reqs 1.5, 2.4).+///+/// One modifier rather than a `@State` mirror per detail screen. What decides+/// whether the sheet is up is `model.state == .sharing`; a second copy of that+/// kept in step by `onChange` is a copy that can disagree with it. The derived+/// binding is the presented-value shape both screens already use for their+/// deletion dialogs, and its `set` is the dismissal — which covers send and+/// cancel alike, because the system share sheet reports neither.+private struct MarkdownExportShare: ViewModifier {+    let model: MarkdownExportModel?+    let sheetIdentifier: String++    func body(content: Content) -> some View {+        content.sheet(+            isPresented: Binding(+                get: { model?.state == .sharing },+                set: { if !$0 { model?.handleShareCompletion() } })+        ) {+            if let url = model?.exportedFileURL {+                ShareSheet(fileURL: url)+                    .accessibilityIdentifier(sheetIdentifier)+            }+        }+    }+}++extension View {+    /// Hands `model`'s staged file to the share sheet while it is sharing.+    func markdownExportShare(+        model: MarkdownExportModel?, sheetIdentifier: String+    ) -> some View {+        modifier(MarkdownExportShare(model: model, sheetIdentifier: sheetIdentifier))+    }+}

diff --git a/Asterism/Asterism/Views/SitesView.swift b/Asterism/Asterism/Views/SitesView.swiftnew file mode 100644index 0000000..2575213--- /dev/null+++ b/Asterism/Asterism/Views/SitesView.swift@@ -0,0 +1,185 @@+import AsterismCore+import ConstellationKit+import SwiftUI++/// The Sites list (Req 6.1): every site the library knows, taught or not.+///+/// Pushed from Settings, like Check Library — Settings sub-screens are pushes.+struct SitesListView: View {+    @State private var model: SitesListModel+    /// Built by the host, because the detail screen's re-teach route has to+    /// close Settings before a sheet can present.+    let detailModel: @MainActor (SiteSnapshot) -> SiteDetailModel?++    init(+        model: SitesListModel,+        detailModel: @escaping @MainActor (SiteSnapshot) -> SiteDetailModel?+    ) {+        _model = State(initialValue: model)+        self.detailModel = detailModel+    }++    var body: some View {+        List {+            switch model.state {+            case .loading:+                ProgressView("Loading…")+                    .accessibilityIdentifier("settings-sites-loading")+            case .error(let message):+                Text(message)+                    .font(.callout)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("settings-sites-error")+            case .ready:+                if model.rows.isEmpty {+                    Text(model.emptyMessage)+                        .font(.callout)+                        .foregroundStyle(.secondary)+                        .accessibilityIdentifier("settings-sites-empty")+                } else {+                    ForEach(model.rows) { row in+                        siteRow(row)+                    }+                }+            }+        }+        .navigationTitle("Sites")+        .accessibilityIdentifier("settings-sites-list")+        .task { await model.load() }+    }++    private func siteRow(_ row: SitesListModel.Row) -> some View {+        NavigationLink {+            if let detail = detailModel(row.site) {+                SiteDetailView(model: detail)+            }+        } label: {+            HStack(spacing: 10) {+                SiteGlyph(hostname: row.hostname, kind: glyphKind(row.site.mode))+                    .accessibilityHidden(true)+                VStack(alignment: .leading, spacing: 2) {+                    Text(row.displayName)+                        .font(AsterismTypography.serifRowTitle)+                        .lineLimit(1)+                        .truncationMode(.tail)+                    if row.showsHostnameSeparately {+                        Text(row.hostname)+                            .font(.caption)+                            .foregroundStyle(.secondary)+                            .lineLimit(1)+                    }+                }+                Spacer()+                Text(row.modeLabel)+                    .font(.caption2)+                    .foregroundStyle(.secondary)+            }+            .frame(minHeight: AsterismLayout.minHitTarget)+        }+        .accessibilityIdentifier("site-row-\(row.hostname)")+        .accessibilityLabel("\(row.displayName), \(row.modeLabel)")+    }++    /// An untaught site has nothing behind it yet and an articles site is+    /// deliberately not a work — both read as the flat, dim glyphs (9.2).+    private func glyphKind(_ mode: SiteMode) -> SiteGlyphKind {+        switch mode {+        case .untaught: .unknown+        case .articles: .articles+        case .taught: .site+        }+    }+}++/// One site's screen (Reqs 6.2–6.4): what mode it is in, the re-teach route,+/// and the one-way switch to articles.+struct SiteDetailView: View {+    @State private var model: SiteDetailModel+    @Environment(\.dismiss) private var dismiss++    init(model: SiteDetailModel) {+        _model = State(initialValue: model)+    }++    var body: some View {+        List {+            Section {+                LabeledContent("Mode") { Text(model.modeLabel) }+                    .accessibilityIdentifier("site-detail-mode")+                Text(model.modeExplanation)+                    .font(.caption)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("site-detail-mode-explanation")+            } header: {+                ConstellationSectionHeader(model.site.hostname)+            }++            Section {+                // Req 9.1: this screen's one gradient control. The articles+                // switch below it is deliberately not — it is a one-way change+                // the reader should have to mean.+                Button(model.reteachLabel) { model.reteach() }+                    .buttonStyle(.constellationPrimary)+                    .disabled(!model.canReteach)+                    .accessibilityIdentifier("site-detail-reteach-button")++                // Never left to a greyed-out button on its own: a control that+                // does nothing and says nothing is the dead end this milestone+                // removes everywhere else.+                if let message = model.reteachUnavailableMessage {+                    Text(message)+                        .font(.caption)+                        .foregroundStyle(.secondary)+                        .accessibilityIdentifier("site-detail-reteach-unavailable")+                }++                if model.canSwitchToArticles {+                    Button("Treat every page as an article") {+                        Task { await model.requestArticlesSwitch() }+                    }+                    .buttonStyle(.constellationSecondary)+                    .disabled(model.isSubmitting)+                    .accessibilityIdentifier("site-detail-articles-button")+                }+            }++            if let message = model.errorMessage {+                Section {+                    Text(message)+                        .font(.callout)+                        .foregroundStyle(AsterismColors.amberText)+                        .accessibilityIdentifier("site-detail-error")+                }+            }+        }+        .navigationTitle(model.site.displayName)+        .navigationBarTitleDisplayMode(.inline)+        .accessibilityIdentifier("site-detail-view")+        // The consequences, then the choice — the same shape teach mode's own+        // articles confirmation has, and the same contracts underneath (6.4).+        .confirmationDialog(+            "Treat every page as an article?",+            isPresented: Binding(+                get: { model.articlesPrompt != nil },+                set: { if !$0 { model.cancelArticlesSwitch() } }),+            presenting: model.articlesPrompt+        ) { prompt in+            // The prompt is taken as a parameter, not re-read from the model:+            // SwiftUI runs the dismissal below before this action (see+            // `SiteDetailModel.ArticlesPrompt`).+            Button("Turn on Articles mode", role: .destructive) {+                Task { await model.confirmArticlesSwitch(prompt) }+            }+            .accessibilityIdentifier("site-detail-articles-confirm")+            Button("Cancel", role: .cancel) { model.cancelArticlesSwitch() }+                .accessibilityIdentifier("site-detail-articles-cancel")+        } message: { prompt in+            Text(prompt.message)+        }+        // The screen holds an immutable snapshot, so once the mode has changed+        // everything on it describes the site as it was. Back to the list.+        .onChange(of: model.didSwitchToArticles) { _, switched in+            if switched { dismiss() }+        }+    }+}

diff --git a/Asterism/Asterism/Views/TeachingComponents.swift b/Asterism/Asterism/Views/TeachingComponents.swiftindex 484408e..e55cfa4 100644--- a/Asterism/Asterism/Views/TeachingComponents.swift+++ b/Asterism/Asterism/Views/TeachingComponents.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// One chip of the composed surface's two-granularity title selector (Req 8.3,@@ -20,13 +21,12 @@ struct TitleChipView: View {                 HStack(spacing: 4) {                     Text(roleSymbol)                         .font(.caption.monospaced().bold())-                        .foregroundStyle(roleColor)                     Text(text)                         .font(.subheadline)                         .lineLimit(1)+                        // §7: an ignored chip is dim, half-opacity, struck out.+                        .strikethrough(role == .ignore)                 }-                .padding(.horizontal, 12)-                .padding(.vertical, 8)                 .frame(minHeight: AsterismLayout.minHitTarget)             }             .buttonStyle(.plain)@@ -44,7 +44,7 @@ struct TitleChipView: View {                 Button(action: onSubdivide) {                     Image(systemName: "scissors")                         .font(.caption)-                        .padding(.horizontal, 10)+                        .padding(.leading, 10)                         .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)                 }                 .buttonStyle(.plain)@@ -53,9 +53,19 @@ struct TitleChipView: View {             }         }         .fixedSize(horizontal: true, vertical: false)-        .background(roleColor.opacity(0.12))-        .clipShape(Capsule())-        .overlay(Capsule().stroke(roleColor.opacity(0.4), lineWidth: 1))+        // §7's teach chip. A selected chip is the only one that glows (§5).+        .constellationChip(role: chipRole, isSelected: role != .ignore)+    }++    /// Q36: the style guide's §7 mapping — chapter chips are amber, work chips+    /// cyan. The shipped code had these inverted; the flip lands here, with the+    /// chip recipe.+    private var chipRole: ConstellationChipRole {+        switch role {+        case .chapter: .chapter+        case .work: .work+        case .ignore: .ignored+        }     }      private var roleSymbol: String {@@ -74,11 +84,13 @@ struct TitleChipView: View {         }     } +    /// The divider between the chip and its split control. Matches the chip's+    /// own accent — amber text on dark, darkened on light (requirement 11.4).     private var roleColor: Color {         switch role {-        case .chapter: AsterismColors.cyanDark-        case .work: AsterismColors.amberDark-        case .ignore: .secondary+        case .chapter: AsterismColors.amberText+        case .work: AsterismColors.cyan+        case .ignore: AsterismColors.secondaryText         }     } }

diff --git a/Asterism/Asterism/Views/WorkDetailView.swift b/Asterism/Asterism/Views/WorkDetailView.swiftindex 9f03b97..8a44e99 100644--- a/Asterism/Asterism/Views/WorkDetailView.swift+++ b/Asterism/Asterism/Views/WorkDetailView.swift@@ -1,20 +1,46 @@ import AsterismCore+import ConstellationKit import SwiftUI -/// Work detail: shows metadata, assigned entries, and editing controls.+/// Work detail in the §6 shape (Req 5.1): header, rating pulse, "Open last+/// noted chapter", generic notes, then the chapter-notes list.+///+/// The screen is presentation-first. What §6 places on it — the title, the type+/// and genre tags, the generic notes — stays editable in place (Q20, Req 5.6);+/// the Work URL and URL-identity machinery, which §6's layout has no home for,+/// moves behind **Edit details**. Save is a toolbar confirmation that appears+/// only while a draft differs, and every other action lives in the one toolbar+/// menu (Req 5.5) — which is also the only route to Merge. struct WorkDetailView: View {     @State private var model: WorkDetailModel     @Environment(\.dismiss) private var dismiss+    @Environment(\.openURL) private var openURL     @State private var activeMergeModel: WorkMergeModel?+    @State private var showingEditDetails = false     @State private var showingURLIdentityReview = false     @State private var showingURLReteach = false+    /// Req 2.4's staging model, `@State`-owned so the staged file survives a+    /// re-render (the `SettingsView` precedent).+    @State private var exportModel: MarkdownExportModel?     /// Req 9.2's route out of a torn Work, or nil where the caller has no sheet     /// to open. Entry detail's shape, for the same reason it has one.     let onResolveDuplicate: (() -> Void)?+    /// Requirement 8.1 puts the sky behind tab-stack content only. This screen+    /// is pushed on the Works stack *and* presented as a sheet by the Merge+    /// route, and a sheet is its own glass layer (§4) — so the host says which+    /// it is rather than the screen assuming.+    let showsSky: Bool -    init(model: WorkDetailModel, onResolveDuplicate: (() -> Void)? = nil) {+    init(+        model: WorkDetailModel,+        onResolveDuplicate: (() -> Void)? = nil,+        exportModel: MarkdownExportModel? = nil,+        showsSky: Bool = true+    ) {         _model = State(initialValue: model)+        _exportModel = State(initialValue: exportModel)         self.onResolveDuplicate = onResolveDuplicate+        self.showsSky = showsSky     }      var body: some View {@@ -32,50 +58,465 @@ struct WorkDetailView: View {             }         }         .navigationTitle("Work")+        .background { if showsSky { ConstellationBackground() } }         .task { await model.load() }+        // A committed deletion takes the screen with it — there is nothing left+        // to show and nothing to go back to.+        .onChange(of: model.isDeleted) { _, deleted in+            if deleted { dismiss() }+        }     } +    // MARK: - The §6 layout+     @ViewBuilder     private func workContent(_ work: WorkSnapshot) -> some View {-        Form {+        List {             if model.isReadOnly { duplicateReviewSection } -            Section("Metadata") {-                TextField("Title", text: $model.draftTitle)-                    .font(AsterismTypography.serifTitle(17))-                    .disabled(model.isReadOnly)-                    .accessibilityIdentifier("work-detail-title-field")+            headerSection(work)+            pulseSection+            openLastNotedSection+            notesSection+            chapterSection -                LabeledContent("Site") {-                    Text(work.siteHostname)+            if let errorMessage = model.errorMessage {+                Section {+                    // Q37: a save failure is amber, not system red — the+                    // palette has no error colour and §11 forbids a fourth hue.+                    Text(errorMessage)+                        .foregroundStyle(AsterismColors.amberText)+                        .frame(maxWidth: .infinity, alignment: .leading)+                        .padding(12)+                        .constellationCard(borderColor: AsterismColors.attentionBorder)+                        .constellationListRow()+                        .accessibilityIdentifier("work-detail-error")+                }+            }+        }+        // Req 8.1: the Works tab's sky shows through the pushed screen too.+        .scrollContentBackground(.hidden)+        .toolbar {+            // Req 5.5: exactly four items, and the only way to Merge.+            ToolbarItem(placement: .topBarTrailing) { actionsMenu }+            // Only while there is something to save (Req 5.6's in-place edits).+            if model.hasUnsavedChanges {+                ToolbarItem(placement: .confirmationAction) {+                    Button("Save") { Task { await model.save() } }+                        .disabled(model.state == .submitting || model.isReadOnly)+                        .frame(minHeight: AsterismLayout.minHitTarget)+                        .accessibilityIdentifier("work-detail-save-button")                 }-                .accessibilityIdentifier("work-detail-hostname")+            }+        }+        .sheet(+            isPresented: Binding(+                get: { activeMergeModel != nil },+                set: { if !$0 { handleMergeDismissed() } }+            )+        ) {+            if let mergeModel = activeMergeModel {+                WorkMergeView(model: mergeModel)+            }+        }+        .sheet(isPresented: $showingEditDetails) {+            NavigationStack {+                WorkEditDetailsView(+                    model: model,+                    onReviewURLIdentity: {+                        showingEditDetails = false+                        showingURLIdentityReview = true+                    },+                    onReteachURLRule: {+                        showingEditDetails = false+                        showingURLReteach = true+                    },+                    onDone: { showingEditDetails = false })+            }+        }+        .sheet(isPresented: $showingURLIdentityReview) {+            if let reviewModel = model.reviewModel() {+                URLIdentityReviewView(model: reviewModel)+            }+        }+        .sheet(isPresented: $showingURLReteach) {+            if let reteachModel = model.composedURLReteachModel() {+                ComposedTeachingContainerView(model: reteachModel)+            }+        }+        .markdownExportShare(+            model: exportModel, sheetIdentifier: "work-detail-export-share-sheet")+        // Req 7.1's two dispositions plus cancel. `presenting:` hands the+        // buttons the projection the dialog was built from, so the count in the+        // message and the contract the commit takes are one value — and the+        // buttons take it as a parameter, because SwiftUI runs the dismissal+        // below (which clears the model) before it runs the tapped action.+        .confirmationDialog(+            "Delete this work?",+            isPresented: Binding(+                get: { model.deletionPrompt != nil },+                set: { if !$0 { model.cancelDelete() } }),+            presenting: model.deletionPrompt+        ) { prompt in+            Button("Delete its notes too", role: .destructive) {+                Task { await model.chooseDeletion(prompt, disposition: .deleteEntries) }+            }+            .accessibilityIdentifier("work-detail-delete-entries")+            Button("Delete work, keep its notes") {+                Task { await model.chooseDeletion(prompt, disposition: .detachEntries) }+            }+            .accessibilityIdentifier("work-detail-delete-detach")+            Button("Cancel", role: .cancel) { model.cancelDelete() }+                .accessibilityIdentifier("work-detail-delete-cancel")+        } message: { prompt in+            Text(prompt.message)+        }+        // Req 7.2's disclosure, on **both** dispositions: deleting destroys+        // authored copies and detaching authors over them. The confirmed value+        // travels as a parameter — SwiftUI clears the binding before the action+        // runs, so re-reading the model here would disclose nothing.+        .alert(+            "Some of these notes have copies that differ",+            isPresented: Binding(+                get: { model.deleteDisclosure != nil },+                set: { if !$0 { model.cancelDeletionDisclosure() } }),+            presenting: model.deleteDisclosure+        ) { disclosure in+            Button("Continue", role: .destructive) {+                Task { await model.confirmDeletion(disclosure) }+            }+            .accessibilityIdentifier("work-detail-delete-disclosure-confirm")+            Button("Cancel", role: .cancel) { model.cancelDeletionDisclosure() }+                .accessibilityIdentifier("work-detail-delete-disclosure-cancel")+        } message: { disclosure in+            Text(disclosureMessage(disclosure))+        }+    }++    /// Header: site glyph, the editable title, the site line with its URL+    /// identity, and the type and genre tags (Req 5.1, 5.6).+    @ViewBuilder+    private func headerSection(_ work: WorkSnapshot) -> some View {+        Section {+            HStack(alignment: .top, spacing: 12) {+                SiteGlyph(hostname: work.siteHostname, size: 44)+                    .accessibilityHidden(true)++                VStack(alignment: .leading, spacing: 6) {+                    TextField("Title", text: $model.draftTitle)+                        .font(AsterismTypography.serifHeading)+                        .foregroundStyle(AsterismColors.primaryText)+                        .disabled(model.isReadOnly)+                        .accessibilityIdentifier("work-detail-title-field") -                Picker("Type", selection: $model.draftType) {-                    ForEach(WorkType.allCases, id: \.self) { type in-                        Text(type.rawValue).tag(type)+                    HStack(spacing: 6) {+                        Text(work.siteHostname)+                            .font(.caption)+                            .foregroundStyle(AsterismColors.secondaryText)+                            .lineLimit(1)+                            .accessibilityIdentifier("work-detail-hostname")+                        // §3: URL chips are monospace and dim.+                        if let identity = work.urlIdentity, !identity.isEmpty {+                            Text(identity)+                                .font(AsterismTypography.mono)+                                .foregroundStyle(AsterismColors.secondaryText)+                                .lineLimit(1)+                                .accessibilityIdentifier("work-detail-url-identity")+                        }                     }                 }+            }+            .padding(12)+            .constellationCard()+            .constellationListRow()++            Picker("Type", selection: $model.draftType) {+                ForEach(WorkType.allCases, id: \.self) { type in+                    Text(type.rawValue).tag(type)+                }+            }+            .disabled(model.isReadOnly)+            .accessibilityIdentifier("work-detail-type-picker")+            .padding(.horizontal, 12)+            .frame(minHeight: AsterismLayout.minHitTarget)+            .constellationCard()+            .constellationListRow()++            TextField(+                "Genre tags (comma-separated)",+                text: Binding(+                    get: { model.draftTags.joined(separator: ", ") },+                    set: {+                        model.draftTags = $0.split(separator: ",")+                            .map { String($0).trimmingCharacters(in: .whitespaces) }+                    }+                )+            )+            .disabled(model.isReadOnly)+            .accessibilityIdentifier("work-detail-tags-field")+            .padding(.horizontal, 12)+            .frame(minHeight: AsterismLayout.minHitTarget)+            .constellationCard()+            .constellationListRow()+        }+    }++    /// Req 5.2: three counts over logical records, no drill-down.+    ///+    /// §7's rating pulse: three equal cards, the ▲ count cyan, the ▼ count+    /// violet, the notes count neutral.+    private var pulseSection: some View {+        Section {+            HStack(spacing: 10) {+                pulseCount(+                    String(model.pulse.notes),+                    tint: AsterismColors.primaryText,+                    label: "notes",+                    identifier: "work-detail-pulse-notes")+                pulseCount(+                    "▲ \(model.pulse.up)",+                    tint: AsterismColors.cyan,+                    label: "rated up",+                    identifier: "work-detail-pulse-up")+                pulseCount(+                    "▼ \(model.pulse.down)",+                    tint: AsterismColors.violet,+                    label: "rated down",+                    identifier: "work-detail-pulse-down")+            }+            // `children: .contain` before the identifier, or the group's+            // identifier propagates down and overwrites each card's own —+            // the same trap `ComposedTeachingView`'s acknowledgment panel+            // records. The three cards have to stay separately addressable.+            .accessibilityElement(children: .contain)+            .accessibilityIdentifier("work-detail-pulse")+            .constellationListRow()+        }+    }++    private func pulseCount(+        _ text: String,+        tint: Color,+        label: String,+        identifier: String+    ) -> some View {+        VStack(spacing: 2) {+            Text(text)+                .font(.headline.weight(.heavy))+                .foregroundStyle(tint)+                .lineLimit(1)+            Text(label)+                .font(.caption2)+                .foregroundStyle(AsterismColors.secondaryText)+                .lineLimit(1)+        }+        .frame(maxWidth: .infinity)+        .padding(.vertical, 12)+        .constellationCard()+        .accessibilityElement(children: .combine)+        .accessibilityIdentifier(identifier)+    }++    /// 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+    private var openLastNotedSection: some View {+        if let last = model.lastNotedURLString, let url = URL(string: last) {+            Section {+                // Req 9.1: this screen's one gradient control. Every other+                // action on it is a toolbar item or a secondary button.+                Button("Open last noted chapter") { openURL(url) }+                    .buttonStyle(.constellationPrimary)+                    .accessibilityIdentifier("work-detail-open-last-noted")+                    .accessibilityLabel("Open the most recently noted chapter")+                    .constellationListRow(+                        insets: EdgeInsets(top: 8, leading: 16, bottom: 8, trailing: 16))+            }+        }+    }++    private var notesSection: some View {+        Section {+            TextField("Notes", text: $model.draftNotes, axis: .vertical)+                .lineLimit(3...6)                 .disabled(model.isReadOnly)-                .accessibilityIdentifier("work-detail-type-picker")+                .accessibilityIdentifier("work-detail-notes-field")+                .padding(12)+                .constellationCard()+                .constellationListRow()+        } header: {+            ConstellationSectionHeader("Notes")+        }+    } -                TextField("Notes", text: $model.draftNotes, axis: .vertical)-                    .lineLimit(3...6)-                    .disabled(model.isReadOnly)-                    .accessibilityIdentifier("work-detail-notes-field")+    /// Req 5.4: the chapter-notes list, from `WorkChapterRow` — display titles+    /// cleaned by the repository, not by this view.+    @ViewBuilder+    private var chapterSection: some View {+        if !model.chapterRows.isEmpty {+            Section {+                ForEach(model.chapterRows) { row in+                    WorkChapterRowView(row: row)+                        .accessibilityIdentifier("work-detail-entry")+                        .accessibilityLabel("Note on \(row.displayTitle)")+                        .constellationListRow()+                }+            } header: {+                ConstellationSectionHeader("Chapter Notes", accent: .violet)             }+        }+    }++    // MARK: - Toolbar menu (Req 5.5)++    private var actionsMenu: some View {+        Menu {+            if exportModel != nil {+                Button("Export") { Task { await exportModel?.startExport() } }+                    .accessibilityIdentifier("work-detail-export-button")+            }+            Button("Merge into…") { activeMergeModel = model.mergeModel() }+                .accessibilityIdentifier("work-detail-merge-button")+            Button("Edit details") { showingEditDetails = true }+                .accessibilityIdentifier("work-detail-edit-details-button")+            Button("Delete work", role: .destructive) {+                Task { await model.requestDelete() }+            }+            .disabled(model.isReadOnly)+            .accessibilityIdentifier("work-detail-delete-button")+        } label: {+            Image(systemName: "ellipsis.circle")+                .frame(+                    minWidth: AsterismLayout.minHitTarget,+                    minHeight: AsterismLayout.minHitTarget)+        }+        .disabled(model.state == .submitting)+        .accessibilityIdentifier("work-detail-menu")+        .accessibilityLabel("Work actions")+    }++    // MARK: - Torn Work notice++    /// Req 2.8 and Req 9.2 on this screen, mirroring Entry detail: say plainly+    /// why the fields are off, and offer the route that turns them back on.+    private var duplicateReviewSection: some View {+        Section {+            VStack(alignment: .leading, spacing: 8) {+                Text("This work arrived \(model.rowCount) times and the copies differ.")+                    .font(.callout)+                    .foregroundStyle(AsterismColors.primaryText)+                Text("Editing is off until you choose which one to keep — nothing has been lost.")+                    .font(.caption)+                    .foregroundStyle(AsterismColors.secondaryText)+                if let onResolveDuplicate {+                    // Secondary, not the gradient: this screen's one primary is+                    // "Open last noted chapter" (9.1).+                    Button("Resolve copies") { onResolveDuplicate() }+                        .buttonStyle(.constellationSecondary)+                        .accessibilityIdentifier("work-detail-resolve-duplicate-button")+                }+            }+            .frame(maxWidth: .infinity, alignment: .leading)+            .padding(12)+            // Decision 1: duplicate review is an actionable-attention surface,+            // so it wears the amber border.+            .constellationCard(borderColor: AsterismColors.attentionBorder)+            .constellationListRow()+            .accessibilityIdentifier("work-detail-duplicate-notice")+        }+    } -            Section("Work URL") {+    // MARK: - Lifecycle helpers++    /// A committed merge deletes this source Work — leave the detail screen.+    /// Otherwise just reload the unchanged Work.+    private func handleMergeDismissed() {+        let committed = activeMergeModel?.state == .committed+        activeMergeModel = nil+        if committed {+            dismiss()+        } else {+            Task { await model.load() }+        }+    }++    private func disclosureMessage(_ disclosure: WorkDetailModel.WorkDeleteDisclosure) -> String {+        let opening = disclosure.disposition == .deleteEntries+            ? "All \(disclosure.variants.count) of these copies go, and they cannot be recovered:"+            : "Detaching writes over all \(disclosure.variants.count) of these copies:"+        return ([opening] + disclosure.lines).joined(separator: "\n\n")+    }+}++/// One row of the chapter-notes list (Req 5.4): rating glyph, chapter title,+/// note preview, date.+///+/// Its own row type rather than `UnattachedEntryRow`: that one renders the raw+/// capture title, which is exactly what 5.4 says this list must not do.+struct WorkChapterRowView: View {+    let row: WorkChapterRow++    var body: some View {+        VStack(alignment: .leading, spacing: 4) {+            HStack(spacing: 6) {+                if let rating = row.rating {+                    Text(rating == .up ? "▲" : "▼")+                        .font(.caption)+                        .foregroundStyle(+                            rating == .up ? AsterismColors.cyan : AsterismColors.violet)+                        .accessibilityIdentifier("work-detail-entry-rating")+                }+                Text(row.displayTitle)+                    .font(AsterismTypography.serifRowTitle)+                    .lineLimit(1)+                    .truncationMode(.tail)+                    .foregroundStyle(AsterismColors.primaryText)+                    .accessibilityIdentifier("work-detail-entry-title")+                Spacer()+                Text(row.lastSharedAt, style: .date)+                    .font(.caption2)+                    .foregroundStyle(AsterismColors.secondaryText)+            }++            if !row.note.isEmpty {+                Text(row.note)+                    .font(.caption)+                    .foregroundStyle(AsterismColors.noteText)+                    .lineLimit(2)+                    .accessibilityIdentifier("work-detail-entry-note")+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(.vertical, 10)+        .padding(.horizontal, 12)+        .frame(minHeight: AsterismLayout.minHitTarget)+        .constellationCard()+    }+}++/// The Edit-details sheet (Q20): the Work URL and URL-identity machinery §6's+/// layout has no home for. A view split only — the model's draft and commit+/// surface is unchanged.+struct WorkEditDetailsView: View {+    @Bindable var model: WorkDetailModel+    let onReviewURLIdentity: () -> Void+    let onReteachURLRule: () -> Void+    let onDone: () -> Void++    var body: some View {+        Form {+            Section {                 if case .available(let candidate) = model.workURLCandidate {                     LabeledContent("Suggested") {                         Text(candidate.value)                             .textSelection(.enabled)                     }+                    // Req 9.1: the Edit-details sheet's one gradient control.                     Button(WorkURLDetailPresentation.confirmLabel) {                         Task { await model.confirmWorkURLCandidate() }                     }+                    .buttonStyle(.constellationPrimary)                     .disabled(model.isWorkURLSubmitting || model.isReadOnly)-                    .frame(minHeight: WorkURLDetailPresentation.minimumHitTarget)                     .accessibilityIdentifier(WorkURLDetailPresentation.confirmIdentifier)                 } @@ -110,133 +551,38 @@ struct WorkDetailView: View {                         .foregroundStyle(.secondary)                         .accessibilityIdentifier("work-detail-url-status")                 }-            }--            Section("Tags") {-                // Simple comma-separated tag editing-                TextField(-                    "Genre tags (comma-separated)",-                    text: Binding(-                        get: { model.draftTags.joined(separator: ", ") },-                        set: { model.draftTags = $0.split(separator: ",").map { String($0).trimmingCharacters(in: .whitespaces) } }-                    )-                )-                .disabled(model.isReadOnly)-                .accessibilityIdentifier("work-detail-tags-field")+            } header: {+                ConstellationSectionHeader("Work URL")             }              if model.supportsURLIdentityReview {-                Section("URL Identity") {-                    Button("Review URL identity") {-                        showingURLIdentityReview = true-                    }-                    .disabled(model.state == .submitting)-                    .frame(minHeight: AsterismLayout.minHitTarget)-                    .accessibilityIdentifier("work-detail-review-url-identity")-                    .accessibilityLabel("Review URL identity evidence and conflicts for this Work's site")--                    Button("Re-teach URL rule") {-                        showingURLReteach = true-                    }-                    .disabled(model.state == .submitting)-                    .frame(minHeight: AsterismLayout.minHitTarget)-                    .accessibilityIdentifier("work-detail-reteach-url")-                    .accessibilityLabel("Re-teach the URL rule with the URL details expanded")-                }-            }--            if !work.entries.isEmpty {-                Section("Entries (\(work.entries.count))") {-                    ForEach(work.entries, id: \.id) { entry in-                        UnattachedEntryRow(entry: entry)-                            .accessibilityIdentifier("work-detail-entry")-                            .accessibilityLabel("Assigned entry: \(entry.captureTitle)")-                    }-                }-            }--            if let errorMessage = model.errorMessage {                 Section {-                    Text(errorMessage)-                        .foregroundStyle(.red)-                        .accessibilityIdentifier("work-detail-error")-                }-            }--            Section {-                Button("Save") {-                    Task { await model.save() }-                }-                .disabled(model.state == .submitting || model.isReadOnly)-                .frame(minHeight: AsterismLayout.minHitTarget)-                .accessibilityIdentifier("work-detail-save-button")+                    Button("Review URL identity") { onReviewURLIdentity() }+                        .disabled(model.state == .submitting)+                        .frame(minHeight: AsterismLayout.minHitTarget)+                        .accessibilityIdentifier("work-detail-review-url-identity")+                        .accessibilityLabel(+                            "Review URL identity evidence and conflicts for this Work's site") -                Button("Merge into…") {-                    activeMergeModel = model.mergeModel()+                    Button("Re-teach URL rule") { onReteachURLRule() }+                        .disabled(model.state == .submitting)+                        .frame(minHeight: AsterismLayout.minHitTarget)+                        .accessibilityIdentifier("work-detail-reteach-url")+                        .accessibilityLabel("Re-teach the URL rule with the URL details expanded")+                } header: {+                    ConstellationSectionHeader("URL Identity", accent: .violet)                 }-                .disabled(model.state == .submitting)-                .frame(minHeight: AsterismLayout.minHitTarget)-                .accessibilityIdentifier("work-detail-merge-button")-                .accessibilityLabel("Merge this Work into another Work on the same site")             }         }-        .sheet(-            isPresented: Binding(-                get: { activeMergeModel != nil },-                set: { if !$0 { handleMergeDismissed() } }-            )-        ) {-            if let mergeModel = activeMergeModel {-                WorkMergeView(model: mergeModel)-            }-        }-        .sheet(isPresented: $showingURLIdentityReview) {-            if let reviewModel = model.reviewModel() {-                URLIdentityReviewView(model: reviewModel)-            }-        }-        .sheet(isPresented: $showingURLReteach) {-            if let reteachModel = model.composedURLReteachModel() {-                ComposedTeachingContainerView(model: reteachModel)-            }-        }-    }--    /// Req 2.8 and Req 9.2 on this screen, mirroring Entry detail: say plainly-    /// why the fields are off, and offer the route that turns them back on.-    ///-    /// Without it the reader types into a title field, finds Save greyed out,-    /// and is told nothing — the silent dead end this milestone exists to-    /// remove, reproduced on the Work half.-    private var duplicateReviewSection: some View {-        Section {-            VStack(alignment: .leading, spacing: 6) {-                Text("This work arrived \(model.rowCount) times and the copies differ.")-                    .font(.callout)-                Text("Editing is off until you choose which one to keep — nothing has been lost.")-                    .font(.caption)-                    .foregroundStyle(.secondary)-                if let onResolveDuplicate {-                    Button("Resolve copies") { onResolveDuplicate() }-                        .frame(-                            minWidth: AsterismLayout.minHitTarget,-                            minHeight: AsterismLayout.minHitTarget)-                        .accessibilityIdentifier("work-detail-resolve-duplicate-button")-                }+        .navigationTitle("Edit Details")+        .navigationBarTitleDisplayMode(.inline)+        .accessibilityIdentifier("work-detail-edit-details")+        .toolbar {+            ToolbarItem(placement: .confirmationAction) {+                Button("Done") { onDone() }+                    .frame(minHeight: AsterismLayout.minHitTarget)+                    .accessibilityIdentifier("work-detail-edit-details-done")             }-            .accessibilityIdentifier("work-detail-duplicate-notice")-        }-    }--    /// A committed merge deletes this source Work — leave the detail screen.-    /// Otherwise just reload the unchanged Work.-    private func handleMergeDismissed() {-        let committed = activeMergeModel?.state == .committed-        activeMergeModel = nil-        if committed {-            dismiss()-        } else {-            Task { await model.load() }         }     } }

diff --git a/Asterism/Asterism/Views/WorkMergeView.swift b/Asterism/Asterism/Views/WorkMergeView.swiftindex 2db8e12..9cbc962 100644--- a/Asterism/Asterism/Views/WorkMergeView.swift+++ b/Asterism/Asterism/Views/WorkMergeView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// Merge picker, preview, and confirmation. Reader sees exact consequences@@ -65,7 +66,7 @@ struct WorkMergeView: View {                         } label: {                             VStack(alignment: .leading, spacing: 4) {                                 Text(work.displayTitle)-                                    .font(AsterismTypography.serifTitle(15))+                                    .font(AsterismTypography.serifRowTitle)                                 Text("\(work.entries.count) entries")                                     .font(.caption)                                     .foregroundStyle(.secondary)@@ -76,7 +77,7 @@ struct WorkMergeView: View {                         .accessibilityLabel("Merge into \(work.displayTitle), \(work.entries.count) entries")                     }                 } header: {-                    Text("Same-Site Works")+                    ConstellationSectionHeader("Same-Site Works")                 }             }         }@@ -106,11 +107,11 @@ struct WorkMergeView: View {              // Retained fields             if !outcome.retainedFields.isEmpty {-                Section("Retained") {+                Section(header: ConstellationSectionHeader("Retained", accent: .cyan)) {                     ForEach(outcome.retainedFields, id: \.rawValue) { field in                         HStack(spacing: 8) {                             Image(systemName: "checkmark.circle")-                                .foregroundStyle(.green)+                                .foregroundStyle(AsterismColors.cyan)                                 .accessibilityHidden(true)                             Text(fieldLabel(field))                         }@@ -123,11 +124,11 @@ struct WorkMergeView: View {              // Discarded fields             if !outcome.discardedFields.isEmpty {-                Section("Discarded") {+                Section(header: ConstellationSectionHeader("Discarded", accent: .violet)) {                     ForEach(outcome.discardedFields, id: \.rawValue) { field in                         HStack(spacing: 8) {                             Image(systemName: "archivebox")-                                .foregroundStyle(.orange)+                                .foregroundStyle(AsterismColors.amberText)                                 .accessibilityHidden(true)                             Text(fieldLabel(field))                             Text("Recorded in merged notes")@@ -143,7 +144,7 @@ struct WorkMergeView: View {              // Audit block disclosure             if let auditBlock = outcome.auditBlock {-                Section("Audit Block Preview") {+                Section(header: ConstellationSectionHeader("Audit Block Preview", accent: .violet)) {                     DisclosureGroup {                         Text(auditBlock)                             .font(.footnote.monospaced())@@ -163,11 +164,11 @@ struct WorkMergeView: View {              // Identity issues             if !outcome.issues.isEmpty {-                Section("Identity") {+                Section(header: ConstellationSectionHeader("Identity", accent: .violet)) {                     ForEach(Array(outcome.issues.enumerated()), id: \.offset) { _, issue in                         HStack(spacing: 8) {                             Image(systemName: "exclamationmark.triangle")-                                .foregroundStyle(.orange)+                                .foregroundStyle(AsterismColors.amberText)                                 .accessibilityHidden(true)                             Text(issueLabel(issue))                         }@@ -180,20 +181,16 @@ struct WorkMergeView: View {              // Confirm button             Section {-                Button {+                // Req 9.1: this screen's one gradient control. Everything else+                // on the confirmation is a disclosure or a toolbar item.+                Button("Confirm Merge") {                     Task { await model.confirmMerge() }-                } label: {-                    HStack {-                        Spacer()-                        Text("Confirm Merge")-                            .font(.headline)-                        Spacer()-                    }-                    .frame(minHeight: AsterismLayout.minHitTarget)-                    .contentShape(Rectangle())                 }+                .buttonStyle(.constellationPrimary)                 .accessibilityIdentifier("merge-confirm-button")                 .accessibilityLabel("Confirm merge into \(outcome.displayTitle)")+                .constellationListRow(+                    insets: EdgeInsets(top: 8, leading: 16, bottom: 8, trailing: 16))             }         }     }@@ -205,7 +202,7 @@ struct WorkMergeView: View {         VStack(spacing: 16) {             Image(systemName: "exclamationmark.triangle")                 .font(.largeTitle)-                .foregroundStyle(.orange)+                .foregroundStyle(AsterismColors.amberText)                 .accessibilityHidden(true)             Text(message)                 .multilineTextAlignment(.center)

diff --git a/Asterism/Asterism/Views/WorksView.swift b/Asterism/Asterism/Views/WorksView.swiftindex 11f101a..a611abe 100644--- a/Asterism/Asterism/Views/WorksView.swift+++ b/Asterism/Asterism/Views/WorksView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// Works tab: shows non-empty works, empty works, and unattached entries group.@@ -29,21 +30,61 @@ struct WorksView: View {         self.onResolveDuplicate = onResolveDuplicate     } -    private var nonEmptyWorks: [WorkSnapshot] {-        snapshot.works.filter { !$0.entries.isEmpty }+    /// Req 4.1's query. The filter only removes rows, so the section split+    /// below (and with it empty works sinking) is unaffected by it.+    @State private var searchQuery = ""++    private var searchFilter: WorksSearchFilter {+        WorksSearchFilter(query: searchQuery)     } -    private var emptyWorks: [WorkSnapshot] {-        snapshot.works.filter { $0.entries.isEmpty }+    private var displayedSnapshot: WorksSnapshot {+        searchFilter.apply(to: snapshot)     }      var body: some View {+        // Filtered and partitioned once per body evaluation — the filter runs+        // per keystroke, and the empty check plus both sections consume it.+        let displayedWorks = displayedSnapshot.works+        let nonEmptyWorks = displayedWorks.filter { !$0.entries.isEmpty }+        let emptyWorks = displayedWorks.filter { $0.entries.isEmpty }+        Group {+            if searchFilter.isActive && displayedWorks.isEmpty {+                // Req 4.3. The unattached group is hidden under a query (4.2),+                // so with no matching work there is genuinely nothing to list.+                ContentUnavailableView.search(text: searchQuery)+                    .accessibilityIdentifier("works-search-empty")+            } else {+                worksList(nonEmptyWorks: nonEmptyWorks, emptyWorks: emptyWorks)+            }+        }+        // Requirement 8.1's fixed layer. On the screen's own root rather than+        // on the enclosing `NavigationStack`: a background applied outside the+        // stack renders behind the stack's own opaque backing and never+        // reaches the screen.+        .background { ConstellationBackground() }+        // On the outer container, so the field survives the empty branch.+        .searchable(text: $searchQuery, prompt: "Search works")+        .toolbar {+            ToolbarItem(placement: .primaryAction) {+                Button {+                    onNewWork()+                } label: {+                    Label("New Work", systemImage: "plus")+                }+                .accessibilityIdentifier("works-new-work-button")+            }+        }+    }++    private func worksList(nonEmptyWorks: [WorkSnapshot], emptyWorks: [WorkSnapshot]) -> some View {         List {             // Non-empty works section             if !nonEmptyWorks.isEmpty {                 Section {                     ForEach(nonEmptyWorks, id: \.id) { work in                         workButton(work)+                            .constellationListRow()                     }                 }             }@@ -53,48 +94,67 @@ struct WorksView: View {                 Section {                     ForEach(emptyWorks, id: \.id) { work in                         workButton(work)+                            .constellationListRow()                     }                 }             } -            // Unattached notes group-            Section {-                if snapshot.unattachedEntries.isEmpty {-                    Text("No unattached notes")-                        .foregroundStyle(.secondary)-                        .accessibilityIdentifier("unattached-empty")-                } else {-                    ForEach(snapshot.unattachedEntries, id: \.id) { entry in-                        Button {-                            onSelectEntry(entry.id)-                        } label: {-                            UnattachedEntryRow(entry: entry)-                                .contentShape(Rectangle())-                        }-                        .buttonStyle(.plain)-                        .accessibilityIdentifier("unattached-entry-\(entry.id.uuidString)")-                        .accessibilityLabel("Open unattached entry \(entry.captureTitle)")+            // Unattached notes group. Hidden outright while a query is active+            // (Req 4.2, Q12): these entries have no work title to search, and+            // an empty group under a query reads as "your search cleared them".+            if !searchFilter.isActive {+                Section {+                    unattachedGroup+                        .constellationListRow()+                } header: {+                    HStack(spacing: 6) {+                        ConstellationSectionHeader("Unattached Notes", accent: .violet)+                            .accessibilityIdentifier("unattached-section-header")+                        Spacer()+                        // §7/Req 9.4: the group carries a count pill, as the+                        // work rows do. The header stays its own static-text+                        // element beside it (Q42).+                        Text("\(snapshot.unattachedEntries.count)")+                            .constellationPill(.count)+                            .accessibilityIdentifier("unattached-entry-count")                     }                 }-            } header: {-                Text("Unattached Notes")-                    .font(AsterismTypography.sectionHeader)-                    .textCase(.uppercase)-                    .accessibilityIdentifier("unattached-section-header")             }         }         .listStyle(.plain)-        .toolbar {-            ToolbarItem(placement: .primaryAction) {-                Button {-                    onNewWork()-                } label: {-                    Label("New Work", systemImage: "plus")+        // Req 8.1: content scrolls over the tab stack's sky.+        .scrollContentBackground(.hidden)+        .accessibilityIdentifier("works-list")+    }++    /// §7's unattached-notes group: one dashed, lower-fill container around the+    /// rows rather than a dashed edge per row — the group is what the style+    /// guide marks.+    private var unattachedGroup: some View {+        VStack(alignment: .leading, spacing: 4) {+            if snapshot.unattachedEntries.isEmpty {+                Text("No unattached notes")+                    .foregroundStyle(AsterismColors.secondaryText)+                    .frame(minHeight: AsterismLayout.minHitTarget)+                    .accessibilityIdentifier("unattached-empty")+            } else {+                ForEach(snapshot.unattachedEntries, id: \.id) { entry in+                    Button {+                        onSelectEntry(entry.id)+                    } label: {+                        UnattachedEntryRow(entry: entry)+                            .frame(maxWidth: .infinity, alignment: .leading)+                            .contentShape(Rectangle())+                    }+                    .buttonStyle(.plain)+                    .accessibilityIdentifier("unattached-entry-\(entry.id.uuidString)")+                    .accessibilityLabel("Open unattached entry \(entry.captureTitle)")                 }-                .accessibilityIdentifier("works-new-work-button")             }         }-        .accessibilityIdentifier("works-list")+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(12)+        .constellationDashedGroup()     }      /// The row and its Resolve pill are sibling buttons, exactly as Recent's@@ -122,20 +182,18 @@ struct WorksView: View {                     onResolveDuplicate(item.route.blockingWorkSet ?? item.key)                 } label: {                     Text(item.route == .merge ? "Merge" : "Resolve")-                        .font(.caption.bold())-                        .foregroundStyle(AsterismColors.amberDark)-                        .padding(.horizontal, 8)-                        .padding(.vertical, 10)-                        .frame(minHeight: AsterismLayout.minHitTarget)-                        .background(AsterismColors.amberDark.opacity(0.15))-                        .clipShape(Capsule())+                        .constellationPill(.attention)                 }                 .buttonStyle(.plain)-                .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)                 .accessibilityIdentifier("work-resolve-duplicate-pill")                 .accessibilityLabel("Resolve duplicate copies of \(work.displayTitle)")             }         }+        .padding(.vertical, 10)+        .padding(.horizontal, 12)+        // A Work awaiting a decision wears the amber border its Entries do+        // (Decision 1); every other work row is the plain card.+        .constellationCard(borderColor: item == nil ? nil : AsterismColors.attentionBorder)     } } @@ -145,32 +203,33 @@ struct WorkRow: View {      var body: some View {         VStack(alignment: .leading, spacing: 4) {+            // Req 11.3: single-line work names truncate, never wrap.             Text(work.displayTitle)-                .font(AsterismTypography.serifTitle(15))+                .font(AsterismTypography.serifRowTitle)                 .lineLimit(1)+                .truncationMode(.tail)+                .foregroundStyle(AsterismColors.primaryText)                 .accessibilityIdentifier("work-title")              HStack(spacing: 6) {-                Text(work.siteHostname)-                    .font(.caption)-                    .foregroundStyle(.secondary)+                // Req 9.2: the glyph stands in for the hostname text.+                SiteGlyph(hostname: work.siteHostname, size: 18)                  if work.type != .other {+                    // §7's type tag: violet tint and border.                     Text(work.type.rawValue)-                        .font(.caption2.weight(.semibold))-                        .foregroundStyle(AsterismColors.violetDark)+                        .constellationPill(.typeTag)                         .accessibilityIdentifier("work-type-tag")                 }                  Spacer() +                // §7's count pill: cyan text on a cyan .12 fill.                 Text("\(work.entries.count)")-                    .font(.caption2.weight(.bold))-                    .foregroundStyle(AsterismColors.cyanDark)+                    .constellationPill(.count)                     .accessibilityIdentifier("work-entry-count")             }         }-        .padding(.vertical, 4)         .frame(minHeight: AsterismLayout.minHitTarget)     } }@@ -182,24 +241,26 @@ struct UnattachedEntryRow: View {     var body: some View {         VStack(alignment: .leading, spacing: 4) {             Text(entry.captureTitle)-                .font(AsterismTypography.serifTitle(15))+                .font(AsterismTypography.serifRowTitle)                 .lineLimit(1)+                .truncationMode(.tail)+                .foregroundStyle(AsterismColors.primaryText)                 .accessibilityIdentifier("entry-title")              HStack(spacing: 6) {-                Text(entry.hostname)-                    .font(.caption)-                    .foregroundStyle(.secondary)+                // §7's dim ✎ glyph marks the group; an unattached entry has no+                // taught identity to colour a site glyph with.+                SiteGlyph(hostname: entry.hostname, kind: .articles, size: 18)                     .accessibilityIdentifier("entry-hostname")                 Spacer()                 if let rating = entry.rating {                     Text(rating == .up ? "▲" : "▼")                         .font(.caption)-                        .foregroundStyle(rating == .up ? AsterismColors.cyanDark : AsterismColors.violetDark)+                        .foregroundStyle(rating == .up ? AsterismColors.cyan : AsterismColors.violet)                 }                 Text(entry.lastSharedAt, style: .time)                     .font(.caption2)-                    .foregroundStyle(.secondary)+                    .foregroundStyle(AsterismColors.secondaryText)             }         }         .padding(.vertical, 4)

diff --git a/Asterism/AsterismShareExtension/CaptureView.swift b/Asterism/AsterismShareExtension/CaptureView.swiftindex 9bad3d3..0672d70 100644--- a/Asterism/AsterismShareExtension/CaptureView.swift+++ b/Asterism/AsterismShareExtension/CaptureView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  /// Capture sheet SwiftUI view: loading, invalid URL, first-site amber state,@@ -9,8 +10,6 @@ import SwiftUI struct CaptureView: View {     @ObservedObject var viewModel: ObservableCaptureViewModel     @FocusState private var noteFieldFocused: Bool-    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency-    @Environment(\.colorScheme) private var colorScheme     let onSaveCompleted: () -> Void     let onCancel: () -> Void @@ -39,7 +38,7 @@ struct CaptureView: View {                     .disabled(viewModel.isSaving)                     .accessibilityLabel("Cancel capture")                     .accessibilityIdentifier("capture.cancel")-                    .frame(minWidth: 44, minHeight: 44)+                    .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)                 }             }         }@@ -68,16 +67,6 @@ struct CaptureView: View {         }     } -    // MARK: - Surface background (Reduce Transparency aware)--    private var fieldBackground: some ShapeStyle {-        if reduceTransparency {-            return AnyShapeStyle(colorScheme == .dark ? Color(white: 0.18) : Color(white: 0.92))-        } else {-            return AnyShapeStyle(.fill.quaternary)-        }-    }-     // MARK: - Loading      private var loadingContent: some View {@@ -158,7 +147,7 @@ struct CaptureView: View {         VStack(spacing: 12) {             Image(systemName: "checkmark.circle.fill")                 .font(.largeTitle)-                .foregroundStyle(.green)+                .foregroundStyle(AsterismColors.cyan)                 .accessibilityHidden(true)             Text("Saved")                 .font(.headline)@@ -180,23 +169,32 @@ struct CaptureView: View {                 manualTitleInput             } else if let title = preparation.resolvedTitle {                 Text(title)-                    .font(.headline)+                    .font(AsterismTypography.serifHeading)                     .accessibilityLabel("Page title")                     .accessibilityIdentifier("capture.pageTitle")             }              if let host = Self.hostname(from: preparation.rawURL) {-                Text(host)-                    .font(.caption)-                    .foregroundStyle(.secondary)-                    .accessibilityLabel("Site: \(host)")-                    .accessibilityIdentifier("capture.hostname")+                HStack(spacing: 6) {+                    // Requirement 9.2: a hostname shown as plain text takes the+                    // glyph instead.+                    SiteGlyph(+                        hostname: host,+                        kind: preparation.siteStatus == .newSite ? .unknown : .site,+                        size: 18+                    )+                    Text(host)+                        .font(.caption)+                        .foregroundStyle(AsterismColors.secondaryText)+                }+                .accessibilityElement(children: .combine)+                .accessibilityLabel("Site: \(host)")+                .accessibilityIdentifier("capture.hostname")             }         }         .frame(maxWidth: .infinity, alignment: .leading)         .padding()-        .background(fieldBackground)-        .clipShape(RoundedRectangle(cornerRadius: 12))+        .constellationField()         .accessibilityIdentifier("capture.metadata")     } @@ -224,7 +222,7 @@ struct CaptureView: View {                 HStack(spacing: 6) {                     Image(systemName: "bookmark.fill")                         .font(.caption)-                        .foregroundStyle(.blue)+                        .foregroundStyle(AsterismColors.cyan)                         .accessibilityHidden(true)                     Text("Chapter: \(chapter)")                         .font(.subheadline)@@ -264,7 +262,7 @@ struct CaptureView: View {                 HStack(spacing: 6) {                     Image(systemName: "book.fill")                         .font(.caption)-                        .foregroundStyle(.purple)+                        .foregroundStyle(AsterismColors.violet)                         .accessibilityHidden(true)                     Text(workDescription)                         .font(.subheadline)@@ -277,11 +275,11 @@ struct CaptureView: View {                 HStack(spacing: 6) {                     Image(systemName: "exclamationmark.circle")                         .font(.caption)-                        .foregroundStyle(.orange)+                        .foregroundStyle(AsterismColors.amberText)                         .accessibilityHidden(true)                     Text("Title does not match pattern")                         .font(.subheadline)-                        .foregroundStyle(.orange)+                        .foregroundStyle(AsterismColors.amberText)                 }                 .accessibilityElement(children: .combine)                 .accessibilityLabel("Title does not match pattern")@@ -293,11 +291,11 @@ struct CaptureView: View {                 HStack(spacing: 6) {                     Image(systemName: "flag.fill")                         .font(.caption)-                        .foregroundStyle(.orange)+                        .foregroundStyle(AsterismColors.amberText)                         .accessibilityHidden(true)                     Text("Actionable — needs review after save")                         .font(.caption)-                        .foregroundStyle(.orange)+                        .foregroundStyle(AsterismColors.amberText)                 }                 .accessibilityElement(children: .combine)                 .accessibilityLabel("Actionable. Needs review after save.")@@ -306,8 +304,7 @@ struct CaptureView: View {         }         .frame(maxWidth: .infinity, alignment: .leading)         .padding()-        .background(fieldBackground)-        .clipShape(RoundedRectangle(cornerRadius: 12))+        .constellationField()         .accessibilityIdentifier("capture.projectedMetadata")     } @@ -315,13 +312,13 @@ struct CaptureView: View {      private var newSiteBanner: some View {         HStack(spacing: 6) {-            Image(systemName: "star.fill")+            Image(systemName: "sparkle")                 .font(.caption)-                .foregroundStyle(.orange)+                .foregroundStyle(AsterismColors.amberText)                 .accessibilityHidden(true)             Text("New site — title saved, teach later in app")                 .font(.caption)-                .foregroundStyle(.orange)+                .foregroundStyle(AsterismColors.amberText)         }         .accessibilityElement(children: .combine)         .accessibilityLabel("New site. Title will be saved. Teach later in app.")@@ -330,18 +327,15 @@ struct CaptureView: View {     private func reviewBanner(message: String) -> some View {         HStack(spacing: 8) {             Image(systemName: "arrow.triangle.2.circlepath")-                .foregroundStyle(.blue)+                .foregroundStyle(AsterismColors.cyan)                 .accessibilityHidden(true)             Text(message)                 .font(.subheadline)-                .foregroundStyle(.primary)+                .foregroundStyle(AsterismColors.primaryText)         }         .padding()         .frame(maxWidth: .infinity, alignment: .leading)-        .background(reduceTransparency-            ? AnyShapeStyle(colorScheme == .dark ? Color(white: 0.15) : Color(white: 0.95))-            : AnyShapeStyle(Color.blue.opacity(0.1)))-        .clipShape(RoundedRectangle(cornerRadius: 12))+        .constellationField()         .accessibilityElement(children: .combine)         .accessibilityLabel(message)         .accessibilityIdentifier("capture.reviewBanner")@@ -349,29 +343,26 @@ struct CaptureView: View {      private var manualTitleInput: some View {         TextField("Title (required)", text: $viewModel.manualTitle)-            .font(.headline)+            .font(AsterismTypography.serifHeading)             .textFieldStyle(.plain)             .accessibilityLabel("Page title, required")             .accessibilityHint("Enter a title for this capture")             .accessibilityIdentifier("capture.manualTitle")-            .frame(minHeight: 44)+            .frame(minHeight: AsterismLayout.minHitTarget)     }      // MARK: - Note      private var noteSection: some View {         VStack(alignment: .leading, spacing: 4) {-            Text("Note")-                .font(.caption)-                .foregroundStyle(.secondary)+            ConstellationSectionHeader("Note")             TextEditor(text: $viewModel.note)                 .focused($noteFieldFocused)                 .font(.body)                 .frame(minHeight: 88)                 .scrollContentBackground(.hidden)                 .padding(8)-                .background(fieldBackground)-                .clipShape(RoundedRectangle(cornerRadius: 12))+                .constellationField()                 .accessibilityLabel("Note")                 .accessibilityHint("Optional note for this capture")                 .accessibilityIdentifier("capture.note")@@ -395,18 +386,15 @@ struct CaptureView: View {      private func ratingToggle(rating: Rating, symbol: String, label: String) -> some View {         let isSelected = viewModel.currentRating == rating-        let accentColor: Color = rating == .up ? .cyan : .purple         return Button {             viewModel.toggleRating(rating)         } label: {             Image(systemName: symbol)                 .font(.title3)-                .foregroundStyle(isSelected ? accentColor : .secondary)-                .frame(width: 48, height: 44)-                .background(isSelected ? accentColor.opacity(0.15) : Color.clear)-                .clipShape(Capsule())-                .overlay(Capsule().stroke(isSelected ? accentColor.opacity(0.55) : Color.clear, lineWidth: 1))         }+        .buttonStyle(+            .constellationRatingToggle(rating == .up ? .up : .down, isActive: isSelected)+        )         .disabled(viewModel.isSaving)         .accessibilityLabel(label)         .accessibilityIdentifier("capture.rating.\(rating.rawValue)")@@ -420,10 +408,8 @@ struct CaptureView: View {             viewModel.save()         } label: {             Text("Save")-                .font(.headline)-                .frame(maxWidth: .infinity, minHeight: 44)         }-        .buttonStyle(.borderedProminent)+        .buttonStyle(.constellationPrimary)         .disabled(!viewModel.canSave || viewModel.isSaving)         .accessibilityLabel("Save capture")         .accessibilityIdentifier("capture.save")@@ -434,10 +420,8 @@ struct CaptureView: View {             viewModel.save()         } label: {             Text("Try Again")-                .font(.headline)-                .frame(maxWidth: .infinity, minHeight: 44)         }-        .buttonStyle(.borderedProminent)+        .buttonStyle(.constellationPrimary)         .disabled(!viewModel.canSave || viewModel.isSaving)         .accessibilityLabel("Try saving again")         .accessibilityIdentifier("capture.retry")@@ -446,18 +430,17 @@ struct CaptureView: View {     private func errorBanner(message: String) -> some View {         HStack(spacing: 8) {             Image(systemName: "exclamationmark.triangle.fill")-                .foregroundStyle(.red)+                .foregroundStyle(AsterismColors.amberText)                 .accessibilityHidden(true)             Text(message)                 .font(.subheadline)-                .foregroundStyle(.primary)+                .foregroundStyle(AsterismColors.primaryText)         }         .padding()         .frame(maxWidth: .infinity, alignment: .leading)-        .background(reduceTransparency-            ? AnyShapeStyle(colorScheme == .dark ? Color(white: 0.15) : Color(white: 0.95))-            : AnyShapeStyle(Color.red.opacity(0.1)))-        .clipShape(RoundedRectangle(cornerRadius: 12))+        // Decision 1: a failure the reader has to act on is an+        // actionable-attention surface.+        .constellationAttentionSurface(cornerRadius: AsterismLayout.fieldRadius)         .accessibilityElement(children: .combine)         .accessibilityLabel("Error: \(message)")         .accessibilityIdentifier("capture.error")

diff --git a/Asterism/AsterismShareExtension/ReShareCaptureView.swift b/Asterism/AsterismShareExtension/ReShareCaptureView.swiftindex 6279402..81c864b 100644--- a/Asterism/AsterismShareExtension/ReShareCaptureView.swift+++ b/Asterism/AsterismShareExtension/ReShareCaptureView.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI  // MARK: - Re-share capture view (Design §9.4, task 36)@@ -13,8 +14,6 @@ import SwiftUI struct ReShareCaptureView: View {     @ObservedObject var viewModel: ObservableReShareViewModel     @FocusState private var noteFieldFocused: Bool-    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency-    @Environment(\.colorScheme) private var colorScheme     let onCompleted: () -> Void     let onCancel: () -> Void @@ -34,8 +33,8 @@ struct ReShareCaptureView: View {                         .disabled(viewModel.isSaving)                         .accessibilityLabel("Cancel capture")                         .accessibilityIdentifier("reshare.cancel")-                        .frame(minWidth: ReShareLayoutConstants.minimumHitTarget,-                               minHeight: ReShareLayoutConstants.minimumHitTarget)+                        .frame(minWidth: AsterismLayout.minHitTarget,+                               minHeight: AsterismLayout.minHitTarget)                 }             }         }@@ -62,16 +61,6 @@ struct ReShareCaptureView: View {         }     } -    // MARK: - Surface background--    private var fieldBackground: some ShapeStyle {-        if reduceTransparency {-            return AnyShapeStyle(colorScheme == .dark ? Color(white: 0.18) : Color(white: 0.92))-        } else {-            return AnyShapeStyle(.fill.quaternary)-        }-    }-     // MARK: - Loading      private var loadingContent: some View {@@ -130,18 +119,15 @@ struct ReShareCaptureView: View {         let bannerText = ReShareBannerFormatter.format(firstCapturedAt: firstCapturedAt)         return HStack(spacing: 8) {             Image(systemName: "pencil.circle.fill")-                .foregroundStyle(.blue)+                .foregroundStyle(AsterismColors.cyan)                 .accessibilityHidden(true)             Text(bannerText)                 .font(.subheadline)-                .foregroundStyle(.primary)+                .foregroundStyle(AsterismColors.primaryText)         }         .padding()         .frame(maxWidth: .infinity, alignment: .leading)-        .background(reduceTransparency-            ? AnyShapeStyle(colorScheme == .dark ? Color(white: 0.15) : Color(white: 0.95))-            : AnyShapeStyle(Color.blue.opacity(0.1)))-        .clipShape(RoundedRectangle(cornerRadius: 12))+        .constellationField()         .accessibilityElement(children: .combine)         .accessibilityLabel(bannerText)         .accessibilityIdentifier("reshare.editBanner")@@ -152,7 +138,7 @@ struct ReShareCaptureView: View {     private var newCaptureContent: some View {         VStack(spacing: 12) {             Text("New capture")-                .font(.headline)+                .font(AsterismTypography.serifHeading)             Text("This page hasn't been captured before.")                 .font(.subheadline)                 .foregroundStyle(.secondary)@@ -181,7 +167,7 @@ struct ReShareCaptureView: View {         VStack(spacing: 12) {             Image(systemName: "checkmark.circle.fill")                 .font(.largeTitle)-                .foregroundStyle(.green)+                .foregroundStyle(AsterismColors.cyan)                 .accessibilityHidden(true)             Text("Updated")                 .font(.headline)@@ -194,17 +180,14 @@ struct ReShareCaptureView: View {      private var noteSection: some View {         VStack(alignment: .leading, spacing: 4) {-            Text("Note")-                .font(.caption)-                .foregroundStyle(.secondary)+            ConstellationSectionHeader("Note")             TextEditor(text: $viewModel.draftNote)                 .focused($noteFieldFocused)                 .font(.body)                 .frame(minHeight: 88)                 .scrollContentBackground(.hidden)                 .padding(8)-                .background(fieldBackground)-                .clipShape(RoundedRectangle(cornerRadius: 12))+                .constellationField()                 .accessibilityLabel("Note")                 .accessibilityHint("Edit your note for this entry")                 .accessibilityIdentifier("reshare.note")@@ -226,18 +209,15 @@ struct ReShareCaptureView: View {      private func ratingToggle(rating: Rating, symbol: String, label: String) -> some View {         let isSelected = viewModel.draftRating == rating-        let accentColor: Color = rating == .up ? .cyan : .purple         return Button {             viewModel.toggleRating(rating)         } label: {             Image(systemName: symbol)                 .font(.title3)-                .foregroundStyle(isSelected ? accentColor : .secondary)-                .frame(width: 48, height: ReShareLayoutConstants.minimumHitTarget)-                .background(isSelected ? accentColor.opacity(0.15) : Color.clear)-                .clipShape(Capsule())-                .overlay(Capsule().stroke(isSelected ? accentColor.opacity(0.55) : Color.clear, lineWidth: 1))         }+        .buttonStyle(+            .constellationRatingToggle(rating == .up ? .up : .down, isActive: isSelected)+        )         .disabled(viewModel.isSaving)         .accessibilityLabel(label)         .accessibilityIdentifier("reshare.rating.\(rating.rawValue)")@@ -249,11 +229,8 @@ struct ReShareCaptureView: View {             viewModel.submitUpdate()         } label: {             Text(ReShareActionLabels.primaryAction(for: viewModel.state))-                .font(.headline)-                .frame(maxWidth: .infinity,-                       minHeight: ReShareLayoutConstants.minimumHitTarget)         }-        .buttonStyle(.borderedProminent)+        .buttonStyle(.constellationPrimary)         .disabled(viewModel.isSaving)         .accessibilityLabel(ReShareActionLabels.primaryActionAccessibilityLabel(for: viewModel.state))         .accessibilityIdentifier("reshare.update")@@ -262,18 +239,17 @@ struct ReShareCaptureView: View {     private func errorBanner(message: String) -> some View {         HStack(spacing: 8) {             Image(systemName: "exclamationmark.triangle.fill")-                .foregroundStyle(.red)+                .foregroundStyle(AsterismColors.amberText)                 .accessibilityHidden(true)             Text(message)                 .font(.subheadline)-                .foregroundStyle(.primary)+                .foregroundStyle(AsterismColors.primaryText)         }         .padding()         .frame(maxWidth: .infinity, alignment: .leading)-        .background(reduceTransparency-            ? AnyShapeStyle(colorScheme == .dark ? Color(white: 0.15) : Color(white: 0.95))-            : AnyShapeStyle(Color.red.opacity(0.1)))-        .clipShape(RoundedRectangle(cornerRadius: 12))+        // Decision 1: a failure the reader has to act on is an+        // actionable-attention surface.+        .constellationAttentionSurface(cornerRadius: AsterismLayout.fieldRadius)         .accessibilityElement(children: .combine)         .accessibilityLabel("Error: \(message)")         .accessibilityIdentifier("reshare.error")@@ -401,8 +377,8 @@ struct UnavailableSetupView: View {                     Button("Done") { onDismiss() }                         .accessibilityLabel("Dismiss")                         .accessibilityIdentifier("unavailable.dismiss")-                        .frame(minWidth: ReShareLayoutConstants.minimumHitTarget,-                               minHeight: ReShareLayoutConstants.minimumHitTarget)+                        .frame(minWidth: AsterismLayout.minHitTarget,+                               minHeight: AsterismLayout.minHitTarget)                 }             }         }

diff --git a/Asterism/AsterismShareExtension/ShareViewController.swift b/Asterism/AsterismShareExtension/ShareViewController.swiftindex 5a08903..6766662 100644--- a/Asterism/AsterismShareExtension/ShareViewController.swift+++ b/Asterism/AsterismShareExtension/ShareViewController.swift@@ -1,4 +1,5 @@ import AsterismCore+import ConstellationKit import SwiftUI import UIKit @@ -16,7 +17,10 @@ final class ShareViewController: UIViewController {      override func viewDidLoad() {         super.viewDidLoad()-        view.backgroundColor = .systemBackground+        // Clear, not `.systemBackground`: the SwiftUI root supplies the §4+        // sheet glass, and an opaque host view underneath would flatten it+        // (requirement 10.1).+        view.backgroundColor = .clear         accessibilityViewIsModal = true          host(AnyView(LoadingCaptureView()))@@ -100,8 +104,9 @@ final class ShareViewController: UIViewController {         hostingController?.view.removeFromSuperview()         hostingController?.removeFromParent() -        let hosting = UIHostingController(rootView: view)+        let hosting = UIHostingController(rootView: AnyView(CaptureSheetChrome { view }))         addChild(hosting)+        hosting.view.backgroundColor = .clear         hosting.view.translatesAutoresizingMaskIntoConstraints = false         self.view.addSubview(hosting.view)         NSLayoutConstraint.activate([@@ -135,6 +140,50 @@ final class ShareViewController: UIViewController {     } } +// MARK: - Sheet chrome++/// The §4 sheet treatment for every hosted state (requirement 10.1): sheet+/// glass plus the specular top edge.+///+/// Deliberately **not** the sky layer — requirement 10.3 keeps the background+/// layer out of the extension, and stacking sky under sheet glass would breach+/// the style guide's two-layer maximum anyway. The corner shape is the system+/// sheet's; this only fills behind the content, so nothing here can fail a+/// capture.+private struct CaptureSheetChrome<Content: View>: View {+    @Environment(\.accessibilityReduceTransparency) private var reduceTransparency++    private let content: Content++    init(@ViewBuilder content: () -> Content) {+        self.content = content()+    }++    var body: some View {+        content+            .background {+                Group {+                    if reduceTransparency {+                        Rectangle().fill(AsterismColors.opaqueCard)+                    } else {+                        ZStack {+                            Rectangle().fill(.regularMaterial)+                            Rectangle().fill(AsterismColors.sheetFill)+                        }+                    }+                }+                .ignoresSafeArea()+            }+            .overlay(alignment: .top) {+                Rectangle()+                    .fill(AsterismColors.specularEdge)+                    .frame(height: 1)+                    .ignoresSafeArea(edges: .horizontal)+                    .allowsHitTesting(false)+            }+    }+}+ // MARK: - Simple hosted states  private struct LoadingCaptureView: View {

diff --git a/Asterism/AsterismTests/ConflictRecentEntryDetailPresentationTests.swift b/Asterism/AsterismTests/ConflictRecentEntryDetailPresentationTests.swiftindex 3ed0817..10a820c 100644--- a/Asterism/AsterismTests/ConflictRecentEntryDetailPresentationTests.swift+++ b/Asterism/AsterismTests/ConflictRecentEntryDetailPresentationTests.swift@@ -154,13 +154,14 @@ struct ConflictRecentEntryDetailPresentationTests {         // and does not use a cached conflict flag.         let mock = MockLibraryProvider()         let work = TestFixtures.makeWork(id: UUID(), displayTitle: "Test Work")-        mock.workResult = .success(work)+        mock.workDetailResult = .success(TestFixtures.makeWorkDetail(work: work))          let model = WorkDetailModel(workID: work.id, library: mock, onMutation: {})         await model.load() -        // Loading the work invokes work() — that's the live read.-        #expect(mock.workCallCount == 1)+        // Loading the work invokes workDetail() — that's the live read (M5+        // swapped work(id:) for the §6 read; it is still one live call).+        #expect(mock.workDetailCallCount == 1)     }      // MARK: - Accessibility

diff --git a/Asterism/AsterismTests/DuplicateSurfaceTests.swift b/Asterism/AsterismTests/DuplicateSurfaceTests.swiftindex 59d5963..b6c4dfb 100644--- a/Asterism/AsterismTests/DuplicateSurfaceTests.swift+++ b/Asterism/AsterismTests/DuplicateSurfaceTests.swift@@ -421,20 +421,20 @@ struct DuplicateSurfaceTests {     @MainActor func aTornWorkIsReadOnly() async {         let library = MockLibraryProvider()         let work = TestFixtures.makeWork(displayTitle: "Serial")-        library.workResult = .success(-            WorkSnapshot(-                id: work.id, displayTitle: work.displayTitle, lastParsedTitle: "Serial",-                siteHostname: work.siteHostname, urlIdentity: nil, workURLString: nil,-                genericNotes: "", type: .other, genreTags: [], titleProvenance: .parsed,-                createdAt: work.createdAt, modifiedAt: work.modifiedAt, entries: [],-                groupState: .torn(variants: [-                    AuthoredVariant(-                        content: WorkAuthoredContent(genericNotes: "this device"),-                        firstCapturedAt: TestFixtures.fixedDate),-                    AuthoredVariant(-                        content: WorkAuthoredContent(genericNotes: "the other one"),-                        firstCapturedAt: TestFixtures.laterDate),-                ])))+        let torn = WorkSnapshot(+            id: work.id, displayTitle: work.displayTitle, lastParsedTitle: "Serial",+            siteHostname: work.siteHostname, urlIdentity: nil, workURLString: nil,+            genericNotes: "", type: .other, genreTags: [], titleProvenance: .parsed,+            createdAt: work.createdAt, modifiedAt: work.modifiedAt, entries: [],+            groupState: .torn(variants: [+                AuthoredVariant(+                    content: WorkAuthoredContent(genericNotes: "this device"),+                    firstCapturedAt: TestFixtures.fixedDate),+                AuthoredVariant(+                    content: WorkAuthoredContent(genericNotes: "the other one"),+                    firstCapturedAt: TestFixtures.laterDate),+            ]))+        library.workDetailResult = .success(TestFixtures.makeWorkDetail(work: torn))         let model = WorkDetailModel(workID: work.id, library: library, onMutation: {})          await model.load()

diff --git a/Asterism/AsterismTests/Helpers/MockLibraryProvider.swift b/Asterism/AsterismTests/Helpers/MockLibraryProvider.swiftindex 1952d72..6c58665 100644--- a/Asterism/AsterismTests/Helpers/MockLibraryProvider.swift+++ b/Asterism/AsterismTests/Helpers/MockLibraryProvider.swift@@ -137,6 +137,74 @@ final class MockLibraryProvider: LibraryProviding, @unchecked Sendable {         return try workDestinationsResult.get()     } +    // MARK: - M5 reads and work deletion++    var sitesCallCount = 0+    var workDetailCallCount = 0+    var entryExportInputCallCount = 0+    var workExportInputCallCount = 0+    var projectWorkDeletionCallCount = 0+    var commitWorkDeletionCallCount = 0++    var sitesResult: Result<[SiteSnapshot], Error> = .success([])+    var workDetailResult: Result<WorkDetailPresentation, Error> = .failure(MockError.notConfigured)+    var entryExportInputResult: Result<EntryExportInput, Error> = .failure(MockError.notConfigured)+    var workExportInputResult: Result<WorkExportInput, Error> = .failure(MockError.notConfigured)+    var projectWorkDeletionResult: Result<WorkDeletionContract, Error> = .failure(+        MockError.notConfigured)+    var commitWorkDeletionResult: Result<WorkDeletionCommitOutcome, Error> = .success(.committed)++    var lastExportLocale: Locale?+    /// Holds an export-input read open, so a second submission can be observed+    /// arriving while the first is still in flight.+    var exportInputDelay: Duration?+    var lastWorkDeletionDisposition: WorkDeletionDisposition?+    /// Doubly optional for `deleteEntry`'s reason: the outer level says whether+    /// the commit was called, the inner one carries what it was passed — and+    /// `nil` there is the "no disclosure was made" a torn group refuses.+    var lastWorkDeletionDisclosedVariants: Set<VariantID>??++    func sites() async throws -> [SiteSnapshot] {+        sitesCallCount += 1+        callLog.append("sites")+        return try sitesResult.get()+    }++    func workDetail(id: UUID) async throws -> WorkDetailPresentation {+        workDetailCallCount += 1+        callLog.append("workDetail")+        return try workDetailResult.get()+    }++    func entryExportInput(entryID: UUID, locale: Locale) async throws -> EntryExportInput {+        entryExportInputCallCount += 1+        lastExportLocale = locale+        if let exportInputDelay { try? await Task.sleep(for: exportInputDelay) }+        return try entryExportInputResult.get()+    }++    func workExportInput(workID: UUID, locale: Locale) async throws -> WorkExportInput {+        workExportInputCallCount += 1+        lastExportLocale = locale+        if let exportInputDelay { try? await Task.sleep(for: exportInputDelay) }+        return try workExportInputResult.get()+    }++    func projectWorkDeletion(workID: UUID) async throws -> WorkDeletionContract {+        projectWorkDeletionCallCount += 1+        return try projectWorkDeletionResult.get()+    }++    func commitWorkDeletion(+        _ contract: WorkDeletionContract, disposition: WorkDeletionDisposition,+        disclosedVariants: Set<VariantID>?+    ) async throws -> WorkDeletionCommitOutcome {+        commitWorkDeletionCallCount += 1+        lastWorkDeletionDisposition = disposition+        lastWorkDeletionDisclosedVariants = .some(disclosedVariants)+        return try commitWorkDeletionResult.get()+    }+     // MARK: - Teaching contract stubs      var entryTeachingDetailResult: Result<EntryTeachingDetail, Error> = .failure(MockError.notConfigured)

diff --git a/Asterism/AsterismTests/Helpers/TestFixtures.swift b/Asterism/AsterismTests/Helpers/TestFixtures.swiftindex 205ea9f..18b0e0b 100644--- a/Asterism/AsterismTests/Helpers/TestFixtures.swift+++ b/Asterism/AsterismTests/Helpers/TestFixtures.swift@@ -39,6 +39,66 @@ enum TestFixtures {         )     } +    /// A Recent row carrying exactly the fields search reads (Req 3.1, 3.3).+    /// Everything else is the settled, unactionable shape — the rows the search+    /// tests care about are ordinary ones.+    static func makeRecentRow(+        id: UUID = UUID(),+        captureTitle: String = "Test Entry",+        hostname: String = "example.com",+        workDisplayTitle: String? = nil,+        chapterTitle: String? = nil,+        note: String = "",+        rating: Rating? = nil,+        isActionable: Bool = false,+        lastSharedAt: Date = fixedDate+    ) -> RecentPresentationRow {+        RecentPresentationRow(+            id: id,+            entry: makeEntry(+                id: id, captureTitle: captureTitle, hostname: hostname, note: note,+                rating: rating, lastSharedAt: lastSharedAt),+            captureTitle: captureTitle,+            hostname: hostname,+            workDisplayTitle: workDisplayTitle,+            chapterTitle: chapterTitle,+            unresolvedCandidateTitle: nil,+            siteMode: .taught,+            isActionable: isActionable,+            actionType: isActionable ? .reteach : .none,+            note: note,+            rating: rating,+            lastSharedAt: lastSharedAt+        )+    }++    /// The §6 Work-detail read, defaulting to the shape a one-entry work+    /// produces so a test only states the part it is about.+    static func makeWorkDetail(+        work: WorkSnapshot,+        pulse: RatingPulse? = nil,+        lastNotedURLString: String? = nil,+        chapterRows: [WorkChapterRow]? = nil+    ) -> WorkDetailPresentation {+        let rows = chapterRows ?? work.entries.map { entry in+            WorkChapterRow(+                id: entry.id,+                displayTitle: entry.chapterTitle ?? entry.captureTitle,+                note: entry.note,+                rating: entry.rating,+                lastSharedAt: entry.lastSharedAt)+        }+        return WorkDetailPresentation(+            work: work,+            pulse: pulse ?? RatingPulse(+                notes: work.entries.count,+                up: work.entries.filter { $0.rating == .up }.count,+                down: work.entries.filter { $0.rating == .down }.count),+            lastNotedURLString: lastNotedURLString+                ?? work.entries.max(by: { $0.lastSharedAt < $1.lastSharedAt })?.rawURLString,+            chapterRows: rows)+    }+     static func makeWork(         id: UUID = UUID(),         displayTitle: String = "Test Work",

diff --git a/Asterism/AsterismTests/MarkdownExportModelTests.swift b/Asterism/AsterismTests/MarkdownExportModelTests.swiftnew file mode 100644index 0000000..1c8ba5d--- /dev/null+++ b/Asterism/AsterismTests/MarkdownExportModelTests.swift@@ -0,0 +1,323 @@+import AsterismCore+import Foundation+import Testing+@testable import Asterism++// The markdown export presentation layer (Reqs 1.5, 2.4). Mirrors+// `SettingsBackupModelTests`: the state machine, the staged file, the cleanup on+// dismissal, the stale-file scavenging, and the privacy-safe messages.++@Suite("Markdown export view model")+struct MarkdownExportModelTests {++    // MARK: - Helpers++    private func makeStagingDirectory() -> URL {+        let url = FileManager.default.temporaryDirectory+            .appending(path: "markdown-export-tests-\(UUID().uuidString)")+        try? FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)+        return url+    }++    private func entryInput(+        heading: String = "Chapter 14", note: String = "a good one"+    ) -> EntryExportInput {+        EntryExportInput(+            headingText: heading,+            rawURLString: "https://example.com/c14",+            workTitle: "The Perfect Run",+            workTypeLabel: "novel",+            dateText: "12 May 2026",+            rating: .up,+            note: note)+    }++    private func workInput(title: String = "The Perfect Run") -> WorkExportInput {+        WorkExportInput(+            titleText: title,+            siteName: "Example",+            workURLString: "https://example.com/work",+            genericNotes: "",+            blocks: [entryInput()])+    }++    @MainActor private func makeSUT(+        subject: MarkdownExportModel.Subject,+        stagingDirectory: URL,+        configure: (MockLibraryProvider) -> Void+    ) -> (MarkdownExportModel, MockLibraryProvider) {+        let mock = MockLibraryProvider()+        configure(mock)+        let model = MarkdownExportModel(+            subject: subject,+            library: mock,+            stagingDirectory: stagingDirectory,+            locale: Locale(identifier: "en_AU"))+        return (model, mock)+    }++    // MARK: - Initial state++    @Test("Starts idle with nothing staged")+    @MainActor func initialState() {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, _) = makeSUT(subject: .entry(UUID()), stagingDirectory: dir) { _ in }+        #expect(model.state == .idle)+        #expect(model.exportedFileURL == nil)+        #expect(model.errorMessage == nil)+    }++    // MARK: - Happy path (1.5)++    @Test("Exporting an entry stages a markdown file and moves to sharing")+    @MainActor func entryExportStages() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, mock) = makeSUT(subject: .entry(UUID()), stagingDirectory: dir) { mock in+            mock.entryExportInputResult = .success(entryInput())+        }++        await model.startExport()++        #expect(model.state == .sharing)+        #expect(mock.entryExportInputCallCount == 1)+        guard let url = model.exportedFileURL else {+            Issue.record("Expected a staged file URL")+            return+        }+        #expect(url.pathExtension == "md")+        #expect(url.deletingLastPathComponent().standardizedFileURL == dir.standardizedFileURL)+        #expect(FileManager.default.fileExists(atPath: url.path))+        let contents = (try? String(contentsOf: url, encoding: .utf8)) ?? ""+        #expect(contents == MarkdownExport.renderEntry(entryInput()))+    }++    @Test("The staged filename is the renderer's, from the sanitised title")+    @MainActor func filenameComesFromTheRenderer() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let input = entryInput(heading: "Ch 14: Bees / Wasps")+        let (model, _) = makeSUT(subject: .entry(UUID()), stagingDirectory: dir) { mock in+            mock.entryExportInputResult = .success(input)+        }++        await model.startExport()++        #expect(model.exportedFileURL?.lastPathComponent == MarkdownExport.filename(for: input))+    }++    @Test("Exporting a work stages the per-work document")+    @MainActor func workExportStages() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, mock) = makeSUT(subject: .work(UUID()), stagingDirectory: dir) { mock in+            mock.workExportInputResult = .success(workInput())+        }++        await model.startExport()++        #expect(model.state == .sharing)+        #expect(mock.workExportInputCallCount == 1)+        #expect(mock.entryExportInputCallCount == 0)+        let contents = model.exportedFileURL.flatMap { try? String(contentsOf: $0, encoding: .utf8) }+        #expect(contents == MarkdownExport.renderWork(workInput()))+    }++    /// The locale dependency lives in the input layer (Q17), so the model has to+    /// hand its locale to the read rather than formatting anything itself.+    @Test("The model's locale reaches the input read")+    @MainActor func localeReachesTheRead() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, mock) = makeSUT(subject: .entry(UUID()), stagingDirectory: dir) { mock in+            mock.entryExportInputResult = .success(entryInput())+        }++        await model.startExport()++        #expect(mock.lastExportLocale == Locale(identifier: "en_AU"))+    }++    @Test("Suppresses a duplicate export while one is in flight")+    @MainActor func duplicateSubmissionSuppressed() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, mock) = makeSUT(subject: .entry(UUID()), stagingDirectory: dir) { mock in+            mock.entryExportInputResult = .success(entryInput())+            mock.exportInputDelay = .milliseconds(100)+        }++        async let _ = model.startExport()+        await model.startExport()++        #expect(mock.entryExportInputCallCount == 1)+    }++    // MARK: - Cleanup++    @Test("Completing the share removes the staged file and returns to idle")+    @MainActor func shareCompletionCleansUp() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, _) = makeSUT(subject: .entry(UUID()), stagingDirectory: dir) { mock in+            mock.entryExportInputResult = .success(entryInput())+        }+        await model.startExport()+        let staged = model.exportedFileURL++        model.handleShareCompletion()++        #expect(model.state == .idle)+        #expect(model.exportedFileURL == nil)+        #expect(!FileManager.default.fileExists(atPath: staged?.path ?? ""))+    }++    @Test("Cancelling the share removes the staged file and returns to idle")+    @MainActor func shareCancellationCleansUp() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, _) = makeSUT(subject: .entry(UUID()), stagingDirectory: dir) { mock in+            mock.entryExportInputResult = .success(entryInput())+        }+        await model.startExport()+        let staged = model.exportedFileURL++        model.handleShareCancellation()++        #expect(model.state == .idle)+        #expect(!FileManager.default.fileExists(atPath: staged?.path ?? ""))+    }++    // MARK: - Scavenging++    /// Backup export scavenges by filename prefix; markdown filenames come from+    /// the reader's own titles (Q11), so the staging *directory* is the only+    /// thing that identifies them (Q40).+    @Test("Stale markdown files are scavenged on init and fresh ones are kept")+    @MainActor func scavengesStaleFiles() {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let stale = dir.appending(path: "Old Chapter.md")+        let fresh = dir.appending(path: "New Chapter.md")+        try? Data("stale".utf8).write(to: stale)+        try? Data("fresh".utf8).write(to: fresh)+        try? FileManager.default.setAttributes(+            [.modificationDate: Date().addingTimeInterval(-48 * 3600)],+            ofItemAtPath: stale.path)++        _ = MarkdownExportModel(+            subject: .entry(UUID()), library: MockLibraryProvider(), stagingDirectory: dir)++        #expect(!FileManager.default.fileExists(atPath: stale.path))+        #expect(FileManager.default.fileExists(atPath: fresh.path))+    }++    // MARK: - Failure (privacy-safe)++    @Test("A read failure enters the failed state")+    @MainActor func readFailureFails() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, _) = makeSUT(subject: .entry(UUID()), stagingDirectory: dir) { mock in+            mock.entryExportInputResult = .failure(+                MockLibraryProvider.MockError.simulatedFailure("boom"))+        }++        await model.startExport()++        #expect(model.state == .failed)+        #expect(model.exportedFileURL == nil)+        #expect(model.errorMessage != nil)+    }++    @Test("A vanished record is reported as gone rather than as a generic failure")+    @MainActor func vanishedRecordHasItsOwnMessage() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let id = UUID()+        let (model, _) = makeSUT(subject: .entry(id), stagingDirectory: dir) { mock in+            mock.entryExportInputResult = .failure(+                LibraryRepositoryError.recordNotFound(type: "Entry", id: id))+        }++        await model.startExport()++        #expect(model.state == .failed)+        let message = model.errorMessage ?? ""+        #expect(!message.isEmpty)+        // Privacy: never the identifier, never a path.+        #expect(!message.contains(id.uuidString))+    }++    /// The one hard rule of these messages: nothing the reader wrote and nothing+    /// about the filesystem leaves the model.+    @Test("Failure messages carry no titles, URLs, or paths")+    @MainActor func messagesArePrivacySafe() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, _) = makeSUT(subject: .work(UUID()), stagingDirectory: dir) { mock in+            mock.workExportInputResult = .failure(+                MockLibraryProvider.MockError.simulatedFailure(+                    "https://example.com/secret — The Perfect Run"))+        }++        await model.startExport()++        let message = model.errorMessage ?? ""+        #expect(!message.contains("https://"))+        #expect(!message.contains("file://"))+        #expect(!message.contains("The Perfect Run"))+        #expect(!message.contains("/var"))+        #expect(!message.contains(dir.path))+    }++    @Test("A staging failure fails rather than reporting a share")+    @MainActor func stagingFailureFails() async {+        // A staging directory the model cannot create: a *file* sits where the+        // directory would go.+        let blocked = FileManager.default.temporaryDirectory+            .appending(path: "markdown-export-blocked-\(UUID().uuidString)")+        try? Data("not a directory".utf8).write(to: blocked)+        defer { try? FileManager.default.removeItem(at: blocked) }++        let (model, _) = makeSUT(+            subject: .entry(UUID()),+            stagingDirectory: blocked.appending(path: "MarkdownExports")+        ) { mock in+            mock.entryExportInputResult = .success(entryInput())+        }++        await model.startExport()++        #expect(model.state == .failed)+        #expect(model.exportedFileURL == nil)+    }++    @Test("A retry after a failure can still succeed")+    @MainActor func retryAfterFailure() async {+        let dir = makeStagingDirectory()+        defer { try? FileManager.default.removeItem(at: dir) }+        let (model, mock) = makeSUT(subject: .entry(UUID()), stagingDirectory: dir) { mock in+            mock.entryExportInputResult = .failure(+                MockLibraryProvider.MockError.simulatedFailure("boom"))+        }+        await model.startExport()+        #expect(model.state == .failed)++        mock.entryExportInputResult = .success(entryInput())+        await model.startExport()++        #expect(model.state == .sharing)+        #expect(model.errorMessage == nil)+    }++    // MARK: - Staging location (design: Library/Caches/MarkdownExports)++    @Test("The staging directory sits under Library/Caches/MarkdownExports")+    func stagingDirectoryLocation() {+        let root = URL(filePath: "/tmp/library-root")+        let staging = MarkdownExportModel.stagingDirectory(inRoot: root)+        #expect(staging.path.hasSuffix("Library/Caches/MarkdownExports"))+    }+}

diff --git a/Asterism/AsterismTests/SearchFilterTests.swift b/Asterism/AsterismTests/SearchFilterTests.swiftnew file mode 100644index 0000000..c24d0db--- /dev/null+++ b/Asterism/AsterismTests/SearchFilterTests.swift@@ -0,0 +1,219 @@+import AsterismCore+import Foundation+import Testing+@testable import Asterism++// Search on both tabs (Reqs 3, 4). Pure in-memory filtering (Q19), so the whole+// requirement is testable here without a view.++@Suite("Recent search filter")+struct RecentSearchFilterTests {++    private func group(_ day: Date, _ rows: [RecentPresentationRow]) -> RecentPresentationGroup {+        RecentPresentationGroup(day: day, rows: rows)+    }++    // MARK: - Inactive query (3.5)++    @Test("An empty query returns the groups unchanged")+    func emptyQueryIsInactive() {+        let groups = [group(TestFixtures.fixedDate, [TestFixtures.makeRecentRow()])]+        #expect(RecentSearchFilter(query: "").apply(to: groups) == groups)+        #expect(!RecentSearchFilter(query: "").isActive)+    }++    @Test("A whitespace-only query is inactive")+    func whitespaceQueryIsInactive() {+        let groups = [group(TestFixtures.fixedDate, [TestFixtures.makeRecentRow()])]+        #expect(RecentSearchFilter(query: "   ").apply(to: groups) == groups)+        #expect(!RecentSearchFilter(query: "   ").isActive)+    }++    // MARK: - Fields and folding (3.1, 3.3)++    @Test("Matches note text case-insensitively")+    func matchesNote() {+        let hit = TestFixtures.makeRecentRow(captureTitle: "A", note: "The Perfect Run is good")+        let miss = TestFixtures.makeRecentRow(captureTitle: "B", note: "nothing here")+        let result = RecentSearchFilter(query: "perfect").apply(+            to: [group(TestFixtures.fixedDate, [hit, miss])])+        #expect(result.count == 1)+        #expect(result[0].rows.map(\.id) == [hit.id])+    }++    @Test("Matches the work title diacritic-insensitively")+    func matchesWorkTitleFoldingDiacritics() {+        let hit = TestFixtures.makeRecentRow(+            captureTitle: "A", workDisplayTitle: "Café Chronicles")+        let result = RecentSearchFilter(query: "cafe").apply(+            to: [group(TestFixtures.fixedDate, [hit])])+        #expect(result.first?.rows.map(\.id) == [hit.id])+    }++    @Test("Matches the chapter title")+    func matchesChapterTitle() {+        let hit = TestFixtures.makeRecentRow(captureTitle: "raw", chapterTitle: "Chapter 14")+        let result = RecentSearchFilter(query: "chapter 1").apply(+            to: [group(TestFixtures.fixedDate, [hit])])+        #expect(result.first?.rows.map(\.id) == [hit.id])+    }++    /// Req 3.3: the cleaned capture title stands in for an absent chapter title.+    @Test("Falls back to the cleaned capture title when there is no chapter title")+    func fallsBackToCaptureTitle() {+        let hit = TestFixtures.makeRecentRow(captureTitle: "An Article About Bees")+        let result = RecentSearchFilter(query: "bees").apply(+            to: [group(TestFixtures.fixedDate, [hit])])+        #expect(result.first?.rows.map(\.id) == [hit.id])+    }++    /// "In place of", not "as well as": a row that has a chapter title is+    /// searched on that, and its raw capture title is not a second haystack.+    @Test("A row with a chapter title does not also match on its capture title")+    func captureTitleIsNotSearchedWhenAChapterTitleExists() {+        let row = TestFixtures.makeRecentRow(+            captureTitle: "Bees | SiteName", chapterTitle: "Chapter 14")+        let result = RecentSearchFilter(query: "SiteName").apply(+            to: [group(TestFixtures.fixedDate, [row])])+        #expect(result.isEmpty)+    }++    @Test("The hostname is not a searchable field")+    func hostnameDoesNotMatch() {+        let row = TestFixtures.makeRecentRow(captureTitle: "A", hostname: "royalroad.com")+        let result = RecentSearchFilter(query: "royalroad").apply(+            to: [group(TestFixtures.fixedDate, [row])])+        #expect(result.isEmpty)+    }++    // MARK: - Grouping (3.4)++    @Test("Day groups are preserved and emptied groups are dropped")+    func preservesGroupsAndDropsEmptyOnes() {+        let monday = TestFixtures.fixedDate+        let tuesday = TestFixtures.laterDate+        let hit = TestFixtures.makeRecentRow(captureTitle: "Bees")+        let miss = TestFixtures.makeRecentRow(captureTitle: "Wasps")+        let result = RecentSearchFilter(query: "bees").apply(to: [+            group(monday, [miss]),+            group(tuesday, [hit, miss]),+        ])+        #expect(result.count == 1)+        #expect(result[0].day == tuesday)+        #expect(result[0].rows.map(\.id) == [hit.id])+    }++    @Test("Row order inside a day is preserved")+    func preservesRowOrder() {+        let first = TestFixtures.makeRecentRow(captureTitle: "Bees one")+        let second = TestFixtures.makeRecentRow(captureTitle: "Bees two")+        let result = RecentSearchFilter(query: "bees").apply(+            to: [group(TestFixtures.fixedDate, [first, second])])+        #expect(result.first?.rows.map(\.id) == [first.id, second.id])+    }++    @Test("A query matching nothing yields no groups at all")+    func noMatchesYieldsNoGroups() {+        let result = RecentSearchFilter(query: "zzz").apply(+            to: [group(TestFixtures.fixedDate, [TestFixtures.makeRecentRow(captureTitle: "Bees")])])+        #expect(result.isEmpty)+    }++    // MARK: - Composition with the banner filters (3.2, Q6)++    /// The filter runs over the *already banner-filtered* groups, so the two+    /// conditions AND. Searching the unfiltered set here would surface a row the+    /// banner had excluded.+    @Test("Search narrows within an active banner filter rather than replacing it")+    func composesWithBannerFiltering() {+        let actionableHit = TestFixtures.makeRecentRow(captureTitle: "Bees", isActionable: true)+        let settledHit = TestFixtures.makeRecentRow(captureTitle: "Bees elsewhere")+        let actionableMiss = TestFixtures.makeRecentRow(captureTitle: "Wasps", isActionable: true)+        let all = [group(TestFixtures.fixedDate, [actionableHit, settledHit, actionableMiss])]++        let bannerFiltered = all.compactMap { group -> RecentPresentationGroup? in+            let rows = group.rows.filter(\.isActionable)+            return rows.isEmpty ? nil : RecentPresentationGroup(day: group.day, rows: rows)+        }+        let result = RecentSearchFilter(query: "bees").apply(to: bannerFiltered)++        #expect(result.flatMap(\.rows).map(\.id) == [actionableHit.id])+    }+}++@Suite("Works search filter")+struct WorksSearchFilterTests {++    private func snapshot(+        works: [WorkSnapshot], unattached: [EntrySnapshot] = []+    ) -> WorksSnapshot {+        WorksSnapshot(works: works, unattachedEntries: unattached)+    }++    @Test("An empty query returns the snapshot unchanged")+    func emptyQueryIsInactive() {+        let input = snapshot(+            works: [TestFixtures.makeWork(displayTitle: "A")],+            unattached: [TestFixtures.makeEntry(captureTitle: "loose")])+        #expect(WorksSearchFilter(query: "").apply(to: input) == input)+        #expect(!WorksSearchFilter(query: "").isActive)+    }++    @Test("Matches the display title case- and diacritic-insensitively")+    func matchesDisplayTitle() {+        let hit = TestFixtures.makeWork(displayTitle: "Café Chronicles")+        let miss = TestFixtures.makeWork(displayTitle: "The Perfect Run")+        let result = WorksSearchFilter(query: "cafe chron").apply(+            to: snapshot(works: [hit, miss]))+        #expect(result.works.map(\.id) == [hit.id])+    }++    /// Req 4.1: the list's own ordering survives, empty works still sinking —+    /// the filter only removes, it never reorders.+    @Test("Existing ordering is preserved, including empty works sinking")+    func preservesOrdering() {+        let full = TestFixtures.makeWork(+            displayTitle: "Bee Chronicles", entries: [TestFixtures.makeEntry()])+        let alsoFull = TestFixtures.makeWork(+            displayTitle: "Bees Abroad", entries: [TestFixtures.makeEntry()])+        let empty = TestFixtures.makeWork(displayTitle: "Bee Fragments")+        let result = WorksSearchFilter(query: "bee").apply(+            to: snapshot(works: [full, alsoFull, empty]))+        #expect(result.works.map(\.id) == [full.id, alsoFull.id, empty.id])+    }++    @Test("Generic notes are not a searchable field on Works")+    func genericNotesDoNotMatch() {+        let work = TestFixtures.makeWork(displayTitle: "A", genericNotes: "all about bees")+        let result = WorksSearchFilter(query: "bees").apply(to: snapshot(works: [work]))+        #expect(result.works.isEmpty)+    }++    /// Req 4.2, Q12: the group is hidden outright while a query is active, so an+    /// unattached entry can never surface from a work-title search.+    @Test("The unattached group is hidden while a query is active")+    func hidesUnattachedGroupWhileSearching() {+        let input = snapshot(+            works: [TestFixtures.makeWork(displayTitle: "Bees")],+            unattached: [TestFixtures.makeEntry(captureTitle: "Bees loose note")])+        let result = WorksSearchFilter(query: "bees").apply(to: input)+        #expect(result.works.count == 1)+        #expect(result.unattachedEntries.isEmpty)+    }++    @Test("Clearing the query restores the unattached group")+    func clearingRestoresUnattached() {+        let input = snapshot(+            works: [TestFixtures.makeWork(displayTitle: "Bees")],+            unattached: [TestFixtures.makeEntry(captureTitle: "loose")])+        #expect(WorksSearchFilter(query: "").apply(to: input).unattachedEntries.count == 1)+    }++    @Test("A query matching no work yields an empty works list")+    func noMatches() {+        let result = WorksSearchFilter(query: "zzz").apply(+            to: snapshot(works: [TestFixtures.makeWork(displayTitle: "Bees")]))+        #expect(result.works.isEmpty)+        #expect(result.unattachedEntries.isEmpty)+    }+}

diff --git a/Asterism/AsterismTests/SitesModelTests.swift b/Asterism/AsterismTests/SitesModelTests.swiftnew file mode 100644index 0000000..fee8c24--- /dev/null+++ b/Asterism/AsterismTests/SitesModelTests.swift@@ -0,0 +1,297 @@+import AsterismCore+import Foundation+import Testing+@testable import Asterism++// The Sites settings screen (Req 6). Wording lives in the models, per the house+// convention, so these tests are where the screen's sentences are pinned.++@Suite("Sites list model")+struct SitesListModelTests {++    private func snapshot(+        hostname: String, displayName: String? = nil, mode: SiteMode+    ) -> SiteSnapshot {+        SiteSnapshot.fixture(+            hostname: hostname, displayName: displayName ?? hostname, mode: mode)+    }++    @Test("Load exposes one row per site with its name, hostname, and mode")+    @MainActor func loadExposesRows() async {+        let mock = MockLibraryProvider()+        mock.sitesResult = .success([+            snapshot(hostname: "royalroad.com", displayName: "Royal Road", mode: .taught),+            snapshot(hostname: "news.example", displayName: "News", mode: .articles),+            snapshot(hostname: "unknown.test", mode: .untaught),+        ])+        let model = SitesListModel(library: mock)++        await model.load()++        #expect(model.state == .ready)+        #expect(model.rows.map(\.hostname) == ["royalroad.com", "news.example", "unknown.test"])+        #expect(model.rows.map(\.displayName) == ["Royal Road", "News", "unknown.test"])+        // Distinct, plain-language labels — the reader is choosing what to do+        // next from them.+        #expect(Set(model.rows.map(\.modeLabel)).count == 3)+    }++    /// Q10: the untaught sites are exactly the ones the screen exists to send+    /// the reader to teach, so they are never filtered out.+    @Test("Untaught sites are listed, not hidden")+    @MainActor func untaughtSitesAreListed() async {+        let mock = MockLibraryProvider()+        mock.sitesResult = .success([snapshot(hostname: "new.test", mode: .untaught)])+        let model = SitesListModel(library: mock)++        await model.load()++        #expect(model.rows.count == 1)+    }++    @Test("An empty store reports having no sites rather than an empty screen")+    @MainActor func emptyStore() async {+        let mock = MockLibraryProvider()+        mock.sitesResult = .success([])+        let model = SitesListModel(library: mock)++        await model.load()++        #expect(model.state == .ready)+        #expect(model.rows.isEmpty)+        #expect(!model.emptyMessage.isEmpty)+    }++    @Test("A failed read enters the error state")+    @MainActor func failedRead() async {+        let mock = MockLibraryProvider()+        mock.sitesResult = .failure(MockLibraryProvider.MockError.simulatedFailure("nope"))+        let model = SitesListModel(library: mock)++        await model.load()++        if case .error = model.state {} else { Issue.record("Expected the error state") }+        #expect(model.rows.isEmpty)+    }+}++@Suite("Site detail model")+struct SiteDetailModelTests {++    private func snapshot(+        hostname: String = "royalroad.com", mode: SiteMode+    ) -> SiteSnapshot {+        SiteSnapshot.fixture(hostname: hostname, displayName: "Royal Road", mode: mode)+    }++    /// Built through the planner teach mode uses, not hand-assembled: the count+    /// the prompt shows has to be the one a real projection would produce.+    private func articlesContract(entryCount: Int) -> ArticlesContract {+        let entries = (0..<entryCount).map { index in+            TestFixtures.makeEntry(captureTitle: "Page \(index)", hostname: "royalroad.com")+        }+        return ArticlesContract(+            basis: TeachingBasis(+                siteMode: .taught, hostname: "royalroad.com", patterns: [], entries: [],+                works: []),+            request: ArticlesRequest(junkSuffixRule: nil),+            outcome: ArticlesOutcome(+                plan: TitleProjectionPlanner.planArticles(+                    entries: entries, junkSuffixRule: nil)))+    }++    @MainActor private func makeSUT(+        mode: SiteMode = .taught,+        canReteach: Bool = true+    ) -> (SiteDetailModel, MockLibraryProvider, ReteachRecorder) {+        let mock = MockLibraryProvider()+        let recorder = ReteachRecorder()+        let model = SiteDetailModel(+            site: snapshot(mode: mode),+            library: mock,+            canReteach: canReteach,+            onReteach: { hostname, permits in recorder.record(hostname, permits) },+            onMutation: {})+        return (model, mock, recorder)+    }++    // MARK: - Re-teach (Req 6.2, 6.3)++    @Test("Re-teaching a taught site routes without the articles-conversion flag")+    @MainActor func reteachTaughtSite() {+        let (model, _, recorder) = makeSUT(mode: .taught)++        #expect(model.canReteach)+        #expect(model.reteachUnavailableMessage == nil)+        model.reteach()++        #expect(recorder.hostnames == ["royalroad.com"])+        #expect(recorder.permits == [false])+    }++    /// Decision 3: the Sites screen is the **only** route allowed to convert an+    /// articles site back, so it is the only one that sets the flag.+    @Test("Re-teaching an articles site carries the conversion flag")+    @MainActor func reteachArticlesSite() {+        let (model, _, recorder) = makeSUT(mode: .articles)++        model.reteach()++        #expect(recorder.permits == [true])+    }++    /// The composed surface is entered from an Entry, so a site with nothing+    /// captured from it has nothing to teach against — and the screen says so+    /// rather than offering a button that does nothing.+    @Test("A site with no entries cannot be re-taught and explains why")+    @MainActor func reteachUnavailableWithoutEntries() {+        let (model, _, recorder) = makeSUT(mode: .untaught, canReteach: false)++        #expect(!model.canReteach)+        #expect(model.reteachUnavailableMessage != nil)+        model.reteach()++        #expect(recorder.hostnames.isEmpty)+    }++    // MARK: - Articles switch (Req 6.3, 6.4)++    @Test("A taught site offers the articles switch; an articles site does not")+    @MainActor func articlesSwitchAvailability() {+        #expect(makeSUT(mode: .taught).0.canSwitchToArticles)+        #expect(makeSUT(mode: .untaught).0.canSwitchToArticles)+        #expect(!makeSUT(mode: .articles).0.canSwitchToArticles)+    }++    @Test("Requesting the switch projects it and names the entry count")+    @MainActor func requestArticlesProjects() async {+        let (model, mock, _) = makeSUT(mode: .taught)+        mock.projectArticlesResult = .success(articlesContract(entryCount: 3))++        await model.requestArticlesSwitch()++        #expect(mock.projectArticlesCallCount == 1)+        #expect(model.articlesPrompt?.entryCount == 3)+        #expect(model.articlesPrompt?.message.contains("3") == true)+        #expect(mock.commitArticlesCallCount == 0)+    }++    /// Req 6.4: the same contracts teach mode uses, so the retroactive semantics+    /// are identical by construction rather than by re-implementation.+    @Test("Confirming commits the projected contract and reports the mutation")+    @MainActor func confirmArticlesCommits() async throws {+        let mock = MockLibraryProvider()+        let mutations = MutationRecorder()+        let model = SiteDetailModel(+            site: snapshot(mode: .taught), library: mock, canReteach: true,+            onReteach: { _, _ in }, onMutation: { mutations.record() })+        let contract = articlesContract(entryCount: 2)+        mock.projectArticlesResult = .success(contract)+        mock.commitArticlesResult = .success(.committed)++        await model.requestArticlesSwitch()+        let prompt = try #require(model.articlesPrompt)+        await model.confirmArticlesSwitch(prompt)++        #expect(mock.commitArticlesCallCount == 1)+        #expect(mock.lastCommittedArticlesContract == contract)+        #expect(model.didSwitchToArticles)+        #expect(mutations.count == 1)+        #expect(model.articlesPrompt == nil)+    }++    @Test("Cancelling the switch writes nothing")+    @MainActor func cancelArticles() async {+        let (model, mock, _) = makeSUT(mode: .taught)+        mock.projectArticlesResult = .success(articlesContract(entryCount: 1))+        await model.requestArticlesSwitch()++        model.cancelArticlesSwitch()++        #expect(model.articlesPrompt == nil)+        #expect(mock.commitArticlesCallCount == 0)+    }++    /// Regression, found by `SitesSettingsUITests`: the confirm button did+    /// nothing at all on the real screen. SwiftUI runs a `confirmationDialog`'s+    /// `isPresented` setter — the dismissal, which is `cancelArticlesSwitch()` —+    /// *before* the tapped button's action, and the commit used to read the+    /// contract back off the model, where the dismissal had already cleared it.+    /// The tests above never saw it because they call the two methods in the+    /// order a reader would expect rather than the order SwiftUI uses.+    @Test("A dismissal running before the confirm action still commits (Q101)")+    @MainActor func confirmSurvivesTheDismissalRunningFirst() async throws {+        let (model, mock, _) = makeSUT(mode: .taught)+        let contract = articlesContract(entryCount: 2)+        mock.projectArticlesResult = .success(contract)+        mock.commitArticlesResult = .success(.committed)+        await model.requestArticlesSwitch()+        let prompt = try #require(model.articlesPrompt)++        // SwiftUI's order, not the reader's.+        model.cancelArticlesSwitch()+        await model.confirmArticlesSwitch(prompt)++        #expect(mock.commitArticlesCallCount == 1)+        #expect(mock.lastCommittedArticlesContract == contract)+        #expect(model.didSwitchToArticles)+    }++    @Test("A refreshed commit re-presents the fresh counts instead of switching")+    @MainActor func refreshedRepresents() async throws {+        let (model, mock, _) = makeSUT(mode: .taught)+        mock.projectArticlesResult = .success(articlesContract(entryCount: 1))+        mock.commitArticlesResult = .success(.refreshed(articlesContract(entryCount: 5)))++        await model.requestArticlesSwitch()+        let prompt = try #require(model.articlesPrompt)+        await model.confirmArticlesSwitch(prompt)++        #expect(!model.didSwitchToArticles)+        #expect(model.articlesPrompt?.entryCount == 5)+        #expect(model.errorMessage != nil)+    }++    @Test("An invalidated commit reports the repository's reason")+    @MainActor func invalidatedReportsReason() async throws {+        let (model, mock, _) = makeSUT(mode: .taught)+        mock.projectArticlesResult = .success(articlesContract(entryCount: 1))+        mock.commitArticlesResult = .success(.invalidated(reason: "This site is quarantined."))++        await model.requestArticlesSwitch()+        let prompt = try #require(model.articlesPrompt)+        await model.confirmArticlesSwitch(prompt)++        #expect(!model.didSwitchToArticles)+        #expect(model.errorMessage == "This site is quarantined.")+    }++    @Test("A projection failure is reported without a commit")+    @MainActor func projectionFailure() async {+        let (model, mock, _) = makeSUT(mode: .taught)+        mock.projectArticlesResult = .failure(+            MockLibraryProvider.MockError.simulatedFailure("nope"))++        await model.requestArticlesSwitch()++        #expect(model.articlesPrompt == nil)+        #expect(model.errorMessage != nil)+        #expect(mock.commitArticlesCallCount == 0)+    }+}++/// Records the re-teach routes a site detail hands back to its host.+final class ReteachRecorder: @unchecked Sendable {+    private(set) var hostnames: [String] = []+    private(set) var permits: [Bool] = []++    func record(_ hostname: String, _ permitsArticlesConversion: Bool) {+        hostnames.append(hostname)+        permits.append(permitsArticlesConversion)+    }+}++final class MutationRecorder: @unchecked Sendable {+    private(set) var count = 0+    func record() { count += 1 }+}

diff --git a/Asterism/AsterismTests/WorkDetailModelTests.swift b/Asterism/AsterismTests/WorkDetailModelTests.swiftindex 1cbbc53..b64a743 100644--- a/Asterism/AsterismTests/WorkDetailModelTests.swift+++ b/Asterism/AsterismTests/WorkDetailModelTests.swift@@ -10,7 +10,8 @@ struct WorkDetailModelTests {      @MainActor private func makeSUT(         work: WorkSnapshot? = nil,-        updateResult: Result<LibraryWriteOutcome, Error> = .success(.committed)+        updateResult: Result<LibraryWriteOutcome, Error> = .success(.committed),+        detail: WorkDetailPresentation? = nil     ) -> (WorkDetailModel, MockLibraryProvider, CallbackTracker) {         let mock = MockLibraryProvider()         let workSnapshot = work ?? TestFixtures.makeWork(@@ -20,6 +21,8 @@ struct WorkDetailModelTests {             genericNotes: "some notes"         )         mock.workResult = .success(workSnapshot)+        mock.workDetailResult = .success(+            detail ?? TestFixtures.makeWorkDetail(work: workSnapshot))         mock.updateWorkResult = updateResult          let tracker = CallbackTracker()@@ -149,4 +152,417 @@ struct WorkDetailModelTests {         #expect(mock.lastUpdateWorkBasis?.lastParsedTitle == work.lastParsedTitle)         #expect(mock.lastUpdateWorkBasis?.titleProvenance == work.titleProvenance)     }++    // MARK: - The §6 read (Reqs 5.1–5.4)++    /// One read, not two: the pulse, the last-noted URL and the chapter rows all+    /// come from `workDetail(id:)`, so they describe one moment of the store.+    @MainActor @Test("Load adopts the workDetail read and exposes its three parts")+    func loadAdoptsWorkDetail() async {+        let entryA = TestFixtures.makeEntry(+            captureTitle: "Ch 1", rating: .up, lastSharedAt: TestFixtures.earlierDate)+        let entryB = TestFixtures.makeEntry(+            captureTitle: "Ch 2", rating: .down, lastSharedAt: TestFixtures.laterDate)+        let work = TestFixtures.makeWork(displayTitle: "Serial", entries: [entryB, entryA])+        let (model, mock, _) = makeSUT(work: work)++        await model.load()++        #expect(mock.workDetailCallCount == 1)+        #expect(mock.workCallCount == 0)+        #expect(model.work == work)+        #expect(model.pulse == RatingPulse(notes: 2, up: 1, down: 1))+        #expect(model.lastNotedURLString == entryB.rawURLString)+        #expect(model.chapterRows.map(\.id) == [entryB.id, entryA.id])+    }++    /// Req 5.3: no entries, no action — the model reports nothing to open+    /// rather than the screen deciding what an empty work means.+    @MainActor @Test("An empty work exposes no last-noted URL and an all-zero pulse")+    func emptyWorkHasNoLastNotedURL() async {+        let work = TestFixtures.makeWork(displayTitle: "Nothing yet")+        let (model, _, _) = makeSUT(work: work)++        await model.load()++        #expect(model.lastNotedURLString == nil)+        #expect(model.pulse == RatingPulse(notes: 0, up: 0, down: 0))+        #expect(model.chapterRows.isEmpty)+    }++    @MainActor @Test("A failed read leaves the screen in the error state")+    func failedDetailReadErrors() async {+        let mock = MockLibraryProvider()+        mock.workDetailResult = .failure(+            MockLibraryProvider.MockError.simulatedFailure("read failed"))+        let model = WorkDetailModel(workID: UUID(), library: mock, onMutation: {})++        await model.load()++        if case .error = model.state {} else { Issue.record("Expected the error state") }+        #expect(model.work == nil)+    }++    // MARK: - Deletion (Req 7.1, 7.2)++    @MainActor private func contract(+        work: WorkSnapshot,+        entryGroupIDs: Set<UUID> = [],+        tornEntryVariants: [UUID: [AuthoredVariant<EntryAuthoredContent>]] = [:]+    ) -> WorkDeletionContract {+        WorkDeletionContract(+            basis: WorkEditBasis(work: work),+            workID: work.id,+            entryGroupIDs: entryGroupIDs,+            tornEntryVariants: tornEntryVariants)+    }++    private func variant(note: String) -> AuthoredVariant<EntryAuthoredContent> {+        AuthoredVariant(+            content: EntryAuthoredContent(note: note, rating: .up),+            firstCapturedAt: TestFixtures.fixedDate)+    }++    /// Answers the dialog the way its `presenting:` closure does: with the+    /// prompt the dialog was rendered from.+    @MainActor private func choose(+        _ disposition: WorkDeletionDisposition, on model: WorkDetailModel+    ) async {+        guard let prompt = model.deletionPrompt else {+            Issue.record("Expected a deletion prompt")+            return+        }+        await model.chooseDeletion(prompt, disposition: disposition)+    }++    /// Req 7.1: the prompt is projected first, so the counts it names are the+    /// store's rather than the loaded snapshot's.+    @MainActor @Test("Requesting deletion projects the contract and raises the prompt")+    func requestDeleteProjects() async {+        let work = TestFixtures.makeWork(displayTitle: "Doomed")+        let (model, mock, _) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(+            contract(work: work, entryGroupIDs: [UUID(), UUID()]))+        await model.load()++        await model.requestDelete()++        #expect(mock.projectWorkDeletionCallCount == 1)+        #expect(model.deletionPrompt?.entryCount == 2)+        #expect(model.deleteDisclosure == nil)+    }++    @MainActor @Test("Cancelling the prompt writes nothing")+    func cancelDeleteWritesNothing() async {+        let work = TestFixtures.makeWork()+        let (model, mock, _) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(contract(work: work))+        await model.load()+        await model.requestDelete()++        model.cancelDelete()++        #expect(model.deletionPrompt == nil)+        #expect(mock.commitWorkDeletionCallCount == 0)+    }++    @MainActor @Test("Choosing delete-entries commits that disposition and dismisses")+    func deleteEntriesCommits() async {+        let work = TestFixtures.makeWork()+        let (model, mock, tracker) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(contract(work: work, entryGroupIDs: [UUID()]))+        await model.load()+        await model.requestDelete()++        await choose(.deleteEntries, on: model)++        #expect(mock.commitWorkDeletionCallCount == 1)+        #expect(mock.lastWorkDeletionDisposition == .deleteEntries)+        #expect(mock.lastWorkDeletionDisclosedVariants == .some(nil))+        #expect(model.isDeleted)+        #expect(tracker.mutationCount == 1)+        #expect(model.deletionPrompt == nil)+    }++    @MainActor @Test("Choosing detach commits the detach disposition")+    func detachCommits() async {+        let work = TestFixtures.makeWork()+        let (model, mock, _) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(contract(work: work, entryGroupIDs: [UUID()]))+        await model.load()+        await model.requestDelete()++        await choose(.detachEntries, on: model)++        #expect(mock.lastWorkDeletionDisposition == .detachEntries)+        #expect(model.isDeleted)+    }++    /// Req 7.2: the disclosure gate applies to **both** dispositions — deleting+    /// destroys authored variants and detaching authors over them.+    @MainActor @Test(+        "A torn entry group routes both dispositions through the disclosure first",+        arguments: [WorkDeletionDisposition.deleteEntries, .detachEntries])+    func tornGroupDisclosesFirst(_ disposition: WorkDeletionDisposition) async {+        let work = TestFixtures.makeWork()+        let groupID = UUID()+        let (model, mock, _) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(+            contract(+                work: work, entryGroupIDs: [groupID],+                tornEntryVariants: [groupID: [variant(note: "one"), variant(note: "two")]]))+        await model.load()+        await model.requestDelete()++        await choose(disposition, on: model)++        #expect(mock.commitWorkDeletionCallCount == 0)+        #expect(model.deleteDisclosure?.disposition == disposition)+        #expect(model.deleteDisclosure?.lines.count == 2)+        #expect(!model.isDeleted)+    }++    /// The disclosure is a **parameter**, mirroring entry deletion: SwiftUI+    /// clears an alert's binding before running its action, so a commit that+    /// re-read the property would find it nil and disclose nothing.+    @MainActor @Test("Confirming the disclosure hands the commit exactly what was shown")+    func confirmingDisclosurePassesTheShownVariants() async {+        let work = TestFixtures.makeWork()+        let groupID = UUID()+        let variants = [variant(note: "one"), variant(note: "two")]+        let (model, mock, _) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(+            contract(+                work: work, entryGroupIDs: [groupID], tornEntryVariants: [groupID: variants]))+        await model.load()+        await model.requestDelete()+        await choose(.deleteEntries, on: model)+        guard let disclosure = model.deleteDisclosure else {+            Issue.record("Expected a disclosure")+            return+        }++        await model.confirmDeletion(disclosure)++        #expect(mock.lastWorkDeletionDisclosedVariants == .some(Set(variants.map(\.id))))+        #expect(model.isDeleted)+    }++    // MARK: - The dismissal-before-action order (the real UI's sequence)++    /// The order SwiftUI actually uses, and the bug it caused: tapping a+    /// confirmation-dialog button dismisses the dialog first — running the+    /// `isPresented` setter, which is `cancelDelete()` — and only then runs the+    /// button's action. A `chooseDeletion` that re-read model state found it+    /// already cleared and deleted nothing, silently.+    @MainActor @Test("A dialog button still commits after the dismissal has cleared the model")+    func dialogButtonCommitsAfterTheDismissal() async {+        let work = TestFixtures.makeWork()+        let (model, mock, tracker) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(contract(work: work, entryGroupIDs: [UUID()]))+        await model.load()+        await model.requestDelete()+        guard let prompt = model.deletionPrompt else {+            Issue.record("Expected a deletion prompt")+            return+        }++        // SwiftUI's order: the dialog goes away, then the button acts.+        model.cancelDelete()+        await model.chooseDeletion(prompt, disposition: .deleteEntries)++        #expect(mock.commitWorkDeletionCallCount == 1)+        #expect(mock.lastWorkDeletionDisposition == .deleteEntries)+        #expect(model.isDeleted)+        #expect(tracker.mutationCount == 1)+    }++    /// The same order one level down, over both alerts in sequence: the dialog+    /// dismisses before it raises the disclosure, and the disclosure dismisses+    /// before its Continue commits.+    @MainActor @Test("A disclosure button still commits after the alert's dismissal")+    func disclosureButtonCommitsAfterTheDismissal() async {+        let work = TestFixtures.makeWork()+        let groupID = UUID()+        let variants = [variant(note: "one"), variant(note: "two")]+        let (model, mock, _) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(+            contract(+                work: work, entryGroupIDs: [groupID], tornEntryVariants: [groupID: variants]))+        await model.load()+        await model.requestDelete()+        guard let prompt = model.deletionPrompt else {+            Issue.record("Expected a deletion prompt")+            return+        }++        model.cancelDelete()+        await model.chooseDeletion(prompt, disposition: .deleteEntries)+        guard let disclosure = model.deleteDisclosure else {+            Issue.record("Expected a disclosure")+            return+        }++        model.cancelDeletionDisclosure()+        await model.confirmDeletion(disclosure)++        #expect(mock.commitWorkDeletionCallCount == 1)+        #expect(mock.lastWorkDeletionDisclosedVariants == .some(Set(variants.map(\.id))))+        #expect(model.isDeleted)+    }++    // MARK: - Deletion outcomes++    /// Q28: the prompt named an entry count, so a changed group set re-presents+    /// rather than deleting more than the reader confirmed.+    @MainActor @Test("A refreshed commit re-presents the prompt with the fresh counts")+    func refreshedRepresentsThePrompt() async {+        let work = TestFixtures.makeWork()+        let fresh = contract(work: work, entryGroupIDs: [UUID(), UUID(), UUID()])+        let (model, mock, tracker) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(contract(work: work, entryGroupIDs: [UUID()]))+        mock.commitWorkDeletionResult = .success(.refreshed(fresh))+        await model.load()+        await model.requestDelete()++        await choose(.deleteEntries, on: model)++        #expect(!model.isDeleted)+        #expect(model.deletionPrompt?.entryCount == 3)+        #expect(model.errorMessage != nil)+        #expect(tracker.mutationCount == 0)+    }++    /// A stale disclosure means a copy arrived while the alert was up: the+    /// contract is re-projected and the reader answers over the current copies.+    @MainActor @Test("A stale disclosure re-projects rather than deleting")+    func staleDisclosureReprojects() async {+        let work = TestFixtures.makeWork()+        let groupID = UUID()+        let (model, mock, _) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(+            contract(+                work: work, entryGroupIDs: [groupID],+                tornEntryVariants: [groupID: [variant(note: "one")]]))+        mock.commitWorkDeletionResult = .success(+            .conflict(.disclosureStale(recordID: work.id, variants: [])))+        await model.load()+        await model.requestDelete()+        await choose(.deleteEntries, on: model)+        guard let disclosure = model.deleteDisclosure else {+            Issue.record("Expected a disclosure")+            return+        }++        await model.confirmDeletion(disclosure)++        #expect(!model.isDeleted)+        #expect(model.errorMessage != nil)+        // Re-projected: the first projection was the request, the second the+        // re-presentation.+        #expect(mock.projectWorkDeletionCallCount == 2)+    }++    @MainActor @Test("A conflict reaches the conflict sink rather than being swallowed")+    func conflictReachesTheSink() async {+        let work = TestFixtures.makeWork()+        let mock = MockLibraryProvider()+        mock.workDetailResult = .success(TestFixtures.makeWorkDetail(work: work))+        mock.projectWorkDeletionResult = .success(+            WorkDeletionContract(+                basis: WorkEditBasis(work: work), workID: work.id,+                entryGroupIDs: [], tornEntryVariants: [:]))+        mock.commitWorkDeletionResult = .success(+            .conflict(.torn(recordID: work.id, variants: [])))+        let sink = ConflictSink()+        let model = WorkDetailModel(+            workID: work.id, library: mock, onMutation: {},+            onConflict: { conflict in sink.record(conflict) })+        await model.load()+        await model.requestDelete()++        await choose(.deleteEntries, on: model)++        #expect(sink.count == 1)+        #expect(!model.isDeleted)+    }++    @MainActor @Test("An invalidated commit reports the reason and keeps the screen")+    func invalidatedReportsTheReason() async {+        let work = TestFixtures.makeWork()+        let (model, mock, _) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(contract(work: work))+        mock.commitWorkDeletionResult = .success(+            .invalidated(reason: "The library check refused this deletion."))+        await model.load()++        await model.requestDelete()+        await choose(.deleteEntries, on: model)++        #expect(!model.isDeleted)+        #expect(model.errorMessage == "The library check refused this deletion.")+    }++    /// A projection that fails raises no prompt, so there is nothing to confirm+    /// and nothing to commit — the reader is told instead.+    @MainActor @Test("A projection failure is reported without a commit")+    func projectionFailureReportsWithoutCommitting() async {+        let work = TestFixtures.makeWork()+        let (model, mock, _) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .failure(+            MockLibraryProvider.MockError.simulatedFailure("projection failed"))+        await model.load()++        await model.requestDelete()++        #expect(model.deletionPrompt == nil)+        #expect(model.errorMessage != nil)+        #expect(mock.commitWorkDeletionCallCount == 0)+    }++    /// Deletion idempotence at the screen: the work was already gone by the time+    /// the commit ran, the repository maps that to `.committed`, and the screen+    /// leaves rather than reporting a failure over something already true.+    @MainActor @Test("An already-gone work commits as deleted and leaves the screen")+    func goneWorkCommitsAsDeleted() async {+        let work = TestFixtures.makeWork()+        let (model, mock, tracker) = makeSUT(work: work)+        mock.projectWorkDeletionResult = .success(contract(work: work, entryGroupIDs: [UUID()]))+        mock.commitWorkDeletionResult = .success(.committed)+        await model.load()+        await model.requestDelete()++        await choose(.deleteEntries, on: model)++        #expect(model.isDeleted)+        #expect(model.errorMessage == nil)+        #expect(model.state == .ready)+        #expect(tracker.mutationCount == 1)+    }++    // MARK: - The Edit-details split (Q20)++    /// The sheet is a *view* split: the model's draft/commit surface is+    /// unchanged, so the Work-URL machinery it hosts still round-trips.+    @MainActor @Test("The Edit-details surface keeps the save and Work-URL paths intact")+    func editDetailsSplitKeepsTheModelSurface() async {+        let work = TestFixtures.makeWork(displayTitle: "Serial")+        let (model, mock, tracker) = makeSUT(work: work)+        await model.load()++        model.draftTitle = "Renamed"+        await model.save()++        #expect(mock.updateWorkCallCount == 1)+        #expect(tracker.mutationCount == 1)+        // Still the same reload path, and still the §6 read.+        #expect(mock.workDetailCallCount == 2)+    }+}++/// Records the conflicts a model hands off, from the `@Sendable` closure the+/// model takes.+final class ConflictSink: @unchecked Sendable {+    private(set) var count = 0+    func record(_ conflict: WriteConflict) { count += 1 } }

diff --git a/Asterism/AsterismUITests/AccessibilityJourneyUITests.swift b/Asterism/AsterismUITests/AccessibilityJourneyUITests.swiftindex 3c0ad3a..e42d333 100644--- a/Asterism/AsterismUITests/AccessibilityJourneyUITests.swift+++ b/Asterism/AsterismUITests/AccessibilityJourneyUITests.swift@@ -49,12 +49,22 @@ final class AccessibilityJourneyUITests: XCTestCase {         XCTAssertTrue(workTitle.waitForExistence(timeout: 10))         workTitle.tap() -        let assignedEntry = app.staticTexts.matching(identifier: "work-detail-entry").firstMatch+        let assignedEntry = app.descendants(matching: .any)+            .matching(identifier: "work-detail-entry").firstMatch         scrollToElement(assignedEntry)         XCTAssertTrue(assignedEntry.waitForExistence(timeout: 10))++        // Save is a toolbar confirmation that appears only while a draft+        // differs from the loaded snapshot (Req 5.6's in-place edits), so the+        // journey has to dirty the title before it can assert the control.+        let titleField = app.textFields["work-detail-title-field"]+        scrollToElement(titleField)+        XCTAssertTrue(titleField.waitForExistence(timeout: 10), "Editable work title should exist")+        titleField.tap()+        titleField.typeText("!")         let saveWork = app.buttons["work-detail-save-button"]-        scrollToElement(saveWork)-        assertContentControl(saveWork, named: "Save Work")+        XCTAssertTrue(saveWork.waitForExistence(timeout: 10), "Save should appear once the title differs")+        assertSystemControl(saveWork, named: "Save Work")     }      @MainActor@@ -166,6 +176,98 @@ final class AccessibilityJourneyUITests: XCTestCase {         assertSystemControl(newWork, named: "New Work")     } +    // MARK: - Constellation visual pass (Reqs 8–11)++    /// The Works tab and Work detail in dark, walked through the surfaces the+    /// Constellation adoption restructured most: the carded work rows, the+    /// unattached-notes header (which has to stay a *static text* element, so a+    /// section header rendered as a container would fail here), and the §6+    /// rating-pulse cards. Identifiers are unchanged by the visual pass, and+    /// this is what says so.+    @MainActor+    func testWorksTabAppearanceJourneyInDark() {+        launchSeeded(extraArguments: ["-AppleInterfaceStyle", "Dark"])+        walkWorksAppearanceJourney(named: "dark")+    }++    /// The same journey in light — requirement 8.2's "no screen renders+    /// dark-variant tokens in light mode" has no pixel assertion behind it, but+    /// a token that failed to resolve would take the surface's contents with it,+    /// and this journey would stop finding them.+    @MainActor+    func testWorksTabAppearanceJourneyInLight() {+        launchSeeded(extraArguments: ["-AppleInterfaceStyle", "Light"])+        walkWorksAppearanceJourney(named: "light")+    }++    /// Requirement 11.1's Reduce Transparency fallback, as far as a simulator+    /// UI test can reach it.+    ///+    /// **The setting itself is not reachable from here** (Q44): neither the+    /// `-UIAccessibilityReduceTransparency YES` launch argument this suite has+    /// always passed nor writing `com.apple.Accessibility` defaults into the+    /// booted device changes what `accessibilityReduceTransparency` reports —+    /// both were measured against the rendered pixels and the row kept its+    /// material either way. So this journey pins what it can: with the flag set+    /// the restructured surfaces are all still reachable under their unchanged+    /// identifiers. Whether the opaque fill *replaces* the material rather than+    /// layering under it is settled in `ConstellationCard` and+    /// `ConstellationSheetSurface`, where the branch has no fall-through.+    @MainActor+    func testReduceTransparencyJourneyKeepsRestructuredSurfacesReachable() {+        launchSeeded(+            extraArguments: [+                "-AppleInterfaceStyle", "Dark",+                "-UIAccessibilityReduceTransparency", "YES",+            ]+        )++        XCTAssertTrue(+            app.collectionViews["recent-list"].waitForExistence(timeout: 30),+            "Recent's carded rows should render under Reduce Transparency")+        assertContentControl(app.buttons["actionable-banner"], named: "Actionable banner")+        assertContentControl(app.buttons["teach-pill"], named: "Teach pill")++        openSeededEntry()+        let update = app.buttons["entry-detail-update-button"]+        scrollToElement(update)+        assertContentControl(update, named: "Update under Reduce Transparency")+    }++    private func walkWorksAppearanceJourney(named appearance: String) {+        let works = app.tabBars.buttons["Works"]+        XCTAssertTrue(works.waitForExistence(timeout: 30), "Works tab missing in \(appearance)")+        works.tap()++        XCTAssertTrue(+            app.collectionViews["works-list"].waitForExistence(timeout: 10),+            "Works list missing in \(appearance)")+        XCTAssertTrue(+            app.staticTexts["unattached-section-header"].waitForExistence(timeout: 10),+            "The unattached-notes header must stay a static-text element in \(appearance)")++        let workRow = app.buttons["Open Work Integration Work from integration.test"]+        assertContentControl(workRow, named: "Work row in \(appearance)")+        workRow.tap()++        // Work detail's §6 shape: the three rating-pulse cards.+        for identifier in [+            "work-detail-pulse-notes", "work-detail-pulse-up", "work-detail-pulse-down",+        ] {+            // `.any`, because a pulse card combines its count and its label into+            // one element — which XCUI reports as an "other", not a static text.+            let card = app.descendants(matching: .any).matching(identifier: identifier).firstMatch+            scrollToElement(card)+            XCTAssertTrue(+                card.waitForExistence(timeout: 10),+                "\(identifier) missing in \(appearance)")+        }++        let menu = app.buttons["work-detail-menu"]+        scrollToElement(menu)+        assertSystemControl(menu, named: "Work actions menu in \(appearance)")+    }+     private func openSeededEntry() {         let chapter = app.buttons["Open entry Integration Work :: Integration Chapter from integration.test"]         XCTAssertTrue(chapter.waitForExistence(timeout: 30))

diff --git a/Asterism/AsterismUITests/ComposedSurfaceUITests.swift b/Asterism/AsterismUITests/ComposedSurfaceUITests.swiftindex a9080a8..79cb5b8 100644--- a/Asterism/AsterismUITests/ComposedSurfaceUITests.swift+++ b/Asterism/AsterismUITests/ComposedSurfaceUITests.swift@@ -361,9 +361,18 @@ final class ComposedSurfaceUITests: XCTestCase {         require(work, "The seeded taught Work should appear in Works", timeout: 20)         work.tap() -        // Work detail is a Form (lazy List); scroll the URL Identity section in.+        require(any("work-detail-pulse"), "Work detail opens on the seeded Work", timeout: 20)++        // Req 5.5 and Q20: §6's layout has no home for the URL-identity+        // machinery, so it moved behind the toolbar menu's Edit details sheet.+        // `dialogButton` because SwiftUI publishes a menu's buttons twice.+        require(app.dialogButton("work-detail-menu"), "Work detail carries the actions menu").tap()+        require(app.dialogButton("work-detail-edit-details-button"), "The menu opens").tap()+        require(any("work-detail-edit-details"), "Edit details is the route to URL identity")++        // Edit details is a Form (lazy); scroll the URL Identity section in.         scrollAndTap(app.buttons["work-detail-review-url-identity"],-                     "Work detail presents Review URL identity for a Work with URL identity")+                     "Edit details presents Review URL identity for a Work with URL identity")          scrollAndTap(app.buttons["review-recalculate-button"],                      "The review offers Recalculate from the split/conflict states")

diff --git a/Asterism/AsterismUITests/DuplicateResolutionUITests.swift b/Asterism/AsterismUITests/DuplicateResolutionUITests.swiftindex d80f2a5..0391e81 100644--- a/Asterism/AsterismUITests/DuplicateResolutionUITests.swift+++ b/Asterism/AsterismUITests/DuplicateResolutionUITests.swift@@ -54,6 +54,20 @@ final class DuplicateResolutionUITests: XCTestCase {         }     } +    /// Opens Work detail's toolbar menu, which is where Req 5.5 put Merge — it+    /// is no longer a control in the screen body, so a scroll cannot reach it.+    /// `dialogButton` because SwiftUI publishes a menu's buttons twice, nested+    /// inside a container carrying the same identifier.+    private func openWorkActionsMenu(file: StaticString = #filePath, line: UInt = #line) {+        require(+            any("work-detail-pulse"), "Work detail is on screen", timeout: 20,+            file: file, line: line)+        require(+            app.dialogButton("work-detail-menu"), "Work detail carries the actions menu",+            file: file, line: line+        ).tap()+    }+     private func waitForDisappearance(         _ element: XCUIElement, _ message: String, timeout: TimeInterval = 30,         file: StaticString = #filePath, line: UInt = #line@@ -155,9 +169,10 @@ final class DuplicateResolutionUITests: XCTestCase {          // And it is a route, not a label.         elsewhere.tap()-        let merge = app.buttons["work-detail-merge-button"]-        scrollTo(merge)-        require(merge, "Tapping it reaches the Merge flow the set needs")+        openWorkActionsMenu()+        require(+            app.dialogButton("work-detail-merge-button"),+            "Tapping it reaches the Merge flow the set needs")     }      // MARK: - Torn group: read-only detail and the disclosure delete (Req 2.8)@@ -255,9 +270,10 @@ final class DuplicateResolutionUITests: XCTestCase {         XCTAssertEqual(pill.label, "Resolve duplicate copies of Twinned Serial")          pill.tap()-        let merge = app.buttons["work-detail-merge-button"]-        scrollTo(merge)-        require(merge, "The pill routes to the Merge flow rather than the resolution sheet")+        openWorkActionsMenu()+        require(+            app.dialogButton("work-detail-merge-button"),+            "The pill routes to the Merge flow rather than the resolution sheet")         XCTAssertFalse(             any("duplicate-resolution-sheet").exists,             "Q30: a divergent Work set with no torn member is a Merge, not the sheet")

diff --git a/Asterism/AsterismUITests/SearchUITests.swift b/Asterism/AsterismUITests/SearchUITests.swiftnew file mode 100644index 0000000..e14a1c5--- /dev/null+++ b/Asterism/AsterismUITests/SearchUITests.swift@@ -0,0 +1,182 @@+import XCTest++/// Search on Recent and Works (Reqs 3, 4), driven from app launch.+///+/// The filters themselves are pure structs with their own unit tests; what only+/// a journey can prove is that the field is reachable, that typing into it+/// narrows the list the reader is looking at, and that a query with nothing+/// behind it produces the empty state rather than a blank list (3.4, 4.3).+///+/// `seeded-composed` is the fixture with a taught Work in it: two `id.test`+/// entries under the Work "Real Work", plus one untaught `composed.test` entry+/// captured as `TtH - Story - Real Title`.+final class SearchUITests: XCTestCase {+    let app = XCUIApplication()++    override func setUp() {+        continueAfterFailure = false+        XCUIDevice.shared.orientation = .portrait+        terminateAndWaitForExit(app)+    }++    override func tearDown() {+        terminateAndWaitForExit(app)+    }++    // MARK: - Helpers++    private func launch(_ scenario: String) {+        app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = scenario+        app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString+        app.launch()+    }++    private var recentRows: XCUIElementQuery {+        app.elements(withIdentifierPrefix: "recent-entry-")+    }++    private var workRows: XCUIElementQuery {+        app.elements(withIdentifierPrefix: "work-row-")+    }++    /// The search field lives in the navigation bar, which iOS may present+    /// collapsed until the list is pulled down.+    @discardableResult+    private func searchField(+        file: StaticString = #filePath, line: UInt = #line+    ) -> XCUIElement {+        let field = app.searchFields.firstMatch+        if !field.waitForExistence(timeout: 5) {+            app.swipeDown()+        }+        return waitFor(field, "The tab offers a search field", file: file, line: line)+    }++    private func type(_ query: String, file: StaticString = #filePath, line: UInt = #line) {+        let field = searchField(file: file, line: line)+        if !field.isHittable { app.swipeDown() }+        field.tap()+        field.typeText(query)+    }++    /// Req 3.5's clear. The field keeps focus, so the next query can be typed+    /// straight after without re-tapping.+    private func clearQuery() {+        let field = app.searchFields.firstMatch+        guard field.exists else { return }+        let clear = field.buttons.firstMatch+        if clear.exists, clear.isHittable {+            clear.tap()+        } else {+            field.tap()+        }+    }++    // MARK: - Recent (Req 3)++    func testRecentSearchNarrowsRowsAndRestoresThemWhenCleared() {+        launch("seeded-composed")+        waitFor(app.collectionViews["recent-list"], "Recent publishes the seeded library", timeout: 60)+        XCTAssertEqual(recentRows.count, 3, "The fixture seeds three entries")++        // Matches the two taught entries on their Work title, and nothing else:+        // the untaught row's cleaned capture title is `TtH - Story - Real Title`.+        type("Real Work")+        let narrowed = expectation(+            for: NSPredicate(format: "count == 2"), evaluatedWith: recentRows)+        XCTAssertEqual(+            XCTWaiter().wait(for: [narrowed], timeout: 15), .completed,+            "Typing a work title narrows Recent to that work's entries")++        // Req 3.5: clearing restores the prior list rather than a fresh read.+        clearQuery()+        let restored = expectation(+            for: NSPredicate(format: "count == 3"), evaluatedWith: recentRows)+        XCTAssertEqual(+            XCTWaiter().wait(for: [restored], timeout: 15), .completed,+            "Clearing the query restores every row")+    }++    func testRecentSearchWithNoMatchesShowsItsOwnEmptyState() {+        launch("seeded-composed")+        waitFor(app.collectionViews["recent-list"], "Recent publishes the seeded library", timeout: 60)++        type("zzqqxx")+        waitFor(+            app.anyElement("recent-search-empty"),+            "Req 3.4: a query with nothing behind it gets a message, not a blank list")+        XCTAssertFalse(+            app.anyElement("recent-empty").exists,+            "The message describes the query, not an empty library")+    }++    /// Req 3.2 / Q6: search runs **after** the banner filter, so both conditions+    /// apply. The divergent fixture is the only shape with a banner to compose+    /// with — two entries on one conservative key with different notes, beside a+    /// healthy row the filter excludes.+    func testRecentSearchComposesWithTheDuplicateFilter() {+        launch("seeded-tolerated-divergentEntrySet")+        waitFor(app.collectionViews["recent-list"], "The library opens", timeout: 60)+        XCTAssertEqual(recentRows.count, 3, "Both members of the set plus the healthy row")++        waitFor(app.buttons["duplicate-banner"], "Recent shows the duplicate banner").tap()+        let filtered = expectation(+            for: NSPredicate(format: "count == 2"), evaluatedWith: recentRows)+        XCTAssertEqual(+            XCTWaiter().wait(for: [filtered], timeout: 15), .completed,+            "The banner filters Recent to the set")++        // Note text is one of the searched fields (3.1), and only one member's+        // note says "this device".+        type("this device")+        let narrowed = expectation(+            for: NSPredicate(format: "count == 1"), evaluatedWith: recentRows)+        XCTAssertEqual(+            XCTWaiter().wait(for: [narrowed], timeout: 15), .completed,+            "The query narrows within the filtered set")+        XCTAssertEqual(+            app.buttons.matching(identifier: "resolve-duplicate-pill").count, 1,+            "The surviving row is still a member of the set")++        // The healthy row matches the query but not the filter: both conditions+        // hold, so the result is empty rather than the banner's filter lapsing.+        clearQuery()+        type("Healthy")+        waitFor(+            app.anyElement("recent-search-empty"),+            "A row the banner excluded is not resurrected by matching the query")+        XCTAssertEqual(recentRows.count, 0, "Nothing satisfies both conditions")+    }++    // MARK: - Works (Req 4)++    func testWorksSearchNarrowsAndHidesTheUnattachedGroup() {+        launch("seeded-composed")+        waitFor(app.collectionViews["recent-list"], "The library opens", timeout: 60)+        waitFor(app.tabBars.buttons["Works"], "The Works tab is reachable").tap()+        waitFor(app.collectionViews["works-list"], "Works lists the seeded library")+        waitFor(app.staticTexts["unattached-section-header"], "Unattached notes start visible")++        type("Real Work")+        waitFor(app.collectionViews["works-list"], "The matching work is still listed")+        XCTAssertEqual(workRows.count, 1, "The seeded work matches its own title")+        // Req 4.2 / Q12: unattached entries have no work title to match, so the+        // group is hidden outright rather than shown empty.+        waitUntilGone(+            app.staticTexts["unattached-section-header"],+            "An active query hides the unattached group")+    }++    func testWorksSearchWithNoMatchesShowsItsOwnEmptyState() {+        launch("seeded-composed")+        waitFor(app.collectionViews["recent-list"], "The library opens", timeout: 60)+        waitFor(app.tabBars.buttons["Works"], "The Works tab is reachable").tap()+        waitFor(app.collectionViews["works-list"], "Works lists the seeded library")++        type("zzqqxx")+        waitFor(+            app.anyElement("works-search-empty"),+            "Req 4.3: a query with no matching work gets a message")+        XCTAssertEqual(workRows.count, 0, "Nothing is listed behind the message")+    }+}

diff --git a/Asterism/AsterismUITests/SitesSettingsUITests.swift b/Asterism/AsterismUITests/SitesSettingsUITests.swiftnew file mode 100644index 0000000..c8bc204--- /dev/null+++ b/Asterism/AsterismUITests/SitesSettingsUITests.swift@@ -0,0 +1,112 @@+import XCTest++/// The Sites settings screen (Req 6), driven from app launch.+///+/// Two things only a journey can prove here. The re-teach route has to cross a+/// sheet dismissal — the composed surface is presented from `ContentView`, which+/// is covered while Settings is up, so the hostname is parked and the sheet+/// opens only after Settings has actually gone (`pendingReteachHostname`). And+/// the articles switch is a confirmation over a projection, which is the shape+/// that has silently done nothing before.+///+/// `seeded-composed` carries both site modes the screen distinguishes: an+/// untaught `composed.test` and a taught `id.test`.+final class SitesSettingsUITests: XCTestCase {+    let app = XCUIApplication()++    override func setUp() {+        continueAfterFailure = false+        XCUIDevice.shared.orientation = .portrait+        terminateAndWaitForExit(app)+        app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = "seeded-composed"+        app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString+        app.launch()+    }++    override func tearDown() {+        terminateAndWaitForExit(app)+    }++    // MARK: - Navigation helpers++    private func openSitesList() {+        waitFor(app.collectionViews["recent-list"], "The library opens", timeout: 60)+        waitFor(app.buttons["settings-button"], "Recent carries the Settings route").tap()+        waitFor(app.anyElement("settings-view"), "Settings opens")+        scrollUntilTappableAndTap(+            app.buttons["settings-sites-button"], in: app,+            "Settings carries the route to the Sites list")+        waitFor(app.anyElement("settings-sites-list"), "The Sites list opens")+    }++    private func openSiteDetail(_ hostname: String) {+        scrollUntilTappableAndTap(+            app.buttons["site-row-\(hostname)"], in: app,+            "The list carries a row for \(hostname)")+        waitFor(app.anyElement("site-detail-view"), "The site's screen opens")+    }++    // MARK: - The list (Req 6.1)++    func testSettingsRoutesToASitesListCarryingEverySite() {+        openSitesList()+        waitFor(app.buttons["site-row-composed.test"], "The untaught site is listed")+        waitFor(app.buttons["site-row-id.test"], "The taught site is listed too")+        XCTAssertFalse(+            app.anyElement("settings-sites-empty").exists,+            "A library with sites does not show the empty message")+    }++    // MARK: - Re-teach across the Settings dismissal (Req 6.2)++    func testReteachingASiteOpensTheComposedSurfaceOnceSettingsHasGone() {+        openSitesList()+        openSiteDetail("id.test")++        XCTAssertFalse(+            app.anyElement("site-detail-reteach-unavailable").exists,+            "A site with notes has something to teach against")+        scrollUntilTappableAndTap(+            app.buttons["site-detail-reteach-button"], in: app,+            "The site offers the re-teach route")++        waitUntilGone(app.anyElement("settings-sites-list"), "Settings closes first")+        waitFor(+            app.buttons["composed-title-chip-0"],+            "The parked route opens the composed teaching surface")+    }++    // MARK: - Articles switch (Req 6.3)++    func testTheArticlesSwitchConfirmsBeforeItWrites() {+        openSitesList()+        openSiteDetail("composed.test")++        scrollUntilTappableAndTap(+            app.buttons["site-detail-articles-button"], in: app,+            "A non-articles site offers the switch")+        waitFor(+            app.dialogButton("site-detail-articles-confirm"),+            "The switch states its consequences before writing")+        declineConfirmationDialog(+            cancel: "site-detail-articles-cancel", dismissing: "site-detail-articles-confirm",+            in: app)++        waitFor(app.anyElement("site-detail-view"), "Declining leaves the site as it was")+        XCTAssertFalse(+            app.anyElement("site-detail-error").exists, "Declining is not a failure")++        // Confirming commits and the screen leaves: everything on it describes+        // the site as it was.+        scrollUntilTappableAndTap(+            app.buttons["site-detail-articles-button"], in: app, "The switch can be reopened")+        waitFor(app.dialogButton("site-detail-articles-confirm"), "The confirmation returns").tap()+        // A committed switch leaves the screen — everything on it describes the+        // site as it was. Staying put with no error is the shape the confirm+        // took before the contract moved onto the prompt: silently nothing.+        waitFor(+            app.anyElement("settings-sites-list"), "A committed switch returns to the list")+        XCTAssertFalse(+            app.anyElement("site-detail-error").exists, "The switch reported no failure")+    }+}