diff --git a/apps/mobile/src/features/settings/ScheduledTaskPickerScreens.tsx b/apps/mobile/src/features/settings/ScheduledTaskPickerScreens.tsx
index 1ea4602da9241..ce6f07dbf6833 100644
--- a/apps/mobile/src/features/settings/ScheduledTaskPickerScreens.tsx
+++ b/apps/mobile/src/features/settings/ScheduledTaskPickerScreens.tsx
@@ -1,7 +1,7 @@
 import { NativeScrollView } from "../../native/NativeScrollViewMarker";
 import { LegendList } from "@legendapp/list/react-native";
 import { useNavigation } from "@react-navigation/native";
-import { isListedThreadLineage } from "@t3tools/contracts";
+import { scheduledTaskDestinationRows } from "@t3tools/client-runtime/scheduled-task-destination";
 import * as Haptics from "expo-haptics";
 import { useMemo, useState } from "react";
 import { Platform } from "react-native";
@@ -21,12 +21,7 @@ import { useDebouncedValue, usePaginatedBranches, useThreadSearch } from "../../
 import { BranchPickerScreen } from "../threads/NewTaskContextPickerScreens";
 import { ThreadSettingsPickerScreen } from "../threads/ThreadSettingsSheet";
 import { SettingsScreen } from "./components/SettingsScreen";
-import {
-  NEW_THREAD_DESTINATION_LABEL,
-  useScheduledTaskDestinationLabel,
-  useScheduledTaskEditor,
-} from "./scheduled-task-editor";
-import { moveDraftToThread, unbindDraftFromThread } from "./scheduledTaskDraft";
+import { useScheduledTaskDestinationLabel, useScheduledTaskEditor } from "./scheduled-task-editor";
 
 function MissingTaskDraft() {
   return (
@@ -213,38 +208,20 @@ export function ScheduledTaskThreadPickerRouteScreen() {
 
   if (!editor) return <MissingTaskDraft />;
 
-  const needle = query.trim().toLocaleLowerCase();
-  const rows = [
-    ...(needle ? [] : [{ key: "new-thread", title: NEW_THREAD_DESTINATION_LABEL, thread: null }]),
-    ...(threadId !== null && currentLabel.toLocaleLowerCase().includes(needle)
-      ? [{ key: threadId, title: currentLabel, thread: null }]
-      : []),
-    ...shells
-      .filter(
-        (thread) =>
-          thread.environmentId === environmentId &&
-          thread.projectId === projectId &&
-          thread.id !== threadId &&
-          thread.archivedAt === null &&
-          isListedThreadLineage(thread.lineage) &&
-          thread.title.toLocaleLowerCase().includes(needle),
-      )
-      .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
-      .map((thread) => ({
-        key: thread.id,
-        title: thread.title.trim() || "Untitled thread",
-        thread,
-      })),
-  ];
-  const selectedKey = threadId ?? (editor.draft.threadMode === "new_thread" ? "new-thread" : null);
+  const rows = scheduledTaskDestinationRows(shells, {
+    environmentId,
+    projectId,
+    current: threadId === null ? null : { id: threadId, title: currentLabel },
+    query,
+  });
 
   return (
     <SettingsScreen title="Destination" search={search}>
       <LegendList
         renderScrollComponent={NativeScrollView}
         data={rows}
-        keyExtractor={(row) => row.key}
-        extraData={selectedKey}
+        keyExtractor={(row) => row.id}
+        extraData={threadId}
         estimatedItemSize={56}
         recycleItems
         className="flex-1"
@@ -266,20 +243,15 @@ export function ScheduledTaskThreadPickerRouteScreen() {
         renderItem={({ item, index }) => (
           <SelectionRow
             title={item.title}
-            selected={item.key === selectedKey}
+            selected={item.id === threadId}
             isFirst={index === 0}
             isLast={index === rows.length - 1}
             onPress={() => {
               void Haptics.selectionAsync();
-              if (item.key !== selectedKey) {
+              if (item.id !== threadId) {
                 setEditor((current) =>
                   current
-                    ? {
-                        ...current,
-                        draft: item.thread
-                          ? moveDraftToThread(current.draft, item.thread)
-                          : { ...unbindDraftFromThread(current.draft), threadMode: "new_thread" },
-                      }
+                    ? { ...current, draft: { ...current.draft, threadId: item.id } }
                     : current,
                 );
               }
diff --git a/apps/mobile/src/features/settings/SettingsScheduledTasksRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsScheduledTasksRouteScreen.tsx
index 3f552c1f0c46c..837771bfb9cd9 100644
--- a/apps/mobile/src/features/settings/SettingsScheduledTasksRouteScreen.tsx
+++ b/apps/mobile/src/features/settings/SettingsScheduledTasksRouteScreen.tsx
@@ -908,53 +908,58 @@ function TaskForm({
           />
         </SettingsSection>
 
-        <SettingsSection
-          title="Destination"
-          footer={
-            draft.threadMode === "new_thread"
-              ? "Each run starts a new thread."
-              : `${
-                  draft.threadMode === "continue"
-                    ? "Runs continue one conversation."
-                    : "Runs share one thread, each in a fresh session without earlier runs' context."
-                }${
-                  draft.threadId === null ? " The first run starts the thread." : ""
-                } Deleting it also deletes this task.`
-          }
-        >
-          {offersThreadModes ? (
-            <SelectRow
-              label="Runs go to"
-              value={THREAD_MODE_LABELS[draft.threadMode]}
-              actions={(Object.keys(THREAD_MODE_LABELS) as ScheduledTaskThreadMode[]).map(
-                (mode) => ({
-                  id: mode,
-                  title: THREAD_MODE_LABELS[mode],
-                  state: draft.threadMode === mode ? "on" : undefined,
-                }),
-              )}
-              onSelect={(id) => {
-                if (id === "new_thread")
-                  setDraft({ ...unbindDraftFromThread(draft), threadMode: id });
-                else if (id === "continue" || id === "fresh_session")
-                  setDraft({ ...draft, threadMode: id });
-              }}
-            />
-          ) : null}
-          {!offersThreadModes || draft.threadMode !== "new_thread" ? (
-            <PickerRow
-              label="Thread"
-              borderTop={offersThreadModes}
-              value={
-                draft.threadId === null && draft.threadMode !== "new_thread"
-                  ? "Started by the first run"
-                  : destinationLabel
-              }
-              onPress={() => navigation.navigate("SettingsScheduledTaskThread")}
-              disabled={!draft.projectId || saving || dictationPending || environmentUnavailable}
-            />
-          ) : null}
-        </SettingsSection>
+        {offersThreadModes || draft.threadMode !== "new_thread" ? (
+          <SettingsSection
+            title="Destination"
+            footer={
+              draft.threadMode === "new_thread"
+                ? "Each run starts a new thread."
+                : `${
+                    draft.threadMode === "continue"
+                      ? "Runs continue one conversation."
+                      : "Runs share one thread, each in a fresh session without earlier runs' context."
+                  }${
+                    draft.threadId === null ? " The first run starts the thread." : ""
+                  } Deleting it also deletes this task.`
+            }
+          >
+            {offersThreadModes ? (
+              <SelectRow
+                label="Runs go to"
+                value={THREAD_MODE_LABELS[draft.threadMode]}
+                actions={(Object.keys(THREAD_MODE_LABELS) as ScheduledTaskThreadMode[]).map(
+                  (mode) => ({
+                    id: mode,
+                    title: THREAD_MODE_LABELS[mode],
+                    state: draft.threadMode === mode ? "on" : undefined,
+                  }),
+                )}
+                onSelect={(id) => {
+                  if (id === "new_thread")
+                    setDraft({ ...unbindDraftFromThread(draft), threadMode: id });
+                  else if (id === "continue" || id === "fresh_session")
+                    setDraft({ ...draft, threadMode: id });
+                }}
+              />
+            ) : null}
+            {draft.threadMode !== "new_thread" ? (
+              <PickerRow
+                label="Thread"
+                borderTop={offersThreadModes}
+                value={destinationLabel}
+                onPress={() => navigation.navigate("SettingsScheduledTaskThread")}
+                // Without thread modes there is no way back to a new thread each run, so stay read-only.
+                disabled={
+                  !offersThreadModes ||
+                  !draft.projectId ||
+                  saving ||
+                  dictationPending ||
+                  environmentUnavailable
+                }
+              />
+            ) : null}
+          </SettingsSection>
+        ) : null}
 
         <SettingsSection title="Workspace">
           <SelectRow
diff --git a/apps/mobile/src/features/settings/scheduled-task-editor.tsx b/apps/mobile/src/features/settings/scheduled-task-editor.tsx
index e99600ae533b8..c2872abbfe8d9 100644
--- a/apps/mobile/src/features/settings/scheduled-task-editor.tsx
+++ b/apps/mobile/src/features/settings/scheduled-task-editor.tsx
@@ -19,8 +19,6 @@ import {
   type ScheduledTaskEditor,
 } from "./scheduled-task-editor-state";
 
-export const NEW_THREAD_DESTINATION_LABEL = "New thread each run";
-
 export function useScheduledTaskDestinationLabel(
   environmentId: EnvironmentId | null,
   threadId: ThreadId | null,
@@ -35,7 +33,7 @@ export function useScheduledTaskDestinationLabel(
       : null,
   );
   const thread = shell ?? family.data?.threads.find((row) => row.id === threadId);
-  if (ref === null) return NEW_THREAD_DESTINATION_LABEL;
+  if (ref === null) return "Started by the first run";
   return thread?.title.trim() || `Thread ${ref.threadId}`;
 }
 
diff --git a/apps/mobile/src/features/settings/scheduledTaskDraft.ts b/apps/mobile/src/features/settings/scheduledTaskDraft.ts
index 1ede30d84072b..0b124179a3f07 100644
--- a/apps/mobile/src/features/settings/scheduledTaskDraft.ts
+++ b/apps/mobile/src/features/settings/scheduledTaskDraft.ts
@@ -254,18 +254,6 @@ export function hasScheduledTaskDraftChanges(
   return draftSignature(initial) !== draftSignature(current);
 }
 
-export function moveDraftToThread(
-  draft: ScheduledTaskDraft,
-  thread: { readonly id: ThreadId; readonly projectId: ProjectId },
-): ScheduledTaskDraft {
-  return {
-    ...draft,
-    threadId: thread.id,
-    projectId: thread.projectId,
-    threadMode: draft.threadMode === "new_thread" ? "continue" : draft.threadMode,
-  };
-}
-
 /** Leaves the thread but keeps the mode. Matches MCP: new threads stay out of the shared checkout. */
 export function unbindDraftFromThread(draft: ScheduledTaskDraft): ScheduledTaskDraft {
   if (draft.threadId === null) return draft;
@@ -278,11 +266,16 @@ export function unbindDraftFromThread(draft: ScheduledTaskDraft): ScheduledTaskD
   };
 }
 
+/** Back in the task's own project, its saved thread returns; a read-only picker can't offer it. */
 export function changeDraftProject(
   draft: ScheduledTaskDraft,
   projectId: ProjectId,
 ): ScheduledTaskDraft {
   if (projectId === draft.projectId) return draft;
+  const saved = draft.task;
+  if (saved?.threadId && projectId === saved.projectId && draft.threadMode !== "new_thread") {
+    return { ...draft, projectId, threadId: saved.threadId };
+  }
   return { ...unbindDraftFromThread(draft), projectId };
 }
 
diff --git a/apps/web/src/components/settings/ScheduledTasksSettings.tsx b/apps/web/src/components/settings/ScheduledTasksSettings.tsx
index fd4f7702d68ab..112524e0ae6f3 100644
--- a/apps/web/src/components/settings/ScheduledTasksSettings.tsx
+++ b/apps/web/src/components/settings/ScheduledTasksSettings.tsx
@@ -93,12 +93,11 @@ import { useSettingsScope } from "./SettingsScopeContext";
 import { EnvironmentRow, useEnvironmentTransportLabel } from "./EnvironmentRow";
 import { SettingsGroup } from "./SettingsGroup";
 import { settingsScopeEnvironmentLabel, settingsScopeEnvironmentLabels } from "./settingsScopeAxis";
+import { scheduledTaskDestinationRows } from "@t3tools/client-runtime/scheduled-task-destination";
 import {
   WEBHOOK_SIGNATURE_DEFAULTS,
   changeDraftProject,
-  moveDraftToThread,
   scheduleDraftErrors,
-  scheduledTaskDestinationThreads,
   toDateTimeLocalValue,
   webhookDeliveryLabel,
   defaultScheduledTaskProjectId,
@@ -156,9 +155,6 @@ import {
 const WEEKDAY_ORDER = [1, 2, 3, 4, 5, 6, 0] as const;
 const WEEKDAY_SHORT = ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"] as const;
 
-// Thread ids are trimmed, so the leading space keeps this from matching one.
-const NEW_THREAD_DESTINATION = " new-thread";
-
 const WORKSPACE_MODE_LABELS: Record<WorkspaceMode, string> = {
   worktree: "Create a new worktree",
   root: "Use the project checkout",
@@ -1195,7 +1191,7 @@ function ScheduledTaskDestination({
   readonly threadId: ThreadId | null;
   readonly threadMode: ScheduledTaskThreadMode;
   readonly disabled: boolean;
-  readonly onSelect: (thread: { id: ThreadId; projectId: ProjectId } | null) => void;
+  readonly onSelect: (threadId: ThreadId) => void;
   /** Absent on servers that predate thread modes. */
   readonly onThreadModeChange: ((mode: ScheduledTaskThreadMode) => void) | undefined;
 }) {
@@ -1209,29 +1205,20 @@ function ScheduledTaskDestination({
   );
   const thread = shell ?? family.data?.threads.find((row) => row.id === threadId);
   const currentLabel =
-    ref !== null
-      ? thread?.title.trim() || `Thread ${ref.threadId}`
-      : threadMode === "new_thread"
-        ? "New thread each run"
-        : "Started by the first run";
+    ref !== null ? thread?.title.trim() || `Thread ${ref.threadId}` : "Started by the first run";
   const shells = useVisibleThreadShells(open);
   // Mounts older settled threads matching the query, which shells may leave out.
   useThreadSearch(open && projectId ? [environmentId] : [], query, {
     titlesOnly: true,
     projectIds: [projectId as ProjectId],
   });
-  const threads = scheduledTaskDestinationThreads(shells, {
+  const rows = scheduledTaskDestinationRows(shells, {
     environmentId,
     projectId,
-    currentThreadId: threadId,
+    current: threadId === null ? null : { id: threadId, title: currentLabel },
     query,
   });
-  const search = query.trim().toLocaleLowerCase();
-  const items: ReadonlyArray<string> = [
-    ...(search ? [] : [NEW_THREAD_DESTINATION]),
-    ...(threadId !== null && currentLabel.toLocaleLowerCase().includes(search) ? [threadId] : []),
-    ...threads.map((row) => row.id),
-  ];
+  const items = rows.map((row) => row.id);
   const handleOpenChange = (next: boolean) => {
     setOpen(next);
     if (!next) setQuery("");
@@ -1265,7 +1252,7 @@ function ScheduledTaskDestination({
           </SelectPopup>
         </Select>
       ) : null}
-      {!onThreadModeChange || threadMode !== "new_thread" ? (
+      {threadMode !== "new_thread" ? (
         <Combobox
           items={items}
           filteredItems={items}
@@ -1273,15 +1260,9 @@ function ScheduledTaskDestination({
           autoHighlight
           open={open && !disabled}
           onOpenChange={handleOpenChange}
-          value={threadId ?? (threadMode === "new_thread" ? NEW_THREAD_DESTINATION : null)}
+          value={threadId}
           onValueChange={(value) => {
-            if (value === NEW_THREAD_DESTINATION) {
-              onSelect(null);
-              handleOpenChange(false);
-              return;
-            }
-            const picked = threads.find((row) => row.id === value);
-            if (picked) onSelect(picked);
+            if (value !== null && value !== threadId) onSelect(value);
             handleOpenChange(false);
           }}
         >
@@ -1309,15 +1290,9 @@ function ScheduledTaskDestination({
             />
             <ComboboxEmpty>No threads found.</ComboboxEmpty>
             <ComboboxList className="max-h-72">
-              {items.map((value, index) => (
-                <ComboboxItem key={value} index={index} value={value}>
-                  <span className="block truncate">
-                    {value === NEW_THREAD_DESTINATION
-                      ? "New thread each run"
-                      : value === threadId
-                        ? currentLabel
-                        : threads.find((row) => row.id === value)?.title || "Untitled thread"}
-                  </span>
+              {rows.map((row, index) => (
+                <ComboboxItem key={row.id} index={index} value={row.id}>
+                  <span className="block truncate">{row.title}</span>
                 </ComboboxItem>
               ))}
             </ComboboxList>
@@ -1649,14 +1624,9 @@ function ScheduledTaskEditorForm({
             projectId={selectedProjectId}
             threadId={draft.threadId ? (draft.threadId as ThreadId) : null}
             threadMode={draft.threadMode}
-            disabled={saving || !connected}
-            onSelect={(thread) =>
-              setDraft((current) =>
-                thread === null
-                  ? { ...unbindDraftFromThread(current), threadMode: "new_thread" }
-                  : moveDraftToThread(current, thread),
-              )
-            }
+            // Without thread modes there is no way back to a new thread each run, so stay read-only.
+            disabled={saving || !connected || !offersThreadModes}
+            onSelect={(threadId) => setDraft((current) => ({ ...current, threadId }))}
             onThreadModeChange={
               offersThreadModes
                 ? (threadMode) =>
@@ -1673,7 +1643,7 @@ function ScheduledTaskEditorForm({
               <Select
                 value={selectedProjectId}
                 onValueChange={(projectId) =>
-                  setDraft((current) => changeDraftProject(current, projectId ?? ""))
+                  setDraft((current) => changeDraftProject(current, projectId ?? "", task))
                 }
               >
                 <SelectTrigger size="sm" id="scheduled-task-project">
diff --git a/apps/web/src/components/settings/scheduledTasksSettings.logic.test.ts b/apps/web/src/components/settings/scheduledTasksSettings.logic.test.ts
index a4918c3d2e123..c72c0779fee59 100644
--- a/apps/web/src/components/settings/scheduledTasksSettings.logic.test.ts
+++ b/apps/web/src/components/settings/scheduledTasksSettings.logic.test.ts
@@ -18,6 +18,7 @@ import { resolveSettingsScope, type SettingsScopeSearch } from "./settingsScope"
 
 import { deriveProviderInstanceEntries } from "../../providerInstances";
 import {
+  changeDraftProject,
   scheduledTaskDefaultModel,
   defaultScheduledTaskProjectId,
   matchesScheduledTaskScope,
@@ -196,6 +197,17 @@ describe("scheduled task destination", () => {
       startFromOrigin: true,
     });
   });
+
+  it("restores the saved thread when the project changes back", () => {
+    const task = {
+      ...legacyTask,
+      threadId: ThreadId.make("thread:bound"),
+      threadMode: "continue" as const,
+    };
+    const moved = changeDraftProject(taskToDraft(task), "project:other", task);
+    expect(moved.threadId).toBe("");
+    expect(changeDraftProject(moved, task.projectId, task).threadId).toBe("thread:bound");
+  });
 });
 
 describe("one-time scheduled tasks", () => {
diff --git a/apps/web/src/components/settings/scheduledTasksSettings.logic.ts b/apps/web/src/components/settings/scheduledTasksSettings.logic.ts
index 1095db83469ba..e376254f44857 100644
--- a/apps/web/src/components/settings/scheduledTasksSettings.logic.ts
+++ b/apps/web/src/components/settings/scheduledTasksSettings.logic.ts
@@ -1,4 +1,4 @@
-import { isListedThreadLineage, isWebhookDedupeTemplate } from "@t3tools/contracts";
+import { isWebhookDedupeTemplate } from "@t3tools/contracts";
 import {
   EnvironmentId,
   MAX_WEBHOOK_DELIVERY_AGE_MINUTES,
@@ -13,9 +13,7 @@ import {
   type RuntimeMode,
   type ProviderInteractionMode,
   type ServerSettings,
-  type ThreadId,
 } from "@t3tools/contracts";
-import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/models";
 import {
   parseMaxDeliveryAge,
   parseWebhookFilterDrafts,
@@ -332,18 +330,6 @@ export function taskToDraft(task: ScheduledTask): DraftState {
   };
 }
 
-export function moveDraftToThread(
-  draft: DraftState,
-  thread: { readonly id: ThreadId; readonly projectId: ProjectId },
-): DraftState {
-  return {
-    ...draft,
-    threadId: thread.id,
-    projectId: thread.projectId,
-    threadMode: draft.threadMode === "new_thread" ? "continue" : draft.threadMode,
-  };
-}
-
 /** Leaves the thread but keeps the mode. Matches MCP: new threads stay out of the shared checkout. */
 export function unbindDraftFromThread(draft: DraftState): DraftState {
   if (!draft.threadId) return draft;
@@ -356,35 +342,19 @@ export function unbindDraftFromThread(draft: DraftState): DraftState {
   };
 }
 
-export function changeDraftProject(draft: DraftState, projectId: string): DraftState {
+/** Back in the task's own project, its saved thread returns; a read-only picker can't offer it. */
+export function changeDraftProject(
+  draft: DraftState,
+  projectId: string,
+  saved: Pick<ScheduledTask, "projectId" | "threadId"> | null,
+): DraftState {
   if (projectId === draft.projectId) return draft;
+  if (saved?.threadId && projectId === saved.projectId && draft.threadMode !== "new_thread") {
+    return { ...draft, projectId, threadId: saved.threadId };
+  }
   return { ...unbindDraftFromThread(draft), projectId };
 }
 
-/** Threads a task can move to. The current one is left out; the picker always shows it. */
-export function scheduledTaskDestinationThreads(
-  threads: ReadonlyArray<EnvironmentThreadShell>,
-  target: {
-    readonly environmentId: EnvironmentId;
-    readonly projectId: string;
-    readonly currentThreadId: ThreadId | null;
-    readonly query: string;
-  },
-): ReadonlyArray<EnvironmentThreadShell> {
-  const search = target.query.trim().toLocaleLowerCase();
-  return threads
-    .filter(
-      (thread) =>
-        thread.environmentId === target.environmentId &&
-        thread.projectId === target.projectId &&
-        thread.id !== target.currentThreadId &&
-        thread.archivedAt === null &&
-        isListedThreadLineage(thread.lineage) &&
-        thread.title.toLocaleLowerCase().includes(search),
-    )
-    .toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-}
-
 export function scheduledTaskDefaultModel(
   settings: ServerSettings,
   project: (LegacyProjectSettingsFields & { readonly id: ProjectId }) | null,
diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.json
index d1e74151e53e3..ff95ab55fd295 100644
--- a/packages/client-runtime/package.json
+++ b/packages/client-runtime/package.json
@@ -83,6 +83,10 @@
       "types": "./src/linkRequest.ts",
       "default": "./src/linkRequest.ts"
     },
+    "./scheduled-task-destination": {
+      "types": "./src/scheduledTaskDestination.ts",
+      "default": "./src/scheduledTaskDestination.ts"
+    },
     "./scheduled-task-webhook": {
       "types": "./src/scheduledTaskWebhook.ts",
       "default": "./src/scheduledTaskWebhook.ts"
diff --git a/packages/client-runtime/src/scheduledTaskDestination.ts b/packages/client-runtime/src/scheduledTaskDestination.ts
new file mode 100644
index 0000000000000..db054dc736498
--- /dev/null
+++ b/packages/client-runtime/src/scheduledTaskDestination.ts
@@ -0,0 +1,31 @@
+import { isListedThreadLineage, type EnvironmentId, type ThreadId } from "@t3tools/contracts";
+
+import type { EnvironmentThreadShell } from "./state/models.ts";
+
+/** Picker rows for a task's destination: the current thread first, then the rest newest first. */
+export function scheduledTaskDestinationRows(
+  threads: ReadonlyArray<EnvironmentThreadShell>,
+  target: {
+    readonly environmentId: EnvironmentId | null;
+    readonly projectId: string | null;
+    readonly current: { readonly id: ThreadId; readonly title: string } | null;
+    readonly query: string;
+  },
+): ReadonlyArray<{ readonly id: ThreadId; readonly title: string }> {
+  const search = target.query.trim().toLocaleLowerCase();
+  const others = threads
+    .filter(
+      (thread) =>
+        thread.environmentId === target.environmentId &&
+        thread.projectId === target.projectId &&
+        thread.id !== target.current?.id &&
+        thread.archivedAt === null &&
+        isListedThreadLineage(thread.lineage) &&
+        thread.title.toLocaleLowerCase().includes(search),
+    )
+    .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt))
+    .map((thread) => ({ id: thread.id, title: thread.title.trim() || "Untitled thread" }));
+  return target.current !== null && target.current.title.toLocaleLowerCase().includes(search)
+    ? [target.current, ...others]
+    : others;
+}