diff --git a/AGENTS.md b/AGENTS.md
index cc72984..851abca 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -59,9 +59,9 @@ directory:
   `Docs/AGENT_SWIFT_GUIDELINES.md`). Agents may **read, create, and edit** these
   and are expected to keep them accurate. Treat the feature spec as the source
   of truth for behavior, and update it when a behavior change makes it stale.
-- **Human-authored** — every other doc, e.g. `README.md` and `CONTRIBUTING.md`.
-  Agents may **read** these for context but must **never create or modify**
-  them; flag needed changes for the maintainer instead.
+- **Human-authored** — every other doc, e.g. `README.md`. Agents may **read**
+  these for context but must **never create or modify** them; flag needed
+  changes for the maintainer instead.
 
 The `AGENT_` prefix is the contract: it marks a file as safe for agents to
 maintain. Any human-authored doc added without the prefix is automatically
@@ -141,6 +141,7 @@ when reminded:
 | `-onboarding-completed` / `-onboarding-required` | Force the onboarding flag |
 | `-seed-scenario=standard` | Active soft rule "Work Time" + upcoming "Sleep" |
 | `-seed-scenario=hard-mode-active` | Active Hard Mode rule "Locked In" + upcoming "Sleep" |
+| `-github-url=<url>` / `-website-url=<url>` | Override the Settings About links with deterministic URLs |
 
 Use `XCUIApplication.launchOpenAppLock(...)` (UITestSupport.swift), which also
 provides `app.element(_:)` for identifier lookup across element types and
@@ -155,7 +156,8 @@ them): `newRuleButton`, `ruleCard-<name>`, `ruleStatus-<name>`,
 `maxOpensStepper(+Value)`, `commitRuleButton`, `doneButton`,
 `toggleEnabledButton`, `deleteRuleButton`, `closeDetailButton`,
 `detailRuleName`, `detailStatusLabel`, `detailRow-<label>`,
-`hardModeLockedNotice`, onboarding: `onboardingContinueButton`,
+`hardModeLockedNotice`, settings About links: `githubLinkButton` /
+`websiteLinkButton`, onboarding: `onboardingContinueButton`,
 `allowScreenTimeButton`, `permissionDeniedLabel`, `openSettingsButton`.
 
 Gotchas learned the hard way:
diff --git a/Config/DeveloperSettings.sample.xcconfig b/Config/DeveloperSettings.sample.xcconfig
index 2224df6..d3ef5bf 100644
--- a/Config/DeveloperSettings.sample.xcconfig
+++ b/Config/DeveloperSettings.sample.xcconfig
@@ -22,7 +22,7 @@
 // Note: the app and its Screen Time extensions are registered under the
 // `dev.bchen.OpenAppLock` bundle-ID prefix and the `group.dev.bchen.OpenAppLock`
 // App Group, which belong to the maintainer's team. To run on your own device
-// you must also change those identifiers to your own — see CONTRIBUTING.md.
+// you must also change those identifiers to your own.
 // Building and running the tests in the simulator needs no signing at all.
 
 DEVELOPMENT_TEAM = YOUR_TEAM_ID
diff --git a/Config/Shared.xcconfig b/Config/Shared.xcconfig
index 61d46f1..64bb16b 100644
--- a/Config/Shared.xcconfig
+++ b/Config/Shared.xcconfig
@@ -11,11 +11,27 @@
 // The optional include below is a no-op when that file is absent (a fresh
 // clone, or CI), so the project always opens and builds for the simulator. To
 // produce a signed build or run on a device, create that file from
-// Config/DeveloperSettings.sample.xcconfig — see CONTRIBUTING.md.
+// Config/DeveloperSettings.sample.xcconfig (it has step-by-step instructions).
 
 // Fallback defaults. These are overridden by DeveloperSettings.xcconfig when
 // it is present, because the include below comes after them.
 DEVELOPMENT_TEAM =
 CODE_SIGN_STYLE = Automatic
 
+// --- App metadata links ------------------------------------------------------
+// Outbound URLs surfaced on the Settings screen (GitHub repo + marketing site).
+// They are user-defined build settings so the destinations are configurable
+// without touching code; OpenAppLock/Info.plist maps them to the OALGitHubURL /
+// OALWebsiteURL keys (custom INFOPLIST_KEY_* settings are NOT injected into a
+// generated Info.plist, so the values have to ride through a real plist), and
+// the app reads them at runtime through `AppLinks`. Edit these to point at the
+// real links — the website value is a placeholder until the site exists.
+//
+// xcconfig treats "//" as the start of a comment, so a literal "https://…"
+// would be truncated to "https:". `$(SLASH)` (a single "/") lets us spell the
+// "://" without tripping the comment parser; it expands at build time.
+SLASH = /
+OAL_GITHUB_URL = https:$(SLASH)$(SLASH)github.com/brendan-ch/OpenAppLock
+OAL_WEBSITE_URL = https:$(SLASH)$(SLASH)openapplock.app
+
 #include? "../../SharedXcodeSettings/DeveloperSettings.xcconfig"
diff --git a/Docs/AGENT_RULES_FEATURE_SPEC.md b/Docs/AGENT_RULES_FEATURE_SPEC.md
index 703c0fc..4accf83 100644
--- a/Docs/AGENT_RULES_FEATURE_SPEC.md
+++ b/Docs/AGENT_RULES_FEATURE_SPEC.md
@@ -528,7 +528,7 @@ own `NavigationStack`:
 
 ```
 TabView: [Home] [Rules] [Settings]
-   │        │        └── "Uninstall Protection" toggle + "Manage App Lists" ─▶ App List library (management mode)
+   │        │        └── "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
@@ -542,7 +542,7 @@ it runs regardless of the selected tab.
 |---|---|
 | Home tab | `NavigationStack` + `List`. Every row carries a **leading kind icon**, the name, and a `<Type> · <context>` subtitle, where *context* is the rule's live status: a schedule reads its countdown (`Schedule · 6h left`), a limit reads its usage once used today (`Time Limit · 18m of 45m used`) or its plain budget while untouched (`Time Limit · 45m / day`). **"Currently Blocking"** section (renamed from "Blocked Apps") — the *rules* blocking right now: a Hard Mode rule shows a trailing `lock.fill` (the block can't be lifted), a soft rule shows a trailing "Unblock" button; tapping a hard row shows the "Hard Mode is on" alert, a soft row the unblock dialog. A limit rule whose budget is **spent** appears here (moved out of Usage). **"Usage"** section: every enabled limit rule scheduled today that is *not* currently blocking; rows have **no trailing label** (the context lives in the subtitle). |
 | Rules tab | `NavigationStack` + `List` split into **Schedule / Time Limit / Open Limit** sections (empty sections hidden); **rules are list rows** (leading kind icon, name, and a `<context>` subtitle — the same live status/countdown/usage as Home, but **without the type prefix** since the section header already conveys the kind, and **without a separate trailing status label**; the `ruleStatus-<name>` identifier lives on this subtitle); "+" toolbar button opens the New Rule sheet; tapping a row opens the Rule Detail sheet. |
-| Settings tab | `NavigationStack` + `Form`. **Uninstall Protection** toggle — while on, the device's app-removal is denied (`ManagedSettingsStore.application.denyAppRemoval`) whenever any Hard Mode rule is actively blocking. The toggle itself is **locked while any Hard Mode rule is actively blocking**: the switch is replaced by a trailing red `lock.fill` (same treatment as a Home "Currently Blocking" hard row) so the protection can't be turned off mid-block — its whole purpose. **Manage App Lists** pushes the shared App List library in management mode (create / edit / delete, honoring the Hard Mode lock — same flow as the rule editor's picker, minus selection). |
+| Settings tab | `NavigationStack` + `Form`. **Uninstall Protection** toggle — while on, the device's app-removal is denied (`ManagedSettingsStore.application.denyAppRemoval`) whenever any Hard Mode rule is actively blocking. The toggle itself is **locked while any Hard Mode rule is actively blocking**: the switch is replaced by a trailing red `lock.fill` (same treatment as a Home "Currently Blocking" hard row) so the protection can't be turned off mid-block — its whole purpose. **Manage App Lists** pushes the shared App List library in management mode (create / edit / delete, honoring the Hard Mode lock — same flow as the rule editor's picker, minus selection). An **About** section holds outbound `Link` rows — **GitHub** and **Website** — each shown only when its destination is configured (see §6.2). |
 | Rule detail | Sheet with inline nav title (name + "Schedule, 6h left" caption), `LabeledContent` rows, "Edit Rule" row pushes the editor; hard-locked rules show a lock row instead |
 | New Rule | `List` with a "Rule Type" section and preset sections as plain rows; editor pushed via `navigationDestination(item:)` |
 | Rule editor | Native `Form`: an inline **Name text field** at the top (no separate rename button; empty names fall back to the kind default), `DatePicker` rows, full-width day-circle row (≥44pt tap targets) with the summary in the section header, toggle rows with footers, stepper rows. Both modes commit via a **checkmark** in the navigation bar (labels: "Add Rule" / "Done"; replaces Hold to Commit). In edit mode an **ellipsis menu** ("Rule Actions") next to the checkmark holds Disable Rule and the destructive Delete Rule |
@@ -588,3 +588,26 @@ an escape hatch.
 
 Like all Screen Time behavior, the real device effect is only observable on a
 device (the simulator uses mock shields and delivers no DeviceActivity callbacks).
+
+### 6.2 About links (Settings)
+
+The Settings "About" section offers two outbound `Link` rows — **GitHub**
+(`githubLinkButton`) and **Website** (`websiteLinkButton`) — that open the
+project's repository and marketing site in the browser.
+
+Both destinations are **configuration, not code**. They come from the
+`OAL_GITHUB_URL` / `OAL_WEBSITE_URL` user-defined build settings in
+`Config/Shared.xcconfig`, ride into the app through `OpenAppLock/Info.plist`
+(keys `OALGitHubURL` / `OALWebsiteURL` — custom keys can't be injected into a
+*generated* Info.plist, so a real partial plist carries them), and are read at
+runtime through the single accessor `AppLinks`. Point them at the real links by
+editing the build settings; the website value is a placeholder until the site
+exists. A row whose URL is unset, blank, or unparseable is omitted, so the
+section is empty (and hidden) only when neither link is configured.
+
+`AppLinks.url(from:)` is the pure parse seam (trims, rejects blank/non-string);
+unit tests cover it and the full build-setting → Info.plist pipeline. A UI test
+asserts each button opens the configured URL by intercepting the `openURL`
+action in UI-testing mode (so no browser launches) — the launch arguments
+`-github-url=` / `-website-url=` (parsed by `LaunchConfiguration`) feed it
+deterministic URLs decoupled from the committed build settings.
diff --git a/OpenAppLock.xcodeproj/project.pbxproj b/OpenAppLock.xcodeproj/project.pbxproj
index 9a07b56..abefc5c 100644
--- a/OpenAppLock.xcodeproj/project.pbxproj
+++ b/OpenAppLock.xcodeproj/project.pbxproj
@@ -79,6 +79,13 @@
 /* End PBXFileReference section */
 
 /* Begin PBXFileSystemSynchronizedBuildFileExceptionSet section */
+		AB00000000000000000000B0 /* Exceptions for "OpenAppLock" folder in "OpenAppLock" target */ = {
+			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
+			membershipExceptions = (
+				Info.plist,
+			);
+			target = 20A7EDCD2E47B7CD0097608D /* OpenAppLock */;
+		};
 		AB00000000000000000000B1 /* Exceptions for "OpenAppLockMonitor" folder in "OpenAppLockMonitor" target */ = {
 			isa = PBXFileSystemSynchronizedBuildFileExceptionSet;
 			membershipExceptions = (
@@ -105,6 +112,9 @@
 /* Begin PBXFileSystemSynchronizedRootGroup section */
 		20A7EDD02E47B7CD0097608D /* OpenAppLock */ = {
 			isa = PBXFileSystemSynchronizedRootGroup;
+			exceptions = (
+				AB00000000000000000000B0 /* Exceptions for "OpenAppLock" folder in "OpenAppLock" target */,
+			);
 			path = OpenAppLock;
 			sourceTree = "<group>";
 		};
@@ -673,6 +683,7 @@
 				ENABLE_PREVIEWS = YES;
 				ENABLE_USER_SELECTED_FILES = readonly;
 				GENERATE_INFOPLIST_FILE = YES;
+				INFOPLIST_FILE = OpenAppLock/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = OpenAppLock;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.productivity";
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphoneos*]" = YES;
@@ -690,6 +701,7 @@
 				"LD_RUNPATH_SEARCH_PATHS[sdk=macosx*]" = "@executable_path/../Frameworks";
 				MACOSX_DEPLOYMENT_TARGET = 15.6;
 				MARKETING_VERSION = 1.0.0;
+				OAL_WEBSITE_URL = "https:$(SLASH)$(SLASH)openapplock.bchen.dev";
 				PRODUCT_BUNDLE_IDENTIFIER = dev.bchen.OpenAppLock;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				REGISTER_APP_GROUPS = YES;
@@ -717,6 +729,7 @@
 				ENABLE_PREVIEWS = YES;
 				ENABLE_USER_SELECTED_FILES = readonly;
 				GENERATE_INFOPLIST_FILE = YES;
+				INFOPLIST_FILE = OpenAppLock/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = OpenAppLock;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.productivity";
 				"INFOPLIST_KEY_UIApplicationSceneManifest_Generation[sdk=iphoneos*]" = YES;
@@ -734,6 +747,7 @@
 				"LD_RUNPATH_SEARCH_PATHS[sdk=macosx*]" = "@executable_path/../Frameworks";
 				MACOSX_DEPLOYMENT_TARGET = 15.6;
 				MARKETING_VERSION = 1.0.0;
+				OAL_WEBSITE_URL = "https:$(SLASH)$(SLASH)openapplock.bchen.dev";
 				PRODUCT_BUNDLE_IDENTIFIER = dev.bchen.OpenAppLock;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				REGISTER_APP_GROUPS = YES;
diff --git a/OpenAppLock/Info.plist b/OpenAppLock/Info.plist
new file mode 100644
index 0000000..23b1a71
--- /dev/null
+++ b/OpenAppLock/Info.plist
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<!-- Partial Info.plist: GENERATE_INFOPLIST_FILE=YES still merges Xcode's
+	     generated keys (scene manifest, orientations, …) on top of this file.
+	     Only the app-specific keys that can't be expressed as INFOPLIST_KEY_*
+	     build settings live here. The two link keys are fed from the
+	     OAL_GITHUB_URL / OAL_WEBSITE_URL build settings (Config/Shared.xcconfig)
+	     and read at runtime through AppLinks. -->
+	<key>OALGitHubURL</key>
+	<string>$(OAL_GITHUB_URL)</string>
+	<key>OALWebsiteURL</key>
+	<string>$(OAL_WEBSITE_URL)</string>
+</dict>
+</plist>
diff --git a/OpenAppLock/Services/AppLinks.swift b/OpenAppLock/Services/AppLinks.swift
new file mode 100644
index 0000000..4a61ead
--- /dev/null
+++ b/OpenAppLock/Services/AppLinks.swift
@@ -0,0 +1,40 @@
+//
+//  AppLinks.swift
+//  OpenAppLock
+//
+
+import Foundation
+
+/// The one place the app reads its outbound URLs (GitHub repo, marketing site).
+///
+/// The values are *configuration, not code*: they come from the
+/// `OAL_GITHUB_URL` / `OAL_WEBSITE_URL` user-defined build settings (see
+/// `Config/Shared.xcconfig`), surfaced to the runtime through the generated
+/// `Info.plist` via `INFOPLIST_KEY_OALGitHubURL` / `INFOPLIST_KEY_OALWebsiteURL`.
+/// Point them at the real destinations by editing the build settings — no code
+/// change needed.
+///
+/// Read them anywhere via ``gitHub`` / ``website``. Both are `nil` when the
+/// setting is unset, blank, or unparseable, so callers can simply omit the row.
+enum AppLinks {
+    /// Info.plist keys the build settings feed into (kept in sync with
+    /// `INFOPLIST_KEY_*` in `Config/Shared.xcconfig`).
+    static let gitHubInfoKey = "OALGitHubURL"
+    static let websiteInfoKey = "OALWebsiteURL"
+
+    /// The project's GitHub repository, or `nil` when unconfigured.
+    static var gitHub: URL? { url(from: Bundle.main.object(forInfoDictionaryKey: gitHubInfoKey)) }
+
+    /// The project's marketing website, or `nil` when unconfigured.
+    static var website: URL? { url(from: Bundle.main.object(forInfoDictionaryKey: websiteInfoKey)) }
+
+    /// Turns a raw Info.plist value into a usable URL. Pure and side-effect
+    /// free so it can be unit-tested directly: non-string, blank, or
+    /// whitespace-only values (and anything `URL` can't parse) become `nil`.
+    static func url(from rawValue: Any?) -> URL? {
+        guard let string = rawValue as? String else { return nil }
+        let trimmed = string.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return nil }
+        return URL(string: trimmed)
+    }
+}
diff --git a/OpenAppLock/Services/LaunchConfiguration.swift b/OpenAppLock/Services/LaunchConfiguration.swift
index d0872f8..e5383b0 100644
--- a/OpenAppLock/Services/LaunchConfiguration.swift
+++ b/OpenAppLock/Services/LaunchConfiguration.swift
@@ -23,11 +23,18 @@ struct LaunchConfiguration: Equatable {
     /// Forces the onboarding-completed flag at launch. Nil leaves stored state alone.
     var onboardingCompleted: Bool?
     var seedScenario: SeedScenario?
+    /// Overrides the Settings GitHub link so UI tests open a known URL instead of
+    /// the configured (swappable) build-setting value. Nil uses `AppLinks`.
+    var gitHubURLOverride: String?
+    /// Overrides the Settings website link for UI tests. Nil uses `AppLinks`.
+    var websiteURLOverride: String?
 
     static let uiTestingFlag = "-ui-testing"
     static let onboardingCompletedFlag = "-onboarding-completed"
     static let onboardingRequiredFlag = "-onboarding-required"
     static let seedScenarioPrefix = "-seed-scenario="
+    static let gitHubURLPrefix = "-github-url="
+    static let websiteURLPrefix = "-website-url="
 
     static func parse(arguments: [String]) -> LaunchConfiguration {
         var config = LaunchConfiguration()
@@ -42,8 +49,15 @@ struct LaunchConfiguration: Equatable {
                 rawValue: String(seedArgument.dropFirst(seedScenarioPrefix.count))
             )
         }
+        config.gitHubURLOverride = value(in: arguments, prefix: gitHubURLPrefix)
+        config.websiteURLOverride = value(in: arguments, prefix: websiteURLPrefix)
         return config
     }
 
+    /// Returns the suffix of the first `prefix=value` argument, or nil if absent.
+    private static func value(in arguments: [String], prefix: String) -> String? {
+        arguments.first { $0.hasPrefix(prefix) }.map { String($0.dropFirst(prefix.count)) }
+    }
+
     static let current = parse(arguments: ProcessInfo.processInfo.arguments)
 }
diff --git a/OpenAppLock/Views/Settings/SettingsView.swift b/OpenAppLock/Views/Settings/SettingsView.swift
index 5336b53..2b6e9b6 100644
--- a/OpenAppLock/Views/Settings/SettingsView.swift
+++ b/OpenAppLock/Views/Settings/SettingsView.swift
@@ -16,6 +16,23 @@ struct SettingsView: View {
     /// it through to the store and re-enforces in one step.
     @State private var uninstallProtectionOn = false
 
+    /// UI-test only: the destination of the most recent link tap, captured by
+    /// the `openURL` interceptor so a test can assert it (see `linkSection`).
+    @State private var lastOpenedLink: URL?
+
+    private let launch = LaunchConfiguration.current
+
+    /// The GitHub destination: a UI-test override when present, otherwise the
+    /// configured build-setting value read centrally through `AppLinks`.
+    private var gitHubURL: URL? {
+        AppLinks.url(from: launch.gitHubURLOverride) ?? AppLinks.gitHub
+    }
+
+    /// The website destination, resolved like ``gitHubURL``.
+    private var websiteURL: URL? {
+        AppLinks.url(from: launch.websiteURLOverride) ?? AppLinks.website
+    }
+
     var body: some View {
         NavigationStack {
             List {
@@ -61,14 +78,45 @@ struct SettingsView: View {
                 } header: {
                     Text("App Lists").textCase(nil)
                 }
+                linkSection
+                if launch.isUITesting {
+                    // Test-only probe: the destination of the last intercepted
+                    // link tap, so a UI test can assert the buttons open the
+                    // configured URLs without launching Safari.
+                    Section {
+                        Text(lastOpenedLink?.absoluteString ?? "none")
+                            .accessibilityIdentifier("openedLinkProbe")
+                    }
+                }
             }
             .navigationTitle("Settings")
+            .captureLinkTaps(when: launch.isUITesting) { lastOpenedLink = $0 }
         }
         .onAppear {
             uninstallProtectionOn = settings.uninstallProtectionEnabled
         }
     }
 
+    /// "About" section: external links (GitHub repo, marketing site). A link is
+    /// omitted when its destination is unconfigured; the whole section is
+    /// dropped when neither is set, so no stray header appears.
+    @ViewBuilder private var linkSection: some View {
+        if gitHubURL != nil || websiteURL != nil {
+            Section {
+                if let gitHubURL {
+                    Link("GitHub", destination: gitHubURL)
+                        .accessibilityIdentifier("githubLinkButton")
+                }
+                if let websiteURL {
+                    Link("Website", destination: websiteURL)
+                        .accessibilityIdentifier("websiteLinkButton")
+                }
+            } header: {
+                Text("About").textCase(nil)
+            }
+        }
+    }
+
     /// True while any Hard Mode rule is actively blocking, which locks the
     /// toggle (it must not be turned off while a hard block is in force).
     private var isUninstallProtectionLocked: Bool {
@@ -92,3 +140,20 @@ struct SettingsView: View {
         )
     }
 }
+
+private extension View {
+    /// In UI-testing mode, swallow `Link` activations and report the destination
+    /// instead of opening Safari, so a UI test can assert which URL was opened.
+    /// A no-op otherwise, so production links open normally.
+    @ViewBuilder
+    func captureLinkTaps(when active: Bool, perform: @escaping (URL) -> Void) -> some View {
+        if active {
+            environment(\.openURL, OpenURLAction { url in
+                perform(url)
+                return .handled
+            })
+        } else {
+            self
+        }
+    }
+}
diff --git a/OpenAppLockTests/AppLinksTests.swift b/OpenAppLockTests/AppLinksTests.swift
new file mode 100644
index 0000000..698db74
--- /dev/null
+++ b/OpenAppLockTests/AppLinksTests.swift
@@ -0,0 +1,53 @@
+//
+//  AppLinksTests.swift
+//  OpenAppLockTests
+//
+
+import Foundation
+import Testing
+
+@testable import OpenAppLock
+
+/// `AppLinks` is the single place the app reads its outbound URLs (GitHub repo,
+/// marketing site). The values arrive from `INFOPLIST_KEY_*` build settings, so
+/// these tests cover both the pure parsing seam and the real Info.plist pipeline
+/// (the unit-test target is app-hosted, so `Bundle.main` is the app bundle).
+@MainActor
+@Suite("AppLinks")
+struct AppLinksTests {
+    @Test("A well-formed URL string parses")
+    func parsesValidURL() {
+        let url = AppLinks.url(from: "https://example.com/path")
+        #expect(url?.absoluteString == "https://example.com/path")
+    }
+
+    @Test("Surrounding whitespace is trimmed before parsing")
+    func trimsWhitespace() {
+        let url = AppLinks.url(from: "  https://example.com  \n")
+        #expect(url?.absoluteString == "https://example.com")
+    }
+
+    @Test("Blank, whitespace-only, missing, and non-string values yield nil")
+    func rejectsUnusableValues() {
+        #expect(AppLinks.url(from: "") == nil)
+        #expect(AppLinks.url(from: "   \n ") == nil)
+        #expect(AppLinks.url(from: nil) == nil)
+        #expect(AppLinks.url(from: 42) == nil)
+    }
+
+    @Test("GitHub link is configured through the build settings → Info.plist pipeline")
+    func gitHubConfigured() {
+        let url = AppLinks.gitHub
+        #expect(url != nil)
+        // A full URL, not a "https:" fragment — guards against the xcconfig
+        // "//"-comment truncation the `$(SLASH)` indirection is there to avoid.
+        #expect(url?.absoluteString.contains("://") == true)
+    }
+
+    @Test("Website link is configured through the build settings → Info.plist pipeline")
+    func websiteConfigured() {
+        let url = AppLinks.website
+        #expect(url != nil)
+        #expect(url?.absoluteString.contains("://") == true)
+    }
+}
diff --git a/OpenAppLockTests/LaunchSupportTests.swift b/OpenAppLockTests/LaunchSupportTests.swift
index 26d0d68..b52e442 100644
--- a/OpenAppLockTests/LaunchSupportTests.swift
+++ b/OpenAppLockTests/LaunchSupportTests.swift
@@ -40,6 +40,24 @@ struct LaunchConfigurationTests {
         let config = LaunchConfiguration.parse(arguments: ["OpenAppLockApp", "-seed-scenario=nope"])
         #expect(config.seedScenario == nil)
     }
+
+    @Test("Link overrides are parsed from their prefixed arguments")
+    func linkOverrides() {
+        let config = LaunchConfiguration.parse(arguments: [
+            "OpenAppLockApp",
+            "-github-url=https://example.com/repo",
+            "-website-url=https://example.com/site",
+        ])
+        #expect(config.gitHubURLOverride == "https://example.com/repo")
+        #expect(config.websiteURLOverride == "https://example.com/site")
+    }
+
+    @Test("Link overrides default to nil when absent")
+    func linkOverridesDefaultNil() {
+        let config = LaunchConfiguration.parse(arguments: ["OpenAppLockApp"])
+        #expect(config.gitHubURLOverride == nil)
+        #expect(config.websiteURLOverride == nil)
+    }
 }
 
 @MainActor
diff --git a/OpenAppLockUITests/SettingsUITests.swift b/OpenAppLockUITests/SettingsUITests.swift
index dea8d56..39bcc96 100644
--- a/OpenAppLockUITests/SettingsUITests.swift
+++ b/OpenAppLockUITests/SettingsUITests.swift
@@ -71,6 +71,27 @@ final class SettingsUITests: XCTestCase {
         )
     }
 
+    func testAboutLinksOpenConfiguredURLs() throws {
+        let gitHub = "https://example.com/openapplock-repo"
+        let website = "https://example.com/openapplock-site"
+        let app = XCUIApplication.launchOpenAppLock(gitHubURL: gitHub, websiteURL: website)
+        app.goToSettingsTab()
+
+        // In UI-testing mode link taps are intercepted (no Safari launch) and the
+        // last-opened URL is reflected into `openedLinkProbe`, so we can assert
+        // each button opens the URL the app was configured with.
+        let probe = app.staticTexts["openedLinkProbe"].waitToAppear()
+        XCTAssertEqual(probe.label, "none", "No link should have been opened yet")
+
+        app.element("githubLinkButton").waitToAppear().tap()
+        expectation(for: NSPredicate(format: "label == %@", gitHub), evaluatedWith: probe)
+        waitForExpectations(timeout: 3)
+
+        app.element("websiteLinkButton").waitToAppear().tap()
+        expectation(for: NSPredicate(format: "label == %@", website), evaluatedWith: probe)
+        waitForExpectations(timeout: 3)
+    }
+
     func testManageAppListsLockedDuringHardSession() throws {
         let app = XCUIApplication.launchOpenAppLock(seedScenario: "hard-mode-active")
         app.goToSettingsTab()
diff --git a/OpenAppLockUITests/UITestSupport.swift b/OpenAppLockUITests/UITestSupport.swift
index cbb7fcc..66ba9f4 100644
--- a/OpenAppLockUITests/UITestSupport.swift
+++ b/OpenAppLockUITests/UITestSupport.swift
@@ -8,9 +8,15 @@ import XCTest
 extension XCUIApplication {
     /// Launches the app in UI-testing mode: in-memory storage, mocked Screen
     /// Time authorization, and no shield side effects.
+    ///
+    /// `gitHubURL` / `websiteURL` override the configured Settings links with
+    /// deterministic values, so link tests don't depend on the committed build
+    /// settings (which point at the real, swappable destinations).
     static func launchOpenAppLock(
         onboardingCompleted: Bool = true,
-        seedScenario: String? = nil
+        seedScenario: String? = nil,
+        gitHubURL: String? = nil,
+        websiteURL: String? = nil
     ) -> XCUIApplication {
         let app = XCUIApplication()
         var arguments = ["-ui-testing"]
@@ -18,6 +24,12 @@ extension XCUIApplication {
         if let seedScenario {
             arguments.append("-seed-scenario=\(seedScenario)")
         }
+        if let gitHubURL {
+            arguments.append("-github-url=\(gitHubURL)")
+        }
+        if let websiteURL {
+            arguments.append("-website-url=\(websiteURL)")
+        }
         app.launchArguments = arguments
         app.launch()
         return app