fix: reconcile main's round-18 features after the rebase

Adopts the round's main features into the v2 architecture: the #9023 media rework (streamed videos, media-file assets, protocol-relative links), #9098 shared live-activity row folded into the v2 working and thinking rows, the #9084/#9078 Claude model catalog for v2 consumers, a native #9005 OpenCode child-session abort in the v2 adapter, #9013's landed LegendList patch, and per-environment sidebar provider entries. For #8600 the server-side pieces land, but auto-settle evaluation stays client-side (reading the new server-owned settings) until the v2 orchestrator grows its own settlement reactor; main's v1-only reactor and coalescer additions are dropped with the rest of the v1 path.

Julius Marminge committed 2 months ago

Commit 7b13bca1 parent 786a25847 files · +1855 −2616Browse files

Showing the changes to apps/mobile/src (5 of 47 files). Show all

Unified · Split

5 files

apps/mobile/src/features/threads/ThreadDetailScreen.tsx +1 −1
apps/mobile/src/features/threads/ThreadFeed.tsx +196 −89
apps/mobile/src/features/threads/thread-list-v2-items.tsx +26 −3
apps/mobile/src/features/threads/threadListV2.test.ts +3 −1
apps/mobile/src/features/threads/threadListV2.ts +70 −8

apps/mobile/src/features/threads/ThreadDetailScreen.tsx+1−1

@@ -681,7 +681,7 @@ export const ThreadDetailScreen = memo(function ThreadDetailScreen(props: Thread · 680 unmodified lines
681	onTouchCancel={handleFeedTouchCancel}	681	onTouchCancel={handleFeedTouchCancel}
682	>	682	>
683	<ThreadFeed	683	<ThreadFeed
684	key={props.selectedThread.id}	684	key={selectedThreadKey}
685	environmentId={props.environmentId}	685	environmentId={props.environmentId}
686	threadId={props.selectedThread.id}	686	threadId={props.selectedThread.id}
687	workspaceRoot={props.threadCwd}	687	workspaceRoot={props.threadCwd}

apps/mobile/src/features/threads/ThreadFeed.tsx+196−89

 import * as Haptics from "expo-haptics";
 import { KeyboardAwareLegendList } from "@legendapp/list/keyboard";
-import { type LegendListRef } from "@legendapp/list/react-native";
+import { useViewabilityAmount, type LegendListRef } from "@legendapp/list/react-native";
 import { scopeThreadRef } from "@t3tools/client-runtime/environment";
 import { canForkProjectedAssistantItem } from "@t3tools/client-runtime/state/thread-workflows";
 import {
 import Animated, {
   FadeIn,
   FadeInUp,
-  FadeOut,
   LinearTransition,
   type SharedValue,
 } from "react-native-reanimated";
   type ThreadFeedLiveFollowEvent,
 } from "./thread-feed-live-follow";
 import {
+  ThreadDisclosureChevron,
   THREAD_DISCLOSURE_TRANSITION_MS,
   ThreadWorkGroupToggle,
   ThreadWorkLog,
 } from "./thread-work-log";
 import { resolveThreadFeedFixedItemSize } from "./thread-feed-item-size";
 import { useMarkdownCodeHighlight } from "./markdownCodeHighlightState";
-import { assetEnvironment, useAssetUrl, useAssetUrlState } from "../../state/assets";
+import {
+  assetEnvironment,
+  useAssetUrl,
+  useAssetUrlState,
+  useRefreshAssetUrl,
+} from "../../state/assets";
 import { useAtomQueryRunner } from "../../state/use-atom-query-runner";
 import { usePreparedConnection } from "../../state/session";
 import * as Option from "effect/Option";
 }
 const THREAD_FEED_LAYOUT_TRANSITION = LinearTransition.duration(THREAD_DISCLOSURE_TRANSITION_MS);
-const THREAD_FEED_DISCLOSURE_ENTER_TRANSITION = FadeIn.duration(140);
+// Let neighboring rows move out of the new rows' space before showing their text.
-const THREAD_FEED_DISCLOSURE_EXIT_TRANSITION = FadeOut.duration(120);
+const THREAD_FEED_DISCLOSURE_ENTER_TRANSITION = FadeIn.delay(
-const EMPTY_DISCLOSURE_ENTRY_IDS: ReadonlySet<string> = new Set();
+  THREAD_DISCLOSURE_TRANSITION_MS,
+).duration(140);
 // Entering animations must only play for rows born just now — LegendList
 // remounts rows when they scroll back into view, and replaying an entrance for
 }) {
   const sourceIdentifier = useId();
   const createAssetUrl = useAtomQueryRunner(assetEnvironment.createUrl, {
+    refresh: true,
     reportFailure: false,
   });
   const preparedConnection = usePreparedConnection(props.environmentId);
   readonly sourceKey: string;
   readonly unavailable: boolean;
   readonly alt: string | null;
+  readonly actionsSource?: MediaActionsSource;
   readonly onPressPreview: (source: FilePreviewSource) => void;
 }) {
   const sourceIdentifier = useId();
+  const mediaActions = useMediaActions(props.actionsSource);
   const [availableWidth, setAvailableWidth] = useState(0);
   const [sourceSize, setSourceSize] = useState<{ width: number; height: number } | null>(null);
   const [failedUri, setFailedUri] = useState<string | null>(null);
           ) : (
             <ActivityIndicator />
           )}
+          {props.actionsSource ? (
+            <View className="absolute right-1 top-1">
+              <MediaActionsMenu media={mediaActions} />
+            </View>
+          ) : null}
         </View>
       ) : (
         <PresentationSource identifier={sourceIdentifier} style={{ alignSelf: "flex-start" }}>
-          <Pressable
+          <View>
-            accessibilityRole="imagebutton"
+            <MediaActionsMenu media={mediaActions}>
-            accessibilityLabel={props.alt ?? "Markdown image"}
+              <Pressable
-            onPress={() =>
+                accessibilityRole="imagebutton"
-              props.onPressPreview({
+                accessibilityLabel={props.alt ?? "Markdown image"}
-                kind: "image",
+                onPress={() =>
-                uri: props.uri!,
+                  props.onPressPreview({
-                name: props.alt ?? "Image",
+                    kind: "image",
-                sourceIdentifier,
+                    uri: props.uri!,
-              })
+                    name: props.alt ?? "Image",
-            }
+                    sourceIdentifier,
-            style={{ alignSelf: "flex-start" }}
+                    actionsSource: props.actionsSource,
-          >
+                  })
-            <View
+                }
-              className="items-center justify-center overflow-hidden rounded-[10px] bg-md-code-bg"
+                style={{ alignSelf: "flex-start" }}
-              style={{
+              >
-                ...frameStyle,
+                <View
-              }}
+                  className="items-center justify-center overflow-hidden rounded-[10px] bg-md-code-bg"
-            >
+                  style={{
-              <ThreadMarkdownImageRequest
+                    ...frameStyle,
-                key={props.uri}
+                  }}
-                uri={props.uri}
+                >
-                onLoad={setSourceSize}
+                  <ThreadMarkdownImageRequest
-                onError={() => setFailedUri(props.uri)}
+                    key={props.uri}
-              />
+                    uri={props.uri}
-            </View>
+                    onLoad={setSourceSize}
-          </Pressable>
+                    onError={() => setFailedUri(props.uri)}
+                  />
+                </View>
+              </Pressable>
+            </MediaActionsMenu>
+            {props.actionsSource ? (
+              <View className="absolute right-1 top-1">
+                <MediaActionsMenu media={mediaActions} />
+              </View>
+            ) : null}
+          </View>
         </PresentationSource>
       )}
       {props.alt ? (
 /** Environment-hosted image that loads through a signed asset URL. */
 function ThreadMarkdownImage(props: {
   readonly environmentId: EnvironmentId;
-  readonly resource: Extract<AssetResource, { readonly _tag: "attachment" | "workspace-file" }>;
+  readonly resource: Extract<AssetResource, { readonly _tag: "attachment" | "media-file" }>;
   readonly alt: string | null;
   readonly srcFragment?: string;
+  readonly actionsSource?: MediaActionsSource;
   readonly onPressPreview: (source: FilePreviewSource) => void;
 }) {
   const assetUrl = useAssetUrlState(props.environmentId, props.resource);
       }
       unavailable={assetUrl._tag === "Failure"}
       alt={props.alt}
+      actionsSource={props.actionsSource}
       onPressPreview={props.onPressPreview}
     />
   );
 }
+const ThreadMediaVisibleContext = createContext(false);
+// LegendList only computes hook visibility when the list has a viewability config.
+const THREAD_MEDIA_VIEWABILITY_CONFIG = { itemVisiblePercentThreshold: 0 };
+function ThreadMediaVisibility(props: { readonly children: ReactNode }) {
+  const [visible, setVisible] = useState(false);
+  useViewabilityAmount<ThreadFeedEntry>(
+    useCallback((token) => setVisible(token.sizeVisible > 0), []),
+  );
+  return <ThreadMediaVisibleContext value={visible}>{props.children}</ThreadMediaVisibleContext>;
+}
+function ThreadMarkdownVideo(props: {
+  readonly source: MediaVideoPreviewSource;
+  readonly onExpand: (source: MediaVideoPreviewSource) => void;
+}) {
+  const { source } = props;
+  const visible = useContext(ThreadMediaVisibleContext);
+  const thumbnailKey = mediaVideoThumbnailKey(source);
+  const asset = useAssetUrlState(
+    "environmentId" in source ? source.environmentId : null,
+    "resource" in source ? source.resource : null,
+  );
+  const refreshAssetUrl = useRefreshAssetUrl(
+    "environmentId" in source ? source.environmentId : null,
+    "resource" in source ? source.resource : null,
+  );
+  const uri = mediaVideoPreviewUri(source, asset._tag === "Success" ? asset.url : null);
+  return (
+    <MediaVideoPlayer
+      key={thumbnailKey}
+      uri={uri}
+      resolvePlaybackUri={
+        "resource" in source
+          ? async () => mediaVideoPreviewUri(source, await refreshAssetUrl())
+          : undefined
+      }
+      name={source.name}
+      thumbnailKey={thumbnailKey}
+      thumbnailVisible={visible}
+      unavailable={"resource" in source && asset._tag === "Failure"}
+      actionsSource={source.actionsSource}
+      onExpand={() => props.onExpand(source)}
+    />
+  );
+}
 function ThreadMarkdownImageUnavailable(props: { readonly alt: string | null }) {
   return (
     <ThreadMarkdownImageView
               title: node.title ?? null,
             }) ?? undefined)
           : undefined,
-      code_inline: ({ content }) => {
+      code_inline: ({ content }) => (
-        const value = content ?? "";
+        <MarkdownInlineCode
-        return (
+          content={content ?? ""}
-          <NativeText
+          textColor={inlineTextColor}
-            className="font-mono"
+          codeColor={inlineCodeTextColor}
-            style={{
+          fontSize={markdownFontSizes.codeBlockFontSize}
-              color: inlineCodeTextColor,
+          lineHeight={markdownFontSizes.bodyLineHeight}
-              fontSize: markdownFontSizes.codeBlockFontSize,
+          onLinkPress={onLinkPress}
-              lineHeight: markdownFontSizes.bodyLineHeight,
+        />
-            }}
+      ),
-          >
-            {value}
-          </NativeText>
-        );
-      },
       ...(preserveSoftBreaks
         ? {
             soft_break: () => <NativeText>{"\n"}</NativeText>,
         accessibilityState={{ expanded: entry.expanded }}
         onPress={() => props.onToggleTurnFold(entry.runId)}
         hitSlop={4}
-        className="mb-3 min-h-11 flex-row items-center gap-2 border-b border-adaptive-neutral-200-a80-white-a8 px-2"
+        className="mb-1 min-h-11 flex-row items-center gap-2 border-b border-adaptive-neutral-200-a80-white-a8 px-2"
       >
         <Text
           key={props.workRowSizing.textSizeKey}
           expanded={entry.expanded}
           collapsedDirection="right"
           size={15}
-          tintColorClassName={"accent-icon-subtle"}
+          tintColor={iconSubtleColor}
-          type="monochrome"
         />
       </Pressable>
     );
   const [endFollowEnabled, setEndFollowEnabled] = useState(true);
   const endFollowEnabledRef = useRef(true);
   // A "user scroll session" spans from drag start through the end of its
-  // momentum; only motion inside a session can break follow, so MVCP
+  // momentum; scroll events only break follow inside that session, so MVCP
   // compensations and programmatic scrolls never strand a follower.
   const userScrollSessionRef = useRef(false);
   const setEndFollow = useCallback(
   );
   const renderMarkdownImage = useCallback<MarkdownImageRenderer>(
     (image) => {
+      const media = resolveMarkdownMediaPreview(image.href, {
+        environmentId: props.environmentId,
+        threadId: props.threadId,
+        workspaceRoot: props.workspaceRoot,
+        imageEmbed: true,
+      });
+      if (media?.kind === "video") {
+        return (
+          <ThreadMarkdownVideo
+            key={image.href}
+            source={{ ...media.source, name: image.alt ?? media.source.name }}
+            onExpand={(source) => setExpandedVideo((current) => current ?? source)}
+          />
+        );
+      }
       const imageSource = classifyMarkdownImageSource(image.href, props.workspaceRoot ?? null);
       if (imageSource._tag === "Direct") {
         return (
           <ThreadMarkdownImageView
-            uri={imageSource.uri}
+            uri={normalizeNativeMarkdownUrl(imageSource.uri)}
             sourceKey={imageSource.uri}
             unavailable={false}
             alt={image.alt}
+            actionsSource={media?.source.actionsSource}
             onPressPreview={(source) => setExpandedFile((current) => current ?? source)}
           />
         );
         <ThreadMarkdownImage
           environmentId={props.environmentId}
           resource={{
-            _tag: "workspace-file",
+            _tag: "media-file",
             threadId: props.threadId,
             path: imageSource.path,
           }}
           alt={image.alt}
           srcFragment={markdownImageSourceFragment(image.href)}
+          actionsSource={media?.source.actionsSource}
           onPressPreview={(source) => setExpandedFile((current) => current ?? source)}
         />
       );
         threadId: props.threadId,
         workspaceRoot: props.workspaceRoot,
       });
+      const media = viewedImage
+        ? resolveMarkdownMediaPreview(image.href, {
+            environmentId: props.environmentId,
+            threadId: props.threadId,
+            workspaceRoot: props.workspaceRoot,
+            imageEmbed: true,
+          })
+        : null;
+      const actionsSource = media?.source.actionsSource;
       return viewedImage ? (
         <ThreadMarkdownImage
           environmentId={props.environmentId}
           resource={viewedImage.resource}
           alt={viewedImage.alt}
           srcFragment={viewedImage.srcFragment}
+          actionsSource={
+            actionsSource && "resource" in actionsSource
+              ? { ...actionsSource, resource: viewedImage.resource }
+              : undefined
+          }
           onPressPreview={(source) => setExpandedFile((current) => current ?? source)}
         />
       ) : null;
     }
     disclosureSettleFrameRef.current = requestAnimationFrame(() => {
       disclosureSettleSecondFrameRef.current = requestAnimationFrame(() => {
+        // A disclosure can leave the reader above the end without a drag.
+        // Reconcile follow before a later layout or resume can re-pin it.
+        const listState = props.listRef.current?.getState();
+        if (listState) {
+          transitionEndFollow({
+            type: "disclosure-settled",
+            isAtEnd: listState.isAtEnd,
+            userScrollSessionActive: userScrollSessionRef.current,
+          });
+        }
         disclosureAnchorKeyRef.current = null;
         setDisclosureToggleSettling(false);
         disclosureSettleFrameRef.current = null;
         disclosureSettleSecondFrameRef.current = null;
       });
     });
-  }, []);
+  }, [props.listRef, transitionEndFollow]);
   const suspendEndScrollMaintenanceForDisclosure = useCallback((anchorKey: string | null) => {
     disclosureAnchorKeyRef.current = anchorKey;
     (info: { item: ThreadFeedEntry; index: number }) => (
       <Animated.View
         key={info.item.id}
-        entering={
+        entering={disclosureToggleSettling ? THREAD_FEED_DISCLOSURE_ENTER_TRANSITION : undefined}
-          disclosureEnteringEntryIds.has(info.item.id)
-            ? THREAD_FEED_DISCLOSURE_ENTER_TRANSITION
-            : undefined
-        }
-        exiting={THREAD_FEED_DISCLOSURE_EXIT_TRANSITION}
       >
-        {renderFeedEntry(info, {
+        <ThreadMediaVisibility>
-          environmentId: props.environmentId,
+          {renderFeedEntry(info, {
-          threadId: props.threadId,
+            environmentId: props.environmentId,
-          copiedRowId,
+            threadId: props.threadId,
-          expandedWorkRows,
+            copiedRowId,
-          terminalAssistantMessageIds,
+            expandedWorkRows,
-          unsettledTurnId,
+            terminalAssistantMessageIds,
-          onCopyWorkRow,
+            unsettledTurnId,
-          onToggleWorkGroup,
+            onCopyWorkRow,
-          onToggleWorkRow,
+            onToggleWorkGroup,
-          onToggleTurnFold,
+            onToggleWorkRow,
-          onPressPreview,
+            onToggleTurnFold,
-          onPressVideo,
+            onPressPreview,
-          onMarkdownLinkPress,
+            onPressVideo,
-          renderMarkdownImage,
+            onMarkdownLinkPress,
-          renderViewedImage,
+            renderMarkdownImage,
-          iconSubtleColor,
+            renderViewedImage,
-          userBubbleColor,
+            iconSubtleColor,
-          markdownStyles,
+            userBubbleColor,
-          reviewCommentColors,
+            markdownStyles,
-          reviewCommentBubbleWidth,
+            reviewCommentColors,
-          userBubbleMaxWidth,
+            reviewCommentBubbleWidth,
-          threadTitle: props.threadTitle,
+            userBubbleMaxWidth,
-          skills: props.skills,
+            threadTitle: props.threadTitle,
-          workspaceRoot: props.workspaceRoot,
+            skills: props.skills,
-        })}
+            workspaceRoot: props.workspaceRoot,
+          })}
+        </ThreadMediaVisibility>
       </Animated.View>
     ),
     [
       copiedRowId,
-      disclosureEnteringEntryIds,
+      disclosureToggleSettling,
       expandedWorkRows,
       workRowSizing,
       workGroupScrollPositions,
             data={presentedFeed}
             extraData={listAppearanceData}
             renderItem={renderItem}
+            viewabilityConfig={THREAD_MEDIA_VIEWABILITY_CONFIG}
             keyExtractor={(entry) => entry.id}
             getItemType={(entry) =>
               entry.type === "message" ? `message:${entry.message.role}` : entry.type
       <FilePreviewModal source={expandedFile} onRequestClose={() => setExpandedFile(null)} />
     </>
   );
+  const EMPTY_DISCLOSURE_ENTRY_IDS: ReadonlySet<string> = new Set();
 });

apps/mobile/src/features/threads/thread-list-v2-items.tsx+26−3

 import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider";
 import { buildThreadTitleRegenerationMenuItems } from "./thread-title-regeneration-menu";
 import {
-  resolveThreadListV2SnoozeMenuSelection,
+  resolveThreadListV2ChangeRequestState,
   resolveThreadListV2SnoozeGateExpiryMs,
+  resolveThreadListV2SnoozeMenuSelection,
   resolveThreadListV2Status,
   resolveThreadListV2SwipeActions,
+  threadHasUnseenCompletion,
+  type ThreadListV2ChangeRequestState,
   type ThreadListV2Status,
 } from "./threadListV2";
 import { ThreadSearchMatchExcerpt } from "./thread-search-match";
   readonly canMovePinnedDown?: boolean;
   readonly onSwipeableWillOpen: (methods: SwipeableMethods) => void;
   readonly onSwipeableClose: (methods: SwipeableMethods) => void;
+  /** Reports this row's live PR (state + last activity) for the partition's
+      merge and close rules. Mirrors web's onChangeRequestState. */
+  readonly onChangeRequestState?: (
+    threadKey: string,
+    changeRequest: ThreadListV2ChangeRequestState | null,
+  ) => void;
   readonly projectCwd?: string | null;
   readonly searchMatch?: EnvironmentThreadSearchMatch;
   readonly searchQuery?: string;
     onPinThread,
     onUnpinThread,
     onMovePinnedThread,
+    onChangeRequestState,
   } = props;
   const snoozedRow = props.snoozed === true;
   const pinnedRow = props.pinned === true;
   const pr = useThreadPr(thread, props.projectCwd ?? props.project?.workspaceRoot ?? null);
+  const prState = pr?.state ?? null;
+  const prUpdatedAt = pr?.updatedAt ?? null;
+  const threadKey = `${thread.environmentId}:${thread.id}`;
+  useEffect(() => {
+    const changeRequest = resolveThreadListV2ChangeRequestState({
+      linkedPullRequest: thread.linkedPullRequest,
+      state: prState,
+      updatedAt: prUpdatedAt,
+    });
+    if (changeRequest === undefined) return;
+    onChangeRequestState?.(threadKey, changeRequest);
+  }, [onChangeRequestState, prState, prUpdatedAt, thread.linkedPullRequest, threadKey]);
   const theme = useUniwindTheme();
   const screenColor = theme["--color-screen"];
   );
   const handleArchive = useCallback(() => onArchiveThread(thread), [onArchiveThread, thread]);
-  // Swipe: the v2 primary action is the lifecycle transition. Un-settling a
+  // Swipe: the v2 primary action is the lifecycle transition. Every settled
-  // settled row keeps it active until new activity clears the user override.
+  // row can un-settle — explicit settles clear the override, auto-settled
+  // rows get pinned active until real activity clears the pin.
   const canUnsettle = variant === "slim";
   const [snoozeGateTick, bumpSnoozeGateTick] = useState(0);
   const snoozeGateExpiryMs = props.snoozeSupported

apps/mobile/src/features/threads/threadListV2.test.ts+3−1

       ],
       environmentId: null,
       searchQuery: "",
-      now: "2026-06-02T00:01:07.500Z",
+      // Minute-floored partition clock vs precise snooze clock.
+      now: "2026-06-02T00:01:00.000Z",
+      snoozeNow: "2026-06-02T00:01:07.500Z",
     });
     expect(layout.items.map((item) => item.thread.id)).toEqual(["just-woke"]);

apps/mobile/src/features/threads/threadListV2.ts+70−8

 import {
+  effectiveSettled,
   effectiveSnoozed,
   hasQueuedTurnStart,
   QUEUED_TURN_START_GRACE_MS,
   resolveSnoozePresets,
   snoozeWakeLabel,
 } from "@t3tools/client-runtime/state/thread-settled";
-import type { SnoozePreset } from "@t3tools/client-runtime/state/thread-settled";
+import type {
+  ChangeRequestSettleSource,
+  SnoozePreset,
+} from "@t3tools/client-runtime/state/thread-settled";
 import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
 import { threadSearchMatchKey } from "@t3tools/client-runtime/state/thread-search";
 import {
   resolveSettledThreadTimestamp,
   sortPinnedThreadsByOrderKey,
 } from "@t3tools/client-runtime/state/thread-sort";
-import type { EnvironmentId, ProjectId } from "@t3tools/contracts";
+import type { EnvironmentId, ProjectId, ThreadLinkedPullRequest } from "@t3tools/contracts";
 import type { PendingNewTask } from "../../state/use-pending-new-tasks";
 export type ThreadListV2Status = "approval" | "input" | "working" | "waiting" | "failed" | "ready";
 export type ThreadListV2SwipeAction = "archive" | "settle" | "unsettle" | "snooze" | "unsnooze";
+export interface ThreadListV2ChangeRequestState extends ChangeRequestSettleSource {
+  readonly linkedPullRequestKey?: string | null;
+}
+function linkedPullRequestKey(
+  linkedPullRequest: ThreadLinkedPullRequest | null | undefined,
+): string | null {
+  if (linkedPullRequest == null) return null;
+  return JSON.stringify([
+    linkedPullRequest.projectId,
+    linkedPullRequest.repository.toLowerCase(),
+    linkedPullRequest.number,
+  ]);
+}
+/** Keep the previous linked PR state while its detail query reloads. */
+export function resolveThreadListV2ChangeRequestState(input: {
+  readonly linkedPullRequest: ThreadLinkedPullRequest | null | undefined;
+  readonly state: ChangeRequestSettleSource["state"] | null;
+  readonly updatedAt: string | null;
+}): ThreadListV2ChangeRequestState | null | undefined {
+  if (input.state === null) return input.linkedPullRequest == null ? null : undefined;
+  return {
+    state: input.state,
+    updatedAt: input.updatedAt,
+    linkedPullRequestKey: linkedPullRequestKey(input.linkedPullRequest),
+  };
+}
 export function resolveThreadListV2SnoozeMenuSelection(input: {
   readonly event: string;
   readonly displayedPresets: ReadonlyArray<SnoozePreset>;
 /**
  * Partitions visible threads into the active card block (creation order) and
- * the settled recency tail, matching the web v2 list.
+ * the settled recency tail, matching the web v2 list. Mobile stores these
+ * auto-settle preferences per device.
  */
 export function buildThreadListV2Items(input: {
   readonly threads: ReadonlyArray<EnvironmentThreadShell>;
   }> | null;
   readonly searchQuery: string;
   readonly matchedThreadKeys?: ReadonlySet<string>;
+  /** Per-row PR reported up by visible rows ("env:threadId" keys). */
+  readonly changeRequestByKey?: ReadonlyMap<string, ThreadListV2ChangeRequestState>;
   /** Environments whose server supports thread.settle/unsettle. Threads on
       other environments never classify as settled — the user could neither
       un-settle nor pin them. Absent = no gating (tests). */
   /** Environments whose server supports thread.snooze/unsnooze. Same
       contract as settlementEnvironmentIds. */
   readonly snoozeEnvironmentIds?: ReadonlySet<EnvironmentId>;
+  readonly autoSettleAfterDays?: number;
+  readonly autoSettleOnMerge?: boolean;
   /** Max settled rows to render; the rest are counted, not built. */
   readonly settledLimit?: number;
-  /** Second-precise clock used for time-based classification. */
+  /** Injectable for tests; defaults to now. */
-  readonly now: string;
+  readonly now?: string;
+  /** Second-precise clock for snooze classification. Callers pass a
+      minute-quantized `now` for memoization; snooze wake times are
+      second-precise, so classifying with the floored minute would hold a
+      woken thread hidden for up to a minute. Defaults to `now`. */
+  readonly snoozeNow?: string;
   /** Expands the snoozed shelf into rows. Collapsed is the default. */
   readonly snoozedShelfExpanded?: boolean;
   /** Expands the settled shelf into rows. Expanded is the default. */
       a split-view detail can never lose its navigation row. */
   readonly selectedThreadKey?: string | null;
 }): ThreadListV2Layout {
-  const now = input.now;
+  const now = input.now ?? new Date().toISOString();
+  const snoozeNow = input.snoozeNow ?? now;
+  const autoSettleAfterDays = input.autoSettleAfterDays ?? 3;
+  const autoSettleOnMerge = input.autoSettleOnMerge ?? true;
   const query = input.searchQuery.trim().toLocaleLowerCase();
   const projectKeys = input.projectRefs
     ? new Set(input.projectRefs.map((ref) => `${ref.environmentId}:${ref.projectId}`))
     }
     const supportsSettlement = input.settlementEnvironmentIds?.has(thread.environmentId) ?? true;
     const supportsSnooze = input.snoozeEnvironmentIds?.has(thread.environmentId) ?? true;
+    const cachedChangeRequest =
+      input.changeRequestByKey?.get(`${thread.environmentId}:${thread.id}`) ?? null;
+    const changeRequest =
+      cachedChangeRequest !== null &&
+      (cachedChangeRequest.linkedPullRequestKey ?? null) ===
+        linkedPullRequestKey(thread.linkedPullRequest)
+        ? cachedChangeRequest
+        : null;
     // Snooze outranks settlement and pinning until the thread wakes.
-    if (supportsSnooze && effectiveSnoozed(thread, { now })) {
+    if (supportsSnooze && effectiveSnoozed(thread, { now: snoozeNow })) {
       snoozed.push(thread);
       if (
         thread.snoozedUntil != null &&
       }
       continue;
     }
-    if (supportsSettlement && thread.settledOverride === "settled") {
+    if (
+      supportsSettlement &&
+      effectiveSettled(thread, {
+        now,
+        autoSettleAfterDays,
+        autoSettleOnMerge,
+        changeRequest,
+      })
+    ) {
       settled.push(thread);
     } else if (thread.pinnedAt != null) {
       pinned.push(thread);