fix(remote): stop button gives immediate feedback and prevents stuck thinking on remote server

apps/mobile/src/features/threads/PendingUserInputCard.tsx

@@ -36,6 +36,8 @@ export interface PendingUserInputCardProps {
   readonly onToggleCollapsed: () => void;
   /** Renders a stop control on the collapsed bar, which replaces the composer. */
   readonly onStopThread?: () => void;
+  /** Optimistic Stop feedback while the interrupt settles (#8618). */
+  readonly isStoppingThread?: boolean;
   /**
    * 0 collapsed → 1 expanded. Slides the iOS overlay card down behind the
    * collapsed bar (inside a clipping window) on the UI thread; the host
@@ -187,10 +189,11 @@ export function PendingUserInputCard(props: PendingUserInputCardProps) {
       </Pressable>
       {props.onStopThread ? (
         <ControlPill
-          accessibilityLabel="Stop"
+          accessibilityLabel={props.isStoppingThread ? "Stopping" : "Stop"}
           icon="stop.fill"
           variant="danger"
           className="h-9 w-9"
+          disabled={props.isStoppingThread}
           onPress={props.onStopThread}
         />
       ) : null}

apps/mobile/src/features/threads/ThreadComposer.tsx

@@ -124,6 +124,8 @@ export interface ThreadComposerProps {
   readonly onNativePasteImages: (uris: ReadonlyArray<string>) => Promise<void>;
   readonly onRemoveDraftImage: (imageId: string) => void;
   readonly onStopThread: () => void;
+  /** Optimistic Stop feedback: disables Stop while the interrupt settles (#8618). */
+  readonly isStoppingThread: boolean;
   readonly onSendMessage: () => Promise<MessageId | null>;
   readonly onUpdateModelSelection: (modelSelection: ModelSelection) => void;
   readonly onUpdateRuntimeMode: (runtimeMode: RuntimeMode) => void;
@@ -716,9 +718,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
                 />
                 {showStopAction ? (
                   <ComposerActionButton
-                    accessibilityLabel="Stop agent"
+                    accessibilityLabel={props.isStoppingThread ? "Stopping agent" : "Stop agent"}
                     icon="stop.fill"
                     variant="danger"
+                    disabled={props.isStoppingThread}
                     onPress={props.onStopThread}
                   />
                 ) : (
@@ -807,9 +810,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
                   />
                   {showStopAction ? (
                     <ComposerActionButton
-                      accessibilityLabel="Stop agent"
+                      accessibilityLabel={props.isStoppingThread ? "Stopping agent" : "Stop agent"}
                       icon="stop.fill"
                       variant="danger"
+                      disabled={props.isStoppingThread}
                       onPress={props.onStopThread}
                     />
                   ) : voicePresentation.showsSend ? (

apps/mobile/src/features/threads/ThreadDetailScreen.tsx

@@ -127,6 +127,8 @@ export interface ThreadDetailScreenProps {
   readonly onNativePasteImages: (uris: ReadonlyArray<string>) => Promise<void>;
   readonly onRemoveDraftImage: (imageId: string) => void;
   readonly onStopThread: () => void;
+  /** Optimistic Stop feedback: set on press, cleared when work ends (#8618). */
+  readonly isStoppingThread: boolean;
   readonly onSendMessage: () => Promise<MessageId | null>;
   readonly onReconnectEnvironment: () => void;
   readonly onUpdateThreadModelSelection: (modelSelection: ModelSelection) => void;
@@ -780,6 +782,7 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
                         collapsed={userInputCollapsed}
                         onToggleCollapsed={handleToggleUserInputCollapsed}
                         onStopThread={props.onStopThread}
+                        isStoppingThread={props.isStoppingThread}
                         cardProgress={userInputCardProgress}
                         cardCoverage={userInputCardCoverage}
                         onInputFocusChange={handleOwnedInputFocusChange}
@@ -820,6 +823,7 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
                   onNativePasteImages={props.onNativePasteImages}
                   onRemoveDraftImage={props.onRemoveDraftImage}
                   onStopThread={props.onStopThread}
+                  isStoppingThread={props.isStoppingThread}
                   onSendMessage={handleSendMessage}
                   onReconnectEnvironment={props.onReconnectEnvironment}
                   onUpdateModelSelection={props.onUpdateThreadModelSelection}

apps/mobile/src/features/threads/ThreadRouteScreen.tsx

@@ -214,6 +214,18 @@ function ThreadRouteContent(
   const gitActions = useSelectedThreadGitActions();
   const requests = useSelectedThreadRequests();
   const interruptThreadTurn = useAtomCommand(threadEnvironment.interruptTurn, "thread interrupt");
+  const [isStoppingThread, setIsStoppingThread] = useState(false);
+  const selectedThreadSessionStatus = selectedThread?.session?.status ?? null;
+  const selectedThreadIdentity = selectedThread
+    ? scopedThreadKey(selectedThread.environmentId, selectedThread.id)
+    : null;
+  useEffect(() => {
+    // "Stopping" holds until the session leaves running/starting; per-thread
+    // so a switch never leaks the state onto another thread.
+    if (selectedThreadSessionStatus !== "running" && selectedThreadSessionStatus !== "starting") {
+      setIsStoppingThread(false);
+    }
+  }, [selectedThreadIdentity, selectedThreadSessionStatus]);
   const navigation = useNavigation();
   const params = props.route.params;
   const environmentIdRaw = firstRouteParam(params.environmentId);
@@ -486,14 +498,22 @@ function ThreadRouteContent(
     ) {
       return;
     }
-    return interruptThreadTurn({
+    // Optimistic stopping feedback for remote links: holds until the session
+    // leaves running/starting (reset effect below); a failed interrupt clears
+    // it immediately so Stop never sticks (#8618).
+    setIsStoppingThread(true);
+    void interruptThreadTurn({
       environmentId: selectedThread.environmentId,
       input: {
         threadId: selectedThread.id,
         ...(selectedThread.session.activeTurnId
           ? { turnId: selectedThread.session.activeTurnId }
           : {}),
       },
+    }).then((result) => {
+      if (result._tag === "Failure") {
+        setIsStoppingThread(false);
+      }
     });
   }, [interruptThreadTurn, selectedThread]);
 
@@ -799,6 +819,7 @@ function ThreadRouteContent(
           onRemoveDraftImage={composer.onRemoveDraftImage}
           serverConfig={serverConfig}
           onStopThread={handleStopThread}
+          isStoppingThread={isStoppingThread}
           onSendMessage={composer.onSendMessage}
           onReconnectEnvironment={handleReconnectEnvironment}
           onUpdateThreadModelSelection={composer.onUpdateModelSelection}

apps/server/src/orchestration/Layers/ProjectionPipeline.test.ts

@@ -1839,6 +1839,99 @@ it.layer(BaseTestLayer)("OrchestrationProjectionPipeline", (it) => {
     }),
   );
 
+  it.effect(
+    "marks the session-pinned turn interrupted when the interrupt request omits turnId",
+    () =>
+      Effect.gen(function* () {
+        const projectionPipeline = yield* OrchestrationProjectionPipeline;
+        const eventStore = yield* OrchestrationEventStore;
+        const sql = yield* SqlClient.SqlClient;
+        const now = "2026-01-01T00:00:00.000Z";
+        const threadId = ThreadId.make("thread-interrupt-no-turn-id");
+        const turnId = TurnId.make("turn-no-turn-id-1");
+
+        yield* eventStore.append({
+          type: "thread.created",
+          eventId: EventId.make("evt-nti1"),
+          aggregateKind: "thread",
+          aggregateId: threadId,
+          occurredAt: now,
+          commandId: CommandId.make("cmd-nti1"),
+          causationEventId: null,
+          correlationId: CorrelationId.make("cmd-nti1"),
+          metadata: {},
+          payload: {
+            threadId,
+            projectId: ProjectId.make("project-no-turn-id"),
+            title: "Interrupt without turn id",
+            modelSelection: {
+              instanceId: ProviderInstanceId.make("codex"),
+              model: "gpt-5-codex",
+            },
+            runtimeMode: "full-access",
+            branch: null,
+            worktreePath: null,
+            createdAt: now,
+            updatedAt: now,
+          },
+        });
+
+        yield* eventStore.append({
+          type: "thread.session-set",
+          eventId: EventId.make("evt-nti2"),
+          aggregateKind: "thread",
+          aggregateId: threadId,
+          occurredAt: "2026-01-01T00:00:01.000Z",
+          commandId: CommandId.make("cmd-nti2"),
+          causationEventId: null,
+          correlationId: CorrelationId.make("cmd-nti2"),
+          metadata: {},
+          payload: {
+            threadId,
+            session: {
+              threadId,
+              status: "running",
+              providerName: "codex",
+              runtimeMode: "full-access",
+              activeTurnId: turnId,
+              lastError: null,
+              updatedAt: "2026-01-01T00:00:01.000Z",
+            },
+          },
+        });
+
+        // Remote snapshots lag, so Stop can persist an interrupt request
+        // without a turnId — the pinned turn must still be settled (#8618).
+        yield* eventStore.append({
+          type: "thread.turn-interrupt-requested",
+          eventId: EventId.make("evt-nti3"),
+          aggregateKind: "thread",
+          aggregateId: threadId,
+          occurredAt: "2026-01-01T00:00:02.000Z",
+          commandId: CommandId.make("cmd-nti3"),
+          causationEventId: null,
+          correlationId: CorrelationId.make("cmd-nti3"),
+          metadata: {},
+          payload: {
+            threadId,
+            createdAt: "2026-01-01T00:00:02.000Z",
+          },
+        });
+
+        yield* projectionPipeline.bootstrap;
+
+        const rows = yield* sql<{
+          readonly state: string;
+          readonly completedAt: string | null;
+        }>`
+          SELECT state, completed_at AS "completedAt"
+          FROM projection_turns
+          WHERE thread_id = ${threadId} AND turn_id = ${turnId}
+        `;
+        assert.deepEqual(rows, [{ state: "interrupted", completedAt: "2026-01-01T00:00:02.000Z" }]);
+      }),
+  );
+
   it.effect("settles a superseded running turn when a new turn becomes active", () =>
     Effect.gen(function* () {
       const projectionPipeline = yield* OrchestrationProjectionPipeline;

apps/server/src/orchestration/Layers/ProjectionPipeline.ts

@@ -1472,12 +1472,25 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
         }
 
         case "thread.turn-interrupt-requested": {
-          if (event.payload.turnId === undefined) {
+          // Remote snapshots lag, so Stop often arrives without a turnId
+          // (see buildThreadTurnInterruptInput). Fall back to the session's
+          // pinned turn instead of dropping the interrupt on the floor — a
+          // turnId-less interrupt must still settle the running turn (#8618).
+          let effectiveTurnId = event.payload.turnId;
+          if (effectiveTurnId === undefined) {
+            const session = yield* projectionThreadSessionRepository.getByThreadId({
+              threadId: event.payload.threadId,
+            });
+            if (Option.isSome(session) && session.value.activeTurnId !== null) {
+              effectiveTurnId = session.value.activeTurnId;
+            }
+          }
+          if (effectiveTurnId === undefined) {
             return;
           }
           const existingTurn = yield* projectionTurnRepository.getByTurnId({
             threadId: event.payload.threadId,
-            turnId: event.payload.turnId,
+            turnId: effectiveTurnId,
           });
           if (Option.isSome(existingTurn)) {
             yield* projectionTurnRepository.upsertByTurnId({
@@ -1490,7 +1503,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
             return;
           }
           yield* projectionTurnRepository.upsertByTurnId({
-            turnId: event.payload.turnId,
+            turnId: effectiveTurnId,
             threadId: event.payload.threadId,
             pendingMessageId: null,
             sourceProposedPlanThreadId: null,