perf(mobile): streaming and provider pushes re-render less on the thread screen

apps/mobile/src/features/keyboard/CommandPalette.tsx

@@ -24,7 +24,7 @@ import { SymbolView, type AppSymbolName } from "../../components/ui/AppSymbol";
 import { cn } from "../../lib/cn";
 import { scopedProjectKey, scopedThreadKey } from "../../lib/scopedEntities";
 import { T3KeyboardCommands } from "../../native/T3KeyboardCommands";
-import { useProjects, useThreadShell, useThreadShells } from "../../state/entities";
+import { useProjects, useQuietThreadShell, useThreadShells } from "../../state/entities";
 import { useThreadSearch } from "../../state/queries";
 import { useWorkspaceEnvironments } from "../../state/workspace";
 import { useSavedRemoteConnections } from "../../state/use-remote-environment-registry";
@@ -144,7 +144,7 @@ export function CommandPalette(props: {
   const projects = useProjects();
   const threads = useThreadShells();
   const activeThreadRef = useMemo(() => parseActiveThreadPath(props.pathname), [props.pathname]);
-  const activeThread = useThreadShell(activeThreadRef);
+  const activeThread = useQuietThreadShell(activeThreadRef);
   const environments = useWorkspaceEnvironments();
   const { savedConnectionsById } = useSavedRemoteConnections();
   const [query, setQuery] = useState("");

apps/mobile/src/features/keyboard/HardwareKeyboardCommandProvider.tsx

@@ -15,7 +15,7 @@ import {
 
 import { tryCopyTextWithHaptic } from "../../lib/copyTextWithHaptic";
 import { T3KeyboardCommands } from "../../native/T3KeyboardCommands";
-import { useThreadShell } from "../../state/entities";
+import { useQuietThreadShell } from "../../state/entities";
 import type { GitActionProgress } from "../../state/use-vcs-action-state";
 import { GitActionProgressOverlay } from "../threads/GitActionProgressOverlay";
 import { CommandPalette } from "./CommandPalette";
@@ -50,7 +50,7 @@ export function HardwareKeyboardCommandProvider({
   const [paletteOpen, setPaletteOpen] = useState(false);
   const closePalette = useCallback(() => setPaletteOpen(false), []);
   const activeThreadRef = useMemo(() => parseActiveThreadPath(pathname), [pathname]);
-  const activeThread = useThreadShell(activeThreadRef);
+  const activeThread = useQuietThreadShell(activeThreadRef);
   const copyTarget = useMemo(
     () =>
       activeThreadRef === null

apps/mobile/src/features/prompt-links/usePromptLinkResolver.ts

@@ -21,7 +21,7 @@ import {
 import { useEffect, useEffectEvent, useRef } from "react";
 
 import { scopedThreadKey } from "../../lib/scopedEntities";
-import { useServerConfigs, useThreadShells } from "../../state/entities";
+import { useServerConfigsWithProviders, useThreadShells } from "../../state/entities";
 import { projectEnvironment } from "../../state/projects";
 import { composerPullRequests } from "../../state/pull-requests";
 import { useAtomCommand } from "../../state/use-atom-command";
@@ -57,7 +57,7 @@ export function usePromptLinkResolver(params: Readonly<Record<string, unknown>>
   const flow = useNewTaskFlow();
   const { state: catalogState } = useWorkspaceState();
   const threads = useThreadShells();
-  const serverConfigs = useServerConfigs();
+  const serverConfigs = useServerConfigsWithProviders();
   const { connectedEnvironments } = useRemoteConnectionStatus();
   const openScratch = useAtomCommand(projectEnvironment.openScratch, { reportFailure: false });
   const loadPullRequest = useAtomQueryRunner(composerPullRequests.detail, {

apps/mobile/src/features/settings/scheduled-task-editor.tsx

@@ -10,7 +10,7 @@ import {
   type SetStateAction,
 } from "react";
 
-import { useProjects, useServerConfigs } from "../../state/entities";
+import { useProjects, useServerConfigsWithProviders } from "../../state/entities";
 import {
   createDraft,
   scheduledTaskDefaultModel,
@@ -43,7 +43,7 @@ const ScheduledTaskEditorContext = createContext<{
 export function ScheduledTaskEditorProvider({ children }: { readonly children: ReactNode }) {
   const { selectedTargets, selectedProjectKey, projectGroups } = useSettingsEnvironmentFilter();
   const selectedGroup = projectGroups.find((group) => group.key === selectedProjectKey);
-  const configs = useServerConfigs();
+  const configs = useServerConfigsWithProviders();
   const projects = useProjects();
   const defaultTarget = settingsTargetsForProject(
     selectedTargets,

apps/mobile/src/features/shortcuts/useAppShortcuts.ts

@@ -8,7 +8,7 @@ import {
   saveRecentThreadShortcuts,
   type RecentThreadShortcut,
 } from "../../persistence/imperative";
-import { useThreadShell } from "../../state/entities";
+import { useQuietThreadShell } from "../../state/entities";
 import {
   activeThreadRef,
   buildShortcutActions,
@@ -56,7 +56,7 @@ function useRecentThreadShortcutSync(state: NavigationState): void {
     () => (Platform.OS === "android" ? activeThreadRef(state) : null),
     [state],
   );
-  const threadShell = useThreadShell(threadRef);
+  const threadShell = useQuietThreadShell(threadRef);
   // null until the persisted list loads; recording waits on it so the first
   // thread opened after a cold start cannot clobber older entries.
   const [recents, setRecents] = useState<ReadonlyArray<RecentThreadShortcut> | null>(null);

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

@@ -11,7 +11,7 @@ import { AppText as Text } from "../../components/ui/AppText";
 import { SymbolView } from "../../components/ui/AppSymbol";
 import { orchestrationEnvironment } from "../../state/orchestration";
 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
-import { useThreadShell, useThreadShells } from "../../state/entities";
+import { useQuietThreadShell, useThreadShells } from "../../state/entities";
 import { useEnvironmentQuery } from "../../state/query";
 import { ThreadMcpApp } from "./McpAppWebView";
 
@@ -101,7 +101,7 @@ export function McpAppFullscreenScreen({ route }: McpAppFullscreenScreenProps) {
   const derived = item?.type === "dynamic_tool" ? mcpAppFromToolItem(item) : undefined;
   const [app, setApp] = useState(derived);
   if (derived?.attachmentId !== app?.attachmentId) setApp(derived);
-  const conversation = useThreadShell(scopeThreadRef(environmentId, conversationThreadId));
+  const conversation = useQuietThreadShell(scopeThreadRef(environmentId, conversationThreadId));
   const awaitingUser =
     conversation?.hasPendingApprovals === true || conversation?.hasPendingUserInput === true;
   useEffect(() => {

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

@@ -33,7 +33,7 @@ import { mobileHtmlRenderTheme } from "../../lib/htmlRenderTheme";
 import { tryOpenExternalUrl } from "../../lib/openExternalUrl";
 import { uuidv4 } from "../../lib/uuid";
 import { useAssetUrlState } from "../../state/assets";
-import { useThreadShell } from "../../state/entities";
+import { useQuietThreadShell } from "../../state/entities";
 import { mcpAppEnvironment } from "../../state/mcpApps";
 import { orchestrationEnvironment } from "../../state/orchestration";
 import { useEnvironmentQuery } from "../../state/query";
@@ -209,7 +209,7 @@ export function ThreadMcpApp(props: {
   const [toolDefinition, setToolDefinition] = useState<unknown>(undefined);
   // Read by the host on every message, so it always sees current values
   // without being rebuilt (which would drop the app's session).
-  const conversation = useThreadShell(
+  const conversation = useQuietThreadShell(
     scopeThreadRef(props.environmentId, props.conversationThreadId),
   );
   const awaitingUser =

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

@@ -9,7 +9,7 @@ import { AppText as Text } from "../../components/ui/AppText";
 import { SymbolView } from "../../components/ui/AppSymbol";
 import { ProviderIcon } from "../../components/ProviderIcon";
 import { cn } from "../../lib/cn";
-import { useEnvironmentServerConfig, useProject, useThreadShell } from "../../state/entities";
+import { useEnvironmentServerConfig, useProject, useQuietThreadShell } from "../../state/entities";
 import { subagentCardDetail } from "./subagent-card-presentation";
 import { SUBAGENT_TONE_TEXT_CLASS, SubagentStatusDot } from "./SubagentStatusDot";
 import { resolveSubagentRowPresentation } from "./threadAgentsPresentation";
@@ -96,8 +96,8 @@ function SubagentMetadata(props: {
   const provider = config?.providers.find(
     (candidate) => candidate.instanceId === subagent.providerInstanceId,
   );
-  const parent = useThreadShell(scopeThreadRef(environmentId, subagent.threadId))?.source;
-  const child = useThreadShell(
+  const parent = useQuietThreadShell(scopeThreadRef(environmentId, subagent.threadId))?.source;
+  const child = useQuietThreadShell(
     subagent.childThreadId === null ? null : scopeThreadRef(environmentId, subagent.childThreadId),
   )?.source;
   const parentProject = useProject(

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

@@ -1,6 +1,10 @@
 import * as Dialog from "../../components/ui/Dialog";
 import { useAtomValue } from "@effect/atom-react";
-import { useChildThreadInputs, useThreadReportedModelSelection } from "../../state/entities";
+import {
+  useChildThreadInputs,
+  useThreadReportedModelSelection,
+  useThreadShell,
+} from "../../state/entities";
 import { UsageLimitRecoveryCard } from "./UsageLimitRecoveryCard";
 import { useNavigation } from "@react-navigation/native";
 import type { WorktreeSetupCardProps } from "./worktree-setup-card";
@@ -322,6 +326,70 @@ const USER_INPUT_TOGGLE_TIMING = {
   easing: Easing.out(Easing.cubic),
 };
 
+// The visit watermark follows the shell's updatedAt, which ticks while a run
+// streams. Keeping it in a leaf lets the screen read the quiet shell.
+function ThreadVisitWatermark(props: {
+  readonly environmentId: EnvironmentId;
+  readonly selectedThread: EnvironmentThreadShell;
+  readonly showContent: boolean;
+}) {
+  const liveThread = useThreadShell({
+    environmentId: props.environmentId,
+    threadId: props.selectedThread.id,
+  });
+  const thread = liveThread ?? props.selectedThread;
+  const showContent = props.showContent;
+  const selectedThreadKey = scopedThreadKey(props.environmentId, thread.id);
+  const visitThread = useAtomCommand(threadEnvironment.visit, { reportFailure: false });
+  const lastDispatchedVisitRef = useRef<string | null>(null);
+  const lastVisitDispatchRef = useRef({ threadKey: selectedThreadKey, at: 0 });
+  const selectedThreadId = thread.id;
+  const selectedThreadUpdatedAt = thread.updatedAt;
+  const selectedThreadLastVisitedAt = thread.lastVisitedAt;
+  const selectedThreadCompletedAt = thread.latestRun?.completedAt;
+  useEffect(() => {
+    if (!showContent || selectedThreadLastVisitedAt === undefined) return;
+    const threadUpdatedAtMs = Date.parse(selectedThreadUpdatedAt);
+    if (Number.isNaN(threadUpdatedAtMs)) return;
+    const lastVisitedAtMs = selectedThreadLastVisitedAt
+      ? Date.parse(selectedThreadLastVisitedAt)
+      : NaN;
+    if (!Number.isNaN(lastVisitedAtMs) && lastVisitedAtMs >= threadUpdatedAtMs) return;
+    const dispatchKey = `${selectedThreadKey}:${selectedThreadUpdatedAt}`;
+    if (lastDispatchedVisitRef.current === dispatchKey) return;
+    const dispatch = () => {
+      lastDispatchedVisitRef.current = dispatchKey;
+      lastVisitDispatchRef.current = { threadKey: selectedThreadKey, at: Date.now() };
+      void visitThread({
+        environmentId: props.environmentId,
+        input: { threadId: selectedThreadId, visitedAt: selectedThreadUpdatedAt },
+      });
+    };
+    const completedAtMs = selectedThreadCompletedAt ? Date.parse(selectedThreadCompletedAt) : NaN;
+    const hasUnseenCompletion =
+      !Number.isNaN(completedAtMs) &&
+      (Number.isNaN(lastVisitedAtMs) || completedAtMs > lastVisitedAtMs);
+    const previous = lastVisitDispatchRef.current;
+    const elapsed = Date.now() - previous.at;
+    if (previous.threadKey !== selectedThreadKey || hasUnseenCompletion || elapsed >= 10_000) {
+      dispatch();
+      return;
+    }
+    const timer = setTimeout(dispatch, 10_000 - elapsed);
+    return () => clearTimeout(timer);
+  }, [
+    props.environmentId,
+    selectedThreadId,
+    selectedThreadKey,
+    selectedThreadLastVisitedAt,
+    selectedThreadCompletedAt,
+    selectedThreadUpdatedAt,
+    showContent,
+    visitThread,
+  ]);
+  return null;
+}
+
 export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: ThreadDetailScreenProps) {
   const usesNativeWorkspaceColumns = useNativeWorkspaceColumnsSupported();
   const navigation = useNavigation();
@@ -812,54 +880,6 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
     setComposerFocused(false);
   }, [selectedThreadKey, showContent]);
 
-  const visitThread = useAtomCommand(threadEnvironment.visit, { reportFailure: false });
-  const lastDispatchedVisitRef = useRef<string | null>(null);
-  const lastVisitDispatchRef = useRef({ threadKey: selectedThreadKey, at: 0 });
-  const selectedThreadId = props.selectedThread.id;
-  const selectedThreadUpdatedAt = props.selectedThread.updatedAt;
-  const selectedThreadLastVisitedAt = props.selectedThread.lastVisitedAt;
-  const selectedThreadCompletedAt = props.selectedThread.latestRun?.completedAt;
-  useEffect(() => {
-    if (!showContent || selectedThreadLastVisitedAt === undefined) return;
-    const threadUpdatedAtMs = Date.parse(selectedThreadUpdatedAt);
-    if (Number.isNaN(threadUpdatedAtMs)) return;
-    const lastVisitedAtMs = selectedThreadLastVisitedAt
-      ? Date.parse(selectedThreadLastVisitedAt)
-      : NaN;
-    if (!Number.isNaN(lastVisitedAtMs) && lastVisitedAtMs >= threadUpdatedAtMs) return;
-    const dispatchKey = `${selectedThreadKey}:${selectedThreadUpdatedAt}`;
-    if (lastDispatchedVisitRef.current === dispatchKey) return;
-    const dispatch = () => {
-      lastDispatchedVisitRef.current = dispatchKey;
-      lastVisitDispatchRef.current = { threadKey: selectedThreadKey, at: Date.now() };
-      void visitThread({
-        environmentId: props.environmentId,
-        input: { threadId: selectedThreadId, visitedAt: selectedThreadUpdatedAt },
-      });
-    };
-    const completedAtMs = selectedThreadCompletedAt ? Date.parse(selectedThreadCompletedAt) : NaN;
-    const hasUnseenCompletion =
-      !Number.isNaN(completedAtMs) &&
-      (Number.isNaN(lastVisitedAtMs) || completedAtMs > lastVisitedAtMs);
-    const previous = lastVisitDispatchRef.current;
-    const elapsed = Date.now() - previous.at;
-    if (previous.threadKey !== selectedThreadKey || hasUnseenCompletion || elapsed >= 10_000) {
-      dispatch();
-      return;
-    }
-    const timer = setTimeout(dispatch, 10_000 - elapsed);
-    return () => clearTimeout(timer);
-  }, [
-    props.environmentId,
-    selectedThreadId,
-    selectedThreadKey,
-    selectedThreadLastVisitedAt,
-    selectedThreadCompletedAt,
-    selectedThreadUpdatedAt,
-    showContent,
-    visitThread,
-  ]);
-
   useEffect(() => {
     setAnchorMessageId(null);
     setSubmittedMessageId(null);
@@ -1043,6 +1063,11 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread
   return (
     <View className="flex-1">
       {!usesNativeWorkspaceColumns ? <NativeLayoutObserver onChange={setScreenMetrics} /> : null}
+      <ThreadVisitWatermark
+        environmentId={props.environmentId}
+        selectedThread={props.selectedThread}
+        showContent={showContent}
+      />
       {showContent ? (
         <View
           style={{ flex: 1 }}

apps/mobile/src/native/useOpenPullRequest.ts

@@ -5,7 +5,7 @@ import { Platform } from "react-native";
 import { CommonActions } from "@react-navigation/native";
 import { androidWorkspaceNavigationState } from "../lib/android-workspace-navigation";
 import { EnvironmentId, ThreadId } from "@t3tools/contracts";
-import { useThreadShell } from "../state/entities";
+import { useQuietThreadShell } from "../state/entities";
 import { tryOpenExternalUrl } from "../lib/openExternalUrl";
 
 export function useOpenPullRequest(options?: {
@@ -27,7 +27,7 @@ export function useOpenPullRequest(options?: {
   };
   const environmentId = options?.context?.environmentId ?? first(routeContext?.environmentId);
   const threadId = first(routeContext?.threadId);
-  const thread = useThreadShell(
+  const thread = useQuietThreadShell(
     environmentId && threadId
       ? { environmentId: EnvironmentId.make(environmentId), threadId: ThreadId.make(threadId) }
       : null,

apps/mobile/src/state/entities.ts

@@ -18,6 +18,7 @@ import { hasThreadLinks, relabelThreadLinks } from "@t3tools/shared/threadLinks"
 import { Atom } from "effect/reactivity";
 import { useMemo } from "react";
 
+import { environmentPresentations } from "./presentation";
 import { environmentProjects } from "./projects";
 import { environmentServerConfigsAtom, serverEnvironment } from "./server";
 import { environmentThreadDetails, environmentThreadShells } from "./threads";
@@ -99,6 +100,13 @@ export function useThreadShell(ref: ScopedThreadRef | null): EnvironmentThreadSh
   );
 }
 
+/** The shell without its streaming timestamps; see quietThreadShellAtom. */
+export function useQuietThreadShell(ref: ScopedThreadRef | null): EnvironmentThreadShell | null {
+  return useAtomValue(
+    ref === null ? EMPTY_THREAD_SHELL_ATOM : environmentThreadShells.quietThreadShellAtom(ref),
+  );
+}
+
 export function useChildThreadInputs(ref: ScopedThreadRef) {
   return useAtomValue(environmentThreadShells.childThreadInputsAtom(ref));
 }
@@ -126,7 +134,13 @@ export function useEnvironmentServerConfig(
   );
 }
 
-export function useServerConfigs(): ReadonlyMap<EnvironmentId, ServerConfig> {
+/** Providers are left out; read them with `useServerConfigsWithProviders()`. */
+export function useServerConfigs() {
+  return useAtomValue(environmentPresentations.serverConfigsAtom);
+}
+
+/** Rebuilds on every provider status push; only for readers of `providers`. */
+export function useServerConfigsWithProviders(): ReadonlyMap<EnvironmentId, ServerConfig> {
   return useAtomValue(environmentServerConfigsAtom);
 }
 

apps/mobile/src/state/use-thread-outbox-drain.permissions.test.ts

@@ -60,7 +60,7 @@ vi.mock("./session", () => ({
 vi.mock("./entities", () => ({
   useProjects: () => [],
   useThreadShells: () => [state.thread],
-  useServerConfigs: () => new Map([["secondary", state.config]]),
+  useServerConfigsWithProviders: () => new Map([["secondary", state.config]]),
 }));
 vi.mock("./server", async () => {
   const { Atom } = await import("effect/reactivity");

apps/mobile/src/state/use-thread-outbox-drain.test.ts

@@ -79,7 +79,7 @@ vi.mock("../lib/attachmentUpload", () => ({
 
 vi.mock("./entities", () => ({
   useProjects: () => [],
-  useServerConfigs: () => new Map(),
+  useServerConfigsWithProviders: () => new Map(),
   useThreadShells: () => [],
 }));
 

apps/mobile/src/state/use-thread-outbox-drain.ts

@@ -36,7 +36,7 @@ import {
 } from "./acknowledged-thread-messages";
 import { appAtomRegistry } from "./atom-registry";
 import { restoredNewTaskDraftKey } from "./new-task-draft-key";
-import { useProjects, useServerConfigs, useThreadShells } from "./entities";
+import { useProjects, useServerConfigsWithProviders, useThreadShells } from "./entities";
 import {
   clearPendingThreadCreationOutcome,
   pendingThreadCreationOutcomesAtom,
@@ -602,7 +602,7 @@ export function useThreadOutboxDrain(): void {
   const threads = useThreadShells();
   const creationOutcomes = useAtomValue(pendingThreadCreationOutcomesAtom);
   const projects = useProjects();
-  const serverConfigs = useServerConfigs();
+  const serverConfigs = useServerConfigsWithProviders();
   const { connectedEnvironments } = useRemoteConnectionStatus();
   const operableEnvironments = useEnvironmentsWithScope(
     connectedEnvironments,

apps/mobile/src/state/use-thread-outbox.ts

@@ -13,7 +13,7 @@ const threadOutboxShellStatusesAtom = Atom.make(
     for (const queue of Object.values(get(threadOutboxManager.queuedMessagesByThreadKeyAtom))) {
       const environmentId = queue[0]?.environmentId;
       if (environmentId !== undefined && !statuses.has(environmentId)) {
-        statuses.set(environmentId, get(environmentShell.stateValueAtom(environmentId)).status);
+        statuses.set(environmentId, get(environmentShell.statusAtom(environmentId)));
       }
     }
     return statuses;