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/WatchApp/Sources/WatchInboxStore.swift

@@ -0,0 +1,821 @@
+import Foundation
+import Observation
+import UserNotifications
+import WatchKit
+
+enum WatchPayloadType: String, Codable, Equatable {
+    case notify = "watch.notify"
+    case reply = "watch.reply"
+    case appSnapshot = "watch.app.snapshot"
+    case appSnapshotRequest = "watch.app.snapshotRequest"
+    case appCommand = "watch.app.command"
+    case execApprovalPrompt = "watch.execApproval.prompt"
+    case execApprovalResolve = "watch.execApproval.resolve"
+    case execApprovalResolved = "watch.execApproval.resolved"
+    case execApprovalExpired = "watch.execApproval.expired"
+    case execApprovalSnapshot = "watch.execApproval.snapshot"
+    case execApprovalSnapshotRequest = "watch.execApproval.snapshotRequest"
+}
+
+enum WatchRiskLevel: String, Codable, Equatable {
+    case low
+    case medium
+    case high
+}
+
+enum WatchExecApprovalDecision: String, Codable, Equatable {
+    case allowOnce = "allow-once"
+    case deny
+}
+
+enum WatchExecApprovalCloseReason: String, Codable, Equatable {
+    case expired
+    case notFound = "not-found"
+    case unavailable
+    case replaced
+    case resolved
+}
+
+struct WatchExecApprovalItem: Codable, Equatable, Identifiable {
+    var id: String
+    var commandText: String
+    var commandPreview: String?
+    var host: String?
+    var nodeId: String?
+    var agentId: String?
+    var expiresAtMs: Int?
+    var allowedDecisions: [WatchExecApprovalDecision]
+    var risk: WatchRiskLevel?
+}
+
+struct WatchExecApprovalPromptMessage: Codable, Equatable {
+    var approval: WatchExecApprovalItem
+    var sentAtMs: Int?
+    var deliveryId: String?
+    var resetResolvingState: Bool?
+}
+
+struct WatchExecApprovalResolvedMessage: Codable, Equatable {
+    var approvalId: String
+    var decision: WatchExecApprovalDecision?
+    var resolvedAtMs: Int?
+    var source: String?
+}
+
+struct WatchExecApprovalExpiredMessage: Codable, Equatable {
+    var approvalId: String
+    var reason: WatchExecApprovalCloseReason
+    var expiredAtMs: Int?
+}
+
+struct WatchExecApprovalSnapshotMessage: Codable, Equatable {
+    var approvals: [WatchExecApprovalItem]
+    var sentAtMs: Int?
+    var snapshotId: String?
+}
+
+struct WatchExecApprovalSnapshotRequestMessage: Codable, Equatable {
+    var requestId: String
+    var sentAtMs: Int?
+}
+
+struct WatchExecApprovalResolveMessage: Codable, Equatable {
+    var approvalId: String
+    var decision: WatchExecApprovalDecision
+    var replyId: String
+    var sentAtMs: Int?
+}
+
+struct WatchAppSnapshotMessage: Codable, Equatable {
+    var gatewayStatusText: String
+    var gatewayConnected: Bool
+    var agentName: String
+    var agentAvatarURL: String?
+    var agentAvatarText: String?
+    var sessionKey: String
+    var gatewayStableID: String?
+    var talkStatusText: String
+    var talkEnabled: Bool
+    var talkListening: Bool
+    var talkSpeaking: Bool
+    var pendingApprovalCount: Int
+    var chatItems: [WatchChatItem]?
+    var chatStatusText: String?
+    var sentAtMs: Int?
+    var snapshotId: String?
+}
+
+struct WatchChatItem: Codable, Equatable, Identifiable {
+    var id: String
+    var role: String
+    var text: String
+    var timestampMs: Int?
+}
+
+struct WatchAppSnapshotRequestMessage: Codable, Equatable {
+    var requestId: String
+    var sentAtMs: Int?
+}
+
+enum WatchAppCommand: String, Codable, Equatable {
+    case refresh
+    case openChat = "open-chat"
+    case sendChat = "send-chat"
+    case startTalk = "start-talk"
+    case stopTalk = "stop-talk"
+}
+
+struct WatchAppCommandMessage: Codable, Equatable {
+    var command: WatchAppCommand
+    var commandId: String
+    var sessionKey: String?
+    var gatewayStableID: String?
+    var text: String?
+    var sentAtMs: Int?
+}
+
+struct WatchPromptAction: Codable, Equatable, Identifiable {
+    var id: String
+    var label: String
+    var style: String?
+}
+
+struct WatchNotifyMessage {
+    var id: String?
+    var title: String
+    var body: String
+    var sentAtMs: Int?
+    var promptId: String?
+    var sessionKey: String?
+    var kind: String?
+    var details: String?
+    var expiresAtMs: Int?
+    var risk: String?
+    var actions: [WatchPromptAction]
+}
+
+struct WatchExecApprovalRecord: Codable, Equatable, Identifiable {
+    var approval: WatchExecApprovalItem
+    var transport: String
+    var updatedAt: Date
+    var isResolving: Bool
+    var pendingDecision: WatchExecApprovalDecision?
+    var statusText: String?
+    var statusAt: Date?
+
+    var id: String {
+        self.approval.id
+    }
+}
+
+@MainActor @Observable final class WatchInboxStore {
+    private struct PersistedState: Codable {
+        var title: String
+        var body: String
+        var transport: String
+        var updatedAt: Date
+        var lastDeliveryKey: String?
+        var promptId: String?
+        var sessionKey: String?
+        var kind: String?
+        var details: String?
+        var expiresAtMs: Int?
+        var risk: String?
+        var actions: [WatchPromptAction]?
+        var replyStatusText: String?
+        var replyStatusAt: Date?
+        var execApprovals: [WatchExecApprovalRecord]
+        var selectedExecApprovalID: String?
+        var lastExecApprovalSnapshotID: String?
+        var lastExecApprovalOutcomeText: String?
+        var lastExecApprovalOutcomeAt: Date?
+        var appSnapshot: WatchAppSnapshotMessage?
+        var appSnapshotUpdatedAt: Date?
+        var appSnapshotStatusText: String?
+        var appCommandStatusText: String?
+    }
+
+    private static let persistedStateKey = "watch.inbox.state.v2"
+    private static let defaultTitle = "OpenClaw"
+    private static let defaultBody = "Waiting for messages from your iPhone."
+    private let defaults: UserDefaults
+
+    var title = WatchInboxStore.defaultTitle
+    var body = WatchInboxStore.defaultBody
+    var transport = "none"
+    var updatedAt: Date?
+    var promptId: String?
+    var sessionKey: String?
+    var kind: String?
+    var details: String?
+    var expiresAtMs: Int?
+    var risk: String?
+    var actions: [WatchPromptAction] = []
+    var replyStatusText: String?
+    var replyStatusAt: Date?
+    var isReplySending = false
+    var execApprovals: [WatchExecApprovalRecord] = []
+    var selectedExecApprovalID: String?
+    var lastExecApprovalOutcomeText: String?
+    var lastExecApprovalOutcomeAt: Date?
+    var appSnapshot: WatchAppSnapshotMessage?
+    var appSnapshotUpdatedAt: Date?
+    var appSnapshotStatusText: String?
+    var appCommandStatusText: String?
+    var greetingTextOverride: String?
+    var isExecApprovalReviewLoading = false
+    var execApprovalReviewStatusText: String?
+    var execApprovalReviewStatusAt: Date?
+    private var lastExecApprovalSnapshotID: String?
+    private var hasCompletedExecApprovalSnapshotRefreshInSession = false
+    private var lastDeliveryKey: String?
+
+    init(
+        defaults: UserDefaults = .standard,
+        requestNotificationAuthorization: Bool = true)
+    {
+        self.defaults = defaults
+        self.restorePersistedState()
+        self.pruneExpiredExecApprovals(nowMs: Self.nowMs())
+        if requestNotificationAuthorization {
+            Task {
+                await self.ensureNotificationAuthorization()
+            }
+        }
+    }
+
+    var sortedExecApprovals: [WatchExecApprovalRecord] {
+        self.execApprovals.sorted { lhs, rhs in
+            let lhsExpires = lhs.approval.expiresAtMs ?? Int.max
+            let rhsExpires = rhs.approval.expiresAtMs ?? Int.max
+            if lhsExpires != rhsExpires {
+                return lhsExpires < rhsExpires
+            }
+            return lhs.updatedAt > rhs.updatedAt
+        }
+    }
+
+    var activeExecApproval: WatchExecApprovalRecord? {
+        if let selectedExecApprovalID,
+           let selected = execApprovals.first(where: { $0.id == selectedExecApprovalID })
+        {
+            return selected
+        }
+        return self.sortedExecApprovals.first
+    }
+
+    var shouldAutoRequestExecApprovalSnapshot: Bool {
+        self.execApprovals.isEmpty
+            && self.actions.isEmpty
+            && self.title == Self.defaultTitle
+            && self.body == Self.defaultBody
+            && !self.hasCompletedExecApprovalSnapshotRefreshInSession
+    }
+
+    var hasCompletedExecApprovalSnapshotRefresh: Bool {
+        self.hasCompletedExecApprovalSnapshotRefreshInSession
+    }
+
+    var shouldShowExecApprovalReviewStatus: Bool {
+        self.execApprovals.isEmpty && !(self.execApprovalReviewStatusText?.isEmpty ?? true)
+    }
+
+    var hasAppSnapshot: Bool {
+        self.appSnapshot != nil
+    }
+
+    var hasMessagePrompt: Bool {
+        self.title != Self.defaultTitle
+            || self.body != Self.defaultBody
+            || !self.actions.isEmpty
+    }
+
+    var gatewaySummaryText: String {
+        guard let appSnapshot else { return "Waiting for iPhone" }
+        return appSnapshot.gatewayConnected ? "Connected" : appSnapshot.gatewayStatusText
+    }
+
+    var talkSummaryText: String {
+        guard let appSnapshot else { return "Not synced" }
+        if appSnapshot.talkListening {
+            return "Listening"
+        }
+        if appSnapshot.talkSpeaking {
+            return "Speaking"
+        }
+        if appSnapshot.talkEnabled {
+            return appSnapshot.talkStatusText.isEmpty ? "Ready" : appSnapshot.talkStatusText
+        }
+        return "Off"
+    }
+
+    func beginExecApprovalReviewLoading() {
+        guard self.execApprovals.isEmpty else {
+            self.markExecApprovalReviewLoaded()
+            return
+        }
+        self.isExecApprovalReviewLoading = true
+        self.execApprovalReviewStatusText = "Loading approval from iPhone…"
+        self.execApprovalReviewStatusAt = Date()
+    }
+
+    func markExecApprovalReviewLoaded() {
+        self.isExecApprovalReviewLoading = false
+        self.execApprovalReviewStatusText = nil
+        self.execApprovalReviewStatusAt = nil
+    }
+
+    func markExecApprovalReviewUnavailable(_ message: String) {
+        guard self.execApprovals.isEmpty else {
+            self.markExecApprovalReviewLoaded()
+            return
+        }
+        self.isExecApprovalReviewLoading = false
+        self.execApprovalReviewStatusText = message
+        self.execApprovalReviewStatusAt = Date()
+    }
+
+    func consume(message: WatchNotifyMessage, transport: String) {
+        let messageID = message.id?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+        let deliveryKey = self.deliveryKey(
+            messageID: messageID,
+            title: message.title,
+            body: message.body,
+            sentAtMs: message.sentAtMs)
+        guard deliveryKey != self.lastDeliveryKey else { return }
+
+        let normalizedTitle = message.title.isEmpty ? "OpenClaw" : message.title
+        self.title = normalizedTitle
+        self.body = message.body
+        self.transport = transport
+        self.markExecApprovalReviewLoaded()
+        self.updatedAt = Date()
+        self.promptId = message.promptId
+        self.sessionKey = message.sessionKey
+        self.kind = message.kind
+        self.details = message.details
+        self.expiresAtMs = message.expiresAtMs
+        self.risk = message.risk
+        self.actions = message.actions
+        self.lastDeliveryKey = deliveryKey
+        self.replyStatusText = nil
+        self.replyStatusAt = nil
+        self.isReplySending = false
+        self.persistState()
+
+        Task {
+            await self.postLocalNotification(
+                identifier: deliveryKey,
+                title: normalizedTitle,
+                body: message.body,
+                risk: message.risk)
+        }
+    }
+
+    func consume(
+        execApprovalPrompt message: WatchExecApprovalPromptMessage,
+        transport: String)
+    {
+        self.pruneExpiredExecApprovals(nowMs: Self.nowMs())
+        self.upsertExecApproval(
+            message.approval,
+            transport: transport,
+            keepSelectionIfPossible: true,
+            resetResolvingState: message.resetResolvingState == true)
+        self.markExecApprovalReviewLoaded()
+        self.lastExecApprovalOutcomeText = nil
+        self.lastExecApprovalOutcomeAt = nil
+
+        Task {
+            await self.postLocalNotification(
+                identifier: "watch.execApproval.\(message.approval.id)",
+                title: "Exec approval required",
+                body: message.approval.commandPreview ?? message.approval.commandText,
+                risk: message.approval.risk?.rawValue)
+        }
+    }
+
+    func consume(
+        execApprovalSnapshot message: WatchExecApprovalSnapshotMessage,
+        transport: String)
+    {
+        let snapshotID = message.snapshotId?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let snapshotID, !snapshotID.isEmpty, snapshotID == lastExecApprovalSnapshotID {
+            return
+        }
+
+        let existingRecordsByID = Dictionary(
+            uniqueKeysWithValues: execApprovals.map { ($0.id, $0) })
+        self.execApprovals = message.approvals.map { approval in
+            self.mergedExecApprovalRecord(
+                approval: approval,
+                transport: transport,
+                existingRecord: existingRecordsByID[approval.id])
+        }
+        self.lastExecApprovalSnapshotID = snapshotID
+        self.hasCompletedExecApprovalSnapshotRefreshInSession = true
+        if let selectedExecApprovalID,
+           !self.execApprovals.contains(where: { $0.id == selectedExecApprovalID })
+        {
+            self.selectedExecApprovalID = self.sortedExecApprovals.first?.id
+        } else if selectedExecApprovalID == nil {
+            selectedExecApprovalID = self.sortedExecApprovals.first?.id
+        }
+        self.pruneExpiredExecApprovals(nowMs: Self.nowMs())
+        self.markExecApprovalReviewLoaded()
+        self.persistState()
+    }
+
+    func consume(appSnapshot message: WatchAppSnapshotMessage) {
+        let snapshotID = message.snapshotId?.trimmingCharacters(in: .whitespacesAndNewlines)
+        if let snapshotID, !snapshotID.isEmpty, snapshotID == appSnapshot?.snapshotId {
+            return
+        }
+        var merged = message
+        if merged.chatItems == nil {
+            merged.chatItems = self.appSnapshot?.chatItems
+        }
+        if merged.chatStatusText == nil {
+            merged.chatStatusText = self.appSnapshot?.chatStatusText
+        }
+        self.appSnapshot = merged
+        self.appSnapshotUpdatedAt = Date()
+        self.appSnapshotStatusText = nil
+        self.persistState()
+    }
+
+    func markAppSnapshotRequestStarted() {
+        self.appSnapshotStatusText = "Refreshing from iPhone…"
+        self.persistState()
+    }
+
+    func markAppSnapshotRequestResult(_ result: WatchReplySendResult) {
+        if let errorMessage = result.errorMessage, !errorMessage.isEmpty {
+            self.appSnapshotStatusText = "Refresh failed: \(errorMessage)"
+        } else if result.deliveredImmediately {
+            self.appSnapshotStatusText = "Refresh requested"
+        } else if result.queuedForDelivery {
+            self.appSnapshotStatusText = "Refresh queued"
+        } else {
+            self.appSnapshotStatusText = nil
+        }
+        self.persistState()
+    }
+
+    func makeAppCommand(_ command: WatchAppCommand, text: String? = nil) -> WatchAppCommandMessage {
+        let snapshotSessionKey = self.appSnapshot?.sessionKey.trimmingCharacters(in: .whitespacesAndNewlines)
+        return WatchAppCommandMessage(
+            command: command,
+            commandId: UUID().uuidString,
+            sessionKey: (snapshotSessionKey?.isEmpty == false) ? snapshotSessionKey : self.sessionKey,
+            gatewayStableID: self.appSnapshot?.gatewayStableID,
+            text: text,
+            sentAtMs: Self.nowMs())
+    }
+
+    var hasGatewayTaggedAppSnapshot: Bool {
+        let gatewayStableID = self.appSnapshot?.gatewayStableID?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+        return !gatewayStableID.isEmpty
+    }
+
+    func markAppCommandSending(_ command: WatchAppCommand) {
+        self.appCommandStatusText = "Sending \(Self.commandLabel(command))…"
+        self.persistState()
+    }
+
+    func markAppCommandBlocked(_ command: WatchAppCommand, reason: String) {
+        self.appCommandStatusText = "\(Self.commandLabel(command)): \(reason)"
+        self.persistState()
+    }
+
+    func markAppCommandResult(_ result: WatchReplySendResult, command: WatchAppCommand) {
+        let label = Self.commandLabel(command)
+        if let errorMessage = result.errorMessage, !errorMessage.isEmpty {
+            self.appCommandStatusText = "\(label) failed: \(errorMessage)"
+        } else if result.deliveredImmediately {
+            self.appCommandStatusText = "\(label): sent"
+        } else if result.queuedForDelivery {
+            self.appCommandStatusText = "\(label): queued"
+        } else {
+            self.appCommandStatusText = "\(label): sent"
+        }
+        self.persistState()
+    }
+
+    func consume(execApprovalResolved message: WatchExecApprovalResolvedMessage) {
+        self.removeExecApproval(id: message.approvalId)
+        let statusText = switch message.decision {
+        case .allowOnce:
+            "Allowed once"
+        case .deny:
+            "Denied"
+        case nil:
+            "Approval resolved"
+        }
+        self.lastExecApprovalOutcomeText = statusText
+        self.lastExecApprovalOutcomeAt = Date()
+        self.persistState()
+    }
+
+    func consume(execApprovalExpired message: WatchExecApprovalExpiredMessage) {
+        self.removeExecApproval(id: message.approvalId)
+        let statusText = switch message.reason {
+        case .expired:
+            "Approval expired"
+        case .notFound:
+            "Approval no longer available"
+        case .resolved:
+            "Approval resolved elsewhere"
+        case .replaced:
+            "Approval replaced"
+        case .unavailable:
+            "Approval unavailable"
+        }
+        self.lastExecApprovalOutcomeText = statusText
+        self.lastExecApprovalOutcomeAt = Date()
+        self.persistState()
+    }
+
+    func selectExecApproval(id: String) {
+        let normalizedID = id.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !normalizedID.isEmpty else { return }
+        guard self.execApprovals.contains(where: { $0.id == normalizedID }) else { return }
+        self.selectedExecApprovalID = normalizedID
+        self.persistState()
+    }
+
+    func markExecApprovalSending(approvalId: String, decision: WatchExecApprovalDecision) {
+        guard let index = execApprovals.firstIndex(where: { $0.id == approvalId }) else { return }
+        self.execApprovals[index].isResolving = true
+        self.execApprovals[index].pendingDecision = decision
+        self.execApprovals[index].statusText = "Sending \(Self.decisionLabel(decision))…"
+        self.execApprovals[index].statusAt = Date()
+        self.persistState()
+    }
+
+    func markExecApprovalSendResult(
+        approvalId: String,
+        decision: WatchExecApprovalDecision,
+        result: WatchReplySendResult)
+    {
+        guard let index = execApprovals.firstIndex(where: { $0.id == approvalId }) else { return }
+        if let errorMessage = result.errorMessage, !errorMessage.isEmpty {
+            self.execApprovals[index].isResolving = false
+            self.execApprovals[index].statusText = "Failed: \(errorMessage)"
+        } else if result.deliveredImmediately {
+            self.execApprovals[index].isResolving = true
+            self.execApprovals[index].statusText = "\(Self.decisionLabel(decision)): sent"
+        } else if result.queuedForDelivery {
+            self.execApprovals[index].isResolving = true
+            self.execApprovals[index].statusText = "\(Self.decisionLabel(decision)): queued"
+        } else {
+            self.execApprovals[index].isResolving = true
+            self.execApprovals[index].statusText = "\(Self.decisionLabel(decision)): sent"
+        }
+        self.execApprovals[index].pendingDecision = result.errorMessage == nil ? decision : nil
+        self.execApprovals[index].statusAt = Date()
+        self.persistState()
+    }
+
+    private func upsertExecApproval(
+        _ approval: WatchExecApprovalItem,
+        transport: String,
+        keepSelectionIfPossible: Bool,
+        resetResolvingState: Bool = false)
+    {
+        if let index = execApprovals.firstIndex(where: { $0.id == approval.id }) {
+            self.execApprovals[index] = self.mergedExecApprovalRecord(
+                approval: approval,
+                transport: transport,
+                existingRecord: self.execApprovals[index],
+                resetResolvingState: resetResolvingState)
+        } else {
+            self.execApprovals.append(
+                self.mergedExecApprovalRecord(
+                    approval: approval,
+                    transport: transport,
+                    existingRecord: nil,
+                    resetResolvingState: resetResolvingState))
+        }
+        if !keepSelectionIfPossible || self.selectedExecApprovalID == nil {
+            self.selectedExecApprovalID = approval.id
+        }
+        self.persistState()
+    }
+
+    private func mergedExecApprovalRecord(
+        approval: WatchExecApprovalItem,
+        transport: String,
+        existingRecord: WatchExecApprovalRecord?,
+        resetResolvingState: Bool = false) -> WatchExecApprovalRecord
+    {
+        // Preserve in-flight state across ordinary snapshot/prompt refreshes so duplicate
+        // submissions stay disabled, but clear it when the iPhone explicitly republishes a
+        // prompt after a failed resolve so the watch can retry.
+        let isResolving = resetResolvingState ? false : (existingRecord?.isResolving ?? false)
+        let pendingDecision = resetResolvingState ? nil : existingRecord?.pendingDecision
+        let statusText = resetResolvingState ? nil : existingRecord?.statusText
+        let statusAt = resetResolvingState ? nil : existingRecord?.statusAt
+        return WatchExecApprovalRecord(
+            approval: approval,
+            transport: transport,
+            updatedAt: Date(),
+            isResolving: isResolving,
+            pendingDecision: pendingDecision,
+            statusText: statusText,
+            statusAt: statusAt)
+    }
+
+    private func removeExecApproval(id: String) {
+        let normalizedID = id.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !normalizedID.isEmpty else { return }
+        self.execApprovals.removeAll { $0.id == normalizedID }
+        if self.selectedExecApprovalID == normalizedID {
+            self.selectedExecApprovalID = self.sortedExecApprovals.first?.id
+        }
+        self.persistState()
+    }
+
+    private func pruneExpiredExecApprovals(nowMs: Int) {
+        self.execApprovals.removeAll { record in
+            guard let expiresAtMs = record.approval.expiresAtMs else { return false }
+            return expiresAtMs <= nowMs
+        }
+        if let selectedExecApprovalID,
+           !self.execApprovals.contains(where: { $0.id == selectedExecApprovalID })
+        {
+            self.selectedExecApprovalID = self.sortedExecApprovals.first?.id
+        }
+        self.persistState()
+    }
+
+    private func restorePersistedState() {
+        guard let data = defaults.data(forKey: Self.persistedStateKey),
+              let state = try? JSONDecoder().decode(PersistedState.self, from: data)
+        else {
+            return
+        }
+
+        self.title = state.title
+        self.body = state.body
+        self.transport = state.transport
+        self.updatedAt = state.updatedAt
+        self.lastDeliveryKey = state.lastDeliveryKey
+        self.promptId = state.promptId
+        self.sessionKey = state.sessionKey
+        self.kind = state.kind
+        self.details = state.details
+        self.expiresAtMs = state.expiresAtMs
+        self.risk = state.risk
+        self.actions = state.actions ?? []
+        self.replyStatusText = state.replyStatusText
+        self.replyStatusAt = state.replyStatusAt
+        self.execApprovals = state.execApprovals
+        self.selectedExecApprovalID = state.selectedExecApprovalID
+        self.lastExecApprovalSnapshotID = state.lastExecApprovalSnapshotID
+        self.lastExecApprovalOutcomeText = state.lastExecApprovalOutcomeText
+        self.lastExecApprovalOutcomeAt = state.lastExecApprovalOutcomeAt
+        self.appSnapshot = state.appSnapshot
+        self.appSnapshotUpdatedAt = state.appSnapshotUpdatedAt
+        self.appSnapshotStatusText = state.appSnapshotStatusText
+        self.appCommandStatusText = state.appCommandStatusText
+    }
+
+    private func persistState() {
+        let updatedAt = self.updatedAt ?? self.lastExecApprovalOutcomeAt ?? Date()
+        let state = PersistedState(
+            title: title,
+            body: body,
+            transport: transport,
+            updatedAt: updatedAt,
+            lastDeliveryKey: lastDeliveryKey,
+            promptId: promptId,
+            sessionKey: sessionKey,
+            kind: kind,
+            details: details,
+            expiresAtMs: expiresAtMs,
+            risk: risk,
+            actions: actions,
+            replyStatusText: replyStatusText,
+            replyStatusAt: replyStatusAt,
+            execApprovals: execApprovals,
+            selectedExecApprovalID: selectedExecApprovalID,
+            lastExecApprovalSnapshotID: lastExecApprovalSnapshotID,
+            lastExecApprovalOutcomeText: lastExecApprovalOutcomeText,
+            lastExecApprovalOutcomeAt: lastExecApprovalOutcomeAt,
+            appSnapshot: appSnapshot,
+            appSnapshotUpdatedAt: appSnapshotUpdatedAt,
+            appSnapshotStatusText: appSnapshotStatusText,
+            appCommandStatusText: appCommandStatusText)
+        guard let data = try? JSONEncoder().encode(state) else { return }
+        self.defaults.set(data, forKey: Self.persistedStateKey)
+    }
+
+    private func deliveryKey(messageID: String?, title: String, body: String, sentAtMs: Int?) -> String {
+        if let messageID, messageID.isEmpty == false {
+            return "id:\(messageID)"
+        }
+        return "content:\(title)|\(body)|\(sentAtMs ?? 0)"
+    }
+
+    private func ensureNotificationAuthorization() async {
+        let center = UNUserNotificationCenter.current()
+        let settings = await center.notificationSettings()
+        switch settings.authorizationStatus {
+        case .notDetermined:
+            _ = try? await center.requestAuthorization(options: [.alert, .sound])
+        default:
+            break
+        }
+    }
+
+    private func mapHapticRisk(_ risk: String?) -> WKHapticType {
+        switch risk?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() {
+        case "high":
+            .failure
+        case "medium":
+            .notification
+        default:
+            .click
+        }
+    }
+
+    func makeReplyDraft(action: WatchPromptAction) -> WatchReplyDraft {
+        let prompt = self.promptId?.trimmingCharacters(in: .whitespacesAndNewlines)
+        return WatchReplyDraft(
+            replyId: UUID().uuidString,
+            promptId: (prompt?.isEmpty == false) ? prompt! : "unknown",
+            actionId: action.id,
+            actionLabel: action.label,
+            sessionKey: self.sessionKey,
+            note: nil,
+            sentAtMs: Self.nowMs())
+    }
+
+    func markReplySending(actionLabel: String) {
+        self.isReplySending = true
+        self.replyStatusText = "Sending \(actionLabel)…"
+        self.replyStatusAt = Date()
+        self.persistState()
+    }
+
+    func markReplyResult(_ result: WatchReplySendResult, actionLabel: String) {
+        self.isReplySending = false
+        if let errorMessage = result.errorMessage, !errorMessage.isEmpty {
+            self.replyStatusText = "Failed: \(errorMessage)"
+        } else if result.deliveredImmediately {
+            self.replyStatusText = "\(actionLabel): sent"
+        } else if result.queuedForDelivery {
+            self.replyStatusText = "\(actionLabel): queued"
+        } else {
+            self.replyStatusText = "\(actionLabel): sent"
+        }
+        self.replyStatusAt = Date()
+        self.persistState()
+    }
+
+    private func postLocalNotification(identifier: String, title: String, body: String, risk: String?) async {
+        let content = UNMutableNotificationContent()
+        content.title = title
+        content.body = body
+        content.sound = .default
+        content.threadIdentifier = "openclaw-watch"
+
+        let request = UNNotificationRequest(
+            identifier: identifier,
+            content: content,
+            trigger: UNTimeIntervalNotificationTrigger(timeInterval: 0.2, repeats: false))
+
+        _ = try? await UNUserNotificationCenter.current().add(request)
+        WKInterfaceDevice.current().play(self.mapHapticRisk(risk))
+    }
+
+    private static func decisionLabel(_ decision: WatchExecApprovalDecision) -> String {
+        switch decision {
+        case .allowOnce:
+            "Allow Once"
+        case .deny:
+            "Deny"
+        }
+    }
+
+    private static func commandLabel(_ command: WatchAppCommand) -> String {
+        switch command {
+        case .refresh:
+            "Refresh"
+        case .openChat:
+            "Open Chat"
+        case .sendChat:
+            "Chat"
+        case .startTalk:
+            "Start Talk"
+        case .stopTalk:
+            "Stop Talk"
+        }
+    }
+
+    private static func nowMs() -> Int {
+        Int(Date().timeIntervalSince1970 * 1000)
+    }
+}