fix(i18n): 否定识别的作用域 —— 屏蔽词、后置锚点、小句边界、日语丁宁体

来自一轮主动扫描 + Codex 两条 P2，五处都逐条对 origin/main 复核过、每处都做了
删除变异验证。全是「把意思读**反**」而不是「读不出来」的那类：

1. `個別難過 / 區別開心` 判成 neutral —— 相邻否定把 `別` 当否定词，可它同时是
   十来个常用词的后半。启发式那侧早有一张屏蔽表，现在两侧共用（新 helper
   `_strip_negation_blocklist`）。
2. `難過哭不出來@0.9` 判成 neutral —— 整标签兜底把 `難過哭` 整段模糊匹配成一个
   写错的情绪词。后置否定只能否定**紧挨着它**的那个词（`_marker_attaches_to_head`）。
3. `sino que estoy feliz / estoy muy bueno y feliz` 整句情绪被吞 —— 宽回看那张表
   的拉丁词条靠补空格伪造词边界，只挡住一侧，`no ` 于是命中 `sino ` / `bueno `。
   拉丁词条改走真词边界，CJK 词条留在子串匹配（那里没有词边界可找）。
4. `não triste, feliz / not sad but happy` 判成 neutral —— 三条「整标签」分支都把
   标签当一句读。标点和转折连词是同一个边界，`_last_clause_cut` 统一收口；
   后置那条仍用更精确的 `_alias_after`（`我笑不起來，其實真的開心不起來` 带逗号
   但确实该否）。
5. `興奮していません` 判成 happy —— 逐匹配要求后缀紧贴别名，只收结尾的 `ません`
   对不上中间的 `してい`。丁宁体复合形态整条收；动词 te 形一条没加，因为别名表里
   没有能接它的词。

新增 62 条用例（每条都跑两种 confidence —— 端点传的是高置信度那条路径），
11 处变异逐个验红。

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: wehos

config/prompts/prompts_emotion.py

@@ -755,8 +755,16 @@ def get_heuristic_contrast_conjunctions_flat() -> tuple:
     # 别名表里没有这些词所以不冲突；将来若加，它会被自己的 `ない` 灭掉。
     # 另外 `_has_heuristic_negation_after` 是从关键词末尾紧贴锚定的，所以
     # `可愛` 后面跟的是 `くない` 而不是 `ない` —— 两个都要收。
+    # ⚠️ 逐匹配那条判定要求后缀**紧贴**别名（从别名末尾 `startswith`），所以丁宁体
+    # 不能只收结尾的 `ません` —— `興奮していません` 里别名后面接的整段是
+    # `していません`，中间隔着的 `してい` 不在表里就一个都对不上。复合形态要整条收。
+    # 反过来，只有**别名能直接接**的形态才值得收：动词 te 形（`ていません` 等）这里
+    # 一条都没有，因为别名表里没有能接它的词。每条都用删除变异验过是活的。
     'ja': ('くない', 'くなかった', 'じゃない', 'ではない', 'じゃなかった',
-           'ではありません', 'しない', 'していない', 'してない', 'ません', 'ない'),
+           'ではありません', 'じゃありません',
+           'しない', 'していない', 'してない',
+           'していません', 'してません', 'しておりません', 'しません',
+           'ません', 'ない'),
     'ko': ('지 않', '지않', '지 않아', '지않아', '지 않다', '지않다', '지 않음', '지않음',
            '지 못', '지못', '지 못해', '지못해', '지 못하다', '지못하다',
            '않', '않아', '않다', '않음', '아냐', '아니야', '아니다', '아닌', '아님'),

main_routers/system_router/emotion.py

@@ -191,6 +191,19 @@ def _looks_like_emotion_compact_candidate(candidate, cutoff):
     ))
 
 
+def _strip_negation_blocklist(text):
+    """Drop the words that merely *contain* a negation character.
+
+    Removed rather than blanked: both callers compare against the end of a
+    fixed-width window, so leaving spaces behind pushes a real negation out of
+    it -- `別特別開心` would become `別  ` and read as un-negated.
+    """
+    for phrase in _HEURISTIC_NEGATION_BLOCKLIST:
+        if phrase and phrase in text:
+            text = text.replace(phrase, '')
+    return text
+
+
 def _alias_after(compact_text, position):
     """Whether any emotion alias appears at or after `position`.
 
@@ -203,9 +216,49 @@ def _alias_after(compact_text, position):
     return any(alias and alias in tail for alias in _EMOTION_COMPACT_ALIAS_LOOKUP)
 
 
+def _marker_attaches_to_head(head):
+    """Whether a postposed negation is denying the emotion word right before it.
+
+    `難過哭不出來` is sad: the marker denies the crying, and the sadness is the
+    reason. The fuzzy test alone read the whole of `難過哭` as one misspelt
+    emotion word and answered the opposite. So when the head does contain an
+    emotion word, that word has to be the thing the marker sits against; a head
+    with none is still handed to the fuzzy test, which is what it was for.
+    """
+    present = [alias for alias in _EMOTION_COMPACT_ALIAS_LOOKUP if alias and alias in head]
+    return any(head.endswith(alias) for alias in present) if present else True
+
+
+def _last_clause_cut(head):
+    """Index of the last thing in `head` that ends a clause, or -1 for none.
+
+    Punctuation or a contrast conjunction, whichever comes later. Both mark the
+    same thing for our purposes: what precedes it is being left behind.
+    """
+    cut = max((head.rfind(delim) for delim in _HEURISTIC_CLAUSE_DELIMITERS), default=-1)
+    for conjunction in _HEURISTIC_CONTRAST_CONJUNCTIONS:
+        found = head.rfind(conjunction)
+        if found >= 0:
+            cut = max(cut, found + len(conjunction) - 1)
+    return cut
+
+
 def _has_negated_emotion_phrase(normalized_text, compact_text, fuzzy_compact_cutoff):
     tokens = [token for token in _EMOTION_TOKEN_RE.findall(normalized_text) if token]
-    if tokens and any(token in _EMOTION_NEGATION_WORDS for token in tokens):
+    # The two branches below answer for the WHOLE label off a single negation at
+    # its front, so they may only speak for a label that *is* one clause. Both
+    # read `não triste, feliz` as one run -- the negation dropped and the rest
+    # glued into `tristefeliz`, which scores close enough to `triste` at the
+    # confidence the endpoint passes -- and returned neutral, so the label named
+    # the emotion it was asserting and got nothing. Past a clause break the
+    # per-match scan is the one that can answer; it looks at each alias on its
+    # own. (The postposed loop further down is scoped by `_alias_after` instead,
+    # which is sharper: `我笑不起來，其實真的開心不起來` has a comma and still has
+    # to be vetoed.)
+    single_clause = _last_clause_cut(normalized_text) < 0
+    if tokens and single_clause and any(
+        token in _EMOTION_NEGATION_WORDS for token in tokens
+    ):
         remaining_compact = re.sub(
             r"[\W_]+",
             "",
@@ -216,7 +269,7 @@ def _has_negated_emotion_phrase(normalized_text, compact_text, fuzzy_compact_cut
             return True
 
     for negation in _EMOTION_NEGATION_COMPACT_PREFIXES:
-        if not compact_text.startswith(negation):
+        if not single_clause or not compact_text.startswith(negation):
             continue
         rest = compact_text[len(negation):]
         if len(negation) == 1:
@@ -243,7 +296,7 @@ def _has_negated_emotion_phrase(normalized_text, compact_text, fuzzy_compact_cut
             # emotion and asserts the second, and vetoing here would report the
             # denial as the answer. A marker that negates one word among several
             # is handled per match in the alias scan below instead.
-            if _looks_like_emotion_compact_candidate(
+            if _marker_attaches_to_head(head) and _looks_like_emotion_compact_candidate(
                 head, fuzzy_compact_cutoff
             ) and not _alias_after(compact_text, marker_index + len(negation)):
                 return True
@@ -285,7 +338,14 @@ def _normalize_emotion_label(raw_emotion, raw_confidence=None):
         return "neutral"
 
     def _is_negated_ascii_match(match_start):
-        prefix_tokens = _EMOTION_TOKEN_RE.findall(normalized_text[:match_start])
+        # Three tokens of lookback is generous enough to cross a clause: `não
+        # triste, feliz` and `not sad but happy` both name the emotion they are
+        # asserting *after* the one they deny, and the denial reached forward and
+        # cancelled it. So stop at whichever comes last — punctuation or a
+        # contrast conjunction. The compact path already scopes this way; the
+        # ASCII one never did.
+        head = normalized_text[:match_start]
+        prefix_tokens = _EMOTION_TOKEN_RE.findall(head[_last_clause_cut(head) + 1:])
         return any(token in _EMOTION_NEGATION_WORDS for token in prefix_tokens[-3:])
 
     # Where each compact character came from, so a clause boundary can be found in
@@ -315,7 +375,11 @@ def _current_clause(match_start):
         return prefix[len(prefix) - min(len(prefix), kept):]
 
     def _is_negated_compact_match(match_start):
-        prefix = _current_clause(match_start)
+        # The blocklist goes first, before anything measures this window: `別` is
+        # a negation on its own but only a syllable inside `個別` / `區別`, and the
+        # adjacency test below cannot tell them apart -- it read `個別難過` as
+        # "don't be sad" and answered neutral.
+        prefix = _strip_negation_blocklist(_current_clause(match_start))
         peeled = _strip_degree_adverbs(prefix)
         adverbs = len(prefix) - len(peeled)
         # A negation adjacent to the alias still counts, as long as it reaches
@@ -456,6 +520,23 @@ def _coerce_emotion_confidence(raw_confidence, default=0.5):
 _HEURISTIC_NEGATION_TOKENS = get_heuristic_negation_tokens_flat()
 
 
+# The Latin entries in that table carry padding spaces to fake a word boundary,
+# which only works on one side: `no ` also matches inside `sino ` / `bueno ` /
+# `uno `, so `sino que estoy feliz` came back with no emotion at all. Match those
+# on real boundaries instead and leave the CJK entries on the substring path,
+# where there are no word boundaries to find.
+_HEURISTIC_ASCII_NEGATION_RE = re.compile(
+    r"\b(?:%s)\b" % "|".join(
+        re.escape(token.strip())
+        for token in sorted(_HEURISTIC_NEGATION_TOKENS, key=len, reverse=True)
+        if token.strip() and token.isascii()
+    )
+)
+_HEURISTIC_CJK_NEGATION_TOKENS = tuple(
+    token for token in _HEURISTIC_NEGATION_TOKENS if not token.isascii()
+)
+
+
 _HEURISTIC_TIGHT_NEGATION_TOKENS = get_heuristic_tight_negation_tokens_flat()
 
 
@@ -517,7 +598,9 @@ def _has_heuristic_negation_before(text_value, position):
             # `別特別開心` would become `別  ` and read as un-negated.
             sanitized = sanitized.replace(phrase, '')
     # 5) 多字否定 token（宽 lookback）
-    if any(token in sanitized for token in _HEURISTIC_NEGATION_TOKENS):
+    if any(token in sanitized for token in _HEURISTIC_CJK_NEGATION_TOKENS):
+        return True
+    if _HEURISTIC_ASCII_NEGATION_RE.search(sanitized):
         return True
     # 5.5) 情态复合否定（`不會 / 不算 / 不再 / 未必`）：这些词只有紧贴情绪词时
     #      才是在否定它 —— 放进上面那张宽回看表会否定同一小句里**另一个**谓语

tests/unit/test_emotion_zh_tw.py

@@ -1034,3 +1034,151 @@ def test_portuguese_spanish_and_contracted_english_negation(label, confidence):
     neither half was ever a negation.
     """
     assert _label(label, confidence) == "neutral"
+
+
+# --- 否定识别的三处反转（来自主动扫描，逐条对 origin/main 复核过） ---
+
+
+@pytest.mark.parametrize("confidence", CONFIDENCES)
+@pytest.mark.parametrize("label, expected", [
+    ("個別難過", "sad"),
+    ("个别难过", "sad"),
+    ("區別開心", "happy"),
+    ("区别开心", "happy"),
+    ("分別很開心", "happy"),
+    ("特別開心", "happy"),
+    ("差別很大很開心", "happy"),
+    ("送別難過", "sad"),
+])
+def test_a_negation_syllable_inside_a_word_is_not_a_negation(label, expected, confidence):
+    """The imperative negator is also the second half of a dozen common words.
+
+    The adjacency test could not tell them apart, so a label built out of one of
+    those words came back as the denial of the emotion it was asserting -- the
+    worst answer available. The heuristic side already kept a blocklist for
+    exactly this; both sides read it now.
+    """
+    assert _label(label, confidence) == expected
+
+
+@pytest.mark.parametrize("confidence", CONFIDENCES)
+@pytest.mark.parametrize("label", ["別難過", "別太開心", "不特別開心", "别难过"])
+def test_the_bare_imperative_negation_still_negates(label, confidence):
+    """The other half of the above: removing the blocklist word must not remove
+    a negation that was really there."""
+    assert _label(label, confidence) == "neutral"
+
+
+@pytest.mark.parametrize("confidence", CONFIDENCES)
+@pytest.mark.parametrize("label, expected", [
+    ("難過哭不出來", "sad"),
+    ("难过哭不出来", "sad"),
+    ("傷心哭不出來", "sad"),
+    ("難過到笑不出來", "sad"),
+])
+def test_a_postposed_marker_denies_the_word_it_sits_against(label, expected, confidence):
+    """"So sad I can't even cry" is sad, and the marker is about the crying.
+
+    The whole-label veto fuzzy-matched the entire run before the marker as one
+    misspelt emotion word, which at the confidence the endpoint passes scored
+    high enough to answer neutral. Only reachable at high confidence, which is
+    why the parameterisation over confidences is not decorative.
+    """
+    assert _label(label, confidence) == expected
+
+
+@pytest.mark.parametrize("confidence", CONFIDENCES)
+@pytest.mark.parametrize("label", [
+    "開心不起來", "我難過不起來", "我笑不起來，其實真的開心不起來", "开心不起来",
+])
+def test_a_postposed_marker_still_vetoes_the_word_it_does_sit_against(label, confidence):
+    assert _label(label, confidence) == "neutral"
+
+
+@pytest.mark.parametrize("text", [
+    "sino que estoy feliz",
+    "estoy muy bueno y feliz",
+    "casino night, I am happy",
+    "not only happy",
+])
+def test_a_latin_word_that_ends_in_a_negation_is_not_a_negation(text):
+    """The Latin entries pad themselves with a space to fake a word boundary.
+
+    That only guards one side, so every Spanish or Portuguese word ending in
+    those two letters -- sino, bueno, uno -- silently swallowed the writer's
+    emotion. Real boundaries on the Latin entries; the CJK ones stay on the
+    substring path, where there are no boundaries to find.
+    """
+    from main_routers.system_router.emotion import _infer_emotion_from_text
+
+    assert _infer_emotion_from_text(text)[0] is not None
+
+
+@pytest.mark.parametrize("text", [
+    "no estoy feliz", "nunca feliz", "nao estou feliz", "I am not happy",
+    "cannot be happy", "I don't feel happy", "not angry at all",
+])
+def test_latin_negations_still_negate(text):
+    from main_routers.system_router.emotion import _infer_emotion_from_text
+
+    assert _infer_emotion_from_text(text)[0] is None
+
+
+# --- 否定的作用域：小句边界与日语丁宁体 ---
+
+
+@pytest.mark.parametrize("confidence", CONFIDENCES)
+@pytest.mark.parametrize("label", [
+    "興奮していません", "憤怒していません", "傷心していません",
+    "興奮しておりません", "興奮してません", "興奮しません",
+    "興奮していない", "興奮してない", "興奮しない",
+    "興奮ではありません", "興奮じゃありません", "嬉しくありません",
+])
+def test_japanese_polite_negation_is_recognised(label, confidence):
+    """The polite forms put three or four kana between the word and the ending.
+
+    The per-match test anchors the marker to the end of the alias, so a table
+    holding only the tail matched nothing at all -- the label came back as the
+    emotion it was denying. Composed forms go in whole.
+    """
+    assert _label(label, confidence) == "neutral"
+
+
+@pytest.mark.parametrize("confidence", CONFIDENCES)
+@pytest.mark.parametrize("label, expected", [
+    ("não triste, feliz", "happy"),
+    ("não triste mas feliz", "happy"),
+    ("no triste, feliz", "happy"),
+    ("no triste pero feliz", "happy"),
+    ("not sad, happy", "happy"),
+    ("not sad but happy", "happy"),
+])
+def test_a_negation_does_not_reach_past_a_clause_break(label, expected, confidence):
+    """These name the emotion they assert, right after the one they deny.
+
+    Three branches each read the label as one run and answered neutral, so the
+    asserted half was thrown away. Punctuation and a contrast conjunction mark
+    the same boundary and both have to stop it.
+    """
+    assert _label(label, confidence) == expected
+
+
+@pytest.mark.parametrize("confidence", CONFIDENCES)
+@pytest.mark.parametrize("label", [
+    "não estou feliz", "no estoy feliz", "not happy", "não triste", "not sad.",
+    "nunca feliz", "jamas feliz",
+])
+def test_a_negation_inside_one_clause_still_negates(label, confidence):
+    """The other half: scoping must not cost the ordinary single-clause case."""
+    assert _label(label, confidence) == "neutral"
+
+
+@pytest.mark.parametrize("confidence", CONFIDENCES)
+def test_a_postposed_veto_still_crosses_a_clause_break(confidence):
+    """The postposed loop is scoped by what follows the marker, not by clauses.
+
+    That is deliberate and sharper: this label has a comma and its last clause
+    is still a denial, so a blanket clause guard there would answer sad.
+    """
+    assert _label("我笑不起來，其實真的開心不起來", confidence) == "neutral"
+    assert _label("我難過不起來但很開心", confidence) == "happy"