From 12e38ec307def98bc0eae06e1ad9becb32fde6c9 Mon Sep 17 00:00:00 2001
From: SMAP-git <333812182+SMAP-git@users.noreply.github.com>
Date: Wed, 11 Nov 2026 12:54:53 +0100
Subject: [PATCH 1/7] Add opt-in self-hosted pt-PT grammar checks

Keep v1.7.0 as the rollback baseline and isolate the v1.8.0 experiment. Add a bounded LanguageTool client, review-first diagnostics, explicit-subject agreement allowlist, aligned English and MiniLM safeguards, candidate rechecks, and shared preview/batch settings. No model or Java installation, public cloud API or generative rewriting.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../GrammarChecksTests.cs                     | 444 ++++++++++++++++++
 .../ReferenceTests.cs                         |  16 +
 .../BatchMode.cs                              |  21 +-
 .../ConversionOptions.cs                      |  23 +-
 .../GrammarChecks.cs                          | 201 ++++++++
 .../LanguageToolClient.cs                     | 129 +++++
 .../LocalChecks.cs                            |  33 +-
 .../MainWindow.axaml                          |  10 +
 .../MainWindow.axaml.cs                       |  73 ++-
 se5/BrazilianToEuropeanPortuguese/README.md   |  80 +++-
 .../README.pt-PT.md                           |  84 +++-
 se5/BrazilianToEuropeanPortuguese/plugin.json |   2 +-
 12 files changed, 1088 insertions(+), 28 deletions(-)
 create mode 100644 se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs
 create mode 100644 se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs
 create mode 100644 se5/BrazilianToEuropeanPortuguese/LanguageToolClient.cs

diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs
new file mode 100644
index 00000000..c8dca1a9
--- /dev/null
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs
@@ -0,0 +1,444 @@
+using System.Net;
+using System.Net.Http;
+using System.Net.Sockets;
+using System.Text;
+using System.Text.Json;
+using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
+using SubtitleEdit.Plugins.Shared;
+
+namespace BrazilianToEuropeanPortuguese.Tests;
+
+public sealed class GrammarChecksTests
+{
+    private static readonly ConversionOptions Enabled = new(GrammarCheck: true, GrammarAutoFix: true);
+    private static readonly IProgress<string> Progress = new Progress<string>(_ => { });
+    private static CheckLine Line(string text = "Eles tem razão.", string? english = "They are right.") =>
+        new(0, text, text, null, english);
+    private static GrammarMatch Match(string text, string from = "tem", string to = "têm", string rule = "AGREEMENT") =>
+        new(text.IndexOf(from, StringComparison.Ordinal), from.Length, rule, "Check agreement.", new[] { to });
+    private static Task<float[]> SameMeaning(string _, CancellationToken token)
+    {
+        token.ThrowIfCancellationRequested();
+        return Task.FromResult(new[] { 1f, 0f });
+    }
+
+    private static async Task<(Dictionary<int, string> Texts, List<string> Notes, string Summary)> Run(
+        IReadOnlyList<CheckLine> lines, ConversionOptions? options = null, PortugueseLocalWordList? words = null,
+        Func<string, CancellationToken, Task<IReadOnlyList<GrammarMatch>>>? check = null,
+        Func<string, CancellationToken, Task<float[]>>? embed = null)
+    {
+        var texts = lines.ToDictionary(l => l.Index, l => l.Converted);
+        var notes = new List<string>();
+        check ??= (text, _) => Task.FromResult<IReadOnlyList<GrammarMatch>>(
+            text.Contains("tem", StringComparison.Ordinal) ? new[] { Match(text) } : Array.Empty<GrammarMatch>());
+        var summary = await GrammarChecks.RunAsync(lines, options ?? Enabled, words, texts,
+            (_, note) => notes.Add(note), check, embed, Progress, CancellationToken.None);
+        return (texts, notes, summary);
+    }
+
+    [Fact]
+    public async Task DefaultAndDisabledStageMakeNoRequests()
+    {
+        Task<IReadOnlyList<GrammarMatch>> Fail(string _, CancellationToken __) => throw new Exception("Unexpected server request.");
+        foreach (var options in new[] { ConversionOptions.Default, Enabled with { DisabledRules = "languagetool" } })
+        {
+            var result = await Run(new[] { Line() }, options, check: Fail);
+            Assert.Equal(Line().Converted, result.Texts[0]);
+            Assert.Empty(result.Notes);
+            Assert.Empty(result.Summary);
+        }
+    }
+
+    [Fact]
+    public async Task ReviewModeNeverEmbedsOrChangesText()
+    {
+        var result = await Run(new[] { Line() }, Enabled with { GrammarAutoFix = false },
+            embed: (_, _) => throw new Exception("Review must not embed."));
+        Assert.Equal("Eles tem razão.", result.Texts[0]);
+        Assert.Contains("review only", Assert.Single(result.Notes));
+        Assert.Contains("0 allowlisted", result.Summary);
+    }
+
+    [Fact]
+    public async Task AutomaticAgreementNeedsModelAndRechecksGrammar()
+    {
+        var missing = await Run(new[] { Line() });
+        Assert.Equal("Eles tem razão.", missing.Texts[0]);
+        Assert.Contains("requires enabled, installed MiniLM", Assert.Single(missing.Notes));
+        var requests = new List<string>();
+        var accepted = await Run(new[] { Line() }, embed: SameMeaning, check: (text, _) =>
+        {
+            requests.Add(text);
+            return Task.FromResult<IReadOnlyList<GrammarMatch>>(text.Contains("tem", StringComparison.Ordinal)
+                ? new[] { Match(text) } : Array.Empty<GrammarMatch>());
+        });
+        Assert.Equal("Eles têm razão.", accepted.Texts[0]);
+        Assert.Equal(new[] { "Eles tem razão.", "Eles têm razão." }, requests);
+        Assert.Contains("corrected", Assert.Single(accepted.Notes));
+    }
+
+    [Theory]
+    [InlineData("Eles tem razão.", "Eles têm razão.", "They are right.", true)]
+    [InlineData("Elas vem aqui.", "Elas vêm aqui.", "They come here.", true)]
+    [InlineData("Ele têm razão.", "Ele tem razão.", "He is right.", true)]
+    [InlineData("Ela vêm aqui.", "Ela vem aqui.", "She comes here.", true)]
+    [InlineData("ELES TEM RAZÃO.", "ELES TÊM RAZÃO.", "They are right.", true)]
+    [InlineData("Eles não tem razão.", "Eles não têm razão.", "They are not right.", true)]
+    [InlineData("Eles tem razão.", "Eles têm razão.", "He is right.", false)]
+    [InlineData("Eles tem razão.", "Eles têm razão.", null, false)]
+    [InlineData("Eles tem razão.", "Eles têm razão.", "Right.", false)]
+    [InlineData("Tu tem razão.", "Tu tens razão.", "You are right.", false)]
+    [InlineData("A equipa têm razão.", "A equipa tem razão.", "The team is right.", false)]
+    [InlineData("Eles tem razão.", "Eles tinham razão.", "They were right.", false)]
+    [InlineData("Ela falarei nisto.", "Ela falaria nisto.", "She would talk about this.", false)]
+    [InlineData("\"Eles tem razão.\"", "\"Eles têm razão.\"", "They are right.", false)]
+    [InlineData("'Eles tem razão.'", "'Eles têm razão.'", "They are right.", false)]
+    [InlineData("-Eles tem razão.", "-Eles têm razão.", "They are right.", false)]
+    [InlineData("<i>Eles tem razão.</i>", "<i>Eles têm razão.</i>", "They are right.", false)]
+    public void AllowlistIsBounded(string before, string after, string? english, bool expected) =>
+        Assert.Equal(expected, GrammarChecks.Eligible(before, after, english, Enabled));
+
+    [Fact]
+    public void DisabledAgreementSettingsRemainAuthoritative()
+    {
+        Assert.False(GrammarChecks.Eligible("Eles tem razão.", "Eles têm razão.", "They are right.", Enabled with { YouToTu = false }));
+        Assert.False(GrammarChecks.Eligible("Eles tem razão.", "Eles têm razão.", "They are right.", Enabled with { DisabledRules = "address" }));
+    }
+
+    [Fact]
+    public async Task UnlistedVocabularyAndTenseAreSuggestionsOnlyEvenWithPerfectSimilarity()
+    {
+        var line = Line("Ela falarei nisto.", "She would talk about this.");
+        var result = await Run(new[] { line }, embed: SameMeaning, check: (text, _) =>
+            Task.FromResult<IReadOnlyList<GrammarMatch>>(new[] { Match(text, "falarei", "falaria") }));
+        Assert.Equal(line.Converted, result.Texts[0]);
+        Assert.Contains("not a unique allowlisted", Assert.Single(result.Notes));
+    }
+
+    [Fact]
+    public async Task SafeSentenceGroupPreservesCueBoundariesAndInternalNewlines()
+    {
+        var sentence = new SentenceMeaning(0, 1, "Eles tem razão, de facto.", "They are right, in fact.");
+        var lines = new[]
+        {
+            Line("Eles tem\nrazão,", "They are right,") with { MeaningSentence = sentence },
+            new CheckLine(1, "de facto.", "de facto.", null, "in fact.", sentence),
+        };
+        var result = await Run(lines, embed: SameMeaning);
+        Assert.Equal("Eles têm\nrazão,", result.Texts[0]);
+        Assert.Equal("de facto.", result.Texts[1]);
+        Assert.Equal(2, result.Notes.Count);
+    }
+
+    [Fact]
+    public async Task IncompleteSelectedGroupDoesNotReadUnselectedContext()
+    {
+        var sentence = new SentenceMeaning(0, 1, "Eles tem razão.", "They are right.");
+        var seen = new List<string>();
+        var line = Line("razão.", "right.") with { Index = 1, MeaningSentence = sentence };
+        await Run(new[] { line }, check: (text, _) =>
+        {
+            seen.Add(text);
+            return Task.FromResult<IReadOnlyList<GrammarMatch>>(Array.Empty<GrammarMatch>());
+        });
+        Assert.Equal(new[] { "razão." }, seen);
+    }
+
+    [Fact]
+    public async Task SubjectInPreviousSafeCueCanConfirmAgreementWithoutMovingWords()
+    {
+        var sentence = new SentenceMeaning(0, 1, "Eles tem razão.", "They are right.");
+        var lines = new[]
+        {
+            Line("Eles", "They") with { MeaningSentence = sentence },
+            new CheckLine(1, "tem razão.", "tem razão.", null, "are right.", sentence),
+        };
+        var result = await Run(lines, embed: SameMeaning);
+        Assert.Equal("Eles", result.Texts[0]);
+        Assert.Equal("têm razão.", result.Texts[1]);
+    }
+
+    [Fact]
+    public async Task LowSimilarityWithholdsCandidateBeforeGrammarRecheck()
+    {
+        var requests = 0;
+        var result = await Run(new[] { Line() }, check: (text, _) =>
+        {
+            requests++;
+            return Task.FromResult<IReadOnlyList<GrammarMatch>>(new[] { Match(text) });
+        }, embed: (text, _) => Task.FromResult(text.Contains("têm", StringComparison.Ordinal)
+            ? new[] { 0f, 1f } : new[] { 1f, 0f }));
+        Assert.Equal(1, requests);
+        Assert.Equal("Eles tem razão.", result.Texts[0]);
+        Assert.Contains("meaning safeguard rejected", Assert.Single(result.Notes));
+    }
+
+    [Fact]
+    public async Task IgnoredAndCustomWordsCannotBeChangedOrUsedAsAgreementEvidence()
+    {
+        var words = new PortugueseLocalWordList();
+        words.Ignored.Add("Eles");
+        var ignored = await Run(new[] { Line() }, words: words, embed: SameMeaning);
+        Assert.Equal("Eles tem razão.", ignored.Texts[0]);
+        words.Ignored.Clear();
+        words.Words.Add(("custom", "tem"));
+        var custom = await Run(new[] { Line() }, words: words, embed: SameMeaning,
+            check: (_, _) => Task.FromResult<IReadOnlyList<GrammarMatch>>(new[] { new GrammarMatch(5, 3, "TEST", "Protected.", new[] { "têm" }) }));
+        Assert.Equal("Eles tem razão.", custom.Texts[0]);
+        Assert.Empty(custom.Notes);
+        var original = "<i>😀 Eles tem</i>\n{\\an8}razão.";
+        var masked = GrammarChecks.Mask(original, words);
+        Assert.Equal(original.Length, masked.Length);
+        Assert.DoesNotContain("tem", masked);
+        Assert.DoesNotContain("<i>", masked);
+    }
+
+    [Fact]
+    public async Task OverlappingDiagnosticsRemainReviewOnly()
+    {
+        var result = await Run(new[] { Line() }, embed: SameMeaning, check: (text, _) =>
+            Task.FromResult<IReadOnlyList<GrammarMatch>>(new[] { Match(text), Match(text) with { Rule = "OTHER" } }));
+        Assert.Equal(Line().Converted, result.Texts[0]);
+        Assert.Equal(2, result.Notes.Count);
+    }
+
+    [Fact]
+    public async Task InsertionAndNoReplacementFindingsRemainVisibleForReview()
+    {
+        var result = await Run(new[] { Line() }, check: (_, _) =>
+            Task.FromResult<IReadOnlyList<GrammarMatch>>(new[]
+            {
+                new GrammarMatch(4, 0, "INSERTION", "Missing punctuation.", new[] { "," }),
+                new GrammarMatch(9, 5, "REVIEW", "Check this construction.", Array.Empty<string>()),
+            }));
+        Assert.Equal(2, result.Notes.Count);
+        Assert.Contains(result.Notes, n => n.Contains("INSERTION"));
+        Assert.Contains(result.Notes, n => n.Contains("no replacement supplied"));
+        Assert.Equal(Line().Converted, result.Texts[0]);
+    }
+
+    [Fact]
+    public async Task OnlyTheFixedDiagnosticIsLabelledCorrected()
+    {
+        var calls = 0;
+        var result = await Run(new[] { Line() }, embed: SameMeaning, check: (text, _) =>
+        {
+            calls++;
+            var other = new GrammarMatch(9, 5, "AGREEMENT", "Review this word.", Array.Empty<string>());
+            return Task.FromResult<IReadOnlyList<GrammarMatch>>(calls == 1 ? new[] { Match(text), other } : new[] { other });
+        });
+        Assert.Equal("Eles têm razão.", result.Texts[0]);
+        Assert.Single(result.Notes, n => n.Contains("; corrected"));
+        Assert.Single(result.Notes, n => n.Contains("; review (not automatically changed)"));
+    }
+
+    [Fact]
+    public async Task NewOrUnresolvedDiagnosticsRejectCandidate()
+    {
+        foreach (var unresolved in new[] { true, false })
+        {
+            var calls = 0;
+            var result = await Run(new[] { Line() }, embed: SameMeaning, check: (text, _) =>
+            {
+                calls++;
+                return Task.FromResult<IReadOnlyList<GrammarMatch>>(calls == 1 ? new[] { Match(text) } :
+                    new[] { new GrammarMatch(0, 4, unresolved ? "AGREEMENT" : "NEW", "New finding.", Array.Empty<string>()) });
+            });
+            Assert.Equal(2, calls);
+            Assert.Equal(Line().Converted, result.Texts[0]);
+            Assert.Contains("recheck", Assert.Single(result.Notes));
+        }
+    }
+
+    [Theory]
+    [InlineData(.8f, .8f, .8f, true)]
+    [InlineData(.7001f, .8f, .8f, true)]
+    [InlineData(.699f, .8f, .8f, false)]
+    [InlineData(.8f, .8f, .759f, false)]
+    [InlineData(.8f, .5f, .449f, false)]
+    [InlineData(.8f, .4f, .8f, false)]
+    [InlineData(float.NaN, .8f, .8f, false)]
+    public async Task MeaningGateUsesOriginalCandidateAndEnglish(float similarity, float beforeEnglish, float afterEnglish, bool expected)
+    {
+        Task<float[]> Embed(string text, CancellationToken _) => Task.FromResult(text switch
+        {
+            "before" => new[] { 1f, 0f, 0f },
+            "after" => new[] { similarity, 1f, 0f },
+            _ => new[] { beforeEnglish, afterEnglish - similarity * beforeEnglish, 0f },
+        });
+        Assert.Equal(expected, await GrammarChecks.MeaningSafeAsync("before", "after", "english", Embed, CancellationToken.None));
+    }
+
+    [Fact]
+    public async Task EmbeddingErrorsPropagateAndNeverApplyChanges()
+    {
+        await Assert.ThrowsAsync<IOException>(() => Run(new[] { Line() }, embed: (_, _) => throw new IOException("model failed")));
+    }
+
+    [Fact]
+    public void OptionsRoundTripAndOlderSettingsStayOff()
+    {
+        var options = Enabled with { GrammarServer = "http://languagetool:8010/" };
+        var request = new PluginRequest { Settings = options.ToJson(), SettingsVersion = ConversionOptions.Version };
+        Assert.Equal(options, ConversionOptions.Load(request));
+        request.Settings = JsonSerializer.SerializeToElement(new { spelling = true });
+        Assert.False(ConversionOptions.Load(request).GrammarCheck);
+        Assert.False(ConversionOptions.Load(request).GrammarAutoFix);
+        request.Settings = JsonSerializer.SerializeToElement(new { grammarCheck = "yes" });
+        Assert.Throws<InvalidDataException>(() => ConversionOptions.Load(request));
+    }
+
+    private static string Response(string text, params GrammarMatch[] matches) => JsonSerializer.Serialize(new
+    {
+        language = new { code = "pt-PT" },
+        matches = matches.Select(m => new
+        {
+            offset = m.Offset, length = m.Length, message = m.Message, rule = new { id = m.Rule },
+            replacements = m.Replacements.Select(value => new { value }),
+        }),
+    });
+
+    private sealed class Handler(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> send) : HttpMessageHandler
+    {
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) =>
+            send(request, cancellationToken);
+    }
+
+    [Theory]
+    [InlineData("http://127.0.0.1:8081/", "http://127.0.0.1:8081/v2/check")]
+    [InlineData("http://languagetool:8010/v2", "http://languagetool:8010/v2/check")]
+    [InlineData("https://grammar.local/v2/check", "https://grammar.local/v2/check")]
+    public void ServerUrlSupportsLocalDockerAndHttps(string server, string expected) =>
+        Assert.Equal(expected, LanguageToolClient.CheckUri(server).AbsoluteUri);
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("file:///tmp/grammar")]
+    [InlineData("http://user:password@localhost/")]
+    [InlineData("http://localhost/?text=hello")]
+    [InlineData("http://localhost/#fragment")]
+    [InlineData("https://api.languagetool.org")]
+    [InlineData("https://api.languagetoolplus.com/v2")]
+    public void InvalidAndCloudUrlsAreRejected(string server) =>
+        Assert.Throws<InvalidDataException>(() => LanguageToolClient.CheckUri(server));
+
+    [Fact]
+    public async Task ClientPostsPtPtCachesWithinRunAndUsesUtf16Offsets()
+    {
+        var calls = 0;
+        const string text = "😀 Eles tem razão.";
+        using var client = new LanguageToolClient("http://localhost:8081/", new Handler(async (request, token) =>
+        {
+            calls++;
+            Assert.Equal(HttpMethod.Post, request.Method);
+            Assert.Equal("/v2/check", request.RequestUri!.AbsolutePath);
+            var form = await request.Content!.ReadAsStringAsync(token);
+            Assert.Contains("language=pt-PT", form);
+            Assert.Contains("text=", form);
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(Response(text, Match(text))) };
+        }));
+        var first = await client.CheckAsync(text, CancellationToken.None);
+        Assert.Equal(8, Assert.Single(first).Offset);
+        Assert.Same(first, await client.CheckAsync(text, CancellationToken.None));
+        Assert.Equal(1, calls);
+    }
+
+    [Theory]
+    [InlineData("{}")]
+    [InlineData("not json")]
+    [InlineData("{\"language\":{\"code\":\"pt-BR\"},\"matches\":[]}")]
+    [InlineData("{\"language\":{\"code\":\"pt-PT\"},\"warnings\":{\"incompleteResults\":true},\"matches\":[]}")]
+    [InlineData("{\"language\":{\"code\":\"pt-PT\"},\"warnings\":{\"incompleteResults\":\"true\"},\"matches\":[]}")]
+    [InlineData("{\"language\":{\"code\":\"pt-PT\"},\"matches\":[{\"offset\":999,\"length\":3}]}")]
+    [InlineData("{\"language\":{\"code\":\"pt-PT\"},\"matches\":[{\"offset\":\"0\",\"length\":3}]}")]
+    public async Task InvalidResponsesFailExplicitly(string body)
+    {
+        using var client = new LanguageToolClient("http://localhost:8081/", new Handler((_, _) =>
+            Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(body) })));
+        await Assert.ThrowsAsync<InvalidDataException>(() => client.CheckAsync("Eles tem razão.", CancellationToken.None));
+    }
+
+    [Theory]
+    [InlineData(HttpStatusCode.TooManyRequests)]
+    [InlineData(HttpStatusCode.InternalServerError)]
+    [InlineData(HttpStatusCode.Redirect)]
+    public async Task HttpFailuresAreNotSuccessShaped(HttpStatusCode status)
+    {
+        using var client = new LanguageToolClient("http://localhost:8081/", new Handler((_, _) =>
+            Task.FromResult(new HttpResponseMessage(status))));
+        await Assert.ThrowsAsync<HttpRequestException>(() => client.CheckAsync("Eles tem razão.", CancellationToken.None));
+    }
+
+    [Fact]
+    public async Task TimeoutAndUserCancellationAreDistinct()
+    {
+        using var client = new LanguageToolClient("http://localhost:8081/", new Handler((_, _) => throw new TaskCanceledException()));
+        Assert.Contains("timed out", (await Assert.ThrowsAsync<IOException>(() => client.CheckAsync("text", CancellationToken.None))).Message);
+        using var cancel = new CancellationTokenSource();
+        cancel.Cancel();
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.CheckAsync("text", cancel.Token));
+    }
+
+    [Fact]
+    public async Task BatchUsesSelfHostedProtocolAndPreservesTimingsAndTextInReviewMode()
+    {
+        using var listener = new TcpListener(IPAddress.Loopback, 0);
+        listener.Start();
+        var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+        using var limit = new CancellationTokenSource(TimeSpan.FromSeconds(15));
+        var server = Task.Run(async () =>
+        {
+            using var socket = await listener.AcceptTcpClientAsync(limit.Token);
+            await using var stream = socket.GetStream();
+            using var reader = new StreamReader(stream, Encoding.ASCII, leaveOpen: true);
+            Assert.StartsWith("POST /v2/check ", await reader.ReadLineAsync(limit.Token));
+            var length = 0;
+            string? line;
+            while (!string.IsNullOrEmpty(line = await reader.ReadLineAsync(limit.Token)))
+                if (line.StartsWith("Content-Length:", StringComparison.OrdinalIgnoreCase)) length = int.Parse(line.Split(':')[1]);
+            var content = new char[length];
+            Assert.Equal(length, await reader.ReadBlockAsync(content.AsMemory(), limit.Token));
+            Assert.Contains("language=pt-PT", new string(content));
+            var body = Encoding.UTF8.GetBytes(Response("Olá, mundo.", new GrammarMatch(0, 3, "TEST", "Test suggestion.", new[] { "Bom dia" })));
+            var header = Encoding.ASCII.GetBytes($"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {body.Length}\r\nConnection: close\r\n\r\n");
+            await stream.WriteAsync(header, limit.Token);
+            await stream.WriteAsync(body, limit.Token);
+        }, limit.Token);
+        var request = new PluginRequest
+        {
+            RequestType = PluginRequestType.Batch,
+            Subtitle = new PluginSubtitle { SubRip = "1\n00:00:01,234 --> 00:00:03,456\nOlá, mundo.\n\n" },
+            SettingsVersion = ConversionOptions.Version,
+            Settings = new ConversionOptions(GrammarCheck: true, GrammarServer: $"http://127.0.0.1:{port}/").ToJson(),
+        };
+        var result = await Task.Run(() => BatchMode.BuildBatchResponse(request, Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".xml"),
+            new EmbeddingSettings(CheckMeaning: false)), limit.Token);
+        await server;
+        Assert.Equal(PluginStatus.Ok, result.Status);
+        Assert.Null(result.Subtitle);
+        Assert.Contains("1 cue(s) with findings", result.Message);
+        Assert.Contains("0 allowlisted", result.Message);
+        Assert.Equal("1\n00:00:01,234 --> 00:00:03,456\nOlá, mundo.\n\n", request.Subtitle.SubRip);
+    }
+
+    [Fact]
+    public void BatchReportsServerFailureAndRetainsRuleOutput()
+    {
+        var request = new PluginRequest
+        {
+            RequestType = PluginRequestType.Batch,
+            Subtitle = new PluginSubtitle { SubRip = "1\n00:00:01,234 --> 00:00:03,456\nPegue o ônibus.\n\n" },
+            SettingsVersion = ConversionOptions.Version,
+            Settings = new ConversionOptions(GrammarCheck: true, GrammarServer: "http://127.0.0.1:0/").ToJson(),
+        };
+        var response = BatchMode.BuildBatchResponse(request, Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".xml"),
+            new EmbeddingSettings(CheckMeaning: false));
+        Assert.Contains("Optional checks failed; rule-only output retained", response.Message);
+        Assert.Contains("LanguageTool", response.Message);
+        Assert.Equal(PluginStatus.Ok, response.Status);
+        var output = Assert.Single(SubRipParser.Parse(response.Subtitle!.Native));
+        Assert.Contains("autocarro", output.Text);
+        Assert.Equal(1234, output.StartMs);
+        Assert.Equal(3456, output.EndMs);
+    }
+}
diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
index 2ab126e1..d2938cfd 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
@@ -477,6 +477,22 @@ public void MainWindowAppliesReferenceToProposals()
             var subtitle = Path.Combine(data, "episode.pt-br.srt");
             File.WriteAllText(subtitle, "");
             PluginBootstrap.BuildAvaloniaApp<App>().SetupWithoutStarting();
+            var grammarWindow = new MainWindow(new PluginRequest
+            {
+                SettingsVersion = ConversionOptions.Version,
+                Settings = new ConversionOptions(GrammarCheck: true, GrammarServer: "http://languagetool:8010/").ToJson(),
+                Subtitle = new PluginSubtitle { SubRip = "1\n00:00:01,000 --> 00:00:03,000\nOlá.\n" },
+            });
+            Assert.True(grammarWindow.FindControl<CheckBox>("GrammarCheck")!.IsChecked);
+            Assert.False(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.IsChecked);
+            Assert.Equal("http://languagetool:8010/", grammarWindow.FindControl<TextBox>("GrammarServer")!.Text);
+            grammarWindow.ApplyCheckResults(new[] { new CheckLine(0, "Olá.", "Olá.", null, null) },
+                new Dictionary<int, CheckResult> { [0] = new("Olá.", "LanguageTool [TEST]: review only.") });
+            Assert.Contains("LanguageTool", Assert.Single(grammarWindow.Proposals).ReviewNote);
+            grammarWindow.FindControl<CheckBox>("GrammarCheck")!.IsChecked = false;
+            Assert.Empty(grammarWindow.Proposals);
+            grammarWindow.FindControl<TextBox>("GrammarServer")!.Text = "http://127.0.0.1:8081/";
+            Assert.True(grammarWindow.FindControl<Button>("ApplyButton")!.IsEnabled);
             var repeatedWindow = new MainWindow(new PluginRequest
             {
                 Subtitle = new PluginSubtitle
diff --git a/se5/BrazilianToEuropeanPortuguese/BatchMode.cs b/se5/BrazilianToEuropeanPortuguese/BatchMode.cs
index 7d199a3b..05791d46 100644
--- a/se5/BrazilianToEuropeanPortuguese/BatchMode.cs
+++ b/se5/BrazilianToEuropeanPortuguese/BatchMode.cs
@@ -58,7 +58,7 @@ internal static PluginResponse BuildBatchResponse(PluginRequest request, string
                 alignment?.Texts[i], conversions[i].MeaningSentence));
         }
 
-        referenceNote += Judge(blocks, checkLines, changesByLine, embedding);
+        referenceNote += OptionalChecks(blocks, checkLines, changesByLine, embedding, options, localWordList);
         var review = 0;
         var grammar = 0;
         var idioms = 0;
@@ -147,15 +147,18 @@ internal static (ReferenceAlignment? Alignment, string Note) AlignReference(List
         }
     }
 
-    /// <summary>Gervásio's choices between fixed alternatives; review flags need the window, so they are skipped here.</summary>
-    private static string Judge(List<SrtBlock> blocks, List<CheckLine> lines, Dictionary<int, string> changesByLine, EmbeddingSettings? settings)
+    /// <summary>Optional post-rule checks. Grammar findings are counted; details are available in preview.</summary>
+    private static string OptionalChecks(List<SrtBlock> blocks, List<CheckLine> lines, Dictionary<int, string> changesByLine,
+        EmbeddingSettings? settings, ConversionOptions options, PortugueseLocalWordList words)
     {
-        settings = EmbeddingAssets.WithInstalledFiles((settings ?? EmbeddingAssets.Load()) with { CheckMeaning = false });
-        if (!LocalChecks.JudgeReady(settings)) return string.Empty;
+        settings = EmbeddingAssets.WithInstalledFiles(settings ?? EmbeddingAssets.Load());
+        var grammar = options.GrammarCheck && options.RuleEnabled("languagetool");
+        if (!grammar) settings = settings with { CheckMeaning = false };
+        if (!LocalChecks.JudgeReady(settings) && !grammar) return string.Empty;
         try
         {
             using var timeout = new CancellationTokenSource(TimeSpan.FromMinutes(60));
-            var (results, summary) = Task.Run(() => LocalChecks.RunAsync(lines, settings, new Progress<string>(_ => { }), timeout.Token))
+            var (results, summary) = Task.Run(() => LocalChecks.RunAsync(lines, settings, new Progress<string>(_ => { }), timeout.Token, options, words))
                 .GetAwaiter().GetResult();
             foreach (var (index, result) in results)
             {
@@ -164,9 +167,11 @@ private static string Judge(List<SrtBlock> blocks, List<CheckLine> lines, Dictio
             }
             return " " + summary;
         }
-        catch (Exception ex) when (ex is not OutOfMemoryException)
+        catch (Exception ex) when (ex is IOException or System.Net.Http.HttpRequestException or InvalidOperationException or
+            UnauthorizedAccessException or System.Text.Json.JsonException or OperationCanceledException or
+            PlatformNotSupportedException or System.ComponentModel.Win32Exception)
         {
-            return $" Gervásio skipped: {ex.Message}";
+            return $" Optional checks failed; rule-only output retained: {ex.Message}";
         }
     }
 
diff --git a/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs b/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs
index 0269c58c..58304e10 100644
--- a/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs
+++ b/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs
@@ -26,7 +26,10 @@ public sealed record ConversionOptions(
     bool Conversational = false,
     bool LayoutWarnings = false,
     string NameArticles = "",
-    bool AskNameArticles = true)
+    bool AskNameArticles = true,
+    bool GrammarCheck = false,
+    bool GrammarAutoFix = false,
+    string GrammarServer = "http://127.0.0.1:8081/")
 {
     public const int Version = 1;
 
@@ -54,6 +57,9 @@ public JsonElement ToJson() => JsonSerializer.SerializeToElement(new
         layoutWarnings = LayoutWarnings,
         nameArticles = NameArticles,
         askNameArticles = AskNameArticles,
+        grammarCheck = GrammarCheck,
+        grammarAutoFix = GrammarAutoFix,
+        grammarServer = GrammarServer,
     });
 
     public static ConversionOptions Load(PluginRequest request)
@@ -85,7 +91,10 @@ public static ConversionOptions Load(PluginRequest request)
             ReadOptIn(json, "conversational"),
             ReadOptIn(json, "layoutWarnings"),
             ReadNameArticles(json),
-            !json.TryGetProperty("askNameArticles", out _) || ReadOptIn(json, "askNameArticles"));
+            !json.TryGetProperty("askNameArticles", out _) || ReadOptIn(json, "askNameArticles"),
+            ReadOptIn(json, "grammarCheck"),
+            ReadOptIn(json, "grammarAutoFix"),
+            ReadGrammarServer(json));
     }
 
     public bool RuleEnabled(string id) => DisabledRules.Length == 0 || !DisabledRules.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
@@ -119,6 +128,16 @@ private static string ReadNameArticles(JsonElement json)
         return text;
     }
 
+    private static string ReadGrammarServer(JsonElement json)
+    {
+        if (!json.TryGetProperty("grammarServer", out var value)) return Default.GrammarServer;
+        if (value.ValueKind != JsonValueKind.String)
+            throw new InvalidDataException("Invalid grammarServer in plugin settings (expected a URL string).");
+        var server = value.GetString()!;
+        _ = LanguageToolClient.CheckUri(server);
+        return server;
+    }
+
     private static AddressMode ReadAddress(JsonElement json)
     {
         if (!json.TryGetProperty("address", out var value)) return AddressMode.Automatic;
diff --git a/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs b/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs
new file mode 100644
index 00000000..fafbfb16
--- /dev/null
+++ b/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs
@@ -0,0 +1,201 @@
+using System.Text.RegularExpressions;
+
+namespace SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
+
+internal static class GrammarChecks
+{
+    private const RegexOptions Ci = RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
+    private static readonly Regex Markup = new(@"<[^>]*>|\{[^}]*\}|[\uE000-\uF8FF]", RegexOptions.Compiled);
+    private static readonly Regex UnsafeAddress = new(@"[""'‘’“”«»]|^\s*[-–—]|\n\s*[-–—]", RegexOptions.Compiled);
+    private static readonly Regex SubjectAgreement = new(
+        @"(?:^|[.!?;]\s*)(?<subject>ele|ela|eles|elas)(?<gap>\s+(?:(?:não|nunca|já|ainda|também)\s+){0,2})(?<verb>tem|têm|vem|vêm)\b", Ci);
+
+    internal static async Task<string> RunAsync(IReadOnlyList<CheckLine> lines, ConversionOptions options,
+        PortugueseLocalWordList? words, Dictionary<int, string> texts, Action<int, string> note,
+        Func<string, CancellationToken, Task<IReadOnlyList<GrammarMatch>>> check,
+        Func<string, CancellationToken, Task<float[]>>? embed, IProgress<string> progress, CancellationToken token)
+    {
+        if (!options.GrammarCheck || !options.RuleEnabled("languagetool")) return string.Empty;
+        var groups = Groups(lines);
+        var changed = 0;
+        var flagged = 0;
+        for (var n = 0; n < groups.Count; n++)
+        {
+            token.ThrowIfCancellationRequested();
+            if (n % 10 == 0) progress.Report($"LanguageTool: {n + 1}/{groups.Count} sentence group(s)...");
+            var group = groups[n];
+            var parts = group.Select(l => texts[l.Index]).ToArray();
+            var baseline = string.Join("\n", parts);
+            if (baseline.Length > 1200)
+            {
+                foreach (var line in group) note(line.Index, "LanguageTool: skipped context over 1200 characters.");
+                continue;
+            }
+            var masked = Mask(baseline, words);
+            var matches = (await check(masked, token)).Where(m => Visible(masked, baseline, m)).ToArray();
+            if (matches.Length == 0) continue;
+            flagged += group.Count;
+            var english = group.Any(l => string.IsNullOrWhiteSpace(l.Reference))
+                ? null : string.Join(" ", group.Select(l => l.Reference));
+            var allowed = matches.SelectMany(m => m.Replacements.Take(5).Select(r =>
+                (Match: m, Text: baseline[..m.Offset] + r + baseline[(m.Offset + m.Length)..])))
+                .Where(c => masked == baseline && Eligible(baseline, c.Text, english, options) &&
+                    !matches.Any(m => m != c.Match && Overlaps(m, c.Match)) &&
+                    WithinCue(parts, c.Match)).Distinct().ToArray();
+            string? accepted = null;
+            GrammarMatch? acceptedMatch = null;
+            var reason = !options.GrammarAutoFix ? "review only" :
+                allowed.Length != 1 ? "not a unique allowlisted correction" :
+                embed == null ? "automatic correction requires enabled, installed MiniLM" : "";
+            if (options.GrammarAutoFix && allowed.Length == 1 && embed != null)
+            {
+                var candidate = allowed[0];
+                if (!await MeaningSafeAsync(baseline, candidate.Text, english!, embed, token))
+                    reason = "MiniLM meaning safeguard rejected the candidate";
+                else
+                {
+                    var rechecked = (await check(Mask(candidate.Text, words), token)).ToArray();
+                    if (!ResolvedWithoutNewDiagnostics(baseline, candidate.Text, matches, rechecked, candidate.Match.Rule))
+                        reason = "grammar recheck did not resolve the diagnostic without new findings";
+                    else
+                    {
+                        accepted = candidate.Text;
+                        acceptedMatch = candidate.Match;
+                        reason = "not automatically changed";
+                        changed++;
+                    }
+                }
+            }
+            if (accepted != null)
+            {
+                if (accepted.Length != baseline.Length)
+                    throw new InvalidDataException("LanguageTool: correction could not preserve cue and line boundaries.");
+                // Each cue may itself contain newlines; the allowed edits preserve all whitespace.
+                var position = 0;
+                for (var i = 0; i < group.Count; i++)
+                {
+                    texts[group[i].Index] = accepted.Substring(position, parts[i].Length);
+                    position += parts[i].Length + 1;
+                }
+            }
+            foreach (var match in matches)
+            {
+                var suggestions = match.Replacements.Length == 0 ? "no replacement supplied" :
+                    string.Join(" / ", match.Replacements.Take(5).Select(r => r.Replace("\r", " ").Replace("\n", " ")));
+                var status = ReferenceEquals(acceptedMatch, match) ? "corrected (allowlisted agreement; English + MiniLM + recheck)" :
+                    $"review ({reason})";
+                var description = $"LanguageTool [{match.Rule}]: {match.Message} Suggested: {suggestions}; {status}.";
+                foreach (var line in group) note(line.Index, description);
+            }
+            progress.Report($"LanguageTool: {n + 1}/{groups.Count} sentence group(s)...");
+        }
+        return $"LanguageTool pt-PT: {flagged} cue(s) with findings, {changed} allowlisted correction(s).";
+    }
+
+    private static List<List<CheckLine>> Groups(IReadOnlyList<CheckLine> lines)
+    {
+        var byIndex = lines.ToDictionary(l => l.Index);
+        var used = new HashSet<int>();
+        var groups = new List<List<CheckLine>>();
+        foreach (var line in lines.OrderBy(l => l.Index))
+        {
+            if (!used.Add(line.Index)) continue;
+            var group = new List<CheckLine> { line };
+            if (line.MeaningSentence is { } sentence && sentence.First == line.Index &&
+                sentence.Last - sentence.First is > 0 and < 3 &&
+                Enumerable.Range(sentence.First, sentence.Last - sentence.First + 1)
+                    .All(i => byIndex.TryGetValue(i, out var peer) && peer.MeaningSentence == sentence))
+                for (var i = line.Index + 1; i <= sentence.Last; i++)
+                {
+                    used.Add(i);
+                    group.Add(byIndex[i]);
+                }
+            groups.Add(group);
+        }
+        return groups;
+    }
+
+    internal static string Mask(string text, PortugueseLocalWordList? words)
+    {
+        var masked = Markup.Replace(text, m => new string(' ', m.Length));
+        foreach (var phrase in (words?.Ignored ?? Enumerable.Empty<string>())
+            .Concat(words?.Words.Select(w => w.Pt) ?? Enumerable.Empty<string>()).Where(p => p.Length > 0))
+            masked = Regex.Replace(masked, @"(?<![\p{L}\p{M}])" + Regex.Escape(phrase) + @"(?![\p{L}\p{M}])",
+                m => new string(' ', m.Length), Ci);
+        return masked;
+    }
+
+    private static bool Visible(string masked, string original, GrammarMatch match)
+    {
+        if (match.Length < 0 || match.Offset < 0 || match.Offset > original.Length - match.Length) return false;
+        if (match.Length > 0)
+            return original.AsSpan(match.Offset, match.Length).SequenceEqual(masked.AsSpan(match.Offset, match.Length));
+        return (match.Offset == 0 || original[match.Offset - 1] == masked[match.Offset - 1]) &&
+            (match.Offset == original.Length || original[match.Offset] == masked[match.Offset]);
+    }
+
+    private static bool Overlaps(GrammarMatch a, GrammarMatch b) =>
+        a.Offset < b.Offset + b.Length && b.Offset < a.Offset + a.Length;
+
+    private static bool WithinCue(string[] parts, GrammarMatch match)
+    {
+        var start = 0;
+        foreach (var part in parts)
+        {
+            if (match.Offset >= start && match.Offset + match.Length <= start + part.Length) return true;
+            start += part.Length + 1;
+        }
+        return false;
+    }
+
+    internal static bool Eligible(string before, string after, string? english, ConversionOptions options)
+    {
+        if (!options.YouToTu || !options.RuleEnabled("address") ||
+            string.IsNullOrWhiteSpace(english) || !LocalChecks.IsComparable(before, english) ||
+            before.Length != after.Length || Markup.IsMatch(before) || UnsafeAddress.IsMatch(before) ||
+            DialogueRegister.ConflictingAddress(before)) return false;
+        foreach (Match match in SubjectAgreement.Matches(before))
+        {
+            var subject = match.Groups["subject"].Value.ToLowerInvariant();
+            var verb = match.Groups["verb"];
+            var plural = subject is "eles" or "elas";
+            var replacement = verb.Value.ToLowerInvariant() switch
+            {
+                "tem" when plural => "têm", "vem" when plural => "vêm",
+                "têm" when !plural => "tem", "vêm" when !plural => "vem", _ => null,
+            };
+            if (replacement == null) continue;
+            var expected = before[..verb.Index] + CaseHelper.MatchCase(verb.Value, replacement) + before[(verb.Index + verb.Length)..];
+            var englishSubject = subject switch { "ele" => "he", "ela" => "she", _ => "they" };
+            if (after == expected && Regex.IsMatch(english, @"^\s*" + englishSubject + @"\b", Ci))
+                return true;
+        }
+        return false;
+    }
+
+    internal static async Task<bool> MeaningSafeAsync(string before, string after, string english,
+        Func<string, CancellationToken, Task<float[]>> embed, CancellationToken token)
+    {
+        var source = await embed(LocalChecks.ForScoring(before), token);
+        var candidate = await embed(LocalChecks.ForScoring(after), token);
+        var reference = await embed(LocalChecks.ForScoring(english), token);
+        var similarity = ReferenceAligner.Dot(source, candidate);
+        var originalEnglish = ReferenceAligner.Dot(source, reference);
+        var finalEnglish = ReferenceAligner.Dot(candidate, reference);
+        return double.IsFinite(similarity) && double.IsFinite(originalEnglish) && double.IsFinite(finalEnglish) &&
+            similarity >= LocalChecks.MeaningThreshold &&
+            originalEnglish >= LocalChecks.TranslationThreshold && finalEnglish >= LocalChecks.TranslationThreshold &&
+            originalEnglish - finalEnglish < (originalEnglish >= LocalChecks.FaithfulBaseline
+                ? LocalChecks.SuspiciousDrop : LocalChecks.ReferenceDrop);
+    }
+
+    private static bool ResolvedWithoutNewDiagnostics(string original, string candidate,
+        IReadOnlyList<GrammarMatch> before, IReadOnlyList<GrammarMatch> after, string rule)
+    {
+        static (string Rule, string Message, string Text) Key(GrammarMatch m, string text) =>
+            (m.Rule, m.Message, text.Substring(m.Offset, m.Length));
+        var counts = before.GroupBy(m => Key(m, original)).ToDictionary(g => g.Key, g => g.Count());
+        return after.Count(m => m.Rule == rule) < before.Count(m => m.Rule == rule) &&
+            after.GroupBy(m => Key(m, candidate)).All(g => counts.TryGetValue(g.Key, out var count) && g.Count() <= count);
+    }
+}
diff --git a/se5/BrazilianToEuropeanPortuguese/LanguageToolClient.cs b/se5/BrazilianToEuropeanPortuguese/LanguageToolClient.cs
new file mode 100644
index 00000000..ad6a8855
--- /dev/null
+++ b/se5/BrazilianToEuropeanPortuguese/LanguageToolClient.cs
@@ -0,0 +1,129 @@
+using System.Net.Http;
+using System.Text.Json;
+
+namespace SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
+
+internal sealed record GrammarMatch(int Offset, int Length, string Rule, string Message, string[] Replacements);
+
+internal sealed class LanguageToolClient : IDisposable
+{
+    private readonly HttpClient _client;
+    private readonly Uri _checkUri;
+    private readonly Dictionary<string, IReadOnlyList<GrammarMatch>> _cache = new(StringComparer.Ordinal);
+
+    internal LanguageToolClient(string server, HttpMessageHandler? handler = null)
+    {
+        _checkUri = CheckUri(server);
+        _client = new HttpClient(handler ?? new HttpClientHandler { AllowAutoRedirect = false, UseProxy = false })
+        {
+            Timeout = TimeSpan.FromSeconds(15),
+            MaxResponseContentBufferSize = 2 * 1024 * 1024,
+        };
+    }
+
+    internal static Uri CheckUri(string server)
+    {
+        if (!Uri.TryCreate(server, UriKind.Absolute, out var uri) ||
+            uri.Scheme is not ("http" or "https") || uri.UserInfo.Length != 0 ||
+            uri.Query.Length != 0 || uri.Fragment.Length != 0 ||
+            uri.Host.Equals("languagetool.org", StringComparison.OrdinalIgnoreCase) ||
+            uri.Host.EndsWith(".languagetool.org", StringComparison.OrdinalIgnoreCase) ||
+            uri.Host.Equals("languagetoolplus.com", StringComparison.OrdinalIgnoreCase) ||
+            uri.Host.EndsWith(".languagetoolplus.com", StringComparison.OrdinalIgnoreCase))
+            throw new InvalidDataException("LanguageTool: enter an HTTP(S) URL for your self-hosted server, without credentials, query or fragment. Public LanguageTool cloud endpoints are not supported.");
+        var address = uri.AbsoluteUri.TrimEnd('/');
+        if (address.EndsWith("/v2/check", StringComparison.Ordinal)) return new Uri(address);
+        return new Uri(address + (address.EndsWith("/v2", StringComparison.Ordinal) ? "/check" : "/v2/check"));
+    }
+
+    internal async Task<IReadOnlyList<GrammarMatch>> CheckAsync(string text, CancellationToken token)
+    {
+        token.ThrowIfCancellationRequested();
+        if (_cache.TryGetValue(text, out var cached)) return cached;
+        using var content = new FormUrlEncodedContent(new Dictionary<string, string>
+        {
+            ["language"] = "pt-PT",
+            ["text"] = text,
+        });
+        HttpResponseMessage response;
+        try
+        {
+            response = await _client.PostAsync(_checkUri, content, token);
+        }
+        catch (OperationCanceledException ex) when (!token.IsCancellationRequested)
+        {
+            throw new IOException("LanguageTool: the self-hosted server timed out after 15 seconds.", ex);
+        }
+        catch (HttpRequestException ex)
+        {
+            throw new IOException("LanguageTool: could not contact the configured self-hosted server. " + ex.Message, ex);
+        }
+        using (response)
+        {
+            if (!response.IsSuccessStatusCode)
+                throw new HttpRequestException($"LanguageTool: self-hosted server returned HTTP {(int)response.StatusCode}.", null, response.StatusCode);
+            try
+            {
+                using var json = JsonDocument.Parse(await response.Content.ReadAsStringAsync(token));
+                var matches = Parse(json.RootElement, text);
+                _cache.Add(text, matches);
+                return matches;
+            }
+            catch (JsonException ex)
+            {
+                throw new InvalidDataException("LanguageTool: invalid JSON response from the self-hosted server.", ex);
+            }
+        }
+    }
+
+    internal static IReadOnlyList<GrammarMatch> Parse(JsonElement root, string text)
+    {
+        if (root.ValueKind != JsonValueKind.Object ||
+            !root.TryGetProperty("language", out var language) || language.ValueKind != JsonValueKind.Object ||
+            !language.TryGetProperty("code", out var code) || code.ValueKind != JsonValueKind.String || code.GetString() != "pt-PT" ||
+            !root.TryGetProperty("matches", out var matches) || matches.ValueKind != JsonValueKind.Array)
+            throw new InvalidDataException("LanguageTool: expected a complete pt-PT check response.");
+        if (root.TryGetProperty("warnings", out var warnings))
+        {
+            if (warnings.ValueKind != JsonValueKind.Object)
+                throw new InvalidDataException("LanguageTool: invalid warnings field.");
+            if (warnings.TryGetProperty("incompleteResults", out var incomplete))
+            {
+                if (incomplete.ValueKind is not (JsonValueKind.True or JsonValueKind.False))
+                    throw new InvalidDataException("LanguageTool: invalid incompleteResults field.");
+                if (incomplete.ValueKind == JsonValueKind.True)
+                    throw new InvalidDataException("LanguageTool: server returned incomplete results; no corrections were applied.");
+            }
+        }
+        var result = new List<GrammarMatch>();
+        foreach (var match in matches.EnumerateArray())
+        {
+            if (match.ValueKind != JsonValueKind.Object ||
+                !match.TryGetProperty("offset", out var offset) || offset.ValueKind != JsonValueKind.Number || !offset.TryGetInt32(out var start) ||
+                !match.TryGetProperty("length", out var length) || length.ValueKind != JsonValueKind.Number || !length.TryGetInt32(out var count) ||
+                start < 0 || count < 0 || start > text.Length - count ||
+                !Boundary(text, start) || !Boundary(text, start + count) ||
+                !match.TryGetProperty("message", out var message) || message.ValueKind != JsonValueKind.String ||
+                !match.TryGetProperty("rule", out var rule) || rule.ValueKind != JsonValueKind.Object ||
+                !rule.TryGetProperty("id", out var id) || id.ValueKind != JsonValueKind.String ||
+                string.IsNullOrWhiteSpace(id.GetString()) ||
+                !match.TryGetProperty("replacements", out var replacements) || replacements.ValueKind != JsonValueKind.Array)
+                throw new InvalidDataException("LanguageTool: invalid match offsets or missing diagnostic fields.");
+            var values = new List<string>();
+            foreach (var replacement in replacements.EnumerateArray())
+            {
+                if (replacement.ValueKind != JsonValueKind.Object ||
+                    !replacement.TryGetProperty("value", out var value) || value.ValueKind != JsonValueKind.String)
+                    throw new InvalidDataException("LanguageTool: invalid replacement.");
+                values.Add(value.GetString()!);
+            }
+            result.Add(new GrammarMatch(start, count, id.GetString()!, message.GetString()!, values.Distinct().ToArray()));
+        }
+        return result;
+    }
+
+    private static bool Boundary(string text, int offset) =>
+        offset == 0 || offset == text.Length || !char.IsLowSurrogate(text[offset]) || !char.IsHighSurrogate(text[offset - 1]);
+
+    public void Dispose() => _client.Dispose();
+}
diff --git a/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs b/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs
index d8305cc1..9d7a9681 100644
--- a/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs
+++ b/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs
@@ -114,7 +114,7 @@ private static bool PluralBefore(string text, int index)
 internal sealed record CheckLine(int Index, string Original, string Converted, string? Previous, string? Reference,
     SentenceMeaning? MeaningSentence = null);
 
-internal sealed record CheckResult(string Text, string? Note);
+internal sealed record CheckResult(string Text, string? Note, IReadOnlyList<RuleChange>? Rules = null);
 
 /// <summary>Optional checks with local models: Gervásio PT-PT choices after the rules; MiniLM meaning flags before and after the rules.</summary>
 internal static class LocalChecks
@@ -202,7 +202,8 @@ internal static bool MeaningReady(EmbeddingSettings settings) =>
     }
 
     internal static async Task<(Dictionary<int, CheckResult> Results, string Summary)> RunAsync(IReadOnlyList<CheckLine> lines,
-        EmbeddingSettings settings, IProgress<string> progress, CancellationToken token)
+        EmbeddingSettings settings, IProgress<string> progress, CancellationToken token,
+        ConversionOptions? options = null, PortugueseLocalWordList? words = null)
     {
         settings = EmbeddingAssets.WithInstalledFiles(settings);
         var texts = lines.ToDictionary(l => l.Index, l => l.Converted);
@@ -214,6 +215,7 @@ void Note(int index, string note)
         }
 
         var summary = new List<string>();
+        var rules = lines.ToDictionary(l => l.Index, _ => new List<RuleChange>());
         if (JudgeReady(settings))
         {
             var (chosen, device) = await JudgeAsync(lines, settings, texts, Note, progress, token);
@@ -224,6 +226,31 @@ void Note(int index, string note)
             summary.Add("Gervásio is not downloaded.");
         }
 
+        foreach (var line in lines.Where(l => texts[l.Index] != l.Converted))
+            rules[line.Index].Add(new RuleChange("local-judge", "Gervásio chose a fixed alternative", "Local model ranking; see review note"));
+
+        if (options is { GrammarCheck: true } && options.RuleEnabled("languagetool"))
+        {
+            using var client = new LanguageToolClient(options.GrammarServer);
+            EmbeddingRuntime? runtime = null;
+            try
+            {
+                if (options.GrammarAutoFix && MeaningReady(settings))
+                    runtime = await EmbeddingRuntime.StartAsync(settings, progress, token);
+                var previous = texts.ToDictionary(p => p.Key, p => p.Value);
+                var grammarSummary = await GrammarChecks.RunAsync(lines, options, words, texts, Note, client.CheckAsync,
+                    runtime == null ? null : runtime.EmbedAsync, progress, token);
+                summary.Add(grammarSummary);
+                foreach (var line in lines.Where(l => texts[l.Index] != previous[l.Index]))
+                    rules[line.Index].Add(new RuleChange("languagetool", "Allowlisted pt-PT agreement correction",
+                        "LanguageTool suggestion; explicit subject and English; MiniLM safeguard; grammar recheck"));
+            }
+            finally
+            {
+                if (runtime != null) await runtime.DisposeAsync();
+            }
+        }
+
         if (MeaningReady(settings))
         {
             var flagged = await MeaningAsync(lines, settings, texts, Note, progress, token);
@@ -232,7 +259,7 @@ void Note(int index, string note)
 
         var results = lines.Where(l => texts[l.Index] != l.Converted || notes.ContainsKey(l.Index))
             .ToDictionary(l => l.Index, l => new CheckResult(texts[l.Index],
-                notes.TryGetValue(l.Index, out var list) ? string.Join("\n", list) : null));
+                notes.TryGetValue(l.Index, out var list) ? string.Join("\n", list) : null, rules[l.Index]));
         return (results, string.Join(" ", summary));
     }
 
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
index 97798607..9628a7d6 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
@@ -232,6 +232,16 @@
                     <Button x:Name="ReferenceCancelButton" Content="Stop" Click="OnCancelReference" IsEnabled="False" Margin="0,0,8,4" />
                 </WrapPanel>
                 <TextBlock Text="Extra checks (local, after the rules)" FontWeight="SemiBold" Margin="0,4,0,0" />
+                <CheckBox x:Name="GrammarCheck" Content="LanguageTool pt-PT (self-hosted, off by default)"
+                          IsCheckedChanged="OnGrammarSettingChanged" />
+                <TextBox x:Name="GrammarServer" Watermark="http://127.0.0.1:8081/"
+                         TextChanged="OnGrammarServerChanged"
+                         ToolTip.Tip="Your self-hosted server URL. Text is sent to this server only. No automatic installation, cloud API or redirects." />
+                <CheckBox x:Name="GrammarAutoFix" Content="Allow tested agreement fixes (requires English and MiniLM)"
+                          IsCheckedChanged="OnGrammarSettingChanged"
+                          ToolTip.Tip="Off: suggestions only. On: only explicit ele/ela/eles/elas + tem/têm/vem/vêm, after English subject, meaning and grammar rechecks. Other findings remain review notes." />
+                <TextBlock Text="LanguageTool suggestions are review notes unless an allowlisted fix passes every safeguard. No text generation. Use Run checks after changing settings."
+                           TextWrapping="Wrap" Opacity="0.7" />
                 <WrapPanel>
                     <CheckBox x:Name="MeaningCheck" Content="Flag meaning changes (MiniLM)" Margin="0,0,16,0"
                               IsCheckedChanged="OnEmbeddingSettingChanged"
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
index 23df3aca..fed65a1e 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
@@ -62,6 +62,10 @@ public partial class MainWindow : Window
     private CancellationTokenSource? _referenceCancel;
     private CheckBox _meaningCheck = null!;
     private CheckBox _judgeCheck = null!;
+    private CheckBox _grammarCheck = null!;
+    private CheckBox _grammarAutoFix = null!;
+    private TextBox _grammarServer = null!;
+    private string _lastGrammarServer = "";
     private readonly List<CheckLine> _checkLines = new();
     private readonly Dictionary<CheckLine, CheckResult> _checks = new();
     private ComboBox _addressChoice = null!;
@@ -130,10 +134,16 @@ internal MainWindow(PluginRequest request, string wordListPath)
         _conversationalCheck.IsChecked == true,
         _layoutWarningsCheck.IsChecked == true,
         _nameArticles,
-        _askNameArticlesCheck.IsChecked == true);
+        _askNameArticlesCheck.IsChecked == true,
+        _grammarCheck.IsChecked == true,
+        _grammarAutoFix.IsChecked == true,
+        _grammarServer.Text ?? "");
 
-    private bool NameSettingsChanged => _nameArticles != _initialOptions.NameArticles ||
-        (_askNameArticlesCheck.IsChecked == true) != _initialOptions.AskNameArticles;
+    private bool SettingsChanged => _nameArticles != _initialOptions.NameArticles ||
+        (_askNameArticlesCheck.IsChecked == true) != _initialOptions.AskNameArticles ||
+        Options.GrammarCheck != _initialOptions.GrammarCheck ||
+        Options.GrammarAutoFix != _initialOptions.GrammarAutoFix ||
+        Options.GrammarServer != _initialOptions.GrammarServer;
 
     private ConversionOptions SavedOptions => Options with { DisabledRules = _savedDisabledRules };
 
@@ -163,6 +173,10 @@ private void LoadOptions(ConversionOptions options)
         _savedDisabledRules = options.DisabledRules;
         _nameArticles = options.NameArticles;
         _askNameArticlesCheck.IsChecked = options.AskNameArticles;
+        _grammarCheck.IsChecked = options.GrammarCheck;
+        _grammarAutoFix.IsChecked = options.GrammarAutoFix;
+        _grammarServer.Text = options.GrammarServer;
+        _lastGrammarServer = options.GrammarServer;
         _loadingOptions = false;
 
         foreach (var check in OptionChecks)
@@ -175,10 +189,23 @@ private void OnOptionChanged(object? sender, RoutedEventArgs e)
     {
         if (!_loadingOptions && !_isConfigure)
         {
+            if (_checks.Values.Any(check => check.Rules?.Any(rule => rule.Id == "languagetool") == true ||
+                check.Note?.Contains("LanguageTool", StringComparison.Ordinal) == true))
+                _checks.Clear();
             RefreshProposals();
         }
     }
 
+    private void OnGrammarSettingChanged(object? sender, RoutedEventArgs e) => OnOptionChanged(sender, e);
+
+    private void OnGrammarServerChanged(object? sender, TextChangedEventArgs e)
+    {
+        var current = _grammarServer?.Text ?? "";
+        if (current == _lastGrammarServer) return;
+        _lastGrammarServer = current;
+        OnOptionChanged(sender, e);
+    }
+
     private void OnOrthographyChanged(object? sender, SelectionChangedEventArgs e) =>
         OnOptionChanged(sender, e);
 
@@ -342,8 +369,8 @@ private void RefreshProposals()
         _changesBorder.IsVisible = hasChanges;
         if (!hasChanges)
         {
-            _applyButton.IsEnabled = NameSettingsChanged;
-            _summaryLabel.Text = NameSettingsChanged ? "Apply to save personal name settings; subtitle unchanged." : string.Empty;
+            _applyButton.IsEnabled = SettingsChanged;
+            _summaryLabel.Text = SettingsChanged ? "Apply to save settings; subtitle unchanged." : string.Empty;
             return;
         }
 
@@ -388,6 +415,9 @@ private void InitializeComponent()
         _referenceCancelButton = this.FindControl<Button>("ReferenceCancelButton")!;
         _meaningCheck = this.FindControl<CheckBox>("MeaningCheck")!;
         _judgeCheck = this.FindControl<CheckBox>("JudgeCheck")!;
+        _grammarCheck = this.FindControl<CheckBox>("GrammarCheck")!;
+        _grammarAutoFix = this.FindControl<CheckBox>("GrammarAutoFix")!;
+        _grammarServer = this.FindControl<TextBox>("GrammarServer")!;
         _addressChoice = this.FindControl<ComboBox>("AddressChoice")!;
         _sentenceContextCheck = this.FindControl<CheckBox>("SentenceContextCheck")!;
         _rewrapCheck = this.FindControl<CheckBox>("RewrapCheck")!;
@@ -403,6 +433,10 @@ private void InitializeComponent()
             this.FindControl<Button>("ListDevicesButton")!, this.FindControl<Button>("DownloadModelButton")!, this.FindControl<Button>("DownloadRuntimeButton")!,
             this.FindControl<Button>("DownloadJudgeButton")!, this.FindControl<Button>("RunChecksButton")!,
             _embeddingCheck, _vulkanCheck, _deviceChoice, _meaningCheck, _judgeCheck,
+            _grammarCheck, _grammarAutoFix, _grammarServer,
+            _askNameArticlesCheck, this.FindControl<Button>("EditNameArticlesButton")!,
+            this.FindControl<Button>("ContributeVocabularyButton")!,
+            this.FindControl<Button>("DisableRuleButton")!, this.FindControl<Button>("RestoreRulesButton")!,
         };
     }
 
@@ -489,7 +523,8 @@ private void BuildProposals(PortugueseLocalWordList? localWordList)
             _checkLines.Add(checkLine);
             if (_checks.TryGetValue(checkLine, out var check))
             {
-                if (check.Text != text) rules.Add(new RuleChange("local-judge", "Gervásio chose a fixed alternative", "Local model ranking; see review note"));
+                if (check.Text != text)
+                    rules.AddRange(check.Rules ?? new[] { new RuleChange("local-judge", "Gervásio chose a fixed alternative", "Local model ranking; see review note") });
                 text = check.Text;
                 reviewNotes.Add(check.Note);
             }
@@ -578,7 +613,7 @@ private void UpdateSummary()
         var review = _proposals.Count(p => p.HasReview);
         _summaryLabel.Text = $"{selected} of {total} change(s) selected." + (review > 0 ? $" {review} to review." : string.Empty) +
             $" Showing {_proposals.Count(p => p.VisibleInReview)} of {_proposals.Count} row(s).";
-        _applyButton.IsEnabled = selected > 0 || NameSettingsChanged;
+        _applyButton.IsEnabled = selected > 0 || SettingsChanged;
     }
 
     private void OnFindingFilterChanged(object? sender, RoutedEventArgs e)
@@ -682,7 +717,8 @@ private bool ChecksReady
         get
         {
             var settings = EmbeddingAssets.WithInstalledFiles(_embeddingSettings);
-            return LocalChecks.JudgeReady(settings) || LocalChecks.MeaningReady(settings);
+            return Options.GrammarCheck && Options.RuleEnabled("languagetool") ||
+                LocalChecks.JudgeReady(settings) || LocalChecks.MeaningReady(settings);
         }
     }
 
@@ -696,9 +732,13 @@ await RunReferenceJob(async (progress, token) =>
         {
             _embeddingSettings = EmbeddingAssets.WithInstalledFiles(_embeddingSettings);
             if (!ChecksReady)
-                throw new InvalidOperationException("Tick a check and download its model and llama-server first.");
+                throw new InvalidOperationException("Enable LanguageTool with a self-hosted server, or enable and download a local model check.");
             var pending = _checkLines.ToList();
-            var (results, summary) = await LocalChecks.RunAsync(pending, _embeddingSettings, progress, token);
+            var options = Options;
+            var words = PortugueseLocalWordList.Load(_wordListPath);
+            var (results, summary) = await LocalChecks.RunAsync(pending, _embeddingSettings, progress, token, options, words);
+            if (options != Options || !pending.SequenceEqual(_checkLines))
+                throw new InvalidOperationException("Check settings or subtitle context changed during the run. Run checks again.");
             ApplyCheckResults(pending, results);
             _referenceStatus.Text = "Checks done. " + summary;
         });
@@ -755,7 +795,7 @@ or PlatformNotSupportedException or System.ComponentModel.Win32Exception or Inva
     private void UpdateSummaryOrEmpty()
     {
         if (_proposals.Count > 0) UpdateSummary();
-        else _applyButton.IsEnabled = NameSettingsChanged;
+        else _applyButton.IsEnabled = SettingsChanged;
     }
 
     private void OnCancelReference(object? sender, RoutedEventArgs e) => _referenceCancel?.Cancel();
@@ -929,6 +969,15 @@ private void OnCancel(object? sender, RoutedEventArgs e)
 
     private void OnApply(object? sender, RoutedEventArgs e)
     {
+        try
+        {
+            _ = LanguageToolClient.CheckUri(Options.GrammarServer);
+        }
+        catch (InvalidDataException ex)
+        {
+            _referenceStatus.Text = ex.Message;
+            return;
+        }
         if (_isConfigure)
         {
             App.Response = BatchMode.BuildConfigureResponse(SavedOptions);
@@ -944,7 +993,7 @@ private void OnApply(object? sender, RoutedEventArgs e)
 
             if (changesByLine.Count == 0)
             {
-                App.Response = NameSettingsChanged ? BatchMode.BuildConfigureResponse(SavedOptions) :
+                App.Response = SettingsChanged ? BatchMode.BuildConfigureResponse(SavedOptions) :
                     new PluginResponse { Status = PluginStatus.Cancelled };
                 Close();
                 return;
diff --git a/se5/BrazilianToEuropeanPortuguese/README.md b/se5/BrazilianToEuropeanPortuguese/README.md
index c2000209..b5d59d43 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.md
@@ -4,6 +4,9 @@
 
 ## Latest changes
 
+- Experimental, **off-by-default self-hosted LanguageTool pt-PT checks**, with
+  review suggestions and a narrowly allowlisted, English/MiniLM-guarded agreement pass.
+  No generative model or automatic Java/LanguageTool installation is added.
 - One **Contribute vocabulary / Local word list** window with three separate tabs.
 - Contribution CSVs for words and expressions, with optional examples and context;
   suggestions do not change conversion rules or upload automatically.
@@ -18,7 +21,9 @@ Earlier updates include reviewed workbook vocabulary and verb constructions,
 English-confirmed sportswear and shared-residence expressions, physical descriptions,
 finding filters, and original PT-BR text visible on warning-only rows.
 
-The standalone source build is **1.4.2**. Official Subtitle Edit package versions
+The experimental standalone source build is **1.8.0**. The pre-LanguageTool
+rollback baseline is [v1.7.0](https://github.com/SMAP-git/BrazilianToEuropeanPortuguese/tree/v1.7.0).
+Official Subtitle Edit package versions
 are assigned by the upstream release workflow and may differ.
 
 Version **1.4.2** improves contextual agreement and formal address, reference-confirmed
@@ -26,6 +31,79 @@ objects and vocabulary senses, natural dialogue constructions and interrogative
 accentuation. It adds regression coverage for these interactions while preserving
 subtitle cue timings and user-controlled rule options.
 
+### Optional self-hosted grammar checking (experimental)
+
+In the English reference / extra-checks panel, enable **LanguageTool pt-PT
+(self-hosted, off by default)** and enter the URL of a LanguageTool server you
+manage, for example `http://127.0.0.1:8081/`. Then choose **Run checks**. Saved
+settings also apply in **Batch convert**. Nothing is downloaded or started:
+LanguageTool and its Java runtime are managed separately. See the
+[official self-hosted server guide](https://dev.languagetool.org/http-server).
+The local distribution does not include LanguageTool's cloud-only AI rules.
+
+For Docker, `127.0.0.1` means the Subtitle Edit container itself. A separate
+LanguageTool container can instead use its service name and configured port,
+for example `http://languagetool:8010/`, on a private shared network. The plugin
+does not create containers or modify network settings.
+
+The pipeline is:
+
+1. Align available English and run the existing deterministic conversion rules.
+2. Check the converted Portuguese with `language=pt-PT` using POST `/v2/check`.
+   With **Convert complete sentences across adjacent cues** enabled, reuse only
+   the existing safe sentence groups (same-speaker/selection/timing safeguards,
+   at most three cues and 1200 characters). Otherwise check individual cues.
+   Never join arbitrary neighbouring dialogue.
+3. Show diagnostic messages, rule IDs and up to five replacement suggestions
+   as review notes. These notes do not automatically edit the text; use the
+   editable preview to accept a different correction.
+4. If **Allow tested agreement fixes** is enabled separately, permit only
+   `ele/ela/eles/elas` with incompatible `tem/têm` or `vem/vêm`, retaining the
+   explicit subject, person, tense, register, case, punctuation and whitespace.
+   The English must be comparable and start with the corresponding
+   `he/she/they`; English `you` never establishes formal/informal address.
+   Agreement/address conversion must remain enabled.
+5. Require exactly one eligible candidate, no overlapping diagnostic, an
+   enabled and installed MiniLM meaning check, and aligned English for the
+   whole checked group. Compare the candidate with the pre-correction Portuguese
+   and English using the existing meaning thresholds. High similarity alone
+   never authorises a correction.
+6. Recheck the candidate with LanguageTool: the targeted rule must have fewer
+   findings, with no new diagnostic fingerprints. Only then apply the edit,
+   within its original cue, without moving words or changing line breaks,
+   cue IDs or timings. At most one correction is accepted per checked group.
+
+Other grammatical, vocabulary, spelling, tense, pronoun and register suggestions
+remain review-only, even if MiniLM prefers them. This initial allowlist does not
+claim comprehensive grammatical correction. Quoted dialogue, dialogue-marker
+lines and markup are excluded from automatic fixes. Markup, ignored phrases
+and custom output vocabulary are masked with equal-length spaces for checking;
+masked groups are never automatically rewritten. Pre-1990 spelling settings
+are not overridden by LanguageTool suggestions.
+
+The plugin sends masked converted Portuguese only to the configured server;
+English and original Portuguese are not sent to LanguageTool. Use a server you
+trust: self-hosted does not necessarily mean it runs on this computer. Public
+LanguageTool cloud endpoints, embedded credentials and HTTP redirects are not
+supported. Protect any remote server/network yourself.
+
+Requests have a 15-second timeout and a bounded response size. Identical texts
+are cached only for the current run. Invalid, non-pt-PT or incomplete responses
+fail explicitly. Preview keeps the preceding result and displays the failure;
+batch reports the failure and retains rule-only output, without applying
+partial optional-check results. Batch counts findings; open the preview to see
+their details. No real LanguageTool server is bundled with the tests: protocol
+and safety tests use controlled responses. Actual rule coverage, false-positive
+rates and speed depend on your server and still require corpus benchmarking.
+
+**Undo / rollback:** disabling **LanguageTool pt-PT** clears its preview results
+and restores the existing conversion pipeline; untick **Allow tested agreement
+fixes** for suggestions only. Already applied subtitle edits require Subtitle
+Edit's Undo or restoring your subtitle copy. For a full code rollback, use the
+tagged v1.7.0 source/build rather than merging or reverting unrelated changes.
+The experimental work is isolated on `feature/languagetool-ptpt`; v1.7.0 remains
+the published deterministic baseline.
+
 Converts Brazilian Portuguese (pt-BR) subtitles to natural European Portuguese (pt-PT):
 spelling, vocabulary and grammar. Like *American to British*, it shows a checkable
 preview of every changed line, so you can review and untick individual changes before
diff --git a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
index d4bd1f14..814d990d 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
@@ -6,6 +6,10 @@ Português europeu | [English](README.md)
 
 ## Alterações mais recentes
 
+- Verificação experimental com **LanguageTool pt-PT autoalojado, desativada por
+  predefinição**, com sugestões para revisão e correções de concordância muito
+  delimitadas, protegidas pela referência inglesa e pelo MiniLM. Sem geração de
+  texto nem instalação automática de Java ou do LanguageTool.
 - Uma janela **Contribute vocabulary / Local word list** com três separadores distintos.
 - CSV de contribuições para palavras e expressões, com exemplos e contexto opcionais;
   as sugestões não alteram as regras de conversão nem são enviadas automaticamente.
@@ -22,7 +26,10 @@ partir de folhas de cálculo, vestuário desportivo e expressões de residência
 confirmados pelo inglês, descrições físicas, filtros de resultados e o texto
 original em PT-BR visível nas linhas que contêm apenas avisos.
 
-A compilação do repositório autónomo é a **1.4.2**. As versões oficiais dos
+A compilação experimental do repositório autónomo é a **1.8.0**. A base anterior
+ao LanguageTool está guardada em
+[v1.7.0](https://github.com/SMAP-git/BrazilianToEuropeanPortuguese/tree/v1.7.0).
+As versões oficiais dos
 pacotes do Subtitle Edit são atribuídas pelo fluxo de lançamento do projeto
 principal e podem ser diferentes.
 
@@ -32,6 +39,81 @@ construções naturais de diálogo e a acentuação interrogativa. Acrescenta te
 de regressão destas interações, preservando os tempos das legendas e as opções
 de regras controladas pelo utilizador.
 
+### Verificação gramatical autoalojada (experimental e opcional)
+
+No painel da referência inglesa e verificações adicionais, ative **LanguageTool
+pt-PT (self-hosted, off by default)**, introduza o endereço de um servidor que
+controle, por exemplo `http://127.0.0.1:8081/`, e escolha **Run checks**. As opções
+guardadas também se aplicam a **Batch convert**. O plugin não instala nem inicia
+Java ou o LanguageTool. Consulte o
+[guia oficial do servidor](https://dev.languagetool.org/http-server).
+A distribuição local não inclui as regras de IA exclusivas da nuvem.
+
+Em Docker, `127.0.0.1` identifica o próprio contentor do Subtitle Edit. Para um
+servidor noutro contentor da mesma rede privada, pode usar o nome do serviço e
+a porta configurada, por exemplo `http://languagetool:8010/`. O plugin não cria
+contentores nem altera a rede.
+
+A ordem de processamento é:
+
+1. Alinhar a referência inglesa disponível e executar as regras de conversão.
+2. Verificar o português convertido com `language=pt-PT`, por POST `/v2/check`.
+   Com **Convert complete sentences across adjacent cues** ativo, reutilizar
+   apenas os grupos seguros já existentes: salvaguardas de interlocutor, seleção
+   e tempos, no máximo três legendas e 1200 carateres. Sem essa opção, verificar
+   cada legenda separadamente, sem juntar arbitrariamente falas vizinhas.
+3. Apresentar mensagens, identificadores das regras e até cinco sugestões em
+   notas de revisão. Estas notas não alteram o texto automaticamente; pode
+   editar a correção na pré-visualização.
+4. Só com **Allow tested agreement fixes** também ativo, admitir as trocas
+   `tem/têm` e `vem/vêm` quando discordam de `ele/ela/eles/elas` explícitos.
+   Preservar sujeito, pessoa, tempo, tratamento, maiúsculas, pontuação e espaços.
+   A referência comparável tem de começar pelo sujeito correspondente
+   `he/she/they`; o inglês `you` nunca determina o tratamento formal ou informal.
+   A conversão de concordância/tratamento tem de continuar ativa.
+5. Exigir uma única candidata elegível, sem diagnósticos sobrepostos, MiniLM
+   instalado e verificação de significado ativa, e inglês alinhado para todo o
+   grupo. Comparar a candidata com o português anterior à correção e com o
+   inglês, usando os limiares existentes. Semelhança elevada não basta para
+   autorizar uma alteração.
+6. Voltar a verificar a candidata no LanguageTool: a regra em causa tem de
+   apresentar menos ocorrências, sem novos diagnósticos. Só depois aplicar a
+   correção dentro da legenda original, sem deslocar palavras, alterar quebras
+   de linha, identificadores ou tempos. No máximo uma correção por grupo.
+
+As restantes sugestões gramaticais, lexicais, ortográficas, de tempo verbal,
+pronomes ou tratamento ficam para revisão, mesmo com semelhança elevada no
+MiniLM. Esta lista inicial não pretende corrigir toda a gramática. Citações,
+marcadores de diálogo e formatação impedem correções automáticas. A formatação,
+as expressões ignoradas e o vocabulário de saída personalizado são substituídos
+por espaços com o mesmo comprimento durante a consulta; grupos com estas
+proteções nunca são reescritos automaticamente. A opção pré-Acordo não é
+substituída por sugestões do LanguageTool.
+
+Só o português convertido e protegido é enviado ao servidor configurado.
+O inglês e o português original não são enviados ao LanguageTool. Utilize um
+servidor de confiança: autoalojado não significa necessariamente local neste
+computador. Não são suportados os serviços públicos do LanguageTool, credenciais
+no endereço ou redirecionamentos HTTP. Proteja o servidor e a rede.
+
+Cada pedido tem um limite de 15 segundos e uma resposta de tamanho limitado.
+Textos iguais são reutilizados apenas durante a execução atual. Respostas
+inválidas, incompletas ou que não sejam pt-PT provocam um erro explícito.
+A pré-visualização mantém o resultado anterior e mostra o erro; o processamento
+em lote comunica a falha e conserva a saída das regras, sem aplicar resultados
+parciais das verificações opcionais. Em lote, as ocorrências são contadas; abra
+a pré-visualização para consultar os pormenores. Os testes usam respostas
+controladas, não um servidor real incluído: cobertura efetiva, falsos positivos
+e desempenho ainda precisam de avaliação com o seu servidor e as legendas.
+
+**Desfazer / voltar atrás:** desativar **LanguageTool pt-PT** limpa os resultados
+da pré-visualização e repõe o processamento existente. Desativar apenas
+**Allow tested agreement fixes** mantém as sugestões sem alterações automáticas.
+Para alterações já aplicadas, utilize Desfazer no Subtitle Edit ou uma cópia
+das legendas. Para repor integralmente o código, utilize a versão marcada
+v1.7.0. A experiência está isolada em `feature/languagetool-ptpt`; a v1.7.0
+continua a ser a base determinística publicada.
+
 Converte legendas de português do Brasil (pt-BR) para português europeu (pt-PT),
 adaptando a ortografia, o vocabulário e a gramática. Tal como o plugin *American to
 British*, apresenta uma pré-visualização de cada legenda alterada, com uma caixa
diff --git a/se5/BrazilianToEuropeanPortuguese/plugin.json b/se5/BrazilianToEuropeanPortuguese/plugin.json
index c37415ed..5a69cebb 100644
--- a/se5/BrazilianToEuropeanPortuguese/plugin.json
+++ b/se5/BrazilianToEuropeanPortuguese/plugin.json
@@ -2,7 +2,7 @@
   "apiVersion": 1,
   "name": "Brazilian to European Portuguese",
   "description": "Converts Brazilian Portuguese (pt-BR) to European Portuguese (pt-PT), with complement-aware vocabulary, personal infinitives, guarded clause agreement and idioms, optional conversational style, dialogue controls and grammar review. Shows a checkable preview of changes and their rule stages.",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "author": "Subtitle Edit",
   "url": "https://github.com/SubtitleEdit/plugins/tree/main/se5/BrazilianToEuropeanPortuguese",
   "menu": "Tools",

From 427911ca350787554814d65ef014737e8f87392e Mon Sep 17 00:00:00 2001
From: SMAP-git <333812182+SMAP-git@users.noreply.github.com>
Date: Wed, 11 Nov 2026 13:36:30 +0100
Subject: [PATCH 2/7] Manage local pt-PT grammar checker and arrange context
 panels

Add verified LanguageTool and portable Java downloads, owned loopback server lifecycle, and advanced external-server mode. Preserve real grammar phrase suggestions and subtitle boundaries. Move reference/model settings beside dialogue/layout and document the opt-in v1.8.1 workflow.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../GrammarChecksTests.cs                     |  33 ++-
 .../GrammarRuntimeTests.cs                    | 162 +++++++++++
 .../ReferenceTests.cs                         |  27 +-
 .../ConversionOptions.cs                      |   7 +-
 .../EmbeddingRuntime.cs                       |  11 +-
 .../GrammarChecks.cs                          |  23 +-
 .../GrammarRuntime.cs                         | 264 ++++++++++++++++++
 .../LocalChecks.cs                            |   4 +-
 .../MainWindow.axaml                          |  86 +++---
 .../MainWindow.axaml.cs                       |  50 +++-
 se5/BrazilianToEuropeanPortuguese/README.md   |  67 +++--
 .../README.pt-PT.md                           |  70 +++--
 se5/BrazilianToEuropeanPortuguese/plugin.json |   2 +-
 13 files changed, 711 insertions(+), 95 deletions(-)
 create mode 100644 se5/BrazilianToEuropeanPortuguese.Tests/GrammarRuntimeTests.cs
 create mode 100644 se5/BrazilianToEuropeanPortuguese/GrammarRuntime.cs

diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs
index c8dca1a9..0e84936c 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs
@@ -158,6 +158,35 @@ public async Task SubjectInPreviousSafeCueCanConfirmAgreementWithoutMovingWords(
         Assert.Equal("têm razão.", result.Texts[1]);
     }
 
+    [Theory]
+    [InlineData("Eles tem razão.", "Eles têm razão.")]
+    [InlineData("Eles\ntem razão.", "Eles\ntêm razão.")]
+    public async Task LanguageToolPhraseReplacementsPreserveWhitespaceAndRejectSubjectChanges(string before, string expected)
+    {
+        var result = await Run(new[] { Line(before) }, embed: SameMeaning, check: (text, _) =>
+            Task.FromResult<IReadOnlyList<GrammarMatch>>(text.Contains("tem", StringComparison.Ordinal)
+                ? new[] { new GrammarMatch(0, text.IndexOf("tem", StringComparison.Ordinal) + 3, "GENERAL_VERB_AGREEMENT_ERRORS",
+                    "Concordância.", new[] { "Eles têm", "Ele tem" }) } : Array.Empty<GrammarMatch>()));
+        Assert.Equal(expected, result.Texts[0]);
+    }
+
+    [Fact]
+    public async Task ActualPhraseReplacementMaySpanSafeCueBoundaryButOnlyVerbChanges()
+    {
+        var sentence = new SentenceMeaning(0, 1, "Eles tem razão.", "They are right.");
+        var lines = new[]
+        {
+            Line("Eles", "They") with { MeaningSentence = sentence },
+            new CheckLine(1, "tem razão.", "tem razão.", null, "are right.", sentence),
+        };
+        var result = await Run(lines, embed: SameMeaning, check: (text, _) =>
+            Task.FromResult<IReadOnlyList<GrammarMatch>>(text.Contains("tem", StringComparison.Ordinal)
+                ? new[] { new GrammarMatch(0, 8, "GENERAL_VERB_AGREEMENT_ERRORS", "Concordância.",
+                    new[] { "Eles têm", "Ele tem" }) } : Array.Empty<GrammarMatch>()));
+        Assert.Equal("Eles", result.Texts[0]);
+        Assert.Equal("têm razão.", result.Texts[1]);
+    }
+
     [Fact]
     public async Task LowSimilarityWithholdsCandidateBeforeGrammarRecheck()
     {
@@ -409,7 +438,7 @@ public async Task BatchUsesSelfHostedProtocolAndPreservesTimingsAndTextInReviewM
             RequestType = PluginRequestType.Batch,
             Subtitle = new PluginSubtitle { SubRip = "1\n00:00:01,234 --> 00:00:03,456\nOlá, mundo.\n\n" },
             SettingsVersion = ConversionOptions.Version,
-            Settings = new ConversionOptions(GrammarCheck: true, GrammarServer: $"http://127.0.0.1:{port}/").ToJson(),
+            Settings = new ConversionOptions(GrammarCheck: true, GrammarServer: $"http://127.0.0.1:{port}/", GrammarExternalServer: true).ToJson(),
         };
         var result = await Task.Run(() => BatchMode.BuildBatchResponse(request, Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".xml"),
             new EmbeddingSettings(CheckMeaning: false)), limit.Token);
@@ -429,7 +458,7 @@ public void BatchReportsServerFailureAndRetainsRuleOutput()
             RequestType = PluginRequestType.Batch,
             Subtitle = new PluginSubtitle { SubRip = "1\n00:00:01,234 --> 00:00:03,456\nPegue o ônibus.\n\n" },
             SettingsVersion = ConversionOptions.Version,
-            Settings = new ConversionOptions(GrammarCheck: true, GrammarServer: "http://127.0.0.1:0/").ToJson(),
+            Settings = new ConversionOptions(GrammarCheck: true, GrammarServer: "http://127.0.0.1:0/", GrammarExternalServer: true).ToJson(),
         };
         var response = BatchMode.BuildBatchResponse(request, Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".xml"),
             new EmbeddingSettings(CheckMeaning: false));
diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/GrammarRuntimeTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/GrammarRuntimeTests.cs
new file mode 100644
index 00000000..f940af94
--- /dev/null
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/GrammarRuntimeTests.cs
@@ -0,0 +1,162 @@
+using System.Diagnostics;
+using System.Formats.Tar;
+using System.IO.Compression;
+using System.Runtime.InteropServices;
+using System.Text;
+using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
+using SubtitleEdit.Plugins.Shared;
+using Xunit.Abstractions;
+
+namespace BrazilianToEuropeanPortuguese.Tests;
+
+[Collection("XdgDataHome")]
+public sealed class GrammarRuntimeTests(ITestOutputHelper output)
+{
+    [Theory]
+    [InlineData("linux", Architecture.X64)]
+    [InlineData("linux", Architecture.Arm64)]
+    [InlineData("mac", Architecture.X64)]
+    [InlineData("mac", Architecture.Arm64)]
+    [InlineData("windows", Architecture.X64)]
+    [InlineData("windows", Architecture.Arm64)]
+    public void PortableJavaPackagesArePinnedForSupportedTargets(string os, Architecture architecture)
+    {
+        var package = GrammarAssets.JavaPackage(os, architecture);
+        Assert.Equal(64, package.Hash.Length);
+        Assert.Matches("^[a-f0-9]{64}$", package.Hash);
+        Assert.InRange(package.Size, 30_000_000, 60_000_000);
+        Assert.Contains("21.0.13", package.File);
+        Assert.StartsWith("https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.13%2B9/", package.Url);
+        if (os == "windows") Assert.Contains("x64_windows", package.File);
+    }
+
+    [Fact]
+    public void UnsupportedJavaPlatformAndArchitectureFailExplicitly()
+    {
+        Assert.Throws<PlatformNotSupportedException>(() => GrammarAssets.JavaPackage("linux", Architecture.X86));
+        Assert.Throws<PlatformNotSupportedException>(() => GrammarAssets.JavaPackage("other", Architecture.X64));
+    }
+
+    [Fact]
+    public void GrammarPackageIsFixedAndDefaultsAreManagedButOff()
+    {
+        Assert.Equal("https://languagetool.org/download/LanguageTool-6.6.zip", GrammarAssets.Tool.Url);
+        Assert.Equal("53600506b399bb5ffe1e4c8dec794fd378212f14aaf38ccef9b6f89314d11631", GrammarAssets.Tool.Hash);
+        Assert.Equal(251998221, GrammarAssets.Tool.Size);
+        Assert.False(ConversionOptions.Default.GrammarCheck);
+        Assert.False(ConversionOptions.Default.GrammarExternalServer);
+        var external = new ConversionOptions(GrammarCheck: true, GrammarExternalServer: true);
+        Assert.Equal(external, ConversionOptions.Load(new PluginRequest
+        {
+            SettingsVersion = ConversionOptions.Version, Settings = external.ToJson(),
+        }));
+    }
+
+    [Fact]
+    public async Task MissingManagedAssetsExplainTheTwoDownloadButtons()
+    {
+        var directory = Path.Combine(Path.GetTempPath(), "ptpt-missing-grammar-" + Guid.NewGuid().ToString("N"));
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(() =>
+            GrammarRuntime.StartAsync(new Progress<string>(), CancellationToken.None, directory));
+        Assert.Contains("Download LanguageTool pt-PT", exception.Message);
+        Assert.Contains("Download portable Java", exception.Message);
+        Assert.False(Directory.Exists(directory));
+    }
+
+    [Fact]
+    public void SafeJavaLicenseAliasesAreCopiedAndEscapesAreRejected()
+    {
+        var directory = Path.Combine(Path.GetTempPath(), "ptpt-grammar-extract-" + Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(directory);
+        var archive = Path.Combine(directory, "java.tar.gz");
+        try
+        {
+            void Archive(string link)
+            {
+                using var file = File.Create(archive);
+                using var gzip = new GZipStream(file, CompressionMode.Compress);
+                using var writer = new TarWriter(gzip);
+                using var content = new MemoryStream(Encoding.UTF8.GetBytes("license text"));
+                writer.WriteEntry(new PaxTarEntry(TarEntryType.RegularFile, "java/legal/java.base/LICENSE") { DataStream = content });
+                writer.WriteEntry(new PaxTarEntry(TarEntryType.SymbolicLink, "java/legal/java.naming/LICENSE") { LinkName = link });
+            }
+            Archive("../java.base/LICENSE");
+            var safe = Path.Combine(directory, "safe");
+            EmbeddingAssets.ExtractRuntime(archive, safe, CancellationToken.None, allowInternalLinks: true);
+            Assert.Equal("license text", File.ReadAllText(Path.Combine(safe, "java/legal/java.naming/LICENSE")));
+            Assert.Null(new FileInfo(Path.Combine(safe, "java/legal/java.naming/LICENSE")).LinkTarget);
+            Archive("../../../../outside");
+            Assert.Throws<InvalidDataException>(() =>
+                EmbeddingAssets.ExtractRuntime(archive, Path.Combine(directory, "unsafe"), CancellationToken.None, allowInternalLinks: true));
+        }
+        finally { Directory.Delete(directory, true); }
+    }
+
+    [OptInFact("PTPT_TEST_GRAMMAR", "downloads and runs the actual managed LanguageTool and portable Java")]
+    public async Task RealManagedPtPtCheckerStartsChecksAndStopsWithoutExternalServer()
+    {
+        var directory = Environment.GetEnvironmentVariable("PTPT_GRAMMAR_TEST_ROOT") ??
+            Path.Combine(Path.GetTempPath(), "ptpt-real-grammar-" + Guid.NewGuid().ToString("N"));
+        var keep = Environment.GetEnvironmentVariable("PTPT_GRAMMAR_TEST_ROOT") != null;
+        using var limit = new CancellationTokenSource(TimeSpan.FromMinutes(8));
+        var progress = new Progress<string>(output.WriteLine);
+        try
+        {
+            await GrammarAssets.DownloadToolAsync(progress, limit.Token, directory);
+            await GrammarAssets.DownloadJavaAsync(progress, limit.Token, directory);
+            Assert.True(GrammarAssets.IsInstalled(directory));
+            int pid;
+            var clock = Stopwatch.StartNew();
+            await using (var runtime = await GrammarRuntime.StartAsync(progress, limit.Token, directory))
+            {
+                pid = runtime.ProcessId;
+                output.WriteLine($"Ready in {clock.Elapsed.TotalSeconds:0.00}s; PID {pid}; {runtime.Server}");
+                using var client = new LanguageToolClient(runtime.Server);
+                var examples = new[]
+                {
+                    "Eles tem razão.", "Eles têm razão.", "Elas vem aqui.", "Elas vêm aqui.",
+                    "Ela falarei nisto.", "Não para polícias.", "As operações policiais começaram.",
+                };
+                clock.Restart();
+                foreach (var example in examples)
+                {
+                    var matches = await client.CheckAsync(example, limit.Token);
+                    output.WriteLine(example + " => " + string.Join("; ", matches.Select(m =>
+                        $"{m.Rule}: {string.Join("/", m.Replacements.Take(3))}")));
+                }
+                output.WriteLine($"Checked {examples.Length} examples in {clock.Elapsed.TotalSeconds:0.00}s.");
+                var wrong = await client.CheckAsync(examples[0], limit.Token);
+                Assert.Contains(wrong, m => m.Replacements.Contains("Eles têm", StringComparer.Ordinal));
+                var correct = await client.CheckAsync(examples[1], limit.Token);
+                Assert.DoesNotContain(correct, m => m.Replacements.Contains("tem", StringComparer.Ordinal));
+                var lines = new[] { new CheckLine(0, examples[0], examples[0], null, "They are right.") };
+                var texts = new Dictionary<int, string> { [0] = examples[0] };
+                var notes = new List<string>();
+                var summary = await GrammarChecks.RunAsync(lines, new ConversionOptions(GrammarCheck: true, GrammarAutoFix: true),
+                    null, texts, (_, note) => notes.Add(note), client.CheckAsync,
+                    (_, _) => Task.FromResult(new[] { 1f, 0f }), progress, limit.Token);
+                Assert.Equal(examples[1], texts[0]);
+                Assert.Contains(notes, n => n.Contains("corrected"));
+                output.WriteLine(summary);
+            }
+            try
+            {
+                using var process = Process.GetProcessById(pid);
+                Assert.True(process.HasExited);
+            }
+            catch (ArgumentException) { /* Process has been reaped. */ }
+            Assert.Empty(Directory.GetFiles(directory, "server-*.properties"));
+
+            var cancelled = new CancellationTokenSource();
+            cancelled.Cancel();
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() =>
+                GrammarRuntime.StartAsync(progress, cancelled.Token, directory));
+            cancelled.Dispose();
+            using var interrupted = new CancellationTokenSource(TimeSpan.FromMilliseconds(50));
+            await Assert.ThrowsAnyAsync<OperationCanceledException>(() =>
+                GrammarRuntime.StartAsync(progress, interrupted.Token, directory));
+            Assert.Empty(Directory.GetFiles(directory, "server-*.properties"));
+        }
+        finally { if (!keep && Directory.Exists(directory)) Directory.Delete(directory, true); }
+    }
+}
diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
index d2938cfd..4f2fd437 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
@@ -485,6 +485,12 @@ public void MainWindowAppliesReferenceToProposals()
             });
             Assert.True(grammarWindow.FindControl<CheckBox>("GrammarCheck")!.IsChecked);
             Assert.False(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.IsChecked);
+            Assert.False(grammarWindow.FindControl<CheckBox>("GrammarExternalServer")!.IsChecked);
+            Assert.False(grammarWindow.FindControl<TextBox>("GrammarServer")!.IsVisible);
+            Assert.NotNull(grammarWindow.FindControl<Button>("DownloadGrammarButton"));
+            Assert.NotNull(grammarWindow.FindControl<Button>("DownloadJavaButton"));
+            grammarWindow.FindControl<CheckBox>("GrammarExternalServer")!.IsChecked = true;
+            Assert.True(grammarWindow.FindControl<TextBox>("GrammarServer")!.IsVisible);
             Assert.Equal("http://languagetool:8010/", grammarWindow.FindControl<TextBox>("GrammarServer")!.Text);
             grammarWindow.ApplyCheckResults(new[] { new CheckLine(0, "Olá.", "Olá.", null, null) },
                 new Dictionary<int, CheckResult> { [0] = new("Olá.", "LanguageTool [TEST]: review only.") });
@@ -1014,6 +1020,25 @@ void LayoutScreenshot()
                 Avalonia.Threading.Dispatcher.UIThread.RunJobs();
             }
             LayoutScreenshot();
+            var panels = screenshotWindow.FindControl<Grid>("ReviewLayoutPanels")!;
+            var layoutPanel = screenshotWindow.FindControl<Expander>("LayoutTools")!;
+            var referencePanel = screenshotWindow.FindControl<Expander>("ReferencePanel")!;
+            Assert.Same(panels, layoutPanel.Parent);
+            Assert.Same(panels, referencePanel.Parent);
+            Assert.Equal(1, Grid.GetColumn(layoutPanel));
+            Assert.Equal(2, Grid.GetColumn(referencePanel));
+            Assert.True(referencePanel.Bounds.X >= layoutPanel.Bounds.Right);
+            Assert.True(referencePanel.Bounds.Width > 200);
+            Assert.True(referencePanel.Bounds.Right <= panels.Bounds.Width + 0.1);
+            if (Environment.GetEnvironmentVariable("PTPT_UI_LAYOUT_CAPTURE") is { Length: > 0 } capture)
+            {
+                layoutPanel.IsExpanded = true;
+                LayoutScreenshot();
+                using var bitmap = new Avalonia.Media.Imaging.RenderTargetBitmap(
+                    new Avalonia.PixelSize((int)screenshotContent.Bounds.Width, (int)screenshotContent.Bounds.Height));
+                bitmap.Render(screenshotContent);
+                bitmap.Save(capture);
+            }
             var settingsHeight = settingsPanel.Bounds.Height;
             var reviewHeight = screenshotWindow.FindControl<Border>("ChangesBorder")!.Bounds.Height;
             toggleSettings.RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
@@ -1046,7 +1071,7 @@ void LayoutScreenshot()
             });
             Assert.Contains("a tua foto", window.Proposals[0].ConvertedText);
             Assert.Contains("MiniLM is not installed", window.ReferenceStatusText);
-            Assert.Equal("Model: not downloaded\nllama-server: not downloaded\nGervásio: not downloaded", window.AssetStatusText);
+            Assert.Equal("Model: not downloaded\nllama-server: not downloaded\nGervásio: not downloaded\nLanguageTool pt-PT: not downloaded\nPortable Java: not downloaded", window.AssetStatusText);
             window.FindReferenceAutomatically().GetAwaiter().GetResult();
             Assert.Equal(4, window.Alignment!.Matched);
             Assert.Contains("a sua foto", window.Proposals[0].ConvertedText);
diff --git a/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs b/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs
index 58304e10..abeff422 100644
--- a/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs
+++ b/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs
@@ -29,7 +29,8 @@ public sealed record ConversionOptions(
     bool AskNameArticles = true,
     bool GrammarCheck = false,
     bool GrammarAutoFix = false,
-    string GrammarServer = "http://127.0.0.1:8081/")
+    string GrammarServer = "http://127.0.0.1:8081/",
+    bool GrammarExternalServer = false)
 {
     public const int Version = 1;
 
@@ -60,6 +61,7 @@ public JsonElement ToJson() => JsonSerializer.SerializeToElement(new
         grammarCheck = GrammarCheck,
         grammarAutoFix = GrammarAutoFix,
         grammarServer = GrammarServer,
+        grammarExternalServer = GrammarExternalServer,
     });
 
     public static ConversionOptions Load(PluginRequest request)
@@ -94,7 +96,8 @@ public static ConversionOptions Load(PluginRequest request)
             !json.TryGetProperty("askNameArticles", out _) || ReadOptIn(json, "askNameArticles"),
             ReadOptIn(json, "grammarCheck"),
             ReadOptIn(json, "grammarAutoFix"),
-            ReadGrammarServer(json));
+            ReadGrammarServer(json),
+            ReadOptIn(json, "grammarExternalServer"));
     }
 
     public bool RuleEnabled(string id) => DisabledRules.Length == 0 || !DisabledRules.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
diff --git a/se5/BrazilianToEuropeanPortuguese/EmbeddingRuntime.cs b/se5/BrazilianToEuropeanPortuguese/EmbeddingRuntime.cs
index e8665290..3f56072f 100644
--- a/se5/BrazilianToEuropeanPortuguese/EmbeddingRuntime.cs
+++ b/se5/BrazilianToEuropeanPortuguese/EmbeddingRuntime.cs
@@ -185,7 +185,7 @@ internal static string SafePath(string directory, string entry)
         return path;
     }
 
-    internal static void ExtractRuntime(string archive, string directory, CancellationToken token)
+    internal static void ExtractRuntime(string archive, string directory, CancellationToken token, bool allowInternalLinks = false)
     {
         long total = 0;
         int count = 0;
@@ -234,9 +234,10 @@ void Copy(string name, long size, Stream input)
                 {
                     if (++count > 3000) throw new InvalidDataException("Too many runtime entries.");
                     var path = SafePath(directory, entry.Name);
-                    if (entry.LinkName != Path.GetFileName(entry.LinkName) || entry.LinkName.Contains('\\') ||
-                        entry.LinkName is "." or "..")
-                        throw new InvalidDataException("Only sibling library aliases are allowed.");
+                    if (entry.LinkName.Contains('\\') || entry.LinkName.Contains(':') || Path.IsPathRooted(entry.LinkName) ||
+                        entry.LinkName is "." or ".." ||
+                        !allowInternalLinks && entry.LinkName != Path.GetFileName(entry.LinkName))
+                        throw new InvalidDataException("Only safe internal archive aliases are allowed.");
                     links.Add(path, SafePath(directory, Path.Combine(Path.GetDirectoryName(entry.Name)!, entry.LinkName)));
                     continue;
                 }
@@ -245,7 +246,7 @@ void Copy(string name, long size, Stream input)
                 Copy(entry.Name, entry.Length, entry.DataStream!);
             }
         }
-        // Library aliases (libggml.so.0 → libggml.so.0.27.0) become regular copies.
+        // Aliases become regular copies; their final target must be an extracted regular file.
         foreach (var link in links)
         {
             var target = link.Value;
diff --git a/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs b/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs
index fafbfb16..dcd4b902 100644
--- a/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs
+++ b/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs
@@ -38,10 +38,10 @@ internal static async Task<string> RunAsync(IReadOnlyList<CheckLine> lines, Conv
             var english = group.Any(l => string.IsNullOrWhiteSpace(l.Reference))
                 ? null : string.Join(" ", group.Select(l => l.Reference));
             var allowed = matches.SelectMany(m => m.Replacements.Take(5).Select(r =>
-                (Match: m, Text: baseline[..m.Offset] + r + baseline[(m.Offset + m.Length)..])))
+                (Match: m, Text: Suggestion(baseline, m, r))))
                 .Where(c => masked == baseline && Eligible(baseline, c.Text, english, options) &&
                     !matches.Any(m => m != c.Match && Overlaps(m, c.Match)) &&
-                    WithinCue(parts, c.Match)).Distinct().ToArray();
+                    ChangedWithinCue(parts, baseline, c.Text)).Distinct().ToArray();
             string? accepted = null;
             GrammarMatch? acceptedMatch = null;
             var reason = !options.GrammarAutoFix ? "review only" :
@@ -137,12 +137,27 @@ private static bool Visible(string masked, string original, GrammarMatch match)
     private static bool Overlaps(GrammarMatch a, GrammarMatch b) =>
         a.Offset < b.Offset + b.Length && b.Offset < a.Offset + a.Length;
 
-    private static bool WithinCue(string[] parts, GrammarMatch match)
+    internal static string Suggestion(string baseline, GrammarMatch match, string replacement)
     {
+        var original = baseline.Substring(match.Offset, match.Length);
+        var words = Regex.Matches(replacement, @"\S+").Select(m => m.Value).ToArray();
+        if (words.Length == Regex.Matches(original, @"\S+").Count)
+        {
+            var index = 0;
+            replacement = Regex.Replace(original, @"\S+", _ => words[index++]);
+        }
+        return baseline[..match.Offset] + replacement + baseline[(match.Offset + match.Length)..];
+    }
+
+    private static bool ChangedWithinCue(string[] parts, string before, string after)
+    {
+        if (before.Length != after.Length) return false;
+        var changed = Enumerable.Range(0, before.Length).Where(i => before[i] != after[i]).ToArray();
+        if (changed.Length == 0) return false;
         var start = 0;
         foreach (var part in parts)
         {
-            if (match.Offset >= start && match.Offset + match.Length <= start + part.Length) return true;
+            if (changed[0] >= start && changed[^1] < start + part.Length) return true;
             start += part.Length + 1;
         }
         return false;
diff --git a/se5/BrazilianToEuropeanPortuguese/GrammarRuntime.cs b/se5/BrazilianToEuropeanPortuguese/GrammarRuntime.cs
new file mode 100644
index 00000000..6ad3117c
--- /dev/null
+++ b/se5/BrazilianToEuropeanPortuguese/GrammarRuntime.cs
@@ -0,0 +1,264 @@
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using System.Net;
+using System.Net.Http;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
+
+internal sealed record GrammarPackage(string File, string Url, string Hash, long Size);
+
+internal static class GrammarAssets
+{
+    internal const string ToolVersion = "6.6";
+    internal const string JavaVersion = "21.0.13+9";
+    internal static readonly GrammarPackage Tool = new("LanguageTool-6.6.zip",
+        "https://languagetool.org/download/LanguageTool-6.6.zip",
+        "53600506b399bb5ffe1e4c8dec794fd378212f14aaf38ccef9b6f89314d11631", 251998221);
+    internal static string DirectoryPath => Path.Combine(
+        Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+        "SubtitleEdit", "BrazilianToEuropeanPortuguese", "GrammarChecker");
+
+    internal static GrammarPackage JavaPackage(string os, Architecture architecture)
+    {
+        // Windows on ARM runs the current x64 Temurin JRE through OS emulation.
+        var arch = architecture switch
+        {
+            Architecture.X64 => "x64",
+            Architecture.Arm64 when os == "windows" => "x64",
+            Architecture.Arm64 => "aarch64",
+            _ => throw new PlatformNotSupportedException("Portable Java downloads support x64 and ARM64."),
+        };
+        var (hash, size) = (os, arch) switch
+        {
+            ("linux", "x64") => ("a535a1df9c6284d9618872984e026ae0352d1f7e9e0605425c0e6114f47351dd", 52181297L),
+            ("linux", "aarch64") => ("b1734db7ade49c3f6acc6ae06233b8c2dd90e3e2f00f67000ae1c972aaa64d8c", 51266660L),
+            ("mac", "x64") => ("c909674b1c10c261b9a3fb7e9c0efebd303e33f88a4fe84be7135b5e2d711f89", 41902098L),
+            ("mac", "aarch64") => ("225bab0a09491ef06835488cd942f5d2befa9a0410a2484f0c8bbcf7506ec09a", 47935740L),
+            ("windows", "x64") => ("2332c0b4cff6bed722da3567c91d5e47568bcba863fa4945d0a8d6fc76158628", 49106397L),
+            _ => throw new PlatformNotSupportedException("Portable Java downloads support Windows, Linux and macOS."),
+        };
+        var name = $"OpenJDK21U-jre_{arch}_{os}_hotspot_21.0.13_9." + (os == "windows" ? "zip" : "tar.gz");
+        return new GrammarPackage(name,
+            "https://github.com/adoptium/temurin21-binaries/releases/download/jdk-21.0.13%2B9/" + name, hash, size);
+    }
+
+    internal static GrammarPackage JavaPackage() => JavaPackage(
+        OperatingSystem.IsWindows() ? "windows" : OperatingSystem.IsLinux() ? "linux" :
+        OperatingSystem.IsMacOS() ? "mac" : throw new PlatformNotSupportedException("Unsupported Java platform."),
+        RuntimeInformation.ProcessArchitecture);
+
+    internal static string ToolJar(string? root = null) =>
+        Path.Combine(root ?? DirectoryPath, "tool-" + ToolVersion, "LanguageTool-" + ToolVersion, "languagetool-server.jar");
+
+    internal static string JavaExecutable(string? root = null)
+    {
+        var home = Path.Combine(root ?? DirectoryPath, "java-" + JavaVersion, "jdk-" + JavaVersion + "-jre");
+        if (OperatingSystem.IsMacOS()) home = Path.Combine(home, "Contents", "Home");
+        return Path.Combine(home, "bin", OperatingSystem.IsWindows() ? "java.exe" : "java");
+    }
+
+    internal static bool IsInstalled(string? root = null) => File.Exists(ToolJar(root)) && File.Exists(JavaExecutable(root));
+
+    internal static Task DownloadToolAsync(IProgress<string> progress, CancellationToken token, string? root = null) =>
+        InstallAsync(Tool, "tool-" + ToolVersion, ToolJar(root), progress, token, root);
+
+    internal static Task DownloadJavaAsync(IProgress<string> progress, CancellationToken token, string? root = null) =>
+        InstallAsync(JavaPackage(), "java-" + JavaVersion, JavaExecutable(root), progress, token, root);
+
+    private static async Task InstallAsync(GrammarPackage package, string folder, string expected,
+        IProgress<string> progress, CancellationToken token, string? directory)
+    {
+        var root = directory ?? DirectoryPath;
+        Directory.CreateDirectory(root);
+        FileStream installLock;
+        try
+        {
+            installLock = new FileStream(Path.Combine(root, "install.lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
+        }
+        catch (IOException ex)
+        {
+            throw new IOException("Grammar checker installation is already running in another plugin instance.", ex);
+        }
+        await using (installLock)
+        {
+            if (File.Exists(expected))
+            {
+                progress.Report(package.File + " is already installed.");
+                return;
+            }
+            var archive = Path.Combine(root, package.File);
+            if (!File.Exists(archive) || !await EmbeddingAssets.HasHashAsync(archive, package.Hash, token))
+                await EmbeddingAssets.DownloadAsync(new Uri(package.Url), archive, package.Hash, package.Size, progress, token);
+            var target = Path.Combine(root, folder);
+            if (Directory.Exists(target))
+                throw new IOException("Incomplete grammar checker installation at " + target + ". Remove that version's folder and download again.");
+            var staging = Path.Combine(root, "install-" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(staging);
+            try
+            {
+                progress.Report("Extracting " + package.File + "...");
+                await Task.Run(() => EmbeddingAssets.ExtractRuntime(archive, staging, token, allowInternalLinks: true), token);
+                var executable = Path.Combine(staging, Path.GetRelativePath(target, expected));
+                if (!File.Exists(executable)) throw new InvalidDataException("Grammar package is missing its expected executable or server JAR.");
+                if (!OperatingSystem.IsWindows() && expected == JavaExecutable(root))
+                    File.SetUnixFileMode(executable, File.GetUnixFileMode(executable) | UnixFileMode.UserExecute);
+                token.ThrowIfCancellationRequested();
+                Directory.Move(staging, target);
+                File.Delete(archive);
+            }
+            finally
+            {
+                if (Directory.Exists(staging)) Directory.Delete(staging, true);
+            }
+        }
+    }
+}
+
+/// <summary>Owned loopback-only LanguageTool server, started for a check and stopped afterwards.</summary>
+internal sealed class GrammarRuntime : IAsyncDisposable
+{
+    private static readonly ConcurrentDictionary<Process, byte> Running = new();
+    private readonly Process _process;
+    private readonly StringBuilder _log = new();
+    private readonly Task _stdout;
+    private readonly Task _stderr;
+    private readonly string _configuration;
+    internal string Server { get; }
+    internal int ProcessId => _process.Id;
+
+    static GrammarRuntime() => AppDomain.CurrentDomain.ProcessExit += (_, _) => KillAll();
+
+    private GrammarRuntime(Process process, string server, string configuration)
+    {
+        _process = process;
+        Server = server;
+        _configuration = configuration;
+        Running.TryAdd(process, 0);
+        _stdout = ReadLogAsync(process.StandardOutput);
+        _stderr = ReadLogAsync(process.StandardError);
+    }
+
+    private async Task ReadLogAsync(StreamReader reader)
+    {
+        while (await reader.ReadLineAsync() is { } line)
+            lock (_log)
+            {
+                if (_log.Length > 16000) _log.Remove(0, _log.Length - 8000);
+                _log.AppendLine(line);
+            }
+    }
+
+    private string Tail() { lock (_log) return _log.ToString(); }
+
+    internal static async Task<GrammarRuntime> StartAsync(IProgress<string> progress, CancellationToken token, string? root = null)
+    {
+        token.ThrowIfCancellationRequested();
+        if (!GrammarAssets.IsInstalled(root))
+            throw new InvalidOperationException("Local grammar checker is not ready. Click Download LanguageTool pt-PT and Download portable Java first.");
+        using var listener = new TcpListener(IPAddress.Loopback, 0);
+        listener.Start();
+        var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+        listener.Stop();
+        var configuration = Path.Combine(root ?? GrammarAssets.DirectoryPath, "server-" + Guid.NewGuid().ToString("N") + ".properties");
+        var start = new ProcessStartInfo(GrammarAssets.JavaExecutable(root))
+        {
+            WorkingDirectory = Path.GetDirectoryName(GrammarAssets.ToolJar(root))!,
+            UseShellExecute = false, CreateNoWindow = true, RedirectStandardOutput = true, RedirectStandardError = true,
+        };
+        foreach (var argument in new[]
+        {
+            "-Xms64m", "-Xmx768m", "-cp", GrammarAssets.ToolJar(root),
+            "org.languagetool.server.HTTPServer", "--config", configuration, "--port", port.ToString(System.Globalization.CultureInfo.InvariantCulture),
+        }) start.ArgumentList.Add(argument);
+        // Do not inherit machine-wide options capable of changing the downloaded runtime's command.
+        foreach (var variable in new[] { "JAVA_TOOL_OPTIONS", "_JAVA_OPTIONS", "JDK_JAVA_OPTIONS", "CLASSPATH" })
+            start.Environment.Remove(variable);
+        Process process;
+        try
+        {
+            await File.WriteAllTextAsync(configuration,
+                "maxTextLength=20000\nmaxCheckTimeMillis=10000\nmaxCheckThreads=2\ncacheSize=500\npipelineCaching=true\nmaxPipelinePoolSize=2\n", token);
+            token.ThrowIfCancellationRequested();
+            process = Process.Start(start) ?? throw new IOException("Could not start the downloaded portable Java.");
+        }
+        catch
+        {
+            File.Delete(configuration);
+            throw;
+        }
+        var runtime = new GrammarRuntime(process, $"http://127.0.0.1:{port}/", configuration);
+        try
+        {
+            progress.Report("Starting local LanguageTool pt-PT on CPU...");
+            using var timeout = CancellationTokenSource.CreateLinkedTokenSource(token);
+            timeout.CancelAfter(TimeSpan.FromSeconds(90));
+            using var http = new HttpClient(new HttpClientHandler { UseProxy = false, AllowAutoRedirect = false })
+            { Timeout = TimeSpan.FromSeconds(2) };
+            while (true)
+            {
+                timeout.Token.ThrowIfCancellationRequested();
+                if (process.HasExited)
+                {
+                    await Task.WhenAll(runtime._stdout, runtime._stderr);
+                    throw new IOException("Local LanguageTool exited during startup:\n" + runtime.Tail());
+                }
+                try
+                {
+                    using var response = await http.GetAsync(runtime.Server + "v2/languages", timeout.Token);
+                    response.EnsureSuccessStatusCode();
+                    break;
+                }
+                catch (HttpRequestException) { }
+                catch (OperationCanceledException) when (!timeout.IsCancellationRequested) { }
+                await Task.Delay(200, timeout.Token);
+            }
+            using var client = new LanguageToolClient(runtime.Server);
+            var findings = await client.CheckAsync("Eles tem razão.", timeout.Token);
+            if (!findings.Any(m => m.Replacements.Any(r => r.Contains("têm", StringComparison.Ordinal))))
+                throw new InvalidDataException("Local LanguageTool did not pass its European Portuguese agreement self-test.");
+            progress.Report("Local LanguageTool pt-PT ready (CPU, no generative model).");
+            return runtime;
+        }
+        catch (OperationCanceledException ex) when (!token.IsCancellationRequested)
+        {
+            await runtime.DisposeAsync();
+            throw new IOException("Local LanguageTool startup timed out after 90 seconds.", ex);
+        }
+        catch
+        {
+            await runtime.DisposeAsync();
+            throw;
+        }
+    }
+
+    internal static void KillAll()
+    {
+        foreach (var process in Running.Keys)
+            Stop(process);
+    }
+
+    private static void Stop(Process process)
+    {
+        try { if (!process.HasExited) process.Kill(entireProcessTree: true); }
+        catch (InvalidOperationException) { /* Already stopped. */ }
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        try
+        {
+            Stop(_process);
+            await _process.WaitForExitAsync();
+            await Task.WhenAll(_stdout, _stderr);
+        }
+        finally
+        {
+            Running.TryRemove(_process, out _);
+            _process.Dispose();
+            File.Delete(_configuration);
+        }
+    }
+}
diff --git a/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs b/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs
index 9d7a9681..4701b643 100644
--- a/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs
+++ b/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs
@@ -231,7 +231,9 @@ void Note(int index, string note)
 
         if (options is { GrammarCheck: true } && options.RuleEnabled("languagetool"))
         {
-            using var client = new LanguageToolClient(options.GrammarServer);
+            await using var grammarRuntime = options.GrammarExternalServer ? null :
+                await GrammarRuntime.StartAsync(progress, token);
+            using var client = new LanguageToolClient(grammarRuntime?.Server ?? options.GrammarServer);
             EmbeddingRuntime? runtime = null;
             try
             {
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
index 9628a7d6..a88568d8 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
@@ -8,6 +8,7 @@
         Title="Brazilian to European Portuguese"
         Width="1120" Height="760"
         MinWidth="1000" MinHeight="560"
+        SizeChanged="OnWindowSizeChanged"
         WindowStartupLocation="CenterScreen">
     <DockPanel Margin="20">
 
@@ -113,7 +114,26 @@
                   ToolTip.Tip="Ask once per unresolved name when a supported rule needs an article. Batch convert never asks."
                   Margin="0,0,0,8" />
 
-        <Grid DockPanel.Dock="Top" x:Name="ReviewLayoutPanels" ColumnDefinitions="340,*" Margin="0,0,0,8">
+        <WrapPanel Margin="0,0,0,8">
+            <TextBlock Text="Orthography:" VerticalAlignment="Center" Margin="0,0,8,0" />
+            <ComboBox x:Name="OrthographyChoice" SelectedIndex="0" Margin="0,0,12,0"
+                      SelectionChanged="OnOrthographyChanged">
+                <ComboBoxItem Content="Post-1990 agreement (AO90)" />
+                <ComboBoxItem Content="Pre-1990 agreement" />
+            </ComboBox>
+            <CheckBox x:Name="ValidateSpellingCheck" Content="Validate spelling"
+                      IsCheckedChanged="OnOptionChanged"
+                      ToolTip.Tip="Flag words not recognised by the selected Natura dictionary; never auto-correct them." />
+            <Button x:Name="DictionaryCheckButton" Content="Check dictionary updates"
+                    Click="OnCheckDictionary" Margin="8,0,8,0" />
+            <Button x:Name="DictionaryDownloadButton" Content="Re-download dictionary"
+                    Click="OnDownloadDictionary" />
+        </WrapPanel>
+        <ScrollViewer MaxHeight="80" Margin="0,0,0,8">
+            <TextBlock x:Name="DictionaryStatus" TextWrapping="Wrap" Opacity="0.75"
+                       Text="Natura dictionaries available offline (2025-10-01)." />
+        </ScrollViewer>
+        <Grid DockPanel.Dock="Top" x:Name="ReviewLayoutPanels" ColumnDefinitions="230,*,*" Margin="0,0,0,8">
         <Expander Grid.Column="0" x:Name="ReviewTools" Header="Review tools"
                   HorizontalAlignment="Stretch" VerticalAlignment="Top" Margin="0,0,12,0">
             <StackPanel Spacing="6">
@@ -128,8 +148,12 @@
                            TextWrapping="Wrap" Opacity="0.7" />
             </StackPanel>
         </Expander>
-        <Expander Grid.Column="1" x:Name="LayoutTools" Header="Dialogue context and subtitle layout"
-                  HorizontalAlignment="Stretch" VerticalAlignment="Top">
+        <Expander Grid.Column="1" x:Name="LayoutTools"
+                  HorizontalAlignment="Stretch" VerticalAlignment="Top" Margin="0,0,12,0">
+            <Expander.Header>
+                <TextBlock Text="Dialogue context and subtitle layout" TextWrapping="Wrap" />
+            </Expander.Header>
+            <ScrollViewer x:Name="LayoutContent" MaxHeight="220" HorizontalScrollBarVisibility="Disabled">
             <StackPanel Spacing="6">
                 <WrapPanel>
                     <TextBlock Text="Address:" VerticalAlignment="Center" Margin="0,0,8,0" />
@@ -176,34 +200,16 @@
                 <TextBlock Text="Timings never change. An infeasible wrap is kept rather than forced; enable layout warnings to flag it."
                            TextWrapping="Wrap" Opacity="0.7" />
             </StackPanel>
+            </ScrollViewer>
         </Expander>
-        </Grid>
 
-        <WrapPanel DockPanel.Dock="Top" Margin="0,0,0,8">
-            <TextBlock Text="Orthography:" VerticalAlignment="Center" Margin="0,0,8,0" />
-            <ComboBox x:Name="OrthographyChoice" SelectedIndex="0" Margin="0,0,12,0"
-                      SelectionChanged="OnOrthographyChanged">
-                <ComboBoxItem Content="Post-1990 agreement (AO90)" />
-                <ComboBoxItem Content="Pre-1990 agreement" />
-            </ComboBox>
-            <CheckBox x:Name="ValidateSpellingCheck" Content="Validate spelling"
-                      IsCheckedChanged="OnOptionChanged"
-                      ToolTip.Tip="Flag words not recognised by the selected Natura dictionary; never auto-correct them." />
-        </WrapPanel>
-        <WrapPanel DockPanel.Dock="Top" Margin="0,0,0,8">
-            <Button x:Name="DictionaryCheckButton" Content="Check dictionary updates"
-                    Click="OnCheckDictionary" Margin="0,0,8,0" />
-            <Button x:Name="DictionaryDownloadButton" Content="Re-download dictionary"
-                    Click="OnDownloadDictionary" />
-        </WrapPanel>
-        <ScrollViewer DockPanel.Dock="Top" MaxHeight="80" Margin="0,0,0,8">
-            <TextBlock x:Name="DictionaryStatus" TextWrapping="Wrap" Opacity="0.75"
-                       Text="Natura dictionaries available offline (2025-10-01)." />
-        </ScrollViewer>
-
-        <Expander DockPanel.Dock="Top" x:Name="ReferencePanel" Header="Reference subtitle and local models (optional)"
-                  HorizontalAlignment="Stretch" Margin="0,0,0,8"
+        <Expander Grid.Column="2" x:Name="ReferencePanel"
+                  HorizontalAlignment="Stretch" VerticalAlignment="Top"
                   ToolTip.Tip="An English subtitle of the same episode, found automatically when it is named like the subtitle or video with .en/.eng/.english. It prevents wrong changes (his/her → keeps 'o seu/a sua') and marks you/your lines that kept você/seu for review; it never adds text.">
+            <Expander.Header>
+                <TextBlock Text="Reference subtitle and local models (optional)" TextWrapping="Wrap" />
+            </Expander.Header>
+            <ScrollViewer x:Name="ReferenceContent" MaxHeight="220" HorizontalScrollBarVisibility="Disabled">
             <StackPanel Spacing="6">
                 <CheckBox x:Name="BatchReferenceCheck" IsVisible="False" IsChecked="True"
                           Content="Use the English subtitle next to each file"
@@ -232,15 +238,29 @@
                     <Button x:Name="ReferenceCancelButton" Content="Stop" Click="OnCancelReference" IsEnabled="False" Margin="0,0,8,4" />
                 </WrapPanel>
                 <TextBlock Text="Extra checks (local, after the rules)" FontWeight="SemiBold" Margin="0,4,0,0" />
-                <CheckBox x:Name="GrammarCheck" Content="LanguageTool pt-PT (self-hosted, off by default)"
+                <CheckBox x:Name="GrammarCheck"
+                          IsCheckedChanged="OnGrammarSettingChanged">
+                    <TextBlock Text="LanguageTool pt-PT (local grammar checker)" TextWrapping="Wrap" />
+                </CheckBox>
+                <WrapPanel>
+                    <Button x:Name="DownloadGrammarButton" Content="Download LanguageTool pt-PT (240 MB)"
+                            Click="OnDownloadGrammar" Margin="0,0,8,4"
+                            ToolTip.Tip="LanguageTool 6.6, LGPL-2.1-or-later; official archive, SHA-256 verified. Includes Portuguese grammar rules. Not a generative model." />
+                    <Button x:Name="DownloadJavaButton" Content="Download portable Java (40–50 MB)"
+                            Click="OnDownloadJava" Margin="0,0,8,4"
+                            ToolTip.Tip="Eclipse Temurin JRE 21.0.13+9, GPLv2 with Classpath Exception; pinned and SHA-256 verified. Plugin-private, no system installation." />
+                </WrapPanel>
+                <CheckBox x:Name="GrammarExternalServer" Content="Use my own server instead (advanced)"
                           IsCheckedChanged="OnGrammarSettingChanged" />
                 <TextBox x:Name="GrammarServer" Watermark="http://127.0.0.1:8081/"
                          TextChanged="OnGrammarServerChanged"
                          ToolTip.Tip="Your self-hosted server URL. Text is sent to this server only. No automatic installation, cloud API or redirects." />
-                <CheckBox x:Name="GrammarAutoFix" Content="Allow tested agreement fixes (requires English and MiniLM)"
+                <CheckBox x:Name="GrammarAutoFix"
                           IsCheckedChanged="OnGrammarSettingChanged"
-                          ToolTip.Tip="Off: suggestions only. On: only explicit ele/ela/eles/elas + tem/têm/vem/vêm, after English subject, meaning and grammar rechecks. Other findings remain review notes." />
-                <TextBlock Text="LanguageTool suggestions are review notes unless an allowlisted fix passes every safeguard. No text generation. Use Run checks after changing settings."
+                          ToolTip.Tip="Off: suggestions only. On: only explicit ele/ela/eles/elas + tem/têm/vem/vêm, after English subject, meaning and grammar rechecks. Other findings remain review notes.">
+                    <TextBlock Text="Allow tested agreement fixes (requires English and MiniLM)" TextWrapping="Wrap" />
+                </CheckBox>
+                <TextBlock Text="Download both components once; Run checks starts and stops the local checker automatically. CPU only; no text generation. Suggestions stay review-only unless all automatic-fix safeguards pass."
                            TextWrapping="Wrap" Opacity="0.7" />
                 <WrapPanel>
                     <CheckBox x:Name="MeaningCheck" Content="Flag meaning changes (MiniLM)" Margin="0,0,16,0"
@@ -260,7 +280,9 @@
                 <TextBlock x:Name="ReferenceStatus" TextWrapping="Wrap" Opacity="0.75"
                            Text="No reference. Pick the English subtitle of the same release to protect 'o seu/a sua' when the English says his/her/their." />
             </StackPanel>
+            </ScrollViewer>
         </Expander>
+        </Grid>
         </StackPanel>
 
         <TextBlock DockPanel.Dock="Top"
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
index fed65a1e..fe32c403 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
@@ -64,6 +64,7 @@ public partial class MainWindow : Window
     private CheckBox _judgeCheck = null!;
     private CheckBox _grammarCheck = null!;
     private CheckBox _grammarAutoFix = null!;
+    private CheckBox _grammarExternalServer = null!;
     private TextBox _grammarServer = null!;
     private string _lastGrammarServer = "";
     private readonly List<CheckLine> _checkLines = new();
@@ -137,12 +138,14 @@ internal MainWindow(PluginRequest request, string wordListPath)
         _askNameArticlesCheck.IsChecked == true,
         _grammarCheck.IsChecked == true,
         _grammarAutoFix.IsChecked == true,
-        _grammarServer.Text ?? "");
+        _grammarServer.Text ?? "",
+        _grammarExternalServer.IsChecked == true);
 
     private bool SettingsChanged => _nameArticles != _initialOptions.NameArticles ||
         (_askNameArticlesCheck.IsChecked == true) != _initialOptions.AskNameArticles ||
         Options.GrammarCheck != _initialOptions.GrammarCheck ||
         Options.GrammarAutoFix != _initialOptions.GrammarAutoFix ||
+        Options.GrammarExternalServer != _initialOptions.GrammarExternalServer ||
         Options.GrammarServer != _initialOptions.GrammarServer;
 
     private ConversionOptions SavedOptions => Options with { DisabledRules = _savedDisabledRules };
@@ -176,6 +179,8 @@ private void LoadOptions(ConversionOptions options)
         _grammarCheck.IsChecked = options.GrammarCheck;
         _grammarAutoFix.IsChecked = options.GrammarAutoFix;
         _grammarServer.Text = options.GrammarServer;
+        _grammarExternalServer.IsChecked = options.GrammarExternalServer;
+        _grammarServer.IsVisible = options.GrammarExternalServer;
         _lastGrammarServer = options.GrammarServer;
         _loadingOptions = false;
 
@@ -196,7 +201,12 @@ private void OnOptionChanged(object? sender, RoutedEventArgs e)
         }
     }
 
-    private void OnGrammarSettingChanged(object? sender, RoutedEventArgs e) => OnOptionChanged(sender, e);
+    private void OnGrammarSettingChanged(object? sender, RoutedEventArgs e)
+    {
+        if (_grammarServer != null && _grammarExternalServer != null)
+            _grammarServer.IsVisible = _grammarExternalServer.IsChecked == true;
+        OnOptionChanged(sender, e);
+    }
 
     private void OnGrammarServerChanged(object? sender, TextChangedEventArgs e)
     {
@@ -211,6 +221,13 @@ private void OnOrthographyChanged(object? sender, SelectionChangedEventArgs e) =
 
     private void OnLayoutChanged(object? sender, NumericUpDownValueChangedEventArgs e) => OnOptionChanged(sender, e);
 
+    private void OnWindowSizeChanged(object? sender, SizeChangedEventArgs e)
+    {
+        var height = Math.Clamp(e.NewSize.Height * 0.28, 140, 360);
+        foreach (var name in new[] { "LayoutContent", "ReferenceContent" })
+            if (this.FindControl<ScrollViewer>(name) is { } content) content.MaxHeight = height;
+    }
+
     private void OnToggleSettings(object? sender, RoutedEventArgs e)
     {
         var panel = this.FindControl<StackPanel>("SettingsPanel")!;
@@ -417,6 +434,7 @@ private void InitializeComponent()
         _judgeCheck = this.FindControl<CheckBox>("JudgeCheck")!;
         _grammarCheck = this.FindControl<CheckBox>("GrammarCheck")!;
         _grammarAutoFix = this.FindControl<CheckBox>("GrammarAutoFix")!;
+        _grammarExternalServer = this.FindControl<CheckBox>("GrammarExternalServer")!;
         _grammarServer = this.FindControl<TextBox>("GrammarServer")!;
         _addressChoice = this.FindControl<ComboBox>("AddressChoice")!;
         _sentenceContextCheck = this.FindControl<CheckBox>("SentenceContextCheck")!;
@@ -434,6 +452,7 @@ private void InitializeComponent()
             this.FindControl<Button>("DownloadJudgeButton")!, this.FindControl<Button>("RunChecksButton")!,
             _embeddingCheck, _vulkanCheck, _deviceChoice, _meaningCheck, _judgeCheck,
             _grammarCheck, _grammarAutoFix, _grammarServer,
+            _grammarExternalServer, this.FindControl<Button>("DownloadGrammarButton")!, this.FindControl<Button>("DownloadJavaButton")!,
             _askNameArticlesCheck, this.FindControl<Button>("EditNameArticlesButton")!,
             this.FindControl<Button>("ContributeVocabularyButton")!,
             this.FindControl<Button>("DisableRuleButton")!, this.FindControl<Button>("RestoreRulesButton")!,
@@ -902,6 +921,26 @@ await DownloadAsset(async (progress, token) =>
             return "llama-server downloaded and verified (SHA-256). Use List devices to pick the GPU.";
         });
 
+    private async void OnDownloadGrammar(object? sender, RoutedEventArgs e) =>
+        await DownloadGrammarAsset(false);
+
+    private async void OnDownloadJava(object? sender, RoutedEventArgs e) =>
+        await DownloadGrammarAsset(true);
+
+    private async Task DownloadGrammarAsset(bool java)
+    {
+        await RunReferenceJob(async (progress, token) =>
+        {
+            if (java) await GrammarAssets.DownloadJavaAsync(progress, token);
+            else await GrammarAssets.DownloadToolAsync(progress, token);
+            _referenceStatus.Text = GrammarAssets.IsInstalled()
+                ? "Local LanguageTool pt-PT is installed. Enable LanguageTool and choose Run checks; startup and shutdown are automatic."
+                : java ? "Portable Java installed and verified. Now download LanguageTool pt-PT."
+                : "LanguageTool installed and verified. Now download portable Java.";
+        });
+        UpdateAssetStatus();
+    }
+
     /// <summary>Downloads one asset; once both are installed, MiniLM is switched on and the reference re-aligned.</summary>
     private async Task DownloadAsset(Func<IProgress<string>, CancellationToken, Task<string>> download)
     {
@@ -930,7 +969,9 @@ private void UpdateAssetStatus()
         var settings = EmbeddingAssets.WithInstalledFiles(_embeddingSettings);
         string Describe(string name, string path) => File.Exists(path) ? $"{name}: {path}" : $"{name}: not downloaded";
         _assetStatus.Text = Describe("Model", settings.ModelPath) + "\n" + Describe("llama-server", settings.RuntimePath) + "\n" +
-                            Describe("Gervásio", settings.JudgeModelPath);
+                            Describe("Gervásio", settings.JudgeModelPath) + "\n" +
+                            Describe("LanguageTool pt-PT", GrammarAssets.ToolJar()) + "\n" +
+                            Describe("Portable Java", GrammarAssets.JavaExecutable());
     }
 
     private async void OnDownloadJudge(object? sender, RoutedEventArgs e)
@@ -958,6 +999,7 @@ protected override void OnClosed(EventArgs e)
         _closed = true;
         _referenceCancel?.Cancel();
         EmbeddingRuntime.KillAll();
+        GrammarRuntime.KillAll();
         base.OnClosed(e);
     }
 
@@ -971,7 +1013,7 @@ private void OnApply(object? sender, RoutedEventArgs e)
     {
         try
         {
-            _ = LanguageToolClient.CheckUri(Options.GrammarServer);
+            if (Options.GrammarExternalServer) _ = LanguageToolClient.CheckUri(Options.GrammarServer);
         }
         catch (InvalidDataException ex)
         {
diff --git a/se5/BrazilianToEuropeanPortuguese/README.md b/se5/BrazilianToEuropeanPortuguese/README.md
index b5d59d43..b314f9b7 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.md
@@ -4,9 +4,12 @@
 
 ## Latest changes
 
-- Experimental, **off-by-default self-hosted LanguageTool pt-PT checks**, with
+- Experimental, **off-by-default local LanguageTool pt-PT checks**, with
   review suggestions and a narrowly allowlisted, English/MiniLM-guarded agreement pass.
-  No generative model or automatic Java/LanguageTool installation is added.
+  Download the checker and its private portable Java from the plugin; no
+  generative model, system Java installation or manually configured server is needed.
+- Reference/local-model controls now sit **to the right of dialogue/layout**,
+  with scrollable contents so expanded settings do not consume the whole preview.
 - One **Contribute vocabulary / Local word list** window with three separate tabs.
 - Contribution CSVs for words and expressions, with optional examples and context;
   suggestions do not change conversion rules or upload automatically.
@@ -21,7 +24,7 @@ Earlier updates include reviewed workbook vocabulary and verb constructions,
 English-confirmed sportswear and shared-residence expressions, physical descriptions,
 finding filters, and original PT-BR text visible on warning-only rows.
 
-The experimental standalone source build is **1.8.0**. The pre-LanguageTool
+The experimental standalone source build is **1.8.1**. The pre-LanguageTool
 rollback baseline is [v1.7.0](https://github.com/SMAP-git/BrazilianToEuropeanPortuguese/tree/v1.7.0).
 Official Subtitle Edit package versions
 are assigned by the upstream release workflow and may differ.
@@ -31,20 +34,40 @@ objects and vocabulary senses, natural dialogue constructions and interrogative
 accentuation. It adds regression coverage for these interactions while preserving
 subtitle cue timings and user-controlled rule options.
 
-### Optional self-hosted grammar checking (experimental)
-
-In the English reference / extra-checks panel, enable **LanguageTool pt-PT
-(self-hosted, off by default)** and enter the URL of a LanguageTool server you
-manage, for example `http://127.0.0.1:8081/`. Then choose **Run checks**. Saved
-settings also apply in **Batch convert**. Nothing is downloaded or started:
-LanguageTool and its Java runtime are managed separately. See the
-[official self-hosted server guide](https://dev.languagetool.org/http-server).
+### Optional local grammar checking (experimental)
+
+LanguageTool is the grammar checker; its Portuguese rules include **European
+Portuguese (`pt-PT`)**. You do not need to choose or download a separate grammar
+model. In the **Reference subtitle and local models** panel, now to the right of
+**Dialogue context and subtitle layout**:
+
+1. Click **Download LanguageTool pt-PT (240 MB)**.
+2. Click **Download portable Java (40–50 MB)**.
+3. Enable **LanguageTool pt-PT (local grammar checker)** and choose **Run checks**.
+
+Both downloads are explicit, pinned and SHA-256 verified. LanguageTool **6.6**
+comes from its official download site (LGPL-2.1-or-later); the private Eclipse
+Temurin **JRE 21.0.13+9** comes from Adoptium's GitHub releases (GPLv2 with
+Classpath Exception). Licences remain in the extracted distributions. The Java
+download never installs system Java or changes `PATH`. Windows ARM64 uses the
+x64 JRE through Windows emulation; Linux/macOS have native x64/ARM64 packages.
+Only Linux x64 has been exercised with the real downloaded runtime here.
+
+The plugin stores them under its local application-data
+`SubtitleEdit/BrazilianToEuropeanPortuguese/GrammarChecker` folder. This is inside
+the app's data area in Flatpak; container installations should persist that data
+folder. It starts the checker on a private loopback port automatically for each
+run, verifies pt-PT grammar checking, and stops its owned process afterwards,
+including on cancellation or window closure. No separate terminal, fixed port
+8081, Docker service or GPU is required. After downloading, checking is offline.
 The local distribution does not include LanguageTool's cloud-only AI rules.
 
-For Docker, `127.0.0.1` means the Subtitle Edit container itself. A separate
-LanguageTool container can instead use its service name and configured port,
-for example `http://languagetool:8010/`, on a private shared network. The plugin
-does not create containers or modify network settings.
+The optional **Use my own server instead (advanced)** switch reveals the server
+URL for existing self-hosted installations and bypasses managed startup. In
+Docker, `127.0.0.1` means the Subtitle Edit container; a separate service can use,
+for example, `http://languagetool:8010/` on a private shared network. No containers
+or network settings are changed. See the
+[official server guide](https://dev.languagetool.org/http-server).
 
 The pipeline is:
 
@@ -81,9 +104,9 @@ and custom output vocabulary are masked with equal-length spaces for checking;
 masked groups are never automatically rewritten. Pre-1990 spelling settings
 are not overridden by LanguageTool suggestions.
 
-The plugin sends masked converted Portuguese only to the configured server;
-English and original Portuguese are not sent to LanguageTool. Use a server you
-trust: self-hosted does not necessarily mean it runs on this computer. Public
+The plugin sends masked converted Portuguese only to the owned loopback server
+by default; English and original Portuguese are not sent to LanguageTool.
+If you explicitly choose an external server, use one you trust. Public
 LanguageTool cloud endpoints, embedded credentials and HTTP redirects are not
 supported. Protect any remote server/network yourself.
 
@@ -92,9 +115,11 @@ are cached only for the current run. Invalid, non-pt-PT or incomplete responses
 fail explicitly. Preview keeps the preceding result and displays the failure;
 batch reports the failure and retains rule-only output, without applying
 partial optional-check results. Batch counts findings; open the preview to see
-their details. No real LanguageTool server is bundled with the tests: protocol
-and safety tests use controlled responses. Actual rule coverage, false-positive
-rates and speed depend on your server and still require corpus benchmarking.
+their details. Protocol and safety tests use controlled responses; the optional
+`PTPT_TEST_GRAMMAR=1` test installs and runs the actual pinned checker and Java,
+checks real pt-PT diagnostics, and verifies shutdown. Its candidate meaning gate
+uses deterministic vectors, not real MiniLM inference. Broader rule coverage,
+false-positive rates and subtitle-corpus speed still require benchmarking.
 
 **Undo / rollback:** disabling **LanguageTool pt-PT** clears its preview results
 and restores the existing conversion pipeline; untick **Allow tested agreement
diff --git a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
index 814d990d..4e372b83 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
@@ -6,10 +6,13 @@ Português europeu | [English](README.md)
 
 ## Alterações mais recentes
 
-- Verificação experimental com **LanguageTool pt-PT autoalojado, desativada por
+- Verificação experimental com **LanguageTool pt-PT local, desativada por
   predefinição**, com sugestões para revisão e correções de concordância muito
   delimitadas, protegidas pela referência inglesa e pelo MiniLM. Sem geração de
-  texto nem instalação automática de Java ou do LanguageTool.
+  texto. O verificador e o Java portátil são descarregados pelo próprio plugin,
+  sem instalar Java no sistema nem configurar um servidor manualmente.
+- O painel de referência/modelos locais fica **à direita do diálogo/disposição**,
+  com conteúdo deslocável para deixar espaço para a pré-visualização.
 - Uma janela **Contribute vocabulary / Local word list** com três separadores distintos.
 - CSV de contribuições para palavras e expressões, com exemplos e contexto opcionais;
   as sugestões não alteram as regras de conversão nem são enviadas automaticamente.
@@ -26,7 +29,7 @@ partir de folhas de cálculo, vestuário desportivo e expressões de residência
 confirmados pelo inglês, descrições físicas, filtros de resultados e o texto
 original em PT-BR visível nas linhas que contêm apenas avisos.
 
-A compilação experimental do repositório autónomo é a **1.8.0**. A base anterior
+A compilação experimental do repositório autónomo é a **1.8.1**. A base anterior
 ao LanguageTool está guardada em
 [v1.7.0](https://github.com/SMAP-git/BrazilianToEuropeanPortuguese/tree/v1.7.0).
 As versões oficiais dos
@@ -39,20 +42,40 @@ construções naturais de diálogo e a acentuação interrogativa. Acrescenta te
 de regressão destas interações, preservando os tempos das legendas e as opções
 de regras controladas pelo utilizador.
 
-### Verificação gramatical autoalojada (experimental e opcional)
-
-No painel da referência inglesa e verificações adicionais, ative **LanguageTool
-pt-PT (self-hosted, off by default)**, introduza o endereço de um servidor que
-controle, por exemplo `http://127.0.0.1:8081/`, e escolha **Run checks**. As opções
-guardadas também se aplicam a **Batch convert**. O plugin não instala nem inicia
-Java ou o LanguageTool. Consulte o
-[guia oficial do servidor](https://dev.languagetool.org/http-server).
+### Verificação gramatical local (experimental e opcional)
+
+O LanguageTool é o verificador gramatical e já inclui regras de **português
+europeu (`pt-PT`)**. Não precisa de escolher um modelo gramatical separado.
+No painel **Reference subtitle and local models**, agora à direita de
+**Dialogue context and subtitle layout**:
+
+1. Clique em **Download LanguageTool pt-PT (240 MB)**.
+2. Clique em **Download portable Java (40–50 MB)**.
+3. Ative **LanguageTool pt-PT (local grammar checker)** e escolha **Run checks**.
+
+As transferências são explícitas, de versões fixadas e verificadas por SHA-256.
+O LanguageTool **6.6** vem do sítio oficial (LGPL-2.1-ou-posterior); o Eclipse
+Temurin **JRE 21.0.13+9** vem dos lançamentos da Adoptium no GitHub (GPLv2 com
+Classpath Exception). As licenças permanecem nas distribuições extraídas.
+O Java é privado do plugin: não é instalado no sistema nem altera o `PATH`.
+No Windows ARM64, utiliza-se o JRE x64 por emulação; Linux/macOS têm pacotes
+nativos x64/ARM64. O ensaio real feito aqui abrange apenas Linux x64.
+
+Os componentes ficam na pasta de dados local
+`SubtitleEdit/BrazilianToEuropeanPortuguese/GrammarChecker`, dentro dos dados da
+aplicação no caso de Flatpak. Em contentores, deve persistir essa pasta de dados.
+O plugin inicia automaticamente o verificador numa porta privada de loopback,
+confirma a verificação pt-PT e termina o processo que iniciou no fim, também ao
+cancelar ou fechar a janela. Não é necessário terminal, porta fixa 8081,
+servidor Docker separado ou GPU. Depois das transferências, funciona sem rede.
 A distribuição local não inclui as regras de IA exclusivas da nuvem.
 
-Em Docker, `127.0.0.1` identifica o próprio contentor do Subtitle Edit. Para um
-servidor noutro contentor da mesma rede privada, pode usar o nome do serviço e
-a porta configurada, por exemplo `http://languagetool:8010/`. O plugin não cria
-contentores nem altera a rede.
+A opção **Use my own server instead (advanced)** revela o endereço para quem já
+tem um servidor próprio e dispensa o arranque local. Em Docker, `127.0.0.1`
+identifica o próprio contentor; outro serviço da rede privada pode usar,
+por exemplo, `http://languagetool:8010/`. O plugin não cria contentores nem altera
+a rede. Consulte o [guia oficial](https://dev.languagetool.org/http-server).
+As opções guardadas também se aplicam a **Batch convert**.
 
 A ordem de processamento é:
 
@@ -90,10 +113,10 @@ por espaços com o mesmo comprimento durante a consulta; grupos com estas
 proteções nunca são reescritos automaticamente. A opção pré-Acordo não é
 substituída por sugestões do LanguageTool.
 
-Só o português convertido e protegido é enviado ao servidor configurado.
-O inglês e o português original não são enviados ao LanguageTool. Utilize um
-servidor de confiança: autoalojado não significa necessariamente local neste
-computador. Não são suportados os serviços públicos do LanguageTool, credenciais
+Por predefinição, só o português convertido e protegido é enviado ao processo
+local de loopback. O inglês e o português original não são enviados ao
+LanguageTool. Se escolher explicitamente outro servidor, utilize um de
+confiança. Não são suportados os serviços públicos do LanguageTool, credenciais
 no endereço ou redirecionamentos HTTP. Proteja o servidor e a rede.
 
 Cada pedido tem um limite de 15 segundos e uma resposta de tamanho limitado.
@@ -102,9 +125,12 @@ inválidas, incompletas ou que não sejam pt-PT provocam um erro explícito.
 A pré-visualização mantém o resultado anterior e mostra o erro; o processamento
 em lote comunica a falha e conserva a saída das regras, sem aplicar resultados
 parciais das verificações opcionais. Em lote, as ocorrências são contadas; abra
-a pré-visualização para consultar os pormenores. Os testes usam respostas
-controladas, não um servidor real incluído: cobertura efetiva, falsos positivos
-e desempenho ainda precisam de avaliação com o seu servidor e as legendas.
+a pré-visualização para consultar os pormenores. Os testes de protocolo usam
+respostas controladas; o teste opcional `PTPT_TEST_GRAMMAR=1` instala e executa
+as distribuições reais fixadas, verifica diagnósticos pt-PT e confirma o fim do
+processo. A proteção de significado nesse teste usa vetores determinísticos,
+não inferência real do MiniLM. A cobertura alargada, os falsos positivos e o
+desempenho com legendas completas ainda precisam de avaliação.
 
 **Desfazer / voltar atrás:** desativar **LanguageTool pt-PT** limpa os resultados
 da pré-visualização e repõe o processamento existente. Desativar apenas
diff --git a/se5/BrazilianToEuropeanPortuguese/plugin.json b/se5/BrazilianToEuropeanPortuguese/plugin.json
index 5a69cebb..794edf87 100644
--- a/se5/BrazilianToEuropeanPortuguese/plugin.json
+++ b/se5/BrazilianToEuropeanPortuguese/plugin.json
@@ -2,7 +2,7 @@
   "apiVersion": 1,
   "name": "Brazilian to European Portuguese",
   "description": "Converts Brazilian Portuguese (pt-BR) to European Portuguese (pt-PT), with complement-aware vocabulary, personal infinitives, guarded clause agreement and idioms, optional conversational style, dialogue controls and grammar review. Shows a checkable preview of changes and their rule stages.",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "author": "Subtitle Edit",
   "url": "https://github.com/SubtitleEdit/plugins/tree/main/se5/BrazilianToEuropeanPortuguese",
   "menu": "Tools",

From 2e9b613eb604c543f23de8e72bd3a530ee1e1ebe Mon Sep 17 00:00:00 2001
From: SMAP-git <333812182+SMAP-git@users.noreply.github.com>
Date: Wed, 11 Nov 2026 15:14:44 +0100
Subject: [PATCH 3/7] Add saved LanguageTool alert groups and individual rule
 selection

Add a grammar-only preset and per-rule exclusions for spelling, dialogue typography, style and other findings. Persist selections for preview and batch, filter rechecks consistently, and send explicit rule exclusions to LanguageTool. Include native dialog, settings and protocol regression tests; update experimental version to 1.8.2.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../GrammarChecksTests.cs                     | 104 ++++++++++++++-
 .../ReferenceTests.cs                         |  51 +++++++
 .../ConversionOptions.cs                      |  18 ++-
 .../GrammarChecks.cs                          |   6 +-
 .../GrammarRuleSelection.cs                   |  45 +++++++
 .../GrammarRulesWindow.cs                     | 124 ++++++++++++++++++
 .../LanguageToolClient.cs                     |  26 +++-
 .../LocalChecks.cs                            |   3 +-
 .../MainWindow.axaml                          |   3 +
 .../MainWindow.axaml.cs                       |  28 +++-
 se5/BrazilianToEuropeanPortuguese/README.md   |  16 ++-
 .../README.pt-PT.md                           |  16 ++-
 se5/BrazilianToEuropeanPortuguese/plugin.json |   2 +-
 13 files changed, 424 insertions(+), 18 deletions(-)
 create mode 100644 se5/BrazilianToEuropeanPortuguese/GrammarRuleSelection.cs
 create mode 100644 se5/BrazilianToEuropeanPortuguese/GrammarRulesWindow.cs

diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs
index 0e84936c..afcc1d13 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/GrammarChecksTests.cs
@@ -59,6 +59,75 @@ public async Task ReviewModeNeverEmbedsOrChangesText()
         Assert.Contains("0 allowlisted", result.Summary);
     }
 
+    [Theory]
+    [InlineData("misspelling", "TYPOS", "spelling")]
+    [InlineData("typographical", "PUNCTUATION", "typography")]
+    [InlineData("whitespace", "", "typography")]
+    [InlineData("style", "REDUNDANCY", "style")]
+    [InlineData("register", "", "style")]
+    [InlineData("grammar", "", "grammar")]
+    [InlineData("", "GRAMMAR", "grammar")]
+    [InlineData("", "", "other")]
+    [InlineData("new-server-type", "NEW_CATEGORY", "other")]
+    public async Task DisabledGroupsProduceNoAlertsOrCorrections(string issueType, string category, string group)
+    {
+        var match = Match("Eles tem razão.") with { IssueType = issueType, Category = category };
+        Assert.Equal(group, GrammarRuleSelection.Group(match));
+        var result = await Run(new[] { Line() }, Enabled with { GrammarDisabledGroups = group },
+            check: (_, _) => Task.FromResult<IReadOnlyList<GrammarMatch>>(new[] { match }),
+            embed: (_, _) => throw new Exception("Disabled checks must not embed."));
+        Assert.Empty(result.Notes);
+        Assert.Contains("0 cue(s)", result.Summary);
+        Assert.Equal("Eles tem razão.", result.Texts[0]);
+    }
+
+    [Fact]
+    public async Task IndividualExclusionsDoNotDisableOtherRules()
+    {
+        var result = await Run(new[] { Line() }, Enabled with { GrammarDisabledRules = "AGREEMENT" },
+            check: (text, _) => Task.FromResult<IReadOnlyList<GrammarMatch>>(new[]
+            {
+                Match(text), Match(text, rule: "OTHER_RULE") with { Replacements = Array.Empty<string>() },
+            }), embed: SameMeaning);
+        Assert.Equal("Eles tem razão.", result.Texts[0]);
+        Assert.Contains("[OTHER_RULE]", Assert.Single(result.Notes));
+        Assert.DoesNotContain("[AGREEMENT]", result.Notes[0]);
+    }
+
+    [Fact]
+    public async Task DisabledGroupsAlsoApplyDuringGrammarRecheck()
+    {
+        var result = await Run(new[] { Line() }, Enabled with { GrammarDisabledGroups = "style" },
+            check: (text, _) => Task.FromResult<IReadOnlyList<GrammarMatch>>(text.Contains("tem", StringComparison.Ordinal)
+                ? new[] { Match(text) with { IssueType = "grammar" } }
+                : new[] { new GrammarMatch(0, 4, "WORDINESS", "Style only.", Array.Empty<string>(), "style") }),
+            embed: SameMeaning);
+        Assert.Equal("Eles têm razão.", result.Texts[0]);
+        Assert.Contains("corrected", Assert.Single(result.Notes));
+    }
+
+    [Fact]
+    public void GrammarSelectionsRoundTripAndLegacySettingsKeepAllGroups()
+    {
+        var options = Enabled with { GrammarDisabledRules = "DASH_ENUMERATION_SPACE_RULE,MORFOLOGIK_RULE_PT_PT", GrammarDisabledGroups = "spelling,style,typography" };
+        Assert.Equal(options, ConversionOptions.Load(new PluginRequest { SettingsVersion = 1, Settings = options.ToJson() }));
+        var legacy = ConversionOptions.Load(new PluginRequest { SettingsVersion = 1, Settings = JsonSerializer.SerializeToElement(new { grammarCheck = true }) });
+        Assert.Empty(legacy.GrammarDisabledRules);
+        Assert.Empty(legacy.GrammarDisabledGroups);
+        Assert.Equal("A,B", GrammarRuleSelection.Validate("B,\nA,A"));
+        Assert.Equal(new[] { "A", "B" }, GrammarRuleSelection.ObservedIds(new[] { "LanguageTool [B]: test\nLanguageTool [A]: test", null }));
+    }
+
+    [Theory]
+    [InlineData("{\"grammarDisabledRules\":false}")]
+    [InlineData("{\"grammarDisabledRules\":\"BAD ID\"}")]
+    [InlineData("{\"grammarDisabledRules\":\"A&text=secret\"}")]
+    [InlineData("{\"grammarDisabledGroups\":\"unknown\"}")]
+    [InlineData("{\"grammarDisabledGroups\":[]}")]
+    public void InvalidGrammarSelectionsFailExplicitly(string json) =>
+        Assert.Throws<InvalidDataException>(() => ConversionOptions.Load(new PluginRequest
+        { SettingsVersion = 1, Settings = JsonSerializer.Deserialize<JsonElement>(json) }));
+
     [Fact]
     public async Task AutomaticAgreementNeedsModelAndRechecksGrammar()
     {
@@ -322,7 +391,8 @@ private static string Response(string text, params GrammarMatch[] matches) => Js
         language = new { code = "pt-PT" },
         matches = matches.Select(m => new
         {
-            offset = m.Offset, length = m.Length, message = m.Message, rule = new { id = m.Rule },
+            offset = m.Offset, length = m.Length, message = m.Message,
+            rule = new { id = m.Rule, issueType = m.IssueType, category = new { id = m.Category } },
             replacements = m.Replacements.Select(value => new { value }),
         }),
     });
@@ -333,6 +403,23 @@ protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage reques
             send(request, cancellationToken);
     }
 
+    [Fact]
+    public async Task ClientSendsRuleExclusionsAndPreservesClassification()
+    {
+        using var client = new LanguageToolClient("http://localhost:8081/", new Handler(async (request, token) =>
+        {
+            var form = Uri.UnescapeDataString(await request.Content!.ReadAsStringAsync(token));
+            Assert.Contains("disabledRules=DASH_ENUMERATION_SPACE_RULE,MORFOLOGIK_RULE_PT_PT", form);
+            return new HttpResponseMessage(HttpStatusCode.OK)
+            {
+                Content = new StringContent(Response("Eles tem razão.", Match("Eles tem razão.") with { IssueType = "grammar", Category = "GRAMMAR" })),
+            };
+        }), "MORFOLOGIK_RULE_PT_PT,DASH_ENUMERATION_SPACE_RULE");
+        var match = Assert.Single(await client.CheckAsync("Eles tem razão.", CancellationToken.None));
+        Assert.Equal("grammar", match.IssueType);
+        Assert.Equal("GRAMMAR", match.Category);
+    }
+
     [Theory]
     [InlineData("http://127.0.0.1:8081/", "http://127.0.0.1:8081/v2/check")]
     [InlineData("http://languagetool:8010/v2", "http://languagetool:8010/v2/check")]
@@ -408,8 +495,11 @@ public async Task TimeoutAndUserCancellationAreDistinct()
         await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.CheckAsync("text", cancel.Token));
     }
 
-    [Fact]
-    public async Task BatchUsesSelfHostedProtocolAndPreservesTimingsAndTextInReviewMode()
+    [Theory]
+    [InlineData("", "", 1)]
+    [InlineData("TEST", "", 0)]
+    [InlineData("", "style", 0)]
+    public async Task BatchUsesSelfHostedProtocolAndPreservesTimingsAndTextInReviewMode(string disabledRules, string disabledGroups, int findings)
     {
         using var listener = new TcpListener(IPAddress.Loopback, 0);
         listener.Start();
@@ -428,7 +518,8 @@ public async Task BatchUsesSelfHostedProtocolAndPreservesTimingsAndTextInReviewM
             var content = new char[length];
             Assert.Equal(length, await reader.ReadBlockAsync(content.AsMemory(), limit.Token));
             Assert.Contains("language=pt-PT", new string(content));
-            var body = Encoding.UTF8.GetBytes(Response("Olá, mundo.", new GrammarMatch(0, 3, "TEST", "Test suggestion.", new[] { "Bom dia" })));
+            Assert.Contains("disabledRules=" + disabledRules, new string(content));
+            var body = Encoding.UTF8.GetBytes(Response("Olá, mundo.", new GrammarMatch(0, 3, "TEST", "Test suggestion.", new[] { "Bom dia" }, "style")));
             var header = Encoding.ASCII.GetBytes($"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {body.Length}\r\nConnection: close\r\n\r\n");
             await stream.WriteAsync(header, limit.Token);
             await stream.WriteAsync(body, limit.Token);
@@ -438,14 +529,15 @@ public async Task BatchUsesSelfHostedProtocolAndPreservesTimingsAndTextInReviewM
             RequestType = PluginRequestType.Batch,
             Subtitle = new PluginSubtitle { SubRip = "1\n00:00:01,234 --> 00:00:03,456\nOlá, mundo.\n\n" },
             SettingsVersion = ConversionOptions.Version,
-            Settings = new ConversionOptions(GrammarCheck: true, GrammarServer: $"http://127.0.0.1:{port}/", GrammarExternalServer: true).ToJson(),
+            Settings = new ConversionOptions(GrammarCheck: true, GrammarServer: $"http://127.0.0.1:{port}/",
+                GrammarExternalServer: true, GrammarDisabledRules: disabledRules, GrammarDisabledGroups: disabledGroups).ToJson(),
         };
         var result = await Task.Run(() => BatchMode.BuildBatchResponse(request, Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".xml"),
             new EmbeddingSettings(CheckMeaning: false)), limit.Token);
         await server;
         Assert.Equal(PluginStatus.Ok, result.Status);
         Assert.Null(result.Subtitle);
-        Assert.Contains("1 cue(s) with findings", result.Message);
+        Assert.Contains($"{findings} cue(s) with findings", result.Message);
         Assert.Contains("0 allowlisted", result.Message);
         Assert.Equal("1\n00:00:01,234 --> 00:00:03,456\nOlá, mundo.\n\n", request.Subtitle.SubRip);
     }
diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
index 4f2fd437..e02a9180 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
@@ -495,6 +495,27 @@ public void MainWindowAppliesReferenceToProposals()
             grammarWindow.ApplyCheckResults(new[] { new CheckLine(0, "Olá.", "Olá.", null, null) },
                 new Dictionary<int, CheckResult> { [0] = new("Olá.", "LanguageTool [TEST]: review only.") });
             Assert.Contains("LanguageTool", Assert.Single(grammarWindow.Proposals).ReviewNote);
+            grammarWindow.Show();
+            grammarWindow.FindControl<Button>("GrammarRulesButton")!
+                .RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var grammarRules = Assert.IsType<GrammarRulesWindow>(Assert.Single(grammarWindow.OwnedWindows));
+            Assert.True(grammarRules.FindControl<CheckBox>("GrammarRule_TEST")!.IsChecked);
+            grammarRules.FindControl<Button>("GrammarOnlyPreset")!
+                .RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            Assert.Equal("other,spelling,style,typography", grammarRules.DisabledGroups);
+            grammarRules.FindControl<CheckBox>("GrammarRule_MORFOLOGIK_RULE_PT_PT")!.IsChecked = false;
+            grammarRules.FindControl<TextBox>("ExtraGrammarDisabledRules")!.Text = "BAD ID";
+            grammarRules.FindControl<Button>("SaveGrammarRules")!
+                .RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            Assert.Contains("Invalid LanguageTool", grammarRules.FindControl<TextBlock>("GrammarRulesError")!.Text);
+            Assert.Contains("LanguageTool", Assert.Single(grammarWindow.Proposals).ReviewNote);
+            grammarRules.FindControl<TextBox>("ExtraGrammarDisabledRules")!.Text = "";
+            grammarRules.FindControl<Button>("SaveGrammarRules")!
+                .RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            Assert.Empty(grammarWindow.Proposals);
+            Assert.Contains("Run checks again", grammarWindow.ChecksStatusText);
             grammarWindow.FindControl<CheckBox>("GrammarCheck")!.IsChecked = false;
             Assert.Empty(grammarWindow.Proposals);
             grammarWindow.FindControl<TextBox>("GrammarServer")!.Text = "http://127.0.0.1:8081/";
@@ -841,6 +862,36 @@ void LocalText(string name, string text)
             Assert.Equal("teste", Assert.Single(PortugueseLocalWordList.Load(refreshPath).Ignored));
             batchConfig.Close();
 
+            var rulesConfig = new MainWindow(new PluginRequest { RequestType = PluginRequestType.Configure }, refreshPath);
+            rulesConfig.Show();
+            rulesConfig.FindControl<Button>("GrammarRulesButton")!
+                .RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            var rulesEditor = Assert.IsType<GrammarRulesWindow>(Assert.Single(rulesConfig.OwnedWindows));
+            rulesEditor.FindControl<Button>("GrammarOnlyPreset")!
+                .RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            rulesEditor.FindControl<CheckBox>("GrammarRule_DASH_ENUMERATION_SPACE_RULE")!.IsChecked = false;
+            rulesEditor.FindControl<Button>("SaveGrammarRules")!
+                .RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            Avalonia.Threading.Dispatcher.UIThread.RunJobs();
+            rulesConfig.FindControl<Button>("ApplyButton")!
+                .RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            var rulesResponse = App.Response!;
+            var storedRules = ConversionOptions.Load(new PluginRequest
+            {
+                Settings = rulesResponse.Settings, SettingsVersion = rulesResponse.SettingsVersion,
+            });
+            Assert.Equal("DASH_ENUMERATION_SPACE_RULE", storedRules.GrammarDisabledRules);
+            Assert.Equal("other,spelling,style,typography", storedRules.GrammarDisabledGroups);
+            var rulesReload = new GrammarRulesWindow(storedRules, Array.Empty<string>());
+            Assert.False(rulesReload.FindControl<CheckBox>("GrammarGroup_style")!.IsChecked);
+            Assert.False(rulesReload.FindControl<CheckBox>("GrammarRule_DASH_ENUMERATION_SPACE_RULE")!.IsChecked);
+            rulesReload.FindControl<Button>("AllGrammarRules")!
+                .RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
+            Assert.Empty(rulesReload.DisabledRules);
+            Assert.Empty(rulesReload.DisabledGroups);
+            rulesReload.Close();
+
             var namesConfig = new MainWindow(new PluginRequest { RequestType = PluginRequestType.Configure }, refreshPath);
             namesConfig.Show();
             namesConfig.FindControl<Button>("EditNameArticlesButton")!
diff --git a/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs b/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs
index abeff422..dc6ea08a 100644
--- a/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs
+++ b/se5/BrazilianToEuropeanPortuguese/ConversionOptions.cs
@@ -30,7 +30,9 @@ public sealed record ConversionOptions(
     bool GrammarCheck = false,
     bool GrammarAutoFix = false,
     string GrammarServer = "http://127.0.0.1:8081/",
-    bool GrammarExternalServer = false)
+    bool GrammarExternalServer = false,
+    string GrammarDisabledRules = "",
+    string GrammarDisabledGroups = "")
 {
     public const int Version = 1;
 
@@ -62,6 +64,8 @@ public JsonElement ToJson() => JsonSerializer.SerializeToElement(new
         grammarAutoFix = GrammarAutoFix,
         grammarServer = GrammarServer,
         grammarExternalServer = GrammarExternalServer,
+        grammarDisabledRules = GrammarDisabledRules,
+        grammarDisabledGroups = GrammarDisabledGroups,
     });
 
     public static ConversionOptions Load(PluginRequest request)
@@ -97,12 +101,22 @@ public static ConversionOptions Load(PluginRequest request)
             ReadOptIn(json, "grammarCheck"),
             ReadOptIn(json, "grammarAutoFix"),
             ReadGrammarServer(json),
-            ReadOptIn(json, "grammarExternalServer"));
+            ReadOptIn(json, "grammarExternalServer"),
+            ReadGrammarSelection(json, "grammarDisabledRules", false),
+            ReadGrammarSelection(json, "grammarDisabledGroups", true));
     }
 
     public bool RuleEnabled(string id) => DisabledRules.Length == 0 || !DisabledRules.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
         .Contains(id, StringComparer.Ordinal);
 
+    private static string ReadGrammarSelection(JsonElement json, string name, bool groups)
+    {
+        if (!json.TryGetProperty(name, out var value)) return "";
+        if (value.ValueKind != JsonValueKind.String)
+            throw new InvalidDataException($"Invalid {name} in plugin settings (expected a string).");
+        return GrammarRuleSelection.Validate(value.GetString()!, groups);
+    }
+
     private static bool ReadOptIn(JsonElement json, string name)
     {
         if (!json.TryGetProperty(name, out var value)) return false;
diff --git a/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs b/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs
index dcd4b902..4f35cb72 100644
--- a/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs
+++ b/se5/BrazilianToEuropeanPortuguese/GrammarChecks.cs
@@ -32,7 +32,8 @@ internal static async Task<string> RunAsync(IReadOnlyList<CheckLine> lines, Conv
                 continue;
             }
             var masked = Mask(baseline, words);
-            var matches = (await check(masked, token)).Where(m => Visible(masked, baseline, m)).ToArray();
+            var matches = (await check(masked, token))
+                .Where(m => GrammarRuleSelection.Enabled(m, options) && Visible(masked, baseline, m)).ToArray();
             if (matches.Length == 0) continue;
             flagged += group.Count;
             var english = group.Any(l => string.IsNullOrWhiteSpace(l.Reference))
@@ -54,7 +55,8 @@ internal static async Task<string> RunAsync(IReadOnlyList<CheckLine> lines, Conv
                     reason = "MiniLM meaning safeguard rejected the candidate";
                 else
                 {
-                    var rechecked = (await check(Mask(candidate.Text, words), token)).ToArray();
+                    var rechecked = (await check(Mask(candidate.Text, words), token))
+                        .Where(m => GrammarRuleSelection.Enabled(m, options)).ToArray();
                     if (!ResolvedWithoutNewDiagnostics(baseline, candidate.Text, matches, rechecked, candidate.Match.Rule))
                         reason = "grammar recheck did not resolve the diagnostic without new findings";
                     else
diff --git a/se5/BrazilianToEuropeanPortuguese/GrammarRuleSelection.cs b/se5/BrazilianToEuropeanPortuguese/GrammarRuleSelection.cs
new file mode 100644
index 00000000..89a14afa
--- /dev/null
+++ b/se5/BrazilianToEuropeanPortuguese/GrammarRuleSelection.cs
@@ -0,0 +1,45 @@
+using System.Text.RegularExpressions;
+
+namespace SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
+
+internal static class GrammarRuleSelection
+{
+    internal static readonly (string Id, string Label)[] Groups =
+    {
+        ("grammar", "Grammar and agreement"),
+        ("spelling", "Spelling (including names and unknown words)"),
+        ("typography", "Punctuation, dialogue dashes, spacing and typography"),
+        ("style", "Style, wordiness and register"),
+        ("other", "Other / unclassified checks"),
+    };
+
+    internal static string[] Ids(string value) =>
+        value.Split(new[] { ',', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+            .Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal).ToArray();
+
+    internal static string Validate(string value, bool groups = false)
+    {
+        var ids = Ids(value);
+        foreach (var id in ids)
+            if (groups ? !Groups.Any(g => g.Id == id) : !Regex.IsMatch(id, @"^[A-Za-z0-9_][A-Za-z0-9_.:-]*$", RegexOptions.CultureInvariant))
+                throw new InvalidDataException($"Invalid LanguageTool {(groups ? "group" : "rule ID")}: {id}.");
+        return string.Join(",", ids);
+    }
+
+    internal static string Group(GrammarMatch match)
+    {
+        if (match.IssueType == "misspelling" || match.Category == "TYPOS") return "spelling";
+        if (match.IssueType is "style" or "register" || match.Category is "STYLE" or "REDUNDANCY") return "style";
+        if (match.IssueType is "typographical" or "whitespace" or "formatting" or "characters" or "duplication" ||
+            match.Category is "PUNCTUATION" or "TYPOGRAPHY" or "CASING") return "typography";
+        return match.IssueType == "grammar" || match.Category == "GRAMMAR" ? "grammar" : "other";
+    }
+
+    internal static bool Enabled(GrammarMatch match, ConversionOptions options) =>
+        !Ids(options.GrammarDisabledRules).Contains(match.Rule, StringComparer.Ordinal) &&
+        !Ids(options.GrammarDisabledGroups).Contains(Group(match), StringComparer.Ordinal);
+
+    internal static string[] ObservedIds(IEnumerable<string?> notes) => notes.Where(n => n != null)
+        .SelectMany(n => Regex.Matches(n!, @"LanguageTool \[([A-Za-z0-9_][A-Za-z0-9_.:-]*)\]:")
+            .Select(m => m.Groups[1].Value)).Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal).ToArray();
+}
diff --git a/se5/BrazilianToEuropeanPortuguese/GrammarRulesWindow.cs b/se5/BrazilianToEuropeanPortuguese/GrammarRulesWindow.cs
new file mode 100644
index 00000000..fdc70f6c
--- /dev/null
+++ b/se5/BrazilianToEuropeanPortuguese/GrammarRulesWindow.cs
@@ -0,0 +1,124 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+
+namespace SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
+
+internal sealed class GrammarRulesWindow : Window
+{
+    private readonly Dictionary<string, CheckBox> _groups = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, CheckBox> _rules = new(StringComparer.Ordinal);
+    private readonly TextBox _extra;
+    internal string DisabledRules => GrammarRuleSelection.Validate(string.Join(",",
+        _rules.Where(r => r.Value.IsChecked != true).Select(r => r.Key).Append(_extra.Text ?? "")));
+    internal string DisabledGroups => string.Join(",", _groups.Where(g => g.Value.IsChecked != true).Select(g => g.Key).Order(StringComparer.Ordinal));
+
+    internal GrammarRulesWindow(ConversionOptions options, IEnumerable<string> observed)
+    {
+        Title = "LanguageTool rules";
+        Width = 780;
+        Height = 650;
+        MinWidth = 540;
+        MinHeight = 400;
+        WindowStartupLocation = WindowStartupLocation.CenterOwner;
+        var scope = new NameScope();
+        NameScope.SetNameScope(this, scope);
+        _extra = new TextBox { Name = "ExtraGrammarDisabledRules", AcceptsReturn = true, MinHeight = 65, Watermark = "RULE_ID, ANOTHER_RULE_ID" };
+        scope.Register(_extra.Name, _extra);
+        var content = new StackPanel { Spacing = 8 };
+        content.Children.Add(new TextBlock
+        {
+            Text = "Choose which LanguageTool alerts and corrections to use. Unchecked groups override individual rules. " +
+                   "These choices are saved for future files and Batch convert. They do not disable the plugin's own conversion rules.",
+            TextWrapping = TextWrapping.Wrap,
+        });
+        foreach (var group in GrammarRuleSelection.Groups)
+        {
+            var box = new CheckBox
+            {
+                Name = "GrammarGroup_" + group.Id, Content = group.Label,
+                IsChecked = !GrammarRuleSelection.Ids(options.GrammarDisabledGroups).Contains(group.Id, StringComparer.Ordinal),
+            };
+            _groups.Add(group.Id, box);
+            scope.Register(box.Name, box);
+            content.Children.Add(box);
+        }
+        var grammarOnly = new Button { Name = "GrammarOnlyPreset", Content = "Grammar only (fewer alerts)" };
+        scope.Register(grammarOnly.Name, grammarOnly);
+        grammarOnly.Click += (_, _) =>
+        {
+            foreach (var group in _groups) group.Value.IsChecked = group.Key == "grammar";
+        };
+        var all = new Button { Name = "AllGrammarRules", Content = "Enable all" };
+        scope.Register(all.Name, all);
+        all.Click += (_, _) =>
+        {
+            foreach (var box in _groups.Values.Concat(_rules.Values)) box.IsChecked = true;
+            _extra.Text = "";
+        };
+        content.Children.Add(new WrapPanel { Children = { grammarOnly, all } });
+        content.Children.Add(new TextBlock
+        {
+            Text = "Individual rules: current findings, saved exclusions and common subtitle alerts",
+            FontWeight = FontWeight.SemiBold, TextWrapping = TextWrapping.Wrap,
+        });
+        var common = new Dictionary<string, string>(StringComparer.Ordinal)
+        {
+            ["MORFOLOGIK_RULE_PT_PT"] = "Spelling / unknown names",
+            ["DASH_ENUMERATION_SPACE_RULE"] = "Space after dialogue dash",
+            ["PT_WORDINESS_REPLACE_POR_CAUSA_DA"] = "Style: por causa da",
+        };
+        var disabled = GrammarRuleSelection.Ids(options.GrammarDisabledRules);
+        foreach (var id in observed.Concat(common.Keys).Concat(disabled).Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal))
+        {
+            var box = new CheckBox
+            {
+                Name = "GrammarRule_" + id,
+                Content = new TextBlock
+                {
+                    Text = common.TryGetValue(id, out var label) ? $"{label} [{id}]" : id,
+                    TextWrapping = TextWrapping.Wrap,
+                },
+                IsChecked = !disabled.Contains(id, StringComparer.Ordinal),
+            };
+            _rules.Add(id, box);
+            scope.Register(box.Name, box);
+            content.Children.Add(box);
+        }
+        content.Children.Add(new TextBlock
+        {
+            Text = "Disable additional rule IDs (comma-separated or one per line). Copy an ID from LanguageTool [ID] in a finding. " +
+                   "Run checks again after saving to refresh results.",
+            TextWrapping = TextWrapping.Wrap,
+        });
+        content.Children.Add(_extra);
+        var error = new TextBlock { Name = "GrammarRulesError", Foreground = Brushes.Red, TextWrapping = TextWrapping.Wrap };
+        scope.Register(error.Name, error);
+        var save = new Button { Name = "SaveGrammarRules", Content = "Use selected rules", IsDefault = true };
+        scope.Register(save.Name, save);
+        save.Click += (_, _) =>
+        {
+            try
+            {
+                _ = DisabledRules;
+                Close(true);
+            }
+            catch (InvalidDataException ex) { error.Text = ex.Message; }
+        };
+        var cancel = new Button { Content = "Cancel", IsCancel = true };
+        cancel.Click += (_, _) => Close(false);
+        var buttons = new StackPanel
+        {
+            Orientation = Orientation.Horizontal, HorizontalAlignment = HorizontalAlignment.Right,
+            Spacing = 8, Margin = new Thickness(0, 10, 0, 0), Children = { cancel, save },
+        };
+        var panel = new DockPanel { Margin = new Thickness(16), LastChildFill = true };
+        DockPanel.SetDock(buttons, Dock.Bottom);
+        DockPanel.SetDock(error, Dock.Bottom);
+        panel.Children.Add(buttons);
+        panel.Children.Add(error);
+        panel.Children.Add(new ScrollViewer { Content = content, HorizontalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Disabled });
+        Content = panel;
+    }
+}
diff --git a/se5/BrazilianToEuropeanPortuguese/LanguageToolClient.cs b/se5/BrazilianToEuropeanPortuguese/LanguageToolClient.cs
index ad6a8855..3320e132 100644
--- a/se5/BrazilianToEuropeanPortuguese/LanguageToolClient.cs
+++ b/se5/BrazilianToEuropeanPortuguese/LanguageToolClient.cs
@@ -3,17 +3,20 @@
 
 namespace SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
 
-internal sealed record GrammarMatch(int Offset, int Length, string Rule, string Message, string[] Replacements);
+internal sealed record GrammarMatch(int Offset, int Length, string Rule, string Message, string[] Replacements,
+    string IssueType = "", string Category = "");
 
 internal sealed class LanguageToolClient : IDisposable
 {
     private readonly HttpClient _client;
     private readonly Uri _checkUri;
+    private readonly string _disabledRules;
     private readonly Dictionary<string, IReadOnlyList<GrammarMatch>> _cache = new(StringComparer.Ordinal);
 
-    internal LanguageToolClient(string server, HttpMessageHandler? handler = null)
+    internal LanguageToolClient(string server, HttpMessageHandler? handler = null, string disabledRules = "")
     {
         _checkUri = CheckUri(server);
+        _disabledRules = GrammarRuleSelection.Validate(disabledRules);
         _client = new HttpClient(handler ?? new HttpClientHandler { AllowAutoRedirect = false, UseProxy = false })
         {
             Timeout = TimeSpan.FromSeconds(15),
@@ -44,6 +47,7 @@ internal async Task<IReadOnlyList<GrammarMatch>> CheckAsync(string text, Cancell
         {
             ["language"] = "pt-PT",
             ["text"] = text,
+            ["disabledRules"] = _disabledRules,
         });
         HttpResponseMessage response;
         try
@@ -117,7 +121,15 @@ internal static IReadOnlyList<GrammarMatch> Parse(JsonElement root, string text)
                     throw new InvalidDataException("LanguageTool: invalid replacement.");
                 values.Add(value.GetString()!);
             }
-            result.Add(new GrammarMatch(start, count, id.GetString()!, message.GetString()!, values.Distinct().ToArray()));
+            var issueType = OptionalString(rule, "issueType");
+            var category = "";
+            if (rule.TryGetProperty("category", out var categoryValue))
+            {
+                if (categoryValue.ValueKind != JsonValueKind.Object)
+                    throw new InvalidDataException("LanguageTool: invalid rule category.");
+                category = OptionalString(categoryValue, "id");
+            }
+            result.Add(new GrammarMatch(start, count, id.GetString()!, message.GetString()!, values.Distinct().ToArray(), issueType, category));
         }
         return result;
     }
@@ -125,5 +137,13 @@ internal static IReadOnlyList<GrammarMatch> Parse(JsonElement root, string text)
     private static bool Boundary(string text, int offset) =>
         offset == 0 || offset == text.Length || !char.IsLowSurrogate(text[offset]) || !char.IsHighSurrogate(text[offset - 1]);
 
+    private static string OptionalString(JsonElement value, string name)
+    {
+        if (!value.TryGetProperty(name, out var field)) return "";
+        if (field.ValueKind != JsonValueKind.String)
+            throw new InvalidDataException($"LanguageTool: invalid {name}.");
+        return field.GetString()!;
+    }
+
     public void Dispose() => _client.Dispose();
 }
diff --git a/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs b/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs
index 4701b643..f2078e2c 100644
--- a/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs
+++ b/se5/BrazilianToEuropeanPortuguese/LocalChecks.cs
@@ -233,7 +233,8 @@ void Note(int index, string note)
         {
             await using var grammarRuntime = options.GrammarExternalServer ? null :
                 await GrammarRuntime.StartAsync(progress, token);
-            using var client = new LanguageToolClient(grammarRuntime?.Server ?? options.GrammarServer);
+            using var client = new LanguageToolClient(grammarRuntime?.Server ?? options.GrammarServer,
+                disabledRules: options.GrammarDisabledRules);
             EmbeddingRuntime? runtime = null;
             try
             {
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
index a88568d8..d421fd31 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
@@ -242,6 +242,9 @@
                           IsCheckedChanged="OnGrammarSettingChanged">
                     <TextBlock Text="LanguageTool pt-PT (local grammar checker)" TextWrapping="Wrap" />
                 </CheckBox>
+                <Button x:Name="GrammarRulesButton" Content="Choose LanguageTool rules..."
+                        Click="OnChooseGrammarRules"
+                        ToolTip.Tip="Choose alert groups and individual LanguageTool rules. Saved for preview and Batch convert. Run checks again after changing the selection." />
                 <WrapPanel>
                     <Button x:Name="DownloadGrammarButton" Content="Download LanguageTool pt-PT (240 MB)"
                             Click="OnDownloadGrammar" Margin="0,0,8,4"
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
index fe32c403..baf7174e 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
@@ -67,6 +67,9 @@ public partial class MainWindow : Window
     private CheckBox _grammarExternalServer = null!;
     private TextBox _grammarServer = null!;
     private string _lastGrammarServer = "";
+    private string _grammarDisabledRules = "";
+    private string _grammarDisabledGroups = "";
+    private readonly HashSet<string> _observedGrammarRules = new(StringComparer.Ordinal);
     private readonly List<CheckLine> _checkLines = new();
     private readonly Dictionary<CheckLine, CheckResult> _checks = new();
     private ComboBox _addressChoice = null!;
@@ -139,13 +142,17 @@ internal MainWindow(PluginRequest request, string wordListPath)
         _grammarCheck.IsChecked == true,
         _grammarAutoFix.IsChecked == true,
         _grammarServer.Text ?? "",
-        _grammarExternalServer.IsChecked == true);
+        _grammarExternalServer.IsChecked == true,
+        _grammarDisabledRules,
+        _grammarDisabledGroups);
 
     private bool SettingsChanged => _nameArticles != _initialOptions.NameArticles ||
         (_askNameArticlesCheck.IsChecked == true) != _initialOptions.AskNameArticles ||
         Options.GrammarCheck != _initialOptions.GrammarCheck ||
         Options.GrammarAutoFix != _initialOptions.GrammarAutoFix ||
         Options.GrammarExternalServer != _initialOptions.GrammarExternalServer ||
+        Options.GrammarDisabledRules != _initialOptions.GrammarDisabledRules ||
+        Options.GrammarDisabledGroups != _initialOptions.GrammarDisabledGroups ||
         Options.GrammarServer != _initialOptions.GrammarServer;
 
     private ConversionOptions SavedOptions => Options with { DisabledRules = _savedDisabledRules };
@@ -182,6 +189,8 @@ private void LoadOptions(ConversionOptions options)
         _grammarExternalServer.IsChecked = options.GrammarExternalServer;
         _grammarServer.IsVisible = options.GrammarExternalServer;
         _lastGrammarServer = options.GrammarServer;
+        _grammarDisabledRules = options.GrammarDisabledRules;
+        _grammarDisabledGroups = options.GrammarDisabledGroups;
         _loadingOptions = false;
 
         foreach (var check in OptionChecks)
@@ -257,6 +266,21 @@ private async void OnEditNameArticles(object? sender, RoutedEventArgs e)
         }
     }
 
+    private async void OnChooseGrammarRules(object? sender, RoutedEventArgs e)
+    {
+        _observedGrammarRules.UnionWith(GrammarRuleSelection.ObservedIds(_checks.Values.Select(c => c.Note)));
+        var editor = new GrammarRulesWindow(Options, _observedGrammarRules);
+        if (await editor.ShowDialog<bool>(this))
+        {
+            if (_grammarDisabledRules == editor.DisabledRules && _grammarDisabledGroups == editor.DisabledGroups) return;
+            _grammarDisabledRules = editor.DisabledRules;
+            _grammarDisabledGroups = editor.DisabledGroups;
+            _checks.Clear();
+            OnOptionChanged(sender, e);
+            _referenceStatus.Text = "LanguageTool rule selection changed. Run checks again to refresh findings.";
+        }
+    }
+
     private async Task AskUnknownNameArticles()
     {
         if (!_readyForNameQuestions || _closed || _isConfigure || _askingNames ||
@@ -453,6 +477,7 @@ private void InitializeComponent()
             _embeddingCheck, _vulkanCheck, _deviceChoice, _meaningCheck, _judgeCheck,
             _grammarCheck, _grammarAutoFix, _grammarServer,
             _grammarExternalServer, this.FindControl<Button>("DownloadGrammarButton")!, this.FindControl<Button>("DownloadJavaButton")!,
+            this.FindControl<Button>("GrammarRulesButton")!,
             _askNameArticlesCheck, this.FindControl<Button>("EditNameArticlesButton")!,
             this.FindControl<Button>("ContributeVocabularyButton")!,
             this.FindControl<Button>("DisableRuleButton")!, this.FindControl<Button>("RestoreRulesButton")!,
@@ -767,6 +792,7 @@ await RunReferenceJob(async (progress, token) =>
 
     internal void ApplyCheckResults(IReadOnlyList<CheckLine> lines, IReadOnlyDictionary<int, CheckResult> results)
     {
+        _observedGrammarRules.UnionWith(GrammarRuleSelection.ObservedIds(results.Values.Select(c => c.Note)));
         foreach (var line in lines)
             _checks[line] = results.TryGetValue(line.Index, out var result)
                 ? result : new CheckResult(line.Converted, null);
diff --git a/se5/BrazilianToEuropeanPortuguese/README.md b/se5/BrazilianToEuropeanPortuguese/README.md
index b314f9b7..cd0a7449 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.md
@@ -24,7 +24,7 @@ Earlier updates include reviewed workbook vocabulary and verb constructions,
 English-confirmed sportswear and shared-residence expressions, physical descriptions,
 finding filters, and original PT-BR text visible on warning-only rows.
 
-The experimental standalone source build is **1.8.1**. The pre-LanguageTool
+The experimental standalone source build is **1.8.2**. The pre-LanguageTool
 rollback baseline is [v1.7.0](https://github.com/SMAP-git/BrazilianToEuropeanPortuguese/tree/v1.7.0).
 Official Subtitle Edit package versions
 are assigned by the upstream release workflow and may differ.
@@ -45,6 +45,20 @@ model. In the **Reference subtitle and local models** panel, now to the right of
 2. Click **Download portable Java (40–50 MB)**.
 3. Enable **LanguageTool pt-PT (local grammar checker)** and choose **Run checks**.
 
+Use **Choose LanguageTool rules...** to enable/disable grammar, spelling,
+punctuation/typography, style/register and unclassified checks. **Grammar only
+(fewer alerts)** disables the other groups without changing the plugin's own
+conversion rules. Existing settings keep all groups enabled until you choose.
+The same dialog lists individual rule IDs from current-session findings, saved
+exclusions and common subtitle alerts (unknown names, dialogue-dash spacing and
+the `por causa da` style suggestion). Uncheck any rule, or enter additional IDs
+copied from `LanguageTool [ID]` findings. Group exclusions take precedence.
+Choices are saved for future files and Batch convert; **Run checks** again after
+saving. Disabled rules cannot produce alerts or automatic corrections. Unknown
+server classifications belong to **Other / unclassified checks**. This filters
+findings rather than guaranteeing a faster check; only explicit rule-ID
+exclusions are also sent to the server.
+
 Both downloads are explicit, pinned and SHA-256 verified. LanguageTool **6.6**
 comes from its official download site (LGPL-2.1-or-later); the private Eclipse
 Temurin **JRE 21.0.13+9** comes from Adoptium's GitHub releases (GPLv2 with
diff --git a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
index 4e372b83..961dfba6 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
@@ -29,7 +29,7 @@ partir de folhas de cálculo, vestuário desportivo e expressões de residência
 confirmados pelo inglês, descrições físicas, filtros de resultados e o texto
 original em PT-BR visível nas linhas que contêm apenas avisos.
 
-A compilação experimental do repositório autónomo é a **1.8.1**. A base anterior
+A compilação experimental do repositório autónomo é a **1.8.2**. A base anterior
 ao LanguageTool está guardada em
 [v1.7.0](https://github.com/SMAP-git/BrazilianToEuropeanPortuguese/tree/v1.7.0).
 As versões oficiais dos
@@ -53,6 +53,20 @@ No painel **Reference subtitle and local models**, agora à direita de
 2. Clique em **Download portable Java (40–50 MB)**.
 3. Ative **LanguageTool pt-PT (local grammar checker)** e escolha **Run checks**.
 
+Em **Choose LanguageTool rules...**, pode ativar/desativar grupos de gramática,
+ortografia, pontuação/tipografia, estilo/registo e verificações não classificadas.
+**Grammar only (fewer alerts)** mantém apenas o grupo gramatical, sem alterar as
+regras de conversão do plugin. As opções antigas mantêm todos os grupos ativos
+até escolher. Pode também desmarcar regras individuais encontradas nesta sessão,
+exclusões guardadas e alertas comuns de legendagem (nomes desconhecidos, espaços
+após travessões e a sugestão de estilo `por causa da`). Pode introduzir outros
+identificadores copiados de `LanguageTool [ID]`. A exclusão de um grupo prevalece
+sobre a seleção individual. As escolhas ficam guardadas para outros ficheiros e
+**Batch convert**; execute **Run checks** novamente após guardar. Regras excluídas
+não geram alertas nem correções automáticas. Classificações desconhecidas ficam
+em **Other / unclassified checks**. A filtragem não garante maior velocidade;
+apenas as exclusões por identificador são também enviadas ao servidor.
+
 As transferências são explícitas, de versões fixadas e verificadas por SHA-256.
 O LanguageTool **6.6** vem do sítio oficial (LGPL-2.1-ou-posterior); o Eclipse
 Temurin **JRE 21.0.13+9** vem dos lançamentos da Adoptium no GitHub (GPLv2 com
diff --git a/se5/BrazilianToEuropeanPortuguese/plugin.json b/se5/BrazilianToEuropeanPortuguese/plugin.json
index 794edf87..ba092697 100644
--- a/se5/BrazilianToEuropeanPortuguese/plugin.json
+++ b/se5/BrazilianToEuropeanPortuguese/plugin.json
@@ -2,7 +2,7 @@
   "apiVersion": 1,
   "name": "Brazilian to European Portuguese",
   "description": "Converts Brazilian Portuguese (pt-BR) to European Portuguese (pt-PT), with complement-aware vocabulary, personal infinitives, guarded clause agreement and idioms, optional conversational style, dialogue controls and grammar review. Shows a checkable preview of changes and their rule stages.",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "author": "Subtitle Edit",
   "url": "https://github.com/SubtitleEdit/plugins/tree/main/se5/BrazilianToEuropeanPortuguese",
   "menu": "Tools",

From 86545f39662051f97af8eda149d510866ab8da86 Mon Sep 17 00:00:00 2001
From: SMAP-git <333812182+SMAP-git@users.noreply.github.com>
Date: Wed, 11 Nov 2026 15:30:19 +0100
Subject: [PATCH 4/7] Align reference and model settings beside orthography
 controls

Move reference settings below the top-right actions, align dialogue/layout and dictionary right edges, and bound scrolling to preserve subtitle-review space. Validate native layout at minimum, standard and wide widths.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../ReferenceTests.cs                         | 33 ++++++++++++++++---
 .../MainWindow.axaml                          | 25 ++++++++++----
 .../MainWindow.axaml.cs                       |  6 ++--
 se5/BrazilianToEuropeanPortuguese/README.md   |  9 +++--
 .../README.pt-PT.md                           |  9 +++--
 5 files changed, 64 insertions(+), 18 deletions(-)

diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
index e02a9180..2cc648d2 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
@@ -1,4 +1,5 @@
 using System.Text;
+using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.VisualTree;
@@ -1072,15 +1073,26 @@ void LayoutScreenshot()
             }
             LayoutScreenshot();
             var panels = screenshotWindow.FindControl<Grid>("ReviewLayoutPanels")!;
+            var settingsColumns = screenshotWindow.FindControl<Grid>("SettingsColumns")!;
             var layoutPanel = screenshotWindow.FindControl<Expander>("LayoutTools")!;
             var referencePanel = screenshotWindow.FindControl<Expander>("ReferencePanel")!;
             Assert.Same(panels, layoutPanel.Parent);
-            Assert.Same(panels, referencePanel.Parent);
+            Assert.Same(settingsColumns, referencePanel.Parent);
             Assert.Equal(1, Grid.GetColumn(layoutPanel));
-            Assert.Equal(2, Grid.GetColumn(referencePanel));
-            Assert.True(referencePanel.Bounds.X >= layoutPanel.Bounds.Right);
+            Assert.Equal(1, Grid.GetColumn(referencePanel));
+            var dictionaryButton = screenshotWindow.FindControl<Button>("DictionaryDownloadButton")!;
+            var layoutOrigin = layoutPanel.TranslatePoint(default, settingsColumns)!.Value;
+            var dictionaryOrigin = dictionaryButton.TranslatePoint(default, settingsColumns)!.Value;
+            Assert.Equal(dictionaryOrigin.X + dictionaryButton.Bounds.Width,
+                layoutOrigin.X + layoutPanel.Bounds.Width, 1);
+            Assert.True(referencePanel.Bounds.X > dictionaryOrigin.X + dictionaryButton.Bounds.Width);
+            Assert.Equal(0, referencePanel.Bounds.Y, 1);
             Assert.True(referencePanel.Bounds.Width > 200);
-            Assert.True(referencePanel.Bounds.Right <= panels.Bounds.Width + 0.1);
+            Assert.True(referencePanel.Bounds.Right <= settingsColumns.Bounds.Width + 0.1);
+            var topButton = screenshotWindow.FindControl<Button>("EditNameArticlesButton")!;
+            var referenceOrigin = referencePanel.TranslatePoint(default, screenshotContent)!.Value;
+            var buttonOrigin = topButton.TranslatePoint(default, screenshotContent)!.Value;
+            Assert.True(referenceOrigin.Y >= buttonOrigin.Y + topButton.Bounds.Height);
             if (Environment.GetEnvironmentVariable("PTPT_UI_LAYOUT_CAPTURE") is { Length: > 0 } capture)
             {
                 layoutPanel.IsExpanded = true;
@@ -1092,6 +1104,7 @@ void LayoutScreenshot()
             }
             var settingsHeight = settingsPanel.Bounds.Height;
             var reviewHeight = screenshotWindow.FindControl<Border>("ChangesBorder")!.Bounds.Height;
+            Assert.True(reviewHeight > 80, $"Expanded settings leave only {reviewHeight} pixels for subtitle review.");
             toggleSettings.RaiseEvent(new Avalonia.Interactivity.RoutedEventArgs(Button.ClickEvent));
             LayoutScreenshot();
             Assert.False(settingsPanel.IsVisible);
@@ -1206,9 +1219,10 @@ void LayoutScreenshot()
             Assert.Equal("Estou pronto.", Assert.Single(styleWindow.Proposals).ConvertedText);
             styleWindow.FindControl<Expander>("ReviewTools")!.IsExpanded = true;
             styleWindow.FindControl<Expander>("LayoutTools")!.IsExpanded = true;
+            styleWindow.FindControl<Expander>("ReferencePanel")!.IsExpanded = true;
             styleWindow.Show();
             Avalonia.Threading.Dispatcher.UIThread.RunJobs();
-            foreach (var width in new[] { styleWindow.MinWidth, 1120d })
+            foreach (var width in new[] { styleWindow.MinWidth, 1120d, 1600d })
             {
                 styleWindow.Width = width;
                 var content = Assert.IsAssignableFrom<Control>(styleWindow.Content);
@@ -1219,6 +1233,15 @@ void LayoutScreenshot()
                 var layoutTools = styleWindow.FindControl<Expander>("LayoutTools")!;
                 Assert.Same(reviewTools.Parent, layoutTools.Parent);
                 Assert.True(layoutTools.Bounds.Left >= reviewTools.Bounds.Right);
+                var columns = styleWindow.FindControl<Grid>("SettingsColumns")!;
+                var dictionary = styleWindow.FindControl<Button>("DictionaryDownloadButton")!;
+                var layoutPosition = layoutTools.TranslatePoint(default, columns)!.Value;
+                var dictionaryPosition = dictionary.TranslatePoint(default, columns)!.Value;
+                Assert.Equal(dictionaryPosition.X + dictionary.Bounds.Width, layoutPosition.X + layoutTools.Bounds.Width, 1);
+                var reference = styleWindow.FindControl<Expander>("ReferencePanel")!;
+                Assert.True(reference.Bounds.Left > layoutPosition.X + layoutTools.Bounds.Width);
+                Assert.True(reference.Bounds.Right <= columns.Bounds.Width + 0.1);
+                Assert.True(styleWindow.FindControl<Border>("ChangesBorder")!.Bounds.Height > 80);
                 foreach (var name in new[] { "LineLength", "MaxLines", "CharactersPerSecond" })
                 {
                     var numeric = styleWindow.FindControl<NumericUpDown>(name)!;
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
index d421fd31..258e013b 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
@@ -79,6 +79,10 @@
         </Grid>
 
         <StackPanel DockPanel.Dock="Top" x:Name="SettingsPanel">
+        <Grid x:Name="SettingsColumns" ColumnDefinitions="55*,45*" Margin="0,0,0,8">
+        <ScrollViewer Grid.Column="0" x:Name="ConversionSettingsContent" MaxHeight="400"
+                      Margin="0,0,12,0" HorizontalScrollBarVisibility="Disabled">
+        <StackPanel>
         <TextBlock
                    FontSize="18"
                    FontWeight="SemiBold"
@@ -114,7 +118,8 @@
                   ToolTip.Tip="Ask once per unresolved name when a supported rule needs an article. Batch convert never asks."
                   Margin="0,0,0,8" />
 
-        <WrapPanel Margin="0,0,0,8">
+        <Grid x:Name="OrthographyControls" ColumnDefinitions="*,Auto" Margin="0,0,0,8">
+        <WrapPanel Grid.Column="0">
             <TextBlock Text="Orthography:" VerticalAlignment="Center" Margin="0,0,8,0" />
             <ComboBox x:Name="OrthographyChoice" SelectedIndex="0" Margin="0,0,12,0"
                       SelectionChanged="OnOrthographyChanged">
@@ -126,14 +131,16 @@
                       ToolTip.Tip="Flag words not recognised by the selected Natura dictionary; never auto-correct them." />
             <Button x:Name="DictionaryCheckButton" Content="Check dictionary updates"
                     Click="OnCheckDictionary" Margin="8,0,8,0" />
-            <Button x:Name="DictionaryDownloadButton" Content="Re-download dictionary"
-                    Click="OnDownloadDictionary" />
         </WrapPanel>
+            <Button Grid.Column="1" x:Name="DictionaryDownloadButton" Content="Re-download dictionary"
+                    VerticalAlignment="Bottom"
+                    Click="OnDownloadDictionary" />
+        </Grid>
         <ScrollViewer MaxHeight="80" Margin="0,0,0,8">
             <TextBlock x:Name="DictionaryStatus" TextWrapping="Wrap" Opacity="0.75"
                        Text="Natura dictionaries available offline (2025-10-01)." />
         </ScrollViewer>
-        <Grid DockPanel.Dock="Top" x:Name="ReviewLayoutPanels" ColumnDefinitions="230,*,*" Margin="0,0,0,8">
+        <Grid x:Name="ReviewLayoutPanels" ColumnDefinitions="180,*">
         <Expander Grid.Column="0" x:Name="ReviewTools" Header="Review tools"
                   HorizontalAlignment="Stretch" VerticalAlignment="Top" Margin="0,0,12,0">
             <StackPanel Spacing="6">
@@ -149,7 +156,7 @@
             </StackPanel>
         </Expander>
         <Expander Grid.Column="1" x:Name="LayoutTools"
-                  HorizontalAlignment="Stretch" VerticalAlignment="Top" Margin="0,0,12,0">
+                  HorizontalAlignment="Stretch" VerticalAlignment="Top">
             <Expander.Header>
                 <TextBlock Text="Dialogue context and subtitle layout" TextWrapping="Wrap" />
             </Expander.Header>
@@ -203,13 +210,17 @@
             </ScrollViewer>
         </Expander>
 
-        <Expander Grid.Column="2" x:Name="ReferencePanel"
+        </Grid>
+        </StackPanel>
+        </ScrollViewer>
+
+        <Expander Grid.Column="1" x:Name="ReferencePanel"
                   HorizontalAlignment="Stretch" VerticalAlignment="Top"
                   ToolTip.Tip="An English subtitle of the same episode, found automatically when it is named like the subtitle or video with .en/.eng/.english. It prevents wrong changes (his/her → keeps 'o seu/a sua') and marks you/your lines that kept você/seu for review; it never adds text.">
             <Expander.Header>
                 <TextBlock Text="Reference subtitle and local models (optional)" TextWrapping="Wrap" />
             </Expander.Header>
-            <ScrollViewer x:Name="ReferenceContent" MaxHeight="220" HorizontalScrollBarVisibility="Disabled">
+            <ScrollViewer x:Name="ReferenceContent" MaxHeight="350" HorizontalScrollBarVisibility="Disabled">
             <StackPanel Spacing="6">
                 <CheckBox x:Name="BatchReferenceCheck" IsVisible="False" IsChecked="True"
                           Content="Use the English subtitle next to each file"
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
index baf7174e..8443a119 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
@@ -233,8 +233,10 @@ private void OnOrthographyChanged(object? sender, SelectionChangedEventArgs e) =
     private void OnWindowSizeChanged(object? sender, SizeChangedEventArgs e)
     {
         var height = Math.Clamp(e.NewSize.Height * 0.28, 140, 360);
-        foreach (var name in new[] { "LayoutContent", "ReferenceContent" })
-            if (this.FindControl<ScrollViewer>(name) is { } content) content.MaxHeight = height;
+        if (this.FindControl<ScrollViewer>("LayoutContent") is { } layout) layout.MaxHeight = height;
+        var settingsHeight = Math.Clamp(e.NewSize.Height * 0.5, 240, 480);
+        if (this.FindControl<ScrollViewer>("ConversionSettingsContent") is { } settings) settings.MaxHeight = settingsHeight;
+        if (this.FindControl<ScrollViewer>("ReferenceContent") is { } reference) reference.MaxHeight = settingsHeight - 50;
     }
 
     private void OnToggleSettings(object? sender, RoutedEventArgs e)
diff --git a/se5/BrazilianToEuropeanPortuguese/README.md b/se5/BrazilianToEuropeanPortuguese/README.md
index cd0a7449..a02a8ea8 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.md
@@ -38,8 +38,13 @@ subtitle cue timings and user-controlled rule options.
 
 LanguageTool is the grammar checker; its Portuguese rules include **European
 Portuguese (`pt-PT`)**. You do not need to choose or download a separate grammar
-model. In the **Reference subtitle and local models** panel, now to the right of
-**Dialogue context and subtitle layout**:
+model. The **Reference subtitle and local models** panel is below the top-right
+settings/name/vocabulary buttons, beside the orthography controls. The right edge
+of **Dialogue context and subtitle layout** aligns with **Re-download dictionary**;
+reference/model controls expand alongside them. Both columns scroll when needed
+to preserve subtitle-review space.
+
+To set up checking:
 
 1. Click **Download LanguageTool pt-PT (240 MB)**.
 2. Click **Download portable Java (40–50 MB)**.
diff --git a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
index 961dfba6..ec6d3605 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
@@ -46,8 +46,13 @@ de regras controladas pelo utilizador.
 
 O LanguageTool é o verificador gramatical e já inclui regras de **português
 europeu (`pt-PT`)**. Não precisa de escolher um modelo gramatical separado.
-No painel **Reference subtitle and local models**, agora à direita de
-**Dialogue context and subtitle layout**:
+O painel **Reference subtitle and local models** fica abaixo dos botões superiores
+de opções, artigos de nomes e vocabulário, ao lado dos controlos de ortografia.
+O limite direito de **Dialogue context and subtitle layout** alinha com
+**Re-download dictionary**; o painel da referência expande ao lado. As colunas
+têm deslocamento quando necessário para preservar espaço para rever legendas.
+
+Para configurar a verificação:
 
 1. Clique em **Download LanguageTool pt-PT (240 MB)**.
 2. Clique em **Download portable Java (40–50 MB)**.

From f3c901242affbfa43e708e56f587dde0e23fa44c Mon Sep 17 00:00:00 2001
From: SMAP-git <333812182+SMAP-git@users.noreply.github.com>
Date: Wed, 11 Nov 2026 15:42:38 +0100
Subject: [PATCH 5/7] Add separate grammar findings display filter

Classify LanguageTool findings independently of other review warnings while preserving multi-type rows, edits and Apply selections. Verify classification and native filter controls.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../QualityTests.cs                              |  8 +++++++-
 .../ReferenceTests.cs                            | 16 +++++++++++-----
 .../ChangeProposal.cs                            |  6 +++++-
 .../MainWindow.axaml                             |  3 +++
 .../MainWindow.axaml.cs                          |  1 +
 se5/BrazilianToEuropeanPortuguese/README.md      |  6 ++++--
 .../README.pt-PT.md                              |  6 ++++--
 7 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/QualityTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/QualityTests.cs
index 7150643a..d641b54c 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/QualityTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/QualityTests.cs
@@ -241,8 +241,14 @@ public void FindingTypesDistinguishRulesModelsReviewsAndManualEdits()
         var combined = new ChangeProposal(3, "A", "B",
             reviewNote: "MiniLM: check it.\nGervásio chose an alternative.\nGrammar: check agreement.",
             rules: new[] { new RuleChange("word-list", "Vocabulary") });
-        Assert.Equal(FindingType.RuleBased | FindingType.MiniLm | FindingType.Judge | FindingType.OtherReview,
+        Assert.Equal(FindingType.RuleBased | FindingType.MiniLm | FindingType.Judge | FindingType.Grammar,
             combined.FindingTypes);
+        var grammar = new ChangeProposal(6, "A", "A", reviewNote: "LanguageTool [TEST]: check grammar.");
+        Assert.Equal(FindingType.Grammar, grammar.FindingTypes);
+        var corrected = new ChangeProposal(7, "A", "B", rules: new[] { new RuleChange("languagetool", "Grammar correction") });
+        Assert.Equal(FindingType.RuleBased | FindingType.Grammar, corrected.FindingTypes);
+        var mixed = new ChangeProposal(8, "A", "A", reviewNote: "LanguageTool [TEST]: check grammar.\nReview this wording.");
+        Assert.Equal(FindingType.Grammar | FindingType.OtherReview, mixed.FindingTypes);
         mini.ConvertedText = "Manual correction";
         Assert.Equal(FindingType.MiniLm | FindingType.ManualEdit, mini.FindingTypes);
         mini.ConvertedText = "A";
diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
index 2cc648d2..46f52e51 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
@@ -560,7 +560,8 @@ public void MainWindowAppliesReferenceToProposals()
                     SubRip = "1\n00:00:01,000 --> 00:00:04,000\nO trem chegou.\n\n" +
                              "2\n00:00:05,000 --> 00:00:07,000\nBom dia.\n\n" +
                              "3\n00:00:08,000 --> 00:00:10,000\nBoa noite.\n\n" +
-                             "4\n00:00:11,000 --> 00:00:13,000\nAté amanhã.\n",
+                             "4\n00:00:11,000 --> 00:00:13,000\nAté amanhã.\n\n" +
+                             "5\n00:00:14,000 --> 00:00:16,000\nBom trabalho.\n",
                 },
             });
             filterWindow.ApplyCheckResults(new[]
@@ -568,17 +569,19 @@ public void MainWindowAppliesReferenceToProposals()
                 new CheckLine(1, "Bom dia.", "Bom dia.", "O comboio chegou.", null),
                 new CheckLine(2, "Boa noite.", "Boa noite.", "Bom dia.", null),
                 new CheckLine(3, "Até amanhã.", "Até amanhã.", "Boa noite.", null),
+                new CheckLine(4, "Bom trabalho.", "Bom trabalho.", "Até amanhã.", null),
             }, new Dictionary<int, CheckResult>
             {
                 [1] = new("Bom dia.", "MiniLM: check the translation."),
                 [2] = new("Boa noite!", "Gervásio chose an alternative."),
                 [3] = new("Até amanhã.", "Review this wording."),
+                [4] = new("Bom trabalho.", "LanguageTool [TEST]: grammar review."),
             });
             filterWindow.Show();
             Avalonia.Threading.Dispatcher.UIThread.RunJobs();
-            var filterNames = new[] { "RuleBasedFilter", "MiniLmFilter", "JudgeFilter", "OtherReviewFilter", "ManualEditFilter" };
+            var filterNames = new[] { "RuleBasedFilter", "MiniLmFilter", "JudgeFilter", "GrammarFilter", "OtherReviewFilter", "ManualEditFilter" };
             Assert.All(filterNames, name => Assert.True(filterWindow.FindControl<ToggleButton>(name)!.IsChecked));
-            Assert.Equal(4, filterWindow.Proposals.Count);
+            Assert.Equal(5, filterWindow.Proposals.Count);
             Assert.All(filterWindow.Proposals, p => Assert.True(p.VisibleInReview));
             void SetFilter(string name, bool enabled)
             {
@@ -589,7 +592,7 @@ void SetFilter(string name, bool enabled)
             }
             foreach (var name in filterNames) SetFilter(name, false);
             Assert.All(filterWindow.Proposals, p => Assert.False(p.VisibleInReview));
-            Assert.Contains("Showing 0 of 4", filterWindow.FindControl<TextBlock>("SummaryLabel")!.Text);
+            Assert.Contains("Showing 0 of 5", filterWindow.FindControl<TextBlock>("SummaryLabel")!.Text);
             Assert.True(filterWindow.FindControl<Button>("ApplyButton")!.IsEnabled);
             var selectionButtons = filterWindow.FindControl<Control>("SelectButtons")!.GetVisualDescendants().OfType<Button>();
             Assert.Single(selectionButtons, b => Equals(b.Content, "Select none"))
@@ -619,11 +622,14 @@ void SetFilter(string name, bool enabled)
             SetFilter("JudgeFilter", true);
             Assert.Equal(2, Assert.Single(filterWindow.Proposals, p => p.VisibleInReview).LineIndex);
             SetFilter("JudgeFilter", false);
+            SetFilter("GrammarFilter", true);
+            Assert.Equal(4, Assert.Single(filterWindow.Proposals, p => p.VisibleInReview).LineIndex);
+            SetFilter("GrammarFilter", false);
             SetFilter("OtherReviewFilter", true);
             Assert.Equal(3, Assert.Single(filterWindow.Proposals, p => p.VisibleInReview).LineIndex);
             var visibleBorders = filterWindow.FindControl<ItemsControl>("ChangesList")!.GetVisualDescendants()
                 .OfType<Border>().Where(b => b.DataContext is ChangeProposal && b.Padding == new Avalonia.Thickness(8, 6));
-            Assert.Equal(4, visibleBorders.Count());
+            Assert.Equal(5, visibleBorders.Count());
             Assert.Single(visibleBorders, b => b.IsVisible);
             filterWindow.FindControl<CheckBox>("VocabularyCheck")!.IsChecked = false;
             Assert.All(filterNames, name => Assert.Equal(name == "OtherReviewFilter",
diff --git a/se5/BrazilianToEuropeanPortuguese/ChangeProposal.cs b/se5/BrazilianToEuropeanPortuguese/ChangeProposal.cs
index 252518dc..5dba10f1 100644
--- a/se5/BrazilianToEuropeanPortuguese/ChangeProposal.cs
+++ b/se5/BrazilianToEuropeanPortuguese/ChangeProposal.cs
@@ -11,6 +11,7 @@ public enum FindingType
     Judge = 4,
     OtherReview = 8,
     ManualEdit = 16,
+    Grammar = 32,
 }
 
 public partial class ChangeProposal : ObservableObject
@@ -66,9 +67,12 @@ public FindingType FindingTypes
                 Rules.Count == 0 && (OriginalText != LanguageText || HasLayoutChange))
                 types |= FindingType.RuleBased;
             if (Rules.Any(r => r.Id == "local-judge")) types |= FindingType.Judge;
+            if (Rules.Any(r => r.Id == "languagetool")) types |= FindingType.Grammar;
             foreach (var note in ReviewNote.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
                 types |= note.StartsWith("MiniLM", StringComparison.Ordinal) ? FindingType.MiniLm :
-                    note.StartsWith("Gervásio", StringComparison.Ordinal) ? FindingType.Judge : FindingType.OtherReview;
+                    note.StartsWith("Gervásio", StringComparison.Ordinal) ? FindingType.Judge :
+                    note.StartsWith("LanguageTool", StringComparison.Ordinal) || note.StartsWith("Grammar:", StringComparison.Ordinal)
+                        ? FindingType.Grammar : FindingType.OtherReview;
             if (_edited != null) types |= FindingType.ManualEdit;
             return types == FindingType.None ? FindingType.OtherReview : types;
         }
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
index 258e013b..6de8b5f4 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
@@ -49,6 +49,9 @@
                                   Click="OnFindingFilterChanged" Margin="0,0,6,4" />
                     <ToggleButton x:Name="JudgeFilter" Content="Gervásio choices" IsChecked="True"
                                   Click="OnFindingFilterChanged" Margin="0,0,6,4" />
+                    <ToggleButton x:Name="GrammarFilter" Content="Grammar warnings" IsChecked="True"
+                                  Click="OnFindingFilterChanged" Margin="0,0,6,4"
+                                  ToolTip.Tip="Show LanguageTool grammar findings independently of other review warnings. Does not change which rules run or which corrections Apply includes." />
                     <ToggleButton x:Name="OtherReviewFilter" Content="Other review warnings" IsChecked="True"
                                   Click="OnFindingFilterChanged" Margin="0,0,6,4" />
                     <ToggleButton x:Name="ManualEditFilter" Content="Manual edits" IsChecked="True"
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
index 8443a119..720987c3 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml.cs
@@ -675,6 +675,7 @@ private void UpdateFindingFilters()
         {
             ("RuleBasedFilter", FindingType.RuleBased), ("MiniLmFilter", FindingType.MiniLm),
             ("JudgeFilter", FindingType.Judge), ("OtherReviewFilter", FindingType.OtherReview),
+            ("GrammarFilter", FindingType.Grammar),
             ("ManualEditFilter", FindingType.ManualEdit),
         })
             if (this.FindControl<ToggleButton>(name)!.IsChecked == true) enabled |= type;
diff --git a/se5/BrazilianToEuropeanPortuguese/README.md b/se5/BrazilianToEuropeanPortuguese/README.md
index a02a8ea8..75ae3ee1 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.md
@@ -1971,8 +1971,10 @@ its field when the row wraps. Batch configuration uses the full panel width.
   are escaped similarly to preserve round trips.
 
 - **Finding filters:** toggle **Rule-based changes**, **MiniLM warnings**,
-  **Gervásio choices**, **Other review warnings** and **Manual edits** to show or
-  hide matching rows. All five are on when the plugin opens. A row matching
+  **Gervásio choices**, **Grammar warnings**, **Other review warnings** and **Manual edits** to show or
+  hide matching rows. Grammar warnings include LanguageTool findings, separately
+  from other review warnings. This is a display filter, not a rule selection.
+  All six are on when the plugin opens. A row matching
   several types remains visible while any matching type is on. Filters survive
   settings/model-result refreshes and do not discard edits or change Apply
   selections. The summary shows visible/total rows; switching every type off
diff --git a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
index ec6d3605..8dc58cfe 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
@@ -2268,9 +2268,11 @@ painel.
   para preservar o texto ao guardar e reabrir.
 
 - **Filtros de resultados:** ative ou desative **Rule-based changes**,
-  **MiniLM warnings**, **Gervásio choices**, **Other review warnings** e
+  **MiniLM warnings**, **Gervásio choices**, **Grammar warnings**, **Other review warnings** e
   **Manual edits** para mostrar ou ocultar as linhas correspondentes.
-  Os cinco estão ativos quando o plugin abre. Uma linha de vários tipos
+  **Grammar warnings** mostra os resultados do LanguageTool separadamente dos
+  restantes avisos; filtra a apresentação, não as regras executadas.
+  Os seis estão ativos quando o plugin abre. Uma linha de vários tipos
   continua visível enquanto algum dos tipos correspondentes estiver ativo.
   Os filtros mantêm-se nas atualizações de definições/resultados dos
   modelos e não descartam edições nem alteram as seleções de **Apply**.

From 87d00618fb07beefc835d16537e01a74c1ec5b50 Mon Sep 17 00:00:00 2001
From: SMAP-git <333812182+SMAP-git@users.noreply.github.com>
Date: Wed, 11 Nov 2026 16:00:18 +0100
Subject: [PATCH 6/7] Place restrictive adverbs after recognised reflexive
 commands
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Normalize Só lembra-te to Lembra-te só and equivalent apenas/somente commands without moving adverbs in indicative, negative or subordinate uses. Reuse finite-clitic and imperative morphology, cover dialogue dashes and case, update the earlier exception tests and document the pt-PT rule. Verified episode S08E02 cue 659 through the published executable with all 902 cue IDs and timings preserved.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../BigCompareObjectTests.cs                  |  4 +-
 .../ReflexiveCoverageTests.cs                 |  2 +-
 .../RestrictiveCommandTests.cs                | 51 +++++++++++++++++++
 .../AttractedEnclisis.cs                      | 42 +++++++++++----
 se5/BrazilianToEuropeanPortuguese/README.md   | 12 +++++
 .../README.pt-PT.md                           | 12 +++++
 6 files changed, 109 insertions(+), 14 deletions(-)
 create mode 100644 se5/BrazilianToEuropeanPortuguese.Tests/RestrictiveCommandTests.cs

diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/BigCompareObjectTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/BigCompareObjectTests.cs
index 62743f36..2582b5ec 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/BigCompareObjectTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/BigCompareObjectTests.cs
@@ -379,8 +379,8 @@ public void WhatWentWrongKeepsTheImpersonalSubject()
     [InlineData("O único jeito de resolver.", "A única forma de resolver.")]
     [InlineData("Ele tem jeito para isso.", "Ele tem jeito para isso.")]
     [InlineData("Ela nunca devia ter pego o caso.", "Ela nunca devia ter pegado no caso.")]
-    [InlineData("Só lembre-se de mim.", "Só lembra-te de mim.")]
-    [InlineData("Só lembra-te de quem enfrentas.", "Só lembra-te de quem enfrentas.")]
+    [InlineData("Só lembre-se de mim.", "Lembra-te só de mim.")]
+    [InlineData("Só lembra-te de quem enfrentas.", "Lembra-te só de quem enfrentas.")]
     [InlineData("Ele só lembrou-se de mim.", "Ele só se lembrou de mim.")]
     [InlineData("Já disse-te a verdade.", "Já te disse a verdade.")]
     public void BlueBloodsLeftoversUseEuropeanConstructions(string input, string expected)
diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ReflexiveCoverageTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ReflexiveCoverageTests.cs
index 4db0ca3f..cff3ea5f 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/ReflexiveCoverageTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/ReflexiveCoverageTests.cs
@@ -90,7 +90,7 @@ public void RegularPronominalFamiliesUseSharedMechanics(string source, string ex
     [InlineData("Certo. Te digo.", "Certo. Digo-te.")]
     [InlineData("Te dou vinte minutos.", "Dou-te vinte minutos.")]
     [InlineData("Me deram um bolo.", "Deram-me um bolo.")]
-    [InlineData("-Só cala-te um minuto.", "-Só cala-te um minuto.")]
+    [InlineData("-Só cala-te um minuto.", "-Cala-te só um minuto.")]
     [InlineData("Sem escuta,\napenas sente-se com ele.", "Sem escuta,\napenas sente-se com ele.")]
     public void SharedPlacementCoversReflexiveReciprocalAndInherentPronouns(string source, string expected)
     {
diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/RestrictiveCommandTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/RestrictiveCommandTests.cs
new file mode 100644
index 00000000..42a22426
--- /dev/null
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/RestrictiveCommandTests.cs
@@ -0,0 +1,51 @@
+using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
+
+namespace BrazilianToEuropeanPortuguese.Tests;
+
+public sealed class RestrictiveCommandTests
+{
+    [Theory]
+    [InlineData("Só lembre-se quem\nvocê enfrenta.", "Lembra-te só quem\nenfrentas.")]
+    [InlineData("Só lembra-te quem enfrentas.", "Lembra-te só quem enfrentas.")]
+    [InlineData("Só lembra-te de mim.", "Lembra-te só de mim.")]
+    [InlineData("só lembra-te de mim.", "lembra-te só de mim.")]
+    [InlineData("SÓ LEMBRA-TE DE MIM.", "LEMBRA-TE SÓ DE MIM.")]
+    [InlineData("Só prepara-te para sair.", "Prepara-te só para sair.")]
+    [InlineData("Só concentra-te no trabalho.", "Concentra-te só no trabalho.")]
+    [InlineData("Só senta-te aqui.", "Senta-te só aqui.")]
+    [InlineData("Só veste-te depressa.", "Veste-te só depressa.")]
+    [InlineData("Só lava-te primeiro.", "Lava-te só primeiro.")]
+    [InlineData("Apenas lembra-te de mim.", "Lembra-te apenas de mim.")]
+    [InlineData("Somente lembra-te de mim.", "Lembra-te somente de mim.")]
+    [InlineData("-Só cala-te um minuto.", "-Cala-te só um minuto.")]
+    [InlineData("Joe, só lembra-te de mim.", "Joe, lembra-te só de mim.")]
+    [InlineData("Só\nlembra-te de mim.", "Lembra-te\nsó de mim.")]
+    public void RestrictiveAdverbsFollowKnownReflexiveCommands(string source, string expected)
+    {
+        var converter = new PortugueseConverter();
+        Assert.Equal(expected, converter.Convert(source));
+        Assert.Equal(expected, converter.Convert(expected));
+    }
+
+    [Theory]
+    [InlineData("Ele só lembrou-se de mim.", "Ele só se lembrou de mim.")]
+    [InlineData("Só lembras-te de mim.", "Só te lembras de mim.")]
+    [InlineData("Só lembrava-te disso.", "Só te lembrava disso.")]
+    [InlineData("Apenas lembraste-te disso.", "Apenas te lembraste disso.")]
+    [InlineData("Somente lembraste-te disso.", "Somente te lembraste disso.")]
+    [InlineData("Não te lembres disso.", "Não te lembres disso.")]
+    [InlineData("Disse que só lembra-te de mim.", "Disse que só lembra-te de mim.")]
+    [InlineData("Se só lembra-te de mim.", "Se só lembra-te de mim.")]
+    [InlineData("Só, lembra-te de mim.", "Só, lembra-te de mim.")]
+    [InlineData("Lembra-te só de mim.", "Lembra-te só de mim.")]
+    [InlineData("Eu só lembra-te de mim.", "Eu só te lembra de mim.")]
+    public void IndicativeNegationSubordinationAndScopeArePreserved(string source, string expected) =>
+        Assert.Equal(expected, AttractedEnclisis.Apply(source));
+
+    [Fact]
+    public void PronounSettingStillControlsTheCorrection()
+    {
+        var converter = new PortugueseConverter(new ConversionOptions(Pronouns: false, YouToTu: false));
+        Assert.Equal("Só lembra-te de mim.", converter.Convert("Só lembra-te de mim."));
+    }
+}
diff --git a/se5/BrazilianToEuropeanPortuguese/AttractedEnclisis.cs b/se5/BrazilianToEuropeanPortuguese/AttractedEnclisis.cs
index ac990c14..b72381af 100644
--- a/se5/BrazilianToEuropeanPortuguese/AttractedEnclisis.cs
+++ b/se5/BrazilianToEuropeanPortuguese/AttractedEnclisis.cs
@@ -10,7 +10,7 @@ internal static class AttractedEnclisis
     private const RegexOptions Ci = RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
 
     private const string Attractor =
-        "não|nunca|jamais|já|também|só|sempre|ainda|nem|talvez|que|quem|onde|aonde|quando|porque|como|enquanto|embora|caso|se|" +
+        "não|nunca|jamais|já|também|só|apenas|somente|sempre|ainda|nem|talvez|que|quem|onde|aonde|quando|porque|como|enquanto|embora|caso|se|" +
         "ninguém|alguém|tudo|nada";
 
     private const string Subject =
@@ -19,7 +19,7 @@ internal static class AttractedEnclisis
 
     // Only plain clitics: "-lo/-la/-no/-na" changed the verb form and are left alone.
     private static readonly Regex Enclitic = new(
-        @"(?<![\p{L}\p{M}-])(?<attr>" + Attractor + @")(?<gap>[ \t]+|[ \t]*\n[ \t]*)" +
+        @"(?:(?<![\p{L}\p{M}-])|(?<=^-)|(?<=\n-))(?<attr>" + Attractor + @")(?<gap>[ \t]+|[ \t]*\n[ \t]*)" +
         @"(?<subj>" + Subject + @"(?:[ \t]+|[ \t]*\n[ \t]*))?" +
         @"(?<adv>(?:(?:não|nunca|já|também|só|sempre|ainda)[ \t]+)*)" +
         @"(?<v>[\p{L}\p{M}]+)-(?<cl>me|te|se|lhe|lhes|nos|vos|o|a|os|as)(?![\p{L}\p{M}-])", Ci);
@@ -31,21 +31,37 @@ public static string Apply(string s)
         {
             var verb = m.Groups["v"].Value;
             var lower = verb.ToLowerInvariant();
+            var attr = m.Groups["attr"].Value.ToLowerInvariant();
+            var restrictive = attr is "só" or "apenas" or "somente";
             // After "se/quando/caso + subject" an infinitive-looking form is the future subjunctive: "se ele lembrar-se" → "se ele se lembrar".
             var futureSubjunctive = m.Groups["subj"].Success && PortugueseVerbs.IsInfinitive(lower) &&
                 m.Groups["attr"].Value.ToLowerInvariant() is "se" or "quando" or "caso" or "enquanto";
-            if (!PortugueseVerbs.IsKnownVerbForm(lower) && !futureSubjunctive || PortugueseVerbs.IsInfinitive(lower) && !futureSubjunctive ||
+            if (!(restrictive ? PortugueseVerbs.IsFiniteCliticForm(lower) : PortugueseVerbs.IsKnownVerbForm(lower)) && !futureSubjunctive || PortugueseVerbs.IsInfinitive(lower) && !futureSubjunctive ||
                 lower.EndsWith("ndo", StringComparison.Ordinal) || PortugueseVerbs.IsFutureOrConditional(lower)) return m.Value;
-            var attr = m.Groups["attr"].Value.ToLowerInvariant();
             // "se" alone may itself be a clitic, but not before another clitic: "Se faz-te sentir" can only be "if" → "Se te faz sentir".
             if (attr == "se" && !m.Groups["subj"].Success &&
                 (m.Groups["cl"].Value.Equals("se", StringComparison.OrdinalIgnoreCase) || m.Groups["adv"].Length > 0)) return m.Value;
-            if (!m.Groups["subj"].Success && IsAffirmativeImperative(s, m.Index, attr, lower, m.Groups["cl"].Value)) return m.Value;
+            if (!m.Groups["subj"].Success && IsAffirmativeImperative(s, m.Index, attr, lower, m.Groups["cl"].Value))
+            {
+                if (attr is "só" or "apenas" or "somente" &&
+                    m.Groups["cl"].Value.Equals("te", StringComparison.OrdinalIgnoreCase) && m.Groups["adv"].Length == 0)
+                {
+                    var command = verb + "-" + m.Groups["cl"].Value;
+                    var adverb = m.Groups["attr"].Value;
+                    if (char.IsUpper(adverb[0]))
+                    {
+                        command = char.ToUpperInvariant(command[0]) + command[1..];
+                        if (!adverb.All(char.IsUpper)) adverb = adverb.ToLowerInvariant();
+                    }
+                    return command + m.Groups["gap"].Value + adverb;
+                }
+                return m.Value;
+            }
             if (m.Groups["subj"].Success)
             {
                 var subject = m.Groups["subj"].Value.TrimEnd();
                 // A subject only sits between a subordinating word and its verb ("que a Linda disse"); "não ele" is not one.
-                if (attr is "não" or "nunca" or "jamais" or "já" or "também" or "só" or "sempre" or "ainda" or "nem" or "talvez" or
+                if (attr is "não" or "nunca" or "jamais" or "já" or "também" or "só" or "apenas" or "somente" or "sempre" or "ainda" or "nem" or "talvez" or
                     "ninguém" or "alguém" or "tudo" or "nada") return m.Value;
                 if (!PortugueseConverter.PronounRules.AfterSubordinateSubject(attr + " " + subject)) return m.Value;
             }
@@ -55,18 +71,22 @@ public static string Apply(string s)
         });
     }
 
-    // "Só lembra-te de mim" / "Só lembre-se de mim": an adverb opening the clause before a tu imperative keeps enclisis.
+    // Restrictive adverbs move after a recognised tu reflexive command; other adverbs retain their existing placement.
     private static bool IsAffirmativeImperative(string s, int index, string attr, string verb, string clitic)
     {
-        if (attr is not ("só" or "sempre" or "também" or "ainda" or "já")) return false;
+        if (attr is not ("só" or "apenas" or "somente" or "sempre" or "também" or "ainda" or "já")) return false;
         var you = clitic.Equals("se", StringComparison.OrdinalIgnoreCase);
         if (!you && !clitic.Equals("te", StringComparison.OrdinalIgnoreCase)) return false;
         var i = index - 1;
         while (i >= 0 && (s[i] == ' ' || s[i] == '\t' || s[i] == '"' || s[i] == '«')) i--;
         if (i >= 0 && ".!?…\n-—:;,".IndexOf(s[i]) < 0) return false;
-        if (verb.EndsWith("va", StringComparison.Ordinal) || verb.EndsWith("ia", StringComparison.Ordinal)) return false;
+        var regularImperative = verb.EndsWith('a') && PortugueseConverter.TuImperative.IsInfinitive(verb[..^1] + "ar") ||
+            verb.EndsWith('e') && (PortugueseConverter.TuImperative.IsInfinitive(verb[..^1] + "er") ||
+                PortugueseConverter.TuImperative.IsInfinitive(verb[..^1] + "ir"));
+        if (!regularImperative && (verb.EndsWith("va", StringComparison.Ordinal) || verb.EndsWith("ia", StringComparison.Ordinal))) return false;
         // "Só lembre-se" is the formal command that later becomes "Só lembra-te".
-        if (you) return PortugueseConverter.TuImperative.ToTu(verb) != null;
-        return PortugueseVerbs.TryThirdToSecond(verb, out var second) && second.Equals(verb + "s", StringComparison.OrdinalIgnoreCase);
+        if (you) return PortugueseConverter.TuImperative.ToTu(verb) != null || verb == "sente";
+        return regularImperative || PortugueseVerbs.TryThirdToSecond(verb, out var second) &&
+            second.Equals(verb + "s", StringComparison.OrdinalIgnoreCase);
     }
 }
diff --git a/se5/BrazilianToEuropeanPortuguese/README.md b/se5/BrazilianToEuropeanPortuguese/README.md
index 75ae3ee1..55428444 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.md
@@ -34,6 +34,18 @@ objects and vocabulary senses, natural dialogue constructions and interrogative
 accentuation. It adds regression coverage for these interactions while preserving
 subtitle cue timings and user-controlled rule options.
 
+### Restrictive adverbs with reflexive commands
+
+With **Pronoun placement** enabled, a recognised clause-initial affirmative
+*tu* reflexive command places restrictive *só/apenas/somente* after the
+verb-clitic group: *Só lembre-se quem você enfrenta* → *Lembra-te só quem
+enfrentas*, *Só prepara-te* → *Prepara-te só*. This preserves enclisis without
+leaving a preverbal proclisis attractor. It is not a blanket movement of *só*:
+indicatives retain proclisis (*só te lembras*, *ele só se lembrou*), and negation,
+subordination, existing postverbal adverbs and ambiguous formal address are not
+reinterpreted as informal commands. Existing complements are preserved.
+Source: [Ciberdúvidas: adverbs attracting proclisis](https://ciberduvidas.iscte-iul.pt/consultorio/perguntas/adverbios-que-atraem-os-pronomes-atonos-proclise/35696).
+
 ### Optional local grammar checking (experimental)
 
 LanguageTool is the grammar checker; its Portuguese rules include **European
diff --git a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
index 8dc58cfe..82b9c5bd 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
@@ -42,6 +42,18 @@ construções naturais de diálogo e a acentuação interrogativa. Acrescenta te
 de regressão destas interações, preservando os tempos das legendas e as opções
 de regras controladas pelo utilizador.
 
+### Advérbios restritivos com imperativos reflexivos
+
+Com **Pronoun placement** ativo, um imperativo afirmativo reflexivo de *tu*
+reconhecido no início da oração coloca *só/apenas/somente* depois do conjunto
+verbo-clítico: *Só lembre-se quem você enfrenta* → *Lembra-te só quem enfrentas*,
+*Só prepara-te* → *Prepara-te só*. Mantém-se a ênclise sem deixar antes do verbo
+um atrator de próclise. Não se desloca indiscriminadamente *só*: os indicativos
+mantêm a próclise (*só te lembras*, *ele só se lembrou*); negação, subordinação,
+advérbios já pós-verbais e tratamento formal ambíguo não são reinterpretados como
+ordens informais. Preservam-se os complementos existentes.
+Fonte: [Ciberdúvidas: advérbios atratores de próclise](https://ciberduvidas.iscte-iul.pt/consultorio/perguntas/adverbios-que-atraem-os-pronomes-atonos-proclise/35696).
+
 ### Verificação gramatical local (experimental e opcional)
 
 O LanguageTool é o verificador gramatical e já inclui regras de **português

From 6a228ba996a36e27d0730cd62fe2c8c30b4936af Mon Sep 17 00:00:00 2001
From: SMAP-git <333812182+SMAP-git@users.noreply.github.com>
Date: Wed, 11 Nov 2026 16:22:41 +0100
Subject: [PATCH 7/7] Correct injury result states and wrapped possessive
 articles

Preserve existing articles across subtitle line breaks and prefer guarded resultative ficar for anatomical injuries. Clarify that tested agreement fixes work with managed and external grammar checkers. Validated 5,475 tests and actual S08E02 cue 305 with IDs, timings and source preserved.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../InjuryStateTests.cs                       | 62 +++++++++++++++++++
 .../ReferenceTests.cs                         |  9 +++
 .../AutomaticGrammar.cs                       | 19 ++++++
 .../MainWindow.axaml                          | 12 ++--
 .../PortugueseConverter.cs                    | 14 ++---
 se5/BrazilianToEuropeanPortuguese/README.md   | 20 ++++++
 .../README.pt-PT.md                           | 19 ++++++
 7 files changed, 143 insertions(+), 12 deletions(-)
 create mode 100644 se5/BrazilianToEuropeanPortuguese.Tests/InjuryStateTests.cs

diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/InjuryStateTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/InjuryStateTests.cs
new file mode 100644
index 00000000..71ce60b9
--- /dev/null
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/InjuryStateTests.cs
@@ -0,0 +1,62 @@
+using SubtitleEdit.Plugins.BrazilianToEuropeanPortuguese;
+
+namespace BrazilianToEuropeanPortuguese.Tests;
+
+public sealed class InjuryStateTests
+{
+    [Theory]
+    [InlineData("a perna esquerda do\nmeu padrinho foi lesionada.", "a perna esquerda do\nmeu padrinho ficou lesionada.")]
+    [InlineData("A perna esquerda do meu padrinho foi lesionada.", "A perna esquerda do meu padrinho ficou lesionada.")]
+    [InlineData("O braço direito foi magoado.", "O braço direito ficou magoado.")]
+    [InlineData("As pernas foram lesionadas.", "As pernas ficaram lesionadas.")]
+    [InlineData("Os joelhos do meu pai foram feridos.", "Os joelhos do meu pai ficaram feridos.")]
+    [InlineData("A mão foi gravemente lesionada.", "A mão ficou gravemente lesionada.")]
+    [InlineData("O tornozelo foi ligeiramente magoado.", "O tornozelo ficou ligeiramente magoado.")]
+    [InlineData("As costas foram lesionadas no acidente.", "As costas ficaram lesionadas no acidente.")]
+    [InlineData("O pescoço foi lesionado.", "O pescoço ficou lesionado.")]
+    [InlineData("O tendão foi lesionado.", "O tendão ficou lesionado.")]
+    [InlineData("Os tendões foram lesionados.", "Os tendões ficaram lesionados.")]
+    public void AnatomicalInjuriesUseResultState(string source, string expected)
+    {
+        var converter = new PortugueseConverter();
+        Assert.Equal(expected, converter.Convert(source));
+        Assert.Equal(expected, converter.Convert(expected));
+    }
+
+    [Theory]
+    [InlineData("A perna foi lesionada pelo agressor.")]
+    [InlineData("A perna foi lesionada por uma bala.")]
+    [InlineData("A perna foi lesionada de propósito.")]
+    [InlineData("A perna foi lesionada intencionalmente.")]
+    [InlineData("O suspeito foi ferido.")]
+    [InlineData("A perna não foi lesionada.")]
+    [InlineData("A perna já estava lesionada.")]
+    [InlineData("As pernas foi lesionada.")]
+    [InlineData("A perna que foi lesionada.")]
+    [InlineData("A perna foi examinada.")]
+    [InlineData("A perna e o braço foram lesionados.")]
+    public void EventivePassivesNegationAndOtherMeaningsAreNotRewritten(string source) =>
+        Assert.Equal(source, AutomaticGrammar.Apply(source, ConversionOptions.Default));
+
+    [Theory]
+    [InlineData("a perna do\nmeu padrinho foi lesionada.", "a perna do\nmeu padrinho ficou lesionada.")]
+    [InlineData("a casa da\nminha irmã ficou bonita.", "a casa da\nminha irmã ficou bonita.")]
+    [InlineData("o carro dos\nmeus amigos chegou.", "o carro dos\nmeus amigos chegou.")]
+    [InlineData("estou no\nmeu quarto.", "estou no\nmeu quarto.")]
+    [InlineData("ela está na\nsua casa.", "ela está na\nsua casa.")]
+    [InlineData("olha para o\nmeu carro.", "olha para o\nmeu carro.")]
+    [InlineData("Ele falou do\nmeu bebé!", "Ele falou do\nmeu bebé!")]
+    public void WrappedPossessivesDoNotDuplicateExistingArticles(string source, string expected)
+    {
+        var converter = new PortugueseConverter();
+        Assert.Equal(expected, converter.Convert(source));
+        Assert.Equal(expected, converter.Convert(expected));
+    }
+
+    [Fact]
+    public void ColloquialOptionControlsResultativePreference()
+    {
+        var converter = new PortugueseConverter(new ConversionOptions(Colloquial: false));
+        Assert.Equal("A perna foi lesionada.", converter.Convert("A perna foi lesionada."));
+    }
+}
diff --git a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
index 46f52e51..8b5a03f3 100644
--- a/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
+++ b/se5/BrazilianToEuropeanPortuguese.Tests/ReferenceTests.cs
@@ -486,12 +486,21 @@ public void MainWindowAppliesReferenceToProposals()
             });
             Assert.True(grammarWindow.FindControl<CheckBox>("GrammarCheck")!.IsChecked);
             Assert.False(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.IsChecked);
+            Assert.True(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.IsVisible);
+            Assert.True(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.IsEnabled);
+            var grammarControls = Assert.IsType<StackPanel>(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.Parent);
+            Assert.True(grammarControls.Children.IndexOf(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!) <
+                grammarControls.Children.IndexOf(grammarWindow.FindControl<CheckBox>("GrammarExternalServer")!));
+            grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.IsChecked = true;
+            Assert.True(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.IsChecked);
             Assert.False(grammarWindow.FindControl<CheckBox>("GrammarExternalServer")!.IsChecked);
             Assert.False(grammarWindow.FindControl<TextBox>("GrammarServer")!.IsVisible);
             Assert.NotNull(grammarWindow.FindControl<Button>("DownloadGrammarButton"));
             Assert.NotNull(grammarWindow.FindControl<Button>("DownloadJavaButton"));
             grammarWindow.FindControl<CheckBox>("GrammarExternalServer")!.IsChecked = true;
             Assert.True(grammarWindow.FindControl<TextBox>("GrammarServer")!.IsVisible);
+            Assert.True(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.IsChecked);
+            Assert.True(grammarWindow.FindControl<CheckBox>("GrammarAutoFix")!.IsEnabled);
             Assert.Equal("http://languagetool:8010/", grammarWindow.FindControl<TextBox>("GrammarServer")!.Text);
             grammarWindow.ApplyCheckResults(new[] { new CheckLine(0, "Olá.", "Olá.", null, null) },
                 new Dictionary<int, CheckResult> { [0] = new("Olá.", "LanguageTool [TEST]: review only.") });
diff --git a/se5/BrazilianToEuropeanPortuguese/AutomaticGrammar.cs b/se5/BrazilianToEuropeanPortuguese/AutomaticGrammar.cs
index 522f4d98..69301454 100644
--- a/se5/BrazilianToEuropeanPortuguese/AutomaticGrammar.cs
+++ b/se5/BrazilianToEuropeanPortuguese/AutomaticGrammar.cs
@@ -48,6 +48,14 @@ internal static class AutomaticGrammar
     private static readonly Regex RequiredDe = new(
         @"(?<pre>^|[.!?]\s+)(?<subject>eu\s+|tu\s+|nós\s+|eles\s+|elas\s+)?(?<verb>gosto|gostas|gostamos|gostam|preciso|precisas|precisamos|precisam)" +
         @"\s+(?<det>o|a|os|as|um|uma|uns|umas)\s+(?!(?:pouco|bocado|bocadinho|que)\b)(?=\p{L})", Ci);
+    private static readonly Regex InjuryState = new(
+        @"(?<![\p{L}\p{M}-])(?<part>pernas?|braços?|mãos?|pés?|joelhos?|tornozelos?|ombros?|pulsos?|cotovelos?|" +
+        @"dedos?|costelas?|costas|anca|ancas|cabeça|pescoço|coluna|tendões|tendão|músculos?|ligamentos?)" +
+        @"(?<owner>(?:\s+(?:esquerd[oa]s?|direit[oa]s?))?" +
+        @"(?:\s+d(?:e|o|a|os|as)(?:\s+(?!(?:foi|foram|que|e|ou|não|nunca|já|também)\b)[\p{L}\p{M}]+){1,6})?)" +
+        @"(?<gap>\s+)(?<verb>foi|foram)(?<space>\s+)(?<degree>(?:(?:gravemente|ligeiramente|seriamente)\s+)?)" +
+        @"(?<injury>lesionad[oa]s?|magoad[oa]s?|ferid[oa]s?)" + Boundary +
+        @"(?!\s+(?:por|pel[oa]s?|de\s+propósito|intencionalmente|deliberadamente)\b)", Ci);
 
     private static Dictionary<string, string[]> BuildPluralForms()
     {
@@ -114,6 +122,17 @@ public static string Apply(string text, ConversionOptions options)
         }
         if (options.Colloquial)
         {
+            text = InjuryState.Replace(text, m =>
+            {
+                var part = m.Groups["part"].Value;
+                var plural = part.EndsWith("s", StringComparison.OrdinalIgnoreCase);
+                var injury = m.Groups["injury"].Value;
+                if (plural != m.Groups["verb"].Value.Equals("foram", StringComparison.OrdinalIgnoreCase) ||
+                    plural != injury.EndsWith("s", StringComparison.OrdinalIgnoreCase)) return m.Value;
+                return part + m.Groups["owner"].Value + m.Groups["gap"].Value +
+                    CaseHelper.MatchCase(m.Groups["verb"].Value, plural ? "ficaram" : "ficou") +
+                    m.Groups["space"].Value + m.Groups["degree"].Value + injury;
+            });
             text = TemporalPorHora.Replace(text, "${head} por agora");
             text = AtFront.Replace(text, "${v} à frente");
             text = ComeToMind.Replace(text, "${v} à mente");
diff --git a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
index 6de8b5f4..12beb96f 100644
--- a/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
+++ b/se5/BrazilianToEuropeanPortuguese/MainWindow.axaml
@@ -267,16 +267,18 @@
                             Click="OnDownloadJava" Margin="0,0,8,4"
                             ToolTip.Tip="Eclipse Temurin JRE 21.0.13+9, GPLv2 with Classpath Exception; pinned and SHA-256 verified. Plugin-private, no system installation." />
                 </WrapPanel>
+                <CheckBox x:Name="GrammarAutoFix"
+                          IsCheckedChanged="OnGrammarSettingChanged"
+                          ToolTip.Tip="Works with the downloaded checker and an external server alike. Off: suggestions only. On: only explicit ele/ela/eles/elas + tem/têm/vem/vêm, after English subject, meaning and grammar rechecks. Other findings remain review notes.">
+                    <TextBlock Text="Allow tested agreement fixes (requires English and MiniLM)" TextWrapping="Wrap" />
+                </CheckBox>
+                <TextBlock Text="Agreement fixes work with either checker mode; your own server is not required."
+                           TextWrapping="Wrap" Opacity="0.7" />
                 <CheckBox x:Name="GrammarExternalServer" Content="Use my own server instead (advanced)"
                           IsCheckedChanged="OnGrammarSettingChanged" />
                 <TextBox x:Name="GrammarServer" Watermark="http://127.0.0.1:8081/"
                          TextChanged="OnGrammarServerChanged"
                          ToolTip.Tip="Your self-hosted server URL. Text is sent to this server only. No automatic installation, cloud API or redirects." />
-                <CheckBox x:Name="GrammarAutoFix"
-                          IsCheckedChanged="OnGrammarSettingChanged"
-                          ToolTip.Tip="Off: suggestions only. On: only explicit ele/ela/eles/elas + tem/têm/vem/vêm, after English subject, meaning and grammar rechecks. Other findings remain review notes.">
-                    <TextBlock Text="Allow tested agreement fixes (requires English and MiniLM)" TextWrapping="Wrap" />
-                </CheckBox>
                 <TextBlock Text="Download both components once; Run checks starts and stops the local checker automatically. CPU only; no text generation. Suggestions stay review-only unless all automatic-fix safeguards pass."
                            TextWrapping="Wrap" Opacity="0.7" />
                 <WrapPanel>
diff --git a/se5/BrazilianToEuropeanPortuguese/PortugueseConverter.cs b/se5/BrazilianToEuropeanPortuguese/PortugueseConverter.cs
index 1e9c39a4..f3ac629a 100644
--- a/se5/BrazilianToEuropeanPortuguese/PortugueseConverter.cs
+++ b/se5/BrazilianToEuropeanPortuguese/PortugueseConverter.cs
@@ -4660,6 +4660,7 @@ private static bool IsThinkOfAs(Match m, string verb) =>
 
         private static string AddArticle(Match m)
         {
+            if (HasPreviousArticle(m)) return m.Value;
             var noun = m.Groups["n"].Value;
             if (noun is "Deus" or "deus" || !(IsVerbish(m.Groups["w1"].Value) || (m.Groups["w2"].Success && IsVerbish(m.Groups["w2"].Value) && !IsVerbish(noun))))
             {
@@ -4696,6 +4697,7 @@ private static string AddArticle(Match m)
 
         private static string AddExclaimedArticle(Match m)
         {
+            if (HasPreviousArticle(m)) return m.Value;
             var noun = m.Groups["n"].Value;
             if (Vocatives.Contains(noun) || char.IsUpper(noun[0]) && !CaseHelper.IsAllUpper(noun))
             {
@@ -4729,6 +4731,7 @@ private static string AddExclaimedArticle(Match m)
 
         private static string AddStartArticle(Match m)
         {
+            if (HasPreviousArticle(m)) return m.Value;
             // "Desculpa, tua mãe ligou": after an opening word, a family noun followed by a verb is the subject, not an address.
             var subjectAfterOpening = m.Groups["pre"].Value.TrimEnd().EndsWith(',') &&
                                       Regex.IsMatch(m.Result("$'"), @"^\s+(?:\p{Ll}+\s+)?(?:ligou|está|esteve|estava|quer|disse|chegou|veio|vem|vai|foi|é|era|tem|teve|precisa|pediu|perguntou|mandou|telefonou|morreu|saiu|ligou)" + NotWordAfter, Cs);
@@ -4744,13 +4747,6 @@ private static string AddStartArticle(Match m)
                 return m.Value;
             }
 
-            // "Além de aumentar o\nseu colesterol": the article is at the end of the previous line.
-            if (char.IsLower(m.Groups["poss"].Value[0]) &&
-                Regex.Match(m.Result("$`") + m.Groups["pre"].Value, @"(\p{L}+)\s*$").Groups[1].Value is { Length: > 0 } last && ArticleContractions.Contains(last))
-            {
-                return m.Value;
-            }
-
             var poss = m.Groups["poss"].Value;
             var article = ArticleFor(poss);
             return CaseHelper.IsAllUpper(poss)
@@ -4793,6 +4789,10 @@ private static string AddIntroductoryArticle(Match m)
             "o", "a", "os", "as", "no", "na", "nos", "nas", "do", "da", "dos", "das", "ao", "à", "aos", "às", "pelo", "pela", "pelos", "pelas",
         };
 
+        private static bool HasPreviousArticle(Match match) =>
+            Regex.Match(match.Result("$`") + match.Groups["pre"].Value, @"(\p{L}+)\s*$").Groups[1].Value
+                is { Length: > 0 } last && ArticleContractions.Contains(last);
+
         // "Diga a sua mãe" / "Conta a teu pai" → "Diga à sua mãe" / "Conta ao teu pai": "a" is the preposition before a person.
         private static readonly Regex DativePossessive = new(
             NotWordBefore + @"(?<v>diz|diga|digas|digam|dizer|disse|disseste|contar|conta|conte|contes|contou|perguntar|pergunta|pergunte|perguntes|perguntou|" +
diff --git a/se5/BrazilianToEuropeanPortuguese/README.md b/se5/BrazilianToEuropeanPortuguese/README.md
index 55428444..43dcb44f 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.md
@@ -48,6 +48,21 @@ Source: [Ciberdúvidas: adverbs attracting proclisis](https://ciberduvidas.iscte
 
 ### Optional local grammar checking (experimental)
 
+**Injury result states and wrapped possessives:** with **Colloquial** enabled,
+an anatomical subject with agentless past *foi/foram lesionado/magoado/ferido*
+uses resultative *ficou/ficaram*, preserving the injury term, number, owner,
+side and supported severity modifiers: *a perna esquerda do meu padrinho foi
+lesionada* → *a perna esquerda do meu padrinho ficou lesionada*. This is a
+naturalness preference, not a claim that every *ser* passive is ungrammatical.
+Explicit agents/causes introduced by *por/pelo*, intentional actions, negation,
+relative clauses and non-injury predicates are not rewritten. Existing
+*lesionada* is not replaced by *magoada*, which may describe a different severity.
+With **Pronoun placement**, possessive-article insertion also respects articles
+and contractions across wrapped lines (*do\nmeu padrinho*, not *do\no meu
+padrinho*).
+Sources: [resultative ficar](https://ciberduvidas.iscte-iul.pt/consultorio/perguntas/participios-passados-verbais-e-adjetivais/35876)
+and [possessive articles](https://ciberduvidas.iscte-iul.pt/consultorio/perguntas/regra-para-a-posicao-dos-pronomes-possessivos/29320).
+
 LanguageTool is the grammar checker; its Portuguese rules include **European
 Portuguese (`pt-PT`)**. You do not need to choose or download a separate grammar
 model. The **Reference subtitle and local models** panel is below the top-right
@@ -100,6 +115,11 @@ for example, `http://languagetool:8010/` on a private shared network. No contain
 or network settings are changed. See the
 [official server guide](https://dev.languagetool.org/http-server).
 
+**Allow tested agreement fixes** works in both managed-local and external-server
+modes. It is placed above the advanced server switch; an external server is not
+required. Enabled/installed MiniLM, aligned English and all existing safety gates
+are still required before an automatic correction is accepted.
+
 The pipeline is:
 
 1. Align available English and run the existing deterministic conversion rules.
diff --git a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
index 82b9c5bd..cf138932 100644
--- a/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
+++ b/se5/BrazilianToEuropeanPortuguese/README.pt-PT.md
@@ -56,6 +56,20 @@ Fonte: [Ciberdúvidas: advérbios atratores de próclise](https://ciberduvidas.i
 
 ### Verificação gramatical local (experimental e opcional)
 
+**Estados resultantes de lesões e possessivos entre linhas:** com **Colloquial**
+ativo, um sujeito anatómico com *foi/foram lesionado/magoado/ferido*, sem agente,
+passa a *ficou/ficaram*, preservando o termo da lesão, número, possuidor, lado e
+modificadores de gravidade reconhecidos: *a perna esquerda do meu padrinho foi
+lesionada* → *a perna esquerda do meu padrinho ficou lesionada*. É uma preferência
+de naturalidade, não uma afirmação de que todas as passivas com *ser* estão
+erradas. Preservam-se agentes/causas com *por/pelo*, ações intencionais, negação,
+orações relativas e outros predicados. Não se troca *lesionada* por *magoada*,
+que pode sugerir outra gravidade. Com **Pronoun placement**, a inserção de
+artigos possessivos respeita artigos e contrações na linha anterior:
+*do\nmeu padrinho*, nunca *do\no meu padrinho*.
+Fontes: [ficar resultativo](https://ciberduvidas.iscte-iul.pt/consultorio/perguntas/participios-passados-verbais-e-adjetivais/35876)
+e [artigos com possessivos](https://ciberduvidas.iscte-iul.pt/consultorio/perguntas/regra-para-a-posicao-dos-pronomes-possessivos/29320).
+
 O LanguageTool é o verificador gramatical e já inclui regras de **português
 europeu (`pt-PT`)**. Não precisa de escolher um modelo gramatical separado.
 O painel **Reference subtitle and local models** fica abaixo dos botões superiores
@@ -108,6 +122,11 @@ por exemplo, `http://languagetool:8010/`. O plugin não cria contentores nem alt
 a rede. Consulte o [guia oficial](https://dev.languagetool.org/http-server).
 As opções guardadas também se aplicam a **Batch convert**.
 
+**Allow tested agreement fixes** funciona com o verificador descarregado e com
+um servidor externo. Está acima da opção avançada: não exige servidor próprio.
+As correções continuam a exigir MiniLM instalado/ativo, inglês alinhado e todas
+as verificações de segurança existentes.
+
 A ordem de processamento é:
 
 1. Alinhar a referência inglesa disponível e executar as regras de conversão.