test(email): cover render_needs_you_list, rewrite_triage_answer, finalize_answer

Addresses review: the answer-rewriting logic that now decides what every
triage reply says had no coverage. Adds section ordering, ref numbering,
per-item classifier reasons, sender-address handling, the lead-paragraph
extraction, and the finalize_answer/process_query dedup that stops an
append-style guard firing twice on one turn.

Also fixes the pylint failure (unused finalize_answer default-hook argument),
collapses a doubled comment on _ITEM_LINE_EMAIL_RE, corrects two comments
that still claimed NEEDS_YOU_CAP is 5, and documents why
rewrite_triage_answer keys on tool presence rather than parsing intent.

Author: itomek

hub/agents/email/python/gaia_agent_email/answer_grounding.py

@@ -311,12 +311,10 @@ def strip_scaffolding_leaks(text: str) -> str:
 # "...scheduling meetings: 4. Tomasz ... 5. Tomasz ...".
 _INLINE_NUMBERED_ITEM_RE = re.compile(r"(?<=\S)[ \t]+(?=\d{1,3}\.[ \t]+\S)")
 
-# A bare address on an item line. The sender is already named beside it, so
-# this renders as the address twice -- once as text, once as a mailto: link
-# the markdown renderer expands.
 # Any bare address on an item line, however the model punctuated around it.
-# An explicit mailto: link goes too — the markdown renderer expands a bare
-# address into one anyway, which is the duplication being removed.
+# The sender is already named beside it, so a bare address renders twice --
+# once as text, once as the mailto: link the markdown renderer expands. An
+# explicit mailto: link goes too, for the same reason.
 _ITEM_LINE_EMAIL_RE = re.compile(
     r"[ \t]*\[?<?(?:mailto:)?[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}>?\]?"
     r"(?:\((?:mailto:)?[^)]*\))?"
@@ -450,6 +448,15 @@ def rewrite_triage_answer(
     and asking the chat model to do it produced invented numbering, dropped
     items, merged sections, and once no list at all. So the chat model keeps
     the opening sentence and this renders the rest.
+
+    Deliberately keyed on tool PRESENCE, not on parsing the user's question:
+    any turn that calls ``pre_scan_inbox`` gets the authoritative list, even
+    for a narrower ask ("how many urgent emails do I have?"). A hand-
+    summarized partial view is exactly the failure mode this function
+    replaces, and ``pre_scan_inbox`` only ever runs when the model judged
+    the question worth a scan in the first place — so a rewrite here is
+    never wrong, only sometimes more complete than the question strictly
+    asked for.
     """
     prescan = last_tool_payload(conversation, "pre_scan_inbox")
     if not prescan:

hub/agents/email/python/tests/test_answer_grounding.py

@@ -29,6 +29,7 @@
 from __future__ import annotations
 
 import json
+import re
 import sys
 import time
 from pathlib import Path
@@ -58,6 +59,9 @@
     find_unlicensed_cross_mailbox_claim,
     find_unqualified_negative_claim,
     ground_final_answer,
+    normalize_triage_list,
+    render_needs_you_list,
+    rewrite_triage_answer,
     strip_scaffolding_leaks,
     tools_called_this_turn,
 )
@@ -435,6 +439,150 @@ def test_leaves_clean_text_unchanged_apart_from_whitespace_trim(self):
         assert strip_scaffolding_leaks(clean) == clean
 
 
+# ---------------------------------------------------------------------------
+# render_needs_you_list / rewrite_triage_answer — the triage list is rendered
+# from the scan's own needs_you view, never retyped by the model (#2789
+# follow-up: three consecutive live runs invented numbering, dropped items,
+# or merged sections when the model was asked to write the list itself).
+# ---------------------------------------------------------------------------
+
+
+def _needs_you_row(ref: int, kind: str, **overrides) -> dict:
+    base = {
+        "ref": ref,
+        "kind": kind,
+        "message_id": f"m{ref}",
+        "thread_id": f"t{ref}",
+        "sender": "Someone <someone@example.com>",
+        "subject": f"subject {ref}",
+        "age_seconds": 3600,
+        "why": "",
+        "detail": [],
+        "due_hint": None,
+        "mailbox": None,
+    }
+    base.update(overrides)
+    return base
+
+
+class TestRenderNeedsYouList:
+    def test_empty_needs_you_renders_nothing(self):
+        assert render_needs_you_list(_prescan_envelope(needs_you=[])) == ""
+        assert render_needs_you_list({}) == ""
+
+    def test_sections_appear_in_display_order_with_ascending_refs(self):
+        envelope = _prescan_envelope(
+            needs_you=[
+                _needs_you_row(1, "waiting_on_you"),
+                _needs_you_row(2, "needs_response"),
+                _needs_you_row(3, "meeting_request"),
+                _needs_you_row(4, "needs_review"),
+            ]
+        )
+        rendered = render_needs_you_list(envelope)
+        # Every section header appears, in _TRIAGE_SECTIONS order.
+        for heading in (
+            "Waiting on your reply",
+            "Needs a response",
+            "Meetings to decide",
+            "Needs a manual look",
+        ):
+            assert heading in rendered
+        assert rendered.index("Waiting on your reply") < rendered.index("Needs a response")
+        assert rendered.index("Needs a response") < rendered.index("Meetings to decide")
+        assert rendered.index("Meetings to decide") < rendered.index("Needs a manual look")
+        # Refs ascend in the order they appear on the page, unbroken.
+        seen_refs = [int(tok) for tok in re.findall(r"^(\d+)\.", rendered, re.MULTILINE)]
+        assert seen_refs == [1, 2, 3, 4]
+
+    def test_urgent_and_waiting_on_you_share_one_reply_section(self):
+        # Both kinds render as REPLY (verbForKind, tui/cards/emailprescan.go) —
+        # a separate heading per kind would split one verb into two sections.
+        envelope = _prescan_envelope(
+            needs_you=[
+                _needs_you_row(1, "urgent"),
+                _needs_you_row(2, "waiting_on_you"),
+            ]
+        )
+        rendered = render_needs_you_list(envelope)
+        assert rendered.count("Waiting on your reply") == 1
+
+    def test_each_item_carries_its_classifier_reason(self):
+        envelope = _prescan_envelope(
+            needs_you=[
+                _needs_you_row(1, "needs_response", why="flagged as phishing"),
+            ]
+        )
+        assert "flagged as phishing" in render_needs_you_list(envelope)
+
+    def test_sender_address_is_dropped_when_a_display_name_exists(self):
+        envelope = _prescan_envelope(
+            needs_you=[
+                _needs_you_row(1, "waiting_on_you", sender="Jane Doe <jane@example.com>")
+            ]
+        )
+        rendered = render_needs_you_list(envelope)
+        assert "Jane Doe" in rendered
+        assert "jane@example.com" not in rendered
+
+    def test_address_only_sender_is_kept_but_not_autolinkable(self):
+        envelope = _prescan_envelope(
+            needs_you=[_needs_you_row(1, "waiting_on_you", sender="jane@example.com")]
+        )
+        rendered = render_needs_you_list(envelope)
+        assert "`jane@example.com`" in rendered
+
+
+class TestRewriteTriageAnswer:
+    def test_no_pre_scan_tool_call_leaves_the_answer_untouched(self):
+        text = "You have no new mail today."
+        assert rewrite_triage_answer(text, conversation=[]) == text
+
+    def test_pre_scan_with_no_needs_you_items_leaves_the_answer_untouched(self):
+        conversation = [_tool_entry("pre_scan_inbox", _prescan_envelope(needs_you=[]))]
+        text = "Your inbox is clear."
+        assert rewrite_triage_answer(text, conversation) == text
+
+    def test_the_models_own_list_is_discarded_in_favor_of_the_rendered_one(self):
+        envelope = _prescan_envelope(
+            needs_you=[_needs_you_row(1, "waiting_on_you", subject="Re: Q3 roadmap")]
+        )
+        conversation = [_tool_entry("pre_scan_inbox", envelope)]
+        model_answer = (
+            "Here's your inbox — 1 item needs attention.\n\n"
+            "### Stuff\n- **9.** a row the model invented\n- **3.** a duplicate"
+        )
+        out = rewrite_triage_answer(model_answer, conversation)
+        assert "the model invented" not in out
+        assert "1." in out and "Re: Q3 roadmap" in out
+        # The opening sentence survives; only the list is replaced.
+        assert out.startswith("Here's your inbox — 1 item needs attention.")
+
+
+class TestNormalizeTriageList:
+    def test_ordinary_prose_is_untouched(self):
+        prose = "We looked at 5. Then we stopped."
+        assert normalize_triage_list(prose) == prose
+
+    def test_run_on_items_are_split_onto_their_own_line(self):
+        # normalize_triage_list only activates once the text already contains
+        # a line-start numbered item (the signal that this IS a triage list);
+        # item 3 provides that, item 4/5 are the run-on fragment being fixed.
+        text = (
+            "3. Carol: Q3 roadmap\n"
+            "These emails propose scheduling: 4.  Alice: 30 minutes? 5.  Bob: Design review"
+        )
+        out = normalize_triage_list(text)
+        assert "\n4." in out
+        assert "\n5." in out
+
+    def test_duplicated_address_is_stripped_from_a_numbered_line(self):
+        text = "1. Tomasz Testingiewicz tomasz.t@outlook.com - Re: Partnership intro"
+        out = normalize_triage_list(text)
+        assert "tomasz.t@outlook.com" not in out
+        assert "Tomasz Testingiewicz" in out
+
+
 class TestDecodeStrayUnicodeEscapes:
     def test_decodes_known_escapes(self):
         assert decode_stray_unicode_escapes("a\\u2013b\\u2019c") == "a\u2013b\u2019c"
@@ -1080,6 +1228,50 @@ def test_grounded_answer_passes_through_unchanged(self, tmp_path):
         finally:
             agent.close_db()
 
+    def test_finalize_answer_grounds_the_text_the_loop_will_emit(self, tmp_path):
+        # #2789: grounding used to run only on process_query's return value,
+        # which the SSE/TUI stream never re-reads. finalize_answer is the
+        # hook the agent LOOP calls before it emits anything, so this must
+        # ground on its own, with no process_query involved at all.
+        agent = _build_agent(tmp_path)
+        try:
+            conversation = [{"role": "user", "content": "archive it"}]
+            out = agent.finalize_answer("The message has been archived.", conversation)
+            assert out == UNGROUNDED_SUCCESS_FALLBACK
+            assert agent._grounded_answer == UNGROUNDED_SUCCESS_FALLBACK
+        finally:
+            agent.close_db()
+
+    def test_process_query_does_not_re_ground_what_finalize_answer_already_did(
+        self, tmp_path
+    ):
+        # An append-style guard (attention-card) makes a double-fire visible: if
+        # process_query's fallback re-ran ground_final_answer on text
+        # finalize_answer already corrected, the correction would appear twice.
+        _store_attention_view(items=[_attention_item("action_item")], scanned=7)
+        agent = _build_agent(tmp_path)
+        try:
+            conversation = [{"role": "user", "content": "anything need my attention?"}]
+            grounded_by_loop = agent.finalize_answer(
+                "No urgent or actionable items found.", conversation
+            )
+            assert grounded_by_loop.count("attention card") == 1
+
+            canned = {
+                "status": "success",
+                "result": grounded_by_loop,
+                "conversation": conversation,
+                "steps_taken": 1,
+            }
+            with patch(
+                "gaia.agents.base.agent.Agent.process_query", return_value=canned
+            ):
+                out = agent.process_query("anything need my attention?")
+            assert out["result"] == grounded_by_loop
+            assert out["result"].count("attention card") == 1
+        finally:
+            agent.close_db()
+
     def test_attention_card_contradiction_is_appended_by_the_real_override(
         self, tmp_path
     ):

src/gaia/agents/base/agent.py

@@ -3325,7 +3325,7 @@ def _console_cancelled(self) -> bool:
         cancelled = getattr(self.console, "cancelled", None)
         return cancelled is not None and cancelled.is_set()
 
-    def finalize_answer(self, answer: str, conversation: Any) -> str:
+    def finalize_answer(self, answer: str, _conversation: Any) -> str:
         """Last chance to correct the final answer, BEFORE it is emitted.
 
         Runs ahead of ``console.print_final_answer``, so a subclass's

tui/internal/ui/cards/emailprescan_test.go

@@ -107,9 +107,9 @@ func TestPreScanCapsHitShowsNofM(t *testing.T) {
 	t.Logf("\n%s", plain(out))
 
 	assertWidth(t, out, width80)
-	// needs_you is capped at 5 server-side while needs_you_total (40)
-	// reports the true pre-cap count -- the header must read "5 of 40"
-	// rather than a bare count that implies the list is everything.
+	// The fixture ships fewer needs_you rows (5) than needs_you_total (40)
+	// reports -- the header must read "5 of 40" rather than a bare count
+	// that implies the list is everything.
 	assertContains(t, out, "NEEDS A REPLY", "5 of 40")
 }
 

tui/internal/ui/cards/testdata_test.go

@@ -46,9 +46,10 @@ const populatedPreScan = `{
   }
 }`
 
-// capsHitPreScan: needs_you is at its server-side cap of 5 while
-// needs_you_total reports the real pre-cap count, so the header must read
-// "5 of 40".
+// capsHitPreScan: needs_you carries fewer rows (5) than needs_you_total (40)
+// reports as the real pre-cap count -- NEEDS_YOU_CAP is 10 server-side, so
+// this fixture demonstrates the header reading "N of M" honestly whenever
+// N < M, without needing to hit the cap exactly.
 const capsHitPreScan = `{
   "kind": "email_pre_scan",
   "urgent": [], "actionable": [], "informational_count": 4,