diff --git a/apps/mobile/src/features/threads/NewTaskRouteScreen.test.tsx b/apps/mobile/src/features/threads/NewTaskRouteScreen.test.tsx
new file mode 100644
index 0000000000000..20ac36d3f7ad8
--- /dev/null
+++ b/apps/mobile/src/features/threads/NewTaskRouteScreen.test.tsx
@@ -0,0 +1,224 @@
+import type { ReactNode } from "react";
+import { act } from "react";
+import * as React from "react";
+import { createRoot } from "react-dom/client";
+import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
+import { EnvironmentId, ProjectId } from "@t3tools/contracts";
+import { expect, it, vi } from "vite-plus/test";
+import { retargetSavedNewTaskDraft } from "../../state/use-composer-drafts";
+
+const environmentId = EnvironmentId.make("env-1");
+
+function project(id: string, workspaceRoot: string): EnvironmentProject {
+ return {
+ environmentId,
+ id: ProjectId.make(id),
+ title: id,
+ workspaceRoot,
+ repositoryIdentity: null,
+ defaultModelSelection: null,
+ defaultThreadEnvMode: "worktree",
+ scripts: [],
+ createdAt: "2026-10-26T00:00:00Z",
+ updatedAt: "2026-10-26T00:00:00Z",
+ };
+}
+
+const regular = project("app", "/repo/app");
+const scratch = project("scratch", "/scratch");
+
+const harness = vi.hoisted(() => ({
+ setProject: vi.fn(),
+ openScratch: vi.fn(),
+ selectDetail: vi.fn(),
+ navigation: {
+ goBack: vi.fn(),
+ getState: () => ({
+ routeNames: ["Thread", "NewTaskProject"],
+ index: 1,
+ routes: [{ name: "Thread", params: { draft: {} } }, { name: "NewTaskProject" }],
+ }),
+ getParent: () => undefined,
+ canGoBack: () => true,
+ dispatch: vi.fn(),
+ navigate: vi.fn(),
+ },
+}));
+
+vi.mock("react-native", () => ({
+ Platform: { OS: "ios" },
+ View: ({ children }: { children?: ReactNode }) =>
{children}
,
+ Pressable: (props: {
+ accessibilityLabel: string;
+ disabled?: boolean;
+ onPress: () => void;
+ children?: ReactNode;
+ }) => (
+
+ ),
+}));
+vi.mock("react-native-safe-area-context", () => ({
+ useSafeAreaInsets: () => ({ top: 0, bottom: 0, left: 0, right: 0 }),
+}));
+vi.mock("gt-react-native", () => ({
+ msg: (text: string) => text,
+ T: ({ children }: { children?: ReactNode }) => <>{children}>,
+ useGT: () => (text: string) => text,
+ useMessages: () => (text: string) => text,
+}));
+vi.mock("@react-navigation/native", () => ({
+ StackActions: { push: (name: string) => ({ type: "PUSH", name }) },
+ useFocusEffect: (effect: () => () => void) => React.useEffect(effect, [effect]),
+ useIsFocused: () => true,
+ useNavigation: () => harness.navigation,
+}));
+vi.mock("../../components/ui/NavigationRow", () => ({
+ NavigationRow: (props: { title: string; disabled?: boolean; onPress?: () => void }) => (
+
+ ),
+}));
+vi.mock("../../components/ui/Dialog", () => ({ alert: vi.fn() }));
+vi.mock("../../components/ui/AppActivityIndicator", () => ({ AppActivityIndicator: () => null }));
+vi.mock("../../components/ui/AppBar", () => ({ AppBar: () => null }));
+vi.mock("../../components/ui/AppSymbol", () => ({ SymbolView: () => null }));
+vi.mock("../../components/ui/Button", () => ({ Button: () => null }));
+vi.mock("../../components/ui/ScreenContent", () => ({
+ ScreenContent: ({ children }: { children?: ReactNode }) => <>{children}>,
+}));
+vi.mock("../../components/ui/ScreenScrollView", () => ({
+ ScreenScrollView: ({ children }: { children?: ReactNode }) => <>{children}>,
+}));
+vi.mock("../../components/ui/AppText", () => ({
+ AppText: ({ children }: { children?: ReactNode }) => {children},
+}));
+vi.mock("../../components/ProjectFavicon", () => ({ ProjectFavicon: () => null }));
+vi.mock("../connection/environmentStatusText", () => ({ runtimeConnectionErrorText: () => null }));
+vi.mock("../../state/entities", () => ({
+ useProjects: () => [regular, scratch],
+ useServerConfigs: () => new Map([[environmentId, { scratchWorkspaceRoot: "/scratch" }]]),
+}));
+vi.mock("../../state/projects", () => ({ projectEnvironment: { openScratch: {} } }));
+vi.mock("../../state/use-atom-command", () => ({ useAtomCommand: () => harness.openScratch }));
+vi.mock("../../state/use-composer-drafts", () => ({ retargetSavedNewTaskDraft: vi.fn() }));
+vi.mock("../../state/use-remote-environment-registry", () => ({
+ useRemoteConnectionStatus: () => ({
+ connectedEnvironments: [{ environmentId, connectionState: "connected" }],
+ }),
+}));
+vi.mock("../../state/workspace", () => ({
+ useWorkspaceState: () => ({ state: { hasReadyEnvironment: true } }),
+}));
+vi.mock("../sharing/IncomingShareProvider", () => ({
+ useIncomingShare: () => ({ getShare: () => null, releaseShareReservation: vi.fn() }),
+}));
+vi.mock("../layout/workspace/useSelectWorkspaceDetail", () => ({
+ useSelectWorkspaceDetail: () => harness.selectDetail,
+}));
+vi.mock("./new-task-flow-provider", () => ({
+ useNewTaskFlow: () => ({
+ projectScopes: [
+ {
+ key: "app",
+ title: "app",
+ representative: regular,
+ projects: [regular],
+ projectRefs: [],
+ pinned: false,
+ archived: false,
+ },
+ ],
+ selectedEnvironmentId: environmentId,
+ setProject: harness.setProject,
+ }),
+}));
+
+import { NewTaskRouteScreen } from "./NewTaskRouteScreen";
+
+it("keeps the project picked while No project was still opening", async () => {
+ (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+ const opening = Promise.withResolvers();
+ harness.openScratch.mockReturnValue(opening.promise);
+
+ const container = document.createElement("div");
+ const root = createRoot(container);
+ using _root = { [Symbol.dispose]: () => act(() => root.unmount()) };
+ act(() => root.render());
+ const row = (label: string) => container.querySelector(`[aria-label="${label}"]`)!;
+
+ act(() => row("No project").click());
+ await act(async () => row("app").click());
+ await act(async () => opening.resolve({ _tag: "Success", value: scratch }));
+
+ expect(harness.setProject.mock.calls).toEqual([[regular]]);
+ expect(harness.navigation.goBack).toHaveBeenCalledTimes(1);
+});
+
+function renderWithSavedDraft() {
+ (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+ const opening = Promise.withResolvers();
+ const retargeting = Promise.withResolvers();
+ harness.openScratch.mockReturnValue(opening.promise);
+ vi.mocked(retargetSavedNewTaskDraft)
+ .mockReset()
+ .mockImplementation((_draftId, target) =>
+ target.projectId === scratch.id ? retargeting.promise : Promise.resolve(true),
+ );
+ harness.selectDetail.mockClear();
+
+ const container = document.createElement("div");
+ const root = createRoot(container);
+ const route = { params: { draftId: "existing-draft" } } as never;
+ act(() => root.render());
+ return {
+ opening,
+ retargeting,
+ root,
+ route,
+ row: (label: string) => container.querySelector(`[aria-label="${label}"]`)!,
+ [Symbol.dispose]: () => act(() => root.unmount()),
+ };
+}
+
+const appDraftSelection = [
+ [
+ {
+ name: "Thread",
+ params: { draft: { environmentId, projectId: regular.id, draftId: "existing-draft" } },
+ },
+ ],
+];
+
+it("keeps the picked project after backing out and reopening while No project is pending", async () => {
+ using screen = renderWithSavedDraft();
+
+ act(() => screen.row("No project").click());
+ act(() => screen.root.render(null));
+ act(() => screen.root.render());
+ await act(async () => screen.row("app").click());
+ await act(async () => {
+ screen.opening.resolve({ _tag: "Success", value: scratch });
+ screen.retargeting.resolve(true);
+ });
+
+ expect(harness.selectDetail.mock.calls).toEqual(appDraftSelection);
+});
+
+it("cancels the No project draft retarget when another project is picked", async () => {
+ using screen = renderWithSavedDraft();
+
+ act(() => screen.row("No project").click());
+ await act(async () => screen.opening.resolve({ _tag: "Success", value: scratch }));
+ const scratchSignal = vi
+ .mocked(retargetSavedNewTaskDraft)
+ .mock.calls.find(([, target]) => target.projectId === scratch.id)?.[2];
+ expect(scratchSignal?.aborted).toBe(false);
+ await act(async () => screen.row("app").click());
+ expect(scratchSignal?.aborted).toBe(true);
+ await act(async () => screen.retargeting.resolve(true));
+
+ expect(harness.selectDetail.mock.calls).toEqual(appDraftSelection);
+});
diff --git a/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx b/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx
index f429972a176fc..716713e4293d2 100644
--- a/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx
+++ b/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx
@@ -7,6 +7,7 @@ import { NavigationRow } from "../../components/ui/NavigationRow";
import { AppBar } from "../../components/ui/AppBar";
import {
StackActions,
+ useFocusEffect,
useIsFocused,
useNavigation,
type StaticScreenProps,
@@ -19,7 +20,7 @@ import {
squashAtomCommandFailure,
} from "@t3tools/client-runtime/state/runtime";
import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell";
-import { useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
import { Platform, Pressable, View } from "react-native";
import { useSafeAreaInsets } from "react-native-safe-area-context";
import { cn } from "../../lib/cn";
@@ -235,13 +236,19 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps(null);
+ const cancelPendingScratch = useCallback(() => {
+ pendingScratchRef.current?.abort();
+ pendingScratchRef.current = null;
+ }, []);
+ useFocusEffect(useCallback(() => cancelPendingScratch, [cancelPendingScratch]));
- async function selectProject(project: EnvironmentProject): Promise {
+ async function selectProject(project: EnvironmentProject, signal?: AbortSignal): Promise {
if (incomingShare?.destination && !reservedDestinationProject) {
try {
await releaseShareReservation(incomingShare.id, incomingShare.destination);
} catch (error) {
+ if (signal?.aborted) return;
Dialog.alert(
gt("Could not change project"),
errorDisplayMessage(error, m) ??
@@ -249,6 +256,7 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps found,
() => null,
);
+ if (signal?.aborted) return;
if (retargeted === null) {
Dialog.alert(
gt("Could not change project"),
@@ -292,13 +302,20 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps {
- if (!canStartScratch || !scratchOption || scratchStartInFlightRef.current) return;
+ if (!canStartScratch || !scratchOption || pendingScratchRef.current) return;
const environmentId = scratchOption.environmentId;
- scratchStartInFlightRef.current = true;
+ const request = new AbortController();
+ pendingScratchRef.current = request;
const result = await openScratch({ environmentId, input: {} });
+ if (request.signal.aborted) return;
if (result._tag === "Failure") {
- scratchStartInFlightRef.current = false;
+ pendingScratchRef.current = null;
if (!isAtomCommandInterrupted(result)) {
const error = squashAtomCommandFailure(result);
Dialog.alert(
@@ -309,9 +326,8 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps void selectProject(selectionTarget)}
+ onPress={() => chooseProject(selectionTarget)}
leading={
void selectProject(selectionTarget)}
+ onPress={() => chooseProject(selectionTarget)}
className="flex-row items-center gap-3 bg-grouped-card px-4 py-3.5"
>
diff --git a/apps/mobile/src/state/use-composer-drafts.test.ts b/apps/mobile/src/state/use-composer-drafts.test.ts
index 0f0e4a69419fb..6345836750a3f 100644
--- a/apps/mobile/src/state/use-composer-drafts.test.ts
+++ b/apps/mobile/src/state/use-composer-drafts.test.ts
@@ -2053,6 +2053,14 @@ describe("mobile composer drafts", () => {
appAtomRegistry.set(composerDraftsAtom, {});
resetComposerDraftsLoadState();
+ composerDraftFileMocks.blockRead();
+ const controller = new AbortController();
+ const cancelled = retargetSavedNewTaskDraft(key, to, controller.signal);
+ controller.abort();
+ composerDraftFileMocks.releaseRead();
+ await expect(cancelled).resolves.toBe(false);
+ expect(getComposerDraftSnapshot(key).project).toMatchObject(from);
+
await expect(retargetSavedNewTaskDraft(key, to)).resolves.toBe(true);
expect(getComposerDraftSnapshot(key)).toMatchObject({
text: "kept through a cold start",
diff --git a/apps/mobile/src/state/use-composer-drafts.ts b/apps/mobile/src/state/use-composer-drafts.ts
index 57b620de5264b..f5c47c24847bb 100644
--- a/apps/mobile/src/state/use-composer-drafts.ts
+++ b/apps/mobile/src/state/use-composer-drafts.ts
@@ -2075,13 +2075,15 @@ export function retargetNewTaskDraft(
});
}
-/** Retargets a saved draft once drafts load; an absent one is not created. */
+/** Retargets a saved draft after loading. Returns false if absent or cancelled before the write. */
export async function retargetSavedNewTaskDraft(
draftKey: string,
project: { readonly environmentId: EnvironmentId; readonly projectId: ProjectId },
+ signal?: AbortSignal,
): Promise {
await waitForComposerDraftsLoaded();
- if (appAtomRegistry.get(composerDraftsAtom)[draftKey] === undefined) return false;
+ if (signal?.aborted || appAtomRegistry.get(composerDraftsAtom)[draftKey] === undefined)
+ return false;
retargetNewTaskDraft(draftKey, project);
return true;
}
diff --git a/apps/mobile/vite.config.ts b/apps/mobile/vite.config.ts
index 05261f9cb1848..80fca082c7c8e 100644
--- a/apps/mobile/vite.config.ts
+++ b/apps/mobile/vite.config.ts
@@ -8,6 +8,7 @@ const reactTests = [
"src/features/threads/useSubmitAfterNativeImages.test.tsx",
"src/features/threads/git/GitBranchesSheet.test.tsx",
"src/features/threads/new-task-flow-provider.test.tsx",
+ "src/features/threads/NewTaskRouteScreen.test.tsx",
"src/features/layout/workspace/workspace-tabs-state.test.ts",
"src/state/use-thread-pr.demand.test.tsx",
"src/features/threads/git/GitBranchesSheet.occupancy.test.tsx",