T-2115 safety implementation and native Settings integration. PR #116 was squash-merged after fresh pr-pilot review and fixer gates.
Squash-merged with one owner exception
1 failing phone UI case remains recorded under the exact owner-accepted exception. Four fresh independent reviews and fixer passes completed; two minor documentation findings were fixed. The final head was reviewed clean before and after a no-op rebase. CI was empty (no CI configured). Merge 97e150da36d2b837717e39168007323b0246e83e exactly matches reviewed tree 689abea84102e426b112bb6bc193412ecc43748e. Zero builds or tests were repeated in pr-pilot because runtime/test/build inputs were unchanged.
7f227a491ac708ed6c05d31104fbeab0b0053ef8 T-2115: Isolate benchmark preferences across app roots 04435d9c3288d0e0a16b5f3f53391ecb2d822649 T-2115: Correct the implementation publication status 689abea84102e426b112bb6bc193412ecc43748e T-2115: Normalize decision log identifiers and dates The benchmark gets a temporary preference area of its own, so its initial settings and release-note state can be predictable without resetting the normal preference area. The app passes the selected store to its windows.
A malformed benchmark request stops at an unavailable startup state. Normal Release launches retain standard storage. Draft publication proceeds with one explicit owner-accepted phone test exception; its failed outcome is retained.
launchPreferences() selects a fixed-prefix, UUID-scoped UserDefaults suite in test-enabled builds. request() separately validates the opt-in, scenario and run identifier. AsterismApp.init() hands the same instance to reset and announcement helpers, main roots, and the retained native Settings owner.
No domain name is accepted from the environment, and suite creation cannot fall back to normal defaults. Separately hosted Settings page roots receive their own explicit defaultAppStorage modifier.
Presence of malformed isolation input still selects a throwaway suite; request validation then rejects production bootstrap. The ordinary optimized build excludes test-launch behavior at compile time. Storage selection occurs once per launch.
The mounted AppStorage test is a generic modifier-routing probe, not a rendered proof of every production root. Its iOS path passed; its separate AppKit path was not executed with an isolated host setup. Source tracing covers root propagation, and Mac compilation validates the types. The six actual production Mac Settings journeys subsequently passed; they are distinct from the generic probe.
Asterism/Asterism/UITestLaunchSupport.swift
Why it matters. Keeps benchmark resets separate from normal preferences and rejects invalid launches.
What to look at. launchPreferences() and request()
Asterism/Asterism/AsterismApp.swift
Why it matters. Reset logic, announcement state and AppStorage views agree on their storage.
What to look at. init() and main scene roots
Asterism/Asterism/Support/MacSettingsWindow.swift
Why it matters. Native Settings pages are separately hosted trees.
What to look at. MacSettingsWindow.init and MacSettingsPageRoot
Asterism/AsterismUITests/M4ScaleTodayPerformanceUITests.swift
Why it matters. Uses the isolated suite while preserving scenarios, iterations, queries and assertions.
What to look at. Launch environment opt-in
A new run-scoped suite avoids copying normal preference state or restoring it after a benchmark.
On 2026-10-25 the owner accepted only AccessibilityJourneyUITests/testTheCreatorControlsStayReachableAtLargestDynamicType() and directed no further investigation or rerun. The complete phone result stays Failed; no other failure or gate is waived. Decision 1 records this narrow authorization.
| Severity | Area | Finding | Resolution |
|---|---|---|---|
| major | Verification documentation | Private provenance and stale physical-acceptance wording appeared in the review candidate. | Sanitized candidate documentation and the entire single unpublished commit. The original commit and evidence are preserved locally; the old commit is not reachable from the publication branch. |
| minor | Implementation documentation | Stale statement said no PR had been created. | Linked delivery to PR #116 without claiming an all-green phone gate. |
| minor | Decision-log format | Quick decisions lacked dated Q identifiers and the full ADR shared their sequence. | Added Q1–Q4 and evidenced dates; renumbered the full ADR to Decision 1 and updated the PR reference. |
Source: local run at 2026-10-25T04:04:37.820852+00:00 · snapshot 689abea84102e426b112bb6bc193412ecc43748e
Baseline: none
Execution: failed · JUnit: 4 files · Coverage: none · Baseline: absent
Coverage scope: as the project configures it
Totals: 2245 passed · 1 failed · 2 skipped · 0 errored · 0 flaky
| Suite | Test | Job or artifact | Message |
|---|---|---|---|
| AccessibilityJourneyUITests | testTheCreatorControlsStayReachableAtLargestDynamicType() | — | failed - All works is reachable from the hub |
Derived by declaration name, from the diff (no baseline run).
Files that import a changed file on the left, changed files in the centre, files a changed file imports on the right. Snapshot working-tree against base cd0e76350fd0daea4ff61ba483893a90a5aec646.
14 files: 7 code · 7 docs. Click to expand.
diff --git a/Asterism/Asterism/AsterismApp.swift b/Asterism/Asterism/AsterismApp.swiftindex 6cc282bd..0f6094dd 100644--- a/Asterism/Asterism/AsterismApp.swift+++ b/Asterism/Asterism/AsterismApp.swift@@ -36,7 +36,7 @@ struct AsterismApp: App { /// in `init` for the model's reason: the open intents route through it. @State private var navigation: AppNavigation #if os(macOS)- @State private var settingsWindow = MacSettingsWindow()+ @State private var settingsWindow: MacSettingsWindow #endif /// The announcement seen state (`today-announcements` Q22), for both of the /// reasons above and one more: a `UserDefaults` write triggers no@@ -47,7 +47,8 @@ struct AsterismApp: App { /// launch's pin before constructing the state that reads it (Q14). The /// dependency is inside that function rather than in the order of these two /// declarations, so nothing here breaks if they are ever reordered.- @State private var announcements = ContentView.launchSeenState()+ @State private var announcements: AnnouncementSeenState+ private let preferences: UserDefaults #if os(iOS) /// Watched only to know when the app has left the foreground, which is one@@ -68,8 +69,14 @@ struct AsterismApp: App { #endif init() {- let model = ContentView.launchModel()+ let preferences = UITestLaunchSupport.launchPreferences()+ self.preferences = preferences+ let model = ContentView.launchModel(defaults: preferences)+ _announcements = State(initialValue: ContentView.launchSeenState(defaults: preferences)) let navigation = AppNavigation()+ #if os(macOS)+ _settingsWindow = State(initialValue: MacSettingsWindow(preferences: preferences))+ #endif _model = State(initialValue: model) _navigation = State(initialValue: navigation) // `app-intents`: the intents read the library and the navigation@@ -100,6 +107,7 @@ struct AsterismApp: App { Window("Asterism", id: Self.mainWindowID) { ContentView(model: model, navigation: navigation, announcements: announcements) .environment(settingsWindow)+ .defaultAppStorage(preferences) // Req 2.4: the two-column layout with the list at 320 pt still // fits here. `contentMinSize` below is what makes the window // honour it rather than letting the reader squash the content.@@ -117,6 +125,7 @@ struct AsterismApp: App { #else WindowGroup { ContentView(model: model, navigation: navigation, announcements: announcements)+ .defaultAppStorage(preferences) } // Req 6.1's shortcuts, which iPadOS also lists in the held-⌘ overlay. // Settings is the one command that is the iPad's alone (Q4): the Mac
diff --git a/Asterism/Asterism/ContentView.swift b/Asterism/Asterism/ContentView.swiftindex 93c521da..546a2095 100644--- a/Asterism/Asterism/ContentView.swift+++ b/Asterism/Asterism/ContentView.swift@@ -133,27 +133,30 @@ struct ContentView: View { /// /// Debug UI tests may request an isolated seeded library; malformed requests /// render unavailable rather than touching an App Group.- static func launchModel() -> AppLibraryModel {+ static func launchModel(+ defaults: UserDefaults = .standard,+ environmentProvider: any ProcessEnvironmentProviding = SystemProcessEnvironment()+ ) -> AppLibraryModel { #if DEBUG || ASTERISM_PERFORMANCE_TESTING- switch UITestLaunchSupport.request() {+ switch UITestLaunchSupport.request(environmentProvider: environmentProvider) { case .disabled: return productionModel() case .seeded(let configuration, let fixture): // `works-list-options` Q8: the Works list's sort is the first // preference a UI test can change, and it persists per device — so // a test that picks A to Z would leak into every launch after it.- // Cleared here, where the seeded request is already resolved, rather- // than through a per-run defaults suite that would need the run id- // plumbed into `AsterismApp` and leave a plist per run behind.+ // Reset the selected store only. Ordinary UI launches keep their+ // existing store; the opted-in physical benchmark supplies a+ // UUID-scoped suite shared with AppStorage and announcements. // // The group-by-series toggle joined it (Req 4.3 of // `series-and-related-works`) and the list is named beside the keys // themselves, so a preference added later is reset by declaring it // there rather than by remembering this line (Q51). for key in WorksListStorageKey.seededLaunchResets {- if ProcessInfo.processInfo.environment["ASTERISM_UI_TEST_RESTORE_NAVIGATION"] == "1",+ if environmentProvider.environment["ASTERISM_UI_TEST_RESTORE_NAVIGATION"] == "1", [RestoreStorageKey.selectedSidebarItem, RestoreStorageKey.todayPath, RestoreStorageKey.libraryPath, RestoreStorageKey.selectedTab, RestoreStorageKey.selectedTodayEntryID, RestoreStorageKey.selectedWorkID].contains(key) { continue }- UserDefaults.standard.removeObject(forKey: key)+ defaults.removeObject(forKey: key) } // `launch-to-today` Q17: nil for every scenario but the one that // asks for a failed works load. Written as a closure literal at the@@ -161,7 +164,7 @@ struct ContentView: View { // `UITestLaunchSupport`: that type is implicitly `@Sendable`, and a // function value converted into it warns about data races. var worksReadFault: (@MainActor () throws -> Void)?- if UITestLaunchSupport.worksReadFailsUntilRetry() {+ if UITestLaunchSupport.worksReadFailsUntilRetry(environmentProvider: environmentProvider) { worksReadFault = { throw UITestLaunchSupport.InjectedWorksReadFailure() } } return AppLibraryModel(@@ -191,15 +194,19 @@ struct ContentView: View { /// would put a release-note row on every fixture that holds entries (Q11) /// and shift the rows under the journeys. A journey that wants the row names /// an older version in `ASTERISM_UI_TEST_LAST_SEEN_VERSION`.- static func launchSeenState() -> AnnouncementSeenState {+ static func launchSeenState(+ defaults: UserDefaults = .standard,+ environmentProvider: any ProcessEnvironmentProviding = SystemProcessEnvironment()+ ) -> AnnouncementSeenState { #if DEBUG || ASTERISM_PERFORMANCE_TESTING- if case .seeded = UITestLaunchSupport.request() {+ if case .seeded = UITestLaunchSupport.request(environmentProvider: environmentProvider) { UITestLaunchSupport.pinLastSeenVersion(- in: .standard,- currentVersion: AnnouncementSeenState.marketingVersion())+ in: defaults,+ currentVersion: AnnouncementSeenState.marketingVersion(),+ environmentProvider: environmentProvider) } #endif- return AnnouncementSeenState()+ return AnnouncementSeenState(defaults: defaults) } /// The model the app runs on, built from what this build's bundle declares.
diff --git a/Asterism/Asterism/Support/MacSettingsWindow.swift b/Asterism/Asterism/Support/MacSettingsWindow.swiftindex e436c68b..4464f27b 100644--- a/Asterism/Asterism/Support/MacSettingsWindow.swift+++ b/Asterism/Asterism/Support/MacSettingsWindow.swift@@ -9,8 +9,13 @@ import SwiftUI @Observable final class MacSettingsWindow { static let identifier = "settings-window"+ private let preferences: UserDefaults @ObservationIgnored private var controller: NSWindowController? + init(preferences: UserDefaults) {+ self.preferences = preferences+ }+ func show( model: AppLibraryModel, navigation: AppNavigation,@@ -27,7 +32,8 @@ final class MacSettingsWindow { tabs.pageActions[page] = toolbar let root = MacSettingsPageRoot( page: page, model: model, navigation: navigation,- announcements: announcements, openMainWindow: openMainWindow, toolbar: toolbar)+ announcements: announcements, openMainWindow: openMainWindow,+ preferences: preferences, toolbar: toolbar) let host = NSHostingController(rootView: root) host.sceneBridgingOptions = [] let item = NSTabViewItem(viewController: host)@@ -62,6 +68,7 @@ private struct MacSettingsPageRoot: View { let navigation: AppNavigation let announcements: AnnouncementSeenState let openMainWindow: () -> Void+ let preferences: UserDefaults let toolbar: SettingsToolbarActions var body: some View {@@ -70,6 +77,7 @@ private struct MacSettingsPageRoot: View { page: page, model: model, navigation: navigation, dismissSheet: nil, openMainWindow: openMainWindow) }+ .defaultAppStorage(preferences) .environment(\.nativeSettingsToolbar, toolbar) .environment(\.siteNames, model.siteNames) .environment(announcements)
diff --git a/Asterism/Asterism/UITestLaunchSupport.swift b/Asterism/Asterism/UITestLaunchSupport.swiftindex 3a404da2..423f84ae 100644--- a/Asterism/Asterism/UITestLaunchSupport.swift+++ b/Asterism/Asterism/UITestLaunchSupport.swift@@ -383,11 +383,44 @@ enum UITestLaunchSupport { struct InjectedWorksReadFailure: Error {} #endif + /// Internal opt-in used only by the physical signpost benchmark harness.+ static let isolatedBenchmarkPreferencesKey = "ASTERISM_UI_TEST_ISOLATED_BENCHMARK_PREFERENCES"++ /// Custom suites write only their own domain. Invalid opt-ins also receive+ /// a disposable domain; request validation renders unavailable rather than+ /// ever falling back to the production library or preferences.+ static func launchPreferences(+ environmentProvider: any ProcessEnvironmentProviding = SystemProcessEnvironment(),+ standard: UserDefaults = .standard+ ) -> UserDefaults {+ #if DEBUG || ASTERISM_PERFORMANCE_TESTING+ let environment = environmentProvider.environment+ guard environment[isolatedBenchmarkPreferencesKey] != nil else { return standard }+ let runID = environment[runIDKey].flatMap(UUID.init(uuidString:)) ?? UUID()+ let name = "AsterismUITests.Benchmark.\(runID.uuidString)"+ guard let defaults = UserDefaults(suiteName: name) else {+ preconditionFailure("Cannot create isolated benchmark preferences")+ }+ // Never accept a caller-supplied domain, remove a production domain, or+ // use addSuite(named:), which would keep the standard search domain.+ defaults.removePersistentDomain(forName: name)+ return defaults+ #else+ return standard+ #endif+ }+ static func request( environmentProvider: any ProcessEnvironmentProviding = SystemProcessEnvironment(), temporaryDirectory: URL = FileManager.default.temporaryDirectory ) -> UITestLaunchRequest { let environment = environmentProvider.environment+ if let isolation = environment[isolatedBenchmarkPreferencesKey] {+ let allowed = [seededScaleM4Scenario, seededScaleM4ToleratedPrefix + "duplicateSiteRows"]+ guard isolation == "1", let scenario = environment[scenarioKey], allowed.contains(scenario) else {+ return .invalid(message: "Invalid isolated benchmark scenario.")+ }+ } guard let scenario = environment[scenarioKey] else { return .disabled }
diff --git a/Asterism/AsterismTests/BenchmarkPreferencesRenderingTests.swift b/Asterism/AsterismTests/BenchmarkPreferencesRenderingTests.swiftnew file mode 100644index 00000000..206c9d3a--- /dev/null+++ b/Asterism/AsterismTests/BenchmarkPreferencesRenderingTests.swift@@ -0,0 +1,55 @@+import AsterismPresentation+import SwiftUI+#if os(macOS)+import AppKit+#else+import UIKit+#endif+import XCTest+@testable import Asterism++private struct BenchmarkAppStorageProbe: View {+ @AppStorage(WorksListStorageKey.sort) private var sort = "newest"+ let written: () -> Void+ var body: some View {+ Text(sort).onAppear { sort = "aToZ"; written() }+ }+}++@MainActor+final class BenchmarkPreferencesRenderingTests: XCTestCase {+ func testMountedAppStorageWritesOnlyToSelectedBenchmarkSuite() async throws {+ let name = "benchmark.rendering.tests.\(UUID())"+ let selected = try XCTUnwrap(UserDefaults(suiteName: name))+ let outerName = "benchmark.rendering.production-stand-in.\(UUID())"+ let production = try XCTUnwrap(UserDefaults(suiteName: outerName))+ production.set("owner-kept", forKey: WorksListStorageKey.sort)+ defer {+ selected.removePersistentDomain(forName: name)+ production.removePersistentDomain(forName: outerName)+ }+ let appeared = expectation(description: "AppStorage wrote through selected environment")+ let content = BenchmarkAppStorageProbe(written: { appeared.fulfill() })+ .defaultAppStorage(selected)+ .defaultAppStorage(production)+ #if os(macOS)+ let window = NSWindow(contentRect: CGRect(x: 0, y: 0, width: 300, height: 200),+ styleMask: [.titled], backing: .buffered, defer: false)+ window.isReleasedWhenClosed = false+ window.contentView = NSHostingView(rootView: content)+ window.orderFront(nil)+ defer { window.orderOut(nil); window.contentView = nil; window.close() }+ #else+ let scene = try XCTUnwrap(UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.first)+ let window = UIWindow(windowScene: scene)+ window.frame = CGRect(x: 0, y: 0, width: 300, height: 200)+ window.rootViewController = UIHostingController(rootView: content)+ window.isHidden = false+ defer { window.isHidden = true; window.rootViewController = nil }+ #endif+ let outcome = await XCTWaiter.fulfillment(of: [appeared], timeout: 3)+ XCTAssertEqual(outcome, .completed)+ XCTAssertEqual(selected.string(forKey: WorksListStorageKey.sort), "aToZ")+ XCTAssertEqual(production.string(forKey: WorksListStorageKey.sort), "owner-kept")+ }+}
diff --git a/Asterism/AsterismTests/BenchmarkPreferencesTests.swift b/Asterism/AsterismTests/BenchmarkPreferencesTests.swiftnew file mode 100644index 00000000..08a856ab--- /dev/null+++ b/Asterism/AsterismTests/BenchmarkPreferencesTests.swift@@ -0,0 +1,120 @@+import AsterismCore+import AsterismPresentation+import Foundation+import Testing+@testable import Asterism++@MainActor+@Suite("Benchmark preferences isolation")+struct BenchmarkPreferencesTests {+ private func environment(runID: UUID = UUID(), scenario: String = "seeded-scale-m4") -> BenchmarkEnvironment {+ BenchmarkEnvironment(values: [+ UITestLaunchSupport.isolatedBenchmarkPreferencesKey: "1",+ UITestLaunchSupport.scenarioKey: scenario,+ UITestLaunchSupport.runIDKey: runID.uuidString,+ UITestLaunchSupport.lastSeenVersionKey: "0.6.0",+ ])+ }++ @Test("Normal and ordinary seeded launches keep their injected standard store")+ func ordinaryLaunchStoreUnchanged() {+ AnnouncementTestSupport.withThrowawayDefaults { production in+ for values in [[:], [UITestLaunchSupport.scenarioKey: "seeded-m1",+ UITestLaunchSupport.runIDKey: UUID().uuidString]] {+ let selected = UITestLaunchSupport.launchPreferences(+ environmentProvider: BenchmarkEnvironment(values: values), standard: production)+ #expect(selected === production)+ }+ }+ }++ @Test("Benchmark resets and announcement writes cannot alter the production preference domain")+ func launchWritesStayIsolated() {+ AnnouncementTestSupport.withThrowawayDefaults { production in+ let runID = UUID(), env = environment(runID: runID)+ let domain = "AsterismUITests.Benchmark.\(runID.uuidString)"+ let keys = WorksListStorageKey.seededLaunchResets+ for key in keys { production.set("owner-kept-\(key)", forKey: key) }+ production.set("owner-version", forKey: AnnouncementSeenState.lastSeenVersionKey)+ production.set("unrelated", forKey: "benchmark.unrelated.sentinel")+ let selected = UITestLaunchSupport.launchPreferences(environmentProvider: env, standard: production)+ defer { selected.removePersistentDomain(forName: domain) }+ #expect(selected !== production)+ for key in keys {+ #expect(selected.object(forKey: key) == nil)+ selected.set("temporary", forKey: key)+ }+ _ = ContentView.launchModel(defaults: selected, environmentProvider: env)+ let seen = ContentView.launchSeenState(defaults: selected, environmentProvider: env)+ for key in keys {+ #expect(selected.object(forKey: key) == nil)+ #expect(production.string(forKey: key) == "owner-kept-\(key)")+ }+ #expect(seen.lastSeenVersion == "0.6.0")+ #expect(selected.string(forKey: AnnouncementSeenState.lastSeenVersionKey) == "0.6.0")+ #expect(production.string(forKey: AnnouncementSeenState.lastSeenVersionKey) == "owner-version")+ #expect(production.string(forKey: "benchmark.unrelated.sentinel") == "unrelated")+ }+ }++ @Test("Separate benchmark runs never share saved preferences")+ func separateRunDomains() {+ let firstID = UUID(), secondID = UUID()+ let first = UITestLaunchSupport.launchPreferences(environmentProvider: environment(runID: firstID))+ let second = UITestLaunchSupport.launchPreferences(environmentProvider: environment(runID: secondID))+ defer {+ first.removePersistentDomain(forName: "AsterismUITests.Benchmark.\(firstID.uuidString)")+ second.removePersistentDomain(forName: "AsterismUITests.Benchmark.\(secondID.uuidString)")+ }+ first.set("first-only", forKey: WorksListStorageKey.sort)+ #expect(second.object(forKey: WorksListStorageKey.sort) == nil)+ second.set("second-only", forKey: WorksListStorageKey.sort)+ #expect(first.string(forKey: WorksListStorageKey.sort) == "first-only")+ }++ @Test("Both benchmark scenarios retain contained temporary libraries without CloudKit",+ arguments: ["seeded-scale-m4", "seeded-scale-m4-duplicateSiteRows"])+ func benchmarkLibraryIsolation(scenario: String) {+ let runID = UUID()+ let request = UITestLaunchSupport.request(+ environmentProvider: environment(runID: runID, scenario: scenario),+ temporaryDirectory: URL(filePath: "/tmp/benchmark-isolation-unit"))+ guard case .seeded(let configuration, _) = request else {+ Issue.record("Expected isolated benchmark fixture"); return+ }+ #expect(configuration.rootDirectory.path == "/tmp/benchmark-isolation-unit/AsterismUITests/\(runID.uuidString)")+ #expect(configuration.cloudKitContainerID == nil)+ }++ @Test("Malformed opt-ins cannot select a production library or standard preferences",+ arguments: ["missing-scenario", "unsupported-scenario", "missing-uuid", "invalid-uuid", "invalid-opt-in"])+ func malformedBenchmarkFailsClosed(kind: String) {+ AnnouncementTestSupport.withThrowawayDefaults { production in+ let id = UUID()+ var values = environment(runID: id).values+ switch kind {+ case "missing-scenario": values.removeValue(forKey: UITestLaunchSupport.scenarioKey)+ case "unsupported-scenario": values[UITestLaunchSupport.scenarioKey] = "seeded-m1"+ case "missing-uuid": values.removeValue(forKey: UITestLaunchSupport.runIDKey)+ case "invalid-uuid": values[UITestLaunchSupport.runIDKey] = "../../production"+ default: values[UITestLaunchSupport.isolatedBenchmarkPreferencesKey] = "yes"+ }+ let env = BenchmarkEnvironment(values: values)+ guard case .invalid = UITestLaunchSupport.request(environmentProvider: env) else {+ Issue.record("Invalid benchmark opt-in must not fall through to production"); return+ }+ let selected = UITestLaunchSupport.launchPreferences(environmentProvider: env, standard: production)+ defer { selected.removePersistentDomain(forName: "AsterismUITests.Benchmark.\(id.uuidString)") }+ #expect(selected !== production)+ production.set("unchanged", forKey: WorksListStorageKey.sort)+ _ = ContentView.launchModel(defaults: selected, environmentProvider: env)+ _ = ContentView.launchSeenState(defaults: selected, environmentProvider: env)+ #expect(production.string(forKey: WorksListStorageKey.sort) == "unchanged")+ }+ }+}++private struct BenchmarkEnvironment: ProcessEnvironmentProviding {+ let values: [String: String]+ var environment: [String: String] { values }+}
diff --git a/Asterism/AsterismUITests/M4ScaleTodayPerformanceUITests.swift b/Asterism/AsterismUITests/M4ScaleTodayPerformanceUITests.swiftindex 1d278b23..3dcaf18b 100644--- a/Asterism/AsterismUITests/M4ScaleTodayPerformanceUITests.swift+++ b/Asterism/AsterismUITests/M4ScaleTodayPerformanceUITests.swift@@ -162,6 +162,7 @@ final class M4ScaleTodayPerformanceUITests: XCTestCase { let app = XCUIApplication() app.launchEnvironment["ASTERISM_UI_TEST_SCENARIO"] = scenario app.launchEnvironment["ASTERISM_UI_TEST_RUN_ID"] = UUID().uuidString+ app.launchEnvironment["ASTERISM_UI_TEST_ISOLATED_BENCHMARK_PREFERENCES"] = "1" app.launch() return app }
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 33fca3c7..2049bcaf 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,6 +8,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). ### Fixed +- **Physical benchmark preferences (T-2115):** isolate opted-in performance runs from the installed app's sort, navigation and release-note preferences using a disposable domain for each launch; preserve normal launch behaviour.+ - **Qualification index (T-2468):** align the association status with source-qualified Core/native/Mac and full phone/iPad results, while retaining failed performance gates and the pending release disposition. - **UI acceptance discovery (T-2468):** reveal lazy Work, recovery and saved-source review rows before verifying note counts, exact annotation text and control sizes. Keep review controls fully below their own sheet toolbar before native activation and wait for the decision before closing. Open Capture details with its native action and require the expanded content as the witness.
diff --git a/specs/OVERVIEW.md b/specs/OVERVIEW.mdindex 908bb8d9..82cc1998 100644--- a/specs/OVERVIEW.md+++ b/specs/OVERVIEW.md@@ -3,8 +3,9 @@ | Name | Creation Date | Status | Summary | |------|---------------|--------|---------| | [Settings Layout](settings-layout/requirements.md) | 2026-10-24 | Implemented — publication gates passed | T-2483. Group mobile configuration rows, provide direct Mac settings tabs, and collect detached notes/captures in Maintenance. |+| [Benchmark Preferences Isolation](#benchmark-preferences-isolation) | 2026-10-24 | In Progress — eligible for draft publication with one owner-accepted phone exception; history/privacy checks pending | T-2115. Isolate opted-in benchmark preferences while preserving normal launches and benchmark semantics. | | [Character–Chapter Associations](#characterchapter-associations) | 2026-10-18 | In Progress — UI acceptance qualified; performance release exceptions accepted | T-2468. Persist grounded chapter-note links and exact pair annotations; shared known-character/place Save matching and duplicate-resolution continuity have focused verification. |-| [Performance Signpost Names](#performance-signpost-names) | 2026-10-15 | In Progress — source implemented; acceptance blocked by host memory/scheduler pressure | T-2115. Replace milestone helper/category names with presentation and teaching names, preserve interval behavior, and guard emitter/metric agreement on the host. Physical sample verification remains owner-run. |+| [Performance Signpost Names](#performance-signpost-names) | 2026-10-15 | In Progress — rename merged; physical samples verified; phone result red with one owner-accepted exception | T-2115. Replace milestone helper/category names with presentation and teaching names, preserve interval behavior, and guard emitter/metric agreement on the host. | | [Chosen-Day Notes](#chosen-day-notes) | 2026-10-15 | Complete — owner validated; phone UI gate qualified | T-2428. Optional day in the existing notes Shortcuts action, preserving default-today/latest-share results and typed values. | | [Bootstrap Initialization](#bootstrap-initialization) | 2026-10-14 | Owner accepted — pr-pilot final review; broad UI gates qualified | T-2056. Consolidate five AppLibraryModel constructors through one private Bootstrap initializer while preserving caller APIs and runtime behavior. | | [Cover Image Drop](#cover-image-drop) | 2026-10-11 | Draft Review | T-2433. Drop local cover images through existing crop/draft/Save; no network or schema change. |@@ -1104,3 +1105,9 @@ The original duplicate observation/settling and capture-projection budgets remai - [Save-time matching and resolver verification](character-chapter-associations/save-time-known-links/implementation.md) - [Save-time policy decisions](character-chapter-associations/save-time-known-links/decision_log.md) - [Reading refinement tasks](character-chapter-associations/note-first-redesign/ui-refinements-tasks.md)++## Benchmark Preferences Isolation++- **Path:** `specs/benchmark-preferences-isolation/`+- **Files:** [smolspec.md](benchmark-preferences-isolation/smolspec.md), [tasks.md](benchmark-preferences-isolation/tasks.md), [decision_log.md](benchmark-preferences-isolation/decision_log.md), [implementation.md](benchmark-preferences-isolation/implementation.md), [verification.md](benchmark-preferences-isolation/verification.md)+- **Status:** All 33 expected iPad UI identifiers passed with 0 skips. The full phone result remains Failed (246 passed, 1 failed, 2 expected physical-only skips); the owner accepted only the named creator-controls failure as a publication exception and directed no further investigation or rerun. An approved retry passed all 6 expected production Mac Settings UI identifiers with 0 failures and 0 skips; the AppKit-hosted branch of the generic mounted rendering probe was not run separately. The change is eligible for draft publication with this one exception; history and privacy checks are separate publication prerequisites. Physical signpost evidence applies only to the preserved pre-integration safety snapshot; normal app restoration was a separate approved normal-build install and launch before this integration. No current-source physical run is claimed.
diff --git a/specs/benchmark-preferences-isolation/decision_log.md b/specs/benchmark-preferences-isolation/decision_log.mdnew file mode 100644index 00000000..97f85662--- /dev/null+++ b/specs/benchmark-preferences-isolation/decision_log.md@@ -0,0 +1,76 @@+# Decision Log: Benchmark Preferences Isolation++## Quick Decisions++| ID | Date | Decision | Rationale |+| --- | --- | --- | --- |+| Q1 | 2026-10-24 | Use one injected UUID-scoped UserDefaults suite for explicitly opted-in benchmarks and all scene roots. | Reuses the existing AnnouncementSeenState(defaults:) seam; no live preferences rollback is needed. Normal launches retain standard defaults. |+| Q2 | 2026-10-24 | Reject any present opt-in other than exact `1`, unsupported/missing scenarios and invalid/missing UUIDs; malformed launches use disposable preferences and unavailable library state. | No malformed test request may select a real library or production preferences. |+| Q3 | 2026-10-24 | Use a fixed internal domain prefix plus UUID; never accept a domain name from the environment. Select once per launch. | Prevents real-domain selection and accidental clearing during repeated composition. |+| Q4 | 2026-10-24 | Keep physical execution owner-run and separate from simulator proof. | The owner-run check against the preserved pre-integration safety snapshot confirmed four physical suite cases, including two measurement cases, with 20 samples per measurement case. This resolves the named signpost sample check only; it does not replace publication gates or authorize a rerun after integration. |++Clean-context explanation and design critique found no escalation trigger or major design concern. Wording gaps were resolved in place: exact scenarios/flag, Release exclusion, per-launch suite lifecycle, synthetic production stand-ins and fail-closed suite-creation failure. The user explicitly authorised implementing this narrow safety correction; routine internal naming/plan choices require no further approval.++## Decision 1: Accept One Creator-Control UI Exception++**Date**: 2026-10-25+**Status**: accepted++### Context++The full phone UI run remains failed: 249 unique identifiers produced 246+passes, one failure, and two expected physical-only skips. The failing case is+`AccessibilityJourneyUITests/testTheCreatorControlsStayReachableAtLargestDynamicType()`.+It fails on the second return to All works after opening creator detail and+the creator list. Earlier ordered-prefix evidence was mixed: the branch run+had seven passes and the same failure, while a clean main-tree run and an+unchanged-branch repeat each passed all eight. The cause remains unresolved.++On 2026-10-25, the owner explicitly accepted this one test failure as a+publication exception and directed that this case not be investigated or+rerun. The acceptance does not change the recorded test outcome.++### Decision++Accept only this exact test failure as an owner-approved publication+exception. Keep the full phone result marked Failed and do not investigate or+rerun the case. No other failure or gate is waived.++### Rationale++The owner made a specific, informed scope decision after reviewing the+preserved run comparisons. Respecting that decision allows the change to be+eligible for draft publication while preserving the failure and uncertainty+for future readers. The approved Mac retry has since passed all six expected+production Settings UI journeys; it does not alter the phone exception's+scope.++### Alternatives Considered++- **Keep publication blocked until every phone case passes**: Rejected because+ the owner explicitly accepted this single exception and directed that work+ on this case stop.+- **Relabel the case or full phone run as passed**: Rejected because the+ executed result contains a failure; an exception is not a passing test.+- **Apply a navigation workaround or continue investigating**: Rejected+ because the owner directed no further investigation or rerun, and the+ diagnostic observation does not prove the intermittent cause.++### Consequences++**Positive:**+- Draft publication may proceed after history and privacy checks.+- The failure, its selector, and the uncertainty remain explicit in the+ verification record.++**Negative:**+- The full phone UI result remains red, with one unresolved failure.+- This exception is narrow and does not provide precedent to waive another+ failure or gate.++### Impact++Applies only to the named phone UI case for this publication decision. It+does not change assertions, implementation, or test status.++---
diff --git a/specs/benchmark-preferences-isolation/implementation.md b/specs/benchmark-preferences-isolation/implementation.mdnew file mode 100644index 00000000..fa6bf680--- /dev/null+++ b/specs/benchmark-preferences-isolation/implementation.md@@ -0,0 +1,189 @@+# Implementation explanation++This note explains the integrated preference-isolation path and records the+limits of its current verification. It is not a release or publication+approval.++## Beginner Level++### What Changed / What This Does++An explicitly opted-in scale benchmark gets a temporary preference area of its+own. Preferences include sort order and which release notes were seen. Each+benchmark launch uses a new area identified by a fixed internal prefix and its+run UUID. Normal Release launches continue to use standard preferences.++The app chooses the preference store once at startup and gives the same store+to launch-time reset and announcement logic, the main iPhone or Mac window,+and the separate native Mac Settings window. A malformed benchmark request+uses a disposable preference area and produces an unavailable launch instead+of falling through to the real library.++### Why It Matters++The benchmark can reset its own preferences without changing the owner's+regular settings or copying preference files back afterwards. Sharing one+selected store across windows also prevents settings screens from writing to a+different domain than the rest of the launch.++### Key Concepts++- A **preference domain** is a named area where `UserDefaults` stores values.+ A UUID-scoped domain is a temporary drawer for one run.+- A **root view** is the top of a SwiftUI view tree. `defaultAppStorage` tells+ `@AppStorage` views below it which preference store to use.+- **Fail closed** means a malformed request stops before it can select+ production preferences or library state.++## Intermediate Level++### Changes Overview++`UITestLaunchSupport.launchPreferences()` selects the store in `DEBUG` and+`ASTERISM_PERFORMANCE_TESTING` builds. No opt-in returns the standard store.+Any present opt-in selects a suite name made from a fixed internal prefix and+a parsed run UUID. If the UUID is absent or malformed, a generated UUID still+keeps the selected domain disposable; caller input never becomes a domain+name. The selected suite is cleared before use. Failure to create it stops+initialization instead of falling back. Other build configurations return+standard defaults and ignore test-launch handling.++`UITestLaunchSupport.request()` separately requires the exact opt-in value+`1`, one of the two supported scale scenarios, and a valid run UUID. Invalid+input produces `.invalid`. `ContentView.launchModel()` maps `.invalid` to an+unavailable startup model; only `.disabled` reaches production bootstrap. A+valid seeded request resets its existing keys through the defaults instance+passed into `launchModel()`. Thus the benchmark resets its private suite,+while an ordinary seeded UI test without the opt-in retains its previous+reset behavior against standard defaults. `launchSeenState()` uses the same+instance for the announcement-version pin.++`AsterismApp.init()` selects the store once and passes it to `launchModel()`+and `launchSeenState()`. The iOS `WindowGroup` and Mac main `Window` apply it+with `defaultAppStorage`. The app also constructs one `MacSettingsWindow`+owner with the same instance. That owner supplies it to each native Settings+page root; the sidebar action and keyboard command both use the same owner.+The physical UI-test helper opts in and generates a fresh run UUID per launch.++### Implementation Approach++The design uses the existing injectable `AnnouncementSeenState(defaults:)`+seam. Selection lives at app initialization, while launch validation and+library selection remain in the existing launch-support/model-factory path.+The native Mac Settings window retains the selected store so each opening path+does not need to pass another preference argument.++Native tests cover normal selection, distinct run domains, reset and+announcement writes, synthetic production sentinels, malformed requests, and+the two temporary library configurations with CloudKit disabled.+`BenchmarkPreferencesRenderingTests` mounts a generic+`BenchmarkAppStorageProbe` using `@AppStorage` and configured defaults+modifiers. It verifies modifier-level routing to disposable suites; it does+not render each production root. Production-root coverage is a source trace of+the `defaultAppStorage` composition in `AsterismApp` and+`MacSettingsWindow`. iOS rendering does not qualify Mac rendering.++### Trade-offs++Sharing one selected `UserDefaults` instance avoids independent store choices+across the app's separate view roots. Malformed requests lose the requested+benchmark launch, which prevents them from reaching standard preferences or+production library bootstrap. The design does not copy preference files,+migrate production settings, or accept a domain name from the environment.++## Expert Level++### Technical Deep Dive++Preference selection and launch validity are separate safeguards. A present+opt-in selects a custom suite even when malformed; a generated UUID makes+that domain disposable. Request validation then rejects non-`1` values,+unsupported or missing scenarios, and invalid or missing UUIDs. This ordering+ensures malformed input cannot turn into a normal production launch. Suite+creation failure also halts initialization before fallback. The custom suite+is emptied only under its generated fixed-prefix name; it is not added to the+standard defaults search list.++For valid seeded launches, the same instance receives preference resets and+the release-note pin, then flows to the iOS root, Mac main root, and every+separately hosted native Mac Settings page root. Because the native Settings+pages live in their own `NSHostingController`s, each root applies+`defaultAppStorage` explicitly rather than relying on environment inheritance+from the main window. The retained Mac window owner makes both Settings entry+points share that same selection.++Compile-time conditions preserve Release behavior: outside the test-enabled+build configurations, launch preference selection returns standard defaults+and launch request handling is excluded. In test-enabled builds without an+opt-in, ordinary production launch selection remains standard; existing+non-benchmark seeded UI tests keep their prior standard-store resets.++### Architecture Impact++`UserDefaults` remains preferences-only. Library isolation continues to use+the existing validated temporary `LibraryConfiguration` with no CloudKit+container. This change adds no production preference migration or library+schema change; it threads one launch-scoped dependency through app composition.++### Potential Issues++- Any future separately hosted `@AppStorage` root must receive the selected+ store explicitly.+- The mounted rendering probe establishes generic modifier routing, not+ rendered coverage of every production root. Current production-root evidence+ is source-reviewed composition.+- Integrated verification is mixed. Development and ordinary optimized Mac+ app/extension compile and signature checks passed as compile-only checks;+ fresh iOS app units passed 1,847 identifiers across 1,957 executions; and+ all 33 expected iPad UI identifiers passed with no skips. Core and fast+ results are reusable because their 612 Package/script/Makefile inputs are+ unchanged.+- The full phone UI gate remains red: 249 unique identifiers yielded 246+ passes, one failure, and two expected physical-only skips. The failing+ identifier is+ `AccessibilityJourneyUITests/testTheCreatorControlsStayReachableAtLargestDynamicType()`.+ It fails on the second return to All works after creator detail and the+ creator list; the cause is unresolved. The ordered-prefix branch attempt+ produced 7 passes and 1 failure; a clean checkout tree-identical to current+ main and an unchanged-branch repeat each passed all 8. These outcomes do not+ establish a baseline classification. The owner explicitly accepted only+ this named failure as a publication exception and directed no further+ investigation or rerun. The full phone result remains Failed; no other+ failures are waived.+- The prior Mac attempt timed out before executing its six Settings UI cases.+ An explicitly approved retry passed all 6 expected production Settings UI+ identifiers with no failures or skips. The AppKit-hosted branch of the+ generic mounted rendering probe was not run separately. These six production+ journeys are distinct from the generic mounted iOS rendering probe. No+ security settings changed. The prior XCTest runner timeout does not establish+ binary replacement or personal-data changes.+- A separate authorized instrumented exact-eight-prefix run passed 8/8. It+ recorded All works below the tab bar at the second-return pre-scroll; the+ existing downward swipes moved it farther below the viewport, while two+ existing helper upward swipes restored hittability and the tap succeeded.+ Added accessibility queries and screenshots can affect timing, so this is+ diagnostic observation only; it does not prove the intermittent mechanism or+ a production regression. No code remedy was applied. Removing only the+ second-return downward pre-scroll while retaining the bounded helper and+ assertions is deferred as a proposal requiring verification. The temporary+ diagnostic edits were restored exactly.+- The physical signpost result applies only to the preserved pre-integration+ safety snapshot. Normal app restoration was a separate, owner-approved+ normal-build install and launch on the normal app source before this+ integration; it is not part of that safety snapshot. Neither qualifies the+ current integrated source.++## Completeness Assessment++The explanation covers standard and opted-in selection, fail-closed malformed+requests, Release exclusion, launch-time preference reset/pinning, and+propagation to each current app root. It distinguishes generic mounted+`AppStorage` routing from source-reviewed production-root composition and+from the six passing production Mac Settings journeys. It records the full+phone UI result as Failed while limiting the owner's accepted exception to one+exact test. The exception leaves every other result and gate unchanged. The+physical benchmark remains pre-integration evidence; normal restoration was a+separate approved normal-build launch before this integration.+Delivery is tracked in [PR #116](https://github.com/ArjenSchwarz/asterism/pull/116)+with the single owner-accepted phone exception. This does not claim that the PR+has merged or that the overall phone UI gate passed.
diff --git a/specs/benchmark-preferences-isolation/smolspec.md b/specs/benchmark-preferences-isolation/smolspec.mdnew file mode 100644index 00000000..582bc574--- /dev/null+++ b/specs/benchmark-preferences-isolation/smolspec.md@@ -0,0 +1,30 @@+# Benchmark preferences isolation++## Overview+T-2115's physical Today signpost benchmark seeds an isolated library. Its explicitly opted-in launches use their own UUID-scoped preference domain, preserving regular Asterism and Devsterism preferences without copying database or preferences files back.++## Requirements+- Opted-in benchmark launches MUST read/write/reset/pin preferences in a fresh run-specific domain, including SwiftUI AppStorage, sort/navigation and announcement seen state.+- Absent opt-in MUST preserve current preference selection and behaviour. In test-enabled builds only, exact value `1` requests isolation; any other present value MUST fail closed with throwaway preferences. Ordinary Release builds MUST ignore test launch handling as they do now.+- An isolation request with missing/invalid UUID or unsupported/missing benchmark scenario MUST fail closed without opening a production library or modifying production preferences.+- The `seeded-scale-m4` and `seeded-scale-m4-duplicateSiteRows` benchmark scenarios MUST retain their existing temporary library roots, nil CloudKit configuration, seed data, queries, metric interval, iteration count, assertions and budgets.+- The benchmark MUST preserve the owner-interactive device gate; no bypass flag or agent answer is introduced.+- No production preference value or real-library content MUST be included in tests, source or review evidence.++## Implementation Approach+- Add an internal benchmark isolation opt-in to `Asterism/Asterism/UITestLaunchSupport.swift`. Validate it alongside the existing scenario/UUID request; create a custom suite whose name includes only a fixed prefix and a validated UUID. Invalid opt-ins get a throwaway domain while request validation yields unavailable, never production fallback. Each benchmark launch generates a new UUID; the selected suite is emptied only within its fixed test-only namespace. If Foundation cannot create that suite, initialization halts before production bootstrap rather than falling back.+- Select the suite once per app launch, then thread that one UserDefaults instance through `Asterism/Asterism/AsterismApp.swift`, `ContentView.launchModel`, `ContentView.launchSeenState` and root `.defaultAppStorage` environments, including the separate Mac Settings root. Use the existing injectable defaults pattern from `AnnouncementSeenState`.+- Set the opt-in only in `Asterism/AsterismUITests/M4ScaleTodayPerformanceUITests.swift`'s existing fresh-launch helper. Do not change its fixtures or measurement body.+- Add focused native tests for valid/invalid opt-ins, two-run isolation, synthetic sentinels in a disposable production stand-in suite, all reset keys/announcement writes, preserved normal selection, and the existing temporary library/CloudKit contract. Exercise both existing simulator seed methods and relevant launch/announcement tests.+- Dependencies are existing Foundation UserDefaults, SwiftUI AppStorage, current test environment provider and Makefile.+- Out of scope: production preference migration, raw plist restoration, schema/library/CloudKit changes, performance optimisation, settings cleanup, fixture lifetime work, merge and signing/security changes.++## Risks and Assumptions+- Risk: a scene keeps using standard defaults while launch helpers are isolated. Mitigation: share one instance across launch helpers and every scene root; review wiring and run focused native/rendered checks.+- Risk: malformed opt-in falls through to normal bootstrap. Mitigation: request validation rejects it before disabled/production selection; test malformed UUID, absent scenario and unsupported scenario.+- Risk: custom suite could accidentally name a real domain. Mitigation: fixed test-only prefix plus UUID, never arbitrary domain input; test distinct runs and production sentinel preservation.+- Physical verification was completed by the owner against the preserved pre-integration safety snapshot. The normal app restoration was a separate, owner-approved normal-build installation and launch before this integration. On 2026-10-25, the owner accepted only `AccessibilityJourneyUITests/testTheCreatorControlsStayReachableAtLargestDynamicType()` as a publication exception and directed no further investigation or rerun; all other failures and gates retain their status. The change is eligible for draft publication pending history and privacy checks. The existing owner-only device gate still applies to any future run.+- Scope: internal reversible test-launch wiring; no public API, persisted library schema, authorisation boundary or contested product decision. Implementation is explicitly authorised; internal naming and routine plan choices need no additional approval.++## Escalation Note+This change was scoped as a smolspec. If implementation reveals ambiguity only the user can resolve, an irreversible boundary (public API, persisted schema, auth path), or a contested architectural choice, stop and escalate to the full spec workflow rather than deciding it inline.
diff --git a/specs/benchmark-preferences-isolation/tasks.md b/specs/benchmark-preferences-isolation/tasks.mdnew file mode 100644index 00000000..3a219923--- /dev/null+++ b/specs/benchmark-preferences-isolation/tasks.md@@ -0,0 +1,12 @@+---+references:+ - smolspec.md+---+# Benchmark preferences isolation++- [x] 1. Benchmark bootstrap and scene preferences are isolated without changing normal launches <!-- id:g6aeihq -->+ - Verify exact opt-in validation, UUID domains, reset/announcement paths, AppStorage scene wiring, synthetic production sentinels and temporary-library/CloudKit contract against smolspec.md.++- [x] 2. Focused native and rendered benchmark guards qualify the isolated path <!-- id:g6aeihr -->+ - Run selected native suites and both unchanged simulator scale-seeding methods; reconcile expected identifiers and source hashes; review complete safety delta. Record physical prerequisites honestly, no merge.+ - Blocked-by: g6aeihq (Benchmark bootstrap and scene preferences are isolated without changing normal launches)
diff --git a/specs/benchmark-preferences-isolation/verification.md b/specs/benchmark-preferences-isolation/verification.mdnew file mode 100644index 00000000..ea888800--- /dev/null+++ b/specs/benchmark-preferences-isolation/verification.md@@ -0,0 +1,109 @@+# Verification++## Integrated-source checks++- Development and ordinary optimized Mac app and extension compile/signature+ checks passed. These build checks performed no app launch; the separate Development Mac+ runtime checks are recorded below.+- Fresh iOS app-unit coverage passed all **1,847 identifiers** across **1,957+ expanded executions**.+- Core and fast results are reusable because all **612 Package, script, and+ Makefile inputs** match their earlier successful run.+- No owned build or test runner remains active.+- Full phone UI execution finalized with **249 unique identifiers: 246 passed,+ 1 failed, 2 expected physical-only skips**. Expanded totals were **249+ passed, 1 failed, 2 skipped across 252 executions**, because one launch test+ has four configurations. The ordered-prefix branch attempt had 7 passes and+ the same 1 failure; a clean checkout tree-identical to current main passed+ all 8, and an unchanged-branch repeat also passed all 8. The first two+ prefix orders were confirmed identical. The branch source inputs remained+ unchanged during these attempts.++ The failure was+ `AccessibilityJourneyUITests/testTheCreatorControlsStayReachableAtLargestDynamicType()`.+ It occurs on the **second** return to All works after entering creator detail+ and the creator list, not on the initial navigation. The cause is unresolved.+ The passing runs do not establish a baseline classification, and no assertion+ or implementation workaround was added. The full phone gate remains red.+- The full iPad UI run executed and passed **all 33 expected identifiers, with+ 0 skips**.+- The earlier Mac attempt executed **0/6** Settings UI cases because its+ separate XCTest runner timed out during automation initialization and exited.+ An explicitly approved retry then executed and passed **all 6 expected+ production Settings UI identifiers, with 0 failures and 0 skips**. No+ security settings changed. The AppKit-hosted branch of the generic mounted+ rendering probe was not run separately. These six production Settings+ journeys are actual Mac UI evidence; the generic mounted rendering probe is+ iOS-only and does not qualify Mac rendering.++The XCTest runner is separate from the regular Asterism app target. The earlier+timeout and 0/6 result describe runner initialization, not the regular app+target; no binary-replacement or personal-data conclusion follows from that+timeout. The approved retry resolved the Mac UI execution gap.++## Temporary navigation diagnostic++An authorized instrumented exact-eight-prefix run passed **8/8**. The+diagnostic adds accessibility queries and screenshots, so this is an+observation, not acceptance evidence or a performance result. It recorded the+All works button at y=888.67 in a 402 × 874 point app viewport, below a tab bar+starting at y=791. The first downward hub swipe moved it to y=1553.67; seven+more left it there. `selectTab` did not change the recorded geometry. The+existing helper's first upward swipe moved the button to y=872.67; its second+moved it to y=207.67 and made it hittable, after which the tap succeeded.++This observation shows that the pre-scroll in the captured state moved the+target farther below the viewport. It does not establish the cause of the+original intermittent failure or a production regression. No production or+test remedy was applied. The smallest proposed test-navigation change is to+remove only the second-return downward pre-scroll while retaining the existing+bounded helper and assertions; this remains a proposal requiring verification.+The temporary instrumentation was then restored exactly to its saved source.++## Physical signpost and normal restoration++The owner-run physical result belongs to the preserved pre-integration safety+snapshot. It finalized **four physical suite cases, including two measurement+cases: 4 passed, 0 failed, 0 skipped**. Each measurement case recorded 20+nonzero TodayPresentation repository-read samples:++| Scenario | Mean | p95 |+| --- | ---: | ---: |+| Composed scale | 0.56750888335 s | 0.600889875 s |+| Duplicate Site rows | 0.58047991245 s | 0.598323375 s |++These intervals are below the existing 2 s repository-publication reference.+They do not measure end-to-end UI readiness, establish a new baseline, or+demonstrate equivalence to the historical mean. The original signpost rename+has merged. No physical rerun occurred after safety changes were integrated+with the latest main and native Settings roots; this result does not authorize+one.++Normal app restoration was a separate, owner-approved normal-build+installation and launch on the normal app source before this integration. It+was not part of the preserved safety snapshot used for the physical benchmark.+Standard preferences and production bootstrap were used. Library contents and+CloudKit convergence were not independently inspected. Neither restoration+evidence nor physical samples qualify the currently integrated source.++The tap-ready screenshot also shows the upper portion of All works behind the pinned+search field. The full app/hub frame is therefore not the unobscured content+viewport. The original intermittent failure has no equivalent captured geometry.++## Gate status++The benchmark preference implementation is explained in+[implementation.md](implementation.md). Its generic mounted AppStorage probe+verifies modifier-level routing through disposable suites; production-root+coverage is source-reviewed composition, not rendered coverage of every root.++The full phone UI result remains **Failed**: 246 passed, 1 failed, and 2+expected physical-only skips. On 2026-10-25, the owner explicitly accepted+only `AccessibilityJourneyUITests/testTheCreatorControlsStayReachableAtLargestDynamicType()`+as a publication exception and directed that it not be investigated or rerun.+The failure remains recorded as a failure; no other failure is waived. The+approved Mac retry passed all six production Settings journeys, and the full+iPad and current app-unit gates passed. The change is eligible for draft+publication with that one explicit owner-accepted exception. History and+privacy checks remain prerequisites to publishing; the exception does not turn+the phone result into a pass.
The creator-controls case failed on its second return to All works. Isolated comparisons passed; the ordered sequence was branch 7/8, main 8/8, unchanged branch 8/8. A diagnostic run showed a downward pre-scroll moving an already-below-screen target farther away, but did not prove the original intermittent cause. All instrumentation was restored exactly. The owner accepted this case alone and directed work on it to stop; no production or test workaround was applied.
The first runner initialization timed out before any of the six Settings cases executed. After explicit user approval, the single retry executed and passed all six expected production Settings identifiers with no skips. No security settings changed. The generic mounted AppStorage probe ran on iOS; its separately app-hosted AppKit branch was not run. The historical initialization failure is preserved separately from the successful final Mac gate.
Runtime inputs are byte-identical to the verified source after the documentation-only history rewrite. Temporary diagnostic test edits had their own manifest and were restored to original hashes. Core/fast evidence is reused for 612 identical Package, script and Makefile inputs. Earlier physical measurement belongs to a pre-integration safety snapshot; normal-build reinstallation/launch was a separate earlier action. Neither is current-source physical acceptance. Coverage was not collected.