diff --git a/pyproject.toml b/pyproject.toml
index 02d4f00..e911c0d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -18,7 +18,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-dev = ["pytest>=8.0", "ruff>=0.5", "mypy>=1.10"]
+dev = ["pytest>=8.0", "ruff>=0.5,<0.16", "mypy>=1.10"]
 
 [build-system]
 requires = ["hatchling"]
diff --git a/src/trinity/adapters/drop.py b/src/trinity/adapters/drop.py
index 1314803..07fcbd4 100644
--- a/src/trinity/adapters/drop.py
+++ b/src/trinity/adapters/drop.py
@@ -130,9 +130,12 @@ def _maybe_unbox(segment: str) -> str:
     return boxed if boxed is not None else ""
 
 
-#: Surrounding punctuation stripped from a token, EXCLUDING the signs ``+``/``-`` — a
-#: leading sign is part of a number's value, not wrapping noise.
-_STRIP_EDGE = "".join(c for c in string.punctuation if c not in "+-")
+#: Surrounding punctuation stripped from a token, EXCLUDING the signs ``+``/``-`` and
+#: the decimal point ``.`` — a leading sign or decimal point is part of a number's
+#: value, not wrapping noise. A genuinely-trailing ``.`` (sentence period) is handled
+#: by the dedicated rstrip retry in :func:`_normalize_token`, which can tell it apart
+#: from a value-bearing leading point; a blanket edge-strip cannot.
+_STRIP_EDGE = "".join(c for c in string.punctuation if c not in "+-.")
 
 
 def _normalize_token(raw: str) -> str:
@@ -147,20 +150,27 @@ def _normalize_token(raw: str) -> str:
     dropped the ``-`` and left commas to break ``float()``) did not deliver.
 
     A token that is ALREADY a number is recognised before any punctuation is
-    stripped: the edge-strip set includes ``.``, so a leading-decimal token like
-    ``".5"`` would otherwise lose its point and normalize to ``"5.0"`` — equal to
-    a gold ``"5"`` (false positive) and unequal to the value-identical gold
-    ``"0.5"`` (false negative). The official DROP ``_remove_punc`` tests
-    ``_is_number`` first and leaves numbers untouched for exactly this reason."""
+    stripped: a leading-decimal token like ``".5"`` must not lose its point and
+    normalize to ``"5.0"`` — equal to a gold ``"5"`` (false positive) and unequal
+    to the value-identical gold ``"0.5"`` (false negative). The official DROP
+    ``_remove_punc`` tests ``_is_number`` first and leaves numbers untouched for
+    exactly this reason (issue #423). The float-first path alone only covers the
+    *bare* token: with ``.`` in the edge-strip set, wrapped forms like ``"$.5"``
+    and ``".5."`` still lost the leading point on the second-chance path. So the
+    edge strip excludes ``.`` entirely, and a genuinely-trailing period (``".5."``,
+    ``"16.."``) is retried with an explicit ``rstrip(".")`` — right-side dots are
+    sentence punctuation, left-side dots are value."""
     try:
         return str(float(raw.replace(",", "")))
     except ValueError:
         pass
     core = raw.strip(_STRIP_EDGE)
-    try:
-        return str(float(core.replace(",", "")))
-    except ValueError:
-        return _PUNCT.sub("", raw)
+    for cand in (core, core.rstrip(".")):
+        try:
+            return str(float(cand.replace(",", "")))
+        except ValueError:
+            continue
+    return _PUNCT.sub("", raw)
 
 
 def _split_internal_hyphens(token: str) -> list[str]:
diff --git a/src/trinity/orchestration/reward.py b/src/trinity/orchestration/reward.py
index 7192ef8..91879dc 100644
--- a/src/trinity/orchestration/reward.py
+++ b/src/trinity/orchestration/reward.py
@@ -1062,7 +1062,9 @@ def _strip_choice_font_wrappers(text: str) -> str:
 # sides of a single ``A-J``, and the ``(?<![\w*])`` / ``(?![\w*])`` guards keep it from
 # touching ``snake_case`` identifiers (``MAX_A_VAL``) or longer marker runs, so any text
 # that is not exactly ``<marker>LETTER<marker>`` is left byte-identical.
-_CHOICE_MD_EMPHASIS_RE = re.compile(r"(?<![\w*])(\*\*|\*|__|_|`)([A-Ja-j])\1(?![\w*])")
+_CHOICE_MD_EMPHASIS_RE = re.compile(
+    r"(?<![\w*])(\*\*\*|\*\*|\*|__|_|`)([A-Ja-j])\1(?![\w*])"
+)
 
 
 def _strip_choice_md_emphasis(text: str) -> str:
@@ -1117,6 +1119,10 @@ def _strip_choice_md_emphasis(text: str) -> str:
 # last match, in priority order, only when no committed-answer pattern matched.
 _FALLBACK_CHOICE_PATTERNS: tuple[re.Pattern[str], ...] = (
     re.compile(r"\boption\s*\(?\s*([A-J])(?![A-Za-z])", re.I),
+    # Bracketed letters (``[B]``) — common MMLU/GPQA final-answer spelling (#491).
+    re.compile(r"\[\s*([A-J])\s*\]", re.I),
+    # Chinese "answer" cue (fullwidth or ASCII colon).
+    re.compile(r"答案\s*[：:]\s*([A-J])(?![A-Za-z])", re.I),
     re.compile(r"^\s*\(?\s*([A-J])\s*[\).:]", re.M),
 )
 # Kept for anything that referenced the combined set (order = priority).
diff --git a/tests/test_reward_choice_letter_gaps.py b/tests/test_reward_choice_letter_gaps.py
new file mode 100644
index 0000000..a0581cc
--- /dev/null
+++ b/tests/test_reward_choice_letter_gaps.py
@@ -0,0 +1,22 @@
+"""Choice-letter gaps: [B], ***B***, 答案：B (issue #491)."""
+
+from trinity.orchestration.reward import extract_choice_letter, score_text
+
+
+def test_bracketed_choice_letter():
+    assert extract_choice_letter("[B]") == "B"
+    assert score_text("mmlu", "[B]", "B") == 1.0
+    assert score_text("mmlu", "[B]", "C") == 0.0
+
+
+def test_triple_star_md_emphasis():
+    assert extract_choice_letter("***B***") == "B"
+    assert score_text("mmlu", "***B***", "B") == 1.0
+    # existing double-star still works
+    assert extract_choice_letter("**B**") == "B"
+
+
+def test_chinese_answer_cue():
+    assert extract_choice_letter("答案：B") == "B"
+    assert extract_choice_letter("答案:C") == "C"
+    assert score_text("mmlu", "答案：B", "B") == 1.0