diff --git a/docs/GATEWAY_FIXTURE_TESTING.md b/docs/GATEWAY_FIXTURE_TESTING.md
index cf9cd620e9..795b34f655 100644
--- a/docs/GATEWAY_FIXTURE_TESTING.md
+++ b/docs/GATEWAY_FIXTURE_TESTING.md
@@ -70,6 +70,24 @@ test container. The request-driven server and scenario live in
 `tests\OpenClaw.TestSupport\Gateway`. Repeated reads and different request
 orders work; this is deliberately not sequential packet playback.
 
+In Sessions, submit **Search active conversation messages** with Enter or
+**Search**. This calls `sessions.search` against the Gateway's active,
+configured-agent roster rather than filtering the currently loaded titles.
+Search covers all channels; **Show background** controls the Gateway's cron
+and system membership filters before its 25-message limit. Select a result's
+conversation title to open its chat (the key is a fallback when no title is supplied). Editing the query, changing background
+scope, unloading the page, or changing connection withdraws old results.
+Older Gateways, permission/connection failures, initial indexing and partial
+results have distinct presentation. Search does not edit or execute snippets.
+
+The browse fixture searches synthetic transcript text with case-insensitive
+substring matching. It does not emulate production full-text ranking or prove
+published Gateway compatibility. `GatewayFixtureProtocolTests.Search` separately
+exercises strict parameter validation, permission denial, unsupported methods,
+index readiness, membership-before-limit, archival and message provenance.
+`GatewayFixtureUiTests.TranscriptSearch_ShowsVisibleMatchesAndOpensTheMatchingConversation`
+checks visible matches and navigation through the real native Search button.
+
 ## Run the application smoke
 
 ```powershell
diff --git a/src/OpenClaw.Shared/IOperatorGatewayClient.cs b/src/OpenClaw.Shared/IOperatorGatewayClient.cs
index 1a1e3ca271..0e47817ddd 100644
--- a/src/OpenClaw.Shared/IOperatorGatewayClient.cs
+++ b/src/OpenClaw.Shared/IOperatorGatewayClient.cs
@@ -203,6 +203,9 @@ Task<SessionCreateResult> CreateSessionAsync(SessionCreateRequest request, int t
     /// <summary>List only the archived sessions (<c>sessions.list</c> with <c>archived:true</c>). Rows are detached snapshots.</summary>
     Task<SessionListResult> ListArchivedSessionsAsync(int timeoutMs = 15000)
         => Task.FromResult(new SessionListResult { IsSupported = false });
+    /// <summary>Search active transcripts across the Gateway's visible session roster.</summary>
+    Task<SessionSearchResult> SearchSessionsAsync(SessionSearchRequest request, int timeoutMs = 15000)
+        => Task.FromResult(new SessionSearchResult([], IsSupported: false));
 }
 
 public sealed record CronRunRequestResult(
diff --git a/src/OpenClaw.Shared/Sessions/SessionSearch.cs b/src/OpenClaw.Shared/Sessions/SessionSearch.cs
new file mode 100644
index 0000000000..03c7e387f4
--- /dev/null
+++ b/src/OpenClaw.Shared/Sessions/SessionSearch.cs
@@ -0,0 +1,127 @@
+using System.Text.Json;
+
+namespace OpenClaw.Shared;
+
+/// <summary>Searches active conversation transcripts, not just the locally loaded titles.</summary>
+public sealed record SessionSearchRequest(string Query, bool IncludeBackground = false)
+{
+    public const int ResultLimit = 25;
+    public const int MaximumQueryLength = 4096;
+
+    internal object ToPayload()
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(Query);
+        var query = Query.Trim();
+        if (query.Length > MaximumQueryLength)
+            throw new ArgumentOutOfRangeException(nameof(Query));
+        var scope = new Dictionary<string, object>
+        {
+            ["archived"] = false,
+            ["includeUnknown"] = true,
+            ["configuredAgentsOnly"] = true
+        };
+        if (!IncludeBackground)
+        {
+            scope["excludeCron"] = true;
+            scope["excludeSystem"] = true;
+        }
+        return new { query, limit = ResultLimit, scope };
+    }
+}
+
+public sealed record SessionSearchHit(
+    string SessionKey, string SessionId, string MessageId, string Role,
+    long Timestamp, string Snippet, double Score, string? Title = null)
+{
+    public string DisplayTitle => Title ?? SessionKey;
+}
+
+public sealed record SessionSearchResult(
+    IReadOnlyList<SessionSearchHit> Results,
+    bool Indexing = false,
+    bool Truncated = false,
+    int ArchivedTranscriptsExcluded = 0,
+    bool IsSupported = true);
+
+public partial class OpenClawGatewayClient
+{
+    public async Task<SessionSearchResult> SearchSessionsAsync(SessionSearchRequest request, int timeoutMs = 15000)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+        var parameters = request.ToPayload();
+        var epoch = SessionMutationConnectionEpoch
+            ?? throw new InvalidOperationException("Gateway handshake has not completed.");
+        JsonElement payload;
+        try
+        {
+            payload = await SendResponseRequestAsync("sessions.search", parameters, timeoutMs, epoch).ConfigureAwait(false);
+        }
+        catch (InvalidOperationException ex) when (IsUnknownMethodError(ex.Message))
+        {
+            _logger.Warn("sessions.search unsupported on gateway");
+            return new([], IsSupported: false);
+        }
+        return ParseSessionSearch(payload);
+    }
+
+    internal static SessionSearchResult ParseSessionSearch(JsonElement payload)
+    {
+        if (payload.ValueKind != JsonValueKind.Object ||
+            !payload.TryGetProperty("results", out var results) || results.ValueKind != JsonValueKind.Array ||
+            results.GetArrayLength() > SessionSearchRequest.ResultLimit)
+            throw new JsonException("Invalid sessions.search results.");
+        var titles = new Dictionary<string, string>(StringComparer.Ordinal);
+        if (payload.TryGetProperty("sessions", out var sessions))
+        {
+            if (sessions.ValueKind != JsonValueKind.Array || sessions.GetArrayLength() > SessionSearchRequest.ResultLimit)
+                throw new JsonException("Invalid sessions.search session rows.");
+            foreach (var session in sessions.EnumerateArray())
+            {
+                var key = Required(session, "key");
+                var title = OptionalTitle("label") ?? OptionalTitle("displayName") ?? key;
+                if (!titles.TryAdd(key, title))
+                    throw new JsonException("Duplicate sessions.search session row.");
+
+                string? OptionalTitle(string name) => session.TryGetProperty(name, out var value) &&
+                    value.ValueKind == JsonValueKind.String && !string.IsNullOrWhiteSpace(value.GetString())
+                        ? value.GetString() : null;
+            }
+        }
+        var hits = results.EnumerateArray().Select(row =>
+        {
+            var key = Required(row, "sessionKey");
+            var sessionId = Required(row, "sessionId");
+            var messageId = Required(row, "messageId");
+            var role = Required(row, "role");
+            if (role is not ("user" or "assistant") ||
+                !row.TryGetProperty("timestamp", out var timestamp) || timestamp.ValueKind != JsonValueKind.Number ||
+                !timestamp.TryGetInt64(out var ts) || ts < 0 ||
+                !row.TryGetProperty("snippet", out var snippet) || snippet.ValueKind != JsonValueKind.String ||
+                !row.TryGetProperty("score", out var score) || score.ValueKind != JsonValueKind.Number ||
+                !score.TryGetDouble(out var rank) || !double.IsFinite(rank))
+                throw new JsonException("Invalid sessions.search match.");
+            return new SessionSearchHit(key, sessionId, messageId, role, ts, snippet.GetString()!, rank,
+                titles.GetValueOrDefault(key));
+        }).ToArray();
+        var excluded = 0;
+        if (payload.TryGetProperty("archivedTranscriptsExcluded", out var count) &&
+            (count.ValueKind != JsonValueKind.Number || !count.TryGetInt32(out excluded) || excluded < 0))
+            throw new JsonException("Invalid sessions.search excluded count.");
+        return new(hits, OptionalFlag("indexing"), OptionalFlag("truncated"), excluded);
+
+        bool OptionalFlag(string name)
+        {
+            if (!payload.TryGetProperty(name, out var flag)) return false;
+            if (flag.ValueKind is not (JsonValueKind.True or JsonValueKind.False))
+                throw new JsonException($"Invalid sessions.search {name}.");
+            return flag.GetBoolean();
+        }
+        static string Required(JsonElement row, string name)
+        {
+            if (row.ValueKind != JsonValueKind.Object || !row.TryGetProperty(name, out var value) ||
+                value.ValueKind != JsonValueKind.String || string.IsNullOrWhiteSpace(value.GetString()))
+                throw new JsonException($"Invalid sessions.search {name}.");
+            return value.GetString()!;
+        }
+    }
+}
diff --git a/src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml b/src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml
index c32267f1a9..bbf673eef4 100644
--- a/src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml
+++ b/src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml
@@ -63,6 +63,38 @@
                     </Button>
                 </Grid>
 
+                <Grid ColumnSpacing="12">
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="*"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+                    <AutoSuggestBox x:Name="TranscriptQuery" x:Uid="SessionsPage_TranscriptQuery"
+                                    QuerySubmitted="OnTranscriptQuerySubmitted"
+                                    TextChanged="OnTranscriptQueryChanged"
+                                    AutomationProperties.AutomationId="SessionsTranscriptQuery"/>
+                    <Button Grid.Column="1" x:Uid="SessionsPage_SearchButton"
+                            Click="OnTranscriptSearchClick"
+                            AutomationProperties.AutomationId="SessionsTranscriptSubmit"/>
+                </Grid>
+                <TextBlock x:Name="TranscriptSearchStatus" TextWrapping="Wrap"
+                           Foreground="{ThemeResource TextFillColorSecondaryBrush}"
+                           AutomationProperties.LiveSetting="Polite"
+                           AutomationProperties.AutomationId="SessionsTranscriptSearchStatus"/>
+                <ListView x:Name="TranscriptSearchResults" SelectionMode="None"
+                          Visibility="Collapsed"
+                          AutomationProperties.AutomationId="SessionsTranscriptSearchResults">
+                    <ListView.ItemTemplate>
+                        <DataTemplate>
+                            <StackPanel Spacing="4" Padding="8">
+                                <Button Content="{Binding DisplayTitle}" Tag="{Binding SessionKey}"
+                                        Click="OnOpenChat"/>
+                                <TextBlock Text="{Binding Snippet}" TextWrapping="Wrap"
+                                           MaxLines="3" TextTrimming="CharacterEllipsis"/>
+                            </StackPanel>
+                        </DataTemplate>
+                    </ListView.ItemTemplate>
+                </ListView>
+
                 <InfoBar x:Uid="SessionsPage_GatewayDisconnected"
                          x:Name="ConnectionInfoBar"
                          IsOpen="False" IsClosable="False" Severity="Warning"
diff --git a/src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml.cs b/src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml.cs
index 505e7456b8..2fcf1db456 100644
--- a/src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml.cs
+++ b/src/OpenClaw.Tray.WinUI/Pages/SessionsPage.xaml.cs
@@ -31,10 +31,13 @@ public sealed partial class SessionsPage : Page
     private bool _syncingShowCompletedToggle;
     private bool _showBackgroundSessions;
     private readonly ArchivedSessionsSource _archived;
+    private readonly SessionTranscriptSearch _transcriptSearch;
 
     public SessionsPage()
     {
         InitializeComponent();
+        _transcriptSearch = new SessionTranscriptSearch(ApplyTranscriptSearch,
+            ex => new AppLogger().Warn($"[Sessions] Transcript search failed ({ex.GetType().Name})."));
         _archived = new ArchivedSessionsSource(ApplyArchivedSessions,
             ex => new AppLogger().Warn($"[Sessions] Archived sessions unavailable ({ex.GetType().Name})."));
         ArchivedSection.Header = LocalizationHelper.GetString("SessionsPage_Archived");
@@ -42,6 +45,7 @@ public SessionsPage()
         Unloaded += (_, _) =>
         {
             _unloaded = true;
+            _transcriptSearch.Clear();
             _archived.Clear();
             _refreshTimer?.Stop(); _refreshTimer = null;
             if (_appState != null) _appState.PropertyChanged -= OnAppStateChanged;
@@ -56,6 +60,7 @@ public SessionsPage()
     public void Initialize()
     {
         _unloaded = false;
+        _transcriptSearch.Clear();
         // Guard against duplicate subscriptions (NavigationCacheMode reuses page)
         if (_appState != null) _appState.PropertyChanged -= OnAppStateChanged;
         _appState = CurrentApp.AppState!;
@@ -318,6 +323,7 @@ private void OnShowCompletedToggled(object sender, RoutedEventArgs e)
     private void OnShowBackgroundToggled(object sender, RoutedEventArgs e)
     {
         _showBackgroundSessions = ShowBackgroundToggle.IsOn;
+        _transcriptSearch?.Clear();
         RebuildChannelTabs();
         ApplyFilter();
     }
@@ -331,6 +337,7 @@ private void OnAppStateChanged(object? sender, PropertyChangedEventArgs e)
                 _ = _archived.RefreshAsync(CurrentApp.GatewayClient);
                 break;
             case nameof(AppState.Status):
+                _transcriptSearch.Clear();
                 if (_appState!.Status != ConnectionStatus.Connected)
                     _archived.Clear();
                 ApplyArchivedSessions();
@@ -339,6 +346,40 @@ private void OnAppStateChanged(object? sender, PropertyChangedEventArgs e)
         }
     }
 
+    private void OnTranscriptQueryChanged(AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs args)
+        => _transcriptSearch?.Clear();
+
+    private void OnTranscriptQuerySubmitted(AutoSuggestBox sender, AutoSuggestBoxQuerySubmittedEventArgs args)
+        => RunTranscriptSearch(args.QueryText);
+
+    private void OnTranscriptSearchClick(object sender, RoutedEventArgs args)
+        => RunTranscriptSearch(TranscriptQuery.Text);
+
+    private void RunTranscriptSearch(string query)
+        => AsyncEventHandlerGuard.Run(() => _transcriptSearch.SearchAsync(CurrentApp.GatewayClient,
+            () => _unloaded ? null : CurrentApp.GatewayClient, query, _showBackgroundSessions),
+            new AppLogger(), nameof(RunTranscriptSearch));
+
+    private void ApplyTranscriptSearch()
+    {
+        var result = _transcriptSearch.Result;
+        TranscriptSearchResults.ItemsSource = result?.Results;
+        TranscriptSearchResults.Visibility = result?.Results.Count > 0 ? Visibility.Visible : Visibility.Collapsed;
+        var key = _transcriptSearch.Status switch
+        {
+            SessionSearchStatus.Loading => "SessionsPage_SearchLoading",
+            SessionSearchStatus.Unsupported => "SessionsPage_SearchUnsupported",
+            SessionSearchStatus.Failed => "SessionsPage_SearchFailed",
+            SessionSearchStatus.Ready when result?.Indexing == true => "SessionsPage_SearchIndexing",
+            SessionSearchStatus.Ready when result?.Truncated == true || result?.ArchivedTranscriptsExcluded > 0
+                => "SessionsPage_SearchPartial",
+            SessionSearchStatus.Ready => "SessionsPage_SearchReady",
+            _ => null
+        };
+        TranscriptSearchStatus.Text = key is null ? "" :
+            LocalizationHelper.Format(key, result?.Results.Count ?? 0);
+    }
+
     private void OnArchivedExpanding(Expander sender, ExpanderExpandingEventArgs args)
     {
         _archived.SetExpanded(true);
diff --git a/src/OpenClaw.Tray.WinUI/Services/SessionTranscriptSearch.cs b/src/OpenClaw.Tray.WinUI/Services/SessionTranscriptSearch.cs
new file mode 100644
index 0000000000..de80113918
--- /dev/null
+++ b/src/OpenClaw.Tray.WinUI/Services/SessionTranscriptSearch.cs
@@ -0,0 +1,56 @@
+using System.Text.Json;
+using OpenClaw.Shared;
+
+namespace OpenClawTray.Services;
+
+internal enum SessionSearchStatus { Idle, Loading, Ready, Unsupported, Failed }
+
+/// <summary>UI-thread-owned search. Query, connection and view changes withdraw old results.</summary>
+internal sealed class SessionTranscriptSearch(Action changed, Action<Exception> reportFailure)
+{
+    private int _generation;
+    public SessionSearchStatus Status { get; private set; }
+    public SessionSearchResult? Result { get; private set; }
+
+    public void Clear()
+    {
+        _generation++;
+        Status = SessionSearchStatus.Idle;
+        Result = null;
+        changed();
+    }
+
+    public async Task SearchAsync(IOperatorGatewayClient? client, Func<IOperatorGatewayClient?> currentClient,
+        string query, bool includeBackground)
+    {
+        Clear();
+        if (string.IsNullOrWhiteSpace(query)) return;
+        if (client is not { IsConnectedToGateway: true } || client.SessionMutationConnectionEpoch is not { } epoch)
+        {
+            Status = SessionSearchStatus.Failed;
+            changed();
+            return;
+        }
+        var generation = _generation;
+        Status = SessionSearchStatus.Loading;
+        changed();
+        try
+        {
+            var result = await client.SearchSessionsAsync(new(query, includeBackground));
+            if (!IsCurrent()) return;
+            Result = result;
+            Status = result.IsSupported ? SessionSearchStatus.Ready : SessionSearchStatus.Unsupported;
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or TimeoutException or
+            OperationCanceledException or JsonException or ArgumentException)
+        {
+            if (!IsCurrent()) return;
+            Status = SessionSearchStatus.Failed;
+            reportFailure(ex);
+        }
+        changed();
+
+        bool IsCurrent() => generation == _generation && ReferenceEquals(client, currentClient()) &&
+            client.IsConnectedToGateway && client.SessionMutationConnectionEpoch == epoch;
+    }
+}
diff --git a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw
index 4f494967a6..d77ae50337 100644
--- a/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw
+++ b/src/OpenClaw.Tray.WinUI/Strings/en-us/Resources.resw
@@ -1,5 +1,14 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
+  <data name="SessionsPage_SearchButton.Content" xml:space="preserve"><value>Search</value></data>
+  <data name="SessionsPage_TranscriptQuery.PlaceholderText" xml:space="preserve"><value>Search active conversation messages. Press Enter.</value></data>
+  <data name="SessionsPage_TranscriptQuery.AutomationProperties.Name" xml:space="preserve"><value>Search active conversation messages</value></data>
+  <data name="SessionsPage_SearchLoading" xml:space="preserve"><value>Searching conversation messages...</value></data>
+  <data name="SessionsPage_SearchUnsupported" xml:space="preserve"><value>This Gateway does not support transcript search.</value></data>
+  <data name="SessionsPage_SearchFailed" xml:space="preserve"><value>Search failed. Check the Gateway connection and submit the search again (maximum 4096 characters).</value></data>
+  <data name="SessionsPage_SearchIndexing" xml:space="preserve"><value>The Gateway is still indexing messages. Submit the search again for updated results.</value></data>
+  <data name="SessionsPage_SearchPartial" xml:space="preserve"><value>Some matches are not shown. Narrow the query to see more results. Archived transcripts may be excluded.</value></data>
+  <data name="SessionsPage_SearchReady" xml:space="preserve"><value>Search complete: {0} message matches. Select a conversation to open it.</value></data>
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:element name="root" msdata:IsDataSet="true">
       <xsd:complexType>
diff --git a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw
index 3431232a7e..c8d190804b 100644
--- a/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw
+++ b/src/OpenClaw.Tray.WinUI/Strings/fr-fr/Resources.resw
@@ -1,5 +1,14 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <data name="SessionsPage_SearchButton.Content" xml:space="preserve"><value>Rechercher</value></data>
+  <data name="SessionsPage_TranscriptQuery.PlaceholderText" xml:space="preserve"><value>Rechercher dans les conversations actives. Appuyez sur Entrée.</value></data>
+  <data name="SessionsPage_TranscriptQuery.AutomationProperties.Name" xml:space="preserve"><value>Rechercher dans les messages des conversations actives</value></data>
+  <data name="SessionsPage_SearchLoading" xml:space="preserve"><value>Recherche dans les messages...</value></data>
+  <data name="SessionsPage_SearchUnsupported" xml:space="preserve"><value>Cette passerelle ne prend pas en charge la recherche dans les messages.</value></data>
+  <data name="SessionsPage_SearchFailed" xml:space="preserve"><value>Échec de la recherche. Vérifiez la connexion à la passerelle et relancez la recherche (4096 caractères maximum).</value></data>
+  <data name="SessionsPage_SearchIndexing" xml:space="preserve"><value>La passerelle indexe encore les messages. Relancez la recherche pour actualiser les résultats.</value></data>
+  <data name="SessionsPage_SearchPartial" xml:space="preserve"><value>Certains résultats ne sont pas affichés. Précisez la recherche. Les messages archivés peuvent être exclus.</value></data>
+  <data name="SessionsPage_SearchReady" xml:space="preserve"><value>Recherche terminée : {0} messages trouvés. Sélectionnez une conversation pour l'ouvrir.</value></data>
   <xs:schema id="root">
     <xs:element name="root" ns1:IsDataSet="true">
       <xs:complexType>
diff --git a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw
index f4928c8caf..3d7e71db11 100644
--- a/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw
+++ b/src/OpenClaw.Tray.WinUI/Strings/nl-nl/Resources.resw
@@ -1,5 +1,14 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <data name="SessionsPage_SearchButton.Content" xml:space="preserve"><value>Zoeken</value></data>
+  <data name="SessionsPage_TranscriptQuery.PlaceholderText" xml:space="preserve"><value>Zoek in actieve gespreksberichten. Druk op Enter.</value></data>
+  <data name="SessionsPage_TranscriptQuery.AutomationProperties.Name" xml:space="preserve"><value>Zoek in actieve gespreksberichten</value></data>
+  <data name="SessionsPage_SearchLoading" xml:space="preserve"><value>Gespreksberichten doorzoeken...</value></data>
+  <data name="SessionsPage_SearchUnsupported" xml:space="preserve"><value>Deze gateway ondersteunt het doorzoeken van berichten niet.</value></data>
+  <data name="SessionsPage_SearchFailed" xml:space="preserve"><value>Zoeken mislukt. Controleer de gatewayverbinding en zoek opnieuw (maximaal 4096 tekens).</value></data>
+  <data name="SessionsPage_SearchIndexing" xml:space="preserve"><value>De gateway indexeert nog berichten. Zoek opnieuw voor bijgewerkte resultaten.</value></data>
+  <data name="SessionsPage_SearchPartial" xml:space="preserve"><value>Sommige resultaten worden niet getoond. Verfijn de zoekopdracht. Gearchiveerde berichten kunnen zijn uitgesloten.</value></data>
+  <data name="SessionsPage_SearchReady" xml:space="preserve"><value>Zoeken voltooid: {0} overeenkomende berichten. Selecteer een gesprek om het te openen.</value></data>
   <xs:schema id="root">
     <xs:element name="root" ns1:IsDataSet="true">
       <xs:complexType>
diff --git a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw
index 9e54d1ab3b..d0790ca7c9 100644
--- a/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw
+++ b/src/OpenClaw.Tray.WinUI/Strings/pt-br/Resources.resw
@@ -1,5 +1,14 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root>
+  <data name="SessionsPage_SearchButton.Content" xml:space="preserve"><value>Pesquisar</value></data>
+  <data name="SessionsPage_TranscriptQuery.PlaceholderText" xml:space="preserve"><value>Pesquisar mensagens de conversas ativas. Pressione Enter.</value></data>
+  <data name="SessionsPage_TranscriptQuery.AutomationProperties.Name" xml:space="preserve"><value>Pesquisar mensagens de conversas ativas</value></data>
+  <data name="SessionsPage_SearchLoading" xml:space="preserve"><value>Pesquisando mensagens...</value></data>
+  <data name="SessionsPage_SearchUnsupported" xml:space="preserve"><value>Este Gateway não oferece pesquisa nas mensagens.</value></data>
+  <data name="SessionsPage_SearchFailed" xml:space="preserve"><value>A pesquisa falhou. Verifique a conexão com o Gateway e pesquise novamente (máximo de 4096 caracteres).</value></data>
+  <data name="SessionsPage_SearchIndexing" xml:space="preserve"><value>O Gateway ainda está indexando mensagens. Pesquise novamente para atualizar os resultados.</value></data>
+  <data name="SessionsPage_SearchPartial" xml:space="preserve"><value>Alguns resultados não são exibidos. Refine a pesquisa. Mensagens arquivadas podem estar excluídas.</value></data>
+  <data name="SessionsPage_SearchReady" xml:space="preserve"><value>Pesquisa concluída: {0} mensagens encontradas. Selecione uma conversa para abri-la.</value></data>
   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
     <xsd:element name="root" msdata:IsDataSet="true">
       <xsd:complexType>
diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw
index 052ea530a0..46df52aa1e 100644
--- a/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw
+++ b/src/OpenClaw.Tray.WinUI/Strings/zh-cn/Resources.resw
@@ -1,5 +1,14 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <data name="SessionsPage_SearchButton.Content" xml:space="preserve"><value>搜索</value></data>
+  <data name="SessionsPage_TranscriptQuery.PlaceholderText" xml:space="preserve"><value>搜索活跃会话消息。按 Enter 键搜索。</value></data>
+  <data name="SessionsPage_TranscriptQuery.AutomationProperties.Name" xml:space="preserve"><value>搜索活跃会话消息</value></data>
+  <data name="SessionsPage_SearchLoading" xml:space="preserve"><value>正在搜索会话消息...</value></data>
+  <data name="SessionsPage_SearchUnsupported" xml:space="preserve"><value>此网关不支持消息记录搜索。</value></data>
+  <data name="SessionsPage_SearchFailed" xml:space="preserve"><value>搜索失败。请检查网关连接并重新搜索（最多 4096 个字符）。</value></data>
+  <data name="SessionsPage_SearchIndexing" xml:space="preserve"><value>网关仍在为消息建立索引。请重新搜索以更新结果。</value></data>
+  <data name="SessionsPage_SearchPartial" xml:space="preserve"><value>部分匹配结果未显示。请缩小搜索范围。已归档的消息记录可能被排除。</value></data>
+  <data name="SessionsPage_SearchReady" xml:space="preserve"><value>搜索完成：找到 {0} 条匹配消息。选择会话即可打开。</value></data>
   <xs:schema id="root">
     <xs:element name="root" ns1:IsDataSet="true">
       <xs:complexType>
diff --git a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw
index 55aeb5bdba..58544cb5bd 100644
--- a/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw
+++ b/src/OpenClaw.Tray.WinUI/Strings/zh-tw/Resources.resw
@@ -1,5 +1,14 @@
 <?xml version="1.0" encoding="utf-8"?>
 <root xmlns:ns1="urn:schemas-microsoft-com:xml-msdata" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <data name="SessionsPage_SearchButton.Content" xml:space="preserve"><value>搜尋</value></data>
+  <data name="SessionsPage_TranscriptQuery.PlaceholderText" xml:space="preserve"><value>搜尋使用中對話的訊息。按 Enter 鍵搜尋。</value></data>
+  <data name="SessionsPage_TranscriptQuery.AutomationProperties.Name" xml:space="preserve"><value>搜尋使用中對話的訊息</value></data>
+  <data name="SessionsPage_SearchLoading" xml:space="preserve"><value>正在搜尋對話訊息...</value></data>
+  <data name="SessionsPage_SearchUnsupported" xml:space="preserve"><value>此閘道不支援訊息記錄搜尋。</value></data>
+  <data name="SessionsPage_SearchFailed" xml:space="preserve"><value>搜尋失敗。請檢查閘道連線並重新搜尋（最多 4096 個字元）。</value></data>
+  <data name="SessionsPage_SearchIndexing" xml:space="preserve"><value>閘道仍在為訊息建立索引。請重新搜尋以更新結果。</value></data>
+  <data name="SessionsPage_SearchPartial" xml:space="preserve"><value>部分相符結果未顯示。請縮小搜尋範圍。已封存的訊息記錄可能被排除。</value></data>
+  <data name="SessionsPage_SearchReady" xml:space="preserve"><value>搜尋完成：找到 {0} 則相符訊息。選取對話即可開啟。</value></data>
   <xs:schema id="root">
     <xs:element name="root" ns1:IsDataSet="true">
       <xs:complexType>
diff --git a/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.Search.cs b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.Search.cs
new file mode 100644
index 0000000000..7ed1ca702d
--- /dev/null
+++ b/tests/OpenClaw.Shared.Tests/GatewayFixtureProtocolTests.Search.cs
@@ -0,0 +1,107 @@
+using OpenClaw.Shared;
+using OpenClaw.TestSupport.Gateway;
+using Xunit;
+
+namespace OpenClaw.Shared.Tests;
+
+public sealed partial class GatewayFixtureProtocolTests
+{
+    [Theory]
+    [InlineData(TranscriptSearchFixtureMode.Unsupported)]
+    [InlineData(TranscriptSearchFixtureMode.Forbidden)]
+    [InlineData(TranscriptSearchFixtureMode.Indexing)]
+    public async Task TranscriptSearch_CompatibilityPermissionAndIndexReadinessStayDistinct(TranscriptSearchFixtureMode mode)
+    {
+        var token = CreateToken();
+        await using var server = await FixtureGatewayServer.StartAsync(GatewayScenario.CreateTranscriptSearch(mode), token);
+        await using var connected = await ConnectedClient.OpenAsync(server, token, expectedSessionCount: 7);
+        if (mode == TranscriptSearchFixtureMode.Forbidden)
+        {
+            var error = await Assert.ThrowsAsync<InvalidOperationException>(() =>
+                connected.Client.SearchSessionsAsync(new("lighthouse")));
+            Assert.Contains("operator.read", error.Message);
+        }
+        else
+        {
+            var result = await connected.Client.SearchSessionsAsync(new("lighthouse"));
+            Assert.Equal(mode != TranscriptSearchFixtureMode.Unsupported, result.IsSupported);
+            Assert.Equal(mode == TranscriptSearchFixtureMode.Indexing, result.Indexing);
+        }
+        Assert.Empty(server.UnexpectedRequests);
+    }
+
+    [Fact]
+    public async Task TranscriptSearch_RealClientFindsMessagesWithDistinctProvenance()
+    {
+        var token = CreateToken();
+        await using var server = await FixtureGatewayServer.StartAsync(GatewayScenario.CreateBrowse(), token);
+        await using var connected = await ConnectedClient.OpenAsync(server, token);
+        var result = await connected.Client.SearchSessionsAsync(new("FIXTURE RESEARCH:"));
+        Assert.True(result.IsSupported);
+        Assert.Equal(2, result.Results.Count);
+        Assert.All(result.Results, hit =>
+        {
+            Assert.Equal("agent:research:fixture-other", hit.SessionKey);
+            Assert.Equal("00000000-0000-4000-8000-000000000003", hit.SessionId);
+            Assert.Equal("assistant", hit.Role);
+            Assert.Equal("Fixture: research conversation", hit.DisplayTitle);
+            Assert.Equal("FIXTURE RESEARCH: the violet compass points north.", hit.Snippet);
+        });
+        Assert.Equal("fixture-shared-002", result.Results[0].MessageId);
+        Assert.Equal("00000000-0000-4000-8000-000000000003-message-004", result.Results[1].MessageId);
+        Assert.True(result.Results[0].Timestamp < result.Results[1].Timestamp);
+        Assert.Empty((await connected.Client.SearchSessionsAsync(new("no-such-fixture-message"))).Results);
+        Assert.Contains(server.Requests, r => r.Method == "sessions.search" && r.Outcome == "ok");
+        Assert.Empty(server.UnexpectedRequests);
+    }
+
+    [Fact]
+    public async Task TranscriptSearch_FiltersMembershipBeforeLimitAndReflectsArchival()
+    {
+        var token = CreateToken();
+        await using var server = await FixtureGatewayServer.StartAsync(GatewayScenario.CreateTranscriptSearch(), token);
+        await using var connected = await ConnectedClient.OpenAsync(server, token, expectedSessionCount: 7);
+        var client = connected.Client;
+        var visible = await client.SearchSessionsAsync(new("lighthouse"));
+        Assert.Equal("agent:main:main", Assert.Single(visible.Results).SessionKey);
+        Assert.False(visible.Truncated);
+        var background = await client.SearchSessionsAsync(new("lighthouse", IncludeBackground: true));
+        Assert.Equal(25, background.Results.Count);
+        Assert.True(background.Truncated);
+        Assert.All(background.Results, hit => Assert.Equal("agent:main:cron:fixture-search", hit.SessionKey));
+
+        await client.SendWizardRequestAsync("sessions.patch",
+            new { key = GatewayScenario.OtherSessionKey, archived = true });
+        Assert.Empty((await client.SearchSessionsAsync(new("FIXTURE RESEARCH:"))).Results);
+        await client.SendWizardRequestAsync("sessions.patch",
+            new { key = GatewayScenario.OtherSessionKey, archived = false });
+        Assert.Equal(2, (await client.SearchSessionsAsync(new("FIXTURE RESEARCH:"))).Results.Count);
+        Assert.Empty(server.UnexpectedRequests);
+    }
+
+    [Theory]
+    [InlineData("""{"query":"lighthouse","scope":{},"limit":26}""")]
+    [InlineData("""{"query":"lighthouse","scope":{"excludeCron":"yes"}}""")]
+    [InlineData("""{"query":"lighthouse","scope":{},"sessionKeys":["agent:main:main"]}""")]
+    public async Task TranscriptSearch_FixtureRejectsUnsupportedOrInvalidContracts(string json)
+    {
+        var token = CreateToken();
+        await using var server = await FixtureGatewayServer.StartAsync(GatewayScenario.CreateBrowse(), token);
+        await using var connected = await ConnectedClient.OpenAsync(server, token);
+        using var parameters = System.Text.Json.JsonDocument.Parse(json);
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            connected.Client.SendWizardRequestAsync("sessions.search", parameters.RootElement));
+        Assert.Empty(server.UnexpectedRequests);
+    }
+
+    [Fact]
+    public async Task TranscriptSearch_BeforeConnectDoesNotReachWire()
+    {
+        var token = CreateToken();
+        await using var server = await FixtureGatewayServer.StartAsync(GatewayScenario.CreateBrowse(), token);
+        using var directory = new OpenClaw.TestSupport.TempDirectory();
+        using var client = new OpenClawGatewayClient(server.Endpoint.ToString(), token, identityPath: directory.Path);
+        await Assert.ThrowsAsync<InvalidOperationException>(() => client.SearchSessionsAsync(new("lighthouse")));
+        Assert.DoesNotContain(server.Requests, r => r.Method == "sessions.search");
+    }
+}
diff --git a/tests/OpenClaw.Shared.Tests/SessionSearchTests.cs b/tests/OpenClaw.Shared.Tests/SessionSearchTests.cs
new file mode 100644
index 0000000000..ed762e49e4
--- /dev/null
+++ b/tests/OpenClaw.Shared.Tests/SessionSearchTests.cs
@@ -0,0 +1,116 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using OpenClaw.Shared;
+using Xunit;
+
+namespace OpenClaw.Shared.Tests;
+
+public sealed class SessionSearchTests
+{
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Payload_SearchesVisibleRosterBeforeLimit_NotLoadedKeysOrTitleSearch(bool background)
+    {
+        var payload = JsonSerializer.SerializeToElement(new SessionSearchRequest("  lighthouse  ", background).ToPayload());
+        Assert.Equal("lighthouse", payload.GetProperty("query").GetString());
+        Assert.Equal(25, payload.GetProperty("limit").GetInt32());
+        Assert.False(payload.TryGetProperty("sessionKeys", out _));
+        var scope = payload.GetProperty("scope");
+        Assert.False(scope.GetProperty("archived").GetBoolean());
+        Assert.True(scope.GetProperty("includeUnknown").GetBoolean());
+        Assert.True(scope.GetProperty("configuredAgentsOnly").GetBoolean());
+        Assert.False(scope.TryGetProperty("search", out _));
+        Assert.False(scope.TryGetProperty("limit", out _));
+        Assert.Equal(!background, scope.TryGetProperty("excludeCron", out _));
+        Assert.Equal(!background, scope.TryGetProperty("excludeSystem", out _));
+        if (!background)
+        {
+            Assert.True(scope.GetProperty("excludeCron").GetBoolean());
+            Assert.True(scope.GetProperty("excludeSystem").GetBoolean());
+        }
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(" ")]
+    public void EmptyQueriesAreRejected(string query)
+        => Assert.Throws<ArgumentException>(() => new SessionSearchRequest(query).ToPayload());
+
+    [Fact]
+    public void MaximumQueryLengthIsEnforced()
+    {
+        _ = new SessionSearchRequest(new string('x', 4096)).ToPayload();
+        Assert.Throws<ArgumentOutOfRangeException>(() => new SessionSearchRequest(new string('x', 4097)).ToPayload());
+    }
+
+    [Theory]
+    [InlineData("""{"key":"key","label":"Human label","displayName":"Display"}""", "Human label")]
+    [InlineData("""{"key":"key","displayName":"Display"}""", "Display")]
+    [InlineData("""{"key":"key","label":"  "}""", "key")]
+    public void ScopedSessionRowsSupplyHumanTitleWithoutChangingNavigationKey(string session, string expected)
+    {
+        using var doc = JsonDocument.Parse("""
+            {"results":[{"sessionKey":"key","sessionId":"session","messageId":"message",
+             "role":"user","timestamp":1,"snippet":"text","score":1}],
+             "sessions":[
+            """ + session + "]}");
+        var hit = Assert.Single(OpenClawGatewayClient.ParseSessionSearch(doc.RootElement).Results);
+        Assert.Equal(expected, hit.DisplayTitle);
+        Assert.Equal("key", hit.SessionKey);
+    }
+
+    [Fact]
+    public void ResponsePreservesProvenanceFlagsAndUntrustedSnippetAsData()
+    {
+        using var doc = JsonDocument.Parse("""
+            {"results":[{"sessionKey":"agent:research:other","sessionId":"session-1","messageId":"message-7",
+             "role":"assistant","timestamp":1790000000000,"snippet":"<script>not executed</script>","score":0.75}],
+             "indexing":true,"truncated":true,"archivedTranscriptsExcluded":3}
+            """);
+        var result = OpenClawGatewayClient.ParseSessionSearch(doc.RootElement);
+        var hit = Assert.Single(result.Results);
+        Assert.Equal("agent:research:other", hit.SessionKey);
+        Assert.Equal("session-1", hit.SessionId);
+        Assert.Equal("message-7", hit.MessageId);
+        Assert.Equal("assistant", hit.Role);
+        Assert.Equal(1790000000000, hit.Timestamp);
+        Assert.Equal("<script>not executed</script>", hit.Snippet);
+        Assert.Equal(0.75, hit.Score);
+        Assert.True(result.Indexing);
+        Assert.True(result.Truncated);
+        Assert.Equal(3, result.ArchivedTranscriptsExcluded);
+    }
+
+    [Theory]
+    [InlineData("""{"results":null}""")]
+    [InlineData("""{"results":[{}]}""")]
+    [InlineData("""{"results":[],"indexing":"true"}""")]
+    [InlineData("""{"results":[],"archivedTranscriptsExcluded":-1}""")]
+    [InlineData("""{"results":[],"archivedTranscriptsExcluded":"1"}""")]
+    [InlineData("""{"results":[],"sessions":{}}""")]
+    [InlineData("""{"results":[],"sessions":[{"key":"duplicate"},{"key":"duplicate"}]}""")]
+    public void MalformedResponsesNeverBecomeEmptySuccess(string json)
+    {
+        using var doc = JsonDocument.Parse(json);
+        Assert.Throws<JsonException>(() => OpenClawGatewayClient.ParseSessionSearch(doc.RootElement));
+    }
+
+    [Theory]
+    [InlineData("role", "\"system\"")]
+    [InlineData("timestamp", "-1")]
+    [InlineData("timestamp", "\"1\"")]
+    [InlineData("score", "\"1\"")]
+    [InlineData("snippet", "null")]
+    [InlineData("messageId", "\"\"")]
+    public void InvalidMatchIsRejected(string field, string value)
+    {
+        var row = JsonNode.Parse("""
+            {"sessionKey":"agent:main:main","sessionId":"session-1","messageId":"message-1",
+             "role":"user","timestamp":1,"snippet":"text","score":1}
+            """)!.AsObject();
+        row[field] = JsonNode.Parse(value);
+        var response = JsonSerializer.SerializeToElement(new { results = new[] { row } });
+        Assert.Throws<JsonException>(() => OpenClawGatewayClient.ParseSessionSearch(response));
+    }
+}
diff --git a/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.Search.cs b/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.Search.cs
new file mode 100644
index 0000000000..a631b3d1c1
--- /dev/null
+++ b/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.Search.cs
@@ -0,0 +1,83 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace OpenClaw.TestSupport.Gateway;
+
+public enum TranscriptSearchFixtureMode { Ready, Unsupported, Forbidden, Indexing }
+
+public sealed partial class GatewayScenario
+{
+    /// <summary>Hidden matches outnumber the result cap, exercising membership before limiting.</summary>
+    public static GatewayScenario CreateTranscriptSearch(TranscriptSearchFixtureMode mode = TranscriptSearchFixtureMode.Ready)
+    {
+        var browse = CreateBrowse(allowSessionMutations: true);
+        var extra = new[] { "cron", "system" }.Select((classification, index) =>
+        {
+            var session = CreateSession($"agent:main:{classification}:fixture-search",
+                $"Fixture {classification}", "main", "browse", index + 8,
+                Enumerable.Repeat("Synthetic lighthouse background match.", 30).ToArray());
+            var row = JsonNode.Parse(session.Row.GetRawText())!.AsObject();
+            row["classification"] = classification;
+            row["isBackground"] = true;
+            return session with { Row = JsonSerializer.SerializeToElement(row) };
+        });
+        return new([.. browse._sessions, .. extra], browse._reads, allowSessionMutations: true, transcriptSearchMode: mode);
+    }
+
+    private object SearchTranscripts(JsonElement p)
+    {
+        if (_transcriptSearchMode == TranscriptSearchFixtureMode.Unsupported)
+            throw new FixtureRequestException("METHOD_NOT_FOUND", "Unknown method: sessions.search.");
+        if (_transcriptSearchMode == TranscriptSearchFixtureMode.Forbidden)
+            throw new FixtureRequestException("FORBIDDEN", "Missing scope: operator.read.");
+        // Deliberately bounded fixture support for the native scope contract, not a catch-all search service.
+        ValidateProperties(p, "query", "scope", "limit");
+        var query = RequiredString(p, "query");
+        if (query.Length > 4096)
+            throw new FixtureRequestException("INVALID_PARAMS", "query exceeds the search limit.");
+        var limit = PositiveInt(p, "limit", 25);
+        if (limit > 25 || !p.TryGetProperty("scope", out var scope))
+            throw new FixtureRequestException("INVALID_PARAMS", "Expected a bounded scope search.");
+        ValidateProperties(scope, "archived", "includeUnknown", "configuredAgentsOnly", "excludeCron", "excludeSystem");
+        var archived = OptionalBoolean(scope, "archived") ?? false;
+        _ = OptionalBoolean(scope, "includeUnknown");
+        _ = OptionalBoolean(scope, "configuredAgentsOnly");
+        var excludeCron = OptionalBoolean(scope, "excludeCron") ?? false;
+        var excludeSystem = OptionalBoolean(scope, "excludeSystem") ?? false;
+        lock (_sessionChanges)
+        {
+            var matches = _sessions.Where(session =>
+            {
+                if (_sessionChanges.TryGetValue(session.Key, out var changed) && changed is null) return false;
+                var row = changed is null ? session.Row : JsonSerializer.SerializeToElement(changed);
+                var isArchived = row.TryGetProperty("archived", out var a) && a.ValueKind == JsonValueKind.True;
+                var classification = row.TryGetProperty("classification", out var c) ? c.GetString() : null;
+                return isArchived == archived && !(excludeCron && classification == "cron") &&
+                    !(excludeSystem && classification == "system");
+            }).SelectMany(session => session.Messages.Select((message, index) => new { session, message, index }))
+                .Where(match => match.message.GetProperty("role").GetString() is "user" or "assistant" &&
+                    match.session.Texts[match.index].Contains(query, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(match => match.session.Key, StringComparer.Ordinal).ThenBy(match => match.index)
+                .ToArray();
+            return new
+            {
+                results = matches.Take(limit).Select(match => new
+                {
+                    sessionKey = match.session.Key,
+                    sessionId = match.session.Id,
+                    messageId = match.message.GetProperty("__openclaw").GetProperty("id").GetString(),
+                    role = match.message.GetProperty("role").GetString(),
+                    timestamp = match.message.GetProperty("timestamp").GetInt64(),
+                    snippet = match.session.Texts[match.index],
+                    score = 1.0
+                }).ToArray(),
+                sessions = matches.Take(limit).Select(match => match.session).DistinctBy(session => session.Key)
+                    .Select(session => _sessionChanges.TryGetValue(session.Key, out var changed) && changed is not null
+                        ? JsonSerializer.SerializeToElement(changed) : session.Row).ToArray(),
+                indexing = _transcriptSearchMode == TranscriptSearchFixtureMode.Indexing,
+                truncated = matches.Length > limit,
+                archivedTranscriptsExcluded = 0
+            };
+        }
+    }
+}
diff --git a/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs b/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs
index ea891cafb2..e42d16de57 100644
--- a/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs
+++ b/tests/OpenClaw.TestSupport/Gateway/GatewayScenario.cs
@@ -55,6 +55,7 @@ public sealed partial class GatewayScenario
     private readonly bool _publishedModelCatalog;
     private readonly bool _allowSessionMutations;
     private readonly bool _allowChatSend;
+    private readonly TranscriptSearchFixtureMode _transcriptSearchMode;
     public bool IsInteractive { get; }
     private readonly ContextUsageFixture? _contextUsage;
     private readonly Dictionary<string, JsonObject?> _sessionChanges = new(StringComparer.Ordinal);
@@ -76,7 +77,8 @@ public sealed partial class GatewayScenario
     private GatewayScenario(Session[] sessions, IReadOnlyDictionary<string, JsonElement> reads,
         Func<string, JsonElement, object>? setup = null, bool advertiseSetup = true, bool allowAgentCreation = false,
         bool allowSessionMutations = false, bool allowChatSend = false, JsonObject[]? cronJobs = null,
-        bool interactive = false, ContextUsageFixture? contextUsage = null, bool publishedModelCatalog = false)
+        bool interactive = false, ContextUsageFixture? contextUsage = null, bool publishedModelCatalog = false,
+        TranscriptSearchFixtureMode transcriptSearchMode = TranscriptSearchFixtureMode.Ready)
     {
         _sessions = sessions;
         _reads = reads;
@@ -86,21 +88,23 @@ private GatewayScenario(Session[] sessions, IReadOnlyDictionary<string, JsonElem
         _allowSessionMutations = allowSessionMutations;
         IsInteractive = interactive;
         _allowChatSend = allowChatSend;
+        _transcriptSearchMode = transcriptSearchMode;
         _cronJobs = cronJobs?.ToDictionary(job => job["id"]!.GetValue<string>(), StringComparer.Ordinal);
         _contextUsage = contextUsage;
         SessionKeys = Array.AsReadOnly(sessions.Select(s => s.Key).ToArray());
         ReadMethods = Array.AsReadOnly(new[]
         {
-            "sessions.list", "sessions.subscribe", "sessions.preview", "chat.history",
+            "sessions.list", "sessions.subscribe", "sessions.preview", "sessions.search", "chat.history",
             "models.list", "usage.cost"
         }.Concat(reads.Keys).Concat(setup is null ? [] : advertiseSetup
             ? SetupMethods : ["wizard.start", "wizard.next", "wizard.cancel", "logs.tail"])
             .Concat(cronJobs is null ? [] : ["cron.list", "cron.status", "cron.add", "cron.update"])
             .Concat(allowSessionMutations ? ["sessions.create", "sessions.patch", "sessions.delete"] : [])
+            .Where(method => method != "sessions.search" || transcriptSearchMode != TranscriptSearchFixtureMode.Unsupported)
             .Order(StringComparer.Ordinal).ToArray());
         var source = JsonSerializer.Serialize(new
         {
-            Name, Version, ProtocolVersion, ContractProvenance, publishedModelCatalog,
+            Name, Version, ProtocolVersion, ContractProvenance, publishedModelCatalog, transcriptSearchMode,
             sessions = sessions.Select(s => new { s.Row, s.Messages }), reads, cronJobs
         });
         Sha256 = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(source))).ToLowerInvariant();
@@ -417,6 +421,7 @@ internal object Respond(string method, JsonElement parameters, Func<string, bool
             "sessions.list" => ListSessions(parameters),
             "sessions.subscribe" => Subscribe(parameters),
             "sessions.preview" => Preview(parameters),
+            "sessions.search" => SearchTranscripts(parameters),
             "chat.history" => History(parameters),
             "models.list" => Models(parameters, containsModelSession ?? ContainsSession),
             "usage.cost" => Cost(parameters),
diff --git a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj
index 849addb2a4..8f4507b7b9 100644
--- a/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj
+++ b/tests/OpenClaw.Tray.Tests/OpenClaw.Tray.Tests.csproj
@@ -19,6 +19,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <Compile Include="..\..\src\OpenClaw.Tray.WinUI\Services\SessionTranscriptSearch.cs" Link="Services\SessionTranscriptSearch.cs" />
     <PackageReference Include="OpenTelemetry" Version="1.16.0" />
     <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.16.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
diff --git a/tests/OpenClaw.Tray.Tests/SessionTranscriptSearchTests.cs b/tests/OpenClaw.Tray.Tests/SessionTranscriptSearchTests.cs
new file mode 100644
index 0000000000..f4b942311c
--- /dev/null
+++ b/tests/OpenClaw.Tray.Tests/SessionTranscriptSearchTests.cs
@@ -0,0 +1,107 @@
+using System.Reflection;
+using OpenClaw.Shared;
+using OpenClawTray.Services;
+
+namespace OpenClaw.Tray.Tests;
+
+public sealed class SessionTranscriptSearchTests
+{
+    public class GatewayProxy : DispatchProxy
+    {
+        public long Epoch = 1;
+        public bool Connected = true;
+        public int Calls;
+        public SessionSearchRequest? Request;
+        public Func<Task<SessionSearchResult>> Response = () => Task.FromResult(Result("current"));
+        protected override object? Invoke(MethodInfo? method, object?[]? args) => method?.Name switch
+        {
+            "get_IsConnectedToGateway" => Connected,
+            "get_SessionMutationConnectionEpoch" => (long?)Epoch,
+            "SearchSessionsAsync" => Load((SessionSearchRequest)args![0]!),
+            _ => throw new NotSupportedException(method?.Name)
+        };
+        private Task<SessionSearchResult> Load(SessionSearchRequest request)
+        {
+            Calls++;
+            Request = request;
+            return Response();
+        }
+    }
+
+    private static SessionSearchResult Result(string key) =>
+        new([new(key, "session", "message", "assistant", 1, "Synthetic snippet.", 1)]);
+
+    private static (IOperatorGatewayClient Client, GatewayProxy Proxy) Gateway()
+    {
+        var client = DispatchProxy.Create<IOperatorGatewayClient, GatewayProxy>();
+        return (client, (GatewayProxy)client);
+    }
+
+    [Fact]
+    public async Task SubmitRoutesQueryAndBackgroundScope_EmptyQueryOnlyClears()
+    {
+        var (client, proxy) = Gateway();
+        var source = new SessionTranscriptSearch(() => { }, _ => Assert.Fail("Unexpected error."));
+        await source.SearchAsync(client, () => client, "needle", true);
+        Assert.Equal(new SessionSearchRequest("needle", true), proxy.Request);
+        Assert.Equal(SessionSearchStatus.Ready, source.Status);
+        Assert.Equal("current", Assert.Single(source.Result!.Results).SessionKey);
+        await source.SearchAsync(client, () => client, " ", false);
+        Assert.Equal(1, proxy.Calls);
+        Assert.Equal(SessionSearchStatus.Idle, source.Status);
+        Assert.Null(source.Result);
+    }
+
+    [Theory]
+    [InlineData("query")]
+    [InlineData("unload")]
+    [InlineData("reconnect")]
+    [InlineData("replacement")]
+    public async Task PendingResultsNeverSurviveAuthorityChanges(string change)
+    {
+        var (client, proxy) = Gateway();
+        IOperatorGatewayClient? current = client;
+        var pending = new TaskCompletionSource<SessionSearchResult>();
+        proxy.Response = () => pending.Task;
+        var source = new SessionTranscriptSearch(() => { }, _ => Assert.Fail("Unexpected error."));
+        var oldSearch = source.SearchAsync(client, () => current, "old", false);
+        Assert.Equal(SessionSearchStatus.Loading, source.Status);
+        switch (change)
+        {
+            case "query":
+                proxy.Response = () => Task.FromResult(Result("new"));
+                await source.SearchAsync(client, () => current, "new", false);
+                break;
+            case "unload": source.Clear(); current = null; break;
+            case "reconnect": proxy.Epoch++; source.Clear(); break;
+            case "replacement": current = Gateway().Client; source.Clear(); break;
+        }
+        pending.SetResult(Result("stale"));
+        await oldSearch;
+        if (change == "query")
+            Assert.Equal("new", Assert.Single(source.Result!.Results).SessionKey);
+        else
+            Assert.Null(source.Result);
+    }
+
+    [Fact]
+    public async Task UnsupportedAndFailedSearchAreNotSuccessfulEmptyResults()
+    {
+        var (client, proxy) = Gateway();
+        Exception? reported = null;
+        var source = new SessionTranscriptSearch(() => { }, ex => reported = ex);
+        proxy.Response = () => Task.FromResult(new SessionSearchResult([], IsSupported: false));
+        await source.SearchAsync(client, () => client, "needle", false);
+        Assert.Equal(SessionSearchStatus.Unsupported, source.Status);
+        var failure = new TimeoutException();
+        proxy.Response = () => Task.FromException<SessionSearchResult>(failure);
+        await source.SearchAsync(client, () => client, "needle", false);
+        Assert.Equal(SessionSearchStatus.Failed, source.Status);
+        Assert.Null(source.Result);
+        Assert.Same(failure, reported);
+        proxy.Connected = false;
+        await source.SearchAsync(client, () => client, "needle", false);
+        Assert.Equal(2, proxy.Calls);
+        Assert.Equal(SessionSearchStatus.Failed, source.Status);
+    }
+}
diff --git a/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.Search.cs b/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.Search.cs
new file mode 100644
index 0000000000..a97dc7af9a
--- /dev/null
+++ b/tests/OpenClaw.Tray.UITests/GatewayFixtureUiTests.Search.cs
@@ -0,0 +1,44 @@
+using System.Windows.Automation;
+using OpenClaw.TestSupport.Gateway;
+
+namespace OpenClaw.Tray.UITests;
+
+public sealed partial class GatewayFixtureUiTests
+{
+    [GatewayFixtureUiFact]
+    [Trait("Category", "GatewayFixture")]
+    public async Task TranscriptSearch_ShowsVisibleMatchesAndOpensTheMatchingConversation()
+    {
+        await WithAppAsync(async run =>
+        {
+            await run.InvokeAsync("app.navigate", new { page = "sessions" });
+            await WaitUiAsync(run, () => FindById(run, "SessionsTranscriptQuery") is not null, "transcript search field");
+            var query = FindById(run, "SessionsTranscriptQuery")!;
+            var input = query.FindFirst(TreeScope.Descendants,
+                new PropertyCondition(AutomationElement.IsValuePatternAvailableProperty, true)) ?? query;
+            ((ValuePattern)input.GetCurrentPattern(ValuePattern.Pattern)).SetValue("FIXTURE RESEARCH:");
+            var searchWindow = AppWindows(run).Single(window => window.FindFirst(TreeScope.Descendants,
+                new PropertyCondition(AutomationElement.AutomationIdProperty, "SessionsTranscriptQuery")) is not null);
+            Invoke(FindById(run, "SessionsTranscriptSubmit")!);
+            await run.Gateway.WaitForCompletedRequestAsync("sessions.search");
+            await WaitUiAsync(run, () => FindById(run, "SessionsTranscriptSearchResults") is { Current.IsOffscreen: false },
+                "visible transcript search results");
+            var results = FindById(run, "SessionsTranscriptSearchResults")!;
+            var snippets = results.FindAll(TreeScope.Descendants,
+                new PropertyCondition(AutomationElement.NameProperty,
+                    "FIXTURE RESEARCH: the violet compass points north."));
+            Assert.Equal(2, snippets.Count);
+            Assert.All(snippets.Cast<AutomationElement>(), snippet => Assert.False(snippet.Current.IsOffscreen));
+            if (Environment.GetEnvironmentVariable("OPENCLAW_GATEWAY_FIXTURE_SCREENSHOTS") == "1")
+                OwnedWindowCapture.Save(run, searchWindow, "sessions-transcript-search-results.png");
+            var open = results.FindFirst(TreeScope.Descendants, new AndCondition(
+                new PropertyCondition(AutomationElement.ControlTypeProperty, ControlType.Button),
+                new PropertyCondition(AutomationElement.NameProperty, "Fixture: research conversation")))!;
+            Invoke(open);
+            await WaitHistoryAsync(run, GatewayScenario.OtherSessionKey);
+            await WaitUiAsync(run, () => IsVisibleInTimeline(run, GatewayScenario.OtherSentinel),
+                "matched conversation transcript");
+            await CaptureIfRequestedAsync(run, "sessions-search-opened-matching-conversation.png");
+        });
+    }
+}