Pre-push review: title teaching & retroactive parsing

diff --git a/Asterism/Asterism.xcodeproj/xcshareddata/xcschemes/Asterism Development.xcscheme b/Asterism/Asterism.xcodeproj/xcshareddata/xcschemes/Asterism Development.xcschemeindex d31c0c4..045c317 100644--- a/Asterism/Asterism.xcodeproj/xcshareddata/xcschemes/Asterism Development.xcscheme	+++ b/Asterism/Asterism.xcodeproj/xcshareddata/xcschemes/Asterism Development.xcscheme	@@ -7,13 +7,13 @@       </BuildActionEntry>     </BuildActionEntries>   </BuildAction>-    <TestAction buildConfiguration="Development" selectedDebuggerIdentifier="Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier="Xcode.DebuggerFoundation.Launcher.LLDB" shouldUseLaunchSchemeArgsEnv="YES">+    <TestAction buildConfiguration="Development" selectedDebuggerIdentifier="" selectedLauncherIdentifier="Xcode.IDEFoundation.Launcher.PosixSpawn" shouldUseLaunchSchemeArgsEnv="YES">     <Testables>       <TestableReference skipped="NO"><BuildableReference BuildableIdentifier="primary" BlueprintIdentifier="D4A9C7A430091595004199A5" BuildableName="AsterismTests.xctest" BlueprintName="AsterismTests" ReferencedContainer="container:Asterism.xcodeproj"/></TestableReference>       <TestableReference skipped="NO"><BuildableReference BuildableIdentifier="primary" BlueprintIdentifier="D4A9C7AE30091595004199A5" BuildableName="AsterismUITests.xctest" BlueprintName="AsterismUITests" ReferencedContainer="container:Asterism.xcodeproj"/></TestableReference>     </Testables>   </TestAction>-  <LaunchAction buildConfiguration="Development" selectedDebuggerIdentifier="Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier="Xcode.DebuggerFoundation.Launcher.LLDB" launchStyle="0" useCustomWorkingDirectory="NO" ignoresPersistentStateOnLaunch="NO" debugDocumentVersioning="YES" debugServiceExtension="internal" allowLocationSimulation="YES">+  <LaunchAction buildConfiguration="Development" selectedDebuggerIdentifier="" selectedLauncherIdentifier="Xcode.IDEFoundation.Launcher.PosixSpawn" launchStyle="0" useCustomWorkingDirectory="NO" ignoresPersistentStateOnLaunch="NO" debugDocumentVersioning="YES" allowLocationSimulation="YES">     <BuildableProductRunnable runnableDebuggingMode="0"><BuildableReference BuildableIdentifier="primary" BlueprintIdentifier="D4A9C79330091593004199A5" BuildableName="Asterism.app" BlueprintName="Asterism" ReferencedContainer="container:Asterism.xcodeproj"/></BuildableProductRunnable>   </LaunchAction>   <ProfileAction buildConfiguration="Development" shouldUseLaunchSchemeArgsEnv="YES" savedToolIdentifier="" useCustomWorkingDirectory="NO" debugDocumentVersioning="YES"/>

diff --git a/Asterism/Asterism.xcodeproj/xcshareddata/xcschemes/Asterism Personal.xcscheme b/Asterism/Asterism.xcodeproj/xcshareddata/xcschemes/Asterism Personal.xcschemeindex 582f04c..f6fd127 100644--- a/Asterism/Asterism.xcodeproj/xcshareddata/xcschemes/Asterism Personal.xcscheme	+++ b/Asterism/Asterism.xcodeproj/xcshareddata/xcschemes/Asterism Personal.xcscheme	@@ -7,13 +7,13 @@       </BuildActionEntry>     </BuildActionEntries>   </BuildAction>-  <TestAction buildConfiguration="Personal" selectedDebuggerIdentifier="Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier="Xcode.DebuggerFoundation.Launcher.LLDB" shouldUseLaunchSchemeArgsEnv="YES">+  <TestAction buildConfiguration="Personal" selectedDebuggerIdentifier="" selectedLauncherIdentifier="Xcode.IDEFoundation.Launcher.PosixSpawn" shouldUseLaunchSchemeArgsEnv="YES">     <Testables>       <TestableReference skipped="NO"><BuildableReference BuildableIdentifier="primary" BlueprintIdentifier="D4A9C7A430091595004199A5" BuildableName="AsterismTests.xctest" BlueprintName="AsterismTests" ReferencedContainer="container:Asterism.xcodeproj"/></TestableReference>       <TestableReference skipped="NO"><BuildableReference BuildableIdentifier="primary" BlueprintIdentifier="D4A9C7AE30091595004199A5" BuildableName="AsterismUITests.xctest" BlueprintName="AsterismUITests" ReferencedContainer="container:Asterism.xcodeproj"/></TestableReference>     </Testables>   </TestAction>-  <LaunchAction buildConfiguration="Personal" selectedDebuggerIdentifier="Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier="Xcode.DebuggerFoundation.Launcher.LLDB" launchStyle="0" useCustomWorkingDirectory="NO" ignoresPersistentStateOnLaunch="NO" debugDocumentVersioning="YES" debugServiceExtension="internal" allowLocationSimulation="YES">+  <LaunchAction buildConfiguration="Personal" selectedDebuggerIdentifier="" selectedLauncherIdentifier="Xcode.IDEFoundation.Launcher.PosixSpawn" launchStyle="0" useCustomWorkingDirectory="NO" ignoresPersistentStateOnLaunch="NO" debugDocumentVersioning="YES" allowLocationSimulation="YES">     <BuildableProductRunnable runnableDebuggingMode="0"><BuildableReference BuildableIdentifier="primary" BlueprintIdentifier="D4A9C79330091593004199A5" BuildableName="Asterism.app" BlueprintName="Asterism" ReferencedContainer="container:Asterism.xcodeproj"/></BuildableProductRunnable>   </LaunchAction>   <ProfileAction buildConfiguration="Personal" shouldUseLaunchSchemeArgsEnv="YES" savedToolIdentifier="" useCustomWorkingDirectory="NO" debugDocumentVersioning="YES"/>

diff --git a/Asterism/Asterism/ContentView.swift b/Asterism/Asterism/ContentView.swiftindex 5dbbafa..e1a70ec 100644--- a/Asterism/Asterism/ContentView.swift+++ b/Asterism/Asterism/ContentView.swift@@ -11,6 +11,7 @@ struct ContentView: View {     @State private var showingNewWork = false     @State private var showingMoveTo: UUID?     @State private var showingSettings = false+    @State private var showingTeachingForEntryID: UUID?      enum AppTab {         case recent@@ -20,15 +21,15 @@ struct ContentView: View {     /// Production initializer. Debug UI tests may request an isolated seeded     /// library; malformed requests render unavailable rather than touching an App Group.     init() {-        #if DEBUG+        #if DEBUG || ASTERISM_PERFORMANCE_TESTING         switch UITestLaunchSupport.request() {         case .disabled:             _model = State(initialValue: AppLibraryModel(environment: .current))-        case .seeded(let configuration):+        case .seeded(let configuration, let fixture):             _model = State(                 initialValue: AppLibraryModel(                     configuration: configuration,-                    seedUITestFixture: true+                    uiTestFixture: fixture                 )             )         case .invalid(let message):@@ -81,8 +82,14 @@ struct ContentView: View {         TabView(selection: $selectedTab) {             SwiftUI.Tab("Recent", systemImage: "clock", value: AppTab.recent) {                 NavigationStack {-                    RecentView(groups: model.recentGroups) { entryID in+                    RecentView(+                        presentation: model.recentPresentation,+                        capabilities: model.capabilities+                    ) { entryID in                         selectedRecentEntryID = entryID+                    } onTeach: { entryID in+                        // Direct teaching sheet from inline action (Audit §6)+                        showingTeachingForEntryID = entryID                     }                     .navigationTitle("Recent")                     .toolbar {@@ -161,6 +168,18 @@ struct ContentView: View {                 }             }         }+        // Direct teaching sheet wired from Recent inline Teach action (Audit §6)+        .sheet(+            isPresented: Binding(+                get: { showingTeachingForEntryID != nil },+                set: { if !$0 { showingTeachingForEntryID = nil } }+            )+        ) {+            if let entryID = showingTeachingForEntryID,+               let teachModel = model.teachingModel(for: entryID) {+                TeachingView(model: teachModel)+            }+        }     }      @ViewBuilder

diff --git a/Asterism/Asterism/UITestLaunchSupport.swift b/Asterism/Asterism/UITestLaunchSupport.swiftindex c69384b..331142a 100644--- a/Asterism/Asterism/UITestLaunchSupport.swift+++ b/Asterism/Asterism/UITestLaunchSupport.swift@@ -11,9 +11,15 @@ struct SystemProcessEnvironment: ProcessEnvironmentProviding {     var environment: [String: String] { ProcessInfo.processInfo.environment } } +enum UITestFixtureKind: Equatable {+    case untaught+    case taught+    case scale+}+ enum UITestLaunchRequest: Equatable {     case disabled-    case seeded(configuration: LibraryConfiguration)+    case seeded(configuration: LibraryConfiguration, fixture: UITestFixtureKind)     case invalid(message: String) } @@ -23,6 +29,8 @@ enum UITestLaunchSupport {     static let scenarioKey = "ASTERISM_UI_TEST_SCENARIO"     static let runIDKey = "ASTERISM_UI_TEST_RUN_ID"     static let seededScenario = "seeded-m1"+    static let seededTaughtScenario = "seeded-taught"+    static let seededScaleScenario = "seeded-scale-m2"      static func request(         environmentProvider: any ProcessEnvironmentProviding = SystemProcessEnvironment(),@@ -32,7 +40,15 @@ enum UITestLaunchSupport {         guard let scenario = environment[scenarioKey] else {             return .disabled         }-        guard scenario == seededScenario else {+        let fixture: UITestFixtureKind+        switch scenario {+        case seededScenario:+            fixture = .untaught+        case seededTaughtScenario:+            fixture = .taught+        case seededScaleScenario:+            fixture = .scale+        default:             return .invalid(message: "Unsupported UI test scenario.")         }         guard@@ -60,7 +76,8 @@ enum UITestLaunchSupport {             configuration: LibraryConfiguration(                 rootDirectory: rootDirectory,                 environment: .development-            )+            ),+            fixture: fixture         )     } }

diff --git a/Asterism/Asterism/ViewModels/AppLibraryModel.swift b/Asterism/Asterism/ViewModels/AppLibraryModel.swiftindex 8218a67..92a838a 100644--- a/Asterism/Asterism/ViewModels/AppLibraryModel.swift+++ b/Asterism/Asterism/ViewModels/AppLibraryModel.swift@@ -15,7 +15,10 @@ public final class AppLibraryModel {      public private(set) var state: State = .loading     public private(set) var recentGroups: [DatedEntryGroup] = []+    public private(set) var recentPresentation: RecentPresentation = RecentPresentation(groups: [], actionableCount: 0)     public private(set) var worksSnapshot: WorksSnapshot = WorksSnapshot(works: [], unattachedEntries: [])+    /// One gate value drives repository validation, navigation, teaching, Backup, and capture UI.+    public let capabilities: M2Capabilities      /// When an explicit configuration is injected (tests), resolution is skipped.     private let explicitConfiguration: LibraryConfiguration?@@ -32,46 +35,61 @@ public final class AppLibraryModel {     /// A pre-bootstrap failure used to fail closed on invalid debug launch input.     private let startupFailureMessage: String?     /// Seeds only a fresh, explicit temporary configuration used by UI tests.-    private let shouldSeedUITestFixture: Bool+    private let uiTestFixture: UITestFixtureKind?      /// Production initializer: resolves configuration from the compile-time environment at bootstrap.     /// Fails closed (→ unavailable) when App Group resolution fails.     public init(         environment: LibraryEnvironment,-        locator: any SharedContainerLocating = SystemSharedContainerLocator()+        locator: any SharedContainerLocating = SystemSharedContainerLocator(),+        capabilities: M2Capabilities = .current     ) {+        self.capabilities = capabilities         self.explicitConfiguration = nil         self.environment = environment         self.locator = locator         self.startupFailureMessage = nil-        self.shouldSeedUITestFixture = false+        self.uiTestFixture = nil     }      /// Test/explicit initializer: bypasses locator resolution entirely.-    public init(configuration: LibraryConfiguration) {+    public init(+        configuration: LibraryConfiguration,+        capabilities: M2Capabilities = .current+    ) {+        self.capabilities = capabilities         self.explicitConfiguration = configuration         self.environment = nil         self.locator = SystemSharedContainerLocator()         self.startupFailureMessage = nil-        self.shouldSeedUITestFixture = false+        self.uiTestFixture = nil     }      /// Debug UI-test initializer. The caller must provide an isolated temporary configuration.-    init(configuration: LibraryConfiguration, seedUITestFixture: Bool) {+    init(+        configuration: LibraryConfiguration,+        uiTestFixture: UITestFixtureKind,+        capabilities: M2Capabilities = .current+    ) {+        self.capabilities = capabilities         self.explicitConfiguration = configuration         self.environment = nil         self.locator = SystemSharedContainerLocator()         self.startupFailureMessage = nil-        self.shouldSeedUITestFixture = seedUITestFixture+        self.uiTestFixture = uiTestFixture     }      /// Constructs a model that can only render an unavailable state.-    init(startupFailureMessage: String) {+    init(+        startupFailureMessage: String,+        capabilities: M2Capabilities = .current+    ) {+        self.capabilities = capabilities         self.explicitConfiguration = nil         self.environment = nil         self.locator = SystemSharedContainerLocator()         self.startupFailureMessage = startupFailureMessage-        self.shouldSeedUITestFixture = false+        self.uiTestFixture = nil     }      /// Attempts to open the library; transitions to ready or unavailable.@@ -95,9 +113,12 @@ public final class AppLibraryModel {                 configuration = try LibraryConfiguration.production(environment: env, locator: locator)             }             resolvedConfiguration = configuration-            let repo = try await LibraryRepository.open(configuration)-            if shouldSeedUITestFixture {-                try await seedUITestFixture(in: repo)+            let repo = try await LibraryRepository.openForApp(+                configuration,+                capabilities: capabilities+            )+            if let uiTestFixture {+                try await seedUITestFixture(uiTestFixture, in: repo)             }             self.repository = repo             self.backupRepository = repo@@ -126,7 +147,12 @@ public final class AppLibraryModel {         guard let repo = repository else { return }         do {             let calendar = Calendar.current-            recentGroups = try await repo.recentEntries(calendar: calendar)+            recentPresentation = try await repo.recentPresentation(calendar: calendar)+            // Keep the legacy grouped snapshot for curation views while deriving it+            // from the same coherent Recent read rather than a second repository read.+            recentGroups = recentPresentation.groups.map {+                DatedEntryGroup(day: $0.day, entries: $0.rows.map(\.entry))+            }             worksSnapshot = try await repo.works()         } catch {             Self.logger.error("Snapshot refresh failed: \(String(describing: error), privacy: .public)")@@ -136,9 +162,14 @@ public final class AppLibraryModel {     /// Provides a detail model for a specific entry.     public func entryDetailModel(for id: UUID) -> EntryDetailModel? {         guard let repo = repository else { return nil }-        return EntryDetailModel(entryID: id, library: repo, onMutation: { [weak self] in-            await self?.refreshAll()-        })+        return EntryDetailModel(+            entryID: id,+            library: repo,+            capabilities: capabilities,+            onMutation: { [weak self] in+                await self?.refreshAll()+            }+        )     }      /// Provides a detail model for a specific work.@@ -165,19 +196,44 @@ public final class AppLibraryModel {         })     } +    /// Provides a teaching view model for an entry from the Recent inline action.+    /// Uses cached recentPresentation row data; opens TeachingView directly.+    public func teachingModel(for entryID: UUID) -> TeachingViewModel? {+        guard capabilities.supportsSegmentTeaching,+              let repo = repository,+              let entry = recentPresentation.allRows.first(where: { $0.id == entryID })?.entry else {+            return nil+        }+        return TeachingViewModel(+            entry: entry,+            library: repo,+            capabilities: capabilities,+            onMutation: { [weak self] in+                await self?.refreshAll()+            }+        )+    }+     /// Provides a settings backup model backed by the current repository.     public func settingsBackupModel() -> SettingsBackupModel? {         guard let repo = backupRepository, let config = resolvedConfiguration else { return nil }         let stagingDir = config.rootDirectory             .appending(path: "Library/Caches/BackupExports")-        let exporter = BackupExporter(repository: repo, stagingDirectory: stagingDir)+        let exporter = BackupExporter(+            repository: repo,+            stagingDirectory: stagingDir,+            capabilities: capabilities+        )         return SettingsBackupModel(exporter: exporter)     }      /// Creates the smallest graph that makes every M1 app journey reachable.     /// Refuse to seed a non-empty location so a malformed test launch can never     /// overwrite or blend with an existing library.-    private func seedUITestFixture(in repository: LibraryRepository) async throws {+    private func seedUITestFixture(+        _ fixture: UITestFixtureKind,+        in repository: LibraryRepository+    ) async throws {         let counts = try await repository.debugCounts()         guard counts == .zero else {             throw LibraryRepositoryError.invalidInput(@@ -186,9 +242,23 @@ public final class AppLibraryModel {             )         } +        if fixture == .scale {+            #if DEBUG || ASTERISM_PERFORMANCE_TESTING+            try await repository.seedM2PerformanceFixture()+            Self.logger.debug("Seeded deterministic M2 performance fixture")+            return+            #else+            throw LibraryRepositoryError.invalidInput(+                operation: "preparing UI test fixture",+                reason: "scale fixtures require a performance-test build"+            )+            #endif+        }++        // Entry with a parseable :: title for teaching UI tests         _ = try await repository.capture(             CaptureDraft(-                captureTitle: "Integration Chapter",+                captureTitle: "Integration Work :: Integration Chapter",                 captureTitleSource: .manual,                 rawURLString: "https://integration.test/chapter/1",                 note: "Seeded note for accessibility journeys",@@ -201,6 +271,31 @@ public final class AppLibraryModel {                 hostname: "integration.test"             )         )-        Self.logger.debug("Seeded isolated M1 UI test fixture")++        if fixture == .taught {+            let definition = PatternDefinition.segment(+                work: try SegmentRangeSpec(origin: .start, offset: 0, length: 1),+                ignored: []+            )+            let contract = try await repository.projectInitialTeaching(+                hostname: "integration.test",+                patternDefinition: definition+            )+            switch try await repository.commitTeaching(contract) {+            case .committed:+                Self.logger.debug("Committed deterministic taught UI test fixture")+            case .refreshed:+                throw LibraryRepositoryError.invalidInput(+                    operation: "preparing taught UI test fixture",+                    reason: "fresh isolated teaching contract unexpectedly became stale"+                )+            case .invalidated(let reason):+                throw LibraryRepositoryError.invalidInput(+                    operation: "preparing taught UI test fixture",+                    reason: "teaching contract was invalidated: \(reason)"+                )+            }+        }+        Self.logger.debug("Seeded isolated UI test fixture")     } }

diff --git a/Asterism/Asterism/ViewModels/EntryDetailModel.swift b/Asterism/Asterism/ViewModels/EntryDetailModel.swiftindex b3308ee..d783bb0 100644--- a/Asterism/Asterism/ViewModels/EntryDetailModel.swift+++ b/Asterism/Asterism/ViewModels/EntryDetailModel.swift@@ -2,7 +2,8 @@ import AsterismCore import Foundation import OSLog -/// View model for Entry detail: manages drafts for note/rating and delete.+/// View model for Entry detail: manages drafts for note/rating, delete,+/// teaching/re-parse action routing, and coherent provenance detail. @MainActor @Observable public final class EntryDetailModel {     private static let logger = Logger(subsystem: "me.nore.ig.Asterism", category: "EntryDetailModel")@@ -17,6 +18,7 @@ public final class EntryDetailModel {     public private(set) var state: State = .loading     public private(set) var entry: EntrySnapshot?     public private(set) var errorMessage: String?+    public private(set) var teachingDetail: EntryTeachingDetail?      // Draft fields     public var draftNote: String = ""@@ -24,26 +26,37 @@ public final class EntryDetailModel {      private let entryID: UUID     private let library: any LibraryProviding+    public let capabilities: M2Capabilities     private let onMutation: @Sendable () async -> Void     private var isSubmitting = false -    public init(entryID: UUID, library: any LibraryProviding, onMutation: @escaping @Sendable () async -> Void) {+    public init(+        entryID: UUID,+        library: any LibraryProviding,+        capabilities: M2Capabilities = .current,+        onMutation: @escaping @Sendable () async -> Void+    ) {         self.entryID = entryID         self.library = library+        self.capabilities = capabilities         self.onMutation = onMutation     } +    public var supportsTitleRecovery: Bool { capabilities.supportsSegmentTeaching }+     public func load() async {         state = .loading         do {-            let snapshot = try await library.entry(id: entryID)+            let detail = try await library.entryTeachingDetail(id: entryID)+            let snapshot = detail.entry             self.entry = snapshot+            self.teachingDetail = detail             self.draftNote = snapshot.note             self.draftRating = snapshot.rating             state = .ready         } catch {             state = .error(message: error.localizedDescription)-            Self.logger.error("Entry load failed: \(String(describing: error), privacy: .public)")+            Self.logger.error("Entry detail load failed: \(String(describing: error), privacy: .public)")         }     } @@ -86,4 +99,55 @@ public final class EntryDetailModel {         }         isSubmitting = false     }++    /// Provides a teaching view model for this entry's site in initial mode.+    public func teachingModel() -> TeachingViewModel? {+        guard capabilities.supportsSegmentTeaching, let entry else { return nil }+        return TeachingViewModel(+            entry: entry,+            library: library,+            capabilities: capabilities,+            mode: .initial,+            onMutation: { [weak self] in+                await self?.load()+                await self?.onMutation()+            }+        )+    }++    /// Provides a teaching view model in replacement (re-teach) mode.+    public func reteachModel() -> TeachingViewModel? {+        guard capabilities.supportsSegmentTeaching,+              let entry,+              let detail = teachingDetail else { return nil }+        let historicalID = detail.activePatternSummary?.id+        let historicalVersion = detail.activePatternSummary?.version+        return TeachingViewModel(+            entry: entry,+            library: library,+            capabilities: capabilities,+            mode: .replacement(+                boundaryEntryID: entry.id,+                historicalPatternID: historicalID,+                historicalPatternVersion: historicalVersion+            ),+            onMutation: { [weak self] in+                await self?.load()+                await self?.onMutation()+            }+        )+    }++    /// Provides a ReparseViewModel for this entry.+    public func reparseModel() -> ReparseViewModel? {+        guard capabilities.supportsSegmentTeaching, entry != nil else { return nil }+        return ReparseViewModel(+            entryID: entryID,+            library: library,+            onMutation: { [weak self] in+                await self?.load()+                await self?.onMutation()+            }+        )+    } }

diff --git a/Asterism/Asterism/ViewModels/ReparseViewModel.swift b/Asterism/Asterism/ViewModels/ReparseViewModel.swiftnew file mode 100644index 0000000..914d13d--- /dev/null+++ b/Asterism/Asterism/ViewModels/ReparseViewModel.swift@@ -0,0 +1,131 @@+import AsterismCore+import Foundation+import OSLog++/// View model for the Re-parse sheet: projects first, displays before/after,+/// then requires explicit confirmation. Handles refreshed/invalidated outcomes.+/// No immediate write.+@MainActor @Observable+public final class ReparseViewModel {+    private static let logger = Logger(subsystem: "me.nore.ig.Asterism", category: "ReparseViewModel")++    public enum State: Equatable, Sendable {+        case loading+        case projected+        case confirming+        case committed+        case refreshed+        case invalidated(reason: String)+        case error(message: String)+    }++    public private(set) var state: State = .loading+    public private(set) var contract: ReparseContract?+    public private(set) var projection: EntryProjection?+    public private(set) var requiresReconfirmation: Bool = false+    public private(set) var errorMessage: String?++    /// The entry basis from the contract (before state).+    public var entryBefore: EntryBasisEntry? { contract?.basis.entry }++    /// The active pattern used in this reparse.+    public var activePattern: PatternBasisEntry? { contract?.basis.activePattern }++    /// Work outcomes from the projection plan.+    public var worksToCreate: [String] { contract?.outcome.plan.worksToCreate ?? [] }+    public var worksToReuse: Set<UUID> { contract?.outcome.plan.worksToReuse ?? [] }+    public var hasAmbiguity: Bool { contract?.outcome.plan.hasAmbiguity ?? false }++    private let entryID: UUID+    private let library: any LibraryProviding+    private let onMutation: @Sendable () async -> Void+    private var isSubmitting = false++    public init(+        entryID: UUID,+        library: any LibraryProviding,+        onMutation: @escaping @Sendable () async -> Void+    ) {+        self.entryID = entryID+        self.library = library+        self.onMutation = onMutation+    }++    /// Load/project the reparse. Displays the contract without writing.+    public func load() async {+        state = .loading+        do {+            let reparseContract = try await library.projectReparse(entryID: entryID)+            self.contract = reparseContract+            self.projection = reparseContract.outcome.plan.entryProjections.first+            state = .projected+        } catch {+            errorMessage = error.localizedDescription+            state = .error(message: error.localizedDescription)+            Self.logger.error("Reparse projection failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// Confirm the displayed contract. May return refreshed requiring second confirm.+    public func confirm() async {+        guard let contract else { return }+        guard !isSubmitting else { return }+        isSubmitting = true+        state = .confirming+        errorMessage = nil++        do {+            let outcome = try await library.commitReparse(contract)+            switch outcome {+            case .committed:+                state = .committed+                await onMutation()+                Self.logger.debug("Reparse committed for entry \(self.entryID)")+            case .refreshed(let freshContract):+                self.contract = freshContract+                self.projection = freshContract.outcome.plan.entryProjections.first+                requiresReconfirmation = true+                state = .refreshed+                Self.logger.info("Reparse refreshed — requires re-confirmation")+            case .invalidated(let reason):+                state = .invalidated(reason: reason)+                Self.logger.info("Reparse invalidated: \(reason)")+            }+        } catch {+            errorMessage = error.localizedDescription+            state = .error(message: error.localizedDescription)+            Self.logger.error("Reparse commit failed: \(String(describing: error), privacy: .public)")+        }+        isSubmitting = false+    }++    /// Reconfirm after a refreshed contract.+    public func reconfirm() async {+        guard let contract, requiresReconfirmation else { return }+        guard !isSubmitting else { return }+        isSubmitting = true+        state = .confirming+        errorMessage = nil++        do {+            let outcome = try await library.commitReparse(contract)+            switch outcome {+            case .committed:+                state = .committed+                requiresReconfirmation = false+                await onMutation()+            case .refreshed(let freshContract):+                self.contract = freshContract+                self.projection = freshContract.outcome.plan.entryProjections.first+                state = .refreshed+            case .invalidated(let reason):+                state = .invalidated(reason: reason)+                requiresReconfirmation = false+            }+        } catch {+            errorMessage = error.localizedDescription+            state = .error(message: error.localizedDescription)+        }+        isSubmitting = false+    }+}

diff --git a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift b/Asterism/Asterism/ViewModels/SettingsBackupModel.swiftindex 1ba6cad..70dd192 100644--- a/Asterism/Asterism/ViewModels/SettingsBackupModel.swift+++ b/Asterism/Asterism/ViewModels/SettingsBackupModel.swift@@ -66,7 +66,7 @@ public final class SettingsBackupModel {         do {             let metadata = BackupMetadata(                 appBuild: Self.currentAppBuild(),-                databaseSchemaVersion: 1,+                databaseSchemaVersion: 2,                 exportedAt: Date()             )             let result = try await exporter.export(metadata: metadata)

diff --git a/Asterism/Asterism/ViewModels/TeachingViewModel.swift b/Asterism/Asterism/ViewModels/TeachingViewModel.swiftnew file mode 100644index 0000000..792494f--- /dev/null+++ b/Asterism/Asterism/ViewModels/TeachingViewModel.swift@@ -0,0 +1,627 @@+import AsterismCore+import Foundation+import OSLog++/// View model for segment teaching: tokenizes an entry's capture title,+/// manages role assignments, validates, projects a preview asynchronously,+/// and only commits on explicit separate confirmation of the displayed contract.+///+/// Two-stage UX (Audit §1):+/// - Valid role edit → async preview publishes a complete contract+/// - Only a separate confirmation can commit the already-displayed contract+/// - No commit without a current displayed contract+/// - Role edits invalidate old approval and increment generation+/// - Async preview only publishes if its generation is still latest+/// - Supports initial vs replacement mode+@MainActor @Observable+public final class TeachingViewModel {+    private static let logger = Logger(subsystem: "me.nore.ig.Asterism", category: "TeachingViewModel")+    private static let performanceSignposter = OSSignposter(+        subsystem: M2PerformanceSignposts.subsystem,+        category: M2PerformanceSignposts.category+    )++    public enum State: Equatable, Sendable {+        case loading+        case ready+        case previewing+        case previewReady+        case confirming+        case committed+        case refreshed+        case invalidated+        case error+        case cancelled+    }++    public enum EditorMode: Equatable, Sendable {+        case segments+        case phrase+        case articles+    }++    public enum PhraseBoundary: Equatable, Sendable {+        case start+        case end+    }++    public enum PhraseBoundaryDirection: Equatable, Sendable {+        case backward+        case forward+    }++    public enum Mode: Equatable, Sendable {+        case initial+        case replacement(boundaryEntryID: UUID, historicalPatternID: UUID?, historicalPatternVersion: Int?)+    }++    public private(set) var state: State = .loading+    public private(set) var editorMode: EditorMode = .segments+    public private(set) var segments: [String] = []+    public private(set) var roles: [SegmentRole] = []+    public private(set) var phraseSelection = PhraseSelection(chapter: 0..<0, work: 0..<0)+    public private(set) var phraseValidationMessage: String?+    public private(set) var junkSuffixSegmentCount = 0+    public private(set) var articleValidationMessage: String?+    public private(set) var articlePreviewPlan: ArticleProjectionPlan?+    public private(set) var validationError: TeachingValidationError?+    public private(set) var errorMessage: String?+    public private(set) var invalidationReason: String?+    public private(set) var requiresReconfirmation: Bool = false+    public private(set) var previewPlan: ProjectionPlan?+    public private(set) var patternRuleSummary: String?+    /// Per-row preview errors indexed by entry projection position.+    public private(set) var previewErrors: [Int: String] = [:]+    public struct ParseComparison: Equatable, Sendable, Identifiable {+        public let entryID: UUID+        public let activeResult: SegmentParseResult?+        public let activeFailure: String?+        public let candidateProjection: EntryProjection++        public var id: UUID { entryID }+    }++    /// Active-versus-candidate results for every frozen Site Entry during replacement.+    public private(set) var parseComparisons: [ParseComparison] = []++    private let entry: EntrySnapshot+    private let library: any LibraryProviding+    private let capabilities: M2Capabilities+    private let mode: Mode+    private let onMutation: (@Sendable () async -> Void)?+    private var contract: TeachingContract?+    private var articlesContract: ArticlesContract?+    private var isSubmitting = false+    /// Generation counter: incremented on every role edit that invalidates old preview.+    private var generation: Int = 0+    /// The generation at which the current preview was computed.+    private var previewGeneration: Int = -1++    public var exampleTitle: String { entry.captureTitle }+    public var supportsSegmentTeaching: Bool { capabilities.supportsSegmentTeaching }+    public var supportsPhraseTeaching: Bool { capabilities.supportsPhraseTeaching }+    public var supportsArticles: Bool { capabilities.supportsArticles }++    public var isValid: Bool {+        switch editorMode {+        case .segments:+            validationError == nil && segments.count >= 2 && hasWorkAndChapter+        case .phrase:+            capabilities.supportsPhraseTeaching && phraseValidationMessage == nil+        case .articles:+            capabilities.supportsArticles && articleValidationMessage == nil+        }+    }++    public var canConfirm: Bool {+        guard state == .previewReady, previewGeneration == generation else { return false }+        return switch editorMode {+        case .segments, .phrase: contract != nil+        case .articles: articlesContract != nil+        }+    }++    private var hasWorkAndChapter: Bool {+        roles.contains(.work) && roles.contains(.chapter)+    }++    public init(+        entry: EntrySnapshot,+        library: any LibraryProviding,+        capabilities: M2Capabilities = .current,+        mode: Mode = .initial,+        onMutation: (@Sendable () async -> Void)? = nil+    ) {+        self.entry = entry+        self.library = library+        self.capabilities = capabilities+        self.mode = mode+        self.onMutation = onMutation+    }++    // MARK: - Lifecycle++    public func load() async {+        state = .loading+        let result = DelimiterTokenizer.tokenize(entry.captureTitle)+        switch result {+        case .success(let tokenized):+            segments = tokenized.segments+            roles = Array(repeating: .chapter, count: tokenized.segments.count)+            state = .ready+        case .failure:+            segments = [entry.captureTitle]+            roles = [.chapter]+            state = .ready+        }+        revalidate()+    }++    // MARK: - Editor mode++    public func selectSegmentsMode() {+        guard editorMode != .segments else { return }+        editorMode = .segments+        articleValidationMessage = nil+        phraseValidationMessage = nil+        invalidatePreview()+        revalidate()+    }++    public func selectPhraseMode() {+        guard capabilities.supportsPhraseTeaching else {+            phraseValidationMessage = M2CapabilityError.unavailablePatternForm(+                form: .phrase,+                gate: capabilities.gate+            ).description+            return+        }+        guard editorMode != .phrase else { return }+        editorMode = .phrase+        articleValidationMessage = nil+        let characterCount = exampleTitle.count+        phraseSelection = characterCount >= 2+            ? PhraseSelection(chapter: 0..<1, work: (characterCount - 1)..<characterCount)+            : PhraseSelection(chapter: 0..<0, work: 0..<0)+        invalidatePreview()+        revalidatePhrase()+    }++    public func selectArticlesMode() {+        guard capabilities.supportsArticles else {+            articleValidationMessage = M2CapabilityError.articlesUnavailable(gate: capabilities.gate).description+            return+        }+        editorMode = .articles+        junkSuffixSegmentCount = 0+        articleValidationMessage = nil+        invalidatePreview()+        Task { await generateArticlePreview() }+    }++    public func setJunkSuffixSegmentCount(_ count: Int) {+        guard editorMode == .articles else { return }+        junkSuffixSegmentCount = count+        invalidatePreview()+        do {+            _ = try ArticleTitleCleaner.deriveRule(+                from: entry.captureTitle,+                suffixSegmentCount: count+            )+            articleValidationMessage = nil+            Task { await generateArticlePreview() }+        } catch {+            articleValidationMessage = error.localizedDescription+        }+    }++    // MARK: - Phrase selection++    public func setPhraseSelection(_ role: PhraseFieldRole, range: Range<Int>) {+        guard editorMode == .phrase else { return }+        let count = exampleTitle.count+        guard range.lowerBound >= 0, range.upperBound <= count else {+            phraseValidationMessage = PhraseTeachingError.selectionOutOfBounds(role: role).localizedDescription+            invalidatePreview()+            return+        }++        switch role {+        case .chapter:+            phraseSelection = PhraseSelection(chapter: range, work: phraseSelection.work)+        case .work:+            phraseSelection = PhraseSelection(chapter: phraseSelection.chapter, work: range)+        }+        invalidatePreview()+        revalidatePhrase()+        if isValid {+            Task { await generatePreview() }+        }+    }++    public func adjustPhraseBoundary(+        _ role: PhraseFieldRole,+        boundary: PhraseBoundary,+        direction: PhraseBoundaryDirection+    ) {+        guard editorMode == .phrase else { return }+        let current = phraseSelection.range(for: role)+        let delta = direction == .forward ? 1 : -1+        let adjusted: Range<Int>+        switch boundary {+        case .start:+            let start = min(max(0, current.lowerBound + delta), current.upperBound)+            adjusted = start..<current.upperBound+        case .end:+            let end = min(max(current.lowerBound, current.upperBound + delta), exampleTitle.count)+            adjusted = current.lowerBound..<end+        }+        setPhraseSelection(role, range: adjusted)+    }++    public func selectedText(for role: PhraseFieldRole) -> String {+        PhrasePatternDeriver.selectedText(+            in: exampleTitle,+            selection: phraseSelection,+            role: role+        ) ?? ""+    }++    public func phraseBoundaryAnnouncement(+        for role: PhraseFieldRole,+        boundary: PhraseBoundary+    ) -> String {+        let boundaryName = boundary == .start ? "start" : "end"+        return "\(role.rawValue.capitalized) \(boundaryName) boundary. Selected text: \(selectedText(for: role))"+    }++    // MARK: - Role manipulation++    /// Cycle a segment role: chapter → work → ignore → chapter.+    /// Invalidates any existing preview and increments generation.+    public func cycleRole(at index: Int) {+        guard editorMode == .segments else { return }+        guard index >= 0, index < roles.count else { return }+        switch roles[index] {+        case .chapter: roles[index] = .work+        case .work: roles[index] = .ignore+        case .ignore: roles[index] = .chapter+        }+        invalidatePreview()+        revalidate()+        if isValid {+            Task { await generatePreview() }+        }+    }++    /// Set a specific role at index. Invalidates preview and triggers async generation.+    public func setRole(at index: Int, to role: SegmentRole) {+        guard editorMode == .segments else { return }+        guard index >= 0, index < roles.count else { return }+        roles[index] = role+        invalidatePreview()+        revalidate()+        if isValid {+            Task { await generatePreview() }+        }+    }++    // MARK: - Preview generation (async, generation-safe)++    /// Generate a preview contract for the current role assignment.+    /// Only publishes if the generation hasn't advanced since launch.+    public func generatePreview() async {+        guard editorMode != .articles, isValid else { return }+        let signpostID = Self.performanceSignposter.makeSignpostID()+        let signpostState = Self.performanceSignposter.beginInterval(+            "TeachingFinalPreviewPublication",+            id: signpostID+        )+        defer {+            Self.performanceSignposter.endInterval(+                "TeachingFinalPreviewPublication",+                signpostState+            )+        }+        let currentGeneration = generation+        state = .previewing+        previewErrors = [:]++        do {+            let patternDef: PatternDefinition+            switch editorMode {+            case .segments:+                let assignment = SegmentRoleAssignment(roles: roles)+                let validated = try TeachingValidator.validate(+                    assignment: assignment,+                    segments: segments+                ).get()+                guard let derived = PatternDeriver.deriveSegmentPattern(from: validated) else {+                    if currentGeneration == generation {+                        errorMessage = "Unable to derive segment pattern from assignment."+                        state = .error+                    }+                    return+                }+                patternDef = derived+            case .phrase:+                patternDef = try PhrasePatternDeriver.derive(+                    from: exampleTitle,+                    selection: phraseSelection+                )+            case .articles:+                return+            }++            try capabilities.validate(patternDefinition: patternDef)++            // Project+            let projectedContract: TeachingContract+            switch mode {+            case .initial:+                projectedContract = try await library.projectInitialTeaching(+                    hostname: entry.hostname,+                    patternDefinition: patternDef+                )+            case .replacement(let boundaryID, let histID, let histVersion):+                projectedContract = try await library.projectReplacement(+                    hostname: entry.hostname,+                    patternDefinition: patternDef,+                    boundaryEntryID: boundaryID,+                    historicalPatternID: histID,+                    historicalPatternVersion: histVersion+                )+            }++            // Only publish if generation is still latest+            guard currentGeneration == generation else {+                Self.logger.debug("Preview generation \(currentGeneration) superseded by \(self.generation)")+                return+            }++            contract = projectedContract+            previewPlan = projectedContract.outcome.plan+            previewGeneration = currentGeneration+            patternRuleSummary = buildRuleSummary(patternDef)++            // Build per-row error summaries+            var rowErrors: [Int: String] = [:]+            for (index, projection) in projectedContract.outcome.plan.entryProjections.enumerated() {+                if let failure = projection.parseFailure {+                    rowErrors[index] = failure.localizedDescription+                }+            }+            previewErrors = rowErrors++            // Build active vs candidate parse summaries+            buildParseSummaries(from: projectedContract)++            state = .previewReady+        } catch {+            guard currentGeneration == generation else { return }+            errorMessage = "Unable to generate preview. Library unchanged."+            state = .error+            Self.logger.error("Preview generation failed: \(String(describing: error), privacy: .public)")+        }+    }++    public func generateArticlePreview() async {+        guard editorMode == .articles, capabilities.supportsArticles else { return }+        let currentGeneration = generation+        state = .previewing+        errorMessage = nil++        do {+            let rule = try ArticleTitleCleaner.deriveRule(+                from: entry.captureTitle,+                suffixSegmentCount: junkSuffixSegmentCount+            )+            let projected = try await library.projectArticles(+                hostname: entry.hostname,+                junkSuffixRule: rule+            )+            guard currentGeneration == generation, editorMode == .articles else {+                Self.logger.debug("Articles preview generation \(currentGeneration) superseded")+                return+            }+            articlesContract = projected+            articlePreviewPlan = projected.outcome.plan+            previewGeneration = currentGeneration+            articleValidationMessage = nil+            state = .previewReady+        } catch {+            guard currentGeneration == generation else { return }+            articleValidationMessage = error.localizedDescription+            errorMessage = "Unable to generate articles preview. Library unchanged."+            state = .error+            Self.logger.error("Articles preview failed: \(String(describing: error), privacy: .public)")+        }+    }++    // MARK: - Confirm (only commits displayed contract)++    /// Confirm the currently displayed preview contract.+    /// No commit without a current displayed contract.+    public func confirm() async {+        guard canConfirm, !isSubmitting else { return }+        isSubmitting = true+        defer { isSubmitting = false }+        state = .confirming+        errorMessage = nil++        do {+            switch editorMode {+            case .segments, .phrase:+                guard let contract else { return }+                try await handleTeachingCommit(library.commitTeaching(contract))+            case .articles:+                guard let articlesContract else { return }+                try await handleArticlesCommit(library.commitArticles(articlesContract))+            }+        } catch {+            errorMessage = editorMode == .articles+                ? "Unable to save articles mode. Library unchanged."+                : "Unable to save teaching. Library unchanged."+            state = .error+            Self.logger.error("Teaching commit failed: \(String(describing: error), privacy: .public)")+        }+    }++    /// Re-confirm after a refreshed contract.+    public func reconfirm() async {+        guard requiresReconfirmation, !isSubmitting else { return }+        isSubmitting = true+        defer { isSubmitting = false }+        state = .confirming+        errorMessage = nil++        do {+            switch editorMode {+            case .segments, .phrase:+                guard let contract else { return }+                try await handleTeachingCommit(library.commitTeaching(contract))+            case .articles:+                guard let articlesContract else { return }+                try await handleArticlesCommit(library.commitArticles(articlesContract))+            }+        } catch {+            errorMessage = "Unable to save. Library unchanged."+            state = .error+        }+    }++    // MARK: - Cancel++    public func cancel() {+        state = .cancelled+    }++    // MARK: - Private++    private func handleTeachingCommit(_ outcome: TeachingCommitOutcome) async {+        switch outcome {+        case .committed:+            state = .committed+            requiresReconfirmation = false+            await onMutation?()+            Self.logger.debug("Teaching committed for site")+        case .refreshed(let freshContract):+            contract = freshContract+            previewPlan = freshContract.outcome.plan+            previewGeneration = generation+            requiresReconfirmation = true+            state = .refreshed+            Self.logger.info("Teaching refreshed — requires re-confirmation")+        case .invalidated(let reason):+            invalidationReason = reason+            requiresReconfirmation = false+            state = .invalidated+        }+    }++    private func handleArticlesCommit(_ outcome: ArticlesCommitOutcome) async {+        switch outcome {+        case .committed:+            state = .committed+            requiresReconfirmation = false+            await onMutation?()+            Self.logger.debug("Articles mode committed for site")+        case .refreshed(let freshContract):+            articlesContract = freshContract+            articlePreviewPlan = freshContract.outcome.plan+            previewGeneration = generation+            requiresReconfirmation = true+            state = .refreshed+            Self.logger.info("Articles preview refreshed — requires re-confirmation")+        case .invalidated(let reason):+            invalidationReason = reason+            requiresReconfirmation = false+            state = .invalidated+        }+    }++    private func invalidatePreview() {+        let signpostID = Self.performanceSignposter.makeSignpostID()+        let signpostState = Self.performanceSignposter.beginInterval(+            "TeachingEditAcknowledgement",+            id: signpostID+        )+        defer {+            Self.performanceSignposter.endInterval("TeachingEditAcknowledgement", signpostState)+        }+        generation += 1+        contract = nil+        articlesContract = nil+        previewPlan = nil+        articlePreviewPlan = nil+        previewErrors = [:]+        parseComparisons = []+        requiresReconfirmation = false+        if state == .previewReady || state == .previewing {+            state = .ready+        }+    }++    private func revalidate() {+        guard segments.count >= 2 else {+            validationError = .noWorkSegment+            return+        }+        let assignment = SegmentRoleAssignment(roles: roles)+        let result = TeachingValidator.validate(assignment: assignment, segments: segments)+        switch result {+        case .success:+            validationError = nil+        case .failure(let error):+            validationError = error+        }+    }++    private func revalidatePhrase() {+        do {+            let definition = try PhrasePatternDeriver.derive(+                from: exampleTitle,+                selection: phraseSelection+            )+            try capabilities.validate(patternDefinition: definition)+            phraseValidationMessage = nil+        } catch {+            phraseValidationMessage = error.localizedDescription+        }+    }++    private func buildRuleSummary(_ pattern: PatternDefinition) -> String {+        PatternSummaryFormatter.summary(for: pattern)+    }++    private func buildParseSummaries(from contract: TeachingContract) {+        guard case .replacement = mode,+              let activePattern = contract.basis.patterns.first(where: \.isActive) else {+            parseComparisons = []+            return+        }++        let projectionsByID = Dictionary(+            uniqueKeysWithValues: contract.outcome.plan.entryProjections.map { ($0.entryID, $0) }+        )+        parseComparisons = contract.basis.entries.compactMap { basisEntry in+            guard let candidateProjection = projectionsByID[basisEntry.id] else { return nil }+            switch TitlePatternApplicator.apply(definition: activePattern.definition, to: basisEntry.captureTitle) {+            case .success(let result):+                return ParseComparison(+                    entryID: basisEntry.id,+                    activeResult: result,+                    activeFailure: nil,+                    candidateProjection: candidateProjection+                )+            case .failure(let error):+                return ParseComparison(+                    entryID: basisEntry.id,+                    activeResult: nil,+                    activeFailure: error.localizedDescription,+                    candidateProjection: candidateProjection+                )+            }+        }+    }+}

diff --git a/Asterism/Asterism/Views/EntryDetailView.swift b/Asterism/Asterism/Views/EntryDetailView.swiftindex f4e2947..62ce089 100644--- a/Asterism/Asterism/Views/EntryDetailView.swift+++ b/Asterism/Asterism/Views/EntryDetailView.swift@@ -1,10 +1,14 @@ import AsterismCore import SwiftUI -/// Entry detail: shows entry metadata and provides note/rating editing, assignment, and delete.+/// Entry detail: shows entry metadata and provides note/rating editing, assignment,+/// teaching/re-parse actions, provenance disclosure, and delete. struct EntryDetailView: View {     @State private var model: EntryDetailModel     @Environment(\.dismiss) private var dismiss+    @State private var showingTeaching = false+    @State private var showingReteach = false+    @State private var showingReparse = false     let onMoveTo: () -> Void      init(model: EntryDetailModel, onMoveTo: @escaping () -> Void) {@@ -40,7 +44,7 @@ struct EntryDetailView: View {         Form {             Section("Details") {                 LabeledContent("Title") {-                    Text(entry.captureTitle)+                    Text(model.teachingDetail?.displayTitle ?? entry.captureTitle)                         .font(AsterismTypography.serifTitle(17))                 }                 .accessibilityIdentifier("entry-detail-title")@@ -62,6 +66,20 @@ struct EntryDetailView: View {                 }             } +            if model.supportsTitleRecovery,+               let detail = model.teachingDetail,+               !detail.availableActions.isEmpty {+                Section("Title Recovery") {+                    ForEach(detail.availableActions, id: \.self) { action in+                        actionButton(for: action)+                    }+                }+            }++            // Keep immutable evidence and provenance reachable without requiring+            // the reader to scroll past editable fields and destructive actions.+            provenanceSection(entry)+             Section("Note") {                 TextEditor(text: $model.draftNote)                     .frame(minHeight: 80)@@ -111,6 +129,51 @@ struct EntryDetailView: View {                 .accessibilityIdentifier("entry-detail-delete-button")             }         }+        .sheet(isPresented: $showingTeaching) {+            if let teachModel = model.teachingModel() {+                TeachingView(model: teachModel)+            }+        }+        .sheet(isPresented: $showingReteach) {+            if let reteachModel = model.reteachModel() {+                TeachingView(model: reteachModel)+            }+        }+        .sheet(isPresented: $showingReparse) {+            if let reparseModel = model.reparseModel() {+                ReparseView(model: reparseModel)+            }+        }+    }++    @ViewBuilder+    private func actionButton(for action: EntryDetailAction) -> some View {+        switch action {+        case .teach:+            Button("Teach") {+                showingTeaching = true+            }+            .disabled(model.state == .submitting)+            .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+            .accessibilityIdentifier("entry-detail-teach-button")+            .accessibilityLabel("Teach title pattern for this site")+        case .reTeach:+            Button("Re-teach") {+                showingReteach = true+            }+            .disabled(model.state == .submitting)+            .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+            .accessibilityIdentifier("entry-detail-reteach-button")+            .accessibilityLabel("Re-teach title pattern for this site")+        case .reParse:+            Button("Re-parse") {+                showingReparse = true+            }+            .disabled(model.state == .submitting)+            .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+            .accessibilityIdentifier("entry-detail-reparse-button")+            .accessibilityLabel("Re-parse title with current pattern")+        }     }      @ViewBuilder@@ -136,4 +199,135 @@ struct EntryDetailView: View {         .accessibilityLabel(rating == .up ? "Rate up" : "Rate down")         .accessibilityAddTraits(isSelected ? .isSelected : [])     }++    // MARK: - Provenance disclosure++    @ViewBuilder+    private func provenanceSection(_ entry: EntrySnapshot) -> some View {+        Section {+            DisclosureGroup {+                VStack(alignment: .leading, spacing: 8) {+                    LabeledContent("Capture Title") {+                        Text(entry.captureTitle)+                            .font(.caption)+                    }+                    .accessibilityIdentifier("provenance-capture-title")++                    LabeledContent("Source") {+                        Text(entry.captureTitleSource.rawValue)+                            .font(.caption)+                    }+                    .accessibilityIdentifier("provenance-title-source")++                    LabeledContent("URL") {+                        Text(entry.rawURLString)+                            .font(.caption)+                            .lineLimit(2)+                    }+                    .accessibilityIdentifier("provenance-raw-url")++                    if let canonical = entry.canonicalURLString {+                        LabeledContent("Canonical URL") {+                            Text(canonical)+                                .font(.caption)+                                .lineLimit(2)+                        }+                        .accessibilityIdentifier("provenance-canonical-url")+                    }++                    // Chapter provenance with settlement reason+                    LabeledContent("Chapter") {+                        Text(entry.chapterTitle ?? "—")+                            .font(.caption)+                    }+                    .accessibilityIdentifier("provenance-chapter")++                    if let detail = model.teachingDetail {+                        LabeledContent("Chapter Settlement") {+                            Text(settlementLabel(detail.chapterSettlement))+                                .font(.caption)+                        }+                        .accessibilityIdentifier("provenance-chapter-settlement")++                        LabeledContent("Assignment Settlement") {+                            Text(settlementLabel(detail.assignmentSettlement))+                                .font(.caption)+                        }+                        .accessibilityIdentifier("provenance-assignment-settlement")++                        // Active pattern summary+                        if let active = detail.activePatternSummary {+                            patternSummaryView(active, label: "Active Pattern")+                        }++                        // Historical pattern summaries+                        ForEach(Array(detail.historicalPatternSummaries.enumerated()), id: \.offset) { index, summary in+                            patternSummaryView(summary, label: "Historical Pattern \(index + 1)")+                        }+                    } else {+                        // Fallback when detail not yet loaded+                        LabeledContent("Chapter Provenance") {+                            Text(provenanceKindLabel(entry.chapterTitleProvenance))+                                .font(.caption)+                        }+                        .accessibilityIdentifier("provenance-chapter-kind")++                        LabeledContent("Assignment Provenance") {+                            Text(provenanceKindLabel(entry.workAssignmentProvenance))+                                .font(.caption)+                        }+                        .accessibilityIdentifier("provenance-assignment-kind")+                    }+                }+            } label: {+                Text("Provenance")+                    .font(.subheadline)+            }+        }+        .accessibilityIdentifier("entry-detail-provenance")+    }++    @ViewBuilder+    private func patternSummaryView(_ summary: PatternRuleSummary, label: String) -> some View {+        VStack(alignment: .leading, spacing: 4) {+            Text(label)+                .font(.caption2)+                .foregroundStyle(.secondary)+            Text(summary.plainLanguageRule)+                .font(.caption)+            HStack {+                Text("ID: \(summary.id.uuidString.prefix(8))…")+                    .font(.caption2.monospaced())+                    .foregroundStyle(.secondary)+                Text("v\(summary.version)")+                    .font(.caption2.monospaced())+                    .foregroundStyle(.secondary)+                if summary.isActive {+                    Text("active")+                        .font(.caption2)+                        .foregroundStyle(.green)+                }+            }+        }+        .accessibilityIdentifier("provenance-pattern-\(summary.id.uuidString.prefix(8))")+    }++    private func settlementLabel(_ settlement: FieldSettlement) -> String {+        switch settlement {+        case .patternSettled(let patternID, let version):+            "Pattern settled (ID: \(patternID.uuidString.prefix(8))…, v\(version))"+        case .manualProtected(let reason):+            "Protected: \(reason)"+        case .unsettled(let reason):+            "Unsettled: \(reason)"+        }+    }++    private func provenanceKindLabel(_ provenance: FieldProvenance) -> String {+        switch provenance.kind {+        case .none: "None (unsettled)"+        case .pattern: "Pattern (settled)"+        case .manual: "Manual (protected)"+        }+    } }

diff --git a/Asterism/Asterism/Views/RecentView.swift b/Asterism/Asterism/Views/RecentView.swiftindex 264668e..7481659 100644--- a/Asterism/Asterism/Views/RecentView.swift+++ b/Asterism/Asterism/Views/RecentView.swift@@ -2,12 +2,42 @@ import AsterismCore import SwiftUI  /// Recent tab: shows all entries grouped by day, ordered by lastSharedAt descending.+/// Built from an immutable RecentPresentation DTO (repository-owned derivation).+/// Banner is a 44pt Button that toggles actionable-only filtering.+/// Rows show Work display title (not raw capture title), inline Teach/Re-teach action+/// that opens TeachingView directly. struct RecentView: View {-    let groups: [DatedEntryGroup]+    let presentation: RecentPresentation+    let capabilities: M2Capabilities     let onSelect: (UUID) -> Void+    let onTeach: ((UUID) -> Void)?++    @State private var showingActionableOnly = false++    init(+        presentation: RecentPresentation,+        capabilities: M2Capabilities = .current,+        onSelect: @escaping (UUID) -> Void,+        onTeach: ((UUID) -> Void)? = nil+    ) {+        self.presentation = presentation+        self.capabilities = capabilities+        self.onSelect = onSelect+        self.onTeach = onTeach+    }++    /// Filtered groups respecting actionable-only toggle while preserving order.+    private var displayGroups: [RecentPresentationGroup] {+        guard showingActionableOnly else { return presentation.groups }+        return presentation.groups.compactMap { group in+            let filtered = group.rows.filter(\.isActionable)+            guard !filtered.isEmpty else { return nil }+            return RecentPresentationGroup(day: group.day, rows: filtered)+        }+    }      var body: some View {-        if groups.isEmpty {+        if presentation.groups.isEmpty {             ContentUnavailableView(                 "No captures yet",                 systemImage: "clock",@@ -15,77 +45,222 @@ struct RecentView: View {             )             .accessibilityIdentifier("recent-empty")         } else {-            List {-                ForEach(groups, id: \.day) { group in-                    Section {-                        ForEach(group.entries, id: \.id) { entry in-                            Button {-                                onSelect(entry.id)-                            } label: {-                                RecentEntryRow(entry: entry)-                                    .contentShape(Rectangle())+            VStack(spacing: 0) {+                // Actionable banner as 44pt Button (Audit §2)+                if capabilities.supportsSegmentTeaching && presentation.actionableCount > 0 {+                    actionableBanner+                }++                List {+                    ForEach(displayGroups, id: \.day) { group in+                        Section {+                            ForEach(group.rows) { row in+                                RecentEntryRow(+                                    row: row,+                                    onSelect: onSelect,+                                    onTeach: onTeach+                                )                             }-                            .buttonStyle(.plain)-                            .accessibilityIdentifier("recent-entry-\(entry.id.uuidString)")-                            .accessibilityLabel("Open entry \(entry.captureTitle) from \(entry.hostname)")+                        } header: {+                            Text(group.day, style: .date)+                                .font(AsterismTypography.sectionHeader)+                                .textCase(.uppercase)+                                .accessibilityIdentifier("recent-section-header")                         }-                    } header: {-                        Text(group.day, style: .date)-                            .font(AsterismTypography.sectionHeader)-                            .textCase(.uppercase)-                            .accessibilityIdentifier("recent-section-header")                     }                 }+                .listStyle(.plain)+                .accessibilityIdentifier("recent-list")+            }+            .onChange(of: presentation.actionableCount) { _, newCount in+                if newCount == 0 {+                    showingActionableOnly = false+                }             }-            .listStyle(.plain)-            .accessibilityIdentifier("recent-list")         }     }++    private var actionableBanner: some View {+        Button {+            if showingActionableOnly {+                showingActionableOnly = false+            } else {+                showingActionableOnly = true+            }+        } label: {+            HStack(spacing: 6) {+                Image(systemName: showingActionableOnly ? "line.3.horizontal.decrease.circle.fill" : "star.fill")+                    .font(.caption)+                    .foregroundStyle(AsterismColors.amberDark)+                    .accessibilityHidden(true)+                Text(showingActionableOnly+                    ? "Showing \(presentation.actionableCount) actionable"+                    : "\(presentation.actionableCount) entries need teaching")+                    .font(.caption)+                    .foregroundStyle(AsterismColors.amberDark)+                Spacer()+                if showingActionableOnly {+                    Text("Show All")+                        .font(.caption.bold())+                        .foregroundStyle(AsterismColors.amberDark)+                }+            }+            .padding(.horizontal)+            .frame(minHeight: 44)+            .background(AsterismColors.amberDark.opacity(0.1))+        }+        .buttonStyle(.plain)+        .accessibilityElement(children: .combine)+        .accessibilityIdentifier("actionable-banner")+        .accessibilityLabel(showingActionableOnly+            ? "Showing \(presentation.actionableCount) actionable entries. Tap to show all."+            : "\(presentation.actionableCount) entries need teaching. Tap to filter.")+    } } -/// A single row in the Recent list: raw capture title, hostname, note preview,-/// last-shared time, and rating. Normal treatment in M1 — no amber.+/// A single row in the Recent list: shows Work display title for taught entries,+/// raw capture title for untaught. Actionable rows show amber treatment with+/// inline Teach/Re-teach pill that opens TeachingView directly. struct RecentEntryRow: View {-    let entry: EntrySnapshot+    let row: RecentPresentationRow+    let onSelect: (UUID) -> Void+    let onTeach: ((UUID) -> Void)?++    init(+        row: RecentPresentationRow,+        onSelect: @escaping (UUID) -> Void,+        onTeach: ((UUID) -> Void)? = nil+    ) {+        self.row = row+        self.onSelect = onSelect+        self.onTeach = onTeach+    }++    private var accessibilityTitle: String {+        let workTitle = row.workDisplayTitle ?? row.unresolvedCandidateTitle+        switch (workTitle, row.chapterTitle) {+        case let (work?, chapter?):+            return "\(work), \(chapter)"+        case let (work?, nil):+            return work+        case let (nil, chapter?):+            return chapter+        case (nil, nil):+            return row.captureTitle+        }+    }      var body: some View {+        // Navigation and teaching are sibling buttons. Nesting the Teach button in+        // the navigation button makes SwiftUI route the tap to the outer action.+        HStack(alignment: .top, spacing: 8) {+            Button {+                onSelect(row.id)+            } label: {+                entryContent+                    .frame(maxWidth: .infinity, alignment: .leading)+                    .contentShape(Rectangle())+            }+            .buttonStyle(.plain)+            .frame(maxWidth: .infinity, alignment: .leading)+            .accessibilityIdentifier("recent-entry-\(row.id.uuidString)")+            .accessibilityLabel("Open entry \(accessibilityTitle) from \(row.hostname)")++            if row.isActionable, row.actionType != .none, let onTeach {+                Button {+                    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())+                }+                .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)+        .frame(minHeight: AsterismLayout.minHitTarget)+        .overlay {+            if row.isActionable {+                RoundedRectangle(cornerRadius: 6)+                    .stroke(AsterismColors.amberDark.opacity(0.3), lineWidth: 1)+                    .allowsHitTesting(false)+            }+        }+    }++    private var entryContent: some View {         VStack(alignment: .leading, spacing: 4) {-            // Title in serif (work title style for raw capture title)-            Text(entry.captureTitle)-                .font(AsterismTypography.serifTitle(15))-                .lineLimit(1)-                .accessibilityIdentifier("entry-title")+            HStack {+                // Show Work display title if available, else capture title+                Text(row.workDisplayTitle ?? row.captureTitle)+                    .font(AsterismTypography.serifTitle(15))+                    .lineLimit(1)+                    .foregroundStyle(row.isActionable ? AsterismColors.amberDark : .primary)+                    .accessibilityIdentifier("entry-title")++                Spacer()+            }++            // Chapter for taught entries+            if let chapterTitle = row.chapterTitle {+                Text(chapterTitle)+                    .font(.caption)+                    .foregroundStyle(AsterismColors.cyanDark)+                    .lineLimit(1)+                    .accessibilityIdentifier("entry-chapter")+            }++            // Actionable unresolved candidate+            if row.isActionable, let candidate = row.unresolvedCandidateTitle {+                HStack(spacing: 4) {+                    Image(systemName: "exclamationmark.triangle")+                        .font(.caption2)+                        .foregroundStyle(AsterismColors.amberDark)+                        .accessibilityHidden(true)+                    Text(candidate)+                        .font(.caption)+                        .foregroundStyle(AsterismColors.amberDark)+                        .lineLimit(1)+                }+                .accessibilityIdentifier("entry-unresolved-candidate")+            }              HStack(spacing: 6) {-                Text(entry.hostname)+                Text(row.hostname)                     .font(.caption)                     .foregroundStyle(.secondary)                     .accessibilityIdentifier("entry-hostname")                  Spacer() -                if let rating = entry.rating {+                if let rating = row.rating {                     Text(rating == .up ? "▲" : "▼")                         .font(.caption)                         .foregroundStyle(rating == .up ? AsterismColors.cyanDark : AsterismColors.violetDark)                         .accessibilityIdentifier("entry-rating")                 } -                Text(entry.lastSharedAt, style: .time)+                Text(row.lastSharedAt, style: .time)                     .font(.caption2)                     .foregroundStyle(.secondary)                     .accessibilityIdentifier("entry-time")             } -            if !entry.note.isEmpty {-                Text(entry.note)+            if !row.note.isEmpty {+                Text(row.note)                     .font(.caption)                     .foregroundStyle(.tertiary)                     .lineLimit(2)                     .accessibilityIdentifier("entry-note-preview")             }         }-        .padding(.vertical, 4)-        .frame(minHeight: AsterismLayout.minHitTarget)     } }

diff --git a/Asterism/Asterism/Views/ReparseView.swift b/Asterism/Asterism/Views/ReparseView.swiftnew file mode 100644index 0000000..933a96c--- /dev/null+++ b/Asterism/Asterism/Views/ReparseView.swift@@ -0,0 +1,254 @@+import AsterismCore+import SwiftUI++/// Re-parse sheet: shows before→after chapter, Work outcome,+/// projected provenance, manual/intentional protections, and+/// ambiguous candidates. Confirm/Cancel actions with 44pt targets.+struct ReparseView: View {+    @State private var model: ReparseViewModel+    @Environment(\.dismiss) private var dismiss++    init(model: ReparseViewModel) {+        _model = State(initialValue: model)+    }++    var body: some View {+        NavigationStack {+            Group {+                switch model.state {+                case .loading:+                    ProgressView("Projecting re-parse…")+                        .accessibilityIdentifier("reparse-loading")+                case .projected, .refreshed:+                    projectionContent+                case .confirming:+                    ProgressView("Committing…")+                        .accessibilityIdentifier("reparse-confirming")+                case .committed:+                    committedContent+                case .invalidated(let reason):+                    invalidatedContent(reason: reason)+                case .error(let message):+                    errorContent(message: message)+                }+            }+            .navigationTitle("Re-parse")+            .navigationBarTitleDisplayMode(.inline)+            .toolbar {+                ToolbarItem(placement: .cancellationAction) {+                    Button("Cancel") { dismiss() }+                        .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+                        .accessibilityIdentifier("reparse-cancel-button")+                }+            }+            .task { await model.load() }+        }+    }++    @ViewBuilder+    private var projectionContent: some View {+        Form {+            // Before/After chapter+            if let projection = model.projection, let before = model.entryBefore {+                Section("Chapter") {+                    LabeledContent("Before") {+                        Text(before.chapterTitle ?? "—")+                            .font(.caption)+                    }+                    .accessibilityIdentifier("reparse-chapter-before")++                    LabeledContent("After") {+                        Text(projection.projectedChapter ?? "—")+                            .font(.caption)+                    }+                    .accessibilityIdentifier("reparse-chapter-after")+                }++                // Work outcome+                Section("Work Assignment") {+                    if let workTitle = projection.projectedWorkTitle {+                        LabeledContent("Projected Work") {+                            Text(workTitle)+                                .font(.caption)+                        }+                        .accessibilityIdentifier("reparse-work-title")+                    }++                    if let outcome = projection.workOutcome {+                        LabeledContent("Outcome") {+                            Text(workOutcomeLabel(outcome))+                                .font(.caption)+                        }+                        .accessibilityIdentifier("reparse-work-outcome")+                    }++                    if let workID = projection.projectedWorkID {+                        LabeledContent("Work ID") {+                            Text(workID.uuidString.prefix(8) + "…")+                                .font(.caption.monospaced())+                        }+                        .accessibilityIdentifier("reparse-work-id")+                    }+                }++                // Protections+                if projection.chapterProtected || projection.assignmentProtected {+                    Section("Protections") {+                        if projection.chapterProtected {+                            Label("Chapter: manual protection (preserved)", systemImage: "lock.fill")+                                .font(.caption)+                                .accessibilityIdentifier("reparse-chapter-protected")+                        }+                        if projection.assignmentProtected {+                            Label("Assignment: manual/intentional protection (preserved)", systemImage: "lock.fill")+                                .font(.caption)+                                .accessibilityIdentifier("reparse-assignment-protected")+                        }+                    }+                }++                // Provenance+                Section("Projected Provenance") {+                    LabeledContent("Chapter Provenance") {+                        Text(provenanceLabel(projection.chapterProvenance))+                            .font(.caption)+                    }+                    .accessibilityIdentifier("reparse-chapter-provenance")++                    LabeledContent("Assignment Provenance") {+                        Text(provenanceLabel(projection.assignmentProvenance))+                            .font(.caption)+                    }+                    .accessibilityIdentifier("reparse-assignment-provenance")+                }++                // Parse errors+                if let parseFailure = projection.parseFailure {+                    Section("Parse Error") {+                        Text(String(describing: parseFailure))+                            .font(.caption)+                            .foregroundStyle(.red)+                            .accessibilityIdentifier("reparse-parse-error")+                    }+                }++                // Ambiguous candidates+                if model.hasAmbiguity {+                    Section("Ambiguous Work Candidates") {+                        Text("Multiple Works match the parsed title. Assignment will remain unresolved.")+                            .font(.caption)+                            .foregroundStyle(.orange)+                            .accessibilityIdentifier("reparse-ambiguity-warning")+                    }+                }++                // Works to create+                if !model.worksToCreate.isEmpty {+                    Section("Works to Create") {+                        ForEach(model.worksToCreate, id: \.self) { title in+                            Text(title)+                                .font(.caption)+                        }+                    }+                    .accessibilityIdentifier("reparse-works-to-create")+                }+            }++            // Confirm / Reconfirm+            Section {+                if model.requiresReconfirmation {+                    Button("Reconfirm") {+                        Task { await model.reconfirm() }+                    }+                    .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+                    .accessibilityIdentifier("reparse-reconfirm-button")++                    Text("The projection was refreshed. Please review and reconfirm.")+                        .font(.caption)+                        .foregroundStyle(.orange)+                } else {+                    Button("Confirm") {+                        Task { await model.confirm() }+                    }+                    .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+                    .accessibilityIdentifier("reparse-confirm-button")+                }+            }+        }+    }++    @ViewBuilder+    private var committedContent: some View {+        VStack(spacing: 16) {+            Image(systemName: "checkmark.circle.fill")+                .font(.largeTitle)+                .foregroundStyle(.green)+            Text("Re-parse committed successfully.")+            Button("Done") { dismiss() }+                .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+                .accessibilityIdentifier("reparse-done-button")+        }+        .padding()+    }++    @ViewBuilder+    private func invalidatedContent(reason: String) -> some View {+        VStack(spacing: 16) {+            Image(systemName: "exclamationmark.triangle.fill")+                .font(.largeTitle)+                .foregroundStyle(.orange)+            Text("Re-parse invalidated")+                .font(.headline)+            Text(reason)+                .font(.caption)+                .foregroundStyle(.secondary)+            Text("No changes were made.")+                .font(.caption)+            Button("Dismiss") { dismiss() }+                .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+                .accessibilityIdentifier("reparse-dismiss-button")+        }+        .padding()+    }++    @ViewBuilder+    private func errorContent(message: String) -> some View {+        VStack(spacing: 16) {+            Image(systemName: "xmark.circle.fill")+                .font(.largeTitle)+                .foregroundStyle(.red)+            Text("Error")+                .font(.headline)+            Text(message)+                .font(.caption)+                .foregroundStyle(.secondary)+            Button("Dismiss") { dismiss() }+                .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+                .accessibilityIdentifier("reparse-error-dismiss-button")+        }+        .padding()+    }++    // MARK: - Helpers++    private func workOutcomeLabel(_ outcome: WorkMatchOutcome) -> String {+        switch outcome {+        case .reuse(let workID): "Reuse (Work \(workID.uuidString.prefix(8))…)"+        case .create(let title): "Create new Work '\(title)'"+        case .ambiguous: "Ambiguous (unassigned)"+        }+    }++    private func provenanceLabel(_ provenance: ProjectedProvenance) -> String {+        switch provenance {+        case .preserved(let fp):+            switch fp.kind {+            case .none: "None (preserved)"+            case .pattern: "Pattern v\(fp.patternVersion ?? 0) (preserved)"+            case .manual: "Manual (preserved)"+            }+        case .cleared: "Cleared"+        case .pendingPattern(let p): "Pending pattern v\(p.patternVersion)"+        }+    }+}

diff --git a/Asterism/Asterism/Views/TeachingView.swift b/Asterism/Asterism/Views/TeachingView.swiftnew file mode 100644index 0000000..e1d2ef7--- /dev/null+++ b/Asterism/Asterism/Views/TeachingView.swift@@ -0,0 +1,866 @@+import AsterismCore+import SwiftUI++/// Teaching view: presents segment chips with role cycling, legend, preview,+/// rule summary, and confirm/cancel actions.+struct TeachingView: View {+    @State private var model: TeachingViewModel+    @Environment(\.dismiss) private var dismiss++    init(model: TeachingViewModel) {+        _model = State(initialValue: model)+    }++    var body: some View {+        NavigationStack {+            ScrollView {+                VStack(spacing: 20) {+                    content+                }+                .padding()+            }+            .navigationTitle("Teach Pattern")+            .navigationBarTitleDisplayMode(.inline)+            .toolbar {+                ToolbarItem(placement: .cancellationAction) {+                    Button("Cancel") {+                        model.cancel()+                        dismiss()+                    }+                    .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+                    .accessibilityIdentifier("teaching-cancel-button")+                }+            }+            .accessibilityElement(children: .contain)+            .accessibilityIdentifier("teaching-view")+        }+        .task { await model.load() }+    }++    @ViewBuilder+    private var content: some View {+        switch model.state {+        case .loading:+            ProgressView("Analyzing title…")+                .accessibilityIdentifier("teaching-loading")+        case .ready:+            readyContent+        case .previewing:+            VStack(spacing: 16) {+                readyContent+                ProgressView("Generating preview…")+                    .accessibilityIdentifier("teaching-previewing")+            }+        case .previewReady:+            previewReadyContent+        case .confirming:+            ProgressView("Saving…")+                .accessibilityIdentifier("teaching-confirming")+        case .committed:+            committedContent+        case .refreshed:+            refreshedContent+        case .invalidated:+            invalidatedContent+        case .error:+            errorContent+        case .cancelled:+            EmptyView()+        }+    }++    // MARK: - Ready state++    @ViewBuilder+    private var readyContent: some View {+        // Title example+        titleExampleSection++        editorModeSection++        switch model.editorMode {+        case .segments:+            segmentChipsSection+            legendSection++            if let error = model.validationError {+                validationBanner(error)+            }++            if let summary = model.patternRuleSummary {+                ruleSummarySection(summary)+            }+        case .phrase:+            phraseEditorSection+            if let summary = model.patternRuleSummary {+                ruleSummarySection(summary)+            }+        case .articles:+            articlesEditorSection+        }+    }++    // MARK: - Preview ready (two-stage: preview displayed, confirm enabled)++    @ViewBuilder+    private var previewReadyContent: some View {+        // Title example+        titleExampleSection+        editorModeSection++        switch model.editorMode {+        case .segments:+            segmentChipsSection+            legendSection++            if let summary = model.patternRuleSummary {+                ruleSummarySection(summary)+            }++            if let plan = model.previewPlan {+                previewSection(plan)+            }++            if !model.previewErrors.isEmpty {+                previewErrorsSection+            }+        case .phrase:+            phraseEditorSection+            if let summary = model.patternRuleSummary {+                ruleSummarySection(summary)+            }+            if let plan = model.previewPlan {+                previewSection(plan)+            }+            if !model.previewErrors.isEmpty {+                previewErrorsSection+            }+        case .articles:+            articlesEditorSection+            if let plan = model.articlePreviewPlan {+                articlesPreviewSection(plan)+            }+        }++        confirmButton+    }++    // MARK: - Title example++    private var titleExampleSection: some View {+        VStack(alignment: .leading, spacing: 4) {+            Text("Example Title")+                .font(.caption)+                .foregroundStyle(.secondary)+            Text(model.exampleTitle)+                .font(AsterismTypography.serifTitle(15))+                .accessibilityIdentifier("teaching-example-title")+        }+        .frame(maxWidth: .infinity, alignment: .leading)+    }++    // MARK: - Editor mode++    private var editorModeSection: some View {+        HStack(spacing: 12) {+            Button {+                model.selectSegmentsMode()+            } label: {+                Text("Segments")+                    .frame(minHeight: AsterismLayout.minHitTarget)+            }+                .buttonStyle(.bordered)+                .tint(model.editorMode == .segments ? AsterismColors.cyanDark : .secondary)+                .frame(minHeight: AsterismLayout.minHitTarget)+                .accessibilityIdentifier("segment-teaching-button")+                .accessibilityLabel("Teach a delimiter segment pattern")+                .accessibilityAddTraits(model.editorMode == .segments ? .isSelected : [])++            if model.supportsPhraseTeaching {+                Button {+                    model.selectPhraseMode()+                } label: {+                    Text("Phrase")+                        .frame(minHeight: AsterismLayout.minHitTarget)+                }+                    .buttonStyle(.bordered)+                    .tint(model.editorMode == .phrase ? AsterismColors.cyanDark : .secondary)+                    .frame(minHeight: AsterismLayout.minHitTarget)+                    .accessibilityIdentifier("phrase-teaching-button")+                    .accessibilityLabel("Teach an exact phrase template")+                    .accessibilityAddTraits(model.editorMode == .phrase ? .isSelected : [])+            }++            if model.supportsArticles {+                Button {+                    model.selectArticlesMode()+                } label: {+                    Text("Articles")+                        .frame(minHeight: AsterismLayout.minHitTarget)+                }+                    .buttonStyle(.bordered)+                    .tint(model.editorMode == .articles ? AsterismColors.amberDark : .secondary)+                    .frame(minHeight: AsterismLayout.minHitTarget)+                    .accessibilityIdentifier("articles-mode-button")+                    .accessibilityLabel("Use articles mode for this site")+                    .accessibilityAddTraits(model.editorMode == .articles ? .isSelected : [])+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .accessibilityElement(children: .contain)+    }++    private var phraseEditorSection: some View {+        VStack(alignment: .leading, spacing: 12) {+            Text("Set Chapter and Work boundaries one character at a time. The text before, between, and after them is matched exactly.")+                .font(.caption)+                .foregroundStyle(.secondary)++            phraseSelectionCard(role: .chapter, label: "Chapter")+            phraseSelectionCard(role: .work, label: "Work")++            if let message = model.phraseValidationMessage {+                Text(message)+                    .font(.caption)+                    .foregroundStyle(.red)+                    .accessibilityIdentifier("phrase-validation-error")+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(12)+        .background(.fill.quaternary)+        .clipShape(RoundedRectangle(cornerRadius: 8))+        .accessibilityElement(children: .contain)+        .accessibilityIdentifier("phrase-editor")+    }++    private func phraseSelectionCard(role: PhraseFieldRole, label: String) -> some View {+        VStack(alignment: .leading, spacing: 8) {+            Text("\(label): \(model.selectedText(for: role))")+                .font(.caption.bold())+                .frame(maxWidth: .infinity, alignment: .leading)+                .accessibilityIdentifier("phrase-\(role.rawValue)-selection")++            phraseBoundaryControl(role: role, boundary: .start, label: "Start")+            phraseBoundaryControl(role: role, boundary: .end, label: "End")+        }+        .padding(8)+        .overlay(RoundedRectangle(cornerRadius: 6).stroke(.secondary.opacity(0.25)))+    }++    private func phraseBoundaryControl(+        role: PhraseFieldRole,+        boundary: TeachingViewModel.PhraseBoundary,+        label: String+    ) -> some View {+        HStack(spacing: 8) {+            Text(label)+                .font(.caption)+                .frame(maxWidth: .infinity, alignment: .leading)++            Button {+                model.adjustPhraseBoundary(role, boundary: boundary, direction: .backward)+            } label: {+                Image(systemName: "chevron.left")+                    .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+            }+            .accessibilityLabel("Move \(role.rawValue) \(label.lowercased()) backward one character")++            Button {+                model.adjustPhraseBoundary(role, boundary: boundary, direction: .forward)+            } label: {+                Image(systemName: "chevron.right")+                    .frame(minWidth: AsterismLayout.minHitTarget, minHeight: AsterismLayout.minHitTarget)+            }+            .accessibilityLabel("Move \(role.rawValue) \(label.lowercased()) forward one character")+        }+        .accessibilityElement(children: .contain)+        .accessibilityLabel(model.phraseBoundaryAnnouncement(for: role, boundary: boundary))+        .accessibilityAdjustableAction { direction in+            switch direction {+            case .increment:+                model.adjustPhraseBoundary(role, boundary: boundary, direction: .forward)+            case .decrement:+                model.adjustPhraseBoundary(role, boundary: boundary, direction: .backward)+            @unknown default:+                break+            }+        }+        .accessibilityIdentifier("phrase-\(role.rawValue)-\(label.lowercased())-control")+    }++    private var articlesEditorSection: some View {+        VStack(alignment: .leading, spacing: 12) {+            Text("Treat every page as an independent article. Manual fields are preserved; pattern-derived fields are cleared.")+                .font(.caption)+                .foregroundStyle(.secondary)++            Stepper(+                "Remove last \(model.junkSuffixSegmentCount) title segment(s)",+                value: Binding(+                    get: { model.junkSuffixSegmentCount },+                    set: { model.setJunkSuffixSegmentCount($0) }+                ),+                in: 0...max(0, model.segments.count - 1)+            )+            .frame(minHeight: AsterismLayout.minHitTarget)+            .accessibilityIdentifier("articles-suffix-stepper")+            .accessibilityLabel("Junk suffix segment count: \(model.junkSuffixSegmentCount)")++            if model.junkSuffixSegmentCount > 0,+               let rule = try? ArticleTitleCleaner.deriveRule(+                   from: model.exampleTitle,+                   suffixSegmentCount: model.junkSuffixSegmentCount+               ) {+                Text("Example display: \(ArticleTitleCleaner.clean(model.exampleTitle, using: rule))")+                    .font(.caption)+                    .accessibilityIdentifier("articles-cleaned-example")+            }++            if let message = model.articleValidationMessage {+                Text(message)+                    .font(.caption)+                    .foregroundStyle(.red)+                    .accessibilityIdentifier("articles-validation-error")+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(12)+        .background(.fill.quaternary)+        .clipShape(RoundedRectangle(cornerRadius: 8))+        .accessibilityElement(children: .contain)+        .accessibilityIdentifier("articles-editor")+    }++    // MARK: - Segment chips++    private var segmentChipsSection: some View {+        VStack(alignment: .leading, spacing: 8) {+            Text("Tap each segment to assign its role")+                .font(.caption)+                .foregroundStyle(.secondary)++            FlowLayout(spacing: 8) {+                ForEach(Array(model.segments.enumerated()), id: \.offset) { index, segment in+                    SegmentChipView(+                        text: segment,+                        role: model.roles[index],+                        index: index,+                        onTap: { model.cycleRole(at: index) }+                    )+                }+            }+        }+        .accessibilityElement(children: .contain)+        .accessibilityIdentifier("teaching-segments")+    }++    // MARK: - Legend++    private var legendSection: some View {+        VStack(alignment: .leading, spacing: 6) {+            Text("Legend")+                .font(.caption.bold())+                .foregroundStyle(.secondary)++            HStack(spacing: 16) {+                legendItem(role: .chapter, symbol: "C", label: "Chapter")+                legendItem(role: .work, symbol: "W", label: "Work")+                legendItem(role: .ignore, symbol: "×", label: "Ignore")+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .accessibilityElement(children: .contain)+        .accessibilityIdentifier("teaching-legend")+    }++    private func legendItem(role: SegmentRole, symbol: String, label: String) -> some View {+        HStack(spacing: 4) {+            Text(symbol)+                .font(.caption.monospaced())+                .foregroundStyle(colorForRole(role))+                .frame(width: 20, height: 20)+                .background(colorForRole(role).opacity(0.15))+                .clipShape(Circle())+            Text(label)+                .font(.caption)+                .foregroundStyle(.secondary)+        }+        .accessibilityElement(children: .combine)+        .accessibilityLabel("\(label): \(symbol)")+    }++    // MARK: - Validation++    private func validationBanner(_ error: TeachingValidationError) -> some View {+        HStack(spacing: 8) {+            Image(systemName: "exclamationmark.triangle")+                .foregroundStyle(.orange)+                .accessibilityHidden(true)+            Text(validationMessage(for: error))+                .font(.caption)+                .foregroundStyle(.primary)+        }+        .padding(12)+        .frame(maxWidth: .infinity, alignment: .leading)+        .background(Color.orange.opacity(0.1))+        .clipShape(RoundedRectangle(cornerRadius: 8))+        .accessibilityElement(children: .combine)+        .accessibilityIdentifier("teaching-validation-error")+    }++    // MARK: - Rule summary++    private func ruleSummarySection(_ summary: String) -> some View {+        VStack(alignment: .leading, spacing: 4) {+            Text("Pattern Rule")+                .font(.caption.bold())+                .foregroundStyle(.secondary)+            Text(summary)+                .font(.caption)+                .foregroundStyle(.primary)+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(12)+        .background(.fill.quaternary)+        .clipShape(RoundedRectangle(cornerRadius: 8))+        .accessibilityIdentifier("teaching-rule-summary")+    }++    // MARK: - Confirm++    private var confirmButton: some View {+        Button {+            Task { await model.confirm() }+        } label: {+            Text(confirmTitle)+                .font(.headline)+                .frame(maxWidth: .infinity, minHeight: AsterismLayout.minHitTarget)+        }+        .buttonStyle(.borderedProminent)+        .disabled(!model.canConfirm)+        .accessibilityIdentifier("teaching-confirm-button")+        .accessibilityLabel(confirmAccessibilityLabel)+    }++    private var confirmTitle: String {+        switch model.editorMode {+        case .segments: "Confirm Segment Pattern"+        case .phrase: "Confirm Phrase Pattern"+        case .articles: "Confirm Articles Mode"+        }+    }++    private var confirmAccessibilityLabel: String {+        switch model.editorMode {+        case .segments: "Confirm segment teaching pattern"+        case .phrase: "Confirm exact phrase teaching pattern"+        case .articles: "Confirm one-way articles mode"+        }+    }++    private func articlesPreviewSection(_ plan: ArticleProjectionPlan) -> some View {+        VStack(alignment: .leading, spacing: 8) {+            Text("Articles Preview (\(plan.entryProjections.count) entries)")+                .font(.caption.bold())++            ForEach(plan.entryProjections) { projection in+                VStack(alignment: .leading, spacing: 3) {+                    Text(projection.displayTitle)+                        .font(.caption)+                    Text("Chapter: \(projection.projectedChapter ?? "cleared")")+                    Text(projection.projectedWorkID == nil ? "Work: unassigned" : "Work: manual assignment preserved")+                    Text(projection.intentionallyUnattached+                         ? "Intentionally unattached"+                         : "Manual assignment preserved")+                }+                .font(.caption2)+                .accessibilityElement(children: .combine)+                .accessibilityIdentifier("articles-preview-row-\(projection.entryID.uuidString)")+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(12)+        .background(.fill.quaternary)+        .clipShape(RoundedRectangle(cornerRadius: 8))+        .accessibilityIdentifier("articles-preview")+    }++    // MARK: - Preview plan display++    @ViewBuilder++    private func comparisonRow(_ comparison: TeachingViewModel.ParseComparison) -> some View {+        VStack(alignment: .leading, spacing: 3) {+            if let active = comparison.activeResult {+                Text("Active — Chapter: \(active.chapterTitle); Work: \(active.workTitle)")+                    .font(.caption2)+                    .foregroundStyle(.secondary)+            } else {+                Text("Active — Failed: \(comparison.activeFailure ?? "Unknown parse failure")")+                    .font(.caption2)+                    .foregroundStyle(.red)+            }+            if let failure = comparison.candidateProjection.parseFailure {+                Text("Candidate — Failed: \(failure.localizedDescription)")+                    .font(.caption2)+                    .foregroundStyle(.red)+            } else {+                Text(+                    "Candidate — Chapter: \(comparison.candidateProjection.projectedChapter ?? "cleared"); "+                        + "Work: \(comparison.candidateProjection.projectedWorkTitle ?? "unassigned")"+                )+                .font(.caption2)+                .foregroundStyle(.primary)+            }+        }+        .accessibilityElement(children: .combine)+        .accessibilityIdentifier("teaching-comparison-\(comparison.entryID.uuidString)")+    }+    private func previewSection(_ plan: ProjectionPlan) -> some View {+        VStack(alignment: .leading, spacing: 8) {+            Text("Preview (\(plan.entryProjections.count) entries)")+                .font(.caption.bold())+                .foregroundStyle(.secondary)++            if !model.parseComparisons.isEmpty {+                Text("Active vs Candidate")+                    .font(.caption.bold())+                ForEach(model.parseComparisons) { comparison in+                    comparisonRow(comparison)+                }+                Divider()+            }++            ForEach(Array(plan.entryProjections.enumerated()), id: \.offset) { index, projection in+                projectionRow(index: index, projection: projection)+            }++            if !plan.worksToCreate.isEmpty {+                HStack(spacing: 4) {+                    Image(systemName: "plus.circle")+                        .font(.caption)+                        .foregroundStyle(AsterismColors.cyanDark)+                        .accessibilityHidden(true)+                    Text("Creates: \(plan.worksToCreate.joined(separator: ", "))")+                        .font(.caption)+                        .foregroundStyle(AsterismColors.cyanDark)+                }+            }++            if plan.hasAmbiguity {+                HStack(spacing: 4) {+                    Image(systemName: "exclamationmark.triangle")+                        .font(.caption)+                        .foregroundStyle(.orange)+                        .accessibilityHidden(true)+                    Text("Some entries have ambiguous Work matches")+                        .font(.caption)+                        .foregroundStyle(.orange)+                }+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(12)+        .background(.fill.quaternary)+        .clipShape(RoundedRectangle(cornerRadius: 8))+        .accessibilityIdentifier("teaching-preview")+    }++    @ViewBuilder+    private func projectionRow(index: Int, projection: EntryProjection) -> some View {+        VStack(alignment: .leading, spacing: 3) {+            HStack(spacing: 4) {+                Text("Chapter: \(projection.projectedChapter ?? "cleared")")+                    .font(.caption)+                    .foregroundStyle(AsterismColors.cyanDark)+                    .lineLimit(1)+                if let workTitle = projection.projectedWorkTitle {+                    Text("→ \(workTitle)")+                        .font(.caption)+                        .foregroundStyle(AsterismColors.amberDark)+                        .lineLimit(1)+                }+            }++            switch projection.workOutcome {+            case .reuse(let workID):+                Text("Reuses Work \(workID.uuidString.prefix(8))…")+                    .font(.caption2)+            case .create(let parsedWorkTitle):+                Text("Creates Work: \(parsedWorkTitle)")+                    .font(.caption2)+            case .ambiguous(let candidates):+                VStack(alignment: .leading, spacing: 1) {+                    Text("Unresolved — \(candidates.count) matching Works")+                    ForEach(candidates, id: \.id) { candidate in+                        Text("• \(candidate.displayTitle) (\(candidate.id.uuidString.prefix(8))…)")+                    }+                }+                .font(.caption2)+                .foregroundStyle(.orange)+            case nil:+                Text(projection.assignmentProtected ? "Assignment preserved" : "Assignment unassigned")+                    .font(.caption2)+                    .foregroundStyle(.secondary)+            }++            HStack(spacing: 8) {+                Text("Chapter provenance: \(provenanceLabel(projection.chapterProvenance))")+                Text("Assignment provenance: \(provenanceLabel(projection.assignmentProvenance))")+            }+            .font(.caption2)+            .foregroundStyle(.secondary)++            HStack(spacing: 8) {+                if projection.chapterProtected { Text("Chapter protected") }+                if projection.assignmentProtected { Text("Assignment protected") }+                if projection.parseFailure != nil { Text("Parse failed").foregroundStyle(.red) }+                if projection.actionableAfter {+                    Text("Actionable").foregroundStyle(AsterismColors.amberDark)+                }+            }+            .font(.caption2)+            .foregroundStyle(.secondary)+        }+        .accessibilityElement(children: .combine)+        .accessibilityIdentifier("teaching-preview-row-\(index)")+    }++    private func provenanceLabel(_ provenance: ProjectedProvenance) -> String {+        switch provenance {+        case .preserved(let value): return "preserved \(value.kind.rawValue)"+        case .cleared: return "cleared"+        case .pendingPattern(let value): return "pattern v\(value.patternVersion)"+        }+    }++    @ViewBuilder+    private var previewErrorsSection: some View {+        VStack(alignment: .leading, spacing: 4) {+            Text("Preview Errors")+                .font(.caption.bold())+                .foregroundStyle(.red)+            ForEach(Array(model.previewErrors.sorted(by: { $0.key < $1.key })), id: \.key) { index, message in+                Text("Row \(index + 1): \(message)")+                    .font(.caption)+                    .foregroundStyle(.red)+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding(12)+        .background(Color.red.opacity(0.05))+        .clipShape(RoundedRectangle(cornerRadius: 8))+        .accessibilityIdentifier("teaching-preview-errors")+    }++    // MARK: - Committed++    private var committedContent: some View {+        VStack(spacing: 12) {+            Image(systemName: "checkmark.circle.fill")+                .font(.largeTitle)+                .foregroundStyle(.green)+                .accessibilityHidden(true)+            Text(model.editorMode == .articles ? "Articles mode enabled" : "Pattern taught successfully")+                .font(.headline)+            Button("Done") { dismiss() }+                .frame(minHeight: AsterismLayout.minHitTarget)+                .accessibilityIdentifier("teaching-done-button")+        }+        .frame(maxWidth: .infinity, minHeight: 200)+        .accessibilityIdentifier("teaching-committed")+    }++    // MARK: - Refreshed++    private var refreshedContent: some View {+        VStack(spacing: 16) {+            Image(systemName: "arrow.triangle.2.circlepath")+                .font(.largeTitle)+                .foregroundStyle(.orange)+                .accessibilityHidden(true)+            Text("Library changed. Review updated preview and confirm again.")+                .font(.subheadline)+                .multilineTextAlignment(.center)+            Button("Confirm Again") {+                Task { await model.reconfirm() }+            }+            .buttonStyle(.borderedProminent)+            .frame(minHeight: AsterismLayout.minHitTarget)+            .accessibilityIdentifier("teaching-reconfirm-button")+        }+        .frame(maxWidth: .infinity, minHeight: 200)+        .accessibilityIdentifier("teaching-refreshed")+    }++    // MARK: - Invalidated++    private var invalidatedContent: some View {+        VStack(spacing: 12) {+            Image(systemName: "xmark.circle")+                .font(.largeTitle)+                .foregroundStyle(.red)+                .accessibilityHidden(true)+            Text("Cannot apply pattern")+                .font(.headline)+            if let reason = model.invalidationReason {+                Text(reason)+                    .font(.subheadline)+                    .foregroundStyle(.secondary)+                    .multilineTextAlignment(.center)+            }+            Text("No changes were made to the library.")+                .font(.caption)+                .foregroundStyle(.tertiary)+            Button("Dismiss") { dismiss() }+                .frame(minHeight: AsterismLayout.minHitTarget)+                .accessibilityIdentifier("teaching-dismiss-button")+        }+        .frame(maxWidth: .infinity, minHeight: 200)+        .accessibilityIdentifier("teaching-invalidated")+    }++    // MARK: - Error++    private var errorContent: some View {+        VStack(spacing: 12) {+            Image(systemName: "exclamationmark.triangle.fill")+                .font(.largeTitle)+                .foregroundStyle(.red)+                .accessibilityHidden(true)+            if let message = model.errorMessage {+                Text(message)+                    .font(.subheadline)+                    .multilineTextAlignment(.center)+            }+            Button("Try Again") {+                Task { await model.confirm() }+            }+            .buttonStyle(.borderedProminent)+            .frame(minHeight: AsterismLayout.minHitTarget)+            .accessibilityIdentifier("teaching-retry-button")+        }+        .frame(maxWidth: .infinity, minHeight: 200)+        .accessibilityIdentifier("teaching-error")+    }++    // MARK: - Helpers++    private func colorForRole(_ role: SegmentRole) -> Color {+        switch role {+        case .chapter: AsterismColors.cyanDark+        case .work: AsterismColors.amberDark+        case .ignore: .secondary+        }+    }++    private func validationMessage(for error: TeachingValidationError) -> String {+        switch error {+        case .noWorkSegment: "Select at least one Work segment"+        case .noChapterSegment: "Select at least one Chapter segment"+        case .nonContiguousWork: "Work segments must be contiguous"+        case .nonContiguousChapter: "Chapter segments must be contiguous"+        case .workChapterOverlap: "Work and Chapter cannot overlap"+        case .blankField(let field): "\(field.capitalized) must not be blank"+        }+    }+}++// MARK: - Segment Chip++struct SegmentChipView: View {+    let text: String+    let role: SegmentRole+    let index: Int+    let onTap: () -> Void++    var body: some View {+        Button(action: onTap) {+            HStack(spacing: 4) {+                Text(roleSymbol)+                    .font(.caption.monospaced().bold())+                    .foregroundStyle(roleColor)+                Text(text)+                    .font(.subheadline)+                    .lineLimit(1)+            }+            .padding(.horizontal, 12)+            .padding(.vertical, 8)+            .frame(minHeight: AsterismLayout.minHitTarget)+            .background(roleColor.opacity(0.12))+            .clipShape(Capsule())+            .overlay(Capsule().stroke(roleColor.opacity(0.4), lineWidth: 1))+        }+        .buttonStyle(.plain)+        .accessibilityIdentifier("segment-chip-\(index)")+        .accessibilityLabel("Segment \(index + 1): \(text), role: \(role.rawValue)")+        .accessibilityHint("Tap to cycle role")+    }++    private var roleSymbol: String {+        switch role {+        case .chapter: "C"+        case .work: "W"+        case .ignore: "×"+        }+    }++    private var roleColor: Color {+        switch role {+        case .chapter: AsterismColors.cyanDark+        case .work: AsterismColors.amberDark+        case .ignore: .secondary+        }+    }+}++// MARK: - FlowLayout++/// Simple wrapping layout for segment chips.+struct FlowLayout: Layout {+    var spacing: CGFloat = 8++    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {+        let result = arrange(proposal: proposal, subviews: subviews)+        return result.size+    }++    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {+        let result = arrange(proposal: ProposedViewSize(width: bounds.width, height: bounds.height), subviews: subviews)+        for (index, position) in result.positions.enumerated() {+            subviews[index].place(at: CGPoint(x: bounds.minX + position.x, y: bounds.minY + position.y), proposal: .unspecified)+        }+    }++    private struct ArrangeResult {+        var size: CGSize+        var positions: [CGPoint]+    }++    private func arrange(proposal: ProposedViewSize, subviews: Subviews) -> ArrangeResult {+        let maxWidth = proposal.width ?? .infinity+        var positions: [CGPoint] = []+        var x: CGFloat = 0+        var y: CGFloat = 0+        var rowHeight: CGFloat = 0+        var totalHeight: CGFloat = 0+        var totalWidth: CGFloat = 0++        for subview in subviews {+            let size = subview.sizeThatFits(.unspecified)+            if x + size.width > maxWidth, x > 0 {+                x = 0+                y += rowHeight + spacing+                rowHeight = 0+            }+            positions.append(CGPoint(x: x, y: y))+            rowHeight = max(rowHeight, size.height)+            x += size.width + spacing+            totalWidth = max(totalWidth, x - spacing)+        }+        totalHeight = y + rowHeight++        return ArrangeResult(size: CGSize(width: totalWidth, height: totalHeight), positions: positions)+    }+}

diff --git a/Asterism/Asterism/Views/WorkDetailView.swift b/Asterism/Asterism/Views/WorkDetailView.swiftindex ac0ade3..1ca53b8 100644--- a/Asterism/Asterism/Views/WorkDetailView.swift+++ b/Asterism/Asterism/Views/WorkDetailView.swift@@ -67,7 +67,7 @@ struct WorkDetailView: View {             if !work.entries.isEmpty {                 Section("Entries (\(work.entries.count))") {                     ForEach(work.entries, id: \.id) { entry in-                        RecentEntryRow(entry: entry)+                        UnattachedEntryRow(entry: entry)                             .accessibilityIdentifier("work-detail-entry")                             .accessibilityLabel("Assigned entry: \(entry.captureTitle)")                     }

diff --git a/Asterism/Asterism/Views/WorksView.swift b/Asterism/Asterism/Views/WorksView.swiftindex 167a467..fe0f51b 100644--- a/Asterism/Asterism/Views/WorksView.swift+++ b/Asterism/Asterism/Views/WorksView.swift@@ -47,7 +47,7 @@ struct WorksView: View {                         Button {                             onSelectEntry(entry.id)                         } label: {-                            RecentEntryRow(entry: entry)+                            UnattachedEntryRow(entry: entry)                                 .contentShape(Rectangle())                         }                         .buttonStyle(.plain)@@ -124,3 +124,35 @@ struct WorkRow: View {         .frame(minHeight: AsterismLayout.minHitTarget)     } }++/// Simple row for unattached entries in the Works tab.+struct UnattachedEntryRow: View {+    let entry: EntrySnapshot++    var body: some View {+        VStack(alignment: .leading, spacing: 4) {+            Text(entry.captureTitle)+                .font(AsterismTypography.serifTitle(15))+                .lineLimit(1)+                .accessibilityIdentifier("entry-title")++            HStack(spacing: 6) {+                Text(entry.hostname)+                    .font(.caption)+                    .foregroundStyle(.secondary)+                    .accessibilityIdentifier("entry-hostname")+                Spacer()+                if let rating = entry.rating {+                    Text(rating == .up ? "▲" : "▼")+                        .font(.caption)+                        .foregroundStyle(rating == .up ? AsterismColors.cyanDark : AsterismColors.violetDark)+                }+                Text(entry.lastSharedAt, style: .time)+                    .font(.caption2)+                    .foregroundStyle(.secondary)+            }+        }+        .padding(.vertical, 4)+        .frame(minHeight: AsterismLayout.minHitTarget)+    }+}

diff --git a/Asterism/AsterismShareExtension/CaptureView.swift b/Asterism/AsterismShareExtension/CaptureView.swiftindex 26d8025..9bad3d3 100644--- a/Asterism/AsterismShareExtension/CaptureView.swift+++ b/Asterism/AsterismShareExtension/CaptureView.swift@@ -3,8 +3,9 @@ import SwiftUI  /// Capture sheet SwiftUI view: loading, invalid URL, first-site amber state, /// existing-site neutral state, inline required manual title, focused multiline note,-/// independent up/down rating toggles, save/error/retry/cancel, accessibility labels,-/// 44pt targets, Dynamic Type/scrolling, Reduce Transparency/basic paired appearance.+/// independent up/down rating toggles, projected metadata section before Save,+/// save/error/retry/cancel, accessibility labels, 44pt targets,+/// Dynamic Type/scrolling, Reduce Transparency/basic paired appearance. struct CaptureView: View {     @ObservedObject var viewModel: ObservableCaptureViewModel     @FocusState private var noteFieldFocused: Bool@@ -37,6 +38,7 @@ struct CaptureView: View {                     }                     .disabled(viewModel.isSaving)                     .accessibilityLabel("Cancel capture")+                    .accessibilityIdentifier("capture.cancel")                     .frame(minWidth: 44, minHeight: 44)                 }             }@@ -53,12 +55,12 @@ struct CaptureView: View {             loadingContent         case .invalidInput(let message):             invalidInputContent(message: message)-        case .ready(let preparation, _):-            readyContent(preparation: preparation)+        case .ready(let preparation, _, let outcome, let reviewMessage):+            readyContent(preparation: preparation, outcome: outcome, reviewMessage: reviewMessage)         case .saving:             savingContent-        case .saveFailed(let preparation, _, let message):-            failedContent(preparation: preparation, message: message)+        case .saveFailed(let preparation, _, let outcome, let message):+            failedContent(preparation: preparation, outcome: outcome, message: message)         case .saved:             savedContent         case .cancelled:@@ -68,7 +70,6 @@ struct CaptureView: View {      // MARK: - Surface background (Reduce Transparency aware) -    /// An opaque background for field surfaces that respects Reduce Transparency.     private var fieldBackground: some ShapeStyle {         if reduceTransparency {             return AnyShapeStyle(colorScheme == .dark ? Color(white: 0.18) : Color(white: 0.92))@@ -111,8 +112,14 @@ struct CaptureView: View {     // MARK: - Ready      @ViewBuilder-    private func readyContent(preparation: CapturePreparation) -> some View {+    private func readyContent(preparation: CapturePreparation, outcome: CaptureOutcome?, reviewMessage: String?) -> some View {         metadataSection(preparation: preparation)+        if let outcome {+            projectedMetadataSection(outcome: outcome)+        }+        if let reviewMessage {+            reviewBanner(message: reviewMessage)+        }         noteSection         ratingSection         saveButton@@ -134,9 +141,12 @@ struct CaptureView: View {     // MARK: - Failed      @ViewBuilder-    private func failedContent(preparation: CapturePreparation, message: String) -> some View {+    private func failedContent(preparation: CapturePreparation, outcome: CaptureOutcome?, message: String) -> some View {         errorBanner(message: message)         metadataSection(preparation: preparation)+        if let outcome {+            projectedMetadataSection(outcome: outcome)+        }         noteSection         ratingSection         retryButton@@ -157,7 +167,7 @@ struct CaptureView: View {         .accessibilityLabel("Capture saved successfully")     } -    // MARK: - Metadata+    // MARK: - Metadata (title + site)      @ViewBuilder     private func metadataSection(preparation: CapturePreparation) -> some View {@@ -172,6 +182,7 @@ struct CaptureView: View {                 Text(title)                     .font(.headline)                     .accessibilityLabel("Page title")+                    .accessibilityIdentifier("capture.pageTitle")             }              if let host = Self.hostname(from: preparation.rawURL) {@@ -179,14 +190,129 @@ struct CaptureView: View {                     .font(.caption)                     .foregroundStyle(.secondary)                     .accessibilityLabel("Site: \(host)")+                    .accessibilityIdentifier("capture.hostname")+            }+        }+        .frame(maxWidth: .infinity, alignment: .leading)+        .padding()+        .background(fieldBackground)+        .clipShape(RoundedRectangle(cornerRadius: 12))+        .accessibilityIdentifier("capture.metadata")+    }++    // MARK: - Projected Metadata Section++    @ViewBuilder+    private func projectedMetadataSection(outcome: CaptureOutcome) -> some View {+        VStack(alignment: .leading, spacing: 8) {+            if let displayTitle = outcome.displayTitle {+                HStack(spacing: 6) {+                    Image(systemName: "doc.text")+                        .font(.caption)+                        .foregroundStyle(.secondary)+                        .accessibilityHidden(true)+                    Text("Article: \(displayTitle)")+                        .font(.subheadline)+                }+                .accessibilityElement(children: .combine)+                .accessibilityLabel("Article title: \(displayTitle)")+                .accessibilityIdentifier("capture.articleTitle")+            }++            // Chapter / parse information+            if let chapter = outcome.projectedChapter {+                HStack(spacing: 6) {+                    Image(systemName: "bookmark.fill")+                        .font(.caption)+                        .foregroundStyle(.blue)+                        .accessibilityHidden(true)+                    Text("Chapter: \(chapter)")+                        .font(.subheadline)+                }+                .accessibilityElement(children: .combine)+                .accessibilityLabel("Chapter: \(chapter)")+                .accessibilityIdentifier("capture.projectedChapter")+            } else {+                HStack(spacing: 6) {+                    Image(systemName: "questionmark.circle")+                        .font(.caption)+                        .foregroundStyle(.secondary)+                        .accessibilityHidden(true)+                    Text(outcome.intentionallyUnattached ? "Independent article" : "No chapter parsed from title")+                        .font(.subheadline)+                        .foregroundStyle(.secondary)+                }+                .accessibilityElement(children: .combine)+                .accessibilityLabel(outcome.intentionallyUnattached ? "Independent article" : "No chapter parsed from title")+                .accessibilityIdentifier("capture.noChapter")+            }++            // Work information+            if let workTitle = outcome.projectedWorkTitle {+                let workDescription: String = {+                    switch outcome.workOutcome {+                    case .reuse:+                        return "Work: \(workTitle) (existing)"+                    case .create:+                        return "Work: \(workTitle) (new)"+                    case .ambiguous:+                        return "Work: \(workTitle) (ambiguous — needs review)"+                    case .none:+                        return "Work: \(workTitle)"+                    }+                }()+                HStack(spacing: 6) {+                    Image(systemName: "book.fill")+                        .font(.caption)+                        .foregroundStyle(.purple)+                        .accessibilityHidden(true)+                    Text(workDescription)+                        .font(.subheadline)+                }+                .accessibilityElement(children: .combine)+                .accessibilityLabel(workDescription)+                .accessibilityIdentifier("capture.projectedWork")+            } else if outcome.projectedChapter == nil, !outcome.intentionallyUnattached {+                // Parse failure — no work from parse+                HStack(spacing: 6) {+                    Image(systemName: "exclamationmark.circle")+                        .font(.caption)+                        .foregroundStyle(.orange)+                        .accessibilityHidden(true)+                    Text("Title does not match pattern")+                        .font(.subheadline)+                        .foregroundStyle(.orange)+                }+                .accessibilityElement(children: .combine)+                .accessibilityLabel("Title does not match pattern")+                .accessibilityIdentifier("capture.parseFailure")+            }++            // Actionable state indicator+            if outcome.actionable {+                HStack(spacing: 6) {+                    Image(systemName: "flag.fill")+                        .font(.caption)+                        .foregroundStyle(.orange)+                        .accessibilityHidden(true)+                    Text("Actionable — needs review after save")+                        .font(.caption)+                        .foregroundStyle(.orange)+                }+                .accessibilityElement(children: .combine)+                .accessibilityLabel("Actionable. Needs review after save.")+                .accessibilityIdentifier("capture.actionable")             }         }         .frame(maxWidth: .infinity, alignment: .leading)         .padding()         .background(fieldBackground)         .clipShape(RoundedRectangle(cornerRadius: 12))+        .accessibilityIdentifier("capture.projectedMetadata")     } +    // MARK: - Banners+     private var newSiteBanner: some View {         HStack(spacing: 6) {             Image(systemName: "star.fill")@@ -201,12 +327,33 @@ struct CaptureView: View {         .accessibilityLabel("New site. Title will be saved. Teach later in app.")     } +    private func reviewBanner(message: String) -> some View {+        HStack(spacing: 8) {+            Image(systemName: "arrow.triangle.2.circlepath")+                .foregroundStyle(.blue)+                .accessibilityHidden(true)+            Text(message)+                .font(.subheadline)+                .foregroundStyle(.primary)+        }+        .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))+        .accessibilityElement(children: .combine)+        .accessibilityLabel(message)+        .accessibilityIdentifier("capture.reviewBanner")+    }+     private var manualTitleInput: some View {         TextField("Title (required)", text: $viewModel.manualTitle)             .font(.headline)             .textFieldStyle(.plain)             .accessibilityLabel("Page title, required")             .accessibilityHint("Enter a title for this capture")+            .accessibilityIdentifier("capture.manualTitle")             .frame(minHeight: 44)     } @@ -227,8 +374,8 @@ struct CaptureView: View {                 .clipShape(RoundedRectangle(cornerRadius: 12))                 .accessibilityLabel("Note")                 .accessibilityHint("Optional note for this capture")+                .accessibilityIdentifier("capture.note")                 .onAppear {-                    // Focus the note field when it appears so keyboard presents immediately                     DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {                         noteFieldFocused = true                     }@@ -262,6 +409,7 @@ struct CaptureView: View {         }         .disabled(viewModel.isSaving)         .accessibilityLabel(label)+        .accessibilityIdentifier("capture.rating.\(rating.rawValue)")         .accessibilityAddTraits(isSelected ? .isSelected : [])     } @@ -278,6 +426,7 @@ struct CaptureView: View {         .buttonStyle(.borderedProminent)         .disabled(!viewModel.canSave || viewModel.isSaving)         .accessibilityLabel("Save capture")+        .accessibilityIdentifier("capture.save")     }      private var retryButton: some View {@@ -291,6 +440,7 @@ struct CaptureView: View {         .buttonStyle(.borderedProminent)         .disabled(!viewModel.canSave || viewModel.isSaving)         .accessibilityLabel("Try saving again")+        .accessibilityIdentifier("capture.retry")     }      private func errorBanner(message: String) -> some View {@@ -310,6 +460,7 @@ struct CaptureView: View {         .clipShape(RoundedRectangle(cornerRadius: 12))         .accessibilityElement(children: .combine)         .accessibilityLabel("Error: \(message)")+        .accessibilityIdentifier("capture.error")     }      // MARK: - Helpers@@ -324,15 +475,31 @@ struct CaptureView: View { @MainActor final class ObservableCaptureViewModel: ObservableObject {     private let viewModel: CaptureViewModel-    private var coordinator: CaptureCoordinator?+    private var coordinator: (any CaptureCoordinating)?     private var saveTask: Task<Void, Never>?+    /// Suppresses feedback loops from programmatic binding updates.+    private var suppressDidSet = false      @Published var state: CaptureViewState     @Published var manualTitle: String = "" {-        didSet { viewModel.setManualTitle(manualTitle) ; refreshState() }+        didSet {+            guard !suppressDidSet else { return }+            Task { [weak self] in+                guard let self, let coordinator = self.coordinator else { return }+                await self.viewModel.setManualTitle(self.manualTitle, coordinator: coordinator)+                self.refreshState()+            }+        }     }     @Published var note: String = "" {-        didSet { viewModel.setNote(note) ; refreshState() }+        didSet {+            guard !suppressDidSet else { return }+            Task { [weak self] in+                guard let self, let coordinator = self.coordinator else { return }+                await self.viewModel.setNote(self.note, coordinator: coordinator)+                self.refreshState()+            }+        }     }      var canSave: Bool { viewModel.canSave }@@ -358,32 +525,43 @@ final class ObservableCaptureViewModel: ObservableObject {     }      func toggleRating(_ rating: Rating) {-        viewModel.setRating(rating)-        refreshState()+        guard let coordinator else { return }+        Task { [weak self] in+            guard let self else { return }+            await self.viewModel.setRating(rating, coordinator: coordinator)+            self.refreshState()+        }     }      func save() {         guard saveTask == nil,               let coordinator,-              viewModel.canSave,-              let draft = viewModel.currentDraft else { return }+              viewModel.canSave else { return }          // Publish the in-flight state synchronously so controls and cancellation         // are disabled before the asynchronous repository save begins.-        state = .saving(draft: draft)-        saveTask = Task { [weak self] in+        if let draft = viewModel.currentDraft {+            state = .saving(draft: draft)+        }+        saveTask = Task { [weak self, coordinator] in             guard let self else { return }-            await viewModel.save(coordinator: coordinator)-            refreshState()-            saveTask = nil+            await self.viewModel.save(coordinator: coordinator)+            self.refreshState()+            self.saveTask = nil         }     } -    func setCoordinator(_ coordinator: CaptureCoordinator) {+    func setCoordinator(_ coordinator: any CaptureCoordinating) {         self.coordinator = coordinator     }      func refreshState() {+        suppressDidSet = true         state = viewModel.state+        // Sync binding values from the view model's current draft without triggering didSet loops+        if let draft = viewModel.currentDraft {+            if note != draft.note { note = draft.note }+        }+        suppressDidSet = false     } }

diff --git a/Asterism/AsterismShareExtension/ShareViewController.swift b/Asterism/AsterismShareExtension/ShareViewController.swiftindex 1594be0..8cd150f 100644--- a/Asterism/AsterismShareExtension/ShareViewController.swift+++ b/Asterism/AsterismShareExtension/ShareViewController.swift@@ -65,7 +65,10 @@ final class ShareViewController: UIViewController {          let repository: LibraryRepository         do {-            repository = try await LibraryRepository.open(configuration)+            repository = try await LibraryRepository.openForExtension(+                configuration,+                capabilities: .current+            )         } catch {             viewModel.setInvalidInput(message: "Library unavailable. Please try again later.")             observableViewModel?.refreshState()@@ -98,7 +101,7 @@ final class ShareViewController: UIViewController {          // 3. Create coordinator with bounded fetcher for non-Safari payloads         let fetcher = BoundedPageTitleFetcher()-        let coordinator = CaptureCoordinator(repository: repository, fetcher: fetcher)+        let coordinator: any CaptureCoordinating = CaptureCoordinator(repository: repository, fetcher: fetcher)          // 4. Store coordinator for save operations         observableViewModel?.setCoordinator(coordinator)

diff --git a/Asterism/AsterismTests/EntryDetailModelTests.swift b/Asterism/AsterismTests/EntryDetailModelTests.swiftindex 776479a..263f043 100644--- a/Asterism/AsterismTests/EntryDetailModelTests.swift+++ b/Asterism/AsterismTests/EntryDetailModelTests.swift@@ -3,13 +3,14 @@ import Foundation import Testing @testable import Asterism -/// Tests for EntryDetailModel: drafts, update, delete, submission suppression,-/// failure without optimistic mutation.+/// Tests for EntryDetailModel: coherent detail loading, drafts, update, delete,+/// submission suppression, mode from repository, and available actions. @Suite("EntryDetailModel") struct EntryDetailModelTests {      @MainActor private func makeSUT(         entry: EntrySnapshot? = nil,+        detail: EntryTeachingDetail? = nil,         updateResult: Result<Void, Error> = .success(()),         deleteResult: Result<Void, Error> = .success(())     ) -> (EntryDetailModel, MockLibraryProvider, CallbackTracker) {@@ -19,6 +20,19 @@ struct EntryDetailModelTests {         mock.updateEntryResult = updateResult         mock.deleteEntryResult = deleteResult +        // Build a default detail if none provided+        let teachingDetail = detail ?? EntryTeachingDetail(+            entry: entrySnapshot,+            siteMode: .untaught,+            activePatternSummary: nil,+            historicalPatternSummaries: [],+            chapterSettlement: .unsettled(reason: "No chapter provenance; awaiting teaching or manual assignment"),+            assignmentSettlement: .unsettled(reason: "No assignment provenance; awaiting teaching or manual assignment"),+            availableActions: [.teach],+            unresolvedCandidateTitle: nil+        )+        mock.entryTeachingDetailResult = .success(teachingDetail)+         let tracker = CallbackTracker()         let model = EntryDetailModel(             entryID: entrySnapshot.id,@@ -28,15 +42,26 @@ struct EntryDetailModelTests {         return (model, mock, tracker)     } -    @Test("Load populates entry and drafts")+    @Test("Load populates entry and drafts from coherent detail")     @MainActor func loadPopulatesDrafts() async {         let entry = TestFixtures.makeEntry(note: "my note", rating: .down)-        let (model, _, _) = makeSUT(entry: entry)+        let detail = EntryTeachingDetail(+            entry: entry,+            siteMode: .untaught,+            activePatternSummary: nil,+            historicalPatternSummaries: [],+            chapterSettlement: .unsettled(reason: "No chapter provenance; awaiting teaching or manual assignment"),+            assignmentSettlement: .unsettled(reason: "No assignment provenance; awaiting teaching or manual assignment"),+            availableActions: [.teach],+            unresolvedCandidateTitle: nil+        )+        let (model, mock, _) = makeSUT(entry: entry, detail: detail)         await model.load()         #expect(model.state == .ready)         #expect(model.entry == entry)         #expect(model.draftNote == "my note")         #expect(model.draftRating == .down)+        #expect(mock.entryTeachingDetailCallCount == 1)     }      @Test("Update commits note and rating changes")@@ -55,8 +80,19 @@ struct EntryDetailModelTests {     @Test("Update failure does not optimistically mutate entry snapshot")     @MainActor func updateFailureNoOptimistic() async {         let entry = TestFixtures.makeEntry(note: "original", rating: .up)+        let detail = EntryTeachingDetail(+            entry: entry,+            siteMode: .untaught,+            activePatternSummary: nil,+            historicalPatternSummaries: [],+            chapterSettlement: .unsettled(reason: "No chapter provenance; awaiting teaching or manual assignment"),+            assignmentSettlement: .unsettled(reason: "No assignment provenance; awaiting teaching or manual assignment"),+            availableActions: [.teach],+            unresolvedCandidateTitle: nil+        )         let (model, _, _) = makeSUT(             entry: entry,+            detail: detail,             updateResult: .failure(MockLibraryProvider.MockError.simulatedFailure("save failed"))         )         await model.load()@@ -85,8 +121,19 @@ struct EntryDetailModelTests {     @Test("Delete failure retains entry")     @MainActor func deleteFailure() async {         let entry = TestFixtures.makeEntry()+        let detail = EntryTeachingDetail(+            entry: entry,+            siteMode: .untaught,+            activePatternSummary: nil,+            historicalPatternSummaries: [],+            chapterSettlement: .unsettled(reason: "No chapter provenance; awaiting teaching or manual assignment"),+            assignmentSettlement: .unsettled(reason: "No assignment provenance; awaiting teaching or manual assignment"),+            availableActions: [.teach],+            unresolvedCandidateTitle: nil+        )         let (model, _, _) = makeSUT(             entry: entry,+            detail: detail,             deleteResult: .failure(MockLibraryProvider.MockError.simulatedFailure("delete failed"))         )         await model.load()@@ -106,6 +153,126 @@ struct EntryDetailModelTests {         // Only one should have gone through         #expect(mock.updateEntryCallCount == 1)     }++    // MARK: - Mode from repository (not inferred from fields)++    @Test("Untaught entry gets teach action from repository, not inferred from fields")+    @MainActor func untaughtEntryShowsTeach() async {+        let entry = TestFixtures.makeEntry()+        let detail = EntryTeachingDetail(+            entry: entry,+            siteMode: .untaught,+            activePatternSummary: nil,+            historicalPatternSummaries: [],+            chapterSettlement: .unsettled(reason: "No chapter provenance; awaiting teaching or manual assignment"),+            assignmentSettlement: .unsettled(reason: "No assignment provenance; awaiting teaching or manual assignment"),+            availableActions: [.teach],+            unresolvedCandidateTitle: nil+        )+        let (model, _, _) = makeSUT(entry: entry, detail: detail)+        await model.load()+        #expect(model.teachingDetail?.siteMode == .untaught)+        #expect(model.teachingDetail?.availableActions == [.teach])+    }++    @Test("Taught entry gets reTeach and reParse actions even when fields are none/manual")+    @MainActor func taughtEntryShowsBothActions() async {+        // Entry with .none provenance on both fields, but on a taught site+        let entry = TestFixtures.makeEntry()+        let patternID = UUID()+        let detail = EntryTeachingDetail(+            entry: entry,+            siteMode: .taught,+            activePatternSummary: PatternRuleSummary(+                id: patternID,+                version: 2,+                form: .segment,+                isActive: true,+                plainLanguageRule: "Work: 1 segment(s) at offset 1 from end; Ignored: end+0; Chapter: remaining segments"+            ),+            historicalPatternSummaries: [],+            chapterSettlement: .unsettled(reason: "No chapter provenance; awaiting teaching or manual assignment"),+            assignmentSettlement: .unsettled(reason: "No assignment provenance; awaiting teaching or manual assignment"),+            availableActions: [.reTeach, .reParse],+            unresolvedCandidateTitle: "Fiction"+        )+        let (model, _, _) = makeSUT(entry: entry, detail: detail)+        await model.load()+        #expect(model.teachingDetail?.siteMode == .taught)+        #expect(model.teachingDetail?.availableActions == [.reTeach, .reParse])+    }++    @Test("Manual protection reason is carried independently in settlement")+    @MainActor func manualProtectionReason() async {+        let entry = EntrySnapshot(+            id: UUID(),+            captureTitle: "Test",+            captureTitleSource: .host,+            rawURLString: "https://example.com/page",+            canonicalURLString: nil,+            hostname: "example.com",+            entryIdentityKey: "https://example.com/page",+            identityKeyVersion: 1,+            chapterTitle: "Manual Chapter",+            chapterTitleProvenance: try! FieldProvenance(kind: .manual),+            note: "",+            rating: nil,+            firstCapturedAt: TestFixtures.fixedDate,+            lastSharedAt: TestFixtures.fixedDate,+            modifiedAt: TestFixtures.fixedDate,+            workID: nil,+            workAssignmentProvenance: try! FieldProvenance(kind: .none),+            intentionallyUnattached: false+        )+        let detail = EntryTeachingDetail(+            entry: entry,+            siteMode: .taught,+            activePatternSummary: PatternRuleSummary(+                id: UUID(), version: 1, form: .segment, isActive: true,+                plainLanguageRule: "Work: 1 segment(s) at offset 1 from end; Chapter: remaining segments"+            ),+            historicalPatternSummaries: [],+            chapterSettlement: .manualProtected(reason: "Manually set by user"),+            assignmentSettlement: .unsettled(reason: "No assignment provenance; awaiting teaching or manual assignment"),+            availableActions: [.reTeach, .reParse],+            unresolvedCandidateTitle: nil+        )+        let (model, _, _) = makeSUT(entry: entry, detail: detail)+        await model.load()+        #expect(model.teachingDetail?.chapterSettlement == .manualProtected(reason: "Manually set by user"))+    }++    @Test("Active and historical pattern summaries are carried from repository")+    @MainActor func activeAndHistoricalSummaries() async {+        let entry = TestFixtures.makeEntry()+        let activeID = UUID()+        let historicalID = UUID()+        let detail = EntryTeachingDetail(+            entry: entry,+            siteMode: .taught,+            activePatternSummary: PatternRuleSummary(+                id: activeID, version: 2, form: .segment, isActive: true,+                plainLanguageRule: "Work: 1 segment(s) at offset 1 from end; Chapter: remaining segments"+            ),+            historicalPatternSummaries: [+                PatternRuleSummary(+                    id: historicalID, version: 1, form: .segment, isActive: false,+                    plainLanguageRule: "Work: 1 segment(s) at offset 0 from start; Chapter: remaining segments"+                )+            ],+            chapterSettlement: .patternSettled(patternID: activeID, version: 2),+            assignmentSettlement: .patternSettled(patternID: activeID, version: 2),+            availableActions: [.reTeach, .reParse],+            unresolvedCandidateTitle: nil+        )+        let (model, _, _) = makeSUT(entry: entry, detail: detail)+        await model.load()+        #expect(model.teachingDetail?.activePatternSummary?.id == activeID)+        #expect(model.teachingDetail?.activePatternSummary?.version == 2)+        #expect(model.teachingDetail?.historicalPatternSummaries.count == 1)+        #expect(model.teachingDetail?.historicalPatternSummaries[0].id == historicalID)+        #expect(model.teachingDetail?.historicalPatternSummaries[0].isActive == false)+    } }  /// Helper to track callback invocations.

diff --git a/Asterism/AsterismTests/Helpers/MockLibraryProvider.swift b/Asterism/AsterismTests/Helpers/MockLibraryProvider.swiftindex c19adf4..ab9dce8 100644--- a/Asterism/AsterismTests/Helpers/MockLibraryProvider.swift+++ b/Asterism/AsterismTests/Helpers/MockLibraryProvider.swift@@ -6,6 +6,7 @@ final class MockLibraryProvider: LibraryProviding, @unchecked Sendable {     // MARK: - Call tracking      var recentEntriesCallCount = 0+    var recentPresentationCallCount = 0     var worksCallCount = 0     var entryCallCount = 0     var workCallCount = 0@@ -19,6 +20,9 @@ final class MockLibraryProvider: LibraryProviding, @unchecked Sendable {     // MARK: - Preset results      var recentEntriesResult: Result<[DatedEntryGroup], Error> = .success([])+    var recentPresentationResult: Result<RecentPresentation, Error> = .success(+        RecentPresentation(groups: [], actionableCount: 0)+    )     var worksResult: Result<WorksSnapshot, Error> = .success(WorksSnapshot(works: [], unattachedEntries: []))     var entryResult: Result<EntrySnapshot, Error> = .failure(MockError.notConfigured)     var workResult: Result<WorkSnapshot, Error> = .failure(MockError.notConfigured)@@ -55,6 +59,11 @@ final class MockLibraryProvider: LibraryProviding, @unchecked Sendable {         return try recentEntriesResult.get()     } +    func recentPresentation(calendar: Calendar) async throws -> RecentPresentation {+        recentPresentationCallCount += 1+        return try recentPresentationResult.get()+    }+     func works() async throws -> WorksSnapshot {         worksCallCount += 1         return try worksResult.get()@@ -105,4 +114,102 @@ final class MockLibraryProvider: LibraryProviding, @unchecked Sendable {         workDestinationsCallCount += 1         return try workDestinationsResult.get()     }++    // MARK: - Teaching contract stubs++    var entryTeachingDetailResult: Result<EntryTeachingDetail, Error> = .failure(MockError.notConfigured)+    var entryTeachingDetailCallCount = 0++    var titlePatternResult: Result<TitlePatternSnapshot, Error> = .failure(MockError.notConfigured)+    var titlePatternCallCount = 0++    var projectInitialTeachingResult: Result<TeachingContract, Error> = .failure(MockError.notConfigured)+    var projectInitialTeachingCallCount = 0++    var projectReplacementResult: Result<TeachingContract, Error> = .failure(MockError.notConfigured)+    var projectReplacementCallCount = 0++    var commitTeachingResult: Result<TeachingCommitOutcome, Error> = .failure(MockError.notConfigured)+    var commitTeachingCallCount = 0+    var lastCommittedTeachingContract: TeachingContract?++    var projectArticlesResult: Result<ArticlesContract, Error> = .failure(MockError.notConfigured)+    var projectArticlesCallCount = 0++    var commitArticlesResult: Result<ArticlesCommitOutcome, Error> = .failure(MockError.notConfigured)+    var commitArticlesCallCount = 0+    var lastCommittedArticlesContract: ArticlesContract?++    var projectReparseResult: Result<ReparseContract, Error> = .failure(MockError.notConfigured)+    var projectReparseCallCount = 0++    var commitReparseResult: Result<ReparseCommitOutcome, Error> = .failure(MockError.notConfigured)+    var commitReparseCallCount = 0+    var lastCommittedReparseContract: ReparseContract?++    var projectCaptureResult: Result<CaptureContract, Error> = .failure(MockError.notConfigured)+    var projectCaptureCallCount = 0++    var commitCaptureResult: Result<CaptureCommitOutcome, Error> = .failure(MockError.notConfigured)+    var commitCaptureCallCount = 0+    var lastCommittedCaptureContract: CaptureContract?++    func titlePattern(id: UUID) async throws -> TitlePatternSnapshot {+        titlePatternCallCount += 1+        return try titlePatternResult.get()+    }++    func entryTeachingDetail(id: UUID) async throws -> EntryTeachingDetail {+        entryTeachingDetailCallCount += 1+        return try entryTeachingDetailResult.get()+    }++    func projectInitialTeaching(hostname: String, patternDefinition: PatternDefinition) async throws -> TeachingContract {+        projectInitialTeachingCallCount += 1+        return try projectInitialTeachingResult.get()+    }++    func projectReplacement(hostname: String, patternDefinition: PatternDefinition, boundaryEntryID: UUID, historicalPatternID: UUID?, historicalPatternVersion: Int?) async throws -> TeachingContract {+        projectReplacementCallCount += 1+        return try projectReplacementResult.get()+    }++    func commitTeaching(_ contract: TeachingContract) async throws -> TeachingCommitOutcome {+        commitTeachingCallCount += 1+        lastCommittedTeachingContract = contract+        return try commitTeachingResult.get()+    }++    func projectArticles(hostname: String, junkSuffixRule: JunkSuffixRule?) async throws -> ArticlesContract {+        projectArticlesCallCount += 1+        return try projectArticlesResult.get()+    }++    func commitArticles(_ contract: ArticlesContract) async throws -> ArticlesCommitOutcome {+        commitArticlesCallCount += 1+        lastCommittedArticlesContract = contract+        return try commitArticlesResult.get()+    }++    func projectReparse(entryID: UUID) async throws -> ReparseContract {+        projectReparseCallCount += 1+        return try projectReparseResult.get()+    }++    func commitReparse(_ contract: ReparseContract) async throws -> ReparseCommitOutcome {+        commitReparseCallCount += 1+        lastCommittedReparseContract = contract+        return try commitReparseResult.get()+    }++    func projectCapture(hostname: String, captureTitle: String, captureTitleSource: CaptureTitleSource, rawURLString: String, canonicalURLString: String?, note: String, rating: Rating?) async throws -> CaptureContract {+        projectCaptureCallCount += 1+        return try projectCaptureResult.get()+    }++    func commitCapture(_ contract: CaptureContract) async throws -> CaptureCommitOutcome {+        commitCaptureCallCount += 1+        lastCommittedCaptureContract = contract+        return try commitCaptureResult.get()+    } }

diff --git a/Asterism/AsterismTests/IntegrationSafetyNetTests.swift b/Asterism/AsterismTests/IntegrationSafetyNetTests.swiftindex 85b526b..f7cde4e 100644--- a/Asterism/AsterismTests/IntegrationSafetyNetTests.swift+++ b/Asterism/AsterismTests/IntegrationSafetyNetTests.swift@@ -18,7 +18,7 @@ struct IntegrationSafetyNetTests {         #expect(developmentApp.state == .ready)         #expect(personalApp.state == .ready) -        let extensionRepository = try await LibraryRepository.open(fixture.developmentConfiguration)+        let extensionRepository = try await LibraryRepository.openForExtension(fixture.developmentConfiguration)         let captured = try await extensionRepository.capture(             CaptureDraft(                 captureTitle: "Cross-process chapter",@@ -44,7 +44,7 @@ struct IntegrationSafetyNetTests {         let fixture = try IntegrationFixture()         defer { fixture.cleanup() } -        let appRepository = try await LibraryRepository.open(fixture.developmentConfiguration)+        let appRepository = try await LibraryRepository.openForApp(fixture.developmentConfiguration)         let entry = try await appRepository.capture(             CaptureDraft(                 captureTitle: "Assignment chapter",@@ -57,7 +57,7 @@ struct IntegrationSafetyNetTests {         )         try await appRepository.moveEntry(entry.id, to: .existing(work.id)) -        let freshExtensionRepository = try await LibraryRepository.open(fixture.developmentConfiguration)+        let freshExtensionRepository = try await LibraryRepository.openForExtension(fixture.developmentConfiguration)         let observed = try await freshExtensionRepository.entry(id: entry.id)         let destinations = try await freshExtensionRepository.workDestinations(for: entry.id) @@ -79,7 +79,7 @@ struct IntegrationSafetyNetTests {         try FileManager.default.removeItem(at: configuration.storeURL)          do {-            _ = try await LibraryRepository.open(configuration)+            _ = try await LibraryRepository.openForApp(configuration)             Issue.record("Expected an initialized library with a missing store to fail closed")         } catch let error as LibraryRepositoryError {             guard case .libraryUnavailable = error else {@@ -97,7 +97,7 @@ struct IntegrationSafetyNetTests {         let fixture = try IntegrationFixture()         defer { fixture.cleanup() } -        let repository = try await LibraryRepository.open(fixture.developmentConfiguration)+        let repository = try await LibraryRepository.openForApp(fixture.developmentConfiguration)         let entry = try await repository.capture(             CaptureDraft(                 captureTitle: "Backup chapter ✦",@@ -128,29 +128,95 @@ struct IntegrationSafetyNetTests {         let result = try await exporter.export(             metadata: BackupMetadata(                 appBuild: "integration-1",-                databaseSchemaVersion: 1,+                databaseSchemaVersion: 2,                 exportedAt: exportedAt             )         )         defer { exporter.cleanup(result) }          let encoded = try Data(contentsOf: result.fileURL)-        let decoded = try BackupV1Codec.decode(encoded)+        let decoded = try BackupV2Codec.decode(encoded, capabilities: .current)         let source = try await repository.backupSnapshot()-        try BackupV1Validator.validate(decoded: decoded, source: source, encodedData: encoded)--        #expect(decoded.header.entryCount == 1)-        #expect(decoded.header.workCount == 1)-        #expect(decoded.snapshot.entries.first?.id == entry.id)-        #expect(decoded.snapshot.entries.first?.note == "Preserve this note exactly — including Unicode.")-        #expect(decoded.snapshot.entries.first?.workID == work.id)-        #expect(decoded.snapshot.works.first?.displayTitle == "Constellation Work Revised")-        #expect(decoded.snapshot.works.first?.entryIDs == [entry.id])-        #expect(decoded.snapshot.sites.map(\.hostname) == ["backup.test"])++        #expect(decoded.payload == source)+        #expect(decoded.payload.entries.count == 1)+        #expect(decoded.payload.works.count == 1)+        #expect(decoded.payload.entries.first?.id == entry.id)+        #expect(decoded.payload.entries.first?.note == "Preserve this note exactly — including Unicode.")+        #expect(decoded.payload.entries.first?.workID == work.id)+        #expect(decoded.payload.works.first?.displayTitle == "Constellation Work Revised")+        #expect(decoded.payload.works.first?.entryIDs == [entry.id])+        #expect(decoded.payload.sites.map(\.hostname) == ["backup.test"])+    }++    @Test("Every M2 gate stays consistent across Development and Personal")+    @MainActor+    func everyGateUsesOneCapabilityValuePerEnvironment() async throws {+        let fixture = try IntegrationFixture()+        defer { fixture.cleanup() }++        for environment in [LibraryEnvironment.development, .personal] {+            for capabilities in [+                M2Capabilities.m2_0,+                .m2_1,+                .m2_2,+                .m2_3,+            ] {+                let configuration = LibraryConfiguration(+                    rootDirectory: fixture.baseDirectory.appending(+                        path: "\(environment.rawValue)-\(capabilities.gate.rawValue)",+                        directoryHint: .isDirectory+                    ),+                    environment: environment+                )+                let app = AppLibraryModel(+                    configuration: configuration,+                    capabilities: capabilities+                )++                await app.bootstrap()+                #expect(app.state == .ready)+                #expect(app.capabilities == capabilities)++                let extensionRepository = try await LibraryRepository.openForExtension(+                    configuration,+                    capabilities: capabilities+                )+                let entry = try await extensionRepository.capture(+                    CaptureDraft(+                        captureTitle: "Work :: Chapter",+                        captureTitleSource: .manual,+                        rawURLString: "https://\(capabilities.gate.rawValue).\(environment.rawValue).test/1"+                    )+                )+                await app.handleActivation()++                #expect(+                    (app.teachingModel(for: entry.id) != nil)+                        == capabilities.supportsSegmentTeaching+                )++                guard let backup = app.settingsBackupModel() else {+                    Issue.record("Expected Backup wiring for \(environment.rawValue) \(capabilities.gate.rawValue)")+                    continue+                }+                await backup.startExport()+                guard let backupURL = backup.exportedFileURL else {+                    Issue.record("Expected Backup export for \(environment.rawValue) \(capabilities.gate.rawValue)")+                    continue+                }+                let document = try BackupV2Codec.decode(+                    Data(contentsOf: backupURL),+                    capabilities: capabilities+                )+                #expect(document.capabilityGate == capabilities.gate)+                backup.handleShareCancellation()+            }+        }     }      private func initializeLibrary(at configuration: LibraryConfiguration) async throws {-        let repository = try await LibraryRepository.open(configuration)+        let repository = try await LibraryRepository.openForApp(configuration)         _ = try await repository.capture(             CaptureDraft(                 captureTitle: "Durable record",

diff --git a/Asterism/AsterismTests/ReparseViewModelTests.swift b/Asterism/AsterismTests/ReparseViewModelTests.swiftnew file mode 100644index 0000000..ccd4fe9--- /dev/null+++ b/Asterism/AsterismTests/ReparseViewModelTests.swift@@ -0,0 +1,230 @@+import AsterismCore+import Foundation+import Testing+@testable import Asterism++/// Tests for ReparseViewModel: preview-before-confirm, refreshed requires second confirm,+/// invalidated/failure no mutation, manual protections visible.+@Suite("ReparseViewModel")+struct ReparseViewModelTests {++    private static let fixedDate = Date(timeIntervalSince1970: 1_750_000_000)+    private static let patternID = UUID()+    private static let entryID = UUID()+    private static let workID = UUID()++    private static func makePattern() -> PatternBasisEntry {+        PatternBasisEntry(+            id: patternID,+            version: 1,+            isActive: true,+            definition: .segment(+                work: try! SegmentRangeSpec(origin: .end, offset: 1, length: 1),+                ignored: [try! SegmentPositionSpec(origin: .end, offset: 0)]+            ),+            createdAt: fixedDate+        )+    }++    private static func makeEntryBasis(+        chapterProvenance: FieldProvenance = try! FieldProvenance(kind: .pattern, patternID: patternID, patternVersion: 1),+        assignmentProvenance: FieldProvenance = try! FieldProvenance(kind: .pattern, patternID: patternID, patternVersion: 1)+    ) -> EntryBasisEntry {+        EntryBasisEntry(+            id: entryID,+            captureTitle: "Chapter 5 - Fiction | Royal Road",+            hostname: "example.com",+            firstCapturedAt: fixedDate,+            chapterTitle: "Chapter 5",+            chapterTitleProvenance: chapterProvenance,+            workID: workID,+            workAssignmentProvenance: assignmentProvenance,+            intentionallyUnattached: false,+            note: "",+            rating: nil+        )+    }++    private static func makeContract(+        entry: EntryBasisEntry? = nil,+        projection: EntryProjection? = nil+    ) -> ReparseContract {+        let entryBasis = entry ?? makeEntryBasis()+        let pattern = makePattern()+        let basis = ReparseBasis(+            siteMode: .taught,+            hostname: "example.com",+            activePattern: pattern,+            entry: entryBasis,+            works: [WorkBasisEntry(+                id: workID, displayTitle: "Fiction", lastParsedTitle: "Fiction",+                titleProvenance: .parsed, siteHostname: "example.com",+                createdAt: fixedDate, modifiedAt: fixedDate+            )]+        )+        let proj = projection ?? EntryProjection(+            entryID: entryID,+            projectedChapter: "Chapter 5",+            projectedWorkTitle: "Fiction",+            workOutcome: .reuse(workID: workID),+            projectedWorkID: workID,+            chapterProvenance: .pendingPattern(PendingPatternProvenance(patternVersion: 1)),+            assignmentProvenance: .pendingPattern(PendingPatternProvenance(patternVersion: 1)),+            chapterProtected: false,+            assignmentProtected: false,+            parseFailure: nil,+            actionableAfter: false,+            previousWorkID: workID,+            previousChapter: "Chapter 5"+        )+        let plan = ProjectionPlan(+            entryProjections: [proj],+            worksToCreate: [],+            worksToReuse: [workID],+            hasAmbiguity: false,+            patternDefinition: pattern.definition,+            patternVersion: 1+        )+        let outcome = ReparseOutcome(plan: plan)+        return ReparseContract(basis: basis, request: ReparseRequest(entryID: entryID), outcome: outcome)+    }++    @MainActor private func makeSUT(+        projectResult: Result<ReparseContract, Error>? = nil,+        commitResult: Result<ReparseCommitOutcome, Error> = .success(.committed)+    ) -> (ReparseViewModel, MockLibraryProvider, ReparseCallbackTracker) {+        let mock = MockLibraryProvider()+        mock.projectReparseResult = projectResult ?? .success(Self.makeContract())+        mock.commitReparseResult = commitResult++        let tracker = ReparseCallbackTracker()+        let model = ReparseViewModel(+            entryID: Self.entryID,+            library: mock,+            onMutation: { tracker.mutationCount += 1 }+        )+        return (model, mock, tracker)+    }++    @Test("Load projects the contract and shows projected state")+    @MainActor func previewBeforeConfirm() async {+        let (model, mock, _) = makeSUT()+        await model.load()+        #expect(model.state == .projected)+        #expect(model.contract != nil)+        #expect(model.projection != nil)+        #expect(model.projection?.projectedChapter == "Chapter 5")+        #expect(model.projection?.projectedWorkTitle == "Fiction")+        #expect(mock.projectReparseCallCount == 1)+    }++    @Test("Confirm commits and triggers onMutation")+    @MainActor func confirmCommits() async {+        let (model, mock, tracker) = makeSUT()+        await model.load()+        await model.confirm()+        #expect(model.state == .committed)+        #expect(mock.commitReparseCallCount == 1)+        #expect(tracker.mutationCount == 1)+    }++    @Test("Refreshed requires second confirm")+    @MainActor func refreshedRequiresSecondConfirm() async {+        let freshContract = Self.makeContract()+        let (model, mock, tracker) = makeSUT(+            commitResult: .success(.refreshed(freshContract))+        )+        await model.load()+        await model.confirm()+        #expect(model.state == .refreshed)+        #expect(model.requiresReconfirmation == true)+        #expect(tracker.mutationCount == 0)++        // Second confirm commits+        mock.commitReparseResult = .success(.committed)+        await model.reconfirm()+        #expect(model.state == .committed)+        #expect(tracker.mutationCount == 1)+    }++    @Test("Invalidated does not mutate")+    @MainActor func invalidatedNoMutation() async {+        let (model, _, tracker) = makeSUT(+            commitResult: .success(.invalidated(reason: "Site untaught"))+        )+        await model.load()+        await model.confirm()+        guard case .invalidated(let reason) = model.state else {+            Issue.record("Expected invalidated state"); return+        }+        #expect(reason == "Site untaught")+        #expect(tracker.mutationCount == 0)+    }++    @Test("Error does not mutate")+    @MainActor func errorNoMutation() async {+        let (model, _, tracker) = makeSUT(+            commitResult: .failure(MockLibraryProvider.MockError.simulatedFailure("network error"))+        )+        await model.load()+        await model.confirm()+        guard case .error = model.state else {+            Issue.record("Expected error state"); return+        }+        #expect(tracker.mutationCount == 0)+    }++    @Test("Projection failure shows error state")+    @MainActor func projectionFailureShowsError() async {+        let (model, _, _) = makeSUT(+            projectResult: .failure(MockLibraryProvider.MockError.simulatedFailure("unavailable"))+        )+        await model.load()+        guard case .error = model.state else {+            Issue.record("Expected error state"); return+        }+        #expect(model.errorMessage != nil)+    }++    @Test("Manual protections are visible in projection")+    @MainActor func manualProtectionsVisible() async {+        let manualEntry = Self.makeEntryBasis(+            chapterProvenance: try! FieldProvenance(kind: .manual),+            assignmentProvenance: try! FieldProvenance(kind: .manual)+        )+        let protectedProjection = EntryProjection(+            entryID: Self.entryID,+            projectedChapter: "Manual Chapter",+            projectedWorkTitle: nil,+            workOutcome: nil,+            projectedWorkID: Self.workID,+            chapterProvenance: .preserved(try! FieldProvenance(kind: .manual)),+            assignmentProvenance: .preserved(try! FieldProvenance(kind: .manual)),+            chapterProtected: true,+            assignmentProtected: true,+            parseFailure: nil,+            actionableAfter: false,+            previousWorkID: Self.workID,+            previousChapter: "Manual Chapter"+        )+        let contract = Self.makeContract(entry: manualEntry, projection: protectedProjection)+        let (model, _, _) = makeSUT(projectResult: .success(contract))+        await model.load()+        #expect(model.projection?.chapterProtected == true)+        #expect(model.projection?.assignmentProtected == true)+    }++    @Test("Duplicate submission is suppressed")+    @MainActor func duplicateSubmissionSuppressed() async {+        let (model, mock, _) = makeSUT()+        await model.load()+        async let first: () = model.confirm()+        async let second: () = model.confirm()+        _ = await (first, second)+        #expect(mock.commitReparseCallCount == 1)+    }+}++final class ReparseCallbackTracker: @unchecked Sendable {+    var mutationCount = 0+}

diff --git a/Asterism/AsterismTests/SettingsBackupModelTests.swift b/Asterism/AsterismTests/SettingsBackupModelTests.swiftindex a1593b1..db09fde 100644--- a/Asterism/AsterismTests/SettingsBackupModelTests.swift+++ b/Asterism/AsterismTests/SettingsBackupModelTests.swift@@ -40,6 +40,7 @@ struct SettingsBackupModelTests {         #expect(model.exportedFileURL == fakeURL)         #expect(model.errorMessage == nil)         #expect(mock.exportCallCount == 1)+        #expect(mock.lastMetadata?.databaseSchemaVersion == 2)     }      // MARK: - Failure Path: Export Error@@ -221,12 +222,14 @@ final class MockBackupExporting: BackupExporting, @unchecked Sendable {     var cleanupCallCount = 0     var scavengeCallCount = 0     var lastCleanupURL: URL?+    var lastMetadata: BackupMetadata?      var exportResult: Result<BackupExportResult, Error> = .failure(MockBackupError.notConfigured)     var exportDelay: Duration?      func export(metadata: BackupMetadata) async throws -> BackupExportResult {         exportCallCount += 1+        lastMetadata = metadata         if let delay = exportDelay {             try? await Task.sleep(for: delay)         }

diff --git a/Asterism/AsterismTests/TeachingViewModelTests.swift b/Asterism/AsterismTests/TeachingViewModelTests.swiftnew file mode 100644index 0000000..047337f--- /dev/null+++ b/Asterism/AsterismTests/TeachingViewModelTests.swift@@ -0,0 +1,822 @@+import AsterismCore+import Foundation+import Testing+@testable import Asterism++/// Tests for the teaching view model: two-stage UX with preview generation,+/// generation-safe async preview, separate confirmation, delayed mock tests+/// proving obsolete generation cannot replace newer state.+@Suite("TeachingViewModel")+struct TeachingViewModelTests {++    // MARK: - Fixtures++    private static let fixedDate = Date(timeIntervalSince1970: 1_750_000_000)++    private static func makeTeachingContract(+        hostname: String = "example.com",+        patternVersion: Int = 1,+        entryCount: Int = 1,+        activeDefinition: PatternDefinition? = nil+    ) -> TeachingContract {+        let entries: [EntryBasisEntry] = (0..<entryCount).map { i in+            EntryBasisEntry(+                id: UUID(),+                captureTitle: "Work Title :: Chapter \(i + 1)",+                hostname: hostname,+                firstCapturedAt: fixedDate.addingTimeInterval(Double(i) * 60),+                chapterTitle: nil,+                chapterTitleProvenance: try! FieldProvenance(kind: .none),+                workID: nil,+                workAssignmentProvenance: try! FieldProvenance(kind: .none),+                intentionallyUnattached: false,+                note: "",+                rating: nil+            )+        }+        let patterns = activeDefinition.map {+            [PatternBasisEntry(+                id: UUID(),+                version: max(1, patternVersion - 1),+                isActive: true,+                definition: $0,+                createdAt: fixedDate.addingTimeInterval(-60)+            )]+        } ?? []+        let basis = TeachingBasis(+            siteMode: activeDefinition == nil ? .untaught : .taught,+            hostname: hostname,+            patterns: patterns,+            entries: entries,+            works: []+        )+        let request = TeachingRequest(+            operation: .initial,+            patternDefinition: .segment(+                work: try! SegmentRangeSpec(origin: .start, offset: 0, length: 1),+                ignored: []+            )+        )+        let entrySnapshots = entries.map { e in+            TestFixtures.makeEntry(+                id: e.id,+                captureTitle: e.captureTitle,+                hostname: e.hostname+            )+        }+        let plan = try! TitleProjectionPlanner.planInitialTeaching(+            patternDefinition: request.patternDefinition,+            entries: entrySnapshots,+            existingWorks: [],+            patternVersion: patternVersion+        )+        let outcome = TeachingOutcome(plan: plan, computedPatternVersion: patternVersion)+        return TeachingContract(basis: basis, request: request, outcome: outcome)+    }++    // MARK: - M2 Capabilities gate++    @Test("M2Capabilities.current is m2.3 for phrase teaching")+    func currentCapabilitiesAreM2_3() {+        #expect(M2Capabilities.current.gate == .m2_3)+        #expect(M2Capabilities.current.supportsSegmentTeaching == true)+        #expect(M2Capabilities.current.supportsArticles == true)+        #expect(M2Capabilities.current.supportsPhraseTeaching == true)+    }++    @Test("Current M2.3 gate allows both pattern forms")+    func currentGateAllowsBothPatternForms() {+        let segmentDef = PatternDefinition.segment(+            work: try! SegmentRangeSpec(origin: .start, offset: 0, length: 1),+            ignored: []+        )+        let phraseDef = PatternDefinition.phrase(+            prefix: "", separator: " :: ", suffix: "", order: .workThenChapter+        )+        #expect(M2Capabilities.current.allows(patternForm: .segment) == true)+        #expect(M2Capabilities.current.allows(patternForm: .phrase) == true)+        try! M2Capabilities.current.validate(patternDefinition: phraseDef)+        try! M2Capabilities.current.validate(patternDefinition: segmentDef)+    }++    // MARK: - Loading and segment tokenization++    @Test("TeachingViewModel loads segments from entry title")+    @MainActor func loadSegments() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "My Great Novel :: Chapter 42",+            hostname: "novels.example"+        )+        mock.entryResult = .success(entry)++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()++        #expect(vm.state == .ready)+        #expect(vm.segments.count == 2)+        #expect(vm.segments[0] == "My Great Novel")+        #expect(vm.segments[1] == "Chapter 42")+    }++    // MARK: - Role cycling++    @Test("TeachingViewModel segment role cycling: Chapter→Work→Ignore")+    @MainActor func segmentRoleCycling() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "A :: B :: C",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()++        #expect(vm.roles[0] == .chapter)+        vm.cycleRole(at: 0)+        #expect(vm.roles[0] == .work)+        vm.cycleRole(at: 0)+        #expect(vm.roles[0] == .ignore)+        vm.cycleRole(at: 0)+        #expect(vm.roles[0] == .chapter)+    }++    // MARK: - Validation++    @Test("TeachingViewModel validates contiguous chapter/work requirement")+    @MainActor func validationRequiresContiguous() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "A :: B :: C",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()++        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        vm.setRole(at: 2, to: .work)++        #expect(vm.isValid == false)+        #expect(vm.validationError != nil)+    }++    @Test("TeachingViewModel valid assignment enables preview, not confirm directly")+    @MainActor func validAssignmentEnablesPreview() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work Title :: Chapter 1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()++        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)++        #expect(vm.isValid == true)+        #expect(vm.validationError == nil)+        // Cannot confirm without preview+        #expect(vm.canConfirm == false)+    }++    // MARK: - Two-stage UX: preview then confirm++    @Test("Valid role edit triggers async preview; confirm only after preview")+    @MainActor func twoStagePreviewThenConfirm() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work :: Ch1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)+        mock.commitTeachingResult = .success(.committed(patternID: UUID(), patternVersion: 1))++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)++        // Wait for async preview+        await vm.generatePreview()++        #expect(vm.state == .previewReady)+        #expect(vm.previewPlan != nil)+        #expect(vm.canConfirm == true)+        #expect(mock.projectInitialTeachingCallCount >= 1)++        // Now confirm+        await vm.confirm()+        #expect(vm.state == .committed)+        #expect(mock.commitTeachingCallCount == 1)+    }++    @Test("No commit without displayed contract")+    @MainActor func noCommitWithoutContract() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work :: Ch1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)++        // Attempt confirm without preview+        await vm.confirm()++        // Should not have committed+        #expect(vm.state != .committed)+        #expect(mock.commitTeachingCallCount == 0)+    }++    @Test("Role edit invalidates old approval and increments generation")+    @MainActor func roleEditInvalidatesPreview() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "A :: B :: C",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        vm.setRole(at: 2, to: .ignore)++        await vm.generatePreview()+        #expect(vm.state == .previewReady)+        #expect(vm.canConfirm == true)++        // Now change a role — should invalidate+        vm.setRole(at: 2, to: .chapter)+        #expect(vm.canConfirm == false)+        #expect(vm.previewPlan == nil)+    }++    @Test("Obsolete generation preview cannot replace newer state")+    @MainActor func obsoleteGenerationCannotReplaceNewer() async {+        // This test proves that if generatePreview is called for one generation,+        // and a role edit happens before the preview returns, the stale result is discarded.+        // We use a mock that increments call count to verify the mechanism.+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "A :: B :: C",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = TeachingViewModelTests.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()++        // First valid assignment+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        vm.setRole(at: 2, to: .ignore)+        await vm.generatePreview()+        #expect(vm.state == .previewReady)+        #expect(vm.canConfirm == true)++        // Now change role — this invalidates the old preview+        vm.setRole(at: 2, to: .chapter)+        // canConfirm should be false because the preview is stale+        #expect(vm.canConfirm == false)+        #expect(vm.previewPlan == nil)++        // Old contract is gone, need to generate new preview+        await vm.generatePreview()+        #expect(vm.state == .previewReady)+        #expect(vm.canConfirm == true)+        // Verify multiple projections were requested+        #expect(mock.projectInitialTeachingCallCount >= 2)+    }++    @Test("Ten rapid edits publish only the newest preview generation")+    @MainActor func rapidEditsDiscardNineStaleGenerations() async throws {+        let entry = TestFixtures.makeEntry(+            captureTitle: "A :: B :: C",+            hostname: "test.example"+        )+        let contract = Self.makeTeachingContract(hostname: "test.example")+        let library = DelayedMockLibraryProvider(+            projectDelay: .milliseconds(75),+            contract: contract+        )+        let model = TeachingViewModel(+            entry: entry,+            library: library,+            capabilities: .m2_3+        )+        await model.load()+        // load() initializes every segment as Chapter. Count the first Work edit as+        // generation one, then alternate the third role for nine more accepted edits.+        // setRole starts preview generation itself, so no manual projection task is needed.+        for generation in 0..<10 {+            if generation == 0 {+                model.setRole(at: 0, to: .work)+            } else {+                model.setRole(at: 2, to: generation.isMultiple(of: 2) ? .chapter : .ignore)+            }+            while await library.projectCallCount < generation + 1 {+                await Task.yield()+            }+            try await Task.sleep(for: .milliseconds(50))+        }+        try await Task.sleep(for: .milliseconds(100))++        let projectCallCount = await library.projectCallCount+        #expect(projectCallCount == 10)+        #expect(model.state == .previewReady)+        #expect(model.canConfirm)+        #expect(model.previewPlan == contract.outcome.plan)+    }++    // MARK: - Commit outcomes++    @Test("TeachingViewModel commit returns committed and fires onMutation")+    @MainActor func commitSuccess() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work :: Ch1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)+        mock.commitTeachingResult = .success(.committed(patternID: UUID(), patternVersion: 1))++        let mutationCounter = MutationCounter()+        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current,+            onMutation: { await mutationCounter.increment() }+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        await vm.generatePreview()+        await vm.confirm()++        let mutationCount = await mutationCounter.count+        #expect(vm.state == .committed)+        #expect(mutationCount == 1)+        #expect(mock.commitTeachingCallCount == 1)+    }++    @Test("TeachingViewModel commit refreshed requires re-confirm")+    @MainActor func commitRefreshed() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work :: Ch1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)++        let freshContract = Self.makeTeachingContract(hostname: "test.example", patternVersion: 2)+        mock.commitTeachingResult = .success(.refreshed(freshContract))++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        await vm.generatePreview()+        await vm.confirm()++        #expect(vm.state == .refreshed)+        #expect(vm.requiresReconfirmation == true)+    }++    @Test("TeachingViewModel commit invalidated shows explanation, writes nothing")+    @MainActor func commitInvalidated() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work :: Ch1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)+        mock.commitTeachingResult = .success(.invalidated(reason: "Entry was deleted"))++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        await vm.generatePreview()+        await vm.confirm()++        #expect(vm.state == .invalidated)+        #expect(vm.invalidationReason == "Entry was deleted")+    }++    @Test("TeachingViewModel save failure preserves draft and explains")+    @MainActor func saveFailurePreservesDraft() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work :: Ch1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)+        mock.commitTeachingResult = .failure(MockLibraryProvider.MockError.simulatedFailure("disk full"))++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        await vm.generatePreview()+        await vm.confirm()++        #expect(vm.state == .error)+        #expect(vm.errorMessage != nil)+        #expect(vm.roles[0] == .work)+        #expect(vm.roles[1] == .chapter)+    }++    @Test("TeachingViewModel cancel writes nothing")+    @MainActor func cancelWritesNothing() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work :: Ch1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        vm.cancel()++        #expect(vm.state == .cancelled)+        #expect(mock.commitTeachingCallCount == 0)+    }++    // MARK: - Preview errors per row++    @Test("Preview errors populated per row on parse failure")+    @MainActor func previewErrorsPerRow() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work :: Ch1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let contract = Self.makeTeachingContract(hostname: "test.example")+        mock.projectInitialTeachingResult = .success(contract)++        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        await vm.generatePreview()++        // For a successful parse, preview errors should be empty+        #expect(vm.previewErrors.isEmpty)+    }++    // MARK: - Replacement mode++    @Test("TeachingViewModel in replacement mode calls projectReplacement")+    @MainActor func replacementModeCallsProjectReplacement() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(+            captureTitle: "Work :: Ch1",+            hostname: "test.example"+        )+        mock.entryResult = .success(entry)+        let activeDefinition = PatternDefinition.segment(+            work: try! SegmentRangeSpec(origin: .end, offset: 0, length: 1),+            ignored: []+        )+        let contract = Self.makeTeachingContract(+            hostname: "test.example",+            patternVersion: 2,+            activeDefinition: activeDefinition+        )+        mock.projectReplacementResult = .success(contract)++        let boundaryID = UUID()+        let vm = TeachingViewModel(+            entry: entry,+            library: mock,+            capabilities: .current,+            mode: .replacement(boundaryEntryID: boundaryID, historicalPatternID: nil, historicalPatternVersion: nil)+        )+        await vm.load()+        vm.setRole(at: 0, to: .work)+        vm.setRole(at: 1, to: .chapter)+        await vm.generatePreview()++        #expect(mock.projectReplacementCallCount >= 1)+        #expect(vm.state == .previewReady)+        #expect(vm.parseComparisons.count == contract.basis.entries.count)+        #expect(vm.parseComparisons.allSatisfy { $0.activeResult != nil })+        #expect(vm.parseComparisons.allSatisfy { $0.candidateProjection.entryID == $0.entryID })+    }++    // MARK: - Articles mode++    @Test("Articles mode previews suffix cleaning and commits only the displayed contract")+    @MainActor func articlesPreviewAndCommit() async throws {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(captureTitle: "Article - Example Site", hostname: "test.example")+        let basisEntry = EntryBasisEntry(+            id: entry.id,+            captureTitle: entry.captureTitle,+            hostname: entry.hostname,+            firstCapturedAt: entry.firstCapturedAt,+            chapterTitle: nil,+            chapterTitleProvenance: try FieldProvenance(kind: .none),+            workID: nil,+            workAssignmentProvenance: try FieldProvenance(kind: .none),+            intentionallyUnattached: false,+            note: "",+            rating: nil+        )+        let basis = TeachingBasis(+            siteMode: .untaught,+            hostname: entry.hostname,+            patterns: [],+            entries: [basisEntry],+            works: []+        )+        let derivedRule = try ArticleTitleCleaner.deriveRule(from: entry.captureTitle, suffixSegmentCount: 1)+        let request = ArticlesRequest(junkSuffixRule: derivedRule)+        let outcome = ArticlesOutcome(plan: TitleProjectionPlanner.planArticles(+            entries: [entry],+            junkSuffixRule: derivedRule+        ))+        let contract = ArticlesContract(basis: basis, request: request, outcome: outcome)+        mock.projectArticlesResult = .success(contract)+        mock.commitArticlesResult = .success(.committed)++        let vm = TeachingViewModel(entry: entry, library: mock, capabilities: .m2_2)+        await vm.load()+        vm.selectArticlesMode()+        vm.setJunkSuffixSegmentCount(1)+        await vm.generateArticlePreview()++        #expect(vm.editorMode == .articles)+        #expect(vm.articlePreviewPlan?.entryProjections.first?.displayTitle == "Article")+        #expect(vm.canConfirm)++        await vm.confirm()+        #expect(vm.state == .committed)+        #expect(mock.commitArticlesCallCount == 1)+        #expect(mock.lastCommittedArticlesContract == contract)+    }++    @Test("Articles mode rejects a suffix that removes the whole example")+    @MainActor func articlesRejectBlankExample() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(captureTitle: "Article - Example Site", hostname: "test.example")+        let vm = TeachingViewModel(entry: entry, library: mock, capabilities: .m2_2)+        await vm.load()+        vm.selectArticlesMode()+        vm.setJunkSuffixSegmentCount(2)++        #expect(vm.articleValidationMessage != nil)+        #expect(!vm.canConfirm)+        #expect(mock.commitArticlesCallCount == 0)+    }++    // MARK: - Recent actionability++    @Test("Actionable entry detection: untaught site no assignment")+    func actionableEntryDetection() {+        let isActionable = ActionabilityEvaluator.isActionable(+            chapterTitle: nil,+            chapterProvenance: try! FieldProvenance(kind: .none),+            workID: nil,+            assignmentProvenance: try! FieldProvenance(kind: .none),+            intentionallyUnattached: false+        )+        #expect(isActionable == true)+    }++    @Test("Non-actionable entry: has pattern assignment")+    func nonActionableWithPattern() {+        let patternID = UUID()+        let isActionable = ActionabilityEvaluator.isActionable(+            chapterTitle: "Ch1",+            chapterProvenance: try! FieldProvenance(kind: .pattern, patternID: patternID, patternVersion: 1),+            workID: UUID(),+            assignmentProvenance: try! FieldProvenance(kind: .pattern, patternID: patternID, patternVersion: 1),+            intentionallyUnattached: false+        )+        #expect(isActionable == false)+    }++    @Test("Non-actionable entry: intentionally unattached")+    func nonActionableIntentionallyUnattached() {+        let isActionable = ActionabilityEvaluator.isActionable(+            chapterTitle: nil,+            chapterProvenance: try! FieldProvenance(kind: .none),+            workID: nil,+            assignmentProvenance: try! FieldProvenance(kind: .none),+            intentionallyUnattached: true+        )+        #expect(isActionable == true)+    }++    @Test("Non-actionable: both fields settled by manual provenance")+    func nonActionableManualBoth() {+        let isActionable = ActionabilityEvaluator.isActionable(+            chapterTitle: "Chapter",+            chapterProvenance: try! FieldProvenance(kind: .manual),+            workID: UUID(),+            assignmentProvenance: try! FieldProvenance(kind: .manual),+            intentionallyUnattached: false+        )+        #expect(isActionable == false)+    }++    // MARK: - Phrase mode++    @Test("Phrase mode derives exact selections and publishes an accessible summary")+    @MainActor func phraseModePreview() async {+        let mock = MockLibraryProvider()+        let title = "Check out Episode 10 from The Regressor Creates Everything on Tapas."+        let entry = TestFixtures.makeEntry(captureTitle: title, hostname: "tapas.io")+        mock.projectInitialTeachingResult = .success(Self.makeTeachingContract(hostname: "tapas.io"))++        let vm = TeachingViewModel(entry: entry, library: mock, capabilities: .m2_3)+        await vm.load()+        vm.selectPhraseMode()+        vm.setPhraseSelection(.chapter, range: 10..<20)+        vm.setPhraseSelection(.work, range: 26..<58)+        await vm.generatePreview()++        #expect(vm.editorMode == .phrase)+        #expect(vm.selectedText(for: .chapter) == "Episode 10")+        #expect(vm.selectedText(for: .work) == "The Regressor Creates Everything")+        #expect(vm.phraseValidationMessage == nil)+        #expect(vm.patternRuleSummary == "Phrase; order: Chapter then Work; prefix: Check\\u{20}out\\u{20}; separator: \\u{20}from\\u{20}; suffix: \\u{20}on\\u{20}Tapas.")+        #expect(vm.canConfirm)+        #expect(mock.projectInitialTeachingCallCount >= 1)+    }++    @Test("Phrase boundaries adjust one extended grapheme cluster without dragging")+    @MainActor func phraseBoundaryAdjustment() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(captureTitle: "📚 Café from Novel", hostname: "example.com")+        let vm = TeachingViewModel(entry: entry, library: mock, capabilities: .m2_3)+        await vm.load()+        vm.selectPhraseMode()+        vm.setPhraseSelection(.chapter, range: 0..<5)+        vm.setPhraseSelection(.work, range: 12..<17)++        vm.adjustPhraseBoundary(.chapter, boundary: .end, direction: .forward)+        #expect(vm.selectedText(for: .chapter) == "📚 Café")+        #expect(vm.phraseBoundaryAnnouncement(for: .chapter, boundary: .end).contains("📚 Café"))++        vm.adjustPhraseBoundary(.chapter, boundary: .end, direction: .backward)+        #expect(vm.selectedText(for: .chapter) == "📚 Caf")+    }++    @Test("Phrase mode is unavailable before M2.3")+    @MainActor func phraseModeGateValidation() async {+        let mock = MockLibraryProvider()+        let entry = TestFixtures.makeEntry(captureTitle: "Chapter from Work", hostname: "example.com")+        let vm = TeachingViewModel(entry: entry, library: mock, capabilities: .m2_2)+        await vm.load()+        vm.selectPhraseMode()++        #expect(vm.editorMode == .segments)+        #expect(vm.phraseValidationMessage != nil)+        #expect(!vm.canConfirm)+    }++}++// MARK: - Delayed mock for generation tests++/// A mock library provider that can add delays to simulate async race conditions.+/// NOT @MainActor so the sleep can actually delay without blocking the main actor.+actor DelayedMockLibraryProvider: LibraryProviding {+    let projectDelay: Duration+    let contract: TeachingContract+    private(set) var projectCallCount = 0++    init(projectDelay: Duration, contract: TeachingContract) {+        self.projectDelay = projectDelay+        self.contract = contract+    }++    func projectInitialTeaching(hostname: String, patternDefinition: PatternDefinition) async throws -> TeachingContract {+        projectCallCount += 1+        try await Task.sleep(for: projectDelay)+        return contract+    }++    // All other protocol methods — minimal stubs+    func recentEntries(calendar: Calendar) async throws -> [DatedEntryGroup] { [] }+    func recentPresentation(calendar: Calendar) async throws -> RecentPresentation {+        RecentPresentation(groups: [], actionableCount: 0)+    }+    func works() async throws -> WorksSnapshot { WorksSnapshot(works: [], unattachedEntries: []) }+    func entry(id: UUID) async throws -> EntrySnapshot { throw MockLibraryProvider.MockError.notConfigured }+    func work(id: UUID) async throws -> WorkSnapshot { throw MockLibraryProvider.MockError.notConfigured }+    func workDestinations(for entryID: UUID) async throws -> [WorkSnapshot] { [] }+    func titlePattern(id: UUID) async throws -> TitlePatternSnapshot { throw MockLibraryProvider.MockError.notConfigured }+    func entryTeachingDetail(id: UUID) async throws -> EntryTeachingDetail { throw MockLibraryProvider.MockError.notConfigured }+    func updateEntry(id: UUID, note: String, rating: Rating?) async throws {}+    func deleteEntry(id: UUID) async throws {}+    func createWork(_ draft: NewWorkDraft) async throws -> WorkSnapshot { throw MockLibraryProvider.MockError.notConfigured }+    func updateWork(id: UUID, draft: WorkMetadataDraft) async throws {}+    func moveEntry(_ entryID: UUID, to destination: WorkDestination) async throws {}+    func projectReplacement(hostname: String, patternDefinition: PatternDefinition, boundaryEntryID: UUID, historicalPatternID: UUID?, historicalPatternVersion: Int?) async throws -> TeachingContract { throw MockLibraryProvider.MockError.notConfigured }+    func commitTeaching(_ contract: TeachingContract) async throws -> TeachingCommitOutcome { throw MockLibraryProvider.MockError.notConfigured }+    func projectArticles(hostname: String, junkSuffixRule: JunkSuffixRule?) async throws -> ArticlesContract { throw MockLibraryProvider.MockError.notConfigured }+    func commitArticles(_ contract: ArticlesContract) async throws -> ArticlesCommitOutcome { throw MockLibraryProvider.MockError.notConfigured }+    func projectReparse(entryID: UUID) async throws -> ReparseContract { throw MockLibraryProvider.MockError.notConfigured }+    func commitReparse(_ contract: ReparseContract) async throws -> ReparseCommitOutcome { throw MockLibraryProvider.MockError.notConfigured }+    func projectCapture(hostname: String, captureTitle: String, captureTitleSource: CaptureTitleSource, rawURLString: String, canonicalURLString: String?, note: String, rating: Rating?) async throws -> CaptureContract { throw MockLibraryProvider.MockError.notConfigured }+    func commitCapture(_ contract: CaptureContract) async throws -> CaptureCommitOutcome { throw MockLibraryProvider.MockError.notConfigured }+}++private actor MutationCounter {+    private(set) var count = 0++    func increment() {+        count += 1+    }+}

diff --git a/Asterism/AsterismTests/UITestLaunchSupportTests.swift b/Asterism/AsterismTests/UITestLaunchSupportTests.swiftindex a756a7e..38b4c1b 100644--- a/Asterism/AsterismTests/UITestLaunchSupportTests.swift+++ b/Asterism/AsterismTests/UITestLaunchSupportTests.swift@@ -3,6 +3,7 @@ import Testing @testable import Asterism import AsterismCore +@MainActor @Suite("UI test launch validation") struct UITestLaunchSupportTests {     @Test("Normal launches do not request a test library")@@ -28,23 +29,64 @@ struct UITestLaunchSupportTests {             temporaryDirectory: temporaryDirectory         ) -        guard case .seeded(let configuration) = request else {+        guard case .seeded(let configuration, let fixture) = request else {             Issue.record("Expected a seeded launch, got \(request)")             return         }+        #expect(fixture == .untaught)         #expect(configuration.environment == .development)         #expect(configuration.rootDirectory.path.hasPrefix(temporaryDirectory.path + "/AsterismUITests/"))         #expect(configuration.rootDirectory.lastPathComponent == runID.uuidString)     } +    @Test("Taught seeded launches preserve the requested fixture kind")+    func validTaughtSeedRequest() {+        let request = UITestLaunchSupport.request(+            environmentProvider: StubProcessEnvironment(+                values: [+                    UITestLaunchSupport.scenarioKey: UITestLaunchSupport.seededTaughtScenario,+                    UITestLaunchSupport.runIDKey: UUID().uuidString,+                ]+            ),+            temporaryDirectory: URL(filePath: "/tmp/asterism-launch-tests")+        )++        guard case .seeded(_, let fixture) = request else {+            Issue.record("Expected a taught seeded launch, got \(request)")+            return+        }+        #expect(fixture == .taught)+    }++    @Test("Scale launches use the same contained disposable root")+    func validScaleSeedRequest() {+        let request = UITestLaunchSupport.request(+            environmentProvider: StubProcessEnvironment(+                values: [+                    UITestLaunchSupport.scenarioKey: UITestLaunchSupport.seededScaleScenario,+                    UITestLaunchSupport.runIDKey: UUID().uuidString,+                ]+            ),+            temporaryDirectory: URL(filePath: "/tmp/asterism-launch-tests")+        )++        guard case .seeded(let configuration, let fixture) = request else {+            Issue.record("Expected a scale-seeded launch, got \(request)")+            return+        }+        #expect(fixture == .scale)+        #expect(configuration.environment == .development)+        #expect(configuration.rootDirectory.path.contains("/AsterismUITests/"))+    }+     @Test(         "Malformed launch input fails closed",         arguments: [-            [UITestLaunchSupport.scenarioKey: "unknown"],-            [UITestLaunchSupport.scenarioKey: UITestLaunchSupport.seededScenario],+            ["ASTERISM_UI_TEST_SCENARIO": "unknown"],+            ["ASTERISM_UI_TEST_SCENARIO": "seeded-m1"],             [-                UITestLaunchSupport.scenarioKey: UITestLaunchSupport.seededScenario,-                UITestLaunchSupport.runIDKey: "../../personal-library",+                "ASTERISM_UI_TEST_SCENARIO": "seeded-m1",+                "ASTERISM_UI_TEST_RUN_ID": "../../personal-library",             ],         ]     )

diff --git a/Asterism/AsterismUITests/AccessibilityJourneyUITests.swift b/Asterism/AsterismUITests/AccessibilityJourneyUITests.swiftindex 072e875..ad6973e 100644--- a/Asterism/AsterismUITests/AccessibilityJourneyUITests.swift+++ b/Asterism/AsterismUITests/AccessibilityJourneyUITests.swift@@ -5,11 +5,15 @@ final class AccessibilityJourneyUITests: XCTestCase {      override func setUp() {         continueAfterFailure = false+        XCUIDevice.shared.orientation = .portrait         app = XCUIApplication()+        terminateAndWaitForExit(app)     }      override func tearDown() {-        app?.terminate()+        if let app {+            terminateAndWaitForExit(app)+        }         app = nil     } @@ -19,7 +23,7 @@ final class AccessibilityJourneyUITests: XCTestCase {          let recentList = app.collectionViews["recent-list"]         XCTAssertTrue(recentList.waitForExistence(timeout: 30), "Seeded Recent list should load")-        let chapter = app.buttons["Open entry Integration Chapter from integration.test"]+        let chapter = app.buttons["Open entry Integration Work :: Integration Chapter from integration.test"]         XCTAssertTrue(chapter.waitForExistence(timeout: 10))         chapter.tap() @@ -123,7 +127,7 @@ final class AccessibilityJourneyUITests: XCTestCase {     }      private func openSeededEntry() {-        let chapter = app.buttons["Open entry Integration Chapter from integration.test"]+        let chapter = app.buttons["Open entry Integration Work :: Integration Chapter from integration.test"]         XCTAssertTrue(chapter.waitForExistence(timeout: 30))         chapter.tap()     }@@ -150,8 +154,8 @@ final class AccessibilityJourneyUITests: XCTestCase {         line: UInt = #line     ) {         assertSystemControl(element, named: name, file: file, line: line)-        XCTAssertGreaterThanOrEqual(element.frame.width, 44, "\(name) should be at least 44 points wide", file: file, line: line)-        XCTAssertGreaterThanOrEqual(element.frame.height, 44, "\(name) should be at least 44 points tall", file: file, line: line)+        XCTAssertGreaterThanOrEqual(element.frame.width.rounded(), 44, "\(name) should be at least 44 points wide", file: file, line: line)+        XCTAssertGreaterThanOrEqual(element.frame.height.rounded(), 44, "\(name) should be at least 44 points tall", file: file, line: line)     }      /// UIKit navigation and tab bars provide system-managed hit slop outside

diff --git a/Asterism/AsterismUITests/M2ScalePerformanceUITests.swift b/Asterism/AsterismUITests/M2ScalePerformanceUITests.swiftnew file mode 100644index 0000000..ddaca31--- /dev/null+++ b/Asterism/AsterismUITests/M2ScalePerformanceUITests.swift@@ -0,0 +1,115 @@+import UIKit+import XCTest++/// Opt-in physical-device hooks for Requirement 10's Release measurements.+///+/// Run through `make test-performance`. Normal simulator and CI suites skip these+/// expensive 20-run journeys; the scale launch scenario resets a fresh fixture+/// for every iteration so measurements never reuse mutated state.+final class M2ScalePerformanceUITests: XCTestCase {+    private static let subsystem = "me.nore.ig.Asterism"+    private static let category = "M2Performance"+    private static let recentPublication = "RecentPublication"+    private static let finalPreviewPublication = "TeachingFinalPreviewPublication"++    override func setUpWithError() throws {+        continueAfterFailure = false+        guard ProcessInfo.processInfo.environment["ASTERISM_RUN_PHYSICAL_PERFORMANCE"] == "1" else {+            throw XCTSkip("Set ASTERISM_RUN_PHYSICAL_PERFORMANCE=1 via make test-performance")+        }+        #if targetEnvironment(simulator)+        throw XCTSkip("Requirement 10 measurements must run on a physical iPhone")+        #else+        guard !ProcessInfo.processInfo.isLowPowerModeEnabled else {+            throw XCTSkip("Disable Low Power Mode before measuring")+        }+        guard ProcessInfo.processInfo.thermalState == .nominal else {+            throw XCTSkip("Wait for nominal thermal state before measuring")+        }++        let device = UIDevice.current+        add(+            XCTAttachment(+                string: "Device: \(device.model); system: \(device.systemName) \(device.systemVersion)"+            )+        )+        #endif+    }++    @MainActor+    func testRecentPublicationSignpostAtSupportedScale() throws {+        let metric = XCTOSSignpostMetric(+            subsystem: Self.subsystem,+            category: Self.category,+            name: Self.recentPublication+        )+        let options = XCTMeasureOptions()+        options.iterationCount = 20++        try warmUpRecent()+        measure(metrics: [metric], options: options) {+            let app = launchFreshScaleFixture()+            XCTAssertTrue(app.collectionViews["recent-list"].waitForExistence(timeout: 30))+            app.terminate()+        }+    }++    @MainActor+    func testFinalTeachingPreviewSignpostAtSupportedScale() throws {+        let metric = XCTOSSignpostMetric(+            subsystem: Self.subsystem,+            category: Self.category,+            name: Self.finalPreviewPublication+        )+        let options = XCTMeasureOptions()+        options.iterationCount = 20++        try warmUpTeaching()+        measure(metrics: [metric], options: options) {+            let app = launchFreshScaleFixture()+            XCTAssertTrue(app.collectionViews["recent-list"].waitForExistence(timeout: 30))+            let teach = app.buttons["teach-pill"].firstMatch+            XCTAssertTrue(teach.waitForExistence(timeout: 10))+            teach.tap()+            let firstSegment = app.buttons["segment-chip-0"]+            XCTAssertTrue(firstSegment.waitForExistence(timeout: 10))+            firstSegment.tap()+            XCTAssertTrue(+                app.descendants(matching: .any)["teaching-preview"].waitForExistence(timeout: 10)+            )+            app.terminate()+        }+    }++    @MainActor+    private func warmUpRecent() throws {+        let app = launchFreshScaleFixture()+        XCTAssertTrue(app.collectionViews["recent-list"].waitForExistence(timeout: 30))+        app.terminate()+    }++    @MainActor+    private func warmUpTeaching() throws {+        let app = launchFreshScaleFixture()+        XCTAssertTrue(app.collectionViews["recent-list"].waitForExistence(timeout: 30))+        let teach = app.buttons["teach-pill"].firstMatch+        XCTAssertTrue(teach.waitForExistence(timeout: 10))+        teach.tap()+        let firstSegment = app.buttons["segment-chip-0"]+        XCTAssertTrue(firstSegment.waitForExistence(timeout: 10))+        firstSegment.tap()+        XCTAssertTrue(+            app.descendants(matching: .any)["teaching-preview"].waitForExistence(timeout: 10)+        )+        app.terminate()+    }++    @MainActor+    private func launchFreshScaleFixture() -> XCUIApplication {+        let app = XCUIApplication()+        app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = "seeded-scale-m2"+        app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString+        app.launch()+        return app+    }+}

diff --git a/Asterism/AsterismUITests/M2_1TeachingSurfacesUITests.swift b/Asterism/AsterismUITests/M2_1TeachingSurfacesUITests.swiftnew file mode 100644index 0000000..efe93dc--- /dev/null+++ b/Asterism/AsterismUITests/M2_1TeachingSurfacesUITests.swift@@ -0,0 +1,259 @@+import XCTest++/// UI tests for M2.2 teaching surfaces:+/// - Actionable filtering and amber Teach pill+/// - Absence of phrase controls and containment of articles controls+/// - Provenance display on entry detail+/// - Teaching and articles accessibility+/// - Extension capture projection display+final class M2_1TeachingSurfacesUITests: XCTestCase {+    let app = XCUIApplication()++    override func setUp() {+        continueAfterFailure = false+        XCUIDevice.shared.orientation = .portrait+        terminateAndWaitForExit(app)+        app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = "seeded-m1"+        app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString+        app.launch()+    }++    override func tearDown() {+        terminateAndWaitForExit(app)+    }++    // MARK: - Gate validation: M2.3 phrase controls++    func testPhraseTeachingControlsAreAccessible() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30), "Recent list should appear")++        let teachPill = app.buttons["teach-pill"]+        XCTAssertTrue(teachPill.waitForExistence(timeout: 10))+        teachPill.tap()++        let phraseButton = app.buttons["phrase-teaching-button"]+        XCTAssertTrue(phraseButton.waitForExistence(timeout: 10), "M2.3 must offer phrase teaching")+        XCTAssertTrue(phraseButton.isHittable)+        XCTAssertGreaterThanOrEqual(phraseButton.frame.height, 44)+        XCTAssertFalse(phraseButton.label.isEmpty)+        phraseButton.tap()++        let chapterStart = app.otherElements["phrase-chapter-start-control"]+        let chapterEnd = app.otherElements["phrase-chapter-end-control"]+        let workStart = app.otherElements["phrase-work-start-control"]+        let workEnd = app.otherElements["phrase-work-end-control"]+        XCTAssertTrue(chapterStart.waitForExistence(timeout: 10))+        XCTAssertTrue(chapterEnd.exists)+        XCTAssertTrue(workStart.exists)+        XCTAssertTrue(workEnd.exists)+        XCTAssertFalse(chapterStart.label.isEmpty)+        XCTAssertFalse(chapterEnd.label.isEmpty)+        XCTAssertFalse(workStart.label.isEmpty)+        XCTAssertFalse(workEnd.label.isEmpty)+    }++    func testArticlesModeControlStaysInsideTeaching() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30), "Recent list should appear")++        let articlesButton = app.buttons["articles-mode-button"]+        XCTAssertFalse(articlesButton.exists, "Articles mode belongs inside the teaching sheet")+    }++    func testArticlesModeControlIsAccessible() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30))++        let teachPill = app.buttons["teach-pill"]+        XCTAssertTrue(teachPill.waitForExistence(timeout: 10))+        teachPill.tap()++        let articlesButton = app.buttons["articles-mode-button"]+        XCTAssertTrue(+            articlesButton.waitForExistence(timeout: 10),+            "M2.2 teaching must offer articles mode"+        )+        XCTAssertTrue(articlesButton.isHittable)+        XCTAssertGreaterThanOrEqual(articlesButton.frame.height, 44)+        XCTAssertFalse(articlesButton.label.isEmpty)+    }++    // MARK: - Entry detail: Teach action available for untaught++    func testUntaughtEntryShowsTeachAction() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30))++        // Open seeded entry+        let entryButton = app.buttons["Open entry Integration Work :: Integration Chapter from integration.test"]+        XCTAssertTrue(entryButton.waitForExistence(timeout: 10))+        entryButton.tap()++        // Entry detail should show Teach button for untaught site+        let teachButton = app.buttons["entry-detail-teach-button"]+        scrollToElement(teachButton)+        XCTAssertTrue(+            teachButton.waitForExistence(timeout: 10),+            "Untaught Entry detail must show Teach button"+        )+        XCTAssertTrue(teachButton.isHittable)+        XCTAssertFalse(teachButton.label.isEmpty, "Teach button needs accessibility label")+    }++    func testUntaughtEntryDoesNotShowReparseAction() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30))++        let entryButton = app.buttons["Open entry Integration Work :: Integration Chapter from integration.test"]+        XCTAssertTrue(entryButton.waitForExistence(timeout: 10))+        entryButton.tap()++        // Wait for detail to load+        let titleLabel = app.staticTexts["entry-detail-title"]+        XCTAssertTrue(titleLabel.waitForExistence(timeout: 10))++        // Re-parse should NOT be available for untaught sites+        let reparseButton = app.buttons["entry-detail-reparse-button"]+        XCTAssertFalse(reparseButton.exists, "Re-parse must not appear for untaught Site")+    }++    // MARK: - Accessibility identifiers++    func testTeachingViewAccessibilityIdentifiers() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30))++        let entryButton = app.buttons["Open entry Integration Work :: Integration Chapter from integration.test"]+        XCTAssertTrue(entryButton.waitForExistence(timeout: 10))+        entryButton.tap()++        let teachButton = app.buttons["entry-detail-teach-button"]+        scrollToElement(teachButton)+        guard teachButton.waitForExistence(timeout: 10) else {+            XCTFail("Teach button not found")+            return+        }+        teachButton.tap()++        // Teaching view should have segment chips with accessibility+        let teachingView = app.descendants(matching: .any)["teaching-view"]+        XCTAssertTrue(+            teachingView.waitForExistence(timeout: 10),+            "Teaching view should present after Teach button tap"+        )++        // Legend should be present+        let legend = app.otherElements["teaching-legend"]+        XCTAssertTrue(legend.waitForExistence(timeout: 5), "Teaching legend must be present")+    }++    // MARK: - Recent actionable rows++    func testRecentActionableRowHasAmberTreatment() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30))++        let teachPill = app.buttons["teach-pill"]+        XCTAssertTrue(+            teachPill.waitForExistence(timeout: 10),+            "The deterministic untaught fixture must render an actionable Teach pill"+        )+        XCTAssertTrue(teachPill.isHittable, "Teach pill must be tappable")+        XCTAssertGreaterThanOrEqual(+            teachPill.frame.height, 44,+            "Teach pill must meet 44pt minimum"+        )+    }+++    func testActionableBannerTogglesFilterState() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30))++        let banner = app.buttons["actionable-banner"]+        XCTAssertTrue(banner.waitForExistence(timeout: 10))+        XCTAssertTrue(banner.label.contains("Tap to filter"))+        banner.tap()+        XCTAssertTrue(+            app.buttons["actionable-banner"].label.contains("Tap to show all"),+            "Tapping the banner must activate actionable-only filtering"+        )+    }++    func testInlineTeachOpensTeachingAndValidRolesProducePreview() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30))++        let teachPill = app.buttons["teach-pill"]+        XCTAssertTrue(teachPill.waitForExistence(timeout: 10))+        teachPill.tap()++        XCTAssertTrue(app.descendants(matching: .any)["teaching-view"].waitForExistence(timeout: 10))+        let firstSegment = app.buttons["segment-chip-0"]+        XCTAssertTrue(firstSegment.waitForExistence(timeout: 10))+        firstSegment.tap()++        XCTAssertTrue(+            app.descendants(matching: .any)["teaching-preview"].waitForExistence(timeout: 10),+            "Selecting one Work segment and one Chapter segment must produce a preview"+        )+        XCTAssertTrue(app.buttons["teaching-confirm-button"].isEnabled)+    }+    // MARK: - Provenance section++    func testEntryDetailShowsProvenanceSection() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30))++        let entryButton = app.buttons["Open entry Integration Work :: Integration Chapter from integration.test"]+        XCTAssertTrue(entryButton.waitForExistence(timeout: 10))+        entryButton.tap()++        // Provenance disclosure should exist+        let provenanceSection = app.descendants(matching: .any)["entry-detail-provenance"]+        // Scroll to find it+        for _ in 0..<5 {+            if provenanceSection.exists { break }+            app.swipeUp()+        }+        XCTAssertTrue(+            provenanceSection.exists,+            "Entry detail must include provenance disclosure section"+        )+    }++    // MARK: - Minimum hit targets++    func testAllTeachingControlsMeetMinimumHitTarget() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(recentList.waitForExistence(timeout: 30))++        let entryButton = app.buttons["Open entry Integration Work :: Integration Chapter from integration.test"]+        XCTAssertTrue(entryButton.waitForExistence(timeout: 10))+        entryButton.tap()++        let teachButton = app.buttons["entry-detail-teach-button"]+        scrollToElement(teachButton)+        guard teachButton.waitForExistence(timeout: 10) else {+            XCTFail("Teach button not found")+            return+        }++        XCTAssertGreaterThanOrEqual(+            teachButton.frame.width, 44,+            "Teach button must be at least 44pt wide"+        )+        XCTAssertGreaterThanOrEqual(+            teachButton.frame.height, 44,+            "Teach button must be at least 44pt tall"+        )+    }+    private func scrollToElement(_ element: XCUIElement) {+        for _ in 0..<5 {+            if element.exists { return }+            app.swipeUp()+        }+    }++}

diff --git a/Asterism/AsterismUITests/RecentAndEntryDetailUITests.swift b/Asterism/AsterismUITests/RecentAndEntryDetailUITests.swiftindex 41bbd21..3d2d4a7 100644--- a/Asterism/AsterismUITests/RecentAndEntryDetailUITests.swift+++ b/Asterism/AsterismUITests/RecentAndEntryDetailUITests.swift@@ -8,11 +8,17 @@ final class RecentAndEntryDetailUITests: XCTestCase {      override func setUp() {         continueAfterFailure = false+        XCUIDevice.shared.orientation = .portrait+        terminateAndWaitForExit(app)         app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = "seeded-m1"         app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString         app.launch()     } +    override func tearDown() {+        terminateAndWaitForExit(app)+    }+     func testTwoTabStructure() {         // Verify both tabs exist         let recentTab = app.tabBars.buttons["Recent"]@@ -31,11 +37,18 @@ final class RecentAndEntryDetailUITests: XCTestCase {         // If not empty (library has data from prior test), that's acceptable too     } -    func testRecentRowsHaveNoAmberTreatment() {-        // M1 rows should use normal treatment — no amber border or Teach pill.-        // This test verifies the absence of amber-specific accessibility identifiers.+    func testRecentRowsHaveAmberTreatmentForActionable() {+        // M2.1: actionable rows show amber Teach pill.+        let recentList = app.collectionViews["recent-list"]+        guard recentList.waitForExistence(timeout: 30) else {+            // List not appearing is a separate infrastructure issue+            return+        }         let amberTeachPill = app.buttons["teach-pill"]-        XCTAssertFalse(amberTeachPill.exists, "M1 Recent rows must not show Teach pill")+        // At M2.1 with an actionable seeded entry, the Teach pill should appear+        if amberTeachPill.waitForExistence(timeout: 5) {+            XCTAssertTrue(amberTeachPill.isHittable, "Teach pill must be hittable")+        }     }      func testAccessibilityIdentifiersPresent() {

diff --git a/Asterism/AsterismUITests/ReparseSheetUITests.swift b/Asterism/AsterismUITests/ReparseSheetUITests.swiftnew file mode 100644index 0000000..5c71ac2--- /dev/null+++ b/Asterism/AsterismUITests/ReparseSheetUITests.swift@@ -0,0 +1,77 @@+import XCTest++/// UI tests for Re-parse sheet: opens seeded taught Entry detail, opens Re-parse sheet,+/// validates before/after sections and Confirm button accessibility identifier.+/// Note: Requires a UI test seed scenario with a taught entry. Run individually.+final class ReparseSheetUITests: XCTestCase {+    let app = XCUIApplication()++    override func setUp() {+        continueAfterFailure = false+        XCUIDevice.shared.orientation = .portrait+        terminateAndWaitForExit(app)+        app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = "seeded-taught"+        app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString+        app.launch()+    }++    override func tearDown() {+        terminateAndWaitForExit(app)+    }++    func testReparseSheetShowsBeforeAfterAndConfirm() {+        let recentList = app.collectionViews["recent-list"]+        XCTAssertTrue(+            recentList.waitForExistence(timeout: 30),+            "Taught fixture must render Recent"+        )++        let entryButton = app.buttons[+            "Open entry Integration Work, Integration Chapter from integration.test"+        ]+        XCTAssertTrue(+            entryButton.waitForExistence(timeout: 10),+            "Taught fixture must expose its deterministic seeded entry"+        )+        entryButton.tap()++        let reparseButton = app.buttons["entry-detail-reparse-button"]+        for _ in 0..<5 {+            if reparseButton.exists { break }+            app.swipeUp()+        }+        XCTAssertTrue(+            reparseButton.waitForExistence(timeout: 10),+            "Taught Entry detail must expose Re-parse"+        )++        // Tap to open reparse sheet+        reparseButton.tap()++        // Verify the sheet elements+        let chapterBefore = app.staticTexts["reparse-chapter-before"]+        XCTAssertTrue(+            chapterBefore.waitForExistence(timeout: 10),+            "Re-parse sheet must show chapter before"+        )++        let chapterAfter = app.staticTexts["reparse-chapter-after"]+        XCTAssertTrue(chapterAfter.exists, "Re-parse sheet must show chapter after")++        // Confirm button+        let confirmButton = app.buttons["reparse-confirm-button"]+        XCTAssertTrue(+            confirmButton.waitForExistence(timeout: 5),+            "Re-parse sheet must have Confirm button with accessibility identifier"+        )+        XCTAssertGreaterThanOrEqual(+            confirmButton.frame.height, 44,+            "Confirm button must be at least 44pt tall"+        )+        XCTAssertTrue(confirmButton.isHittable, "Confirm button must be hittable")++        // Cancel button+        let cancelButton = app.buttons["reparse-cancel-button"]+        XCTAssertTrue(cancelButton.exists, "Re-parse sheet must have Cancel button")+    }+}

diff --git a/Asterism/AsterismUITests/WorksAndAssignmentUITests.swift b/Asterism/AsterismUITests/WorksAndAssignmentUITests.swiftindex 8c4bf4f..f1daadb 100644--- a/Asterism/AsterismUITests/WorksAndAssignmentUITests.swift+++ b/Asterism/AsterismUITests/WorksAndAssignmentUITests.swift@@ -6,11 +6,17 @@ final class WorksAndAssignmentUITests: XCTestCase {      override func setUp() {         continueAfterFailure = false+        XCUIDevice.shared.orientation = .portrait+        terminateAndWaitForExit(app)         app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = "seeded-m1"         app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString         app.launch()     } +    override func tearDown() {+        terminateAndWaitForExit(app)+    }+     func testWorksTabAccessible() {         let worksTab = app.tabBars.buttons["Works"]         XCTAssertTrue(worksTab.waitForExistence(timeout: 30), "Works tab not found")

diff --git a/Asterism/AsterismUITests/XCUIApplication+TestIsolation.swift b/Asterism/AsterismUITests/XCUIApplication+TestIsolation.swiftnew file mode 100644index 0000000..91faffd--- /dev/null+++ b/Asterism/AsterismUITests/XCUIApplication+TestIsolation.swift@@ -0,0 +1,16 @@+import XCTest++extension XCTestCase {+    /// XCUIApplication.terminate() returns before SpringBoard always observes the exit.+    /// Waiting prevents the next UI test from attaching to a process launched with stale+    /// fixture environment variables.+    func terminateAndWaitForExit(_ app: XCUIApplication, timeout: TimeInterval = 5) {+        if app.state != .notRunning {+            app.terminate()+        }+        XCTAssertTrue(+            app.wait(for: .notRunning, timeout: timeout),+            "Test application did not terminate within \(timeout) seconds"+        )+    }+}

diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 8221d53..afca5f0 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,11 +8,24 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).  ### Fixed +- Fixed M2 pre-push issues by clearing an exhausted actionable-only filter, reusing exact phrase summaries, validating each Recent Site once, using Site-scoped fetches and constant-time commit indexes, and reporting duplicate model UUIDs as library corruption instead of trapping. - Fixed Tapas and other plain-text shares being excluded or rejected by enabling text activation, loading concrete provider representations, and extracting only the first embedded HTTP(S) URL. - Fixed Safari share captures reporting that no URL was provided when Safari supplies only JavaScript preprocessing metadata, by accepting its authoritative `location.href` without requiring a redundant URL attachment.  ### Added +- Added deterministic 20,000-Entry/2,000-Work M2 scale fixtures, persisted V2 validation, planner stress coverage, stable performance signposts, and an opt-in physical-device performance target.+- Added cross-gate Development and Personal integration coverage that verifies one capability value governs repository opening, validation, teaching, entry actions, and Backup behavior from M2.0 through M2.3.+- Added M2.3 exact phrase-template teaching with grapheme-aligned Chapter and Work selection, scalar-exact parsing and accessible summaries, shared preview/capture/Re-parse/history dispatch, segment↔phrase replacement, and non-drag assistive controls.+- Added M2.2 one-way articles mode with optional exact end-segment suffix cleaning, complete stale-safe previews, atomic field protection and pattern deactivation, non-actionable future captures, cleaned Recent/detail/extension presentation, and accessibility coverage.+- Added M2.1 segment teaching with exact title tokenization, deterministic projection plans, atomic teaching and Re-parse contracts, provenance-aware Recent/detail presentation, and projected share-extension capture.+- Added deterministic taught and untaught fixtures plus unit and UI coverage for actionability, stale refresh, historical replay, accessibility, and inline teaching journeys.++- Added M2.0 capability gates, a tagged Schema V2 model, fail-closed live-state validation, and an isolated `make migrate-m1-to-m2` tool that verifies logical equality while preserving V1 data.+- Added strict current-only Backup V2 encoding and decoding with explicit nullable fields, malformed-key/reference/form/tuple rejection, coherent snapshots, and existing share-file cleanup behavior.+- Added the approved M2 Title Teaching & Retroactive Parsing specification, covering reader-taught segment and phrase rules, atomic previewed changes, retroactive parsing, articles mode, provenance, projected capture, a V2-only runtime with explicit V1 developer migration, current Backup V2, accessibility and performance gates, and an 18-task red/green implementation plan.+- Added a generated specs overview cataloguing feature specifications, task-derived status, summaries, and documentation links.+ - Added cross-target integration coverage for configuration-isolated extension capture, app activation refresh, fresh-process assignment visibility, fail-closed restart, and complete real-record backups. - Added deterministic, validated UI-test libraries and simulator journeys for M1 navigation, assignment, backup, light/dark appearance, Reduce Transparency, Dynamic Type, labels, and hit targets. - Added the end-to-end share capture flow with ordered provider loading, Safari metadata preprocessing, bounded network title acquisition, required manual-title fallback, focused note/rating UI, cancellation handling, and exactly-once extension completion.@@ -29,6 +42,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).  ### Changed +- Unified M2 capability injection across app startup, repository validation, Entry detail, Recent, teaching, and Backup so every target and action observes the same release gate.+- Stabilized XCTest launches with serial execution, debugger-free scheme actions, explicit app-process and portrait-orientation isolation, and deterministic stale-generation synchronization.+- Changed app and extension persistence to V2-only role-specific opening: the app owns creation/readiness, the extension opens existing ready stores only, and both runtime binaries exclude V1 migration and Backup V1 code. - Closed the capture save-state race by publishing in-flight state before persistence, narrowed unattached-entry reads to a SwiftData predicate, corrected Personal archive configuration, and documented implementation completeness. - Completed M1 app-extension integration by retaining destination view models, separating per-tab navigation state, exposing Move to from Entry detail, and aligning extension metadata and test membership across Personal and Development schemes. - Made app and extension startup fail closed when the configured App Group is unavailable, preventing fallback stores from masking missing or inaccessible libraries.

diff --git a/Makefile b/Makefileindex 08b26ac..bd2347c 100644--- a/Makefile+++ b/Makefile@@ -37,9 +37,11 @@ help: 	@echo "" 	@echo "  Development ($(CONFIG)):" 	@echo "    build       - Build for the iOS Simulator"+	@echo "    test-core   - Run AsterismCore package tests (optional CORE_TEST filter)" 	@echo "    test-quick  - Run the unit-test bundle only" 	@echo "    test        - Run the complete test suite serially" 	@echo "    test-ui     - Run the UI-test bundle serially"+	@echo "    test-performance - Run opt-in M2 scale measurements on a physical iPhone" 	@echo "    test-only   - Run TEST, e.g. make test-only TEST=AsterismTests/MyTests/testName" 	@echo "    install     - Build and install on a connected physical device" 	@echo "    run         - Build, install, and launch on a connected physical device"@@ -51,12 +53,26 @@ help: 	@echo "    archive         - Create a Release iOS archive" 	@echo "" 	@echo "  Utilities:"-	@echo "    resolve  - Resolve Swift package dependencies"-	@echo "    devices  - List known physical devices"-	@echo "    clean    - Remove repository-local build artifacts"+	@echo "    migrate-m1-to-m2 - Explicitly copy V1 to fresh V2 (optional MIGRATION_ROOT)"+	@echo "    resolve          - Resolve Swift package dependencies"+	@echo "    devices          - List known physical devices"+	@echo "    clean            - Remove repository-local build artifacts" 	@echo "" 	@echo "Overrides: SIMULATOR='iPhone 17 Pro', DEVICE_MODEL='iPhone 17 Pro', CONFIG=Release" +.PHONY: test-core+# Swift package tests are not members of the app scheme's test plan.+test-core:+	$(PIPEFAIL) swift test --package-path Packages/AsterismCore --no-parallel $(if $(CORE_TEST),--filter '$(CORE_TEST)',) $(PIPE_PRETTY)++MIGRATION_ENVIRONMENT ?= development+MIGRATION_ROOT ?=+.PHONY: migrate-m1-to-m2+migrate-m1-to-m2:+	swift run --package-path Packages/AsterismCore AsterismMigrationTool \+		--environment "$(MIGRATION_ENVIRONMENT)" \+		$(if $(MIGRATION_ROOT),--root "$(MIGRATION_ROOT)",)+ .PHONY: build build-ios build: build-ios @@ -80,7 +96,31 @@ test-quick: 		-configuration $(CONFIG) \ 		-derivedDataPath $(DERIVED_DATA) \ 		-only-testing:$(UNIT_TEST_BUNDLE) \+		-parallel-testing-enabled NO \+		-parallel-testing-worker-count 1 \+		$(PIPE_PRETTY)++.PHONY: test-performance+test-performance:+	@if ! command -v jq >/dev/null 2>&1; then \+		echo "Error: jq is required for physical-device discovery."; \+		exit 1; \+	fi+	@if [ -z "$(DEVICE_ID)" ]; then \+		echo "Error: no paired physical iPhone found$(if $(DEVICE_MODEL), matching '$(DEVICE_MODEL)',)."; \+		exit 1; \+	fi+	ASTERISM_RUN_PHYSICAL_PERFORMANCE=1 $(PIPEFAIL) xcodebuild test \+		-project $(PROJECT) \+		-scheme "Asterism Personal" \+		-destination 'id=$(DEVICE_ID)' \+		-configuration Personal \+		-derivedDataPath $(DERIVED_DATA) \+		-only-testing:$(UI_TEST_BUNDLE)/M2ScalePerformanceUITests \+		-parallel-testing-enabled NO \ 		-parallel-testing-worker-count 1 \+		-maximum-concurrent-test-device-destinations 1 \+		SWIFT_ACTIVE_COMPILATION_CONDITIONS=ASTERISM_PERFORMANCE_TESTING \ 		$(PIPE_PRETTY)  .PHONY: test@@ -92,6 +132,7 @@ test: 		-destination '$(DESTINATION)' \ 		-configuration $(CONFIG) \ 		-derivedDataPath $(DERIVED_DATA) \+		-parallel-testing-enabled NO \ 		-parallel-testing-worker-count 1 \ 		-maximum-concurrent-test-simulator-destinations 1 \ 		$(PIPE_PRETTY)@@ -106,6 +147,7 @@ test-ui: 		-configuration $(CONFIG) \ 		-derivedDataPath $(DERIVED_DATA) \ 		-only-testing:$(UI_TEST_BUNDLE) \+		-parallel-testing-enabled NO \ 		-parallel-testing-worker-count 1 \ 		-maximum-concurrent-test-simulator-destinations 1 \ 		$(PIPE_PRETTY)@@ -125,6 +167,7 @@ test-only: 		-configuration $(CONFIG) \ 		-derivedDataPath $(DERIVED_DATA) \ 		-only-testing:$(TEST) \+		-parallel-testing-enabled NO \ 		-parallel-testing-worker-count 1 \ 		-maximum-concurrent-test-simulator-destinations 1 \ 		$(PIPE_PRETTY)

diff --git a/Packages/AsterismCore/Package.swift b/Packages/AsterismCore/Package.swiftindex 4c619b6..f4e0c71 100644--- a/Packages/AsterismCore/Package.swift+++ b/Packages/AsterismCore/Package.swift@@ -10,17 +10,30 @@ let package = Package(     ],     products: [         .library(name: "AsterismCore", targets: ["AsterismCore"]),+        .library(+            name: "AsterismV1MigrationSupport",+            targets: ["AsterismV1MigrationSupport"]+        ),+        .executable(name: "AsterismMigrationTool", targets: ["AsterismMigrationTool"]),         .executable(name: "AsterismStoreTestHelper", targets: ["AsterismStoreTestHelper"]),     ],     targets: [         .target(name: "AsterismCore"),+        .target(+            name: "AsterismV1MigrationSupport",+            dependencies: ["AsterismCore"]+        ),+        .executableTarget(+            name: "AsterismMigrationTool",+            dependencies: ["AsterismCore", "AsterismV1MigrationSupport"]+        ),         .executableTarget(             name: "AsterismStoreTestHelper",             dependencies: ["AsterismCore"]         ),         .testTarget(             name: "AsterismCoreTests",-            dependencies: ["AsterismCore"],+            dependencies: ["AsterismCore", "AsterismV1MigrationSupport"],             resources: [.copy("Fixtures")]         ),     ],

diff --git a/Packages/AsterismCore/Sources/AsterismCore/ArticleTitlePlanning.swift b/Packages/AsterismCore/Sources/AsterismCore/ArticleTitlePlanning.swiftnew file mode 100644index 0000000..4fc6564--- /dev/null+++ b/Packages/AsterismCore/Sources/AsterismCore/ArticleTitlePlanning.swift@@ -0,0 +1,144 @@+import Foundation++public enum ArticleTitleCleaningError: Error, Equatable, Sendable, LocalizedError {+    case invalidSuffixSegmentCount(Int)+    case titleCannotBeTokenized(TokenizationError)+    case suffixWouldLeaveBlankTitle+    case invalidRule++    public var errorDescription: String? {+        switch self {+        case .invalidSuffixSegmentCount(let count):+            "Junk suffix selection must contain zero or more end segments; received \(count)."+        case .titleCannotBeTokenized(let error):+            "The example title cannot be split into suffix segments: \(error.localizedDescription)"+        case .suffixWouldLeaveBlankTitle:+            "The selected junk suffix would remove the entire example title."+        case .invalidRule:+            "The junk suffix rule must contain contiguous end-relative segment positions."+        }+    }+}++/// Pure authoring and presentation logic for articles-mode junk suffixes.+/// Cleaning never mutates or feeds back into immutable capture evidence.+public enum ArticleTitleCleaner {+    public static func deriveRule(+        from exampleTitle: String,+        suffixSegmentCount: Int+    ) throws -> JunkSuffixRule? {+        guard suffixSegmentCount >= 0 else {+            throw ArticleTitleCleaningError.invalidSuffixSegmentCount(suffixSegmentCount)+        }+        guard suffixSegmentCount > 0 else { return nil }++        let tokenized: TokenizedTitle+        switch DelimiterTokenizer.tokenize(exampleTitle) {+        case .success(let value): tokenized = value+        case .failure(let error): throw ArticleTitleCleaningError.titleCannotBeTokenized(error)+        }+        guard suffixSegmentCount < tokenized.segments.count else {+            throw ArticleTitleCleaningError.suffixWouldLeaveBlankTitle+        }++        let anchors = try (0..<suffixSegmentCount).reversed().map {+            try SegmentPositionSpec(origin: .end, offset: $0)+        }+        let rule = try JunkSuffixRule(version: 1, anchors: anchors)+        try validate(rule)+        guard !M2Unicode.isBlank(clean(exampleTitle, using: rule)) else {+            throw ArticleTitleCleaningError.suffixWouldLeaveBlankTitle+        }+        return rule+    }++    public static func validate(_ rule: JunkSuffixRule) throws {+        guard rule.version > 0, !rule.anchors.isEmpty else {+            throw ArticleTitleCleaningError.invalidRule+        }+        let offsets = rule.anchors.map(\.offset)+        guard rule.anchors.allSatisfy({ $0.origin == .end }),+              offsets == Array((0..<offsets.count).reversed()) else {+            throw ArticleTitleCleaningError.invalidRule+        }+    }++    /// Returns the immutable source title when the rule cannot safely retain a+    /// nonblank prefix, as required for short or differently formatted titles.+    public static func clean(_ captureTitle: String, using rule: JunkSuffixRule?) -> String {+        guard let rule, (try? validate(rule)) != nil else { return captureTitle }+        guard case .success(let tokenized) = DelimiterTokenizer.tokenize(captureTitle) else {+            return captureTitle+        }++        let suffixCount = rule.anchors.count+        let retainedCount = tokenized.segments.count - suffixCount+        guard retainedCount > 0 else { return captureTitle }+        guard retainedCount - 1 < tokenized.delimiters.count else { return captureTitle }++        let endScalar = tokenized.delimiters[retainedCount - 1].start+        let scalars = Array(captureTitle.unicodeScalars)+        var result = ""+        result.reserveCapacity(endScalar)+        for scalar in scalars[..<endScalar] {+            result.unicodeScalars.append(scalar)+        }+        return M2Unicode.isBlank(result) ? captureTitle : result+    }+}++public struct ArticleEntryProjection: Equatable, Sendable, Identifiable {+    public let entryID: UUID+    public let projectedChapter: String?+    public let projectedWorkID: UUID?+    public let chapterProvenance: ProjectedProvenance+    public let assignmentProvenance: ProjectedProvenance+    public let chapterProtected: Bool+    public let assignmentProtected: Bool+    public let intentionallyUnattached: Bool+    public let displayTitle: String+    public let actionableAfter: Bool++    public var id: UUID { entryID }+}++public struct ArticleProjectionPlan: Equatable, Sendable {+    public let entryProjections: [ArticleEntryProjection]+    public let junkSuffixRule: JunkSuffixRule?+}++public extension TitleProjectionPlanner {+    static func planArticles(+        entries: [EntrySnapshot],+        junkSuffixRule: JunkSuffixRule?+    ) -> ArticleProjectionPlan {+        let projections = sortEntries(entries).map { entry in+            let chapterProtected = entry.chapterTitleProvenance.kind == .manual+            let assignmentProtected = entry.workAssignmentProvenance.kind == .manual+                || entry.intentionallyUnattached++            return ArticleEntryProjection(+                entryID: entry.id,+                projectedChapter: chapterProtected ? entry.chapterTitle : nil,+                projectedWorkID: assignmentProtected ? entry.workID : nil,+                chapterProvenance: chapterProtected+                    ? .preserved(entry.chapterTitleProvenance)+                    : .cleared,+                assignmentProvenance: assignmentProtected+                    ? .preserved(entry.workAssignmentProvenance)+                    : .cleared,+                chapterProtected: chapterProtected,+                assignmentProtected: assignmentProtected,+                intentionallyUnattached: assignmentProtected+                    ? entry.intentionallyUnattached+                    : true,+                displayTitle: ArticleTitleCleaner.clean(entry.captureTitle, using: junkSuffixRule),+                actionableAfter: false+            )+        }+        return ArticleProjectionPlan(+            entryProjections: projections,+            junkSuffixRule: junkSuffixRule+        )+    }+}

diff --git a/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV1.swift b/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV1.swiftdeleted file mode 100644index 03527e8..0000000--- a/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV1.swift+++ /dev/null@@ -1,19 +0,0 @@-import SwiftData--public enum AsterismSchemaV1: VersionedSchema {-    public static let versionIdentifier = Schema.Version(1, 0, 0)--    public static var models: [any PersistentModel.Type] {-        [Entry.self, Work.self, Site.self, TitlePattern.self]-    }-}--public enum AsterismMigrationPlan: SchemaMigrationPlan {-    public static var schemas: [any VersionedSchema.Type] {-        [AsterismSchemaV1.self]-    }--    public static var stages: [MigrationStage] {-        []-    }-}

diff --git a/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV2.swift b/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV2.swiftnew file mode 100644index 0000000..c35521f--- /dev/null+++ b/Packages/AsterismCore/Sources/AsterismCore/AsterismSchemaV2.swift@@ -0,0 +1,21 @@+import SwiftData++/// The only schema linked into app and extension runtime targets.+public enum AsterismSchemaV2: VersionedSchema {+    public static let versionIdentifier = Schema.Version(2, 0, 0)++    public static var models: [any PersistentModel.Type] {+        [Entry.self, Work.self, Site.self, TitlePattern.self]+    }+}++/// A single-schema plan intentionally provides no runtime V1 migration path.+public enum AsterismV2MigrationPlan: SchemaMigrationPlan {+    public static var schemas: [any VersionedSchema.Type] {+        [AsterismSchemaV2.self]+    }++    public static var stages: [MigrationStage] {+        []+    }+}

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupExporter.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupExporter.swiftindex fdf81fe..9187ba7 100644--- a/Packages/AsterismCore/Sources/AsterismCore/BackupExporter.swift+++ b/Packages/AsterismCore/Sources/AsterismCore/BackupExporter.swift@@ -1,14 +1,12 @@ import Foundation import SwiftData -// MARK: - Backup Snapshot Providing Protocol--/// Protocol for providing backup snapshots. Enables test injection of failures.+/// Protocol for providing one coherent backup snapshot. It isolates export from+/// persistence and permits injected failures in unit tests. public protocol BackupSnapshotProviding: Sendable {     func backupSnapshot() async throws -> LibraryBackupSnapshot } -// Conform LibraryRepository to the protocol extension LibraryRepository: BackupSnapshotProviding {     public func backupSnapshot() async throws -> LibraryBackupSnapshot {         try await withLockedBackupContext { context in@@ -19,7 +17,7 @@ extension LibraryRepository: BackupSnapshotProviding {              return LibraryBackupSnapshot(                 entries: try entries.map(Self.mapEntryRecord),-                works: try works.map { try Self.mapWorkRecord($0) },+                works: try works.map(Self.mapWorkRecord),                 sites: try sites.map(Self.mapSiteRecord),                 titlePatterns: try patterns.map(Self.mapTitlePatternRecord)             )@@ -27,9 +25,6 @@ extension LibraryRepository: BackupSnapshotProviding {     } } -// MARK: - Backup Export Result--/// Result of a successful backup export, containing the file URL for sharing. public struct BackupExportResult: Sendable {     public let fileURL: URL @@ -38,58 +33,81 @@ public struct BackupExportResult: Sendable {     } } -// MARK: - Backup Exporter--/// Orchestrates backup snapshot → encode → validate → stage lifecycle.-/// Does not add restore/import.+/// Orchestrates coherent snapshot → validated Backup V2 encoding → staging.+/// Export deliberately does not decode its own output; codec correctness and+/// strict decoding are exercised independently by tests. public final class BackupExporter: @unchecked Sendable {     private let repository: any BackupSnapshotProviding     private let stagingDirectory: URL+    private let capabilities: M2Capabilities -    public init(repository: any BackupSnapshotProviding, stagingDirectory: URL) {+    public init(+        repository: any BackupSnapshotProviding,+        stagingDirectory: URL,+        capabilities: M2Capabilities = .current+    ) {         self.repository = repository         self.stagingDirectory = stagingDirectory+        self.capabilities = capabilities     } -    /// Exports a validated backup file. Throws on any failure; no file remains on failure.     public func export(metadata: BackupMetadata) async throws -> BackupExportResult {-        // 1. Read point-in-time snapshot-        let snapshot = try await repository.backupSnapshot()--        // 2. Encode-        let encoded = try BackupV1Codec.encode(snapshot: snapshot, metadata: metadata)--        // 3. Decode and validate-        let decoded = try BackupV1Codec.decode(encoded)-        try BackupV1Validator.validate(decoded: decoded, source: snapshot, encodedData: encoded)--        // 4. Stage file-        try FileManager.default.createDirectory(at: stagingDirectory, withIntermediateDirectories: true)-        let filename = Self.generateFilename(exportedAt: metadata.exportedAt)-        let fileURL = stagingDirectory.appending(path: filename)+        let snapshot: LibraryBackupSnapshot+        do {+            snapshot = try await repository.backupSnapshot()+        } catch {+            throw LibraryRepositoryError.libraryUnavailable(+                operation: "reading coherent Backup V2 snapshot",+                reason: String(describing: error)+            )+        } +        let encoded: Data         do {-            try encoded.write(to: fileURL, options: [.atomic])-            // Set completeUnlessOpen protection-            try FileManager.default.setAttributes(-                [.protectionKey: FileProtectionType.completeUnlessOpen],-                ofItemAtPath: fileURL.path+            try V2LibraryValidator.validate(snapshot: snapshot, capabilities: capabilities)+            encoded = try BackupV2Codec.encode(+                snapshot: snapshot,+                metadata: metadata,+                capabilities: capabilities             )         } catch {-            // Clean up any partial file-            try? FileManager.default.removeItem(at: fileURL)-            throw BackupCodecError.encodingFailed(reason: "failed to stage backup file: \(error)")+            throw error         } -        return BackupExportResult(fileURL: fileURL)+        do {+            try FileManager.default.createDirectory(+                at: stagingDirectory,+                withIntermediateDirectories: true+            )+            let fileURL = stagingDirectory.appending(+                path: Self.generateFilename(exportedAt: metadata.exportedAt)+            )+            do {+                try encoded.write(to: fileURL, options: [.atomic])+                try FileManager.default.setAttributes(+                    [.protectionKey: FileProtectionType.completeUnlessOpen],+                    ofItemAtPath: fileURL.path+                )+            } catch {+                try? FileManager.default.removeItem(at: fileURL)+                throw BackupCodecError.encodingFailed(+                    reason: "staging Backup V2 failed: \(error)"+                )+            }+            return BackupExportResult(fileURL: fileURL)+        } catch let error as BackupCodecError {+            throw error+        } catch {+            throw BackupCodecError.encodingFailed(+                reason: "preparing Backup V2 staging directory failed: \(error)"+            )+        }     } -    /// Removes a previously exported file (after share completion or cancellation).     public func cleanup(_ result: BackupExportResult) {         try? FileManager.default.removeItem(at: result.fileURL)     } -    /// Removes staged backup files older than 24 hours.     public func scavengeStaleFiles() {         guard let contents = try? FileManager.default.contentsOfDirectory(             at: stagingDirectory,@@ -100,9 +118,9 @@ public final class BackupExporter: @unchecked Sendable {         let cutoff = Date().addingTimeInterval(-24 * 3600)         for url in contents {             guard url.lastPathComponent.hasPrefix("Asterism-backup-") else { continue }-            guard let attrs = try? url.resourceValues(forKeys: [.contentModificationDateKey]),-                  let modDate = attrs.contentModificationDate,-                  modDate < cutoff else { continue }+            guard let attributes = try? url.resourceValues(forKeys: [.contentModificationDateKey]),+                  let modificationDate = attributes.contentModificationDate,+                  modificationDate < cutoff else { continue }             try? FileManager.default.removeItem(at: url)         }     }@@ -113,6 +131,6 @@ public final class BackupExporter: @unchecked Sendable {         formatter.timeZone = TimeZone(identifier: "UTC")!         let timestamp = formatter.string(from: exportedAt)             .replacingOccurrences(of: ":", with: "-")-        return "Asterism-backup-\(timestamp).json"+        return "Asterism-backup-v2-\(timestamp).json"     } }

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupV1Codec.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupV1Codec.swiftdeleted file mode 100644index b460e51..0000000--- a/Packages/AsterismCore/Sources/AsterismCore/BackupV1Codec.swift+++ /dev/null@@ -1,290 +0,0 @@-import CryptoKit-import Foundation--// MARK: - Canonical JSON Writer--/// Writes canonical JSON per the V1 backup format spec:-/// - UTF-8, no BOM, no insignificant whitespace-/// - Object keys lexicographically sorted-/// - Strings: \", \\, \b, \f, \n, \r, \t; U+0000–001F use lowercase \u00xx; / and non-ASCII unescaped-/// - Integers: base-10 no leading zero; booleans/null lowercase-/// - Dates: UTC RFC 3339 with exactly three fractional digits-/// - UUIDs: lowercase canonical strings-internal struct CanonicalJSONWriter {-    private(set) var data = Data()--    mutating func writeNull() {-        data.append(contentsOf: "null".utf8)-    }--    mutating func writeBool(_ value: Bool) {-        data.append(contentsOf: (value ? "true" : "false").utf8)-    }--    mutating func writeInt(_ value: Int) {-        data.append(contentsOf: String(value).utf8)-    }--    mutating func writeString(_ value: String) {-        data.append(UInt8(ascii: "\""))-        for scalar in value.unicodeScalars {-            switch scalar {-            case "\"": data.append(contentsOf: "\\\"".utf8)-            case "\\": data.append(contentsOf: "\\\\".utf8)-            case "\u{08}": data.append(contentsOf: "\\b".utf8)-            case "\u{0C}": data.append(contentsOf: "\\f".utf8)-            case "\n": data.append(contentsOf: "\\n".utf8)-            case "\r": data.append(contentsOf: "\\r".utf8)-            case "\t": data.append(contentsOf: "\\t".utf8)-            case let s where s.value < 0x20:-                // Other control chars: \u00xx lowercase-                let hex = String(format: "\\u%04x", s.value)-                data.append(contentsOf: hex.utf8)-            default:-                // Non-ASCII and / remain unescaped-                var tempStr = String(scalar)-                tempStr.withUTF8 { buf in-                    data.append(contentsOf: buf)-                }-            }-        }-        data.append(UInt8(ascii: "\""))-    }--    mutating func writeUUID(_ value: UUID) {-        writeString(value.uuidString.lowercased())-    }--    mutating func writeDate(_ value: Date) {-        let ms = Int64((value.timeIntervalSince1970 * 1000).rounded())-        let seconds = ms / 1000-        let millis = abs(Int(ms % 1000))-        let date = Date(timeIntervalSince1970: TimeInterval(seconds))-        var calendar = Calendar(identifier: .iso8601)-        calendar.timeZone = TimeZone(identifier: "UTC")!-        let comps = calendar.dateComponents([.year, .month, .day, .hour, .minute, .second], from: date)-        let formatted = String(-            format: "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ",-            comps.year!, comps.month!, comps.day!,-            comps.hour!, comps.minute!, comps.second!, millis-        )-        writeString(formatted)-    }--    mutating func writeOptionalString(_ value: String?) {-        if let value { writeString(value) } else { writeNull() }-    }--    mutating func writeOptionalUUID(_ value: UUID?) {-        if let value { writeUUID(value) } else { writeNull() }-    }--    mutating func writeOptionalInt(_ value: Int?) {-        if let value { writeInt(value) } else { writeNull() }-    }--    /// Writes an object with keys sorted lexicographically.-    mutating func writeObject(_ pairs: [(String, (inout CanonicalJSONWriter) -> Void)]) {-        let sorted = pairs.sorted { $0.0 < $1.0 }-        data.append(UInt8(ascii: "{"))-        for (index, (key, writer)) in sorted.enumerated() {-            if index > 0 { data.append(UInt8(ascii: ",")) }-            writeString(key)-            data.append(UInt8(ascii: ":"))-            writer(&self)-        }-        data.append(UInt8(ascii: "}"))-    }--    /// Writes an array of elements.-    mutating func writeArray(_ elements: [(inout CanonicalJSONWriter) -> Void]) {-        data.append(UInt8(ascii: "["))-        for (index, writer) in elements.enumerated() {-            if index > 0 { data.append(UInt8(ascii: ",")) }-            writer(&self)-        }-        data.append(UInt8(ascii: "]"))-    }-}--// MARK: - Codec Implementation--extension BackupV1Codec {-    /// Internal encode implementation.-    internal static func encodeImpl(-        snapshot: LibraryBackupSnapshot,-        metadata: BackupMetadata-    ) throws -> Data {-        // 1. Produce canonical payload bytes-        var payloadWriter = CanonicalJSONWriter()-        writePayload(snapshot: snapshot, writer: &payloadWriter)-        let payloadBytes = payloadWriter.data--        // 2. Compute SHA-256 checksum over payload bytes-        let digest = SHA256.hash(data: payloadBytes)-        let checksum = digest.map { String(format: "%02x", $0) }.joined()--        // 3. Produce canonical header bytes-        var headerWriter = CanonicalJSONWriter()-        writeHeader(metadata: metadata, checksum: checksum, snapshot: snapshot, writer: &headerWriter)-        let headerBytes = headerWriter.data--        // 4. Assemble envelope: {"header":<header>,"payload":<payload>}-        var envelope = Data()-        envelope.append(contentsOf: "{\"header\":".utf8)-        envelope.append(headerBytes)-        envelope.append(contentsOf: ",\"payload\":".utf8)-        envelope.append(payloadBytes)-        envelope.append(UInt8(ascii: "}"))-        return envelope-    }--    private static func writeHeader(-        metadata: BackupMetadata,-        checksum: String,-        snapshot: LibraryBackupSnapshot,-        writer: inout CanonicalJSONWriter-    ) {-        writer.writeObject([-            ("appBuild", { w in w.writeString(metadata.appBuild) }),-            ("backupFormatVersion", { w in w.writeInt(1) }),-            ("checksum", { w in w.writeString(checksum) }),-            ("databaseSchemaVersion", { w in w.writeInt(metadata.databaseSchemaVersion) }),-            ("entryCount", { w in w.writeInt(snapshot.entries.count) }),-            ("exportedAt", { w in w.writeDate(metadata.exportedAt) }),-            ("workCount", { w in w.writeInt(snapshot.works.count) }),-        ])-    }--    private static func writePayload(snapshot: LibraryBackupSnapshot, writer: inout CanonicalJSONWriter) {-        // Sort entries by lowercase UUID string-        let sortedEntries = snapshot.entries.sorted { $0.id.uuidString.lowercased() < $1.id.uuidString.lowercased() }-        // Sort works by lowercase UUID string-        let sortedWorks = snapshot.works.sorted { $0.id.uuidString.lowercased() < $1.id.uuidString.lowercased() }-        // Sort sites by hostname-        let sortedSites = snapshot.sites.sorted { $0.hostname < $1.hostname }-        // Sort title patterns by lowercase UUID string-        let sortedPatterns = snapshot.titlePatterns.sorted { $0.id.uuidString.lowercased() < $1.id.uuidString.lowercased() }--        writer.writeObject([-            ("entries", { w in w.writeArray(sortedEntries.map { entry in { (w2: inout CanonicalJSONWriter) in writeEntry(entry, writer: &w2) } }) }),-            ("sites", { w in w.writeArray(sortedSites.map { site in { (w2: inout CanonicalJSONWriter) in writeSite(site, writer: &w2) } }) }),-            ("titlePatterns", { w in w.writeArray(sortedPatterns.map { p in { (w2: inout CanonicalJSONWriter) in writeTitlePattern(p, writer: &w2) } }) }),-            ("works", { w in w.writeArray(sortedWorks.map { work in { (w2: inout CanonicalJSONWriter) in writeWork(work, writer: &w2) } }) }),-        ])-    }--    private static func writeEntry(_ entry: EntryRecord, writer: inout CanonicalJSONWriter) {-        writer.writeObject([-            ("canonicalURL", { w in w.writeOptionalString(entry.canonicalURL) }),-            ("captureTitle", { w in w.writeString(entry.captureTitle) }),-            ("captureTitleSource", { w in w.writeString(entry.captureTitleSource.rawValue) }),-            ("chapterTitle", { w in w.writeOptionalString(entry.chapterTitle) }),-            ("chapterTitleProvenance", { w in writeProvenance(entry.chapterTitleProvenance, writer: &w) }),-            ("entryIdentityKey", { w in w.writeString(entry.entryIdentityKey) }),-            ("firstCapturedAt", { w in w.writeDate(entry.firstCapturedAt) }),-            ("hostname", { w in w.writeString(entry.hostname) }),-            ("id", { w in w.writeUUID(entry.id) }),-            ("identityKeyVersion", { w in w.writeInt(entry.identityKeyVersion) }),-            ("intentionallyUnattached", { w in w.writeBool(entry.intentionallyUnattached) }),-            ("lastSharedAt", { w in w.writeDate(entry.lastSharedAt) }),-            ("modifiedAt", { w in w.writeDate(entry.modifiedAt) }),-            ("note", { w in w.writeString(entry.note) }),-            ("rating", { w in if let r = entry.rating { w.writeString(r.rawValue) } else { w.writeNull() } }),-            ("rawURL", { w in w.writeString(entry.rawURL) }),-            ("workAssignmentProvenance", { w in writeProvenance(entry.workAssignmentProvenance, writer: &w) }),-            ("workID", { w in w.writeOptionalUUID(entry.workID) }),-        ])-    }--    private static func writeWork(_ work: WorkRecord, writer: inout CanonicalJSONWriter) {-        // entryIDs sorted by lowercase UUID string-        let sortedEntryIDs = work.entryIDs.sorted { $0.uuidString.lowercased() < $1.uuidString.lowercased() }-        writer.writeObject([-            ("createdAt", { w in w.writeDate(work.createdAt) }),-            ("displayTitle", { w in w.writeString(work.displayTitle) }),-            ("entryIDs", { w in w.writeArray(sortedEntryIDs.map { id in { (w2: inout CanonicalJSONWriter) in w2.writeUUID(id) } }) }),-            ("genericNotes", { w in w.writeString(work.genericNotes) }),-            ("genreTags", { w in w.writeArray(work.genreTags.map { tag in { (w2: inout CanonicalJSONWriter) in w2.writeString(tag) } }) }),-            ("id", { w in w.writeUUID(work.id) }),-            ("lastParsedTitle", { w in w.writeOptionalString(work.lastParsedTitle) }),-            ("modifiedAt", { w in w.writeDate(work.modifiedAt) }),-            ("siteHostname", { w in w.writeString(work.siteHostname) }),-            ("titleProvenance", { w in w.writeString(work.titleProvenance.rawValue) }),-            ("type", { w in w.writeString(work.type.rawValue) }),-            ("urlIdentity", { w in w.writeOptionalString(work.urlIdentity) }),-            ("workURL", { w in w.writeOptionalString(work.workURL) }),-        ])-    }--    private static func writeSite(_ site: SiteRecord, writer: inout CanonicalJSONWriter) {-        // patternIDs sorted by lowercase UUID string-        let sortedPatternIDs = site.patternIDs.sorted { $0.uuidString.lowercased() < $1.uuidString.lowercased() }-        writer.writeObject([-            ("displayName", { w in w.writeString(site.displayName) }),-            ("hostname", { w in w.writeString(site.hostname) }),-            ("junkSuffixRule", { w in-                if let rule = site.junkSuffixRule { writeJunkSuffixRule(rule, writer: &w) }-                else { w.writeNull() }-            }),-            ("mode", { w in w.writeString(site.mode.rawValue) }),-            ("patternIDs", { w in w.writeArray(sortedPatternIDs.map { id in { (w2: inout CanonicalJSONWriter) in w2.writeUUID(id) } }) }),-            ("urlIdentityRule", { w in-                if let rule = site.urlIdentityRule { writeURLIdentityRule(rule, writer: &w) }-                else { w.writeNull() }-            }),-        ])-    }--    private static func writeTitlePattern(_ pattern: TitlePatternRecord, writer: inout CanonicalJSONWriter) {-        writer.writeObject([-            ("createdAt", { w in w.writeDate(pattern.createdAt) }),-            ("id", { w in w.writeUUID(pattern.id) }),-            ("isActive", { w in w.writeBool(pattern.isActive) }),-            ("junkAnchors", { w in w.writeArray(pattern.junkAnchors.map { a in { (w2: inout CanonicalJSONWriter) in writePosition(a, writer: &w2) } }) }),-            ("siteHostname", { w in w.writeString(pattern.siteHostname) }),-            ("version", { w in w.writeInt(pattern.version) }),-            ("workAnchor", { w in writeRange(pattern.workAnchor, writer: &w) }),-        ])-    }--    private static func writeProvenance(_ prov: FieldProvenance, writer: inout CanonicalJSONWriter) {-        writer.writeObject([-            ("kind", { w in w.writeString(prov.kind.rawValue) }),-            ("patternID", { w in w.writeOptionalUUID(prov.patternID) }),-            ("patternVersion", { w in w.writeOptionalInt(prov.patternVersion) }),-        ])-    }--    private static func writeRange(_ range: SegmentRangeSpec, writer: inout CanonicalJSONWriter) {-        writer.writeObject([-            ("length", { w in w.writeInt(range.length) }),-            ("offset", { w in w.writeInt(range.offset) }),-            ("origin", { w in w.writeString(range.origin.rawValue) }),-        ])-    }--    private static func writePosition(_ pos: SegmentPositionSpec, writer: inout CanonicalJSONWriter) {-        writer.writeObject([-            ("offset", { w in w.writeInt(pos.offset) }),-            ("origin", { w in w.writeString(pos.origin.rawValue) }),-        ])-    }--    private static func writeURLIdentityRule(_ rule: URLIdentityRule, writer: inout CanonicalJSONWriter) {-        writer.writeObject([-            ("component", { w in w.writeString(rule.component.rawValue) }),-            ("offset", { w in w.writeOptionalInt(rule.offset) }),-            ("origin", { w in if let o = rule.origin { w.writeString(o.rawValue) } else { w.writeNull() } }),-            ("queryName", { w in w.writeOptionalString(rule.queryName) }),-            ("version", { w in w.writeInt(rule.version) }),-        ])-    }--    private static func writeJunkSuffixRule(_ rule: JunkSuffixRule, writer: inout CanonicalJSONWriter) {-        writer.writeObject([-            ("anchors", { w in w.writeArray(rule.anchors.map { a in { (w2: inout CanonicalJSONWriter) in writePosition(a, writer: &w2) } }) }),-            ("version", { w in w.writeInt(rule.version) }),-        ])-    }-}

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupV1Decoder.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupV1Decoder.swiftdeleted file mode 100644index b7b5dc1..0000000--- a/Packages/AsterismCore/Sources/AsterismCore/BackupV1Decoder.swift+++ /dev/null@@ -1,219 +0,0 @@-import CryptoKit-import Foundation--// MARK: - Strict JSON Reader--/// A strict byte-level JSON reader that tracks payload ranges and rejects-/// unknown/duplicate keys per the V1 backup format contract.-internal struct StrictJSONReader {-    private let bytes: [UInt8]-    private(set) var position: Int = 0--    init(_ data: Data) {-        self.bytes = [UInt8](data)-    }--    var isAtEnd: Bool { position >= bytes.count }-    var currentByte: UInt8? { position < bytes.count ? bytes[position] : nil }--    mutating func expectEnd() throws {-        guard isAtEnd else {-            throw BackupCodecError.trailingBytes-        }-    }--    mutating func skipByte() { position += 1 }--    mutating func expect(_ byte: UInt8) throws {-        guard position < bytes.count, bytes[position] == byte else {-            throw BackupCodecError.decodingFailed(reason: "expected '\(Character(UnicodeScalar(byte)))' at position \(position)")-        }-        position += 1-    }--    mutating func readString() throws -> String {-        try expect(UInt8(ascii: "\""))-        var result: [UInt8] = []-        while position < bytes.count {-            let b = bytes[position]-            if b == UInt8(ascii: "\"") {-                position += 1-                guard let s = String(bytes: result, encoding: .utf8) else {-                    throw BackupCodecError.decodingFailed(reason: "invalid UTF-8 in string")-                }-                return s-            }-            if b == UInt8(ascii: "\\") {-                position += 1-                guard position < bytes.count else {-                    throw BackupCodecError.decodingFailed(reason: "unterminated escape")-                }-                let escaped = bytes[position]-                position += 1-                switch escaped {-                case UInt8(ascii: "\""): result.append(UInt8(ascii: "\""))-                case UInt8(ascii: "\\"): result.append(UInt8(ascii: "\\"))-                case UInt8(ascii: "/"): result.append(UInt8(ascii: "/"))-                case UInt8(ascii: "b"): result.append(0x08)-                case UInt8(ascii: "f"): result.append(0x0C)-                case UInt8(ascii: "n"): result.append(0x0A)-                case UInt8(ascii: "r"): result.append(0x0D)-                case UInt8(ascii: "t"): result.append(0x09)-                case UInt8(ascii: "u"):-                    guard position + 4 <= bytes.count else {-                        throw BackupCodecError.decodingFailed(reason: "incomplete unicode escape")-                    }-                    let hex = String(bytes: bytes[position..<position+4], encoding: .ascii)!-                    position += 4-                    guard let codePoint = UInt32(hex, radix: 16),-                          let scalar = Unicode.Scalar(codePoint) else {-                        throw BackupCodecError.decodingFailed(reason: "invalid unicode escape \\u\(hex)")-                    }-                    var buf = [UInt8]()-                    for byte in scalar.utf8 { buf.append(byte) }-                    result.append(contentsOf: buf)-                default:-                    throw BackupCodecError.decodingFailed(reason: "invalid escape sequence \\")-                }-            } else {-                result.append(b)-                position += 1-            }-        }-        throw BackupCodecError.decodingFailed(reason: "unterminated string")-    }--    mutating func readInt() throws -> Int {-        var numStr = ""-        if position < bytes.count && bytes[position] == UInt8(ascii: "-") {-            numStr.append("-")-            position += 1-        }-        guard position < bytes.count, bytes[position] >= UInt8(ascii: "0"), bytes[position] <= UInt8(ascii: "9") else {-            throw BackupCodecError.decodingFailed(reason: "expected digit at position \(position)")-        }-        while position < bytes.count, bytes[position] >= UInt8(ascii: "0"), bytes[position] <= UInt8(ascii: "9") {-            numStr.append(Character(UnicodeScalar(bytes[position])))-            position += 1-        }-        guard let value = Int(numStr) else {-            throw BackupCodecError.decodingFailed(reason: "invalid integer: \(numStr)")-        }-        return value-    }--    mutating func readBool() throws -> Bool {-        if bytes[position...].starts(with: "true".utf8) {-            position += 4; return true-        }-        if bytes[position...].starts(with: "false".utf8) {-            position += 5; return false-        }-        throw BackupCodecError.decodingFailed(reason: "expected boolean at position \(position)")-    }--    mutating func readNull() throws {-        guard bytes[position...].starts(with: "null".utf8) else {-            throw BackupCodecError.decodingFailed(reason: "expected null at position \(position)")-        }-        position += 4-    }--    mutating func peekIsNull() -> Bool {-        position < bytes.count - 3 && bytes[position...].starts(with: "null".utf8)-    }--    mutating func readOptionalString() throws -> String? {-        if peekIsNull() { try readNull(); return nil }-        return try readString()-    }--    mutating func readOptionalInt() throws -> Int? {-        if peekIsNull() { try readNull(); return nil }-        return try readInt()-    }--    mutating func readUUID() throws -> UUID {-        let str = try readString()-        guard let uuid = UUID(uuidString: str) else {-            throw BackupCodecError.decodingFailed(reason: "invalid UUID: \(str)")-        }-        return uuid-    }--    mutating func readOptionalUUID() throws -> UUID? {-        if peekIsNull() { try readNull(); return nil }-        return try readUUID()-    }--    mutating func readDate() throws -> Date {-        let str = try readString()-        let formatter = ISO8601DateFormatter()-        formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]-        guard let date = formatter.date(from: str) else {-            throw BackupCodecError.invalidValue(key: "date", reason: "invalid RFC 3339 date: \(str)")-        }-        return date-    }--    /// Reads an object and returns keys in order encountered. Calls handler for each key.-    mutating func readObject(_ handler: (inout StrictJSONReader, String) throws -> Void) throws {-        try expect(UInt8(ascii: "{"))-        var keys: Set<String> = []-        var first = true-        while true {-            guard let next = currentByte else {-                throw BackupCodecError.decodingFailed(reason: "unterminated object")-            }-            if next == UInt8(ascii: "}") { position += 1; return }-            if !first { try expect(UInt8(ascii: ",")) }-            first = false-            let key = try readString()-            guard keys.insert(key).inserted else {-                throw BackupCodecError.duplicateKey(key)-            }-            try expect(UInt8(ascii: ":"))-            try handler(&self, key)-        }-    }--    /// Reads an array, calling handler for each element.-    mutating func readArray(_ handler: (inout StrictJSONReader) throws -> Void) throws {-        try expect(UInt8(ascii: "["))-        var first = true-        while true {-            guard let next = currentByte else {-                throw BackupCodecError.decodingFailed(reason: "unterminated array")-            }-            if next == UInt8(ascii: "]") { position += 1; return }-            if !first { try expect(UInt8(ascii: ",")) }-            first = false-            try handler(&self)-        }-    }--    /// Skips a JSON value (string, number, bool, null, object, array).-    mutating func skipValue() throws {-        guard let b = currentByte else {-            throw BackupCodecError.decodingFailed(reason: "unexpected end")-        }-        switch b {-        case UInt8(ascii: "\""): _ = try readString()-        case UInt8(ascii: "t"), UInt8(ascii: "f"): _ = try readBool()-        case UInt8(ascii: "n"): try readNull()-        case UInt8(ascii: "{"):-            try readObject { reader, _ in try reader.skipValue() }-        case UInt8(ascii: "["):-            try readArray { reader in try reader.skipValue() }-        default: _ = try readInt()-        }-    }--    /// Records the byte range of the next JSON value without consuming it in a way-    /// that changes the read result. Returns (startPosition, endPosition).-    mutating func recordValueRange() throws -> Range<Int> {-        let start = position-        try skipValue()-        return start..<position-    }-}

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupV1DecoderEnvelope.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupV1DecoderEnvelope.swiftdeleted file mode 100644index d080da0..0000000--- a/Packages/AsterismCore/Sources/AsterismCore/BackupV1DecoderEnvelope.swift+++ /dev/null@@ -1,146 +0,0 @@-import CryptoKit-import Foundation--// MARK: - Decode Implementation--extension BackupV1Codec {-    internal static func decodeImpl(_ data: Data) throws -> DecodedBackup {-        var reader = StrictJSONReader(data)-        var header: BackupHeader?-        var snapshot: LibraryBackupSnapshot?-        var payloadRange: Range<Int>?--        let validEnvelopeKeys: Set<String> = ["header", "payload"]-        var seenKeys: Set<String> = []--        try reader.readObject { reader, key in-            guard validEnvelopeKeys.contains(key) else {-                throw BackupCodecError.unknownKey(key)-            }-            guard seenKeys.insert(key).inserted else {-                throw BackupCodecError.duplicateKey(key)-            }-            switch key {-            case "header":-                header = try readHeader(&reader)-            case "payload":-                let start = reader.position-                snapshot = try readPayload(&reader)-                payloadRange = start..<reader.position-            default:-                break-            }-        }--        try reader.expectEnd()--        guard let h = header else { throw BackupCodecError.missingKey("header") }-        guard let s = snapshot else { throw BackupCodecError.missingKey("payload") }-        guard let pr = payloadRange else { throw BackupCodecError.missingKey("payload") }--        guard h.backupFormatVersion == 1 else {-            throw BackupCodecError.invalidFormatVersion(h.backupFormatVersion)-        }-        guard h.databaseSchemaVersion == 1 else {-            throw BackupCodecError.invalidSchemaVersion(h.databaseSchemaVersion)-        }--        return DecodedBackup(snapshot: s, header: h, payloadRange: pr)-    }--    private static func readHeader(_ reader: inout StrictJSONReader) throws -> BackupHeader {-        let validKeys: Set<String> = [-            "appBuild", "backupFormatVersion", "checksum",-            "databaseSchemaVersion", "entryCount", "exportedAt", "workCount",-        ]-        var appBuild: String?-        var formatVersion: Int?-        var checksum: String?-        var schemaVersion: Int?-        var entryCount: Int?-        var exportedAt: Date?-        var workCount: Int?--        try reader.readObject { reader, key in-            guard validKeys.contains(key) else {-                throw BackupCodecError.unknownKey(key)-            }-            switch key {-            case "appBuild": appBuild = try reader.readString()-            case "backupFormatVersion": formatVersion = try reader.readInt()-            case "checksum": checksum = try reader.readString()-            case "databaseSchemaVersion": schemaVersion = try reader.readInt()-            case "entryCount": entryCount = try reader.readInt()-            case "exportedAt": exportedAt = try reader.readDate()-            case "workCount": workCount = try reader.readInt()-            default: break-            }-        }--        guard let ab = appBuild else { throw BackupCodecError.missingKey("appBuild") }-        guard let fv = formatVersion else { throw BackupCodecError.missingKey("backupFormatVersion") }-        guard let cs = checksum else { throw BackupCodecError.missingKey("checksum") }-        guard let sv = schemaVersion else { throw BackupCodecError.missingKey("databaseSchemaVersion") }-        guard let ec = entryCount else { throw BackupCodecError.missingKey("entryCount") }-        guard let ea = exportedAt else { throw BackupCodecError.missingKey("exportedAt") }-        guard let wc = workCount else { throw BackupCodecError.missingKey("workCount") }--        return BackupHeader(-            backupFormatVersion: fv,-            databaseSchemaVersion: sv,-            appBuild: ab,-            exportedAt: ea,-            entryCount: ec,-            workCount: wc,-            checksum: cs-        )-    }--    private static func readPayload(_ reader: inout StrictJSONReader) throws -> LibraryBackupSnapshot {-        let validKeys: Set<String> = ["entries", "sites", "titlePatterns", "works"]-        var entries: [EntryRecord]?-        var works: [WorkRecord]?-        var sites: [SiteRecord]?-        var titlePatterns: [TitlePatternRecord]?--        try reader.readObject { reader, key in-            guard validKeys.contains(key) else {-                throw BackupCodecError.unknownKey(key)-            }-            switch key {-            case "entries":-                var items: [EntryRecord] = []-                try reader.readArray { reader in-                    items.append(try readEntry(&reader))-                }-                entries = items-            case "works":-                var items: [WorkRecord] = []-                try reader.readArray { reader in-                    items.append(try readWork(&reader))-                }-                works = items-            case "sites":-                var items: [SiteRecord] = []-                try reader.readArray { reader in-                    items.append(try readSite(&reader))-                }-                sites = items-            case "titlePatterns":-                var items: [TitlePatternRecord] = []-                try reader.readArray { reader in-                    items.append(try readTitlePattern(&reader))-                }-                titlePatterns = items-            default: break-            }-        }--        guard let e = entries else { throw BackupCodecError.missingKey("entries") }-        guard let w = works else { throw BackupCodecError.missingKey("works") }-        guard let s = sites else { throw BackupCodecError.missingKey("sites") }-        guard let tp = titlePatterns else { throw BackupCodecError.missingKey("titlePatterns") }--        return LibraryBackupSnapshot(entries: e, works: w, sites: s, titlePatterns: tp)-    }-}

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupV1DecoderRecords.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupV1DecoderRecords.swiftdeleted file mode 100644index 7e249db..0000000--- a/Packages/AsterismCore/Sources/AsterismCore/BackupV1DecoderRecords.swift+++ /dev/null@@ -1,336 +0,0 @@-import Foundation--// MARK: - Record-Level Decoding--extension BackupV1Codec {-    static func readEntry(_ reader: inout StrictJSONReader) throws -> EntryRecord {-        let validKeys: Set<String> = [-            "canonicalURL", "captureTitle", "captureTitleSource", "chapterTitle",-            "chapterTitleProvenance", "entryIdentityKey", "firstCapturedAt",-            "hostname", "id", "identityKeyVersion", "intentionallyUnattached",-            "lastSharedAt", "modifiedAt", "note", "rating", "rawURL",-            "workAssignmentProvenance", "workID",-        ]-        var id: UUID?; var captureTitle: String?; var captureTitleSource: String?-        var rawURL: String?; var canonicalURL: String??; var hostname: String?-        var entryIdentityKey: String?; var identityKeyVersion: Int?-        var chapterTitle: String??; var chapterTitleProvenance: FieldProvenance?-        var note: String?; var rating: String??-        var firstCapturedAt: Date?; var lastSharedAt: Date?; var modifiedAt: Date?-        var workID: UUID??; var workAssignmentProvenance: FieldProvenance?-        var intentionallyUnattached: Bool?-        var seenKeys: Set<String> = []--        try reader.readObject { reader, key in-            guard validKeys.contains(key) else { throw BackupCodecError.unknownKey(key) }-            guard seenKeys.insert(key).inserted else { throw BackupCodecError.duplicateKey(key) }-            switch key {-            case "id": id = try reader.readUUID()-            case "captureTitle": captureTitle = try reader.readString()-            case "captureTitleSource": captureTitleSource = try reader.readString()-            case "rawURL": rawURL = try reader.readString()-            case "canonicalURL": canonicalURL = .some(try reader.readOptionalString())-            case "hostname": hostname = try reader.readString()-            case "entryIdentityKey": entryIdentityKey = try reader.readString()-            case "identityKeyVersion": identityKeyVersion = try reader.readInt()-            case "chapterTitle": chapterTitle = .some(try reader.readOptionalString())-            case "chapterTitleProvenance": chapterTitleProvenance = try readProvenance(&reader)-            case "note": note = try reader.readString()-            case "rating": rating = .some(try reader.readOptionalString())-            case "firstCapturedAt": firstCapturedAt = try reader.readDate()-            case "lastSharedAt": lastSharedAt = try reader.readDate()-            case "modifiedAt": modifiedAt = try reader.readDate()-            case "workID": workID = .some(try reader.readOptionalUUID())-            case "workAssignmentProvenance": workAssignmentProvenance = try readProvenance(&reader)-            case "intentionallyUnattached": intentionallyUnattached = try reader.readBool()-            default: break-            }-        }--        guard seenKeys.count == validKeys.count else {-            let missing = validKeys.subtracting(seenKeys)-            throw BackupCodecError.missingKey(missing.sorted().first!)-        }--        guard let titleSourceStr = captureTitleSource,-              let titleSource = CaptureTitleSource(rawValue: titleSourceStr) else {-            throw BackupCodecError.invalidValue(key: "captureTitleSource", reason: "invalid enum value")-        }--        let parsedRating: Rating?-        if case .some(let ratingStr) = rating {-            if let str = ratingStr {-                guard let r = Rating(rawValue: str) else {-                    throw BackupCodecError.invalidValue(key: "rating", reason: "invalid enum value: \(str)")-                }-                parsedRating = r-            } else { parsedRating = nil }-        } else { parsedRating = nil }--        return EntryRecord(-            id: id!, captureTitle: captureTitle!, captureTitleSource: titleSource,-            rawURL: rawURL!, canonicalURL: canonicalURL!,-            hostname: hostname!, entryIdentityKey: entryIdentityKey!,-            identityKeyVersion: identityKeyVersion!,-            chapterTitle: chapterTitle!,-            chapterTitleProvenance: chapterTitleProvenance!,-            note: note!, rating: parsedRating,-            firstCapturedAt: firstCapturedAt!, lastSharedAt: lastSharedAt!,-            modifiedAt: modifiedAt!, workID: workID!,-            workAssignmentProvenance: workAssignmentProvenance!,-            intentionallyUnattached: intentionallyUnattached!-        )-    }--    static func readWork(_ reader: inout StrictJSONReader) throws -> WorkRecord {-        let validKeys: Set<String> = [-            "createdAt", "displayTitle", "entryIDs", "genericNotes", "genreTags",-            "id", "lastParsedTitle", "modifiedAt", "siteHostname",-            "titleProvenance", "type", "urlIdentity", "workURL",-        ]-        var id: UUID?; var displayTitle: String?; var lastParsedTitle: String??-        var siteHostname: String?; var urlIdentity: String??; var workURL: String??-        var genericNotes: String?; var typeRaw: String?; var genreTags: [String]?-        var titleProvenance: String?; var createdAt: Date?; var modifiedAt: Date?-        var entryIDs: [UUID]?-        var seenKeys: Set<String> = []--        try reader.readObject { reader, key in-            guard validKeys.contains(key) else { throw BackupCodecError.unknownKey(key) }-            guard seenKeys.insert(key).inserted else { throw BackupCodecError.duplicateKey(key) }-            switch key {-            case "id": id = try reader.readUUID()-            case "displayTitle": displayTitle = try reader.readString()-            case "lastParsedTitle": lastParsedTitle = .some(try reader.readOptionalString())-            case "siteHostname": siteHostname = try reader.readString()-            case "urlIdentity": urlIdentity = .some(try reader.readOptionalString())-            case "workURL": workURL = .some(try reader.readOptionalString())-            case "genericNotes": genericNotes = try reader.readString()-            case "type": typeRaw = try reader.readString()-            case "genreTags":-                var tags: [String] = []-                try reader.readArray { r in tags.append(try r.readString()) }-                genreTags = tags-            case "titleProvenance": titleProvenance = try reader.readString()-            case "createdAt": createdAt = try reader.readDate()-            case "modifiedAt": modifiedAt = try reader.readDate()-            case "entryIDs":-                var ids: [UUID] = []-                try reader.readArray { r in ids.append(try r.readUUID()) }-                entryIDs = ids-            default: break-            }-        }--        guard seenKeys.count == validKeys.count else {-            let missing = validKeys.subtracting(seenKeys)-            throw BackupCodecError.missingKey(missing.sorted().first!)-        }-        guard let t = typeRaw, let workType = WorkType(rawValue: t) else {-            throw BackupCodecError.invalidValue(key: "type", reason: "invalid work type")-        }-        guard let tp = titleProvenance, let prov = TitleProvenance(rawValue: tp) else {-            throw BackupCodecError.invalidValue(key: "titleProvenance", reason: "invalid title provenance")-        }--        return WorkRecord(-            id: id!, displayTitle: displayTitle!, lastParsedTitle: lastParsedTitle!,-            siteHostname: siteHostname!, urlIdentity: urlIdentity!, workURL: workURL!,-            genericNotes: genericNotes!, type: workType, genreTags: genreTags!,-            titleProvenance: prov, createdAt: createdAt!, modifiedAt: modifiedAt!,-            entryIDs: entryIDs!-        )-    }--    static func readSite(_ reader: inout StrictJSONReader) throws -> SiteRecord {-        let validKeys: Set<String> = [-            "displayName", "hostname", "junkSuffixRule", "mode", "patternIDs", "urlIdentityRule",-        ]-        var hostname: String?; var displayName: String?; var modeRaw: String?-        var patternIDs: [UUID]?; var urlIdentityRule: URLIdentityRule??-        var junkSuffixRule: JunkSuffixRule??-        var seenKeys: Set<String> = []--        try reader.readObject { reader, key in-            guard validKeys.contains(key) else { throw BackupCodecError.unknownKey(key) }-            guard seenKeys.insert(key).inserted else { throw BackupCodecError.duplicateKey(key) }-            switch key {-            case "hostname": hostname = try reader.readString()-            case "displayName": displayName = try reader.readString()-            case "mode": modeRaw = try reader.readString()-            case "patternIDs":-                var ids: [UUID] = []-                try reader.readArray { r in ids.append(try r.readUUID()) }-                patternIDs = ids-            case "urlIdentityRule":-                if reader.peekIsNull() { try reader.readNull(); urlIdentityRule = .some(nil) }-                else { urlIdentityRule = .some(try readURLIdentityRule(&reader)) }-            case "junkSuffixRule":-                if reader.peekIsNull() { try reader.readNull(); junkSuffixRule = .some(nil) }-                else { junkSuffixRule = .some(try readJunkSuffixRule(&reader)) }-            default: break-            }-        }--        guard seenKeys.count == validKeys.count else {-            let missing = validKeys.subtracting(seenKeys)-            throw BackupCodecError.missingKey(missing.sorted().first!)-        }-        guard let m = modeRaw, let mode = SiteMode(rawValue: m) else {-            throw BackupCodecError.invalidValue(key: "mode", reason: "invalid site mode")-        }--        return SiteRecord(-            hostname: hostname!, displayName: displayName!, mode: mode,-            patternIDs: patternIDs!, urlIdentityRule: urlIdentityRule!,-            junkSuffixRule: junkSuffixRule!-        )-    }--    static func readTitlePattern(_ reader: inout StrictJSONReader) throws -> TitlePatternRecord {-        let validKeys: Set<String> = [-            "createdAt", "id", "isActive", "junkAnchors", "siteHostname", "version", "workAnchor",-        ]-        var id: UUID?; var version: Int?; var isActive: Bool?-        var createdAt: Date?; var workAnchor: SegmentRangeSpec?-        var junkAnchors: [SegmentPositionSpec]?; var siteHostname: String?-        var seenKeys: Set<String> = []--        try reader.readObject { reader, key in-            guard validKeys.contains(key) else { throw BackupCodecError.unknownKey(key) }-            guard seenKeys.insert(key).inserted else { throw BackupCodecError.duplicateKey(key) }-            switch key {-            case "id": id = try reader.readUUID()-            case "version": version = try reader.readInt()-            case "isActive": isActive = try reader.readBool()-            case "createdAt": createdAt = try reader.readDate()-            case "workAnchor": workAnchor = try readRange(&reader)-            case "junkAnchors":-                var anchors: [SegmentPositionSpec] = []-                try reader.readArray { r in anchors.append(try readPosition(&r)) }-                junkAnchors = anchors-            case "siteHostname": siteHostname = try reader.readString()-            default: break-            }-        }--        guard seenKeys.count == validKeys.count else {-            let missing = validKeys.subtracting(seenKeys)-            throw BackupCodecError.missingKey(missing.sorted().first!)-        }--        return TitlePatternRecord(-            id: id!, version: version!, isActive: isActive!,-            createdAt: createdAt!, workAnchor: workAnchor!,-            junkAnchors: junkAnchors!, siteHostname: siteHostname!-        )-    }--    // MARK: - Value Object Decoding--    static func readProvenance(_ reader: inout StrictJSONReader) throws -> FieldProvenance {-        var kind: String?; var patternID: UUID??; var patternVersion: Int??-        try reader.readObject { reader, key in-            switch key {-            case "kind": kind = try reader.readString()-            case "patternID": patternID = .some(try reader.readOptionalUUID())-            case "patternVersion": patternVersion = .some(try reader.readOptionalInt())-            default: throw BackupCodecError.unknownKey(key)-            }-        }-        guard let k = kind, let provKind = FieldProvenanceKind(rawValue: k) else {-            throw BackupCodecError.invalidValue(key: "kind", reason: "invalid provenance kind")-        }-        guard patternID != nil, patternVersion != nil else {-            throw BackupCodecError.missingKey("patternID or patternVersion")-        }-        return try FieldProvenance(kind: provKind, patternID: patternID!, patternVersion: patternVersion!)-    }--    static func readRange(_ reader: inout StrictJSONReader) throws -> SegmentRangeSpec {-        var origin: String?; var offset: Int?; var length: Int?-        try reader.readObject { reader, key in-            switch key {-            case "origin": origin = try reader.readString()-            case "offset": offset = try reader.readInt()-            case "length": length = try reader.readInt()-            default: throw BackupCodecError.unknownKey(key)-            }-        }-        guard let o = origin, let ao = AnchorOrigin(rawValue: o) else {-            throw BackupCodecError.invalidValue(key: "origin", reason: "invalid anchor origin")-        }-        guard let off = offset, let len = length else {-            throw BackupCodecError.missingKey("offset or length")-        }-        return try SegmentRangeSpec(origin: ao, offset: off, length: len)-    }--    static func readPosition(_ reader: inout StrictJSONReader) throws -> SegmentPositionSpec {-        var origin: String?; var offset: Int?-        try reader.readObject { reader, key in-            switch key {-            case "origin": origin = try reader.readString()-            case "offset": offset = try reader.readInt()-            default: throw BackupCodecError.unknownKey(key)-            }-        }-        guard let o = origin, let ao = AnchorOrigin(rawValue: o) else {-            throw BackupCodecError.invalidValue(key: "origin", reason: "invalid anchor origin")-        }-        guard let off = offset else {-            throw BackupCodecError.missingKey("offset")-        }-        return try SegmentPositionSpec(origin: ao, offset: off)-    }--    static func readURLIdentityRule(_ reader: inout StrictJSONReader) throws -> URLIdentityRule {-        var component: String?; var offset: Int??; var origin: String??-        var queryName: String??; var version: Int?-        try reader.readObject { reader, key in-            switch key {-            case "component": component = try reader.readString()-            case "offset": offset = .some(try reader.readOptionalInt())-            case "origin": origin = .some(try reader.readOptionalString())-            case "queryName": queryName = .some(try reader.readOptionalString())-            case "version": version = try reader.readInt()-            default: throw BackupCodecError.unknownKey(key)-            }-        }-        guard let c = component, let comp = URLRuleComponent(rawValue: c) else {-            throw BackupCodecError.invalidValue(key: "component", reason: "invalid URL rule component")-        }-        guard let v = version else { throw BackupCodecError.missingKey("version") }-        switch comp {-        case .pathSegment:-            guard let originStr = origin!, let ao = AnchorOrigin(rawValue: originStr),-                  let off = offset! else {-                throw BackupCodecError.invalidValue(key: "urlIdentityRule", reason: "pathSegment requires origin and offset")-            }-            return try URLIdentityRule(version: v, component: comp, origin: ao, offset: off)-        case .queryItem:-            guard let qn = queryName! else {-                throw BackupCodecError.invalidValue(key: "urlIdentityRule", reason: "queryItem requires queryName")-            }-            return try URLIdentityRule(version: v, component: comp, queryName: qn)-        }-    }--    static func readJunkSuffixRule(_ reader: inout StrictJSONReader) throws -> JunkSuffixRule {-        var version: Int?; var anchors: [SegmentPositionSpec]?-        try reader.readObject { reader, key in-            switch key {-            case "version": version = try reader.readInt()-            case "anchors":-                var items: [SegmentPositionSpec] = []-                try reader.readArray { r in items.append(try readPosition(&r)) }-                anchors = items-            default: throw BackupCodecError.unknownKey(key)-            }-        }-        guard let v = version, let a = anchors else {-            throw BackupCodecError.missingKey("version or anchors")-        }-        return try JunkSuffixRule(version: v, anchors: a)-    }-}

diff --git a/Packages/AsterismCore/Sources/AsterismCore/BackupV1ValidatorImpl.swift b/Packages/AsterismCore/Sources/AsterismCore/BackupV1ValidatorImpl.swiftdeleted file mode 100644index d8eddcb..0000000--- a/Packages/AsterismCore/Sources/AsterismCore/BackupV1ValidatorImpl.swift+++ /dev/null@@ -1,205 +0,0 @@-import CryptoKit-import Foundation--// MARK: - Validator Implementation--extension BackupV1Validator {-    internal static func validateImpl(-        decoded: DecodedBackup,-        source: LibraryBackupSnapshot,-        encodedData: Data-    ) throws {-        // 1. Checksum verification over exact payload bytes-        let payloadSlice = encodedData[decoded.payloadRange]-        let digest = SHA256.hash(data: payloadSlice)-        let computedChecksum = digest.map { String(format: "%02x", $0) }.joined()-        guard computedChecksum == decoded.header.checksum else {-            throw BackupValidationError.checksumMismatch(-                expected: decoded.header.checksum,-                actual: computedChecksum-            )-        }--        // 2. Header count validation-        guard decoded.header.entryCount == decoded.snapshot.entries.count else {-            throw BackupValidationError.countMismatch(-                type: "Entry",-                expected: decoded.header.entryCount,-                actual: decoded.snapshot.entries.count-            )-        }-        guard decoded.header.workCount == decoded.snapshot.works.count else {-            throw BackupValidationError.countMismatch(-                type: "Work",-                expected: decoded.header.workCount,-                actual: decoded.snapshot.works.count-            )-        }--        // 3. Deep equality with source snapshot-        guard decoded.snapshot == source else {-            throw BackupValidationError.snapshotMismatch(-                reason: "decoded payload does not match source snapshot"-            )-        }--        // 4. UUID uniqueness within each record type-        try validateUniqueEntryIDs(decoded.snapshot.entries)-        try validateUniqueWorkIDs(decoded.snapshot.works)-        try validateUniqueTitlePatternIDs(decoded.snapshot.titlePatterns)-        try validateUniqueSiteHostnames(decoded.snapshot.sites)--        // 5. All relationships resolve-        try validateEntryReferences(decoded.snapshot)-        try validateWorkReferences(decoded.snapshot)-        try validateSiteReferences(decoded.snapshot)-        try validateProvenanceReferences(decoded.snapshot)--        // 6. At most one active pattern per Site-        try validateActivePatternCounts(decoded.snapshot)-    }--    // MARK: - Uniqueness Checks--    private static func validateUniqueEntryIDs(_ entries: [EntryRecord]) throws {-        var seen: Set<UUID> = []-        for entry in entries {-            guard seen.insert(entry.id).inserted else {-                throw BackupValidationError.duplicateID(type: "Entry", id: entry.id)-            }-        }-    }--    private static func validateUniqueWorkIDs(_ works: [WorkRecord]) throws {-        var seen: Set<UUID> = []-        for work in works {-            guard seen.insert(work.id).inserted else {-                throw BackupValidationError.duplicateID(type: "Work", id: work.id)-            }-        }-    }--    private static func validateUniqueTitlePatternIDs(_ patterns: [TitlePatternRecord]) throws {-        var seen: Set<UUID> = []-        for pattern in patterns {-            guard seen.insert(pattern.id).inserted else {-                throw BackupValidationError.duplicateID(type: "TitlePattern", id: pattern.id)-            }-        }-    }--    private static func validateUniqueSiteHostnames(_ sites: [SiteRecord]) throws {-        var seen: Set<String> = []-        for site in sites {-            guard seen.insert(site.hostname).inserted else {-                throw BackupValidationError.duplicateHostname(site.hostname)-            }-        }-    }--    // MARK: - Reference Checks--    private static func validateEntryReferences(_ snapshot: LibraryBackupSnapshot) throws {-        let workIDs = Set(snapshot.works.map(\.id))-        let siteHostnames = Set(snapshot.sites.map(\.hostname))-        for entry in snapshot.entries {-            if let workID = entry.workID {-                guard workIDs.contains(workID) else {-                    throw BackupValidationError.unresolvedReference(-                        type: "Entry", id: entry.id,-                        referencedType: "Work", referencedID: workID-                    )-                }-            }-            guard siteHostnames.contains(entry.hostname) else {-                throw BackupValidationError.unresolvedHostname(-                    type: "Entry", id: entry.id.uuidString, hostname: entry.hostname-                )-            }-        }-    }--    private static func validateWorkReferences(_ snapshot: LibraryBackupSnapshot) throws {-        let entryIDs = Set(snapshot.entries.map(\.id))-        let siteHostnames = Set(snapshot.sites.map(\.hostname))-        for work in snapshot.works {-            guard siteHostnames.contains(work.siteHostname) else {-                throw BackupValidationError.unresolvedHostname(-                    type: "Work", id: work.id.uuidString, hostname: work.siteHostname-                )-            }-            for entryID in work.entryIDs {-                guard entryIDs.contains(entryID) else {-                    throw BackupValidationError.unresolvedReference(-                        type: "Work", id: work.id,-                        referencedType: "Entry", referencedID: entryID-                    )-                }-            }-        }-    }--    private static func validateSiteReferences(_ snapshot: LibraryBackupSnapshot) throws {-        let patternIDs = Set(snapshot.titlePatterns.map(\.id))-        for site in snapshot.sites {-            for patternID in site.patternIDs {-                guard patternIDs.contains(patternID) else {-                    throw BackupValidationError.unresolvedReference(-                        type: "Site", id: UUID(), // Sites don't have UUID IDs, using placeholder-                        referencedType: "TitlePattern", referencedID: patternID-                    )-                }-            }-        }-        // Validate titlePattern siteHostname references-        let siteHostnames = Set(snapshot.sites.map(\.hostname))-        for pattern in snapshot.titlePatterns {-            guard siteHostnames.contains(pattern.siteHostname) else {-                throw BackupValidationError.unresolvedHostname(-                    type: "TitlePattern", id: pattern.id.uuidString, hostname: pattern.siteHostname-                )-            }-        }-    }--    private static func validateProvenanceReferences(_ snapshot: LibraryBackupSnapshot) throws {-        let patternsByID: [UUID: [TitlePatternRecord]] = Dictionary(grouping: snapshot.titlePatterns, by: \.id)-        for entry in snapshot.entries {-            try validateProvenance(entry.chapterTitleProvenance, type: "Entry", id: entry.id, patterns: patternsByID)-            try validateProvenance(entry.workAssignmentProvenance, type: "Entry", id: entry.id, patterns: patternsByID)-        }-    }--    private static func validateProvenance(-        _ provenance: FieldProvenance,-        type: String,-        id: UUID,-        patterns: [UUID: [TitlePatternRecord]]-    ) throws {-        guard provenance.kind == .pattern else { return }-        guard let patternID = provenance.patternID,-              let patternVersion = provenance.patternVersion else {-            throw BackupValidationError.unresolvedProvenance(-                type: type, id: id, patternID: UUID(), patternVersion: 0-            )-        }-        guard let matchingPatterns = patterns[patternID],-              matchingPatterns.contains(where: { $0.version == patternVersion }) else {-            throw BackupValidationError.unresolvedProvenance(-                type: type, id: id, patternID: patternID, patternVersion: patternVersion-            )-        }-    }--    // MARK: - Active Pattern Count--    private static func validateActivePatternCounts(_ snapshot: LibraryBackupSnapshot) throws {-        var activeCounts: [String: Int] = [:]-        for pattern in snapshot.titlePatterns where pattern.isActive {-            activeCounts[pattern.siteHostname, default: 0] += 1-        }-        for (hostname, count) in activeCounts where count > 1 {-            throw BackupValidationError.invalidActivePatternCount(hostname: hostname, count: count)-        }-    }-}