@devries-cameron20 / t3code-1 / commits / e109dc8d89
Fork 0

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) => {