v0.1.15: detect and skip ACT-renamed encounters

Adds a "title-vs-combatants" heuristic that rejects uploads whose
encounter title doesn't match any enemy combatant in the fight —
the only signal we have that a user has manually renamed the
encounter in ACT (right-click → Rename Encounter), since ACT preserves
no original-title shadow, no rename flag, no audit trail of any kind
(confirmed empirically via a reflection sweep over EncounterData).

Without this gate, a user can rename a trash encounter to a boss name
and either auto-upload it (if uploads-enabled is on) or manually
right-click → "Upload to EQ2 Lexicon" — and pollute the boss
leaderboards on the site with what amounts to forged data. The
server-side enforcement (a follow-up PR in EQ2Lexicon-raids) is the
real defense; this client-side check is the friendly UX layer that
catches the casual case and tells the user why nothing uploaded.

Core
- EncounterTitle.MatchesAnEnemy(title, enemyNames) — case-insensitive,
  trims whitespace, permissive in both substring directions to
  handle EQ2's "Boss the Epithet" naming (ACT sometimes uses the
  short name; a user might append a note like "Pawbuster - take 2"
  to a legitimate name). Returns false on null/empty title or empty
  enemy list, so the gate fails CLOSED.
- 14 new tests covering exact match, both substring directions,
  multi-enemy fights, case-insensitivity, whitespace trim, the exact
  "TESTING" rename observed in the diagnostic session, empty input
  short-circuits, and null-element tolerance in the enemy list.

UI
- EncounterCapture.ProcessEncounter (auto path): runs the check after
  CaptureSnapshot. Failure → MarkProcessedNoCapture + OnSkipped with
  message "title '<X>' doesn't match any enemy — was this fight
  renamed in ACT?".
- Plugin.OnManualUploadRequested (manual right-click path): same
  check, same message phrasing scoped to "manual upload skipped".
- New EncounterCapture.EnumerateEnemyNames helper extracts the
  non-ally combatant names from a snapshot — single source of truth
  for both call sites.

Investigation residue
- All TEMPORARY DEBUG INSTRUMENTATION from the diagnostic-sweep
  iteration is removed. The reflection-based dump on every settled
  encounter, the "Dump diagnostic to event log" right-click item,
  and the OnDiag event are gone.

Full suite: 248 passing (was 234, +14). ruff … wait, this is the .NET
plugin: dotnet format clean, dotnet build clean, dotnet test clean,
no vulnerable packages.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: VortexUK

src/Core/EQ2Lexicon.ACTPlugin.Core.csproj

@@ -18,7 +18,7 @@
       Build metadata is mirrored from the UI csproj so this assembly's
       version tracks the user-facing plugin version.
     -->
-    <Version>0.1.14</Version>
+    <Version>0.1.15</Version>
     <Company>EQ2 Lexicon</Company>
     <Product>EQ2 Lexicon Uploader (Core)</Product>
     <Description>Pure payload / config / HTTP layer shared by EQ2Lexicon.ACTPlugin.</Description>

src/Core/EncounterTitle.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace EQ2Lexicon.ACTPlugin
 {
@@ -34,5 +35,58 @@ public static bool IsPlaceholder(string? title)
             return string.Equals(t, "Encounter", StringComparison.OrdinalIgnoreCase)
                 || string.Equals(t, "Unknown", StringComparison.OrdinalIgnoreCase);
         }
+
+        /// <summary>
+        /// True when <paramref name="title"/> appears as (or within) one
+        /// of the supplied enemy combatant names. The expected guarantee
+        /// is that ACT's auto-derived title for an encounter is always
+        /// the name of an enemy that was actually fought — so a title
+        /// that matches NO enemy is a strong signal the user manually
+        /// renamed the encounter via right-click → Rename Encounter in
+        /// ACT.
+        ///
+        /// Confirmed empirically (the diagnostic-dump session that led
+        /// to this code) that ACT preserves no original-title shadow,
+        /// no `Tags` marker, and no `HistoryRecord` audit field — every
+        /// title-bearing property mutates with the rename. The
+        /// combatant-list cross-check is the only signal we have.
+        ///
+        /// Matching is permissive in both directions to handle EQ2's
+        /// "Boss the Epithet" mob naming style:
+        ///   * exact (case-insensitive): "Pawbuster" == "Pawbuster"
+        ///   * title-is-substring-of-enemy: title "Pawbuster" matches
+        ///     enemy "Pawbuster the Crusher"
+        ///   * enemy-is-substring-of-title: title "Pawbuster (Wipe 1)"
+        ///     matches enemy "Pawbuster"
+        ///
+        /// Both directions are needed because:
+        ///   * ACT sometimes uses the short form ("Pawbuster") even
+        ///     when the EQ2 log gives the full epithet,
+        ///   * and a legitimate user note appended to the title
+        ///     ("Pawbuster - take 2") shouldn't trip the filter.
+        ///
+        /// Returns false when the title is null/whitespace, or when
+        /// <paramref name="enemyNames"/> is empty (no enemies = nothing
+        /// to compare against, treat as suspect).
+        ///
+        /// Whitespace at the edges is trimmed on both sides before
+        /// comparing — copy-pasted-with-trailing-space titles shouldn't
+        /// false-positive.
+        /// </summary>
+        public static bool MatchesAnEnemy(string? title, IEnumerable<string?>? enemyNames)
+        {
+            if (string.IsNullOrWhiteSpace(title)) return false;
+            if (enemyNames == null) return false;
+            var t = title.Trim();
+            foreach (var name in enemyNames)
+            {
+                if (string.IsNullOrWhiteSpace(name)) continue;
+                var n = name.Trim();
+                if (n.Equals(t, StringComparison.OrdinalIgnoreCase)) return true;
+                if (n.IndexOf(t, StringComparison.OrdinalIgnoreCase) >= 0) return true;
+                if (t.IndexOf(n, StringComparison.OrdinalIgnoreCase) >= 0) return true;
+            }
+            return false;
+        }
     }
 }

src/EQ2Lexicon.ACTPlugin.csproj

@@ -22,7 +22,7 @@
     <ActInstallDir Condition="'$(ActInstallDir)' == ''">C:\Program Files (x86)\Advanced Combat Tracker</ActInstallDir>
 
     <!-- Build metadata shown in ACT's plugin list -->
-    <Version>0.1.14</Version>
+    <Version>0.1.15</Version>
     <Company>EQ2 Lexicon</Company>
     <Product>EQ2 Lexicon Uploader</Product>
     <Description>Uploads ACT-parsed encounters to the EQ2 Lexicon site.</Description>

src/EncounterCapture.cs

@@ -209,12 +209,53 @@ private void MarkProcessedNoCapture(string encid)
         // exercise it without ACT installed. Both the polling path
         // above and Plugin.OnManualUploadRequested call into it.
 
+        /// <summary>
+        /// Yields every combatant name in <paramref name="snap"/> that
+        /// isn't in AllyNames — i.e. the enemies fought during the
+        /// encounter. Used by the rename-detection gate (both auto and
+        /// manual paths) to cross-reference the title against actual
+        /// participants. Lives here rather than in Core because the
+        /// snapshot DTO already lives in Core and we want a single
+        /// canonical enemy filter that both call sites share.
+        /// </summary>
+        public static IEnumerable<string> EnumerateEnemyNames(EncounterSnapshot snap)
+        {
+            if (snap?.Combatants == null) yield break;
+            foreach (var c in snap.Combatants)
+            {
+                if (c == null) continue;
+                if (string.IsNullOrWhiteSpace(c.Name)) continue;
+                if (snap.AllyNames != null && snap.AllyNames.Contains(c.Name)) continue;
+                yield return c.Name;
+            }
+        }
+
         private void ProcessEncounter(EncounterData enc, string encid)
         {
             // Snapshot the ACT state THEN build the payload — keeps the
             // ACT-coupled extraction separate from the pure transformation
             // so the latter is unit-testable.
             var snapshot = CaptureSnapshot(enc);
+
+            // Rename-detection gate: ACT's right-click → Rename Encounter
+            // mutates EncounterData.Title with no audit trail (no
+            // OldTitle, no Tags marker, no HistoryRecord original —
+            // confirmed empirically via reflection dump). A title that
+            // doesn't appear in any enemy combatant's name is a strong
+            // signal someone retitled the fight, and uploading it would
+            // pollute the boss rankings on the site. The check lives
+            // here (not Poll) because it needs the snapshot's
+            // AllyNames set to identify enemies. See
+            // EncounterTitle.MatchesAnEnemy for the matching rules.
+            var enemyNames = EnumerateEnemyNames(snapshot);
+            if (!EncounterTitle.MatchesAnEnemy(snapshot.Title, enemyNames))
+            {
+                MarkProcessedNoCapture(encid);
+                OnSkipped?.Invoke(
+                    $"skipped ({encid}: title '{snapshot.Title}' doesn't match any enemy — was this fight renamed in ACT?)");
+                return;
+            }
+
             var payload = PayloadBuilder.BuildPayload(
                 ActHelpers.GetLoggingCharacterName(),
                 ActHelpers.GetLoggingServerName(),

src/Plugin.cs

@@ -391,6 +391,26 @@ private void OnManualUploadRequested(EncounterData enc)
             {
                 var snapshot = EncounterCapture.CaptureSnapshot(enc);
                 title = snapshot.Title;
+
+                // Rename-detection gate — mirrors the polling path.
+                // ACT's right-click → Rename Encounter mutates Title
+                // with no audit trail, so a title that doesn't appear
+                // in any enemy combatant is the only signal we have
+                // that the user retitled the fight. Block here too:
+                // the manual upload path skips the blacklist + the
+                // upload-enabled toggle, but a deliberate rename is
+                // a different category — clearly the user typed
+                // something, and uploading it would mislabel the parse
+                // on the site.
+                var enemyNames = EncounterCapture.EnumerateEnemyNames(snapshot);
+                if (!EncounterTitle.MatchesAnEnemy(title, enemyNames))
+                {
+                    var msg = $"manual upload skipped (title '{title}' doesn't match any enemy — looks renamed in ACT)";
+                    _settingsPanel.SetUploadStatus(msg, success: false);
+                    _eventLog?.Log(EventSeverity.Warning, "upload", msg);
+                    return;
+                }
+
                 var payload = PayloadBuilder.BuildPayload(
                     ActHelpers.GetLoggingCharacterName(),
                     ActHelpers.GetLoggingServerName(),

tests/EQ2Lexicon.ACTPlugin.Tests/EncounterTitleTests.cs

@@ -41,5 +41,80 @@ public void IsPlaceholder_FalseForRealMobNames(string title)
         {
             Assert.False(EncounterTitle.IsPlaceholder(title));
         }
+
+        // ── MatchesAnEnemy ─────────────────────────────────────────────────
+        //
+        // Heuristic detector for "user renamed this encounter in ACT".
+        // ACT's right-click → Rename Encounter literally just assigns to
+        // EncounterData.Title and leaves no audit trail (confirmed
+        // empirically via reflection — every title-bearing property
+        // mutates together). The only signal we have is that an
+        // auto-derived title always matches an actual enemy combatant
+        // in the fight; a rename usually doesn't.
+
+        [Theory]
+        [InlineData("Pawbuster", "Pawbuster")]                         // exact match
+        [InlineData("pawbuster", "Pawbuster")]                         // case-insensitive
+        [InlineData("  Pawbuster  ", "Pawbuster")]                     // trim both sides
+        [InlineData("Pawbuster", "Pawbuster the Crusher")]             // title is substring of enemy (EQ2 epithet)
+        [InlineData("Pawbuster the Crusher", "Pawbuster")]             // enemy is substring of title (ACT short-name)
+        [InlineData("a krait patriarch", "a krait patriarch")]         // EQ2 lowercase article-prefixed name
+        [InlineData("Pawbuster (Wipe 1)", "Pawbuster")]                // user-appended note still passes
+        public void MatchesAnEnemy_TrueForRealisticAutoTitles(string title, string enemyName)
+        {
+            Assert.True(EncounterTitle.MatchesAnEnemy(title, new[] { enemyName }));
+        }
+
+        [Fact]
+        public void MatchesAnEnemy_TrueWhenAnyEnemyInListMatches()
+        {
+            // Multi-enemy fight — title only needs to match ONE of them.
+            // Mirrors a boss + adds encounter where the title is the boss
+            // and the adds are also in the combatant list.
+            var enemies = new[] { "an adder", "a wisp", "Pawbuster the Crusher" };
+            Assert.True(EncounterTitle.MatchesAnEnemy("Pawbuster", enemies));
+        }
+
+        [Theory]
+        [InlineData("TESTING", "a krait patriarch")]       // user renamed to "TESTING" — the diagnostic-session smoking gun
+        [InlineData("Pawbuster", "a brain magnate")]       // title is a real boss but the fight was something else
+        [InlineData("dps test", "training dummy")]         // user labelling a parse run
+        public void MatchesAnEnemy_FalseWhenTitleIsClearlyRenamed(string title, string enemyName)
+        {
+            Assert.False(EncounterTitle.MatchesAnEnemy(title, new[] { enemyName }));
+        }
+
+        [Fact]
+        public void MatchesAnEnemy_FalseForEmptyTitle()
+        {
+            // Empty / whitespace title shouldn't be considered a match
+            // even if there's an empty-string enemy in the list. Belt-
+            // and-brace — Plugin already filters placeholder titles via
+            // IsPlaceholder before this check ever runs, but a future
+            // call site might not.
+            Assert.False(EncounterTitle.MatchesAnEnemy("", new[] { "Pawbuster" }));
+            Assert.False(EncounterTitle.MatchesAnEnemy("   ", new[] { "Pawbuster" }));
+            Assert.False(EncounterTitle.MatchesAnEnemy(null, new[] { "Pawbuster" }));
+        }
+
+        [Fact]
+        public void MatchesAnEnemy_FalseWhenNoEnemiesProvided()
+        {
+            // Caller must pass at least one enemy name for the heuristic
+            // to mean anything. No enemies = nothing to compare against —
+            // treat as "doesn't match" so the upload is gated.
+            Assert.False(EncounterTitle.MatchesAnEnemy("Pawbuster", System.Array.Empty<string>()));
+            Assert.False(EncounterTitle.MatchesAnEnemy("Pawbuster", new string?[] { null, "" }));
+            Assert.False(EncounterTitle.MatchesAnEnemy("Pawbuster", null));
+        }
+
+        [Fact]
+        public void MatchesAnEnemy_SkipsNullAndEmptyEnemyEntries()
+        {
+            // A mix of legit + junk entries — the real ones still drive
+            // the answer; null / whitespace shouldn't false-positive.
+            var enemies = new string?[] { null, "  ", "", "Pawbuster the Crusher" };
+            Assert.True(EncounterTitle.MatchesAnEnemy("Pawbuster", enemies));
+        }
     }
 }