fix(mobile): make Stop work during preparing worktree phase

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

@@ -137,6 +137,10 @@ 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/cancel settles. */
+  readonly isStoppingThread: boolean;
+  /** True while the thread creation is still preparing (e.g. worktree checkout). */
+  readonly isPreparingCreation: boolean;
   readonly onSendMessage: () => Promise<MessageId | null>;
   /** `/usage-limits` resolves locally; the host decides where the report shows. Null clears it. */
   readonly onShowUsageLimits: (report: UsageLimitsReport | null) => void;
@@ -308,7 +312,15 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
   const showStopAction =
     !hasContent &&
     (props.selectedThread.session?.status === "running" ||
-      props.selectedThread.session?.status === "starting");
+      props.selectedThread.session?.status === "starting" ||
+      props.isPreparingCreation);
+  const stopAccessibilityLabel = props.isStoppingThread
+    ? "Stopping agent"
+    : props.isPreparingCreation &&
+        props.selectedThread.session?.status !== "running" &&
+        props.selectedThread.session?.status !== "starting"
+      ? "Cancel task setup"
+      : "Stop agent";
 
   const uploadStates = useAtomValue(composerAttachmentUploadsAtom);
   const attachmentsUploading =
@@ -804,9 +816,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
                 />
                 {showStopAction ? (
                   <ComposerActionButton
-                    accessibilityLabel="Stop agent"
+                    accessibilityLabel={stopAccessibilityLabel}
                     icon="stop.fill"
                     variant="danger"
+                    disabled={props.isStoppingThread}
                     onPress={props.onStopThread}
                   />
                 ) : (
@@ -895,9 +908,10 @@ export const ThreadComposer = memo(function ThreadComposer(props: ThreadComposer
                   />
                   {showStopAction ? (
                     <ComposerActionButton
-                      accessibilityLabel="Stop agent"
+                      accessibilityLabel={stopAccessibilityLabel}
                       icon="stop.fill"
                       variant="danger"
+                      disabled={props.isStoppingThread}
                       onPress={props.onStopThread}
                     />
                   ) : voicePresentation.showsSend ? (

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

@@ -157,6 +157,10 @@ 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 (#12187). */
+  readonly isStoppingThread: boolean;
+  /** True while the thread creation is still preparing (e.g. worktree checkout). */
+  readonly isPreparingCreation: boolean;
   readonly onSendMessage: () => Promise<MessageId | null>;
   readonly onReconnectEnvironment: () => void;
   readonly onUpdateThreadModelSelection: (modelSelection: ModelSelection) => void;
@@ -1051,6 +1055,8 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
                     onNativePasteImages={props.onNativePasteImages}
                     onRemoveDraftImage={props.onRemoveDraftImage}
                     onStopThread={props.onStopThread}
+                    isStoppingThread={props.isStoppingThread}
+                    isPreparingCreation={props.isPreparingCreation}
                     onSendMessage={handleSendMessage}
                     onShowUsageLimits={showUsageLimits}
                     onUpdateModelSelection={props.onUpdateThreadModelSelection}

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

@@ -26,7 +26,11 @@ import { Alert, Platform, ScrollView, View } from "react-native";
 import { useSafeAreaInsets } from "react-native-safe-area-context";
 import { useWorkspaceState } from "../../state/workspace";
 import { restoredNewTaskDraftKey } from "../../state/new-task-draft-key";
-import { clearPendingThreadCreationOutcome } from "../../state/pending-thread-creation";
+import {
+  clearPendingThreadCreationOutcome,
+  resolvePreparingStopAction,
+} from "../../state/pending-thread-creation";
+import { removeThreadOutboxMessage } from "../../state/thread-outbox-removal";
 import { recoverFailedThreadDraft } from "../../state/recover-failed-thread-draft";
 import { useEnvironmentQuery } from "../../state/query";
 import { dismissGitActionResult, useGitActionProgress } from "../../state/use-vcs-action-state";
@@ -498,24 +502,104 @@ function ThreadRouteContent(
   const handleOpenConnectionEditor = useCallback(() => {
     void navigation.navigate("Connections");
   }, [navigation]);
+  const [isStoppingThread, setIsStoppingThread] = useState(false);
   const handleStopThread = useCallback(() => {
-    if (
-      !selectedThread ||
-      (selectedThread.session?.status !== "running" &&
-        selectedThread.session?.status !== "starting")
-    ) {
+    const stopAction = resolvePreparingStopAction({
+      isPreparing:
+        selectedThreadCreation !== null && selectedThreadCreation.outcome?.kind !== "failed",
+      creationOutcomeKind:
+        selectedThreadCreation?.outcome?.kind === "delivered"
+          ? "delivered"
+          : selectedThreadCreation?.outcome?.kind === "failed"
+            ? "failed"
+            : null,
+      creationMessageId: selectedThreadCreation
+        ? String(selectedThreadCreation.message.messageId)
+        : null,
+      dispatchingMessageId: composer.dispatchingQueuedMessageId
+        ? String(composer.dispatchingQueuedMessageId)
+        : null,
+      sessionStatus: selectedThread?.session?.status ?? null,
+    });
+    // A still-queued creation has no server turn to interrupt: cancel it
+    // locally with immediate feedback instead of a silent no-op (#12187).
+    if (stopAction.kind === "cancel-queued-creation" && selectedThreadCreation) {
+      const queuedMessage = selectedThreadCreation.message;
+      const threadKey = routeThreadIdentity;
+      setIsStoppingThread(true);
+      void (async () => {
+        try {
+          const removed = await removeThreadOutboxMessage(queuedMessage);
+          if (!removed) {
+            return;
+          }
+          if (threadKey) {
+            clearPendingThreadCreationOutcome(threadKey);
+          }
+          if (navigation.canGoBack()) {
+            navigation.goBack();
+          } else {
+            navigation.dispatch(StackActions.replace("Home"));
+          }
+        } catch (error) {
+          Alert.alert(
+            "Could not cancel task",
+            error instanceof Error ? error.message : String(error),
+          );
+        } finally {
+          setIsStoppingThread(false);
+        }
+      })();
+      return;
+    }
+    if (stopAction.kind !== "interrupt-running-turn") {
       return;
     }
-    return interruptThreadTurn({
+    if (!selectedThread) {
+      return;
+    }
+    const activeSession = selectedThread.session;
+    if (!activeSession) {
+      return;
+    }
+    setIsStoppingThread(true);
+    const interrupt = interruptThreadTurn({
       environmentId: selectedThread.environmentId,
       input: {
         threadId: selectedThread.id,
-        ...(selectedThread.session.activeTurnId
-          ? { turnId: selectedThread.session.activeTurnId }
-          : {}),
+        ...(activeSession.activeTurnId ? { turnId: activeSession.activeTurnId } : {}),
       },
     });
-  }, [interruptThreadTurn, selectedThread]);
+    void interrupt.then((result) => {
+      if (result._tag === "Failure") {
+        setIsStoppingThread(false);
+      }
+    });
+  }, [
+    composer.dispatchingQueuedMessageId,
+    interruptThreadTurn,
+    navigation,
+    routeThreadIdentity,
+    selectedThread,
+    selectedThreadCreation,
+  ]);
+  // Optimistic Stop feedback clears once work actually ends, when switching
+  // threads, or immediately on a failed interrupt above (#12187).
+  const selectedThreadSessionStatus = selectedThread?.session?.status ?? null;
+  const selectedThreadIdentity = selectedThread
+    ? scopedThreadKey(selectedThread.environmentId, selectedThread.id)
+    : null;
+  const previousStopThreadIdentityRef = useRef<string | null>(null);
+  useEffect(() => {
+    if (previousStopThreadIdentityRef.current !== selectedThreadIdentity) {
+      previousStopThreadIdentityRef.current = selectedThreadIdentity;
+      setIsStoppingThread(false);
+      return;
+    }
+    if (selectedThreadSessionStatus !== "running" && selectedThreadSessionStatus !== "starting") {
+      setIsStoppingThread(false);
+    }
+  }, [selectedThreadIdentity, selectedThreadSessionStatus]);
 
   const handleOpenTerminal = useCallback(
     (nextTerminalId?: string | null) => {
@@ -894,6 +978,10 @@ function ThreadRouteContent(
           onRemoveDraftImage={composer.onRemoveDraftImage}
           serverConfig={serverConfig}
           onStopThread={handleStopThread}
+          isStoppingThread={isStoppingThread}
+          isPreparingCreation={
+            selectedThreadCreation !== null && selectedThreadCreation.outcome?.kind !== "failed"
+          }
           onSendMessage={composer.onSendMessage}
           onReconnectEnvironment={handleReconnectEnvironment}
           onUpdateThreadModelSelection={composer.onUpdateModelSelection}

apps/mobile/src/state/pending-thread-creation.test.ts

@@ -14,6 +14,7 @@ import {
   pendingThreadCreationMessage,
   pendingThreadCreationShell,
   resolvePendingThreadCreation,
+  resolvePreparingStopAction,
   type PendingThreadCreation,
 } from "./pending-thread-creation";
 import type { QueuedThreadMessage } from "./thread-outbox-model";
@@ -261,3 +262,67 @@ describe("pendingThreadCreationMessage", () => {
     expect(pendingThreadCreationMessage(creation)).not.toHaveProperty("attachments");
   });
 });
+
+describe("resolvePreparingStopAction", () => {
+  const creationMessageId = String(creation.messageId);
+
+  it("cancels a still-queued creation during preparing", () => {
+    expect(
+      resolvePreparingStopAction({
+        isPreparing: true,
+        creationOutcomeKind: null,
+        creationMessageId,
+        dispatchingMessageId: null,
+        sessionStatus: null,
+      }),
+    ).toEqual({ kind: "cancel-queued-creation" });
+  });
+
+  it("never cancels mid-delivery; falls through to interrupt when running", () => {
+    expect(
+      resolvePreparingStopAction({
+        isPreparing: true,
+        creationOutcomeKind: null,
+        creationMessageId,
+        dispatchingMessageId: creationMessageId,
+        sessionStatus: "starting",
+      }),
+    ).toEqual({ kind: "interrupt-running-turn" });
+  });
+
+  it("interrupts after delivery while the worktree is still checking out", () => {
+    expect(
+      resolvePreparingStopAction({
+        isPreparing: true,
+        creationOutcomeKind: "delivered",
+        creationMessageId,
+        dispatchingMessageId: null,
+        sessionStatus: "starting",
+      }),
+    ).toEqual({ kind: "interrupt-running-turn" });
+  });
+
+  it("is a noop when preparing is over and nothing is running", () => {
+    expect(
+      resolvePreparingStopAction({
+        isPreparing: false,
+        creationOutcomeKind: "delivered",
+        creationMessageId,
+        dispatchingMessageId: null,
+        sessionStatus: "stopped",
+      }),
+    ).toEqual({ kind: "noop" });
+  });
+
+  it("is a noop for a delivered creation whose session never started", () => {
+    expect(
+      resolvePreparingStopAction({
+        isPreparing: true,
+        creationOutcomeKind: "delivered",
+        creationMessageId,
+        dispatchingMessageId: null,
+        sessionStatus: null,
+      }),
+    ).toEqual({ kind: "noop" });
+  });
+});

apps/mobile/src/state/pending-thread-creation.ts

@@ -106,6 +106,42 @@ export function isPendingThreadCreationVisible(input: {
   return !input.loadedMessageIds?.includes(input.creationMessageId);
 }
 
+/**
+ * What Stop should do from the thread screen. The preparing window (queued
+ * creation or worktree checkout before the first turn) has no turn to
+ * interrupt: when the creation is still queued locally, Stop cancels it
+ * outright; once delivered, Stop falls through to the normal interrupt path
+ * (best effort — the server may still be checking out the worktree).
+ */
+export type PreparingStopAction =
+  | { readonly kind: "cancel-queued-creation" }
+  | { readonly kind: "interrupt-running-turn" }
+  | { readonly kind: "noop" };
+
+export function resolvePreparingStopAction(input: {
+  /** Null once the server's detail has taken over the pill. */
+  readonly isPreparing: boolean;
+  /** Outcome recorded by the outbox drain; null while still queued. */
+  readonly creationOutcomeKind: "delivered" | "failed" | null;
+  readonly creationMessageId: string | null;
+  /** Currently-delivering outbox message, if any. Never cancel mid-delivery. */
+  readonly dispatchingMessageId: string | null;
+  readonly sessionStatus: string | null;
+}): PreparingStopAction {
+  if (
+    input.isPreparing &&
+    input.creationMessageId !== null &&
+    input.creationOutcomeKind === null &&
+    input.dispatchingMessageId !== input.creationMessageId
+  ) {
+    return { kind: "cancel-queued-creation" };
+  }
+  if (input.sessionStatus === "running" || input.sessionStatus === "starting") {
+    return { kind: "interrupt-running-turn" };
+  }
+  return { kind: "noop" };
+}
+
 export function pendingThreadCreationMessage(
   message: QueuedThreadMessage,
 ): OrchestrationThread["messages"][number] {

apps/server/src/provider/Layers/OpenCodeAdapter.ts

@@ -31,6 +31,7 @@ import * as Semaphore from "effect/Semaphore";
 import * as Stream from "effect/Stream";
 import type { OpencodeClient, Part, PermissionRequest, QuestionRequest } from "@opencode-ai/sdk/v2";
 import { getModelSelectionStringOptionValue } from "@t3tools/shared/model";
+import { sanitizeTerminalValue } from "@t3tools/shared/stripTerminalEscapes";
 
 import { resolveAttachmentPath } from "../../attachmentStore.ts";
 import { ServerConfig } from "../../config.ts";
@@ -3134,8 +3135,10 @@ export function makeOpenCodeAdapter(
           // prompt into the running session, so the active turn id is reused.
           const steeringTurnId = context.activeTurnId;
           const turnId = steeringTurnId ?? freshTurnId;
-          const agent = getModelSelectionStringOptionValue(modelSelection, "agent");
-          const variant = getModelSelectionStringOptionValue(modelSelection, "variant");
+          const rawAgent = getModelSelectionStringOptionValue(modelSelection, "agent");
+          const rawVariant = getModelSelectionStringOptionValue(modelSelection, "variant");
+          const agent = rawAgent ? sanitizeTerminalValue(rawAgent) : undefined;
+          const variant = rawVariant ? sanitizeTerminalValue(rawVariant) : undefined;
           const pendingIdleReconciliation = context.pendingIdleReconciliation;
           const priorAwaitingBusy = context.awaitingBusyAfterInterruption;
           const priorIdleCandidate = pendingIdleReconciliation

apps/server/src/provider/Layers/OpenCodeProvider.ts

@@ -11,6 +11,10 @@ import * as Effect from "effect/Effect";
 
 import { createModelCapabilities } from "@t3tools/shared/model";
 import { compareSemverVersions } from "@t3tools/shared/semver";
+import {
+  sanitizeTerminalValue,
+  stripTerminalEscapes,
+} from "@t3tools/shared/stripTerminalEscapes";
 import {
   buildServerProvider,
   COMPACT_SLASH_COMMAND,
@@ -209,15 +213,20 @@ function openCodeCapabilitiesForModel(input: {
   // Codex/Grok experience where reasoning is always configurable). The set
   // covers the common OpenCode variant spectrum; `inferDefaultVariant`
   // picks the provider-appropriate default (e.g. medium for openai/opencode).
-  const variantValues =
-    rawVariantValues.length > 0 ? rawVariantValues : ["low", "medium", "high", "xhigh"];
+  const variantValues = (
+    rawVariantValues.length > 0 ? rawVariantValues : ["low", "medium", "high", "xhigh"]
+  ).map(sanitizeTerminalValue);
   const defaultVariant = inferDefaultVariant(input.providerID, variantValues);
   const variantOptions = variantValues.map((value) =>
     defaultVariant === value
       ? { id: value, label: titleCaseSlug(value), isDefault: true as const }
       : { id: value, label: titleCaseSlug(value) },
   );
-  const primaryAgents = input.agents.filter(
+  const sanitizedAgents = input.agents.map((agent) => ({
+    ...agent,
+    name: sanitizeTerminalValue(agent.name),
+  }));
+  const primaryAgents = sanitizedAgents.filter(
     (agent) => !agent.hidden && (agent.mode === "primary" || agent.mode === "all"),
   );
   const defaultAgent = inferDefaultAgent(primaryAgents);
@@ -447,7 +456,7 @@ export const checkOpenCodeProviderStatus = Effect.fn("checkOpenCodeProviderStatu
     if (versionExit._tag === "Failure") {
       return fallback(Cause.squash(versionExit.cause));
     }
-    version = parseGenericCliVersion(versionExit.value.stdout) ?? null;
+    version = parseGenericCliVersion(stripTerminalEscapes(versionExit.value.stdout)) ?? null;
 
     if (!version) {
       return fallback(