Test Featured

Source content

from __future__ import annotations

import hashlib

import json

import re

from pathlib import Path

from urllib.parse import urlparse

import pytest

from epistemedia.cli import main

from epistemedia.core import PublicCatalog, build_public, stable_id, verify_release_identity

from epistemedia.dossier import independence_summary

from epistemedia.featured import (

FEATURE_VIEWS,

FeaturedDossier,

FeaturedDossierError,

share_card_svg,

)

from epistemedia.server import Gateway, Request

ROOT = Path(__file__).resolve().parents[1]

SLUG = "corrections-and-familiarity-backfire"

def test_feature_manifest_binds_exact_reviewed_dossier_and_derives_counts() -> None:

featured = FeaturedDossier.load(ROOT)

counts = featured.derived_counts()

assert featured.slug == SLUG

assert featured.dossier["dossier_id"] == (

"em:dossier:sha256:4339d6d6d52b9b534d2e63c95f52ff3cf90be5264f567762f47bab9af4d945a7"

)

assert featured.receipt["decision"] == "pass"

assert featured.receipt["repository"]["reviewed_head"] == featured.manifest["reviewed_head"]

assert counts["apparent_support_assertion_count"] == 10

assert counts["known_support_data_root_count"] == 6

assert counts["unresolved_support_data_root_count"] == 1

assert counts["target_comparable_support_data_root_count"] == 4

assert counts["target_comparable_unresolved_data_root_count"] == 1

assert counts["review_report_assertion_count"] == 4

assert counts["counter_assertion_count"] == 12

assert counts["counter_data_root_count"] == 12

def test_real_shared_ancestor_collapses_without_collapsing_new_participant_data() -> None:

dossier = FeaturedDossier.load(ROOT).dossier

reported_unpublished = independence_summary(

dossier,

[

"assert-handbook-claim",

"assert-schwarz-flu-result",

"assert-ecker-2020-historical-report",

],

)

assert reported_unpublished["independent_lineage_count"] == 0

assert reported_unpublished["unknown_lineage_count"] == 1

assert reported_unpublished["unknown_lineages"] == ["lineage-skurnik-2007-data"]

new_participants_shared_program = independence_summary(

dossier,

["assert-pluviano-2017-result", "assert-pluviano-2019-result"],

)

assert new_participants_shared_program["independent_lineage_count"] == 2

assert new_participants_shared_program["unknown_lineage_count"] == 0

def test_every_featured_sentence_resolves_exact_span_edition_and_work_identity() -> None:

featured = FeaturedDossier.load(ROOT)

for view in FEATURE_VIEWS:

projection = featured.projection(view)

assert projection["featured_relations"]

for item in projection["featured_relations"]:

assert item["statement"]

assert item["statement"] == item["relation"]["note"]

assert item["sources"]

for source in item["sources"]:

span = source["span"]

edition = source["edition"]

work = source["source_work"]

assert span["edition_key"] == edition["key"]

assert edition["work_key"] == work["key"]

assert span["id"].startswith("em:dossier-span:sha256:")

assert edition["id"].startswith("em:dossier-edition:sha256:")

assert work["id"].startswith("em:dossier-source-work:sha256:")

assert span["locator"]["label"]

assert span["extent"]["type"] in {"quote", "json-value"}

assert work["canonical_uri"].startswith("http")

assert work["license"]

encyclopedia = featured.projection("encyclopedia")

pluviano = encyclopedia["featured_relations"][0]

thomas = encyclopedia["featured_relations"][1]

assert "two vaccine-message studies" not in pluviano["statement"].lower()

assert "later direct replication" not in pluviano["statement"].lower()

assert {source["source_work"]["key"] for source in pluviano["sources"]} == {

"work-pluviano-2017"

}

assert "did not reach significance in every experiment" not in thomas["statement"]

assert {source["source_work"]["key"] for source in thomas["sources"]} == {

"work-thomas-2024"

}

def test_policy_views_share_dossier_sources_but_materially_differ() -> None:

catalog = PublicCatalog.build(ROOT)

featured = FeaturedDossier.load(ROOT)

encyclopedia = featured.envelope(catalog, "encyclopedia")

skeptical = featured.envelope(catalog, "skeptical")

assert encyclopedia["catalog_id"] == skeptical["catalog_id"]

assert encyclopedia["frontier"] == skeptical["frontier"]

assert encyclopedia["commit"] == skeptical["commit"]

assert encyclopedia["policies"] == skeptical["policies"]

assert encyclopedia["data"]["dossier"] == skeptical["data"]["dossier"]

assert encyclopedia["data"]["source_works"] == skeptical["data"]["source_works"]

assert encyclopedia["data"]["view"]["policy_id"] != skeptical["data"]["view"]["policy_id"]

assert encyclopedia["data"]["view"]["label"] != skeptical["data"]["view"]["label"]

assert [

item["relation"]["key"] for item in encyclopedia["data"]["featured_relations"]

] != [item["relation"]["key"] for item in skeptical["data"]["featured_relations"]]

skeptical_replication = next(

item

for item in skeptical["data"]["featured_relations"]

if item["relation"]["key"]

== "relation-ecker-2023-failed-replication-pluviano-2017"

)

assert "did not reproduce" in skeptical_replication["statement"]

assert (

skeptical_replication["statement"]

!= skeptical_replication["proposition"]["text"]

)

assert encyclopedia["content_digest"] != skeptical["content_digest"]

def test_scoreboard_ledger_is_complete_derived_and_source_identified() -> None:

featured = FeaturedDossier.load(ROOT)

projection = featured.projection("encyclopedia")

counts = projection["counts"]

ledger = projection["evidence_ledger"]

assert [item["key"] for item in ledger["apparent_support_assertions"]] == counts[

"apparent_support_assertion_keys"

]

assert [item["key"] for item in ledger["target_comparable_support_roots"]] == counts[

"target_comparable_support_data_root_keys"

]

assert [

item["key"] for item in ledger["target_comparable_unresolved_roots"]

] == counts["target_comparable_unresolved_data_root_keys"]

assert [item["key"] for item in ledger["counter_roots"]] == counts[

"counter_data_root_keys"

]

assert len(ledger["apparent_support_assertions"]) == 10

assert len(ledger["target_comparable_support_roots"]) == 4

assert len(ledger["target_comparable_unresolved_roots"]) == 1

assert len(ledger["counter_roots"]) == 12

for entries in ledger.values():

for entry in entries:

assert entry["source_works"]

assert all(work["title"] and work["canonical_uri"] for work in entry["source_works"])

def test_practical_reading_is_policy_relative_and_relation_source_closed() -> None:

featured = FeaturedDossier.load(ROOT)

readings = {}

for view in FEATURE_VIEWS:

projection = featured.projection(view)

relation_keys = [

item["relation"]["key"] for item in projection["featured_relations"]

]

reading = projection["practical_reading"]

assert reading["basis_relation_keys"] == relation_keys

assert "universal" in reading["qualifier"].lower()

assert all(item["sources"] for item in projection["featured_relations"])

readings[view] = reading["text"]

assert readings["encyclopedia"] != readings["skeptical"]

def test_share_card_is_deterministic_view_specific_and_identity_bound() -> None:

catalog = PublicCatalog.build(ROOT)

featured = FeaturedDossier.load(ROOT)

encyclopedia = featured.envelope(catalog, "encyclopedia")

skeptical = featured.envelope(catalog, "skeptical")

first = share_card_svg(encyclopedia, "https://epistemedia.org")

second = share_card_svg(encyclopedia, "https://epistemedia.org")

skeptical_card = share_card_svg(skeptical, "https://epistemedia.org")

assert first == second

assert first != skeptical_card

assert encyclopedia["data"]["title"] in first

assert encyclopedia["data"]["view"]["label"].replace("&", "&") in first

assert encyclopedia["data"]["dossier_id"] in first

assert encyclopedia["catalog_id"] in first

assert encyclopedia["frontier"] in first

assert encyclopedia["commit"] in first

assert "10" in first and "4 + 1?" in first and "12" in first

assert (

"https://epistemedia.org/how-we-know/corrections-and-familiarity-backfire/"

"encyclopedia/"

) in first

assert "<script" not in first

def test_static_html_markdown_and_json_preserve_one_view_identity(tmp_path: Path) -> None:

public = tmp_path / "public"

build_public(ROOT, public)

catalog = PublicCatalog.build(ROOT)

featured = FeaturedDossier.load(ROOT)

expected = featured.envelope(catalog, "encyclopedia")

case = public / "how-we-know" / SLUG

assert json.loads((case / "index.json").read_text()) == expected

assert json.loads((case / "encyclopedia" / "index.json").read_text()) == expected

markdown = (case / "index.md").read_text()

html = (case / "index.html").read_text()

home = (public / "index.html").read_text()

assert expected["data"]["dossier_id"] in markdown

assert expected["content_digest"] in markdown

assert expected["data"]["dossier_id"] in html

assert expected["content_digest"] in html

assert html.count("<h1>") == 1

assert html.count('<details class="source-xray">') == 6

assert '<nav class="policy-switch" aria-label="Evidence policy">' in html

assert 'aria-current="page"' in html

assert "<script" not in html

assert "source-xray" in html

assert 'href="#apparent-support"' in html

assert 'href="#supporting-roots"' in html

assert 'href="#counter-roots"' in html

assert 'id="unresolved-lineage"' in html

assert 'id="apparent-support"' in html

assert 'id="supporting-roots"' in html

assert 'id="counter-roots"' in html

assert html.count('class="ledger-entry-head"') == 27

assert html.count("<dt>") >= 5

assert "The Stranger Test asks how many apparently separate claims" in html

assert expected["data"]["practical_reading"]["text"] in html

assert "Share card" in html

assert "86 exact spans" in home

assert home.index("Does repeating misinformation") < home.index(

"Explore how the record is built"

)

assert (

f'href="https://epistemedia.org/how-we-know/{SLUG}/#unresolved-lineage"'

in home

)

skeptical_html = (case / "skeptical" / "index.html").read_text()

assert 'href="#apparent-support"' in skeptical_html

assert 'href="#supporting-roots"' in skeptical_html

assert 'href="#counter-roots"' in skeptical_html

assert f'href="https://epistemedia.org/how-we-know/{SLUG}/#apparent-support"' not in (

skeptical_html

)

def test_public_review_receipt_is_exact_sanitized_and_linked(tmp_path: Path) -> None:

public = tmp_path / "public"

build_public(ROOT, public)

featured = FeaturedDossier.load(ROOT)

expected = featured.review_envelope(PublicCatalog.build(ROOT))

review = public / "how-we-know" / SLUG / "review"

assert json.loads((review / "index.json").read_text()) == expected

html = (review / "index.html").read_text()

markdown = (review / "index.md").read_text()

home = (public / "index.html").read_text()

case = (public / "how-we-know" / SLUG / "index.html").read_text()

assert expected["data"]["review"]["reviewer_id"] in html

assert expected["data"]["review"]["reviewed_head"] in html

assert expected["data"]["review"]["receipt_sha256"] in html

assert "29 source receipts" in html

assert "86 span records" in html

assert "A separate Codex review agent worked from a fresh clone" in html

assert "independently retrieved the declared evidence" in html

assert "did not use the authoring agent's artifacts" in html

assert "did not decide whether the scientific conclusion is ultimately true" in html

assert "Technical reviewer ID" in html

assert "A separate Codex review agent worked from a fresh clone" in markdown

assert "Technical reviewer ID" in markdown

assert "another model family" not in (html + markdown).lower()

assert "human reviewer" not in (html + markdown).lower()

assert expected["data"]["review"]["fresh_clone"] is True

assert expected["data"]["review"]["independent_retrieval"] is True

assert expected["data"]["review"]["authoring_agent_artifacts_used"] is False

assert "Independence conditions" in markdown

assert "/private/tmp" not in html + markdown + (review / "index.json").read_text()

assert "Review receipt" in home

assert "Review receipt" in case

assert "Independently reviewed</span>" not in home

def test_editorial_pass_preserves_accepted_case_input_bytes() -> None:

expected = {

ROOT / "catalog" / "dossiers" / f"{SLUG}.json": (

"5c96dead036b527793ba5a0de59bf7316efdfeb591470d4a23e5bf979f3b9288"

),

ROOT

/ "research"

/ "how-we-know"

/ "corrections-backfire"

/ "candidate-dossier.json": (

"7003413e286e4d310f81441db33f4a467ba2eb3e08f41ddfa3cef5abb34707ca"

),

ROOT

/ "research"

/ "how-we-know"

/ "corrections-backfire"

/ "review-receipts"

/ "20260822T183134Z-codex-independent-reviewer.json": (

"503d16396b25b1c22d7fc10ac6fb7db2e530e6ce348d63fa8b639db5a5288f0a"

),

}

for path, digest in expected.items():

assert hashlib.sha256(path.read_bytes()).hexdigest() == digest

def test_cold_start_agent_discovers_and_summarizes_case_from_llms(tmp_path: Path) -> None:

public = tmp_path / "public"

build_public(ROOT, public)

llms = (public / "llms.txt").read_text()

links = dict(re.findall(r"^- \[([^]]+)\]\(([^)]+)\)$", llms, re.MULTILINE))

markdown_url = links["Featured evidence dossier"]

json_url = links["Featured dossier JSON"]

assert markdown_url.endswith(f"/how-we-know/{SLUG}/index.md")

assert json_url.endswith(f"/how-we-know/{SLUG}/index.json")

markdown_path = public / urlparse(markdown_url).path.lstrip("/")

json_path = public / urlparse(json_url).path.lstrip("/")

dossier = json.loads(json_path.read_text())["data"]

summary = {

"question": dossier["question"],

"verdict": dossier["view"]["label"],

"apparent": dossier["counts"]["apparent_support_assertion_count"],

"support_known": dossier["counts"]["target_comparable_support_data_root_count"],

"support_unresolved": dossier["counts"][

"target_comparable_unresolved_data_root_count"

],

"counter": dossier["counts"]["counter_data_root_count"],

"unresolved": dossier["unresolved_lineages"][0]["note"],

}

assert markdown_path.exists()

assert summary["question"].startswith("When a correction repeats a false claim")

assert (summary["apparent"], summary["support_known"], summary["support_unresolved"]) == (

10,

4,

1,

)

assert summary["counter"] == 12

assert "2007" in summary["unresolved"]

def test_release_identity_verifier_rejects_mixed_build(tmp_path: Path) -> None:

public = tmp_path / "public"

build_public(ROOT, public)

assert verify_release_identity(public) == []

home = public / "index.html"

catalog = json.loads((public / "catalog.json").read_text())

home.write_text(home.read_text().replace(catalog["commit"], "0" * 40, 1))

findings = verify_release_identity(public)

assert "mixed release identity in index.html: missing commit" in findings

assert "release manifest digest differs: index.html" in findings

def test_release_identity_verifier_recomputes_manifest_and_closes_inventory(

tmp_path: Path,

) -> None:

public = tmp_path / "public"

build_public(ROOT, public)

manifest_path = public / "manifest.json"

manifest = json.loads(manifest_path.read_text())

manifest["manifest_id"] = "em:release-manifest:sha256:" + "0" * 64

manifest_path.write_text(json.dumps(manifest))

assert "release manifest identity does not match its declared inventory" in (

verify_release_identity(public)

)

manifest["manifest_id"] = stable_id(

"release-manifest",

{

"catalog_id": manifest["catalog_id"],

"frontier": manifest["frontier"],

"commit": manifest["commit"],

"files": [(item["path"], item["sha256"]) for item in manifest["files"]],

},

)

manifest["files"][0]["bytes"] += 1

manifest_path.write_text(json.dumps(manifest))

assert any(

finding.startswith("release manifest byte count differs:")

for finding in verify_release_identity(public)

)

def test_api_mcp_cli_and_static_json_are_exactly_equivalent(

tmp_path: Path, capsys: pytest.CaptureFixture[str]

) -> None:

public = tmp_path / "public"

build_public(ROOT, public)

static = json.loads(

(public / "how-we-know" / SLUG / "skeptical" / "index.json").read_text()

)

gateway = Gateway(ROOT)

status, _, api = gateway.handle_api(

Request(

"GET",

f"/v1/dossiers/{SLUG}",

{"policy": ["skeptical"]},

{},

b"",

)

)

assert status == 200

assert api == static

tool = gateway.mcp_method(

"tools/call",

{

"name": "get_dossier",

"arguments": {"slug": SLUG, "policy": "skeptical"},

},

)

assert tool["structuredContent"] == static

resource = gateway.mcp_method(

"resources/read", {"uri": f"epistemedia://dossier/{SLUG}/skeptical"}

)

resource_envelope = json.loads(resource["contents"][0]["text"])

assert resource_envelope == static

assert main(["--root", str(ROOT), "dossier", SLUG, "--policy", "skeptical"]) == 0

cli = json.loads(capsys.readouterr().out)

assert cli == static

def test_dossier_byte_drift_fails_closed(tmp_path: Path) -> None:

manifest = json.loads(

(ROOT / "catalog" / "dossiers" / f"{SLUG}.json").read_text()

)

dossier_source = ROOT / manifest["dossier_path"]

receipt_source = ROOT / manifest["review_receipt_path"]

manifest_target = tmp_path / "catalog" / "dossiers" / f"{SLUG}.json"

dossier_target = tmp_path / manifest["dossier_path"]

receipt_target = tmp_path / manifest["review_receipt_path"]

for target in (manifest_target, dossier_target, receipt_target):

target.parent.mkdir(parents=True, exist_ok=True)

manifest_target.write_text(json.dumps(manifest))

dossier_target.write_bytes(dossier_source.read_bytes())

receipt_target.write_bytes(receipt_source.read_bytes())

altered = json.loads(dossier_target.read_text())

altered["title"] += " altered"

dossier_target.write_text(json.dumps(altered))

with pytest.raises(FeaturedDossierError):

FeaturedDossier.load(tmp_path)

def test_review_receipt_byte_drift_and_forged_independence_fail_closed(

tmp_path: Path,

) -> None:

manifest = json.loads(

(ROOT / "catalog" / "dossiers" / f"{SLUG}.json").read_text()

)

dossier_source = ROOT / manifest["dossier_path"]

receipt_source = ROOT / manifest["review_receipt_path"]

manifest_target = tmp_path / "catalog" / "dossiers" / f"{SLUG}.json"

dossier_target = tmp_path / manifest["dossier_path"]

receipt_target = tmp_path / manifest["review_receipt_path"]

for target in (manifest_target, dossier_target, receipt_target):

target.parent.mkdir(parents=True, exist_ok=True)

manifest_target.write_text(json.dumps(manifest))

dossier_target.write_bytes(dossier_source.read_bytes())

receipt_target.write_bytes(receipt_source.read_bytes())

forged = json.loads(receipt_target.read_text())

forged["reviewer"]["id"] = "forged-author-reviewer"

forged["reviewer"]["independent_retrieval"] = False

forged["reviewer"]["authoring_agent_artifacts_used"] = True

receipt_target.write_text(json.dumps(forged))

with pytest.raises(FeaturedDossierError):

FeaturedDossier.load(tmp_path)

manifest["review_receipt_sha256"] = hashlib.sha256(

receipt_target.read_bytes()

).hexdigest()

manifest["review_receipt_bytes"] = receipt_target.stat().st_size

manifest_target.write_text(json.dumps(manifest))

with pytest.raises(FeaturedDossierError):

FeaturedDossier.load(tmp_path)