Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

apps/ios/Sources/Location/LocationPermissionSummary.swift

@@ -0,0 +1,102 @@
+import CoreLocation
+import Foundation
+import OpenClawKit
+
+struct LocationPermissionSummary: Equatable {
+    var desiredMode: OpenClawLocationMode
+    var locationServicesEnabled: Bool
+    var authorizationStatus: CLAuthorizationStatus
+    var accuracyAuthorization: CLAccuracyAuthorization
+
+    var effectiveMode: OpenClawLocationMode {
+        guard self.desiredMode != .off else { return .off }
+        guard self.locationServicesEnabled else { return .off }
+        switch self.authorizationStatus {
+        case .authorizedAlways:
+            return self.desiredMode == .always ? .always : .whileUsing
+        case .authorizedWhenInUse:
+            return .whileUsing
+        default:
+            return .off
+        }
+    }
+
+    var canUseLocationInBackground: Bool {
+        self.locationServicesEnabled && self.desiredMode == .always && self.authorizationStatus == .authorizedAlways
+    }
+
+    var needsAttention: Bool {
+        switch self.desiredMode {
+        case .off:
+            false
+        case .whileUsing:
+            !self.locationServicesEnabled ||
+                (self.authorizationStatus != .authorizedWhenInUse && self.authorizationStatus != .authorizedAlways)
+        case .always:
+            !self.locationServicesEnabled || self.authorizationStatus != .authorizedAlways
+        }
+    }
+
+    var statusText: String {
+        switch self.effectiveMode {
+        case .off:
+            "Off"
+        case .whileUsing:
+            "While Using"
+        case .always:
+            "Always"
+        }
+    }
+
+    var detailText: String {
+        switch (
+            self.desiredMode,
+            self.locationServicesEnabled,
+            self.authorizationStatus,
+            self.accuracyAuthorization)
+        {
+        case (.off, false, _, _):
+            "Location sharing is disabled in OpenClaw. Location Services are off in iOS Settings."
+        case (.off, true, .authorizedAlways, _):
+            "Location sharing is disabled in OpenClaw. iOS currently allows Always."
+        case (.off, true, .authorizedWhenInUse, _):
+            "Location sharing is disabled in OpenClaw. iOS currently allows While Using."
+        case (.off, _, _, _):
+            "Location sharing is disabled."
+        case (_, false, _, _):
+            "Location Services are off in iOS Settings."
+        case (.whileUsing, true, .authorizedWhenInUse, .fullAccuracy):
+            "Foreground location requests are allowed. Precise Location is on."
+        case (.whileUsing, true, .authorizedAlways, .fullAccuracy):
+            "Foreground location requests are allowed. Precise Location is on."
+        case (.whileUsing, true, .authorizedWhenInUse, .reducedAccuracy):
+            "Foreground location requests are allowed. Precise Location is off."
+        case (.whileUsing, true, .authorizedAlways, .reducedAccuracy):
+            "Foreground location requests are allowed. Precise Location is off."
+        case (.whileUsing, true, .authorizedWhenInUse, _):
+            "Foreground location requests are allowed."
+        case (.whileUsing, true, .authorizedAlways, _):
+            "Foreground location requests are allowed."
+        case (.always, true, .authorizedAlways, .fullAccuracy):
+            "Background location requests and significant-change updates are allowed. Precise Location is on."
+        case (.always, true, .authorizedAlways, .reducedAccuracy):
+            "Background location requests and significant-change updates are allowed. Precise Location is off."
+        case (.always, true, .authorizedAlways, _):
+            "Background location requests and significant-change updates are allowed."
+        case (.always, true, .authorizedWhenInUse, .fullAccuracy):
+            "Always is selected, but iOS currently allows location only while using the app. Precise Location is on."
+        case (.always, true, .authorizedWhenInUse, .reducedAccuracy):
+            "Always is selected, but iOS currently allows location only while using the app. Precise Location is off."
+        case (.always, true, .authorizedWhenInUse, _):
+            "Always is selected, but iOS currently allows location only while using the app."
+        case (_, true, .denied, _):
+            "Location permission is denied in iOS Settings."
+        case (_, true, .restricted, _):
+            "Location permission is restricted on this device."
+        case (_, true, .notDetermined, _):
+            "Choose a location mode to request iOS permission."
+        @unknown default:
+            "OpenClaw cannot determine the current iOS location permission."
+        }
+    }
+}

apps/ios/Sources/Location/LocationService.swift

@@ -0,0 +1,174 @@
+import CoreLocation
+import Foundation
+import OpenClawKit
+import UIKit
+
+@MainActor
+final class LocationService: NSObject, CLLocationManagerDelegate, LocationServiceCommon {
+    enum Error: Swift.Error {
+        case timeout
+        case unavailable
+    }
+
+    private let manager = CLLocationManager()
+    private var authWaitID: UUID?
+    private var authContinuation: CheckedContinuation<CLAuthorizationStatus, Never>?
+    private var locationContinuation: CheckedContinuation<CLLocation, Swift.Error>?
+    private var authorizationChangeHandler: (@MainActor @Sendable (CLAuthorizationStatus) -> Void)?
+    private var significantLocationCallback: (@Sendable (CLLocation) -> Void)?
+    private var isMonitoringSignificantChanges = false
+
+    var locationManager: CLLocationManager {
+        self.manager
+    }
+
+    var locationRequestContinuation: CheckedContinuation<CLLocation, Swift.Error>? {
+        get { self.locationContinuation }
+        set { self.locationContinuation = newValue }
+    }
+
+    override init() {
+        super.init()
+        self.configureLocationManager()
+    }
+
+    func ensureAuthorization(mode: OpenClawLocationMode) async -> CLAuthorizationStatus {
+        guard CLLocationManager.locationServicesEnabled() else { return .denied }
+
+        let status = self.manager.authorizationStatus
+        if status == .notDetermined {
+            self.manager.requestWhenInUseAuthorization()
+            let updated = await self.awaitAuthorizationChange()
+            if mode != .always { return updated }
+        }
+
+        if mode == .always {
+            let current = self.manager.authorizationStatus
+            if current == .authorizedWhenInUse {
+                self.manager.requestAlwaysAuthorization()
+                return await self.awaitAuthorizationChange()
+            }
+            return current
+        }
+
+        return self.manager.authorizationStatus
+    }
+
+    func currentLocation(
+        params: OpenClawLocationGetParams,
+        desiredAccuracy: OpenClawLocationAccuracy,
+        maxAgeMs: Int?,
+        timeoutMs: Int?) async throws -> CLLocation
+    {
+        _ = params
+        return try await LocationCurrentRequest.resolve(
+            manager: self.manager,
+            desiredAccuracy: desiredAccuracy,
+            maxAgeMs: maxAgeMs,
+            timeoutMs: timeoutMs,
+            request: { try await self.requestLocationOnce() },
+            withTimeout: { timeoutMs, operation in
+                try await self.withTimeout(timeoutMs: timeoutMs, operation: operation)
+            })
+    }
+
+    private func awaitAuthorizationChange() async -> CLAuthorizationStatus {
+        await withCheckedContinuation { cont in
+            let waitID = UUID()
+            self.authWaitID = waitID
+            self.authContinuation = cont
+            Task { @MainActor in
+                let clock = ContinuousClock()
+                let noPromptDeadline = clock.now.advanced(by: .milliseconds(1500))
+                var observedPrompt = UIApplication.shared.applicationState != .active
+                // A slow system prompt must not trigger the no-callback fallback. Once iOS makes
+                // the app inactive, wait until the user dismisses the prompt and the app returns.
+                while self.authWaitID == waitID, self.authContinuation != nil {
+                    try? await Task.sleep(for: .milliseconds(100))
+                    let applicationIsActive = UIApplication.shared.applicationState == .active
+                    if !applicationIsActive {
+                        observedPrompt = true
+                        continue
+                    }
+                    guard observedPrompt || clock.now >= noPromptDeadline else { continue }
+                    self.finishAuthorizationWait(waitID: waitID, status: self.manager.authorizationStatus)
+                }
+            }
+        }
+    }
+
+    private func finishAuthorizationWait(waitID: UUID, status: CLAuthorizationStatus) {
+        guard self.authWaitID == waitID, let cont = self.authContinuation else { return }
+        self.authWaitID = nil
+        self.authContinuation = nil
+        cont.resume(returning: status)
+    }
+
+    private func withTimeout<T: Sendable>(
+        timeoutMs: Int,
+        operation: @escaping @Sendable () async throws -> T) async throws -> T
+    {
+        try await AsyncTimeout.withTimeoutMs(timeoutMs: timeoutMs, onTimeout: { Error.timeout }, operation: operation)
+    }
+
+    func startMonitoringSignificantLocationChanges(onUpdate: @escaping @Sendable (CLLocation) -> Void) {
+        self.significantLocationCallback = onUpdate
+        guard !self.isMonitoringSignificantChanges else { return }
+        self.isMonitoringSignificantChanges = true
+        self.manager.startMonitoringSignificantLocationChanges()
+    }
+
+    func setBackgroundLocationUpdatesEnabled(_ enabled: Bool) {
+        self.manager.allowsBackgroundLocationUpdates = enabled
+    }
+
+    func setAuthorizationChangeHandler(
+        _ handler: @escaping @MainActor @Sendable (CLAuthorizationStatus) -> Void)
+    {
+        self.authorizationChangeHandler = handler
+    }
+
+    func stopMonitoringSignificantLocationChanges() {
+        self.significantLocationCallback = nil
+        self.isMonitoringSignificantChanges = false
+        self.manager.stopMonitoringSignificantLocationChanges()
+    }
+
+    nonisolated func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        let status = manager.authorizationStatus
+        Task { @MainActor in
+            self.authorizationChangeHandler?(status)
+            guard let waitID = self.authWaitID else { return }
+            self.finishAuthorizationWait(waitID: waitID, status: status)
+        }
+    }
+
+    nonisolated func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        let locs = locations
+        Task { @MainActor in
+            // Resolve the one-shot continuation first (if any).
+            if let cont = self.locationContinuation {
+                self.locationContinuation = nil
+                if let latest = locs.last {
+                    cont.resume(returning: latest)
+                } else {
+                    cont.resume(throwing: Error.unavailable)
+                }
+                // Don't return — also forward to significant-change callback below
+                // so both consumers receive updates when both are active.
+            }
+            if let callback = self.significantLocationCallback, let latest = locs.last {
+                callback(latest)
+            }
+        }
+    }
+
+    nonisolated func locationManager(_ manager: CLLocationManager, didFailWithError error: Swift.Error) {
+        let err = error
+        Task { @MainActor in
+            guard let cont = self.locationContinuation else { return }
+            self.locationContinuation = nil
+            cont.resume(throwing: err)
+        }
+    }
+}

apps/ios/Sources/Location/SignificantLocationMonitor.swift

@@ -0,0 +1,43 @@
+import CoreLocation
+import Foundation
+import OpenClawKit
+
+/// Monitors significant location changes and pushes `location.update`
+/// events to the gateway so the severance hook can determine whether
+/// the user is at their configured work location.
+@MainActor
+enum SignificantLocationMonitor {
+    static func startIfNeeded(
+        locationService: any LocationServicing,
+        locationMode: OpenClawLocationMode,
+        gateway: GatewayNodeSession,
+        beforeSend: (@MainActor @Sendable () async -> Void)? = nil)
+    {
+        guard locationMode == .always else { return }
+        let status = locationService.authorizationStatus()
+        guard status == .authorizedAlways else { return }
+        locationService.setBackgroundLocationUpdatesEnabled(true)
+        locationService.startMonitoringSignificantLocationChanges { location in
+            struct Payload: Codable {
+                var lat: Double
+                var lon: Double
+                var accuracyMeters: Double
+                var source: String?
+            }
+            let payload = Payload(
+                lat: location.coordinate.latitude,
+                lon: location.coordinate.longitude,
+                accuracyMeters: location.horizontalAccuracy,
+                source: "ios-significant-location")
+            guard let data = try? JSONEncoder().encode(payload),
+                  let json = String(data: data, encoding: .utf8)
+            else { return }
+            Task { @MainActor in
+                if let beforeSend {
+                    await beforeSend()
+                }
+                await gateway.sendEvent(event: "location.update", payloadJSON: json)
+            }
+        }
+    }
+}