perf(shell): cold connects skip idle nested subagent chains, a quarter of the shell rows

apps/mobile/src/connection/environment-cache-store.ts

@@ -111,9 +111,9 @@ export const make = Effect.fn("MobileEnvironmentCacheStore.make")(function* () {
         select: (stored) =>
           stored.environmentId === environmentId
             ? Option.some(
-                stored.origin === undefined
+                stored.originV2 === undefined
                   ? stored.snapshot
-                  : { ...stored.snapshot, origin: stored.origin },
+                  : { ...stored.snapshot, origin: stored.originV2 },
               )
             : Option.none(),
       }).pipe(
@@ -130,7 +130,7 @@ export const make = Effect.fn("MobileEnvironmentCacheStore.make")(function* () {
           schemaVersion: ORCHESTRATION_CACHE_SCHEMA_VERSION,
           environmentId,
           snapshot,
-          ...(origin === undefined ? {} : { origin }),
+          ...(origin === undefined ? {} : { originV2: origin }),
         }).pipe(Effect.mapError((cause) => persistenceError("save-shell", cause)));
         yield* database
           .saveCache(

apps/mobile/src/features/layout/AdaptiveWorkspaceLayout.tsx

@@ -106,9 +106,11 @@ import { useAndroidWorkspaceRoot } from "./workspace/AndroidWorkspaceTabsProvide
 import { dispatchRootStackReset, rootStackState } from "../../lib/root-stack-reset";
 import {
   currentWorkspaceSelections,
+  markWorkspaceThreadReopened,
   workspaceSelectionCheck,
 } from "./workspace/workspace-selection-store";
 import {
+  threadReopenedByTab,
   workspaceTabColumns,
   workspaceTabNavigationState,
 } from "./workspace/workspace-tab-navigation";
@@ -555,6 +557,11 @@ function AdaptiveWorkspaceLayoutContent(
         seedPullRequest: withKnownPullRequestSummary,
       },
     );
+    if (tab === "threads") {
+      markWorkspaceThreadReopened(
+        threadReopenedByTab(workspace, next.routes, currentWorkspaceSelections()),
+      );
+    }
     if (layout.variant === "medium") {
       const opened = next.routes.at(-1 - overlays.length)?.key ?? null;
       setOverlaySidebar((current) => ({ ...current, visible: true, keepOpenFor: opened }));

apps/mobile/src/features/layout/workspace/workspace-selection-store.ts

@@ -19,13 +19,11 @@ import { workspaceRoutesOf } from "../workspace-overlay-routes";
 import type { WorkspaceSelections } from "../../../persistence/mobile-preferences";
 import { appAtomRegistry } from "../../../state/atom-registry";
 import { environmentPresentations } from "../../../state/presentation";
-import {
-  environmentThreadShells,
-  startOpeningEnvironmentThread,
-  threadEnvironment,
-} from "../../../state/threads";
+import { environmentShell } from "../../../state/shell";
+import { environmentThreadShells, startOpeningEnvironmentThread } from "../../../state/threads";
 import {
   rememberedSettingsPage,
+  rememberedThreadReopens,
   workspaceSelectionsIn,
   type WorkspaceSelectionCheck,
 } from "./workspace-tab-navigation";
@@ -38,6 +36,9 @@ const REMEMBERS = Platform.OS === "ios";
 let selections: WorkspaceSelections = {};
 let saved = selections;
 let hydration: Promise<void> | null = null;
+// The chat a tab switch or a cold start reopened by itself, while it stays the remembered one.
+let reopened: WorkspaceSelections["threads"];
+let reopenings = 0;
 
 function save() {
   const writing = selections;
@@ -89,6 +90,32 @@ export function currentWorkspaceSelections() {
 export function recordWorkspaceSelections(state: NavigationState | undefined) {
   if (!REMEMBERS || !state) return;
   selections = workspaceSelectionsIn(state.routes.slice(0, state.index + 1), selections);
+  if (reopened && !sameThread(reopened, selections.threads)) reopened = undefined;
+}
+
+function sameThread(
+  left: { readonly environmentId: string; readonly threadId: string },
+  right: { readonly environmentId: string; readonly threadId: string } | undefined,
+) {
+  return left.environmentId === right?.environmentId && left.threadId === right.threadId;
+}
+
+/** Marks the chat a tab switch reopened by itself; see `threadReopenedByTab`. */
+export function markWorkspaceThreadReopened(thread: WorkspaceSelections["threads"]) {
+  reopened = thread;
+  if (thread) reopenings += 1;
+}
+
+/**
+ * The number of the reopening that put this chat on screen, or null when somebody opened it.
+ * Nobody asked for a reopened chat, so its screen closes it when it turns out archived or
+ * deleted, where a chat somebody opened shows what it has. iOS keeps a screen mounted across tab
+ * switches, so what the screen learned counts for one reopening only.
+ */
+export function workspaceThreadReopening(environmentId: EnvironmentId, threadId: ThreadId) {
+  return reopened !== undefined && sameThread(reopened, { environmentId, threadId })
+    ? reopenings
+    : null;
 }
 
 function environmentRemoved(environmentId: string) {
@@ -101,22 +128,31 @@ function environmentRemoved(environmentId: string) {
   );
 }
 
-/**
- * A remembered chat is gone once its environment was removed, or once that environment's
- * snapshot has loaded without it. Before it loads there is nothing to contradict it.
- */
+/** Reads what `rememberedThreadReopens` decides from: the shell rows and the removals it applied. */
 export const workspaceSelectionCheck: WorkspaceSelectionCheck = {
   thread: (selection) => {
     if (environmentRemoved(selection.environmentId)) return false;
     const environmentId = selection.environmentId as EnvironmentId;
-    if (!appAtomRegistry.get(threadEnvironment.snapshotAtom(environmentId))) return true;
-    return appAtomRegistry
-      .get(environmentThreadShells.environmentThreadIndexAtom(environmentId))
-      .has(selection.threadId as ThreadId);
+    const threadId = selection.threadId as ThreadId;
+    return rememberedThreadReopens({
+      listed: appAtomRegistry
+        .get(environmentThreadShells.environmentThreadIndexAtom(environmentId))
+        .has(threadId),
+      removed: appAtomRegistry
+        .get(environmentShell.stateValueAtom(environmentId))
+        .removedAt.has(threadId),
+    });
   },
   pullRequest: (selection) => !environmentRemoved(selection.environmentId),
 };
 
+/** Stops reopening a chat its own screen found archived or deleted. */
+export function forgetWorkspaceThread(environmentId: EnvironmentId, threadId: ThreadId) {
+  const { threads, ...rest } = selections;
+  if (threads && sameThread(threads, { environmentId, threadId })) selections = rest;
+  if (reopened && sameThread(reopened, { environmentId, threadId })) reopened = undefined;
+}
+
 /** Whether the window lays the workspace out in columns, by the rule the layout itself uses. */
 export function workspaceHasColumns() {
   const metrics = currentNativeLayoutMetrics();
@@ -153,9 +189,9 @@ export async function launchWorkspaceURL(): Promise<string | null> {
   }
   await metrics;
   if (!thread || !workspaceHasColumns() || !workspaceSelectionCheck.thread(thread)) return null;
-  return Linking.createURL(
-    `threads/${encodeURIComponent(thread.environmentId)}/${encodeURIComponent(thread.threadId)}`,
-  );
+  markWorkspaceThreadReopened(thread);
+  // Not `createURL(path)`: it encodes the path again, and a subagent's id holds `%` and `:`.
+  return `${Linking.createURL("/")}threads/${encodeURIComponent(thread.environmentId)}/${encodeURIComponent(thread.threadId)}`;
 }
 
 /** Whether the workspace shows its first detail page, directly above its list. */

apps/mobile/src/features/layout/workspace/workspace-tab-navigation.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, it } from "vite-plus/test";
 
 import { restoreSettingsLinkState } from "../../settings/settings-navigation";
 import {
+  rememberedThreadReopens,
+  threadReopenedByTab,
   workspaceSelectionsIn,
   workspaceTabColumns,
   workspaceTabNavigationState,
@@ -48,6 +50,27 @@ describe("workspace tab selections", () => {
   });
 });
 
+describe("reopening the remembered chat", () => {
+  it("reopens a chat the shell left out, and not one the shell removed", () => {
+    // An idle subagent or an older settled chat: no row, and nothing removed it.
+    expect(rememberedThreadReopens({ listed: false, removed: false })).toBe(true);
+    expect(rememberedThreadReopens({ listed: true, removed: false })).toBe(true);
+    // Archived or deleted in this session.
+    expect(rememberedThreadReopens({ listed: false, removed: true })).toBe(false);
+    // Archived, then restored: the row is back.
+    expect(rememberedThreadReopens({ listed: true, removed: true })).toBe(true);
+  });
+
+  it("marks the chat a tab switch put on screen, and not one that was already there", () => {
+    const selections = { threads: thread.params };
+    expect(threadReopenedByTab([home, pullRequest], [home, thread], selections)).toBe(
+      selections.threads,
+    );
+    expect(threadReopenedByTab([home, thread], [home, thread], selections)).toBe(undefined);
+    expect(threadReopenedByTab([home, pullRequest], [home], selections)).toBe(undefined);
+  });
+});
+
 describe("opening a workspace tab", () => {
   const columns = { columns: true, check: available };
 

apps/mobile/src/features/layout/workspace/workspace-tab-navigation.ts

@@ -38,6 +38,37 @@ export function rememberedSettingsPage(selections: WorkspaceSelections): Setting
     : DEFAULT_SETTINGS_PAGE;
 }
 
+/**
+ * Whether a remembered chat is reopened. Shells leave idle subagents and older settled chats out,
+ * so a missing row does not say the chat is gone; a removal the shell applied does. A chat
+ * reopened without a row closes itself when its detail says it was archived or deleted.
+ */
+export function rememberedThreadReopens(input: {
+  readonly listed: boolean;
+  readonly removed: boolean;
+}) {
+  return input.listed || !input.removed;
+}
+
+function showsThread(route: RouteLike, thread: ThreadSelection) {
+  return (
+    route.name === "Thread" &&
+    stringParam(route.params, "environmentId") === thread.environmentId &&
+    stringParam(route.params, "threadId") === thread.threadId
+  );
+}
+
+/** The remembered chat, when opening a tab put it on screen and it was not there before. */
+export function threadReopenedByTab(
+  previous: readonly RouteLike[],
+  next: readonly RouteLike[],
+  selections: WorkspaceSelections,
+) {
+  const thread = selections.threads;
+  if (!thread || previous.some((route) => showsThread(route, thread))) return undefined;
+  return next.some((route) => showsThread(route, thread)) ? thread : undefined;
+}
+
 /** Whether a remembered chat or pull request can still be opened. */
 export interface WorkspaceSelectionCheck {
   readonly thread: (selection: ThreadSelection) => boolean;
@@ -167,12 +198,7 @@ function detailRoute(
     const thread = selections.threads;
     if (!thread || !check.thread(thread)) return undefined;
     return (
-      state.routes.find(
-        (route) =>
-          route.name === "Thread" &&
-          stringParam(route.params, "environmentId") === thread.environmentId &&
-          stringParam(route.params, "threadId") === thread.threadId,
-      ) ?? {
+      state.routes.find((route) => showsThread(route, thread)) ?? {
         key: thread.key,
         name: "Thread",
         params: { environmentId: thread.environmentId, threadId: thread.threadId },

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

@@ -92,7 +92,7 @@ import { useSelectedThreadWorktree } from "../../state/use-selected-thread-workt
 import { useThreadComposerState } from "../../state/use-thread-composer-state";
 import { resolveMergeBackTargetThreadId } from "@t3tools/client-runtime/state/thread-relationships";
 import { resolveLatestMergeBackRun } from "@t3tools/client-runtime/state/thread-workflows";
-import { threadEnvironment } from "../../state/threads";
+import { threadEnvironment, useOpenThreadFamily } from "../../state/threads";
 import { EMPTY_ENVIRONMENT_THREAD_STATE } from "@t3tools/client-runtime/state/threads";
 import { useProjects } from "../../state/entities";
 import { projectThreadContentPresentation } from "./threadContentPresentation";
@@ -105,6 +105,7 @@ import { ThreadFileNavigatorPane } from "../files/thread-file-navigator-pane";
 import { InspectorSheetContext } from "../layout/workspace-inspector-sheet";
 import type { InspectorContent } from "../layout/inspector-panes";
 import {
+  reopenedThreadIsGone,
   threadDetailErrorIsCurrent,
   threadRouteIsHydrating,
   threadRouteOpensDraft,
@@ -126,6 +127,10 @@ import { useStartSideChat } from "./useStartSideChat";
 import { useThreadStatusAnnouncements } from "./useThreadStatusAnnouncements";
 import type { ThreadInspectorMode, ThreadInspectorTarget } from "./thread-inspector-navigation";
 import { useSelectWorkspaceDetail } from "../layout/workspace/useSelectWorkspaceDetail";
+import {
+  forgetWorkspaceThread,
+  workspaceThreadReopening,
+} from "../layout/workspace/workspace-selection-store";
 
 function firstRouteParam(value: string | string[] | undefined): string | null {
   const first = Array.isArray(value) ? value[0] : value;
@@ -225,6 +230,27 @@ function UnavailableThreadDraftRedirect(props: { readonly environmentId: Environ
   return <OpeningThreadLoadingScreen />;
 }
 
+/** A chat the workspace reopened by itself and that cannot open: back to the list, for good. */
+function ReopenedThreadClose(props: {
+  readonly environmentId: EnvironmentId;
+  readonly threadId: ThreadId;
+}) {
+  const goBack = useWorkspaceBackNavigation("threads");
+  const navigation = useNavigation();
+  const routeKey = useRoute().key;
+  const close = useEffectEvent(() => {
+    forgetWorkspaceThread(props.environmentId, props.threadId);
+    // iOS keeps this screen mounted after a tab switch dropped its route; going back from there
+    // would act on the page in front.
+    if (navigation.getState()?.routes.some((route) => route.key === routeKey)) goBack();
+  });
+  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- leaves this route for the list on mount: the workspace reopened the chat by itself and it cannot open
+  useEffect(() => {
+    close();
+  }, []);
+  return <OpeningThreadLoadingScreen />;
+}
+
 export function ThreadRouteScreen(props: ThreadRouteScreenProps) {
   return (
     <ThreadScreenHost>
@@ -244,7 +270,8 @@ function LiveThreadRouteController(props: ThreadRouteScreenProps) {
   useAndroidWorkspaceBack("threads");
   const connectionsReady = useConnectionsReady();
   const { connectionState } = useRemoteConnectionStatus();
-  const { selectedThread } = useThreadSelection();
+  const { selectedThread, selectedThreadListed, selectedThreadDetailRef } = useThreadSelection();
+  const familyPending = useOpenThreadFamily(selectedThreadDetailRef);
   const params = props.route.params ?? {};
   const environmentIdRaw = firstRouteParam(params.environmentId);
   const threadIdRaw = firstRouteParam(params.threadId);
@@ -265,6 +292,19 @@ function LiveThreadRouteController(props: ThreadRouteScreenProps) {
       ? null
       : scopedThreadKey(selectedThread.environmentId, selectedThread.id);
   const selectedThreadDetailState = useSelectedThreadDetailState();
+  const reopening =
+    routeName === "Thread" &&
+    !props.inspectorPresentation &&
+    environmentId !== null &&
+    threadIdRaw !== null
+      ? workspaceThreadReopening(environmentId, ThreadId.make(threadIdRaw))
+      : null;
+  // A shell row proves a reopened chat exists. Until one arrives, its detail can still close it.
+  const [provenReopening, setProvenReopening] = useState<number | null>(null);
+  if (reopening !== null && selectedThreadListed && provenReopening !== reopening) {
+    setProvenReopening(reopening);
+  }
+  const reopenedUnproven = reopening !== null && provenReopening !== reopening;
   const detailError = selectedThreadDetailState.error;
   const [errorBeforeConnected, setErrorBeforeConnected] = useState(() =>
     routeConnectionState === "connected" ? Option.none<string>() : detailError,
@@ -289,6 +329,19 @@ function LiveThreadRouteController(props: ThreadRouteScreenProps) {
     return withInspectorHeader(<OpeningThreadLoadingScreen />);
   }
 
+  const closeReopened = (
+    <ReopenedThreadClose environmentId={environmentId} threadId={ThreadId.make(threadIdRaw)} />
+  );
+  if (
+    reopenedUnproven &&
+    reopenedThreadIsGone({
+      detailStatus: selectedThreadDetailState.status,
+      thread: selectedThreadKey === routeThreadKey ? selectedThread : null,
+    })
+  ) {
+    return closeReopened;
+  }
+
   if (selectedThread !== null && selectedThreadKey === routeThreadKey) {
     return withInspectorHeader(
       <ThreadRouteContent {...props} selectedThreadDetailState={selectedThreadDetailState} />,
@@ -310,6 +363,7 @@ function LiveThreadRouteController(props: ThreadRouteScreenProps) {
       error: detailError,
       errorBeforeConnected,
     }),
+    familyPending,
   });
 
   if (stillHydrating) {
@@ -324,7 +378,12 @@ function LiveThreadRouteController(props: ThreadRouteScreenProps) {
       detailStatus: selectedThreadDetailState.status,
     })
   ) {
-    return <UnavailableThreadDraftRedirect environmentId={environmentId} />;
+    // A draft nobody asked for must not take the place of a chat that only failed to reopen.
+    return reopenedUnproven ? (
+      closeReopened
+    ) : (
+      <UnavailableThreadDraftRedirect environmentId={environmentId} />
+    );
   }
 
   return withInspectorHeader(