The best way to control Claude Code, Codex and more from any computer or phone
refactor(mobile): each new-task draft route keeps its own flow state (#25812)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Oct 27, 2026 at 03:07 UTC
e109dc8d89419ae8120110ab28a4c94c5a4f600b
8 files changed
+455
-121
apps/mobile/src/App.tsx
+2
@@ -83,6 +83,7 @@ import {
83
linkToRootPath,
84
rootNavigationRef,
85
} from "./lib/rootNavigation";
86
+import { pruneNewTaskFlowStates } from "./features/threads/new-task-flow-state";
87
import { pruneNewTaskBranchCheckouts } from "./features/threads/NewTaskDraftRouteScreen";
88
89
import "../global.css";
@@ -147,6 +148,7 @@ function handleNavigationStateChange(state: NavigationState | undefined): void {
148
if (!state) return;
149
setAgentNotificationPathname(workspaceLocationFromState(state).pathname);
150
recordAppShortcutNavigationState(state);
151
+ pruneNewTaskFlowStates(state);
152
pruneNewTaskBranchCheckouts(state);
153
pruneIncomingShareImports(state);
154
}
apps/mobile/src/Stack.tsx
+12
-2
@@ -89,6 +89,7 @@ import {
89
NewTaskThreadSettingsRouteScreen,
90
} from "./features/threads/ThreadSettingsSheet";
91
import { NewTaskFlowProvider } from "./features/threads/new-task-flow-provider";
92
+import { newTaskFlowKey } from "./features/threads/new-task-flow-state";
93
import { NewTaskRouteScreen } from "./features/threads/NewTaskRouteScreen";
94
import { SettingsNavigationRouteScreen } from "./features/settings/SettingsNavigationRouteScreen";
95
import { SettingsAppearanceRouteScreen } from "./features/settings/SettingsAppearanceRouteScreen";
@@ -503,7 +504,12 @@ function RootStackLayout(props: {
504
.slice(0, props.state.index + 1)
505
.filter((route) => !isWorkspaceOverlayRoute(route.name)),
506
);
506
- const draftRoute = props.state.routes.findLast((route) => route.name === "Thread");
507
+ // The flow follows the draft route even while a pushed Thread covers it, so
508
+ // its state lives exactly as long as the route.
509
+ const draftRoute = props.state.routes.findLast(isDraftThreadRoute);
510
+ const draftRouteOnTop =
511
+ draftRoute !== undefined &&
512
+ props.state.routes.findLast((route) => route.name === "Thread") === draftRoute;
513
const draftParams = (
514
draftRoute?.params as { draft?: { draftId?: string | string[] } } | undefined
515
)?.draft;
@@ -512,7 +518,11 @@ function RootStackLayout(props: {
518
: draftParams?.draftId;
519
520
return (
515
- <NewTaskFlowProvider active={isDraftThreadRoute(draftRoute)} routeDraftId={routeDraftId}>
521
+ <NewTaskFlowProvider
522
+ active={draftRouteOnTop}
523
+ flowKey={draftRoute === undefined ? undefined : newTaskFlowKey(draftRoute)}
524
+ routeDraftId={routeDraftId}
525
+ >
526
<HardwareKeyboardCommandProvider pathname={pathname}>
527
<ShowcaseCaptureCoordinator pathname={pathname} />
528
<SettingsEnvironmentFilterProvider open={settingsOpen}>
apps/mobile/src/features/threads/NewTaskDraftRouteScreen.tsx
+1
-10
@@ -1,4 +1,3 @@
1
-import { useNewTaskFlow } from "./new-task-flow-provider";
1
import * as Dialog from "../../components/ui/Dialog";
2
import {
3
CommonActions,
@@ -7,7 +6,7 @@ import {
6
usePreventRemoveContext,
7
type StaticScreenProps,
8
} from "@react-navigation/native";
10
-import { useEffect, useLayoutEffect, useState } from "react";
9
+import { useEffect, useState } from "react";
10
import { View } from "react-native";
11
import { useAtomValue } from "@effect/atom-react";
12
import {
@@ -91,13 +90,6 @@ const idleBranchCheckoutAtom = Atom.make(AsyncResult.initial<BranchCheckoutResul
90
export function NewTaskDraftRouteScreen({ route }: StaticScreenProps<NewTaskDraftRouteParams>) {
91
const currentRoute = useRoute();
92
const params = route.params ?? {};
94
- const { reset } = useNewTaskFlow();
95
- const [initialized, setInitialized] = useState(false);
96
- useLayoutEffect(() => {
97
- reset();
98
- // oxlint-disable-next-line react/set-state-in-effect -- Draft reset runs once before first paint; initialized gates the screen until then.
99
- setInitialized(true);
100
- }, [reset]);
93
const draftId = Array.isArray(params.draftId) ? params.draftId[0] : params.draftId;
94
const projects = useProjects();
95
const { state: catalogState } = useWorkspaceState();
@@ -201,7 +193,6 @@ export function NewTaskDraftRouteScreen({ route }: StaticScreenProps<NewTaskDraf
193
};
194
const preparingBranch = checkoutPending || (needsPreparation && result?._tag !== "Success");
195
204
- if (!initialized) return null;
196
return (
197
<>
198
{preparingBranch ? (
apps/mobile/src/features/threads/NewTaskDraftScreen.tsx
+10
-42
@@ -61,7 +61,6 @@ import {
61
getComposerDraftSnapshot,
62
updateComposerDraftSettings,
63
scheduleUnusedComposerAttachmentCleanup,
64
- waitForComposerDraftsLoaded,
64
} from "../../state/use-composer-drafts";
65
import { useEnvironmentServerConfig, useProjects } from "../../state/entities";
66
import { useProjectClone } from "../../state/projectClones";
@@ -223,10 +222,6 @@ export function NewTaskDraftScreen(props: {
222
}
223
};
224
const deleteProject = useAtomCommand(projectEnvironment.delete, { reportFailure: false });
226
- const selectedProjectRef = useRef(selectedProject);
227
- useEffect(() => {
228
- selectedProjectRef.current = selectedProject;
229
- }, [selectedProject]);
225
const removeClonedProject = async () => {
226
if (!selectedProject) return;
227
const removed = selectedProject;
@@ -242,8 +237,7 @@ export function NewTaskDraftScreen(props: {
237
);
238
return;
239
}
245
- const current = selectedProjectRef.current;
246
- if (current?.id === removed.id && current.environmentId === removed.environmentId) {
240
+ if (flow.getSelectedProjectKey() === scopedProjectKey(removed.environmentId, removed.id)) {
241
navigation.dispatch(StackActions.replace("Home"));
242
}
243
};
@@ -280,8 +274,12 @@ export function NewTaskDraftScreen(props: {
274
project.id === props.initialProjectRef?.projectId,
275
),
276
);
277
+ // A route naming a draft that is gone, or whose project is gone, also
278
+ // returns to the picker.
279
+ const isRouteDraftMissing =
280
+ props.draftId !== undefined && flow.missingRouteDraftId === props.draftId;
281
const isProjectPickerReturnActive =
284
- isReturningToProjectPicker && !requestedInitialProjectAvailable;
282
+ (isReturningToProjectPicker && !requestedInitialProjectAvailable) || isRouteDraftMissing;
283
const isIncomingShareAwaitingServerConfig = Boolean(
284
incomingShare?.attachments.some((attachment) => attachment.type === "file") &&
285
selectedEnvironmentServerConfig === null,
@@ -373,12 +371,11 @@ export function NewTaskDraftScreen(props: {
371
isIncomingShareUnavailable;
372
const appliedInitialProjectKeyRef = useRef<string | null>(null);
373
useEffect(() => {
376
- if (!isReturningToProjectPicker) {
377
- return;
378
- }
379
- if (requestedInitialProjectAvailable) {
374
+ if (isReturningToProjectPicker && requestedInitialProjectAvailable) {
375
// oxlint-disable-next-line react/set-state-in-effect -- Ends the return-to-picker flow once the requested project arrives from the catalog.
376
setIsReturningToProjectPicker(false);
377
+ }
378
+ if (!isProjectPickerReturnActive) {
379
return;
380
}
381
// Wait for usePreventRemove to disable before replacing, or the transfer guard swallows the fallback.
@@ -389,41 +386,12 @@ export function NewTaskDraftScreen(props: {
386
});
387
return () => cancelAnimationFrame(frame);
388
}, [
389
+ isProjectPickerReturnActive,
390
isReturningToProjectPicker,
391
navigation,
392
props.incomingShareId,
393
requestedInitialProjectAvailable,
394
]);
397
- const { openDraft } = flow;
398
- // Cold launches load drafts and projects separately; wait for hydration and retry while shells load.
399
- const attemptedDraftIdRef = useRef<string | null>(null);
400
- useEffect(() => {
401
- if (!props.draftId) {
402
- return;
403
- }
404
- const draftId = props.draftId;
405
- if (attemptedDraftIdRef.current === draftId) {
406
- return;
407
- }
408
- let cancelled = false;
409
- void waitForComposerDraftsLoaded().then(() => {
410
- if (cancelled || attemptedDraftIdRef.current === draftId) {
411
- return;
412
- }
413
- if (openDraft(draftId)) {
414
- attemptedDraftIdRef.current = draftId;
415
- return;
416
- }
417
- if (getComposerDraftSnapshot(draftId).project !== undefined && projects.length === 0) {
418
- return;
419
- }
420
- attemptedDraftIdRef.current = draftId;
421
- navigation.dispatch(CommonActions.navigate("NewTaskProject"));
422
- });
423
- return () => {
424
- cancelled = true;
425
- };
426
- }, [navigation, openDraft, projects, props.draftId]);
395
396
const lastInitialProjectRefRef = useRef(props.initialProjectRef);
397
const initialPickerRef = useRef<"open" | "dismissed" | null>(null);
apps/mobile/src/features/threads/new-task-flow-provider.tsx
+129
-67
@@ -1,6 +1,6 @@
1
import { ActiveNewTaskContext } from "../../state/active-new-task";
2
import * as Dialog from "../../components/ui/Dialog";
3
-import React, { useCallback, useEffect, useRef, useState } from "react";
3
+import React, { useEffect, useRef, useState } from "react";
4
5
import type {
6
EnvironmentId,
@@ -33,6 +33,7 @@ import {
33
resolveSelectableModelSelection,
34
} from "../../lib/modelOptions";
35
import { scopedProjectKey } from "../../lib/scopedEntities";
36
+import { useAtomValue } from "@effect/atom-react";
37
import { appAtomRegistry } from "../../state/atom-registry";
38
import { projectEnvironment } from "../../state/projects";
39
import { useEnvironmentQuery } from "../../state/query";
@@ -41,7 +42,7 @@ import {
42
appendComposerDraftAttachments,
43
type ComposerDraftInsertion,
44
type ComposerDraftWorkspaceSelection,
44
- composerDraftsAtom,
45
+ composerDraftsLoadedAtom,
46
createNewTaskDraft,
47
getComposerDraftSnapshot,
48
isNewTaskDraftKey,
@@ -92,6 +93,18 @@ import {
93
import { resolveEnvironmentProjectMatch } from "./new-task-project-selection";
94
import { useNewTaskProjectDefaults } from "./use-new-task-project-defaults";
95
import { resolveProjectThreadCreationBranch } from "./projectThreadCreationValidation";
96
+import {
97
+ INACTIVE_FLOW_KEY,
98
+ type NewTaskFlowState,
99
+ newTaskFlowStateAtom,
100
+ readNewTaskFlowState,
101
+ resolveRouteDraft,
102
+ type RouteDraftResolution,
103
+ stampedEnvironmentProjectsLoading,
104
+ updateNewTaskFlowState,
105
+} from "./new-task-flow-state";
106
+import { useEnvironmentShellReadiness } from "../../state/shell";
107
+import { useConnectionsReady, useWorkspaceEnvironments } from "../../state/workspace";
108
109
type WorkspaceMode = "local" | "worktree";
110
@@ -153,10 +166,15 @@ type NewTaskFlowContextValue = {
166
readonly selectedModelOption: ModelOption | null;
167
readonly selectedProviderStatus: ServerProvider | null;
168
readonly providerGroups: ReadonlyArray<ProviderGroup>;
156
- readonly reset: () => void;
169
readonly setProject: (project: EnvironmentProject) => void;
158
- /** Returns false if the existing draft is gone, allowing fallback to a fresh draft. */
159
- readonly openDraft: (draftKey: string) => boolean;
170
+ /** The flow's project, read when a continuation resumes after an await. */
171
+ readonly getSelectedProjectKey: () => string | null;
172
+ /**
173
+ * The draft id of the route this flow serves when that draft, or its
174
+ * project, is gone. Only the topmost draft route is served, so a screen
175
+ * compares this with its own draft id.
176
+ */
177
+ readonly missingRouteDraftId: string | null;
178
readonly selectEnvironment: (environmentId: EnvironmentId) => void;
179
readonly switchEnvironment: (environmentId: EnvironmentId) => Promise<boolean>;
180
readonly switchingToEnvironmentId: EnvironmentId | null;
@@ -197,6 +215,8 @@ const NewTaskFlowContext = React.createContext<NewTaskFlowContextValue | null>(n
215
export function NewTaskFlowProvider(
216
props: React.PropsWithChildren<{
217
active?: boolean;
218
+ /** Identifies the draft route this flow serves; a new key starts a fresh flow. */
219
+ flowKey?: string;
220
routeDraftId?: string;
221
}>,
222
) {
@@ -217,38 +237,89 @@ export function NewTaskFlowProvider(
237
projectSortOrder: "updated_at",
238
});
239
220
- const [selectedEnvironmentIdOverride, setSelectedEnvironmentId] = useState<EnvironmentId | null>(
221
- null,
240
+ const flowKey = props.flowKey ?? INACTIVE_FLOW_KEY;
241
+ const storedFlowState = useAtomValue(newTaskFlowStateAtom(flowKey));
242
+ const draftsLoaded = useAtomValue(composerDraftsLoadedAtom);
243
+ // A draft route opened from a list row, a deep link, or restored state binds
244
+ // its draft here until the flow's first write stores the binding.
245
+ const routeDraft = useComposerDraft(
246
+ storedFlowState.draftKey === null ? (props.routeDraftId ?? null) : null,
247
);
248
+ // Readiness of the environment the route's draft is stamped to; another
249
+ // environment's projects loading first says nothing about it.
250
+ const stampedEnvironmentId = routeDraft.project?.environmentId ?? null;
251
+ const connectionsReady = useConnectionsReady();
252
+ const stampedEnvironmentConnection =
253
+ useWorkspaceEnvironments().find(
254
+ (environment) => environment.environmentId === stampedEnvironmentId,
255
+ )?.connectionState ?? null;
256
+ const stampedEnvironmentShell = useEnvironmentShellReadiness(stampedEnvironmentId);
257
+ const stampedEnvironmentLoading = stampedEnvironmentProjectsLoading({
258
+ connectionsReady,
259
+ connectionState: stampedEnvironmentConnection,
260
+ shellCacheRead: stampedEnvironmentShell.cacheRead,
261
+ shellStatus: stampedEnvironmentShell.status,
262
+ shellHasError: stampedEnvironmentShell.hasError,
263
+ });
264
+ const resolveRoute = (
265
+ flow: NewTaskFlowState,
266
+ loaded: boolean,
267
+ stamp: Parameters<typeof resolveRouteDraft>[0]["stamp"],
268
+ ): RouteDraftResolution =>
269
+ resolveRouteDraft({
270
+ flow,
271
+ routeDraftId: props.routeDraftId,
272
+ draftsLoaded: loaded,
273
+ stamp,
274
+ projects,
275
+ stampedEnvironmentLoading,
276
+ });
277
+ const routeDraftResolution = resolveRoute(storedFlowState, draftsLoaded, routeDraft.project);
278
+ const flowState =
279
+ routeDraftResolution.kind === "open" ? routeDraftResolution.flow : storedFlowState;
280
+ const {
281
+ environmentId: selectedEnvironmentIdOverride,
282
+ projectKey: selectedProjectKey,
283
+ draftKey: activeDraftKey,
284
+ submitting,
285
+ expandedProvider,
286
+ } = flowState;
287
+ // Continuations read the flow at use time, with the route's draft applied.
288
+ const readFlow = (): NewTaskFlowState => {
289
+ const stored = readNewTaskFlowState(flowKey);
290
+ const resolution = resolveRoute(
291
+ stored,
292
+ appAtomRegistry.get(composerDraftsLoadedAtom),
293
+ props.routeDraftId === undefined
294
+ ? undefined
295
+ : getComposerDraftSnapshot(props.routeDraftId).project,
296
+ );
297
+ return resolution.kind === "open" ? resolution.flow : stored;
298
+ };
299
+ // Every flow write stores the route's draft binding along with it, so the
300
+ // binding outlives the draft's project stamp (submit clears it).
301
+ const updateFlow = (patch: Partial<NewTaskFlowState>) =>
302
+ updateNewTaskFlowState(flowKey, { ...readFlow(), ...patch });
303
const selectedEnvironmentId =
304
selectedEnvironmentIdOverride !== null &&
305
projects.some((project) => project.environmentId === selectedEnvironmentIdOverride)
306
? selectedEnvironmentIdOverride
307
: (projects[0]?.environmentId ?? null);
228
- const [selectedProjectKey, setSelectedProjectKey] = useState<string | null>(null);
229
- const [activeDraftKey, setActiveDraftKey] = useState<string | null>(null);
230
- const [submitting, setSubmitting] = useState(false);
231
- const [expandedProvider, setExpandedProvider] = useState<string | null>(null);
232
-
233
- const reset = useCallback(() => {
234
- setSelectedEnvironmentId(null);
235
- setSelectedProjectKey(null);
236
- setActiveDraftKey(null);
237
- setSubmitting(false);
238
- setExpandedProvider(null);
239
- }, []);
240
-
308
const projectsForEnvironment = pipe(
309
projects,
310
Arr.filter((project) => project.environmentId === selectedEnvironmentId),
311
);
312
313
+ // A route draft still waiting for its environment has no project yet: the
314
+ // fallback would show, and could send to, another environment's project.
315
const selectedProject =
247
- projectsForEnvironment.find(
248
- (project) => scopedProjectKey(project.environmentId, project.id) === selectedProjectKey,
249
- ) ??
250
- projectsForEnvironment[0] ??
251
- null;
316
+ routeDraftResolution.kind === "pending"
317
+ ? null
318
+ : (projectsForEnvironment.find(
319
+ (project) => scopedProjectKey(project.environmentId, project.id) === selectedProjectKey,
320
+ ) ??
321
+ projectsForEnvironment[0] ??
322
+ null);
323
324
const projectDefaults = useNewTaskProjectDefaults(selectedProject);
325
const selectedEnvironmentServerConfig = projectDefaults.serverConfig;
@@ -318,17 +389,23 @@ export function NewTaskFlowProvider(
389
390
const selectedProjectDraftKey = selectedProject ? activeDraftKey : null;
391
useEffect(() => {
321
- if (props.active === false || activeDraftKey !== null || selectedProject === null) {
392
+ // A route that names a draft binds that draft, or returns to the picker.
393
+ if (
394
+ props.active === false ||
395
+ props.routeDraftId !== undefined ||
396
+ activeDraftKey !== null ||
397
+ selectedProject === null
398
+ ) {
399
return;
400
}
324
- // oxlint-disable-next-line react/set-state-in-effect -- Creates the persistent draft once the project selection is ready; the key must exist before the composer mounts.
325
- setActiveDraftKey(
326
- createNewTaskDraft({
401
+ // Creates the persistent draft once the project selection is ready; the key must exist before the composer mounts.
402
+ updateNewTaskFlowState(flowKey, {
403
+ draftKey: createNewTaskDraft({
404
environmentId: selectedProject.environmentId,
405
projectId: selectedProject.id,
406
}),
330
- );
331
- }, [activeDraftKey, selectedProject, props.active]);
407
+ });
408
+ }, [activeDraftKey, flowKey, selectedProject, props.active, props.routeDraftId]);
409
const activePendingKey =
410
props.active === false
411
? null
@@ -528,38 +605,22 @@ export function NewTaskFlowProvider(
605
replaceComposerDraftAttachments(selectedProjectDraftKey, []);
606
};
607
531
- const carryDraftContentTo = (project: EnvironmentProject) => {
608
+ const carryDraftContentTo = (project: EnvironmentProject): string => {
609
const target = { environmentId: project.environmentId, projectId: project.id };
533
- if (activeDraftKey !== null && isNewTaskDraftKey(activeDraftKey)) {
534
- retargetNewTaskDraft(activeDraftKey, target);
535
- } else {
536
- setActiveDraftKey(createNewTaskDraft(target));
610
+ const current = readFlow().draftKey;
611
+ if (current !== null && isNewTaskDraftKey(current)) {
612
+ retargetNewTaskDraft(current, target);
613
+ return current;
614
}
615
+ return createNewTaskDraft(target);
616
};
617
618
const setProject = (project: EnvironmentProject) => {
541
- carryDraftContentTo(project);
542
- setSelectedEnvironmentId(project.environmentId);
543
- setSelectedProjectKey(scopedProjectKey(project.environmentId, project.id));
544
- };
545
-
546
- const openDraft = (draftKey: string): boolean => {
547
- const draft = appAtomRegistry.get(composerDraftsAtom)[draftKey];
548
- const stamp = draft?.project;
549
- if (!isNewTaskDraftKey(draftKey) || !stamp) {
550
- return false;
551
- }
552
- // Require the stamped project to load; selectedProject otherwise falls back and retargets the draft.
553
- const projectLoaded = projects.some(
554
- (project) => project.environmentId === stamp.environmentId && project.id === stamp.projectId,
555
- );
556
- if (!projectLoaded) {
557
- return false;
558
- }
559
- setActiveDraftKey(draftKey);
560
- setSelectedEnvironmentId(stamp.environmentId);
561
- setSelectedProjectKey(scopedProjectKey(stamp.environmentId, stamp.projectId));
562
- return true;
619
+ updateFlow({
620
+ draftKey: carryDraftContentTo(project),
621
+ environmentId: project.environmentId,
622
+ projectKey: scopedProjectKey(project.environmentId, project.id),
623
+ });
624
};
625
626
const selectEnvironment = (environmentId: EnvironmentId) => {
@@ -567,11 +628,11 @@ export function NewTaskFlowProvider(
628
projects.filter((project) => project.environmentId === environmentId),
629
selectedProject,
630
);
570
- if (match) {
571
- carryDraftContentTo(match);
572
- }
573
- setSelectedEnvironmentId(environmentId);
574
- setSelectedProjectKey(match ? scopedProjectKey(match.environmentId, match.id) : null);
631
+ updateFlow({
632
+ draftKey: match ? carryDraftContentTo(match) : readFlow().draftKey,
633
+ environmentId,
634
+ projectKey: match ? scopedProjectKey(match.environmentId, match.id) : null,
635
+ });
636
};
637
638
const openScratch = useAtomCommand(projectEnvironment.openScratch, { reportFailure: false });
@@ -797,9 +858,10 @@ export function NewTaskFlowProvider(
858
selectedModelOption,
859
selectedProviderStatus,
860
providerGroups,
800
- reset,
861
setProject,
802
- openDraft,
862
+ getSelectedProjectKey: () => readFlow().projectKey,
863
+ missingRouteDraftId:
864
+ routeDraftResolution.kind === "missing" ? (props.routeDraftId ?? null) : null,
865
selectEnvironment,
866
switchEnvironment,
867
switchingToEnvironmentId,
@@ -813,12 +875,12 @@ export function NewTaskFlowProvider(
875
appendAttachments,
876
removeAttachment,
877
clearAttachments,
816
- setSubmitting,
878
+ setSubmitting: (value: boolean) => updateFlow({ submitting: value }),
879
loadBranches,
880
setRuntimeMode,
881
setInteractionMode,
882
setSelectedModelOptions,
821
- setExpandedProvider,
883
+ setExpandedProvider: (value: string | null) => updateFlow({ expandedProvider: value }),
884
} satisfies NewTaskFlowContextValue;
885
886
return (
apps/mobile/src/features/threads/new-task-flow-state.test.ts
new
+154
@@ -0,0 +1,154 @@
1
+import { EnvironmentId, ProjectId } from "@t3tools/contracts";
2
+import { describe, expect, it } from "vite-plus/test";
3
+
4
+import { appAtomRegistry } from "../../state/atom-registry";
5
+import {
6
+ INITIAL_NEW_TASK_FLOW_STATE,
7
+ newTaskFlowKey,
8
+ newTaskFlowStateAtom,
9
+ pruneNewTaskFlowStates,
10
+ readNewTaskFlowState,
11
+ resolveRouteDraft,
12
+ stampedEnvironmentProjectsLoading,
13
+ updateNewTaskFlowState,
14
+} from "./new-task-flow-state";
15
+
16
+function draftRoute(key: string, draftId: string) {
17
+ return { key, name: "Thread", params: { draft: { draftId } } };
18
+}
19
+
20
+describe("new task flow state", () => {
21
+ it("keeps a covered draft route's flow while another draft route is pushed above it", () => {
22
+ const routeA = draftRoute("route-a", "draft-a");
23
+ const routeB = draftRoute("route-b", "draft-b");
24
+ const flowA = newTaskFlowKey(routeA)!;
25
+ const flowB = newTaskFlowKey(routeB)!;
26
+
27
+ // The provider subscribes to A, writes its selection, then moves to B.
28
+ const unmountA = appAtomRegistry.mount(newTaskFlowStateAtom(flowA));
29
+ updateNewTaskFlowState(flowA, { projectKey: "env:project-a", draftKey: "draft-a" });
30
+ unmountA();
31
+ const unmountB = appAtomRegistry.mount(newTaskFlowStateAtom(flowB));
32
+ pruneNewTaskFlowStates({ routes: [{ key: "home", name: "Home" }, routeA, routeB] });
33
+
34
+ expect(readNewTaskFlowState(flowB)).toBe(INITIAL_NEW_TASK_FLOW_STATE);
35
+ expect(appAtomRegistry.get(newTaskFlowStateAtom(flowA))).toMatchObject({
36
+ projectKey: "env:project-a",
37
+ draftKey: "draft-a",
38
+ });
39
+
40
+ // Popping B returns to A with its state intact.
41
+ unmountB();
42
+ pruneNewTaskFlowStates({ routes: [{ key: "home", name: "Home" }, routeA] });
43
+ expect(readNewTaskFlowState(flowA).projectKey).toBe("env:project-a");
44
+ });
45
+
46
+ it("drops a flow when its route is popped or promoted to a live thread", () => {
47
+ const routeA = draftRoute("route-a", "draft-a");
48
+ const routeB = draftRoute("route-b", "draft-b");
49
+ updateNewTaskFlowState(newTaskFlowKey(routeA)!, { projectKey: "env:project-a" });
50
+ updateNewTaskFlowState(newTaskFlowKey(routeB)!, { projectKey: "env:project-b" });
51
+
52
+ pruneNewTaskFlowStates({
53
+ routes: [{ key: "route-a", name: "Thread", params: { environmentId: "env", threadId: "t" } }],
54
+ });
55
+
56
+ expect(readNewTaskFlowState(newTaskFlowKey(routeA)!)).toBe(INITIAL_NEW_TASK_FLOW_STATE);
57
+ expect(readNewTaskFlowState(newTaskFlowKey(routeB)!)).toBe(INITIAL_NEW_TASK_FLOW_STATE);
58
+ });
59
+});
60
+
61
+describe("resolveRouteDraft", () => {
62
+ const environmentId = EnvironmentId.make("env");
63
+ const projectId = ProjectId.make("project");
64
+ const stamp = { environmentId, projectId };
65
+ const project = { environmentId, id: projectId };
66
+ const base = {
67
+ flow: INITIAL_NEW_TASK_FLOW_STATE,
68
+ routeDraftId: "new-task:draft-1",
69
+ draftsLoaded: true,
70
+ stamp,
71
+ projects: [project],
72
+ stampedEnvironmentLoading: false,
73
+ };
74
+
75
+ it("binds the route's draft and its stamped project", () => {
76
+ expect(resolveRouteDraft(base)).toEqual({
77
+ kind: "open",
78
+ flow: {
79
+ ...INITIAL_NEW_TASK_FLOW_STATE,
80
+ environmentId,
81
+ projectKey: "env:project",
82
+ draftKey: "new-task:draft-1",
83
+ },
84
+ });
85
+ });
86
+
87
+ it("leaves a flow that already bound a draft alone", () => {
88
+ const flow = { ...INITIAL_NEW_TASK_FLOW_STATE, draftKey: "new-task:other" };
89
+ expect(resolveRouteDraft({ ...base, flow })).toEqual({ kind: "none" });
90
+ });
91
+
92
+ it("waits for hydration, and for the stamped environment's projects", () => {
93
+ expect(resolveRouteDraft({ ...base, draftsLoaded: false, stamp: undefined })).toEqual({
94
+ kind: "pending",
95
+ });
96
+ expect(resolveRouteDraft({ ...base, projects: [], stampedEnvironmentLoading: true })).toEqual({
97
+ kind: "pending",
98
+ });
99
+ });
100
+
101
+ it("waits for a slower environment's projects while another environment's have loaded", () => {
102
+ const environmentB = EnvironmentId.make("env-b");
103
+ const projectB = { environmentId: environmentB, id: ProjectId.make("project-b") };
104
+ const stampB = { environmentId: environmentB, projectId: projectB.id };
105
+
106
+ expect(resolveRouteDraft({ ...base, stamp: stampB, stampedEnvironmentLoading: true })).toEqual({
107
+ kind: "pending",
108
+ });
109
+ expect(
110
+ resolveRouteDraft({ ...base, stamp: stampB, projects: [project, projectB] }),
111
+ ).toMatchObject({ kind: "open", flow: { environmentId: environmentB } });
112
+ });
113
+
114
+ it("reports a draft that is gone or whose project is gone", () => {
115
+ expect(resolveRouteDraft({ ...base, stamp: undefined })).toEqual({ kind: "missing" });
116
+ expect(
117
+ resolveRouteDraft({ ...base, projects: [{ environmentId, id: ProjectId.make("other") }] }),
118
+ ).toEqual({ kind: "missing" });
119
+ });
120
+});
121
+
122
+describe("stampedEnvironmentProjectsLoading", () => {
123
+ const settled = {
124
+ connectionsReady: true,
125
+ connectionState: "connected" as const,
126
+ shellCacheRead: true,
127
+ shellStatus: "live" as const,
128
+ shellHasError: false,
129
+ };
130
+
131
+ it("waits while the environment is still delivering its first project list", () => {
132
+ expect(stampedEnvironmentProjectsLoading({ ...settled, connectionsReady: false })).toBe(true);
133
+ expect(stampedEnvironmentProjectsLoading({ ...settled, shellCacheRead: false })).toBe(true);
134
+ expect(stampedEnvironmentProjectsLoading({ ...settled, connectionState: "connecting" })).toBe(
135
+ true,
136
+ );
137
+ expect(stampedEnvironmentProjectsLoading({ ...settled, shellStatus: "synchronizing" })).toBe(
138
+ true,
139
+ );
140
+ });
141
+
142
+ it("settles once the list is live, or when nothing more will arrive", () => {
143
+ expect(stampedEnvironmentProjectsLoading(settled)).toBe(false);
144
+ expect(stampedEnvironmentProjectsLoading({ ...settled, connectionState: null })).toBe(false);
145
+ expect(
146
+ stampedEnvironmentProjectsLoading({
147
+ ...settled,
148
+ connectionState: "reconnecting",
149
+ shellStatus: "synchronizing",
150
+ }),
151
+ ).toBe(false);
152
+ expect(stampedEnvironmentProjectsLoading({ ...settled, shellHasError: true })).toBe(false);
153
+ });
154
+});
apps/mobile/src/features/threads/new-task-flow-state.ts
+135
@@ -1,9 +1,20 @@
1
+import type { EnvironmentConnectionPhase } from "@t3tools/client-runtime/connection";
2
+import type { EnvironmentShellStatus } from "@t3tools/client-runtime/state/shell";
3
+import type { EnvironmentId, ProjectId } from "@t3tools/contracts";
4
+import { Atom } from "effect/reactivity";
5
+
6
+import { scopedProjectKey } from "../../lib/scopedEntities";
7
+import { appAtomRegistry } from "../../state/atom-registry";
8
+import { isNewTaskDraftKey } from "../../state/new-task-draft-key";
9
import {
10
draftRouteIdentity,
11
isDraftThreadRoute,
12
type NewTaskDraftRouteParams,
13
} from "./thread-route-state";
14
15
+/** The flow a provider serves while no draft route is on the stack. */
16
+export const INACTIVE_FLOW_KEY = "inactive";
17
+
18
/** The flow key for a draft Thread route: its key plus the draft it opened. */
19
export function newTaskFlowKey(route: {
20
readonly key: string;
@@ -13,6 +24,118 @@ export function newTaskFlowKey(route: {
24
return draft ? `${route.key}:${draftRouteIdentity(draft)}` : undefined;
25
}
26
27
+export interface NewTaskFlowState {
28
+ readonly environmentId: EnvironmentId | null;
29
+ readonly projectKey: string | null;
30
+ readonly draftKey: string | null;
31
+ readonly submitting: boolean;
32
+ readonly expandedProvider: string | null;
33
+}
34
+
35
+export const INITIAL_NEW_TASK_FLOW_STATE: NewTaskFlowState = {
36
+ environmentId: null,
37
+ projectKey: null,
38
+ draftKey: null,
39
+ submitting: false,
40
+ expandedProvider: null,
41
+};
42
+
43
+// Every draft route on the stack keeps its flow, not just the one the provider
44
+// currently serves: a draft Thread pushed above draft A must not drop A's
45
+// selection. Entries live exactly as long as their route (see prune below).
46
+const flowStatesAtom = Atom.make<Readonly<Record<string, NewTaskFlowState>>>({}).pipe(
47
+ Atom.keepAlive,
48
+ Atom.withLabel("mobile:new-task-flows"),
49
+);
50
+
51
+export const newTaskFlowStateAtom = Atom.family((flowKey: string) =>
52
+ Atom.make((get) => get(flowStatesAtom)[flowKey] ?? INITIAL_NEW_TASK_FLOW_STATE).pipe(
53
+ Atom.withLabel("mobile:new-task-flow"),
54
+ ),
55
+);
56
+
57
+export function readNewTaskFlowState(flowKey: string): NewTaskFlowState {
58
+ return appAtomRegistry.get(flowStatesAtom)[flowKey] ?? INITIAL_NEW_TASK_FLOW_STATE;
59
+}
60
+
61
+export function updateNewTaskFlowState(flowKey: string, patch: Partial<NewTaskFlowState>): void {
62
+ const flows = appAtomRegistry.get(flowStatesAtom);
63
+ appAtomRegistry.set(flowStatesAtom, {
64
+ ...flows,
65
+ [flowKey]: { ...(flows[flowKey] ?? INITIAL_NEW_TASK_FLOW_STATE), ...patch },
66
+ });
67
+}
68
+
69
+/**
70
+ * What a draft route's `draftId` means for a flow that has not bound a draft
71
+ * yet. Drafts hydrate from disk and projects arrive with the shell snapshot,
72
+ * so on a cold launch or deep link the answer can be "pending" for a while.
73
+ */
74
+export type RouteDraftResolution =
75
+ | { readonly kind: "none" }
76
+ | { readonly kind: "pending" }
77
+ | { readonly kind: "missing" }
78
+ | { readonly kind: "open"; readonly flow: NewTaskFlowState };
79
+
80
+export function resolveRouteDraft(input: {
81
+ readonly flow: NewTaskFlowState;
82
+ readonly routeDraftId: string | undefined;
83
+ readonly draftsLoaded: boolean;
84
+ readonly stamp:
85
+ | { readonly environmentId: EnvironmentId; readonly projectId: ProjectId }
86
+ | undefined;
87
+ readonly projects: ReadonlyArray<{
88
+ readonly environmentId: EnvironmentId;
89
+ readonly id: ProjectId;
90
+ }>;
91
+ /** See `stampedEnvironmentProjectsLoading`. */
92
+ readonly stampedEnvironmentLoading: boolean;
93
+}): RouteDraftResolution {
94
+ const { routeDraftId, stamp } = input;
95
+ if (routeDraftId === undefined || input.flow.draftKey !== null) return { kind: "none" };
96
+ if (!input.draftsLoaded) return { kind: "pending" };
97
+ if (!isNewTaskDraftKey(routeDraftId) || stamp === undefined) return { kind: "missing" };
98
+ // The stamped project must be loaded: the composer falls back to the
99
+ // environment's first project otherwise, and the draft would be sent
100
+ // somewhere the user never chose.
101
+ const loaded = input.projects.some(
102
+ (project) => project.environmentId === stamp.environmentId && project.id === stamp.projectId,
103
+ );
104
+ if (!loaded) return input.stampedEnvironmentLoading ? { kind: "pending" } : { kind: "missing" };
105
+ return {
106
+ kind: "open",
107
+ flow: {
108
+ ...input.flow,
109
+ environmentId: stamp.environmentId,
110
+ projectKey: scopedProjectKey(stamp.environmentId, stamp.projectId),
111
+ draftKey: routeDraftId,
112
+ },
113
+ };
114
+}
115
+
116
+/**
117
+ * Whether the stamped environment may still deliver its project list. An
118
+ * unknown, offline, or failed environment is settled, so a project it lacks
119
+ * sends the route back to the picker. Mirrors `threadRouteIsHydrating`.
120
+ */
121
+export function stampedEnvironmentProjectsLoading(input: {
122
+ readonly connectionsReady: boolean;
123
+ readonly connectionState: EnvironmentConnectionPhase | null;
124
+ readonly shellCacheRead: boolean;
125
+ readonly shellStatus: EnvironmentShellStatus;
126
+ readonly shellHasError: boolean;
127
+}): boolean {
128
+ if (input.shellHasError) return false;
129
+ if (!input.connectionsReady) return true;
130
+ if (input.connectionState === null) return false;
131
+ if (!input.shellCacheRead) return true;
132
+ // Only a first attempt is worth waiting out; a reconnecting environment's
133
+ // retries leave its shell synchronizing.
134
+ if (input.connectionState === "connecting") return true;
135
+ if (input.connectionState !== "connected") return false;
136
+ return input.shellStatus === "synchronizing" || input.shellStatus === "empty";
137
+}
138
+
139
interface NavigationRoutes {
140
readonly routes: ReadonlyArray<{
141
readonly key: string;
@@ -30,3 +153,15 @@ export function liveNewTaskFlowKeys(state: NavigationRoutes): ReadonlySet<string
153
}),
154
);
155
}
156
+
157
+/**
158
+ * Drops the flow of every draft route that left the stack: popped (discarded)
159
+ * or promoted to a live thread, whose params no longer carry the draft.
160
+ */
161
+export function pruneNewTaskFlowStates(state: NavigationRoutes): void {
162
+ const flows = appAtomRegistry.get(flowStatesAtom);
163
+ const live = liveNewTaskFlowKeys(state);
164
+ const kept = Object.entries(flows).filter(([flowKey]) => live.has(flowKey));
165
+ if (kept.length === Object.keys(flows).length) return;
166
+ appAtomRegistry.set(flowStatesAtom, Object.fromEntries(kept));
167
+}
apps/mobile/src/state/use-composer-drafts.ts
+12
@@ -471,6 +471,16 @@ export const composerDraftsAtom = Atom.make<Record<string, ComposerDraft>>({}).p
471
Atom.withLabel("mobile:composer-drafts"),
472
);
473
474
+/**
475
+ * Whether persisted drafts have merged in. Hydration starts with the app's
476
+ * attachment upload worker; a failed load stays false until the next
477
+ * `ensureComposerDraftsLoaded` caller retries it.
478
+ */
479
+export const composerDraftsLoadedAtom = Atom.make(false).pipe(
480
+ Atom.keepAlive,
481
+ Atom.withLabel("mobile:composer-drafts-loaded"),
482
+);
483
+
484
export const stickyComposerModelSelectionAtom = Atom.make<ModelSelection | null>(null).pipe(
485
Atom.keepAlive,
486
Atom.withLabel("mobile:sticky-composer-model-selection"),
@@ -507,6 +517,7 @@ const persistenceQueue = new SerializedAsyncQueue();
517
518
export function resetComposerDraftsLoadState(): void {
519
loadPromise = null;
520
+ appAtomRegistry.set(composerDraftsLoadedAtom, false);
521
persistRetryNeeded = false;
522
}
523
@@ -1039,6 +1050,7 @@ export function ensureComposerDraftsLoaded(): void {
1050
),
1051
});
1052
}
1053
+ appAtomRegistry.set(composerDraftsLoadedAtom, true);
1054
});
1055
loadPromise = loading;
1056
void loading.catch((cause) => {