diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index b4f451c..238c847 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -7,10 +7,21 @@ on:
 
 jobs:
   test:
-    name: Run all tests on iOS
+    name: Test on ${{ matrix.device }}
     runs-on: macos-26
     timeout-minutes: 30
 
+    strategy:
+      # Run every device leg to completion: an iPad failure shouldn't hide the
+      # iPhone result (or vice versa).
+      fail-fast: false
+      matrix:
+        include:
+          - device: iPhone 17 Pro
+            slug: iphone
+          - device: iPad Pro 11-inch (M5)
+            slug: ipad
+
     steps:
       - name: Checkout current repository
         uses: actions/checkout@v4
@@ -24,7 +35,7 @@ jobs:
           xcodebuild build-for-testing \
             -project OpenAppLock.xcodeproj \
             -scheme OpenAppLock \
-            -destination 'platform=iOS Simulator,name=iPhone 17 Pro' \
+            -destination 'platform=iOS Simulator,name=${{ matrix.device }}' \
             -xcconfig Config/CI.xcconfig
 
       - name: Run tests
@@ -34,7 +45,7 @@ jobs:
           xcodebuild test-without-building \
             -project OpenAppLock.xcodeproj \
             -scheme OpenAppLock \
-            -destination 'platform=iOS Simulator,name=iPhone 17 Pro' \
+            -destination 'platform=iOS Simulator,name=${{ matrix.device }}' \
             -resultBundlePath ./output/test-result.xcresult \
             -xcconfig Config/CI.xcconfig
 
@@ -45,11 +56,11 @@ jobs:
       - name: Upload test result
         uses: actions/upload-artifact@v4
         with:
-          name: test-result
+          name: test-result-${{ matrix.slug }}
           path: output/test-result.zip
 
       - name: Check for test failure
         if: steps.tests.outcome == 'failure'
         run: |
-          echo "Tests failed. Check the uploaded artifacts for details."
+          echo "Tests failed on ${{ matrix.device }}. Check the uploaded artifacts for details."
           exit 1
diff --git a/AGENTS.md b/AGENTS.md
index 851abca..e4862db 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -82,8 +82,9 @@ off-limits to agent edits.
 - Shields: one `ManagedSettingsStore` per rule (`rule-<uuid>`), tracked in
   UserDefaults for stray cleanup. `blockAdultContent` engages
   `webContent.blockedByFilter = .auto()` alongside the shield.
-- `RuleEnforcer.refresh` is the only place shields change; the home view runs
-  it on rule changes and a 30s loop while visible.
+- `RuleEnforcer.refresh` is the only place shields change; the post-onboarding
+  shell (`MainView`) runs it on rule changes and a 30s loop while the app is open,
+  regardless of the active layout (compact `TabView` vs regular-width sidebar).
 
 ## Build & test
 
@@ -156,7 +157,8 @@ them): `newRuleButton`, `ruleCard-<name>`, `ruleStatus-<name>`,
 `maxOpensStepper(+Value)`, `commitRuleButton`, `doneButton`,
 `toggleEnabledButton`, `deleteRuleButton`, `closeDetailButton`,
 `detailRuleName`, `detailStatusLabel`, `detailRow-<label>`,
-`hardModeLockedNotice`, settings About links: `githubLinkButton` /
+`hardModeLockedNotice`, `sidebarItem-<section>` (iPad sidebar rows: `home` /
+`rules` / `settings`), settings About links: `githubLinkButton` /
 `websiteLinkButton`, onboarding: `onboardingContinueButton`,
 `allowScreenTimeButton`, `permissionDeniedLabel`, `openSettingsButton`.
 
@@ -179,6 +181,13 @@ Gotchas learned the hard way:
   `Color.primary`/`Color.secondary`/`Color(.tertiaryLabel)`.
 - The unblock confirmation dialog is queried via `app.sheets.buttons[...]`
   (a bare `buttons["Unblock"]` is ambiguous with the row label).
+- **iPad presentation differs and the UI suite runs on both** (CI matrix:
+  iPhone + iPad). On iPad the shell is a sidebar, not a tab bar — navigate with
+  the idiom-aware `goToHomeTab()/…` and `waitForMainUI()` helpers, never bare
+  `tabBars`. Sheets present as *centered, shorter* form sheets, so: a window-edge
+  swipe-back misses them (use the nav `BackButton`); rows can start below the
+  fold (scroll into view); and span/width assertions measured against the full
+  window only hold on iPhone (gate with `UIDevice.current.userInterfaceIdiom`).
 
 ## Known gaps / next steps
 
diff --git a/Docs/AGENT_RULES_FEATURE_SPEC.md b/Docs/AGENT_RULES_FEATURE_SPEC.md
index 4accf83..05ebd01 100644
--- a/Docs/AGENT_RULES_FEATURE_SPEC.md
+++ b/Docs/AGENT_RULES_FEATURE_SPEC.md
@@ -523,20 +523,32 @@ iOS design language, keeping the backend (models, logic, services), the
 flows, and the accessibility identifiers intact. Sections 1–5 remain as the
 spec for *what* the feature does; presentation now maps as follows.
 
-After onboarding the app is a three-tab `TabView` (`MainTabView`), each tab its
-own `NavigationStack`:
+After onboarding the app is an **adaptive shell** (`MainView`) holding the same
+three sections (Home / Rules / Settings), each its own `NavigationStack`. The
+navigation chrome is chosen from the horizontal size class
+(`MainLayout.resolve`), reusing identical section views in both layouts:
+
+- **Compact width** (iPhone, and iPad multitasking / Slide Over): a bottom
+  `TabView` (`MainTabView`).
+- **Regular width** (full-screen iPad): a left sidebar `NavigationSplitView`
+  (`MainSidebarView`) — sections listed in the sidebar (`sidebarItem-<section>`),
+  the selected one filling the detail column. This is the iPad-idiomatic
+  presentation; a bottom tab bar is an iPhone idiom (Apple HIG).
 
 ```
-TabView: [Home] [Rules] [Settings]
+MainView (adaptive):  compact ─▶ TabView      [Home] [Rules] [Settings]   (bottom tabs)
+                      regular ─▶ NavigationSplitView  sidebar │ detail     (left sidebar)
    │        │        └── "Uninstall Protection" toggle + "Manage App Lists" ─▶ App List library (management mode) + "About" GitHub / Website links
    │        └── rules grouped into Schedule / Time Limit / Open Limit sections; "+" ─▶ New Rule sheet
    │                 └── tap a rule row ─▶ Rule Detail sheet ─▶ "Edit Rule" ─▶ Rule Editor
    └── "Currently Blocking" section + "Usage" section
 ```
 
-The app-level **enforcement lifecycle** (the `enforcer.refresh` 30 s loop, the
-rule-change reconcile, and a scene-active reconcile) lives on `MainTabView`, so
-it runs regardless of the selected tab.
+Section labels and icons come from one source of truth, the `AppSection` enum,
+so the tab bar and the sidebar can't drift. The app-level **enforcement
+lifecycle** (the `enforcer.refresh` 30 s loop, the rule-change reconcile, and a
+scene-active reconcile) lives on `MainView`, so it runs regardless of the active
+layout or selected section.
 
 | Spec element | Native presentation |
 |---|---|
diff --git a/OpenAppLock/Views/MainSidebarView.swift b/OpenAppLock/Views/MainSidebarView.swift
new file mode 100644
index 0000000..7fc7de5
--- /dev/null
+++ b/OpenAppLock/Views/MainSidebarView.swift
@@ -0,0 +1,51 @@
+//
+//  MainSidebarView.swift
+//  OpenAppLock
+//
+
+import SwiftUI
+
+/// The regular-width (full-screen iPad) layout: a persistent left sidebar listing
+/// the top-level sections, with the selected section filling the detail column.
+///
+/// Reuses the exact same section views as the compact `TabView` (`HomeView`,
+/// `RulesListView`, `SettingsView` — each brings its own `NavigationStack`); only
+/// the navigation chrome differs. Sidebar rows are built from `AppSection`, the
+/// shared source of truth, so labels and icons match the tab bar.
+struct MainSidebarView: View {
+    @State private var selection: AppSection? = .home
+
+    var body: some View {
+        // Pin the sidebar visible: on the roomy iPad canvas the top-level
+        // sections should always be in reach (HIG), and a constant column
+        // visibility keeps the layout stable for UI tests and rotation.
+        NavigationSplitView(columnVisibility: .constant(.all)) {
+            List(selection: $selection) {
+                ForEach(AppSection.allCases) { section in
+                    Label(section.title, systemImage: section.systemImage)
+                        // Collapse the icon + title into one queryable, hittable
+                        // element so UI tests target the row, not the bare symbol.
+                        .accessibilityElement(children: .combine)
+                        .accessibilityIdentifier("sidebarItem-\(section.rawValue)")
+                        .tag(section)
+                }
+            }
+            .navigationTitle("OpenAppLock")
+        } detail: {
+            detail(for: selection ?? .home)
+        }
+        .navigationSplitViewStyle(.balanced)
+    }
+
+    @ViewBuilder
+    private func detail(for section: AppSection) -> some View {
+        switch section {
+        case .home:
+            HomeView()
+        case .rules:
+            RulesListView()
+        case .settings:
+            SettingsView()
+        }
+    }
+}
diff --git a/OpenAppLock/Views/MainTabView.swift b/OpenAppLock/Views/MainTabView.swift
index 8c8ce38..5397d4b 100644
--- a/OpenAppLock/Views/MainTabView.swift
+++ b/OpenAppLock/Views/MainTabView.swift
@@ -3,66 +3,24 @@
 //  OpenAppLock
 //
 
-import SwiftData
 import SwiftUI
 
-/// The post-onboarding shell: a three-tab layout (Home / Rules / Settings).
+/// The compact-width layout: the three top-level sections as a bottom `TabView`.
+/// Used on iPhone and in iPad multitasking / Slide Over (anywhere the horizontal
+/// size class is compact). The app-level enforcement lifecycle lives on the
+/// adaptive shell `MainView`, not here, so it runs regardless of layout.
 ///
-/// The app-level enforcement lifecycle lives here, not on any one tab, so it
-/// runs regardless of the selected tab: a 30 s `refresh` loop, a reconcile on
-/// any blocking-relevant rule change, and a reconcile whenever the app becomes
-/// active (so Uninstall Protection re-evaluates on every foreground).
+/// Tab labels and icons come from `AppSection`, the same source the regular-width
+/// sidebar (`MainSidebarView`) uses, so the two layouts can never drift.
 struct MainTabView: View {
-    @Environment(\.modelContext) private var modelContext
-    @Environment(RuleEnforcer.self) private var enforcer
-    @Environment(\.scenePhase) private var scenePhase
-    @Query(sort: \BlockingRule.createdAt) private var rules: [BlockingRule]
-
     var body: some View {
         TabView {
             HomeView()
-                .tabItem { Label("Home", systemImage: "house") }
+                .tabItem { Label(AppSection.home.title, systemImage: AppSection.home.systemImage) }
             RulesListView()
-                .tabItem { Label("Rules", systemImage: "shield.lefthalf.filled") }
+                .tabItem { Label(AppSection.rules.title, systemImage: AppSection.rules.systemImage) }
             SettingsView()
-                .tabItem { Label("Settings", systemImage: "gearshape") }
-        }
-        .task {
-            await enforcementLoop()
-        }
-        .onChange(of: ruleChangeToken) {
-            refreshEnforcement()
-        }
-        .onChange(of: scenePhase) { _, phase in
-            if phase == .active { refreshEnforcement() }
-        }
-    }
-
-    // MARK: - Enforcement
-
-    /// Changes whenever any rule's blocking-relevant state changes.
-    private var ruleChangeToken: String {
-        rules.map {
-            "\($0.id)|\($0.isEnabled)|\($0.hardMode)|\($0.blockAdultContent)|"
-                + "\($0.startMinutes)|\($0.endMinutes)|\($0.dayNumbers)|"
-                + "\($0.selectionModeRaw)|\($0.appList?.id.uuidString ?? "-")|"
-                + "\($0.appList?.selectionCount ?? 0)|"
-                + "\($0.pausedUntil?.timeIntervalSince1970 ?? 0)"
-        }
-        .joined(separator: ",")
-    }
-
-    private func refreshEnforcement() {
-        enforcer.refresh(rules: rules)
-    }
-
-    /// Keeps shields in sync while the app is open, so windows that begin or
-    /// end while the user is looking at the screen take effect promptly.
-    private func enforcementLoop() async {
-        while !Task.isCancelled {
-            let allRules = (try? modelContext.fetch(FetchDescriptor<BlockingRule>())) ?? []
-            enforcer.refresh(rules: allRules)
-            try? await Task.sleep(for: .seconds(30))
+                .tabItem { Label(AppSection.settings.title, systemImage: AppSection.settings.systemImage) }
         }
     }
 }
diff --git a/OpenAppLock/Views/MainView.swift b/OpenAppLock/Views/MainView.swift
new file mode 100644
index 0000000..36afe01
--- /dev/null
+++ b/OpenAppLock/Views/MainView.swift
@@ -0,0 +1,75 @@
+//
+//  MainView.swift
+//  OpenAppLock
+//
+
+import SwiftData
+import SwiftUI
+
+/// The post-onboarding shell. Chooses its navigation chrome from the horizontal
+/// size class — a bottom `TabView` (`MainTabView`) in compact width (iPhone, iPad
+/// multitasking) and a left sidebar (`MainSidebarView`) in regular width
+/// (full-screen iPad) — and owns the app-level enforcement lifecycle so it runs
+/// regardless of which layout is showing and which section is selected.
+///
+/// The lifecycle is a 30 s `refresh` loop, a reconcile on any blocking-relevant
+/// rule change, and a reconcile whenever the app becomes active (so Uninstall
+/// Protection re-evaluates on every foreground).
+struct MainView: View {
+    @Environment(\.modelContext) private var modelContext
+    @Environment(RuleEnforcer.self) private var enforcer
+    @Environment(\.scenePhase) private var scenePhase
+    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
+    @Query(sort: \BlockingRule.createdAt) private var rules: [BlockingRule]
+
+    var body: some View {
+        layout
+            .task {
+                await enforcementLoop()
+            }
+            .onChange(of: ruleChangeToken) {
+                refreshEnforcement()
+            }
+            .onChange(of: scenePhase) { _, phase in
+                if phase == .active { refreshEnforcement() }
+            }
+    }
+
+    @ViewBuilder
+    private var layout: some View {
+        switch MainLayout.resolve(horizontalSizeClass: horizontalSizeClass) {
+        case .tabs:
+            MainTabView()
+        case .sidebar:
+            MainSidebarView()
+        }
+    }
+
+    // MARK: - Enforcement
+
+    /// Changes whenever any rule's blocking-relevant state changes.
+    private var ruleChangeToken: String {
+        rules.map {
+            "\($0.id)|\($0.isEnabled)|\($0.hardMode)|\($0.blockAdultContent)|"
+                + "\($0.startMinutes)|\($0.endMinutes)|\($0.dayNumbers)|"
+                + "\($0.selectionModeRaw)|\($0.appList?.id.uuidString ?? "-")|"
+                + "\($0.appList?.selectionCount ?? 0)|"
+                + "\($0.pausedUntil?.timeIntervalSince1970 ?? 0)"
+        }
+        .joined(separator: ",")
+    }
+
+    private func refreshEnforcement() {
+        enforcer.refresh(rules: rules)
+    }
+
+    /// Keeps shields in sync while the app is open, so windows that begin or end
+    /// while the user is looking at the screen take effect promptly.
+    private func enforcementLoop() async {
+        while !Task.isCancelled {
+            let allRules = (try? modelContext.fetch(FetchDescriptor<BlockingRule>())) ?? []
+            enforcer.refresh(rules: allRules)
+            try? await Task.sleep(for: .seconds(30))
+        }
+    }
+}
diff --git a/OpenAppLock/Views/Navigation/AppSection.swift b/OpenAppLock/Views/Navigation/AppSection.swift
new file mode 100644
index 0000000..b16269d
--- /dev/null
+++ b/OpenAppLock/Views/Navigation/AppSection.swift
@@ -0,0 +1,35 @@
+//
+//  AppSection.swift
+//  OpenAppLock
+//
+
+import Foundation
+
+/// The app's top-level sections. Single source of truth for the post-onboarding
+/// navigation, shared by the compact `TabView` (`MainTabView`) and the
+/// regular-width sidebar (`MainSidebarView`) so the two layouts can't drift.
+enum AppSection: String, CaseIterable, Identifiable {
+    case home
+    case rules
+    case settings
+
+    var id: String { rawValue }
+
+    /// User-facing label shown in the tab item and the sidebar row.
+    var title: String {
+        switch self {
+        case .home: "Home"
+        case .rules: "Rules"
+        case .settings: "Settings"
+        }
+    }
+
+    /// SF Symbol shown alongside the title in both layouts.
+    var systemImage: String {
+        switch self {
+        case .home: "house"
+        case .rules: "shield.lefthalf.filled"
+        case .settings: "gearshape"
+        }
+    }
+}
diff --git a/OpenAppLock/Views/Navigation/MainLayout.swift b/OpenAppLock/Views/Navigation/MainLayout.swift
new file mode 100644
index 0000000..20ccd37
--- /dev/null
+++ b/OpenAppLock/Views/Navigation/MainLayout.swift
@@ -0,0 +1,22 @@
+//
+//  MainLayout.swift
+//  OpenAppLock
+//
+
+import SwiftUI
+
+/// Which navigation chrome the post-onboarding shell shows, chosen from the
+/// horizontal size class: a left sidebar on the roomy regular-width iPad canvas,
+/// the bottom tab bar everywhere else (iPhone, plus iPad multitasking / Slide
+/// Over, where the width is compact).
+enum MainLayout {
+    case tabs
+    case sidebar
+
+    /// Resolves the layout from the current horizontal size class. The sidebar is
+    /// reserved for *known* regular width; an undetermined (`nil`) size class
+    /// falls back to the iPhone-safe tab bar.
+    static func resolve(horizontalSizeClass: UserInterfaceSizeClass?) -> MainLayout {
+        horizontalSizeClass == .regular ? .sidebar : .tabs
+    }
+}
diff --git a/OpenAppLock/Views/RootView.swift b/OpenAppLock/Views/RootView.swift
index 085a162..c5640d6 100644
--- a/OpenAppLock/Views/RootView.swift
+++ b/OpenAppLock/Views/RootView.swift
@@ -15,7 +15,7 @@ struct RootView: View {
     var body: some View {
         Group {
             if hasCompletedOnboarding {
-                MainTabView()
+                MainView()
             } else {
                 OnboardingView {
                     hasCompletedOnboarding = true
diff --git a/OpenAppLockTests/AppSectionTests.swift b/OpenAppLockTests/AppSectionTests.swift
new file mode 100644
index 0000000..2005e1f
--- /dev/null
+++ b/OpenAppLockTests/AppSectionTests.swift
@@ -0,0 +1,45 @@
+//
+//  AppSectionTests.swift
+//  OpenAppLockTests
+//
+
+import Testing
+@testable import OpenAppLock
+
+/// `AppSection` is the single source of truth for the top-level sections, shared
+/// by the compact `TabView` (`MainTabView`) and the regular-width sidebar
+/// (`MainSidebarView`). These tests pin its order, labels, and icons so the two
+/// layouts can never drift.
+@MainActor
+struct AppSectionTests {
+    @Test("Sections are ordered Home, Rules, Settings")
+    func ordering() {
+        #expect(AppSection.allCases == [.home, .rules, .settings])
+    }
+
+    @Test("There are exactly three top-level sections")
+    func count() {
+        #expect(AppSection.allCases.count == 3)
+    }
+
+    @Test("Each section exposes its display title")
+    func titles() {
+        #expect(AppSection.home.title == "Home")
+        #expect(AppSection.rules.title == "Rules")
+        #expect(AppSection.settings.title == "Settings")
+    }
+
+    @Test("Each section exposes its SF Symbol")
+    func symbols() {
+        #expect(AppSection.home.systemImage == "house")
+        #expect(AppSection.rules.systemImage == "shield.lefthalf.filled")
+        #expect(AppSection.settings.systemImage == "gearshape")
+    }
+
+    @Test("Identifiers are the stable raw values")
+    func identifiers() {
+        #expect(AppSection.home.id == "home")
+        #expect(AppSection.rules.id == "rules")
+        #expect(AppSection.settings.id == "settings")
+    }
+}
diff --git a/OpenAppLockTests/MainLayoutTests.swift b/OpenAppLockTests/MainLayoutTests.swift
new file mode 100644
index 0000000..5c700dd
--- /dev/null
+++ b/OpenAppLockTests/MainLayoutTests.swift
@@ -0,0 +1,30 @@
+//
+//  MainLayoutTests.swift
+//  OpenAppLockTests
+//
+
+import SwiftUI
+import Testing
+@testable import OpenAppLock
+
+/// `MainLayout.resolve` decides whether the post-onboarding shell shows the
+/// bottom `TabView` or the left sidebar, purely from the horizontal size class.
+/// Sidebar is reserved for *known* regular width so an undetermined size class
+/// falls back to the iPhone-safe tab bar.
+@MainActor
+struct MainLayoutTests {
+    @Test("Regular width uses the sidebar")
+    func regularUsesSidebar() {
+        #expect(MainLayout.resolve(horizontalSizeClass: .regular) == .sidebar)
+    }
+
+    @Test("Compact width uses tabs")
+    func compactUsesTabs() {
+        #expect(MainLayout.resolve(horizontalSizeClass: .compact) == .tabs)
+    }
+
+    @Test("Unknown width falls back to tabs")
+    func unknownFallsBackToTabs() {
+        #expect(MainLayout.resolve(horizontalSizeClass: nil) == .tabs)
+    }
+}
diff --git a/OpenAppLockUITests/AppListUITests.swift b/OpenAppLockUITests/AppListUITests.swift
index c8bc8aa..ef56ced 100644
--- a/OpenAppLockUITests/AppListUITests.swift
+++ b/OpenAppLockUITests/AppListUITests.swift
@@ -37,10 +37,12 @@ final class AppListUITests: XCTestCase {
             "Time-limit rules are always Block; the mode picker must not appear"
         )
 
-        // Back to the rule-type list, then check the open-limit editor too.
-        let edge = app.coordinate(withNormalizedOffset: CGVector(dx: 0.02, dy: 0.5))
-        let middle = app.coordinate(withNormalizedOffset: CGVector(dx: 0.9, dy: 0.5))
-        edge.press(forDuration: 0.05, thenDragTo: middle)
+        // Back to the rule-type list, then check the open-limit editor too. Use
+        // the nav back button rather than an edge-swipe, which assumes a full-width
+        // sheet and misses iPad's centered form sheet. Target the back button by
+        // its identifier ("BackButton") — its "New Rule" label collides with the
+        // Rules tab's "New Rule" (+) button sitting behind the sheet.
+        app.navigationBars.buttons["BackButton"].waitToAppear().tap()
 
         app.buttons["ruleKind-openLimit"].waitToAppear().tap()
         app.element("selectedAppsRow").waitToAppear()
diff --git a/OpenAppLockUITests/NavigationChromeUITests.swift b/OpenAppLockUITests/NavigationChromeUITests.swift
new file mode 100644
index 0000000..e0d11e0
--- /dev/null
+++ b/OpenAppLockUITests/NavigationChromeUITests.swift
@@ -0,0 +1,53 @@
+//
+//  NavigationChromeUITests.swift
+//  OpenAppLockUITests
+//
+
+import XCTest
+
+/// The post-onboarding shell adapts its navigation chrome to the available width:
+/// a bottom tab bar on iPhone (compact), a left sidebar on full-screen iPad
+/// (regular). These flows run on whatever destination the suite is launched
+/// against and branch on the device idiom, so the same test validates both legs
+/// of the CI matrix.
+final class NavigationChromeUITests: XCTestCase {
+    override func setUpWithError() throws {
+        continueAfterFailure = false
+    }
+
+    /// iPad shows a sidebar and no tab bar; iPhone shows a tab bar and no sidebar.
+    func testNavigationChromeMatchesIdiom() throws {
+        let app = XCUIApplication.launchOpenAppLock()
+
+        if UIDevice.current.userInterfaceIdiom == .pad {
+            app.element("sidebarItem-home").waitToAppear()
+            app.element("sidebarItem-rules").waitToAppear()
+            app.element("sidebarItem-settings").waitToAppear()
+            XCTAssertFalse(
+                app.tabBars.firstMatch.exists,
+                "Full-screen iPad should use a sidebar, not a bottom tab bar"
+            )
+        } else {
+            app.tabBars.buttons["Home"].waitToAppear()
+            XCTAssertFalse(
+                app.element("sidebarItem-home").exists,
+                "iPhone should use a bottom tab bar, not a sidebar"
+            )
+        }
+    }
+
+    /// Every section is reachable through whichever chrome is presented, proving
+    /// the shared `goTo…` helpers drive both the tab bar and the sidebar.
+    func testEverySectionIsReachable() throws {
+        let app = XCUIApplication.launchOpenAppLock()
+
+        app.goToRulesTab()
+        app.element("newRuleButton").waitToAppear()
+
+        app.goToSettingsTab()
+        app.switches["uninstallProtectionToggle"].waitToAppear()
+
+        app.goToHomeTab()
+        app.element("nothingBlockedLabel").waitToAppear()
+    }
+}
diff --git a/OpenAppLockUITests/OnboardingUITests.swift b/OpenAppLockUITests/OnboardingUITests.swift
index fc7f3aa..3bb2947 100644
--- a/OpenAppLockUITests/OnboardingUITests.swift
+++ b/OpenAppLockUITests/OnboardingUITests.swift
@@ -17,17 +17,16 @@ final class OnboardingUITests: XCTestCase {
         app.staticTexts["OpenAppLock"].waitToAppear()
         app.buttons["onboardingContinueButton"].waitToAppear().tap()
 
-        // Permission step: granting (mocked) lands on the tabbed home screen.
+        // Permission step: granting (mocked) lands on the main app, in whichever
+        // navigation chrome the device uses (tab bar on iPhone, sidebar on iPad).
         app.buttons["allowScreenTimeButton"].waitToAppear().tap()
-        app.tabBars.buttons["Home"].waitToAppear()
-        XCTAssertTrue(app.tabBars.buttons["Rules"].exists)
-        XCTAssertTrue(app.tabBars.buttons["Settings"].exists)
-        XCTAssertTrue(app.staticTexts["Currently Blocking"].exists)
+        app.waitForMainUI()
+        XCTAssertTrue(app.staticTexts["Currently Blocking"].waitToAppear().exists)
     }
 
     func testCompletedOnboardingIsSkipped() throws {
         let app = XCUIApplication.launchOpenAppLock(onboardingCompleted: true)
-        app.tabBars.buttons["Home"].waitToAppear()
+        app.waitForMainUI()
         XCTAssertFalse(app.buttons["onboardingContinueButton"].exists)
     }
 }
diff --git a/OpenAppLockUITests/RuleCreationUITests.swift b/OpenAppLockUITests/RuleCreationUITests.swift
index b39742e..9c6e20c 100644
--- a/OpenAppLockUITests/RuleCreationUITests.swift
+++ b/OpenAppLockUITests/RuleCreationUITests.swift
@@ -72,15 +72,21 @@ final class RuleCreationUITests: XCTestCase {
 
         let first = app.buttons["dayToggle-1"].waitToAppear()
         let last = app.buttons["dayToggle-7"].waitToAppear()
-        let span = last.frame.maxX - first.frame.minX
-        XCTAssertGreaterThan(
-            span, app.frame.width * 0.75,
-            "Day toggles should span the full row width, got \(span) of \(app.frame.width)"
-        )
         XCTAssertGreaterThanOrEqual(
             first.frame.height, 44,
             "Day toggle tap target should be at least 44pt tall"
         )
+        // The "fill the row" guarantee is measured against the window width, which
+        // only holds where the editor sheet spans the full width (iPhone). On iPad
+        // the editor is a centered form sheet narrower than the window, so that
+        // comparison doesn't apply; the toggles still fill their (narrower) row.
+        if UIDevice.current.userInterfaceIdiom == .phone {
+            let span = last.frame.maxX - first.frame.minX
+            XCTAssertGreaterThan(
+                span, app.frame.width * 0.75,
+                "Day toggles should span the full row width, got \(span) of \(app.frame.width)"
+            )
+        }
     }
 
     func testDayTogglesUpdateSummary() throws {
@@ -177,6 +183,15 @@ final class RuleCreationUITests: XCTestCase {
     }
 
     func testEditorSupportsNativeSwipeBack() throws {
+        // The edge-swipe starts at the window's left edge, which only lands on the
+        // editor when the sheet spans the full width (iPhone). On iPad the editor
+        // is a centered form sheet, so the equivalent back navigation is covered by
+        // AppListUITests.testLimitEditorsAreBlockOnly (nav back button) instead.
+        try XCTSkipUnless(
+            UIDevice.current.userInterfaceIdiom == .phone,
+            "Edge-swipe-back is an iPhone full-width-sheet gesture; iPad back nav is covered elsewhere"
+        )
+
         let app = XCUIApplication.launchOpenAppLock()
         app.goToRulesTab()
         app.buttons["newRuleButton"].waitToAppear().tap()
diff --git a/OpenAppLockUITests/RuleManagementUITests.swift b/OpenAppLockUITests/RuleManagementUITests.swift
index 11f9f4f..e9acf0d 100644
--- a/OpenAppLockUITests/RuleManagementUITests.swift
+++ b/OpenAppLockUITests/RuleManagementUITests.swift
@@ -37,7 +37,13 @@ final class RuleManagementUITests: XCTestCase {
         app.buttons["ruleCard-Sleep"].waitToAppear().tap()
         app.buttons["editRuleButton"].waitToAppear().tap()
 
-        let hardMode = app.switches["hardModeToggle"].waitToAppear()
+        // On iPad the editor is a shorter, centered form sheet; the Hard Mode row
+        // can start below the fold and isn't rendered until scrolled into view.
+        let hardMode = app.switches["hardModeToggle"]
+        if !hardMode.waitForExistence(timeout: 2) {
+            app.swipeUp()
+        }
+        hardMode.waitToAppear()
         XCTAssertEqual(hardMode.label, "Hard Mode", "The Hard Mode switch must carry its label for VoiceOver")
         // A labeled Toggle fills the row, so a centered `.tap()` lands on the
         // label; tap the switch itself at the trailing edge to flip it.
diff --git a/OpenAppLockUITests/UITestSupport.swift b/OpenAppLockUITests/UITestSupport.swift
index 66ba9f4..aeda882 100644
--- a/OpenAppLockUITests/UITestSupport.swift
+++ b/OpenAppLockUITests/UITestSupport.swift
@@ -45,13 +45,40 @@ extension XCUIApplication {
 }
 
 extension XCUIApplication {
-    /// Switches to the Home tab (Currently Blocking + Usage). Home is the
-    /// default selection, so most Home-tab tests don't need to call this.
-    func goToHomeTab() { tabBars.buttons["Home"].waitToAppear().tap() }
-    /// Switches to the Rules tab (the rule list + New Rule button).
-    func goToRulesTab() { tabBars.buttons["Rules"].waitToAppear().tap() }
-    /// Switches to the Settings tab (Uninstall Protection + Manage App Lists).
-    func goToSettingsTab() { tabBars.buttons["Settings"].waitToAppear().tap() }
+    /// Switches to the Home section (Currently Blocking + Usage). Home is the
+    /// default selection, so most Home tests don't need to call this.
+    func goToHomeTab() { goToSection(tabLabel: "Home", sidebarIdentifier: "sidebarItem-home") }
+    /// Switches to the Rules section (the rule list + New Rule button).
+    func goToRulesTab() { goToSection(tabLabel: "Rules", sidebarIdentifier: "sidebarItem-rules") }
+    /// Switches to the Settings section (Uninstall Protection + Manage App Lists).
+    func goToSettingsTab() { goToSection(tabLabel: "Settings", sidebarIdentifier: "sidebarItem-settings") }
+
+    /// Navigates to a top-level section regardless of the current navigation
+    /// chrome: the bottom tab bar in compact width (iPhone, iPad multitasking) or
+    /// the left sidebar in regular width (full-screen iPad). Keeps the rest of the
+    /// UI suite agnostic to which device it runs on.
+    private func goToSection(tabLabel: String, sidebarIdentifier: String) {
+        let tab = tabBars.buttons[tabLabel]
+        if tab.waitForExistence(timeout: 2) {
+            tab.tap()
+        } else {
+            element(sidebarIdentifier).waitToAppear().tap()
+        }
+    }
+
+    /// Waits for the post-onboarding shell to appear in whichever chrome the
+    /// device presents — the bottom tab bar on iPhone, the left sidebar on
+    /// full-screen iPad — so tests can confirm "we reached the main app" without
+    /// hard-coding one device's navigation.
+    @discardableResult
+    func waitForMainUI() -> XCUIApplication {
+        if UIDevice.current.userInterfaceIdiom == .pad {
+            element("sidebarItem-home").waitToAppear()
+        } else {
+            tabBars.buttons["Home"].waitToAppear()
+        }
+        return self
+    }
 }
 
 extension XCUIElement {