From 93fa955d6cea4b90c5d5d64090cccd3677efbe44 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sat, 5 Sep 2026 14:31:53 +0200 Subject: [PATCH 01/27] chore: ignore local worktrees --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 0c47b1be..92a7b4e4 100644 --- a/.gitignore +++ b/.gitignore @@ -16,6 +16,7 @@ Package.resolved # Local agent workflow scratch .superpowers/ +.worktrees/ # Machine-local native UI capture ledger (portable checkpoint is tracked separately) docs/ui-review/evidence-manifest.local.json From 94ae9580aeff53237430eabda764c39ea273f90e Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 15:55:11 +0200 Subject: [PATCH 02/27] docs: design Vifty audit remediation program --- ...26-09-06-vifty-audit-remediation-design.md | 216 ++++++++++++++++++ 1 file changed, 216 insertions(+) create mode 100644 docs/superpowers/specs/2026-09-06-vifty-audit-remediation-design.md diff --git a/docs/superpowers/specs/2026-09-06-vifty-audit-remediation-design.md b/docs/superpowers/specs/2026-09-06-vifty-audit-remediation-design.md new file mode 100644 index 00000000..84499acd --- /dev/null +++ b/docs/superpowers/specs/2026-09-06-vifty-audit-remediation-design.md @@ -0,0 +1,216 @@ +# Vifty Audit Remediation Design + +**Date:** 2026-09-06 +**Status:** Approved design +**Repository baseline:** `93fa955d6cea4b90c5d5d64090cccd3677efbe44` + +## Purpose + +Resolve the confirmed correctness, safety, operational-truth, and UI-evidence findings from the 2026-09-06 comprehensive audit without weakening Vifty's existing fan-control, XPC, helper-maintenance, local-data, or release-trust boundaries. + +The work is split into three independently shippable stages. Each stage must leave the repository green and may be reviewed or reverted without depending on unfinished work in a later stage. + +## Global constraints + +- macOS 15 remains the minimum deployment target and Swift Package Manager remains the build system. +- Add no third-party dependency. +- Preserve daemon-first, fail-closed fan writes and all existing fresh-snapshot, transaction, readback, ownership, restore, lock, and journal requirements. +- Do not expose raw SMC writes or relax the agent cooling lease policy. +- Do not change published release history, release tags, cask metadata, signing identities, or notarization policy. +- Implementation verification is read-only with respect to hardware: no fan command, cooling lease, helper maintenance, `sudo`, install, Auto restoration, or release mutation. +- Reuse existing persistence and error-presentation patterns where they satisfy the requirement; do not create a general storage framework. +- Every behavioral change starts with a failing focused test and ends with an independently reviewable commit. +- Current screenshots and accessibility evidence are required before claiming visual polish. Historical evidence is context only. + +## Selected architecture + +Use a safety-first staged program: + +1. Correct durable policy, preference, and helper-process behavior. +2. Make diagnostics, audit health, CLI help, and compiler gates truthful. +3. Repair exact-source UI evidence, review current captures, and apply only evidence-backed polish. + +This order prevents presentation work from hiding unresolved safety or data-integrity defects. It also keeps the UI stage grounded in current screenshots instead of source inspection or historical captures. + +## Stage 1: Safety and persistence + +### 1. Agent-control policy loading + +`AgentControlService` must distinguish active-lease persistence from policy persistence. + +- A successful stored policy value remains authoritative. +- Absence of a stored policy retains the bootstrap default for first-run compatibility. +- Any error reading the policy file forces the in-memory policy to disabled for that daemon session. +- The failure must remain observable in daemon status or diagnostics using a typed persistence-health signal; it must not be represented as unsupported hardware or helper unreachability. +- A policy-read failure by itself must not trigger an SMC write or unnecessary Auto restoration. Existing active-lease or ownership recovery requirements remain unchanged. +- No agent prepare request may succeed while policy persistence health is unresolved. + +### 2. Transactional policy mutation + +Policy changes must not leave memory and durable state disagreeing. + +- Enabling persists `true` before the in-memory policy becomes enabled. +- If enabling persistence fails, the policy remains disabled and the caller receives a typed failure. +- Disabling an active lease first completes the existing Auto restoration path. Durable `false` is then written before the successful disabled status is returned. +- If the durable disable write fails after Auto restoration, the active lease stays cleared, the prior persisted policy remains authoritative, and the caller receives an explicit persistence failure. The service must not report a successfully committed toggle. +- A successful save clears the policy-persistence health error. +- Restart tests must prove success and failure behavior from stored `true`, stored `false`, absent, corrupt, and unreadable policy states. + +### 3. Application preference durability and recovery + +`AppPreferencesStore` must adopt the small, proven recovery behavior used by `CurveProfileStore`, without introducing a shared abstraction. + +- Before replacing a valid primary file, preserve it as `.bak` using same-directory atomic operations. +- On load, try the primary first and then a valid backup. +- A corrupt primary must never overwrite or delete a valid backup. +- Preserve corrupt bytes under a distinct quarantine suffix only when that can be done without endangering the primary or backup; quarantine failure must not block recovery from a valid backup. +- A recovered backup becomes the returned preference state. Rewriting the primary may be attempted, but failure must remain visible rather than destroying the recovered in-memory value. +- Directory permissions remain `0700`; primary, backup, temporary, and quarantine files remain `0600`. +- The nonthrowing `save` path is removed from production use. `AppModel` catches the throwing save, retains the user's in-memory selection, and exposes a clear “settings were not saved” state with a retry path. The state clears on the next successful save. +- Preference write failures must not affect fan-control ownership or invoke hardware operations. + +### 4. Helper lifecycle subprocess reliability + +`DaemonInstallProcessRunner.system` must not wait for process exit while bounded pipes are undrained. + +- Drain stdout and stderr concurrently from process launch through termination. +- Bound captured bytes per stream. Additional bytes may be discarded after the bound; helper lifecycle correctness cannot depend on unbounded diagnostic output. +- Preserve the current exit-status mapping in `DaemonInstallService`. +- On stdin write failure, terminate the process, close all handles, wait for bounded cleanup, and return an error. +- Add a real-process regression whose child writes more than the platform pipe capacity to both stdout and stderr before exiting. The test must complete within a bounded timeout and prove both streams are handled without deadlock. + +### Stage 1 acceptance + +- Injected policy load/save failures prove fail-closed and transactional behavior. +- Preference tests cover valid primary, valid backup, corrupt primary plus valid backup, corrupt primary and backup, permission failure, and successful retry. +- The high-output lifecycle regression passes repeatedly. +- Focused suites and `make test-fast` pass. +- No privileged or hardware mutation command is executed. + +## Stage 2: Diagnostics and operational truth + +### 1. Unknown hardware reporting + +Do not encode snapshot unavailability as a known negative hardware identity. + +- Preserve the existing fallback snapshot only as an internal container where required for report construction. +- The readiness builder must consider `daemonSnapshotError` before interpreting `isAppleSilicon` or `isMacBookPro`. +- When snapshot acquisition fails, the supported-hardware check reports `unknown/unavailable` copy and recommends repairing the daemon path; it must not claim that the machine is unsupported. +- A successful snapshot from genuinely unsupported hardware retains the existing unsupported-hardware blocker and read-only guidance. +- JSON output remains machine-readable and keeps stable existing fields. If a new state field is necessary, update Codable, XPC bridges, JSON schemas, canonical examples, documentation, and compatibility tests together. + +### 2. Audit persistence health + +Audit logging remains observability, not an authorization prerequisite, but failures must be visible. + +- `appendAudit` records the latest persistence error in bounded in-memory state and logs it through the existing Vifty logging surface. +- A later successful append clears the in-memory failure. +- Status and diagnose expose audit availability without overwriting a more important fan-control or restore error. +- An audit append failure must not falsely report that a fan mutation failed if the authoritative transaction and readback succeeded. +- Audit content, paths, permissions, maximum event count, and privacy boundaries remain unchanged. + +### 3. CLI help + +Add discoverable help without changing agent JSON command semantics. + +- `viftyctl help`, `viftyctl --help`, and `viftyctl -h` print the same deterministic usage text and exit zero. +- The usage lists public agent commands and directs helper-maintenance operations to documented supervised flows; it must not advertise raw helper or SMC commands. +- Invalid commands continue returning usage exit code `64` and the structured error behavior already selected by `--json`. +- Help output is version-stable enough for snapshot testing but does not duplicate full integration documentation. + +### 4. Warning-free test gate + +- Remove the unnecessary `try` in `AgentControlServiceTests`. +- Compile test sources with warnings-as-errors in both fast and full verification paths. +- Keep the production warnings-as-errors build. +- CI continues to invoke `make verify-full`; no parallel compiler policy is introduced. + +### Stage 2 acceptance + +- Fixture tests distinguish supported, unsupported, and unavailable hardware. +- Audit failure and recovery are observable without changing fan mutation results. +- All three help forms exit zero; invalid commands retain exit `64`. +- A deliberately introduced test warning would fail the gate. +- `make verify` passes with schemas, examples, documentation contracts, bundle checks, and codesign structure intact. + +## Stage 3: UI evidence and polish + +### 1. Repair fixture readiness + +Treat the 10-second and 60-second `READY_TIMEOUT` reports as the starting failure. + +- Trace the exact-source fixture from preparation through window creation, observation bridge delivery, stability checks, capture, and final report publication. +- Determine whether the failure is deterministic application logic or a WindowServer/session precondition before changing production UI code. +- Add the smallest behavioral seam that makes readiness observable and testable. +- Add a regression that launches the inert fixture, receives a stable observation, and reaches capture-ready state within the documented bound. +- Preserve `modelStartSkipped=true`, inert hardware dependencies, and zero external fan/helper mutations. + +### 2. Capture current evidence + +Run the repository's declared matrix rather than inventing a new parallel harness. + +- Capture required main-window widths, menu-bar popover, settings views, helper/error states, agent-control states, light mode, dark mode, and increased text scale. +- Collect accessibility evidence for labels, roles, values, actions, focus order, adjustable curve controls, keyboard operation, and meaningful status text. +- Each accepted row must bind to the exact source revision and build provenance. +- Failed or missing rows stay pending; do not promote a partial matrix as complete. + +### 3. Evidence-backed polish pass + +Only current evidence may create polish work. + +- Fix clipping, truncation, low contrast, excessive dead space, inconsistent spacing, unclear hierarchy, misleading status copy, inaccessible controls, or broken focus behavior found in the accepted matrix. +- Prefer native SwiftUI layout, accessibility, and control behavior. +- Preserve the existing application information architecture unless evidence shows a concrete workflow failure. +- Each visual change receives a focused behavioral/layout test and before/after capture at affected matrix rows. + +### 4. Simplify evidence maintenance + +After the capture path is stable, convert repeated matrix cases to data-driven declarations where this reduces duplication without weakening provenance or acceptance rules. + +- Do not simplify fan safety, release verification, evidence signing, provenance binding, or fail-closed review semantics. +- Do not introduce a new snapshot-testing dependency. +- Deletion is accepted only when the replacement tests prove equivalent required matrix coverage. + +### Stage 3 acceptance + +- Every required evidence-manifest row is accepted or explicitly documented as pending with a concrete blocker. +- No accepted capture shows clipping, unreadable contrast, inaccessible primary controls, misleading ownership state, or broken focus behavior. +- Accessibility evidence covers the complete supported interaction surface. +- `make verify-full` passes. +- A final read-only `viftyctl diagnose --json` is recorded; if the installed helper is unavailable, that limitation is reported rather than repaired automatically. + +## Commit and review boundaries + +Use small commits aligned with independently testable behavior: + +1. Fail-closed policy loading. +2. Transactional policy mutation. +3. Recoverable app preferences and visible save failure. +4. Nonblocking lifecycle output handling. +5. Truthful unknown-hardware diagnostics. +6. Observable audit persistence health. +7. CLI help and warning-free test gates. +8. UI fixture readiness repair. +9. Current evidence capture. +10. Evidence-backed UI fixes. +11. Data-driven evidence-harness reduction, only if equivalence is proven. + +Review Stage 1 before starting Stage 2, and Stage 2 before starting Stage 3. A failed gate stops the program without folding unrelated fixes into the failing commit. + +## Verification and proof boundaries + +Repository tests and inert fixtures can prove deterministic source behavior, schemas, packaging, and read-only diagnostics. They cannot prove physical fan compatibility, successful privileged helper replacement, notarization of new bytes, or subjective visual quality on every display. + +Those claims require separate, explicitly authorized evidence: + +- Supported-hardware Fixed/Curve/Auto compatibility requires supervised hardware validation and fresh full-set readback. +- Helper repair or install behavior requires an explicit privileged maintenance session. +- Release trust requires the existing Developer ID, notarization, stapling, checksum, Gatekeeper, governance, and public artifact workflow. +- Visual polish requires current accepted screenshots and human review after the fixture is repaired. + +## Non-goals + +- No new fan-control mode, agent policy feature, updater, telemetry persistence, analytics, network service, or third-party dependency. +- No rewrite of `AgentControlService`, `AppModel`, the release pipeline, or the UI evidence system. +- No weakening of output schemas for convenience. +- No automatic repair, install, fan control, cooling request, Auto restoration, release, or deployment during implementation. From daeaf107cdcbd5224a6a7784e35ac59c51fe841e Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 16:06:58 +0200 Subject: [PATCH 03/27] docs: plan staged Vifty audit remediation --- ...-09-06-vifty-stage-1-safety-persistence.md | 294 ++++++++++++++++++ ...6-09-06-vifty-stage-2-operational-truth.md | 220 +++++++++++++ ...-09-06-vifty-stage-3-ui-evidence-polish.md | 270 ++++++++++++++++ 3 files changed, 784 insertions(+) create mode 100644 docs/superpowers/plans/2026-09-06-vifty-stage-1-safety-persistence.md create mode 100644 docs/superpowers/plans/2026-09-06-vifty-stage-2-operational-truth.md create mode 100644 docs/superpowers/plans/2026-09-06-vifty-stage-3-ui-evidence-polish.md diff --git a/docs/superpowers/plans/2026-09-06-vifty-stage-1-safety-persistence.md b/docs/superpowers/plans/2026-09-06-vifty-stage-1-safety-persistence.md new file mode 100644 index 00000000..f1f3aa52 --- /dev/null +++ b/docs/superpowers/plans/2026-09-06-vifty-stage-1-safety-persistence.md @@ -0,0 +1,294 @@ +# Vifty Stage 1 Safety and Persistence Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Make agent policy, application preferences, and helper lifecycle execution fail closed, durable, recoverable, and truthful. + +**Architecture:** Add one small status value for daemon persistence health, keep policy mutations inside `AgentControlService`, copy the proven `CurveProfileStore` recovery sequence into the app-preference store, and drain lifecycle process output concurrently with fixed byte limits. Do not create a general persistence framework or alter fan mutation paths. + +**Tech Stack:** Swift 6, Foundation, Swift Concurrency, XCTest, Swift Package Manager, macOS `Process` and `Pipe`. + +**Spec:** `docs/superpowers/specs/2026-09-06-vifty-audit-remediation-design.md` + +## Global Constraints + +- macOS 15 minimum; no third-party dependency. +- No fan command, cooling lease, helper maintenance, `sudo`, install, Auto restoration, or release mutation during verification. +- Preserve all daemon/XPC/SMC/ownership/journal/readback gates. +- Use `.build` as the Swift scratch path and stop if `/System/Volumes/Data` has less than 30 GiB free. + +--- + +### Task 1: Define the persistence-health contract + +**Files:** +- Modify: `Sources/ViftyCore/AgentControlModels.swift` +- Modify: `Sources/ViftyCore/ViftyDaemonProtocol.swift` +- Modify: `Sources/ViftyCore/ViftyCtlRunner.swift` +- Modify: `docs/schemas/viftyctl-status.schema.json` +- Modify: `docs/schemas/viftyctl-command-error.schema.json` +- Modify: `docs/examples/viftyctl/status-active-lease.json` +- Test: `Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift` +- Test: `Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift` + +**Interfaces:** +- Produces: `AgentControlPersistenceHealth(policyStatusAvailable:policyError:auditStatusAvailable:auditError:)`. +- Produces: non-optional `AgentControlStatus.persistenceHealth`, defaulting to `.healthy` for source call-site compatibility. +- XPC decode treats a missing persistence dictionary as unavailable rather than healthy. + +- [ ] **Step 1: Add failing model and XPC round-trip tests** + +```swift +let health = AgentControlPersistenceHealth( + policyStatusAvailable: false, + policyError: "policy unreadable", + auditStatusAvailable: true, + auditError: nil +) +let status = AgentControlStatus( + enabled: false, + activeLease: nil, + lastDecision: nil, + lastErrorCode: .persistenceFailure, + persistenceHealth: health +) +XCTAssertEqual(XPCAgentControlCoding.decodeStatus(XPCAgentControlCoding.encode(status)), status) +``` + +- [ ] **Step 2: Run the focused tests and verify the missing-type failure** + +Run: `swift test --scratch-path "$PWD/.build" --filter XPCAgentControlCodingTests` + +Expected: compilation fails because `AgentControlPersistenceHealth` and `.persistenceFailure` do not exist. + +- [ ] **Step 3: Add the minimal model** + +```swift +public struct AgentControlPersistenceHealth: Codable, Equatable, Sendable { + public var policyStatusAvailable: Bool + public var policyError: String? + public var auditStatusAvailable: Bool + public var auditError: String? + + public static let healthy = Self( + policyStatusAvailable: true, + policyError: nil, + auditStatusAvailable: true, + auditError: nil + ) +} +``` + +Add `case persistenceFailure = "PERSISTENCE_FAILURE"` to `AgentControlErrorCode` and map it to the existing `.runDiagnose` command-error recovery action. Encode all four persistence fields through JSON and XPC; decode absent XPC persistence data as both statuses unavailable with a bounded compatibility message. In `capabilitiesReport()`, require both `status.policy != nil` and `status.persistenceHealth.policyStatusAvailable` before setting `policyStatusAvailable: true`; otherwise return the disabled fallback policy and the bounded policy persistence message without claiming the daemon itself is unreachable. + +- [ ] **Step 4: Update the strict status schema and schema tests** + +Require `persistenceHealth`; require both Boolean availability fields; allow both error fields to be string or null. Add `PERSISTENCE_FAILURE` to every schema/test enum for `AgentControlErrorCode`, including the command-error schema. Update canonical status fixture builders to emit `.healthy` without changing unrelated fields. + +- [ ] **Step 5: Run contract tests** + +Run: `swift test --scratch-path "$PWD/.build" --filter 'XPCAgentControlCodingTests|ViftyCtlJSONExampleTests'` + +Expected: PASS. + +- [ ] **Step 6: Commit** + +```bash +git add Sources/ViftyCore/AgentControlModels.swift Sources/ViftyCore/ViftyDaemonProtocol.swift Sources/ViftyCore/ViftyCtlRunner.swift docs/schemas/viftyctl-status.schema.json docs/schemas/viftyctl-command-error.schema.json docs/examples/viftyctl/status-active-lease.json Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift +git commit -m "feat: expose agent persistence health" +``` + +### Task 2: Fail closed and make policy toggles transactional + +**Files:** +- Modify: `Sources/ViftyCore/AgentControlService.swift` +- Test: `Tests/ViftyCoreTests/AgentControlServiceTests.swift` + +**Interfaces:** +- Consumes: `AgentControlPersistenceHealth` and `.persistenceFailure` from Task 1. +- Produces: policy prepare gate and transactional `setPolicyEnabled(_:)` behavior. + +- [ ] **Step 1: Add one fault-injecting store to the existing test support** + +```swift +private enum AgentControlFault: Error { case loadPolicy, savePolicy } + +private final class AgentControlFaultStore: AgentControlPersisting, @unchecked Sendable { + let base: AgentControlStore + var loadedPolicy: Result = .success(nil) + var savePolicyError: AgentControlFault? + var savedPolicies: [Bool] = [] + + func saveActiveLease(_ lease: AgentCoolingLease?) throws { try base.saveActiveLease(lease) } + func loadActiveLease() throws -> AgentCoolingLease? { try base.loadActiveLease() } + func appendAuditEvent(_ event: AgentControlAuditEvent) throws { try base.appendAuditEvent(event) } + func loadRecentAuditEvents(limit: Int) throws -> [AgentControlAuditEvent] { + try base.loadRecentAuditEvents(limit: limit) + } + func loadAgentControlEnabled() throws -> Bool? { try loadedPolicy.get() } + func saveAgentControlEnabled(_ enabled: Bool) throws { + if let savePolicyError { throw savePolicyError } + savedPolicies.append(enabled) + try base.saveAgentControlEnabled(enabled) + } +} +``` + +Add tests for stored true, stored false, absent, load failure, failed enable save, failed disable save, and successful retry. For load failure assert `enabled == false`, `policyStatusAvailable == false`, error code `.persistenceFailure`, and prepare denial before `hardware.apply`. + +- [ ] **Step 2: Run tests and verify failure on current behavior** + +Run: `swift test --scratch-path "$PWD/.build" --filter AgentControlServiceTests` + +Expected: new load-failure test observes enabled policy or missing health; mutation tests observe memory/disk disagreement. + +- [ ] **Step 3: Separate lease and policy load errors in initialization** + +Use an explicit `do/catch` for `loadAgentControlEnabled()`. On catch set `policy.enabled = false`, set `policyStatusAvailable = false`, and retain a bounded localized message. Do not add the policy error to `persistenceLoadErrorMessage`, because that lease error intentionally triggers Auto recovery. + +- [ ] **Step 4: Gate prepare and reorder durable mutation** + +At the top of `prepare`, deny with `.persistenceFailure` while policy status is unavailable. In `setPolicyEnabled`, perform active-lease Auto restoration first when disabling, then call `saveAgentControlEnabled(enabled)`, and only then assign `policy.enabled = enabled`. On failure retain the pre-call policy value, publish the typed health error, and rethrow. + +- [ ] **Step 5: Run service and store tests** + +Run: `swift test --scratch-path "$PWD/.build" --filter 'AgentControlServiceTests|AgentControlStoreTests'` + +Expected: PASS with no hardware apply in persistence-failure cases. + +- [ ] **Step 6: Commit** + +```bash +git add Sources/ViftyCore/AgentControlService.swift Tests/ViftyCoreTests/AgentControlServiceTests.swift +git commit -m "fix: fail closed on agent policy persistence errors" +``` + +### Task 3: Recover app preferences and surface failed saves + +**Files:** +- Modify: `Sources/Vifty/AppPreferencesStore.swift` +- Modify: `Sources/Vifty/AppModel.swift` +- Modify: `Sources/Vifty/AppModel+MenuBar.swift` +- Modify: `Sources/Vifty/SettingsGeneralView.swift` +- Test: `Tests/ViftyCoreTests/AppModelPreferencesTests.swift` +- Test: `Tests/ViftyCoreTests/AppSourceRegressionTests.swift` + +**Interfaces:** +- Produces: `AppPreferencesLoadResult(preferences:recoveryMessage:)`. +- Produces: `AppModel.appPreferencesPersistenceMessage` and `retryAppPreferencesSave()`. + +- [ ] **Step 1: Add failing backup and write-error tests** + +Create private `0700` test directories and `0600` files. Assert that a corrupt primary plus valid backup returns the backup, does not mutate the backup, and reports recovery. Assert that an unwritable/invalid destination sets `appPreferencesPersistenceMessage`, while a later valid retry clears it. + +- [ ] **Step 2: Run the focused tests and capture the failures** + +Run: `swift test --scratch-path "$PWD/.build" --filter AppModelPreferencesTests` + +Expected: backup is replaced by corrupt bytes and save failure remains invisible. + +- [ ] **Step 3: Implement the store recovery sequence** + +```swift +struct AppPreferencesLoadResult: Equatable { + var preferences: AppPreferences + var recoveryMessage: String? +} +``` + +Add `loadResult() throws -> AppPreferencesLoadResult`. Decode primary, then backup. Preserve a valid primary to `.bak` before replacement. Never delete `.bak` during corrupt-primary handling. Use same-directory atomic writes and reapply `0700`/`0600` permissions. Keep `load()` as a test/compatibility convenience returning `(try? loadResult().preferences) ?? migratedPreferences()`; production initialization uses `loadResult()`. + +- [ ] **Step 4: Route throwing saves through AppModel** + +Replace `preferencesStore.save(...)` with `do { try saveThrowing; message = nil } catch { message = "Settings were not saved: …" }`. Add `retryAppPreferencesSave()` that calls the same single persistence function. Avoid rollback and recursive `didSet` writes. + +- [ ] **Step 5: Present the error and retry in General settings** + +Use a compact native `Label` plus `Button("Retry Save")` in `SettingsGeneralView`; give both stable accessibility text. Do not mix this message into fan-control `lastError`. + +- [ ] **Step 6: Run focused UI/model tests** + +Run: `swift test --scratch-path "$PWD/.build" --filter 'AppModelPreferencesTests|AppSourceRegressionTests'` + +Expected: PASS; no test hardware command recorded. + +- [ ] **Step 7: Commit** + +```bash +git add Sources/Vifty/AppPreferencesStore.swift Sources/Vifty/AppModel.swift Sources/Vifty/AppModel+MenuBar.swift Sources/Vifty/SettingsGeneralView.swift Tests/ViftyCoreTests/AppModelPreferencesTests.swift Tests/ViftyCoreTests/AppSourceRegressionTests.swift +git commit -m "fix: make app preferences recoverable and truthful" +``` + +### Task 4: Drain helper lifecycle output without deadlock + +**Files:** +- Modify: `Sources/Vifty/DaemonInstallService.swift` +- Test: `Tests/ViftyCoreTests/DaemonInstallServiceTests.swift` + +**Interfaces:** +- Produces: bounded concurrent stdout/stderr capture inside `DaemonInstallProcessRunner.system`. + +- [ ] **Step 1: Add the real high-output regression** + +Create a temporary executable shell script that reads stdin, writes 256 KiB to stdout and 256 KiB to stderr, and exits 0. Invoke `DaemonInstallProcessRunner.system.run` under a two-second XCTest timeout and assert exit 0 plus captured lengths no greater than a named per-stream limit. + +- [ ] **Step 2: Run the test against current code** + +Run: `swift test --scratch-path "$PWD/.build" --filter DaemonInstallServiceTests/testSystemRunnerDrainsLargeOutputWithoutDeadlock` + +Expected: timeout/failure because the child fills a pipe before `waitUntilExit` returns. + +- [ ] **Step 3: Add a bounded collector and drain both handles concurrently** + +```swift +private actor BoundedProcessOutput { + static let maximumBytesPerStream = 64 * 1_024 + private var data = Data() + func append(_ chunk: Data) { + guard data.count < Self.maximumBytesPerStream else { return } + data.append(chunk.prefix(Self.maximumBytesPerStream - data.count)) + } +} +``` + +Start one task per read handle before writing stdin; read until EOF, retaining only the bound. Wait for process termination and both reader tasks. Close handles on every error path. Keep environment and exit mapping unchanged. + +- [ ] **Step 4: Run lifecycle tests repeatedly** + +Run: `for i in 1 2 3; do swift test --scratch-path "$PWD/.build" --filter DaemonInstallServiceTests || exit 1; done` + +Expected: all three runs PASS without a hang. + +- [ ] **Step 5: Commit** + +```bash +git add Sources/Vifty/DaemonInstallService.swift Tests/ViftyCoreTests/DaemonInstallServiceTests.swift +git commit -m "fix: drain helper lifecycle output concurrently" +``` + +### Task 5: Stage 1 verification checkpoint + +**Files:** +- Verify only; modify a file only to fix a Stage 1 regression. + +- [ ] **Step 1: Check disk and diff hygiene** + +Run: `df -h /System/Volumes/Data && git diff --check` + +Expected: at least 30 GiB free and exit 0. + +- [ ] **Step 2: Run the fast gate** + +Run: `make test-fast` + +Expected: all fast XCTest cases pass. + +- [ ] **Step 3: Run the production build gate** + +Run: `swift build --scratch-path "$PWD/.build" -Xswiftc -warnings-as-errors` + +Expected: exit 0. + +- [ ] **Step 4: Review Stage 1 before Stage 2** + +Inspect `git log --oneline` and `git diff 94ae958..HEAD`. Confirm no SMC, XPC authorization, release, or helper-maintenance script weakening. Record `94ae958` and the exact Stage 1 head SHA in the review message; do not create a review-only commit. diff --git a/docs/superpowers/plans/2026-09-06-vifty-stage-2-operational-truth.md b/docs/superpowers/plans/2026-09-06-vifty-stage-2-operational-truth.md new file mode 100644 index 00000000..58e878f4 --- /dev/null +++ b/docs/superpowers/plans/2026-09-06-vifty-stage-2-operational-truth.md @@ -0,0 +1,220 @@ +# Vifty Stage 2 Operational Truth Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Make hardware readiness, audit persistence, CLI discovery, and compiler gates report exactly what is known. + +**Architecture:** Reuse Stage 1's persistence-health object, pass snapshot availability into the existing readiness builder, add one pure help command, and put warnings-as-errors directly on the two existing test targets. Preserve JSON field names and exit codes unless the schema is explicitly advanced in the same commit. + +**Tech Stack:** Swift 6, Foundation, XCTest, JSON Schema fixtures, Make, Swift Package Manager. + +**Spec:** `docs/superpowers/specs/2026-09-06-vifty-audit-remediation-design.md` + +## Global Constraints + +- Stage 1 must be approved and green first. +- No third-party dependency or privileged/hardware operation. +- Preserve `policyStatusAvailable`, `safeToRequestCooling`, blocker IDs, recovery actions, and exit-code contracts. + +--- + +### Task 1: Distinguish unavailable from unsupported hardware + +**Files:** +- Modify: `Sources/ViftyCore/AgentDiagnostics.swift` +- Test: `Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift` +- Test: `Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift` + +**Interfaces:** +- Produces: `supportedHardwareCheck(_:snapshotError:)` with supported, unsupported, and unavailable copy. + +- [ ] **Step 1: Add failing diagnostic cases** + +For a snapshot error, assert the `supportedHardware` message contains “could not be determined” and does not contain “supported only”. For a successful Intel/non-MacBook snapshot, retain the unsupported message and blocker. + +- [ ] **Step 2: Run the focused failure** + +Run: `swift test --scratch-path "$PWD/.build" --filter 'ViftyCtlRunnerTests|ViftyCtlJSONExampleTests'` + +Expected: unavailable case is mislabeled unsupported. + +- [ ] **Step 3: Pass the existing error into the check** + +```swift +private static func supportedHardwareCheck( + _ snapshot: HardwareSnapshot, + snapshotError: String? +) -> ViftyCtlReadinessCheck +``` + +If `snapshotError != nil`, return `passed: false` with unavailable copy. Otherwise evaluate the two hardware booleans exactly as today. Keep the stable check ID so existing agent blocker processing remains compatible. + +- [ ] **Step 4: Run tests and commit** + +Run: `swift test --scratch-path "$PWD/.build" --filter 'ViftyCtlRunnerTests|ViftyCtlJSONExampleTests'` + +```bash +git add Sources/ViftyCore/AgentDiagnostics.swift Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift +git commit -m "fix: report unavailable hardware truthfully" +``` + +### Task 2: Surface audit persistence health + +**Files:** +- Modify: `Sources/ViftyCore/AgentControlService.swift` +- Modify: `Sources/ViftyCore/ViftyCoreLog.swift` +- Modify: `Sources/ViftyCore/AgentDiagnostics.swift` +- Modify: `Sources/Vifty/AppModel+Control.swift` +- Modify: `Sources/Vifty/SettingsAgentWorkflowView.swift` +- Test: `Tests/ViftyCoreTests/AgentControlServiceTests.swift` +- Test: `Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift` +- Test: `Tests/ViftyCoreTests/AppModelFanControlTests.swift` +- Test: `Tests/ViftyCoreTests/AppSourceRegressionTests.swift` + +**Interfaces:** +- Consumes: `AgentControlStatus.persistenceHealth` from Stage 1. +- Produces: last audit append failure and later recovery without changing fan transaction results. + +- [ ] **Step 1: Extend the Stage 1 fault store and add red tests** + +Make `appendAuditEvent` fail once, then succeed. Assert the first status has `auditStatusAvailable == false`, the next successful append restores it to true, and a successful mocked fan transaction still returns success. + +- [ ] **Step 2: Run service tests and verify health remains falsely green** + +Run: `swift test --scratch-path "$PWD/.build" --filter AgentControlServiceTests` + +- [ ] **Step 3: Replace swallowed append with bounded health state** + +```swift +private func appendAudit(...) { + do { + try store.appendAuditEvent(event) + auditPersistenceErrorMessage = nil + } catch { + auditPersistenceErrorMessage = String(error.localizedDescription.prefix(512)) + ViftyCoreLog.agentControl.error("Agent audit persistence failed") + } +} +``` + +Add `static let agentControl = Logger(subsystem: "tech.reidar.vifty", category: "AgentControl")` beside the existing core XPC logger. Build `status().persistenceHealth` from policy and audit health. Do not throw from `appendAudit` and do not replace a fan/restore `lastErrorCode`. + +- [ ] **Step 4: Add diagnostic and UI presentation** + +Keep the existing readiness-check ID set stable. Diagnose and status already embed `AgentControlStatus`, so expose audit health through its `persistenceHealth` object and surface concise attention copy in the existing agent settings/status area. Do not let audit availability change `safeToRequestCooling`, authorize cooling, reverse fan control, or overwrite a higher-priority fan/restore error. + +- [ ] **Step 5: Run focused tests and commit** + +Run: `swift test --scratch-path "$PWD/.build" --filter 'AgentControlServiceTests|ViftyCtlRunnerTests|AppModelFanControlTests|AppSourceRegressionTests'` + +```bash +git add Sources/ViftyCore/AgentControlService.swift Sources/ViftyCore/ViftyCoreLog.swift Sources/ViftyCore/AgentDiagnostics.swift Sources/Vifty/AppModel+Control.swift Sources/Vifty/SettingsAgentWorkflowView.swift Tests/ViftyCoreTests/AgentControlServiceTests.swift Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift Tests/ViftyCoreTests/AppModelFanControlTests.swift Tests/ViftyCoreTests/AppSourceRegressionTests.swift +git commit -m "fix: expose agent audit persistence failures" +``` + +### Task 3: Add deterministic CLI help + +**Files:** +- Modify: `Sources/ViftyCore/ViftyCtlArguments.swift` +- Modify: `Sources/ViftyCore/ViftyCtlRunner.swift` +- Modify: `docs/agent-workflows.md` +- Test: `Tests/ViftyCoreTests/ViftyCtlArgumentsTests.swift` +- Test: `Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift` + +**Interfaces:** +- Produces: `ViftyCtlCommand.help` and `ViftyCtlArguments.usage`. + +- [ ] **Step 1: Add parser and output tests** + +Assert `help`, `--help`, and `-h` parse to `.help`; running `.help` returns exit 0 and identical text ending in a newline. Assert `frobnicate` still throws `.unknownCommand`. + +- [ ] **Step 2: Run the red tests** + +Run: `swift test --scratch-path "$PWD/.build" --filter 'ViftyCtlArgumentsTests|ViftyCtlRunnerTests'` + +- [ ] **Step 3: Add the command and one usage string** + +```swift +public static let usage = """ +Usage: viftyctl [options] +Commands: status, capabilities, agent-rule, diagnose, audit, prepare, restore-auto, run +Run 'viftyctl agent-rule' for the guarded agent workflow. +""" +``` + +Handle aliases in `parse`, return the usage from `ViftyCtlRunner`, add `.help` to command-name/JSON switches, and keep helper-maintenance commands out of public help. + +- [ ] **Step 4: Verify the built executable** + +Run: `bin_dir="$(swift build --scratch-path "$PWD/.build" --show-bin-path)" && for arg in help --help -h; do "$bin_dir/viftyctl" "$arg"; done` + +Expected: three identical outputs and three zero exits. + +- [ ] **Step 5: Commit** + +```bash +git add Sources/ViftyCore/ViftyCtlArguments.swift Sources/ViftyCore/ViftyCtlRunner.swift docs/agent-workflows.md Tests/ViftyCoreTests/ViftyCtlArgumentsTests.swift Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift +git commit -m "feat: add viftyctl help" +``` + +### Task 4: Enforce warning-free test compilation + +**Files:** +- Modify: `Tests/ViftyCoreTests/AgentControlServiceTests.swift` +- Modify: `Makefile` +- Modify: `Tests/ViftyCoreTests/MakefileTrustGateTests.swift` + +**Interfaces:** +- Produces: `SWIFT_TEST_WARNING_ARGS = -Xswiftc -warnings-as-errors` used by both test targets. + +- [ ] **Step 1: Pin the intended Makefile contract in a failing test** + +Assert both `swift test` invocations include `$(SWIFT_TEST_WARNING_ARGS)` and the variable equals `-Xswiftc -warnings-as-errors`. + +- [ ] **Step 2: Run the trust-gate test** + +Run: `swift test --scratch-path "$PWD/.build" --filter MakefileTrustGateTests` + +Expected: FAIL because the argument is absent. + +- [ ] **Step 3: Remove the known warning and wire the flag once** + +Change `let status = try await service.status()` to `let status = await service.status()`. Add the named Make variable and use it in `test-fast` and `test-full`; do not duplicate a second test target. + +- [ ] **Step 4: Run the warning gate** + +Run: `make test-fast` + +Expected: exit 0 with test sources compiled under warnings-as-errors. + +- [ ] **Step 5: Commit** + +```bash +git add Tests/ViftyCoreTests/AgentControlServiceTests.swift Makefile Tests/ViftyCoreTests/MakefileTrustGateTests.swift +git commit -m "test: reject Swift test warnings" +``` + +### Task 5: Stage 2 verification checkpoint + +**Files:** +- Verify schemas, fixtures, docs, and bundles. + +- [ ] **Step 1: Run diff and JSON checks** + +Run: `git diff --check && plutil -lint Resources/Info.plist` + +- [ ] **Step 2: Run the fast trust gate** + +Run: `make verify` + +Expected: tests, warnings-as-errors build, bundle, plist, codesign, schema resources, and identifiers pass. + +- [ ] **Step 3: Inspect CLI compatibility** + +Run: `stage2_tmp="$(mktemp -d)"; trap 'rm -rf "$stage2_tmp"' EXIT; .build/Vifty.app/Contents/MacOS/viftyctl --help && .build/Vifty.app/Contents/MacOS/viftyctl diagnose --json >"$stage2_tmp/diagnose.json"; status=$?; /usr/bin/python3 -m json.tool "$stage2_tmp/diagnose.json" >/dev/null; test "$status" -eq 0 -o "$status" -eq 75` + +Expected: help exits 0; diagnose is parseable and either ready or safely blocked. Do not run recovery commands. + +- [ ] **Step 4: Review Stage 2 before UI work** + +Review the Stage 2 commit range and confirm stable existing JSON keys and exit codes. Record any schema addition explicitly; do not begin Stage 3 with a failing gate. diff --git a/docs/superpowers/plans/2026-09-06-vifty-stage-3-ui-evidence-polish.md b/docs/superpowers/plans/2026-09-06-vifty-stage-3-ui-evidence-polish.md new file mode 100644 index 00000000..74b4f887 --- /dev/null +++ b/docs/superpowers/plans/2026-09-06-vifty-stage-3-ui-evidence-polish.md @@ -0,0 +1,270 @@ +# Vifty Stage 3 UI Evidence and Polish Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Restore exact-source UI capture readiness, complete the declared evidence matrix, and apply only current-evidence-backed polish. + +**Architecture:** Fix the existing SwiftUI/AppKit observation bridge at its root, retain the current 50-row provenance-bound harness, and keep visual changes downstream of accepted captures. Use native SwiftUI and existing tests; add no snapshot framework. + +**Tech Stack:** SwiftUI, AppKit, XCTest, Ruby orchestration, macOS Accessibility APIs, existing UI evidence schemas and Make targets. + +**Spec:** `docs/superpowers/specs/2026-09-06-vifty-audit-remediation-design.md` + +## Global Constraints + +- Stages 1 and 2 must be approved and green. +- Standard captures require at least 30 GiB free and a clean exact Git tree. +- Preserve `modelStartSkipped=true`, inert dependencies, and zero hardware/helper mutations. +- Historical checkpoint `6ac429cbacf7cc3358c74493ab7461a43fa40275` is not current evidence. +- Human visual and VoiceOver claims require actual current observations; automated AX is not VoiceOver evidence. + +--- + +### Task 1: Make the observation bridge reliably schedule readiness + +**Files:** +- Modify: `Sources/Vifty/ViftyReviewFixture.swift` +- Test: `Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift` +- Test: `Tests/ViftyCoreTests/UIReviewEvidenceScriptTests.swift` + +**Interfaces:** +- Produces: observation scheduling from both `makeNSView` and later updates, still requiring two stable samples. + +- [ ] **Step 1: Add a hosted-window regression** + +Create an `NSWindow` with an `NSHostingView` containing `ViftyReviewFixtureSceneHost`, order it front, and wait for `runtime.hasReadyObservation`. Do not call `recordObservation` directly. Assert the ready report appears before the test deadline and records no mutations. + +- [ ] **Step 2: Run the regression against current source** + +Run: `swift test --scratch-path "$PWD/.build" --filter ViftyReviewFixtureTests/testHostedSceneSchedulesObservationAfterPreparation` + +Expected: timeout because a newly created observation representable is not guaranteed an update callback after insertion. + +If this test reaches ready on unchanged source, do not apply Step 3. Preserve that evidence, rerun the exact product capture once in the same interactive WindowServer session, and compare lifecycle timing. A non-reproducing unit/hosted test means the current timeout is environmental or occurs outside this bridge; revise this task from observed evidence before editing production fixture code. + +- [ ] **Step 3: Schedule from creation as well as update** + +```swift +func makeNSView(context: Context) -> ViftyReviewFixtureWindowObserverView { + let view = ViftyReviewFixtureWindowObserverView(frame: .zero) + configure(view) + view.scheduleObservationPair() + return view +} +``` + +Keep `viewDidMoveToWindow`, `layout`, the update call, and `observationPairScheduled`; nil-window emissions remain harmless and later lifecycle callbacks reschedule. + +- [ ] **Step 4: Run Swift and orchestrator regression tests** + +Run: `swift test --scratch-path "$PWD/.build" --filter 'ViftyReviewFixtureTests|UIReviewEvidenceScriptTests'` + +Expected: PASS, including structured timeout behavior for intentionally non-ready fixtures. + +- [ ] **Step 5: Commit** + +```bash +git add Sources/Vifty/ViftyReviewFixture.swift Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift Tests/ViftyCoreTests/UIReviewEvidenceScriptTests.swift +git commit -m "fix: schedule UI fixture observation on creation" +``` + +### Task 2: Prove one real exact-source capture before matrix work + +**Files:** +- Generated ignored evidence only under `.build/ui-review-evidence/`. +- Do not modify the committed manifest in this task. + +- [ ] **Step 1: Verify disk, clean tree, and host settings** + +Run: `df -h /System/Volumes/Data && test -z "$(git status --porcelain --untracked-files=all)"` + +Expected: at least 30 GiB free and clean tree. Standard rows require Increase Contrast and Reduce Transparency off; inspect them manually/read-only per `docs/ui-review/README.md`. + +- [ ] **Step 2: Build exact products and initialize the local ledger** + +Run: `make ui-review-start-session` + +Expected: one provenance-bound debug app, release exclusion binary, AX collector, and ignored local ledger for current `HEAD`. + +- [ ] **Step 3: Capture the previously failing row** + +Run the documented `--capture --row-kind visual --row-id main-1180x820-light` command with five-second readiness and 120-second hold, then seal its returned capture ID. + +Expected: capture and seal exit 0; final fixture report has `phase: final`, `passed: true`, `modelStartSkipped: true`, and empty mutation arrays. + +- [ ] **Step 4: Inspect the immutable PNG** + +Open the sealed screenshot, confirm it is the requested Vifty window rather than transparent/solid/launcher content, and record any visual defect separately. Do not patch UI in this task. + +- [ ] **Step 5: Commit only a checkpoint note if source documentation requires it** + +Normally make no commit: ignored evidence is the deliverable. If a source change was required after Task 1, return to Task 1 and repeat its red/green cycle instead of committing an unreviewed capture workaround. + +### Task 3: Recapture and verify the automated 50-row matrix + +**Files:** +- Generated: ignored `.build/ui-review-evidence/**` +- Generated: ignored `docs/ui-review/evidence-manifest.local.json` +- Modify after automated pass only: `docs/ui-review/automated-checkpoint.json` +- Modify after automated pass only: `docs/images/vifty-screenshot.png` + +**Interfaces:** +- Consumes: nine fixture, 28 visual, and 13 AX requests from `scripts/lib/ui_review_contract.rb`. +- Produces: exact-current-source automated checkpoint and canonical hero. + +- [ ] **Step 1: Capture the nine fixture rows** + +Use the documented capture and seal commands for every exact state emitted by: + +```bash +jq -r '.fixtureReports[].state' docs/ui-review/evidence-manifest.json +``` + +For each emitted value, pass it unchanged to `--row-id`, extract `captureID` from the returned JSON with `/usr/bin/ruby -rjson`, and pass that exact ID to `--seal`. Stop on the first nonzero capture or seal result. + +- [ ] **Step 2: Capture the standard visual rows** + +Capture and seal every standard light/dark, size, state, Settings, popover, and accessibility-text row listed by `jq -r '.visualCells[].id'`. Keep the two system-setting rows pending until their settings are explicitly arranged. + +- [ ] **Step 3: Capture and collect automated AX rows** + +For each `jq -r '.accessibilityChecks[].id'` row, launch with a 300-second hold, run `--collect-ax` with the exact collector, and seal. Do not activate inspect-only controls. + +- [ ] **Step 4: Capture the two explicit system-setting rows** + +With owner-controlled settings, capture Reduce Transparency under standard contrast, then Increase Contrast with macOS-implied reduced transparency. Restore the owner's preferred settings afterward and record only observed readback. + +- [ ] **Step 5: Verify automated evidence** + +Run: `make ui-review-verify-automated` + +Expected: 9/9 fixture, 28/28 visual, and 13/13 AX rows pass with zero mutation aggregates. + +- [ ] **Step 6: Publish the portable checkpoint** + +Run: `UI_REVIEW_SOURCE_COMMIT="$(git rev-parse HEAD)" make ui-review-write-checkpoint` + +Expected: path-free checkpoint bound to current source/products and canonical hero. + +- [ ] **Step 7: Commit checkpoint artifacts** + +```bash +git add docs/ui-review/automated-checkpoint.json docs/images/vifty-screenshot.png +git commit -m "docs: refresh current Vifty UI evidence checkpoint" +``` + +### Task 4: Conduct human review and create file-specific fix plans + +**Files:** +- Update: `/Users/reidar/Obsidian/Hermes/Hermes/Personal/Projects/Vifty/Vifty.md` +- Create when findings exist: one dated design/implementation-plan pair per coherent validated UI problem. +- Generated: visual and VoiceOver attestations when actually completed. + +**Interfaces:** +- Produces: a ranked finding ledger containing row ID, capture ID, observed defect, expected behavior, owning file, and acceptance check. +- Produces: concrete file-specific plans before any UI production edit. + +- [ ] **Step 1: Review every sealed visual row** + +Check clipping, overlap, truncation, contrast, hierarchy, spacing, state truth, and compact-scroll reachability. Record “no issue” or one concrete finding per row; do not infer defects from source alone. + +- [ ] **Step 2: Perform the VoiceOver session if the owner authorizes it** + +Use the exact seven scripted steps and row subsets in `docs/ui-review/README.md`. If not authorized, preserve `skipped-by-owner` and make no VoiceOver claim. + +- [ ] **Step 3: Write the durable current-review ledger** + +In the Vifty Obsidian project note, record all 28 visual rows and 13 AX rows with exact row ID, capture ID, disposition (`no-issue` or `validated-finding`), observation, and evidence hash. For every validated finding also record severity, owning source path, focused test path, and affected recapture row IDs. Do not write production code or tracked repository documentation in this step, because either would invalidate the exact-source capture set. + +- [ ] **Step 4: Verify the review did not invalidate source provenance** + +```bash +test -z "$(git status --porcelain --untracked-files=all)" +make ui-review-verify-automated +``` + +- [ ] **Step 5: Create concrete follow-on plans for validated findings** + +If the ledger contains no validated finding, record that Stage 3 needs no UI production edit. Otherwise, group only findings that share one owning presentation/layout path, run the brainstorming approval gate, and create dated file-specific plans under `docs/superpowers/plans/`. Each follow-on plan names exact Swift files, exact focused tests, exact failing assertion, exact affected capture rows, and its commit message before implementation begins. + +- [ ] **Step 6: Execute approved follow-on plans and recapture affected rows** + +Each approved fix must pass its red/green test and replace every stale affected capture. Re-run `make ui-review-verify-automated`; update human visual bindings only after inspecting the new immutable PNG. Do not proceed on an unapproved or non-file-specific fix plan. + +### Task 5: Reduce harness duplication only after stability + +**Files:** +- Modify if duplication is proven: `Tests/ViftyCoreTests/UIReviewEvidenceScriptTests.swift` +- Modify if duplication is proven: `scripts/lib/ui_review_contract.rb` +- Do not modify: verifier safety, provenance, sealing, schemas, or path-containment code. + +- [ ] **Step 1: Count repeated request/expectation blocks** + +Run: `rg -n 'main-1180x820|settings-general|accessibility-text' Tests/ViftyCoreTests/UIReviewEvidenceScriptTests.swift scripts/lib/ui_review_contract.rb` + +Identify only byte-structurally repeated cases already represented by the canonical request table. + +- [ ] **Step 2: Add one parameterized test loop alongside existing cases** + +Keep the old cases temporarily, run the new loop, and prove identical row IDs and expected request dictionaries. + +- [ ] **Step 3: Delete only superseded duplicated cases** + +Run `git diff --stat` and require net line deletion. Keep explicit adversarial security/path/provenance tests separate. + +- [ ] **Step 4: Run all UI evidence suites** + +Run: `swift test --scratch-path "$PWD/.build" --filter UIReviewEvidenceScriptTests && make ui-review-ruby-tests` + +Expected: identical required matrix coverage and all tests pass. + +- [ ] **Step 5: Commit only if the result is smaller** + +```bash +git add Tests/ViftyCoreTests/UIReviewEvidenceScriptTests.swift scripts/lib/ui_review_contract.rb +git commit -m "test: deduplicate UI evidence matrix cases" +``` + +Skip this commit entirely if the change is not a net deletion or weakens explicit adversarial coverage. + +If this task creates a commit, its new source tree invalidates the existing products and capture ledger. Repeat Tasks 2 through 4 against the new exact `HEAD` before entering Task 6. If no net-deletion commit is justified, retain the already verified matrix and continue directly to Task 6. + +### Task 6: Final program verification and proof report + +**Files:** +- Modify: `docs/ui-review/README.md` only for commands or state that actually changed. +- Log: Obsidian Vifty project note and current daily note. + +- [ ] **Step 1: Run full repository verification** + +Run: `df -h /System/Volumes/Data && git diff --check && make verify-full` + +Expected: at least 30 GiB free and every Swift/Ruby/build/bundle/schema/plist/codesign gate passes. + +- [ ] **Step 2: Run current automated UI verification** + +Run: `make ui-review-verify-automated` + +Expected: complete automated matrix pass for exact current products. + +- [ ] **Step 3: Run full matrix verification only when both human attestations exist** + +Run: `make ui-review-verify` + +Expected: pass only if visual and VoiceOver attestations are genuinely complete. Otherwise report the exact pending human gate and do not relabel it as failure or success. + +- [ ] **Step 4: Record a read-only runtime diagnostic** + +Run: `.build/Vifty.app/Contents/MacOS/viftyctl diagnose --json` + +Accept exit 0 or safely blocked exit 75. Do not follow repair or cooling recommendations automatically. + +- [ ] **Step 5: Check owned temporary leftovers** + +Run: `du -sh /private/tmp/[Vv]ifty* 2>/dev/null || true` + +Remove only stale Vifty-owned temporary directories after confirming no active `lsof` handles. + +- [ ] **Step 6: Write the evidence-backed closeout** + +Report exact test counts, commit range, automated matrix counts, human-review status, runtime status, and explicit non-claims for hardware compatibility, helper replacement, notarization, and release publication. From b1f92a3e43926705db0e427ecdc48cc306ef9176 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 16:27:48 +0200 Subject: [PATCH 04/27] feat: expose agent persistence health --- Sources/ViftyCore/AgentControlModels.swift | 62 ++++++++++++++++++- Sources/ViftyCore/ViftyCtlRunner.swift | 21 ++++++- Sources/ViftyCore/ViftyDaemonProtocol.swift | 35 ++++++++++- .../ViftyCtlJSONExampleTests.swift | 5 +- .../ViftyCoreTests/ViftyCtlRunnerTests.swift | 4 +- .../XPCAgentControlCodingTests.swift | 13 +++- .../viftyctl/status-active-lease.json | 6 ++ .../viftyctl-command-error.schema.json | 3 +- docs/schemas/viftyctl-status.schema.json | 38 +++++++++++- 9 files changed, 175 insertions(+), 12 deletions(-) diff --git a/Sources/ViftyCore/AgentControlModels.swift b/Sources/ViftyCore/AgentControlModels.swift index 2422d1a3..9b607830 100644 --- a/Sources/ViftyCore/AgentControlModels.swift +++ b/Sources/ViftyCore/AgentControlModels.swift @@ -34,6 +34,7 @@ public enum AgentControlErrorCode: String, Codable, Equatable, Sendable { case childCommandFailed = "CHILD_COMMAND_FAILED" case prepareRateLimited = "PREPARE_RATE_LIMITED" case restoreRequested = "RESTORE_REQUESTED" + case persistenceFailure = "PERSISTENCE_FAILURE" } public struct AgentControlRequest: Codable, Equatable, Sendable { @@ -142,12 +143,54 @@ public struct AgentCoolingLease: Codable, Equatable, Sendable { } } +public struct AgentControlPersistenceHealth: Codable, Equatable, Sendable { + public var policyStatusAvailable: Bool + public var policyError: String? + public var auditStatusAvailable: Bool + public var auditError: String? + + private enum CodingKeys: String, CodingKey { + case policyStatusAvailable + case policyError + case auditStatusAvailable + case auditError + } + + public init( + policyStatusAvailable: Bool, + policyError: String?, + auditStatusAvailable: Bool, + auditError: String? + ) { + self.policyStatusAvailable = policyStatusAvailable + self.policyError = policyError + self.auditStatusAvailable = auditStatusAvailable + self.auditError = auditError + } + + public static let healthy = Self( + policyStatusAvailable: true, + policyError: nil, + auditStatusAvailable: true, + auditError: nil + ) + + public func encode(to encoder: any Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(policyStatusAvailable, forKey: .policyStatusAvailable) + try container.encode(policyError, forKey: .policyError) + try container.encode(auditStatusAvailable, forKey: .auditStatusAvailable) + try container.encode(auditError, forKey: .auditError) + } +} + public struct AgentControlStatus: Codable, Equatable, Sendable { public var enabled: Bool public var activeLease: AgentCoolingLease? public var lastDecision: AgentControlDecision? public var lastErrorCode: AgentControlErrorCode? public var policy: AgentControlPolicySnapshot? + public var persistenceHealth: AgentControlPersistenceHealth private enum CodingKeys: String, CodingKey { case enabled @@ -155,6 +198,7 @@ public struct AgentControlStatus: Codable, Equatable, Sendable { case lastDecision case lastErrorCode case policy + case persistenceHealth } // Emit nil optionals as explicit JSON nulls so strict schema consumers see @@ -166,6 +210,20 @@ public struct AgentControlStatus: Codable, Equatable, Sendable { try container.encode(lastDecision, forKey: .lastDecision) try container.encode(lastErrorCode, forKey: .lastErrorCode) try container.encode(policy, forKey: .policy) + try container.encode(persistenceHealth, forKey: .persistenceHealth) + } + + public init(from decoder: any Decoder) throws { + let container = try decoder.container(keyedBy: CodingKeys.self) + enabled = try container.decode(Bool.self, forKey: .enabled) + activeLease = try container.decodeIfPresent(AgentCoolingLease.self, forKey: .activeLease) + lastDecision = try container.decodeIfPresent(AgentControlDecision.self, forKey: .lastDecision) + lastErrorCode = try container.decodeIfPresent(AgentControlErrorCode.self, forKey: .lastErrorCode) + policy = try container.decodeIfPresent(AgentControlPolicySnapshot.self, forKey: .policy) + persistenceHealth = try container.decodeIfPresent( + AgentControlPersistenceHealth.self, + forKey: .persistenceHealth + ) ?? .healthy } public init( @@ -173,13 +231,15 @@ public struct AgentControlStatus: Codable, Equatable, Sendable { activeLease: AgentCoolingLease?, lastDecision: AgentControlDecision?, lastErrorCode: AgentControlErrorCode?, - policy: AgentControlPolicySnapshot? = nil + policy: AgentControlPolicySnapshot? = nil, + persistenceHealth: AgentControlPersistenceHealth = .healthy ) { self.enabled = enabled self.activeLease = activeLease self.lastDecision = lastDecision self.lastErrorCode = lastErrorCode self.policy = policy + self.persistenceHealth = persistenceHealth } } diff --git a/Sources/ViftyCore/ViftyCtlRunner.swift b/Sources/ViftyCore/ViftyCtlRunner.swift index 2500cda7..b5b74bbf 100644 --- a/Sources/ViftyCore/ViftyCtlRunner.swift +++ b/Sources/ViftyCore/ViftyCtlRunner.swift @@ -845,7 +845,8 @@ public enum ViftyCtlCommandErrorRecoveryAction: String, Codable, Equatable, Send .rpmOutOfRange, .thermalCritical, .leaseNotFound, - .restoreFailed: + .restoreFailed, + .persistenceFailure: return .runDiagnose } } @@ -1163,6 +1164,7 @@ public struct ViftyCtlStatusReport: Codable, Equatable, Sendable { public var lastDecision: AgentControlDecision? public var lastErrorCode: AgentControlErrorCode? public var policy: AgentControlPolicySnapshot? + public var persistenceHealth: AgentControlPersistenceHealth private enum CodingKeys: String, CodingKey { case schemaVersion @@ -1173,6 +1175,7 @@ public struct ViftyCtlStatusReport: Codable, Equatable, Sendable { case lastDecision case lastErrorCode case policy + case persistenceHealth } // Emit nil optionals as explicit JSON nulls so the status schema's required @@ -1187,6 +1190,7 @@ public struct ViftyCtlStatusReport: Codable, Equatable, Sendable { try container.encode(lastDecision, forKey: .lastDecision) try container.encode(lastErrorCode, forKey: .lastErrorCode) try container.encode(policy, forKey: .policy) + try container.encode(persistenceHealth, forKey: .persistenceHealth) } public init( @@ -1203,6 +1207,7 @@ public struct ViftyCtlStatusReport: Codable, Equatable, Sendable { self.lastDecision = status.lastDecision self.lastErrorCode = status.lastErrorCode self.policy = status.policy + self.persistenceHealth = status.persistenceHealth } } @@ -1752,10 +1757,20 @@ public struct ViftyCtlRunner: Sendable { private func capabilitiesReport() async -> ViftyCtlCapabilities { do { let status = try await client.status() - let policy = status.policy ?? AgentControlPolicy(enabled: false).snapshot + guard let policy = status.policy, + status.persistenceHealth.policyStatusAvailable else { + return ViftyCtlCapabilities( + policy: AgentControlPolicy(enabled: false).snapshot, + policySource: .fallbackUnavailable, + daemonStatusAvailable: true, + policyStatusAvailable: false, + agentControlStatusError: status.persistenceHealth.policyError + ?? "Agent-control policy persistence is unavailable." + ) + } return ViftyCtlCapabilities( policy: policy, - policyStatusAvailable: status.policy != nil + policyStatusAvailable: true ) } catch { return ViftyCtlCapabilities( diff --git a/Sources/ViftyCore/ViftyDaemonProtocol.swift b/Sources/ViftyCore/ViftyDaemonProtocol.swift index 959ec921..592d1c6c 100644 --- a/Sources/ViftyCore/ViftyDaemonProtocol.swift +++ b/Sources/ViftyCore/ViftyDaemonProtocol.swift @@ -420,6 +420,8 @@ public enum XPCSnapshotCoding { } public enum XPCAgentControlCoding { + private static let missingPersistenceHealthMessage = "Persistence health unavailable from older daemon response." + public static func encode(_ request: AgentControlRequest) -> NSDictionary { [ "workload": request.workload.rawValue, @@ -465,6 +467,12 @@ public enum XPCAgentControlCoding { if let policy = status.policy { encoded["policy"] = encodePolicy(policy) } + encoded["persistenceHealth"] = [ + "policyStatusAvailable": status.persistenceHealth.policyStatusAvailable, + "policyError": status.persistenceHealth.policyError.map { $0 as Any } ?? NSNull(), + "auditStatusAvailable": status.persistenceHealth.auditStatusAvailable, + "auditError": status.persistenceHealth.auditError.map { $0 as Any } ?? NSNull() + ] return encoded as NSDictionary } @@ -509,12 +517,37 @@ public enum XPCAgentControlCoding { policy = decodedPolicy } + let persistenceHealth: AgentControlPersistenceHealth + if let value = dictionary["persistenceHealth"] { + guard let healthDictionary = value as? NSDictionary, + let policyStatusAvailable = boolValue(healthDictionary["policyStatusAvailable"]), + let auditStatusAvailable = boolValue(healthDictionary["auditStatusAvailable"]), + (healthDictionary["policyError"] == nil || healthDictionary["policyError"] is String || healthDictionary["policyError"] is NSNull), + (healthDictionary["auditError"] == nil || healthDictionary["auditError"] is String || healthDictionary["auditError"] is NSNull) else { + return nil + } + persistenceHealth = AgentControlPersistenceHealth( + policyStatusAvailable: policyStatusAvailable, + policyError: healthDictionary["policyError"] as? String, + auditStatusAvailable: auditStatusAvailable, + auditError: healthDictionary["auditError"] as? String + ) + } else { + persistenceHealth = AgentControlPersistenceHealth( + policyStatusAvailable: false, + policyError: Self.missingPersistenceHealthMessage, + auditStatusAvailable: false, + auditError: Self.missingPersistenceHealthMessage + ) + } + return AgentControlStatus( enabled: enabled, activeLease: activeLease, lastDecision: lastDecision, lastErrorCode: lastErrorCode, - policy: policy + policy: policy, + persistenceHealth: persistenceHealth ) } diff --git a/Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift b/Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift index 5b77b525..56ebcc46 100644 --- a/Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift @@ -384,6 +384,7 @@ final class ViftyCtlJSONExampleTests: XCTestCase { XCTAssertEqual(status.lastDecision?.allowed, true) XCTAssertEqual(status.lastDecision?.targetRPMByFanID[1], 3700) XCTAssertNil(status.lastErrorCode) + XCTAssertEqual(status.persistenceHealth, .healthy) } func testCommandErrorExampleDecodesAgainstCurrentModel() throws { @@ -974,6 +975,7 @@ final class ViftyCtlJSONExampleTests: XCTestCase { try assertRequiredFields(definition: "request", in: statusDefinitions, arePresentIn: activeLease["request"] as? [String: Any], context: "lease request") try assertRequiredFields(definition: "decision", in: statusDefinitions, arePresentIn: statusExample["lastDecision"] as? [String: Any], context: "last decision") try assertRequiredFields(definition: "policy", in: statusDefinitions, arePresentIn: statusExample["policy"] as? [String: Any], context: "status policy") + try assertRequiredFields(definition: "persistenceHealth", in: statusDefinitions, arePresentIn: statusExample["persistenceHealth"] as? [String: Any], context: "status persistence health") let commandErrorSchema = try readJSON(schemaURL("viftyctl-command-error.schema.json")) let commandErrorProperties = try XCTUnwrap(commandErrorSchema["properties"] as? [String: Any]) @@ -1157,7 +1159,8 @@ final class ViftyCtlJSONExampleTests: XCTestCase { "INVALID_ARGUMENTS", "CHILD_COMMAND_FAILED", "PREPARE_RATE_LIMITED", - "RESTORE_REQUESTED" + "RESTORE_REQUESTED", + "PERSISTENCE_FAILURE" ] } diff --git a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift index 892cb671..59401178 100644 --- a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift @@ -389,8 +389,8 @@ final class ViftyCtlRunnerTests: XCTestCase { let json = try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any]) XCTAssertEqual(json["daemonStatusAvailable"] as? Bool, true) XCTAssertEqual(json["policyStatusAvailable"] as? Bool, false) - XCTAssertEqual(json["policySource"] as? String, ViftyCtlPolicySource.daemonStatus.rawValue) - XCTAssertNil(json["agentControlStatusError"] as? String) + XCTAssertEqual(json["policySource"] as? String, ViftyCtlPolicySource.fallbackUnavailable.rawValue) + XCTAssertEqual(json["agentControlStatusError"] as? String, "Agent-control policy persistence is unavailable.") let policy = try XCTUnwrap(json["policy"] as? [String: Any]) XCTAssertEqual(policy["enabled"] as? Bool, false) XCTAssertEqual(policy["maxDurationSeconds"] as? Int, 1_800) diff --git a/Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift b/Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift index 084b655e..20fc761a 100644 --- a/Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift +++ b/Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift @@ -13,6 +13,12 @@ final class XPCAgentControlCodingTests: XCTestCase { func testStatusRoundTripsThroughNSDictionary() { let created = Date(timeIntervalSince1970: 1_000) + let health = AgentControlPersistenceHealth( + policyStatusAvailable: false, + policyError: "policy unreadable", + auditStatusAvailable: true, + auditError: nil + ) let status = AgentControlStatus( enabled: true, activeLease: AgentCoolingLease( @@ -24,7 +30,8 @@ final class XPCAgentControlCodingTests: XCTestCase { ), lastDecision: .denied(.prepareRateLimited, message: "Wait", retryAfterSeconds: 12), lastErrorCode: .prepareRateLimited, - policy: AgentControlPolicy(enabled: true, minimumAgentRPMPercent: 40, maximumAllowedRPMPercent: 75, maxDurationSeconds: 1_800, prepareCooldownSeconds: 12).snapshot + policy: AgentControlPolicy(enabled: true, minimumAgentRPMPercent: 40, maximumAllowedRPMPercent: 75, maxDurationSeconds: 1_800, prepareCooldownSeconds: 12).snapshot, + persistenceHealth: health ) let encoded = XPCAgentControlCoding.encode(status) @@ -44,6 +51,10 @@ final class XPCAgentControlCodingTests: XCTestCase { XCTAssertNil(decoded?.activeLease) XCTAssertNil(decoded?.lastDecision) XCTAssertNil(decoded?.policy) + XCTAssertEqual(decoded?.persistenceHealth.policyStatusAvailable, false) + XCTAssertEqual(decoded?.persistenceHealth.auditStatusAvailable, false) + XCTAssertEqual(decoded?.persistenceHealth.policyError, "Persistence health unavailable from older daemon response.") + XCTAssertEqual(decoded?.persistenceHealth.auditError, "Persistence health unavailable from older daemon response.") } func testAuditEventsRoundTripThroughNSDictionary() { diff --git a/docs/examples/viftyctl/status-active-lease.json b/docs/examples/viftyctl/status-active-lease.json index dd613909..3e5c55cd 100644 --- a/docs/examples/viftyctl/status-active-lease.json +++ b/docs/examples/viftyctl/status-active-lease.json @@ -38,6 +38,12 @@ "minimumAgentRPMPercent": 45, "prepareCooldownSeconds": 30 }, + "persistenceHealth": { + "auditError": null, + "auditStatusAvailable": true, + "policyError": null, + "policyStatusAvailable": true + }, "generatedAt": 700000900, "schemaID": "https://vifty.local/schemas/viftyctl-status.schema.json", "schemaVersion": 1 diff --git a/docs/schemas/viftyctl-command-error.schema.json b/docs/schemas/viftyctl-command-error.schema.json index b1f5edbf..1adba460 100644 --- a/docs/schemas/viftyctl-command-error.schema.json +++ b/docs/schemas/viftyctl-command-error.schema.json @@ -46,7 +46,8 @@ "INVALID_ARGUMENTS", "CHILD_COMMAND_FAILED", "PREPARE_RATE_LIMITED", - "RESTORE_REQUESTED" + "RESTORE_REQUESTED", + "PERSISTENCE_FAILURE" ] }, { diff --git a/docs/schemas/viftyctl-status.schema.json b/docs/schemas/viftyctl-status.schema.json index ff6a98db..b65eccb1 100644 --- a/docs/schemas/viftyctl-status.schema.json +++ b/docs/schemas/viftyctl-status.schema.json @@ -12,7 +12,8 @@ "activeLease", "lastDecision", "lastErrorCode", - "policy" + "policy", + "persistenceHealth" ], "properties": { "schemaVersion": { @@ -66,6 +67,9 @@ "type": "null" } ] + }, + "persistenceHealth": { + "$ref": "#/$defs/persistenceHealth" } }, "$defs": { @@ -94,7 +98,8 @@ "INVALID_ARGUMENTS", "CHILD_COMMAND_FAILED", "PREPARE_RATE_LIMITED", - "RESTORE_REQUESTED" + "RESTORE_REQUESTED", + "PERSISTENCE_FAILURE" ] }, "request": { @@ -241,6 +246,35 @@ } } }, + "persistenceHealth": { + "type": "object", + "required": [ + "policyStatusAvailable", + "policyError", + "auditStatusAvailable", + "auditError" + ], + "properties": { + "policyStatusAvailable": { + "type": "boolean" + }, + "policyError": { + "type": [ + "string", + "null" + ] + }, + "auditStatusAvailable": { + "type": "boolean" + }, + "auditError": { + "type": [ + "string", + "null" + ] + } + } + }, "fanRPMMap": { "type": "object", "additionalProperties": { From eae9e282df039a42bed6123e089351b3e7c1db82 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 16:34:41 +0200 Subject: [PATCH 05/27] fix: bound policy persistence messages --- Sources/ViftyCore/ViftyCtlRunner.swift | 16 +++++++-- .../ViftyCoreTests/ViftyCtlRunnerTests.swift | 36 +++++++++++++++++++ 2 files changed, 50 insertions(+), 2 deletions(-) diff --git a/Sources/ViftyCore/ViftyCtlRunner.swift b/Sources/ViftyCore/ViftyCtlRunner.swift index b5b74bbf..9c216a4e 100644 --- a/Sources/ViftyCore/ViftyCtlRunner.swift +++ b/Sources/ViftyCore/ViftyCtlRunner.swift @@ -1349,6 +1349,8 @@ public struct ViftyCtlDaemonClient: ViftyCtlAgentControlClient { } public struct ViftyCtlRunner: Sendable { + private static let policyPersistenceFallbackMessage = "Agent-control policy persistence is unavailable." + private let client: any ViftyCtlAgentControlClient private let processRunner: any ViftyCtlProcessRunning private let thermalReader: @Sendable () -> ThermalPressure @@ -1764,8 +1766,7 @@ public struct ViftyCtlRunner: Sendable { policySource: .fallbackUnavailable, daemonStatusAvailable: true, policyStatusAvailable: false, - agentControlStatusError: status.persistenceHealth.policyError - ?? "Agent-control policy persistence is unavailable." + agentControlStatusError: Self.boundedPolicyPersistenceMessage(status.persistenceHealth.policyError) ) } return ViftyCtlCapabilities( @@ -1783,6 +1784,17 @@ public struct ViftyCtlRunner: Sendable { } } + private static func boundedPolicyPersistenceMessage(_ message: String?) -> String { + guard let message else { + return policyPersistenceFallbackMessage + } + let trimmed = message.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { + return policyPersistenceFallbackMessage + } + return String(trimmed.prefix(AgentControlRequest.maximumReasonLength)) + } + private func diagnoseReport() async -> ViftyCtlReadinessReport { let generatedAt = now() async let snapshotProbe = capture { try await client.snapshot() } diff --git a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift index 59401178..5e2e4a53 100644 --- a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift @@ -396,6 +396,42 @@ final class ViftyCtlRunnerTests: XCTestCase { XCTAssertEqual(policy["maxDurationSeconds"] as? Int, 1_800) } + func testCapabilitiesJSONBoundsPolicyPersistenceMessage() async throws { + let messages = [ + "", + String(repeating: "x", count: AgentControlRequest.maximumReasonLength + 1) + ] + + for originalMessage in messages { + let runner = ViftyCtlRunner( + client: FakeAgentControlClient(status: AgentControlStatus( + enabled: true, + activeLease: nil, + lastDecision: nil, + lastErrorCode: nil, + policy: AgentControlPolicy(enabled: true).snapshot, + persistenceHealth: AgentControlPersistenceHealth( + policyStatusAvailable: false, + policyError: originalMessage, + auditStatusAvailable: true, + auditError: nil + ) + )), + processRunner: FakeProcessRunner() + ) + + let result = try await runner.run(.capabilities(json: true)) + let data = try XCTUnwrap(result.stdout.data(using: .utf8)) + let json = try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any]) + let message = try XCTUnwrap(json["agentControlStatusError"] as? String) + let expected = originalMessage.isEmpty + ? "Agent-control policy persistence is unavailable." + : String(originalMessage.prefix(AgentControlRequest.maximumReasonLength)) + XCTAssertEqual(message, expected) + XCTAssertLessThanOrEqual(message.count, AgentControlRequest.maximumReasonLength) + } + } + func testCapabilitiesJSONReturnsStaticContractWhenDaemonStatusUnavailable() async throws { let runner = ViftyCtlRunner( client: FakeAgentControlClient( From 519483906e8cd15e4defcd2c2c82b42d633e8e06 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 16:43:07 +0200 Subject: [PATCH 06/27] fix: fail closed on agent policy persistence errors --- Sources/ViftyCore/AgentControlService.swift | 65 ++++++- .../AgentControlServiceTests.swift | 167 ++++++++++++++++++ 2 files changed, 228 insertions(+), 4 deletions(-) diff --git a/Sources/ViftyCore/AgentControlService.swift b/Sources/ViftyCore/AgentControlService.swift index 75f31f3e..889e42c4 100644 --- a/Sources/ViftyCore/AgentControlService.swift +++ b/Sources/ViftyCore/AgentControlService.swift @@ -51,6 +51,7 @@ public actor AgentControlService { private var activeLease: AgentCoolingLease? private var persistenceLoadErrorMessage: String? + private var persistenceHealth = AgentControlPersistenceHealth.healthy private var lastDecision: AgentControlDecision? private var lastErrorCode: AgentControlErrorCode? private var operationInProgress = false @@ -86,8 +87,18 @@ public actor AgentControlService { self.activeLease = nil self.persistenceLoadErrorMessage = error.localizedDescription } - if let storedEnabled = try? store.loadAgentControlEnabled() { - self.policy.enabled = storedEnabled + do { + if let storedEnabled = try store.loadAgentControlEnabled() { + self.policy.enabled = storedEnabled + } + } catch { + self.policy.enabled = false + self.persistenceHealth = AgentControlPersistenceHealth( + policyStatusAvailable: false, + policyError: Self.boundedPolicyPersistenceMessage(error), + auditStatusAvailable: true, + auditError: nil + ) } self.scheduledExpiry = nil if automaticallySchedulePersistedLeaseMonitor, let activeLease { @@ -104,7 +115,8 @@ public actor AgentControlService { activeLease: lease, lastDecision: lastDecision, lastErrorCode: lastErrorCode, - policy: policy.snapshot + policy: policy.snapshot, + persistenceHealth: persistenceHealth ) } @@ -116,8 +128,35 @@ public actor AgentControlService { if !enabled, activeLease != nil { _ = try await restoreAuto(reason: "Agent control disabled by user") } + let previousEnabled = policy.enabled + do { + try store.saveAgentControlEnabled(enabled) + } catch { + policy.enabled = previousEnabled + persistenceHealth = AgentControlPersistenceHealth( + policyStatusAvailable: false, + policyError: Self.boundedPolicyPersistenceMessage(error), + auditStatusAvailable: persistenceHealth.auditStatusAvailable, + auditError: persistenceHealth.auditError + ) + let decision = AgentControlDecision.denied( + .persistenceFailure, + message: persistenceHealth.policyError ?? "Agent-control policy persistence is unavailable." + ) + lastDecision = decision + lastErrorCode = decision.errorCode + appendAudit(action: "policy-persistence-failed", leaseID: nil, message: decision.message) + throw error + } policy.enabled = enabled - try store.saveAgentControlEnabled(enabled) + persistenceHealth = AgentControlPersistenceHealth( + policyStatusAvailable: true, + policyError: nil, + auditStatusAvailable: persistenceHealth.auditStatusAvailable, + auditError: persistenceHealth.auditError + ) + lastDecision = nil + lastErrorCode = nil return status() } @@ -187,6 +226,16 @@ public actor AgentControlService { "Agent-control ownership state is unreadable; startup Auto recovery is required before prepare: \(persistenceLoadErrorMessage)" ) } + guard persistenceHealth.policyStatusAvailable else { + let decision = AgentControlDecision.denied( + .persistenceFailure, + message: persistenceHealth.policyError ?? "Agent-control policy persistence is unavailable." + ) + lastDecision = decision + lastErrorCode = decision.errorCode + appendAudit(action: "prepare-denied", leaseID: nil, message: decision.message) + return status() + } let prepareRestoreGeneration = restoreRequestGeneration guard let request = request.normalizedMetadata else { let decision = AgentControlDecision.denied( @@ -642,6 +691,14 @@ public actor AgentControlService { let normalized = trimmed.isEmpty ? fallback : trimmed return String(normalized.prefix(AgentControlRequest.maximumReasonLength)) } + + private static func boundedPolicyPersistenceMessage(_ error: any Error) -> String { + let trimmed = error.localizedDescription.trimmingCharacters(in: .whitespacesAndNewlines) + guard !trimmed.isEmpty else { + return "Agent-control policy persistence is unavailable." + } + return String(trimmed.prefix(AgentControlRequest.maximumReasonLength)) + } } private final class AgentControlSendableFlag: @unchecked Sendable { diff --git a/Tests/ViftyCoreTests/AgentControlServiceTests.swift b/Tests/ViftyCoreTests/AgentControlServiceTests.swift index 2aa4af3f..403ecd78 100644 --- a/Tests/ViftyCoreTests/AgentControlServiceTests.swift +++ b/Tests/ViftyCoreTests/AgentControlServiceTests.swift @@ -161,6 +161,144 @@ final class AgentControlServiceTests: XCTestCase { XCTAssertEqual(status.policy?.enabled, false) } + func testServiceLoadsPersistedPolicyEnabledTrueAtInit() async throws { + let store = AgentControlFaultStore(directory: temporaryDirectory()) + store.loadedPolicy = .success(true) + let hardware = AgentServiceFakeHardware(snapshot: Self.snapshot(fans: [Self.fan(id: 0, minimumRPM: 1500, maximumRPM: 4500)])) + let service = AgentControlService( + hardware: hardware, + policy: AgentControlPolicy(enabled: false), + store: store, + thermalReader: { .nominal } + ) + + let status = await service.status() + + XCTAssertTrue(status.enabled) + XCTAssertEqual(status.policy?.enabled, true) + XCTAssertTrue(status.persistenceHealth.policyStatusAvailable) + } + + func testServiceKeepsPolicyDefaultWhenPersistedPolicyIsAbsent() async throws { + let store = AgentControlFaultStore(directory: temporaryDirectory()) + let hardware = AgentServiceFakeHardware(snapshot: Self.snapshot(fans: [Self.fan(id: 0, minimumRPM: 1500, maximumRPM: 4500)])) + let service = AgentControlService( + hardware: hardware, + policy: AgentControlPolicy(enabled: false), + store: store, + thermalReader: { .nominal } + ) + + let status = await service.status() + + XCTAssertFalse(status.enabled) + XCTAssertEqual(status.policy?.enabled, false) + XCTAssertTrue(status.persistenceHealth.policyStatusAvailable) + } + + func testPolicyLoadFailureFailsClosedAndDeniesPrepareBeforeHardwareApply() async throws { + let store = AgentControlFaultStore(directory: temporaryDirectory()) + store.loadedPolicy = .failure(.loadPolicy) + let hardware = AgentServiceFakeHardware(snapshot: Self.snapshot(fans: [Self.fan(id: 0, minimumRPM: 1500, maximumRPM: 4500)])) + let service = AgentControlService( + hardware: hardware, + policy: AgentControlPolicy(enabled: true), + store: store, + thermalReader: { .nominal } + ) + + let initial = await service.status() + let denied = try await service.prepare(AgentControlRequest( + workload: .build, + durationSeconds: 600, + maxRPMPercent: 75, + reason: "Build", + idempotencyKey: "load-failure" + )) + + XCTAssertFalse(initial.enabled) + XCTAssertFalse(initial.persistenceHealth.policyStatusAvailable) + XCTAssertEqual(denied.lastErrorCode, .persistenceFailure) + XCTAssertEqual(denied.lastDecision?.errorCode, .persistenceFailure) + let snapshotCallCount = await hardware.snapshotCallCount + let appliedCommands = await hardware.appliedCommands + XCTAssertEqual(snapshotCallCount, 0) + XCTAssertEqual(appliedCommands, []) + } + + func testFailedEnableSaveKeepsPolicyDisabledAndPublishesPersistenceFailure() async throws { + let store = AgentControlFaultStore(directory: temporaryDirectory()) + store.loadedPolicy = .success(false) + store.savePolicyError = .savePolicy + let hardware = AgentServiceFakeHardware(snapshot: Self.snapshot(fans: [Self.fan(id: 0, minimumRPM: 1500, maximumRPM: 4500)])) + let service = AgentControlService( + hardware: hardware, + policy: AgentControlPolicy(enabled: true), + store: store, + thermalReader: { .nominal } + ) + + do { + _ = try await service.setPolicyEnabled(true) + XCTFail("Expected policy enable persistence to fail") + } catch { + XCTAssertTrue(error is AgentControlFault) + } + + let status = await service.status() + XCTAssertFalse(status.enabled) + XCTAssertEqual(status.policy?.enabled, false) + XCTAssertFalse(status.persistenceHealth.policyStatusAvailable) + XCTAssertEqual(status.lastErrorCode, .persistenceFailure) + XCTAssertEqual(store.savedPolicies, []) + } + + func testFailedDisableSaveRestoresActiveLeaseAndSuccessfulRetryPublishesToggle() async throws { + let store = AgentControlFaultStore(directory: temporaryDirectory()) + store.loadedPolicy = .success(true) + let hardware = AgentServiceFakeHardware(snapshot: Self.snapshot(fans: [Self.fan(id: 0, minimumRPM: 1500, maximumRPM: 4500)])) + let service = AgentControlService( + hardware: hardware, + policy: AgentControlPolicy(enabled: false), + store: store, + thermalReader: { .nominal }, + now: { Date(timeIntervalSince1970: 1_000) }, + leaseID: { "lease-1" } + ) + _ = try await service.prepare(AgentControlRequest( + workload: .build, + durationSeconds: 600, + maxRPMPercent: 75, + reason: "Build", + idempotencyKey: "disable-failure" + )) + store.savePolicyError = .savePolicy + + do { + _ = try await service.setPolicyEnabled(false) + XCTFail("Expected policy disable persistence to fail") + } catch { + XCTAssertTrue(error is AgentControlFault) + } + + let failed = await service.status() + XCTAssertTrue(failed.enabled) + XCTAssertEqual(failed.policy?.enabled, true) + XCTAssertNil(failed.activeLease) + XCTAssertFalse(failed.persistenceHealth.policyStatusAvailable) + XCTAssertEqual(failed.lastErrorCode, .persistenceFailure) + let restoredFanIDs = await hardware.restoredFanIDs + XCTAssertEqual(restoredFanIDs, [0]) + + store.savePolicyError = nil + let retried = try await service.setPolicyEnabled(false) + XCTAssertFalse(retried.enabled) + XCTAssertEqual(retried.policy?.enabled, false) + XCTAssertTrue(retried.persistenceHealth.policyStatusAvailable) + XCTAssertEqual(try store.base.loadAgentControlEnabled(), false) + XCTAssertEqual(store.savedPolicies, [false]) + } + func testLeaseExpiryUsesMonotonicDecisionClockNotWallClockRollback() async throws { let hardware = AgentServiceFakeHardware(snapshot: Self.snapshot(fans: [Self.fan(id: 0, minimumRPM: 1500, maximumRPM: 4500)])) let wall = AgentControlTestClock(now: Date(timeIntervalSince1970: 1_000)) @@ -1773,6 +1911,35 @@ private final class FailingActiveLeaseSaveStore: AgentControlPersisting, @unchec } } +private enum AgentControlFault: Error { + case loadPolicy + case savePolicy +} + +private final class AgentControlFaultStore: AgentControlPersisting, @unchecked Sendable { + let base: AgentControlStore + var loadedPolicy: Result = .success(nil) + var savePolicyError: AgentControlFault? + var savedPolicies: [Bool] = [] + + init(directory: URL) { + self.base = AgentControlStore(directory: directory) + } + + func saveActiveLease(_ lease: AgentCoolingLease?) throws { try base.saveActiveLease(lease) } + func loadActiveLease() throws -> AgentCoolingLease? { try base.loadActiveLease() } + func appendAuditEvent(_ event: AgentControlAuditEvent) throws { try base.appendAuditEvent(event) } + func loadRecentAuditEvents(limit: Int) throws -> [AgentControlAuditEvent] { + try base.loadRecentAuditEvents(limit: limit) + } + func loadAgentControlEnabled() throws -> Bool? { try loadedPolicy.get() } + func saveAgentControlEnabled(_ enabled: Bool) throws { + if let savePolicyError { throw savePolicyError } + savedPolicies.append(enabled) + try base.saveAgentControlEnabled(enabled) + } +} + private actor AgentServiceFakeHardware: HardwareService { enum Failure: Error, Equatable { case applyFailed From fb419a880e1d9264db872e8b9fb9d89130531157 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 16:58:36 +0200 Subject: [PATCH 07/27] fix: make app preferences recoverable and truthful --- Sources/Vifty/AppModel+MenuBar.swift | 14 ++- Sources/Vifty/AppModel.swift | 9 +- Sources/Vifty/AppPreferencesStore.swift | 118 +++++++++++++++--- Sources/Vifty/SettingsGeneralView.swift | 15 +++ .../AppModelPreferencesTests.swift | 60 +++++++++ .../AppSourceRegressionTests.swift | 25 ++++ 6 files changed, 224 insertions(+), 17 deletions(-) create mode 100644 Tests/ViftyCoreTests/AppSourceRegressionTests.swift diff --git a/Sources/Vifty/AppModel+MenuBar.swift b/Sources/Vifty/AppModel+MenuBar.swift index 1570681b..ba261cb4 100644 --- a/Sources/Vifty/AppModel+MenuBar.swift +++ b/Sources/Vifty/AppModel+MenuBar.swift @@ -175,7 +175,7 @@ extension AppModel { } func persistAppPreferences() { - preferencesStore.save(AppPreferences( + let preferences = AppPreferences( menuBarDisplayMode: menuBarDisplayMode, menuBarCustomFields: menuBarCustomFields, startupMode: startupMode, @@ -184,7 +184,17 @@ extension AppModel { usePerFanFixedRPM: usePerFanFixedRPM, fixedFanTargets: fixedFanTargets, codexUsageDisplayPreferences: codexUsageDisplayPreferences - )) + ) + do { + try preferencesStore.saveThrowing(preferences) + appPreferencesPersistenceMessage = nil + } catch { + appPreferencesPersistenceMessage = "Settings were not saved: \(error.localizedDescription)" + } + } + + func retryAppPreferencesSave() { + persistAppPreferences() } var codexUsageDisplayPreferences: CodexUsageDisplayPreferences { diff --git a/Sources/Vifty/AppModel.swift b/Sources/Vifty/AppModel.swift index d17b0a48..41335f09 100644 --- a/Sources/Vifty/AppModel.swift +++ b/Sources/Vifty/AppModel.swift @@ -30,6 +30,7 @@ final class AppModel: ObservableObject { } @Published var lastError: String? @Published var curveProfilePersistenceError: String? + @Published var appPreferencesPersistenceMessage: String? @Published var fanAccessMessage: String? @Published var daemonResponding = false @Published var daemonReachable = false @@ -318,7 +319,13 @@ final class AppModel: ObservableObject { self.agentRestore = agentRestore self.profileStore = profileStore self.preferencesStore = preferencesStore - let appPreferences = self.preferencesStore.load() + let appPreferences: AppPreferences + do { + appPreferences = try self.preferencesStore.loadResult().preferences + } catch { + appPreferences = self.preferencesStore.load() + appPreferencesPersistenceMessage = "Settings were not saved: \(error.localizedDescription)" + } menuBarDisplayMode = appPreferences.menuBarDisplayMode menuBarCustomFields = MenuBarField.normalized(appPreferences.menuBarCustomFields) startupMode = appPreferences.startupMode diff --git a/Sources/Vifty/AppPreferencesStore.swift b/Sources/Vifty/AppPreferencesStore.swift index 7885c747..6592943a 100644 --- a/Sources/Vifty/AppPreferencesStore.swift +++ b/Sources/Vifty/AppPreferencesStore.swift @@ -59,6 +59,11 @@ struct AppPreferences: Codable, Equatable { } } +struct AppPreferencesLoadResult: Equatable { + var preferences: AppPreferences + var recoveryMessage: String? +} + final class AppPreferencesStore: @unchecked Sendable { static let legacyMenuBarDisplayModeDefaultsKey = "menuBarDisplayMode" static let legacyNotificationHelperFailureDefaultsKey = "notification.helperFailure" @@ -76,24 +81,37 @@ final class AppPreferencesStore: @unchecked Sendable { } func load() -> AppPreferences { - if let data = try? Data(contentsOf: url), - let preferences = try? JSONDecoder().decode(AppPreferences.self, from: data) { - return preferences - } + (try? loadResult().preferences) ?? migratedPreferences() + } - // Preserve the unreadable original before any overwrite so a decode - // failure never silently destroys the last recoverable copy. - if FileManager.default.fileExists(atPath: url.path) { - let backup = url.appendingPathExtension("bak") - try? FileManager.default.removeItem(at: backup) - try? FileManager.default.copyItem(at: url, to: backup) + func loadResult() throws -> AppPreferencesLoadResult { + switch decodePreferences(at: url) { + case .success(let preferences): + try? restrictDirectoryPermissions() + try? restrictFilePermissions(at: url) + return AppPreferencesLoadResult(preferences: preferences, recoveryMessage: nil) + case .missing, .failure: + break } - let migrated = migratedPreferences() - if migrated != .defaults { - try? saveThrowing(migrated) + switch decodePreferences(at: backupURL) { + case .success(let preferences): + try? restrictDirectoryPermissions() + try? restrictFilePermissions(at: backupURL) + if case .failure = decodePreferences(at: url) { + quarantinePrimaryIfPossible() + } + return AppPreferencesLoadResult( + preferences: preferences, + recoveryMessage: "Vifty loaded its private app-preferences backup." + ) + case .missing, .failure: + let migrated = migratedPreferences() + if migrated != .defaults { + try saveThrowing(migrated) + } + return AppPreferencesLoadResult(preferences: migrated, recoveryMessage: nil) } - return migrated } func save(_ preferences: AppPreferences) { @@ -105,9 +123,81 @@ final class AppPreferencesStore: @unchecked Sendable { try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) try FileManager.default.setAttributes([.posixPermissions: NSNumber(value: 0o700)], ofItemAtPath: directory.path) + if case .success = decodePreferences(at: url), + let primaryData = try? Data(contentsOf: url) { + replaceBackupIfPossible(with: primaryData) + } + let data = try JSONEncoder().encode(preferences) try data.write(to: url, options: .atomic) try restrictFilePermissions(at: url) + + if case .success = decodePreferences(at: backupURL) { + try? restrictFilePermissions(at: backupURL) + } else { + replaceBackupIfPossible(with: data) + } + } + + private var backupURL: URL { + url.appendingPathExtension("bak") + } + + private enum DecodeResult { + case success(AppPreferences) + case missing + case failure + } + + private func decodePreferences(at fileURL: URL) -> DecodeResult { + guard FileManager.default.fileExists(atPath: fileURL.path) else { return .missing } + do { + return .success(try JSONDecoder().decode(AppPreferences.self, from: Data(contentsOf: fileURL))) + } catch { + return .failure + } + } + + private func replaceBackupIfPossible(with data: Data) { + let temporaryURL = backupURL.deletingLastPathComponent().appendingPathComponent( + ".\(backupURL.lastPathComponent).\(UUID().uuidString).tmp" + ) + do { + try data.write(to: temporaryURL, options: .withoutOverwriting) + try restrictFilePermissions(at: temporaryURL) + if FileManager.default.fileExists(atPath: backupURL.path) { + _ = try FileManager.default.replaceItemAt( + backupURL, + withItemAt: temporaryURL, + backupItemName: nil, + options: [] + ) + } else { + try FileManager.default.moveItem(at: temporaryURL, to: backupURL) + } + try restrictFilePermissions(at: backupURL) + } catch { + try? FileManager.default.removeItem(at: temporaryURL) + } + } + + private func quarantinePrimaryIfPossible() { + let quarantineURL = url.deletingLastPathComponent().appendingPathComponent( + ".\(url.lastPathComponent).corrupt.\(UUID().uuidString)" + ) + do { + try FileManager.default.moveItem(at: url, to: quarantineURL) + try restrictFilePermissions(at: quarantineURL) + } catch { + // Recovery from a valid backup must not depend on quarantine I/O. + } + } + + private func restrictDirectoryPermissions() throws { + try FileManager.default.setAttributes( + [.posixPermissions: NSNumber(value: 0o700)], + ofItemAtPath: url.deletingLastPathComponent().path + ) } private func migratedPreferences() -> AppPreferences { diff --git a/Sources/Vifty/SettingsGeneralView.swift b/Sources/Vifty/SettingsGeneralView.swift index fe52145e..9fa05118 100644 --- a/Sources/Vifty/SettingsGeneralView.swift +++ b/Sources/Vifty/SettingsGeneralView.swift @@ -23,6 +23,21 @@ struct SettingsGeneralView: View { var body: some View { SettingsPane(accessibilityPane: .general) { + if let message = model.appPreferencesPersistenceMessage { + HStack(alignment: .firstTextBaseline) { + Label(message, systemImage: "exclamationmark.triangle") + .foregroundStyle(.orange) + .accessibilityLabel("Settings were not saved") + .accessibilityValue(message) + Button("Retry Save") { + model.retryAppPreferencesSave() + } + .accessibilityLabel("Retry saving settings") + } + .viftyFont(.caption) + .fixedSize(horizontal: false, vertical: true) + } + updatesSection Section("Startup") { diff --git a/Tests/ViftyCoreTests/AppModelPreferencesTests.swift b/Tests/ViftyCoreTests/AppModelPreferencesTests.swift index c0ff2715..2c4ebdfa 100644 --- a/Tests/ViftyCoreTests/AppModelPreferencesTests.swift +++ b/Tests/ViftyCoreTests/AppModelPreferencesTests.swift @@ -4,6 +4,66 @@ import XCTest @MainActor final class AppModelPreferencesTests: XCTestCase { + func testCorruptPrimaryRecoversValidBackupWithoutMutatingBackup() throws { + let preferencesURL = temporaryPreferencesPath() + let directory = preferencesURL.deletingLastPathComponent() + defer { try? FileManager.default.removeItem(at: directory) } + try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) + try FileManager.default.setAttributes( + [.posixPermissions: NSNumber(value: 0o700)], + ofItemAtPath: directory.path + ) + + let backupPreferences = AppPreferences( + menuBarDisplayMode: .temperature, + startupMode: .curve, + notificationSettings: .disabled + ) + let backupData = try JSONEncoder().encode(backupPreferences) + let corruptData = Data("corrupt primary".utf8) + try corruptData.write(to: preferencesURL) + try backupData.write(to: preferencesURL.appendingPathExtension("bak")) + try FileManager.default.setAttributes( + [.posixPermissions: NSNumber(value: 0o600)], + ofItemAtPath: preferencesURL.path + ) + try FileManager.default.setAttributes( + [.posixPermissions: NSNumber(value: 0o600)], + ofItemAtPath: preferencesURL.appendingPathExtension("bak").path + ) + + let result = try AppPreferencesStore(url: preferencesURL, legacyDefaults: nil).loadResult() + + XCTAssertEqual(result.preferences, backupPreferences) + XCTAssertNotNil(result.recoveryMessage) + XCTAssertEqual(try Data(contentsOf: preferencesURL.appendingPathExtension("bak")), backupData) + XCTAssertEqual(try posixPermissions(at: preferencesURL.appendingPathExtension("bak")), 0o600) + } + + func testPreferenceSaveFailureIsSeparateAndRetryClearsMessage() throws { + let root = temporaryPreferencesPath().deletingLastPathComponent() + try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) + defer { try? FileManager.default.removeItem(at: root) } + let invalidParent = root.appendingPathComponent("preferences-parent") + try Data("not a directory".utf8).write(to: invalidParent) + let preferencesURL = invalidParent.appendingPathComponent("app-preferences.json") + let store = AppPreferencesStore(url: preferencesURL, legacyDefaults: nil) + let model = AppModel(preferencesStore: store) + model.lastError = "fan control failure" + + model.menuBarDisplayMode = .temperature + + XCTAssertTrue(model.appPreferencesPersistenceMessage?.hasPrefix("Settings were not saved:") == true) + XCTAssertEqual(model.lastError, "fan control failure") + + try FileManager.default.removeItem(at: invalidParent) + try FileManager.default.createDirectory(at: invalidParent, withIntermediateDirectories: true) + model.retryAppPreferencesSave() + + XCTAssertNil(model.appPreferencesPersistenceMessage) + XCTAssertEqual(store.load().menuBarDisplayMode, .temperature) + } + func testSaveProfileWithDuplicateNameRequiresConfirmationAndPreservesIdentity() throws { let model = AppModel() model.savedProfiles = [] diff --git a/Tests/ViftyCoreTests/AppSourceRegressionTests.swift b/Tests/ViftyCoreTests/AppSourceRegressionTests.swift new file mode 100644 index 00000000..1e389253 --- /dev/null +++ b/Tests/ViftyCoreTests/AppSourceRegressionTests.swift @@ -0,0 +1,25 @@ +import Foundation +import XCTest + +final class AppSourceRegressionTests: XCTestCase { + func testGeneralSettingsSurfacesRetryablePreferenceSaveFailure() throws { + let source = try read("Sources/Vifty/SettingsGeneralView.swift") + + XCTAssertTrue(source.contains("model.appPreferencesPersistenceMessage")) + XCTAssertTrue(source.contains("Button(\"Retry Save\")")) + XCTAssertTrue(source.contains("model.retryAppPreferencesSave()")) + XCTAssertTrue(source.contains(".accessibilityLabel(\"Settings were not saved\")")) + } + + private func read(_ relativePath: String) throws -> String { + let testFile = URL(fileURLWithPath: #filePath) + let repositoryRoot = testFile + .deletingLastPathComponent() + .deletingLastPathComponent() + .deletingLastPathComponent() + return try String( + contentsOf: repositoryRoot.appendingPathComponent(relativePath), + encoding: .utf8 + ) + } +} From d112cbb03ff4738569ff45c0038a0d8e40f2da87 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 17:07:51 +0200 Subject: [PATCH 08/27] fix: fail closed on preference backup recovery --- Sources/Vifty/AppModel.swift | 5 +- Sources/Vifty/AppPreferencesStore.swift | 25 ++++----- Sources/Vifty/SettingsGeneralView.swift | 9 ++++ .../AppModelPreferencesTests.swift | 52 +++++++++++++++++++ .../AppSourceRegressionTests.swift | 12 +++++ 5 files changed, 88 insertions(+), 15 deletions(-) diff --git a/Sources/Vifty/AppModel.swift b/Sources/Vifty/AppModel.swift index 41335f09..6f4f802b 100644 --- a/Sources/Vifty/AppModel.swift +++ b/Sources/Vifty/AppModel.swift @@ -31,6 +31,7 @@ final class AppModel: ObservableObject { @Published var lastError: String? @Published var curveProfilePersistenceError: String? @Published var appPreferencesPersistenceMessage: String? + @Published var appPreferencesRecoveryMessage: String? @Published var fanAccessMessage: String? @Published var daemonResponding = false @Published var daemonReachable = false @@ -321,7 +322,9 @@ final class AppModel: ObservableObject { self.preferencesStore = preferencesStore let appPreferences: AppPreferences do { - appPreferences = try self.preferencesStore.loadResult().preferences + let result = try self.preferencesStore.loadResult() + appPreferences = result.preferences + appPreferencesRecoveryMessage = result.recoveryMessage } catch { appPreferences = self.preferencesStore.load() appPreferencesPersistenceMessage = "Settings were not saved: \(error.localizedDescription)" diff --git a/Sources/Vifty/AppPreferencesStore.swift b/Sources/Vifty/AppPreferencesStore.swift index 6592943a..a049062f 100644 --- a/Sources/Vifty/AppPreferencesStore.swift +++ b/Sources/Vifty/AppPreferencesStore.swift @@ -87,8 +87,8 @@ final class AppPreferencesStore: @unchecked Sendable { func loadResult() throws -> AppPreferencesLoadResult { switch decodePreferences(at: url) { case .success(let preferences): - try? restrictDirectoryPermissions() - try? restrictFilePermissions(at: url) + try restrictDirectoryPermissions() + try restrictFilePermissions(at: url) return AppPreferencesLoadResult(preferences: preferences, recoveryMessage: nil) case .missing, .failure: break @@ -96,8 +96,8 @@ final class AppPreferencesStore: @unchecked Sendable { switch decodePreferences(at: backupURL) { case .success(let preferences): - try? restrictDirectoryPermissions() - try? restrictFilePermissions(at: backupURL) + try restrictDirectoryPermissions() + try restrictFilePermissions(at: backupURL) if case .failure = decodePreferences(at: url) { quarantinePrimaryIfPossible() } @@ -114,18 +114,14 @@ final class AppPreferencesStore: @unchecked Sendable { } } - func save(_ preferences: AppPreferences) { - try? saveThrowing(preferences) - } - func saveThrowing(_ preferences: AppPreferences) throws { let directory = url.deletingLastPathComponent() try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) try FileManager.default.setAttributes([.posixPermissions: NSNumber(value: 0o700)], ofItemAtPath: directory.path) - if case .success = decodePreferences(at: url), - let primaryData = try? Data(contentsOf: url) { - replaceBackupIfPossible(with: primaryData) + if case .success = decodePreferences(at: url) { + let primaryData = try Data(contentsOf: url) + try replaceBackup(with: primaryData) } let data = try JSONEncoder().encode(preferences) @@ -133,9 +129,9 @@ final class AppPreferencesStore: @unchecked Sendable { try restrictFilePermissions(at: url) if case .success = decodePreferences(at: backupURL) { - try? restrictFilePermissions(at: backupURL) + try restrictFilePermissions(at: backupURL) } else { - replaceBackupIfPossible(with: data) + try replaceBackup(with: data) } } @@ -158,7 +154,7 @@ final class AppPreferencesStore: @unchecked Sendable { } } - private func replaceBackupIfPossible(with data: Data) { + private func replaceBackup(with data: Data) throws { let temporaryURL = backupURL.deletingLastPathComponent().appendingPathComponent( ".\(backupURL.lastPathComponent).\(UUID().uuidString).tmp" ) @@ -178,6 +174,7 @@ final class AppPreferencesStore: @unchecked Sendable { try restrictFilePermissions(at: backupURL) } catch { try? FileManager.default.removeItem(at: temporaryURL) + throw error } } diff --git a/Sources/Vifty/SettingsGeneralView.swift b/Sources/Vifty/SettingsGeneralView.swift index 9fa05118..2fb73dc5 100644 --- a/Sources/Vifty/SettingsGeneralView.swift +++ b/Sources/Vifty/SettingsGeneralView.swift @@ -38,6 +38,15 @@ struct SettingsGeneralView: View { .fixedSize(horizontal: false, vertical: true) } + if let message = model.appPreferencesRecoveryMessage { + Label("Settings recovered", systemImage: "arrow.counterclockwise.circle") + .foregroundStyle(.secondary) + .accessibilityLabel("Settings recovered") + .accessibilityValue(message) + .viftyFont(.caption) + .fixedSize(horizontal: false, vertical: true) + } + updatesSection Section("Startup") { diff --git a/Tests/ViftyCoreTests/AppModelPreferencesTests.swift b/Tests/ViftyCoreTests/AppModelPreferencesTests.swift index 2c4ebdfa..8af53f1e 100644 --- a/Tests/ViftyCoreTests/AppModelPreferencesTests.swift +++ b/Tests/ViftyCoreTests/AppModelPreferencesTests.swift @@ -1,9 +1,61 @@ +import Darwin import XCTest @testable import ViftyCore @testable import Vifty @MainActor final class AppModelPreferencesTests: XCTestCase { + func testSaveFailsBeforeReplacingValidPrimaryWhenBackupPreservationFails() throws { + let preferencesURL = temporaryPreferencesPath() + let directory = preferencesURL.deletingLastPathComponent() + defer { try? FileManager.default.removeItem(at: directory) } + try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) + + let existing = AppPreferences( + menuBarDisplayMode: .temperature, + startupMode: .curve, + notificationSettings: .disabled + ) + let replacement = AppPreferences( + menuBarDisplayMode: .averageFanRPM, + startupMode: .fixed, + notificationSettings: .disabled + ) + let existingData = try JSONEncoder().encode(existing) + try existingData.write(to: preferencesURL) + let backupURL = preferencesURL.appendingPathExtension("bak") + try Data("keep this invalid backup".utf8).write(to: backupURL) + XCTAssertEqual(chflags(backupURL.path, UInt32(UF_IMMUTABLE)), 0) + defer { _ = chflags(backupURL.path, 0) } + + XCTAssertThrowsError(try AppPreferencesStore(url: preferencesURL, legacyDefaults: nil).saveThrowing(replacement)) + XCTAssertEqual(try Data(contentsOf: preferencesURL), existingData) + XCTAssertEqual(try Data(contentsOf: backupURL), Data("keep this invalid backup".utf8)) + } + + func testAppModelSurfacesPreferenceRecoverySeparatelyFromFanError() throws { + let preferencesURL = temporaryPreferencesPath() + let directory = preferencesURL.deletingLastPathComponent() + defer { try? FileManager.default.removeItem(at: directory) } + try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) + try Data("corrupt primary".utf8).write(to: preferencesURL) + let recovered = AppPreferences( + menuBarDisplayMode: .temperature, + startupMode: .curve, + notificationSettings: .disabled + ) + try JSONEncoder().encode(recovered).write(to: preferencesURL.appendingPathExtension("bak")) + + let model = AppModel( + preferencesStore: AppPreferencesStore(url: preferencesURL, legacyDefaults: nil) + ) + + XCTAssertEqual(model.menuBarDisplayMode, .temperature) + XCTAssertTrue(model.appPreferencesRecoveryMessage?.contains("backup") == true) + XCTAssertNil(model.appPreferencesPersistenceMessage) + XCTAssertNil(model.lastError) + } + func testCorruptPrimaryRecoversValidBackupWithoutMutatingBackup() throws { let preferencesURL = temporaryPreferencesPath() let directory = preferencesURL.deletingLastPathComponent() diff --git a/Tests/ViftyCoreTests/AppSourceRegressionTests.swift b/Tests/ViftyCoreTests/AppSourceRegressionTests.swift index 1e389253..a90744ab 100644 --- a/Tests/ViftyCoreTests/AppSourceRegressionTests.swift +++ b/Tests/ViftyCoreTests/AppSourceRegressionTests.swift @@ -11,6 +11,18 @@ final class AppSourceRegressionTests: XCTestCase { XCTAssertTrue(source.contains(".accessibilityLabel(\"Settings were not saved\")")) } + func testPreferenceStoreDoesNotKeepSilentSaveOrIgnoreSecurityFailures() throws { + let store = try read("Sources/Vifty/AppPreferencesStore.swift") + let model = try read("Sources/Vifty/AppModel.swift") + let general = try read("Sources/Vifty/SettingsGeneralView.swift") + + XCTAssertFalse(store.contains("func save(_ preferences: AppPreferences)")) + XCTAssertFalse(store.contains("try? restrictDirectoryPermissions()")) + XCTAssertFalse(store.contains("try? restrictFilePermissions(at:")) + XCTAssertTrue(model.contains("appPreferencesRecoveryMessage")) + XCTAssertTrue(general.contains("Settings recovered")) + } + private func read(_ relativePath: String) throws -> String { let testFile = URL(fileURLWithPath: #filePath) let repositoryRoot = testFile From da081c5db70ab2cba4589def99931c4066524c66 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 17:23:04 +0200 Subject: [PATCH 09/27] fix: drain helper lifecycle output concurrently --- Sources/Vifty/DaemonInstallService.swift | 65 +++++++++++++++++-- .../DaemonInstallServiceTests.swift | 32 +++++++++ 2 files changed, 93 insertions(+), 4 deletions(-) diff --git a/Sources/Vifty/DaemonInstallService.swift b/Sources/Vifty/DaemonInstallService.swift index e6c616d0..92e663c2 100644 --- a/Sources/Vifty/DaemonInstallService.swift +++ b/Sources/Vifty/DaemonInstallService.swift @@ -24,6 +24,20 @@ struct DaemonInstallProcessOutput: Equatable, Sendable { var standardError: String } +private actor BoundedProcessOutput { + static let maximumBytesPerStream = 64 * 1_024 + private var data = Data() + + func append(_ chunk: Data) { + guard data.count < Self.maximumBytesPerStream else { return } + data.append(chunk.prefix(Self.maximumBytesPerStream - data.count)) + } + + func snapshot() -> Data { + data + } +} + struct DaemonInstallProcessRunner: Sendable { let run: @Sendable (URL, [String], Data) async throws -> DaemonInstallProcessOutput @@ -45,26 +59,69 @@ struct DaemonInstallProcessRunner: Sendable { let inputPipe = Pipe() let outputPipe = Pipe() let errorPipe = Pipe() + let inputHandle = inputPipe.fileHandleForWriting + let outputHandle = outputPipe.fileHandleForReading + let errorHandle = errorPipe.fileHandleForReading process.standardInput = inputPipe process.standardOutput = outputPipe process.standardError = errorPipe + defer { + try? inputHandle.close() + try? outputHandle.close() + try? errorHandle.close() + } try process.run() + let output = BoundedProcessOutput() + let error = BoundedProcessOutput() + let outputReader = Task.detached(priority: .userInitiated) { + do { + while let chunk = try outputHandle.read(upToCount: 64 * 1_024), !chunk.isEmpty { + await output.append(chunk) + } + } catch { + return + } + } + let errorReader = Task.detached(priority: .userInitiated) { + do { + while let chunk = try errorHandle.read(upToCount: 64 * 1_024), !chunk.isEmpty { + await error.append(chunk) + } + } catch { + return + } + } do { - try inputPipe.fileHandleForWriting.write(contentsOf: standardInput) - try inputPipe.fileHandleForWriting.close() + try inputHandle.write(contentsOf: standardInput) + try inputHandle.close() } catch { process.terminate() + try? inputHandle.close() + try? outputHandle.close() + try? errorHandle.close() + let deadline = Date().addingTimeInterval(1) + while process.isRunning && Date() < deadline { + usleep(10_000) + } + if process.isRunning { + kill(process.processIdentifier, SIGKILL) + } + process.waitUntilExit() + _ = await outputReader.value + _ = await errorReader.value throw error } process.waitUntilExit() + _ = await outputReader.value + _ = await errorReader.value return DaemonInstallProcessOutput( terminationStatus: process.terminationStatus, standardOutput: String( - decoding: outputPipe.fileHandleForReading.readDataToEndOfFile(), + decoding: await output.snapshot(), as: UTF8.self ), standardError: String( - decoding: errorPipe.fileHandleForReading.readDataToEndOfFile(), + decoding: await error.snapshot(), as: UTF8.self ) ) diff --git a/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift b/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift index a4628076..b264eccd 100644 --- a/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift +++ b/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift @@ -77,6 +77,30 @@ final class DaemonInstallServiceTests: XCTestCase { } } + func testSystemRunnerDrainsLargeOutputWithoutDeadlock() async throws { + let script = FileManager.default.temporaryDirectory + .appendingPathComponent("vifty-output-" + UUID().uuidString + ".sh") + defer { try? FileManager.default.removeItem(at: script) } + try Data("#!/bin/bash\ncat >/dev/null\ndd if=/dev/zero bs=262144 count=1 2>/dev/null\ndd if=/dev/zero bs=262144 count=1 1>&2 2>/dev/null\nexit 0\n".utf8) + .write(to: script) + XCTAssertEqual(chmod(script.path, 0o755), 0) + + let resultBox = ProcessOutputBox() + let completion = expectation(description: "high-output process completes") + let maximumBytesPerStream = 64 * 1_024 + Task { + defer { completion.fulfill() } + await resultBox.set(try? await DaemonInstallProcessRunner.system.run(script, [], Data("input\n".utf8))) + } + + await fulfillment(of: [completion], timeout: 2) + let output = await resultBox.value + let result = try XCTUnwrap(output) + XCTAssertEqual(result.terminationStatus, 0) + XCTAssertLessThanOrEqual(result.standardOutput.utf8.count, maximumBytesPerStream) + XCTAssertLessThanOrEqual(result.standardError.utf8.count, maximumBytesPerStream) + } + func testBundledLoaderAcceptsOnlyTheReviewedLifecycleScriptBytes() throws { let reviewedScript = repositoryRoot.appendingPathComponent("scripts/vifty-helper-lifecycle.sh") let expectedData = try Data(contentsOf: reviewedScript) @@ -215,3 +239,11 @@ private actor InstallRunnerRecorder { ) } } + +private actor ProcessOutputBox { + private(set) var value: DaemonInstallProcessOutput? + + func set(_ value: DaemonInstallProcessOutput?) { + self.value = value + } +} From 9077e5bef502c7f0782424a517bc358f7f9a5468 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 17:59:38 +0200 Subject: [PATCH 10/27] fix: bound lifecycle cleanup after stdin failure --- Sources/Vifty/DaemonInstallService.swift | 7 ++- .../DaemonInstallServiceTests.swift | 44 ++++++++++++++++++- 2 files changed, 45 insertions(+), 6 deletions(-) diff --git a/Sources/Vifty/DaemonInstallService.swift b/Sources/Vifty/DaemonInstallService.swift index 92e663c2..3089062b 100644 --- a/Sources/Vifty/DaemonInstallService.swift +++ b/Sources/Vifty/DaemonInstallService.swift @@ -99,16 +99,15 @@ struct DaemonInstallProcessRunner: Sendable { try? inputHandle.close() try? outputHandle.close() try? errorHandle.close() - let deadline = Date().addingTimeInterval(1) + let deadline = Date().addingTimeInterval(0.25) while process.isRunning && Date() < deadline { usleep(10_000) } if process.isRunning { kill(process.processIdentifier, SIGKILL) } - process.waitUntilExit() - _ = await outputReader.value - _ = await errorReader.value + outputReader.cancel() + errorReader.cancel() throw error } process.waitUntilExit() diff --git a/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift b/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift index b264eccd..abbcc0bd 100644 --- a/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift +++ b/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift @@ -97,8 +97,40 @@ final class DaemonInstallServiceTests: XCTestCase { let output = await resultBox.value let result = try XCTUnwrap(output) XCTAssertEqual(result.terminationStatus, 0) - XCTAssertLessThanOrEqual(result.standardOutput.utf8.count, maximumBytesPerStream) - XCTAssertLessThanOrEqual(result.standardError.utf8.count, maximumBytesPerStream) + XCTAssertEqual(result.standardOutput.utf8.count, maximumBytesPerStream) + XCTAssertEqual(result.standardError.utf8.count, maximumBytesPerStream) + } + + func testSystemRunnerBoundsCleanupAfterStdinWriteFailure() async throws { + let script = FileManager.default.temporaryDirectory + .appendingPathComponent("vifty-input-failure-" + UUID().uuidString + ".sh") + defer { try? FileManager.default.removeItem(at: script) } + try Data("#!/bin/bash\nexec 0<&-\ntrap '' TERM\nwhile :; do :; done\n".utf8).write(to: script) + XCTAssertEqual(chmod(script.path, 0o755), 0) + + let previousSIGPIPEHandler = signal(SIGPIPE, SIG_IGN) + defer { signal(SIGPIPE, previousSIGPIPEHandler) } + let resultBox = ProcessFailureBox() + let completion = expectation(description: "stdin failure cleanup completes") + let startedAt = Date() + Task { + defer { completion.fulfill() } + do { + _ = try await DaemonInstallProcessRunner.system.run( + script, + [], + Data(repeating: 0, count: 1 * 1_024 * 1_024) + ) + await resultBox.set(threw: false) + } catch { + await resultBox.set(threw: true) + } + } + + await fulfillment(of: [completion], timeout: 2) + XCTAssertLessThan(Date().timeIntervalSince(startedAt), 1.25) + let didThrow = await resultBox.threw + XCTAssertTrue(didThrow) } func testBundledLoaderAcceptsOnlyTheReviewedLifecycleScriptBytes() throws { @@ -247,3 +279,11 @@ private actor ProcessOutputBox { self.value = value } } + +private actor ProcessFailureBox { + private(set) var threw = false + + func set(threw: Bool) { + self.threw = threw + } +} From 49a8a8a74a332d26141d3f688b542638467dc230 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 19:22:09 +0200 Subject: [PATCH 11/27] Fix Stage 1 persistence safety reporting --- Sources/Vifty/AppPreferencesStore.swift | 20 ++++-- Sources/ViftyCore/ViftyCtlRunner.swift | 7 +- .../AgentControlServiceTests.swift | 2 + .../AppModelPreferencesTests.swift | 71 ++++++++++++++++++- .../DaemonInstallServiceTests.swift | 38 ++++++---- .../ViftyCoreTests/ViftyCtlRunnerTests.swift | 45 ++++++++++++ .../XPCAgentControlCodingTests.swift | 24 +++++++ 7 files changed, 187 insertions(+), 20 deletions(-) diff --git a/Sources/Vifty/AppPreferencesStore.swift b/Sources/Vifty/AppPreferencesStore.swift index a049062f..8e39ac70 100644 --- a/Sources/Vifty/AppPreferencesStore.swift +++ b/Sources/Vifty/AppPreferencesStore.swift @@ -85,20 +85,25 @@ final class AppPreferencesStore: @unchecked Sendable { } func loadResult() throws -> AppPreferencesLoadResult { - switch decodePreferences(at: url) { + let primary = decodePreferences(at: url) + switch primary { case .success(let preferences): try restrictDirectoryPermissions() try restrictFilePermissions(at: url) + if case .success = decodePreferences(at: backupURL) { + try restrictFilePermissions(at: backupURL) + } return AppPreferencesLoadResult(preferences: preferences, recoveryMessage: nil) case .missing, .failure: break } - switch decodePreferences(at: backupURL) { + let backup = decodePreferences(at: backupURL) + switch backup { case .success(let preferences): try restrictDirectoryPermissions() try restrictFilePermissions(at: backupURL) - if case .failure = decodePreferences(at: url) { + if case .failure = primary { quarantinePrimaryIfPossible() } return AppPreferencesLoadResult( @@ -110,7 +115,14 @@ final class AppPreferencesStore: @unchecked Sendable { if migrated != .defaults { try saveThrowing(migrated) } - return AppPreferencesLoadResult(preferences: migrated, recoveryMessage: nil) + let recoveryMessage: String? + switch (primary, backup) { + case (.failure, _), (_, .failure): + recoveryMessage = "Vifty could not recover its private app preferences; defaults are in use." + default: + recoveryMessage = nil + } + return AppPreferencesLoadResult(preferences: migrated, recoveryMessage: recoveryMessage) } } diff --git a/Sources/ViftyCore/ViftyCtlRunner.swift b/Sources/ViftyCore/ViftyCtlRunner.swift index 9c216a4e..f43b3814 100644 --- a/Sources/ViftyCore/ViftyCtlRunner.swift +++ b/Sources/ViftyCore/ViftyCtlRunner.swift @@ -1413,7 +1413,10 @@ public struct ViftyCtlRunner: Sendable { } let stderr: String if let error = capabilities.agentControlStatusError { - stderr = "viftyctl capabilities: daemon status unavailable; policy is a disabled fallback: \(error)\n" + let source = capabilities.daemonStatusAvailable + ? "policy persistence unavailable" + : "daemon status unavailable" + stderr = "viftyctl capabilities: \(source); policy is a disabled fallback: \(error)\n" } else if !capabilities.policyStatusAvailable { stderr = "viftyctl capabilities: daemon returned no usable policy; policy is a disabled fallback\n" } else { @@ -1779,7 +1782,7 @@ public struct ViftyCtlRunner: Sendable { policySource: .fallbackUnavailable, daemonStatusAvailable: false, policyStatusAvailable: false, - agentControlStatusError: error.localizedDescription + agentControlStatusError: Self.boundedPolicyPersistenceMessage(error.localizedDescription) ) } } diff --git a/Tests/ViftyCoreTests/AgentControlServiceTests.swift b/Tests/ViftyCoreTests/AgentControlServiceTests.swift index 403ecd78..eb41893f 100644 --- a/Tests/ViftyCoreTests/AgentControlServiceTests.swift +++ b/Tests/ViftyCoreTests/AgentControlServiceTests.swift @@ -256,6 +256,7 @@ final class AgentControlServiceTests: XCTestCase { func testFailedDisableSaveRestoresActiveLeaseAndSuccessfulRetryPublishesToggle() async throws { let store = AgentControlFaultStore(directory: temporaryDirectory()) store.loadedPolicy = .success(true) + try store.base.saveAgentControlEnabled(true) let hardware = AgentServiceFakeHardware(snapshot: Self.snapshot(fans: [Self.fan(id: 0, minimumRPM: 1500, maximumRPM: 4500)])) let service = AgentControlService( hardware: hardware, @@ -289,6 +290,7 @@ final class AgentControlServiceTests: XCTestCase { XCTAssertEqual(failed.lastErrorCode, .persistenceFailure) let restoredFanIDs = await hardware.restoredFanIDs XCTAssertEqual(restoredFanIDs, [0]) + XCTAssertEqual(try store.base.loadAgentControlEnabled(), true) store.savePolicyError = nil let retried = try await service.setPolicyEnabled(false) diff --git a/Tests/ViftyCoreTests/AppModelPreferencesTests.swift b/Tests/ViftyCoreTests/AppModelPreferencesTests.swift index 8af53f1e..49291ce1 100644 --- a/Tests/ViftyCoreTests/AppModelPreferencesTests.swift +++ b/Tests/ViftyCoreTests/AppModelPreferencesTests.swift @@ -8,7 +8,13 @@ final class AppModelPreferencesTests: XCTestCase { func testSaveFailsBeforeReplacingValidPrimaryWhenBackupPreservationFails() throws { let preferencesURL = temporaryPreferencesPath() let directory = preferencesURL.deletingLastPathComponent() - defer { try? FileManager.default.removeItem(at: directory) } + defer { + try? FileManager.default.setAttributes( + [.posixPermissions: NSNumber(value: 0o700)], + ofItemAtPath: directory.path + ) + try? FileManager.default.removeItem(at: directory) + } try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) let existing = AppPreferences( @@ -92,6 +98,69 @@ final class AppModelPreferencesTests: XCTestCase { XCTAssertEqual(try posixPermissions(at: preferencesURL.appendingPathExtension("bak")), 0o600) } + func testValidPrimaryLoadRestrictsExistingValidBackupPermissions() throws { + let preferencesURL = temporaryPreferencesPath() + let directory = preferencesURL.deletingLastPathComponent() + defer { + try? FileManager.default.setAttributes( + [.posixPermissions: NSNumber(value: 0o700)], + ofItemAtPath: directory.path + ) + try? FileManager.default.removeItem(at: directory) + } + try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) + + let primary = AppPreferences( + menuBarDisplayMode: .fanIcon, + startupMode: .auto, + notificationSettings: .disabled + ) + let backup = AppPreferences( + menuBarDisplayMode: .temperature, + startupMode: .curve, + notificationSettings: .disabled + ) + try JSONEncoder().encode(primary).write(to: preferencesURL) + try JSONEncoder().encode(backup).write(to: preferencesURL.appendingPathExtension("bak")) + try FileManager.default.setAttributes( + [.posixPermissions: NSNumber(value: 0o644)], + ofItemAtPath: preferencesURL.path + ) + try FileManager.default.setAttributes( + [.posixPermissions: NSNumber(value: 0o644)], + ofItemAtPath: preferencesURL.appendingPathExtension("bak").path + ) + try FileManager.default.setAttributes( + [.posixPermissions: NSNumber(value: 0o755)], + ofItemAtPath: directory.path + ) + + let result = try AppPreferencesStore(url: preferencesURL, legacyDefaults: nil).loadResult() + + XCTAssertEqual(result.preferences, primary) + XCTAssertEqual(try posixPermissions(at: directory), 0o700) + XCTAssertEqual(try posixPermissions(at: preferencesURL), 0o600) + XCTAssertEqual(try posixPermissions(at: preferencesURL.appendingPathExtension("bak")), 0o600) + } + + func testCorruptPrimaryAndBackupUseVisibleDefaultsRecoveryState() throws { + let preferencesURL = temporaryPreferencesPath() + let directory = preferencesURL.deletingLastPathComponent() + defer { try? FileManager.default.removeItem(at: directory) } + try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) + try Data("corrupt primary".utf8).write(to: preferencesURL) + try Data("corrupt backup".utf8).write(to: preferencesURL.appendingPathExtension("bak")) + + let model = AppModel( + preferencesStore: AppPreferencesStore(url: preferencesURL, legacyDefaults: nil) + ) + + XCTAssertEqual(model.menuBarDisplayMode, AppPreferences.defaults.menuBarDisplayMode) + XCTAssertTrue(model.appPreferencesRecoveryMessage?.localizedCaseInsensitiveContains("defaults") == true) + XCTAssertNil(model.appPreferencesPersistenceMessage) + XCTAssertNil(model.lastError) + } + func testPreferenceSaveFailureIsSeparateAndRetryClearsMessage() throws { let root = temporaryPreferencesPath().deletingLastPathComponent() try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) diff --git a/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift b/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift index abbcc0bd..33b46801 100644 --- a/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift +++ b/Tests/ViftyCoreTests/DaemonInstallServiceTests.swift @@ -88,13 +88,14 @@ final class DaemonInstallServiceTests: XCTestCase { let resultBox = ProcessOutputBox() let completion = expectation(description: "high-output process completes") let maximumBytesPerStream = 64 * 1_024 - Task { + let task = Task { defer { completion.fulfill() } - await resultBox.set(try? await DaemonInstallProcessRunner.system.run(script, [], Data("input\n".utf8))) + resultBox.set(try? await DaemonInstallProcessRunner.system.run(script, [], Data("input\n".utf8))) } + defer { task.cancel() } await fulfillment(of: [completion], timeout: 2) - let output = await resultBox.value + let output = resultBox.value let result = try XCTUnwrap(output) XCTAssertEqual(result.terminationStatus, 0) XCTAssertEqual(result.standardOutput.utf8.count, maximumBytesPerStream) @@ -113,7 +114,7 @@ final class DaemonInstallServiceTests: XCTestCase { let resultBox = ProcessFailureBox() let completion = expectation(description: "stdin failure cleanup completes") let startedAt = Date() - Task { + let task = Task { defer { completion.fulfill() } do { _ = try await DaemonInstallProcessRunner.system.run( @@ -121,15 +122,16 @@ final class DaemonInstallServiceTests: XCTestCase { [], Data(repeating: 0, count: 1 * 1_024 * 1_024) ) - await resultBox.set(threw: false) + resultBox.set(threw: false) } catch { - await resultBox.set(threw: true) + resultBox.set(threw: true) } } + defer { task.cancel() } await fulfillment(of: [completion], timeout: 2) XCTAssertLessThan(Date().timeIntervalSince(startedAt), 1.25) - let didThrow = await resultBox.threw + let didThrow = resultBox.threw XCTAssertTrue(didThrow) } @@ -272,18 +274,28 @@ private actor InstallRunnerRecorder { } } -private actor ProcessOutputBox { - private(set) var value: DaemonInstallProcessOutput? +private final class ProcessOutputBox: @unchecked Sendable { + private let lock = NSLock() + private var storedValue: DaemonInstallProcessOutput? + + var value: DaemonInstallProcessOutput? { + lock.withLock { storedValue } + } func set(_ value: DaemonInstallProcessOutput?) { - self.value = value + lock.withLock { storedValue = value } } } -private actor ProcessFailureBox { - private(set) var threw = false +private final class ProcessFailureBox: @unchecked Sendable { + private let lock = NSLock() + private var storedThrew = false + + var threw: Bool { + lock.withLock { storedThrew } + } func set(threw: Bool) { - self.threw = threw + lock.withLock { storedThrew = threw } } } diff --git a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift index 5e2e4a53..1eb10049 100644 --- a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift @@ -14,6 +14,7 @@ final class ViftyCtlRunnerTests: XCTestCase { XCTAssertEqual(ViftyCtlCommandErrorRecoveryAction.recommended(for: .childCommandFailed), .fixChildCommand) XCTAssertEqual(ViftyCtlCommandErrorRecoveryAction.recommended(for: .restoreRequested), .restoreAutoBeforeRetry) XCTAssertEqual(ViftyCtlCommandErrorRecoveryAction.recommended(for: .prepareRateLimited), .waitBeforeRetry) + XCTAssertEqual(ViftyCtlCommandErrorRecoveryAction.recommended(for: .persistenceFailure), .runDiagnose) XCTAssertEqual(ViftyCtlCommandErrorRecoveryAction.recommended(for: .thermalCritical), .runDiagnose) XCTAssertEqual(ViftyCtlCommandErrorRecoveryAction.recommended(for: nil), .runDiagnose) } @@ -492,6 +493,50 @@ final class ViftyCtlRunnerTests: XCTestCase { XCTAssertEqual(policy["maxDurationSeconds"] as? Int, 1_800) } + func testCapabilitiesHumanReadableDescribesPolicyPersistenceWhenDaemonResponds() async throws { + let runner = ViftyCtlRunner( + client: FakeAgentControlClient(status: AgentControlStatus( + enabled: true, + activeLease: nil, + lastDecision: nil, + lastErrorCode: .persistenceFailure, + policy: AgentControlPolicy(enabled: true).snapshot, + persistenceHealth: AgentControlPersistenceHealth( + policyStatusAvailable: false, + policyError: "policy file unreadable", + auditStatusAvailable: true, + auditError: nil + ) + )), + processRunner: FakeProcessRunner() + ) + + let result = try await runner.run(.capabilities(json: false)) + + XCTAssertEqual(result.exitCode, 69) + XCTAssertTrue(result.stderr.contains("policy persistence unavailable")) + XCTAssertTrue(result.stderr.contains("policy file unreadable")) + XCTAssertFalse(result.stderr.contains("daemon status unavailable")) + } + + func testCapabilitiesJSONBoundsDaemonRequestError() async throws { + let originalMessage = String(repeating: "x", count: AgentControlRequest.maximumReasonLength + 100) + let runner = ViftyCtlRunner( + client: FakeAgentControlClient( + statusError: ViftyError.helperRejected(originalMessage) + ), + processRunner: FakeProcessRunner() + ) + + let result = try await runner.run(.capabilities(json: true)) + + let data = try XCTUnwrap(result.stdout.data(using: .utf8)) + let json = try XCTUnwrap(JSONSerialization.jsonObject(with: data) as? [String: Any]) + let message = try XCTUnwrap(json["agentControlStatusError"] as? String) + XCTAssertEqual(message.count, AgentControlRequest.maximumReasonLength) + XCTAssertTrue(message.hasSuffix(String(repeating: "x", count: 20))) + } + func testCapabilitiesHumanReadableReturnsCommandsAndUnavailableExitWhenDaemonStatusUnavailable() async throws { let runner = ViftyCtlRunner( client: FakeAgentControlClient( diff --git a/Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift b/Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift index 20fc761a..cf738693 100644 --- a/Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift +++ b/Tests/ViftyCoreTests/XPCAgentControlCodingTests.swift @@ -42,6 +42,30 @@ final class XPCAgentControlCodingTests: XCTestCase { XCTAssertEqual(decoded?.policy?.maximumAllowedRPMPercent, 75) } + func testPersistenceFailureRoundTripsThroughJSONAndXPC() throws { + let status = AgentControlStatus( + enabled: false, + activeLease: nil, + lastDecision: .denied(.persistenceFailure, message: "policy unreadable"), + lastErrorCode: .persistenceFailure, + policy: AgentControlPolicy(enabled: false).snapshot, + persistenceHealth: AgentControlPersistenceHealth( + policyStatusAvailable: false, + policyError: "policy unreadable", + auditStatusAvailable: true, + auditError: nil + ) + ) + + let json = try JSONDecoder().decode( + AgentControlStatus.self, + from: JSONEncoder().encode(status) + ) + + XCTAssertEqual(json, status) + XCTAssertEqual(XPCAgentControlCoding.decodeStatus(XPCAgentControlCoding.encode(status)), status) + } + func testOlderStatusWithoutLeaseStillDecodes() { let dictionary: NSDictionary = ["enabled": true] From 71ec76b83628c8659c46259be6e466a125ae80a0 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 19:48:02 +0200 Subject: [PATCH 12/27] fix: report unavailable hardware truthfully --- Sources/ViftyCore/AgentDiagnostics.swift | 16 +++++++++-- .../ViftyCtlJSONExampleTests.swift | 27 +++++++++++++++++++ .../ViftyCoreTests/ViftyCtlRunnerTests.swift | 9 +++++++ 3 files changed, 50 insertions(+), 2 deletions(-) diff --git a/Sources/ViftyCore/AgentDiagnostics.swift b/Sources/ViftyCore/AgentDiagnostics.swift index 2c89acbc..99ff1e71 100644 --- a/Sources/ViftyCore/AgentDiagnostics.swift +++ b/Sources/ViftyCore/AgentDiagnostics.swift @@ -481,7 +481,7 @@ public struct ViftyCtlReadinessReport: Codable, Equatable, Sendable { ownershipStatusError: fanControlOwnershipStatusError ), daemonRuntimeMatchesExpectedCheck(daemonRuntime), - supportedHardwareCheck(snapshot), + supportedHardwareCheck(snapshot, snapshotError: daemonSnapshotError), agentControlEnabledCheck(agentControl), temperatureSensorsPresentCheck(snapshot), controllableFansPresentCheck(controllableFans), @@ -859,7 +859,19 @@ public struct ViftyCtlReadinessReport: Codable, Equatable, Sendable { ) } - private static func supportedHardwareCheck(_ snapshot: HardwareSnapshot) -> ViftyCtlReadinessCheck { + private static func supportedHardwareCheck( + _ snapshot: HardwareSnapshot, + snapshotError: String? + ) -> ViftyCtlReadinessCheck { + guard snapshotError == nil else { + return ViftyCtlReadinessCheck( + id: "supportedHardware", + severity: .error, + passed: false, + message: "Supported hardware could not be determined because the daemon hardware snapshot is unavailable." + ) + } + let passed = snapshot.isAppleSilicon && snapshot.isMacBookPro return ViftyCtlReadinessCheck( id: "supportedHardware", diff --git a/Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift b/Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift index 56ebcc46..e541b37b 100644 --- a/Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlJSONExampleTests.swift @@ -186,6 +186,33 @@ final class ViftyCtlJSONExampleTests: XCTestCase { XCTAssertNil(report.agentControlStatusError) } + func testKnownUnsupportedHardwareRetainsExistingBlockerAndCopy() { + let report = ViftyCtlReadinessReport.make( + snapshot: HardwareSnapshot( + fans: [], + temperatureSensors: [], + modelIdentifier: "Mac14,15", + isAppleSilicon: false, + isMacBookPro: false, + capturedAt: Date(timeIntervalSince1970: 1_000) + ), + agentControl: AgentControlStatus( + enabled: false, + activeLease: nil, + lastDecision: nil, + lastErrorCode: nil + ), + thermalPressure: .nominal, + generatedAt: Date(timeIntervalSince1970: 1_000) + ) + + let check = report.checks.first { $0.id == "supportedHardware" } + XCTAssertEqual(check?.passed, false) + XCTAssertTrue(check?.message.contains("supported only") == true) + XCTAssertTrue(report.failedCheckIDs.contains("supportedHardware")) + XCTAssertTrue(report.coolingBlockerIDs.contains("supportedHardware")) + } + func testDiagnoseBlockedHelperUnreachableExampleDecodesAgainstCurrentModel() throws { let report = try decode(ViftyCtlReadinessReport.self, from: "diagnose-blocked-helper-unreachable.json") diff --git a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift index 1eb10049..40613ac5 100644 --- a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift @@ -890,6 +890,15 @@ final class ViftyCtlRunnerTests: XCTestCase { && (check["passed"] as? Bool) == false && (check["severity"] as? String) == "error" }) + XCTAssertTrue(checks.contains { check in + guard (check["id"] as? String) == "supportedHardware", + let message = check["message"] as? String else { + return false + } + return (check["passed"] as? Bool) == false + && message.contains("could not be determined") + && !message.contains("supported only") + }) } func testDiagnoseJSONReturnsBlockedReportWhenAgentControlStatusFails() async throws { From 355b8d46da081330239155800de0269b61190e9a Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 20:01:44 +0200 Subject: [PATCH 13/27] fix: expose agent audit persistence failures --- Sources/Vifty/AppModel+Control.swift | 10 +++++ Sources/Vifty/SettingsAgentWorkflowView.swift | 11 +++++ Sources/ViftyCore/AgentControlService.swift | 22 +++++++++- Sources/ViftyCore/ViftyCoreLog.swift | 1 + .../AgentControlServiceTests.swift | 43 ++++++++++++++++++- .../AppModelFanControlTests.swift | 23 ++++++++++ .../AppSourceRegressionTests.swift | 10 +++++ .../ViftyCoreTests/ViftyCtlRunnerTests.swift | 38 ++++++++++++++++ 8 files changed, 155 insertions(+), 3 deletions(-) diff --git a/Sources/Vifty/AppModel+Control.swift b/Sources/Vifty/AppModel+Control.swift index b679e344..95f225fe 100644 --- a/Sources/Vifty/AppModel+Control.swift +++ b/Sources/Vifty/AppModel+Control.swift @@ -461,6 +461,16 @@ extension AppModel { } } + var agentAuditPersistenceMessage: String? { + guard let health = agentControlStatus?.persistenceHealth, + !health.auditStatusAvailable else { return nil } + let detail = health.auditError?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" + guard !detail.isEmpty else { + return "Agent audit history unavailable; cooling control is unchanged." + } + return "Agent audit history unavailable; cooling control is unchanged. " + detail + } + func setAgentCoolingEnabled(_ enabled: Bool) async { do { guard let status = try await agentPolicySetter(enabled) else { return } diff --git a/Sources/Vifty/SettingsAgentWorkflowView.swift b/Sources/Vifty/SettingsAgentWorkflowView.swift index 004e3556..c07c3f2e 100644 --- a/Sources/Vifty/SettingsAgentWorkflowView.swift +++ b/Sources/Vifty/SettingsAgentWorkflowView.swift @@ -32,6 +32,17 @@ struct SettingsAgentWorkflowView: View { ) .disabled(model.agentCoolingEnabled == nil) .accessibilityIdentifier(ViftyAccessibilityIdentifier.agentCoolingEnabled) + + if let message = model.agentAuditPersistenceMessage { + Label { + Text(message) + } icon: { + Image(systemName: "exclamationmark.triangle") + } + .foregroundStyle(.orange) + .fixedSize(horizontal: false, vertical: true) + .accessibilityLabel("Agent audit persistence needs attention") + } } Section("Commands") { diff --git a/Sources/ViftyCore/AgentControlService.swift b/Sources/ViftyCore/AgentControlService.swift index 889e42c4..ebe86783 100644 --- a/Sources/ViftyCore/AgentControlService.swift +++ b/Sources/ViftyCore/AgentControlService.swift @@ -678,12 +678,30 @@ public actor AgentControlService { } private func appendAudit(action: String, leaseID: String?, message: String) { - try? store.appendAuditEvent(AgentControlAuditEvent( + let event = AgentControlAuditEvent( timestamp: now(), action: action, leaseID: leaseID, message: message - )) + ) + do { + try store.appendAuditEvent(event) + persistenceHealth = AgentControlPersistenceHealth( + policyStatusAvailable: persistenceHealth.policyStatusAvailable, + policyError: persistenceHealth.policyError, + auditStatusAvailable: true, + auditError: nil + ) + } catch { + let auditError = String(error.localizedDescription.prefix(512)) + persistenceHealth = AgentControlPersistenceHealth( + policyStatusAvailable: persistenceHealth.policyStatusAvailable, + policyError: persistenceHealth.policyError, + auditStatusAvailable: false, + auditError: auditError + ) + ViftyCoreLog.agentControl.error("Agent audit persistence failed") + } } private static func normalizedAuditReason(_ reason: String, fallback: String) -> String { diff --git a/Sources/ViftyCore/ViftyCoreLog.swift b/Sources/ViftyCore/ViftyCoreLog.swift index 22b5b70d..67c396b7 100644 --- a/Sources/ViftyCore/ViftyCoreLog.swift +++ b/Sources/ViftyCore/ViftyCoreLog.swift @@ -2,4 +2,5 @@ import OSLog enum ViftyCoreLog { static let xpc = Logger(subsystem: "tech.reidar.vifty", category: "XPC") + static let agentControl = Logger(subsystem: "tech.reidar.vifty", category: "AgentControl") } diff --git a/Tests/ViftyCoreTests/AgentControlServiceTests.swift b/Tests/ViftyCoreTests/AgentControlServiceTests.swift index eb41893f..153d7b54 100644 --- a/Tests/ViftyCoreTests/AgentControlServiceTests.swift +++ b/Tests/ViftyCoreTests/AgentControlServiceTests.swift @@ -253,6 +253,40 @@ final class AgentControlServiceTests: XCTestCase { XCTAssertEqual(store.savedPolicies, []) } + func testAuditAppendFailureIsVisibleAndLaterSuccessRecoversWithoutChangingTransactionResult() async throws { + let store = AgentControlFaultStore(directory: temporaryDirectory()) + store.auditErrorsRemaining = 1 + let hardware = AgentServiceFakeHardware(snapshot: Self.snapshot(fans: [Self.fan(id: 0, minimumRPM: 1500, maximumRPM: 4500)])) + let service = AgentControlService( + hardware: hardware, + policy: AgentControlPolicy(enabled: true), + store: store, + thermalReader: { .nominal }, + now: { Date(timeIntervalSince1970: 1_000) }, + leaseID: { "lease-1" } + ) + let request = AgentControlRequest( + workload: .build, + durationSeconds: 600, + maxRPMPercent: 75, + reason: "Build", + idempotencyKey: "audit-failure" + ) + + let prepared = try await service.prepare(request) + + XCTAssertNotNil(prepared.activeLease) + XCTAssertFalse(prepared.persistenceHealth.auditStatusAvailable) + XCTAssertNotNil(prepared.persistenceHealth.auditError) + + let restored = try await service.restoreAuto(reason: "Finished") + + XCTAssertNil(restored.activeLease) + XCTAssertTrue(restored.persistenceHealth.auditStatusAvailable) + XCTAssertNil(restored.persistenceHealth.auditError) + XCTAssertEqual(restored.lastErrorCode, nil) + } + func testFailedDisableSaveRestoresActiveLeaseAndSuccessfulRetryPublishesToggle() async throws { let store = AgentControlFaultStore(directory: temporaryDirectory()) store.loadedPolicy = .success(true) @@ -1923,6 +1957,7 @@ private final class AgentControlFaultStore: AgentControlPersisting, @unchecked S var loadedPolicy: Result = .success(nil) var savePolicyError: AgentControlFault? var savedPolicies: [Bool] = [] + var auditErrorsRemaining = 0 init(directory: URL) { self.base = AgentControlStore(directory: directory) @@ -1930,7 +1965,13 @@ private final class AgentControlFaultStore: AgentControlPersisting, @unchecked S func saveActiveLease(_ lease: AgentCoolingLease?) throws { try base.saveActiveLease(lease) } func loadActiveLease() throws -> AgentCoolingLease? { try base.loadActiveLease() } - func appendAuditEvent(_ event: AgentControlAuditEvent) throws { try base.appendAuditEvent(event) } + func appendAuditEvent(_ event: AgentControlAuditEvent) throws { + if auditErrorsRemaining > 0 { + auditErrorsRemaining -= 1 + throw AgentControlFault.savePolicy + } + try base.appendAuditEvent(event) + } func loadRecentAuditEvents(limit: Int) throws -> [AgentControlAuditEvent] { try base.loadRecentAuditEvents(limit: limit) } diff --git a/Tests/ViftyCoreTests/AppModelFanControlTests.swift b/Tests/ViftyCoreTests/AppModelFanControlTests.swift index 36c23d1a..33158d37 100644 --- a/Tests/ViftyCoreTests/AppModelFanControlTests.swift +++ b/Tests/ViftyCoreTests/AppModelFanControlTests.swift @@ -478,6 +478,29 @@ final class AppModelFanControlTests: XCTestCase { XCTAssertEqual(model.agentCoolingRestoreActionHelp, "Restore Auto before starting another agent workload") } + func testAuditPersistenceFailureIsPresentedWithoutBlockingCoolingStatus() { + let model = AppModel() + model.agentControlStatus = AgentControlStatus( + enabled: true, + activeLease: nil, + lastDecision: nil, + lastErrorCode: nil, + persistenceHealth: AgentControlPersistenceHealth( + policyStatusAvailable: true, + policyError: nil, + auditStatusAvailable: false, + auditError: "audit file unavailable" + ) + ) + + XCTAssertEqual( + model.agentAuditPersistenceMessage, + "Agent audit history unavailable; cooling control is unchanged. audit file unavailable" + ) + XCTAssertFalse(model.agentCoolingNeedsAttention) + XCTAssertNil(model.agentCoolingSummary) + } + func testAgentCoolingSummaryIncludesWorkloadAndSortedTargets() { let model = AppModel(now: { Date(timeIntervalSince1970: 1200) }) model.agentControlStatus = AgentControlStatus( diff --git a/Tests/ViftyCoreTests/AppSourceRegressionTests.swift b/Tests/ViftyCoreTests/AppSourceRegressionTests.swift index a90744ab..9ca8668e 100644 --- a/Tests/ViftyCoreTests/AppSourceRegressionTests.swift +++ b/Tests/ViftyCoreTests/AppSourceRegressionTests.swift @@ -23,6 +23,16 @@ final class AppSourceRegressionTests: XCTestCase { XCTAssertTrue(general.contains("Settings recovered")) } + func testAgentSettingsSurfacesAuditPersistenceAttentionWithoutChangingCoolingPolicy() throws { + let settings = try read("Sources/Vifty/SettingsAgentWorkflowView.swift") + let control = try read("Sources/Vifty/AppModel+Control.swift") + + XCTAssertTrue(settings.contains("model.agentAuditPersistenceMessage")) + XCTAssertTrue(settings.contains("Agent audit persistence needs attention")) + XCTAssertTrue(control.contains("auditStatusAvailable")) + XCTAssertTrue(control.contains("cooling control is unchanged")) + } + private func read(_ relativePath: String) throws -> String { let testFile = URL(fileURLWithPath: #filePath) let repositoryRoot = testFile diff --git a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift index 40613ac5..e1519dab 100644 --- a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift @@ -624,6 +624,44 @@ final class ViftyCtlRunnerTests: XCTestCase { XCTAssertEqual(restoreReasonCount, 0) } + func testDiagnoseExposesAuditPersistenceHealthWithoutChangingCoolingReadiness() async throws { + let client = FakeAgentControlClient( + snapshot: Self.readySnapshot(), + status: AgentControlStatus( + enabled: true, + activeLease: nil, + lastDecision: nil, + lastErrorCode: nil, + policy: AgentControlPolicy(enabled: true).snapshot, + persistenceHealth: AgentControlPersistenceHealth( + policyStatusAvailable: true, + policyError: nil, + auditStatusAvailable: false, + auditError: "audit file unavailable" + ) + ) + ) + let runner = ViftyCtlRunner( + client: client, + processRunner: FakeProcessRunner(), + thermalReader: { .nominal }, + manualControlActiveReader: { false } + ) + + let result = try await runner.run(.diagnose(json: true)) + + XCTAssertEqual(result.exitCode, 0) + let json = try jsonObject(in: result.stdout) + XCTAssertEqual(json["safeToRequestCooling"] as? Bool, true) + XCTAssertEqual(json["state"] as? String, "ready") + let agentControl = try XCTUnwrap(json["agentControl"] as? [String: Any]) + let persistenceHealth = try XCTUnwrap(agentControl["persistenceHealth"] as? [String: Any]) + XCTAssertEqual(persistenceHealth["auditStatusAvailable"] as? Bool, false) + XCTAssertEqual(persistenceHealth["auditError"] as? String, "audit file unavailable") + let checks = try XCTUnwrap(json["checks"] as? [[String: Any]]) + XCTAssertFalse(checks.contains { ($0["id"] as? String)?.localizedCaseInsensitiveContains("audit") == true }) + } + func testDiagnoseReplacementMaintenanceAttestationDoesNotAssumeTwoFans() async throws { var snapshot = Self.readySnapshot() snapshot.fans = Array(snapshot.fans.prefix(1)) From 9f74794dba755f462c65088d38802d0bc5725537 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 20:11:46 +0200 Subject: [PATCH 14/27] feat: add viftyctl help --- Sources/ViftyCore/ViftyCtlArguments.swift | 11 ++++++++++ Sources/ViftyCore/ViftyCtlRunner.swift | 6 ++++++ .../ViftyCtlArgumentsTests.swift | 6 ++++++ .../ViftyCoreTests/ViftyCtlRunnerTests.swift | 21 +++++++++++++++++++ docs/agent-workflows.md | 1 + 5 files changed, 45 insertions(+) diff --git a/Sources/ViftyCore/ViftyCtlArguments.swift b/Sources/ViftyCore/ViftyCtlArguments.swift index 00050cbb..746f612d 100644 --- a/Sources/ViftyCore/ViftyCtlArguments.swift +++ b/Sources/ViftyCore/ViftyCtlArguments.swift @@ -1,6 +1,7 @@ import Foundation public enum ViftyCtlCommand: Equatable, Sendable { + case help case status(json: Bool) case capabilities(json: Bool) case agentRule(json: Bool) @@ -16,6 +17,11 @@ public enum ViftyCtlCommand: Equatable, Sendable { public enum ViftyCtlArguments { public static let defaultAuditLimit = 20 + public static let usage = """ + Usage: viftyctl [options] + Commands: status, capabilities, agent-rule, diagnose, audit, prepare, restore-auto, run + Run 'viftyctl agent-rule' for the guarded agent workflow. + """ public static func parse(_ arguments: [String]) throws -> ViftyCtlCommand { guard let command = arguments.first else { @@ -25,6 +31,11 @@ public enum ViftyCtlArguments { let rest = Array(arguments.dropFirst()) switch command { + case "help", "--help", "-h": + guard rest.isEmpty else { + throw ViftyCtlParseError.unexpectedArgument(rest[0]) + } + return .help case "status": try validateOptions(rest, flagOnly: ["--json"], valueFlags: []) return .status(json: rest.contains("--json")) diff --git a/Sources/ViftyCore/ViftyCtlRunner.swift b/Sources/ViftyCore/ViftyCtlRunner.swift index f43b3814..bd0f2421 100644 --- a/Sources/ViftyCore/ViftyCtlRunner.swift +++ b/Sources/ViftyCore/ViftyCtlRunner.swift @@ -1398,6 +1398,8 @@ public struct ViftyCtlRunner: Sendable { public func run(_ command: ViftyCtlCommand) async throws -> ViftyCtlResult { do { switch command { + case .help: + return ViftyCtlResult(stdout: ViftyCtlArguments.usage + "\n") case .status(let json): let status = try await client.status() let stdout = try formatStatus(status, json: json) @@ -1641,6 +1643,8 @@ public struct ViftyCtlRunner: Sendable { private func jsonRequested(for command: ViftyCtlCommand) -> Bool { switch command { + case .help: + return false case .status(let json), .capabilities(let json), .agentRule(let json), @@ -1661,6 +1665,8 @@ public struct ViftyCtlRunner: Sendable { private func commandName(for command: ViftyCtlCommand) -> String { switch command { + case .help: + return "help" case .status: return "status" case .capabilities: diff --git a/Tests/ViftyCoreTests/ViftyCtlArgumentsTests.swift b/Tests/ViftyCoreTests/ViftyCtlArgumentsTests.swift index 33ba25c7..5315853b 100644 --- a/Tests/ViftyCoreTests/ViftyCtlArgumentsTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlArgumentsTests.swift @@ -10,6 +10,12 @@ final class ViftyCtlArgumentsTests: XCTestCase { assertParseError(["frobnicate"], equals: .unknownCommand("frobnicate")) } + func testParsesHelpAliases() throws { + XCTAssertEqual(try ViftyCtlArguments.parse(["help"]), .help) + XCTAssertEqual(try ViftyCtlArguments.parse(["--help"]), .help) + XCTAssertEqual(try ViftyCtlArguments.parse(["-h"]), .help) + } + func testParsesStatusJSON() throws { let command = try ViftyCtlArguments.parse(["status", "--json"]) diff --git a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift index e1519dab..89a1d5b0 100644 --- a/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlRunnerTests.swift @@ -113,6 +113,27 @@ final class ViftyCtlRunnerTests: XCTestCase { XCTAssertTrue(result.stdout.contains("agent-rule")) } + func testHelpAliasesReturnIdenticalCanonicalUsage() async throws { + let runner = ViftyCtlRunner( + client: FakeAgentControlClient(), + processRunner: FakeProcessRunner() + ) + + var outputs: [String] = [] + for argument in ["help", "--help", "-h"] { + let command = try ViftyCtlArguments.parse([argument]) + let result = try await runner.run(command) + XCTAssertEqual(result.exitCode, 0) + XCTAssertEqual(result.stderr, "") + XCTAssertTrue(result.stdout.hasSuffix("\n")) + outputs.append(result.stdout) + } + + XCTAssertEqual(Set(outputs).count, 1) + XCTAssertEqual(outputs.first, ViftyCtlArguments.usage + "\n") + XCTAssertFalse(outputs[0].contains("helper-maintenance")) + } + func testAgentRuleReturnsPasteableRuleWithoutDaemonMutation() async throws { let client = FakeAgentControlClient( status: AgentControlStatus( diff --git a/docs/agent-workflows.md b/docs/agent-workflows.md index e4f42ab4..57b80001 100644 --- a/docs/agent-workflows.md +++ b/docs/agent-workflows.md @@ -67,6 +67,7 @@ Vifty never exposes raw SMC writes through `viftyctl`. Agents request intent: wo ## Commands ```sh +viftyctl help viftyctl status --json viftyctl capabilities --json viftyctl agent-rule --json From f94d8464748e9e64438e238bce4c8c28ccfd7c7f Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 20:27:37 +0200 Subject: [PATCH 15/27] test: reject Swift test warnings --- Makefile | 5 +++-- Tests/ViftyCoreTests/AgentControlServiceTests.swift | 2 +- Tests/ViftyCoreTests/MakefileTrustGateTests.swift | 3 +++ 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/Makefile b/Makefile index af8b70ba..4ee146c1 100644 --- a/Makefile +++ b/Makefile @@ -18,6 +18,7 @@ RELEASE_SWIFT_PLATFORM_DIR ?= $(RELEASE_ARCHITECTURE)-apple-macosx SWIFT_TRIPLE_ARGS = $(if $(filter release,$(CONFIGURATION)),--triple "$(RELEASE_SWIFT_TRIPLE)",) SWIFT_PROVENANCE_ARGS = $(if $(SWIFT_BUILD_PROVENANCE_FILE),-Xlinker -sectcreate -Xlinker __TEXT -Xlinker __vifty_src -Xlinker "$(SWIFT_BUILD_PROVENANCE_FILE)",) SWIFT_BUILD_ARGS = $(if $(SWIFT_BUILD_PATH),--build-path "$(SWIFT_BUILD_PATH)",) $(SWIFT_TRIPLE_ARGS) $(SWIFT_PROVENANCE_ARGS) $(SWIFT_BUILD_EXTRA_ARGS) +SWIFT_TEST_WARNING_ARGS = -Xswiftc -warnings-as-errors # SwiftPM's product layout is toolchain-dependent (for example, Xcode 26 # places release products under .build/out/Products/Release). Ask SwiftPM for # the path it actually selected, while preserving explicit caller overrides. @@ -264,10 +265,10 @@ source-first-readiness: ## Check published source-first release readiness test: test-full ## Run the full XCTest suite test-fast: check-toolchain ## Run the fast local XCTest suite - swift test $(SWIFT_BUILD_ARGS) $(SLOW_TEST_SKIP_ARGS) + swift test $(SWIFT_BUILD_ARGS) $(SLOW_TEST_SKIP_ARGS) $(SWIFT_TEST_WARNING_ARGS) test-full: check-toolchain ## Run the full XCTest suite, including slow evidence/release script tests - swift test $(SWIFT_BUILD_ARGS) + swift test $(SWIFT_BUILD_ARGS) $(SWIFT_TEST_WARNING_ARGS) verify: check-toolchain ## Run fast local trust gates without installing /bin/bash -n scripts/*.sh scripts/lib/*.sh examples/viftyctl/*.sh diff --git a/Tests/ViftyCoreTests/AgentControlServiceTests.swift b/Tests/ViftyCoreTests/AgentControlServiceTests.swift index 153d7b54..5a0d2993 100644 --- a/Tests/ViftyCoreTests/AgentControlServiceTests.swift +++ b/Tests/ViftyCoreTests/AgentControlServiceTests.swift @@ -107,7 +107,7 @@ final class AgentControlServiceTests: XCTestCase { XCTAssertEqual(disabled.policy?.enabled, false) XCTAssertEqual(try store.loadAgentControlEnabled(), false) - let status = try await service.status() + let status = await service.status() XCTAssertEqual(status.policy?.enabled, false) } diff --git a/Tests/ViftyCoreTests/MakefileTrustGateTests.swift b/Tests/ViftyCoreTests/MakefileTrustGateTests.swift index b01f4ec9..6a69468e 100644 --- a/Tests/ViftyCoreTests/MakefileTrustGateTests.swift +++ b/Tests/ViftyCoreTests/MakefileTrustGateTests.swift @@ -105,6 +105,9 @@ final class MakefileTrustGateTests: XCTestCase { XCTAssertTrue(makefile.contains("/bin/bash -n scripts/*.sh scripts/lib/*.sh examples/viftyctl/*.sh")) XCTAssertTrue(makefile.contains("scripts/check-community-standards.sh")) XCTAssertTrue(makefile.contains("scripts/validate-release-metadata.sh --mode \"$(RELEASE_METADATA_MODE)\"")) + XCTAssertTrue(makefile.contains("SWIFT_TEST_WARNING_ARGS = -Xswiftc -warnings-as-errors")) + XCTAssertTrue(makefile.contains("swift test $(SWIFT_BUILD_ARGS) $(SLOW_TEST_SKIP_ARGS) $(SWIFT_TEST_WARNING_ARGS)")) + XCTAssertTrue(makefile.contains("swift test $(SWIFT_BUILD_ARGS) $(SWIFT_TEST_WARNING_ARGS)")) XCTAssertTrue(makefile.contains("swift test $(SWIFT_BUILD_ARGS) $(SLOW_TEST_SKIP_ARGS)")) XCTAssertTrue(makefile.contains("swift test $(SWIFT_BUILD_ARGS)")) XCTAssertTrue(makefile.contains("$(MAKE) $(VERIFY_TEST_TARGET)")) From 96f2f7791bbeb957753a48aa244176e2829dc5c4 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 20:53:44 +0200 Subject: [PATCH 16/27] test: bind warning flag to test recipes --- .../MakefileTrustGateTests.swift | 43 ++++++++++++++++--- 1 file changed, 38 insertions(+), 5 deletions(-) diff --git a/Tests/ViftyCoreTests/MakefileTrustGateTests.swift b/Tests/ViftyCoreTests/MakefileTrustGateTests.swift index 6a69468e..8507bf82 100644 --- a/Tests/ViftyCoreTests/MakefileTrustGateTests.swift +++ b/Tests/ViftyCoreTests/MakefileTrustGateTests.swift @@ -105,11 +105,10 @@ final class MakefileTrustGateTests: XCTestCase { XCTAssertTrue(makefile.contains("/bin/bash -n scripts/*.sh scripts/lib/*.sh examples/viftyctl/*.sh")) XCTAssertTrue(makefile.contains("scripts/check-community-standards.sh")) XCTAssertTrue(makefile.contains("scripts/validate-release-metadata.sh --mode \"$(RELEASE_METADATA_MODE)\"")) - XCTAssertTrue(makefile.contains("SWIFT_TEST_WARNING_ARGS = -Xswiftc -warnings-as-errors")) - XCTAssertTrue(makefile.contains("swift test $(SWIFT_BUILD_ARGS) $(SLOW_TEST_SKIP_ARGS) $(SWIFT_TEST_WARNING_ARGS)")) - XCTAssertTrue(makefile.contains("swift test $(SWIFT_BUILD_ARGS) $(SWIFT_TEST_WARNING_ARGS)")) - XCTAssertTrue(makefile.contains("swift test $(SWIFT_BUILD_ARGS) $(SLOW_TEST_SKIP_ARGS)")) - XCTAssertTrue(makefile.contains("swift test $(SWIFT_BUILD_ARGS)")) + let contractViolations = warningContractViolations(in: makefile) + XCTAssertEqual(contractViolations, []) + let unboundMakefile = makefile.replacingOccurrences(of: " $(SWIFT_TEST_WARNING_ARGS)", with: "") + XCTAssertFalse(warningContractViolations(in: unboundMakefile).isEmpty) XCTAssertTrue(makefile.contains("$(MAKE) $(VERIFY_TEST_TARGET)")) XCTAssertTrue(makefile.contains("verify-full: VERIFY_TEST_TARGET = test-full")) XCTAssertTrue(makefile.contains("verify-full: verify")) @@ -296,4 +295,38 @@ final class MakefileTrustGateTests: XCTestCase { .appendingPathComponent(relativePath) return try String(contentsOf: url, encoding: .utf8) } + + private func warningContractViolations(in makefile: String) -> [String] { + let lines = makefile.components(separatedBy: "\n") + var violations: [String] = [] + let expectedDefinition = "SWIFT_TEST_WARNING_ARGS = -Xswiftc -warnings-as-errors" + let definitions = lines.filter { line in + line.hasPrefix("SWIFT_TEST_WARNING_ARGS") && line.contains("=") + } + if definitions.count != 1 || definitions.first != expectedDefinition { + violations.append("warning argument definition must appear exactly once") + } + + for (target, expectedRecipe) in [ + ("test-fast", "\tswift test $(SWIFT_BUILD_ARGS) $(SLOW_TEST_SKIP_ARGS) $(SWIFT_TEST_WARNING_ARGS)"), + ("test-full", "\tswift test $(SWIFT_BUILD_ARGS) $(SWIFT_TEST_WARNING_ARGS)") + ] { + let headers = lines.indices.filter { lines[$0].hasPrefix("\(target):") } + guard headers.count == 1, let header = headers.first else { + violations.append("\(target) target must appear exactly once") + continue + } + var block = [lines[header]] + var index = header + 1 + while index < lines.count, lines[index].isEmpty || lines[index].hasPrefix("\t") { + block.append(lines[index]) + index += 1 + } + let swiftTestRecipes = block.filter { $0.hasPrefix("\tswift test ") } + if swiftTestRecipes != [expectedRecipe] { + violations.append("\(target) recipe must invoke Swift tests with warning arguments") + } + } + return violations + } } From b8981cdc984c6c005eaaf779ca16d7486097f763 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 22:04:43 +0200 Subject: [PATCH 17/27] test: cover hosted UI observation lifecycle --- .../ViftyReviewFixtureTests.swift | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift b/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift index 02505055..61597921 100644 --- a/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift +++ b/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift @@ -97,6 +97,7 @@ final class ViftyReviewFixtureTests: XCTestCase { let root = fixtureRoot() defer { try? FileManager.default.removeItem(at: root) } let executable = try writeExecutableFixture(in: root) + // Match the observed WindowServer setting so this test isolates lifecycle scheduling. let request = try fixtureRequest( root: root, captureID: "capture-schema-v3", @@ -162,6 +163,61 @@ final class ViftyReviewFixtureTests: XCTestCase { XCTAssertEqual(stabilizer.consume(matching, request: request), matching) } + func testHostedSceneSchedulesObservationAfterPreparation() async throws { + let root = fixtureRoot() + defer { try? FileManager.default.removeItem(at: root) } + let executable = try writeExecutableFixture(in: root) + let request = try fixtureRequest( + root: root, + captureID: "capture-hosted-scene", + transparency: .reduced + ) + let runtime = try ViftyReviewFixtureRuntime( + request: request, + executableURL: executable, + processIdentifier: 42 + ) + + try await runtime.prepare() + + let window = NSWindow( + contentRect: NSRect(origin: .zero, size: request.window.size), + styleMask: [.titled, .closable], + backing: .buffered, + defer: false + ) + window.isReleasedWhenClosed = false + let hostingView = NSHostingView( + rootView: ViftyReviewFixtureSceneHost( + runtime: runtime, + provenance: "swiftui-main-window" + ) { + Color.clear + } + ) + window.contentView = hostingView + window.orderFrontRegardless() + window.displayIfNeeded() + defer { + window.orderOut(nil) + window.close() + } + + let deadline = Date().addingTimeInterval(2) + while !runtime.hasReadyObservation, Date() < deadline { + try await Task.sleep(for: .milliseconds(20)) + } + + XCTAssertTrue(runtime.hasReadyObservation) + let report = runtime.report(phase: "current") + XCTAssertTrue(report.passed) + XCTAssertTrue(report.modelStartSkipped) + XCTAssertEqual(report.runtimeIdentity?.provenance, "swiftui-main-window") + XCTAssertTrue(report.recorder.attemptedHardwareCommands.isEmpty) + XCTAssertTrue(report.recorder.attemptedExternalMutations.isEmpty) + XCTAssertTrue(report.recorder.realControlPathConstructions.isEmpty) + } + func testWindowConfiguratorOverridesRestoredMainAndSettingsGeometry() throws { let root = fixtureRoot() defer { try? FileManager.default.removeItem(at: root) } @@ -1351,6 +1407,7 @@ final class ViftyReviewFixtureTests: XCTestCase { state: ViftyReviewFixtureState = .healthyAuto, surface: ViftyReviewFixtureSurface = .main, window: ViftyReviewFixtureWindow = .standard, + transparency: ViftyReviewFixtureTransparency = .standard, interaction: ViftyReviewFixtureInteraction = .none, expectedExecutableSHA256: String? = nil ) throws -> ViftyReviewFixtureRequest { @@ -1359,6 +1416,7 @@ final class ViftyReviewFixtureTests: XCTestCase { "--ui-review-fixture", state.rawValue, "--ui-review-surface", surface.rawValue, "--ui-review-window", window.rawValue, + "--ui-review-transparency", transparency.rawValue, "--ui-review-interaction", interaction.rawValue, "--ui-review-capture-id", captureID, "--ui-review-output", root.path From a8771bdf8c274302332f488b7ca0f6b30f5b90a5 Mon Sep 17 00:00:00 2001 From: Reidar Date: Sun, 6 Sep 2026 22:16:47 +0200 Subject: [PATCH 18/27] test: clarify hosted fixture lifecycle comment --- Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift b/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift index 61597921..eacedaa5 100644 --- a/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift +++ b/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift @@ -97,7 +97,6 @@ final class ViftyReviewFixtureTests: XCTestCase { let root = fixtureRoot() defer { try? FileManager.default.removeItem(at: root) } let executable = try writeExecutableFixture(in: root) - // Match the observed WindowServer setting so this test isolates lifecycle scheduling. let request = try fixtureRequest( root: root, captureID: "capture-schema-v3", @@ -167,6 +166,7 @@ final class ViftyReviewFixtureTests: XCTestCase { let root = fixtureRoot() defer { try? FileManager.default.removeItem(at: root) } let executable = try writeExecutableFixture(in: root) + // Match the observed WindowServer setting so this test isolates lifecycle scheduling. let request = try fixtureRequest( root: root, captureID: "capture-hosted-scene", From ea769b2ba6373046d9fd210e16d1ec64ad5d6ab2 Mon Sep 17 00:00:00 2001 From: Reidar Date: Mon, 7 Sep 2026 06:25:28 +0200 Subject: [PATCH 19/27] fix: keep UI review readiness deadlines in one clock domain --- .../ViftyCoreTests/UIReviewEvidenceScriptTests.swift | 12 ++++-------- scripts/lib/ui_review_orchestrator.rb | 9 +++------ 2 files changed, 7 insertions(+), 14 deletions(-) diff --git a/Tests/ViftyCoreTests/UIReviewEvidenceScriptTests.swift b/Tests/ViftyCoreTests/UIReviewEvidenceScriptTests.swift index 1506a87a..4afe5864 100644 --- a/Tests/ViftyCoreTests/UIReviewEvidenceScriptTests.swift +++ b/Tests/ViftyCoreTests/UIReviewEvidenceScriptTests.swift @@ -676,7 +676,7 @@ final class UIReviewEvidenceScriptTests: XCTestCase { XCTAssertEqual(identity["executablePath"] as? String, try canonicalFilesystemPath(fixture.debugExecutable)) } - func testCaptureModePassesPersistenceIsolationArgumentsToFixtureProcess() throws { + func testCaptureModeDoesNotPassCrossRuntimeReadinessDeadlineToFixtureProcess() throws { let fixture = try orchestrationFixture(mode: .successful) defer { try? FileManager.default.removeItem(at: fixture.root) } @@ -703,14 +703,10 @@ final class UIReviewEvidenceScriptTests: XCTestCase { 1, launchArguments.joined(separator: "\n") ) - let deadlineIndex = try XCTUnwrap( - launchArguments.firstIndex(of: "--ui-review-readiness-deadline-uptime") - ) - let deadlineValue = try XCTUnwrap( - Double(launchArguments[deadlineIndex + 1]) + XCTAssertFalse( + launchArguments.contains("--ui-review-readiness-deadline-uptime"), + launchArguments.joined(separator: "\n") ) - XCTAssertTrue(deadlineValue.isFinite) - XCTAssertGreaterThan(deadlineValue, 0) } func testCaptureModePreservesStructuredReadyTimeoutAndCleansUpChild() throws { diff --git a/scripts/lib/ui_review_orchestrator.rb b/scripts/lib/ui_review_orchestrator.rb index c4682e6c..efdd9981 100644 --- a/scripts/lib/ui_review_orchestrator.rb +++ b/scripts/lib/ui_review_orchestrator.rb @@ -181,7 +181,7 @@ def capture(options) } write_json_atomic(session_path, session, containment_root: evidence_root) - readiness_deadline = monotonic_now + options.fetch(:timeout_seconds) + deadline = monotonic_now + options.fetch(:timeout_seconds) fixture_arguments = fixture_arguments( request: request, capture_id: capture_id, @@ -189,8 +189,7 @@ def capture(options) screenshot_path: screenshot_path, completion_path: completion_path, executable_sha: debug_sha, - timeout_seconds: options.fetch(:fixture_hold_seconds), - readiness_deadline: readiness_deadline + timeout_seconds: options.fetch(:fixture_hold_seconds) ) process_log = open_output_file( process_log_path, @@ -208,7 +207,6 @@ def capture(options) session["processIdentifier"] = pid write_json_atomic(session_path, session, containment_root: evidence_root) - deadline = readiness_deadline report = wait_for_report( path: report_path, phase: "ready", @@ -761,7 +759,7 @@ def requirement_id(row, kind) row[kind == "fixture" ? "state" : "id"] end - def fixture_arguments(request:, capture_id:, output_path:, screenshot_path:, completion_path:, executable_sha:, timeout_seconds:, readiness_deadline:) + def fixture_arguments(request:, capture_id:, output_path:, screenshot_path:, completion_path:, executable_sha:, timeout_seconds:) arguments = [ "-ApplePersistenceIgnoreState", "YES", "--ui-review-fixture", request.fetch("state"), @@ -776,7 +774,6 @@ def fixture_arguments(request:, capture_id:, output_path:, screenshot_path:, com "--ui-review-output", output_path, "--ui-review-completion-file", completion_path, "--ui-review-timeout-seconds", timeout_seconds.to_s, - "--ui-review-readiness-deadline-uptime", readiness_deadline.to_s, "--ui-review-executable-sha256", executable_sha ] arguments.concat(["--ui-review-screenshot", screenshot_path]) if screenshot_path From 78de149fb89fb2c28405f417638b695caa2b193e Mon Sep 17 00:00:00 2001 From: Reidar Date: Mon, 7 Sep 2026 07:06:43 +0200 Subject: [PATCH 20/27] fix: tolerate missing AX descriptions --- Sources/ViftyAXCollector/AXReader.swift | 5 +++-- Tests/ViftyCoreTests/AXCollectorAdapterTests.swift | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/Sources/ViftyAXCollector/AXReader.swift b/Sources/ViftyAXCollector/AXReader.swift index 6c40f60d..0bb58990 100644 --- a/Sources/ViftyAXCollector/AXReader.swift +++ b/Sources/ViftyAXCollector/AXReader.swift @@ -54,6 +54,7 @@ public struct AXSystemReader: AXReadAdapter { static func treatsGenericFailureAsMissing(errorCode: Int32, attribute: String) -> Bool { guard errorCode == AXError.failure.rawValue else { return false } return attribute == AXReadAttribute.identifier + || attribute == AXReadAttribute.description || attribute == AXReadAttribute.valueDescription } @@ -159,8 +160,8 @@ public struct AXSystemReader: AXReadAdapter { var value: CFTypeRef? let error = AXUIElementCopyAttributeValue(element, attribute as CFString, &value) if error == .attributeUnsupported || error == .noValue { return nil } - // SwiftUI can return the generic AX failure when optional identifier - // or value-description metadata is absent instead of returning + // SwiftUI can return the generic AX failure when optional identifier, + // description, or value-description metadata is absent instead of returning // `noValue`. Required identifiers are still enforced by exact target // matching and semantic predicates; every other failure stays closed. if Self.treatsGenericFailureAsMissing(errorCode: error.rawValue, attribute: attribute) { diff --git a/Tests/ViftyCoreTests/AXCollectorAdapterTests.swift b/Tests/ViftyCoreTests/AXCollectorAdapterTests.swift index 87092a25..ac921b61 100644 --- a/Tests/ViftyCoreTests/AXCollectorAdapterTests.swift +++ b/Tests/ViftyCoreTests/AXCollectorAdapterTests.swift @@ -18,7 +18,7 @@ final class AXCollectorAdapterTests: XCTestCase { attribute: AXReadAttribute.identifier ) ) - XCTAssertFalse( + XCTAssertTrue( AXSystemReader.treatsGenericFailureAsMissing( errorCode: -25_200, attribute: AXReadAttribute.description From e5b75764fd84c2e0a70c1d7e60a3033fa999df45 Mon Sep 17 00:00:00 2001 From: Reidar Date: Mon, 7 Sep 2026 07:39:41 +0200 Subject: [PATCH 21/27] Fix update toggle accessibility label --- Sources/Vifty/SettingsGeneralView.swift | 1 + 1 file changed, 1 insertion(+) diff --git a/Sources/Vifty/SettingsGeneralView.swift b/Sources/Vifty/SettingsGeneralView.swift index 2fb73dc5..f704f7c0 100644 --- a/Sources/Vifty/SettingsGeneralView.swift +++ b/Sources/Vifty/SettingsGeneralView.swift @@ -111,6 +111,7 @@ struct SettingsGeneralView: View { isOn: automaticUpdateChecksBinding ) .disabled(!softwareUpdates.canCheck) + .accessibilityLabel("Automatically check for updates") .accessibilityIdentifier( ViftyAccessibilityIdentifier.settingsUpdateAutomatic ) From a5f9c80db805746315e622094d020c1ed33a7e69 Mon Sep 17 00:00:00 2001 From: Reidar Date: Mon, 7 Sep 2026 12:48:00 +0200 Subject: [PATCH 22/27] docs: refresh current Vifty UI evidence checkpoint --- docs/images/vifty-screenshot.png | Bin 346470 -> 100979 bytes docs/ui-review/automated-checkpoint.json | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/images/vifty-screenshot.png b/docs/images/vifty-screenshot.png index 9700aea4882ef9058c4355f6d9acb68470da5fee..e08b1e3cddd3bf4b07d6e5dbcde7a19cfb835224 100644 GIT binary patch literal 100979 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 z zZ7RQ;I;L?{{!=U#K);4t)>##MF!6foEJLem5IegS%V_btaZff7WsU#@@5#-mzl6`% zwr$@3`r2VW+|gu+F&id-tRvnUjKZ624-e$~Lr8VzKQdpaNqMoZd_j0!pjlz+_hfnO zn;f7VsFwv;&!J^t2Ruh)8KUA@&HV6*qLb(suiqwk;SmV8&u`UgY)MZ=MRJvwe|E_U z-23PGv*3rQUx9&p6euF)x+cyUqGyr2EjTpP!L7awM!$^HMkcnS(8<1vDAuVPEA_zY zavDt+&5;*tS6u50aLxP*&P;C<-)q;;RW#ehm!LmIQp=WZ1V$i0A2quh4-xZiOEn72oqZpF z-vDjAD|3n2-dY<iNliuM%O7EhI{UY56+Jb}x~a!R1etX!{YHPcOEP3pV5KUf}$;E%0p}Z*a5A*K4ZB$tojn^n(nxj*^2E zm*nry(SPDeK#n@R8(BK;c@aAR2z4Yx3KbPqQaT_3goCk(HQfi?T4C@QYLw9gKDH0T z`GR9TvAdd!!LRr zWvcJtWa-sHR16- z=_g(Qx7Af?+S?|EPXkF=8LUO?O7qrUCY+svf`r1KIO@DYc^=K)1K6aYK zW@qC`Zy&K%;GNXPq~LazMV7#=H?F>OVWZnNnKP|Gki=4`ItmIV^!b=ahcCviqk2`< z88SDkv~3OYDPGnZ4uZzS9@!igwvZ9GfP7jQ#x~)01*}3sG>apsQ^GlLB48stE*Kx# z_&u-pNH@ePi@3l>8V=oscCpRBdC6zLvYerK8DpLpxQ{)&Qu{ey!{46`e`e6e?(c~xS4`@owN$nhbxiNn29?;{tQm@$pxQ zk&4kjJE6YbE%`W_8scX9Kjb`&65b2a+H|J#O24=$eFxzsw8f6^$#S8In3dJdmqTXN zgAZ-fH%h}3&*;S%#DKr)aHW33$U2ouZM1s-yvw<2m}=G`OLj1mArAX8x+t!D zE@Dh?u_-_Q#xm&?D?|bxpU}RCiSBa6%d(*ClYW`?nLR}23y)x}gW;9e16(V!ibm<LU7vu7M& z+!%D%5Dv7=N>6pPvWhgU{y_ZvgrtXjDYZ)-`A%-}hc#4WChJnLeU&;+zaLeLuj4q7 z5uJkg(wAG>Fgx6D7-!=9%E+Oh&JeMd=^ey5OMVgS#;3gaf<99EJ0%Q8BZ9S}eo`3X zN#H7MxQ*ZZv6ga?>c(z(uHHg)PB7cNMPI`6DfF13?lO5e&e2<}wa>mrP2?F%zS=LR zGSBGOH}|&P@~*F^qeay=zb8v8?%Fy0*jY^q9ZTb!^g5Oh=~V1C1!*rM5pYNTk>}49 z6;lEqZU|{b1l4GydU7w?E+&TMl7q>~r?!D8(2h00ID!pifN zW-Vh3V~V?H*t_M%b3q2r$!PXAI-oV>sfsW8EzX6o%o5%lM3~`78vKBeyYHi*OA!p7!Yz- zBkK7kc4@Is07xmbTl{g}>$&JC9g}|z^qk}${+tEBRQ_L?IEL%>V9BeY;6VqYkxUL&*Jh}ySbFimH~%?D zMxg@plVN_9_tzZ$MV&vAD}}Dt>gX#<+*hMKi^88!@EiixA)`@svr{^idc5;FoHyhm zH7ll9Ik=hXSTs7W3rx5 zvuDE9BdoNHIysqGtFeD~0&}P`QNUXa3l?F38^;f8q+UY(LCxohbENa$I+Av}T$fug z+(C#~Kv@r$F8){NVhIonFx;WXrDk_3A{+(pRlkZpB2K%anrA=#L zGe)W^ScF=U4CS(C3%PTt661*1aC;G?`}P?5J#2haI9?ycxEh|}hB^lKlgxED4^)j; z`Oh7FGX2JmQbNcw(OR}vu|6C>fnp*jz}7Op+5s777qF6u@2NM#Tqnd(<-@6{fJM36 z;v+tD>GkgT8tSHrv@pwYm>2r>P5rMf%P!RKNluGwmcQpwk-eR{q3aIaPSL%06npbxwR6PbTV$<}xq8A+ zP!ecuGkJEtp(h*svFeC)`J?Qm*x${hoZn{fQO%X!4G5@xC)+$DO;>&7pEI#B;$Brc zEjOiK+s$sE_vm^%M4Vj%6r&7<H!l~`Ryrib% z#Cf~iDE>cb92#SAF?0D8d-}cQWPSDP!9KZ7!9p7BvwK*@FeZ6!juZ)t#J4UM3`zkU z>xl`?SbjpOj*6X^NpJX{El)+7YI&+9r0wYK>J+7-8g~1V)OVNn=q9u>V_a4SM4e(t zjTK}wdMIW2;P#g5Ci4nYRv#bkQ(r=q)PJCHPZ}E?z9j6@v?@hYXTdJU7O8Zx81`+a zLBV&`&UPwk7RYmg`kk~axVbir%yDa-^HnB%Y2HO{DBs7}HE0CClEkPiOuS({|!Z*e0Euiz1?g z<*rep)_T*<;<{2iio+SMk%mu1BUS*&(=$~7sBfdQ_2>H%SSJT%WaGU)h zckvTs34ul)Uj_}z0&HE@tGTD(B+Ia(qmsX8BI%)zWH=${;!2DF)?HPof?aIA^lIa3 z2>OUvdVs~Pf62|?`|-NZWrr6J9DhGVq@(HL7{a<%+sN;veUDnNOg1zw00KgG%(X50 zcbC`NWaG1`3u~v0A&6&+2ufh@7QN>G>1Po}zogu4f%%fSi#Z{VVHv(>Hs>3Ks;K{K zHrn^+pf7k;heSu=Np{qjP_hT?NPJi40&2lBx`O*I_JVs7FV}Yq(&6m+Cok+M^UH{zl!6p< zT92nvH6k7lTYG-f*X_QE?wQcfYr*Zu{CPG|QV^FzgX7@9Mtyu3+!kT;gEpFyuQwrP zDHVpGVe|H#5KjKyUMMTwpz03_j8CFZe8ynK}UC(xRxuPD>4^IoSN zwW!_+?`-ElS{@D=igS?={ocS`EG36vdVJ) zWHTJs_rIzLnW!ZDy=}SP9Jot+f`$F z_VSQkH!_61{`#xH?nP6&Prx!;K||~ZCZPc4V*Jl_&t_j#fxQ;Dy=FZuORMcVVjtnI zi%$<=cCnu6ou9%?``L2PyICrutIwwd{pGBX2o#t4bu zvbGe78nj>d5ow%J;HQFdn$1KizN>D!cZsPc^aS4c`_13zZ3RAP8Qxx!=a}$0U^^mc z-P}*D%(MU9C!X=Gb(=wsTk-R+bUWH`CY8bqV+-TA?iDDx6n;-mUxLWKeJzoS&RU2S zCC=$$Q23W*Mei=$L9nTJ@|VAmS*X1bo|%d1jn6w3N-m?vE%|X*?oxqk{E*e9q-vNc z)}ctXX^W=waT;UFrHy+ii@KjDaB97$SCh3V?V{W#4>z+~xfbX2HHa>8X( zBm@>#2d{d*+kwg#T{eh*_(=e?%wswvZ4Bv<+#c9NQi}@1jif)URs|*dH&qba+GF8 zs+i&Jw4FetphR)|${d~7X1xp)RPNr_A%yxF@7aB+KGjsvSQNAe2=~(0js6vj_i-c* zygTb1I||h`{qHH`DhuSa*U#O#8niF}jGcv?yVS(?vvMnp2&&jO2+cU>a zu*E06k$)`U+HkA|<>!_-{I&oMqr7-Z8jR7mxf=US*r>$hxsAQ%52}WT(%L+V1bBC3 z%OUC2E^|Gk|Fjbz5*Mc{{N#(b5T^sByw z*Q~MI{30mL8ZLcy?u!98x%f`9$@!d;4!L{Ra!=7)z8l+Iz%wm-{3B!Xaly7_<>U2c zP4)W!!^bB>1=`QEhV!N(Di-z#k{twX#P6Oh*7#xSK#-2s2+CLIj&A8CuuE>YMjsVh z1OX7F-8Jn$yJ4E>tte|N$E`Ps%O1yPg1*?!rDeXwN`Q}N5NuJI$*EnaSr~2>UpcN_ zNL~E*qfos9e|ooLZ?$=UUACERd0`hv8!LRikl>7-5p>o4$!t+;l~T2nFKz4p z>xEs#y>j!!%QtnL9Ph+>??sv6igr%fi{pFC*@x%C=l?!;j$r8Z{rOS3puGu8<=p1g z6?>SPJ0gE;M`E}F@Q{(JU)tAED#Q8|PhUkIY?j%~T*zPzEr@;9gY z=Qc?oxMz1L>xV#nAeZ^D2je)XS4Xk zn7QuIs{8R%JDx$-PVTl3r0b1N=$$>kZ}Hq(9T1fNe5k*h|1DaB7Uqvt0(#}4x>u8h zfK!l*6!iO3eX&2Q27Vyqv$?Rw8+W|Uw7~Js|$lpo@K(QjQ1;s!u*^{QGwB0HIA4KxL0PBfR+8It5_@9iA5jm$_ zWWpX5^Cm4`ueHPxxekP#mIU;Hiz%5^U-SC+Axr5tfEYjg8qHJ&ebu44Wltn77qCh{ zn!td)z>v~w6}}dG503ahk(dktyzmTWl&Y{?WnAxMX3iJRVJ=eNw{{O|$2_x-QYr}& zeCQ^+C}NXyQ^F78+xykENSo{pltEVOWbS2Gwg?IF`5p({V%9IC-*&3 z_;Nhu>Ukj!%T3c^3)E8%8-20XhA&^{KLXEy&?$dupSexy0h7mwqW zXR_}IIQPed_F2=ptlpJDx^Nf5f7dzxT!E_01qIAh84FLEpHS|vtxeTfDU%AlDSe*C z(HW@%I>Zs}56=Hvq%c3!v;?O<3H~0RSCep-Z>Vi5vDfZ>bKY!MY%fJWE@i1yiK@0g z=!y+b+Qrk~6vpt+WxZ;xonQMNXcI`|DOe$z1;BrLK0Y^MYM5kLXT8s!24W|wiOdO4 z$SQb6=*tWnsRQIQXpb&h^!``N zO<(ojw+YDdR`mE*L_FqY^eNl_J=;2)xA~|DBC?w%Re=|LO!MWHnU1(dTjki4m%TPw%w zMOw`q)O-$LprcDWkqG+^#6wayZ0)zMk1V9+>3Xjie)OWx-~U|a)GDx>kLz92q8RF; zzwC3fH99`je$MgdB08utpA9^YJNqYKGz>NP`Ood&$|BFNe;ptvhIEfa7fiI7SWwhJfuK91e5gBf)b3o(Pdh94VAjsEIO8{w=8t zH65(K?XgeIk84jqhFSj2;2bku_7Ig}kJJN8vTd;0a+a3jd-x?a_9S@IZTRxUA5&Q= zfN8g-KgJKRyj(e&J3kGbTdl66Vr^NvE>HeX3ilKdvF1sxH30{^kkEL&AN7tFhYGae z9&yt10}yUUIzST6?ub(q^_9f8_1@kK^UMC8#`(}XPT@>sZ5+m^1=7a1Konc*?qmtN zNLaidd2NG!Xk@4>M_7#{9W&q$y`4qlM#%dE6)59`sLv$6OVzwK4L4E~^||0!b8D-= zF^s@zPN0>~*j%lD_H?n)&F1g*{^zYngQCd`1u`uA#rjGh$dHe(qoCBV#qZhy%&v3& zN4GJ-vqzV*uPR4m&OQI1OK;!$0I=c%J_M^rB^UA4hIDNFG%z)6og&J;0JO& zzQlwsM7?#BTqQWYDB@XqvODQx$)=z(i5;Yjmit%a)ig=q!iDkfsOke<(Zk2+I2T>K zr!t5W;wq#c+5Dp>0$*KwE4k?hpHQHn|JoQD*XlGvCf#1}c4;1J6KZ%Z_!P1W<(Ak} zzTO_ZHFzb8bhD4^4&&tPf2JUi15;!g)Z}ebQkOu>=WwN^78wg4X#9apN97sb;ysJ% zOcR)&;;Dap#rI}Bl@U+s8kXoiiGZ%O3q~3bTc1305 z5#zJyM89~}Q)xN*&w2d-rL!IIlFh!Q;kS;U5iCOpMZu(-HGdu#fh#EJV0(b@wWA#6 z*DofXjL{d!Y8@DRqfU)C6f#AhbZrLM_lg*RvVr z(ZBL>Qvrb2z)7$A4>1M<*%FHTp3RF|g?l=XyEG!NAc}J8-NhwF{@2kwyPK)q{LJfr zUp&rlMD6E!-w6iv#~vh&VU;h_MPTuHEWb9HT(q@$tQJKC=qtD`P$e9=asnkikgyL$ zGXmppY6MWjSc0{oDo8x6gW0P+YHr_5lHS&uwydCSdz(LU;WUv!SexjpyLz^eVoxpG zoCcWTAxQ^{@N>?b69yFR_{uGU>D1T!|wN!+OzBT(G`|aQG5SSXO+4m09I}zEDA?etl*3Z+}$YSKb9dnmg zx0%#6S&5?%PyT*a$PF4r#6;2%TYaY=kJuFy^f#6{h$`C%O?4012rd>Y^n8>JQ4wx7 zeGCPE(}Y#^ABEy71N{B3X2m4;w}kL+NtwlhHV`V3Z8}8uinK4>bT~M{9fXA;18Vr{ z#Cnm4Xz0Oa#;=WSJ*$pZ3%+(}7!${WkNu*=BS=_C3KaU5dEO_qRoaEVxI&heTHVvksY1P=H& z5hRV*M6zy-0*Wz(>MlbNcK$|LxLN%=lmCeqgF|Q~-p9br2_Jjnm|6YQsz8S`c}moY z+UH&WE?;yF{-XB?PeOx;IyjOZr)Qh)9AoW|k+u4{pBU{28evrsJQ4Cor132)A3tHQ zY`>zWou*UyYTM(@Zr0It{-cB7BZ3`=6Tv$mmH@$>Ng$35xlS#Q zDGWZV^$Tb01mUZ=%qO*MTESA2Z}{kl5udlT=jgiKAO00Rd^ykyU$b%v#x8IH)3|=K zMx6sTsyjjW* zklGGqpV`#3w5N|TYdp>?MpfU|(U`#C1EvsnfVyIe{+MYF1zAFrkl;Yok!|+7f>K{! zA`#yCw~z9`leO+5kHZDc1}EdkjseK9M*MPs&6oagu>t&15>oMimen;ykOy{Ha=ym4JXqR2HT#S-};O^l*cu=G|OvGfw$;H59uLRNIN= zTCb?Y{PcV-cBr2Sy{VQ}^)+tuYjjwsQ)Fw}p{X6cxqBsS+1OR8x=a835Aurej8!8$ ze>eer)(baBYopv>^!`>HZhJ2qBt}fe`KZr;yVMdSw@;L5F$w}JH@6P_IKz@c_sQRo z9WbdO)si`BIdgN@b z=Nbm}4osrHzc1=)Owh)qA25@Zbuz zm0YA~hk8>|j2S(Ye>Y zoyY2Xy?hP`vS1{Y)9!$aOPZUT%k3t0sSV0J0!1=v7&}zeD+3(fw&w)o`~#p|#1Es5 zeIoqA#jO=+ICrN%=@wr}gRE+PQhbKz9P7Y*UKtaVlAKKUNEh9zc*Zkwe#d0sv*&9)w*HtPW7j#b}Fa$sTSy%``C5NmdB1IxlT(fOqN`L{@GA6E;n&(+a0oOmGEWb?ni;0*QJ z+?PhFFh>j_ zi>?A_nbh1DG03`YH@(Vjj6xPH)t;HCwSRVh`vZt0HwPI%@<1G5gdhYY1q7dbm3Vi} zT5J1*W}~&v>-6Q95d5$gk@Y7~858n-$G4gL9|P~_jUK)UM(9#^-JS@_q~S?Dz$9qJ z$Go?*ZNz*};<~m)sHr=>h{r&e2;Oyzma-;~L*{1&b@8ArPa9`;-CMQxKUwV*TO3NE zi;oJr6In?4)q16bYc$?=mL=HBV2CtiwN++6Jg>X&c+-Qg<`wtFtP_%CkNI~xJUK4olixjK(pmo`!0(p+@8TFi)%#NJS~MhiMIc4^ zyI%$3l=k{OI@1`c=%s|&jmc3@dyHuUVkgXIgnv3O){idjtoI?_yd)Q?hY56o**DfA zBGoY#t5Je2xiGAb(04>*h+N6^nV-;|V;3xm&I&hvb0;vS2s8Jpu!hk@mN~axemFhq z{)(MIloOm5*7Gh`8ku|hZq0x(f2<^E&qK3shMz`}d_g3?Xc4j!EX z*Gn2EIT?61o>`J!LGS*0-+OCN-RS`z%$Eh`vpBw7>k2~dCVh} zL2t+SJT2D(i+M|3IilSitjrd?W-tD=4b%ZWff!N+Gz-7AjVP*D)|0E863{SHZg}R` zBl*^0E?s2a%hZYc zMzCv69;iQDwEQIK#4ESsS>BRFow0{bx3d!ohYN$q!1SQs7zc||C?+JGP;~fv`VpxR zRco;Dh+qk3-Mc`knhda^a+RkfA#XPkrxL5vo{dstbQ$n6%-z_2H|s~i@qCiNMzjfJ z$r=`;&4*+khNe+1C`ZYZ5h~S>4D$!eoWI4I3nQ11dhB@8%Eh?QWx*8RbikvK-8?_^ zcMB1s=;{crh$`~gCMKnOM%3vNpO^uZj|)*<`Q$y%h`#D!1OiZqtQbHx%+rYZgkiWu zlQYz;4ho%}Y~&NR3w332#{j_D2_fB;cD2}@C?dn!z}$w-Rom0kM2ORSgp4V(*U$?n~O#r{;3K@&ysdL-kVu@Y?M7%!8 z(A(DtQ3g2Qs;RA>bggcn9H>eT;e-)J8kg3;%xeF$9$oV@;6{*2)^9k1^(n>u^?G`qDhW-G2(NDLCf^da}H-0EpdZ*knXEp!n9B6dI#<_9r+QjN*`dObpD zZ8nwsXg7@Wy>;x$JL0{sj+)JBymxxWq$;n+MX!v4GvW>dVOrFvUmO=_B9Y1*u@ofq zP}Z6ByHJ}&SAdEwgNp9fENv+cw=nv(J@Ev|HisFO>s(?jpK}c3zRQvP1&x1C?XG!D z*BItORimPDCf0kITy4ax)2R60G+aajS}pduV^Ogzw-nbbg%PY5bwGzvqg4=gqXxvU;&$#M3>~_Nxv`DdjdDuNZPDF z6QrbeJH1@eU=0o8Vxp1w_YuNN!I_4d&mwJNX)ocqr%hSVP};-eus?bJZOy6qkWcib zX21w%efvbdUu_B!M8%)- zdu%QG9@pmxw~Qzw(iA>@j(Hi%d~Fu>_uO=|_#MLar&$Jk=ok>yYDSSNNa}@l!3@oh zpASjM~}`zBMzy`mlIuc z59GP%1j<~P&|(pF!A1}A;nrIIN?_vPJyqug9RptoN$Ok|Bf*FEU}*_K`tt(2Hv-|A zBHfl+tVU*`$ihq^xsN6iy-X#JIP4mxlwL+{AAsckx^R!zQx6Um#|QwW&7{&!7xtc$ zi#qSygi}MOMp@$VqqC4gS&C%LHHnih$x$pj*?7v}Y_j;TbANH8PeBD(S_dnv0E_+% zy3@h)Ln-k7W!B?Jsq!}DGD(MPIFxDicomm9M;?tcdD`SNgjZsl=&1BK`s$gXJU_v~ zT~TaZjIu2}&Ao;^f!Ki;W%pfREa5C;m`OP={8q>(i zk2hr7PBnw!uc^#K5zs#Xl)1U(u&aNock)(JVz%}d%I~bH^n&ua6jMUUc8T5silS#%H(_~$LapWYt@q3s&9 z7@F;n%lj?CNutx>!Os1|}4l zZhuqIRw|Pl4MaksKkuF{2BlCBtSVz2VkCGp#pW6hU}Vo&D#RUvpO`+} zeufgc;C0oy=B;T3xUjWkeUWss$CLA)zomWxP1C{lj<`KUI;!t&G|8j_N6r0G<$8x!9&+fuYN|EuW{%W{X#q)w;@7o8jR9|0fGT=d!CWVGV{e{aDx zlDVLYckM!D6o_Kit5z4gJ&~qQUIp47wZZk?XsfyEPnM4$JP?X01A=FBr{MhuK;=wR zyiYU@G=2tJuy}NkhRf$L2LnSOBQN$n4c0A_lA3SmS|IDU^O#B}<6rd;_lRQAZQjp_ zZ;}`O1ctn!$0?HYHCvkP0ivWlI}{+CuHXec-K52PQ3hbqD{@$Ak;M{Ng(DU5swSnH z&SG|2tXBbDhO_HVUc>-XNml+n$acvDsln0!N#|;%6ul<>d(@onI{d6b;M7YBaR@p1 zKrB#ksd%Bh(?7h}V8bs?KBdXe$#^FA-?bPi5e!oYvoi(3_mbUC$ns&B(w8U2|M$E+ zt{xZ;3FgyC0b-F6w4v%uCGPtHlfLbDzcYCNaPr`Sbv31>rU+)c6@oE%KH1l5X<@6k zg6>c^&f={PE>rcq;_%KJU+rfHfgz0+jIrb@{K2dF*~Fhz%478KrN99oP7$a zLc5mIGTF~S_TdMR6e(Y)3bGwlZkNGqvsZgyx=s7=NILgcrgJe#qFwE^O7?YS@e|wx zVwv3MI0Iwn#65>#lS{5{1%^kfg}PnULy0A^>z#r}o=Ffiom;^ul*s^o+Vxjhlo}#> zP0Vhx-V+SU|znJ3er`U+=a-)eSMa&O3|NCBEd8yv+YbpkX*N2wV zK60fcfbEOc0F8e%z0=JVRqjME_(IYW7%JFHa;{UkKGct5^jKxSYla_gKOCxedYkFf z2W5=>zP?Z079!z?bG`gV21bbZ?%lhQ&BDY5qeiETFjpi{lRD!EK@PT_1gt+Kt@&b&A z!!+?TuW2y~Y8$io`ABUBumojMFE@L-O+@>4dAk~UK?3pZX-Z;8quiXF((bpl7c(_j2=u+G+_*#}#^&tvwM zJZr92eD~)<3nxE3qh?}^*95n=0Tr;|++bqNG85{lOsTKbEGqxI!>MyVl2zx}rStS> z5bpaC3fqpeN`J}C54c^ZG&RF9qG6y)89M5t>;mIurKCfUe)ta+C&JjNLt1?heqz-Y}C_q%(t^ek&9%$6ha2k{J#WMZvwPMiQI^KPFIq)1S6Ky~B$f+H|1~K2~OLE%eBM>6kwuYLB@;GNazBgJ0%+i(7`WRiJ6*Q9g1+{0gSoa5 zgG-HWR=`YY*L_g_DV%iUx|u~I?uG+qVq{eD)gExJtok){<;8y#B2TY+iA@IpL>=?w zt19yvkH^7qxxp+D^p^@;z#xA^B!qe#`-&V9P|N*O7c5{bol?y>3Yjh;wvH)7DT;iJ z5?il+;n=p^9C7`Ov<#gqOxF74Vx{zWBC|taStlri45eApcS`|C&weIudOFReIBgB- zxb7CE%4yftq?Z`E4)!*2FM~m*d5%BwW!)@HH=Z+6(AfjOC29fNo1Aj7b!3m~W^iEg z#^}E5j@rrkCN?QlfxtL|CF1S9ZfDBfHvK^>h(1dK3zOXA>w;|vd_ZZhPNjit?tQr6 z9M}uZVgdsTJhF0^;e=nsBVM?Hr;_@)?Rr6hi#Hj>_?EsQ;DJ?ZSpxsSZT@#~fFcL8 ziU&?oJ25#%vzh%Y`kj{U)Tvz)Az=`Pe?Vt80l>hGgXti_ZBa=4n~)zbSf{GZ3jV3~ z5DDQ~b`i_cVR))u5R0hnPe-K%aa_?`1%A;ezN&vFv90>V!hKmhWh8t>F1|-begoJ` zGI*QS?-Dgb->m5P*~r3WcoG-;ALc^wRb;J$9I$O`LrEa00PGzf0@1$(iN7A_m`qg~ z>KY!6aE~YZ9zS8@U%p^(1qWqpR>1XcTjfHY^nhH_GCkgSn`*WY0NnguLRpmr{)Whn zkHF%$ww)Ow7cUAOxe+WpG+!tDnP-A?dxn6>Tw&PEx7A1s_PS*c9(Ei*QPwwCohVe$ zo~M~4!Y|&WOT)?SY>%ZE)OUs`2&@&EH$du34;+a2ZZayHz_N5A)Dj0*c~}`k@wt5s zne=;m`@6bk{2pRI`!Jk)buxN@O|N94Pme+n?f`ResIkxD9 zI%CYuW;Doc&PmVeGIPdR9!gO)X!+!g{%*Xde*Z^3?tMap{ zse`yMPDCjoTP!@)>aDO|Vc3kNN2v;4Du! zcF8&QFT0Ur=1{v}zu?Bn3c&wp6tMxaU_Y0CpDKm#&ZM5L(C0R0P1W&lyFF9hbzgeT zC%hf`#G1Mvzl-oxbh3_HXstS7pa21RQTKYc&*ILxUZ zx8Dx2xIXw_?anGOzIKBwGR_*g#aJ&WeyNcxk{ z5gdW4pqYp-2-&keA6ck24>fYR|GTA06Q4_LS_a_fk)8KoxyO z?_@t+ZdHirJmnkE<0x0;IQ%(*D=W#rI((6{c{F{kiO|IL6|QO!Ivrg00E;zzT<;%H zGkvxT7d~!rld6`eqiXg*OnI(Ynn(&IxCr3e%#Yp#u;qKHmpk9{Gy=BPPXAcE-%TY@ z&=$(C6k9?bS!%99Nypj9Ye3pcwy4!qwWIG&z0i8k12x4zw>!R=5L zVHbI5@fqVYtsMg(PeJ|pg)-jle^~(W1^GCnLIS$VF;C)t#wxjc3*da5HSx?Avj8dE zY%u398;h87iO0VJ9}G{6VjIqEQIq7E&+lEC$!e(~`jQgFQorP9<$v{SY!52EN@K!( z>VoLHO`q~=oiCD#QR_J7+Dt`M$f8d&_qJa_BWvR1MF`Z4lc!T5Ori#1z4sAp!^dyl z$~sPf6Btv-G24y<7>w=)>;zYy!aOEjtoT&IK$4NNo)#1#C2LuT-if-# zgOUgCL^3^XLs!SmfdtpL)P=Cu2u!r4gHPG_spDelkvwSFpIw!)?Rv($FbWr>x`?y;1>yM5Cl{nuYu`I_k@4X~}gc)>;x`hJhyVT%N5!GBOUNAeII(Ur$3gFe*G zqfR!x-smeMAgtQ>8jWch*?&lXJD?qTI40CDDG?##Wt0|rlTOa~Vuxr}yGW`BP6kHm zm~*(O4AnD%nQfE(P9siXo>Pi<8IqU`g+Z9UPqIR(dm*nF_j4oAGdY|hkZ_62z!6cs zcd))vs!^~BI0}ND9h29+gg(cO+c`-fw*Xpbw&dZt^y*ZE1nR&wL9##l+4DZv04c&T zBJk#rUsQZtq0Q`ynAOJy6wKq~WhA96dCta;1J4y`m)*CsCywhTwX+WazCYtdtMbzu zcz!MCbaYXtqQy9xdGZ43_avYaU$KApzZ7KMsl34NGV9L}{k^2sN1oW()PV5=O^0)C zI!_q`K3?c_!J|^6AEB=#+oxP9D;NerjoL@SNC;^=pPE#&wp^@|k3YpgIW zd3d0IP7xgXW*RfRTChjN^N4%GE;dGnLBUl)KmUCt$9P#(@o`X(q|pU?=?jxrXU$hR zz84#JPl_Kpv$<{K!E{M|p*K4)5PaMh9@K-3*G@9ge;Cg|mvB4rUYF97OyDCZ>3+A1 zs(f@4j?a9!0b$x|7UQVG`ZVHZcG+JvcH;9pT$lcwG7s{1;b_1#B@N75^sZ(Wot1sH zN+uS1!`TODi3f`KeS2=_jOOfpSw)e;p?HuZy<(2?3-(+5b>e$^-9JN?@j-BaGL2<`?F$jbbDaZ zVZczo1GVWl_lUTv6y(lz6lUs3Fn~*#J{^a2`vuw1(FHEQ#>$8y;t?mh$F08SE`4h0 zMMi5MZnJ2JL(A-(Qpk@(csU`&Lu^G1lD)RwKJw`kSXZaqWY2rCiOMK(u6{|my)r%N)I&S=9*;xjoPY;S*SItx(AbNL#+ zXCw`|AgxWpj7bWu4iS2ypp~4$#)(M8s)y6yn4p9`Syk_dEwlrJkBZ&KG`ezH-UKE3 zq}z=fIIqg?5DQ@w5p-k=w)uib;Ik(hoJ}#&29*^GM*)ZGc@(nUD+Fno7_DBYPDPx6;|y5Zeed&UEo}?_$B_ptQNp@-U;U$2%x0>4JV_5q zXs~t5YBwA-5XT{^E?TAFBrXlZ6++UmOuNcS{M#T3)fbl^X$6A-vc@NS(`6vAD5zf9 z-}OrjLSp_Q{Ap!ff;lH;H>Uubawwbp(IWDOQ9%V6B9-h=<{O%|WNUk=SOmkC5RQ-^ zE&|Pe!qJp!u%a)CtmQcxx_K2)npSCC(s$91Dw~#(dzQb3JBnqSM6w19Z&Nqm*7Fl(E+2n81U9eK<< zLOL+F;4=8IWH3CwT(hypte=&2l?qBe;1RLaC=NMYnCWvl?s_p8ALc=fzw}wNNGa?Z zSwY&<>mvFKdwYdquuQrI-Pp#r2c|=1M-z z9`%@Skz^JeFU)GVn3Hb2#=@wY8~^Ean7+u*pFJU^p(UOY8XDz zn>n!=p*i0(Ezgi4R6uV%gNs6F2(2TiuPQ-jgTPRiq7U_WgH_0J6ofNR)XTy)H2^xr z^GBJzjYN`fj^|NvEKWYr(L@;j=k+H-{lKd)@4sAzaq+USy&$XvdK~mZn~KH71Bi8O zxS{wlZXqer!OlJ`OF}}wjM!PvNprA(1$5bk#m{w;oa9Qp7RwQ{a%{sNf*@A3O2W_kqt zU{)HlzGUAj4Fg4Hg7g!PjZJ@sRHB3{H-z9)U2E6zsijhxqYn@&86^*lcvqIEjsiuf zyhMwjMc3>?EyTaiB|=Js*1ra6C{^WT?Bq-cIBK4x8)HW(j6|+3j}i+u0^f_Byy(ZQ zl21Pj;;}eJ>~-uWSlJ4;IUssZf7&@58`;K?nesZMi8xKMm~SKF5nqmWk<{Bs$VqY` z$`yW@B&Bc&7QLL(vTH{{cd@r&OemMCLE`f_(<9|`Npxq-ev?@47XaochqyIu;ykT% zOj5=)Wv#at*LTvUKfU$tj88_1i0YBX76i!;jp1#`gU?BbuJD%l)Z$kcN2!RUq*>ItUM z%oT3s3ap!Y=7kzZ z+h6vxHrW;azToyu3iit%ehQ&hScci~{7s8G#U#ehm~b}34VT3(lwEohPuppeq6^2v ze|vw}jLnJO#@pxe%t2ItwpfL{v&y}?8DScWWc@BxUwe(hwKZ_sw zDRJQ^-0d-5hZ*llRMwUM&!9FXY;tZXM0?>P-D`m=&@ZN zX`w2%;Dx&U6V7>$QCW`&7Td#{<(jQupnNKHE=znSH$5>vsm+UEWWV?PPN zx~h(U!_GiWzgpkFPW)N@wpb;*91p|E53T6v$VbW;t*>plu&DLD@d3x$WwTB9iJlN7 z9?Qxn zKi0ghr>`plTP(P?Bo|<&)KB(G*dng*JdTH_YPpv^PCxMvMV>C?N+Pr`qTX~m85q;f zr^FRproH)YVMG(Jk0_Oul9xR)BI4>w+4SyW*kR>)EHs%Pl85Ayro(}PQ$-EoyUW2s z-A4D~pG3r-cq!MY?*?Ef4u|6tHNfCn(BtU#)p0t3=lnKC z#Kx|Z;7!nv_V44GcRnN+*UiIJ&bZEwbKknpMZ6JfWbOLw7cK4A8wV`Mu`5ZX5+fFsU3iLm-*;PCaW%Y2F!M7-L_7F<94(2L zlc#I-=WUd9+8azowD3MDyg@4-TY&y3g%~GRYZ>y3X0Ft7Vv7&*XAjNy)jSQK8+kUyhcQ*{OIvoXG_fRRL&T02v)3g5kF2+j zi)wq{hG7`GyJ6^V=^D}jDQOgtZV-@0VrZlW1O+7|l#~{bP)Zt9LK;CqB$W;UpEaJZ z=ltH!`!})oUVE>&ue$T)AA36K&ZIa5`+y)AG54H>t1j`24NU&+@dl>Cc1P2 zab4CKx`VKRT5yR~c1TcDSFLisYmOl)_ey4x(5U$H_{h+VT_t@HlRkj%g5Obs>^kTF zQaHIWM)6G=vH{LEjKs}9yMuxN<>UXtu?u*w_5WIV^YH0gikfZbLx-phRvbX9G3>QJB zZmUCz{+&NG`ZERcGI)Kt!it`V$lcq)H4``T>i!VyuahEAg4a977Bd0 zVUXj=K)w;$e^3^uxn}FcQ1fhy_2)|e7w}(EIN);Fzs?G957MrM)ZCd&p7Y)xjtmFG z3;rc~G~TdBiUem{<|yjeG-Iq+=h&(E;*?#pK}1-;w`n~K;1dsH zW?aq8KJW|tStqJiHtg}V=<&Q*svpJ%QXXv0l%>|ILDnQdPaTH`%h5V~WLsWY#f>&^B_Syx956^m>*js4X@5_xSxpGOYA z^v_!PzahbXfblKPsglg129z?VA1OumZThP@NZ$_(q=%$T#$@kipCfDcL&|-3AI~=1J?`vV1s@t$J znXajx=-~_1s9;Q8q%q`&PJ9?YO75|hq`yKArpe_t;!U8~;7 zKWK@fuelZUyyxs*U;1bcbPs>F@osF#!fo_^8608m^v7;_=2y9*)oXbM2h5d*mO@qDY{_`cUy?__$#-TUI;s^W}p;TpAUbd&+9F0Xbe`h%Zi9CKP%( zURp2yrx864e$er@o{|0Jq5HPn|Ztft{C&IgM;{-oSsu5FhbGfH2IVk;&?cEd5; zUTA1(kvL78>e@DH$GOw1w9d!7#vR!BK7cn(HfhP!Vg1!wz#xfik)DlcU0{MHTzTZ_ zUKblh3UOEhTn}VeZ3{e;w<-unBPk}l6pYEAA zBoR&ujui`;-a}LwI)7ge{0#>xrq$q$8o8A+ZRqk0^Gb{?L+Sl}u^spR813Km{w!wF zysuttv;2cpxk67bbQ$Uw9@wxJ9cSNuP8jYw#5%3rg_|M?`?GGLr{xeXa@BNzQOW~_ zCinppSOV}c-(@7O+`9{qyymyH1%fQ5_J*HQUO%e6;0XwhwuSNA&C%*6+mb)J5)fxe zOv~t1gP=W?gTQF%09=Jpb+0D$_kW(D;&=%2Nh!2P~?#6w=adw*GmBF36aTM|)P^oPA@IJ^Y~d z{C2a~3%bO$yr4C@3_J%~q^Xfz#~0^Q zV~oC-OK|>g??UFPz#ilCAVd^Fw52cLgUcK!;h`YM#e@NC{Z80XRxVI47}nWooB@f3 z!%};&F9=92?>duDjOshFtR0rGAupWTc!M8B6xsJ$ z?fBvI%z67358nH`)~Lg{A=wb_FHR%bY=GSI8{lTdy_2OP${cq1(Gd7axw3&5qA)}6 zbHwis;yw;?JQ7HDhkZ_EbkD_if4g`34hlk`)90JZ_|xMCY6=iK zA93}%3gkuZr3Kb|&P$p2$F^>XyuDxtN|;1i1)g0Y^IABt*tX^J5)$4F$Kw>&^KhlW z-(oSM6QRS>(9jq!(W2CK0_@+p7}Q=kM+`ertz_-8CnygjE?-<6yl={03mI`*DmS~9 zi0itUL*+1{-iLUB)S8c@d{aCAhvfgW+YYjQs8xwx1zi@dO@>I_U1Bo%B75)Kcl9^G z#z1}oOfV%BOa^an^mzhZ!%r?CNS}M+CGImUAvj6M_70oTG@OEe&4T7zmMv5?)a;k8 z?Kof0Rtb0zLlOX`m4k?3BX5+3Io`?k?8F|{MkA2LmLI~5&2HR-<*-=(|Yte87Q#9P=dm97y-`0$@k;z5bflgFz7gU?tXB0?&UXI{J)YSC@B(%TFqF(4sQl;y=+EnWB@=#-DTz| zLnnU)95GBsa;Gc9cY#F0=SgOd`gw}<5{gn^;U@gnT1-+l>)pr1Thc>-AQZA{^D`;0 z&gJDGOqYdr_jOCEpme#uiA0}cp*Cetm!m29MQBE9(;g+afe@P#-?gDAjbor6co{=! zY&<;Qqn80rikBwoq|kF0qJ#Fgt+}C;J|1vRM^QcY1JRj3t6|D zf9QwpK@I8bzkpkQJZ&ASn`k^E*K6MM3+<6MX^Z0(=q{>>@~{Gy`qY}@R5|Tm+rS>M zTH8bN5Rj(o7kxq=oH)a?arGk|ia3=tf}WfZS4zF~!Mz9n?%TY6P#cU3;8=MGq^;&G z_kXJ7wSOHJrfDKhcA)iegx|tUQbVZOt|Z3V*OOF0PJQLW&i%M@!9;hZDZev>uK3H* zJ!om4oN5!>5#T(ki`-poYu?>lvqIU~Zdtk5cau;jf~{ero0`xS5nu@zjEXoU_Pwgu zP2db!>mn!JgxGI3-hFOgnp&|BHN>FcGXI|MH?H*nlV^W|hEOj<%+GOoEd!5%xA7Hsply_YlNU$(YDP zFjyN!v^c|T<+vQbQIq%XL??uRFkn9>`xOPJ5xT5zE=%pNg=5nDT}$&`P?&%()yNl* zBI5fG^T{@5nr{OqnMQgye}Eu_L3}L81`vZ$$6)#pf59O15nL#Q#Ma^eQh?>6*7cPy zOYHIOhf)JGu~w<_Sz(p%XDS-xS0GK83S~(56tI*HZRQH35D582%ss7sVd1f)6JuMA0SPvI)HH&MGozDYwbYyL_9v1ox<_#v2;1@ElHG zeJ{Wd`%iz{t%9-XXTX8=I!5HpBjfHb6jBnkHhm6gUh7A77cb*3hbVOQgvm$v>x|8HRJ7-pQ&n=FEjE3iSN zMiJ#%ud$BaXy5+)QN2m_g(|`ugml;&^qjvb#^nTyt3zfL|g${vkakHDw zp5PLIlpiZ7;swdabTzpQiIPo9u*KYa!9k29l%@6b|f_Shaz4Ny^VMET;W=@bx$V??gorA<$7xU{hlz>)xFeN@qLw z=r`{Q#SOzG2_uM6<~&*c$%d8TRi4bJ+qsT=Np=}n5Oz#X_U`*zSO)APbdbN@e!(8+ z2j}6PUtS)cs&Z1$7E)92qow{J?D>GPB^F9|yd9Fa_uRf3LNX zypx?S$xJ7oEi6*&7#ywqREd7km{UbxbbTSCFbJ@Hs?&#H-RPDC;zszYO*)~nU~k>` zSU(Dn$>m|u-7Z#=B>POPu@2bL(^`A>w0AsBx$&7Xp|qmTg{?${Q&SbG#e^ngq^EbU zU^lVj>uuPQu!(8j^0Lw}?7kDD`Dkto=ZCg@T;qkb;t)vJN?jYWkRs#|Oi&r?M8c4q z(2@w7zzraoom^y5`O?XjYXz^o4pD|#*Z#yAB^86G_;jTv;U&1sW=(qLmE&(H-%{y2IxxzQY-y^IUi201i2BoAJ_q>%lw465@Ct zVxkpz#;kAgHtgBU$!wfu{aP|S-*3x9CN#zS6Pp6lfZdiMeY2F;7*jDzvHa#^2}cK&3{4=g z9Y={l{skP!NHNRU;fmPfipQkWsB2MFs%b2W#^?BiR%H4H_6HK;EFz?2da#OJpq$MHo|*jQlKyzJHyKZ=~? z1ne1=JH&!PJ4IbMb&g%#y^r26eHDu*gEzRH;Mb&jN3zZ-whm74%akyQdcm)NF{n4Y z&d?WTxKis9S3%s(^YsHM8=GxEX&-KavEcnWjdm_a6n7sPo}oO>!ZgZBy&!gyeOqWn z!ITvTpNKu+OD}10$x{^RIGn!rXME!qV7$%3=u}jWcP8MZ-BYLwI*rA8O+;;u`W*D_ z*{(ONN+lf2XgOZ4mG&gu^`l5UdBVYkM){&W!PmZ2q1zl~4J!3~Q(}%2d^>m_b@3;PBg;EV9p-bMb02C(DVs3Z>7%p+r> z2rzbEza6rxi`Nk5K1q}->w|NxfL0T2=nfj0wmoqhQB>pfp7Tv6lGq3d3lrv5WTL{h zWuwQe;n#C|zLTf5#Z@R72tBrat<0_UHiMT5H6H*3ulGbv!Wm(*GAxTHGE>u~S|I!k z&xP_S>ouXVSBaxq2p4YqEPfCPqD0Km9bilJORE;!erg?#T2}JND%9uxvQ5{%(=-o_ zs8tI978zb!EG^}kSakXalNP)L{}l(S1RSsmoL1iS716JXZwoDg0A05m_~SR~mnwk0$FmgbzUj4G(s6{TkUXo3qr4< z6doW$NIThfoHV-E+y+j8b=Fyp8!+D;g%vlz))jS)jX7iB__*mx!3hiV{V9^4v@g?j zT}KY_<=J}`|B;Lr-<4rc;Q4R}L4fVE>YVaeu6=dZ!-t2+xALqfl4D{^mv~l5_JQnny5q_2Zm}1L>&RHZZIX!G?ulL_q83HS z*e=)vY9!Y@YXRbP0b8Qz->`t;VN8i+N0ctg3*rS!+#sMu-lsPTo{c&_d-6Do(DXS% z2D`Gu{MO$>kX{8gjn89D@i3SUH!dXVRcXw-{h2y@69UM%DoQF!WydnWAi9TUdxoC0 z4NK(#zgNzVx<%SC`(yWkdal?=Ps4ROCFBmB;%HTjk)fl#4ZFd2JejZK7=_2VGAx80 zH)^jo*x=oKiWhWG|Be)l91pTWg|M-3VMmEV0vs7rZ6;eMv(jUXy5HHs|GhC)m{oV8 zW{<=qnNHllr(YPvcIzXQ{WCexs#wVfG@vq9zI7(%FS^mo zylu0xJKz}pXJ2xl!mNDL6|1jlJNl}(F=sTbSksx%W&X4E0kEdP&)97GSqt8-#mfQ@ z&mQo*P_eQu{e$_U=S~8g0B8=Jz)+0Z+GgB8}bl zzHsf=L|opeZm}!#SZEpKlkDp+PE+Csw*7PA~-zGcD+)JhFkVGSw1z z!Noo2{7yU-`_0=nD{NcUo_C;2$ibg0C$l%`fyd+Z@tk{}dp@v=kqwL=1cII>a;er4 zVYx;g$sEZqNtJWIpFY1Am3QY(&lHCZ9mSZ}ayO7~DuFjHg zRk(A1FE$x?)%$_VfKlh;ja>L&!^!yxD+~lENUToSqv5oPwBKK1x(4T7ZLNZ6*L2gD z#~Dbh_Y}!5S9;=y0Vu|SE>S3Hz80CjTqKf})YSt5zq8Ae&yGOY=cHqr3FsJi`WJea zrVP?ci-|qJM|Taf>$8!<#L{a0L&r*u;pgK!;pw1Ix_P`5de?QfK9-yKEpVhba59$2 zgX88bI3kN@uu!r=){q!nxkFfv-&Fq3j6$Mi&0zS_x2oGrk7tU@g>zrV^xb=(l3o!0 zL;!3piHDp1?SSA8-9MT(y7n8ik60qpws-h_Ns0=;)SJ*aiow6TsVEr53g8k<JR_1r&ZG^)LRnL3TI$q;S2!9B3*Eg zB>=5L$6wx-mfbAl7&V{$j8IwRL^sJWZkcU}ph94wRaYRz<2uKhU(@lP$eU~`Y8r=4 z5U!GC6LpJp-~}jm2h)_tOd$YMTpKS``&AYMr1??YwPBIBlcFFm<t5$t%24%kAXL0^1gwr{%*@xlCF3uMg!^Wak0Jf3|au4Y@lCI9VUSCgR(NwHfH?1a`eeMD}~~|CqQ6GGdfW9&Sh+ zQV<^NE1emGm=2G-2ie1THaEA*^yA(yhQGE9Fq?(9*bxQo=pkDGhB_4$4)V-sv+MlQ z*{oU9LHOJ|YI(m~4Nkg>nCZ}FkW8UiZC+=Ywp(z#BVWcKKr;&NH7|9MM(9ap$ppG3 z2`_>Vj0_9t=VPbfG{_9#-+It#DtLdelwBL6`}?Qccd6Uo#*uV%w@Wb4X?3o+>AMa; z8vPdCQ&aCYrLCq({D_$G6XW=%%E6VKCOTxocvFMsCg<b~=>u4gt8?g~0;_U^NXi$bA|YA43V^{+oSUNMLrC3+G1> zWrxh1&#uniN6;mf2>DK11y)o5p`#@QIktTzXk%2dbPjqxlpT)i$xn&e7ESa;(VaNG z&wptcVXk9uODs82R77A{s>fU$FvrUtW=)1HA?rMlZr$R_Qg21F`N-SABZ9vq@;tZi zC(-jY_-zf+lq$Rfw`XpCRzq9xSi?_MrcB7m983V}InriZM9;{G#wW&s&>onG1CR2) znHs&q=g)?!sZwTOyNZX7AA?wzm_C238Dff}um^4FNT=PdsA^~e%4$Q}P z{ANpHmtC?Y#j2|xza?Dr2ub+5o*%NwR}3LPe~_ZlrNxuCDj0BeYTp5@qQ4~{Ufda> z-OfVWBoP4M&U1ie`2$a6g*r9SP{4+7c82ME6PH`ng4P3`Svb7Sxh1W&&5ekHhfzaE zQvc9s#xm-GC7@flCje}Shp+fls@p2;NHj-2uv++q7>Ny2yVgUO+d8!maTu@FGRN+< zyjRLIKJwe1d2I5kIxLi;n#PR9NFC-@xXY5u_aa9X%wW(g!H6Z|!iPs{NzD6`^)p4) zmy@m9S*nKBuxPQSWe*v~zR*T@Pn0%Wvz37(GgyX1U8#eM_vA{+2lUV{VW zP(-dXwaE7K%}OU*aWy#nBQ_r9PJUCGoexHQv7%WT{K^JN7^;hEkFH>x{OmM(zLZ?| z=oV{PDzMygXfH*{bnp71CL>puK?{hIrYXDfzOI(5B8{Y}NF|Q~7URfgzCc?k zo&*m{cCt0M_U<}!65J+h$JjF})+9!b!pri36=b+#m-y(XP8(>>C~y-yk*|IFCuWQ= z0&gbp25N|@t%{y2*Q;Yk>h&*{o)=H7>~^p94Z;|bx}aD&>v<7x+HDTC*)&5R&W0b= z4~tCGnrs*Ck^GBh7|h`HT65V9AA_krNr(O8`KHUv9)XnePe-~YiJ$(o8TvpUV%F{Y z*h;m@3FN}wDVA%Vq@##1qaB~o^#W_ANp>9~PMbNPT+MR3WvbDYQVlV6DpdobTaBjWL^0dug z;$5om%v7Cq$GPu>?(Yl`2SGCn@;g=mxiRex%N0Ggi6<%{-!2UM*@f%YLgyf|UHXne z0%p4cTB5Nk+O-F4PHOcFaph7`Tscr7e zL0hcmMCC`+pI%x$O`ludT9EA z&(zU@N*fV<^uDjz@-uu+eK*zvh{WHvZJc$HvA@ZblA!FaAK}R}eDkxLkbiTb=8kgz zvAW!bnD9UEX;lg`oZ_HjbzsZG+^op+xIgH9{~c!dyPe#7IM+=sLCVBU`_H1<_rWo# zY>s4U9snYe@~4(XQo>{#XsZPyy@6xo15z5y;~R(9S;GW@tS&j69MlYjvqCQ5MEoGr z8|;iJyLf)PucN12WQOhmSLuf7lqf+`-i}S=1rm2RjsGj~n^wC;f+K861*NSs+x9m0 z*ROyftr?TP0(wi$cg0|EY|blp0aH+5_vBXB42O0vn=!8`dtn15&T)UO!7&5T^#UMn zeqdB4bi0Wz>%){=61UmT<4J8oF+rqOZ+4TG{@nn2@zBv(@O6 z&uO)fZGQC2sfG}U$kv4J&N@5RbR6%8l=@#bib=`!-Cwh`-M-ni;uyMzV(a_z`_8!b zG&B7j7ZoRB@wmkW5wE~(^)V6AI}c&!7atPHoy_vTd%9CG>YyQ?Rl}x$!ai2D|07JBU zymrdw)R8;yB#sz)Eay#brly=lyW|04I#HNVHy@>=EyLfl#6CV|jd5I?7p(9ifj0(O zXPTkw)fmKrjQou2B4D}_D8eo-0v?@L0E$?7L|w1*7_TH1-iKETO#Y@zfL|Au=J%g@ zQkRsje!leGXZo6?{SAjCGzm6=?`P6iS3-)}U<^!tv$-cbJc}eaqw${u3qq_SE|2=8 zdhkQ8-lX@PKNY)>{dTs_+>I}{T}91o;tj$`30(4jJbA5eoJ68`0(6|L7}uLAuP&{-X|RYO>_Rah_{k*7 zW$5@Dk7<5#QEV*UKN#JASEAKtaLa5qxHNAS?c@-MBQbfUxSGO@S*y4P3?c-M=n}>& z`u_XH!0S}D;N)+MRoo`yKnXeAo;6~Tq|ibwK=>pbhp5nX`Nt`d435!`9L*>0jW>Iu z>8{>-wQ2=^OUhc`(KM_8nRTrKxZ_(kL|GtQ^3D`CIc|hRGUlXI98vV)Co3F%GAoc0 zm%*~wHXQ$A8*PBo)&M)KP|-#E-y^934W36Jkwd1&riwmgLrblZno@x2`hN3C@CYSz zVcW1QPfU}-M7dUxQ@_(jG69|gLmkSj95n09ArmQ(#^i{UoxMTNd^Xoi4>24pw%3Pk zvr**glnJbKq!%l{eoSRA1MF(;dvWS`o-n+&Wb-^Wa0q@uBXn!vKr>`>&b`LOzZrz& zZ0boGmFhkO+7tZb@Y}e)IP%|xtXhrF4|fC}605wLDrMno~8y-itt~*ubi7c<-#~~1;-Ws(G0;Y*x_&ZRQ#A3mDniQyUdAb zWT4$UmF-4|rlJ8lGBd_6_>){z9LPu_RVV=+(xERg!|47MjrU#KsT&#?F&?sQ$>e$w zzve%WqzXsyo<++=QXzeQIH!E{L@3*y5Fj>e=D(OFLnnEhO69gGuvEFI1LN3otNee@ zX*!aU90Ro_16O6T6>oF&wG96mR}zwWIy0$p6IiIt!$Dn{9bh(N_~xvp9lS`;AV9{{ zgvckc80oj0CAoRs%X7vo2@%Deh~78Q8M|(KWv;z1xn$_3yaZ_lX>l-!M9M7vX&P3}kQvo3LKDlPN#zjFzTuV&mz`SJ;gN&KjLDsU{k3z9dZ=M( z<~fMX&-&u}yjD>5Tk7z?au`P>+=W2Dp(@e#>9!$XoiROsAbBLem3Z5jN>qnxEW5ehZ&60194}b+8fv^?P zFNHr7#mZ8c?QGx+J8shzTy5K}l^!!KA9wPOWmyoQh%ubk2CXUesb(`>aA3(cr;H?h zgTLJnb&M(J^B)9ijNeWWS>R+fb0jPBx5TrAAa=$2hHSSP`2%L2*W7ybT_{_!cD;0i zCA93l^3@(GX5rep0n3bMR9iP$&g@;t!7!WRq4uGaTL{6+1HfW}SVVtzqv@&P%Bb~m@il2i2nSpCMB70gpC zfzD;8LR%X2_M}(#%01kf;8C?A)`)+?Y&=Ht<0Hq~lc1cf#ejKTVHR=q=Si9juUZ|4 zAKw5~%Znc*TS{q~`E5J4F3i75VZ(O%=JG{AC&U(A%@?tuaO$a+a>m5X!$>863d)vh2$! z-E4fE5$xIldJUP1D+gkU2O^X}$_Wc3=RI7%V|;n9xjZ*xLtx0{C+xj)uD0WGOpKA! zo`c)pNt6I@A{RX-R27bNh;18aVwmk~PyqPw`D30>BT3-V7gV2pD2PD5d|SD!k{^-z z(FL|*tl23JHjV$GaWFzWUahZBE;jr-vl-juA67D0z{Nu?XhJR<;uY?pLrCWFsLl^W z298d~lJ*Pdbl>hXBYlVuC{`@~NxH{}99#ltE;Hv?3$fX1cFC}0IVWQ{@)_mAv%}%`) zqM{{}l}fHg_J{aDvnML5oquc*5Mv~)lF9+{O|>S1Thsx4(1cPVRRKcYaTPFRo7S}* zOD`meUz*%K*!wSrkF4Ubc{c}474_B?y@bnUR4q6`ymlkwsoK@5_@%%IbK=ks%v)Ta?dmXkys`h%9peJo2VAI5dKQa?jq&Dof+eW(;CT(NRQpG#-N)T=k#< zdG-lq$BN!M074Mg7l8g@8{$BovzYTweol3{ik#%Xd$7_vyqY{2gw&JOhzj>R* z*Q_-;bA4-c&DsCX1Q0Da@B(Pjgo`|Yw9&X8nh!z>Xvhre7C?&^M*yGJc{zXhEQ#+| z$^eq>O4{E`do6IHBV)H)x2g@hw#N=GPm~9MOWQH1^qFqEk;d3O@5&a_%eOl{fET$p zLLg$of^dE`CdrX1qe`Oi6P`td`P$If zm=m-TN(T$LYc4>x)t|q3BIU^s$f*o~*A0Pvvy=i3;$TrAM(R$5>B~)HmZV=GW>Rgi z8ja`v0H5X;jT@^6B1&e;WVYyBbo*3UO>J%MRU{}nK#bO4l|=)9ytsXb_)1+u&=Tf$ zpm?hHUDI~`SQLA>F>!quXM^GbNv0}$GhlMmYD|q((YP;_xst*f7{1#+z1Gg+*Q00a zI7G*dfZ(C$;4Jwh0GudS(KsDIHwf`!0sAH31uo4ihPwc}JOtq?1AQrs=zweA0k(Mc zwZ%#^5gyjbyBDW>;?84Ce@MBOuc;5gFAal$`4>l!6|;^Ie?X}emw-IhJ&XX5l53i) zFSo%7w9Hnyhu-3#fE1GGh6(km-Dba(7?V+(KLvux>G~S;I#q*+5~G*5BvX=_R69gK z`1%qyEab@#Qbp%T5)&vK&)Aa!;5{XpbpJC*LVuO=vEajd zbl%ENnpIms7EroMJ6YXq0%>$N<}t%S=zIQL>e6wH!vtE08b)#X4UEe}AO%MBr!r%Q zt;f<@qq?GT+bSu2NSKhb$@CJ3GoT&03Tr~FmAZp9SQ8Ckc-d*h)C4(=cp;a%XU$KK z1y;EalZ~}yf-zRO{#~xf7%|Ju$!q$=Pq2*aH1~c{jR7*U8$~!-33|S z?YjOUz%f+W0zszmymk}c2BaQS9UFm-vi62OgBALotvwdtgOpRtkV&GYtsuIIOWPP( zi-8H5;wHmKYf8X)-$^9AE34v-4)O;vn-#sI`)k9Jy1yFSruZ>2V-;>j*x-rpfIy>1 zAbSa~7Lw?Dx)RUm>lq=t(fg1p2@r=CsS5iD(7pOzCfow_F`&|vB4xUn3XX@mb#Nt^ z?(#DN9Cl&{<^k!-qFA{oL6tm}dR>4k^t45QG{R?&Z$Z|q9!!8m8KlNK)$X z`k@e+9TpA|%1B?)WH`#Vw?bgx4Vb0YVpy&ORTp!VVfZoM0CdKSPUwhJlU;@%T1*+< z*84&32>*F&0dNC7B8Wi7OY))mUkLHuZVlobzdW*yEUowB*+Rt^7XZ z82I+T;q5`pc({nx$N|ipdLVzV^dsYp*=9wc+Zy?8EwnB=B=REa-ug?H71l{i3Uiblq#Rj)i@gLOi<_Sd)o?L=u;WA61UHkV zH1aN)5c~*1%n3jg3SeSK;d2r&?PHfGh{Eg_HsEr^4o2tzrR7n}O zN5-;-DFvH=~I=Fl-gCzG(@wMaWPi)Eb`r-7CeB zoqF;+CHy`HNjm zDl_9wH~>2{bqbWM2A^tYaZEH8JV;mCkBROjzFI~pU8r1R`wgP3+~vx!5QJoEU{Rz% z*`f@5DT#M|qY#mq)B|E=+sFlPd6Z*q1oj3;P0S<8v7BbRPYnE|Ln#V-xb?(q|BP`# zP)m`QH-hpgRxQty1(pQX{uftEtbyS)SfT2-U@V?=CC>8{8_Nu1d5@cw7&<4FCj)Vw zNX@eEzOf%p@`hb58<;)iss8u^F};;0`ZI9-N40=4Z6Qs(5|sLSc?+MC1kZ?YT>%(nhVE#)V$XgH3`6}I-~=|5VU(hxAyco zQVw9>Cn1D}Iw)_|GkaN^)NAQV0}9eNsRUA|S!XasZ1CeRF6YG4&tuNVZcPNH`ka#_ zD3yH#b+_Ix!Z~V^U{yDQfWqZxPjL9IA#4l7RK7jCs|ZX&+U)Nt1h#Kueg&dz{_=!3 zw{L~ADpFu=nF}x}UBYqx14|O%u6XcK{J1g|3M6l&kAn=^^-r2)$uiNMuR-#f-yYE` z0m1gmrl)tEi0=0slTM=ANjQm&`(Y+A@7ivM;H`d?c%Lj)(&NMhhrNT~@;wAOQJNrt z+)5GmBL=R#l1Rs42E$JrKI~u02&|;gOv=7WHu|sYa3z~&S(FwYX{fRnZuBQW22^EW z8%#e~d!~v9fgXpQ=XytJ>w;8H`&)X;1Vn5|%Hggu*<>S9Rwc_sNirK)jGZha%MsQr zH1wu5t;ieVB&j$>t{F9m3e^6K_ioG2_(@c=k`yr$$FDKXi9kIAEm)%>QQy~agxt$0 z3U3z)LK;gWulF1h45oCQZMzy1krx`^#cJ+g};=DgoeBtO{D4;;Z}?j>VgF2sS9BF=Og) z4HC7<^mj9^o4y;ZQ9{XJYGL+F)Zwur_9GGFej~s}bP?=!dIq2dGj?nTT&9E)U@g(D z?l``c6~6a~)b?U%XFa~wE4~%kSQq^I$4YzSufm^&t`=H@0k{u)zi51m^EC$`m;9Ak zC+Ui3+i5)iqICNGuhTrn5vZ7@CY3o<-~KUm39c*m-LQ|%%k74?;r<%tCH5vuWFq0R zw@V{LU_mHj;*Sw*2nX}mLPLN3AXlm3OPj3+98A42RRtldr~0U&TUQ27#?MLG zdW^-+e}A&wa`?aef2JZtST^7l7I`CnB_rEy+EBmG0x|b)-whRvk!wi(vm3!|3PO*~ z@ycde=ZYEQVUwRtc01oIi>C!@;+H=C{p0tfbyQpSj2>N^kBxM;@~4`|pmF9fwUaaP zwx&eDws~+LLdEua<`3u54A+U$8$h#wHhX0?Ik{WQYzII%k`8DEKQO~vbFA)wl&AV^ zO|`|~gWP|gn->mck|(Ryvazw@JrsE!YyG>^&zL3?%$j5lgJ~h-TvHaB0RRznJZ4196>Tjx?lT%mG=t#$ zRNa;|dF?j7KIlNCnaWh|V_Wd$$=gfaM?!amX>%jqT=QBm&yQHaMr$?>l_LJF`7zm- z(=fQJRs5_o1TE8^neuFK^B$h_5Yush*Nu|KqxycJU%7K#3j65NOjKk$M$=l8EB8F- zW&BHbP{t@IJ0*L`C%<$;=jEzTPP$Gw%+@>Bd#|W68iTErJ8;P-UhpsY&!cMyaeK~| zyIk>vS+TaEpLqICjeIC)D`Ub#O#Odv2nkW^l=mUMb+of84{pee$Mux3<4Oyw4;@Xg zN(_lTytp?tl`nVvH0u0HpoKPIA^q{q?hPU}nJExqEm39F*7T?E4>%NLm^j_GZx-O= z^AUb3>HcCJWm92Up5ZauY63R|nbLY_e@u?3ZIoq14>1D{fAI93z`X6Ic`v>D`Tu|w$YySe{YoBhT zO|IfYWrIj_xzG==EC*kE)2@&He!t?zetQ{j3co(J%W?Ej=s2Hq-v>F?!yP~+XrHFU zz?`l0=Y#!cZVeDZx2qOd4vGx5jJrS0vph@~dWQZn63&7Cpy|F3wGiChq;y_<%kk`G zv*K<`Ps1`B>L#OJ_|#`F!B=;I)($Ox{0FyQrR_gQTFO=3pp|_;a~DlJPga=RxGU*3 zIe@eBR~(IgWO=gAi%Fkv-PZHP_e9L}JydpRtwWPdtQnQ=f4)aAV7hxgPcRcQZ@>E} zo9mCW8pONa54p-|o!OizZon$|N**=(x{>Gj_1&}_mF5wnx_8sbBO1N_IqUfi^bVQc z``Y{}J3C+4)X)vR#K+5~x=sTD<{Y&GFy}xH?0G$O&n6%e(DnlTDA0|f#?Lyj)_fa= znVG@e{T-envV`n{CxoF^Y`hZ6x0lt2-FxEGe_Cp;JUn1&f+T)YUKi+v{Gov;)L{kr z5if+B#WJdy-4#6V@M5a`EU}Vw3Lw zYEG`@`v1eL-#Mow&nC9uqn5-uRKhit42AFFht>2))0*8vb_hzRm*5sIj~(g{D8uPgkw@$A;u!++FzV@$gXit28>jIbfFZo&pvX*w16|8KMu$bae? z9?fl88vTGu^XV7_@hK_iI&e?I98lTCJSAKe*_ zi-T460e-IFacC79Nw!dh-N}#8rh9G9p?DM=I14*AeKVmAnf)=`D-s=-3HLv^9a1Rpq4fKn&}@2 zn13~;(`BsL79aaL3!odb>`SKS0N(R-(3IJwwd~%eup17`rO6D~pu)Q6e<2mlC;R&a zP$u?;f5z5_{AcjYS(zPs^s?ku>(3btbN9uyrf)?nQ z8;6&T{>2ajdf%Pxss58A)TLIr!)|bS{_f2=CbB9R&{%(*gkC;8~@3^+q z-Gk-npNHEJCwN2xRKPo(QO^I}ECesoCF&Q5 zEh#0IvVd`29SPjm_{4Kw-29(ZVa< z={RCW=o!-6R~{kX0hD`B?t&)Bjmbcy;E$W=v#Zx1mb$#;{xl{u!|O6C#BciJ|D)?I zpsI@A^kKkDgR}zD64Kq>DGdVBji_{YgDBFS(w!pRAt5Cp9fEXsfBPE0nfcFrYq40Y z3*39oK0Drc!i!}5s$vd$%YG7Aw!+7A>tQ_@#yr0VrBa`v`Uz~&c>U-S?|&9ZBqp3@ z1JKp`njt|%nY{!&1H^to+1o8%*F{D1pu+tOfJRkMIU;$W*l}oa3q)}=pir%eCxrPj z6cMjhO_5g;IRhDo+A=v(7iuu>YxxTBldq;pBcGFnKr49KO|F%v@z9tG%9T`=P2+cg z+DXvM)&Rg2y=X1aLXe*-(_4eq+CeeXY6e(60v>3dB_COavXqQXJ#i?lj02SX{%Wd> z5g1$8FP^1J_k0**w;gWh%;WY{hf%t!_uef1c+NL9FnsiT;i^iuT{j);=O@2?*mGQ( z-245Q>07%_g$ym32y#BIhzah0_A-$ifUA&$d`si!E_*c(bK4 z$#T+}zUe*-MRYtQO4mc-mv{8UD#2d`!7^CWPpOdjw+`${U?TxxaA@4#U*g?5*;+MV zycAQa0E^LHdg{>TE=|4|hQ0T{U^()1O13i)hJjNqHDxoWc_~)x+OUa24yUf|ip>YC(PO48( zVE<`IgPs5)8?tk3CPIjSQFR~R4`2VQCzPKf&qGMP3#@($g%%q4+-m&wtyRY3jfK5* z)7W_Jeui|dRPYn%7Mkw-s4U8}*r#&lXqJ?vx($nnR!XC7aPH}yTs)^1{C&r6??uRk z?&tO!#7cZfTrAW+zn`}4ShY?ePp*AC&G7Qe8_xAvM=^wC+7sqhKhxcRVT577>7skq z`AY2wzuopDFX?zGbqKtuHG=?F6|&P2;Y2X$Yi_@hdcaIk|BTL+v_xhE(cp@F9*PKu z5-kIK8@^wMegT{!D1!vT-$$-%^)Ol$sBWmzQpu>alkbA+XK~a4w9x=1{!%4~ShkA_ zVwiqUWHpJ!4FJ`t#d7{RQM&%!rc-g^3X^%CyJONMVV{;6Kl_l6ZV?Yn(~=zM4~@%F zm+>|3#R@pKe;XiyKI_RbvjUqo+R1INeiZX>re-OyW!cIx-U~MU^k0%fH&_LhIr{J3 zQS_nQN9JBLajSCQ4==d2y-+E6bMrj=d_i_YPeg^!pX^Zu8H)aRxWAklCZ5N28G8AP zCOR&WGCWaSJbILOxU^%%Ckqdd)5dMmWzDPCS1Eb>cxBI0kI`CV-c(n!-)lQtWB};A zT)%y90*oC4GwdV93L<|DDuV|^_8x>N32F`aVL_8ckp$tg?ru;|kNEc^&L^Z6nZ>sZ zr(?w```la*9VGskQ$K@qHK4l`BNKqP|7wM#_qIR&aV7HRy5?6u%T?LeVmcLC_Fr^5 zydh7yj0CxjaaPv3KJw5o1{RHU9X)~5jfO!Eq=OZ@7ytY#;PYI|7gvo3OmW6)6$_*c zkC7u`kRyFFkPp%}Eiy&ZQa3lzx5UiV>Xey%xGY^mAu?oNkpn@OeSCma;LDd`{}^XX z5&;1%Y-}=E=-1a5aF$~5;mrA-@OV{W+x(QxCs{wf6K}0yOh3thr-8*D>74s8(g8SQ zp-W^-jY~P6PgtOz`1{LMiHtL7Uvb|mNJJrF7M7HN{45I#{Hx!~R7o%}U;RZ2gzv?g zZ?xwgwb#sAw9`^?QYE@pF#I#G--pDmcY3xWFk^~9#1str)!DQ3?-WGp0>D+9BK^H; zIPQjFe>D=CI%L=y28zF*Y%1E8E6p6vGe_J38ALaZ&kF8{on;U&ybPwT97hbj8F2Pl^){hQs&o7fO`x<`L(B*q~gN?hN=}R4SaNXV7=Yg@Zkw zV;>OvDwd@`2K@ymJGqaY&$vG+gr?{txepEYpW7EzGljAVGMsjm-#*ZZ8hf>AFEd!r~#fWjfnN^-|X?h0>fG_V1ezLBd&TWDlel?)}s_ z;JfJ}|8Xx;gjIsSVgs$D)qP+1@<8bOcdlEwK51=Cm~)b#PGQO+X~4V)f~Dm27n_WetqC<$Mbt+Ok!)uD{gRJA_s8~t zHZf?f3+tU3xXe4*cjF1_p4ow!1ttKQ53&e@J0O<!}n{rz#pl+@Hxz?hiabz#xd!H2%ZYYn(-;UKAZ zhd+MoXu6aJIefMA1JN<02LK76e6}t3wa+Z@tR-@B{YQXJE|V)42kBiOyp(M2O^*hl z;%rPj5T^RtdVgEwxWAwWI+Va2ZS#o{cHRj!o#Idl%{VIIy!qy!?k|Hfh5B!7_hntN zvfv)tv>}5I!whM0jW@#|XuoLxy2o>aABK#`hM!e4XSG4{V`FjWK`=e%R(>4*5sqWk zrtwWAAk|G=HQBVLF^-OolECMK&Rk*o$@ejU+}|c-WgVU5d+}$1pai#_FW!@ZP%IXN z=gJ3Fz^1**^L+k1eku059gqDZvt&p&=su*6mZm;BEYXRJDPlnlPex_ z296oVkL$o3UIf}0GDzK?vWW!IASxd#sP5$c1Rw_q5;xOS{l#jFj|!k)Ds;JuL%?qS zK5n7Bb?6%<4~WyI_(*K&g}5l-%9>!KjJ~&V2{xG%U?!c5Q;Rp>c#C|c1Xl|e`*)Xl z*!1RhM3DhZ6Mj$mc!nqdRF*U7?NurDfG`r{VKW@iY7?CTv? zx3lT>@%7drwU%$$j8BK_S-f&J=N!k&Z1yJ%>jhQ;Q zQ}z9eZ)3G@UM3vZi~dh9`xA}=W)NR~#_rqXf#id^w0Y6j*N2UT zWt0{khX)K|BSOMU$X~lgyeQMv)-2bL$z3wV_Jx_OGDDqrTNZjf+|_Q|FqGC9s;5u{ zvJwV^76rxhrsvu-@uMok>4NltDVSdy%(jj&u4+YKR9ItgubD>R*T>QHdr~|H`_Mh| zF$&lW6sa(`hFig^s@{{=YJV9#DP&qYk`~;_+ymltMi8k+Ba#x)U!U*45L}L_S$xmG zPgD{<`PupfCqr3236n~Tr`x>s!(tjGSRuZ62JKh3hAN){7K2d}O#Nq@^Vf3Fp8p!C zx@vY(W5<5QD-PMYJa!>Pv*j@%wb4zW2?o&a0dDDpLrZR)m}2kG zp8)>YzAVK&Pl!(p05xN^h zQAnO5iU2qFliKSH0QBesxR_VF5n*BR!0=*YVFRQ(ePK8>C#*aC_^Gto<`=*Q0_TtG?tBkXX)eluU20C7J>FfazULv8+s_a8 za_Z`_?(w~a>+V(wCx%YAPdw(#GQ56*aCAHk>oJpVBq##N0h8HWuj?~S+$K_%u7|{r zD?;@ujdSM!`exFu1c2z}(a~=duTD0zOTQSxPE=bcQ3dbXg#m17;j6D6u3B|DIe8G( z+5qnIB(xNTPJY+$9n~r@M^Mq;f>SUM_wUY2>{y+xmzeC2awv$~uoN2`oAYEBzsPsm zcPVuu!Pm$RpV|TgGxOKC>*q|ZO(~pc9o|irqsHzy>}2E@Tln%c9m0Q3EH;m`*HFs# z8eoA`NO<$dmqdId@oJ5w)6n6)RP`Z_^}pM-eensU zqk}@-VZ=P#dc{Uq>VgK0y=$!qlne%@=~Ftd@u zZ4P!Nu=^&;gXIHcWdO3Phc0C4&6x2g@&pn#P4=@S6KGruMrSo0#&i97x`6i8`F=U0 z{D=EopgU)YxWr4m*zEDK#GqAwul3&BY)xJFC7zKCXK*_?pazS-EV~2EO!r@nK$@PG zl}>wDH9_qyE9L&Ll&9Xz)sA2xQqS1x*Zl&w*C>5@WMrmA>j0A;$m=Me+=~v&9_uuwQqzjau~fNz;hHt zOEW~y+7UoQ;cfleqc_We4_re8?k;e2&^&f3rPlzGaq?j=sT<`RXZ3`b351BwtI3Nj z_q)sWI1PU0TrC8D+ljJ{(*6%q?b)S*cXn&mGwYiu@N7Pek=!OjYLK#I7_J!FX%kORdUp$P2 zdlA{7yZS)|8lU(At#*-md$VdP-#%(MmDl~X$^tUK4@r@~-$g~pzOh?k;s#3oNk#tm zcUuHl6vd$e#9#h@gZ4kc$$!542gAVUXBNsm3jDu+pDOC>AH%-oSO34?8v2S~Cb>vE ztz}U(Jo)b@^}qhg0yA@I^}V|x(|`{+|y(B80<`o{Uet>&318TOa0CvdhbJvtA*FX40H^jpKXA)|%;<#oM*RQ2n=F~OYPc8-N*3KWfC~&LzT8&rmS;QDI)elp zmXWop9aQ9UoNs2-r9P6B2IT<;k~Pp!ZMhJGc5zo`e2#V0l=xbK)L`<1?AHtxZouaT@1ZL%|a7DgL>Q- z>eg31YOpGmW(h zEftmIO9G8TRY}lYpb85M)46FM;X&dB+9>frEwv8>c#MELH#R936;+0yV`O9m!q=>i z?P9NhDVq+O4$zlry1Uw*q3dt1BKOCmRh0;rWo2cBJEU#&wN4~mX%|)pqy0H^qQ%RD zvB=Ct=wsBM-NH8pDU+S5I3wn$uj$Y36NmuoiP(X$515o}mmBElaJ&ge(7aTQ)&C^{ zj-jia!X;JDFuqEnNvO@a3))YV_k8vk)49teQ?qaIoeU|XzQ9V+q#ym-z0~dwfJHkp z#(2hzCXd-vzXzuAPX77;-yEcVijgU>X>az6l480*(yo(A&jZAVb>l9zG&!VQw{{0h zqU{BhsW%25G3jAHi+&_FU)BWTo5D#v!5O>)6PJ$PWpBLm7a1IRX2sd@UO6S2r2F3tTxCIYTZxtjNquhKqg3}Km)aqN%Dx%9z9sGq5!+RxU(Luo_p0~O& z!n#i|WDx$Yd?W~*n$U&Fg3tXeLp9&}dWPVY(BKgSkt7k++Fq-~kIt)mzz}Pq{aMvR zRK6JQb$W$)@3DvI$TMX|KaIV(90J0ubq?%$zPtgL$KSpzZqXZ`3=whKJ!)}cZLk2+ z8C9-_#=D&tC4_|mHsjv?^QiB+gf36i>OD4;!=H9F@dD*ympSi7`MqlSPAX$2E|#c- z#*vu$%}`W3_+|OEw}_`UHGVro1Dp6`X}P+~XvAz??|>$!6yxjUQN>>knvgGebtm-z z>^gt;>n#o;0-B!TdlQV2N8T##NNC1I1y~xb1yO2%Qd$}j5@je{%ti42m2sTwj{+m{ z&AIyOTgOtpOht11tRZM_^WbfLcaZ}Qf!U8Nj)bFr7^J;`Oe2w{Taakf*hN;Ajrvp7 zi8~x};ub8$s+k)xjyHR_SQWq+;}gSWt_VZSqXHh-q8WAi6adUKXtoK&DsN(Xd*2*N zTaD#}3GF|IZFXg!;<0Z1B91Q?m6X8s|fe;~eKk0X#f zs&;80m2|l4q5J$(kh?Dn(iG?NyGyez526?wuhRDdTT{jPQ&CfLMS^}+gvCU$1dC@C z<6-LFiL(aINn8|uKkPw}DDUW4(?zR-K5GC>0B7S2*3N03N56dAqTN_lFV`)aY*;H3 zX3b5XF?@&et3k#l>qzi}M^+%4p&!eG53o9M87yNwHRW~s)ZI@^Wv&%J~z153Tw%o$nB;mD}h$y&*r6AkmpQEpH!MxL) zY6R+arx+asH=2#8iiU7y;(HD9837Nu6{-*(5aDDdE!~eRQwfRHb=`(si8i-8Vg8^X zW8Nr1g1XqABy8=1!rYv`Ans`$N@pm6Cn;BC{jsqoOmDTI@C+_ z2p#x(1J%$a?==T3^tikt^57m6!n>a&-da#_x(8Kwfy)Kss}6LI^qs?(1ul%9yeonp zpSSd$ln5bU9<+D^_r+D9z#Q4RHDlTIi3VH#`tm|cB*3QYVA(%RdO>-ARio$-q51-U zVx(E=QbXeDUU!227|wgLU6%!~7v3*Ev_nbc!Nn2O9IlI+X$qDvGF8svb)>V=)`d#? zE95yz4kM(cU%WY0@jH$zx61HgO3^SWjYv*hC7d|u4x~V`JZa4@=^i2BDdX#VRmg=* zX!9cfi@YP{-JhWCYcxz(Cf(L7+M*kETPrghgOcH)DO@dU6=d-pVytBEH@V0*7h<8C z7lq{7n5l+?%9>&Du0CGpx93;&p5Xl7c0!_Z%}??jWo0qN&+|n189>tFOU@(8(SAJV zP12%`h4@y(Q17JPoq4H~n8`#S7uM)kEH-9v!8rjW#AYHyNP=^fbmbeMrG8Wh#-cXZ z8_3?8N6PAe#Fn1Ny-0p;jogj^2U#$1L*KK?9Ar6ZJLf`USJw2r{zQ~fy#LlS+(mug z)HB1x{9?ZURbB}8UgSrIP4Roo$JH&1g)@Y$#V*VYRZz*R+ixwZ^%H(ej*0{>BKY+x z--PZLxfe!uVQQF1WNV*$wTk1yN+WsKqaTc-W%Wa982jmr5ZiSh!;SKBqM)?oVUeC% zLj=15PE{;8DPCQ@C(x1TVy(d|Q%RPTToXbP%3*aQkl?D34=%1nnUR!vd~-%mVu_d) zFigU-gVnB;{#fm*QyAA^?q|ZYO5{oHC2x^60=Qfcm>1uTLQQPVAW`2*$iA*L*t8x; zJc`*d&csT=Bo&Jh?xN0#J8UI*d5OPOh(P9zq`b}2n2HQl_|ljBSpgzHozWU$%aM^l zcq|Dj4;y;IumTY+BBRz@e2FZmQmR}Ji-3}OqN{IGNMc`j^U(n*EC&0Hbnp+;4#V6H z!p~S3Ts&yp7y>vU^8e0KQ#jWzVu4~0kUt?4hFdDPt6%F)DEqbf_XtFEq7dM?WKQj< zoGMD&kd;K;s|yxa5J~;S-&g7C-3Jw{$>s_C$-4+S)DI_5#-(9y7(c;=xHynb*ake~ zbRWdO%-G73>YPe#75yeLD|5;rR^d+;O!A$nC>wdU!kiFzIP4*RP(h!vFA}tsih~zi z%yYpuYwLwwm`Ae2q}bJ>5+l!K4cT>xlL>Md`Pz-xX#&89<#uUXqY~oRoD;M`>3Sy> zpZsn?kwhkCvh*|rnJ+ut>rDI2Swy3@jW- z!{={izidCm>gsAlS$yNVkE^lh?27RNp2kypz zmeTxf)Re4t)TUk)w>Xd|FQq(6BkHliEQ7b}5p3%~SP=WRlX7cbFCOQX zhs_s3d-%{zyjSL}xTY1E@MAr|1bZCM@s+=&9_yeb$kn8!{7|u}(m?p5ThNkAUV9)^1&coS-?RFdbwKb#A z2ch4b6GV}#5_fV_mGB)5RUoD!TF*Kai9Zm}wj~;N4#i0y3fM3aI{P5=ixwRXK43IZ z@FUOTYs|>nd>DGdCh@rk!KlWnjEz*N3&MsW$|{Vbhp++2NF={z3EcuSjo!0Vygl0W zMpv>DNfgz|8*EUhZJHf`IP>T;gzsC%(B$C7>r2IydFb!V;&%iOu{8aR3dU;Ov9s6d z^)e+j4(37!Qts{gk9MSAc99Ia2*=lbA$u#vz-i`-39&WW3%2v%tuow`u`bS0ZA1e_=VD67g`})-9vXe*k3ZIF6ZzU$ zb-88ZU|+W*!kYOBF`Ff>lX1jQH!WDt;?a0CwbT}+ppDx#iKGA{DOCPQL$ z#qTj6cFp>QVN23H=;;~I7RAMJ+r6JRKgIA_Vs3}TAoA!)FMvO8Ya)de-yY!!EEGEO ziMdj~{74vVQBv^VPeF+o2`Z+npD?h)N(wh%q3tI^IFBHt;~Schvk{r{Ji!5K$}?c?qs}=6P(lvNt?h z$ZY0~PR9xg`_!&#n)x*RoD%Yue$d*ZJ?6P$!;gymXySn>a2IX_~} zg5M5!`~FnPA_ZXuQmzY)v~10rB+&bM9G-}OW(h$x?$RGXQGkv-EASqF3J8qx^VY_3R2~| z&RXNh9aD9F)OS9%%{{a^bM~_! zVOMUP?Jih{?hB7AM#m`k4Q@NtLn6Ix0>o;}+MP|a&kqqd55gew);Sp4OqJx6E(V%gMMuH+e(t!;~xsWajX&1~~ikAkOeizL`n zQR(e*YEI+qMGvB?R-_O~#yAy68x6ecokb#Q$k^IdQO+4=sN`c=AonR7Hvtu#dfFeK zl8*L|VF3ORa@}Lwj~!od7#1TF=5&HAoYFw)whqmstHju>T9}pg+r2243KSdhr&QPW zK}6j&b~b(P4T)-VjS!!5!^BI zc{a}E5NdC99{Q7YAH(B@J>LWwOFjMywU2!HJBlU%#i zYlm1uL_57K4Hd20khy-C^^)at?DR%qAkny$VtD9imv(OT+!P2NZ%tiF+z0SgPrQa*kwA0sYG_N5XP{Y{=%B7 zf?=hw-{qk6wDHX%cR$ z+ZVBtSY4Dj!wh~sEpHcV_d^Z>vR*l;my;68CL#}A$hzwy%WuHymb)h|&mwm|8?g@2 z=ZXo|rtrF;ZiA3-;AQ08h#7^#r@GFRf1nK~N9is^SpC?)hz)9U?GTc9Wm^#xKlJvT zH}UQkSEQjbiOmmT*=GnU`?P$FocR;S?#oJ&$#g_-uJV)J@?(kb2GlXoi&-p1?M0A7#{f6P?^*BjW-mPoSfUNkJihet2K3utM|E= zNhp3-9)RH`iCqeOi`Zi?H$(UC9_H zqW!Sx+HG&v5{F!0AMR*NsS?>OGe}MUmH+zRf`;!$NUHgAte)Nb?~_eD8yuTr0#z@c zWhLODYbbqSKN-vl!RmOlvWkmIx@k7`eY=nws}p;vxI>Mks*(EUStjd7p=ij0=!JoZ z$wV_&qF(ZUFG{yd`3j}_mr7}q{C!pj?64;sKi7vN^)LwC*U5gkKEV{`2e2qtY#)0E zbPs();y4YFeM1nnRPhbo{#QX8lMU3>gA_EXGylG(>oitCWXsHxbJ?*viF+)?m(09!hZfQy4D5%EEtv);0 zYo8EUsR)`}$yg-#)l>#ZN+h}7t*TjYn+DOd9uq7K|%^xw@j`@X!wc2Q-5o7N=$RSSCkku-4q zi=Q8cg~`6s#J<5kttg$ldeHy9`!7uBPq`EZnI~1m@0;rR@fFg$=kSi~MEu0GK6`@# zABkI6PUCt?O_#vS~>r_zabU?Eh+CB4}~D8gv1`L%vcabmJmU%bvC5+b0Lr8SC<78>{% z_q1&Fod~{hv2b^`YEIx4XQ{IyQ@Btk!Ir&bR21|s$j%`hCl9nJ+1OO?K^2ZVHH+z- z$n8I8KNx2bTWqB8kKxC%N3sf^CRA+~2pRDH;1;~GL*KnWqP-Lk!H~~=hvy|1Koj%t z!9Z7zh&Q-Ca;HlTm^}IaHuu1V|L1Fo0W^D3HAn~1|3w@B{S9D{Ap)S+1#1w*@IPPv zyDq`=5BCKyxQ1bMi@107|N2#k07CY?J+8ClZ&m&G|6T+^XUclQ92?fZS>WeMWqaoT zHLQBso=KFFT$_@hb-YH~OwB9VoYJ8BTi1Vo%JyWw+VPze%wkC-l7abh>VYzSp9)nQ z5(_f!pSXKtrj96W-@jjL3k&)CPh`HxJi|R!=ash8h2Fi2L9((F8_!7M=p-rBs3;gT zIy3?xA7Xr6XP?Flbv|i3e+6rv=Jdk1!i^SOoHP(K8djNz${&Qt5Pv#m;gwt!GfvbA zmi5;Wb`TQV4_Lz0qJR)w|3I zTn2Ix9p85US>`pCbJ95R)+JL4@DN}ne1}_Mib{y82(@-U#;kXkE*{!WJCf-trXt61 zIYq-yDz_kHc=22&!=@|!dum`?(cFtr)_hKpFrgIti!&xb;WgaU$z-%u=VOvr`qS2M z1?<8#_RTFMPoZs8Uo~JdyB?c-AV}&raraD3KqI-(*)XL+wnz`3sram*(%BnH2vu=; zS%_vi#Fz#7@54bNf>U&J0flS#YMlwiXgV{0jVM{>$EV?Kml(!t99sLb#lE_~7dQiW z{{;9%m>J^4-H)%#)N-BXC3rC(Gc}rcO}Tq2k`IzPYr;CtvK0TFbxZWH`Az&TB=S$B z9y=Px$n&Sk#gw00x2J#XXUF^6K(BSyL7w^PGdYqS_IAjz%^IhAlvt2}iM5~CbOavp0G%)IQae)t-BHuf zd&PVPT*E_(w)Knvx=svjjTw9=TJ+8q8&B(YGK z;P1Ry*}uA`ZE17Ovr(B4m&qNU!mFtS6!?)SOmtL%wSWr)V6Z4KY|K%Q;i$s%ww#UU zv=`s10;H;`kQitB(~g^Hb$zV^qJLwH1c$YZ^{NNMqKSE!Dijx^VR{2@h0BoIfzq(y z<{Mit4*u_x*gw$MZ7<0z5|_Rp9IMGmLx4_Wh>AzVw&NBDw7a~ch;$#1-zRDD{C-=% zCd{^C!u_wdYv&`hWf(ZolJ6uC)SmWDlKEeLerTT5(kJPQ$>L-c4;%f)9N>+7A)eHR z=^o~r4*m*ci^xB==)TU7N>Zp&k@s=?Mzy4++i@j3TFQh-OUcT~B@2hDubr@Rc5|Fn zbpIRjc6qYWzNm!*<#1cGZ>B_nDY2b|HIHq>7`H?sEw3wZxIHsN&0D0lTsN2I1w5tTH2L(AB+rPW^O5#7cq~KX&LVf@I zKkH=#V(42!o$Ms>13>y-18)z2%cgst%n=WiEp;w+fXX>QPj0<&w44B51AuX1N!(k{ z1FQ|btVuN=k_u4(yeU-TJmK~S5Thw4;=WNBx zuysJY6qsZZ5peGr?bedLph1*0{cfn#Dobo%jsUOo2tWqfmVsZagDd=6Wb=}nQC6BI zy4FC}xHfU#QY;?99>6w3Pdq;|Y8dVZmSd01Wi*m5&RY%Qpe^KfMDe41#WXtZdB>PJ zSCeFsV?ZH5UcqD5*9EX2DggS31O4m%3Zu>%5e}CZ z5kNnK@gFJy+X|0AOomTH0fIS2Y1)Q~Nt8d14dvh2P39*?&f@S(0WiPL9W$EyrrB_&44VVQZ%X}bioIa!)QN#Cmm#R~#M#m2D)rzZeDE1rHlUuTEowi;!3 z<*6kLm8|&-!Bj~9e&VOMr7_LI^2IercYqy_lFk5J_Y|0&uhK8fv9<1^^})+XkJC zbWfmEBxiV?fJWk(U%NL`X%ZrEJjnjaqe4fB9{5B|*sfkh=j#>Aw!^7E(Ql@=kJX{fIESZlhJ21e>yuo7{No!6#d>NAAPQ9; z=WnT)PGbQcqu9u;+?_$Yz5Eg#FnLfwd*snaM_~U}j0hhW~*& z0K66g{+7@jz`$zPSVo;W!P6H%PvPnlzOyU79fvXCJ`H-uu??$FX`TU{>`fGg>298P zZb8K?PtA%bK8t^Y+qs%yJJn7kU~IBhv!xR_YhwEw_d#&|cBMPkt|wHgynO<@GEige zsZ?{#N=@s_o_`uIOpGqB5|I$)aXrW!C~-)~_Di&1YJ+8LXe<8?HNpWm@?C}eDlm13Kj$TV=K3wpn*7g zdhqH9oEktV$7(sH01%D%D@%Qvu!smL+>cobNn?|DU%w*lqRsDwzI&%CemaB%C8^A~1pZO43f4#x9 zFWTL_4oqY@&~Dcq>Qr#TCqeLej&yJg$zM(vJKdTv11>Z=1u8RYI?BJc0TxR2le&{q z{)X4-Hg`p8umu6_El4DC9(4oUoUx=Jz#gTu0u@<~+WTOGATpVT$Oo4%Dw=McIbU{fE<60F z-Bo+JQ787YL#>VVqTs|_b9QI!Ft+wuNTCHT+{&hG&HJtX7r_L+^1{P^l?ebhd&*+w zjdgicUcfK_FS_+p(yG_tDIZWY7g=z({sg5%ut=a8o$c(`lv7?v9#Pl4a*Bd76QIUI z?ylO0#@%Lz8R2o5)e0}ga>E|A&_8}`FsI3Tf2RWo8^t9l{e{+w-!FqXzXPDx=M7Hp zn}H+X{tM+|KE1!1x;LAyJIT}Cv$OpMXr**^W%Yo1DMh+B^Ev#C7=BS1fHYgLY5f|} z&Cs{9tUUy62Rc)sNsjLqaEczs#~!b2<^}I|=hpsQQTlqluQWz1-u(_Qrnsy@4vHd6 zbGdjU;Q?EHDkUW)d%l-YoOO7A@C?C7EDEZs2;dNLk`8YOI5tSfz?rCk7D-J_Cz_8x zqf*f()kgU=u?Dg({uWDga)a` z=JC85c;vJN+!kvr0cu6Nfx`1AEXDdPnIw5w{92!1LJY8$K4>4#$op8W9SyyE8e z+*~l{P2f>6#0Y7q`SZlbx7X8zzI@+OkMT+N+=ntn18RO89}WCm16b7}a%bt!LF2&C z+O$6wBgg0dP8EO|CySr%uw7Z@Yze0iPHO zfYBa_SHxd=%t4+nhmq`GMFx$@m!y1$g}KRKYc^+IkEBuWH*?FPdo3~pAouq-(ZF?y z7P!`r1c~)dobAqzmsFdqzN0UT1ZFTQlVy6_m2H?QWP~5^SykUXVx-$|Ixahcb>mXg z9W1*BJYIUBUdiTt<0|-_ape{`u#Cnpewnkco&y|}xR4J=z-z&RPgvMFu)DWgH2l9( zeIzot-)K-g`d_@g^v;scerBlG^Y8(ATK&tGg2CCnhi!SB{M+uY8AP}e7vo9ReAkdBkfZUqvvX{f1D-04uC{`j`3 zvH)ORMF<;6^{dh0s89JXJ)Y0MOl?gt-1BM!SPI z)@tN_E^`!newRSq9~EO1|09rRy8Apfcsisfp`83%zqIyMA_8K3yfD0hni4;$_oD;) z5<^cBXzV)ihgojt_A%poVVO89)#--%vFg5V&s4I^c9)`pqg0z2s3n!2U-~|V__E(B5g_&C;2EPb-Z?@<|vM$C=#UH zJ`0jRwJ#joUy-Qak6HOuq2EI*y%I#C@aSahHLiQvO|sv{Mne(JiSs0KZAlb* zR%;pLyDvFY8E-yURCRAdGii|)oTX#tMXdF0c!d~oMx_j)Y-V^LIUMSyJcbWkv_6Xa z*7vf4?k5#heh+g%h^dKyahJcQ*v40&X{hnRkS~>tOEgtZMrO7gBkz85syrh-6uxr< z@R^Iw(}jKX-{FRhQN#(p6)i0`&)z53psmDAiKgYcd>BLf=TSq5VLj=y#SuCy;TU6? z;>n}%!W822%Y@6j^RCA$>Nn-HS8bcD^m5}$6b|2C1gTASw0O72Lj9><;m=deB#5`` zR+5#i=(}t!ur=!1RQrELEB{Rpf|qF%*cqg{ykVz=v)I%L!C(03E30DIJzx6r1+8{f z;Mt~W{|VTy!Bf6S+W}GA^lnv&N_OyqkmE*$K8dim?zLqRP-m4Fs2(j)d1^J^@OeTg zG%ReidW%q=wrjT0B?IXGi33dVH>=Cqlk6p2*AE+>+5LfkBd)dwex_)=!}!*F8ll-g#)cd`Z5A{4YracdCfj zz}y72Dr8s;41SD8|C|a@9W*r~t6hvi%ohMe%6Yt}yLND$Ihe#QjVcTUj;$Hg*=D6X z0tH4cY+_=@?Wytv0J+>SvAqFi_NHdtv1Gtu=eu{j`S6{l^Zr7qC$m>scMb^G84~UN zr-9f6twvE!Iv&1a-*S!TO4k=?a^*fbpE`7Y>e>Y~f38Yw!k%sCt-kLmu(3LP{V(sg zhm*7Q?`|sZ%v7Yu*#(q{Rf5U(x*DN;!dI5M&RM#B>X&9-JxDj`*H0|>rDs+|~ICK!X%EO$0DCE9w__EGU^8425V6WMSTSyAlkk>r(n|qh` zD*>634T!`Gnm+Vb1<=J@r3`DQC${~uv~bo`p(>ae2LYS{kWU~`9RRuqB}DHG%1S=T z(fKHRFdh9QNtZVLih9nq{&=Vz2t(kMlVz786>mU6f&d0U2?&kqaO$+2n_nOBDvtZt zQg}xG8rK|TdMY%m8nWyt+b27%7ts5k>g;O>#ZwBeN2w^U;`vOkKN!60$FOFTpn0jH zt9kuJJ~nF}TlZ}3KDgBAt>)?2>s6nJuJHd!C6%8VT3aM)VC-USPyz1d=%fSyc%Kqt zm!yCseg&J9eNsc69k=tNn!XqSgbS6v*5+(~_qd(3dVGyBzjhFo?7`o2I@0$X!jfW5 z78LbDH`1D^zr~?&kt)po#nfEb^F#`KK@WcCok*avt1Yvn*2dFU<6MNtQM2P+F@iAN zdhdHAS@9w|TK(?iy(675@RF(QGw$7tbUK%_TXdG;NpSX{0GT@kXtg? zedL^+oFasP^FvgAYV*9t)+zYS1rAyB@^{gvui_ij);n`vhpAiTdUEMaaj7J$59@ir z2)Y0y?RUw5dhWn{>+)vJlnkXbJ`MgZAjLaS`pHCR5ll%LAPr*n{5V`&k50WH^N9hC zQhMwYnoWt>AQ$W>FR5mDx;!ni_nmT6YVkaCNOSiqIO{89&Q%?pNe}uqTQ$rHt^Mllhg*z$U8LROn!sr!Tsl9RjJ@SAp?|BEWnbz1^ z^5f37Tv!-MaW8V7xg7vx|K8pUI8T=j?sfn@FAW(2QMx?TW0wg|Bi2N${aVxn0kS#>@$a7 zgIMfteNZL4@W;%xE2bqmUto|0AB6p!QnpCa*^3zFWdB`$fgY8^F2Rbje!Cdsf%7EI z%GTz<=kMz3j6^|+URhS# zUXN+gfn7TifTp#2O-xMSJ4<%5v?`53%xCef|TD`0b`rZZbx2g$*`8ggJ7pOt*(sa8L3=QLN)dC zWXn-Ni86RRsESCcczb>B(x(ihDON$jXrg+mo=EvgMd%e!*ID~Kr5{sJ@QhIt_^&%Z zL@7i`S=e(>3Yk@;j?{Ni9HKb>O?|l(0~JrtcAd;H1nKJspvo+!<*7>~v&u_JP37+N z7VKKkqLAhs(4a2F2zg{bz{o8xArUBWe{<}9mINd)I^O-Xf=3?!r04;lPo1`T07QAl z5j#~j7jBOfdYA5(0o}@ZdJ$A8>j9(VKWy?g7dXstefLeOwek9Qxb&Lp$f!O86-MWB zKT~E=78E|GRft62V{ig zjE#*U>%Xb%$KT5QgTe%iyJU7V8(a@p?C);e+WC=JCVo_66x`s&KntTl{=K~Hg+8hp z=0K5pA%iQ8Mv=NKX$JfH<5Ln3IYREYucIdhphR=PMJrtpoHqkI0aI_)Ea+?X@7YH5 zJ|q@mh>K;3pQ>|MD4}O*e-?SU}`(I(WZ;o!WAH_QYzYCh0w3k_rh~Pfh`rsS6ZczWwGmM_oHU z4bGOS`SrBD+hO zqi24iDgb0aFkgc_8nuiNz3PRQoLr*B#iX##f%q2SIx>Jzc0~9DC584Q&GY0On_8@= zQb@t7P4{<{?T5hB;Mx5{+J=ND)zf5|G$$aVj|1$SEet}>iluBL5JE%)!l96%RI&a> zKD;=^ocNcwdQknu$+su(fa#?;m{NXwr#+{8_3I?_-}&56@as1|X;xW%H|KTPONE+U z7a=y6J2Cxb{tMs~ykM4MIU(qr!X*4lV5cy-az_&XAf-Jzi zjSfrIi8K@50?9}VUO!urm6g59hBF>L{7I7oj$FR5i;I{dEFabK*7JqyDu;DN0)dMR z)kbGxL4Ndz6c__Sux*WX(iqZm`rMJa>#TvIge;((O;mg^n(X!E?PZuM(S8bQn-jtp z+afw&NStTBjD%t9~Z;jK&;3oV@khC#fD*s@k(|e`&^VF;2ZeGCM|mmlfL6w`YdUdpU^h!G_FuX6A_Mt?rJ~v z+hi%~YiGhyu%7Fvvp>!TC({xE)L9(wc$Mdac@?p9p~RK zebCfh!H=&8%pGb#`KKKLWV{xw6`Q69a^&;a#_u- zm2_H#rxIPSY(=*GZrNR)v%6q)jNF+6EE7@)vb6q1la9M>5DFwgo7{fy zgX8dT_vTfIn?!|ZX$@op)}RuG;tl&`SFiGvJjs=KfPNYH3=}PMbYFA^+S)w^OqrEV zd7oR&2`!#iL?3P_eNi&1d1wl#Efg=~{fw4pzLI$hTEGh(dYY~GP-;ix3DKzb3RnWA z6K=0+K1aw)kdv496)A^Qy$DnpK)ep7kjlS%Jy6VSs-%>LRvsb__}Uf*WO?o0VZ%R8 zk6256I%H$Fs~#OrLGXHug@z>=%k+IcUlzuaJZgPStMhywbisj8O?UhXIpt8a+L(}x zLTmO7-6#;>bv2-=FJ)T~HaGB59tlG61sr%Xqv94c_P zE{g$# zxqR>%jGp_a6jz9&Od| z(T18#y)Bdiox7Vf1NG7cqRNJrDy))#kVu;Z1RzKvxAN~^BCfTz(T}-s3Fsx|u5hJCM2AOb?tSBg?Db@>>D&k9;J2VutRyQvS!SVi;q_tCX(>8pvDMV2==(kC z&xZ;wiabBA@e|%pw+9tvvtvXY3@R7a3S@gPV`s{YKvJP30xfY2=e~c87?kR`$4eht zD9HD#H5+O4IN4o1c#syo(G7bnDnCz=2ZfQuKL>-35BMnq#-N%0b^Cwa**x* z&Ox3T@l2m+QIai<+LOvD`aN@*QT|U%T2WblNq`yw{ z-oc=cQ`gn?#>(cxZ$aVgWP1f{kE}m_O%H|lr~aweLy7S0IM}pypjKp?j*)~f#DUAj zi2VfiiF-=aDD|DE6P;vG$L#n>0BZ z-Xw73pZY)*YGZ;#k1dY9k@Q#a1QYA?r4AOJh@|;p(ln-qGe2pig`{+-?WH*U#GLXW1ItG#0 z%CKocT_F1D(|1p)8pvKUizxJdXzYR9p8JT|-%Ms&wO&SS*=z-?Dj$-AW&ohWpFIH@ zM}_b6-tu$Wp-dJ~xnAmdVUs|quH;W8JB8X_Bkn{&SsFd=OGvxD3hNP zKn`6t)UDk{d-hVP-+%C=t`D_(Q1$tr02q95fPv$YOmMkd{s&xflZ*ZHCul)<#s;V2 z_KoSr3Hj%rax36ErZXn}oqt}rxyAp7-(O*>?#=Oh^gAp!M5*s2H6oHyU@*+b>>u86 z$rV&5@;WE>eB510zPCm!6$RDAcw(T$aZg!d`!&VJQ0%4miy-=oZ_*ZPCl!UF4HS-> zk0XC`HS9_~!8HDa7PBpzx4@1s8XvHpik}{3(1gmaM^;UAs}TK&Wc9-}I!E9gfIxU@ zOk}jpZXe$JW>|7CDDrB8?xN&z#@&VrTaHs@Qapv_$GnNZH|w@6pBhVghAL7>J)N90 zLa{dg5b@0F!1EGG6STGS3FSNaTsPDej*?)t7UJxTiAL72Z_e%%j4KTh6q^h3$~|;! zprD`-2PsJ!e`G>?#w%=bF|iMzwA_}+?E<^=4G~~fKE}t#Yhe7M`GA)9P%>U&Qn;_T zQM&Rek=?I*xEp)ts8W%}zNmv~ZZDRp=b8{i6rCQK^OHEw)q{8SFDplMW)^;OXTHHs zaa##R=@nd!q|>4Wd6jVEp)YMGd&`S}#mu@1i4|I|TwLi(eXjT8LAGjP3f4z}KOqI< zo^rxz)L78Vj*lI$*=@Dz-1`A!LaJqhQzo8`2vkr%f@0^WgAJ%+UZdS%KHhTv=1moS z7Y*0lfV*4*r#gK{PK&@E&f?@H5J9hA(wSMEWgV53T?C(xarY5J4*ksu1#EZaMXBf; z5R}DGjJxC6Nl+Z~fjxzyUG|;*AL6HhnA!Ovr=Yf9R~`fj>Ckf7x7Xrk=}cg9me(6V z63hshtSZCfuoZ)H8iP_}l8~@4gwyis^5VJKIFl0?S*8!hH7S7DMG^-<(~uToP4fGUWMiHS-+h4d1WY9xo*NFq=Y$UR8gV)W(3cY57l86| z@ducB3vv(;n`8f9PaQ9HYpZ!7T)SkG8HtyC$;L6 zU82E(^nrtpWAEM1|P}T>B+kQD4lT|9_l@Kx-oG#$`2C)M!sD5RM@~1-Cz)NWd zucoB8*!jTNEMXs1uAm|10vG@?)HDzBC12nYfybq)i{9M=s$|&3>F7S$z(Z{VW5mb+ z)#@Oz9Hc)Tl}1q&Afy13o#Yb<{y~9ylxk>})QTuv=SL!RSO+B_W%Z@SI|oRlG{DyI z+<5RANGb&L;ruS=dGS4&;Xv1TvM{Ph(DzgV+293Tmmhm;`X0jQW5}W1@^U;oU}b!A zdm4T;$?4E;T48bQM7(~un?9#u_;R}`PgUC+{R=J@A10+zZ=@(lA`MIcxWPz@f`mk1 z>2oLr8I)HZ4IRDY_-(QkiZ#e8Py;%| zf`7j?f%*|mD#P%mVch$Y7CVr1v%0n{Ba~P(T716x8ik)__#cD~u2saYujkobw;QJx zZM)Eg2zVy={zHG>@po{PZ2S+NH*ET}=YmG@0&l|HAi&Yh=J!jafdqm ziGU6cfh&j37=U{~r%f{%^$XFz?&jvx_TI{bW>@H?x(QmQ_7JbR8>q{qE-lUA^?#8u zJVil)_0Bgl!SyhJC?i5Mw#{8Iq%)cnkO}_9)>=NVU0tApZwo@z-YHYwAp zTc$?6Y<8NQp!(TcQ3m#g!2rsGfa7&9QUXK+=$*v=o-%!yg&nlZUL2 z6>&U**J_;xLGQsKkXTqOwciiG2jeTwSMuS!SB$a~&F8S>#bP!K)^!Z&LjXc=n5ynE zXr^|A!Dv$y(Xk2~#^)x()MhcTYfq2Wy#=?Sd2ndwyV)3QGD1-=|M4R>%g>#F$cU4~ z-_hqnMZ+$ln^`CaI6)@-2q~z)o8RF@$|Dg#h&)o8G&6{IMlKco*|3xfkXY367}QW{ z)mB%ZEXBS0+-PdI&AnvM$#Z0|Gth7hFXDt?DG)O2W-yv0eup^HZJ6^x`kt*DdeZME$ z(+n7-W&xe(SArb2L-2$C1hCNLIMlA07QR8O$E^VBVVK@A{w>QrvS$rnU0jyYLl^)v z>GVX2?*}8zkI(~h&IgPaFCX>7Q}5!35%)}z>N$+X@Fie8#5Q%&4+Xc|BzhaR%W^}K zZ^x(=K@AJhryijP9xd(%T7Am+ zu_@c!chT|Xv`~5Coz(Za1h+K#V{JVj!K$7W31B@Yv%8>x!Kpk4cG$_@PAdu*D{}wW0Vy z5#ZdmX*f)#U+@w40Qx04EcL5T0Fjm>E-fKZWgkU39e!v3DY;$?PnN+%&1Zw&3o$?h z=->qKj@GmWazEgAl%3^9ZMc@|%r45_SwzwT2<|vtD*GeB)%DxxVVwz_vQS>S za4HoUq@*|sobf|2l205u02|&;#IhSeNs|pbnk~5=6cU0IYdx9?D0WJy8q)$Xe<66L zy9gYKNRT~ReQB+ed@ycO&{lVOK)1np9})>LO2~9RqyuTX((A}EOj9_I)fdiP~IXH{17%BG5`6Ls}0J|?-J z%0oRIF+u?>gXU(_N`AsoKIBtMgWDhk{02=LU}?kHI*6c?@FC7znJQZD@+xLrSA)QT z;TOF%EDr9FO+br6Zmrk~#-T!13JY6k!WR1_Cn)48#97RLe#U!kQT&k;%B6_h z67m;x@FAd&OiL>d6prS`;_qVksPDKK;ZfD8?f+*pqa1w7AYWRGAB|?19~2cLL|yA~-!IFGAUY4Bm|#uq^7K z2D1$ERU9_PA#;czuc-+V-05gR3 zOZLlg4IDI;^VO66nx%&YH!5u*Df3NV5P80!gb;9liTbMQ&E{)U4=vp}^M0q@E)0@3 zzpKij`R1HK;}Zn^;lG;n{ifqw@xu&1uR;<0r;m924d!YoDoI0tpr)bk1Pv2?wl z$VFpo>u;r>4-cJRl7$D|Nt8?og2jpWu$>3naDT2FiXKIA1EA|{n)fq= zUqH3uOF}-bN99hW4N0$iR}h^!Rgr;Po*Vrv2eiaZEC&dBLj2qSYcGl_1wWhfDI_yO z_KUJLaOF%8v%rQ?Hi&8Pa(Bj`q@(p48+$=Ol}ip$1xF#^u2#APrapkpz3%<&0e`Lr zTyja|4#wrVSAbAA0*fZrL`&Ad;|;ZRRNYHIk?fZe(0AO5bJ(@4HS-gxw9?wd<9l;+ z8yK2UKwZJQTH60YMS~QY=Ap&qhy`$NVt^QbVHQPf4H%qP#g*3aW&Lh*-8PW`wnUqS5_XoR?Vr>2t0Zlu;7l0QAr|Kuxyx z+q*}9a^iLsG~Uy#L|OS5Ay-D1A8?5uEITjWM}cDU$qDET_}4Hi-@PB%N=SS>6ofUw z_tC~qSPv=fbMZ4H`RS;bG+Ai}T3xD)lkYD#&b642yS3o6147vk#o*jXv8ME{-7_H} zxv#%KlsX%tV+LNJ_>bg$W~RaQGa>@esG=UE3#js9sLN)iAt%d8Batsr-fL_4zFg40 z@GZ9F@wUR90(d>B7d&Nefk6!Vy8V;wK$p-nC=>OrDv9`IikKSuVKoI-}R#T1PvCwexi8pnLMCF zG-yB&xbGM9$U}NX|E)M%XOoRyB$8JfkD7)#+r+$g$s|MBh3b#5up>27ru=Nr=fX0N zH{Ef93CU!wh<;QANgp~|5+rI^)+yUty8DWYY}aqI%{S z(NTAb1bqd>>}FvY1Oyqbnwnq81sX0vO!G!^Sw-t2G@i{$-9cBwN*Ec>8eu!;9SS;n z-eq8jf2psy)|S-O9V!zk1CV{7FdEECK9oi%yR#B*GWN|E6SJ1=eVw?8Ax|D?L@l0w z6U*+*6G4*pY4TCrEFEzg|JQA(yD8TS>ph7J*EEZUhDP0hAlOR3{{Tz$!6VowKEUUb z*{vF(pAT#(7xAUQF^SLzkeqElsL_(McE&qa6!7FtM?lw9j1-A0=FMDc_fPLk$*p9M&xw)e;g2#mYC`~*NUis?|A{p|`6pREe6 zQ2UVDndkOx7@bxo7Nx>!71ZzjNdbF*tUop%mN2 z#gAg^Z*yN;SXrq#Q$})EhP$Fz)c|VL50_A*~|Pcd9cc=&?0Q%0VhJi*%BT%*4dFttg-2KTVCe zdRqMus)I4Gpta$kYOQ>eFS6v3ln1)2kVi(q<;rm*?fL^kY(&qEWwE$a3*rH2j89+y z)T?1>z_eJF_#Rt%5sE*=8YnXK$jSX|PcWO9Vm6`TH&elgtP_&pd|l?H_jY$zH7 zm^LW1sXh0&bmca&lvzG==9()69{g~Wkb**WoI$>r(6@DVEHbO*emvt-Yw5%|{wI|J z-uvcQbT1?odpkZiGD8jBGe;PC`7r0Kn6eZ_p>m6@rh#@LPR?n*%ct9*ekB3Qs&Gh8 zq^5(CZ7p>X7%iB5@G#Z)5lVDQn|jfh9*49uFwP6q52CJhz#+1NC{Vx?h~I6Ewv1C- zqJ9GgKgDgQy`}cD>254l-&C5R%$|~Q+1DU>_!<t7$zp4^n7Bewp3X4y-7SQy*;uqkiIfqN zq!Jsu2>nD$O!$5-p`i>=S+2K$rQf6RlWC}65+d6Ntt9#uv}l-+IEyC1_SGzf=D;a+ z$_}>d$P?K}`F$_wEOt=SAdc3=zP&Vwl3>3+N(30thtBRF$dZ`}Y={ZNVH)Qv5tM4FSSZC8Q>Y1R>aAY2m=ME-?$X z&qW0(#%GH|gy{Lca$wr~r`I8pT5y>#Hn<@lZA~%q-Q}Xu`aMQFJ~+U<5s#9&TI9w| z{0;9KL#3|`=v8gRr~&}8_Wd)}e82vN*<-*utKmE_(~5S+ur>)$a<)zPQ}A8y*L&k4 zQSR3+j(+WL{Fpan_)faiZ4C26OT6F{#Rz$3TbV_Aa-fk;B%rXS<~X`{E`67L%ddgF z7FD|{&xHbd2iTeZ`lt^>C9dL(nKp<@mhBXbTz}YjXSiUXJiB8>h8>`_0hZeiB>_}= z$t{`yPyK5!^a)BqzlISVl{&Ho&8ue213wM@96C|y0_SrWa1`0OO$z`8@2lux0!mc$WY4pj#~p4OE|@1Iwt23GfHfB zYa0bvQsXZ>U+~Z%X&gG5K-BL;H7#5dJ8ypDp}*)CjCd~HS()qj0IEOAUHQeJ>=r`NzO8+IDYA1x-sm$j(c>STcL&epZXp#TnI!|!`!wDYj2w{bJz!WY{N+to_x=NC3SaKv?c|_5)8cKjO~CD}3I|P`7bBCKh+wGR6yc2*-I@=)D^RxR+Le(B%1zzl;FtU1}S;O>rDyci#SE?RY!5hoP`DYyFZ!Bf19un7iEszU^Y( zepvG9*W^k5gT6sM;tMVjd%ru6XP(07%uRGmi0fOKYqpM7*nN7@z3%q;@E~{2h8Oxo zu!uMLeda2y(j#j*Lk8R%fC&u;0IwVF$1P!cB*XnOz$kvpBnT*o{nc|?l6}n5LndkuX%s9o8GvEvT~YiTf=+n zVIL976TZ({u$7n9YtD6AQ%adbu;AY1mn-rmJzk3YKc{$7T3EMX!F}OTo@`h0P24(7 zVBfEOZme-$Vy@+2@rs-4r#_v7VGiF2vi|CYD(+7a&s$zZG&9T7y(f-pN&0K09We*n zmQgi#XC`Y29ndPVfWtI{$wo%y(!=46AgCVda2CEd?a~at|nS_e5+F`SJ&6* zJsj`oW6Z2`8f^)Ids2g2&RiPO7w7XDE6ILAV{7IO%o1e)dTU_q?$MP19yfH6`)~PN zd6|d{Bv>ttS*6+A+CFJ@)RmoGZoJ_A(Dgb>V<6pCMsT*+KtX3^J(0IMpAgc^&Ta_o zrWY&9_TCnf<=q)Y4Ud;d32UL{Jn`zYQC8E#uQzwY%E}g**OrWB@ttsN&trZvR1Cm1 z$!R)QAo^56AA+75F5@+x;$=uZi8~z&puJju^FA9}M57?;?qnwG5LXCicly92zXN5{ zi6^IrJx|l@IbA~qI*vPx`z2C;PxSy@PIuDm6YjWffBcbxFvz}L4lY~C!wfsCg!#;2 zL30GKPhgE+&ps58662WEKE(}aVJ&JIgp6CXOZtyu&U89I$hhb*9I33QL4J@?WSI+A z7477;JKxE z2Z=(JxwE@xFL(VuJ^9LD7@o6hX)s+8@`{kNV&hs3_4zOrkTVyQRc;t~^5BRj$dYxp zu(ZNvxZA&7&%&n#t2m{dS=O3HTDC>Lb9AcLPTDt!n7V{!B*B?~#jzXpftl4yQCiv! z^?Dl`s6Q0EmuPM-moYBQ#(r9H;cT+1_;${~lHlO;=Z&Mc`(p>3g{)w`p7)PWSowIP zW7u-}cOTi;9>%>ZTHDCa7(7sJcfVQe^$uL`?roSFG!(Xjz&4rxaRn1x`Ty~EzDj5m zM6Uy}22bu+%cn-2)t@^z!J=PMX^>v|O@7FrKlBwwRFRHV1Ru_!~`F$k*<&#BHHakd&8 zIhC+7USVSAWnm79l~-YO)tq4xB<8#ku4JlS*G~}zl*S&Z%(l((kFM_vHgN?(2o`hX z?S|RLP(I?2C9d<8Og!rK#g!61m$Lw4Y|I*WMNS|e*N+4LK+LNR|C6GcO9F!oOy=zq zRL*DD+Jl}GcK6AutGo`$@0C62MOz7Qvdhc1&%0+ht31Pm_(l^PMd+S*^C>?4*4X@A z?yKd)Kd(a(HYHzCo&3-ao$cU7@7ndDsMp4P6Pf-v_uf|d%^?B5eJcIA(JrMvdzuFy zAN}Uw(8wv1J{t9htUxu+^;Z}a@x6!Bhm|Qh5!|!C{tE4S`0x9!kAFQkIBxDJ(K!Wf zA&+@$3p5b=z&rZnVtX+eB=z*N?{MS^oiJ#b$(W$Aa#7HnAwip0t4_Bo^I5*3S z!I;iWOl8$%m9wK_#bv!W9nJJnFAZXf7d&yyh6hkx;(y66JsTXX%-cO1o5AZx`P>6j zTvqG@iqH&)>iG>w{T*Z}RKA)%doaQ@-K=!%@Vz}`$R;6l z7DOE~z%w&_Wz)qx;BnrPIRFL}g@+W~3F!Y5gAFmc!2`D|jEWkM#`?g6U%#YvAt zrd|j;*`#F?k`cI?xTuH2YOap{xy$+Hfs@CG9=do=i*?bqbI~s)ck}xbHD#GFr`jw*`ZH(`ZUZ zi7!q^>dXZa@g2_jUcE{7?H9(@2nUe;#r@JUv)DtB(0UXS8%SXXtz_ad8c3b4X;uH-lzwP4-y z06D;=7Q(KU?WX+oMhUw=k7qN zSiA-#>1v{NUn|2(J~sWz&#@S;*uK-nd*v$a5~CkU8*21hC-@b4)*G>ToOUN%i{8G% z4B-DT7C{r9!61?iUX6*^0Ma21q6tTI4v;@(!MCixlpbYrKR>oTg%~bC?2ywyFGn9N zC#uLnF-`f5cb8&ePXOwMG|}#GEs1D|X+~MerbEs9p&eySCsXI+S^v0t2q1BkL8Si5 zhfdpEt97xelIbLFqF*iRI)@I4x9JwwI&SRix{NbB>@Eg#U6Y4j( zymxMtkhUKT*j=0aqGIv!H>vMqV}%)zXhcxKfB~B>JpdcMdT-Lh^&9;(MTC-JQ8gRV20&+n7 z?;d+A=OCklrc6DM!d;$xHH6c=M{!lgBBQ59)6~_z;B18BdD+bZ>-jJPtZ#96O zU09O*hQrUDx&gWtHU^^93$-PKpKn1_4fZdKcB|`+ln1N*uDAUGqZfSSu&UnsC1O%z z3~tbpLm_g%dH)*#{~o*~q5Ux@s}A2>TpE2iJgpY&Gp-+%Fp!;j`NRxNL+Lu9{?Wn=w#6&hxlTFqp8j-HrvS>~tcq&j} z*@}SW*FGNK=K=&5T~W57T)SfV_bS9r>+jjO28Ef9d46Y>RoDAoe4(NlGbl9~8a4 z5To_lK+z$_Jc}q zknVh_^cmUawaaxIrb%W7OswoA`6$AYvnEp0sv7XrSoMef$)d_avx564m8wY!xAS>I zNkB9pSqWzQR5Aw&OAs@iE|4Qj0Np6dak8M;54dyKCTshklZ2DVq@9_YVaOR$C=P+4 zn~xoG1QHmv6jX{cc>$ERN#)2<%N?^Gp1t6m=?kJ9+3R=H8wxXT-IdzBJ6Kd}>Lev! zphYk+p(~*=$XE%=f&Iogd69z20B@b9>A>_Be}19@phhf0LQw*ZY&JH`x_mW81Vj2X zt%4_!Jhs*>kMg$`d43tHLie~u21myAbv9k@09e_lz z1jVg`(plG=9h_zit;qLaLS^iy_bter>jUiJr;g*!Yk9FV&y2<0R~7HEA|~2SofIW; zr#uoaIUHY0d;5^%S%PKb4kXcKvn?n-e%wbB9B7%MGbGlZA85;G8g2Lcv|8<$qE>%4 z+isj=PT7Wbb>7Js>6ihDJ&||+sf)z z&8`WDb4&-MgiZ^6)o9zoPT@nmRU4^GZ(%ZHV^4{%t)ifuwrf5%reLKSNsMkptIK~bSQ#YkSHrwp*UE_3Sg1s~27cS-6_Z*VYJShR{L7BP>#G6d&mEL;_ zl4t{4Taa{euXT^(b=z{8mh}K9H}2>ZV0uO{s6#RB&s-Fls_T3YWUqzilwaE(3yJq^ zy+~0i$pzq3;&5RBdclS98wG9foEp;~kGZ}WMn3*bl$RqjW)4enu5?s)uNb@$mee>f zs25^;zC+IBrC4nYUY2Ci<$h+|H@HH!j`XO@r_D@NSxx&Rb(hT8w|I%(6Y?gXe6%R2 zIW*1h$Z#u5+!Dsm1|CsruyvrkA{1|=SY5rWBJGq>Alw8e!-#gsbt7$_Fhz`(r^98n z5r=>!%(h>goEgn38SVC`%{C&tXe<;A@Mh;~(#W>R56^u}QH z-TmD zoG&^VdzcRHg3%uyor6l1&)6;tJT9neAkr3;f%2`-2||e%0F+AIMh7#eQb^kC*|$g7 zN`+UsnyL}3{l7z}&f8w4rKK4Lin12?2l15?m44ENvf)fC9W0Feids{ddnRYhmVvRz zRt@C~A0;bQ*K_l4&iCE0`iZH-QgzOm-QpGk7p9yqLMs?YdV`76ZKrd5!)KW z$rhcO7Yc2IrZp{10;=f)1IHr?s=UG61qID4{$D}G6Z#oAgS>Gi)=bQfy$gU;$*d3w z7P~qrDPXq4wRgNa8_2I(?_a-IEO1TF90kZPRTV^~?sO>F{@_|rZArGb zn~*b=y?&S{5=0_5M{(rw%GYJHP5_83fHr+{F3NHHEv2w`1Ncf%WuR8|73GL3+gff> zKcTf8gKU0Q?NY1>OQw@m{@8YFYG{Uo8Q{yi^1RcZ=QJHNc?r&PW@-or?UJk= z7Z=Mab>lfH=^h{ei=930ps8~mcdy!zAcO`f=sr;6Z4nqzyFC{KNvcqAUFRh)1qE;} zd_V~ZnL67vnc`8tefk4m@J#4+$2oo&onmWk0?d89h zPHLlS13D2|eS3PkgcZuhjdN@*HjnbT66lOozqfPc6qLT&8+W|i#Z%x;P}z7FVNU?W z1Nh3w>3Vxk0DaG*0h|E{(1cRR%c$ao>pDIbNvDIE{UC`DJK}J;)|{;fH=U>g8|bd< z)0f88m{mp7ScopmRp_+(QIgh3opn_E?S7YqYwG$Xh~!x=j(^%HMt?7BV$fZkadp?h znFvm#!(S9}y*qu`?VylLiJ=yM1-zBSS2`+tpX;E9<}>_vN|T)2ZxVqM@Cn1JZU?(n zU)R(6^6HQFbV*Rznp?jDX0u8CLEAD;mk&1y29V>bM^HkDr@d&CjWsf6prL8>&nmQC zCcNzRp+}@G*B+m}Lnu~vzDPH4Z+GMBd_NOHe$o@V3!egb0*GmfI-fHNy+bicbXpPz z=vb+wR(@F@-nAtQj?l|SYzgfH5I@((1hRM}Iv+ORJ4luNbT$d(GZAueu_@#==#1Wf zoqxr|K`84g$)QCsOjw4x`WnkL^BsW0%3^xiEYO`i@IYj0iw zQ)#E@F;{oBRu@YQxr(qzwI33BY!>bw7G;;Xz3@poi2>8>=kX3CfJ>M*FlDoD+8y#E z&Rha}iNbHzddBOXjKk*HW|hUM2EmXmu;`hFHb|MryyS%EGxr99oW4x|bc)rbdKSCs zJIRGYmUPl-sG!C&N-6v9%;u7pQ+|{?GUIYprS_x2zUv5W=;a)C+*gXg#uobqUu>4- zNzw|O>i5vS1x6uErm%7X_{2KbLGs+=!NgLB#V}chIY==V4P7aiL|4IHfWwVB zQFnD#$C~=SyN#sc)iQ3VY^#@|sr&$?2#&DWVG-EsNS96XDrSG7f~8o(t5y+`-9r3N zqPopW-VTd;XOmm*Ba@QOuDSYX{39dQL`Q`2&c^7y!p{yR9yURDGNfhElfLx0)X5*; zUQA_SkB!3Pjv3Uxda+{RBza(ee>S=psh005zx$&gTBB#UJUm*XW%VyxVUWZ(U4ZTq zb=)}<{BYFc3Ii@9wY$HB-SZ`PX!{r~_R^G1K}~F*bk3r)35U=d!@2PkDTX+r&4V2{fC!MRy zwgv{=^NjRBa>bUhgf3%FxSWOO-kZWa7CUDRshBnOQKtKuqHO5Ct#y|BeGoyAJK~90 zW3*EVKhJbpP|3YtwnG+|R0BdMql5ntocDPIJIoqW$Tm?-$C<9ly1M=!Mq#|zg|LF+-_F(=q1fPb_Q;`kPAtzQw4NreoUc@bw1%JNxn)St;5fqw{6A`qr1d!$g|WH>7%L>xGVAZ>nE z=e#p`8gs|Sq26pK$IQMf`>`eYmggTY!xmQWe=qW?-Kw18|4obZUo`}vb-)=-?ZFmuHGMM=dn&_zChq-DkxikGy<;8|{O(R5W@+!30u6VIp zd~Wcnf6D8Z!Jr?7JxyeLfBaKk)GhsoQD|#JzrIs?DZFNW=WK7mZa~trcKoP9!XEyP z_Z2AiKw8XneJg-JS~p_x7_Le03b49yUx37rL}5Q@-IR}`Q1%Xz1EzpMI(p9^?^$zk zZ8R;G&VY)w)%wYfq|cxmE#CnoHNS9+VQ0?E(Tog3h=nG{>> zC(Oz)QeAZ=)Pnm1sgZQ62;r2WqBFdMG9L6 zGkQ(zgO9pGa%<%*?ZOJ7ovDd)<(w8K3)vR3OWyN^TXq%nPVpA!gb`+?Qyh~YRN{hk z=Rm82nIaz`>`TE<&2*15;dA5eAcHf7$b-CC(RHC-^xK2kPT^g`POpBRvOkTD z>66yzo12(>mQ~}L7~4DGYwyEScwarZ7GfUsHET_&YLj4XvqXb1s8T^?*+!G9z`6|7 z5}0zz@e@@>-hEgf$E$2MGnE(O4xtjcQ$nyduCnGXwFOP|2gXV!Abu!IOp2JW4D!s& ze6a~M_wrG2m~!ExvB8(Z&;wVb@Z%4mgFPs3!^5{zm)yA3i2 zo{FLJ&_t?u1-+OxFo3IVu+0yNfd0;1KfaQBiX<7eOAG7E9#Ff#iTUWO;fPHGA8B)g zS^y&lOlC~qH@fR9I8R`h?_{#2Qw*%7_&Aot9NrOX*ZG}3hwl{AZfB}gub}8r$SHZD zmYzR+8{&U+%jgRj1~{G)yR^e|Ez_$Ck*cz)mDuUiI!3vzG%TFmd|4Wgj14ap7OB=3IzCG^Mm zP*K=0?<4*9VsSxj4ma@hKY#XSQ=Wkf0?GelvH!k|KZ1Gl;oq0>NA|Bj{ChI~c`*M~ zQ-2ig^@o4e)IU`Ezc%9^I`v-z{+F@8mX&`E_&;2ff4!-HICKBHwtqLfUjMqbfA`Ct z$o(5<{7ppu4f_7X#lJrM8}$9%?0)_?0{@4I{F@H>yV?CWH}wy{4EEo2$luNGzv+;_ z8C{S7_%|K$e=QyIajoCv)-8BCaUp)Ce~tOS#vFR|{&jQz;lrT(KYudDC&tG$^ZUa7 zN9hRuwO5p$&!_sfI=H`kGSJc$B@9D31xzM(&VB~^e_z$1>+S2?(RJ~!HyXVXy!DTi z9Xv`FX>Vjv#$jnl2)40Z7U6&2V3y_ssQ&d5cpzEaHN3$l|7RjpPWp4+hA)7RE0sL7 zyXmd`&&%|=aJ%7^nc&$b;AEOkle|8W|8oh0=+SsyimNM*xtdYVzd_i4nID{P7$=TN zy$z@60g|RipnvzDz6-n(#v2Qdw3@uUjpRU$)xf{&X>cQL9K;2FhHNohQIO~;tf1RM&@Bh81Q?d_5 z>7bWyBV#2EAwE)7_ucYdaV5#waE{7H&41eraxeHeFc#z>rmutctf%`-3Z1PP9dupQ zm&c3Y8#`+ll9~PY7a76sGF4W9j?CWHj~Px}(?)Bjd~5ESCFc2ntoM+c-I0Urp4?gq zfrI3YhUj$ivYKznY{t^C?IsK$`6C^m&D)8&64dTRyE3{5RyYKuSR1nsURP^_zPHO} zs!wEQk^Z7)pEAc1CY`%!{_g&Po78_rXX9KJoTwh|D;xt@?$e;e#tb=#m5-vsYrulJ z;EmYL*rQNjZ<`w}%9j`ZHfwSBG0gyj(=M^omGJK4uIaF=1)1fJqxqh!>glY_(_NgK zub^Lp5n=19Oi=mLy2}JZw~V*E7(Y=RZ4-~Zw}Hq$??hCV6dQlFfGQEXC@&Sd&_aj{ oXzrmjpsu8WW`A|>go8XvgHW057WhY8SVkycK->HO0I+@2pa1{> literal 346470 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�vvq-9L>iqXr8U9 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

S+O24K%O7#VYV@R;k6$}3-bip|F2MS|&L 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 Date: Mon, 7 Sep 2026 13:38:38 +0200 Subject: [PATCH 23/27] test: make verification host and worktree independent --- .../ReleaseEnvironmentScriptTests.swift | 25 +++++++++++++++++-- .../ReleaseGovernanceScriptTests.swift | 4 +-- .../ViftyReviewFixtureTests.swift | 7 ++++-- 3 files changed, 30 insertions(+), 6 deletions(-) diff --git a/Tests/ViftyCoreTests/ReleaseEnvironmentScriptTests.swift b/Tests/ViftyCoreTests/ReleaseEnvironmentScriptTests.swift index 6004cb82..0e7a7c07 100644 --- a/Tests/ViftyCoreTests/ReleaseEnvironmentScriptTests.swift +++ b/Tests/ViftyCoreTests/ReleaseEnvironmentScriptTests.swift @@ -110,8 +110,8 @@ final class ReleaseEnvironmentScriptTests: XCTestCase { XCTAssertTrue(trackedResult.stderr.contains("must not replace a tracked worktree path")) XCTAssertEqual(try Data(contentsOf: trackedURL), trackedBefore) - let refURL = repositoryRoot - .appendingPathComponent(".git/refs/tags/vifty-environment-output-\(UUID().uuidString)") + let refURL = try repositoryGitCommonDirectory(from: repositoryRoot) + .appendingPathComponent("refs/tags/vifty-environment-output-\(UUID().uuidString)") let metadataResult = try runChecker(fixture: fixture, output: refURL) XCTAssertEqual(metadataResult.exitCode, 65) XCTAssertTrue(metadataResult.stderr.contains("must not be inside Git metadata")) @@ -732,6 +732,27 @@ final class ReleaseEnvironmentScriptTests: XCTestCase { } } +func repositoryGitCommonDirectory(from repositoryRoot: URL) throws -> URL { + let process = Process() + process.executableURL = URL(fileURLWithPath: "/usr/bin/git") + process.arguments = [ + "-C", repositoryRoot.path, + "rev-parse", "--path-format=absolute", "--git-common-dir" + ] + let stdout = Pipe() + process.standardOutput = stdout + try process.run() + process.waitUntilExit() + guard process.terminationStatus == 0 else { + throw NSError(domain: "ViftyTests.Git", code: Int(process.terminationStatus)) + } + let path = String( + decoding: stdout.fileHandleForReading.readDataToEndOfFile(), + as: UTF8.self + ).trimmingCharacters(in: .whitespacesAndNewlines) + return URL(fileURLWithPath: path, isDirectory: true) +} + private struct ReleaseEnvironmentProcessResult { let stdout: String let stderr: String diff --git a/Tests/ViftyCoreTests/ReleaseGovernanceScriptTests.swift b/Tests/ViftyCoreTests/ReleaseGovernanceScriptTests.swift index b59144a4..fd5f52ec 100644 --- a/Tests/ViftyCoreTests/ReleaseGovernanceScriptTests.swift +++ b/Tests/ViftyCoreTests/ReleaseGovernanceScriptTests.swift @@ -258,8 +258,8 @@ final class ReleaseGovernanceScriptTests: XCTestCase { XCTAssertTrue(result.stderr.contains("must not replace a checker input"), result.stderr) XCTAssertEqual(try Data(contentsOf: fixture.repoURL), originalFixtureBytes) - let gitMetadataOutput = repositoryRoot - .appendingPathComponent(".git/refs/tags") + let gitMetadataOutput = try repositoryGitCommonDirectory(from: repositoryRoot) + .appendingPathComponent("refs/tags") .appendingPathComponent("vifty-governance-output-\(UUID().uuidString)") result = try runChecker(fixture, outputURL: gitMetadataOutput) diff --git a/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift b/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift index eacedaa5..f7a393ef 100644 --- a/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift +++ b/Tests/ViftyCoreTests/ViftyReviewFixtureTests.swift @@ -166,11 +166,12 @@ final class ViftyReviewFixtureTests: XCTestCase { let root = fixtureRoot() defer { try? FileManager.default.removeItem(at: root) } let executable = try writeExecutableFixture(in: root) - // Match the observed WindowServer setting so this test isolates lifecycle scheduling. + let workspace = NSWorkspace.shared let request = try fixtureRequest( root: root, captureID: "capture-hosted-scene", - transparency: .reduced + contrast: workspace.accessibilityDisplayShouldIncreaseContrast ? .increased : .standard, + transparency: workspace.accessibilityDisplayShouldReduceTransparency ? .reduced : .standard ) let runtime = try ViftyReviewFixtureRuntime( request: request, @@ -1407,6 +1408,7 @@ final class ViftyReviewFixtureTests: XCTestCase { state: ViftyReviewFixtureState = .healthyAuto, surface: ViftyReviewFixtureSurface = .main, window: ViftyReviewFixtureWindow = .standard, + contrast: ViftyReviewFixtureContrast = .standard, transparency: ViftyReviewFixtureTransparency = .standard, interaction: ViftyReviewFixtureInteraction = .none, expectedExecutableSHA256: String? = nil @@ -1416,6 +1418,7 @@ final class ViftyReviewFixtureTests: XCTestCase { "--ui-review-fixture", state.rawValue, "--ui-review-surface", surface.rawValue, "--ui-review-window", window.rawValue, + "--ui-review-contrast", contrast.rawValue, "--ui-review-transparency", transparency.rawValue, "--ui-review-interaction", interaction.rawValue, "--ui-review-capture-id", captureID, From 196e09b5940cdf6b543dc44911c8cf659d2be98b Mon Sep 17 00:00:00 2001 From: Reidar Date: Mon, 7 Sep 2026 14:02:28 +0200 Subject: [PATCH 24/27] docs: refresh current Vifty UI evidence checkpoint --- docs/ui-review/automated-checkpoint.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/ui-review/automated-checkpoint.json b/docs/ui-review/automated-checkpoint.json index 85a3a3c4..b045a80b 100644 --- a/docs/ui-review/automated-checkpoint.json +++ b/docs/ui-review/automated-checkpoint.json @@ -1 +1 @@ -{"counts":{"accessibility":13,"fixture":9,"total":50,"visual":28},"evidenceKind":"hardware-free-native-container-debug-fixture","hero":{"canonicalPixelSHA256":"42fe34fa9add13e9360f3030e2ff6458513dc70857d57b8d04c0ef5203ced332","captureIDHash":"f247128880034697ea41dc8173c0f2bd5a914fb91a50187a1dfd97f63157e776","heroArtifactSHA256":"77bfdc4c2284b16096ca877b44c094576f773d6244e39b1aa738a7186f5d1a89","rowID":"main-1180x820-light","screenshotSHA256":"77bfdc4c2284b16096ca877b44c094576f773d6244e39b1aa738a7186f5d1a89"},"nonClaims":["full-evidence-bundle-not-committed","hardware-compatibility-not-claimed","release-readiness-not-claimed"],"products":{"axCollectorProvenance":{"buildTransactionID":"fde3ee95925161ad2ad44e3d9354880c265f672ebb5868bd0c01638bf35e3097","configuration":"debug","productRole":"ax-collector","schemaID":"https://vifty.app/schemas/ui-review-build-provenance-v1.schema.json","schemaVersion":1,"sourceCommit":"e5b75764fd84c2e0a70c1d7e60a3033fa999df45","sourceTree":"1654ddb3a847bc6ed193e56a9ecff21e611e243b"},"axCollectorProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","buildTransactionID":"fde3ee95925161ad2ad44e3d9354880c265f672ebb5868bd0c01638bf35e3097","debugFixtureProvenance":{"buildTransactionID":"fde3ee95925161ad2ad44e3d9354880c265f672ebb5868bd0c01638bf35e3097","configuration":"debug","productRole":"debug-fixture-app","schemaID":"https://vifty.app/schemas/ui-review-build-provenance-v1.schema.json","schemaVersion":1,"sourceCommit":"e5b75764fd84c2e0a70c1d7e60a3033fa999df45","sourceTree":"1654ddb3a847bc6ed193e56a9ecff21e611e243b"},"debugFixtureProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","releaseExclusionProvenance":{"buildTransactionID":"fde3ee95925161ad2ad44e3d9354880c265f672ebb5868bd0c01638bf35e3097","configuration":"release","productRole":"release-exclusion","schemaID":"https://vifty.app/schemas/ui-review-build-provenance-v1.schema.json","schemaVersion":1,"sourceCommit":"e5b75764fd84c2e0a70c1d7e60a3033fa999df45","sourceTree":"1654ddb3a847bc6ed193e56a9ecff21e611e243b"},"releaseExclusionProvenanceSHA256":"b3e64cf1c2c5e34d5fe8093894ff9e685b4975b5aa523a5d4a09f472281b22fe","releaseExclusionSHA256":"50d264c7f1a6dc6c70a8cf8d67aecdb1e389869216d74a5960474e4dc6ea98a2"},"reviewGates":{"visual":{"claims":[],"priorEvidence":"superseded","status":"pending"},"voiceOver":{"claims":[],"decision":"skipped-by-owner","status":"pending"}},"rows":[{"captureIDHash":"41c4f68dc45593a359373751ba755945f5d9d27411cb597d29fe777ebce865e1","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"b506ec4b210d2d3a35990bfb7d492aaf442c1305f4aa7a55d5c9de0b37b0a871","id":"healthy-auto","kind":"fixture","requestSHA256":"b98d552cdad1f859cb12af693cea3259509f804a9b9a69c780b7954912a55db1"},{"captureIDHash":"97c67525938d134d39982c6c277e27a1932f2d2600cf923d55a133acd2cb9032","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"6ac3c38800dd6075404b5ec72fa0239a25254d3f4d549fd644fd0ad8f84c3236","id":"divergent-per-fan-curve-draft","kind":"fixture","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7"},{"captureIDHash":"9a1633ac129973f854b57ce1e2f7c365f8203a2c73e89c9d41cf718dea888f15","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"a00451a75f06e725ec4ed6cecf8603178b6edf02a87bb882a4befd7aa97141e6","id":"active-manual","kind":"fixture","requestSHA256":"357c7554d9b7565645537f5eeab8e94e954d332fbb15229dcfc9c55e400ae42b"},{"captureIDHash":"916cb5192ce033a1205424848f9e525e21b506425453b148504131aa81b25698","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"74f204e33efc98027bd1a431a1815bdd787ace286db32b629aaab28cc0b70ed3","id":"recovery-mixed-ownership","kind":"fixture","requestSHA256":"922dae33cd3e1954f5d29d3edd1d58a66848229dc290c9e6c4e59627c0dac46e"},{"captureIDHash":"49ce202dcfc1933bf604fd2dcb90ac6429aa5cc528b4464c8c59d971f135bb99","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"7a87cf5eb6d2ff4ac85c0bce837310bac37ef52ffef220eafbf94d2449898c95","id":"helper-blocked","kind":"fixture","requestSHA256":"266bc5b039931c7d15d938674309f8982d60faba4f17c3b95e798f9750901597"},{"captureIDHash":"ea78a703d1baaa3e6fddc7b8b0aaa23a618af24c31a807286ff77e41d8ed279f","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"1c80b0b7da9867215bcf99f9d0d61661119f8486a5693f6434ee2d70b9c89ab7","id":"notification-denied","kind":"fixture","requestSHA256":"33b9aa34cb75aa2f7221410a4529d50d0228729eaad6c8990f6892ea59c7fa86"},{"captureIDHash":"90c262b01bad4055659da7b250a0ce00e635b791d9f95710002ba407dbdfc7a0","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"edb77955ef7302a5ccfb1de20a125ef2324be160ae9408d36f8831d51c33322c","id":"edited-profile","kind":"fixture","requestSHA256":"17c3ec7261f8c10e2c607a9049642417406fb500ef3bf65141f1b30504456a07"},{"captureIDHash":"c7212bf630315869f29143037b4d53adc9859990c8fd912da5317c05d635f32d","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"a2362138b6f97cd3b3320a37be0acef2a62bc2f9e80e1b7ad25138c50e25aee6","id":"selected-vs-highest-temperature","kind":"fixture","requestSHA256":"4a103f7896f25e5db1c8c154a9d5bd7f80b031b0b395f4fd4457e34456624e33"},{"captureIDHash":"cf0d62119b921b09c95f195ad861ba921c5c28683dbed4bacbd12602469c717c","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"e9b0dc57112ef7fc1d7c9bda552c2bbaf6c8d998417c837f91274750eca63cfa","id":"raw-spike-telemetry","kind":"fixture","requestSHA256":"cb850ba1eb313e2daafa9263efe5e3b3eaceda51dd4dd8a56e6725d085fd2fa7"},{"canonicalPixelSHA256":"44a961ff9935cf468019254f76c39862d812c7d71174d3748efa3203c8be521c","captureIDHash":"584c26f2f93e49ca9e2bb030a27d1f922dcd36bacec7e52c49d7252a0e3b3202","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"b7ef6f052dcab44d4167d9a67d993a3456bf03679e6de25672d8e425b1a7937b","id":"main-780x480-light","kind":"visual","requestSHA256":"6343f043c95507a0bf3bca03d4b2640882f1da998b7c760d51420815137ad42c","screenshotSHA256":"f1253ee10af457505d294b8560de2bbf2c4e72c8a659578aa3a996c4e75c84bb"},{"canonicalPixelSHA256":"461d62e06ad3f3de2bdd4e988ef4f9bbfffbaf13bf0a3062a0ad77aa4043d813","captureIDHash":"3e2d4d9dd4d0dd5362a0eceb01d5ab51a76670e736a7d598399c9bf59198f172","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"ba67848e4b062922534e740533a107784745534b5811c1a3ae0c85bcc1ddfd9e","id":"main-780x480-dark","kind":"visual","requestSHA256":"7a7a94aba066bc74a0a4d39bd907c4a967b151e3d32ea5406bdc9b0bc1a10791","screenshotSHA256":"2ce957137af73fac6755b0d8d0235b61c30de00176ef7877ce0371a385037def"},{"canonicalPixelSHA256":"42fe34fa9add13e9360f3030e2ff6458513dc70857d57b8d04c0ef5203ced332","captureIDHash":"f247128880034697ea41dc8173c0f2bd5a914fb91a50187a1dfd97f63157e776","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"bba728b9059726ee7671860d50225e26888c69e750cd818b97d4e1d921687c84","id":"main-1180x820-light","kind":"visual","requestSHA256":"b98d552cdad1f859cb12af693cea3259509f804a9b9a69c780b7954912a55db1","screenshotSHA256":"77bfdc4c2284b16096ca877b44c094576f773d6244e39b1aa738a7186f5d1a89"},{"canonicalPixelSHA256":"b17b4791855d949a0590d0dd845fd620060df9f07be26ed9449ba66158e3eeaf","captureIDHash":"49b3b365cb3ded052cbc8f9cfb009c233daf12a0b4a5b1a15fb46302351f66a9","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"a9a3e41795ad7201a93970d5bab1e99865b73616c8c1b7033de36068a65c75a6","id":"main-1180x820-dark","kind":"visual","requestSHA256":"0df86b8f7a07fa1e934a40ad455b217aeafc3960e918904434292a7a2bdd8b91","screenshotSHA256":"2d7874f72dda5b2d54c2a50034196e08e3e2c17f69d2bf718269cea9bd830e41"},{"canonicalPixelSHA256":"78d94c452296027f2c64ad1af5b3d1bbeb3180c579d642887a3fdc108eee479a","captureIDHash":"bed8548a289b0a56005861c7f834b31b36c881a943d61339dde04efeeabc695c","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"f97c5fd2aa8ab7673c84610e9842773b9d72ba4e31e54bd1af4aa8ad90132cee","id":"main-1280x720-light","kind":"visual","requestSHA256":"edcb941caf1c1240669a4e9be836e828c568fed10c251eb284ef9d81bf70753c","screenshotSHA256":"618fb27ad546c992a9804c2cd2a39e61905de1aae64e9ad0e442b004bde87bdf"},{"canonicalPixelSHA256":"7e066eaaa346c451349fcfad3b59bf23650c3b173f47c5faf4176b60b0666895","captureIDHash":"10db6effd2854ef5bfdf61d4e5ac9a87452be14c7dc9d8d95d93aca55a9df0f8","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"ba937fa1e33b98b13408aa0ff6c2d99911f38d9dffe973435c14985cffd5ad90","id":"main-1280x720-dark","kind":"visual","requestSHA256":"6367c41b8dfa354e76ac7b3bfaecd5ffafbc78ec8de475cef7b13640b3dd05a4","screenshotSHA256":"b5e4f0a2aa20cb05f03b439cba3628cf28522f9fc2d310f657290e70d6b1b52d"},{"canonicalPixelSHA256":"d606e47fc33e278fbbf3526e78d2cd7dd0a14a2bde2351b683ae9610f6c61920","captureIDHash":"fecf174b4a7fa239000b3496468cc952e851b039c8f066c91022d5e5ba4d4c59","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"f623415dc09a726209f1dfaf2a6af38e029e4df1194795671661c56c47708202","id":"main-1500x900-light","kind":"visual","requestSHA256":"583ec26d1455fdcdb4d931d699a3c478a03cfaf87d81d9128b865ecf2fc57992","screenshotSHA256":"e75f2afaa53805355bcdcb1258a65cebb4af6168333bf195dd7e6fe3d7957223"},{"canonicalPixelSHA256":"8c84479886accb90c0170215a0b623380b5b27d1548c3bb1e944ee196281494c","captureIDHash":"695a696e9164a86252c537bda3343ae4796fcc2fc68923a3b6966b4c4efd47cd","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"1e3b2bc6180ca3061a63fd0b1e43a2506d99aeb9adadab2f8c5259b14e9a16d7","id":"main-1500x900-dark","kind":"visual","requestSHA256":"86473313ce5225cde9c29ced6f68f3513b0fd9e0a647a0d97aeaf2cbf4d6b73f","screenshotSHA256":"ecdbd7a9c5f27e97ee6e8f22054e9a761284a4781a8ecc9f240e47ddf682af5a"},{"canonicalPixelSHA256":"256ecfa238aa4bba6410baccef9aedc931d07bb43903602a9b54c8e150d75d4b","captureIDHash":"0ab765f5f10ae20ff2fb3a869588974e21ad4b247108c5ba5331dcfc92701be9","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"adf49f6ea6ec91e6b79b55a37136330957a6ef22dbd7fcc3e9ac08b981a0a837","id":"state-divergent-per-fan-curve-draft","kind":"visual","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7","screenshotSHA256":"545c346757ce6a803737aa658b0f4c26247a8c80fceee69c8a574d345bb75a12"},{"canonicalPixelSHA256":"0ad95f87c94de44c8456e36dcb633b87dfd6add2f4740742ee2751c6369422d2","captureIDHash":"c3ee134cac42542003d8313d0673d073141e34da7cc3085006d1a822c3ff03fd","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"c8c3e253f0f58ff0a7797aae006c84ad408a40ad59b1effcde3b8ba8faac61b3","id":"state-active-manual","kind":"visual","requestSHA256":"357c7554d9b7565645537f5eeab8e94e954d332fbb15229dcfc9c55e400ae42b","screenshotSHA256":"8b8a659bca3d21e7d297e74d8341c596db0233531aa44ae87ffcb1957a1e2912"},{"canonicalPixelSHA256":"8f16bc4324fe93d1a7d41f198e60e714a6109d8d3e8dd3c86d1c26ba473ec2e5","captureIDHash":"2728d024cd23d4c77851eedc09d1ca2a13b592a1683634c17cd56cbf773b4f0f","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"b855ce506da7e2e0f278f94bc450a57115b10b0544133c1f5ed2a1f444b2dcf3","id":"state-recovery-mixed-ownership","kind":"visual","requestSHA256":"922dae33cd3e1954f5d29d3edd1d58a66848229dc290c9e6c4e59627c0dac46e","screenshotSHA256":"08be09730f7c890f35bfd93581c29a917dcbb759bd3b273c05bfca35557c8325"},{"canonicalPixelSHA256":"8fe4131c1535c5f3f6ea5ea352c75d66356388bc27fa50902a8fb05c7ee23225","captureIDHash":"9a81808705e97c4845d37c39090c9e821f7cc54922af1614eb67b0e09b5bc0d0","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"458607afa803a7111cfffc754d280d1100598240f42dc7dd7de6e88ffa85b22a","id":"state-helper-blocked","kind":"visual","requestSHA256":"266bc5b039931c7d15d938674309f8982d60faba4f17c3b95e798f9750901597","screenshotSHA256":"0d35fb6bc8355a3976f872833624520dfa03cc7832a1b5a8096d8056cefff899"},{"canonicalPixelSHA256":"f7e61fe1f806f435d167efa0b05d4ba98e8f285f32ca8d7d334e5d5e2a9b1a2b","captureIDHash":"a1639acdd37dcd34e2e3744a65b8a3b6726088b0abc8b74b9bcb4ba72fe33b31","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"1478a604ae65dcd7daff7eaeebbee8c2060da60d41f26e784bdf962375407a60","id":"state-notification-denied","kind":"visual","requestSHA256":"55c3cb22d211c8164b11e63689ed7dbf259c95e1f8ff9e612e1514aa7d6ea683","screenshotSHA256":"7c9710a724aecdd57d7cc0debc2c2c3571d9a043cccb96747b35729934f44e7a"},{"canonicalPixelSHA256":"2a24502516d4df8e266823c0a5d7b6af91e62f6132ee864c73a59545257bec91","captureIDHash":"37f2c7fd081bd8ad04a74cc68be348bef7d4fab0a18a9420011f64dfd2f5c4e8","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"fea56e01347ddf15fbdc943e783a8528a8582e24ed07b2f6ac24e317619ae51d","id":"state-edited-profile","kind":"visual","requestSHA256":"17c3ec7261f8c10e2c607a9049642417406fb500ef3bf65141f1b30504456a07","screenshotSHA256":"af1947ec170cc2015f709851091875c250c9c8904782883e9aa6ffb57b9f633f"},{"canonicalPixelSHA256":"4f7b3dff0d8d84208da84a716c9ea56a584cac92307e096509e432b4127264c4","captureIDHash":"3dcd3df04eae88811bcd365b929da7acd94116cc24eec58527c43ac3166e8dff","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"5e576c1fd63055088a78a9679ede4c35489f75e5b0bb26a45d87cfc3a3d032b9","id":"state-selected-vs-highest-temperature","kind":"visual","requestSHA256":"4a103f7896f25e5db1c8c154a9d5bd7f80b031b0b395f4fd4457e34456624e33","screenshotSHA256":"83eb381113351b7dd409b01bd37977599d0aa7fb5c916eec52188684965da6f4"},{"canonicalPixelSHA256":"f4e6a2f2c87096bec6b90cf96a3dc0807e3b985d3c9614409069b17583251189","captureIDHash":"6ed3ae405d8e0d5e842bc45959737f99b0c3a08cf589854022032cc844b5d4ae","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"df3cfe6e0fa016501c1b9f04f2efd1e08cec3132c9fee2e52cde7fd51b0f19b0","id":"state-raw-spike-telemetry","kind":"visual","requestSHA256":"cb850ba1eb313e2daafa9263efe5e3b3eaceda51dd4dd8a56e6725d085fd2fa7","screenshotSHA256":"44d5a595f896759d596d39d58745a5970fe34e9aae232529e7eba3b55acb6c46"},{"canonicalPixelSHA256":"5779213ced63da391e54cd06a939e30910a128c23622e66992314a87d1cbfa6c","captureIDHash":"ccb19411b0b21ffcaaaf620dd795028f00332ae61080ae1c2b970d47786f8ae9","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"a46c1a24db50f2bc58d9525bd6af859a063173f70811a2558bf21e41a9c4bbf7","id":"settings-general","kind":"visual","requestSHA256":"987e3e64153ba3cd3b55b8d2c672ecf43f00a3b7d7957de79a6ff2103ef01aa1","screenshotSHA256":"e218f53cf24f219f40fd4d3cbd3cd76533f7d3ca670bd31e6b5b6a36c5162082"},{"canonicalPixelSHA256":"0edfa965601687dc41a0ec4fe4e436a821310372d71df4727f6de3fffbd028a9","captureIDHash":"24248e488b84c5b1fc7af2da1ce7abb06c729c310f1da0eefa273fce7702c9bf","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"cb6d97eae532da6c58b2afc3cf7c2183a61b488d0a179d8bd35b22977a23cd5c","id":"settings-menu-bar","kind":"visual","requestSHA256":"398d0ace3621d468b0dc8cf7dce1ae4a23a064dfbf60ed702cbd819e97e821fd","screenshotSHA256":"9f673eb27a191424072fea2290e92ce7d9eb3663cb5821cb954957b774814102"},{"canonicalPixelSHA256":"90b09f5fd0e8bd6542052ca8cb6f9b56ad06edba9a26ba85a7f33938ae059e0e","captureIDHash":"a99592d4a12285f7f17bd31c2c9936815f69849d4065a5c834d00fd3ca49a161","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"ed8bc8b41a66a93ffb58c1bc4b0cd1dc40e75caf0cb050e3feb4b2a402882496","id":"settings-notifications","kind":"visual","requestSHA256":"fbd20a8956ac61d5fb44e16151ddb9834b0e1c9966b540bb787c82f53a32568f","screenshotSHA256":"6f265e6031c39b4f4538cde00975d2bd5850139faa8110c7193ffa1c31b27008"},{"canonicalPixelSHA256":"49c540a61d15487776ca0827a60531d17ad0ec4f1d0d0e01bb07bb456bdcbc1a","captureIDHash":"e3a9dbcf6c47574d6f0e61ff11f32572f0c8f4dd35748cbeb81853d4fdd6713e","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"56fddc3a9690427cafcf0e1cdd08665d4d14ed8153530b09ba69127064849d73","id":"settings-agent-workflows","kind":"visual","requestSHA256":"69d15a3f7fe3c38ef059c8f07298620dccd101f4d678c5759b19b2c3bd1f1970","screenshotSHA256":"62de000d8de491b3572caab097876386f9ada015e2bd468fedcfe0d5b3061a7c"},{"canonicalPixelSHA256":"fdd901ffaafe5151f74fa380a47be0e706b7378720981bc9c9672c7f9a237ac4","captureIDHash":"c1db3bfa1cbdef58f4dd910f3834a7d07ef55ba9c043ffdd38c38db0f4996a77","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"27ff10a7cbe4e9611e4b912968b49a0990344467a6724e1822f9df3d46c44f42","id":"menu-popover","kind":"visual","requestSHA256":"cb03f3378c6539e637e300b154f9bae22b5790e2194b5c5d721072fce285b76c","screenshotSHA256":"eeef7bbc1d525a12c837ed375d019ef6d0572c67f6a7a3d3019f5d5bb3c968ee"},{"canonicalPixelSHA256":"aba25df3a105be22df12949fd75eab620f1def56cbf28f23a3b809128c0341da","captureIDHash":"c3d76f5f4afe7eb7b7e7790f654442a2b26cceb06dbe6dccc76983689a8c8e0b","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"9914a9e83ea939710ff005e908dcf7d934c3c8e234af514d068b79bb5d8798db","id":"main-increase-contrast","kind":"visual","requestSHA256":"6c833933f9d386ebe2a4a1274cf627c26065b32d6795a50053637f65bf292140","screenshotSHA256":"8887aad35d70aaf6a5162d7528cd94f58dad5b3f7bbdce650a1a7d0c5153fad0"},{"canonicalPixelSHA256":"7a91ce346b0d8c9fec3777fc2cccc6e30b83588cd0516b33ffca0731e7c5e87b","captureIDHash":"6486fbf71188442bb35452cbae4a577a5f771d1ca38dd9b9df2e2a7c751dc925","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"55b4c4bbe5ea9f0edfce079bbe5e6b1e3750772e054b47c0ee7b41f0f340ed9d","id":"main-reduce-transparency","kind":"visual","requestSHA256":"3f511ec536dde4fa5f62b835eab9f3e7f3665bcd04f51e90c7b27c1471a67146","screenshotSHA256":"843a01c3f5ca32f0c7c8a9743b4f0a578cb87b78dd92443fa2ecff83a37d87d0"},{"canonicalPixelSHA256":"313d5b773c2b7a4733a044729dfa22dfd1858c304ff0c9b6cf8791c0ea2cb542","captureIDHash":"88fdc0095398ce3d9842f6e8caec3238a45f84c5008fc8807b88502b05d9a087","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"1eb77080b9834b3f1b53418e05a820d3dafd241a7f1413069ba3ede5b8eb1a35","id":"main-accessibility-text","kind":"visual","requestSHA256":"06ef1a3339cea079de91a3a2a475dfe89e27d7610e3145191dec223cf4532536","screenshotSHA256":"9d78d42f9f30a06b733e23e1f348f5e2906aef322f7bf3bd829abf338add2dc7"},{"canonicalPixelSHA256":"3b235d77b5f0833999777f1b35b7321f466a84be3b4058463f0a03df4aadeecb","captureIDHash":"be1e8bb8561d6150160d779c2cdf4e845581f667b5e30a9bfd6d0f2203b2ab76","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"e901ba0c8856be9af07fbd243a0d2e2921090207a00ee946327a812f36746093","id":"settings-general-accessibility-text","kind":"visual","requestSHA256":"13cad00f5411b5406a7eab48f682dfe28689719ceaec223a1fa2ec1cce37cf7d","screenshotSHA256":"c3de664a8924abd3cda0dcb2b876f4f72210ae337798f8d3085ca2d57da00a11"},{"canonicalPixelSHA256":"dcc1c62c9bdd03975685c0412c25c24f3cf24b9cd1825650597ff6e442203184","captureIDHash":"40d1a66b315ba1ba019a5c5a887380d475e90586037fd1097cb6883cc680cda3","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"28de6a141770cbe74cdfe64206e4a80d3bff7c936b1cef176109a05caec99157","id":"settings-menu-bar-accessibility-text","kind":"visual","requestSHA256":"b98b34396a5424617583574f815c1cc15c43b40385b41238b4ecefa289077fef","screenshotSHA256":"cbe4029401c85b651f15e1ddcadc19c3afdbe9599968c4a4915059bd67380e90"},{"canonicalPixelSHA256":"ef248153233c0d3a8b4a0a0bdbf230053ba225db233ed4838c18400bc275a820","captureIDHash":"a792221c9a23317877194833b0d3476dfd1800d9f607b7d222ef1cd425e302c5","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"9774233b61ab4c7a7201a1efeab03242cc112c06ce67fd8bd3e5722772fdd86d","id":"settings-notifications-accessibility-text","kind":"visual","requestSHA256":"8fcb30e4f1eb18e8f07b3a932bd9cd35dc16fb5d86e797912f1055c5e8365dba","screenshotSHA256":"b7a2d88f6d40a63bf1e63d369dc3379f1019d402c45663329a3518730459ca18"},{"canonicalPixelSHA256":"fdc4dc792d92f44d7b44973d23080ce95c0587c174d9c29803e9cf78933fded4","captureIDHash":"3ea04fe7a1bc9c873330155e80648bf62bc770b7227da758a8026adf5e40cad7","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"e01527771182cb989d4f4b43acb145dddf01bcf5901af976ba43e7034f3e33e4","id":"settings-agent-workflows-accessibility-text","kind":"visual","requestSHA256":"60bb10f84325eb39f88d57aae132df4495f96d82cfabe5dfdc2ee7661a48c875","screenshotSHA256":"f7df137d87e4ac2dd93e51abe19e3b967eb181589b3c8c2a546c974d1ded4943"},{"accessibilityRawSHA256":"a37b8fdb129399cc26d6db43892ed4a95f864268622fe4d5292e153d42ec4ca6","accessibilitySealedSHA256":"17605a30084984ef3a07fb18bacbaea6e3e537068a8801300c33f37e4b4ec4e2","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"e798c23538f4664102eed8d6e9c4a68957da8beb81e849bfe4e0999f475132bc","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"3a93c01220247d32897f900c826bc930911d02fdc648991699cf331d6bf529d2","id":"confirmed-owner-headline","kind":"accessibility","requestSHA256":"357c7554d9b7565645537f5eeab8e94e954d332fbb15229dcfc9c55e400ae42b"},{"accessibilityRawSHA256":"2ca53bf9decd605874557277ef9eb8f44666bf507425bbe6b36de6e8c7fe0733","accessibilitySealedSHA256":"078e89c5bc4c9c7e66d955450c4a178dbd6c68cda4f9dac3c395f79cd836fc2f","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"a70d89ae00f7af63f05301c1325c23127510303289b52cbc44ea3b760ef8cd7f","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"ccdca7825088149eec88daf78cfaac7b672520b24be67e0eb475140198b55b4e","id":"correct-per-fan-target","kind":"accessibility","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7"},{"accessibilityRawSHA256":"80f3d3b237442c27a73a9a3c0ae9a5e827673c20b4515fa5a4a7d56edfbeaccd","accessibilitySealedSHA256":"83f247bd796545489d832cf12c531b32afc09e5102971bea3f91d5af944ef106","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"9d8d652cf9550a07b8bd3712bf5cdf65077090e08ad1542aadbf64fc49c5273f","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"8a6a9f93632acf95e98174d9da823331fef342ddf374ca79c5a08042fcac5350","id":"six-adjustable-point-controls","kind":"accessibility","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7"},{"accessibilityRawSHA256":"aa113a3c1b8098904e4f658196071c65b0827996f118ef88255f5d360c9e5f0e","accessibilitySealedSHA256":"64a248224b083246c822f7fbb4622f6f3384512029beb70cf5e66c3744b6cf92","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"4aed4f84806f7a3297b1bf4593bfdf3a5abbd4ee803051404c31e3c65caa23f6","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"b1315fc358ed2f5b201d7309e3e6742de321f2876b4721875aa8c6cdb5e0a1ec","id":"sensor-selected-trait-value","kind":"accessibility","requestSHA256":"4a103f7896f25e5db1c8c154a9d5bd7f80b031b0b395f4fd4457e34456624e33"},{"accessibilityRawSHA256":"e4b57113bbcf91c9169e01740bb433dd13a55f6fe978eed6497e95356fba00f1","accessibilitySealedSHA256":"89877133f716c61d0197e200116c7968d4baad7449792f1cab24999aca551b49","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"34d6ec2262b0b22b91f160359768e3ed0a3e0190cc7eddfa0bdf77b13776c8e1","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"49e3bdfa6d3607e29c882d2c8219e64b37cee81a72556e3e28a29ac208ab1564","id":"explicit-temperature-role","kind":"accessibility","requestSHA256":"4a103f7896f25e5db1c8c154a9d5bd7f80b031b0b395f4fd4457e34456624e33"},{"accessibilityRawSHA256":"6ea1cee987a6620a478c7ff4882d95d297480b1823ba1a46b18e511772f80b2a","accessibilitySealedSHA256":"48bcd06a6607816c4b16caf2871593ab3119bee4f82e16800adad40d78fb21d5","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"ec6ab1c0f33097b3d7910a6ce36e1590bd08fb54a24cb2ee12ae1bb231231c1a","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"2e9c59e742d5377d78519b8b872086e65c0d84ff5482817d5e62f7b761080aa3","id":"notification-actions","kind":"accessibility","requestSHA256":"55c3cb22d211c8164b11e63689ed7dbf259c95e1f8ff9e612e1514aa7d6ea683"},{"accessibilityRawSHA256":"2d89f45e126e80511a6f25a9e49ec0157cf3bd3cc7f920871f136409cc2e57aa","accessibilitySealedSHA256":"46f85213325c766b2b8c74aea6ed75a263aed1defa6bc57283ddea4adf4d1c76","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"6dec01e4c105eee0fd94f9c96c8ddbb1d5378136cd3251c63314265b7a983eae","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"8cc35b805a0e657efe9a972f013a92cd5227fced2f63dde6f90724c05f2c0c87","id":"settings-logical-traversal","kind":"accessibility","requestSHA256":"987e3e64153ba3cd3b55b8d2c672ecf43f00a3b7d7957de79a6ff2103ef01aa1"},{"accessibilityRawSHA256":"c995870b860954f099bbf6c8faa035d92af37b8e4fa8d8a672526411c951f283","accessibilitySealedSHA256":"c7c558f851e49f1df3a208d87618c2e4035ee90c6de66b599dea7c8dac949b4b","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"aa88a7c3f481eeab29451119d04f008cbbe27710a19d80dfacbf94d3dedc923f","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"8e581d06ea04baea9c1c27162fac7e7e92ae933f77e754395c6dfbcce58bf4e7","id":"no-duplicate-chart-elements","kind":"accessibility","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7"},{"accessibilityRawSHA256":"1b84e600ec990a65f9127694daffbd23a9cd3161f972d7fbab49a9733ebeda5d","accessibilitySealedSHA256":"c39fe85f8733ebfcef5f331184df9b2a443a0036b81814a730a0904663023e77","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"f14148ee4b625427b8b3ea2a1472b02d62db7ff24f14ac53e4426f8aa0b02ef8","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"d0671371083984e0e0c51455527c1f2a319ceaa1d124885ffa6e690bcc48384f","id":"compact-main-scroll-reachable","kind":"accessibility","requestSHA256":"9d3fbb204496fe492711815609ee6ca684d66073373ff6ba2415ef7240679635"},{"accessibilityRawSHA256":"21be6a2ba17b3a87f7a805ec5b031595703ad552d01bd19d3ee1596f87d08e01","accessibilitySealedSHA256":"0efa4dd681df903bd9eb34b47b614a6b4148aa0421ea2fd4ed3080fa5ff6e6b0","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"eec2498ca86ed888e2c0124df0ab5761254b7f1724eb4c2e678df66e116be368","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"863430ba2eb8e59df6eef661f45ffb03cac24a0b0c3a8873d7b9267c01ec4a34","id":"settings-general-scroll-reachable","kind":"accessibility","requestSHA256":"4c086d7fdb10cf87ca5a6ebaf3703bc412ea27e75a4fe6b43646bbad25b3bfca"},{"accessibilityRawSHA256":"4c9f15fb3440b40d1e4f30efc2c8486eaa528cdc519f11185c8f5a8e37e41736","accessibilitySealedSHA256":"a5c43f8c75e5d02fe1bb204f3d723e51025d227f60c480e0b73b74eba63f8ea6","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"b6e8fcb7e89940e0b4add5dbe739341fadd1227e778ca233c3cfe784819b3144","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"5ea49940cc13280b3bd7c99339fdb6b76f0684927f4b33c14d965763c724dcbe","id":"settings-menu-bar-scroll-reachable","kind":"accessibility","requestSHA256":"bfa01810723b71dc34a9c3b6a94a161960e60b6ac318db09970a6d74103e24f5"},{"accessibilityRawSHA256":"00002b68ce1226bb427b83ac9215817a0bcc9f296bbae4b43dc0fb5312259db1","accessibilitySealedSHA256":"b7765351e20b706fbb0c7899243c04e2e5c48f98508f4440cefa9f4984d7c223","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"cfc1687bc158ebdedabfac820069b227da28e4a458033d8f6ad7a9e4f3d9067a","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"0e4b27245bab4c82948cbd4ba5d17bdae170339acb0d80909be611ea409822b7","id":"settings-notifications-scroll-reachable","kind":"accessibility","requestSHA256":"93c79cd3053aaac63f572258c8e558b147f1e76cb23ddeb9335243ddb568cf3c"},{"accessibilityRawSHA256":"725a6c291cb6eb66416cd68d0f485e5f4183df6d8c0643a4bcb77889eed99c04","accessibilitySealedSHA256":"c989f8a65915c217683815fa322d7b1b5ee3d3a4bb918ad24274e050cdf21540","axCollectorBuildProvenanceSHA256":"c51ae68424290cea029916e4f24af8b04b5ca0a7d7ce01a3a9911176ee051748","axCollectorSHA256":"e61b1b57e5c34f7e98414d9279eba7eb06bd70eb46c4a4fd3d2baf4ca154754a","captureIDHash":"2128550d8276de75664afd7e510e9d4580a6c4910f651ecb002b1d10ec8ce4e3","debugBuildProvenanceSHA256":"c35c40ff8be367f9770a1c7f6dab30712a197d741a8cb0f74b0434ac36bcd54c","debugFixtureSHA256":"e0a424e2b90ae2845695b24855ec88076c3eaa8709e3d70eb06f289c77e03280","fixtureReportSHA256":"96cb7547e60b8e65d932ba8d24be93ccc0df18b39e4849f9c96d68517490729a","id":"settings-agent-workflows-scroll-reachable","kind":"accessibility","requestSHA256":"07994c8a7f853f1444deffc6447b8b21a8fc44bedc03b446b474d81b01254db1"}],"safetyAggregate":{"attemptedExternalMutations":0,"attemptedHardwareCommands":0,"finalReportsPassed":50,"modelStartSkipped":50,"realControlPathConstructions":0},"schemaID":"https://vifty.app/schemas/ui-review-automated-checkpoint-v1.schema.json","schemaVersion":1,"source":{"commit":"e5b75764fd84c2e0a70c1d7e60a3033fa999df45","manifestSHA256":"439056fddc164740229250cd639268545e6bd89816ed559d537f91416904770e","tree":"1654ddb3a847bc6ed193e56a9ecff21e611e243b"},"status":"automated-passed"} +{"counts":{"accessibility":13,"fixture":9,"total":50,"visual":28},"evidenceKind":"hardware-free-native-container-debug-fixture","hero":{"canonicalPixelSHA256":"42fe34fa9add13e9360f3030e2ff6458513dc70857d57b8d04c0ef5203ced332","captureIDHash":"874689bde574aa2f551e467b05be84427b90406b5756e4e1ceade7de234e2683","heroArtifactSHA256":"77bfdc4c2284b16096ca877b44c094576f773d6244e39b1aa738a7186f5d1a89","rowID":"main-1180x820-light","screenshotSHA256":"77bfdc4c2284b16096ca877b44c094576f773d6244e39b1aa738a7186f5d1a89"},"nonClaims":["full-evidence-bundle-not-committed","hardware-compatibility-not-claimed","release-readiness-not-claimed"],"products":{"axCollectorProvenance":{"buildTransactionID":"fae136354b90306736d101981e16da943951f666ccc76beb43e4d3da3408086b","configuration":"debug","productRole":"ax-collector","schemaID":"https://vifty.app/schemas/ui-review-build-provenance-v1.schema.json","schemaVersion":1,"sourceCommit":"3b869337c1249c18d26caf4a0558dda53152e775","sourceTree":"756300206274844d99fd8202d44592522cb3fcd0"},"axCollectorProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","buildTransactionID":"fae136354b90306736d101981e16da943951f666ccc76beb43e4d3da3408086b","debugFixtureProvenance":{"buildTransactionID":"fae136354b90306736d101981e16da943951f666ccc76beb43e4d3da3408086b","configuration":"debug","productRole":"debug-fixture-app","schemaID":"https://vifty.app/schemas/ui-review-build-provenance-v1.schema.json","schemaVersion":1,"sourceCommit":"3b869337c1249c18d26caf4a0558dda53152e775","sourceTree":"756300206274844d99fd8202d44592522cb3fcd0"},"debugFixtureProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","releaseExclusionProvenance":{"buildTransactionID":"fae136354b90306736d101981e16da943951f666ccc76beb43e4d3da3408086b","configuration":"release","productRole":"release-exclusion","schemaID":"https://vifty.app/schemas/ui-review-build-provenance-v1.schema.json","schemaVersion":1,"sourceCommit":"3b869337c1249c18d26caf4a0558dda53152e775","sourceTree":"756300206274844d99fd8202d44592522cb3fcd0"},"releaseExclusionProvenanceSHA256":"5257482ba7ef555ce91685ec2c818542873e785addb46bc19c28f980969863dd","releaseExclusionSHA256":"a12a89edcb91785d3fc86caebe1177371cf9b292a410235741e58d00008cbb8a"},"reviewGates":{"visual":{"claims":[],"priorEvidence":"superseded","status":"pending"},"voiceOver":{"claims":[],"decision":"skipped-by-owner","status":"pending"}},"rows":[{"captureIDHash":"ba8bbb9cec1d2beacfb6d2b5c42c67807571dff7e9a261d5b278acf16aca5092","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"deb1bb6a370564259c5d9440828ed29eb23bae24a3042bee5701b7941266f318","id":"healthy-auto","kind":"fixture","requestSHA256":"b98d552cdad1f859cb12af693cea3259509f804a9b9a69c780b7954912a55db1"},{"captureIDHash":"c498e96f579a084a639446e7421a4e8783323b6732842660f234ddbfc2edc3e1","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"688d16a6695850ff795a7d14c1dda6690d1bcd9e6f2bdda91f162dc049626c30","id":"divergent-per-fan-curve-draft","kind":"fixture","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7"},{"captureIDHash":"37b1a1c3f37f481f688cd595374852f6473c9897d7c16b52ab8207053d45310c","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"a7e4bf13ad763fc4286e9a8158afc9b8d0f11f123f8e90cbfaf097dd4d31d8cd","id":"active-manual","kind":"fixture","requestSHA256":"357c7554d9b7565645537f5eeab8e94e954d332fbb15229dcfc9c55e400ae42b"},{"captureIDHash":"93295a5162a083ef0bec89d2402791279b7409d0db8a2e7ace9b1f5899046e9b","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"f17856b3a45c0be117d8ea60916a4c86f31b1e355c6dfb7e973a4d61ea9dc6cf","id":"recovery-mixed-ownership","kind":"fixture","requestSHA256":"922dae33cd3e1954f5d29d3edd1d58a66848229dc290c9e6c4e59627c0dac46e"},{"captureIDHash":"fe7dfaf6b904d2ae941d02c152e3bff28c27b70dbefad17e4fe8caf134c59924","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"7c831b3d012d93ae9832f31bd7d485c6cc5e4215277c5e8bfe5592053781694a","id":"helper-blocked","kind":"fixture","requestSHA256":"266bc5b039931c7d15d938674309f8982d60faba4f17c3b95e798f9750901597"},{"captureIDHash":"534d6bfdc023036ec2ef8f43cf475edb73d6fd8ec2bad9fb9d030a5c38fe34f9","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"2d685f444b314f78cb710c05940f4f4f897f1490c59c321c32f85559a5437fc9","id":"notification-denied","kind":"fixture","requestSHA256":"33b9aa34cb75aa2f7221410a4529d50d0228729eaad6c8990f6892ea59c7fa86"},{"captureIDHash":"0156c62ca4c7b7f4cf976a0c77d30afae9d5489e9bb03d1a496ecf167aebf3cf","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"593aaabbe60ca0a2a633e76dc188e1265e38e2aae62cad58ff5e4e3063adf472","id":"edited-profile","kind":"fixture","requestSHA256":"17c3ec7261f8c10e2c607a9049642417406fb500ef3bf65141f1b30504456a07"},{"captureIDHash":"5867305bbef0a8e5ddcd50a5a41485cf58db30dc4593deea53c28ed596ba1716","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"6ba836945c9b14c84f56e06a806cf2cd20efbff021dc27dba7a535e68578d879","id":"selected-vs-highest-temperature","kind":"fixture","requestSHA256":"4a103f7896f25e5db1c8c154a9d5bd7f80b031b0b395f4fd4457e34456624e33"},{"captureIDHash":"f9a7afa559d726893a8fb019c372fff80db8581d8217a3513e3762f5a4c53f31","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"1d00e62ce4fb24ace005d67b65d0fd1686622f7dee8acd6753f3c79e69190089","id":"raw-spike-telemetry","kind":"fixture","requestSHA256":"cb850ba1eb313e2daafa9263efe5e3b3eaceda51dd4dd8a56e6725d085fd2fa7"},{"canonicalPixelSHA256":"74076c8a14e41151939af80a5d532fdcf9eb26c4ae5b1928929e902903d6619b","captureIDHash":"7cb5d50dee5cc095c59e613bc15a783a46e782382e9008eb1fd1c5cbc31418ca","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"c389f8b49e465b14c1554d13cbc9566b6b4cf4dcca7786a430b13189766afed1","id":"main-780x480-light","kind":"visual","requestSHA256":"6343f043c95507a0bf3bca03d4b2640882f1da998b7c760d51420815137ad42c","screenshotSHA256":"d428a4f933da448817f4879502998ee083456ea7c5148739e1759d54ad5799f2"},{"canonicalPixelSHA256":"461d62e06ad3f3de2bdd4e988ef4f9bbfffbaf13bf0a3062a0ad77aa4043d813","captureIDHash":"ce2b7266c542aca3adb1eff808e944dd9f6468ff2a1a7146732ae8f054600b80","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"c066d32b2a00c80622dd07cbe2a351a522999db159692e8e57349f712f0e9691","id":"main-780x480-dark","kind":"visual","requestSHA256":"7a7a94aba066bc74a0a4d39bd907c4a967b151e3d32ea5406bdc9b0bc1a10791","screenshotSHA256":"2ce957137af73fac6755b0d8d0235b61c30de00176ef7877ce0371a385037def"},{"canonicalPixelSHA256":"42fe34fa9add13e9360f3030e2ff6458513dc70857d57b8d04c0ef5203ced332","captureIDHash":"874689bde574aa2f551e467b05be84427b90406b5756e4e1ceade7de234e2683","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"331d4a6d7a3bb497a4f18109c1e360fccc7ceb45353fc809e407b892833ce1e1","id":"main-1180x820-light","kind":"visual","requestSHA256":"b98d552cdad1f859cb12af693cea3259509f804a9b9a69c780b7954912a55db1","screenshotSHA256":"77bfdc4c2284b16096ca877b44c094576f773d6244e39b1aa738a7186f5d1a89"},{"canonicalPixelSHA256":"b17b4791855d949a0590d0dd845fd620060df9f07be26ed9449ba66158e3eeaf","captureIDHash":"79fe5073dfe115cdd27d21c23f4365e097d4669ce9605970770fab10b2b98aa5","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"0eda6038d81b51dacb93d1f7aa3a4777e948ca9614a92672d43479926caf06ae","id":"main-1180x820-dark","kind":"visual","requestSHA256":"0df86b8f7a07fa1e934a40ad455b217aeafc3960e918904434292a7a2bdd8b91","screenshotSHA256":"2d7874f72dda5b2d54c2a50034196e08e3e2c17f69d2bf718269cea9bd830e41"},{"canonicalPixelSHA256":"f259553554a5d3ebdc4331447ca96db5387098185364e5b8f3c3671cde41b124","captureIDHash":"3491e075da65ed261b060aca860012ac66d3067026b3b43273edb602c7b18172","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"016717748147828ed4ac9fd3a7746e9c7dcc5984350e4c33f296c50f7f713234","id":"main-1280x720-light","kind":"visual","requestSHA256":"edcb941caf1c1240669a4e9be836e828c568fed10c251eb284ef9d81bf70753c","screenshotSHA256":"b6d3269b95035fbca880780d02433bfa41e14af096df71ee33d7039c5245757c"},{"canonicalPixelSHA256":"7e066eaaa346c451349fcfad3b59bf23650c3b173f47c5faf4176b60b0666895","captureIDHash":"dfe9b4a0aa63281b4277494c68c32392da6ede7afa68f53e21c5b2805c25985d","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"ff9f22b7d05046678850c3483e6cf521ef656f6092bcc1e6b86d82d41faef012","id":"main-1280x720-dark","kind":"visual","requestSHA256":"6367c41b8dfa354e76ac7b3bfaecd5ffafbc78ec8de475cef7b13640b3dd05a4","screenshotSHA256":"b5e4f0a2aa20cb05f03b439cba3628cf28522f9fc2d310f657290e70d6b1b52d"},{"canonicalPixelSHA256":"d606e47fc33e278fbbf3526e78d2cd7dd0a14a2bde2351b683ae9610f6c61920","captureIDHash":"75bf5d446409608753bb2074be3171a2f78de7b2519a8f6caeb2d54ddf160460","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"96ea1579ab8fb1bc433b81daa6613ba6874efd99bdb14b912ca69b9559f126dc","id":"main-1500x900-light","kind":"visual","requestSHA256":"583ec26d1455fdcdb4d931d699a3c478a03cfaf87d81d9128b865ecf2fc57992","screenshotSHA256":"e75f2afaa53805355bcdcb1258a65cebb4af6168333bf195dd7e6fe3d7957223"},{"canonicalPixelSHA256":"8c84479886accb90c0170215a0b623380b5b27d1548c3bb1e944ee196281494c","captureIDHash":"6d4f3bee4ebedf439376853a39180c5def249ffa48cf2635dc4153d5fe5b92f4","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"733bb93496fd3d3431de2cd43b932e6e7d7e74d888395c90bc840181fad1033f","id":"main-1500x900-dark","kind":"visual","requestSHA256":"86473313ce5225cde9c29ced6f68f3513b0fd9e0a647a0d97aeaf2cbf4d6b73f","screenshotSHA256":"ecdbd7a9c5f27e97ee6e8f22054e9a761284a4781a8ecc9f240e47ddf682af5a"},{"canonicalPixelSHA256":"256ecfa238aa4bba6410baccef9aedc931d07bb43903602a9b54c8e150d75d4b","captureIDHash":"3191758a8c657f4985892462ab765f3feaaf7f794a3be4d734a3f4196368cb87","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"5144181026b59ec9e0118bb8e94e0debad8dd2dcdd2e86ef570f09d935196e34","id":"state-divergent-per-fan-curve-draft","kind":"visual","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7","screenshotSHA256":"545c346757ce6a803737aa658b0f4c26247a8c80fceee69c8a574d345bb75a12"},{"canonicalPixelSHA256":"0ad95f87c94de44c8456e36dcb633b87dfd6add2f4740742ee2751c6369422d2","captureIDHash":"3b12b16f03c6d15239d1787fd6489e1aba5e398fe11dc57df49c36ca6de3b933","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"e639ff6bf1f80e574b55487a05759e6d785020f453a41c461e4a1583daeaecf9","id":"state-active-manual","kind":"visual","requestSHA256":"357c7554d9b7565645537f5eeab8e94e954d332fbb15229dcfc9c55e400ae42b","screenshotSHA256":"8b8a659bca3d21e7d297e74d8341c596db0233531aa44ae87ffcb1957a1e2912"},{"canonicalPixelSHA256":"8f16bc4324fe93d1a7d41f198e60e714a6109d8d3e8dd3c86d1c26ba473ec2e5","captureIDHash":"0abf741f6ea9b6acfa736917d30af752df1136edd07905bf7db35a31900e1e15","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"6ff0f3b09e10138416b8c6bfac817b52cc5b4c734468bd991c6808d508e0e1e6","id":"state-recovery-mixed-ownership","kind":"visual","requestSHA256":"922dae33cd3e1954f5d29d3edd1d58a66848229dc290c9e6c4e59627c0dac46e","screenshotSHA256":"08be09730f7c890f35bfd93581c29a917dcbb759bd3b273c05bfca35557c8325"},{"canonicalPixelSHA256":"8fe4131c1535c5f3f6ea5ea352c75d66356388bc27fa50902a8fb05c7ee23225","captureIDHash":"98c5ab00e16b98d23ef4f249f4416098d52d38b6e98e9cfd03c381b6d760e257","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"e27dab75004b0d1d045298662660fcd9d9c9718b3aade42e6c85718e06c350cf","id":"state-helper-blocked","kind":"visual","requestSHA256":"266bc5b039931c7d15d938674309f8982d60faba4f17c3b95e798f9750901597","screenshotSHA256":"0d35fb6bc8355a3976f872833624520dfa03cc7832a1b5a8096d8056cefff899"},{"canonicalPixelSHA256":"f7e61fe1f806f435d167efa0b05d4ba98e8f285f32ca8d7d334e5d5e2a9b1a2b","captureIDHash":"333bb47578fd319db63d9741728d50163aaa3d9f0f4ec0499f0e1acc0e6995e6","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"1b722ce86733033c8f03983f2257feacbba0ef22e1422972faa2d609c0f4e37b","id":"state-notification-denied","kind":"visual","requestSHA256":"55c3cb22d211c8164b11e63689ed7dbf259c95e1f8ff9e612e1514aa7d6ea683","screenshotSHA256":"7c9710a724aecdd57d7cc0debc2c2c3571d9a043cccb96747b35729934f44e7a"},{"canonicalPixelSHA256":"2a24502516d4df8e266823c0a5d7b6af91e62f6132ee864c73a59545257bec91","captureIDHash":"81849198f873b88ec0bc30b7d87d4b5f38e5b14346381453f254b478c99e43be","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"8daece70dc353dc5a1bda0bf0ed9e71f2957dafbcd28052035fdf61d8acdcc62","id":"state-edited-profile","kind":"visual","requestSHA256":"17c3ec7261f8c10e2c607a9049642417406fb500ef3bf65141f1b30504456a07","screenshotSHA256":"af1947ec170cc2015f709851091875c250c9c8904782883e9aa6ffb57b9f633f"},{"canonicalPixelSHA256":"184c9cc218b3cfeb46e5d1cd29ddee7d5e65eb867769c2194872290c23def3b2","captureIDHash":"32519f50114fd416f47e65518575396c1d474ee78d2f9e5d6ee071d6492acc56","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"a295054660b8940380b51ae151a5aee543a1f65c465c69ef970d023884227a79","id":"state-selected-vs-highest-temperature","kind":"visual","requestSHA256":"4a103f7896f25e5db1c8c154a9d5bd7f80b031b0b395f4fd4457e34456624e33","screenshotSHA256":"1918d42d4334d5de2712cf93c9bb51fde45ebc93bc9989e3beae9861ca2ce803"},{"canonicalPixelSHA256":"f4e6a2f2c87096bec6b90cf96a3dc0807e3b985d3c9614409069b17583251189","captureIDHash":"2acc45f68e26bd9f9a783797d007874ef95fc5b7e5e1e431e55c46420d28f431","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"b7d82089766997ea311d0eb1fc085c29c65751afac976e921d54f9c4b8a78aad","id":"state-raw-spike-telemetry","kind":"visual","requestSHA256":"cb850ba1eb313e2daafa9263efe5e3b3eaceda51dd4dd8a56e6725d085fd2fa7","screenshotSHA256":"44d5a595f896759d596d39d58745a5970fe34e9aae232529e7eba3b55acb6c46"},{"canonicalPixelSHA256":"5779213ced63da391e54cd06a939e30910a128c23622e66992314a87d1cbfa6c","captureIDHash":"b732ae6dd144cf24cd8bb9a9e13e9bcbfc41782baef772e028c00c6e596fa85e","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"1a2a849d343a971481ef7e76ee5b1c69fd0e33911be0f859638d9b42b2952431","id":"settings-general","kind":"visual","requestSHA256":"987e3e64153ba3cd3b55b8d2c672ecf43f00a3b7d7957de79a6ff2103ef01aa1","screenshotSHA256":"e218f53cf24f219f40fd4d3cbd3cd76533f7d3ca670bd31e6b5b6a36c5162082"},{"canonicalPixelSHA256":"0edfa965601687dc41a0ec4fe4e436a821310372d71df4727f6de3fffbd028a9","captureIDHash":"e2ade2e6e8b47563f1a44e3268662397914e6a43c6fbf5516e886d2b916f4c54","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"e38cbcdeaef29ed7d5ed090adf6a44ecdb27bb317300f61a153d0ba2d98f9284","id":"settings-menu-bar","kind":"visual","requestSHA256":"398d0ace3621d468b0dc8cf7dce1ae4a23a064dfbf60ed702cbd819e97e821fd","screenshotSHA256":"9f673eb27a191424072fea2290e92ce7d9eb3663cb5821cb954957b774814102"},{"canonicalPixelSHA256":"90b09f5fd0e8bd6542052ca8cb6f9b56ad06edba9a26ba85a7f33938ae059e0e","captureIDHash":"7e7251afebd5e52f4802f01b78001ad4e2006e9726571de8f9987aadbdcd641b","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"4c8a19eb8872416d493e004f59669c3ecc0e1b9e09be2438af780064797888a8","id":"settings-notifications","kind":"visual","requestSHA256":"fbd20a8956ac61d5fb44e16151ddb9834b0e1c9966b540bb787c82f53a32568f","screenshotSHA256":"6f265e6031c39b4f4538cde00975d2bd5850139faa8110c7193ffa1c31b27008"},{"canonicalPixelSHA256":"49c540a61d15487776ca0827a60531d17ad0ec4f1d0d0e01bb07bb456bdcbc1a","captureIDHash":"ed474aca0e306c033dbef57b9cf804b5d669a7345b4e548db873086b5349db4d","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"6113baaa08a607188f4b74cb66efc48c5717e7d41b5cd23e6da53509defc4d3e","id":"settings-agent-workflows","kind":"visual","requestSHA256":"69d15a3f7fe3c38ef059c8f07298620dccd101f4d678c5759b19b2c3bd1f1970","screenshotSHA256":"62de000d8de491b3572caab097876386f9ada015e2bd468fedcfe0d5b3061a7c"},{"canonicalPixelSHA256":"fdd901ffaafe5151f74fa380a47be0e706b7378720981bc9c9672c7f9a237ac4","captureIDHash":"d8e57ca953790a9f1eb0c68d26c1217df801246ef6b1c1b96704a56ac0fa2144","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"22316b3ece3d864ae35048927c2fc10c7a9bcd60ceca7a399190e38147102f5a","id":"menu-popover","kind":"visual","requestSHA256":"cb03f3378c6539e637e300b154f9bae22b5790e2194b5c5d721072fce285b76c","screenshotSHA256":"eeef7bbc1d525a12c837ed375d019ef6d0572c67f6a7a3d3019f5d5bb3c968ee"},{"canonicalPixelSHA256":"aba25df3a105be22df12949fd75eab620f1def56cbf28f23a3b809128c0341da","captureIDHash":"050c6ba33091111e05376fcd9993f9c90a3a4a2b03d3d82a7400e7b1a40b777c","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"4bd239ceb83552d426dbdef66992ae1d71f808b7108f968c36e4b3dcea65006d","id":"main-increase-contrast","kind":"visual","requestSHA256":"6c833933f9d386ebe2a4a1274cf627c26065b32d6795a50053637f65bf292140","screenshotSHA256":"8887aad35d70aaf6a5162d7528cd94f58dad5b3f7bbdce650a1a7d0c5153fad0"},{"canonicalPixelSHA256":"7a91ce346b0d8c9fec3777fc2cccc6e30b83588cd0516b33ffca0731e7c5e87b","captureIDHash":"d9df091897bfbf80b7a516820c9e7a6933460818113d336936fd3bf01f77211b","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"e77cc29829587b25de92c12235de287260ae0aaee73a176579c4b3928a1cf882","id":"main-reduce-transparency","kind":"visual","requestSHA256":"3f511ec536dde4fa5f62b835eab9f3e7f3665bcd04f51e90c7b27c1471a67146","screenshotSHA256":"843a01c3f5ca32f0c7c8a9743b4f0a578cb87b78dd92443fa2ecff83a37d87d0"},{"canonicalPixelSHA256":"313d5b773c2b7a4733a044729dfa22dfd1858c304ff0c9b6cf8791c0ea2cb542","captureIDHash":"d189669767651f8c746e7112a65da998c06a26514d43836fb94e26a4132b40f0","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"2d3952fd82728baeb61c4754d3e092d698d273e3352a40183321d283752a21d6","id":"main-accessibility-text","kind":"visual","requestSHA256":"06ef1a3339cea079de91a3a2a475dfe89e27d7610e3145191dec223cf4532536","screenshotSHA256":"9d78d42f9f30a06b733e23e1f348f5e2906aef322f7bf3bd829abf338add2dc7"},{"canonicalPixelSHA256":"3b235d77b5f0833999777f1b35b7321f466a84be3b4058463f0a03df4aadeecb","captureIDHash":"e1de44a9d3b4db97a248b3850027638818c4bd786591d80740556f8d8faa2e8a","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"782a3075eb93812dbdfbb81e4604c51b196f32346c0a9e8c9257b62750f6fd36","id":"settings-general-accessibility-text","kind":"visual","requestSHA256":"13cad00f5411b5406a7eab48f682dfe28689719ceaec223a1fa2ec1cce37cf7d","screenshotSHA256":"c3de664a8924abd3cda0dcb2b876f4f72210ae337798f8d3085ca2d57da00a11"},{"canonicalPixelSHA256":"dcc1c62c9bdd03975685c0412c25c24f3cf24b9cd1825650597ff6e442203184","captureIDHash":"babac13e9a4d6ef55059037a2033878bf1c13973383b6f838adbc4b54ae02396","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"63efae131e5d292e7606326e46d5c2b29c08b5ddcaa4fd3f3a952c6d011560a4","id":"settings-menu-bar-accessibility-text","kind":"visual","requestSHA256":"b98b34396a5424617583574f815c1cc15c43b40385b41238b4ecefa289077fef","screenshotSHA256":"cbe4029401c85b651f15e1ddcadc19c3afdbe9599968c4a4915059bd67380e90"},{"canonicalPixelSHA256":"ef248153233c0d3a8b4a0a0bdbf230053ba225db233ed4838c18400bc275a820","captureIDHash":"55e9436b4daba6989cb20cbaf7405cb98287e24fae37e994aa9b408e95870e58","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"f585d5c2a3be4acfa49f209ba57579f2bf4922c2a5225e8ad625f69470134555","id":"settings-notifications-accessibility-text","kind":"visual","requestSHA256":"8fcb30e4f1eb18e8f07b3a932bd9cd35dc16fb5d86e797912f1055c5e8365dba","screenshotSHA256":"b7a2d88f6d40a63bf1e63d369dc3379f1019d402c45663329a3518730459ca18"},{"canonicalPixelSHA256":"fdc4dc792d92f44d7b44973d23080ce95c0587c174d9c29803e9cf78933fded4","captureIDHash":"5720dd429540c8951f8069ad650c6a0ee731c995d9e509e249628703c39678c1","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"fcf3f34273b533b00f2a8e5681486ec8ab12445bf2c2231b3ee6244c63f6b7ce","id":"settings-agent-workflows-accessibility-text","kind":"visual","requestSHA256":"60bb10f84325eb39f88d57aae132df4495f96d82cfabe5dfdc2ee7661a48c875","screenshotSHA256":"f7df137d87e4ac2dd93e51abe19e3b967eb181589b3c8c2a546c974d1ded4943"},{"accessibilityRawSHA256":"ef189c0d724ed4736049cfc5a2fe4f7a6738155f49f240d15e0d8bb469354b9f","accessibilitySealedSHA256":"e8e28702f95a37d5273d4625c9bbbb113788b28d3c8ea593560333d840bc9f54","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"e7fe1af7399b640036bfcf356b060756bc25e9c12a09e39bd6db4a3b3259d2b7","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"8ef0acaf79f70cf6cfe0d169758a273178e8b1d8ff927a1f5d67f5edb76d6f74","id":"confirmed-owner-headline","kind":"accessibility","requestSHA256":"357c7554d9b7565645537f5eeab8e94e954d332fbb15229dcfc9c55e400ae42b"},{"accessibilityRawSHA256":"9891c478d77ddc27a8d9c75134adbfa34efba3ff9871e004917d815e5394bec0","accessibilitySealedSHA256":"72d7d5da30de992bad93023af7d5288a0623474e9b1024039ad4136acd089b58","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"f950543b0d4bbcf671b8f6a111be8e0228cdcc1bd4002e15dfafaf58a674be2b","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"90b82ff48a8a38a3787124176378c508d0f3d619cf4884e4e75a8e439b8b80c1","id":"correct-per-fan-target","kind":"accessibility","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7"},{"accessibilityRawSHA256":"7cdfdeb2a0a8b7fb15fe872e548152217a8f7855ff96b43d72048be97d20a8dd","accessibilitySealedSHA256":"f4d004a80eb571e5d9d63aa36ab762aa36e983773860446d13fedf2829535c93","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"9bc2e57b6d10116ad46d66426358a81d019cc513d521a319d1dc894ccf5a6030","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"6ef31333024ecb156535131c5d0d377e0f1aef4214431652c71f4e232f5e4a9d","id":"six-adjustable-point-controls","kind":"accessibility","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7"},{"accessibilityRawSHA256":"69677f3873b393f80a421c353c7dbe447b47d639c1f01ae9ee6b656e8a4fa47d","accessibilitySealedSHA256":"6a9796c1a4752322c35452696e8df126f6eaefce8578a31c91814faf6a161b83","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"b9e21b896b69d6577e349d9b65ddc74a2d02790ea207097fc148fca67ee2ddc0","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"c2b9e1c61e77c030d685cee43e500744099a307778e76e84d0b9df286a086dea","id":"sensor-selected-trait-value","kind":"accessibility","requestSHA256":"4a103f7896f25e5db1c8c154a9d5bd7f80b031b0b395f4fd4457e34456624e33"},{"accessibilityRawSHA256":"652fd899c1cd7c9b8e082b338621866b72034f94a4f9adf6e7b50550400fb839","accessibilitySealedSHA256":"b42c83835f8e30232f45bd0d5270f108c17eb85d9ac59b0e4dcf4ce5e8a801d3","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"a0f7021fb92fdf6fba541d8fa139b2d21021abf55251646925fe9dc29129e695","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"773adfeb74d5ce807f6b082c4963c573cbcc68a8d2e318e1d83f3dbcf5ebb5e5","id":"explicit-temperature-role","kind":"accessibility","requestSHA256":"4a103f7896f25e5db1c8c154a9d5bd7f80b031b0b395f4fd4457e34456624e33"},{"accessibilityRawSHA256":"42b63042930483f2493df9df3dff95b250eec468d56135765fce37f3b6365c05","accessibilitySealedSHA256":"e56adcf1ab7b056660c3d70dafbe316c1e7b6d7a7ec88bf81555c1f93d195066","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"4da7ad8e78218d61bd18e4d5dc38b38a0b5dda3e0f204b9f36d5522aeae5eb31","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"00ea100c055ffd708dfb343419a4f402ed972469fde476a7ae3c139eb5f06cfb","id":"notification-actions","kind":"accessibility","requestSHA256":"55c3cb22d211c8164b11e63689ed7dbf259c95e1f8ff9e612e1514aa7d6ea683"},{"accessibilityRawSHA256":"c8b26c5b073b59c1f5ed8b24f5a757f1b0fb8141640f007495b38ec91d520204","accessibilitySealedSHA256":"44d0ea18b8f22011f87a95466546195f3ea262506cd4b6447a452c83452899fb","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"c53a2d7b15189ba3920c87ccdc674bcd62dcce61258ed1cc10b01a2e43570878","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"43ed55683ba017da6460ab2f8a614fdf25d7a2e5b87dd3326e3a7b96a4dbda12","id":"settings-logical-traversal","kind":"accessibility","requestSHA256":"987e3e64153ba3cd3b55b8d2c672ecf43f00a3b7d7957de79a6ff2103ef01aa1"},{"accessibilityRawSHA256":"64acd8e4796c5b161b5830573221e62c08e56decc5d6380ff5cf636a8b79d61e","accessibilitySealedSHA256":"a6a998d1504d4f9d26047463adbabd05699e8cca0b8f9edfee5f5d995ccff927","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"1d6674fb81b71ec4d5dce89c0860771bf4904953e5c74a806c4245a57d41bbce","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"f4b126709937e83f05922bd7aa3693c031d10c6614a09872f70a55d3802b7cd8","id":"no-duplicate-chart-elements","kind":"accessibility","requestSHA256":"c40244a7207996bfd7d4a20c75467ea519bba3fc710cd0eac417c888d67f2bc7"},{"accessibilityRawSHA256":"a57e1fb404877e17d240082376eee4eeda62b36531652ec874507be3e925baee","accessibilitySealedSHA256":"bd1d6d88d032b87dfcf2a500d9d57437d8802e5e411ee99d2107bb2ef38658f4","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"649e813d049bdee402d5b235a2c9a62df30fdee17b9e439d6e9b6c5fc8b33303","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"ef1dc3677ca35f16b3e852b55f584c8d4c020c89d8ae99f347e0d024ba083304","id":"compact-main-scroll-reachable","kind":"accessibility","requestSHA256":"9d3fbb204496fe492711815609ee6ca684d66073373ff6ba2415ef7240679635"},{"accessibilityRawSHA256":"7d2ee052f6bab3b6eb1a2b63e3ed1a4a10c0740a3775f052d8cb714f18aa3a8b","accessibilitySealedSHA256":"01e9812b8bfd49cf99fb77d2a042189af248604a33f6b80278bb86c76b8e6777","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"24adb28d2f2c8f4da7303ac81b4c092d2f44995ddd1df3bd14e9e5e8819770a0","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"43bbb6ebec1cc41372eab830f643aed8cf0c0570ec03fafcaed430e06d828a79","id":"settings-general-scroll-reachable","kind":"accessibility","requestSHA256":"4c086d7fdb10cf87ca5a6ebaf3703bc412ea27e75a4fe6b43646bbad25b3bfca"},{"accessibilityRawSHA256":"5d4177379f15bdbac27358eae9cd1d737557c9fd8fb37c37b9baa08607470a71","accessibilitySealedSHA256":"ea6358c6ad43691c33e41ff0cbbd6a1c79cf23979d7a602c403b69984c964211","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"6b3b521f271854741bccffc45ff6f516f4690391f4f960397d4b00e545288a9a","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"9d88db9a29a957fba4c5b583e185e2484d0a6f5c8ab89f46357648cc28291659","id":"settings-menu-bar-scroll-reachable","kind":"accessibility","requestSHA256":"bfa01810723b71dc34a9c3b6a94a161960e60b6ac318db09970a6d74103e24f5"},{"accessibilityRawSHA256":"7acbfbdb80e75c4097bc12bd30f6327e1c70741f77c10646a5600f359a01b86f","accessibilitySealedSHA256":"fd87b6139ef1b2a2c098df1773eb7475d05bbb764cbcd1b1caf71c20dc24ea11","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"c4c42dc594b1cb3983ceee9c8d98b362ad17dc755e6956c8947fb75b77ecd105","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"b5012dc341a423ec6ab93764a8e0523d952830808630a45044100554c08888ad","id":"settings-notifications-scroll-reachable","kind":"accessibility","requestSHA256":"93c79cd3053aaac63f572258c8e558b147f1e76cb23ddeb9335243ddb568cf3c"},{"accessibilityRawSHA256":"f2be1bec2b74bbb3f30b835f8974e87b6df5009eeed6d889154515805992309a","accessibilitySealedSHA256":"53272aab39548fe30e958edf82e8d31d93f16f65c46e84141ae6d271b4c87fa8","axCollectorBuildProvenanceSHA256":"752f5659f1b4a95b1840a11176acb10fe94cf9e6595457042d9ddcceb9e288d8","axCollectorSHA256":"bfcb45708b47898068b931d7a6b1432f99c2d69d2d7f77c3ee80b697d89646c2","captureIDHash":"97b344340f7cbf166d92ab05a08402830633322c0db131570dfe27383f2acdfa","debugBuildProvenanceSHA256":"d4f2ae1112ccfcadeb73baf81b94465362a0655ab5b58540d3ed27c9b33c0f1b","debugFixtureSHA256":"e03fdc6ccce75c1afd177d4bd7ede1fb578fad6524951d895ec4df171afae5cc","fixtureReportSHA256":"405ab2486a53cc246b322eb3033331dedacc45d430d855539c3564f75b2fd5ff","id":"settings-agent-workflows-scroll-reachable","kind":"accessibility","requestSHA256":"07994c8a7f853f1444deffc6447b8b21a8fc44bedc03b446b474d81b01254db1"}],"safetyAggregate":{"attemptedExternalMutations":0,"attemptedHardwareCommands":0,"finalReportsPassed":50,"modelStartSkipped":50,"realControlPathConstructions":0},"schemaID":"https://vifty.app/schemas/ui-review-automated-checkpoint-v1.schema.json","schemaVersion":1,"source":{"commit":"3b869337c1249c18d26caf4a0558dda53152e775","manifestSHA256":"9d8843d84f04df5d458ce69669e133751d129be75e692ac635ee2278378e385f","tree":"756300206274844d99fd8202d44592522cb3fcd0"},"status":"automated-passed"} From c68b6851d84d53ff90937b2c7319c68ab29f5b0d Mon Sep 17 00:00:00 2001 From: Reidar Date: Mon, 7 Sep 2026 15:37:49 +0200 Subject: [PATCH 25/27] test: make validation fixture warning-clean on Xcode 16 --- Tests/ViftyCoreTests/ValidationEvidenceReviewScriptTests.swift | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tests/ViftyCoreTests/ValidationEvidenceReviewScriptTests.swift b/Tests/ViftyCoreTests/ValidationEvidenceReviewScriptTests.swift index 62827a0a..a9430cbb 100644 --- a/Tests/ViftyCoreTests/ValidationEvidenceReviewScriptTests.swift +++ b/Tests/ViftyCoreTests/ValidationEvidenceReviewScriptTests.swift @@ -2597,7 +2597,7 @@ private final class ValidationEvidenceReviewHarness { ? [ "attempted": true, "retryAfterSeconds": rateLimitRetryAfterSeconds, - "initialExitStatus": rateLimitInitialMetadataExitStatus ?? rateLimitInitialExitStatus, + "initialExitStatus": (rateLimitInitialMetadataExitStatus ?? rateLimitInitialExitStatus) as Any, "stdout": "viftyctl-run.json", "stderr": "viftyctl-run.stderr" ] From f9532c736bb67e9fd75bacfdd2b6e83100a662c4 Mon Sep 17 00:00:00 2001 From: Reidar Date: Mon, 7 Sep 2026 16:34:18 +0200 Subject: [PATCH 26/27] test: wait for complete process fixture output --- Tests/ViftyCoreTests/ViftyCtlProcessRunnerTests.swift | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/Tests/ViftyCoreTests/ViftyCtlProcessRunnerTests.swift b/Tests/ViftyCoreTests/ViftyCtlProcessRunnerTests.swift index 53fd7c3d..4c604fa7 100644 --- a/Tests/ViftyCoreTests/ViftyCtlProcessRunnerTests.swift +++ b/Tests/ViftyCoreTests/ViftyCtlProcessRunnerTests.swift @@ -122,7 +122,7 @@ final class ViftyCtlProcessRunnerTests: XCTestCase { childProcessGroup: Darwin.getpgid(childPID), wrapperProcessGroup: Darwin.getpgrp() ) - _ = Self.waitForFile(at: pidFile, timeout: 1) + _ = Self.waitForFile(at: pidFile, componentCount: 2, timeout: 1) XCTAssertEqual(Darwin.kill(Darwin.getpid(), SIGTERM), 0) } ) @@ -287,9 +287,14 @@ final class ViftyCtlProcessRunnerTests: XCTestCase { return (child, grandchild) } - private static func waitForFile(at url: URL, timeout: TimeInterval) -> Bool { + private static func waitForFile( + at url: URL, + componentCount: Int = 1, + timeout: TimeInterval + ) -> Bool { waitUntil(timeout: timeout) { - FileManager.default.fileExists(atPath: url.path) + guard let contents = try? String(contentsOf: url, encoding: .utf8) else { return false } + return contents.split(whereSeparator: \.isWhitespace).count >= componentCount } } From b9467506591fadb67dc4fc62fce7ce246f09a1ec Mon Sep 17 00:00:00 2001 From: Reidar Date: Mon, 7 Sep 2026 17:10:25 +0200 Subject: [PATCH 27/27] fix: scope diagnose probes for Swift 6.1 --- Sources/ViftyCore/ViftyCtlRunner.swift | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/Sources/ViftyCore/ViftyCtlRunner.swift b/Sources/ViftyCore/ViftyCtlRunner.swift index bd0f2421..888a66e8 100644 --- a/Sources/ViftyCore/ViftyCtlRunner.swift +++ b/Sources/ViftyCore/ViftyCtlRunner.swift @@ -1806,14 +1806,13 @@ public struct ViftyCtlRunner: Sendable { private func diagnoseReport() async -> ViftyCtlReadinessReport { let generatedAt = now() - async let snapshotProbe = capture { try await client.snapshot() } - async let statusProbe = capture { try await client.status() } - async let ownershipProbe = capture { try await client.fanControlOwnershipStatus() } - let (snapshotResult, statusResult, ownershipResult) = await ( - snapshotProbe, - statusProbe, - ownershipProbe - ) + // Keep async-let lifetimes nested to avoid Swift 6.1 task-stack misordering (swiftlang/swift#81771). + let (snapshotResult, statusResult, ownershipResult) = await { + async let snapshotProbe = capture { try await client.snapshot() } + async let statusProbe = capture { try await client.status() } + async let ownershipProbe = capture { try await client.fanControlOwnershipStatus() } + return await (snapshotProbe, statusProbe, ownershipProbe) + }() let snapshot: HardwareSnapshot let daemonSnapshotError: String?