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/Tests/RootTabsPresentationTests.swift

@@ -0,0 +1,540 @@
+import SwiftUI
+import Testing
+import UIKit
+@testable import OpenClaw
+
+@MainActor
+struct RootTabsPresentationTests {
+    @Test func `quick setup does not present when gateway already configured`() {
+        let shouldPresent = RootTabs.shouldPresentQuickSetup(
+            quickSetupDismissed: false,
+            showOnboarding: false,
+            hasPresentedSheet: false,
+            gatewayConnected: false,
+            hasExistingGatewayConfig: true,
+            discoveredGatewayCount: 1)
+
+        #expect(!shouldPresent)
+    }
+
+    @Test func `quick setup presents for fresh install with discovered gateway`() {
+        let shouldPresent = RootTabs.shouldPresentQuickSetup(
+            quickSetupDismissed: false,
+            showOnboarding: false,
+            hasPresentedSheet: false,
+            gatewayConnected: false,
+            hasExistingGatewayConfig: false,
+            discoveredGatewayCount: 1)
+
+        #expect(shouldPresent)
+    }
+
+    @Test func `quick setup does not present when already connected`() {
+        let shouldPresent = RootTabs.shouldPresentQuickSetup(
+            quickSetupDismissed: false,
+            showOnboarding: false,
+            hasPresentedSheet: false,
+            gatewayConnected: true,
+            hasExistingGatewayConfig: false,
+            discoveredGatewayCount: 1)
+
+        #expect(!shouldPresent)
+    }
+
+    @Test func `sidebar tabs enabled for I pad regular width`() {
+        #expect(
+            RootTabs.shouldUseSidebarTabs(
+                idiom: .pad,
+                horizontalSizeClass: .regular))
+    }
+
+    @Test func `sidebar tabs enabled for I pad compact width`() {
+        #expect(
+            RootTabs.shouldUseSidebarTabs(
+                idiom: .pad,
+                horizontalSizeClass: .compact))
+    }
+
+    @Test func `sidebar tabs disabled for I phone`() {
+        #expect(
+            !RootTabs.shouldUseSidebarTabs(
+                idiom: .phone,
+                horizontalSizeClass: .regular))
+    }
+
+    @Test func `sidebar groups match adaptive navigation model`() {
+        let groups = RootTabs.sidebarGroups
+        let destinationIDs = RootTabs.SidebarDestination.allCases.map(\.rawValue)
+
+        #expect(groups.map(\.title) == ["CHAT", "CONTROL", "SETTINGS", "REFERENCE"])
+        #expect(groups[0].destinations.map(\.rawValue) == ["chat", "talk"])
+        #expect(groups[1].destinations == [
+            .overview,
+            .activity,
+            .agents,
+            .workboard,
+            .skillWorkshop,
+            .instances,
+            .sessions,
+            .dreaming,
+            .usage,
+            .cron,
+            .terminal,
+        ])
+        #expect(groups[2].destinations == [.settings])
+        #expect(groups[3].destinations == [.docs])
+        #expect(destinationIDs == [
+            "chat",
+            "talk",
+            "overview",
+            "activity",
+            "agents",
+            "workboard",
+            "skillWorkshop",
+            "instances",
+            "sessions",
+            "dreaming",
+            "usage",
+            "cron",
+            "terminal",
+            "docs",
+            "settings",
+            "gateway",
+        ])
+        #expect(!destinationIDs.contains("agent"))
+        #expect(!RootTabs.sidebarGroups.flatMap(\.destinations).contains(.gateway))
+    }
+
+    @Test func `phone control groups avoid duplicating the agent tab`() {
+        let groups = RootTabs.phoneControlGroups
+        let destinations = groups.flatMap(\.destinations)
+
+        #expect(groups.map(\.title) == ["CHAT", "CONTROL", "SETTINGS", "REFERENCE"])
+        #expect(!destinations.contains(.agents))
+        #expect(RootTabs.sidebarGroups.flatMap(\.destinations).contains(.agents))
+        #expect(destinations.contains(.dreaming))
+        #expect(destinations.contains(.instances))
+    }
+
+    @Test func `sidebar uses compact labels for long routes`() {
+        #expect(RootTabs.SidebarDestination.settings.title == "Settings")
+        #expect(RootTabs.SidebarDestination.gateway.title == "Settings / Gateway")
+        #expect(RootTabs.SidebarDestination.gateway.sidebarTitle == "Connection")
+    }
+
+    @Test func `phone hub uses root tabs only for native chat agent and gateway`() {
+        #expect(RootTabs.shouldOpenRootTabFromPhoneHub(.chat))
+        #expect(RootTabs.shouldOpenRootTabFromPhoneHub(.talk))
+        #expect(RootTabs.shouldOpenRootTabFromPhoneHub(.agents))
+        #expect(RootTabs.shouldOpenRootTabFromPhoneHub(.gateway))
+        #expect(RootTabs.shouldOpenRootTabFromPhoneHub(.settings))
+
+        for destination in RootTabs.SidebarDestination.allCases
+            where destination != .chat && destination != .talk && destination != .agents && destination != .gateway &&
+            destination != .settings
+        {
+            #expect(!RootTabs.shouldOpenRootTabFromPhoneHub(destination))
+        }
+    }
+
+    @Test func `app launch defaults to chat tab`() {
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw"]) == .chat)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-tab"]) == .chat)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-tab", "unknown"]) == .chat)
+    }
+
+    @Test func `app launch uses requested destination before chat fallback`() {
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-destination", "overview"]) == .control)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-destination", "chat"]) == .chat)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-destination", "agents"]) == .agent)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-destination", "gateway"]) == .settings)
+        #expect(
+            RootTabs.initialTab(arguments: [
+                "OpenClaw",
+                "--openclaw-initial-tab",
+                "unknown",
+                "--openclaw-initial-destination",
+                "activity",
+            ]) == .control)
+    }
+
+    @Test func `app launch respects explicit initial tab override`() {
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-tab", "control"]) == .control)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-tab", "overview"]) == .control)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-tab", "chat"]) == .chat)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-tab", "voice"]) == .talk)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-tab", "agents"]) == .agent)
+        #expect(RootTabs.initialTab(arguments: ["OpenClaw", "--openclaw-initial-tab", "settings"]) == .settings)
+    }
+
+    @Test func `legacy initial tabs map to matching sidebar destinations`() {
+        #expect(RootTabs.defaultSidebarDestination(for: .control) == .overview)
+        #expect(RootTabs.defaultSidebarDestination(for: .chat) == .chat)
+        #expect(RootTabs.defaultSidebarDestination(for: .talk) == .talk)
+        #expect(RootTabs.defaultSidebarDestination(for: .agent) == .agents)
+        #expect(RootTabs.defaultSidebarDestination(for: .settings) == .settings)
+    }
+
+    @Test func `skill workshop mutations require admin scope`() {
+        #expect(IPadSkillWorkshopScreen.shouldEnableProposalMutation(canWrite: true, hasOperatorAdminScope: true))
+        #expect(!IPadSkillWorkshopScreen.shouldEnableProposalMutation(canWrite: true, hasOperatorAdminScope: false))
+        #expect(!IPadSkillWorkshopScreen.shouldEnableProposalMutation(canWrite: false, hasOperatorAdminScope: true))
+    }
+
+    @Test func `skill workshop held filter includes quarantined and stale`() {
+        #expect(IPadSkillWorkshopScreen.proposalStatusFilters.contains("held"))
+        #expect(IPadSkillWorkshopScreen.proposalStatusMatchesFilter(status: "quarantined", filter: "held"))
+        #expect(IPadSkillWorkshopScreen.proposalStatusMatchesFilter(status: "stale", filter: "held"))
+        #expect(!IPadSkillWorkshopScreen.proposalStatusMatchesFilter(status: "pending", filter: "held"))
+    }
+
+    @Test func `skill workshop board lanes match status filter`() {
+        #expect(
+            IPadSkillWorkshopScreen.proposalStatusBoardLanes(
+                filter: "pending",
+                proposalStatuses: ["pending", "applied"]) == ["pending"])
+        #expect(
+            IPadSkillWorkshopScreen.proposalStatusBoardLanes(
+                filter: "held",
+                proposalStatuses: ["quarantined", "stale"]) == ["quarantined", "stale"])
+        #expect(
+            IPadSkillWorkshopScreen.proposalStatusBoardLanes(
+                filter: "all",
+                proposalStatuses: ["pending", "needs-review"]) == [
+                "pending",
+                "quarantined",
+                "stale",
+                "applied",
+                "rejected",
+                "needs-review",
+            ])
+        #expect(IPadSkillWorkshopScreen.proposalLaneLabel("quarantined") == "Quarantined")
+        #expect(IPadSkillWorkshopScreen.proposalLaneLabel("pending") == "Pending")
+        #expect(IPadSkillWorkshopScreen.proposalLaneLabel("needs-review") == "Needs Review")
+        #expect(IPadSkillWorkshopScreen.proposalLaneLabel("manual_QA") == "Manual QA")
+    }
+
+    @Test func `skill workshop selection stays inside active filter`() {
+        let proposals = [
+            (id: "applied-1", status: "applied"),
+            (id: "pending-1", status: "pending"),
+            (id: "held-1", status: "quarantined"),
+        ]
+
+        #expect(
+            IPadSkillWorkshopScreen.nextSelectedProposalID(
+                current: "applied-1",
+                proposals: proposals,
+                filter: "pending") == "pending-1")
+        #expect(
+            IPadSkillWorkshopScreen.nextSelectedProposalID(
+                current: "held-1",
+                proposals: proposals,
+                filter: "held") == "held-1")
+        #expect(
+            IPadSkillWorkshopScreen.nextSelectedProposalID(
+                current: "pending-1",
+                visibleProposalIDs: ["held-1"]) == "held-1")
+        #expect(
+            IPadSkillWorkshopScreen.nextSelectedProposalID(
+                current: "pending-1",
+                visibleProposalIDs: []) == nil)
+    }
+
+    @Test func `workboard board scope labels stay compact`() {
+        #expect(IPadWorkboardScreen.normalizedScopeID("  planning ") == "planning")
+        #expect(IPadWorkboardScreen.boardScopeLabel(for: "") == "All boards")
+        #expect(IPadWorkboardScreen.boardScopeLabel(for: "planning") == "planning")
+        #expect(IPadWorkboardScreen.boardScopeOptions(
+            knownBoardIDs: ["default", " empty-board ", ""],
+            cardBoardIDs: ["planning", "default"]) == ["default", "empty-board", "planning"])
+        #expect(IPadWorkboardScreen
+            .workboardSubtitle(boardScopeLabel: "All boards", selectedStatus: "active") == "All boards / Active")
+        #expect(IPadWorkboardScreen
+            .workboardSubtitle(boardScopeLabel: "planning", selectedStatus: "running") == "planning / Running")
+    }
+
+    @Test func `workboard compact unavailable copy explains real capability state`() {
+        #expect(IPadWorkboardScreen
+            .compactWriteUnavailableMessage(canRead: false) ==
+            "Connect from Settings to create, move, and dispatch cards.")
+        #expect(IPadWorkboardScreen.compactWriteUnavailableMessage(canRead: true) == "Read-only gateway.")
+    }
+
+    @Test func `skill workshop agent scope normalizes gateway ids`() {
+        #expect(IPadSkillWorkshopScreen.normalizedScopeID("  aiden ") == "aiden")
+        #expect(IPadSkillWorkshopScreen.normalizedScopeID(nil) == "")
+    }
+
+    @Test func `channel lifecycle controls require admin scope`() {
+        #expect(SettingsChannelsDestination.shouldEnableChannelOperation(canRead: true, hasOperatorAdminScope: true))
+        #expect(!SettingsChannelsDestination.shouldEnableChannelOperation(canRead: true, hasOperatorAdminScope: false))
+        #expect(!SettingsChannelsDestination.shouldEnableChannelOperation(canRead: false, hasOperatorAdminScope: true))
+    }
+
+    @Test func `click clack stays in channels integration metadata`() {
+        #expect(SettingsChannelsDestination.fallbackLabel("clickclack") == "ClickClack")
+        #expect(SettingsChannelsDestination.fallbackDetail("clickclack") == "Self-hosted chat bot routing.")
+        #expect(SettingsChannelsDestination.fallbackSystemImage("clickclack") == "bubble.left.and.bubble.right")
+    }
+
+    @Test func `i pad overview can suppress standalone header branding`() {
+        #expect(CommandCenterTab.shouldShowHeaderMark(hasLeadingAction: false, showsHeaderMark: true))
+        #expect(!CommandCenterTab.shouldShowHeaderMark(hasLeadingAction: true, showsHeaderMark: true))
+        #expect(!CommandCenterTab.shouldShowHeaderMark(hasLeadingAction: false, showsHeaderMark: false))
+    }
+
+    @Test func `command center can use parent navigation stack for embedded routes`() {
+        let standalone = CommandCenterTab(openChat: {}, openSettings: {})
+        let embedded = CommandCenterTab(
+            ownsNavigationStack: false,
+            openChat: {},
+            openSettings: {})
+        let native = CommandCenterTab(
+            ownsNavigationStack: false,
+            usesNativeNavigationChrome: true,
+            openChat: {},
+            openSettings: {})
+        let shellRouted = CommandCenterTab(
+            ownsNavigationStack: false,
+            openChat: {},
+            openSettings: {},
+            openSessions: {})
+
+        #expect(standalone.ownsNavigationStack)
+        #expect(standalone.openSessions == nil)
+        #expect(!embedded.ownsNavigationStack)
+        #expect(!embedded.usesNativeNavigationChrome)
+        #expect(embedded.openSessions == nil)
+        #expect(native.usesNativeNavigationChrome)
+        #expect(shellRouted.openSessions != nil)
+    }
+
+    @Test func `chat sidebar destination can use native route title instead of agent branding`() {
+        let standalone = ChatProTab()
+        let routed = ChatProTab(
+            headerTitle: "Chat",
+            showsAgentBadge: false,
+            ownsNavigationStack: false,
+            openSettings: {})
+
+        #expect(standalone.showsAgentBadge)
+        #expect(standalone.ownsNavigationStack)
+        #expect(standalone.headerTitle == nil)
+        #expect(standalone.openSettings == nil)
+        #expect(routed.headerTitle == "Chat")
+        #expect(!routed.showsAgentBadge)
+        #expect(!routed.ownsNavigationStack)
+        #expect(routed.openSettings != nil)
+        #expect(ChatProTab.defaultHeaderTitle(showsAgentBadge: true, agentDisplayName: "OpenClaw") == "OpenClaw")
+        #expect(ChatProTab.defaultHeaderTitle(showsAgentBadge: false, agentDisplayName: "OpenClaw") == "Chat")
+    }
+
+    @Test func `agent routes can open gateway settings from header pill`() {
+        let standalone = AgentProTab()
+        let routed = AgentProTab(
+            directRoute: .instances,
+            headerTitle: "Instances",
+            openSettings: {})
+
+        #expect(standalone.headerTitle == "Agents")
+        #expect(standalone.directRoute == nil)
+        #expect(standalone.openSettings == nil)
+        #expect(AgentProTab(directRoute: .agents).directRoute == .agents)
+        #expect(routed.directRoute == .instances)
+        #expect(routed.headerTitle == "Instances")
+        #expect(routed.openSettings != nil)
+    }
+
+    @Test func `workboard dispatch summary reports started and failures`() throws {
+        let payload = Data(
+            """
+            {
+              "count": 2,
+              "started": [{}],
+              "startFailures": [{}],
+              "promoted": [],
+              "reclaimed": [],
+              "blocked": [],
+              "orchestrated": []
+            }
+            """.utf8)
+        let summary = try JSONDecoder().decode(IPadWorkboardDispatchSummary.self, from: payload)
+
+        #expect(summary.summaryText == "2 dispatched: 1 started, 1 failed.")
+    }
+
+    @Test func `talk sidebar destination can receive reveal action`() {
+        let action = OpenClawSidebarHeaderAction(
+            systemName: "sidebar.left",
+            accessibilityLabel: "Show Sidebar",
+            action: {})
+        let routed = TalkProTab(headerLeadingAction: action, openSettings: {})
+        let embedded = TalkProTab(
+            headerLeadingAction: action,
+            ownsNavigationStack: false,
+            openSettings: {})
+
+        #expect(routed.headerLeadingAction?.systemName == "sidebar.left")
+        #expect(routed.headerLeadingAction?.accessibilityLabel == "Show Sidebar")
+        #expect(routed.ownsNavigationStack)
+        #expect(!embedded.ownsNavigationStack)
+    }
+
+    @Test func `settings can use parent navigation stack for sidebar routes`() {
+        let standalone = SettingsProTab()
+        let embedded = SettingsProTab(ownsNavigationStack: false)
+
+        #expect(standalone.ownsNavigationStack)
+        #expect(!embedded.ownsNavigationStack)
+    }
+
+    @Test func `i pad portrait uses hidden drawer sidebar`() {
+        let mode = RootTabs.sidebarLayoutMode(containerSize: CGSize(width: 1024, height: 1366))
+
+        #expect(mode == .drawer)
+        #expect(!RootTabs.preferredSidebarVisibility(layoutMode: mode))
+    }
+
+    @Test func `i pad wide landscape uses visible split sidebar`() {
+        let mode = RootTabs.sidebarLayoutMode(containerSize: CGSize(width: 1366, height: 1024))
+
+        #expect(mode == .split)
+        #expect(RootTabs.preferredSidebarVisibility(layoutMode: mode))
+    }
+
+    @Test func `i pad split sidebar width stays usable`() {
+        let width = RootTabs.sidebarWidth(containerWidth: 1366, isDrawerLayout: false)
+
+        #expect(width >= RootTabs.sidebarSplitIdealWidth)
+        #expect(width <= RootTabs.sidebarSplitMaximumWidth)
+    }
+
+    @Test func `i pad collapsed split sidebar uses header reveal without reserved rail`() {
+        #expect(
+            RootTabs.shouldShowSidebarRevealInDestinationHeader(
+                isSidebarVisible: false,
+                layoutMode: .split))
+        #expect(
+            RootTabs.shouldShowSidebarRevealInDestinationHeader(
+                isSidebarVisible: true,
+                layoutMode: .split))
+        #expect(
+            RootTabs.shouldShowSidebarRevealInDestinationHeader(
+                isSidebarVisible: false,
+                layoutMode: .drawer))
+        #expect(
+            !RootTabs.shouldShowSidebarRevealInDestinationHeader(
+                isSidebarVisible: true,
+                layoutMode: .drawer))
+    }
+
+    @Test func `initial sidebar visibility parses launch argument`() {
+        #expect(
+            RootTabs.requestedInitialSidebarVisibility(arguments: [
+                "OpenClaw",
+                "--openclaw-sidebar-visibility",
+                "hidden",
+            ]) == false)
+        #expect(
+            RootTabs.requestedInitialSidebarVisibility(arguments: [
+                "OpenClaw",
+                "--openclaw-sidebar-visibility",
+                "visible",
+            ]) == true)
+        #expect(
+            RootTabs.requestedInitialSidebarVisibility(arguments: [
+                "OpenClaw",
+                "--openclaw-sidebar-visibility",
+                "unknown",
+            ]) == nil)
+    }
+
+    @Test func `sidebar controls have stable accessibility identifiers`() {
+        #expect(RootTabs.sidebarShowButtonAccessibilityIdentifier == "RootTabs.Sidebar.Show")
+        #expect(RootTabs.sidebarHideButtonAccessibilityIdentifier == "RootTabs.Sidebar.Hide")
+    }
+
+    @Test func `i pad drawer sidebar width stays inside screen`() {
+        let width = RootTabs.sidebarWidth(containerWidth: 744, isDrawerLayout: true)
+
+        #expect(width >= 280)
+        #expect(width <= RootTabs.sidebarDrawerMaximumWidth)
+    }
+
+    @Test func `narrow landscape keeps drawer sidebar`() {
+        let mode = RootTabs.sidebarLayoutMode(containerSize: CGSize(width: 900, height: 600))
+
+        #expect(mode == .drawer)
+        #expect(!RootTabs.preferredSidebarVisibility(layoutMode: mode))
+    }
+
+    @Test func `drawer selection collapses sidebar but split selection does not`() {
+        #expect(RootTabs.shouldCollapseSidebarAfterSelection(layoutMode: .drawer))
+        #expect(!RootTabs.shouldCollapseSidebarAfterSelection(layoutMode: .split))
+    }
+
+    @Test func `hidden sidebar shows reveal control`() {
+        #expect(RootTabs.shouldShowSidebarRevealControl(isSidebarVisible: false))
+    }
+
+    @Test func `sidebar reveal controls hide when sidebar is visible`() {
+        #expect(!RootTabs.shouldShowSidebarRevealControl(isSidebarVisible: true))
+    }
+
+    @Test func `i pad split prefers integrated visible sidebar`() {
+        #expect(RootTabs.preferredSidebarVisibility(layoutMode: .split))
+        #expect(!RootTabs.shouldCollapseSidebarAfterSelection(layoutMode: .split))
+        #expect(!RootTabs.preferredSidebarVisibility(layoutMode: .drawer))
+        #expect(RootTabs.shouldCollapseSidebarAfterSelection(layoutMode: .drawer))
+    }
+
+    @Test func `destination headers own hidden sidebar reveal control`() {
+        #expect(
+            RootTabs.shouldShowSidebarRevealInDestinationHeader(
+                isSidebarVisible: false,
+                layoutMode: .drawer))
+        #expect(
+            RootTabs.shouldShowSidebarRevealInDestinationHeader(
+                isSidebarVisible: false,
+                layoutMode: .split))
+        #expect(
+            !RootTabs.shouldShowSidebarRevealInDestinationHeader(
+                isSidebarVisible: true,
+                layoutMode: .drawer))
+        #expect(
+            RootTabs.shouldShowSidebarRevealInDestinationHeader(
+                isSidebarVisible: true,
+                layoutMode: .split))
+    }
+
+    @Test func `workboard and skill workshop use compact task flow on phone sizes`() {
+        #expect(
+            IPadWorkboardScreen.usesCompactTaskFlow(
+                horizontalSizeClass: .compact,
+                verticalSizeClass: .regular))
+        #expect(
+            IPadSkillWorkshopScreen.usesCompactTaskFlow(
+                horizontalSizeClass: .compact,
+                verticalSizeClass: .regular))
+        #expect(
+            IPadWorkboardScreen.usesCompactTaskFlow(
+                horizontalSizeClass: .regular,
+                verticalSizeClass: .compact))
+        #expect(
+            IPadSkillWorkshopScreen.usesCompactTaskFlow(
+                horizontalSizeClass: .regular,
+                verticalSizeClass: .compact))
+    }
+
+    @Test func `workboard and skill workshop keep regular task flow on wide I pad sizes`() {
+        #expect(
+            !IPadWorkboardScreen.usesCompactTaskFlow(
+                horizontalSizeClass: .regular,
+                verticalSizeClass: .regular))
+        #expect(
+            !IPadSkillWorkshopScreen.usesCompactTaskFlow(
+                horizontalSizeClass: .regular,
+                verticalSizeClass: .regular))
+    }
+}