feat(web): find messages and plans in the current thread

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 { videoMimeType } from "@t3tools/shared/video";
 
 import type { MARKDOWN_FILE_ICON_SOURCES } from "./markdownFileIcons.generated";

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

@@ -4,7 +4,7 @@ import { type EnvironmentConnectionPhase } from "@t3tools/client-runtime/connect
 import {
   appendCodexArtifactTemplateUsePrompt,
   type CodexArtifactTemplate,
-} from "@t3tools/client-runtime/codex-artifact-templates";
+} from "@t3tools/shared/codexArtifactTemplates";
 import type {
   CodexFeedbackSubmission,
   EnvironmentThreadStatus,

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

@@ -28,7 +28,7 @@ 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 { formatAttachmentSize } from "@t3tools/client-runtime/state/attachments";
 import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";
@@ -40,7 +40,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";

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";

apps/mobile/src/features/threads/thread-search-match.tsx

@@ -1,57 +1,18 @@
 import { Platform } from "react-native";
-import type { EnvironmentThreadSearchMatch } from "@t3tools/client-runtime/state/thread-search";
+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;
   readonly selected?: boolean;
   readonly compact?: 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(

apps/server/src/auth/RpcAuthorization.ts

@@ -26,6 +26,7 @@ export const RPC_REQUIRED_SCOPES = {
   [ORCHESTRATION_WS_METHODS.getTurnDiff]: AuthOrchestrationReadScope,
   [ORCHESTRATION_WS_METHODS.getFullThreadDiff]: AuthOrchestrationReadScope,
   [ORCHESTRATION_WS_METHODS.searchThreads]: AuthOrchestrationReadScope,
+  [ORCHESTRATION_WS_METHODS.searchThread]: AuthOrchestrationReadScope,
   [ORCHESTRATION_WS_METHODS.subscribeShell]: AuthOrchestrationReadScope,
   [ORCHESTRATION_WS_METHODS.getArchivedShellSnapshot]: AuthOrchestrationReadScope,
   [ORCHESTRATION_WS_METHODS.subscribeThread]: AuthOrchestrationReadScope,

apps/server/src/checkpointing/CheckpointDiffQuery.test.ts

@@ -116,6 +116,7 @@ describe("CheckpointDiffQuery.layer", () => {
             getThreadShellById: () => Effect.succeed(Option.none()),
             getThreadDetailById: () => Effect.succeed(Option.none()),
             getThreadDetailSnapshot: () => Effect.succeed(Option.none()),
+            searchThread: () => Effect.die("searchThread is not used in this test"),
             searchThreads: () => Effect.succeed({ matches: [] }),
           }),
         ),
@@ -218,6 +219,7 @@ describe("CheckpointDiffQuery.layer", () => {
             getThreadShellById: () => Effect.succeed(Option.none()),
             getThreadDetailById: () => Effect.succeed(Option.none()),
             getThreadDetailSnapshot: () => Effect.succeed(Option.none()),
+            searchThread: () => Effect.die("searchThread is not used in this test"),
             searchThreads: () => Effect.succeed({ matches: [] }),
           }),
         ),
@@ -310,6 +312,7 @@ describe("CheckpointDiffQuery.layer", () => {
             getThreadShellById: () => Effect.succeed(Option.none()),
             getThreadDetailById: () => Effect.succeed(Option.none()),
             getThreadDetailSnapshot: () => Effect.succeed(Option.none()),
+            searchThread: () => Effect.die("searchThread is not used in this test"),
             searchThreads: () => Effect.succeed({ matches: [] }),
           }),
         ),
@@ -387,6 +390,7 @@ describe("CheckpointDiffQuery.layer", () => {
             getThreadShellById: () => Effect.succeed(Option.none()),
             getThreadDetailById: () => Effect.succeed(Option.none()),
             getThreadDetailSnapshot: () => Effect.succeed(Option.none()),
+            searchThread: () => Effect.die("searchThread is not used in this test"),
             searchThreads: () => Effect.succeed({ matches: [] }),
           }),
         ),
@@ -449,6 +453,7 @@ describe("CheckpointDiffQuery.layer", () => {
             getThreadShellById: () => Effect.succeed(Option.none()),
             getThreadDetailById: () => Effect.succeed(Option.none()),
             getThreadDetailSnapshot: () => Effect.succeed(Option.none()),
+            searchThread: () => Effect.die("searchThread is not used in this test"),
             searchThreads: () => Effect.succeed({ matches: [] }),
           }),
         ),

apps/server/src/orchestration/Layers/OrchestrationEngine.test.ts

@@ -458,6 +458,7 @@ describe("OrchestrationEngine", () => {
           getThreadShellById: () => Effect.succeed(Option.none()),
           getThreadDetailById: () => Effect.succeed(Option.none()),
           getThreadDetailSnapshot: () => Effect.succeed(Option.none()),
+          searchThread: () => Effect.die("searchThread is not used in this test"),
           searchThreads: () => Effect.succeed({ matches: [] }),
         }),
       ),

apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.test.ts

@@ -2353,6 +2353,19 @@ projectionSnapshotLayer("ProjectionSnapshotQuery", (it) => {
         )
       `;
 
+      const withinThread = yield* snapshotQuery.searchThread({
+        threadId: ThreadId.make("thread-active"),
+        query: "interim needle",
+      });
+      assert.equal(withinThread.totalMatches, 1);
+      assert.equal(withinThread.match?.source, "message");
+      assert.equal(
+        (yield* snapshotQuery.searchThread({
+          threadId: ThreadId.make("thread-active"),
+          query: "system needle",
+        })).totalMatches,
+        0,
+      );
       const literalPercent = yield* snapshotQuery.searchThreads({ query: "100%" });
       assert.deepStrictEqual(
         literalPercent.matches.map((match) => [match.threadId, match.source]),
@@ -3548,3 +3561,36 @@ projectionSnapshotLayer("ProjectionSnapshotQuery activities by kind", (it) => {
     }),
   );
 });
+
+projectionSnapshotLayer("ThreadFindLifecycle", (it) => {
+  it.effect("invalidates search when a deleted thread ID is recreated", () =>
+    Effect.gen(function* () {
+      const query = yield* ProjectionSnapshotQuery;
+      const sql = yield* SqlClient.SqlClient;
+      const threadId = ThreadId.make("recreated-search-thread");
+      const at = "2026-06-01T00:00:00.000Z";
+      yield* sql`DELETE FROM orchestration_events`;
+      yield* sql`DELETE FROM projection_state`;
+      yield* sql`INSERT INTO projection_threads (thread_id, project_id, title, model_selection_json, created_at, updated_at)
+        VALUES (${threadId}, 'project', 'Find', '{"provider":"codex","model":"gpt-5"}', ${at}, ${at})`;
+      yield* sql`INSERT INTO projection_thread_messages (message_id, thread_id, role, text, is_streaming, created_at, updated_at)
+        VALUES ('recreated-message', ${threadId}, 'assistant', 'needle', 0, ${at}, ${at})`;
+      const event = (sequence: number, type: string) => sql`INSERT INTO orchestration_events
+        (sequence, event_id, aggregate_kind, stream_id, stream_version, event_type, occurred_at, actor_kind, payload_json, metadata_json)
+        VALUES (${sequence}, ${`search-event-${sequence}`}, 'thread', ${threadId}, ${sequence}, ${type}, ${at}, 'client', '{}', '{}')`;
+      yield* event(1, "thread.message-sent");
+      for (const projector of Object.values(ORCHESTRATION_PROJECTOR_NAMES)) {
+        yield* sql`INSERT INTO projection_state (projector, last_applied_sequence, updated_at) VALUES (${projector}, 1, ${at})`;
+      }
+      assert.equal((yield* query.searchThread({ threadId, query: "needle" })).totalMatches, 1);
+      yield* event(2, "thread.deleted");
+      yield* event(3, "thread.created");
+      yield* sql`DELETE FROM projection_thread_messages WHERE thread_id = ${threadId}`;
+      yield* sql`UPDATE projection_state SET last_applied_sequence = 3`;
+      const result = yield* query.searchThread({ threadId, query: "needle" });
+      assert.equal(result.threadSequence, 3);
+      assert.equal(result.totalMatches, 0);
+      assert.equal(result.match, null);
+    }),
+  );
+});

apps/server/src/orchestration/Layers/ProjectionSnapshotQuery.ts

@@ -80,6 +80,8 @@ import {
   type ProjectionSnapshotQueryShape,
 } from "../Services/ProjectionSnapshotQuery.ts";
 
+import { makeThreadFindQuery } from "./ThreadFindQuery.ts";
+
 const decodeReadModel = Schema.decodeUnknownEffect(OrchestrationReadModel);
 const decodeShellSnapshot = Schema.decodeUnknownEffect(OrchestrationShellSnapshot);
 const decodeThread = Schema.decodeUnknownEffect(OrchestrationThread);
@@ -3757,6 +3759,27 @@ pending_approval_requests AS (
         ),
       );
 
+  // Unlike the detail subscription watermark, a search index must include lifecycle
+  // events: creating a previously deleted ID resets all of its projected messages.
+  const getThreadSearchSequence = SqlSchema.findOne({
+    Request: Schema.Struct({ threadId: ThreadId, maxSequence: Schema.Number }),
+    Result: Schema.Struct({ sequence: Schema.NullOr(Schema.Number) }),
+    execute: ({ threadId, maxSequence }) => sql`
+      SELECT MAX(sequence) AS sequence FROM orchestration_events
+      WHERE aggregate_kind = 'thread' AND stream_id = ${threadId}
+        AND sequence <= ${maxSequence}`,
+  });
+  const searchThread = yield* makeThreadFindQuery(
+    Effect.fn("ThreadFindQuery.sequence")(function* (threadId) {
+      const { snapshotSequence } = yield* getSnapshotSequence();
+      const row = yield* getThreadSearchSequence({
+        threadId,
+        maxSequence: snapshotSequence,
+      }).pipe(Effect.mapError(toPersistenceSqlError("searchThread:sequence")));
+      return row.sequence ?? 0;
+    }),
+  );
+
   return {
     getCommandReadModel,
     getUserInputActivity,
@@ -3766,6 +3789,7 @@ pending_approval_requests AS (
     getArchivedShellSnapshot,
     getDeletedWorktreeThreads,
     searchThreads,
+    searchThread,
     getSnapshotSequence,
     getCounts,
     getEventReplayStats,