diff --git a/Directory.Packages.props b/Directory.Packages.props
index 25e873c44f..00779f72ca 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -59,6 +59,7 @@
     <PackageVersion Include="Microsoft.Win32.Registry" Version="5.0.0" />
     <PackageVersion Include="Microsoft.WindowsAppSDK" Version="1.8.251003001" />
     <PackageVersion Include="OpenTelemetry" Version="1.15.3" />
+    <PackageVersion Include="System.Text.Json" Version="8.0.5" />
     <PackageVersion Include="System.Threading.Tasks.Extensions" Version="$(SystemThreadingTasksExtensionsVersion)" />
   </ItemGroup>
   <ItemGroup Label="Test dependencies">
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsCommandLineOptions.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsCommandLineOptions.cs
index bfe0b50025..54a7b1f96d 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsCommandLineOptions.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsCommandLineOptions.cs
@@ -6,5 +6,8 @@ namespace Microsoft.Testing.Extensions.Reporting;
 internal static class AzureDevOpsCommandLineOptions
 {
     public const string AzureDevOpsOptionName = "report-azdo";
+    public const string AzureDevOpsDemoteKnownFlaky = "report-azdo-demote-known-flaky";
+    public const string AzureDevOpsFlakyHistory = "report-azdo-flaky-history";
+    public const string AzureDevOpsQuarantineFile = "report-azdo-quarantine-file";
     public const string AzureDevOpsReportSeverity = "report-azdo-severity";
 }
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsCommandLineProvider.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsCommandLineProvider.cs
index 85598bc581..e6bfbe680a 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsCommandLineProvider.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsCommandLineProvider.cs
@@ -1,6 +1,7 @@
 ﻿// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using Microsoft.Testing.Extensions.AzureDevOpsReport;
 using Microsoft.Testing.Extensions.AzureDevOpsReport.Resources;
 using Microsoft.Testing.Platform.CommandLine;
 using Microsoft.Testing.Platform.Extensions;
@@ -12,6 +13,11 @@ internal sealed class AzureDevOpsCommandLineProvider : ICommandLineOptionsProvid
 {
     private static readonly string[] SeverityOptions = ["error", "warning"];
 
+    private static readonly string DemoteKnownFlakyOptionDescriptionFormatted = string.Format(
+        CultureInfo.InvariantCulture,
+        AzureDevOpsResources.DemoteKnownFlakyOptionDescription,
+        AzureDevOpsReporter.KnownFlakyFailureRateThreshold * 100);
+
     public string Uid => nameof(AzureDevOpsCommandLineProvider);
 
     public string Version => ExtensionVersion.DefaultSemVer;
@@ -26,31 +32,61 @@ public IReadOnlyCollection<CommandLineOption> GetCommandLineOptions()
         =>
         [
             new CommandLineOption(AzureDevOpsCommandLineOptions.AzureDevOpsOptionName, AzureDevOpsResources.OptionDescription, ArgumentArity.Zero, false),
+            new CommandLineOption(AzureDevOpsCommandLineOptions.AzureDevOpsDemoteKnownFlaky, DemoteKnownFlakyOptionDescriptionFormatted, ArgumentArity.Zero, false),
+            new CommandLineOption(AzureDevOpsCommandLineOptions.AzureDevOpsFlakyHistory, AzureDevOpsResources.FlakyHistoryOptionDescription, ArgumentArity.ExactlyOne, false),
+            new CommandLineOption(AzureDevOpsCommandLineOptions.AzureDevOpsQuarantineFile, AzureDevOpsResources.QuarantineFileOptionDescription, ArgumentArity.ExactlyOne, false),
             new CommandLineOption(AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity, AzureDevOpsResources.SeverityOptionDescription, ArgumentArity.ExactlyOne, false),
         ];
 
     public Task<ValidationResult> ValidateOptionArgumentsAsync(CommandLineOption commandOption, string[] arguments)
+        => commandOption.Name switch
+        {
+            AzureDevOpsCommandLineOptions.AzureDevOpsFlakyHistory => ValidateFlakyHistoryArgumentsAsync(arguments),
+            AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity => ValidateSeverityArgumentsAsync(arguments),
+            _ => ValidationResult.ValidTask,
+        };
+
+    public Task<ValidationResult> ValidateCommandLineOptionsAsync(ICommandLineOptions commandLineOptions)
     {
-        if (commandOption.Name == AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity)
+        string? errorMessage = null;
+        if (!commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsOptionName))
         {
-            if (!SeverityOptions.Contains(arguments[0], StringComparer.OrdinalIgnoreCase))
+            if (commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsDemoteKnownFlaky))
             {
-                return ValidationResult.InvalidTask(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.InvalidSeverity, arguments[0]));
+                errorMessage = AzureDevOpsResources.AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps;
+            }
+            else if (commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsFlakyHistory))
+            {
+                errorMessage = AzureDevOpsResources.AzureDevOpsFlakyHistoryRequiresAzureDevOps;
+            }
+            else if (commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsQuarantineFile))
+            {
+                errorMessage = AzureDevOpsResources.AzureDevOpsQuarantineFileRequiresAzureDevOps;
+            }
+            else if (commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity))
+            {
+                errorMessage = AzureDevOpsResources.AzureDevOpsReportSeverityRequiresAzureDevOps;
             }
         }
-
-        return ValidationResult.ValidTask;
-    }
-
-    public Task<ValidationResult> ValidateCommandLineOptionsAsync(ICommandLineOptions commandLineOptions)
-    {
-        if (!commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsOptionName) &&
-            commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity))
+        else if (commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsDemoteKnownFlaky)
+            && !commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsFlakyHistory))
         {
-            // If report-azdo is not set, but report-azdo-severity is set, it's invalid.
-            return ValidationResult.InvalidTask(AzureDevOpsResources.AzureDevOpsReportSeverityRequiresAzureDevOps);
+            errorMessage = AzureDevOpsResources.AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory;
         }
 
-        return ValidationResult.ValidTask;
+        return errorMessage is null
+            ? ValidationResult.ValidTask
+            : ValidationResult.InvalidTask(errorMessage);
     }
+
+    private static Task<ValidationResult> ValidateFlakyHistoryArgumentsAsync(string[] arguments)
+        => int.TryParse(arguments[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out int days)
+            && days is >= 1 and <= 90
+                ? ValidationResult.ValidTask
+                : ValidationResult.InvalidTask(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.InvalidFlakyHistoryDays, arguments[0]));
+
+    private static Task<ValidationResult> ValidateSeverityArgumentsAsync(string[] arguments)
+        => SeverityOptions.Contains(arguments[0], StringComparer.OrdinalIgnoreCase)
+            ? ValidationResult.ValidTask
+            : ValidationResult.InvalidTask(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.InvalidSeverity, arguments[0]));
 }
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsExtensions.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsExtensions.cs
index 728a257520..2b0266564d 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsExtensions.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsExtensions.cs
@@ -4,7 +4,6 @@
 using Microsoft.Testing.Extensions.AzureDevOpsReport;
 using Microsoft.Testing.Extensions.Reporting;
 using Microsoft.Testing.Platform.Builder;
-using Microsoft.Testing.Platform.Extensions;
 using Microsoft.Testing.Platform.Services;
 
 namespace Microsoft.Testing.Extensions;
@@ -20,17 +19,31 @@ public static class AzureDevOpsExtensions
     /// <param name="builder">The test application builder.</param>
     public static void AddAzureDevOpsProvider(this ITestApplicationBuilder builder)
     {
-        var compositeTestSessionAzDoService =
-           new CompositeExtensionFactory<AzureDevOpsReporter>(serviceProvider =>
-               new AzureDevOpsReporter(
-                   serviceProvider.GetCommandLineOptions(),
-                   serviceProvider.GetEnvironment(),
-                   serviceProvider.GetFileSystem(),
-                   serviceProvider.GetOutputDevice(),
-                   serviceProvider.GetLoggerFactory()));
+        AzureDevOpsHistoryService? historyService = null;
 
-        builder.TestHost.AddDataConsumer(compositeTestSessionAzDoService);
+        builder.TestHost.AddDataConsumer(serviceProvider =>
+        {
+            historyService ??= CreateHistoryService(serviceProvider);
 
+            return new AzureDevOpsReporter(
+                serviceProvider.GetCommandLineOptions(),
+                serviceProvider.GetEnvironment(),
+                serviceProvider.GetFileSystem(),
+                serviceProvider.GetOutputDevice(),
+                serviceProvider.GetLoggerFactory(),
+                historyService);
+        });
+        builder.TestHost.AddTestSessionLifetimeHandler(serviceProvider =>
+            historyService ??= CreateHistoryService(serviceProvider));
         builder.CommandLine.AddProvider(() => new AzureDevOpsCommandLineProvider());
     }
+
+    private static AzureDevOpsHistoryService CreateHistoryService(IServiceProvider serviceProvider)
+        => new(
+            serviceProvider.GetCommandLineOptions(),
+            serviceProvider.GetEnvironment(),
+            serviceProvider.GetClock(),
+            new AzureDevOpsHistoryClient(serviceProvider.GetTask(), serviceProvider.GetClock()),
+            serviceProvider.GetTask(),
+            serviceProvider.GetLoggerFactory());
 }
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsHistoryClient.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsHistoryClient.cs
new file mode 100644
index 0000000000..ef33aade64
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsHistoryClient.cs
@@ -0,0 +1,392 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Net;
+using System.Text.Json.Serialization;
+using System.Text.Json.Serialization.Metadata;
+
+using Microsoft.Testing.Platform;
+using Microsoft.Testing.Platform.Helpers;
+
+namespace Microsoft.Testing.Extensions.AzureDevOpsReport;
+
+internal interface IAzureDevOpsHistoryClient
+{
+    Task<IReadOnlyList<AzureDevOpsTestRun>> GetRunsAsync(AzureDevOpsHistoryQuery query, int maximumRunCount, CancellationToken cancellationToken);
+
+    Task<AzureDevOpsTestResultsPage> GetResultsAsync(AzureDevOpsHistoryQuery query, string runUrl, int skip, int top, string? continuationToken, CancellationToken cancellationToken);
+}
+
+internal sealed class AzureDevOpsHistoryClient : IAzureDevOpsHistoryClient
+{
+    private const int BaseDelayMs = 500;
+    private const int ErrorContentMaxLength = 500;
+    private const int MaxAttempts = 3;
+    private const int RunsPageSize = 200;
+    private const string ApiVersion = "7.1";
+    private const string ContinuationTokenHeaderName = "x-ms-continuationtoken";
+    private static readonly System.Net.Http.Headers.MediaTypeWithQualityHeaderValue JsonMediaType = new("application/json");
+    private static readonly System.Net.Http.Headers.ProductInfoHeaderValue UserAgent = new("Microsoft.Testing.Extensions.AzureDevOpsReport", ExtensionVersion.DefaultSemVer);
+    private static readonly TimeSpan RequestTimeout = TimeSpan.FromSeconds(20);
+    private static readonly HttpClient SharedHttpClient = new();
+
+    private readonly ITask _task;
+    private readonly IClock _clock;
+    private readonly HttpClient _httpClient;
+
+    public AzureDevOpsHistoryClient(ITask task, IClock clock, HttpClient? httpClient = null)
+    {
+        _task = task;
+        _clock = clock;
+        _httpClient = httpClient ?? SharedHttpClient;
+    }
+
+    public async Task<IReadOnlyList<AzureDevOpsTestRun>> GetRunsAsync(AzureDevOpsHistoryQuery query, int maximumRunCount, CancellationToken cancellationToken)
+    {
+        if (maximumRunCount <= 0)
+        {
+            return [];
+        }
+
+        List<AzureDevOpsTestRun> runs = [];
+        string? continuationToken = null;
+        string? previousContinuationToken = null;
+        int skip = 0;
+
+        while (runs.Count < maximumRunCount)
+        {
+            int top = Math.Min(RunsPageSize, maximumRunCount - runs.Count);
+            AzureDevOpsTestRunsPage page = await SendWithRetryAsync(
+                () => CreateRunsRequest(query, skip, top, continuationToken),
+                ParseRunsAsync,
+                cancellationToken).ConfigureAwait(false);
+
+            if (page.Runs.Count == 0)
+            {
+                return runs;
+            }
+
+            foreach (AzureDevOpsTestRun run in page.Runs)
+            {
+                runs.Add(run);
+                if (runs.Count == maximumRunCount)
+                {
+                    return runs;
+                }
+            }
+
+            if (page.ContinuationToken is null)
+            {
+                if (continuationToken is not null || page.Runs.Count < top)
+                {
+                    return runs;
+                }
+
+                skip += page.Runs.Count;
+                continue;
+            }
+
+            if (page.ContinuationToken == previousContinuationToken)
+            {
+                return runs;
+            }
+
+            previousContinuationToken = page.ContinuationToken;
+            continuationToken = page.ContinuationToken;
+        }
+
+        return runs;
+    }
+
+    public Task<AzureDevOpsTestResultsPage> GetResultsAsync(AzureDevOpsHistoryQuery query, string runUrl, int skip, int top, string? continuationToken, CancellationToken cancellationToken)
+        => SendWithRetryAsync(() => CreateResultsRequest(query, runUrl, skip, top, continuationToken), ParseResultsAsync, cancellationToken);
+
+    internal static string CreateRunsRequestUri(AzureDevOpsHistoryQuery query, int skip, int top, string? continuationToken = null)
+    {
+        string collectionUri = EnsureTrailingSlash(query.CollectionUri);
+        System.Text.StringBuilder builder = new();
+        builder
+            .Append(collectionUri)
+            .Append(Uri.EscapeDataString(query.TeamProject))
+            .Append("/_apis/test/Runs")
+            .Append("?minLastUpdatedDate=")
+            .Append(Uri.EscapeDataString(query.MinLastUpdatedDate.ToString("O", CultureInfo.InvariantCulture)))
+            .Append("&maxLastUpdatedDate=")
+            .Append(Uri.EscapeDataString(query.MaxLastUpdatedDate.ToString("O", CultureInfo.InvariantCulture)))
+            .Append("&definitions=")
+            .Append(Uri.EscapeDataString(query.BuildDefinitionId))
+            .Append("&automated=true")
+            .Append("&$top=")
+            .Append(top.ToString(CultureInfo.InvariantCulture));
+
+        if (continuationToken is null)
+        {
+            builder.Append("&$skip=").Append(skip.ToString(CultureInfo.InvariantCulture));
+        }
+        else
+        {
+            builder.Append("&continuationToken=").Append(Uri.EscapeDataString(continuationToken));
+        }
+
+        builder.Append("&api-version=").Append(ApiVersion);
+        return builder.ToString();
+    }
+
+    private static HttpRequestMessage CreateRunsRequest(AzureDevOpsHistoryQuery query, int skip, int top, string? continuationToken)
+        => CreateRequest(query.AccessToken, CreateRunsRequestUri(query, skip, top, continuationToken));
+
+    private static HttpRequestMessage CreateResultsRequest(AzureDevOpsHistoryQuery query, string runUrl, int skip, int top, string? continuationToken)
+        => CreateRequest(query.AccessToken, CreateResultsRequestUri(runUrl, skip, top, continuationToken));
+
+    private static string CreateResultsRequestUri(string runUrl, int skip, int top, string? continuationToken)
+    {
+        System.Text.StringBuilder builder = new();
+        builder
+            .Append(runUrl.TrimEnd('/'))
+            .Append("/results?outcomes=Failed,Passed")
+            .Append("&$top=")
+            .Append(top.ToString(CultureInfo.InvariantCulture));
+
+        if (continuationToken is null)
+        {
+            builder.Append("&$skip=").Append(skip.ToString(CultureInfo.InvariantCulture));
+        }
+        else
+        {
+            builder.Append("&continuationToken=").Append(Uri.EscapeDataString(continuationToken));
+        }
+
+        builder.Append("&api-version=").Append(ApiVersion);
+        return builder.ToString();
+    }
+
+    private static HttpRequestMessage CreateRequest(string accessToken, string requestUri)
+    {
+        HttpRequestMessage request = new(HttpMethod.Get, requestUri);
+        string encodedToken = Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes($":{accessToken}"));
+        request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", encodedToken);
+        request.Headers.Accept.Add(JsonMediaType);
+        request.Headers.UserAgent.Add(UserAgent);
+        return request;
+    }
+
+    private async Task<T> SendWithRetryAsync<T>(Func<HttpRequestMessage> requestFactory, Func<HttpResponseMessage, Task<T>> responseParser, CancellationToken cancellationToken)
+    {
+        for (int attempt = 1; ; attempt++)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                using HttpRequestMessage request = requestFactory();
+                using var timeoutCancellationTokenSource = new CancellationTokenSource(RequestTimeout);
+                using var linkedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCancellationTokenSource.Token);
+                using HttpResponseMessage response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, linkedCancellationTokenSource.Token).ConfigureAwait(false);
+                if (response.IsSuccessStatusCode)
+                {
+                    return await responseParser(response).ConfigureAwait(false);
+                }
+
+                if (attempt >= MaxAttempts || !IsTransient(response.StatusCode))
+                {
+                    string responseContent = await ReadResponseContentAsync(response).ConfigureAwait(false);
+                    string reasonPhrase = RoslynString.IsNullOrWhiteSpace(response.ReasonPhrase) ? response.StatusCode.ToString() : response.ReasonPhrase!;
+                    string responseSuffix = responseContent.Length == 0 ? string.Empty : $" {responseContent}";
+                    throw new HttpRequestException($"Azure DevOps history request failed with status code {(int)response.StatusCode} ({reasonPhrase}).{responseSuffix}");
+                }
+
+                await _task.Delay(GetRetryDelay(response, attempt), cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested && attempt < MaxAttempts)
+            {
+                await _task.Delay(GetRetryDelay(response: null, attempt), cancellationToken).ConfigureAwait(false);
+            }
+            catch (OperationCanceledException ex) when (!cancellationToken.IsCancellationRequested)
+            {
+                throw new HttpRequestException("Azure DevOps history request timed out.", ex);
+            }
+            catch (HttpRequestException) when (attempt < MaxAttempts)
+            {
+                await _task.Delay(GetRetryDelay(response: null, attempt), cancellationToken).ConfigureAwait(false);
+            }
+        }
+    }
+
+    private TimeSpan GetRetryDelay(HttpResponseMessage? response, int attempt)
+    {
+        if (response?.Headers.RetryAfter?.Delta is TimeSpan retryAfterDelta)
+        {
+            return retryAfterDelta;
+        }
+
+        if (response?.Headers.RetryAfter?.Date is DateTimeOffset retryAfterDate)
+        {
+            TimeSpan delay = retryAfterDate - _clock.UtcNow;
+            if (delay > TimeSpan.Zero)
+            {
+                return delay;
+            }
+        }
+
+        return TimeSpan.FromMilliseconds(BaseDelayMs * Math.Pow(2, attempt - 1));
+    }
+
+    private static bool IsTransient(HttpStatusCode statusCode)
+        => statusCode is HttpStatusCode.RequestTimeout
+            or HttpStatusCode.InternalServerError
+            or HttpStatusCode.BadGateway
+            or HttpStatusCode.ServiceUnavailable
+            or HttpStatusCode.GatewayTimeout
+            || (int)statusCode == 429;
+
+    private static async Task<AzureDevOpsTestRunsPage> ParseRunsAsync(HttpResponseMessage response)
+    {
+        AzureDevOpsRunsResponse? payload = await DeserializeResponseAsync(response, AzureDevOpsHistoryClientJsonContext.Default.AzureDevOpsRunsResponse).ConfigureAwait(false);
+        return payload?.Value is null
+            ? new AzureDevOpsTestRunsPage([], GetContinuationToken(response))
+            : new AzureDevOpsTestRunsPage(
+                [.. payload.Value
+                    .Where(static run => !RoslynString.IsNullOrWhiteSpace(run.Url))
+                    .Select(static run => new AzureDevOpsTestRun(run.Url!))],
+                GetContinuationToken(response));
+    }
+
+    private static async Task<AzureDevOpsTestResultsPage> ParseResultsAsync(HttpResponseMessage response)
+    {
+        AzureDevOpsResultsResponse? payload = await DeserializeResponseAsync(response, AzureDevOpsHistoryClientJsonContext.Default.AzureDevOpsResultsResponse).ConfigureAwait(false);
+        string? continuationToken = GetContinuationToken(response);
+
+        return payload?.Value is null
+            ? new AzureDevOpsTestResultsPage([], continuationToken)
+            : new AzureDevOpsTestResultsPage(
+                [.. payload.Value
+                    .Where(static result => !RoslynString.IsNullOrWhiteSpace(result.AutomatedTestName) && !RoslynString.IsNullOrWhiteSpace(result.Outcome))
+                    .Select(static result => new AzureDevOpsTestResult(result.AutomatedTestName!, result.Outcome!))],
+                continuationToken);
+    }
+
+    private static async Task<T?> DeserializeResponseAsync<T>(HttpResponseMessage response, JsonTypeInfo<T> jsonTypeInfo)
+    {
+#pragma warning disable CA2016 // CancellationToken overload is unavailable on all target frameworks.
+        string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+#pragma warning restore CA2016
+        return System.Text.Json.JsonSerializer.Deserialize(content, jsonTypeInfo);
+    }
+
+    private static string EnsureTrailingSlash(string value)
+        => value.EndsWith("/", StringComparison.Ordinal) ? value : value + "/";
+
+    private static string? GetContinuationToken(HttpResponseMessage response)
+        => response.Headers.TryGetValues(ContinuationTokenHeaderName, out IEnumerable<string>? values)
+            ? values.FirstOrDefault()
+            : null;
+
+    private static async Task<string> ReadResponseContentAsync(HttpResponseMessage response)
+    {
+#pragma warning disable CA2016 // CancellationToken overload is unavailable on all target frameworks.
+        string responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+#pragma warning restore CA2016
+        return responseContent.Length <= ErrorContentMaxLength
+            ? responseContent
+            : responseContent.Substring(0, ErrorContentMaxLength);
+    }
+}
+
+internal sealed class AzureDevOpsHistoryQuery
+{
+    public AzureDevOpsHistoryQuery(string collectionUri, string teamProject, string accessToken, string buildDefinitionId, DateTimeOffset minLastUpdatedDate, DateTimeOffset maxLastUpdatedDate)
+    {
+        CollectionUri = collectionUri;
+        TeamProject = teamProject;
+        AccessToken = accessToken;
+        BuildDefinitionId = buildDefinitionId;
+        MinLastUpdatedDate = minLastUpdatedDate;
+        MaxLastUpdatedDate = maxLastUpdatedDate;
+    }
+
+    public string CollectionUri { get; }
+
+    public string TeamProject { get; }
+
+    public string AccessToken { get; }
+
+    public string BuildDefinitionId { get; }
+
+    public DateTimeOffset MinLastUpdatedDate { get; }
+
+    public DateTimeOffset MaxLastUpdatedDate { get; }
+}
+
+internal sealed class AzureDevOpsRunResponse
+{
+    [JsonPropertyName("url")]
+    public string? Url { get; set; }
+}
+
+internal sealed class AzureDevOpsRunsResponse
+{
+    [JsonPropertyName("value")]
+    public AzureDevOpsRunResponse[]? Value { get; set; }
+}
+
+internal sealed class AzureDevOpsTestRun
+{
+    public AzureDevOpsTestRun(string url)
+        => Url = url;
+
+    public string Url { get; }
+}
+
+internal sealed class AzureDevOpsTestRunsPage
+{
+    public AzureDevOpsTestRunsPage(IReadOnlyList<AzureDevOpsTestRun> runs, string? continuationToken)
+    {
+        Runs = runs;
+        ContinuationToken = continuationToken;
+    }
+
+    public IReadOnlyList<AzureDevOpsTestRun> Runs { get; }
+
+    public string? ContinuationToken { get; }
+}
+
+internal sealed class AzureDevOpsResultResponse
+{
+    [JsonPropertyName("automatedTestName")]
+    public string? AutomatedTestName { get; set; }
+
+    [JsonPropertyName("outcome")]
+    public string? Outcome { get; set; }
+}
+
+internal sealed class AzureDevOpsResultsResponse
+{
+    [JsonPropertyName("value")]
+    public AzureDevOpsResultResponse[]? Value { get; set; }
+}
+
+internal sealed class AzureDevOpsTestResult
+{
+    public AzureDevOpsTestResult(string automatedTestName, string outcome)
+    {
+        AutomatedTestName = automatedTestName;
+        Outcome = outcome;
+    }
+
+    public string AutomatedTestName { get; }
+
+    public string Outcome { get; }
+}
+
+internal sealed class AzureDevOpsTestResultsPage
+{
+    public AzureDevOpsTestResultsPage(IReadOnlyList<AzureDevOpsTestResult> results, string? continuationToken)
+    {
+        Results = results;
+        ContinuationToken = continuationToken;
+    }
+
+    public IReadOnlyList<AzureDevOpsTestResult> Results { get; }
+
+    public string? ContinuationToken { get; }
+}
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsHistoryClientJsonContext.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsHistoryClientJsonContext.cs
new file mode 100644
index 0000000000..f811c20d40
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsHistoryClientJsonContext.cs
@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Text.Json.Serialization;
+
+namespace Microsoft.Testing.Extensions.AzureDevOpsReport;
+
+[JsonSerializable(typeof(AzureDevOpsResultsResponse))]
+[JsonSerializable(typeof(AzureDevOpsRunsResponse))]
+internal sealed partial class AzureDevOpsHistoryClientJsonContext : JsonSerializerContext;
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsHistoryService.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsHistoryService.cs
new file mode 100644
index 0000000000..e51b09e515
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsHistoryService.cs
@@ -0,0 +1,279 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Extensions.AzureDevOpsReport.Resources;
+using Microsoft.Testing.Extensions.Reporting;
+using Microsoft.Testing.Platform;
+using Microsoft.Testing.Platform.CommandLine;
+using Microsoft.Testing.Platform.Extensions.TestHost;
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.Logging;
+using Microsoft.Testing.Platform.Services;
+
+namespace Microsoft.Testing.Extensions.AzureDevOpsReport;
+
+internal sealed class AzureDevOpsHistoryService : ITestSessionLifetimeHandler, IAzureDevOpsHistoryService
+{
+    // NOTE: Inspect one extra run so the reporter can log when Azure DevOps history exceeds the inspection cap.
+    private const int MaxRunsToInspect = 500;
+
+    // NOTE: Request the largest practical result page to minimize Azure DevOps round-trips during session start.
+    private const int ResultsPageSize = 1000;
+
+    // NOTE: Bound per-run paging so a single large run cannot keep session startup busy indefinitely.
+    private const int MaxResultPagesPerRun = 50;
+
+    private static readonly TimeSpan HistoryLoadBudget = TimeSpan.FromSeconds(30);
+    private static readonly IReadOnlyDictionary<string, FlakyStats> EmptyStatsByTest = new Dictionary<string, FlakyStats>(StringComparer.OrdinalIgnoreCase);
+
+    private readonly ICommandLineOptions _commandLineOptions;
+    private readonly IEnvironment _environment;
+    private readonly IClock _clock;
+    private readonly IAzureDevOpsHistoryClient _historyClient;
+    private readonly ITask _task;
+    private readonly ILogger _logger;
+    private int _historyWindowInDays;
+    private IReadOnlyDictionary<string, FlakyStats> _statsByTest = EmptyStatsByTest;
+
+    public AzureDevOpsHistoryService(
+        ICommandLineOptions commandLineOptions,
+        IEnvironment environment,
+        IClock clock,
+        IAzureDevOpsHistoryClient historyClient,
+        ITask task,
+        ILoggerFactory loggerFactory)
+    {
+        _commandLineOptions = commandLineOptions;
+        _environment = environment;
+        _clock = clock;
+        _historyClient = historyClient;
+        _task = task;
+        _logger = loggerFactory.CreateLogger<AzureDevOpsHistoryService>();
+    }
+
+    public string Uid => nameof(AzureDevOpsHistoryService);
+
+    public string Version => ExtensionVersion.DefaultSemVer;
+
+    public string DisplayName => AzureDevOpsResources.DisplayName;
+
+    public string Description => AzureDevOpsResources.Description;
+
+    public int HistoryWindowInDays => Volatile.Read(ref _historyWindowInDays);
+
+    public Task<bool> IsEnabledAsync()
+        => Task.FromResult(_commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsOptionName)
+            && _commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsFlakyHistory));
+
+    public async Task OnTestSessionStartingAsync(ITestSessionContext testSessionContext)
+    {
+        if (!_commandLineOptions.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsOptionName)
+            || !TryGetHistoryWindowInDays(out int historyWindowInDays))
+        {
+            return;
+        }
+
+        if (!string.Equals(_environment.GetEnvironmentVariable("TF_BUILD"), "true", StringComparison.OrdinalIgnoreCase))
+        {
+            return;
+        }
+
+        if (!TryCreateQuery(historyWindowInDays, out AzureDevOpsHistoryQuery? query))
+        {
+            _logger.LogWarning(AzureDevOpsResources.FlakyHistoryMissingEnvironmentWarning);
+            return;
+        }
+
+        try
+        {
+            CancellationTokenSource? budgetCancellationTokenSource = null;
+
+            try
+            {
+                using var loadCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(testSessionContext.CancellationToken);
+                budgetCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(testSessionContext.CancellationToken);
+                Task loadTask = LoadHistoryAsync(query, historyWindowInDays, loadCancellationTokenSource.Token);
+                Task budgetTask = _task.Delay(HistoryLoadBudget, budgetCancellationTokenSource.Token);
+
+                if (await Task.WhenAny(loadTask, budgetTask).ConfigureAwait(false) != loadTask)
+                {
+                    testSessionContext.CancellationToken.ThrowIfCancellationRequested();
+#pragma warning disable VSTHRD103 // CancelAsync is unavailable on all target frameworks.
+                    loadCancellationTokenSource.Cancel();
+#pragma warning restore VSTHRD103
+                    ResetHistoryState();
+                    _logger.LogInformation(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.FlakyHistoryLoadTimedOutInfo, (int)HistoryLoadBudget.TotalSeconds));
+
+                    try
+                    {
+                        await loadTask.ConfigureAwait(false);
+                    }
+                    catch (OperationCanceledException) when (!testSessionContext.CancellationToken.IsCancellationRequested)
+                    {
+                    }
+
+                    return;
+                }
+
+#pragma warning disable VSTHRD103 // CancelAsync is unavailable on all target frameworks.
+                budgetCancellationTokenSource.Cancel();
+#pragma warning restore VSTHRD103
+                await loadTask.ConfigureAwait(false);
+            }
+            finally
+            {
+                budgetCancellationTokenSource?.Dispose();
+            }
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            ResetHistoryState();
+            _logger.LogWarning(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.FlakyHistoryLoadFailedWarning, ex.Message));
+        }
+    }
+
+    public Task OnTestSessionFinishingAsync(ITestSessionContext testSessionContext)
+        => Task.CompletedTask;
+
+    public bool TryGetStats(string testName, out FlakyStats stats)
+    {
+        if (RoslynString.IsNullOrWhiteSpace(testName))
+        {
+            stats = default;
+            return false;
+        }
+
+        // NOTE: Callers must only query stats after test-session start completes; the published snapshot is empty until then.
+        return Volatile.Read(ref _statsByTest).TryGetValue(testName, out stats);
+    }
+
+    public bool IsLikelyFlaky(string testName, double threshold)
+        => TryGetStats(testName, out FlakyStats stats)
+            && stats.TotalCount > 0
+            && stats.FailureRate >= threshold;
+
+    private async Task LoadHistoryAsync(AzureDevOpsHistoryQuery query, int historyWindowInDays, CancellationToken cancellationToken)
+    {
+        IReadOnlyList<AzureDevOpsTestRun> runs = await _historyClient.GetRunsAsync(query, MaxRunsToInspect + 1, cancellationToken).ConfigureAwait(false);
+        if (runs.Count > MaxRunsToInspect)
+        {
+            _logger.LogInformation(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.FlakyHistoryRunsCappedInfo, runs.Count, MaxRunsToInspect));
+            runs = [.. runs.Take(MaxRunsToInspect)];
+        }
+
+        var counts = new Dictionary<string, (int PassCount, int FailCount)>(StringComparer.OrdinalIgnoreCase);
+        foreach (AzureDevOpsTestRun run in runs)
+        {
+            await AggregateRunResultsAsync(query, run, counts, cancellationToken).ConfigureAwait(false);
+        }
+
+        PublishHistoryStats(historyWindowInDays, counts);
+    }
+
+    private async Task AggregateRunResultsAsync(
+        AzureDevOpsHistoryQuery query,
+        AzureDevOpsTestRun run,
+        Dictionary<string, (int PassCount, int FailCount)> counts,
+        CancellationToken cancellationToken)
+    {
+        string? continuationToken = null;
+        string? previousContinuationToken = null;
+        bool hasSeenContinuationToken = false;
+        int skip = 0;
+
+        for (int pageNumber = 0; pageNumber < MaxResultPagesPerRun; pageNumber++)
+        {
+            AzureDevOpsTestResultsPage page = await _historyClient.GetResultsAsync(query, run.Url, skip, ResultsPageSize, continuationToken, cancellationToken).ConfigureAwait(false);
+            foreach (AzureDevOpsTestResult result in page.Results)
+            {
+                if (!counts.TryGetValue(result.AutomatedTestName, out (int PassCount, int FailCount) currentCount))
+                {
+                    currentCount = default;
+                }
+
+                counts[result.AutomatedTestName] = result.Outcome switch
+                {
+                    "Passed" => (currentCount.PassCount + 1, currentCount.FailCount),
+                    "Failed" => (currentCount.PassCount, currentCount.FailCount + 1),
+                    _ => currentCount,
+                };
+            }
+
+            if (page.Results.Count == 0)
+            {
+                return;
+            }
+
+            if (page.ContinuationToken is null)
+            {
+                if (hasSeenContinuationToken || page.Results.Count < ResultsPageSize)
+                {
+                    return;
+                }
+
+                skip += page.Results.Count;
+                continue;
+            }
+
+            if (page.ContinuationToken == previousContinuationToken)
+            {
+                _logger.LogWarning(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.FlakyHistoryResultsPagingStoppedWarning, run.Url, MaxResultPagesPerRun));
+                return;
+            }
+
+            hasSeenContinuationToken = true;
+            previousContinuationToken = page.ContinuationToken;
+            continuationToken = page.ContinuationToken;
+        }
+
+        _logger.LogWarning(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.FlakyHistoryResultsPagingStoppedWarning, run.Url, MaxResultPagesPerRun));
+    }
+
+    private void PublishHistoryStats(int historyWindowInDays, Dictionary<string, (int PassCount, int FailCount)> counts)
+    {
+        Volatile.Write(ref _historyWindowInDays, historyWindowInDays);
+        IReadOnlyDictionary<string, FlakyStats> publishedStats = counts.ToDictionary(
+            static keyValuePair => keyValuePair.Key,
+            static keyValuePair => new FlakyStats(keyValuePair.Value.PassCount, keyValuePair.Value.FailCount),
+            StringComparer.OrdinalIgnoreCase);
+
+        // NOTE: Volatile.Write on a reference atomically publishes the fully materialized dictionary to concurrent readers.
+        Volatile.Write(ref _statsByTest, publishedStats);
+    }
+
+    private void ResetHistoryState()
+    {
+        Volatile.Write(ref _historyWindowInDays, 0);
+
+        // NOTE: Volatile.Write on a reference atomically publishes the empty snapshot when history loading is skipped or fails.
+        Volatile.Write(ref _statsByTest, EmptyStatsByTest);
+    }
+
+    private bool TryGetHistoryWindowInDays(out int historyWindowInDays)
+    {
+        historyWindowInDays = 0;
+        return _commandLineOptions.TryGetOptionArgumentList(AzureDevOpsCommandLineOptions.AzureDevOpsFlakyHistory, out string[]? arguments)
+            && arguments is [string value]
+            && int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out historyWindowInDays);
+    }
+
+    private bool TryCreateQuery(int historyWindowInDays, [NotNullWhen(true)] out AzureDevOpsHistoryQuery? query)
+    {
+        string? collectionUri = _environment.GetEnvironmentVariable("SYSTEM_COLLECTIONURI");
+        string? teamProject = _environment.GetEnvironmentVariable("SYSTEM_TEAMPROJECT");
+        string? accessToken = _environment.GetEnvironmentVariable("SYSTEM_ACCESSTOKEN");
+        string? buildDefinitionId = _environment.GetEnvironmentVariable("BUILD_DEFINITIONID");
+        if (RoslynString.IsNullOrWhiteSpace(collectionUri)
+            || RoslynString.IsNullOrWhiteSpace(teamProject)
+            || RoslynString.IsNullOrWhiteSpace(accessToken)
+            || RoslynString.IsNullOrWhiteSpace(buildDefinitionId))
+        {
+            query = null;
+            return false;
+        }
+
+        DateTimeOffset now = _clock.UtcNow;
+        query = new AzureDevOpsHistoryQuery(collectionUri, teamProject, accessToken, buildDefinitionId, now.AddDays(-historyWindowInDays), now);
+        return true;
+    }
+}
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsReporter.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsReporter.cs
index 3e94fe947d..7bad431d44 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsReporter.cs
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/AzureDevOpsReporter.cs
@@ -1,4 +1,4 @@
-﻿// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using Microsoft.Testing.Extensions.AzureDevOpsReport.Resources;
@@ -19,7 +19,13 @@ internal sealed class AzureDevOpsReporter :
     IDataConsumer,
     IOutputDeviceDataProducer
 {
+    internal const double KnownFlakyFailureRateThreshold = 0.25;
     private const string DeterministicBuildRoot = "/_/";
+    private const string FullyQualifiedNamePropertyKey = "vstest.TestCase.FullyQualifiedName";
+    private const int MinSamplesForRegressionAnnotation = 5;
+    private const string QuarantineBuildTagLine = "##vso[build.addbuildtag]has-quarantined-test-failure";
+    private const string WarningSeverity = "warning";
+    private static readonly char[] NewlineCharacters = ['\r', '\n'];
 
     // Fully-qualified type prefixes for MSTest assertion implementations. A stack frame whose
     // 'code' (i.e., the "Namespace.Type.Method(args)" portion) starts with any of these is treated
@@ -38,24 +44,30 @@ internal sealed class AzureDevOpsReporter :
 
     private readonly IOutputDevice _outputDisplay;
     private readonly ILogger _logger;
-    private static readonly char[] NewlineCharacters = ['\r', '\n'];
     private readonly ICommandLineOptions _commandLine;
     private readonly IEnvironment _environment;
     private readonly IFileSystem _fileSystem;
+    private readonly IAzureDevOpsHistoryService _historyService;
     private readonly string _targetFrameworkMoniker;
-    private string _severity = "error";
+    private string? _severity;
+    private bool _demoteKnownFlaky;
+    private QuarantineFile? _quarantineFile;
+    private bool _hasLoadedEnabledConfiguration;
+    private int _quarantineBuildTagEmitted;
 
     public AzureDevOpsReporter(
         ICommandLineOptions commandLine,
         IEnvironment environment,
         IFileSystem fileSystem,
         IOutputDevice outputDisplay,
-        ILoggerFactory loggerFactory)
+        ILoggerFactory loggerFactory,
+        IAzureDevOpsHistoryService historyService)
     {
         _commandLine = commandLine;
         _environment = environment;
         _fileSystem = fileSystem;
         _outputDisplay = outputDisplay;
+        _historyService = historyService;
         _logger = loggerFactory.CreateLogger<AzureDevOpsReporter>();
         _targetFrameworkMoniker = GetTargetFrameworkMoniker();
     }
@@ -92,34 +104,18 @@ public Task<bool> IsEnabledAsync()
         }
 
         bool isEnabledByEnvVariable = string.Equals(_environment.GetEnvironmentVariable("TF_BUILD"), "true", StringComparison.OrdinalIgnoreCase);
-        if (_logger.IsEnabled(LogLevel.Trace))
-        {
-            _logger.LogTrace($"TF_BUILD environment variable is {(isEnabledByEnvVariable ? "enabled. Will report errors to Azure DevOps, because we are running in CI." : "disabled. Will not report errors to Azure DevOps.")}.");
-        }
-
-        if (!isEnabledByEnvVariable)
+        if (isEnabledByEnvVariable)
         {
-            return Task.FromResult(false);
+            EnsureEnabledConfigurationLoaded();
         }
 
-        bool found = _commandLine.TryGetOptionArgumentList(AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity, out string[]? arguments);
-        if (found && arguments?.Length > 0)
-        {
-            _severity = arguments[0].ToLowerInvariant();
-            if (_logger.IsEnabled(LogLevel.Trace))
-            {
-                _logger.LogTrace($"Severity is set to '{_severity}', by --report-azdo-severity parameter.");
-            }
-        }
-        else
+        if (_logger.IsEnabled(LogLevel.Trace))
         {
-            if (_logger.IsEnabled(LogLevel.Trace))
-            {
-                _logger.LogTrace($"Severity is set to '{_severity}', you can override it by using --report-azdo-severity parameter.");
-            }
+            _logger.LogTrace($"TF_BUILD environment variable is {(isEnabledByEnvVariable ? "enabled. Will report errors to Azure DevOps, because we are running in CI." : "disabled. Will not report errors to Azure DevOps.")}");
+            _logger.LogTrace($"Severity is set to '{_severity ?? "error"}', you can override it by using --report-azdo-severity parameter.");
         }
 
-        return Task.FromResult(true);
+        return Task.FromResult(isEnabledByEnvVariable);
     }
 
     public async Task ConsumeAsync(IDataProducer dataProducer, IData value, CancellationToken cancellationToken)
@@ -131,38 +127,47 @@ public async Task ConsumeAsync(IDataProducer dataProducer, IData value, Cancella
             return;
         }
 
+        EnsureEnabledConfigurationLoaded();
         TestNodeStateProperty? nodeState = nodeUpdateMessage.TestNode.Properties.SingleOrDefault<TestNodeStateProperty>();
-
         string testDisplayName = nodeUpdateMessage.TestNode.DisplayName;
+        string testName = GetTestName(nodeUpdateMessage.TestNode);
 
         switch (nodeState)
         {
             case FailedTestNodeStateProperty failed:
-                await WriteExceptionAsync(testDisplayName, failed.Explanation, failed.Exception, cancellationToken).ConfigureAwait(false);
+                await WriteExceptionAsync(testDisplayName, testName, failed.Explanation, failed.Exception, cancellationToken).ConfigureAwait(false);
                 break;
             case ErrorTestNodeStateProperty error:
-                await WriteExceptionAsync(testDisplayName, error.Explanation, error.Exception, cancellationToken).ConfigureAwait(false);
+                await WriteExceptionAsync(testDisplayName, testName, error.Explanation, error.Exception, cancellationToken).ConfigureAwait(false);
                 break;
 #pragma warning disable CS0618, MTP0001 // Type or member is obsolete
             case CancelledTestNodeStateProperty cancelled:
 #pragma warning restore CS0618, MTP0001 // Type or member is obsolete
-                await WriteExceptionAsync(testDisplayName, cancelled.Explanation, cancelled.Exception, cancellationToken).ConfigureAwait(false);
+                await WriteExceptionAsync(testDisplayName, testName, cancelled.Explanation, cancelled.Exception, cancellationToken).ConfigureAwait(false);
                 break;
             case TimeoutTestNodeStateProperty timeout:
-                await WriteExceptionAsync(testDisplayName, timeout.Explanation, timeout.Exception, cancellationToken).ConfigureAwait(false);
+                await WriteExceptionAsync(testDisplayName, testName, timeout.Explanation, timeout.Exception, cancellationToken).ConfigureAwait(false);
                 break;
         }
     }
 
-    private async Task WriteExceptionAsync(string testDisplayName, string? explanation, Exception? exception, CancellationToken cancellationToken)
+    private async Task WriteExceptionAsync(string testDisplayName, string testName, string? explanation, Exception? exception, CancellationToken cancellationToken)
     {
         if (_logger.IsEnabled(LogLevel.Trace))
         {
             _logger.LogTrace("Failure received.");
         }
 
-        string? line = GetErrorText(testDisplayName, explanation, exception, _severity, _fileSystem, _logger, _targetFrameworkMoniker);
-        if (line == null)
+        bool isQuarantined = _quarantineFile?.Matches(testName) == true;
+        if (isQuarantined && Interlocked.Exchange(ref _quarantineBuildTagEmitted, 1) == 0)
+        {
+            await _outputDisplay.DisplayAsync(this, new FormattedTextOutputDeviceData(QuarantineBuildTagLine), cancellationToken).ConfigureAwait(false);
+        }
+
+        string severity = GetSeverity(testName, isQuarantined);
+        string annotationSuffix = BuildAnnotationSuffix(testName, isQuarantined);
+        string? line = GetErrorText(testDisplayName, explanation, exception, severity, _fileSystem, _logger, _targetFrameworkMoniker, annotationSuffix);
+        if (line is null)
         {
             if (_logger.IsEnabled(LogLevel.Trace))
             {
@@ -181,8 +186,11 @@ private async Task WriteExceptionAsync(string testDisplayName, string? explanati
     }
 
     internal static /* for testing */ string? GetErrorText(string testDisplayName, string? explanation, Exception? exception, string severity, IFileSystem fileSystem, ILogger logger, string targetFrameworkMoniker)
+        => GetErrorText(testDisplayName, explanation, exception, severity, fileSystem, logger, targetFrameworkMoniker, additionalMessageSuffix: null);
+
+    internal static /* for testing */ string? GetErrorText(string testDisplayName, string? explanation, Exception? exception, string severity, IFileSystem fileSystem, ILogger logger, string targetFrameworkMoniker, string? additionalMessageSuffix)
     {
-        if (exception == null || exception.StackTrace == null)
+        if (exception is null || exception.StackTrace is null)
         {
             if (logger.IsEnabled(LogLevel.Trace))
             {
@@ -193,8 +201,7 @@ private async Task WriteExceptionAsync(string testDisplayName, string? explanati
         }
 
         string message = explanation ?? exception.Message;
-
-        if (message == null)
+        if (message is null)
         {
             if (logger.IsEnabled(LogLevel.Trace))
             {
@@ -214,7 +221,7 @@ private async Task WriteExceptionAsync(string testDisplayName, string? explanati
         foreach (string? stackFrame in stackTrace.Split(NewlineCharacters, StringSplitOptions.RemoveEmptyEntries))
         {
             (string Code, string File, int LineNumber)? location = GetStackFrameLocation(stackFrame);
-            if (location == null)
+            if (location is null)
             {
                 if (logger.IsEnabled(LogLevel.Trace))
                 {
@@ -237,7 +244,6 @@ private async Task WriteExceptionAsync(string testDisplayName, string? explanati
                 continue;
             }
 
-            // Deterministic build paths start with "/_/"
             string relativePath;
             if (file.StartsWith(DeterministicBuildRoot, StringComparison.OrdinalIgnoreCase))
             {
@@ -247,7 +253,6 @@ private async Task WriteExceptionAsync(string testDisplayName, string? explanati
                 }
 
                 relativePath = file.Substring(DeterministicBuildRoot.Length);
-
                 if (logger.IsEnabled(LogLevel.Trace))
                 {
                     logger.LogTrace($"Using relative path '{relativePath}'.");
@@ -268,7 +273,6 @@ private async Task WriteExceptionAsync(string testDisplayName, string? explanati
             }
             else
             {
-                // Path does not belong to current repo, keep it null.
                 if (logger.IsEnabled(LogLevel.Trace))
                 {
                     logger.LogTrace($"Path '{file}' does not belong to current repo '{repoRoot}'. Continue to next.");
@@ -277,17 +281,9 @@ private async Task WriteExceptionAsync(string testDisplayName, string? explanati
                 continue;
             }
 
-            // Combine with repo root, to be able to resolve deterministic build paths.
             string fullPath = Path.Combine(repoRoot, relativePath);
             if (!fileSystem.ExistFile(fullPath))
             {
-                // Path does not belong to current repository or does not exist, no need to report it because it will not show up in the PR error, we will only see it details of the run, which is the same
-                // as not reporting it this way. Maybe there can be 2 modes, but right now we want this to be usable for GitHub + AzDo, not for pure AzDo.
-                //
-                // In case of deterministic build, all the paths will be relative, so if library carries symbols and matches our path we would see the error as coming from our file
-                // even though it would not. That change is slim and something we have to live with.
-                //
-                // Deterministic build will also have paths normalized to /, luckily File.Exist does not care about the slash direction (on Windows).
                 if (logger.IsEnabled(LogLevel.Trace))
                 {
                     logger.LogTrace($"Path '{fullPath}' does not exist on disk. Continue to next.");
@@ -296,36 +292,121 @@ private async Task WriteExceptionAsync(string testDisplayName, string? explanati
                 continue;
             }
 
-            // The slashes must be / for GitHub to render the error placement correctly.
             string relativeNormalizedPath = relativePath.Replace('\\', '/');
             if (logger.IsEnabled(LogLevel.Trace))
             {
                 logger.LogTrace($"Normalized path for GitHub '{relativeNormalizedPath}'.");
             }
 
-            string formattedMessage = FormatErrorMessage(testDisplayName, targetFrameworkMoniker, message);
+            string formattedMessage = $"{FormatErrorMessage(testDisplayName, targetFrameworkMoniker, message)}{additionalMessageSuffix}";
             string line = $"##vso[task.logissue type={severity};sourcepath={relativeNormalizedPath};linenumber={location.Value.LineNumber};columnnumber=1]{AzDoEscaper.Escape(formattedMessage)}";
             if (logger.IsEnabled(LogLevel.Trace))
             {
                 logger.LogTrace($"Reported full message '{line}'.");
             }
 
-            // Report the error only for the first stack frame that is useful.
             return line;
         }
 
         if (logger.IsEnabled(LogLevel.Trace))
         {
-            logger.LogTrace($"No stack trace line matched criteria, no failure line was reported.");
+            logger.LogTrace("No stack trace line matched criteria, no failure line was reported.");
         }
 
         return null;
     }
 
+    private string GetConfiguredSeverity()
+        => _commandLine.TryGetOptionArgumentList(AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity, out string[]? arguments)
+            && arguments is [string configuredSeverity]
+                ? configuredSeverity.ToLowerInvariant()
+                : "error";
+
+    private QuarantineFile? LoadQuarantineFile()
+    {
+        if (!_commandLine.TryGetOptionArgumentList(AzureDevOpsCommandLineOptions.AzureDevOpsQuarantineFile, out string[]? arguments)
+            || arguments is not [string quarantineFilePath])
+        {
+            return null;
+        }
+
+        // NOTE: The value is treated as an explicit filesystem path supplied by the caller; this extension only validates existence and readability.
+        if (!_fileSystem.ExistFile(quarantineFilePath))
+        {
+            _logger.LogWarning(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.QuarantineFileMissingWarning, quarantineFilePath));
+            return null;
+        }
+
+        try
+        {
+            return new QuarantineFile(quarantineFilePath, _fileSystem, _logger);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            _logger.LogWarning(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.QuarantineFileLoadFailedWarning, quarantineFilePath, ex.Message));
+            return null;
+        }
+    }
+
+    private string GetSeverity(string testName, bool isQuarantined)
+        => isQuarantined || (_demoteKnownFlaky && _historyService.IsLikelyFlaky(testName, KnownFlakyFailureRateThreshold))
+            ? WarningSeverity
+            : _severity ?? "error";
+
+    private string BuildAnnotationSuffix(string testName, bool isQuarantined)
+    {
+        string? historyAnnotation = GetHistoryAnnotation(testName);
+        if (historyAnnotation is null && !isQuarantined)
+        {
+            return string.Empty;
+        }
+
+        StringBuilder builder = new();
+        if (historyAnnotation is not null)
+        {
+            builder.Append(' ').Append(historyAnnotation);
+        }
+
+        if (isQuarantined)
+        {
+            builder.Append(' ').Append(AzureDevOpsResources.QuarantinedAnnotation);
+        }
+
+        return builder.ToString();
+    }
+
+    private string? GetHistoryAnnotation(string testName)
+        => !_historyService.TryGetStats(testName, out FlakyStats stats) || stats.TotalCount == 0
+            ? null
+            : stats.FailCount == 0
+                ? stats.TotalCount >= MinSamplesForRegressionAnnotation
+                    ? AzureDevOpsResources.FlakyHistoryRegressionAnnotation
+                    : null
+                : string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.FlakyHistoryFailureAnnotation, stats.FailCount, stats.TotalCount, _historyService.HistoryWindowInDays);
+
+    private void EnsureEnabledConfigurationLoaded()
+    {
+        if (_hasLoadedEnabledConfiguration)
+        {
+            return;
+        }
+
+        _severity = GetConfiguredSeverity();
+        _demoteKnownFlaky = _commandLine.IsOptionSet(AzureDevOpsCommandLineOptions.AzureDevOpsDemoteKnownFlaky);
+        _quarantineFile = LoadQuarantineFile();
+        _hasLoadedEnabledConfiguration = true;
+    }
+
     private static string GetTargetFrameworkMoniker()
         => TargetFrameworkParser.GetShortTargetFramework(Assembly.GetEntryAssembly()?.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkDisplayName)
             ?? TargetFrameworkParser.GetShortTargetFramework(RuntimeInformation.FrameworkDescription);
 
+    private static string GetTestName(TestNode testNode)
+        => testNode.Properties
+            .OfType<SerializableKeyValuePairStringProperty>()
+            .FirstOrDefault(static property => property.Key == FullyQualifiedNamePropertyKey)?.Value
+            ?? testNode.DisplayName;
+
     /// <summary>
     /// Formats the reporter message so the test name lands on its own line.
     /// PR check UIs (GitHub Checks via the dotnet problem matcher and Azure DevOps)
@@ -372,8 +453,7 @@ private static (string Code, string File, int LineNumber)? GetStackFrameLocation
         }
 
         string code = match.Groups["code"].Value;
-        bool weHaveFilePathAndCodeLine = !RoslynString.IsNullOrWhiteSpace(code);
-        if (!weHaveFilePathAndCodeLine)
+        if (RoslynString.IsNullOrWhiteSpace(code))
         {
             return null;
         }
@@ -385,7 +465,6 @@ private static (string Code, string File, int LineNumber)? GetStackFrameLocation
         }
 
         int line = int.TryParse(match.Groups["line"].Value, out int value) ? value : 0;
-
         return (code, file, line);
     }
 }
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/FlakyStats.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/FlakyStats.cs
new file mode 100644
index 0000000000..c277acd7de
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/FlakyStats.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Testing.Extensions.AzureDevOpsReport;
+
+internal readonly struct FlakyStats
+{
+    public FlakyStats(int passCount, int failCount)
+    {
+        PassCount = passCount;
+        FailCount = failCount;
+    }
+
+    public int PassCount { get; }
+
+    public int FailCount { get; }
+
+    public int TotalCount => PassCount + FailCount;
+
+    public double FailureRate => TotalCount == 0 ? 0 : (double)FailCount / TotalCount;
+}
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/IAzureDevOpsHistoryService.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/IAzureDevOpsHistoryService.cs
new file mode 100644
index 0000000000..c87575d9f6
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/IAzureDevOpsHistoryService.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Testing.Extensions.AzureDevOpsReport;
+
+internal interface IAzureDevOpsHistoryService
+{
+    int HistoryWindowInDays { get; }
+
+    bool TryGetStats(string testName, out FlakyStats stats);
+
+    bool IsLikelyFlaky(string testName, double threshold);
+}
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Microsoft.Testing.Extensions.AzureDevOpsReport.csproj b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Microsoft.Testing.Extensions.AzureDevOpsReport.csproj
index 025d2c16f3..584c40e84b 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Microsoft.Testing.Extensions.AzureDevOpsReport.csproj
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Microsoft.Testing.Extensions.AzureDevOpsReport.csproj
@@ -47,12 +47,17 @@ This package extends Microsoft Testing Platform to provide a Azure DevOps report
     <Compile Include="$(RepoRoot)src/Polyfills/**/*.cs" Link="Polyfills\%(RecursiveDir)%(Filename)%(Extension)" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="System.Text.Json" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="$(RepoRoot)src\Platform\Microsoft.Testing.Platform\Microsoft.Testing.Platform.csproj" />
   </ItemGroup>
 
   <ItemGroup>
     <InternalsVisibleTo Include="Microsoft.Testing.Extensions.UnitTests" Key="$(VsPublicKey)" />
+    <InternalsVisibleTo Include="DynamicProxyGenAssembly2" Key="$(MoqPublicKey)" />
   </ItemGroup>
 
 </Project>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/QuarantineFile.cs b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/QuarantineFile.cs
new file mode 100644
index 0000000000..c35d07c6fa
--- /dev/null
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/QuarantineFile.cs
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Extensions.AzureDevOpsReport.Resources;
+using Microsoft.Testing.Platform;
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.Logging;
+
+namespace Microsoft.Testing.Extensions.AzureDevOpsReport;
+
+internal sealed class QuarantineFile
+{
+    private const int MaxPatternCount = 10_000;
+    private const int MaxPatternLength = 4 * 1024;
+
+    // TODO: Consider an opt-in modifier for case-insensitive quarantine matching if customer scenarios require it.
+    private static readonly RegexOptions RegexOptions = RegexOptions.CultureInvariant;
+
+    private readonly Regex[] _patterns;
+
+    public QuarantineFile(string path, IFileSystem fileSystem, ILogger logger)
+        : this(ParsePatterns(fileSystem.ReadAllText(path), logger))
+    {
+    }
+
+    internal QuarantineFile(IEnumerable<string> patterns)
+        => _patterns = [.. patterns.Select(CreatePatternRegex)];
+
+    public bool Matches(string testFqn)
+    {
+        if (RoslynString.IsNullOrWhiteSpace(testFqn))
+        {
+            return false;
+        }
+
+        string normalizedTestFqn = Normalize(testFqn);
+        foreach (Regex pattern in _patterns)
+        {
+            if (pattern.IsMatch(normalizedTestFqn))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static IEnumerable<string> ParsePatterns(string fileContent, ILogger logger)
+    {
+        int patternCount = 0;
+        foreach (string line in fileContent.Split(['\r', '\n'], StringSplitOptions.RemoveEmptyEntries))
+        {
+            string trimmedLine = line.Trim();
+            if (trimmedLine.Length == 0 || trimmedLine.StartsWith("#", StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            string normalizedPattern = Normalize(trimmedLine);
+            if (normalizedPattern.Length > MaxPatternLength)
+            {
+                logger.LogWarning(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.QuarantinePatternTooLongWarning, MaxPatternLength));
+                continue;
+            }
+
+            if (patternCount >= MaxPatternCount)
+            {
+                logger.LogWarning(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.QuarantinePatternsCappedWarning, MaxPatternCount));
+                yield break;
+            }
+
+            patternCount++;
+            yield return normalizedPattern;
+        }
+    }
+
+    private static Regex CreatePatternRegex(string pattern)
+    {
+        string escapedPattern = Regex.Escape(pattern)
+            .Replace("\\*", ".*")
+            .Replace("\\?", ".");
+
+        return new Regex($"^{escapedPattern}$", RegexOptions);
+    }
+
+    private static string Normalize(string value)
+        => value.Trim();
+}
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/AzureDevOpsResources.resx b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/AzureDevOpsResources.resx
index 516d5d4382..e3b964e574 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/AzureDevOpsResources.resx
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/AzureDevOpsResources.resx
@@ -1,4 +1,4 @@
-﻿<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <root>
   <!-- 
     Microsoft ResX Schema 
@@ -121,7 +121,7 @@
     <value>'--report-azdo-severity' requires '--report-azdo' to be enabled</value>
   </data>
   <data name="Description" xml:space="preserve">
-    <value>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</value>
+    <value>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</value>
   </data>
   <data name="DisplayName" xml:space="preserve">
     <value>Azure DevOps report generator</value>
@@ -130,10 +130,77 @@
     <value>Invalid option {0}.</value>
   </data>
   <data name="OptionDescription" xml:space="preserve">
-    <value>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</value>
+    <value>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</value>
   </data>
   <data name="SeverityOptionDescription" xml:space="preserve">
     <value>Severity to use for the reported event. Options are: error (default) and warning.</value>
     <comment>{Locked="error"}{Locked="warning"}</comment>
   </data>
+  <data name="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps" xml:space="preserve">
+    <value>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</value>
+  </data>
+  <data name="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory" xml:space="preserve">
+    <value>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</value>
+  </data>
+  <data name="AzureDevOpsFlakyHistoryRequiresAzureDevOps" xml:space="preserve">
+    <value>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</value>
+  </data>
+  <data name="AzureDevOpsQuarantineFileRequiresAzureDevOps" xml:space="preserve">
+    <value>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</value>
+  </data>
+  <data name="DemoteKnownFlakyOptionDescription" xml:space="preserve">
+    <value>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</value>
+    <comment>{0} is the percentage threshold (e.g., 25).</comment>
+  </data>
+  <data name="FlakyHistoryFailureAnnotation" xml:space="preserve">
+    <value>[flaky: failed {0}/{1} in last {2}d]</value>
+    <comment>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</comment>
+  </data>
+  <data name="FlakyHistoryLoadFailedWarning" xml:space="preserve">
+    <value>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</value>
+    <comment>{Locked='--report-azdo-flaky-history'}</comment>
+  </data>
+  <data name="FlakyHistoryLoadTimedOutInfo" xml:space="preserve">
+    <value>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</value>
+  </data>
+  <data name="FlakyHistoryMissingEnvironmentWarning" xml:space="preserve">
+    <value>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</value>
+    <comment>{Locked='--report-azdo-flaky-history'}</comment>
+  </data>
+  <data name="FlakyHistoryOptionDescription" xml:space="preserve">
+    <value>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</value>
+  </data>
+  <data name="FlakyHistoryRegressionAnnotation" xml:space="preserve">
+    <value>[REGRESSION]</value>
+    <comment>{Locked="[REGRESSION]"}</comment>
+  </data>
+  <data name="FlakyHistoryRunsCappedInfo" xml:space="preserve">
+    <value>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</value>
+  </data>
+  <data name="FlakyHistoryResultsPagingStoppedWarning" xml:space="preserve">
+    <value>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</value>
+  </data>
+  <data name="InvalidFlakyHistoryDays" xml:space="preserve">
+    <value>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</value>
+  </data>
+  <data name="QuarantinedAnnotation" xml:space="preserve">
+    <value>[quarantined]</value>
+    <comment>{Locked="[quarantined]"}</comment>
+  </data>
+  <data name="QuarantineFileLoadFailedWarning" xml:space="preserve">
+    <value>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</value>
+    <comment>{Locked='--report-azdo-quarantine-file'}</comment>
+  </data>
+  <data name="QuarantineFileMissingWarning" xml:space="preserve">
+    <value>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</value>
+  </data>
+  <data name="QuarantineFileOptionDescription" xml:space="preserve">
+    <value>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</value>
+  </data>
+  <data name="QuarantinePatternTooLongWarning" xml:space="preserve">
+    <value>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</value>
+  </data>
+  <data name="QuarantinePatternsCappedWarning" xml:space="preserve">
+    <value>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.cs.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.cs.xlf
index 076a3037b9..cb5c35bd63 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.cs.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.cs.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="cs" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">--report-azdo-severity vyžaduje, aby byla povolena možnost --report-azdo</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Generátor sestav Azure DevOps pro zápis chyb do výstupu způsobem, který je pro AzureDev Ops srozumitelný.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Generátor sestav Azure DevOps pro zápis chyb do výstupu způsobem, který je pro AzureDev Ops srozumitelný.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Generátor sestav Azure DevOps</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">Neplatná možnost {0}.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Umožňuje generátoru sestav Azure DevOps zapisovat chyby do výstupu způsobem, který je pro AzureDev Ops srozumitelný.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Umožňuje generátoru sestav Azure DevOps zapisovat chyby do výstupu způsobem, který je pro AzureDev Ops srozumitelný.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">Závažnost, která se má použít pro hlášenou událost. Možnosti: error (výchozí) a warning.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.de.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.de.xlf
index 87be6a6ce5..cdc84a698c 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.de.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.de.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="de" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">Für „--report-azdo-severity“ muss „--report-azdo“ aktiviert sein.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Azure DevOps-Berichts-Generator, um Fehler auf eine Weise in die Ausgabe zu schreiben, die AzureDev Ops versteht.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Azure DevOps-Berichts-Generator, um Fehler auf eine Weise in die Ausgabe zu schreiben, die AzureDev Ops versteht.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Azure DevOps-Berichts-Generator</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">Ungültige Option „{0}“.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Azure DevOps-Berichts-Generator aktivieren, um Fehler auf eine Weise in die Ausgabe zu schreiben, die AzureDev Ops versteht.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Azure DevOps-Berichts-Generator aktivieren, um Fehler auf eine Weise in die Ausgabe zu schreiben, die AzureDev Ops versteht.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">Schweregrad, der für das gemeldete Ereignis verwendet werden soll. Optionen sind: error (Standard) und warning.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.es.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.es.xlf
index c4a61c952f..8b61f32139 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.es.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.es.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="es" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">"--report-azdo-severity" requiere que se habilite "--report-azdo"</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">El generador de informes de Azure DevOps escribe errores en la salida de una manera que AzureDev Ops comprende.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">El generador de informes de Azure DevOps escribe errores en la salida de una manera que AzureDev Ops comprende.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Generador de informes de Azure DevOps</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">Opción no válida {0}.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Habilite el generador de informes de Azure DevOps para escribir errores en la salida de una manera que AzureDev Ops comprenda.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Habilite el generador de informes de Azure DevOps para escribir errores en la salida de una manera que AzureDev Ops comprenda.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">Gravedad que se va a usar para el evento notificado. Las opciones son: error (valor predeterminado) y warning.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.fr.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.fr.xlf
index 4feb6d0ab7..5b1a668495 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.fr.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.fr.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="fr" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">« --report-azdo-severity » nécessite l’activation de « --report-azdo »</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Générateur de rapports Azure DevOps pour écrire les erreurs dans la sortie d’une manière comprise par Azure DevOps.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Générateur de rapports Azure DevOps pour écrire les erreurs dans la sortie d’une manière comprise par Azure DevOps.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Générateur de rapports Azure DevOps</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">Option {0} non valide.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Activez le générateur de rapports Azure DevOps pour écrire les erreurs dans la sortie d’une manière comprise par Azure DevOps.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Activez le générateur de rapports Azure DevOps pour écrire les erreurs dans la sortie d’une manière comprise par Azure DevOps.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">Gravité à utiliser pour l’événement signalé. Les options sont : error (par défaut) et warning.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.it.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.it.xlf
index d9756f675c..a0e7366077 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.it.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.it.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="it" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">'--report-azdo-severity' richiede l'autenticazione di '--report-azdo'</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Il generatore di report di Azure DevOps per scrivere gli errori nell'output in un modo che Azure DevOps comprenda.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Il generatore di report di Azure DevOps per scrivere gli errori nell'output in un modo che Azure DevOps comprenda.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Generatore di report di Azure DevOps</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">Opzione non valida {0}.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Abilitare il generatore di report di Azure DevOps per scrivere gli errori nell'output in un modo che Azure DevOps comprenda.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Abilitare il generatore di report di Azure DevOps per scrivere gli errori nell'output in un modo che Azure DevOps comprenda.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">Gravità da usare per l'evento segnalato. Le opzioni sono: error (impostazione predefinita) e warning.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ja.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ja.xlf
index ea3529945b..1ce41fa03c 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ja.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ja.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="ja" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">'--report-azdo-severity' では、'--report-azdo' を有効にする必要があります</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">AzureDev Ops が理解する方法で出力にエラーを書き込む Azure DevOps レポート生成プログラム。</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">AzureDev Ops が理解する方法で出力にエラーを書き込む Azure DevOps レポート生成プログラム。</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Azure DevOps レポート生成プログラム</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">オプション {0} が無効です。</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Azure DevOps レポート生成プログラムを有効にして、AzureDev Ops が理解する方法で出力にエラーを書き込みます。</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Azure DevOps レポート生成プログラムを有効にして、AzureDev Ops が理解する方法で出力にエラーを書き込みます。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">報告されたイベントに使用する重大度。オプションは、error (既定) と warning です。</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ko.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ko.xlf
index f74caa7f6e..fcc5b7b7d6 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ko.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ko.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="ko" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">'--report-azdo-severity'를 사용하려면 '--report-azdo'를 사용 설정 해야합니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Azure DevOps가 이해할 수 있는 방식으로 출력에 오류를 기록하는 Azure DevOps 보고서 생성기입니다.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Azure DevOps가 이해할 수 있는 방식으로 출력에 오류를 기록하는 Azure DevOps 보고서 생성기입니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Azure DevOps 보고서 생성기</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">{0} 옵션이 잘못되었습니다.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Azure DevOps 보고서 생성기를 활성화하여 Azure DevOps가 이해할 수 있는 방식으로 출력에 오류를 기록합니다.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Azure DevOps 보고서 생성기를 활성화하여 Azure DevOps가 이해할 수 있는 방식으로 출력에 오류를 기록합니다.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">보고된 이벤트에 사용할 심각도입니다. 옵션은 error(기본값)와 warning, 두 가지입니다.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.pl.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.pl.xlf
index 8890f27f70..667832ae4d 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.pl.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.pl.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="pl" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">Element „--report-azdo-severity” wymaga włączenia polecenia „--report-azdo”</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Generator raportów usługi Azure DevOps umożliwiający zapisywanie błędów w danych wyjściowych w sposób zrozumiały dla usługi Azure DevOps.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Generator raportów usługi Azure DevOps umożliwiający zapisywanie błędów w danych wyjściowych w sposób zrozumiały dla usługi Azure DevOps.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Generator raportów usługi Azure DevOps</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">Nieprawidłowa opcja {0}.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Włącz generator raportów usługi Azure DevOps, aby zapisywać błędy w danych wyjściowych w sposób zrozumiały dla usługi Azure DevOps.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Włącz generator raportów usługi Azure DevOps, aby zapisywać błędy w danych wyjściowych w sposób zrozumiały dla usługi Azure DevOps.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">Ważność do użycia dla zgłoszonego zdarzenia. Dostępne opcje to: error (domyślny) i warning.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.pt-BR.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.pt-BR.xlf
index d660d0e56a..c87abf5837 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.pt-BR.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.pt-BR.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="pt-BR" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">'--report-azdo-severity' requer que '--report-azdo' esteja habilitado</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Gerador de relatórios do Azure DevOps para gravar erros na saída de uma forma que o Azure DevOps entenda.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Gerador de relatórios do Azure DevOps para gravar erros na saída de uma forma que o Azure DevOps entenda.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Gerador de relatórios do Azure DevOps</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">Opção {0} inválida.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Habilitar o gerador de relatórios do Azure DevOps para gravar erros na saída de uma forma que o Azure DevOps entenda.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Habilitar o gerador de relatórios do Azure DevOps para gravar erros na saída de uma forma que o Azure DevOps entenda.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">A gravidade que será usada para o evento relatado. As opções são: error (padrão) e warning.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ru.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ru.xlf
index 756d7c9cae..ed4fee6fed 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ru.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.ru.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="ru" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">"--report-azdo-severity" требует включения "--report-azdo"</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Генератор отчетов Azure DevOps для записи ошибок в выходные данные в формате, который понимает Azure DevOps.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Генератор отчетов Azure DevOps для записи ошибок в выходные данные в формате, который понимает Azure DevOps.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Генератор отчетов Azure DevOps</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">Недопустимый параметр {0}.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Включите генератор отчетов Azure DevOps для записи ошибок в выходные данные в формате, который понимает Azure DevOps.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Включите генератор отчетов Azure DevOps для записи ошибок в выходные данные в формате, который понимает Azure DevOps.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">Уровень серьезности, используемый для события из отчета. Параметры: error (по умолчанию) и warning.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.tr.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.tr.xlf
index 69207860a2..5e98d26d6d 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.tr.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.tr.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="tr" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">'--report-azdo-severity' öğesi '--report-azdo' öğesinin etkinleştirilmesini gerektirir</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Hataları Azure DevOps'un anlayacağı şekilde çıktıya yazan Azure DevOps rapor oluşturucusu.</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Hataları Azure DevOps'un anlayacağı şekilde çıktıya yazan Azure DevOps rapor oluşturucusu.</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Azure DevOps rapor oluşturucusu</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">Geçersiz seçenek{0}.</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Azure DevOps rapor oluşturucusunu, hataları Azure DevOps'un anlayacağı şekilde çıktıya yazması için etkinleştirin.</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Azure DevOps rapor oluşturucusunu, hataları Azure DevOps'un anlayacağı şekilde çıktıya yazması için etkinleştirin.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">Raporlanan olay için kullanılacak önem derecesi. Seçenekler şunlardır: error (varsayılan) ve warning.</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.zh-Hans.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.zh-Hans.xlf
index 2b5199f4ad..01b806a7e9 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.zh-Hans.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.zh-Hans.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="zh-Hans" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">'--report-azdo-severity' 要求启用 '--report-azdo'</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Azure DevOps报表生成器，可通过 Azure DevOps 可理解的方式将错误写入输出。</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Azure DevOps报表生成器，可通过 Azure DevOps 可理解的方式将错误写入输出。</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Azure DevOps报表生成器</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">选项 {0} 无效。</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">启用 Azure DevOps 报表生成器，以通过 Azure DevOps 可理解的方式将错误写入输出。</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">启用 Azure DevOps 报表生成器，以通过 Azure DevOps 可理解的方式将错误写入输出。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">要用于所报告事件的严重性。选项为: error (默认)和 warning。</target>
diff --git a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.zh-Hant.xlf b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.zh-Hant.xlf
index 6c61f0fb8f..921b1f2d74 100644
--- a/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.zh-Hant.xlf
+++ b/src/Platform/Microsoft.Testing.Extensions.AzureDevOpsReport/Resources/xlf/AzureDevOpsResources.zh-Hant.xlf
@@ -2,14 +2,39 @@
 <xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
   <file datatype="xml" source-language="en" target-language="zh-Hant" original="../AzureDevOpsResources.resx">
     <body>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory">
+        <source>'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</source>
+        <target state="new">'--report-azdo-demote-known-flaky' requires '--report-azdo-flaky-history' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsFlakyHistoryRequiresAzureDevOps">
+        <source>'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-flaky-history' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AzureDevOpsQuarantineFileRequiresAzureDevOps">
+        <source>'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</source>
+        <target state="new">'--report-azdo-quarantine-file' requires '--report-azdo' to be enabled</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AzureDevOpsReportSeverityRequiresAzureDevOps">
         <source>'--report-azdo-severity' requires '--report-azdo' to be enabled</source>
         <target state="translated">'--report-azdo-severity' 需要啟用 '--report-azdo'</target>
         <note />
       </trans-unit>
+      <trans-unit id="DemoteKnownFlakyOptionDescription">
+        <source>Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</source>
+        <target state="new">Demote failures with an Azure DevOps flaky history of at least {0}% in the selected window to warnings.</target>
+        <note>{0} is the percentage threshold (e.g., 25).</note>
+      </trans-unit>
       <trans-unit id="Description">
-        <source>Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">Azure DevOps 報告產生器以 Azure DevOps 可理解的方式將錯誤寫入輸出。</target>
+        <source>Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">Azure DevOps 報告產生器以 Azure DevOps 可理解的方式將錯誤寫入輸出。</target>
         <note />
       </trans-unit>
       <trans-unit id="DisplayName">
@@ -17,16 +42,91 @@
         <target state="translated">Azure DevOps 報告產生器</target>
         <note />
       </trans-unit>
+      <trans-unit id="FlakyHistoryFailureAnnotation">
+        <source>[flaky: failed {0}/{1} in last {2}d]</source>
+        <target state="new">[flaky: failed {0}/{1} in last {2}d]</target>
+        <note>{Locked="[flaky: failed {0}/{1} in last {2}d]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadFailedWarning">
+        <source>Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</source>
+        <target state="new">Unable to load Azure DevOps flaky history. Continuing without history annotations. {0}</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryLoadTimedOutInfo">
+        <source>Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history did not finish loading within {0} seconds. Continuing without history annotations.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryMissingEnvironmentWarning">
+        <source>Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</source>
+        <target state="new">Azure DevOps flaky history was requested but the required Azure DevOps environment variables are missing. Continuing without history annotations.</target>
+        <note>{Locked='--report-azdo-flaky-history'}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryOptionDescription">
+        <source>Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</source>
+        <target state="new">Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRegressionAnnotation">
+        <source>[REGRESSION]</source>
+        <target state="new">[REGRESSION]</target>
+        <note>{Locked="[REGRESSION]"}</note>
+      </trans-unit>
+      <trans-unit id="FlakyHistoryResultsPagingStoppedWarning">
+        <source>Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</source>
+        <target state="new">Azure DevOps flaky history for run '{0}' exceeded {1} pages or returned an unchanged continuation token. Remaining results will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="FlakyHistoryRunsCappedInfo">
+        <source>Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</source>
+        <target state="new">Azure DevOps flaky history returned {0} runs. Only the first {1} runs will be inspected.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="InvalidFlakyHistoryDays">
+        <source>Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</source>
+        <target state="new">Invalid value '{0}' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="InvalidSeverity">
         <source>Invalid option {0}.</source>
         <target state="translated">無效的選項 {0}。</target>
         <note />
       </trans-unit>
       <trans-unit id="OptionDescription">
-        <source>Eanble Azure DevOps report generator to write errors to the output in a way that AzureDev Ops understands.</source>
-        <target state="translated">啟用 Azure DevOps 報告產生器，以 Azure DevOps 可理解的方式將錯誤寫入輸出。</target>
+        <source>Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.</source>
+        <target state="needs-review-translation">啟用 Azure DevOps 報告產生器，以 Azure DevOps 可理解的方式將錯誤寫入輸出。</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileLoadFailedWarning">
+        <source>Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</source>
+        <target state="new">Unable to load Azure DevOps quarantine file '{0}'. Continuing without quarantine awareness. {1}</target>
+        <note>{Locked='--report-azdo-quarantine-file'}</note>
+      </trans-unit>
+      <trans-unit id="QuarantineFileMissingWarning">
+        <source>Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</source>
+        <target state="new">Azure DevOps quarantine file '{0}' does not exist. Continuing without quarantine awareness.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantineFileOptionDescription">
+        <source>Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</source>
+        <target state="new">Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternTooLongWarning">
+        <source>Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</source>
+        <target state="new">Azure DevOps quarantine pattern exceeds the {0} character limit and will be ignored.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="QuarantinePatternsCappedWarning">
+        <source>Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</source>
+        <target state="new">Azure DevOps quarantine file contains more than {0} patterns. Remaining patterns will be ignored.</target>
         <note />
       </trans-unit>
+      <trans-unit id="QuarantinedAnnotation">
+        <source>[quarantined]</source>
+        <target state="new">[quarantined]</target>
+        <note>{Locked="[quarantined]"}</note>
+      </trans-unit>
       <trans-unit id="SeverityOptionDescription">
         <source>Severity to use for the reported event. Options are: error (default) and warning.</source>
         <target state="translated">要用於所報告事件的嚴重性。選項為: error (預設) warning。</target>
diff --git a/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/AzureDevOpsCommandLineTests.cs b/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/AzureDevOpsCommandLineTests.cs
new file mode 100644
index 0000000000..e6dfdbb7b0
--- /dev/null
+++ b/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/AzureDevOpsCommandLineTests.cs
@@ -0,0 +1,107 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Testing.Platform.Acceptance.IntegrationTests;
+
+[TestClass]
+public sealed class AzureDevOpsCommandLineTests : AcceptanceTestBase<AzureDevOpsCommandLineTests.TestAssetFixture>
+{
+    private const string AssetName = "AzureDevOpsCommandLineValidation";
+
+    public TestContext TestContext { get; set; } = null!;
+
+    [DynamicData(nameof(TargetFrameworks.AllForDynamicData), typeof(TargetFrameworks))]
+    [TestMethod]
+    public async Task AzureDevOps_WhenFlakyHistoryValueIsInvalid_ShouldFail(string tfm)
+    {
+        var testHost = TestInfrastructure.TestHost.LocateFrom(AssetFixture.TargetAssetPath, AssetName, tfm);
+        TestHostResult testHostResult = await testHost.ExecuteAsync("--report-azdo --report-azdo-flaky-history 0", cancellationToken: TestContext.CancellationToken);
+
+        testHostResult.AssertExitCodeIs(ExitCode.InvalidCommandLine);
+        testHostResult.AssertOutputContains("Option '--report-azdo-flaky-history' has invalid arguments: Invalid value '0' for '--report-azdo-flaky-history'. Provide an integer between 1 and 90.");
+    }
+
+    [DynamicData(nameof(TargetFrameworks.AllForDynamicData), typeof(TargetFrameworks))]
+    [TestMethod]
+    public async Task AzureDevOps_WhenSeverityValueIsInvalid_ShouldFail(string tfm)
+    {
+        var testHost = TestInfrastructure.TestHost.LocateFrom(AssetFixture.TargetAssetPath, AssetName, tfm);
+        TestHostResult testHostResult = await testHost.ExecuteAsync("--report-azdo --report-azdo-severity invalid", cancellationToken: TestContext.CancellationToken);
+
+        testHostResult.AssertExitCodeIs(ExitCode.InvalidCommandLine);
+        testHostResult.AssertOutputContains("Option '--report-azdo-severity' has invalid arguments: Invalid option invalid.");
+    }
+
+    public sealed class TestAssetFixture() : TestAssetFixtureBase()
+    {
+        private const string Sources = """
+#file AzureDevOpsCommandLineValidation.csproj
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>$TargetFrameworks$</TargetFrameworks>
+    <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
+    <LangVersion>preview</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Testing.Extensions.AzureDevOpsReport" Version="$MicrosoftTestingPlatformVersion$" />
+  </ItemGroup>
+</Project>
+
+#file Program.cs
+using System.Threading.Tasks;
+
+using Microsoft.Testing.Extensions;
+using Microsoft.Testing.Platform.Builder;
+using Microsoft.Testing.Platform.Capabilities.TestFramework;
+using Microsoft.Testing.Platform.Extensions.TestFramework;
+using Microsoft.Testing.Platform.Services;
+
+public class Program
+{
+    public static async Task<int> Main(string[] args)
+    {
+        ITestApplicationBuilder builder = await TestApplication.CreateBuilderAsync(args);
+        builder.RegisterTestFramework(
+            _ => new TestFrameworkCapabilities(),
+            (_,__) => new DummyTestFramework());
+        builder.AddAzureDevOpsProvider();
+        using ITestApplication app = await builder.BuildAsync();
+        return await app.RunAsync();
+    }
+}
+
+public class DummyTestFramework : ITestFramework
+{
+    public string Uid => nameof(DummyTestFramework);
+
+    public string Version => "2.0.0";
+
+    public string DisplayName => nameof(DummyTestFramework);
+
+    public string Description => nameof(DummyTestFramework);
+
+    public Task<bool> IsEnabledAsync() => Task.FromResult(true);
+
+    public Task<CreateTestSessionResult> CreateTestSessionAsync(CreateTestSessionContext context)
+        => Task.FromResult(new CreateTestSessionResult() { IsSuccess = true });
+
+    public Task<CloseTestSessionResult> CloseTestSessionAsync(CloseTestSessionContext context)
+        => Task.FromResult(new CloseTestSessionResult() { IsSuccess = true });
+
+    public Task ExecuteRequestAsync(ExecuteRequestContext context)
+    {
+        context.Complete();
+        return Task.CompletedTask;
+    }
+}
+""";
+
+        public string TargetAssetPath => GetAssetPath(AssetName);
+
+        public override (string ID, string Name, string Code) GetAssetsToGenerate() => (AssetName, AssetName,
+            Sources
+                .PatchTargetFrameworks(TargetFrameworks.All)
+                .PatchCodeWithReplace("$MicrosoftTestingPlatformVersion$", MicrosoftTestingPlatformVersion));
+    }
+}
diff --git a/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/HelpInfoAllExtensionsTests.cs b/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/HelpInfoAllExtensionsTests.cs
index d989315655..7217ba2fc8 100644
--- a/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/HelpInfoAllExtensionsTests.cs
+++ b/test/IntegrationTests/Microsoft.Testing.Platform.Acceptance.IntegrationTests/HelpInfoAllExtensionsTests.cs
@@ -103,6 +103,16 @@ Disable reporting progress to screen.
     --output
         Output verbosity when reporting tests.
         Valid values are 'Normal', 'Detailed'. Default is 'Normal'.
+    --report-azdo
+        Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.
+    --report-azdo-demote-known-flaky
+        Demote failures with an Azure DevOps flaky history of at least 25% in the selected window to warnings.
+    --report-azdo-flaky-history
+        Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.
+    --report-azdo-quarantine-file
+        Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.
+    --report-azdo-severity
+        Severity to use for the reported event. Options are: error (default) and warning.
     --report-trx
         Enable generating TRX report
     --report-trx-filename
@@ -269,6 +279,31 @@ Note that this is slowing down the test execution.
         Description: A global test execution timeout.
         Takes one argument as string in the format <value>[h|m|s] where 'value' is float.
 Registered command line providers:
+  AzureDevOpsCommandLineProvider
+    Name: Azure DevOps report generator
+    Version: *
+    Description: Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.
+    Options:
+      --report-azdo
+        Arity: 0
+        Hidden: False
+        Description: Enable Azure DevOps report generator to write errors to the output in a way that Azure DevOps understands.
+      --report-azdo-demote-known-flaky
+        Arity: 0
+        Hidden: False
+        Description: Demote failures with an Azure DevOps flaky history of at least 25% in the selected window to warnings.
+      --report-azdo-flaky-history
+        Arity: 1
+        Hidden: False
+        Description: Query Azure DevOps test result history for the past N days (1-90) and annotate reported failures with flakiness context.
+      --report-azdo-quarantine-file
+        Arity: 1
+        Hidden: False
+        Description: Path to a text file that lists quarantined test fully qualified names or glob patterns. Matching failures are reported as warnings.
+      --report-azdo-severity
+        Arity: 1
+        Hidden: False
+        Description: Severity to use for the reported event. Options are: error (default) and warning.
   CrashDumpCommandLineProvider
     Name: Crash dump
     Version: *
@@ -439,6 +474,7 @@ public sealed class TestAssetFixture() : TestAssetFixtureBase()
     </PropertyGroup>
     <ItemGroup>
         <PackageReference Include="Microsoft.Testing.Platform.MSBuild" Version="$MicrosoftTestingPlatformVersion$" />
+        <PackageReference Include="Microsoft.Testing.Extensions.AzureDevOpsReport" Version="$MicrosoftTestingPlatformVersion$" />
         <PackageReference Include="Microsoft.Testing.Extensions.CrashDump" Version="$MicrosoftTestingPlatformVersion$" />
         <PackageReference Include="Microsoft.Testing.Extensions.HangDump" Version="$MicrosoftTestingPlatformVersion$" />
         <PackageReference Include="Microsoft.Testing.Extensions.HotReload" Version="$MicrosoftTestingPlatformVersion$" />
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsCommandLineProviderTests.cs b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsCommandLineProviderTests.cs
new file mode 100644
index 0000000000..f3c00741c6
--- /dev/null
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsCommandLineProviderTests.cs
@@ -0,0 +1,97 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Testing.Extensions.AzureDevOpsReport.Resources;
+using Microsoft.Testing.Extensions.Reporting;
+using Microsoft.Testing.Extensions.UnitTests.Helpers;
+using Microsoft.Testing.Platform.CommandLine;
+using Microsoft.Testing.Platform.Extensions;
+
+namespace Microsoft.Testing.Extensions.UnitTests;
+
+[TestClass]
+public sealed class AzureDevOpsCommandLineProviderTests
+{
+    [TestMethod]
+    public async Task ValidateCommandLineOptionsAsync_ReturnsInvalid_WhenDemoteKnownFlakyIsUsedWithoutAzureDevOpsAsync()
+    {
+        AzureDevOpsCommandLineProvider provider = new();
+        ValidationResult validationResult = await provider.ValidateCommandLineOptionsAsync(new TestCommandLineOptions(new Dictionary<string, string[]>
+        {
+            [AzureDevOpsCommandLineOptions.AzureDevOpsDemoteKnownFlaky] = [],
+        })).ConfigureAwait(false);
+
+        Assert.IsFalse(validationResult.IsValid);
+        Assert.AreEqual(AzureDevOpsResources.AzureDevOpsDemoteKnownFlakyRequiresAzureDevOps, validationResult.ErrorMessage);
+    }
+
+    [TestMethod]
+    public async Task ValidateCommandLineOptionsAsync_ReturnsInvalid_WhenFlakyHistoryIsUsedWithoutAzureDevOpsAsync()
+    {
+        AzureDevOpsCommandLineProvider provider = new();
+        ValidationResult validationResult = await provider.ValidateCommandLineOptionsAsync(new TestCommandLineOptions(new Dictionary<string, string[]>
+        {
+            [AzureDevOpsCommandLineOptions.AzureDevOpsFlakyHistory] = ["14"],
+        })).ConfigureAwait(false);
+
+        Assert.IsFalse(validationResult.IsValid);
+        Assert.AreEqual(AzureDevOpsResources.AzureDevOpsFlakyHistoryRequiresAzureDevOps, validationResult.ErrorMessage);
+    }
+
+    [TestMethod]
+    public async Task ValidateCommandLineOptionsAsync_ReturnsInvalid_WhenQuarantineFileIsUsedWithoutAzureDevOpsAsync()
+    {
+        AzureDevOpsCommandLineProvider provider = new();
+        ValidationResult validationResult = await provider.ValidateCommandLineOptionsAsync(new TestCommandLineOptions(new Dictionary<string, string[]>
+        {
+            [AzureDevOpsCommandLineOptions.AzureDevOpsQuarantineFile] = ["quarantine.txt"],
+        })).ConfigureAwait(false);
+
+        Assert.IsFalse(validationResult.IsValid);
+        Assert.AreEqual(AzureDevOpsResources.AzureDevOpsQuarantineFileRequiresAzureDevOps, validationResult.ErrorMessage);
+    }
+
+    [TestMethod]
+    public async Task ValidateCommandLineOptionsAsync_ReturnsInvalid_WhenSeverityIsUsedWithoutAzureDevOpsAsync()
+    {
+        AzureDevOpsCommandLineProvider provider = new();
+        ValidationResult validationResult = await provider.ValidateCommandLineOptionsAsync(new TestCommandLineOptions(new Dictionary<string, string[]>
+        {
+            [AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity] = ["warning"],
+        })).ConfigureAwait(false);
+
+        Assert.IsFalse(validationResult.IsValid);
+        Assert.AreEqual(AzureDevOpsResources.AzureDevOpsReportSeverityRequiresAzureDevOps, validationResult.ErrorMessage);
+    }
+
+    [TestMethod]
+    public async Task ValidateCommandLineOptionsAsync_ReturnsInvalid_WhenDemoteKnownFlakyIsUsedWithoutFlakyHistoryAsync()
+    {
+        AzureDevOpsCommandLineProvider provider = new();
+        ValidationResult validationResult = await provider.ValidateCommandLineOptionsAsync(new TestCommandLineOptions(new Dictionary<string, string[]>
+        {
+            [AzureDevOpsCommandLineOptions.AzureDevOpsOptionName] = [],
+            [AzureDevOpsCommandLineOptions.AzureDevOpsDemoteKnownFlaky] = [],
+        })).ConfigureAwait(false);
+
+        Assert.IsFalse(validationResult.IsValid);
+        Assert.AreEqual(AzureDevOpsResources.AzureDevOpsDemoteKnownFlakyRequiresFlakyHistory, validationResult.ErrorMessage);
+    }
+
+    [TestMethod]
+    public async Task ValidateCommandLineOptionsAsync_ReturnsValid_WhenAzureDevOpsDependentOptionsAreConfiguredCorrectlyAsync()
+    {
+        AzureDevOpsCommandLineProvider provider = new();
+        ValidationResult validationResult = await provider.ValidateCommandLineOptionsAsync(new TestCommandLineOptions(new Dictionary<string, string[]>
+        {
+            [AzureDevOpsCommandLineOptions.AzureDevOpsOptionName] = [],
+            [AzureDevOpsCommandLineOptions.AzureDevOpsDemoteKnownFlaky] = [],
+            [AzureDevOpsCommandLineOptions.AzureDevOpsFlakyHistory] = ["14"],
+            [AzureDevOpsCommandLineOptions.AzureDevOpsQuarantineFile] = ["quarantine.txt"],
+            [AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity] = ["warning"],
+        })).ConfigureAwait(false);
+
+        Assert.IsTrue(validationResult.IsValid);
+        Assert.IsNull(validationResult.ErrorMessage);
+    }
+}
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsHistoryClientTests.cs b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsHistoryClientTests.cs
new file mode 100644
index 0000000000..e38b26ff93
--- /dev/null
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsHistoryClientTests.cs
@@ -0,0 +1,112 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+
+using Microsoft.Testing.Extensions.AzureDevOpsReport;
+using Microsoft.Testing.Platform.Helpers;
+
+namespace Microsoft.Testing.Extensions.UnitTests;
+
+[TestClass]
+public sealed class AzureDevOpsHistoryClientTests
+{
+    [TestMethod]
+    public async Task GetRunsAsync_UsesDefinitionsQueryParameterAndExpectedHeadersAsync()
+    {
+        Queue<HttpResponseMessage> responses = new([
+            CreateRunsResponse("https://example/_apis/test/Runs/1"),
+        ]);
+        RecordingHttpMessageHandler handler = new(responses);
+        using HttpClient httpClient = new(handler);
+        AzureDevOpsHistoryClient client = new(new TestTask(), new TestClock(), httpClient);
+
+        await client.GetRunsAsync(CreateQuery(), 1, CancellationToken.None).ConfigureAwait(false);
+
+        Assert.HasCount(1, handler.Requests);
+        HttpRequestMessage request = handler.Requests[0];
+        Uri requestUri = request.RequestUri!;
+        Assert.Contains("definitions=123", requestUri.Query);
+        Assert.AreEqual("application/json", request.Headers.Accept.Single().MediaType);
+        ProductInfoHeaderValue userAgent = request.Headers.UserAgent.Single();
+        Assert.AreEqual("Microsoft.Testing.Extensions.AzureDevOpsReport", userAgent.Product?.Name);
+    }
+
+    [TestMethod]
+    public async Task GetRunsAsync_PagesUntilMaximumRunCountIsReachedAsync()
+    {
+        Queue<HttpResponseMessage> responses = new([
+            CreateRunsResponse(Enumerable.Range(1, 200).Select(static i => $"https://example/_apis/test/Runs/{i}").ToArray()),
+            CreateRunsResponse(Enumerable.Range(201, 50).Select(static i => $"https://example/_apis/test/Runs/{i}").ToArray()),
+        ]);
+        RecordingHttpMessageHandler handler = new(responses);
+        using HttpClient httpClient = new(handler);
+        AzureDevOpsHistoryClient client = new(new TestTask(), new TestClock(), httpClient);
+
+        IReadOnlyList<AzureDevOpsTestRun> runs = await client.GetRunsAsync(CreateQuery(), 250, CancellationToken.None).ConfigureAwait(false);
+
+        Assert.HasCount(250, runs);
+        Assert.HasCount(2, handler.Requests);
+        Uri firstRequestUri = handler.Requests[0].RequestUri!;
+        Assert.Contains("$top=200", firstRequestUri.Query);
+        Uri secondRequestUri = handler.Requests[1].RequestUri!;
+        Assert.Contains("$skip=200", secondRequestUri.Query);
+        Assert.Contains("$top=50", secondRequestUri.Query);
+    }
+
+    private static AzureDevOpsHistoryQuery CreateQuery()
+        => new("https://dev.azure.com/example/", "testfx", "token", "123", new DateTimeOffset(2025, 05, 01, 0, 0, 0, TimeSpan.Zero), new DateTimeOffset(2025, 05, 16, 0, 0, 0, TimeSpan.Zero));
+
+    private static HttpResponseMessage CreateRunsResponse(params string[] runUrls)
+        => new(HttpStatusCode.OK)
+        {
+            Content = new StringContent($"{{\"value\":[{string.Join(",", runUrls.Select(static runUrl => $"{{\"url\":\"{runUrl}\"}}"))}]}}"),
+        };
+
+    private sealed class RecordingHttpMessageHandler(Queue<HttpResponseMessage> responses) : HttpMessageHandler
+    {
+        private readonly Queue<HttpResponseMessage> _responses = responses;
+
+        public List<HttpRequestMessage> Requests { get; } = [];
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            Requests.Add(request);
+            return Task.FromResult(_responses.Dequeue());
+        }
+    }
+
+    private sealed class TestClock : IClock
+    {
+        public DateTimeOffset UtcNow { get; } = new(2025, 05, 16, 12, 00, 00, TimeSpan.Zero);
+    }
+
+    private sealed class TestTask : ITask
+    {
+        public Task Delay(int millisecondDelay)
+            => Task.CompletedTask;
+
+        public Task Delay(TimeSpan timeSpan, CancellationToken cancellationToken)
+            => Task.CompletedTask;
+
+        public Task Run(Action action)
+        {
+            action();
+            return Task.CompletedTask;
+        }
+
+        public Task Run(Func<Task> function, CancellationToken cancellationToken)
+            => function();
+
+        public Task<T> Run<T>(Func<Task<T>?> function, CancellationToken cancellationToken)
+            => function()!;
+
+        public Task RunLongRunning(Func<Task> action, string name, CancellationToken cancellationToken)
+            => action();
+
+        public Task WhenAll(params Task[] tasks)
+            => Task.WhenAll(tasks);
+    }
+}
diff --git a/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsHistoryServiceTests.cs b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsHistoryServiceTests.cs
new file mode 100644
index 0000000000..a367332ff9
--- /dev/null
+++ b/test/UnitTests/Microsoft.Testing.Extensions.UnitTests/AzureDevOpsHistoryServiceTests.cs
@@ -0,0 +1,486 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Net.Http;
+
+using Microsoft.Testing.Extensions.AzureDevOpsReport;
+using Microsoft.Testing.Extensions.AzureDevOpsReport.Resources;
+using Microsoft.Testing.Extensions.Reporting;
+using Microsoft.Testing.Platform.CommandLine;
+using Microsoft.Testing.Platform.Extensions.Messages;
+using Microsoft.Testing.Platform.Extensions.OutputDevice;
+using Microsoft.Testing.Platform.Helpers;
+using Microsoft.Testing.Platform.Logging;
+using Microsoft.Testing.Platform.OutputDevice;
+using Microsoft.Testing.Platform.Services;
+using Microsoft.Testing.Platform.TestHost;
+
+using Moq;
+
+namespace Microsoft.Testing.Extensions.UnitTests;
+
+[TestClass]
+public sealed class AzureDevOpsHistoryServiceTests
+{
+    [TestMethod]
+    public void QuarantineFile_IgnoresCommentsAndBlanksAndMatchesGlobsCaseSensitively()
+    {
+        string quarantineFilePath = Path.Combine(AppContext.BaseDirectory, $"{Guid.NewGuid():N}.quarantine.txt");
+        File.WriteAllText(quarantineFilePath, "# comment\n\nNamespace.Tests.FlakyTest\nNamespace.Tests.Slow*\nNamespace.Tests.Quarantined?\n");
+
+        try
+        {
+            QuarantineFile quarantineFile = new(quarantineFilePath, new SystemFileSystem(), new TextLogger());
+
+            Assert.IsTrue(quarantineFile.Matches("Namespace.Tests.FlakyTest"));
+            Assert.IsTrue(quarantineFile.Matches("Namespace.Tests.Slowest"));
+            Assert.IsTrue(quarantineFile.Matches("Namespace.Tests.Quarantined1"));
+            Assert.IsFalse(quarantineFile.Matches("Namespace.Tests.Other"));
+            Assert.IsFalse(quarantineFile.Matches("namespace.tests.flakytest"));
+        }
+        finally
+        {
+            File.Delete(quarantineFilePath);
+        }
+    }
+
+    [TestMethod]
+    public async Task HistoryService_AggregatesStatsFromSinglePageAsync()
+    {
+        Mock<IAzureDevOpsHistoryClient> historyClientMock = new();
+        historyClientMock
+            .Setup(x => x.GetRunsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync([new AzureDevOpsTestRun("https://example/_apis/test/Runs/1")]);
+        historyClientMock
+            .Setup(x => x.GetResultsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), "https://example/_apis/test/Runs/1", 0, 1000, null, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new AzureDevOpsTestResultsPage(
+            [
+                new AzureDevOpsTestResult("Namespace.Tests.Flaky", "Passed"),
+                new AzureDevOpsTestResult("Namespace.Tests.Flaky", "Failed"),
+                new AzureDevOpsTestResult("Namespace.Tests.Stable", "Passed"),
+            ],
+            continuationToken: null));
+
+        AzureDevOpsHistoryService historyService = CreateHistoryService(historyClientMock);
+        await historyService.OnTestSessionStartingAsync(new TestSessionContextStub()).ConfigureAwait(false);
+
+        Assert.IsTrue(historyService.TryGetStats("Namespace.Tests.Flaky", out FlakyStats flakyStats));
+        Assert.AreEqual(1, flakyStats.PassCount);
+        Assert.AreEqual(1, flakyStats.FailCount);
+        Assert.AreEqual(14, historyService.HistoryWindowInDays);
+
+        Assert.IsTrue(historyService.TryGetStats("Namespace.Tests.Stable", out FlakyStats stableStats));
+        Assert.AreEqual(1, stableStats.PassCount);
+        Assert.AreEqual(0, stableStats.FailCount);
+    }
+
+    [TestMethod]
+    public async Task HistoryService_AggregatesStatsAcrossPagesAsync()
+    {
+        Mock<IAzureDevOpsHistoryClient> historyClientMock = new();
+        historyClientMock
+            .Setup(x => x.GetRunsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync([new AzureDevOpsTestRun("https://example/_apis/test/Runs/1")]);
+        historyClientMock
+            .Setup(x => x.GetResultsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), "https://example/_apis/test/Runs/1", 0, 1000, null, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new AzureDevOpsTestResultsPage(
+            [
+                new AzureDevOpsTestResult("Namespace.Tests.Flaky", "Passed"),
+                new AzureDevOpsTestResult("Namespace.Tests.Flaky", "Failed"),
+            ],
+            continuationToken: "next-page"));
+        historyClientMock
+            .Setup(x => x.GetResultsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), "https://example/_apis/test/Runs/1", 0, 1000, "next-page", It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new AzureDevOpsTestResultsPage(
+            [
+                new AzureDevOpsTestResult("Namespace.Tests.Flaky", "Failed"),
+                new AzureDevOpsTestResult("Namespace.Tests.Flaky", "Passed"),
+            ],
+            continuationToken: null));
+
+        AzureDevOpsHistoryService historyService = CreateHistoryService(historyClientMock);
+        await historyService.OnTestSessionStartingAsync(new TestSessionContextStub()).ConfigureAwait(false);
+
+        Assert.IsTrue(historyService.TryGetStats("Namespace.Tests.Flaky", out FlakyStats flakyStats));
+        Assert.AreEqual(2, flakyStats.PassCount);
+        Assert.AreEqual(2, flakyStats.FailCount);
+        Assert.IsTrue(historyService.IsLikelyFlaky("Namespace.Tests.Flaky", 0.25));
+    }
+
+    [TestMethod]
+    public async Task HistoryService_LogsWhenRunsAreCappedAsync()
+    {
+        Mock<IAzureDevOpsHistoryClient> historyClientMock = new();
+        historyClientMock
+            .Setup(x => x.GetRunsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(Enumerable.Range(1, 501).Select(static i => new AzureDevOpsTestRun($"https://example/_apis/test/Runs/{i}")).ToArray());
+        historyClientMock
+            .Setup(x => x.GetResultsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string?>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new AzureDevOpsTestResultsPage([], continuationToken: null));
+        TextLogger logger = new();
+
+        AzureDevOpsHistoryService historyService = CreateHistoryService(historyClientMock, logger: logger);
+        await historyService.OnTestSessionStartingAsync(new TestSessionContextStub()).ConfigureAwait(false);
+
+        string cappedRunsLog = string.Join("\n", logger.Logs);
+        Assert.Contains(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.FlakyHistoryRunsCappedInfo, 501, 500), cappedRunsLog, cappedRunsLog);
+    }
+
+    [TestMethod]
+    public async Task HistoryService_DegradesGracefullyWhenBudgetExpiresAsync()
+    {
+        Mock<IAzureDevOpsHistoryClient> historyClientMock = new();
+        historyClientMock
+            .Setup(x => x.GetRunsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
+            .Returns<AzureDevOpsHistoryQuery, int, CancellationToken>(async (_, _, cancellationToken) =>
+            {
+                await Task.Delay(Timeout.Infinite, cancellationToken).ConfigureAwait(false);
+                return [];
+            });
+        TextLogger logger = new();
+
+        AzureDevOpsHistoryService historyService = CreateHistoryService(historyClientMock, task: new TestTask(delay: (_, _) => Task.CompletedTask), logger: logger);
+        await historyService.OnTestSessionStartingAsync(new TestSessionContextStub()).ConfigureAwait(false);
+
+        Assert.IsFalse(historyService.TryGetStats("Namespace.Tests.Flaky", out _));
+        Assert.AreEqual(0, historyService.HistoryWindowInDays);
+        string timeoutLogs = string.Join("\n", logger.Logs);
+        Assert.Contains(string.Format(CultureInfo.InvariantCulture, AzureDevOpsResources.FlakyHistoryLoadTimedOutInfo, 30), timeoutLogs, timeoutLogs);
+    }
+
+    [TestMethod]
+    public async Task HistoryService_CancelsBudgetDelayWhenLoadCompletesFirstAsync()
+    {
+        Mock<IAzureDevOpsHistoryClient> historyClientMock = new();
+        historyClientMock
+            .Setup(x => x.GetRunsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync([]);
+
+        CancellationToken budgetDelayToken = default;
+        TaskCompletionSource<object?> budgetDelayCancelled = new(TaskCreationOptions.RunContinuationsAsynchronously);
+        AzureDevOpsHistoryService historyService = CreateHistoryService(
+            historyClientMock,
+            task: new TestTask(delay: (_, cancellationToken) =>
+            {
+                budgetDelayToken = cancellationToken;
+                cancellationToken.Register(() => budgetDelayCancelled.TrySetResult(null));
+                return Task.Delay(Timeout.Infinite, cancellationToken);
+            }));
+
+        await historyService.OnTestSessionStartingAsync(new TestSessionContextStub()).ConfigureAwait(false);
+        await budgetDelayCancelled.Task.ConfigureAwait(false);
+
+        Assert.IsTrue(budgetDelayToken.IsCancellationRequested);
+    }
+
+    [TestMethod]
+    public async Task Reporter_AppendsRegressionAnnotationOnlyWhenMinimumSamplesAreAvailableAsync()
+    {
+        AzureDevOpsHistoryService belowThresholdHistoryService = await CreateHistoryServiceWithStatsAsync("Namespace.Tests.Regression", passCount: 4, failCount: 0).ConfigureAwait(false);
+        var belowThresholdOutputDevice = new CapturingOutputDevice();
+        AzureDevOpsReporter belowThresholdReporter = CreateReporter(belowThresholdHistoryService, belowThresholdOutputDevice, CreateCommandLineOptions());
+
+        await belowThresholdReporter.ConsumeAsync(Mock.Of<IDataProducer>(), CreateFailedMessage("Namespace.Tests.Regression", "RegressionTestBelowThreshold"), CancellationToken.None).ConfigureAwait(false);
+
+        Assert.HasCount(1, belowThresholdOutputDevice.Lines);
+        Assert.DoesNotContain("[REGRESSION]", belowThresholdOutputDevice.Lines[0]);
+
+        AzureDevOpsHistoryService atThresholdHistoryService = await CreateHistoryServiceWithStatsAsync("Namespace.Tests.Regression", passCount: 5, failCount: 0).ConfigureAwait(false);
+        var atThresholdOutputDevice = new CapturingOutputDevice();
+        AzureDevOpsReporter atThresholdReporter = CreateReporter(atThresholdHistoryService, atThresholdOutputDevice, CreateCommandLineOptions());
+
+        await atThresholdReporter.ConsumeAsync(Mock.Of<IDataProducer>(), CreateFailedMessage("Namespace.Tests.Regression", "RegressionTestAtThreshold"), CancellationToken.None).ConfigureAwait(false);
+
+        Assert.HasCount(1, atThresholdOutputDevice.Lines);
+        Assert.Contains("[REGRESSION]", atThresholdOutputDevice.Lines[0]);
+    }
+
+    [TestMethod]
+    public async Task Reporter_DemotesKnownFlakyFailuresWhenEnabledAsync()
+    {
+        AzureDevOpsHistoryService historyService = await CreateHistoryServiceWithStatsAsync("Namespace.Tests.Flaky", passCount: 3, failCount: 1).ConfigureAwait(false);
+        var outputDevice = new CapturingOutputDevice();
+        AzureDevOpsReporter reporter = CreateReporter(
+            historyService,
+            outputDevice,
+            CreateCommandLineOptions((AzureDevOpsCommandLineOptions.AzureDevOpsDemoteKnownFlaky, [])));
+
+        await reporter.ConsumeAsync(Mock.Of<IDataProducer>(), CreateFailedMessage("Namespace.Tests.Flaky", "FlakyTest"), CancellationToken.None).ConfigureAwait(false);
+
+        Assert.HasCount(1, outputDevice.Lines);
+        Assert.Contains("type=warning;", outputDevice.Lines[0]);
+        Assert.Contains("[flaky: failed 1/4 in last 14d]", outputDevice.Lines[0]);
+    }
+
+    [TestMethod]
+    public async Task Reporter_AnnotatesQuarantinedFailuresAndEmitsBuildTagOnceAsync()
+    {
+        string quarantineFilePath = Path.Combine(AppContext.BaseDirectory, $"{Guid.NewGuid():N}.quarantine.txt");
+        File.WriteAllText(quarantineFilePath, "Namespace.Tests.Quarantined\n");
+
+        try
+        {
+            Mock<IAzureDevOpsHistoryClient> historyClientMock = new();
+            AzureDevOpsHistoryService historyService = CreateHistoryService(historyClientMock, CreateCommandLineOptions((AzureDevOpsCommandLineOptions.AzureDevOpsQuarantineFile, [quarantineFilePath])));
+            var outputDevice = new CapturingOutputDevice();
+            AzureDevOpsReporter reporter = CreateReporter(
+                historyService,
+                outputDevice,
+                CreateCommandLineOptions((AzureDevOpsCommandLineOptions.AzureDevOpsQuarantineFile, [quarantineFilePath])));
+
+            TestNodeUpdateMessage message = CreateFailedMessage("Namespace.Tests.Quarantined", "QuarantinedTest");
+            await reporter.ConsumeAsync(Mock.Of<IDataProducer>(), message, CancellationToken.None).ConfigureAwait(false);
+            await reporter.ConsumeAsync(Mock.Of<IDataProducer>(), message, CancellationToken.None).ConfigureAwait(false);
+
+            Assert.HasCount(3, outputDevice.Lines);
+            Assert.AreEqual("##vso[build.addbuildtag]has-quarantined-test-failure", outputDevice.Lines[0]);
+            Assert.Contains("type=warning;", outputDevice.Lines[1]);
+            Assert.Contains("[quarantined]", outputDevice.Lines[1]);
+            Assert.Contains("[quarantined]", outputDevice.Lines[2]);
+        }
+        finally
+        {
+            File.Delete(quarantineFilePath);
+        }
+    }
+
+    [TestMethod]
+    public async Task Reporter_LogsMissingQuarantineFileWarningAsync()
+    {
+        Mock<IAzureDevOpsHistoryClient> historyClientMock = new();
+        AzureDevOpsHistoryService historyService = CreateHistoryService(historyClientMock);
+        TextLogger logger = new();
+        Mock<ILoggerFactory> loggerFactoryMock = CreateLoggerFactory(logger);
+        AzureDevOpsReporter reporter = new(
+            CreateCommandLineOptions((AzureDevOpsCommandLineOptions.AzureDevOpsQuarantineFile, [Path.Combine(AppContext.BaseDirectory, $"{Guid.NewGuid():N}.missing.txt")])),
+            CreateEnvironmentMock().Object,
+            new SystemFileSystem(),
+            new CapturingOutputDevice(),
+            loggerFactoryMock.Object,
+            historyService);
+
+        bool isEnabled = await reporter.IsEnabledAsync().ConfigureAwait(false);
+
+        Assert.IsTrue(isEnabled);
+        string reporterLogs = string.Join("\n", logger.Logs);
+        Assert.Contains("does not exist", reporterLogs, reporterLogs);
+    }
+
+    [TestMethod]
+    public async Task HistoryService_DegradesGracefullyOnNetworkFailureAsync()
+    {
+        Mock<IAzureDevOpsHistoryClient> historyClientMock = new();
+        historyClientMock
+            .Setup(x => x.GetRunsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
+            .ThrowsAsync(new HttpRequestException("network failure"));
+
+        AzureDevOpsHistoryService historyService = CreateHistoryService(historyClientMock);
+        await historyService.OnTestSessionStartingAsync(new TestSessionContextStub()).ConfigureAwait(false);
+
+        Assert.IsFalse(historyService.TryGetStats("Namespace.Tests.Flaky", out _));
+        Assert.AreEqual(0, historyService.HistoryWindowInDays);
+    }
+
+    private static async Task<AzureDevOpsHistoryService> CreateHistoryServiceWithStatsAsync(string testName, int passCount, int failCount)
+    {
+        Mock<IAzureDevOpsHistoryClient> historyClientMock = new();
+        historyClientMock
+            .Setup(x => x.GetRunsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
+            .ReturnsAsync([new AzureDevOpsTestRun("https://example/_apis/test/Runs/1")]);
+
+        List<AzureDevOpsTestResult> results = [];
+        for (int i = 0; i < passCount; i++)
+        {
+            results.Add(new AzureDevOpsTestResult(testName, "Passed"));
+        }
+
+        for (int i = 0; i < failCount; i++)
+        {
+            results.Add(new AzureDevOpsTestResult(testName, "Failed"));
+        }
+
+        historyClientMock
+            .Setup(x => x.GetResultsAsync(It.IsAny<AzureDevOpsHistoryQuery>(), "https://example/_apis/test/Runs/1", 0, 1000, null, It.IsAny<CancellationToken>()))
+            .ReturnsAsync(new AzureDevOpsTestResultsPage(results, continuationToken: null));
+
+        AzureDevOpsHistoryService historyService = CreateHistoryService(historyClientMock);
+        await historyService.OnTestSessionStartingAsync(new TestSessionContextStub()).ConfigureAwait(false);
+        return historyService;
+    }
+
+    private static AzureDevOpsHistoryService CreateHistoryService(
+        Mock<IAzureDevOpsHistoryClient> historyClientMock,
+        ICommandLineOptions? commandLineOptions = null,
+        ITask? task = null,
+        TextLogger? logger = null)
+    {
+        commandLineOptions ??= CreateCommandLineOptions();
+        Mock<IEnvironment> environmentMock = CreateEnvironmentMock();
+        logger ??= new TextLogger();
+        task ??= new TestTask();
+        Mock<ILoggerFactory> loggerFactoryMock = CreateLoggerFactory(logger);
+
+        return new AzureDevOpsHistoryService(commandLineOptions, environmentMock.Object, new TestClock(), historyClientMock.Object, task, loggerFactoryMock.Object);
+    }
+
+    private static AzureDevOpsReporter CreateReporter(IAzureDevOpsHistoryService historyService, IOutputDevice outputDevice, ICommandLineOptions commandLineOptions)
+    {
+        Mock<IEnvironment> environmentMock = CreateEnvironmentMock();
+        TextLogger logger = new();
+        Mock<ILoggerFactory> loggerFactoryMock = CreateLoggerFactory(logger);
+
+        return new AzureDevOpsReporter(commandLineOptions, environmentMock.Object, new SystemFileSystem(), outputDevice, loggerFactoryMock.Object, historyService);
+    }
+
+    private static ICommandLineOptions CreateCommandLineOptions(params (string Name, string[] Arguments)[] options)
+    {
+        Dictionary<string, string[]> values = new(StringComparer.OrdinalIgnoreCase)
+        {
+            [AzureDevOpsCommandLineOptions.AzureDevOpsOptionName] = [],
+            [AzureDevOpsCommandLineOptions.AzureDevOpsFlakyHistory] = ["14"],
+            [AzureDevOpsCommandLineOptions.AzureDevOpsReportSeverity] = ["error"],
+        };
+
+        foreach ((string name, string[] arguments) in options)
+        {
+            values[name] = arguments;
+        }
+
+        return new FakeCommandLineOptions(values);
+    }
+
+    private static Mock<IEnvironment> CreateEnvironmentMock()
+    {
+        Mock<IEnvironment> environmentMock = new();
+        environmentMock.Setup(x => x.GetEnvironmentVariable("TF_BUILD")).Returns("true");
+        environmentMock.Setup(x => x.GetEnvironmentVariable("SYSTEM_COLLECTIONURI")).Returns("https://dev.azure.com/example/");
+        environmentMock.Setup(x => x.GetEnvironmentVariable("SYSTEM_TEAMPROJECT")).Returns("testfx");
+        environmentMock.Setup(x => x.GetEnvironmentVariable("SYSTEM_ACCESSTOKEN")).Returns("token");
+        environmentMock.Setup(x => x.GetEnvironmentVariable("BUILD_DEFINITIONID")).Returns("123");
+        return environmentMock;
+    }
+
+    private static Mock<ILoggerFactory> CreateLoggerFactory(TextLogger logger)
+    {
+        Mock<ILoggerFactory> loggerFactoryMock = new();
+        loggerFactoryMock.Setup(x => x.CreateLogger(It.IsAny<string>())).Returns(logger);
+        return loggerFactoryMock;
+    }
+
+    private static TestNodeUpdateMessage CreateFailedMessage(string fullyQualifiedName, string displayName)
+    {
+        Exception exception = CreateException();
+        PropertyBag propertyBag = new();
+        propertyBag.Add(new FailedTestNodeStateProperty(exception));
+        propertyBag.Add(new SerializableKeyValuePairStringProperty("vstest.TestCase.FullyQualifiedName", fullyQualifiedName));
+
+        return new TestNodeUpdateMessage(new SessionUid("session"), new TestNode
+        {
+            Uid = "test",
+            DisplayName = displayName,
+            Properties = propertyBag,
+        });
+    }
+
+    private static Exception CreateException()
+    {
+        try
+        {
+            throw new InvalidOperationException("boom");
+        }
+        catch (Exception ex)
+        {
+            return ex;
+        }
+    }
+
+    private sealed class FakeCommandLineOptions(IReadOnlyDictionary<string, string[]> options) : ICommandLineOptions
+    {
+        private readonly IReadOnlyDictionary<string, string[]> _options = options;
+
+        public bool IsOptionSet(string optionName)
+            => _options.ContainsKey(optionName);
+
+        public bool TryGetOptionArgumentList(string optionName, [NotNullWhen(true)] out string[]? arguments)
+        {
+            if (_options.TryGetValue(optionName, out string[]? values))
+            {
+                arguments = values;
+                return true;
+            }
+
+            arguments = null;
+            return false;
+        }
+    }
+
+    private sealed class CapturingOutputDevice : IOutputDevice
+    {
+        public List<string> Lines { get; } = [];
+
+        public Task DisplayAsync(IOutputDeviceDataProducer producer, IOutputDeviceData data, CancellationToken cancellationToken)
+        {
+            Lines.Add(((TextOutputDeviceData)data).Text);
+            return Task.CompletedTask;
+        }
+    }
+
+    private sealed class TestClock : IClock
+    {
+        public DateTimeOffset UtcNow { get; } = new(2025, 05, 16, 12, 00, 00, TimeSpan.Zero);
+    }
+
+    private sealed class TestTask(Func<TimeSpan, CancellationToken, Task>? delay = null) : ITask
+    {
+        private readonly Func<TimeSpan, CancellationToken, Task> _delay = delay ?? ((_, _) => Task.CompletedTask);
+
+        public Task Delay(int millisecondDelay)
+            => Task.CompletedTask;
+
+        public Task Delay(TimeSpan timeSpan, CancellationToken cancellationToken)
+            => _delay(timeSpan, cancellationToken);
+
+        public Task Run(Action action)
+        {
+            action();
+            return Task.CompletedTask;
+        }
+
+        public Task Run(Func<Task> function, CancellationToken cancellationToken)
+            => function();
+
+        public Task<T> Run<T>(Func<Task<T>?> function, CancellationToken cancellationToken)
+            => function()!;
+
+        public Task RunLongRunning(Func<Task> action, string name, CancellationToken cancellationToken)
+            => action();
+
+        public Task WhenAll(params Task[] tasks)
+            => Task.WhenAll(tasks);
+    }
+
+    private sealed class TestSessionContextStub : ITestSessionContext
+    {
+        public SessionUid SessionUid { get; } = new("session");
+
+        public CancellationToken CancellationToken { get; } = CancellationToken.None;
+    }
+
+    private sealed class TextLogger : ILogger
+    {
+        public List<string> Logs { get; } = [];
+
+        public bool IsEnabled(LogLevel logLevel)
+            => true;
+
+        public void Log<TState>(LogLevel logLevel, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+            => Logs.Add($"{logLevel.ToString().ToUpperInvariant()}: {formatter(state, exception)}");
+
+        public Task LogAsync<TState>(LogLevel logLevel, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        {
+            Logs.Add($"{logLevel.ToString().ToUpperInvariant()}: {formatter(state, exception)}");
+            return Task.CompletedTask;
+        }
+    }
+}
