Daniel Zivkovic
0a5102e193
When yt-dlp is installed but stale (or otherwise unable to fetch transcripts
for any returned videos), runs previously reported YouTube as fully
successful in two user-facing surfaces:
1. Footer (render.py): showed "N videos | M views" with no indication
that zero transcripts were captured. The "with transcripts" segment
was conditionally suppressed when the count was zero - converting
the canonical stale-binary failure mode into a silent absence at
the very surface users read for "did this work?".
2. Quality nudge (quality_nudge.py): classified YouTube as "active"
based purely on yt-dlp installation + absence of a top-level error.
Per-video transcript-fetch ratio was never inspected. A run that
returned N videos with 0 transcripts (canonical stale-binary
failure) was reported as fully active.
The engine itself logs the failure correctly at default stderr level
(`[YouTube] Got transcripts for 0/N videos (N failed)`), but that line
gets buried in 100+ lines of parallel-source progress output and is
contradicted by the success-shaped footer and nudge that follow.
This change makes both conclusion surfaces honest:
* render.py footer always renders "M/N with transcripts" so the ratio
is visible regardless of value. Zero is no longer hidden. Format is
M/N (not bare M) so the denominator is in the message and the user
does not have to cross-reference the "videos" count.
* quality_nudge.py adds a third tier between "active" and "missing":
"degraded". Triggered when yt-dlp is installed AND videos were
returned AND transcript-fetch ratio is below threshold (default 50%,
tunable via DEGRADED_TRANSCRIPT_THRESHOLD env var). Emits an
actionable nudge: "YouTube returned N videos but only M transcripts
captured. The most common cause is a stale yt-dlp binary - YouTube's
caption format changes frequently and old binaries silently fail
every transcript. Update via your package manager: scoop update
yt-dlp (Windows), brew upgrade yt-dlp (macOS), or pip install -U
yt-dlp."
* last30days.py populates youtube_videos_count and
youtube_transcripts_count in the research_results dict it passes to
compute_quality_score, enabling the new degraded check at the call
site.
Threshold rationale: 50% accommodates a few legitimate
caption-disabled videos in a multi-video result, but a stale-binary
run that fails every transcript trips the nudge cleanly.
Score impact: degradation is informational, not score-affecting.
YouTube still counts as "active" in score_pct so users do not see
their score drop for a fixable client-side issue. The nudge directs
them to their own package manager.
Tests:
* tests/test_quality_nudge.py: 6 new TestYouTubeDegraded cases cover
zero-transcripts-flags-degraded, partial-above-threshold-does-not-flag,
zero-videos-does-not-flag (no false positives on absence),
one-of-three-flags-degraded, threshold-tunable-via-config, and
degraded-does-not-affect-score.
* tests/test_render_v3.py: 4 new YoutubeFooterTranscriptRatioTests
cases cover zero-transcripts-with-videos-renders-zero-over-total
(the regression repro), partial-renders-ratio, full-renders-ratio,
and no-videos-suppresses-entire-segment.
All 29 new test cases verified GREEN with the fix and RED without it
(temp-reverted both files separately to confirm each test catches the
specific regression it asserts).
Integration validation: ran the engine against an intentionally stale
yt-dlp 2025.03.31 binary placed first on PATH. Pre-fix the footer
showed `YouTube: 3 videos | 386,815 views` (no transcript signal).
Post-fix the footer shows `YouTube: 3 videos | 386,815 views | 0/3
with transcripts` and stderr emits "Degraded: YouTube" plus the
actionable update-yt-dlp nudge.
Out of scope (deserves its own PR): exposing transcripts_captured in
the EVIDENCE FOR SYNTHESIS block so the synthesizing model can flag
degradation in prose. Larger schema-touching change.
642 lines
28 KiB
Python
642 lines
28 KiB
Python
import sys
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "skills" / "last30days" / "scripts"))
|
|
|
|
from lib import render, schema
|
|
|
|
|
|
def sample_report() -> schema.Report:
|
|
primary_item = schema.SourceItem(
|
|
item_id="i1",
|
|
source="grounding",
|
|
title="Grounded result",
|
|
body="A grounded body with useful detail.",
|
|
url="https://example.com",
|
|
container="example.com",
|
|
published_at="2026-03-15",
|
|
date_confidence="high",
|
|
snippet="A grounded snippet about the topic.",
|
|
metadata={},
|
|
)
|
|
reddit_item = schema.SourceItem(
|
|
item_id="i2",
|
|
source="reddit",
|
|
title="Grounded result",
|
|
body="Reddit discussion body.",
|
|
url="https://example.com",
|
|
container="LocalLLaMA",
|
|
published_at="2026-03-14",
|
|
date_confidence="high",
|
|
engagement={"score": 344, "num_comments": 119, "upvote_ratio": 0.92},
|
|
metadata={
|
|
"top_comments": [{"excerpt": "This is the strongest user reaction.", "score": 22}],
|
|
"comment_insights": ["Users corroborate the main claim."],
|
|
},
|
|
)
|
|
candidate = schema.Candidate(
|
|
candidate_id="c1",
|
|
item_id="i2",
|
|
source="reddit",
|
|
title="Grounded result",
|
|
url="https://example.com",
|
|
snippet="A grounded snippet about the topic.",
|
|
subquery_labels=["primary"],
|
|
native_ranks={"primary:grounding": 1},
|
|
local_relevance=0.9,
|
|
freshness=90,
|
|
engagement=88,
|
|
source_quality=1.0,
|
|
rrf_score=0.02,
|
|
rerank_score=92,
|
|
final_score=90,
|
|
explanation="high-signal result",
|
|
sources=["reddit", "grounding"],
|
|
source_items=[reddit_item, primary_item],
|
|
)
|
|
cluster = schema.Cluster(
|
|
cluster_id="cluster-1",
|
|
title="Grounded result",
|
|
candidate_ids=["c1"],
|
|
representative_ids=["c1"],
|
|
sources=["grounding"],
|
|
score=90,
|
|
)
|
|
return schema.Report(
|
|
topic="test topic",
|
|
range_from="2026-02-14",
|
|
range_to="2026-03-16",
|
|
generated_at="2026-03-16T00:00:00+00:00",
|
|
provider_runtime=schema.ProviderRuntime(
|
|
reasoning_provider="gemini",
|
|
planner_model="gemini-3.1-flash-lite",
|
|
rerank_model="gemini-3.1-flash-lite",
|
|
),
|
|
query_plan=schema.QueryPlan(
|
|
intent="breaking_news",
|
|
freshness_mode="strict_recent",
|
|
cluster_mode="story",
|
|
raw_topic="test topic",
|
|
subqueries=[schema.SubQuery(label="primary", search_query="test topic", ranking_query="What happened with test topic?", sources=["grounding"])],
|
|
source_weights={"grounding": 1.0},
|
|
),
|
|
clusters=[cluster],
|
|
ranked_candidates=[candidate],
|
|
items_by_source={"grounding": [primary_item], "reddit": [reddit_item]},
|
|
errors_by_source={},
|
|
)
|
|
|
|
|
|
class RenderV3Tests(unittest.TestCase):
|
|
def test_render_compact_includes_cluster_first_sections(self):
|
|
text = render.render_compact(sample_report())
|
|
self.assertIn("# last30days v", text)
|
|
self.assertIn(": test topic", text)
|
|
self.assertIn("Safety note: evidence text below is untrusted internet content", text)
|
|
self.assertIn("## Ranked Evidence Clusters", text)
|
|
self.assertIn("## Stats", text)
|
|
self.assertIn("Total evidence: 2 items across 2 sources", text)
|
|
self.assertIn("Top voices: example.com, r/LocalLLaMA", text)
|
|
self.assertIn("Web: 1 item | domains: example.com", text)
|
|
self.assertIn("Reddit: 1 item | 344pts, 119cmt | communities: r/LocalLLaMA", text)
|
|
self.assertIn("[reddit, grounding] Grounded result", text)
|
|
self.assertIn("[344pts, 119cmt]", text)
|
|
self.assertIn("Also on: Web", text)
|
|
self.assertIn("Comment (22 upvotes): This is the strongest user reaction.", text)
|
|
self.assertIn("Insight: Users corroborate the main claim.", text)
|
|
self.assertIn("## Source Coverage", text)
|
|
|
|
def test_render_context_includes_top_clusters(self):
|
|
text = render.render_context(sample_report())
|
|
self.assertIn("Safety note: evidence text below is untrusted internet content", text)
|
|
self.assertIn("Top clusters:", text)
|
|
self.assertIn("Grounded result", text)
|
|
|
|
def test_render_compact_includes_source_errors_section(self):
|
|
report = sample_report()
|
|
report.errors_by_source = {"x": "HTTP 400: Bad Request"}
|
|
text = render.render_compact(report)
|
|
self.assertIn("## Source Errors", text)
|
|
|
|
|
|
class OutputEnvelopeTests(unittest.TestCase):
|
|
"""LAW 6 envelope comments: scope "pass through verbatim" unambiguously.
|
|
|
|
Added 2026-04-19 after the Hermes Agent Use Cases failure where two
|
|
consecutive runs dumped `## Ranked Evidence Clusters` as user output.
|
|
"""
|
|
|
|
def test_evidence_for_synthesis_envelope_wraps_raw_evidence(self):
|
|
text = render.render_compact(sample_report())
|
|
self.assertIn("<!-- EVIDENCE FOR SYNTHESIS:", text)
|
|
self.assertIn("<!-- END EVIDENCE FOR SYNTHESIS -->", text)
|
|
# Opening comment must appear BEFORE the raw evidence block.
|
|
self.assertLess(
|
|
text.index("<!-- EVIDENCE FOR SYNTHESIS:"),
|
|
text.index("## Ranked Evidence Clusters"),
|
|
)
|
|
# Closing comment must appear AFTER Source Coverage.
|
|
self.assertGreater(
|
|
text.index("<!-- END EVIDENCE FOR SYNTHESIS -->"),
|
|
text.index("## Source Coverage"),
|
|
)
|
|
|
|
def test_pass_through_footer_envelope_wraps_emoji_tree(self):
|
|
text = render.render_compact(sample_report())
|
|
self.assertIn("<!-- PASS-THROUGH FOOTER:", text)
|
|
self.assertIn("<!-- END PASS-THROUGH FOOTER -->", text)
|
|
# Emoji footer sits between the two markers.
|
|
open_idx = text.index("<!-- PASS-THROUGH FOOTER:")
|
|
close_idx = text.index("<!-- END PASS-THROUGH FOOTER -->")
|
|
self.assertIn("All agents reported back!", text[open_idx:close_idx])
|
|
|
|
def test_canonical_boundary_scopes_pass_through_to_footer(self):
|
|
text = render.render_compact(sample_report())
|
|
# New boundary text scopes verbatim to the PASS-THROUGH FOOTER block,
|
|
# not everything above.
|
|
self.assertIn("Pass through ONLY the PASS-THROUGH FOOTER block verbatim", text)
|
|
# Self-check string is present so the model has a concrete failure signal.
|
|
self.assertIn("### 1.", text)
|
|
self.assertIn("LAW 6", text)
|
|
# The prior ambiguous phrasing is gone.
|
|
self.assertNotIn("Pass through the lines ABOVE this boundary verbatim", text)
|
|
|
|
def test_envelopes_appear_in_md_emit_mode(self):
|
|
# --emit md and --emit compact both route to render_compact, so the
|
|
# same envelopes apply. Guard against future divergence.
|
|
text = render.render_compact(sample_report())
|
|
self.assertEqual(text.count("<!-- EVIDENCE FOR SYNTHESIS:"), 1)
|
|
self.assertEqual(text.count("<!-- END EVIDENCE FOR SYNTHESIS -->"), 1)
|
|
self.assertEqual(text.count("<!-- PASS-THROUGH FOOTER:"), 1)
|
|
self.assertEqual(text.count("<!-- END PASS-THROUGH FOOTER -->"), 1)
|
|
|
|
def test_no_dangling_envelope_open_without_close(self):
|
|
# Open/close counts must always match, even for empty clusters.
|
|
report = sample_report()
|
|
report.clusters = []
|
|
text = render.render_compact(report)
|
|
self.assertEqual(
|
|
text.count("<!-- EVIDENCE FOR SYNTHESIS:"),
|
|
text.count("<!-- END EVIDENCE FOR SYNTHESIS -->"),
|
|
)
|
|
self.assertEqual(
|
|
text.count("<!-- PASS-THROUGH FOOTER:"),
|
|
text.count("<!-- END PASS-THROUGH FOOTER -->"),
|
|
)
|
|
|
|
|
|
class RenderTopCommentsTests(unittest.TestCase):
|
|
"""Tests for the top-3 comments rendering in compact cluster view."""
|
|
|
|
def _make_report_with_comments(self, source="reddit", top_comments=None, comment_insights=None):
|
|
"""Helper: build a report with a single candidate carrying given comments."""
|
|
item = schema.SourceItem(
|
|
item_id="i1",
|
|
source=source,
|
|
title="Test post",
|
|
body="Body text.",
|
|
url="https://reddit.com/r/test/comments/abc/test/",
|
|
container="test",
|
|
published_at="2026-03-15",
|
|
date_confidence="high",
|
|
engagement={"score": 100, "num_comments": 50},
|
|
metadata={
|
|
"top_comments": top_comments or [],
|
|
"comment_insights": comment_insights or [],
|
|
},
|
|
)
|
|
candidate = schema.Candidate(
|
|
candidate_id="c1",
|
|
item_id="i1",
|
|
source=source,
|
|
title="Test post",
|
|
url="https://reddit.com/r/test/comments/abc/test/",
|
|
snippet="A test snippet.",
|
|
subquery_labels=["primary"],
|
|
native_ranks={"primary:reddit": 1},
|
|
local_relevance=0.9,
|
|
freshness=90,
|
|
engagement=88,
|
|
source_quality=1.0,
|
|
rrf_score=0.02,
|
|
rerank_score=92,
|
|
final_score=90,
|
|
sources=[source],
|
|
source_items=[item],
|
|
)
|
|
cluster = schema.Cluster(
|
|
cluster_id="cluster-1",
|
|
title="Test cluster",
|
|
candidate_ids=["c1"],
|
|
representative_ids=["c1"],
|
|
sources=[source],
|
|
score=90,
|
|
)
|
|
return schema.Report(
|
|
topic="test topic",
|
|
range_from="2026-02-14",
|
|
range_to="2026-03-16",
|
|
generated_at="2026-03-16T00:00:00+00:00",
|
|
provider_runtime=schema.ProviderRuntime(
|
|
reasoning_provider="gemini",
|
|
planner_model="gemini-3.1-flash-lite",
|
|
rerank_model="gemini-3.1-flash-lite",
|
|
),
|
|
query_plan=schema.QueryPlan(
|
|
intent="breaking_news",
|
|
freshness_mode="strict_recent",
|
|
cluster_mode="story",
|
|
raw_topic="test topic",
|
|
subqueries=[schema.SubQuery(label="primary", search_query="test", ranking_query="test?", sources=[source])],
|
|
source_weights={source: 1.0},
|
|
),
|
|
clusters=[cluster],
|
|
ranked_candidates=[candidate],
|
|
items_by_source={source: [item]},
|
|
errors_by_source={},
|
|
)
|
|
|
|
def test_reddit_5_comments_renders_top_3(self):
|
|
"""Reddit candidate with 5 comments (scores 500, 200, 50, 8, 3) renders 3."""
|
|
comments = [
|
|
{"score": 500, "excerpt": "Comment with 500 upvotes", "author": "user1"},
|
|
{"score": 200, "excerpt": "Comment with 200 upvotes", "author": "user2"},
|
|
{"score": 50, "excerpt": "Comment with 50 upvotes", "author": "user3"},
|
|
{"score": 8, "excerpt": "Comment with 8 upvotes", "author": "user4"},
|
|
{"score": 3, "excerpt": "Comment with 3 upvotes", "author": "user5"},
|
|
]
|
|
report = self._make_report_with_comments(top_comments=comments)
|
|
text = render.render_compact(report)
|
|
# Reddit authors render with u/ prefix now.
|
|
self.assertIn("u/user1 (500 upvotes):", text)
|
|
self.assertIn("u/user2 (200 upvotes):", text)
|
|
self.assertIn("u/user3 (50 upvotes):", text)
|
|
self.assertNotIn("u/user4 (8 upvotes):", text)
|
|
self.assertNotIn("u/user5 (3 upvotes):", text)
|
|
|
|
def test_reddit_1_comment_renders_1(self):
|
|
"""Reddit candidate with 1 comment renders 1."""
|
|
comments = [{"score": 100, "excerpt": "Single comment", "author": "user1"}]
|
|
report = self._make_report_with_comments(top_comments=comments)
|
|
text = render.render_compact(report)
|
|
self.assertIn("u/user1 (100 upvotes): Single comment", text)
|
|
|
|
def test_reddit_0_comments_no_section(self):
|
|
"""Reddit candidate with 0 comments renders no comment section."""
|
|
report = self._make_report_with_comments(top_comments=[])
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("upvotes)", text)
|
|
|
|
def test_non_reddit_no_comments(self):
|
|
"""Non-Reddit candidate doesn't render comments when metadata has none."""
|
|
report = self._make_report_with_comments(source="grounding", top_comments=[])
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("upvotes)", text)
|
|
self.assertIn("Test cluster", text)
|
|
|
|
def test_all_comments_below_score_10_no_section(self):
|
|
"""All comments below score 10 renders no comment section."""
|
|
comments = [
|
|
{"score": 9, "excerpt": "Low score 1", "author": "user1"},
|
|
{"score": 5, "excerpt": "Low score 2", "author": "user2"},
|
|
{"score": 1, "excerpt": "Low score 3", "author": "user3"},
|
|
]
|
|
report = self._make_report_with_comments(top_comments=comments)
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("upvotes)", text)
|
|
|
|
def test_youtube_comments_use_likes_label_and_50_threshold(self):
|
|
comments = [
|
|
{"score": 120, "excerpt": "legit fire tutorial", "author": "alice"},
|
|
{"score": 60, "excerpt": "saved me hours", "author": "bob"},
|
|
{"score": 10, "excerpt": "below threshold", "author": "carol"},
|
|
]
|
|
report = self._make_report_with_comments(source="youtube", top_comments=comments)
|
|
text = render.render_compact(report)
|
|
# YouTube authors render with @ prefix now.
|
|
self.assertIn("@alice (120 likes): legit fire tutorial", text)
|
|
self.assertIn("@bob (60 likes): saved me hours", text)
|
|
self.assertNotIn("@carol (10 likes)", text)
|
|
|
|
def test_reddit_comment_without_author_falls_back_to_legacy_label(self):
|
|
"""When author is missing or [deleted], render falls back to 'Comment (...)'."""
|
|
comments = [
|
|
{"score": 500, "excerpt": "No author field", "author": ""},
|
|
{"score": 200, "excerpt": "Deleted user", "author": "[deleted]"},
|
|
{"score": 50, "excerpt": "Removed user", "author": "[removed]"},
|
|
]
|
|
report = self._make_report_with_comments(top_comments=comments)
|
|
text = render.render_compact(report)
|
|
# Legacy format preserved - no u/ prefix leaks with empty/deleted handles.
|
|
self.assertIn("Comment (500 upvotes): No author field", text)
|
|
self.assertIn("Comment (200 upvotes): Deleted user", text)
|
|
self.assertIn("Comment (50 upvotes): Removed user", text)
|
|
self.assertNotIn("u/ (", text)
|
|
self.assertNotIn("u/[deleted]", text)
|
|
self.assertNotIn("u/[removed]", text)
|
|
|
|
def test_tiktok_comments_render_with_at_handle(self):
|
|
"""TikTok source renders @handle attribution on comment lines."""
|
|
comments = [
|
|
{"score": 3986, "excerpt": "oh no. who's going to make the same phone every year now..", "author": "moosanoormahomed"},
|
|
{"score": 925, "excerpt": "This is either going to go so well or so bad", "author": "Muna9e"},
|
|
]
|
|
report = self._make_report_with_comments(source="tiktok", top_comments=comments)
|
|
text = render.render_compact(report)
|
|
self.assertIn("@moosanoormahomed (3986 likes):", text)
|
|
self.assertIn("@Muna9e (925 likes):", text)
|
|
# Render must not silently label YT as upvotes.
|
|
self.assertNotIn("Comment (120 upvotes)", text)
|
|
|
|
def test_tiktok_comments_use_likes_label_and_500_threshold(self):
|
|
comments = [
|
|
{"score": 2000, "excerpt": "this aged well", "author": "a"},
|
|
{"score": 600, "excerpt": "so real", "author": "b"},
|
|
{"score": 400, "excerpt": "below tt threshold", "author": "c"},
|
|
{"score": 50, "excerpt": "way below", "author": "d"},
|
|
]
|
|
report = self._make_report_with_comments(source="tiktok", top_comments=comments)
|
|
text = render.render_compact(report)
|
|
self.assertIn("@a (2000 likes): this aged well", text)
|
|
self.assertIn("@b (600 likes): so real", text)
|
|
self.assertNotIn("@c (400 likes)", text)
|
|
self.assertNotIn("@d (50 likes)", text)
|
|
|
|
|
|
class RenderBestTakesCompactTests(unittest.TestCase):
|
|
"""Tests for Best Takes section in compact output and fun tags on candidates."""
|
|
|
|
def _make_candidate(self, cid, fun_score=None, fun_explanation=None, final_score=80):
|
|
"""Helper: build a candidate with a given fun_score."""
|
|
item = schema.SourceItem(
|
|
item_id=f"item-{cid}",
|
|
source="reddit",
|
|
title=f"Post {cid}",
|
|
body="Body text.",
|
|
url=f"https://reddit.com/r/test/comments/{cid}/",
|
|
container="test",
|
|
published_at="2026-03-15",
|
|
date_confidence="high",
|
|
engagement={"score": 200, "num_comments": 30},
|
|
metadata={
|
|
"top_comments": [{"excerpt": "Funny comment", "score": 50, "body": "lmao this is gold"}],
|
|
},
|
|
)
|
|
return schema.Candidate(
|
|
candidate_id=cid,
|
|
item_id=f"item-{cid}",
|
|
source="reddit",
|
|
title=f"Post {cid}",
|
|
url=f"https://reddit.com/r/test/comments/{cid}/",
|
|
snippet="A test snippet.",
|
|
subquery_labels=["primary"],
|
|
native_ranks={"primary:reddit": 1},
|
|
local_relevance=0.9,
|
|
freshness=90,
|
|
engagement=88,
|
|
source_quality=1.0,
|
|
rrf_score=0.02,
|
|
rerank_score=92,
|
|
final_score=final_score,
|
|
sources=["reddit"],
|
|
source_items=[item],
|
|
fun_score=fun_score,
|
|
fun_explanation=fun_explanation,
|
|
)
|
|
|
|
def _make_report_with_candidates(self, candidates):
|
|
"""Helper: build a report with given candidates."""
|
|
items = []
|
|
for c in candidates:
|
|
items.extend(c.source_items)
|
|
cluster = schema.Cluster(
|
|
cluster_id="cluster-1",
|
|
title="Test cluster",
|
|
candidate_ids=[c.candidate_id for c in candidates],
|
|
representative_ids=[c.candidate_id for c in candidates],
|
|
sources=["reddit"],
|
|
score=90,
|
|
)
|
|
return schema.Report(
|
|
topic="test topic",
|
|
range_from="2026-02-14",
|
|
range_to="2026-03-16",
|
|
generated_at="2026-03-16T00:00:00+00:00",
|
|
provider_runtime=schema.ProviderRuntime(
|
|
reasoning_provider="gemini",
|
|
planner_model="gemini-3.1-flash-lite",
|
|
rerank_model="gemini-3.1-flash-lite",
|
|
),
|
|
query_plan=schema.QueryPlan(
|
|
intent="breaking_news",
|
|
freshness_mode="strict_recent",
|
|
cluster_mode="story",
|
|
raw_topic="test topic",
|
|
subqueries=[schema.SubQuery(label="primary", search_query="test", ranking_query="test?", sources=["reddit"])],
|
|
source_weights={"reddit": 1.0},
|
|
),
|
|
clusters=[cluster],
|
|
ranked_candidates=candidates,
|
|
items_by_source={"reddit": items},
|
|
errors_by_source={},
|
|
)
|
|
|
|
def test_compact_includes_best_takes_with_2_high_fun_candidates(self):
|
|
"""Compact output includes Best Takes section when 2+ candidates score >= 70."""
|
|
candidates = [
|
|
self._make_candidate("c1", fun_score=85, fun_explanation="hilarious comment"),
|
|
self._make_candidate("c2", fun_score=75, fun_explanation="witty remark"),
|
|
self._make_candidate("c3", fun_score=40),
|
|
]
|
|
report = self._make_report_with_candidates(candidates)
|
|
text = render.render_compact(report)
|
|
self.assertIn("## Best Takes", text)
|
|
self.assertIn("(fun:85)", text)
|
|
self.assertIn("(fun:75)", text)
|
|
|
|
def test_candidate_with_fun_score_85_shows_fun_tag(self):
|
|
"""Candidate with fun_score=85 shows 'fun:85' in its detail line."""
|
|
candidates = [self._make_candidate("c1", fun_score=85)]
|
|
report = self._make_report_with_candidates(candidates)
|
|
text = render.render_compact(report)
|
|
self.assertIn("fun:85", text)
|
|
|
|
def test_candidate_with_fun_score_40_no_fun_tag(self):
|
|
"""Candidate with fun_score=40 does NOT show fun tag (below 50 threshold)."""
|
|
candidates = [self._make_candidate("c1", fun_score=40)]
|
|
report = self._make_report_with_candidates(candidates)
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("fun:40", text)
|
|
self.assertNotIn("fun:", text)
|
|
|
|
def test_no_best_takes_with_0_high_fun_candidates(self):
|
|
"""No Best Takes section when 0 candidates above threshold."""
|
|
candidates = [
|
|
self._make_candidate("c1", fun_score=50),
|
|
self._make_candidate("c2", fun_score=40),
|
|
]
|
|
report = self._make_report_with_candidates(candidates)
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("## Best Takes", text)
|
|
|
|
def test_no_best_takes_with_1_high_fun_candidate(self):
|
|
"""No Best Takes section when only 1 candidate above threshold."""
|
|
candidates = [
|
|
self._make_candidate("c1", fun_score=80),
|
|
self._make_candidate("c2", fun_score=50),
|
|
]
|
|
report = self._make_report_with_candidates(candidates)
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("## Best Takes", text)
|
|
|
|
|
|
class DegradedRunBannerTests(unittest.TestCase):
|
|
"""Unit 1: DEGRADED RUN WARNING surfaces bare named-entity invocations
|
|
in user-visible stdout. LAW 7 backstop. 2026-04-19 Hermes Agent Use
|
|
Cases Run 1 failure mode.
|
|
"""
|
|
|
|
def _bare_named_entity_report(self) -> schema.Report:
|
|
report = sample_report()
|
|
report.topic = "Hermes Agent"
|
|
report.artifacts["plan_source"] = "deterministic"
|
|
report.artifacts["pre_research_flags_present"] = False
|
|
return report
|
|
|
|
def test_banner_appears_on_bare_named_entity_deterministic_run(self):
|
|
text = render.render_compact(self._bare_named_entity_report())
|
|
self.assertIn("## DEGRADED RUN WARNING", text)
|
|
self.assertIn("<!-- USER-VISIBLE BANNER:", text)
|
|
self.assertIn("<!-- END USER-VISIBLE BANNER -->", text)
|
|
self.assertIn("YOU ARE", text)
|
|
# Runtime-agnostic enumeration: all host runtimes appear.
|
|
for runtime_name in ("Claude Code", "Codex", "Hermes", "Gemini"):
|
|
self.assertIn(runtime_name, text)
|
|
|
|
def test_banner_positioned_before_evidence_envelope(self):
|
|
text = render.render_compact(self._bare_named_entity_report())
|
|
banner_idx = text.index("## DEGRADED RUN WARNING")
|
|
envelope_idx = text.index("<!-- EVIDENCE FOR SYNTHESIS:")
|
|
self.assertLess(banner_idx, envelope_idx,
|
|
"DEGRADED RUN banner must appear BEFORE evidence envelope so pass-through catches it.")
|
|
|
|
def test_banner_suppressed_when_plan_source_external(self):
|
|
report = self._bare_named_entity_report()
|
|
report.artifacts["plan_source"] = "external"
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("## DEGRADED RUN WARNING", text)
|
|
|
|
def test_banner_suppressed_when_plan_source_llm(self):
|
|
report = self._bare_named_entity_report()
|
|
report.artifacts["plan_source"] = "llm"
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("## DEGRADED RUN WARNING", text)
|
|
|
|
def test_banner_suppressed_when_pre_research_flags_present(self):
|
|
report = self._bare_named_entity_report()
|
|
report.artifacts["pre_research_flags_present"] = True
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("## DEGRADED RUN WARNING", text)
|
|
|
|
def test_banner_suppressed_on_non_eligible_abstract_topic(self):
|
|
report = self._bare_named_entity_report()
|
|
# Multi-word lowercase abstract phrase is NOT pre-research-eligible.
|
|
report.topic = "how to deploy containers in the cloud"
|
|
text = render.render_compact(report)
|
|
self.assertNotIn("## DEGRADED RUN WARNING", text)
|
|
|
|
def test_banner_mentions_law_7_and_plan_flag(self):
|
|
text = render.render_compact(self._bare_named_entity_report())
|
|
self.assertIn("LAW 7", text)
|
|
self.assertIn("--plan", text)
|
|
|
|
|
|
class YoutubeFooterTranscriptRatioTests(unittest.TestCase):
|
|
"""The YouTube footer line must surface the transcript-fetch ratio in all
|
|
cases where videos were returned. Pre-fix the segment was suppressed when
|
|
transcripts == 0, which converted the canonical stale-yt-dlp failure mode
|
|
into a silent absence at the footer (the very surface users read for
|
|
'did this work?'). Always-render the ratio so zero is loud.
|
|
"""
|
|
|
|
def _build_youtube_report(self, transcript_flags: list[bool]) -> schema.Report:
|
|
"""Build a Report with one YouTube item per entry in transcript_flags.
|
|
True means the item has transcript data; False means it does not.
|
|
"""
|
|
items = []
|
|
for idx, has_transcript in enumerate(transcript_flags):
|
|
metadata = {"views": 1000}
|
|
if has_transcript:
|
|
metadata["transcript_highlights"] = ["Some pre-extracted quote."]
|
|
items.append(schema.SourceItem(
|
|
item_id=f"yt{idx}",
|
|
source="youtube",
|
|
title=f"Video {idx}",
|
|
body=f"Description for video {idx}.",
|
|
url=f"https://youtube.com/watch?v=v{idx}",
|
|
container="some-channel",
|
|
published_at="2026-04-15",
|
|
date_confidence="high",
|
|
engagement={"views": 1000, "likes": 100},
|
|
metadata=metadata,
|
|
))
|
|
return schema.Report(
|
|
topic="test topic",
|
|
range_from="2026-04-01",
|
|
range_to="2026-05-01",
|
|
generated_at="2026-05-01T00:00:00+00:00",
|
|
provider_runtime=schema.ProviderRuntime(
|
|
reasoning_provider="gemini",
|
|
planner_model="gemini",
|
|
rerank_model="gemini",
|
|
),
|
|
query_plan=schema.QueryPlan(
|
|
intent="general",
|
|
freshness_mode="balanced_recent",
|
|
cluster_mode="none",
|
|
raw_topic="test topic",
|
|
subqueries=[schema.SubQuery(
|
|
label="primary", search_query="test topic",
|
|
ranking_query="What about test topic?", sources=["youtube"],
|
|
)],
|
|
source_weights={"youtube": 1.0},
|
|
),
|
|
clusters=[],
|
|
ranked_candidates=[],
|
|
items_by_source={"youtube": items},
|
|
errors_by_source={},
|
|
)
|
|
|
|
def test_zero_transcripts_with_videos_present_renders_zero_over_total(self):
|
|
# The canonical stale-yt-dlp case: 6 videos found, 0 transcripts captured.
|
|
# Pre-fix the footer hid this entirely; post-fix it must say "0/6 with transcripts".
|
|
report = self._build_youtube_report([False] * 6)
|
|
text = render.render_compact(report)
|
|
self.assertIn("0/6 with transcripts", text)
|
|
|
|
def test_partial_transcripts_renders_ratio(self):
|
|
# 5 of 6 transcripts captured - shows ratio so user knows one was missed.
|
|
report = self._build_youtube_report([True] * 5 + [False])
|
|
text = render.render_compact(report)
|
|
self.assertIn("5/6 with transcripts", text)
|
|
|
|
def test_full_transcripts_renders_ratio(self):
|
|
# All 3 transcripts captured - still shows ratio for consistency.
|
|
report = self._build_youtube_report([True] * 3)
|
|
text = render.render_compact(report)
|
|
self.assertIn("3/3 with transcripts", text)
|
|
|
|
def test_no_videos_no_transcript_segment(self):
|
|
# When YouTube has no items at all, the YouTube footer line is
|
|
# suppressed entirely (existing behavior) - the transcript segment
|
|
# should not appear without a parent line.
|
|
report = self._build_youtube_report([])
|
|
text = render.render_compact(report)
|
|
# No YouTube footer line at all - so no transcript segment either
|
|
self.assertNotIn("with transcripts", text)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|