fix(swift-ios): retain Stop feedback until the session is inactive

apps/swift-ios/Core/T3Client.swift

@@ -638,6 +638,29 @@ public actor T3Client {
         )
     }
 
+    /// Passive shells start with a full snapshot on each socket subscription.
+    /// Registering its identity atomically prevents late socket results from
+    /// acquiring authority over a replacement connection.
+    public func shellEventsOnCurrentConnection() async throws -> (
+        events: AsyncThrowingStream<ShellStreamItem, Error>, connectionID: UUID
+    ) {
+        try await rpc.subscribeOnCurrentConnection(
+            RPCMethod.subscribeShell.rawValue,
+            payload: .object(["requestCompletionMarker": .bool(true)]),
+            as: ShellStreamItem.self
+        )
+    }
+
+    public func shellEventBatchesOnCurrentConnection() async throws -> (
+        events: AsyncThrowingStream<[ShellStreamItem], Error>, connectionID: UUID
+    ) {
+        try await rpc.subscribeBatchesOnCurrentConnection(
+            RPCMethod.subscribeShell.rawValue,
+            payload: .object(["requestCompletionMarker": .bool(true)]),
+            as: ShellStreamItem.self
+        )
+    }
+
     public func threadEventBatches(
         threadID: String,
         after sequence: Int? = nil,

apps/swift-ios/Features/Chat/FeatureComposerView.swift

@@ -70,6 +70,8 @@ struct FeatureComposerView: View {
     private let materializesDefaultSelection: Bool
     private let isSending: Bool
     private let isWorking: Bool
+    private let stopPhase: FeatureStopPhase?
+    private let onRetryStop: (() -> Void)?
     @Binding private var focused: Bool
     private let contextUsage: Double?
     private let forceExpanded: Bool
@@ -100,6 +102,8 @@ struct FeatureComposerView: View {
         materializesDefaultSelection: Bool = true,
         isSending: Bool,
         isWorking: Bool,
+        stopPhase: FeatureStopPhase? = nil,
+        onRetryStop: (() -> Void)? = nil,
         focused: Binding<Bool>,
         onSend: @escaping () -> Void,
         onStop: @escaping () -> Void,
@@ -141,6 +145,8 @@ struct FeatureComposerView: View {
         self.materializesDefaultSelection = materializesDefaultSelection
         self.isSending = isSending
         self.isWorking = isWorking
+        self.stopPhase = stopPhase
+        self.onRetryStop = onRetryStop
         _focused = focused
         self.onSend = onSend
         self.onStop = onStop
@@ -288,12 +294,28 @@ struct FeatureComposerView: View {
 
     private var composerSurfaceContent: some View {
         VStack(spacing: 0) {
+            if let stopPhase {
+                HStack {
+                    Text(stopIsUnconfirmed
+                         ? "Stop unconfirmed. Waiting for the thread’s status."
+                         : "Stopping… Waiting for the agent to finish.")
+                    if stopPhase == .unconfirmed, let onRetryStop {
+                        Button("Retry stop", action: onRetryStop)
+                            .disabled(!environmentIsConnected)
+                    }
+                }
+                .font(T3Typography.supporting)
+                .foregroundStyle(T3Colors.textSecondary)
+                .padding(.horizontal, 12)
+                .padding(.vertical, 8)
+                .accessibilityIdentifier("thread-stop-status")
+            }
             if let approval = pendingApprovals.first, let onApprovalDecision {
                 FeatureComposerApprovalPanel(
                     approval: approval,
                     position: 1,
                     total: pendingApprovals.count,
-                    isResponding: resolvingRequestIDs.contains(approval.id),
+                    isResponding: resolvingRequestIDs.contains(approval.id) || stopPhase != nil,
                     onDecision: { decision in
                         onApprovalDecision(approval.id, decision)
                     },
@@ -310,6 +332,8 @@ struct FeatureComposerView: View {
                     environmentID: environmentID,
                     attachmentPreferences: attachmentPreferences
                 )
+                .disabled(stopPhase != nil)
+                .opacity(stopPhase != nil ? 0.56 : 1)
             } else if isExpanded {
                 expandedComposer
             } else {
@@ -724,12 +748,18 @@ struct FeatureComposerView: View {
     }
 
     private var submitSymbol: String {
-        if isSending { return "ellipsis" }
+        if isSending || (showsStop && stopPhase != nil) { return "ellipsis" }
         return showsStop ? "stop.fill" : "arrow.up"
     }
 
+    private var stopIsUnconfirmed: Bool {
+        stopPhase != nil && (stopPhase == .unconfirmed || !environmentIsConnected)
+    }
+
     private var submitAccessibilityLabel: String {
         if isSending { return "Sending message" }
+        if showsStop, stopIsUnconfirmed { return "Stop outcome unconfirmed" }
+        if showsStop, stopPhase != nil { return "Stopping agent" }
         if showsStop { return "Stop agent" }
         return isWorking ? "Queue message" : "Send message"
     }
@@ -754,7 +784,7 @@ struct FeatureComposerView: View {
     }
 
     private var submitDisabled: Bool {
-        isSending || (!showsStop && !canSend)
+        isSending || (showsStop && stopPhase != nil) || (!showsStop && !canSend)
     }
 
     private var textIsEmpty: Bool {

apps/swift-ios/Features/Chat/ThreadDetailView.swift

@@ -14,6 +14,7 @@ public struct ThreadDetailView: View {
     let submitMessage: (FeatureMessageSubmission) async -> Bool
     let onNavigateBack: () -> Void
     private let draftStore: FeatureComposerDraftStore
+    private let managesThreadPresentation: Bool
 
     @State private var draft = ""
     @State private var composerContext: OrchestrationMessageContext?
@@ -52,20 +53,22 @@ public struct ThreadDetailView: View {
         thread: FeatureThread,
         submitMessage: @escaping (FeatureMessageSubmission) async -> Bool,
         onNavigateBack: @escaping () -> Void = {},
-        draftStore: FeatureComposerDraftStore = .shared
+        draftStore: FeatureComposerDraftStore = .shared,
+        managesThreadPresentation: Bool = true
     ) {
         self.model = model
         self.thread = thread
         self.submitMessage = submitMessage
         self.onNavigateBack = onNavigateBack
         self.draftStore = draftStore
+        self.managesThreadPresentation = managesThreadPresentation
     }
 
     private var threadContent: some View {
         Group {
             if let detail {
                 timeline(detail)
-            } else if isLoading {
+            } else if isOpening {
                 FeatureThreadOpeningView()
             } else {
                 ContentUnavailableView {
@@ -102,16 +105,27 @@ public struct ThreadDetailView: View {
             }
         }
         .task(id: thread.id) {
+            guard managesThreadPresentation else { return }
             isLoading = true
-            _ = await model.detail(for: thread.id, force: true)
-            isLoading = false
+            await model.runThreadPresentation(id: thread.id) {
+                isLoading = false
+            }
         }
         .task(id: thread.id) {
             // A cached thread can already show its composer while the server
             // is catching up. Local drafts must not wait for that request.
-            await model.checkRewindRecovery(for: currentThread)
-            guard !didRestoreDraft else { return }
-            await restoreDraft(from: composerDraft, key: draftKey)
+            // When a thread is reopened in the compact split view, SwiftUI can
+            // report this view as disappeared right after it appears while it
+            // stays on screen. That cancels this task and it never re-runs, so
+            // the composer would stay busy. Finish the restore outside the
+            // view's task lifetime; each thread has its own view identity, so
+            // a late restore cannot reach another thread's composer.
+            let restore = Task { @MainActor in
+                await model.checkRewindRecovery(for: currentThread)
+                guard !didRestoreDraft else { return }
+                await restoreDraft(from: composerDraft, key: draftKey)
+            }
+            await restore.value
         }
         .task(id: pullRequestObservationID) {
             await observeThreadPullRequest()
@@ -133,7 +147,7 @@ public struct ThreadDetailView: View {
         .onChange(of: threadConnectionState) { _, state in
             if state == .connected,
                case .failed = model.detailLoadStates[thread.id],
-               !isLoading {
+               !isOpening {
                 reloadThread()
             }
         }
@@ -143,7 +157,6 @@ public struct ThreadDetailView: View {
             }
         }
         .onDisappear {
-            model.releaseThread(thread.id)
             persistDraftBeforeLeaving()
         }
         .sheet(item: $toolSurface) { surface in
@@ -277,6 +290,12 @@ public struct ThreadDetailView: View {
         }
     }
 
+    private var isOpening: Bool {
+        if managesThreadPresentation { return isLoading }
+        if case .failed = model.detailLoadStates[thread.id] { return false }
+        return detail == nil || model.detailLoadStates[thread.id] == .loading
+    }
+
     private var detail: FeatureThreadDetail? {
         model.details[thread.id]
     }
@@ -683,10 +702,8 @@ public struct ThreadDetailView: View {
     }
 
     private func reloadThread() {
-        isLoading = true
-        Task {
-            _ = await model.detail(for: thread.id, force: true, fresh: true)
-            isLoading = false
+        if model.refreshThreadPresentation(id: thread.id, onLoaded: { isLoading = false }) {
+            isLoading = true
         }
     }
 
@@ -699,7 +716,7 @@ public struct ThreadDetailView: View {
         ThreadRefreshPresentation.resolve(
             loadState: model.detailLoadStates[thread.id],
             connectionState: threadConnectionState,
-            isOpening: isLoading,
+            isOpening: isOpening,
             syncState: model.threadSyncStates[thread.id]
         )
     }
@@ -850,10 +867,12 @@ public struct ThreadDetailView: View {
                     isSending: isSending || isRewinding || !didRestoreDraft,
                     isWorking: detail.thread.state == .working || detail.thread.state == .queued
                         || isCompacting,
+                    stopPhase: model.stopPhase(threadID: thread.id),
+                    onRetryStop: { model.retryCancelTurn(threadID: thread.id) },
                     focused: $composerFocused,
                     onSend: send,
                     onStop: {
-                        Task { await model.cancelTurn(threadID: thread.id) }
+                        model.requestCancelTurn(threadID: thread.id)
                     },
                     pendingApprovals: detail.approvals,
                     pendingUserInputs: detail.userInputs,