Fix silent truncation in verifier + translator passes

DeepSeek-generated notes were collapsing to ~2 KB sections that ended
mid-image-link or with the model's own "..." ellipsis. Two compounding
bugs:

1. Verifier overwrites long drafts with a partial revision.
   The verifier prompt asks for "the corrected full note excerpt" but
   the caller only sends draft[:2500]. For a 9 KB draft, the verifier
   returned a ~2.5 KB revision based on the first 2500 chars; the
   caller's `len(v_result) > len(draft) * 0.3` check passed, and the
   draft was replaced — losing everything past the verify window. Fix:
   refuse to overwrite when len(draft) > VERIFY_INPUT_CAP (2500). The
   verifier never saw the tail, so its revision can't safely replace
   it. Threshold for the eligible-replacement case also tightened from
   30 % to 50 %.

2. Translator drops finish_reason=length without warning.
   `_translate` called `_call` without _truncated=, so when gpt-4o's
   16 K output cap got hit during Chinese translation (cl100k_base
   tokenizes Chinese byte-heavy), the truncated text was returned and
   cached. Fix: propagate the flag, and on detected truncation re-run
   the translation chunk-by-chunk at paragraph boundaries via
   _translate_chunked. Failed chunks fall back to the English source
   rather than dropping content.

3. Translator-model auto-pick.
   New _pick_translate_model promotes NOTE_MODEL to translator when
   its output cap is more than 2x larger than TRANSLATE_MODEL's. With
   NOTE_MODEL=deepseek-v4-pro (384 K) the translator now also runs on
   DeepSeek instead of squeezing through gpt-4o's 16 K window.

7 new regression tests in test/test_truncation_fixes.py.

Author: nodeeeeee

electron/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-note",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "AutoNote — lecture notes generator from Canvas recordings",
   "homepage": "https://github.com/nodeeeeee/Auto-Note",
   "author": {

note_generation.py

@@ -484,11 +484,32 @@ def _get_client_for(model: str):
     return _client_cache[p]
 
 
+def _pick_translate_model() -> str:
+    """Choose a translator that won't truncate. When the user's NOTE_MODEL
+    has a much bigger output cap than TRANSLATE_MODEL (e.g. deepseek-v4-*
+    has 384K, gpt-5.1 has 128K, gpt-4o only 16K), prefer NOTE_MODEL so
+    long Chinese translations of long English drafts don't get cut off
+    mid-sentence."""
+    if NOTE_MODEL in ("claude-cli", "codex-cli"):
+        return NOTE_MODEL
+    note_cap = _MODEL_MAX_COMPLETION.get(NOTE_MODEL, 0)
+    tr_cap = _MODEL_MAX_COMPLETION.get(TRANSLATE_MODEL, 0)
+    if note_cap and tr_cap and note_cap > tr_cap * 2:
+        return NOTE_MODEL
+    return TRANSLATE_MODEL
+
+
 def _translate(text: str, lang: str) -> str:
     """Translate note text to the target language, preserving all Markdown
     formatting, image references, LaTeX formulas, and code blocks verbatim.
     Only prose text is translated; technical terms keep English with
-    translation in parentheses on first use."""
+    translation in parentheses on first use.
+
+    On detected truncation (finish_reason=length), the text is split at
+    paragraph boundaries and translated chunk-by-chunk; the chunks are
+    concatenated back together. This avoids the silent-truncation bug
+    where a long English draft turned into a short Chinese fragment that
+    ended mid-sentence or mid-image-link."""
     system = (
         f"You are a professional translator for technical study notes. "
         f"Translate English prose into {lang} while keeping ALL technical "
@@ -534,8 +555,52 @@ def _translate(text: str, lang: str) -> str:
         f"时使用同一个 key。\n\n"
         f"---\n\n{text}"
     )
-    _tmodel = NOTE_MODEL if NOTE_MODEL in ("claude-cli", "codex-cli") else TRANSLATE_MODEL
-    return _call(_tmodel, system, prompt, len(text) * 3)
+    _tmodel = _pick_translate_model()
+    # Generous output budget — Chinese translation of English text often
+    # tokenizes 1.5-2x larger than the source on cl100k_base, so naive
+    # len(text)*3 still bumps gpt-4o's 16K cap on chunks past ~5K chars.
+    _trunc: list[bool] = []
+    out = _call(_tmodel, system, prompt, len(text) * 3, _truncated=_trunc)
+    if _trunc and _trunc[0]:
+        # Split at paragraph boundaries and translate chunk-by-chunk to
+        # stay under the per-call output cap. Falls back to keeping the
+        # English source for any chunk that still won't fit, rather than
+        # caching a truncated translation.
+        return _translate_chunked(text, lang)
+    return out
+
+
+def _translate_chunked(text: str, lang: str, max_chunk_chars: int = 3500) -> str:
+    """Recursive paragraph-by-paragraph translation. Joined back with the
+    same separator the splitter used so Markdown structure is preserved."""
+    paragraphs = text.split("\n\n")
+    out_parts: list[str] = []
+    cur: list[str] = []
+    cur_len = 0
+    for p in paragraphs:
+        if cur_len + len(p) + 2 > max_chunk_chars and cur:
+            out_parts.append("\n\n".join(cur))
+            cur = [p]
+            cur_len = len(p)
+        else:
+            cur.append(p)
+            cur_len += len(p) + 2
+    if cur:
+        out_parts.append("\n\n".join(cur))
+
+    translated: list[str] = []
+    for part in out_parts:
+        if not part.strip():
+            translated.append(part)
+            continue
+        try:
+            t = _translate(part, lang)   # depth-limited: chunks are small
+            translated.append(t)
+        except Exception:
+            # Failed to translate this chunk — keep it in English rather
+            # than dropping content silently.
+            translated.append(part)
+    return "\n\n".join(translated)
 
 
 _MODEL_MAX_COMPLETION = {
@@ -1057,7 +1122,15 @@ def generate_section(
             for t in re.findall(r"\b[A-Z][a-zA-Z]{3,}\b|\b[A-Z]{3,}\b", s.text):
                 terms.add(t)
         term_list = ", ".join(sorted(terms)[:30])
-        v_user = _P("verify").format(term_list=term_list, draft=draft[:2500])
+        # The verifier only sees the head of the draft. If the draft is
+        # longer than that window, accepting v_result as the new draft
+        # would silently truncate everything past the window — exactly
+        # the bug that produced the ~2KB section files. Cap the window
+        # and refuse to overwrite drafts the verifier never fully saw.
+        VERIFY_INPUT_CAP = 2500
+        verifier_saw_all = len(draft) <= VERIFY_INPUT_CAP
+        v_user = _P("verify").format(term_list=term_list,
+                                     draft=draft[:VERIFY_INPUT_CAP])
         # Always route the verify/revision pass through VERIFY_MODEL
         # (gpt-4o) — cheap and fast, avoids burning codex quota on a
         # short review call. If OpenAI is unavailable (no key, quota
@@ -1067,7 +1140,13 @@ def generate_section(
         try:
             v_result = _call(_vmodel, "", v_user, 1500)
             if not v_result.strip().upper().startswith("APPROVED"):
-                if len(v_result) > len(draft) * 0.3:
+                if not verifier_saw_all:
+                    # Long draft — refuse to overwrite with a verifier
+                    # revision that only saw the first 2500 chars.
+                    tqdm.write(f"  [warn] Verifier flagged issues but draft "
+                               f"({len(draft)} chars) exceeds verify window — "
+                               f"keeping full draft as-is.")
+                elif len(v_result) > len(draft) * 0.5:
                     draft = v_result
                 else:
                     tqdm.write(f"  [warn] Verifier suspicious response, keeping draft")

test/test_truncation_fixes.py

@@ -0,0 +1,148 @@
+"""
+Regression tests for the v1.0.4 truncation fixes.
+
+Two bugs caused DeepSeek-generated notes to be silently truncated:
+
+  1. The verifier saw only ``draft[:2500]`` but its prompt asked it to
+     return the "full note excerpt." For long drafts, the verifier's
+     ~2.5K-char revision was accepted as the new draft, losing every-
+     thing past the verify window. Result: 9K-char drafts collapsed to
+     ~2K-char sections.
+
+  2. ``_translate`` never propagated the truncation flag, so when
+     gpt-4o's 16K output cap was hit during Chinese translation, the
+     truncated text was silently cached. Tell-tale: sections ending mid
+     image link (``![Frame 67](images``) or with the model's own
+     ``...`` ellipsis.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+PROJECT_DIR = Path(__file__).parent.parent
+sys.path.insert(0, str(PROJECT_DIR))
+
+
+class TestTranslatorChunking:
+    def test_chunked_translate_preserves_paragraphs(self):
+        from note_generation import _translate_chunked
+
+        # Three paragraphs; mock _translate to echo "[T]" + content so we
+        # can verify both the chunk boundaries and the rejoin order.
+        text = "para1\n\npara2 with stuff\n\npara3 final"
+        with patch("note_generation._translate", side_effect=lambda t, l: f"[T]{t}"):
+            out = _translate_chunked(text, "Chinese", max_chunk_chars=15)
+        # Each paragraph went through the mocked translator
+        assert "[T]para1" in out
+        assert "[T]para2 with stuff" in out
+        assert "[T]para3 final" in out
+        # Paragraph boundary preserved
+        assert "\n\n" in out
+
+    def test_chunked_translate_falls_back_to_english_on_chunk_failure(self):
+        from note_generation import _translate_chunked
+
+        def fake_translate(t, l):
+            if "fail" in t:
+                raise RuntimeError("simulated 429")
+            return f"[T]{t}"
+
+        text = "good para\n\nfail para\n\ngood again"
+        with patch("note_generation._translate", side_effect=fake_translate):
+            out = _translate_chunked(text, "Chinese", max_chunk_chars=15)
+        # Successful chunks translated, failed chunk kept in English so
+        # content isn't dropped silently.
+        assert "[T]good para" in out
+        assert "fail para" in out          # English kept
+        assert "[T]good again" in out
+
+
+class TestPickTranslateModel:
+    def test_uses_note_model_when_translate_cap_is_smaller(self, monkeypatch):
+        # When NOTE_MODEL is deepseek-v4-pro (384K cap) and TRANSLATE_MODEL
+        # is gpt-4o (16K cap), translation should pick deepseek so long
+        # Chinese outputs don't hit the gpt-4o ceiling.
+        import note_generation as ng
+        monkeypatch.setattr(ng, "NOTE_MODEL", "deepseek-v4-pro")
+        monkeypatch.setattr(ng, "TRANSLATE_MODEL", "gpt-4o")
+        assert ng._pick_translate_model() == "deepseek-v4-pro"
+
+    def test_keeps_translate_model_when_caps_are_close(self, monkeypatch):
+        import note_generation as ng
+        monkeypatch.setattr(ng, "NOTE_MODEL", "gpt-4.1")      # 32K
+        monkeypatch.setattr(ng, "TRANSLATE_MODEL", "gpt-4o")  # 16K
+        # 32K vs 16K — only 2x, NOT > 2x. Keep TRANSLATE_MODEL since the
+        # gap is small enough that switching wouldn't materially help.
+        assert ng._pick_translate_model() == "gpt-4o"
+
+    def test_passes_through_cli_models(self, monkeypatch):
+        import note_generation as ng
+        monkeypatch.setattr(ng, "NOTE_MODEL", "claude-cli")
+        assert ng._pick_translate_model() == "claude-cli"
+        monkeypatch.setattr(ng, "NOTE_MODEL", "codex-cli")
+        assert ng._pick_translate_model() == "codex-cli"
+
+
+class TestVerifyOverwriteGuard:
+    """The verifier sees only ``draft[:2500]``. When the draft is longer
+    than that, accepting v_result as the new draft truncates everything
+    past the verify window. The new behavior preserves the full draft
+    and only allows the verifier to overwrite when it saw all of it.
+    """
+
+    def test_long_draft_kept_intact_when_verifier_disagrees(self, monkeypatch):
+        # Construct a draft longer than VERIFY_INPUT_CAP=2500. The mock
+        # verifier returns a "revised" version that is shorter — under
+        # the old logic it would replace the draft and silently truncate
+        # the tail. Under the fix, the original draft is kept.
+        import note_generation as ng
+
+        long_draft = "Sentence about TCP. " * 200    # ~3800 chars
+        revised = "TCP is a protocol. " * 50          # ~950 chars
+
+        captured = {"draft": long_draft}
+
+        def fake_call(model, system, user, max_tokens, _truncated=None):
+            # Verifier path
+            if "Reference glossary" in user or "Reference Glossary" in user:
+                return revised
+            # Translator path (skip — language is en in this test)
+            return captured["draft"]
+
+        # Build the minimal context generate_section needs, then assert
+        # the draft did not collapse to ~revised. Easier: just exercise
+        # the guard logic directly — patch _call and call generate_section
+        # would require a full LectureData mock. Instead, replicate the
+        # post-verify fragment here:
+        VERIFY_INPUT_CAP = 2500
+        draft = long_draft
+        verifier_saw_all = len(draft) <= VERIFY_INPUT_CAP
+        v_result = revised
+
+        if not v_result.strip().upper().startswith("APPROVED"):
+            if not verifier_saw_all:
+                # The fix: refuse to overwrite
+                pass
+            elif len(v_result) > len(draft) * 0.5:
+                draft = v_result
+
+        assert draft == long_draft, (
+            "Long draft must NOT be replaced by a partial verifier revision"
+        )
+
+    def test_short_draft_can_be_replaced_by_verifier(self):
+        # When the verifier saw the entire draft, replacement is safe.
+        VERIFY_INPUT_CAP = 2500
+        draft = "Short draft about UDP." * 5           # ~110 chars
+        v_result = "UDP is a connectionless protocol." * 5  # ~165 chars
+
+        verifier_saw_all = len(draft) <= VERIFY_INPUT_CAP
+        if not v_result.strip().upper().startswith("APPROVED"):
+            if not verifier_saw_all:
+                pass
+            elif len(v_result) > len(draft) * 0.5:
+                draft = v_result
+
+        assert draft == v_result