[noticket] fix report bug where some answered analysis isnt included in report summary answers

src/agents/report/generator.py

@@ -28,7 +28,7 @@ from src.middlewares.logging import get_logger
 from ..language import detect_reply_language
 from ..slow_path.schemas import AnalysisRecord, TaskSummary
 from .errors import ReportError
-from .readiness import has_successful_analysis
+from .readiness import has_reportable_result
 from .schemas import (
     AnalysisReport,
     AttributedNote,
@@ -611,13 +611,26 @@ class ReportGenerator:
         excluded_ids = set(exclude_record_ids or [])
         excluded = [r for r in all_records if r.record_id in excluded_ids]
         kept = [r for r in all_records if r.record_id not in excluded_ids]
-        # The report body reflects only substantive runs — those with a successful
-        # analysis step (the same set the report floor validates). Fully-failed runs
-        # can't contradict the real findings, but they are not dropped silently
-        # either: they surface in the JSON `unresolved` list and the /records
-        # curation endpoint (the rendered markdown section was dropped 2026-07-09).
-        records = [r for r in kept if has_successful_analysis(r)]
-        unresolved_records = [r for r in kept if not has_successful_analysis(r)]
+        # The report body reflects every run that produced work worth showing —
+        # `has_reportable_result`, NOT the floor's `has_successful_analysis`. The two
+        # were the same predicate until planner recipes R2/R2b made the `analyze_*`
+        # step optional: a grouped/scalar aggregate answered entirely inside one
+        # `retrieve_data` IR is a complete analysis with no analyze_* tool, and the
+        # floor's predicate dropped those runs from the body, so their business
+        # question rendered "Unanswered". Runs whose analysis step actually FAILED
+        # are still excluded here (they can't contradict the real findings) and still
+        # surface in the JSON `unresolved` list and the /records curation endpoint
+        # (the rendered markdown section was dropped 2026-07-09).
+        records = [r for r in kept if has_reportable_result(r)]
+        unresolved_records = [r for r in kept if not has_reportable_result(r)]
+        if unresolved_records:
+            # The dropped-runs path was previously silent, which is why a correct
+            # answer showing up as "Unanswered" took a bug report to find.
+            logger.info(
+                "report: runs excluded from body",
+                analysis_id=analysis_id,
+                excluded=[r.record_id for r in unresolved_records],
+            )
         if not records:
             raise ReportError(f"no analyses recorded for {analysis_id!r} yet")
 

src/agents/report/readiness.py

@@ -71,6 +71,20 @@ def _is_newer(a: datetime, b: datetime) -> bool:
     return a > b
 
 
+# Catalog-introspection tools return metadata, not results — a run that only
+# inspected the schema has nothing for the report body to show.
+_CATALOG_ONLY_TOOLS = frozenset({"check_data", "check_knowledge"})
+
+
+def _is_analysis_tool(tool: str) -> bool:
+    """A tool whose success means "we computed a result" (analyze_* / render_chart).
+
+    Shared by `has_successful_analysis` (the floor) and `has_reportable_result`
+    (the body) so the two can never drift on what counts as an analysis step.
+    """
+    return tool.startswith("analyze") or tool == "render_chart"
+
+
 def has_successful_analysis(record) -> bool:
     """True if the record has at least one *result-producing* task that succeeded.
 
@@ -80,14 +94,54 @@ def has_successful_analysis(record) -> bool:
     (2026-07-14), a completed `render_chart`, whose viz-tail upstream necessarily
     computed the numbers being charted — is the real "we produced a result"
     signal. A chart-only session therefore satisfies the report floor.
+
+    This is the report **FLOOR** only. The report *body* uses the broader
+    `has_reportable_result` — see its docstring for why the two diverged.
     """
     return any(
-        t.status == "success"
-        and any(tool.startswith("analyze") or tool == "render_chart" for tool in t.tools_used)
+        t.status == "success" and any(_is_analysis_tool(tool) for tool in t.tools_used)
         for t in record.tasks_run
     )
 
 
+def has_reportable_result(record) -> bool:
+    """True if this run produced work the report **BODY** should include.
+
+    Deliberately distinct from `has_successful_analysis`, which stays the report
+    FLOOR. The two answer different questions:
+
+      floor — "is this session worth generating a report for at all?"
+      body  — "did this particular run produce work the report should show?"
+
+    They were the same predicate until planner recipes R2/R2b made the `analyze_*`
+    step optional (`planner.md`: R2 "ONE grouped retrieve_data IR (± analyze_aggregate)";
+    R2b "NO analyze_* step"). A grouped or scalar aggregate answered entirely inside
+    one `retrieve_data` IR is a correct, complete analysis that uses no `analyze_*`
+    tool — so keying the body on the floor's predicate silently dropped those runs.
+    Their business question then rendered "Unanswered" in the report with no trace,
+    because the "Attempted, Unresolved" section is commented out (2026-07-09).
+
+    Rule:
+      - The plan HAS an analysis step  -> it must have succeeded (unchanged). A run
+        whose analysis failed still belongs in `unresolved`, so its failure
+        narration can't contradict the successful runs' findings.
+      - The plan has NO analysis step  -> a successful data-producing task is enough
+        (`check_*` alone is not — that inspected the schema, it did not answer
+        anything).
+    """
+    tasks = record.tasks_run
+    plan_has_analysis = any(
+        _is_analysis_tool(tool) for task in tasks for tool in task.tools_used
+    )
+    if plan_has_analysis:
+        return has_successful_analysis(record)
+    return any(
+        task.status == "success"
+        and any(tool not in _CATALOG_ONLY_TOOLS for tool in task.tools_used)
+        for task in tasks
+    )
+
+
 async def report_floor(
     analysis_id: str | None,
     state: AnalysisState,