From ab1488d2179aa18a80f56625d5051cda9f43282f Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 12 Sep 2026 15:59:18 +1000
Subject: [PATCH 01/10] feat(swift-ios): add Move up/down context-menu thread
 reordering

The native client had no way to rearrange the thread list even though
servers already support the fractional order-key protocol used by web
drag and React Native mobile's Move up / Move down. Add both menu
actions on pinned and active rows, planned against the canonical
section across environments and written through thread.pin.reorder /
thread.active.reorder, capability-gated and disabled at section edges.
Pinning now also takes the top of the arranged run when the server
supports it.

Generated with Devin (swe-2-high, T3 Code/Cursor harness)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 apps/swift-ios/App/NativeFeatureClient.swift  | 113 +++++-
 apps/swift-ios/Core/Models.swift              |   9 +
 apps/swift-ios/Core/T3Client.swift            |  83 +++-
 .../Features/Root/FeatureRootModel.swift      |  25 ++
 .../Features/Shared/FeatureClient.swift       |  12 +
 .../Features/Shared/FeatureModels.swift       |  33 ++
 .../Features/Workspace/DailyUXModels.swift    | 111 ++++--
 .../Workspace/HomeThreadCollectionView.swift  |  24 ++
 .../Workspace/ThreadOrderPlanner.swift        | 199 ++++++++++
 .../Features/Workspace/WorkspaceView.swift    |   6 +
 .../Tests/CoreTests/CoreContractTests.swift   |  50 +++
 .../NativeContractExpansionTests.swift        |  74 ++++
 .../HomeThreadSwipeActionTests.swift          |   2 +
 .../ThreadOrderPlannerTests.swift             | 374 ++++++++++++++++++
 14 files changed, 1070 insertions(+), 45 deletions(-)
 create mode 100644 apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift
 create mode 100644 apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift

diff --git a/apps/swift-ios/App/NativeFeatureClient.swift b/apps/swift-ios/App/NativeFeatureClient.swift
index 91277dec5e02..6585ebfd8dee 100644
--- a/apps/swift-ios/App/NativeFeatureClient.swift
+++ b/apps/swift-ios/App/NativeFeatureClient.swift
@@ -82,6 +82,9 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
     private var latestServerConfig: ServerConfigSnapshot?
     private var serverConfigsByEnvironmentID: [String: ServerConfigSnapshot] = [:]
     private var latestSnapshot: FeatureSnapshot?
+    /// One reorder at a time: a second move planned from the same keys would
+    /// land a conflicting write (React Native holds a pending order for this).
+    private var threadMoveInFlight = false
     private var activeThreadID: String?
     private var activeThreadEnvironmentID: String?
     private var latestDetails: [String: FeatureThreadDetail] = [:]
@@ -1687,10 +1690,90 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
 
     func setThreadPinned(id: String, pinned: Bool) async throws {
         let route = try threadRoute(for: id)
-        _ = try await route.client.pin(threadID: route.wireID, pinned: pinned)
+        // Same placement as web and React Native: a fresh pin takes the top of
+        // the arranged run. Servers that predate reordering get the bare pin
+        // (keyless, sorted by creation order below keyed threads).
+        var orderKey: String? = nil
+        if pinned, cachedThread(id: route.uiID)?.supportsPinReorder == true {
+            let firstKey = latestSnapshot?.threads
+                .filter { $0.pinnedAt != nil }
+                .compactMap(\.pinOrderKey)
+                .min()
+            orderKey = ThreadOrderPlanner.orderKeyBetween(before: nil, after: firstKey)
+        }
+        _ = try await route.client.pin(threadID: route.wireID, pinned: pinned, orderKey: orderKey)
         try? await refresh(client: route.client)
     }
 
+    /// Executes a Move up / Move down from the thread context menu. Plans the
+    /// move against the canonical ordered section across every connected
+    /// environment (a spread rewrite can write keys on neighbors hosted by
+    /// other servers), then refreshes each environment it touched. Returns the
+    /// assignments the server confirmed so the caller can patch local state if
+    /// a refresh fell behind.
+    @discardableResult
+    func moveThread(
+        id: String,
+        direction: FeatureThreadMoveDirection
+    ) async throws -> [FeatureThreadOrderAssignment] {
+        guard !threadMoveInFlight else { return [] }
+        guard let snapshot = latestSnapshot,
+              let thread = snapshot.threads.first(where: { $0.id == id }) else {
+            throw NativeFeatureClientError.threadNotFound
+        }
+        let section: FeatureThreadOrderSection = thread.pinnedAt != nil ? .pinned : .active
+        let planner = ThreadOrderPlanner.movePlanner(
+            ordered: DailyUXSidebarIndex.orderedSection(
+                snapshot.threads,
+                section: section,
+                now: .now
+            ),
+            all: snapshot.threads,
+            section: section
+        )
+        guard let assignments = planner(thread, direction), !assignments.isEmpty else {
+            return []
+        }
+
+        threadMoveInFlight = true
+        defer { threadMoveInFlight = false }
+
+        var confirmed: [FeatureThreadOrderAssignment] = []
+        var touchedEnvironmentIDs = Set<String>()
+        var firstError: Error?
+        for assignment in assignments {
+            do {
+                let route = try threadRoute(for: assignment.threadID)
+                switch section {
+                case .pinned:
+                    _ = try await route.client.reorderPinnedThread(
+                        threadID: route.wireID,
+                        orderKey: assignment.orderKey
+                    )
+                case .active:
+                    _ = try await route.client.reorderActiveThread(
+                        threadID: route.wireID,
+                        orderKey: assignment.orderKey
+                    )
+                }
+                confirmed.append(assignment)
+                touchedEnvironmentIDs.insert(route.environmentID)
+            } catch {
+                // Confirmed writes stand: a later environment rejecting its
+                // write leaves the earlier arrangement in place.
+                firstError = error
+                break
+            }
+        }
+        for environmentID in touchedEnvironmentIDs {
+            if let client = environmentClients[environmentID] {
+                try? await refresh(client: client)
+            }
+        }
+        if let firstError { throw firstError }
+        return confirmed
+    }
+
     func setRuntimeMode(id: String, mode: FeatureRuntimeMode) async throws {
         let route = try threadRoute(for: id)
         _ = try await route.client.setRuntimeMode(
@@ -5215,6 +5298,8 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
             supportsSettlement: capabilities?.threadSettlement,
             supportsSnooze: capabilities?.threadSnooze,
             supportsPinning: capabilities?.threadPinning,
+            supportsPinReorder: capabilities?.threadPinReorder,
+            supportsActiveReorder: capabilities?.threadActiveReorder,
             supportsTitleRegeneration: capabilities?.threadTitleRegeneration,
             supportsPullRequestLinking: capabilities?.threadPullRequestLinking,
             isRegeneratingTitle: thread.titleRegeneration != nil,
@@ -5302,6 +5387,8 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
             supportsSettlement: capabilities?.threadSettlement,
             supportsSnooze: capabilities?.threadSnooze,
             supportsPinning: capabilities?.threadPinning,
+            supportsPinReorder: capabilities?.threadPinReorder,
+            supportsActiveReorder: capabilities?.threadActiveReorder,
             supportsTitleRegeneration: capabilities?.threadTitleRegeneration,
             supportsPullRequestLinking: capabilities?.threadPullRequestLinking,
             isRegeneratingTitle: thread.titleRegeneration != nil,
@@ -5611,6 +5698,7 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
             snoozedUntil: loaded.snoozedUntil,
             snoozedAt: loaded.snoozedAt,
             pinnedAt: loaded.pinnedAt,
+            pinOrderKey: loaded.pinOrderKey,
             titleRegeneration: loaded.titleRegeneration,
             deletedAt: loaded.deletedAt,
             messages: prependByID(older.messages, loaded.messages),
@@ -7133,6 +7221,12 @@ enum NativeThreadDetailReducer {
             result = reduceUnsettled(payload: payload, thread: thread)
         case "thread.meta-updated":
             result = reduceMetadata(payload: payload, occurredAt: occurredAt, thread: thread)
+        case "thread.pin-reordered":
+            result = reducePinReordered(
+                payload: payload,
+                occurredAt: occurredAt,
+                thread: thread
+            )
         case "thread.message-sent":
             result = reduceMessage(
                 payload: payload,
@@ -7267,6 +7361,23 @@ enum NativeThreadDetailReducer {
         return .updated(updated)
     }
 
+    private static func reducePinReordered(
+        payload: JSONValue,
+        occurredAt: String,
+        thread: OrchestrationThread
+    ) -> NativeThreadDetailReductionResult {
+        guard let orderKey = payload["orderKey"]?.stringValue,
+              !orderKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            return .refresh
+        }
+        var updated = replacing(
+            thread,
+            updatedAt: payload["updatedAt"]?.stringValue ?? occurredAt
+        )
+        updated.pinOrderKey = orderKey
+        return .updated(updated)
+    }
+
     private static func reduceMessage(
         payload: JSONValue,
         occurredAt: String,
diff --git a/apps/swift-ios/Core/Models.swift b/apps/swift-ios/Core/Models.swift
index 6244809db5da..8b7e943fbffe 100644
--- a/apps/swift-ios/Core/Models.swift
+++ b/apps/swift-ios/Core/Models.swift
@@ -112,6 +112,8 @@ public struct EnvironmentDescriptor: Codable, Equatable, Sendable {
         public var threadRestartContinuation: Bool? = nil
         public let threadSnooze: Bool?
         public let threadPinning: Bool?
+        public let threadPinReorder: Bool?
+        public let threadActiveReorder: Bool?
         public let threadTitleRegeneration: Bool?
         public let threadPullRequestLinking: Bool?
         public let serverSelfUpdate: String?
@@ -131,6 +133,8 @@ public struct EnvironmentDescriptor: Codable, Equatable, Sendable {
             case threadRestartContinuation
             case threadSnooze
             case threadPinning
+            case threadPinReorder
+            case threadActiveReorder
             case threadTitleRegeneration
             case threadPullRequestLinking
             case serverSelfUpdate
@@ -165,6 +169,11 @@ public struct EnvironmentDescriptor: Codable, Equatable, Sendable {
             )
             threadSnooze = try container.decodeIfPresent(Bool.self, forKey: .threadSnooze)
             threadPinning = try container.decodeIfPresent(Bool.self, forKey: .threadPinning)
+            threadPinReorder = try container.decodeIfPresent(Bool.self, forKey: .threadPinReorder)
+            threadActiveReorder = try container.decodeIfPresent(
+                Bool.self,
+                forKey: .threadActiveReorder
+            )
             threadTitleRegeneration = try container.decodeIfPresent(
                 Bool.self,
                 forKey: .threadTitleRegeneration
diff --git a/apps/swift-ios/Core/T3Client.swift b/apps/swift-ios/Core/T3Client.swift
index f1a8c55340b8..f4314464b3d7 100644
--- a/apps/swift-ios/Core/T3Client.swift
+++ b/apps/swift-ios/Core/T3Client.swift
@@ -873,8 +873,34 @@ public actor T3Client {
     }
 
     @discardableResult
-    public func pin(threadID: String, pinned: Bool) async throws -> DispatchResult {
-        try await dispatch(OrchestrationCommands.pin(threadID: threadID, pinned: pinned))
+    public func pin(
+        threadID: String,
+        pinned: Bool,
+        orderKey: String? = nil
+    ) async throws -> DispatchResult {
+        try await dispatch(
+            OrchestrationCommands.pin(threadID: threadID, pinned: pinned, orderKey: orderKey)
+        )
+    }
+
+    @discardableResult
+    public func reorderPinnedThread(
+        threadID: String,
+        orderKey: String
+    ) async throws -> DispatchResult {
+        try await dispatch(
+            OrchestrationCommands.reorderPinned(threadID: threadID, orderKey: orderKey)
+        )
+    }
+
+    @discardableResult
+    public func reorderActiveThread(
+        threadID: String,
+        orderKey: String
+    ) async throws -> DispatchResult {
+        try await dispatch(
+            OrchestrationCommands.reorderActive(threadID: threadID, orderKey: orderKey)
+        )
     }
 
     @discardableResult
@@ -2278,13 +2304,56 @@ public enum OrchestrationCommands {
     public static func pin(
         threadID: String,
         pinned: Bool,
+        orderKey: String? = nil,
         commandID: String = UUID().uuidString
     ) -> JSONValue {
-        basic(
-            type: pinned ? "thread.pin" : "thread.unpin",
-            threadID: threadID,
-            commandID: commandID
-        )
+        guard pinned, let orderKey else {
+            return basic(
+                type: pinned ? "thread.pin" : "thread.unpin",
+                threadID: threadID,
+                commandID: commandID
+            )
+        }
+        return .object([
+            "type": .string("thread.pin"),
+            "commandId": .string(commandID),
+            "threadId": .string(threadID),
+            "orderKey": .string(orderKey),
+        ])
+    }
+
+    /// Fractional-index reorder: pinned threads sort by `pinOrderKey`, so a
+    /// move writes one key on one thread (see `thread.pin.reorder` in
+    /// packages/contracts). `thread.active.reorder` does the same for the
+    /// active section's `activeOrderKey`.
+    public static func reorderPinned(
+        threadID: String,
+        orderKey: String,
+        commandID: String = UUID().uuidString
+    ) -> JSONValue {
+        reorder(type: "thread.pin.reorder", threadID: threadID, orderKey: orderKey, commandID: commandID)
+    }
+
+    public static func reorderActive(
+        threadID: String,
+        orderKey: String,
+        commandID: String = UUID().uuidString
+    ) -> JSONValue {
+        reorder(type: "thread.active.reorder", threadID: threadID, orderKey: orderKey, commandID: commandID)
+    }
+
+    private static func reorder(
+        type: String,
+        threadID: String,
+        orderKey: String,
+        commandID: String
+    ) -> JSONValue {
+        .object([
+            "type": .string(type),
+            "commandId": .string(commandID),
+            "threadId": .string(threadID),
+            "orderKey": .string(orderKey),
+        ])
     }
 
     public static func setRuntimeMode(
diff --git a/apps/swift-ios/Features/Root/FeatureRootModel.swift b/apps/swift-ios/Features/Root/FeatureRootModel.swift
index ba0b7fd46233..0684023b73ec 100644
--- a/apps/swift-ios/Features/Root/FeatureRootModel.swift
+++ b/apps/swift-ios/Features/Root/FeatureRootModel.swift
@@ -561,6 +561,31 @@ public final class FeatureRootModel {
         }
     }
 
+    /// Move up / Move down availability for a thread row, planned on demand
+    /// against the canonical section (every connected environment). Nil when
+    /// the row's environment predates reordering.
+    public func moveOptions(for thread: FeatureThread) -> FeatureThreadMoveOptions? {
+        DailyUXSidebarIndex.moveOptions(for: thread, in: snapshot.threads, now: .now)
+    }
+
+    public func moveThread(_ id: String, direction: FeatureThreadMoveDirection) async {
+        let environment = currentEnvironmentIdentity
+        await perform {
+            let assignments = try await client.moveThread(id: id, direction: direction)
+            guard currentEnvironmentIdentity == environment else { return }
+            let section: FeatureThreadOrderSection = snapshot.threads
+                .first(where: { $0.id == id })?.pinnedAt != nil ? .pinned : .active
+            for assignment in assignments {
+                mutateThread(id: assignment.threadID) {
+                    switch section {
+                    case .pinned: $0.pinOrderKey = assignment.orderKey
+                    case .active: $0.activeOrderKey = assignment.orderKey
+                    }
+                }
+            }
+        }
+    }
+
     func updatePullRequest(
         _ pullRequest: HomeThreadPullRequestPresentation?,
         threadID: String,
diff --git a/apps/swift-ios/Features/Shared/FeatureClient.swift b/apps/swift-ios/Features/Shared/FeatureClient.swift
index c014f560de38..db1628e3eb2b 100644
--- a/apps/swift-ios/Features/Shared/FeatureClient.swift
+++ b/apps/swift-ios/Features/Shared/FeatureClient.swift
@@ -52,6 +52,14 @@ public protocol FeatureClient: AnyObject {
     func setThreadSettled(id: String, settled: Bool) async throws
     func setThreadSnoozed(id: String, until: Date?) async throws
     func setThreadPinned(id: String, pinned: Bool) async throws
+    /// Executes a Move up / Move down on the thread's list section. Returns
+    /// the order-key assignments the server confirmed; an empty result means
+    /// the move was unavailable (capability or section edge).
+    @discardableResult
+    func moveThread(
+        id: String,
+        direction: FeatureThreadMoveDirection
+    ) async throws -> [FeatureThreadOrderAssignment]
     func setRuntimeMode(id: String, mode: FeatureRuntimeMode) async throws
     func setInteractionMode(id: String, mode: FeatureInteractionMode) async throws
     func deleteThread(id: String) async throws
@@ -398,6 +406,10 @@ public extension FeatureClient {
     func setThreadSettled(id: String, settled: Bool) async throws {}
     func setThreadSnoozed(id: String, until: Date?) async throws {}
     func setThreadPinned(id: String, pinned: Bool) async throws {}
+    func moveThread(
+        id: String,
+        direction: FeatureThreadMoveDirection
+    ) async throws -> [FeatureThreadOrderAssignment] { [] }
     func setRuntimeMode(id: String, mode: FeatureRuntimeMode) async throws {}
     func setInteractionMode(id: String, mode: FeatureInteractionMode) async throws {}
     func loadReviewFileContents(
diff --git a/apps/swift-ios/Features/Shared/FeatureModels.swift b/apps/swift-ios/Features/Shared/FeatureModels.swift
index 848bd2f66806..37125fb69cc6 100644
--- a/apps/swift-ios/Features/Shared/FeatureModels.swift
+++ b/apps/swift-ios/Features/Shared/FeatureModels.swift
@@ -297,6 +297,8 @@ public struct FeatureThread: Identifiable, Sendable, Equatable, Hashable, Codabl
     public var supportsSettlement: Bool?
     public var supportsSnooze: Bool?
     public var supportsPinning: Bool?
+    public var supportsPinReorder: Bool?
+    public var supportsActiveReorder: Bool?
     public var supportsTitleRegeneration: Bool?
     public var supportsPullRequestLinking: Bool?
     /// True while the server is generating a new title. Derived from the wire
@@ -343,6 +345,8 @@ public struct FeatureThread: Identifiable, Sendable, Equatable, Hashable, Codabl
         supportsSettlement: Bool? = nil,
         supportsSnooze: Bool? = nil,
         supportsPinning: Bool? = nil,
+        supportsPinReorder: Bool? = nil,
+        supportsActiveReorder: Bool? = nil,
         supportsTitleRegeneration: Bool? = nil,
         supportsPullRequestLinking: Bool? = nil,
         isRegeneratingTitle: Bool = false,
@@ -386,6 +390,8 @@ public struct FeatureThread: Identifiable, Sendable, Equatable, Hashable, Codabl
         self.supportsSettlement = supportsSettlement
         self.supportsSnooze = supportsSnooze
         self.supportsPinning = supportsPinning
+        self.supportsPinReorder = supportsPinReorder
+        self.supportsActiveReorder = supportsActiveReorder
         self.supportsTitleRegeneration = supportsTitleRegeneration
         self.supportsPullRequestLinking = supportsPullRequestLinking
         self.isRegeneratingTitle = isRegeneratingTitle
@@ -437,6 +443,33 @@ public struct FeatureThread: Identifiable, Sendable, Equatable, Hashable, Codabl
 
 }
 
+/// The thread-list section a context-menu move arranges. Pinned threads write
+/// `pinOrderKey`; active threads write `activeOrderKey`.
+public enum FeatureThreadOrderSection: String, Sendable, Equatable {
+    case pinned
+    case active
+}
+
+public enum FeatureThreadMoveDirection: String, Sendable, Equatable {
+    case up
+    case down
+}
+
+/// One `orderKey` write needed to realize a move. A move between keyed
+/// neighbors produces a single assignment on the moved thread; a move next to
+/// keyless threads rewrites the whole section (see ThreadOrderPlanner).
+public struct FeatureThreadOrderAssignment: Sendable, Equatable {
+    /// Feature-scoped thread id (`FeatureScopedID.thread`), so assignments can
+    /// span environments.
+    public let threadID: String
+    public let orderKey: String
+
+    public init(threadID: String, orderKey: String) {
+        self.threadID = threadID
+        self.orderKey = orderKey
+    }
+}
+
 public enum FeatureMessageRole: String, Sendable, Codable {
     case user
     case assistant
diff --git a/apps/swift-ios/Features/Workspace/DailyUXModels.swift b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
index 7e3d8e1b3395..2a6516d68bee 100644
--- a/apps/swift-ios/Features/Workspace/DailyUXModels.swift
+++ b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
@@ -710,32 +710,9 @@ struct DailyUXSidebarIndex {
         }
         let available = visible.filter { !$0.isEffectivelySnoozed(at: now) }
 
-        pinned = available
-            .filter {
-                $0.pinnedAt != nil
-                    && !($0.supportsSettlement == true && $0.isEffectivelySettled())
-            }
-            .sorted(by: Self.pinnedOrder)
+        pinned = Self.orderedSection(visible, section: .pinned, now: now)
 
-        active = available
-            .filter {
-                $0.pinnedAt == nil
-                    && !($0.supportsSettlement == true && $0.isEffectivelySettled())
-            }
-            .sorted { lhs, rhs in
-                switch (lhs.activeOrderKey, rhs.activeOrderKey) {
-                case (.none, .some): return true
-                case (.some, .none): return false
-                case let (.some(left), .some(right)):
-                    return left == right ? Self.activeIdentityOrder(lhs, rhs) : left < right
-                case (.none, .none): break
-                }
-                let leftAnchor = max(lhs.createdAt, lhs.unsettledAt ?? lhs.createdAt)
-                let rightAnchor = max(rhs.createdAt, rhs.unsettledAt ?? rhs.createdAt)
-                return leftAnchor == rightAnchor
-                    ? Self.activeIdentityOrder(lhs, rhs)
-                    : leftAnchor > rightAnchor
-            }
+        active = Self.orderedSection(visible, section: .active, now: now)
 
         snoozed = visible
             .filter { $0.isEffectivelySnoozed(at: now) }
@@ -767,28 +744,88 @@ struct DailyUXSidebarIndex {
         )
     }
 
-    /// Same rule as client-runtime `sortPinnedThreadsByOrderKey`: user-arranged
-    /// keys first by string compare, then keyless pins newest-created first, so
-    /// every client renders one pinned order.
+    /// Move up / Move down availability for one row, planned against the
+    /// canonical section (every environment, before project filtering and
+    /// search). Nil when the thread's environment predates reordering.
+    /// Built on demand when a context menu opens — the same per-row check
+    /// React Native runs — rather than once per row per index rebuild.
+    static func moveOptions(
+        for thread: FeatureThread,
+        in threads: [FeatureThread],
+        now: Date
+    ) -> FeatureThreadMoveOptions? {
+        let section: FeatureThreadOrderSection = thread.pinnedAt != nil ? .pinned : .active
+        guard ThreadOrderPlanner.isWritable(thread, section: section) else { return nil }
+        let planner = ThreadOrderPlanner.movePlanner(
+            ordered: orderedSection(threads, section: section, now: now),
+            all: threads,
+            section: section
+        )
+        return FeatureThreadMoveOptions(
+            canMoveUp: planner(thread, .up) != nil,
+            canMoveDown: planner(thread, .down) != nil
+        )
+    }
+
+    /// The pinned or active list in display order, independent of project
+    /// filtering and search — the same canonical section React Native plans
+    /// `thread.pin.reorder` / `thread.active.reorder` against, so a menu move
+    /// means the same thing no matter which rows are on screen.
+    static func orderedSection(
+        _ threads: [FeatureThread],
+        section: FeatureThreadOrderSection,
+        now: Date
+    ) -> [FeatureThread] {
+        threads
+            .filter { thread in
+                !thread.isArchived
+                    && !thread.isEffectivelySnoozed(at: now)
+                    && !(thread.supportsSettlement == true && thread.isEffectivelySettled())
+                    && (thread.pinnedAt != nil) == (section == .pinned)
+            }
+            .sorted(by: section == .pinned ? pinnedOrder : activeOrder)
+    }
+
+    /// Keyed rows hold their user-arranged order first; threads pinned by
+    /// clients that predate reordering keep static creation order below them
+    /// (`sortPinnedThreadsByOrderKey` in client-runtime).
     private static func pinnedOrder(_ lhs: FeatureThread, _ rhs: FeatureThread) -> Bool {
         switch (lhs.pinOrderKey, rhs.pinOrderKey) {
-        case (.some, .none): return true
-        case (.none, .some): return false
         case let (.some(left), .some(right)):
-            return left == right ? activeIdentityOrder(lhs, rhs) : left < right
+            return left == right ? identityOrder(lhs, rhs) : left < right
+        case (.some, .none):
+            return true
+        case (.none, .some):
+            return false
         case (.none, .none):
-            return creationOrder(lhs, rhs)
+            return lhs.createdAt == rhs.createdAt
+                ? identityOrder(lhs, rhs)
+                : lhs.createdAt > rhs.createdAt
         }
     }
 
-    private static func creationOrder(_ lhs: FeatureThread, _ rhs: FeatureThread) -> Bool {
-        if lhs.createdAt != rhs.createdAt {
-            return lhs.createdAt > rhs.createdAt
+    /// New and reopened threads lead the active list. Arranged threads follow
+    /// their saved keys; activity leaves both groups in place
+    /// (`sortActiveThreadsByOrderKey` in client-runtime).
+    private static func activeOrder(_ lhs: FeatureThread, _ rhs: FeatureThread) -> Bool {
+        switch (lhs.activeOrderKey, rhs.activeOrderKey) {
+        case (.none, .some): return true
+        case (.some, .none): return false
+        case let (.some(left), .some(right)):
+            return left == right ? identityOrder(lhs, rhs) : left < right
+        case (.none, .none): break
         }
-        return lhs.id < rhs.id
+        let leftAnchor = max(lhs.createdAt, lhs.unsettledAt ?? lhs.createdAt)
+        let rightAnchor = max(rhs.createdAt, rhs.unsettledAt ?? rhs.createdAt)
+        return leftAnchor == rightAnchor
+            ? identityOrder(lhs, rhs)
+            : leftAnchor > rightAnchor
     }
 
-    private static func activeIdentityOrder(_ lhs: FeatureThread, _ rhs: FeatureThread) -> Bool {
+    /// Wire id first, then environment: thread ids are only unique within an
+    /// environment, and merged sections need both parts or two clients could
+    /// render equal-key threads in stream-arrival order.
+    private static func identityOrder(_ lhs: FeatureThread, _ rhs: FeatureThread) -> Bool {
         let leftID = lhs.wireID ?? lhs.id
         let rightID = rhs.wireID ?? rhs.id
         if leftID != rightID { return leftID < rightID }
diff --git a/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift b/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
index e5cf1b3c807f..2ee0ea8348d9 100644
--- a/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
+++ b/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
@@ -25,6 +25,8 @@ struct HomeThreadCollectionView: UIViewRepresentable {
     let onSettle: (FeatureThread, Bool, @escaping (Bool) -> Void) -> Void
     let onSnooze: (FeatureThread, Date?) -> Void
     let onPin: (FeatureThread, Bool) -> Void
+    let onMove: (FeatureThread, FeatureThreadMoveDirection) -> Void
+    let onMoveOptions: (FeatureThread) -> FeatureThreadMoveOptions?
     let onDelete: (FeatureThread) -> Void
     let onPullRequestChange: (String, String, HomeThreadPullRequestPresentation?) -> Void
 
@@ -711,6 +713,28 @@ struct HomeThreadCollectionView: UIViewRepresentable {
 
             var statusActions: [UIMenuElement] = []
             if !isArchived {
+                // Planned against the canonical section when the menu opens;
+                // nil means the row's environment predates reordering, and a
+                // false direction means the move has no valid plan (edge of
+                // the section or an unwritable neighbor).
+                if let moveOptions = parent.onMoveOptions(thread) {
+                    for direction in [FeatureThreadMoveDirection.up, .down] {
+                        let enabled = direction == .up
+                            ? moveOptions.canMoveUp
+                            : moveOptions.canMoveDown
+                        statusActions.append(
+                            UIAction(
+                                title: direction == .up ? "Move up" : "Move down",
+                                image: UIImage(
+                                    systemName: direction == .up ? "arrow.up" : "arrow.down"
+                                ),
+                                attributes: enabled ? [] : .disabled
+                            ) { [weak self] _ in
+                                self?.parent.onMove(thread, direction)
+                            }
+                        )
+                    }
+                }
                 if thread.canTogglePin {
                     let isPinned = thread.pinnedAt != nil
                     statusActions.append(
diff --git a/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift b/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift
new file mode 100644
index 000000000000..7f31e148e6f0
--- /dev/null
+++ b/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift
@@ -0,0 +1,199 @@
+import Foundation
+
+/// Swift port of the order-key math shared by web and React Native
+/// (`packages/client-runtime/src/state/threadSort.ts`). Order keys are
+/// base-26 fractional indices: a move writes one key that sorts between the
+/// moved thread's new neighbors, so threads hosted on other servers are never
+/// touched and every client converges on the same order.
+enum ThreadOrderPlanner {
+    private static let digits = Array("abcdefghijklmnopqrstuvwxyz")
+
+    /// Whether the thread's environment accepts `thread.pin.reorder` /
+    /// `thread.active.reorder` writes for this section.
+    static func isWritable(_ thread: FeatureThread, section: FeatureThreadOrderSection) -> Bool {
+        switch section {
+        case .pinned: thread.supportsPinReorder == true
+        case .active: thread.supportsActiveReorder == true
+        }
+    }
+
+    /// Key that sorts strictly between two neighbors; nil bounds mean "top of
+    /// the arranged run" / "bottom of the keyed run". Returns nil instead of
+    /// trapping when existing keys are corrupt or out of order — callers fall
+    /// back to rewriting the section.
+    static func orderKeyBetween(before: String?, after: String?) -> String? {
+        let a = before ?? ""
+        let b = after ?? ""
+        if !a.isEmpty, !isValidKey(a) { return nil }
+        if !b.isEmpty, !isValidKey(b) { return nil }
+        if !b.isEmpty, a >= b { return nil }
+        return midpoint(a, b)
+    }
+
+    /// Evenly spaced keys for materializing an order. Wider keys keep a
+    /// large section from exhausting the space between two-digit keys
+    /// (`generateSpreadPinOrderKeys` in client-runtime).
+    static func spreadKeys(count: Int) -> [String] {
+        guard count > 0 else { return [] }
+        var width = 2
+        var space = digits.count * digits.count
+        while space <= (count + 1) * 2 {
+            width += 1
+            space *= digits.count
+        }
+        let step = Double(space) / Double(count + 1)
+        var keys: [String] = []
+        for index in 0..<count {
+            var value = Int((step * Double(index + 1)).rounded())
+            // Skip values whose low digit is the minimum (a trailing "a" key).
+            if value % digits.count == 0 { value += 1 }
+            var key = ""
+            for _ in 0..<width {
+                key = String(digits[value % digits.count]) + key
+                value /= digits.count
+            }
+            keys.append(key)
+        }
+        return keys
+    }
+
+    /// Assignments needed to realize a new order. When the moved thread sits
+    /// between two keyed (or absent) neighbors this is a single write; when a
+    /// neighbor is keyless the whole section gets fresh spread keys — a
+    /// one-time materialization, after which every move is single-write.
+    /// `keysByID` may include rows outside `orderedIDs` (archived, snoozed,
+    /// filtered): their keys are reserved so a fresh key never collides with
+    /// a hidden row's (`planPinnedReorder` in client-runtime).
+    static func planReorder(
+        orderedIDs: [String],
+        keysByID: [String: String?],
+        movedID: String
+    ) -> [FeatureThreadOrderAssignment] {
+        let visibleIDs = Set(orderedIDs)
+        var reservedKeys = Set<String>()
+        for (id, key) in keysByID where !visibleIDs.contains(id) {
+            if let key { reservedKeys.insert(key) }
+        }
+        guard let movedIndex = orderedIDs.firstIndex(of: movedID) else { return [] }
+        let beforeID = movedIndex > 0 ? orderedIDs[movedIndex - 1] : nil
+        let afterID = movedIndex < orderedIDs.count - 1 ? orderedIDs[movedIndex + 1] : nil
+        let beforeKey = beforeID.flatMap { keysByID[$0] ?? nil }
+        let afterKey = afterID.flatMap { keysByID[$0] ?? nil }
+        let beforeUsable = beforeID == nil || beforeKey != nil
+        let afterUsable = afterID == nil || afterKey != nil
+        if beforeUsable, afterUsable {
+            var key = orderKeyBetween(before: beforeKey, after: afterKey)
+            while let current = key, reservedKeys.contains(current) {
+                key = orderKeyBetween(before: current, after: afterKey)
+            }
+            if let key {
+                return [FeatureThreadOrderAssignment(threadID: movedID, orderKey: key)]
+            }
+        }
+        // Keyless neighbor (or corrupt keys): rewrite the section in the new order.
+        let keys = spreadKeys(count: orderedIDs.count + reservedKeys.count)
+            .filter { !reservedKeys.contains($0) }
+        return orderedIDs.enumerated().compactMap { index, id in
+            guard index < keys.count, keys[index] != keysByID[id] ?? nil else { return nil }
+            return FeatureThreadOrderAssignment(threadID: id, orderKey: keys[index])
+        }
+    }
+
+    /// `planReorder` specialized for the Move up / Move down menu actions:
+    /// swap the moved thread with its displayed neighbor. Nil when the move
+    /// falls off either end of the section. Same single-write-per-move
+    /// semantics as a web drag.
+    static func planMove(
+        orderedIDs: [String],
+        keysByID: [String: String?],
+        movedID: String,
+        direction: FeatureThreadMoveDirection
+    ) -> [FeatureThreadOrderAssignment]? {
+        guard let from = orderedIDs.firstIndex(of: movedID) else { return nil }
+        let to = direction == .up ? from - 1 : from + 1
+        guard to >= 0, to < orderedIDs.count else { return nil }
+        var newOrder = orderedIDs
+        newOrder.remove(at: from)
+        newOrder.insert(movedID, at: to)
+        return planReorder(orderedIDs: newOrder, keysByID: keysByID, movedID: movedID)
+    }
+
+    /// Keeps every visible row as an anchor but only offers plans whose key
+    /// writes are supported — the same rule React Native applies to Move up /
+    /// Move down, so menu availability and execution share one plan.
+    static func movePlanner(
+        ordered: [FeatureThread],
+        all: [FeatureThread],
+        section: FeatureThreadOrderSection
+    ) -> (FeatureThread, FeatureThreadMoveDirection) -> [FeatureThreadOrderAssignment]? {
+        let orderedIDs = ordered.map(\.id)
+        var keysByID: [String: String?] = [:]
+        for thread in all {
+            keysByID[thread.id] = section == .pinned ? thread.pinOrderKey : thread.activeOrderKey
+        }
+        let writableIDs = Set(ordered.filter { isWritable($0, section: section) }.map(\.id))
+        return { thread, direction in
+            guard writableIDs.contains(thread.id),
+                  let assignments = planMove(
+                      orderedIDs: orderedIDs,
+                      keysByID: keysByID,
+                      movedID: thread.id,
+                      direction: direction
+                  ),
+                  !assignments.isEmpty,
+                  assignments.allSatisfy({ writableIDs.contains($0.threadID) })
+            else { return nil }
+            return assignments
+        }
+    }
+
+    private static func isValidKey(_ key: String) -> Bool {
+        guard !key.isEmpty, key.allSatisfy({ digits.contains($0) }) else { return false }
+        // A trailing minimum digit would leave no room to sort a key
+        // immediately before this one; generators never produce it, so treat
+        // it as corrupt.
+        return key.last != digits[0]
+    }
+
+    /// Midpoint of two digit strings interpreted as fractions in (0, 1).
+    /// "" stands for the open bound on either side. Requires a < b.
+    private static func midpoint(_ a: String, _ b: String) -> String {
+        if !b.isEmpty {
+            // Recurse past the longest common prefix ("a" pads the shorter side).
+            var n = 0
+            let aChars = Array(a)
+            let bChars = Array(b)
+            while n < bChars.count,
+                  (n < aChars.count ? aChars[n] : digits[0]) == bChars[n] { n += 1 }
+            if n > 0 {
+                return String(bChars[0..<n])
+                    + midpoint(
+                        n < aChars.count ? String(aChars[n...]) : "",
+                        String(bChars[n...])
+                    )
+            }
+        }
+        let digitA = a.isEmpty ? 0 : digits.firstIndex(of: a.first!)!
+        let digitB = b.isEmpty ? digits.count : digits.firstIndex(of: b.first!)!
+        if digitB - digitA > 1 {
+            return String(digits[(digitA + digitB + 1) / 2])
+        }
+        // Consecutive leading digits: either b has spare digits to shorten
+        // into, or we extend a (never producing a trailing minimum digit).
+        if b.count > 1 { return String(b.first!) }
+        return String(digits[digitA]) + midpoint(String(a.dropFirst()), "")
+    }
+}
+
+/// Move up / Move down availability for one thread row. A present value means
+/// the row's environment supports reordering its section; each direction
+/// stays enabled only while a plan exists for it.
+public struct FeatureThreadMoveOptions: Equatable, Sendable {
+    public let canMoveUp: Bool
+    public let canMoveDown: Bool
+
+    public init(canMoveUp: Bool, canMoveDown: Bool) {
+        self.canMoveUp = canMoveUp
+        self.canMoveDown = canMoveDown
+    }
+}
diff --git a/apps/swift-ios/Features/Workspace/WorkspaceView.swift b/apps/swift-ios/Features/Workspace/WorkspaceView.swift
index 67a35064a30c..dfbc8578b5fb 100644
--- a/apps/swift-ios/Features/Workspace/WorkspaceView.swift
+++ b/apps/swift-ios/Features/Workspace/WorkspaceView.swift
@@ -252,6 +252,12 @@ public struct WorkspaceView: View {
                 onPin: { thread, pinned in
                     Task { await model.setPinned(thread.id, pinned: pinned) }
                 },
+                onMove: { thread, direction in
+                    Task { await model.moveThread(thread.id, direction: direction) }
+                },
+                onMoveOptions: { thread in
+                    model.moveOptions(for: thread)
+                },
                 onDelete: { thread in
                     deletingThread = thread
                 },
diff --git a/apps/swift-ios/Tests/CoreTests/CoreContractTests.swift b/apps/swift-ios/Tests/CoreTests/CoreContractTests.swift
index 20775900c61c..6e6c27f69134 100644
--- a/apps/swift-ios/Tests/CoreTests/CoreContractTests.swift
+++ b/apps/swift-ios/Tests/CoreTests/CoreContractTests.swift
@@ -173,6 +173,56 @@ final class CoreContractTests: XCTestCase {
         XCTAssertEqual(unpin["type"]?.stringValue, "thread.unpin")
     }
 
+    func testReorderCommandsMatchOrchestrationContract() {
+        let pinWithKey = OrchestrationCommands.pin(
+            threadID: "thread-1",
+            pinned: true,
+            orderKey: "mn",
+            commandID: "command-pin-keyed"
+        )
+        XCTAssertEqual(pinWithKey["type"]?.stringValue, "thread.pin")
+        XCTAssertEqual(pinWithKey["threadId"]?.stringValue, "thread-1")
+        XCTAssertEqual(pinWithKey["orderKey"]?.stringValue, "mn")
+        XCTAssertEqual(pinWithKey["commandId"]?.stringValue, "command-pin-keyed")
+
+        // An unpin never carries a key.
+        let unpin = OrchestrationCommands.pin(
+            threadID: "thread-1",
+            pinned: false,
+            orderKey: "mn",
+            commandID: "command-unpin"
+        )
+        XCTAssertEqual(unpin["type"]?.stringValue, "thread.unpin")
+        XCTAssertNil(unpin["orderKey"])
+
+        XCTAssertEqual(
+            OrchestrationCommands.reorderPinned(
+                threadID: "thread-1",
+                orderKey: "mn",
+                commandID: "command-reorder-pin"
+            ),
+            .object([
+                "type": .string("thread.pin.reorder"),
+                "commandId": .string("command-reorder-pin"),
+                "threadId": .string("thread-1"),
+                "orderKey": .string("mn"),
+            ])
+        )
+        XCTAssertEqual(
+            OrchestrationCommands.reorderActive(
+                threadID: "thread-2",
+                orderKey: "bd",
+                commandID: "command-reorder-active"
+            ),
+            .object([
+                "type": .string("thread.active.reorder"),
+                "commandId": .string("command-reorder-active"),
+                "threadId": .string("thread-2"),
+                "orderKey": .string("bd"),
+            ])
+        )
+    }
+
     func testRegenerateTitleCommandMatchesOrchestrationContract() {
         let command = OrchestrationCommands.regenerateTitle(
             threadID: "thread-1",
diff --git a/apps/swift-ios/Tests/CoreTests/NativeContractExpansionTests.swift b/apps/swift-ios/Tests/CoreTests/NativeContractExpansionTests.swift
index d2e347fe8ae2..b9567b5cae28 100644
--- a/apps/swift-ios/Tests/CoreTests/NativeContractExpansionTests.swift
+++ b/apps/swift-ios/Tests/CoreTests/NativeContractExpansionTests.swift
@@ -169,6 +169,80 @@ final class NativeContractExpansionTests: XCTestCase {
         XCTAssertEqual(RPCMethod.attachmentsDelete.rawValue, "attachments.delete")
     }
 
+    func testReorderCapabilitiesAndPinOrderKeyDecode() throws {
+        let descriptor = try JSONDecoder.t3.decode(
+            EnvironmentDescriptor.self,
+            from: Data(
+                """
+                {
+                  "environmentId": "environment-1",
+                  "label": "Studio",
+                  "platform": {"os": "darwin", "arch": "arm64"},
+                  "serverVersion": "1.0.0",
+                  "capabilities": {
+                    "repositoryIdentity": true,
+                    "threadPinning": true,
+                    "threadPinReorder": true,
+                    "threadActiveReorder": false
+                  }
+                }
+                """.utf8
+            )
+        )
+        XCTAssertEqual(descriptor.capabilities.threadPinReorder, true)
+        XCTAssertEqual(descriptor.capabilities.threadActiveReorder, false)
+
+        // Servers that predate reordering omit both flags: decode to nil,
+        // treated as unsupported everywhere downstream.
+        let legacy = try JSONDecoder.t3.decode(
+            EnvironmentDescriptor.self,
+            from: Data(
+                """
+                {
+                  "environmentId": "environment-2",
+                  "label": "Legacy",
+                  "platform": {"os": "darwin", "arch": "arm64"},
+                  "serverVersion": "0.9.0",
+                  "capabilities": {"repositoryIdentity": true}
+                }
+                """.utf8
+            )
+        )
+        XCTAssertNil(legacy.capabilities.threadPinReorder)
+        XCTAssertNil(legacy.capabilities.threadActiveReorder)
+
+        let snapshot = try JSONDecoder.t3.decode(
+            OrchestrationShellSnapshot.self,
+            from: Data(
+                """
+                {
+                  "snapshotSequence": 1,
+                  "updatedAt": "2026-09-12T00:00:00.000Z",
+                  "projects": [],
+                  "threads": [{
+                    "id": "thread-1",
+                    "projectId": "project-1",
+                    "title": "Task",
+                    "modelSelection": {"instanceId": "codex", "model": "gpt-5.6-sol"},
+                    "runtimeMode": "full-access",
+                    "interactionMode": "default",
+                    "createdAt": "2026-09-12T00:00:00.000Z",
+                    "updatedAt": "2026-09-12T00:00:00.000Z",
+                    "pinnedAt": "2026-09-12T00:00:00.000Z",
+                    "pinOrderKey": "mn",
+                    "hasPendingApprovals": false,
+                    "hasPendingUserInput": false,
+                    "hasActionableProposedPlan": false
+                  }]
+                }
+                """.utf8
+            )
+        )
+        XCTAssertEqual(snapshot.threads.count, 1)
+        XCTAssertEqual(snapshot.threads.first?.pinOrderKey, "mn")
+        XCTAssertNil(snapshot.threads.first?.activeOrderKey)
+    }
+
     func testCodexFeedbackContractMatchesTheServerRPC() throws {
         let result = try JSONDecoder.t3.decode(
             ProviderUploadFeedbackResult.self,
diff --git a/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift b/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
index ad1781d46c57..18f884f630ee 100644
--- a/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
+++ b/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
@@ -1182,6 +1182,8 @@ struct HomeThreadSwipeActionTests {
             },
             onSnooze: { _, _ in },
             onPin: { _, _ in },
+            onMove: { _, _ in },
+            onMoveOptions: { _ in nil },
             onDelete: { _ in },
             onPullRequestChange: { _, _, _ in }
         )
diff --git a/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift b/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift
new file mode 100644
index 000000000000..0769aa0c2411
--- /dev/null
+++ b/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift
@@ -0,0 +1,374 @@
+import Foundation
+import Testing
+@testable import T3Code
+
+/// Parity coverage for `ThreadOrderPlanner` against
+/// `packages/client-runtime/src/state/threadSort.ts` and
+/// `apps/mobile/src/features/threads/threadOrder.ts`.
+@Suite("Thread order planner")
+struct ThreadOrderPlannerTests {
+    private let now = Date(timeIntervalSince1970: 2_000_000)
+
+    // MARK: - orderKeyBetween
+
+    @Test
+    func orderKeyBetweenFindsAKeyBetweenKeyedNeighbors() {
+        let key = ThreadOrderPlanner.orderKeyBetween(before: "f", after: "t")
+        #expect(key != nil)
+        #expect(key! > "f")
+        #expect(key! < "t")
+    }
+
+    @Test
+    func orderKeyBetweenHandlesOpenBoundsAndRepeatedSplitting() {
+        let top = ThreadOrderPlanner.orderKeyBetween(before: nil, after: "b")
+        #expect(top != nil)
+        #expect(top! < "b")
+
+        let bottom = ThreadOrderPlanner.orderKeyBetween(before: "y", after: nil)
+        #expect(bottom != nil)
+        #expect(bottom! > "y")
+
+        // Splitting a one-digit gap must extend, not collide.
+        var a = "f"
+        for _ in 0..<64 {
+            let next = ThreadOrderPlanner.orderKeyBetween(before: a, after: "g")
+            #expect(next != nil)
+            #expect(next! > a)
+            #expect(next! < "g")
+            a = next!
+        }
+    }
+
+    @Test
+    func orderKeyBetweenRejectsCorruptOrInvertedBounds() {
+        #expect(ThreadOrderPlanner.orderKeyBetween(before: "fa", after: "z") == nil)
+        #expect(ThreadOrderPlanner.orderKeyBetween(before: "f", after: "1") == nil)
+        #expect(ThreadOrderPlanner.orderKeyBetween(before: "t", after: "f") == nil)
+        #expect(ThreadOrderPlanner.orderKeyBetween(before: "m", after: "m") == nil)
+        #expect(ThreadOrderPlanner.orderKeyBetween(before: nil, after: nil) != nil)
+    }
+
+    // MARK: - spreadKeys
+
+    @Test(arguments: [0, 1, 650, 675, 676, 1_001, 2_000])
+    func spreadKeysAreUniqueSortedAndInsertable(count: Int) {
+        let keys = ThreadOrderPlanner.spreadKeys(count: count)
+        #expect(keys.count == count)
+        #expect(Set(keys).count == count)
+        #expect(keys.sorted() == keys)
+        for (index, key) in keys.enumerated() {
+            #expect(key.last != "a")
+            let between = ThreadOrderPlanner.orderKeyBetween(
+                before: index > 0 ? keys[index - 1] : nil,
+                after: key
+            )
+            #expect(between != nil)
+            #expect(between! < key)
+            if index > 0 {
+                #expect(between! > keys[index - 1])
+            }
+        }
+    }
+
+    // MARK: - planMove
+
+    @Test
+    func moveUpWritesASingleKeyOnTheMovedThread() {
+        let assignments = ThreadOrderPlanner.planMove(
+            orderedIDs: ["a", "b", "c"],
+            keysByID: ["a": "f", "b": "m", "c": "t"],
+            movedID: "c",
+            direction: .up
+        )
+        #expect(assignments?.count == 1)
+        #expect(assignments?[0].threadID == "c")
+        #expect(assignments![0].orderKey > "f")
+        #expect(assignments![0].orderKey < "m")
+    }
+
+    @Test
+    func movesOffTheSectionEndsReturnNil() {
+        let keys: [String: String?] = ["a": "f", "b": "m"]
+        #expect(ThreadOrderPlanner.planMove(
+            orderedIDs: ["a", "b"], keysByID: keys, movedID: "a", direction: .up
+        ) == nil)
+        #expect(ThreadOrderPlanner.planMove(
+            orderedIDs: ["a", "b"], keysByID: keys, movedID: "b", direction: .down
+        ) == nil)
+    }
+
+    @Test
+    func keylessNeighborMaterializesTheWholeSectionInTheNewOrder() {
+        let assignments = ThreadOrderPlanner.planMove(
+            orderedIDs: ["a", "b", "c"],
+            keysByID: ["a": nil, "b": "m", "c": nil],
+            movedID: "b",
+            direction: .up
+        )
+        #expect(assignments != nil)
+        let keys = assignments!.map(\.orderKey)
+        #expect(keys.sorted() == keys)
+        // The requested order is [b, a, c]: b's new key sorts first.
+        let keyByID = Dictionary(
+            uniqueKeysWithValues: assignments!.map { ($0.threadID, $0.orderKey) }
+        )
+        #expect(keyByID["b"]! < keyByID["a"]!)
+        #expect(keyByID["a"]! < keyByID["c"]!)
+    }
+
+    @Test
+    func keylessThreadMovesIntoTheArrangedRunWithOneWrite() {
+        let assignments = ThreadOrderPlanner.planMove(
+            orderedIDs: ["new", "reopened", "first", "last"],
+            keysByID: ["new": nil, "reopened": nil, "first": "f", "last": "t"],
+            movedID: "reopened",
+            direction: .down
+        )
+        #expect(assignments?.count == 1)
+        #expect(assignments?[0].threadID == "reopened")
+        #expect(assignments![0].orderKey > "f")
+        #expect(assignments![0].orderKey < "t")
+    }
+
+    // MARK: - hidden-row reservations
+
+    @Test
+    func hiddenRowKeysAreReservedForSingleKeyInserts() {
+        let midpoint = ThreadOrderPlanner.orderKeyBetween(before: "f", after: "t")!
+        let assignments = ThreadOrderPlanner.planReorder(
+            orderedIDs: ["a", "moved", "b"],
+            keysByID: ["a": "f", "b": "t", "moved": "z", "snoozed": midpoint],
+            movedID: "moved"
+        )
+        #expect(assignments.count == 1)
+        #expect(assignments[0].threadID == "moved")
+        #expect(assignments[0].orderKey > "f")
+        #expect(assignments[0].orderKey < "t")
+        #expect(assignments[0].orderKey != midpoint)
+    }
+
+    @Test
+    func spreadRewritesNeverStealAHiddenRowKey() {
+        let reserved = ThreadOrderPlanner.spreadKeys(count: 6)
+        var keysByID: [String: String?] = ["a": nil, "b": nil, "c": nil]
+        for (index, key) in reserved.enumerated() {
+            keysByID["hidden-\(index)"] = key
+        }
+        let assignments = ThreadOrderPlanner.planReorder(
+            orderedIDs: ["c", "a", "b"],
+            keysByID: keysByID,
+            movedID: "c"
+        )
+        #expect(assignments.map(\.threadID) == ["c", "a", "b"])
+        let keys = assignments.map(\.orderKey)
+        #expect(keys.sorted() == keys)
+        #expect(Set(keys).count == 3)
+        #expect(keys.allSatisfy { !reserved.contains($0) })
+    }
+
+    // MARK: - movePlanner / moveOptions capability gating
+
+    @Test
+    func movePlannerRequiresReorderSupportOnEveryAssignedEnvironment() {
+        let envA = sectionThreads(
+            environmentID: "env-a",
+            pinned: true,
+            keys: ["a-1": "f", "a-2": "t"],
+            supportsPinReorder: true
+        )
+        // env-b predates reordering: its rows stay keyless and unwritable.
+        let envB = sectionThreads(
+            environmentID: "env-b",
+            pinned: true,
+            keys: ["b-1": nil],
+            supportsPinReorder: false
+        )
+        let all = envA + envB
+        let ordered = DailyUXSidebarIndex.orderedSection(all, section: .pinned, now: now)
+        // Keyed rows first (env-a), keyless env-b row last.
+        #expect(ordered.map(\.id) == ["env-a:a-1", "env-a:a-2", "env-b:b-1"])
+
+        let planner = ThreadOrderPlanner.movePlanner(
+            ordered: ordered,
+            all: all,
+            section: .pinned
+        )
+        // Single-key move within the writable environment works.
+        let moving = ordered.first { $0.id == "env-a:a-2" }!
+        let assignments = planner(moving, .up)
+        #expect(assignments?.count == 1)
+        #expect(assignments?[0].threadID == "env-a:a-2")
+
+        // Moving the env-a row down past the keyless env-b row would need a
+        // spread rewrite touching env-b — refused, like React Native.
+        let edge = ordered.first { $0.id == "env-a:a-2" }!
+        #expect(planner(edge, .down) == nil)
+
+        // The env-b row itself gets no plan at all.
+        let unwritable = ordered.first { $0.id == "env-b:b-1" }!
+        #expect(planner(unwritable, .up) == nil)
+        #expect(planner(unwritable, .down) == nil)
+    }
+
+    @Test
+    func moveOptionsReportPerDirectionAvailabilityForWritableRowsOnly() {
+        let threads = sectionThreads(
+            environmentID: "env-a",
+            pinned: true,
+            keys: ["a-1": "f", "a-2": "m", "a-3": "t"],
+            supportsPinReorder: true
+        ) + sectionThreads(
+            environmentID: "env-b",
+            pinned: true,
+            keys: ["b-1": "n"],
+            supportsPinReorder: false
+        )
+        var options: [String: FeatureThreadMoveOptions] = [:]
+        for thread in threads {
+            if let value = DailyUXSidebarIndex.moveOptions(for: thread, in: threads, now: now) {
+                options[thread.id] = value
+            }
+        }
+        // Ordered by key: a-1(f), a-2(m), b-1(n), a-3(t).
+        #expect(options["env-a:a-1"] == FeatureThreadMoveOptions(canMoveUp: false, canMoveDown: true))
+        #expect(options["env-a:a-3"] == FeatureThreadMoveOptions(canMoveUp: true, canMoveDown: false))
+        // env-b's row sorts mid-list by key but cannot be written itself.
+        #expect(options["env-b:b-1"] == nil)
+        // Moving a-2 down past the keyed env-b row is still a single write on
+        // a-2, so it stays enabled.
+        #expect(options["env-a:a-2"] == FeatureThreadMoveOptions(canMoveUp: true, canMoveDown: true))
+    }
+
+    @Test
+    func activeSectionUsesActiveOrderKeysAndCapability() {
+        let threads = sectionThreads(
+            environmentID: "env-a",
+            pinned: false,
+            keys: ["a-1": "f", "a-2": "m"],
+            supportsActiveReorder: true
+        )
+        let ordered = DailyUXSidebarIndex.orderedSection(threads, section: .active, now: now)
+        let planner = ThreadOrderPlanner.movePlanner(
+            ordered: ordered,
+            all: threads,
+            section: .active
+        )
+        let assignments = planner(ordered[1], .up)
+        #expect(assignments?.count == 1)
+        #expect(assignments?[0].threadID == "env-a:a-2")
+    }
+
+    // MARK: - pinned section ordering
+
+    @Test
+    func pinnedSectionSortsKeyedRowsFirstThenKeylessByCreation() {
+        var keyed = thread(id: "env-a:keyed", pinned: true, created: -1_000)
+        keyed.pinOrderKey = "m"
+        var keyedEarly = thread(id: "env-a:keyed-early", pinned: true, created: -500)
+        keyedEarly.pinOrderKey = "f"
+        let keylessNew = thread(id: "env-a:keyless-new", pinned: true, created: -100)
+        let keylessOld = thread(id: "env-a:keyless-old", pinned: true, created: -900)
+
+        let ordered = DailyUXSidebarIndex.orderedSection(
+            [keylessNew, keyed, keylessOld, keyedEarly],
+            section: .pinned,
+            now: now
+        )
+        #expect(ordered.map(\.id) == [
+            "env-a:keyed-early",
+            "env-a:keyed",
+            "env-a:keyless-new",
+            "env-a:keyless-old",
+        ])
+    }
+
+    @Test
+    func pinnedTiesBreakByWireIDThenEnvironment() {
+        var first = thread(id: "z-env:a-thread", pinned: true, created: -100)
+        first.wireID = "a-thread"
+        first.environmentID = "z-env"
+        first.pinOrderKey = "m"
+        var second = thread(id: "a-env:z-thread", pinned: true, created: -100)
+        second.wireID = "z-thread"
+        second.environmentID = "a-env"
+        second.pinOrderKey = "m"
+        var sameWire = thread(id: "a-env:a-thread", pinned: true, created: -100)
+        sameWire.wireID = "a-thread"
+        sameWire.environmentID = "a-env"
+        sameWire.pinOrderKey = "m"
+
+        let ordered = DailyUXSidebarIndex.orderedSection(
+            [second, first, sameWire],
+            section: .pinned,
+            now: now
+        )
+        #expect(ordered.map(\.id) == ["a-env:a-thread", "z-env:a-thread", "a-env:z-thread"])
+    }
+
+    @Test
+    func orderedSectionExcludesArchivedSnoozedAndSettledRows() {
+        let live = thread(id: "env-a:live", pinned: true, created: -100)
+        var archived = thread(id: "env-a:archived", pinned: true, created: -50)
+        archived.isArchived = true
+        var snoozed = thread(id: "env-a:snoozed", pinned: true, created: -50)
+        snoozed.snoozedUntil = now.addingTimeInterval(3_600)
+        snoozed.supportsSnooze = true
+        var settled = thread(id: "env-a:settled", pinned: true, created: -50)
+        settled.supportsSettlement = true
+        settled.settlementFacts = FeatureThreadSettlementFacts(settlementOverride: .settled)
+
+        let ordered = DailyUXSidebarIndex.orderedSection(
+            [live, archived, snoozed, settled],
+            section: .pinned,
+            now: now
+        )
+        #expect(ordered.map(\.id) == ["env-a:live"])
+    }
+
+    // MARK: - fixtures
+
+    private func thread(
+        id: String,
+        pinned: Bool = false,
+        created: TimeInterval
+    ) -> FeatureThread {
+        FeatureThread(
+            id: id,
+            wireID: String(id.split(separator: ":").last!),
+            projectID: "project",
+            environmentID: id.split(separator: ":").first.map(String.init),
+            title: "Task",
+            createdAt: now.addingTimeInterval(created),
+            updatedAt: now.addingTimeInterval(created),
+            pinnedAt: pinned ? now.addingTimeInterval(created) : nil,
+            supportsPinning: true
+        )
+    }
+
+    private func sectionThreads(
+        environmentID: String,
+        pinned: Bool,
+        keys: [String: String?],
+        supportsPinReorder: Bool = false,
+        supportsActiveReorder: Bool = false
+    ) -> [FeatureThread] {
+        keys.keys.sorted().enumerated().map { index, wireID in
+            FeatureThread(
+                id: "\(environmentID):\(wireID)",
+                wireID: wireID,
+                projectID: "project",
+                environmentID: environmentID,
+                title: "Task",
+                createdAt: now.addingTimeInterval(-Double(index) - 100),
+                updatedAt: now.addingTimeInterval(-Double(index) - 100),
+                activeOrderKey: pinned ? nil : keys[wireID] ?? nil,
+                pinnedAt: pinned ? now.addingTimeInterval(-Double(index) - 100) : nil,
+                pinOrderKey: pinned ? keys[wireID] ?? nil : nil,
+                supportsPinning: true,
+                supportsPinReorder: supportsPinReorder,
+                supportsActiveReorder: supportsActiveReorder
+            )
+        }
+    }
+}

From a0382deb93617d7a914cfa0f609247a752db43d5 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 12 Sep 2026 16:10:18 +1000
Subject: [PATCH 02/10] fix(swift-ios): never write order keys to disconnected
 environments

The move planner treated every enabled environment as writable, so a
reorder-capable server that dropped its connection kept stale rows in
the canonical section and could receive writes aimed at a dead client.
Rows outside the connected set now remain anchors but are never
assigned keys, matching the review finding on #11379.

Generated with Devin (swe-2-high, T3 Code/Cursor harness)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 apps/swift-ios/App/NativeFeatureClient.swift  | 11 +++-
 .../Features/Root/FeatureRootModel.swift      | 14 +++-
 .../Features/Workspace/DailyUXModels.swift    | 13 ++--
 .../Workspace/ThreadOrderPlanner.swift        | 17 ++++-
 .../ThreadOrderPlannerTests.swift             | 65 ++++++++++++++++++-
 5 files changed, 107 insertions(+), 13 deletions(-)

diff --git a/apps/swift-ios/App/NativeFeatureClient.swift b/apps/swift-ios/App/NativeFeatureClient.swift
index 6585ebfd8dee..3d1d5607ff5b 100644
--- a/apps/swift-ios/App/NativeFeatureClient.swift
+++ b/apps/swift-ios/App/NativeFeatureClient.swift
@@ -1722,6 +1722,14 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
             throw NativeFeatureClientError.threadNotFound
         }
         let section: FeatureThreadOrderSection = thread.pinnedAt != nil ? .pinned : .active
+        // Only currently-connected environments are writable; a disconnected
+        // server's rows keep their stale keys as anchors but never receive
+        // writes, so a spread rewrite cannot half-land on a dead client.
+        let connectedEnvironmentIDs = Set(
+            environmentConnectionStates
+                .filter { $0.value == .connected }
+                .map(\.key)
+        )
         let planner = ThreadOrderPlanner.movePlanner(
             ordered: DailyUXSidebarIndex.orderedSection(
                 snapshot.threads,
@@ -1729,7 +1737,8 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
                 now: .now
             ),
             all: snapshot.threads,
-            section: section
+            section: section,
+            connectedEnvironmentIDs: connectedEnvironmentIDs
         )
         guard let assignments = planner(thread, direction), !assignments.isEmpty else {
             return []
diff --git a/apps/swift-ios/Features/Root/FeatureRootModel.swift b/apps/swift-ios/Features/Root/FeatureRootModel.swift
index 0684023b73ec..374a47de0975 100644
--- a/apps/swift-ios/Features/Root/FeatureRootModel.swift
+++ b/apps/swift-ios/Features/Root/FeatureRootModel.swift
@@ -563,9 +563,19 @@ public final class FeatureRootModel {
 
     /// Move up / Move down availability for a thread row, planned on demand
     /// against the canonical section (every connected environment). Nil when
-    /// the row's environment predates reordering.
+    /// the row's environment predates reordering or is not connected.
     public func moveOptions(for thread: FeatureThread) -> FeatureThreadMoveOptions? {
-        DailyUXSidebarIndex.moveOptions(for: thread, in: snapshot.threads, now: .now)
+        let connectedEnvironmentIDs = Set(
+            snapshot.environments
+                .filter { $0.connectionState == .connected }
+                .map(\.id)
+        )
+        return DailyUXSidebarIndex.moveOptions(
+            for: thread,
+            in: snapshot.threads,
+            now: .now,
+            connectedEnvironmentIDs: connectedEnvironmentIDs
+        )
     }
 
     public func moveThread(_ id: String, direction: FeatureThreadMoveDirection) async {
diff --git a/apps/swift-ios/Features/Workspace/DailyUXModels.swift b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
index 2a6516d68bee..b1d1943898e8 100644
--- a/apps/swift-ios/Features/Workspace/DailyUXModels.swift
+++ b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
@@ -746,20 +746,25 @@ struct DailyUXSidebarIndex {
 
     /// Move up / Move down availability for one row, planned against the
     /// canonical section (every environment, before project filtering and
-    /// search). Nil when the thread's environment predates reordering.
+    /// search). Nil when the thread's environment predates reordering or is
+    /// not in `connectedEnvironmentIDs` — a move planned against a
+    /// disconnected server's stale keys would target a dead client.
     /// Built on demand when a context menu opens — the same per-row check
     /// React Native runs — rather than once per row per index rebuild.
     static func moveOptions(
         for thread: FeatureThread,
         in threads: [FeatureThread],
-        now: Date
+        now: Date,
+        connectedEnvironmentIDs: Set<String>
     ) -> FeatureThreadMoveOptions? {
         let section: FeatureThreadOrderSection = thread.pinnedAt != nil ? .pinned : .active
-        guard ThreadOrderPlanner.isWritable(thread, section: section) else { return nil }
+        guard ThreadOrderPlanner.isWritable(thread, section: section),
+              connectedEnvironmentIDs.contains(thread.environmentID ?? "") else { return nil }
         let planner = ThreadOrderPlanner.movePlanner(
             ordered: orderedSection(threads, section: section, now: now),
             all: threads,
-            section: section
+            section: section,
+            connectedEnvironmentIDs: connectedEnvironmentIDs
         )
         return FeatureThreadMoveOptions(
             canMoveUp: planner(thread, .up) != nil,
diff --git a/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift b/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift
index 7f31e148e6f0..76faf0c26629 100644
--- a/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift
+++ b/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift
@@ -120,18 +120,29 @@ enum ThreadOrderPlanner {
 
     /// Keeps every visible row as an anchor but only offers plans whose key
     /// writes are supported — the same rule React Native applies to Move up /
-    /// Move down, so menu availability and execution share one plan.
+    /// Move down, so menu availability and execution share one plan. Rows in
+    /// environments outside `connectedEnvironmentIDs` stay anchors but are
+    /// never written: their last-known keys are stale, and a write would go
+    /// to a dead client.
     static func movePlanner(
         ordered: [FeatureThread],
         all: [FeatureThread],
-        section: FeatureThreadOrderSection
+        section: FeatureThreadOrderSection,
+        connectedEnvironmentIDs: Set<String>
     ) -> (FeatureThread, FeatureThreadMoveDirection) -> [FeatureThreadOrderAssignment]? {
         let orderedIDs = ordered.map(\.id)
         var keysByID: [String: String?] = [:]
         for thread in all {
             keysByID[thread.id] = section == .pinned ? thread.pinOrderKey : thread.activeOrderKey
         }
-        let writableIDs = Set(ordered.filter { isWritable($0, section: section) }.map(\.id))
+        let writableIDs = Set(
+            ordered
+                .filter {
+                    isWritable($0, section: section)
+                        && connectedEnvironmentIDs.contains($0.environmentID ?? "")
+                }
+                .map(\.id)
+        )
         return { thread, direction in
             guard writableIDs.contains(thread.id),
                   let assignments = planMove(
diff --git a/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift b/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift
index 0769aa0c2411..de4bf5c94b95 100644
--- a/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift
+++ b/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift
@@ -192,7 +192,8 @@ struct ThreadOrderPlannerTests {
         let planner = ThreadOrderPlanner.movePlanner(
             ordered: ordered,
             all: all,
-            section: .pinned
+            section: .pinned,
+            connectedEnvironmentIDs: ["env-a", "env-b"]
         )
         // Single-key move within the writable environment works.
         let moving = ordered.first { $0.id == "env-a:a-2" }!
@@ -226,7 +227,12 @@ struct ThreadOrderPlannerTests {
         )
         var options: [String: FeatureThreadMoveOptions] = [:]
         for thread in threads {
-            if let value = DailyUXSidebarIndex.moveOptions(for: thread, in: threads, now: now) {
+            if let value = DailyUXSidebarIndex.moveOptions(
+                for: thread,
+                in: threads,
+                now: now,
+                connectedEnvironmentIDs: ["env-a", "env-b"]
+            ) {
                 options[thread.id] = value
             }
         }
@@ -252,13 +258,66 @@ struct ThreadOrderPlannerTests {
         let planner = ThreadOrderPlanner.movePlanner(
             ordered: ordered,
             all: threads,
-            section: .active
+            section: .active,
+            connectedEnvironmentIDs: ["env-a"]
         )
         let assignments = planner(ordered[1], .up)
         #expect(assignments?.count == 1)
         #expect(assignments?[0].threadID == "env-a:a-2")
     }
 
+    @Test
+    func disconnectedEnvironmentRowsStayAnchorsButAreNeverWritten() {
+        // env-b is reorder-capable but currently disconnected: its last-known
+        // keys are stale, so its rows anchor positions without being writable.
+        let threads = sectionThreads(
+            environmentID: "env-a",
+            pinned: true,
+            keys: ["a-1": "f", "a-2": "t"],
+            supportsPinReorder: true
+        ) + sectionThreads(
+            environmentID: "env-b",
+            pinned: true,
+            keys: ["b-1": "m"],
+            supportsPinReorder: true
+        )
+        let all = threads
+        let ordered = DailyUXSidebarIndex.orderedSection(all, section: .pinned, now: now)
+        #expect(ordered.map(\.id) == ["env-a:a-1", "env-b:b-1", "env-a:a-2"])
+
+        let planner = ThreadOrderPlanner.movePlanner(
+            ordered: ordered,
+            all: all,
+            section: .pinned,
+            connectedEnvironmentIDs: ["env-a"]
+        )
+        // The disconnected row itself offers no move.
+        let stale = ordered.first { $0.id == "env-b:b-1" }!
+        #expect(planner(stale, .up) == nil)
+        #expect(planner(stale, .down) == nil)
+        // A connected row can still move past it with a single write.
+        let moving = ordered.first { $0.id == "env-a:a-2" }!
+        let assignments = planner(moving, .up)
+        #expect(assignments == [
+            FeatureThreadOrderAssignment(threadID: "env-a:a-2", orderKey: "j")
+        ])
+
+        var options: [String: FeatureThreadMoveOptions] = [:]
+        for thread in threads {
+            if let value = DailyUXSidebarIndex.moveOptions(
+                for: thread,
+                in: threads,
+                now: now,
+                connectedEnvironmentIDs: ["env-a"]
+            ) {
+                options[thread.id] = value
+            }
+        }
+        #expect(options["env-b:b-1"] == nil)
+        #expect(options["env-a:a-1"] == FeatureThreadMoveOptions(canMoveUp: false, canMoveDown: true))
+        #expect(options["env-a:a-2"] == FeatureThreadMoveOptions(canMoveUp: true, canMoveDown: false))
+    }
+
     // MARK: - pinned section ordering
 
     @Test

From d2aef6119305ae91f44459c0524cb996560a83ef Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 12 Sep 2026 16:18:25 +1000
Subject: [PATCH 03/10] fix(swift-ios): reconcile partial reorder writes and
 pin section early

Two review findings on #11379: moveThread now captures the section
before awaiting so a mid-flight pin/unpin cannot misapply confirmed
keys, and a spread rewrite that fails partway surfaces the confirmed
assignments via FeatureThreadMovePartialError so the sidebar reflects
the writes that actually landed.

Generated with Devin (swe-2-high, T3 Code/Cursor harness)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 apps/swift-ios/App/NativeFeatureClient.swift  | 10 +++++-
 .../Features/Root/FeatureRootModel.swift      | 32 ++++++++++++++-----
 .../Features/Shared/FeatureModels.swift       | 13 ++++++++
 3 files changed, 46 insertions(+), 9 deletions(-)

diff --git a/apps/swift-ios/App/NativeFeatureClient.swift b/apps/swift-ios/App/NativeFeatureClient.swift
index 3d1d5607ff5b..c2cfb2bd9d01 100644
--- a/apps/swift-ios/App/NativeFeatureClient.swift
+++ b/apps/swift-ios/App/NativeFeatureClient.swift
@@ -1779,7 +1779,15 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
                 try? await refresh(client: client)
             }
         }
-        if let firstError { throw firstError }
+        if let firstError {
+            guard confirmed.isEmpty else {
+                throw FeatureThreadMovePartialError(
+                    confirmed: confirmed,
+                    underlying: firstError
+                )
+            }
+            throw firstError
+        }
         return confirmed
     }
 
diff --git a/apps/swift-ios/Features/Root/FeatureRootModel.swift b/apps/swift-ios/Features/Root/FeatureRootModel.swift
index 374a47de0975..7673e613eaab 100644
--- a/apps/swift-ios/Features/Root/FeatureRootModel.swift
+++ b/apps/swift-ios/Features/Root/FeatureRootModel.swift
@@ -581,16 +581,32 @@ public final class FeatureRootModel {
     public func moveThread(_ id: String, direction: FeatureThreadMoveDirection) async {
         let environment = currentEnvironmentIdentity
         await perform {
-            let assignments = try await client.moveThread(id: id, direction: direction)
-            guard currentEnvironmentIdentity == environment else { return }
+            // The section is fixed by the plan the client is about to run —
+            // reading it after the await would misapply confirmed keys if a
+            // pin/unpin landed in between.
             let section: FeatureThreadOrderSection = snapshot.threads
                 .first(where: { $0.id == id })?.pinnedAt != nil ? .pinned : .active
-            for assignment in assignments {
-                mutateThread(id: assignment.threadID) {
-                    switch section {
-                    case .pinned: $0.pinOrderKey = assignment.orderKey
-                    case .active: $0.activeOrderKey = assignment.orderKey
-                    }
+            do {
+                let assignments = try await client.moveThread(id: id, direction: direction)
+                applyMoveAssignments(assignments, section: section, environment: environment)
+            } catch let partial as FeatureThreadMovePartialError {
+                applyMoveAssignments(partial.confirmed, section: section, environment: environment)
+                throw partial.underlying
+            }
+        }
+    }
+
+    private func applyMoveAssignments(
+        _ assignments: [FeatureThreadOrderAssignment],
+        section: FeatureThreadOrderSection,
+        environment: String
+    ) {
+        guard currentEnvironmentIdentity == environment else { return }
+        for assignment in assignments {
+            mutateThread(id: assignment.threadID) {
+                switch section {
+                case .pinned: $0.pinOrderKey = assignment.orderKey
+                case .active: $0.activeOrderKey = assignment.orderKey
                 }
             }
         }
diff --git a/apps/swift-ios/Features/Shared/FeatureModels.swift b/apps/swift-ios/Features/Shared/FeatureModels.swift
index 37125fb69cc6..94625687c074 100644
--- a/apps/swift-ios/Features/Shared/FeatureModels.swift
+++ b/apps/swift-ios/Features/Shared/FeatureModels.swift
@@ -470,6 +470,19 @@ public struct FeatureThreadOrderAssignment: Sendable, Equatable {
     }
 }
 
+/// A spread rewrite that wrote some assignments before a later environment
+/// rejected its write. Callers apply `confirmed` — those rows are arranged on
+/// their servers — and surface `underlying` as the move's failure.
+public struct FeatureThreadMovePartialError: Error, Sendable {
+    public let confirmed: [FeatureThreadOrderAssignment]
+    public let underlying: Error
+
+    public init(confirmed: [FeatureThreadOrderAssignment], underlying: Error) {
+        self.confirmed = confirmed
+        self.underlying = underlying
+    }
+}
+
 public enum FeatureMessageRole: String, Sendable, Codable {
     case user
     case assistant

From ac0cf24550290870a5682a8ac8acbc9b29f6986b Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 12 Sep 2026 16:21:49 +1000
Subject: [PATCH 04/10] chore(swift-ios): retrigger CI after unrelated web test
 flake

Generated with Devin (swe-2-high, T3 Code/Cursor harness)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

From b89bfa6a3de3e14e521f21bc4dfaa16402621bd0 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 12 Sep 2026 18:47:02 +1000
Subject: [PATCH 05/10] feat(swift-ios): hold-and-drag thread reordering
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the context-menu Move up/down actions with direct hold-and-drag
reordering on the Home thread list, per review feedback. A long-press
lifts a row inside its own section (pinned or active); the drop plans
fractional order-key writes from the post-drop displayed order — the same
input web passes to planPinnedReorder. A stationary hold still opens the
context menu.

- UICollectionView drag/drop delegates + diffable reorderingHandlers;
  drop proposals clamp to the dragged row's section so pinned rows can't
  cross the divider and shelf rows/search results/headers never lift.
- planDrop() replaces movePlanner(): arbitrary-position drops with the
  same writability rules (reorder-capable + connected environments only;
  disconnected rows anchor but are never written).
- pendingReorder holds the dropped order against mid-flight stream
  updates and converges on the common rows; a failed or partial write
  snaps back to the true model state. New lifts are blocked while a
  write is outstanding and no-op drops skip the write.
- Stream updates defer while a drag is active (hasActiveDrag) so the
  lifted row can't shift under the finger.
- FeatureThreadMoveDirection/MoveOptions removed; lift gating is a plain
  writable+connected check.

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 apps/swift-ios/App/NativeFeatureClient.swift  |  40 +-
 .../Features/Root/FeatureRootModel.swift      |  64 ++--
 .../Features/Shared/FeatureClient.swift       |  17 +-
 .../Features/Shared/FeatureModels.swift       |   7 +-
 .../Features/Workspace/DailyUXModels.swift    |  30 +-
 .../Workspace/HomeThreadCollectionView.swift  | 347 ++++++++++++++++--
 .../Workspace/ThreadOrderPlanner.swift        |  98 +++--
 .../Features/Workspace/WorkspaceView.swift    |  14 +-
 .../HomeThreadSwipeActionTests.swift          |   4 +-
 .../ThreadOrderPlannerTests.swift             | 329 ++++++++++-------
 10 files changed, 635 insertions(+), 315 deletions(-)

diff --git a/apps/swift-ios/App/NativeFeatureClient.swift b/apps/swift-ios/App/NativeFeatureClient.swift
index c2cfb2bd9d01..e4714e847d51 100644
--- a/apps/swift-ios/App/NativeFeatureClient.swift
+++ b/apps/swift-ios/App/NativeFeatureClient.swift
@@ -1705,23 +1705,23 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
         try? await refresh(client: route.client)
     }
 
-    /// Executes a Move up / Move down from the thread context menu. Plans the
-    /// move against the canonical ordered section across every connected
-    /// environment (a spread rewrite can write keys on neighbors hosted by
-    /// other servers), then refreshes each environment it touched. Returns the
-    /// assignments the server confirmed so the caller can patch local state if
-    /// a refresh fell behind.
+    /// Executes a hold-and-drag reorder. `orderedIDs` is the moved thread's
+    /// displayed section order after the drop — the same input web passes to
+    /// `planPinnedReorder`. Rows absent from the current snapshot are skipped;
+    /// every row a spread rewrite would write must sit in a connected,
+    /// reorder-capable environment or the whole drop is rejected before any
+    /// write. Returns the assignments the server confirmed so the caller can
+    /// patch local state if a refresh fell behind.
     @discardableResult
-    func moveThread(
+    func reorderThread(
         id: String,
-        direction: FeatureThreadMoveDirection
+        section: FeatureThreadOrderSection,
+        orderedIDs: [String]
     ) async throws -> [FeatureThreadOrderAssignment] {
         guard !threadMoveInFlight else { return [] }
-        guard let snapshot = latestSnapshot,
-              let thread = snapshot.threads.first(where: { $0.id == id }) else {
+        guard let snapshot = latestSnapshot else {
             throw NativeFeatureClientError.threadNotFound
         }
-        let section: FeatureThreadOrderSection = thread.pinnedAt != nil ? .pinned : .active
         // Only currently-connected environments are writable; a disconnected
         // server's rows keep their stale keys as anchors but never receive
         // writes, so a spread rewrite cannot half-land on a dead client.
@@ -1730,17 +1730,17 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
                 .filter { $0.value == .connected }
                 .map(\.key)
         )
-        let planner = ThreadOrderPlanner.movePlanner(
-            ordered: DailyUXSidebarIndex.orderedSection(
-                snapshot.threads,
-                section: section,
-                now: .now
-            ),
+        let threadsByID = Dictionary(
+            snapshot.threads.map { ($0.id, $0) },
+            uniquingKeysWith: { first, _ in first }
+        )
+        guard let assignments = ThreadOrderPlanner.planDrop(
+            ordered: orderedIDs.compactMap { threadsByID[$0] },
             all: snapshot.threads,
             section: section,
-            connectedEnvironmentIDs: connectedEnvironmentIDs
-        )
-        guard let assignments = planner(thread, direction), !assignments.isEmpty else {
+            connectedEnvironmentIDs: connectedEnvironmentIDs,
+            movedID: id
+        ) else {
             return []
         }
 
diff --git a/apps/swift-ios/Features/Root/FeatureRootModel.swift b/apps/swift-ios/Features/Root/FeatureRootModel.swift
index 7673e613eaab..bcc96dae585f 100644
--- a/apps/swift-ios/Features/Root/FeatureRootModel.swift
+++ b/apps/swift-ios/Features/Root/FeatureRootModel.swift
@@ -561,38 +561,44 @@ public final class FeatureRootModel {
         }
     }
 
-    /// Move up / Move down availability for a thread row, planned on demand
-    /// against the canonical section (every connected environment). Nil when
-    /// the row's environment predates reordering or is not connected.
-    public func moveOptions(for thread: FeatureThread) -> FeatureThreadMoveOptions? {
-        let connectedEnvironmentIDs = Set(
-            snapshot.environments
-                .filter { $0.connectionState == .connected }
-                .map(\.id)
-        )
-        return DailyUXSidebarIndex.moveOptions(
-            for: thread,
-            in: snapshot.threads,
-            now: .now,
-            connectedEnvironmentIDs: connectedEnvironmentIDs
-        )
+    /// Whether a thread row can lift for drag reordering: its environment
+    /// accepts reorder writes for its section and is currently connected.
+    public func canReorder(_ thread: FeatureThread) -> Bool {
+        let section: FeatureThreadOrderSection = thread.pinnedAt != nil ? .pinned : .active
+        guard ThreadOrderPlanner.isWritable(thread, section: section) else { return false }
+        return snapshot.environments.contains {
+            $0.id == thread.environmentID && $0.connectionState == .connected
+        }
     }
 
-    public func moveThread(_ id: String, direction: FeatureThreadMoveDirection) async {
+    /// Commits a dropped order: `orderedIDs` is the section's displayed order
+    /// with the dragged row already in its new slot. Returns false when the
+    /// write was rejected or failed so the collection view can snap the row
+    /// back.
+    @discardableResult
+    public func reorderThread(
+        _ id: String,
+        section: FeatureThreadOrderSection,
+        orderedIDs: [String]
+    ) async -> Bool {
         let environment = currentEnvironmentIdentity
-        await perform {
-            // The section is fixed by the plan the client is about to run —
-            // reading it after the await would misapply confirmed keys if a
-            // pin/unpin landed in between.
-            let section: FeatureThreadOrderSection = snapshot.threads
-                .first(where: { $0.id == id })?.pinnedAt != nil ? .pinned : .active
-            do {
-                let assignments = try await client.moveThread(id: id, direction: direction)
-                applyMoveAssignments(assignments, section: section, environment: environment)
-            } catch let partial as FeatureThreadMovePartialError {
-                applyMoveAssignments(partial.confirmed, section: section, environment: environment)
-                throw partial.underlying
-            }
+        do {
+            let assignments = try await client.reorderThread(
+                id: id,
+                section: section,
+                orderedIDs: orderedIDs
+            )
+            applyMoveAssignments(assignments, section: section, environment: environment)
+            return !assignments.isEmpty
+        } catch let partial as FeatureThreadMovePartialError {
+            applyMoveAssignments(partial.confirmed, section: section, environment: environment)
+            await perform { throw partial.underlying }
+            // Confirmed keys are in the model; snapping back renders the true
+            // arrangement instead of holding a full order that never landed.
+            return false
+        } catch {
+            await perform { throw error }
+            return false
         }
     }
 
diff --git a/apps/swift-ios/Features/Shared/FeatureClient.swift b/apps/swift-ios/Features/Shared/FeatureClient.swift
index db1628e3eb2b..72ff399618e1 100644
--- a/apps/swift-ios/Features/Shared/FeatureClient.swift
+++ b/apps/swift-ios/Features/Shared/FeatureClient.swift
@@ -52,13 +52,15 @@ public protocol FeatureClient: AnyObject {
     func setThreadSettled(id: String, settled: Bool) async throws
     func setThreadSnoozed(id: String, until: Date?) async throws
     func setThreadPinned(id: String, pinned: Bool) async throws
-    /// Executes a Move up / Move down on the thread's list section. Returns
-    /// the order-key assignments the server confirmed; an empty result means
-    /// the move was unavailable (capability or section edge).
+    /// Commits a drag reorder: `orderedIDs` is the thread's displayed section
+    /// order after the drop. Returns the order-key assignments the server
+    /// confirmed; an empty result means the move was unavailable (capability,
+    /// connectivity, or an unwritable neighbor).
     @discardableResult
-    func moveThread(
+    func reorderThread(
         id: String,
-        direction: FeatureThreadMoveDirection
+        section: FeatureThreadOrderSection,
+        orderedIDs: [String]
     ) async throws -> [FeatureThreadOrderAssignment]
     func setRuntimeMode(id: String, mode: FeatureRuntimeMode) async throws
     func setInteractionMode(id: String, mode: FeatureInteractionMode) async throws
@@ -406,9 +408,10 @@ public extension FeatureClient {
     func setThreadSettled(id: String, settled: Bool) async throws {}
     func setThreadSnoozed(id: String, until: Date?) async throws {}
     func setThreadPinned(id: String, pinned: Bool) async throws {}
-    func moveThread(
+    func reorderThread(
         id: String,
-        direction: FeatureThreadMoveDirection
+        section: FeatureThreadOrderSection,
+        orderedIDs: [String]
     ) async throws -> [FeatureThreadOrderAssignment] { [] }
     func setRuntimeMode(id: String, mode: FeatureRuntimeMode) async throws {}
     func setInteractionMode(id: String, mode: FeatureInteractionMode) async throws {}
diff --git a/apps/swift-ios/Features/Shared/FeatureModels.swift b/apps/swift-ios/Features/Shared/FeatureModels.swift
index 94625687c074..9c358f9713cd 100644
--- a/apps/swift-ios/Features/Shared/FeatureModels.swift
+++ b/apps/swift-ios/Features/Shared/FeatureModels.swift
@@ -443,18 +443,13 @@ public struct FeatureThread: Identifiable, Sendable, Equatable, Hashable, Codabl
 
 }
 
-/// The thread-list section a context-menu move arranges. Pinned threads write
+/// The thread-list section a drag reorder arranges. Pinned threads write
 /// `pinOrderKey`; active threads write `activeOrderKey`.
 public enum FeatureThreadOrderSection: String, Sendable, Equatable {
     case pinned
     case active
 }
 
-public enum FeatureThreadMoveDirection: String, Sendable, Equatable {
-    case up
-    case down
-}
-
 /// One `orderKey` write needed to realize a move. A move between keyed
 /// neighbors produces a single assignment on the moved thread; a move next to
 /// keyless threads rewrites the whole section (see ThreadOrderPlanner).
diff --git a/apps/swift-ios/Features/Workspace/DailyUXModels.swift b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
index b1d1943898e8..059047939769 100644
--- a/apps/swift-ios/Features/Workspace/DailyUXModels.swift
+++ b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
@@ -744,37 +744,9 @@ struct DailyUXSidebarIndex {
         )
     }
 
-    /// Move up / Move down availability for one row, planned against the
-    /// canonical section (every environment, before project filtering and
-    /// search). Nil when the thread's environment predates reordering or is
-    /// not in `connectedEnvironmentIDs` — a move planned against a
-    /// disconnected server's stale keys would target a dead client.
-    /// Built on demand when a context menu opens — the same per-row check
-    /// React Native runs — rather than once per row per index rebuild.
-    static func moveOptions(
-        for thread: FeatureThread,
-        in threads: [FeatureThread],
-        now: Date,
-        connectedEnvironmentIDs: Set<String>
-    ) -> FeatureThreadMoveOptions? {
-        let section: FeatureThreadOrderSection = thread.pinnedAt != nil ? .pinned : .active
-        guard ThreadOrderPlanner.isWritable(thread, section: section),
-              connectedEnvironmentIDs.contains(thread.environmentID ?? "") else { return nil }
-        let planner = ThreadOrderPlanner.movePlanner(
-            ordered: orderedSection(threads, section: section, now: now),
-            all: threads,
-            section: section,
-            connectedEnvironmentIDs: connectedEnvironmentIDs
-        )
-        return FeatureThreadMoveOptions(
-            canMoveUp: planner(thread, .up) != nil,
-            canMoveDown: planner(thread, .down) != nil
-        )
-    }
-
     /// The pinned or active list in display order, independent of project
     /// filtering and search — the same canonical section React Native plans
-    /// `thread.pin.reorder` / `thread.active.reorder` against, so a menu move
+    /// `thread.pin.reorder` / `thread.active.reorder` against, so a reorder
     /// means the same thing no matter which rows are on screen.
     static func orderedSection(
         _ threads: [FeatureThread],
diff --git a/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift b/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
index 2ee0ea8348d9..ab7c8093ab3f 100644
--- a/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
+++ b/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
@@ -25,8 +25,18 @@ struct HomeThreadCollectionView: UIViewRepresentable {
     let onSettle: (FeatureThread, Bool, @escaping (Bool) -> Void) -> Void
     let onSnooze: (FeatureThread, Date?) -> Void
     let onPin: (FeatureThread, Bool) -> Void
-    let onMove: (FeatureThread, FeatureThreadMoveDirection) -> Void
-    let onMoveOptions: (FeatureThread) -> FeatureThreadMoveOptions?
+    /// Whether the row can lift for drag reordering (reorder-capable,
+    /// connected environment).
+    let onCanReorder: (FeatureThread) -> Bool
+    /// Commits a drop: the thread, its section, and the section's displayed
+    /// thread order after the drop. Completion reports whether the writes
+    /// landed so the view can snap back on failure.
+    let onReorder: (
+        FeatureThread,
+        FeatureThreadOrderSection,
+        [String],
+        @escaping (Bool) -> Void
+    ) -> Void
     let onDelete: (FeatureThread) -> Void
     let onPullRequestChange: (String, String, HomeThreadPullRequestPresentation?) -> Void
 
@@ -54,6 +64,11 @@ struct HomeThreadCollectionView: UIViewRepresentable {
         collectionView.contentInset = UIEdgeInsets(top: 4, left: 0, bottom: 74, right: 0)
         collectionView.verticalScrollIndicatorInsets = UIEdgeInsets(top: 4, left: 0, bottom: 74, right: 0)
         collectionView.delegate = context.coordinator
+        // Long-press-and-drag reorders a row inside its section; a stationary
+        // hold still opens the context menu (UIKit resolves the two).
+        collectionView.dragInteractionEnabled = true
+        collectionView.dragDelegate = context.coordinator
+        collectionView.dropDelegate = context.coordinator
         context.coordinator.configure(collectionView)
         return collectionView
     }
@@ -66,10 +81,13 @@ struct HomeThreadCollectionView: UIViewRepresentable {
         coordinator.invalidateTimer()
         coordinator.cancelPendingSwipeActions()
         collectionView.delegate = nil
+        collectionView.dragDelegate = nil
+        collectionView.dropDelegate = nil
     }
 
     @MainActor
-    final class Coordinator: NSObject, UICollectionViewDelegate {
+    final class Coordinator: NSObject, UICollectionViewDelegate,
+        UICollectionViewDragDelegate, UICollectionViewDropDelegate {
         private enum Section: Hashable {
             case main
         }
@@ -80,6 +98,16 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             let finish: (Bool) -> Void
         }
 
+        /// A drop the collection view already shows but the model has not
+        /// caught up with yet: stream updates keep displaying this order until
+        /// the reorder write confirms or fails.
+        private struct PendingReorder {
+            let id: UUID
+            let section: FeatureThreadOrderSection
+            let orderedThreadIDs: [String]
+            let deadline: Date
+        }
+
         private var parent: HomeThreadCollectionView
         private var dataSource: UICollectionViewDiffableDataSource<Section, HomeCollectionItem.ID>?
         private var registration: UICollectionView.CellRegistration<HomeCollectionCell, HomeCollectionItem.ID>?
@@ -92,6 +120,8 @@ struct HomeThreadCollectionView: UIViewRepresentable {
         private var timerTick = 0
         private var timerInterval: TimeInterval = 0
         private var pendingSwipeCompletions: [String: PendingSwipeCompletion] = [:]
+        private var draggedThread: (id: String, section: FeatureThreadOrderSection)?
+        private var pendingReorder: PendingReorder?
         private var isApplyingSnapshot = false
         private var hasQueuedUpdate = false
 
@@ -109,7 +139,7 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             }
             self.registration = registration
 
-            dataSource = UICollectionViewDiffableDataSource<Section, HomeCollectionItem.ID>(
+            let dataSource = UICollectionViewDiffableDataSource<Section, HomeCollectionItem.ID>(
                 collectionView: collectionView
             ) { [weak self] collectionView, indexPath, identifier in
                 guard let self, let registration = self.registration else { return nil }
@@ -119,6 +149,19 @@ struct HomeThreadCollectionView: UIViewRepresentable {
                     item: identifier
                 )
             }
+            // The data source applies a same-view reorder drop itself; the
+            // drop's commit to the server happens in didReorder.
+            var reorderingHandlers = UICollectionViewDiffableDataSource<
+                Section, HomeCollectionItem.ID
+            >.ReorderingHandlers()
+            reorderingHandlers.canReorderItem = { [weak self] identifier in
+                self?.isReorderable(identifier) ?? false
+            }
+            reorderingHandlers.didReorder = { [weak self] transaction in
+                self?.didReorder(transaction)
+            }
+            dataSource.reorderingHandlers = reorderingHandlers
+            self.dataSource = dataSource
 
             update(parent: parent, collectionView: collectionView)
         }
@@ -131,8 +174,11 @@ struct HomeThreadCollectionView: UIViewRepresentable {
 
         /// Keep a row's content and size fixed during its removal. Stream updates
         /// that arrive mid-animation are applied together after that animation.
+        /// Updates also wait out an active drag so a lifted row's snapshot does
+        /// not shift under the user's finger.
         private func applyLatestSnapshot(in collectionView: UICollectionView) {
-            guard !isApplyingSnapshot, hasQueuedUpdate, let dataSource else { return }
+            guard !isApplyingSnapshot, hasQueuedUpdate,
+                  !collectionView.hasActiveDrag, let dataSource else { return }
             hasQueuedUpdate = false
             let previousItems = itemsByID
             let previousThreadItemIDs = threadItemIDs
@@ -159,7 +205,22 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             startTimer()
 
             let currentIdentifiers = dataSource.snapshot().itemIdentifiers
-            let newIdentifiers = items.map(\.id)
+            var newIdentifiers = items.map(\.id)
+            if let pending = pendingReorder {
+                // Converged once the rows still present carry the dropped
+                // order — rows joining or leaving mid-write don't count.
+                let natural = sectionThreadIDs(in: newIdentifiers, section: pending.section)
+                let held = Set(pending.orderedThreadIDs)
+                let caughtUp = natural.filter(held.contains)
+                    == pending.orderedThreadIDs.filter(Set(natural).contains)
+                if caughtUp || Date.now > pending.deadline {
+                    pendingReorder = nil
+                } else {
+                    // The drop already shows; hold its order until the write
+                    // lands so a mid-flight stream update cannot revert it.
+                    newIdentifiers = applyingPendingReorder(pending, to: newIdentifiers)
+                }
+            }
             let resolvedSwipes = pendingSwipeCompletions.filter { threadID, pending in
                 guard let identifier = threadItemIDs[threadID],
                       case let .thread(thread, _, _, _, _, _) = itemsByID[identifier] else {
@@ -292,6 +353,258 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             }
         }
 
+        // MARK: - Drag to reorder
+
+        /// A row lifts for reordering only when its environment can take the
+        /// write right now — `onCanReorder` is false for pre-reorder servers
+        /// and disconnected environments. Lifts are also blocked while an
+        /// earlier drop's write is still outstanding, since the client runs
+        /// one reorder at a time and a second would snap back on top of it.
+        private func isReorderable(_ identifier: HomeCollectionItem.ID) -> Bool {
+            guard pendingReorder == nil,
+                  case let .thread(_, shelf) = identifier,
+                  shelf == .active,
+                  let item = itemsByID[identifier],
+                  case let .thread(thread, _, _, _, _, _) = item else { return false }
+            return parent.onCanReorder(thread)
+        }
+
+        /// Item-index bounds of a section's displayed rows. `upper` sits just
+        /// past the last row — on the pinned divider, a shelf header, or one
+        /// past the list end — so an "insert before" drop there still lands
+        /// inside the section.
+        private func sectionBounds(
+            _ section: FeatureThreadOrderSection,
+            in identifiers: [HomeCollectionItem.ID]
+        ) -> (lower: Int, upper: Int)? {
+            var lower: Int?
+            var upper = 0
+            for (index, identifier) in identifiers.enumerated() {
+                guard case let .thread(_, shelf) = identifier,
+                      shelf == .active,
+                      let item = itemsByID[identifier],
+                      case let .thread(thread, _, _, _, _, _) = item,
+                      (thread.pinnedAt != nil) == (section == .pinned) else { continue }
+                if lower == nil { lower = index }
+                upper = index + 1
+            }
+            guard let lower else { return nil }
+            return (lower, upper)
+        }
+
+        /// The section's displayed thread order within an item list — the
+        /// same list a drop plans against on web (`planPinnedReorder` on the
+        /// displayed order, hidden rows' keys reserved by the client).
+        private func sectionThreadIDs(
+            in identifiers: [HomeCollectionItem.ID],
+            section: FeatureThreadOrderSection
+        ) -> [String] {
+            identifiers.compactMap { identifier in
+                guard case let .thread(threadID, shelf) = identifier,
+                      shelf == .active,
+                      let item = itemsByID[identifier],
+                      case let .thread(thread, _, _, _, _, _) = item,
+                      (thread.pinnedAt != nil) == (section == .pinned) else { return nil }
+                return threadID
+            }
+        }
+
+        /// Permute only the pending section's rows inside an identifier list;
+        /// headers, dividers, and the other section stay put.
+        private func applyingPendingReorder(
+            _ pending: PendingReorder,
+            to identifiers: [HomeCollectionItem.ID]
+        ) -> [HomeCollectionItem.ID] {
+            var rank: [String: Int] = [:]
+            for (index, threadID) in pending.orderedThreadIDs.enumerated() {
+                rank[threadID] = index
+            }
+            let regionIndices = identifiers.indices.filter { index in
+                guard case let .thread(_, shelf) = identifiers[index],
+                      shelf == .active,
+                      let item = itemsByID[identifiers[index]],
+                      case let .thread(thread, _, _, _, _, _) = item else { return false }
+                return (thread.pinnedAt != nil) == (pending.section == .pinned)
+            }
+            let reordered = regionIndices
+                .map { identifiers[$0] }
+                .enumerated()
+                .sorted { left, right in
+                    let leftRank = left.element.threadID.flatMap { rank[$0] } ?? .max
+                    let rightRank = right.element.threadID.flatMap { rank[$0] } ?? .max
+                    return leftRank != rightRank ? leftRank < rightRank : left.offset < right.offset
+                }
+                .map(\.element)
+            var result = identifiers
+            for (position, index) in regionIndices.enumerated() {
+                result[index] = reordered[position]
+            }
+            return result
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            itemsForBeginning session: UIDragSession,
+            at indexPath: IndexPath
+        ) -> [UIDragItem] {
+            guard let identifier = dataSource?.itemIdentifier(for: indexPath),
+                  isReorderable(identifier),
+                  case let .thread(thread, _, _, _, _, _) = itemsByID[identifier] else {
+                return []
+            }
+            draggedThread = (
+                id: thread.id,
+                section: thread.pinnedAt != nil ? .pinned : .active
+            )
+            let dragItem = UIDragItem(itemProvider: NSItemProvider())
+            dragItem.localObject = thread.id
+            return [dragItem]
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            itemsForAddingTo session: UIDragSession,
+            at indexPath: IndexPath,
+            point: CGPoint
+        ) -> [UIDragItem] {
+            []
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            dragSessionAllowsMoveOperation session: UIDragSession
+        ) -> Bool {
+            true
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            dragSessionIsRestrictedToDraggingBounds session: UIDragSession
+        ) -> Bool {
+            true
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            dragSessionWillBegin session: UIDragSession
+        ) {
+            PlatformHapticEngine.shared.selection(enabled: parent.hapticsEnabled)
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            dragSessionDidEnd session: UIDragSession
+        ) {
+            draggedThread = nil
+            // Flush any update deferred while the row was lifted.
+            applyLatestSnapshot(in: collectionView)
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            dropSessionDidUpdate session: UIDropSession,
+            withDestinationIndexPath destinationIndexPath: IndexPath?
+        ) -> UICollectionViewDropProposal {
+            guard session.localDragSession != nil,
+                  let dragged = draggedThread,
+                  let identifiers = dataSource?.snapshot().itemIdentifiers,
+                  let bounds = sectionBounds(dragged.section, in: identifiers) else {
+                return UICollectionViewDropProposal(operation: .forbidden)
+            }
+            if let destinationIndexPath {
+                let within = destinationIndexPath.section == 0
+                    && destinationIndexPath.item >= bounds.lower
+                    && destinationIndexPath.item <= bounds.upper
+                return UICollectionViewDropProposal(
+                    operation: within ? .move : .forbidden,
+                    intent: .insertAtDestinationIndexPath
+                )
+            }
+            // Hovering past the last row only works when the section runs to
+            // the end of the list (no shelves below it).
+            return UICollectionViewDropProposal(
+                operation: bounds.upper >= identifiers.count ? .move : .forbidden,
+                intent: .insertAtDestinationIndexPath
+            )
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            performDropWith coordinator: UICollectionViewDropCoordinator
+        ) {
+            guard coordinator.session.localDragSession != nil,
+                  let dragged = draggedThread,
+                  let dataSource,
+                  let item = coordinator.items.first else { return }
+            if let destinationIndexPath = coordinator.destinationIndexPath {
+                // Clamped into the section by dropSessionDidUpdate; the data
+                // source applies the move and reports it via didReorder.
+                coordinator.drop(item.dragItem, toItemAt: destinationIndexPath)
+                return
+            }
+            // Dropped past the last row of a section that ends the list:
+            // move the row there ourselves (no system move, no didReorder).
+            let identifiers = dataSource.snapshot().itemIdentifiers
+            guard let bounds = sectionBounds(dragged.section, in: identifiers),
+                  bounds.upper >= identifiers.count,
+                  let draggedIdentifier = threadItemIDs[dragged.id],
+                  let lastIdentifier = identifiers.last,
+                  draggedIdentifier != lastIdentifier else { return }
+            var snapshot = dataSource.snapshot()
+            snapshot.deleteItems([draggedIdentifier])
+            snapshot.insertItems([draggedIdentifier], afterItem: lastIdentifier)
+            dataSource.apply(snapshot, animatingDifferences: true)
+            commitReorder(section: dragged.section, identifiers: snapshot.itemIdentifiers)
+        }
+
+        private func didReorder(
+            _ transaction: NSDiffableDataSourceTransaction<Section, HomeCollectionItem.ID>
+        ) {
+            guard let dragged = draggedThread else { return }
+            commitReorder(
+                section: dragged.section,
+                identifiers: transaction.finalSnapshot.itemIdentifiers
+            )
+        }
+
+        /// Hand the dropped order to the model. A failed write snaps the rows
+        /// back; a confirmed one holds until the next snapshot carries it.
+        private func commitReorder(
+            section: FeatureThreadOrderSection,
+            identifiers: [HomeCollectionItem.ID]
+        ) {
+            // One commit per drop: a second path firing for the same drop
+            // would overwrite the hold and race the in-flight write.
+            guard pendingReorder == nil,
+                  let dragged = draggedThread,
+                  let identifier = threadItemIDs[dragged.id],
+                  case let .thread(thread, _, _, _, _, _) = itemsByID[identifier] else { return }
+            let orderedIDs = sectionThreadIDs(in: identifiers, section: section)
+            // A drop back onto the same slot changes nothing — skip the write.
+            let unchanged = sectionThreadIDs(
+                in: parent.collectionItems.map(\.id),
+                section: section
+            )
+            guard orderedIDs.contains(dragged.id), orderedIDs != unchanged else { return }
+            PlatformHapticEngine.shared.selection(enabled: parent.hapticsEnabled)
+            let completionID = UUID()
+            pendingReorder = PendingReorder(
+                id: completionID,
+                section: section,
+                orderedThreadIDs: orderedIDs,
+                deadline: .now.addingTimeInterval(10)
+            )
+            parent.onReorder(thread, section, orderedIDs) { [weak self] succeeded in
+                guard let self,
+                      !succeeded,
+                      self.pendingReorder?.id == completionID,
+                      let collectionView = self.collectionView else { return }
+                self.pendingReorder = nil
+                self.hasQueuedUpdate = true
+                self.applyLatestSnapshot(in: collectionView)
+            }
+        }
+
         func trailingSwipeActions(at indexPath: IndexPath) -> UISwipeActionsConfiguration? {
             guard case let .thread(thread, _, _, isArchived, _, _) = item(at: indexPath) else {
                 return nil
@@ -713,28 +1026,6 @@ struct HomeThreadCollectionView: UIViewRepresentable {
 
             var statusActions: [UIMenuElement] = []
             if !isArchived {
-                // Planned against the canonical section when the menu opens;
-                // nil means the row's environment predates reordering, and a
-                // false direction means the move has no valid plan (edge of
-                // the section or an unwritable neighbor).
-                if let moveOptions = parent.onMoveOptions(thread) {
-                    for direction in [FeatureThreadMoveDirection.up, .down] {
-                        let enabled = direction == .up
-                            ? moveOptions.canMoveUp
-                            : moveOptions.canMoveDown
-                        statusActions.append(
-                            UIAction(
-                                title: direction == .up ? "Move up" : "Move down",
-                                image: UIImage(
-                                    systemName: direction == .up ? "arrow.up" : "arrow.down"
-                                ),
-                                attributes: enabled ? [] : .disabled
-                            ) { [weak self] _ in
-                                self?.parent.onMove(thread, direction)
-                            }
-                        )
-                    }
-                }
                 if thread.canTogglePin {
                     let isPinned = thread.pinnedAt != nil
                     statusActions.append(
diff --git a/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift b/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift
index 76faf0c26629..164918873d60 100644
--- a/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift
+++ b/apps/swift-ios/Features/Workspace/ThreadOrderPlanner.swift
@@ -99,43 +99,55 @@ enum ThreadOrderPlanner {
         }
     }
 
-    /// `planReorder` specialized for the Move up / Move down menu actions:
-    /// swap the moved thread with its displayed neighbor. Nil when the move
-    /// falls off either end of the section. Same single-write-per-move
-    /// semantics as a web drag.
-    static func planMove(
-        orderedIDs: [String],
-        keysByID: [String: String?],
-        movedID: String,
-        direction: FeatureThreadMoveDirection
-    ) -> [FeatureThreadOrderAssignment]? {
-        guard let from = orderedIDs.firstIndex(of: movedID) else { return nil }
-        let to = direction == .up ? from - 1 : from + 1
-        guard to >= 0, to < orderedIDs.count else { return nil }
-        var newOrder = orderedIDs
-        newOrder.remove(at: from)
-        newOrder.insert(movedID, at: to)
-        return planReorder(orderedIDs: newOrder, keysByID: keysByID, movedID: movedID)
-    }
-
-    /// Keeps every visible row as an anchor but only offers plans whose key
-    /// writes are supported — the same rule React Native applies to Move up /
-    /// Move down, so menu availability and execution share one plan. Rows in
-    /// environments outside `connectedEnvironmentIDs` stay anchors but are
-    /// never written: their last-known keys are stale, and a write would go
-    /// to a dead client.
-    static func movePlanner(
+    /// Planner for a drag drop: `ordered` is the section's displayed order
+    /// after the drop (same input web passes to `planPinnedReorder`).
+    /// `all` keeps hidden rows' keys reserved. Every visible row anchors its
+    /// position but a plan exists only when the moved row — and every row a
+    /// spread rewrite would touch — can be written: reorder-capable and in
+    /// `connectedEnvironmentIDs`. Rows on disconnected servers keep their
+    /// stale keys as anchors and are never written, so a spread rewrite
+    /// cannot half-land on a dead client.
+    static func planDrop(
         ordered: [FeatureThread],
         all: [FeatureThread],
         section: FeatureThreadOrderSection,
-        connectedEnvironmentIDs: Set<String>
-    ) -> (FeatureThread, FeatureThreadMoveDirection) -> [FeatureThreadOrderAssignment]? {
-        let orderedIDs = ordered.map(\.id)
+        connectedEnvironmentIDs: Set<String>,
+        movedID: String
+    ) -> [FeatureThreadOrderAssignment]? {
+        let writableIDs = writableIDs(
+            in: ordered,
+            section: section,
+            connectedEnvironmentIDs: connectedEnvironmentIDs
+        )
+        guard writableIDs.contains(movedID) else { return nil }
+        let assignments = planReorder(
+            orderedIDs: ordered.map(\.id),
+            keysByID: keysByID(all, section: section),
+            movedID: movedID
+        )
+        guard !assignments.isEmpty,
+              assignments.allSatisfy({ writableIDs.contains($0.threadID) })
+        else { return nil }
+        return assignments
+    }
+
+    private static func keysByID(
+        _ all: [FeatureThread],
+        section: FeatureThreadOrderSection
+    ) -> [String: String?] {
         var keysByID: [String: String?] = [:]
         for thread in all {
             keysByID[thread.id] = section == .pinned ? thread.pinOrderKey : thread.activeOrderKey
         }
-        let writableIDs = Set(
+        return keysByID
+    }
+
+    private static func writableIDs(
+        in ordered: [FeatureThread],
+        section: FeatureThreadOrderSection,
+        connectedEnvironmentIDs: Set<String>
+    ) -> Set<String> {
+        Set(
             ordered
                 .filter {
                     isWritable($0, section: section)
@@ -143,19 +155,6 @@ enum ThreadOrderPlanner {
                 }
                 .map(\.id)
         )
-        return { thread, direction in
-            guard writableIDs.contains(thread.id),
-                  let assignments = planMove(
-                      orderedIDs: orderedIDs,
-                      keysByID: keysByID,
-                      movedID: thread.id,
-                      direction: direction
-                  ),
-                  !assignments.isEmpty,
-                  assignments.allSatisfy({ writableIDs.contains($0.threadID) })
-            else { return nil }
-            return assignments
-        }
     }
 
     private static func isValidKey(_ key: String) -> Bool {
@@ -195,16 +194,3 @@ enum ThreadOrderPlanner {
         return String(digits[digitA]) + midpoint(String(a.dropFirst()), "")
     }
 }
-
-/// Move up / Move down availability for one thread row. A present value means
-/// the row's environment supports reordering its section; each direction
-/// stays enabled only while a plan exists for it.
-public struct FeatureThreadMoveOptions: Equatable, Sendable {
-    public let canMoveUp: Bool
-    public let canMoveDown: Bool
-
-    public init(canMoveUp: Bool, canMoveDown: Bool) {
-        self.canMoveUp = canMoveUp
-        self.canMoveDown = canMoveDown
-    }
-}
diff --git a/apps/swift-ios/Features/Workspace/WorkspaceView.swift b/apps/swift-ios/Features/Workspace/WorkspaceView.swift
index dfbc8578b5fb..87678f4b0952 100644
--- a/apps/swift-ios/Features/Workspace/WorkspaceView.swift
+++ b/apps/swift-ios/Features/Workspace/WorkspaceView.swift
@@ -252,11 +252,17 @@ public struct WorkspaceView: View {
                 onPin: { thread, pinned in
                     Task { await model.setPinned(thread.id, pinned: pinned) }
                 },
-                onMove: { thread, direction in
-                    Task { await model.moveThread(thread.id, direction: direction) }
+                onCanReorder: { thread in
+                    model.canReorder(thread)
                 },
-                onMoveOptions: { thread in
-                    model.moveOptions(for: thread)
+                onReorder: { thread, section, orderedIDs, completion in
+                    Task {
+                        completion(await model.reorderThread(
+                            thread.id,
+                            section: section,
+                            orderedIDs: orderedIDs
+                        ))
+                    }
                 },
                 onDelete: { thread in
                     deletingThread = thread
diff --git a/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift b/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
index 18f884f630ee..1abf6b28715f 100644
--- a/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
+++ b/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
@@ -1182,8 +1182,8 @@ struct HomeThreadSwipeActionTests {
             },
             onSnooze: { _, _ in },
             onPin: { _, _ in },
-            onMove: { _, _ in },
-            onMoveOptions: { _ in nil },
+            onCanReorder: { _ in false },
+            onReorder: { _, _, _, completion in completion(true) },
             onDelete: { _ in },
             onPullRequestChange: { _, _, _ in }
         )
diff --git a/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift b/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift
index de4bf5c94b95..bfbe8c7060d4 100644
--- a/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift
+++ b/apps/swift-ios/Tests/FeatureTests/ThreadOrderPlannerTests.swift
@@ -71,47 +71,33 @@ struct ThreadOrderPlannerTests {
         }
     }
 
-    // MARK: - planMove
+    // MARK: - planReorder
 
     @Test
-    func moveUpWritesASingleKeyOnTheMovedThread() {
-        let assignments = ThreadOrderPlanner.planMove(
-            orderedIDs: ["a", "b", "c"],
+    func reorderWritesASingleKeyOnTheMovedThread() {
+        let assignments = ThreadOrderPlanner.planReorder(
+            orderedIDs: ["a", "c", "b"],
             keysByID: ["a": "f", "b": "m", "c": "t"],
-            movedID: "c",
-            direction: .up
+            movedID: "c"
         )
-        #expect(assignments?.count == 1)
-        #expect(assignments?[0].threadID == "c")
-        #expect(assignments![0].orderKey > "f")
-        #expect(assignments![0].orderKey < "m")
-    }
-
-    @Test
-    func movesOffTheSectionEndsReturnNil() {
-        let keys: [String: String?] = ["a": "f", "b": "m"]
-        #expect(ThreadOrderPlanner.planMove(
-            orderedIDs: ["a", "b"], keysByID: keys, movedID: "a", direction: .up
-        ) == nil)
-        #expect(ThreadOrderPlanner.planMove(
-            orderedIDs: ["a", "b"], keysByID: keys, movedID: "b", direction: .down
-        ) == nil)
+        #expect(assignments.count == 1)
+        #expect(assignments[0].threadID == "c")
+        #expect(assignments[0].orderKey > "f")
+        #expect(assignments[0].orderKey < "m")
     }
 
     @Test
     func keylessNeighborMaterializesTheWholeSectionInTheNewOrder() {
-        let assignments = ThreadOrderPlanner.planMove(
-            orderedIDs: ["a", "b", "c"],
+        let assignments = ThreadOrderPlanner.planReorder(
+            orderedIDs: ["b", "a", "c"],
             keysByID: ["a": nil, "b": "m", "c": nil],
-            movedID: "b",
-            direction: .up
+            movedID: "b"
         )
-        #expect(assignments != nil)
-        let keys = assignments!.map(\.orderKey)
+        let keys = assignments.map(\.orderKey)
         #expect(keys.sorted() == keys)
         // The requested order is [b, a, c]: b's new key sorts first.
         let keyByID = Dictionary(
-            uniqueKeysWithValues: assignments!.map { ($0.threadID, $0.orderKey) }
+            uniqueKeysWithValues: assignments.map { ($0.threadID, $0.orderKey) }
         )
         #expect(keyByID["b"]! < keyByID["a"]!)
         #expect(keyByID["a"]! < keyByID["c"]!)
@@ -119,16 +105,15 @@ struct ThreadOrderPlannerTests {
 
     @Test
     func keylessThreadMovesIntoTheArrangedRunWithOneWrite() {
-        let assignments = ThreadOrderPlanner.planMove(
-            orderedIDs: ["new", "reopened", "first", "last"],
+        let assignments = ThreadOrderPlanner.planReorder(
+            orderedIDs: ["new", "first", "reopened", "last"],
             keysByID: ["new": nil, "reopened": nil, "first": "f", "last": "t"],
-            movedID: "reopened",
-            direction: .down
+            movedID: "reopened"
         )
-        #expect(assignments?.count == 1)
-        #expect(assignments?[0].threadID == "reopened")
-        #expect(assignments![0].orderKey > "f")
-        #expect(assignments![0].orderKey < "t")
+        #expect(assignments.count == 1)
+        #expect(assignments[0].threadID == "reopened")
+        #expect(assignments[0].orderKey > "f")
+        #expect(assignments[0].orderKey < "t")
     }
 
     // MARK: - hidden-row reservations
@@ -167,109 +152,165 @@ struct ThreadOrderPlannerTests {
         #expect(keys.allSatisfy { !reserved.contains($0) })
     }
 
-    // MARK: - movePlanner / moveOptions capability gating
+    // MARK: - planDrop capability gating
 
     @Test
-    func movePlannerRequiresReorderSupportOnEveryAssignedEnvironment() {
-        let envA = sectionThreads(
+    func dropRequiresTheSectionCapabilityOnTheMovedEnvironment() {
+        // env-a supports pinned reordering but not active reordering: its
+        // active rows cannot be written in the active section.
+        let threads = sectionThreads(
             environmentID: "env-a",
-            pinned: true,
-            keys: ["a-1": "f", "a-2": "t"],
-            supportsPinReorder: true
+            pinned: false,
+            keys: ["a-1": "f", "a-2": "m"],
+            supportsPinReorder: true,
+            supportsActiveReorder: false
         )
-        // env-b predates reordering: its rows stay keyless and unwritable.
-        let envB = sectionThreads(
-            environmentID: "env-b",
+        let ordered = DailyUXSidebarIndex.orderedSection(threads, section: .active, now: now)
+        #expect(ThreadOrderPlanner.planDrop(
+            ordered: [ordered[1], ordered[0]],
+            all: threads,
+            section: .active,
+            connectedEnvironmentIDs: ["env-a"],
+            movedID: "env-a:a-2"
+        ) == nil)
+        // The same row is writable in the pinned section.
+        let pinned = sectionThreads(
+            environmentID: "env-a",
             pinned: true,
-            keys: ["b-1": nil],
-            supportsPinReorder: false
+            keys: ["a-1": "f", "a-2": "m"],
+            supportsPinReorder: true,
+            supportsActiveReorder: false
         )
-        let all = envA + envB
-        let ordered = DailyUXSidebarIndex.orderedSection(all, section: .pinned, now: now)
-        // Keyed rows first (env-a), keyless env-b row last.
-        #expect(ordered.map(\.id) == ["env-a:a-1", "env-a:a-2", "env-b:b-1"])
-
-        let planner = ThreadOrderPlanner.movePlanner(
-            ordered: ordered,
-            all: all,
+        let pinnedOrdered = DailyUXSidebarIndex.orderedSection(pinned, section: .pinned, now: now)
+        #expect(ThreadOrderPlanner.planDrop(
+            ordered: [pinnedOrdered[1], pinnedOrdered[0]],
+            all: pinned,
             section: .pinned,
-            connectedEnvironmentIDs: ["env-a", "env-b"]
-        )
-        // Single-key move within the writable environment works.
-        let moving = ordered.first { $0.id == "env-a:a-2" }!
-        let assignments = planner(moving, .up)
-        #expect(assignments?.count == 1)
-        #expect(assignments?[0].threadID == "env-a:a-2")
-
-        // Moving the env-a row down past the keyless env-b row would need a
-        // spread rewrite touching env-b — refused, like React Native.
-        let edge = ordered.first { $0.id == "env-a:a-2" }!
-        #expect(planner(edge, .down) == nil)
-
-        // The env-b row itself gets no plan at all.
-        let unwritable = ordered.first { $0.id == "env-b:b-1" }!
-        #expect(planner(unwritable, .up) == nil)
-        #expect(planner(unwritable, .down) == nil)
+            connectedEnvironmentIDs: ["env-a"],
+            movedID: "env-a:a-2"
+        ) != nil)
     }
 
+    // MARK: - planDrop (hold-and-drag reorder)
+
     @Test
-    func moveOptionsReportPerDirectionAvailabilityForWritableRowsOnly() {
+    func dropToSectionEndWritesASingleKeyBelowTheLastRow() {
         let threads = sectionThreads(
             environmentID: "env-a",
             pinned: true,
             keys: ["a-1": "f", "a-2": "m", "a-3": "t"],
             supportsPinReorder: true
-        ) + sectionThreads(
-            environmentID: "env-b",
-            pinned: true,
-            keys: ["b-1": "n"],
-            supportsPinReorder: false
         )
-        var options: [String: FeatureThreadMoveOptions] = [:]
-        for thread in threads {
-            if let value = DailyUXSidebarIndex.moveOptions(
-                for: thread,
-                in: threads,
-                now: now,
-                connectedEnvironmentIDs: ["env-a", "env-b"]
-            ) {
-                options[thread.id] = value
-            }
-        }
-        // Ordered by key: a-1(f), a-2(m), b-1(n), a-3(t).
-        #expect(options["env-a:a-1"] == FeatureThreadMoveOptions(canMoveUp: false, canMoveDown: true))
-        #expect(options["env-a:a-3"] == FeatureThreadMoveOptions(canMoveUp: true, canMoveDown: false))
-        // env-b's row sorts mid-list by key but cannot be written itself.
-        #expect(options["env-b:b-1"] == nil)
-        // Moving a-2 down past the keyed env-b row is still a single write on
-        // a-2, so it stays enabled.
-        #expect(options["env-a:a-2"] == FeatureThreadMoveOptions(canMoveUp: true, canMoveDown: true))
+        let ordered = DailyUXSidebarIndex.orderedSection(threads, section: .pinned, now: now)
+        #expect(ordered.map(\.id) == ["env-a:a-1", "env-a:a-2", "env-a:a-3"])
+
+        // Dragging the first row below the last: post-drop order [a-2, a-3, a-1].
+        let assignments = ThreadOrderPlanner.planDrop(
+            ordered: [ordered[1], ordered[2], ordered[0]],
+            all: threads,
+            section: .pinned,
+            connectedEnvironmentIDs: ["env-a"],
+            movedID: "env-a:a-1"
+        )
+        #expect(assignments?.count == 1)
+        #expect(assignments?[0].threadID == "env-a:a-1")
+        #expect(assignments![0].orderKey > "t")
     }
 
     @Test
-    func activeSectionUsesActiveOrderKeysAndCapability() {
+    func dropToSectionStartWritesASingleKeyAboveTheFirstRow() {
         let threads = sectionThreads(
             environmentID: "env-a",
             pinned: false,
-            keys: ["a-1": "f", "a-2": "m"],
+            keys: ["a-1": "f", "a-2": "m", "a-3": "t"],
             supportsActiveReorder: true
         )
         let ordered = DailyUXSidebarIndex.orderedSection(threads, section: .active, now: now)
-        let planner = ThreadOrderPlanner.movePlanner(
-            ordered: ordered,
+        // Keyless-first ordering does not apply here: every row is keyed, so
+        // keys decide — a-1(f), a-2(m), a-3(t).
+        #expect(ordered.map(\.id) == ["env-a:a-1", "env-a:a-2", "env-a:a-3"])
+
+        // Dragging the last row above the first: post-drop order [a-3, a-1, a-2].
+        let assignments = ThreadOrderPlanner.planDrop(
+            ordered: [ordered[2], ordered[0], ordered[1]],
             all: threads,
             section: .active,
-            connectedEnvironmentIDs: ["env-a"]
+            connectedEnvironmentIDs: ["env-a"],
+            movedID: "env-a:a-3"
         )
-        let assignments = planner(ordered[1], .up)
         #expect(assignments?.count == 1)
-        #expect(assignments?[0].threadID == "env-a:a-2")
+        #expect(assignments?[0].threadID == "env-a:a-3")
+        #expect(assignments![0].orderKey < "f")
     }
 
     @Test
-    func disconnectedEnvironmentRowsStayAnchorsButAreNeverWritten() {
-        // env-b is reorder-capable but currently disconnected: its last-known
-        // keys are stale, so its rows anchor positions without being writable.
+    func dropOntoKeylessNeighborsMaterializesTheSectionInTheDroppedOrder() {
+        // Pinned order: keyed a-2(m) first, then keyless by newest creation.
+        let threads = sectionThreads(
+            environmentID: "env-a",
+            pinned: true,
+            keys: ["a-1": nil, "a-2": "m", "a-3": nil],
+            supportsPinReorder: true
+        )
+        let ordered = DailyUXSidebarIndex.orderedSection(threads, section: .pinned, now: now)
+        #expect(ordered.map(\.id) == ["env-a:a-2", "env-a:a-1", "env-a:a-3"])
+
+        // Drag a-2 to the bottom: both new neighbors are keyless, so the whole
+        // section gets fresh spread keys in the dropped order.
+        let dropped = [ordered[1], ordered[2], ordered[0]]
+        let assignments = ThreadOrderPlanner.planDrop(
+            ordered: dropped,
+            all: threads,
+            section: .pinned,
+            connectedEnvironmentIDs: ["env-a"],
+            movedID: "env-a:a-2"
+        )
+        #expect(assignments?.map(\.threadID) == ["env-a:a-1", "env-a:a-3", "env-a:a-2"])
+        let keys = assignments!.map(\.orderKey)
+        #expect(keys.sorted() == keys)
+    }
+
+    @Test
+    func dropRejectsAPlanThatWouldWriteToAnUnwritableNeighbor() {
+        let writable = sectionThreads(
+            environmentID: "env-a",
+            pinned: true,
+            keys: ["a-1": "f"],
+            supportsPinReorder: true
+        )
+        // env-b predates reordering: keyless and unwritable.
+        let legacy = sectionThreads(
+            environmentID: "env-b",
+            pinned: true,
+            keys: ["b-1": nil],
+            supportsPinReorder: false
+        )
+        let all = writable + legacy
+        let ordered = DailyUXSidebarIndex.orderedSection(all, section: .pinned, now: now)
+        #expect(ordered.map(\.id) == ["env-a:a-1", "env-b:b-1"])
+
+        // Dragging a-1 below the keyless env-b row needs a spread rewrite that
+        // would assign b-1 a key — refused, no partial write.
+        let dropped = [ordered[1], ordered[0]]
+        #expect(ThreadOrderPlanner.planDrop(
+            ordered: dropped,
+            all: all,
+            section: .pinned,
+            connectedEnvironmentIDs: ["env-a", "env-b"],
+            movedID: "env-a:a-1"
+        ) == nil)
+        // The legacy row itself cannot be dragged either.
+        #expect(ThreadOrderPlanner.planDrop(
+            ordered: dropped,
+            all: all,
+            section: .pinned,
+            connectedEnvironmentIDs: ["env-a", "env-b"],
+            movedID: "env-b:b-1"
+        ) == nil)
+    }
+
+    @Test
+    func dropRejectsAMovedRowOnADisconnectedEnvironment() {
         let threads = sectionThreads(
             environmentID: "env-a",
             pinned: true,
@@ -281,41 +322,61 @@ struct ThreadOrderPlannerTests {
             keys: ["b-1": "m"],
             supportsPinReorder: true
         )
-        let all = threads
-        let ordered = DailyUXSidebarIndex.orderedSection(all, section: .pinned, now: now)
+        let ordered = DailyUXSidebarIndex.orderedSection(threads, section: .pinned, now: now)
         #expect(ordered.map(\.id) == ["env-a:a-1", "env-b:b-1", "env-a:a-2"])
 
-        let planner = ThreadOrderPlanner.movePlanner(
-            ordered: ordered,
-            all: all,
+        // env-b is disconnected: its row anchors position but cannot be moved.
+        #expect(ThreadOrderPlanner.planDrop(
+            ordered: [ordered[1], ordered[0], ordered[2]],
+            all: threads,
             section: .pinned,
-            connectedEnvironmentIDs: ["env-a"]
+            connectedEnvironmentIDs: ["env-a"],
+            movedID: "env-b:b-1"
+        ) == nil)
+        // A connected row can still drop across the stale anchor with one write.
+        let assignments = ThreadOrderPlanner.planDrop(
+            ordered: [ordered[0], ordered[2], ordered[1]],
+            all: threads,
+            section: .pinned,
+            connectedEnvironmentIDs: ["env-a"],
+            movedID: "env-a:a-2"
         )
-        // The disconnected row itself offers no move.
-        let stale = ordered.first { $0.id == "env-b:b-1" }!
-        #expect(planner(stale, .up) == nil)
-        #expect(planner(stale, .down) == nil)
-        // A connected row can still move past it with a single write.
-        let moving = ordered.first { $0.id == "env-a:a-2" }!
-        let assignments = planner(moving, .up)
         #expect(assignments == [
             FeatureThreadOrderAssignment(threadID: "env-a:a-2", orderKey: "j")
         ])
+    }
 
-        var options: [String: FeatureThreadMoveOptions] = [:]
-        for thread in threads {
-            if let value = DailyUXSidebarIndex.moveOptions(
-                for: thread,
-                in: threads,
-                now: now,
-                connectedEnvironmentIDs: ["env-a"]
-            ) {
-                options[thread.id] = value
-            }
-        }
-        #expect(options["env-b:b-1"] == nil)
-        #expect(options["env-a:a-1"] == FeatureThreadMoveOptions(canMoveUp: false, canMoveDown: true))
-        #expect(options["env-a:a-2"] == FeatureThreadMoveOptions(canMoveUp: true, canMoveDown: false))
+    @Test
+    func dropReservesKeysHeldByRowsOutsideTheDroppedOrder() {
+        let threads = sectionThreads(
+            environmentID: "env-a",
+            pinned: true,
+            keys: ["a-1": "f", "a-2": "t", "a-3": "z"],
+            supportsPinReorder: true
+        )
+        // A snoozed row holds "m" — the exact midpoint of f and t. Hidden from
+        // the section, its key stays reserved so the dropped row lands on the
+        // next free key instead of colliding with it.
+        var snoozed = thread(id: "env-a:snoozed", pinned: true, created: -10)
+        snoozed.pinOrderKey = "m"
+        snoozed.snoozedUntil = now.addingTimeInterval(3_600)
+        snoozed.supportsSnooze = true
+        let all = threads + [snoozed]
+        let ordered = DailyUXSidebarIndex.orderedSection(all, section: .pinned, now: now)
+        #expect(ordered.map(\.id) == ["env-a:a-1", "env-a:a-2", "env-a:a-3"])
+
+        // Drop a-3 between a-1(f) and a-2(t).
+        let assignments = ThreadOrderPlanner.planDrop(
+            ordered: [ordered[0], ordered[2], ordered[1]],
+            all: all,
+            section: .pinned,
+            connectedEnvironmentIDs: ["env-a"],
+            movedID: "env-a:a-3"
+        )
+        #expect(assignments?.count == 1)
+        #expect(assignments![0].orderKey > "f")
+        #expect(assignments![0].orderKey < "t")
+        #expect(assignments![0].orderKey != "m")
     }
 
     // MARK: - pinned section ordering

From fe7ee808a65caba5691da66d194ce4c1ab040197 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sun, 13 Sep 2026 20:25:22 +1000
Subject: [PATCH 06/10] fix(swift-ios): keep thread drags scrolling above the
 list

---
 .../Workspace/HomeThreadCollectionView.swift  | 42 +++++++++-
 .../HomeThreadSwipeActionTests.swift          | 79 +++++++++++++++++++
 2 files changed, 120 insertions(+), 1 deletion(-)

diff --git a/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift b/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
index ab7c8093ab3f..2c9c3ba85fd0 100644
--- a/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
+++ b/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
@@ -79,6 +79,7 @@ struct HomeThreadCollectionView: UIViewRepresentable {
 
     static func dismantleUIView(_ collectionView: UICollectionView, coordinator: Coordinator) {
         coordinator.invalidateTimer()
+        coordinator.stopDragAutoScroll()
         coordinator.cancelPendingSwipeActions()
         collectionView.delegate = nil
         collectionView.dragDelegate = nil
@@ -121,6 +122,8 @@ struct HomeThreadCollectionView: UIViewRepresentable {
         private var timerInterval: TimeInterval = 0
         private var pendingSwipeCompletions: [String: PendingSwipeCompletion] = [:]
         private var draggedThread: (id: String, section: FeatureThreadOrderSection)?
+        private weak var dragSession: UIDragSession?
+        private var dragDisplayLink: CADisplayLink?
         private var pendingReorder: PendingReorder?
         private var isApplyingSnapshot = false
         private var hasQueuedUpdate = false
@@ -479,7 +482,7 @@ struct HomeThreadCollectionView: UIViewRepresentable {
 
         func collectionView(
             _ collectionView: UICollectionView,
-            dragSessionIsRestrictedToDraggingBounds session: UIDragSession
+            dragSessionIsRestrictedToDraggingApplication session: UIDragSession
         ) -> Bool {
             true
         }
@@ -489,12 +492,49 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             dragSessionWillBegin session: UIDragSession
         ) {
             PlatformHapticEngine.shared.selection(enabled: parent.hapticsEnabled)
+            stopDragAutoScroll()
+            dragSession = session
+            let displayLink = CADisplayLink(target: self, selector: #selector(advanceDragAutoScroll(_:)))
+            displayLink.preferredFrameRateRange = CAFrameRateRange(minimum: 30, maximum: 60, preferred: 60)
+            displayLink.add(to: .main, forMode: .common)
+            dragDisplayLink = displayLink
+        }
+
+        func stopDragAutoScroll() {
+            dragDisplayLink?.invalidate()
+            dragDisplayLink = nil
+            dragSession = nil
+        }
+
+        @objc private func advanceDragAutoScroll(_ displayLink: CADisplayLink) {
+            advanceDragAutoScroll(by: displayLink.targetTimestamp - displayLink.timestamp)
+        }
+
+        /// UIKit stops autoscrolling when a drag leaves the collection for the
+        /// Home header. Track the source session there so overshooting the top
+        /// edge keeps scrolling, even while the finger is stationary. UIKit
+        /// continues to own scrolling and drop destinations inside the list.
+        func advanceDragAutoScroll(by elapsed: TimeInterval) {
+            guard let dragSession, let collectionView, let window = collectionView.window else { return }
+            let point = dragSession.location(in: window)
+            let viewport = collectionView.convert(collectionView.bounds, to: window)
+            guard window.bounds.contains(point),
+                  point.x >= viewport.minX, point.x < viewport.maxX,
+                  point.y < viewport.minY else { return }
+            let top = -collectionView.adjustedContentInset.top
+            let offset = collectionView.contentOffset
+            guard offset.y > top else { return }
+            collectionView.contentOffset = CGPoint(
+                x: offset.x,
+                y: max(top, offset.y - 600 * min(max(elapsed, 0), 1.0 / 15))
+            )
         }
 
         func collectionView(
             _ collectionView: UICollectionView,
             dragSessionDidEnd session: UIDragSession
         ) {
+            stopDragAutoScroll()
             draggedThread = nil
             // Flush any update deferred while the row was lifted.
             applyLatestSnapshot(in: collectionView)
diff --git a/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift b/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
index 1abf6b28715f..f4634f0cf896 100644
--- a/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
+++ b/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
@@ -9,6 +9,71 @@ import UIKit
 struct HomeThreadSwipeActionTests {
     private let now = Date(timeIntervalSince1970: 20_000)
 
+    @Test
+    func draggingAboveTheListScrollsWithoutNeedingAnEarlierScrollGesture() {
+        let initial = threadList(
+            client: SwipeSettlementClientStub(),
+            snapshot: snapshot(threads: (0..<70).map { thread(id: "\($0)") })
+        )
+        let coordinator = initial.makeCoordinator()
+        let collectionView = testCollectionView()
+        coordinator.configure(collectionView)
+        let controller = UIViewController()
+        let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 800, height: 900))
+        window.rootViewController = controller
+        controller.view.addSubview(collectionView)
+        collectionView.frame = CGRect(x: 20, y: 150, width: 300, height: 600)
+        collectionView.contentInset.top = 4
+        window.isHidden = false
+        collectionView.layoutIfNeeded()
+        defer {
+            HomeThreadCollectionView.dismantleUIView(collectionView, coordinator: coordinator)
+            window.isHidden = true
+        }
+
+        let session = HomeDragSessionStub(point: CGPoint(x: 170, y: 130))
+        collectionView.contentOffset.y = 600
+        coordinator.collectionView(collectionView, dragSessionWillBegin: session)
+        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
+        #expect(collectionView.contentOffset.y < 600)
+
+        // A stationary finger stays in the header as content coordinates move.
+        let previous = collectionView.contentOffset.y
+        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
+        #expect(collectionView.contentOffset.y < previous)
+
+        // Leave in-list and downward scrolling to UIKit. A drag over another
+        // iPad pane or outside the window must not scroll this sidebar.
+        for point in [
+            CGPoint(x: 170, y: 160), CGPoint(x: 170, y: 740),
+            CGPoint(x: 500, y: 130), CGPoint(x: 10, y: 130),
+            CGPoint(x: 170, y: -10),
+        ] {
+            session.point = point
+            let offset = collectionView.contentOffset
+            coordinator.advanceDragAutoScroll(by: 1.0 / 60)
+            #expect(collectionView.contentOffset == offset)
+        }
+
+        session.point = CGPoint(x: 170, y: 130)
+        let top = -collectionView.adjustedContentInset.top
+        collectionView.contentOffset.y = top + 1
+        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
+        #expect(collectionView.contentOffset.y == top)
+        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
+        #expect(collectionView.contentOffset.y == top)
+
+        coordinator.collectionView(collectionView, dragSessionDidEnd: session)
+        collectionView.contentOffset.y = 600
+        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
+        #expect(collectionView.contentOffset.y == 600)
+
+        coordinator.collectionView(collectionView, dragSessionWillBegin: session)
+        HomeThreadCollectionView.dismantleUIView(collectionView, coordinator: coordinator)
+        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
+        #expect(collectionView.contentOffset.y == 600)
+    }
+
     @Test
     func backKeepsTheMostRecentlyOpenedThreadHighlighted() {
         var selection = WorkspaceThreadSelection()
@@ -1217,6 +1282,20 @@ struct HomeThreadSwipeActionTests {
     }
 }
 
+@MainActor
+private final class HomeDragSessionStub: NSObject, UIDragSession {
+    var point: CGPoint
+    var localContext: Any?
+    let items: [UIDragItem] = []
+    let allowsMoveOperation = true
+    let isRestrictedToDraggingApplication = true
+
+    init(point: CGPoint) { self.point = point }
+    func location(in view: UIView) -> CGPoint { point }
+    func hasItemsConforming(toTypeIdentifiers typeIdentifiers: [String]) -> Bool { false }
+    func canLoadObjects(ofClass aClass: NSItemProviderReading.Type) -> Bool { false }
+}
+
 enum PendingSettlementEvent: CaseIterable {
     case thread
     case detail

From 6e5f135e22462315f9e2d9aa1f961d59695e836b Mon Sep 17 00:00:00 2001
From: Theo Browne <me@t3.gg>
Date: Sun, 13 Sep 2026 21:24:52 -0700
Subject: [PATCH 07/10] feat(swift-ios): arrange threads with separate drag
 handles

---
 apps/swift-ios/App/NativeFeatureClient.swift  |  50 ++-
 .../Features/Root/FeatureRootModel.swift      |  49 ++-
 .../Features/Workspace/DailyUXModels.swift    |   2 -
 .../Workspace/HomeThreadCollectionView.swift  | 373 +-----------------
 .../Workspace/ThreadArrangementPlanner.swift  | 111 ++++++
 .../Workspace/ThreadArrangementView.swift     | 346 ++++++++++++++++
 .../Features/Workspace/WorkspaceView.swift    |  17 +-
 .../HomeThreadSwipeActionTests.swift          |  82 +---
 .../FeatureTests/ThreadArrangementTests.swift | 138 +++++++
 9 files changed, 695 insertions(+), 473 deletions(-)
 create mode 100644 apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift
 create mode 100644 apps/swift-ios/Features/Workspace/ThreadArrangementView.swift
 create mode 100644 apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift

diff --git a/apps/swift-ios/App/NativeFeatureClient.swift b/apps/swift-ios/App/NativeFeatureClient.swift
index e4714e847d51..707f09cdd4f3 100644
--- a/apps/swift-ios/App/NativeFeatureClient.swift
+++ b/apps/swift-ios/App/NativeFeatureClient.swift
@@ -1705,13 +1705,8 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
         try? await refresh(client: route.client)
     }
 
-    /// Executes a hold-and-drag reorder. `orderedIDs` is the moved thread's
-    /// displayed section order after the drop — the same input web passes to
-    /// `planPinnedReorder`. Rows absent from the current snapshot are skipped;
-    /// every row a spread rewrite would write must sit in a connected,
-    /// reorder-capable environment or the whole drop is rejected before any
-    /// write. Returns the assignments the server confirmed so the caller can
-    /// patch local state if a refresh fell behind.
+    /// Saves a full-section order. Cross-section moves first clear the source
+    /// lifecycle state. Every key write goes to the thread's owning server.
     @discardableResult
     func reorderThread(
         id: String,
@@ -1726,15 +1721,21 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
         // server's rows keep their stale keys as anchors but never receive
         // writes, so a spread rewrite cannot half-land on a dead client.
         let connectedEnvironmentIDs = Set(
-            environmentConnectionStates
-                .filter { $0.value == .connected }
-                .map(\.key)
+            snapshot.environments
+                .filter { $0.isEnabled && environmentConnectionStates[$0.id] == .connected }
+                .map(\.id)
         )
         let threadsByID = Dictionary(
             snapshot.threads.map { ($0.id, $0) },
             uniquingKeysWith: { first, _ in first }
         )
-        guard let assignments = ThreadOrderPlanner.planDrop(
+        let now = Date.now
+        let canonical = DailyUXSidebarIndex.orderedSection(snapshot.threads, section: section, now: now)
+        guard let moved = threadsByID[id],
+              ThreadArrangementPlanner.canEnter(moved, section: section, now: now),
+              Set(orderedIDs).count == orderedIDs.count,
+              Set(orderedIDs) == Set(canonical.map(\.id)).union([id]),
+              let assignments = ThreadOrderPlanner.planDrop(
             ordered: orderedIDs.compactMap { threadsByID[$0] },
             all: snapshot.threads,
             section: section,
@@ -1750,9 +1751,35 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
         var confirmed: [FeatureThreadOrderAssignment] = []
         var touchedEnvironmentIDs = Set<String>()
         var firstError: Error?
+        let crossesSection = !canonical.contains(where: { $0.id == id })
+        if crossesSection {
+            do {
+                let route = try threadRoute(for: id)
+                touchedEnvironmentIDs.insert(route.environmentID)
+                for action in ThreadArrangementPlanner.lifecycle(moved, section: section, now: now) {
+                    switch action {
+                    case .pin:
+                        let key = assignments.first(where: { $0.threadID == id })?.orderKey
+                        _ = try await route.client.pin(threadID: route.wireID, pinned: true, orderKey: key)
+                    case .unpin:
+                        _ = try await route.client.pin(threadID: route.wireID, pinned: false)
+                    case .unsettle:
+                        _ = try await route.client.settle(threadID: route.wireID, settled: false)
+                    case .unsnooze:
+                        _ = try await route.client.snooze(threadID: route.wireID, until: nil)
+                    }
+                }
+            } catch {
+                firstError = error
+            }
+        }
         for assignment in assignments {
+            guard firstError == nil else { break }
             do {
                 let route = try threadRoute(for: assignment.threadID)
+                // Refresh even when the transport lost a receipt after the
+                // server accepted the write.
+                touchedEnvironmentIDs.insert(route.environmentID)
                 switch section {
                 case .pinned:
                     _ = try await route.client.reorderPinnedThread(
@@ -1766,7 +1793,6 @@ final class NativeFeatureClient: FeatureClient, FeatureDeviceManaging,
                     )
                 }
                 confirmed.append(assignment)
-                touchedEnvironmentIDs.insert(route.environmentID)
             } catch {
                 // Confirmed writes stand: a later environment rejecting its
                 // write leaves the earlier arrangement in place.
diff --git a/apps/swift-ios/Features/Root/FeatureRootModel.swift b/apps/swift-ios/Features/Root/FeatureRootModel.swift
index bcc96dae585f..1ed729d71183 100644
--- a/apps/swift-ios/Features/Root/FeatureRootModel.swift
+++ b/apps/swift-ios/Features/Root/FeatureRootModel.swift
@@ -69,6 +69,7 @@ public final class FeatureRootModel {
     private(set) var detailRenderUpdates: [String: FeatureDetailRenderUpdate] = [:]
     public private(set) var isLoading = true
     public private(set) var isPerformingAction = false
+    private(set) var isArrangingThreads = false
     /// Approval and question IDs with a response in flight. Views disable
     /// only that request, not every request in every thread.
     public private(set) var resolvingRequestIDs: Set<String> = []
@@ -561,14 +562,48 @@ public final class FeatureRootModel {
         }
     }
 
-    /// Whether a thread row can lift for drag reordering: its environment
-    /// accepts reorder writes for its section and is currently connected.
-    public func canReorder(_ thread: FeatureThread) -> Bool {
-        let section: FeatureThreadOrderSection = thread.pinnedAt != nil ? .pinned : .active
-        guard ThreadOrderPlanner.isWritable(thread, section: section) else { return false }
-        return snapshot.environments.contains {
-            $0.id == thread.environmentID && $0.connectionState == .connected
+    func arrangementPlan(
+        id: String,
+        destination: ThreadArrangementDestination
+    ) -> ThreadArrangementPlanner.Plan? {
+        guard !isArrangingThreads else { return nil }
+        return ThreadArrangementPlanner.plan(
+            id: id,
+            destination: destination,
+            threads: snapshot.threads,
+            connectedEnvironmentIDs: Set(snapshot.environments.filter {
+                $0.isEnabled && $0.connectionState == .connected
+            }.map(\.id)),
+            now: .now
+        )
+    }
+
+    @discardableResult
+    func arrangeThread(_ id: String, destination: ThreadArrangementDestination) async -> Bool {
+        guard let plan = arrangementPlan(id: id, destination: destination),
+              let previous = snapshot.threads.first(where: { $0.id == id }) else { return false }
+        isArrangingThreads = true
+        defer { isArrangingThreads = false }
+        guard let section = plan.section else { return await setSettled(id, settled: true) }
+        let environment = currentEnvironmentIdentity
+        let succeeded = await reorderThread(id, section: section, orderedIDs: plan.orderedIDs)
+        guard succeeded, currentEnvironmentIdentity == environment else { return false }
+        if ThreadArrangementPlanner.section(of: previous, now: .now).orderSection != section {
+            mutateThread(id: id) {
+                $0.pinnedAt = section == .pinned ? .now : nil
+                $0.snoozedUntil = nil
+                $0.snoozedAt = nil
+                if section == .active { $0.pinOrderKey = nil }
+                if previous.isEffectivelySettled() {
+                    $0.isSettled = false
+                    $0.keepsActive = true
+                    $0.settledAt = nil
+                    $0.unsettledAt = .now
+                    $0.settlementFacts?.settlementOverride = .active
+                }
+            }
         }
+        return true
     }
 
     /// Commits a dropped order: `orderedIDs` is the section's displayed order
diff --git a/apps/swift-ios/Features/Workspace/DailyUXModels.swift b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
index 059047939769..fd653b73d62d 100644
--- a/apps/swift-ios/Features/Workspace/DailyUXModels.swift
+++ b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
@@ -708,8 +708,6 @@ struct DailyUXSidebarIndex {
             guard !thread.isArchived else { return false }
             return projectID == nil || thread.projectID == projectID
         }
-        let available = visible.filter { !$0.isEffectivelySnoozed(at: now) }
-
         pinned = Self.orderedSection(visible, section: .pinned, now: now)
 
         active = Self.orderedSection(visible, section: .active, now: now)
diff --git a/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift b/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
index 2c9c3ba85fd0..73a8624c1b87 100644
--- a/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
+++ b/apps/swift-ios/Features/Workspace/HomeThreadCollectionView.swift
@@ -25,18 +25,7 @@ struct HomeThreadCollectionView: UIViewRepresentable {
     let onSettle: (FeatureThread, Bool, @escaping (Bool) -> Void) -> Void
     let onSnooze: (FeatureThread, Date?) -> Void
     let onPin: (FeatureThread, Bool) -> Void
-    /// Whether the row can lift for drag reordering (reorder-capable,
-    /// connected environment).
-    let onCanReorder: (FeatureThread) -> Bool
-    /// Commits a drop: the thread, its section, and the section's displayed
-    /// thread order after the drop. Completion reports whether the writes
-    /// landed so the view can snap back on failure.
-    let onReorder: (
-        FeatureThread,
-        FeatureThreadOrderSection,
-        [String],
-        @escaping (Bool) -> Void
-    ) -> Void
+    let onArrange: () -> Void
     let onDelete: (FeatureThread) -> Void
     let onPullRequestChange: (String, String, HomeThreadPullRequestPresentation?) -> Void
 
@@ -64,11 +53,6 @@ struct HomeThreadCollectionView: UIViewRepresentable {
         collectionView.contentInset = UIEdgeInsets(top: 4, left: 0, bottom: 74, right: 0)
         collectionView.verticalScrollIndicatorInsets = UIEdgeInsets(top: 4, left: 0, bottom: 74, right: 0)
         collectionView.delegate = context.coordinator
-        // Long-press-and-drag reorders a row inside its section; a stationary
-        // hold still opens the context menu (UIKit resolves the two).
-        collectionView.dragInteractionEnabled = true
-        collectionView.dragDelegate = context.coordinator
-        collectionView.dropDelegate = context.coordinator
         context.coordinator.configure(collectionView)
         return collectionView
     }
@@ -79,16 +63,12 @@ struct HomeThreadCollectionView: UIViewRepresentable {
 
     static func dismantleUIView(_ collectionView: UICollectionView, coordinator: Coordinator) {
         coordinator.invalidateTimer()
-        coordinator.stopDragAutoScroll()
         coordinator.cancelPendingSwipeActions()
         collectionView.delegate = nil
-        collectionView.dragDelegate = nil
-        collectionView.dropDelegate = nil
     }
 
     @MainActor
-    final class Coordinator: NSObject, UICollectionViewDelegate,
-        UICollectionViewDragDelegate, UICollectionViewDropDelegate {
+    final class Coordinator: NSObject, UICollectionViewDelegate {
         private enum Section: Hashable {
             case main
         }
@@ -99,16 +79,6 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             let finish: (Bool) -> Void
         }
 
-        /// A drop the collection view already shows but the model has not
-        /// caught up with yet: stream updates keep displaying this order until
-        /// the reorder write confirms or fails.
-        private struct PendingReorder {
-            let id: UUID
-            let section: FeatureThreadOrderSection
-            let orderedThreadIDs: [String]
-            let deadline: Date
-        }
-
         private var parent: HomeThreadCollectionView
         private var dataSource: UICollectionViewDiffableDataSource<Section, HomeCollectionItem.ID>?
         private var registration: UICollectionView.CellRegistration<HomeCollectionCell, HomeCollectionItem.ID>?
@@ -121,10 +91,6 @@ struct HomeThreadCollectionView: UIViewRepresentable {
         private var timerTick = 0
         private var timerInterval: TimeInterval = 0
         private var pendingSwipeCompletions: [String: PendingSwipeCompletion] = [:]
-        private var draggedThread: (id: String, section: FeatureThreadOrderSection)?
-        private weak var dragSession: UIDragSession?
-        private var dragDisplayLink: CADisplayLink?
-        private var pendingReorder: PendingReorder?
         private var isApplyingSnapshot = false
         private var hasQueuedUpdate = false
 
@@ -142,7 +108,7 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             }
             self.registration = registration
 
-            let dataSource = UICollectionViewDiffableDataSource<Section, HomeCollectionItem.ID>(
+            dataSource = UICollectionViewDiffableDataSource<Section, HomeCollectionItem.ID>(
                 collectionView: collectionView
             ) { [weak self] collectionView, indexPath, identifier in
                 guard let self, let registration = self.registration else { return nil }
@@ -152,19 +118,6 @@ struct HomeThreadCollectionView: UIViewRepresentable {
                     item: identifier
                 )
             }
-            // The data source applies a same-view reorder drop itself; the
-            // drop's commit to the server happens in didReorder.
-            var reorderingHandlers = UICollectionViewDiffableDataSource<
-                Section, HomeCollectionItem.ID
-            >.ReorderingHandlers()
-            reorderingHandlers.canReorderItem = { [weak self] identifier in
-                self?.isReorderable(identifier) ?? false
-            }
-            reorderingHandlers.didReorder = { [weak self] transaction in
-                self?.didReorder(transaction)
-            }
-            dataSource.reorderingHandlers = reorderingHandlers
-            self.dataSource = dataSource
 
             update(parent: parent, collectionView: collectionView)
         }
@@ -177,11 +130,8 @@ struct HomeThreadCollectionView: UIViewRepresentable {
 
         /// Keep a row's content and size fixed during its removal. Stream updates
         /// that arrive mid-animation are applied together after that animation.
-        /// Updates also wait out an active drag so a lifted row's snapshot does
-        /// not shift under the user's finger.
         private func applyLatestSnapshot(in collectionView: UICollectionView) {
-            guard !isApplyingSnapshot, hasQueuedUpdate,
-                  !collectionView.hasActiveDrag, let dataSource else { return }
+            guard !isApplyingSnapshot, hasQueuedUpdate, let dataSource else { return }
             hasQueuedUpdate = false
             let previousItems = itemsByID
             let previousThreadItemIDs = threadItemIDs
@@ -208,22 +158,7 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             startTimer()
 
             let currentIdentifiers = dataSource.snapshot().itemIdentifiers
-            var newIdentifiers = items.map(\.id)
-            if let pending = pendingReorder {
-                // Converged once the rows still present carry the dropped
-                // order — rows joining or leaving mid-write don't count.
-                let natural = sectionThreadIDs(in: newIdentifiers, section: pending.section)
-                let held = Set(pending.orderedThreadIDs)
-                let caughtUp = natural.filter(held.contains)
-                    == pending.orderedThreadIDs.filter(Set(natural).contains)
-                if caughtUp || Date.now > pending.deadline {
-                    pendingReorder = nil
-                } else {
-                    // The drop already shows; hold its order until the write
-                    // lands so a mid-flight stream update cannot revert it.
-                    newIdentifiers = applyingPendingReorder(pending, to: newIdentifiers)
-                }
-            }
+            let newIdentifiers = items.map(\.id)
             let resolvedSwipes = pendingSwipeCompletions.filter { threadID, pending in
                 guard let identifier = threadItemIDs[threadID],
                       case let .thread(thread, _, _, _, _, _) = itemsByID[identifier] else {
@@ -356,295 +291,6 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             }
         }
 
-        // MARK: - Drag to reorder
-
-        /// A row lifts for reordering only when its environment can take the
-        /// write right now — `onCanReorder` is false for pre-reorder servers
-        /// and disconnected environments. Lifts are also blocked while an
-        /// earlier drop's write is still outstanding, since the client runs
-        /// one reorder at a time and a second would snap back on top of it.
-        private func isReorderable(_ identifier: HomeCollectionItem.ID) -> Bool {
-            guard pendingReorder == nil,
-                  case let .thread(_, shelf) = identifier,
-                  shelf == .active,
-                  let item = itemsByID[identifier],
-                  case let .thread(thread, _, _, _, _, _) = item else { return false }
-            return parent.onCanReorder(thread)
-        }
-
-        /// Item-index bounds of a section's displayed rows. `upper` sits just
-        /// past the last row — on the pinned divider, a shelf header, or one
-        /// past the list end — so an "insert before" drop there still lands
-        /// inside the section.
-        private func sectionBounds(
-            _ section: FeatureThreadOrderSection,
-            in identifiers: [HomeCollectionItem.ID]
-        ) -> (lower: Int, upper: Int)? {
-            var lower: Int?
-            var upper = 0
-            for (index, identifier) in identifiers.enumerated() {
-                guard case let .thread(_, shelf) = identifier,
-                      shelf == .active,
-                      let item = itemsByID[identifier],
-                      case let .thread(thread, _, _, _, _, _) = item,
-                      (thread.pinnedAt != nil) == (section == .pinned) else { continue }
-                if lower == nil { lower = index }
-                upper = index + 1
-            }
-            guard let lower else { return nil }
-            return (lower, upper)
-        }
-
-        /// The section's displayed thread order within an item list — the
-        /// same list a drop plans against on web (`planPinnedReorder` on the
-        /// displayed order, hidden rows' keys reserved by the client).
-        private func sectionThreadIDs(
-            in identifiers: [HomeCollectionItem.ID],
-            section: FeatureThreadOrderSection
-        ) -> [String] {
-            identifiers.compactMap { identifier in
-                guard case let .thread(threadID, shelf) = identifier,
-                      shelf == .active,
-                      let item = itemsByID[identifier],
-                      case let .thread(thread, _, _, _, _, _) = item,
-                      (thread.pinnedAt != nil) == (section == .pinned) else { return nil }
-                return threadID
-            }
-        }
-
-        /// Permute only the pending section's rows inside an identifier list;
-        /// headers, dividers, and the other section stay put.
-        private func applyingPendingReorder(
-            _ pending: PendingReorder,
-            to identifiers: [HomeCollectionItem.ID]
-        ) -> [HomeCollectionItem.ID] {
-            var rank: [String: Int] = [:]
-            for (index, threadID) in pending.orderedThreadIDs.enumerated() {
-                rank[threadID] = index
-            }
-            let regionIndices = identifiers.indices.filter { index in
-                guard case let .thread(_, shelf) = identifiers[index],
-                      shelf == .active,
-                      let item = itemsByID[identifiers[index]],
-                      case let .thread(thread, _, _, _, _, _) = item else { return false }
-                return (thread.pinnedAt != nil) == (pending.section == .pinned)
-            }
-            let reordered = regionIndices
-                .map { identifiers[$0] }
-                .enumerated()
-                .sorted { left, right in
-                    let leftRank = left.element.threadID.flatMap { rank[$0] } ?? .max
-                    let rightRank = right.element.threadID.flatMap { rank[$0] } ?? .max
-                    return leftRank != rightRank ? leftRank < rightRank : left.offset < right.offset
-                }
-                .map(\.element)
-            var result = identifiers
-            for (position, index) in regionIndices.enumerated() {
-                result[index] = reordered[position]
-            }
-            return result
-        }
-
-        func collectionView(
-            _ collectionView: UICollectionView,
-            itemsForBeginning session: UIDragSession,
-            at indexPath: IndexPath
-        ) -> [UIDragItem] {
-            guard let identifier = dataSource?.itemIdentifier(for: indexPath),
-                  isReorderable(identifier),
-                  case let .thread(thread, _, _, _, _, _) = itemsByID[identifier] else {
-                return []
-            }
-            draggedThread = (
-                id: thread.id,
-                section: thread.pinnedAt != nil ? .pinned : .active
-            )
-            let dragItem = UIDragItem(itemProvider: NSItemProvider())
-            dragItem.localObject = thread.id
-            return [dragItem]
-        }
-
-        func collectionView(
-            _ collectionView: UICollectionView,
-            itemsForAddingTo session: UIDragSession,
-            at indexPath: IndexPath,
-            point: CGPoint
-        ) -> [UIDragItem] {
-            []
-        }
-
-        func collectionView(
-            _ collectionView: UICollectionView,
-            dragSessionAllowsMoveOperation session: UIDragSession
-        ) -> Bool {
-            true
-        }
-
-        func collectionView(
-            _ collectionView: UICollectionView,
-            dragSessionIsRestrictedToDraggingApplication session: UIDragSession
-        ) -> Bool {
-            true
-        }
-
-        func collectionView(
-            _ collectionView: UICollectionView,
-            dragSessionWillBegin session: UIDragSession
-        ) {
-            PlatformHapticEngine.shared.selection(enabled: parent.hapticsEnabled)
-            stopDragAutoScroll()
-            dragSession = session
-            let displayLink = CADisplayLink(target: self, selector: #selector(advanceDragAutoScroll(_:)))
-            displayLink.preferredFrameRateRange = CAFrameRateRange(minimum: 30, maximum: 60, preferred: 60)
-            displayLink.add(to: .main, forMode: .common)
-            dragDisplayLink = displayLink
-        }
-
-        func stopDragAutoScroll() {
-            dragDisplayLink?.invalidate()
-            dragDisplayLink = nil
-            dragSession = nil
-        }
-
-        @objc private func advanceDragAutoScroll(_ displayLink: CADisplayLink) {
-            advanceDragAutoScroll(by: displayLink.targetTimestamp - displayLink.timestamp)
-        }
-
-        /// UIKit stops autoscrolling when a drag leaves the collection for the
-        /// Home header. Track the source session there so overshooting the top
-        /// edge keeps scrolling, even while the finger is stationary. UIKit
-        /// continues to own scrolling and drop destinations inside the list.
-        func advanceDragAutoScroll(by elapsed: TimeInterval) {
-            guard let dragSession, let collectionView, let window = collectionView.window else { return }
-            let point = dragSession.location(in: window)
-            let viewport = collectionView.convert(collectionView.bounds, to: window)
-            guard window.bounds.contains(point),
-                  point.x >= viewport.minX, point.x < viewport.maxX,
-                  point.y < viewport.minY else { return }
-            let top = -collectionView.adjustedContentInset.top
-            let offset = collectionView.contentOffset
-            guard offset.y > top else { return }
-            collectionView.contentOffset = CGPoint(
-                x: offset.x,
-                y: max(top, offset.y - 600 * min(max(elapsed, 0), 1.0 / 15))
-            )
-        }
-
-        func collectionView(
-            _ collectionView: UICollectionView,
-            dragSessionDidEnd session: UIDragSession
-        ) {
-            stopDragAutoScroll()
-            draggedThread = nil
-            // Flush any update deferred while the row was lifted.
-            applyLatestSnapshot(in: collectionView)
-        }
-
-        func collectionView(
-            _ collectionView: UICollectionView,
-            dropSessionDidUpdate session: UIDropSession,
-            withDestinationIndexPath destinationIndexPath: IndexPath?
-        ) -> UICollectionViewDropProposal {
-            guard session.localDragSession != nil,
-                  let dragged = draggedThread,
-                  let identifiers = dataSource?.snapshot().itemIdentifiers,
-                  let bounds = sectionBounds(dragged.section, in: identifiers) else {
-                return UICollectionViewDropProposal(operation: .forbidden)
-            }
-            if let destinationIndexPath {
-                let within = destinationIndexPath.section == 0
-                    && destinationIndexPath.item >= bounds.lower
-                    && destinationIndexPath.item <= bounds.upper
-                return UICollectionViewDropProposal(
-                    operation: within ? .move : .forbidden,
-                    intent: .insertAtDestinationIndexPath
-                )
-            }
-            // Hovering past the last row only works when the section runs to
-            // the end of the list (no shelves below it).
-            return UICollectionViewDropProposal(
-                operation: bounds.upper >= identifiers.count ? .move : .forbidden,
-                intent: .insertAtDestinationIndexPath
-            )
-        }
-
-        func collectionView(
-            _ collectionView: UICollectionView,
-            performDropWith coordinator: UICollectionViewDropCoordinator
-        ) {
-            guard coordinator.session.localDragSession != nil,
-                  let dragged = draggedThread,
-                  let dataSource,
-                  let item = coordinator.items.first else { return }
-            if let destinationIndexPath = coordinator.destinationIndexPath {
-                // Clamped into the section by dropSessionDidUpdate; the data
-                // source applies the move and reports it via didReorder.
-                coordinator.drop(item.dragItem, toItemAt: destinationIndexPath)
-                return
-            }
-            // Dropped past the last row of a section that ends the list:
-            // move the row there ourselves (no system move, no didReorder).
-            let identifiers = dataSource.snapshot().itemIdentifiers
-            guard let bounds = sectionBounds(dragged.section, in: identifiers),
-                  bounds.upper >= identifiers.count,
-                  let draggedIdentifier = threadItemIDs[dragged.id],
-                  let lastIdentifier = identifiers.last,
-                  draggedIdentifier != lastIdentifier else { return }
-            var snapshot = dataSource.snapshot()
-            snapshot.deleteItems([draggedIdentifier])
-            snapshot.insertItems([draggedIdentifier], afterItem: lastIdentifier)
-            dataSource.apply(snapshot, animatingDifferences: true)
-            commitReorder(section: dragged.section, identifiers: snapshot.itemIdentifiers)
-        }
-
-        private func didReorder(
-            _ transaction: NSDiffableDataSourceTransaction<Section, HomeCollectionItem.ID>
-        ) {
-            guard let dragged = draggedThread else { return }
-            commitReorder(
-                section: dragged.section,
-                identifiers: transaction.finalSnapshot.itemIdentifiers
-            )
-        }
-
-        /// Hand the dropped order to the model. A failed write snaps the rows
-        /// back; a confirmed one holds until the next snapshot carries it.
-        private func commitReorder(
-            section: FeatureThreadOrderSection,
-            identifiers: [HomeCollectionItem.ID]
-        ) {
-            // One commit per drop: a second path firing for the same drop
-            // would overwrite the hold and race the in-flight write.
-            guard pendingReorder == nil,
-                  let dragged = draggedThread,
-                  let identifier = threadItemIDs[dragged.id],
-                  case let .thread(thread, _, _, _, _, _) = itemsByID[identifier] else { return }
-            let orderedIDs = sectionThreadIDs(in: identifiers, section: section)
-            // A drop back onto the same slot changes nothing — skip the write.
-            let unchanged = sectionThreadIDs(
-                in: parent.collectionItems.map(\.id),
-                section: section
-            )
-            guard orderedIDs.contains(dragged.id), orderedIDs != unchanged else { return }
-            PlatformHapticEngine.shared.selection(enabled: parent.hapticsEnabled)
-            let completionID = UUID()
-            pendingReorder = PendingReorder(
-                id: completionID,
-                section: section,
-                orderedThreadIDs: orderedIDs,
-                deadline: .now.addingTimeInterval(10)
-            )
-            parent.onReorder(thread, section, orderedIDs) { [weak self] succeeded in
-                guard let self,
-                      !succeeded,
-                      self.pendingReorder?.id == completionID,
-                      let collectionView = self.collectionView else { return }
-                self.pendingReorder = nil
-                self.hasQueuedUpdate = true
-                self.applyLatestSnapshot(in: collectionView)
-            }
-        }
-
         func trailingSwipeActions(at indexPath: IndexPath) -> UISwipeActionsConfiguration? {
             guard case let .thread(thread, _, _, isArchived, _, _) = item(at: indexPath) else {
                 return nil
@@ -920,6 +566,9 @@ struct HomeThreadCollectionView: UIViewRepresentable {
             }
 
             if !isArchived {
+                actions.append(accessibilityAction("Arrange threads", systemImage: "line.3.horizontal") { coordinator in
+                    coordinator.parent.onArrange()
+                })
                 if thread.canTogglePin {
                     let isPinned = thread.pinnedAt != nil
                     actions.append(accessibilityAction(
@@ -1066,6 +715,12 @@ struct HomeThreadCollectionView: UIViewRepresentable {
 
             var statusActions: [UIMenuElement] = []
             if !isArchived {
+                statusActions.append(UIAction(
+                    title: "Arrange threads",
+                    image: UIImage(systemName: "line.3.horizontal")
+                ) { [weak self] _ in
+                    self?.parent.onArrange()
+                })
                 if thread.canTogglePin {
                     let isPinned = thread.pinnedAt != nil
                     statusActions.append(
diff --git a/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift b/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift
new file mode 100644
index 000000000000..57eefca5b6a6
--- /dev/null
+++ b/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift
@@ -0,0 +1,111 @@
+import Foundation
+
+enum ThreadArrangementSection: String, CaseIterable, Hashable {
+    case pinned, active, snoozed, settled
+
+    var title: String { rawValue.capitalized }
+
+    var orderSection: FeatureThreadOrderSection? {
+        switch self {
+        case .pinned: .pinned
+        case .active: .active
+        case .snoozed, .settled: nil
+        }
+    }
+}
+
+struct ThreadArrangementDestination: Equatable {
+    let section: ThreadArrangementSection
+    var targetID: String? = nil
+    var after = false
+}
+
+/// Resolves drops against all environments, without the Home project filter.
+/// A destination identifies a row rather than an index so a stale drag cannot
+/// silently move next to a different thread.
+enum ThreadArrangementPlanner {
+    enum LifecycleAction: Equatable {
+        case pin, unpin, unsettle, unsnooze
+    }
+
+    struct Plan {
+        let section: FeatureThreadOrderSection?
+        let orderedIDs: [String]
+        let assignments: [FeatureThreadOrderAssignment]
+    }
+
+    static func lifecycle(
+        _ thread: FeatureThread,
+        section: FeatureThreadOrderSection,
+        now: Date
+    ) -> [LifecycleAction] {
+        if section == .pinned { return [.pin] }
+        var actions: [LifecycleAction] = []
+        if thread.pinnedAt != nil { actions.append(.unpin) }
+        if thread.isEffectivelySettled() { actions.append(.unsettle) }
+        if thread.isEffectivelySnoozed(at: now) { actions.append(.unsnooze) }
+        return actions
+    }
+
+    static func section(of thread: FeatureThread, now: Date) -> ThreadArrangementSection {
+        if thread.isEffectivelySnoozed(at: now) { return .snoozed }
+        if thread.supportsSettlement == true, thread.isEffectivelySettled() { return .settled }
+        return thread.pinnedAt == nil ? .active : .pinned
+    }
+
+    static func canEnter(
+        _ thread: FeatureThread,
+        section: FeatureThreadOrderSection,
+        now: Date
+    ) -> Bool {
+        guard !thread.isArchived, ThreadOrderPlanner.isWritable(thread, section: section) else {
+            return false
+        }
+        let source = self.section(of: thread, now: now)
+        if source.orderSection == section { return true }
+        if (section == .pinned || thread.pinnedAt != nil), thread.supportsPinning != true {
+            return false
+        }
+        if thread.isEffectivelySettled(), thread.supportsSettlement != true { return false }
+        if thread.isEffectivelySnoozed(at: now), thread.supportsSnooze != true { return false }
+        return true
+    }
+
+    static func plan(
+        id: String,
+        destination: ThreadArrangementDestination,
+        threads: [FeatureThread],
+        connectedEnvironmentIDs: Set<String>,
+        now: Date
+    ) -> Plan? {
+        guard let moved = threads.first(where: { $0.id == id }),
+              !moved.isArchived,
+              connectedEnvironmentIDs.contains(moved.environmentID ?? "") else { return nil }
+        if destination.section == .settled {
+            guard moved.supportsSettlement == true, !moved.isEffectivelySettled(),
+                  moved.canSettleNow(at: now) else { return nil }
+            return Plan(section: nil, orderedIDs: [], assignments: [])
+        }
+        guard let section = destination.section.orderSection,
+              canEnter(moved, section: section, now: now) else { return nil }
+        let current = DailyUXSidebarIndex.orderedSection(threads, section: section, now: now)
+        var ordered = current.filter { $0.id != id }
+        let index: Int
+        if let target = destination.targetID {
+            guard let targetIndex = ordered.firstIndex(where: { $0.id == target }) else { return nil }
+            index = targetIndex + (destination.after ? 1 : 0)
+        } else {
+            index = destination.after ? ordered.count : 0
+        }
+        ordered.insert(moved, at: index)
+        guard ordered.map(\.id) != current.map(\.id),
+              let assignments = ThreadOrderPlanner.planDrop(
+                ordered: ordered,
+                all: threads,
+                section: section,
+                connectedEnvironmentIDs: connectedEnvironmentIDs,
+                movedID: id
+              ) else { return nil }
+        return Plan(section: section, orderedIDs: ordered.map(\.id), assignments: assignments)
+    }
+}
diff --git a/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift b/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift
new file mode 100644
index 000000000000..df6a45c60ccf
--- /dev/null
+++ b/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift
@@ -0,0 +1,346 @@
+import SwiftUI
+import UIKit
+
+/// Lives on the workspace, not a row, so moving the source to another shelf
+/// does not dismiss the sheet.
+struct ThreadArrangementView: View {
+    @SwiftUI.Environment(\.dismiss) private var dismiss
+    @Bindable var model: FeatureRootModel
+    @State private var action: String?
+    @State private var now = Date.now
+
+    var body: some View {
+        NavigationStack {
+            ThreadArrangementCollection(
+                model: model,
+                revision: model.homePresentationRevision,
+                busy: model.isArrangingThreads,
+                now: now,
+                onAction: { action = $0 }
+            )
+            .background(.black)
+            .navigationTitle(action ?? "Arrange threads")
+            .navigationBarTitleDisplayMode(.inline)
+            .toolbar {
+                ToolbarItem(placement: .confirmationAction) {
+                    Button("Done") { dismiss() }
+                        .disabled(model.isArrangingThreads)
+                }
+            }
+        }
+        .preferredColorScheme(.dark)
+        .interactiveDismissDisabled(model.isArrangingThreads)
+        .alert("Could not arrange threads", isPresented: Binding(
+            get: { model.errorMessage != nil },
+            set: { if !$0 { model.errorMessage = nil } }
+        )) {
+            Button("OK") { model.errorMessage = nil }
+        } message: {
+            Text(model.errorMessage ?? "The move failed.")
+        }
+        .task(id: nextWake) {
+            guard let wake = nextWake else { return }
+            do {
+                try await Task.sleep(for: .seconds(max(0, wake.timeIntervalSinceNow)))
+                now = max(.now, wake)
+            } catch {}
+        }
+    }
+
+    private var nextWake: Date? {
+        model.snapshot.threads.compactMap(\.snoozedUntil).filter { $0 > now }.min()
+    }
+}
+
+private struct ThreadArrangementCollection: UIViewRepresentable {
+    let model: FeatureRootModel
+    let revision: UInt64
+    let busy: Bool
+    let now: Date
+    let onAction: (String?) -> Void
+
+    func makeCoordinator() -> Coordinator { Coordinator(parent: self) }
+
+    func makeUIView(context: Context) -> UICollectionView {
+        var layout = UICollectionLayoutListConfiguration(appearance: .plain)
+        layout.backgroundColor = .black
+        layout.showsSeparators = false
+        let view = UICollectionView(
+            frame: .zero,
+            collectionViewLayout: UICollectionViewCompositionalLayout.list(using: layout)
+        )
+        view.backgroundColor = .black
+        view.alwaysBounceVertical = true
+        view.dragInteractionEnabled = true
+        view.delegate = context.coordinator
+        view.dragDelegate = context.coordinator
+        view.dropDelegate = context.coordinator
+        context.coordinator.configure(view)
+        return view
+    }
+
+    func updateUIView(_ view: UICollectionView, context: Context) {
+        context.coordinator.parent = self
+        context.coordinator.update()
+    }
+
+    static func dismantleUIView(_ view: UICollectionView, coordinator: Coordinator) {
+        view.delegate = nil
+        view.dragDelegate = nil
+        view.dropDelegate = nil
+    }
+
+    @MainActor
+    final class Coordinator: NSObject, UICollectionViewDelegate,
+        UICollectionViewDragDelegate, UICollectionViewDropDelegate {
+        struct Row {
+            let section: ThreadArrangementSection
+            var thread: FeatureThread?
+            var id: String { thread.map { "thread:\($0.id)" } ?? "section:\(section.rawValue)" }
+        }
+
+        var parent: ThreadArrangementCollection
+        private weak var view: UICollectionView?
+        private var dataSource: UICollectionViewDiffableDataSource<Int, String>?
+        private var rows: [Row] = []
+        private var expanded = Set<ThreadArrangementSection>()
+        private var draggedID: String?
+        private var pendingRows: [Row]?
+
+        init(parent: ThreadArrangementCollection) { self.parent = parent }
+
+        func configure(_ view: UICollectionView) {
+            self.view = view
+            let registration = UICollectionView.CellRegistration<UICollectionViewListCell, String> {
+                [weak self] cell, _, id in
+                self?.configure(cell, id: id)
+            }
+            dataSource = UICollectionViewDiffableDataSource<Int, String>(collectionView: view) {
+                collection, indexPath, id in
+                collection.dequeueConfiguredReusableCell(using: registration, for: indexPath, item: id)
+            }
+            update()
+        }
+
+        func update(completion: (() -> Void)? = nil) {
+            guard draggedID == nil || pendingRows != nil else { return }
+            if let pendingRows {
+                rows = pendingRows
+            } else {
+                let index = DailyUXSidebarIndex(snapshot: parent.model.snapshot, query: "", now: parent.now)
+                rows = ThreadArrangementSection.allCases.flatMap { section -> [Row] in
+                    let threads: [FeatureThread]
+                    switch section {
+                    case .pinned: threads = index.pinned
+                    case .active: threads = index.active
+                    case .snoozed: threads = index.snoozed
+                    case .settled: threads = index.settled
+                    }
+                    if section == .snoozed, threads.isEmpty { return [] }
+                    let visible = section.orderSection != nil || expanded.contains(section)
+                    return [Row(section: section)] + (visible ? threads.map { Row(section: section, thread: $0) } : [])
+                }
+            }
+            var snapshot = NSDiffableDataSourceSnapshot<Int, String>()
+            snapshot.appendSections([0])
+            snapshot.appendItems(rows.map(\.id))
+            if let existing = dataSource?.snapshot().itemIdentifiers {
+                let previousIDs = Set(existing)
+                snapshot.reconfigureItems(rows.map(\.id).filter { previousIDs.contains($0) })
+            }
+            dataSource?.apply(snapshot, animatingDifferences: !UIAccessibility.isReduceMotionEnabled, completion: completion)
+        }
+
+        private func configure(_ cell: UICollectionViewListCell, id: String) {
+            guard let row = rows.first(where: { $0.id == id }) else { return }
+            cell.backgroundConfiguration = .clear()
+            cell.accessories = []
+            if let thread = row.thread {
+                let enabled = !parent.model.isArrangingThreads && canLift(thread)
+                cell.contentConfiguration = UIHostingConfiguration {
+                    HStack(spacing: 12) {
+                        VStack(alignment: .leading, spacing: 2) {
+                            Text(thread.title).font(.system(size: 15)).foregroundStyle(.white).lineLimit(1)
+                            if let name = thread.environmentName {
+                                Text(name).font(.system(size: 11)).foregroundStyle(.gray).lineLimit(1)
+                            }
+                        }
+                        Spacer(minLength: 0)
+                        Image(systemName: "line.3.horizontal")
+                            .foregroundStyle(enabled ? Color.white : Color.gray)
+                            .frame(width: 48, height: 48)
+                    }
+                    .frame(height: 56)
+                    .padding(.horizontal, 16)
+                    .background(.black)
+                }.margins(.all, 0)
+                cell.isAccessibilityElement = true
+                cell.accessibilityLabel = thread.title
+                cell.accessibilityValue = row.section.title
+                cell.accessibilityHint = "Use actions to change order or section."
+                cell.accessibilityTraits = .button
+                cell.accessibilityCustomActions = accessibilityActions(thread, section: row.section)
+            } else {
+                let expandable = row.section.orderSection == nil
+                let isExpanded = expanded.contains(row.section)
+                cell.contentConfiguration = UIHostingConfiguration {
+                    HStack {
+                        Text(row.section.title).font(.system(size: 14, weight: .semibold))
+                        Spacer()
+                        if expandable {
+                            Image(systemName: isExpanded ? "chevron.down" : "chevron.right")
+                        }
+                    }
+                    .foregroundStyle(.white)
+                    .padding(.horizontal, 16)
+                    .frame(height: 48)
+                    .background(.black)
+                }.margins(.all, 0)
+                cell.isAccessibilityElement = true
+                cell.accessibilityLabel = row.section.title
+                cell.accessibilityValue = expandable ? (expanded.contains(row.section) ? "Expanded" : "Collapsed") : nil
+                cell.accessibilityHint = nil
+                cell.accessibilityTraits = expandable ? [.header, .button] : .header
+                cell.accessibilityCustomActions = []
+            }
+        }
+
+        private func canLift(_ thread: FeatureThread) -> Bool {
+            guard !thread.isArchived,
+                  parent.model.snapshot.environments.contains(where: {
+                    $0.id == thread.environmentID && $0.isEnabled && $0.connectionState == .connected
+                  }) else { return false }
+            return ThreadArrangementPlanner.canEnter(thread, section: .pinned, now: .now)
+                || ThreadArrangementPlanner.canEnter(thread, section: .active, now: .now)
+                || (thread.supportsSettlement == true && !thread.isEffectivelySettled() && thread.canSettleNow())
+        }
+
+        func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
+            guard rows.indices.contains(indexPath.item), rows[indexPath.item].thread == nil,
+                  !parent.model.isArrangingThreads else { return }
+            let section = rows[indexPath.item].section
+            guard section.orderSection == nil else { return }
+            if expanded.contains(section) { expanded.remove(section) } else { expanded.insert(section) }
+            update()
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            itemsForBeginning session: UIDragSession,
+            at indexPath: IndexPath
+        ) -> [UIDragItem] {
+            guard !parent.model.isArrangingThreads, pendingRows == nil, rows.indices.contains(indexPath.item),
+                  let thread = rows[indexPath.item].thread, canLift(thread),
+                  let cell = collectionView.cellForItem(at: indexPath),
+                  session.location(in: cell).x >= cell.bounds.maxX - 64 else { return [] }
+            draggedID = thread.id
+            let item = UIDragItem(itemProvider: NSItemProvider(object: thread.id as NSString))
+            item.localObject = thread.id
+            return [item]
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            dragSessionIsRestrictedToDraggingApplication session: UIDragSession
+        ) -> Bool { true }
+
+        func collectionView(_ collectionView: UICollectionView, dragSessionDidEnd session: UIDragSession) {
+            draggedID = nil
+            parent.onAction(nil)
+            update()
+        }
+
+        private func destination(at indexPath: IndexPath?) -> ThreadArrangementDestination? {
+            guard let indexPath, indexPath.section == 0 else { return nil }
+            if indexPath.item == rows.count, let last = rows.last {
+                return ThreadArrangementDestination(section: last.section, targetID: last.thread?.id, after: true)
+            }
+            guard rows.indices.contains(indexPath.item) else { return nil }
+            let row = rows[indexPath.item]
+            return ThreadArrangementDestination(section: row.section, targetID: row.thread?.id)
+        }
+
+        func collectionView(
+            _ collectionView: UICollectionView,
+            dropSessionDidUpdate session: UIDropSession,
+            withDestinationIndexPath indexPath: IndexPath?
+        ) -> UICollectionViewDropProposal {
+            guard session.localDragSession != nil, let id = draggedID,
+                  let destination = destination(at: indexPath),
+                  parent.model.arrangementPlan(id: id, destination: destination) != nil else {
+                parent.onAction(nil)
+                return UICollectionViewDropProposal(operation: .forbidden)
+            }
+            if let source = rows.first(where: { $0.thread?.id == id }) {
+                parent.onAction(action(source: source.section, destination: destination.section))
+            }
+            return UICollectionViewDropProposal(operation: .move, intent: .insertAtDestinationIndexPath)
+        }
+
+        func collectionView(_ collectionView: UICollectionView, performDropWith coordinator: UICollectionViewDropCoordinator) {
+            guard let id = draggedID, let item = coordinator.items.first,
+                  let destination = destination(at: coordinator.destinationIndexPath),
+                  parent.model.arrangementPlan(id: id, destination: destination) != nil,
+                  let moved = rows.first(where: { $0.thread?.id == id })?.thread else { return }
+            var next = rows.filter { $0.thread?.id != id }
+            let target = destination.targetID.flatMap { id in next.firstIndex { $0.thread?.id == id } }
+                ?? next.firstIndex { $0.thread == nil && $0.section == destination.section }
+            guard let target else { return }
+            let insertAt = target + (destination.targetID == nil || destination.after ? 1 : 0)
+            if destination.section.orderSection != nil || expanded.contains(destination.section) {
+                next.insert(Row(section: destination.section, thread: moved), at: insertAt)
+            }
+            pendingRows = next
+            let dropPath = IndexPath(item: min(insertAt, next.count - 1), section: 0)
+            update {
+                coordinator.drop(item.dragItem, toItemAt: dropPath)
+            }
+            commit(id, destination: destination)
+        }
+
+        private func commit(_ id: String, destination: ThreadArrangementDestination) {
+            Task { [weak self] in
+                guard let self else { return }
+                _ = await parent.model.arrangeThread(id, destination: destination)
+                pendingRows = nil
+                draggedID = nil
+                parent.onAction(nil)
+                update()
+            }
+        }
+
+        private func action(source: ThreadArrangementSection, destination: ThreadArrangementSection) -> String {
+            if destination == .settled { return "Settle" }
+            if source == destination { return "Reorder" }
+            if destination == .pinned { return "Pin" }
+            if source == .pinned { return "Unpin" }
+            return source == .settled ? "Unsettle" : "Unsnooze"
+        }
+
+        private func accessibilityActions(_ thread: FeatureThread, section: ThreadArrangementSection) -> [UIAccessibilityCustomAction] {
+            var choices: [(String, ThreadArrangementDestination)] = []
+            if let orderSection = section.orderSection {
+                let ordered = DailyUXSidebarIndex.orderedSection(parent.model.snapshot.threads, section: orderSection, now: .now)
+                if let index = ordered.firstIndex(where: { $0.id == thread.id }) {
+                    if index > 0 {
+                        choices.append(("Move up", .init(section: section, targetID: ordered[index - 1].id)))
+                    }
+                    if index + 1 < ordered.count {
+                        choices.append(("Move down", .init(section: section, targetID: ordered[index + 1].id, after: true)))
+                    }
+                }
+            }
+            for destination in [ThreadArrangementSection.pinned, .active, .settled] where destination != section {
+                choices.append((action(source: section, destination: destination), .init(section: destination)))
+            }
+            return choices.compactMap { name, destination in
+                guard parent.model.arrangementPlan(id: thread.id, destination: destination) != nil else { return nil }
+                return UIAccessibilityCustomAction(name: name) { [weak self] _ in
+                    guard let self, self.parent.model.arrangementPlan(id: thread.id, destination: destination) != nil else { return false }
+                    self.commit(thread.id, destination: destination)
+                    return true
+                }
+            }
+        }
+    }
+}
diff --git a/apps/swift-ios/Features/Workspace/WorkspaceView.swift b/apps/swift-ios/Features/Workspace/WorkspaceView.swift
index 87678f4b0952..6a2de20a94fb 100644
--- a/apps/swift-ios/Features/Workspace/WorkspaceView.swift
+++ b/apps/swift-ios/Features/Workspace/WorkspaceView.swift
@@ -55,6 +55,7 @@ public struct WorkspaceView: View {
     @State private var showingAddProject = false
     @State private var showingEnvironments = false
     @State private var showingSettings = false
+    @State private var showingThreadArrangement = false
     @State private var renamingThread: FeatureThread?
     @State private var deletingThread: FeatureThread?
     @State private var renameTitle = ""
@@ -120,6 +121,9 @@ public struct WorkspaceView: View {
         .sheet(isPresented: $showingSettings) {
             SettingsView(model: model)
         }
+        .sheet(isPresented: $showingThreadArrangement) {
+            ThreadArrangementView(model: model)
+        }
         .alert(
             "Rename thread",
             isPresented: Binding(
@@ -252,18 +256,7 @@ public struct WorkspaceView: View {
                 onPin: { thread, pinned in
                     Task { await model.setPinned(thread.id, pinned: pinned) }
                 },
-                onCanReorder: { thread in
-                    model.canReorder(thread)
-                },
-                onReorder: { thread, section, orderedIDs, completion in
-                    Task {
-                        completion(await model.reorderThread(
-                            thread.id,
-                            section: section,
-                            orderedIDs: orderedIDs
-                        ))
-                    }
-                },
+                onArrange: { showingThreadArrangement = true },
                 onDelete: { thread in
                     deletingThread = thread
                 },
diff --git a/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift b/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
index f4634f0cf896..22d412c7b596 100644
--- a/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
+++ b/apps/swift-ios/Tests/FeatureTests/HomeThreadSwipeActionTests.swift
@@ -9,71 +9,6 @@ import UIKit
 struct HomeThreadSwipeActionTests {
     private let now = Date(timeIntervalSince1970: 20_000)
 
-    @Test
-    func draggingAboveTheListScrollsWithoutNeedingAnEarlierScrollGesture() {
-        let initial = threadList(
-            client: SwipeSettlementClientStub(),
-            snapshot: snapshot(threads: (0..<70).map { thread(id: "\($0)") })
-        )
-        let coordinator = initial.makeCoordinator()
-        let collectionView = testCollectionView()
-        coordinator.configure(collectionView)
-        let controller = UIViewController()
-        let window = UIWindow(frame: CGRect(x: 0, y: 0, width: 800, height: 900))
-        window.rootViewController = controller
-        controller.view.addSubview(collectionView)
-        collectionView.frame = CGRect(x: 20, y: 150, width: 300, height: 600)
-        collectionView.contentInset.top = 4
-        window.isHidden = false
-        collectionView.layoutIfNeeded()
-        defer {
-            HomeThreadCollectionView.dismantleUIView(collectionView, coordinator: coordinator)
-            window.isHidden = true
-        }
-
-        let session = HomeDragSessionStub(point: CGPoint(x: 170, y: 130))
-        collectionView.contentOffset.y = 600
-        coordinator.collectionView(collectionView, dragSessionWillBegin: session)
-        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
-        #expect(collectionView.contentOffset.y < 600)
-
-        // A stationary finger stays in the header as content coordinates move.
-        let previous = collectionView.contentOffset.y
-        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
-        #expect(collectionView.contentOffset.y < previous)
-
-        // Leave in-list and downward scrolling to UIKit. A drag over another
-        // iPad pane or outside the window must not scroll this sidebar.
-        for point in [
-            CGPoint(x: 170, y: 160), CGPoint(x: 170, y: 740),
-            CGPoint(x: 500, y: 130), CGPoint(x: 10, y: 130),
-            CGPoint(x: 170, y: -10),
-        ] {
-            session.point = point
-            let offset = collectionView.contentOffset
-            coordinator.advanceDragAutoScroll(by: 1.0 / 60)
-            #expect(collectionView.contentOffset == offset)
-        }
-
-        session.point = CGPoint(x: 170, y: 130)
-        let top = -collectionView.adjustedContentInset.top
-        collectionView.contentOffset.y = top + 1
-        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
-        #expect(collectionView.contentOffset.y == top)
-        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
-        #expect(collectionView.contentOffset.y == top)
-
-        coordinator.collectionView(collectionView, dragSessionDidEnd: session)
-        collectionView.contentOffset.y = 600
-        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
-        #expect(collectionView.contentOffset.y == 600)
-
-        coordinator.collectionView(collectionView, dragSessionWillBegin: session)
-        HomeThreadCollectionView.dismantleUIView(collectionView, coordinator: coordinator)
-        coordinator.advanceDragAutoScroll(by: 1.0 / 60)
-        #expect(collectionView.contentOffset.y == 600)
-    }
-
     @Test
     func backKeepsTheMostRecentlyOpenedThreadHighlighted() {
         var selection = WorkspaceThreadSelection()
@@ -1247,8 +1182,7 @@ struct HomeThreadSwipeActionTests {
             },
             onSnooze: { _, _ in },
             onPin: { _, _ in },
-            onCanReorder: { _ in false },
-            onReorder: { _, _, _, completion in completion(true) },
+            onArrange: {},
             onDelete: { _ in },
             onPullRequestChange: { _, _, _ in }
         )
@@ -1282,20 +1216,6 @@ struct HomeThreadSwipeActionTests {
     }
 }
 
-@MainActor
-private final class HomeDragSessionStub: NSObject, UIDragSession {
-    var point: CGPoint
-    var localContext: Any?
-    let items: [UIDragItem] = []
-    let allowsMoveOperation = true
-    let isRestrictedToDraggingApplication = true
-
-    init(point: CGPoint) { self.point = point }
-    func location(in view: UIView) -> CGPoint { point }
-    func hasItemsConforming(toTypeIdentifiers typeIdentifiers: [String]) -> Bool { false }
-    func canLoadObjects(ofClass aClass: NSItemProviderReading.Type) -> Bool { false }
-}
-
 enum PendingSettlementEvent: CaseIterable {
     case thread
     case detail
diff --git a/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift b/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift
new file mode 100644
index 000000000000..4a80e514cf78
--- /dev/null
+++ b/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift
@@ -0,0 +1,138 @@
+import Foundation
+import Testing
+@testable import T3Code
+
+@Suite("Thread arrangement")
+struct ThreadArrangementTests {
+    private let now = Date(timeIntervalSince1970: 20_000)
+
+    @Test
+    func crossSectionMoveUsesAllProjectsAndScopedThreadIDs() throws {
+        var source = thread("same", environment: "two")
+        source.projectID = "another-project"
+        var first = thread("same", environment: "one")
+        first.pinnedAt = now
+        first.pinOrderKey = "f"
+        var last = thread("last", environment: "two")
+        last.pinnedAt = now
+        last.pinOrderKey = "t"
+        let plan = try #require(ThreadArrangementPlanner.plan(
+            id: source.id,
+            destination: .init(section: .pinned, targetID: last.id),
+            threads: [last, source, first],
+            connectedEnvironmentIDs: ["one", "two"],
+            now: now
+        ))
+        #expect(plan.orderedIDs == [first.id, source.id, last.id])
+        #expect(plan.assignments.count == 1)
+        #expect(plan.assignments[0].threadID == source.id)
+        #expect(plan.assignments[0].orderKey > "f")
+        #expect(plan.assignments[0].orderKey < "t")
+        #expect(source.projectID == "another-project")
+    }
+
+    @Test
+    func liveSectionsAcceptDropsWhenEmpty() throws {
+        var source = thread("source")
+        source.pinnedAt = now
+        let active = try #require(plan(source, destination: .active))
+        #expect(active.orderedIDs == [source.id])
+        #expect(active.assignments.count == 1)
+        source.pinnedAt = nil
+        let pinned = try #require(plan(source, destination: .pinned))
+        #expect(pinned.orderedIDs == [source.id])
+    }
+
+    @Test
+    func reopeningClearsEveryParkedStateBeforeReordering() {
+        var source = thread("source")
+        source.pinnedAt = now
+        source.isSettled = true
+        source.snoozedUntil = now.addingTimeInterval(100)
+        #expect(ThreadArrangementPlanner.lifecycle(source, section: .active, now: now)
+            == [.unpin, .unsettle, .unsnooze])
+        // The server's pin command clears settlement and snooze itself.
+        #expect(ThreadArrangementPlanner.lifecycle(source, section: .pinned, now: now) == [.pin])
+        #expect(plan(source, destination: .active) != nil)
+        #expect(plan(source, destination: .pinned) != nil)
+    }
+
+    @Test
+    func staleOrUnsupportedLifecycleMovesDoNotWriteKeys() {
+        var source = thread("source")
+        source.supportsPinning = nil
+        #expect(plan(source, destination: .pinned) == nil)
+        source.supportsPinning = true
+        source.isSettled = true
+        source.supportsSettlement = nil
+        #expect(plan(source, destination: .pinned) == nil)
+        source.supportsSettlement = true
+        source.snoozedUntil = now.addingTimeInterval(100)
+        source.supportsSnooze = nil
+        #expect(plan(source, destination: .active) == nil)
+        source.supportsSnooze = true
+        source.supportsActiveReorder = nil
+        #expect(plan(source, destination: .active) == nil)
+        #expect(ThreadArrangementPlanner.plan(
+            id: source.id, destination: .init(section: .pinned), threads: [source],
+            connectedEnvironmentIDs: [], now: now
+        ) == nil)
+    }
+
+    @Test
+    func settlementRejectsLiveWorkAndSnoozedIsNotADropDestination() {
+        var source = thread("source")
+        #expect(plan(source, destination: .settled)?.section == nil)
+        #expect(plan(source, destination: .settled) != nil)
+        #expect(plan(source, destination: .snoozed) == nil)
+        source.state = .working
+        #expect(plan(source, destination: .settled) == nil)
+        source.state = .idle
+        source.isArchived = true
+        #expect(plan(source, destination: .active) == nil)
+        #expect(plan(source, destination: .pinned) == nil)
+        #expect(plan(source, destination: .settled) == nil)
+    }
+
+    @Test
+    func staleTargetDoesNotBecomeAnIndexMove() {
+        let source = thread("source")
+        #expect(ThreadArrangementPlanner.plan(
+            id: source.id, destination: .init(section: .pinned, targetID: "deleted"),
+            threads: [source], connectedEnvironmentIDs: ["one"], now: now
+        ) == nil)
+        #expect(plan(source, destination: .active) == nil)
+    }
+
+    @Test
+    func aCrossSectionSpreadCannotWriteAnOfflineNeighbor() {
+        let source = thread("source")
+        var offline = thread("neighbor", environment: "two")
+        offline.pinnedAt = now
+        #expect(ThreadArrangementPlanner.plan(
+            id: source.id, destination: .init(section: .pinned), threads: [source, offline],
+            connectedEnvironmentIDs: ["one"], now: now
+        ) == nil)
+        offline.pinOrderKey = "m"
+        #expect(ThreadArrangementPlanner.plan(
+            id: source.id, destination: .init(section: .pinned), threads: [source, offline],
+            connectedEnvironmentIDs: ["one"], now: now
+        )?.assignments.map(\.threadID) == [source.id])
+    }
+
+    private func plan(_ source: FeatureThread, destination: ThreadArrangementSection) -> ThreadArrangementPlanner.Plan? {
+        ThreadArrangementPlanner.plan(
+            id: source.id, destination: .init(section: destination), threads: [source],
+            connectedEnvironmentIDs: ["one"], now: now
+        )
+    }
+
+    private func thread(_ id: String, environment: String = "one") -> FeatureThread {
+        FeatureThread(
+            id: "\(environment):\(id)", wireID: id, projectID: "project", environmentID: environment,
+            title: id, createdAt: now, updatedAt: now,
+            supportsSettlement: true, supportsSnooze: true, supportsPinning: true,
+            supportsPinReorder: true, supportsActiveReorder: true
+        )
+    }
+}

From ca5fd6d49130370cc4355bd8f5756c7c630e763d Mon Sep 17 00:00:00 2001
From: Theo Browne <me@t3.gg>
Date: Sun, 13 Sep 2026 21:26:43 -0700
Subject: [PATCH 08/10] fix(swift-ios): validate arrangement shelf targets

---
 .../Features/Workspace/ThreadArrangementPlanner.swift  |  2 +-
 .../Features/Workspace/ThreadArrangementView.swift     | 10 +++++++++-
 .../Tests/FeatureTests/ThreadArrangementTests.swift    |  1 +
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift b/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift
index 57eefca5b6a6..8444bdef9e5e 100644
--- a/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift
+++ b/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift
@@ -61,12 +61,12 @@ enum ThreadArrangementPlanner {
         guard !thread.isArchived, ThreadOrderPlanner.isWritable(thread, section: section) else {
             return false
         }
+        if thread.isEffectivelySettled(), thread.supportsSettlement != true { return false }
         let source = self.section(of: thread, now: now)
         if source.orderSection == section { return true }
         if (section == .pinned || thread.pinnedAt != nil), thread.supportsPinning != true {
             return false
         }
-        if thread.isEffectivelySettled(), thread.supportsSettlement != true { return false }
         if thread.isEffectivelySnoozed(at: now), thread.supportsSnooze != true { return false }
         return true
     }
diff --git a/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift b/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift
index df6a45c60ccf..23fe8c798ea6 100644
--- a/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift
+++ b/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift
@@ -244,6 +244,11 @@ private struct ThreadArrangementCollection: UIViewRepresentable {
             dragSessionIsRestrictedToDraggingApplication session: UIDragSession
         ) -> Bool { true }
 
+        func collectionView(
+            _ collectionView: UICollectionView,
+            dragSessionAllowsMoveOperation session: UIDragSession
+        ) -> Bool { true }
+
         func collectionView(_ collectionView: UICollectionView, dragSessionDidEnd session: UIDragSession) {
             draggedID = nil
             parent.onAction(nil)
@@ -274,7 +279,10 @@ private struct ThreadArrangementCollection: UIViewRepresentable {
             if let source = rows.first(where: { $0.thread?.id == id }) {
                 parent.onAction(action(source: source.section, destination: destination.section))
             }
-            return UICollectionViewDropProposal(operation: .move, intent: .insertAtDestinationIndexPath)
+            return UICollectionViewDropProposal(
+                operation: .move,
+                intent: destination.targetID == nil ? .insertIntoDestinationIndexPath : .insertAtDestinationIndexPath
+            )
         }
 
         func collectionView(_ collectionView: UICollectionView, performDropWith coordinator: UICollectionViewDropCoordinator) {
diff --git a/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift b/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift
index 4a80e514cf78..127521277f5b 100644
--- a/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift
+++ b/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift
@@ -66,6 +66,7 @@ struct ThreadArrangementTests {
         source.isSettled = true
         source.supportsSettlement = nil
         #expect(plan(source, destination: .pinned) == nil)
+        #expect(plan(source, destination: .active) == nil)
         source.supportsSettlement = true
         source.snoozedUntil = now.addingTimeInterval(100)
         source.supportsSnooze = nil

From 1d22303b6ef5473c16021fea35acdeeb8dfdb841 Mon Sep 17 00:00:00 2001
From: Theo Browne <me@t3.gg>
Date: Sun, 13 Sep 2026 21:29:06 -0700
Subject: [PATCH 09/10] fix(swift-ios): keep end-of-section drops in their
 section

---
 .../Workspace/ThreadArrangementPlanner.swift  | 26 ++++++++++++++++++
 .../Workspace/ThreadArrangementView.swift     | 27 +++++++++----------
 .../FeatureTests/ThreadArrangementTests.swift | 22 +++++++++++++++
 3 files changed, 61 insertions(+), 14 deletions(-)

diff --git a/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift b/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift
index 8444bdef9e5e..1a2e3e2a1641 100644
--- a/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift
+++ b/apps/swift-ios/Features/Workspace/ThreadArrangementPlanner.swift
@@ -20,6 +20,12 @@ struct ThreadArrangementDestination: Equatable {
     var after = false
 }
 
+struct ThreadArrangementRow {
+    let section: ThreadArrangementSection
+    var thread: FeatureThread?
+    var id: String { thread.map { "thread:\($0.id)" } ?? "section:\(section.rawValue)" }
+}
+
 /// Resolves drops against all environments, without the Home project filter.
 /// A destination identifies a row rather than an index so a stale drag cannot
 /// silently move next to a different thread.
@@ -34,6 +40,26 @@ enum ThreadArrangementPlanner {
         let assignments: [FeatureThreadOrderAssignment]
     }
 
+    static func destination(
+        rows: [ThreadArrangementRow],
+        insertionIndex: Int,
+        isBeforeHeader: Bool
+    ) -> ThreadArrangementDestination? {
+        if insertionIndex == rows.count, let last = rows.last {
+            return .init(section: last.section, targetID: last.thread?.id, after: true)
+        }
+        guard rows.indices.contains(insertionIndex) else { return nil }
+        let row = rows[insertionIndex]
+        // UIKit uses the next header's index for the preceding section's end.
+        // A pointer on the header itself still targets that section, including
+        // empty sections and the collapsed Settled shelf.
+        if row.thread == nil, isBeforeHeader, insertionIndex > 0 {
+            let previous = rows[insertionIndex - 1]
+            return .init(section: previous.section, targetID: previous.thread?.id, after: true)
+        }
+        return .init(section: row.section, targetID: row.thread?.id)
+    }
+
     static func lifecycle(
         _ thread: FeatureThread,
         section: FeatureThreadOrderSection,
diff --git a/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift b/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift
index 23fe8c798ea6..fbe14cb1b14d 100644
--- a/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift
+++ b/apps/swift-ios/Features/Workspace/ThreadArrangementView.swift
@@ -93,11 +93,7 @@ private struct ThreadArrangementCollection: UIViewRepresentable {
     @MainActor
     final class Coordinator: NSObject, UICollectionViewDelegate,
         UICollectionViewDragDelegate, UICollectionViewDropDelegate {
-        struct Row {
-            let section: ThreadArrangementSection
-            var thread: FeatureThread?
-            var id: String { thread.map { "thread:\($0.id)" } ?? "section:\(section.rawValue)" }
-        }
+        typealias Row = ThreadArrangementRow
 
         var parent: ThreadArrangementCollection
         private weak var view: UICollectionView?
@@ -255,14 +251,14 @@ private struct ThreadArrangementCollection: UIViewRepresentable {
             update()
         }
 
-        private func destination(at indexPath: IndexPath?) -> ThreadArrangementDestination? {
+        private func destination(at indexPath: IndexPath?, location: CGPoint) -> ThreadArrangementDestination? {
             guard let indexPath, indexPath.section == 0 else { return nil }
-            if indexPath.item == rows.count, let last = rows.last {
-                return ThreadArrangementDestination(section: last.section, targetID: last.thread?.id, after: true)
-            }
-            guard rows.indices.contains(indexPath.item) else { return nil }
-            let row = rows[indexPath.item]
-            return ThreadArrangementDestination(section: row.section, targetID: row.thread?.id)
+            let frame = view?.layoutAttributesForItem(at: indexPath)?.frame
+            return ThreadArrangementPlanner.destination(
+                rows: rows,
+                insertionIndex: indexPath.item,
+                isBeforeHeader: frame.map { location.y < $0.minY } ?? false
+            )
         }
 
         func collectionView(
@@ -271,7 +267,7 @@ private struct ThreadArrangementCollection: UIViewRepresentable {
             withDestinationIndexPath indexPath: IndexPath?
         ) -> UICollectionViewDropProposal {
             guard session.localDragSession != nil, let id = draggedID,
-                  let destination = destination(at: indexPath),
+                  let destination = destination(at: indexPath, location: session.location(in: collectionView)),
                   parent.model.arrangementPlan(id: id, destination: destination) != nil else {
                 parent.onAction(nil)
                 return UICollectionViewDropProposal(operation: .forbidden)
@@ -287,7 +283,10 @@ private struct ThreadArrangementCollection: UIViewRepresentable {
 
         func collectionView(_ collectionView: UICollectionView, performDropWith coordinator: UICollectionViewDropCoordinator) {
             guard let id = draggedID, let item = coordinator.items.first,
-                  let destination = destination(at: coordinator.destinationIndexPath),
+                  let destination = destination(
+                    at: coordinator.destinationIndexPath,
+                    location: coordinator.session.location(in: collectionView)
+                  ),
                   parent.model.arrangementPlan(id: id, destination: destination) != nil,
                   let moved = rows.first(where: { $0.thread?.id == id })?.thread else { return }
             var next = rows.filter { $0.thread?.id != id }
diff --git a/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift b/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift
index 127521277f5b..25d05e72a39d 100644
--- a/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift
+++ b/apps/swift-ios/Tests/FeatureTests/ThreadArrangementTests.swift
@@ -6,6 +6,28 @@ import Testing
 struct ThreadArrangementTests {
     private let now = Date(timeIntervalSince1970: 20_000)
 
+    @Test
+    func sectionBoundaryAndSectionHeaderAreDifferentDropTargets() {
+        let pinned = thread("pinned")
+        let active = thread("active")
+        let rows: [ThreadArrangementRow] = [
+            .init(section: .pinned), .init(section: .pinned, thread: pinned),
+            .init(section: .active), .init(section: .active, thread: active),
+            .init(section: .settled),
+        ]
+        #expect(ThreadArrangementPlanner.destination(rows: rows, insertionIndex: 2, isBeforeHeader: true)
+            == .init(section: .pinned, targetID: pinned.id, after: true))
+        #expect(ThreadArrangementPlanner.destination(rows: rows, insertionIndex: 2, isBeforeHeader: false)
+            == .init(section: .active))
+        #expect(ThreadArrangementPlanner.destination(rows: rows, insertionIndex: 4, isBeforeHeader: true)
+            == .init(section: .active, targetID: active.id, after: true))
+        #expect(ThreadArrangementPlanner.destination(rows: rows, insertionIndex: 4, isBeforeHeader: false)
+            == .init(section: .settled))
+        #expect(ThreadArrangementPlanner.destination(
+            rows: [.init(section: .pinned), .init(section: .active)], insertionIndex: 1, isBeforeHeader: true
+        ) == .init(section: .pinned, after: true))
+    }
+
     @Test
     func crossSectionMoveUsesAllProjectsAndScopedThreadIDs() throws {
         var source = thread("same", environment: "two")

From 3b96928191ac7f825077b5a447995a7ada1bd36a Mon Sep 17 00:00:00 2001
From: Theo Browne <me@t3.gg>
Date: Sun, 13 Sep 2026 21:30:03 -0700
Subject: [PATCH 10/10] fix(swift-ios): retain settled shelf visibility filter

---
 apps/swift-ios/Features/Workspace/DailyUXModels.swift | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/apps/swift-ios/Features/Workspace/DailyUXModels.swift b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
index fd653b73d62d..059047939769 100644
--- a/apps/swift-ios/Features/Workspace/DailyUXModels.swift
+++ b/apps/swift-ios/Features/Workspace/DailyUXModels.swift
@@ -708,6 +708,8 @@ struct DailyUXSidebarIndex {
             guard !thread.isArchived else { return false }
             return projectID == nil || thread.projectID == projectID
         }
+        let available = visible.filter { !$0.isEffectivelySnoozed(at: now) }
+
         pinned = Self.orderedSection(visible, section: .pinned, now: now)
 
         active = Self.orderedSection(visible, section: .active, now: now)