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/LiveActivity/LiveActivityManager.swift

@@ -0,0 +1,181 @@
+@preconcurrency import ActivityKit
+import Foundation
+import os
+
+/// Minimal Live Activity lifecycle focused on connection health + stale cleanup.
+@MainActor
+final class LiveActivityManager {
+    static let shared = LiveActivityManager()
+
+    private let logger = Logger(subsystem: "ai.openclawfoundation.app", category: "LiveActivity")
+    private let connectingStaleSeconds: TimeInterval = 120
+    private let hydrationStaleSeconds: TimeInterval = 300
+    private var currentActivity: Activity<OpenClawActivityAttributes>?
+    private var activityStartDate: Date = .now
+
+    private init() {
+        self.hydrateCurrentAndPruneDuplicates()
+    }
+
+    func showConnecting(statusText: String = "Connecting...", agentName: String, sessionKey: String) {
+        self.hydrateCurrentAndPruneDuplicates()
+
+        if self.currentActivity != nil {
+            self.handleConnecting(statusText: statusText)
+            return
+        }
+
+        let authInfo = ActivityAuthorizationInfo()
+        guard authInfo.areActivitiesEnabled else {
+            self.logger.info("Live Activities disabled; skipping start")
+            return
+        }
+
+        self.activityStartDate = .now
+        let attributes = OpenClawActivityAttributes(agentName: agentName, sessionKey: sessionKey)
+        let state = self.connectingState(statusText: statusText)
+
+        do {
+            let activity = try Activity.request(
+                attributes: attributes,
+                content: ActivityContent(
+                    state: state,
+                    staleDate: Date().addingTimeInterval(self.connectingStaleSeconds)),
+                pushType: nil)
+            self.currentActivity = activity
+            self.logger.info("started live activity id=\(activity.id, privacy: .public)")
+        } catch {
+            self.logger.error("failed to start live activity: \(error.localizedDescription, privacy: .public)")
+        }
+    }
+
+    func showAttention(statusText: String, agentName: String, sessionKey: String) {
+        self.hydrateCurrentAndPruneDuplicates()
+
+        if self.currentActivity == nil {
+            let authInfo = ActivityAuthorizationInfo()
+            guard authInfo.areActivitiesEnabled else {
+                self.logger.info("Live Activities disabled; skipping attention state")
+                return
+            }
+            self.activityStartDate = .now
+            let attributes = OpenClawActivityAttributes(agentName: agentName, sessionKey: sessionKey)
+            do {
+                let activity = try Activity.request(
+                    attributes: attributes,
+                    content: ActivityContent(state: self.attentionState(statusText: statusText), staleDate: nil),
+                    pushType: nil)
+                self.currentActivity = activity
+                self.logger.info("started attention live activity id=\(activity.id, privacy: .public)")
+            } catch {
+                self.logger.error(
+                    "failed to start attention live activity: \(error.localizedDescription, privacy: .public)")
+            }
+            return
+        }
+
+        self.updateCurrent(state: self.attentionState(statusText: statusText), staleDate: nil)
+    }
+
+    func handleConnecting(statusText: String = "Connecting...") {
+        self.updateCurrent(
+            state: self.connectingState(statusText: statusText),
+            staleDate: Date().addingTimeInterval(self.connectingStaleSeconds))
+    }
+
+    func handleReconnect() {
+        self.endActivity(reason: "connected")
+    }
+
+    func endActivity(reason: String) {
+        guard let activity = self.currentActivity else { return }
+        self.currentActivity = nil
+        self.logger.info("ending live activity reason=\(reason, privacy: .public)")
+        Task {
+            await activity.end(
+                ActivityContent(state: self.disconnectedState(), staleDate: nil),
+                dismissalPolicy: .immediate)
+        }
+    }
+
+    private func hydrateCurrentAndPruneDuplicates() {
+        let active = Activity<OpenClawActivityAttributes>.activities
+        guard !active.isEmpty else {
+            self.currentActivity = nil
+            return
+        }
+
+        let now = Date()
+        let candidates = active.filter { activity in
+            let state = activity.content.state
+            guard activity.activityState == .active else { return false }
+            guard !state.isIdle, !state.isDisconnected else { return false }
+            return now.timeIntervalSince(state.startedAt) < self.hydrationStaleSeconds
+        }
+
+        guard !candidates.isEmpty else {
+            self.currentActivity = nil
+            for activity in active {
+                self.end(activity: activity)
+            }
+            return
+        }
+
+        let keeper = candidates.max { lhs, rhs in
+            lhs.content.state.startedAt < rhs.content.state.startedAt
+        } ?? candidates[0]
+
+        self.currentActivity = keeper
+        self.activityStartDate = keeper.content.state.startedAt
+
+        let stale = active.filter { $0.id != keeper.id }
+        for activity in stale {
+            self.end(activity: activity)
+        }
+    }
+
+    private func updateCurrent(state: OpenClawActivityAttributes.ContentState, staleDate: Date? = nil) {
+        guard let activity = self.currentActivity, activity.activityState == .active else {
+            self.currentActivity = nil
+            return
+        }
+        Task {
+            await activity.update(ActivityContent(state: state, staleDate: staleDate))
+        }
+    }
+
+    private func end(activity: Activity<OpenClawActivityAttributes>) {
+        Task {
+            await activity.end(
+                ActivityContent(state: self.disconnectedState(), staleDate: nil),
+                dismissalPolicy: .immediate)
+        }
+    }
+
+    private func connectingState(statusText: String = "Connecting...") -> OpenClawActivityAttributes.ContentState {
+        OpenClawActivityAttributes.ContentState(
+            statusText: statusText,
+            isIdle: false,
+            isDisconnected: false,
+            isConnecting: true,
+            startedAt: self.activityStartDate)
+    }
+
+    private func attentionState(statusText: String) -> OpenClawActivityAttributes.ContentState {
+        OpenClawActivityAttributes.ContentState(
+            statusText: statusText,
+            isIdle: false,
+            isDisconnected: false,
+            isConnecting: false,
+            startedAt: self.activityStartDate)
+    }
+
+    private func disconnectedState() -> OpenClawActivityAttributes.ContentState {
+        OpenClawActivityAttributes.ContentState(
+            statusText: "Disconnected",
+            isIdle: false,
+            isDisconnected: true,
+            isConnecting: false,
+            startedAt: self.activityStartDate)
+    }
+}