From ed97a41c0c8ac710086ac0d29eee05ffe158bb95 Mon Sep 17 00:00:00 2001
From: Yash Singh <saiansh2525@gmail.com>
Date: Tue, 6 Oct 2026 15:26:28 -0500
Subject: [PATCH 01/21] feat(web): find messages and plans in the current
 thread

---
 .../t3-markdown-text/src/markdownLinks.ts     |   6 +-
 .../src/nativeMarkdownText.ts                 |   2 +-
 .../features/threads/ThreadDetailScreen.tsx   |   2 +-
 .../src/features/threads/ThreadFeed.tsx       |   6 +-
 .../src/features/threads/fileChipMenu.ts      |   2 +-
 .../features/threads/thread-search-match.tsx  |  43 +-
 apps/server/src/auth/RpcAuthorization.ts      |   1 +
 .../src/observability/RpcInstrumentation.ts   |   1 +
 .../src/orchestration-v2/Orchestrator.ts      |  17 +
 .../src/orchestration-v2/ProjectionStore.ts   |  25 +
 .../ProviderTurnControlService.test.ts        |   1 +
 .../src/orchestration-v2/ThreadFind.test.ts   | 388 ++++++++++++++++
 .../server/src/orchestration-v2/ThreadFind.ts | 253 +++++++++++
 .../ThreadManagementService.ts                |  11 +
 .../src/relay/AgentAwarenessRelay.test.ts     |   1 +
 apps/server/src/ws.ts                         |   6 +
 apps/web/package.json                         |   3 -
 apps/web/src/components/ChatMarkdown.test.tsx |  61 +++
 apps/web/src/components/ChatMarkdown.tsx      | 410 ++---------------
 .../web/src/components/ChatView.logic.test.ts |   2 +-
 apps/web/src/components/ChatView.logic.ts     |   2 +-
 apps/web/src/components/ChatView.tsx          |  43 +-
 apps/web/src/components/CommandPalette.tsx    |  15 +
 apps/web/src/components/GitActionsControl.tsx |   2 +-
 .../src/components/ThreadTerminalDrawer.tsx   |   3 +-
 apps/web/src/components/chat/ChatComposer.tsx |   2 +-
 apps/web/src/components/chat/ChatHeader.tsx   |   6 +-
 .../components/chat/MessagesTimeline.logic.ts |   2 +-
 .../src/components/chat/MessagesTimeline.tsx  | 427 +++++++++++++-----
 .../src/components/chat/ProposedPlanCard.tsx  |  21 +-
 .../web/src/components/chat/ThreadFindBar.tsx | 115 +++++
 .../components/chat/markdownFindContext.ts    |   4 +
 .../src/components/chat/threadFind.test.ts    | 251 ++++++++++
 apps/web/src/components/chat/threadFind.ts    |  85 ++++
 .../components/chat/threadFindActionBus.ts    |  10 +
 .../components/chat/threadFindHighlights.ts   | 139 ++++++
 .../components/chat/useThreadFind.test.tsx    | 176 ++++++++
 apps/web/src/components/chat/useThreadFind.ts | 179 ++++++++
 .../chat/useThreadFindHistory.test.tsx        | 104 +++++
 .../components/chat/useThreadFindHistory.ts   |  42 ++
 .../src/components/files/FileBreadcrumbs.tsx  |   2 +-
 .../components/files/FileMarkdownPreview.tsx  |   2 +-
 .../src/components/files/FilePreviewPanel.tsx |   3 +-
 apps/web/src/components/files/filePath.ts     |   4 +-
 .../src/components/files/filePreviewMode.ts   |   3 +-
 .../components/settings/ThemeEditorPanel.tsx  |  18 +
 apps/web/src/components/ui/input-group.tsx    |   9 +-
 apps/web/src/diffFileActions.ts               |   2 +-
 apps/web/src/fileContextMenu.ts               |   2 +-
 apps/web/src/filePathDisplay.ts               |   7 +-
 apps/web/src/index.css                        |  14 +
 apps/web/src/keybindings.test.ts              |   8 +
 apps/web/src/markdown-incremental.test.tsx    |  11 +-
 apps/web/src/markdown-links.test.ts           | 260 -----------
 apps/web/src/markdown-links.ts                |  53 +--
 ...test.tsx => markdownGithubAlerts.test.tsx} |   2 +-
 ...t.tsx => markdownListIndentation.test.tsx} |   2 +-
 apps/web/src/openVsxThemes.test.ts            |  24 +-
 apps/web/src/openVsxThemes.ts                 |   4 +
 apps/web/src/proposedPlan.test.ts             |  26 --
 apps/web/src/proposedPlan.ts                  |  21 +-
 apps/web/src/terminal-links.test.ts           |   2 +-
 apps/web/src/terminal-links.ts                |  63 ---
 apps/web/src/themePalette.test.ts             |  69 +++
 apps/web/src/themePalette.ts                  |  24 +
 apps/web/src/vscodeThemeImport.test.ts        |  94 ++++
 apps/web/src/vscodeThemeImport.ts             |  22 +
 docs/user/keybindings.md                      |   8 +
 packages/client-runtime/package.json          |  24 +-
 packages/client-runtime/src/markdownImages.ts |   7 +-
 packages/client-runtime/src/mediaReference.ts |   2 +-
 packages/client-runtime/src/mediaSource.ts    |   8 +-
 .../client-runtime/src/state/orchestration.ts |   6 +
 .../src/state/subagentDisplay.ts              |   2 +-
 packages/contracts/src/keybindings.test.ts    |   6 +
 packages/contracts/src/keybindings.ts         |   1 +
 packages/contracts/src/orchestrationV2.ts     |  36 ++
 packages/contracts/src/rpc.ts                 |  12 +
 packages/contracts/src/server.ts              |   1 +
 packages/shared/package.json                  |  55 +++
 .../src/codexArtifactTemplates.test.ts        |   2 +-
 .../src/codexArtifactTemplates.ts             |   0
 .../src/codexFileCitations.test.ts            |   2 +-
 .../src/codexFileCitations.ts                 |   0
 .../src/codexMarkdownDirectives.test.ts       |   4 +-
 .../src/codexMarkdownDirectives.ts            |   0
 packages/shared/src/composerContextLegacy.ts  |   6 +-
 packages/shared/src/fileLinks.test.ts         |  65 +++
 packages/shared/src/fileLinks.ts              | 183 ++++++++
 packages/shared/src/keybindings.ts            |   1 +
 .../shared/src/markdownGithubAlerts.ts        |   0
 .../src/markdownLinks.test.ts                 | 128 +++++-
 .../src/markdownLinks.ts                      | 146 +++---
 .../shared/src/markdownListIndentation.ts     |   0
 packages/shared/src/markdownPipeline.ts       | 232 ++++++++++
 packages/shared/src/path.test.ts              |  39 ++
 packages/shared/src/path.ts                   |  37 ++
 packages/shared/src/proposedPlanText.test.ts  |  26 ++
 packages/shared/src/proposedPlanText.ts       |  20 +
 packages/shared/src/themePalettes.ts          |  52 +++
 packages/shared/src/threadFindText.test.ts    | 114 +++++
 packages/shared/src/threadFindText.ts         | 175 +++++++
 packages/shared/src/threadSearch.test.ts      |  23 +
 packages/shared/src/threadSearch.ts           |  70 +++
 pnpm-lock.yaml                                |  60 +--
 105 files changed, 4016 insertions(+), 1157 deletions(-)
 create mode 100644 apps/server/src/orchestration-v2/ThreadFind.test.ts
 create mode 100644 apps/server/src/orchestration-v2/ThreadFind.ts
 create mode 100644 apps/web/src/components/chat/ThreadFindBar.tsx
 create mode 100644 apps/web/src/components/chat/markdownFindContext.ts
 create mode 100644 apps/web/src/components/chat/threadFind.test.ts
 create mode 100644 apps/web/src/components/chat/threadFind.ts
 create mode 100644 apps/web/src/components/chat/threadFindActionBus.ts
 create mode 100644 apps/web/src/components/chat/threadFindHighlights.ts
 create mode 100644 apps/web/src/components/chat/useThreadFind.test.tsx
 create mode 100644 apps/web/src/components/chat/useThreadFind.ts
 create mode 100644 apps/web/src/components/chat/useThreadFindHistory.test.tsx
 create mode 100644 apps/web/src/components/chat/useThreadFindHistory.ts
 rename apps/web/src/{markdown-github-alerts.test.tsx => markdownGithubAlerts.test.tsx} (96%)
 rename apps/web/src/{markdown-list-indentation.test.tsx => markdownListIndentation.test.tsx} (96%)
 rename packages/{client-runtime => shared}/src/codexArtifactTemplates.test.ts (99%)
 rename packages/{client-runtime => shared}/src/codexArtifactTemplates.ts (100%)
 rename packages/{client-runtime => shared}/src/codexFileCitations.test.ts (98%)
 rename packages/{client-runtime => shared}/src/codexFileCitations.ts (100%)
 rename packages/{client-runtime => shared}/src/codexMarkdownDirectives.test.ts (98%)
 rename packages/{client-runtime => shared}/src/codexMarkdownDirectives.ts (100%)
 create mode 100644 packages/shared/src/fileLinks.test.ts
 create mode 100644 packages/shared/src/fileLinks.ts
 rename apps/web/src/markdown-github-alerts.ts => packages/shared/src/markdownGithubAlerts.ts (100%)
 rename packages/{client-runtime => shared}/src/markdownLinks.test.ts (66%)
 rename packages/{client-runtime => shared}/src/markdownLinks.ts (71%)
 rename apps/web/src/markdown-list-indentation.ts => packages/shared/src/markdownListIndentation.ts (100%)
 create mode 100644 packages/shared/src/markdownPipeline.ts
 create mode 100644 packages/shared/src/proposedPlanText.test.ts
 create mode 100644 packages/shared/src/proposedPlanText.ts
 create mode 100644 packages/shared/src/threadFindText.test.ts
 create mode 100644 packages/shared/src/threadFindText.ts
 create mode 100644 packages/shared/src/threadSearch.test.ts
 create mode 100644 packages/shared/src/threadSearch.ts

diff --git a/apps/mobile/modules/t3-markdown-text/src/markdownLinks.ts b/apps/mobile/modules/t3-markdown-text/src/markdownLinks.ts
index 8b491c0c77c1..913f7cb37167 100644
--- a/apps/mobile/modules/t3-markdown-text/src/markdownLinks.ts
+++ b/apps/mobile/modules/t3-markdown-text/src/markdownLinks.ts
@@ -1,10 +1,10 @@
+import { fileBasename } from "@t3tools/shared/path";
+import { formatFilePathPosition } from "@t3tools/shared/fileLinks";
 import {
-  fileBasename,
-  formatFilePathPosition,
   inlineCodeFilePathCandidate,
   normalizeMarkdownLinkDestination,
   parseMarkdownFileLink,
-} from "@t3tools/client-runtime/markdown-links";
+} from "@t3tools/shared/markdownLinks";
 import { parseThreadLinkHref } from "@t3tools/shared/threadLinks";
 import { videoMimeType } from "@t3tools/shared/video";
 
diff --git a/apps/mobile/modules/t3-markdown-text/src/nativeMarkdownText.ts b/apps/mobile/modules/t3-markdown-text/src/nativeMarkdownText.ts
index 6ae50075093f..58df022faf1d 100644
--- a/apps/mobile/modules/t3-markdown-text/src/nativeMarkdownText.ts
+++ b/apps/mobile/modules/t3-markdown-text/src/nativeMarkdownText.ts
@@ -1,5 +1,5 @@
 import type { MarkdownNode } from "react-native-nitro-markdown/headless";
-import { isMarkdownFileLinkLabel } from "@t3tools/client-runtime/markdown-links";
+import { isMarkdownFileLinkLabel } from "@t3tools/shared/markdownLinks";
 import { collectComposerInlineTokens } from "@t3tools/shared/composerInlineTokens";
 import { imageMimeType } from "@t3tools/shared/image";
 import { isWindowsAbsolutePath } from "@t3tools/shared/path";
diff --git a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
index ea6353578302..9a2fc45d5e1c 100644
--- a/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
+++ b/apps/mobile/src/features/threads/ThreadDetailScreen.tsx
@@ -29,7 +29,7 @@ import type {
 import {
   appendCodexArtifactTemplateUsePrompt,
   type CodexArtifactTemplate,
-} from "@t3tools/client-runtime/codex-artifact-templates";
+} from "@t3tools/shared/codexArtifactTemplates";
 import type { ThreadUserInputQuestion } from "@t3tools/client-runtime/state/thread-requests";
 import {
   presentPendingBackgroundWork,
diff --git a/apps/mobile/src/features/threads/ThreadFeed.tsx b/apps/mobile/src/features/threads/ThreadFeed.tsx
index 4d81c6f07063..4a91ad7f1000 100644
--- a/apps/mobile/src/features/threads/ThreadFeed.tsx
+++ b/apps/mobile/src/features/threads/ThreadFeed.tsx
@@ -36,9 +36,9 @@ import { writeComposerContextClipboard } from "../../lib/composerContextClipboar
 import {
   codexArtifactTemplatePresentationLabel,
   type CodexArtifactTemplate,
-} from "@t3tools/client-runtime/codex-artifact-templates";
+} from "@t3tools/shared/codexArtifactTemplates";
 import { resolveAssetUrl } from "@t3tools/client-runtime/state/assets";
-import { isMarkdownFileLinkLabel } from "@t3tools/client-runtime/markdown-links";
+import { isMarkdownFileLinkLabel } from "@t3tools/shared/markdownLinks";
 import { getTextContent, type MarkdownNode } from "react-native-nitro-markdown/headless";
 import { formatAttachmentSize } from "@t3tools/client-runtime/state/attachments";
 import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
@@ -50,7 +50,7 @@ import { resolveViewedImageAsset } from "@t3tools/client-runtime/work-log/presen
 import {
   renderCodexFileCitationsAsMarkdown,
   splitCodexArtifactTemplateMarkdown,
-} from "@t3tools/client-runtime/codex-markdown-directives";
+} from "@t3tools/shared/codexMarkdownDirectives";
 import { CHAT_LIST_ANCHOR_OFFSET, resolveChatListAnchoredEndSpace } from "@t3tools/shared/chatList";
 import { imageMimeType } from "@t3tools/shared/image";
 import { videoMimeType } from "@t3tools/shared/video";
diff --git a/apps/mobile/src/features/threads/fileChipMenu.ts b/apps/mobile/src/features/threads/fileChipMenu.ts
index 9f82e089444d..9835c0c37cc1 100644
--- a/apps/mobile/src/features/threads/fileChipMenu.ts
+++ b/apps/mobile/src/features/threads/fileChipMenu.ts
@@ -1,4 +1,4 @@
-import { fileBasename } from "@t3tools/client-runtime/markdown-links";
+import { fileBasename } from "@t3tools/shared/path";
 import type { ThreadId } from "@t3tools/contracts";
 import { resolveMarkdownLinkPresentation } from "@t3tools/mobile-markdown-text/links";
 import type { MarkdownFileContextMenu } from "@t3tools/mobile-markdown-text/types";
diff --git a/apps/mobile/src/features/threads/thread-search-match.tsx b/apps/mobile/src/features/threads/thread-search-match.tsx
index 553160dbdd8c..1f03e2c2adf0 100644
--- a/apps/mobile/src/features/threads/thread-search-match.tsx
+++ b/apps/mobile/src/features/threads/thread-search-match.tsx
@@ -1,48 +1,9 @@
+import { splitThreadSearchText } from "@t3tools/shared/threadSearch";
 import type { EnvironmentThreadSearchMatch } from "@t3tools/client-runtime/state/thread-search";
 
 import { AppText as Text } from "../../components/AppText";
 import { cn } from "../../lib/cn";
 
-function foldAsciiCase(value: string): string {
-  return value.replace(/[A-Z]/g, (character) => character.toLowerCase());
-}
-
-function splitHighlightParts(text: string, query: string) {
-  const normalizedText = foldAsciiCase(text);
-  const normalizedQuery = foldAsciiCase(query.trim());
-  if (normalizedQuery.length === 0) {
-    return [{ text, highlighted: false, start: 0 }];
-  }
-
-  const parts: Array<{
-    readonly text: string;
-    readonly highlighted: boolean;
-    readonly start: number;
-  }> = [];
-  let cursor = 0;
-  while (cursor < text.length) {
-    const matchIndex = normalizedText.indexOf(normalizedQuery, cursor);
-    if (matchIndex === -1) {
-      parts.push({ text: text.slice(cursor), highlighted: false, start: cursor });
-      break;
-    }
-    if (matchIndex > cursor) {
-      parts.push({
-        text: text.slice(cursor, matchIndex),
-        highlighted: false,
-        start: cursor,
-      });
-    }
-    parts.push({
-      text: text.slice(matchIndex, matchIndex + normalizedQuery.length),
-      highlighted: true,
-      start: matchIndex,
-    });
-    cursor = matchIndex + normalizedQuery.length;
-  }
-  return parts;
-}
-
 export function ThreadSearchMatchExcerpt(props: {
   readonly match: EnvironmentThreadSearchMatch;
   readonly query: string;
@@ -51,7 +12,7 @@ export function ThreadSearchMatchExcerpt(props: {
   readonly sidebar?: boolean;
 }) {
   const isUser = props.match.source === "user";
-  const parts = splitHighlightParts(props.match.snippet, props.query);
+  const parts = splitThreadSearchText(props.match.snippet, props.query);
   return (
     <Text
       className={cn(
diff --git a/apps/server/src/auth/RpcAuthorization.ts b/apps/server/src/auth/RpcAuthorization.ts
index ee0d24e44d5a..beeed533f2b9 100644
--- a/apps/server/src/auth/RpcAuthorization.ts
+++ b/apps/server/src/auth/RpcAuthorization.ts
@@ -47,6 +47,7 @@ export const RPC_REQUIRED_SCOPES = {
   [ORCHESTRATION_V2_WS_METHODS.getTurnDiff]: AuthOrchestrationReadScope,
   [ORCHESTRATION_V2_WS_METHODS.getFullThreadDiff]: AuthOrchestrationReadScope,
   [ORCHESTRATION_V2_WS_METHODS.searchThreads]: AuthOrchestrationReadScope,
+  [ORCHESTRATION_V2_WS_METHODS.searchThread]: AuthOrchestrationReadScope,
   [ORCHESTRATION_V2_WS_METHODS.getArchivedShellSnapshot]: AuthOrchestrationReadScope,
   [ORCHESTRATION_V2_WS_METHODS.getThreadProjection]: AuthOrchestrationReadScope,
   [ORCHESTRATION_V2_WS_METHODS.getTurnItem]: AuthOrchestrationReadScope,
diff --git a/apps/server/src/observability/RpcInstrumentation.ts b/apps/server/src/observability/RpcInstrumentation.ts
index f0f51f3d969a..833bd2b7b0e1 100644
--- a/apps/server/src/observability/RpcInstrumentation.ts
+++ b/apps/server/src/observability/RpcInstrumentation.ts
@@ -21,6 +21,7 @@ const RPC_AGGREGATES = {
   [ORCHESTRATION_V2_WS_METHODS.getTurnDiff]: "orchestration",
   [ORCHESTRATION_V2_WS_METHODS.getFullThreadDiff]: "orchestration",
   [ORCHESTRATION_V2_WS_METHODS.searchThreads]: "orchestration",
+  [ORCHESTRATION_V2_WS_METHODS.searchThread]: "orchestration",
   [ORCHESTRATION_V2_WS_METHODS.getArchivedShellSnapshot]: "orchestration",
   [ORCHESTRATION_V2_WS_METHODS.getThreadProjection]: "orchestrationV2",
   [ORCHESTRATION_V2_WS_METHODS.launchThread]: "orchestration",
diff --git a/apps/server/src/orchestration-v2/Orchestrator.ts b/apps/server/src/orchestration-v2/Orchestrator.ts
index 5d4b1cfda15f..7032d930bb10 100644
--- a/apps/server/src/orchestration-v2/Orchestrator.ts
+++ b/apps/server/src/orchestration-v2/Orchestrator.ts
@@ -1,3 +1,7 @@
+import type {
+  OrchestrationV2SearchThreadInput,
+  OrchestrationV2SearchThreadResult,
+} from "@t3tools/contracts";
 import {
   latestExecutedRun,
   latestRootProviderFailure,
@@ -280,6 +284,9 @@ export interface OrchestratorV2Shape {
   readonly dispatch: (
     command: OrchestrationV2ServerCommand,
   ) => Effect.Effect<OrchestratorV2DispatchResult, OrchestratorV2Error>;
+  readonly searchThread: (
+    input: OrchestrationV2SearchThreadInput,
+  ) => Effect.Effect<OrchestrationV2SearchThreadResult, OrchestratorV2Error>;
   readonly getTimelinePage: (
     threadId: ThreadId,
     options: ProjectionTimelinePageOptions,
@@ -10800,6 +10807,14 @@ const makeOrchestrator = Effect.fn("orchestrationV2.Orchestrator.layer")(functio
     recoverDelegatedTask,
     delegatedTaskResultPending,
     dispatch: dispatchWithReceipt,
+    searchThread: (input) =>
+      projectionStore
+        .searchThread(input)
+        .pipe(
+          Effect.mapError(
+            (cause) => new OrchestratorProjectionError({ threadId: input.threadId, cause }),
+          ),
+        ),
     getTimelinePage: (threadId, options) =>
       projectionStore
         .getTimelinePage(threadId, options)
@@ -10935,6 +10950,8 @@ const layerUnavailable: Layer.Layer<OrchestratorV2> = Layer.succeed(
           cause: "Orchestration V2 live runtime is not configured.",
         }),
       ),
+    searchThread: (input) =>
+      Effect.fail(new OrchestratorProjectionError({ threadId: input.threadId })),
     getTimelinePage: (threadId) => Effect.fail(new OrchestratorProjectionError({ threadId })),
     getMessageCount: (threadId) => Effect.fail(new OrchestratorProjectionError({ threadId })),
     getTurnItem: ({ threadId }) => Effect.fail(new OrchestratorProjectionError({ threadId })),
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.ts
index ec75937a9a62..18ae04d536cf 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.ts
@@ -1,3 +1,8 @@
+import { makeThreadFind, findProjectedThreadItems } from "./ThreadFind.ts";
+import type {
+  OrchestrationV2SearchThreadInput,
+  OrchestrationV2SearchThreadResult,
+} from "@t3tools/contracts";
 import {
   latestRootProviderFailure,
   latestUnheldRun,
@@ -308,6 +313,9 @@ export interface ProjectionTimelinePage {
 }
 
 export interface ProjectionStoreV2Shape {
+  readonly searchThread: (
+    input: OrchestrationV2SearchThreadInput,
+  ) => Effect.Effect<OrchestrationV2SearchThreadResult, ProjectionStoreV2Error>;
   readonly getThreadAttachmentIds: (
     threadId: ThreadId,
   ) => Effect.Effect<ReadonlyArray<string>, ProjectionStoreV2Error>;
@@ -4787,6 +4795,10 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
         ),
       );
 
+    const searchThread = yield* makeThreadFind((threadId) =>
+      readTimelineIndex(threadId, new Set()).pipe(Effect.map((index) => index.visible)),
+    );
+
     const getTimelinePage: ProjectionStoreV2Shape["getTimelinePage"] = (threadId, options) =>
       sql
         .withTransaction(
@@ -5701,6 +5713,7 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =
       getThreadSnapshot,
       getThreadSnapshotWindow,
       getTimelinePage,
+      searchThread,
       getThreadAttachmentIds,
     } satisfies ProjectionStoreV2Shape;
   }),
@@ -6257,6 +6270,18 @@ export const layerMemory: Layer.Layer<ProjectionStoreV2> = Layer.effect(
             ),
           ),
         ),
+      searchThread: (input) =>
+        service
+          .getThreadSnapshot(input.threadId)
+          .pipe(
+            Effect.map((snapshot) =>
+              findProjectedThreadItems(
+                snapshot.projection.visibleTurnItems,
+                input,
+                snapshot.snapshotSequence,
+              ),
+            ),
+          ),
       getTimelinePage: (threadId, options) =>
         service.getThreadProjection(threadId).pipe(
           Effect.map((projection) => {
diff --git a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts
index 7918f819eee2..7a670121962b 100644
--- a/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts
+++ b/apps/server/src/orchestration-v2/ProviderTurnControlService.test.ts
@@ -224,6 +224,7 @@ it.effect(
           getPlan: () => Effect.die("unused"),
           hasUnpairedRunInterruptRequest: () => Effect.die("unused interrupt read"),
           getThreadAttachmentIds: () => Effect.die("Unused attachment lookup"),
+          searchThread: () => Effect.die("unused"),
           getTimelinePage: () => Effect.die("Unused timeline read"),
           getMessageCount: () => Effect.die("unused message count"),
           getNextTurnItemOrdinal: () => Effect.die("unused ordinal read"),
diff --git a/apps/server/src/orchestration-v2/ThreadFind.test.ts b/apps/server/src/orchestration-v2/ThreadFind.test.ts
new file mode 100644
index 000000000000..fc2427f7d00d
--- /dev/null
+++ b/apps/server/src/orchestration-v2/ThreadFind.test.ts
@@ -0,0 +1,388 @@
+import { assert, it, describe } from "@effect/vitest";
+import {
+  EventId,
+  MessageId,
+  PlanId,
+  RunId,
+  RuntimeRequestId,
+  TurnItemId,
+  type OrchestrationV2TurnItem,
+  type OrchestrationV2Run,
+  ProjectId,
+  ProviderInstanceId,
+  ThreadId,
+  type OrchestrationV2DomainEvent,
+} from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+
+import * as SqlitePersistence from "../persistence/Sqlite.ts";
+import * as ProjectionStore from "./ProjectionStore.ts";
+import * as ProjectStore from "./ProjectStore.ts";
+import * as EventStore from "./EventStore.ts";
+
+const layerTest = Layer.mergeAll(EventStore.layer, ProjectionStore.layer, ProjectStore.layer).pipe(
+  Layer.provideMerge(SqlitePersistence.layerMemory),
+);
+
+const providerInstanceId = ProviderInstanceId.make("codex");
+const at = (minute: number) => DateTime.makeUnsafe(Date.UTC(2026, 8, 27, 0, minute));
+
+const createProject = (projectId: ProjectId) =>
+  Effect.flatMap(ProjectStore.ProjectStoreV2, (projects) =>
+    projects.apply({
+      sequence: 0,
+      eventId: EventId.make(`created:${projectId}`),
+      aggregateKind: "project",
+      aggregateId: projectId,
+      occurredAt: DateTime.formatIso(at(0)),
+      commandId: null,
+      causationEventId: null,
+      correlationId: null,
+      metadata: {},
+      type: "project.created",
+      payload: {
+        projectId,
+        title: projectId,
+        workspaceRoot: `/work/${projectId}`,
+        defaultModelSelection: null,
+        scripts: [],
+        createdAt: DateTime.formatIso(at(0)),
+        updatedAt: DateTime.formatIso(at(0)),
+      },
+    }),
+  );
+
+const thread = (
+  threadId: ThreadId,
+  projectId: ProjectId,
+  overrides: { readonly archivedAt?: DateTime.Utc; readonly deletedAt?: DateTime.Utc } = {},
+): OrchestrationV2DomainEvent => ({
+  id: EventId.make(`created:${threadId}`),
+  type: "thread.created",
+  threadId,
+  providerInstanceId,
+  occurredAt: at(0),
+  payload: {
+    createdBy: "user",
+    creationSource: "web",
+    id: threadId,
+    projectId,
+    title: threadId,
+    providerInstanceId,
+    modelSelection: { instanceId: providerInstanceId, model: "gpt-5" },
+    runtimeMode: "full-access",
+    interactionMode: "default",
+    branch: null,
+    worktreePath: null,
+    activeProviderThreadId: null,
+    lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
+    forkedFrom: null,
+    createdAt: at(0),
+    updatedAt: at(0),
+    archivedAt: overrides.archivedAt ?? null,
+    settledOverride: null,
+    settledAt: null,
+    lastVisitedAt: null,
+    deletedAt: overrides.deletedAt ?? null,
+  },
+});
+
+const threadId = ThreadId.make("thread:find");
+const projectId = ProjectId.make("project:find");
+const runId = RunId.make("run:find");
+
+function item(
+  id: string,
+  ordinal: number,
+  text: string,
+  kind: "user_message" | "assistant_message" | "proposed_plan" = "assistant_message",
+  owner = threadId,
+): Extract<
+  OrchestrationV2TurnItem,
+  { type: "user_message" | "assistant_message" | "proposed_plan" }
+> {
+  const base = {
+    id: TurnItemId.make(id),
+    threadId: owner,
+    runId,
+    nodeId: null,
+    providerThreadId: null,
+    providerTurnId: null,
+    nativeItemRef: null,
+    parentItemId: null,
+    ordinal,
+    status: "completed" as const,
+    title: null,
+    // Creation time deliberately opposes the canonical item order.
+    startedAt: at(100 - ordinal),
+    completedAt: at(100 - ordinal),
+    updatedAt: at(1),
+  };
+  if (kind === "proposed_plan")
+    return { ...base, type: kind, planId: PlanId.make(id), markdown: text, streaming: false };
+  if (kind === "user_message")
+    return {
+      ...base,
+      type: kind,
+      messageId: MessageId.make(id),
+      text,
+      inputIntent: "turn_start",
+      attachments: [],
+      createdBy: "user",
+      creationSource: "web",
+    };
+  return { ...base, type: kind, messageId: MessageId.make(id), text, streaming: false };
+}
+
+function run(
+  owner = threadId,
+  id = runId,
+  ordinal = 1,
+  status: OrchestrationV2Run["status"] = "completed",
+): Extract<OrchestrationV2DomainEvent, { type: "run.created" }> {
+  return {
+    id: EventId.make(`run:${owner}:${id}:${status}`),
+    threadId: owner,
+    occurredAt: at(1),
+    type: "run.created",
+    payload: {
+      id,
+      threadId: owner,
+      ordinal,
+      providerInstanceId,
+      modelSelection: { instanceId: providerInstanceId, model: "gpt-6" },
+      providerThreadId: null,
+      userMessageId: MessageId.make("prompt"),
+      rootNodeId: null,
+      activeAttemptId: null,
+      status,
+      requestedAt: at(1),
+      startedAt: at(1),
+      completedAt: at(2),
+      checkpointId: null,
+      contextHandoffId: null,
+    },
+  };
+}
+
+const commit = Effect.fn("ThreadFindTest.commit")(function* (
+  events: readonly OrchestrationV2DomainEvent[],
+) {
+  const store = yield* EventStore.EventStoreV2;
+  const projection = yield* ProjectionStore.ProjectionStoreV2;
+  yield* store.append({ events });
+  yield* Effect.forEach(events, projection.apply, { discard: true });
+});
+const putItems = (items: readonly OrchestrationV2TurnItem[], version = "initial") =>
+  commit(
+    items.map((payload) => ({
+      id: EventId.make(`${payload.threadId}:${payload.id}:${version}`),
+      threadId: payload.threadId,
+      occurredAt: at(1),
+      type: "turn-item.updated" as const,
+      payload,
+    })),
+  );
+const setup = Effect.gen(function* () {
+  yield* createProject(projectId);
+  yield* commit([thread(threadId, projectId), run()]);
+  return yield* ProjectionStore.ProjectionStoreV2;
+});
+
+describe("V2 thread find", () => {
+  it.effect("searches visible rendered messages and plans in canonical item order", () =>
+    Effect.gen(function* () {
+      const projection = yield* setup;
+      yield* putItems([
+        item("user", 1, "Check **the build**", "user_message"),
+        item("assistant", 2, "check the build twice: check the build"),
+        item("plan-item", 3, "# Check the build\nShip it", "proposed_plan"),
+        item("url", 4, "[documentation](https://hidden.example/needle)"),
+      ]);
+      const matches = [];
+      for (let index = 0; index < 4; index++) {
+        const result = yield* projection.searchThread({
+          threadId,
+          query: "CHECK THE BUILD",
+          index,
+        });
+        assert.equal(result.totalMatches, 4);
+        matches.push(result.match);
+      }
+      assert.deepEqual(matches, [
+        { entryId: "user", runId, occurrence: 0 },
+        { entryId: "assistant", runId, occurrence: 0 },
+        { entryId: "assistant", runId, occurrence: 1 },
+        { entryId: "plan-item", runId, occurrence: 0 },
+      ]);
+      assert.equal(
+        (yield* projection.searchThread({ threadId, query: "hidden.example" })).totalMatches,
+        0,
+      );
+      assert.equal(
+        (yield* projection.searchThread({ threadId, query: "check", index: 99 })).activeIndex,
+        3,
+      );
+    }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect("returns only nearby rows for a match beyond the recent history window", () =>
+    Effect.gen(function* () {
+      const projection = yield* setup;
+      const items = Array.from({ length: 520 }, (_, i) =>
+        item(`message:${i}`, i + 1, i === 8 || i === 510 ? "sentinel" : "other message"),
+      );
+      yield* putItems(items);
+      const first = yield* projection.searchThread({ threadId, query: "sentinel" });
+      const last = yield* projection.searchThread({ threadId, query: "sentinel", index: 1 });
+      assert.equal(first.totalMatches, 2);
+      assert.equal(first.match?.entryId, "message:8");
+      assert.equal(last.match?.entryId, "message:510");
+      assert.lengthOf(first.items, 5);
+      assert.lengthOf(last.items, 5);
+      assert.deepEqual(
+        last.items.map((row) => row.item.id),
+        ["message:508", "message:509", "message:510", "message:511", "message:512"],
+      );
+    }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect("invalidates cached counts when streamed text changes or a run rolls back", () =>
+    Effect.gen(function* () {
+      const projection = yield* setup;
+      const original = item("streaming", 1, "needle");
+      yield* putItems([original]);
+      assert.equal((yield* projection.searchThread({ threadId, query: "needle" })).totalMatches, 1);
+      if (original.type !== "assistant_message") return;
+      yield* putItems([{ ...original, text: "needle needle", streaming: true }], "streaming");
+      assert.equal((yield* projection.searchThread({ threadId, query: "needle" })).totalMatches, 2);
+      const updated = run(threadId, runId, 1, "rolled_back");
+      yield* commit([{ ...updated, type: "run.updated" }]);
+      assert.equal((yield* projection.searchThread({ threadId, query: "needle" })).totalMatches, 0);
+    }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect(
+    "does not search undispatched inputs, cancelled queue rows, or folded question answers",
+    () =>
+      Effect.gen(function* () {
+        const projection = yield* setup;
+        const queuedRunId = RunId.make("queued:cancelled");
+        yield* commit([run(threadId, queuedRunId, 2, "cancelled")]);
+        const queued = item("cancelled", 1, "needle", "user_message");
+        if (queued.type !== "user_message") return;
+        const answer = item("async-answer:question", 2, "needle", "user_message");
+        const question: OrchestrationV2TurnItem = {
+          ...item("question", 3, ""),
+          type: "user_input_request",
+          requestId: RuntimeRequestId.make("question"),
+          questions: [],
+          questionAnswer: { requestId: "question", answers: {}, attachmentsByQuestionId: {} },
+        };
+        yield* putItems([
+          { ...queued, runId: queuedRunId, inputIntent: "queued_turn" },
+          answer,
+          question,
+        ]);
+        const event: OrchestrationV2DomainEvent = {
+          id: EventId.make("undispatched"),
+          threadId,
+          occurredAt: at(2),
+          type: "message.updated",
+          payload: {
+            id: MessageId.make("undispatched"),
+            threadId,
+            runId: null,
+            nodeId: null,
+            role: "user",
+            text: "needle",
+            attachments: [],
+            streaming: false,
+            createdBy: "user",
+            creationSource: "web",
+            createdAt: at(2),
+            updatedAt: at(2),
+          },
+        };
+        yield* commit([event]);
+        const result = yield* projection.searchThread({ threadId, query: "needle" });
+        assert.equal(result.totalMatches, 0);
+        assert.deepEqual(result.items, []);
+      }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect(
+    "searches inherited fork history through the fork boundary, using source item identities",
+    () =>
+      Effect.gen(function* () {
+        const projection = yield* setup;
+        const parent = ThreadId.make("thread:parent");
+        const laterRun = RunId.make("run:later");
+        const parentRun = RunId.make("run:parent");
+        yield* commit([
+          thread(parent, projectId),
+          run(parent, parentRun),
+          run(parent, laterRun, 2),
+        ]);
+        yield* putItems([
+          { ...item("inherited", 1, "needle", "assistant_message", parent), runId: parentRun },
+          { ...item("after-fork", 2, "needle", "assistant_message", parent), runId: laterRun },
+        ]);
+        const child = thread(threadId, projectId);
+        if (child.type !== "thread.created") return;
+        yield* commit([
+          {
+            ...child,
+            id: EventId.make("child:fork"),
+            type: "thread.metadata-updated",
+            payload: {
+              ...child.payload,
+              forkedFrom: { type: "run", threadId: parent, runId: parentRun },
+            },
+          },
+        ]);
+        yield* putItems([item("local", 1, "needle")]);
+        const inherited = yield* projection.searchThread({ threadId, query: "needle" });
+        assert.equal(inherited.totalMatches, 2);
+        assert.equal(inherited.match?.entryId, "inherited");
+        assert.equal(inherited.items[0]?.visibility, "inherited");
+        assert.equal(inherited.items[0]?.sourceThreadId, parent);
+        assert.equal(
+          (yield* projection.searchThread({ threadId, query: "needle", index: 1 })).match?.entryId,
+          "local",
+        );
+        // Parent updates invalidate a child's cached inherited result too.
+        yield* putItems(
+          [{ ...item("inherited", 1, "gone", "assistant_message", parent), runId: parentRun }],
+          "parent-update",
+        );
+        assert.equal(
+          (yield* projection.searchThread({ threadId, query: "needle" })).totalMatches,
+          1,
+        );
+      }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect("rejects deleted threads and keeps results scoped to their thread", () =>
+    Effect.gen(function* () {
+      const projection = yield* setup;
+      const other = ThreadId.make("thread:other");
+      yield* commit([thread(other, projectId), run(other, RunId.make("run:other"))]);
+      yield* putItems([
+        item("shared-id", 1, "needle"),
+        item("other-id", 1, "other text", "assistant_message", other),
+      ]);
+      assert.equal((yield* projection.searchThread({ threadId, query: "needle" })).totalMatches, 1);
+      assert.equal(
+        (yield* projection.searchThread({ threadId: other, query: "needle" })).totalMatches,
+        0,
+      );
+      const deleted = thread(threadId, projectId, { deletedAt: at(3) });
+      if (deleted.type !== "thread.created") return;
+      yield* commit([{ ...deleted, id: EventId.make("deleted"), type: "thread.deleted" }]);
+      yield* Effect.flip(projection.searchThread({ threadId, query: "needle" }));
+    }).pipe(Effect.provide(layerTest)),
+  );
+});
diff --git a/apps/server/src/orchestration-v2/ThreadFind.ts b/apps/server/src/orchestration-v2/ThreadFind.ts
new file mode 100644
index 000000000000..14245210123d
--- /dev/null
+++ b/apps/server/src/orchestration-v2/ThreadFind.ts
@@ -0,0 +1,253 @@
+import {
+  OrchestrationV2TurnItemJson,
+  type OrchestrationV2ProjectedTurnItem,
+  type OrchestrationV2SearchThreadInput,
+  type OrchestrationV2SearchThreadResult,
+  type OrchestrationV2TurnItem,
+  ThreadId,
+  TurnItemId,
+} from "@t3tools/contracts";
+import { searchableMessageSegments, searchablePlanSegments } from "@t3tools/shared/threadFindText";
+import { countThreadSearchOccurrences } from "@t3tools/shared/threadSearch";
+import * as Cache from "effect/Cache";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Schema from "effect/Schema";
+import * as SqlClient from "effect/sql/SqlClient";
+import { ProjectionStoreReadError, type ProjectionStoreV2Error } from "./ProjectionStore.ts";
+
+interface FindRow {
+  readonly position: number;
+  readonly visibility: OrchestrationV2ProjectedTurnItem["visibility"];
+  readonly sourceThreadId: ThreadId;
+  readonly sourceItemId: TurnItemId;
+}
+interface FindDocument extends FindRow {
+  readonly entryId: string;
+  readonly runId: OrchestrationV2TurnItem["runId"];
+  readonly count: number;
+}
+class SearchKey extends Data.Class<{
+  threadId: ThreadId;
+  query: string;
+  sequence: number;
+  cwd: string | undefined;
+}> {}
+
+function countItem(item: OrchestrationV2TurnItem, query: string, cwd?: string): number {
+  let segments: readonly string[] | null = null;
+  if (item.type === "proposed_plan") segments = searchablePlanSegments(item.markdown, cwd);
+  else if (item.type === "user_message" || item.type === "assistant_message")
+    segments = searchableMessageSegments(
+      {
+        role: item.type === "user_message" ? "user" : "assistant",
+        text: item.text,
+        streaming: item.type === "assistant_message" && item.streaming,
+        context: item.type === "user_message" ? item.context : undefined,
+      },
+      cwd,
+    );
+  return segments?.reduce((sum, text) => sum + countThreadSearchOccurrences(text, query), 0) ?? 0;
+}
+
+function selectMatch(documents: readonly FindDocument[], requestedIndex: number) {
+  const totalMatches = documents.reduce((sum, doc) => sum + doc.count, 0);
+  const activeIndex = Math.min(requestedIndex, Math.max(0, totalMatches - 1));
+  let occurrence = activeIndex;
+  for (const document of documents) {
+    if (occurrence < document.count) return { totalMatches, activeIndex, document, occurrence };
+    occurrence -= document.count;
+  }
+  return { totalMatches, activeIndex, document: null, occurrence: 0 };
+}
+
+/** The memory projection uses the same match ordering and bounded context as SQLite. */
+export function findProjectedThreadItems(
+  items: readonly OrchestrationV2ProjectedTurnItem[],
+  input: OrchestrationV2SearchThreadInput,
+  snapshotSequence: number,
+  cwd?: string,
+): OrchestrationV2SearchThreadResult {
+  const foldedAnswers = new Set(
+    items.flatMap(({ item }) =>
+      item.type === "user_input_request" && item.questionAnswer
+        ? [`async-answer:${item.questionAnswer.requestId}`]
+        : [],
+    ),
+  );
+  const rows = items.filter(
+    ({ item }) =>
+      ["user_message", "assistant_message", "proposed_plan"].includes(item.type) &&
+      !(item.type === "user_message" && foldedAnswers.has(item.messageId)),
+  );
+  const docs: FindDocument[] = rows.map((row) => ({
+    ...row,
+    entryId:
+      row.item.type === "user_message" || row.item.type === "assistant_message"
+        ? row.item.messageId
+        : row.item.id,
+    runId: row.item.runId,
+    count: countItem(row.item, input.query, cwd),
+  }));
+  const selected = selectMatch(docs, input.index ?? 0);
+  const index = selected.document === null ? -1 : docs.indexOf(selected.document);
+  return {
+    snapshotSequence,
+    totalMatches: selected.totalMatches,
+    activeIndex: selected.activeIndex,
+    match:
+      selected.document === null
+        ? null
+        : {
+            entryId: selected.document.entryId,
+            runId: selected.document.runId,
+            occurrence: selected.occurrence,
+          },
+    items: index < 0 ? [] : rows.slice(Math.max(0, index - 2), index + 3),
+  };
+}
+
+/** Read the canonical index once per scan, including inherited fork rows, without tool bodies. */
+export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
+  readIndex: (threadId: ThreadId) => Effect.Effect<
+    readonly (Omit<FindRow, "position"> & {
+      readonly item: Pick<OrchestrationV2TurnItem, "type">;
+    })[],
+    ProjectionStoreV2Error
+  >,
+) {
+  const sql = yield* SqlClient.SqlClient;
+  const encodeSources = Schema.encodeEffect(
+    Schema.fromJsonString(Schema.Array(Schema.Struct({ threadId: ThreadId, id: TurnItemId }))),
+  );
+  const decodeItem = Schema.decodeUnknownEffect(Schema.fromJsonString(OrchestrationV2TurnItemJson));
+  const revision = (threadId: ThreadId) =>
+    sql<{ sequence: number }>`
+    SELECT COALESCE(MAX(sequence), 0) AS sequence FROM orchestration_events
+  `.pipe(
+      Effect.map((rows) => rows[0]?.sequence ?? 0),
+      Effect.mapError((cause) => new ProjectionStoreReadError({ threadId, cause })),
+    );
+  const changed = (threadId: ThreadId) => new ProjectionStoreReadError({ threadId });
+  const load = Effect.fn("ThreadFind.load")(function* (
+    threadId: ThreadId,
+    rows: readonly FindRow[],
+  ) {
+    if (rows.length === 0) return [];
+    const sources = yield* encodeSources(
+      rows.map((row) => ({ threadId: row.sourceThreadId, id: row.sourceItemId })),
+    ).pipe(Effect.mapError((cause) => new ProjectionStoreReadError({ threadId, cause })));
+    const payloads = yield* sql<{ thread_id: string; turn_item_id: string; payload_json: string }>`
+      SELECT item.thread_id, item.turn_item_id, item.payload_json
+      FROM orchestration_v2_projection_turn_items AS item
+      JOIN json_each(${sources}) AS wanted
+        ON item.thread_id = json_extract(wanted.value, '$.threadId')
+          AND item.turn_item_id = json_extract(wanted.value, '$.id')
+    `.pipe(Effect.mapError((cause) => new ProjectionStoreReadError({ threadId, cause })));
+    const byThread = new Map<string, Map<string, string>>();
+    for (const row of payloads) {
+      let items = byThread.get(row.thread_id);
+      if (!items) byThread.set(row.thread_id, (items = new Map()));
+      items.set(row.turn_item_id, row.payload_json);
+    }
+    return yield* Effect.forEach(rows, (row) =>
+      Effect.gen(function* () {
+        const payload = byThread.get(row.sourceThreadId)?.get(row.sourceItemId);
+        if (payload === undefined) return yield* changed(threadId);
+        const item = yield* decodeItem(payload).pipe(
+          Effect.mapError((cause) => new ProjectionStoreReadError({ threadId, cause })),
+        );
+        return { ...row, item };
+      }),
+    );
+  });
+  const scan = Effect.fn("ThreadFind.scan")(function* (key: SearchKey) {
+    const index = yield* readIndex(key.threadId);
+    const rows = index.map((row, position) => ({ ...row, position }));
+    // Question answers render inside their request card, not as searchable message bubbles.
+    const questions = rows.filter((row) => row.item.type === "user_input_request");
+    const foldedAnswers = new Set<string>();
+    for (let start = 0; start < questions.length; start += 128) {
+      for (const { item } of yield* load(key.threadId, questions.slice(start, start + 128))) {
+        if (item.type === "user_input_request" && item.questionAnswer)
+          foldedAnswers.add(`async-answer:${item.questionAnswer.requestId}`);
+      }
+      yield* Effect.yieldNow;
+    }
+    const candidates = rows.filter((row) =>
+      ["user_message", "assistant_message", "proposed_plan"].includes(row.item.type),
+    );
+    const context: FindRow[] = [];
+    const documents: FindDocument[] = [];
+    for (let start = 0; start < candidates.length; start += 128) {
+      const batch = yield* load(key.threadId, candidates.slice(start, start + 128));
+      for (const { item, ...row } of batch) {
+        if (item.type === "user_message" && foldedAnswers.has(item.messageId)) continue;
+        context.push(row);
+        const count = countItem(item, key.query, key.cwd);
+        if (count > 0)
+          documents.push({
+            ...row,
+            count,
+            runId: item.runId,
+            entryId:
+              item.type === "user_message" || item.type === "assistant_message"
+                ? item.messageId
+                : item.id,
+          });
+      }
+      yield* Effect.yieldNow;
+    }
+    if ((yield* revision(key.threadId)) !== key.sequence) return yield* changed(key.threadId);
+    return { documents, context };
+  });
+  // Keep IDs/counts only. Navigation never retains transcript bodies or one record per occurrence.
+  const cache = yield* Cache.makeWith(scan, {
+    capacity: 16,
+    timeToLive: (exit) =>
+      Exit.isSuccess(exit) && exit.value.context.length <= 10_000 ? "1 minute" : 0,
+  });
+  return Effect.fn("ProjectionStore.searchThread")(function* (
+    input: OrchestrationV2SearchThreadInput,
+  ) {
+    const active = yield* sql<{ cwd: string | null }>`
+      SELECT COALESCE(json_extract(t.payload_json, '$.worktreePath'), p.workspace_root) AS cwd
+      FROM orchestration_v2_projection_threads t JOIN projection_projects p ON p.project_id = t.project_id
+      WHERE t.thread_id = ${input.threadId} AND t.deleted_at IS NULL AND p.deleted_at IS NULL
+    `.pipe(
+      Effect.mapError((cause) => new ProjectionStoreReadError({ threadId: input.threadId, cause })),
+    );
+    if (!active[0]) return yield* changed(input.threadId);
+    const snapshotSequence = yield* revision(input.threadId);
+    const { documents, context } = yield* Cache.get(
+      cache,
+      new SearchKey({
+        threadId: input.threadId,
+        query: input.query,
+        sequence: snapshotSequence,
+        cwd: active[0].cwd ?? undefined,
+      }),
+    );
+    const selected = selectMatch(documents, input.index ?? 0);
+    const document = selected.document;
+    const index =
+      document === null ? -1 : context.findIndex((row) => row.position === document.position);
+    const items =
+      index < 0
+        ? []
+        : yield* load(input.threadId, context.slice(Math.max(0, index - 2), index + 3));
+    if ((yield* revision(input.threadId)) !== snapshotSequence)
+      return yield* changed(input.threadId);
+    return {
+      snapshotSequence,
+      totalMatches: selected.totalMatches,
+      activeIndex: selected.activeIndex,
+      match:
+        document === null
+          ? null
+          : { entryId: document.entryId, runId: document.runId, occurrence: selected.occurrence },
+      items,
+    };
+  });
+});
diff --git a/apps/server/src/orchestration-v2/ThreadManagementService.ts b/apps/server/src/orchestration-v2/ThreadManagementService.ts
index a450f34df5f0..00099b8af745 100644
--- a/apps/server/src/orchestration-v2/ThreadManagementService.ts
+++ b/apps/server/src/orchestration-v2/ThreadManagementService.ts
@@ -1,3 +1,7 @@
+import type {
+  OrchestrationV2SearchThreadInput,
+  OrchestrationV2SearchThreadResult,
+} from "@t3tools/contracts";
 import type {
   ProjectionRecordField,
   ProjectionRecordFilter,
@@ -271,6 +275,9 @@ export type ThreadManagementError = typeof ThreadManagementError.Type;
 type ThreadManagementFailure = ThreadManagementError | Orchestrator.OrchestratorV2Error;
 
 export interface ThreadManagementServiceShape {
+  readonly searchThread: (
+    input: OrchestrationV2SearchThreadInput,
+  ) => Effect.Effect<OrchestrationV2SearchThreadResult, Orchestrator.OrchestratorV2Error>;
   readonly ensureLegacyTranscript: (
     threadId: ThreadId,
   ) => Effect.Effect<void, LegacyV1ThreadImporter.LegacyV1ThreadImportError>;
@@ -793,6 +800,10 @@ const make = Effect.gen(function* () {
 
   return ThreadManagementService.of({
     ensureLegacyTranscript,
+    searchThread: (input) =>
+      ensureProjectionTranscript(input.threadId).pipe(
+        Effect.andThen(orchestrator.searchThread(input)),
+      ),
     dispatch,
     getTimelinePage: (threadId, options) =>
       ensureProjectionTranscript(threadId).pipe(
diff --git a/apps/server/src/relay/AgentAwarenessRelay.test.ts b/apps/server/src/relay/AgentAwarenessRelay.test.ts
index 79f100fb46e9..214b43f31f0f 100644
--- a/apps/server/src/relay/AgentAwarenessRelay.test.ts
+++ b/apps/server/src/relay/AgentAwarenessRelay.test.ts
@@ -192,6 +192,7 @@ const makeTestRelay = Effect.fnUntraced(function* (
       }),
     ensureLegacyTranscript: unused,
     dispatch: unused,
+    searchThread: () => Effect.die("unused"),
     getTimelinePage: () => Effect.die("Unused timeline read"),
     getMessageCount: () => Effect.die("unused message count"),
     getTurnItem: () => Effect.die("unused turn item read"),
diff --git a/apps/server/src/ws.ts b/apps/server/src/ws.ts
index fab4edb44406..6448bfc6caea 100644
--- a/apps/server/src/ws.ts
+++ b/apps/server/src/ws.ts
@@ -52,6 +52,7 @@ import {
   type AcpRegistrySetProviderInput,
   OrchestrationGetFullThreadDiffError,
   OrchestrationSearchThreadsError,
+  OrchestrationV2SearchThreadError,
   OrchestrationGetTurnDiffError,
   ORCHESTRATION_V2_WS_METHODS,
   ORCHESTRATION_PROTOCOL_QUERY_PARAM,
@@ -1722,6 +1723,7 @@ const layerWsRpc = (
             shellResumeCompletionMarker: true,
             threadResumeCompletionMarker: true,
             threadSnapshotPagination: true,
+            threadFind: true,
             ...Option.match(scratchWorkspaceRoot, {
               onNone: () => ({}),
               onSome: (root) => ({ scratchWorkspaceRoot: root }),
@@ -1888,6 +1890,10 @@ const layerWsRpc = (
                 }),
             ),
           ),
+        [ORCHESTRATION_V2_WS_METHODS.searchThread]: (input) =>
+          threadManagement
+            .searchThread(input)
+            .pipe(Effect.mapError((cause) => new OrchestrationV2SearchThreadError({ cause }))),
         [ORCHESTRATION_V2_WS_METHODS.searchThreads]: (input) =>
           threadSearch.search(input).pipe(
             Effect.mapError(
diff --git a/apps/web/package.json b/apps/web/package.json
index d17795f15c5d..18c096548ed8 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -55,9 +55,6 @@
     "react": "19.2.6",
     "react-dom": "19.2.6",
     "react-markdown": "^10.1.0",
-    "rehype-raw": "^7.0.0",
-    "rehype-sanitize": "^6.0.0",
-    "remark-breaks": "^4.0.0",
     "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.4.0",
     "unbash": "^5.0.0",
diff --git a/apps/web/src/components/ChatMarkdown.test.tsx b/apps/web/src/components/ChatMarkdown.test.tsx
index b1ceb33062c8..274503a54e79 100644
--- a/apps/web/src/components/ChatMarkdown.test.tsx
+++ b/apps/web/src/components/ChatMarkdown.test.tsx
@@ -1,6 +1,7 @@
 // @vitest-environment jsdom
 
 import { EnvironmentId, type AuthEnvironmentScope } from "@t3tools/contracts";
+import { MarkdownFindContext } from "./chat/markdownFindContext";
 import { act, type ComponentProps, type ReactNode } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import { create, type ReactTestRenderer } from "react-test-renderer";
@@ -1034,3 +1035,63 @@ describe("ChatMarkdown Windows file links", () => {
     expect(html).not.toContain("chat-markdown-file-link");
   });
 });
+
+it("opens nested disclosures for find and restores their prior state when find closes", async () => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  let renderer: ReactTestRenderer | undefined;
+  const render = (searching: boolean) => (
+    <MarkdownFindContext value={searching}>
+      <ChatMarkdown
+        cwd={undefined}
+        text="<details><summary>Outer</summary><details><summary>Inner</summary><p>needle</p></details></details>"
+      />
+    </MarkdownFindContext>
+  );
+  try {
+    await act(async () => {
+      renderer = create(render(false));
+    });
+    expect(JSON.stringify(renderer!.toJSON())).not.toContain("needle");
+    await act(async () => {
+      renderer!.update(render(true));
+    });
+    expect(JSON.stringify(renderer!.toJSON())).toContain("needle");
+    await act(async () => {
+      renderer!.update(render(false));
+    });
+    expect(
+      renderer!.root
+        .findAll(
+          (node) => node.type === "button" && node.props["data-markdown-details-summary"] === "",
+        )
+        .every((node) => node.props["aria-expanded"] === false),
+    ).toBe(true);
+    const trigger = renderer!.root.findAll(
+      (node) => node.type === "button" && node.props["data-markdown-details-summary"] === "",
+    )[0]!;
+    await act(async () => {
+      trigger.props.onClick({ nativeEvent: new Event("click") });
+    });
+    await act(async () => {
+      renderer!.update(render(true));
+    });
+    await act(async () => {
+      renderer!.update(render(false));
+    });
+    expect(
+      renderer!.root.findAllByProps({ "data-markdown-details-open": "true" }).length,
+    ).toBeGreaterThan(0);
+    expect(
+      renderer!.root
+        .findAll(
+          (node) => node.type === "button" && node.props["data-markdown-details-summary"] === "",
+        )
+        .map((node) => node.props["aria-expanded"]),
+    ).toEqual([true, false]);
+  } finally {
+    await act(async () => {
+      renderer?.unmount();
+    });
+    vi.unstubAllGlobals();
+  }
+});
diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index 42a34d8b5d25..aa1a43016e33 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -1,5 +1,24 @@
+import { MarkdownFindContext } from "./chat/markdownFindContext";
+import {
+  buildFileLinkParentSuffixByPath,
+  fileLinkLabel,
+  resolvePathLinkTarget,
+} from "@t3tools/shared/fileLinks";
+import {
+  isWindowsDrivePathHref,
+  normalizeMarkdownLinkDestination,
+  extractInlineCodeSpans,
+  extractMarkdownLinkHrefs,
+  inlineCodeFilePathCandidate,
+} from "@t3tools/shared/markdownLinks";
+import { isAbsolutePath } from "@t3tools/shared/path";
 import { usePullRequestLinking } from "~/hooks/usePullRequestLinking";
 import { AuthFilesystemReadScope, AuthOrchestrationOperateScope } from "@t3tools/contracts";
+import {
+  CHAT_MARKDOWN_REMARK_PLUGINS,
+  CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS,
+  CHAT_MARKDOWN_REHYPE_PLUGINS,
+} from "@t3tools/shared/markdownPipeline";
 import { useAtomValue } from "@effect/atom-react";
 import {
   COMPOSER_CONTEXT_CLIPBOARD_MIME,
@@ -46,12 +65,11 @@ import {
   codexArtifactTemplatePresentationLabel,
   type CodexArtifactTemplate,
   type CodexArtifactTemplateKind,
-} from "@t3tools/client-runtime/codex-artifact-templates";
+} from "@t3tools/shared/codexArtifactTemplates";
 import {
   classifyMarkdownImageSource,
   markdownImageSourceFragment,
 } from "@t3tools/client-runtime/markdown-images";
-import { inlineCodeFilePathCandidate } from "@t3tools/client-runtime/markdown-links";
 import { mediaFileReference, mediaUrlReference } from "@t3tools/client-runtime/media-reference";
 import { mediaKindFromPath, mediaMimeTypeFromExtension } from "@t3tools/shared/filePreview";
 import * as Cause from "effect/Cause";
@@ -83,24 +101,16 @@ import ReactMarkdown from "react-markdown";
 import { toHtml } from "hast-util-to-html";
 import { createIncrementalMarkdownPlugin } from "../markdown-incremental";
 import { defaultUrlTransform } from "react-markdown";
-import rehypeRaw from "rehype-raw";
-import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
-import remarkBreaks from "remark-breaks";
 import { parseAssistantCitationHref } from "@t3tools/shared/assistantCitations";
 import { parseComposerContextHref } from "@t3tools/shared/composerContextReferences";
-import { parseThreadLinkHref, THREAD_LINK_PROTOCOL } from "@t3tools/shared/threadLinks";
+import { parseThreadLinkHref } from "@t3tools/shared/threadLinks";
 import { AssistantCitationChip } from "./chat/AssistantCitationChip";
 import { MarkdownThreadLink } from "./chat/MarkdownThreadLink";
-import remarkGfm from "remark-gfm";
-import type { Processor } from "unified";
 import { isWindowsAbsolutePath } from "@t3tools/shared/path";
-import { remarkGithubAlerts } from "../markdown-github-alerts";
 import {
   artifactTemplateFromHastProperties,
-  CODEX_ARTIFACT_TEMPLATE_HAST_PROPERTIES,
-  remarkCodexDirectives,
   renderCodexFileCitationsAsMarkdown,
-} from "@t3tools/client-runtime/codex-markdown-directives";
+} from "@t3tools/shared/codexMarkdownDirectives";
 import { renderSkillInlineMarkdownChildren } from "./chat/SkillInlineText";
 import {
   resolveMarkdownMediaPreview,
@@ -153,11 +163,7 @@ import {
   serializeTableElementToCsv,
   serializeTableElementToMarkdown,
 } from "../markdown-clipboard";
-import { remarkNormalizeListItemIndentation } from "../markdown-list-indentation";
 import {
-  extractMarkdownLinkHrefs,
-  isWindowsDrivePathHref,
-  normalizeMarkdownLinkDestination,
   resolveInlineCodeFileLinkMeta,
   resolveMarkdownFileLinkMeta,
   rewriteMarkdownFileUriHref,
@@ -165,7 +171,7 @@ import {
   shouldOpenMarkdownFileLinkInEditor,
   type MarkdownFileLinkMeta,
 } from "../markdown-links";
-import { isMarkdownFileLinkLabel } from "@t3tools/client-runtime/markdown-links";
+import { isMarkdownFileLinkLabel } from "@t3tools/shared/markdownLinks";
 import { readLocalApi } from "../localApi";
 import { useAssetUrlRefresh, useAssetUrlState } from "../assets/assetUrls";
 import { cn } from "../lib/utils";
@@ -195,7 +201,6 @@ import {
 import { useOpenLink } from "../browser/useOpenLink";
 import { writeTextToClipboard } from "../hooks/useCopyToClipboard";
 import { isPreviewAvailableFor } from "../browser/previewRuntime";
-import { isAbsolutePath, resolvePathLinkTarget } from "../terminal-links";
 import {
   isBrowserPreviewFile,
   openFileInPreview,
@@ -396,190 +401,7 @@ function orderedListGutterStyle(
   return { "--list-gutter": `${markerWidth + 2}ch` };
 }
 
-type MarkdownImageHastNode = {
-  type?: string;
-  value?: string;
-  tagName?: string;
-  properties?: Record<string, unknown>;
-  children?: MarkdownImageHastNode[];
-};
 
-function meaningfulHastChildren(node: MarkdownImageHastNode): MarkdownImageHastNode[] {
-  return (node.children ?? []).filter(
-    (child) => !(child.type === "text" && (child as { value?: string }).value?.trim() === ""),
-  );
-}
-
-/**
- * An image that is the only content of its block (optionally wrapped in a
- * link) is almost always a screenshot or figure, so it gets a reserved slot
- * while it loads. Images mixed with text or other images — badge rows, icons
- * in a sentence — stay inline at their natural size, since a placeholder taller
- * than the image would move the page more than the image itself does.
- */
-/** Containers whose sole child image reads as a figure rather than part of a sentence. */
-const STANDALONE_IMAGE_BLOCKS = new Set([
-  "p",
-  "div",
-  "li",
-  "td",
-  "th",
-  "figure",
-  "center",
-  "blockquote",
-]);
-
-function soleImageDescendant(node: MarkdownImageHastNode): MarkdownImageHastNode | undefined {
-  const children = meaningfulHastChildren(node);
-  if (children.length !== 1) return undefined;
-  const only = children[0];
-  if (only?.type !== "element") return undefined;
-  if (only.tagName === "img") return only;
-  // A link, emphasis, or similar inline wrapper around the image still counts
-  // as long as nothing else shares the block.
-  return only.tagName === "a" || only.tagName === "strong" || only.tagName === "em"
-    ? soleImageDescendant(only)
-    : undefined;
-}
-
-function markStandaloneImages(node: MarkdownImageHastNode) {
-  // A raw `<img>` on its own line reaches the root without a paragraph.
-  if (node.type === "root" || (node.tagName && STANDALONE_IMAGE_BLOCKS.has(node.tagName))) {
-    const image = soleImageDescendant(node);
-    if (image) image.properties = { ...image.properties, dataStandalone: true };
-  }
-  node.children?.forEach((child) => {
-    if (child.type === "element") markStandaloneImages(child);
-  });
-}
-
-/** Keep unmatched inline `<A>` placeholders from opening an HTML link over later blocks. */
-function rehypePreserveBareAnchorPlaceholders() {
-  return (tree: MarkdownImageHastNode) => {
-    const anchors: Array<MarkdownImageHastNode | null> = [];
-    let rawTextTag: string | undefined;
-    const visit = (node: MarkdownImageHastNode) => {
-      if (node.type === "raw" && typeof node.value === "string") {
-        // Raw blocks can contain several tags. Consume whole tags, quoted attributes,
-        // and comments so text resembling a closing anchor cannot pair a placeholder.
-        const tags = /<!--[\s\S]*?(?:-->|$)|<\/?[A-Za-z](?:[^"'<>]|"[^"]*"|'[^']*')*>/g;
-        let offset = 0;
-        while (rawTextTag !== "plaintext") {
-          // Raw text ends at its closing tag even inside comment-looking text.
-          const matcher = rawTextTag ? new RegExp(`</${rawTextTag}\\s*>`, "gi") : tags;
-          matcher.lastIndex = offset;
-          const match = matcher.exec(node.value);
-          if (!match) break;
-          const [tag] = match;
-          offset = matcher.lastIndex;
-          if (rawTextTag) {
-            rawTextTag = undefined;
-            continue;
-          }
-          if (tag.startsWith("<!--")) continue;
-          const closing = /^<\/([a-z]+)\s*>$/i.exec(tag)?.[1]?.toLowerCase();
-          const opening = /^<([a-z]+)(?:\s|\/?>)/i.exec(tag)?.[1]?.toLowerCase();
-          if (
-            opening &&
-            /^(?:script|style|textarea|title|xmp|iframe|noembed|noframes|plaintext)$/.test(opening)
-          ) {
-            rawTextTag = opening;
-          } else if (opening === "a") {
-            anchors.push(node.value === tag && /^<a\s*\/?>$/i.test(tag) ? node : null);
-          } else if (closing === "a") {
-            anchors.pop();
-          }
-        }
-      }
-      node.children?.forEach(visit);
-    };
-
-    visit(tree);
-    for (const anchor of anchors) {
-      if (anchor) anchor.type = "text";
-    }
-  };
-}
-
-/** Carries authored image source metadata through the sanitizer to the image renderer. */
-function rehypePreserveImageSourceMeta() {
-  return (tree: MarkdownImageHastNode) => {
-    const visit = (node: MarkdownImageHastNode) => {
-      const src = node.properties?.src;
-      const title = node.properties?.title;
-      if (node.type === "element" && node.tagName === "img") {
-        node.properties = {
-          ...node.properties,
-          ...(typeof src === "string" && isWindowsDrivePathHref(src) ? { dataLocalSrc: src } : {}),
-          ...(typeof title === "string" ? { dataMarkdownTitle: title } : {}),
-        };
-      }
-      node.children?.forEach(visit);
-    };
-
-    visit(tree);
-    markStandaloneImages(tree);
-  };
-}
-
-const CHAT_MARKDOWN_SANITIZE_SCHEMA = {
-  ...defaultSchema,
-  attributes: {
-    ...defaultSchema.attributes,
-    "*": (defaultSchema.attributes?.["*"] ?? []).filter((attribute) => attribute !== "title"),
-    code: [...(defaultSchema.attributes?.code ?? []), "dataCodeMeta", "dataInlineCode"],
-    blockquote: [...(defaultSchema.attributes?.blockquote ?? []), "dataAlert"],
-    div: [...(defaultSchema.attributes?.div ?? []), ...CODEX_ARTIFACT_TEMPLATE_HAST_PROPERTIES],
-    a: [...(defaultSchema.attributes?.a ?? []), "dataPullRequestAutolink"],
-    img: [
-      ...(defaultSchema.attributes?.img ?? []),
-      "dataLocalSrc",
-      "dataMarkdownTitle",
-      "dataStandalone",
-    ],
-  },
-  protocols: {
-    ...defaultSchema.protocols,
-    href: [
-      ...(defaultSchema.protocols?.href ?? []),
-      "file",
-      "t3-citation",
-      "t3-context",
-      THREAD_LINK_PROTOCOL,
-    ],
-    src: [...(defaultSchema.protocols?.src ?? []), "file", "t3-context"],
-  },
-} satisfies Parameters<typeof rehypeSanitize>[0];
-
-const CHAT_MARKDOWN_REMARK_PLUGINS = [
-  remarkGfm,
-  remarkKeepWindowsPathDestinations,
-  remarkGithubAlerts,
-  remarkNormalizeListItemIndentation,
-  remarkCodexDirectives,
-  remarkPreserveCodeMeta,
-  remarkNormalizeLinksAndTagInlineCode,
-] satisfies NonNullable<ReactMarkdownOptions["remarkPlugins"]>;
-
-const CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS = [
-  remarkGfm,
-  remarkKeepWindowsPathDestinations,
-  remarkGithubAlerts,
-  remarkNormalizeListItemIndentation,
-  remarkCodexDirectives,
-  remarkBreaks,
-  remarkPreserveCodeMeta,
-  remarkNormalizeLinksAndTagInlineCode,
-] satisfies NonNullable<ReactMarkdownOptions["remarkPlugins"]>;
-
-const CHAT_MARKDOWN_REHYPE_PLUGINS = [
-  rehypePreserveBareAnchorPlaceholders,
-  rehypeRaw,
-  rehypePreserveImageSourceMeta,
-  [rehypeSanitize, CHAT_MARKDOWN_SANITIZE_SCHEMA],
-] satisfies NonNullable<ReactMarkdownOptions["rehypePlugins"]>;
-
-/** GitHub's own five alert kinds, in its colors: the glyph names the urgency, the title says it. */
 const GITHUB_ALERT_PRESENTATIONS: Record<
   string,
   { label: string; Icon: typeof InfoIcon; borderClassName: string; titleClassName: string }
@@ -680,87 +502,6 @@ type MarkdownAstNode = {
   children?: MarkdownAstNode[];
 };
 
-function remarkPreserveCodeMeta() {
-  return (tree: MarkdownAstNode) => {
-    const visit = (node: MarkdownAstNode) => {
-      if (node.type === "code" && typeof node.meta === "string" && node.meta.trim().length > 0) {
-        node.data = {
-          ...node.data,
-          hProperties: {
-            ...node.data?.hProperties,
-            dataCodeMeta: node.meta.trim(),
-          },
-        };
-      }
-      node.children?.forEach(visit);
-    };
-
-    visit(tree);
-  };
-}
-
-interface DestinationCompileContext {
-  readonly stack: ReadonlyArray<{ readonly type: string; url?: string }>;
-  resume(): string;
-  sliceSerialize(token: unknown): string;
-}
-
-function keepWindowsPathDestination(this: DestinationCompileContext, token: unknown) {
-  const decoded = this.resume();
-  const authored = this.sliceSerialize(token);
-  const node = this.stack.at(-1);
-  // Character references still need decoding, so those destinations keep the parsed URL.
-  if (node)
-    node.url = isWindowsAbsolutePath(authored) && !authored.includes("&") ? authored : decoded;
-}
-
-/**
- * CommonMark reads the `\.` in `C:\me\.t3\shot.png` as an escape, even in a link
- * destination. Every backslash in a Windows path is a separator, so link, image, and
- * definition destinations that are Windows paths keep the text as written.
- */
-function remarkKeepWindowsPathDestinations(this: Processor) {
-  const data = this.data();
-  (data.fromMarkdownExtensions ??= []).push({
-    exit: {
-      resourceDestinationString: keepWindowsPathDestination,
-      definitionDestinationString: keepWindowsPathDestination,
-    },
-  });
-}
-
-/**
- * Preserve Windows drive links as allowed `file:` URLs before sanitization.
- * The same traversal tags inline code while it can still be distinguished
- * from fenced code. Code inside links stays untagged to avoid nested anchors.
- */
-function remarkNormalizeLinksAndTagInlineCode() {
-  return (tree: MarkdownAstNode) => {
-    const visit = (node: MarkdownAstNode, insideLink: boolean) => {
-      if (
-        (node.type === "link" || node.type === "definition") &&
-        typeof node.url === "string" &&
-        WINDOWS_DRIVE_PATH_REGEX.test(node.url)
-      ) {
-        node.url = `file:///${node.url.replaceAll("\\", "/")}`;
-      }
-      if (node.type === "inlineCode" && !insideLink) {
-        node.data = {
-          ...node.data,
-          hProperties: {
-            ...node.data?.hProperties,
-            dataInlineCode: "",
-          },
-        };
-      }
-      const childInsideLink = insideLink || node.type === "link" || node.type === "linkReference";
-      node.children?.forEach((child) => visit(child, childInsideLink));
-    };
-
-    visit(tree, false);
-  };
-}
-
 function nodeToPlainText(node: ReactNode): string {
   if (typeof node === "string" || typeof node === "number") {
     return String(node);
@@ -947,6 +688,8 @@ function MarkdownDetails({
   open = false,
 }: Pick<React.ComponentProps<"details">, "children" | "open">) {
   const [isOpen, setIsOpen] = useState(open);
+  const searching = use(MarkdownFindContext);
+  const expanded = searching || isOpen;
   const childNodes = Children.toArray(children);
   const summaryIndex = childNodes.findIndex(
     (child) => isValidElement(child) && child.type === "summary",
@@ -961,10 +704,10 @@ function MarkdownDetails({
   return (
     <div className="my-2 border-y border-border/60">
       <Collapsible
-        defaultOpen={open}
+        open={expanded}
         onOpenChange={setIsOpen}
         data-markdown-details=""
-        data-markdown-details-open={isOpen ? "true" : "false"}
+        data-markdown-details-open={expanded ? "true" : "false"}
       >
         <CollapsibleTrigger
           className="flex w-full items-center gap-2 py-2 text-left text-sm font-medium text-foreground data-panel-open:[&_svg]:rotate-90"
@@ -1403,79 +1146,6 @@ interface MarkdownFileLinkProps {
 
 const MARKDOWN_FILE_LINK_CLASS_NAME = "chat-markdown-file-link";
 
-function pathParentSegments(path: string): string[] {
-  const normalized = path.replaceAll("\\", "/");
-  const segments = normalized.split("/").filter((segment) => segment.length > 0);
-  return segments.slice(0, -1);
-}
-
-function buildFileLinkParentSuffixByPath(filePaths: ReadonlyArray<string>): Map<string, string> {
-  const groups = new Map<string, Set<string>>();
-  for (const filePath of filePaths) {
-    const normalizedPath = filePath.replaceAll("\\", "/");
-    const pathSegments = normalizedPath.split("/").filter((segment) => segment.length > 0);
-    const basename = pathSegments[pathSegments.length - 1];
-    if (!basename) continue;
-    const group = groups.get(basename) ?? new Set<string>();
-    group.add(normalizedPath);
-    groups.set(basename, group);
-  }
-
-  const suffixByPath = new Map<string, string>();
-  for (const group of groups.values()) {
-    const uniquePaths = [...group];
-    if (uniquePaths.length < 2) continue;
-
-    const parentSegmentsByPath = new Map(
-      uniquePaths.map((filePath) => [filePath, pathParentSegments(filePath)]),
-    );
-    const minUniqueDepthByPath = new Map<string, number>();
-
-    for (const filePath of uniquePaths) {
-      const segments = parentSegmentsByPath.get(filePath) ?? [];
-      let resolvedDepth = segments.length;
-      for (let depth = 1; depth <= segments.length; depth += 1) {
-        const candidate = segments.slice(-depth).join("/");
-        const collision = uniquePaths.some((otherPath) => {
-          if (otherPath === filePath) return false;
-          const otherSegments = parentSegmentsByPath.get(otherPath) ?? [];
-          return otherSegments.slice(-depth).join("/") === candidate;
-        });
-        if (!collision) {
-          resolvedDepth = depth;
-          break;
-        }
-      }
-      minUniqueDepthByPath.set(filePath, resolvedDepth);
-    }
-
-    for (const filePath of uniquePaths) {
-      const segments = parentSegmentsByPath.get(filePath) ?? [];
-      if (segments.length === 0) continue;
-      const minUniqueDepth = minUniqueDepthByPath.get(filePath) ?? 1;
-      const suffixDepth = Math.min(segments.length, Math.max(minUniqueDepth, 2));
-      suffixByPath.set(filePath, segments.slice(-suffixDepth).join("/"));
-    }
-  }
-
-  return suffixByPath;
-}
-
-const FENCED_CODE_SEGMENT_PATTERN = /(```[\s\S]*?(?:```|$))/;
-const INLINE_CODE_SPAN_PATTERN = /`([^`\n]+)`/g;
-
-function extractInlineCodeSpans(text: string): string[] {
-  const spans: string[] = [];
-  const segments = text.split(FENCED_CODE_SEGMENT_PATTERN);
-  for (let index = 0; index < segments.length; index += 2) {
-    for (const match of (segments[index] ?? "").matchAll(INLINE_CODE_SPAN_PATTERN)) {
-      const span = match[1]?.trim();
-      if (span) spans.push(span);
-    }
-  }
-  return spans;
-}
-
 function normalizeMarkdownLinkHrefKey(href: string): string {
   const normalizedHref = normalizeMarkdownLinkDestination(href);
   const rewrittenHref = rewriteMarkdownFileUriHref(normalizedHref) ?? normalizedHref;
@@ -2826,18 +2496,6 @@ function useChatMarkdownState({
   );
   const fileLinkChip = useCallback(
     (fileLinkMeta: MarkdownFileLinkMeta, copyMarkdown: string, mediaSource?: string) => {
-      const parentSuffix = fileLinkParentSuffixByPath.get(
-        fileLinkMeta.filePath.replaceAll("\\", "/"),
-      );
-      const labelParts = [fileLinkMeta.basename];
-      if (typeof parentSuffix === "string" && parentSuffix.length > 0) {
-        labelParts.push(parentSuffix);
-      }
-      if (fileLinkMeta.line) {
-        labelParts.push(
-          `L${fileLinkMeta.line}${fileLinkMeta.column ? `:C${fileLinkMeta.column}` : ""}`,
-        );
-      }
       const mediaPath = mediaSource ?? fileLinkMeta.filePath;
       const canPreviewMedia =
         mediaMimeTypeFromExtension(
@@ -2857,7 +2515,14 @@ function useChatMarkdownState({
           displayPath={fileLinkMeta.displayPath}
           panelPath={panelPath}
           line={fileLinkMeta.line}
-          label={labelParts.join(" · ")}
+          label={fileLinkLabel(
+            {
+              path: fileLinkMeta.filePath,
+              ...(fileLinkMeta.line !== undefined ? { line: fileLinkMeta.line } : {}),
+              ...(fileLinkMeta.column !== undefined ? { column: fileLinkMeta.column } : {}),
+            },
+            fileLinkParentSuffixByPath,
+          )}
           copyMarkdown={copyMarkdown}
           theme={resolvedTheme}
           threadRef={threadRef}
@@ -3035,7 +2700,10 @@ const CHAT_MARKDOWN_COMPONENTS = {
     // text under a colored title — which is how the host renders it.
     return (
       <div role="note" className={cn("my-1 border-l-2 pl-3", alert.borderClassName)}>
-        <p className={cn("flex items-center gap-1.5 font-medium", alert.titleClassName)}>
+        <p
+          data-thread-find-ignore="true"
+          className={cn("flex items-center gap-1.5 font-medium", alert.titleClassName)}
+        >
           <alert.Icon aria-hidden className="size-3.5 shrink-0" />
           {alert.label}
         </p>
diff --git a/apps/web/src/components/ChatView.logic.test.ts b/apps/web/src/components/ChatView.logic.test.ts
index bf8d32f1daf3..f870182b1b2d 100644
--- a/apps/web/src/components/ChatView.logic.test.ts
+++ b/apps/web/src/components/ChatView.logic.test.ts
@@ -24,7 +24,7 @@ import {
   type OrchestrationV2ProjectedTurnItem,
   type WorktreeSetupSnapshot,
 } from "@t3tools/contracts";
-import type { CodexArtifactTemplate } from "@t3tools/client-runtime/codex-artifact-templates";
+import type { CodexArtifactTemplate } from "@t3tools/shared/codexArtifactTemplates";
 import * as DateTime from "effect/DateTime";
 import * as Option from "effect/Option";
 import { afterEach, describe, expect, it, vi } from "vite-plus/test";
diff --git a/apps/web/src/components/ChatView.logic.ts b/apps/web/src/components/ChatView.logic.ts
index f36e54d334fe..1e79964caa0a 100644
--- a/apps/web/src/components/ChatView.logic.ts
+++ b/apps/web/src/components/ChatView.logic.ts
@@ -38,7 +38,7 @@ import {
   appendCodexArtifactTemplateUsePrompt,
   codexArtifactTemplateUsePrompt,
   type CodexArtifactTemplate,
-} from "@t3tools/client-runtime/codex-artifact-templates";
+} from "@t3tools/shared/codexArtifactTemplates";
 import { presentThreadShell } from "@t3tools/client-runtime/state/shell";
 import {
   type ChatMessage,
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 3b08fa7e5597..f4acfa03d03c 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -1,3 +1,5 @@
+import { useThreadFind } from "./chat/useThreadFind";
+import { ThreadFindBar } from "./chat/ThreadFindBar";
 import { ChatCanvas } from "./chat/ChatCanvas";
 import { usageLimitRecoveryBannerItem } from "./chat/UsageLimitRecoveryBanner";
 import {
@@ -608,7 +610,7 @@ import {
 const EMPTY_PROVIDERS: ServerProvider[] = [];
 const EMPTY_PROVIDER_MODELS: ServerProvider["models"] = [];
 const EMPTY_USAGE_LIMIT_SOURCES: UsageLimitSourceSnapshots = [];
-import type { CodexArtifactTemplate } from "@t3tools/client-runtime/codex-artifact-templates";
+import type { CodexArtifactTemplate } from "@t3tools/shared/codexArtifactTemplates";
 
 const TIMELINE_SCROLL_CANCEL_SENTINEL = Object.freeze({});
 const EMPTY_FEEDBACK_SUBMISSIONS: ReadonlyArray<CodexFeedbackSubmission> = [];
@@ -7902,6 +7904,24 @@ export default function ChatView(props: ChatViewProps) {
     }),
     [composerRef, previewPanelOpen, terminalUiState.terminalOpen, routeKind, phase],
   );
+  const threadFind = useThreadFind({
+    cwd: gitCwd ?? undefined,
+    thread: activeThreadRef,
+    serverSearch: isServerThread && serverConfig?.threadFind === true,
+    content: serverProjection ?? undefined,
+    entries: timelineEntries,
+    history: threadHistoryControls
+      ? {
+          loading: threadHistoryControls.loading,
+          cursor: serverThreadHistory.historyCursor,
+          onLoadEarlier: () => {
+            threadHistoryControls.onLoadEarlier();
+            return true;
+          },
+        }
+      : null,
+  });
+  const { isOpen: isThreadFindActive, open: openThreadFind, close: closeThreadFind } = threadFind;
 
   useEffect(() => {
     const handler = (event: globalThis.KeyboardEvent) => {
@@ -7909,6 +7929,13 @@ export default function ChatView(props: ChatViewProps) {
         event.stopPropagation();
         return;
       }
+      if (isThreadFindActive && event.key === "Escape") {
+        event.preventDefault();
+        event.stopPropagation();
+        closeThreadFind();
+        focusComposer();
+        return;
+      }
       if (isTerminalCloseConfirmPending() && preventTerminalCloseShortcut(event, keybindings)) {
         event.stopPropagation();
         return;
@@ -8000,6 +8027,13 @@ export default function ChatView(props: ChatViewProps) {
         return;
       }
 
+      if (command === "chat.find") {
+        event.preventDefault();
+        event.stopPropagation();
+        openThreadFind();
+        return;
+      }
+
       if (command === "rightPanel.toggle") {
         event.preventDefault();
         event.stopPropagation();
@@ -8219,6 +8253,9 @@ export default function ChatView(props: ChatViewProps) {
     confirmAndUnpinThread,
     copyActiveThreadReference,
     getShortcutContext,
+    openThreadFind,
+    closeThreadFind,
+    isThreadFindActive,
     toggleRightPanel,
     toggleThreadPanel,
     toggleTerminalVisibility,
@@ -11209,6 +11246,7 @@ export default function ChatView(props: ChatViewProps) {
             activeThreadTitle={activeThread.title}
             activeProject={activeProject ?? null}
             rightPanelOpen={inlineRightPanelOwnsTitleBar}
+            findBar={<ThreadFindBar {...threadFind.barProps} />}
             onNewThreadInProject={handleNewThreadInActiveProject}
             {...(activeDraftLogicalProjectKey
               ? { onOpenProjectSettings: handleOpenDraftProjectSettings }
@@ -11291,6 +11329,7 @@ export default function ChatView(props: ChatViewProps) {
                 isPreparingWorktree={!paintOnlyDisplayedTimeline && isPreparingWorktree}
                 footer={paintOnlyDisplayedTimeline ? null : threadStatusLine}
                 listRef={legendListRef}
+                {...(!paintOnlyDisplayedTimeline ? threadFind.timelineProps : {})}
                 timelineEntries={displayedTimeline.entries}
                 providerStatuses={
                   environmentById.get(
@@ -11365,7 +11404,7 @@ export default function ChatView(props: ChatViewProps) {
               />
 
               {/* scroll to end pill — shown when user has scrolled away from the live edge */}
-              {showScrollToBottom && (
+              {showScrollToBottom && threadFind.timelineProps.searchEntries === null && (
                 <div
                   className="chat-scroll-to-bottom pointer-events-none absolute z-30 flex justify-center py-1.5"
                   style={{ bottom: scrollToEndClearance + 4 }}
diff --git a/apps/web/src/components/CommandPalette.tsx b/apps/web/src/components/CommandPalette.tsx
index 023eafa9397a..976d66a41e3d 100644
--- a/apps/web/src/components/CommandPalette.tsx
+++ b/apps/web/src/components/CommandPalette.tsx
@@ -68,6 +68,7 @@ import {
   SunIcon,
   TextSearchIcon,
 } from "lucide-react";
+import { requestThreadFindOpen } from "./chat/threadFindActionBus";
 import {
   useCallback,
   useDeferredValue,
@@ -1929,6 +1930,20 @@ function OpenCommandPaletteDialog(props: {
     });
   }
 
+  if (activeThreadId) {
+    actionItems.push({
+      kind: "action",
+      value: "find-current-thread",
+      title: "Find in current thread",
+      searchTerms: ["find", "search", "messages", "plans"],
+      icon: <TextSearchIcon className={ITEM_ICON_CLASS} />,
+      shortcutCommand: "chat.find",
+      run: async () => {
+        requestThreadFindOpen();
+      },
+    });
+  }
+
   if (activeThreadReferenceCopyTarget !== null) {
     actionItems.push({
       kind: "action",
diff --git a/apps/web/src/components/GitActionsControl.tsx b/apps/web/src/components/GitActionsControl.tsx
index 23cb11ea9c5c..6e3aff08484e 100644
--- a/apps/web/src/components/GitActionsControl.tsx
+++ b/apps/web/src/components/GitActionsControl.tsx
@@ -121,7 +121,7 @@ import { threadEnvironment } from "~/state/threads";
 import { useAtomCommand } from "~/state/use-atom-command";
 import { vcsActionManager, vcsEnvironment } from "~/state/vcs";
 import { randomUUID } from "~/lib/utils";
-import { resolvePathLinkTarget } from "~/terminal-links";
+import { resolvePathLinkTarget } from "@t3tools/shared/fileLinks";
 import { type DraftId, useComposerDraftStore } from "~/composerDraftStore";
 import {
   THREAD_DETAILS_PANEL_CHEVRON_CLASS,
diff --git a/apps/web/src/components/ThreadTerminalDrawer.tsx b/apps/web/src/components/ThreadTerminalDrawer.tsx
index bd40a4417955..5e0f1e4a4899 100644
--- a/apps/web/src/components/ThreadTerminalDrawer.tsx
+++ b/apps/web/src/components/ThreadTerminalDrawer.tsx
@@ -60,7 +60,8 @@ import {
 } from "~/terminal/ghostty/surface";
 import { type GhosttyColor, type GhosttyTheme } from "~/terminal/ghostty/core";
 import { useOpenInPreferredEditor } from "../editorPreferences";
-import { isTerminalUrl, resolvePathLinkTarget } from "../terminal-links";
+import { resolvePathLinkTarget } from "@t3tools/shared/fileLinks";
+import { isTerminalUrl } from "../terminal-links";
 import {
   isDiffToggleShortcut,
   isTerminalClearShortcut,
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
index 4923e1fc47e7..22b042167ca9 100644
--- a/apps/web/src/components/chat/ChatComposer.tsx
+++ b/apps/web/src/components/chat/ChatComposer.tsx
@@ -1084,7 +1084,7 @@ import {
   ShieldIcon,
   XIcon,
 } from "lucide-react";
-import { proposedPlanTitle } from "../../proposedPlan";
+import { proposedPlanTitle } from "@t3tools/shared/proposedPlanText";
 import { hasProviderSetup } from "./ProviderStatusBanner";
 import {
   applyProviderInstanceSettings,
diff --git a/apps/web/src/components/chat/ChatHeader.tsx b/apps/web/src/components/chat/ChatHeader.tsx
index 51c7ebb15f47..03f06b82819d 100644
--- a/apps/web/src/components/chat/ChatHeader.tsx
+++ b/apps/web/src/components/chat/ChatHeader.tsx
@@ -17,6 +17,7 @@ import {
   useMemo,
   useRef,
   useState,
+  type ReactNode,
   type KeyboardEvent as ReactKeyboardEvent,
   type MouseEvent as ReactMouseEvent,
 } from "react";
@@ -39,6 +40,7 @@ import {
 import { cn } from "~/lib/utils";
 
 interface ChatHeaderProps {
+  findBar: import("react").ReactNode;
   activeThreadEnvironmentId: EnvironmentId;
   activeThreadId: ThreadId;
   activeThreadTitle: string;
@@ -72,6 +74,7 @@ export function resolveRenameCommit(input: {
 // opens immediately.
 const TITLE_MENU_OPEN_DELAY_MS = 500;
 export const ChatHeader = memo(function ChatHeader({
+  findBar,
   activeThreadEnvironmentId,
   activeThreadId,
   activeThreadTitle,
@@ -254,7 +257,7 @@ export const ChatHeader = memo(function ChatHeader({
   return (
     <div
       className={cn(
-        "flex min-w-0 flex-1 items-center gap-2 sm:gap-3",
+        "relative flex min-w-0 flex-1 items-center gap-2 sm:gap-3",
         rightPanelOpen ? "pr-10" : "pr-24",
       )}
       onContextMenu={handleHeaderContextMenu}
@@ -355,6 +358,7 @@ export const ChatHeader = memo(function ChatHeader({
           )}
         </WorkspaceBreadcrumbItem>
       </WorkspaceBreadcrumb>
+      {findBar}
     </div>
   );
 });
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts
index 7360650a3a99..18245f40fe24 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts
@@ -2,7 +2,7 @@ import { worktreeSetupAgentStarted } from "@t3tools/client-runtime/worktree-setu
 export { worktreeSetupAgentStarted } from "@t3tools/client-runtime/worktree-setup";
 import * as Equal from "effect/Equal";
 import { shallow } from "zustand/vanilla/shallow";
-import { renderCodexDirectivesForCopy } from "@t3tools/client-runtime/codex-markdown-directives";
+import { renderCodexDirectivesForCopy } from "@t3tools/shared/codexMarkdownDirectives";
 import {
   commandDisplayText,
   commandProgramName,
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 79d216ba5f14..dddb15c49272 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -1,3 +1,5 @@
+const NOOP_SEARCH_LAYOUT = () => {};
+import { MarkdownFindContext } from "./markdownFindContext";
 import { ComputerUseAppIcon } from "~/components/Icons";
 import { useChatCanvas } from "./ChatCanvasContext";
 import { WorkLogBlock, WorkLogButton, WorkLogDetails, WorkLogList, WorkLogRow } from "./WorkLog";
@@ -94,7 +96,7 @@ import {
   workEntrySignalsSevereFailure,
   workLogEntryIsToolLike,
 } from "../../session-logic";
-import type { CodexArtifactTemplate } from "@t3tools/client-runtime/codex-artifact-templates";
+import type { CodexArtifactTemplate } from "@t3tools/shared/codexArtifactTemplates";
 import {
   type ChatMessage,
   type ChatFileAttachment,
@@ -218,6 +220,8 @@ import {
   type TimelineLatestRun,
   type WorkGroupScrollAnchor,
 } from "./MessagesTimeline.logic";
+import { type ThreadFindMatch } from "./threadFind";
+import { useThreadFindHighlights } from "./threadFindHighlights";
 import { TerminalContextInlineChip } from "./TerminalContextInlineChip";
 import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";
 import { Spinner } from "../ui/spinner";
@@ -313,6 +317,7 @@ interface TimelineRowSharedState {
   onRevertToTurnCount: (targetTurnCount: number, messageId: MessageId) => void;
   onUseArtifactTemplate: (template: CodexArtifactTemplate) => void;
   onRunShellCommand: ((command: string) => void) | undefined;
+  findActive: boolean;
   onImageExpand: (preview: ExpandedImagePreview) => void;
   displayThreadKey?: string;
   onOpenTurnDiff: (runId: RunId, filePath?: string) => void;
@@ -408,6 +413,7 @@ const TIMELINE_MAINTAIN_SCROLL_AT_END_SMOOTH = {
   ...TIMELINE_MAINTAIN_SCROLL_AT_END,
   animated: true,
 } as const satisfies MaintainScrollAtEndOptions;
+const FIND_MATCH_VIEW_MARGIN = 96;
 
 // ---------------------------------------------------------------------------
 // Props (public API)
@@ -500,19 +506,84 @@ interface MessagesTimelineProps {
   onContentOverflowChange?: (overflows: boolean) => void;
   onToolOutputCollapsedAtEnd?: () => void;
   onManualNavigation: () => void;
-  cancelPositionRestoreRef?: React.RefObject<(() => void) | null>;
+  cancelPositionRestoreRef?: React.RefObject<(() => void) | null> | undefined;
   hideEmptyPlaceholder?: boolean;
   topFadeEnabled?: boolean;
-  historyControls?: MessagesTimelineHistoryControls;
+  historyControls?: MessagesTimelineHistoryControls | undefined;
   /** Non-null when older turns exist beyond the loaded window. */
   loadEarlier?: CitationHistoryPage | null;
+  searchEntries?: ReadonlyArray<TimelineEntry> | null;
+  onCloseSearch?: () => void;
+  findQuery?: string;
+  activeFindMatch?: ThreadFindMatch | null;
+  findNavigationId?: number;
 }
 
 // ---------------------------------------------------------------------------
 // MessagesTimeline — list owner
 // ---------------------------------------------------------------------------
 
-export const MessagesTimeline = memo(function MessagesTimeline({
+export function MessagesTimeline(props: MessagesTimelineProps) {
+  const searchListRef = useRef<LegendListRef | null>(null);
+  const searchEntries = props.searchEntries;
+  const searching = searchEntries != null;
+  return (
+    <div className="relative flex min-h-0 flex-1 flex-col">
+      <div
+        className={
+          searching ? "invisible absolute inset-0 flex flex-col" : "flex min-h-0 flex-1 flex-col"
+        }
+        inert={searching}
+      >
+        <ConversationTimeline
+          {...props}
+          canvasActive={!searching}
+          findQuery={searching ? "" : (props.findQuery ?? "")}
+          activeFindMatch={searching ? null : (props.activeFindMatch ?? null)}
+          liveFollowEnabled={!searching && props.liveFollowEnabled}
+        />
+      </div>
+      {searchEntries && (
+        <>
+          <div className="flex items-center gap-3 border-b bg-background px-4 py-2 text-xs text-muted-foreground">
+            <span>Search result · nearby messages</span>
+            <Button variant="ghost" size="xs" onClick={props.onCloseSearch}>
+              Return to conversation
+            </Button>
+          </div>
+          <ConversationTimeline
+            {...props}
+            listRef={searchListRef}
+            timelineEntries={searchEntries}
+            loadEarlier={null}
+            historyControls={undefined}
+            rememberPosition={false}
+            cancelPositionRestoreRef={undefined}
+            worktreeSetup={null}
+            citationRequest={null}
+            anchorMessageId={null}
+            latestRun={null}
+            runningRunId={null}
+            turnDiffSummaries={[]}
+            supportsConversationRollback={false}
+            isWorking={false}
+            runlessWorkActive={false}
+            activeTurnInProgress={false}
+            activeTurnStartedAt={null}
+            isPreparingWorktree={false}
+            isCompacting={false}
+            liveFollowEnabled={false}
+            onManualNavigation={NOOP_SEARCH_LAYOUT}
+            onIsAtEndChange={NOOP_SEARCH_LAYOUT}
+            onContentOverflowChange={NOOP_SEARCH_LAYOUT}
+          />
+        </>
+      )}
+    </div>
+  );
+}
+
+const ConversationTimeline = memo(function ConversationTimeline({
   citationRequest = null,
   citationHistoryLoading = false,
   onCiteAssistantText,
@@ -531,6 +602,9 @@ export const MessagesTimeline = memo(function MessagesTimeline({
   isCompacting = false,
   listRef,
   timelineEntries,
+  findQuery = "",
+  activeFindMatch = null,
+  findNavigationId = 0,
   latestRun,
   runningRunId = null,
   turnDiffSummaries,
@@ -571,11 +645,13 @@ export const MessagesTimeline = memo(function MessagesTimeline({
   topFadeEnabled = false,
   historyControls,
   loadEarlier = null,
-}: MessagesTimelineProps) {
+  canvasActive = true,
+  rememberPosition = true,
+}: MessagesTimelineProps & { canvasActive?: boolean; rememberPosition?: boolean }) {
   const listIdentityKey = displayThreadKey ?? routeThreadKey;
   const rememberedPosition = useMemo(
-    () => readTimelinePosition(listIdentityKey),
-    [listIdentityKey],
+    () => (rememberPosition ? readTimelinePosition(listIdentityKey) : undefined),
+    [listIdentityKey, rememberPosition],
   );
   const [expandedRunIds, setExpandedRunIds] = useState<ReadonlySet<RunId>>(
     () => rememberedPosition?.disclosures?.runs ?? new Set(),
@@ -630,6 +706,9 @@ export const MessagesTimeline = memo(function MessagesTimeline({
   const disclosureAnchorKeyRef = useRef<string | null>(null);
   const disclosureSettleFrameRef = useRef<number | null>(null);
   const disclosureSettleSecondFrameRef = useRef<number | null>(null);
+  const normalizedFindQuery = findQuery.trim();
+  const findActive = normalizedFindQuery.length > 0;
+
   useEffect(() => {
     return () => {
       if (disclosureSettleFrameRef.current !== null) {
@@ -763,6 +842,25 @@ export const MessagesTimeline = memo(function MessagesTimeline({
     });
   }, [latestRun]);
 
+  const activeFindRunId = activeFindMatch?.runId;
+  const visibleExpandedRunIds = useMemo(() => {
+    if (!activeFindRunId || paintedExpandedRunIds.has(activeFindRunId)) {
+      return paintedExpandedRunIds;
+    }
+    return new Set(paintedExpandedRunIds).add(activeFindRunId);
+  }, [activeFindRunId, paintedExpandedRunIds]);
+
+  const activeFindAttemptId = activeFindMatch
+    ? timelineEntries.find((entry) => entry.id === activeFindMatch.entryId)?.attempt?.id
+    : undefined;
+  const visibleExpandedAttemptIds = useMemo(
+    () =>
+      activeFindAttemptId
+        ? new Set(paintedExpandedAttemptIds).add(activeFindAttemptId)
+        : paintedExpandedAttemptIds,
+    [activeFindAttemptId, paintedExpandedAttemptIds],
+  );
+
   const rowsProjectionRef = useRef<{
     readonly threadKey: string;
     readonly workspaceRoot: string | undefined;
@@ -775,8 +873,8 @@ export const MessagesTimeline = memo(function MessagesTimeline({
         timelineEntries,
         latestRun,
         runningRunId,
-        expandedRunIds,
-        expandedAttemptIds,
+        expandedRunIds: visibleExpandedRunIds,
+        expandedAttemptIds: visibleExpandedAttemptIds,
         expandedWorkGroupIds,
         isWorking,
         runlessWorkActive,
@@ -798,8 +896,8 @@ export const MessagesTimeline = memo(function MessagesTimeline({
     timelineEntries,
     latestRun,
     runningRunId,
-    expandedRunIds,
-    expandedAttemptIds,
+    visibleExpandedRunIds,
+    visibleExpandedAttemptIds,
     expandedWorkGroupIds,
     isWorking,
     runlessWorkActive,
@@ -1047,7 +1145,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
     if (restoringThreadPosition || state?.data !== rows) return;
     const isAtEnd = resolveTimelineIsAtEnd(state);
     const position = state?.data?.length ? resolveWorkGroupScrollAnchor(state) : undefined;
-    if (position && state && isAtEnd !== undefined) {
+    if (rememberPosition && position && state && isAtEnd !== undefined) {
       const index = state.indexByKey(position.rowId);
       const row = index === undefined ? undefined : state.elementAtIndex(index);
       const element = listRef.current?.getScrollableNode();
@@ -1115,6 +1213,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
     paintedExpandedAttemptIds,
     workGroupViewState,
     rows,
+    rememberPosition,
     listIdentityKey,
     restoringThreadPosition,
     listRef,
@@ -1180,6 +1279,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
       activeThreadEnvironmentId,
       onRevertToTurnCount,
       onRunShellCommand,
+      findActive,
       onImageExpand,
       onFileOpen,
       onUseArtifactTemplate,
@@ -1215,6 +1315,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
       activeThreadEnvironmentId,
       onRevertToTurnCount,
       onRunShellCommand,
+      findActive,
       onImageExpand,
       onFileOpen,
       onUseArtifactTemplate,
@@ -1296,7 +1397,7 @@ export const MessagesTimeline = memo(function MessagesTimeline({
   }, [historyControls, onOpenThread, parentThreadLink, topFadeEnabled]);
 
   const canvas = useChatCanvas();
-  const registerTimeline = canvas?.registerTimeline;
+  const registerTimeline = canvasActive ? canvas?.registerTimeline : undefined;
   const setTimelineList = useCallback(
     (list: LegendListRef | null) => {
       listRef.current = list;
@@ -1305,6 +1406,71 @@ export const MessagesTimeline = memo(function MessagesTimeline({
     [listRef, registerTimeline],
   );
 
+  const activeFindMatchKey = activeFindMatch
+    ? `${findNavigationId}:${normalizedFindQuery}:${activeFindMatch.entryId}:${activeFindMatch.occurrence}`
+    : null;
+  const revealActiveFindRange = useCallback(
+    (range: Range | null) => {
+      if (!range) return;
+
+      const codeScroller = range.startContainer.parentElement?.closest("pre");
+      if (codeScroller) {
+        const match = range.getBoundingClientRect();
+        const viewport = codeScroller.getBoundingClientRect();
+        if (match.left < viewport.left) codeScroller.scrollLeft += match.left - viewport.left - 16;
+        else if (match.right > viewport.right)
+          codeScroller.scrollLeft += match.right - viewport.right + 16;
+      }
+      const matchRect = range.getBoundingClientRect();
+      const viewportRect = timelineViewportElement?.getBoundingClientRect();
+      if (!viewportRect || matchRect.height === 0) return;
+
+      const topBoundary = viewportRect.top + FIND_MATCH_VIEW_MARGIN;
+      const bottomBoundary =
+        viewportRect.bottom - FIND_MATCH_VIEW_MARGIN - contentInsetEndAdjustment;
+      let delta = 0;
+      if (matchRect.top < topBoundary) delta = matchRect.top - topBoundary;
+      else if (matchRect.bottom > bottomBoundary) delta = matchRect.bottom - bottomBoundary;
+      if (Math.abs(delta) < 1) return;
+
+      const currentScroll = listRef.current?.getState?.().scroll;
+      if (typeof currentScroll === "number") {
+        listRef.current?.scrollToOffset({ offset: currentScroll + delta, animated: false });
+      }
+    },
+    [contentInsetEndAdjustment, listRef, timelineViewportElement],
+  );
+
+  const navigatedFindMatchKeyRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    if (!activeFindMatch || !activeFindMatchKey) {
+      navigatedFindMatchKeyRef.current = null;
+      return;
+    }
+
+    const rowIndex = rows.findIndex((row) => row.id === activeFindMatch.entryId);
+    if (rowIndex === -1) return;
+
+    if (navigatedFindMatchKeyRef.current === activeFindMatchKey) return;
+    navigatedFindMatchKeyRef.current = activeFindMatchKey;
+
+    onManualNavigation();
+    void listRef.current?.scrollToIndex({
+      index: rowIndex,
+      animated: false,
+      viewOffset: FIND_MATCH_VIEW_MARGIN,
+    });
+  }, [activeFindMatch, activeFindMatchKey, listRef, onManualNavigation, rows]);
+
+  useThreadFindHighlights({
+    container: timelineViewportElement,
+    query: normalizedFindQuery,
+    activeRowId: activeFindMatch?.entryId ?? null,
+    activeOccurrence: activeFindMatch?.occurrence ?? 0,
+    onActiveRange: revealActiveFindRange,
+  });
+
   // Stable renderItem — no closure deps. Row components read shared state
   // from TimelineRowCtx, which propagates through LegendList's memo.
   const renderItem = useCallback(
@@ -1341,80 +1507,82 @@ export const MessagesTimeline = memo(function MessagesTimeline({
   }
 
   return (
-    <TimelineRowCtx value={sharedState}>
-      <TimelineRowActivityCtx value={activityState}>
-        <TooltipScrollDismissArea
-          ref={setTimelineViewportElement}
-          className="relative h-full min-h-0"
-          data-assistant-citation-viewport="true"
-        >
-          {onCiteAssistantText && citationThreadRef ? (
-            <AssistantSelectionToolbar
-              viewport={timelineViewportElement}
-              threadRef={citationThreadRef}
-              onCite={onCiteAssistantText}
+    <MarkdownFindContext value={findActive}>
+      <TimelineRowCtx value={sharedState}>
+        <TimelineRowActivityCtx value={activityState}>
+          <TooltipScrollDismissArea
+            ref={setTimelineViewportElement}
+            className="relative h-full min-h-0"
+            data-assistant-citation-viewport="true"
+          >
+            {onCiteAssistantText && citationThreadRef ? (
+              <AssistantSelectionToolbar
+                viewport={timelineViewportElement}
+                threadRef={citationThreadRef}
+                onCite={onCiteAssistantText}
+              />
+            ) : null}
+            <LegendList<MessagesTimelineRow>
+              ref={setTimelineList}
+              data={rows}
+              extraData={`${listIdentityKey}:${rows.length}`}
+              keyExtractor={keyExtractor}
+              getItemType={getItemType}
+              renderItem={renderItem}
+              estimatedItemSize={90}
+              initialScrollAtEnd={citationRequest === null && rememberedPosition?.atEnd !== false}
+              // Legend needs a data refresh to mount new pins without a scroll event.
+              dataVersion={readyCitationRequest?.key ?? listIdentityKey}
+              {...(alwaysRender ? { alwaysRender } : {})}
+              onLoad={onCitationListLoad}
+              {...(anchoredEndSpace ? { anchoredEndSpace } : {})}
+              contentInsetEndAdjustment={anchoredEndSpace ? contentInsetEndAdjustment : 0}
+              maintainScrollAtEnd={
+                citationPositioning ||
+                (restoringThreadPosition && rememberedPosition?.atEnd === false) ||
+                anchoredEndSpace ||
+                !liveFollowEnabled ||
+                disclosureToggleSettling
+                  ? false
+                  : isWorking && !prefersReducedMotion && settlingListIdentity === null
+                    ? TIMELINE_MAINTAIN_SCROLL_AT_END_SMOOTH
+                    : TIMELINE_MAINTAIN_SCROLL_AT_END
+              }
+              maintainVisibleContentPosition={
+                citationPositioning ||
+                (restoringThreadPosition && rememberedPosition?.atEnd === false)
+                  ? false
+                  : maintainVisibleContentPosition
+              }
+              maintainScrollAtEndThreshold={1}
+              onScroll={handleScroll}
+              onItemSizeChanged={reportContentOverflow}
+              className={cn(
+                "messages-timeline-scroll scrollbar-gutter-both h-full min-h-0 overflow-x-hidden overscroll-y-contain [overflow-anchor:none]",
+                topFadeEnabled && "topbar-scroll-fade",
+              )}
+              ListHeaderComponent={listHeader}
+              ListFooterComponent={timelineListFooter}
             />
-          ) : null}
-          <LegendList<MessagesTimelineRow>
-            ref={setTimelineList}
-            data={rows}
-            extraData={`${listIdentityKey}:${rows.length}`}
-            keyExtractor={keyExtractor}
-            getItemType={getItemType}
-            renderItem={renderItem}
-            estimatedItemSize={90}
-            initialScrollAtEnd={citationRequest === null && rememberedPosition?.atEnd !== false}
-            // Legend needs a data refresh to mount new pins without a scroll event.
-            dataVersion={readyCitationRequest?.key ?? listIdentityKey}
-            {...(alwaysRender ? { alwaysRender } : {})}
-            onLoad={onCitationListLoad}
-            {...(anchoredEndSpace ? { anchoredEndSpace } : {})}
-            contentInsetEndAdjustment={anchoredEndSpace ? contentInsetEndAdjustment : 0}
-            maintainScrollAtEnd={
-              citationPositioning ||
-              (restoringThreadPosition && rememberedPosition?.atEnd === false) ||
-              anchoredEndSpace ||
-              !liveFollowEnabled ||
-              disclosureToggleSettling
-                ? false
-                : isWorking && !prefersReducedMotion && settlingListIdentity === null
-                  ? TIMELINE_MAINTAIN_SCROLL_AT_END_SMOOTH
-                  : TIMELINE_MAINTAIN_SCROLL_AT_END
-            }
-            maintainVisibleContentPosition={
-              citationPositioning ||
-              (restoringThreadPosition && rememberedPosition?.atEnd === false)
-                ? false
-                : maintainVisibleContentPosition
-            }
-            maintainScrollAtEndThreshold={1}
-            onScroll={handleScroll}
-            onItemSizeChanged={reportContentOverflow}
-            className={cn(
-              "messages-timeline-scroll scrollbar-gutter-both h-full min-h-0 overflow-x-hidden overscroll-y-contain [overflow-anchor:none]",
-              topFadeEnabled && "topbar-scroll-fade",
-            )}
-            ListHeaderComponent={listHeader}
-            ListFooterComponent={timelineListFooter}
-          />
-          <TimelineMinimap
-            items={minimapItems}
-            hasPersistentGutter={minimapHasPersistentGutter}
-            hitStripWidth={minimapHitStripWidth}
-            currentIndex={minimapCurrentIndex}
-            stripMap={minimapStripMap}
-            onSelect={(item) => {
-              onManualNavigation();
-              void listRef.current?.scrollToIndex({
-                index: item.rowIndex,
-                animated: true,
-                viewOffset: 24,
-              });
-            }}
-          />
-        </TooltipScrollDismissArea>
-      </TimelineRowActivityCtx>
-    </TimelineRowCtx>
+            <TimelineMinimap
+              items={minimapItems}
+              hasPersistentGutter={minimapHasPersistentGutter}
+              hitStripWidth={minimapHitStripWidth}
+              currentIndex={minimapCurrentIndex}
+              stripMap={minimapStripMap}
+              onSelect={(item) => {
+                onManualNavigation();
+                void listRef.current?.scrollToIndex({
+                  index: item.rowIndex,
+                  animated: true,
+                  viewOffset: 24,
+                });
+              }}
+            />
+          </TooltipScrollDismissArea>
+        </TimelineRowActivityCtx>
+      </TimelineRowCtx>
+    </MarkdownFindContext>
   );
 });
 
@@ -2095,21 +2263,23 @@ function UserTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "message"
             ? (userFiles.find((file) => file.id === record.attachmentId) ?? null)
             : null;
       return (
-        <UserMessageContextReferenceChip
-          reference={reference}
-          record={record}
-          annotationImage={annotationImage}
-          attachment={attachment}
-          onExpandImage={(image) => {
-            const preview = buildExpandedImagePreview(userImages, image.id);
-            if (preview) onImageExpand(preview);
-          }}
-          onOpenFile={onFileOpen}
-          onExpandVideo={(file) => {
-            const preview = buildAttachmentVideoPreview(ctx.activeThreadEnvironmentId, file);
-            if (preview) onImageExpand(preview);
-          }}
-        />
+        <span data-thread-find-ignore>
+          <UserMessageContextReferenceChip
+            reference={reference}
+            record={record}
+            annotationImage={annotationImage}
+            attachment={attachment}
+            onExpandImage={(image) => {
+              const preview = buildExpandedImagePreview(userImages, image.id);
+              if (preview) onImageExpand(preview);
+            }}
+            onOpenFile={onFileOpen}
+            onExpandVideo={(file) => {
+              const preview = buildAttachmentVideoPreview(ctx.activeThreadEnvironmentId, file);
+              if (preview) onImageExpand(preview);
+            }}
+          />
+        </span>
       );
     },
     [
@@ -2270,6 +2440,7 @@ function UserTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "message"
         ) : null}
         <div onCopyCapture={onBodyCopyCapture}>
           <CollapsibleUserMessageBody
+            expandForFind={ctx.findActive}
             text={resolvedContext.text}
             renderContextReference={renderContextReference}
             skills={ctx.skills}
@@ -2519,26 +2690,28 @@ function AssistantTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "mess
     <>
       <div className="relative min-w-0 px-1 py-0.5">
         <MessageAuthorHeading>T3 Code</MessageAuthorHeading>
-        <AssistantCitationSource
-          messageId={row.message.id}
-          {...(ctx.threadRef ? { threadRef: ctx.threadRef } : {})}
-          itemKey={row.id}
-          request={ctx.citationRequest}
-          listRef={ctx.listRef}
-        >
-          <ChatMarkdown
-            text={messageText}
-            cwd={ctx.markdownCwd}
-            threadRef={ctx.threadRef ?? undefined}
-            isStreaming={Boolean(row.message.streaming)}
-            lineBreaks={shouldPreserveAssistantLineBreaks(messageText)}
-            skills={ctx.skills}
-            headingLevelOffset={MESSAGE_HEADING_LEVEL}
-            onUseArtifactTemplate={ctx.onUseArtifactTemplate}
-            onRunShellCommand={ctx.onRunShellCommand}
-            onImageExpand={ctx.onImageExpand}
-          />
-        </AssistantCitationSource>
+        <div data-thread-find-text="true">
+          <AssistantCitationSource
+            messageId={row.message.id}
+            {...(ctx.threadRef ? { threadRef: ctx.threadRef } : {})}
+            itemKey={row.id}
+            request={ctx.citationRequest}
+            listRef={ctx.listRef}
+          >
+            <ChatMarkdown
+              text={messageText}
+              cwd={ctx.markdownCwd}
+              threadRef={ctx.threadRef ?? undefined}
+              isStreaming={Boolean(row.message.streaming)}
+              lineBreaks={shouldPreserveAssistantLineBreaks(messageText)}
+              skills={ctx.skills}
+              headingLevelOffset={MESSAGE_HEADING_LEVEL}
+              onUseArtifactTemplate={ctx.onUseArtifactTemplate}
+              onRunShellCommand={ctx.onRunShellCommand}
+              onImageExpand={ctx.onImageExpand}
+            />
+          </AssistantCitationSource>
+        </div>
         <AssistantChangedFilesSection
           turnSummary={row.assistantTurnDiffSummary}
           routeThreadKey={ctx.routeThreadKey}
@@ -2715,6 +2888,7 @@ function ProposedPlanTimelineRow({
         threadRef={ctx.threadRef ?? undefined}
         cwd={ctx.markdownCwd}
         workspaceRoot={ctx.workspaceRoot}
+        expandForFind={ctx.findActive}
       />
     </div>
   );
@@ -4383,12 +4557,14 @@ const CollapsibleUserMessageBody = memo(function CollapsibleUserMessageBody(prop
   renderContextReference: (reference: ChatMarkdownContextReference) => ReactNode;
   skills: ReadonlyArray<Pick<ServerProviderSkill, "name" | "displayName">>;
   markdownCwd: string | undefined;
+  expandForFind?: boolean;
   footer?: ReactNode;
 }) {
   const [expanded, setExpanded] = useState(false);
   const hasVisibleBody = props.text.trim().length > 0;
   const canCollapse = hasVisibleBody && shouldCollapseUserMessage(props.text);
-  const isCollapsed = canCollapse && !expanded;
+  const isCollapsed = canCollapse && !expanded && !props.expandForFind;
+  const showCollapseControl = canCollapse && !props.expandForFind;
 
   return (
     <div>
@@ -4396,6 +4572,7 @@ const CollapsibleUserMessageBody = memo(function CollapsibleUserMessageBody(prop
         <div
           className={cn("relative", isCollapsed && "max-h-44 overflow-hidden")}
           data-user-message-body="true"
+          data-thread-find-text="true"
           data-user-message-collapsed={isCollapsed ? "true" : "false"}
           data-user-message-collapsible={canCollapse ? "true" : "false"}
           data-user-message-fade={isCollapsed ? "true" : "false"}
@@ -4416,15 +4593,15 @@ const CollapsibleUserMessageBody = memo(function CollapsibleUserMessageBody(prop
           />
         </div>
       ) : null}
-      {canCollapse || props.footer ? (
+      {showCollapseControl || props.footer ? (
         <div
           className={cn(
             "mt-1.5 flex items-center gap-2",
-            canCollapse && props.footer ? "justify-between" : "justify-end",
+            showCollapseControl && props.footer ? "justify-between" : "justify-end",
           )}
           data-user-message-footer="true"
         >
-          {canCollapse ? (
+          {showCollapseControl ? (
             <Button
               type="button"
               size="xs"
diff --git a/apps/web/src/components/chat/ProposedPlanCard.tsx b/apps/web/src/components/chat/ProposedPlanCard.tsx
index 856d50a10a6a..83a4833124cf 100644
--- a/apps/web/src/components/chat/ProposedPlanCard.tsx
+++ b/apps/web/src/components/chat/ProposedPlanCard.tsx
@@ -1,3 +1,4 @@
+import { proposedPlanTitle, stripDisplayedPlanMarkdown } from "@t3tools/shared/proposedPlanText";
 import { memo, useState, useId } from "react";
 import {
   isAtomCommandInterrupted,
@@ -13,8 +14,6 @@ import {
   buildProposedPlanMarkdownFilename,
   downloadPlanAsTextFile,
   normalizePlanMarkdownForExport,
-  proposedPlanTitle,
-  stripDisplayedPlanMarkdown,
 } from "../../proposedPlan";
 import ChatMarkdown from "../ChatMarkdown";
 import { EllipsisIcon } from "lucide-react";
@@ -44,12 +43,14 @@ export const ProposedPlanCard = memo(function ProposedPlanCard({
   threadRef,
   cwd,
   workspaceRoot,
+  expandForFind = false,
 }: {
   planMarkdown: string;
   environmentId: EnvironmentId;
   threadRef?: ScopedThreadRef | undefined;
   cwd: string | undefined;
   workspaceRoot: string | undefined;
+  expandForFind?: boolean;
 }) {
   const [expanded, setExpanded] = useState(false);
   const canWriteFiles = useEnvironmentScope(environmentId, AuthFilesystemWriteScope);
@@ -79,6 +80,7 @@ export const ProposedPlanCard = memo(function ProposedPlanCard({
   const collapsedPreview = canCollapse
     ? buildCollapsedProposedPlanPreviewMarkdown(planMarkdown, { maxLines: 10 })
     : null;
+  const isCollapsed = canCollapse && !expanded && !expandForFind;
   const downloadFilename = buildProposedPlanMarkdownFilename(planMarkdown);
   const saveContents = normalizePlanMarkdownForExport(planMarkdown);
 
@@ -159,7 +161,9 @@ export const ProposedPlanCard = memo(function ProposedPlanCard({
           <Badge variant="secondary">Plan</Badge>
           {/* Same heading level as the message author headings in the timeline,
               so a plan's own headings nest beneath it in the outline. */}
-          <h3 className="truncate text-sm font-medium text-foreground">{title}</h3>
+          <h3 data-thread-find-text="true" className="truncate text-sm font-medium text-foreground">
+            {title}
+          </h3>
         </div>
         <Menu>
           <MenuTrigger
@@ -182,8 +186,11 @@ export const ProposedPlanCard = memo(function ProposedPlanCard({
         </Menu>
       </div>
       <div className="mt-4">
-        <div className={cn("relative", canCollapse && !expanded && "max-h-104 overflow-hidden")}>
-          {canCollapse && !expanded ? (
+        <div
+          className={cn("relative", isCollapsed && "max-h-104 overflow-hidden")}
+          data-thread-find-text="true"
+        >
+          {isCollapsed ? (
             <ChatMarkdown
               text={collapsedPreview ?? ""}
               cwd={cwd}
@@ -202,11 +209,11 @@ export const ProposedPlanCard = memo(function ProposedPlanCard({
               headingLevelOffset={3}
             />
           )}
-          {canCollapse && !expanded ? (
+          {isCollapsed ? (
             <div className="pointer-events-none absolute inset-x-0 bottom-0 h-24 bg-linear-to-t from-card/95 via-card/80 to-transparent" />
           ) : null}
         </div>
-        {canCollapse ? (
+        {canCollapse && !expandForFind ? (
           <div className="mt-4 flex justify-center">
             <Button
               size="sm"
diff --git a/apps/web/src/components/chat/ThreadFindBar.tsx b/apps/web/src/components/chat/ThreadFindBar.tsx
new file mode 100644
index 000000000000..eabff16ecaf4
--- /dev/null
+++ b/apps/web/src/components/chat/ThreadFindBar.tsx
@@ -0,0 +1,115 @@
+import { useEffect, useRef, type KeyboardEvent } from "react";
+import { ChevronDownIcon, ChevronUpIcon, XIcon } from "lucide-react";
+import { Button } from "../ui/button";
+import { InputGroup, InputGroupAddon, InputGroupInput } from "../ui/input-group";
+import { cn } from "~/lib/utils";
+import { formatThreadFindCount } from "./threadFind";
+
+interface ThreadFindBarProps {
+  readonly open: boolean;
+  readonly query: string;
+  readonly matchCount: number;
+  readonly historyState: "loading" | "incomplete" | "error" | null;
+  readonly onRetryHistory: () => void;
+  readonly activeIndex: number;
+  readonly focusRequestId: number;
+  readonly onQueryChange: (query: string) => void;
+  readonly onNext: () => void;
+  readonly onPrevious: () => void;
+  readonly onClose: () => void;
+}
+
+export function ThreadFindBar(props: ThreadFindBarProps) {
+  const inputRef = useRef<HTMLInputElement | null>(null);
+
+  useEffect(() => {
+    if (!props.open) return;
+    inputRef.current?.focus();
+    inputRef.current?.select();
+  }, [props.focusRequestId, props.open]);
+
+  if (!props.open) return null;
+
+  const hasQuery = props.query.trim().length > 0;
+  const noResults = hasQuery && !props.historyState && props.matchCount === 0;
+  let label = "";
+  if (hasQuery) {
+    label = formatThreadFindCount(props.activeIndex, props.matchCount);
+    if (props.historyState === "incomplete") label += " (partial)";
+  }
+  if (props.historyState === "loading") label = "Searching…";
+  if (props.historyState === "error") label = "Search failed";
+  const navigationDisabled = props.matchCount === 0 || props.historyState === "loading";
+  const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
+    if (event.nativeEvent.isComposing || event.nativeEvent.keyCode === 229) return;
+    if (event.key === "Enter") {
+      event.preventDefault();
+      event.stopPropagation();
+      if (event.shiftKey) props.onPrevious();
+      else props.onNext();
+    }
+  };
+
+  return (
+    <InputGroup
+      variant="popover"
+      size="lg"
+      onContextMenu={(event) => event.stopPropagation()}
+      role="search"
+      aria-label="Find in thread"
+      aria-busy={props.historyState === "loading"}
+      className="absolute top-[calc(100%+0.5rem)] right-0 z-40 w-[min(24rem,calc(100vw-1.5rem))] [-webkit-app-region:no-drag]"
+    >
+      <InputGroupInput
+        ref={inputRef}
+        type="search"
+        size="sm"
+        value={props.query}
+        aria-label="Find in thread"
+        placeholder="Find in thread"
+        maxLength={200}
+        spellCheck={false}
+        autoComplete="off"
+        onChange={(event) => props.onQueryChange(event.target.value)}
+        onKeyDown={handleKeyDown}
+      />
+      <InputGroupAddon align="inline-end">
+        <span
+          aria-live="polite"
+          className={cn(
+            "min-w-10 text-center text-xs tabular-nums",
+            noResults ? "text-destructive" : "text-muted-foreground",
+          )}
+        >
+          {label}
+        </span>
+        {props.historyState === "incomplete" || props.historyState === "error" ? (
+          <Button size="xs" variant="ghost" onClick={props.onRetryHistory}>
+            Retry
+          </Button>
+        ) : null}
+        <Button
+          size="icon-xs"
+          variant="ghost"
+          aria-label="Previous match"
+          disabled={navigationDisabled}
+          onClick={props.onPrevious}
+        >
+          <ChevronUpIcon />
+        </Button>
+        <Button
+          size="icon-xs"
+          variant="ghost"
+          aria-label="Next match"
+          disabled={navigationDisabled}
+          onClick={props.onNext}
+        >
+          <ChevronDownIcon />
+        </Button>
+        <Button size="icon-xs" variant="ghost" aria-label="Close find" onClick={props.onClose}>
+          <XIcon />
+        </Button>
+      </InputGroupAddon>
+    </InputGroup>
+  );
+}
diff --git a/apps/web/src/components/chat/markdownFindContext.ts b/apps/web/src/components/chat/markdownFindContext.ts
new file mode 100644
index 000000000000..f765c9e1b716
--- /dev/null
+++ b/apps/web/src/components/chat/markdownFindContext.ts
@@ -0,0 +1,4 @@
+import { createContext } from "react";
+
+// Temporarily reveal Markdown disclosures while finding; preserve the user's fold state.
+export const MarkdownFindContext = createContext(false);
diff --git a/apps/web/src/components/chat/threadFind.test.ts b/apps/web/src/components/chat/threadFind.test.ts
new file mode 100644
index 000000000000..92d63a767237
--- /dev/null
+++ b/apps/web/src/components/chat/threadFind.test.ts
@@ -0,0 +1,251 @@
+import { MessageId, RunId, PlanId } from "@t3tools/contracts";
+import { describe, expect, it } from "vite-plus/test";
+import type { TimelineEntry } from "../../session-logic";
+import { deriveMessagesTimelineRows } from "./MessagesTimeline.logic";
+import {
+  buildThreadFindMatches,
+  clampThreadFindIndex,
+  formatThreadFindCount,
+  stepThreadFindIndex,
+} from "./threadFind";
+
+const CREATED_AT = "2026-01-01T00:00:00.000Z";
+
+function messageEntry(
+  id: string,
+  role: "user" | "assistant" | "system",
+  text: string,
+  runId: RunId | null = null,
+): TimelineEntry {
+  return {
+    id,
+    kind: "message",
+    createdAt: CREATED_AT,
+    message: {
+      id: MessageId.make(id),
+      role,
+      text,
+      runId,
+      streaming: false,
+      createdAt: CREATED_AT,
+      updatedAt: CREATED_AT,
+    },
+  };
+}
+
+function workEntry(id: string): TimelineEntry {
+  return {
+    id,
+    kind: "work",
+    createdAt: CREATED_AT,
+    entry: {
+      id,
+      label: "deploy sentinel",
+      tone: "tool",
+      createdAt: CREATED_AT,
+    },
+  };
+}
+
+function proposedPlanEntry(id: string, planMarkdown: string, runId: RunId | null): TimelineEntry {
+  return {
+    id,
+    kind: "proposed-plan",
+    createdAt: CREATED_AT,
+    proposedPlan: {
+      id: PlanId.make(id),
+      runId,
+      planMarkdown,
+      status: "active",
+      createdAt: CREATED_AT,
+      updatedAt: CREATED_AT,
+    },
+  };
+}
+
+describe("searchable thread entries", () => {
+  it("searches displayed user text without appended context payloads", () => {
+    const prompt = [
+      "check the build",
+      "",
+      "<terminal_context>",
+      "- Terminal 1 line 12:",
+      "  secret sentinel output",
+      "</terminal_context>",
+    ].join("\n");
+
+    const entries = [messageEntry("m1", "user", prompt)];
+    expect(buildThreadFindMatches(entries, "check the build")).toHaveLength(1);
+    expect(buildThreadFindMatches(entries, "sentinel")).toHaveLength(0);
+  });
+
+  it("excludes terminal labels that render as non-searchable chips", () => {
+    const prompt = [
+      "check @terminal-1:12",
+      "",
+      "<terminal_context>",
+      "- Terminal 1 line 12:",
+      "  12 | output",
+      "</terminal_context>",
+    ].join("\n");
+
+    const entries = [messageEntry("m1", "user", prompt)];
+    expect(buildThreadFindMatches(entries, "check")).toHaveLength(1);
+    expect(buildThreadFindMatches(entries, "@terminal-1:12")).toHaveLength(0);
+  });
+
+  it("keeps repeated terminal labels that are still visible after the chip", () => {
+    const prompt =
+      "check @terminal-1:12 and @terminal-1:12\n\n<terminal_context>\n- Terminal 1 line 12:\n  12 | output\n</terminal_context>";
+    expect(
+      buildThreadFindMatches([messageEntry("m1", "user", prompt)], "@terminal-1:12"),
+    ).toHaveLength(1);
+  });
+
+  it("excludes terminal chips even when their labels are out of context order", () => {
+    const prompt =
+      "@terminal-2:12 then @terminal-1:12\n\n<terminal_context>\n- Terminal 1 line 12:\n  12 | first\n- Terminal 2 line 12:\n  12 | second\n</terminal_context>";
+    expect(buildThreadFindMatches([messageEntry("m1", "user", prompt)], "@terminal-")).toHaveLength(
+      0,
+    );
+  });
+
+  it.each(["user", "assistant"] as const)(
+    "searches rendered %s Markdown, not link destinations or formatting",
+    (role) => {
+      const entries = [
+        messageEntry(
+          "m1",
+          role,
+          "[documentation](https://hidden.example/path) foo**bar** and `inline code`",
+        ),
+      ];
+      expect(buildThreadFindMatches(entries, "hidden.example")).toHaveLength(0);
+      expect(buildThreadFindMatches(entries, "documentation")).toHaveLength(1);
+      expect(buildThreadFindMatches(entries, "foobar")).toHaveLength(1);
+      expect(buildThreadFindMatches(entries, "inline code")).toHaveLength(1);
+    },
+  );
+
+  it("searches code, escaped punctuation, entities and sanitized HTML as displayed", () => {
+    const entries = [
+      messageEntry(
+        "m1",
+        "assistant",
+        "```ts\nconst value = 1;\n```\n\n\\*literal\\* &amp; <strong>bold</strong><script>hidden</script>",
+      ),
+    ];
+    for (const query of ["const value", "*literal* & bold"]) {
+      expect(buildThreadFindMatches(entries, query)).toHaveLength(1);
+    }
+    for (const query of ["hidden", "strong", "```ts"]) {
+      expect(buildThreadFindMatches(entries, query)).toHaveLength(0);
+    }
+  });
+
+  it("preserves literal HTML in user messages", () => {
+    expect(
+      buildThreadFindMatches([messageEntry("m1", "user", "<strong>bold</strong>")], "<strong>"),
+    ).toHaveLength(1);
+  });
+
+  it("searches plan titles before body matches, including the default title", () => {
+    const entries = [proposedPlanEntry("p1", "# Release\n\n## Summary\n\nRelease **ready**", null)];
+    expect(buildThreadFindMatches(entries, "Release").map((match) => match.occurrence)).toEqual([
+      0, 1,
+    ]);
+    expect(buildThreadFindMatches(entries, "Summary")).toHaveLength(0);
+    expect(
+      buildThreadFindMatches([proposedPlanEntry("p2", "Body", null)], "Proposed plan"),
+    ).toHaveLength(1);
+  });
+
+  it("does not join separate blocks or the plan title and body into a phrase", () => {
+    expect(
+      buildThreadFindMatches([messageEntry("m1", "assistant", "first\n\nsecond")], "firstsecond"),
+    ).toHaveLength(0);
+    expect(
+      buildThreadFindMatches([proposedPlanEntry("p1", "# first\n\nsecond", null)], "firstsecond"),
+    ).toHaveLength(0);
+  });
+
+  it("indexes the rendered placeholder for empty assistant responses", () => {
+    expect(
+      buildThreadFindMatches([messageEntry("m1", "assistant", "")], "(empty response)"),
+    ).toHaveLength(1);
+  });
+
+  it("skips work rows and system messages", () => {
+    expect(
+      buildThreadFindMatches(
+        [workEntry("w1"), messageEntry("s1", "system", "sentinel")],
+        "sentinel",
+      ),
+    ).toHaveLength(0);
+  });
+
+  it("uses the displayed proposed-plan title and body", () => {
+    const entries = [proposedPlanEntry("p1", "# Visible title\n\n## Summary\n\nship it", null)];
+    expect(buildThreadFindMatches(entries, "Visible title")).toHaveLength(1);
+    expect(buildThreadFindMatches(entries, "ship it")).toHaveLength(1);
+    expect(buildThreadFindMatches(entries, "Summary")).toHaveLength(0);
+  });
+});
+
+describe("buildThreadFindMatches", () => {
+  it("carries turn ownership for folded messages and plans", () => {
+    const runId = RunId.make("turn-1");
+    const entries = [
+      messageEntry("m1", "assistant", "deploy twice: deploy", runId),
+      proposedPlanEntry("p1", "deploy the plan", runId),
+    ];
+
+    expect(buildThreadFindMatches(entries, "deploy")).toEqual([
+      { entryId: "m1", runId, occurrence: 0 },
+      { entryId: "m1", runId, occurrence: 1 },
+      { entryId: "p1", runId, occurrence: 0 },
+    ]);
+  });
+
+  it("reveals a search result inside a settled turn and restores its fold afterward", () => {
+    const runId = RunId.make("settled-turn");
+    const entries = [
+      messageEntry("prompt", "user", "Check the release"),
+      messageEntry("progress", "assistant", "Found the sentinel", runId),
+      messageEntry("final", "assistant", "Done", runId),
+    ];
+    const input = {
+      timelineEntries: entries,
+      isWorking: false,
+      activeTurnStartedAt: null,
+      turnDiffSummaries: [],
+      supportsConversationRollback: false,
+    };
+    const collapsed = deriveMessagesTimelineRows(input);
+    expect(collapsed.some((row) => row.id === "progress")).toBe(false);
+
+    const match = buildThreadFindMatches(entries, "sentinel")[0]!;
+    const expanded = deriveMessagesTimelineRows({
+      ...input,
+      expandedRunIds: new Set(match.runId ? [match.runId] : []),
+    });
+    expect(expanded.some((row) => row.id === match.entryId)).toBe(true);
+    expect(deriveMessagesTimelineRows(input).map((row) => row.id)).toEqual(
+      collapsed.map((row) => row.id),
+    );
+  });
+
+  it("ignores blank queries", () => {
+    expect(buildThreadFindMatches([messageEntry("m1", "user", "deploy")], "   ")).toEqual([]);
+  });
+});
+
+describe("thread find navigation", () => {
+  it("clamps, wraps, and formats positions", () => {
+    expect(clampThreadFindIndex(4, 2)).toBe(1);
+    expect(stepThreadFindIndex(2, 3, 1)).toBe(0);
+    expect(stepThreadFindIndex(0, 3, -1)).toBe(2);
+    expect(formatThreadFindCount(4, 2)).toBe("2/2");
+    expect(formatThreadFindCount(0, 0)).toBe("0/0");
+  });
+});
diff --git a/apps/web/src/components/chat/threadFind.ts b/apps/web/src/components/chat/threadFind.ts
new file mode 100644
index 000000000000..dfa925cce882
--- /dev/null
+++ b/apps/web/src/components/chat/threadFind.ts
@@ -0,0 +1,85 @@
+import type { RunId } from "@t3tools/contracts";
+import { countThreadSearchOccurrences } from "@t3tools/shared/threadSearch";
+import type { TimelineEntry } from "../../session-logic";
+import { searchableMessageSegments, searchablePlanSegments } from "@t3tools/shared/threadFindText";
+
+/** One occurrence of the query inside a searchable timeline entry. */
+export interface ThreadFindMatch {
+  readonly entryId: string;
+  /** The turn to expand when the matching entry is folded. */
+  readonly runId: RunId | null;
+  /** Zero-based occurrence within this timeline entry. */
+  readonly occurrence: number;
+}
+
+// Message/plan records are immutable and survive timeline rebuilds during streaming.
+// Weak keys reuse parsed text across keystrokes without retaining old messages.
+const entryTextCache = new WeakMap<
+  object,
+  { cwd: string | undefined; segments: readonly string[] | null }
+>();
+
+function searchableThreadEntrySegments(
+  entry: TimelineEntry,
+  cwd?: string,
+): readonly string[] | null {
+  if (entry.kind !== "message" && entry.kind !== "proposed-plan") return null;
+  const key = entry.kind === "message" ? entry.message : entry.proposedPlan;
+  const cached = entryTextCache.get(key);
+  if (cached && cached.cwd === cwd) return cached.segments;
+  const segments =
+    entry.kind === "message"
+      ? searchableMessageSegments(entry.message, cwd)
+      : searchablePlanSegments(entry.proposedPlan.planMarkdown, cwd);
+  entryTextCache.set(key, { cwd, segments });
+  return segments;
+}
+
+function threadEntryRunId(entry: TimelineEntry): RunId | null {
+  if (entry.kind === "message") return entry.message.runId ?? null;
+  if (entry.kind === "proposed-plan") return entry.proposedPlan.runId;
+  return null;
+}
+
+export function buildThreadFindMatches(
+  entries: ReadonlyArray<TimelineEntry>,
+  query: string,
+  cwd?: string,
+): ThreadFindMatch[] {
+  const normalizedQuery = query.trim();
+  if (normalizedQuery.length === 0) return [];
+
+  const matches: ThreadFindMatch[] = [];
+  for (const entry of entries) {
+    const segments = searchableThreadEntrySegments(entry, cwd);
+    if (segments === null) continue;
+
+    const total = segments.reduce(
+      (count, text) => count + countThreadSearchOccurrences(text, normalizedQuery),
+      0,
+    );
+    for (let occurrence = 0; occurrence < total; occurrence += 1) {
+      matches.push({
+        entryId: entry.id,
+        runId: threadEntryRunId(entry),
+        occurrence,
+      });
+    }
+  }
+  return matches;
+}
+
+export function clampThreadFindIndex(index: number, total: number): number {
+  if (total <= 0 || !Number.isFinite(index) || index < 0) return 0;
+  return Math.min(Math.trunc(index), total - 1);
+}
+
+export function stepThreadFindIndex(index: number, total: number, delta: number): number {
+  if (total <= 0) return 0;
+  const clamped = clampThreadFindIndex(index, total);
+  return (((clamped + delta) % total) + total) % total;
+}
+
+export function formatThreadFindCount(index: number, total: number): string {
+  return total <= 0 ? "0/0" : `${clampThreadFindIndex(index, total) + 1}/${total}`;
+}
diff --git a/apps/web/src/components/chat/threadFindActionBus.ts b/apps/web/src/components/chat/threadFindActionBus.ts
new file mode 100644
index 000000000000..375610fbc077
--- /dev/null
+++ b/apps/web/src/components/chat/threadFindActionBus.ts
@@ -0,0 +1,10 @@
+const THREAD_FIND_OPEN_EVENT = "t3:thread-find-open";
+
+export function requestThreadFindOpen(): void {
+  window.dispatchEvent(new Event(THREAD_FIND_OPEN_EVENT));
+}
+
+export function subscribeThreadFindOpen(listener: () => void): () => void {
+  window.addEventListener(THREAD_FIND_OPEN_EVENT, listener);
+  return () => window.removeEventListener(THREAD_FIND_OPEN_EVENT, listener);
+}
diff --git a/apps/web/src/components/chat/threadFindHighlights.ts b/apps/web/src/components/chat/threadFindHighlights.ts
new file mode 100644
index 000000000000..c899db21fe29
--- /dev/null
+++ b/apps/web/src/components/chat/threadFindHighlights.ts
@@ -0,0 +1,139 @@
+import { findThreadSearchOccurrences } from "@t3tools/shared/threadSearch";
+import { useEffect } from "react";
+import { THREAD_FIND_BLOCK_TAGS } from "@t3tools/shared/threadFindText";
+
+const THREAD_FIND_HIGHLIGHT_NAME = "t3-thread-find";
+const THREAD_FIND_ACTIVE_HIGHLIGHT_NAME = "t3-thread-find-active";
+
+const THREAD_FIND_TEXT_SELECTOR = "[data-thread-find-text]";
+const THREAD_FIND_IGNORE_SELECTOR = "[data-thread-find-ignore]";
+
+interface ThreadFindRange {
+  readonly rowId: string;
+  readonly occurrence: number;
+  readonly range: Range;
+}
+
+/** Collects visible occurrences without modifying rendered markdown. */
+function collectThreadFindRanges(container: HTMLElement, query: string): ThreadFindRange[] {
+  if (query.length === 0) return [];
+
+  const ranges: ThreadFindRange[] = [];
+  const occurrenceByRowId = new Map<string, number>();
+
+  for (const scope of container.querySelectorAll(THREAD_FIND_TEXT_SELECTOR)) {
+    if (scope.parentElement?.closest(THREAD_FIND_TEXT_SELECTOR)) continue;
+    const rowId = scope.closest("[data-timeline-row-id]")?.getAttribute("data-timeline-row-id");
+    if (!rowId) continue;
+
+    let text = "";
+    let nodes: { node: Node; start: number; end: number }[] = [];
+    const flush = () => {
+      for (const offset of findThreadSearchOccurrences(text, query)) {
+        const start = nodes.find((part) => part.end > offset);
+        const end = nodes.find((part) => part.end >= offset + query.length);
+        if (!start || !end) continue;
+        const range = container.ownerDocument.createRange();
+        range.setStart(start.node, offset - start.start);
+        range.setEnd(end.node, offset + query.length - end.start);
+        const occurrence = occurrenceByRowId.get(rowId) ?? 0;
+        ranges.push({ rowId, occurrence, range });
+        occurrenceByRowId.set(rowId, occurrence + 1);
+      }
+      text = "";
+      nodes = [];
+    };
+    const visit = (node: Node, inPre = false) => {
+      const element = node.nodeType === 1 ? (node as Element) : null;
+      if (element?.matches("svg")) return;
+      if (element?.matches(`${THREAD_FIND_IGNORE_SELECTOR}, [role="toolbar"]`)) {
+        flush();
+        return;
+      }
+      const tag = element?.tagName.toLowerCase() ?? "";
+      const block = THREAD_FIND_BLOCK_TAGS.has(tag);
+      if (block) flush();
+      if (node.nodeType === 3) {
+        const value = node.nodeValue ?? "";
+        const start = text.length;
+        text += inPre ? value : value.replace(/\n/g, " ");
+        nodes.push({ node, start, end: text.length });
+      }
+      for (const child of node.childNodes) visit(child, inPre || tag === "pre");
+      if (block) flush();
+    };
+    visit(scope);
+    flush();
+  }
+  return ranges;
+}
+
+export function useThreadFindHighlights(input: {
+  readonly container: HTMLElement | null;
+  readonly query: string;
+  readonly activeRowId: string | null;
+  readonly activeOccurrence: number;
+  readonly onActiveRange: (range: Range | null) => void;
+}): void {
+  const { container, query, activeRowId, activeOccurrence, onActiveRange } = input;
+
+  useEffect(() => {
+    if (typeof CSS === "undefined" || !CSS.highlights || typeof Highlight === "undefined") {
+      onActiveRange(null);
+      return;
+    }
+    const clearHighlights = () => {
+      CSS.highlights.delete(THREAD_FIND_HIGHLIGHT_NAME);
+      CSS.highlights.delete(THREAD_FIND_ACTIVE_HIGHLIGHT_NAME);
+    };
+    if (!container || query.length === 0) {
+      onActiveRange(null);
+      clearHighlights();
+      return;
+    }
+
+    const repaint = () => {
+      let active: Range | null = null;
+      const inactive: Range[] = [];
+      for (const match of collectThreadFindRanges(container, query)) {
+        if (
+          active === null &&
+          match.rowId === activeRowId &&
+          match.occurrence === activeOccurrence
+        ) {
+          active = match.range;
+        } else {
+          inactive.push(match.range);
+        }
+      }
+      onActiveRange(active);
+      CSS.highlights.set(THREAD_FIND_HIGHLIGHT_NAME, new Highlight(...inactive));
+      CSS.highlights.set(
+        THREAD_FIND_ACTIVE_HIGHLIGHT_NAME,
+        new Highlight(...(active ? [active] : [])),
+      );
+    };
+    repaint();
+
+    let frame: number | null = null;
+    const observer = new MutationObserver(() => {
+      if (frame !== null) return;
+      frame = requestAnimationFrame(() => {
+        frame = null;
+        repaint();
+      });
+    });
+    observer.observe(container, {
+      subtree: true,
+      childList: true,
+      characterData: true,
+      attributes: true,
+      attributeFilter: ["data-wrap"],
+    });
+    return () => {
+      observer.disconnect();
+      if (frame !== null) cancelAnimationFrame(frame);
+      clearHighlights();
+    };
+  }, [activeOccurrence, activeRowId, container, onActiveRange, query]);
+}
diff --git a/apps/web/src/components/chat/useThreadFind.test.tsx b/apps/web/src/components/chat/useThreadFind.test.tsx
new file mode 100644
index 000000000000..f6c82a294200
--- /dev/null
+++ b/apps/web/src/components/chat/useThreadFind.test.tsx
@@ -0,0 +1,176 @@
+import { act, useLayoutEffect } from "react";
+import { create, type ReactTestRenderer } from "react-test-renderer";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import {
+  EnvironmentId,
+  PlanId,
+  RunId,
+  ThreadId,
+  TurnItemId,
+  type OrchestrationV2SearchThreadInput,
+  type OrchestrationV2SearchThreadResult,
+} from "@t3tools/contracts";
+import * as DateTime from "effect/DateTime";
+import { useThreadFind } from "./useThreadFind";
+
+const queries = vi.hoisted(() => ({
+  results: new Map<string, OrchestrationV2SearchThreadResult>(),
+}));
+vi.mock("~/state/orchestration", () => ({
+  orchestrationEnvironment: {
+    threadFind: (input: {
+      environmentId: EnvironmentId;
+      input: OrchestrationV2SearchThreadInput;
+    }) => input,
+  },
+}));
+vi.mock("~/state/queries", () => ({ useDebouncedValue: <T,>(value: T) => value }));
+vi.mock("~/state/query", () => ({
+  useEnvironmentQuery: (atom: { environmentId: EnvironmentId } | null) => ({
+    data: atom === null ? null : (queries.results.get(atom.environmentId) ?? null),
+    isPending: false,
+    error: null,
+    refresh: () => {},
+  }),
+}));
+
+let renderer: ReactTestRenderer | undefined;
+let find: ReturnType<typeof useThreadFind>;
+const a = EnvironmentId.make("environment:a");
+const b = EnvironmentId.make("environment:b");
+const threadId = ThreadId.make("shared-thread");
+const runId = RunId.make("run:plan");
+const now = DateTime.makeUnsafe("2026-10-01T00:00:00Z");
+const entries: Parameters<typeof useThreadFind>[0]["entries"] = [];
+function Probe({ environmentId }: { environmentId: EnvironmentId }) {
+  const state = useThreadFind({
+    thread: { environmentId, threadId },
+    serverSearch: true,
+    cwd: "/repo",
+    content: undefined,
+    entries,
+    history: null,
+  });
+  useLayoutEffect(() => {
+    find = state;
+  });
+  return null;
+}
+beforeEach(() => {
+  vi.stubGlobal("window", new EventTarget());
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+});
+afterEach(async () => {
+  if (renderer) await act(async () => renderer?.unmount());
+  renderer = undefined;
+  queries.results.clear();
+  vi.unstubAllGlobals();
+});
+
+describe("V2 find state", () => {
+  it("derives a plan result with the timeline item ID and run ownership", async () => {
+    queries.results.set(a, {
+      snapshotSequence: 9,
+      totalMatches: 1,
+      activeIndex: 0,
+      match: { entryId: "plan-item", runId, occurrence: 0 },
+      items: [
+        {
+          position: 8,
+          sourceThreadId: threadId,
+          sourceItemId: TurnItemId.make("plan-item"),
+          visibility: "local",
+          item: {
+            id: TurnItemId.make("plan-item"),
+            threadId,
+            runId,
+            nodeId: null,
+            providerThreadId: null,
+            providerTurnId: null,
+            nativeItemRef: null,
+            parentItemId: null,
+            ordinal: 9,
+            status: "completed",
+            title: null,
+            startedAt: now,
+            completedAt: now,
+            updatedAt: now,
+            type: "proposed_plan",
+            planId: PlanId.make("plan-artifact"),
+            markdown: "# Release\nneedle",
+            streaming: false,
+          },
+        },
+      ],
+    });
+    await act(async () => {
+      renderer = create(<Probe environmentId={a} />);
+    });
+    await act(async () => {
+      find.open();
+    });
+    await act(async () => {
+      find.barProps.onQueryChange("needle");
+    });
+    expect(find.timelineProps.activeFindMatch).toEqual({
+      entryId: "plan-item",
+      runId,
+      occurrence: 0,
+    });
+    const entry = find.timelineProps.searchEntries?.[0];
+    expect(entry?.id).toBe("plan-item");
+    expect(entry?.kind).toBe("proposed-plan");
+    if (entry?.kind === "proposed-plan") {
+      expect(entry.proposedPlan.id).toBe("plan-artifact");
+      expect(entry.proposedPlan.runId).toBe(runId);
+    }
+    await act(async () => {
+      find.close();
+    });
+    expect(find.timelineProps.searchEntries).toBeNull();
+    expect(find.timelineProps.findQuery).toBe("");
+  });
+
+  it("drops results on environment changes even when the thread IDs are identical", async () => {
+    queries.results.set(a, {
+      snapshotSequence: 1,
+      totalMatches: 3,
+      activeIndex: 0,
+      match: null,
+      items: [],
+    });
+    queries.results.set(b, {
+      snapshotSequence: 2,
+      totalMatches: 0,
+      activeIndex: 0,
+      match: null,
+      items: [],
+    });
+    await act(async () => {
+      renderer = create(<Probe environmentId={a} />);
+    });
+    await act(async () => {
+      find.open();
+    });
+    await act(async () => {
+      find.barProps.onQueryChange("needle");
+    });
+    expect(find.barProps.matchCount).toBe(3);
+    await act(async () => {
+      renderer?.update(<Probe environmentId={b} />);
+    });
+    expect(find.isOpen).toBe(false);
+    expect(find.timelineProps.searchEntries).toBeNull();
+    await act(async () => {
+      find.open();
+    });
+    await act(async () => {
+      find.barProps.onQueryChange("needle");
+    });
+    expect(find.barProps.matchCount).toBe(0);
+    await act(async () => {
+      renderer?.update(<Probe environmentId={a} />);
+    });
+    expect(find.isOpen).toBe(false);
+  });
+});
diff --git a/apps/web/src/components/chat/useThreadFind.ts b/apps/web/src/components/chat/useThreadFind.ts
new file mode 100644
index 000000000000..cd9abeadcc7e
--- /dev/null
+++ b/apps/web/src/components/chat/useThreadFind.ts
@@ -0,0 +1,179 @@
+import type { OrchestrationV2ThreadProjection, ScopedThreadRef } from "@t3tools/contracts";
+import { scopedThreadKey } from "@t3tools/client-runtime/environment";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { deriveTimelineEntriesFromVisibleTurnItems, type TimelineEntry } from "~/session-logic";
+import { orchestrationEnvironment } from "~/state/orchestration";
+import { useEnvironmentQuery } from "~/state/query";
+import { useDebouncedValue } from "~/state/queries";
+import { buildThreadFindMatches, clampThreadFindIndex, stepThreadFindIndex } from "./threadFind";
+import { subscribeThreadFindOpen } from "./threadFindActionBus";
+import { useThreadFindHistory } from "./useThreadFindHistory";
+
+const CLOSED_FIND = {
+  threadKey: null as string | null,
+  query: "",
+  activeIndex: 0,
+  focusRequestId: 0,
+  navigationId: 0,
+};
+
+/** Owns find state and presents the same controls for server search and older-server history. */
+export function useThreadFind({
+  thread,
+  serverSearch,
+  cwd,
+  content,
+  entries,
+  history,
+}: {
+  thread: ScopedThreadRef | null;
+  serverSearch: boolean;
+  cwd: string | undefined;
+  content: Pick<OrchestrationV2ThreadProjection, "visibleTurnItems" | "runs"> | undefined;
+  entries: ReadonlyArray<TimelineEntry>;
+  history: Parameters<typeof useThreadFindHistory>[1];
+}) {
+  const threadKey = thread ? scopedThreadKey(thread) : null;
+  const [state, setState] = useState(CLOSED_FIND);
+  if (state.threadKey !== null && state.threadKey !== threadKey) setState(CLOSED_FIND);
+  const isOpen = threadKey !== null && state.threadKey === threadKey;
+  const open = useCallback(() => {
+    if (threadKey === null) return;
+    setState((previous) => ({
+      ...(previous.threadKey === threadKey ? previous : CLOSED_FIND),
+      threadKey,
+      focusRequestId: previous.focusRequestId + 1,
+    }));
+  }, [threadKey]);
+  const close = useCallback(() => setState(CLOSED_FIND), []);
+  useEffect(() => subscribeThreadFindOpen(open), [open]);
+
+  const remote = useServerResults(
+    serverSearch && isOpen ? thread : null,
+    state.query,
+    state.activeIndex,
+    content,
+  );
+  const localStatus = useThreadFindHistory(
+    !serverSearch && isOpen && state.query.trim() ? `${threadKey}:${state.focusRequestId}` : null,
+    history,
+  );
+  let status: "loading" | "incomplete" | "error" | null = localStatus;
+  if (serverSearch) {
+    status = null;
+    if (remote.isPending) status = "loading";
+    if (remote.error) status = "error";
+  }
+  const localMatches = useMemo(
+    () =>
+      buildThreadFindMatches(
+        entries,
+        !serverSearch && isOpen && status !== "loading" ? state.query : "",
+        cwd,
+      ),
+    [cwd, entries, isOpen, serverSearch, state.query, status],
+  );
+  const count = serverSearch ? (remote.data?.totalMatches ?? 0) : localMatches.length;
+  const activeIndex = serverSearch
+    ? (remote.data?.activeIndex ?? 0)
+    : clampThreadFindIndex(state.activeIndex, count);
+  const searchEntries = useMemo(
+    () =>
+      remote.data?.match
+        ? deriveTimelineEntriesFromVisibleTurnItems({
+            visibleTurnItems: remote.data.items,
+            optimisticMessages: [],
+          })
+        : null,
+    [remote.data],
+  );
+  const selected = remote.data?.match;
+  const activeMatch = serverSearch
+    ? selected && {
+        entryId: selected.entryId,
+        runId: selected.runId,
+        occurrence: selected.occurrence,
+      }
+    : localMatches[activeIndex];
+  const step = (delta: number) =>
+    setState((previous) => ({
+      ...previous,
+      activeIndex: stepThreadFindIndex(previous.activeIndex, count, delta),
+      navigationId: previous.navigationId + 1,
+    }));
+
+  return {
+    isOpen,
+    open,
+    close,
+    barProps: {
+      open: isOpen,
+      query: state.query,
+      matchCount: count,
+      activeIndex,
+      historyState: status,
+      focusRequestId: state.focusRequestId,
+      onRetryHistory: serverSearch ? remote.refresh : open,
+      onQueryChange: (query: string) =>
+        setState((previous) => ({ ...previous, query, activeIndex: 0 })),
+      onNext: () => step(1),
+      onPrevious: () => step(-1),
+      onClose: close,
+    },
+    timelineProps: {
+      searchEntries,
+      onCloseSearch: close,
+      findQuery: isOpen && (!serverSearch || searchEntries !== null) ? state.query : "",
+      activeFindMatch: activeMatch ?? null,
+      findNavigationId: state.navigationId,
+    },
+  };
+}
+
+/** Query atoms cancel obsolete requests; navigation retains only the current query's result. */
+function useServerResults(
+  thread: ScopedThreadRef | null,
+  query: string,
+  index: number,
+  content: Pick<OrchestrationV2ThreadProjection, "visibleTurnItems" | "runs"> | undefined,
+) {
+  const normalizedQuery = query.trim();
+  const debouncedQuery = useDebouncedValue(normalizedQuery, 200);
+  const atom =
+    thread && debouncedQuery && normalizedQuery === debouncedQuery
+      ? orchestrationEnvironment.threadFind({
+          environmentId: thread.environmentId,
+          input: { threadId: thread.threadId, query: debouncedQuery, index },
+        })
+      : null;
+  const result = useEnvironmentQuery(atom);
+  const { refresh } = result;
+  const messages = content?.visibleTurnItems;
+  const plans = content?.runs;
+  const revision = useMemo(() => ({ messages, plans }), [messages, plans]);
+  const settledRevision = useDebouncedValue(revision, 300);
+  const lastRevision = useRef(settledRevision);
+  useEffect(() => {
+    if (lastRevision.current === settledRevision) return;
+    lastRevision.current = settledRevision;
+    if (atom !== null) refresh();
+  }, [atom, refresh, settledRevision]);
+  const key = thread
+    ? JSON.stringify([thread.environmentId, thread.threadId, normalizedQuery])
+    : null;
+  const [previous, setPrevious] = useState({ key, data: result.data });
+  if (
+    previous.key !== key ||
+    (result.data !== null && !result.isPending && previous.data !== result.data)
+  ) {
+    setPrevious({ key, data: result.data });
+  }
+  return {
+    ...result,
+    data: key === previous.key && !result.error ? (result.data ?? previous.data) : null,
+    isPending:
+      thread !== null &&
+      normalizedQuery.length > 0 &&
+      (normalizedQuery !== debouncedQuery || result.isPending),
+  };
+}
diff --git a/apps/web/src/components/chat/useThreadFindHistory.test.tsx b/apps/web/src/components/chat/useThreadFindHistory.test.tsx
new file mode 100644
index 000000000000..20ea1b30a48a
--- /dev/null
+++ b/apps/web/src/components/chat/useThreadFindHistory.test.tsx
@@ -0,0 +1,104 @@
+import { act, StrictMode, useLayoutEffect } from "react";
+import { create, type ReactTestRenderer } from "react-test-renderer";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import { useThreadFindHistory } from "./useThreadFindHistory";
+
+type CitationHistoryPage = NonNullable<Parameters<typeof useThreadFindHistory>[1]>;
+
+let renderer: ReactTestRenderer;
+let status: ReturnType<typeof useThreadFindHistory>;
+
+function Probe({
+  requestKey,
+  page,
+}: {
+  requestKey: string | null;
+  page: CitationHistoryPage | null;
+}) {
+  const value = useThreadFindHistory(requestKey, page);
+  useLayoutEffect(() => {
+    status = value;
+  }, [value]);
+  return null;
+}
+
+async function render(requestKey: string | null, page: CitationHistoryPage | null) {
+  await act(() => {
+    renderer.update(
+      <StrictMode>
+        <Probe requestKey={requestKey} page={page} />
+      </StrictMode>,
+    );
+  });
+}
+
+beforeEach(async () => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  await act(() => {
+    renderer = create(
+      <StrictMode>
+        <Probe requestKey={null} page={null} />
+      </StrictMode>,
+    );
+  });
+});
+
+afterEach(async () => {
+  await act(() => renderer.unmount());
+  vi.unstubAllGlobals();
+});
+
+describe("thread find history loading", () => {
+  it("loads sequential pages without duplicate requests and finishes only at the oldest page", async () => {
+    const load = vi.fn(() => true);
+    const page = { cursor: "recent", loading: false, onLoadEarlier: load };
+    await render("thread:1", page);
+    await render("thread:1", { ...page });
+    expect(load).toHaveBeenCalledTimes(1);
+    expect(status).toBe("loading");
+
+    await render("thread:1", { ...page, loading: true });
+    expect(status).toBe("loading");
+    expect(load).toHaveBeenCalledTimes(1);
+
+    await render("thread:1", { ...page, cursor: "older" });
+    expect(load).toHaveBeenCalledTimes(2);
+    expect(status).not.toBeNull();
+    await render("thread:1", null);
+    expect(status).toBeNull();
+  });
+
+  it("does not loop on a failed page and allows an explicit retry", async () => {
+    const load = vi.fn(() => true);
+    const page = { cursor: "recent", loading: false, onLoadEarlier: load };
+    await render("thread:1", page);
+    await render("thread:1", { ...page, loading: true });
+    await render("thread:1", { ...page });
+    expect(status).toBe("incomplete");
+    expect(load).toHaveBeenCalledTimes(1);
+
+    await render("thread:2", page);
+    expect(load).toHaveBeenCalledTimes(2);
+  });
+
+  it("offers retry if the thread cannot start a history request", async () => {
+    const load = vi.fn(() => false);
+    await render("thread:1", { cursor: "recent", loading: false, onLoadEarlier: load });
+    expect(status).toBe("incomplete");
+    expect(load).toHaveBeenCalledTimes(1);
+  });
+
+  it("stops when find closes or the query clears, and isolates requests between threads", async () => {
+    const load = vi.fn(() => true);
+    const page = { cursor: "recent", loading: false, onLoadEarlier: load };
+    await render(null, page);
+    expect(load).not.toHaveBeenCalled();
+    await render("thread-a:1", page);
+    await render(null, { ...page, cursor: "older" });
+    expect(load).toHaveBeenCalledTimes(1);
+    expect(status).toBeNull();
+
+    await render("thread-b:1", page);
+    expect(load).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/apps/web/src/components/chat/useThreadFindHistory.ts b/apps/web/src/components/chat/useThreadFindHistory.ts
new file mode 100644
index 000000000000..2b4bd3b0b41a
--- /dev/null
+++ b/apps/web/src/components/chat/useThreadFindHistory.ts
@@ -0,0 +1,42 @@
+import { useEffect, useRef, useState } from "react";
+import type { CitationHistoryPage } from "./useAssistantCitationTarget";
+
+type FindHistoryPage = Omit<CitationHistoryPage, "onLoadEarlier"> & {
+  readonly onLoadEarlier: () => boolean;
+};
+
+/** Search needs every history page, but leaves row mounting to the virtual list. */
+export function useThreadFindHistory(
+  requestKey: string | null,
+  page: FindHistoryPage | null,
+): "loading" | "incomplete" | null {
+  const requested = useRef<{ key: string; cursors: Set<string>; loading: boolean } | null>(null);
+  const [failedKey, setFailedKey] = useState<string | null>(null);
+  if (requestKey === null && failedKey !== null) setFailedKey(null);
+
+  useEffect(() => {
+    if (requestKey === null) {
+      requested.current = null;
+      return;
+    }
+    if (requested.current?.key !== requestKey) {
+      requested.current = { key: requestKey, cursors: new Set(), loading: false };
+    }
+    const wasLoading = requested.current.loading;
+    requested.current.loading = page?.loading ?? false;
+    if (!page || page.loading || failedKey === requestKey) return;
+
+    const cursor = page.cursor ?? "first";
+    // StrictMode replay is not a failed request. Only a completed fetch that
+    // leaves the cursor unchanged needs a manual retry.
+    if (requested.current.cursors.has(cursor)) {
+      if (wasLoading) setFailedKey(requestKey);
+      return;
+    }
+    requested.current.cursors.add(cursor);
+    if (!page.onLoadEarlier()) setFailedKey(requestKey);
+  }, [failedKey, page, requestKey]);
+
+  if (requestKey === null || page === null) return null;
+  return failedKey === requestKey ? "incomplete" : "loading";
+}
diff --git a/apps/web/src/components/files/FileBreadcrumbs.tsx b/apps/web/src/components/files/FileBreadcrumbs.tsx
index a98b4dca69d2..d6ac3f594e94 100644
--- a/apps/web/src/components/files/FileBreadcrumbs.tsx
+++ b/apps/web/src/components/files/FileBreadcrumbs.tsx
@@ -19,7 +19,7 @@ import { Tooltip, TooltipPopup, TooltipTrigger } from "~/components/ui/tooltip";
 import { useTheme } from "~/hooks/useTheme";
 import { useWorkspaceMutationRefresh } from "~/hooks/useWorkspaceMutationRefresh";
 import { cn } from "~/lib/utils";
-import { isAbsolutePath } from "~/terminal-links";
+import { isAbsolutePath } from "@t3tools/shared/path";
 
 import {
   type FileBreadcrumb,
diff --git a/apps/web/src/components/files/FileMarkdownPreview.tsx b/apps/web/src/components/files/FileMarkdownPreview.tsx
index e36ada48acb8..2d4fd14e4b6e 100644
--- a/apps/web/src/components/files/FileMarkdownPreview.tsx
+++ b/apps/web/src/components/files/FileMarkdownPreview.tsx
@@ -1,7 +1,7 @@
 import type { ScopedThreadRef } from "@t3tools/contracts";
 
 import ChatMarkdown from "~/components/ChatMarkdown";
-import { resolvePathLinkTarget } from "~/terminal-links";
+import { resolvePathLinkTarget } from "@t3tools/shared/fileLinks";
 
 export function FileMarkdownPreview(props: {
   readonly cwd: string;
diff --git a/apps/web/src/components/files/FilePreviewPanel.tsx b/apps/web/src/components/files/FilePreviewPanel.tsx
index 6692417adc69..1dbd9f0ea340 100644
--- a/apps/web/src/components/files/FilePreviewPanel.tsx
+++ b/apps/web/src/components/files/FilePreviewPanel.tsx
@@ -57,7 +57,8 @@ import { resolveDiffThemeName } from "~/lib/diffRendering";
 import { PREFERRED_HIGHLIGHTER } from "~/lib/syntaxHighlighting";
 import { cn } from "~/lib/utils";
 import type { ChatFileAttachment } from "~/types";
-import { isAbsolutePath, resolvePathLinkTarget } from "~/terminal-links";
+import { isAbsolutePath } from "@t3tools/shared/path";
+import { resolvePathLinkTarget } from "@t3tools/shared/fileLinks";
 import { ScrollArea } from "~/components/ui/scroll-area";
 import { stackedThreadToast, toastManager } from "~/components/ui/toast";
 import { type DraftId, useComposerDraftStore } from "~/composerDraftStore";
diff --git a/apps/web/src/components/files/filePath.ts b/apps/web/src/components/files/filePath.ts
index e819315310b8..aa6225381be8 100644
--- a/apps/web/src/components/files/filePath.ts
+++ b/apps/web/src/components/files/filePath.ts
@@ -1,7 +1,5 @@
 import type { ProjectEntry } from "@t3tools/contracts";
-import { isWindowsAbsolutePath } from "@t3tools/shared/path";
-
-import { isAbsolutePath } from "~/terminal-links";
+import { isWindowsAbsolutePath, isAbsolutePath } from "@t3tools/shared/path";
 
 export interface FileBreadcrumb {
   label: string;
diff --git a/apps/web/src/components/files/filePreviewMode.ts b/apps/web/src/components/files/filePreviewMode.ts
index 764d44bfd83d..151855404ddc 100644
--- a/apps/web/src/components/files/filePreviewMode.ts
+++ b/apps/web/src/components/files/filePreviewMode.ts
@@ -1,6 +1,5 @@
-import { workspaceRelativeFilePath } from "@t3tools/client-runtime/markdown-links";
 import type { ProjectReadFileError } from "@t3tools/contracts";
-import { isAbsolutePath } from "~/terminal-links";
+import { isAbsolutePath, workspaceRelativeFilePath } from "@t3tools/shared/path";
 
 /** Resolve workspace links before choosing between the explorer and a file preview. */
 export function resolveFilePreviewPath(path: string | null, cwd: string): string | null {
diff --git a/apps/web/src/components/settings/ThemeEditorPanel.tsx b/apps/web/src/components/settings/ThemeEditorPanel.tsx
index 27176181768e..63482a22a105 100644
--- a/apps/web/src/components/settings/ThemeEditorPanel.tsx
+++ b/apps/web/src/components/settings/ThemeEditorPanel.tsx
@@ -162,6 +162,24 @@ const THEME_EDITOR_ROLE_GROUPS: ReadonlyArray<{
       },
     ],
   },
+  {
+    id: "search",
+    title: "Search",
+    families: [
+      {
+        id: "search-matches",
+        label: "Search matches",
+        role: "searchMatchBackground",
+        roles: ["searchMatchBackground", "searchMatchForeground"],
+      },
+      {
+        id: "current-match",
+        label: "Current match",
+        role: "searchMatchActiveBackground",
+        roles: ["searchMatchActiveBackground", "searchMatchActiveForeground"],
+      },
+    ],
+  },
   {
     id: "context",
     title: "Context",
diff --git a/apps/web/src/components/ui/input-group.tsx b/apps/web/src/components/ui/input-group.tsx
index 9a9228ede61d..45d4b42446c9 100644
--- a/apps/web/src/components/ui/input-group.tsx
+++ b/apps/web/src/components/ui/input-group.tsx
@@ -11,11 +11,17 @@ const inputGroupVariants = cva(
   {
     defaultVariants: {
       variant: "default",
+      size: "default",
     },
     variants: {
+      size: {
+        default: null,
+        lg: "h-9",
+      },
       variant: {
         default:
           "border-input bg-background not-dark:bg-clip-padding shadow-xs/5 before:pointer-events-none before:absolute before:inset-0 before:rounded-[calc(var(--control-radius)-1px)] not-has-[input:disabled,textarea:disabled]:not-has-[input:focus-visible,textarea:focus-visible]:not-has-[input[aria-invalid],textarea[aria-invalid]]:before:shadow-[0_1px_--theme(--color-black/4%)] dark:bg-input/32 dark:not-has-[input:disabled,textarea:disabled]:not-has-[input:focus-visible,textarea:focus-visible]:not-has-[input[aria-invalid],textarea[aria-invalid]]:before:shadow-[0_-1px_--theme(--color-white/6%)]",
+        popover: "border-input bg-popover shadow-sm",
         ghost:
           "border-transparent bg-transparent shadow-none hover:bg-muted/40 has-[input:focus-visible,textarea:focus-visible]:bg-background",
       },
@@ -26,11 +32,12 @@ const inputGroupVariants = cva(
 function InputGroup({
   className,
   variant,
+  size,
   ...props
 }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupVariants>) {
   return (
     <div
-      className={cn(inputGroupVariants({ variant }), className)}
+      className={cn(inputGroupVariants({ variant, size }), className)}
       data-slot="input-group"
       role="group"
       {...props}
diff --git a/apps/web/src/diffFileActions.ts b/apps/web/src/diffFileActions.ts
index 3ac22c28cf25..99baf13c9416 100644
--- a/apps/web/src/diffFileActions.ts
+++ b/apps/web/src/diffFileActions.ts
@@ -2,7 +2,7 @@ import type { ScopedThreadRef } from "@t3tools/contracts";
 import { isWindowsAbsolutePath, normalizeProjectPathForComparison } from "@t3tools/shared/path";
 
 import { useRightPanelStore } from "./rightPanelStore";
-import { resolvePathLinkTarget } from "./terminal-links";
+import { resolvePathLinkTarget } from "@t3tools/shared/fileLinks";
 
 interface OpenDiffFilePrimaryActionInput {
   readonly threadRef: ScopedThreadRef | null;
diff --git a/apps/web/src/fileContextMenu.ts b/apps/web/src/fileContextMenu.ts
index 05425f205955..3035f5825ac3 100644
--- a/apps/web/src/fileContextMenu.ts
+++ b/apps/web/src/fileContextMenu.ts
@@ -22,7 +22,7 @@ import { readLocalApi } from "./localApi";
 import { serverEnvironment } from "./state/server";
 import { shellEnvironment } from "./state/shell";
 import { useAtomCommand } from "./state/use-atom-command";
-import { resolvePathLinkTarget } from "./terminal-links";
+import { resolvePathLinkTarget } from "@t3tools/shared/fileLinks";
 import { toastManager } from "./components/ui/toast";
 import { useAtomValue } from "@effect/atom-react";
 
diff --git a/apps/web/src/filePathDisplay.ts b/apps/web/src/filePathDisplay.ts
index 36f5873cf8e0..7fee707bf4c0 100644
--- a/apps/web/src/filePathDisplay.ts
+++ b/apps/web/src/filePathDisplay.ts
@@ -1,10 +1,9 @@
 import {
   fileBasename,
-  formatFilePathPosition,
-  splitFilePathPosition,
   stripSlashPrefixedWindowsDrive,
-} from "@t3tools/client-runtime/markdown-links";
-import { isWindowsAbsolutePath } from "@t3tools/shared/path";
+  isWindowsAbsolutePath,
+} from "@t3tools/shared/path";
+import { formatFilePathPosition, splitFilePathPosition } from "@t3tools/shared/fileLinks";
 
 function normalizePathSeparators(path: string): string {
   return path.replaceAll("\\", "/");
diff --git a/apps/web/src/index.css b/apps/web/src/index.css
index 46b57325a3ff..da330a2e1f31 100644
--- a/apps/web/src/index.css
+++ b/apps/web/src/index.css
@@ -373,6 +373,20 @@ html[data-mobile-composer-route-transition="true"]::view-transition-old(t3-mobil
   }
 }
 
+/* Paint find results without changing rendered markdown or copied text. */
+::highlight(t3-thread-find) {
+  color: var(--app-theme-search-match-foreground, var(--color-foreground));
+  background-color: var(--app-theme-search-match-background, oklch(0.826487 0.157967 78.604 / 0.3));
+}
+
+::highlight(t3-thread-find-active) {
+  color: var(--app-theme-search-match-active-foreground, oklch(0.216164 0.028283 77.423));
+  background-color: var(
+    --app-theme-search-match-active-background,
+    oklch(0.774202 0.151946 74.331)
+  );
+}
+
 @utility dialog-glass {
   background: color-mix(in srgb, var(--background) var(--glass-opacity), transparent);
   -webkit-backdrop-filter: blur(var(--glass-blur)) saturate(var(--glass-saturation));
diff --git a/apps/web/src/keybindings.test.ts b/apps/web/src/keybindings.test.ts
index 811d9101cbc7..73b1fa8fc00c 100644
--- a/apps/web/src/keybindings.test.ts
+++ b/apps/web/src/keybindings.test.ts
@@ -142,6 +142,14 @@ const DEFAULT_BINDINGS = compile([
     shortcut: modShortcut("t", { altKey: true, shiftKey: true }),
     command: "themeEditor.toggle",
   },
+  {
+    shortcut: modShortcut("f"),
+    command: "chat.find",
+    whenAst: whenAnd(
+      whenNot(whenIdentifier("terminalFocus")),
+      whenNot(whenIdentifier("previewFocus")),
+    ),
+  },
   {
     shortcut: modShortcut("m", { shiftKey: true }),
     command: "modelPicker.toggle",
diff --git a/apps/web/src/markdown-incremental.test.tsx b/apps/web/src/markdown-incremental.test.tsx
index cf06355f3b49..3682deb281fa 100644
--- a/apps/web/src/markdown-incremental.test.tsx
+++ b/apps/web/src/markdown-incremental.test.tsx
@@ -1,16 +1,15 @@
+import { CHAT_MARKDOWN_REHYPE_PLUGINS } from "@t3tools/shared/markdownPipeline";
 import type { Root } from "mdast";
 import { renderToStaticMarkup } from "react-dom/server";
 import ReactMarkdown from "react-markdown";
-import rehypeRaw from "rehype-raw";
-import rehypeSanitize from "rehype-sanitize";
 import remarkGfm from "remark-gfm";
 import type { Plugin } from "unified";
 import { describe, expect, it } from "vite-plus/test";
 
-import { remarkCodexDirectives } from "@t3tools/client-runtime/codex-markdown-directives";
-import { remarkGithubAlerts } from "./markdown-github-alerts";
+import { remarkCodexDirectives } from "@t3tools/shared/codexMarkdownDirectives";
+import { remarkGithubAlerts } from "@t3tools/shared/markdownGithubAlerts";
 import { createIncrementalMarkdownPlugin } from "./markdown-incremental";
-import { remarkNormalizeListItemIndentation } from "./markdown-list-indentation";
+import { remarkNormalizeListItemIndentation } from "@t3tools/shared/markdownListIndentation";
 
 function render(source: string, incremental?: Plugin<[], Root>, parsedSources?: string[]) {
   let tree: Root | undefined;
@@ -37,7 +36,7 @@ function render(source: string, incremental?: Plugin<[], Root>, parsedSources?:
         remarkCodexDirectives,
         ...(incremental ? [incremental] : []),
       ]}
-      rehypePlugins={[rehypeRaw, rehypeSanitize]}
+      rehypePlugins={CHAT_MARKDOWN_REHYPE_PLUGINS}
     >
       {source}
     </ReactMarkdown>,
diff --git a/apps/web/src/markdown-links.test.ts b/apps/web/src/markdown-links.test.ts
index fe352ec1a44e..a8e01e834c7a 100644
--- a/apps/web/src/markdown-links.test.ts
+++ b/apps/web/src/markdown-links.test.ts
@@ -1,66 +1,13 @@
 import { describe, expect, it } from "vite-plus/test";
-import { createElement } from "react";
-import { renderToStaticMarkup } from "react-dom/server";
-import ReactMarkdown from "react-markdown";
 
 import {
-  extractMarkdownLinkHrefs,
-  isWindowsDrivePathHref,
   resolveInlineCodeFileLinkMeta,
   resolveMarkdownFileLinkMeta,
-  resolveMarkdownFileLinkTarget,
   rewriteMarkdownFileUriHref,
   shouldOpenMarkdownFileLinkInBrowserByDefault,
   shouldOpenMarkdownFileLinkInEditor,
 } from "./markdown-links";
 
-describe("isWindowsDrivePathHref", () => {
-  it.each([
-    ["C:\\repo\\image.png", true],
-    ["C:%5Crepo%5Cimage.png", true],
-    ["https://example.com/image.png", false],
-  ])("classifies %s as %s", (href, expected) => {
-    expect(isWindowsDrivePathHref(href)).toBe(expected);
-  });
-});
-
-function renderMarkdownLinkHref(markdown: string): string | undefined {
-  let renderedHref: string | undefined;
-  renderToStaticMarkup(
-    createElement(
-      ReactMarkdown,
-      {
-        components: {
-          a({ href }) {
-            renderedHref = href;
-            return createElement("a", { href });
-          },
-        },
-      },
-      markdown,
-    ),
-  );
-  return renderedHref;
-}
-
-describe("extractMarkdownLinkHrefs", () => {
-  it("extracts angle-bracketed paths containing spaces", () => {
-    expect(
-      extractMarkdownLinkHrefs(
-        "[Open the Bike Receipts folder](</Users/dara/Downloads/Lime Ride Artifacts/Bike Receipts>)",
-      ),
-    ).toEqual(["/Users/dara/Downloads/Lime Ride Artifacts/Bike Receipts"]);
-  });
-
-  it("preserves ordinary destinations and ignores link titles", () => {
-    expect(
-      extractMarkdownLinkHrefs(
-        '[source](apps/web/src/markdown-links.ts "implementation") and [docs](https://example.com)',
-      ),
-    ).toEqual(["apps/web/src/markdown-links.ts", "https://example.com"]);
-  });
-});
-
 describe("shouldOpenMarkdownFileLinkInEditor", () => {
   it("uses command-click on macOS", () => {
     expect(shouldOpenMarkdownFileLinkInEditor({ metaKey: true, ctrlKey: false }, "MacIntel")).toBe(
@@ -130,213 +77,6 @@ describe("rewriteMarkdownFileUriHref", () => {
   });
 });
 
-describe("resolveMarkdownFileLinkTarget", () => {
-  it("resolves absolute posix file paths", () => {
-    expect(resolveMarkdownFileLinkTarget("/Users/julius/project/AGENTS.md")).toBe(
-      "/Users/julius/project/AGENTS.md",
-    );
-  });
-
-  it("resolves relative file paths against cwd", () => {
-    expect(resolveMarkdownFileLinkTarget("src/processRunner.ts:71", "/Users/julius/project")).toBe(
-      "/Users/julius/project/src/processRunner.ts:71",
-    );
-  });
-
-  it("does not treat filename line references as external schemes", () => {
-    expect(resolveMarkdownFileLinkTarget("script.ts:10", "/Users/julius/project")).toBe(
-      "/Users/julius/project/script.ts:10",
-    );
-  });
-
-  it("resolves bare file names against cwd", () => {
-    expect(resolveMarkdownFileLinkTarget("AGENTS.md", "/Users/julius/project")).toBe(
-      "/Users/julius/project/AGENTS.md",
-    );
-  });
-
-  it("maps #L line anchors to editor line suffixes", () => {
-    expect(resolveMarkdownFileLinkTarget("/Users/julius/project/src/main.ts#L42C7")).toBe(
-      "/Users/julius/project/src/main.ts:42:7",
-    );
-  });
-
-  it("ignores external urls", () => {
-    expect(resolveMarkdownFileLinkTarget("https://example.com/docs")).toBeNull();
-    expect(resolveMarkdownFileLinkTarget("//cdn.example.com/clip.mp4", "/workspace")).toBeNull();
-  });
-
-  it("does not double-decode file URLs", () => {
-    expect(resolveMarkdownFileLinkTarget("file:///Users/julius/project/file%2520name.md")).toBe(
-      "/Users/julius/project/file%20name.md",
-    );
-  });
-
-  it("resolves file uri authorities as windows UNC paths", () => {
-    expect(resolveMarkdownFileLinkTarget("file://server/share/workspace-image.svg")).toBe(
-      "\\\\server\\share\\workspace-image.svg",
-    );
-  });
-
-  it("resolves a localhost file uri as a local path", () => {
-    expect(resolveMarkdownFileLinkTarget("file://localhost/home/me/notes.md")).toBe(
-      "/home/me/notes.md",
-    );
-  });
-
-  it("formats tooltip display paths relative to the cwd when possible", () => {
-    expect(
-      resolveMarkdownFileLinkMeta(
-        "file:///C:/Users/mike/dev-stuff/t3code/apps/web/src/session-logic.ts#L501",
-        "C:/Users/mike/dev-stuff/t3code",
-      ),
-    ).toMatchObject({
-      displayPath: "t3code/apps/web/src/session-logic.ts:501",
-      workspaceRelativePath: "apps/web/src/session-logic.ts",
-    });
-  });
-
-  it("resolves the encoded spaces emitted by the markdown renderer", () => {
-    expect(
-      resolveMarkdownFileLinkMeta(
-        "/Users/dara/Downloads/Lime%20Ride%20Artifacts/Bike%20Receipts",
-        "/Users/dara/Downloads/Lime Ride Artifacts",
-      ),
-    ).toMatchObject({
-      targetPath: "/Users/dara/Downloads/Lime Ride Artifacts/Bike Receipts",
-      workspaceRelativePath: "Bike Receipts",
-      basename: "Bike Receipts",
-    });
-  });
-
-  it("resolves relative spaced folders from the markdown renderer", () => {
-    const href = renderMarkdownLinkHref("[folder](<docs/My Folder>)");
-
-    expect(href).toBe("docs/My%20Folder");
-    expect(resolveMarkdownFileLinkMeta(href, "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/repo/project")).toMatchObject({
-      targetPath: "/repo/project/docs/My Folder",
-      workspaceRelativePath: "docs/My Folder",
-      basename: "My Folder",
-    });
-  });
-
-  it.each(["md", "html", "xml"])(
-    "resolves a bare spaced .%s filename from the markdown renderer",
-    (extension) => {
-      const href = renderMarkdownLinkHref(`[checklist](<Updated cutover checklist.${extension}>)`);
-
-      expect(href).toBe(`Updated%20cutover%20checklist.${extension}`);
-      expect(resolveMarkdownFileLinkMeta(href, "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/repo/project")).toMatchObject({
-        targetPath: `/repo/project/Updated cutover checklist.${extension}`,
-        workspaceRelativePath: `Updated cutover checklist.${extension}`,
-        basename: `Updated cutover checklist.${extension}`,
-      });
-    },
-  );
-
-  it("formats tooltip display paths relative to the cwd for slash-prefixed windows paths", () => {
-    expect(
-      resolveMarkdownFileLinkMeta(
-        "/C:/Users/mike/dev-stuff/t3code/apps/web/src/components/chat/MessagesTimeline.virtualization.browser.tsx",
-        "C:/Users/mike/dev-stuff/t3code",
-      ),
-    ).toMatchObject({
-      displayPath:
-        "t3code/apps/web/src/components/chat/MessagesTimeline.virtualization.browser.tsx",
-      workspaceRelativePath:
-        "apps/web/src/components/chat/MessagesTimeline.virtualization.browser.tsx",
-    });
-  });
-
-  it("does not create a preview path for files outside the workspace", () => {
-    expect(resolveMarkdownFileLinkMeta("/tmp/report.ts", "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/repo/project")).toMatchObject({
-      workspaceRelativePath: null,
-    });
-  });
-
-  it("does not classify a case-distinct POSIX sibling as a workspace file", () => {
-    expect(
-      resolveMarkdownFileLinkMeta(
-        "/tmp/t3code-case-test/project/probe.txt",
-        "/tmp/t3code-case-test/Project",
-      ),
-    ).toMatchObject({
-      displayPath: "/tmp/t3code-case-test/project/probe.txt",
-      workspaceRelativePath: null,
-    });
-  });
-
-  it("keeps Windows workspace comparisons case-insensitive", () => {
-    expect(
-      resolveMarkdownFileLinkMeta("C:/Users/MIKE/Project/src/main.ts", "c:/users/mike/project"),
-    ).toMatchObject({
-      displayPath: "project/src/main.ts",
-      workspaceRelativePath: "src/main.ts",
-    });
-  });
-
-  it("keeps drive-root workspace comparisons case-insensitive", () => {
-    expect(resolveMarkdownFileLinkMeta("C:/Users/MIKE/project.ts", "c:/")).toMatchObject({
-      displayPath: "c:/Users/MIKE/project.ts",
-      workspaceRelativePath: "Users/MIKE/project.ts",
-    });
-  });
-
-  it("keeps backslash UNC workspace comparisons case-insensitive", () => {
-    expect(
-      resolveMarkdownFileLinkMeta(
-        "\\\\server\\share\\PROJECT\\src\\main.ts",
-        "\\\\Server\\Share\\Project",
-      ),
-    ).toMatchObject({
-      displayPath: "Project/src/main.ts",
-      workspaceRelativePath: "src/main.ts",
-    });
-  });
-
-  it.each([
-    ["/tmp/repo/file.ts", "/", "tmp/repo/file.ts"],
-    ["C:/Users/MIKE/file.ts", "c:/", "Users/MIKE/file.ts"],
-    ["\\\\server\\SHARE\\file.ts", "\\\\Server\\Share\\", "file.ts"],
-    ["/tmp/repo/file.ts%20", "/tmp/repo", "file.ts "],
-  ])("preserves the preview target for %s in workspace %s", (href, cwd, workspaceRelativePath) => {
-    expect(resolveMarkdownFileLinkMeta(href, cwd)).toMatchObject({ workspaceRelativePath });
-  });
-
-  it("keeps an encoded final space in the absolute target", () => {
-    expect(resolveMarkdownFileLinkTarget("/tmp/repo/file.ts%20", "/tmp/repo")).toBe(
-      "/tmp/repo/file.ts ",
-    );
-  });
-
-  it("normalizes slash-prefixed windows drive paths before resolving", () => {
-    expect(
-      resolveMarkdownFileLinkTarget(
-        "/D:/Programme/t3code/apps/web/src/components/chat/OpenInPicker.tsx#L69",
-      ),
-    ).toBe("D:/Programme/t3code/apps/web/src/components/chat/OpenInPicker.tsx:69");
-  });
-
-  it("resolves angle-bracketed windows drive paths", () => {
-    expect(
-      resolveMarkdownFileLinkTarget(
-        "</D:/Programme/t3code/apps/web/src/components/ChatMarkdown.tsx:1>",
-      ),
-    ).toBe("D:/Programme/t3code/apps/web/src/components/ChatMarkdown.tsx:1");
-  });
-
-  it("does not treat app routes as file links, even with a line anchor", () => {
-    expect(resolveMarkdownFileLinkTarget("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/chat/settings")).toBeNull();
-    expect(resolveMarkdownFileLinkTarget("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/chat/settings#L3", "/repo")).toBeNull();
-  });
-
-  it("decodes an encoded drive colon in a file uri before dropping its slash", () => {
-    expect(resolveMarkdownFileLinkTarget("file:///c%3A/Users/x/shot.png")).toBe(
-      "c:/Users/x/shot.png",
-    );
-  });
-});
-
 describe("relative links inside a rendered host file", () => {
   it("anchor to the file's directory while workspace membership follows cwd", () => {
     const meta = resolveMarkdownFileLinkMeta("appendix.md", "/repo", "/tmp/report");
diff --git a/apps/web/src/markdown-links.ts b/apps/web/src/markdown-links.ts
index 8ed59eb8775b..d25d089f6528 100644
--- a/apps/web/src/markdown-links.ts
+++ b/apps/web/src/markdown-links.ts
@@ -1,23 +1,13 @@
+import { fileBasename, workspaceRelativeFilePath } from "@t3tools/shared/path";
 import {
-  fileBasename,
-  formatFilePathPosition,
   inlineCodeFilePathCandidate,
-  isRelativeFilePath,
   normalizeMarkdownLinkDestination,
-  parseFileUrlHref,
-  parseMarkdownFileLink,
-  safeDecodeURIComponent,
-  splitFilePathPosition,
-  workspaceRelativeFilePath,
-} from "@t3tools/client-runtime/markdown-links";
+  resolveMarkdownFileLinkTarget,
+} from "@t3tools/shared/markdownLinks";
+import { parseFileUrlHref, splitFilePathPosition } from "@t3tools/shared/fileLinks";
 
 import { formatWorkspaceRelativePath } from "./filePathDisplay";
-import { isTerminalLinkActivation, resolvePathLinkTarget } from "./terminal-links";
-
-export { normalizeMarkdownLinkDestination };
-
-const MARKDOWN_LINK_HREF_PATTERN =
-  /\[[^\]]*]\(\s*(?:<([^>\n]+)>|([^\s)]+))(?:\s+["'][^"']*["'])?\s*\)/g;
+import { isTerminalLinkActivation } from "./terminal-links";
 
 export interface MarkdownFileLinkMeta {
   filePath: string;
@@ -29,15 +19,6 @@ export interface MarkdownFileLinkMeta {
   column?: number;
 }
 
-export function extractMarkdownLinkHrefs(markdown: string): string[] {
-  const hrefs: string[] = [];
-  for (const match of markdown.matchAll(MARKDOWN_LINK_HREF_PATTERN)) {
-    const href = (match[1] ?? match[2])?.trim();
-    if (href) hrefs.push(href);
-  }
-  return hrefs;
-}
-
 export function shouldOpenMarkdownFileLinkInEditor(
   event: Pick<MouseEvent, "metaKey" | "ctrlKey">,
   platform?: string,
@@ -49,36 +30,12 @@ export function shouldOpenMarkdownFileLinkInBrowserByDefault(path: string): bool
   return /\.pdf$/i.test(path.split(/[?#]/, 1)[0] ?? "");
 }
 
-export function isWindowsDrivePathHref(href: string): boolean {
-  return /^[A-Za-z]:[\\/]/.test(safeDecodeURIComponent(href));
-}
-
 export function rewriteMarkdownFileUriHref(href: string | undefined): string | null {
   if (!href) return null;
   const target = parseFileUrlHref(normalizeMarkdownLinkDestination(href));
   return target ? `${target.path}${target.hash}` : null;
 }
 
-/**
- * `baseDir` anchors relative links; it defaults to the workspace root and is the
- * file's own directory when rendering a markdown file. `cwd` stays the workspace
- * root so the result still knows whether the target is inside it.
- */
-export function resolveMarkdownFileLinkTarget(
-  href: string | undefined,
-  cwd?: string,
-  baseDir: string | undefined = cwd,
-): string | null {
-  if (!href) return null;
-  const target = parseMarkdownFileLink(href);
-  if (!target) return null;
-
-  const pathWithPosition = formatFilePathPosition(target);
-  if (!isRelativeFilePath(pathWithPosition)) return pathWithPosition;
-  if (!baseDir) return null;
-  return resolvePathLinkTarget(pathWithPosition, baseDir);
-}
-
 /**
  * Inline code spans mostly hold identifiers, commands, and refs (`node.meta`,
  * `origin/main`) rather than deliberate link destinations, so auto-linking
diff --git a/apps/web/src/markdown-github-alerts.test.tsx b/apps/web/src/markdownGithubAlerts.test.tsx
similarity index 96%
rename from apps/web/src/markdown-github-alerts.test.tsx
rename to apps/web/src/markdownGithubAlerts.test.tsx
index 22bb711103e1..ff577a78e536 100644
--- a/apps/web/src/markdown-github-alerts.test.tsx
+++ b/apps/web/src/markdownGithubAlerts.test.tsx
@@ -3,7 +3,7 @@ import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import { describe, expect, it } from "vite-plus/test";
 
-import { remarkGithubAlerts } from "./markdown-github-alerts";
+import { remarkGithubAlerts } from "@t3tools/shared/markdownGithubAlerts";
 
 function renderMarkdown(markdown: string): string {
   return renderToStaticMarkup(
diff --git a/apps/web/src/markdown-list-indentation.test.tsx b/apps/web/src/markdownListIndentation.test.tsx
similarity index 96%
rename from apps/web/src/markdown-list-indentation.test.tsx
rename to apps/web/src/markdownListIndentation.test.tsx
index 2c04ed5fa832..3ce4ad6a7ebe 100644
--- a/apps/web/src/markdown-list-indentation.test.tsx
+++ b/apps/web/src/markdownListIndentation.test.tsx
@@ -3,7 +3,7 @@ import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import { describe, expect, it } from "vite-plus/test";
 
-import { remarkNormalizeListItemIndentation } from "./markdown-list-indentation";
+import { remarkNormalizeListItemIndentation } from "@t3tools/shared/markdownListIndentation";
 
 function renderMarkdown(markdown: string): string {
   return renderToStaticMarkup(
diff --git a/apps/web/src/openVsxThemes.test.ts b/apps/web/src/openVsxThemes.test.ts
index b4794f61986a..ba6eb482e8cf 100644
--- a/apps/web/src/openVsxThemes.test.ts
+++ b/apps/web/src/openVsxThemes.test.ts
@@ -305,6 +305,10 @@ describe("Open VSX themes", () => {
         "colors": {
           "editor.foreground": "#eeeeee",
           "focusBorder": "#8b5cf6",
+          "editor.findMatchBackground": "#663399",
+          "editor.findMatchForeground": "#ffffff",
+          "editor.findMatchHighlightBackground": "#445566",
+          "editor.findMatchHighlightForeground": "#ffffff",
         },
       }`,
     );
@@ -312,7 +316,10 @@ describe("Open VSX themes", () => {
       "extension/themes/demo-dark.json",
       `{
         "include": "./base.jsonc",
-        "colors": { "editor.background": "#111111" }
+        "colors": {
+          "editor.background": "#111111",
+          "editor.findMatchHighlightBackground": "#ffffff20"
+        }
       }`,
     );
     zip.file(
@@ -321,7 +328,11 @@ describe("Open VSX themes", () => {
         "colors": {
           "editor.background": "#fafafa",
           "editor.foreground": "#222222",
-          "focusBorder": "#8b5cf6"
+          "focusBorder": "#8b5cf6",
+          "editor.findMatchBackground": "#335577",
+          "editor.findMatchForeground": "#ffffff",
+          "editor.findMatchHighlightBackground": "#bbddff",
+          "editor.findMatchHighlightForeground": "#112233"
         }
       }`,
     );
@@ -410,6 +421,15 @@ describe("Open VSX themes", () => {
     expect(themeColorToHex(paired.colors.canvas)).toBe("#fafafa");
     expect(themeColorToHex(getThemeColorsForMode(paired, "dark")!.canvas)).toBe("#111111");
     expect(themeColorToHex(getThemeColorsForMode(paired, "dark")!.text)).toBe("#eeeeee");
+    const darkColors = getThemeColorsForMode(paired, "dark")!;
+    expect(themeColorToHex(darkColors.searchMatchActiveBackground)).toBe("#663399");
+    expect(themeColorToHex(darkColors.searchMatchActiveForeground)).toBe("#ffffff");
+    expect(themeColorToHex(darkColors.searchMatchBackground)).toBe("#2f2f2f");
+    expect(themeColorToHex(darkColors.searchMatchForeground)).toBe("#ffffff");
+    expect(themeColorToHex(paired.colors.searchMatchActiveBackground)).toBe("#335577");
+    expect(themeColorToHex(paired.colors.searchMatchActiveForeground)).toBe("#ffffff");
+    expect(themeColorToHex(paired.colors.searchMatchBackground)).toBe("#bbddff");
+    expect(themeColorToHex(paired.colors.searchMatchForeground)).toBe("#112233");
 
     packagedManifest.contributes.themes[0]!.label = "Renamed Dark";
     packagedManifest.contributes.themes[1]!.label = "Renamed Light";
diff --git a/apps/web/src/openVsxThemes.ts b/apps/web/src/openVsxThemes.ts
index 8b03d84869b5..81617e3cd21d 100644
--- a/apps/web/src/openVsxThemes.ts
+++ b/apps/web/src/openVsxThemes.ts
@@ -49,6 +49,10 @@ const USED_WORKBENCH_COLORS = new Set([
   "dropdown.border",
   "editor.background",
   "editor.foreground",
+  "editor.findMatchBackground",
+  "editor.findMatchForeground",
+  "editor.findMatchHighlightBackground",
+  "editor.findMatchHighlightForeground",
   "editor.selectionBackground",
   "editorCursor.foreground",
   "editorError.foreground",
diff --git a/apps/web/src/proposedPlan.test.ts b/apps/web/src/proposedPlan.test.ts
index a8700ab924e6..30e114a0eb7c 100644
--- a/apps/web/src/proposedPlan.test.ts
+++ b/apps/web/src/proposedPlan.test.ts
@@ -5,21 +5,9 @@ import {
   buildPlanImplementationThreadTitle,
   buildPlanImplementationPrompt,
   buildProposedPlanMarkdownFilename,
-  proposedPlanTitle,
   resolvePlanFollowUpSubmission,
-  stripDisplayedPlanMarkdown,
 } from "./proposedPlan";
 
-describe("proposedPlanTitle", () => {
-  it("reads the first markdown heading as the plan title", () => {
-    expect(proposedPlanTitle("# Integrate RPC\n\nBody")).toBe("Integrate RPC");
-  });
-
-  it("returns null when the plan has no heading", () => {
-    expect(proposedPlanTitle("- step 1")).toBeNull();
-  });
-});
-
 describe("buildPlanImplementationPrompt", () => {
   it("formats the plan exactly like the Codex follow-up handoff prompt", () => {
     expect(buildPlanImplementationPrompt("## Ship it\n\n- step 1\n")).toBe(
@@ -49,20 +37,6 @@ describe("buildCollapsedProposedPlanPreviewMarkdown", () => {
   });
 });
 
-describe("stripDisplayedPlanMarkdown", () => {
-  it("drops the leading title heading from displayed plan markdown", () => {
-    expect(stripDisplayedPlanMarkdown("# Integrate RPC\n\n## Summary\n\n- step 1\n")).toBe(
-      "- step 1",
-    );
-  });
-
-  it("preserves non-summary headings after dropping the title heading", () => {
-    expect(stripDisplayedPlanMarkdown("# Integrate RPC\n\n## Scope\n\n- step 1\n")).toBe(
-      "## Scope\n\n- step 1",
-    );
-  });
-});
-
 describe("resolvePlanFollowUpSubmission", () => {
   it.each(["", "Consider this "])(
     "keeps context-bearing feedback in plan mode with prose %j",
diff --git a/apps/web/src/proposedPlan.ts b/apps/web/src/proposedPlan.ts
index 525be17a72e0..15f90c59ae23 100644
--- a/apps/web/src/proposedPlan.ts
+++ b/apps/web/src/proposedPlan.ts
@@ -1,23 +1,4 @@
-export function proposedPlanTitle(planMarkdown: string): string | null {
-  const heading = planMarkdown.match(/^\s{0,3}#{1,6}\s+(.+)$/m)?.[1]?.trim();
-  return heading && heading.length > 0 ? heading : null;
-}
-
-export function stripDisplayedPlanMarkdown(planMarkdown: string): string {
-  const lines = planMarkdown.trimEnd().split(/\r?\n/);
-  const sourceLines = lines[0] && /^\s{0,3}#{1,6}\s+/.test(lines[0]) ? lines.slice(1) : [...lines];
-  while (sourceLines[0]?.trim().length === 0) {
-    sourceLines.shift();
-  }
-  const firstHeadingMatch = sourceLines[0]?.match(/^\s{0,3}#{1,6}\s+(.+)$/);
-  if (firstHeadingMatch?.[1]?.trim().toLowerCase() === "summary") {
-    sourceLines.shift();
-    while (sourceLines[0]?.trim().length === 0) {
-      sourceLines.shift();
-    }
-  }
-  return sourceLines.join("\n");
-}
+import { stripDisplayedPlanMarkdown, proposedPlanTitle } from "@t3tools/shared/proposedPlanText";
 
 export function buildCollapsedProposedPlanPreviewMarkdown(
   planMarkdown: string,
diff --git a/apps/web/src/terminal-links.test.ts b/apps/web/src/terminal-links.test.ts
index 5cb2ad915827..6dc750edeec1 100644
--- a/apps/web/src/terminal-links.test.ts
+++ b/apps/web/src/terminal-links.test.ts
@@ -1,3 +1,4 @@
+import { resolvePathLinkTarget } from "@t3tools/shared/fileLinks";
 import { describe, expect, it } from "vite-plus/test";
 
 import {
@@ -5,7 +6,6 @@ import {
   extractTerminalLinks,
   isTerminalLinkActivation,
   isTerminalUrl,
-  resolvePathLinkTarget,
   type TerminalBufferLineLike,
 } from "./terminal-links";
 
diff --git a/apps/web/src/terminal-links.ts b/apps/web/src/terminal-links.ts
index 0f253588b700..7ad2d83843de 100644
--- a/apps/web/src/terminal-links.ts
+++ b/apps/web/src/terminal-links.ts
@@ -1,8 +1,3 @@
-import {
-  formatFilePathPosition,
-  splitFilePathPosition,
-} from "@t3tools/client-runtime/markdown-links";
-
 import { isMacPlatform } from "./lib/utils";
 
 export type TerminalLinkKind = "url" | "path";
@@ -98,45 +93,6 @@ function collectMatches(
   return matches;
 }
 
-function isWindowsAbsolutePath(value: string): boolean {
-  return /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
-}
-
-export function isAbsolutePath(value: string): boolean {
-  return value.startsWith("/") || isWindowsAbsolutePath(value);
-}
-
-function isWindowsPathStyle(value: string): boolean {
-  return isWindowsAbsolutePath(value) || /[A-Za-z]:\\/.test(value);
-}
-
-function joinPath(base: string, next: string, separator: "/" | "\\"): string {
-  const cleanBase = base.replace(/[\\/]+$/, "");
-  if (separator === "\\") {
-    return `${cleanBase}\\${next.replaceAll("/", "\\")}`;
-  }
-  return `${cleanBase}/${next.replace(/^\/+/, "")}`;
-}
-
-function inferHomeFromCwd(cwd: string): string | undefined {
-  const posixUser = cwd.match(/^\/Users\/([^/]+)/);
-  if (posixUser?.[1]) {
-    return `/Users/${posixUser[1]}`;
-  }
-
-  const posixHome = cwd.match(/^\/home\/([^/]+)/);
-  if (posixHome?.[1]) {
-    return `/home/${posixHome[1]}`;
-  }
-
-  const windowsUser = cwd.match(/^([A-Za-z]:\\Users\\[^\\]+)/);
-  if (windowsUser?.[1]) {
-    return windowsUser[1];
-  }
-
-  return undefined;
-}
-
 export function extractTerminalLinks(line: string): TerminalLinkMatch[] {
   const urlMatches = collectMatches(line, "url", URL_PATTERN, []);
   const pathMatches = collectMatches(line, "path", FILE_PATH_PATTERN, urlMatches);
@@ -203,22 +159,3 @@ export function isTerminalLinkActivation(
     ? event.metaKey && !event.ctrlKey
     : event.ctrlKey && !event.metaKey;
 }
-
-export function resolvePathLinkTarget(rawPath: string, cwd: string): string {
-  const position = splitFilePathPosition(rawPath);
-  const { path } = position;
-
-  let resolvedPath = path;
-  if (path.startsWith("~/")) {
-    const home = inferHomeFromCwd(cwd);
-    if (home) {
-      const separator: "/" | "\\" = isWindowsPathStyle(home) ? "\\" : "/";
-      resolvedPath = joinPath(home, path.slice(2), separator);
-    }
-  } else if (!isAbsolutePath(path)) {
-    const separator: "/" | "\\" = isWindowsPathStyle(cwd) ? "\\" : "/";
-    resolvedPath = joinPath(cwd, path, separator);
-  }
-
-  return formatFilePathPosition({ ...position, path: resolvedPath });
-}
diff --git a/apps/web/src/themePalette.test.ts b/apps/web/src/themePalette.test.ts
index de26d531c6f5..02f9e0b90ce1 100644
--- a/apps/web/src/themePalette.test.ts
+++ b/apps/web/src/themePalette.test.ts
@@ -33,6 +33,7 @@ import {
   IRIS_THEME,
   OCEAN_THEME,
   updateCustomTheme,
+  updateThemeColorFamily,
   CUSTOM_THEMES_STORAGE_KEY,
   createVividThemeColors,
   getDefaultThemeColors,
@@ -90,6 +91,68 @@ describe("theme files", () => {
     }
   });
 
+  it("keeps built-in and standard search pairs readable and distinct", () => {
+    const palettes = [
+      getStandardThemeColors("light"),
+      getStandardThemeColors("dark"),
+      ...BUILT_IN_THEMES.flatMap((theme) => [theme.colors, ...Object.values(theme.variants ?? {})]),
+    ];
+    for (const colors of palettes) {
+      expect(
+        contrastRatio(colors.searchMatchForeground, colors.searchMatchBackground),
+      ).toBeGreaterThanOrEqual(4.5);
+      expect(
+        contrastRatio(colors.searchMatchActiveForeground, colors.searchMatchActiveBackground),
+      ).toBeGreaterThanOrEqual(4.5);
+      expect(asHex(colors.searchMatchBackground)).not.toBe(
+        asHex(colors.searchMatchActiveBackground),
+      );
+    }
+  });
+
+  it("round-trips custom search colours and fills them in for older theme files", () => {
+    const legacy = parseThemeFile({
+      version: THEME_FILE_VERSION,
+      name: "Legacy",
+      appearance: "dark",
+      colors: { canvas: "#101010" },
+    });
+    expect(legacy.colors.searchMatchBackground).toBe(
+      getDefaultThemeColors("dark").searchMatchBackground,
+    );
+    const theme = parseThemeFile({
+      version: THEME_FILE_VERSION,
+      name: "Search",
+      appearance: "dark",
+      colors: {
+        searchMatchBackground: "#224466",
+        searchMatchForeground: "#ffffff",
+        searchMatchActiveBackground: "#aaddff",
+        searchMatchActiveForeground: "#112233",
+      },
+      variants: { light: { searchMatchBackground: "#ddeeff", searchMatchForeground: "#112233" } },
+    });
+    const restored = parseThemeFile(JSON.parse(serializeThemeFile(theme)));
+    expect(restored.colors).toEqual(theme.colors);
+    expect(restored.variants).toEqual(theme.variants);
+  });
+
+  it.each(["searchMatchBackground", "searchMatchActiveBackground"] as const)(
+    "editing %s derives readable text without changing the other match or warning colours",
+    (role) => {
+      const original = getDefaultThemeColors("dark");
+      const foreground =
+        role === "searchMatchBackground" ? "searchMatchForeground" : "searchMatchActiveForeground";
+      for (const value of ["#ffffff", "#000000", "#33669980"]) {
+        const updated = updateThemeColorFamily("dark", original, role, value);
+        expect(contrastRatio(updated[foreground], updated[role])).toBeGreaterThanOrEqual(4.5);
+        for (const key of Object.keys(original) as Array<keyof typeof original>) {
+          if (key !== role && key !== foreground) expect(updated[key]).toBe(original[key]);
+        }
+      }
+    },
+  );
+
   it("keeps stock dark controls in the neutral-black surface hierarchy", () => {
     expectThemeColors(getStandardThemeColors("dark"), {
       canvas: "#0a0a0a",
@@ -155,6 +218,12 @@ describe("theme files", () => {
       );
       expect(colors.secondaryLabel).toBe(colors.textMuted);
       expect(contrastRatio(colors.accentForeground, colors.accent)).toBeGreaterThanOrEqual(4.5);
+      expect(
+        contrastRatio(colors.searchMatchForeground, colors.searchMatchBackground),
+      ).toBeGreaterThanOrEqual(4.5);
+      expect(
+        contrastRatio(colors.searchMatchActiveForeground, colors.searchMatchActiveBackground),
+      ).toBeGreaterThanOrEqual(4.5);
       expect(
         contrastRatio(colors.messageActionForeground, colors.messageAction),
       ).toBeGreaterThanOrEqual(4.5);
diff --git a/apps/web/src/themePalette.ts b/apps/web/src/themePalette.ts
index d4a1c4e8cc00..da9af454c5a2 100644
--- a/apps/web/src/themePalette.ts
+++ b/apps/web/src/themePalette.ts
@@ -743,6 +743,10 @@ export function createVividThemeColors(
   const mutedForeground = themeRgbToThemeColor(readableThemeText(mutedRgb, textRgb, 1, 4.6));
   const placeholder = themeRgbToThemeColor(readableThemeText(surfaceRaisedRgb, textRgb, 1, 4.6));
 
+  // Keep matches visible even when an imported theme has no accent colour.
+  const searchMatch = themeOklchToRgb(surfaceAt(0.22, Math.min(0.12, accent.C)));
+  const searchMatchActive = themeOklchToRgb(surfaceAt(0.4, Math.min(0.18, accent.C)));
+
   const actionHover: ThemeOklch = { ...action, L: action.L + (dark ? 0.06 : -0.06) };
 
   return {
@@ -786,6 +790,10 @@ export function createVividThemeColors(
     messageActionHover: themeColor(actionHover),
     codeBackground: themeColor(codeBackground),
     codeForeground: themeRgbToThemeColor(textRgb),
+    searchMatchBackground: themeRgbToThemeColor(searchMatch),
+    searchMatchForeground: themeRgbToThemeColor(readableThemeForeground(searchMatch)),
+    searchMatchActiveBackground: themeRgbToThemeColor(searchMatchActive),
+    searchMatchActiveForeground: themeRgbToThemeColor(readableThemeForeground(searchMatchActive)),
     sidebar: themeColor(sidebar),
     sidebarForeground: foregroundOn(sidebarRgb),
     sidebarMutedForeground: themeRgbToThemeColor(standardMutedThemeText(sidebarRgb, textRgb)),
@@ -1005,6 +1013,18 @@ export function updateThemeColorFamily(
         messageSurface: normalized,
         messageForeground: foregroundOn(selectedOnCanvas),
       };
+    case "searchMatchBackground":
+      return {
+        ...colors,
+        searchMatchBackground: colorOf(selectedOnCanvas),
+        searchMatchForeground: foregroundOn(selectedOnCanvas),
+      };
+    case "searchMatchActiveBackground":
+      return {
+        ...colors,
+        searchMatchActiveBackground: colorOf(selectedOnCanvas),
+        searchMatchActiveForeground: foregroundOn(selectedOnCanvas),
+      };
     case "codeBackground":
       return {
         ...colors,
@@ -1469,6 +1489,10 @@ const APP_THEME_VARIABLES: Readonly<Record<ThemeColorRole, string>> = {
   messageActionHover: "--app-theme-message-action-hover",
   codeBackground: "--app-theme-code-background",
   codeForeground: "--app-theme-code-foreground",
+  searchMatchBackground: "--app-theme-search-match-background",
+  searchMatchForeground: "--app-theme-search-match-foreground",
+  searchMatchActiveBackground: "--app-theme-search-match-active-background",
+  searchMatchActiveForeground: "--app-theme-search-match-active-foreground",
   sidebar: "--app-theme-sidebar",
   sidebarForeground: "--app-theme-sidebar-foreground",
   sidebarMutedForeground: "--app-theme-sidebar-muted-foreground",
diff --git a/apps/web/src/vscodeThemeImport.test.ts b/apps/web/src/vscodeThemeImport.test.ts
index 03860b631480..624d11585f5f 100644
--- a/apps/web/src/vscodeThemeImport.test.ts
+++ b/apps/web/src/vscodeThemeImport.test.ts
@@ -292,6 +292,100 @@ describe("VS Code theme import", () => {
       contrastRatio(lightPlus.colors.placeholder, lightPlus.colors.surfaceRaised),
     ).toBeLessThan(contrastRatio(lightPlus.colors.text, lightPlus.colors.surfaceRaised));
   });
+  it("imports current and other find matches as independent background/text pairs", () => {
+    const { colors } = parseVsCodeThemeFile({
+      type: "dark",
+      colors: {
+        "editor.background": "#202020",
+        "editor.findMatchBackground": "#663399",
+        "editor.findMatchForeground": "#ffffff",
+        "editor.findMatchHighlightBackground": "#bce4ff",
+        "editor.findMatchHighlightForeground": "#17314a",
+      },
+    });
+
+    expect(asHex(colors.searchMatchActiveBackground)).toBe("#663399");
+    expect(asHex(colors.searchMatchActiveForeground)).toBe("#ffffff");
+    expect(asHex(colors.searchMatchBackground)).toBe("#bce4ff");
+    expect(asHex(colors.searchMatchForeground)).toBe("#17314a");
+  });
+
+  it("composites find backgrounds onto the canvas and foregrounds onto their match", () => {
+    const { colors } = parseVsCodeThemeFile({
+      type: "dark",
+      colors: {
+        "editor.background": "#202020",
+        "editor.findMatchBackground": "#33669980",
+        "editor.findMatchForeground": "#ffffffcc",
+        "editor.findMatchHighlightBackground": "#ffcc0040",
+        "editor.findMatchHighlightForeground": "#ffffff",
+      },
+    });
+
+    expect(asHex(colors.searchMatchActiveBackground)).toBe("#2a435d");
+    expect(asHex(colors.searchMatchActiveForeground)).toBe("#d4d9df");
+    expect(asHex(colors.searchMatchBackground)).toBe("#584b18");
+    expect(asHex(colors.searchMatchForeground)).toBe("#ffffff");
+  });
+
+  it("uses editor text when no find foreground is specified", () => {
+    const { colors } = parseVsCodeThemeFile({
+      type: "dark",
+      colors: {
+        "editor.background": "#101010",
+        "editor.foreground": "#eeeeee",
+        "editor.findMatchBackground": "#304050",
+        "editor.findMatchHighlightBackground": "#403020",
+      },
+    });
+
+    expect(asHex(colors.searchMatchActiveForeground)).toBe("#eeeeee");
+    expect(asHex(colors.searchMatchForeground)).toBe("#eeeeee");
+  });
+
+  it.each(["light", "dark"])(
+    "keeps missing or invalid find colours readable in %s themes",
+    (type) => {
+      const base = {
+        "editor.background": type === "dark" ? "#101010" : "#fafafa",
+      };
+      const missing = parseVsCodeThemeFile({ type, colors: base }).colors;
+      const invalid = parseVsCodeThemeFile({
+        type,
+        colors: {
+          ...base,
+          "editor.findMatchBackground": "not-a-colour",
+          "editor.findMatchForeground": 42,
+          "editor.findMatchHighlightBackground": null,
+          "editor.findMatchHighlightForeground": "invalid",
+        },
+      }).colors;
+      const unreadable = parseVsCodeThemeFile({
+        type,
+        colors: {
+          ...base,
+          "editor.findMatchBackground": "#ffffcc",
+          "editor.findMatchForeground": "#ffffff",
+          "editor.findMatchHighlightBackground": "#101020",
+          "editor.findMatchHighlightForeground": "#111111",
+        },
+      }).colors;
+
+      for (const colors of [missing, invalid, unreadable]) {
+        expect(
+          contrastRatio(colors.searchMatchForeground, colors.searchMatchBackground),
+        ).toBeGreaterThanOrEqual(4.5);
+        expect(
+          contrastRatio(colors.searchMatchActiveForeground, colors.searchMatchActiveBackground),
+        ).toBeGreaterThanOrEqual(4.5);
+      }
+      expect(invalid.searchMatchBackground).toBe(missing.searchMatchBackground);
+      expect(invalid.searchMatchActiveBackground).toBe(missing.searchMatchActiveBackground);
+      expect(missing.searchMatchBackground).not.toBe(missing.searchMatchActiveBackground);
+      expect(missing.searchMatchBackground).not.toBe(missing.canvas);
+      expect(missing.searchMatchActiveBackground).not.toBe(missing.canvas);
+    },
+  );
 
   it("fills every role the file omits with a readable derived value", () => {
     const theme = parseVsCodeThemeFile(VSCODE_DARK);
diff --git a/apps/web/src/vscodeThemeImport.ts b/apps/web/src/vscodeThemeImport.ts
index 2d6ff7f6aa80..a02357d599fa 100644
--- a/apps/web/src/vscodeThemeImport.ts
+++ b/apps/web/src/vscodeThemeImport.ts
@@ -321,6 +321,12 @@ export function parseVsCodeThemeFile(value: unknown): ThemeDefinition {
       break;
     }
   }
+  // Find overlays can cover prose, code, or message bubbles. Flatten them onto
+  // the editor canvas so each imported foreground has one predictable surface.
+  const searchMatchBackground =
+    solidOver(canvas, "editor.findMatchHighlightBackground") ?? derived.searchMatchBackground;
+  const searchMatchActiveBackground =
+    solidOver(canvas, "editor.findMatchBackground") ?? derived.searchMatchActiveBackground;
 
   const overrides: Partial<Record<ThemeColorRole, string>> = {
     canvas: canvasHex,
@@ -346,6 +352,22 @@ export function parseVsCodeThemeFile(value: unknown): ThemeDefinition {
       solidOver(canvas, "list.activeSelectionBackground", "list.hoverBackground") ??
       derived.accentSurface,
     codeBackground: solidOver(canvas, "textCodeBlock.background") ?? derived.codeBackground,
+    searchMatchBackground,
+    searchMatchForeground: readableOn(
+      searchMatchBackground,
+      derived.searchMatchForeground,
+      "editor.findMatchHighlightForeground",
+      "editor.foreground",
+      "foreground",
+    ),
+    searchMatchActiveBackground,
+    searchMatchActiveForeground: readableOn(
+      searchMatchActiveBackground,
+      derived.searchMatchActiveForeground,
+      "editor.findMatchForeground",
+      "editor.foreground",
+      "foreground",
+    ),
     sidebar: sidebarHex,
     sidebarForeground: readableOn(sidebarHex, derived.sidebarForeground, "sideBar.foreground"),
     sidebarBorder: solidOver(sidebar, "sideBar.border") ?? derived.sidebarBorder,
diff --git a/docs/user/keybindings.md b/docs/user/keybindings.md
index 488b57b997cb..f61b745f285b 100644
--- a/docs/user/keybindings.md
+++ b/docs/user/keybindings.md
@@ -112,6 +112,14 @@ Combine keys with `!` for not, `&&` for and, `||` for or, and parentheses:
 { "key": "mod+j", "command": "terminal.toggle", "when": "terminalOpen && !terminalFocus" }
 ```
 
+## Find in the current thread
+
+`chat.find` searches conversation messages and proposed plans in the active thread. Entering a
+query searches the entire thread, including older messages. When connected to an older server,
+search loads earlier history first. Select **Retry** if a search or history load fails. It defaults to
+`mod+f` outside terminals and previews. Press **Enter** or **Shift+Enter** to move between matches,
+and **Escape** to close find.
+
 ## Precedence
 
 The last rule whose key and condition both match wins, even if it belongs to a
diff --git a/packages/client-runtime/package.json b/packages/client-runtime/package.json
index 3b72e948454a..8e12f770d016 100644
--- a/packages/client-runtime/package.json
+++ b/packages/client-runtime/package.json
@@ -63,10 +63,6 @@
       "types": "./src/markdownImages.ts",
       "default": "./src/markdownImages.ts"
     },
-    "./markdown-links": {
-      "types": "./src/markdownLinks.ts",
-      "default": "./src/markdownLinks.ts"
-    },
     "./media-reference": {
       "types": "./src/mediaReference.ts",
       "default": "./src/mediaReference.ts"
@@ -79,18 +75,6 @@
       "types": "./src/mediaActions.ts",
       "default": "./src/mediaActions.ts"
     },
-    "./codex-file-citations": {
-      "types": "./src/codexFileCitations.ts",
-      "default": "./src/codexFileCitations.ts"
-    },
-    "./codex-artifact-templates": {
-      "types": "./src/codexArtifactTemplates.ts",
-      "default": "./src/codexArtifactTemplates.ts"
-    },
-    "./codex-markdown-directives": {
-      "types": "./src/codexMarkdownDirectives.ts",
-      "default": "./src/codexMarkdownDirectives.ts"
-    },
     "./errors": {
       "types": "./src/errors/index.ts",
       "default": "./src/errors/index.ts"
@@ -400,17 +384,11 @@
     "@t3tools/contracts": "workspace:*",
     "@t3tools/shared": "workspace:*",
     "effect": "catalog:",
-    "mdast-util-directive": "^3.1.0",
-    "micromark-extension-directive": "^4.0.0",
-    "micromark-util-character": "^2.1.1",
-    "remark-parse": "^11.0.0",
-    "three": "0.180.0",
-    "unified": "^11.0.5"
+    "three": "0.180.0"
   },
   "devDependencies": {
     "@effect/vitest": "catalog:",
     "@types/three": "0.180.0",
-    "micromark-util-types": "^2.0.2",
     "vite-plus": "catalog:"
   }
 }
diff --git a/packages/client-runtime/src/markdownImages.ts b/packages/client-runtime/src/markdownImages.ts
index f4092674c5ae..59a3228037b6 100644
--- a/packages/client-runtime/src/markdownImages.ts
+++ b/packages/client-runtime/src/markdownImages.ts
@@ -1,12 +1,11 @@
-import { isWindowsAbsolutePath } from "@t3tools/shared/path";
+import { isWindowsAbsolutePath, stripSlashPrefixedWindowsDrive } from "@t3tools/shared/path";
 
 import {
   normalizeMarkdownLinkDestination,
-  parseFileUrlHref,
   safeDecodeURIComponent,
   splitMarkdownLinkSearchAndHash,
-  stripSlashPrefixedWindowsDrive,
-} from "./markdownLinks.ts";
+} from "@t3tools/shared/markdownLinks";
+import { parseFileUrlHref } from "@t3tools/shared/fileLinks";
 
 const DIRECT_IMAGE_SOURCE_PATTERN = /^(?:https?:|data:|blob:|\/\/)/i;
 const URI_SCHEME_PATTERN = /^[A-Za-z][A-Za-z0-9+.-]*:/;
diff --git a/packages/client-runtime/src/mediaReference.ts b/packages/client-runtime/src/mediaReference.ts
index f44ec90cd879..da98d4b7ee5e 100644
--- a/packages/client-runtime/src/mediaReference.ts
+++ b/packages/client-runtime/src/mediaReference.ts
@@ -1,6 +1,6 @@
 import { isWindowsAbsolutePath } from "@t3tools/shared/path";
 
-import { safeDecodeURIComponent } from "./markdownLinks.ts";
+import { safeDecodeURIComponent } from "@t3tools/shared/markdownLinks";
 
 /** The authored media location, never the temporary URL used to load its bytes. */
 export type MediaReference =
diff --git a/packages/client-runtime/src/mediaSource.ts b/packages/client-runtime/src/mediaSource.ts
index 6c285e21ba99..5760536a7220 100644
--- a/packages/client-runtime/src/mediaSource.ts
+++ b/packages/client-runtime/src/mediaSource.ts
@@ -6,11 +6,9 @@ import {
   markdownImageSourceFragment,
   type MarkdownImageSource,
 } from "./markdownImages.ts";
-import {
-  fileBasename,
-  splitFilePathPosition,
-  splitMarkdownLinkSearchAndHash,
-} from "./markdownLinks.ts";
+import { fileBasename } from "@t3tools/shared/path";
+import { splitFilePathPosition } from "@t3tools/shared/fileLinks";
+import { splitMarkdownLinkSearchAndHash } from "@t3tools/shared/markdownLinks";
 import {
   mediaFileReference,
   mediaReferenceFileName,
diff --git a/packages/client-runtime/src/state/orchestration.ts b/packages/client-runtime/src/state/orchestration.ts
index 9392ee2baab4..c156e0155f9c 100644
--- a/packages/client-runtime/src/state/orchestration.ts
+++ b/packages/client-runtime/src/state/orchestration.ts
@@ -55,6 +55,12 @@ export function createOrchestrationEnvironmentAtoms<R, E>(
       label: "environment-data:orchestration:full-thread-diff",
       tag: ORCHESTRATION_V2_WS_METHODS.getFullThreadDiff,
     }),
+    threadFind: createEnvironmentRpcQueryAtomFamily(runtime, {
+      label: "environment-data:orchestration:thread-find",
+      tag: ORCHESTRATION_V2_WS_METHODS.searchThread,
+      staleTimeMs: 0,
+      idleTtlMs: 0,
+    }),
     threadSearch: createEnvironmentRpcQueryAtomFamily(runtime, {
       label: "environment-data:orchestration:thread-search",
       tag: ORCHESTRATION_V2_WS_METHODS.searchThreads,
diff --git a/packages/client-runtime/src/state/subagentDisplay.ts b/packages/client-runtime/src/state/subagentDisplay.ts
index 0a456e7a2ddc..480cc8e0c7ec 100644
--- a/packages/client-runtime/src/state/subagentDisplay.ts
+++ b/packages/client-runtime/src/state/subagentDisplay.ts
@@ -5,7 +5,7 @@ import type {
   ServerProvider,
 } from "@t3tools/contracts";
 import { formatModelSlugName, resolveSelectableModel } from "@t3tools/shared/model";
-import { fileBasename } from "../markdownLinks.ts";
+import { fileBasename } from "@t3tools/shared/path";
 import { isTerminalSubagentStatus } from "./subagentRuntime.ts";
 
 /** Summarizes one adjacent group, without changing its member identities or order. */
diff --git a/packages/contracts/src/keybindings.test.ts b/packages/contracts/src/keybindings.test.ts
index 429d5d5fb495..1491fbe482bd 100644
--- a/packages/contracts/src/keybindings.test.ts
+++ b/packages/contracts/src/keybindings.test.ts
@@ -101,6 +101,12 @@ it.effect("parses keybinding rules", () =>
     });
     assert.strictEqual(parsedLocal.command, "chat.newLocal");
 
+    const parsedFind = yield* decode(KeybindingRule, {
+      key: "mod+f",
+      command: "chat.find",
+    });
+    assert.strictEqual(parsedFind.command, "chat.find");
+
     const parsedModelPickerToggle = yield* decode(KeybindingRule, {
       key: "mod+shift+m",
       command: "modelPicker.toggle",
diff --git a/packages/contracts/src/keybindings.ts b/packages/contracts/src/keybindings.ts
index 20bf0b901389..04c3acab803d 100644
--- a/packages/contracts/src/keybindings.ts
+++ b/packages/contracts/src/keybindings.ts
@@ -100,6 +100,7 @@ export const STATIC_KEYBINDING_COMMANDS = [
   "chat.new",
   "chat.newLocal",
   "chat.newWithoutProject",
+  "chat.find",
   "editor.openFavorite",
   "usage.cost",
   "usage.tokens",
diff --git a/packages/contracts/src/orchestrationV2.ts b/packages/contracts/src/orchestrationV2.ts
index c26d5a9327e4..9c31d5a8633f 100644
--- a/packages/contracts/src/orchestrationV2.ts
+++ b/packages/contracts/src/orchestrationV2.ts
@@ -3137,6 +3137,7 @@ export const ORCHESTRATION_V2_WS_METHODS = {
   getTurnDiff: "orchestration.getTurnDiff",
   getFullThreadDiff: "orchestration.getFullThreadDiff",
   searchThreads: "orchestration.searchThreads",
+  searchThread: "orchestration.searchThread",
   getArchivedShellSnapshot: "orchestration.getArchivedShellSnapshot",
   getThreadProjection: "orchestration.getThreadProjection",
   getWorkflowScript: "orchestration.getWorkflowScript",
@@ -3484,7 +3485,42 @@ export class OrchestrationGetWorkflowScriptError extends Schema.TaggedError<Orch
   }
 }
 
+export const OrchestrationV2SearchThreadInput = Schema.Struct({
+  threadId: ThreadId,
+  query: TrimmedNonEmptyString.check(Schema.isMaxLength(200)),
+  index: Schema.optionalKey(NonNegativeInt),
+});
+export type OrchestrationV2SearchThreadInput = typeof OrchestrationV2SearchThreadInput.Type;
+
+export const OrchestrationV2ThreadFindMatch = Schema.Struct({
+  entryId: TrimmedNonEmptyString,
+  runId: Schema.NullOr(RunId),
+  occurrence: NonNegativeInt,
+});
+export const OrchestrationV2SearchThreadResult = Schema.Struct({
+  snapshotSequence: NonNegativeInt,
+  totalMatches: NonNegativeInt,
+  activeIndex: NonNegativeInt,
+  match: Schema.NullOr(OrchestrationV2ThreadFindMatch),
+  // Search context is separate from the client's contiguous history pages.
+  items: Schema.Array(OrchestrationV2ProjectedTurnItem),
+});
+export type OrchestrationV2SearchThreadResult = typeof OrchestrationV2SearchThreadResult.Type;
+
+export class OrchestrationV2SearchThreadError extends Schema.TaggedError<OrchestrationV2SearchThreadError>()(
+  "OrchestrationV2SearchThreadError",
+  { cause: Schema.Defect() },
+) {
+  override get message(): string {
+    return "Could not search this thread. Please retry.";
+  }
+}
+
 export const OrchestrationV2RpcSchemas = {
+  searchThread: {
+    input: OrchestrationV2SearchThreadInput,
+    output: OrchestrationV2SearchThreadResult,
+  },
   dispatchCommand: {
     input: OrchestrationV2Command,
     output: OrchestrationV2DispatchCommandResult,
diff --git a/packages/contracts/src/rpc.ts b/packages/contracts/src/rpc.ts
index ba4ce8288798..04bce70a61fc 100644
--- a/packages/contracts/src/rpc.ts
+++ b/packages/contracts/src/rpc.ts
@@ -1,3 +1,8 @@
+import {
+  OrchestrationV2SearchThreadError,
+  OrchestrationV2SearchThreadInput,
+  OrchestrationV2SearchThreadResult,
+} from "./orchestrationV2.ts";
 import { OrchestrationDispatchCommandError } from "./orchestrationDispatch.ts";
 import {
   ChatGptReconnectProfileInput,
@@ -1526,6 +1531,12 @@ const WsOrchestrationV2GetFullThreadDiffRpc = Rpc.make(
   },
 );
 
+const WsOrchestrationV2SearchThreadRpc = Rpc.make(ORCHESTRATION_V2_WS_METHODS.searchThread, {
+  payload: OrchestrationV2SearchThreadInput,
+  success: OrchestrationV2SearchThreadResult,
+  error: Schema.Union([OrchestrationV2SearchThreadError, EnvironmentAuthorizationError]),
+});
+
 const WsOrchestrationV2SearchThreadsRpc = Rpc.make(ORCHESTRATION_V2_WS_METHODS.searchThreads, {
   payload: OrchestrationSearchThreadsInput,
   success: OrchestrationSearchThreadsResult,
@@ -1914,6 +1925,7 @@ export const WsRpcGroup = RpcGroup.make(
   WsOrchestrationV2GetTurnDiffRpc,
   WsOrchestrationV2GetFullThreadDiffRpc,
   WsOrchestrationV2SearchThreadsRpc,
+  WsOrchestrationV2SearchThreadRpc,
   WsOrchestrationV2GetArchivedShellSnapshotRpc,
   WsOrchestrationV2GetThreadProjectionRpc,
   WsOrchestrationV2LaunchThreadRpc,
diff --git a/packages/contracts/src/server.ts b/packages/contracts/src/server.ts
index c46c8b732a6c..2e7045e07389 100644
--- a/packages/contracts/src/server.ts
+++ b/packages/contracts/src/server.ts
@@ -669,6 +669,7 @@ export const ServerConfig = Schema.Struct({
   threadSnapshotPagination: Schema.optionalKey(Schema.Boolean),
   /** Whether thread reads accept the reasoningMessages opt-in. */
   reasoningMessages: Schema.optionalKey(Schema.Boolean),
+  threadFind: Schema.optionalKey(Schema.Boolean),
   /**
    * Folder behind this environment's Scratch project, for threads that need
    * no repository. Present only on servers that answer projects.ensureScratch
diff --git a/packages/shared/package.json b/packages/shared/package.json
index 73f6698f9b70..927d7d93074d 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -402,6 +402,50 @@
     "./codexAuthHandoff": {
       "types": "./src/codexAuthHandoff.ts",
       "import": "./src/codexAuthHandoff.ts"
+    },
+    "./codexArtifactTemplates": {
+      "types": "./src/codexArtifactTemplates.ts",
+      "import": "./src/codexArtifactTemplates.ts"
+    },
+    "./codexFileCitations": {
+      "types": "./src/codexFileCitations.ts",
+      "import": "./src/codexFileCitations.ts"
+    },
+    "./codexMarkdownDirectives": {
+      "types": "./src/codexMarkdownDirectives.ts",
+      "import": "./src/codexMarkdownDirectives.ts"
+    },
+    "./markdownGithubAlerts": {
+      "types": "./src/markdownGithubAlerts.ts",
+      "import": "./src/markdownGithubAlerts.ts"
+    },
+    "./markdownListIndentation": {
+      "types": "./src/markdownListIndentation.ts",
+      "import": "./src/markdownListIndentation.ts"
+    },
+    "./proposedPlanText": {
+      "types": "./src/proposedPlanText.ts",
+      "import": "./src/proposedPlanText.ts"
+    },
+    "./markdownPipeline": {
+      "types": "./src/markdownPipeline.ts",
+      "import": "./src/markdownPipeline.ts"
+    },
+    "./threadFindText": {
+      "types": "./src/threadFindText.ts",
+      "import": "./src/threadFindText.ts"
+    },
+    "./threadSearch": {
+      "types": "./src/threadSearch.ts",
+      "import": "./src/threadSearch.ts"
+    },
+    "./markdownLinks": {
+      "types": "./src/markdownLinks.ts",
+      "import": "./src/markdownLinks.ts"
+    },
+    "./fileLinks": {
+      "types": "./src/fileLinks.ts",
+      "import": "./src/fileLinks.ts"
     }
   },
   "scripts": {
@@ -414,12 +458,23 @@
     "@t3tools/contracts": "workspace:*",
     "effect": "catalog:",
     "jose": "catalog:",
+    "mdast-util-directive": "^3.1.0",
+    "micromark-extension-directive": "^4.0.0",
+    "micromark-util-character": "^2.1.1",
+    "rehype-raw": "^7.0.0",
+    "rehype-sanitize": "^6.0.0",
+    "remark-breaks": "^4.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "unified": "^11.0.5",
     "yaml": "catalog:"
   },
   "devDependencies": {
     "@effect/platform-node": "catalog:",
     "@effect/vitest": "catalog:",
     "@types/node": "catalog:",
+    "micromark-util-types": "^2.0.2",
     "vite-plus": "catalog:"
   }
 }
diff --git a/packages/client-runtime/src/codexArtifactTemplates.test.ts b/packages/shared/src/codexArtifactTemplates.test.ts
similarity index 99%
rename from packages/client-runtime/src/codexArtifactTemplates.test.ts
rename to packages/shared/src/codexArtifactTemplates.test.ts
index d92236104a56..65c1d489039f 100644
--- a/packages/client-runtime/src/codexArtifactTemplates.test.ts
+++ b/packages/shared/src/codexArtifactTemplates.test.ts
@@ -6,7 +6,7 @@ import {
   codexArtifactTemplateUsePrompt,
   resolveCodexArtifactTemplate,
   type CodexArtifactTemplate,
-} from "./codexArtifactTemplates.js";
+} from "./codexArtifactTemplates.ts";
 
 const HELLO_WORLD_TEMPLATE: CodexArtifactTemplate = {
   artifactKind: "document",
diff --git a/packages/client-runtime/src/codexArtifactTemplates.ts b/packages/shared/src/codexArtifactTemplates.ts
similarity index 100%
rename from packages/client-runtime/src/codexArtifactTemplates.ts
rename to packages/shared/src/codexArtifactTemplates.ts
diff --git a/packages/client-runtime/src/codexFileCitations.test.ts b/packages/shared/src/codexFileCitations.test.ts
similarity index 98%
rename from packages/client-runtime/src/codexFileCitations.test.ts
rename to packages/shared/src/codexFileCitations.test.ts
index d132a5480ca4..e993d777cd2d 100644
--- a/packages/client-runtime/src/codexFileCitations.test.ts
+++ b/packages/shared/src/codexFileCitations.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vite-plus/test";
 
-import { codexFileCitationMarkdown, resolveCodexFileCitationLink } from "./codexFileCitations.js";
+import { codexFileCitationMarkdown, resolveCodexFileCitationLink } from "./codexFileCitations.ts";
 
 describe("resolveCodexFileCitationLink", () => {
   it("resolves the attributes emitted by Codex", () => {
diff --git a/packages/client-runtime/src/codexFileCitations.ts b/packages/shared/src/codexFileCitations.ts
similarity index 100%
rename from packages/client-runtime/src/codexFileCitations.ts
rename to packages/shared/src/codexFileCitations.ts
diff --git a/packages/client-runtime/src/codexMarkdownDirectives.test.ts b/packages/shared/src/codexMarkdownDirectives.test.ts
similarity index 98%
rename from packages/client-runtime/src/codexMarkdownDirectives.test.ts
rename to packages/shared/src/codexMarkdownDirectives.test.ts
index efd5262d073c..2cfd1a0e20bb 100644
--- a/packages/client-runtime/src/codexMarkdownDirectives.test.ts
+++ b/packages/shared/src/codexMarkdownDirectives.test.ts
@@ -7,8 +7,8 @@ import {
   renderCodexDirectivesForCopy,
   renderCodexFileCitationsAsMarkdown,
   splitCodexArtifactTemplateMarkdown,
-} from "./codexMarkdownDirectives.js";
-import { parseMarkdownFileLink } from "./markdownLinks.js";
+} from "./codexMarkdownDirectives.ts";
+import { parseMarkdownFileLink } from "./markdownLinks.ts";
 
 interface TestNode {
   readonly type: string;
diff --git a/packages/client-runtime/src/codexMarkdownDirectives.ts b/packages/shared/src/codexMarkdownDirectives.ts
similarity index 100%
rename from packages/client-runtime/src/codexMarkdownDirectives.ts
rename to packages/shared/src/codexMarkdownDirectives.ts
diff --git a/packages/shared/src/composerContextLegacy.ts b/packages/shared/src/composerContextLegacy.ts
index 4f3fd51f1a70..b13caa51e3e9 100644
--- a/packages/shared/src/composerContextLegacy.ts
+++ b/packages/shared/src/composerContextLegacy.ts
@@ -24,8 +24,10 @@ export interface UpgradedLegacyContext {
 }
 
 const PLACEHOLDER = "";
-const TRAILING_TERMINAL = /\n*<terminal_context>\n([\s\S]*?)\n<\/terminal_context>\s*$/;
-const TRAILING_ELEMENT = /\n*<element_context>\n([\s\S]*?)\n<\/element_context>\s*$/;
+const TRAILING_TERMINAL =
+  /\n*<terminal_context>\n((?:(?!\n<\/terminal_context>)[\s\S])*)\n<\/terminal_context>\s*$/;
+const TRAILING_ELEMENT =
+  /\n*<element_context>\n((?:(?!\n<\/element_context>)[\s\S])*)\n<\/element_context>\s*$/;
 const TRAILING_PREVIEW =
   /\n*<preview_annotation>\n((?:(?!\n<\/preview_annotation>)[\s\S])*)\n<\/preview_annotation>\s*$/;
 const REVIEW_OR_CONTEXT_BLOCK =
diff --git a/packages/shared/src/fileLinks.test.ts b/packages/shared/src/fileLinks.test.ts
new file mode 100644
index 000000000000..7eee43b5998e
--- /dev/null
+++ b/packages/shared/src/fileLinks.test.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vite-plus/test";
+import { parseFileUrlHref, splitFilePathPosition, resolvePathLinkTarget } from "./fileLinks.ts";
+
+describe("parseFileUrlHref", () => {
+  it.each([
+    ["file:///Users/julius/project/src/main.ts#L42", "/Users/julius/project/src/main.ts", "#L42"],
+    [
+      "file:///D:/Programme/t3code/OpenInPicker.tsx#L69",
+      "D:/Programme/t3code/OpenInPicker.tsx",
+      "#L69",
+    ],
+    ["file://server/share/workspace-image.svg", "\\\\server\\share\\workspace-image.svg", ""],
+    ["file://localhost/home/me/notes.md", "/home/me/notes.md", ""],
+  ])("parses %s", (href, path, hash) => {
+    expect(parseFileUrlHref(href)).toEqual({ path, hash });
+  });
+
+  it("keeps percent-encoding so the caller decodes once", () => {
+    expect(parseFileUrlHref("file:///Users/julius/project/file%2520name.md")?.path).toBe(
+      "/Users/julius/project/file%2520name.md",
+    );
+    expect(parseFileUrlHref("file:///c%3A/Users/x/shot.png")?.path).toBe("/c%3A/Users/x/shot.png");
+  });
+
+  it.each(["https://example.com/a.ts", "file://%", "/Users/julius/a.ts"])("rejects %s", (href) => {
+    expect(parseFileUrlHref(href)).toBeNull();
+  });
+});
+
+describe("splitFilePathPosition", () => {
+  it.each([
+    ["src/main.ts", "", { path: "src/main.ts" }],
+    ["src/main.ts:12", "", { path: "src/main.ts", line: 12 }],
+    ["src/main.ts:12:5", "", { path: "src/main.ts", line: 12, column: 5 }],
+    ["src/main.ts", "#L18C2", { path: "src/main.ts", line: 18, column: 2 }],
+    ["src/main.ts:3", "#L18C2", { path: "src/main.ts", line: 3 }],
+    ["src/main.ts:0", "", { path: "src/main.ts" }],
+    ["src/main.ts", "#section", { path: "src/main.ts" }],
+  ])("splits %s%s", (path, hash, expected) => {
+    expect(splitFilePathPosition(path, hash)).toEqual(expected);
+  });
+});
+
+describe("resolvePathLinkTarget", () => {
+  it("resolves relative paths against cwd", () => {
+    expect(
+      resolvePathLinkTarget(
+        "src/components/ThreadTerminalDrawer.tsx:42:7",
+        "/Users/julius/project",
+      ),
+    ).toBe("/Users/julius/project/src/components/ThreadTerminalDrawer.tsx:42:7");
+  });
+
+  it("keeps absolute paths unchanged", () => {
+    expect(
+      resolvePathLinkTarget("/Users/julius/project/src/main.ts:12", "/Users/julius/project"),
+    ).toBe("/Users/julius/project/src/main.ts:12");
+  });
+
+  it("keeps Windows absolute paths with forward slashes unchanged", () => {
+    expect(
+      resolvePathLinkTarget("C:/Users/julius/project/src/main.ts:12", "C:\\Users\\julius\\project"),
+    ).toBe("C:/Users/julius/project/src/main.ts:12");
+  });
+});
diff --git a/packages/shared/src/fileLinks.ts b/packages/shared/src/fileLinks.ts
new file mode 100644
index 000000000000..2f85669797a7
--- /dev/null
+++ b/packages/shared/src/fileLinks.ts
@@ -0,0 +1,183 @@
+import {
+  fileBasename,
+  isAbsolutePath,
+  isWindowsAbsolutePath,
+  stripSlashPrefixedWindowsDrive,
+} from "./path.ts";
+
+const POSITION_SUFFIX_CAPTURE_PATTERN = /:(\d+)(?::(\d+))?$/;
+
+const POSITION_HASH_PATTERN = /^#L(\d+)(?:C(\d+))?$/i;
+
+/**
+ * Turns a `file:` URL into a host path, still percent-encoded so callers that
+ * decode every destination in one place do not decode file URLs twice. A
+ * non-localhost authority becomes a UNC share.
+ */
+export function parseFileUrlHref(
+  href: string,
+): { readonly path: string; readonly hash: string } | null {
+  try {
+    const parsed = new URL(href);
+    if (parsed.protocol.toLowerCase() !== "file:") return null;
+
+    const uncHostname = parsed.hostname.toLowerCase() === "localhost" ? "" : parsed.hostname;
+    const path = uncHostname
+      ? `\\\\${uncHostname}${parsed.pathname.replaceAll("/", "\\")}`
+      : parsed.pathname;
+    if (path.length === 0) return null;
+    return { path: stripSlashPrefixedWindowsDrive(path), hash: parsed.hash };
+  } catch {
+    return null;
+  }
+}
+
+export interface FilePathPosition {
+  readonly path: string;
+  readonly line?: number;
+  readonly column?: number;
+}
+
+export function splitFilePathPosition(path: string, hash = ""): FilePathPosition {
+  const suffixMatch = path.match(POSITION_SUFFIX_CAPTURE_PATTERN);
+  const match = suffixMatch ?? hash.match(POSITION_HASH_PATTERN);
+  if (!match?.[1]) return { path };
+
+  const line = Number.parseInt(match[1], 10);
+  const column = match[2] === undefined ? undefined : Number.parseInt(match[2], 10);
+  return {
+    path: suffixMatch ? path.slice(0, -suffixMatch[0].length) : path,
+    ...(line > 0 ? { line } : {}),
+    ...(column !== undefined && column > 0 ? { column } : {}),
+  };
+}
+
+export function formatFilePathPosition(position: FilePathPosition): string {
+  if (!position.line) return position.path;
+  return `${position.path}:${position.line}${position.column ? `:${position.column}` : ""}`;
+}
+
+function isWindowsPathStyle(value: string): boolean {
+  return isWindowsAbsolutePath(value) || /[A-Za-z]:\\/.test(value);
+}
+
+function joinPath(base: string, next: string, separator: "/" | "\\"): string {
+  const cleanBase = base.replace(/[\\/]+$/, "");
+  if (separator === "\\") {
+    return `${cleanBase}\\${next.replaceAll("/", "\\")}`;
+  }
+  return `${cleanBase}/${next.replace(/^\/+/, "")}`;
+}
+
+function inferHomeFromCwd(cwd: string): string | undefined {
+  const posixUser = cwd.match(/^\/Users\/([^/]+)/);
+  if (posixUser?.[1]) {
+    return `/Users/${posixUser[1]}`;
+  }
+
+  const posixHome = cwd.match(/^\/home\/([^/]+)/);
+  if (posixHome?.[1]) {
+    return `/home/${posixHome[1]}`;
+  }
+
+  const windowsUser = cwd.match(/^([A-Za-z]:\\Users\\[^\\]+)/);
+  if (windowsUser?.[1]) {
+    return windowsUser[1];
+  }
+
+  return undefined;
+}
+
+export function resolvePathLinkTarget(rawPath: string, cwd: string): string {
+  const position = splitFilePathPosition(rawPath);
+  const { path } = position;
+
+  let resolvedPath = path;
+  if (path.startsWith("~/")) {
+    const home = inferHomeFromCwd(cwd);
+    if (home) {
+      const separator: "/" | "\\" = isWindowsPathStyle(home) ? "\\" : "/";
+      resolvedPath = joinPath(home, path.slice(2), separator);
+    }
+  } else if (!isAbsolutePath(path)) {
+    const separator: "/" | "\\" = isWindowsPathStyle(cwd) ? "\\" : "/";
+    resolvedPath = joinPath(cwd, path, separator);
+  }
+
+  return formatFilePathPosition({ ...position, path: resolvedPath });
+}
+
+function pathParentSegments(path: string): string[] {
+  const normalized = path.replaceAll("\\", "/");
+  const segments = normalized.split("/").filter((segment) => segment.length > 0);
+  return segments.slice(0, -1);
+}
+
+export function buildFileLinkParentSuffixByPath(
+  filePaths: ReadonlyArray<string>,
+): Map<string, string> {
+  const groups = new Map<string, Set<string>>();
+  for (const filePath of filePaths) {
+    const normalizedPath = filePath.replaceAll("\\", "/");
+    const pathSegments = normalizedPath.split("/").filter((segment) => segment.length > 0);
+    const basename = pathSegments[pathSegments.length - 1];
+    if (!basename) continue;
+    const group = groups.get(basename) ?? new Set<string>();
+    group.add(normalizedPath);
+    groups.set(basename, group);
+  }
+
+  const suffixByPath = new Map<string, string>();
+  for (const group of groups.values()) {
+    const uniquePaths = [...group];
+    if (uniquePaths.length < 2) continue;
+
+    const parentSegmentsByPath = new Map(
+      uniquePaths.map((filePath) => [filePath, pathParentSegments(filePath)]),
+    );
+    const minUniqueDepthByPath = new Map<string, number>();
+
+    for (const filePath of uniquePaths) {
+      const segments = parentSegmentsByPath.get(filePath) ?? [];
+      let resolvedDepth = segments.length;
+      for (let depth = 1; depth <= segments.length; depth += 1) {
+        const candidate = segments.slice(-depth).join("/");
+        const collision = uniquePaths.some((otherPath) => {
+          if (otherPath === filePath) return false;
+          const otherSegments = parentSegmentsByPath.get(otherPath) ?? [];
+          return otherSegments.slice(-depth).join("/") === candidate;
+        });
+        if (!collision) {
+          resolvedDepth = depth;
+          break;
+        }
+      }
+      minUniqueDepthByPath.set(filePath, resolvedDepth);
+    }
+
+    for (const filePath of uniquePaths) {
+      const segments = parentSegmentsByPath.get(filePath) ?? [];
+      if (segments.length === 0) continue;
+      const minUniqueDepth = minUniqueDepthByPath.get(filePath) ?? 1;
+      const suffixDepth = Math.min(segments.length, Math.max(minUniqueDepth, 2));
+      suffixByPath.set(filePath, segments.slice(-suffixDepth).join("/"));
+    }
+  }
+
+  return suffixByPath;
+}
+
+/** Visible text of a file chip, shared by Markdown rendering and thread search. */
+export function fileLinkLabel(
+  file: FilePathPosition,
+  parentSuffixByPath: ReadonlyMap<string, string>,
+): string {
+  const suffix = parentSuffixByPath.get(file.path.replaceAll("\\", "/"));
+  return [
+    fileBasename(file.path),
+    suffix,
+    file.line ? `L${file.line}${file.column ? `:C${file.column}` : ""}` : undefined,
+  ]
+    .filter(Boolean)
+    .join(" · ");
+}
diff --git a/packages/shared/src/keybindings.ts b/packages/shared/src/keybindings.ts
index 84cfeef663e0..0e95775fbb37 100644
--- a/packages/shared/src/keybindings.ts
+++ b/packages/shared/src/keybindings.ts
@@ -171,6 +171,7 @@ export const DEFAULT_KEYBINDINGS: ReadonlyArray<KeybindingRule> = [
   { key: "mod+shift+o", command: "chat.new", when: "!terminalFocus" },
   { key: "mod+shift+n", command: "chat.newLocal", when: "!terminalFocus" },
   { key: "mod+alt+n", command: "chat.newWithoutProject", when: "!terminalFocus" },
+  { key: "mod+f", command: "chat.find", when: "!terminalFocus && !previewFocus" },
   { key: "mod+shift+m", command: "modelPicker.toggle", when: "!terminalFocus" },
   { key: "mod+shift+h", command: "composer.host", when: "!terminalFocus" },
   { key: "mod+shift+e", command: "composer.effort", when: "!terminalFocus" },
diff --git a/apps/web/src/markdown-github-alerts.ts b/packages/shared/src/markdownGithubAlerts.ts
similarity index 100%
rename from apps/web/src/markdown-github-alerts.ts
rename to packages/shared/src/markdownGithubAlerts.ts
diff --git a/packages/client-runtime/src/markdownLinks.test.ts b/packages/shared/src/markdownLinks.test.ts
similarity index 66%
rename from packages/client-runtime/src/markdownLinks.test.ts
rename to packages/shared/src/markdownLinks.test.ts
index b6e52e4534a1..b16b01008f96 100644
--- a/packages/client-runtime/src/markdownLinks.test.ts
+++ b/packages/shared/src/markdownLinks.test.ts
@@ -1,13 +1,17 @@
+import { splitFilePathPosition } from "./fileLinks.ts";
+import { parseFileUrlHref } from "./fileLinks.ts";
+import { workspaceRelativeFilePath, fileBasename } from "./path.ts";
 import { describe, expect, it } from "vite-plus/test";
+import {
+  extractMarkdownLinkHrefs,
+  resolveMarkdownFileLinkTarget,
+  isWindowsDrivePathHref,
+} from "./markdownLinks.ts";
 
 import {
-  fileBasename,
   inlineCodeFilePathCandidate,
   isMarkdownFileLinkLabel,
-  parseFileUrlHref,
   parseMarkdownFileLink,
-  splitFilePathPosition,
-  workspaceRelativeFilePath,
 } from "./markdownLinks.ts";
 
 describe("isMarkdownFileLinkLabel", () => {
@@ -206,3 +210,119 @@ describe("workspaceRelativeFilePath", () => {
     expect(workspaceRelativeFilePath(path, workspaceRoot)).toBe(relativePath);
   });
 });
+
+describe("isWindowsDrivePathHref", () => {
+  it.each([
+    ["C:\\repo\\image.png", true],
+    ["C:%5Crepo%5Cimage.png", true],
+    ["https://example.com/image.png", false],
+  ])("classifies %s as %s", (href, expected) => {
+    expect(isWindowsDrivePathHref(href)).toBe(expected);
+  });
+});
+
+describe("extractMarkdownLinkHrefs", () => {
+  it("extracts angle-bracketed paths containing spaces", () => {
+    expect(
+      extractMarkdownLinkHrefs(
+        "[Open the Bike Receipts folder](</Users/dara/Downloads/Lime Ride Artifacts/Bike Receipts>)",
+      ),
+    ).toEqual(["/Users/dara/Downloads/Lime Ride Artifacts/Bike Receipts"]);
+  });
+
+  it("preserves ordinary destinations and ignores link titles", () => {
+    expect(
+      extractMarkdownLinkHrefs(
+        '[source](apps/web/src/markdown-links.ts "implementation") and [docs](https://example.com)',
+      ),
+    ).toEqual(["apps/web/src/markdown-links.ts", "https://example.com"]);
+  });
+});
+
+describe("resolveMarkdownFileLinkTarget", () => {
+  it("resolves absolute posix file paths", () => {
+    expect(resolveMarkdownFileLinkTarget("/Users/julius/project/AGENTS.md")).toBe(
+      "/Users/julius/project/AGENTS.md",
+    );
+  });
+
+  it("resolves relative file paths against cwd", () => {
+    expect(resolveMarkdownFileLinkTarget("src/processRunner.ts:71", "/Users/julius/project")).toBe(
+      "/Users/julius/project/src/processRunner.ts:71",
+    );
+  });
+
+  it("does not treat filename line references as external schemes", () => {
+    expect(resolveMarkdownFileLinkTarget("script.ts:10", "/Users/julius/project")).toBe(
+      "/Users/julius/project/script.ts:10",
+    );
+  });
+
+  it("resolves bare file names against cwd", () => {
+    expect(resolveMarkdownFileLinkTarget("AGENTS.md", "/Users/julius/project")).toBe(
+      "/Users/julius/project/AGENTS.md",
+    );
+  });
+
+  it("maps #L line anchors to editor line suffixes", () => {
+    expect(resolveMarkdownFileLinkTarget("/Users/julius/project/src/main.ts#L42C7")).toBe(
+      "/Users/julius/project/src/main.ts:42:7",
+    );
+  });
+
+  it("ignores external urls", () => {
+    expect(resolveMarkdownFileLinkTarget("https://example.com/docs")).toBeNull();
+    expect(resolveMarkdownFileLinkTarget("//cdn.example.com/clip.mp4", "/workspace")).toBeNull();
+  });
+
+  it("does not double-decode file URLs", () => {
+    expect(resolveMarkdownFileLinkTarget("file:///Users/julius/project/file%2520name.md")).toBe(
+      "/Users/julius/project/file%20name.md",
+    );
+  });
+
+  it("resolves file uri authorities as windows UNC paths", () => {
+    expect(resolveMarkdownFileLinkTarget("file://server/share/workspace-image.svg")).toBe(
+      "\\\\server\\share\\workspace-image.svg",
+    );
+  });
+
+  it("resolves a localhost file uri as a local path", () => {
+    expect(resolveMarkdownFileLinkTarget("file://localhost/home/me/notes.md")).toBe(
+      "/home/me/notes.md",
+    );
+  });
+
+  it("keeps an encoded final space in the absolute target", () => {
+    expect(resolveMarkdownFileLinkTarget("/tmp/repo/file.ts%20", "/tmp/repo")).toBe(
+      "/tmp/repo/file.ts ",
+    );
+  });
+
+  it("normalizes slash-prefixed windows drive paths before resolving", () => {
+    expect(
+      resolveMarkdownFileLinkTarget(
+        "/D:/Programme/t3code/apps/web/src/components/chat/OpenInPicker.tsx#L69",
+      ),
+    ).toBe("D:/Programme/t3code/apps/web/src/components/chat/OpenInPicker.tsx:69");
+  });
+
+  it("resolves angle-bracketed windows drive paths", () => {
+    expect(
+      resolveMarkdownFileLinkTarget(
+        "</D:/Programme/t3code/apps/web/src/components/ChatMarkdown.tsx:1>",
+      ),
+    ).toBe("D:/Programme/t3code/apps/web/src/components/ChatMarkdown.tsx:1");
+  });
+
+  it("does not treat app routes as file links, even with a line anchor", () => {
+    expect(resolveMarkdownFileLinkTarget("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/chat/settings")).toBeNull();
+    expect(resolveMarkdownFileLinkTarget("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/chat/settings#L3", "/repo")).toBeNull();
+  });
+
+  it("decodes an encoded drive colon in a file uri before dropping its slash", () => {
+    expect(resolveMarkdownFileLinkTarget("file:///c%3A/Users/x/shot.png")).toBe(
+      "c:/Users/x/shot.png",
+    );
+  });
+});
diff --git a/packages/client-runtime/src/markdownLinks.ts b/packages/shared/src/markdownLinks.ts
similarity index 71%
rename from packages/client-runtime/src/markdownLinks.ts
rename to packages/shared/src/markdownLinks.ts
index 88db0e5a725a..4055ccb08967 100644
--- a/packages/client-runtime/src/markdownLinks.ts
+++ b/packages/shared/src/markdownLinks.ts
@@ -1,23 +1,36 @@
-import { isWindowsAbsolutePath } from "@t3tools/shared/path";
+import { isWindowsAbsolutePath, stripSlashPrefixedWindowsDrive } from "./path.ts";
+import {
+  type FilePathPosition,
+  formatFilePathPosition,
+  parseFileUrlHref,
+  resolvePathLinkTarget,
+  splitFilePathPosition,
+} from "./fileLinks.ts";
 
-const SLASH_PREFIXED_WINDOWS_DRIVE_PATTERN = /^\/[A-Za-z]:[\\/]/;
 const RELATIVE_PATH_PREFIX_PATTERN = /^(~\/|\.{1,2}\/)/;
+
 const RELATIVE_FILE_PATH_PATTERN =
   /^(?:[A-Za-z0-9._-]+(?: +[A-Za-z0-9._-]+)*\/)+[A-Za-z0-9._-]+(?: +[A-Za-z0-9._-]+)*(?::\d+){0,2}$/;
+
 const RELATIVE_FILE_NAME_PATTERN =
   /^[A-Za-z0-9._-]+(?: +[A-Za-z0-9._-]+)*\.[A-Za-z0-9_-]+(?::\d+){0,2}$/;
+
 const EXTERNAL_SCHEME_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):(.*)$/;
+
 const POSITION_SUFFIX_PATTERN = /:\d+(?::\d+)?$/;
-const POSITION_SUFFIX_CAPTURE_PATTERN = /:(\d+)(?::(\d+))?$/;
-const POSITION_HASH_PATTERN = /^#L(\d+)(?:C(\d+))?$/i;
+
 const POSITION_ONLY_PATTERN = /^\d+(?::\d+)?$/;
+
 const INLINE_CODE_DISQUALIFIER_PATTERN = /[\s`]/;
+
 const PATH_SEPARATOR_PATTERN = /[\\/]/;
+
 const FILE_EXTENSION_PATTERN = /\.[A-Za-z0-9_-]+$/;
 // A final dot between digits marks a version or model id (`glm-5.3`,
 // `Qwen2.5-Coder`), not an extension. `ls.1` and `libfoo.so.1` stay files.
 const VERSION_SUFFIX_PATTERN = /\d\.\d[^.]*$/;
 const NUMERIC_DOTTED_PATTERN = /^\d+(?:\.\d+)+$/;
+
 // Standard OS and dev-container roots; deliberately excludes app-route-ish
 // prefixes like /app/ or /chat/ so SPA routes never read as files.
 const POSIX_FILE_ROOT_PREFIXES = [
@@ -46,6 +59,7 @@ const POSIX_FILE_ROOT_PREFIXES = [
   "/workspace/",
   "/workspaces/",
 ] as const;
+
 // `Name:digits` also matches `error:1`, `port:3000`, and `TODO:12`.
 const EXTENSIONLESS_FILE_NAMES = new Set([
   "Makefile",
@@ -76,7 +90,9 @@ const EXTENSIONLESS_FILE_NAMES = new Set([
   "README",
   "CODEOWNERS",
 ]);
+
 const SINGLE_LABEL_HOSTNAMES = new Set(["localhost"]);
+
 // These allowlists avoid classifying dotted directories such as `conf.d/`
 // or filenames such as `Makefile.in:12` as hosts.
 const GENERIC_HOSTNAME_TLDS = new Set([
@@ -106,6 +122,7 @@ const GENERIC_HOSTNAME_TLDS = new Set([
   "store",
   "link",
 ]);
+
 // Country codes also name file extensions. A :line suffix makes `.pl`
 // and `.pt` files more likely than hostnames.
 const COUNTRY_HOSTNAME_TLDS = new Set([
@@ -198,11 +215,6 @@ export function normalizeMarkdownLinkDestination(value: string): string {
   return trimmed.startsWith("<") && trimmed.endsWith(">") ? trimmed.slice(1, -1) : trimmed;
 }
 
-/** Browser URL parsers write `C:/foo` as `/C:/foo` for file URLs. */
-export function stripSlashPrefixedWindowsDrive(path: string): string {
-  return SLASH_PREFIXED_WINDOWS_DRIVE_PATTERN.test(path) ? path.slice(1) : path;
-}
-
 export function splitMarkdownLinkSearchAndHash(value: string): {
   readonly path: string;
   readonly hash: string;
@@ -217,54 +229,6 @@ export function splitMarkdownLinkSearchAndHash(value: string): {
   };
 }
 
-/**
- * Turns a `file:` URL into a host path, still percent-encoded so callers that
- * decode every destination in one place do not decode file URLs twice. A
- * non-localhost authority becomes a UNC share.
- */
-export function parseFileUrlHref(
-  href: string,
-): { readonly path: string; readonly hash: string } | null {
-  try {
-    const parsed = new URL(href);
-    if (parsed.protocol.toLowerCase() !== "file:") return null;
-
-    const uncHostname = parsed.hostname.toLowerCase() === "localhost" ? "" : parsed.hostname;
-    const path = uncHostname
-      ? `\\\\${uncHostname}${parsed.pathname.replaceAll("/", "\\")}`
-      : parsed.pathname;
-    if (path.length === 0) return null;
-    return { path: stripSlashPrefixedWindowsDrive(path), hash: parsed.hash };
-  } catch {
-    return null;
-  }
-}
-
-export interface FilePathPosition {
-  readonly path: string;
-  readonly line?: number;
-  readonly column?: number;
-}
-
-export function splitFilePathPosition(path: string, hash = ""): FilePathPosition {
-  const suffixMatch = path.match(POSITION_SUFFIX_CAPTURE_PATTERN);
-  const match = suffixMatch ?? hash.match(POSITION_HASH_PATTERN);
-  if (!match?.[1]) return { path };
-
-  const line = Number.parseInt(match[1], 10);
-  const column = match[2] === undefined ? undefined : Number.parseInt(match[2], 10);
-  return {
-    path: suffixMatch ? path.slice(0, -suffixMatch[0].length) : path,
-    ...(line > 0 ? { line } : {}),
-    ...(column !== undefined && column > 0 ? { column } : {}),
-  };
-}
-
-export function formatFilePathPosition(position: FilePathPosition): string {
-  if (!position.line) return position.path;
-  return `${position.path}:${position.line}${position.column ? `:${position.column}` : ""}`;
-}
-
 /** Keeps filename and destination-path labels compact without discarding prose. */
 export function isMarkdownFileLinkLabel(label: string, href: string): boolean {
   const destination = parseMarkdownFileLink(href);
@@ -342,28 +306,54 @@ export function parseMarkdownFileLink(href: string): FilePathPosition | null {
   return looksLikeFilePath(position.path, path) ? position : null;
 }
 
-export function fileBasename(path: string): string {
-  // A trailing separator is a valid way to write a directory. Trim it before
-  // taking the final segment so the label is never empty.
-  const trimmed = path.replace(/[/\\]+$/, "");
-  if (trimmed.length === 0) return path;
-  const separatorIndex = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
-  return separatorIndex >= 0 ? trimmed.slice(separatorIndex + 1) : trimmed;
+const FENCED_CODE_SEGMENT_PATTERN = /(```[\s\S]*?(?:```|$))/;
+
+const INLINE_CODE_SPAN_PATTERN = /`([^`\n]+)`/g;
+
+export function extractInlineCodeSpans(text: string): string[] {
+  const spans: string[] = [];
+  const segments = text.split(FENCED_CODE_SEGMENT_PATTERN);
+  for (let index = 0; index < segments.length; index += 2) {
+    for (const match of (segments[index] ?? "").matchAll(INLINE_CODE_SPAN_PATTERN)) {
+      const span = match[1]?.trim();
+      if (span) spans.push(span);
+    }
+  }
+  return spans;
+}
+
+const MARKDOWN_LINK_HREF_PATTERN =
+  /\[[^\]]*]\(\s*(?:<([^>\n]+)>|([^\s)]+))(?:\s+["'][^"']*["'])?\s*\)/g;
+
+export function extractMarkdownLinkHrefs(markdown: string): string[] {
+  const hrefs: string[] = [];
+  for (const match of markdown.matchAll(MARKDOWN_LINK_HREF_PATTERN)) {
+    const href = (match[1] ?? match[2])?.trim();
+    if (href) hrefs.push(href);
+  }
+  return hrefs;
 }
 
-export function workspaceRelativeFilePath(
-  path: string,
-  workspaceRoot: string | null | undefined,
+/**
+ * `baseDir` anchors relative links; it defaults to the workspace root and is the
+ * file's own directory when rendering a markdown file. `cwd` stays the workspace
+ * root so the result still knows whether the target is inside it.
+ */
+export function resolveMarkdownFileLinkTarget(
+  href: string | undefined,
+  cwd?: string,
+  baseDir: string | undefined = cwd,
 ): string | null {
-  if (!workspaceRoot) return null;
-  const normalizedPath = stripSlashPrefixedWindowsDrive(path.replaceAll("\\", "/"));
-  const normalizedRoot = stripSlashPrefixedWindowsDrive(
-    workspaceRoot.replaceAll("\\", "/"),
-  ).replace(/\/+$/, "");
-  const caseInsensitive = isWindowsAbsolutePath(stripSlashPrefixedWindowsDrive(workspaceRoot));
-  const pathForCompare = caseInsensitive ? normalizedPath.toLowerCase() : normalizedPath;
-  const rootForCompare = caseInsensitive ? normalizedRoot.toLowerCase() : normalizedRoot;
-  if (pathForCompare.replace(/\/+$/, "") === rootForCompare) return ".";
-  if (!pathForCompare.startsWith(`${rootForCompare}/`)) return null;
-  return normalizedPath.slice(normalizedRoot.length + 1);
+  if (!href) return null;
+  const target = parseMarkdownFileLink(href);
+  if (!target) return null;
+
+  const pathWithPosition = formatFilePathPosition(target);
+  if (!isRelativeFilePath(pathWithPosition)) return pathWithPosition;
+  if (!baseDir) return null;
+  return resolvePathLinkTarget(pathWithPosition, baseDir);
+}
+
+export function isWindowsDrivePathHref(href: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(safeDecodeURIComponent(href));
 }
diff --git a/apps/web/src/markdown-list-indentation.ts b/packages/shared/src/markdownListIndentation.ts
similarity index 100%
rename from apps/web/src/markdown-list-indentation.ts
rename to packages/shared/src/markdownListIndentation.ts
diff --git a/packages/shared/src/markdownPipeline.ts b/packages/shared/src/markdownPipeline.ts
new file mode 100644
index 000000000000..918c0db6d2da
--- /dev/null
+++ b/packages/shared/src/markdownPipeline.ts
@@ -0,0 +1,232 @@
+import type { Processor } from "unified";
+import { isWindowsAbsolutePath } from "./path.ts";
+import type { PluggableList } from "unified";
+import rehypeRaw from "rehype-raw";
+import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
+import remarkBreaks from "remark-breaks";
+import remarkGfm from "remark-gfm";
+import { remarkGithubAlerts } from "./markdownGithubAlerts.ts";
+import { remarkNormalizeListItemIndentation } from "./markdownListIndentation.ts";
+import {
+  CODEX_ARTIFACT_TEMPLATE_HAST_PROPERTIES,
+  remarkCodexDirectives,
+} from "./codexMarkdownDirectives.ts";
+import { isWindowsDrivePathHref } from "./markdownLinks.ts";
+
+type MarkdownImageHastNode = {
+  type?: string;
+  tagName?: string;
+  properties?: Record<string, unknown>;
+  children?: MarkdownImageHastNode[];
+};
+
+function meaningfulHastChildren(node: MarkdownImageHastNode): MarkdownImageHastNode[] {
+  return (node.children ?? []).filter(
+    (child) => !(child.type === "text" && (child as { value?: string }).value?.trim() === ""),
+  );
+}
+
+/**
+ * An image that is the only content of its block (optionally wrapped in a
+ * link) is almost always a screenshot or figure, so it gets a reserved slot
+ * while it loads. Images mixed with text or other images — badge rows, icons
+ * in a sentence — stay inline at their natural size, since a placeholder taller
+ * than the image would move the page more than the image itself does.
+ */
+/** Containers whose sole child image reads as a figure rather than part of a sentence. */
+const STANDALONE_IMAGE_BLOCKS = new Set([
+  "p",
+  "div",
+  "li",
+  "td",
+  "th",
+  "figure",
+  "center",
+  "blockquote",
+]);
+
+function soleImageDescendant(node: MarkdownImageHastNode): MarkdownImageHastNode | undefined {
+  const children = meaningfulHastChildren(node);
+  if (children.length !== 1) return undefined;
+  const only = children[0];
+  if (only?.type !== "element") return undefined;
+  if (only.tagName === "img") return only;
+  // A link, emphasis, or similar inline wrapper around the image still counts
+  // as long as nothing else shares the block.
+  return only.tagName === "a" || only.tagName === "strong" || only.tagName === "em"
+    ? soleImageDescendant(only)
+    : undefined;
+}
+
+function markStandaloneImages(node: MarkdownImageHastNode) {
+  // A raw `<img>` on its own line reaches the root without a paragraph.
+  if (node.type === "root" || (node.tagName && STANDALONE_IMAGE_BLOCKS.has(node.tagName))) {
+    const image = soleImageDescendant(node);
+    if (image) image.properties = { ...image.properties, dataStandalone: true };
+  }
+  node.children?.forEach((child) => {
+    if (child.type === "element") markStandaloneImages(child);
+  });
+}
+
+/** Carries authored image source metadata through the sanitizer to the image renderer. */
+function rehypePreserveImageSourceMeta() {
+  return (tree: MarkdownImageHastNode) => {
+    const visit = (node: MarkdownImageHastNode) => {
+      const src = node.properties?.src;
+      const title = node.properties?.title;
+      if (node.type === "element" && node.tagName === "img") {
+        node.properties = {
+          ...node.properties,
+          ...(typeof src === "string" && isWindowsDrivePathHref(src) ? { dataLocalSrc: src } : {}),
+          ...(typeof title === "string" ? { dataMarkdownTitle: title } : {}),
+        };
+      }
+      node.children?.forEach(visit);
+    };
+
+    visit(tree);
+    markStandaloneImages(tree);
+  };
+}
+
+const CHAT_MARKDOWN_SANITIZE_SCHEMA = {
+  ...defaultSchema,
+  attributes: {
+    ...defaultSchema.attributes,
+    "*": (defaultSchema.attributes?.["*"] ?? []).filter((attribute) => attribute !== "title"),
+    code: [...(defaultSchema.attributes?.code ?? []), "dataCodeMeta", "dataInlineCode"],
+    blockquote: [...(defaultSchema.attributes?.blockquote ?? []), "dataAlert"],
+    div: [...(defaultSchema.attributes?.div ?? []), ...CODEX_ARTIFACT_TEMPLATE_HAST_PROPERTIES],
+    a: [...(defaultSchema.attributes?.a ?? []), "dataPullRequestAutolink"],
+    img: [
+      ...(defaultSchema.attributes?.img ?? []),
+      "dataLocalSrc",
+      "dataMarkdownTitle",
+      "dataStandalone",
+    ],
+  },
+  protocols: {
+    ...defaultSchema.protocols,
+    href: [...(defaultSchema.protocols?.href ?? []), "file", "t3-citation", "t3-context"],
+    src: [...(defaultSchema.protocols?.src ?? []), "file", "t3-context"],
+  },
+} satisfies Parameters<typeof rehypeSanitize>[0];
+
+export const CHAT_MARKDOWN_REMARK_PLUGINS: PluggableList = [
+  remarkGfm,
+  remarkKeepWindowsPathDestinations,
+  remarkGithubAlerts,
+  remarkNormalizeListItemIndentation,
+  remarkCodexDirectives,
+  remarkPreserveCodeMeta,
+  remarkNormalizeLinksAndTagInlineCode,
+];
+
+export const CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS: PluggableList = [
+  remarkGfm,
+  remarkKeepWindowsPathDestinations,
+  remarkGithubAlerts,
+  remarkNormalizeListItemIndentation,
+  remarkCodexDirectives,
+  remarkBreaks,
+  remarkPreserveCodeMeta,
+  remarkNormalizeLinksAndTagInlineCode,
+];
+
+export const CHAT_MARKDOWN_REHYPE_PLUGINS: PluggableList = [
+  rehypeRaw,
+  rehypePreserveImageSourceMeta,
+  [rehypeSanitize, CHAT_MARKDOWN_SANITIZE_SCHEMA],
+];
+
+type MarkdownAstNode = {
+  type?: string;
+  meta?: unknown;
+  url?: string;
+  data?: {
+    hProperties?: Record<string, unknown>;
+  };
+  children?: MarkdownAstNode[];
+};
+
+function remarkPreserveCodeMeta() {
+  return (tree: MarkdownAstNode) => {
+    const visit = (node: MarkdownAstNode) => {
+      if (node.type === "code" && typeof node.meta === "string" && node.meta.trim().length > 0) {
+        node.data = {
+          ...node.data,
+          hProperties: {
+            ...node.data?.hProperties,
+            dataCodeMeta: node.meta.trim(),
+          },
+        };
+      }
+      node.children?.forEach(visit);
+    };
+
+    visit(tree);
+  };
+}
+
+/**
+ * Preserve Windows drive links as allowed `file:` URLs before sanitization.
+ * The same traversal tags inline code while it can still be distinguished
+ * from fenced code. Code inside links stays untagged to avoid nested anchors.
+ */
+function remarkNormalizeLinksAndTagInlineCode() {
+  return (tree: MarkdownAstNode) => {
+    const visit = (node: MarkdownAstNode, insideLink: boolean) => {
+      if (
+        (node.type === "link" || node.type === "definition") &&
+        typeof node.url === "string" &&
+        /^[A-Za-z]:[\\/]/.test(node.url)
+      ) {
+        node.url = `file:///${node.url.replaceAll("\\", "/")}`;
+      }
+      if (node.type === "inlineCode" && !insideLink) {
+        node.data = {
+          ...node.data,
+          hProperties: {
+            ...node.data?.hProperties,
+            dataInlineCode: "",
+          },
+        };
+      }
+      const childInsideLink = insideLink || node.type === "link" || node.type === "linkReference";
+      node.children?.forEach((child) => visit(child, childInsideLink));
+    };
+
+    visit(tree, false);
+  };
+}
+
+interface DestinationCompileContext {
+  readonly stack: ReadonlyArray<{ readonly type: string; url?: string }>;
+  resume(): string;
+  sliceSerialize(token: unknown): string;
+}
+
+function keepWindowsPathDestination(this: DestinationCompileContext, token: unknown) {
+  const decoded = this.resume();
+  const authored = this.sliceSerialize(token);
+  const node = this.stack.at(-1);
+  // Character references still need decoding, so those destinations keep the parsed URL.
+  if (node)
+    node.url = isWindowsAbsolutePath(authored) && !authored.includes("&") ? authored : decoded;
+}
+
+/**
+ * CommonMark reads the `\.` in `C:\me\.t3\shot.png` as an escape, even in a link
+ * destination. Every backslash in a Windows path is a separator, so link, image, and
+ * definition destinations that are Windows paths keep the text as written.
+ */
+function remarkKeepWindowsPathDestinations(this: Processor) {
+  const data = this.data();
+  (data.fromMarkdownExtensions ??= []).push({
+    exit: {
+      resourceDestinationString: keepWindowsPathDestination,
+      definitionDestinationString: keepWindowsPathDestination,
+    },
+  });
+}
diff --git a/packages/shared/src/path.test.ts b/packages/shared/src/path.test.ts
index b018a4e81d8c..705fdbf97ba6 100644
--- a/packages/shared/src/path.test.ts
+++ b/packages/shared/src/path.test.ts
@@ -1,5 +1,7 @@
 import { describe, expect, it } from "vite-plus/test";
 import {
+  fileBasename,
+  workspaceRelativeFilePath,
   isExplicitRelativePath,
   isUncPath,
   isWindowsAbsolutePath,
@@ -58,3 +60,40 @@ describe("path helpers", () => {
     expect(newProjectFolderName("console")).toBe("console");
   });
 });
+
+describe("fileBasename", () => {
+  it.each([
+    ["/tmp/favicons/", "favicons"],
+    ["C:\\Users\\kelchm\\.claude\\", ".claude"],
+    ["/tmp/", "tmp"],
+    ["AGENTS.md", "AGENTS.md"],
+    ["/", "/"],
+  ])("labels %s as %s", (path, basename) => {
+    expect(fileBasename(path)).toBe(basename);
+  });
+});
+
+describe("workspaceRelativeFilePath", () => {
+  it.each([
+    ["/repo/project/src/main.ts", "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/repo/project", "src/main.ts"],
+    ["/repo/project/src/main.ts", "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/repo/project/", "src/main.ts"],
+    ["C:\\Users\\mike\\t3code\\apps\\web\\a.ts", "C:/Users/mike/t3code", "apps/web/a.ts"],
+    ["/C:/Users/mike/t3code/apps/web/a.ts", "C:/Users/mike/t3code", "apps/web/a.ts"],
+    ["/Repo/Project/src/main.ts", "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/repo/project", null],
+    ["/tmp/case/project/probe.txt", "/tmp/case/Project", null],
+    ["//tmp/case/project/probe.txt", "//tmp/case/Project", null],
+    ["/tmp/case/Project/probe.txt", "/tmp/case/Project", "probe.txt"],
+    ["C:/USERS/mike/t3code/main.ts", "c:/users/MIKE/t3code", "main.ts"],
+    ["/C:/USERS/mike/t3code/main.ts", "/c:/users/MIKE/t3code", "main.ts"],
+    ["\\\\server\\share\\PROJECT\\main.ts", "\\\\Server\\Share\\Project", "main.ts"],
+    ["/tmp/repo/file.ts", "/", "tmp/repo/file.ts"],
+    ["C:/Users/MIKE/main.ts", "c:/", "Users/MIKE/main.ts"],
+    ["\\\\server\\SHARE\\file.ts", "\\\\Server\\Share\\", "file.ts"],
+    ["/tmp/repo/file.ts ", "/tmp/repo", "file.ts "],
+    ["/tmp/report.ts", "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/repo/project", null],
+    ["/repo/project-two/a.ts", "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/repo/project", null],
+    ["/repo/project/a.ts", undefined, null],
+  ])("relates %s to %s", (path, workspaceRoot, relativePath) => {
+    expect(workspaceRelativeFilePath(path, workspaceRoot)).toBe(relativePath);
+  });
+});
diff --git a/packages/shared/src/path.ts b/packages/shared/src/path.ts
index c8626eb5e14c..925e8ac753bd 100644
--- a/packages/shared/src/path.ts
+++ b/packages/shared/src/path.ts
@@ -74,3 +74,40 @@ export function newProjectFolderName(name: string): string {
   if (slug.length === 0) return "project";
   return WINDOWS_RESERVED_NAME.test(slug) ? `${slug}-project` : slug;
 }
+
+const SLASH_PREFIXED_WINDOWS_DRIVE_PATTERN = /^\/[A-Za-z]:[\\/]/;
+
+/** Browser URL parsers write `C:/foo` as `/C:/foo` for file URLs. */
+export function stripSlashPrefixedWindowsDrive(path: string): string {
+  return SLASH_PREFIXED_WINDOWS_DRIVE_PATTERN.test(path) ? path.slice(1) : path;
+}
+
+export function fileBasename(path: string): string {
+  // A trailing separator is a valid way to write a directory. Trim it before
+  // taking the final segment so the label is never empty.
+  const trimmed = path.replace(/[/\\]+$/, "");
+  if (trimmed.length === 0) return path;
+  const separatorIndex = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  return separatorIndex >= 0 ? trimmed.slice(separatorIndex + 1) : trimmed;
+}
+
+export function workspaceRelativeFilePath(
+  path: string,
+  workspaceRoot: string | null | undefined,
+): string | null {
+  if (!workspaceRoot) return null;
+  const normalizedPath = stripSlashPrefixedWindowsDrive(path.replaceAll("\\", "/"));
+  const normalizedRoot = stripSlashPrefixedWindowsDrive(
+    workspaceRoot.replaceAll("\\", "/"),
+  ).replace(/\/+$/, "");
+  const caseInsensitive = isWindowsAbsolutePath(stripSlashPrefixedWindowsDrive(workspaceRoot));
+  const pathForCompare = caseInsensitive ? normalizedPath.toLowerCase() : normalizedPath;
+  const rootForCompare = caseInsensitive ? normalizedRoot.toLowerCase() : normalizedRoot;
+  if (pathForCompare.replace(/\/+$/, "") === rootForCompare) return ".";
+  if (!pathForCompare.startsWith(`${rootForCompare}/`)) return null;
+  return normalizedPath.slice(normalizedRoot.length + 1);
+}
+
+export function isAbsolutePath(value: string): boolean {
+  return value.startsWith("/") || isWindowsAbsolutePath(value);
+}
diff --git a/packages/shared/src/proposedPlanText.test.ts b/packages/shared/src/proposedPlanText.test.ts
new file mode 100644
index 000000000000..f0bcbe35a46a
--- /dev/null
+++ b/packages/shared/src/proposedPlanText.test.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vite-plus/test";
+import { proposedPlanTitle, stripDisplayedPlanMarkdown } from "./proposedPlanText.ts";
+
+describe("proposedPlanTitle", () => {
+  it("reads the first markdown heading as the plan title", () => {
+    expect(proposedPlanTitle("# Integrate RPC\n\nBody")).toBe("Integrate RPC");
+  });
+
+  it("returns null when the plan has no heading", () => {
+    expect(proposedPlanTitle("- step 1")).toBeNull();
+  });
+});
+
+describe("stripDisplayedPlanMarkdown", () => {
+  it("drops the leading title heading from displayed plan markdown", () => {
+    expect(stripDisplayedPlanMarkdown("# Integrate RPC\n\n## Summary\n\n- step 1\n")).toBe(
+      "- step 1",
+    );
+  });
+
+  it("preserves non-summary headings after dropping the title heading", () => {
+    expect(stripDisplayedPlanMarkdown("# Integrate RPC\n\n## Scope\n\n- step 1\n")).toBe(
+      "## Scope\n\n- step 1",
+    );
+  });
+});
diff --git a/packages/shared/src/proposedPlanText.ts b/packages/shared/src/proposedPlanText.ts
new file mode 100644
index 000000000000..52d568898ed6
--- /dev/null
+++ b/packages/shared/src/proposedPlanText.ts
@@ -0,0 +1,20 @@
+export function proposedPlanTitle(planMarkdown: string): string | null {
+  const heading = planMarkdown.match(/^\s{0,3}#{1,6}\s+(.+)$/m)?.[1]?.trim();
+  return heading && heading.length > 0 ? heading : null;
+}
+
+export function stripDisplayedPlanMarkdown(planMarkdown: string): string {
+  const lines = planMarkdown.trimEnd().split(/\r?\n/);
+  const sourceLines = lines[0] && /^\s{0,3}#{1,6}\s+/.test(lines[0]) ? lines.slice(1) : [...lines];
+  while (sourceLines[0]?.trim().length === 0) {
+    sourceLines.shift();
+  }
+  const firstHeadingMatch = sourceLines[0]?.match(/^\s{0,3}#{1,6}\s+(.+)$/);
+  if (firstHeadingMatch?.[1]?.trim().toLowerCase() === "summary") {
+    sourceLines.shift();
+    while (sourceLines[0]?.trim().length === 0) {
+      sourceLines.shift();
+    }
+  }
+  return sourceLines.join("\n");
+}
diff --git a/packages/shared/src/themePalettes.ts b/packages/shared/src/themePalettes.ts
index b26244c04641..b0eccd1b1593 100644
--- a/packages/shared/src/themePalettes.ts
+++ b/packages/shared/src/themePalettes.ts
@@ -88,6 +88,10 @@ export const THEME_COLOR_ROLES = [
   "messageActionHover",
   "codeBackground",
   "codeForeground",
+  "searchMatchBackground",
+  "searchMatchForeground",
+  "searchMatchActiveBackground",
+  "searchMatchActiveForeground",
   "sidebar",
   "sidebarForeground",
   "sidebarMutedForeground",
@@ -129,6 +133,10 @@ export type ThemeDefinition = Readonly<{
  * colors are stored as opaque OKLCH tokens.
  */
 export const T3_CODE_LIGHT_THEME_COLORS: ThemeColors = {
+  searchMatchBackground: "#fce8c0",
+  searchMatchForeground: "#27272a",
+  searchMatchActiveBackground: "#eea52b",
+  searchMatchActiveForeground: "#21180a",
   canvas: "#fcfcfc",
   chrome: "#fcfcfc",
   toolbar: "#fcfcfc",
@@ -189,6 +197,10 @@ export const T3_CODE_LIGHT_THEME_COLORS: ThemeColors = {
 };
 
 export const T3_CODE_DARK_THEME_COLORS: ThemeColors = {
+  searchMatchBackground: "#533e16",
+  searchMatchForeground: "#f5f5f5",
+  searchMatchActiveBackground: "#eea52b",
+  searchMatchActiveForeground: "#21180a",
   canvas: "#0a0a0a",
   chrome: "#0a0a0a",
   toolbar: "#0a0a0a",
@@ -296,6 +308,10 @@ export const T3_CHAT_THEME: ThemeDefinition = {
     messageActionHover: "oklch(0.539042 0.197866 0.305)",
     codeBackground: "oklch(0.953855 0.019695 315.668)",
     codeForeground: "oklch(0.445128 0.13005 307.026)",
+    searchMatchBackground: "oklch(0.869588 0.06751 334.899)",
+    searchMatchForeground: "oklch(0.325698 0.116116 325.037)",
+    searchMatchActiveBackground: "oklch(0.591646 0.217985 0.584)",
+    searchMatchActiveForeground: "oklch(1 0 0)",
     sidebar: "oklch(0.928886 0.031178 322.592)",
     sidebarForeground: "oklch(0.396296 0.025134 285.196)",
     sidebarMutedForeground: "oklch(0.494754 0.190937 354.544)",
@@ -356,6 +372,10 @@ export const T3_CHAT_THEME: ThemeDefinition = {
       messageActionHover: "oklch(0.458754 0.184639 3.857)",
       codeBackground: "oklch(0.22813 0.020366 307.469)",
       codeForeground: "oklch(0.848703 0.064239 306.645)",
+      searchMatchBackground: "oklch(0.313674 0.030572 310.061)",
+      searchMatchForeground: "oklch(0.980735 0.004092 301.426)",
+      searchMatchActiveBackground: "oklch(0.460685 0.185347 4.099)",
+      searchMatchActiveForeground: "oklch(0.901233 0.057189 343.694)",
       sidebar: "oklch(0.185778 0.019368 322.159)",
       sidebarForeground: "oklch(0.967434 0.001326 286.375)",
       sidebarMutedForeground: "oklch(0.880303 0.03077 342.696)",
@@ -423,6 +443,10 @@ export const GROVE_THEME: ThemeDefinition = {
     messageActionHover: "oklch(0.488753 0.096536 77.829)",
     codeBackground: "oklch(0.955888 0.004783 158.391)",
     codeForeground: "oklch(0.222003 0.03479 328.979)",
+    searchMatchBackground: "oklch(0.891377 0.026164 164.929)",
+    searchMatchForeground: "oklch(0.222003 0.03479 328.979)",
+    searchMatchActiveBackground: "oklch(0.523295 0.112292 158.089)",
+    searchMatchActiveForeground: "oklch(0.990339 0.008411 325.64)",
     sidebar: "oklch(0.936464 0.014601 163.554)",
     sidebarForeground: "oklch(0.222003 0.03479 328.979)",
     sidebarMutedForeground: "oklch(0.515606 0.011938 318.897)",
@@ -483,6 +507,10 @@ export const GROVE_THEME: ThemeDefinition = {
       messageActionHover: "oklch(0.815227 0.117902 84.21)",
       codeBackground: "oklch(0.312979 0.018942 164.082)",
       codeForeground: "oklch(0.990339 0.008411 325.64)",
+      searchMatchBackground: "oklch(0.464636 0.066083 158.72)",
+      searchMatchForeground: "oklch(0.990339 0.008411 325.64)",
+      searchMatchActiveBackground: "oklch(0.796228 0.133058 157.319)",
+      searchMatchActiveForeground: "oklch(0.222003 0.03479 328.979)",
       sidebar: "oklch(0.309925 0.032827 160.944)",
       sidebarForeground: "oklch(0.990339 0.008411 325.64)",
       sidebarMutedForeground: "oklch(0.711387 0.007643 175.89)",
@@ -550,6 +578,10 @@ export const OCEAN_THEME: ThemeDefinition = {
     messageActionHover: "oklch(0.45151 0.074407 201.516)",
     codeBackground: "oklch(0.957684 0.002906 253.68)",
     codeForeground: "oklch(0.222003 0.03479 328.979)",
+    searchMatchBackground: "oklch(0.895373 0.023469 241.913)",
+    searchMatchForeground: "oklch(0.222003 0.03479 328.979)",
+    searchMatchActiveBackground: "oklch(0.536684 0.120219 247.01)",
+    searchMatchActiveForeground: "oklch(0.990339 0.008411 325.64)",
     sidebar: "oklch(0.939254 0.01193 241.729)",
     sidebarForeground: "oklch(0.222003 0.03479 328.979)",
     sidebarMutedForeground: "oklch(0.517366 0.018944 311.433)",
@@ -610,6 +642,10 @@ export const OCEAN_THEME: ThemeDefinition = {
       messageActionHover: "oklch(0.815308 0.096174 199.862)",
       codeBackground: "oklch(0.29661 0.021883 251.968)",
       codeForeground: "oklch(0.990339 0.008411 325.64)",
+      searchMatchBackground: "oklch(0.439946 0.0561 243.479)",
+      searchMatchForeground: "oklch(0.990339 0.008411 325.64)",
+      searchMatchActiveBackground: "oklch(0.758933 0.105833 241.548)",
+      searchMatchActiveForeground: "oklch(0.222003 0.03479 328.979)",
       sidebar: "oklch(0.290387 0.032043 247.274)",
       sidebarForeground: "oklch(0.990339 0.008411 325.64)",
       sidebarMutedForeground: "oklch(0.69099 0.01395 266.424)",
@@ -677,6 +713,10 @@ export const EMBER_THEME: ThemeDefinition = {
     messageActionHover: "oklch(0.471223 0.145843 24.688)",
     codeBackground: "oklch(0.959965 0.002668 47.512)",
     codeForeground: "oklch(0.222003 0.03479 328.979)",
+    searchMatchBackground: "oklch(0.899296 0.022939 49.163)",
+    searchMatchForeground: "oklch(0.222003 0.03479 328.979)",
+    searchMatchActiveBackground: "oklch(0.552831 0.129438 44.656)",
+    searchMatchActiveForeground: "oklch(0.990339 0.008411 325.64)",
     sidebar: "oklch(0.942267 0.01151 50.785)",
     sidebarForeground: "oklch(0.222003 0.03479 328.979)",
     sidebarMutedForeground: "oklch(0.519146 0.019214 343.427)",
@@ -737,6 +777,10 @@ export const EMBER_THEME: ThemeDefinition = {
       messageActionHover: "oklch(0.775116 0.117953 29.014)",
       codeBackground: "oklch(0.299662 0.017229 39.973)",
       codeForeground: "oklch(0.990339 0.008411 325.64)",
+      searchMatchBackground: "oklch(0.442681 0.0608 50.795)",
+      searchMatchForeground: "oklch(0.990339 0.008411 325.64)",
+      searchMatchActiveBackground: "oklch(0.762174 0.124117 52.082)",
+      searchMatchActiveForeground: "oklch(0.222003 0.03479 328.979)",
       sidebar: "oklch(0.293349 0.029554 46.882)",
       sidebarForeground: "oklch(0.990339 0.008411 325.64)",
       sidebarMutedForeground: "oklch(0.691874 0.012538 24.638)",
@@ -804,6 +848,10 @@ export const IRIS_THEME: ThemeDefinition = {
     messageActionHover: "oklch(0.471003 0.16748 340.687)",
     codeBackground: "oklch(0.95997 0.004338 306.542)",
     codeForeground: "oklch(0.222003 0.03479 328.979)",
+    searchMatchBackground: "oklch(0.897143 0.028558 299.758)",
+    searchMatchForeground: "oklch(0.222003 0.03479 328.979)",
+    searchMatchActiveBackground: "oklch(0.525348 0.15373 294.176)",
+    searchMatchActiveForeground: "oklch(0.990339 0.008411 325.64)",
     sidebar: "oklch(0.941387 0.014687 300.474)",
     sidebarForeground: "oklch(0.222003 0.03479 328.979)",
     sidebarMutedForeground: "oklch(0.518417 0.023683 320.681)",
@@ -864,6 +912,10 @@ export const IRIS_THEME: ThemeDefinition = {
       messageActionHover: "oklch(0.813537 0.114101 337.23)",
       codeBackground: "oklch(0.281873 0.028308 295.193)",
       codeForeground: "oklch(0.990339 0.008411 325.64)",
+      searchMatchBackground: "oklch(0.395417 0.085554 294.182)",
+      searchMatchForeground: "oklch(0.990339 0.008411 325.64)",
+      searchMatchActiveBackground: "oklch(0.671712 0.169136 293.929)",
+      searchMatchActiveForeground: "oklch(0.222003 0.03479 328.979)",
       sidebar: "oklch(0.266743 0.044689 294.138)",
       sidebarForeground: "oklch(0.990339 0.008411 325.64)",
       sidebarMutedForeground: "oklch(0.668773 0.021522 302.949)",
diff --git a/packages/shared/src/threadFindText.test.ts b/packages/shared/src/threadFindText.test.ts
new file mode 100644
index 000000000000..abf0b2f14157
--- /dev/null
+++ b/packages/shared/src/threadFindText.test.ts
@@ -0,0 +1,114 @@
+import { expect, it } from "vite-plus/test";
+import { searchableMessageSegments } from "./threadFindText.ts";
+
+it("excludes review attachments rendered as context chips", () => {
+  const text = [
+    "Before **review**",
+    '<review_comment sectionId="turn:2" sectionTitle="Turn 2" filePath="hidden.ts" startIndex="3" endIndex="14" rangeLabel="L4">',
+    "Keep **this literal** comment.",
+    "```diff",
+    "+ hidden patch content",
+    "```",
+    "</review_comment>",
+    "After review",
+  ].join("\n");
+  expect(searchableMessageSegments({ role: "user", text, streaming: false })).toEqual([
+    "Before review",
+    " After review",
+  ]);
+});
+
+it("keeps malformed review tags visible, matching the message renderer", () => {
+  const text = "<review_comment>not a valid attachment</review_comment>";
+  expect(searchableMessageSegments({ role: "user", text, streaming: false })).toEqual([text]);
+});
+
+it("excludes structured context chips without joining text across them", () => {
+  expect(
+    searchableMessageSegments({
+      role: "user",
+      streaming: false,
+      text: "before[hidden label](t3-context://v1/terminal/terminal_1)after",
+      context: { version: 1, records: [] },
+    }),
+  ).toEqual(["before", "after"]);
+});
+
+it("does not upgrade literal legacy tags in messages with structured context", () => {
+  const text =
+    "<terminal_context>\n- Terminal 1 line 12:\n  12 | visible output\n</terminal_context>";
+  expect(
+    searchableMessageSegments({
+      role: "user",
+      streaming: false,
+      text,
+      context: { version: 1, records: [] },
+    })?.join("\n"),
+  ).toContain("visible output");
+  expect(searchableMessageSegments({ role: "user", streaming: false, text })).toEqual([]);
+});
+
+it("keeps context reference syntax inside code searchable", () => {
+  expect(
+    searchableMessageSegments({
+      role: "user",
+      streaming: false,
+      text: "`[label](t3-context://v1/terminal/terminal_1)`",
+    }),
+  ).toEqual(["[label](t3-context://v1/terminal/terminal_1)"]);
+});
+
+it("excludes repeated legacy attachments containing literal context tags", () => {
+  const context =
+    "<terminal_context>\n- Terminal 1 line 12:\n  12 | <terminal_context>literal</terminal_context>\n</terminal_context>";
+  expect(
+    searchableMessageSegments({
+      role: "user",
+      streaming: false,
+      text: `Fix this\n\n${context}\n\n${context}`,
+    }),
+  ).toEqual(["Fix this"]);
+});
+
+const assistantSegments = (text: string, cwd?: string) =>
+  searchableMessageSegments({ role: "assistant", text, streaming: false }, cwd);
+
+it("searches displayed prose and file-chip labels without hidden paths", () => {
+  expect(
+    assistantSegments("[important description](/tmp/actual.ts). `/tmp/inline-example.ts:42`"),
+  ).toEqual(["important description actual.ts. inline-example.ts · L42"]);
+  expect(assistantSegments("[label](src/main.ts#L3C2)", "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/workspace/repo")).toEqual([
+    "label main.ts · L3:C2",
+  ]);
+  expect(assistantSegments("[label](src/main.ts#L3C2)")).toEqual(["label"]);
+});
+
+it("includes the same parent suffixes for duplicate filenames as the renderer", () => {
+  expect(
+    assistantSegments(
+      "[first](src/main.ts) and `/workspace/repo/tests/main.ts:2`",
+      "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/workspace/repo",
+    ),
+  ).toEqual(["first main.ts · repo/src and main.ts · repo/tests · L2"]);
+  expect(
+    assistantSegments(
+      "[first](src/main.ts) and `/workspace/repo/src/main.ts:2`",
+      "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/workspace/repo",
+    ),
+  ).toEqual(["first main.ts and main.ts · L2"]);
+});
+
+it("keeps literal file paths in fences and user messages", () => {
+  expect(assistantSegments("```text\n/tmp/file.ts:42\n```")).toEqual(["/tmp/file.ts:42\n"]);
+  expect(
+    searchableMessageSegments({ role: "user", text: "`/tmp/file.ts:42`", streaming: false }),
+  ).toEqual(["/tmp/file.ts:42"]);
+});
+
+it("indexes nested disclosure summaries and bodies in rendered order", () => {
+  expect(
+    assistantSegments(
+      "<details><summary>Outer</summary><p>first</p><details><summary>Inner</summary><p>second</p></details></details>",
+    ),
+  ).toEqual(["Outer", "first", "Inner", "second"]);
+});
diff --git a/packages/shared/src/threadFindText.ts b/packages/shared/src/threadFindText.ts
new file mode 100644
index 000000000000..f11bbd808875
--- /dev/null
+++ b/packages/shared/src/threadFindText.ts
@@ -0,0 +1,175 @@
+import { renderCodexFileCitationsAsMarkdown } from "./codexMarkdownDirectives.ts";
+import {
+  buildFileLinkParentSuffixByPath,
+  splitFilePathPosition,
+  fileLinkLabel,
+} from "./fileLinks.ts";
+import {
+  isMarkdownFileLinkLabel,
+  extractMarkdownLinkHrefs,
+  extractInlineCodeSpans,
+  inlineCodeFilePathCandidate,
+  resolveMarkdownFileLinkTarget,
+} from "./markdownLinks.ts";
+import { upgradeLegacyContextMessage } from "./composerContextLegacy.ts";
+import { parseComposerContextHref } from "./composerContextReferences.ts";
+import type { OrchestrationV2ConversationMessage } from "@t3tools/contracts";
+import { proposedPlanTitle, stripDisplayedPlanMarkdown } from "./proposedPlanText.ts";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import {
+  CHAT_MARKDOWN_REHYPE_PLUGINS,
+  CHAT_MARKDOWN_REMARK_PLUGINS,
+  CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS,
+} from "./markdownPipeline.ts";
+
+// Inline wrappers (including Shiki token spans) must not split a search phrase.
+export const THREAD_FIND_BLOCK_TAGS = new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "br",
+  "dd",
+  "details",
+  "div",
+  "dl",
+  "dt",
+  "figcaption",
+  "figure",
+  "footer",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "summary",
+  "table",
+  "tbody",
+  "td",
+  "th",
+  "thead",
+  "tr",
+  "ul",
+]);
+
+const assistantProcessor = unified()
+  .use(remarkParse)
+  .use(CHAT_MARKDOWN_REMARK_PLUGINS)
+  .use(remarkRehype, { allowDangerousHtml: true })
+  .use(CHAT_MARKDOWN_REHYPE_PLUGINS);
+const userProcessor = unified()
+  .use(remarkParse)
+  .use(CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS)
+  .use(remarkRehype, { allowDangerousHtml: true });
+
+interface TextTree {
+  readonly type: string;
+  readonly tagName?: string;
+  readonly value?: string;
+  readonly properties?: {
+    readonly href?: unknown;
+    readonly src?: unknown;
+    readonly dataInlineCode?: unknown;
+  };
+  readonly children?: ReadonlyArray<TextTree>;
+}
+
+/** Uses the renderer's Markdown transforms, without mounting folded/virtualized rows. */
+function markdownThreadFindText(markdown: string, userMessage = false, cwd?: string): string[] {
+  const processor = userMessage ? userProcessor : assistantProcessor;
+  const tree = processor.runSync(processor.parse(markdown));
+  const paths = userMessage
+    ? []
+    : [
+        ...extractMarkdownLinkHrefs(renderCodexFileCitationsAsMarkdown(markdown)),
+        ...extractInlineCodeSpans(markdown).flatMap(
+          (span) => inlineCodeFilePathCandidate(span) ?? [],
+        ),
+      ].flatMap((href) => {
+        const target = resolveMarkdownFileLinkTarget(href, cwd);
+        return target ? [splitFilePathPosition(target).path] : [];
+      });
+  const parentSuffixes = buildFileLinkParentSuffixByPath(paths);
+  const segments: string[] = [];
+  let text = "";
+  const flush = () => {
+    if (text.trim()) segments.push(text);
+    text = "";
+  };
+  const visit = (node: TextTree, inPre = false) => {
+    const href = node.properties?.href ?? node.properties?.src;
+    if (userMessage && typeof href === "string" && parseComposerContextHref(href)) {
+      flush();
+      return;
+    }
+    if (!userMessage) {
+      let candidate: string | null = null;
+      if (node.tagName === "a" && typeof href === "string") {
+        candidate = href;
+      } else if (
+        node.tagName === "code" &&
+        !inPre &&
+        node.properties?.dataInlineCode !== undefined
+      ) {
+        candidate = inlineCodeFilePathCandidate(
+          (node.children ?? []).map((child) => child.value ?? "").join(""),
+        );
+      }
+      const target = candidate ? resolveMarkdownFileLinkTarget(candidate, cwd) : null;
+      if (target) {
+        const labelText = (node: TextTree): string =>
+          node.value ?? (node.children ?? []).map(labelText).join("");
+        const label = labelText(node);
+        if (node.tagName === "a" && candidate && !isMarkdownFileLinkLabel(label, candidate))
+          text += `${label} `;
+        text += fileLinkLabel(splitFilePathPosition(target), parentSuffixes);
+        return;
+      }
+    }
+    const block = THREAD_FIND_BLOCK_TAGS.has(node.tagName ?? "");
+    if (block) flush();
+    if (node.type === "text" || (userMessage && node.type === "raw")) {
+      text += inPre ? (node.value ?? "") : (node.value ?? "").replace(/\r?\n/g, " ");
+    }
+    for (const child of node.children ?? []) visit(child, inPre || node.tagName === "pre");
+    if (block) flush();
+  };
+  visit(tree);
+  flush();
+  return segments;
+}
+
+export function searchablePlanSegments(markdown: string, cwd?: string): readonly string[] {
+  return [
+    proposedPlanTitle(markdown) ?? "Proposed plan",
+    ...markdownThreadFindText(stripDisplayedPlanMarkdown(markdown), false, cwd),
+  ];
+}
+
+export function searchableMessageSegments(
+  message: Pick<OrchestrationV2ConversationMessage, "role" | "text" | "streaming" | "context">,
+  cwd?: string,
+): readonly string[] | null {
+  if (message.role === "user") {
+    const text = message.context ? message.text : upgradeLegacyContextMessage(message.text).text;
+    return markdownThreadFindText(text, true);
+  }
+  if (message.role !== "assistant") return null;
+  return markdownThreadFindText(
+    message.text || (message.streaming ? "" : "(empty response)"),
+    false,
+    cwd,
+  );
+}
diff --git a/packages/shared/src/threadSearch.test.ts b/packages/shared/src/threadSearch.test.ts
new file mode 100644
index 000000000000..d25bc91fa043
--- /dev/null
+++ b/packages/shared/src/threadSearch.test.ts
@@ -0,0 +1,23 @@
+import { expect, it } from "vite-plus/test";
+import { findThreadSearchOccurrences, splitThreadSearchText } from "./threadSearch.ts";
+
+it("finds non-overlapping occurrences without invalidating Unicode offsets", () => {
+  expect(findThreadSearchOccurrences("Deploy the Deployment", "deploy")).toEqual([0, 11]);
+  expect(findThreadSearchOccurrences("aaaa", "aa")).toEqual([0, 2]);
+  expect(findThreadSearchOccurrences("İİİ needle", "needle")).toEqual([4]);
+});
+
+it("splits search text into highlighted and unhighlighted parts", () => {
+  expect(splitThreadSearchText("one TWO three two", " two ")).toEqual([
+    { text: "one ", highlighted: false, start: 0 },
+    { text: "TWO", highlighted: true, start: 4 },
+    { text: " three ", highlighted: false, start: 7 },
+    { text: "two", highlighted: true, start: 14 },
+  ]);
+});
+
+it("matches both Greek sigma forms without changing source offsets", () => {
+  expect(findThreadSearchOccurrences("ΟΣ ος οσ", "Σ")).toEqual([1, 4, 7]);
+  expect(findThreadSearchOccurrences("ΟΣ ος οσ", "ς")).toEqual([1, 4, 7]);
+  expect(findThreadSearchOccurrences("İ ΟΣ", "Σ")).toEqual([3]);
+});
diff --git a/packages/shared/src/threadSearch.ts b/packages/shared/src/threadSearch.ts
new file mode 100644
index 000000000000..df86c3b94b2c
--- /dev/null
+++ b/packages/shared/src/threadSearch.ts
@@ -0,0 +1,70 @@
+interface ThreadSearchTextPart {
+  readonly text: string;
+  readonly highlighted: boolean;
+  readonly start: number;
+}
+
+function foldThreadSearchCase(text: string): string {
+  const lowered = text.toLowerCase().replace(/ς/g, "σ");
+  if (lowered.length === text.length) return lowered;
+
+  let folded = "";
+  for (const character of text) {
+    const loweredCharacter = character.toLowerCase().replace(/ς/g, "σ");
+    folded += loweredCharacter.length === character.length ? loweredCharacter : character;
+  }
+  return folded;
+}
+
+function scanThreadSearchOccurrences(text: string, query: string, offsets?: number[]): number {
+  if (text.length === 0 || query.length === 0) return 0;
+
+  const foldedText = foldThreadSearchCase(text);
+  const foldedQuery = foldThreadSearchCase(query);
+  let count = 0;
+  let cursor = 0;
+
+  while (cursor <= foldedText.length - foldedQuery.length) {
+    const offset = foldedText.indexOf(foldedQuery, cursor);
+    if (offset === -1) break;
+    offsets?.push(offset);
+    count += 1;
+    cursor = offset + foldedQuery.length;
+  }
+  return count;
+}
+
+export function countThreadSearchOccurrences(text: string, query: string): number {
+  return scanThreadSearchOccurrences(text, query);
+}
+
+export function findThreadSearchOccurrences(text: string, query: string): number[] {
+  const offsets: number[] = [];
+  scanThreadSearchOccurrences(text, query, offsets);
+  return offsets;
+}
+
+export function splitThreadSearchText(text: string, query: string): ThreadSearchTextPart[] {
+  const normalizedQuery = query.trim();
+  if (normalizedQuery.length === 0) {
+    return [{ text, highlighted: false, start: 0 }];
+  }
+
+  const parts: ThreadSearchTextPart[] = [];
+  let cursor = 0;
+  for (const offset of findThreadSearchOccurrences(text, normalizedQuery)) {
+    if (offset > cursor) {
+      parts.push({ text: text.slice(cursor, offset), highlighted: false, start: cursor });
+    }
+    parts.push({
+      text: text.slice(offset, offset + normalizedQuery.length),
+      highlighted: true,
+      start: offset,
+    });
+    cursor = offset + normalizedQuery.length;
+  }
+  if (cursor < text.length) {
+    parts.push({ text: text.slice(cursor), highlighted: false, start: cursor });
+  }
+  return parts;
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 17a19d1ffbeb..9311fce6f6fc 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -757,15 +757,6 @@ importers:
       react-markdown:
         specifier: ^10.1.0
         version: 10.1.0(@types/react@19.3.0)(react@19.2.6)
-      rehype-raw:
-        specifier: ^7.0.0
-        version: 7.0.0
-      rehype-sanitize:
-        specifier: ^6.0.0
-        version: 6.0.0
-      remark-breaks:
-        specifier: ^4.0.0
-        version: 4.0.0
       remark-gfm:
         specifier: ^4.0.1
         version: 4.0.1
@@ -937,24 +928,9 @@ importers:
       effect:
         specifier: 4.0.1
         version: 4.0.1(patch_hash=a33cba07c41f32374c2aaa86ea4a84d3ab9a872a78c94b65e929b19f8361856f)
-      mdast-util-directive:
-        specifier: ^3.1.0
-        version: 3.1.0
-      micromark-extension-directive:
-        specifier: ^4.0.0
-        version: 4.0.0
-      micromark-util-character:
-        specifier: ^2.1.1
-        version: 2.1.1
-      remark-parse:
-        specifier: ^11.0.0
-        version: 11.0.0
       three:
         specifier: 0.180.0
         version: 0.180.0
-      unified:
-        specifier: ^11.0.5
-        version: 11.0.5
     devDependencies:
       '@effect/vitest':
         specifier: 4.0.1
@@ -962,9 +938,6 @@ importers:
       '@types/three':
         specifier: 0.180.0
         version: 0.180.0
-      micromark-util-types:
-        specifier: ^2.0.2
-        version: 2.0.2
       vite-plus:
         specifier: 1.0.0
         version: 1.0.0(@types/node@24.12.4)(@vitest/ui@5.0.1(vitest@5.0.1))(bufferutil@4.1.0)(esbuild@0.28.2)(jiti@2.7.0)(jsdom@30.1.0(@noble/hashes@1.8.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)
@@ -1043,6 +1016,36 @@ importers:
       jose:
         specifier: 'catalog:'
         version: 6.2.2
+      mdast-util-directive:
+        specifier: ^3.1.0
+        version: 3.1.0
+      micromark-extension-directive:
+        specifier: ^4.0.0
+        version: 4.0.0
+      micromark-util-character:
+        specifier: ^2.1.1
+        version: 2.1.1
+      rehype-raw:
+        specifier: ^7.0.0
+        version: 7.0.0
+      rehype-sanitize:
+        specifier: ^6.0.0
+        version: 6.0.0
+      remark-breaks:
+        specifier: ^4.0.0
+        version: 4.0.0
+      remark-gfm:
+        specifier: ^4.0.1
+        version: 4.0.1
+      remark-parse:
+        specifier: ^11.0.0
+        version: 11.0.0
+      remark-rehype:
+        specifier: ^11.1.2
+        version: 11.1.2
+      unified:
+        specifier: ^11.0.5
+        version: 11.0.5
       yaml:
         specifier: ^2.9.0
         version: 2.9.0
@@ -1056,6 +1059,9 @@ importers:
       '@types/node':
         specifier: 24.12.4
         version: 24.12.4
+      micromark-util-types:
+        specifier: ^2.0.2
+        version: 2.0.2
       vite-plus:
         specifier: 1.0.0
         version: 1.0.0(@types/node@24.12.4)(@vitest/ui@5.0.1(vitest@5.0.1))(bufferutil@4.1.0)(esbuild@0.28.2)(jiti@2.7.0)(jsdom@30.1.0(@noble/hashes@1.8.0))(msw@2.12.11(@types/node@24.12.4)(typescript@7.0.2))(terser@5.48.0)(typescript@7.0.2)(unrun@0.2.39)(utf-8-validate@6.0.6)(yaml@2.9.0)

From f7b1e478fa045114a234b548438b265dff809603 Mon Sep 17 00:00:00 2001
From: Jono Kemball <jono-kemball@idexx.com>
Date: Wed, 7 Oct 2026 15:49:17 +1300
Subject: [PATCH 02/21] fix: preserve thread search navigation and consistent
 snapshots

---
 .../src/orchestration-v2/ThreadFind.test.ts   |  64 ++++
 .../server/src/orchestration-v2/ThreadFind.ts | 281 ++++++++++--------
 apps/web/src/components/ChatMarkdown.test.tsx |  91 ++++++
 apps/web/src/components/ChatMarkdown.tsx      |   3 +-
 apps/web/src/components/ChatView.tsx          |  57 ++--
 .../components/ComposerPromptEditorTiptap.tsx |   2 +-
 apps/web/src/components/chat/ChatComposer.tsx |   2 +-
 apps/web/src/components/chat/ChatHeader.tsx   |   3 -
 .../components/chat/ComposerCommandMenu.tsx   |   2 +-
 .../chat/MessagesTimeline.logic.test.ts       |   2 +-
 .../components/chat/MessagesTimeline.logic.ts |   4 -
 .../src/components/chat/MessagesTimeline.tsx  |  93 ++++--
 .../src/components/chat/SkillInlineText.tsx   |  24 +-
 apps/web/src/components/chat/threadFind.ts    |  15 +-
 apps/web/src/components/chat/useThreadFind.ts |  27 +-
 .../chat/useThreadFindHistory.test.tsx        |  13 +-
 .../components/chat/useThreadFindHistory.ts   |   8 +-
 apps/web/src/providerSkillSearch.ts           |   2 +-
 .../client-runtime/src/providerSkills.test.ts |   2 +-
 packages/client-runtime/src/providerSkills.ts |  19 --
 packages/contracts/src/orchestrationV2.ts     |   9 +
 packages/shared/package.json                  |   4 +
 packages/shared/src/inlineSkills.ts           |  35 +++
 packages/shared/src/markdownPipeline.ts       |   4 +
 packages/shared/src/threadFindText.test.ts    |  27 +-
 packages/shared/src/threadFindText.ts         |  79 +++--
 26 files changed, 593 insertions(+), 279 deletions(-)
 create mode 100644 packages/shared/src/inlineSkills.ts

diff --git a/apps/server/src/orchestration-v2/ThreadFind.test.ts b/apps/server/src/orchestration-v2/ThreadFind.test.ts
index fc2427f7d00d..d8f2fc160241 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.test.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.test.ts
@@ -16,6 +16,7 @@ import {
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as SqlClient from "effect/sql/SqlClient";
 
 import * as SqlitePersistence from "../persistence/Sqlite.ts";
 import * as ProjectionStore from "./ProjectionStore.ts";
@@ -228,6 +229,69 @@ describe("V2 thread find", () => {
     }).pipe(Effect.provide(layerTest)),
   );
 
+  it.effect("keeps a search snapshot consistent while another thread commits", () =>
+    Effect.gen(function* () {
+      const projection = yield* setup;
+      const other = ThreadId.make("thread:busy");
+      yield* commit([thread(other, projectId), run(other, RunId.make("run:busy"))]);
+      yield* putItems(Array.from({ length: 260 }, (_, i) => item(`message:${i}`, i, "needle")));
+      const before = yield* projection.searchThread({ threadId, query: "needle" });
+      const [during] = yield* Effect.all(
+        [
+          projection.searchThread({ threadId, query: "needle", index: 259 }),
+          putItems([item("busy", 1, "busy", "assistant_message", other)]),
+        ],
+        { concurrency: "unbounded" },
+      );
+      assert.equal(during.totalMatches, 260);
+      assert.equal(during.match?.entryId, "message:259");
+      assert.equal(during.snapshotSequence, before.snapshotSequence);
+      assert.equal(
+        (yield* projection.searchThread({ threadId, query: "needle" })).snapshotSequence,
+        before.snapshotSequence,
+      );
+    }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect("searches displayed skill labels and invalidates parsed text when labels change", () =>
+    Effect.gen(function* () {
+      const projection = yield* setup;
+      yield* putItems([item("skill", 1, "Use $test-t3-app now")]);
+      const input = {
+        threadId,
+        query: "T3 App Testing",
+        skills: [{ name: "test-t3-app", displayName: "T3 App Testing" }],
+      };
+      assert.equal((yield* projection.searchThread(input)).totalMatches, 1);
+      assert.equal((yield* projection.searchThread({ ...input, skills: [] })).totalMatches, 0);
+      assert.equal((yield* projection.searchThread({ ...input, query: "App" })).totalMatches, 1);
+    }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect("never mixes message versions when the searched thread changes during a scan", () =>
+    Effect.gen(function* () {
+      const projection = yield* setup;
+      const sql = yield* SqlClient.SqlClient;
+      const items = Array.from({ length: 260 }, (_, i) => item(`message:${i}`, i, "needle"));
+      yield* putItems(items);
+      const updated = items.map((item) =>
+        item.type === "assistant_message" ? { ...item, text: "needle needle" } : item,
+      );
+      const [during] = yield* Effect.all(
+        [
+          projection.searchThread({ threadId, query: "needle" }),
+          sql.withTransaction(putItems(updated, "concurrent")),
+        ],
+        { concurrency: "unbounded" },
+      );
+      assert.include([260, 520], during.totalMatches);
+      assert.equal(
+        (yield* projection.searchThread({ threadId, query: "needle" })).totalMatches,
+        520,
+      );
+    }).pipe(Effect.provide(layerTest)),
+  );
+
   it.effect("returns only nearby rows for a match beyond the recent history window", () =>
     Effect.gen(function* () {
       const projection = yield* setup;
diff --git a/apps/server/src/orchestration-v2/ThreadFind.ts b/apps/server/src/orchestration-v2/ThreadFind.ts
index 14245210123d..2c727dde5a23 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.ts
@@ -12,7 +12,6 @@ import { countThreadSearchOccurrences } from "@t3tools/shared/threadSearch";
 import * as Cache from "effect/Cache";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
-import * as Exit from "effect/Exit";
 import * as Schema from "effect/Schema";
 import * as SqlClient from "effect/sql/SqlClient";
 import { ProjectionStoreReadError, type ProjectionStoreV2Error } from "./ProjectionStore.ts";
@@ -28,27 +27,83 @@ interface FindDocument extends FindRow {
   readonly runId: OrchestrationV2TurnItem["runId"];
   readonly count: number;
 }
-class SearchKey extends Data.Class<{
-  threadId: ThreadId;
-  query: string;
-  sequence: number;
+class TextKey extends Data.Class<{
+  text: string;
+  role: "user" | "assistant" | "plan";
+  streaming: boolean;
+  hasContext: boolean;
   cwd: string | undefined;
+  skills: NonNullable<OrchestrationV2SearchThreadInput["skills"]>;
 }> {}
 
-function countItem(item: OrchestrationV2TurnItem, query: string, cwd?: string): number {
-  let segments: readonly string[] | null = null;
-  if (item.type === "proposed_plan") segments = searchablePlanSegments(item.markdown, cwd);
-  else if (item.type === "user_message" || item.type === "assistant_message")
-    segments = searchableMessageSegments(
-      {
-        role: item.type === "user_message" ? "user" : "assistant",
-        text: item.text,
-        streaming: item.type === "assistant_message" && item.streaming,
-        context: item.type === "user_message" ? item.context : undefined,
-      },
-      cwd,
-    );
-  return segments?.reduce((sum, text) => sum + countThreadSearchOccurrences(text, query), 0) ?? 0;
+function textKey(
+  item: OrchestrationV2TurnItem,
+  cwd: string | undefined,
+  skills: TextKey["skills"],
+) {
+  return new TextKey({
+    text:
+      item.type === "proposed_plan"
+        ? item.markdown
+        : item.type === "user_message" || item.type === "assistant_message"
+          ? item.text
+          : "",
+    role:
+      item.type === "proposed_plan" ? "plan" : item.type === "user_message" ? "user" : "assistant",
+    streaming: item.type === "assistant_message" && item.streaming,
+    hasContext: item.type === "user_message" && item.context !== undefined,
+    cwd,
+    skills,
+  });
+}
+
+function parseText(key: TextKey): readonly string[] {
+  return key.role === "plan"
+    ? searchablePlanSegments(key.text, key.cwd, key.skills)
+    : (searchableMessageSegments(
+        {
+          role: key.role,
+          text: key.text,
+          streaming: key.streaming,
+          context: key.hasContext ? { version: 1, records: [] } : undefined,
+        },
+        key.cwd,
+        key.skills,
+      ) ?? []);
+}
+
+function searchableRows(items: readonly OrchestrationV2ProjectedTurnItem[]) {
+  const foldedAnswers = new Set(
+    items.flatMap(({ item }) =>
+      item.type === "user_input_request" && item.questionAnswer
+        ? [`async-answer:${item.questionAnswer.requestId}`]
+        : [],
+    ),
+  );
+  return items.filter(
+    ({ item }) =>
+      ["user_message", "assistant_message", "proposed_plan"].includes(item.type) &&
+      !(item.type === "user_message" && foldedAnswers.has(item.messageId)),
+  );
+}
+
+function documentFor(row: OrchestrationV2ProjectedTurnItem, count: number): FindDocument {
+  return {
+    position: row.position,
+    visibility: row.visibility,
+    sourceThreadId: row.sourceThreadId,
+    sourceItemId: row.sourceItemId,
+    entryId:
+      row.item.type === "user_message" || row.item.type === "assistant_message"
+        ? row.item.messageId
+        : row.item.id,
+    runId: row.item.runId,
+    count,
+  };
+}
+
+function countSegments(segments: readonly string[], query: string) {
+  return segments.reduce((sum, text) => sum + countThreadSearchOccurrences(text, query), 0);
 }
 
 function selectMatch(documents: readonly FindDocument[], requestedIndex: number) {
@@ -69,28 +124,23 @@ export function findProjectedThreadItems(
   snapshotSequence: number,
   cwd?: string,
 ): OrchestrationV2SearchThreadResult {
-  const foldedAnswers = new Set(
-    items.flatMap(({ item }) =>
-      item.type === "user_input_request" && item.questionAnswer
-        ? [`async-answer:${item.questionAnswer.requestId}`]
-        : [],
+  const rows = searchableRows(items);
+  const docs = rows.map((row) =>
+    documentFor(
+      row,
+      countSegments(parseText(textKey(row.item, cwd, input.skills ?? [])), input.query),
     ),
   );
-  const rows = items.filter(
-    ({ item }) =>
-      ["user_message", "assistant_message", "proposed_plan"].includes(item.type) &&
-      !(item.type === "user_message" && foldedAnswers.has(item.messageId)),
-  );
-  const docs: FindDocument[] = rows.map((row) => ({
-    ...row,
-    entryId:
-      row.item.type === "user_message" || row.item.type === "assistant_message"
-        ? row.item.messageId
-        : row.item.id,
-    runId: row.item.runId,
-    count: countItem(row.item, input.query, cwd),
-  }));
-  const selected = selectMatch(docs, input.index ?? 0);
+  return resultFor(rows, docs, input.index ?? 0, snapshotSequence);
+}
+
+function resultFor(
+  rows: readonly OrchestrationV2ProjectedTurnItem[],
+  docs: readonly FindDocument[],
+  requestedIndex: number,
+  snapshotSequence: number,
+): OrchestrationV2SearchThreadResult {
+  const selected = selectMatch(docs, requestedIndex);
   const index = selected.document === null ? -1 : docs.indexOf(selected.document);
   return {
     snapshotSequence,
@@ -118,18 +168,11 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
   >,
 ) {
   const sql = yield* SqlClient.SqlClient;
+  const encodeThreadIds = Schema.encodeEffect(Schema.fromJsonString(Schema.Array(ThreadId)));
   const encodeSources = Schema.encodeEffect(
     Schema.fromJsonString(Schema.Array(Schema.Struct({ threadId: ThreadId, id: TurnItemId }))),
   );
   const decodeItem = Schema.decodeUnknownEffect(Schema.fromJsonString(OrchestrationV2TurnItemJson));
-  const revision = (threadId: ThreadId) =>
-    sql<{ sequence: number }>`
-    SELECT COALESCE(MAX(sequence), 0) AS sequence FROM orchestration_events
-  `.pipe(
-      Effect.map((rows) => rows[0]?.sequence ?? 0),
-      Effect.mapError((cause) => new ProjectionStoreReadError({ threadId, cause })),
-    );
-  const changed = (threadId: ThreadId) => new ProjectionStoreReadError({ threadId });
   const load = Effect.fn("ThreadFind.load")(function* (
     threadId: ThreadId,
     rows: readonly FindRow[],
@@ -154,7 +197,7 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
     return yield* Effect.forEach(rows, (row) =>
       Effect.gen(function* () {
         const payload = byThread.get(row.sourceThreadId)?.get(row.sourceItemId);
-        if (payload === undefined) return yield* changed(threadId);
+        if (payload === undefined) return yield* new ProjectionStoreReadError({ threadId });
         const item = yield* decodeItem(payload).pipe(
           Effect.mapError((cause) => new ProjectionStoreReadError({ threadId, cause })),
         );
@@ -162,92 +205,68 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
       }),
     );
   });
-  const scan = Effect.fn("ThreadFind.scan")(function* (key: SearchKey) {
-    const index = yield* readIndex(key.threadId);
-    const rows = index.map((row, position) => ({ ...row, position }));
-    // Question answers render inside their request card, not as searchable message bubbles.
-    const questions = rows.filter((row) => row.item.type === "user_input_request");
-    const foldedAnswers = new Set<string>();
-    for (let start = 0; start < questions.length; start += 128) {
-      for (const { item } of yield* load(key.threadId, questions.slice(start, start + 128))) {
-        if (item.type === "user_input_request" && item.questionAnswer)
-          foldedAnswers.add(`async-answer:${item.questionAnswer.requestId}`);
-      }
-      yield* Effect.yieldNow;
-    }
-    const candidates = rows.filter((row) =>
-      ["user_message", "assistant_message", "proposed_plan"].includes(row.item.type),
-    );
-    const context: FindRow[] = [];
-    const documents: FindDocument[] = [];
-    for (let start = 0; start < candidates.length; start += 128) {
-      const batch = yield* load(key.threadId, candidates.slice(start, start + 128));
-      for (const { item, ...row } of batch) {
-        if (item.type === "user_message" && foldedAnswers.has(item.messageId)) continue;
-        context.push(row);
-        const count = countItem(item, key.query, key.cwd);
-        if (count > 0)
-          documents.push({
-            ...row,
-            count,
-            runId: item.runId,
-            entryId:
-              item.type === "user_message" || item.type === "assistant_message"
-                ? item.messageId
-                : item.id,
-          });
-      }
-      yield* Effect.yieldNow;
-    }
-    if ((yield* revision(key.threadId)) !== key.sequence) return yield* changed(key.threadId);
-    return { documents, context };
-  });
-  // Keep IDs/counts only. Navigation never retains transcript bodies or one record per occurrence.
-  const cache = yield* Cache.makeWith(scan, {
-    capacity: 16,
-    timeToLive: (exit) =>
-      Exit.isSuccess(exit) && exit.value.context.length <= 10_000 ? "1 minute" : 0,
+  // Cache rendered segments, not queries; typing and navigation reuse Markdown parsing.
+  const textCache = yield* Cache.make({
+    capacity: 512,
+    timeToLive: "1 minute",
+    lookup: (key: TextKey) => Effect.sync(() => parseText(key)),
   });
+  const snapshot = Effect.fn("ThreadFind.snapshot")(
+    function* (threadId: ThreadId) {
+      const active = yield* sql<{ cwd: string | null }>`
+      SELECT COALESCE(json_extract(t.payload_json, '$.worktreePath'), p.workspace_root) AS cwd
+      FROM orchestration_v2_projection_threads t JOIN projection_projects p ON p.project_id = t.project_id
+      WHERE t.thread_id = ${threadId} AND t.deleted_at IS NULL AND p.deleted_at IS NULL
+    `;
+      if (!active[0]) return yield* new ProjectionStoreReadError({ threadId });
+      const index = yield* readIndex(threadId);
+      const sources = yield* encodeThreadIds([
+        ...new Set([threadId, ...index.map((row) => row.sourceThreadId)]),
+      ]);
+      const revision = yield* sql<{ sequence: number }>`
+      SELECT COALESCE(MAX(sequence), 0) AS sequence FROM orchestration_events
+      WHERE application_event_version = 2 AND aggregate_kind = 'thread'
+        AND stream_id IN (SELECT value FROM json_each(${sources}))
+    `;
+      const candidates = index
+        .map((row, position) => ({ ...row, position }))
+        .filter((row) =>
+          ["user_message", "assistant_message", "proposed_plan", "user_input_request"].includes(
+            row.item.type,
+          ),
+        );
+      const items: OrchestrationV2ProjectedTurnItem[] = [];
+      for (let start = 0; start < candidates.length; start += 128) {
+        items.push(...(yield* load(threadId, candidates.slice(start, start + 128))));
+      }
+      return { items, cwd: active[0].cwd ?? undefined, sequence: revision[0]?.sequence ?? 0 };
+    },
+    sql.withTransaction,
+    (effect, threadId) =>
+      effect.pipe(
+        Effect.mapError((cause) =>
+          Schema.is(ProjectionStoreReadError)(cause)
+            ? cause
+            : new ProjectionStoreReadError({ threadId, cause }),
+        ),
+      ),
+  );
   return Effect.fn("ProjectionStore.searchThread")(function* (
     input: OrchestrationV2SearchThreadInput,
   ) {
-    const active = yield* sql<{ cwd: string | null }>`
-      SELECT COALESCE(json_extract(t.payload_json, '$.worktreePath'), p.workspace_root) AS cwd
-      FROM orchestration_v2_projection_threads t JOIN projection_projects p ON p.project_id = t.project_id
-      WHERE t.thread_id = ${input.threadId} AND t.deleted_at IS NULL AND p.deleted_at IS NULL
-    `.pipe(
-      Effect.mapError((cause) => new ProjectionStoreReadError({ threadId: input.threadId, cause })),
-    );
-    if (!active[0]) return yield* changed(input.threadId);
-    const snapshotSequence = yield* revision(input.threadId);
-    const { documents, context } = yield* Cache.get(
-      cache,
-      new SearchKey({
-        threadId: input.threadId,
-        query: input.query,
-        sequence: snapshotSequence,
-        cwd: active[0].cwd ?? undefined,
-      }),
-    );
-    const selected = selectMatch(documents, input.index ?? 0);
-    const document = selected.document;
-    const index =
-      document === null ? -1 : context.findIndex((row) => row.position === document.position);
-    const items =
-      index < 0
-        ? []
-        : yield* load(input.threadId, context.slice(Math.max(0, index - 2), index + 3));
-    if ((yield* revision(input.threadId)) !== snapshotSequence)
-      return yield* changed(input.threadId);
-    return {
-      snapshotSequence,
-      totalMatches: selected.totalMatches,
-      activeIndex: selected.activeIndex,
-      match:
-        document === null
-          ? null
-          : { entryId: document.entryId, runId: document.runId, occurrence: selected.occurrence },
-      items,
-    };
+    // Release the SQLite connection before parsing. All rows and their revision
+    // come from one snapshot, including inherited fork history.
+    const { items, cwd, sequence } = yield* snapshot(input.threadId);
+    const rows = searchableRows(items);
+    const skills = input.skills ?? [];
+    const documents: FindDocument[] = [];
+    for (const row of rows) {
+      const key = textKey(row.item, cwd, skills);
+      const segments =
+        key.text.length <= 32_768 ? yield* Cache.get(textCache, key) : parseText(key);
+      documents.push(documentFor(row, countSegments(segments, input.query)));
+      yield* Effect.yieldNow;
+    }
+    return resultFor(rows, documents, input.index ?? 0, sequence);
   });
 });
diff --git a/apps/web/src/components/ChatMarkdown.test.tsx b/apps/web/src/components/ChatMarkdown.test.tsx
index 274503a54e79..1ef0b1bd79f5 100644
--- a/apps/web/src/components/ChatMarkdown.test.tsx
+++ b/apps/web/src/components/ChatMarkdown.test.tsx
@@ -1,6 +1,11 @@
 // @vitest-environment jsdom
 
 import { EnvironmentId, type AuthEnvironmentScope } from "@t3tools/contracts";
+import { createRoot } from "react-dom/client";
+import { useThreadFindHighlights } from "./chat/threadFindHighlights";
+import { searchableMessageSegments } from "@t3tools/shared/threadFindText";
+import { countThreadSearchOccurrences } from "@t3tools/shared/threadSearch";
+
 import { MarkdownFindContext } from "./chat/markdownFindContext";
 import { act, type ComponentProps, type ReactNode } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
@@ -1095,3 +1100,89 @@ it("opens nested disclosures for find and restores their prior state when find c
     vi.unstubAllGlobals();
   }
 });
+
+it.each([
+  {
+    text: "```mermaid\ngraph TD; SearchSourceAlpha-->B\n```",
+    query: "SearchSourceAlpha",
+    count: 1,
+  },
+  {
+    text: "★ Insight ─────\nfirst line\nsecond line",
+    query: "first line second",
+    count: 0,
+    lineBreaks: true,
+  },
+  { text: "Use $test-t3-app now", query: "T3 App Testing", count: 1 },
+  { text: "`/tmp/file.ts:42`", query: "file.ts · L42", count: 1, user: true, lineBreaks: true },
+  { text: "> [!NOTE]\n> Searchable alert", query: "Searchable alert", count: 1 },
+  {
+    text: "<details><summary>Folded</summary><p>Hidden needle</p></details>",
+    query: "Hidden needle",
+    count: 1,
+  },
+])(
+  "highlights the indexed occurrences in $text",
+  async ({ text, query, count, lineBreaks, user }) => {
+    const skills = [{ name: "test-t3-app", displayName: "T3 App Testing" }];
+    const highlights = new Map<string, Set<Range>>();
+    vi.stubGlobal(
+      "Highlight",
+      class extends Set<Range> {
+        constructor(...ranges: Range[]) {
+          super(ranges);
+        }
+      },
+    );
+    vi.stubGlobal("CSS", { highlights, escape: (value: string) => value });
+    vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+    const container = document.createElement("div");
+    document.body.append(container);
+    const root = createRoot(container);
+    function Probe() {
+      useThreadFindHighlights({
+        container,
+        query,
+        activeRowId: "row",
+        activeOccurrence: 0,
+        onActiveRange: () => {},
+      });
+      return (
+        <div data-timeline-row-id="row">
+          <div data-thread-find-text>
+            <MarkdownFindContext value={true}>
+              <ChatMarkdown
+                text={text}
+                cwd={undefined}
+                skills={skills}
+                lineBreaks={lineBreaks ?? false}
+                parseRawHtml={!user}
+              />
+            </MarkdownFindContext>
+          </div>
+        </div>
+      );
+    }
+    try {
+      await act(() => root.render(<Probe />));
+      await act(() => new Promise<void>((resolve) => requestAnimationFrame(() => resolve())));
+      const ranges = [...highlights.values()].flatMap((value) => [...value]);
+      expect(ranges.map((range) => range.toString())).toEqual(
+        Array.from({ length: count }, () => query),
+      );
+      const segments =
+        searchableMessageSegments(
+          { role: user ? "user" : "assistant", text, streaming: false },
+          undefined,
+          skills,
+        ) ?? [];
+      expect(
+        segments.reduce((sum, segment) => sum + countThreadSearchOccurrences(segment, query), 0),
+      ).toBe(count);
+    } finally {
+      await act(() => root.unmount());
+      container.remove();
+      vi.unstubAllGlobals();
+    }
+  },
+);
diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index aa1a43016e33..c08de21f1cdd 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -964,7 +964,8 @@ function MarkdownMermaidCodeBlock({
   children: ReactNode;
 }) {
   const [showCode, setShowCode] = useState(false);
-  const showDiagram = !showCode && !isStreaming && code.trim().length > 0;
+  const searching = use(MarkdownFindContext);
+  const showDiagram = !searching && !showCode && !isStreaming && code.trim().length > 0;
   const toggleLabel = showCode ? "Show diagram" : "Show code";
   return (
     <MarkdownCodeBlock
diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index f4acfa03d03c..a0e5e7a48e43 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -7904,7 +7904,11 @@ export default function ChatView(props: ChatViewProps) {
     }),
     [composerRef, previewPanelOpen, terminalUiState.terminalOpen, routeKind, phase],
   );
+  const timelineSkills = activeProviderStatus
+    ? resolveProviderSkillsForCwd(activeProviderStatus, gitCwd)
+    : EMPTY_PROVIDER_SKILLS;
   const threadFind = useThreadFind({
+    skills: timelineSkills,
     cwd: gitCwd ?? undefined,
     thread: activeThreadRef,
     serverSearch: isServerThread && serverConfig?.threadFind === true,
@@ -7914,10 +7918,7 @@ export default function ChatView(props: ChatViewProps) {
       ? {
           loading: threadHistoryControls.loading,
           cursor: serverThreadHistory.historyCursor,
-          onLoadEarlier: () => {
-            threadHistoryControls.onLoadEarlier();
-            return true;
-          },
+          onLoadEarlier: threadHistoryControls.onLoadEarlier,
         }
       : null,
   });
@@ -7929,13 +7930,8 @@ export default function ChatView(props: ChatViewProps) {
         event.stopPropagation();
         return;
       }
-      if (isThreadFindActive && event.key === "Escape") {
-        event.preventDefault();
-        event.stopPropagation();
-        closeThreadFind();
-        focusComposer();
-        return;
-      }
+      // Let contextual controls claim Escape before the bubbling find handler.
+      if (isThreadFindActive && event.key === "Escape") return;
       if (isTerminalCloseConfirmPending() && preventTerminalCloseShortcut(event, keybindings)) {
         event.stopPropagation();
         return;
@@ -8216,8 +8212,28 @@ export default function ChatView(props: ChatViewProps) {
       event.stopPropagation();
       void runProjectScript(script);
     };
+    const dismissFind = (event: KeyboardEvent) => {
+      if (
+        event.key !== "Escape" ||
+        !isThreadFindActive ||
+        event.defaultPrevented ||
+        event.isComposing ||
+        event.keyCode === 229 ||
+        isCommandPaletteOpen()
+      )
+        return;
+      const context = getShortcutContext(event.target);
+      if (context.terminalFocus || context.previewFocus || context.modelPickerOpen) return;
+      event.preventDefault();
+      closeThreadFind();
+      focusComposer();
+    };
     window.addEventListener("keydown", handler, true);
-    return () => window.removeEventListener("keydown", handler, true);
+    window.addEventListener("keydown", dismissFind);
+    return () => {
+      window.removeEventListener("keydown", handler, true);
+      window.removeEventListener("keydown", dismissFind);
+    };
   }, [
     activeProject,
     activeRightPanelSurface,
@@ -11246,12 +11262,18 @@ export default function ChatView(props: ChatViewProps) {
             activeThreadTitle={activeThread.title}
             activeProject={activeProject ?? null}
             rightPanelOpen={inlineRightPanelOwnsTitleBar}
-            findBar={<ThreadFindBar {...threadFind.barProps} />}
             onNewThreadInProject={handleNewThreadInActiveProject}
             {...(activeDraftLogicalProjectKey
               ? { onOpenProjectSettings: handleOpenDraftProjectSettings }
               : {})}
           />
+          <ThreadFindBar
+            {...threadFind.barProps}
+            onClose={() => {
+              closeThreadFind();
+              focusComposer();
+            }}
+          />
         </header>
 
         {/* Main content area with optional plan sidebar */}
@@ -11381,11 +11403,7 @@ export default function ChatView(props: ChatViewProps) {
                     ? (heldPaintContext?.workspaceRoot ?? undefined)
                     : activeWorkspaceRoot
                 }
-                skills={
-                  activeProviderStatus
-                    ? resolveProviderSkillsForCwd(activeProviderStatus, gitCwd)
-                    : EMPTY_PROVIDER_SKILLS
-                }
+                skills={timelineSkills}
                 anchorMessageId={paintOnlyDisplayedTimeline ? null : timelineAnchorMessageId}
                 onAnchorReady={onTimelineAnchorReady}
                 onAnchorSizeChanged={onTimelineAnchorSizeChanged}
@@ -11395,6 +11413,7 @@ export default function ChatView(props: ChatViewProps) {
                 onContentOverflowChange={setTimelineOverflows}
                 onToolOutputCollapsedAtEnd={onToolOutputCollapsedAtEnd}
                 onManualNavigation={cancelTimelineLiveFollowForUserNavigation}
+                onResumeLiveFollow={scrollToEnd}
                 cancelPositionRestoreRef={cancelPositionRestoreRef}
                 hideEmptyPlaceholder={isDraftHeroState || threadDetailLoading}
                 topFadeEnabled={!hasTimelineTopBanner}
@@ -11404,7 +11423,7 @@ export default function ChatView(props: ChatViewProps) {
               />
 
               {/* scroll to end pill — shown when user has scrolled away from the live edge */}
-              {showScrollToBottom && threadFind.timelineProps.searchEntries === null && (
+              {showScrollToBottom && !isThreadFindActive && (
                 <div
                   className="chat-scroll-to-bottom pointer-events-none absolute z-30 flex justify-center py-1.5"
                   style={{ bottom: scrollToEndClearance + 4 }}
diff --git a/apps/web/src/components/ComposerPromptEditorTiptap.tsx b/apps/web/src/components/ComposerPromptEditorTiptap.tsx
index 6b7eb7df7066..6d093f66af73 100644
--- a/apps/web/src/components/ComposerPromptEditorTiptap.tsx
+++ b/apps/web/src/components/ComposerPromptEditorTiptap.tsx
@@ -1,3 +1,4 @@
+import { formatProviderSkillDisplayName } from "@t3tools/shared/inlineSkills";
 import { Extension, Node, wrappingInputRule, type JSONContent } from "@tiptap/core";
 import { TaskList } from "@tiptap/extension-task-list";
 import { ReactNodeViewRenderer, NodeViewWrapper, type NodeViewProps } from "@tiptap/react";
@@ -80,7 +81,6 @@ import {
   ComposerContextRecordsContext,
 } from "./composerContextPresentation";
 import type { AssistantCitationSourceAnchor } from "~/lib/assistantTextSelection";
-import { formatProviderSkillDisplayName } from "@t3tools/client-runtime/providerSkills";
 import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip";
 import { importPastedComposerText } from "./composerInlineTokenPaste";
 import { didComposerSelectionChangeVisibly } from "./composerSelection";
diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx
index 22b042167ca9..fc6f82bfc65f 100644
--- a/apps/web/src/components/chat/ChatComposer.tsx
+++ b/apps/web/src/components/chat/ChatComposer.tsx
@@ -1,3 +1,4 @@
+import { formatProviderSkillDisplayName } from "@t3tools/shared/inlineSkills";
 import { DESKTOP_PASTE_AS_TEXT_EVENT } from "../../lib/desktopPasteAsText";
 import { runtimeModeConfig, runtimeModeOptions as runtimeModes } from "./runtimeModeConfig";
 import { isLocalEnvironmentDisabled } from "../../localEnvironment";
@@ -1120,7 +1121,6 @@ import {
 } from "@t3tools/client-runtime/state/composer-dispatch";
 import type { ContextWindowSnapshot } from "../../lib/contextWindow";
 import {
-  formatProviderSkillDisplayName,
   getProviderSlashCommandsForSlashMenu,
   getProviderSkillsForSlashMenu,
   hasCompleteProviderWorkspaceSnapshot,
diff --git a/apps/web/src/components/chat/ChatHeader.tsx b/apps/web/src/components/chat/ChatHeader.tsx
index 03f06b82819d..86d315b3d136 100644
--- a/apps/web/src/components/chat/ChatHeader.tsx
+++ b/apps/web/src/components/chat/ChatHeader.tsx
@@ -40,7 +40,6 @@ import {
 import { cn } from "~/lib/utils";
 
 interface ChatHeaderProps {
-  findBar: import("react").ReactNode;
   activeThreadEnvironmentId: EnvironmentId;
   activeThreadId: ThreadId;
   activeThreadTitle: string;
@@ -74,7 +73,6 @@ export function resolveRenameCommit(input: {
 // opens immediately.
 const TITLE_MENU_OPEN_DELAY_MS = 500;
 export const ChatHeader = memo(function ChatHeader({
-  findBar,
   activeThreadEnvironmentId,
   activeThreadId,
   activeThreadTitle,
@@ -358,7 +356,6 @@ export const ChatHeader = memo(function ChatHeader({
           )}
         </WorkspaceBreadcrumbItem>
       </WorkspaceBreadcrumb>
-      {findBar}
     </div>
   );
 });
diff --git a/apps/web/src/components/chat/ComposerCommandMenu.tsx b/apps/web/src/components/chat/ComposerCommandMenu.tsx
index 4c13641dd1b1..edd28efe1d7f 100644
--- a/apps/web/src/components/chat/ComposerCommandMenu.tsx
+++ b/apps/web/src/components/chat/ComposerCommandMenu.tsx
@@ -1,5 +1,5 @@
+import { formatProviderSkillDisplayName } from "@t3tools/shared/inlineSkills";
 import {
-  formatProviderSkillDisplayName,
   resolveProviderSkillSourceKind,
   type ProviderSkillSourceKind,
 } from "@t3tools/client-runtime/providerSkills";
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
index 173a964d5efc..74b50b9b4a7a 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
@@ -1,3 +1,4 @@
+import { shouldPreserveAssistantLineBreaks } from "@t3tools/shared/markdownPipeline";
 import { ThreadId, type WorktreeSetupSnapshot } from "@t3tools/contracts";
 import {
   CheckpointRef,
@@ -28,7 +29,6 @@ import {
   resolveAssistantMessageCopyState,
   resolveWorkGroupScrollIndex,
   shouldFollowWorkGroupAppend,
-  shouldPreserveAssistantLineBreaks,
   type MessagesTimelineRow,
   resolveTimelineToolPresentation,
   workEntryDisplayLabel,
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts
index 18245f40fe24..6482149de81c 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts
@@ -308,10 +308,6 @@ export function resolveTimelineIsAtEnd(state: TimelineEndState | undefined): boo
   return contentLength - scroll - scrollLength <= TIMELINE_FOLLOW_REARM_THRESHOLD_PX;
 }
 
-export function shouldPreserveAssistantLineBreaks(text: string): boolean {
-  return /^★ Insight(?:\s|─)/mu.test(text);
-}
-
 export function resolveTimelineMinimapHeightStyle(itemCount: number): string {
   const naturalHeight = Math.max(1, (itemCount - 1) * TIMELINE_MINIMAP_ITEM_SPACING);
   return `min(${naturalHeight}px, ${TIMELINE_MINIMAP_MAX_HEIGHT_CSS})`;
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index dddb15c49272..aa41b57e52db 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -1,4 +1,4 @@
-const NOOP_SEARCH_LAYOUT = () => {};
+import { shouldPreserveAssistantLineBreaks } from "@t3tools/shared/markdownPipeline";
 import { MarkdownFindContext } from "./markdownFindContext";
 import { ComputerUseAppIcon } from "~/components/Icons";
 import { useChatCanvas } from "./ChatCanvasContext";
@@ -208,7 +208,6 @@ import {
   resolveTimelineMinimapTopPercent,
   resolveWorkGroupScrollIndex,
   shouldFollowWorkGroupAppend,
-  shouldPreserveAssistantLineBreaks,
   toolGroupAction,
   workEntryDisplayLabel,
   workEntryReadOutput,
@@ -391,6 +390,9 @@ function TimelineListFooter({
     </div>
   );
 }
+const NOOP_SEARCH_LAYOUT = () => {};
+const EMPTY_FIND_DIFFS: MessagesTimelineProps["turnDiffSummaries"] = [];
+
 const EMPTY_TIMELINE_SKILLS: ReadonlyArray<Pick<ServerProviderSkill, "name" | "displayName">> = [];
 const TIMELINE_MAINTAIN_SCROLL_AT_END = {
   animated: false,
@@ -506,6 +508,8 @@ interface MessagesTimelineProps {
   onContentOverflowChange?: (overflows: boolean) => void;
   onToolOutputCollapsedAtEnd?: () => void;
   onManualNavigation: () => void;
+  onResumeLiveFollow?: () => void;
+  findOpen?: boolean;
   cancelPositionRestoreRef?: React.RefObject<(() => void) | null> | undefined;
   hideEmptyPlaceholder?: boolean;
   topFadeEnabled?: boolean;
@@ -527,6 +531,27 @@ export function MessagesTimeline(props: MessagesTimelineProps) {
   const searchListRef = useRef<LegendListRef | null>(null);
   const searchEntries = props.searchEntries;
   const searching = searchEntries != null;
+  const origin = useRef<{ threadId: string; following: boolean } | null>(null);
+  const {
+    findOpen,
+    routeThreadKey: threadId,
+    liveFollowEnabled,
+    onManualNavigation,
+    onResumeLiveFollow,
+  } = props;
+  useLayoutEffect(() => {
+    if (origin.current?.threadId !== threadId) origin.current = null;
+    if (findOpen) {
+      if (!origin.current) {
+        origin.current = { threadId, following: liveFollowEnabled };
+        onManualNavigation();
+      }
+    } else if (origin.current) {
+      const following = origin.current.following;
+      origin.current = null;
+      if (following) onResumeLiveFollow?.();
+    }
+  }, [findOpen, threadId, liveFollowEnabled, onManualNavigation, onResumeLiveFollow]);
   return (
     <div className="relative flex min-h-0 flex-1 flex-col">
       <div
@@ -538,9 +563,9 @@ export function MessagesTimeline(props: MessagesTimelineProps) {
         <ConversationTimeline
           {...props}
           canvasActive={!searching}
-          findQuery={searching ? "" : (props.findQuery ?? "")}
-          activeFindMatch={searching ? null : (props.activeFindMatch ?? null)}
-          liveFollowEnabled={!searching && props.liveFollowEnabled}
+          findQuery=""
+          activeFindMatch={null}
+          liveFollowEnabled={!findOpen && props.liveFollowEnabled}
         />
       </div>
       {searchEntries && (
@@ -564,7 +589,7 @@ export function MessagesTimeline(props: MessagesTimelineProps) {
             anchorMessageId={null}
             latestRun={null}
             runningRunId={null}
-            turnDiffSummaries={[]}
+            turnDiffSummaries={EMPTY_FIND_DIFFS}
             supportsConversationRollback={false}
             isWorking={false}
             runlessWorkActive={false}
@@ -1409,9 +1434,17 @@ const ConversationTimeline = memo(function ConversationTimeline({
   const activeFindMatchKey = activeFindMatch
     ? `${findNavigationId}:${normalizedFindQuery}:${activeFindMatch.entryId}:${activeFindMatch.occurrence}`
     : null;
+  const revealedFindMatchKeyRef = useRef<string | null>(null);
+  const [positionedFindMatchKey, setPositionedFindMatchKey] = useState<string | null>(null);
   const revealActiveFindRange = useCallback(
     (range: Range | null) => {
-      if (!range) return;
+      if (
+        !range ||
+        !activeFindMatchKey ||
+        positionedFindMatchKey !== activeFindMatchKey ||
+        revealedFindMatchKeyRef.current === activeFindMatchKey
+      )
+        return;
 
       const codeScroller = range.startContainer.parentElement?.closest("pre");
       if (codeScroller) {
@@ -1425,6 +1458,7 @@ const ConversationTimeline = memo(function ConversationTimeline({
       const viewportRect = timelineViewportElement?.getBoundingClientRect();
       if (!viewportRect || matchRect.height === 0) return;
 
+      revealedFindMatchKeyRef.current = activeFindMatchKey;
       const topBoundary = viewportRect.top + FIND_MATCH_VIEW_MARGIN;
       const bottomBoundary =
         viewportRect.bottom - FIND_MATCH_VIEW_MARGIN - contentInsetEndAdjustment;
@@ -1438,30 +1472,43 @@ const ConversationTimeline = memo(function ConversationTimeline({
         listRef.current?.scrollToOffset({ offset: currentScroll + delta, animated: false });
       }
     },
-    [contentInsetEndAdjustment, listRef, timelineViewportElement],
+    [
+      activeFindMatchKey,
+      positionedFindMatchKey,
+      contentInsetEndAdjustment,
+      listRef,
+      timelineViewportElement,
+    ],
   );
 
   const navigatedFindMatchKeyRef = useRef<string | null>(null);
 
+  const activeFindRowIndex = activeFindMatch
+    ? rows.findIndex((row) => row.id === activeFindMatch.entryId)
+    : -1;
   useEffect(() => {
-    if (!activeFindMatch || !activeFindMatchKey) {
+    if (!activeFindMatchKey) {
       navigatedFindMatchKeyRef.current = null;
+      revealedFindMatchKeyRef.current = null;
       return;
     }
-
-    const rowIndex = rows.findIndex((row) => row.id === activeFindMatch.entryId);
-    if (rowIndex === -1) return;
-
-    if (navigatedFindMatchKeyRef.current === activeFindMatchKey) return;
-    navigatedFindMatchKeyRef.current = activeFindMatchKey;
-
-    onManualNavigation();
-    void listRef.current?.scrollToIndex({
-      index: rowIndex,
-      animated: false,
-      viewOffset: FIND_MATCH_VIEW_MARGIN,
-    });
-  }, [activeFindMatch, activeFindMatchKey, listRef, onManualNavigation, rows]);
+    if (activeFindRowIndex < 0 || navigatedFindMatchKeyRef.current === activeFindMatchKey) return;
+    let cancelled = false;
+    void listRef.current
+      ?.scrollToIndex({
+        index: activeFindRowIndex,
+        animated: false,
+        viewOffset: FIND_MATCH_VIEW_MARGIN,
+      })
+      .then(() => {
+        if (cancelled) return;
+        navigatedFindMatchKeyRef.current = activeFindMatchKey;
+        setPositionedFindMatchKey(activeFindMatchKey);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [activeFindMatchKey, activeFindRowIndex, listRef]);
 
   useThreadFindHighlights({
     container: timelineViewportElement,
diff --git a/apps/web/src/components/chat/SkillInlineText.tsx b/apps/web/src/components/chat/SkillInlineText.tsx
index 2327577b3a80..5832f8904a5c 100644
--- a/apps/web/src/components/chat/SkillInlineText.tsx
+++ b/apps/web/src/components/chat/SkillInlineText.tsx
@@ -1,34 +1,20 @@
+import { formatProviderSkillDisplayName } from "@t3tools/shared/inlineSkills";
 import { Children, cloneElement, isValidElement, type ReactNode } from "react";
-import type { ServerProviderSkill } from "@t3tools/contracts";
-import { formatProviderSkillDisplayName } from "@t3tools/client-runtime/providerSkills";
+import { matchInlineSkills, type InlineSkill } from "@t3tools/shared/inlineSkills";
 
 import { SKILL_CHIP_ICON_SVG } from "../composerInlineChip";
 import { ContextChip, ContextChipLabel } from "../ContextChip";
 
-const SKILL_TOKEN_REGEX =
-  /(^|\s)\p{Sc}(?![0-9][0-9_]*(?:[kKmMbBtT]|[eE][0-9]+)?(?:\s|$))(?=[a-zA-Z0-9:_-]*[a-zA-Z])([a-zA-Z0-9][a-zA-Z0-9:_-]*)(?=\s|$)/gu;
-
-type InlineSkill = Pick<ServerProviderSkill, "name" | "displayName">;
-
 export function SkillInlineText(props: { text: string; skills: ReadonlyArray<InlineSkill> }) {
   const nodes: ReactNode[] = [];
   let cursor = 0;
 
-  for (const match of props.text.matchAll(SKILL_TOKEN_REGEX)) {
-    const prefix = match[1] ?? "";
-    const name = match[2] ?? "";
-    const start = (match.index ?? 0) + prefix.length;
-    const rawText = `$${name}`;
-    const skill = props.skills.find((candidate) => candidate.name === name);
-    if (!skill) {
-      continue;
-    }
-
+  for (const { start, end, skill, rawText } of matchInlineSkills(props.text, props.skills)) {
     if (start > cursor) {
       nodes.push(props.text.slice(cursor, start));
     }
-    nodes.push(<SkillChip key={`${start}:${name}`} skill={skill} rawText={rawText} />);
-    cursor = (match.index ?? 0) + match[0].length;
+    nodes.push(<SkillChip key={`${start}:${skill.name}`} skill={skill} rawText={rawText} />);
+    cursor = end;
   }
 
   if (cursor === 0) {
diff --git a/apps/web/src/components/chat/threadFind.ts b/apps/web/src/components/chat/threadFind.ts
index dfa925cce882..411692a4cd56 100644
--- a/apps/web/src/components/chat/threadFind.ts
+++ b/apps/web/src/components/chat/threadFind.ts
@@ -1,3 +1,4 @@
+import type { InlineSkill } from "@t3tools/shared/inlineSkills";
 import type { RunId } from "@t3tools/contracts";
 import { countThreadSearchOccurrences } from "@t3tools/shared/threadSearch";
 import type { TimelineEntry } from "../../session-logic";
@@ -16,22 +17,23 @@ export interface ThreadFindMatch {
 // Weak keys reuse parsed text across keystrokes without retaining old messages.
 const entryTextCache = new WeakMap<
   object,
-  { cwd: string | undefined; segments: readonly string[] | null }
+  { cwd: string | undefined; skills: readonly InlineSkill[]; segments: readonly string[] | null }
 >();
 
 function searchableThreadEntrySegments(
   entry: TimelineEntry,
   cwd?: string,
+  skills: readonly InlineSkill[] = [],
 ): readonly string[] | null {
   if (entry.kind !== "message" && entry.kind !== "proposed-plan") return null;
   const key = entry.kind === "message" ? entry.message : entry.proposedPlan;
   const cached = entryTextCache.get(key);
-  if (cached && cached.cwd === cwd) return cached.segments;
+  if (cached && cached.cwd === cwd && cached.skills === skills) return cached.segments;
   const segments =
     entry.kind === "message"
-      ? searchableMessageSegments(entry.message, cwd)
-      : searchablePlanSegments(entry.proposedPlan.planMarkdown, cwd);
-  entryTextCache.set(key, { cwd, segments });
+      ? searchableMessageSegments(entry.message, cwd, skills)
+      : searchablePlanSegments(entry.proposedPlan.planMarkdown, cwd, skills);
+  entryTextCache.set(key, { cwd, skills, segments });
   return segments;
 }
 
@@ -45,13 +47,14 @@ export function buildThreadFindMatches(
   entries: ReadonlyArray<TimelineEntry>,
   query: string,
   cwd?: string,
+  skills: readonly InlineSkill[] = [],
 ): ThreadFindMatch[] {
   const normalizedQuery = query.trim();
   if (normalizedQuery.length === 0) return [];
 
   const matches: ThreadFindMatch[] = [];
   for (const entry of entries) {
-    const segments = searchableThreadEntrySegments(entry, cwd);
+    const segments = searchableThreadEntrySegments(entry, cwd, skills);
     if (segments === null) continue;
 
     const total = segments.reduce(
diff --git a/apps/web/src/components/chat/useThreadFind.ts b/apps/web/src/components/chat/useThreadFind.ts
index cd9abeadcc7e..339028d63855 100644
--- a/apps/web/src/components/chat/useThreadFind.ts
+++ b/apps/web/src/components/chat/useThreadFind.ts
@@ -1,3 +1,4 @@
+import type { InlineSkill } from "@t3tools/shared/inlineSkills";
 import type { OrchestrationV2ThreadProjection, ScopedThreadRef } from "@t3tools/contracts";
 import { scopedThreadKey } from "@t3tools/client-runtime/environment";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
@@ -9,6 +10,8 @@ import { buildThreadFindMatches, clampThreadFindIndex, stepThreadFindIndex } fro
 import { subscribeThreadFindOpen } from "./threadFindActionBus";
 import { useThreadFindHistory } from "./useThreadFindHistory";
 
+const EMPTY_SKILLS: readonly InlineSkill[] = [];
+
 const CLOSED_FIND = {
   threadKey: null as string | null,
   query: "",
@@ -22,6 +25,7 @@ export function useThreadFind({
   thread,
   serverSearch,
   cwd,
+  skills = EMPTY_SKILLS,
   content,
   entries,
   history,
@@ -29,6 +33,7 @@ export function useThreadFind({
   thread: ScopedThreadRef | null;
   serverSearch: boolean;
   cwd: string | undefined;
+  skills?: readonly InlineSkill[];
   content: Pick<OrchestrationV2ThreadProjection, "visibleTurnItems" | "runs"> | undefined;
   entries: ReadonlyArray<TimelineEntry>;
   history: Parameters<typeof useThreadFindHistory>[1];
@@ -53,6 +58,7 @@ export function useThreadFind({
     state.query,
     state.activeIndex,
     content,
+    skills,
   );
   const localStatus = useThreadFindHistory(
     !serverSearch && isOpen && state.query.trim() ? `${threadKey}:${state.focusRequestId}` : null,
@@ -70,8 +76,9 @@ export function useThreadFind({
         entries,
         !serverSearch && isOpen && status !== "loading" ? state.query : "",
         cwd,
+        skills,
       ),
-    [cwd, entries, isOpen, serverSearch, state.query, status],
+    [cwd, entries, isOpen, serverSearch, skills, state.query, status],
   );
   const count = serverSearch ? (remote.data?.totalMatches ?? 0) : localMatches.length;
   const activeIndex = serverSearch
@@ -88,13 +95,7 @@ export function useThreadFind({
     [remote.data],
   );
   const selected = remote.data?.match;
-  const activeMatch = serverSearch
-    ? selected && {
-        entryId: selected.entryId,
-        runId: selected.runId,
-        occurrence: selected.occurrence,
-      }
-    : localMatches[activeIndex];
+  const activeMatch = serverSearch ? selected : localMatches[activeIndex];
   const step = (delta: number) =>
     setState((previous) => ({
       ...previous,
@@ -121,7 +122,8 @@ export function useThreadFind({
       onClose: close,
     },
     timelineProps: {
-      searchEntries,
+      findOpen: isOpen,
+      searchEntries: !serverSearch && isOpen && state.query.trim() ? entries : searchEntries,
       onCloseSearch: close,
       findQuery: isOpen && (!serverSearch || searchEntries !== null) ? state.query : "",
       activeFindMatch: activeMatch ?? null,
@@ -136,14 +138,19 @@ function useServerResults(
   query: string,
   index: number,
   content: Pick<OrchestrationV2ThreadProjection, "visibleTurnItems" | "runs"> | undefined,
+  skills: readonly InlineSkill[],
 ) {
+  const skillLabels = useMemo(
+    () => skills.map(({ name, displayName }) => ({ name, displayName })),
+    [skills],
+  );
   const normalizedQuery = query.trim();
   const debouncedQuery = useDebouncedValue(normalizedQuery, 200);
   const atom =
     thread && debouncedQuery && normalizedQuery === debouncedQuery
       ? orchestrationEnvironment.threadFind({
           environmentId: thread.environmentId,
-          input: { threadId: thread.threadId, query: debouncedQuery, index },
+          input: { threadId: thread.threadId, query: debouncedQuery, index, skills: skillLabels },
         })
       : null;
   const result = useEnvironmentQuery(atom);
diff --git a/apps/web/src/components/chat/useThreadFindHistory.test.tsx b/apps/web/src/components/chat/useThreadFindHistory.test.tsx
index 20ea1b30a48a..16c3f4d2d002 100644
--- a/apps/web/src/components/chat/useThreadFindHistory.test.tsx
+++ b/apps/web/src/components/chat/useThreadFindHistory.test.tsx
@@ -50,7 +50,7 @@ afterEach(async () => {
 
 describe("thread find history loading", () => {
   it("loads sequential pages without duplicate requests and finishes only at the oldest page", async () => {
-    const load = vi.fn(() => true);
+    const load = vi.fn();
     const page = { cursor: "recent", loading: false, onLoadEarlier: load };
     await render("thread:1", page);
     await render("thread:1", { ...page });
@@ -69,7 +69,7 @@ describe("thread find history loading", () => {
   });
 
   it("does not loop on a failed page and allows an explicit retry", async () => {
-    const load = vi.fn(() => true);
+    const load = vi.fn();
     const page = { cursor: "recent", loading: false, onLoadEarlier: load };
     await render("thread:1", page);
     await render("thread:1", { ...page, loading: true });
@@ -81,15 +81,8 @@ describe("thread find history loading", () => {
     expect(load).toHaveBeenCalledTimes(2);
   });
 
-  it("offers retry if the thread cannot start a history request", async () => {
-    const load = vi.fn(() => false);
-    await render("thread:1", { cursor: "recent", loading: false, onLoadEarlier: load });
-    expect(status).toBe("incomplete");
-    expect(load).toHaveBeenCalledTimes(1);
-  });
-
   it("stops when find closes or the query clears, and isolates requests between threads", async () => {
-    const load = vi.fn(() => true);
+    const load = vi.fn();
     const page = { cursor: "recent", loading: false, onLoadEarlier: load };
     await render(null, page);
     expect(load).not.toHaveBeenCalled();
diff --git a/apps/web/src/components/chat/useThreadFindHistory.ts b/apps/web/src/components/chat/useThreadFindHistory.ts
index 2b4bd3b0b41a..1f1d49d59b67 100644
--- a/apps/web/src/components/chat/useThreadFindHistory.ts
+++ b/apps/web/src/components/chat/useThreadFindHistory.ts
@@ -1,14 +1,10 @@
 import { useEffect, useRef, useState } from "react";
 import type { CitationHistoryPage } from "./useAssistantCitationTarget";
 
-type FindHistoryPage = Omit<CitationHistoryPage, "onLoadEarlier"> & {
-  readonly onLoadEarlier: () => boolean;
-};
-
 /** Search needs every history page, but leaves row mounting to the virtual list. */
 export function useThreadFindHistory(
   requestKey: string | null,
-  page: FindHistoryPage | null,
+  page: CitationHistoryPage | null,
 ): "loading" | "incomplete" | null {
   const requested = useRef<{ key: string; cursors: Set<string>; loading: boolean } | null>(null);
   const [failedKey, setFailedKey] = useState<string | null>(null);
@@ -34,7 +30,7 @@ export function useThreadFindHistory(
       return;
     }
     requested.current.cursors.add(cursor);
-    if (!page.onLoadEarlier()) setFailedKey(requestKey);
+    page.onLoadEarlier();
   }, [failedKey, page, requestKey]);
 
   if (requestKey === null || page === null) return null;
diff --git a/apps/web/src/providerSkillSearch.ts b/apps/web/src/providerSkillSearch.ts
index a570c92d91f1..21e182360f9a 100644
--- a/apps/web/src/providerSkillSearch.ts
+++ b/apps/web/src/providerSkillSearch.ts
@@ -1,7 +1,7 @@
+import { formatProviderSkillDisplayName } from "@t3tools/shared/inlineSkills";
 import type { ServerProviderSkill } from "@t3tools/contracts";
 import {
   dedupeProviderSkillsByName,
-  formatProviderSkillDisplayName,
   isProviderSkillUserInvocable,
 } from "@t3tools/client-runtime/providerSkills";
 import {
diff --git a/packages/client-runtime/src/providerSkills.test.ts b/packages/client-runtime/src/providerSkills.test.ts
index d5c8933f0bf4..1b9ca671d10c 100644
--- a/packages/client-runtime/src/providerSkills.test.ts
+++ b/packages/client-runtime/src/providerSkills.test.ts
@@ -4,11 +4,11 @@ import {
   ProviderInstanceId,
   type ServerProvider,
 } from "@t3tools/contracts";
+import { formatProviderSkillDisplayName } from "@t3tools/shared/inlineSkills";
 import { describe, expect, it } from "vite-plus/test";
 
 import {
   dedupeProviderSkillsByName,
-  formatProviderSkillDisplayName,
   getProviderSlashCommandsForSlashMenu,
   getProviderSkillsForSlashMenu,
   hasCompleteProviderWorkspaceSnapshot,
diff --git a/packages/client-runtime/src/providerSkills.ts b/packages/client-runtime/src/providerSkills.ts
index 4d649cd19f11..fe69c371fc6c 100644
--- a/packages/client-runtime/src/providerSkills.ts
+++ b/packages/client-runtime/src/providerSkills.ts
@@ -7,29 +7,10 @@ import {
 
 export type ProviderSkillSourceKind = "app" | "repo" | "project" | "personal" | "system" | "other";
 
-function titleCaseWords(value: string): string {
-  const words: string[] = [];
-  for (const segment of value.split(/[\s:_-]+/)) {
-    if (segment.length === 0) continue;
-    words.push(segment.charAt(0).toUpperCase() + segment.slice(1));
-  }
-  return words.join(" ");
-}
-
 function normalizePathSeparators(pathValue: string): string {
   return pathValue.replaceAll("\\", "/");
 }
 
-export function formatProviderSkillDisplayName(
-  skill: Pick<ServerProviderSkill, "name" | "displayName">,
-): string {
-  const displayName = skill.displayName?.trim();
-  if (displayName) {
-    return displayName;
-  }
-  return titleCaseWords(skill.name);
-}
-
 export function dedupeProviderSkillsByName(
   skills: ReadonlyArray<ServerProviderSkill>,
 ): ServerProviderSkill[] {
diff --git a/packages/contracts/src/orchestrationV2.ts b/packages/contracts/src/orchestrationV2.ts
index 9c31d5a8633f..c9884de0d6f9 100644
--- a/packages/contracts/src/orchestrationV2.ts
+++ b/packages/contracts/src/orchestrationV2.ts
@@ -3487,6 +3487,15 @@ export class OrchestrationGetWorkflowScriptError extends Schema.TaggedError<Orch
 
 export const OrchestrationV2SearchThreadInput = Schema.Struct({
   threadId: ThreadId,
+  // Match the skill labels displayed by this client, including custom display names.
+  skills: Schema.optionalKey(
+    Schema.Array(
+      Schema.Struct({
+        name: Schema.String,
+        displayName: Schema.optional(Schema.String),
+      }),
+    ),
+  ),
   query: TrimmedNonEmptyString.check(Schema.isMaxLength(200)),
   index: Schema.optionalKey(NonNegativeInt),
 });
diff --git a/packages/shared/package.json b/packages/shared/package.json
index 927d7d93074d..38cfd0eb210b 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -446,6 +446,10 @@
     "./fileLinks": {
       "types": "./src/fileLinks.ts",
       "import": "./src/fileLinks.ts"
+    },
+    "./inlineSkills": {
+      "types": "./src/inlineSkills.ts",
+      "import": "./src/inlineSkills.ts"
     }
   },
   "scripts": {
diff --git a/packages/shared/src/inlineSkills.ts b/packages/shared/src/inlineSkills.ts
new file mode 100644
index 000000000000..b5f4437b7a3d
--- /dev/null
+++ b/packages/shared/src/inlineSkills.ts
@@ -0,0 +1,35 @@
+import type { ServerProviderSkill } from "@t3tools/contracts";
+
+export type InlineSkill = Pick<ServerProviderSkill, "name" | "displayName">;
+
+function titleCaseWords(value: string): string {
+  const words: string[] = [];
+  for (const segment of value.split(/[\s:_-]+/)) {
+    if (segment.length === 0) continue;
+    words.push(segment.charAt(0).toUpperCase() + segment.slice(1));
+  }
+  return words.join(" ");
+}
+
+export function formatProviderSkillDisplayName(
+  skill: Pick<ServerProviderSkill, "name" | "displayName">,
+): string {
+  const displayName = skill.displayName?.trim();
+  if (displayName) {
+    return displayName;
+  }
+  return titleCaseWords(skill.name);
+}
+
+const SKILL_TOKEN_REGEX =
+  /(^|\s)\p{Sc}(?![0-9][0-9_]*(?:[kKmMbBtT]|[eE][0-9]+)?(?:\s|$))(?=[a-zA-Z0-9:_-]*[a-zA-Z])([a-zA-Z0-9][a-zA-Z0-9:_-]*)(?=\s|$)/gu;
+
+export function* matchInlineSkills(text: string, skills: readonly InlineSkill[]) {
+  for (const match of text.matchAll(SKILL_TOKEN_REGEX)) {
+    const name = match[2] ?? "";
+    const skill = skills.find((candidate) => candidate.name === name);
+    if (!skill) continue;
+    const start = match.index + (match[1]?.length ?? 0);
+    yield { start, end: match.index + match[0].length, skill, rawText: `$${name}` };
+  }
+}
diff --git a/packages/shared/src/markdownPipeline.ts b/packages/shared/src/markdownPipeline.ts
index 918c0db6d2da..55df21815fba 100644
--- a/packages/shared/src/markdownPipeline.ts
+++ b/packages/shared/src/markdownPipeline.ts
@@ -230,3 +230,7 @@ function remarkKeepWindowsPathDestinations(this: Processor) {
     },
   });
 }
+
+export function shouldPreserveAssistantLineBreaks(text: string): boolean {
+  return /^★ Insight(?:\s|─)/mu.test(text);
+}
diff --git a/packages/shared/src/threadFindText.test.ts b/packages/shared/src/threadFindText.test.ts
index abf0b2f14157..4260207ec69c 100644
--- a/packages/shared/src/threadFindText.test.ts
+++ b/packages/shared/src/threadFindText.test.ts
@@ -98,11 +98,11 @@ it("includes the same parent suffixes for duplicate filenames as the renderer",
   ).toEqual(["first main.ts and main.ts · L2"]);
 });
 
-it("keeps literal file paths in fences and user messages", () => {
+it("keeps fence paths literal and indexes file-chip labels in user messages", () => {
   expect(assistantSegments("```text\n/tmp/file.ts:42\n```")).toEqual(["/tmp/file.ts:42\n"]);
   expect(
     searchableMessageSegments({ role: "user", text: "`/tmp/file.ts:42`", streaming: false }),
-  ).toEqual(["/tmp/file.ts:42"]);
+  ).toEqual(["file.ts · L42"]);
 });
 
 it("indexes nested disclosure summaries and bodies in rendered order", () => {
@@ -112,3 +112,26 @@ it("indexes nested disclosure summaries and bodies in rendered order", () => {
     ),
   ).toEqual(["Outer", "first", "Inner", "second"]);
 });
+
+it("uses Insight line breaks without splitting ordinary assistant prose", () => {
+  expect(assistantSegments("★ Insight ─────\nfirst line\nsecond line")).toEqual([
+    "★ Insight ─────",
+    " first line",
+    " second line",
+  ]);
+  expect(assistantSegments("first line\nsecond line")).toEqual(["first line second line"]);
+});
+
+it("indexes skill labels in prose but leaves links and code literal", () => {
+  expect(
+    searchableMessageSegments(
+      {
+        role: "assistant",
+        streaming: false,
+        text: "Use $test-t3-app now.\n\n`$test-t3-app`\n\n[$test-t3-app](https://example.com)",
+      },
+      undefined,
+      [{ name: "test-t3-app", displayName: "T3 App Testing" }],
+    ),
+  ).toEqual(["Use T3 App Testing now.", "$test-t3-app", "$test-t3-app"]);
+});
diff --git a/packages/shared/src/threadFindText.ts b/packages/shared/src/threadFindText.ts
index f11bbd808875..8a7e9c1c71de 100644
--- a/packages/shared/src/threadFindText.ts
+++ b/packages/shared/src/threadFindText.ts
@@ -1,3 +1,8 @@
+import {
+  matchInlineSkills,
+  formatProviderSkillDisplayName,
+  type InlineSkill,
+} from "./inlineSkills.ts";
 import { renderCodexFileCitationsAsMarkdown } from "./codexMarkdownDirectives.ts";
 import {
   buildFileLinkParentSuffixByPath,
@@ -19,6 +24,7 @@ import { unified } from "unified";
 import remarkParse from "remark-parse";
 import remarkRehype from "remark-rehype";
 import {
+  shouldPreserveAssistantLineBreaks,
   CHAT_MARKDOWN_REHYPE_PLUGINS,
   CHAT_MARKDOWN_REMARK_PLUGINS,
   CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS,
@@ -69,6 +75,11 @@ const assistantProcessor = unified()
   .use(CHAT_MARKDOWN_REMARK_PLUGINS)
   .use(remarkRehype, { allowDangerousHtml: true })
   .use(CHAT_MARKDOWN_REHYPE_PLUGINS);
+const assistantBreaksProcessor = unified()
+  .use(remarkParse)
+  .use(CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS)
+  .use(remarkRehype, { allowDangerousHtml: true })
+  .use(CHAT_MARKDOWN_REHYPE_PLUGINS);
 const userProcessor = unified()
   .use(remarkParse)
   .use(CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS)
@@ -87,20 +98,26 @@ interface TextTree {
 }
 
 /** Uses the renderer's Markdown transforms, without mounting folded/virtualized rows. */
-function markdownThreadFindText(markdown: string, userMessage = false, cwd?: string): string[] {
-  const processor = userMessage ? userProcessor : assistantProcessor;
+function markdownThreadFindText(
+  markdown: string,
+  userMessage = false,
+  cwd?: string,
+  skills: readonly InlineSkill[] = [],
+  lineBreaks = false,
+): string[] {
+  const processor = userMessage
+    ? userProcessor
+    : lineBreaks
+      ? assistantBreaksProcessor
+      : assistantProcessor;
   const tree = processor.runSync(processor.parse(markdown));
-  const paths = userMessage
-    ? []
-    : [
-        ...extractMarkdownLinkHrefs(renderCodexFileCitationsAsMarkdown(markdown)),
-        ...extractInlineCodeSpans(markdown).flatMap(
-          (span) => inlineCodeFilePathCandidate(span) ?? [],
-        ),
-      ].flatMap((href) => {
-        const target = resolveMarkdownFileLinkTarget(href, cwd);
-        return target ? [splitFilePathPosition(target).path] : [];
-      });
+  const paths = [
+    ...extractMarkdownLinkHrefs(renderCodexFileCitationsAsMarkdown(markdown)),
+    ...extractInlineCodeSpans(markdown).flatMap((span) => inlineCodeFilePathCandidate(span) ?? []),
+  ].flatMap((href) => {
+    const target = resolveMarkdownFileLinkTarget(href, cwd);
+    return target ? [splitFilePathPosition(target).path] : [];
+  });
   const parentSuffixes = buildFileLinkParentSuffixByPath(paths);
   const segments: string[] = [];
   let text = "";
@@ -108,13 +125,13 @@ function markdownThreadFindText(markdown: string, userMessage = false, cwd?: str
     if (text.trim()) segments.push(text);
     text = "";
   };
-  const visit = (node: TextTree, inPre = false) => {
+  const visit = (node: TextTree, inPre = false, inlineSkills = false) => {
     const href = node.properties?.href ?? node.properties?.src;
     if (userMessage && typeof href === "string" && parseComposerContextHref(href)) {
       flush();
       return;
     }
-    if (!userMessage) {
+    {
       let candidate: string | null = null;
       if (node.tagName === "a" && typeof href === "string") {
         candidate = href;
@@ -141,9 +158,24 @@ function markdownThreadFindText(markdown: string, userMessage = false, cwd?: str
     const block = THREAD_FIND_BLOCK_TAGS.has(node.tagName ?? "");
     if (block) flush();
     if (node.type === "text" || (userMessage && node.type === "raw")) {
-      text += inPre ? (node.value ?? "") : (node.value ?? "").replace(/\r?\n/g, " ");
+      let value = node.value ?? "";
+      if (inlineSkills) {
+        let cursor = 0;
+        let rendered = "";
+        for (const { start, end, skill } of matchInlineSkills(value, skills)) {
+          rendered += value.slice(cursor, start) + formatProviderSkillDisplayName(skill);
+          cursor = end;
+        }
+        value = rendered + value.slice(cursor);
+      }
+      text += inPre ? value : value.replace(/\r?\n/g, " ");
     }
-    for (const child of node.children ?? []) visit(child, inPre || node.tagName === "pre");
+    const renderSkills =
+      node.tagName === "code" || node.tagName === "a"
+        ? false
+        : inlineSkills || node.tagName === "p" || node.tagName === "li";
+    for (const child of node.children ?? [])
+      visit(child, inPre || node.tagName === "pre", renderSkills);
     if (block) flush();
   };
   visit(tree);
@@ -151,25 +183,32 @@ function markdownThreadFindText(markdown: string, userMessage = false, cwd?: str
   return segments;
 }
 
-export function searchablePlanSegments(markdown: string, cwd?: string): readonly string[] {
+export function searchablePlanSegments(
+  markdown: string,
+  cwd?: string,
+  skills: readonly InlineSkill[] = [],
+): readonly string[] {
   return [
     proposedPlanTitle(markdown) ?? "Proposed plan",
-    ...markdownThreadFindText(stripDisplayedPlanMarkdown(markdown), false, cwd),
+    ...markdownThreadFindText(stripDisplayedPlanMarkdown(markdown), false, cwd, skills),
   ];
 }
 
 export function searchableMessageSegments(
   message: Pick<OrchestrationV2ConversationMessage, "role" | "text" | "streaming" | "context">,
   cwd?: string,
+  skills: readonly InlineSkill[] = [],
 ): readonly string[] | null {
   if (message.role === "user") {
     const text = message.context ? message.text : upgradeLegacyContextMessage(message.text).text;
-    return markdownThreadFindText(text, true);
+    return markdownThreadFindText(text, true, cwd, skills);
   }
   if (message.role !== "assistant") return null;
   return markdownThreadFindText(
     message.text || (message.streaming ? "" : "(empty response)"),
     false,
     cwd,
+    skills,
+    shouldPreserveAssistantLineBreaks(message.text),
   );
 }

From 6c190f21d0627ef08daacbd97e082f8fc2eae1c3 Mon Sep 17 00:00:00 2001
From: Jono Kemball <jono-kemball@idexx.com>
Date: Wed, 7 Oct 2026 16:58:43 +1300
Subject: [PATCH 03/21] fix: address thread search review findings

---
 .../src/orchestration-v2/ProjectionStore.ts   | 24 ++++++-----
 .../src/orchestration-v2/ThreadFind.test.ts   | 40 ++++++++++++++++++-
 .../server/src/orchestration-v2/ThreadFind.ts | 15 ++++---
 apps/web/src/components/ChatMarkdown.test.tsx |  9 ++++-
 apps/web/src/components/ChatMarkdown.tsx      | 12 +++---
 apps/web/src/components/CommandPalette.tsx    |  9 +++++
 packages/shared/src/fileLinks.test.ts         |  7 ++++
 packages/shared/src/fileLinks.ts              |  2 +-
 packages/shared/src/threadFindText.ts         | 16 +++++++-
 9 files changed, 109 insertions(+), 25 deletions(-)

diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.ts
index 18ae04d536cf..2f4b0054ae81 100644
--- a/apps/server/src/orchestration-v2/ProjectionStore.ts
+++ b/apps/server/src/orchestration-v2/ProjectionStore.ts
@@ -6271,17 +6271,21 @@ export const layerMemory: Layer.Layer<ProjectionStoreV2> = Layer.effect(
           ),
         ),
       searchThread: (input) =>
-        service
-          .getThreadSnapshot(input.threadId)
-          .pipe(
-            Effect.map((snapshot) =>
-              findProjectedThreadItems(
-                snapshot.projection.visibleTurnItems,
-                input,
-                snapshot.snapshotSequence,
-              ),
-            ),
+        service.getThreadSnapshot(input.threadId).pipe(
+          Effect.flatMap(({ projection, snapshotSequence }) =>
+            projection.thread.deletedAt !== null
+              ? Effect.fail(new ProjectionStoreThreadNotFoundError({ threadId: input.threadId }))
+              : Effect.succeed(
+                  // This store has no project records, so only worktree paths resolve labels.
+                  findProjectedThreadItems(
+                    projection.visibleTurnItems,
+                    input,
+                    snapshotSequence,
+                    projection.thread.worktreePath ?? undefined,
+                  ),
+                ),
           ),
+        ),
       getTimelinePage: (threadId, options) =>
         service.getThreadProjection(threadId).pipe(
           Effect.map((projection) => {
diff --git a/apps/server/src/orchestration-v2/ThreadFind.test.ts b/apps/server/src/orchestration-v2/ThreadFind.test.ts
index d8f2fc160241..916bfcc877b5 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.test.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.test.ts
@@ -446,7 +446,45 @@ describe("V2 thread find", () => {
       const deleted = thread(threadId, projectId, { deletedAt: at(3) });
       if (deleted.type !== "thread.created") return;
       yield* commit([{ ...deleted, id: EventId.make("deleted"), type: "thread.deleted" }]);
-      yield* Effect.flip(projection.searchThread({ threadId, query: "needle" }));
+      const error = yield* Effect.flip(projection.searchThread({ threadId, query: "needle" }));
+      assert.equal(error._tag, "ProjectionStoreThreadNotFoundError");
     }).pipe(Effect.provide(layerTest)),
   );
+
+  it.effect("memory store resolves worktree file labels and rejects deleted threads", () =>
+    Effect.gen(function* () {
+      const projection = yield* ProjectionStore.ProjectionStoreV2;
+      const created = thread(threadId, projectId);
+      if (created.type !== "thread.created") return;
+      const withWorktree = {
+        ...created,
+        payload: { ...created.payload, worktreePath: "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/work/tree" },
+      };
+      const message = item("file", 1, "See `docs/notes.md:12`.");
+      yield* Effect.forEach(
+        [
+          withWorktree,
+          run(),
+          {
+            id: EventId.make("file"),
+            threadId,
+            occurredAt: at(1),
+            type: "turn-item.updated",
+            payload: message,
+          },
+        ] satisfies OrchestrationV2DomainEvent[],
+        projection.apply,
+        { discard: true },
+      );
+      assert.equal(
+        (yield* projection.searchThread({ threadId, query: "notes.md · L12" })).totalMatches,
+        1,
+      );
+      const deleted = thread(threadId, projectId, { deletedAt: at(3) });
+      if (deleted.type !== "thread.created") return;
+      yield* projection.apply({ ...deleted, id: EventId.make("deleted"), type: "thread.deleted" });
+      const error = yield* Effect.flip(projection.searchThread({ threadId, query: "notes" }));
+      assert.equal(error._tag, "ProjectionStoreThreadNotFoundError");
+    }).pipe(Effect.provide(ProjectionStore.layerMemory)),
+  );
 });
diff --git a/apps/server/src/orchestration-v2/ThreadFind.ts b/apps/server/src/orchestration-v2/ThreadFind.ts
index 2c727dde5a23..8367521a4c0f 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.ts
@@ -14,7 +14,11 @@ import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
 import * as SqlClient from "effect/sql/SqlClient";
-import { ProjectionStoreReadError, type ProjectionStoreV2Error } from "./ProjectionStore.ts";
+import {
+  ProjectionStoreReadError,
+  ProjectionStoreThreadNotFoundError,
+  type ProjectionStoreV2Error,
+} from "./ProjectionStore.ts";
 
 interface FindRow {
   readonly position: number;
@@ -173,6 +177,9 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
     Schema.fromJsonString(Schema.Array(Schema.Struct({ threadId: ThreadId, id: TurnItemId }))),
   );
   const decodeItem = Schema.decodeUnknownEffect(Schema.fromJsonString(OrchestrationV2TurnItemJson));
+  const isSnapshotError = Schema.is(
+    Schema.Union([ProjectionStoreReadError, ProjectionStoreThreadNotFoundError]),
+  );
   const load = Effect.fn("ThreadFind.load")(function* (
     threadId: ThreadId,
     rows: readonly FindRow[],
@@ -218,7 +225,7 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
       FROM orchestration_v2_projection_threads t JOIN projection_projects p ON p.project_id = t.project_id
       WHERE t.thread_id = ${threadId} AND t.deleted_at IS NULL AND p.deleted_at IS NULL
     `;
-      if (!active[0]) return yield* new ProjectionStoreReadError({ threadId });
+      if (!active[0]) return yield* new ProjectionStoreThreadNotFoundError({ threadId });
       const index = yield* readIndex(threadId);
       const sources = yield* encodeThreadIds([
         ...new Set([threadId, ...index.map((row) => row.sourceThreadId)]),
@@ -245,9 +252,7 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
     (effect, threadId) =>
       effect.pipe(
         Effect.mapError((cause) =>
-          Schema.is(ProjectionStoreReadError)(cause)
-            ? cause
-            : new ProjectionStoreReadError({ threadId, cause }),
+          isSnapshotError(cause) ? cause : new ProjectionStoreReadError({ threadId, cause }),
         ),
       ),
   );
diff --git a/apps/web/src/components/ChatMarkdown.test.tsx b/apps/web/src/components/ChatMarkdown.test.tsx
index 1ef0b1bd79f5..9f7e0c536f90 100644
--- a/apps/web/src/components/ChatMarkdown.test.tsx
+++ b/apps/web/src/components/ChatMarkdown.test.tsx
@@ -1121,9 +1121,13 @@ it.each([
     query: "Hidden needle",
     count: 1,
   },
+  { text: ARTIFACT_TEMPLATE_DIRECTIVE, query: "Hello World", count: 1, useTemplate: true },
+  { text: ARTIFACT_TEMPLATE_DIRECTIVE, query: "Document template", count: 1, useTemplate: true },
+  { text: ARTIFACT_TEMPLATE_DIRECTIVE, query: "World Document", count: 0, useTemplate: true },
+  { text: ARTIFACT_TEMPLATE_DIRECTIVE, query: "Use template", count: 0, useTemplate: true },
 ])(
-  "highlights the indexed occurrences in $text",
-  async ({ text, query, count, lineBreaks, user }) => {
+  "highlights the indexed occurrences of $query in $text",
+  async ({ text, query, count, lineBreaks, user, useTemplate }) => {
     const skills = [{ name: "test-t3-app", displayName: "T3 App Testing" }];
     const highlights = new Map<string, Set<Range>>();
     vi.stubGlobal(
@@ -1157,6 +1161,7 @@ it.each([
                 skills={skills}
                 lineBreaks={lineBreaks ?? false}
                 parseRawHtml={!user}
+                onUseArtifactTemplate={useTemplate ? () => undefined : undefined}
               />
             </MarkdownFindContext>
           </div>
diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index c08de21f1cdd..361a17f9260e 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -327,15 +327,17 @@ function CodexArtifactTemplateCard(props: {
             <SparklesIcon aria-hidden className="size-2.5" />
           </span>
         </span>
-        <span className="min-w-0">
-          <span className="block truncate text-sm font-medium text-foreground">
+        {/* Block elements keep the name and label separate thread-find segments. */}
+        <div className="min-w-0">
+          <div className="truncate text-sm font-medium text-foreground">
             {props.template.displayName}
-          </span>
-          <span className="block text-xs text-muted-foreground">{presentationLabel}</span>
-        </span>
+          </div>
+          <div className="text-xs text-muted-foreground">{presentationLabel}</div>
+        </div>
       </div>
       {props.onUse ? (
         <Button
+          data-thread-find-ignore
           type="button"
           size="sm"
           variant="outline"
diff --git a/apps/web/src/components/CommandPalette.tsx b/apps/web/src/components/CommandPalette.tsx
index 976d66a41e3d..517b21e08411 100644
--- a/apps/web/src/components/CommandPalette.tsx
+++ b/apps/web/src/components/CommandPalette.tsx
@@ -3108,6 +3108,15 @@ function OpenCommandPaletteDialog(props: {
       void copyActiveThreadReference();
       return;
     }
+    // ChatView ignores shortcuts while the palette is open, so handle find here
+    // instead of letting the browser's own Find open.
+    if (command === "chat.find" && activeThreadId && !event.nativeEvent.isComposing) {
+      event.preventDefault();
+      event.stopPropagation();
+      setOpen(false);
+      requestThreadFindOpen();
+      return;
+    }
 
     if (addProjectCloneFlow?.step === "repository" && event.key === "Enter") {
       event.preventDefault();
diff --git a/packages/shared/src/fileLinks.test.ts b/packages/shared/src/fileLinks.test.ts
index 7eee43b5998e..7d07826089f7 100644
--- a/packages/shared/src/fileLinks.test.ts
+++ b/packages/shared/src/fileLinks.test.ts
@@ -62,4 +62,11 @@ describe("resolvePathLinkTarget", () => {
       resolvePathLinkTarget("C:/Users/julius/project/src/main.ts:12", "C:\\Users\\julius\\project"),
     ).toBe("C:/Users/julius/project/src/main.ts:12");
   });
+
+  it.each([
+    ["C:\\Users\\julius\\project", "C:\\Users\\julius\\notes.md:3"],
+    ["C:/Users/julius/project", "C:/Users/julius\\notes.md:3"],
+  ])("resolves home paths against the Windows cwd %s", (cwd, expected) => {
+    expect(resolvePathLinkTarget("~/notes.md:3", cwd)).toBe(expected);
+  });
 });
diff --git a/packages/shared/src/fileLinks.ts b/packages/shared/src/fileLinks.ts
index 2f85669797a7..16e1ca567ce7 100644
--- a/packages/shared/src/fileLinks.ts
+++ b/packages/shared/src/fileLinks.ts
@@ -80,7 +80,7 @@ function inferHomeFromCwd(cwd: string): string | undefined {
     return `/home/${posixHome[1]}`;
   }
 
-  const windowsUser = cwd.match(/^([A-Za-z]:\\Users\\[^\\]+)/);
+  const windowsUser = cwd.match(/^([A-Za-z]:[\\/]Users[\\/][^\\/]+)/);
   if (windowsUser?.[1]) {
     return windowsUser[1];
   }
diff --git a/packages/shared/src/threadFindText.ts b/packages/shared/src/threadFindText.ts
index 8a7e9c1c71de..7e6d6e23ec30 100644
--- a/packages/shared/src/threadFindText.ts
+++ b/packages/shared/src/threadFindText.ts
@@ -3,7 +3,11 @@ import {
   formatProviderSkillDisplayName,
   type InlineSkill,
 } from "./inlineSkills.ts";
-import { renderCodexFileCitationsAsMarkdown } from "./codexMarkdownDirectives.ts";
+import {
+  artifactTemplateFromHastProperties,
+  renderCodexFileCitationsAsMarkdown,
+} from "./codexMarkdownDirectives.ts";
+import { codexArtifactTemplatePresentationLabel } from "./codexArtifactTemplates.ts";
 import {
   buildFileLinkParentSuffixByPath,
   splitFilePathPosition,
@@ -155,6 +159,16 @@ function markdownThreadFindText(
         return;
       }
     }
+    const template = artifactTemplateFromHastProperties(node.properties);
+    if (template) {
+      // Matches the card's visible text; its action button is not indexed.
+      flush();
+      segments.push(
+        template.displayName,
+        codexArtifactTemplatePresentationLabel(template.artifactKind),
+      );
+      return;
+    }
     const block = THREAD_FIND_BLOCK_TAGS.has(node.tagName ?? "");
     if (block) flush();
     if (node.type === "text" || (userMessage && node.type === "raw")) {

From 2aeae6398fc521c9bbe2876b6a0e8a3eaeb57a07 Mon Sep 17 00:00:00 2001
From: Jono Kemball <jono-kemball@idexx.com>
Date: Wed, 7 Oct 2026 17:23:22 +1300
Subject: [PATCH 04/21] refactor(web): require server support for thread search

---
 apps/web/src/components/ChatView.tsx          |  11 +-
 apps/web/src/components/CommandPalette.tsx    |   5 +-
 .../web/src/components/chat/ThreadFindBar.tsx |  19 +-
 .../src/components/chat/threadFind.test.ts    | 242 +-----------------
 apps/web/src/components/chat/threadFind.ts    |  65 +----
 .../components/chat/useThreadFind.test.tsx    |  62 ++++-
 apps/web/src/components/chat/useThreadFind.ts |  78 +++---
 .../chat/useThreadFindHistory.test.tsx        |  97 -------
 .../components/chat/useThreadFindHistory.ts   |  38 ---
 docs/user/keybindings.md                      |   4 +-
 10 files changed, 101 insertions(+), 520 deletions(-)
 delete mode 100644 apps/web/src/components/chat/useThreadFindHistory.test.tsx
 delete mode 100644 apps/web/src/components/chat/useThreadFindHistory.ts

diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index a0e5e7a48e43..f751e814dbb7 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -7909,18 +7909,9 @@ export default function ChatView(props: ChatViewProps) {
     : EMPTY_PROVIDER_SKILLS;
   const threadFind = useThreadFind({
     skills: timelineSkills,
-    cwd: gitCwd ?? undefined,
     thread: activeThreadRef,
-    serverSearch: isServerThread && serverConfig?.threadFind === true,
+    enabled: isServerThread && serverConfig?.threadFind === true,
     content: serverProjection ?? undefined,
-    entries: timelineEntries,
-    history: threadHistoryControls
-      ? {
-          loading: threadHistoryControls.loading,
-          cursor: serverThreadHistory.historyCursor,
-          onLoadEarlier: threadHistoryControls.onLoadEarlier,
-        }
-      : null,
   });
   const { isOpen: isThreadFindActive, open: openThreadFind, close: closeThreadFind } = threadFind;
 
diff --git a/apps/web/src/components/CommandPalette.tsx b/apps/web/src/components/CommandPalette.tsx
index 517b21e08411..80aedc344fb1 100644
--- a/apps/web/src/components/CommandPalette.tsx
+++ b/apps/web/src/components/CommandPalette.tsx
@@ -1140,6 +1140,9 @@ function OpenCommandPaletteDialog(props: {
   );
 
   const activeThreadId = activeThread?.id;
+  const supportsThreadFind =
+    environments.find((environment) => environment.environmentId === activeThread?.environmentId)
+      ?.serverConfig?.threadFind === true;
   const currentProjectEnvironmentId =
     activeThread?.environmentId ?? activeDraftThread?.environmentId ?? null;
   const currentProjectId = activeThread?.projectId ?? activeDraftThread?.projectId ?? null;
@@ -1930,7 +1933,7 @@ function OpenCommandPaletteDialog(props: {
     });
   }
 
-  if (activeThreadId) {
+  if (activeThreadId && supportsThreadFind) {
     actionItems.push({
       kind: "action",
       value: "find-current-thread",
diff --git a/apps/web/src/components/chat/ThreadFindBar.tsx b/apps/web/src/components/chat/ThreadFindBar.tsx
index eabff16ecaf4..251845077cb2 100644
--- a/apps/web/src/components/chat/ThreadFindBar.tsx
+++ b/apps/web/src/components/chat/ThreadFindBar.tsx
@@ -9,8 +9,8 @@ interface ThreadFindBarProps {
   readonly open: boolean;
   readonly query: string;
   readonly matchCount: number;
-  readonly historyState: "loading" | "incomplete" | "error" | null;
-  readonly onRetryHistory: () => void;
+  readonly status: "loading" | "error" | null;
+  readonly onRetry: () => void;
   readonly activeIndex: number;
   readonly focusRequestId: number;
   readonly onQueryChange: (query: string) => void;
@@ -31,15 +31,14 @@ export function ThreadFindBar(props: ThreadFindBarProps) {
   if (!props.open) return null;
 
   const hasQuery = props.query.trim().length > 0;
-  const noResults = hasQuery && !props.historyState && props.matchCount === 0;
+  const noResults = hasQuery && !props.status && props.matchCount === 0;
   let label = "";
   if (hasQuery) {
     label = formatThreadFindCount(props.activeIndex, props.matchCount);
-    if (props.historyState === "incomplete") label += " (partial)";
   }
-  if (props.historyState === "loading") label = "Searching…";
-  if (props.historyState === "error") label = "Search failed";
-  const navigationDisabled = props.matchCount === 0 || props.historyState === "loading";
+  if (props.status === "loading") label = "Searching…";
+  if (props.status === "error") label = "Search failed";
+  const navigationDisabled = props.matchCount === 0 || props.status === "loading";
   const handleKeyDown = (event: KeyboardEvent<HTMLInputElement>) => {
     if (event.nativeEvent.isComposing || event.nativeEvent.keyCode === 229) return;
     if (event.key === "Enter") {
@@ -57,7 +56,7 @@ export function ThreadFindBar(props: ThreadFindBarProps) {
       onContextMenu={(event) => event.stopPropagation()}
       role="search"
       aria-label="Find in thread"
-      aria-busy={props.historyState === "loading"}
+      aria-busy={props.status === "loading"}
       className="absolute top-[calc(100%+0.5rem)] right-0 z-40 w-[min(24rem,calc(100vw-1.5rem))] [-webkit-app-region:no-drag]"
     >
       <InputGroupInput
@@ -83,8 +82,8 @@ export function ThreadFindBar(props: ThreadFindBarProps) {
         >
           {label}
         </span>
-        {props.historyState === "incomplete" || props.historyState === "error" ? (
-          <Button size="xs" variant="ghost" onClick={props.onRetryHistory}>
+        {props.status === "error" ? (
+          <Button size="xs" variant="ghost" onClick={props.onRetry}>
             Retry
           </Button>
         ) : null}
diff --git a/apps/web/src/components/chat/threadFind.test.ts b/apps/web/src/components/chat/threadFind.test.ts
index 92d63a767237..10511f4a2609 100644
--- a/apps/web/src/components/chat/threadFind.test.ts
+++ b/apps/web/src/components/chat/threadFind.test.ts
@@ -1,248 +1,8 @@
-import { MessageId, RunId, PlanId } from "@t3tools/contracts";
 import { describe, expect, it } from "vite-plus/test";
-import type { TimelineEntry } from "../../session-logic";
-import { deriveMessagesTimelineRows } from "./MessagesTimeline.logic";
-import {
-  buildThreadFindMatches,
-  clampThreadFindIndex,
-  formatThreadFindCount,
-  stepThreadFindIndex,
-} from "./threadFind";
-
-const CREATED_AT = "2026-01-01T00:00:00.000Z";
-
-function messageEntry(
-  id: string,
-  role: "user" | "assistant" | "system",
-  text: string,
-  runId: RunId | null = null,
-): TimelineEntry {
-  return {
-    id,
-    kind: "message",
-    createdAt: CREATED_AT,
-    message: {
-      id: MessageId.make(id),
-      role,
-      text,
-      runId,
-      streaming: false,
-      createdAt: CREATED_AT,
-      updatedAt: CREATED_AT,
-    },
-  };
-}
-
-function workEntry(id: string): TimelineEntry {
-  return {
-    id,
-    kind: "work",
-    createdAt: CREATED_AT,
-    entry: {
-      id,
-      label: "deploy sentinel",
-      tone: "tool",
-      createdAt: CREATED_AT,
-    },
-  };
-}
-
-function proposedPlanEntry(id: string, planMarkdown: string, runId: RunId | null): TimelineEntry {
-  return {
-    id,
-    kind: "proposed-plan",
-    createdAt: CREATED_AT,
-    proposedPlan: {
-      id: PlanId.make(id),
-      runId,
-      planMarkdown,
-      status: "active",
-      createdAt: CREATED_AT,
-      updatedAt: CREATED_AT,
-    },
-  };
-}
-
-describe("searchable thread entries", () => {
-  it("searches displayed user text without appended context payloads", () => {
-    const prompt = [
-      "check the build",
-      "",
-      "<terminal_context>",
-      "- Terminal 1 line 12:",
-      "  secret sentinel output",
-      "</terminal_context>",
-    ].join("\n");
-
-    const entries = [messageEntry("m1", "user", prompt)];
-    expect(buildThreadFindMatches(entries, "check the build")).toHaveLength(1);
-    expect(buildThreadFindMatches(entries, "sentinel")).toHaveLength(0);
-  });
-
-  it("excludes terminal labels that render as non-searchable chips", () => {
-    const prompt = [
-      "check @terminal-1:12",
-      "",
-      "<terminal_context>",
-      "- Terminal 1 line 12:",
-      "  12 | output",
-      "</terminal_context>",
-    ].join("\n");
-
-    const entries = [messageEntry("m1", "user", prompt)];
-    expect(buildThreadFindMatches(entries, "check")).toHaveLength(1);
-    expect(buildThreadFindMatches(entries, "@terminal-1:12")).toHaveLength(0);
-  });
-
-  it("keeps repeated terminal labels that are still visible after the chip", () => {
-    const prompt =
-      "check @terminal-1:12 and @terminal-1:12\n\n<terminal_context>\n- Terminal 1 line 12:\n  12 | output\n</terminal_context>";
-    expect(
-      buildThreadFindMatches([messageEntry("m1", "user", prompt)], "@terminal-1:12"),
-    ).toHaveLength(1);
-  });
-
-  it("excludes terminal chips even when their labels are out of context order", () => {
-    const prompt =
-      "@terminal-2:12 then @terminal-1:12\n\n<terminal_context>\n- Terminal 1 line 12:\n  12 | first\n- Terminal 2 line 12:\n  12 | second\n</terminal_context>";
-    expect(buildThreadFindMatches([messageEntry("m1", "user", prompt)], "@terminal-")).toHaveLength(
-      0,
-    );
-  });
-
-  it.each(["user", "assistant"] as const)(
-    "searches rendered %s Markdown, not link destinations or formatting",
-    (role) => {
-      const entries = [
-        messageEntry(
-          "m1",
-          role,
-          "[documentation](https://hidden.example/path) foo**bar** and `inline code`",
-        ),
-      ];
-      expect(buildThreadFindMatches(entries, "hidden.example")).toHaveLength(0);
-      expect(buildThreadFindMatches(entries, "documentation")).toHaveLength(1);
-      expect(buildThreadFindMatches(entries, "foobar")).toHaveLength(1);
-      expect(buildThreadFindMatches(entries, "inline code")).toHaveLength(1);
-    },
-  );
-
-  it("searches code, escaped punctuation, entities and sanitized HTML as displayed", () => {
-    const entries = [
-      messageEntry(
-        "m1",
-        "assistant",
-        "```ts\nconst value = 1;\n```\n\n\\*literal\\* &amp; <strong>bold</strong><script>hidden</script>",
-      ),
-    ];
-    for (const query of ["const value", "*literal* & bold"]) {
-      expect(buildThreadFindMatches(entries, query)).toHaveLength(1);
-    }
-    for (const query of ["hidden", "strong", "```ts"]) {
-      expect(buildThreadFindMatches(entries, query)).toHaveLength(0);
-    }
-  });
-
-  it("preserves literal HTML in user messages", () => {
-    expect(
-      buildThreadFindMatches([messageEntry("m1", "user", "<strong>bold</strong>")], "<strong>"),
-    ).toHaveLength(1);
-  });
-
-  it("searches plan titles before body matches, including the default title", () => {
-    const entries = [proposedPlanEntry("p1", "# Release\n\n## Summary\n\nRelease **ready**", null)];
-    expect(buildThreadFindMatches(entries, "Release").map((match) => match.occurrence)).toEqual([
-      0, 1,
-    ]);
-    expect(buildThreadFindMatches(entries, "Summary")).toHaveLength(0);
-    expect(
-      buildThreadFindMatches([proposedPlanEntry("p2", "Body", null)], "Proposed plan"),
-    ).toHaveLength(1);
-  });
-
-  it("does not join separate blocks or the plan title and body into a phrase", () => {
-    expect(
-      buildThreadFindMatches([messageEntry("m1", "assistant", "first\n\nsecond")], "firstsecond"),
-    ).toHaveLength(0);
-    expect(
-      buildThreadFindMatches([proposedPlanEntry("p1", "# first\n\nsecond", null)], "firstsecond"),
-    ).toHaveLength(0);
-  });
-
-  it("indexes the rendered placeholder for empty assistant responses", () => {
-    expect(
-      buildThreadFindMatches([messageEntry("m1", "assistant", "")], "(empty response)"),
-    ).toHaveLength(1);
-  });
-
-  it("skips work rows and system messages", () => {
-    expect(
-      buildThreadFindMatches(
-        [workEntry("w1"), messageEntry("s1", "system", "sentinel")],
-        "sentinel",
-      ),
-    ).toHaveLength(0);
-  });
-
-  it("uses the displayed proposed-plan title and body", () => {
-    const entries = [proposedPlanEntry("p1", "# Visible title\n\n## Summary\n\nship it", null)];
-    expect(buildThreadFindMatches(entries, "Visible title")).toHaveLength(1);
-    expect(buildThreadFindMatches(entries, "ship it")).toHaveLength(1);
-    expect(buildThreadFindMatches(entries, "Summary")).toHaveLength(0);
-  });
-});
-
-describe("buildThreadFindMatches", () => {
-  it("carries turn ownership for folded messages and plans", () => {
-    const runId = RunId.make("turn-1");
-    const entries = [
-      messageEntry("m1", "assistant", "deploy twice: deploy", runId),
-      proposedPlanEntry("p1", "deploy the plan", runId),
-    ];
-
-    expect(buildThreadFindMatches(entries, "deploy")).toEqual([
-      { entryId: "m1", runId, occurrence: 0 },
-      { entryId: "m1", runId, occurrence: 1 },
-      { entryId: "p1", runId, occurrence: 0 },
-    ]);
-  });
-
-  it("reveals a search result inside a settled turn and restores its fold afterward", () => {
-    const runId = RunId.make("settled-turn");
-    const entries = [
-      messageEntry("prompt", "user", "Check the release"),
-      messageEntry("progress", "assistant", "Found the sentinel", runId),
-      messageEntry("final", "assistant", "Done", runId),
-    ];
-    const input = {
-      timelineEntries: entries,
-      isWorking: false,
-      activeTurnStartedAt: null,
-      turnDiffSummaries: [],
-      supportsConversationRollback: false,
-    };
-    const collapsed = deriveMessagesTimelineRows(input);
-    expect(collapsed.some((row) => row.id === "progress")).toBe(false);
-
-    const match = buildThreadFindMatches(entries, "sentinel")[0]!;
-    const expanded = deriveMessagesTimelineRows({
-      ...input,
-      expandedRunIds: new Set(match.runId ? [match.runId] : []),
-    });
-    expect(expanded.some((row) => row.id === match.entryId)).toBe(true);
-    expect(deriveMessagesTimelineRows(input).map((row) => row.id)).toEqual(
-      collapsed.map((row) => row.id),
-    );
-  });
-
-  it("ignores blank queries", () => {
-    expect(buildThreadFindMatches([messageEntry("m1", "user", "deploy")], "   ")).toEqual([]);
-  });
-});
+import { formatThreadFindCount, stepThreadFindIndex } from "./threadFind";
 
 describe("thread find navigation", () => {
   it("clamps, wraps, and formats positions", () => {
-    expect(clampThreadFindIndex(4, 2)).toBe(1);
     expect(stepThreadFindIndex(2, 3, 1)).toBe(0);
     expect(stepThreadFindIndex(0, 3, -1)).toBe(2);
     expect(formatThreadFindCount(4, 2)).toBe("2/2");
diff --git a/apps/web/src/components/chat/threadFind.ts b/apps/web/src/components/chat/threadFind.ts
index 411692a4cd56..3717bdb98fa8 100644
--- a/apps/web/src/components/chat/threadFind.ts
+++ b/apps/web/src/components/chat/threadFind.ts
@@ -1,8 +1,4 @@
-import type { InlineSkill } from "@t3tools/shared/inlineSkills";
 import type { RunId } from "@t3tools/contracts";
-import { countThreadSearchOccurrences } from "@t3tools/shared/threadSearch";
-import type { TimelineEntry } from "../../session-logic";
-import { searchableMessageSegments, searchablePlanSegments } from "@t3tools/shared/threadFindText";
 
 /** One occurrence of the query inside a searchable timeline entry. */
 export interface ThreadFindMatch {
@@ -13,66 +9,7 @@ export interface ThreadFindMatch {
   readonly occurrence: number;
 }
 
-// Message/plan records are immutable and survive timeline rebuilds during streaming.
-// Weak keys reuse parsed text across keystrokes without retaining old messages.
-const entryTextCache = new WeakMap<
-  object,
-  { cwd: string | undefined; skills: readonly InlineSkill[]; segments: readonly string[] | null }
->();
-
-function searchableThreadEntrySegments(
-  entry: TimelineEntry,
-  cwd?: string,
-  skills: readonly InlineSkill[] = [],
-): readonly string[] | null {
-  if (entry.kind !== "message" && entry.kind !== "proposed-plan") return null;
-  const key = entry.kind === "message" ? entry.message : entry.proposedPlan;
-  const cached = entryTextCache.get(key);
-  if (cached && cached.cwd === cwd && cached.skills === skills) return cached.segments;
-  const segments =
-    entry.kind === "message"
-      ? searchableMessageSegments(entry.message, cwd, skills)
-      : searchablePlanSegments(entry.proposedPlan.planMarkdown, cwd, skills);
-  entryTextCache.set(key, { cwd, skills, segments });
-  return segments;
-}
-
-function threadEntryRunId(entry: TimelineEntry): RunId | null {
-  if (entry.kind === "message") return entry.message.runId ?? null;
-  if (entry.kind === "proposed-plan") return entry.proposedPlan.runId;
-  return null;
-}
-
-export function buildThreadFindMatches(
-  entries: ReadonlyArray<TimelineEntry>,
-  query: string,
-  cwd?: string,
-  skills: readonly InlineSkill[] = [],
-): ThreadFindMatch[] {
-  const normalizedQuery = query.trim();
-  if (normalizedQuery.length === 0) return [];
-
-  const matches: ThreadFindMatch[] = [];
-  for (const entry of entries) {
-    const segments = searchableThreadEntrySegments(entry, cwd, skills);
-    if (segments === null) continue;
-
-    const total = segments.reduce(
-      (count, text) => count + countThreadSearchOccurrences(text, normalizedQuery),
-      0,
-    );
-    for (let occurrence = 0; occurrence < total; occurrence += 1) {
-      matches.push({
-        entryId: entry.id,
-        runId: threadEntryRunId(entry),
-        occurrence,
-      });
-    }
-  }
-  return matches;
-}
-
-export function clampThreadFindIndex(index: number, total: number): number {
+function clampThreadFindIndex(index: number, total: number): number {
   if (total <= 0 || !Number.isFinite(index) || index < 0) return 0;
   return Math.min(Math.trunc(index), total - 1);
 }
diff --git a/apps/web/src/components/chat/useThreadFind.test.tsx b/apps/web/src/components/chat/useThreadFind.test.tsx
index f6c82a294200..3fc4394d73c2 100644
--- a/apps/web/src/components/chat/useThreadFind.test.tsx
+++ b/apps/web/src/components/chat/useThreadFind.test.tsx
@@ -12,16 +12,17 @@ import {
 } from "@t3tools/contracts";
 import * as DateTime from "effect/DateTime";
 import { useThreadFind } from "./useThreadFind";
+import { orchestrationEnvironment } from "~/state/orchestration";
+import { requestThreadFindOpen } from "./threadFindActionBus";
 
 const queries = vi.hoisted(() => ({
   results: new Map<string, OrchestrationV2SearchThreadResult>(),
 }));
 vi.mock("~/state/orchestration", () => ({
   orchestrationEnvironment: {
-    threadFind: (input: {
-      environmentId: EnvironmentId;
-      input: OrchestrationV2SearchThreadInput;
-    }) => input,
+    threadFind: vi.fn(
+      (input: { environmentId: EnvironmentId; input: OrchestrationV2SearchThreadInput }) => input,
+    ),
   },
 }));
 vi.mock("~/state/queries", () => ({ useDebouncedValue: <T,>(value: T) => value }));
@@ -34,6 +35,8 @@ vi.mock("~/state/query", () => ({
   }),
 }));
 
+vi.mock("../ui/toast", () => ({ toastManager: { add: vi.fn() } }));
+
 let renderer: ReactTestRenderer | undefined;
 let find: ReturnType<typeof useThreadFind>;
 const a = EnvironmentId.make("environment:a");
@@ -41,15 +44,17 @@ const b = EnvironmentId.make("environment:b");
 const threadId = ThreadId.make("shared-thread");
 const runId = RunId.make("run:plan");
 const now = DateTime.makeUnsafe("2026-10-01T00:00:00Z");
-const entries: Parameters<typeof useThreadFind>[0]["entries"] = [];
-function Probe({ environmentId }: { environmentId: EnvironmentId }) {
+function Probe({
+  environmentId,
+  enabled = true,
+}: {
+  environmentId: EnvironmentId;
+  enabled?: boolean;
+}) {
   const state = useThreadFind({
     thread: { environmentId, threadId },
-    serverSearch: true,
-    cwd: "/repo",
+    enabled,
     content: undefined,
-    entries,
-    history: null,
   });
   useLayoutEffect(() => {
     find = state;
@@ -64,10 +69,47 @@ afterEach(async () => {
   if (renderer) await act(async () => renderer?.unmount());
   renderer = undefined;
   queries.results.clear();
+  vi.clearAllMocks();
   vi.unstubAllGlobals();
 });
 
 describe("V2 find state", () => {
+  it("keeps search unavailable when the server does not support it", async () => {
+    await act(async () => {
+      renderer = create(<Probe environmentId={a} enabled={false} />);
+    });
+    await act(async () => {
+      find.open();
+      requestThreadFindOpen();
+    });
+    expect(find.isOpen).toBe(false);
+    expect(find.timelineProps.searchEntries).toBeNull();
+    expect(orchestrationEnvironment.threadFind).not.toHaveBeenCalled();
+  });
+
+  it("closes search when support disappears without restoring stale queries", async () => {
+    await act(async () => {
+      renderer = create(<Probe environmentId={a} />);
+    });
+    await act(async () => find.open());
+    await act(async () => find.barProps.onQueryChange("needle"));
+    expect(find.isOpen).toBe(true);
+    vi.mocked(orchestrationEnvironment.threadFind).mockClear();
+    await act(async () => {
+      renderer?.update(<Probe environmentId={a} enabled={false} />);
+    });
+    expect(find.isOpen).toBe(false);
+    expect(find.timelineProps.searchEntries).toBeNull();
+    expect(find.timelineProps.findQuery).toBe("");
+    expect(orchestrationEnvironment.threadFind).not.toHaveBeenCalled();
+    await act(async () => {
+      renderer?.update(<Probe environmentId={a} />);
+    });
+    expect(find.isOpen).toBe(false);
+    await act(async () => find.open());
+    expect(find.barProps.query).toBe("");
+  });
+
   it("derives a plan result with the timeline item ID and run ownership", async () => {
     queries.results.set(a, {
       snapshotSequence: 9,
diff --git a/apps/web/src/components/chat/useThreadFind.ts b/apps/web/src/components/chat/useThreadFind.ts
index 339028d63855..19dbdc845fb6 100644
--- a/apps/web/src/components/chat/useThreadFind.ts
+++ b/apps/web/src/components/chat/useThreadFind.ts
@@ -2,13 +2,13 @@ import type { InlineSkill } from "@t3tools/shared/inlineSkills";
 import type { OrchestrationV2ThreadProjection, ScopedThreadRef } from "@t3tools/contracts";
 import { scopedThreadKey } from "@t3tools/client-runtime/environment";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { deriveTimelineEntriesFromVisibleTurnItems, type TimelineEntry } from "~/session-logic";
+import { deriveTimelineEntriesFromVisibleTurnItems } from "~/session-logic";
 import { orchestrationEnvironment } from "~/state/orchestration";
 import { useEnvironmentQuery } from "~/state/query";
 import { useDebouncedValue } from "~/state/queries";
-import { buildThreadFindMatches, clampThreadFindIndex, stepThreadFindIndex } from "./threadFind";
+import { stepThreadFindIndex } from "./threadFind";
 import { subscribeThreadFindOpen } from "./threadFindActionBus";
-import { useThreadFindHistory } from "./useThreadFindHistory";
+import { toastManager } from "../ui/toast";
 
 const EMPTY_SKILLS: readonly InlineSkill[] = [];
 
@@ -20,70 +20,56 @@ const CLOSED_FIND = {
   navigationId: 0,
 };
 
-/** Owns find state and presents the same controls for server search and older-server history. */
+/** Owns find state for the active thread and its environment. */
 export function useThreadFind({
   thread,
-  serverSearch,
-  cwd,
+  enabled,
   skills = EMPTY_SKILLS,
   content,
-  entries,
-  history,
 }: {
   thread: ScopedThreadRef | null;
-  serverSearch: boolean;
-  cwd: string | undefined;
+  enabled: boolean;
   skills?: readonly InlineSkill[];
   content: Pick<OrchestrationV2ThreadProjection, "visibleTurnItems" | "runs"> | undefined;
-  entries: ReadonlyArray<TimelineEntry>;
-  history: Parameters<typeof useThreadFindHistory>[1];
 }) {
   const threadKey = thread ? scopedThreadKey(thread) : null;
   const [state, setState] = useState(CLOSED_FIND);
-  if (state.threadKey !== null && state.threadKey !== threadKey) setState(CLOSED_FIND);
-  const isOpen = threadKey !== null && state.threadKey === threadKey;
+  if (state.threadKey !== null && (!enabled || state.threadKey !== threadKey))
+    setState(CLOSED_FIND);
+  const isOpen = enabled && threadKey !== null && state.threadKey === threadKey;
   const open = useCallback(() => {
     if (threadKey === null) return;
+    if (!enabled) {
+      toastManager.add({
+        id: "thread-find-unavailable",
+        title: "Thread search is unavailable on this server.",
+        description: "Update the server to enable it.",
+      });
+      return;
+    }
     setState((previous) => ({
       ...(previous.threadKey === threadKey ? previous : CLOSED_FIND),
       threadKey,
       focusRequestId: previous.focusRequestId + 1,
     }));
-  }, [threadKey]);
+  }, [enabled, threadKey]);
   const close = useCallback(() => setState(CLOSED_FIND), []);
   useEffect(() => subscribeThreadFindOpen(open), [open]);
 
   const remote = useServerResults(
-    serverSearch && isOpen ? thread : null,
+    isOpen ? thread : null,
     state.query,
     state.activeIndex,
     content,
     skills,
   );
-  const localStatus = useThreadFindHistory(
-    !serverSearch && isOpen && state.query.trim() ? `${threadKey}:${state.focusRequestId}` : null,
-    history,
-  );
-  let status: "loading" | "incomplete" | "error" | null = localStatus;
-  if (serverSearch) {
-    status = null;
-    if (remote.isPending) status = "loading";
-    if (remote.error) status = "error";
-  }
-  const localMatches = useMemo(
-    () =>
-      buildThreadFindMatches(
-        entries,
-        !serverSearch && isOpen && status !== "loading" ? state.query : "",
-        cwd,
-        skills,
-      ),
-    [cwd, entries, isOpen, serverSearch, skills, state.query, status],
-  );
-  const count = serverSearch ? (remote.data?.totalMatches ?? 0) : localMatches.length;
-  const activeIndex = serverSearch
-    ? (remote.data?.activeIndex ?? 0)
-    : clampThreadFindIndex(state.activeIndex, count);
+  const status: "loading" | "error" | null = remote.error
+    ? "error"
+    : remote.isPending
+      ? "loading"
+      : null;
+  const count = remote.data?.totalMatches ?? 0;
+  const activeIndex = remote.data?.activeIndex ?? 0;
   const searchEntries = useMemo(
     () =>
       remote.data?.match
@@ -94,8 +80,6 @@ export function useThreadFind({
         : null,
     [remote.data],
   );
-  const selected = remote.data?.match;
-  const activeMatch = serverSearch ? selected : localMatches[activeIndex];
   const step = (delta: number) =>
     setState((previous) => ({
       ...previous,
@@ -112,9 +96,9 @@ export function useThreadFind({
       query: state.query,
       matchCount: count,
       activeIndex,
-      historyState: status,
+      status,
       focusRequestId: state.focusRequestId,
-      onRetryHistory: serverSearch ? remote.refresh : open,
+      onRetry: remote.refresh,
       onQueryChange: (query: string) =>
         setState((previous) => ({ ...previous, query, activeIndex: 0 })),
       onNext: () => step(1),
@@ -123,10 +107,10 @@ export function useThreadFind({
     },
     timelineProps: {
       findOpen: isOpen,
-      searchEntries: !serverSearch && isOpen && state.query.trim() ? entries : searchEntries,
+      searchEntries,
       onCloseSearch: close,
-      findQuery: isOpen && (!serverSearch || searchEntries !== null) ? state.query : "",
-      activeFindMatch: activeMatch ?? null,
+      findQuery: isOpen && searchEntries !== null ? state.query : "",
+      activeFindMatch: remote.data?.match ?? null,
       findNavigationId: state.navigationId,
     },
   };
diff --git a/apps/web/src/components/chat/useThreadFindHistory.test.tsx b/apps/web/src/components/chat/useThreadFindHistory.test.tsx
deleted file mode 100644
index 16c3f4d2d002..000000000000
--- a/apps/web/src/components/chat/useThreadFindHistory.test.tsx
+++ /dev/null
@@ -1,97 +0,0 @@
-import { act, StrictMode, useLayoutEffect } from "react";
-import { create, type ReactTestRenderer } from "react-test-renderer";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
-import { useThreadFindHistory } from "./useThreadFindHistory";
-
-type CitationHistoryPage = NonNullable<Parameters<typeof useThreadFindHistory>[1]>;
-
-let renderer: ReactTestRenderer;
-let status: ReturnType<typeof useThreadFindHistory>;
-
-function Probe({
-  requestKey,
-  page,
-}: {
-  requestKey: string | null;
-  page: CitationHistoryPage | null;
-}) {
-  const value = useThreadFindHistory(requestKey, page);
-  useLayoutEffect(() => {
-    status = value;
-  }, [value]);
-  return null;
-}
-
-async function render(requestKey: string | null, page: CitationHistoryPage | null) {
-  await act(() => {
-    renderer.update(
-      <StrictMode>
-        <Probe requestKey={requestKey} page={page} />
-      </StrictMode>,
-    );
-  });
-}
-
-beforeEach(async () => {
-  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
-  await act(() => {
-    renderer = create(
-      <StrictMode>
-        <Probe requestKey={null} page={null} />
-      </StrictMode>,
-    );
-  });
-});
-
-afterEach(async () => {
-  await act(() => renderer.unmount());
-  vi.unstubAllGlobals();
-});
-
-describe("thread find history loading", () => {
-  it("loads sequential pages without duplicate requests and finishes only at the oldest page", async () => {
-    const load = vi.fn();
-    const page = { cursor: "recent", loading: false, onLoadEarlier: load };
-    await render("thread:1", page);
-    await render("thread:1", { ...page });
-    expect(load).toHaveBeenCalledTimes(1);
-    expect(status).toBe("loading");
-
-    await render("thread:1", { ...page, loading: true });
-    expect(status).toBe("loading");
-    expect(load).toHaveBeenCalledTimes(1);
-
-    await render("thread:1", { ...page, cursor: "older" });
-    expect(load).toHaveBeenCalledTimes(2);
-    expect(status).not.toBeNull();
-    await render("thread:1", null);
-    expect(status).toBeNull();
-  });
-
-  it("does not loop on a failed page and allows an explicit retry", async () => {
-    const load = vi.fn();
-    const page = { cursor: "recent", loading: false, onLoadEarlier: load };
-    await render("thread:1", page);
-    await render("thread:1", { ...page, loading: true });
-    await render("thread:1", { ...page });
-    expect(status).toBe("incomplete");
-    expect(load).toHaveBeenCalledTimes(1);
-
-    await render("thread:2", page);
-    expect(load).toHaveBeenCalledTimes(2);
-  });
-
-  it("stops when find closes or the query clears, and isolates requests between threads", async () => {
-    const load = vi.fn();
-    const page = { cursor: "recent", loading: false, onLoadEarlier: load };
-    await render(null, page);
-    expect(load).not.toHaveBeenCalled();
-    await render("thread-a:1", page);
-    await render(null, { ...page, cursor: "older" });
-    expect(load).toHaveBeenCalledTimes(1);
-    expect(status).toBeNull();
-
-    await render("thread-b:1", page);
-    expect(load).toHaveBeenCalledTimes(2);
-  });
-});
diff --git a/apps/web/src/components/chat/useThreadFindHistory.ts b/apps/web/src/components/chat/useThreadFindHistory.ts
deleted file mode 100644
index 1f1d49d59b67..000000000000
--- a/apps/web/src/components/chat/useThreadFindHistory.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { useEffect, useRef, useState } from "react";
-import type { CitationHistoryPage } from "./useAssistantCitationTarget";
-
-/** Search needs every history page, but leaves row mounting to the virtual list. */
-export function useThreadFindHistory(
-  requestKey: string | null,
-  page: CitationHistoryPage | null,
-): "loading" | "incomplete" | null {
-  const requested = useRef<{ key: string; cursors: Set<string>; loading: boolean } | null>(null);
-  const [failedKey, setFailedKey] = useState<string | null>(null);
-  if (requestKey === null && failedKey !== null) setFailedKey(null);
-
-  useEffect(() => {
-    if (requestKey === null) {
-      requested.current = null;
-      return;
-    }
-    if (requested.current?.key !== requestKey) {
-      requested.current = { key: requestKey, cursors: new Set(), loading: false };
-    }
-    const wasLoading = requested.current.loading;
-    requested.current.loading = page?.loading ?? false;
-    if (!page || page.loading || failedKey === requestKey) return;
-
-    const cursor = page.cursor ?? "first";
-    // StrictMode replay is not a failed request. Only a completed fetch that
-    // leaves the cursor unchanged needs a manual retry.
-    if (requested.current.cursors.has(cursor)) {
-      if (wasLoading) setFailedKey(requestKey);
-      return;
-    }
-    requested.current.cursors.add(cursor);
-    page.onLoadEarlier();
-  }, [failedKey, page, requestKey]);
-
-  if (requestKey === null || page === null) return null;
-  return failedKey === requestKey ? "incomplete" : "loading";
-}
diff --git a/docs/user/keybindings.md b/docs/user/keybindings.md
index f61b745f285b..b911190476a3 100644
--- a/docs/user/keybindings.md
+++ b/docs/user/keybindings.md
@@ -115,8 +115,8 @@ Combine keys with `!` for not, `&&` for and, `||` for or, and parentheses:
 ## Find in the current thread
 
 `chat.find` searches conversation messages and proposed plans in the active thread. Entering a
-query searches the entire thread, including older messages. When connected to an older server,
-search loads earlier history first. Select **Retry** if a search or history load fails. It defaults to
+query searches the entire thread, including older messages. Thread search requires server support;
+update an older server to enable it. Select **Retry** if a search fails. It defaults to
 `mod+f` outside terminals and previews. Press **Enter** or **Shift+Enter** to move between matches,
 and **Escape** to close find.
 

From 00f3a5f6717a7b107014699d376b789c77285c9f Mon Sep 17 00:00:00 2001
From: Yash Singh <saiansh2525@gmail.com>
Date: Wed, 7 Oct 2026 06:07:24 -0500
Subject: [PATCH 05/21] fix(web): preserve markdown transforms after rebase

---
 packages/shared/src/markdownPipeline.ts | 50 +++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/packages/shared/src/markdownPipeline.ts b/packages/shared/src/markdownPipeline.ts
index 55df21815fba..f7d133f1dc6b 100644
--- a/packages/shared/src/markdownPipeline.ts
+++ b/packages/shared/src/markdownPipeline.ts
@@ -15,6 +15,7 @@ import { isWindowsDrivePathHref } from "./markdownLinks.ts";
 
 type MarkdownImageHastNode = {
   type?: string;
+  value?: string;
   tagName?: string;
   properties?: Record<string, unknown>;
   children?: MarkdownImageHastNode[];
@@ -69,6 +70,54 @@ function markStandaloneImages(node: MarkdownImageHastNode) {
   });
 }
 
+/** Keep unmatched inline `<A>` placeholders from opening an HTML link over later blocks. */
+function rehypePreserveBareAnchorPlaceholders() {
+  return (tree: MarkdownImageHastNode) => {
+    const anchors: Array<MarkdownImageHastNode | null> = [];
+    let rawTextTag: string | undefined;
+    const visit = (node: MarkdownImageHastNode) => {
+      if (node.type === "raw" && typeof node.value === "string") {
+        // Raw blocks can contain several tags. Consume whole tags, quoted attributes,
+        // and comments so text resembling a closing anchor cannot pair a placeholder.
+        const tags = /<!--[\s\S]*?(?:-->|$)|<\/?[A-Za-z](?:[^"'<>]|"[^"]*"|'[^']*')*>/g;
+        let offset = 0;
+        while (rawTextTag !== "plaintext") {
+          // Raw text ends at its closing tag even inside comment-looking text.
+          const matcher = rawTextTag ? new RegExp(`</${rawTextTag}\\s*>`, "gi") : tags;
+          matcher.lastIndex = offset;
+          const match = matcher.exec(node.value);
+          if (!match) break;
+          const [tag] = match;
+          offset = matcher.lastIndex;
+          if (rawTextTag) {
+            rawTextTag = undefined;
+            continue;
+          }
+          if (tag.startsWith("<!--")) continue;
+          const closing = /^<\/([a-z]+)\s*>$/i.exec(tag)?.[1]?.toLowerCase();
+          const opening = /^<([a-z]+)(?:\s|\/?>)/i.exec(tag)?.[1]?.toLowerCase();
+          if (
+            opening &&
+            /^(?:script|style|textarea|title|xmp|iframe|noembed|noframes|plaintext)$/.test(opening)
+          ) {
+            rawTextTag = opening;
+          } else if (opening === "a") {
+            anchors.push(node.value === tag && /^<a\s*\/?>$/i.test(tag) ? node : null);
+          } else if (closing === "a") {
+            anchors.pop();
+          }
+        }
+      }
+      node.children?.forEach(visit);
+    };
+
+    visit(tree);
+    for (const anchor of anchors) {
+      if (anchor) anchor.type = "text";
+    }
+  };
+}
+
 /** Carries authored image source metadata through the sanitizer to the image renderer. */
 function rehypePreserveImageSourceMeta() {
   return (tree: MarkdownImageHastNode) => {
@@ -135,6 +184,7 @@ export const CHAT_MARKDOWN_REMARK_PLUGINS_WITH_BREAKS: PluggableList = [
 ];
 
 export const CHAT_MARKDOWN_REHYPE_PLUGINS: PluggableList = [
+  rehypePreserveBareAnchorPlaceholders,
   rehypeRaw,
   rehypePreserveImageSourceMeta,
   [rehypeSanitize, CHAT_MARKDOWN_SANITIZE_SCHEMA],

From 2c830e88638028f45b922295e222e83723619675 Mon Sep 17 00:00:00 2001
From: Yash Singh <saiansh2525@gmail.com>
Date: Wed, 7 Oct 2026 07:02:30 -0500
Subject: [PATCH 06/21] fix(web): keep thread search messages stable between
 matches

---
 .../src/components/chat/MessagesTimeline.tsx  |  93 +----------
 .../components/chat/useThreadFind.test.tsx    | 109 ++++++++++++-
 apps/web/src/components/chat/useThreadFind.ts |  44 ++++-
 .../chat/useThreadFindNavigation.test.tsx     | 154 ++++++++++++++++++
 .../chat/useThreadFindNavigation.ts           | 112 +++++++++++++
 5 files changed, 418 insertions(+), 94 deletions(-)
 create mode 100644 apps/web/src/components/chat/useThreadFindNavigation.test.tsx
 create mode 100644 apps/web/src/components/chat/useThreadFindNavigation.ts

diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index aa41b57e52db..a598fd96f3fb 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -220,7 +220,7 @@ import {
   type WorkGroupScrollAnchor,
 } from "./MessagesTimeline.logic";
 import { type ThreadFindMatch } from "./threadFind";
-import { useThreadFindHighlights } from "./threadFindHighlights";
+import { useThreadFindNavigation } from "./useThreadFindNavigation";
 import { TerminalContextInlineChip } from "./TerminalContextInlineChip";
 import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";
 import { Spinner } from "../ui/spinner";
@@ -415,7 +415,6 @@ const TIMELINE_MAINTAIN_SCROLL_AT_END_SMOOTH = {
   ...TIMELINE_MAINTAIN_SCROLL_AT_END,
   animated: true,
 } as const satisfies MaintainScrollAtEndOptions;
-const FIND_MATCH_VIEW_MARGIN = 96;
 
 // ---------------------------------------------------------------------------
 // Props (public API)
@@ -1431,91 +1430,15 @@ const ConversationTimeline = memo(function ConversationTimeline({
     [listRef, registerTimeline],
   );
 
-  const activeFindMatchKey = activeFindMatch
-    ? `${findNavigationId}:${normalizedFindQuery}:${activeFindMatch.entryId}:${activeFindMatch.occurrence}`
-    : null;
-  const revealedFindMatchKeyRef = useRef<string | null>(null);
-  const [positionedFindMatchKey, setPositionedFindMatchKey] = useState<string | null>(null);
-  const revealActiveFindRange = useCallback(
-    (range: Range | null) => {
-      if (
-        !range ||
-        !activeFindMatchKey ||
-        positionedFindMatchKey !== activeFindMatchKey ||
-        revealedFindMatchKeyRef.current === activeFindMatchKey
-      )
-        return;
-
-      const codeScroller = range.startContainer.parentElement?.closest("pre");
-      if (codeScroller) {
-        const match = range.getBoundingClientRect();
-        const viewport = codeScroller.getBoundingClientRect();
-        if (match.left < viewport.left) codeScroller.scrollLeft += match.left - viewport.left - 16;
-        else if (match.right > viewport.right)
-          codeScroller.scrollLeft += match.right - viewport.right + 16;
-      }
-      const matchRect = range.getBoundingClientRect();
-      const viewportRect = timelineViewportElement?.getBoundingClientRect();
-      if (!viewportRect || matchRect.height === 0) return;
-
-      revealedFindMatchKeyRef.current = activeFindMatchKey;
-      const topBoundary = viewportRect.top + FIND_MATCH_VIEW_MARGIN;
-      const bottomBoundary =
-        viewportRect.bottom - FIND_MATCH_VIEW_MARGIN - contentInsetEndAdjustment;
-      let delta = 0;
-      if (matchRect.top < topBoundary) delta = matchRect.top - topBoundary;
-      else if (matchRect.bottom > bottomBoundary) delta = matchRect.bottom - bottomBoundary;
-      if (Math.abs(delta) < 1) return;
-
-      const currentScroll = listRef.current?.getState?.().scroll;
-      if (typeof currentScroll === "number") {
-        listRef.current?.scrollToOffset({ offset: currentScroll + delta, animated: false });
-      }
-    },
-    [
-      activeFindMatchKey,
-      positionedFindMatchKey,
-      contentInsetEndAdjustment,
-      listRef,
-      timelineViewportElement,
-    ],
-  );
-
-  const navigatedFindMatchKeyRef = useRef<string | null>(null);
-
-  const activeFindRowIndex = activeFindMatch
-    ? rows.findIndex((row) => row.id === activeFindMatch.entryId)
-    : -1;
-  useEffect(() => {
-    if (!activeFindMatchKey) {
-      navigatedFindMatchKeyRef.current = null;
-      revealedFindMatchKeyRef.current = null;
-      return;
-    }
-    if (activeFindRowIndex < 0 || navigatedFindMatchKeyRef.current === activeFindMatchKey) return;
-    let cancelled = false;
-    void listRef.current
-      ?.scrollToIndex({
-        index: activeFindRowIndex,
-        animated: false,
-        viewOffset: FIND_MATCH_VIEW_MARGIN,
-      })
-      .then(() => {
-        if (cancelled) return;
-        navigatedFindMatchKeyRef.current = activeFindMatchKey;
-        setPositionedFindMatchKey(activeFindMatchKey);
-      });
-    return () => {
-      cancelled = true;
-    };
-  }, [activeFindMatchKey, activeFindRowIndex, listRef]);
-
-  useThreadFindHighlights({
+  useThreadFindNavigation({
+    entries: timelineEntries,
     container: timelineViewportElement,
     query: normalizedFindQuery,
-    activeRowId: activeFindMatch?.entryId ?? null,
-    activeOccurrence: activeFindMatch?.occurrence ?? 0,
-    onActiveRange: revealActiveFindRange,
+    match: activeFindMatch,
+    navigationId: findNavigationId,
+    rowIndex: activeFindMatch ? rows.findIndex((row) => row.id === activeFindMatch.entryId) : -1,
+    listRef,
+    contentInsetEndAdjustment,
   });
 
   // Stable renderItem — no closure deps. Row components read shared state
diff --git a/apps/web/src/components/chat/useThreadFind.test.tsx b/apps/web/src/components/chat/useThreadFind.test.tsx
index 3fc4394d73c2..b649a8310bc8 100644
--- a/apps/web/src/components/chat/useThreadFind.test.tsx
+++ b/apps/web/src/components/chat/useThreadFind.test.tsx
@@ -3,6 +3,7 @@ import { create, type ReactTestRenderer } from "react-test-renderer";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
 import {
   EnvironmentId,
+  MessageId,
   PlanId,
   RunId,
   ThreadId,
@@ -17,6 +18,7 @@ import { requestThreadFindOpen } from "./threadFindActionBus";
 
 const queries = vi.hoisted(() => ({
   results: new Map<string, OrchestrationV2SearchThreadResult>(),
+  pending: false,
 }));
 vi.mock("~/state/orchestration", () => ({
   orchestrationEnvironment: {
@@ -29,7 +31,7 @@ vi.mock("~/state/queries", () => ({ useDebouncedValue: <T,>(value: T) => value }
 vi.mock("~/state/query", () => ({
   useEnvironmentQuery: (atom: { environmentId: EnvironmentId } | null) => ({
     data: atom === null ? null : (queries.results.get(atom.environmentId) ?? null),
-    isPending: false,
+    isPending: queries.pending,
     error: null,
     refresh: () => {},
   }),
@@ -69,11 +71,116 @@ afterEach(async () => {
   if (renderer) await act(async () => renderer?.unmount());
   renderer = undefined;
   queries.results.clear();
+  queries.pending = false;
   vi.clearAllMocks();
   vi.unstubAllGlobals();
 });
 
 describe("V2 find state", () => {
+  function messageResult(index: number, snapshotSequence = 9): OrchestrationV2SearchThreadResult {
+    return {
+      snapshotSequence,
+      totalMatches: 10,
+      activeIndex: index,
+      match: { entryId: `message:${index + 2}`, runId, occurrence: 0 },
+      items: Array.from({ length: 5 }, (_, offset) => {
+        const position = index + offset;
+        return {
+          position,
+          sourceThreadId: threadId,
+          sourceItemId: TurnItemId.make(`item:${position}`),
+          visibility: "local",
+          item: {
+            id: TurnItemId.make(`item:${position}`),
+            messageId: MessageId.make(`message:${position}`),
+            threadId,
+            runId,
+            nodeId: null,
+            providerThreadId: null,
+            providerTurnId: null,
+            nativeItemRef: null,
+            parentItemId: null,
+            ordinal: position,
+            status: "completed",
+            title: null,
+            startedAt: now,
+            completedAt: now,
+            updatedAt: now,
+            type: "assistant_message",
+            text: `COD4 progress ${position}`,
+            streaming: false,
+          },
+        };
+      }),
+    };
+  }
+
+  it("keeps nearby messages stable until the next match leaves the current window", async () => {
+    queries.results.set(a, messageResult(0));
+    await act(async () => {
+      renderer = create(<Probe environmentId={a} />);
+    });
+    await act(async () => find.open());
+    await act(async () => find.barProps.onQueryChange("COD4"));
+    const originalEntries = find.timelineProps.searchEntries;
+    for (const index of [1, 2]) {
+      queries.results.set(a, messageResult(index));
+      await act(async () => find.barProps.onNext());
+      expect(find.timelineProps.searchEntries).toBe(originalEntries);
+      expect(find.timelineProps.activeFindMatch?.entryId).toBe(`message:${index + 2}`);
+      expect(find.barProps.activeIndex).toBe(index);
+    }
+    queries.results.set(a, messageResult(3));
+    await act(async () => find.barProps.onNext());
+    expect(find.timelineProps.searchEntries?.map((entry) => entry.id)).toEqual([
+      "message:3",
+      "message:4",
+      "message:5",
+      "message:6",
+      "message:7",
+    ]);
+    const nextEntries = find.timelineProps.searchEntries;
+    queries.results.set(a, messageResult(2));
+    await act(async () => find.barProps.onPrevious());
+    expect(find.timelineProps.searchEntries).toBe(nextEntries);
+  });
+
+  it("refreshes context when the snapshot or query changes", async () => {
+    queries.results.set(a, messageResult(0));
+    await act(async () => {
+      renderer = create(<Probe environmentId={a} />);
+    });
+    await act(async () => find.open());
+    await act(async () => find.barProps.onQueryChange("COD4"));
+    const originalEntries = find.timelineProps.searchEntries;
+    queries.results.set(a, messageResult(1, 10));
+    await act(async () => find.barProps.onNext());
+    expect(find.timelineProps.searchEntries).not.toBe(originalEntries);
+    expect(find.timelineProps.searchEntries?.[0]?.id).toBe("message:1");
+    queries.results.set(a, messageResult(0, 10));
+    await act(async () => find.barProps.onQueryChange("progress"));
+    expect(find.timelineProps.searchEntries?.[0]?.id).toBe("message:0");
+  });
+
+  it("does not navigate the previous result while a new match is loading", async () => {
+    queries.results.set(a, messageResult(0));
+    await act(async () => {
+      renderer = create(<Probe environmentId={a} />);
+    });
+    await act(async () => find.open());
+    await act(async () => find.barProps.onQueryChange("COD4"));
+    queries.pending = true;
+    queries.results.delete(a);
+    await act(async () => find.barProps.onNext());
+    expect(find.timelineProps.activeFindMatch?.entryId).toBe("message:2");
+    expect(find.timelineProps.findNavigationId).toBe(0);
+    queries.pending = false;
+    queries.results.set(a, messageResult(1));
+    await act(async () => renderer?.update(<Probe environmentId={a} />));
+    expect(find.timelineProps.activeFindMatch?.entryId).toBe("message:3");
+    expect(find.timelineProps.findNavigationId).toBe(1);
+  });
+
   it("keeps search unavailable when the server does not support it", async () => {
     await act(async () => {
       renderer = create(<Probe environmentId={a} enabled={false} />);
diff --git a/apps/web/src/components/chat/useThreadFind.ts b/apps/web/src/components/chat/useThreadFind.ts
index 19dbdc845fb6..b90275f85b36 100644
--- a/apps/web/src/components/chat/useThreadFind.ts
+++ b/apps/web/src/components/chat/useThreadFind.ts
@@ -60,6 +60,7 @@ export function useThreadFind({
     isOpen ? thread : null,
     state.query,
     state.activeIndex,
+    state.navigationId,
     content,
     skills,
   );
@@ -70,15 +71,16 @@ export function useThreadFind({
       : null;
   const count = remote.data?.totalMatches ?? 0;
   const activeIndex = remote.data?.activeIndex ?? 0;
+  const searchItems = remote.data?.match ? remote.data.items : null;
   const searchEntries = useMemo(
     () =>
-      remote.data?.match
+      searchItems
         ? deriveTimelineEntriesFromVisibleTurnItems({
-            visibleTurnItems: remote.data.items,
+            visibleTurnItems: searchItems,
             optimisticMessages: [],
           })
         : null,
-    [remote.data],
+    [searchItems],
   );
   const step = (delta: number) =>
     setState((previous) => ({
@@ -111,7 +113,7 @@ export function useThreadFind({
       onCloseSearch: close,
       findQuery: isOpen && searchEntries !== null ? state.query : "",
       activeFindMatch: remote.data?.match ?? null,
-      findNavigationId: state.navigationId,
+      findNavigationId: remote.navigationId,
     },
   };
 }
@@ -121,6 +123,7 @@ function useServerResults(
   thread: ScopedThreadRef | null,
   query: string,
   index: number,
+  navigationId: number,
   content: Pick<OrchestrationV2ThreadProjection, "visibleTurnItems" | "runs"> | undefined,
   skills: readonly InlineSkill[],
 ) {
@@ -152,16 +155,41 @@ function useServerResults(
   const key = thread
     ? JSON.stringify([thread.environmentId, thread.threadId, normalizedQuery])
     : null;
-  const [previous, setPrevious] = useState({ key, data: result.data });
+  const [previous, setPrevious] = useState({
+    key,
+    response: result.data,
+    data: result.data,
+    navigationId,
+  });
   if (
     previous.key !== key ||
-    (result.data !== null && !result.isPending && previous.data !== result.data)
+    (result.data !== null &&
+      !result.isPending &&
+      (previous.response !== result.data || previous.navigationId !== navigationId))
   ) {
-    setPrevious({ key, data: result.data });
+    const response = result.data;
+    const keepContext =
+      previous.key === key &&
+      response?.match !== null &&
+      response?.snapshotSequence === previous.data?.snapshotSequence &&
+      previous.data?.items.some(
+        ({ item }) =>
+          (item.type === "user_message" || item.type === "assistant_message"
+            ? item.messageId
+            : item.id) === response?.match?.entryId,
+      );
+    const retainedItems = keepContext ? previous.data?.items : undefined;
+    setPrevious({
+      key,
+      response,
+      data: response && retainedItems ? { ...response, items: retainedItems } : response,
+      navigationId,
+    });
   }
   return {
     ...result,
-    data: key === previous.key && !result.error ? (result.data ?? previous.data) : null,
+    data: key === previous.key && !result.error ? previous.data : null,
+    navigationId: previous.navigationId,
     isPending:
       thread !== null &&
       normalizedQuery.length > 0 &&
diff --git a/apps/web/src/components/chat/useThreadFindNavigation.test.tsx b/apps/web/src/components/chat/useThreadFindNavigation.test.tsx
new file mode 100644
index 000000000000..2bf2f42f141b
--- /dev/null
+++ b/apps/web/src/components/chat/useThreadFindNavigation.test.tsx
@@ -0,0 +1,154 @@
+// @vitest-environment jsdom
+
+import type { LegendListRef } from "@legendapp/list/react";
+import { act, type ComponentProps } from "react";
+import { createRoot, type Root } from "react-dom/client";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import { useThreadFindNavigation } from "./useThreadFindNavigation";
+
+function Probe(props: Parameters<typeof useThreadFindNavigation>[0]) {
+  useThreadFindNavigation(props);
+  return null;
+}
+
+let root: Root;
+let host: HTMLDivElement;
+let container: HTMLDivElement;
+let rect: DOMRect;
+const scrollToIndex = vi.fn<LegendListRef["scrollToIndex"]>();
+const scrollToOffset = vi.fn<LegendListRef["scrollToOffset"]>();
+let props: ComponentProps<typeof Probe>;
+
+beforeEach(() => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  vi.stubGlobal("CSS", { highlights: new Map() });
+  vi.stubGlobal(
+    "Highlight",
+    class extends Set<Range> {
+      constructor(...ranges: Range[]) {
+        super(ranges);
+      }
+    },
+  );
+  rect = new DOMRect(0, 200, 40, 20);
+  Object.defineProperty(Range.prototype, "getBoundingClientRect", {
+    configurable: true,
+    value: () => rect,
+  });
+  host = document.createElement("div");
+  container = document.createElement("div");
+  container.innerHTML =
+    '<div data-timeline-row-id="message"><p data-thread-find-text>COD4 and COD4</p></div>';
+  container.getBoundingClientRect = () => new DOMRect(0, 0, 800, 600);
+  document.body.append(host, container);
+  root = createRoot(host);
+  scrollToIndex.mockResolvedValue();
+  props = {
+    container,
+    query: "COD4",
+    match: { entryId: "message", runId: null, occurrence: 0 },
+    navigationId: 0,
+    rowIndex: 0,
+    entries: [{ id: "message" }],
+    listRef: {
+      current: {
+        scrollToIndex,
+        scrollToOffset,
+        getState: () => ({ scroll: 300 }),
+      } as unknown as LegendListRef,
+    },
+    contentInsetEndAdjustment: 100,
+  };
+});
+
+afterEach(async () => {
+  await act(async () => root.unmount());
+  host.remove();
+  container.remove();
+  Reflect.deleteProperty(Range.prototype, "getBoundingClientRect");
+  vi.clearAllMocks();
+  vi.unstubAllGlobals();
+});
+
+describe("find result navigation", () => {
+  it("leaves the scroll position unchanged between already visible occurrences", async () => {
+    await act(async () => root.render(<Probe {...props} />));
+    await act(async () =>
+      root.render(
+        <Probe
+          {...props}
+          navigationId={1}
+          match={{ entryId: "message", runId: null, occurrence: 1 }}
+        />,
+      ),
+    );
+    expect(scrollToIndex).not.toHaveBeenCalled();
+    expect(scrollToOffset).not.toHaveBeenCalled();
+    const highlight = CSS.highlights.get("t3-thread-find-active");
+    const ranges = [...(highlight as unknown as Set<Range>)];
+    expect(ranges).toHaveLength(1);
+    expect(ranges[0]?.startOffset).toBe(9);
+    expect(ranges[0]?.toString()).toBe("COD4");
+  });
+
+  it("moves only far enough to reveal text below the composer", async () => {
+    await act(async () => root.render(<Probe {...props} />));
+    rect = new DOMRect(0, 450, 40, 20);
+    await act(async () =>
+      root.render(
+        <Probe
+          {...props}
+          navigationId={1}
+          match={{ entryId: "message", runId: null, occurrence: 1 }}
+        />,
+      ),
+    );
+    expect(scrollToIndex).not.toHaveBeenCalled();
+    expect(scrollToOffset).toHaveBeenCalledExactlyOnceWith({ offset: 366, animated: false });
+  });
+
+  it("moves only far enough to reveal text above the viewport margin", async () => {
+    await act(async () => root.render(<Probe {...props} />));
+    rect = new DOMRect(0, 40, 40, 20);
+    await act(async () =>
+      root.render(
+        <Probe
+          {...props}
+          navigationId={1}
+          match={{ entryId: "message", runId: null, occurrence: 1 }}
+        />,
+      ),
+    );
+    expect(scrollToIndex).not.toHaveBeenCalled();
+    expect(scrollToOffset).toHaveBeenCalledExactlyOnceWith({ offset: 244, animated: false });
+  });
+
+  it("waits for a new context window to settle before revealing an offscreen result", async () => {
+    rect = new DOMRect(0, 1800, 40, 20);
+    scrollToIndex.mockImplementationOnce(async () => {
+      rect = new DOMRect(0, 450, 40, 20);
+    });
+    await act(async () => root.render(<Probe {...props} />));
+    expect(scrollToIndex).toHaveBeenCalledTimes(1);
+    expect(scrollToOffset).toHaveBeenCalledExactlyOnceWith({ offset: 366, animated: false });
+  });
+
+  it("materializes a virtualized message before revealing its occurrence", async () => {
+    container.replaceChildren();
+    await act(async () => root.render(<Probe {...props} rowIndex={4} />));
+    expect(scrollToIndex).toHaveBeenCalledExactlyOnceWith({
+      index: 4,
+      animated: false,
+      viewOffset: 96,
+    });
+    expect(scrollToOffset).not.toHaveBeenCalled();
+    rect = new DOMRect(0, 450, 40, 20);
+    await act(async () => {
+      container.innerHTML =
+        '<div data-timeline-row-id="message"><p data-thread-find-text>COD4</p></div>';
+      await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+    });
+    expect(scrollToIndex).toHaveBeenCalledTimes(1);
+    expect(scrollToOffset).toHaveBeenCalledExactlyOnceWith({ offset: 366, animated: false });
+  });
+});
diff --git a/apps/web/src/components/chat/useThreadFindNavigation.ts b/apps/web/src/components/chat/useThreadFindNavigation.ts
new file mode 100644
index 000000000000..b4adebf7d22d
--- /dev/null
+++ b/apps/web/src/components/chat/useThreadFindNavigation.ts
@@ -0,0 +1,112 @@
+import type { LegendListRef } from "@legendapp/list/react";
+import { useCallback, useRef, useState, type RefObject } from "react";
+import type { ThreadFindMatch } from "./threadFind";
+import { useThreadFindHighlights } from "./threadFindHighlights";
+
+const FIND_MATCH_VIEW_MARGIN = 96;
+
+/** Materializes missing results and otherwise scrolls only enough to reveal the active text. */
+export function useThreadFindNavigation({
+  container,
+  query,
+  match,
+  navigationId,
+  rowIndex,
+  entries,
+  listRef,
+  contentInsetEndAdjustment,
+}: {
+  container: HTMLElement | null;
+  query: string;
+  match: ThreadFindMatch | null;
+  navigationId: number;
+  rowIndex: number;
+  entries: readonly { readonly id: string }[];
+  listRef: RefObject<LegendListRef | null>;
+  contentInsetEndAdjustment: number;
+}) {
+  const matchKey = match ? `${navigationId}:${query}:${match.entryId}:${match.occurrence}` : null;
+  const positionedMatchRef = useRef<string | null>(null);
+  const [positionedMatchKey, setPositionedMatchKey] = useState<string | null>(null);
+  const revealedMatchRef = useRef<string | null>(null);
+  const positionedEntriesRef = useRef<typeof entries | null>(null);
+  const reveal = useCallback(
+    (range: Range | null) => {
+      if (!matchKey) {
+        positionedMatchRef.current = null;
+        revealedMatchRef.current = null;
+        return;
+      }
+      if (revealedMatchRef.current === matchKey) return;
+      const materialize = () => {
+        const list = listRef.current;
+        if (rowIndex < 0 || !list || positionedMatchRef.current === matchKey) return;
+        positionedMatchRef.current = matchKey;
+        void list
+          .scrollToIndex({
+            index: rowIndex,
+            animated: false,
+            viewOffset: FIND_MATCH_VIEW_MARGIN,
+          })
+          .then(() => {
+            if (positionedMatchRef.current !== matchKey) return;
+            positionedEntriesRef.current = entries;
+            setPositionedMatchKey(matchKey);
+          });
+      };
+      if (!range) {
+        if (container) materialize();
+        return;
+      }
+
+      const codeScroller = range.startContainer.parentElement?.closest("pre");
+      if (codeScroller) {
+        const rect = range.getBoundingClientRect();
+        const viewport = codeScroller.getBoundingClientRect();
+        if (rect.left < viewport.left) codeScroller.scrollLeft += rect.left - viewport.left - 16;
+        else if (rect.right > viewport.right)
+          codeScroller.scrollLeft += rect.right - viewport.right + 16;
+      }
+      const rect = range.getBoundingClientRect();
+      const viewport = container?.getBoundingClientRect();
+      if (!viewport || rect.height === 0) return;
+      const top = viewport.top + FIND_MATCH_VIEW_MARGIN;
+      const bottom = viewport.bottom - FIND_MATCH_VIEW_MARGIN - contentInsetEndAdjustment;
+      const delta =
+        rect.top < top ? rect.top - top : rect.bottom > bottom ? rect.bottom - bottom : 0;
+      // A new list can expose DOM text before its virtual row sizes settle.
+      // Await row positioning before measuring an offscreen occurrence.
+      if (
+        Math.abs(delta) >= 1 &&
+        positionedEntriesRef.current !== entries &&
+        positionedMatchKey !== matchKey
+      ) {
+        materialize();
+        return;
+      }
+      const scroll = listRef.current?.getState?.().scroll;
+      positionedEntriesRef.current = entries;
+      revealedMatchRef.current = matchKey;
+      if (Math.abs(delta) >= 1 && typeof scroll === "number") {
+        listRef.current?.scrollToOffset({ offset: scroll + delta, animated: false });
+      }
+    },
+    [
+      container,
+      contentInsetEndAdjustment,
+      entries,
+      listRef,
+      matchKey,
+      positionedMatchKey,
+      rowIndex,
+    ],
+  );
+
+  useThreadFindHighlights({
+    container,
+    query,
+    activeRowId: match?.entryId ?? null,
+    activeOccurrence: match?.occurrence ?? 0,
+    onActiveRange: reveal,
+  });
+}

From 212f151f8c00b85608d4b1fe624dbc4c464b94b2 Mon Sep 17 00:00:00 2001
From: Yash Singh <saiansh2525@gmail.com>
Date: Wed, 7 Oct 2026 07:04:58 -0500
Subject: [PATCH 07/21] fix(shared): preserve thread links in the markdown
 pipeline

---
 apps/web/src/components/ChatMarkdown.tsx     |  1 -
 packages/shared/src/markdownPipeline.test.ts | 29 ++++++++++++++++++++
 packages/shared/src/markdownPipeline.ts      |  9 +++++-
 3 files changed, 37 insertions(+), 2 deletions(-)
 create mode 100644 packages/shared/src/markdownPipeline.test.ts

diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index 361a17f9260e..83817d4561ef 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -403,7 +403,6 @@ function orderedListGutterStyle(
   return { "--list-gutter": `${markerWidth + 2}ch` };
 }
 
-
 const GITHUB_ALERT_PRESENTATIONS: Record<
   string,
   { label: string; Icon: typeof InfoIcon; borderClassName: string; titleClassName: string }
diff --git a/packages/shared/src/markdownPipeline.test.ts b/packages/shared/src/markdownPipeline.test.ts
new file mode 100644
index 000000000000..1227e77b942f
--- /dev/null
+++ b/packages/shared/src/markdownPipeline.test.ts
@@ -0,0 +1,29 @@
+import { expect, it } from "vite-plus/test";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { CHAT_MARKDOWN_REHYPE_PLUGINS, CHAT_MARKDOWN_REMARK_PLUGINS } from "./markdownPipeline.ts";
+
+it("preserves in-app thread links through the shared Markdown sanitizer", () => {
+  const processor = unified()
+    .use(remarkParse)
+    .use(CHAT_MARKDOWN_REMARK_PLUGINS)
+    .use(remarkRehype, { allowDangerousHtml: true })
+    .use(CHAT_MARKDOWN_REHYPE_PLUGINS);
+  const tree = processor.runSync(
+    processor.parse(
+      '[Open thread](t3-thread://v1/environment/thread)\n\n<a href="javascript:alert(1)">Unsafe</a>',
+    ),
+  );
+  expect(tree.children[0]).toMatchObject({
+    tagName: "p",
+    children: [
+      {
+        tagName: "a",
+        properties: { href: "t3-thread://v1/environment/thread" },
+        children: [{ type: "text", value: "Open thread" }],
+      },
+    ],
+  });
+  expect(JSON.stringify(tree)).not.toContain("javascript:");
+});
diff --git a/packages/shared/src/markdownPipeline.ts b/packages/shared/src/markdownPipeline.ts
index f7d133f1dc6b..7317dcc5b9ff 100644
--- a/packages/shared/src/markdownPipeline.ts
+++ b/packages/shared/src/markdownPipeline.ts
@@ -12,6 +12,7 @@ import {
   remarkCodexDirectives,
 } from "./codexMarkdownDirectives.ts";
 import { isWindowsDrivePathHref } from "./markdownLinks.ts";
+import { THREAD_LINK_PROTOCOL } from "./threadLinks.ts";
 
 type MarkdownImageHastNode = {
   type?: string;
@@ -157,7 +158,13 @@ const CHAT_MARKDOWN_SANITIZE_SCHEMA = {
   },
   protocols: {
     ...defaultSchema.protocols,
-    href: [...(defaultSchema.protocols?.href ?? []), "file", "t3-citation", "t3-context"],
+    href: [
+      ...(defaultSchema.protocols?.href ?? []),
+      "file",
+      "t3-citation",
+      "t3-context",
+      THREAD_LINK_PROTOCOL,
+    ],
     src: [...(defaultSchema.protocols?.src ?? []), "file", "t3-context"],
   },
 } satisfies Parameters<typeof rehypeSanitize>[0];

From c032e8292363be9e49037e72c100282fb7419ab2 Mon Sep 17 00:00:00 2001
From: Yash Singh <saiansh2525@gmail.com>
Date: Wed, 7 Oct 2026 07:15:22 -0500
Subject: [PATCH 08/21] perf(search): reuse thread match counts during
 navigation

---
 .../src/orchestration-v2/ThreadFind.test.ts   | 32 ++++++++++++
 .../server/src/orchestration-v2/ThreadFind.ts | 51 ++++++++++++++++---
 .../src/components/chat/MessagesTimeline.tsx  |  4 +-
 .../components/chat/useThreadFind.test.tsx    | 22 ++++++++
 apps/web/src/components/chat/useThreadFind.ts |  2 +-
 5 files changed, 103 insertions(+), 8 deletions(-)

diff --git a/apps/server/src/orchestration-v2/ThreadFind.test.ts b/apps/server/src/orchestration-v2/ThreadFind.test.ts
index 916bfcc877b5..b56e066a4798 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.test.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.test.ts
@@ -17,6 +17,8 @@ import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as SqlClient from "effect/sql/SqlClient";
+import { vi } from "vite-plus/test";
+import * as ThreadFindText from "@t3tools/shared/threadFindText";
 
 import * as SqlitePersistence from "../persistence/Sqlite.ts";
 import * as ProjectionStore from "./ProjectionStore.ts";
@@ -193,6 +195,36 @@ const setup = Effect.gen(function* () {
 });
 
 describe("V2 thread find", () => {
+  it.effect("reuses match counts on navigation even for text larger than the Markdown cache", () =>
+    Effect.gen(function* () {
+      const projection = yield* setup;
+      const text = `${"large message ".repeat(2600)}needle`;
+      yield* putItems(Array.from({ length: 8 }, (_, i) => item(`large:${i}`, i + 1, text)));
+      const parse = vi.spyOn(ThreadFindText, "searchableMessageSegments");
+      try {
+        const first = yield* projection.searchThread({ threadId, query: "needle" });
+        assert.equal(first.totalMatches, 8);
+        assert.equal(parse.mock.calls.length, 8);
+        parse.mockClear();
+        const next = yield* projection.searchThread({ threadId, query: "needle", index: 4 });
+        assert.equal(next.match?.entryId, "large:4");
+        assert.equal(next.snapshotSequence, first.snapshotSequence);
+        assert.deepEqual(
+          next.items.map(({ item }) => item.id),
+          ["large:2", "large:3", "large:4", "large:5", "large:6"],
+        );
+        assert.equal(parse.mock.calls.length, 0);
+        yield* putItems([item("large:4", 5, `${text} needle`)], "changed");
+        const changed = yield* projection.searchThread({ threadId, query: "needle", index: 5 });
+        assert.equal(changed.totalMatches, 9);
+        assert.deepEqual(changed.match, { entryId: "large:4", runId, occurrence: 1 });
+        assert.equal(parse.mock.calls.length, 8);
+      } finally {
+        parse.mockRestore();
+      }
+    }).pipe(Effect.provide(layerTest)),
+  );
+
   it.effect("searches visible rendered messages and plans in canonical item order", () =>
     Effect.gen(function* () {
       const projection = yield* setup;
diff --git a/apps/server/src/orchestration-v2/ThreadFind.ts b/apps/server/src/orchestration-v2/ThreadFind.ts
index 8367521a4c0f..e72ff99c82fa 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.ts
@@ -146,6 +146,18 @@ function resultFor(
 ): OrchestrationV2SearchThreadResult {
   const selected = selectMatch(docs, requestedIndex);
   const index = selected.document === null ? -1 : docs.indexOf(selected.document);
+  return resultForSelection(
+    selected,
+    index < 0 ? [] : rows.slice(Math.max(0, index - 2), index + 3),
+    snapshotSequence,
+  );
+}
+
+function resultForSelection(
+  selected: ReturnType<typeof selectMatch>,
+  items: readonly OrchestrationV2ProjectedTurnItem[],
+  snapshotSequence: number,
+): OrchestrationV2SearchThreadResult {
   return {
     snapshotSequence,
     totalMatches: selected.totalMatches,
@@ -158,7 +170,7 @@ function resultFor(
             runId: selected.document.runId,
             occurrence: selected.occurrence,
           },
-    items: index < 0 ? [] : rows.slice(Math.max(0, index - 2), index + 3),
+    items,
   };
 }
 
@@ -218,8 +230,12 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
     timeToLive: "1 minute",
     lookup: (key: TextKey) => Effect.sync(() => parseText(key)),
   });
+  // Retain counts and item references, never message bodies. Navigation checks
+  // the current revision in its transaction and loads only five context items.
+  const scans = new Map<string, { sequence: number; documents: readonly FindDocument[] }>();
   const snapshot = Effect.fn("ThreadFind.snapshot")(
-    function* (threadId: ThreadId) {
+    function* (input: OrchestrationV2SearchThreadInput) {
+      const { threadId } = input;
       const active = yield* sql<{ cwd: string | null }>`
       SELECT COALESCE(json_extract(t.payload_json, '$.worktreePath'), p.workspace_root) AS cwd
       FROM orchestration_v2_projection_threads t JOIN projection_projects p ON p.project_id = t.project_id
@@ -235,6 +251,19 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
       WHERE application_event_version = 2 AND aggregate_kind = 'thread'
         AND stream_id IN (SELECT value FROM json_each(${sources}))
     `;
+      const cwd = active[0].cwd ?? undefined;
+      const sequence = revision[0]?.sequence ?? 0;
+      const cacheKey = JSON.stringify([threadId, cwd, input.query, input.skills ?? []]);
+      const cached = scans.get(cacheKey);
+      if (cached?.sequence === sequence) {
+        const selected = selectMatch(cached.documents, input.index ?? 0);
+        const index = selected.document === null ? -1 : cached.documents.indexOf(selected.document);
+        const context = index < 0 ? [] : cached.documents.slice(Math.max(0, index - 2), index + 3);
+        const items = yield* load(threadId, context);
+        scans.delete(cacheKey);
+        scans.set(cacheKey, cached);
+        return { result: resultForSelection(selected, items, sequence) };
+      }
       const candidates = index
         .map((row, position) => ({ ...row, position }))
         .filter((row) =>
@@ -246,13 +275,15 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
       for (let start = 0; start < candidates.length; start += 128) {
         items.push(...(yield* load(threadId, candidates.slice(start, start + 128))));
       }
-      return { items, cwd: active[0].cwd ?? undefined, sequence: revision[0]?.sequence ?? 0 };
+      return { items, cwd, sequence, cacheKey };
     },
     sql.withTransaction,
-    (effect, threadId) =>
+    (effect, input) =>
       effect.pipe(
         Effect.mapError((cause) =>
-          isSnapshotError(cause) ? cause : new ProjectionStoreReadError({ threadId, cause }),
+          isSnapshotError(cause)
+            ? cause
+            : new ProjectionStoreReadError({ threadId: input.threadId, cause }),
         ),
       ),
   );
@@ -261,7 +292,9 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
   ) {
     // Release the SQLite connection before parsing. All rows and their revision
     // come from one snapshot, including inherited fork history.
-    const { items, cwd, sequence } = yield* snapshot(input.threadId);
+    const data = yield* snapshot(input);
+    if (data.result) return data.result;
+    const { items, cwd, sequence, cacheKey } = data;
     const rows = searchableRows(items);
     const skills = input.skills ?? [];
     const documents: FindDocument[] = [];
@@ -272,6 +305,12 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
       documents.push(documentFor(row, countSegments(segments, input.query)));
       yield* Effect.yieldNow;
     }
+    scans.delete(cacheKey);
+    scans.set(cacheKey, { sequence, documents });
+    if (scans.size > 8) {
+      const oldest = scans.keys().next().value;
+      if (oldest !== undefined) scans.delete(oldest);
+    }
     return resultFor(rows, documents, input.index ?? 0, sequence);
   });
 });
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index a598fd96f3fb..fdc8c34b2bba 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -1500,7 +1500,9 @@ const ConversationTimeline = memo(function ConversationTimeline({
               getItemType={getItemType}
               renderItem={renderItem}
               estimatedItemSize={90}
-              initialScrollAtEnd={citationRequest === null && rememberedPosition?.atEnd !== false}
+              initialScrollAtEnd={
+                !findActive && citationRequest === null && rememberedPosition?.atEnd !== false
+              }
               // Legend needs a data refresh to mount new pins without a scroll event.
               dataVersion={readyCitationRequest?.key ?? listIdentityKey}
               {...(alwaysRender ? { alwaysRender } : {})}
diff --git a/apps/web/src/components/chat/useThreadFind.test.tsx b/apps/web/src/components/chat/useThreadFind.test.tsx
index b649a8310bc8..6641078a586f 100644
--- a/apps/web/src/components/chat/useThreadFind.test.tsx
+++ b/apps/web/src/components/chat/useThreadFind.test.tsx
@@ -174,6 +174,9 @@ describe("V2 find state", () => {
     await act(async () => find.barProps.onNext());
     expect(find.timelineProps.activeFindMatch?.entryId).toBe("message:2");
     expect(find.timelineProps.findNavigationId).toBe(0);
+    expect(find.barProps.status).toBeNull();
+    expect(find.barProps.activeIndex).toBe(0);
+    expect(find.barProps.matchCount).toBe(10);
     queries.pending = false;
     queries.results.set(a, messageResult(1));
     await act(async () => renderer?.update(<Probe environmentId={a} />));
@@ -181,6 +184,25 @@ describe("V2 find state", () => {
     expect(find.timelineProps.findNavigationId).toBe(1);
   });
 
+  it("shows Searching only when the query has no result yet", async () => {
+    queries.pending = true;
+    await act(async () => {
+      renderer = create(<Probe environmentId={a} />);
+    });
+    await act(async () => find.open());
+    await act(async () => find.barProps.onQueryChange("COD4"));
+    expect(find.barProps.status).toBe("loading");
+    queries.pending = false;
+    queries.results.set(a, messageResult(0));
+    await act(async () => renderer?.update(<Probe environmentId={a} />));
+    expect(find.barProps.status).toBeNull();
+    queries.pending = true;
+    queries.results.delete(a);
+    await act(async () => find.barProps.onQueryChange("different query"));
+    expect(find.barProps.status).toBe("loading");
+    expect(find.barProps.matchCount).toBe(0);
+  });
+
   it("keeps search unavailable when the server does not support it", async () => {
     await act(async () => {
       renderer = create(<Probe environmentId={a} enabled={false} />);
diff --git a/apps/web/src/components/chat/useThreadFind.ts b/apps/web/src/components/chat/useThreadFind.ts
index b90275f85b36..1c6041642134 100644
--- a/apps/web/src/components/chat/useThreadFind.ts
+++ b/apps/web/src/components/chat/useThreadFind.ts
@@ -66,7 +66,7 @@ export function useThreadFind({
   );
   const status: "loading" | "error" | null = remote.error
     ? "error"
-    : remote.isPending
+    : remote.isPending && remote.data === null
       ? "loading"
       : null;
   const count = remote.data?.totalMatches ?? 0;

From 1e5accb9510bf45ecfc0cc86f19249eb2d796557 Mon Sep 17 00:00:00 2001
From: Yash Singh <saiansh2525@gmail.com>
Date: Wed, 7 Oct 2026 07:21:13 -0500
Subject: [PATCH 09/21] fix(search): wait for the timeline before positioning
 results

---
 .../server/src/orchestration-v2/ThreadFind.ts | 19 +++++++++++++++++--
 .../src/components/chat/MessagesTimeline.tsx  |  8 +++++++-
 .../chat/useThreadFindNavigation.test.tsx     | 13 +++++++++++++
 .../chat/useThreadFindNavigation.ts           |  4 ++++
 4 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/apps/server/src/orchestration-v2/ThreadFind.ts b/apps/server/src/orchestration-v2/ThreadFind.ts
index e72ff99c82fa..face113a2a2a 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.ts
@@ -1,7 +1,7 @@
 import {
   OrchestrationV2TurnItemJson,
   type OrchestrationV2ProjectedTurnItem,
-  type OrchestrationV2SearchThreadInput,
+  OrchestrationV2SearchThreadInput,
   type OrchestrationV2SearchThreadResult,
   type OrchestrationV2TurnItem,
   ThreadId,
@@ -184,6 +184,16 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
   >,
 ) {
   const sql = yield* SqlClient.SqlClient;
+  const encodeCacheKey = Schema.encodeEffect(
+    Schema.fromJsonString(
+      Schema.Struct({
+        threadId: ThreadId,
+        cwd: Schema.optional(Schema.String),
+        query: Schema.String,
+        skills: OrchestrationV2SearchThreadInput.fields.skills,
+      }),
+    ),
+  );
   const encodeThreadIds = Schema.encodeEffect(Schema.fromJsonString(Schema.Array(ThreadId)));
   const encodeSources = Schema.encodeEffect(
     Schema.fromJsonString(Schema.Array(Schema.Struct({ threadId: ThreadId, id: TurnItemId }))),
@@ -253,7 +263,12 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
     `;
       const cwd = active[0].cwd ?? undefined;
       const sequence = revision[0]?.sequence ?? 0;
-      const cacheKey = JSON.stringify([threadId, cwd, input.query, input.skills ?? []]);
+      const cacheKey = yield* encodeCacheKey({
+        threadId,
+        cwd,
+        query: input.query,
+        skills: input.skills ?? [],
+      });
       const cached = scans.get(cacheKey);
       if (cached?.sequence === sequence) {
         const selected = selectMatch(cached.documents, input.index ?? 0);
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index fdc8c34b2bba..2ab94faa6f94 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -1080,6 +1080,11 @@ const ConversationTimeline = memo(function ConversationTimeline({
     onExpandTurn: expandCitedRun,
     onManualNavigation,
   });
+  const [findListReady, setFindListReady] = useState(false);
+  const handleListLoad = useCallback(() => {
+    onCitationListLoad();
+    setFindListReady(true);
+  }, [onCitationListLoad]);
   const [minimapHasPersistentGutter, setMinimapHasPersistentGutter] = useState(false);
   const alwaysRender = citationAlwaysRender ?? restoringAlwaysRender;
   const [minimapHitStripWidth, setMinimapHitStripWidth] = useState(0);
@@ -1431,6 +1436,7 @@ const ConversationTimeline = memo(function ConversationTimeline({
   );
 
   useThreadFindNavigation({
+    listReady: findListReady,
     entries: timelineEntries,
     container: timelineViewportElement,
     query: normalizedFindQuery,
@@ -1506,7 +1512,7 @@ const ConversationTimeline = memo(function ConversationTimeline({
               // Legend needs a data refresh to mount new pins without a scroll event.
               dataVersion={readyCitationRequest?.key ?? listIdentityKey}
               {...(alwaysRender ? { alwaysRender } : {})}
-              onLoad={onCitationListLoad}
+              onLoad={handleListLoad}
               {...(anchoredEndSpace ? { anchoredEndSpace } : {})}
               contentInsetEndAdjustment={anchoredEndSpace ? contentInsetEndAdjustment : 0}
               maintainScrollAtEnd={
diff --git a/apps/web/src/components/chat/useThreadFindNavigation.test.tsx b/apps/web/src/components/chat/useThreadFindNavigation.test.tsx
index 2bf2f42f141b..235dc8f6d137 100644
--- a/apps/web/src/components/chat/useThreadFindNavigation.test.tsx
+++ b/apps/web/src/components/chat/useThreadFindNavigation.test.tsx
@@ -58,6 +58,7 @@ beforeEach(() => {
       } as unknown as LegendListRef,
     },
     contentInsetEndAdjustment: 100,
+    listReady: true,
   };
 });
 
@@ -71,6 +72,18 @@ afterEach(async () => {
 });
 
 describe("find result navigation", () => {
+  it("waits for list bootstrap before positioning the first result", async () => {
+    rect = new DOMRect(0, 1800, 40, 20);
+    await act(async () => root.render(<Probe {...props} listReady={false} />));
+    expect(scrollToIndex).not.toHaveBeenCalled();
+    expect(scrollToOffset).not.toHaveBeenCalled();
+    scrollToIndex.mockImplementationOnce(async () => {
+      rect = new DOMRect(0, 200, 40, 20);
+    });
+    await act(async () => root.render(<Probe {...props} />));
+    expect(scrollToIndex).toHaveBeenCalledTimes(1);
+    expect(scrollToOffset).not.toHaveBeenCalled();
+  });
   it("leaves the scroll position unchanged between already visible occurrences", async () => {
     await act(async () => root.render(<Probe {...props} />));
     await act(async () =>
diff --git a/apps/web/src/components/chat/useThreadFindNavigation.ts b/apps/web/src/components/chat/useThreadFindNavigation.ts
index b4adebf7d22d..3d8ce63e89f6 100644
--- a/apps/web/src/components/chat/useThreadFindNavigation.ts
+++ b/apps/web/src/components/chat/useThreadFindNavigation.ts
@@ -15,6 +15,7 @@ export function useThreadFindNavigation({
   entries,
   listRef,
   contentInsetEndAdjustment,
+  listReady,
 }: {
   container: HTMLElement | null;
   query: string;
@@ -24,6 +25,7 @@ export function useThreadFindNavigation({
   entries: readonly { readonly id: string }[];
   listRef: RefObject<LegendListRef | null>;
   contentInsetEndAdjustment: number;
+  listReady: boolean;
 }) {
   const matchKey = match ? `${navigationId}:${query}:${match.entryId}:${match.occurrence}` : null;
   const positionedMatchRef = useRef<string | null>(null);
@@ -38,6 +40,7 @@ export function useThreadFindNavigation({
         return;
       }
       if (revealedMatchRef.current === matchKey) return;
+      if (!listReady) return;
       const materialize = () => {
         const list = listRef.current;
         if (rowIndex < 0 || !list || positionedMatchRef.current === matchKey) return;
@@ -96,6 +99,7 @@ export function useThreadFindNavigation({
       contentInsetEndAdjustment,
       entries,
       listRef,
+      listReady,
       matchKey,
       positionedMatchKey,
       rowIndex,

From 0ec7e3e9891e4d6f4bad25fb8e858d4735afe723 Mon Sep 17 00:00:00 2001
From: Yash Singh <saiansh2525@gmail.com>
Date: Wed, 7 Oct 2026 07:47:22 -0500
Subject: [PATCH 10/21] fix(search): navigate the conversation from the current
 reading position

---
 .../src/orchestration-v2/ThreadFind.test.ts   |  46 ++++--
 .../server/src/orchestration-v2/ThreadFind.ts |  47 +++---
 .../src/components/chat/MessagesTimeline.tsx  | 150 ++++++++----------
 apps/web/src/components/chat/threadFind.ts    |   5 +-
 .../components/chat/threadFindHighlights.ts   |   2 +-
 .../chat/threadFindPosition.test.ts           |  60 +++++++
 .../src/components/chat/threadFindPosition.ts |  24 +++
 .../components/chat/useThreadFind.test.tsx    | 143 ++++-------------
 apps/web/src/components/chat/useThreadFind.ts |  65 ++++----
 .../chat/useThreadFindNavigation.test.tsx     |  24 +++
 .../chat/useThreadFindNavigation.ts           |  34 +++-
 packages/contracts/src/orchestrationV2.ts     |   6 +-
 12 files changed, 327 insertions(+), 279 deletions(-)
 create mode 100644 apps/web/src/components/chat/threadFindPosition.test.ts
 create mode 100644 apps/web/src/components/chat/threadFindPosition.ts

diff --git a/apps/server/src/orchestration-v2/ThreadFind.test.ts b/apps/server/src/orchestration-v2/ThreadFind.test.ts
index b56e066a4798..bb28b5cb08dd 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.test.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.test.ts
@@ -209,10 +209,6 @@ describe("V2 thread find", () => {
         const next = yield* projection.searchThread({ threadId, query: "needle", index: 4 });
         assert.equal(next.match?.entryId, "large:4");
         assert.equal(next.snapshotSequence, first.snapshotSequence);
-        assert.deepEqual(
-          next.items.map(({ item }) => item.id),
-          ["large:2", "large:3", "large:4", "large:5", "large:6"],
-        );
         assert.equal(parse.mock.calls.length, 0);
         yield* putItems([item("large:4", 5, `${text} needle`)], "changed");
         const changed = yield* projection.searchThread({ threadId, query: "needle", index: 5 });
@@ -324,7 +320,37 @@ describe("V2 thread find", () => {
     }).pipe(Effect.provide(layerTest)),
   );
 
-  it.effect("returns only nearby rows for a match beyond the recent history window", () =>
+  it.effect("starts at the reading position and wraps when no later match exists", () =>
+    Effect.gen(function* () {
+      const projection = yield* setup;
+      yield* putItems([
+        item("first", 1, "needle"),
+        item("reading", 2, "needle above, needle below"),
+        item("between", 3, "nothing"),
+        item("last", 4, "needle"),
+        item("end", 5, "nothing"),
+      ]);
+      const from = (entryId: string, occurrence = 0) =>
+        projection.searchThread({ threadId, query: "needle", start: { entryId, occurrence } });
+      assert.equal((yield* from("reading")).activeIndex, 1);
+      const below = yield* from("reading", 1);
+      assert.equal(below.activeIndex, 2);
+      assert.equal(below.match?.occurrence, 1);
+      assert.equal((yield* from("between")).match?.entryId, "last");
+      assert.equal((yield* from("reading", 2)).activeIndex, 3);
+      assert.equal((yield* from("end")).match?.entryId, "first");
+      assert.equal((yield* from("missing")).activeIndex, 0);
+      const explicit = yield* projection.searchThread({
+        threadId,
+        query: "needle",
+        start: { entryId: "last", occurrence: 0 },
+        index: 1,
+      });
+      assert.equal(explicit.match?.entryId, "reading");
+    }).pipe(Effect.provide(layerTest)),
+  );
+
+  it.effect("finds matches beyond the recent history window", () =>
     Effect.gen(function* () {
       const projection = yield* setup;
       const items = Array.from({ length: 520 }, (_, i) =>
@@ -336,12 +362,6 @@ describe("V2 thread find", () => {
       assert.equal(first.totalMatches, 2);
       assert.equal(first.match?.entryId, "message:8");
       assert.equal(last.match?.entryId, "message:510");
-      assert.lengthOf(first.items, 5);
-      assert.lengthOf(last.items, 5);
-      assert.deepEqual(
-        last.items.map((row) => row.item.id),
-        ["message:508", "message:509", "message:510", "message:511", "message:512"],
-      );
     }).pipe(Effect.provide(layerTest)),
   );
 
@@ -405,7 +425,7 @@ describe("V2 thread find", () => {
         yield* commit([event]);
         const result = yield* projection.searchThread({ threadId, query: "needle" });
         assert.equal(result.totalMatches, 0);
-        assert.deepEqual(result.items, []);
+        assert.isNull(result.match);
       }).pipe(Effect.provide(layerTest)),
   );
 
@@ -443,8 +463,6 @@ describe("V2 thread find", () => {
         const inherited = yield* projection.searchThread({ threadId, query: "needle" });
         assert.equal(inherited.totalMatches, 2);
         assert.equal(inherited.match?.entryId, "inherited");
-        assert.equal(inherited.items[0]?.visibility, "inherited");
-        assert.equal(inherited.items[0]?.sourceThreadId, parent);
         assert.equal(
           (yield* projection.searchThread({ threadId, query: "needle", index: 1 })).match?.entryId,
           "local",
diff --git a/apps/server/src/orchestration-v2/ThreadFind.ts b/apps/server/src/orchestration-v2/ThreadFind.ts
index face113a2a2a..6c64136edc6d 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.ts
@@ -110,8 +110,21 @@ function countSegments(segments: readonly string[], query: string) {
   return segments.reduce((sum, text) => sum + countThreadSearchOccurrences(text, query), 0);
 }
 
-function selectMatch(documents: readonly FindDocument[], requestedIndex: number) {
+function selectMatch(
+  documents: readonly FindDocument[],
+  input: Pick<OrchestrationV2SearchThreadInput, "index" | "start">,
+) {
   const totalMatches = documents.reduce((sum, doc) => sum + doc.count, 0);
+  let requestedIndex = input.index ?? 0;
+  if (input.index === undefined && input.start) {
+    const startIndex = documents.findIndex((doc) => doc.entryId === input.start?.entryId);
+    if (startIndex >= 0) {
+      requestedIndex =
+        documents.slice(0, startIndex).reduce((sum, doc) => sum + doc.count, 0) +
+        Math.min(input.start.occurrence, documents[startIndex]!.count);
+      if (requestedIndex >= totalMatches) requestedIndex = 0;
+    }
+  }
   const activeIndex = Math.min(requestedIndex, Math.max(0, totalMatches - 1));
   let occurrence = activeIndex;
   for (const document of documents) {
@@ -121,7 +134,7 @@ function selectMatch(documents: readonly FindDocument[], requestedIndex: number)
   return { totalMatches, activeIndex, document: null, occurrence: 0 };
 }
 
-/** The memory projection uses the same match ordering and bounded context as SQLite. */
+/** The memory projection uses the same match ordering as SQLite. */
 export function findProjectedThreadItems(
   items: readonly OrchestrationV2ProjectedTurnItem[],
   input: OrchestrationV2SearchThreadInput,
@@ -135,27 +148,11 @@ export function findProjectedThreadItems(
       countSegments(parseText(textKey(row.item, cwd, input.skills ?? [])), input.query),
     ),
   );
-  return resultFor(rows, docs, input.index ?? 0, snapshotSequence);
-}
-
-function resultFor(
-  rows: readonly OrchestrationV2ProjectedTurnItem[],
-  docs: readonly FindDocument[],
-  requestedIndex: number,
-  snapshotSequence: number,
-): OrchestrationV2SearchThreadResult {
-  const selected = selectMatch(docs, requestedIndex);
-  const index = selected.document === null ? -1 : docs.indexOf(selected.document);
-  return resultForSelection(
-    selected,
-    index < 0 ? [] : rows.slice(Math.max(0, index - 2), index + 3),
-    snapshotSequence,
-  );
+  return resultForSelection(selectMatch(docs, input), snapshotSequence);
 }
 
 function resultForSelection(
   selected: ReturnType<typeof selectMatch>,
-  items: readonly OrchestrationV2ProjectedTurnItem[],
   snapshotSequence: number,
 ): OrchestrationV2SearchThreadResult {
   return {
@@ -170,7 +167,6 @@ function resultForSelection(
             runId: selected.document.runId,
             occurrence: selected.occurrence,
           },
-    items,
   };
 }
 
@@ -241,7 +237,7 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
     lookup: (key: TextKey) => Effect.sync(() => parseText(key)),
   });
   // Retain counts and item references, never message bodies. Navigation checks
-  // the current revision in its transaction and loads only five context items.
+  // the current revision in its transaction without reloading message payloads.
   const scans = new Map<string, { sequence: number; documents: readonly FindDocument[] }>();
   const snapshot = Effect.fn("ThreadFind.snapshot")(
     function* (input: OrchestrationV2SearchThreadInput) {
@@ -271,13 +267,10 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
       });
       const cached = scans.get(cacheKey);
       if (cached?.sequence === sequence) {
-        const selected = selectMatch(cached.documents, input.index ?? 0);
-        const index = selected.document === null ? -1 : cached.documents.indexOf(selected.document);
-        const context = index < 0 ? [] : cached.documents.slice(Math.max(0, index - 2), index + 3);
-        const items = yield* load(threadId, context);
+        const selected = selectMatch(cached.documents, input);
         scans.delete(cacheKey);
         scans.set(cacheKey, cached);
-        return { result: resultForSelection(selected, items, sequence) };
+        return { result: resultForSelection(selected, sequence) };
       }
       const candidates = index
         .map((row, position) => ({ ...row, position }))
@@ -326,6 +319,6 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
       const oldest = scans.keys().next().value;
       if (oldest !== undefined) scans.delete(oldest);
     }
-    return resultFor(rows, documents, input.index ?? 0, sequence);
+    return resultForSelection(selectMatch(documents, input), sequence);
   });
 });
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 2ab94faa6f94..b8636f87cf18 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -221,6 +221,8 @@ import {
 } from "./MessagesTimeline.logic";
 import { type ThreadFindMatch } from "./threadFind";
 import { useThreadFindNavigation } from "./useThreadFindNavigation";
+import { readThreadFindPosition } from "./threadFindPosition";
+import type { ThreadFindPositionReader } from "./threadFind";
 import { TerminalContextInlineChip } from "./TerminalContextInlineChip";
 import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";
 import { Spinner } from "../ui/spinner";
@@ -390,8 +392,6 @@ function TimelineListFooter({
     </div>
   );
 }
-const NOOP_SEARCH_LAYOUT = () => {};
-const EMPTY_FIND_DIFFS: MessagesTimelineProps["turnDiffSummaries"] = [];
 
 const EMPTY_TIMELINE_SKILLS: ReadonlyArray<Pick<ServerProviderSkill, "name" | "displayName">> = [];
 const TIMELINE_MAINTAIN_SCROLL_AT_END = {
@@ -515,8 +515,7 @@ interface MessagesTimelineProps {
   historyControls?: MessagesTimelineHistoryControls | undefined;
   /** Non-null when older turns exist beyond the loaded window. */
   loadEarlier?: CitationHistoryPage | null;
-  searchEntries?: ReadonlyArray<TimelineEntry> | null;
-  onCloseSearch?: () => void;
+  findPositionReaderRef?: React.RefObject<ThreadFindPositionReader | null>;
   findQuery?: string;
   activeFindMatch?: ThreadFindMatch | null;
   findNavigationId?: number;
@@ -527,83 +526,15 @@ interface MessagesTimelineProps {
 // ---------------------------------------------------------------------------
 
 export function MessagesTimeline(props: MessagesTimelineProps) {
-  const searchListRef = useRef<LegendListRef | null>(null);
-  const searchEntries = props.searchEntries;
-  const searching = searchEntries != null;
-  const origin = useRef<{ threadId: string; following: boolean } | null>(null);
-  const {
-    findOpen,
-    routeThreadKey: threadId,
-    liveFollowEnabled,
-    onManualNavigation,
-    onResumeLiveFollow,
-  } = props;
-  useLayoutEffect(() => {
-    if (origin.current?.threadId !== threadId) origin.current = null;
-    if (findOpen) {
-      if (!origin.current) {
-        origin.current = { threadId, following: liveFollowEnabled };
-        onManualNavigation();
-      }
-    } else if (origin.current) {
-      const following = origin.current.following;
-      origin.current = null;
-      if (following) onResumeLiveFollow?.();
-    }
-  }, [findOpen, threadId, liveFollowEnabled, onManualNavigation, onResumeLiveFollow]);
+  const { findOpen, onManualNavigation } = props;
+  useEffect(() => {
+    if (findOpen) onManualNavigation();
+  }, [findOpen, onManualNavigation]);
   return (
-    <div className="relative flex min-h-0 flex-1 flex-col">
-      <div
-        className={
-          searching ? "invisible absolute inset-0 flex flex-col" : "flex min-h-0 flex-1 flex-col"
-        }
-        inert={searching}
-      >
-        <ConversationTimeline
-          {...props}
-          canvasActive={!searching}
-          findQuery=""
-          activeFindMatch={null}
-          liveFollowEnabled={!findOpen && props.liveFollowEnabled}
-        />
-      </div>
-      {searchEntries && (
-        <>
-          <div className="flex items-center gap-3 border-b bg-background px-4 py-2 text-xs text-muted-foreground">
-            <span>Search result · nearby messages</span>
-            <Button variant="ghost" size="xs" onClick={props.onCloseSearch}>
-              Return to conversation
-            </Button>
-          </div>
-          <ConversationTimeline
-            {...props}
-            listRef={searchListRef}
-            timelineEntries={searchEntries}
-            loadEarlier={null}
-            historyControls={undefined}
-            rememberPosition={false}
-            cancelPositionRestoreRef={undefined}
-            worktreeSetup={null}
-            citationRequest={null}
-            anchorMessageId={null}
-            latestRun={null}
-            runningRunId={null}
-            turnDiffSummaries={EMPTY_FIND_DIFFS}
-            supportsConversationRollback={false}
-            isWorking={false}
-            runlessWorkActive={false}
-            activeTurnInProgress={false}
-            activeTurnStartedAt={null}
-            isPreparingWorktree={false}
-            isCompacting={false}
-            liveFollowEnabled={false}
-            onManualNavigation={NOOP_SEARCH_LAYOUT}
-            onIsAtEndChange={NOOP_SEARCH_LAYOUT}
-            onContentOverflowChange={NOOP_SEARCH_LAYOUT}
-          />
-        </>
-      )}
-    </div>
+    <ConversationTimeline
+      {...props}
+      liveFollowEnabled={!props.findOpen && props.liveFollowEnabled}
+    />
   );
 }
 
@@ -629,6 +560,7 @@ const ConversationTimeline = memo(function ConversationTimeline({
   findQuery = "",
   activeFindMatch = null,
   findNavigationId = 0,
+  findPositionReaderRef,
   latestRun,
   runningRunId = null,
   turnDiffSummaries,
@@ -867,6 +799,12 @@ const ConversationTimeline = memo(function ConversationTimeline({
   }, [latestRun]);
 
   const activeFindRunId = activeFindMatch?.runId;
+  useEffect(() => {
+    if (!activeFindRunId) return;
+    setExpandedRunIds((previous) =>
+      previous.has(activeFindRunId) ? previous : new Set(previous).add(activeFindRunId),
+    );
+  }, [activeFindRunId]);
   const visibleExpandedRunIds = useMemo(() => {
     if (!activeFindRunId || paintedExpandedRunIds.has(activeFindRunId)) {
       return paintedExpandedRunIds;
@@ -877,6 +815,12 @@ const ConversationTimeline = memo(function ConversationTimeline({
   const activeFindAttemptId = activeFindMatch
     ? timelineEntries.find((entry) => entry.id === activeFindMatch.entryId)?.attempt?.id
     : undefined;
+  useEffect(() => {
+    if (!activeFindAttemptId) return;
+    setExpandedAttemptIds((previous) =>
+      previous.has(activeFindAttemptId) ? previous : new Set(previous).add(activeFindAttemptId),
+    );
+  }, [activeFindAttemptId]);
   const visibleExpandedAttemptIds = useMemo(
     () =>
       activeFindAttemptId
@@ -1435,8 +1379,53 @@ const ConversationTimeline = memo(function ConversationTimeline({
     [listRef, registerTimeline],
   );
 
+  useLayoutEffect(() => {
+    if (!findPositionReaderRef || !timelineViewportElement) return;
+    const read: ThreadFindPositionReader = (query) =>
+      readThreadFindPosition(
+        timelineViewportElement,
+        query,
+        (rowId) => {
+          const rowIndex = rows.findIndex((row) => row.id === rowId);
+          for (const row of rows.slice(Math.max(0, rowIndex))) {
+            const entry = timelineEntries.find((entry) => {
+              if (row.kind === "turn-fold" || row.kind === "attempt-fold") {
+                const runId =
+                  entry.kind === "message"
+                    ? entry.message.runId
+                    : entry.kind === "proposed-plan"
+                      ? entry.proposedPlan.runId
+                      : null;
+                return (
+                  runId === row.runId &&
+                  (entry.kind !== "message" || entry.message.role === "assistant") &&
+                  (row.kind !== "attempt-fold" || entry.attempt?.id === row.attemptId)
+                );
+              }
+              return entry.id === (row.kind === "assistant-meta" ? row.message.id : row.id);
+            });
+            if (entry && (entry.kind === "message" || entry.kind === "proposed-plan"))
+              return entry.id;
+          }
+          return undefined;
+        },
+        contentInsetEndAdjustment,
+      );
+    findPositionReaderRef.current = read;
+    return () => {
+      if (findPositionReaderRef.current === read) findPositionReaderRef.current = null;
+    };
+  }, [
+    contentInsetEndAdjustment,
+    findPositionReaderRef,
+    rows,
+    timelineEntries,
+    timelineViewportElement,
+  ]);
+
   useThreadFindNavigation({
     listReady: findListReady,
+    historyControls,
     entries: timelineEntries,
     container: timelineViewportElement,
     query: normalizedFindQuery,
@@ -1527,6 +1516,7 @@ const ConversationTimeline = memo(function ConversationTimeline({
                     : TIMELINE_MAINTAIN_SCROLL_AT_END
               }
               maintainVisibleContentPosition={
+                findActive ||
                 citationPositioning ||
                 (restoringThreadPosition && rememberedPosition?.atEnd === false)
                   ? false
diff --git a/apps/web/src/components/chat/threadFind.ts b/apps/web/src/components/chat/threadFind.ts
index 3717bdb98fa8..dbb49848465a 100644
--- a/apps/web/src/components/chat/threadFind.ts
+++ b/apps/web/src/components/chat/threadFind.ts
@@ -1,4 +1,7 @@
-import type { RunId } from "@t3tools/contracts";
+import type { OrchestrationV2SearchThreadInput, RunId } from "@t3tools/contracts";
+
+export type ThreadFindStart = NonNullable<OrchestrationV2SearchThreadInput["start"]>;
+export type ThreadFindPositionReader = (query: string) => ThreadFindStart | undefined;
 
 /** One occurrence of the query inside a searchable timeline entry. */
 export interface ThreadFindMatch {
diff --git a/apps/web/src/components/chat/threadFindHighlights.ts b/apps/web/src/components/chat/threadFindHighlights.ts
index c899db21fe29..d5149e7eb5e7 100644
--- a/apps/web/src/components/chat/threadFindHighlights.ts
+++ b/apps/web/src/components/chat/threadFindHighlights.ts
@@ -15,7 +15,7 @@ interface ThreadFindRange {
 }
 
 /** Collects visible occurrences without modifying rendered markdown. */
-function collectThreadFindRanges(container: HTMLElement, query: string): ThreadFindRange[] {
+export function collectThreadFindRanges(container: HTMLElement, query: string): ThreadFindRange[] {
   if (query.length === 0) return [];
 
   const ranges: ThreadFindRange[] = [];
diff --git a/apps/web/src/components/chat/threadFindPosition.test.ts b/apps/web/src/components/chat/threadFindPosition.test.ts
new file mode 100644
index 000000000000..a1867e547a6f
--- /dev/null
+++ b/apps/web/src/components/chat/threadFindPosition.test.ts
@@ -0,0 +1,60 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
+import { readThreadFindPosition } from "./threadFindPosition";
+
+afterEach(() => vi.restoreAllMocks());
+beforeEach(() => {
+  Object.defineProperty(Range.prototype, "getBoundingClientRect", {
+    configurable: true,
+    writable: true,
+    value: () => new DOMRect(),
+  });
+});
+
+function viewport(text = "COD4 COD4") {
+  const container = document.createElement("div");
+  container.innerHTML = `<div data-timeline-row-id="above"><div data-thread-find-text>COD4</div></div>
+    <div data-timeline-row-id="reading"><div data-thread-find-text>${text}</div></div>`;
+  vi.spyOn(container, "getBoundingClientRect").mockReturnValue(new DOMRect(0, 100, 500, 400));
+  vi.spyOn(container.children[0]!, "getBoundingClientRect").mockReturnValue(
+    new DOMRect(0, 0, 500, 80),
+  );
+  vi.spyOn(container.children[1]!, "getBoundingClientRect").mockReturnValue(
+    new DOMRect(0, 50, 500, 300),
+  );
+  return container;
+}
+
+describe("reading position for find", () => {
+  it("skips earlier rows and occurrences above the viewport within the current message", () => {
+    const container = viewport();
+    vi.spyOn(Range.prototype, "getBoundingClientRect").mockImplementation(function (this: Range) {
+      return new DOMRect(0, this.startOffset === 0 ? 60 : 160, 40, 20);
+    });
+    expect(readThreadFindPosition(container, "COD4", (id) => id, 100)).toEqual({
+      entryId: "reading",
+      occurrence: 1,
+    });
+  });
+
+  it("starts after the current message when all its occurrences are above the viewport", () => {
+    const container = viewport();
+    vi.spyOn(Range.prototype, "getBoundingClientRect").mockReturnValue(new DOMRect(0, 60, 40, 20));
+    expect(readThreadFindPosition(container, "COD4", (id) => id, 100)).toEqual({
+      entryId: "reading",
+      occurrence: 2,
+    });
+  });
+
+  it("anchors unmatched or folded content and excludes rows hidden behind the composer", () => {
+    const container = viewport("nothing");
+    expect(readThreadFindPosition(container, "COD4", () => "folded-message", 100)).toEqual({
+      entryId: "folded-message",
+      occurrence: 0,
+    });
+    vi.spyOn(container.children[1]!, "getBoundingClientRect").mockReturnValue(
+      new DOMRect(0, 420, 500, 300),
+    );
+    expect(readThreadFindPosition(container, "COD4", (id) => id, 100)).toBeUndefined();
+  });
+});
diff --git a/apps/web/src/components/chat/threadFindPosition.ts b/apps/web/src/components/chat/threadFindPosition.ts
new file mode 100644
index 000000000000..d67f36049212
--- /dev/null
+++ b/apps/web/src/components/chat/threadFindPosition.ts
@@ -0,0 +1,24 @@
+import type { ThreadFindStart } from "./threadFind";
+import { collectThreadFindRanges } from "./threadFindHighlights";
+
+/** Anchor to the first row being read, skipping occurrences above its viewport. */
+export function readThreadFindPosition(
+  container: HTMLElement,
+  query: string,
+  resolveEntry: (rowId: string) => string | undefined,
+  contentInsetEndAdjustment: number,
+): ThreadFindStart | undefined {
+  const viewport = container.getBoundingClientRect();
+  for (const row of container.querySelectorAll<HTMLElement>("[data-timeline-row-id]")) {
+    const rect = row.getBoundingClientRect();
+    if (rect.bottom <= viewport.top || rect.top >= viewport.bottom - contentInsetEndAdjustment)
+      continue;
+    const rowId = row.dataset.timelineRowId;
+    const entryId = rowId ? resolveEntry(rowId) : undefined;
+    if (!entryId) continue;
+    const matches = collectThreadFindRanges(row, query);
+    const next = matches.find((match) => match.range.getBoundingClientRect().bottom > viewport.top);
+    return { entryId, occurrence: next?.occurrence ?? matches.length };
+  }
+  return undefined;
+}
diff --git a/apps/web/src/components/chat/useThreadFind.test.tsx b/apps/web/src/components/chat/useThreadFind.test.tsx
index 6641078a586f..a7189938b8fc 100644
--- a/apps/web/src/components/chat/useThreadFind.test.tsx
+++ b/apps/web/src/components/chat/useThreadFind.test.tsx
@@ -3,15 +3,11 @@ import { create, type ReactTestRenderer } from "react-test-renderer";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";
 import {
   EnvironmentId,
-  MessageId,
-  PlanId,
   RunId,
   ThreadId,
-  TurnItemId,
   type OrchestrationV2SearchThreadInput,
   type OrchestrationV2SearchThreadResult,
 } from "@t3tools/contracts";
-import * as DateTime from "effect/DateTime";
 import { useThreadFind } from "./useThreadFind";
 import { orchestrationEnvironment } from "~/state/orchestration";
 import { requestThreadFindOpen } from "./threadFindActionBus";
@@ -45,7 +41,6 @@ const a = EnvironmentId.make("environment:a");
 const b = EnvironmentId.make("environment:b");
 const threadId = ThreadId.make("shared-thread");
 const runId = RunId.make("run:plan");
-const now = DateTime.makeUnsafe("2026-10-01T00:00:00Z");
 function Probe({
   environmentId,
   enabled = true,
@@ -83,83 +78,40 @@ describe("V2 find state", () => {
       totalMatches: 10,
       activeIndex: index,
       match: { entryId: `message:${index + 2}`, runId, occurrence: 0 },
-      items: Array.from({ length: 5 }, (_, offset) => {
-        const position = index + offset;
-        return {
-          position,
-          sourceThreadId: threadId,
-          sourceItemId: TurnItemId.make(`item:${position}`),
-          visibility: "local",
-          item: {
-            id: TurnItemId.make(`item:${position}`),
-            messageId: MessageId.make(`message:${position}`),
-            threadId,
-            runId,
-            nodeId: null,
-            providerThreadId: null,
-            providerTurnId: null,
-            nativeItemRef: null,
-            parentItemId: null,
-            ordinal: position,
-            status: "completed",
-            title: null,
-            startedAt: now,
-            completedAt: now,
-            updatedAt: now,
-            type: "assistant_message",
-            text: `COD4 progress ${position}`,
-            streaming: false,
-          },
-        };
-      }),
     };
   }
 
-  it("keeps nearby messages stable until the next match leaves the current window", async () => {
-    queries.results.set(a, messageResult(0));
+  it("starts from the viewport and steps from the server-selected match", async () => {
+    queries.results.set(a, messageResult(4));
     await act(async () => {
       renderer = create(<Probe environmentId={a} />);
     });
     await act(async () => find.open());
-    await act(async () => find.barProps.onQueryChange("COD4"));
-    const originalEntries = find.timelineProps.searchEntries;
-    for (const index of [1, 2]) {
-      queries.results.set(a, messageResult(index));
-      await act(async () => find.barProps.onNext());
-      expect(find.timelineProps.searchEntries).toBe(originalEntries);
-      expect(find.timelineProps.activeFindMatch?.entryId).toBe(`message:${index + 2}`);
-      expect(find.barProps.activeIndex).toBe(index);
-    }
-    queries.results.set(a, messageResult(3));
-    await act(async () => find.barProps.onNext());
-    expect(find.timelineProps.searchEntries?.map((entry) => entry.id)).toEqual([
-      "message:3",
-      "message:4",
-      "message:5",
-      "message:6",
-      "message:7",
-    ]);
-    const nextEntries = find.timelineProps.searchEntries;
-    queries.results.set(a, messageResult(2));
-    await act(async () => find.barProps.onPrevious());
-    expect(find.timelineProps.searchEntries).toBe(nextEntries);
-  });
-
-  it("refreshes context when the snapshot or query changes", async () => {
-    queries.results.set(a, messageResult(0));
-    await act(async () => {
-      renderer = create(<Probe environmentId={a} />);
+    find.timelineProps.findPositionReaderRef.current = () => ({
+      entryId: "message:6",
+      occurrence: 1,
     });
-    await act(async () => find.open());
     await act(async () => find.barProps.onQueryChange("COD4"));
-    const originalEntries = find.timelineProps.searchEntries;
-    queries.results.set(a, messageResult(1, 10));
+    expect(orchestrationEnvironment.threadFind).toHaveBeenLastCalledWith({
+      environmentId: a,
+      input: {
+        threadId,
+        query: "COD4",
+        skills: [],
+        start: { entryId: "message:6", occurrence: 1 },
+      },
+    });
+    expect(find.barProps.activeIndex).toBe(4);
+    queries.results.set(a, messageResult(5));
     await act(async () => find.barProps.onNext());
-    expect(find.timelineProps.searchEntries).not.toBe(originalEntries);
-    expect(find.timelineProps.searchEntries?.[0]?.id).toBe("message:1");
-    queries.results.set(a, messageResult(0, 10));
-    await act(async () => find.barProps.onQueryChange("progress"));
-    expect(find.timelineProps.searchEntries?.[0]?.id).toBe("message:0");
+    expect(orchestrationEnvironment.threadFind).toHaveBeenLastCalledWith({
+      environmentId: a,
+      input: { threadId, query: "COD4", skills: [], index: 5 },
+    });
+    expect(find.timelineProps.activeFindMatch?.entryId).toBe("message:7");
+    queries.results.set(a, messageResult(4));
+    await act(async () => find.barProps.onPrevious());
+    expect(find.barProps.activeIndex).toBe(4);
   });
 
   it("does not navigate the previous result while a new match is loading", async () => {
@@ -212,7 +164,7 @@ describe("V2 find state", () => {
       requestThreadFindOpen();
     });
     expect(find.isOpen).toBe(false);
-    expect(find.timelineProps.searchEntries).toBeNull();
+    expect(find.timelineProps.activeFindMatch).toBeNull();
     expect(orchestrationEnvironment.threadFind).not.toHaveBeenCalled();
   });
 
@@ -228,7 +180,7 @@ describe("V2 find state", () => {
       renderer?.update(<Probe environmentId={a} enabled={false} />);
     });
     expect(find.isOpen).toBe(false);
-    expect(find.timelineProps.searchEntries).toBeNull();
+    expect(find.timelineProps.activeFindMatch).toBeNull();
     expect(find.timelineProps.findQuery).toBe("");
     expect(orchestrationEnvironment.threadFind).not.toHaveBeenCalled();
     await act(async () => {
@@ -239,40 +191,12 @@ describe("V2 find state", () => {
     expect(find.barProps.query).toBe("");
   });
 
-  it("derives a plan result with the timeline item ID and run ownership", async () => {
+  it("preserves plan item ID and run ownership for navigation", async () => {
     queries.results.set(a, {
       snapshotSequence: 9,
       totalMatches: 1,
       activeIndex: 0,
       match: { entryId: "plan-item", runId, occurrence: 0 },
-      items: [
-        {
-          position: 8,
-          sourceThreadId: threadId,
-          sourceItemId: TurnItemId.make("plan-item"),
-          visibility: "local",
-          item: {
-            id: TurnItemId.make("plan-item"),
-            threadId,
-            runId,
-            nodeId: null,
-            providerThreadId: null,
-            providerTurnId: null,
-            nativeItemRef: null,
-            parentItemId: null,
-            ordinal: 9,
-            status: "completed",
-            title: null,
-            startedAt: now,
-            completedAt: now,
-            updatedAt: now,
-            type: "proposed_plan",
-            planId: PlanId.make("plan-artifact"),
-            markdown: "# Release\nneedle",
-            streaming: false,
-          },
-        },
-      ],
     });
     await act(async () => {
       renderer = create(<Probe environmentId={a} />);
@@ -288,17 +212,10 @@ describe("V2 find state", () => {
       runId,
       occurrence: 0,
     });
-    const entry = find.timelineProps.searchEntries?.[0];
-    expect(entry?.id).toBe("plan-item");
-    expect(entry?.kind).toBe("proposed-plan");
-    if (entry?.kind === "proposed-plan") {
-      expect(entry.proposedPlan.id).toBe("plan-artifact");
-      expect(entry.proposedPlan.runId).toBe(runId);
-    }
     await act(async () => {
       find.close();
     });
-    expect(find.timelineProps.searchEntries).toBeNull();
+    expect(find.timelineProps.activeFindMatch).toBeNull();
     expect(find.timelineProps.findQuery).toBe("");
   });
 
@@ -308,14 +225,12 @@ describe("V2 find state", () => {
       totalMatches: 3,
       activeIndex: 0,
       match: null,
-      items: [],
     });
     queries.results.set(b, {
       snapshotSequence: 2,
       totalMatches: 0,
       activeIndex: 0,
       match: null,
-      items: [],
     });
     await act(async () => {
       renderer = create(<Probe environmentId={a} />);
@@ -331,7 +246,7 @@ describe("V2 find state", () => {
       renderer?.update(<Probe environmentId={b} />);
     });
     expect(find.isOpen).toBe(false);
-    expect(find.timelineProps.searchEntries).toBeNull();
+    expect(find.timelineProps.activeFindMatch).toBeNull();
     await act(async () => {
       find.open();
     });
diff --git a/apps/web/src/components/chat/useThreadFind.ts b/apps/web/src/components/chat/useThreadFind.ts
index 1c6041642134..0fa5222e19e9 100644
--- a/apps/web/src/components/chat/useThreadFind.ts
+++ b/apps/web/src/components/chat/useThreadFind.ts
@@ -2,11 +2,14 @@ import type { InlineSkill } from "@t3tools/shared/inlineSkills";
 import type { OrchestrationV2ThreadProjection, ScopedThreadRef } from "@t3tools/contracts";
 import { scopedThreadKey } from "@t3tools/client-runtime/environment";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { deriveTimelineEntriesFromVisibleTurnItems } from "~/session-logic";
 import { orchestrationEnvironment } from "~/state/orchestration";
 import { useEnvironmentQuery } from "~/state/query";
 import { useDebouncedValue } from "~/state/queries";
-import { stepThreadFindIndex } from "./threadFind";
+import {
+  stepThreadFindIndex,
+  type ThreadFindPositionReader,
+  type ThreadFindStart,
+} from "./threadFind";
 import { subscribeThreadFindOpen } from "./threadFindActionBus";
 import { toastManager } from "../ui/toast";
 
@@ -15,7 +18,8 @@ const EMPTY_SKILLS: readonly InlineSkill[] = [];
 const CLOSED_FIND = {
   threadKey: null as string | null,
   query: "",
-  activeIndex: 0,
+  activeIndex: null as number | null,
+  start: undefined as ThreadFindStart | undefined,
   focusRequestId: 0,
   navigationId: 0,
 };
@@ -32,6 +36,7 @@ export function useThreadFind({
   skills?: readonly InlineSkill[];
   content: Pick<OrchestrationV2ThreadProjection, "visibleTurnItems" | "runs"> | undefined;
 }) {
+  const findPositionReaderRef = useRef<ThreadFindPositionReader | null>(null);
   const threadKey = thread ? scopedThreadKey(thread) : null;
   const [state, setState] = useState(CLOSED_FIND);
   if (state.threadKey !== null && (!enabled || state.threadKey !== threadKey))
@@ -61,6 +66,7 @@ export function useThreadFind({
     state.query,
     state.activeIndex,
     state.navigationId,
+    state.start,
     content,
     skills,
   );
@@ -71,21 +77,10 @@ export function useThreadFind({
       : null;
   const count = remote.data?.totalMatches ?? 0;
   const activeIndex = remote.data?.activeIndex ?? 0;
-  const searchItems = remote.data?.match ? remote.data.items : null;
-  const searchEntries = useMemo(
-    () =>
-      searchItems
-        ? deriveTimelineEntriesFromVisibleTurnItems({
-            visibleTurnItems: searchItems,
-            optimisticMessages: [],
-          })
-        : null,
-    [searchItems],
-  );
   const step = (delta: number) =>
     setState((previous) => ({
       ...previous,
-      activeIndex: stepThreadFindIndex(previous.activeIndex, count, delta),
+      activeIndex: stepThreadFindIndex(previous.activeIndex ?? activeIndex, count, delta),
       navigationId: previous.navigationId + 1,
     }));
 
@@ -101,17 +96,18 @@ export function useThreadFind({
       status,
       focusRequestId: state.focusRequestId,
       onRetry: remote.refresh,
-      onQueryChange: (query: string) =>
-        setState((previous) => ({ ...previous, query, activeIndex: 0 })),
+      onQueryChange: (query: string) => {
+        const start = findPositionReaderRef.current?.(query.trim());
+        setState((previous) => ({ ...previous, query, activeIndex: null, start }));
+      },
       onNext: () => step(1),
       onPrevious: () => step(-1),
       onClose: close,
     },
     timelineProps: {
       findOpen: isOpen,
-      searchEntries,
-      onCloseSearch: close,
-      findQuery: isOpen && searchEntries !== null ? state.query : "",
+      findPositionReaderRef,
+      findQuery: isOpen && remote.data?.match ? state.query : "",
       activeFindMatch: remote.data?.match ?? null,
       findNavigationId: remote.navigationId,
     },
@@ -122,8 +118,9 @@ export function useThreadFind({
 function useServerResults(
   thread: ScopedThreadRef | null,
   query: string,
-  index: number,
+  index: number | null,
   navigationId: number,
+  start: ThreadFindStart | undefined,
   content: Pick<OrchestrationV2ThreadProjection, "visibleTurnItems" | "runs"> | undefined,
   skills: readonly InlineSkill[],
 ) {
@@ -137,7 +134,12 @@ function useServerResults(
     thread && debouncedQuery && normalizedQuery === debouncedQuery
       ? orchestrationEnvironment.threadFind({
           environmentId: thread.environmentId,
-          input: { threadId: thread.threadId, query: debouncedQuery, index, skills: skillLabels },
+          input: {
+            threadId: thread.threadId,
+            query: debouncedQuery,
+            ...(index === null ? (start ? { start } : {}) : { index }),
+            skills: skillLabels,
+          },
         })
       : null;
   const result = useEnvironmentQuery(atom);
@@ -153,11 +155,10 @@ function useServerResults(
     if (atom !== null) refresh();
   }, [atom, refresh, settledRevision]);
   const key = thread
-    ? JSON.stringify([thread.environmentId, thread.threadId, normalizedQuery])
+    ? JSON.stringify([thread.environmentId, thread.threadId, normalizedQuery, start])
     : null;
   const [previous, setPrevious] = useState({
     key,
-    response: result.data,
     data: result.data,
     navigationId,
   });
@@ -165,24 +166,12 @@ function useServerResults(
     previous.key !== key ||
     (result.data !== null &&
       !result.isPending &&
-      (previous.response !== result.data || previous.navigationId !== navigationId))
+      (previous.data !== result.data || previous.navigationId !== navigationId))
   ) {
     const response = result.data;
-    const keepContext =
-      previous.key === key &&
-      response?.match !== null &&
-      response?.snapshotSequence === previous.data?.snapshotSequence &&
-      previous.data?.items.some(
-        ({ item }) =>
-          (item.type === "user_message" || item.type === "assistant_message"
-            ? item.messageId
-            : item.id) === response?.match?.entryId,
-      );
-    const retainedItems = keepContext ? previous.data?.items : undefined;
     setPrevious({
       key,
-      response,
-      data: response && retainedItems ? { ...response, items: retainedItems } : response,
+      data: response,
       navigationId,
     });
   }
diff --git a/apps/web/src/components/chat/useThreadFindNavigation.test.tsx b/apps/web/src/components/chat/useThreadFindNavigation.test.tsx
index 235dc8f6d137..48d9a8d015ba 100644
--- a/apps/web/src/components/chat/useThreadFindNavigation.test.tsx
+++ b/apps/web/src/components/chat/useThreadFindNavigation.test.tsx
@@ -72,6 +72,30 @@ afterEach(async () => {
 });
 
 describe("find result navigation", () => {
+  it("loads history until a distant match can be revealed in the conversation", async () => {
+    const onLoadEarlier = vi.fn();
+    const historyControls = { hasMoreHistory: true, loading: false, error: null, onLoadEarlier };
+    const pending = { ...props, rowIndex: -1, entries: [{ id: "recent" }], historyControls };
+    await act(async () => root.render(<Probe {...pending} />));
+    expect(onLoadEarlier).toHaveBeenCalledTimes(1);
+    expect(scrollToIndex).not.toHaveBeenCalled();
+    await act(async () =>
+      root.render(<Probe {...pending} historyControls={{ ...historyControls, loading: true }} />),
+    );
+    expect(onLoadEarlier).toHaveBeenCalledTimes(1);
+    await act(async () =>
+      root.render(<Probe {...pending} entries={[{ id: "older" }, ...pending.entries]} />),
+    );
+    expect(onLoadEarlier).toHaveBeenCalledTimes(2);
+    rect = new DOMRect(0, 1800, 40, 20);
+    scrollToIndex.mockImplementationOnce(async () => {
+      rect = new DOMRect(0, 200, 40, 20);
+    });
+    await act(async () => root.render(<Probe {...props} historyControls={historyControls} />));
+    expect(onLoadEarlier).toHaveBeenCalledTimes(2);
+    expect(scrollToIndex).toHaveBeenCalledTimes(1);
+  });
+
   it("waits for list bootstrap before positioning the first result", async () => {
     rect = new DOMRect(0, 1800, 40, 20);
     await act(async () => root.render(<Probe {...props} listReady={false} />));
diff --git a/apps/web/src/components/chat/useThreadFindNavigation.ts b/apps/web/src/components/chat/useThreadFindNavigation.ts
index 3d8ce63e89f6..8fb72291d481 100644
--- a/apps/web/src/components/chat/useThreadFindNavigation.ts
+++ b/apps/web/src/components/chat/useThreadFindNavigation.ts
@@ -1,5 +1,5 @@
 import type { LegendListRef } from "@legendapp/list/react";
-import { useCallback, useRef, useState, type RefObject } from "react";
+import { useCallback, useEffect, useRef, useState, type RefObject } from "react";
 import type { ThreadFindMatch } from "./threadFind";
 import { useThreadFindHighlights } from "./threadFindHighlights";
 
@@ -16,6 +16,7 @@ export function useThreadFindNavigation({
   listRef,
   contentInsetEndAdjustment,
   listReady,
+  historyControls,
 }: {
   container: HTMLElement | null;
   query: string;
@@ -26,12 +27,41 @@ export function useThreadFindNavigation({
   listRef: RefObject<LegendListRef | null>;
   contentInsetEndAdjustment: number;
   listReady: boolean;
+  historyControls?:
+    | {
+        readonly hasMoreHistory: boolean;
+        readonly loading: boolean;
+        readonly error: string | null;
+        readonly onLoadEarlier: () => void;
+      }
+    | undefined;
 }) {
   const matchKey = match ? `${navigationId}:${query}:${match.entryId}:${match.occurrence}` : null;
   const positionedMatchRef = useRef<string | null>(null);
   const [positionedMatchKey, setPositionedMatchKey] = useState<string | null>(null);
   const revealedMatchRef = useRef<string | null>(null);
   const positionedEntriesRef = useRef<typeof entries | null>(null);
+  const requestedPagesRef = useRef<{ key: string | null; pages: Set<string> }>({
+    key: null,
+    pages: new Set(),
+  });
+  useEffect(() => {
+    if (requestedPagesRef.current.key !== matchKey)
+      requestedPagesRef.current = { key: matchKey, pages: new Set() };
+    if (
+      !match ||
+      !listReady ||
+      rowIndex >= 0 ||
+      entries.some((entry) => entry.id === match.entryId)
+    )
+      return;
+    if (!historyControls?.hasMoreHistory || historyControls.loading || historyControls.error)
+      return;
+    const cursor = entries[0]?.id ?? "first";
+    if (requestedPagesRef.current.pages.has(cursor)) return;
+    requestedPagesRef.current.pages.add(cursor);
+    historyControls.onLoadEarlier();
+  }, [entries, historyControls, listReady, match, matchKey, rowIndex]);
   const reveal = useCallback(
     (range: Range | null) => {
       if (!matchKey) {
@@ -40,7 +70,7 @@ export function useThreadFindNavigation({
         return;
       }
       if (revealedMatchRef.current === matchKey) return;
-      if (!listReady) return;
+      if (!listReady || rowIndex < 0) return;
       const materialize = () => {
         const list = listRef.current;
         if (rowIndex < 0 || !list || positionedMatchRef.current === matchKey) return;
diff --git a/packages/contracts/src/orchestrationV2.ts b/packages/contracts/src/orchestrationV2.ts
index c9884de0d6f9..ea7dbafdac45 100644
--- a/packages/contracts/src/orchestrationV2.ts
+++ b/packages/contracts/src/orchestrationV2.ts
@@ -3498,6 +3498,10 @@ export const OrchestrationV2SearchThreadInput = Schema.Struct({
   ),
   query: TrimmedNonEmptyString.check(Schema.isMaxLength(200)),
   index: Schema.optionalKey(NonNegativeInt),
+  // Used only before an explicit match index is selected.
+  start: Schema.optionalKey(
+    Schema.Struct({ entryId: TrimmedNonEmptyString, occurrence: NonNegativeInt }),
+  ),
 });
 export type OrchestrationV2SearchThreadInput = typeof OrchestrationV2SearchThreadInput.Type;
 
@@ -3511,8 +3515,6 @@ export const OrchestrationV2SearchThreadResult = Schema.Struct({
   totalMatches: NonNegativeInt,
   activeIndex: NonNegativeInt,
   match: Schema.NullOr(OrchestrationV2ThreadFindMatch),
-  // Search context is separate from the client's contiguous history pages.
-  items: Schema.Array(OrchestrationV2ProjectedTurnItem),
 });
 export type OrchestrationV2SearchThreadResult = typeof OrchestrationV2SearchThreadResult.Type;
 

From 4414e914e03a3b031173eed46eb230ef0a505854 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 10:24:10 -0700
Subject: [PATCH 11/21] fix(shared): keep isRelativeFilePath module-private

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 packages/shared/src/markdownLinks.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/shared/src/markdownLinks.ts b/packages/shared/src/markdownLinks.ts
index 4055ccb08967..875f764d448d 100644
--- a/packages/shared/src/markdownLinks.ts
+++ b/packages/shared/src/markdownLinks.ts
@@ -252,7 +252,7 @@ export function isMarkdownFileLinkLabel(label: string, href: string): boolean {
   return destinationPath === labelPath || destinationPath.endsWith(`/${labelPath}`);
 }
 
-export function isRelativeFilePath(path: string): boolean {
+function isRelativeFilePath(path: string): boolean {
   return (
     RELATIVE_PATH_PREFIX_PATTERN.test(path) ||
     (!path.startsWith("/") && !isWindowsAbsolutePath(path))

From 0fdcad218a030b5dfe9fe542108296d994b49368 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 10:35:26 -0700
Subject: [PATCH 12/21] fix(search): count what code block headers and citation
 chips display

The find bar highlighted fence titles and language labels that the server
never counted, and counted citation link text the chip never shows.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 apps/web/src/components/ChatMarkdown.test.tsx |  2 ++
 apps/web/src/components/ChatMarkdown.tsx      |  5 +++-
 .../components/chat/AssistantCitationChip.tsx |  8 ++++---
 packages/shared/src/assistantCitations.ts     |  6 +++++
 packages/shared/src/threadFindText.test.ts    | 24 +++++++++++++++++++
 packages/shared/src/threadFindText.ts         |  8 +++++++
 6 files changed, 49 insertions(+), 4 deletions(-)

diff --git a/apps/web/src/components/ChatMarkdown.test.tsx b/apps/web/src/components/ChatMarkdown.test.tsx
index 9f7e0c536f90..f661c0ff6aec 100644
--- a/apps/web/src/components/ChatMarkdown.test.tsx
+++ b/apps/web/src/components/ChatMarkdown.test.tsx
@@ -1113,6 +1113,8 @@ it.each([
     count: 0,
     lineBreaks: true,
   },
+  { text: '```ts title="src/needle.ts"\nconst a = 1;\n```', query: "needle", count: 0 },
+  { text: "```weirdlang\nconst a = 1;\n```", query: "weirdlang", count: 0 },
   { text: "Use $test-t3-app now", query: "T3 App Testing", count: 1 },
   { text: "`/tmp/file.ts:42`", query: "file.ts · L42", count: 1, user: true, lineBreaks: true },
   { text: "> [!NOTE]\n> Searchable alert", query: "Searchable alert", count: 1 },
diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index 83817d4561ef..05b4b08c13a5 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -890,7 +890,10 @@ function MarkdownCodeBlock({
       data-language={language}
       data-wrap={wrapped ? "true" : "false"}
     >
-      <div className="chat-markdown-codeblock-header flex items-center justify-between gap-2 pt-1.5 pr-1.5 pb-0 pl-3 select-none">
+      <div
+        data-thread-find-ignore
+        className="chat-markdown-codeblock-header flex items-center justify-between gap-2 pt-1.5 pr-1.5 pb-0 pl-3 select-none"
+      >
         <span className="inline-flex min-w-0 items-center gap-1.5 font-mono text-2xs">
           <MarkdownCodeBlockTitleContent
             fenceTitle={fenceTitle}
diff --git a/apps/web/src/components/chat/AssistantCitationChip.tsx b/apps/web/src/components/chat/AssistantCitationChip.tsx
index e03872553a88..9f5d3a2e1e55 100644
--- a/apps/web/src/components/chat/AssistantCitationChip.tsx
+++ b/apps/web/src/components/chat/AssistantCitationChip.tsx
@@ -1,5 +1,8 @@
 import type { AssistantCitation } from "@t3tools/contracts";
-import { serializeAssistantCitation } from "@t3tools/shared/assistantCitations";
+import {
+  assistantCitationLabel,
+  serializeAssistantCitation,
+} from "@t3tools/shared/assistantCitations";
 import { Link, useNavigate } from "@tanstack/react-router";
 import { PencilIcon, QuoteIcon } from "lucide-react";
 import {
@@ -94,8 +97,7 @@ export function AssistantCitationChip({
         },
       }
     : undefined;
-  const preview = (citation.comment?.trim() || citation.text).replace(/\s+/g, " ");
-  const label = preview.length > 64 ? `${preview.slice(0, 64)}…` : preview;
+  const label = assistantCitationLabel(citation);
   const sourceLinkProps = {
     to: "/$environmentId/$threadId" as const,
     params: { environmentId: citation.environmentId, threadId: citation.threadId },
diff --git a/packages/shared/src/assistantCitations.ts b/packages/shared/src/assistantCitations.ts
index e27e35f352bb..37e34524167f 100644
--- a/packages/shared/src/assistantCitations.ts
+++ b/packages/shared/src/assistantCitations.ts
@@ -50,6 +50,12 @@ export function formatAssistantCitationHref(citation: AssistantCitation): string
   return `${CITATION_HREF_PREFIX}${path}?${query}`;
 }
 
+/** Visible chip text: the comment, else the quoted text, collapsed and capped. */
+export function assistantCitationLabel(citation: AssistantCitation): string {
+  const preview = (citation.comment?.trim() || citation.text).replace(/\s+/g, " ");
+  return preview.length > 64 ? `${preview.slice(0, 64)}…` : preview;
+}
+
 export function parseAssistantCitationHref(href: string): AssistantCitation | null {
   if (!href.startsWith(CITATION_HREF_PREFIX) || href.length > MAX_CITATION_HREF_LENGTH) {
     return null;
diff --git a/packages/shared/src/threadFindText.test.ts b/packages/shared/src/threadFindText.test.ts
index 4260207ec69c..b24b0e2c73f0 100644
--- a/packages/shared/src/threadFindText.test.ts
+++ b/packages/shared/src/threadFindText.test.ts
@@ -1,4 +1,6 @@
+import { EnvironmentId, MessageId, ThreadId } from "@t3tools/contracts";
 import { expect, it } from "vite-plus/test";
+import { serializeAssistantCitation } from "./assistantCitations.ts";
 import { searchableMessageSegments } from "./threadFindText.ts";
 
 it("excludes review attachments rendered as context chips", () => {
@@ -135,3 +137,25 @@ it("indexes skill labels in prose but leaves links and code literal", () => {
     ),
   ).toEqual(["Use T3 App Testing now.", "$test-t3-app", "$test-t3-app"]);
 });
+
+it("indexes the citation chip label instead of its link text", () => {
+  const citation = {
+    version: 1 as const,
+    environmentId: EnvironmentId.make("environment"),
+    threadId: ThreadId.make("thread"),
+    messageId: MessageId.make("message"),
+    text: "cited   needle",
+    start: 0,
+    end: 14,
+    prefix: "",
+    suffix: "",
+  };
+  const text = `Please fix ${serializeAssistantCitation(citation)} thanks`;
+  expect(searchableMessageSegments({ role: "user", text, streaming: false })).toEqual([
+    "Please fix cited needle thanks",
+  ]);
+  const commented = serializeAssistantCitation({ ...citation, comment: "my note" });
+  expect(searchableMessageSegments({ role: "user", text: commented, streaming: false })).toEqual([
+    "my note",
+  ]);
+});
diff --git a/packages/shared/src/threadFindText.ts b/packages/shared/src/threadFindText.ts
index 7e6d6e23ec30..54b779560b0e 100644
--- a/packages/shared/src/threadFindText.ts
+++ b/packages/shared/src/threadFindText.ts
@@ -22,6 +22,7 @@ import {
 } from "./markdownLinks.ts";
 import { upgradeLegacyContextMessage } from "./composerContextLegacy.ts";
 import { parseComposerContextHref } from "./composerContextReferences.ts";
+import { assistantCitationLabel, parseAssistantCitationHref } from "./assistantCitations.ts";
 import type { OrchestrationV2ConversationMessage } from "@t3tools/contracts";
 import { proposedPlanTitle, stripDisplayedPlanMarkdown } from "./proposedPlanText.ts";
 import { unified } from "unified";
@@ -135,6 +136,13 @@ function markdownThreadFindText(
       flush();
       return;
     }
+    const citation =
+      node.tagName === "a" && typeof href === "string" ? parseAssistantCitationHref(href) : null;
+    if (citation) {
+      // Matches the citation chip, which shows its label instead of the link text.
+      text += assistantCitationLabel(citation);
+      return;
+    }
     {
       let candidate: string | null = null;
       if (node.tagName === "a" && typeof href === "string") {

From 73a7859c4bc813ff3e6970f4c1326b86cf2974b1 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 10:38:29 -0700
Subject: [PATCH 13/21] fix(web): keep find results expanded while typing and
 leave Mod+F to drafts

Each keystroke cleared the active result, which collapsed folded messages,
details, and diagrams until the next response arrived. Drafts also took
over browser find to show an update-server toast. Short viewports could
scroll a match under the composer.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 apps/web/src/components/ChatView.tsx                    | 3 ++-
 apps/web/src/components/chat/MessagesTimeline.tsx       | 4 +++-
 apps/web/src/components/chat/useThreadFind.test.tsx     | 5 +++++
 apps/web/src/components/chat/useThreadFind.ts           | 2 ++
 apps/web/src/components/chat/useThreadFindNavigation.ts | 9 +++++++--
 5 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index 03d5190d0b7c..fdcff91d2af4 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -8040,7 +8040,8 @@ export default function ChatView(props: ChatViewProps) {
         return;
       }
 
-      if (command === "chat.find") {
+      // Drafts have nothing to search; leave Mod+F to the browser.
+      if (command === "chat.find" && isServerThread) {
         event.preventDefault();
         event.stopPropagation();
         openThreadFind();
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 700293d9c43f..cd0b405b96aa 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -530,6 +530,7 @@ interface MessagesTimelineProps {
   /** Non-null when older turns exist beyond the loaded window. */
   loadEarlier?: CitationHistoryPage | null;
   findPositionReaderRef?: React.RefObject<ThreadFindPositionReader | null>;
+  findExpanded?: boolean;
   findQuery?: string;
   activeFindMatch?: ThreadFindMatch | null;
   findNavigationId?: number;
@@ -572,6 +573,7 @@ const ConversationTimeline = memo(function ConversationTimeline({
   awaitingUser = false,
   listRef,
   timelineEntries,
+  findExpanded = false,
   findQuery = "",
   activeFindMatch = null,
   findNavigationId = 0,
@@ -679,7 +681,7 @@ const ConversationTimeline = memo(function ConversationTimeline({
   const disclosureSettleFrameRef = useRef<number | null>(null);
   const disclosureSettleSecondFrameRef = useRef<number | null>(null);
   const normalizedFindQuery = findQuery.trim();
-  const findActive = normalizedFindQuery.length > 0;
+  const findActive = findExpanded;
 
   useEffect(() => {
     return () => {
diff --git a/apps/web/src/components/chat/useThreadFind.test.tsx b/apps/web/src/components/chat/useThreadFind.test.tsx
index a7189938b8fc..e5cd0c76f611 100644
--- a/apps/web/src/components/chat/useThreadFind.test.tsx
+++ b/apps/web/src/components/chat/useThreadFind.test.tsx
@@ -153,6 +153,11 @@ describe("V2 find state", () => {
     await act(async () => find.barProps.onQueryChange("different query"));
     expect(find.barProps.status).toBe("loading");
     expect(find.barProps.matchCount).toBe(0);
+    // Folded content stays expanded while the new query loads.
+    expect(find.timelineProps.findQuery).toBe("");
+    expect(find.timelineProps.findExpanded).toBe(true);
+    await act(async () => find.barProps.onQueryChange(""));
+    expect(find.timelineProps.findExpanded).toBe(false);
   });
 
   it("keeps search unavailable when the server does not support it", async () => {
diff --git a/apps/web/src/components/chat/useThreadFind.ts b/apps/web/src/components/chat/useThreadFind.ts
index 0fa5222e19e9..b5140bb3bfda 100644
--- a/apps/web/src/components/chat/useThreadFind.ts
+++ b/apps/web/src/components/chat/useThreadFind.ts
@@ -106,6 +106,8 @@ export function useThreadFind({
     },
     timelineProps: {
       findOpen: isOpen,
+      // Stays on between keystrokes so folded content does not collapse while results load.
+      findExpanded: isOpen && state.query.trim().length > 0,
       findPositionReaderRef,
       findQuery: isOpen && remote.data?.match ? state.query : "",
       activeFindMatch: remote.data?.match ?? null,
diff --git a/apps/web/src/components/chat/useThreadFindNavigation.ts b/apps/web/src/components/chat/useThreadFindNavigation.ts
index 8fb72291d481..b99fa465aa50 100644
--- a/apps/web/src/components/chat/useThreadFindNavigation.ts
+++ b/apps/web/src/components/chat/useThreadFindNavigation.ts
@@ -103,8 +103,13 @@ export function useThreadFindNavigation({
       const rect = range.getBoundingClientRect();
       const viewport = container?.getBoundingClientRect();
       if (!viewport || rect.height === 0) return;
-      const top = viewport.top + FIND_MATCH_VIEW_MARGIN;
-      const bottom = viewport.bottom - FIND_MATCH_VIEW_MARGIN - contentInsetEndAdjustment;
+      // Shrink the margin when the band above the composer is short, so the match stays inside it.
+      const margin = Math.min(
+        FIND_MATCH_VIEW_MARGIN,
+        Math.max(0, (viewport.height - contentInsetEndAdjustment - rect.height) / 2),
+      );
+      const top = viewport.top + margin;
+      const bottom = viewport.bottom - margin - contentInsetEndAdjustment;
       const delta =
         rect.top < top ? rect.top - top : rect.bottom > bottom ? rect.bottom - bottom : 0;
       // A new list can expose DOM text before its virtual row sizes settle.

From 7906e463be78832259470de6c15ae5a6c473381b Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 10:43:50 -0700
Subject: [PATCH 14/21] fix(server): thread search no longer holds the write
 lock or reparses large messages

Payload decoding ran inside the BEGIN IMMEDIATE snapshot, and messages over
32 KB were parsed again on every query. Decode after the snapshot, cache
large parses separately, and bound the client-supplied skill labels.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .../src/orchestration-v2/ThreadFind.test.ts   | 12 +++--
 .../server/src/orchestration-v2/ThreadFind.ts | 49 ++++++++++++-------
 packages/contracts/src/orchestrationV2.ts     |  6 +--
 3 files changed, 44 insertions(+), 23 deletions(-)

diff --git a/apps/server/src/orchestration-v2/ThreadFind.test.ts b/apps/server/src/orchestration-v2/ThreadFind.test.ts
index bb28b5cb08dd..1b74a6b0dc0b 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.test.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.test.ts
@@ -195,7 +195,7 @@ const setup = Effect.gen(function* () {
 });
 
 describe("V2 thread find", () => {
-  it.effect("reuses match counts on navigation even for text larger than the Markdown cache", () =>
+  it.effect("reuses parses of large messages across navigation, edits, and new queries", () =>
     Effect.gen(function* () {
       const projection = yield* setup;
       const text = `${"large message ".repeat(2600)}needle`;
@@ -204,7 +204,8 @@ describe("V2 thread find", () => {
       try {
         const first = yield* projection.searchThread({ threadId, query: "needle" });
         assert.equal(first.totalMatches, 8);
-        assert.equal(parse.mock.calls.length, 8);
+        // Identical bodies share one parse.
+        assert.equal(parse.mock.calls.length, 1);
         parse.mockClear();
         const next = yield* projection.searchThread({ threadId, query: "needle", index: 4 });
         assert.equal(next.match?.entryId, "large:4");
@@ -214,7 +215,12 @@ describe("V2 thread find", () => {
         const changed = yield* projection.searchThread({ threadId, query: "needle", index: 5 });
         assert.equal(changed.totalMatches, 9);
         assert.deepEqual(changed.match, { entryId: "large:4", runId, occurrence: 1 });
-        assert.equal(parse.mock.calls.length, 8);
+        // Only the edited message is parsed again.
+        assert.equal(parse.mock.calls.length, 1);
+        parse.mockClear();
+        const retyped = yield* projection.searchThread({ threadId, query: "large message" });
+        assert.equal(retyped.totalMatches, 8 * 2600);
+        assert.equal(parse.mock.calls.length, 0);
       } finally {
         parse.mockRestore();
       }
diff --git a/apps/server/src/orchestration-v2/ThreadFind.ts b/apps/server/src/orchestration-v2/ThreadFind.ts
index 6c64136edc6d..0e7d85316a5b 100644
--- a/apps/server/src/orchestration-v2/ThreadFind.ts
+++ b/apps/server/src/orchestration-v2/ThreadFind.ts
@@ -219,16 +219,12 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
       if (!items) byThread.set(row.thread_id, (items = new Map()));
       items.set(row.turn_item_id, row.payload_json);
     }
-    return yield* Effect.forEach(rows, (row) =>
-      Effect.gen(function* () {
-        const payload = byThread.get(row.sourceThreadId)?.get(row.sourceItemId);
-        if (payload === undefined) return yield* new ProjectionStoreReadError({ threadId });
-        const item = yield* decodeItem(payload).pipe(
-          Effect.mapError((cause) => new ProjectionStoreReadError({ threadId, cause })),
-        );
-        return { ...row, item };
-      }),
-    );
+    return yield* Effect.forEach(rows, (row) => {
+      const payload = byThread.get(row.sourceThreadId)?.get(row.sourceItemId);
+      return payload === undefined
+        ? Effect.fail(new ProjectionStoreReadError({ threadId }))
+        : Effect.succeed({ ...row, payload });
+    });
   });
   // Cache rendered segments, not queries; typing and navigation reuse Markdown parsing.
   const textCache = yield* Cache.make({
@@ -236,7 +232,13 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
     timeToLive: "1 minute",
     lookup: (key: TextKey) => Effect.sync(() => parseText(key)),
   });
-  // Retain counts and item references, never message bodies. Navigation checks
+  // Bounded separately because each entry can hold a large body; typing reuses the parse.
+  const largeTextCache = yield* Cache.make({
+    capacity: 32,
+    timeToLive: "1 minute",
+    lookup: (key: TextKey) => Effect.sync(() => parseText(key)),
+  });
+  // Scans retain counts and item references, never message bodies. Navigation checks
   // the current revision in its transaction without reloading message payloads.
   const scans = new Map<string, { sequence: number; documents: readonly FindDocument[] }>();
   const snapshot = Effect.fn("ThreadFind.snapshot")(
@@ -279,11 +281,11 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
             row.item.type,
           ),
         );
-      const items: OrchestrationV2ProjectedTurnItem[] = [];
+      const payloads: (FindRow & { readonly payload: string })[] = [];
       for (let start = 0; start < candidates.length; start += 128) {
-        items.push(...(yield* load(threadId, candidates.slice(start, start + 128))));
+        payloads.push(...(yield* load(threadId, candidates.slice(start, start + 128))));
       }
-      return { items, cwd, sequence, cacheKey };
+      return { payloads, cwd, sequence, cacheKey };
     },
     sql.withTransaction,
     (effect, input) =>
@@ -302,14 +304,27 @@ export const makeThreadFind = Effect.fn("makeThreadFind")(function* (
     // come from one snapshot, including inherited fork history.
     const data = yield* snapshot(input);
     if (data.result) return data.result;
-    const { items, cwd, sequence, cacheKey } = data;
+    const { payloads, cwd, sequence, cacheKey } = data;
+    // Decode after the snapshot so the write lock is not held for it.
+    const items: OrchestrationV2ProjectedTurnItem[] = yield* Effect.forEach(
+      payloads,
+      ({ payload, ...row }) =>
+        decodeItem(payload).pipe(
+          Effect.map((item) => ({ ...row, item })),
+          Effect.mapError(
+            (cause) => new ProjectionStoreReadError({ threadId: input.threadId, cause }),
+          ),
+        ),
+    );
     const rows = searchableRows(items);
     const skills = input.skills ?? [];
     const documents: FindDocument[] = [];
     for (const row of rows) {
       const key = textKey(row.item, cwd, skills);
-      const segments =
-        key.text.length <= 32_768 ? yield* Cache.get(textCache, key) : parseText(key);
+      const segments = yield* Cache.get(
+        key.text.length <= 32_768 ? textCache : largeTextCache,
+        key,
+      );
       documents.push(documentFor(row, countSegments(segments, input.query)));
       yield* Effect.yieldNow;
     }
diff --git a/packages/contracts/src/orchestrationV2.ts b/packages/contracts/src/orchestrationV2.ts
index ea7dbafdac45..42e0cad86137 100644
--- a/packages/contracts/src/orchestrationV2.ts
+++ b/packages/contracts/src/orchestrationV2.ts
@@ -3491,10 +3491,10 @@ export const OrchestrationV2SearchThreadInput = Schema.Struct({
   skills: Schema.optionalKey(
     Schema.Array(
       Schema.Struct({
-        name: Schema.String,
-        displayName: Schema.optional(Schema.String),
+        name: Schema.String.check(Schema.isMaxLength(200)),
+        displayName: Schema.optional(Schema.String.check(Schema.isMaxLength(200))),
       }),
-    ),
+    ).check(Schema.isMaxLength(1_000)),
   ),
   query: TrimmedNonEmptyString.check(Schema.isMaxLength(200)),
   index: Schema.optionalKey(NonNegativeInt),

From e5c01b2ebf36d2ef47a492d1fe384601553e69c4 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 10:57:44 -0700
Subject: [PATCH 15/21] fix(web): find keeps its reading position and the
 bodies it opened

Enter before results arrived replaced the viewport start with match 1, and
closing find re-collapsed long user messages over the revealed match.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .../src/components/chat/MessagesTimeline.tsx  |  6 +++++
 .../components/chat/useThreadFind.test.tsx    | 23 +++++++++++++++++++
 apps/web/src/components/chat/useThreadFind.ts |  5 +++-
 3 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index cd0b405b96aa..17f1e26cc7d1 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -4598,6 +4598,12 @@ const CollapsibleUserMessageBody = memo(function CollapsibleUserMessageBody(prop
   footer?: ReactNode;
 }) {
   const [expanded, setExpanded] = useState(false);
+  // Closing find keeps bodies it opened, so the reading position and revealed match stay put.
+  const [wasExpandedForFind, setWasExpandedForFind] = useState(props.expandForFind === true);
+  if (wasExpandedForFind !== (props.expandForFind === true)) {
+    setWasExpandedForFind(props.expandForFind === true);
+    if (wasExpandedForFind) setExpanded(true);
+  }
   const hasVisibleBody = props.text.trim().length > 0;
   const canCollapse = hasVisibleBody && shouldCollapseUserMessage(props.text);
   const isCollapsed = canCollapse && !expanded && !props.expandForFind;
diff --git a/apps/web/src/components/chat/useThreadFind.test.tsx b/apps/web/src/components/chat/useThreadFind.test.tsx
index e5cd0c76f611..d5dc40bf1740 100644
--- a/apps/web/src/components/chat/useThreadFind.test.tsx
+++ b/apps/web/src/components/chat/useThreadFind.test.tsx
@@ -136,6 +136,29 @@ describe("V2 find state", () => {
     expect(find.timelineProps.findNavigationId).toBe(1);
   });
 
+  it("keeps the reading-position start when Enter is pressed before results arrive", async () => {
+    queries.pending = true;
+    await act(async () => {
+      renderer = create(<Probe environmentId={a} />);
+    });
+    await act(async () => find.open());
+    find.timelineProps.findPositionReaderRef.current = () => ({
+      entryId: "message:6",
+      occurrence: 1,
+    });
+    await act(async () => find.barProps.onQueryChange("COD4"));
+    await act(async () => find.barProps.onNext());
+    expect(orchestrationEnvironment.threadFind).toHaveBeenLastCalledWith({
+      environmentId: a,
+      input: {
+        threadId,
+        query: "COD4",
+        skills: [],
+        start: { entryId: "message:6", occurrence: 1 },
+      },
+    });
+  });
+
   it("shows Searching only when the query has no result yet", async () => {
     queries.pending = true;
     await act(async () => {
diff --git a/apps/web/src/components/chat/useThreadFind.ts b/apps/web/src/components/chat/useThreadFind.ts
index b5140bb3bfda..548158c6679f 100644
--- a/apps/web/src/components/chat/useThreadFind.ts
+++ b/apps/web/src/components/chat/useThreadFind.ts
@@ -77,12 +77,15 @@ export function useThreadFind({
       : null;
   const count = remote.data?.totalMatches ?? 0;
   const activeIndex = remote.data?.activeIndex ?? 0;
-  const step = (delta: number) =>
+  const step = (delta: number) => {
+    // Before results arrive, stepping would replace the reading-position start with index 0.
+    if (count === 0) return;
     setState((previous) => ({
       ...previous,
       activeIndex: stepThreadFindIndex(previous.activeIndex ?? activeIndex, count, delta),
       navigationId: previous.navigationId + 1,
     }));
+  };
 
   return {
     isOpen,

From e96f67da7eb8d7915d08df01693c2d343bac83ae Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 12:10:58 -0700
Subject: [PATCH 16/21] fix(web): find opens folded content only for the
 selected match

Opening find used to expand every disclosure, long message, and plan, and
flip every Mermaid diagram to source, reflowing the whole timeline. Folded
text now stays mounted but hidden: it still counts, and stepping to a match
inside it dispatches beforematch so only that fold opens.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 apps/web/src/components/ChatMarkdown.test.tsx | 168 +++++++++++++-----
 apps/web/src/components/ChatMarkdown.tsx      |  17 +-
 .../src/components/chat/MermaidDiagram.tsx    |   6 +-
 .../src/components/chat/MessagesTimeline.tsx  |  21 +--
 .../src/components/chat/ProposedPlanCard.tsx  |  20 ++-
 .../components/chat/markdownFindContext.ts    |  20 ++-
 .../components/chat/threadFindHighlights.ts   |  41 ++++-
 7 files changed, 216 insertions(+), 77 deletions(-)

diff --git a/apps/web/src/components/ChatMarkdown.test.tsx b/apps/web/src/components/ChatMarkdown.test.tsx
index f661c0ff6aec..f8988f97fd57 100644
--- a/apps/web/src/components/ChatMarkdown.test.tsx
+++ b/apps/web/src/components/ChatMarkdown.test.tsx
@@ -18,6 +18,10 @@ import { Button } from "./ui/button";
 import { setMarkdownTaskChecked } from "./files/filePreviewMode";
 
 vi.mock("@effect/atom-react", () => ({ useAtomValue: () => null }));
+vi.mock("./chat/MermaidDiagram", () => ({
+  // Real Mermaid needs layout APIs jsdom lacks; a rendered diagram is an SVG.
+  MermaidDiagram: () => <svg aria-label="Diagram" />,
+}));
 vi.mock("../hooks/useTheme", () => ({ useTheme: () => ({ resolvedTheme: "dark" }) }));
 vi.mock("../hooks/useSettings", async (importOriginal) => {
   const actual = await importOriginal<typeof import("../hooks/useSettings")>();
@@ -1041,62 +1045,128 @@ describe("ChatMarkdown Windows file links", () => {
   });
 });
 
-it("opens nested disclosures for find and restores their prior state when find closes", async () => {
+it("opens a disclosure only when find selects a match inside it", async () => {
   vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
-  let renderer: ReactTestRenderer | undefined;
-  const render = (searching: boolean) => (
-    <MarkdownFindContext value={searching}>
-      <ChatMarkdown
-        cwd={undefined}
-        text="<details><summary>Outer</summary><details><summary>Inner</summary><p>needle</p></details></details>"
-      />
-    </MarkdownFindContext>
+  vi.stubGlobal(
+    "Highlight",
+    class extends Set<Range> {
+      constructor(...ranges: Range[]) {
+        super(ranges);
+      }
+    },
   );
-  try {
-    await act(async () => {
-      renderer = create(render(false));
-    });
-    expect(JSON.stringify(renderer!.toJSON())).not.toContain("needle");
-    await act(async () => {
-      renderer!.update(render(true));
-    });
-    expect(JSON.stringify(renderer!.toJSON())).toContain("needle");
-    await act(async () => {
-      renderer!.update(render(false));
+  const highlights = new Map<string, Set<Range>>();
+  vi.stubGlobal("CSS", { highlights, escape: (value: string) => value });
+  const container = document.createElement("div");
+  document.body.append(container);
+  const root = createRoot(container);
+  const openStates = () =>
+    [...container.querySelectorAll("[data-markdown-details-open]")].map((node) =>
+      node.getAttribute("data-markdown-details-open"),
+    );
+  function Probe({ activeOccurrence }: { activeOccurrence: number }) {
+    useThreadFindHighlights({
+      container,
+      query: "needle",
+      activeRowId: "row",
+      activeOccurrence,
+      onActiveRange: () => {},
     });
+    return (
+      <div data-timeline-row-id="row">
+        <div data-thread-find-text>
+          <MarkdownFindContext value={true}>
+            <ChatMarkdown
+              cwd={undefined}
+              text={[
+                "Visible needle.",
+                "<details><summary>Unrelated</summary><p>nothing here</p></details>",
+                "<details><summary>Outer</summary><details><summary>Inner</summary><p>needle</p></details></details>",
+              ].join("\n\n")}
+            />
+          </MarkdownFindContext>
+        </div>
+      </div>
+    );
+  }
+  const frame = () =>
+    act(() => new Promise<void>((resolve) => requestAnimationFrame(() => resolve())));
+  try {
+    await act(() => root.render(<Probe activeOccurrence={0} />));
+    await frame();
+    // Selecting the visible match opens nothing; the folded one is counted but not painted.
+    expect(openStates()).toEqual(["false", "false", "false"]);
+    expect(container.textContent).toContain("nothing here");
     expect(
-      renderer!.root
-        .findAll(
-          (node) => node.type === "button" && node.props["data-markdown-details-summary"] === "",
-        )
-        .every((node) => node.props["aria-expanded"] === false),
-    ).toBe(true);
-    const trigger = renderer!.root.findAll(
-      (node) => node.type === "button" && node.props["data-markdown-details-summary"] === "",
-    )[0]!;
-    await act(async () => {
-      trigger.props.onClick({ nativeEvent: new Event("click") });
-    });
-    await act(async () => {
-      renderer!.update(render(true));
-    });
-    await act(async () => {
-      renderer!.update(render(false));
+      [...(highlights.get("t3-thread-find-active") ?? [])].map((range) => range.toString()),
+    ).toEqual(["needle"]);
+    expect(highlights.get("t3-thread-find")?.size).toBe(0);
+
+    await act(() => root.render(<Probe activeOccurrence={1} />));
+    await frame();
+    await frame();
+    // Stepping to the folded match opens its two ancestors, not the unrelated one.
+    expect(openStates()).toEqual(["false", "true", "true"]);
+    expect(highlights.get("t3-thread-find-active")?.size).toBe(1);
+  } finally {
+    await act(() => root.unmount());
+    container.remove();
+    vi.unstubAllGlobals();
+  }
+});
+
+it("keeps Mermaid diagrams rendered until find selects a match in their source", async () => {
+  vi.stubGlobal("IS_REACT_ACT_ENVIRONMENT", true);
+  vi.stubGlobal(
+    "Highlight",
+    class extends Set<Range> {
+      constructor(...ranges: Range[]) {
+        super(ranges);
+      }
+    },
+  );
+  const highlights = new Map<string, Set<Range>>();
+  vi.stubGlobal("CSS", { highlights, escape: (value: string) => value });
+  const container = document.createElement("div");
+  document.body.append(container);
+  const root = createRoot(container);
+  const diagram = "```mermaid\ngraph TD; Alpha-->Beta\n```";
+  function Probe({ query }: { query: string }) {
+    useThreadFindHighlights({
+      container,
+      query,
+      activeRowId: "row",
+      activeOccurrence: 0,
+      onActiveRange: () => {},
     });
+    return (
+      <div data-timeline-row-id="row">
+        <div data-thread-find-text>
+          <MarkdownFindContext value={true}>
+            <ChatMarkdown cwd={undefined} text={`Needle first.\n\n${diagram}\n\n${diagram}`} />
+          </MarkdownFindContext>
+        </div>
+      </div>
+    );
+  }
+  const frame = () =>
+    act(() => new Promise<void>((resolve) => requestAnimationFrame(() => resolve())));
+  const diagrams = () => container.querySelectorAll('svg[aria-label="Diagram"]').length;
+  try {
+    await act(() => root.render(<Probe query="Needle" />));
+    await frame();
+    expect(diagrams()).toBe(2);
+    await act(() => root.render(<Probe query="Alpha" />));
+    await frame();
+    await frame();
+    // Only the diagram holding the selected match switches to source.
+    expect(diagrams()).toBe(1);
     expect(
-      renderer!.root.findAllByProps({ "data-markdown-details-open": "true" }).length,
-    ).toBeGreaterThan(0);
-    expect(
-      renderer!.root
-        .findAll(
-          (node) => node.type === "button" && node.props["data-markdown-details-summary"] === "",
-        )
-        .map((node) => node.props["aria-expanded"]),
-    ).toEqual([true, false]);
+      [...(highlights.get("t3-thread-find-active") ?? [])].map((range) => range.toString()),
+    ).toEqual(["Alpha"]);
   } finally {
-    await act(async () => {
-      renderer?.unmount();
-    });
+    await act(() => root.unmount());
+    container.remove();
     vi.unstubAllGlobals();
   }
 });
diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index 05b4b08c13a5..2e154c0d952a 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -1,4 +1,4 @@
-import { MarkdownFindContext } from "./chat/markdownFindContext";
+import { MarkdownFindContext, useFindRevealRef } from "./chat/markdownFindContext";
 import {
   buildFileLinkParentSuffixByPath,
   fileLinkLabel,
@@ -690,7 +690,7 @@ function MarkdownDetails({
 }: Pick<React.ComponentProps<"details">, "children" | "open">) {
   const [isOpen, setIsOpen] = useState(open);
   const searching = use(MarkdownFindContext);
-  const expanded = searching || isOpen;
+  const expanded = isOpen;
   const childNodes = Children.toArray(children);
   const summaryIndex = childNodes.findIndex(
     (child) => isValidElement(child) && child.type === "summary",
@@ -720,7 +720,8 @@ function MarkdownDetails({
           />
           <span>{summary}</span>
         </CollapsibleTrigger>
-        <CollapsiblePanel>
+        {/* Base UI opens an until-found panel on `beforematch`. */}
+        <CollapsiblePanel hiddenUntilFound={searching}>
           <div
             className="pb-3 ps-6 text-foreground/[calc(80%+var(--appearance-contrast-boost)/5)]"
             data-markdown-details-content=""
@@ -969,7 +970,9 @@ function MarkdownMermaidCodeBlock({
 }) {
   const [showCode, setShowCode] = useState(false);
   const searching = use(MarkdownFindContext);
-  const showDiagram = !searching && !showCode && !isStreaming && code.trim().length > 0;
+  const revealSource = useCallback(() => setShowCode(true), []);
+  const sourceRevealRef = useFindRevealRef(revealSource);
+  const showDiagram = !showCode && !isStreaming && code.trim().length > 0;
   const toggleLabel = showCode ? "Show diagram" : "Show code";
   return (
     <MarkdownCodeBlock
@@ -1012,6 +1015,12 @@ function MarkdownMermaidCodeBlock({
           >
             <MermaidDiagram source={code} theme={theme} onExpand={onExpand} />
           </Suspense>
+          {/* Find counts the source; a selected match here switches to it. */}
+          {searching ? (
+            <pre ref={sourceRevealRef} hidden>
+              {code}
+            </pre>
+          ) : null}
         </RenderErrorBoundary>
       ) : (
         children
diff --git a/apps/web/src/components/chat/MermaidDiagram.tsx b/apps/web/src/components/chat/MermaidDiagram.tsx
index 30c987918845..dd03bdc4ea10 100644
--- a/apps/web/src/components/chat/MermaidDiagram.tsx
+++ b/apps/web/src/components/chat/MermaidDiagram.tsx
@@ -192,7 +192,11 @@ export function MermaidDiagram({
             </Button>
           ) : null}
         </div>
-        <pre className="mt-2 mb-0 overflow-auto font-mono text-xs whitespace-pre-wrap">
+        {/* Find matches the source through the hidden copy beside the diagram. */}
+        <pre
+          data-thread-find-ignore
+          className="mt-2 mb-0 overflow-auto font-mono text-xs whitespace-pre-wrap"
+        >
           {source}
         </pre>
       </div>
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 17f1e26cc7d1..edb147ed1467 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -1,5 +1,5 @@
 import { shouldPreserveAssistantLineBreaks } from "@t3tools/shared/markdownPipeline";
-import { MarkdownFindContext } from "./markdownFindContext";
+import { MarkdownFindContext, useFindRevealRef } from "./markdownFindContext";
 import { ComputerUseAppIcon } from "~/components/Icons";
 import { useChatCanvas } from "./ChatCanvasContext";
 import { WorkLogBlock, WorkLogButton, WorkLogDetails, WorkLogList, WorkLogRow } from "./WorkLog";
@@ -2454,7 +2454,6 @@ function UserTimelineRow({ row }: { row: Extract<TimelineRow, { kind: "message"
         ) : null}
         <div onCopyCapture={onBodyCopyCapture}>
           <CollapsibleUserMessageBody
-            expandForFind={ctx.findActive}
             text={resolvedContext.text}
             renderContextReference={renderContextReference}
             skills={ctx.skills}
@@ -2902,7 +2901,7 @@ function ProposedPlanTimelineRow({
         threadRef={ctx.threadRef ?? undefined}
         cwd={ctx.markdownCwd}
         workspaceRoot={ctx.workspaceRoot}
-        expandForFind={ctx.findActive}
+        findActive={ctx.findActive}
       />
     </div>
   );
@@ -4594,28 +4593,26 @@ const CollapsibleUserMessageBody = memo(function CollapsibleUserMessageBody(prop
   renderContextReference: (reference: ChatMarkdownContextReference) => ReactNode;
   skills: ReadonlyArray<Pick<ServerProviderSkill, "name" | "displayName">>;
   markdownCwd: string | undefined;
-  expandForFind?: boolean;
   footer?: ReactNode;
 }) {
   const [expanded, setExpanded] = useState(false);
-  // Closing find keeps bodies it opened, so the reading position and revealed match stay put.
-  const [wasExpandedForFind, setWasExpandedForFind] = useState(props.expandForFind === true);
-  if (wasExpandedForFind !== (props.expandForFind === true)) {
-    setWasExpandedForFind(props.expandForFind === true);
-    if (wasExpandedForFind) setExpanded(true);
-  }
+  // Find opens the body only when it selects a match in the clipped part.
+  const revealForFind = useCallback(() => setExpanded(true), []);
+  const findRevealRef = useFindRevealRef(revealForFind);
   const hasVisibleBody = props.text.trim().length > 0;
   const canCollapse = hasVisibleBody && shouldCollapseUserMessage(props.text);
-  const isCollapsed = canCollapse && !expanded && !props.expandForFind;
-  const showCollapseControl = canCollapse && !props.expandForFind;
+  const isCollapsed = canCollapse && !expanded;
+  const showCollapseControl = canCollapse;
 
   return (
     <div>
       {hasVisibleBody ? (
         <div
+          ref={findRevealRef}
           className={cn("relative", isCollapsed && "max-h-44 overflow-hidden")}
           data-user-message-body="true"
           data-thread-find-text="true"
+          data-thread-find-fold={isCollapsed ? "" : undefined}
           data-user-message-collapsed={isCollapsed ? "true" : "false"}
           data-user-message-collapsible={canCollapse ? "true" : "false"}
           data-user-message-fade={isCollapsed ? "true" : "false"}
diff --git a/apps/web/src/components/chat/ProposedPlanCard.tsx b/apps/web/src/components/chat/ProposedPlanCard.tsx
index 83a4833124cf..de082c3d3569 100644
--- a/apps/web/src/components/chat/ProposedPlanCard.tsx
+++ b/apps/web/src/components/chat/ProposedPlanCard.tsx
@@ -1,5 +1,6 @@
 import { proposedPlanTitle, stripDisplayedPlanMarkdown } from "@t3tools/shared/proposedPlanText";
-import { memo, useState, useId } from "react";
+import { memo, useCallback, useState, useId } from "react";
+import { useFindRevealRef } from "./markdownFindContext";
 import {
   isAtomCommandInterrupted,
   squashAtomCommandFailure,
@@ -43,14 +44,14 @@ export const ProposedPlanCard = memo(function ProposedPlanCard({
   threadRef,
   cwd,
   workspaceRoot,
-  expandForFind = false,
+  findActive = false,
 }: {
   planMarkdown: string;
   environmentId: EnvironmentId;
   threadRef?: ScopedThreadRef | undefined;
   cwd: string | undefined;
   workspaceRoot: string | undefined;
-  expandForFind?: boolean;
+  findActive?: boolean;
 }) {
   const [expanded, setExpanded] = useState(false);
   const canWriteFiles = useEnvironmentScope(environmentId, AuthFilesystemWriteScope);
@@ -80,7 +81,12 @@ export const ProposedPlanCard = memo(function ProposedPlanCard({
   const collapsedPreview = canCollapse
     ? buildCollapsedProposedPlanPreviewMarkdown(planMarkdown, { maxLines: 10 })
     : null;
-  const isCollapsed = canCollapse && !expanded && !expandForFind;
+  const isCollapsed = canCollapse && !expanded;
+  // While finding, the full plan stays mounted but clipped, so a match past the
+  // preview can be counted and then opened only once it is selected.
+  const showPreview = isCollapsed && !findActive;
+  const revealForFind = useCallback(() => setExpanded(true), []);
+  const findRevealRef = useFindRevealRef(revealForFind);
   const downloadFilename = buildProposedPlanMarkdownFilename(planMarkdown);
   const saveContents = normalizePlanMarkdownForExport(planMarkdown);
 
@@ -187,10 +193,12 @@ export const ProposedPlanCard = memo(function ProposedPlanCard({
       </div>
       <div className="mt-4">
         <div
+          ref={findRevealRef}
           className={cn("relative", isCollapsed && "max-h-104 overflow-hidden")}
           data-thread-find-text="true"
+          data-thread-find-fold={isCollapsed ? "" : undefined}
         >
-          {isCollapsed ? (
+          {showPreview ? (
             <ChatMarkdown
               text={collapsedPreview ?? ""}
               cwd={cwd}
@@ -213,7 +221,7 @@ export const ProposedPlanCard = memo(function ProposedPlanCard({
             <div className="pointer-events-none absolute inset-x-0 bottom-0 h-24 bg-linear-to-t from-card/95 via-card/80 to-transparent" />
           ) : null}
         </div>
-        {canCollapse && !expandForFind ? (
+        {canCollapse ? (
           <div className="mt-4 flex justify-center">
             <Button
               size="sm"
diff --git a/apps/web/src/components/chat/markdownFindContext.ts b/apps/web/src/components/chat/markdownFindContext.ts
index f765c9e1b716..64754cc6b3c8 100644
--- a/apps/web/src/components/chat/markdownFindContext.ts
+++ b/apps/web/src/components/chat/markdownFindContext.ts
@@ -1,4 +1,20 @@
-import { createContext } from "react";
+import { createContext, useCallback } from "react";
 
-// Temporarily reveal Markdown disclosures while finding; preserve the user's fold state.
+// While find is active, folded content stays mounted (hidden) so its text can be
+// matched. Nothing opens until the selected match lies inside it.
 export const MarkdownFindContext = createContext(false);
+
+/**
+ * Find dispatches `beforematch` on hidden or clipped ancestors of the selected
+ * match, like the browser's own find-in-page. `onReveal` must be stable.
+ */
+export function useFindRevealRef(onReveal: () => void) {
+  return useCallback(
+    (element: HTMLElement | null) => {
+      if (!element) return;
+      element.addEventListener("beforematch", onReveal);
+      return () => element.removeEventListener("beforematch", onReveal);
+    },
+    [onReveal],
+  );
+}
diff --git a/apps/web/src/components/chat/threadFindHighlights.ts b/apps/web/src/components/chat/threadFindHighlights.ts
index d5149e7eb5e7..bfebcba16256 100644
--- a/apps/web/src/components/chat/threadFindHighlights.ts
+++ b/apps/web/src/components/chat/threadFindHighlights.ts
@@ -68,6 +68,34 @@ export function collectThreadFindRanges(container: HTMLElement, query: string):
   return ranges;
 }
 
+/** Ancestors that hide (`hidden`) or clip (`data-thread-find-fold`) text until find opens them. */
+const FOLD_SELECTOR = "[hidden], [data-thread-find-fold]";
+
+/** Folds around the range that currently keep it out of sight, innermost first. */
+function foldsHiding(range: Range, container: HTMLElement): Element[] {
+  const folds: Element[] = [];
+  for (
+    let fold = range.startContainer.parentElement?.closest(FOLD_SELECTOR);
+    fold && container.contains(fold);
+    fold = fold.parentElement?.closest(FOLD_SELECTOR)
+  ) {
+    // A clipped body still shows its first lines; only text past the cutoff is folded.
+    if (
+      fold.hasAttribute("hidden") ||
+      range.getBoundingClientRect().bottom > fold.getBoundingClientRect().bottom
+    )
+      folds.push(fold);
+  }
+  return folds;
+}
+
+/** Dispatches `beforematch` on each fold hiding the range; returns whether any existed. */
+function revealFolded(range: Range, container: HTMLElement): boolean {
+  const folds = foldsHiding(range, container);
+  for (const fold of folds) fold.dispatchEvent(new Event("beforematch"));
+  return folds.length > 0;
+}
+
 export function useThreadFindHighlights(input: {
   readonly container: HTMLElement | null;
   readonly query: string;
@@ -102,11 +130,18 @@ export function useThreadFindHighlights(input: {
           match.occurrence === activeOccurrence
         ) {
           active = match.range;
-        } else {
+        } else if (foldsHiding(match.range, container).length === 0) {
           inactive.push(match.range);
         }
       }
-      onActiveRange(active);
+      // Folded text still counts; only the selected occurrence opens its folds.
+      // The resulting DOM change repaints through the observer below.
+      if (active && revealFolded(active, container)) {
+        onActiveRange(null);
+        active = null;
+      } else {
+        onActiveRange(active);
+      }
       CSS.highlights.set(THREAD_FIND_HIGHLIGHT_NAME, new Highlight(...inactive));
       CSS.highlights.set(
         THREAD_FIND_ACTIVE_HIGHLIGHT_NAME,
@@ -128,7 +163,7 @@ export function useThreadFindHighlights(input: {
       childList: true,
       characterData: true,
       attributes: true,
-      attributeFilter: ["data-wrap"],
+      attributeFilter: ["data-wrap", "hidden", "data-thread-find-fold"],
     });
     return () => {
       observer.disconnect();

From f6a55691436bd03bca5d9ca463effb206469ab04 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 14:06:47 -0700
Subject: [PATCH 17/21] fix(web): find opens folded imported turns

Imported V1 history has no run id, so its turns fold under a synthetic key.
Find expanded the match's own run id, so every match inside a folded imported
turn advanced the counter without revealing anything.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .../chat/MessagesTimeline.logic.test.ts       | 21 ++++++++
 .../components/chat/MessagesTimeline.logic.ts | 51 +++++++++++++++++--
 .../src/components/chat/MessagesTimeline.tsx  | 15 +++++-
 3 files changed, 83 insertions(+), 4 deletions(-)

diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
index 4b908f7712b6..442fc4339aa3 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
@@ -27,6 +27,7 @@ import {
   computeStableMessagesTimelineRows,
   computeMessageDurationStart,
   deriveMessagesTimelineRows,
+  timelineEntryTurnFoldRunId,
   deriveMessagesTimelineRowsWithState,
   liveWorkEntryLabel,
   normalizeCompactToolLabel,
@@ -2302,6 +2303,26 @@ describe("deriveMessagesTimelineRows", () => {
     const withoutPrompt = rows([]);
     expect(withoutPrompt).toContain("turn-fold");
     expect(withoutPrompt).not.toContain("assistant:imported-update");
+
+    // Find must open the fold holding a folded imported message by its synthetic key.
+    const timelineEntries = [
+      message("imported-prompt", "user", 0),
+      message("imported-update", "assistant", 4),
+      message("imported-answer", "assistant", 8),
+    ];
+    const foldInput = { timelineEntries, latestRun: null, isWorking: false };
+    const foldRunId = timelineEntryTurnFoldRunId(foldInput, "imported-update");
+    expect(foldRunId).not.toBeNull();
+    expect(timelineEntryTurnFoldRunId(foldInput, "imported-answer")).toBeNull();
+    const expanded = deriveMessagesTimelineRows({
+      ...foldInput,
+      expandedRunIds: new Set([foldRunId!]),
+      turnDiffSummaries: [],
+      supportsConversationRollback: false,
+    });
+    expect(
+      expanded.some((row) => row.kind === "message" && row.message.id === "imported-update"),
+    ).toBe(true);
   });
 
   it("shows a provider-native subagent's runless tools as live work while it works", () => {
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts
index 1143d3472867..35ea0e01c4ff 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts
@@ -1253,6 +1253,35 @@ function settleSupersededReasoning(entries: ReadonlyArray<TimelineEntry>) {
   });
 }
 
+function timelineRowEntries(entries: ReadonlyArray<TimelineEntry>) {
+  return withoutSubagentDelegationRows(settleSupersededReasoning(entries));
+}
+
+/** The turn folds the timeline would draw, before applying expansion state. */
+function deriveTimelineTurnFolds(
+  input: Pick<
+    MessagesTimelineRowsInput,
+    "timelineEntries" | "latestRun" | "isWorking" | "runlessWorkActive" | "runningRunId"
+  >,
+) {
+  const timelineEntries = timelineRowEntries(input.timelineEntries);
+  const unsettledRunId = deriveUnsettledRunId(input.latestRun ?? null, input.runningRunId ?? null);
+  const failedRunIds = failedTimelineRunIds(timelineEntries, input.latestRun ?? null);
+  const activeVisualResponseRunIds = deriveActiveVisualResponseRunIds({
+    timelineEntries,
+    unsettledRunId,
+    isWorking: input.isWorking,
+  });
+  return deriveTurnFolds({
+    timelineEntries,
+    terminalAssistantMessageIds: deriveTerminalAssistantMessageIds(timelineEntries),
+    latestRun: input.latestRun ?? null,
+    unfoldedRunIds: new Set([...activeVisualResponseRunIds, ...failedRunIds]),
+    runlessWorkActive: input.isWorking && input.runlessWorkActive === true,
+    liveSubagentEntryIds: liveSubagentCardEntryIds(timelineEntries),
+  });
+}
+
 export function deriveMessagesTimelineRows(input: {
   timelineEntries: ReadonlyArray<TimelineEntry>;
   latestRun?: TimelineLatestRun | null;
@@ -1274,9 +1303,7 @@ export function deriveMessagesTimelineRows(input: {
   /** Live bootstrap progress. Renders a stage card under the first user message. */
   worktreeSetup?: WorktreeSetupSnapshot | null;
 }): MessagesTimelineRow[] {
-  const timelineEntries = withoutSubagentDelegationRows(
-    settleSupersededReasoning(input.timelineEntries),
-  );
+  const timelineEntries = timelineRowEntries(input.timelineEntries);
   const turnDiffSummaryByAssistantMessageId = new Map<MessageId, TurnDiffSummary>();
   for (const summary of input.turnDiffSummaries) {
     if (summary.assistantMessageId) {
@@ -1940,6 +1967,24 @@ export interface MessagesTimelineRowsProjection {
   readonly rows: MessagesTimelineRow[];
 }
 
+/**
+ * The turn fold that holds an entry, keyed as `expandedRunIds` expects. Runless
+ * (imported V1) turns fold under a synthetic key, so the entry's own run id is
+ * not enough to open them.
+ */
+export function timelineEntryTurnFoldRunId(
+  input: Pick<
+    MessagesTimelineRowsInput,
+    "timelineEntries" | "latestRun" | "isWorking" | "runlessWorkActive" | "runningRunId"
+  >,
+  entryId: string,
+): RunId | null {
+  for (const fold of deriveTimelineTurnFolds(input).values()) {
+    if (fold.hiddenEntryIds.has(entryId)) return fold.runId;
+  }
+  return null;
+}
+
 function sameCheckpointSummaries(
   previous: MessagesTimelineRowsInput["turnDiffSummaries"],
   next: MessagesTimelineRowsInput["turnDiffSummaries"],
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index edb147ed1467..b27b34a53f50 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -209,6 +209,7 @@ import {
   resolveTimelineMinimapTopPercent,
   resolveWorkGroupScrollIndex,
   shouldFollowWorkGroupAppend,
+  timelineEntryTurnFoldRunId,
   toolGroupAction,
   workEntryDisplayLabel,
   workEntryReadOutput,
@@ -816,7 +817,19 @@ const ConversationTimeline = memo(function ConversationTimeline({
     });
   }, [latestRun]);
 
-  const activeFindRunId = activeFindMatch?.runId;
+  // Find the fold that hides the match: imported turns have no run id but still
+  // fold under a synthetic key, so the match's own run id cannot open them.
+  const activeFindEntryId = activeFindMatch?.entryId;
+  const activeFindRunId = useMemo(
+    () =>
+      activeFindEntryId === undefined
+        ? undefined
+        : (timelineEntryTurnFoldRunId(
+            { timelineEntries, latestRun, runningRunId, isWorking, runlessWorkActive },
+            activeFindEntryId,
+          ) ?? undefined),
+    [activeFindEntryId, timelineEntries, latestRun, runningRunId, isWorking, runlessWorkActive],
+  );
   useEffect(() => {
     if (!activeFindRunId) return;
     setExpandedRunIds((previous) =>

From 1843c75acedcfb1870a186b0b931e833ae8ac5b6 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 14:15:30 -0700
Subject: [PATCH 18/21] fix(web): find opens disclosures that were closed
 before find started

Base UI attaches its beforematch listener only while the panel is mounted,
and a closed disclosure mounts its panel only once find starts, so the
outer block of a nested match never opened.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 apps/web/src/components/ChatMarkdown.test.tsx | 15 ++++++++++++---
 apps/web/src/components/ChatMarkdown.tsx      |  7 +++++--
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/apps/web/src/components/ChatMarkdown.test.tsx b/apps/web/src/components/ChatMarkdown.test.tsx
index f8988f97fd57..08fb61eac0bb 100644
--- a/apps/web/src/components/ChatMarkdown.test.tsx
+++ b/apps/web/src/components/ChatMarkdown.test.tsx
@@ -1064,10 +1064,16 @@ it("opens a disclosure only when find selects a match inside it", async () => {
     [...container.querySelectorAll("[data-markdown-details-open]")].map((node) =>
       node.getAttribute("data-markdown-details-open"),
     );
-  function Probe({ activeOccurrence }: { activeOccurrence: number }) {
+  function Probe({
+    activeOccurrence,
+    searching = true,
+  }: {
+    activeOccurrence: number;
+    searching?: boolean;
+  }) {
     useThreadFindHighlights({
       container,
-      query: "needle",
+      query: searching ? "needle" : "",
       activeRowId: "row",
       activeOccurrence,
       onActiveRange: () => {},
@@ -1075,7 +1081,7 @@ it("opens a disclosure only when find selects a match inside it", async () => {
     return (
       <div data-timeline-row-id="row">
         <div data-thread-find-text>
-          <MarkdownFindContext value={true}>
+          <MarkdownFindContext value={searching}>
             <ChatMarkdown
               cwd={undefined}
               text={[
@@ -1092,6 +1098,9 @@ it("opens a disclosure only when find selects a match inside it", async () => {
   const frame = () =>
     act(() => new Promise<void>((resolve) => requestAnimationFrame(() => resolve())));
   try {
+    // Closed panels are unmounted until find starts, as in the app.
+    await act(() => root.render(<Probe activeOccurrence={0} searching={false} />));
+    expect(container.textContent).not.toContain("nothing here");
     await act(() => root.render(<Probe activeOccurrence={0} />));
     await frame();
     // Selecting the visible match opens nothing; the folded one is counted but not painted.
diff --git a/apps/web/src/components/ChatMarkdown.tsx b/apps/web/src/components/ChatMarkdown.tsx
index 2e154c0d952a..69a1ea03273b 100644
--- a/apps/web/src/components/ChatMarkdown.tsx
+++ b/apps/web/src/components/ChatMarkdown.tsx
@@ -691,6 +691,10 @@ function MarkdownDetails({
   const [isOpen, setIsOpen] = useState(open);
   const searching = use(MarkdownFindContext);
   const expanded = isOpen;
+  const revealForFind = useCallback(() => setIsOpen(true), []);
+  // Base UI only listens for `beforematch` on a panel mounted at its first
+  // render; a closed panel mounts later, when find starts, so listen here.
+  const findRevealRef = useFindRevealRef(revealForFind);
   const childNodes = Children.toArray(children);
   const summaryIndex = childNodes.findIndex(
     (child) => isValidElement(child) && child.type === "summary",
@@ -720,8 +724,7 @@ function MarkdownDetails({
           />
           <span>{summary}</span>
         </CollapsibleTrigger>
-        {/* Base UI opens an until-found panel on `beforematch`. */}
-        <CollapsiblePanel hiddenUntilFound={searching}>
+        <CollapsiblePanel ref={findRevealRef} hiddenUntilFound={searching}>
           <div
             className="pb-3 ps-6 text-foreground/[calc(80%+var(--appearance-contrast-boost)/5)]"
             data-markdown-details-content=""

From b46341791d38893aa8121f27c1dc11a084b789ef Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 14:56:33 -0700
Subject: [PATCH 19/21] fix(web): find bar lines up with the workspace card

The find bar now floats inside the chat canvas at the card's 12px inset,
and the card starts below it while find is open, so the two never overlap.
It uses the card's glass surface with a quiet focus border, keeps its
buttons inside the rounded ends, and closes the details popover in narrow
windows where that popover would cover it.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 apps/web/src/components/ChatView.tsx          | 22 ++++++++++-------
 apps/web/src/components/chat/ChatCanvas.tsx   | 13 +++++++++-
 .../src/components/chat/ChatCanvasContext.ts  |  2 ++
 .../src/components/chat/ThreadDetailsCard.tsx |  2 ++
 .../web/src/components/chat/ThreadFindBar.tsx | 11 +++++++--
 .../chat/threadDetailsCardLayout.test.ts      | 10 ++++++++
 .../chat/threadDetailsCardLayout.ts           | 15 ++++++++----
 apps/web/src/components/ui/input-group.tsx    | 24 +++++++++++++++++--
 8 files changed, 82 insertions(+), 17 deletions(-)

diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx
index fdcff91d2af4..393b1f85855b 100644
--- a/apps/web/src/components/ChatView.tsx
+++ b/apps/web/src/components/ChatView.tsx
@@ -1,5 +1,5 @@
 import { useThreadFind } from "./chat/useThreadFind";
-import { ThreadFindBar } from "./chat/ThreadFindBar";
+import { THREAD_FIND_BAR_RESERVED_HEIGHT, ThreadFindBar } from "./chat/ThreadFindBar";
 import { ChatCanvas } from "./chat/ChatCanvas";
 import { usageLimitRecoveryBannerItem } from "./chat/UsageLimitRecoveryBanner";
 import {
@@ -7940,6 +7940,11 @@ export default function ChatView(props: ChatViewProps) {
     content: serverProjection ?? undefined,
   });
   const { isOpen: isThreadFindActive, open: openThreadFind, close: closeThreadFind } = threadFind;
+  // The details popover hangs off the header over the find bar; opening find dismisses it.
+  useEffect(() => {
+    if (!isThreadFindActive || threadPanelPresentation !== "popover" || !activeThreadRef) return;
+    useRightPanelStore.getState().setThreadPanelOpen(activeThreadRef, "popover", false);
+  }, [activeThreadRef, isThreadFindActive, threadPanelPresentation]);
 
   useEffect(() => {
     const handler = (event: globalThis.KeyboardEvent) => {
@@ -11285,19 +11290,13 @@ export default function ChatView(props: ChatViewProps) {
               ? { onOpenProjectSettings: handleOpenDraftProjectSettings }
               : {})}
           />
-          <ThreadFindBar
-            {...threadFind.barProps}
-            onClose={() => {
-              closeThreadFind();
-              focusComposer();
-            }}
-          />
         </header>
 
         {/* Main content area with optional plan sidebar */}
         <div className="relative flex min-h-0 min-w-0 flex-1">
           {/* Chat column */}
           <ChatCanvas
+            detailsCardTopInset={isThreadFindActive ? THREAD_FIND_BAR_RESERVED_HEIGHT : 0}
             composerOverlayElement={isDraftHeroState ? null : composerOverlayElement}
             data-chat-workspace-drop-target="true"
             onDragEnter={workspaceFileDropHandlers.onDragEnter}
@@ -11305,6 +11304,13 @@ export default function ChatView(props: ChatViewProps) {
             onDragLeave={workspaceFileDropHandlers.onDragLeave}
             onDrop={workspaceFileDropHandlers.onDrop}
           >
+            <ThreadFindBar
+              {...threadFind.barProps}
+              onClose={() => {
+                closeThreadFind();
+                focusComposer();
+              }}
+            />
             {isWorkspaceFileDragActive ? (
               <div
                 className="pointer-events-none absolute inset-2 z-40 flex items-center justify-center rounded-2xl border-2 border-dashed border-primary/60 bg-primary/[0.035]"
diff --git a/apps/web/src/components/chat/ChatCanvas.tsx b/apps/web/src/components/chat/ChatCanvas.tsx
index 504db1730489..3606f6db9700 100644
--- a/apps/web/src/components/chat/ChatCanvas.tsx
+++ b/apps/web/src/components/chat/ChatCanvas.tsx
@@ -17,10 +17,12 @@ import type { PreviewMiniPlayerObstacles } from "../preview/previewMiniPlayerLay
  */
 export function ChatCanvas({
   composerOverlayElement,
+  detailsCardTopInset = 0,
   children,
   ...props
 }: Omit<ComponentProps<"div">, "className" | "style" | "ref"> & {
   composerOverlayElement: HTMLElement | null;
+  detailsCardTopInset?: number;
 }) {
   const elementRef = useRef<HTMLDivElement | null>(null);
   const widthProbeRef = useRef<HTMLDivElement | null>(null);
@@ -106,8 +108,17 @@ export function ChatCanvas({
       clearPreview,
       registerTimeline,
       reportDetailsCard,
+      detailsCardTopInset,
     };
-  }, [measurements, preview, detailsCard, reportPreview, clearPreview, reportDetailsCard]);
+  }, [
+    measurements,
+    preview,
+    detailsCard,
+    reportPreview,
+    clearPreview,
+    reportDetailsCard,
+    detailsCardTopInset,
+  ]);
   const { layout } = context;
   return (
     <ChatCanvasContext value={context}>
diff --git a/apps/web/src/components/chat/ChatCanvasContext.ts b/apps/web/src/components/chat/ChatCanvasContext.ts
index 44b91f82632a..f5fc19d6a7f0 100644
--- a/apps/web/src/components/chat/ChatCanvasContext.ts
+++ b/apps/web/src/components/chat/ChatCanvasContext.ts
@@ -11,6 +11,8 @@ export const ChatCanvasContext = createContext<{
   clearPreview: (key: string) => void;
   registerTimeline: (element: HTMLElement | null) => void;
   reportDetailsCard: (card: PreviewMiniPlayerObstacles["detailsCard"]) => void;
+  /** Height reserved above the details card, such as the open find bar. */
+  detailsCardTopInset: number;
 } | null>(null);
 
 export const useChatCanvas = () => useContext(ChatCanvasContext);
diff --git a/apps/web/src/components/chat/ThreadDetailsCard.tsx b/apps/web/src/components/chat/ThreadDetailsCard.tsx
index 74cbf60cc9ec..040c7ec81f1b 100644
--- a/apps/web/src/components/chat/ThreadDetailsCard.tsx
+++ b/apps/web/src/components/chat/ThreadDetailsCard.tsx
@@ -31,6 +31,7 @@ export function ThreadDetailsCard({
         container: canvas.container,
         lane: canvas.lane,
         frame: null,
+        topInset: canvas.detailsCardTopInset,
       })
     : null;
   const placement = canvas
@@ -39,6 +40,7 @@ export function ThreadDetailsCard({
         lane: canvas.lane,
         frame: canvas.layout.frame,
         overlapsDetailsCard: canvas.layout.overlapsDetailsCard,
+        topInset: canvas.detailsCardTopInset,
       })
     : null;
   const mode = placement ? "inline" : "popover";
diff --git a/apps/web/src/components/chat/ThreadFindBar.tsx b/apps/web/src/components/chat/ThreadFindBar.tsx
index 251845077cb2..2d94c98f0c94 100644
--- a/apps/web/src/components/chat/ThreadFindBar.tsx
+++ b/apps/web/src/components/chat/ThreadFindBar.tsx
@@ -4,6 +4,7 @@ import { Button } from "../ui/button";
 import { InputGroup, InputGroupAddon, InputGroupInput } from "../ui/input-group";
 import { cn } from "~/lib/utils";
 import { formatThreadFindCount } from "./threadFind";
+import { THREAD_DETAILS_CARD_GAP } from "./threadDetailsCardLayout";
 
 interface ThreadFindBarProps {
   readonly open: boolean;
@@ -19,6 +20,12 @@ interface ThreadFindBarProps {
   readonly onClose: () => void;
 }
 
+/**
+ * Room the open bar takes at the top of the chat canvas: its `h-9` height plus
+ * the shared 12px gap below it, so the details card starts on the same rhythm.
+ */
+export const THREAD_FIND_BAR_RESERVED_HEIGHT = 36 + THREAD_DETAILS_CARD_GAP;
+
 export function ThreadFindBar(props: ThreadFindBarProps) {
   const inputRef = useRef<HTMLInputElement | null>(null);
 
@@ -57,7 +64,7 @@ export function ThreadFindBar(props: ThreadFindBarProps) {
       role="search"
       aria-label="Find in thread"
       aria-busy={props.status === "loading"}
-      className="absolute top-[calc(100%+0.5rem)] right-0 z-40 w-[min(24rem,calc(100vw-1.5rem))] [-webkit-app-region:no-drag]"
+      className="absolute top-3 right-3 z-40 w-[min(24rem,calc(100%-1.5rem))]"
     >
       <InputGroupInput
         ref={inputRef}
@@ -72,7 +79,7 @@ export function ThreadFindBar(props: ThreadFindBarProps) {
         onChange={(event) => props.onQueryChange(event.target.value)}
         onKeyDown={handleKeyDown}
       />
-      <InputGroupAddon align="inline-end">
+      <InputGroupAddon align="inline-end" inset="pill">
         <span
           aria-live="polite"
           className={cn(
diff --git a/apps/web/src/components/chat/threadDetailsCardLayout.test.ts b/apps/web/src/components/chat/threadDetailsCardLayout.test.ts
index 165985245cd1..e7d961bc811c 100644
--- a/apps/web/src/components/chat/threadDetailsCardLayout.test.ts
+++ b/apps/web/src/components/chat/threadDetailsCardLayout.test.ts
@@ -22,6 +22,16 @@ describe("workspace card", () => {
     });
     expect(resolve(1344, 900)).toMatchObject({ x: 1052, width: 280 });
   });
+  it("starts below the open find bar, keeping the bottom inset", () => {
+    expect(
+      resolveThreadDetailsCardLayout({
+        container: { width: 1600, height: 900 },
+        lane,
+        frame: null,
+        topInset: 48,
+      }),
+    ).toEqual({ x: 1308, y: 60, width: 280, height: 828 });
+  });
   it("hides when a readable chat lane cannot fit beside it", () => {
     expect(resolve(984, 900)).toMatchObject({ x: 692 });
     expect(resolve(983, 900)).toBeNull();
diff --git a/apps/web/src/components/chat/threadDetailsCardLayout.ts b/apps/web/src/components/chat/threadDetailsCardLayout.ts
index 655aaa487064..8353a3883ba7 100644
--- a/apps/web/src/components/chat/threadDetailsCardLayout.ts
+++ b/apps/web/src/components/chat/threadDetailsCardLayout.ts
@@ -1,6 +1,9 @@
 import type { PreviewMiniPlayerFrame } from "../preview/previewMiniPlayerLayout";
 import { DETAILS_CARD_CLEARANCE } from "./chatCanvasLayout";
 
+/** Inset of the card from the canvas edges; the find bar shares it to line up. */
+export const THREAD_DETAILS_CARD_GAP = 12;
+
 export function resolveThreadDetailsCardDensity(
   height: number,
   content: { full: number; compact: number },
@@ -19,28 +22,32 @@ export function resolveThreadDetailsCardLayout({
   lane,
   frame,
   overlapsDetailsCard = false,
+  topInset = 0,
 }: {
   container: { width: number; height: number };
   lane: { padding: number; minChatWidth: number };
   frame: PreviewMiniPlayerFrame | null;
   overlapsDetailsCard?: boolean;
+  /** Space taken above the card, such as the open find bar. */
+  topInset?: number;
 }) {
-  const gap = 12;
+  const gap = THREAD_DETAILS_CARD_GAP;
   // Keep in sync with --thread-details-panel-width, which sizes the popover.
   const width = 280;
   const x = container.width - width - gap;
   if (x - DETAILS_CARD_CLEARANCE - lane.padding < lane.minChatWidth) return null;
+  const y = gap + topInset;
   // Resizing consumes the height above the player. Dragging first tries to
   // clear the full card and folds it only when there is no readable placement.
   const height =
     overlapsDetailsCard && frame && frame.x + frame.width > x - gap && frame.x < x + width + gap
-      ? Math.min(container.height - gap * 2, frame.y - gap * 2)
-      : container.height - gap * 2;
+      ? Math.min(container.height - y - gap, frame.y - y - gap)
+      : container.height - y - gap;
   if (height < 160) return null;
   return {
     x,
     width,
-    y: gap,
+    y,
     height,
   } as const;
 }
diff --git a/apps/web/src/components/ui/input-group.tsx b/apps/web/src/components/ui/input-group.tsx
index 45d4b42446c9..76eceb0bd010 100644
--- a/apps/web/src/components/ui/input-group.tsx
+++ b/apps/web/src/components/ui/input-group.tsx
@@ -21,7 +21,9 @@ const inputGroupVariants = cva(
       variant: {
         default:
           "border-input bg-background not-dark:bg-clip-padding shadow-xs/5 before:pointer-events-none before:absolute before:inset-0 before:rounded-[calc(var(--control-radius)-1px)] not-has-[input:disabled,textarea:disabled]:not-has-[input:focus-visible,textarea:focus-visible]:not-has-[input[aria-invalid],textarea[aria-invalid]]:before:shadow-[0_1px_--theme(--color-black/4%)] dark:bg-input/32 dark:not-has-[input:disabled,textarea:disabled]:not-has-[input:focus-visible,textarea:focus-visible]:not-has-[input[aria-invalid],textarea[aria-invalid]]:before:shadow-[0_-1px_--theme(--color-white/6%)]",
-        popover: "border-input bg-popover shadow-sm",
+        // Matches floating glass cards (no shadow); focus darkens the hairline instead of a ring.
+        popover:
+          "dropdown-glass rounded-2xl has-[input:focus-visible,textarea:focus-visible]:ring-0 has-[input:focus-visible,textarea:focus-visible]:border-[color-mix(in_srgb,var(--contrast-foreground)_18%,transparent)]",
         ghost:
           "border-transparent bg-transparent shadow-none hover:bg-muted/40 has-[input:focus-visible,textarea:focus-visible]:bg-background",
       },
@@ -51,7 +53,24 @@ const inputGroupAddonVariants = cva(
     defaultVariants: {
       align: "inline-start",
     },
+    compoundVariants: [
+      // Pill groups curve too tightly for buttons pulled to the edge; keep them inset.
+      {
+        align: "inline-end",
+        inset: "pill",
+        className: "has-[>button]:me-0 pe-1 [[data-size=sm]+&]:pe-1 gap-0.5",
+      },
+      {
+        align: "inline-start",
+        inset: "pill",
+        className: "has-[>button]:ms-0 ps-1 [[data-size=sm]+&]:ps-1 gap-0.5",
+      },
+    ],
     variants: {
+      inset: {
+        default: null,
+        pill: "[&_button]:rounded-full",
+      },
       align: {
         "block-end":
           "order-last w-full justify-start px-[calc(--spacing(3)-1px)] pb-[calc(--spacing(3)-1px)] [.border-t]:pt-[calc(--spacing(3)-1px)] [[data-size=sm]+&]:px-[calc(--spacing(2.5)-1px)]",
@@ -69,11 +88,12 @@ const inputGroupAddonVariants = cva(
 function InputGroupAddon({
   className,
   align = "inline-start",
+  inset,
   ...props
 }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>) {
   return (
     <div
-      className={cn(inputGroupAddonVariants({ align }), className)}
+      className={cn(inputGroupAddonVariants({ align, inset }), className)}
       data-align={align}
       data-slot="input-group-addon"
       onMouseDown={(e) => {

From fde0b4288277ea41aa61820121f5449c133c2ce9 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 15:04:09 -0700
Subject: [PATCH 20/21] fix(web): find starts inside a folded imported turn at
 the top of the view

The reading-position reader matched turn-fold rows by run id, which imported
turns lack, so a search started below a folded imported turn at the top of
the viewport. Match by the fold's own key, as revealing a match already does.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .../chat/MessagesTimeline.logic.test.ts       |  7 +++++
 .../components/chat/MessagesTimeline.logic.ts | 15 ++++++++--
 .../src/components/chat/MessagesTimeline.tsx  | 30 ++++++++++++++-----
 3 files changed, 43 insertions(+), 9 deletions(-)

diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
index 91887d866b0a..b766c745448a 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.test.ts
@@ -2359,6 +2359,13 @@ describe("deriveMessagesTimelineRows", () => {
     const foldInput = { timelineEntries, latestRun: null, isWorking: false };
     const foldRunId = timelineEntryTurnFoldRunId(foldInput, "imported-update");
     expect(foldRunId).not.toBeNull();
+    // The rendered turn-fold row carries the same key, so find can map it back.
+    const foldRow = deriveMessagesTimelineRows({
+      ...foldInput,
+      turnDiffSummaries: [],
+      supportsConversationRollback: false,
+    }).find((row) => row.kind === "turn-fold");
+    expect(foldRow?.kind === "turn-fold" ? foldRow.runId : null).toBe(foldRunId);
     expect(timelineEntryTurnFoldRunId(foldInput, "imported-answer")).toBeNull();
     const expanded = deriveMessagesTimelineRows({
       ...foldInput,
diff --git a/apps/web/src/components/chat/MessagesTimeline.logic.ts b/apps/web/src/components/chat/MessagesTimeline.logic.ts
index 5104fad424b8..4b66df25d0ea 100644
--- a/apps/web/src/components/chat/MessagesTimeline.logic.ts
+++ b/apps/web/src/components/chat/MessagesTimeline.logic.ts
@@ -2014,10 +2014,21 @@ export function timelineEntryTurnFoldRunId(
   >,
   entryId: string,
 ): RunId | null {
+  return timelineTurnFoldRunIdsByEntryId(input).get(entryId) ?? null;
+}
+
+/** Every folded entry's fold key, computed once for callers that check many entries. */
+export function timelineTurnFoldRunIdsByEntryId(
+  input: Pick<
+    MessagesTimelineRowsInput,
+    "timelineEntries" | "latestRun" | "isWorking" | "runlessWorkActive" | "runningRunId"
+  >,
+): ReadonlyMap<string, RunId> {
+  const byEntryId = new Map<string, RunId>();
   for (const fold of deriveTimelineTurnFolds(input).values()) {
-    if (fold.hiddenEntryIds.has(entryId)) return fold.runId;
+    for (const entryId of fold.hiddenEntryIds) byEntryId.set(entryId, fold.runId);
   }
-  return null;
+  return byEntryId;
 }
 
 function sameCheckpointSummaries(
diff --git a/apps/web/src/components/chat/MessagesTimeline.tsx b/apps/web/src/components/chat/MessagesTimeline.tsx
index 366a18a223b3..15682b5e6a49 100644
--- a/apps/web/src/components/chat/MessagesTimeline.tsx
+++ b/apps/web/src/components/chat/MessagesTimeline.tsx
@@ -210,6 +210,7 @@ import {
   resolveWorkGroupScrollIndex,
   shouldFollowWorkGroupAppend,
   timelineEntryTurnFoldRunId,
+  timelineTurnFoldRunIdsByEntryId,
   threadReadLabelPrefix,
   threadReadTargetId,
   threadReadTargetTitle,
@@ -1440,8 +1441,16 @@ const ConversationTimeline = memo(function ConversationTimeline({
 
   useLayoutEffect(() => {
     if (!findPositionReaderRef || !timelineViewportElement) return;
-    const read: ThreadFindPositionReader = (query) =>
-      readThreadFindPosition(
+    const read: ThreadFindPositionReader = (query) => {
+      // Imported turns fold under a synthetic key, so match folds by key, not run id.
+      const foldRunIds = timelineTurnFoldRunIdsByEntryId({
+        timelineEntries,
+        latestRun,
+        runningRunId,
+        isWorking,
+        runlessWorkActive,
+      });
+      return readThreadFindPosition(
         timelineViewportElement,
         query,
         (rowId) => {
@@ -1450,11 +1459,13 @@ const ConversationTimeline = memo(function ConversationTimeline({
             const entry = timelineEntries.find((entry) => {
               if (row.kind === "turn-fold" || row.kind === "attempt-fold") {
                 const runId =
-                  entry.kind === "message"
-                    ? entry.message.runId
-                    : entry.kind === "proposed-plan"
-                      ? entry.proposedPlan.runId
-                      : null;
+                  row.kind === "turn-fold"
+                    ? foldRunIds.get(entry.id)
+                    : entry.kind === "message"
+                      ? entry.message.runId
+                      : entry.kind === "proposed-plan"
+                        ? entry.proposedPlan.runId
+                        : null;
                 return (
                   runId === row.runId &&
                   (entry.kind !== "message" || entry.message.role === "assistant") &&
@@ -1470,6 +1481,7 @@ const ConversationTimeline = memo(function ConversationTimeline({
         },
         contentInsetEndAdjustment,
       );
+    };
     findPositionReaderRef.current = read;
     return () => {
       if (findPositionReaderRef.current === read) findPositionReaderRef.current = null;
@@ -1477,7 +1489,11 @@ const ConversationTimeline = memo(function ConversationTimeline({
   }, [
     contentInsetEndAdjustment,
     findPositionReaderRef,
+    isWorking,
+    latestRun,
     rows,
+    runlessWorkActive,
+    runningRunId,
     timelineEntries,
     timelineViewportElement,
   ]);

From 47b18f9e05b4e2d5cd85c8a9eca45561cf8de710 Mon Sep 17 00:00:00 2001
From: Julius Marminge <51714798+juliusmarminge@users.noreply.github.com>
Date: Wed, 7 Oct 2026 15:31:10 -0700
Subject: [PATCH 21/21] build: pin the shared Markdown pipeline in the pnpm
 catalog

The server counts find matches with the same remark/rehype pipeline the web
renders with. Declaring those packages in two places with separate ranges
could resolve two versions and make the counter disagree with the screen.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 apps/web/package.json        |  4 +--
 packages/shared/package.json | 22 ++++++------
 pnpm-lock.yaml               | 69 ++++++++++++++++++++++++++----------
 pnpm-workspace.yaml          | 13 +++++++
 4 files changed, 77 insertions(+), 31 deletions(-)

diff --git a/apps/web/package.json b/apps/web/package.json
index 18c096548ed8..233fe71b887c 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -55,7 +55,7 @@
     "react": "19.2.6",
     "react-dom": "19.2.6",
     "react-markdown": "^10.1.0",
-    "remark-gfm": "^4.0.1",
+    "remark-gfm": "catalog:",
     "tailwind-merge": "^3.4.0",
     "unbash": "^5.0.0",
     "zustand": "^5.0.11"
@@ -80,7 +80,7 @@
     "jsdom": "^30.0.1",
     "react-test-renderer": "19.2.6",
     "tailwindcss": "^4.0.0",
-    "unified": "^11.0.5",
+    "unified": "catalog:",
     "vite": "catalog:",
     "vite-plus": "catalog:"
   }
diff --git a/packages/shared/package.json b/packages/shared/package.json
index ee6a4f5af3cb..16cdd15924f2 100644
--- a/packages/shared/package.json
+++ b/packages/shared/package.json
@@ -466,23 +466,23 @@
     "@t3tools/contracts": "workspace:*",
     "effect": "catalog:",
     "jose": "catalog:",
-    "mdast-util-directive": "^3.1.0",
-    "micromark-extension-directive": "^4.0.0",
-    "micromark-util-character": "^2.1.1",
-    "rehype-raw": "^7.0.0",
-    "rehype-sanitize": "^6.0.0",
-    "remark-breaks": "^4.0.0",
-    "remark-gfm": "^4.0.1",
-    "remark-parse": "^11.0.0",
-    "remark-rehype": "^11.1.2",
-    "unified": "^11.0.5",
+    "mdast-util-directive": "catalog:",
+    "micromark-extension-directive": "catalog:",
+    "micromark-util-character": "catalog:",
+    "rehype-raw": "catalog:",
+    "rehype-sanitize": "catalog:",
+    "remark-breaks": "catalog:",
+    "remark-gfm": "catalog:",
+    "remark-parse": "catalog:",
+    "remark-rehype": "catalog:",
+    "unified": "catalog:",
     "yaml": "catalog:"
   },
   "devDependencies": {
     "@effect/platform-node": "catalog:",
     "@effect/vitest": "catalog:",
     "@types/node": "catalog:",
-    "micromark-util-types": "^2.0.2",
+    "micromark-util-types": "catalog:",
     "vite-plus": "catalog:"
   }
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index cf398d8cdd08..f9d32face3b1 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -30,9 +30,42 @@ catalogs:
     jose:
       specifier: 6.2.2
       version: 6.2.2
+    mdast-util-directive:
+      specifier: 3.1.0
+      version: 3.1.0
+    micromark-extension-directive:
+      specifier: 4.0.0
+      version: 4.0.0
+    micromark-util-character:
+      specifier: 2.1.1
+      version: 2.1.1
+    micromark-util-types:
+      specifier: 2.0.2
+      version: 2.0.2
+    rehype-raw:
+      specifier: 7.0.0
+      version: 7.0.0
+    rehype-sanitize:
+      specifier: 6.0.0
+      version: 6.0.0
+    remark-breaks:
+      specifier: 4.0.0
+      version: 4.0.0
+    remark-gfm:
+      specifier: 4.0.1
+      version: 4.0.1
+    remark-parse:
+      specifier: 11.0.0
+      version: 11.0.0
+    remark-rehype:
+      specifier: 11.1.2
+      version: 11.1.2
     typescript:
       specifier: 7.0.2
       version: 7.0.2
+    unified:
+      specifier: 11.0.5
+      version: 11.0.5
 
 overrides:
   '@exodus/bytes>@noble/hashes': 1.8.0
@@ -757,7 +790,7 @@ importers:
         specifier: ^10.1.0
         version: 10.1.0(@types/react@19.3.0)(react@19.2.6)
       remark-gfm:
-        specifier: ^4.0.1
+        specifier: 'catalog:'
         version: 4.0.1
       tailwind-merge:
         specifier: ^3.4.0
@@ -827,7 +860,7 @@ importers:
         specifier: 4.3.3
         version: 4.3.3
       unified:
-        specifier: ^11.0.5
+        specifier: 'catalog:'
         version: 11.0.5
       vite:
         specifier: npm:@voidzero-dev/vite-plus-core@1.0.0
@@ -1016,34 +1049,34 @@ importers:
         specifier: 'catalog:'
         version: 6.2.2
       mdast-util-directive:
-        specifier: ^3.1.0
+        specifier: 'catalog:'
         version: 3.1.0
       micromark-extension-directive:
-        specifier: ^4.0.0
+        specifier: 'catalog:'
         version: 4.0.0
       micromark-util-character:
-        specifier: ^2.1.1
+        specifier: 'catalog:'
         version: 2.1.1
       rehype-raw:
-        specifier: ^7.0.0
+        specifier: 'catalog:'
         version: 7.0.0
       rehype-sanitize:
-        specifier: ^6.0.0
+        specifier: 'catalog:'
         version: 6.0.0
       remark-breaks:
-        specifier: ^4.0.0
+        specifier: 'catalog:'
         version: 4.0.0
       remark-gfm:
-        specifier: ^4.0.1
+        specifier: 'catalog:'
         version: 4.0.1
       remark-parse:
-        specifier: ^11.0.0
+        specifier: 'catalog:'
         version: 11.0.0
       remark-rehype:
-        specifier: ^11.1.2
+        specifier: 'catalog:'
         version: 11.1.2
       unified:
-        specifier: ^11.0.5
+        specifier: 'catalog:'
         version: 11.0.5
       yaml:
         specifier: ^2.9.0
@@ -1059,7 +1092,7 @@ importers:
         specifier: 24.12.4
         version: 24.12.4
       micromark-util-types:
-        specifier: ^2.0.2
+        specifier: 'catalog:'
         version: 2.0.2
       vite-plus:
         specifier: 1.0.0
@@ -18976,7 +19009,7 @@ snapshots:
 
   hast-util-raw@9.1.0:
     dependencies:
-      '@types/hast': 3.0.4
+      '@types/hast': 3.0.5
       '@types/unist': 3.0.3
       '@ungap/structured-clone': 1.3.1
       hast-util-from-parse5: 8.0.3
@@ -18992,7 +19025,7 @@ snapshots:
 
   hast-util-sanitize@5.0.2:
     dependencies:
-      '@types/hast': 3.0.4
+      '@types/hast': 3.0.5
       '@ungap/structured-clone': 1.3.1
       unist-util-position: 5.0.0
 
@@ -21417,13 +21450,13 @@ snapshots:
 
   rehype-raw@7.0.0:
     dependencies:
-      '@types/hast': 3.0.4
+      '@types/hast': 3.0.5
       hast-util-raw: 9.1.0
       vfile: 6.0.3
 
   rehype-sanitize@6.0.0:
     dependencies:
-      '@types/hast': 3.0.4
+      '@types/hast': 3.0.5
       hast-util-sanitize: 5.0.2
 
   remark-breaks@4.0.0:
@@ -21454,7 +21487,7 @@ snapshots:
 
   remark-rehype@11.1.2:
     dependencies:
-      '@types/hast': 3.0.4
+      '@types/hast': 3.0.5
       '@types/mdast': 4.0.4
       mdast-util-to-hast: 13.2.1
       unified: 11.0.5
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 70b610959865..87c007312a71 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -56,6 +56,19 @@ catalog:
   vite-plus: 1.0.0
   ws: 8.22.0
   yaml: ^2.9.0
+  # Markdown pipeline: the server counts find matches with the same parser the
+  # web renders with, so both must resolve to one version.
+  mdast-util-directive: 3.1.0
+  micromark-extension-directive: 4.0.0
+  micromark-util-character: 2.1.1
+  micromark-util-types: 2.0.2
+  rehype-raw: 7.0.0
+  rehype-sanitize: 6.0.0
+  remark-breaks: 4.0.0
+  remark-gfm: 4.0.1
+  remark-parse: 11.0.0
+  remark-rehype: 11.1.2
+  unified: 11.0.5
 
 minimumReleaseAgeExclude:
   - expo-glass-effect@58.0.3