Jeffrey Sperling
96a4a78faa
The Gemini 3.1 Flash Lite preview model is being discontinued on May 25, 2026. Per Google's GA announcement, the underlying model architecture is identical and only the model identifier needs to be updated from `gemini-3.1-flash-lite-preview` to `gemini-3.1-flash-lite`. Also relaxes the `_require_gemini_31_preview` guard to accept any `gemini-3.1-*` identifier (renamed to `_require_gemini_31`), so the GA name and the still-preview `gemini-3.1-pro-preview` both pass.
556 lines
24 KiB
Python
556 lines
24 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 v3.0.0: 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)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|